Прибавление целочисленного числа к укакзателю называется адресной арифметикой. 
Так что вы не прибавляете число к указателю! Вы переводите значение одного указателя в значение указателя другого типа, его меняете, а затем делаете обратное преобразование значение к типу исходного указателя. На что стандарт, наприсер, языка С говорит:

Надо только упомянуть,что вы привели выдержки из нового draft C0X: стандарта, еще вроде даже не принятого. Не большой знаток С, так что утверждать не буду.
Буду признателен если вы приведете что-то из стандарта С++ (не С), тем более что ТС явно указал язык. 

Не понятно почему вы постоянно сбиваетесь на С, да еще и C0X

Это сообщение отредактировал(а) volatile - 29.6.2011, 00:50

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

Как тогда можно охарактеризовать это поведение?


Но ведь я не писал &123, а написал (int*) 123, т. е. я хотел, чтобы указатель указывал на адрес 123 (что он, собственно, и делает).

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

Там, где вы меня цитируете я говорю про Си, а вы спрашиваете про Си++, хотя поведения с прототипами и отсутствием реализации в Си и Си++ схожи, если не идентичны.

Тем не менее ваш вопрос мне не понятен, проиллюстрируйте пожалуйста.

Он и указывает. Проблема в том, что в виртуальной памяти (в отличии от физической) могут быть 'дырки', т.е. адреса, по которым никакой памяти нет. Ваш 123 попадает в одну из таких дырок. Попытка обратится туда приводит к эксепшену со стороны ОС


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

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

Добавлено через 2 минуты и 1 секунду


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

Ну коль цитату из стандарта С++ вы привести не смогли, будет разбирать то что есть.   
Для полноты картины нужно еще определение понятия "correctly aligned for the pointed to type"
Мой приблизительный перевод "корректно выровнен на указываемый тип"
Означает ли это тоже самое что "выровнен на границу слова" ?

пример


В данном примере  указатель (p) корректно выровнен на указываемую переменную a.i типа int. 
Но он не выровнен не границу слова. Так что это разные вещи.

Без определение понятия "correctly aligned for the pointed to type", все дальнейшие ваши заключения ничего не стоят.
Так что жду от вас хотябы этого.



Это сообщение отредактировал(а) volatile - 29.6.2011, 23:37

это не совсем так.. с точки зрения операционной системы (например линукс) каждый процесс получает свое __неразрывное__ виртуальное пространство (для 32 разрядной системы 4Гб).. в тоже время эта память делится на сегменты.. у каждого сегмента есть базовый адрес (начало сегмента) и его длина (либо в байтах, если он не превышает 1Мб, либо в страницах (обычно 4К), если он больше 1Мб), а так же за каждым сегментом закреплен тип (определяющий его назначение: сегмент кода, сегмент данных и т.д.)

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

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

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

Это именно так с точки зрения архитектуры виртуальной памяти процессора (в данном случае х86) (весьма упрощенно, но тем не менее близко к истине). То, как операционная система использует эту виртуальную память - это уже 2й уровень абстракций. Предлагаю, ради сохранения здравого рассудка ТС, не вдаваться в такие подробности   

Честно говоря, я вам не нянька, чтобы для вас делать выписки из стандарта. Почему бы вам самому не заглянуть в стандарт вместо того, чтобы фантазировать ? В стандарте С++ говорится тоже самое об выравнивании. 
Дело в том, что размер типов данных зависит от платформы. Но в любом случае обычно размер типа int выбирается равным размеру машинного слова. Для 32-битовых платформ, которые в настоящее время наиболее распространены, размер типа int равен 4 байтам. На 64-битовых платформах обычно размер типа int солставляет 8 байтогв. 
Но в любом случае функция malloc возвращает адрес, который выравнен соответствующим образом.
Говоря о границе слова, я лишь приводил конкретный пример для 32-битовых машин, чтобы на конкретноми примере пояснить вопрос.
Не заню по каким причинам, но то ли вы не поняли, что я говорил, то ли начинаете передергивать, так как попали в лужу со своим начальным комментарием, а теперь пытаетесь как-то выкрутиться!
На мой взгляд я все ясно сказал. Вопрос состоял в том, является ли корректным код, когда в указатель заносится значение, не выравненное надлежащим образом для конкретного типа данных. Я ответил, что нет, и привел цитаты из стандарта по крайней мере из стандарта С.

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

Цитата из С++ 98 (какой был под руками)
Раздел 3.9 - Types
Резюме - значения должны быть выровнены, но на сколько именно - зависит от реализации.   

xvr, да эту фразу из стандарта С++ я видел. И это единственное что там нашел по этому поводу. (ну может не единственное, но такая-же фраза повторяется несколько раз, в разных местах)

А применять стандарт С к С++, не совсем корректно, там более выдержки без определения главной фразы.
Что они имели под термином "correctly aligned for the pointed to type"


Кто сел еще надо подумать...  
Дальнейщий диспут, в таком тоне считаю бесполезным.


Это сообщение отредактировал(а) volatile - 1.7.2011, 00:37

Естественно! Зависит от используемой платформы. Ни в С, ни в С++ не гвоорится о размерах данных. Так что тип int может занимать 16 битова на 16-битовых  платформах, как, например,  в MS-DOS, либо 32 бита, либо 64 бита. Но в любом случае тип int соответсвует машинному слову, то есть соответсвует размеру регистров, которые и выполняют арифметические операции.. В этом и состоит сущность языка С и С++, что они максимально прибижены к платформе. То есть они тиспользуют собственные типы данных, существующие на конкретной платформе. Этим обусловлена эффективность этих языков. И именно поэтому их порой называют языками низкого уровня. 

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

А применять стандарт С99 к С++ не совсем корректно. (читай совсем не)
С++ если и произошел от С, то никак не от С99  
это 2 разных языка.

Добавлено @ 00:15
А выборочные выдержки из стандарта С99, без определения основных терминов, вообще не могут рассматриваться в качестве аргументов в споре


Это сообщение отредактировал(а) volatile - 2.7.2011, 03:20