Сообщений 23    Оценка 41 [+0/-3]         Оценить

Размещение объектов в оперативной памяти. Понятие указателя. Часть 2.

Арифметика указателей, массивы.

Автор: Костарев Александр Николаевич
Источник: RSDN Magazine #3-2010

Опубликовано: 15.07.2011
Исправлено: 10.12.2016
Версия текста: 1.1

Массивы, оператор индексации, базовые операции над указателями Практические примеры — функции strcpy и strlen Вместо заключения Полезные упражнения Список литературы

Под арифметикой указателей (или адресной арифметикой) понимают правила применения к указателям арифметических операций. Допустимыми являются операции: сложение указателя с целым числом, вычитание из указателя целого числа, вычитание одного указателя из другого, а также операции сравнения указателей >, >=, <, <=, ==, !=. Сравнение указателей, равно как и вычитание одного указателя из другого, возможно только в случае однотипных указателей (указателей на объекты одного типа).

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

Массивы, оператор индексации, базовые операции над указателями

Массив — это упорядоченный набор (коллекция) однотипных объектов, размещаемых в едином блоке памяти последовательно друг за другом. Однотипные объекты, входящие в состав массива, называют элементами массива. Каждому элементу массива соответствует порядковый номер — индекс. Индексация элементов начинается с нуля: начальный (первый) элемент массива имеет индекс 0, следующий за ним (второй) — индекс 1, следующий за вторым (третий) — индекс 2 и т. д. Последний элемент массива из k элементов имеет индекс k – 1.

Рис. 1. Массив из k элементов

Размещение элементов массива в едином блоке памяти является ключевой особенностью массивов. Такое размещение позволяет максимально эффективно получать доступ к любому наперёд заданному элементу массива. Действительно, зная адрес массива — номер ячейки памяти, начиная с которой в ней последовательно располагаются элементы массива, иными словами, зная адрес элемента с индексом 0, и учитывая, что все элементы массива в силу их однотипности занимают в памяти одинаковое количество ячеек, можно легко получить адрес элемента с любым заданным индексом i. Для этого достаточно i раз выполнить смещение от начала массива на количество ячеек, занимаемое одним элементом или, что то же самое, выполнить смещение от начала массива на количество ячеек, равное произведению индекса требуемого элемента на количество ячеек, занимаемое одним элементом (см. рис. 1). Выполнение подобных смещений реализуется с помощью арифметических операций над указателями.

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

      #include <iostream>
usingnamespace std;

void main()
{
  int arr[3] = {10, 20, 30};

  int k = 6;
  short* vec = newshort[k];  // sizeof(short) = 2

  cout << arr[0] << endl << arr[1] << endl << arr[2] << endl;

  vec[0] = 17;
  cout << vec[0] << endl << *vec << endl;

  *vec = 29;
  cout << vec[0] << endl;

  vec[2] = 103;
  cout << vec[2] << endl << *(vec + 2) << endl;

  short* p = vec + 4;
  *p = 107;

  cout << vec[4] << endl;

  cout << p – 4 << endl << vec << endl;
  cout << *(p – 4) << endl;

  delete[] vec;
}

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

      int arr[3] = {10, 20, 30};

В этой строке определяется массив с именем arr из трёх объектов целочисленного типа int, которые инициализируются значениями 10, 20 и 30 соответственно.

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

      int arr[3] = {10, 20, };

При таком определении элемент с индексом 0 массива arr будет иметь значение 10, следующий за ним — значение 20, остальные — значение по умолчанию, каковым для объектов большинства встроенных типов является число 0.

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

При выполнении первой строки кода функции main в стеке будут выделены ячейки под размещение трёх объектов типа int. В эти ячейки будут записаны значения 10, 20 и 30. Рис. 2 иллюстрирует состояние памяти после выполнения данной строки кода.

Рис. 2

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

С/C++ позволяют создавать в стеке только массивы фиксированного размера. Из этого следует, что в определении массива в квадратных скобках может быть указано только константное выражение — литеральные константы, как в разбираемом примере, или символические константы, как во фрагменте кода ниже:

      const
      int n = 3;
