Inheritance and 2 interface types - c++

Question

I have a question regarding inheritance and designing a user interface.
I have a class KeyboardKey which represents an individual keyboard key, such as Q, W, E, R, ... etc.
I have a class Keyboard which contains a vector of class Keyboardkey. [Important!]
I am using SFML, and so each time an event is generated from an event loop, it is sent to the keyboard class. This class then farms that event out to the corresponding key.
In addition, I have a class SynthesizerKey which inherits from KeyboardKey. In addition to the regular key stuff, such as "is the key enabled", "is the key pressed", this class contains data and functions to handle generating a sin wave tone. Variables include the amplitude and current phase of the sin wave.
I am now about to create a class SynthesizerKeyboard. I was about to copy and paste all the code from class Keyboard into this class, however this is not good programming practice, as code is duplicated!
The main issue I have is that SynthesizerKeyboard contains a function to generate a sequence of samples to be stored in a buffer. In order to generate the samples, a loop iterates over each KeyboardKey and checks if it is pressed. If it is, then we must generate a sample corresponding to that keys note/frequency.
However, since the vector contains class KeyboardKey and not class SynthesizerKey I do not have the variables for the phase and amplitude of the sin waves as member data of the elements of the vector.
I think I may have to do what is known as "refactoring" [?], and separate the "sin wave" parts of SynthesizerKey from the KeyboardKey parts. In other words, I ditch the SynthesizerKey class and have an Synthesizer class and a KeyboardKey class, separately. I then have a vector of Synthesizer in class SynthesizerKeyboard in addition to the vector of KeyboardKey in class Keyboard which I have access to in SynthesizerKeyboard through inheritance.
However this is less elegant. Is there another way?
Below is some code which might help the reader understand the quesiton in more detail.
SynthesizerKeyboard
class SynthesizerKeyboard : public Keyboard
{
public:
SynthesizerKeyboard(const sf::Font& sf_font)
: Keyboard(sf_font)
{
}
double Sample() const
{
for(std::vector<KeyboardKey>::iterator it = m_keyboardkey.begin()
it != m_keyboardkey.end(); ++ it)
{
if(it->IsKeyPressed())
{
it->Sample();
}
}
}
void GenerateBufferSamples(std::vector<sf::Int16> buffer)
{
for(std::size_t i = 0; i < buffer.size(); ++ i)
{
buffer[i] = Sample();
}
}
};
SynthesizerKey
class SynthesizerKey : public KeyboardKey
{
protected:
AbstractOscillator *m_abstractoscillator;
public:
double Sample() const
{
return m_abstractoscillator->Sample();
}
};
Keyboard
class Keyboard
{
protected:
std::vector<KeyboardKey> m_keyboardkey;
public:
Keyboard(const sf::Font& sf_font)
void Draw(sf::RenderWindow& window)
void Event(const sf::Event& event)
{
for(std::vector<KeyboardKey>::iterator it = m_keyboardkey.begin();
it != m_keyboardkey.end(); ++ it)
{
(*it).Event(event);
}
}
bool IsKeyPressed(const sf::Keyboard::Key& sf_key)
{
for(std::vector<KeyboardKey>::iterator it = m_keyboardkey.begin();
it != m_keyboardkey.end(); ++ it)
{
if((*it).Key() == sf_key)
{
return (*it).IsKeyPressed();
}
}
}
};
KeyboardKey
class KeyboardKey
{
protected:
KeyState m_keystate;
sf::Color m_pressed_color;
sf::Color m_release_color;
sf::Text m_sf_text;
sf::Keyboard::Key m_sf_keyboard_key;
sf::RectangleShape m_sf_rectangle;
public:
KeyboardKey(const sf::Keyboard::Key& sf_keyboard_key, const std::string& text, const sf::Font& sf_font,
const double position_x, const double position_y)
void Draw(sf::RenderWindow& window)
void Event(const sf::Event& event)
bool IsKeyPressed()
};

Answer 1

Going to skip over the keys for now, but you should consider something similar for them.
First define a bare bones abstract that performs all of the common tasks and includes hooks for the classes that specialize the abstract to fill out to perform their particular behaviour:
class AbstractKeyboard
{
protected:
std::vector<std::unique_ptr<KeyboardKey>> m_keyboardkey;
void Draw();
void Event()
{
for(auto &key: m_keyboardkey)
{
key->Event();
}
}
bool IsKeyPressed(const sf::Keyboard::Key& sf_key)
{
for(auto &key: m_keyboardkey)
{
if(key->isKey(sf_key))
{
return key->IsKeyPressed();
}
}
return false; // need this to handle the no match case, otherwise undefined behaviour
}
void doStuff()
{
// generic keyboard stuff goes here
doSpecificStuff();
}
virtual void doSpecificStuff() = 0;
public:
AbstractKeyboard(const sf::Font& sf_font);
virtual ~AbstractKeyboard();
};
All keyboards have keys, so the vector of keys goes here. Note that we've gone from a vector of keys to a vector of smart pointers to keys. Now we can have any key that inherits the basic key, synthesizer key for example, and the smart pointer eliminates the usual memory woes of dealing with pointers.
The big takeaway here is the doStuff function. It does stuff. What is up to you. When it's done doing the basic stuff that all keyboards must do, it calls doSpecificStuff, a function that each inheritor must fill out, even if it does nothing. doSpecificStuff does whatever the inheritor does differently, add extra behaviours, and generally makes a synthesizer more than just a regular keyboard.
Here is the basic keyboard:
class Keyboard:public AbstractKeyboard
{
protected:
void doSpecificStuff()
{
// Do keyboard Stuff, if there is any specific stuff to do
}
public:
Keyboard(const sf::Font& sf_font): AbstractKeyboard(sf_font)
{
}
};
It doesn't do anything special, but it could but putting special code into doSpecificStuff.
The synthesizer adds a few functions for folk who know it is a synthesizer (Sample and GenerateBufferSamples) as well as implementing doSpecificStuff to do synthesizer stuff.
class SynthesizerKeyboard : public AbstractKeyboard
{
protected:
void doSpecificStuff()
{
// I do specific stuff! Yay me!
}
public:
SynthesizerKeyboard(const sf::Font& sf_font): AbstractKeyboard(sf_font)
{
}
// leaving these as an example of how to get a SynthesizerKey out of m_keyboardkey
double Sample() const
{
// just going to sum because I don't know what's supposed to happen in here
double sum = 0.0;
for(auto &key: m_keyboardkey)
{
if(key->IsKeyPressed())
{
if(SynthesizerKey* skey = dynamic_cast<SynthesizerKey*>(key.get()))
{
sum += skey->Sample();
}
else
{
// like freak out, man.
}
}
}
return sum;
}
void GenerateBufferSamples(std::vector<sf::Int16> buffer)
{
for(sf::Int16 & val: buffer)
{
val = Sample();
}
}
};
Since the synthesizer uses synthesizer keys, Sample contains an example of how to turn a pointer to a regular key into a synthesizer key and trap a configuration error that places the wrong type of key into m_keyboardkey
By adding a virtual destructor and the virtual keyword to Sample in SynthesizerKeyboard, we could also make a
class MoogSynthesizer: public SynthesizerKeyboard
{
public:
double Sample() const override
{
// I do Moog sampling!
}
}