Здравствуйте, уважаемые форумчане. Я не так давно начал учить C++ и засел на некоторых вопросах:
1) Как сдвинуть указатель на несколько байт? (игнорируя арифметику указателей)
    Реально ли сдвинуть на несколько бит?
2) Почему массив сделали константой? И почему вообще стоит использовать константы?
3) Касательно констант, в следующем коде:

под 10 тоже выделяется отдельное место? А в этом:

4) Если говорить "на языке компьютера", то операция &a возвращает указатель, а не адрес? Ведь эта операция возвращает тип type*, присущий указателям. А адрес - это число (типа int) по моему мнению.
5) Каков порядок инициализации массива в следующем коде:

Строка компилятором заменяется на указатель на  массив типа char. Значит, инициализация состоит из следующих этапов: узнаем размер массива по правую часть; освобождаем память под этот размер; по очереди копируем ячейки правого массива в соответственные ячейки левого. Так?
6) Странно работает программа:

Я один (!) раз ввожу "12345", а она мне выдает "123"! Я же 2 раза использовал функцию cin.getline! Не могли бы вы объяснить мне, почему мне приходится вводить информацию один раз, и переменной b ничего не присваивается?

Заранее благодарен   

Это сообщение отредактировал(а) Hagrael - 26.6.2011, 15:00

1)
указатель это по сути дела адрес!
И здвинуть его модно прибавив (или отняв) нужное вам количество байт.
У 99% ПК байтовое адресное пространство.
2)
Не ясен вопрос.
поясните.
3)
выделяется.
В разных местах может выделяться.
4)
указатель-это и есть число.
Всё верно.
5)
порядок будет несколько различен от того глобальная это переменная или нет

нет



Размер массива сделали константой. Почему не знаю. В новых версиях это уже не константа. Видимо наследие тяжёлых времен.


Во-первых у вас, это не константа. 
const int a; <- вот это константа.
Выделение памяти - зависит от реализации.
По опыту могу сказать, что от формы инициализации не зависит. А зависит есть ли где в программе указатель на эту константу.
Если указателя нет, то и память не выделяется, а просто подставляется значение.
Если есть указатель, то память будет выделена.


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


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

Здесь вам неправильно ответили. Сдвинуть указатель на целове на несколько байт нельзя! То есть этот код юудет неопределенным согласно стандарту языка. Поэтому приведенный в одном комментарии од, показанный ниже, является некорректным. 

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

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

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

Что касается вашего примера с определением целочисленного значения, то очно целочисленные константы в памяти не хранятся. То есть компилятор, например, в вашем коде



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


Что касается примера



то в данном случае компилятор также не хранит строковый литерал в памяти, а лишь использует его для инициализации массива. То есть память выделяется только для массива a[], размер которого определяется как размер строкового литерала плюс один байт по нулевой завершающий символ. В вашем примере для массива будет выделено 6 байтов, и в них будет скопирован строковый литерал, включая завершающий ноль.

То есть этот код полностью эквивалентен следующему коду

char a[ 6 ] = { 'H', 'e', 'l', 'l', 'o', '\0' };

То есть никаких двух массивов, один - для строкового литерала, а другой - для идентификатора 'a', не создается. Создается лишь один массив для идентификатора 'a'.


Что касается этого примера выше, товы ведялете буфер для ввода строки в 4 байта. Функция считывает все то, что вы ввели до нажатия клавиши Enter, а затем копирует лишь 3 байта, добавляя их четвертым байтом нулевого значения. 

Согласен с тем что код не кошерный, и новичкам такое показывать конечно нестоило.
Но строго говорить что 

Вовсе он не должен.
Есть куча стркутур, где DWORD'ы не выровнены на границу слова.
И на PC это абсолютно нормально.
Хотя повторюсь, так делать, конечно-же не стоит.

В вашей структуре может быть целове число не выравнено на границу челого числа, но если вы занесете адрес этого целого числа в указатель, то такое поведение не соответсвует станарту  является неопределенным. И то, что у вас где-то это может "проскочить", совершенно не означает, что код корректный.
Приведу простой пример. Неокторые делают такое объявление

char * p = "12";

А затем менют значение по адресу этого указателя. Например, *p = '3'; При раоте, например, MS-DOS это пройдет, так как память там не защищенная, но тем не менее этот код некорректный согласно стандарту, так как строковые литералы менять запрещается.

