Question

有人知道定义常量大小的矢量的方法吗？

例如，而不是定义

std::vector<int>

它将是

std::vector<10, int>

应完全跨平台。也许是一个开源类？

Answer 1

无法定义常量大小的矢量。如果您在编译时知道大小，则可以使用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，正如其他答案中所建议的那样。

Answer 2

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

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

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

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

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

Answer 3

使用std::array c++11

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

typedef std::array<int, 10> MyIntArray;

Answer 4

std::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;

Answer 5

如果您想要一个固定的编译时指定大小（ala std::array<T, N>），但您希望能够在0和N之间填充包含不同数量元素的向量，那么一个好的选择是eastl::fixed_vector。

<强>的std ::矢量：

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

然而，您可以reserve一定的大小，然后在需要分配新存储空间之前添加该大小的元素。

vector.size()最初为0，并在您添加elementss

时增加

<强>的std ::数组：

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

array.size()始终是数组的大小，等于array.max_size()

<强> EASTL :: fixed_vector：

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

Answer 6

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

// c++14 auto constantContainer = std::make_unique<YourType []> ( size ); // c++11 std::unique_ptr<YourType[]> constantContainer {new YourType[ size ]}; // Access constantContainer[ i ]

Answer 7

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

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/找到有关此课程的更多信息。

Answer 8

如果你需要现代 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;
    }
}

恒定大小的矢量

8 个答案: