Язык программирования C++. Пятое издание - Стенли Липпман

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

3.5.1. Определение и инициализация встроенных массивов

Массив является составным типом (см. раздел 2.3). Оператор объявления массива имеет форму a[d], где а — имя; d — размерность определяемого массива. Размерность задает количество элементов массива, она должна быть больше нуля. Количество элементов — это часть типа массива, поэтому она должна быть известна на момент компиляции. Следовательно, размерность должна быть константным выражением (см. раздел 2.4.4).

unsigned cnt = 42;          // неконстантное выражение

constexpr unsigned sz = 42; // константное выражение

                            // constexpr см. p. 2.4.4

int arr[10];                // массив десяти целых чисел

int *parr[sz];              // массив 42 указателей на int

string bad[cnt];            // ошибка: cnt неконстантное выражение

string strs[get_size()];    // ok, если get_size - constexpr,

                            // в противном случае - ошибка

По умолчанию элементы массива инициализируются значением по умолчанию (раздел 2.2.1).

Подобно переменным встроенного типа, инициализированный по умолчанию массив встроенного типа, определенный в функции, будет содержать неопределенные значения.

При определении массива необходимо указать тип его элементов. Нельзя использовать спецификатор auto для вывода типа из списка инициализаторов. Подобно вектору, массив содержит объекты. Таким образом, невозможен массив ссылок.

Явная инициализация элементов массива

Массив допускает списочную инициализацию (см. раздел 3.3.1) элементов. В этом случае размерность можно опустить. Если размерность отсутствует, компилятор выводит ее из количества инициализаторов. Если размерность определена, количество инициализаторов не должно превышать ее.

Если размерность больше количества инициализаторов, то инициализаторы используются для первых элементов, а остальные инициализируются по умолчанию (см. раздел 3.3.1):

const unsigned sz = 3;

int ia1[sz] = {0, 1, 2};      // массив из трех целых чисел со

                              // значениями 0, 1, 2

int a2[] = {0, 1, 2};         // массив размером 3 элемента

int a3[5] = {0, 1, 2};        // эквивалент a3[] = {0, 1, 2, 0, 0}

string a4[3] = {"hi", "bye"}; // эквивалент a4[] = {"hi", "bye", ""}

int a5[2] = {0, 1, 2};        // ошибка: слишком много инициализаторов

Особенности символьных массивов

У символьных массивов есть дополнительная форма инициализации: строковым литералом (см. раздел 2.1.3). Используя эту форму инициализации, следует помнить, что строковые литералы заканчиваются нулевым символом. Этот нулевой символ копируется в массив наряду с символами литерала.

char a1[] = {'C', '+', '+'};       // списочная инициализация без

                                   // нулевого символа

char а2[] = {'C', '+', '+', ''}; // списочная инициализация с явным

                                   // нулевым символом

char a3[] = "С++";                 // нулевой символ добавляется

                                   // автоматически

const char a4[6] = "Daniel";       // ошибка: нет места для нулевого

                                   // символа!

Массив a1 имеет размерность 3; массивы а2 и a3 — размерности 4. Определение массива a4 ошибочно. Хотя литерал содержит только шесть явных символов, массив a4 должен иметь по крайней мере семь элементов, т.е. шесть для самого литерала и один для нулевого символа.

Не допускается ни копирование, ни присвоение

Нельзя инициализировать массив как копию другого массива, не допустимо также присвоение одного массива другому.

int a[] = {0, 1, 2}; // массив из трех целых чисел

int a2[] = a;        // ошибка: нельзя инициализировать один массив

                     // другим

а2 = a;              // ошибка: нельзя присваивать один массив другому

Некоторые компиляторы допускают присвоение массивов при применении расширения компилятора (compiler extension). Как правило, использования нестандартных средств следует избегать, поскольку они не будут работать на других компиляторах.

Понятие сложных объявлений массива

Как и векторы, массивы способны содержать объекты большинства типов. Например, может быть массив указателей. Поскольку массив — это объект, можно определять и указатели, и ссылки на массивы. Определение массива, содержащего указатели, довольно просто, определение указателя или ссылки на массив немного сложней.

int *ptrs[10];            // ptrs массив десяти указателей на int

int &refs[10] = /* ? */;  // ошибка: массив ссылок невозможен

int (*Parray)[10] = &arr; // Parray указывает на массив из десяти int

int (&arrRef)[10] = arr;  // arrRef ссылается на массив из десяти ints

Обычно модификаторы типа читают справа налево. Читаем определение ptrs справа налево (см. раздел 2.3.3): определить массив размером 10 по имени ptrs для хранения указателей на тип int.

Определение Parray также стоит читать справа налево. Поскольку размерность массива следует за объявляемым именем, объявление массива может быть легче читать изнутри наружу, а не справа налево. Так намного проще понять тип Parray. Объявление начинается с круглых скобок вокруг части *Parray, означающей, что Parray — указатель. Глядя направо, можно заметить, что указатель Parray указывает на массив размером 10. Глядя влево, можно заметить, что элементами этого массива являются целые числа. Таким образом, Parray — это указатель на массив из десяти целых чисел. Точно так же часть (&arrRef) означает, что arrRef — это ссылка, а типом, на который она ссылается, является массив размером 10, хранящий элементы типа int.

Конечно, нет никаких ограничений на количество применяемых модификаторов типа.

int *(&arry)[10]=ptrs; // arry - ссылка на массив из десяти указателей

Читая это объявление изнутри наружу, можно заметить, что arry — это ссылка. Глядя направо, можно заметить, что объект, на который ссылается arry, является массивом размером 10. Глядя влево, можно заметить, что типом элемента является указатель на тип int. Таким образом, arry — это ссылка на массив десяти указателей.

Зачастую объявление массива может быть проще понять, начав его чтение с имени массива и продолжив его изнутри наружу.

Упражнения раздела 3.5.1

Упражнение 3.27. Предположим, что функция txt_size() на получает никаких аргументов и возвращают значение типа int. Объясните, какие из следующих определений недопустимы и почему?

unsigned buf_size = 1024;

(a) int ia[buf_size];   (b) int ia[4 * 7 - 14];

(c) int ia[txt_size()]; (d) char st[11] = "fundamental";

Упражнение 3.28. Какие значения содержатся в следующих массивах?

string sa[10];

int ia[10];

int main() {

 string sa2[10];

 int ia2[10];

}

Упражнение 3.29. Перечислите некоторые из недостатков использования массива вместо вектора.

3.5.2. Доступ к элементам массива

Подобно библиотечным типам vector и string, для доступа к элементам массива можно использовать серийный оператор for или оператор индексирования ([]) (subscript). Как обычно, индексы начинаются с 0. Для массива из десяти элементов используются индексы от 0 до 9, а не от 1 до 10.

При использовании переменной для индексирования массива ее обычно определяют как имеющую тип size_t. Тип size_t — это машинозависимый беззнаковый тип, гарантированно достаточно большой для содержания размера любого объекта в памяти. Тип size_t определен в заголовке cstddef, который является версией С++ заголовка stddef.h библиотеки С.

За исключением фиксированного размера, массивы используются подобно векторам. Например, можно повторно реализовать программу оценок из раздела 3.3.3, используя для хранения счетчиков кластеров массив.

// подсчет количества оценок в кластере по десять: 0--9,