Указатели

Любой объект программы (переменная, массив, функция и т. д.) имеет имя и занимает в памяти определенную область. Местоположение объекта в памяти определяется его адресом. Обращение к объекту можно осуществить по его имени или косвенно, через адрес. Обращение к объекту через адрес осуществляется с помощью переменной- указателя, связанного с объектом. Указатель хранит адрес объекта (или, иначе, адрес ячейки памяти, с которой начинается объект).

Для описания указателей используется операция косвенной адресации *. Например, указатель целого типа uk описывается так:

int *uk.

Унарная операция &, примененная к некоторой переменной, показывает, что нам нужен адрес этой переменной, а не ее текущее значение. Если переменная uk объявлена как указатель, то оператор присваивания

uk=&x

означает: "взять адрес переменной x и присвоить его значение переменной указателю uk". Теперь к переменной x можно обратиться как *uk.

В одной программе можно переопределять указатель, присваивая ему разные адреса. Тогда одна и та же переменная будет использована для обращения к разным объектам. Такой стиль обращений используется, однако, редко.

Чаще, указатели используются при работе с массивами, символьными строками, зарезервированными областями памяти и объектами, память для которых выделяется динамически во время выполнения программы (п. 2.3).

Итак, указатели предназначены для хранения адресов областей памяти. В C++ различают три вида указателей – указатели на объект, на функцию и на void, отличающиеся свойствами и набором допустимых операций. Указатель не является самостоятельным типом, он всегда связан с каким-либо другим конкретным типом объекта.

Указатель на объект содержит адрес области памяти, в которой хранятся данные определенного типа (основного или составного). Объявление указателя на объект (в дальнейшем называемого просто указателем) имеет вид:

тип *имя;

где тип – тип объекта, на который ссылается указатель. Он может быть любым, кроме ссылки и битового поля, причем тип может быть к этому моменту только объявлен, но еще не определен (следовательно, в структуре, например, может присутствовать указатель на структуру того же типа). Символ "звездочка" сообщает компилятору, что объявленная переменная является указателем. Независимо от типа объекта, для указателя резервируется два или четыре байта в зависимости от используемой модели памяти.

Пример объявления указателей на переменные целого типа:

int *pi, *pbi, *pci;

Звездочка относится непосредственно к имени. Поэтому для того, чтобы объявить несколько указателей, требуется ставить ее перед именем каждого из них.

Существует соглашение: имя указателя начинать с буквы p. Это облегчает чтение программы.

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

тип *имя указателя = инициализирующее выражение;

тип *имя указателя (инициализирующее выражение);

Существуют следующие способы инициализации указателя:

1.Присваивание указателю адреса существующего объекта:

– с помощью операции получения адреса:

int a = 5; // целая переменная

int *р = &а; //в указатель записывается адрес а

int *р (&а); // в указатель записывается адрес а другим способом

– с помощью значения другого инициализированного указателя p:

int a = 5;

int *р = &а;

int *pr = р; //pr тоже указатель на a

– с помощью имени массива:

int b[10]; // массив

int * pb = b; // присваивание адреса первого элемента массива

2. Присваивание указателю адреса области памяти в явном виде:

char *pv = (char *)0xB8000000;

Здесь 0xB8000000 – шестнадцатеричная константа (начальный адрес видеопамяти ПЭВМ), (char *) – обязательная операция приведения типа: константа преобразуется к типу указателя (char *). Таким образом, определяется, что в эту ячейку памяти будет записан код переменной типа char.

3. Присваивание пустого значения:

int *psuxx = NULL;

int *prulez = 0;

В первой строке используется константа NULL, определенная в некоторых заголовочных файлах С как указатель, равный нулю. Рекомендуется использовать просто 0, так как это значение типа int будет правильно преобразовано стандартными способами в соответствии с контекстом. Поскольку гарантируется, что объектов с нулевым адресом нет, пустой указатель можно использовать для проверки, ссылается указатель на конкретный объект или нет.

