Vor delete pointer auf NULL prüfen?



  • Hallo forum,

    ist es sinnvoll und/oder notwendig, vor einem delete (idR im Destruktor) den Pointer auf NULL zu prüfen?
    Was passiert wenn ein delete auf einen NULL-pointer aufgerufen wird? Was sagt der Standard dazu? Was machen die euch bekannten Compiler?

    Ist Folgender Schnippsel sinnvoll oder nur übertriebene Paranoia und ein einfaches delete mit anschließendem "NULLen" würde es auch tun?

    if(pointer != NULL){
      delete pointer;
      pointer = NULL;
    }
    

    danke



  • wurfholz schrieb:

    ist es sinnvoll und/oder notwendig, vor einem delete (idR im Destruktor) den Pointer auf NULL zu prüfen?

    nein

    wurfholz schrieb:

    Was passiert wenn ein delete auf einen NULL-pointer aufgerufen wird?

    nix

    wurfholz schrieb:

    Was sagt der Standard dazu?

    dass nix passoeren darf.

    wurfholz schrieb:

    Was machen die euch bekannten Compiler?

    hier halten sich mal ausnahmsweise alle an den standard.

    wurfholz schrieb:

    Ist Folgender Schnippsel sinnvoll

    eher nicht.

    wurfholz schrieb:

    oder nur übertriebene Paranoia

    ja, paranoid. aber nicht übertrieben poaranoid.

    wurfholz schrieb:

    und ein einfaches delete mit anschließendem "NULLen" würde es auch tun?

    auch paranoid. aber nicht übertrieben poaranoid.
    und warum NULL statt 0?
    warum denn NULLen? gerade im Destruktor ist das vollunsinn. fast überakk sonst auch. mach das nullen nur, wenn du weißt, daß es auch was bringt. mach nux aus prinzip weil es jemand anderes so verlangt hat. wird erstmal alle dogmen über bord und mach das, was du einsehen kannst.



  • wurfholz schrieb:

    Was passiert wenn ein delete auf einen NULL-pointer aufgerufen wird?

    Gar nichts.

    wurfholz schrieb:

    Ist Folgender Schnippsel sinnvoll oder nur übertriebene Paranoia und ein einfaches delete mit anschließendem "NULLen" würde es auch tun?

    Fürs Debuggen hin und wieder hilfreich; es schadet sicherlich nicht.

    Nur mußt du es in der richtigen Reihenfolge aufrufen 🤡



  • wurfholz schrieb:

    Hallo forum,

    ist es sinnvoll und/oder notwendig, vor einem delete (idR im Destruktor) den Pointer auf NULL zu prüfen?
    Was passiert wenn ein delete auf einen NULL-pointer aufgerufen wird? Was sagt der Standard dazu? Was machen die euch bekannten Compiler?

    Ist Folgender Schnippsel sinnvoll oder nur übertriebene Paranoia und ein einfaches delete mit anschließendem "NULLen" würde es auch tun?

    if(pointer != NULL){
      delete pointer;
      pointer = NULL;
    }
    

    danke

    Wenn dein Prog abstürzt, bei "delete pointer", hast du es nicht mit NULL initialisiert, weil wie schon geschrieben, es darf nichts passieren.
    Das macht man am besten so:

    class Foobar
    {
    
    Foobar() : m_ptr(NULL)
    {}
    
    Foo* m_ptr;
    };
    

    Dann ein kleiner Vorschlag:

    #define myDELETE(PTR) \
        delete PTR; PTR = NULL;
    

    rya.



  • Scorcher24 schrieb:

    Dann ein kleiner Vorschlag:

    #define myDELETE(PTR) \
        delete PTR; PTR = NULL;
    

    rya.

    nö. das ist doch gar nicht nötig. zeiger einfach baumeln lassen. vertraut mir, da passiert nix.



  • Das hängt davon ab, ob man den Zeiger wieder benötigt und wissen muss, ob er ungültig ist. Im Destruktor macht ein Null-Setzen sicher keinen Sinn.

    Aber wenn man sich schon Schreibarbeit sparen will, sollte man wenigstens Templates nehmen.

    template <typename T>
    DeleteAndNull(T* Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    


  • Nexus schrieb:

    template <typename T>
    DeleteAndNull(T* Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    
    template <typename T>
    DeleteAndNull(T*& Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    


  • Argh, danke. 🙄
    (Kommt davon, wenn man das nie braucht...)

    Edit2: Dass ich so viele Flüchtigkeitsfehler mache, hätte ich jetzt auch nicht gedacht... Vielleicht nächstes Mal Post noch einmal genau anschauen. 😉



  • audacia schrieb:

    template <typename T>
    DeleteAndNull(T*& Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    
    template <typename T>
    void DeleteAndNull(T*& Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    


  • danke Jungs,

    so ein ähnliches macro wie

    #define myDELETE(PTR) \
        delete PTR; PTR = NULL;
    

    hatte ich vorher schon, jedoch mit der Überprüfung auf NULL. Das macht aber Probleme mit dem statischen Codeanalyzer (cppcheck), den ich gerade evaluiere. Daraufhin kam die frage auf, ob die Überprüfung überhaupt sein muss. Ein extra template halte ich jetzt für ein wenig übertrieben.

    schönes Wochenende



  • volkard schrieb:

    template <typename T>
    void DeleteAndNull(T*& Pointer)
    {
        delete Pointer;
        Pointer = 0;
    }
    

    Uah. 🤡



  • wurfholz schrieb:

    danke Jungs,

    so ein ähnliches macro wie

    #define myDELETE(PTR) \
        delete PTR; PTR = NULL;
    

    hatte ich vorher schon, jedoch mit der Überprüfung auf NULL. Das macht aber Probleme mit dem statischen Codeanalyzer (cppcheck), den ich gerade evaluiere. Daraufhin kam die frage auf, ob die Überprüfung überhaupt sein muss. Ein extra template halte ich jetzt für ein wenig übertrieben.

    Lieber das (typsichere) Template als ein Makro. Effektiv wirds keinen großen Unterschied machen, da das Template vermutlich eh geinlined wird. Aber die bekannten Anfälligkeiten von Makros fallen weg.



  • wenn wir schon beim unfug sind, warum nicht ein wenig gas geben?

    struct SafeDeleter
    {
      template <typename T>
      void operator,(T*& Pointer)
      {
        delete Pointer;
        Pointer = 0;
      }
    };
    #define delete SafeDeleter(),
    

    endlich weiß ich, wozu es gut istm den kommaoperator zu überladen. 👍



  • LOL, nicht übel! 🤡



  • Wirklich nett, volkard... 🙂

    Aber was machst du bei delete[] ? :p



  • pumuckl schrieb:

    wurfholz schrieb:

    danke Jungs,

    so ein ähnliches macro wie

    #define myDELETE(PTR) \
        delete PTR; PTR = NULL;
    

    hatte ich vorher schon, jedoch mit der Überprüfung auf NULL. Das macht aber Probleme mit dem statischen Codeanalyzer (cppcheck), den ich gerade evaluiere. Daraufhin kam die frage auf, ob die Überprüfung überhaupt sein muss. Ein extra template halte ich jetzt für ein wenig übertrieben.

    Lieber das (typsichere) Template als ein Makro. Effektiv wirds keinen großen Unterschied machen, da das Template vermutlich eh geinlined wird. Aber die bekannten Anfälligkeiten von Makros fallen weg.

    Bei

    if (condition)
      myDELETE(p);
    

    macht das einen gewaltigen Unterschied, ob es ein Makro oder ein Template ist.



  • tntnet schrieb:

    macht das einen gewaltigen Unterschied, ob es ein Makro oder ein Template ist.

    leider ja, wenn man seine nase zu tief in die gewohneheiten mancher c-programmierer gesteckt hat.

    while(p!=fh9)
      myDELETE(*++p);
    

Anmelden zum Antworten