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

我制作了模板类，测试了所有操作符，一切正常，但是现在我需要为我的类进行专门化，以便上层代码可以工作。这是我做的：

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

运营商＆lt;＆lt;和＆gt;＆gt;工作正常，但我坚持排序因为我不知道如何实现排序方法，以便它的工作原理和字母顺序排序模板对象的专业化字母。谷歌搜索，但没有多少，所以任何提示或帮助将不胜感激...

Answer 1

找到解决方案。我实现了运营商＆lt;对于专业化，所以它比较2个字母：

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

这样我默认可以为我的vector使用sort方法：

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

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

Answer 2

您的专业化与您的一般情况不一致。

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

所以，为了保持一致，template<char *, char *> class Pair;应该包含两个char *（并且我认为分配/解除分配它）。相反，您的专业化包含两个char。非常天真。

你的意图是什么？克里特为char *（C风格的字符串）或一对char字符配对？

实际上，正如Bo Persson所观察到的，关系运算符（在泛型类中）非常糟糕。同样想要忽略（恕我直言）更好地将关系运算符发展为friend而不是类方法，如果结果为真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;结果是两个运算符都返回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<()。

p.s：谨慎，未测试示例代码。

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

c ++模板<char ，char =“”>对象的排序向量

2 个答案:

c ++模板<char *，char * =“”>对象的排序向量

2 个答案:

c ++模板<char ，char =“”>对象的排序向量