Question

我正在将lambda函数R1和R2传递给模板函数F。但是，我不确定是否正确执行了此操作。

函数F应该使用主函数中的所有参数并执行相关计算（牛顿法的根近似法）。

我是使用模板功能的新手。因此，我们将不胜感激。

//main.cpp
    #include <iostream>
    #include "Funct.h"
    using namespace std;

    int main()
    {

        auto f1 = [](long double x) { return (x * x) - 2; };
        auto f2 = [](long double x) { return (2 * x);
        auto RV1 = F<long double>(1.0L,1.0E-20L,f1(1.0L),f2(1.0L));
        return 0;


    }

    //Funct.h
    #include <iostream>
    #include<cmath>
    template<typename T> T F(long double guess, long double tolerance,T ((*f)(const T x)), T((*df)(const T x)));
    template<typename T> T F(long double guess, long double tolerance,T ((*f)(const T x)), T((*df)(const T x)))
    {

    }

Answer 1

首先，如@tkausl所述，在将lambda作为参数传递时，您不应调用lambda，因为这样会自动对lambda求值并产生值（在这种情况下为double），但是您的函数希望将函数作为a参数。

相反，您应该在被调用函数本身（在这种情况下为F）中调用作为参数给出的函数。

您可以使用std::function来描述函数原型，从而避免使用“难看的”函数指针。

首先，您需要包括标准库中的<functional>头文件。

然后您可以编写如下内容：

template <typename T>
using Func = std::function<T(T)>;

template <typename T>
T F(long double guess, long double tolerance, Func<T> f, Func<T> df);

在std::function<long double(long double)>中，括号中的类型表示函数参数的类型，括号前的类型表示函数原型的返回类型；

Answer 2

您可以使用：

template <typename F1, typename F2>
long double F(long double guess,
              long double tolerance,
              F1 f,
              F2 der)
{
    f(4.2); // call function
    def(4.2);
    // ...
}

用法类似于：

auto f = [](long double x) { return (x * x) - 2; };
auto derived = [](long double x) { return 2 * x; };
auto RV1 = F(1.0L, 1.0E-20L, f, derived);

Answer 3

这种老式风格可能仍然有帮助，例如在异步操作中。

void AsyncOperator(bool(*callback)(void*, void*), void* param)
{
   while(true)
   {
      if (specific_condition_is_met)
      {
         if (callback(any_result, param)==false)
            return;
      }
      else if (callback(any_result_again, param))
         break;
   }
}

将lambda函数作为参数C ++传递

3 个答案: