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

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 2

由於類預期模板參數爲實際函數類型，但您在實例化中將模板參數作爲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 3

您可以使用結構與運營商（）的建議

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

我真的不確定你想要實現什麼，因爲如果你仍然想要將它綁定到具有雙參數類型的函數，你怎麼能使用任何函數，但是，下面的例子使你的示例模板能夠工作，但我真的不'沒有看到使用。

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