Что такое разыменование указателя

Указатели в C абстрактнее, чем может показаться

Указатель ссылается на ячейку памяти, а разыменовать указатель — значит считать значение указываемой ячейки. Значением самого указателя является адрес ячейки памяти. Стандарт языка C не оговаривает форму представления адресов памяти. Это очень важное замечание, поскольку разные архитектуры могут использовать разные модели адресации. Большинство современных архитектур использует линейное адресное пространство или аналогичное ему. Однако даже этот вопрос не оговаривается строго, поскольку адреса могут быть физическими или виртуальными. В некоторых архитектурах используется и вовсе нечисловое представление. Так, Symbolics Lisp Machine оперирует кортежами вида (object, offset) в качестве адресов.

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

Если мы скомпилируем этот код GCC с уровнем оптимизации 1 и запустим программу под Linux x86-64, она напечатает следующее:

Обратите внимание, что указатели p и q ссылаются на один и тот же адрес. Однако результат выражения p == q есть false, и это на первый взгляд кажется странным. Разве два указателя на один и тот же адрес не должны быть равны?

Вот как стандарт C определяет результат проверки двух указателей на равенство:

Прежде всего возникает вопрос: что такое «объект»? Поскольку речь идёт о языке C, то очевидно, что здесь объекты не имеют ничего общего с объектами в языках ООП вроде C++. В стандарте C это понятие определяется не вполне строго:

Давайте разбираться. 16-битная целочисленная переменная — это набор данных в памяти, которые могут представлять 16-битные целочисленные значения. Следовательно, такая переменная является объектом. Будут ли два указателя равны, если один из них ссылается на первый байт данного целого числа, а второй — на второй байт этого же числа? Комитет по стандартизации языка, разумеется, имел в виду совсем не это. Но тут надо заметить, что на этот счёт у него нет чётких разъяснений, и мы вынуждены гадать, что же имелось в виду на самом деле.

Когда на пути встаёт компилятор

Вернёмся к нашему первому примеру. Указатель p получен из объекта a, а указатель q — из объекта b. Во втором случае применяется адресная арифметика, которая для операторов «плюс» и «минус» определена следующим образом:

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

Из этого следует, что результатом выражения &b + 1 совершенно точно должен быть адрес, и, значит, p и q — это валидные указатели. Напомню, как определено равенство двух указателей в стандарте: «Два указателя равны тогда и только тогда, когда [. ] один указатель ссылается на позицию за последним элементом массива, а другой — на начало другого массива, следующего сразу за первым в том же адресном пространстве» (C11 § 6.5.9 пункт 6). Именно это мы и наблюдаем в нашем примере. Указатель q ссылается на позицию за объектом b, за которым сразу же следует объект a, на который ссылается указатель p. Получается, в GCC баг? Это противоречие было описано в 2014 году как ошибка #61502, но разработчики GCC не считают его багом и поэтому исправлять его не собираются.

С похожей проблемой в 2016 году столкнулись программисты под Linux. Рассмотрим следующий код:

Символами _start и _end задают границы области памяти. Поскольку они вынесены во внешний файл, компилятор не знает, как на самом деле массивы расположены в памяти. По этой причине он должен здесь проявить осторожность и исходить из предположения, что они следуют в адресном пространстве друг за другом. Однако GCC компилирует условие цикла так, что оно всегда верно, из-за чего цикл становится бесконечным. Эта проблема описана вот в этом посте на LKML — там используется похожий фрагмент кода. Кажется, в данном случае авторы GCC все-таки учли замечания и изменили поведение компилятора. По крайней мере я не смог воспроизвести эту ошибку в версии GCC 7.3.1 под Linux x86_64.

Разгадка — в отчёте об ошибке #260?

Наш случай может прояснить отчёт об ошибке #260. Он больше касается неопределённых значений, однако в нём можно найти любопытный комментарий от комитета:

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

Если понимать этот комментарий буквально, то тогда логично, что результат выражения p == q есть «ложь», так как p и q получены из разных объектов, никак не связанных между собой. Похоже, мы всё ближе подбираемся к истине — или нет? До сих пор мы имели дело с операторами равенства, а как насчёт операторов отношения?