Сыроежка, ваш пример, с
*p = '3';
к теме выравнивания int'ов никакого отношения не имеет.

Добавлено @ 16:28
Кроме того он и не скомпилится.

Но повторю.
Жалею что показал это.
Так делать нехорошо.

Это сообщение отредактировал(а) volatile - 26.6.2011, 16:29

Имеет самое непосредственное отношение! Вы просто не поняли! Я хотел показать, что некоторые некорректные конструкция языка могут проскакивать на той или иной платформе, но тем не менее код является некорректным. Точно также и в случае занесения в указатель на тип int значения, которое не кратно размеру слова, то есть размеру int. Если вы попытаетесь по этому адресу записать целое число, то на многих платформах вы получите аварийное завершение. Н адругих платформах это может проскочить. Но то, что где-то это проскочило, это совершенно не делает код корректным! Стандарт по этому поводу прямо говорит, что такое поведение является неопределенным, то есть вы играетет в рулетку на свой страх и риск. А точнее пишите код, который не является допустимым кодом ни С и ни С++.

Добавлено через 8 минут и 45 секунд


Зря вы думаете, что такой код не компилируется! Многие компияторы, особенно на С, спокойно компилируются этот код. Кроме того вы не забывайте, что компилятору бывает очень трудно обнаружить такую ошибку, например, есл такой указатель передается в качестве аргумента какой-нибудь другой функции, а уж в этой функции происходт присвоение по адресу указателя.

У вас код не окмпилируется скорей всего по той причине, что вы компилируете как код С++, и компилятор видет это непосредственное изменение.  Дело в том, что ест разница между С и С++ в том, како тип имеют строковые литералы. На С++ строковый литерал имеет тип массива производного от типа const char, а в С это массив, производный от типа char. Но тем не менее стандарты и С++ и С строго запрещают менять строковые литералы.

Сыроежка, я уже тыщу раз сказал что пример не хорош, и что я жалею что показал его.
Просто иногда новичку нужно знать (вспоминая себя) и такие вещи.
но на вопрос

ответ мой такой.


Спорить дальше не буду
  

Как происходит инициализация массива строковым литералом, я вам показал выше в своем комментарии.
Но нужно не путать две вещи: инциализацию массива строковым литералом, и инициализацию указателя на char адресом строкового литераа, то есть когда вы пишите

char *p = "Hello";

В этом случае компилятор действительно сохраняет символьный строковый литерал в памяти в виде символьного массива, а указателю p присваивает знчение адреса первого элемента этого массива.
Причем следует знать важные отличия характеристик строкового итерала в С и в С++. 
В С строковый литерал имеет тип массива, производного от типа char (массивы называются в стандартах С и С++ производными типами, то есть их тип определяется типом элемента массива). В то время как в С++ строковый литерал имеет тип, произвоный от типа const char.

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

char s[3] = "XYZ"; 

является корректным в С. В то время как в С++ такой код является некорректным. 

ИМХО чтобы не было проблем с выравниванием и проблем с выравниванием и разрадностью многих систем порой всё же стоит выходить за пределы C.
Я бы реализовал это просто.
void *Point;
__asm
{
  mov eax,Point
  add eax,03h
  mov Point,eax
}

Ну а для всех тех кто неприклонно бориться за чистоту языка:
void *Point;
Point=(void*)((BYTE *)Point)[ 3].         
или:
Point=(void *)(DWORD(Point)+3)

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

Ваши попытки мне напоминают стремление слово "корова" писать через "а". От того, что вы букву "а" напишите, например, прописными буквами, а не строчными, то есть в виде "кАрова", не делает прапвильным правописание этого слова.

То есть ваш комментарий ни к С, ни к С++ отношениря не имеет. А имеет отношение лишь к тому, чего не надо делать на С и С++! Если бы автор вопроса интересовался  именно этим, то есть тем, как не надо писать на С и С++, то ваш ответ был бы к месту.

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


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

void *Point;
__asm
{
  mov eax,Point
  add eax,03h
  mov Point,eax
}

и где же сдесь ошибка??????

А я не гвоорил, что здесь ошибка! Я говорил, что к исходному вопросу это отношения не имеет. Автор, фактически, спрашивал, может ли указатель иметь значение, не кратное размеру int. Ответ прост: не может! То есть такое поведение неопределенное.

