Re: pointers to member functions

Thanks a lot Victor and Alf. In the meantime i've found the following
solution.
It works, but I don't know exactly how and why.

I've defined two auxiliary classes:

class func {
    public:
        func() {};
        virtual ~func() {};
        virtual const T_float operator() (const T_float x) = 0;
        /*virtual const array_1* operator() (const array_1 &vx) = 0;*/
};

// Wrapper for class functions

template <class T>
class Regular_func : public func {
    public:
        typedef T_double (T::*func_ptr)(double);
              //
        Regular_func() {}
        explicit Regular_func(T *t, func_ptr fun) { T_pointer=t; f = fun;}
        const T_float operator() (const T_float x) { return
(T_pointer->*f)(x); }
    private:
        T *T_pointer;
        func_ptr f;
};

and in my CrossSection class i do this:

class CrossSection {
    public:
        // ctor(), dtor()
        double getValue(double x) { /* code */ }
        T_float integrate(double a, double b) {
                double result, error;
                            Regular_func<X> f(this,&X::getValue);
                integration_adapt1 (&f,a, b,&result,&error);
                            if(error<=1e-10)
                        return result;
                            else
                                    HANDLE_ERROR("not converged",
E_NOT_CONV); <-stupid macro that abort()
        }
              private:
              // data
};

and obviously i've changed all the declarations of the C functions so
that they accept
pointers to the base class func. The syntax inside the C functions does
not change, neither
internal calls to integration subfunctions.

So this work, but for now i've not idea about efficiency issues. How
many times a pointer to
class func get deferenced before the actual value calculation?

*f(x) -> operator()(x) -> T_pointer->getValue(x) -> body of the real
function

it should be 3 times? or more ?
Thanks a lot