Question

我有一个函数，我使用一个常量数组：

void function(int Id){
int array1[4] = {4 constants};
int array2[4] = {4 constants};
   for(int i=0; i<4; i++){
   //accessing the array 1&2 for computation;
   }
}

从void function(int Id)访问main()将近百万次。

我的问题是，在头文件中声明array1和array2以及在function()内访问是否更好，或者现在就像现在一样声明它们更好？

哪种方式会更快（考虑从头文件访问或动态声明）？

编辑：只能在function()内访问和修改数组。

Answer 1

如果数组不会改变，并且不会在另一个函数中重用，那么最好将它们设置为静态。这避免了在每次调用函数时都需要在堆栈上构造数组。

void function(int Id){
    static const int array1[4] = {4 constants};
    static const int array2[4] = {4 constants};
    for(int i=0; i<4; i++){
        //accessing the array 1&2 for computation;
   }
}

编辑添加最好避免在数组声明和循环表达式中使用“幻数”4。如果没有这样做，很容易改变数组大小，忘记更改循环表达式。这可以通过使数组大小为常量，或者在循环表达式中使用sizeof（）来完成，如此堆栈溢出问题所示：How do I determine the size of my array in C?

Answer 2

我认为最好的方法是：

void function(int Id){
    static const int array1[4] = {4 constants};
    static const int array2[4] = {4 constants};
   for(int i=0; i<4; i++){
   //accessing the array 1&2 for computation;
   }
}

但最好只做一个小测试，看看哪一个是最快的。 Raxvan。

Answer 3

我猜没有区别。你可能想写：

**const** int array1[4]

更好地向编译器解释你的意思。这可能会为其提供更多选择以进行优化。

Answer 4

我尝试了一个测试用例，它比较了三个选项 - global, local, local static，用于4d向量的简单向量内积的大约2000万个操作。这是在VS2010 32位版本上完成的。结果如下：

DPSUM：600000000时间：78 | DPSUM：600000000时间：62 | DPSUM：6亿时间：63 | DPSUM：600000000时间：47 | DPSUM：600000000时间：46 | DPSUM：600000000时间：78 | DPSUM：600000000时间：47 | DPSUM：6亿时间：47 | DPSUM：600000000时间：78 | DPSUM：600000000时间：47 | DPSUM：600000000时间：47 | DPSUM：600000000时间：62 | DPSUM：6亿时间：62 | DPSUM：600000000时间：47 | DPSUM：600000000时间：63 | DPSUM：600000000时间：46 | DPSUM：600000000时间：63 | DPSUM：6亿时间：62 | DPSUM：600000000时间：47 | DPSUM：600000000时间：47 | DPSUM：600000000时间：78 | DPSUM：600000000时间：47 | DPSUM：6亿时间：46 | DPSUM：600000000时间：78 | DPSUM：600000000时间：47 | DPSUM：600000000时间：47 | DPSUM：600000000时间：62 | DPSUM：6亿时间：63 | DPSUM：600000000时间：47 | DPSUM：600000000时间：62 |

第一列是static const，第二列是local，第三列是global。如果您想尝试使用您的平台，我将发布示例代码。看起来static local和local同样快 - 至少对于这个编译器而言（可能是由于一些内部优化。

以下代码：

#include <stdio.h>
#include <windows.h>

int ag[] = {1,2,3,4}; int bg[] = {1,2,3,4};
int dp1(){
    static const int a[] = {1,2,3,4}; static const int b[] = {1,2,3,4};
    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3];
}

int dp2(){
    int a[] = {1,2,3,4}; int b[] = {1,2,3,4};
    return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3];
}

int dp3(){
    return ag[0]*bg[0] + ag[1]*bg[1] + ag[2]*bg[2] + ag[3]*bg[3];
}

int main(){
    int numtrials = 10;
    typedef int (*DP)();
    DP dps[] = {dp1, dp2, dp3};

    for (int t = 0; t < numtrials; ++t){
        int dpsum[] = {0,0,0};
        for (int jj =0; jj <3; ++jj){
            DWORD bef, aft;
            bef = GetTickCount();
            for (int ii =0; ii< 20000000; ++ii){
                dpsum[jj] += dps[jj]();
            }
            aft = GetTickCount();
            printf("DPSUM:%d TIME:%d| ", dpsum[jj], aft - bef);
        }
        printf("\n");
    }
    getchar();
}

哪种方式更适合阵列访问？

4 个答案: