Перейти к содержимому

Арифметика указателей

  • Что делает сложение указателя и числа
  • Что дает отнимание двух указателей
  • UB в случае, если указатели не из того же блока
  • Целочисленные представления адресов и reinterpret_cast
  • Смещения полей
  • stack

Для фрагментов без main подключите <array> и <iostream> и поместите код в main.

std::array<int, 2> arr{};
int* p = &arr[0];
p = p + 1;
*p = 2;
std::cout << arr[1];
std::cout << std::endl;
Ответ

p + 1 перемещает указатель на 1 базовый элемент, то есть на 1 int, то есть на 4.

p в конце функции равен &arr[1]. Считывание из *p эквивалетно считыванию из arr[1].

2. Возврат адреса следующего элемента массива

Заголовок раздела «2. Возврат адреса следующего элемента массива»
#include <array>
#include <iostream>
int* nextElement(int* current)
{
return current + 1;
}
int main()
{
std::array<int, 3> arr{ 4, 7, 9 };
int* next{ nextElement(&arr[0]) };
*next = 8;
std::cout << arr[1] << std::endl;
}
Ответ

Печатает 8. Вызов возвращает int*, указывающий на arr[1], поэтому запись через next изменяет этот элемент. Массив принадлежит main и продолжает существовать после возврата из функции. Вызывающий код должен убедиться, что следующий элемент существует, прежде чем разыменовывать указатель.

std::array<int, 2> arr{};
int* p = &arr[0];
*(p + 1) = 6;
std::cout << *p << std::endl;
std::cout << arr[1] << std::endl;
Ответ

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

Еще важно заметить, что *(p + 1) не изменяет p, а создает временный измененный адрес. *p считает 0 из первой ячейки массива.

std::array<int, 2> arr{};
int* pStart = &arr[0];
int* p = pStart + 1;
ptrdiff_t x = p - pStart;
std::cout << x;
std::cout << std::endl;
ptrdiff_t x1 = pStart - p;
std::cout << x1;
std::cout << std::endl;
Ответ

Оператор - между указателями дает количество базовых элементов между ними. Результат может быть и отрицательным.

Выведется 1, а потом -1.

#include <cstdint>
#include <array>
#include <iostream>
int main()
{
std::array<int, 2> arr{};
int* a = &arr[0];
int* b = &arr[1];
uintptr_t a1 = reinterpret_cast<uintptr_t>(a);
uintptr_t b1 = reinterpret_cast<uintptr_t>(b);
ptrdiff_t x = static_cast<ptrdiff_t>(b1 - a1);
std::cout << x;
std::cout << std::endl;
}
Ответ

uintptr_t позволяет рассматривать адрес как целое число. reinterpret_cast<uintptr_t> преобразует указатель в такое целочисленное представление.

b1 - a1 вычитает адреса как числа. В этом выражении уже нет информации об исходных типах указателей. Оно работает с их числовыми значениями.

Результат обычно равен 4 — это разница адресов в байтах.

uintptr_t доступен на реализациях, где есть подходящий беззнаковый целочисленный тип. Если числовые адреса соответствуют позициям байтов, результат равен sizeof(int); здесь int занимает 4 байта. Способ преобразования указателя в число зависит от реализации, поэтому такое расстояние гарантируется не везде.

6. Вычитание указателей на однобайтовые элементы

Заголовок раздела «6. Вычитание указателей на однобайтовые элементы»
#include <array>
#include <cstddef>
#include <cstdint>
#include <iostream>
int main()
{
std::array<uint8_t, 5> arr{};
uint8_t* first{ &arr[0] };
uint8_t* last{ &arr[4] };
ptrdiff_t distance{ last - first };
std::cout << distance << std::endl;
}
Ответ

Печатает 4 — то же число, которое обычно получается в предыдущем примере. Здесь результат гарантирован: оба указателя указывают на элементы одного массива на расстоянии четырёх элементов. Каждый uint8_t занимает один байт, поэтому расстояние в элементах равно расстоянию в байтах. Приведение типов не нужно.

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

7. Адрес поля относительно адреса структуры