Что касается вашего примера, то ваша переменная Point объявлена не как указатель на int, а как указатель на void. Так что к исходному вопросу вообще никакого отношения не имеет. Внутреннее представление указателя на void по крайней мере в соответствии со стандартом С соответствует внутреннему представлению указателя на char. Это сделано для того, чтобы можно было использовать такие функции, как, например, memcpy.
Очевидно, что указатель на void может адресовать любой байт. Тем не менее это неверно для указателей на int.

Добавлено через 50 секунд
Я имел в виду, может ли указатель на int иметь значение не кратное размеру int.

Добавлено через 13 минут и 39 секунд


То есть если отвечать на этот исходный вопрос, то сделать это, то есть игнорируя арифметику указателей, нельзя. Так как тогда указатель будет содержать некорректное значение. И примером этого является указатель на int. 
Естественно, что указатель на char ожет адресовать любой байт, но даже он не игнориует арифметику указателей, то есть сдвиг происходи согласно размеру типа ( в данном случае sizeof( char ) ), на данное которого указатель указывает. Более того могут быть и wchar_t типы символов. 
Конечно, если использовать тип char * , то вопросов никаких нет, так как sizeof( char ) == 1. Но, как я понимаю, автора не этот вопрос мучал, а мучал вопрос, может ли какой-нибудь указатель хранить значение, которое не удовлетворяет правилам арифметики с указателями.

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

То есть суть исходного вопроса, касающегосу игнорирования арифметики указателей сводится к следующему вопросу: является ли следующий код корректным?



Ответ: не является!

Это сообщение отредактировал(а) Сыроежка - 26.6.2011, 19:14

Сыроежка, приведите выдержку из стандарта про выравнивание, раз вы его тут упоминали

Резонное предложение. Приведу, но только завтра или послезавтра, так как сейчас общаюсь из нтернет-кафе, и под рукой никаких документов нет.

а такой код будет корректным ? 

Еесли Нет, приведите пример машины, операционной системы, да хоть чего-нибудь, где этот код работать не будет.
(именно этот код с for)

Если Да, то как может в целом корректный код состоять из нескольких некорректных операций?

Сыроежка вот вы говорили:



Изначально вопрос стоял так:


Игнорировать арифметику указателей-означает прежде всего не привязываться к базовым типам.
Если у меня есть указатель на тот или иной участок памяти и задача сдвинуть на несколько байт,
то я просто прибавлю к к имеющемуся значению в указателе значение равное сумме того что есть + 3.
А вот какой тип данных вы будете использовать мне всё равно.
С точки зрения программы адресное пространство масива линейно и применение понятия выравнивания не корректно,
разве что быть может это учитываеться в каких нибудь древних системах или при низкоуровневом программировании...но мы о нём речи не ведём.
Пришлите скрин отладчика(ОС значения не имеет) под которым мя явно увидим что это приведёт к падению системы.....


Это сообщение отредактировал(а) hawk3500 - 26.6.2011, 23:31

hawk3500, на некоторых платформах (микроконтроллеры напр.) действительно нельзя обращаться по указателям не выровненным на слово. К PC (Personal Computer), да и вообще к любым машинам на X86 это не отностися, не важно какая система (win*; dos*; *nix).

Сделаю ударение нельзя именно обращаться.
Но здесь никто и не обращается
Мы только прибавляем число к указателю.   

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

удалил. не к чему это.

Это сообщение отредактировал(а) volatile - 27.6.2011, 01:54

>на некоторых платформах (микроконтроллеры напр .) действительно нельзя обращаться по указателям не выровненным на
слово

Мало того, на некоторых компиляторах размер char равен размеру short и равен размеру int - AnalogDevice под какой-то свой процессор (161-й по-моему) 

Спасибо всем, кто мне ответил!



Данный код некорректен из-за того, что оператор + может связывать переменную типа type* (любой указатель) только с переменной типа int.

А почему некорректен этот код, мне непонятно. Однако, думаю, что прежде следует понять, почему не работает код, приведенный ниже:

Консоль абсолютно чиста, если не считать статуса завершения программы. Из-за чего?