int arr[n] = {10, 20, };

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

Наличие модификатора const в определении объекта n существенно. Без этого модификатора n становится переменной; использование переменной для задания размера массива arr приведёт к ошибке компиляции — у компилятора исключительно формальный подход к идентификации константных выражений.

Перейдём теперь к рассмотрению массивов, размещаемых в динамической памяти — в куче. Следующие две строчки функции main демонстрируют создание массива в динамической памяти:

      int k = 6;
short* vec = newshort[k];  // sizeof(short) = 2

Здесь определяется локальная переменная k — объект целочисленного типа int, инициализируемый значением 6, предназначенный для хранения размера массива. Далее, при помощи специальной формы оператора new (с квадратными скобками), в динамической памяти создается массив из k объектов типа short.

Формат вызова оператора new в случае создания массива объектов таков: ключевое слово «new», за которым следует тип элементов массива, за которым в квадратных скобках указывается размер массива — количество составляющих его объектов.

В целом оператор new с квадратными скобками (далее — оператор new[ ]) выполняет действия аналогичные тем, что выполняет рассмотренная в первой части статьи форма оператора new без квадратных скобок, используемая для создания в куче одного объекта. Вначале оператор new[ ] запрашивает у диспетчера памяти блок памяти, достаточный для размещения заданного количества элементов заданного типа. Размер запрашиваемого блока памяти рассчитывается как произведение количества элементов массива на количество ячеек, занимаемых одним элементом. Затем, в случае успешного выделения памяти, оператор new[ ] для каждого из создаваемых объектов вызывает конструктор, выполняющий начальную инициализацию отведённой под объект памяти. Возвращаемым значением оператора new[ ] является адрес первого элемента массива (адрес объекта с индексом 0). В тех случаях, когда диспетчер памяти не смог найти свободный блок требуемого размера, оператор new[ ] генерирует исключение std::bad_alloc.

Отметим, что значение переменной k, т. е. размер массива, мы могли бы не задавать непосредственно в коде, а ввести с клавиатуры, считать из файла или получить каким-либо ещё способом во время выполнения программы.

Конфигурация памяти после выполнения двух рассматриваемых строк кода представлена на рис. 3.

Рис. 3

Для большей определённости будем считать, что созданный оператором new[ ] массив из k (k = 6) объектов типа short располагается в куче по адресу 0xF838, т. е. объекты массива занимают с 63544 по 63555 ячейки включительно. Первый объект занимает ячейки 0xF838 и 0xF839, второй — 0xF83A и 0xF83B, третий — 0xF83С и 0xF83В и т. д.

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

      short* vec = newshort[k];  // sizeof(short) = 2

порождает в памяти k + 1 объект: массив из k объектов целочисленного типа short в куче и объект-указатель vec в стеке. Адрес начального элемента созданного в куче массива — число 0xF838 — является значением стекового объекта-указателя vec (см. рис. 3).

Для доступа к элементам массива, независимо от региона памяти, в котором массив создан, используется оператор индексации (оператор [ ]), возвращающий элемент массива по его индексу.

Строка функции main:

cout << arr[0] << " " << arr[1] << " " << arr[2] << endl;

демонстрирует применение оператора [ ] для доступа к элементам размещённого в стеке массива arr. Результатом её выполнения будет отображение на экране чисел 10, 20 и 30 (см. рис. 3).

В следующей строке функции main с использованием оператора индексации выполняется присваивание нового значения элементу с индексом 0 размещённого в куче массива vec.

vec[0] = 17;

В этой строке сначала, при помощи оператора [ ], осуществляется переход к соответствующему индексу 0 объекту массива vec, после чего полученному объекту присваивается новое значение — в ячейки памяти, отведённые под этот объект, записывается число 17.

Состояние памяти после выполнения данной строки кода отражено на рис. 4.

Рис. 4

