Множественное наследование

class Node {
 public: Node *prev, *next;
};
class Data {
 ...
};
class DataNode : public Data {
 private:
       Node DNum;
   ...
}
void main() {
  DataNode *p = &Data;
...}

class DataNode : public Data, public Node

class List {
private:
   Node * head;
public:
...
   void save(char* fname) {
      Node * node = head;
      while (node) {
         char* str = КАК ТУТ ПРОЧИТАТЬ СТРОКУ ИЗ DataNode???
      }
   }
};

class Node {
 
public:
    Node() : prev(nullptr), next(nullptr) {}
 
    virtual ~Node() {
        std::cout << "Node dtor" << std::endl;
    }
 
    void SetNext(Node *next) {
        this->next = next;
    }
 
    void SetPrev(Node *prev) {
        this->prev = prev;
    }
 
    Node *GetNext() const {
        return next;
    }
 
    Node *GetPrev() const {
        return prev;
    }
 
    virtual void Show() = 0;
 
private:
    Node *prev;
    Node *next;
 
};
 
 
template<class T>
class Data {
    T data;
public:
    void SetData(T data) {
        this->data = data;
    }
 
public:
    T GetData() const {
        return data;
    }
};
 
 
template<class T>
class DataNode : public Node, public Data<T> {
 
public:
    explicit DataNode(T data) {
 
        Data<T>::SetData(data);
    }
 
    void Show() override {
        std::cout << Data<T>::GetData() << " ";
    }
 
};
 
 
template<class T>
class List {
 
public:
 
    List() : head(nullptr) {}
 
    List<T> &operator=(const List<T> &other) = delete;
 
    List<T> &operator=(List<T> &&other) = delete;
 
    ~List() {
        Node *tmp;
        while (head) {
            tmp = head;
            head = head->GetNext();
            delete tmp;
        }
    }
 
 
    void InsertBegin(Node *newNode) {
 
        if (head == nullptr) {
            head = newNode;
        } else {
            newNode->SetNext(head);
            head->SetPrev(newNode);
            head = newNode;
        }
    }
 
    void Display() {
        Node *ptr = head;
        while (ptr) {
            ptr->Show();
            ptr = ptr->GetNext();
        }
    }
 
private:
    Node *head = nullptr;
};
 
int main() {
 
    List<int> int_list;
    for (int i = 0; i < 10; ++i) {
        int_list.InsertBegin(new DataNode(i));
    }
 
    int_list.Display();
 
    std::cout << std::endl;
 
    List<std::string> string_list;
    for (const std::string &s: {"We", "also", "take", "a", "look", "at", "functional"}) {
        string_list.InsertBegin(new DataNode(s));
    }
    string_list.Display();
 
    std::cout << std::endl;
 
}

class List {
 Node *GetHead() const {
        return head;
    }
 
  friend std::ostream &operator<<( std::ostream &output, const List &list ) {
        Node *ptr = list.GetHead();
        while (ptr) {
           ptr->Show();
            ptr = ptr->GetNext();
        }
        return output;
    }