Язык программирования C++. Вводный курс

Тип “массив”


Мы уже касались массивов в разделе 2.1. Массив – это набор элементов одного типа, доступ к которым производится по индексу – порядковому номеру элемента в массиве. Например:

int ival;

определяет ival как переменную типа int, а инструкция

int ia[ 10 ];

задает массив из десяти объектов типа int. К каждому из этих объектов, или элементов массива, можно обратиться с помощью операции взятия индекса:

ival = ia[ 2 ];

присваивает переменной ival

значение элемента массива ia с индексом 2. Аналогично

ia[ 7 ] = ival;

присваивает элементу с индексом 7 значение ival.

Определение массива состоит из спецификатора типа, имени массива и размера. Размер задает количество элементов массива (не менее 1) и заключается в квадратные скобки. Размер массива нужно знать уже на этапе компиляции, а следовательно, он должен быть константным выражением, хотя не обязательно задается литералом. Вот примеры правильных и неправильных определений массивов:



extern int get_size();

// buf_size и max_files константы

const int buf_size = 512, max_files = 20;

int staff_size = 27;

// правильно: константа

char input_buffer[ buf_size ];

// правильно: константное выражение: 20 - 3

char *fileTable[ max_files-3 ];

// ошибка: не константа

double salaries[ staff_size ];

// ошибка: не константное выражение

int test_scores[ get_size() ];

Объекты buf_size и max_files

являются константами, поэтому определения массивов input_buffer и fileTable

правильны. А вот staff_size – переменная (хотя и инициализированная константой 27), значит, salaries[staff_size] недопустимо. (Компилятор не в состоянии найти значение переменной staff_size в момент определения массива salaries.)

Выражение max_files-3

может быть вычислено на этапе компиляции, следовательно, определение массива fileTable[max_files-3]

синтаксически правильно.

Нумерация элементов начинается с 0, поэтому для массива из 10 элементов правильным диапазоном индексов является не 1 – 10, а 0 – 9. Вот пример перебора всех элементов массива:




int main()

{

           const int array_size = 10;

           int ia[ array_size ];

           for ( int ix = 0; ix < array_size; ++ ix )

                  ia[ ix ] = ix;
}

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



const int array_size = 3;
int ia[ array_size ] = { 0, 1, 2 };

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



// массив размера 3
int ia[] = { 0, 1, 2 };

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



// ia ==> { 0, 1, 2, 0, 0 }

const int array_size = 5;
int ia[ array_size ] = { 0, 1, 2 };

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



const char cal[] = {'C', '+', '+' };
const char cal2[] = "C++";

Размерность массива ca1

равна 3, массива ca2 – 4 (в строковых литералах учитывается завершающий нулевой символ). Следующее определение вызовет ошибку компиляции:



// ошибка: строка "Daniel" состоит из 7 элементов
const char ch3[ 6 ] = "Daniel";

Массиву не может быть присвоено значение другого массива, недопустима и инициализация одного массива другим. Кроме того, не разрешается использовать массив ссылок. Вот примеры правильного и неправильного употребления массивов:



const int array_size = 3;

int ix, jx, kx;

// правильно: массив указателей типа int*

int *iar [] = { &ix, &jx, &kx };

// error: массивы ссылок недопустимы

int &iar[] = { ix, jx, kx };

int main()

{

           int ia3{ array_size ]; // правильно

          

           // ошибка: встроенные массивы нельзя копировать

ia3 = ia;

return 0;
<


}

Чтобы скопировать один массив в другой, придется проделать это для каждого элемента по отдельности:



const int array_size = 7;

int ia1[] = { 0, 1, 2, 3, 4, 5, 6 };

int main()

{

           int ia3[ array_size ];

           for ( int ix = 0; ix < array_size; ++ix )

                  ia2[ ix ] = ia1[ ix ];

           return 0;
}

В качестве индекса массива может выступать любое выражение, дающее результат целого типа. Например:



int someVal, get_index();
ia2[ get_index() ] = someVal;

Подчеркнем, что язык С++ не обеспечивает контроля индексов массива – ни на этапе компиляции, ни на этапе выполнения. Программист сам должен следить за тем, чтобы индекс не вышел за границы массива. Ошибки при работе с индексом достаточно распространены. К сожалению, не так уж трудно встретить примеры программ, которые компилируются и даже работают, но тем не менее содержат фатальные ошибки, рано или поздно приводящие к краху.

Упражнение 3.22

Какие из приведенных определений массивов содержат ошибки? Поясните.



(a) int ia[ buf_size ];     (d) int ia[ 2 * 7 - 14 ]

(b) int ia[ get_size() ];   (e) char st[ 11 ] = "fundamental";
(c) int ia[ 4 * 7 - 14 ];

Упражнение 3.23

Следующий фрагмент кода должен инициализировать каждый элемент массива значением индекса. Найдите допущенные ошибки:



int main() {

    const int array_size = 10;

    int ia[ array_size ];

    for ( int ix = 1; ix <= array_size; ++ix )

                ia[ ia ] = ix;

    // ...
}


Содержание раздела