Заметьте, что, с одной стороны, vec — это имя созданного в куче массива, а с другой — указатель на его начальный элемент (см. определение переменной vec), и, следовательно, к vec можно применить операцию разыменования (операцию *). Операция разыменования обеспечивает переход от указателя на объект к объекту, расположенному в памяти по адресу, хранимому в указателе, т. е. в случае с vec — к начальному элементу массива, объекту, который соответствует индексу 0.

Распечатав значение начального элемента массива и значение объекта, на который указывает vec

cout << vec[0] << endl << *vec << endl;

мы получим один и тот же результат — число 17. Именно оно является значением объекта с индексом 0, и именно на этот объект указывает переменная vec.

Задание нового значения объекту, адресуемому указателем vec:

*vec = 29;

незамедлительно отразится и на значении начального элемента массива vec (рис. 5).

Рис. 5

Выполнение строки кода ниже приведёт к отображению числа 29.

cout << vec[0] << endl;

Таким образом, выражения vec[0] и *vec эквивалентны — они идентифицируют один и тот же объект в памяти.

Рассмотрим теперь обращение к отличному от начального элементу массива, например, к третьему:

vec[2] = 103;

В соответствии с семантикой оператора индексации, здесь осуществляется переход к объекту массива vec с индексом 2, после чего полученному объекту присваивается новое значение — в отведённые под этот объект ячейки памяти записывается число 103 (рис. 6).

Рис. 6

Чтобы осуществить переход к элементу массива с индексом 2, оператору [ ], прежде всего, необходимо получить адрес этого элемента. Как отмечалось ранее, для этого достаточно выполнить смещение от начала массива на количество ячеек, равное произведению индекса требуемого элемента и количества ячеек (байтов), занимаемых одним элементом, т. е. смещение на 2 * sizeof(short) = 4 байта. Так как оператор [ ] в конечном итоге применяется к указателю на начальный элемент массива, то информация о типе элементов массива и адресе начального элемента у него есть.

Для выполнения смещения — здесь мы переходим к адресной арифметике — оператор [ ] производит сложение указателя на начальный элемент массива с индексом требуемого элемента: vec + 2. Результатом вычисления этого выражения будет адрес третьего элемента массива (элемента с индексом 2).

Суть операции сложения указателяpс целым числомi состоит в следующем: если p указывает на некоторый элемент массива объектов типа T, то p + i указывает на i-й после того, на который указывает p, элемент массива (рис. 7). Результатом сложения будет указатель на объект того же типаT; значение этого указателя (номер адресуемой им ячейки памяти) будет на i * sizeof(T) больше значения p (как видно, при расчете адреса учитывается тип объекта, на который указывает p).

Рис. 7. Указатель на элемент массива из k объектов

Если p указывает на объект, который не является элементом массива, то результат сложения p с целым числом не определён (причём к ошибке компиляции такое сложение не приведёт — ошибка возникнет в процессе выполнения программы).

В нашем случае vec — это указатель на начальный элемент массива, следовательно, при вычислении выражения vec + 2 мы должны получить указатель на второй после начального, т. е. на третий элемент массива. В условиях наших допущений о расположении объектов в памяти имеем:

vec + 2 = vec + 2*sizeof(short) = 0xF838 + 2*2 = 0xF838 + 4 = 0xF83C.

Число 0xF83C есть ни что иное как адрес третьего элемента массива (адрес объекта, соответствующего индексу 2) (см. рис. 6).

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

Если распечатать значения элемента массива с индексом 2 и объекта, на который указывает vec + 2:

cout << vec[2] << endl << *(vec + 2) << endl;

то получится один и тот же результат — число 103, что подтверждает наши рассуждения.

При необходимости результат сложения указателя с целым числом можно сохранить в переменной подходящего типа:

      short* p = vec + 4;

Здесь определяется переменная p, являющаяся, как и vec, указателем на объект типа short. Эта переменная инициализируется адресом элемента с индексом 4 массива vec.

