2016-04-26 2 views
-3

Я использую шаблон, но у меня есть проблема с преобразованием съедобного или напитка в проект моего ресторана в элемент в шаблоне ?? кто-нибудь знает, как это сделать? напитка и съедобные являются унаследован от пункта или если кто-то есть идеи, чтобы улучшить свой Thnks проекта за любую помощьКак я использую умный указатель в шаблоне?

#ifndef NODE_H 
#define NODE_H 
#include "Item.h" 
#include "Edible.h" 
#include "Beverage.h" 
#include "Special.h" 
enum Type { special ,beverage, edible }; 
template <class T> 
class Node 
{ 
    public: 

     T* _item; 
     Node* _next; 
     int _refCount; 
     Node():_next(NULL),_refCount(0),_item(NULL){} 
     Node(T* item,Node<T>* next):_next(next),_item(item),_refCount(1){} 
     ~Node(){ if(_item)delete _item;_item=NULL;} 

     friend ostream& operator << (ostream& os,const Node<T>& node){ if(node._item)return os<<*node._item;else return os<<"";} 
     Node<T>* getNode(int i); 
     double getPrice()const {return _item->getPrice();} 
     void addRefCount() {_refCount++;} 
     void addNode(Node<T>* newItem); 
     void print(); 
     template<class newType> // template function for 
     operator Node<newType>() // implicit conversion ops. 
     { 
      return Node<It>(this); 
     } 
     int removeItem(){return --_refCount;} 
    private: 
}; 

template <class T> 
inline Node<T>* Node<T>::getNode(int i) 
{ 
    Node<T>* current=this; 
    for(i;i>0;i--) 
     current=current->_next; 
    return current; 
} 

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

} 
template <class T> 
inline void Node<T>::print() 
{ 
    Node<T>* head=this; 
    /*Print all item until we have null*/ 
    while(head!=NULL) 
    { 
     /*Check if there is any item inside*/ 
     if(head->_item!=NULL) 
      cout<<*head->_item<<endl; 
     head=head->_next; 
    } 
} 

#endif // NODE_H 

у меня есть проблемы с этой функцией: inline Node<T>* Node<T>::getNode(int i)

#include "Menue.h" 

Menue::Menue():_headEdible(NULL), _headBeverage(NULL),_headSpecial(NULL) 
{ 

} 

void Menue::printMenue() 
{ 

    _headEdible->print(); 
    _headBeverage->print(); 
    _headSpecial->print(); 

} 


void Menue::deleteItem(Node<Edible> *item) 
{ 
    if(item==NULL) 
     return; 
    if(!(item->removeItem())) 
    { 
     Node<Edible>* current; 
     current=_headEdible; 
     if(_headEdible==item) 
      _headEdible=_headEdible->_next; 
     else 
     { 
      while(current!=NULL&&item!=current->_next) 
       current=current->_next; 
      if(current==NULL) 
       return; 

      current->_next=current->_next->_next; 
     } 
     delete item; 
    } 
} 


void Menue::deleteItem(Node<Beverage>* item) 
{ 
    if(item==NULL) 
     return; 
    if(!(item-> removeItem())) 
    { 
     Node<Beverage>* current=_headBeverage; 
     if(_headBeverage==item) 
      _headBeverage=_headBeverage->_next; 
     else 
     { 
      while(current!=NULL&&item!=current->_next) 
       current=current->_next; 
      if(current==NULL) 
       return; 
      if(item!=current->_next) 
       return; 
      current->_next=current->_next->_next; 
     } 
     delete item; 
    } 
} 

void Menue::deleteItem(Node<Special>* item) 
{ 
    if(item==NULL) 
     return; 
    if(!(item-> removeItem())) 
    { 
     Node<Special>* current=_headSpecial; 
     if(_headSpecial==item) 
      _headSpecial=_headSpecial->_next; 
     else 
     { 
      while(current!=NULL&&item!=current->_next) 
       current=current->_next; 
      if(current==NULL) 
       return; 
      if(item!=current->_next) 
       return; 
      current->_next=current->_next->_next; 
     } 
     delete item; 
    } 
} 






