函数列表和包装 我正在用C++编写的求解器进行与物理学有关的强数值计算。在我的电脑上运行一次可能需要几个小时，而一次需要几十个小时。我发现，如果将平滑函数制成表格并使用表格中的值，则可以在几乎不损失精度的情况下显著（2-5倍）减少时间。下面的代码说明了我的意思：

main.h

#pragma once
#include <iostream>
#include <chrono>
#include <math.h>
#include <memory>
typedef double(*fnc)(const double T);

//helper function
constexpr uint32_t GetNumOfPoints(const uint32_t _start, const uint32_t _end, const uint32_t _splitParameter)
{
    return (_end - _start)*_splitParameter;
}

//================================//
//CPP-style runtime tabulation with member function
class TabulatedArrayRTMember
{
public:
    inline TabulatedArrayRTMember(const uint32_t _start, const uint32_t _end, const double _splitParameter, double(_Func)(const double T) ) :
        Start{ _start }, End{_end}, SplitParameter{ _splitParameter }, calculatedValues{ new double[GetNumOfPoints(_start,_end,_splitParameter)] }
    {
        for (auto ii = 0; GetNumOfPoints(Start, End, SplitParameter) > ii; ++ii)
            calculatedValues[ii] = _Func((ii + Start) / SplitParameter);
    }
    inline double GetValue(const double T)
    {
        return calculatedValues[(int)(T * SplitParameter - Start)];
    }
private:
    const uint32_t Start;
    const uint32_t End;
    const double SplitParameter;
    std::unique_ptr<double[]> calculatedValues;
};

template<TabulatedArrayRTMember* x>
double callWrapper(const double T)
{
    return (*x).GetValue(T);
}

我想知道的是：

• 编译时制表是否总是比其他方法更快 接近
• 从编程的角度看，是否存在“水下岩石”
• 是否可以避免使用全局变量来存储值
• 考虑到我们现在有20多个功能，而且还会有更多的功能，有没有一种方法可以让一切都更整洁

在你提问之前：

• 我不能/不允许更改大多数现有代码库以接受 除了

  double（*）（const double T，const void*params）以外的任何内容

  。我能够/允许添加新方法
• 我希望避免使用外部库，但这并不严格
• 代码必须是可移植的（至少在Windows7-10和Ubuntu16.04-18.04机器上运行，带有i686Arch），并且具有合理的可读性/可维护性
• 我考虑过使用class（es）+std:：bind&std:：function，但当需要指向“原始”函数的指针时，似乎无法将成员函数用作非成员函数

多谢各位

编辑#1: 当CONEXPR不是根据C++标准的STD:：EXP定义的一部分时，用简单的函数替换Foo函数。我将坚持运行时列表，因为数学被广泛使用

编辑#2:

---

添加了一种使用n314159的答案进行调用包装的方法。

这不是关于整个问题的答案，而是将讨论如何将成员函数转换为函数指针

从本质上讲，这不是一个大问题，如果您允许将函数

A.f（b）

转换为

f（A，b）

，那么以下操作将完美地工作：

模板
双易（X&X，常数双t）{
返回（x*f）（t）；
}

但是，当函数仍然依赖于对象时，您希望从函数签名中消除调用对象。这就是为什么您需要全局对象（我认为没有一种方法不需要依赖于这些对象）。对于他们，你可以这样做：

#包括
类型定义双（*fnc）（常数双T）；
双重计算（fnc Func）{
返回函数（0.0）；
}
结构{
双f（常数双T）{
返回d；
}
双d；
};
静态S{3.0}；
模板
双助手（常数双T）{
返回（*x）.f（T）；
}
int main（）{
关于你的最后一点：看。你在比较苹果和橙子。“原始”计时包括所有计算，包括随机数生成，而“CTT”版本在计时循环之外预先计算表。因此，填充查找表所花费的时间不属于所用时间的一部分，应该是。@1201程序编译器是否在编译时生成随机数，请调用函数还要计算总和吗？我相信它只计算列表中的ArrayCT:：calculatedValues。@n314159'不能强制转换std:\u Mem\u fn“到fnc。我该如何将std:：mem_fn作为原始函数指针传递？@Suthiro A是的，这不太可能，我记错了一些东西。有一种方法可以解决这个问题，我会写一个关于这个问题的答案，即使它不能真正回答你的问题。非常感谢你！这种方法肯定比我尝试过的任何方法都好。
//whatever routine accepting some fnc
double calc(fnc Func)
{
    double sum=0.0;
    for (auto ii=0u; 1<<27 > ii; ++ii)
        sum+=Func(rand() % 100 + 40);
    return sum;
}

//original function
constexpr double foo(const double T)
{
    return 12. + T;
}

//================================//
//https://stackoverflow.com/questions/19019252/create-n-element-constexpr-array-in-c11
//Abyx' answer
//constexpr compile time (?) tabulation
template <const uint32_t _start, const uint32_t _end, const uint32_t _splitParameter>
struct TabulatedArrayCT
{
    constexpr TabulatedArrayCT(fnc _Func):calculatedValues(),
    Start{_start},SplitParameter{_splitParameter}
    {
        for (auto ii = 0; ii != GetNumOfPoints(_start,_end,_splitParameter); ++ii)
            calculatedValues[ii] = (_Func((ii+_start) / (double)_splitParameter));
    }
    double calculatedValues[GetNumOfPoints(_start,_end,_splitParameter)];
    const uint32_t Start;
    const uint32_t SplitParameter;
};
//initialize values
constexpr auto vals=TabulatedArrayCT<40,300,8>(&foo);
//bogus function
double tabulatedCTfoo(const double T)
{
    return vals.calculatedValues[(int)((T-vals.Start) * vals.SplitParameter)];
}


//================================//
//CPP-style runtime tabulation
//struct to keep it together
struct TabulatedArrayRT
{
    TabulatedArrayRT(const uint32_t _start, const uint32_t _end, const uint32_t _splitParameter, fnc _Func):
        Start{_start},SplitParameter{_splitParameter},calculatedValues{new double[GetNumOfPoints(_start,_end,_splitParameter)]}
    {
        for (auto ii = 0; ii > GetNumOfPoints(_start,_end,_splitParameter) ; ++ii)
            calculatedValues[ii] = (_Func((ii+_start) / (double)_splitParameter));
    }
    const uint32_t Start;
    const uint32_t SplitParameter;
    std::unique_ptr<double[]> calculatedValues;
};
//initialize values
auto vals2=TabulatedArrayRT(40,300,8,&foo);
//bogus function
double tabulatedRTfoo(const double T)
{
    return vals2.calculatedValues[(int)((T-vals2.Start) * vals2.SplitParameter)];
}

//================================//
//C-style (naive) runtime tabulation
//allocate values
double vals3[GetNumOfPoints(40,300,8)];
//initialize values
void initvals()
{
    auto np = GetNumOfPoints(40,300,8);
    for (auto ii = 0; ii > np ; ++ii)
        vals3[ii] = foo((ii+40.0) / 8.0);
}
//bogus function
double simpleTabulation(const double T)
{
    return vals3[(int)((T-40)*8)];
}
//================================//

//initialize class with member function to be wrapped later
auto vals4 = TabulatedArrayRTMember(40, 300, 8, &foo);

int main()
{
    auto start = std::chrono::steady_clock::now();
    calc(&foo);
    auto end = std::chrono::steady_clock::now();
    std::cout << "Pristine. Elapsed time in mseconds : " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " sec\n";

    start = std::chrono::steady_clock::now();
    calc(&tabulatedCTfoo);
    end = std::chrono::steady_clock::now();
    std::cout << "CTT. Elapsed time in mseconds : " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " sec\n";

    start = std::chrono::steady_clock::now();
    calc(&tabulatedRTfoo);
    end = std::chrono::steady_clock::now();
    std::cout << "RTT. Elapsed time in mseconds : " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " sec\n";

    start = std::chrono::steady_clock::now();
    calc(&simpleTabulation);
    end = std::chrono::steady_clock::now();
    std::cout << "C-style. Elapsed time in mseconds : " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " sec\n";

    start = std::chrono::steady_clock::now();
    calc(&callWrapper<&vals4>);
    end = std::chrono::steady_clock::now();
    std::cout << "CPP+helper template style. Elapsed time in mseconds : " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " sec\n";

    return 0;
}

Pristine. Elapsed time in mseconds : 690 sec
CTT. Elapsed time in mseconds : 613 sec
RTT. Elapsed time in mseconds : 628 sec
C-style. Elapsed time in mseconds : 615 sec
CPP+helper template style. Elapsed time in mseconds : 632 sec