Polymorphism and Class Abstraction Example in C++ - c++

Question

Trying to get my head round using polymorphism in C++. Below are two base abstract classes, Duck and FlyingBehavior, and a series of inherited classes (this is based on the first chapter from Head First Design Patterns).
// Define an abstract fly behaviour class
class FlyBehavior {
public:
virtual void fly() { cout << "No Flying Set!" << endl; }
};
class FlySwoop : public FlyBehavior {
public:
void fly() { cout << "Swoop Flying!" << endl; }
};
class CantFly : public FlyBehavior {
public:
void fly() { cout << "Can't Fly!" << endl; }
};
// Define an abstract Duck class
class Duck {
CantFly nf;
FlyBehavior *flyBehavior;
public:
Duck() { flyBehavior = &nf; }
void goFly() { flyBehavior->fly(); }
void setFlyBehavior(FlyBehavior *fb) { flyBehavior = fb; }
};
// Define a new Mallard Duck class
class MallardDuck : public Duck {
FlySwoop fb;
public:
MallardDuck(){ setFlyBehavior(&fb); }
};
// Define a new Rubber Duck class
class RubberDuck : public Duck {
CantFly fb;
public:
RubberDuck(){ setFlyBehavior(&fb); }
};
// Define a new Toilet Duck Class
class ToiletDuck : public Duck {};
int main(void) {
Duck *p;
MallardDuck mallardDuck;
RubberDuck rubberDuck;
ToiletDuck toiletDuck;
p = &mallardDuck;
p->goFly();
p = &rubberDuck;
p->goFly();
p = &toiletDuck;
p->goFly();
}
Using the above code I get the following output
Swoop Flying!
Can't Fly!
Can't Fly!
when I was expecting
Swoop Flying!
Can't Fly!
No Flying Set!
Am I approaching this example the right way (use to doing it in Java)? Can't help but feel that I'm missing something fundamental. I'm trying to understand how you pull out a behaviour from a class, put it into another class, and then use polymorphism to delegate to the right behavior. Is there a better way to approach the above?
Hmmm, perhaps this where you use multiple inheritance instead?

Answer 1

If you change
class Duck {
CantFly nf;
FlyBehavior *flyBehavior;
public:
Duck() { flyBehavior = &nf; }
void goFly() { flyBehavior->fly(); }
void setFlyBehavior(FlyBehavior *fb) { flyBehavior = fb; }
};
to
class Duck {
FlyBehavior nf;
FlyBehavior *flyBehavior;
public:
Duck() { flyBehavior = &nf; }
void goFly() { flyBehavior->fly(); }
void setFlyBehavior(FlyBehavior *fb) { flyBehavior = fb; }
};
your code will produce desired output.
In the current version of the code ToiletDuck compiler-generated default constructor calls a default constructor of the Duck class which sets nf to point to an instance of theCantFly class. Of course, it prints Can't fly.

Answer 2

First, your code has no abstract base classes. An abstract base class is one that has pure virtual member functions (such as virtual fly() const=0). FlyBehavior is a polymorphic class, but not abstract, since its virtual function is not pure virtual. Duck is not even a polymorphic class (has no virtual member methods).
Second, any polymorphic classes should have a virtual destructor, so that any object of derived type can be deleted from a pointer to the polymorphic base.
Next, the derived ducks have more data members than actually used. MallardDuck, for example, has a CantFly, a FlySwoop and a FlyBehaviour*. This can be avoided by allocating the actual FlyBehaviour on the heap and managing it through a smart pointer. (This may not be an issue with this simple example, but as soon as those objects get large it will become a problem.)
Finally, the member function setFlyBehavior() is exposed to the public, allowing the user to change the FlyBehavior -- do you really want that?
A possible design is as follows
struct FlyBehavior // polymorphic class
{
virtual void fly() const { cout << "No Flying Set!" << endl; }
virtual~FlyBehavior() {}
};
struct FlySwoop : FlyBehavior
{
void fly() const { cout << "Swoop Flying!" << endl; }
};
struct CantFly : FlyBehavior
{
void fly() const { cout << "Can't Fly!" << endl; }
};
class Duck // non-polymorphic, but using polymorphism through member
{
std::unique_ptr<FlyBehavior> flyBehavior; // calls FlyBehavior::~FlyBehavior at destruction
protected:
explicit Duck(FlyBehavior*f) : flyBehavior(f) { assert(f); }
public:
Duck() : flyBehavior(new FlyBehavior) {} // note: not CantFly as in your code
Duck(Duck&&) = default; // allow move (but no copy)
Duck&operator=(Duck&&) = default;
void goFly() const { flyBehavior->fly(); }
};
struct MallardDuck : Duck
{
MallardDuck() : Duck(new FlySwoop) {}
};
struct RubberDuck : Duck
{
RubberDuck() : Duck(new CantFly) {}
};
Often it is preferrable for FlyBehavior to be abstract. In this case, Duck can be implemented with only a protected constructor (apart from move & copy):
struct FlyBehavior // polymorphic class
{
virtual void fly() const=0 ; // pure virtual
virtual~FlyBehavior() {}
};
class Duck // non-polymorphic, but using polymorphism through member
{
std::unique_ptr<FlyBehavior> flyBehavior; // calls FlyBehavior::~FlyBehavior at destruction
protected:
explicit Duck(FlyBehavior*f) : flyBehavior(f) { assert(f); }
public:
Duck() = delete; // no default constructor
Duck(Duck&&) = default; // allow move (but no copy)
Duck&operator=(Duck&&) = default;
void goFly() const { flyBehavior->fly(); }
};
and the remaining code as above. The difference is that you cannot create a Duck object, but only one of the derived Duck types. Which of these two designs is most suitable depends on the application.