Инициализация указателей
Указатели
Когда компилятор обрабатывает оператор определения переменной, например, int i=10:, он выделяет память в соответствии с типом (int) и инициализирует ее указанным значением (10). Все обращения в программе к переменной по ее имени (i) заменяются компилятором на адрес области памяти, в которой хранится значение переменной. Программист может определить собственные переменные для хранения адресов областей памяти. Такие переменные называются указателями. Итак, указатели предназначены для хранения адресов областей памяти. В C++ различают три вида указателей — указатели на объект, на функцию и на void, отличающиеся свойствами и набором допустимых операций. Указатель не является самостоятельным типом, он всегда связан с каким-либо другим конкретным типом.
Указатель на функцию содержит адрес в сегменте кода, по которому располагается исполняемый код функции, то есть адрес, по которому передается управление при вызове функции. Указатели на функции используются для косвенного вызова функции (не через ее имя, а через обращение к переменной, хранящей ее адрес), а также для передачи имени функции в другую функцию в качестве параметра. Указатель функции имеет тип «указатель функции, возвращающей значение заданного типа и имеющей аргументы заданного типа»:
тип (*имя) ( список_типов_аргументов );
Например, объявление:
int (*fun) (double, double);
задает указатель с именем fun на функцию, возвращающую значение типа int и имеющую два аргумента типа double.
Указатель на объект содержит адрес области памяти, в которой хранятся данные определенного типа (основного или составного). Простейшее объявление указателя на объект (в дальнейшем называемого просто указателем) имеет вид:
тип *имя:
где тип может быть любым, кроме ссылки и битового поля , причем тип может быть к этому моменту только объявлен, но еще не определен (следовательно, в структуре, например, может присутствовать указатель на структуру того же типа.
Звездочка относится непосредственно к имени, поэтому для того, чтобы объявить несколько указателей, требуется ставить ее перед именем каждого из них. Например, в операторе:
int *a, b, *с;
описываются два указателя на целое с именами а и с, а также целая переменная Ь. Размер указателя зависит от модели памяти. Можно определить указатель на указатель и т. д.
Указатель на void применяется в тех случаях, когда конкретный тип объекта, адрес которого требуется хранить, не определен (например, если в одной и той же переменной в разные моменты времени требуется хранить адреса объектов различных типов. Указателю на void можно присвоить значение указателя любого типа, а также сравнивать его с любыми указателями, но перед выполнением каких-либо действий с областью памяти, на которую он ссылается, требуется преобразовать его к конкретному типу явным образом.
Указатель может быть константой или переменной, а также указывать на константу или переменную. Рассмотрим примеры:
int i; // целая переменная
const int ci = i; // целая константа
int * p i ; // указатель на целую переменную
const int * pci; // указатель на целую константу
int * const ср = &i; // указатель-константа на целую переменную
const int * const срс = &ci; // указатель-константа на целую константу.
Как видно из примеров, модификатор const, находящийся между именем указателя и звездочкой, относится к самому указателю и запрещает его изменение, а const слева от звездочки задает постоянство значения, на которое он указывает. Для инициализации указателей использована операция получения адреса &. Величины типа указатель подчиняются общим правилам определения области действия, видимости и времени жизни.
Инициализация указателей
Указатели чаще всего используют при работе с динамической памятью, называемой некоторыми эстетами кучей (перевод с английского языка слова heap). Это свободная память, в которой можно во время выполнения программы выделять место в соответствии с потребностями. Доступ к выделенным участкам динамической памяти, называемым динамическими переменными, производится только через указатели. Время жизни динамических переменных — от точки создания до конца программы или до явного освобождения памяти. В C++ используется два способа работы с динамической памятью. Первый использует семейство функций та 11 ос и достался в наследство от С, второй использует операции new и delete.
При определении указателя надо стремиться выполнить его инициализацию, то есть присвоение начального значения. Непреднамеренное использование инициализированных указателей — распространенный источник ошибок в программах. Инициализатор записывается после имени указателя либо в круглых скобках, либо после знака равенства.
Существуют следующие способы инициализации указателя:
1. Присваивание указателю адреса существующего объекта:
• с помощью операции получения адреса:
int а = 5; // целая переменная
int* р = &а; //в указатель записывается адрес а
int* р (&а): // то же самое другим способом
• с помощью значения другого инициализированного указателя:
int* г = р;
• с помощью имени массива или функции, которые трактуются как адрес:
int b[10]; // массив
i n t * t = b; // присваивание адреса начала массива
....
void f ( i n t а ){ /* ... * / } // определение функции
void ( * p f ) ( i n t ); // указатель на функцию
pf = f; // присваивание адреса функции
2. Присваивание указателю адреса области памяти в явном виде:
char* vp = (char *)0хВ8000000:
Здесь ОхВ8000000 — шестнадцатеричная константа, (char *) — операция приведения типа: константа преобразуется к типу «указатель на char».
3. Присваивание пустого значения:
int* SUXX = NULL;
int* rulez = 0:
В первой строке используется константа NULL, определенная в некоторых заголовочных файлах С как указатель, равный нулю. Рекомендуется использовать просто 0, так как это значение типа 1 nt будет правильно преобразовано стандартными способами в соответствии с контекстом. Поскольку гарантируется, что объектов с нулевым адресом нет, пустой указатель можно использовать для проверки, ссылается указатель на конкретный объект или нет.
4. Выделение участка динамической памяти и присваивание ее адреса указателю:
• с помощью операции new:
int* п = new int: //1
int* m = new int (10); // 2
int* q = new int [10]; // 3
• с помощью функции mal1oc
int* u = (int *)malloc(s1zeof(int)); // 4
В операторе 1 операция new выполняет выделение достаточного для размещения величины типа 1 nt участка динамической памяти и записывает адрес начала этого участка в переменную n. Память под саму переменную n (размера, достаточного для размещения указателя) выделяется на этапе компиляции. В операторе 2, кроме описанных выше действий, производится инициализация выделенной динамической памяти значением 10.
В операторе 3 операция new выполняет выделение памяти под 10 величин типа int (массива из 10 элементов) и записывает адрес начала этого участка в переменную q. которая может трактоваться как имя массива. Через имя можно обращаться к любому элементу массива. О массивах рассказывается на. Если память выделить не удалось, по стандарту должно порождаться исключение bad_alloc (об исключениях рассказывается в разделе «Обработка исключительных ситуаций», а об обработке ошибок выделения памяти. Старые версии компиляторов могут возвращать 0.
В операторе 4 делается то же самое, что и в операторе 1, но с помощью функции выделения памяти ma11oc, унаследованной из библиотеки С, В функцию передается один параметр — количество выделяемой памяти в байтах. Конструкция (int*) используется дляприведения типа указателя, возвращаемого функцией, к требуемому типу. Если память выделить не удалось, функция возвращает 0.
Операцию new использовать предпочтительнее, чем функцию та ma11oc, особенно при работе с объектами.
Освобождение памяти, выделенной с помощью операции new, должно выполняться с помощью delete, а памяти, выделенной функцией ma11oc — посредством функции free. При этом переменная-указатель сохраняется и может инициализироваться повторно. Приведенные выше динамические переменные уничтожаются следующим образом:
delete п; delete m; delete [ ] q; free (u);
Если память выделялась с помощью new[], для освобождения памяти необходимо применять delete[]. Размерность массива при этом не указывается. Если квадратных скобок нет, то никакого сообщения об ошибке не выдается, но помечен как свободный будет только первый элемент массива, а остальные окажутся недоступны для дальнейших операций. Такие ячейки памяти называются мусором.
Если переменная-указатель выходит из области своего действия, отведенная под нее память освобождается. Следовательно, динамическая переменная, на которую ссылался указатель, становится недоступной. При этом память из-под самой динамической переменной не освобождается. Другой случай появления «мусора» — когда инициализированному указателю присваивается значение другого указателя. При этом старое значение бесследно теряется.
С помощью комбинаций звездочек, круглых и квадратных скобок можно описывать составные типы и указатели на составные типы, например, в операторе
int *(*р[10])();
объявляется массив из 10 указателей на функции без параметров, возвращающих указатели на 1 nt.
По умолчанию квадратные и круглые скобки имеют одинаковый приоритет, больший, чем звездочка, и рассматриваются слева направо. Для изменения порядка рассмотрения используются круглые скобки. При интерпретации сложных описаний необходимо придерживаться правила «изнутри наружу»:
1) если справа от имени имеются квадратные скобки, это массив, если скобки круглые — это функция;
2) если слева есть звездочка, это указатель на проинтерпретированную ранее конструкцию;
3) если справа встречается закрывающая круглая скобка, необходимо применить приведенные выше правила внутри скобок, а затем переходить наружу;
4) в последнюю очередь интерпретируется спецификатор типа.
Для приведенного выше описания порядок интерпретации указан цифрами:
int *(*р[10])():
5 4 2 1 3 // порядок интерпретации описания