Заголовок раздела «7. Адрес поля относительно адреса структуры»
#include <cstdint>
#include <iostream>
struct A
{
int f;
};
int main()
{
A a { };
A* pa { &a };
int* pf { &pa->f };
uintptr_t fieldAddress{ reinterpret_cast<uintptr_t>(pf) };
uintptr_t objectAddress{ reinterpret_cast<uintptr_t>(pa) };
uintptr_t diff{ fieldAddress - objectAddress };
std::cout << diff << std::endl;
}
Ответ

Выведется 0. Первое поле этой структуры и сама структура находятся по одному адресу в памяти.

Код вычитает целочисленные представления адресов, а не указатели на структуру и её поле. Такой вывод предполагает, что преобразование этих указателей в числа сохраняет равенство адресов. Правило о первом поле относится к структурам со стандартным размещением, как A здесь.

#include <cstddef>
#include <iostream>
struct A
{
int a;
int b;
};
int main()
{
std::cout << offsetof(A, a) << std::endl;
std::cout << offsetof(A, b) << std::endl;
}
Ответ:

offsetof вычисляется при компиляции и даёт смещение указанного поля в байтах от начала структуры.

Обычно выведется 0 для a и 4 для b.

Точное смещение зависит от реализации и её правил выравнивания.

9. Весь массив и его первый элемент (продвинутый уровень)

Заголовок раздела «9. Весь массив и его первый элемент (продвинутый уровень)»
#include <array>
#include <cstdint>
#include <iostream>
int main()
{
std::array<int, 2> arr{ 1, 2 };
uintptr_t elementAddress{ reinterpret_cast<uintptr_t>(arr.data()) };
uintptr_t arrayAddress{ reinterpret_cast<uintptr_t>(&arr) };
uintptr_t diff{ elementAddress - arrayAddress };
std::cout << diff << std::endl;
}
Ответ

Начало всего объекта массива обычно находится по тому же адресу, что и его первый элемент. Представляйте std::array как его элементы, хранящиеся вместе.

Обычно выведется 0.

Стандарт не требует такого размещения для std::array. У arr.data() тип int*, а у &arr — std::array<int, 2>*. Вычитание чисел здесь предполагает, что реализация преобразует эти равные адреса в одинаковые числа. arr.data() гарантированно указывает на настоящий первый элемент; элементы принадлежат arr. Но весь контейнер и его первый элемент — разные объекты. Приведение этих указателей к одному типу указателя на байты само по себе не означает, что они указывают на элементы одного массива. Для вычитания указателей нужен этот общий массив, даже если напечатанные адреса совпадают.

10. Продвинутый уровень: адреса локальных переменных

Заголовок раздела «10. Продвинутый уровень: адреса локальных переменных»
#include <cstdint>
#include <iostream>
uintptr_t f()
{
int a;
return reinterpret_cast<uintptr_t>(&a);
}
uintptr_t g()
{
int b;
return reinterpret_cast<uintptr_t>(&b);
}
int main()
{
uintptr_t f1 { f() };
uintptr_t f2 { f() };
uintptr_t g1 { g() };
std::cout << f1 << std::endl;
std::cout << f2 << std::endl;
std::cout << g1 << std::endl;
}
Ответ

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

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

11. Чтение за пределами массива из одного элемента (углублённый уровень)

Заголовок раздела «11. Чтение за пределами массива из одного элемента (углублённый уровень)»
std::array<int, 1> value{ 5 };
int neighbor{ 6 };
int* p{ value.data() };
int* past{ p + 1 };
std::cout << *past << std::endl;
std::cout << neighbor << std::endl;
Ответ

Переход на один элемент вперёд выходит за единственный элемент value. Если эту память случайно занимает neighbor, чтение через past может напечатать 6 — его значение. Но отдельно объявленная переменная не обязательно располагается сразу после массива.

Получить указатель сразу за последним элементом можно; разыменовать его — неопределённое поведение. Первый вывод не гарантирован, даже если адреса случайно оказались соседними.

12. Запись за пределами массива (углублённый уровень)

Заголовок раздела «12. Запись за пределами массива (углублённый уровень)»
std::array<int, 2> arr{};
int neighbor{ 6 };
int* past{ arr.data() + arr.size() };
*past = 7;
std::cout << neighbor << std::endl;
Ответ

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

Если по этому адресу случайно хранится neighbor, запись может изменить его, и программа может напечатать 7.

Получить указатель past сразу за последним элементом можно, но запись через него — неопределённое поведение. Расположение neighbor и вывод программы не гарантированы.