68

有人知道定义恒定大小向量的方法吗？

例如，而不是定义

std::vector<int>

这将是

std::vector<10, int>

它应该是完全跨平台的。也许是一个开源课程？

4

8 回答 8

68

std::vector 总是可以动态增长，但有两种方法可以分配初始大小：

这会分配初始大小并用零填充元素：

std::vector<int> v(10);
v.size(); //returns 10

这会分配一个初始大小，但不会用零填充数组：

std::vector<int> v;
v.reserve(10);
v.size(); //returns 0
于 2015-06-23T17:06:05.967 回答
64

没有办法定义一个恒定大小的向量。如果您在编译时知道大小，则可以使用 C++11 的std::array聚合。

#include <array>

std::array<int, 10> a;

如果您没有相关的 C++11 支持，则可以使用 TR1 版本：

#include <tr1/array>

std::tr1::array<int, 10> a;

或boost::array，正如其他答案中所建议的那样。

于 2012-06-21T08:43:41.860 回答
14

如果您想要一个固定的编译时指定大小 (ala std::array<T, N>)，但您希望能够使用 和 之间的不同数量的元素填充向量0，N那么一个不错的选择是eastl::fixed_vector.

标准：：向量：

a 的大小std::vector是动态的——它将动态分配所需的存储空间，您不能限制大小并强制执行错误。

但是，您可以reserve设置一定的大小，然后在需要分配新存储之前将元素添加到该大小。

vector.size()最初为 0，并随着您添加元素而增加

标准：：数组：

a 的大小std::array是一个编译时常量——它将静态分配所需的存储空间，您无法更改大小。

array.size()总是数组的大小，并且等于array.max_size()

东方::fixed_vector:

an 的大小eastl::fixed_vector可以是静态的也可以是动态的。

它最初会分配一定数量的元素，然后如果您允许动态增长，将在需要时动态分配。

出于您最初要求的目的，您可以禁用增长（通过bEnableOverflow下面的模板实例化）

fixed_vector.size()最初为 0，并随着您添加元素而增加。

template<typename T, 
         size_t nodeCount, 
         bool bEnableOverflow = true, 
         typename OverflowAllocator = 
                      typename eastl::type_select<bEnableOverflow,
                                                  EASTLAllocatorType, 
                                                  EASTLDummyAllocatorType>::type>
class fixed_vector;

简单的例子：

#include <iostream>
#include <vector>
#include <array>
#include "EASTL/fixed_vector.h"

int main()
{
    std::vector<int> v;
    v.reserve(10);
    std::cout << "size=" << v.size() << " capacity=" << v.capacity() << '\n';

    std::array<int, 10> a;
    std::cout << "size=" << a.size() << " capacity=" << a.max_size() << '\n';

    eastl::fixed_vector<int, 10, false> fv;
    std::cout << "size=" << fv.size() << " capacity=" << fv.capacity() << '\n';

    return 0;
}

输出：

size=0 capacity=10
size=10 capacity=10
size=0 capacity=10

注意 的大小array为 10，而vector和fixed_vector为 0

于 2016-02-19T19:37:30.130 回答
13

使用std::array

为了更好的可读性，您可以制作 typedef：

typedef std::array<int, 10> MyIntArray;
于 2012-06-21T08:43:25.403 回答
11

这是一个老问题，但如果有人只需要在运行时定义大小的常量索引容器，我喜欢使用unique_ptr：

// c++14
auto constantContainer = std::make_unique<YourType []> ( size );

// c++11
std::unique_ptr<YourType[]> constantContainer {new YourType[ size ]};


// Access
constantContainer[ i ]
于 2018-07-11T13:31:58.693 回答
10

Astd::vector是一个动态容器，没有机制限制它的增长。要分配初始大小：

std::vector<int> v(10);

C++11 有一个std::array更合适的：

std::array<int, 10> my_array;

如果您的编译器不支持 C++11，请考虑使用boost::array：

boost::array<int, 10> my_array;
于 2012-06-21T08:45:30.590 回答
2

这---->std::vector<10, int>无效并导致错误。但是新的 C++ 标准引入了一个新的类；标准::数组。你可以像这样声明一个数组：

std::array<int, 5> arr; // declares a new array that holds 5 ints
std::array<int, 5> arr2(arr); // arr2 is equal to arr
std::array<int, 5> arr3 = {1, 2, 3, 4, 5}; // arr3 holds 1, 2, 3, 4, 5

具有std::array恒定大小并支持iterator/const_iterator/reverse_iterator/const_reverse_iterator. 你可以在http://cplusplus.com/reference/stl/array/找到更多关于这个类的信息。

于 2012-06-21T08:49:16.070 回答
0

如果您需要现代 c++ 功能以及多态性，您可以这样做

template <typename T, unsigned N>
struct polymorphic_std_array : std::array<T, N>, std::span<T>
{
    polymorphic_std_array(std::array<T,N> a)
        : std::array<T, N>(a)
        , std::span<T>(*static_cast<std::array<T, N>*>(this))
    {}
};

int main()
{
    std::span<int>* p = new polymorphic_std_array<int, 2>({ 1,2 });
    for (const auto& e : *p)
    {
        std::cout << e << std::endl;
    }
}
于 2021-07-30T06:01:27.877 回答