Kann ich if (Zeiger) anstelle von if (Zeiger! = NULL) verwenden?

Ist es sicher, einen Zeiger darauf zu überprüfen, dass man nicht NULLeinfach schreibt, if(pointer)oder muss ich ihn verwenden if(pointer != NULL)?

Sie können; Der Nullzeiger wird implizit in einen booleschen Wert false umgewandelt, während Nicht-Nullzeiger in true konvertiert werden. Aus dem C ++ 11-Standard, Abschnitt über Boolesche Konvertierungen:

Ein Wert von arithmetischer, nicht skalierter Aufzählung, Zeiger oder Zeiger auf Elementtyp kann in einen Wert vom Typ konvertiert werden bool. Ein Nullwert, ein Nullzeigerwert oder ein Nullelementzeigerwert wird in konvertiert false. Jeder andere Wert wird in konvertiert true . Ein Wert vom Typ std::nullptr_t kann in einen Wert vom Typ konvertiert werden bool . der resultierende Wert ist false .

Ja du könntest.

• Ein Nullzeiger wird implizit in false konvertiert
• Ein Nicht-Null-Zeiger wird in true konvertiert.

Dies ist Teil der C ++ - Standardkonvertierung, die in die Boolesche Konvertierungsklausel fällt :

§ 4.12 Boolesche Konvertierungen

Ein Wert von arithmetischer, nicht skalierter Aufzählung, Zeiger oder Zeiger auf Elementtyp kann in einen Wert vom Typ bool konvertiert werden. Ein Nullwert, ein Nullzeigerwert oder ein Nullelementzeigerwert wird in false konvertiert. Jeder andere Wert wird in true konvertiert. Ein Wert vom Typ std :: nullptr_t kann in einen Wert vom Typ bool konvertiert werden. Der resultierende Wert ist falsch.

Ja, du kannst. Tatsächlich bevorzuge ich die Verwendung, if(pointer)weil das Lesen und Schreiben einfacher ist, wenn man sich erst einmal daran gewöhnt hat.

Beachten Sie auch, dass C ++ 11 eingeführt wurde, nullptrdas gegenüber bevorzugt wird NULL.

Die Frage wird beantwortet, aber ich möchte meine Punkte hinzufügen.

Ich werde immer lieber if(pointer)anstelle von if(pointer != NULL)und if(!pointer)anstelle von if(pointer == NULL):

• Es ist einfach, klein

• Weniger Chancen auf einen fehlerhaften Code zu schreiben, nehme an, wenn ich Gleichheitsprüfung Operator falsch geschrieben ==mit =
if(pointer == NULL)kann falsch geschrieben , if(pointer = NULL)damit ich es vermeiden, am besten ist einfach if(pointer).
  _{(Ich schlug auch eine Yoda-Bedingung in einer Antwort vor , aber das ist eine andere Sache)}

• In ähnlicher Weise while (node != NULL && node->data == key)werde ich einfach schreiben while (node && node->data == key), was für mich offensichtlicher ist (zeigt, dass Kurzschluss verwendet wird).

• (kann ein dummer Grund sein) Da NULL ein Makro ist, nehmen wir an, dass jemand versehentlich mit einem anderen Wert neu definiert.

Das explizite Überprüfen auf NULL kann dem Compiler einen Hinweis darauf geben, was Sie versuchen, was dazu führen kann, dass er weniger fehleranfällig ist.

Ja, du kannst. Die Möglichkeit, Werte implizit mit Nullen zu vergleichen, wurde von C geerbt und ist in allen Versionen von C ++ vorhanden. Sie können auch if (!pointer)Zeiger auf NULL prüfen.

Die relevanten Anwendungsfälle für Nullzeiger sind

• Umleitung zu einem tieferen Baumknoten, der möglicherweise nicht vorhanden ist oder noch nicht verknüpft wurde. Das ist etwas, das Sie immer eng in einer speziellen Klasse zusammenfassen sollten, damit Lesbarkeit oder Prägnanz hier kein so großes Problem darstellen.

• Dynamische Besetzungen. Das Umwandeln eines Basisklassenzeigers in eine bestimmte abgeleitete Klasse (etwas, das Sie erneut vermeiden sollten, das Sie jedoch manchmal für erforderlich halten) ist immer erfolgreich, führt jedoch zu einem Nullzeiger, wenn die abgeleitete Klasse nicht übereinstimmt. Eine Möglichkeit, dies zu überprüfen, ist

  Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
  if(derived_ptr != nullptr) { ... }

  (oder vorzugsweise auto derived_ptr = ...). Dies ist schlecht, da der (möglicherweise ungültige, dh null) abgeleitete Zeiger außerhalb des ifBereichs des Sicherheitsschutzblocks bleibt . Dies ist nicht erforderlich, da Sie in C ++ boolesche konvertierbare Variablen in eine ifBedingung einführen können :

  if(auto derived_ptr = dynamic_cast<Derived*>(base_ptr)) { ... }

  Das ist nicht nur kürzer und bereichssicher, sondern auch viel klarer in seiner Absicht: Wenn Sie in einer separaten if-Bedingung nach null suchen, fragt sich der Leser: "OK, derived_ptrdarf hier also nicht null sein ... nun, warum sollte es ist null? " Während die einzeilige Version sehr deutlich sagt : „Wenn Sie sicher werfen können base_ptrzu Derived*, dann verwenden Sie es für ...“.

  Das Gleiche funktioniert genauso gut für alle anderen Operationen mit möglichen Fehlern, die einen Zeiger zurückgeben. IMO sollten Sie dies jedoch generell vermeiden: Es ist besser, so etwas wie boost::optionalden "Container" für Ergebnisse möglicherweise fehlgeschlagener Operationen zu verwenden, als Zeiger.

