Правильное поведение с помощью виртуальных методов

Вам больше нечего делать. Код, который вы предоставляете, делает именно это.

Когда вы получаете указатель на базовый класс, поскольку метод был объявлен в базовом классе и является виртуальным, фактическая реализация будет найдена в таблице виртуальных функций класса и вызвана соответствующим образом.

So

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

Будет вызывать A::get(). Вы не должны возвращать null из реализации (ну, вы не можете, так как null не может быть преобразован в std::list‹ что-то в любом случае). Вы должны предоставить реализацию в A/B, так как метод базового класса объявлен чисто виртуальным.

ИЗМЕНИТЬ:

вы не можете иметь только A, возвращающий std::list‹ что-то ›, но не B, поскольку B также наследует базовый класс, а базовый класс имеет чисто виртуальный метод, который должен быть переопределен в производном классе. Наследование от базового класса является отношением «является». Единственным другим способом, который я мог видеть, было бы частное наследование от класса, но это предотвратило бы преобразование производного в базовое.

Если вы действительно не хотите, чтобы B имел метод get, не наследуйте его от base. Некоторые альтернативы:

Вызов исключения в B::get(): Вы можете выдать исключение в B::get(), но убедитесь, что вы хорошо объяснили свое обоснование, поскольку оно противоречит интуиции. ИМХО, это довольно плохой дизайн, и вы рискуете запутать людей, используя свой базовый класс. Это дырявая абстракция, и ее лучше избегать.

Отдельный интерфейс: вы можете разбить базу на отдельный интерфейс:

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
{

};

Множественное наследование в этом случае допустимо, поскольку IGetSomething — это чистый интерфейс (у него нет переменных-членов или нечистых методов).

EDIT2:

Основываясь на комментариях, кажется, что вы хотите иметь общий интерфейс между двумя классами, но при этом иметь возможность выполнять некоторые операции, которые выполняет одна реализация, но не предоставляет другая. Это довольно запутанный сценарий, но мы можем черпать вдохновение из COM (пока не стреляйте в меня):

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;
    }
};

Теперь вы можете сделать следующее:

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

Это запутанно, но есть несколько преимуществ этого метода:

• Вы возвращаете общедоступные интерфейсы, а не конкретные классы реализации.

• Вы используете наследование для того, для чего оно предназначено.

• Его трудно использовать по ошибке: base не предоставляет std::list get(), потому что это не обычная операция между конкретной реализацией.

• #P17# <блочная цитата> #P18#

Это было бы возможно, но плохой дизайн, это все равно, что иметь торговый автомат, который может продавать кока-колу и пепси, за исключением того, что он никогда не продает пепси; это вводит в заблуждение, и его лучше избегать.

Как насчет того, чтобы просто вернуть boost::Optional‹ std::list‹ что-то › › ? (как предложил Андрей)

Я думаю, что это лучшее решение, лучше, чем возврат и интерфейс, который иногда может быть NULL, а иногда нет, потому что тогда вы явно знаете, что это необязательно, и в этом не будет ошибки.

Недостатком является то, что он помещает boost внутри вашего интерфейса, чего я предпочитаю избегать (я могу использовать boost, но клиенты интерфейса не должны быть вынуждены использовать boost).

вернуть boost::optional в случае, если вам нужна возможность не возвращаться (в классе B)

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

То, что вы делаете, неправильно. Если это не является общим для обоих производных классов, вам, вероятно, не следует иметь его в базовом классе.

Кроме того, нет никакого способа достичь того, чего вы хотите. Вы также должны реализовать метод в B, что и является значением чистой виртуальной функции. Однако вы можете добавить специальный случай сбоя, например возврат пустого списка или списка с одним элементом, содержащим предопределенное недопустимое значение.