Окончательная разгадка — в операторах отношения?

Определение операторов отношения и >= в контексте сравнения указателей содержит одну любопытную мысль:

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

Здесь указатели p и q ссылаются на два разных объекта, которые не связаны между собой. Поэтому результат их сравнения не определён. А вот в следующем примере:

указатели p и q ссылаются на один и тот же объект и, следовательно, связаны между собой. Значит, их можно сравнить — если только malloc не вернёт нулевое значение.

Резюме

Стандарт C11 недостаточно строго описывает сравнение указателей. Наиболее проблемным моментом, с которым мы столкнулись, стал пункт 6 § 6.5.9, где явно разрешено сравнивать два указателя, ссылающиеся на два разных массива. Это противоречит комментарию из отчёта об ошибке #260. Однако там речь идёт о неопределённых значениях, и я не хотел бы строить свои рассуждения на основании одного лишь этого комментария и толковать его в другом контексте. При сравнении указателей операторы отношения определяются несколько иначе, чем операторы равенства — а именно, операторы отношения определены, только если оба указателя получены из одного и того же объекта.

Если отвлечься от текста стандарта и задаться вопросом, можно ли сравнивать два указателя, полученных из двух различных объектов, то в любом случае ответ, скорее всего, будет «нет». Пример в начале статьи демонстрирует скорее теоретическую проблему. Поскольку переменные a и b имеют автоматическую продолжительность хранения, наши предположения об их размещении в памяти будут ненадёжными. В отдельных случаях мы можем угадать, но совершенно очевидно, что такой код не получится безопасно портировать, и узнать смысл программы можно, только скомпилировав и запустив или деассемблировав код, а это противоречит любой серьёзной парадигме программирования.

Однако в целом я не удовлетворён формулировками в стандарте C11, и так как уже несколько человек столкнулось с этой проблемой, актуальным остаётся вопрос: почему бы не сформулировать правила яснее?

Дополнение
Указатели на позицию за последним элементом массива

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

Можно ли изменить наш пример так, чтобы на позицию за последним элементом массива x не ссылался бы ни один указатель? Можно, но это будет сложнее. Придётся изменить условие цикла и запретить инкремент переменной i на последней итерации.

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

Примечание команды PVS-Studio

При разработке анализатора кода PVS-Studio нам приходится иногда разбираться с тонкими моментами, чтобы сделать диагностики более точными или чтобы давать подробные консультации нашим клиентам. Эта статья показалась нам интересной, так как затрагивает вопросы, в которых мы сами до конца не чувствуем себя уверенными. Поэтому мы попросили у автора выложить её перевод. Надеемся, так с ней познакомится больше C и C++ программистов и поймут, что не всё так просто и что, когда вдруг анализатор выдаёт странное сообщение, не стоит сразу спешить считать его ложным срабатыванием :).

Источник

Что означает «разыменование» указателя?

укажите пример с объяснением.

6 ответов

обзор основной терминологии

это обычно достаточно хорошо-если вы не программируете сборку-предусмотреть указатель содержит числовой адрес памяти, причем 1 относится ко второму байту в памяти процесса, 2-к третьему, 3-к четвертому и так далее.

различные компьютерные языки имейте разные обозначения, чтобы сообщить компилятору или интерпретатору, что вы теперь заинтересованы в указанном значении-я фокусируюсь ниже на C и c++.

сценарий указателя

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

например, если строковый литерал оказался по адресу 0x1000 и p 32-разрядный указатель на 0x2000, содержимое памяти будет:

разыменование указателя

для обозначения символов p точки, мы разыменование p используя одну из этих обозначений (опять же, для C):

вы также можете перемещать указатели через данные, указывающие на данные, разыменовывая их по мере движения:

если у вас есть некоторые данные, которые можно записать, то вы можете сделать такие вещи:

разыменование и доступ к элементу данных структуры

многобайтовые типы данных

Итак, глядя на несколько более сложный пример:

указатели на динамически выделенную память

в C++ выделение памяти обычно выполняется с помощью new оператор, и освобождение с delete :

см. также C++ умные указатели ниже.

потеря и утечка адресов

