接受任何類型的函數作為參數的C ++類

Question

我正在為一個類編寫一個.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);
}

Answer 1

因為類期望模板參數是實際的函數類型，所以會出現錯誤，但是您在實例化中將模板參數傳遞為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';
}

Answer 2

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;
}

Answer 3

您可以將struct與operator（）一起使用作為建議

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

Answer 4

我真的不確定要實現什么，因為如果您仍然想將其綁定為具有double類型的參數類型，那么該如何使用任何函數，但是下面的示例使您的示例模板正常工作，但是我真的不知道看不到用途。

    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;
    }