Requiring base class operator to perform a "domain check" (C++) - c++

Question

Let's say I'm trying to define an abstract base class for "mathematical functions" - i.e. things that look like y=f(x) where both x and y are numeric types, and x is in the "domain" of f. Here's what my abstract base class might look like:
template<typename T>
class AbstractFunction{
public:
virtual bool CheckDomain(T) const = 0;
virtual T operator()(T) const = 0;
};
This says that any concrete class derived from AbstractFunction must implement a CheckDomain method and an "evaluation operator" (). Now what I'd like to do is require that the evaluation operator calls the CheckDomain function before evaluating the function. Is there a neat way to do some sort of "partial implementation" for operator()(T)? Obviously this would mean it's no longer a pure virtual.
I thought I had it figured out with the following construction, but I must be missing something because if I create ConcreteFunction f and try to evaluate f(1.0), it doesn't use the derived class methods (it always returns 0 for CheckDomain(x)).
class AbstractFunction{
public:
virtual bool CheckDomain(double) const = 0;
virtual double EvalFunction(double) const = 0;
virtual double operator()(double);
};
double AbstractFunction::operator()(double x){
bool D = CheckDomain(x);
if(D==1){
return EvalFunction(x);
}
else{
std::runtime_error("Error: Out of Domain");
}
}
class ConcreteFunction : public AbstractFunction{
public:
bool CheckDomain(double x) const {(x>0.0)? 1:0;}
double EvalFunction(double x) const {return x*x;}
// Don't need to define operator(), should inherit from AbstractFunction.
};
I'm sure I'm missing something easy, any thoughts?

Answer 1

Actually, my method works! I just spaced out on my definition of ConcreteFunction::CheckDomain. I did the domain check, but didn't return it! The following code compiles and runs as desired:
#include<stdexcept>
#include<iostream>
class AbstractFunction{
public:
virtual bool CheckDomain(double) const = 0;
virtual double EvalFunction(double) const = 0;
virtual double operator()(double) const;
};
double AbstractFunction::operator()(double x) const{
bool D = CheckDomain(x);
if(D==1){
return EvalFunction(x);
}
else{
throw std::runtime_error("Error: Out of Domain");
}
}
class ConcreteFunction : public AbstractFunction{
public:
bool CheckDomain(double x) const {return (x>0.0)? 1:0;}
double EvalFunction(double x) const {return x*x;}
// Don't need to define operator(), should inherit from AbstractFunction.
};
int main()
{
ConcreteFunction f;
std::cout<<"f(1) = "<<f(2.0)<<std::endl; //OK, returns 4
std::cout<<"f(-1) = "<<f(-1.0)<<std::endl; //Throws runtime error, out of domain.
return 0;
}