Konvertierung in Vorlage von Classes erben eine Basisklasse in Basis

Question

Ich habe Knoten, der eine Vorlage mit Linkliste ist. Ich möchte in meinem Restaurant-Projekt eine Liste von Artikel verwenden Knoten wie verknüpfte Liste mit Referenz-Zähler, spezielle erben trinken und essbar erstellen. Eine Bevrage und eßbare erben vom Gegenstand. Ich habe eine Speisekarte, die Gerichte enthalten alle diese drei Klassen und ich muss ändern oder hinzufügen Gericht mit meinem Manager. Ich bekomme ein Problem, weil ich die Klasse nicht von node<Item>* in die Basis konvertieren kann.

Ich möchte die Funktion addNewtItem();

#ifndef MENUE_H 
#define MENUE_H 
#include "Node.h" 

class Menue 
{ 
    public: 
     Menue(); 
     Node<Item>* _head; 

     void deleteItem(Node<Item>* item); 
     Node<Item>* getItem(int i); 

     void addNewtItem(Node<Item>& nextNode) {if(_head) _head->addNode(nextNode); else _head=nextNode;} 

     void printMenue(); 
     void deleteItem(int i); 

     ~Menue(); 

    protected: 

    private: 
}; 

#endif // MENUE_H 

Anruf von dieser Klasse

#ifndef MENEGER_H 
#define MENEGER_H 
#include "Node.h" 
#include "Waiter.h" 
#include "Menue.h" 
class Meneger: public Waiter 
{ 
    public: 

     Meneger(); 
     ~Meneger(); 
     void editItem (Node<Edible>&  newItem){ _myMenue->addNewtItem(newItem);} 
     void editItem (Node<Special>& newItem){ _myMenue->addNewtItem(newItem);} 
     void editItem (Node<Beverage>& newItem){ _myMenue->addNewtItem(newItem);} 
    protected: 

    private: 
     int _amountTable; 
     int _weiterId; 
     Table* _table; 
     Menue* _myMenue; 
}; 

#endif // MENEGER_H 

dies ist die Knotenklasse mit der Linkliste

Ich mag diese Funktion nutzen operator Node<newType>() aber die Umwandlung nicht

#ifndef NODE_H 
#define NODE_H 
#include "Item.h" 
#include "Edible.h" 
#include "Beverage.h" 
#include "Special.h" 

template <class T> 
class Node 
{ 
    public: 

     T* _item; 
     Node* _next; 
     int _refCount; 
     Node():_next(NULL),_refCount(0),_item(NULL){} 
     Node(T* item=0,Node<T>* next=0):_next(next),_item(item),_refCount(1){} 
     ~Node(){ if(_item)delete _item;_item=NULL;} 
     T& operator*(){return *_item;} 
     T* operator->(){return _item;} 
     void addRefCount() {_refCount++;} 
     void addNode(Node<T>* newItem); 
     int removeItem(){return --_refCount;} 
     template<class newType> // template function for 
     operator Node<newType>() // implicit conversion ops. 
     { 
      return Node<newType>(_item); 
     } 

    private: 
}; 


template <class T> 
inline void Node<T>::addNode(Node<T>* newItem) 
{ 
    if(newItem==NULL) 
     return; 
    newItem->_next=_next; 
    _next=newItem; 

} 



#endif // NODE_H 

funktioniert

Answer 1

Ich weiß nicht, ob es das Problem ist, nach dem Sie suchen, aber ... es ist ein Problem.

Blick auf die Methode Menue::addNewItem()

void addNewtItem(Node<Item>& nextNode) {if(_head) _head->addNode(nextNode); else _head=nextNode;} 

Ich weiß nicht, was ist ein Item aber _head ein Zeiger auf eine Node<Item> ist. Und Node::addNode() erhalten einen Node<T> (Node<Item>, in diesem Fall) Zeiger. Aber nextNode ist ein Verweis auf eine Node<Item>, kein Zeiger auf ein Node<Item>

Also, wenn Sie schreiben

_head->addNode(nextNode); 

Sie versuchen, eine Node<Item> ein Verfahren zu übergeben, die einen Zeiger zu einem erwarten Node<Item>; und wenn Sie schreiben

_head = nextNode; 

Sie versuchen, eine Node<Item> auf eine Variable vom Typ zuweisen Zeiger zu einem Node<Item>.

Ihre Absicht war

_head->addNode(&nextNode); 
_head = & nextNode; 

?