Как повторно преобразовать шаблонную функцию из другой шаблонной функции в C ++

Question

Я пишу решатель для обыкновенных дифференциальных уравнений (ODE) и пытаюсь реализовать поведение во время выполнения, которое позволяет пользователю выбирать из нескольких решателей ODE, таких как прямой метод Эйлера, метод Рунге-Кутты второго и четвертого порядка.Я стараюсь использовать набор шаблонных функций, чтобы пользователь мог передавать переменные в решатель в виде карты, где ключ может быть 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>;

Удачи!