Указатели C++

Монтаж водяных теплых полов Курск. . Купить grundfos насос промышленный ups. .

Указатели, без сомнения, — один из самых важных и сложных аспектов C++. В значительной степени мощь многих средств C++ определяется использованием указателей. Например, благодаря им обеспечивается поддержка связных списков и динамического выделения памяти, и именно они позволяют функциям изменять содержимое своих аргументов. Однако об этом мы поговорим в последующих главах, а пока (т.е. в этой главе) мы рассмотрим основы применения указателей и покажем, как можно избежать некоторых потенциальных проблем, связанных с их использованием.


При рассмотрении темы указателей нам придется использовать такие понятия, как размер базовых С++-типов данных. В этой главе мы предположим, что символы занимают в памяти один байт, целочисленные значения — четыре, значения с плавающей точкой типа float — четыре, а значения с плавающей точкой типа double — восемь (эти размеры характерны для типичной 32-разрядной среды).
Что представляют собой указатели
Указатели — это переменные, которые хранят адреса памяти. Чаще всего эти адреса обозначают местоположение в памяти других переменных. Например, если х содержит адрес переменной у, то о переменной, х говорят, что она «указывает» на у.
Указатель — это переменная, которая содержит адрес другой переменной.
Переменные-указатели (или переменные типа указатель) должны быть соответственно объявлены. Формат объявления переменной-указателя таков:

тип *имя_переменной;
Здесь элемент тип означает базовый тип указателя, причем он должен быть допустимым С++-типом. Элемент имя_переменной представляет собой имя переменной-указателя. Рассмотрим пример. Чтобы объявить переменную р указателем на int-значение, используйте следующую инструкцию.

int *р;
Для объявления указателя на float-значение используйте такую инструкцию.

float *р;
В общем случае использование символа «звездочка» (*) перед именем переменной в инструкции объявления превращает эту переменную в указатель.
Базовый тип указателя определяет тип данных, на которые он будет ссылаться.
Тип данных, на которые будет ссылаться указатель, определяется его базовым типом. Рассмотрим еще один пример.

int *ip; // указатель на целочисленное значение

double *dp; // указатель на значение типа double
Как отмечено в комментариях, переменная ip — это указатель на int-значение, поскольку его базовым типом является тип int, а переменная dp — указатель на double-значение, поскольку его базовым типом является тип double, Следовательно, в предыдущих примерах переменную ip можно использовать для указания на int-значения, а переменную dp на double-значения. Однако помните: не существует реального средства, которое могло бы помешать указателю ссылаться на «бог-знает-что». Вот потому-то указатели потенциально опасны.
Операторы, используемые с указателями
С указателями используются два оператора: «*» и «&» Оператор «&» — унарный. Он возвращает адрес памяти, по которому расположен его операнд. (Вспомните: унарному оператору требуется только один операнд.) Например, при выполнении следующего фрагмента кода

balptr = &balance;
в переменную balptr помещается адрес переменной balance. Этот адрес соответствует области во внутренней памяти компьютера, которая принадлежит переменной balance. Выполнение этой инструкции никак не повлияло на значение переменной balance. Назначение оператора можно «перевести» на русский язык как «адрес переменной», перед которой он стоит. Следовательно, приведенную выше инструкцию присваивания можно выразить так: «переменная balptr получает адрес переменной balance». Чтобы лучше понять суть этого присваивания, предположим, что переменная balance расположена в области памяти с адресом 100. Следовательно, после выполнения этой инструкции переменная balptr получит значение 100.
Второй оператор работы с указателями (*) служит дополнением к первому (&). Это также унарный оператор, но он обращается к значению переменной, расположенной по адресу, заданному его операндом. Другими словами, он ссылается на значение переменной, адресуемой заданным указателем. Если (продолжая работу с предыдущей инструкцией присваивания) переменная balptr содержит адрес переменной balance, то при выполнении инструкции

value = *balptr;
переменной value будет присвоено значение переменной balance, на которую указывает переменная balptr. Например, если переменная balance содержит значение 3200, после выполнения последней инструкции переменная value будет содержать значение 3200, поскольку это как раз то значение, которое хранится по адресу 100. Назначение оператора «*» можно выразить словосочетаинем «по адресу». В данном случае предыдущую инструкцию можно прочитать так: «переменная value получает значение (расположенное) по адресу balptr». Действие приведенных выше двух инструкций схематично показано на рис. 6.1.
Последовательность операций, отображенных на рис. 6.1, реализуется в следующей программе.

#include <iostream>

using namespace std;

int main ()

{

int balance;

int *balptr;

int value;

balance = 3200;

balptr = &balance;

value = *balptr;

cout << «Баланс равен:» << value <<'\n';

return 0;

}
При выполнении этой программы получаем такие результаты:

