Vfrdtyky

Considering the following couple of classes:

template <typename T1, typename T2>

class A{ 

public:

    // ...

};



template<typename _T>

struct alias { typedef A<int,_T> intA; };



class B{

public:

    // ...

    template <typename _T> B& operator=(const typename alias<_T>::intA& _arg) { };

};

When I try to assign an object of class A<int,int> to an object of class B, I get the following compilation error:

template argument deduction/substitution failed: couldn't deduce template parameter ‘_T’


Is there an alternative way to use something of a typedef as the input argument to B::operator=()??

templated using might fix the issue

template <typename T1, typename T2>

class A{ 

public:

    // ...

};



template<typename _T>

using alias = A<int,_T>;



class B{

public:

    // ...

    template <typename _T> B& operator=(const alias<_T>& ) { return *this; };

};



void f()

{

    B b;

    A<int, int> a;

    b = a;

}

The problem is that intA is a dependant name. Templates cannot be deduced from dependant names. See for example: Dependent Types: Template argument deduction failed.

You are also missing the typename keyword.

You can either explicitly specify the type for the operator:

template <typename T1, typename T2>

struct A{ };



template<typename _T>

struct alias { typedef A<int,_T> intA; };



struct B 

{

    template <typename T> B& operator=(const typename alias<T>::intA& _arg) { };

};



int main() 

{

    A<int,int> a;

    B b;

    b.operator=<int>(a);

    return 0;

}

or you can have a specific, non-dependant-name parameter using a templated alias (with or without a function):

template <typename T1, typename T2>

struct A{ };



template<class T>

using alias_int = A<int, T>;



struct alias

{

    template<class T>

    using intA = A<int, T>;

};



struct B 

{

    template <typename T> B& operator=(const alias_int<T>& _arg) { };

};



struct C

{

    template <typename T> C& operator=(const alias::intA<T>& _arg) { };

};



int main() 

{

    A<int,int> a;

    B b;

    C c;

    b = a;

    c = a;

    return 0;

}

I'm getting a different error (using g++ 5.4):
need ‘typename’ before ‘alias<_T>::intA’ because ‘alias<_T>’ is a dependent scope
and true enough the following compiles for me:

template <typename T1, typename T2>

class A{ 

public:

    // ...

};



template<typename _T>

struct alias { typedef A<int,_T> intA; };



class B{

public:

    // ...

    template <typename _T> B& operator=(const typename alias<_T>::intA& _arg) { };

};

I think the reason is that alias<_T>::intA isn't an actual type but a templated typename.