Re: Problem with inheritance and arbitrary "features" support (via
templates).
* KRao78:
On 12 Nov, 17:08, "Alf P. Steinbach" <al...@start.no> wrote:
* KRao78:
Example2:
class F {
public:
virtual double f( double x ) = 0;
};
class G {
public:
virtual double g( double x ) = 0;
};
class H {
public:
virtual double h( double x ) = 0;
};
class N {};
template<class T1, class T2=N, class T3=N>
class Feature : public T1 , public T2 , public T3
{
};
Again, please copy and paste *working* code.
It works with the compiler I am using at the moment (Visual Studio
Professional 2008).
Nope.
Moreover (at least to my understanding), it never inherits from the
same object more then once, as the specializations provided below are
used when only one or two template arguments are specified by the
user.
If the above is never instantiated as-is, then don't define N, don't use
defaults on the template parameters, and don't define the class. Like
template< class T1, class T2, class T3>
class Feature;
That's it.
[snip]
I think it is probably better to explain the specific numerical
problem at hand to clarify why I do need these classes.
This part of the library deals with the generations of samples (or
vector of samples) distributed according to some statistical
distribution.
Now, the way it usually works is that we have a random number
generator which only generates doubles from 0 and 1 from which, using
different algorithms, we obtain samples from arbitrary distributions.
Say I have some code that requires the generation of Exponential and
Gaussian samples.
Then, for the user, it makes perfect sense to be able to work with
objects of type
Rvg<Exponential,Gaussian>* rvgPtr (Rvg stands for Random Variate
Generator) and use it like:
double sample = rvgPtr->gaussian( mu , sigma ); //Where mu and sigma
are doubles
double sample2 = rvgPtr->exponential( mu );
Conceptually we are dealing with a specific random variate generator
(an aggregate of algorithms and one random number generator), so
separating the Gaussian and Exponential "features" is confusing.
Moreover, as in most applications there is the need to work with
multiple distributions, passing around lot of pointers is seriously
inconvenient. The previous version of the library did so and I am
rewriting it for a good reason.
It's unclear where you get all those pointers from.
Are you allocating random number generators dynamically?
To pass an object by reference, use a C++ reference, not a pointer.
Anyways, at the design level a random number generator is one thing, and a
distribution is another thing that *uses* an rng.
So that means something like
class RandomVariateGenerator
{
public:
virtual double next() = 0;
};
class Gaussian:
public RandomVariateGenerator
{
private:
Random myRng;
public:
double next() { ... }
};
It's as simple as that.
Although as I recall in C++0x the designers managed to mess up even something
this simple. They were thinking in mathematical terms, not in practical terms.
Sort of like hiring a chemist as a chef because she's awfully good with
chemistry, and hey, cooking involves chemistry, right?
Cheers & hth.,
- Alf