c++ 模板 <char, char> 对象的排序向量

Question

我需要实现此代码才能正常工作：

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

我制作了模板 class，测试了所有运算符并且一切正常，但现在我需要对我的 class 进行专门化，以便上面的代码能够正常工作。这是我所做的：

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

运算符 << 和 >> 工作正常，但我坚持排序，因为我不知道如何实现排序方法，以便它在模板对象的这个专业化中工作并按字母顺序排序字母。用谷歌搜索，但内容不多，因此我们将不胜感激任何提示或帮助...

Answer 1

找到解决方案。我实现了 operator< 用于专业化，所以它比较 2 个字母：

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

这样我就可以为我的向量默认使用排序方法：

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

我知道有些情况下字母可以相等，但我可以用更多的if来做到这一点，想法更重要。谢谢大家的帮助！

Answer 2

你的专业与你的一般情况不一致。

template<T1, T2> class Pair; 包含一个 T1 类型的成员和一个 T2 类型的成员。

因此，为了保持一致，template<char *, char *> class Pair; 应该包含两个 char *（我想 allocate/deallocate 它）。相反，您的专业化包含两个 char。很天真。

你的意图是什么？ Crete 一对 char *（C 风格字符串）或一对单个 char 字符？

实际上，正如 Bo Persson 所观察到的，你们这些关系运算符（在通用 class 中）真的很糟糕。还想忽略（恕我直言）最好将关系运算符开发为 friend 而不是 class 方法，重要的是如果结果为真 a == b，a != b 结果为假，反之亦然。否则，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 的情况；结果是两个运算符 returns false。那很危险；真的很危险。

其他关系运算符也有同样的问题。

考虑 first < other.first 和 second > other.second 的情况；所有其他四个运算符（<、<=、>、>=）return 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); }

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

p.s.: 注意，示例代码未测试。

p.s.2: 抱歉我的英语不好。

c++ 模板 <char, char> 对象的排序向量

c++ sort vector of template <char, char> objects

c++

sorting

templates

template-specialization

c++ 模板 <char*, char*> 对象的排序向量

c++ sort vector of template <char*, char*> objects

c++

sorting

templates

template-specialization

c++ 模板 <char, char> 对象的排序向量

c++ sort vector of template <char, char> objects