opérateurs de comparaison de surcharge pour une classe templated

Question

Je vais avoir des problèmes dans la surcharge des opérateurs de comparaison afin de comparer deux pair struct de telle manière:

typedef pair<string, unsigned int> INDEX; 
bool operator>(INDEX &v1, INDEX &v2) 
{ 
    if(v1.second == v2.second) //if integer parts are equal 
    { 
     //string that comes earlier in the dictionary should be larger 
     return v1.first < v2.first; 
    } 
    return v1.second > v2.second; 
} 

La comparaison réelle a lieu à this->element(hole/2) < this->element(hole) l'intérieur fixUp(CBTNODE hole), une fonction membre de classe BinaryHeap, qui est une classe dérivée de CompleteBinaryTree. Le T sera instancié sous le type INDEX, qui correspond à typedef sous la forme pair<string, unsigned int>. En d'autres termes, la comparaison entre deux paires: ("a.txt", 42)> ("b.txt", 42) devrait renvoyer vrai.

J'ai essayé de surcharger operator> en dehors de la déclaration de classe de deux façons différentes, mais aucun d'entre eux travaillaient:

1. bool operator>(INDEX &v1, INDEX &v2);
2. bool operator>(BinaryHeap<T> &v1, BinaryHeap<T> &v2);

Toute aide sera très appréciée!

Z.Zen

Voici les déclarations:

typedef int CBTNODE; 

template <typename T> 
class CompleteBinaryTree { 
public: 
    //Initializes an empty binary tree 
    CompleteBinaryTree(int initialSize = 10); 

    //Destructor 
    ~CompleteBinaryTree(); 

    //Returns the element of the CBT pointed to by node. Behavior is undefined 
    //if node does not exist. 
    T element(CBTNODE node); 

protected: 
    T *data; 
    int numElts, maxElts; 
}; 

typedef pair<string, unsigned int> INDEX; 

template <typename T> 
class BinaryHeap : public CompleteBinaryTree<T> 
{ 
    public: 
     //Maintain heap property with bottom up heapify method. 
     void fixUp(CBTNODE hole); 
}; 
bool operator>(INDEX &v1, INDEX &v2); 

Mise en œuvre:

template <typename T> 
T CompleteBinaryTree<T>::element(CBTNODE node) { 
    assert(node >= 0); 
    assert(node < numElts); 
    return data[node]; 
} 

template <typename T> 
void BinaryHeap<T>::fixUp(CBTNODE hole) 
{ 
    T tmp = this->element(hole);  
    while(hole > 0 && this->element(hole/2) < tmp) 
    { 
     //do stuff 
    } 
} 

bool operator>(INDEX &v1, INDEX &v2) 
{ 
    if(v1.second == v2.second) //if two have same relevance 
    { 
     return v1.first < v2.first; 
    } 
    return v1.second > v2.second; 
} 

Answer 1

temporaire, comme le résultat de element func, ne peut pas être lié à une référence à non const, tels que les arguments formels de votre operator>.

Déclare thusly:

bool operator>(INDEX const& v1, INDEX const& v2) 

Cependant, la mise en œuvre que vous présentez ne semble pas être correct pour operator>.

Et pendant que je suis là, ce que vous voulez est vraiment operator< à la place, parce que c'est celui requis par les algorithmes standard. Peut-être combiné avec un operator== (parce qu'il est inefficace de le synthétiser à partir de operator<). Avec ces deux, toute relation peut être vérifiée relativement efficacement. Si vous arrêtez d'utiliser TOUS les noms de MAJUSCULES pour autre chose que des macros (voir la FAQ), vous pouvez éviter toute collision de nom par inadvertance avec les macros.

Vive & HTH,

Answer 2

Ne pas TypeDef INDEX, être explicite:.

template<class F, class S> 
struct Index { 
    std::pair<F, S> Value; 
    Index(const std::pair<F, S>& pValue) 
    : Value(pValue) {} 
}; 

template<class F, class S> 
bool operator<(const Index<F, S>& pLeft, const Index<F, S>& pRight) { 
    // your implementation... 
}