Массивы
Массив – это совокупность элементов одного и того же типа. Простейшим примером массива может служить набор из двенадцати целых чисел, соответствующих числу дней в каждом календарном месяце:
int days[12]; days[0] = 31; // январьdays[1] = 28; // февральdays[2] = 31; // мартdays[3] = 30; // апрельdays[4] = 31; // майdays[5] = 30; // июньdays[6] = 31; // июльdays[7] = 31; // августdays[8] = 30; // сентябрьdays[9] = 31; // октябрьdays[10] = 30; // ноябрьdays[11] = 31; // декабрьВ первой строчке мы объявили массив из 12 элементов типа int и дали ему имя days. Остальные строки примера – присваивания значений элементам массива. Для того, чтобы обратиться к определенному элементу массива, используют операцию индексации []. Как видно из примера, первый элемент массива имеет индекс0, соответственно, последний – 11.
При объявлении массива его размер должен быть известен в момент компиляции, поэтому в качестве размера можно указывать только целую константу. При обращении же к элементу массива в роли значения индекса может выступать любая переменная или выражение, которое вычисляется во время выполнения программы и преобразуется к целому значению.
Предположим, мы хотим распечатать все элементы массива days. Для этого удобно воспользоваться циклом for.
for (int i = 0; i < 12; i++) {cout<< days[i];}Следует отметить, что при выполнении программы границы массива не контролируются. Если мы ошиблись и вместо 12 в приведенном выше цикле написали 13, то компилятор не выдаст ошибку. При выполнении программа попытается напечатать 13 -е число. Что при этом случится, вообще говоря, не определено. Быть может, произойдет сбой программы. Более вероятно, что будет напечатано какое-то случайное 13 -е число. Выход индексов за границы массива – довольно распространенная ошибка, которую иногда очень трудно обнаружить. В дальнейшем при изучении классов мы рассмотрим, как можно переопределить операцию[]и добавить контроль за индексами.
Отсутствие контроля индексов налагает на программиста большую ответственность. С другой стороны, индексация – настолько часто используемая операция, что наличие контроля, несомненно, повлияло бы на производительность программ.
Рассмотрим еще один пример. Предположим, что имеется массив из 100 целых чисел, и его необходимо отсортировать, т.е. расположить в порядке возрастания. Сортировка методом "пузырька" – наиболее простая и распространенная – будет выглядеть следующим образом:
int array[100];...for (int i = 0; i < 99; i++) {for (int j = i + 1; j < 100; j++) {if (array[j] < array[i]) {inttmp = array[j];array[j] = array[i];array[i] = tmp; } }}В предыдущем примере у массива имеется только один индекс. Такие одномерные массивы часто называются векторами. Имеется возможность определить массивы с несколькими индексами или размерностями. Например, объявление
int m[10][5];представляет матрицу целых чисел размером 10 на 5. По-другому интерпретировать приведенное выше объявление можно как массив из 10 элементов, каждый из которых – вектор целых чисел длиной 5. Общее количество целых чисел в массиве m равно 50.
Обращение к элементам многомерных массивов аналогично обращению к элементам векторов: m[1][2] обращается к третьему элементу второйстроки матрицы m. Следует помнить что индексы начинаются с 0.
Количество размерностей в массиве может быть произвольным. Как и в случае с вектором, при объявлении многомерного массива все его размеры должны быть заданы константами.
При объявлении массива можно присвоить начальные значения его элементам (инициализировать массив). Для вектора это будет выглядеть следующим образом:
intdays[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };При инициализации многомерных массивов каждая размерность должна быть заключена в фигурные скобки:
doubletemp[2][3] = { { 3.2, 3.3, 3.4 }, { 4.1, 3.9, 3.9 } };Структуры
Структуры – это не что иное, как классы, у которых разрешен доступ ко всем их элементам (доступ к определенным атрибутам класса может быть ограничен, о чем мы узнаем в лекции 11). Пример структуры:
structRecord {intnumber;charname[20];};Так же, как и для классов, операция "." обозначает обращение к элементу структуры.
В отличие от классов, можно определить переменную-структуру без определения отдельного типа:
struct {double x;double y;} coord;Обратиться к атрибутам переменной coord можно coord.x и coord.y.
Битовые поля
В структуре можно определить размеры атрибута с точностью до бита. Традиционно структуры используются в системном программировании для описания регистров аппаратуры. В них каждый бит имеет свое значение. Не менее важной является возможность экономии памяти – ведь минимальный тип атрибута структуры это байт (char), который занимает 8 битов. До сих пор, несмотря на мегабайты и даже гигабайты оперативной памяти, используемые в современных компьютерах, существует немало задач, где каждый бит на счету.
Если после описания атрибута структуры поставить двоеточие и затем целое число, то это число задает количество битов, выделенных под данный атрибут структуры. Такие атрибуты называют битовыми полями. Следующая структура хранит в компактной форме дату и время дня с точностью до секунды.
Одна структура TimeAndDate требует всего 39 битов, т.е. 5 байтов (один байт — 8 битов). Если бы мы использовали для каждого атрибута этой структуры тип char, нам бы потребовалось 7 байтов.
Указатели
Указатель – это производный тип, который представляет собой адрес какого-либо значения. В языке Си++ используется понятие адреса переменных. Работа с адресами досталась Си++ в наследство от языка Си. Предположим, что в программе определена переменная типа int:
int x;Можно определить переменную типа " указатель " на целое число:
int* xptr;и присвоить переменной xptrадрес переменной x:
xptr = &x;Операция &, примененная к переменной, – это операция взятия адреса. Операция *, примененная к адресу, – это операция обращения по адресу. Таким образом, два оператора эквивалентны:
int y = x; // присвоить переменной y значение xint y = *xptr; // присвоить переменной y значение, // находящееся по адресу xptrС помощью операцииобращения по адресу можно записывать значения:
*xptr = 10; // записать число 10 по адресу xptrПосле выполнения этого оператора значение переменной x станет равным 10, поскольку xptr указывает на переменную x.
Указатель – это не просто адрес, а адрес величины определенного типа. Указательxptr – адрес целой величины. Определить адреса величин других типов можно следующим образом:
unsignedlong* lPtr; // указатель на целое число без знака char* cp; // указатель на байт Complex* p; // указатель на объект класса ComplexЕсли указатель ссылается на объект некоторого класса, то операция обращения к атрибуту класса вместо точки обозначается " -> ", например p->real. Если вспомнить один из предыдущих примеров:
voidComplex::Add(Complex x){this->real = this->real + x.real;this->imaginary = this->imaginary + x.imaginary;}то this – это указатель на текущий объект, т.е. объект, который выполняет метод Add. Записьthis-> означает обращение к атрибуту текущего объекта.
Можно определить указатель на любой тип, в том числе на функцию или метод класса. Если имеется несколько функций одного и того же типа:
intfoo(long x);intbar(long x);можно определить переменную типа указатель на функцию и вызывать эти функции не напрямую, а косвенно, через указатель:
int (*functptr)(long x);functptr = &foo;(*functptr)(2);functptr = &bar;(*functptr)(4);Длячегонужныуказатели? Указатели появились, прежде всего, для нужд системного программирования. Поскольку язык Си предназначался для "низкоуровневого" программирования, на нем нужно было обращаться, например, к регистрам устройств. У этих регистров вполне определенные адреса, т.е. необходимо было прочитать или записать значение по определенному адресу. Благодаря механизму указателей, такие операции не требуют никаких дополнительных средств языка.
int* hardwareRegister =0x80000;*hardwareRegister =12;Однако использование указателей нуждами системного программирования не ограничивается. Указатели позволяют существенно упростить и ускорить ряд операций. Предположим, в программе имеется область памяти для хранения промежуточных результатов вычислений. Эту область памяти используют разные модули программы. Вместо того, чтобы каждый раз при обращении к модулю копировать эту область памяти, мы можем передавать указатель в качестве аргумента вызова функции, тем самым упрощая и ускоряя вычисления.
structTempResults {double x1;double x2;} tempArea; // Функция calc возвращает истину, если // вычисления были успешны, и ложь – при // наличии ошибки. Вычисленные результаты // записываются на место аргументов по // адресу, переданному в указателе trPtrboolcalc(TempResults* trPtr){ // вычисленияif (noerrors) {trPtr->x1 = res1;trPtr->x2 = res2;return true; } else {return false; }}voidfun1(void){...TempResultstr; tr.x1 = 3.4; tr.x2 = 5.4;if (calc(&tr) == false) {// обработкаошибки}...}В приведенном примере проиллюстрированы сразу две возможности использования указателей: передача адреса общей памяти и возможность функции иметь более одного значения в качестве результата. Структура TempResults используется для хранения данных. Вместо того чтобы передавать эти данные по отдельности, в функцию calc передается указатель на структуру. Таким образом достигаются две цели: большая наглядность и большая эффективность (не надо копировать элементы структуры по одному). Функцияcalc возвращает булево значение – признак успешного завершения вычислений. Сами же результаты вычислений записываются в структуру, указатель на которую передан в качестве аргумента.
Упомянутые примеры использования указателей никак не связаны с объектно-ориентированным программированием. Казалось бы, объектно-ориентированное программирование должно уменьшить зависимость от низкоуровневых конструкций типа указателей. На самом деле программирование с классами нисколько не уменьшило потребность в указателях, и даже наоборот, нашло им дополнительное применение, о чем мы будем рассказывать по ходу изложения.
Адресная арифметика
С указателями можно выполнять не только операции присваивания и обращения по адресу, но и ряд арифметических операций. Прежде всего, указатели одного и того же типа можно сравнивать с помощью стандартных операций сравнения. При этом сравниваются значения указателей, а не значения величин, на которые данные указатели ссылаются. Так, в приведенном ниже примере результат первой операции сравнения будет ложным:
int x = 10;int y = 10;int* xptr = &x;int* yptr = &y;// сравниваем указателиif (xptr == yptr) {cout<< "Указатели равны" <<endl;} else {cout<< "Указатели не равны" <<endl;}// сравниваем значения, на которые указывают// указателиif (*xptr == *yptr) {cout<< "Значения равны" <<endl;} else {cout<< "Значения не равны" <<endl;}Однако результат второй операции сравнения будет истинным, поскольку переменные x и y имеют одно и то же значение.
Кроме того, над указателями можно выполнять ограниченный набор арифметических операций. К указателю можно прибавить целое число или вычесть из него целое число. Результатом прибавления к указателю единицы является адрес следующей величины типа, на который ссылается указатель, в памяти. Поясним это на рисунке. Пусть xPtr – указатель на целое число типа long, а cp – указатель на тип char. Начиная с адреса1000, в памяти расположены два целых числа. Адрес второго — 1004 (в большинстве реализаций Си++ под тип long выделяется четыре байта). Начиная с адреса2000, в памяти расположены объекты типа char.
Рис. 8.2. Адресная арифметика.
Размер памяти, выделяемой для числа типа long и для char, различен. Поэтому адрес при увеличении xPtr и cp тоже изменяется по-разному. Однако и в том, и в другом случае увеличение указателя на единицу означает переход к следующей в памяти величине того же типа. Прибавление или вычитание любого целого числа работает по тому же принципу, что и увеличение на единицу. Указатель сдвигается вперед (при прибавлении положительного числа) или назад (при вычитании положительного числа) на соответствующее количество объектов того типа, на который показывает указатель. Вообще говоря, неважно, объекты какого типа на самом деле находятся в памяти — адрес просто увеличивается или уменьшается на необходимую величину. На самом деле значение указателя ptr всегда изменяется на число, кратное sizeof(*ptr).
Указатели одного и того же типа можно друг из друга вычитать. Разность указателей показывает, сколько объектов соответствующего типа может поместиться между указанными адресами.
Связь между массивами и указателями
Между указателями и массивами существует определенная связь. Предположим, имеется массив из 100 целых чисел. Запишем двумя способами программу суммирования элементов этого массива:
longarray[100];long sum = 0;for (int i = 0; i < 100; i++)sum += array[i];То же самое можно сделать с помощью указателей:
long array[100];long sum = 0;for (long* ptr = &array[0]; ptr<&array[99] + 1; ptr++)sum += *ptr;Элементы массива расположены в памяти последовательно, и увеличение указателя на единицу означает смещение к следующему элементу массива. Упоминание имени массива без индексов преобразуется в адрес его первого элемента:
for (long* ptr = array; ptr<&array[99] + 1; ptr++)sum += *ptr;Хотя смешивать указатели и массивы можно, мы бы не стали рекомендовать такой стиль, особенно начинающим программистам.
При использовании многомерных массивовуказатели позволяют обращаться к срезам или подмассивам. Если мы объявим трехмерный массивexmpl:
longexmpl[5][6][7]то выражение вида exmpl[1][1][2] – это целое число, exmpl[1][1] – вектор целых чисел (адрес первого элемента вектора, т.е. имеет тип *long), exmpl[1] – двухмерная матрица или указатель на вектор (тип (*long)[7]). Таким образом, задавая не все индексы массива, мы получаем указатели на массивы меньшей размерности.