Баланс равен: 3200
К сожалению, знак умножения (*) и оператор со значением «по адресу» обозначаются одинаковыми символами «звездочка», что иногда сбивает с толку новичков в языке C++. Эти операции никак не связаны одна с другой. Имейте в виду, что операторы «*» и «&» имеют более высокий приоритет, чем любой из арифметических операторов, за исключением унарного минуса, приоритет которого такой же, как у операторов, применяемых для работы с указателями.
Операции, выполняемые с помощью указателей, часто называют операциями непрямого доступа, поскольку мы косвенно получаем доступ к переменной посредством некоторой другой переменной.
Операция непрямого доступа — это процесс использования указателя для доступа к некоторому объекту.
О важности базового типа указателя
На примере предыдущей программы была показана возможность присвоения переменной value значения переменной balance посредством операции непрямого доступа, т.е. с использованием указателя. Возможно, при этом у вас промелькнул вопрос: «Как С++-компилятор узнает, сколько необходимо скопировать байтов в переменную value из области памяти, адресуемой указателем balptr?». Сформулируем тот же вопрос в более общем виде: как С++-компилятор передает надлежащее количество байтов при выполнении операции присваивания с использованием указателя? Ответ звучит так. Тип данных, адресуемый указателем, определяется базовым типом указателя. В данном случае, поскольку balptr представляет собой указатель на целочисленный тип, С++-компилятор скопирует в переменную value из области памяти, адресуемой указателем balptr, четыре байт информации (что справедливо для 32-разрядной среды), но если бы мы имели дело с double-указателем, то в аналогичной ситуации скопировалось бы восемь байт.
Переменные-указатели должны всегда указывать на соответствующий тип данных. Например, при объявлении указателя типа int компилятор «предполагает», что все значения, на которые ссылается этот указатель, имеют тип int. С++-компилятор попросту не позволит выполнить операцию присваивания с участием указателей (с обеих сторон от оператора присваивания), если типы этих указателей несовместимы (по сути не одинаковы).
Например, следующий фрагмент кода некорректен.

int *р;

double f;

// ...

р = &f; // ОШИБКА!
Некорректность этого фрагмента состоит в недопустимости присваивания double-указателя int-указателю. Выражение &f генерирует указатель на double-значение, а р — указатель на целочисленный тип int. Эти два типа несовместимы, поэтому компилятор отметит эту инструкцию как ошибочную и не скомпилирует программу.
Несмотря на то что, как было заявлено выше, при присваивании два указателя должны быть совместимы по типу, это серьезное ограничение можно преодолеть (правда, на свой страх и риск) с помощью операции приведения типов. Например, следующий фрагмент кода теперь формально корректен.

int *р;

double f;

// ...

р = (int *) &f; // Теперь формально все ОК!
Операция приведения к типу (int *) вызовет преобразование double- к int-указателю. Все же использование операции приведения в таких целях несколько сомнительно, поскольку именно базовый тип указателя определяет, как компилятор будет обращаться с данными, на которые он ссылается. В данном случае, несмотря на то, что p (после выполнения последней инструкции) в действительности указывает на значение с плавающей точкой, компилятор по-прежнему «считает», что он указывает на целочисленное значение (поскольку р по определению — int-указатель).
Чтобы лучше понять, почему использование операции приведения типов при присваивании одного указателя другому не всегда приемлемо, рассмотрим следующую программу.

// Эта программа не будет выполняться правильно.

#include <iostream>

using namespace std;

int main ()

{

double x, у;

int *p;

x = 123.23;

p = (int *) &x; // Используем операцию приведения типов для присваивания double-указателя int-указателю.

у = *р; // Что происходит при выполнении этой инструкции?

cout << у; // Что выведет эта инструкция?

return 0;

}
Как видите, в этой программе переменной p (точнее, указателю на целочисленное значение) присваивается адрес переменной х (которая имеет тип double). Следовательно, когда переменной y присваивается значение, адресуемое указателем р, переменная y получает только четыре байт данных (а не все восемь, требуемые для double-значения), поскольку р— указатель на целочисленный тип int. Таким образом, при выполнении cout-инструкции на экран будет выведено не число 123.23, а, как говорят программисты, «мусор». (Выполните программу и убедитесь в этом сами.)
Присваивание значений с помощью указателей
При присваивании значения области памяти, адресуемой указателем, его (указатель) можно использовать с левой стороны от оператора присваивания. Например, при выполнении следующей инструкции (если р — указатель на целочисленный тип)

*р = 101;
число 101 присваивается области памяти, адресуемой указателем р. Таким образом, эту инструкцию можно прочитать так: «по адресу р помещаем значение 101». Чтобы инкрементировать или декрементировать значение, расположенное в области памяти, адресуемой указателем, можно использовать инструкцию, подобную следующей.

(*р)++;
Круглые скобки здесь обязательны, поскольку оператор «*» имеет более низкий приоритет, чем оператор «++».
Присваивание значений с использованием указателей демонстрируется в следующей программе.

#include <iostream>

using namespace std;

int main ()

{

int *p, num;

p = &num;

*p = 100;

cout << num << ' ';

(*p)++;

cout << num << ' ';

(*p) --;

cout << num << '\n';

return 0;

}
Вот такие результаты генерирует эта программа.

100 101 100
Использование указателей в выражениях
Указатели можно использовать в большинстве допустимых в C++ выражений. Но при этом следует применять некоторые специальные правила и не забывать, что некоторые части таких выражений необходимо заключать в круглые скобки, чтобы гарантированно получить желаемый результат.
Арифметические операции над указателями
С указателями можно использовать только четыре арифметических оператора: ++, — , + и — . Чтобы лучше понять, что происходит при выполнении арифметических действий с указателями, начнем с примера. Пусть p1 — указатель на int-переменную с текущим значением 2 ООО (т.е. p1 содержит адрес 2 ООО). После выполнения (в 32-разрядной среде) выражения