Массив на самом деле ведь указывает на свою первую ячейку. Однако это не просто указатель, а константа-указатель. Следующий код приводит к ошибке " non-lvalue in assignment ":

А следующий - к ошибке " incompatible types in assignment of `int' to `int[10]' ":

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

А следующий - нет, т. к. нет префикса const перед второй строкой:

Так что же это такое - массив? Это не просто const type*   


Вот что я понял. К переменным всех типов присваиваются их литералы, которые заранее никуда в ОЗУ не копируются. Единственное - исключение может составить указатель, указывающий на строку. Тогда строковый литерал изначально превращается в массив типа char, и когда дело доходит до инициализации нашего указателя, то в него возвращается заранее созданный массив.

А под локальные переменные неиспользуемой функции выделяется место? Или оно выделяется под них только при запуске функции? А где хранятся все те литералы, которые посылаются в аргументы? В памяти той функции, из которой вызывается другая функция, принимающая литералы в качестве аргументов? И еще вопрос: .exe-файл на протяжении всей программы хранится в ОЗУ. Но зачем? Разве из него сразу же не вытянули всю информацию?


Мне все говорят, что указатель - это переменная, хранящая адрес. Но ведь компьютер не видит этой разницы, так?


Если ты ввел в первый раз менее 4-х символов, то компьютер тебя просит ввести еще одну строку, после чего выводится то, что ты ввел в первый раз и то, что ты ввел во второй раз. Однако если ты введешь 4 символа или более, то тебе не предоставится второй возможности ввести строку, вместо этого на экран выведутся 3 первых буквы из того, что ты ввел в этот единственный раз и на пустота, находящаяся строчкой ниже. Можете объяснить это поведение?
Кстати, касательно функции cin.getline: она странно работает - возвращает 3 символа, когда я вторым аргументом послал число 4! Что это такое?

И новый вопрос:
7) Что такое "конец слова" и "выравнивание под конец слова"?

Заранее благодарю.

Это сообщение отредактировал(а) Hagrael - 27.6.2011, 10:21

Данный код вполне корректен. Так как p переместится на 0 позиций. Слово "сдвиг" я бы вообще не рекомендовал применять к указателям, так как под сдвигом понимается битовая операция (фактически, сдвиг на 1 влево тоже самое что и умножение на 2, а вправо - целочисленное деление на 2), которая для указателей вообще недопустима (если не понятно почему, почитай про указатели в Ответах на часто задаваемые вопросы).
По мне, он корректен - я не нашел в стандарте указаний на то, что доступ к объектам обязан быть выравнен. С другой стороны, если я такой код увижу, то я буду считать его ошибочным (если, конечно, в комментариях к нему меня не убедят в обратном). Потому что очень мало причин, по которым может это понадобиться. Обычно, все решается несколько иначе.


Начнем с того, что 10 - это код символа '\n' - конец строки. Он на консоли отображается как перемещение курсора в начало следующей строки. Но, данный код может отобразиться тогда и только тогда, когда у тебя система Little Endian (x86, например). А вот на Big Endian системах (ARM, например) на экран будет выведен символ '\0' (так как x будет содержать байты 0, 0, 0, 10 вместо 10, 0, 0, 0).


