oop - C++ best way te determine an inherited object

Question

I have an abstract object inherited by objects with very different needs, but I need to get all of them in the same container at a point.

I have two main ideas, the first :

Define all methods in the abstract object in that way :

class AbstractObject
{
    ...

    virtual bool isObjectSpecial ()
    {
        /* Default behavior : you are not special, so return false. */
        return false;
    };

    virtual void doSomethingSpecial ()
    {
        /* Default behavior : you are really not special, so do nothing.*/
    };

    ...
}

class SpecificObjectA : public AbstractObject
{
    ...

    bool isObjectSpecial () override 
    {
        return true;
    };

    void doSomethingSpecial () override
    {
        /* Do the special A thing ... */
    };

    ...
}

class SpecificObjectB : public AbstractObject
{
    ...

    bool isObjectSpecial () override 
    {
        return true;
    };

    void doSomethingSpecial () override
    {
        /* Do the special B thing ... */
    };

    ...
}

class RegularObjectA : public AbstractObject
{
    ...
}

/* ... and so on. */

And the use case will be :

if ( abstractObjectPtr->isObjectSpecial() )
    abstractObjectPtr->doSomethingSpecial();

The second idea is : Define only common methods to the base abstract and create an other abstract object containing methods for the special case in that way.

class AbstractObject
{
    ...
}

class AbstractSpecialObject : public AbstractObject
{
    ...

    void doSomethingSpecial () = 0; // NOTE: Pure virtual here !

    ...
}

class SpecificObjectA : public AbstractSpecialObject
{
    ...

    void doSomethingSpecial () override
    {
        /* Do the special A thing ... */
    };

    ...
}

class SpecificObjectB : public AbstractSpecialObject
{
    ...

    void doSomethingSpecial () override
    {
        /* Do the special B thing ... */
    };
    
    ...
}

class RegularObjectA : public AbstractObject
{
    ...
}

/* ... and so on. */

And the use case will be :

auto specialAbstractObjectPtr = dynamic_cast< AbstractSpecialObject * >(abstractObjectPtr);

if ( specialAbstractObjectPtr != nullptr )
    specialAbstractObjectPtr->doSomethingSpecial();

From a full OOP perspective, I prefer the second solution, but I don't like the dynamic casting. In the other hand, I don't know what could be wrong with the first one, just the fact it forces the abstract object to be responsible for all methods.

What will you choose and why ? And, did someone have an other solution ?

Answer 1

等待大神答复