Программирование. Принципы и практика использования C++ Исправленное издание - Бьёрн Страуструп

указателю на переменную типа char.

17.4.1. Размещение в свободной памяти

 

 Оператор new выполняет выделение (allocation) свободной памяти (free store).

• Оператор new возвращает указатель на выделенную память.

• Значением указателя является адрес на первый байт выделенной памяти.

• Указатель ссылается на объект указанного типа.

• Указатель не знает, на какое количество элементов он ссылается.

Оператор new может выделять память как для отдельных элементов, так и для последовательности элементов. Рассмотрим пример.

int* pi = new int;          // выделяем память для одной переменной int

int* qi = new int[4];       // выделяем память для четырех переменных int

                            // (массив)

double* pd = new double;    // выделяем память для одной переменной

                            // double

double* qd = new double[n]; // выделяем память для n переменных

                            // double

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

Указатели на объекты разных типов имеют разные типы. Рассмотрим пример.

pi = pd; // ошибка: нельзя присвоить указатель double* указателю int*

pd = pi; // ошибка: нельзя присвоить указатель int* указателю double*

Почему нельзя? В конце концов, мы же можем присвоить переменную типа int переменной типа double, и наоборот. Причина заключается в операторе []. Для того чтобы найти элемент, он использует информацию о размере его типа. Например, элемент qi[2] находится на расстоянии, равном двум размерам типа int от элемента qi[0], а элемент qd[2] находится на расстоянии, равном двум размерам типа double от элемента qd[0]. Если размер типа int отличается от размера типа double, как во многих компьютерах, то, разрешив указателю qi ссылаться на память, выделенную для адресации указателем qd, можем получить довольно странные результаты.

Это объяснение с практической точки зрения. С теоретической точки зрения ответ таков: присваивание друг другу указателей на разные типы сделало бы возможными ошибки типа (type errors).

17.4.2. Доступ с помощью указателей

Кроме оператора разыменования *, к указателю можно применять оператор индексирования []. Рассмотрим пример.

double* p = new double[4]; // выделяем память для четырех переменных

                           // типа double в свободной памяти

double x = *p;             // читаем (первый) объект, на который

                           // ссылается p

double y = p[2];           // читаем третий объект, на который

                           // ссылается p

Так же как и в классе vector, оператор индексирования начинает отсчет от нуля. Это значит, что выражение p[2] ссылается на третий элемент; p[0] — это первый элемент, поэтому p[0] означает то же самое, что и *p. Операторы [] и * можно также использовать для записи.

*p = 7.7;   // записываем число в (первый) объект, на который

            // ссылается p

p[2] = 9.9; // записываем число в третий объект, на который

            // ссылается p

Указатель ссылается на объект, расположенный в памяти. Оператор разыменования (“contents of” operator, or dereference operator) позволяет читать и записывать объект, на который ссылается указатель p.

double x = *p; // читаем объект, на который ссылается указатель p

*p = 8.9;      // записываем объект, на который ссылается указатель p

Когда оператор [] применяется к указателю p, он интерпретирует память как последовательность объектов (имеющих тип, указанный в объявлении указателя), на первый из который ссылается указатель p.

double x = p[3]; // читаем четвертый объект, на который ссылается p

p[3] = 4.4;      // записываем четвертый объект, на который

                 // ссылается p

double y = p[0]; // p[0] - то же самое, что и *p

Вот и все. Здесь нет никаких проверок, никакой тонкой реализации — простой доступ к памяти.

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

17.4.3. Диапазоны

 

 Основная проблема, связанная с указателями, заключается в том, что указатель не знает, на какое количество элементов он ссылается. Рассмотрим пример.

double* pd = new double[3];

pd[2] = 2.2;

pd[4] = 4.4;

pd[– 3] = – 3.3;

 

 Может ли указатель pd ссылаться на третий элемент pd[2]? Может ли он ссылаться на пятый элемент pd[4]? Если мы посмотрим на определение указателя pd, то ответим “да” и “нет” соответственно. Однако компилятор об этом не знает; он не отслеживает значения указателя. Наш код просто обращается к памяти так, будто она распределена правильно. Компилятор даже не возразит против выражения pd[–3], как будто можно разместить три числа типа double перед элементом, на который ссылается указатель pd.

Нам не известно, что собой представляют ячейки памяти, на которые ссылаются выражения pd[–3] и pd[4]. Однако мы знаем, что они не могут использоваться как часть нашего массива, в котором хранятся три числа типа double, на которые ссылается указатель pd. Вероятнее всего, они являются частью других объектов, и мы просто заблудились. Это плохо. Это катастрофически плохо. Здесь слово “катастрофически” означает либо “моя программа почему-то завершилась аварийно”, либо “моя программа выдает неправильные ответы”. Попытайтесь произнести это вслух; звучит ужасно. Нужно очень многое сделать, чтобы избежать подобных фраз. Выход за пределы допустимого диапазона представляет собой особенно ужасную ошибку, поскольку очевидно, что при этом опасности подвергаются данные, не имеющие отношения к нашей программе. Считывая содержимое ячейки памяти, находящегося за пределами допустимого диапазона, получаем случайное число, которое может быть результатом совершенно других вычислений. Записывая в ячейку памяти, находящуюся за пределами допустимого диапазона, можем перевести какой-то объект в “невозможное” состояние или просто получить совершенно неожиданное и неправильное значение. Такие