Назад | Начало урока | Вперед
Содержание

Глава 8

Манипулирование данными с помощью указателей

// Listing 8.2 Using pointers

#include <iostream.h>

typedef unsigned short int USHORT;

int main()

// using std::cout;

USHORT myAge; // a variable
USHORT * pAge = 0; // a pointer

myAge = 5;

cout << "myAge: " << myAge << "\n";
pAge = &myAge; // assign address of myAge to pAge
cout << "*pAge: " << *pAge << "\n\n";

cout << "Setting *pAge = 7...\n";
*pAge = 7; // sets myAge to 7

cout << "*pAge: " << *pAge << "\n";
cout << "myAge: " << myAge << "\n\n";

cout << "Setting myAge = 9...\n";
myAge = 9;

cout << "myAge: " << myAge << "\n";
cout << "*pAge: " << *pAge << "\n";

return 0;

Результат:

myAge: 5
*pAge: 5

Setting *pAge = 7...
*pAge: 7
myAge: 7

Setting myAge = 9...
myAge: 9
*pAge: 9

Прежде всего я обратил внимание на строку:

typedef unsigned short int USHORT;

Далее в программе объявлены две переменные :myAge типа unsigned short и
pAge которая является указателем на тип unsigned short и указатель
сразу инициализируется нулем.

USHORT myAge; // a variable
USHORT * pAge = 0; // a pointer

Далее первая переменная инициализируется и выводится на экран,
и затем указатель также инициализируется адресом этой переменной
и выводится на экран.

myAge = 5;
cout << "myAge: " << myAge << "\n";

Инициализируем указатель адресом переменной

pAge = &myAge; // assign address of myAge to pAge
cout << "*pAge: " << *pAge << "\n\n";

И происходит два вывода : первый вывод myAge, второй вывод *pAge
Как и ожидалось на экране мы увидим одинаковое значение!

Далее следует косвенное обращение к нашей переменной (через ее указатель)
с тем чтобы присвоить ей новое значение. Затем вывод на экран прямо
обращаясь к переменной и затем косвенно обращаясь к этой же переменной.

cout << "Setting *pAge = 7...\n";
*pAge = 7; // sets myAge to 7

cout << "*pAge: " << *pAge << "\n";
cout << "myAge: " << myAge << "\n\n";

Далее подобный процесс обращения к переменной напрямую и косвенно
повторяется еще раз.

cout << "Setting myAge = 9...\n";
myAge = 9;

cout << "myAge: " << myAge << "\n";
cout << "*pAge: " << *pAge << "\n";

Таким образом мы можем изменить значение переменной, обращаясь к ней
через указатель, который инициализирован адресом этой переменной.
Так мы можем присваивать переменной новое значение или получить
от переменной то значение которое в ней хранится.
А в области динамической памяти мы только так и можем поступать
- только через указатель!

Вверх

Адреса

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

Что хранится в указателях?

// Listing 8.3 What is stored in a pointer.

#include <iostream.h>

int main()

using std::cout;

Объявим и инициализируем две переменных

unsigned short int myAge = 5, yourAge = 10;

Объявим и инициализируем указатель на этот тип переменной // a pointer

unsigned short int * pAge = &myAge;

Выведем на экран значения этих двух переменных

cout << "myAge:\t" << myAge
<< "\t\tyourAge:\t" << yourAge << "\n";

Выведем на экран адреса этих двух переменных

cout << "&myAge:\t" << &myAge
<< "\t&yourAge:\t" << &yourAge <<"\n";

Выведем то, что содержит сам указатель на переменную (это адрес,
в данном случае переменной myAge)

cout << "pAge:\t" << pAge << "\n";

Выведем то на что указывает указатель(это значение переменной на которую
он указывает , в данном случае значение myAge )

cout << "*pAge:\t" << *pAge << "\n";
cout << "\nReassigning: pAge = &yourAge...\n\n";

Попробуем реинициализировать указатель новым адресом (адресом второй
переменной)

pAge = &yourAge; // reassign the pointer

Снова выведем на экран значения двух переменных , обращаясь к ним
напрямую(значения не изменились)

cout << "myAge:\t" << myAge <<
"\t\tyourAge:\t" << yourAge << "\n";

Выведем на экран адреса переменных(адреса не изменились)

cout << "&myAge:\t" << &myAge
<< "\t&yourAge:\t" << &yourAge <<"\n";

Выведем на экран то что содержит указатель (это адрес второй переменной)

cout << "pAge:\t" << pAge << "\n";

Выведем на экран то на что указывает указатель(это значение второй переменной)

cout << "*pAge:\t" << *pAge << "\n";
Выведем на экран адрес самого указателя

cout << "\n&pAge:\t" << &pAge << "\n";

return 0;

Результаты программы:

myAge: 5 yourAge: 10
&myAge: 0x3580 &yourAge: 0x3582
pAge: 0x3580
*pAge: 5

Reassigning: pAge = &yourAge...

myAge: 5 yourAge: 10
&myAge: 0x3580 &yourAge: 0x3582
pAge: 0x3582
*pAge: 10

&pAge: 0x3584

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

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

Рекомендуется

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

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

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

Использование указателей

Чтобы объявить указатель, укажите вначале тип переменной или объекта
на который будет ссылаться этот указатель, затем поместите символ
звездочки (*), а за ним имя указателя:

unsigned short int *pPointer=0;

Чтобы присвоить указателю адрес переменной, установите перед ее именем
оператор взятия адреса(&) :

unsigned short int theVariable=5;
unsigned short int *pPointer=&theVariable;

Чтобы возвратить значение по адресу, содержащемуся в указателе,
установите перед его именем оператор взятия значения (*) :

unsigned short int theVariable= *pPointer;

Назад | Начало урока | Вверх | Вперед
Содержание

Hosted by uCoz