Question

I am using template metaprogramming in c++ to generate a hierarchy of classes from using a typelist like so:

//! Basic typelist class
template<class H, class T>
class Typelist
{
public:
    typedef H Head;
    typedef T Tail;
};

//! Terminating type
class NullType {};

//! Forward declaration
template<class Types>
class Recur;

//! Specialisation to terminate the recursion
template<>
class Recur<NullType>
{
};

//! General recursive class 
template<class Types>
class Recur: public Recur<typename Types::Tail>
{
};

// Dummy classes 
class Type1{};
class Type2{};
class Type3{};
int main()
{
    // Defines the typelist
    typedef Typelist<Type1,Typelist<Type2,Typelist<Type3,NullType>>> Types;

    // Instantiate the recursion
    Recur<Types> recur;
    return 1;
}

This would produce a class hierarchy like so:

Recur<Typelist<Type2,Typelist<Type3,NullType>>> which derives from:
Recur<Typelist<Type3,NullType>> which derives from:

Recur<NullType> (base class)

Question: Are there any Visual Studio 2010 compiler limits to the depth of class derivation using this recursive technique? In other words if my typelist contained N types would the code above compile and construct N classes even if N equals say 100,000?

Answer 1

Annex B of the Standard specifies only a minimum level of direct and indirect base classes and nested template instantiations, and it’s a quality of implementation issue whether a specific compiler goes beyond that. Consult your specific compilers own documentation for the precies numbers. Below follow the minimum quantities required by the Standard.

Annex B (informative)
Implementation quantities [implimits]

1 Because computers are finite, C++ implementations are inevitably
limited in the size of the programs they can successfully process.
Every implementation shall document those limitations where known.
This documentation may cite fixed limits where they exist, say how to
compute variable limits as a function of available resources, or say
that fixed limits do not exist or are unknown.

2 The limits may constrain quantities that include those described
below or others. The bracketed number following each quantity is
recommended as the minimum for that quantity. However, these
quantities are only guidelines and do not determine compliance.

— Direct and indirect base classes [16 384].

— Direct base classes for a single class [1 024].

— Recursively nested template instantiations, including substitution
during template argument deduction (14.8.2) [1 024].