Hinzufügen einer Instanz zu einer verknüpften Liste mit einem Knoten

Question

Ich habe Probleme zu verstehen, wie ich die Add-Funktion in Main aufrufen würde, wenn ich eine Instanz zur Liste hinzufügen möchte.

#include "object.h" 
class list { 

private: 
struct Node 
{ 
object objectInfo; 
Node *next; 

}; 


int size; 
Node *head; 


public: 

list(); 
list(const list& otherlist); 
~list(); 

void Add(const Node myObject); 

mein Haupt

int main() { 
object myObject; 

myObject.setTitle("Object 1"); 
myObject.setPrice(78.58); 
myObject.setISBN("515161611"); 


cout << myObject << endl; 

list myList; 

myList.Add(myObject); 


return 0; 

} 

meine Funktion in cpp

void list::Add(const Node myObject) { 

Node* temp; 
temp = new Node; 
temp->objectInfo = myObject.objectInfo; 
temp->next = head; 


head = temp; 
size++; 

} 

Im mit Mühe auf dieser Linie myList.Add (myObject); hält sagen Leere Liste :: Add (const Liste &) ': kann nicht Argument 1 von konvertieren ‚Objekt‘ auf ‚const Liste :: Node‘

auch keine Instanz von überladenen Funktion ‚Liste :: Add‘ stimmt mit dem Argument Liste

Answer 1

Sie versuchen, ein Objekt vom Typ Objekt in eine Funktion übergeben, die einen Parameter vom Typ Node übernimmt. const Knoten myObject sollte const object myObject sein.

Answer 2

Dies könnte Ihnen ein paar Ideen:

#include <iostream> 
#include <string> 

template <typename Object> 
class List { 
    class Node : public Object { 
     //static int& count() { static int c=0; return c; } 
    public: 
     Node* next; 
     Node() : next(nullptr) { 
      //std::cout << ++count() << " Nodes\n"; 
     } 
     Node(const Object& obj) : next(nullptr), Object(obj) { 
      //std::cout << ++count() << " Nodes\n"; 
     } 
     ~Node() { 
      //std::cout << --count() << " Nodes\n"; 
     } 
    }; 

    Node *head, *tail; 
    int size; 

public: 
    class iterator { 
     Node *cur_node; 
    public: 
     iterator(Node* node) { cur_node = node; } 
     Object& operator *() const { return *cur_node; } 
     bool operator != (const iterator& iter) const { return iter.cur_node != cur_node; } 
     iterator& operator ++() { if(cur_node) cur_node = cur_node->next; return *this; } 
    }; 
    class iterator_const { 
     const Node *cur_node; 
    public: 
     iterator_const(const Node* node) { cur_node = node; } 
     const Object& operator *() const { return *cur_node; } 
     bool operator != (const iterator_const& iter) const { return iter.cur_node != cur_node; } 
     iterator_const& operator ++() { if(cur_node) cur_node = cur_node->next; return *this; } 
    }; 

    iterator  begin()  { return iterator(head); } 
    iterator  end()   { return iterator(nullptr); } 
    iterator_const begin() const { return iterator_const(head); } 
    iterator_const end() const { return iterator_const(nullptr); } 

    template <typename ...Args> 
    void Add(const Object& obj, Args...more) { 
     Node *new_node = new Node(obj); 
     ++size; 
     if(!tail) { tail = head = new_node; } 
     else  { tail->next = new_node; tail = new_node; } 
     Add(more...); 
    } 
    void Add() {} 

    int Size() const { return size; } 

    List() : head(nullptr), tail(nullptr), size(0) {} 
    List(const List& src) : head(nullptr), tail(nullptr), size(0) { 
     for(auto&& entry : src) { 
      Add(entry); 
     } 
    } 
    ~List() { 
     Node* p = head; 
     while(p) { 
      Node* next = p->next; 
      delete p; 
      p = next; 
     } 
    } 
}; 

struct MyObjectType { 
    std::string name; 
    int   age; 
    MyObjectType(std::string name, int age) : name(name), age(age) {} 
    friend std::ostream& operator << (std::ostream& os, const MyObjectType& obj) { 
     return os << "{\"" << obj.name << "\":" << obj.age << "}"; 
    } 
}; 

template <typename T> 
void PrintList(const List<T>& list) { 
    std::cout << "Size: " << list.Size() << "\n"; 
    for(const auto &elem : list) { 
     std::cout << " " << elem << "\n"; 
    } 
} 

int main() { 
    using MyList = List<MyObjectType>; 

    MyList list_one; 
    list_one.Add(
     MyObjectType("Harry",32), 
     MyObjectType("Lisa", 66), 
     MyObjectType("Buddy", 2), 
     MyObjectType("Skippy", 21) 
    ); 

    MyList list_two(list_one); 
    list_two.Add(
     MyObjectType("Horse", 10), 
     MyObjectType("Mule", 11) 
    ); 

    std::cout << "list_one:\n"; 
    PrintList(list_one); 
    std::cout << '\n'; 
    std::cout << "list_two:\n"; 
    PrintList(list_two); 
}