Gibt es Vorteile beim Übergeben eines Zeigers gegenüber dem Übergeben eines Verweises in C ++?

Welche Vorteile bietet das Übergeben eines Zeigers gegenüber dem Übergeben eines Verweises in C ++?

In letzter Zeit habe ich eine Reihe von Beispielen gesehen, bei denen die Übergabe von Funktionsargumenten durch Zeiger anstelle der Übergabe als Referenz ausgewählt wurde. Gibt es Vorteile dabei?

Beispiel:

func(SPRITE *x);

mit einem Anruf von

func(&mySprite);

vs.

func(SPRITE &x);

mit einem Anruf von

func(mySprite);

Ein Zeiger kann einen NULL-Parameter empfangen, ein Referenzparameter nicht. Wenn die Möglichkeit besteht, dass Sie "kein Objekt" übergeben möchten, verwenden Sie einen Zeiger anstelle einer Referenz.

Durch Übergeben eines Zeigers können Sie außerdem an der Aufrufstelle explizit sehen, ob das Objekt als Wert oder als Referenz übergeben wird:

// 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);

Übergabe durch Zeiger

• Anrufer muss die Adresse nehmen -> nicht transparent
• Ein 0-Wert kann angegeben werden, um zu bedeuten nothing. Dies kann verwendet werden, um optionale Argumente bereitzustellen.

Als Referenz übergeben

• Der Anrufer übergibt nur das Objekt -> transparent. Muss für das Überladen von Operatoren verwendet werden, da ein Überladen für Zeigertypen nicht möglich ist (Zeiger sind eingebaute Typen). Sie können also keine string s = &str1 + &str2;Zeiger verwenden.
• Keine 0-Werte möglich -> Die aufgerufene Funktion muss nicht nach ihnen suchen
• Der Verweis auf const akzeptiert auch temporäre : void f(const T& t); ... f(T(a, b, c));, Zeiger können nicht so verwendet werden, da Sie die Adresse eines temporären nicht annehmen können.
• Last but not least sind Referenzen einfacher zu verwenden -> weniger Fehlerwahrscheinlichkeit.

Ich mag die Argumentation eines Artikels von "cplusplus.com:"

1. Übergeben Sie den Wert, wenn die Funktion den Parameter nicht ändern möchte und der Wert einfach zu kopieren ist (Ints, Doubles, Char, Bool usw.). Einfache Typen. Std :: string, std :: vector und alle anderen STL Behälter sind KEINE einfachen Typen.)

2. Übergeben Sie den const-Zeiger, wenn das Kopieren des Werts teuer ist UND die Funktion den Wert, auf den AND NULL zeigt, nicht ändern möchte. Dies ist ein gültiger, erwarteter Wert, den die Funktion verarbeitet.

3. Übergeben Sie einen nicht konstanten Zeiger, wenn das Kopieren des Werts teuer ist UND die Funktion den Wert ändern möchte, auf den AND NULL zeigt. Dies ist ein gültiger, erwarteter Wert, den die Funktion verarbeitet.

4. Übergeben Sie die Konstantenreferenz, wenn das Kopieren des Werts teuer ist UND die Funktion den auf AND NULL bezogenen Wert nicht ändern möchte. Dies wäre kein gültiger Wert, wenn stattdessen ein Zeiger verwendet würde.

5. Übergeben Sie eine nicht fortlaufende Referenz, wenn das Kopieren des Werts teuer ist UND die Funktion den auf AND NULL bezogenen Wert ändern möchte. Dies wäre kein gültiger Wert, wenn stattdessen ein Zeiger verwendet würde.

6. Beim Schreiben von Vorlagenfunktionen gibt es keine eindeutige Antwort, da einige Kompromisse zu berücksichtigen sind, die über den Rahmen dieser Diskussion hinausgehen. Es genügt jedoch zu sagen, dass die meisten Vorlagenfunktionen ihre Parameter nach Wert oder (const) Referenz verwenden Da jedoch die Iteratorsyntax der von Zeigern (Sternchen zu "Dereferenzierung") ähnlich ist, akzeptiert jede Vorlagenfunktion, die Iteratoren als Argumente erwartet, standardmäßig auch Zeiger (und prüft nicht auf NULL, da das NULL-Iteratorkonzept eine andere Syntax hat ).

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

