Design dilemma: extensibility vs simplicity
In my opinion, a better approach (along similar lines) is to avoid abstract base classes and instead use generic "policy" classes. You informally define an interface for each behaviour, and mix them into the class as template parameters. This avoids the need for dynamic memory allocation, and removes the overhead of virtual function calls; everything is resolved at compile time. Your example could be something like this:

#include &lt;iostream&gt;

// Flying styles must have interfaces compatible with this
// struct FlyStyle
// {
//    void Fly() const;
// };

struct FlyHigh
{
  void Fly() const
  {
    std::cout &lt;&lt; "Fly high!" &lt;&lt; std::endl;
  }
};

struct NoFly
{
  void Fly() const
  {
    std::cout &lt;&lt; "No fly!" &lt;&lt; std::endl;
  }
};

// Speaking styles must have interfaces compatible with this
// struct SpeakStyle
// {
//     void Speak() const;
// };

struct SpeakLoud
{
  void Speak() const
  {
    std::cout &lt;&lt; "Speak LAUD!!!!" &lt;&lt; std::endl;
  }
};

struct NoSpeak
{
  void Speak() const
  {
    std::cout &lt;&lt; "No speaking!" &lt;&lt; std::endl;
  }
};

template &lt;class FlyStyle, class SpeakStyle&gt;
class SuperBird
{
  public:
    void Fly() const
    {
      flystyle.Fly();
    }
    void Speak() const
    {
      speakstyle.Speak();
    }
  private:
    FlyStyle flystyle;
    SpeakStyle speakstyle;
};

typedef SuperBird&lt;FlyHigh, SpeakLoud&gt; Eagle;
typedef SuperBird&lt;NoFly, NoSpeak&gt; Penguin;

int main()
{
  Eagle eagle;
  eagle.Fly();
  eagle.Speak();

  Penguin penguin;
  penguin.Fly();
  penguin.Speak();
}