Limitations of metaprogramming inheritance

I am using template metaprogramming in C ++ to generate a class hierarchy with a list of types like this:

//! 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 will create a class hierarchy:

Recur<Typelist<Type2,Typelist<Type3,NullType>>>

which comes from: Recur<Typelist<Type3,NullType>>

which comes from:

Recur<NullType> (base class)

      

        
        
        
      

    

Question: Is there any Visual Studio 2010 compiler that limits the depth of class derivation using this recursive technique? In other words, if my list of types contained N types, would the code above compile and build N classes, even if N is 100,000?