OOP - Store objects and serve interfaces - c++

Question

I'm currently working on a C++ project, I'm dealing with a home-made class CSound and handling its instances with a CSoundEngine, which allow myself to create a CSound (stored in my CSoundEngine) and return a pointer to it.
The fact is that I would like, for design purposes, to return a pointer to an interface. It is possible to store a real object in a vector for example, and serve it via an interface in C++ (or Java) ?
If the answer is yes, is it possible to store a vector a generic object which can be extended and return a specific interface depending on the child class ?
Thanks !

Answer 1

So, if I understand you correctly, you have something like:
class CSound {
// Whatever
};
class CSoundEngine {
// A lot of stuff
CSound* createSound(/* ... */);
};
And you don't want CSound be returned, but an interface, ALTHOUGH it is internally stored in a vector with it's specific type?
Well the first problem - Interface - is easy to solve:
Create your interfaces and derive from them.
class ISound {
public:
ISound(const ISound&) = delete;
ISound(ISound&&) = delete;
ISound& operator =(const ISound&) = delete;
ISound& operator =(ISound&&) = delete;
virtual ~ISound() = default;
// Your ISound public API here as pure virtual methods, e.g.:
virtual const std::string name() const = 0;
protected:
ISound() = default;
};
class ILoopable {
public:
ILoopable(const ILoopable&) = delete;
ILoopable(ILoopable&&) = delete;
ILoopable& operator =(const ILoopable&) = delete;
ILoopable& operator =(ILoopable&&) = delete;
virtual ~ILoopable() = default;
// Your ILoopable public API here as pure virtual methods, e.g.:
virtual const bool isLoopingActive() const = 0;
virtual bool setLoopingActive(bool) = 0;
protected:
ILoopable() = default;
};
class CDefaultSound
: public ISound {
public:
CDefaultSound () = default;
// ISound implementation
inline const std::string name() const { return mName; }
private:
std::string mName;
};
class CLoopableSound
: public ISound,
public ILoopable {
public:
CLoopableSound()
: ISound(),
ILoopable(),
mLoopingActive(true),
mName("")
{
}
// ISound implementation
inline const std::string name() const { return (mName + "(Loopable)"); }
// ILoopable implementation
inline const bool isLoopingActive() const { return mLoopingActive; }
inline bool setLoopingActive(bool active) { mLoopingActive = active; }
private:
bool mLoopingActive;
std::string mName;
};
int main()
{
// Now you can do something like this, for example, using polymorphism
// in your CSoundEngine (see below)...
ISound *pDef = new CDefaultSound();
ISound *pLoopable = new CLoopableSound();
}
If you want to use only CSound deriving from ISound that's fine, you don't need multiple classes, but then I don't understand the point of using an interface.
Important: Due to the pure virtual interface methods, you cannot instaniate the interface class, so you have to use a pointer or RAII-pointer like shared_ptr or unique_ptr (I'd recommend RAII anyway...)
The second problem - storing specific type in vector - is much harder, since you'd required a single vector foreach permitted type. OR! You store the interface-instances and only use the interface-methods!
class DefaultSoundCreator {
static ISound* createSound(/* Criteria */) { ... }
};
template <typename TSoundCreator>
class CSoundEngine {
public:
CSoundEngine()
: mSoundCreator() {
}
std::shared_ptr<ISound> createSound(/* some criteria */);
private:
std::vector<std::shared_ptr<ISound>> mSounds;
};
// cpp
std::shared_ptr<ISound> CSoundEngine::createSound(/* some criteria */) {
// Use criteria to create specific sound classes and store them in the mSOunds vector.
ISound *pSound = TSoundCreator::createSound(/* forward criteria for creation */);
std::shared_ptr<ISound> pSoundPtr = std::shared_ptr<ISound>(pSound);
mSounds.push_back(pSoundPtr);
return pSoundPtr;
}
int main() {
std::unique_ptr<CSoundEngine<DefaultSoundCreator>> pEngine = std::make_shared<CSoundEngine<DefaultSoundCreator>>();
std::shared_ptr<ISound> pSound = pEngine->createSound(/* Criteria */);
}
This way you could rely on the functionality provided by ISound, but by specifying the Creator-class, you could control sound-creation with a generic sound engine.
Now the actual problem of type-erasure using interface base classes: You known you stored a CLoopableSound at index 2 but you can only use ISound-Interfacemethods, due to the sound-engine's method createSound() : std::shared_ptr;
How do you access the ILoopable-behaviour?
And this is the point, where it becomes philosophical... I would recommend reading:
https://akrzemi1.wordpress.com/2013/11/18/type-erasure-part-i/
Type erasure techniques
https://aherrmann.github.io/programming/2014/10/19/type-erasure-with-merged-concepts/
One technique I like to use:
class CLoopableSound
: public ISound {
// All the above declarations and definitions
// AND:
static std::shared_ptr<CLoopableSound> fromISound(const std::shared_ptr<ISound>& other, bool *pSuccess = nullptr) {
std::shared_ptr<CLoopableSound> p = std::static_pointer_cast<CLoopableSound>(other);
if(pSuccess)
*pSuccess = p.operator bool();
return p;
}
};
// Use like
std::shared_ptr<CLoopableSound> pLoopable = CLoopableSound::fromISound(pSoundEngine->getSound(...));
if(pLoopable) {
// Use
}
Finally, you could of course make the fromISound-function a template and use the casts to access only ILoopable instead of CLoopableSound, etc..