C++ C++；实例对象的函数指针

我有一个简单的模板类，它有两个函数指针和一个值。一个指针是比较运算符，另一个指针是对象（例如getX（））

标题：

template<class T>
class A {

public:
    A(T (*function)(), const bool (*op)(T,T),const T value) : 
        function(function), value(value), op(op){}
    bool valid();

private:
    T value;
    T (*function)();
    bool (*op)(T, T);
};

实际的头/类定义工作正常。问题是在创建一个实例时；它不起作用。我想这是因为'x->getX'，但是有什么方法可以实现我想要的吗

谢谢

编辑：：

确切的编译器错误如下所示：

....\Classes\Objects\B.cpp:42:错误：调用“A:：A（未解析重载函数类型，未解析重载函数类型，浮点）”时没有匹配的函数 …..\Classes\Objects/A.h:30:注：候选项是：A:：A（T（），const bool（）（T，T），T）[带T=float] ..\Classes\Objects/A.h:26:note:A:：A（常数A&）

请注意：如果可以使用C++11，则“x->getX”将返回一个浮点值：

做你想做的事情的方法是使用和

此外，如果要将比较运算符作为基本类型（int、float…）的参数传递，可以使用标头（std:：less、std:：greater…）中定义的

比较函数对象

#包括
#包括
模板
甲级{
公众：
A（std:：function，BinaryPredicate pred，const T value）：
函数（函数），pred（pred），值（值）{
bool-valid（）；
私人：
std：：函数；
二元谓词pred_；
T值；
};
模板
boola:：valid（）{
返回（pred_（函数_（），值_））；
}
X类{
私人：
浮阀；
公众：
X（float val）：val_（val）{}
float getX（）{return val_；}
};
内部主（空）
{
X（20）；
A（std:：bind（&X:：getX，&X），std:：equal_to（），20）；
std:：cout“不工作”是什么意思？函数指针不是函子。函子是一个重载
操作符（）
。改为函数指针的类。所谓“不工作”，我的意思是在创建A的实例时它不编译。粘贴到确切的编译器错误中<代码> GETX是一类方法。<代码> x/Cux>是该类的一个对象。不能将 x.GETX<／C>作为指针指向正常函数。它在C++中不工作，就像C语言中的委托。我想的最简单的方法是做一个包装器。在C++中一定有一些习惯用法，但是你需要。有人会用这种语言告诉你。
#include "A.h"

template<class T>
bool A<T>::valid(){
    return (op(function(),value));
}

A<float> a = A<float>(x->getX,operator==,20);

x->getX() == 20;

#include <functional>
#include <iostream>

template<class T, typename BinaryPredicate>
class A {

public:
    A(std::function<T()> function, BinaryPredicate pred,const T value) : 
        function_(function), pred_(pred), value_(value){}
    bool valid();

private:
    std::function<T()> function_;
    BinaryPredicate    pred_;
    T                  value_;
};

template<class T, typename BinaryPredicate>
bool A<T, BinaryPredicate>::valid(){
    return (pred_(function_(), value_));
}

class X {

   private:
   float val_;

   public:
   X(float val) : val_(val) {}

   float getX() {return val_;}
};

int main(void)
{
   X x(20);

   A<float, std::equal_to<float>> a(std::bind(&X::getX, &x), std::equal_to<float>(), 20);

   std::cout << std::boolalpha << a.valid() << std::endl;

   return (0);
}