Использование ключевого слова const при объявлении указателей

 

При объявлении указателей допускается использование ключевого слова const пе­ред спецификатором типа или после него. Корректны, например, следующие вариан­ты объявления:

 

const int * pOne;

int * const pTwo;

const int * const pThree;

 

В этом примере pOne является указателем на константу типа int. Поэтому значе­ние, на которое он указывает, изменять нельзя.

Указатель pTwo является константным указателем на тип int. В этом случае значе­ние, записанное по адресу в указателе, может изменяться, но сам адрес остается не­изменным.

И наконец, pThree объявлен как константный указатель на константу типа int. Это означает, что он всегда указывает на одну и ту же область памяти и значение, запи­санное по этому адресу, не может изменяться.

В первую очередь необходимо понимать, какое именно значение объявляется кон­стантой. Если наименование типа переменной записано после ключевого слова const, значит, объявляемая переменная будет константой. Если же за словом const следует имя переменной, константой является указатель.

 

const int * p1; // Укаэатоль на коисттпу типа ini

int * const p2; // Константный указаюль, всегда указывающий на одну и ту же область памяти

Использование ключевого слова const при объявлении указателей и функций-членов

 

Использование ключевого шва const при объявлении указателей и функции-членов

На занятии 4 мы обсудили вопрос об использовании ключевого слова const при объявлении функций-членов классов. При объявлении функции константной попытка внести изменения в данные объекта с помощью этой функции будут пресекаться компилятором.

Если указатель на объект объявлен константным, он может использоваться для вызова только тех методов, которые также объявлены со спецификатором const (листинг 8.10).

Листинг 8.10. Указатели на константные объекты

1: // Листинг 8.10.

2: // Вызов константных методов с помощью указателей

3:

4: flinclude <iostream.h>

5:

6: class Rectangle

7: {

8: public:

9: Rectangle();

10: ~Rectangle();

11: void SetLength(int length) { itsLength = length; }

12: int GetLength() const { return itsLength; }

13: void SetWidth(int width) { itsWidth = width: }

14: int GetWidth() const { return itsWidth; }

15:

16: private:

17: int itsLength;

18: int itsWidth;

19: };

20:

21: Rectangle::Rectangle()

22: {

23: itsWidth = 5;

24: itsLength = 10;

25: }

26:

27: Rectangle::~Rectangle()

28: { }

29:

30: int main()

31: {

32: Rectangle* pRect = new Rectangle;

33: const Rectangle * pConstRect = new Rectangle;

34: Rectangle * const pConstPtr = new Rectangle;

35:

36: cout << "pRect width; " << pRect->GetWidth() << " meters\n";

37: cout << "pConstRect width: " << pConstRect-> GetWidth() << " meters\n";

38: cout << "pConstPtr width: " << pConstPtr-> GetWidth() << " meters\n";

39:

40: pRect->SetWidth(10);

41: // pConstRect->SetWidth(10);

42: pConstPt r->SetWidth(10); 43:

44: cout << "pRect width: " << pRect->GetWidth() << " meters\n";

45: cout << "pConstRect width:"<< pConstRect->GetWidth() << " meters\n";

46: cout << "pConstPtr width: " << pConstPtr->GetWidth() << " meters\n";

47: return 0;

48: }

 

Результат:

pRect width: 5 meters

pConstRect width: 5 meters

pConstPtr width: 5 meters

pRect width: 10 meters

pConstRect width: 5 meters

pConstPtr width: 10 meters

 

Анализ: В строках 6—19 приведено описание класса Rectangle. Обратите внимание, что метод GetWidth(), описанный в строке 14, имеет спецификатор const. Затем в строке 32 объявляется указатель на объект класса Rectangle, а в строке 33 — на константный объект этого же класса. Константный указатель pConstPrt описывается в строке 34.

В строках 36—38 значения переменных класса выводятся на экран.

Метод SetWidth(), вызванный для указателя pRect (строка 40), устанавливает значение ширины объекта. В строке 41 показан пример использования указателя pConstRect для вызова метода класса. Но, так как pConstRect является указателем на константный объект, вызов методов без спецификатора const для него недоступен, поэтому данная строка закомментирована. В строке 42 происходит вызов метода SetWidth() для указателя pConstPrt. Этот указатель константный и может ссылаться только на одну область памяти, однако сам объект константным не является, поэтому данная операция полностью корректна.

 

Рекомендуется: Проверяйте значения, возвращаемые

функцией malloc().

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

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

 