Wenn also der Hauptanwendungsfall für Nullzeiger immer in einer Variation des impliziten Cast-Stils geschrieben werden sollte, würde ich sagen, dass es aus Konsistenzgründen gut ist , diesen Stil immer zu verwenden, dh ich würde mich für if(ptr)mehr einsetzen if(ptr!=nullptr).

Ich fürchte, ich muss mit einer Anzeige enden: Die if(auto bla = ...)Syntax ist eigentlich nur eine etwas umständliche Annäherung an die eigentliche Lösung solcher Probleme: Pattern Matching . Warum sollten Sie zuerst eine Aktion erzwingen (z. B. einen Zeiger werfen) und dann bedenken, dass möglicherweise ein Fehler vorliegt? Ich meine, es ist lächerlich, nicht wahr? Es ist wie, Sie haben etwas zu essen und möchten Suppe machen. Sie geben es Ihrem Assistenten mit der Aufgabe, den Saft zu extrahieren, falls es sich um ein weiches Gemüse handelt. Du siehst es dir nicht zuerst an. Wenn Sie eine Kartoffel haben, geben Sie sie immer noch Ihrem Assistenten, aber er schlägt sie Ihnen mit einem Fehlerbericht ins Gesicht. Ah, zwingende Programmierung!

Viel besser: Betrachten Sie sofort alle Fälle, auf die Sie stoßen könnten. Dann handeln Sie entsprechend. Haskell:

makeSoupOf :: Foodstuff -> Liquid
makeSoupOf p@(Potato{..}) = mash (boil p) <> water
makeSoupOf vegetable
 | isSoft vegetable  = squeeze vegetable <> salt
makeSoupOf stuff  = boil (throwIn (water<>salt) stuff)

Haskell hat auch spezielle Werkzeuge für den Fall, dass wirklich ernsthafte Fehler möglich sind (sowie für eine ganze Reihe anderer Dinge): Monaden. Aber das ist nicht der Ort, um diese zu erklären.

^{⟨/Inserat⟩}

ja natürlich! In der Tat ist das Schreiben von if (Zeiger) eine bequemere Schreibweise als if (Zeiger! = NULL), weil: 1. es leicht zu debuggen ist 2. leicht zu verstehen ist 3. wenn versehentlich der Wert von NULL definiert wird, dann stürzt auch der Code nicht ab

Ja. In der Tat sollten Sie. Wenn Sie sich fragen, ob ein Segmentierungsfehler auftritt , ist dies nicht der Fall.

Wie andere bereits gut geantwortet haben, sind beide austauschbar.

Es ist jedoch erwähnenswert, dass es einen Fall geben kann, in dem Sie die explizite Aussage verwenden möchten, z pointer != NULL.

Siehe auch https://stackoverflow.com/a/60891279/2463963

Ja, Sie können dies immer tun, da die 'IF'-Bedingung nur dann ausgewertet wird, wenn die darin enthaltene Bedingung erfüllt ist. C hat keinen booleschen Rückgabetyp und gibt daher einen Wert ungleich Null zurück, wenn die Bedingung wahr ist, während 0 zurückgegeben wird, wenn sich die Bedingung in 'IF' als falsch herausstellt. Der standardmäßig zurückgegebene Wert ungleich Null ist 1. Somit sind beide Arten des Schreibens des Codes korrekt, während ich immer den zweiten vorziehen werde.

Ich denke als Faustregel, ob Ihr if-Ausdruck als neu geschrieben werden kann

const bool local_predicate = *if-expression*;
if (local_predicate) ...

so dass es KEINE WARNUNGEN verursacht, sollte DAS der bevorzugte Stil für den if-Ausdruck sein . (Ich weiß, dass ich Warnungen bekomme, wenn ich einem C ++ ein altes C BOOL( #define BOOL int) zuweise bool, geschweige denn Zeiger.)

"Ist es sicher..?" ist eine Frage zum Sprachstandard und zum generierten Code.

"Ist das eine gute Praxis?" ist eine Frage, wie gut die Aussage von einem beliebigen menschlichen Leser der Aussage verstanden wird. Wenn Sie diese Frage stellen, deutet dies darauf hin, dass die "sichere" Version für zukünftige Leser und Autoren weniger klar ist.