Здравствуйте.
Классический пример :



Прокомментируйте пожалуйста, почему строчка temp=x отработает корректно, ведь x должен быть адресом, я ведь не пишу
int *temp=x;

Как я понял в x уже хранится конкретное значение. Но как я его извлёк из адреса, если операция извлечения выглядит как *x. Тогда по идее строка должна выглядеть так :
int temp=*x.

Прокомментируйте пожалуйста где я ошибаюсь, и если можно сделайте комментарий к каждой строчке функции swap. Вот например, функция принимает два дареса, или в процессе приёма данных берёт операцию адреса переменных ?Ведь вызывать я буду её как
swap(a,b) а не swap(&a,&b)

Спасибо

MasterZiv , спасибо за ответ. Вероятно я получил много ценной информации, но не всё мне понятно.

А1
"ссылка -- это не указатель. Это всегда разименованный константный указатель." Мне не очень понятно это выражение.

Как я это понимаю: согласно K&R, "Указатель - это переменная содержащая адрес другой переменной". То есть например я объявил
int *px; Так, вот элемент x-может хранить значение адреса другой переменной. Далее, адрес переменной.
int x;//объявил переменную типа int, которая имеет свой сегмент в ОП, и свой адрес в памяти, например 0x123
px=&x; //теперь в px хранится значение 0x123.

Причём тут я не провожу дифференциации на то, константный ли указатель, или нет. Константный указатель это неизменяемый адрес памяти, если я правильно понимаю.
то есть если я напишу
int *const px2;
px2=&x;//адрес x это и есть ссылка ? и это есть в данном случае разименнованный константный указатель ? а в примере выше, px ведь можно менять, и потому в том случае это не ссылка ?

А2
"При работе со ссылками у переменной сохраняется семантика самой переменной, а не указателя на переменную, но эффективно при инициализации ссылки производится как бы "передача указателя" при работе подобной этой ?
int *px=&x; //и да, я ведь не могу написать int x=&x;
Объясните пожалуйста эту фразу побробнее.

Б1
// код на ссылках, с проставленными явно операциями, выполняемыми неявно компилятором. (в лишних скобках)

void swap(int &x, int &y) // тут как бы неявно (int *x, int *y)
{
int temp = (*x);
(*x) = (*y);
(*y) = temp;
}

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

Б2
// код с комментариями
void swap(int &x, int &y) // реально на физическом уровне передаются указатели на две переменные
// но в функции ты не можешь поменять эти адреса или использовать их как массивы, т.е. реализовать с ними адресную арифметику.
{
int temp=x; // эффективно выполняется код int temp = *x , т.е. в temp заносится значение, располагающееся по адресу x.
x=y; // эффективно выполняется код *x = *y , по адресу x заносится значение, лежащее по адресу y.
y=temp; // эффективно выполняется *y = temp, по адресу y заносится значение temp.
}

Тогда зачем этот код ??Тот выше намного логичнее, что значит фраза эфективнее ? Быстрее сделать в этом примере, чем в примере выше Б1?

Прокомментируйте пожалуйста.

mayton, это шутка ?)

"MasterZiv, можно попробовать сделать #define swap ... "

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

define sqr(x) x*x
...
int x=5,y;
y=sqr(x+1);

Известно что препроцессор сделает.
Мне кажется, что если define где и используется, то только в тех программах которые работают со своим кодом. то есть программы который меняют свой программный код. Где то я про такое слышал.

Или это не шутка ?
Тогда define swap(x,y) а дальше как ? не {int temp; temp=x;x=y;y=temp;} ?
и то, тут вероятно ошибка

Anatoly Moskovsky, вы правы.

K&R не говорят о типе переменных как
int &x; я понял!
У нас есть , f e:
int x=100;// &x=0x123
int &rx=x;// &rx=0x123 То есть эта переменная имеет тип данных ссылка ? Это ссылочный тип данных которого нет в Си, и он появился в C++ ?
и как я понял операция взятий значения по адресу ссылки в данном случае выглядит как rx; f e: int temp=rx ??


void swap(int &x, int &y) //функция принимает именно два адреса
{
int temp=x; //в temp записывается значение по адресу x, в temp сейчас хранится конкретное целое число
x=y; //аналогично выше
y=temp; //аналогично
}

То что я написал выше корректно ?

И остался вопрос, я его практически понял подсознательно, но не конца .
используем функцию вызовом
swap(x,y)
Непонятно только это, если всё написанное выше верно

у нас есть
swap(int &a,int &b) -прототип функции

int x1=5,y=10; //&x=0x123 &y=0x127

Делаю вызов
swap(,y);

Функция принимает две переменных ссылочного типа, две ссылки, то есть в момент вызова
А- функция принимает (0x123 , 0x127 )
Б- как это происходит что берутся как бы псевдонимы этих переменных ??

ааа.стоп
я ведь пишу
int rx=&x;
И именно поэтому функция вызывается таким образом ?))

Итого:
При вызове функции (в прототипе она принимает &a,&b), в значения &a и &b записываются адреса переменных x и y !!!, и далее происходит работа с ними ?)
Я правильно понял ??

PS
"Функция принимает две переменных ссылочного типа, две ссылки, то есть в момент вызова
А- функция принимает (0x123 , 0x127 )
"
Этот мой комментарий верен, но некорректен !! Функция подставляет адреса принимаемых переменных x и у в &a и &b ! Вот это грамотный комментарий ! То есть фактически во время вызова функции происходят две операции:
int &a=x;
int &b=y;

Верно ??

Даже не подставляет, а делает так что параметры a и b берут значение из той же области памяти что и x с y

Anatoly Moskovsky,

// при вызове
swap(x, y);
// генерится следущий код
// int& tmp1 = x;
// int& tmp2 = y;
// swap(tmp1, tmp2);

Я понял !))) Спасибо!

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

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

м. А указатель это переменная хранящая адрес другой переменной. Интересные комбинации могут получить из указателей и адресов.


Anatoly Moskovsky и MasterZiv, Спасибо за все объяснения! Я понял !

Кстати, объявления вида:



Как я понял аналогичны, но ведь очевидно что первое int& rx; будет более грамотным, разве нет ? Или тут такая-же ситуация как с обратным чтением
const int*- указатель типа int на константу
int *const -константный указатель на целое число

да нет, всё равно int& x; выглядит грамотней, intr& это тип, а rx это имя переменной

про SRC понял, окей.

"так нефиг в одной строке объявлять несколько переменных "