Re: breaking template parameter dependence
On Nov 30, 10:43 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
er wrote:
I have a class D<INT> which serves a small implementation purpose
(think for example D<INT> is Factorial<INT>). I don't want every class
that uses D<INT> to 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?
So far, I have created
class Wrap: public B{ private: B& ref;} which is copyable/assignable
so I can put it in a vector. Usually I'd use a pointer rather than a
reference, but in this case, the reference is guaranteed to refer to
an object at all time (i think?)
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,
Thanks, I will try to clarify, now and in the future.
D<INT> can be thought of as Factorial<INT> (INT!). Although it's more
complicated, I would have the same problem if it were in fact
Factorial<INT>. The client of this class, say A, represents a sequence
of monomials (computed recursively via horner's rule) whose
coefficients are D<INT>.
Anyhow, my point is that I find it cumbersome to use template
parameters for every part of the code that needs a factorial
computation.
I don't want to define A<INT>, I want to define A::A(unsigned int
INT). The solution I propose is to save the results obtained at
compile time for D<0>....D<N> and return any of these values on demand
(hence Get). But I find the whole thing cumbersome, and I'm wondering
if there's a simpler alternative.
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<INT> is 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*>
The way that D is set up, I can only get a reference (B&) to a
singleton by calling D<INT>::instance(). You mean I should do B* p =
&D<INT>::instance()?
Anyhow my wrapper solution is similar to this.
(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