p1++;
содержимое переменной-указателя p1 станет равным 2 004, а не 2 001! Дело в том, что при каждом инкрементировании указатель p1 будет указывать на следующее int-значение. Для операции декрементирования справедливо обратное утверждение, т.е. при каждом декрементировании значение p1 будет уменьшаться на 4. Например, после выполнения инструкции

p1--;
указатель p1 будет иметь значение 1 996, если до этого оно было равно 2 000. Итак, каждый раз, когда указатель инкрементируется, он будет указывать на область памяти, содержащую следующий элемент базового типа этого указателя. А при каждом декрементировании он будет указывать на область памяти, содержащую предыдущий элемент базового типа этого указателя.
Для указателей на символьные значения результат операций инкрементирования и декрементирования будет таким же, как при «нормальной» арифметике, поскольку символы занимают только один байт. Но при использовании любого другого типа указателя при инкрементировании или декрементировании значение переменной-указателя будет увеличиваться или уменьшаться на величину, равную размеру его базового типа.
Арифметические операции над указателями не ограничиваются использованием операторов инкремента и декремента. Со значениями указателей можно выполнять операции сложения и вычитания, используя в качестве второго операнда целочисленные значения. Выражение

p1 = p1 + 9;
заставляет p1 ссылаться на девятый элемент базового типа указателя p1 относительно элемента, на который p1 ссылался до выполнения этой инструкций.
Несмотря на то что складывать указатели нельзя, один указатель можно вычесть из другого (если они оба имеют один и тот же базовый тип). Разность покажет количество элементов базового типа, которые разделяют эти два указателя.
Помимо сложения указателя с целочисленным значением и вычитания его из указателя, а также вычисления разности двух указателей, над указателями никакие другие арифметические операции не выполняются. Например, с указателями нельзя складывать float- или double-значения.
Чтобы понять, как формируется результат выполнения арифметических операций над указателями, выполним следующую короткую программу. Она выводит реальные физические адреса, которые содержат указатель на int-значение (i) и указатель на float-значение (f). Обратите внимание на каждое изменение адреса (зависящее от базового типа указателя), которое происходит при повторении цикла. (Для большинства 32-разрядных компиляторов значение i будет увеличиваться на 4, а значение f — на 8.) Отметьте также, что при использовании указателя в cout-инструкции его адрес автоматически отображается в формате адресации, применяемом для текущего процессора и среды выполнения.

// Демонстрация арифметических операций над указателями.

#include <iostream>

using namespace std;

int main ()

