模板中默认类型的重载运算符答案

【问题标题】：Overloading operator for default type in template模板中默认类型的重载运算符
【发布时间】：2018-04-21 11:14:39
【问题描述】：

我怎样才能在模板类中为每个期望的类型重载运算符 - 例如 int 和 char。

    Point<char> operator+ (Point<char> const& sec){
        Point<char> tmp(x+2, y+3);
        return tmp;
    }


    Point<int> operator+ (Point<int> const& sec){
        Point<int> tmp(x+sec.x + 1, y+sec.y + 1);
        return tmp;
    }

    Point<T> operator+ (Point<T> const& sec){
        return Point<T>(x+sec.x, y+sec.y);
    }

这样的事情是行不通的。我可以为特定类型或 T 重载，但不能将两者结合起来。

【问题讨论】：

使用类指定

标签： c++ templates operator-overloading

【解决方案1】：

您可以在类之外显式特化，就像这样（最小示例）：

#include <iostream>

template<class T>
struct Point
{
    Point operator+(Point rhs)
    {
        std::cout << "Generic\n";
        return rhs;
    }
};

template<>
Point<char> Point<char>::operator+(Point<char> rhs)
{
    std::cout << "char\n";
    return rhs;
}

template<>
Point<int> Point<int>::operator+(Point<int> rhs)
{
    std::cout << "int\n";
    return rhs;
}


int main()
{
    Point<double> p;
    Point<int> i;
    Point<char> c;

    p + p;
    i + i;
    c + c;
}

Live on Coliru

【讨论】：

酷，+1，你甚至不需要在这里写template<>。
@Yola 谢谢！你确实需要，对吧？没有它就无法在我这边编译。
这取决于你的编译器版本。
@Yola gcc/clang 都需要它。也许在 Visual Studio 中（它有一些时髦的非标准扩展，并不总是 100% 符合标准）。

【解决方案2】：

您可以添加一个 if 语句，如

if(std::is_same<T, int>::value) {...}
else if(std::is_same<T, char>::value) {...}
else {...}

把这个写在Point operator+(){}的代码里。

我从来没有实现过这个，但我认为你可以让它工作。

我不知道是否可以按照您想要的方式重载运算符，但是您可以尝试一下。

【讨论】：

【解决方案3】：

要显式特化一个成员，您还需要将其周围的类模板也显式特化。在您的情况下，您可以使用朋友：

template <class T>
class Point {
public:
    Point(T x, T y) : x(x), y(y) {}

private:
    T x, y;

    friend Point<char> operator+ (Point<char> const& a, Point<char> const& b);
    friend Point<int> operator+ (Point<int> const& a, Point<int> const& b);
    template<class T>
    friend Point<T> operator+ (Point<T> const& a, Point<T> const& b);
    template<class T>
    friend Point<T*> operator+ (Point<T*> const& a, Point<T*> const& b);
};

Point<char> operator+ (Point<char> const& a, Point<char> const& b) {
    std::cout << "overload for char" << std::endl;
    return a;
}


Point<int> operator+ (Point<int> const& a, Point<int> const& b) {
    std::cout << "overload for int" << std::endl;
    return a;
}

template <class T>
Point<T> operator+ (Point<T> const& a, Point<T> const&) {
    std::cout << "overload for other non-pointers type" << std::endl;
    return a;
}

// you can even provide overload for pointers
template <class T>
Point<T*> operator+ (Point<T*> const& a, Point<T*> const&) {
    std::cout << "overload for pointers" << std::endl;
    return a;
}


int main() {

    Point<int> p1(1,1);
    p1 + p1;
    Point<char> p2(1, 1);
    p2 + p2;
    Point<long long> p3(1, 1);
    p3 + p3;

    int i[2];
    Point<int*> p4(i, i+1);
    p4 + p4;

    return 0;
}

int 重载
字符重载
其他非指针类型的重载
指针重载

【讨论】：