Menue::~Menue() 
{ 
    while(_headEdible!=NULL) 
     if(!(_headEdible->removeItem())) 
     { 
      Node<Edible>* temp=_headEdible->_next; 
      delete _headEdible; 
      _headEdible=temp; 
     } 
    while(_headBeverage!=NULL) 
     if(!(_headBeverage->removeItem())) 
     { 
      Node<Beverage>* temp=_headBeverage->_next; 
      delete _headBeverage; 
      _headBeverage=temp; 
     } 
    while(_headSpecial!=NULL) 
     if(!(_headSpecial->removeItem())) 
     { 
      Node<Special>* temp=_headSpecial->_next; 
      delete _headSpecial; 
      _headSpecial=temp; 
     } 
} 
Node<Item>* Menue:: getItem(int i,Type type) 
{ 
    /*Switch the correct item we want to order*/ 
    switch (type) 
    { 
     case special:return _headEdible->getNode(i); 
     break; 

     case beverage:return _headBeverage->getNode(i); 
     break; 

     case edible:return _headSpecial->getNode(i); 
     break; 

     default: return NULL; 
     break; 
    } 

} 

это функция Node<Item>* Menue:: getItem(int i,Type type), которые используют его в manue , если кто-то знает, как это исправить ??

+0

Где в вашем примере вы используете _smart pointer_ на самом деле? –

+0

Я пытаюсь понять, с кем я могу вернуться с узла узла * i отправка наследуется bev или съедобная, но я не знаю, кто ее решить. Я хочу знать, может ли умный poiner решить ее ?? – Idan

+0

A Узел * '. Одна из многих проблем заключается в том, что вы пытаетесь вернуть 'Node *' как 'Node *', и вы не можете. Это разные вещи. Вам нужно переосмыслить реализацию связанного списка. – user4581301

ответ

0
Node<Item>* Menue:: getItem(int i,Type type) 

не может работать, потому что в то время как Beverage, Edible и Special могут быть sublasses из Item, Node<Item> отличается от Node<Beverage>. Node<Edible> - это специализация Node, а не подкласс Node<Item> и не может использоваться как Node<Item>.

К счастью, пользователю меню все равно, что в нем есть связанный список узлов. Все, что они хотят, это Item, и это может быть предусмотрено без обертки Node.

Item * Menue:: getItem(int i,Type type) 
{ 
    /*Switch the correct item we want to order*/ 
    switch (type) 
    { 
     case special:return _headEdible->getNode(i)->_item; 
     break; 

     case beverage:return _headBeverage->getNode(i)->_item; 
     break; 

     case edible:return _headSpecial->getNode(i)->_item; 
     break; 

     default: return NULL; 
     break; 
    } 
} 

Это устраняет непосредственную проблему, но не основной вопрос: OP действительно достаточно того, что они делают, чтобы написать программу такой сложности еще не понимает. Решение этой проблемы читается больше из учебника, и некоторые из проблем или работают с примерами, чтобы лучше понять наследование и указатели.

А затем они должны написать связанный список Node s (Node<T>::getNode, например, можно легко запустить за конец списка), полностью проверив его, прежде чем переходить к написанию логики, которая зависит от связанного списка. Попытка написать две части программы в то же время часто умножает количество ошибок в частях A и части B вместе, а не добавлять их для целей отладки времени.

+0

Я понимаю, но если я получу элемент, я нарушу идею общего указателя, который был основной идеей, чтобы начать все это. Мне нужна оболочка, чтобы знать, когда нужно удалить указатель. я думал использовать интеллектуальный указатель, потому что он может использовать такой шаблон, но все же я не знаю, как – Idan

+0

. В этом случае вы знаете индекс узла, поэтому вы можете написать свою функцию удаления, чтобы удалить узел по индексу.Вы также можете искать и удалять, но вы не можете смешивать указатели на «Узлы разных типов» без другого трюка. Сделайте класс 'BaseNode', на который наследуется ваш шаблонный« Узел ». Затем вы можете передать любой тип «Node» в качестве «BaseNode», но это, вероятно, слишком усложняет ситуацию. Во-первых, как вы знаете, какой из трех списков можно удалить из «BaseNode»? – user4581301

+0

есть счетчик, который подсчитывает количество использования, чтобы дать адинамическую возможность удалить adish из меню, но все же адрес узла находится внутри счетов, которые используют его, когда thay finsh необходимо удалить один из счетчика до тех пор, пока он не будет равен нулю, а затем удалите эта нода. я просто хочу понять, могу ли я использовать умный указатель, он может решить эту проблему или как я могу сделать это правильно? – Idan

Смежные вопросы