Re: Is it a good practice to call the destructor explicitly and use placement new(this) in assignment operators?

From:

Paavo Helde <myfirstname@osa.pri.ee>

Newsgroups:

comp.lang.c++

Date:

Mon, 14 Dec 2009 12:17:17 -0600

Message-ID:

<Xns9CE1CE77B7E8Apaavo256@216.196.109.131>

Pete Becker <pete@versatilecoding.com> wrote in
news:avCdnWPGG-KB8bjWnZ2dnUVZ_oli4p2d@giganews.com:

Paavo Helde wrote:

Pete Becker <pete@versatilecoding.com> wrote in news:-
eudnfqVh_ZQ3bjWnZ2dnUVZ_t-onZ2d@giganews.com:

Paavo Helde wrote:

Pete Becker <pete@versatilecoding.com> wrote in
news:mt6dnQGnBLwuirjWnZ2dnUVZ_ohi4p2d@giganews.com:

Paavo Helde wrote:

Michael Tsang <miklcct@gmail.com> wrote in
news:hg2tuh$bmb$1@news.eternal-september.org:

Pete Becker wrote:

No. Think about what happens when someone derives from this
class

and

writes a normal assignment operator.

Sorry I forgot to make my assignment operator virtual. Now
consider the following code:

class Foo {
public:
        // default constructor
        Foo();
        // l-value copy constructor
        Foo(const Foo &);
        // destructor
        virtual ~Foo();
        // assignment operator
        virtual Foo &operator=(const Foo &x) {
                if(this != &x) {
                        this->~Foo();
                        new(this) Foo(x);

This slices any derived class object to Foo.

It doesn't even do that. Slicing is well defined:

Foo f = Bar(); // slices the Bar object; f is a valid Foo
object

That placement new constructs a Foo object where a Bar object used
to exist, resulting in undefined behavior.

I cannot quite see how this is UB by itself. Consider:

void* p = malloc(sizeof(Bar));
Bar* b = new (p) Bar();
b->~Bar();
Foo* f = new (p) Foo();

Here also a Foo object is constructed where Bar was. Is this UB
too?

That's not inside operator=.

I presume this means no UB in the last example.

Then, how the operator= is any different? Clearly, just being a
member function should not affect anything. For example, several
people (incl. James Kanze) advocate using "delete this;" from inside
a member function. This clearly invalidates the object, but as long
as it is not accessed any more, there should be no UB.

operator= isn't usually called on objects that are going to be thrown
away immediately.

In no way do I advocate actually using this, but here is an example of
using the object after assignment. UB or not UB?

#include <iostream>

class Foo {
public:
    Foo(int x): x_(x) {}
    void operator=(const Foo& b) {
        void* p = static_cast<void*>(this);
        this->~Foo();
        new (p) Foo(b.x_);
    }
    virtual ~Foo() {}
    virtual void f() {
        std::cout << "Foo(" << x_ << ")\n";
    }
protected:
    int x_;
};

class Bar: public Foo {
public:
    Bar(int x, int y): Foo(x), y_(y) {}
    virtual void f() {
        std::cout << "Bar(" << x_ << ", " << y_ << ")\n";
    }
private:
    int y_;
};

int main() {

    Foo* p = new Bar(42,43);

    std::cout << "Before assignment: ";
    p->f();

    *p = Foo(31);

    std::cout << "After assignment: ";
    p->f();

    delete p;
}