C++ 如何专门化模板化运算符重载？

我试图将比较运算符重载为特定模板类

sub

的非成员，1）在

sub

的实例之间，2）在

sub

和特定变量之间，第一种情况返回

comparer\u sub

的实例，另一种情况返回

comparer\u el

，与其他一些有用的成员一起对

sub

执行比较：

template <typename T1, typename T2>
class sub_base {
public:
    sub_base() {};
};

template <typename T>
class mat {
    class sub : public sub_base<T,mat<T>> {
    public:
        sub(): sub_base<T,mat<T>>() {};
    };
public:
    int mb;
    sub getSub() {return sub();};
};

template <typename T1,typename T2>
class comparer_base {
public:
    comparer_base() {};
    void base_method() {};
};

template <typename lT1,typename lT2,typename rT1,typename rT2>
class comparer_sub :  public comparer_base<sub_base<lT1,lT2>,sub_base<rT1,rT2>> {
    using comparer_base<sub_base<lT1,lT2>,sub_base<rT1,rT2>>::base_method;
public:
    comparer_sub() : comparer_base<sub_base<lT1,lT2>,sub_base<rT1,rT2>>() {};
};

template <typename lT1,typename lT2,typename rT>
class comparer_el :  public comparer_base<sub_base<lT1,lT2>,rT> {
    using comparer_base<sub_base<lT1,lT2>,rT>::base_method;
public:
    comparer_el() : comparer_base<sub_base<lT1,lT2>,rT>() {};
};

template <typename lT1,typename lT2,typename rT1,typename rT2>
comparer_sub<lT1,lT2,rT1,rT2> operator== (const sub_base<lT1,lT2>& lhs, const sub_base<rT1,rT2>& rhs){
    printf("comparer_sub\n");
    return comparer_sub<lT1,lT2,rT1,rT2>();
};
template <typename lT1,typename lT2,typename rT>
comparer_el<lT1,lT2,rT> operator== (const sub_base<lT1,lT2>& lhs, const rT& rhs){
    printf("comparer_el\n");
    return comparer_el<lT1,lT2,rT>();
};

---

如何在

sub

实例之间强制第一个重载优先于第二个重载？

问题是，

comparer\el

与

rT=sub

相比，替换+从

sub

转换到

sub\u base

更好。演绎不会隐式强制转换（除了放置附加的c/v限定符）。。。要获得更好的描述，请阅读

因此，一种解决方案不是在

getSub（）

中使用返回类型

sub

，而是使用基类型

sub\u base

。看

重要部分：

template <typename T>
class mat {
    class sub : public sub_base<T,mat<T>> {
    public:
        sub(): sub_base<T,mat<T>>() {};
    };
public:
    int mb;
    sub_base<T,mat<T>> getSub() {return sub();};
 // ^^^^^^^^^^^^^^^^^^ return type changed from sub to sub_base<T,mat<T>>
};

模板
班垫{
子类：公共子类{
公众：
sub（）：sub_base（）{}；
};
公众：
int-mb；
sub_base getSub（）{return sub（）；}；
//^^^^^^^^^^^^^^^^^^^^^^^^^^^返回类型已从sub更改为sub_base
};

@user1810087我已经编辑了这个问题，需要对比较类型调用

getSub（）

。现在它是：）顺便说一句，我没有否决你的问题。。。计数器+1，因为问题很有趣…现在无法用好话来表达，但问题是，

comparer\u el

与第二个参数从

sub

替换为

typename rT2

是一个更好的选择，因为替换+从

sub

转换为

sub\u base

。替换不会隐式强制转换。。。因此，一种解决方案不是将返回类型

sub

与

getSub（）

一起使用，而是使用基类型

sub\u base

。另请参见，返回类型

sub_base

应优先选择，因为类

sub

是嵌套的，并且只在类mat中已知……公平地说，我想我已经理解了这个问题。我嵌套class

sub

的全部原因是为了简化语法并避免拖尾模板参数（实际的代码非常杂乱，很难“读取”），模板化的typedef在这种情况下可以工作吗？

template <typename T>
class mat {
    class sub : public sub_base<T,mat<T>> {
    public:
        sub(): sub_base<T,mat<T>>() {};
    };
public:
    int mb;
    sub_base<T,mat<T>> getSub() {return sub();};
 // ^^^^^^^^^^^^^^^^^^ return type changed from sub to sub_base<T,mat<T>>
};