C++ Defining a virtual base class overloaded operator - c++

Question

I am trying to write a set of generic math utility classes (root finders, integrators, etc.) that take in upon construction a pointer to a base class that defines the function I want the specific algorithm to operate on. The base class should only define a public virtual interface (abstract or with default trivial functionality) type operator()(type inputArg) that can be implemented by the user as needed. This would allow the user to just implement the needed functors and perform the needed computations. My mwe is below:
This first header defines the abstract interface class
// BaseFunctor.h
#ifndef _BASE_FUNCTOR_H_
#define _BASE_FUNCTOR_H_
class BaseFunctor
{
public:
virtual double operator() (double x) = 0;
};
#endif
This is the class for one of the solver methods
// NewtonsMethod.h
#ifndef _NEWTONS_METHOD_H_
#define _NEWTONS_METHOD_H_
class BaseFunctor;
class NewtonsMethod
{
public:
NewtonsMethod(BaseFunctor *rhsIn,
BaseFunctor *rhsPrimeIn,
double x0In);
~NewtonsMethod();
bool DetermineRoot(double &root);
private:
double x0;
BaseFunctor *rhs;
BaseFunctor *rhsPrime;
static const double EPSILON;
static const unsigned int MAX_ITER;
};
#endif
This is the solver implementation:
// NewtonsMethod.cpp
#include "NewtonsMethod.h"
#include "BaseFunctor.h"
#include <cmath>
const double NewtonsMethod::EPSILON = 1e-9;
const unsigned int NewtonsMethod::MAX_ITER = 30;
NewtonsMethod::NewtonsMethod(BaseFunctor *rhsIn,
BaseFunctor *rhsPrimeIn,
double x0In) :
rhs (rhsIn),
rhsPrime(rhsPrimeIn),
x0 (x0In)
{ }
NewtonsMethod::~NewtonsMethod() { }
bool NewtonsMethod::DetermineRoot(double &root)
{
// This is obviously not implemented
root = rhs(1.0) / rhsPrime(2.0);
return false;
}
And the main function where I make the derived class implementations:
// Main.cpp
#include "BaseFunctor.h"
#include "NewtonsMethod.h"
#include <iostream>
#include <iomanip>
class fOfX : public BaseFunctor
{
double operator() (double x)
{
return x * x - 2.0;
}
};
class fPrimeOfX : public BaseFunctor
{
double operator() (double x)
{
return 2.0 * x;
}
};
int main()
{
double x0 = 2.0;
BaseFunctor *f = new fOfX();
BaseFunctor *fPrime = new fPrimeOfX();
NewtonsMethod newton(f, fPrime, x0);
double root = 0.0;
bool converged = newton.DetermineRoot(root);
if (converged)
{
std::cout << "SUCCESS: root == " << std::setprecision(16) << root << std::endl;
}
else
{
std::cout << "FAILED: root == " << std::setprecision(16) << root << std::endl;
}
delete f;
delete fPrime;
}
I tried to make that as brief as possible, so sorry if it is too long. Basically I get the error:
g++ Main.cpp NewtonsMethod.cpp -o main
NewtonsMethod.cpp: In member function ‘bool NewtonsMethod::DetermineRoot(double&)’:
NewtonsMethod.cpp:29: error: ‘((NewtonsMethod*)this)->NewtonsMethod::rhs’ cannot be used as a function
NewtonsMethod.cpp:29: error: ‘((NewtonsMethod*)this)->NewtonsMethod::rhsPrime’ cannot be used as a function
How can I get this resolved keeping the desired functionality or deriving a class for the various needed functions?
Thanks

Answer 1

rhs and rhsPrime are pointers. You need to reference them in order for the function call operator to be invoked.
(*rhs)(1.0) / (*rhsPrime)(2.0)
If rhs and rhsPrime are required (i.e. cannot be NULL) and cannot be changed after the NewtonsMethod object has constructor you should declare them as references instead of pointers. This would also eliminate the need to dereference them to invoke the function call operator.
The example below shows how to use references to reference the functors.
class NewtonsMethod
{
public:
NewtonsMethod(BaseFunctor& rhsIn,
BaseFunctor& rhsPrimeIn,
double x0In);
~NewtonsMethod();
bool DetermineRoot(double &root);
private:
double x0;
BaseFunctor& rhs;
BaseFunctor& rhsPrime;
static const double EPSILON;
static const unsigned int MAX_ITER;
};
int main()
{
double x0 = 2.0;
fOfX f;
fPrimeOfX fPrime;
NewtonsMethod newton(f, fPrime, x0);
}
...or...
int main()
{
double x0 = 2.0;
BaseFunctor *f = new fOfX();
BaseFunctor *fPrime = new fPrimeOfX();
NewtonsMethod newton(*f, *fPrime, x0);
// ... other code including delete for the functors
}