Was ich daraus nehme, ist, dass der Hauptunterschied zwischen der Wahl eines Zeigers oder eines Referenzparameters darin besteht, ob NULL ein akzeptabler Wert ist. Das ist es.

Ob der Wert eingegeben, ausgegeben, geändert usw. werden kann, sollte schließlich in der Dokumentation / den Kommentaren zur Funktion enthalten sein.

Allen Holubs "Genug Seil, um sich in den Fuß zu schießen" listet die folgenden 2 Regeln auf:

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

Er listet mehrere Gründe auf, warum Referenzen zu C ++ hinzugefügt wurden:

• Sie sind erforderlich, um Kopierkonstruktoren zu definieren
• Sie sind für Überlastungen des Bedieners erforderlich
• const Mit Referenzen können Sie eine Semantik für die Übergabe von Werten verwenden und gleichzeitig eine Kopie vermeiden

Sein Hauptpunkt ist, dass Referenzen nicht als Ausgabeparameter verwendet werden sollten, da an der Aufrufstelle kein Hinweis darauf vorhanden ist, ob der Parameter eine Referenz oder ein Wertparameter ist. Seine Regel ist es also, nur constReferenzen als Argumente zu verwenden.

Persönlich halte ich dies für eine gute Faustregel, da dadurch klarer wird, ob ein Parameter ein Ausgabeparameter ist oder nicht. Obwohl ich dem im Allgemeinen persönlich zustimme, erlaube ich mir, mich von den Meinungen anderer in meinem Team beeinflussen zu lassen, wenn sie für Ausgabeparameter als Referenz argumentieren (einige Entwickler mögen sie sehr).

Erläuterungen zu den vorhergehenden Beiträgen:

Referenzen sind KEINE Garantie dafür, dass ein Zeiger ungleich Null erhalten wird. (Obwohl wir sie oft als solche behandeln.)

Während schrecklich schlechter Code, wie Sie hinter dem schlechten Code von Woodshed herausholen , wird Folgendes kompiliert und ausgeführt: (Zumindest unter meinem Compiler.)

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

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

Das eigentliche Problem, das ich mit Referenzen habe, liegt bei anderen Programmierern, im Folgenden IDIOTS genannt , die im Konstruktor zuordnen, im Destruktor freigeben und keinen Kopierkonstruktor oder Operator = () angeben .

Plötzlich gibt es einen großen Unterschied zwischen foo (BAR Bar) und foo (BAR & Bar) . (Der automatische bitweise Kopiervorgang wird aufgerufen. Die Freigabe im Destruktor wird zweimal aufgerufen.)

Zum Glück werden moderne Compiler diese doppelte Freigabe desselben Zeigers übernehmen. Vor 15 Jahren haben sie es nicht getan. (Verwenden Sie unter gcc / g ++ setenv MALLOC_CHECK_ 0 , um die alten Methoden erneut aufzurufen .) Unter DEC UNIX wird derselbe Speicher zwei verschiedenen Objekten zugewiesen. Viel Spaß beim Debuggen ...

Praktischer:

• Referenzen verbergen, dass Sie Daten ändern, die an einem anderen Ort gespeichert sind.
• Es ist leicht, eine Referenz mit einem kopierten Objekt zu verwechseln.
• Zeiger machen es deutlich!

Die meisten Antworten hier sprechen nicht die inhärente Mehrdeutigkeit an, einen Rohzeiger in einer Funktionssignatur zu haben, um die Absicht auszudrücken. Die Probleme sind die folgenden:

• Der Aufrufer weiß nicht, ob der Zeiger auf ein einzelnes Objekt oder auf den Anfang eines "Arrays" von Objekten zeigt.

• Der Aufrufer weiß nicht, ob der Zeiger den Speicher "besitzt", auf den er zeigt. IE, ob die Funktion den Speicher freigeben soll oder nicht. ( foo(new int)- Ist das ein Speicherverlust?).

