函数对象的使用

//============================================================
// 关于版本的说明：
// 不同的版本由不痛的说明
// ver 1.0 是普通的运用函数指针来实现的
// ver 2.0 使用函数对象实现
// ver 3.0 主要使用了虚函数的抽象
// ver 4.0 是通过类模板来实现的，通过类模板实现的好处是，
// 曲线的存在函数可以独立在不同的类中，只要有一致的函数形式
// 形式是指函数返回值和参数类型一致，当然还可以由虚拟函数的重载
// 来实现多种参数函数的调用
// 这里计算的是一元的曲线
//===============================================================


#include <iostream>

using namespace std;

double aFunc( double x )
...{
    return x*x;
}

// ver 1.0使用普通的函数实现
//==============================================================
typedef double (*F)( double );
//计算积分 f是曲线表达式
double integrate( F f, double low, double high ) ...{
    const int numsteps = 100;
    double step = (high-low)/numsteps;
    double area = 0.0;
    while( low < high ) ...{
        area += f( low ) * step;
        low += step;
    }
    return area;
}
//===================================================================
// 2.0 使用函数对象实现
//====================================================================
class Fuc
...{
private:
    double (*m_f)(double);
public:
    Fuc(double(*f)(double)):m_f(f)...{}
    ~Fuc()...{}
    double operator()(double d)
    ...{
        return m_f(d);
    }
};
double integrate( Fuc& f, double low, double high ) ...{
    const int numsteps = 100;
    double step = (high-low)/numsteps;
    double area = 0.0;
    while( low < high ) ...{
        area += f( low ) * step;
        low += step;
    }
    return area;
}
//======================================================================
//ver 3.0 使用虚函数继承实现
//=====================================================================
class FucBase
...{
public:
    FucBase()...{}
    virtual ~FucBase()...{}
    virtual double operator()(double )=0;

};
class inte:public FucBase
...{
private:
    double (*m_f)(double);
public:
    inte(double(*f)(double)):m_f(f)...{}
    ~inte()...{}
    double operator()(double d)
    ...{
        return m_f(d);
    }

};

double integrate(FucBase& f, double low, double high )
...{
    const int numsteps = 1000;
    double step = (high-low)/numsteps; // 划分的区间个数，计算小矩形代替区边梯形
    double area = 0.0;
    while( low < high ) 
    ...{
        area += f(low) * step;
        low += step;
    }
    return area;
}
//================================================
// ver 4.0 通过模板+虚函数实现
//===============================================
class FucBase;
template<typename Obj>
class intetmpl:public FucBase
...{
private:
    double (Obj::*m_f)(double); //类的成员函数指针
    Obj & obj;
public:
    intetmpl(Obj & obj,double (Obj::*f)(double)):obj(obj),m_f(f)...{}
    ~intetmpl()...{}
    double operator()(double d)
    ...{
        return (obj.*m_f)(d); // 类成员函数的指针得到事偏移量，必须用类的实例来调用
    }

};
//模板测试类
class tst
...{
public:
    double fuc(double d) 
    ...{
        return d*d;
    }
};
class tst4
...{
public:
    double fuc(double d)
    ...{
        return d*d*d;
    }
};
//===================================================
int main()
...{
    cout << integrate(aFunc,0,2) << endl;
    Fuc fc(aFunc);
    cout << integrate(fc,0,2) << endl;
    inte b(aFunc);
    cout << integrate(b,0,2) << endl;
    tst4 t;
    intetmpl<tst4> ttml(t,tst4::fuc);
    cout << integrate(ttml,0,2) << endl;
    return 0;
}