如何使模板化运算符推导出正确的返回类型？

Question

Say I want two orthogonal types A and B so that I can write

A a = b1 * b2; // b1,b2 of type B
B b = a1 * a2; // a1,a2 of type A

The data they share is the same, so I attempted some policy-based design. Some code :

#include <type_traits>

struct isA {};
struct isB {};

template<typename T>
struct myClass
{
    int _data;

    template<typename U>
    myClass<U> operator * ( const myClass<T>& other );
};

template<typename T>
template<typename U>
myClass<U> myClass<T>::operator * ( const myClass<T>& other )
{
    // just an idea, will not be needed if correct instanciation
    static_assert( std::is_same<U,T>::value, "cannot return same type" );
   // ... here, some code
}


int main()
{
    myClass<isA> a1,a2;
    myClass<isB> b = a1 * a2;
}

This fails with:

main.cpp: In function 'int main()':
main.cpp:26:25: error: no match for 'operator*' (operand types are
'myClass<isA>' and 'myClass<isA>')
    myClass<isB> b = a1 * a2;
main.cpp:12:16: note: candidate: 'template<class U> myClass<U> myClass<T>::operator*(const myClass<T>&) [with U = U; T = isA]'
  myClass<U> operator * ( const myClass<T>& other );
 main.cpp:12:16: note:   template argument deduction/substitution failed:
 main.cpp:26:27: note:   couldn't deduce template parameter 'U'

What I understand is that it fails because its only the function arguments that are used by the compiler to generate the instanciation, not the return type. Thus the compiler cannot generate the correct instanciation for the operator.

My question (pretty simple): how can I implement this operator ?

There is no template specialization required here, the behavior is the same with the two types (but other functions - not shown here - will have a specific implementation for each of the types). But I want to enforce the fact that that you cannot do: A a = a1 * a2;

Side note: couldn't find any question with this topic, if you find one, please link!

Answer 1

You can implement it as two (non-template) free functions. If the implementation is exactly the same, these can specify the return type for a shared implementation.

namespace detail
{
    template<typename Out, typename In>
    MyClass<Out> times( const MyClass<In> & lhs, const MyClass<In> & rhs)
    {
        // shared code here
    }
}

myClass<isA> operator * ( const myClass<isB>& lhs, const myClass<isB>& rhs )
{ return detail::times<isA>(lhs, rhs); }

myClass<isB> operator * ( const myClass<isA>& lhs, const myClass<isA>& rhs )
{ return detail::times<isB>(lhs, rhs); }

Answer 2

You can create a trait that maps isA to isB , and isB to isA .

namespace detail
{
    template<typename>
    struct myClassTraits;

    template<>
    struct myClassTraits<isA>
    {
        using other_type = isB;
    };

    template<>
    struct myClassTraits<isB>
    {
        using other_type = isA;
    };
}

template<typename T>
struct myClass
{
    int _data;

    using times_t = myClass<typename detail::myClassTraits<T>::other_type>;

    times_t operator * ( const myClass& other );
};

Answer 3

Unfortunately C++ doesn't use return type to deduce template parameters (some other languages can do it), so you can do nothing with the template.

However to make

A a = b1 * b2; // b1,b2 of type B

working you may implement implicit conversion constructor so that first you'll get type B as a result of multiplication operator and then it will be cast to A type:

template <typename U>
myClass(const myClass<U>& other)  {} // copy conversion constructor
template <typename U>
myClass(myClass<U>&& other)  {} // move conversion constructor

so that

A a = b1 * b2;

will be equivalent to

A a = A(b1 * b2);