Конфигурация памяти после выполнения данной строки программы показана на рис. 8.

Рис. 8

Сделав такое определение, мы можем обращаться к пятому элементу массива (для чтения и изменения данных, хранящихся в отведённых под него ячейках) не только с использованием оператора индексации, как к vec[4], но и посредством указателя p.

К примеру, следующий код

*p = 107;

производит запись числа 107 в ячейки памяти, отведённые под объект, адрес которого хранится в указателе p, т. е. в ячейки памяти, занимаемые объектом vec[4] (рис. 9).

Рис. 9

Если теперь распечатать значение элемента с индексом 4

cout << vec[4] << endl;

то на экран будет выведено число 107.

Как отмечалось ранее, к указателям применима не только операция сложения с целым числом, но и операция вычитания из указателя целого числа. Определяется эта операция аналогично сложению: если p указывает на некоторый элемент массива объектов типа T, а i — целое число, то p – i указывает на i-й элемент массива перед тем, на который указывает p (см. рис. 7). Результатом вычитания будет указатель на объект того же типаT; значение этого указателя (номер адресуемой им ячейки памяти) будет на i * sizeof(T) меньше значения p.

Например, вычисление выражения p – 4, где p — указатель на элемент массива vec с индексом 4, даст адрес начального элемента массива, что подтверждается выполнением следующей строки функции main:

cout << p – 4 << endl << vec << endl;

В обоих случаях на экран будет выведено одно и то же число (0000F838), так как в условиях наших допущений о расположении объектов в памяти:

p – 4 = p – 4* sizeof(short) = 0xF840 – 4*2 = 0xF838

Число 0xF838 — это адрес начального элемента массива, значение переменной vec (см. рис. 9).

Соответственно, следующая строка программы:

cout << *(p - 4) << endl;

приведёт к отображению на экране числа 29 — значения начального элемента массива.

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

Так, для обращения к начальному элементу созданного в стеке массива arr можно использовать выражение *arr, для обращения к элементу с индексом 1 — выражение *(arr + 1) и т. п.

Таким образом, мы можем наблюдать тесную связь массивов и указателей: имя массива является указателем на его начальный элемент, а любые вычисления, выполняемые с использованием оператора индексации, могут быть произведены через соответствующие операции над указателями — выражения vec[i] и *(vec + i) тождественны.

Для удаления созданного в куче массива объектов используется оператор delete с квадратными скобками:

      delete[] vec;

Оператор delete с квадратными скобками (далее — оператор delete[ ]), подобно рассмотренному в первой части статьи оператору delete без квадратных скобок, производит действия, в точности обратные тем, что совершает оператор new[ ] при создании массива объектов. Сначала оператор delete[ ] для каждого из созданных оператором new[ ] объектов вызывает деструктор. После этого он обращается к диспетчеру памяти, передаёт ему адрес массива объектов (адрес начального элемента) и сообщает, что работа с областью памяти, занимаемой в куче объектами этого массива, завершена. Диспетчер памяти освобождает идентифицируемый указанным адресом блок памяти.

Возникает интересный вопрос: как оператор delete[ ], получая в качестве аргумента только указатель на начальный элемент массива, узнаёт количество элементов в этом массиве — количество объектов, для которых нужно вызвать деструктор? Секрет в том, что оператор new[ ] (точнее, его реализация в большинстве компиляторов C++) выделяет на несколько ячеек памяти больше, чем требуется для размещения массива объектов. В дополнительные ячейки записываются данные о размере создаваемого массива. Располагаются эти данные непосредственно перед начальным элементом массива — перед тем адресом, который возвращает оператор new[ ].

Так, вполне вероятно, что при выполнении рассмотренной ранее строки кода:

      short* vec = newshort[k];