часто указатель может быть единственным указанием, где некоторые данные или буфер существует в памяти. Если требуется постоянное использование этих данных / буфера или возможность вызова free() или delete для избежания протекать памяти, то программист должен работать с копией указателя.

. или тщательно организовать реверсирование любых изменений.

C++ умные указатели

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

. и shared_ptr для владения акциями (используя подсчет ссылок).

нулевые указатели

подробнее об адресах памяти, и почему вам, вероятно, не нужно знать

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

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

3gl языки программирования, такие как C и C++, имеют тенденцию скрывать эту сложность, например:

если компилятор дает вам указатель на переменную или функцию, вы можете разыменовать ее свободно (пока переменная не разрушена/освобождена), и это проблема компилятора, например, конкретный регистр процессора должен быть восстановлен заранее, или используется отдельная инструкция машинного кода

если вы получаете указатель на элемент в массиве, вы можете использовать арифметику указателя для перемещения в любом месте массива или даже для формирования адреса, который является законным для сравнения с другими указателями на элементы в массиве (или которые аналогично были перемещены арифметикой указателя на то же самое значение с одним концом); опять же в C и C++ это до компилятора, чтобы убедиться, что это «просто работает»

конкретные функции ОС, например отображение общей памяти, могут дать вам указатели, и они будут «просто работать» в диапазоне адресов, которые имеют смысл для них

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

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

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

Я думаю, что все предыдущие ответы неверны, так как они укажите, что разыменование означает доступ к фактическому значению. Википедия дает правильное определение вместо этого: https://en.wikipedia.org/wiki/Dereference_operator

он работает с переменной указателя и возвращает l-значение, эквивалентное значению в адресе указателя. Это называется «разыменование» указателя.

тем не менее, мы можем разыменовать указатель без когда-либо доступ к значению, на которое он указывает. Например:

мы разыменовали нулевой указатель без доступа к его значение. Или мы могли бы сделать:

опять же, разыменование, но не доступ к значению. Такой код не будет сбой: Катастрофа происходит, когда вы на самом деле открыть данные по неверный указатель. Однако, к сожалению, согласно стандарт, разыменование недопустимого указателя является неопределенным поведение (за некоторыми исключениями), даже если вы не пытаетесь коснитесь фактических данных.

короче говоря: разыменование указателя означает применение оператор разыменования к нему. Этот оператор просто возвращает L-значение для вашего будущего использования.

Источник

Указатели

Указатели

Э то, пожалуй, самая сложная и самая важная тема во всём курсе. Без понимания указателей дальнейшее изучении си будет бессмысленным. Указатели – очень простая концепция, очень логичная, но требующая внимания к деталям.

Определение

У казатель – это переменная, которая хранит адрес области памяти. Указатель, как и переменная, имеет тип. Синтаксис объявления указателей

Например
float *a;
long long *b;
Два основных оператора для работы с указателями – это оператор & взятия адреса, и оператор * разыменования. Рассмотрим простой пример.

Рассмотрим код внимательно, ещё раз

Была объявлена переменная с именем A. Она располагается по какому-то адресу в памяти. По этому адресу хранится значение 100.

Создали указатель типа int.

Теперь переменная p хранит адрес переменной A. Используя оператор * мы получаем доступ до содержимого переменной A.
Чтобы изменить содержимое, пишем

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

Будет выведено
4
4
8
4
Несмотря на то, что переменные имеют разный тип и размер, указатели на них имеют один размер. Действительно, если указатели хранят адреса, то они должны быть целочисленного типа. Так и есть, указатель сам по себе хранится в переменной типа size_t (а также ptrdiff_t), это тип, который ведёт себя как целочисленный, однако его размер зависит от разрядности системы. В большинстве случаев разницы между ними нет. Зачем тогда указателю нужен тип?

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

