c++ - 模板<char *，char *>对象的c++排序 vector

我需要实现此代码，以便它可以工作:

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;
}

我制作了模板类，测试了所有运算符，并且一切正常，但是现在我需要对我的类进行专门化处理，以便上层代码起作用。这是我所做的:

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;
    }
};

我知道为了特化，我需要单独编写代码，所以我这样做:

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(){
        // ???
    }
};

运算符<>可以正常工作，但是我坚持进行排序，因为我不知道如何实现排序方法，以便在模板对象的这种特化中它可以工作并按字母顺序对字母进行排序。谷歌搜索，但那里不多，所以任何提示或帮助将不胜感激...

最佳答案

您的专业与您的一般情况不一致。
template<T1, T2> class Pair;包含T1类型的成员和T2类型的成员。

因此，为了保持一致，template<char *, char *> class Pair;应该包含两个char *(我想应该分配/取消分配它)。相反，您的特化包含两个char。很天真。

你的意图是什么？为char *(C风格的字符串)提供一对，还是为一个char字符提供一对？

实际上，正如Bo Persson所观察到的，关系运算符(在通用类中)确实很糟糕。也要忽略(IMHO)更好地将关系运算符开发为friend而不是类方法，重要的是，如果结果为true a == b，a != b结果为false，反之亦然。否则，std::sort()可能会使程序崩溃。

查看operator==()和operator!=()实现

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;
}

考虑first == other.first和second != other.second的情况；结果是两个运算符都返回false。那很危险；真的很危险

与其他关系运算符相同的问题。

考虑first < other.first和second > other.second的情况；其他所有四个运算符(<，<=，>，>=)都返回false。

我强烈建议您以相互依赖的方式编写关系运算符。就像是

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); }

记得在类friend和operator==()中声明operator<()。

附注:请谨慎，示例代码未经测试。

第2页:对不起，我的英语不好。