C++ Art Vektor der Vorlage <char *, char *> Objekte

Question

Ich brauche diesen Code zu implementieren, so dass es funktioniert:

Pair<char*, char*> p1, p2, p3; 
vector<Pair<char*, char*> > v; 
cin >> p1 >> p2 >> p3; 
v.push_back(p1); 
v.push_back(p2); 
v.push_back(p3); 
sort(v.begin(), v.end()); 

for (it = v.begin(); it != v.end(); ++it){ 
    cout << *it << endl; 
} 

I Template-Klasse hergestellt, getestet alle Betreiber und alles funktioniert gut, aber jetzt habe ich Ich muss Spezialisierung für meine Klasse machen, damit der obere Code funktioniert. Hier ist, was ich getan habe:

template<typename T1, typename T2> 
class Pair 
{ 
T1 first; 
T2 second; 

public: 
    Pair(const T1& t1=0, const T2& t2=0) : first(t1), second(t2){} 
    Pair(const Pair<T1, T2>& other) : first(other.first), second(other.second){} 

    bool operator==(const Pair<T1, T2>& other) const{ 
     return first == other.first && second == other.second; 
    } 

    bool operator!=(const Pair<T1, T2>& other) const{ 
     return first != other.first && second != other.second; 
    } 

    bool operator<(const Pair<T1, T2>& other) const{ 
     return first < other.first && second < other.second; 
    } 

    bool operator<=(const Pair<T1, T2>& other) const{ 
     return first <= other.first && second <= other.second; 
    } 

    bool operator>(const Pair<T1, T2>& other) const{ 
     return first > other.first && second > other.second; 
    } 

    bool operator>=(const Pair<T1, T2>& other) const{ 
     return first >= other.first && second >= other.second; 
    } 

    Pair<T1, T2>& operator=(const Pair<T1, T2>& other){ 
     first=other.first; 
     second=other.second; 
     return *this; 
    } 

    friend ostream& operator<<(ostream& os, const Pair<T1, T2>& b){ 
     os << "Values: " << b.first << " " << b.second << endl; 
     return os ; 
    } 

    friend istream& operator>>(istream& is, Pair<T1, T2>& p){ 
     is >> p.first >> p.second; 
     return is; 
    } 

    friend void swap(Pair<T1, T2>& a, Pair<T1, T2>& b){ 
     Pair<T1, T2> t = a; 
     a = b; 
     b = t; 
    } 
}; 

Ich weiß, dass für die Spezialisierung muss ich Code separat schreiben, also tat ich dies:

template<> 
class Pair<char*, char*>{ 
char s1, s2; 
public: 
    Pair(const char t1='x', const char t2='y') : s1(t1), s2(t2){} 

    friend ostream& operator<<(ostream& os, const Pair<char*, char*>& b){ 
     os << "Values: " << b.s1 << " " << b.s2 << endl; 
     return os ; 
    } 

    friend istream& operator>>(istream& is, Pair<char*, char*>& p){ 
     is >> p.s1 >> p.s2; 
     return is; 
    } 

    friend void sort(){ 
     // ??? 
    } 
}; 

Betreiber < < und >> funktioniert gut, aber ich blieb auf Sortiere, weil ich keine Idee habe, wie man die Sortiermethode implementiert, so dass sie Buchstaben in dieser Spezialisierung für Vorlagenobjekte alphabetisch sortiert und sortiert. Google wird gegoogelt, aber nicht viel dort, also werden irgendwelche Hinweise oder Hilfe geschätzt ...

Answer 1

Ihre Spezialisierung stimmt nicht mit Ihrem allgemeinen Fall überein. Die template<T1, T2> class Pair; enthält ein Element vom Typ T1 und ein Element vom Typ T2.

Also, um konsistent zu sein, sollte template<char *, char *> class Pair; zwei char * enthalten (und zuordnen/freigeben, nehme ich an). Stattdessen enthält Ihre Spezialisierung zwei char. Sehr naiv.

Was waren Ihre Absichten? Crete ein Paar für char * (C-Stil Strings) oder ein Paar für einzelne char Zeichen?

So wie es ist, und wie von Bo Persson beobachtet, sind Sie relationale Operatoren (in der generischen Klasse) wirklich schlecht. Will auch ignorieren, dass (IMHO) ist besser relationale Operatoren als friend und nicht als Klassenmethoden zu entwickeln, ist es wichtig, dass, wenn Ergebnis wahr a == b, a != b Ergebnis falsch und umgekehrt. Ansonsten kann das std::sort() das Programm zum Absturz bringen.

Blick auf operator==() und operator!=() Implementierungen

bool operator==(const Pair<T1, T2>& other) const{ 
    return first == other.first && second == other.second; 
} 

bool operator!=(const Pair<T1, T2>& other) const{ 
    return first != other.first && second != other.second; 
} 

Betrachten wir den Fall first == other.first und second != other.second; Das Ergebnis ist, dass beide Bediener false zurückgibt. Das ist gefährlich; wirklich gefährlich.

Das gleiche Problem mit anderen relationalen Operator.

Betrachten Sie den Fall first < other.first und second > other.second; alle vier anderen Operatoren (<, <=, >, >=) zurück false.

Ich empfehle Ihnen dringend, den relationalen Operator in einer abhängigen Weise zu schreiben; so etwas wie

template <typename T1, typename T2> 
    bool operator== (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return (p1.first == p2.first) && (p1.second == p2.second); } 

template <typename T1, typename T2> 
    bool operator!= (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return ! (p1 == p2); } 

template <typename T1, typename T2> 
    bool operator< (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return (p1.first < p2.first) 
      || ((p1.first == p2.first) && (p1.second < p2.second)); } 

template <typename T1, typename T2> 
    bool operator<= (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return ! (p2 < p1); } 

template <typename T1, typename T2> 
    bool operator> (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return (p2 < p1); } 

template <typename T1, typename T2> 
    bool operator>= (const Pair<T1, T2> & p1, const Pair<T1, T2> & p2) 
    { return ! (p1 < p2); } 

Erinnerung friend in Klassen zu erklären, operator==() und operator<().

S.: Achtung, Beispielcode nicht getestet.

S.2: Entschuldigung für mein schlechtes Englisch.

Answer 2

Gefundene Lösung. Ich implementierte Betreiber < für die Spezialisierung, so dass es zwei Buchstaben vergleicht:

bool operator<(const Pair<char*, char*>& other) const{ 
    return s1 < other.s1; 
} 

diese Weise, die ich Sortiermethode standardmäßig für meinen Vektor verwenden kann:

sort(v.begin(), v.end()); 

ich dort kennen Fälle, in denen Buchstaben gleich sein können, aber ich kann es mit paar mehr wenns machen, die idee ist wichtiger. Danke allen für die Hilfe!