Question

Suppose I have a pure virtual method in the base interface that returns to me a list of something:

class base 
{ 
public:
     virtual std::list<something> get() = 0; 
}; 

Suppose I have two classes that inherit the base class:

class A : public base 
{ 
public:
     std::list<something> get();
}; 

class B : public base 
{ 
public:
     std::list<something> get(); 
};

I want that only the A class can return a list<something>, but I need also to have the possibility to get the list using a base pointer, like for example:

base* base_ptr = new A();
base_ptr->get();

What I have to do?

Have I to return a pointer to this list? A reference?

Have I to return a null pointer from the method of class B? Or have I to throw an exception when I try to get the list using a B object? Or have I to change the base class method get, making it not pure and do this work in the base class?

Have I to do something else?

Answer 1

You have nothing else to do. The code you provide does exactly that.

When you get a pointer to the base class, since the method was declared in the base class, and is virtual, the actual implementation will be looked up in the class virtual function table and called appropriately.

So

base* base_ptr = new A();
base_ptr->get();

Will call A::get(). You should not return null from the implementation (well you can’t, since null is not convertible to std::list< something > anyway). You have to provide an implementation in A/B since the base class method is declared pure virtual.

EDIT:

you cannot have only A return an std::list< something > and not B since B also inherits the base class, and the base class has a pure virtual method that must be overriden in the derived class. Inheriting from a base class is a "is-a" relationship. The only other way around I could see would be to inherit privately from the class, but that would prevent derived to base conversion.

If you really don’t want B to have the get method, don’t inherit from base.
Some alternatives are:

Throwing an exception in B::get():
You could throw an exception in B::get() but make sure you explain your rationale well as it is counter-intuitive. IMHO this is pretty bad design, and you risk confusing people using your base class. It is a leaky abstraction and is best avoided.

Separate interface:
You could break base into separate interface for that matter:

class IGetSomething
{
public:
    virtual ~IGetSomething() {}
    virtual std::list<something> Get() = 0;
};

class base
{
public:
    // ...
};

class A : public base, public IGetSomething
{
public:
    virtual std::list<something> Get()
    {
        // Implementation
        return std::list<something>();
    }
};

class B : public base
{

};

The multiple inheritance in that case is OK because IGetSomething is a pure interface (it does not have member variables or non-pure methods).

EDIT2:

Based on the comments it seems you want to be able to have a common interface between the two classes, yet be able to perform some operation that one implementation do, but the other doesn’t provide. It is quite a convoluted scenario but we can take inspiration from COM (don’t shoot me yet):

class base
{
public:
    virtual ~base() {}
    // ... common interface

    // TODO: give me a better name
    virtual IGetSomething *GetSomething() = 0;
};

class A : public Base
{
public:
    virtual IGetSomething *GetSomething()
    {
        return NULL;
    }
};

class B : public Base, public IGetSomething
{
public:
    virtual IGetSomething *GetSomething()
    {
        // Derived-to-base conversion OK
        return this;
    }
};

Now what you can do is this:

base* base_ptr = new A();
IGetSomething *getSmthing = base_ptr->GetSomething();
if (getSmthing != NULL)
{
    std::list<something> listOfSmthing = getSmthing->Get();
}

It is convoluted, but there are several advantages of this method:

• You return public interfaces, not concrete implementation classes.

• You use inheritance for what it’s designed for.

• It is hard to use mistakenly: base does not provide std::list get() because it is not a common operation between the concrete implementation.

• You are explicit about the semantics of GetSomething(): it allows you to return an interface that can be use to retrieve a list of something.

  What about just returning an empty std::list ?

That would be possible but bad design, it’s like having a vending machine that can give Coke and Pepsi, except it never serves Pepsi; it’s misleading and best avoided.

What about just returning a boost::optional< std::list< something > > ? (as suggested by Andrew)

I think that’s a better solution, better than returning and interface that sometimes could be NULL and sometimes not, because then you explicitly know that it’s optional, and there would be no mistake about it.

The downside is that it puts boost inside your interface, which I prefer to avoid (it’s up to me to use boost, but clients of the interface shouldn’t have to be forced to use boost).