Question

我正在编写一个用于常微分方程（ODE）的求解器，并试图实现允许用户从多个ODE求解器中进行选择的运行时行为，例如正向Euler方法，二阶和四阶Runge-Kutta方法。我正在努力使用一组模板函数，以便用户可以将变量作为映射传递给求解器，其中的键可以是int，char或std::string。另外，关联的值可以是float或double。在名为ode_solver()的成员函数中，我需要将变量class_func设置为等于求解器函数之一，它们是euler_method，rk2_method或rk4_method；但是，由于这些函数未模板化，因此我收到了消息Variable 'class_func' with type auto has incompatible initializer of type <overloaded>。我确信这是由于C ++不允许我为函数动态分配类型。下面提供了代码。有没有一种方法可以启用我在此问题中尝试的行为，还是我不得不放弃模板并仅对数据类型进行硬编码？ .hpp文件中所有大写字母突出显示了代码有问题的区域。我正在使用C ++ 17编译器。

// main.cpp
#include "test.hpp"
#include <iostream>
#include <math.h>
#include <map>
#include <tuple>

double func6(std::map<char, double> arr);

int main(int argc, const char * argv[]) {

    ODESolver q;
    // Code inputs
    std::map<char, double> inputs;
    inputs['x'] = 2.0;
    inputs['y'] = g.e;

    double unc = 0.001;
    double tol = 0.0;
    double step_size = 0.1;
    double start = 2.0;
    double stop = 3.0;
    std::string func_name("Euler");
    std::tuple<std::vector<double>, std::vector<double>> res;
    res = q.new_ode_solver(step_size, start, stop, tol, func_name,
                           inputs, func6);
}

double func6(std::map<char, double> arr)
{
    return arr['y'] * MathKernels::logr(arr['y']) / arr['x'];
}

头文件是;

class ODESolver
{
public:

    template<class char_type, class real_type, class F>
    static inline std::tuple<std::vector<real_type>, std::vector<real_type>>
    ode_solver(real_type step_size, real_type start, real_type stop,
                   real_type error, std::string func_name,
                   std::map<char_type, real_type> &inputs,
                   const F& func)
    {
        // Verify that a correct function name was passed
        if (func_name != "Euler" and func_name != "RK2" and func_name != "RK4")
        {
            std::cout << "FATAL ERROR: ODE Solver Name must be 'Euler', 'RK2' or 'RK4'" << std::endl;
            exit (EXIT_FAILURE);
        }

        // Determine which ODE Solver to use
        // - THIS IS THE PROBLEM, THE COMPILER CANNOT DEDUCE
        //   THE TYPE FROM THE STATEMENT BELOW.
        auto class_func = &ODESolver::euler_method;

        std::tuple<real_type, real_type> res;
        std::vector<char_type> keys;
        std::vector<real_type> x_var;
        std::vector<real_type> y_var;

        keys = get_keys(inputs);
        std::cout << keys[0] << std::endl;

        // Solve ODE
        x_var.push_back(inputs[keys[0]]);
        y_var.push_back(inputs[keys[1]]);
        real_type time = start;
        while (time < stop)
        {
            res = class_func(func, step_size, inputs, keys, error);
            y_var.push_back(std::get<0>(res));
            step_size = std::get<1>(res);
            x_var.push_back(time);
            time += step_size;
            inputs[keys[0]] += step_size;
            inputs[keys[1]] = std::get<0>(res);
        }
        std::tuple<std::vector<real_type>, std::vector<real_type>> value(x_var, y_var);
        return value;
    }
// ================================================================

    template<class char_type, class real_type, class F>
    static inline std::tuple<real_type, real_type>
    euler_method(real_type step_size, std::map<char_type, real_type> inputs,
                 real_type keys, real_type error,
                 const F& func)
    {
        real_type dydx = func(inputs);
        real_type value = inputs[keys[1]] + step_size * dydx;
        std::tuple<real_type, real_type> vals(value, step_size);
        return vals;
    }
// ================================================================
// ================================================================

private:
    template<class char_type, class real_type>
    static inline std::vector<char_type> get_keys(std::map<char_type, real_type> &arr)
    {
        std::vector<char_type> keys;
        for (typename std::map<char_type, real_type>::iterator it = arr.begin();
             it != arr.end(); it++)
        {
            keys.push_back(it -> first);
        }
        return keys;
    }
};

Answer 1

就像其他人提到的那样，您正在尝试存储功能的地址，但是分配无法分配功能模板的地址！
只需指定模板参数，由于这些参数已经存在于ode_solver函数模板中（除非不需要这样做），您可以直接在euler_method函数模板中使用它们。快速修复如下：

auto class_func = &ODESolver::euler_method<char_type, real_type, F>;

此外，因为它属于同一类：

auto class_func = &euler_method<char_type, real_type, F>;

祝你好运！

如何从C ++中的另一个模板函数重新投射一个模板函数

1 个答案: