Как сравнить указатели?
Предположим, у меня есть 2 указателя:
Если я хочу сравнить их и посмотреть, указывают ли они на одно и то же место, работает (a == b)?
5 ответов
Да, это определение равенства указателей: они оба указывают на одно и то же место (или являются указатель псевдонимов)
, если факты вот соответствующий текст из спецификации
оператор равенства (==,!=)
указатели на объекты одного типа можно сравнить для равенства с «интуитивными» ожидаемыми результатами:
С § 5.10 стандарта C++11:
указатели того же типа (после преобразования указателя) можно сравнить для равенства. Сравнение двух указателей одного типа равно, если и только если они оба нулевые, оба указывают на одну и ту же функцию, или оба представляют один и тот же адрес (3.9.2).
(опуская детали сравнения указателей на член и / или константы нулевого указателя-они продолжаются вниз по той же строке «Do What I Mean»:)
самое «заметное» предостережение связано с виртуалами, и, похоже, логично ожидать тоже:
реляционные операторы (,=)
С § 5.9 стандарта C++11:
указатели на объекты или функции одного типа (после преобразования указателей) можно сравнить, с результатом, определенным следующим образом:
Итак, если бы у вас было:
но это зависит от something в вашей вопрос:
бонус: что еще есть в стандартной библиотеке?
Указатели
Указатели
Э то, пожалуй, самая сложная и самая важная тема во всём курсе. Без понимания указателей дальнейшее изучении си будет бессмысленным. Указатели – очень простая концепция, очень логичная, но требующая внимания к деталям.
Определение
У казатель – это переменная, которая хранит адрес области памяти. Указатель, как и переменная, имеет тип. Синтаксис объявления указателей
Например
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? Можно ли сравнивать указатели, которые не указывают на один и тот же массив?
В главе 5 K & R (язык программирования C, 2-е издание) я прочитал следующее:
Кажется, это означает, что сравнивать можно только указатели, указывающие на один и тот же массив.
Однако, когда я попробовал этот код
1 выводится на экран.
Прежде всего, я думал, что получу неопределенный или какой-то тип или ошибку, потому что pt и px не указывают на один и тот же массив (по крайней мере, в моем понимании).
Я запутываюсь, когда вводится malloc. Также в K & R в главе 8.7 написано следующее:
У меня не было проблем со сравнением указателей, указывающих на пространство, расположенное в куче, с указателями, указывающими на переменные стека.
Например, следующий код работал нормально, с печатью 1 :
Тем не менее, меня смущает то, что я читаю в K & R.
Я спрашиваю, потому что мой проф. фактически сделал это экзаменационным вопросом. Он дал следующий код:
(Мой профессор включает в себя заявление об отказе на экзамене, что вопросы касаются среды программирования Ubuntu Linux 16.04, 64-битная версия)
(примечание редактора: если бы SO допускало больше тегов, эта последняя часть гарантировала бы x86-64, linux и, возможно, сборки. вопрос / класс был конкретно деталями реализации ОС низкого уровня, а не переносимым C.)
5 ответов
Когда сравниваются два указателя, результат зависит от относительного расположения в адресном пространстве указанных объектов. Если два указателя на типы объектов оба указывают на один и тот же объект или оба указывают один за последним элементом одного и того же объекта массива, они сравниваются одинаково. Если указанные объекты являются членами одного и того же агрегатного объекта, указатели на элементы структуры, объявленные позже, сравниваются больше, чем указатели, на элементы, объявленные ранее в структуре, а указатели на элементы массива с большими значениями нижнего индекса сравниваются больше, чем указатели, на элементы того же массива с более низкими значениями индекса. Все указатели на члены одного и того же объекта объединения сравниваются одинаково. Если выражение P указывает на элемент объекта массива, а выражение Q указывает на последний элемент того же объекта массива, выражение указателя Q + 1 сравнивается больше, чем P. Во всех других случаях поведение не определено.
Обратите внимание, что любые сравнения, которые не удовлетворяют этому требованию, вызывают неопределенное поведение, что означает (среди прочего) что вы не можете зависеть от результатов, чтобы быть повторяемыми.
Например, процессор x86, работающий в реальном режиме 8086, имеет сегментированную модель памяти, использующую 16-битный сегмент и 16-битное смещение для построения 20-битного адреса. Так что в этом случае адрес не преобразуется точно в целое число.
Что касается вопроса об экзамене, заданного вашим профессором, он делает ряд ошибочных предположений:
Если бы вы запускали этот код на архитектуре и / или с компилятором, который не удовлетворяет этим предположениям, вы могли бы получить совсем другие результаты.
Оценить Ответ 0, 1 и 0.
Эти вопросы сводятся к:
И ответом на все три является «определение реализации». Вопросы вашего профессора являются поддельными; они основали его в традиционном формате Unix:
Согласно опубликованному обоснованию, авторы Стандарта предполагали, что реализации расширяют язык, определяя, как они будут вести себя в ситуациях, которые Стандарт характеризует как «неопределенное поведение» (т. Е. Когда Стандарт не предъявляет требований ), когда это было бы полезно и практично, но некоторые авторы компиляторов предпочли бы, чтобы программы никогда не пытались извлекать выгоду из чего-то помимо того, что предписывает Стандарт, чем позволять программам эффективно использовать поведение, которое платформы могут поддерживать, без каких-либо дополнительных затрат.
В качестве примера ситуации, когда даже сравнение на равенство ведет себя бессмысленно в gcc и clang, рассмотрим:
Если компиляторы могут получить такое «креативное» с помощью сценария равенства указателей, который описан в Стандарте, я бы не стал доверять им, чтобы они воздерживались от еще более креативного в тех случаях, когда Стандарт не предъявляет требований.
Указатели в C абстрактнее, чем может показаться
Указатель ссылается на ячейку памяти, а разыменовать указатель — значит считать значение указываемой ячейки. Значением самого указателя является адрес ячейки памяти. Стандарт языка C не оговаривает форму представления адресов памяти. Это очень важное замечание, поскольку разные архитектуры могут использовать разные модели адресации. Большинство современных архитектур использует линейное адресное пространство или аналогичное ему. Однако даже этот вопрос не оговаривается строго, поскольку адреса могут быть физическими или виртуальными. В некоторых архитектурах используется и вовсе нечисловое представление. Так, Symbolics Lisp Machine оперирует кортежами вида (object, offset) в качестве адресов.
| Через некоторое время, уже после публикации перевода на Хабре автор внёс большие модификации в текст статьи. Обновлять перевод на Хабре не очень хорошая идея, так как некоторые комментарии потеряют смысл или будут смотреться неуместно. Публиковать текст, как новую статью, тоже не хочется. Поэтому мы просто обновили перевод статьи на сайте viva64.com, а здесь оставили всё как есть. Если Вы новый читатель, то предлагаю читать более свежий перевод на нашем сайте, перейдя по приведённой выше ссылке. |
Стандарт не оговаривает форму представления указателей, но оговаривает — в большей или меньшей степени — операции с ними. Ниже мы рассмотрим эти операции и особенности их определения в стандарте. Начнём со следующего примера:
Если мы скомпилируем этот код GCC с уровнем оптимизации 1 и запустим программу под Linux x86-64, она напечатает следующее:
Обратите внимание, что указатели p и q ссылаются на один и тот же адрес. Однако результат выражения p == q есть false, и это на первый взгляд кажется странным. Разве два указателя на один и тот же адрес не должны быть равны?
Вот как стандарт C определяет результат проверки двух указателей на равенство:
| C11 § 6.5.9 пункт 6 Два указателя равны тогда и только тогда, когда оба являются нулевыми, либо указывают на один и тот же объект (в том числе указатель на объект и первый подобъект в составе объекта) или функцию, либо указывают на позицию за последним элементом массива, либо один указатель ссылается на позицию за последним элементом массива, а другой — на начало другого массива, следующего сразу за первым в том же адресном пространстве. |
Прежде всего возникает вопрос: что такое «объект»? Поскольку речь идёт о языке C, то очевидно, что здесь объекты не имеют ничего общего с объектами в языках ООП вроде C++. В стандарте C это понятие определяется не вполне строго:
| C11 § 3.15 Объект — это область хранения данных в среде выполнения, содержимое которой может использоваться для представления значений ПРИМЕЧАНИЕ При упоминании объект может рассматриваться как имеющий конкретный тип; см. 6.3.2.1. |
Давайте разбираться. 16-битная целочисленная переменная — это набор данных в памяти, которые могут представлять 16-битные целочисленные значения. Следовательно, такая переменная является объектом. Будут ли два указателя равны, если один из них ссылается на первый байт данного целого числа, а второй — на второй байт этого же числа? Комитет по стандартизации языка, разумеется, имел в виду совсем не это. Но тут надо заметить, что на этот счёт у него нет чётких разъяснений, и мы вынуждены гадать, что же имелось в виду на самом деле.
Когда на пути встаёт компилятор
Вернёмся к нашему первому примеру. Указатель p получен из объекта a, а указатель q — из объекта b. Во втором случае применяется адресная арифметика, которая для операторов «плюс» и «минус» определена следующим образом:
| C11 § 6.5.6 пункт 7 При использовании с этими операторами указатель на объект, не являющийся элементом массива, ведёт себя, как указатель на начало массива длиной в один элемент, тип которого соответствует типу исходного объекта. |
Поскольку любой указатель на объект, не являющийся массивом, фактически становится указателем на массив длиной в один элемент, стандарт определяет адресную арифметику только для указателей на массивы — это уже пункт 8. Нас интересует следующая его часть:
| C11 § 6.5.6 пункт 8 Если целочисленное выражение прибавляется к указателю или вычитается из него, результирующий указатель имеет тот же тип, что и исходный указатель. Если исходный указатель ссылается на элемент массива и массив имеет достаточную длину, то исходный и результирующий элементы отстоят друг от друга так, что разность между их индексами равна значению целочисленного выражения. Другими словами, если выражение P указывает на i-й элемент массива, выражения (P)+N (или равносильное ему N+(P)) и (P)-N (где N имеет значение n) указывают соответственно на (i+n)-й и (i−n)-й элементы массива, при условии что они существуют. Более того, если выражение P указывает на последний элемент массива, то выражение (P)+1 указывает на позицию за последним элементом массива, а если выражение Q указывает на позицию за последним элементом массива, то выражение (Q)-1 указывает на последний элемент массива. Если и исходный, и результирующий указатели ссылаются на элементы одного и того же массива либо на позицию за последним элементом массива, то переполнение исключено; в противном случае поведение не определено. Если результирующий указатель ссылается на позицию за последним элементом массива, к нему не может применяться унарный оператор *. |
Из этого следует, что результатом выражения &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 получены из разных объектов, никак не связанных между собой. Похоже, мы всё ближе подбираемся к истине — или нет? До сих пор мы имели дело с операторами равенства, а как насчёт операторов отношения?
Окончательная разгадка — в операторах отношения?
Определение операторов отношения и >= в контексте сравнения указателей содержит одну любопытную мысль:
| C11 § 6.5.8 пункт 5 Результат сравнения двух указателей зависит от взаимного расположения указываемых объектов в адресном пространстве. Если два указателя на объектные типы ссылаются на один и тот же объект, либо оба ссылаются на позицию за последним элементом одного и того же массива, то такие указатели равны. Если указываемые объекты являются членами одного и того же составного объекта, то указатели на члены структуры, объявленные позже, больше указателей на члены, объявленные раньше, а указатели на элементы массива с большими индексами больше указателей на элементы того же массива с меньшими индексами. Все указатели на члены одного и того же объединения равны. Если выражение P указывает на элемент массива, а выражение Q — на последний элемент того же массива, то значение указателя-выражения Q+1 больше, чем значение выражения P. Во всех остальных случаях поведение не определено. |
Согласно этому определению, результат сравнения указателей определён только в том случае, если указатели получены из одного и того же объекта. Покажем это на двух примерах.
Здесь указатели p и q ссылаются на два разных объекта, которые не связаны между собой. Поэтому результат их сравнения не определён. А вот в следующем примере:
указатели p и q ссылаются на один и тот же объект и, следовательно, связаны между собой. Значит, их можно сравнить — если только malloc не вернёт нулевое значение.
Резюме
Стандарт C11 недостаточно строго описывает сравнение указателей. Наиболее проблемным моментом, с которым мы столкнулись, стал пункт 6 § 6.5.9, где явно разрешено сравнивать два указателя, ссылающиеся на два разных массива. Это противоречит комментарию из отчёта об ошибке #260. Однако там речь идёт о неопределённых значениях, и я не хотел бы строить свои рассуждения на основании одного лишь этого комментария и толковать его в другом контексте. При сравнении указателей операторы отношения определяются несколько иначе, чем операторы равенства — а именно, операторы отношения определены, только если оба указателя получены из одного и того же объекта.
Если отвлечься от текста стандарта и задаться вопросом, можно ли сравнивать два указателя, полученных из двух различных объектов, то в любом случае ответ, скорее всего, будет «нет». Пример в начале статьи демонстрирует скорее теоретическую проблему. Поскольку переменные a и b имеют автоматическую продолжительность хранения, наши предположения об их размещении в памяти будут ненадёжными. В отдельных случаях мы можем угадать, но совершенно очевидно, что такой код не получится безопасно портировать, и узнать смысл программы можно, только скомпилировав и запустив или деассемблировав код, а это противоречит любой серьёзной парадигме программирования.
Однако в целом я не удовлетворён формулировками в стандарте C11, и так как уже несколько человек столкнулось с этой проблемой, актуальным остаётся вопрос: почему бы не сформулировать правила яснее?
Дополнение
Указатели на позицию за последним элементом массива
Что касается правила о сравнении и адресной арифметике указателей на позицию за последним элементом массива, сплошь и рядом можно найти исключения из него. Предположим, что стандарт не разрешал бы сравнивать два указателя, полученные из одного и того же массива, при том что хотя бы один из них ссылается на позицию за концом массива. Тогда следующий код не работал бы:
Можно ли изменить наш пример так, чтобы на позицию за последним элементом массива x не ссылался бы ни один указатель? Можно, но это будет сложнее. Придётся изменить условие цикла и запретить инкремент переменной i на последней итерации.
В этом коде полно технических тонкостей, возня с которыми отвлекает от главной задачи. Кроме того, в теле цикла появилась дополнительная ветка. Так что я считаю разумным, что стандарт разрешает исключения при сравнении указателей на позицию за последним элементом массива.
Примечание команды PVS-Studio
При разработке анализатора кода PVS-Studio нам приходится иногда разбираться с тонкими моментами, чтобы сделать диагностики более точными или чтобы давать подробные консультации нашим клиентам. Эта статья показалась нам интересной, так как затрагивает вопросы, в которых мы сами до конца не чувствуем себя уверенными. Поэтому мы попросили у автора выложить её перевод. Надеемся, так с ней познакомится больше C и C++ программистов и поймут, что не всё так просто и что, когда вдруг анализатор выдаёт странное сообщение, не стоит сразу спешить считать его ложным срабатыванием :).
Как сравнить указатели?
Предположим, у меня есть 2 указателя:
если я хочу сравнить их и посмотреть, указывают ли они на одно и то же место (a == b) работает?
5 ответов:
Да, это определение равенства указателей: они оба указывают на одно и то же место (или указатель псевдонимов)
, если факты вот соответствующий текст из спецификации
оператор равенства (==,!=)
указатели на объекты одного типа можно сравнить для равенства с «интуитивными» ожидаемыми результатами:
С § 5.10 стандарта C++11:
указатели одного типа (после преобразования указателя) можно сравнить для равенства. Сравнение двух указателей одного типа равны, если и только если они оба нулевые, оба указывают на одну и ту же функцию, или оба представляют один и тот же адрес (3.9.2).
(оставляя без внимания детали сравнения указателей на член и или константы нулевого указателя-они продолжают вниз по той же строке «делать то, что я имею в виду»:)
самое «заметное» предостережение связано с виртуалами, и, похоже, это тоже логично ожидать:
реляционные операторы (,=)
С § 5.9 стандарта C++11:
указатели на объекты или функции одного типа (после преобразования указателей) можно сравнить, с результатом, определенным следующим образом:
но это зависит от something в вашей вопрос:
бонус: что еще есть в стандартной библиотеке?
на == оператор на указателях будет сравнивать их числовой адрес и, следовательно, определять, указывают ли они на один и тот же объект.
подведем итог. Если мы хотим увидеть, указывают ли два указателя на одну и ту же ячейку памяти, мы можем это сделать. Кроме того, если мы хотим сравнить содержимое памяти, на которое указывают два указателя, мы можем сделать это тоже, просто помните, чтобы сначала разыменовать их.
, которые являются двумя указателями одного типа можно:
сравнить адреса памяти:
и сравниваем содержание:
Итак, что вам нужно сделать, это проверить правильность двух адресов, на которые указывают указатели.
таким образом, вы используете что-то вроде
или вы можете использовать оператор==, чтобы проверить, имеет ли указатель a равное значение с указателем b.
