C++ use alias template declaration in different classes - c++

Question

I got three template classes (Code in C++ Shell) and an alias template using AType = A<T1,T2> defined in A. I would like to use the alias across the files where objects of A are being used.
So in B instead of writing:
C<A<T1,T2>> c_object;
I'd rather like to be able to write something like:
C<typename AType> c_object;
using the alias declared in A.
// A.h
template<typename T1, typename T2>
class A{
A();
};
template<typename T1, typename T2>
using AType = A<T1,T2>;
// C.h
template<typename H>
// H = A<T1,T2>
class C{
C();
};
// B.h
#include "A.h"
template<typename T1, typename T2>
class B{
B();
// const C<A<T1,T2>>& GetC() const;
const C<typename AType>& GetC() const;
private:
C<typename AType> c_object;
};
Note the relations of the template parameters.
If B would only have one template parameter G like:
template<typename G>
class B{};
I could just do:
C<typename G::AType> c_object;
But since B actually has two, I can't figure out how that would work out. Or is entire problem usually solved in a different way?

Answer 1

You should instead add a using to B for your C type:
#include "A.h"
template<class T1, class T2>
struct B{
using C_type = A<T1, T2>;
B();
// const C_type& GetC() const;
const C_type& GetC() const;
private:
C_type c_object;
};
Or could inject A into the template arguments for B, which would let the caller optionally change it:
#include "A.h"
template<class T1, class T2, template<class, class> class C_T = A<T1, T2>>
struct B{
B();
// const C_T& GetC() const;
const C_T& GetC() const;
private:
C_T c_object;
}
You misunderstand what template aliases are for. They simply make referring to some other template easier; they don't implicitly bind template arguments to be passed on (T1 and T2 don't get implicitly passed to A in your OP; the template arguments to A must be specified).
You could simplify writing a C type templated for A using a template alias:
template<class T1, class T2>
using C_A = C<A<T1, T2>>;
And then you could use C_A<T1, T2> in B. This may be more flexible if you need a C templated on A in more than one location. However, what I wrote above may be preferable; this was only for demonstrated purposes.

Answer 2

The problem is that AType isn't a type; it's a template template type.
Your code compile if you write C as follows
template <template <typename...> class>
class C
{ C(); };
and pass AType in this way
template <typename T1, typename T2>
class B
{
B();
const C<AType>& GetC() const;
private:
C<AType> c_object;
};
but I don't understand what do you want to do with C and AType
-- EDIT --
Klaus say
In your posted code you write C<AType> c_objectwhich is invalid as using AType = A;`. I can't see the place where you put any type to aliased template AType. So your posted code makes no sense as T1 and T2 are unused.
My answer: I suppose that my posted code "makes no sense as T1 and T2 are unused", because I didn't understand the sense of the original code.
But you say my code "is invalid".
The following is my code that use C<AType> c_objectwhich and using AType = A<T1,T2>;. Please, say to me where is invalid and which error you get compiling it.
template <typename, typename>
class A { A(); };
template <typename T1, typename T2>
using AType = A<T1,T2>;
template <template <typename...> class>
class C { C (); };
template <typename, typename>
class B
{
B();
const C<AType> & GetC () const;
private:
C<AType> c_object;
};
int main()
{ }
template <typename, typename>
class A { A(); };
template <typename T1, typename T2>
using AType = A<T1,T2>;
template <template <typename...> class>
class C { C (); };
template <typename, typename>
class B
{
B();
const C<AType> & GetC () const;
private:
C<AType> c_object;
};
int main()
{ }