Массивы

Массивы

Массивы в С++ объявляются с указанием количества элементов массива в квадратных скобках после имени переменной массива. Допускаются двумерные массивы, т.е. массив массивов. Ниже приводится определение одномерного массива, содержащего 10 элементов типа int:

int fibonacci[10];

Доступ к элементам осуществляется с помощью следующей записи: fibonacci[0], fibonacci[1], … fibonacci[9]. Часто требуется инициализировать массив при его определении:

int fibonacci[10] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

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

int fibonacci[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

Статическая инициализация также работает для сложных типов, например для Point2D:

Point2D triangle[] = {

Point2D(0.0, 0.0), Point2D(1.0, 0.0), Point2D(0.5, 0.866)

};

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

const int fibonacci[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

Для нахождения количества элементов в массиве можно использовать оператор sizeof():

int n = sizeof(fibonacci) / sizeof(fibonacci[0]);

Оператор sizeof() возвращает размер аргумента в байтах. Количество элементов массива равно его размеру в байтах, поделенному на размер одного его элемента. Поскольку это долго вводить, распространенной альтернативой является объявление константы и ее использование при определении массива:

enum { NFibonacci = 10 };

const int fibonacci[NFibonacci] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

Есть соблазн объявить константу как переменную типа const int. К сожалению, некоторые компиляторы имеют проблемы при использовании константных переменных для представления размера массива. Ключевое слово enum будет объяснено далее в этом приложении.

Проход в цикле по массиву обычно выполняется с использованием переменной целого типа. Например:

for (int i = 0; i < NFibonacci; ++i)

cout << fibonacci[i] << endl;

Массив можно также проходить с помощью указателя:

const int *ptr = &fibonacci[0];

while (ptr != &fibonacci[10]) {

cout << *ptr << endl;

++ptr;

}

Мы инициализируем указатель адресом первого элемента и проходим его в цикле, пока не достигнем элемента «после последнего элемента» («одиннадцатого» элемента, fibonacci[10]). На каждом шаге цикла оператор ++ продвигает указатель к следующему элементу.

Вместо &fibonacci[0] можно было бы также написать fibonacci. Это объясняется тем, что указанное без элементов имя массива автоматически преобразуется в указатель на первый элемент массива. Аналогично можно было бы подставить fibonacci + 10 вместо &fibonacci[10]. Эти приемы работают и в других местах: мы можем получить содержимое текущего элемента, используя запись *ptr или ptr[0], а получить доступ к следующему элементу могли бы, используя *(ptr + 1) или ptr[1]. Это свойство иногда называют «эквивалентностью указателей и массивов».

Чтобы не допустить того, что считается необоснованной неэффективностью, С++ не позволяет передавать массивы функциям по значению. Вместо этого передается адрес массива. Например:

01 #include <iostream>

02 using namespace std;

03 void printIntegerTable(const int *table, int size)

04 {

05 for (int i = 0; i < size; ++i)

06 cout << table[i] << endl;

07 }

08 int main()

09 {

10 const int fibonacci[10] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

11 printIntegerTable(fibonacci, 10);

12 return 0;

13 }

Ирония в том, что, хотя С++ не позволяет выбирать между передачей массива по ссылке и передачей по значению, он предоставляет некоторую свободу синтаксиса при объявлении типа параметра. Вместо const int *table можно было бы также написать const int table[] для объявления в качестве параметра указателя на константный тип int. Аналогично параметр argv функции main() можно объявлять как char *argv[] или как char **argv.

Для копирования одного массива в другой можно пройти в цикле по элементам массива:

const int fibonacci[NFibonacci] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };

int temp[NFibonacci];

for (int i = 0; i < NFibonacci; ++i)

temp[i] = fibonacci[i];

Для базовых типов, таких как int, можно также использовать функцию std::memcpy(), которая копирует блок памяти. Например:

memcpy(temp, fibonacci, sizeof(fibonacci));

При объявлении массива С++ его размер должен быть константой[10]. Если необходимо создать массив переменного размера, это можно сделать несколькими способами:

• Выделять память под массив можно динамически:

int *fibonacci = new int[n];

Оператор new [] выделяет последовательные участки памяти под определенное количество элементов и возвращает указатель на первый элемент. Благодаря принципу «эквивалентности указателей и массивов» обращаться к элементам можно с помощью указателей: fibonacci[0], fibonacci[1], … fibonacci[n — 1]. После завершения работы с массивом необходимо освободить занимаемую им память, используя оператор delete []:

delete [] fibonacci;

• Можно использовать стандартный класс std::vector<T>:

#include <vector>

using namespace std;

vector<int> fibonacci(n);

Обращаться к элементам можно с помощью оператора [], как это делается для обычного массива С++. При использовании вектора std::vector<T> (где T — тип элемента, хранимого в векторе) можно изменить его размер в любой момент с помощью функции resize(), и его можно копировать, применяя оператор присваивания. Классы, содержащие угловые скобки в имени, называются шаблонными классами.

• Можно использовать класс Qt QVector<T>:

#include <QVector>

QVector<int> fibonacci(n);

Программный интерфейс вектора QVector<T> очень похож на интерфейс вектора std::vector<T>, кроме того, он поддерживает возможность прохода по его элементам с помощью ключевого слова Qt foreach и использует неявное совмещение данных («копирование при записи») как метод оптимизации расхода памяти и повышения быстродействия. В главе 11 представлены классы—контейнеры Qt и объясняется их связь со стандартными контейнерами С++.

Может возникнуть соблазн применения везде векторов std::vector<T> или QVector<T> вместо встроенных массивов. Тем не менее полезно иметь представление о работе встроенных массивов, потому что рано или поздно вам может потребоваться очень быстрый программный код или придется использовать существующие библиотеки С.