C++: различие между амперсандом “&\” и звездочкой “*” в функции/объявлении метода?

В первом примере со ссылками Вы знаете, что b не может быть ПУСТЫМ. С примером указателя, b мог бы быть Нулевой указатель.

Однако примечание, что возможно передать Несуществующий объект через ссылку, но это является неловким и названная процедура может предположить, что это - ошибка сделать так:

a1(*(float *)NULL);

Да. * в нотации говорится, что, что, передают стек, указатель, т.е., адрес чего-то. Эти & говорит, что это - ссылка. Эффект подобен, но не идентичен:

Позволяют нам взять два случая:

   void examP(int* ip);
   void examR(int& i);

   int i;

, Если я звоню examP, я пишу

   examP(&i);

, который берет адрес объекта и передает его стеку. Если я звоню examR,

   examR(i);

мне не нужен он; теперь компилятор "так или иначе" передает ссылку - который практически означает, что это получает и передает адрес i. На стороне кода тогда

   void examP(int* ip){
        *ip += 1;
   }

я должен удостовериться, что разыменовал указатель. ip += 1 делает что-то совсем другое.

   void examR(int& i){
        i += 1;
   }

всегда обновления значение [1 111].

Для больше для размышления о читайте на "вызове по ссылке" по сравнению с "вызовом по значению". & понятие дает вызов по ссылке C++.

Во втором примере вызывающая сторона должна снабдить префиксом имя переменной '&'; передать адрес переменной.

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

Кроме синтаксического сахара, единственной реальной разницей является способность к параметру функции, который является указателем для пустого указателя. Таким образом, версия указателя может быть более выразительной, если она обрабатывает пустой случай правильно. Пустой случай может также иметь некоторое особое значение, присоединенное к нему. Ссылочная версия может только воздействовать на значения типа, определенного без пустой возможности.

Функционально в Вашем примере, обе версии делают то же.

первое имеет преимущество, что это прозрачно на стороне вызова. Вообразите, как это искало бы оператор:

cin >> &x;

И как это выглядит ужасным для вызова подкачки

swap(&a, &b);

, Вы хотите подкачать a и b. И это выглядит намного лучше чем тогда, когда сначала необходимо взять адрес. Кстати, bjarne stroustrup пишет, что основная причина ссылок была прозрачностью, которая была добавлена в стороне вызова - специально для операторов. Также посмотрите, как больше не очевидно, добавил ли следующий

&a + 10

10 к содержанию a, назвав оператор + его, или добавляет ли это 10 к временному указателю, чтобы a. Добавить что к невозможности, что Вы не можете перегрузить операторы только для встроенных операндов (как указатель и целое число). Ссылки делают это совершенно прозрачным.

Указатели полезны, если Вы хотите быть в состоянии поместить "пустой указатель":

a1(0);

Тогда в a1 метод может сравнить указатель с 0 и видеть, указывает ли указатель на какой-либо объект.

Одна большая разница, которую стоит отметить, - то, что продолжается снаружи, Вы любой имеет:

a1(something);

или:

a1(&something);

мне нравится передавать аргументы ссылкой (всегда константа один:)), когда они не изменяются в функции/методе (и затем можно также передать автоматические внутренние / внутренние временные объекты) и передают их указателем, чтобы показать и предупредить пользователя/читателя кода, называя метод, что аргумент может и вероятно намеренно изменяться внутри.