Designing A class with multiple set of method implementation [c++] - c++

Question

I am working on an existing project which has one class for which I need an alternate member function definition. I don't want to modify existing member functions or their signatures, just an alternate definition which has to be selected run time based on some xml file (Compile time flag not preferred).
I am new to C++, so this may be a stupid question.
Please suggest design guidelines such that I don't have to change and test existing code base, and just plug my implementation.
Example
class ABC{
public:
int operate(int, int);
}
//Assume below method to be existing implementation
ABC::operate(int op1, int op2)
{
return op1+ op2; //add
}
//Alternate desired implementation
ABC::operate(int op1, int op2)
{
return op1 * op2; //multiply
}
Ideally I would want above to be run time selection but can fall to compile time if thats the only way.

Answer 1

note this thread Reason for C++ member function hiding regarding name-hiding in inheritence.
When a derived class implements a NON VIRTUAL method with the same name as in the base class, that method in the base becomes hidden, and only the derived method can be used - through objects of static type Derived.
My suggestion for you is to implement something like
class ABC{
public:
int operate(int, int);
};
//Assume below method to be existing implementation
ABC::operate(int op1, int op2)
{
return op1+ op2; //add
}
Now, for your extended functionality, derive from ABC (sidenote: inheritence or composition is another discussion, read about it on google).
class Derived : public ABC{
operate(int op1, int op2){
return op1 * op2; //multiply
}
}
Now, wherever you need your new functionality, change the static type of the calling object to Derived, and the derived operate will be called.
A more logical solution is possible if it is possible to change ABC's operate's signature to virtual int operate(int,int);, then polimorphism could take place, and accessing operate through reference types anywhere would invoke the operate that belongs to the dynamic type of the calling object.
Thus, you would only have to instantiate your object to be of type Derived rather than ABC.
Note that virtual method usage is not possible if operate is static, and it was unclear here if that is the case.

Answer 2

I was preparing an answer but Gulzar answered meanwhile ( end of his answer )
What you need is a base notion/mechanism in C++ called dynamic binding ( maybe you learned it also meanwhile as your post is 1 month old )
#include <iostream>
#include <cstddef>
using namespace std;
class ABC_Base
{
public:
//pure virtual member function
//compelling effective creation of the
//function in the daughter classes
virtual int operate(int,int) = 0;
//virtual xtor as base will be derived
virtual ~ABC_Base() {}
};
class ABC_M1 : public ABC_Base
{
int operate (int a, int b ) {return a+b; }
};
class ABC_M2 : public ABC_Base
{
int operate (int a, int b ) {return a*b; }
};
ABC_Base * createABC(string xml_filename)
{
int criterion = 0;
// nullptr need at least c++11 option
ABC_Base * ptr = nullptr;
//read xml file and update criterion
//see other post to do that
//criterion = ...
switch(criterion)
{
case 0:
ptr = new ABC_M1();
break;
case 1:
ptr = new ABC_M2();
break;
default:
break;
}
return ptr;
}
int main()
{
ABC_Base * ptr = createABC("My_Config.xml");
if (nullptr != ptr)
{
cout << ptr->operate(3,4) << endl;
}
// If you absolutely want / have to use plain old pointers
// do not forget to release things
// works even if ptr is null, so unconditional delete
delete(ptr);
return 0;
}