Call static function on deleted object

Question

I'd start learning C++ and I don't understand this is memory leak or some kind of voodoo magic?!

I have some "singleton" class (just for a demo):

#include <iostream>
using namespace std;

class S {
    private: S() {
        cout << "S::S" << endl;
    }

    public: static S* instance() {
        static S* i;
        if(i == NULL) {
            cout << "Create S" << endl;
            i = new S;
        }
        return i;
    }

    public: virtual ~S() {
        cout << "S::~S" << endl;
    }

    public: void a() {
        cout << "S::a" << endl;
    }
};

int main() {
    // call some method
    S::instance()->a();
    // delete pointer to instance (no reason, because I'm curious)
    delete S::instance();
    // call method again
    S::instance()->a();

    return 0;
}

Output of these is:

Create S
S::S
S::a
S::~S
S::a

So my question is: Why after destructor call I still have working copy of class S in static variable?

Upd: Thanks for answers. I realize my mistakes. Please, forgive me for disturbing.

Answer 1

The second call to instance is now risky:

S::instance()->a();

It will call:

public: static S* instance() {
    static S* i;
    if(i == NULL) {
            cout << "Create S" << endl;
        i = new S;
    }
    return i;
}

But i is not NULL (although to object is deleted, the pointer to it is invalid), so it returns an pointer to some memory where once was S. And then you have undefined behaviour, the old object maybe there, it may not, or something far worse can happen.

Conclusion to make it work, make sure when you delete the object always set the pointer to NULL. For example check this answer: How to delete Singleton pointer?

Answer 2

You don't have a "working instance," you have Undefined Behaviour (you're accessing an object after it's been destroyed). It just so happens that because a() does not access the data members of the object in any way, it appears to work normally. But you're technically dereferencing a dangling pointer and anything could happen, including segfaults.

While your case is slightly different (you have an access-after-delete, not a dangling pointer to stack), you might want to read this excellent answer on stale pointers.

---

Side note on formatting: while your code layout is certainly legal, it reads quite foreign to a C++ developer. Here's what more natural formatting could look like:

class S {
    S() {
        cout << "S::S" << endl;
    }

public:
    static S* instance() {
        static S* i;
        if(i == NULL) {
            cout << "Create S" << endl;
            i = new S;
        }
        return i;
    }

    virtual ~S() {
        cout << "S::~S" << endl;
    }

    void a() {
        cout << "S::a" << endl;
    }
};

Answer 3

Because using a destroyed object results in undefined behavior. Anything can happen, including it working...until it decides not to.

That's the correct answer by the language. The reason this usually results in this kind of undefined behavior is because member functions are just regular functions once turned into machine code. If you never actually use a member of your class it's unlikely to explode.

But again, undefined behavior. Don't do this expecting it's going to work.

Answer 4

As in other answers, you have undefined behaviour in your code, in simple code like your you might see that your code works actually properly anyway. In most codebases, code is much more complicated, and such bug results in :

bash: line 7: 7324 Segmentation fault (core dumped) ./a.out

But still this might occur in other parts of code, not related to the one where bug is present, and also not immediately.

I have modified your code a bit, to allow for such output. As you see there is more allocations in this code, and this is what most probably is causing this segfault, by that I mean that vector is probably reusing part of S::ss freed memory causing it to crash dump once used in S::a.

http://coliru.stacked-crooked.com/a/c1be7a83275ae847

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class S {
    std::string ss;
    private: S() {
        ss = "ub ub ub ub ub ub ub ub ";
        cout << "S::S" << endl;
    }

    public: static S* instance() {
        static S* i;
        if(i == NULL) {
            cout << "Create S" << endl;
            i = new S;
        }
        return i;
    }

    public: virtual ~S() {
        cout << "S::~S" << endl;
    }

    public: void a() {
        cout << "S::a" << ss << endl;
    }
};

int main() {
        S::instance()->a();
        // delete pointer to instance (no reason, because I'm curious)
        delete S::instance();    
    for ( int n = 0; n < 100; ++n ){
        std::vector<char> avec(n);
        // call some method
        S::instance()->a();
    }

    return 0;
}