оператор new[ ], обращаясь к диспетчеру памяти, запросил у него не k * sizeof(short) ячеек памяти, а k * sizeof(short) + sizeof(int). Диспетчер выделил блок памяти, начинающийся, в условиях наших предыдущих допущений, с ячейки 0xF834, и вернул оператору new[ ] адрес этого блока. Оператор new[ ] в первые четыре ячейки полученного блока записал значение переменной k (в нашем примере — число 6), а адрес следующей за этими четырьмя ячейками — число 0xF838 — вернул как адрес созданного массива объектов (рис. 10).

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

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

Оператор delete[ ] знает о том, что оператор new[ ] записывает данные о количестве элементов массива перед его начальным элементом, а также о том, сколько ячеек памяти отводится под хранение этих данных. Следовательно, он может по адресу начального элемента определить размер массива — количество объектов, для которых нужно вызвать деструктор.

Из приведённых рассуждений следует, что необходимо строго соблюдать парность операторов создания и удаления объектов в куче: объекты, созданные оператором new, должны быть удалены оператором delete; объекты, созданные оператором new[ ], должны быть удалены оператором delete[ ]. Нарушение парности этих операторов не выявляется на этапе компиляции, и хотя то, как на самом деле выделяется память, зависит от конкретного компилятора, в большинстве случаев такое нарушение приводит к нестабильному выполнению программы.

Массивы, созданные в стеке (более точно, объекты, входящие в их состав), подобно любым другим создаваемым в стеке объектам, автоматически разрушаются в точке выхода имени массива из области видимости. В нашем примере объекты, входящие в состав массива arr, будут разрушены в момент выхода процесса выполнения из функции main, равно как и целочисленный объект k, объекты-указатели vec и p.

Практические примеры — функции strcpy и strlen

Вернёмся к арифметике указателей. Определённые над указателями арифметические операции позволяют писать эффективный, компактный и элегантный код. Ярким примером этому является реализация функций работы со строками в стандартной библиотеке С/C++.

Рассмотрим функцию копирования строки strcpy:

      char* strcpy(char* t, constchar* s)
{
   char* p = t;
   while(*p++ = *s++);
   return t;
}

Функция strcpy принимает в качестве параметров два указателя: указатель s на исходную строку (на массив символов, которые надо скопировать) и указатель t на результирующую строку (на буфер, в который надо скопировать символы строки s). Предполагается, что память под массив, адресуемый указателем t, выделена, и её достаточно для размещения всех символов строки s.

Для примера предположим, что s указывает на строку «Hello world», размещённую в памяти по адресу 0xF850, а t — на буфер, размещённый по адресу 0xF88C (рис. 11).

Рис. 11. Состояние памяти перед первой итерацией цикла

Непосредственно копирование символов осуществляется во второй строке функции:

      while(*p++ = *s++);

Эта строка содержит цикл while с пустым телом. Цикл выполняется до тех пор, пока истинно значение выражения в круглых скобках. В C++ значение выражения истинно, когда оно отлично от 0.

Выражение *p++ = *s++ является выражением присваивания: объекту, получаемому в результате вычисления подвыражения, стоящего слева от знака равенства, присваивается значение подвыражения, стоящего справа от знака равенства. Значением выражения присваивания является значение левостороннего операнда (объекта) после выполнения, собственно, присваивания. Рассмотрим подробно конструкцию:

*p++

Поскольку для указателей определены операции сложения с целым числом и вычитания целого числа, то определены и производные от них операции, в частности, операции префиксного и постфиксного инкремента и декремента (++ и --), которые часто используются для реализации итераций по массиву объектов.

Операция постфиксного инкремента имеет более высокий приоритет, чем операция разыменования, следовательно, в выражении *p++ сначала к указателю p применяется операция постфиксного инкремента, после чего к её результату (к значению, возвращенному операцией постфиксного инкремента) применяется операция разыменования.

Инкремент указателя — это увеличение значения указателя на единицу, т. е. сложение значения указателя с числом 1 и сохранение адреса, полученного в результате сложения, в ячейках памяти, отведённых под этот указатель. Так, если значением указателя был адрес i элемента массива, то после выполнения операции инкремента значением указателя будет адрес следующего, i + 1 элемента (соответственно, после выполнения операции декремента значением указателя будет адрес предыдущего, i - 1 элемента).

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

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

