Какова разница между "struct node * temp" и "struct node * & temp"?

Question

Хотя делать некоторые вопросы на основе бинарных деревьев поиска ... я немного запутался в вызове функции:

void find(node* root,node*& temp) 
{ 
    blah blah... 
} 
int main() 
{ 
    node* temp=NULL; 
    node* root=NULL; 
    find(root,temp); 
} 

В чем разница между двумя переданными аргументами?

Answer 1

В

void find(node* root,node*& temp) 

root передается по значению. Все, что вы делаете до *root, будет отражено в вызывающем, но никакого изменения на root не будет.

temp передается путем ссылки. Все, что вы делаете до *temp, будет отражено в вызывающем абоненте, и любое изменение на temp также будет отражено в вызывающем абоненте.

Answer 2

Первый параметр функции указателя (то есть node *root) передается по значению (т.е. копия исходного объекта-указателя передается в функцию), а второй (то есть node*& temp) передается по ссылке (то есть, в функции передается псевдоним исходного указателя).

Рассмотрим следующий пример:

void find(node* root,node*& temp) { 
    root = z; 
    temp = z; 
} 

int main() { 
    node *root = x; 
    node *temp = y; 
    find(root, temp); 
    // at this point root still points to x 
    // temp changed and points to z 
} 

Answer 3

node *root представляет собой указатель на структуру node (передается по значению). Если вы измените значение, вы меняете местную цельную.

node *&temp представляет ссылку на указатель на структуру node. Если вы измените значение temp, вы измените исходный указатель, пройденный по ссылке.

Answer 4

Префикс & по объявляемому идентификатору делает его ссылкой. Поскольку ссылка не const, выражение аргумента должно быть lvalue (т. Е. Должно обозначать объект). Функция может изменить этот объект!

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

Объявленный тип не изменяется; в любом случае, тип node *. Ссылка не является тип; это аспект того, как имя относится к значению.

Например, если мы имеем:

int x = 0, y = 2; 

есть два объекта. Если мы заявляем y в качестве ссылки, есть один объект типа int, который фактически имеет два названия:

int x = 0, &y = x; 

инициализатор для ссылки является сама x объекта, а не значением x «s.

Когда мы объявляем параметр функции в качестве ссылки, он становится «ссылочным параметром».Способ, которым функция получает значение через этот параметр, изменяется от обычной семантики «pass by value», унаследованной от C.

Также возможно привязать ссылки к типам const. Любопытные константные параметры. они могут получить буквенные объекты в качестве значений:

void foo(const int &x); // can be called as foo(42); ! 

Const ссылки полезны, потому что, когда вы передаете константную ссылку на объект класса, он напоминает «передать по значению», но дешевле, потому что сам объект передается (нет копирование строительства).

В C++ были введены ссылки на константы для решения проблемы «какой должен быть параметр конструктора копирования?». Конструктор копирования не может выглядеть следующим образом:

some_class::some_class(some_class original_obj) { /*...*. } 

, потому что это создает проблему курицы и яйца: передавая объект в конструктор копирования требует копию (в связи с семантикой по значению), который требует конструктор копирования ! Const. Справочное изобретение на помощь:

some_class::some_class(some_class &original_obj) { /*...*. } 

Проблема решена; конструктор копирования получает объект по ссылке, но таким образом, что он квазибезопасен, потому что объект квазинемодифицируется. (Квази, потому что в какой-то момент было создано ключевое слово mutable для пробивания отверстий в объектах const.)