Is inheritance from a base class with no virtual methods bad practice?

I read an answer some time back to a question regarding dynamic_cast. The dynamic_cast failed to work because the base class had no virtual methods. One of the answers said that deriving from classes with no virtual methods generally means a bad design. Is this correct? Even without taking advantage of polymorphis开发者_如何学编程m, I still can't see the wrongness in doing this.

It depends what we're talking about:

• for Traits classes (no data) it's fine (std::unary_function comes to mind)
• for private inheritance (used instead of composition to benefit from Empty Base Optimization) it's fine too

The problem comes when you starts treating such a Derived object polymorphically wrt this Base class. If you ever attain such a position, then it's definite code smell.

Note: Even when noted as fine above, you are still providing the ability to use the class polymorphically, and you thus expose yourself to subtle bugs.

Deriving from a class is always a valid option, for the sake of code reuse.

Sometimes, we are not looking for polymorphic behavior. That's OK - there's a reason we have that option. If this is the case, though, then consider using private inheritance instead - if your class isn't meant to be polymorphic, then there's no reason for anyone to try to use it polymorphically.

Here is an OK example, to factor behaviors into policies (note the protected destructor):

struct some_policy
{
    // Some non-virtual interface here
protected:
    ~some_policy() { ... }

private:
    // Some state here
};

struct some_class : some_policy, some_other_policy { ... };

Another Ok example, to avoid code bloat in templates. Note the protected destructor:

struct base_vector
{
    // Put everything which doesn't depend 
    // on a template parameter here

protected:
    ~base_vector() { ... }
};

template <typename T>
struct vector : base_vector
{ ... };

Another example, called CRTP. Note the protected destructor:

template <typename Base>
struct some_concept 
{
    void do_something { static_cast<Base*>(this)->do_some_other_thing(); }

protected:
    ~some_concept() { ... }
};

struct some_class : some_concept<some_class> { ... };

Another example, called Empty Base Optimization. Not really inheritance per se, since it is more a trick to allow the compiler to reserve no space in some_class for the base class (which acts as a private member).

template <typename T>
struct some_state_which_can_be_empty { ... };

template <typename T>
struct some_class : private some_state_which_can_be_empty<T> { ... };

As a rule of thumb, classes you inherit from should have either virtual or protected destructor.

Inheritance without virtual methods in C++ is nothing more than a code reuse. I can't think of inheritance without polymorphism.

Some classes in the C++ standard library have protected members (which are only meaningful to a derived class) but no virtual member functions. I.e., they're designed for derivation, without having virtuals. This proves that it must generally be bad design to derive from a class without virtuals.

Cheers & hth.,