Re: Placement new myself
On May 7, 7:41 pm, nroberts <roberts.n...@gmail.com> wrote:
Someone asked a question with some really deranged code and I'm unable
to find something in the standard that would indicate whether this
would be defined or not:
struct foo; // let's talk the generic case here. If there are
specifics please explain
foo f = foo();
new (&f) foo(f);
As I understand it, this will try to recreate f on top of itself with
itself.
My instinct says that this is likely undefined and in some cases is
going to do absolutely absurd stuff...
The pedantic literal answer is that it's defined behavior. However,
very closely related code can have problems.
This is related to one of my personal pet peeves about both the C and C
++ standards. The responses I get are all over the map. There's no
real consensus.
At the end of the day, I think everyone agrees that you ought to be
able to write in portable C or C++ code a pooling memory allocator.
That is, some code which allocates a big chunk of memory through
magic, such as operator new, malloc, mmap, etc. From that big pool, it
can then parcel out pieces of it, and pieces can be returned and made
available for future allocations from the pool. Again, I think we can
all agree that this should be well defined by the relevant standards.
However, there's a lot of pain to make this work. In short, to be able
to write a well defined type-agnostic pooling memory allocator in
userspace (barring new syntax), the following code must be well
defined:
#include <new>
class Foo { public: Foo() {} private: int x; };
class Bar { public: Bar () {} private: float x; };
int main()
{
void * v;
Foo * f;
Bar * b;
v = operator new(sizeof *f + sizeof *b);
f = new (v) Foo();
f->~Foo();
v = f;
b = new (v) Bar();
b->~Bar();
v = b;
f = new (v) Foo();
f->~Foo();
v = f;
operator delete(v);
}
The last time I checked the C++ standard, there's some confusion as to
whether the above program is well defined. It gets even worse with the
C and its effective type rules, where's it's common practice to do
things like:
#include <stdlib.h>
typedef struct Foo { int x; float y; } Foo;
int main(void)
{
Foo * f;
f = malloc(sizeof *f);
f->x = 1;
return f->x;
}
Here, there isn't even an explicit call to a "constructor" to help the
compiler figure out that an object's lifetime is starting. I don't
know what to make the rules, and as I said earlier, I think there's no
consensus either.
Here's a thread from google groups archive from comp.std.c++ from long
ago, where I discussed these issues, without any conclusion:
"Defect Report #1116: Comment about changes"
First post on: Sep 15 2010, 4:26 pm
http://groups.google.com/group/comp.std.c++/browse_thread/thread/69c81befe0cea264#
My suggestion is don't do anything weird. If you don't do anything
weird, then the compiler shouldn't break you. This is one of the dark
corners of C and C++ that is honestly underspecified and bug ridden.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]