1

我正在为一个类编写一个 .hpp 文件，该类应该接收一个函数作为其参数之一并将其存储在一个成员变量中，到目前为止，我的代码如下所示：

template<typename Function> class myClass
{
  public:
           myClass(Function function) : pvFunction( function ) {}

           //Functor operator
           double operator() (double x) const{
             return pvFunction(x+4);
           }
  private:
           Function pvFunction
}

该程序看起来毫无意义，因为它返回的值现在并不重要。我只是想弄清楚如何将函数传递给这个类并使用它的仿函数运算符。唯一的问题是：

1）我不知道这个类的定义是否正确，这意味着这是接受任何类型的函数作为参数传递给这个类的对象的正确方法。

2）如何在我的程序中创建此类的实例？如何将函数传递给新对象然后调用它？

已经有一段时间了，似乎无法弄清楚

编辑：

在我的程序文件 main.cpp 中，此代码收到错误：

double function(double);

int main()
{
   myClass<double> myClassObject((function));
   return 0;
}

double function(double x)
{
   return (x+3.0);
}
4

4 回答 4

4

您收到一个错误，因为该类期望模板参数是实际的函数类型，但您double在实例化中传递了模板参数。

考虑使用 C++11 的新功能，例如std::function.

template<typename T>
struct myClass
{
    typedef std::function<T(T)> func_type;

    func_type pvFunction;

    myClass(func_type func) : pvFunction(func) {}

    T operator()(T x)
        { return pvFunction(x + 4); }
};

double function(double x)
{
    return (x+3.0);
}

int main()
{
    myClass<double> my_class(function);
    std::cout << "my_class(3) = " << my_class(3) << '\n';
}
于 2012-10-11T08:35:14.977 回答
1

1) 是的。

2）myClassObject你的例子中的类型应该是

 myClass<double(*)(double)> myClassObject(function);

因为函数是类型double(*)(double)。构造此类模板对象的最佳方法是使用如下函数模板：

template<typename Function>
myClass<Function> MakeMyClass(Function f)
{
    return myClass<Function>(f);
}


int main()
{
   auto withFuncPtr= MakeMyClass(function);
   auto withLambda= MakeMyClass([] (double v) {return v*2;});

   Foo foo;
   auto withStdFunction = MakeMyClass(
       std::bind(&Foo::Method, &foo, std::placeholders::_1));
   return 0;
}
于 2012-10-11T08:37:46.757 回答
0

您可以使用带有 operator() 的 struct 作为建议

template<typename Function> class myClass
{
  public:
        myClass(){}

        //Functor operator
        double operator() (double x) const
        {
          return pvFunction(x+4);
        }
  private:
        Function pvFunction;
};

struct Double
{
    double operator()(const double n)const
    {
        return n;
    }
};

int main() {
    myClass<Double> myClassObject;
    std::cout<<myClassObject(2.0f);
    return 0;
}

打印 6

于 2012-10-11T08:39:27.443 回答
0

我真的不确定你想要实现什么，因为如果你仍然想将任何函数绑定到具有双精度类型的参数，你怎么能使用它，但是，下面的示例使你的示例模板工作，但我真的不'看不到用途。

    template<typename Function> class myClass
    {
    public:
        myClass(Function function) : pvFunction( function ) {}

        //Functor operator
        double operator() (double x) const{
            return pvFunction(x+4);
        }
    private:
        Function pvFunction;
    };

    double foo1(double x)
    {
        return x;
    }

    double foo2(double x)
    {
        return x + 1;
    }
    int main(int argc, char** argv)
    {
        myClass<double(*)(double)> instance1(foo1);
        myClass<double(*)(double)> instance2(foo2);
        double a = instance1(1.5), b = instance2(1.5);
        return 0;
    }
于 2012-10-11T08:39:49.590 回答