Implementing interfaces in C++

Question

I usually program in C# but am trying to do a bit of C++ and am struggling somewhat trying to implement interfaces in C++.

In C# I'd do something like this:

class Base<T>
{
    public void DoSomething(T value)
    {
        // Do something here
    }
}

interface IDoubleDoSomething
{
    void DoSomething(double value);
}

class Foo : Base<double>, IDoubleDoSomething
{
}

In C++ I've implemented it like this:

template <class T>
class Base
{
public:
    virtual void DoSomething(T value)
    {
        // Do something here
    }
};

class IDoubleDoSomething
{
public:
    virtual void DoSomething(double value) = 0;
};

class Foo : public Base<double>, public IDoubleDoSomething
{
};

The problem is that I cannot instantiate Foo because it is abstract (doesn't implement DoSomething). I realise I can implement DoSomething and just call the method on Base but I was hoping there is a better way of doing this. I have other classes which inherit from base with different data types and I have other classes which inherit from IDoubleDoSomething which don't use Base.

Any help appreciated.

Answer 1

Consider the following c++ code

class Foo
{
public:
    void DoSomething1(){}
};

template<typename t>
void MethodExpectsDosomething1( t f )
{
    f.DoSomething1();
}

template<typename t>
void MethodExpectsDosomething2( t f )
{
    f.DoSomething2();
}

int main()
{
    Foo f;
    MethodExpectsDosomething1<Foo>( f );

    MethodExpectsDosomething2<Foo>( f );

    return 0;
}

In C++ you can use Foo without it implementing a IDoSomething1 and IDoSomething2. The second method MethodExpectsDosomething2 will simply fail to compile as Foo doesn't have the DoSomething2 method.

In C# such construct is not possible and forces you to have IDoSomething1 and IDoSomething2 interface and specify that as a type constraint.

So maybe you need to look at your code and see if such interfaces are needed at all ?

Answer 2

The thing is, Base::DoSomething and IWhatever::DoSomething are two unrelated functions (even if there weren't any pure virtual functions in this, you wouldn't be able to call DoSomething on a Foo object, anyway). Base needs to inherit from IWhatever for this to work.

That said, ask yourself if you actually need this. Generic programming with templates (and concepts, which are sort of like interfaces — see Boost.ConceptCheck) is usually a better solution in C++ than runtime subtype polymorphism.