Здесь и далее у тебя уже начинается путаница.
"константный указатель" и "указатель на константу" в большинстве случаев значит одно и тоже (хотя, должно значить разное): const type * pointer
"указатель-константа" - это уже несколько другое:  type * const pointer
Разница в следующем: в первом случае ты имеешь право менять УКАЗАТЕЛЬ (например, чтобы он указывал в другое место), но не имеешь права менять элемент, на который он указывает, а во втором ты имеешь право менять элемент, но не сам указатель. Разницу видишь?
Массив имеет свой собственный тип - массив (type[n]). Его можно воспринимать, как "указатель-константа". Но в отличие от последнего, sizeof() возвращает не размер указателя, а занимаемое место (в char'ах) массивом.
выделяется только при входе в функцию.
в коде программы (когда надо вызвать твою функцию, процессор получает команды: запихать 10 в стек, запихать 50 в стек, вызвать подпрограмму по адресу такому-то, ..., откатить стек на <размер аргументов>). Вообще-то, основную часть экзэшника (речь не про отладочную сборку, когда 99,99% его объема уходит под отладочную информацию) занимает программа. А она должна быть в памяти, чтобы процессор мог ее выполнять.


Еще раз рекомендую почитать ответы на часто задаваемые вопросы (тема прикреплена).
http://cplusplus.com/reference/iostream/istream/getline/ почитай, когда включается failbit. Кстати, после возникновения ошибки и до ее снятия читать не получится.

под "словом" понимается так называемое "машинное слово". Т.е. это данные такого размера, работа с которыми для процессора наименее трудоемка. Наиболее популярны 32 и 64 бита (4 и 8 байт, соответственно). У современных процессоров все узлы оптимизированы на работу с такими словами. Но платой за это является снижение производительности при невыравненном доступе: представь, процессор за 1 такт читает 4 байта с адресов, кратных 4. Чтобы прочитать данные, которые лежат только кратно 2, ему придется прочитать 2 раза по 4 байта, а затем лишние байты выкинуть. А теперь представь, что нужно сделать, чтобы записать: прочитать 4 байта, заменить 2 на новые данные, записать, прочитать еще 4 байта, заменить 2 байта на новые, записать.... Минимум 4 такта вместо 1. Именно поэтому все современные компиляторы умеют делать выравнивание по границе машинного слова.

Спасибо за ответ.


На самом деле код был таким:

Я написал 1/4 для ясности, забыв о том, что если делить один int на другой, то выполнится целочисленное деление  Думаю, теперь понятно, о чем я говорил:



Т. е. технически этот код правилен, однако вы бы подумали, что его автор не знает, что делает, да?


И правда, я просто не заметил переноса строки.


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


Спасибо, понял.


Ах вот оно что, значит, массив - это не просто указатель на свою первую ячейку. Он не является константой (т. к. при операции int* p=int_arr; в левой стороне не нужно слово const), однако его нельзя менять. Так?


Это понятно, но разве при запуске программы глобальные переменные все функции с их инструкциями не вытаскиваются?


Значит, в ОЗУ все стремиться к подобному порядку:
4 байта | 8 байт | 8 байт | ...
Но зачем 2 раза читать по 4 байта, а затем лишние байты выкинуть? Вы говорите о таких размерах, как 5-7 байт? Тогда, выходит, это устроено так:
    1. Нашел адрес;
    2. Считал 8 байт (2 раза по 4 байта);
    3. Выкинул 2 байта (т. к. нужно было только 6 байт)
А по 8 процессор читать не может, да?


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

Это сообщение отредактировал(а) Hagrael - 27.6.2011, 12:42

да
endianess отвечает лишь за порядок байт в ОЗУ. АЛУ работает независимо.
Я же объяснил, чем "указатель на константу" отличается от "указателя-константы". const int *p - указатель на константу. int * const p - указатель-константа. Так вот, массив можно воспринимать как указатель-константу (хотя, на самом деле, делать так не стоит).
А что по твоему содержит экзэшник? Он содержит именно программный код, информацию о распределении памяти и необходимых подключаемых библиотеках, а также данные для инициализации глобальных переменных. Правда, возможно, он еще может содержать всякий "мусор" (например, самораспаковывающиеся архивы).

может. все зависит от архитектуры процессора и контроллера памяти.
Учи английский, иначе в программировании делать тебе нечего.
failbit устанавливается при ряде ошибок чтения. В частности, getline устанавливает его, когда размер буфера меньше, чем данных в потоке. Для снятия этого бита нужно использовать метод clear().

согласен на 200%. Удивительно как точно сформулирована мысль.  
именно это я и хотел сказать вчера.

Простите, что так долго не понимаю...


Вот именно, как я понимаю, на самом деле, это не указатель-константа! Взять даже ошибки, которые высвечиваются в логе после этого кода:

Вот, собственно, ошибки:

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


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

После компиляции, насколько я понимаю, в .exe-файле будут следующие инструкции:

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

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

А библиотечные функции пишутся на C++ или Asm? Логичнее было бы писать их на Asm, и я бы не спросил об этом, если бы не увидел директивы #include, включающей файл с расширением .h.

И еще один вопрос: Если у каждой программы своя виртуальная память, то почему выдает ошибку такая конструкция:

я же изменяю свою переменную, а не переменную чужой программы.

Это сообщение отредактировал(а) Hagrael - 28.6.2011, 10:38

Прикладной программе (не по функциональности, а по типу и правам запуска) ОС указывает какой участок памяти она может занять (строго говоря это может быть где угодно в пользовательской памяти) далее мы уже имеем дело со смещениями т.е. ваши 0xB04566 и 0xB04700 могут меняться от запуска к запуску, но переход от main к func будет - "сдвинуться на 0xB04700-0xB04566".


Большинство функции на Си как раз писаны на Asm, при этом файл .h все равно присутствует - он содержит прототипы функций, но это все вообще-то зависит от реализации. 
Си++ые же функции (чистых функций в std::* не так уж и много) - главным образом на Си++, причем большинство - шаблонные, поэтому реализация в виде исходного кода.

Это сообщение отредактировал(а) triclosan - 28.6.2011, 12:39

Вы заблуждаетесь! Это не все равно! Языки С и С++ типизированные, и у вас не просто какой-то указатель неизвестного типа, а указатель производного типа от int. Именно для вашего примера в мтандарте сказано, что такое поведение неопределенное. То есть вы можете использовать любые некорректные конструкции, но это к сущности языка не имеет никакого отношения.

Теперь приведу выдержку из стандарта по языку С:
"6.5.3.2 Address and indirection operators

#4 If an invalid value has been assigned to the pointer the behavior of the using * operator is undefined"

В комментарии к этому параграфу дается разъяснение, что означает "invalid value"

"Among the invalid values for dereferencing a pointer by the using * operator are a null pointer, an address inoppropriatedly aligned for the type of object pointed to, ..."

Но и это еще не все. В параграфе 6,3.2.3 №7 сказано: "A pointer of an object or incomplete type may be converted to a pointer to a different object or incomplete type. If the resulting pointer is not correctly aligned for the pointed to type, the behavior is undefined"

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

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



Я вам уже объяснил! Вы очевидно с первого раза не поняли! Что вы собираетесь менять?!!! Назовите мне ту ячейку памяти, которую вы собираетесь изменить! С именем массива не связана никакая ячейка памяти! То есть нет такой ячейки, где хранится адрес массива, и которую вы могли бы изменить! В памяти хранится сам массив, то есть его элементы. А имя массива - это, можно так сказать, виртуальный адрес массива, то есть нигде этот адрес не хранится! Если бы он где-то хранился, то тогда бы вы его могли изменить. Но в этом случае это уже был бы не сам массив, а указатель на массив, то есть отдельная ячейка памяти, которую вы могли бы менять!

Добавлено через 9 минут и 19 секунд


123 - это не переменная! Это константа препроцессора, которая в результате компиляции заносится непосредственно в машинную команду, которая инициализирует некоторую переменную.

В приведенном ваше примере компилятор никуда не помещает 123, поэтому у этой константы нет адреса!

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

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





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

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

Надо только упомянуть,что вы привели выдержки из нового 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

здесь речь идет не о размере, а о выравнивании. И о том, что второе совсем не обязательно равно первому. Например классическая х86 система не требует выравнивания (т.е. align должен быть на 1), хотя и приветствует   
 

Это вы сами с собой дискусируете?! Я нигде не гворил, что указатель должен быть выравнен на границу слова! Я приводил пример, ято если указатель является производным от типа int, то он должен быть выравнен в сосотевтсвии с выравниванием типа int. А тип int на различных платформах обычно выбирается равным слову!

но при этом выровнен не обязательно по размеру слова.. 

Я уже все ясно сказал! То, что вы не понимаете сказанного, это уже ваши личные проблемы! Тип int на платформах выбирается равным размеру слова. Есть только исключение, когда на платформе емкость регистров которой удваивается по сравнению с предыдущей реализацией данной платформы, тип int может равняться получлову. Но тем не менее он всегда соответсвует размеру регистра на исхдной платформе. 
То есть чтобы было понятно, на 32 -битовой платформе Intel тип int может равняться 16 битам. Но это соответсвует размеру регистра AX, то есть значению слова на той платформе (в данном случа 16-битовой), для совместимостью с которой создается компилятор.

Кроме одной детали : размер и выравнивание могут быть равны, но не обязаны..   

Я не встречал еще ассемблера, где при выделении памяти для слова, как, например,

или

для Intel



для IBM проходило выравнивание не по размеру слова!

и что это доказывает ?

без комментариев.

[QUOTE=Сыроежка,3.7.2011,  18:20]
Ой, покажите мне такой ассемблер (все равно для чего), который будет по своему усмотрению выравнивать dw или ds   Хочу полюбоваться   

al.s

как видим - никаких выравниваний   

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

У меня такое впечатление, что я имею дело не с адекватным человеком! Я говорил, что значение   указателя должны быть выравнено согласно выравниванию типа данных, на которое он указывает. Я несколько раз специально для вас это повторял и в качестве примера приводил указатель на тип int.  Во-вторых, совершенно не понятно, какие "определения  основных терминово" вам нужны? Любое цитирование стандарта предполагает ссылки на термины стандарта. Так что цитировать стандарт - это всегда корректно. В-третьих, стандарт С++ также требует выравнивание значений указателей в соответствии с выравниванием типов, на которые эти указатели указывают. Джае оставляя в стороне стандарты, а просто руководствуясь обычным здравым смыслом, очевидно, что в С и в С++ должно быть одно и то же выравнивание, так как модули на С и С++ очнь часто собираются в один проект. В противном случае любой проект, состоящий из смешанных модулей, был бы некорректным!

Буквально с больной головы на здоровую  

Вам уже все ясно объяснили. Неплохо было бы признать свою ошибку.
Время на вас тратить не хочу больше. 
Извините.

Вы очевидно относиетсь к тем программистам, опыт которых ограничен лишь работой на одной платформе, и которые начинают свято верить, что других аппаратных архитектур и операционных систем в природе просто не существует!
Я вам на самом деле уже все указал, просто вы не внимательно читаете, что вам другие пишут!
Есть такие вычислительные машины, как IBM mainframe. В настоящее время это серия Z, а операционная система соответственно называется z/OS. Так на этой платформе обращение к памяти, не выравненное соответсвующим образом приводит к аварийному завершению программы. Например, если вы в ассемблере для IBM, который называется HLASM ( от слов High Level Assembler ), зададите директиву



то память будет выравнена на границу слова. Если у вас есть знакомые, которые имеют дело с IBM mainframe, то вы можете у них проконсультироваться. У меня есть документация по IBM mainframe, включая "Руководство по операциям", а также руководства по ассемблеру HLASM, которая лежит где-то упакованная. Как я найду ее, то сомгу вам привести непосредственно выдержки из документации. А пока ограничусь цитатой из старой книги автора У.Радд "Программирование на языке ассемблера на вычислительной системе IBM 360 и 370": "Это предложение (смотри выше -мое прим.) запрашивает резервирование трех полных слов ( 3F) и присваивает имени WORDS адрес первого из зарезервированных 12 байтов. Поскольку выделение памяти мы запросили полными словами будет произведено выравнивание по границе полного слова, т.е. в качестве адреса WORDS будет выбрано значение кратное 4." (стр. 135).

Когда на С или С++ объявляется статическая переменная типа int, то как раз генерируется директива ассемблера DS F. То есть на всех компиляторах, а не только IBM mainframe, для целых чисел выбирается размер машинного слова, соответсвующий размеру регистра. Почему это сделано? Да потому что арифметическим операциям поставлены в соответсвии машинные команды для выполнения арифметических операций над регистрами. Если бы не было такого соответсвия, то пришлось бы с помощью других команд моделироваться эти простейшие арифметические операции, что сразу же делало С и С++ неэффективными языками.

Когда вы сами удостоверитесь в том, что я написал, с помощью своих более опытных щнакомых, или справитесь по этому вопросу в интернет, то попробуйте поставить себя на место разработчиков стандарта языков С и С++. Правильный код, написанный на С/С++, должен быть переносим, не так ли? То есть поведение программы должно быть определенным. Теперь представьте ситуацию, что ваш "правильный" код на одной платформе работает, а на другой платформе аварийно завершается. И что тогда делать с переносимостью языка?! Она рассыпается как карточный домик! Значит надо принимать такое решение в стандарте, чтобы исключить такую ситуцию, чтобы действительно правильный окд, который удовлетворяет стандарту, мог работать на любой платформе!

Я вам приведу другой пример узости мышление подобного вашему. Он симметричен данной дискуссии, но только тогда оппонентом у меня выступал программист, работающий на IBM mainframe. ОН в стандартную строковую функцию передавал нулевой указатель. Когда я ему заявил, что так делать нельзя, и такое поведение программы неопределенное, он мне в ответ точно стал возражать походим образом, как это делаете вы. Он мне заявил, что программа нормально работает, так как IBM mainframe позволяет читать память по нулевым адресам. Убедить его было бесполезно, пока я его не подвел к Intel платформе, на которой вы работаете, и не показал, что программа завершается аварийно при попытке чтения в Windows памяти по нулевым адресам.

Так что смотрите на вещи ширше! И не думайте, что весь мир ограничен той платформой, на которой вы работаете!

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


Это вы хотите, чтобы я признал ваш бред в виде вашего кода




который совершенно не соответсвтует стандартам С и С++?!! Вы уж лучше учите С/С++! Это вам пойдет на пользу!

слишком жестко..  имхо, точнее было бы : который по стандарту является зависим от реализации/платформы.. 

    

Михаил Жванецкий в таких случаях отвечает:
-  Не говорите, что мне нужно делать, и я не буду говорить, куда вам нужно идти...   

Далеко не на одной, вынужден вас огорчить   SPARK, Itanium, ARM, x86, x86-64 Достаточно?

'Другие' - это вы один. Вам же пишут хором (человек так 5), но вы похоже вообще не читаете   

Да, IBM у меня под столом не завалялось, увы   

Ну и что? На SPARK'е это тоже так. И на ARM'е. А на x86 не так. И что это доказывает? Только то, что компьютеры бывают разные.

Когда на С или С++ объявляется статическая переменная типа int, то как раз генерируется директива ассемблера DS F. 
[/quote]gcc предпримет явные действия по выравниванию, а не будет полагаться на ассемблер



результат после g++ (ассемблер)



Я уже удостоверился, из первоисточника - компилятора. С более опытными 'щнакомыми' советую ознакомится вам, хотя видимо не поможет. Вам уже хором эти самые 'более опытные' говорят и говорят - все как об стенку горох   

Нет, не так. Может быть переносим, но не обязан. Переносимость - это всего лишь одно из требований к программе. Оно может требоваться, а может и не требоваться.

Запросто могу представить. Для начала она (программа) скорее всего на другой платформе не соберется.

А ее и нет. Посмотрите на коды переносимых программ на С (или С++). Найдете кучу ifdef и прочих прелестей, для каждой конкретной платформы.


Это ваши домыслы. Стандарт этого не требует. Если вам нужен 100% переносимый код - пишите на Java, хотя и там 100% не получается   

Ну и что? Его программа должна была работать на Windows? Если нет, то он абсолютно прав.


Не записывайте себя во 'весь мир'. 

Соответствует. Код абсолютно правильный (для x86), и абсолютно не переносимый.

Да уж, вам его учить не надо - на пользу явно не пошло   


PS. И не надо со мной спорить, просто поверьте человеку, который принимал участие в написании как минимум 2х коммерческих компиляторов.   

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



Это не мои домыфслы, а это ваше полное не знание стандарта языков программирования С и С++! Вы даже не знаете, как я уже написал выше, определение строгогго соответсвия программы стандарту!





У вас не только IBM под рукой нет, нол ук вас и знаний С и С++ нет, но тем не менее вы свое невежество пытаетесь поставить выше стандарта.

И потом, я вам уже ясно сказал, что если на одной платформе обращение к памяти, не выравненной по границе типа данного заканчивается аварийно, а на друцгой нет, то это никак не связан, как вы наивно думаете, с платформами, а это связано с тем, что 1) код некорректный; 2) вы совершенно не знаете С и С++. И это никак не свуязано с особенностями платформ, как вы наивно думаете! Иначе бы просто С, как языка, не существаовало. Не догадываетесь, почему? Попробутй догадаться с трех раз! Не догадались? Я вам подскажу: тогда бы поведение программ было совершенно не предсказуемыма!

Однако, как вам это не покажется странным, это на самом деле не так! Я для IBM mainframe писал программы на Visual C++, так как у меня под рукой тоже не было IBM mainframe. И тем не менее код, написанный на Visual C++ без единой ошибке исполнялся на IBM mainframe, когда я его пересылал по электронной почте.

Извините, но далее ваш бред мне просто не интересно читать!