Указатель const this

 

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

Более подробно этот вопрос рассматривается на следующем занятии при изучении ссылок на константные объекты.

 

 

Вычисления с указателями

 

Один указатель можно вычитать из другого. Если, например, два указателя ссылаются на разные элементы массива, вычитание одного указателя из другого позволяет получить количество элементов массива, находящихся между двумя заданными. Наиболее эффективно эта методика используется при обработке символьных массивов (листинг 8.11).

Листинг 8.11. Выделение слов из массива символов

1: #include <iostream.h>

2: #include <ctype.h>

3: #include <string.h>

4: bool GetWord(char* string, char* word, int& wordOffset);

5: // основная программа

6: int main()

7: {

8: const int bufferSize = 255;

9: char buffer[bufferSize+1]; // переменная для хранения всей строки

10: char word[bufferSize+1]; // переменная для хранения слова

11: int wordOffset = 0; // начинаем с первого символа

12:

13: cout << "Enter а string: ";

14: cin.getline(buffer,bufferSize);

15:

16: while (GetWord(buffer,word,wordOffset))

17: {

18: cout << "Got this word: " << word << endl;

19: }

20:

21: return 0;

22:

23: }

24:

25:

26: // Функция для выделения слова из строки символов.

27: bool GetWord(char* string, char* word, int& wordOffset)

