Question

在我自己写作之前，我会问你们所有人。

我正在寻找一个几乎完全像STL向量的C ++类，但是将数据存储到堆栈中的数组中。某种类型的STL分配器类也可以工作，但我试图避免任何类型的堆，甚至是静态分配的每线程堆（尽管其中一个是我的第二选择）。堆栈效率更高。

对于使用向量的当前代码，它几乎需要替代。

对于我自己要写的东西，我在考虑这样的事情：

char buffer[4096];
stack_vector<match_item> matches(buffer, sizeof(buffer));

或者类可以在内部分配缓冲区空间。然后它看起来像：

stack_vector<match_item, 256> matches;

我认为如果空间不足，它会抛出std :: bad_alloc，尽管这不应该发生。

更新

使用Chromium的stack_container.h效果很好！

我之所以没想过这样做的原因是我总是忽略了STL集合构造函数的allocator对象参数。我已经使用了几次模板参数来做静态池，但是我从未见过代码或写过任何实际使用过对象参数的代码。我学到了新东西。很酷！

代码有点乱，由于某种原因，GCC强迫我将分配器声明为实际项而不是将其构造为vector的allocator参数。它来自这样的事情：

typedef std::pair< const char *, const char * > comp_list_item;
typedef std::vector< comp_list_item > comp_list_type;

comp_list_type match_list;
match_list.reserve(32);

对此：

static const size_t comp_list_alloc_size = 128;
typedef std::pair< const char *, const char * > comp_list_item;
typedef StackAllocator< comp_list_item, comp_list_alloc_size > comp_list_alloc_type;
typedef std::vector< comp_list_item, comp_list_alloc_type > comp_list_type;

comp_list_alloc_type::Source match_list_buffer;
comp_list_alloc_type match_list_alloc( &match_list_buffer );
comp_list_type match_list( match_list_alloc );
match_list.reserve( comp_list_alloc_size );

每当我宣布一个新的时候我都要重复一遍。但它的工作方式就像我想要的那样。

我注意到stack_container.h定义了StackVector，我尝试使用它。但它不会从vector继承或定义相同的方法，因此它不是替代品。我不想使用向量重写所有代码，所以我放弃了它。

Answer 1

您不必编写全新的容器类。您可以坚持使用STL容器，但更改例如std::vector的第二个参数，以便为其提供从堆栈缓冲区分配的自定义分配器。铬作者为此写了一个分配器：

https://chromium.googlesource.com/chromium/chromium/+/master/base/stack_container.h

它的工作原理是分配一个缓冲区，你可以说它有多大。您创建容器并调用container.reserve(buffer_size);。如果溢出该大小，分配器将自动从堆中获取元素（因为它是从std::allocator派生的，在这种情况下它将只使用标准分配器的工具）。我没有尝试过，但看起来它来自谷歌，所以我觉得值得一试。

用法是这样的：

StackVector<int, 128> s;
s->push_back(42); // overloaded operator->
s->push_back(43);

// to get the real std::vector. 
StackVector<int, 128>::ContainerType & v = s.container();
std::cout << v[0] << " " << v[1] << std::endl;

Answer 2

似乎boost::static_vector正是您所寻找的。来自文档：

static_vector是向量和数组之间的混合：与向量一样，它是一个具有连续存储的序列容器，可以改变大小，以及静态分配，低开销和固定容量的数组。 static_vector基于Adam Wulkiewicz和Andrew Hundt的高性能varray类。

static_vector中的元素数量可能会动态变化到固定容量，因为元素与数组类似地存储在对象本身中。

Answer 3

您可能需要查看的一些选项：

Matthew Wilson（Imperfect C ++的作者）的STLSoft有一个auto_buffer模板类，它将一个默认数组放在堆栈上，但是如果它增长到大于堆栈分配将从堆中获取内存。我喜欢这个类 - 如果你知道你的容器大小通常会受到一个相当低的限制，那么你就可以获得一个本地堆栈分配数组的速度。但是，对于需要更多内存的极端情况，它仍能正常工作。

http://www.stlsoft.org/doc-1.9/classstlsoft_1_1auto__buffer.html

请注意，我自己使用的实现不是STLSoft，而是一种从中大量借用的实现。

“Lazy Programmer”为使用alloca()存储的容器实现了一篇文章。我不是这种技术的粉丝，但我会让你自己决定它是否是你想要的：

