Accessing nested template parameters without template template arguments - c++

Question

I have this situation:
template<unsigned int N>
class Base
{
public:
Base(){}
int myint[N];
};
template<unsigned int M>
class BaseWrapper : Base<M>
{
public:
BaseWrapper(){}
};
template<typename T>
class User
{
public:
User(){}
//int myint[T::N]; //How to statically allocate using M or N from above?
};
int main(void)
{
User<BaseWrapper<10> > myuser;
// Do something with User::myint here.
}
I want to be able to use the non-type parameter of the template argument to User to statically allocate data in the User class. I know I can use template template parameters to create BaseWrapper<M> inside User but this is not my preferred approach. Any simple methods to do this?
Thanks!

Answer 1

Add static const unsigned int Size = N; to your class.
Example:
template<unsigned int N>
class Base
{
public:
Base(){}
int myint[N];
static const unsigned int Size = N;
};
Then N is accessible as T::Size in your User class.

Answer 2

Solution 1
Declare a const static member data as:
template<unsigned int M>
class BaseWrapper : Base<M>
{
public:
static const unsigned int size = M; //add this line!
BaseWrapper(){}
};
Then use this as T::size in User class:
template<typename T>
class User
{
public:
User(){}
int myint[T::size]; //you can do this!
};
Solution 2
Or if you cannot add size as member (for whatever reason), then you can use this approach as:
template<typename T> struct get;
template<unsigned int N>
struct get< BaseWrapper<N> > //partial specialization!
{
static const unsigned int size = N;
};
template<typename T>
class User
{
public:
User(){}
int myint[get<T>::size]; //get the size!
};

Answer 3

You can expose the template parameter as a static member variable of the class:
template<unsigned int M>
class BaseWrapper : Base<M>
{
public:
static const int counter = M;
BaseWrapper(){}
};
Then you can use this static member in your User class:
template<typename T>
class User
{
public:
User(){}
int myint[T::counter];
};

Answer 4

The simplest way, which already has been mentioned by the others, is to add a static member to Basewrapper which is initialized to N.
However if for some reason you cannot change User, there's also a way to get at N:
template<typename T> struct get_N;
template<unsigned int N> struct get_N<Basewrapper<N> > { unsigned int const value = N; };
Now in your User template you just can write get_N<T>::value.
One advantage of this is that you can adapt any type after the fact without touching its definition, so if you ever want to instantiate User on anything else than a Basewrapper, say on Newbasewrapper, you just add the line
template<unsigned int N> struct get_N<Newbasewrapper<N> > { unsigned int const value = N; };
or if Newbasewrapper takes some type as template argument and provides the value of N as static const member,
template<typename T> struct get_N<Basewrapper<T> > { unsigned int const value = Basewrapper<T>::N; };