Вектор постоянного размера

Ответ 1

std::vector всегда может динамически развиваться, но есть два способа выделения начального размера:

Это выделяет начальный размер и заполняет элементы нулями:

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

Это выделяет начальный размер, но не заполняет массив нулями:

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

Ответ 2

Невозможно определить вектор с постоянным размером. Если вы знаете размер во время компиляции, вы можете использовать агрегат С++ 11 std:: array.

#include <array>

std::array<int, 10> a;

Если у вас нет соответствующей поддержки С++ 11, вы можете использовать версию TR1:

#include <tr1/array>

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

или boost:: array, как было предложено в других ответах.

Ответ 3

Использовать std:: array С++ 11

Для лучшей читаемости вы можете сделать typedef:

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

Ответ 4

A std::vector является динамическим контейнером, нет механизма для ограничения его роста. Чтобы выделить начальный размер:

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

С++ 11 имеет std::array, который был бы более уместным:

std::array<int, 10> my_array;

Если ваш компилятор не поддерживает С++ 11, рассмотрите возможность использования boost::array:

boost::array<int, 10> my_array;

Ответ 5

Если вам нужен фиксированный указанный во время компиляции размер (ala std::array<T, N>), но вы хотите иметь возможность заполнять вектор переменным числом элементов от 0 до N, тогда хорошим вариантом будет eastl::fixed_vector.

станд :: вектор:

Размер std::vector является динамическим - он будет выделять требуемое хранилище динамически, и вы не можете ограничить размер и вызвать ошибку.

Однако вы можете reserve определенный размер, а затем добавить элементы этого размера, прежде чем ему потребуется выделить новое хранилище.

vector.size() изначально равен 0 и увеличивается при добавлении элементов

станд :: массив:

Размер std::array является константой времени компиляции - он статически выделяет требуемое хранилище, и вы не можете изменить размер.

array.size() всегда имеет размер массива и равен array.max_size()

eastl :: fixed_vector:

Размер eastl::fixed_vector может быть статическим или динамическим.

Первоначально он выделит определенное количество элементов, а затем, если вы разрешите динамический рост, выделит динамически при необходимости.

В целях, о которых вы изначально просили, вы можете отключить рост (с помощью bEnableOverflow в приведенном ниже 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

Ответ 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 ]

Ответ 7

Это ---- > std::vector<10, int> является недопустимым и вызывает ошибку. Но новый стандарт С++ ввел новый класс; 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/.