Чи є переваги проходження вказівника над проходженням посиланням на C ++?

Які переваги проходження за вказівником над проходженням за посиланням в C ++?

Останнім часом я бачив ряд прикладів, які вибирали аргументи функції передачі вказівниками замість передачі посилання. Чи є користь від цього?

Приклад:

func(SPRITE *x);

із закликом

func(&mySprite);

vs.

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. Передайте значення, коли функція не бажає змінювати параметр, а значення легко копіювати (ints, double, char, bool тощо) прості типи. Std :: string, std :: vector та всі інші STL контейнери НЕ прості типи.)

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

3. Пройдіть повз покажчик non-const, коли значення копіюється дорого І функція хоче змінити значення, вказане на AND NULL, є дійсним, очікуваним значенням, яке обробляє функція.

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

5. Пропустити повне посилання, коли значення дорого копіюється І функція хоче змінити значення, на яке посилається І 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 , які виділяють у конструкторі, делокації в деструкторі і не в змозі поставити конструктор копій або оператор = ().

Раптом з’являється світ різниці між футом (бар BAR) і футом (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-перевірку на один рівень для абонента вашої функції.