Вернёмся ко второй строке функции strcpy:

      while(*p++ = *s++);

В начальный момент времени — перед выполнением цикла — переменная s указывает на первый элемент исходного массива символов (на символ ‘H’ копируемой строки); p указывает на первый элемент буфера t (также являющегося массивом символов) (см. рис. 11).

Выполнение цикла while начинается с проверки истинности условия цикла, т. е. с вычисления значения выражения *p++ = *s++.

Сначала вычисляется правостороннее подвыражение *s++. К указателю s применяется постфиксный оператор инкремента, который увеличивает значение указателя на единицу и превращает его, таким образом, из указателя на первый символ исходной строки в указатель на второй символ — символ ‘e’. К возвращаемому операцией постфиксного инкремента значению, т. е. к начальному значению указателя s, применяется операция разыменования, посредством которой осуществляется переход от указателя на первый элемент массива непосредственно к первому элементу — объекту типа char, значением которого является код символа ‘H’. Это же значение является значением всего подвыражения.

Аналогичным образом вычисляется левостороннее подвыражение *p++: после его выполнения указатель p будет адресовать второй элемент массива t; операция разыменования применяется к указателю на первый элемент массива t.

Далее объекту, полученному в результате вычисления левостороннего подвыражения, присваивается новое значение: в ячейки памяти (более точно — “в ячейку памяти”, sizeof(char) = 1), отведённые под первый элемент массива t, записываются данные, хранящиеся в ячейках, отведённых под первый элемент копируемого массива — код символа ‘H’ (рис. 12).

Рис. 12. Состояние памяти после выполнения первой итерации цикла

Значением всего выражения присваивания *p++ = *s++ будет значение левостороннего операнда после выполнения присваивания — новое значение первого элемента массива символов t — код символа ‘H’. Этот код отличен от 0, следовательно, условие цикла истинно, и поскольку тела у данного цикла нет, то после проверки истинности условия процесс выполнения сразу перейдет к следующей итерации цикла, которая вновь начнётся с вычисления значения выражения *p++ = *s++. При этом значения переменных s и p на предыдущей (первой) итерации были изменены так, что на момент начала второй итерации они указывают соответственно на второй символ исходной строки и на второй элемент массива t (см. рис. 12), а значит, повторное вычисление выражения *p++ = *s++ приведёт к копированию второго символа строки — символа ‘e’.

Выполнение цикла завершится, когда значение условного выражения цикла станет ложным, т. е. тогда, когда будет скопирован завершающий исходную строку 0 (рис. 13).

Рис. 13. Состояние памяти после выполнения последней итерации цикла

С использованием оператора индексации рассмотренный цикл копирования строки можно было бы записать так:

      int i = 0;

while(p[i] = s[i])
  ++i;

или так:

      for(int i = 0; p[i] = s[i]; ++i)
  ;

или так:

      int i = 0;

for(i = 0; s[i] != 0; ++i)
  p[i] = s[i];

p[i] = 0;

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

Возможно, выражение while(*p++ = *s++) на первый взгляд и кажется непонятным, однако такая запись удобна, на практике подобный код встречается. О важности его понимания говорит и тот факт, что разобранный нами пример рассмотрен также в книге Бьерна Страуструпа «Язык программирования C++» [1] и книге Брайана Кернигана и Денниса Ритчи «Язык программирования C» [2]. Дополнительно о важности знания аспектов реализации функции strcpy можно почитать в книгах Джоэла Спольски «Джоэл о программировании” [6] и “Джоэл: и снова о программировании» [10].

В заключение раздела рассмотрим операцию вычитания одного указателя из другого. С использованием данной операции реализуется, в частности, функция вычисления длины строки strlen стандартной библиотеки C/C++.

      int strlen(constchar* s)
{
  constchar* p = s;

  while(*p)
  ++p;

  return p - s;
}

