Abstract Interfacing (overiding an initialization function)

[Jeremy G]

I'm trying to figure out how to overide a virtual function with a different signature. A function initialize may need to be initialized a different a different way per object (I know this isn't a perfectly abstract interface) but I dont want to define a ton of virtual Init functions in the abstract class and redefine them empty in each inheriting class. Any way I can achieve this?

class AbstractInterface{
public:
     AbstractInterface();
     ~AbstractInterface();

public:
     virtual void Init();
};

class AIobject : public AbstractInterface {
public:
     void Init(bool small);
};

class AIobject2 : public AbstractInterface {
public:
     void Init(int size);
};

[Prelude]

The closest you can get is with return values. If the base class returns a reference to base then you can declare the function virtual and return a derived reference in the derived class. Otherwise you're not overriding Init and polymorphism won't take effect. Perhaps templates would be more to your liking:

#include <iostream>

using namespace std;

template <typename T>
class Interface {
public:
  virtual void Init(T obj) { cout<<"Interface Init: "<< obj <<endl; }
};

template <typename T>
class Derived: public Interface<T> {
public:
  void Init(T small) { cout<<"Derived Init: "<< small <<endl; }
};

int
main()
{
  Interface<bool> *i = new Derived<bool>;

  i->Init(true);
}