Is it possible to access a c++ template template constant parameter? - c++

Question

I want to do something like this:
template<template<int d, class>
class container,
int dim = d, typename content_data_type>
class MyClass {
};
My Compiler tells me that this is not possible because "d" is not defined outside of:
template<int d, class> class container
Is there maybe another way of doing this ?
Thanks in advance for any help on this topic.
UPDATE:
# Rook: i want to access the "dim" and "content_data_type" parameters later on in a specialization
e.g.
General class:
template<template<int d, class>
class container>
class MyClass {
};
Spec. class:
template<>
class MyClass<vec> {
vec c; // Error: vec needs template parameters
};
This gave me an error because i used my template class "vec" whitout template parameters, i expected the compiler to deduce the template parameters, e.g. when i use
MyClass<vec<3, float> >
then variable "c" should have the type
vec<3, float>
Because this didn't work, I thought i can create two excplicit template paramters "dim" and "content_data_type" which i can access in the specialization class like this:
template<template<int d, class t>
class container,
int dim = d, typename content_data_type = t>
class MyClass<vec> {
vec<dim, content_data_type> c;
};
... and sorry again for not being specific enough with the initial question :)

Answer 1

I don't think what you're doing makes sense, so the answer is "no".
The template parameter container is a class template, not a class. When MyClass is instantiated, its argument is the whole template, not just one instantiation of it. So it's not possible to default the dimension of MyClass to "the dimension of container", because container doesn't have values for its own template parameters. Your class MyClass can create and use one or more instantiations of container with different values of d, but it isn't given any one of them in particular, it's given the template.
By analogy, suppose you pass a pointer-to-function f as a parameter to a function g. You can't then use "the arguments passed to f" in the definition of g. The function g can call f one or more times with different arguments, but it isn't given any one call in particular, it's given the function.
From your update:
e.g. when i use MyClass<vec<3, float> >
You don't use MyClass<vec<3, float> >, there's no such thing. As I say, MyClass takes a template not a class. vec is a template, vec<3, float> is a class. It sounds like maybe you don't need a template as a template parameter at all.

Answer 2

normally the container would expose the dim member, so this would work:
template< template< int, class> class container, int dim, class content_data_type >
class MyClass
{
public:
typedef typename container< dim, content_data_type > container_type;
static const int dim = container_type::dim;
};
template< int d, class >
class acontainer
{
public:
static const int dim = d;
};
MyClass< acontainer, 2, sometype > x;
std::cout << "container size " << x.dim << std::endl;

Answer 3

Below is a workaround, you have to define the two arguments as a type and a static exposed by the container class though (see for example boost::array)
#include <iostream>
template <int d, class T>
struct container
{
typedef T value_type;
static const int static_size = d;
};
template<typename cont, int d = cont::static_size, class T = typename cont::value_type>
struct A
{
static const int dimension = d;
};
int main(void)
{
A<container<10, int> > a;
std::cout << a.dimension << std::endl;
}