Retrieve innermost template type within the template itself

Question

is it possible to retrieve the innermost type of stacked templates of the same type from within the template? I'd like to retrieve the double type in the following example:

template<typename T>
struct is_a : std::false_type {};

template<typename T>
struct A
{
    using type = std::conditional_t<
        is_a<T>::value,
        T::type, // if it's an A, go deeper
        T>;      // if not, we're done
};
template<typename T>
struct is_a<A<T>> : std::true_type {};

int main()
{
    A<A<A<A<A<double>>>>>::type d = 3.0;
    return 0;
}

It was motivated by this question. Also, I found this post, indicating that it may have something do to with typename or template keyword placing, but I couldn't get it to work myself.

Marco A. · Answer 1 · 2018-05-15T07:37:24.077

34

Unless I'm missing something I'd just partially specialize a template to make things easier

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

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

int main()
{
    A<double>::type a = 5.0;
    A<A<double>>::type d = 3.0;
    A<A<A<double>>>::type c = 9.5;
    return 0;
}

Live sample

edited May 15 '18 at 07:37

answered May 15 '18 at 07:17

Marco A.

43,032
26
132
246

1

Holy crap this is clever. Thanks! – Thomas B. May 15 '18 at 07:24
Wait, it doesn't seem to work if i only stack 2 A: `A>::type`? – Thomas B. May 15 '18 at 07:28
1

Yes this doesn't work for use case A>::type d = 3.0; – PapaDiHatti May 15 '18 at 07:30
1

What's the third specialization one for? Seems to work without – Thomas B. May 15 '18 at 07:36
@ThomasB. yes, the third one was test code leftover. Removed. – Marco A. May 15 '18 at 07:38
3

I think this is a good example of a procedurally minded approach vs a functionally minded approach. Using `conditional_t` (analogous to `if` and `else`) is a procedurally minded approach, while template specialisation is a functionally minded approach (analogous to pattern matching). It might be worth mentioning that inheriting from `A` might be worthwhile if there's more to the class than just a type alias. – Pharap May 15 '18 at 11:31

score 11 · Accepted Answer · answered May 15 '18 at 11:12

11

The usual trick to do it with your original approach is to defer evaluation:

template<class T> struct type_identity { using type = T; };

template<typename T>
struct A
{
    using type = typename std::conditional_t<
        is_a<T>::value,
        T,
        type_identity<T>>::type;
};

answered May 15 '18 at 11:12

T.C.

133,968
17
288
421

Gotta accept this one because it's closer to the original question. Now we have both approaches in here, this is a good thing – Thomas B. May 15 '18 at 12:11

score 3 · Answer 3 · answered May 15 '18 at 07:14

Besides your typo of missing a typename, the problem here:

using type = std::conditional_t<
    is_a<T>::value,
    T::type, // if it's an A, go deeper
    T>;      // if not, we're done

is that std::conditional is not short-circuit. When T doesn't have type member, this will cause an error.

You can write a meta function to recursively extract the inner type:

template<class T>
struct extract_type {
    using type = T;
};

template<class T> class A;

template<class T>
struct extract_type<A<T>> {
    using type = typename extract_type<T>::type;
};

template<typename T>
struct A
{
    using type = typename extract_type<T>::type;
};

int main()
{
    A<A<A<A<A<double>>>>>::type d = 3.0;
    return 0;
}

Jodocus · Answer 4 · 2018-05-15T07:33:29.100

1

You can use enable_if and SFINAE to select the innermost type like that:

template<typename T, class Enable = void>
struct A {
    using type = T;
};

template<typename T>
struct A<T, std::enable_if_t<!std::is_same_v<T, typename T::type>>> {
   using type = typename T::type;
};

edited May 15 '18 at 07:33

answered May 15 '18 at 07:18

Jodocus

7,493
1
29
45

score 1 · Answer 5 · answered May 15 '18 at 07:20

Alternative to Marco's (correct) answer. You may want to put some of this type-selection logic into a traits class:

// step 1 - predeclare the template A

template<typename T> struct A;

// define a default specialisation of a traits type
template<class T> struct ATraits
{
    using type = T;
};

// specialise the traits for the A<T> case
template<class T> struct ATraits<A<T>>
{
    using type = typename A<T>::type;
};

// now define the A template default specialisation
template<typename T>
struct A
{
    using type = typename ATraits<T>::type;
};

int main()
{
    A<A<A<A<A<double>>>>>::type d = 3.0;
    return 0;
}

Retrieve innermost template type within the template itself

5 Answers5