Object not deleted before new is assigned

Question

I'm kind of confused, because I was sure this should work different. Take a look at this code example:

#include <iostream>
#include <string>

using namespace std;

class base
{
    public:
    virtual ~base() = default;
};

class derived : public base
{
    private:
    int a = 0;
    int *b = nullptr;
    std::string lol;

    public:
    derived(std::string s) : b(new int(6)), lol{s} { cout << "ctor " << lol << endl; }
    derived(derived const& d) : lol{d.lol + " copy"} {cout << "copy " << lol << endl; }

    virtual ~derived() { cout << "dtor " << lol << endl; delete b; }

    virtual void superFunction() { cout << "OMG " << lol << endl; }
};

int main()
{
    derived a("a");
    derived b("b");
    a = b;
}

And the program output with all optimizations off is:

ctor a
ctor b
dtor b
dtor b

I was sure that in this case compiler should generate code that deletes object a and uses copy constructor to create new object. Instead it uses operator= that it implicitly declares.

Can someone explain why? Or point me to C++ standard.

Thanks.

If "the compiler" deletes `a` first, what would it copy into `b`? Anyway, there is no copy here, just assignment. — juanchopanza, Aug 18 '16 at 10:15
related: https://stackoverflow.com/questions/4172722/what-is-the-rule-of-three — kmdreko, Sep 25 '17 at 00:20

score 5 · Accepted Answer · edited Sep 25 '17 at 00:02

When you write a = b;, compiler calls assignment operator, which will be automatically generated if not present in the code and not marked as deleted. Copy constructor is used only if you try to initialize a new object from another object like this:

derived a("a");
derived b = a;

Also, your code crashes before main returns as it tries to delete b, which points to the same memory from a and from b after a = b; default-assignment.

If you want to delete a with derived destructor after a = b; execution, all you need is copy-and-swap idiom. What is the copy and swap idiom? has a great answer on how to do that in legacy and modern C++. Proper implementation of rule-of-four from that answer will perfectly fit the DRY principle and help you to avoid memory issues. Note the fabulous trick with passing parameter to operator= by value, which makes compiler select the appropriate constructor (copy or move) and allows you to write only four methods instead of all five of them.

Object not deleted before new is assigned

1 Answers1