Есть ли преимущества передачи по указателю перед передачей по ссылке в C ++?

Каковы преимущества передачи по указателю перед передачей по ссылке в C ++?

В последнее время я видел ряд примеров, в которых аргументы функции передаются по указателям, а не по ссылке. Есть ли преимущества для этого?

Пример:

func(SPRITE *x);

с вызовом

func(&mySprite);

против

func(SPRITE &x);

с вызовом

func(mySprite);

Указатель может получить параметр NULL, а ссылочный параметр - нет. Если есть вероятность, что вы захотите передать «нет объекта», используйте указатель вместо ссылки.

Кроме того, передача по указателю позволяет вам явно видеть на сайте вызова, передается ли объект по значению или по ссылке:

// Is mySprite passed by value or by reference?  You can't tell 
// without looking at the definition of func()
func(mySprite);

// func2 passes "by pointer" - no need to look up function definition
func2(&mySprite);

Передача по указателю

• Звонящий должен взять адрес -> не прозрачный
• Значение 0 может быть предоставлено, чтобы означать nothing. Это может быть использовано для предоставления необязательных аргументов.

Передать по ссылке

• Абонент просто передает объект -> прозрачный. Должен использоваться для перегрузки операторов, поскольку перегрузка для типов указателей невозможна (указатели являются встроенными типами). Так что вы не можете string s = &str1 + &str2;использовать указатели.
• 0 значений невозможно -> Вызываемая функция не должна проверять их
• Ссылка на const также принимает временные значения: void f(const T& t); ... f(T(a, b, c));указатели не могут использоваться таким образом, поскольку вы не можете получить адрес временного объекта.
• И последнее, но не менее важное: ссылки проще в использовании -> меньше шансов для ошибок.

Мне нравится рассуждение статьи из "cplusplus.com:"

1. Передача по значению, когда функция не хочет изменять параметр, а значение легко копировать (целые, двойные, char, bool и т. Д. ... простые типы. Std :: string, std :: vector и все другие STL контейнеры НЕ простые типы.)

2. Передача по указателю const, когда значение копируется слишком дорого, и функция не хочет изменять значение, указанное в AND. NULL является допустимым ожидаемым значением, которое обрабатывает функция.

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

4. Передача по константной ссылке, когда значение копируется дорого, и функция не хочет изменять значение, указанное в AND. NULL не будет допустимым значением, если вместо этого используется указатель.

5. Передача по неконтрольной ссылке, когда значение дорого копировать, а функция хочет изменить значение, указанное в AND, NULL не будет допустимым значением, если вместо этого используется указатель.

6. При написании шаблонных функций нет однозначного ответа, потому что есть несколько компромиссов, которые следует рассмотреть, которые выходят за рамки этого обсуждения, но достаточно сказать, что большинство шаблонных функций принимают свои параметры по значению или (const) ссылке Однако, поскольку синтаксис итератора аналогичен синтаксису указателей (от звездочки до «разыменования»), любая шаблонная функция, которая ожидает итераторы в качестве аргументов, также по умолчанию также принимает указатели (и не проверяет NULL, поскольку концепция итератора NULL имеет другой синтаксис ).

http://www.cplusplus.com/articles/z6vU7k9E/

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

В конце концов, в документации / комментариях к функции должно быть указано, является ли значение входным, выходным, изменяемым и т. Д.

«Достаточно веревки, чтобы выстрелить себе в ногу» Аллена Холуба, перечисляет следующие 2 правила:

120. Reference arguments should always be `const`
121. Never use references as outputs, use pointers

Он перечисляет несколько причин, по которым ссылки были добавлены в C ++:

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

Его главная мысль заключается в том, что ссылки не должны использоваться в качестве выходных параметров, потому что на сайте вызова нет указаний на то, является ли параметр ссылкой или параметром-значением. Таким образом, его правило - использовать только constссылки в качестве аргументов.

Лично я думаю, что это хорошее эмпирическое правило, поскольку оно делает более понятным, когда параметр является выходным параметром или нет. Однако, хотя я лично согласен с этим в целом, я позволяю себе склоняться к мнению других членов моей команды, если они отстаивают выходные параметры в качестве ссылок (некоторым разработчикам они очень нравятся).

Пояснения к предыдущим постам:

Ссылки НЕ являются гарантией получения ненулевого указателя. (Хотя мы часто относимся к ним как к таковым.)

В то время как ужасно плохой код, например, выводит вас из-за плохого кода, скомпилирует и запустит следующее: (По крайней мере, под моим компилятором.)

bool test( int & a)
{
  return (&a) == (int *) NULL;
}

int
main()
{
  int * i = (int *)NULL;
  cout << ( test(*i) ) << endl;
};

