breaking template parameter dependence

[er]

Hi All,

I have a class D<INTwhich serves a small implementation purpose
(think for example D<INTis Factorial<INT>). I don't want every class
that uses D<INTto depend on template parameter INT. However I know
that I won't need more than say INT=5. So I do 2 things:
a) have D derive from a base class B (see below)
b) have a class Get with a member B& instance_of_B(unsigned int INT)
(see below). However I can't put references to B into an vector
because D<INTis a singleton (non-copyable/assignable). do I have to
go through the trouble of creating a (copyable) wrapper around each
D<INT>& or is there an easier way (based on the code below)?
class B;//abstract class defining an interface

template<unsigned int INT>
class D: public B{
public:
static B& instance(){static D singleton; return singleton;}
};

class Get{
public:
Get()
:r0(D<0>::instance())
,r1(D<1>::instance())
,r2(D<2>::instance())
,r3(D<3>::instance())
,r4(D<4>::instance())
,r5(D<5>::instance()){
/* whatever else needed */
};
static B& instance_of_B(unsigned int i){
// intended behaviour:
// instance_of_B(0) returns r0
// instance_of_B(1) returns r1
// instance_of_B(2) returns r2
// instance_of_B(3) returns r3
// instance_of_B(4) returns r4
// instance_of_B(5) returns r5

};
private:
B& r0;
B& r1;
B& r2;
B& r3;
B& r4;
B& r5;
};

[Victor Bazarov]

er wrote:

I have a class D<INTwhich serves a small implementation purpose
(think for example D<INTis Factorial<INT>). I don't want every class
that uses D<INTto depend on template parameter INT. However I know
that I won't need more than say INT=5. So I do 2 things:
a) have D derive from a base class B (see below)
b) have a class Get with a member B& instance_of_B(unsigned int INT)
(see below). However I can't put references to B into an vector

You can't put references to anything in a vector. You can, however,
put _pointers_ to your objects in a vector, because while your D<>
are singletons, pointers to it can be multiplied at will. So can
pointers to B, which still provide polymorphism, don't they?

In the future, will you please specify how your class is going to be
used? You give some abstract representation of some idea you have,
and it's supposed to serve some concrete purpose (otherwise why do
you create it?) and then we need to imagine what purpose you have
in mind. We are not mind readers, you know.

The suitability of any particular design is verified against the
problem it solves, not against another similar solution.

because D<INTis a singleton (non-copyable/assignable). do I have to
go through the trouble of creating a (copyable) wrapper around each
D<INT>& or is there an easier way (based on the code below)?

What's wrong with

vector<B*>

(considering your definition of 'B', of course)?

>

class B;//abstract class defining an interface

template<unsigned int INT>
class D: public B{
public:
static B& instance(){static D singleton; return singleton;}
};

class Get{
public:
Get()
:r0(D<0>::instance())
,r1(D<1>::instance())
,r2(D<2>::instance())
,r3(D<3>::instance())
,r4(D<4>::instance())
,r5(D<5>::instance()){
/* whatever else needed */
};
static B& instance_of_B(unsigned int i){
// intended behaviour:
// instance_of_B(0) returns r0
// instance_of_B(1) returns r1
// instance_of_B(2) returns r2
// instance_of_B(3) returns r3
// instance_of_B(4) returns r4
// instance_of_B(5) returns r5

};
private:
B& r0;
B& r1;
B& r2;
B& r3;
B& r4;
B& r5;
};

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask