C++ 为指针或标量优化函数

我有一个复杂的程序，我正试图优化。经过一些测试，我分离出一个函数，如下所示：

void sum(int* res, int* a, int* b, int size){
    for (int i=0;i<size;i++){
       res[i] = a[i] * (b[i]+1);
    }
}

void sum（int*res，int*a，int*b，int size）{
对于（int i=0；i而言，这里的想法只是将
sum
作为一个模板，并考虑实现之间的差异，即数组或标量访问：

namespace detail_arrayish {
    template <class T>
    auto &access(T &single, int) {
        return single;
    }

    template <class T>
    auto &access(T *array, int n) {
        return array[n];
    }
}

template <class A, class B>
void sum(int* res, A a, B b, int size) {
    using detail_arrayish::access;

    for (int i=0;i<size;i++){
       res[i] = access(a, i) * (access(b, i) + 1);
    }
}

名称空间详细信息\u arrayish{
模板
自动存取（T&single，int）{
返回单；
}
模板
自动存取（T*数组，int n）{
返回数组[n]；
}
}
模板
无效和（整数*res，A A，B B，整数大小）{
使用detail_arrayish:：access；
对于（int i=0；i而言，这里的想法只是将
sum
作为一个模板，并考虑实现之间的差异，即数组或标量访问：

namespace detail_arrayish {
    template <class T>
    auto &access(T &single, int) {
        return single;
    }

    template <class T>
    auto &access(T *array, int n) {
        return array[n];
    }
}

template <class A, class B>
void sum(int* res, A a, B b, int size) {
    using detail_arrayish::access;

    for (int i=0;i<size;i++){
       res[i] = access(a, i) * (access(b, i) + 1);
    }
}

名称空间详细信息\u arrayish{
模板
自动存取（T&single，int）{
返回单；
}
模板
自动存取（T*数组，int n）{
返回数组[n]；
}
}
模板
无效和（整数*res，A A，B B，整数大小）{
使用detail_arrayish:：access；
对于（inti=0；i，假设函数的行为复杂，但术语相对简单，不一定需要模板，重载正确的因子分解就足够了

例如

无效和（int*res，int a，int b，int i）{
//这里是复函数
res[i]=a*（b+1）；
}
无效和（int*res、int*a、int*b、int-size）{
对于（inti=0；i，假设函数的行为复杂，但术语相对简单，不一定需要模板，重载正确的因子分解就足够了

例如

无效和（int*res，int a，int b，int i）{
//这里是复函数
res[i]=a*（b+1）；
}
无效和（int*res、int*a、int*b、int-size）{
对于（int i=0；iIt很难说。你能提供一些导致错误的东西吗？从你在这里展示的内容来看，我知道这并不完全相同，重载应该已经解决了问题。你想优化速度或大小吗？是的。重载工作得很好。但我不喜欢我必须重复实现三次的事实s、 真正的程序更复杂，因此重复执行3次是相当麻烦的维护工作。@AndyG我认为想法是共享实现，而不是将其分配到三个版本中的一个。@Adrian Maire，我想优化速度。我并不特别关心可执行文件的大小。但我不想维护它在函数的三个几乎相同的版本中。很难说。你能提供一些导致错误的东西吗？从你在这里展示的内容来看，我知道这并不完全相同，重载应该已经解决了问题。你想优化速度或大小吗？是的。的确。重载工作得很好。但我不喜欢我这样做“我必须重复执行三次。真正的程序更复杂，因此重复执行三次是相当麻烦的维护工作。@AndyG我认为想法是共享执行，而不是分派到三个版本中的一个。@Adrian Maire，我想优化速度。我不特别关心执行的大小。”可编辑。但我不想维护三个几乎相同的函数版本。太好了。我对您的解决方案做了一些修改，使其始终使用索引器，请参阅。我想我的代码也应该由现代编译器优化。@Tohiko！现代编译器不是很漂亮吗；）太好了。我对您的解决方案做了一些修改，使其始终使用索引器，请参阅。我想我的代码也应该由现代编译器进行优化。@Tohiko！现代编译器不是很漂亮吗；）
namespace detail_arrayish {
    template <class T>
    auto &access(T &single, int) {
        return single;
    }

    template <class T>
    auto &access(T *array, int n) {
        return array[n];
    }
}

template <class A, class B>
void sum(int* res, A a, B b, int size) {
    using detail_arrayish::access;

    for (int i=0;i<size;i++){
       res[i] = access(a, i) * (access(b, i) + 1);
    }
}

void sum(int* res, int a, int b, int i){
    // your complex function here
    res[i] = a * (b+1);
}


void sum(int* res, int* a, int* b, int size){
    for (int i=0; i<size; ++i){
       sum(res, a[i], b[i], i)
    }
}

void sum(int* res, int* a, int b, int size){
    for (int i=0; i<size; ++i){
       sum(res, a[i], b, i)
    }
}

void sum(int* res, int a, int* b, int size){
    for (int i=0; i<size; ++i){
       sum(res, a, b[i], i)
    }
}