нет подходящей функции для вызова «Дерево <int> :: operator == (Дерево <int> * &, Дерево <int> * &) const '

Question

У меня есть эта общая реализация дерева, и я получаю эту ошибку, записывая рекурсивное сравнение дерева. В строке 89 я получаю эту ошибку: нет функции соответствия для вызова 'Tree :: оператор == (Дерево &, Дерево &) Const' Это мой код:

#include <iostream> 
#include <list> 

template<class T> class Tree { 
public: 
    Tree(); 
    Tree(const T& pNode); 
    virtual ~Tree(); 

    const T& getNode(); 
    void setNode(const T& pNode); 

    void addChild(Tree<T>* pChild); 
    const Tree<T>* getChild(int pIndex); 

    const std::list<Tree<T>*>* getChildren(); 
    void printTree(const Tree<T>* pTree, int pLevel); 

    bool operator==(const Tree<T>& other) const; 
private: 
    T node; 
    std::list<Tree<T>*>* children; 
}; 

template<class T> Tree<T>::Tree(const T& pNode) : 
     node(pNode), children(nullptr) { 
} 

template<class T> Tree<T>::Tree() : 
     node(T()), children(nullptr) { 
} 

template<class T> Tree<T>::~Tree() { 
    delete children; 
} 

template<class T> const T& Tree<T>::getNode() { 
    return this->node; 
} 

template<class T> void Tree<T>::setNode(const T& pNode) { 
    this->node = pNode; 
} 

template<class T> void Tree<T>::addChild(Tree<T>* pChild) { 
    if (this->children == nullptr) { 
     this->children = new std::list<Tree<T>*>(); 
    } 

    this->children->push_back(pChild); 
} 

template<class T> const Tree<T>* Tree<T>::getChild(int pIndex) { 
    if (true) { 
    } 

    return this->children[pIndex]; 
} 

template<class T> void Tree<T>::printTree(const Tree<T>* pTree, 
     int pLevel = 0) { 
    for (int i = 0; i < pLevel; i++) { 
     std::cout << " "; // Print 2 spaces for each level 
    } 

    std::cout << pTree->node << std::endl; 

    if (pTree->children != nullptr) { 
     for (typename std::list<Tree<T>*>::iterator i = 
       pTree->children->begin(); i != pTree->children->end(); i++) { 
      printTree(*i, pLevel + 1); 
     } 
    } 
} 

template<class T> const std::list<Tree<T>*>* Tree<T>::getChildren() { 
    return this->children; 
} 

template<class T> bool Tree<T>::operator==(const Tree<T>& other) const { 
    bool ret = false; 

    if (this->node == other.node) { 
     ret = true; 
     typename std::list<Tree<T>*>::iterator i, j; 
     for (i = this->children->begin(), j = other.children->begin(); 
       i != this->children->end() && j != other.children->end(); 
       i++, j++) { 
      ret = ret && (operator==(*i, *j)); // This is the line with the error 
     } 
    } 

    return ret; 
} 

int main(int argc, char **argv) { 
    Tree<int> a1(1), b1(2), c1(3); 
    Tree<int> a2(1), b2(2), c2(3); 

    a1.addChild(&b1); 
    a1.addChild(&c1); 

    a2.addChild(&b2); 
    a2.addChild(&c2); 

    bool ret = a1 == a2; 

    std::cout << ret << std::endl; 
    return 0; 
} 

Answer 1

итераторы в Tree* с, когда разыменованные возвращаются Tree* s.

Вы звоните Tree::operator==, или бесплатно operator==, на двух Tree* s, и такого не найдено (не удивительно). Если вы хотите сравнить деревья, вам нужно снова разыменовать. И используйте infix ==, пока вы на нем. Итак, **i==**j.

Вы должны сначала проверить на нуль - *i&&*j&&(**i==**j) - за исключением, может быть, вы хотите, чтобы два нуль-указателя сравнивались одинаково? (...)||(!*j&&!*i) Или как возможная оптимизация: (*i==*j)||(*i&&*j&&(**i==**j)), который также пропускает равенство, когда оба указателя одинаковы, и уменьшает ветви.

Альтернативно, если вы не хотите сравнивать Tree, но указатели, сделайте *i == *j.