Why do I need to delete resources when using copy-assign operator?

Question

Code like this from one of my books for example:

class HasPtr {
public:
    HasPtr(const HasPtr& h): ps(new std::string(*h.ps)), i(h.i) { }
    HasPtr(const std::string &s = std::string()): ps(new std::string(s)), i(0) { }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr() { delete ps; }
private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps); // copy the underlying string
    delete ps; // free the old memory
    ps = newp; // copy data from rhs into this object
    i = rhs.i;
    return *this; // return this object
}

Seems like the inside of the operator= could just be:

*ps = *rhs.ps
i = rhs.i
return *this;

With no need to delete the pointer first, seems redundant to do so. It did mention it is written in a way to leave the object in a suitable state should an exception occur but didn't divulge past that, but I don't see what exception could occur that even my alternative wouldn't handle. Why is there a need to delete the object first before assigning?

You need to observe the [rule of three](http://stackoverflow.com/questions/4172722/what-is-the-rule-of-three) (which is trivially observed by following the [rule of zero](http://stackoverflow.com/q/22806523/315052)). Also use [copy-and-swap](http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom) if you implement your own assignment operator. — jxh, Aug 27 '15 at 23:46
@LightnessRacesinOrbit C++ Primer 5th Edition, Chapter 13.2.1 — AntiElephant, Aug 28 '15 at 00:04
If you jump to page 644, they provide a fixed version of their assignment operator. — jxh, Aug 28 '15 at 00:10

score 5 · Answer 1 · answered Aug 28 '15 at 00:01

5

In this case, yes, that would be fine.

You're not leaking the dynamically-allocated string: you're re-using it.

answered Aug 28 '15 at 00:01

Lightness Races in Orbit

378,754
76
643
1,055

score 4 · Accepted Answer · answered Aug 28 '15 at 00:19

This looks fine to me.

And you're right, std::string assignment already offers a strong exception guarantee so you will still leave the object in its original state should an exception occur copying the string.

Of course there is no reason to allocate a std::string with new like that. You could just write this instead:

class HasNoPtr {
public:
    HasNoPtr(const std::string& s): ps(s), i(0) { }
private:
    std::string ps;
    int i;
};

Why do I need to delete resources when using copy-assign operator?

2 Answers2