please explain why this is Undefined Behavior

[Victor Bazarov]

Examples are what they are, examples. It doesn't necessarily mean you
cannot use placement new with non-POD objects or for "copying".

Is this also guaranteed to work? SomeClass is a non-POD type here:


#include <iostream>
#include <new>

class SomeClass
{
public:
SomeClass() { std::cout<<"Constructor called!\n"; }
~SomeClass() { std::cout<<"Destructor called!\n"; }

void somefunc() const { std::cout<<"somefunc() called!\n"; }
};


int main()
{
using namespace std;

unsigned char *parray= new unsigned char[sizeof(SomeClass)];

SomeClass *pSomeClass= new(parray) SomeClass;

pSomeClass->somefunc();

pSomeClass->~SomeClass();

delete[] parray;
}

Of course it is! What could possibly make you think that it isn't?

V

 

[REH]

Examples are what they are, examples. It doesn't necessarily mean you
cannot use placement new with non-POD objects or for "copying".

Is this also guaranteed to work? SomeClass is a non-POD type here:


#include <iostream>
#include <new>

class SomeClass
{
public:
SomeClass() { std::cout<<"Constructor called!\n"; }
~SomeClass() { std::cout<<"Destructor called!\n"; }

void somefunc() const { std::cout<<"somefunc() called!\n"; }
};


int main()
{
using namespace std;

unsigned char *parray= new unsigned char[sizeof(SomeClass)];

SomeClass *pSomeClass= new(parray) SomeClass;

pSomeClass->somefunc();

pSomeClass->~SomeClass();

delete[] parray;
}

It's fine except you are calling the constructor twice.

REH

 

[REH]

int main()
{
using namespace std;

unsigned char *parray= new unsigned char[sizeof(SomeClass)];

SomeClass *pSomeClass= new(parray) SomeClass;

pSomeClass->somefunc();

pSomeClass->~SomeClass();

delete[] parray;
}

It's fine except you are calling the constructor twice.

REH

Sorry, my bad. I misread "somefunc" as "SomeClass."

 

[Victor Bazarov]

Sorry, my bad. I misread "somefunc" as "SomeClass."

Besides, there is no way to call a constructor, so it wouldn't compile
if it were written as pSomeClass->SomeClass();

V

 

[Ioannis Vranos]

Is this also guaranteed to work? SomeClass is a non-POD type here:


#include <iostream>
#include <new>

class SomeClass
{
public:
SomeClass() { std::cout<<"Constructor called!\n"; }
~SomeClass() { std::cout<<"Destructor called!\n"; }

void somefunc() const { std::cout<<"somefunc() called!\n"; }
};


int main()
{
using namespace std;

unsigned char *parray= new unsigned char[sizeof(SomeClass)];

SomeClass *pSomeClass= new(parray) SomeClass;

pSomeClass->somefunc();

pSomeClass->~SomeClass();

delete[] parray;
}

Of course it is! What could possibly make you think that it isn't?

I asked because the standard says that we can *only* read non-POD types as unsigned chars
(more accurately, the memcpy() back and forth retaining the original value is guaranteed
only for POD types).

 

[Victor Bazarov]

Is this also guaranteed to work? SomeClass is a non-POD type here:


#include <iostream>
#include <new>

class SomeClass
{
public:
SomeClass() { std::cout<<"Constructor called!\n"; }
~SomeClass() { std::cout<<"Destructor called!\n"; }

void somefunc() const { std::cout<<"somefunc() called!\n"; }
};


int main()
{
using namespace std;

unsigned char *parray= new unsigned char[sizeof(SomeClass)];

SomeClass *pSomeClass= new(parray) SomeClass;

pSomeClass->somefunc();

pSomeClass->~SomeClass();

delete[] parray;
}

Of course it is! What could possibly make you think that it isn't?

I asked because the standard says that we can *only* read non-POD types
as unsigned chars (more accurately, the memcpy() back and forth
retaining the original value is guaranteed only for POD types).

The difference about just reading the bytes into the memory of the object
and placement new is that placement new assures _construction_ whereas the
POD doesn't have any constructors to execute. You may of course construct
a POD object using placement new, but the standard allows you to do away
with it, but only for PODs.

V