Dynamically choosing a template parameter at runtime

[alan]

AFAIK a template parameter must be completely determinable by the
compiler at compile time, is this correct?

Currently my problem is, I have a class which contains a std::vector.
The size of this vector can be determined at the time an object of the
class is constructed, and is assured not to change over the lifetime
of the object.

Now this class is part of an intrusive memory pool management scheme,
and while it's okay for the std::vector to use standard allocations,
I'd prefer that the underlying array be part of the object, so that
the memory manager will handle the entire memory of that class,
instead of just (effectively) the pointer, size, and capacity.

//Generic is the intrusive memory pool
//management base class
class Closure : public Generic {
public:
....
Closure(size_t S) : dat(S) {}
std::vector<Generic*dat;
Generic*& operator[](size_t i){return dat[i]};
};

What I'd rather have:

class Closure : public Generic {
public:
....
virtual Generic*& operator[](size_t i)=0;
};

template<size_t S>
class ClosureA : public Closure{
public:
Generic* dat[S];
virtual Generic*& operator[](size_t i){return dat[i];};
};

However the size parameter must be determined at runtime, not compile
time:

// current use!
void do_something(Heap& h, size_t N){
Closure *s = new(h) Closure(N);
....
}

The best solution I could come up with is:

// fallback on vectors
class ClosureV : public Closure{
public:
ClosureV(size_t S) : dat(S){}
std::vector<Generic*dat;
virtual Generic*& operator[](size_t i){return dat[i];};
};

//factory function
Closure* NewClosure(Heap& h,size_t S){
switch(S){
case 0: return new(h) ClosureA<0>();
case 1: return new(h) ClosureA<1>();
case 2: return new(h) ClosureA<2>();
case 3: return new(h) ClosureA<3>();
case 4: return new(h) ClosureA<4>();
case 5: return new(h) ClosureA<5>();
case 6: return new(h) ClosureA<6>();
case 7: return new(h) ClosureA<7>();
case 8: return new(h) ClosureA<8>();
// give up; not likely to occur, but still might... :(
default: return new(h) ClosureV(S);
}
}

I'd like to ask if there's a better way?

[Leandro Melo]

On 24 jul, 03:15, alan <[e-mail]:

AFAIK a template parameter must be completely determinable by the
compiler at compile time, is this correct?

Yes, it's correct.

Currently my problem is, I have a class which contains a std::vector.
The size of this vector can be determined at the time an object of the
class is constructed, and is assured not to change over the lifetime
of the object.

Now this class is part of an intrusive memory pool management scheme,
and while it's okay for the std::vector to use standard allocations,
I'd prefer that the underlying array be part of the object, so that
the memory manager will handle the entire memory of that class,
instead of just (effectively) the pointer, size, and capacity.

//Generic is the intrusive memory pool
//management base class
class Closure : public Generic {
public:
* * * * ....
* * * * Closure(size_t S) : dat(S) {}
* * * * std::vector<Generic*dat;
* * * * Generic*& operator[](size_t i){return dat[i]};

};

What I'd rather have:

class Closure : public Generic {
public:
* * * * ....
* * * * virtual Generic*& operator[](size_t i)=0;

};

template<size_t S>
class ClosureA : public Closure{
public:
* * * * Generic* dat[S];
* * * * virtual Generic*& operator[](size_t i){return dat[i];};

};

However the size parameter must be determined at runtime, not compile
time:

// current use!
void do_something(Heap& h, size_t N){
* * * * *Closure *s = new(h) Closure(N);
* * * * *....

}

The best solution I could come up with is:

// fallback on vectors
class ClosureV : public Closure{
public:
* * * * ClosureV(size_t S) : dat(S){}
* * * * std::vector<Generic*dat;
* * * * virtual Generic*& operator[](size_t i){return dat[i];};

};

//factory function
Closure* NewClosure(Heap& h,size_t S){
* * * * switch(S){
* * * * case 0: return new(h) ClosureA<0>();
* * * * case 1: return new(h) ClosureA<1>();
* * * * case 2: return new(h) ClosureA<2>();
* * * * case 3: return new(h) ClosureA<3>();
* * * * case 4: return new(h) ClosureA<4>();
* * * * case 5: return new(h) ClosureA<5>();
* * * * case 6: return new(h) ClosureA<6>();
* * * * case 7: return new(h) ClosureA<7>();
* * * * case 8: return new(h) ClosureA<8>();
* * * * // give up; not likely to occur, but still might... :(
* * * * default: return new(h) ClosureV(S);
* * * * }

}

I'd like to ask if there's a better way?

Templates are compile-time mechanisms. On the other hand, virtual
stuff are run-time mechanisms. (That's why a template function cannot
be virtual.) I suggest you to write this classes using either
templates or virtuals, not mixing them. If you want to stick with the
dynamic world, std::vector is a choice, just as you did.

Keep in mind that with templates you can almost always achieve the
same functionality of dynamic polimorphism with techniques that allow
you to design static polimorphism. You loose the ability to create
heterogeneous collections (or similars), but there's usually some
workaround. However, there other benefits like, for example,
performance gains.

--
Leandro T. C. Melo

[Gianni Mariani]

On Jul 24, 5:15*pm, alan <[e-mail]:

AFAIK a template parameter must be completely determinable by the
compiler at compile time, is this correct?

Yes.

>
I'd like to ask if there's a better way?

That's a pretty good way and most likely just fine.

There is a way to use a generic factory pattern to do the same thing
but one can debate if it's worth the trouble. You will still need to
register all the sizes you care for.

[alan]

I'd like to ask if there's a better way?

>
That's a pretty good way and most likely just fine.

There is a way to use a generic factory pattern to do the same thing
but one can debate if it's worth the trouble. *You will still need to
register all the sizes you care for.

Err, I thought what I already did was a factory pattern?

Or is "generic factory pattern" something even more than what I just
did??

[alan]

On Jul 24, 7:41*pm, Leandro Melo <[e-mail]:

>

I'd like to ask if there's a better way?

Templates are compile-time mechanisms. On the other hand, virtual
stuff are run-time mechanisms. (That's why a template function cannot
be virtual.) I suggest you to write this classes using either
templates or virtuals, not mixing them. If you want to stick with the
dynamic world, std::vector is a choice, just as you did.

None of the virtual functions are templated. The template I'm using
is a size template, since I would like to make a class with a variable-
size array, which I'd prefer to be part of the class object.

And std::vector isn't so good a choice: it allocates using the default
allocator. I know it can use a different allocator, the problem is
that my memory manager is intrusive, so std::vector will have to
allocate a class that ultimately derives from Generic, my intrusive
class. But std::vector allocates a plain memory area, which my
intrusive memory manager cannot handle.

The main reason I'm mixing templates and virtuals is that I need my
class to be variable size, but still present the same interface, i.e.
the Closure interface.