{

int *i, j[10];

double *f, g[10];

int x;

i = j;

f = g;

for (x=0; x<10; x++)

cout << i+x << ' ' << f+x << '\n';

return 0;

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

0012FE5C 0012FE84

0012FE60 0012FE8C

0012FE64 0012FE94

0012FE68 0012FE9C

0012FE6C 0012FEA4

0012FE70 0012FEAC

0012FE74 0012FEB4

0012FE78 0012FEBC

0012FE7C 0012FEC4

0012FE80 0012FECC
Узелок на память. Все арифметические операции над указателями выполняются относительно базового типа указателя.
Сравнение указателей
Указатели можно сравнивать, используя операторы отношения ==, < и >. Однако для того, чтобы результат сравнения указателей поддавался интерпретации, сравниваемые указатели должны быть каким-то образом связаны. Например, если p1 и р2 — указатели, которые ссылаются на две отдельные и никак не связанные переменные, то любое сравнение p1 и р2 в общем случае не имеет смысла. Но если p1 и р2 указывают на переменные, между которыми существует некоторая связь (как, например, между элементами одного и того же массива), то результат сравнения указателей p1 и р2 может иметь определенный смысл. Ниже в этой главе мы рассмотрим пример программы, в которой используется сравнение указателей.
Указатели и массивы
В C++ указатели и массивы тесно связаны между собой, причем настолько, что зачастую понятия «указатель» и «массив» взаимозаменяемы. В этом разделе мы попробуем проследить эту связь. Для начала рассмотрим следующий фрагмент программы.

char str[80];

char *p1;

p1 = str;
Здесь str представляет собой имя массива, содержащего 80 символов, a p1 — указатель на тип char. Особый интерес представляет третья строка, при выполнении которой переменной p1 присваивается адрес первого элемента массива str. (Другими словами, после этого присваивания p1 будет указывать на элемент str[0].) Дело в том, что в C++ использование имени массива без индекса генерирует указатель на первый элемент этого массива. Таким образом, при выполнении присваивания p1 = str адрес stг[0] присваивается указателю p1. Это и есть ключевой момент, который необходимо четко понимать: неиндексированное имя массива, использованное в выражении, означает указатель на начало этого массива.
Имя массива без индекса образует указатель на начало этого массива.
Поскольку после рассмотренного выше присваивания p1 будет указывать на начало массива str, указатель p1 можно использовать для доступа к элементам этого массива. Например, если нужно получить доступ к пятому элементу массива str, используйте одно из следующих выражений:

str[4]

или

*(p1+4)
В обоих случаях будет выполнено обращение к пятому элементу. Помните, что индексирование массива начинается с нуля, поэтому при индексе, равном четырем, обеспечивается доступ к пятому элементу. Точно такой же эффект производит суммирование значения исходного указателя (p1) с числом 4, поскольку p1 указывает на первый элемент массива str.
Необходимость использования круглых скобок, в которые заключено выражение p1+4, обусловлена тем, что оператор «*» имеет более высокий приоритет, чем оператор «+». Без этих круглых скобок выражение бы свелось к получению значения, адресуемого указателем p1, т.е. значения первого элемента массива, которое затем было бы увеличено на 4.
Важно! Убедитесь лишний раз в правильности использования круглых скобок в выражении с указателями. В противном случае ошибку будет трудно отыскать, поскольку внешне программа может выглядеть вполне корректной. Если у вас есть сомнения в необходимости их использования, примите решение в их пользу — вреда от этого не будет.
В действительности в C++ предусмотрено два способа доступа к элементам массивов: с помощью индексирования массивов и арифметики указателей. Дело в том, что арифметические операции над указателями иногда выполняются быстрее, чем индексирование массивов, особенно при доступе к элементам, расположение которых отличается строгой упорядоченностью. Поскольку быстродействие часто является определяющим фактором при выборе тех или иных решений в программировании, то использование указателей для доступа к элементам массива— характерная особенность многих С++-программ. Кроме того, иногда указатели позволяют написать более компактный код по сравнению с использованием индексирования массивов.
Чтобы лучше понять различие между использованием индексирования массивов и арифметических операций над указателями, рассмотрим две версии одной и той же программы. В этой программе из строки текста выделяются слова, разделенные пробелами. Например, из строки «Привет дружище» программа должна выделить слова «Привет» и «дружище». Программисты обычно называют такие разграниченные символьные последовательности лексемами (token). При выполнении программы входная строка посимвольно копируется в другой массив (с именем token) до тех пор, пока не встретится пробел. После этого выделенная лексема выводится на экран, и процесс продолжается до тех пор, пока не будет достигнут конец строки. Например, если в качестве входной строки использовать строку Это лишь простой тест., программа отобразит следующее.

Это

лишь

простой

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

// Программа разбиения строки на слова:

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

#include <iostream>

#include <cstdio>

using namespace std;

int main ()

{

char str[80];

char token[80];

char *p, *q;

cout << "Введите предложение: ";

gets (str);

p = str;

// Считываем лексему из строки.

while (*р) {

q = token; // Устанавливаем q для указания на начало массива token.

/* Считываем символы до тех пор, пока не встретится либо пробел, либо нулевой символ (признак завершения строки). */

while (*p != ' ' && *р) {

*q = *р;

q++; р++;

}

if (*p) р++; // Перемещаемся за пробел.

*q = '\0'; // Завершаем лексему нулевым символом.

cout << token << '\n';

}

return 0;

}
А вот как выглядит версия той же программы с использованием индексирования массивов.

// Программа разбиения строки на слова:

// версия с использованием индексирования массивов.

#include <iostream>

#include <cstdio>

using namespace std;

int main ()

{

char str[80];

char token[80];

int i, j;

cout << "Введите предложение: ";

gets (str);

// Считываем лексему из строки.

for (i=0; ; i++) {

/* Считываем символы до тех пор пока не встретится либо пробел, либо нулевой символ (признак завершения строки). */

for (j=0; str[i]!=' ' && str[i]; j++, i++)

token[j] = str[i];

token[j] = '\0'; // Завершаем лексему нулевым символом.

cout << token << '\n';

if (!str[i]) break;

}

return 0;

}
У этих программ может быть различное быстродействие, что обусловлено особенностями генерирования кода С++-компиляторами. Как правило, при использовании индексирования массивов генерируется более длинный код (с большим количеством машинных команд), чем при выполнении арифметических действий над указателями. Поэтому неудивительно, что в профессионально написанном С++-коде чаще встречаются версии, ориентированные на обработку указателей. Но если вы— начинающий программист, смело используйте индексирование массивов, пока не научитесь свободно обращаться с указателями.
Индексирование указателя
Как было показано выше, можно получить доступ к массиву, используя арифметические действия над указателями. Интересно то, что в C++ указатель, Который ссылается на массив, можно индексировать так, как если бы это было имя массива (это говорит о тесной связи между указателями и массивами). Соответствующий такому подходу синтаксис обеспечивает альтернативу арифметическим операциям над указателями, поскольку он более удобен в некоторых ситуациях. Рассмотрим пример.

// Индексирование указателя подобно массиву.

#include <iostream>

#include <cctype>

using namespace std;

int main ()

{

char str[20] = «I love you»;

char *p;

int i;

p = str;

// Индексируем указатель.

for (i=0; p[i]; i++) p[i] = toupper (p[i]);

cout << p; // Отображаем строку.

return 0;

}
При выполнении программа отобразит на экране следующее.

I LOVE YOU
Вот как работает эта программа. Сначала в массив str вводится строка «I love you». Затем адрес начала этой строки присваивается указателю р. После этого каждый символ строки str с помощью функции toupper () преобразуется в его прописной эквивалент посредством индексирования указателя р. Помните, что выражение р[i] по своему действию идентично выражению *(p+i).
О взаимозаменяемости указателей и массивов
Выше было показано, что указатели и массивы очень тесно связаны. И действительно, во многих случаях они взаимозаменяемы. Например, с помощью указателя, который содержит адрес начала массива, можно получить доступ к элементам этого массива либо посредством арифметических действий над указателем, либо посредством индексирования массива. Однако в общем случае указатели и массивы не являются взаимозаменяемыми. Рассмотрим, например, такой фрагмент кода.

int num[10];

int i;

for (i=0; i<10; i++) {

*num = i; // Здесь все в порядке.

num++; // ОШИБКА — переменную num модифицировать нельзя.

}
Здесь используется массив целочисленных значений с именем num. Как отмечено в комментарии, несмотря на то, что совершенно приемлемо применить к имени num оператор «*» (который обычно применяется к указателям), абсолютно недопустимо модифицировать значение num. Дело в том, что num — это константа, которая указывает на начало массива. И ее, следовательно, инкрементировать никак нельзя. Другими словами, несмотря на то, что имя массива (без индекса) действительно генерирует указатель на начало массива, его значение изменению не подлежит.
Хотя имя массива генерирует константу-указатель, на него, тем не менее, (подобно указателям) можно включать в выражения, если, конечно, оно при этом не модифицируется. Например следующая инструкция, при выполнении которой элементу num[3] присваивается значение 100, вполне допустима.

*(num+3) = 100; // Здесь все в порядке, поскольку num не изменяется.
Указатели и строковые литералы
Возможно, вас удивит способ обработки С++-компиляторами строковых литералов, подобных следующему.

cout << strlen («С++-компилятор»);
Если С++-компилятор обнаруживает строковый литерал, он сохраняет его в таблице строк программы и генерирует указатель на нужную строку. Поэтому следующая программа совершенно корректна и при выполнении выводит на экран фразу: Работа с указателями — сплошное удовольствие!.

#include <iostream>

using namespace std;

int main ()

{

char *s;

s = «Работа с указателями — сплошное удовольствие!\n»;

cout << s;

return 0;

}
При выполнении этой программы символы, образующие строковый литерал, сохраняются в таблице строк, а переменной s присваивается указатель на соответствующую строку в этой таблице.
Таблица строк — это таблица, сгенерированная компилятором для хранения строк, используемых в программе.
Поскольку указатель на таблицу строк конкретной программы при использовании строкового литерала генерируется автоматически, то можно попытаться использовать этот факт для модификации содержимого данной таблицы. Однако такое решения вряд ли можно назвать удачным. Дело в том, что С++-компиляторы создают оптимизированные таблицы, в которых один строковый литерал может использоваться в двух (или больше) различных местах программы. Поэтому «насильственное» изменение строки может вызвать нежелательные побочные эффекты. Более того, строковые литералы представляют собой константы, и некоторые современные С++-компиляторы попросту не позволят менять их содержимое. А при попытке сделать это будет сгенерирована ошибка времени выполнения.
Все познается в сравнении
Выше отмечалось, что значение одного указателя можно сравнивать с другим. Но, чтобы сравнение указателей имело смысл, сравниваемые указатели должны быть каким-то образом связаны друг с другом. Чаще всего такая связь устанавливается в случае, когда оба указателя указывают на элементы одного и того же массива. Например, даны два указателя (с именами А и В), которые ссылаются на один и тот же массив. Если А меньше В, значит, указатель А указывает на элемент, индекс которого меньше индекса элемента, адресуемого указателем В. Такое сравнение особенно полезно для определения граничных условий.
Сравнение указателей демонстрируется в следующей программе. В этой программе создается две переменных типа указатель. Одна (с именем start) первоначально указывает на начало массива, а вторая (с именем end) — на его конец. По мере ввода пользователем чисел массив последовательно заполняется от начала к концу. Каждый раз, когда в массив вводится очередное число, указатель start инкрементируется. Чтобы определить, заполнился ли массив, в программе просто сравниваются значения указателей start и end. Когда start превысит end, массив будет заполнен «до отказа». Программе останется лишь вывести содержимое заполненного массива на экран.

// Пример сравнения указателей.

#include <iostream>

using namespace std;

int main ()

{

int num[10];

int *start, *end;

start = num;

end = &num[9];

while (start <= end) {

cout << "Введите число: «;

cin >> *start;

start++;

}

start << num; /* Восстановление исходного значения указателя */

while (start <= end) {

cout << *start << ' ';

start++;

}

return 0;

}
Как показано в этой программе, поскольку start и end оба указывают на общий объект (в данном случае им является массив num), их сравнение может иметь смысл. Подобное сравнение часто используется в профессионально написанном С++-коде.
Массивы указателей
Указатели, подобно данным других типов, могут храниться в массивах. Вот, например, как выглядит объявление 10-элементного массива указателей на int-значения.

int *ipa[10];
Здесь каждый элемент массива ipa содержит указатель на целочисленное значение.
Чтобы присвоить адрес int-переменной с именем var третьему элементу этого массива указателей, запишите следующее.

ipa[2] = &var;
Помните, что здесь ipa — массив указателей на целочисленные значения. Элементы этого массива могут содержать только значения, которые представляют собой адреса переменных целочисленного типа. Вот поэтому переменная var предваряется оператором Чтобы присвоить значение переменной var целочисленной переменной х с помощью массива ipa, используйте такой синтаксис.

x = *ipa[2];
Поскольку адрес переменной var хранится в элементе ipa[2], применение оператора „*“ к этой индексированной переменной позволит получить значение переменной var.
Подобно другим массивам, массивы указателей можно инициализировать. Как правило, инициализированные массивы указателей используются для хранения указателей на строки. Например, чтобы создать функцию, которая выводит счастливые предсказания, можно следующим образом определить массив fortunes,

char *fortunes[] = {

„Вскоре деньги потекут к Вам рекой.\n“,

„Вашу жизнь озарит новая любовь.\n“,

„Вы будете жить долго и счастливо.\n“,

„Деньги, вложенные сейчас в дело, принесут доход.\n“,

„Близкий друг будет искать Вашего расположения.\n“

};
Не забывайте, что C++ обеспечивает хранение всех строковых литералов в таблице строк, связанной с конкретной программой, поэтому массив нужен только Для хранения указателей на эти строки. Таким образом, для вывода второго сообщения достаточно использовать инструкцию, подобную следующей.

cout << fortunes[1];
Ниже программа предсказаний приведена целиком. Для получения случайных чисел используется функция rand (), а для получения случайных чисел в диапазоне от 0 до 4 — оператор деления по модулю, поскольку именно такие числа могут служить для доступа к элементам массива по индексу.

#include <iostream>

#include <cstdlib>

#include <conio.h>

using namespace std;

char *fortunes[] = {

„Вскоре деньги потекут к Вам рекой.\n“,

„Вашу жизнь озарит новая любовь.\n“,

„Вы будете жить долго и счастливо.\n“,

„Деньги, вложенные сейчас в дело, принесут доход.\n“,

„Близкий друг будет искать Вашего расположения.\n“

};

int main ()

{

int chance;

cout <<»Чтобы узнать свою судьбу, нажмите любую клавишу: ";

// Рандомизируем генератор случайных чисел.

while (!kbhit ()) rand ();

cout << '\n';

chance = rand ();

chance = chance % 5;

cout << fortunes[chance];

return 0;

}
Обратите внимание на цикл while, который вызывает функцию rand () до тех пор, пока не будет нажата какая-либо клавиша. Поскольку функция rand () всегда генерирует одну и ту же последовательность случайных чисел, важно иметь возможность программно использовать эту последовательность с некоторой произвольной позиции. (В противном случае каждый раз после запуска программа будет выдавать одно и то же «предсказание».) Эффект случайности достигается за счет повторяющихся обращений к функции rand (). Когда пользователь нажмет клавишу, цикл остановится на некоторой, случайной позиции последовательности генерируемых чисел, и эта позиция определит номер сообщения, которое будет выведено на экран. Напомню, что функция kbhit () представляет собой довольно распространенное расширение библиотеки функций C++, обеспечиваемое многими компиляторами, но не входит в стандартный пакет библиотечных функций C++.
В следующем примере используется двумерный массив указателей для создания программы, которая отображает синтаксис-памятку по ключевым словам C++. В программе инициализируется список указателей на строки. Первая размерность массива предназначена для указания на ключевые слова C++, а вторая — на краткое их описание. Список завершается двумя нулевыми строками, которые используются в качестве признака конца списка. Пользователь вводит ключевое слово, а программа должна вывести на экран его описание. Как видите, этот список содержит всего несколько ключевых слов. Поэтому его продолжение остается за вами.

// Простая памятка по ключевым словам C++.

#include <iostream>

#include <cstring>

using namespace std;

char *keyword[][2] = {

«for», «for (инициализация; условие; инкремент)»,

«if», "if (условие) ... else ... ",

«switch», «switch (значение) {case-список}»,

«while», «while (условие) ...»,

// Сюда нужно добавить остальные ключевые слова C++.

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

};

int main ()

{

char str[80];

int i;

cout << "Введите ключевое слово: ";

cin >> str;

// Отображаем синтаксис.

for (i=0; *keyword[i][0]; i++)

if (!strcmp (keyword[i][0], str))

cout << keyword[i][1];

return 0;

}
Вот пример выполнения этой программы.

Введите ключевое слово: for

for (инициализация; условие; инкремент)
В этой программе обратите внимание на выражение, управляющее циклом for. Оно приводит к завершению цикла, когда элемент keyword[i][0] содержит указатель на нуль, который интерпретируется как значение ЛОЖЬ. Следовательно, цикл останавливается, когда встречается нулевая строка, которая завершает массив указателей.
Соглашение о нулевых указателях
Объявленный, но не инициализированный указатель будет содержать произвольное значение. При попытке использовать указатель до присвоения ему конкретного значения можно разрушить не только собственную программу, но даже и операционную систему (отвратительнейший, надо сказать, тип ошибки!). Поскольку не существует гарантированного способа избежать использования неинициализированного указателя, С++-программисты приняли процедуру, которая позволяет избегать таких ужасных ошибок. По соглашению, если указатель содержит нулевое значение, считается, что он ни на что не ссылается. Это значит, что, если всем неиспользуемым указателям присваивать нулевые значения и избегать использования нулевых указателей, можно избежать случайного использования неинициализированного указателя. Вам следует придерживаться этой практики программирования.
При объявлении указатель любого типа можно инициализировать нулевым значением, например, как это делается в следующей инструкции,

float *р = 0; // р — теперь нулевой указатель.
Для тестирования указателя используется инструкция if (любой из следующих ее вариантов).

if (р) // Выполняем что-то, если р — не нулевой указатель.

if (!p) // Выполняем что-то, если р — нулевой указатель.
Соблюдая упомянутое выше соглашение о нулевых указателях, вы можете избежать многих серьезных проблем, возникающих при использование указателей.
Указатели и 16-разрядные среды
Несмотря на то что в настоящее время большинство вычислительных сред 32-разрядные, все же немало пользователей до сих пор работают в 16-разрядных (в основном, это DOS и Windows 3.1) и, естественно, с 16-разрядным кодом. Эти операционные системы были разработаны для процессоров семейства Intel 8086, которые включают такие модификации, как 80286, 80386, 80486 и Pentium (при работе в режиме эмуляции процессора 8086). И хотя при написании нового кода программисты, как правило, ориентируются на использование 32-разрядной среды выполнения, все же некоторые программы по-прежнему создаются и поддерживаются в более компактных 16-разрядных средах. Поскольку некоторые темы актуальны только для 16-разрядных сред, программистам, которые работают в них, будет полезно получить информацию о том, как адаптировать «старый» код к новой среде, т.е. переориентировать 16-разрядный код на 32-разрядный.
При написании 16-разрядного кода для процессоров семейства Intel 8086 программист вправе рассчитывать на шесть способов компиляции программ, которые различаются организацией компьютерной памяти. Программы можно компилировать для миниатюрной, малой, средней, компактной, большой и огромной моделей памяти. Каждая из этих моделей по-своему оптимизирует пространство, резервируемое для данных, кода и стека. Различие в организации компьютерной памяти объясняется использованием процессорами семейства Intel 8086 сегментированной архитектуры при выполнении 16-разрядного кода. В 16-разрядном сегментированном режиме процессоры семейства Intel 8086 делят память на 16К сегментов.
В некоторых случаях модель памяти может повлиять на поведение указателей и ваши возможности по их использованию. Основная проблема возникает при инкрементировании указателя за пределы сегмента. Рассмотрение особенностей каждой из 16-разрядных моделей памяти выходит за рамки этой книги. Главное, чтобы вы знали, что, если вам придется работать в 16-разрядной среде и ориентироваться на процессоры семейства Intel 8086, вы должны изучить документацию, прилагаемую к используемому вами компилятору, и подробно разобраться в моделях памяти и их влиянии на указатели.
И последнее. При написании программ для современной 32-разрядной среды необходимо знать, что в ней используется единственная модель организации памяти, которая называется одноуровневой, несегментированной или линейной (flat model).
Многоуровневая непрямая адресация
Можно создать указатель, который будет ссылаться на другой указатель, а тот — на конечное значение. Эту ситуацию называют многоуровневой непрямой адресацией (multiple indirection) или использованием указателя на указатель. Идея многоуровневой непрямой адресации схематично проиллюстрирована на рис. 6.2. Как видите, значение обычного указателя (при одноуровневой непрямой адресации) представляет собой адрес переменной, которая содержит некоторое значение. В случае применения указателя на указатель первый содержит адрес второго, а тот ссылается на переменную, содержащую определенное значение.
При использовании непрямой адресации можно организовать любое желаемое количество уровней, но, как правило, ограничиваются лишь двумя, поскольку увеличение числа уровней часто ведет к возникновению концептуальных ошибок.
Переменную, которая является указателем на указатель, нужно объявить соответствующим образом. Для этого достаточно перед ее именем поставить дополнительный символ «звездочка»(*). Например, следующее объявление сообщает компилятору о том, что balance — это указатель на указатель на значение типа int.

int **balance;
Необходимо помнить, что переменная balance здесь — не указатель на целочисленное значение, а указатель на указатель на int-значение.
Чтобы получить доступ к значению, адресуемому указателем на указатель, необходимо дважды применить оператор «*» как показано в следующем коротком примере.

// Использование многоуровневой непрямой адресации.

#include <iostream>

using namespace std;

int main ()

{

int x, *p, **q;

x = 10;

p = &x;

q = &p;

cout << **q; // Выводим значение переменной x.

return 0;

}
Здесь переменная p объявлена как указатель на int-значеине, а переменная q — как указатель на указатель на int-значеине. При выполнении этой программы мы получим значение переменной х, т.е. число 10.
Проблемы, связанные с использованием указателей
Для программиста нет ничего более страшного, чем «взбесившиеся» указатели! Указатели можно сравнить с энергией атома: они одновременно и чрезвычайно полезны и чрезвычайно опасны. Если проблема связана с получением указателем неверного значения, то такую ошибку отыскать труднее всего.
Трудности выявления ошибок, связанных с указателями, объясняются тем, что сам по себе указатель не обнаруживает проблему. Проблема может проявиться только косвенно, возможно, даже в результате выполнения нескольких инструкций после «крамольной» операции с указателем. Например, если один указатель случайно получит адрес «не тех» данных, то при выполнении операции с этим «сомнительным» указателем адресуемые данные могут подвергнуться нежелательному изменению, и, что самое здесь неприятное, это «тайное» изменение, как правило, становится явным гораздо позже. Такое «запаздывание» существенно усложняет поиск ошибки, поскольку посылает вас по «ложному следу». К тому моменту, когда проблема станет очевидной, вполне возможно, что указатель-виновник внешне будет выглядеть «безобидной овечкой», и вам придется затратить еще немало времени, чтобы найти истинную причину проблемы.
Поскольку для многих работать с указателями — значит потенциально обречь себя на поиски ответа на вопрос «Кто виноват?», мы попытаемся рассмотреть возможные «овраги» на пути отважного программиста и показать обходные пути, позволяющие избежать изматывающих «мук творчества».
Неинициализированные указатели
Классический пример ошибки, допускаемой при работе с указателями, — использование неинициализированного указателя. Рассмотрим следующий фрагмент кода.

// Эта программа некорректна.

int main ()

{

int х, *р;

х = 10;

*р = х; // На что указывает переменная р?

return 0;

}
Здесь указатель р содержит неизвестный адрес, поскольку он нигде не определен. У вас нет возможности узнать, где записано значение переменной х. При небольших размерах программы (например, как в данном случае) ее странности (которые заключаются в том, что указатель р содержит адрес, не принадлежащий ни коду программы, ни области данных) могут никак не проявляться, т.е. программа внешне будет работать нормально. Но по мере ее развития и, соответственно, увеличения ее объема, вероятность того, что р станет указывать либо на код программы, либо на область данных, возрастет. В один прекрасный день программа вообще перестанет работать. Способ не допустить создания таких программ очевиден: прежде чем использовать указатель, позаботьтесь о том, чтобы он ссылался на что-нибудь действительное!
Некорректное сравнение указателей
Сравнение указателей, которые не ссылаются на элементы одного и того же массива, в общем случае некорректно и часто приводит к возникновению ошибок. Никогда не стоит полагаться на то, что различные объекты будут размещены в памяти каким-то определенным образом (где-то рядом) или на то, что все компиляторы и операционные среды будут обрабатывать ваши данные одинаково. Поэтому любое сравнение указателей, которые ссылаются на различные объекты, может привести к неожиданным последствиям. Рассмотрим пример.

char s[80];

char у[80];

char *p1, *р2;

p1 = s;

р2 = у;

if (p1 < р2) . . .
Здесь используется некорректное сравнение указателей, поскольку C++ не дает никаких гарантий относительно размещения переменных в памяти. Ваш код должен быть написан таким образом, чтобы он работал одинаково устойчиво вне зависимости от того, где расположены данные в памяти.
Было бы ошибкой предполагать, что два объявленных массива будут расположены в памяти «плечом к плечу», и поэтому можно обращаться к ним путем индексирования их с помощью одного и того же указателя. Предположение о том, что инкрементируемый указатель после выхода за границы первого массива станет ссылаться на второй, совершенно ни на чем не основано и потому неверно. Рассмотрим этот пример внимательно.

int first[101;

int second[10];

int *p, t;

p = first;

for (t=0; t<20; ++t) {

*p = t;

p++;

}
Цель этой программы — инициализировать элементы массивов first и second числами от 0 до 19. Однако этот код не позволяет надеяться на достижение желаемого результата, несмотря на то, что в некоторых условиях и при использовании определенных компиляторов эта программа будет работать так, как задумано автором. Не стоит полагаться на то, что массивы first и second будут расположены в памяти компьютера последовательно, причем первым обязательно будет массив first. Язык C++ не гарантирует определенного расположения объектов в памяти, и потому эту программу нельзя считать корректной.
Не забывайте об установке указателей
Следующая (некорректная) программа должна принять строку, введенную с клавиатуры, а затем отобразить ASCII-код для каждого символа этой строки. (Обратите внимание на то, что для вывода ASCII-кодов на экран используется операция приведения типов.) Однако эта программа содержит серьезную ошибку.

// Эта программа некорректна.

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char s [80];

char *p1;

p1 = s;

do {

cout << "Введите строку: ";

gets (p1); // Считываем строку.

// Выводим ASCII-значения каждого символа.

while (*p1) cout << (int) *p1++ << ' ';

cout << ' \n';

}while (strcmp (s, «конец»));

return 0;

}
Сможете ли вы сами найти здесь ошибку?
В приведенном выше варианте программы указателю p1 присваивается адрес массива s только один раз. Это присваивание выполняется вне цикла. При входе в do-while-цикл (т.е. при первой его итерации) p1 действительно указывает на первый символ массива s. Но при втором проходе того же цикла p1 указатель будет содержать значение, которое останется после выполнения предыдущей итерации цикла, поскольку указатель p1 не устанавливается заново на начало массива s. Рано или поздно граница массива s будет нарушена.
Вот как выглядит корректный вариант той же программы.

// Эта программа корректна.

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char s[80];

char *p1;

do {

p1 = s; // Устанавливаем p1 при каждой итерации цикла.

cout << "Введите строку: ";

gets (p1); // Считываем строку.

// Выводим ASCII-значения каждого символа.

while (*p1) cout << (int) *p1++ <<' ';

cout << '\n';

}while (strcmp (s, «конец»));

return 0;

}
Итак, в этом варианте программы в начале каждой итерации цикла указатель p1 устанавливается на начало строки.
Узелок на память. Чтобы использование указателей было безопасным, нужно в любой момент знать, на что они ссылаются.

Комментирование и размещение ссылок запрещено.

Комментарии закрыты.