ошибка: недопустимое новое выражение абстрактного типа класса
Привет всем, я получаю эту ошибку, пытаясь сделать мой файл CPP! Ошибка исходит из ROOT заголовка. Я понятия не имею, что делать. Большое спасибо!
/usr/include/root/Math/ParamFunctor.h:246:58: error: invalid new-expression of abstract class type ‘ROOT::Math::ParamFunctorHandler<ROOT::Math::ParamFunctor, double (*)(double*, double*)>’
fImpl(new ParamFunctorHandler<ParamFunctor,FreeFunc>(f))
^
мой ParamFunctor.h
class ParamFunctor {public:
typedef ParamFunctionBase Impl;/**
Default constructor
*/
ParamFunctor () : fImpl(0) {}/**
construct from a pointer to member function (multi-dim type)
*/
template <class PtrObj, typename MemFn>
ParamFunctor(const PtrObj& p, MemFn memFn)
: fImpl(new ParamMemFunHandler<ParamFunctor, PtrObj, MemFn>(p, memFn))
{}/**
construct from another generic Functor of multi-dimension
*/
template <typename Func>
explicit ParamFunctor( const Func & f) :
fImpl(new ParamFunctorHandler<ParamFunctor,Func>(f))
{}// specialization used in TF1
typedef double (* FreeFunc ) (double * , double *);
ParamFunctor(FreeFunc f) :
fImpl(new ParamFunctorHandler<ParamFunctor,FreeFunc>(f))
{
}/**
Destructor (no operations)
*/
virtual ~ParamFunctor () {
if (fImpl) delete fImpl;
}
/**
Copy constructor
*/
ParamFunctor(const ParamFunctor & rhs) :
fImpl(0)
{
// if (rhs.fImpl.get() != 0)
// fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Clone() );
if (rhs.fImpl != 0) fImpl = rhs.fImpl->Clone();
}
/**
Assignment operator
*/
ParamFunctor & operator = (const ParamFunctor & rhs) {
// ParamFunctor copy(rhs);
// swap auto_ptr by hand
// Impl * p = fImpl.release();
// fImpl.reset(copy.fImpl.release());
// copy.fImpl.reset(p);
if(this != &rhs) {
if (fImpl) delete fImpl;
fImpl = 0;
if (rhs.fImpl != 0)
fImpl = rhs.fImpl->Clone();
}
return *this;
}
Решение
Спасибо за быстрый ответ. Я новичок здесь, поэтому я не знаю много.
@Gover Nator Вот это Класс ParamFunctorHandler.
#ifndef __CINT__
template<class ParentFunctor, class Func >
class ParamFunctorHandler : public ParentFunctor::Impl {
typedef typename ParentFunctor::Impl Base;
public:
// constructor
ParamFunctorHandler(const Func & fun) : fFunc(fun) {}virtual ~ParamFunctorHandler() {}// for 1D functions
inline double operator() (double x, double *p) {
return fFunc(x,p);
}
// inline double operator() (double x, const double *p) const {
// return fFunc(x,p);
// }
// for multi-dimensional functions
// inline double operator() (const double * x, const double *p) const {
// return fFunc(x,p);
// }
inline double operator() (long double * x,long double *p) {
return FuncEvaluator<Func>::Eval(fFunc,x,p);
}
// clone (use same pointer)
ParamFunctorHandler * Clone() const {
return new ParamFunctorHandler(fFunc);
}private :
Func fFunc;
// structure to distinguish pointer types
template <typename F> struct FuncEvaluator {
inline static double Eval( F & f, double *x, double * p) {
return f(x,p);
}
};
template <typename F> struct FuncEvaluator<F*> {
inline static double Eval( F * f, double *x, double * p) {
return (*f)(x,p);
}
};
template <typename F> struct FuncEvaluator<F* const> {
inline static double Eval( const F * f, double *x, double * p) {
return (*f)(x,p);
}
};
// need maybe also volatile ?
};};
#endif
Другие решения
Других решений пока нет …