Суть операции вычитания одного указателя из другого состоит в следующем: если p1 и p2 указывают на элементы одного и того же массива, и при этом p1 < p2, то значением выражения p2 – p1 + 1 будет количество элементов, расположенных в диапазоне от адресуемого p1 до адресуемого p2 включительно (см. рис. 7).

Вместо заключения

Значительная часть ошибок при работе с памятью связана с её утечками, т. е. с не освобождением или неправильным освобождением ранее выделенной динамической памяти. В частности, распространённой ошибкой является удаление массива объектов оператором delete вместо оператора delete[ ]. Такая подмена операторов может никак не проявиться при удалении массива объектов встроенного типа, но при разрушении массива сложных объектов, например массива строк (объектов типа std::string), использование оператора delete приведёт к тому, что будет удалена только первая строка, остальные останутся в памяти. Для обнаружения ошибок подобного рода созданы специальные инструментальные средства, одно из которых было рассмотрено в первой части статьи.

Хуже обстоят дела с другим видом ошибок — ошибками, вызванными повреждением («протиркой») памяти. Такие ошибки возникают при обращениях по недействительным указателям, в том числе, при выходе в процессе обработки элементов массива за его пределы. Разыменование недействительного указателя и последующая модификация адресуемых им данных часто не заканчиваются аварийным завершением работы программы, а приводит к изменению состояния объекта, который может в этот момент находиться на месте ранее удаленного объекта, что неминуемо нарушает логику работы программы. Последствия подобных ошибок проявляются в совершенно непредсказуемых местах, причём добиться их стабильного проявления бывает весьма сложно.

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

Полезные упражнения

1. Выполните ввод с клавиатуры двух целочисленных массивов, сформируйте и выведите на экран третий массив, получаемый вставкой всех элементов второго массива после заданного элемента первого.
2. Выполните ввод с клавиатуры двух строк, сформируйте и выведите на экран третью строку, являющуюся конкатенацией введённых.

Список литературы

1. Страуструп Б. Язык программирования С++. — 3-е изд.: Пер. с англ. — СПб.: Невский диалект; М.: Бином, 1999. — 991 с.
2. Керниган Б., Ритчи Д. Язык программирования C. — 2-е изд.: Пер. с англ. — М.: Издательский дом «Вильямс», 2009. — 304 с.
3. Мейерс С. Эффективное использование С++. 50 рекомендаций по улучшению ваших программ и проектов: Пер. с англ. — М.: ДМК, 2000. — 240 с.
4. Элджер Дж. С++: библиотека программиста: Пер. с англ. — СПб.: Питер, 2000. — 320 с.
5. Липпман С. Основы программирования на C++: Пер. с англ. — М.: Издательский дом «Вильямс», 2002. — 256 с.
6. Спольски Дж. Джоэл о программировании: Пер. с англ. — Спб.: Символ-Плюс, 2006. — 352 с.
7. Рихтер Д. Windows для профессионалов. — 4-е изд.: Пер. с англ. — СПб.: Питер; М.: Русская редакция, 2001. — 752 с.
8. Мейерс С. Наиболее эффективное использование С++. 35 новых рекомендаций по улучшению ваших программ и проектов: Пер. с англ. — М.: ДМК Пресс, 2000. — 304 с.
9. Страуструп Б. Дизайн и эволюция C++: Пер. с англ. — М.: ДМК Пресс, 2000. — 448 с.
10. Спольски Дж. Джоэл: и снова о программировании: Пер. с англ. — СПб.: Символ-Плюс, 2009. — 320 с.
11. Буч Г. Объектно-ориентированный анализ и проектирование с примерами приложений на C++. — 2-е изд.: Пер. с англ. — М.: Издательство Бином; СПб.: Невский диалект, 1998. — 562 с.
12. Андерсон Д. Дискретная математика и комбинаторика: Пер. с англ. — М.: Издательский дом «Вильямс», 2003. — 960 с.

Сообщений 23    Оценка 41 [+0/-3]         Оценить