I have the following existing classes:

```
class Gaussian {
public:
  virtual Vector get_mean() = 0;
  virtual Matrix get_covariance() = 0;
  virtual double calculate_likelihood(Vector &data) = 0;
};

class Diagonal_Gaussian : public Gaussian {
public:
  virtual Vector get_mean();
  virtual Matrix get_covariance();
  virtual double calculate_likelihood(Vector &data);
private:
  Vector m_mean;
  Vector m_covariance;
};

class FullCov_Gaussian : public Gaussian {
public:
  virtual Vector get_mean();
  virtual Matrix get_covariance();
  virtual double calculate_likelihood(Vector &data);
private:
  Vector m_mean;
  Matrix m_covariance;
};

```

As you see, the class Gaussian acts as an interface but doesn't have any implementation. This is all working fine.

Now I want to make an class "AdaptedGaussian" where the data vector provided to the calculated\_likelihood will be changed before the likelihood is calculated.

Some requirements:

* The AdaptedGaussian must be a child-class of Gaussian
* AdaptedGaussian must be able to "wrap" or "be an instance of" every possible Gaussian class
* AdaptedGaussian must be constructed from an already existing Gaussian Object

The idea I have now is:

```
class Adapted_Gaussian : public Gaussian {
private:
  Gaussian* m_g;

public:
  virtual Vector get_mean() { return m_g->get_mean(); }
  virtual Matrix get_covariance() { return m_g->get_covariance(); }
  virtual double calculate_likelihood(Vector &data) 
  { 
    //do something with data
    return g->calculate_likelihood(Vector &data); 
  }
} 

```

There are maybe some disadvantages:

* For every method (and there are more than showed here) a dummy method must be written in the new class
* If Gaussian is ever extended, and this class would be forgotten, nasty bugs can appear.

Am I doing this in the right way? Or are there better methods to implement this?

Is there maybe a good way to standard delegate every non-implemented method to the same named method of m\_g?