28: {

29:

30: if (!string[wordOffset]) // определяет конец строки?

31: return false;

32:

33: char *p1, *p2;

34: p1 = p2 = string+wordOffset; // указатель на следующее слово

35:

36: // удаляем ведущие пробелы

37: for (int i = 0; i<(int)strlen(p1) &&!isalnum(p1[0]); i++)

38: p1++;

39:

40: // проверка наличия слова

41: if (!iKalruj[n(pl[0]))

42: return false;

43:

44: // указатель р1 показание начало сдолующего слова

45: // iа к жо как и p2

46: p2 = p1;

47:

48: // перпмещавм p2 и конец олова

49: while (isalnum(p2[0]))

50: p2++;

51:

62: // p2 указывает на конец слова

53: // а p1 - в начало

54: // разность указатолой показываот длину слова

55: int len = int (p2 - p1);

56:

57: // копируем слово в буфер

58: strncpy (word,p1,len);

59:

60: // и добавляем символ разрыва сроки

61: word[len]='\0';

62:

63: // ищем начало следующего слова

64: for (int i = int(p2-string); K(int)strlen(string) &&!isalnum(p2[0]); i++)

65: p2++;

66:

67: wordOffset = int(p2-string);

68:

69: return true;

70: }

 

Результат:

Enter а string: this code first appeared jn C++ Report

Got this word: this

Got this word: code

Got this word: first

Got this word: appeared

Got this word: in

Got this word: C

Got this word: Report

 

Анализ: В строке 13 пользователю предлагается ввести строку. Строка считывается функцией GetWord(), параметрами которой является буферизированная переменная для хранения первого слова и целочисленная переменная WordOffset. В строке 11 переменной WordOffset присваивается значение 0. По мере ввода строки (до тех пор пока GetWord() не возвратит значение 0) введенные слова отображаются на экране.

При каждом вызове функции GetWord() управление передается в строку 27. Далее, в строке 30, значение string[wordOffset ] проверяется на равенство нулю. Выполнение условия означает, что мы находимся за пределами строки. Функция GetWord() возвращает значение false.

В строке 33 объявляются два указателя на переменную символьного типа. В строке 34 оба указателя устанавливаются на начало следующего слова, заданное значением переменной WordOffset. Исходно значение WordOffset равно 0, что соответствует началу строки.

С помощью цикла в строках 37 и 38 указатель р1 перемещается на первый символ, являющийся буквой или цифрой. Если такой символ не найден, функция возвращает false (строки 41 и 42).

Таким образом, указатель p1 соответствует началу очередного слова. Строка 46 присваивает указателю p2 то же значение.

В строках 49 и 50 осуществляется поиск в строке первого символа, не являющегося ни цифрой, ни буквой. Указатель p2 перемещается на этот символ. Теперь p1 и p2 указывают на начало и конец слова соответственно. Вычтем из значения указателя p2 значение р1 и преобразуем результат к целочисленному типу. Результатом выполнения такой операции будет длина очередного слова (строка 55). Затем на основании данных о начале и длине полученное слово копируется в буферную переменную.

Строкой 61 в конец слова добавляется концевой нулевой символ, служащий сигналом разрыва строки. Далее указатель p2 перемещается на начало следующего слова, а переменной WordOffset присваивается значение смещения начала очередного слова относительно начала строки. Возвращая значение true, мы сигнализируем о том, что слово найдено.

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

 

Резюме

 

Указатели являются мощным средством непрямого доступа к данным. Каждая переменная имеет адрес, получить который можно с помощью оператора адреса (t). Для хранения адреса используются указатели.

Для объявления указателя достаточно установить тип объекта, адрес которого он будет содержать, а затем ввести символ "*" и имя указателя. После объявления указатель следует инициализировать. Если адрес объекта неизвестен, указатель инициализируется значением 0.

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

Чтобы выделить память для хранения какого-либо объекта, используется оператор new, а затем полученный адрес присваивается указателю. Для освобождения зарезервированной памяти используется оператор delete. Сам указатель при освобождении памяти не уничтожается, поэтому освобожденному указателю необходимо присвоить нулевое значение, чтобы обезопасить его.

 

Вопросы и ответы

 

В чем состоит преимущество работы с указателями?

На этом занятии вы узнали, насколько удобно использовать доступ к объекту по его адресу и передавать параметры как ссылки. На занятии 13 будет рассмотрена роль указателей в полиморфизме классов.

Чем удобно размещение объектов в динамической области памяти?

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

Зачем ограничивать права доступа к объекту, объявляя его константным?

Следует использовать все средства, позволяющие предотвратить появление ошибок. На практике достаточно сложно отследить, в какой момент и какой функцией изменяется объект. Использование спецификатора const позволяет решить эту проблему.

 

Коллоквиум

 

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

Контрольные вопросы

 

1. Какой оператор используется для получения адреса переменной?

2. Какой оператор позволяет получить значение, записанное по адресу, содержащемуся в указателе?

3. Что такое указатель?

4. В чем различие между адресом, который хранится в указателе, и значением, записанным по этому адресу?

5. В чем различие между оператором разыменования и оператором получения адреса?

6. В чем различие между следующими объявлениями: const int * ptrOne и int * const ptrTwo?

 

Упражнения

 

1. Объясните смысл следующих объявлений переменных:

• int * pOne

• int vTwo

• int * pThree = &vTwo

2. Допустим, в программе объявлена переменная yourAge типа unsigned short. Как объявить указатель, позволяющий манипулировать этой переменной?

3. С помошью указателя присвойте переменной yourAge значение 50.

4. Напишите небольшую программу и объявите в ней переменную типа int и указатель на этот тип. Сохраните адрес переменной в указателе. Используя указатель, присвойте переменной какое-либо значение,

5. Жучки: найдите ошибку в следующем фрагменте программы.

#include <iostream,h>

int main()

{

int *pInt;

*pInt = 9;

cout << "The value at pInt: " << *pInt;

return 0;

}

6. Жучки: найдите ошибку в следующем фрагменте программы.

int main()

{

int SomeVariable = 5;

cout << "SomeVariable: " << SomeVariable << "\n";

int *pVar = & SomeVariable;

pVar = 9;

cout << "SomeVariable: " << *pVar << "\n";

return 0;

}

 

День 9-й. Ссылки

 

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

• Что представляют собой ссылки

• Чем ссылки отличаются ог указателей

• Как создать ссылки и использовать их

• Какие ограничения есть у ссылок

• Как по ссылке передаются значения и объекты в функции и из функций

Что такое ссылка

 

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

Для объявления ссылки нужно указать типа объекта адресата, за которым следует оператор ссылки (&), а за ним — имя ссылки. Для ссылок можно использовать любое легальное имя переменной, но многие программисты предпочитают со всеми именами ссылок использовать префикс "г". Так, если у вас есть целочисленная переменная с именем someInt, вы можете создать ссылку на эту переменную, написав

 

int &rSomeRef = someInt;

 

Это читается следующим образом: rSomeRef — это ссылка на целочисленное значение, инициализированная адресом переменной someInt. Создание и использование ссылок показано в листинге 9.1.

 

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

 

Листинг 9.1. Создание и использование ссылок

1: // Листинг 9.1.

2: // Пример использования ссылок

3:

4: #include <iostream.h>

5:

6: int main()

7: {

8: int intOne;

9: int &rSomeRef = intOne;

10:

11: intOne = 5;

12: cout << "intOne: " << intOne << endl;

13: cout << "rSomeRef: " << rSomeRef << endl;

14:

15: rSomeRef = 7;

16: cout << "intOne: " << intOne << endl;

17: cout << "rSomeRef: " << rSomeRef << endl;

18: return 0;

19: }

 

Результат:

intOne: 5

rSomeRef: 5

intOne: 7

rSomeRef: 7

 

Анализ: В строке 8 объявляется локальная целочисленная переменная intOne, а в строке 9 — ссылка rSomeRef на некоторое целое значение, инициализируемая адресом переменной intOne. Если объявить ссылку, но не инициализировать ее, будет сгенерирована ошибка компиляции. Ссылки, в отличие от указателя, необходимо инициализировать при объявлении.

В строке 11 переменной intOne присваивается значение 5. В строках 12 и 13 выводятся на экран значения переменной intOne и ссылки rSomeRef - они, конечно же, оказываются одинаковыми.

В строке 15 ссылке rSomeRef присваивается значение 7. Поскольку мы имеем дело со ссылкой, а она является псевдонимом для переменной intOne, то число 7 в действительности присваивается переменной intOne, что и подтверждается выводом на экран в строках 16 и 17.

 

Использование оператора адреса (&) при работе со ссылками

 

Если использовать ссылку для получения адреса, она вернет адрес своего адресата. В этом и состоит природа ссылок. Они являются псевдонимами для своих адресатов. Именно это свойство и демонстрирует листинг 9.2.

Листинг 9.2. Взятие адреса ссылки

1: // Листинг 9.2.

2: // Пример использования ссылок

3:

4: #include <iostream.h>

5:

6: int main()

7: {

8: int intOne;

9: int &rSomeRef = intOne;

10:

11: intOne = 5;

12: cout << "intOne: " << intOne << endl;

13: cout << "rSomeRef: " << rSomeRef << endl;

14:

15: cout << "&intOne: " << &mtOne << endl;

16: cout << "&rSomeRef: " << &rSomeRef << endl;

17:

18: return 0;

19: }

 

Результат:

intOne: 5

rSomeRef: 5

&intOne: 0x3500

&rSomeRef: 0x3500

 

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

 

Анализ: И вновь-таки ссылка rSomeRef инициализируется адресом переменной intOno. На этот раз выводятся адреса двух переменных, и они оказываются идентичными. В языке C++ не предусмотрено предоставление доступа к адресу самой ссылки, поскольку в этом нет смысла. С таким же успехом для этого можно было бы использовать указатель или другую переменную. Ссылки инициализируются при создании, и они всегда действуют как синонимы для своих адресатов, даже в том случае, когда применяется оператор адреса.

Например, если у вас есть класс с именем City, вы могли бы объявить объект этого класса следующим образом:

City boston;

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

City &beanTown = boston;

Существует только один класс City; оба идентификатора ссылаются на один и тот же объект одного и того же класса. Любое действие, которое вы предпримите относительно ссылки beanTown, будет выполнено также и над объектом boston.

Обратите внимание на различие между символом & в строке 9 листинга 9.2, который объявляет ссылку rSomeRef на значение типа int, и символами & в строках 15 и 16, которые возвращают адреса целочисленной переменной intOne и ссылки rSomeRef.

Обычно для ссылки оператор адреса не используется. Мы просто используем ссылку вместо связанной с ней переменной, как показано в строке 13.

Ссылки нельзя переназначать

 

Даже опытных программистов, которые хорошо знают правило о том, что ссылки нельзя переназначать и что они всегда являются псевдонимами для своих адресатов, может ввести в заблуждение происходящее при попытке переназначить ссылку. То, что кажется переназначением, оказывается присвоением нового значения адресату. Этот факт иллюстрируется в листинге 9.3.

Листинг 9.3. Присвоение значения ссылке

1: // Листинг 9.3

2: // Присвоение значения ссылке

3:

4: #include <iostream.h>

5:

6: int main()

7: {

8: int intOne;

9: int &rSomeRef = intOne;

10:

11: intOne: 5

12: cout << "intOne:\t" << intOne << endl;

13: cout << "rSomeRef:\t" << rSomeRef << endl;

14: cout << "&intOne:\t" << &intOne << endl;

15: cout << "&rSomeRef:\t" << &rSomeRef << endl;

16:

17: int intTwo = 8;

18: rSomeRef = intTwo; // не то что вы думаете

19: cout << "\nintOne:\t" << intOne << endl;

20: cout << "intTwo:\t" << intTwo << endl;

21: cout << "rSomeRef:\t" << rSomeRef << endl;

22: cout << "&intOne:\t" << &intOne << endl;

23: cout << "&intTwo:\t" << &intTwo << endl;

24: cout << "&rSomeRef:\t" << &rSomeRef << endl;

25: return 0;

26: }

 

Результат:

intOne: 5

rSomeRef: 5

&intOne: 0x213e

&rSomeRef: 0x213e

intOne: 8

int:Two: 8

rSomeRef: 8

&intOne: 0x213e

&intTwo: 0x2130

&rSomeRef: 0x213e

 

Анализ: Вновь в строках 8 и 9 объявляются целочисленная переменная и ссылка на целое значение. В строке 11 целочисленной переменной присваивается значение 5, а в строках 12-15 выводятся значения переменной и ссылки, а также их адреса.

В строке 17 создается новая переменная intTwo, которая тут же инициализируется значением 8. В строке 18 программист пытается переназначить ссылку rSomeRef так, чтобы она стала псевдонимом переменной intTwo, но этого не происходит. На самом же деле ссылка rSomeRef продолжает действовать как псевдоним переменной intOne, поэтому такое присвоение эквивалентно следующей операции:

intOne = intTwo;

Это кажется достаточно убедительным, особенно при выводе на экран значений переменной intOne и ссылки rSomeRef (строки 19— 21): их значения совпадают со значением переменной intTwo. На самом деле при выводе на экран адресов в строках 22—24 вы видите, что ссылка rSomeRef продолжает ссылаться на переменную intOne, а не на переменную intTwo.

 

Не рекомендуется: Не пытайтесь переназначить ссылку. Не путайте оператор адреса с оператором ссылки.

Рекомендуется: Используйте ссылки для создания псевдонимов объектов. Инициализируйте ссылки при объявлении.

 

 

На что можно ссылаться

 

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

int & rIntRef = int; // неверно

Ссылку rIntRef нужно инициализировать, используя конкретную целочисленную переменную, например:

int howBig = 200: int & rIntRef = howBig;

Точно так же нельзя инициализировать ссылку классом CAT:

CAT & rCatRef = CAT; // неверно

Ссылку rCatRef нужно инициализировать, используя конкретный объект класса CAT:

CAT frisky;

CAT & rCatRef = frisky;

Ссылки на объекты используются точно так же, как сами объекты. Доступ к данным-членам и методам осуществляется с помощью обычного оператора доступа к членам класса (.), и, подобно встроенным типам, ссылка действует как псевдоним для объекта. Этот факт иллюстрируется в листинге 9.4.

Листинг 9.4. Ссылки на объекты класса

1: // Листинг 9.4.

2: // Ссылки на объекты класса

3:

4: #include <iostream.h>

5:

6: class SimpleCat

7: {

8: public:

9: SimpleCat(int age, int weight);

10: ~SimpleCat() {}

11: int GetAge() { return itsAge; }

12: int GetWeight() { return itsWeight; }

13: private:

14: int itsAge;

15: int itsWeight;

16: }

17:

18: SimpleCat::SimpleCat(int age, int weight)

19: {

20: itsAge = age;

21: itsWeight = weight;

22: }

23:

24: int main()

25: {

26: SimpleCat Fnsky(5,3);

27: SimpleCat & rCat = Fnsky;

28:

29: cout << "Frisky: ";

30: cout << Frisky.GetAge() << " years old. \n";

31: cout << "И Frisky весит: ";

32: cout << rCat.GetWeight() << " kilograms. \n";

33: return 0;

34: }

 

Результат:

Frisky: 5 years old.

И Frisky весит: 3 kilograms.

 

Анализ: В строке 26 объявляется переменная Frisky в качестве объекта класса SimplcCat. В строке 27 объявляется ссылка rCat на некоторый объект класса SimpleCat, и эта ссылка инициализируется с использованием уже объявленного объекта Frisky. В строках 30 и 32 вызываются методы доступа к членам класса SimpleCat, причем сначала это делается с помощью объекта класса SimpleCat (Frisky), а затем с помощью ссылки на объект класса SimpleCat (rCat). Обратите внимание, что результаты идентичны. Снова повторюсь: ссылка — это всего лишь псевдоним реального объекта.

 

Объявление ссылок

Ссылка объявляется путем указания типа данных, за которым следует оператор ссылки (&) и имя ссылки. Ссылки нужно инициализировать при объявлении.

Пример 1:

int hisAge;

int &rAge = hisAge;

Пример 2:

CAT boots;

CAT &rCatRef = boots;