Funktionsargument als Verweis, um die Überprüfung auf NULL zu vermeiden

Question

Wenn ich eine Funktion habe, die einen Zeiger akzeptiert, der niemals NULL sein darf, mache ich normalerweise etwas wie das hier:

void Foo(const somePointer* ptr)
{
  if (ptr == NULL)
  {
    // Assertion werfen
    return;
  }

  // Etwas tun
}

Jetzt überprüfe ich also jedes Mal, ob der Zeiger NULL ist, und wenn er nicht von Anfang an auf NULL gesetzt und auch nicht allokiert ist, dann ist diese Überprüfung nutzlos. Jetzt überlege ich also, ob ich meine Funktionen so definieren sollte (obwohl mir klar ist, dass das nicht garantiert, dass ich ein gültiges Objekt erhalte, zumindest wird es nicht NULL sein):

void Foo(const somePointer& ptr)
{
  // Keine Überprüfung mehr nötig, der Client ist verantwortlich

  // Etwas tun
}

Bevor ich das also mache (oder auch nicht, abhängig von den Antworten, die ich hier bekomme), dachte ich, ich würde hier fragen und sehen, was alle dazu zu sagen haben, insbesondere die Vor- und Nachteile.

Answer 1

Nun, wenn Sie niemals ein nicht vorhandenes Objekt übergeben möchten, verwenden Sie eine Referenz (Hinweis: nicht vorhanden, nicht ungültig).
Wenn Sie diese Möglichkeit möchten, verwenden Sie einen Zeiger.

Answer 2

Sehr viel hängt von der Struktur Ihres Codes ab - wenn Sie viel Zeug wie dieses schreiben:

A * a = new A();
f( a );

dann ist es sinnvoll, dass f() einen Zeiger annimmt, anstatt zu schreiben:

f( *a );

Persönlich überprüfe ich praktisch nie auf NULL-Werte, new kann keinen zurückgeben, und wenn Sie feststellen, dass Sie einen haben, sind Sie wahrscheinlich bereits im UB-Bereich.

Answer 3

Ich halte es für sinnlos als Sicherheitsüberprüfung. Als Dokumentation ist es jedoch marginal sinnvoll.

Wenn Sie die Änderung vornehmen, wird nur passieren, dass ein Benutzer diesen Code ändert:

somePointer *ptr = something();
Foo(ptr);

Zu diesem:

somePointer *ptr = something();
Foo(*ptr);

Jetzt, wenn ptr null war, dann ist der erste Code ungültig, und es war ihr Fehler, null in eine Funktion zu übergeben, deren Parameter "niemals NULL sein sollte". Auch der zweite Code ist ungültig, und es war ihr Fehler, einen Nullzeiger aufzulösen.

Es ist hilfreich als Dokumentation, vielleicht werden sie beim Tippen des *-Zeichens denken: "oh, Moment mal, das darf nicht null sein". Während wenn Sie einfach dokumentiert haben, dass null eine ungültige Eingabe ist (wie z.B. strlen), müssten sie die Dokumentation lesen, um zu wissen, dass sie keinen Nullzeiger übergeben sollen. In der Theorie wird der Benutzer Ihres Codes die Dokumentation überprüfen, anstatt einfach wild auf der Tastatur herumzuhämmern, bis er etwas hat, das sich übersetzen lässt, und davon ausgehen, dass es funktioniert. In der Praxis haben wir alle unsere weniger intelligenten Momente.