Design of a Wrapper Class in C++ - c++

Question

I have to work with an old class with a very clumsy interface. Since I cannot change it and am reliant to it, I want to build a wrapper, offering a clean interface. Let's say I have a class ClumsyClass. Basically, I have three approaches:
1. Reference Member
Class Wrapper {
public:
Wrapper (ClumsyClass& clumsyClass)
: m_clumsyClass(clumsyClass)
{ }
int getSmth() {
return m_clumsyClass.getSmth();
}
private:
ClumsyClass& m_clumsyClass;
}
2. Pointer Member
Class Wrapper {
public:
Wrapper (ClumsyClass* clumsyClass)
: m_clumsyClass(clumsyClass)
{ }
int getSmth() {
return m_clumsyClass->getSmth();
}
private:
ClumsyClass* m_clumsyClass;
}
3. Inheritance
Class Wrapper : public ClumsyClass {
...
}
Which approach is the "cleanest" way to implement a wrapper? I prefer the third one, but when I already have a ClumsyClass object and then create a Wrapper object (copy constructor), more memory will be needed (since an instance of the original class is necessary in my case).

Answer 1

I would avoid 3 as it fails to encapsulate ClumsyClass. Users of Wrapper can, intentionally or otherwise, directly access the "clumsy" interface of ClumsyClass which is what you are trying to avoid. Prefer composition over inheritance.
The differences between 1. and 2. are minor. Using a reference member makes the wrapper less flexible. The class is not assignable, you can't reseat the reference and replace it with a different instance of ClumsyClass and the member can't be null. These could be good or bad things depending on your requirements.
But as mentioned in comments, the default choice should probably be to have ClumsyClass as a by-value member of Wrapper:
class Wrapper {
public:
// possible constructors
//Wrapper(const ClumsyClass& cc) : m_clumsyClass(cc) {} // copy
//Wrapper(ClumsyClass&& cc) : m_clumsyClass(std::move(cc)) {} // move
int getSmth() { return m_clumsyClass.getSmth(); }
private:
ClumsyClass m_clumsyClass;
};
There are number of reasons why this might not be possible or desirable in your particular use case and then you can fall-back to option 1 or 2. The decision depends mostly on ownership. Should Wrapper "own" the ClumsyClass or does the instance of ClumsyClass have a lifetime outside that of Wrapper?
One potential downside of using a direct member is you can no-longer hide the implementation of ClumsyClass behind a forward declaration so you lose some of the encapsulation of ClumsyClass. It is worth noting that one way of solving this is to extract out an abstract base class "interface" that Wrapper inherits from. Something like:
class IWrapper {
public:
virtual ~IWrapper() {}
virtual int getSmth() = 0;
};
which might provide additional benefits like testability.

Answer 2

It seems from the constraints that you have mentioned that this could be a feasible approach:
Create an interface with the methods you like to have
struct IMyMethods
{
virtual int getOther() = 0;
...
virtual ~IMyMethods() {};
};
Now create a new class deriving from your class and the interface you want to use on the class where you add the implementation of the interface
class MyAgileClass : public ClumsyClass, IMyMethods
{
public:
MyAgileClass(/*same args as for ClumsyClass*/)
{}
~MyAgileClass()
{}
virtual int getOther()
{
return getSmth(); // clumsy class function
}
...
};
You can now either access the ClumsyClass directly or via the simplified interface