Inheriting typedefs?

Question

I've been confused recently by a few code examples -- sometimes it seems that inheriting typedefs exposed by a base class works, and sometimes it seems that it doesn't.

My questions are

• Why doesn't it always work?
• What are the situations that it will / won't work?
• What are the good workarounds when it doesn't work?

Here's some specific code:

// First example: Inheriting `static const int ...`
// Basic TypeList object
template<typename... Ts>
struct TypeList {
    static const int size = sizeof...(Ts);
};

// Repeat metafunction
template<typename T>
struct repeat;

template<typename... Ts>
struct repeat<TypeList<Ts...>> : TypeList<Ts..., Ts...> {};

// Checks
typedef TypeList<int, float, char> MyList;

static_assert(MyList::size == 3, "D:");
static_assert(repeat<MyList>::size == 6, "D:");


// Second example: Inheriting typedefs
// Meta function to compute a bundle of types
template <typename T>
struct FuncPtrTypes {
    typedef int result_type;
    typedef T input_type;
    typedef result_type(*func_ptr_type)(input_type);
};


// template <typename T, typename FuncPtrTypes<T>::func_ptr_type me>
// struct FuncPtr : FuncPtrTypes<T> {
//     static result_type apply(input_type i) {
//         return me(i);
//     }
// };
//
// Doesn't compile (?): clang 3.6:
// main.cpp:34:9: error: unknown type name 'result_type'
//         static result_type apply(input_type i) {
//                ^
// main.cpp:34:27: error: unknown type name 'input_type'
//         static result_type apply(input_type i) {
//                                  ^
//
// g++ 4.8.4:
// main.cpp:34:9: error: ‘result_type’ does not name a type
//   static result_type apply(input_type i) {
//          ^
// main.cpp:34:9: note: (perhaps ‘typename FuncPtrTypes<T>::result_type’ was intended)


// This compiles but is clumsy:

template <typename T, typename FuncPtrTypes<T>::func_ptr_type me>
struct FuncPtr {
    typedef typename FuncPtrTypes<T>::input_type input_type;
    typedef typename FuncPtrTypes<T>::result_type result_type;

    static result_type apply(input_type i) {
        return me(i);
    }
};


// A non-template example:
struct foo {
    typedef int bar;
};

struct baz : foo {};

typedef baz::bar bazbar;
// ^ This compiles... huh??

int main() {}

Answer 1

We can simplify your failing example down to:

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


template <typename T>
struct Derived : Base<T>
{
    type mem; // error: 'type' does not name a type
};

The issue is that type here is a dependent name. It depends on T. There is no guarantee that for a given T there isn't some specialization of Base<T> which does not name type. As such, base templates of class templates are not part of the standard name lookup, so you have to qualify it:

Base<T>::type mem;

Although now we run afoul of the rule which indicates that dependent names are not assumed to be types unless explicitly states as such, so you need:

typename Base<T>::type mem;

None of the other cases presented in the OP rely upon unqualified lookup of a dependent name.

To return to the specific problem, this doesn't compile:

static result_type apply(input_type i) {

because result_type and input_type are dependent types and so must be qualified and prefixed with typename:

static typename FuncPtrTypes<T>::result_type apply(typename FuncPtrTypes<T>::input_type i) {

Or, if you prefer, you can simply bring both names in with a using-declaration:

 using typename FuncPtrTypes<T>::input_type;
 using typename FuncPtrTypes<T>::result_type;

 static result_type apply(input_type i) {

Answer 2

The code below will compile:

template <typename T, typename FuncPtrTypes<T>::func_ptr_type me>
 struct FuncPtr : FuncPtrTypes<T> {
     static typename FuncPtrTypes<T>::result_type apply(typename FuncPtrTypes<T>::input_type i) {
         return me(i);
     }
 };

The problem is basically that c++ templates have a two phased lookup during compilation. The first phase is a syntactical lookup, while the second phase performs the compilation in terms of the actual type.

To expand further:

The problem is that result_type might be either a global symbol or inherited, and during the first phase of lookup it is assumed that it is global, as the type that is dependent on T is not parsed/evaluated at that stage/phase of compilation.

See: where typenames are required

Another possible solution to your problem, is to use traits (e.g):

template <class T>
struct FuncPtrTraits
{
  typedef int result_type;
  typedef T input_type;
  typedef result_type(*func_ptr_type)(input_type);
};

 template <typename T, typename TraitsT = FuncPtrTraits<T> >
 struct FuncPtr
     static typename TraitsT::result_type apply(typename TraitsT::input_type i) {
         return me(i);
     }
 };

When designed correctly traits can help one modify code from the outside, and also partially, when you inherit from the base trait type.