• Der Anrufer weiß nicht, ob er nullptrsicher an die Funktion übergeben werden kann oder nicht .

Alle diese Probleme werden durch Referenzen gelöst:

• Referenzen beziehen sich immer auf ein einzelnes Objekt.

• Referenzen besitzen niemals das Gedächtnis, auf das sie sich beziehen, sie sind lediglich ein Blick in das Gedächtnis.

• Referenzen dürfen nicht null sein.

Dies macht Referenzen zu einem viel besseren Kandidaten für die allgemeine Verwendung. Referenzen sind jedoch nicht perfekt - es sind einige Hauptprobleme zu berücksichtigen.

• Keine explizite Indirektion. Dies ist bei einem Rohzeiger kein Problem, da wir den &Operator verwenden müssen, um zu zeigen, dass wir tatsächlich einen Zeiger übergeben. Zum Beispiel int a = 5; foo(a);ist hier überhaupt nicht klar, dass a als Referenz übergeben wird und geändert werden könnte.
• Nullbarkeit. Diese Schwäche von Zeigern kann auch eine Stärke sein, wenn wir tatsächlich wollen, dass unsere Referenzen nullbar sind. Da std::optional<T&>Zeiger (aus guten Gründen) nicht gültig sind, geben sie uns die gewünschte Nullfähigkeit.

Wenn wir also eine nullfähige Referenz mit expliziter Indirektion wollen, sollten wir nach einem T*Recht greifen ? Falsch!

Abstraktionen

In unserer Verzweiflung nach Nullfähigkeit können wir nach T*allen zuvor aufgeführten Mängeln und semantischen Zweideutigkeiten greifen und diese einfach ignorieren. Stattdessen sollten wir nach dem greifen, was C ++ am besten kann: einer Abstraktion. Wenn wir einfach eine Klasse schreiben, die einen Zeiger umschließt, gewinnen wir die Ausdruckskraft sowie die Nullbarkeit und explizite Indirektion.

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;
};

Dies ist die einfachste Oberfläche, die ich mir vorstellen kann, aber sie erledigt den Job effektiv. Sie können die Referenz initialisieren, prüfen, ob ein Wert vorhanden ist, und auf den Wert zugreifen. Wir können es so verwenden:

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

Wir haben unsere Ziele erreicht! Lassen Sie uns nun die Vorteile im Vergleich zum Rohzeiger sehen.

• Die Schnittstelle zeigt deutlich, dass sich die Referenz nur auf ein Objekt beziehen sollte.
• Offensichtlich besitzt es nicht den Speicher, auf den es sich bezieht, da es keinen benutzerdefinierten Destruktor und keine Methode zum Löschen des Speichers hat.
• Der Aufrufer weiß, dass übergeben werden nullptrkann, da der Funktionsautor explizit nach einem fragtoptional_ref

Wir könnten die Schnittstelle von hier aus komplexer gestalten, z. B. durch Hinzufügen von Gleichheitsoperatoren, einer Monade get_orund einer mapSchnittstelle, einer Methode, die den Wert abruft oder eine Ausnahme auslöst, constexprUnterstützung. Das können Sie tun.

Anstatt rohe Zeiger zu verwenden, begründen Sie, was diese Zeiger tatsächlich in Ihrem Code bedeuten, und nutzen Sie entweder eine Standard-Bibliotheksabstraktion oder schreiben Sie Ihre eigene. Dadurch wird Ihr Code erheblich verbessert.

Nicht wirklich. Intern erfolgt die Übergabe als Referenz, indem im Wesentlichen die Adresse des referenzierten Objekts übergeben wird. Es gibt also wirklich keine Effizienzgewinne durch Übergeben eines Zeigers.

Das Übergeben von Referenzen hat jedoch einen Vorteil. Es ist garantiert, dass Sie eine Instanz eines beliebigen Objekts / Typs haben, das übergeben wird. Wenn Sie einen Zeiger übergeben, besteht das Risiko, dass Sie einen NULL-Zeiger erhalten. Durch die Verwendung von Pass-by-Reference schieben Sie eine implizite NULL-Prüfung um eine Ebene an den Aufrufer Ihrer Funktion.