Verwendung von "assert" mit Zeigern in C++

Question

Wann müssen wir "assert" für Zeiger in C++ verwenden, und wenn sie verwendet werden, wie sind sie am häufigsten implementiert?

Answer 1

In C gibt es auch die Funktion assert. im Debug-Modus, wenn assert(x), x Bedingung ist falsch, es wird eine Warnung erscheinen... Aber denken Sie daran, es funktioniert nur im Debug-Modus... im Release-Modus werden alle Assert-Funktionen übersprungen

Answer 2

Assertions werden verwendet, um zu definieren, wie das Programm funktionieren soll. Die häufigste Verwendung von Assert()s im Umgang mit Zeigern besteht darin, dass sie entweder gültig sind (nicht NULL und auf gültigen Speicher zeigen) oder dass ihr interner Zustand gültig ist, wenn sie z. B. auf ein Objekt/eine Klasseninstanz zeigen.

Assertions sind nicht dazu da, um Code zu ersetzen oder als Fehlerbedingung zu fungieren, sondern um Regeln durchzusetzen, die Sie für das Funktionieren Ihres Codes aufstellen, z. B. welche Bedingungen zu bestimmten Zeitpunkten herrschen sollten.

Zum Beispiel,

    function int f(int x, int * pY)
    {
        // These are entrance conditions expected in the function. It would be
        // a BUG if this happened at all.
        Assert(x >= 0);
        Assert(pY != nullptr);

        Assert(*pY >= 0, "*pY should never be less than zero");

        // ...Do a bunch of computations with x and pY and return the result as z...
        int z = x * 2 / (x + 1) + pow(*pY, x);  // Maybe z should be always positive 
                                                // after these calculations:
        Assert(x >= 0, "X should always be positive after calculations);
        // Maybe *pY should always be non-zero after calculations
        Assert(*pY != 0, "y should never be zero after computation");
        Assert(z > 0):

        return z;
    }

Viele Benutzer von Asserts entscheiden sich dafür, Assertions auf die interne Zustandsvalidierung anzuwenden, sobald sie sich mit ihnen vertraut gemacht haben. Wir nennen diese Invarianten(), die Methoden einer Klasse sind, die viele Dinge über die Interna des Objekts behaupten, die immer wahr sein sollten.

Zum Beispiel:

    class A
    {
    public:
        A(wchar_t * wszName)
        {
             _cch = 0;
             _wszName = wszName;
        }
        // Invariant method to be called at times to verify that the
        // internal state is consistent.  This means here that the
        // internal variable tracking the length of the string is
        // matching the actual length of the string.
        void Invariant()
        {
            Assert(pwszName != nullptr);
            Assert(_cch == wcslen(pwszName));
        }

        void ProcessABunchOfThings()
        {
            ...
        }
    protected:
        int _cch;
        wchar_t * pwszName;
    }

    // Call to validate internal state of object is consistent/ok
    A a(L"Test Object");
    a.Invariant();
    a.ProcessABunchOfThings();
    a.Invariant();

Wichtig ist, dass man sich daran erinnert, dass damit sichergestellt wird, dass, wenn Fehler auftreten, die bedeuten, dass das Programm nicht so funktioniert, wie man es erwarten würde, die Auswirkungen des Fehlers so nah wie möglich an der Stelle im Code auftreten, um die Fehlersuche zu erleichtern. Ich habe Asserts ausgiebig in meinem eigenen Code und bei Microsoft verwendet und ich schwöre auf sie, da sie mir so viel Zeit bei der Fehlersuche erspart haben und ich sogar wusste, dass der Fehler vorhanden ist.