You're welcome. I'm glad I could help you somewhat, and hope that I can help in the future also. Just to be clear also, a true interface in C++ is a completely virtual class with no fields. For example:
Code:
class IRenderable
{
public:
virtual void render() = 0;
virtual bool isLoaded() = 0;
};
while a class with some virtual methods is technically an abstract class. Abstract classes must be inherited because they have some virtual methods that need to be implemented by a deriving class. For example:
Code:
class AbstractToken
{
private:
std::string _value;
public:
AbstractToken(std::string value);
~AbstractToken();
std::string getValue();
/* This must be implemented by a deriving class */
virtual bool tryParse(std::string value, AbstractToken * outToken) = 0;
};
AbstractToken::AbstractToken(std::string value)
{
this->_value = value;
}
AbstractToken::~AbstractToken()
{
}
std::string AbstractToken::getValue()
{
return _value;
}
class ConcreteToken : public AbstractToken
{
public:
ConcreteToken(std::string value);
~ConcreteToken();
/* Here is the implementation for AbstractToken::tryParse */
bool tryParse(std::string value, AbstractToken * outToken);
};
ConcreteToken::ConcreteToken(std::string value) : AbstractToken(value)
{
}
ConcreteToken::~ConcreteToken()
{
}
bool ConcreteToken::tryParse(std::string value, AbstractToken * outToken)
{
bool successful = true;
//...
return successful;
}
Both abstract classes and pure interfaces are considered interfaces in OOP. C++ is just a lot more loose on creating these than modern object-oriented programming languages. And it may not be that important, but it becomes more important when implementing design patterns.