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

18.4.1. Перегрузка ключевого слова const

Функция

operator[]()

void f(const vector& cv)

{

 double d = cv[1]; // неожиданная ошибка

 cv[1] = 2.0;    // ожидаемая ошибка

}

Причина заключается в том, что наша функция

vector::operator[]()

vector

const

class vector {

 // ...

 double& operator[](int n);    // для неконстантных векторов

 double operator[](int n) const; // для константных векторов

};

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

double&

const

double

const double &

double

void ff(const vector& cv, vector& v)

{

 double d = cv[1]; // отлично (использует константный вариант [ ])

 cv[1] = 2.0;    // ошибка (использует константный вариант [ ])

 double d = v[1];  // отлично (использует неконстантный вариант [ ])

 v[1] = 2.0;    // отлично (использует неконстантный вариант [ ])

}

Поскольку объекты класса

vector

operator[]()

const

18.5.1. Указатели на элементы массива

Указатель может ссылаться на элемент массива. Рассмотрим пример.

double ad[10];

double* p = &ad[5]; // ссылается на элемент ad[5]

Указатель

p

double

ad[5]

Этот указатель можно индексировать и разыменовывать.

*p =7;

p[2] = 6;

p[–3] = 9;

Теперь ситуация выглядит следующим образом.

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

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

p += 2; // переносим указатель p на два элемента вправо

Итак, приходим к следующей ситуации.

Аналогично,

p –= 5; // переносим указатель p на пять элементов вправо

В итоге получим следующее.

Использование операций

+

–

+=

–=

p += 1000;   // абсурд: p ссылается на массив, содержащий

        // только 10 чисел

double d = *p; // незаконно: возможно неправильное значение

         // (совершенно непредсказуемое)

*p = 12.34;   // незаконно: можно задеть неизвестные данные

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

