If template parameter AA is a templatized class A itself, is it possible to get the template parameter (T) of this templatized class?

Question

Consider the code below:

template <typename T>
class A{
...
}

template <class U>
class B{
...
}

int main {
B<A<int>> a;
...
}

How can I get the template parameter of A (int in this case) inside B, if A<int> is the template parameter for B? I could parametrize B as follows, but I feel like I am sending an unnecessary piece of information.

template <class AA, typename T>
class B { ... }

The reason I do not simply use template <typename T> for class B is that I have a pointer to class A inside B, and I want to use the template parameter class AA to see if that pointer is const or not, hence have the correct type for the member pointer in B.

You could partially specialize it like `template class B> { /* whatever */ };`. And there's no harm in your own solution either. Your question is too vague for a more concrete answer. — Tanveer Badar, Dec 15 '20 at 14:42
@TanveerBadar, thanks for the answer. class B is supposed to always have A as template parameter. It is T that is the real parameter (as well as constness of A). — KMot, Dec 15 '20 at 14:51
@Damien, Because I have 'A* X' or 'const A* X' depending on whether A is const or not. Assume that A is a very big class and I want to have a pointer to that inside B, but at the same time A might be const or not. I have asked another question for that here: https://stackoverflow.com/q/65286216/10755448 — KMot, Dec 15 '20 at 15:11
I don't see what it changes. You could have `template class B{ A *X; const A *Y; ...}; ... — Damien, Dec 15 '20 at 15:13
@Damien, Perhaps there is something that I do not know or understand here. But let me clarify. I have just X, it points to an A, that A might be const or not, so the type of X depends on the constness of A that it points to. Assume that B is created inside A, and inside A. — KMot, Dec 15 '20 at 15:32

score 1 · Answer 1 · answered Dec 15 '20 at 15:41

I think the following does what you want:

#include<type_traits>
template<class>
class A{};

template<class>
struct get_inner;

template<template<class> class TT, class T>
struct get_inner<TT<T>> {
    using outer = TT<T>;
    using inner = T;
};

template<class TT>
struct B {
    using A = TT;
    using inner = typename get_inner<std::decay_t<A>>::inner;
};


int main(int argc, char *argv[])
{
    static_assert(std::is_const_v<typename B<const A<int>>::A>);
        static_assert(!std::is_const_v<typename B<A<int>>::A>);
}

Note the std::decay_t, it wouldn't work with the const parameter directly (hence we cannot just specialize B in this way). Maybe decay_t is a bit strong but it works^^

score 1 · Answer 2 · answered Dec 15 '20 at 16:09

1

Try this

template <typename X> class B;

template <template <typename> class XX, typename T>
class B<XX<T>>
{
    // your implementation
};

B<A<int>> a;

answered Dec 15 '20 at 16:09

n. m. could be an AI

112,515
14
128
243

score 1 · Accepted Answer · answered Dec 15 '20 at 16:39

There are several ways, depending of that you might change:

Quick way, specialize B

template <class> class B;

template <class T>
class B<A<T>>
{
    // Use directly T
    //...
};

Add info in A directly (as std containers do with value_type)

template <typename T>
struct A
{
    using my_type = T;
};

// Then in `B<U>`, use `typename U::my_type`

Use external traits to extract information from A (as std::iterator_traits) (that also allows to handle built-in types):

template <typename T>
struct ATrait;

template <typename T>
struct ATrait<A<T>>
{
    using my_type = T;
};

// Possibly a generic one
template <template <typename> class C, typename T>
struct ATrait<C<T>>
{
    using my_type = T;
};

// Then in `B<U>`, use `typename ATrait<U>::my_type`

If template parameter AA is a templatized class A itself, is it possible to get the template parameter (T) of this templatized class?

3 Answers3