可以在模板参数中使用decltype吗？

Question

我试图重载一个乘法运算符，但不想输入多个重载函数来考虑整数与浮点、整数与双精度、浮点与整数的乘法等等。。。我希望编写一个重载运算符来解释所有带浮点数、整数和double的乘法组合，并得到正确的返回类型。我得到的错误是，没有找到接受“Widget:：Widget”类型的右操作数的运算符（或者没有可接受的转换）。我想这是因为我正在使用decltype来设置返回对象小部件的模板类型。如果返回不是模板对象，则使用尾部返回类型有效。

下面是一个重载运算符的示例：

template<typename T1, typename T2>
auto
operator*(const Widget<T1>& aWidge, const Widget<T2>& bWidge) -> Widget<decltype(aWidge.x*bWidge.x)>
{
    Widget<decltype(aWidge.x*bWidge.x)> result;

    //do stuff needed when multiplying two Widgets

    return result;
}

template<typename T>
Widget<T>& Widget<T>::operator=(const Widget<T>& aWidget)
{
    x = aWidget.x;

    return *this;
}

下面是模板类的一个例子

template<typename T> class Widget
{
    private:
        T x;
    public:
        Widget();
        ~Widget();
        void SetX(T value);
        Widget<T>& operator=(const Widget<T>& aWidget);
}

示例Main.cpp

int main()
{
    Widget<int> aWidge;
    Widget<float> bWidge;
    Widget<float> cWidge;

    aWidge.SetX(2);
    bWidge.SetX(2.0);

    cWidge = aWidge*bWidge; //this should give a float return type
}

Answer 1

视觉工作室2012

不要介意那些草率的代码。这是一个快速修复的代码，没有正确编译开始（不管自动decltype问题）。

template<typename T>
class Widget
{
public:
    T x;
public:
    Widget()
        : x(666)
    {}

    ~Widget() {}

    void SetX(T value)
    {
        x = value;
    }

    Widget<T>& operator=(const Widget<T>& aWidget)
    {
        x = aWidget.x;

        return *this;
    }
};


template<typename T1, typename T2>
auto operator*(const Widget<T1>& aWidge, const Widget<T2>& bWidge) -> Widget<typename std::remove_const<decltype(aWidge.x*bWidge.x)>::type>
{
    Widget<typename std::remove_const<decltype(aWidge.x*bWidge.x)>::type> result;

    result.x = aWidge.x * bWidge.x;

    return result;
}



int main ()
{
    Widget<int> aWidge;
    Widget<float> bWidge;
    Widget<float> cWidge;

    aWidge.SetX(2);
    bWidge.SetX(2.0);

    cWidge = aWidge*bWidge; //this should give a float return type
}

Answer 2

仔细阅读错误消息，问题很明显：

candidate template ignored: substitution failure [with T1 = int, T2 = float]: 'x' is
      a private member of 'Widget<int>'

非成员二进制运算符*试图在其声明（和定义）中访问私有成员x。由于您有一个setter函数，一个简单的解决方案是还定义一个getter，并且只通过该函数访问成员x：

template<typename T> class Widget
{
    private:
        T x;

    public:
        Widget() {}
        ~Widget() {}
        void SetX(T value) {}
        T& GetX() { return x; }
        const T& GetX() const { return x; }
        Widget<T>& operator=(const Widget<T>& aWidget);
};

template<typename T1, typename T2>
auto
operator*(const Widget<T1>& aWidge, const Widget<T2>& bWidge)
-> Widget<decltype(aWidge.GetX()*bWidge.GetX())>
{
    Widget<decltype(aWidge.GetX()*bWidge.GetX())> result;
    //...
    return result;
}

另一个选择是让操作员*成为朋友：

template<typename T> class Widget
{
    private:
        T x;

    template<typename T1, typename T2>
    friend auto
    operator*(const Widget<T1>& aWidge, const Widget<T2>& bWidge)
    -> Widget<decltype(aWidge.x*bWidge.x)>;

    public:
        Widget() {}
        ~Widget() {}
        void SetX(T value) {}
        Widget<T>& operator=(const Widget<T>& aWidget);
};

template<typename T1, typename T2>
auto
operator*(const Widget<T1>& aWidge, const Widget<T2>& bWidge)
-> Widget<decltype(aWidge.x*bWidge.x)>
{
    Widget<decltype(aWidge.x*bWidge.x)> result;

    return result;
}

或者，让它成为一个成员函数（感谢WhozCraig）。

你可能还需要

typename std::decay<decltype(aWidge.x*bWidge.x)>::type

而不仅仅是decltype（aWidge.x*bWidge.x）。

其他选择包括

typename std::decay<decltype(std::declval<T1>()*std::declval<T2>())>::type

完全绕过了前面的问题（感谢亚当），或者

typename std::common_type<T1, T2>::type

它应该适合这个目的，可以说是最简单的形式。