클래스에서 템플릿의 변환은 기본 클래스를 기본으로 상속합니다.

링크 목록이있는 템플릿 노드가 있습니다. 내 레스토랑 프로젝트에서 참조 카운터, 특별 상속 음료 및 식용이있는 연결 목록과 같은 항목 사용 노드 목록을 만들고 싶습니다. bevrage와 식용은 항목에서 상속됩니다. 이 세 가지 클래스가 모두 포함 된 요리가있는 메뉴가 있는데 매니저와 함께 요리를 변경하거나 추가해야합니다. 클래스를 .NET에서베이스로 변환 할 수 없기 때문에 문제가 발생 node<Item>*합니다.

기능을 사용하고 싶습니다 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

이 수업에서 전화

#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

링크 목록이있는 노드 클래스입니다.

이 기능을 사용하고 싶지만 operator Node<newType>()변환이되지 않습니다.

#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