Реальная проблема, которую я имею со ссылками, связана с другими программистами, далее именуемыми IDIOTS , которые выделяют в конструкторе, освобождают в деструкторе и не могут предоставить конструктор копирования или оператор = ().

Внезапно возникает огромная разница между foo (BAR bar) и foo (BAR & bar) . (Автоматическая побитовая операция копирования вызывается. Удаление в деструкторе вызывается дважды.)

К счастью, современные компиляторы подберут это двойное освобождение одного и того же указателя. 15 лет назад они этого не сделали. (В gcc / g ++ используйте setenv MALLOC_CHECK_ 0, чтобы вернуться к старым способам.) В результате в DEC UNIX в одной и той же памяти выделяется два разных объекта. Там много отладочного веселья ...

Более практично:

• Ссылки скрывают, что вы меняете данные, хранящиеся где-то еще.
• Ссылку легко скопировать с скопированным объектом.
• Указатели делают это очевидным!

Большинство ответов здесь не в состоянии устранить неоднозначность, присущую необработанному указателю в сигнатуре функции с точки зрения выражения намерения. Проблемы заключаются в следующем:

• Вызывающая сторона не знает, указывает ли указатель на один объект или на начало «массива» объектов.

• Вызывающая сторона не знает, «принадлежит» ли указатель памяти, на которую он указывает. IE, должна ли функция освободить память. ( foo(new int)- Это утечка памяти?).

• Вызывающая сторона не знает, nullptrможет ли она быть безопасно передана в функцию.

Все эти проблемы решаются по ссылкам:

• Ссылки всегда относятся к одному объекту.

• Ссылки никогда не владеют памятью, к которой они относятся, они просто видят память.

• Ссылки не могут быть нулевыми.

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

• Нет явного косвенного Это не проблема с необработанным указателем, так как мы должны использовать &оператор, чтобы показать, что мы действительно передаем указатель. Например, int a = 5; foo(a);здесь совершенно не ясно, что a передается по ссылке и может быть изменено.
• Допустимость пустой. Эта слабость указателей также может быть сильной стороной, когда мы действительно хотим, чтобы наши ссылки были обнуляемыми. Видя, что std::optional<T&>это недопустимо (по уважительным причинам), указатели дают нам такую ​​обнуляемость, которую вы хотите.

Таким образом, кажется, что когда мы хотим пустую ссылку с явным косвенным обращением, мы должны достичь T*права? Неправильно!

Абстракции

В нашем отчаянии за обнуляемость мы можем достичь T*и просто игнорировать все недостатки и семантическую двусмысленность, перечисленные ранее. Вместо этого мы должны достичь того, что C ++ делает лучше всего: абстракция. Если мы просто напишем класс, который обтекает указатель, мы получим выразительность, а также обнуляемость и явную косвенность.

template <typename T>
struct optional_ref {
  optional_ref() : ptr(nullptr) {}
  optional_ref(T* t) : ptr(t) {}
  optional_ref(std::nullptr_t) : ptr(nullptr) {}

  T& get() const {
    return *ptr;
  }

  explicit operator bool() const {
    return bool(ptr);
  }

private:
  T* ptr;
};

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

void foo(optional_ref<int> x) {
  if (x) {
    auto y = x.get();
    // use y here
  }
}

int x = 5;
foo(&x); // explicit indirection here
foo(nullptr); // nullability

Мы достигли наших целей! Давайте теперь посмотрим на преимущества по сравнению с необработанным указателем.

• Интерфейс ясно показывает, что ссылка должна ссылаться только на один объект.
• Очевидно, он не владеет памятью, на которую ссылается, поскольку у него нет определенного пользователем деструктора и метода удаления памяти.
• Звонящий знает, что его nullptrможно передать, поскольку автор функции явно запрашиваетoptional_ref

Мы могли бы сделать интерфейс более сложным, например, добавив операторы равенства, монадику get_orи mapинтерфейс, метод, который получает значение или выдает исключение, constexprподдержку. Это может быть сделано вами.

В заключение, вместо использования сырых указателей, подумайте о том, что эти указатели действительно означают в вашем коде, и либо используйте стандартную абстракцию библиотеки, либо напишите свою собственную. Это значительно улучшит ваш код.

На самом деле, нет. Внутренне передача по ссылке осуществляется по существу передачей адреса объекта, на который есть ссылка. Таким образом, на самом деле нет никакого повышения эффективности при передаче указателя.

Однако передача по ссылке имеет одно преимущество. У вас гарантированно будет экземпляр любого объекта / типа, который передается. Если вы передадите указатель, то вы рискуете получить указатель NULL. Используя передачу по ссылке, вы отправляете неявную проверку NULL на один уровень вызывающей стороне вашей функции.