Наиболее распространенным использованием арифметик указателей является инкрементация указателя (с помощью оператора

++

––

for (double* p = &ad[0]; p<&ad[10]; ++p) cout << *p << '\n';

И в обратном порядке:

for (double* p = &ad[9]; p>=&ad[0]; ––p) cout << *p << '\n';

Это использование арифметики указателей не слишком широко распространено. Однако, по нашему мнению, последний (“обратный”) пример небезопасен. Почему

&ad[9]

&ad[10]

>=

>

vector

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

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

double* p1 = &ad[0];

double* p2 = p1+7;

double* p3 = &p1[7];

if (p2 != p3) cout << "impossible!\n";

В основном это произошло по историческим причинам. Эти правила были разработаны для языка C несколько десяткой лет назад, и отменить их невозможно, не выбросив в мусорную корзину огромное количество программ. Частично это объясняется тем, что арифметика указателей обеспечивает определенное удобство в некоторых низкоуровневых приложениях, например в механизме управления памятью.

18.5.2. Указатели и массивы

Имя массива относится ко всем элементам массива. Рассмотрим пример.

char ch[100];

Размер массива

ch

sizeof(ch)

char* p = ch;

Здесь указатель

p

&ch[0]

sizeof(p)

strlen()

int strlen(const char* p) // аналогична стандартной

              // функции strlen()

{

 int count = 0;

 while (*p) { ++count; ++p; }

 return count;

}

Теперь можем вызвать ее как с аргументом

strlen(ch)

strlen(&ch[0]

int strlen(const char a[]) // аналогична стандартной

               // функции strlen()

{

 int count = 0;

 while (a[count]) { ++count; }

 return count;

}

char lots [100000];

void f()

{

 int nchar = strlen(lots);

 // ... 

Наивно (но частично обоснованно) мы могли бы ожидать, что при выполнении этого вызова будут скопированы 100 тыс. символов, заданных как аргумент функции

strlen()

char p[]

char* p

strlen(lots)

strlen(&lots[0])

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

char ac[10];

ac = new char [20];   // ошибка: имени массива ничего присвоить нельзя

&ac[0] = new char [20]; // ошибка: значению указателя ничего

             // присвоить нельзя

И на десерт — проблема, которую компилятор может перехватить!

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

int x[100];

int y[100];

// ...

x = y;      // ошибка

int z[100] = y; // ошибка

Это логично, но неудобно. Если необходимо скопировать массив, вы должны написать более сложный код. Рассмотрим пример.

for (int i=0; i<100; ++i) x[i]=y[i]; // копируем 100 чисел типа int

memcpy(x,y,100*sizeof(int)); // копируем 100*sizeof(int) байт

copy(y,y+100, x); // копируем 100 чисел типа int

Поскольку в языке C нет векторов, в нем интенсивно используются массивы. Вследствие этого в огромном количестве программ, написанных на языке C++, используются массивы (подробнее об этом — в разделе 27.1.2). В частности, строки в стиле C (массивы символов, завершаемые нулем; эта тема рассматривается в разделе 27.5) распространены очень широко.

Если хотите копировать, то используйте класс, аналогичный классу

vector

vector

vector x(100);

vector y(100);

// ...

x = y;   // копируем 100 чисел типа int

18.5.3. Инициализация массива

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

char ac[] = "Beorn"; // массив из шести символов

Подсчитайте эти символы. Их пять, но

ac

Строка, завершающаяся нулем, является обычным явлением в языке С и многих системах. Такие массивы символов, завершающиеся нулем, мы называем строками в стиле языка С (C-style string). Все строковые литералы являются строками в стиле языка C. Рассмотрим пример.

char* pc = "Howdy"; // указатель pc ссылается на массив из шести

           // символов

Графически это можно изобразить следующим образом.

Переменная типа

char

0

'0'

int strlen(const char* p) // похоже на стандартную функцию strlen()

{

 int n = 0;

 while (p[n]) ++n;

 return n;

}

На самом деле мы не обязаны определять функцию

strlen()

strlen()

n

char

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

int ai[] = { 1, 2, 3, 4, 5, 6 };    // массив из шести чисел

                     // типа int

int ai2[100] = { 0,1,2,3,4,5,6,7,8,9 }; // остальные 90 элементов

                     // инициализируются нулем

double ad[100] = { };       // все элементы инициализируются нулем

char chars[] = { 'a', 'b', 'c' }; // нет завершающего нуля!

Обратите внимание на то, что количество элементов в массиве

ai

chars

ai2

ad

18.5.4. Проблемы с указателями

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

• Обращение по нулевому указателю.

• Обращение по неинициализированному указателю.

• Выход за пределы массива.

• Обращение к удаленному объекту.

• Обращение к объекту, вышедшему из области видимости.

На практике во всех перечисленных ситуациях главная проблема, стоящая перед программистом, заключается в том, что внешне фактический доступ выглядит вполне невинно; просто указатель ссылается на неправильное значение. Что еще хуже (при записи с помощью указателя), проблема может проявиться намного позднее, когда окажется, что некий объект, не связанный с программой, был поврежден. Рассмотрим следующий пример.

Не обращайтесь к памяти с помощью нулевого указателя.

int* p = 0;

*p = 7;  // Ой!

Очевидно, что в реальной программе это может произойти, если между инициализацией и использованием указателя размещен какой-то код. Чаще всего эта ошибка возникает при передаче указателя p функции или при получении его в результате работы функции. Мы рекомендуем никуда не передавать нулевой указатель, но, уж если вы это сделали, проверьте указатель перед его использованием. Например,

int* p = fct_that_can_return_a_0();

if (p == 0) {

  // что-то делаем

}

else {

 // используем р

  *p = 7;

}

и

void fct_that_can_receive_a_0(int* p)

{

 if (p == 0) {

   // что-то делаем

  }

  else {

   // используем р

   *p = 7;

  }

}

Основными средствами, позволяющими избежать ошибок, связанных с нулевыми указателями, являются ссылки (см. раздел 17.9.1) и исключения (см. разделы 5.6 и 19.5).

Инициализируйте указатели.

int* p;

*p = 9; // Ой!

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

Не обращайтесь к несуществующим элементам массива.

int a[10];

int* p = &a[10];

*p = 11;   // Ой!

a[10] = 12;  // Ой!

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

vector

Не обращайтесь к памяти с помощью удаленного указателя.

int* p = new int(7);

// ...

delete p;

// ...

*p = 13;  // Ой!

Инструкция

delete p

*p

new

delete

new

delete

Vector_ref

Не возвращайте указатель на локальную переменную.

int* f()

{

 int x = 7;

 // .. .

 return &x;

}

// ...

int* p = f();

// ...

*p = 15;  // Ой!

Возврат из функции

f()

*p

Рассмотрим эквивалентный пример.

vector& ff()

{

 vector x(7);

 // ...

 return x;

}  // здесь вектор х был уничтожен

// ...

vector& p = ff();

// ...

p[4] = 15;  // Ой!

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

new

delete

18.6.1. Палиндромы, созданные с помощью класса string

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

string

int

bool is_palindrome(const string& s)

{

 int first = 0;      // индекс первой буквы

 int last = s.length()–1; // индекс последней буквы

 while (first < last) {   // мы еще не достигли середины слова

   if (s[first]!=s[last]) return false;

   ++first;  // вперед

   ––last;  // назад

 }

 return true;

}

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

is_palindrome()

int main()

{

 string s;

 while (cin>>s) {

   cout << s << " is";

   if (!is_palindrome(s)) cout << " not";

   cout << " a palindrome\n";

 }

}

По существу, причина, по которой мы используем класс

string

string

is_palindrome()

getline()

18.6.2. Палиндромы, созданные с помощью массива

А если бы у нас не было класса

string

vector

bool is_palindrome(const char s[], int n)

 // указатель s ссылается на первый символ массива из n символов

{

 int first = 0;     // индекс первой буквы

 int last = n–1;     // индекс последней буквы

 while (first < last) { // мы еще не достигли середины слова

 if (s[first]!=s[last]) return false;

 ++first;   // вперед

 ––last;   // назад

 }

 return true;

}

Для того чтобы выполнить функцию

is_palindrome()

istream& read_word(istream& is, char* buffer, int max)

 // считывает не более max–1 символов в массив buffer

{

 is.width(max); // при выполнении следующего оператора >>

         // будет считано не более max–1 символов

 is >> buffer;  // читаем слово, разделенное пробелами,

         // добавляем нуль после последнего символа

 return is;

}

Правильная установка ширины потока

istream

>>

width()

string

vector

0

read_word()

int main()

{

 const int max = 128;

 char s[max];

 while (read_word(cin,s,max)) {

   cout << s << " is";

   if (!is_palindrome(s,strlen(s))) cout << " not";

   cout << " a palindrome\n";

 }

}

Вызов

strlen(s)

read_word()

cout<

string