http://tlzprgmr.wordpress.com/2008/04/02/c-how-to-create-variable-length-arrays-on-the-stack/

然后有boost::array没有前两个的动态大小调整行为，但是提供了更多的vector接口，而不仅仅是使用指针作为内置数组获得的迭代器（即，你得到begin()，end()，size()等等）：

http://www.boost.org/doc/libs/1_37_0/doc/html/boost/array.html

Answer 4

您可以使用自己的std :: vector分配器，让它分配基于堆栈的存储块，类似于您的示例。 allocator类是模板的第二部分。

编辑：我从未尝试过这个，看着文档进一步让我相信你不能编写自己的分配器。我还在调查它。

Answer 5

如果速度很重要，我会看到运行时间

4 ns int [10]，堆栈上的固定大小
40 ns <vector>
1300 ns <stlsoft/containers/pod_vector.hpp>

下面的一个愚蠢的测试 - 只需2推，v [0] v [1]，2 pop，在一个平台上，mac ppc，仅限gcc-4.2 -O3。（我不知道Apple是否优化了他们的版本。）

不接受任何你没有伪造的时间。当然，每种使用模式都不同。尽管如此，因素> 2让我大吃一惊。

（如果mems，内存访问，是运行时的主要因素，什么是各种实现中的额外mems？）

#include <stlsoft/containers/pod_vector.hpp>
#include <stdio.h>
using namespace std;

int main( int argc, char* argv[] )
{
        // times for 2 push, v[0] v[1], 2 pop, mac g4 ppc gcc-4.2 -O3 --
    // Vecint10 v;  // stack int[10]: 4 ns
    vector<int> v;  // 40 ns
    // stlsoft::pod_vector<int> v;  // 1300 ns
    // stlsoft::pod_vector<int, std::allocator<int>, 64> v;

    int n = (argv[1] ? atoi( argv[1] ) : 10) * 1000000;
    int sum = 0;

    while( --n >= 0 ){
        v.push_back( n );
        v.push_back( n );
        sum += v[0] + v[1];
        v.pop_back();
        v.pop_back();
    }
    printf( "sum: %d\n", sum );

}

Answer 6

tr1 :: array与您的描述部分匹配。它缺少诸如push ___ back（）之类的东西，但它可能值得一看作为起点。包装它并向“back”添加索引以支持push_back（）等应该相当容易。

Answer 7

为什么要特别将它放在堆栈上？如果你有一个alloca（）的实现，你可以使用它而不是malloc（）来构建一个类分配器，但你使用静态分配的数组的想法更好：它在大多数体系结构上都快，而你没有风险堆栈腐败你搞砸了。

Answer 8

您可能正在使用Qt。那么您可能想要QVarLengthArray（docs）。它基本上位于std::vector和std::array之间，静态分配一定数量，并在必要时回退到堆分配。

如果我使用的话，我更喜欢升级版。

Answer 9

Boost有这个。它被称为small_vector

small_vector是一个类似矢量的容器，针对它的情况进行了优化   包含很少的元素。它包含一些预分配的元素   就地，这允许它避免使用动态存储   当实际元素数低于该数时，分配   预分配阈值。 small_vector的灵感来自LLVM的SmallVector   容器。与static_vector不同，small_vector的容量可以增长   超出最初的预分配能力。

small_vector可转换为small_vector_base，这是一种独立于预分配元素的类型   count，允许不需要模板化的客户端代码   N论点。 small_vector继承了所有vector的成员函数   支持所有标准功能，如安置，有状态分配器，   等

Answer 10

如果您想在堆栈上进行分配但不希望在编译时预先定义最大大小，则可以使用StackVector，这是一个可以像这样使用的小实现：

new_stack_vector(Type, name, size)

其中Type是向量中元素的类型，name是向量的变量名，size是向量中允许的最大元素数。< / p>

size可以是变量，不需要是编译时常量！：d

示例：

new_stack_vector(int, vec, 100); //like vector<int> vec; vec.reserve(100); but on the stack :) vec.push_back(10); //added "10" as the first item in the vector

......那就是全部！

免责声明：一般情况下，不要在堆栈上使用非常大的数组大小。就像你不应该使用int var[9999999]一样，你应该同样不要使用new_stack_vector(int, vec, 9999999)！负责任地使用。

寻找类似C ++ STL的矢量类，但使用堆栈存储

10 个答案: