Читаю тут одну книгу по C++ и не могу понять почему верна такая запись int *p=&a; (где a переменная типа int, объявленная выше)?
Цитата из книги: Указатель – это не сам объект, а его адрес. Чтобы превратить указатель в объект, применяется оператор *. Если, скажем, p – это указатель на переменную типа int, то *p – сама переменная типа int.

Мой вывод: получается что в инструкции int *p=&a; объекту на который указывает p присваивается адрес переменной a. В книге же написано, что в указатель p засылается адрес переменной a. Почему так???

Здравствуйте, MichaelXP, Вы писали:

MXP>Читаю тут одну книгу по C++ и не могу понять почему верна такая запись int *p=&a; (где a переменная типа int, объявленная выше)?
MXP>Цитата из книги: Указатель – это не сам объект, а его адрес. Чтобы превратить указатель в объект, применяется оператор *. Если, скажем, p – это указатель на переменную типа int, то *p – сама переменная типа int.

MXP>Мой вывод: получается что в инструкции int *p=&a; объекту на который указывает p присваивается адрес переменной a. В книге же написано, что в указатель p засылается адрес переменной a. Почему так???

Запись int *p=&a; является объявлением переменной р с типом "указатель на int", которая инициализируется адресом переменной а.
Эту составную инструкцию (объявление + инициализация) можно разбить на две:

int *p;
p = a;

Т.е. *р в этой инструкции — это не разыменованный указатель.


Другими словами, ты можешь объявить синоним для типа "указатель на int" и потом использовать его, тогда у тебя не будет смущающей тебя звездочки в объявлении (этим широко пользуется Microsoft, но я лично так писать не рекомендую):

typedef int * PINT;
PINT p = &a;

You will always get what you always got
  If you always do  what you always did

Здравствуйте, MichaelXP, Вы писали:

MXP>Читаю тут одну книгу по C++ и не могу понять почему верна такая запись int *p=&a; (где a переменная типа int, объявленная выше)?
MXP>Цитата из книги: Указатель – это не сам объект, а его адрес. Чтобы превратить указатель в объект, применяется оператор *. Если, скажем, p – это указатель на переменную типа int, то *p – сама переменная типа int.

MXP>Мой вывод: получается что в инструкции int *p=&a; объекту на который указывает p присваивается адрес переменной a. В книге же написано, что в указатель p засылается адрес переменной a. Почему так???

Операторы бывают только в выражениях. А 'int *p' — не выражение, а объявление переменной. Поэтому символ '*', который ты там видишь, не является оператором '*' и не имеет никакого отношения к оператору '*', о котором идет речь в дальнейшем тексте. Данный символ '*' — это просто элемент синтаксиса, используемый при объявлении указателей в С/С++. Поэтому целое объявление 'int *p = &a' определяет переменную 'p' типа 'int*' (указатель на 'int') и инициализирует это указатель адресом переменной 'a'.

Потом, когда ты будешь использовать этот указатель 'p', ты сможешь применить к нему оператор '*'

int *p = &a; // <- здесь нет применения оператора '*'
std::cout << *p; <- а это уже применение оператора '*'

Это будет именно то, о чем идет речь в книге. Но это использование '*', еще раз, не имеет никакого отношения к использованию '*' в объявлении 'p'.

Здравствуйте, MichaelXP, Вы писали:

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

int a = 3;
int* pa = &a;

проблемы с восприятием исчезают. Становится видно, что pa — это переменная типа "указатель на int".

Здравствуйте, SchweinDeBurg, Вы писали:

SDB>

SDB>int a = 3;
SDB>int* pa = &a;
SDB>

SDB>проблемы с восприятием исчезают. Становится видно, что pa — это переменная типа "указатель на int".

Но зато в этом случае появиться проблемы с восприятием вот этого:

int* a, b;

Ведь в данном случае тип "указатель на int" относится только к a. Но визуально
'*' от "int" не отделяется. Поэтому я всегда пишу так:

int *a, b;
double *c, *d;
// и т. д.

Здравствуйте, Dimeon, Вы писали:

D> Но зато в этом случае появиться проблемы с восприятием вот этого:

D>

D> int* a, b;
D>

Проблемы с восприятием этой и подобных, более сложных, конструкций будут в любом случае,
вне зависимости от положения "звездочки" и прочих "рюшечек":

int *a, (*c)();

поэтому лучшим решением будет писать так:

int* a;
int b;
int (*c)();

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Здравствуйте, Dimeon, Вы писали:

D>> Но зато в этом случае появиться проблемы с восприятием вот этого:

D>>

D>> int* a, b;
D>>

ПК>Проблемы с восприятием этой и подобных, более сложных, конструкций будут в любом случае,
ПК>вне зависимости от положения "звездочки" и прочих "рюшечек":

ПК>

ПК>int *a, (*c)();
ПК>

ПК>поэтому лучшим решением будет писать так:

ПК>

ПК>int* a;
ПК>int b;
ПК>int (*c)();
ПК>

А может тогда лучше

typedef int* IntPtr;
...
IntPtr pA, pB;

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

Здравствуйте, Вы писали:

> А может тогда лучше
>

> typedef int* IntPtr;
> ...
> IntPtr pA, pB;
>

И так на каждый чих?

IntConstPtr pA, pB;
IntConstPtrRef rpA, rpB; // кстати, что сие значит без определения IntConstPtrRef угадать
                         // тяжело: то ли ссылка константная, то ли указатель...

Достаточно просто отказаться от записи объявлений переменных
через запятую — и будет всем счастье

int* pA;
int* pB;
const int*& rpA;
const int*& rpB;

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>И так на каждый чих?

Ну в общем конечно же во всем нужна золотая середина.
Вот ее постоянно и ищу

С int может это и перебор, а вот для всех своих собственных
классов указатели (вернее умные указатели) объявляю таким способом

class MyCoolClass {};
typedef MyCoolSmartPointer < MyCoolClass > MyCoolClassPtr;
typedef const MyCoolSmartPointer < MyCoolClass > MyCoolClassConstPtr;

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

Здравствуйте, Андрей Тарасевич, Вы писали:

АТ>Операторы бывают только в выражениях. А 'int *p' — не выражение, а объявление переменной. Поэтому символ '*', который ты там видишь, не является оператором '*' и не имеет никакого отношения к оператору '*', о котором идет речь в дальнейшем тексте. Данный символ '*' — это просто элемент синтаксиса, используемый при объявлении указателей в С/С++. Поэтому целое объявление 'int *p = &a' определяет переменную 'p' типа 'int*' (указатель на 'int') и инициализирует это указатель адресом переменной 'a'.

АТ>Потом, когда ты будешь использовать этот указатель 'p', ты сможешь применить к нему оператор '*'

АТ>

АТ>int *p = &a; // <- здесь нет применения оператора '*'
АТ>std::cout << *p; <- а это уже применение оператора '*'
АТ>

АТ>Это будет именно то, о чем идет речь в книге. Но это использование '*', еще раз, не имеет никакого отношения к использованию '*' в объявлении 'p'.
И все же! Как красиво, а?! Применение одной только звездочки! Никаких тебе специальных ключевых слов! И опять же
int *p; // *p — целая переменная!
Когда до меня дошла такая вот красота конструкций С, я его и полюбил.

Здравствуйте, LaptevVV, Вы писали:

LVV>И все же! Как красиво, а?! Применение одной только звездочки! Никаких тебе специальных ключевых слов! И опять же
LVV>int *p; // *p — целая переменная!
LVV>Когда до меня дошла такая вот красота конструкций С, я его и полюбил.

Точно! я C/C++ полюбил за это же!