Birds, bees and abstract classes

Question

Newbie me is currently stuck at this seemingly simple problem. Let's say I want to write some code about a bunch of animals procreating happily everafter. Obviously, they'd all need a mate() method, so I could define an abstract class like this:

class FemaleAnimal {
public:
    virtual FemaleAnimal mate(const MaleAnimal& a) const = 0;
    virtual MaleAnimal mate(const MaleAnimal& a) const = 0;
}

And derive all the different species:

class FemaleBird : public FemaleAnimal {
public:
    FemaleBird mate (const MaleBird& b) const;
    MaleBird mate (const MaleBird& b) const;
}

class FemaleBee: public FemaleAnimal {
public:
    FemaleBee mate (const MaleBee& b) const;
    MaleBee mate (const MaleBee& b) const;
}

In main(), I want two vectors

males = vector<MaleAnimal>
females = vector<FemaleAnimal>

each of which might contain both birds and bees, and is filled at run time. The species at each index match, so if males[i] is a bee, then females[i] is also a bee, so I can do

vector<FemaleAnimal> femaleOffspring;
vector<MaleAnimal> maleOffspring;
for (int i=0; i<males.size(); ++i){
    femaleOffspring.push_back( females[i].mate(males[i]) );
    maleOffspring.push_back( females[i].mate(males[i]) );
}    

Now, obviously I want the mate() method in the derived classes to implement the one in the base class, but then I'd have to define mate() for animals in general, such as

FemaleBee::mate(const MaleAnimal& a) const;

But bees don't mate with birds. How would I achieve that kind of specialization? Is there some special design pattern for this? I've tried to look into things like covariance, but that was more confusing than helping.

Bonus question: How do I capture the case when males[i] and females[i] are of different species at runtime?

Edit: Assume that males and females come from entirely different class hierarchies and could not sensibly be derived from a common base class.

Edit: For completeness sake, here is the final solution based on n.m.'s answer. Lots of thanks everybody!

#include <iostream>

using namespace std;

class GenericMale {
public:
    virtual void test() = 0;    // just to make the class abstract
};


template <typename Species>
class Male : public GenericMale
{
    void test() {};
};


class GenericFemale {
    virtual void tryMate (const GenericMale&) const = 0;
};


template <typename Species>
class Female : public GenericFemale
{
public:
    virtual void tryMate (const GenericMale& m) const
    {
        try {
            auto& p= dynamic_cast<const Male<Species>&>(m);    // will throw if Species does not match
            Species::doMate(p);
        } catch ( exception& e) {
            cerr << "[MATING ERROR] You filthy animals, stay within your own species!" << endl;
        }
    }
};


class Bee {
public:
    static void doMate(const Male<Bee>& p) {
        cout << "Buzz buzz buzz!" <<endl;
    }
};


class Bird {
public:
    static void doMate(const Male<Bird>& p) {
        cout << "Chirpy chirpy cheep cheep!" << endl;
    }
};



int main() {
    Female<Bee> queenBee;
    Male<Bee> drone;
    queenBee.tryMate(drone);

    Female<Bird> mamaBird;
    Male<Bird> papaBird;
    mamaBird.tryMate(papaBird);

    queenBee.tryMate(papaBird);
}

Answer 1

You basically have two options: compile-time checks and run-time checks.

Compile-time

Your MaleAnimal and FemaleAnimal objects don't have mate methods with the signature you gave. Indeed, since any female cannot mate any male, the method signature

FemaleAnimal::mate(const MaleAnimal& a) const

is an overly generous promise. Don't promise what you cannot fulfil.

A FemaleAnimal should be able to mate with a MaleAnimal of the same species. How do we write that down? We encode the species in the type of the animal. In C++, that would be a template.

template <typename Species>
class Animal ...

template <typename Species>
class MaleAnimal : public Animal<Species> ...

template <typename Species>
class FemaleAnimal : public Animal<Species>
{ ...
   void mate (const MaleAnimal<Species>&) const ...
}

This type-safety comes with a price. You cannot keep representatives of different species in the same container and retain their species information. You need a separate container of a distinct type for each species.

 class AnimalContainer
 { ...
    virtual void mateAll() = 0;
 };

 template <typename Species>
 class SpecificContainer : public Container
 {
    ...
    std::vector<MaleAnimal<Species>> males;
    std::vector<FemaleAnimal<Species>> females;
    void mateAll()
    {
       for (...) females[i].mate(males[i]);
    }        
 }

Now you can keep a container of AnimalContainers and each one can keep a separate species.

Run-time

Your FemaleAnimal can try to mate any MaleAnimal. The attempt could fail. This is best modelled with dynamic_cast: if the check passes, it returns the right type, and if not, it fails (throws an exception).

The hierarchy can be modified thus:

class Animal ...

class GenericMaleAnimal : public Animal ...
class GenericFemaleAnimal : public Animal 
{ ...
   virtual void tryMate (const GenericMaleAnimal&) const = 0;
};

template <typename Species>
class MaleAnimal : public GenericMaleAnimal ...

template <typename Species>
class FemaleAnimal : public GenericFemaleAnimal
{ ...
   virtual void tryMate (const GenericMaleAnimal& m) const
   {
      // will throw if species don't match
      auto& other = dynamic_cast<const MaleAnimal<Species>&>(m);
      // Specific mate procedure for given species
      Species::doMate(*this, other);
   }
};

Now you can keep everything in the same container, and it's your responsibility to make types match.

Answer 2

Your description might point to the answer in that:

The species at each index match, so if males[i] is a bee, then females[i] is also a bee

covers the specialization

But bees don't mate with birds. How would I achieve that kind of specialization?

Q: How did you guarantee they match up? A: You must have known the types of both entries at the same time! And when you did, simply set up a command pattern, lambda, etc. to call the specialized method with the two known types.

Finally look at this use of enable_if -- could be used to satisfy your problem if I am incorrect regarding the above statement.

Answer 3

"How do I capture the case when males[i] and females[i] are of different species at runtime?": Depends whether the attempt to mate the wrong one is an error or not. If it's ok to try but just doesn't work, you could perform some check in the mate() function, e.g. StillLearning's suggestion of a dynamic cast of the argument (is it my species?). If you want to be more flexible you could make that test configurable with a check functor that can be provided e.g. in the constructor of an animal, or as an optional argument to mate(). If the test is negative simply do nothing.

If a bad mating attempt is an error (because you set your vectors up badly and cannot continue) you can just throw an exception.

Edit: @Buddy's pointer to the double dispatch pattern is useful and elegant for mating differently with different species (different subclasses of their respective bases), even though just a pointer or reference to a base is provided. The double dispatch could implicitly incorporate a "check" by overloading mate_callback() (or whatever -- the function implemented in the original caller which is called by the original argument) for desired species sensibly and having a catch-all that throws or does nothing for all other species. Double dispatch also pleases me ethically because it requires mutual consensus when mating.