В о-первых, указателю нужен тип для того, чтобы корректно работала операция разыменования (получения содержимого по адресу). Если указатель хранит адрес переменной, необходимо знать, сколько байт нужно взять, начиная от этого адреса, чтобы получить всю переменную.
Во-вторых, указатели поддерживают арифметические операции. Для их выполнения необходимо знать размер.
операция + N сдвигает указатель вперёд на N*sizeof(тип) байт.
Например, если указатель int *p; хранит адрес CC02, то после p += 10; он будет хранить адрес СС02 + sizeof(int)*10 = CC02 + 28 = CC2A (Все операции выполняются в шестнадцатиричном формате). Пусть мы создали указатель на начало массива. После этого мы можем «двигаться» по этому массиву, получая доступ до отдельных элементов.

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

Массив, по сути, сам является указателем, поэтому не нужно использовать оператор &. Мы можем переписать пример по-другому

Если же указатели равны, то они указывают на одну и ту же область памяти.

Указатель на указатель

У казатель хранит адрес области памяти. Можно создать указатель на указатель, тогда он будет хранить адрес указателя и сможет обращаться к его содержимому. Указатель на указатель определяется как

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

Указатели и приведение типов

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

В этом примере мы пользуемся тем, что размер типа int равен 4 байта, а char 1 байт. За счёт этого, получив адрес первого байта, можно пройти по остальным байтам числа и вывести их содержимое.

У казатель до инициализации хранит мусор, как и любая другая переменная. Но в то же время, этот «мусор» вполне может оказаться валидным адресом. Пусть, к примеру, у нас есть указатель. Каким образом узнать, инициализирован он или нет? В общем случае никак. Для решения этой проблемы был введён макрос NULL библиотеки stdlib.
Принято при определении указателя, если он не инициализируется конкретным значением, делать его равным NULL.

По стандарту гарантировано, что в этом случае указатель равен NULL, и равен нулю, и может быть использован как булево значение false. Хотя в зависимости от реализации NULL может и не быть равным 0 (в смысле, не равен нулю в побитовом представлении, как например, int или float).
Это значит, что в данном случае

вполне корректная операция, а в случае

поведение не определено. То есть указатель можно сравнивать с нулём, или с NULL, но нельзя NULL сравнивать с переменной целого типа или типа с плавающей точкой.

Примеры

Теперь несколько примеров работы с указателями
1. Пройдём по массиву и найдём все чётные элементы.

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

3. Более интересный пример. Так как размер типа char всегда равен 1 байт, то с его помощью можно реализовать операцию swap – обмена местами содержимого двух переменных.

В этом примере можно поменять тип переменных a и b на double или любой другой (с соответствующим изменением вывода и вызова sizeof), всё равно мы будет обменивать местами байты двух переменных.

4. Найдём длину строки, введённой пользователем, используя указатель

Источник

Как использовать указатели в прошивках на языке C

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

Работа со значениями указателей

Модификация и разыменование указателей

Есть два значения, связанные с указателем. Первое – это адрес памяти, который хранится в самом указателе, а второе – это данные, которые хранятся по этому адресу памяти. Чтобы изменить адрес, сохраненный в переменной указателя, вы просто используете знак равенства.

Для доступа к данным, хранящимся по адресу указателя, вы используете звездочку. Этот работает как для чтения, так и для записи.

Доступ к значению, на которое ссылается указатель, называется разыменованием, а звездочка (при использовании с указателями) называется оператором разыменования.

Рисунок 1 – Разыменование указателя

Получение адреса переменной

Рисунок 2 – Получение адреса переменной

Это позволяет вам поместить адрес переменной в указатель, даже если вы не знаете, где в памяти будет расположена конкретная переменная. Использование оператора & демонстрируется в следующем фрагменте кода, который также служит кратким описанием базового использования указателей.

Рассмотрим шаг за шагом, что именно делает этот код.

Переменная DisplayChar сейчас хранит значение, соответствующее ASCII символу ‘ A ‘.

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

Рисунок 3 – Изменение значения указателя при инкременте

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

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

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

Когда использовать указатели

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

Указатель против массива

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

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

Передача указателя в функции

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

Эта техника работает следующим образом:

Заключение

Я надеюсь, что теперь у вас есть четкое представление о том, что такое указатели, и как начать работать с ними в вашем проекте прошивки на языке C. Если есть еще какие-либо аспекты встроенного ПО на C, которые вы хотели бы обсудить в будущих статьях, напишите об этом в комментариях ниже.

Источник