为不同的特征专门化相同的运算符

Question

我想通过特征专业化来完成以下工作。

Array Aa = Scalar in_a 会使用 overload I.
Array Aa = Array Bb 会使用 overload II.

在下面的代码中，overload II永远不会用到。

有人提到在overload II中无法推导出T1。

如何解决？

我使用 C++ shell 用 C++14 编译代码。

#include <iostream>
#include <type_traits>

using namespace std;
class A; // forward declaration.

template <typename T>
struct is_A : false_type {};
template <> struct is_A<A> : true_type {};

template <typename T>
struct is_int : false_type {};
template <> struct is_int<int> : true_type {};
template <> struct is_int<long> : true_type {};

class A{
    public:
        int val;
        void print(void){
            std::cout << val << std::endl;
        }
        template <typename T1>
        enable_if_t<is_int<T1>::value,void>
        operator=(const T1 & input){
            val = 2*input; //Overload I
        }
        template <typename T1>
        enable_if_t<is_A<T1>::value,void>
        operator=(const T1 & Bb){
            val = 5*Bb.val; //Overload II
        }
};

int main(void){
    A Aa;
    A Bb;
    int in_a = 3;
    Aa = in_a; //This uses overload I as intended.
    Bb = Aa; //I want this to use overload II, but
             //actually overload I is used.
             //This leads to an error during compilation.
    Aa.print(); //This should give 6. (3x2)
    Bb.print(); //This should give 30. (6x5)
}

Answer 1

您的代码应该是

template <typename T>
std::enable_if_t<is_int<T>::value, A&>
operator=(const T& input){
    val = 2 * input; //Overload I
    return *this;
}
template <typename T>
std::enable_if_t<is_A<T>::value, A&>
operator=(T& rhs){
    val = 5 * rhs.val; //Overload II
    return *this;
}

Demo

但你的情况更简单

A& operator=(int input){
    val = 2 * input; //Overload I
    return *this;
}

A& operator=(const A& rhs){
    val = 5 * rhs.val; //Overload II
    return *this;
}

Answer 2

这是您的代码，经过简化并按预期工作：

#include <iostream>
#include <type_traits>
#include<utility>

class A;

template <typename T>
struct is_A : std::false_type {};
template <> struct is_A<A> : std::true_type {};

template <typename T>
struct is_int : std::false_type {};
template <> struct is_int<int> : std::true_type {};
template <> struct is_int<long> : std::true_type {};

class A{
public:
    int val;

    void print(void){
        std::cout << val << std::endl;
    }

    template <typename T1>
    std::enable_if_t<is_int<std::decay_t<T1>>::value, void>
    operator=(T1 && input){
        val = 2*std::forward<T1>(input);
    }

    template <typename T1>
    std::enable_if_t<is_A<std::decay_t<T1>>::value,void>
    operator=(T1 && Bb){
        val = 5*std::forward<T1>(Bb).val;
    }
};

int main(void){
    A Aa;
    A Bb;
    int in_a = 3;
    Aa = in_a;
    Bb = Aa;
    Aa.print(); //This should give 6. (3x2)
    Bb.print(); //This should give 30. (6x5)
}

Answer 3

您的简单案例真的需要所有模板魔法吗？

#include <iostream>

class A;

class A{
public:
    int val;

    void print(void){
        std::cout << val << std::endl;
    }

    void operator =(const A& in){ val = in.val*5; }
    void operator =(int in) { val = in*2; }
};


int main(void){
    A Aa;
    A Bb;
    Aa = 3;
    Bb = Aa;
    Aa.print(); //This should give 6. (3x2)
    Bb.print(); //This should give 30. (6x5)
    return 0;
}

为不同的特征专门化相同的运算符

Specialize same operator for different traits

c++

typetraits

template-specialization

c++14