Как работает возврат ссылки?

#cpp

Что-то я туплю...
Есть класс буфера, который, возвращая элемент, копирует его в свой член OutObject
и возвращает ссылку на OutObject. Принимается же этот элемент в объект:
struct DataStr;

DataStr& TBuffer::get( void )
{
// ...
OutObject = *OldElement;
return OutObject;
}

DataStr data;
data = buffer->get();

К какой области памяти теперь относится data? К той же, что и раньше? Или к OutObject?
Или здесь все же происходит копирование значения?    

Ответы

Ответ 1

о боже, ответ получился безумно длинным  и без BBcode выглядит ужасно нечитабельно :(( 
не пугайтесь огромного размера :))



предисловие
чтобы не было путаницы ввиду пару обозначений
$ //некое место в коде (может иметь номер $1,$2)

переменная //именованная область данных (переменная с именем)
^ // временная переменная без имени но с адресом в памяти

адрес_объекта //адрес в памяти какого-нибудь объекта
адрес_переменной //адрес какой то переменной

переменная_указатель //переменная типа указатель
переменная_ссылка //переменная типа ссылка
переменная_объект //переменная типа объект

int переменная_объект    //переменная типа int
int переменная_указатель //указатель на int 
int переменная_ссылка    //ссылка на int

(текст) //какие то мысли или пояснение




что такое ссылка ?
все ссылки это по сути константные указатели (не путать с указателем на конст)
то есть 
тип * const имя_переменной_указатель

у ссылок есть пара отличий от просто указателя

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

во время компиляции, компилятор автоматически переделает ссылку в конст_переменная_указатель,
возьмёт адрес_объекта и во всех местах где используется ссылка подставит разыменование
(*конст_переменная_указатель)...



передача\возврат значений в\из функцию
главное всегда помнить в функцию ничего не передаётся и функция ничего не возвращает
на самом деле вы создаёте в функции новую переменную и присваиваете ей значение из
вызвавшей_функции (эта переменная может быть указателем, ссылкой или объектом)
при возврате вы создаёте в вызвавшей_функции новую переменную и присваиваете ей значение
из функции (эта переменная так же может быть указателем, ссылкой или объектом. Она
имеет адрес в памяти но не имеет имени)



создаём в функции новые переменные
---------------пример1:
void fun(тип переменная_1_объект) $ {   
   \\...
}
\\--------------------------------\\
fun(переменная_объект);

при вызове fun() в месте $ будет выполнена операция 
тип переменная_1_объект = переменная_объект


---------------пример2:
void fun(тип &переменная_1_ссылка) $ {   
   \\...
}
\\--------------------------------\\
fun(переменная_объект);

при вызове fun() в месте $ будет выполнена операция 
тип &переменная_1_ссылка = переменная_объект


---------------пример3: (работать не будет)
void fun(тип *переменная_1_указатель) $ {   
   \\...
}
\\--------------------------------\\
fun(переменная_объект);

при вызове fun() в месте $ будет выполнена операция 
тип *переменная_1_указатель = переменная_объект //вот тут то и неработает




создаём в вызвавшей_функции переменные без имени "^"
---------------пример1:
тип fun(){   
   \\...
   return переменная_1_объект;
}
\\--------------------------------\\
$ fun();

в вызвавшей_функции в месте $ будет выполнена операция
тип ^_объект = переменная_1_объект


---------------пример2:
тип& fun(){   
   \\...
   return переменная_1_объект;
}
\\--------------------------------\\
$ fun();

в вызвавшей_функции в месте $ будет выполнена операция
тип &^_ссылка = переменная_1_объект


---------------пример3: (работать не будет)
тип* fun(){   
   \\...
   return переменная_1_объект;
}
\\--------------------------------\\
$ fun();

в вызвавшей_функции в месте $ будет выполнена операция
тип *^_указатель= переменная_1_объект //вот тут то и неработает




смешиваем
---------------пример:
тип& fun(тип &переменная_1_ссылка)$1{   
   \\...
   return переменная_1_ссылка;
}
\\--------------------------------\\
$2 fun(переменная_объект);

в функции_fun в месте $1 будет выполнена операция
тип &переменная_1_ссылка = переменная_объект

затем в вызвавшей_функции в месте $2 будет выполнена операция
тип &^_ссылка = (переменная_1_ссылка)

тоесть ^_ссылка и переменная_1_ссылка будут указывать на переменная_объект

если кто не понял  привожу аналогичный код в виде указателей
в функции_fun в месте $1 будет выполнена операция
тип * const переменная_1 = &переменная //(объект)

затем в вызвавшей_функции в месте $2 будет выполнена операция
тип * const ^ = &(*переменная_1) //




p.s стоит ли писать про то когда вызывается конструктор_копирования, а когда оператор= ???
p.s.s вопросы, недочёты, ошибки и т.д. писать в коментах под этим постом
p.s.s.s пусть "очень много "пожеланий"" создателей Markdown