BrokenFunctionCalls.cpp

#include <stdio.h>


class Base {
   public:
      Base () { }
      virtual ~Base () { }
};

class Enroll : public virtual Base {
   public:
      virtual ~Enroll () { }
      virtual void enroll () = 0;
};

class Verify : public virtual Base {
   public:
      virtual ~Verify () { }
      virtual void verify () = 0;
};

class Both : public Enroll, public Verify {
   public:
      virtual ~Both () { }

      virtual void enroll () { printf ("Enrolling.\n"); }
      virtual void verify () { printf ("Verifying.\n"); }
};

typedef Enroll* (*EnrollGenerator) ();
typedef Verify* (*VerifyGenerator) ();

Both* createInstanceOfBoth () {
   return new Both();
}

Enroll* createInstanceOfEnroll () {
   return new Both();
}
Verify* createInstanceOfVerify () {
   return new Both();
}

class Registry {
   public:
      Registry () { }

      void setupBrokenGenerators () {
         enrollGenerator = (EnrollGenerator)&createInstanceOfBoth;
         verifyGenerator = (VerifyGenerator)&createInstanceOfBoth;
      }
      void setupWorkingGenerators () {
         enrollGenerator = &createInstanceOfEnroll;
         verifyGenerator = &createInstanceOfVerify;
      }

      Enroll* getEnroll () { return enrollGenerator (); }
      Verify* getVerify () { return verifyGenerator (); }

      EnrollGenerator enrollGenerator;
      VerifyGenerator verifyGenerator;
};

int main () {
   Registry registry;
   Enroll *enroller;
   Verify *verifier;

   printf ("Broken:\n");
   registry.setupBrokenGenerators ();
   enroller = registry.getEnroll ();
   verifier = registry.getVerify ();
   enroller->enroll ();
   verifier->verify ();

   printf ("Working:\n");
   registry.setupWorkingGenerators ();
   enroller = registry.getEnroll ();
   verifier = registry.getVerify ();
   enroller->enroll ();
   verifier->verify ();
}