Почему в одном случае ошибка, а в другом нормально?

Ошибка

а тут норм



Это сообщение отредактировал(а) GQU - 29.8.2014, 20:29

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

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

Странно, а почему в первом случае  p всегда одинакова(у меня всегда 64), а во втором всегда разная

//тут p  всегда одинакова


//тут p  всегда разная


Это сообщение отредактировал(а) GQU - 29.8.2014, 21:02

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

Это сообщение отредактировал(а) Romikgy - 29.8.2014, 22:13

т.е сначала явная инициализация, потом что осталось на неинициализированные переменные?

Гм. Указатель - тоже переменная, и именно значение этой переменной будет случайно-мусорным, "если не инициализировать". Грубо говоря, значение указателя - это номер байта в адресном пространстве процесса, на который он указывает (отчего он и "указатель"). Если это указатель на int (как в Вашем случае), то он указывает сразу на четыре последовательных байта, начиная именно с того номера байта, которое есть значение указателя. Только в этом смысле неинициализированный обладает значением.

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

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



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

это не номер, это значение какого то случайного байта

это не значение какого то случайного байта . это адрес, гре рассположен объект. 

смотря с какой стороны смотреть
если так

то p это адрес, по которому располагается a

А если принимать указатель за переменную, то если ее не инициализировать, в ее 4 байта попадает случайный мусор, так же как и в любую другую неинициализированную переменную, например int
Просто в случае указателя эти данные будут восприниматься как адрес, а в случае int, как целое число

Это сообщение отредактировал(а) GQU - 29.8.2014, 23:08

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

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

Да как не посмотри.

Это как? Конечно, над указателями применима арифметика, что и над переменными, но указатель - это указатель, переменная - это переменная. И если уже сравнивать указатель на int с int, то это неудачное сравнение. Память не может располагаться по отрицательному адресу.  Здесь уместно будет сравнение с unsigned int. Вы, похоже, путаете значение указателя с значением объекта, на который ссылается указатель

Да, вот еще, Ваши оба примера у меня вывалились с ошибкой (С++). В конфигурации release оба отработали без ошибок. 

неправильно сказал
это значение каких то 4-х случайных байт

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

так нет инициализации, на разных компиляторах по разному, если который в ВизуалСтудио, там среда сама генерирует исключение, а на gcc норм

А указатель это и есть переменная, прсто в ней содержится адрес
 
Неправильно

я сравнивал не с int, а с 4-мя байтами, подразумевал беззнаковое целое

Это сообщение отредактировал(а) GQU - 31.8.2014, 07:25

Указатель всегда указывает на начальный байт адреса, где лежат данные. Компилятор уже сам, исходя из типа указателя, опрделяет из скольких байт, следующих за начальным адресом, взять данные.
Попробуйте сделать так:
Здесь компилятор сам вычисляет на сколько нужно сдвинуть указатель для каждого из типов. Так что указатель -- беззнаковое число, в котором хранится начальный адрес на область данных. Разыменовывание (операция *) говорит компилятору: сходи по такому-то адресу и возьми столько-то байт (в зависимости от типа на который указывает этот самый указатель).
И да, все указатели имеют одинаковую длину в байтах (в пределах данной архитектуры ОС), независимо от типа данных, на который они указывают. Если не прав -- поправьте, но мне это видится именно так.

Я бы все же использовал %p.