一个很好的C可变长度数组示例[关闭]

这个问题在SO上引起了不小的反响，所以我决定在那里删除它，然后在这里尝试。如果您认为它也不适合此处，请至少对如何找到我所追求的示例提出建议...

您能举个例子吗，使用C99 VLA相对于当前的标准堆（使用C ++ RAII机制）提供了真正的优势？

我遵循的示例应：

1. 与使用堆相比，可轻松实现（可能达到10％）的性能优势。
2. 没有一个好的解决方法，它根本不需要整个数组。
3. 实际受益于使用动态尺寸，而不是固定的最大尺寸。
4. 在正常使用情况下，不太可能导致堆栈溢出。
5. 足够强大，足以吸引需要性能的开发人员在C ++项目中包含C99源文件。

在上下文中添加了一些说明：我的意思是C99所指的VLA，但不包括在标准C ++中：int array[n]这里n是变量。在一个用例示例中，我胜过其他标准（C90，C ++ 11）提供的替代方案：

int array[MAXSIZE]; // C stack array with compile time constant size
int *array = calloc(n, sizeof int); // C heap array with manual free
int *array = new int[n]; // C++ heap array with manual delete
std::unique_ptr<int[]> array(new int[n]); // C++ heap array with RAII
std::vector<int> array(n); // STL container with preallocated size

一些想法：

• 带有varargs的函数，自然会将项目数限制为合理，但没有任何有用的API级别上限。
• 递归函数，不需要浪费堆栈
• 许多小的分配和发行，堆开销会很糟糕。
• 处理性能至关重要的多维数组（如任意大小的矩阵），小型函数有望内联很多。
• 注释：并发算法，堆分配具有同步开销。

维基百科有一个不符合我标准的示例，因为至少在没有上下文的情况下，使用堆的实际区别似乎无关紧要。这也是不理想的，因为如果没有更多的上下文，看来项目计数很可能会导致堆栈溢出。

注意：我特别关注示例代码，或者是从中受益的算法建议，让我自己实现示例。

我只是破解了一个小程序，该程序会生成一组随机数，每次都会在相同的种子处重新启动，以确保其“公平”和“可比”。在进行过程中，它将计算出这些值的最小值和最大值。而当它已经产生的一组数字，它计算多少都高于平均水平的min和max。

对于VERY小型阵列，VLA的over具有明显的好处std::vector<>。

这不是一个真正的问题，但是我们可以轻松地想象一下，我们将从一个小文件中读取值，而不是使用随机数，并使用相同类型的代码进行其他更有意义的计数/最小/最大计算。

对于相关函数中非常小的“随机数数量”（x）值，该vla解决方案大获全胜。随着大小变大，“获胜”会变小，并且给定足够的大小，矢量解似乎更有效率-不必过多研究该变体，因为当我们在VLA中开始有成千上万个元素时，真的是他们的本意...

而且我敢肯定有人会告诉我，有一些方法可以用一堆模板编写所有这些代码，并且可以在不运行RDTSC和cout运行时运行更多代码的情况下完成此工作……但是我认为那不是真的重点。

运行此特定变体时，我在func1（VLA）和func2（std :: vector）之间得到大约10％的差异。

count = 9884
func1 time in clocks per iteration 7048685
count = 9884
func2 time in clocks per iteration 7661067
count = 9884
func3 time in clocks per iteration 8971878

编译为： g++ -O3 -Wall -Wextra -std=gnu++0x -o vla vla.cpp

这是代码：

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstdlib>

using namespace std;

const int SIZE = 1000000;

uint64_t g_val[SIZE];


static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}


int func1(int x)
{
    int v[x];

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}

int func2(int x)
{
    vector<int> v;
    v.resize(x); 

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v[i] = rand() % x;
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

int func3(int x)
{
    vector<int> v;

    int vmax = 0;
    int vmin = x;
    for(int i = 0; i < x; i++)
    {
        v.push_back(rand() % x);
        if (v[i] > vmax) 
            vmax = v[i];
        if (v[i] < vmin) 
            vmin = v[i];
    }
    int avg = (vmax + vmin) / 2;
    int count = 0;
    for(int i = 0; i < x; i++)
    {
        if (v[i] > avg)
        {
            count++;
        }
    }
    return count;
}    

void runbench(int (*f)(int), const char *name)
{
    srand(41711211);
    uint64_t long t = rdtsc();
    int count = 0;
    for(int i = 20; i < 200; i++)
    {
        count += f(i);
    }
    t = rdtsc() - t;
    cout << "count = " << count << endl;
    cout << name << " time in clocks per iteration " << dec << t << endl;
}

struct function
{
    int (*func)(int);
    const char *name;
};


#define FUNC(f) { f, #f }

function funcs[] = 
{
    FUNC(func1),
    FUNC(func2),
    FUNC(func3),
}; 


int main()
{
    for(size_t i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++)
    {
        runbench(funcs[i].func, funcs[i].name);
    }
}

关于VLA与向量

您是否认为Vector可以利用VLA本身。没有VLA，向量必须指定数组的某些“比例”，例如10、100、10000进行存储，因此最终需要分配10000个项目的数组来容纳101个项目。使用VLA，如果将大小调整为200，则算法可能会假设您只需要200，并且可以分配200个项目数组。或者它可以分配一个缓冲区，例如n * 1.5。

无论如何，我会争辩说，如果您知道在运行时需要多少个项目，那么VLA的性能会更高（如Mats的基准测试所示）。他演示了一个简单的两遍迭代。想想一下蒙特卡洛模拟（其中重复采样随机样本）或图像处理（如Photoshop滤镜），其中对每个元素进行多次计算，并且很可能对每个元素进行的每次计算都涉及查看邻居。

从向量跳转到其内部数组的额外指针累加起来。

回答主要问题

但是，当您谈论使用动态分配的结构（如LinkedList）时，没有可比性。数组使用指针算术对其元素进行直接访问。使用链表，您必须遍历节点才能到达特定元素。因此，在这种情况下，VLA胜出了。

根据此答案，它在体系结构上是相关的，但是在某些情况下，由于堆栈在缓存中可用，因此堆栈上的内存访问会更快。如果有很多因素，这可以被否定（这可能是Mats在基准测试中看到的收益递减的原因）。但是，值得注意的是，高速缓存的大小正在显着增长，并且您可能会看到更多的相应增长。

使用VLA的原因主要是性能。忽略Wiki示例仅具有“无关”差异是错误的。我可以很容易地看到某些情况下，确切的代码可能会有很大的不同，例如，如果该函数在紧密循环中被调用，那么read_val在某些速度至关重要的系统上，IO函数会很快返回。

实际上，在大多数以这种方式使用VLA的地方，它们不会替换堆调用，而是替换如下内容：

float vals[256]; /* I hope we never get more! */

关于任何本地声明的事情是，它非常快。该行float vals[n]通常只需要几个处理器指令（可能只有一个）。它只是将值添加n到堆栈指针中。

另一方面，堆分配需要遍历数据结构以找到可用区域。即使在最幸运的情况下，时间也可能要长一个数量级。（即放在n堆栈上并进行调用的行为malloc可能是5-10条指令。）如果堆中有足够数量的数据，则可能会更糟。看到malloc一个实际程序中的速度慢100到1000倍的情况，这一点都不令我感到惊讶。

当然，匹配也会对性能产生影响，其free大小可能与malloc调用相似。

此外，还有内存碎片的问题。很多小的分配往往会使堆碎片化。碎片堆既浪费内存，又增加了分配内存所需的时间。