После определения указателя и его инициализации адресом переменной или адресом области памяти, указатель можно использовать для записи и чтения значения, находящегося по этому адресу. Для этого применяется операция разыменования ' * ' (получение значения через указатель). Пример:

int a; // целая переменная

int *р = &а; //в указатель записывается адрес а

*p = 5; //через операцию разыменования указателя переменной a присвоено значение 5

cout<< *p; // вывод значения переменной a через указатель

но

cout<< p; // вывод адреса переменной a

Выражение *p обладает в данном случае правами имени переменной a и может использоваться везде, где допустимо использование имен объектов того типа, к которому относиться указатель.

С помощью указателя можно записать и считать значение непосредственно из ячейки памяти с заданным адресом:

char *pv = (char *)0xB8000000;// присваивание указателю адреса области памяти в явном виде

*pv = '+'; // запись в ячейку с адресом 0xB8000000 символа +

char v = *pv; // присваивание v значения из ячейки с адресом

0xB8000000, значение будет представлено в символьном виде

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

тип *const имя указателя инициализатор;

Пример:

char *const key_byte = (char*)1047;

Значение указателя key_byte невозможно изменить, он всегда указывает на байт с адресом 1047.

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

char *const key_byte = (char*)1047;

cout<<"\nbyte key: "<< *key_byte;

*key_byte = 'Ё';

cout<<"\nbyte key: "<< *key_byte;

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

key_byte = NULL;

не допустит компилятор и выдаст сообщение об ошибке.

Можно определить указатель на константу. Формат определения:

тип const *имя указателя инициализатор;

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

const int zero = 0; //определение константы

int const *pconst = &zero; //указатель на константу 0

Операторы вида

*pconst = 1;

cin>>*pconst;

недопустимы, так как каждый из них – попытка изменить значение константы 0.

Однако операторы

pconst = &a;

pconst = NULL;

допустимы, так как разрывают связь указателя pconst с константой 0, но не меняют значение этой константы.

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

const float pi = 3.141593;

float const *const ppi = &pi;

Можно определить указатель на указатель и т.д. сколько нужно раз. В следующей программе определены такие указатели и с их помощью выполнен доступ к значению переменной:

int i = 77;

int *pi = &i;

int **ppi = &pi;

int ***pppi = &ppi;

cout<<"i = "<< ***pppi;

Указатель на тип void применяется и тех случаях, когда конкретный тип объекта, адрес которого требуется хранить, не определен (например, если в одной и той же переменной в разные моменты времени требуется хранить адреса объектов различных типов).

Указателю на void можно присвоить значение указателя любого типа, а также сравнивать его с любыми указателями, но перед выполнением каких-либо действий с областью памяти, на которую он ссылается, требуется преобразовать его к конкретному типу явным образом. Возможности связывания указателя void * с объектами разных типов показаны в следующей программе:

void *pv;

int i = 77;

float f = 2.3456;

cout<<RUS("\nНачальное значение pv = ")<< pv;

pv = &i; //работаем с переменной типа int

cout<<"i = "<< *(int *)pv; //перед разыменованием явное приведение типа указателя к типу int

pv = &f; // работаем с переменной типа float

cout<<"f = "<< *(float *)pv; //перед разыменованием явное приведение типа указателя к типу float

Ссылки

Ссылка представляет собой синоним имени, указанного при инициализации ссылки. Ссылку можно рассматривать как указатель, который всегда разыменован. Формат объявления ссылки:

тип & имя;

где тип – это тип величины, на которую указывает ссылка, & – оператор ссылки, означающий, что следующее за ним имя является именем переменной ссылочного типа, например:

int kol;

int& pal = kol; // ссылка pal - альтернативное имя для kol

const char& CR = '\n'; // ссылка на константу

Необходимо помнить следующие правила:

переменная-ссылка должна явно инициализироваться при ее описании, кро­ме случаев, когда она является параметром функции, описана как extern или ссылается на поле данных класса;

после инициализации ссылке не может быть присвоена другая переменная;

тип ссылки должен совпадать с типом величины, на которую она ссылается;

не разрешается определять указатели на ссылки, создавать массивы ссылок и ссылки на ссылки.

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

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