Passing address of stack memory to placement new operator

[mangesh]

This code is from c++ faq in section 11 :

void someCode()
{
char memory[sizeof(Fred)];
void* p = memory;
Fred* f = new(p) Fred();
f->~Fred(); // Explicitly call the destructor for the placed
object
}

Here we r passing address of stack memory to new .
New is used to allocate memory on heap . Then how can we pass address
of
stack memory to new operator . It is confusing .

Regards ,
Mangesh .

[Alf P. Steinbach]

* mangesh:

This code is from c++ faq in section 11 :

void someCode()
{
char memory[sizeof(Fred)];
void* p = memory;
Fred* f = new(p) Fred();
Should be

Fred* f = ::new(p) Fred();

f->~Fred(); // Explicitly call the destructor for the placed
object
}

Here we r passing address of stack memory to new .
New is used to allocate memory on heap . Then how can we pass address
of
stack memory to new operator . It is confusing .

The basic placement new operator (there are an infinity of them, but the
basic one from <new>) constructs an object in a specified region of memory.

You shouldn't use it because it's a low-level mechanism to subvert the
ordinary language rules and as such is fraught with dangers, even more
than with casts, e.g., as just one example, here that 'memory' may not
be properly aligned for an object of type 'Fred', and in particular:

* A novice should /never/ use the basic placement new.

Most uses of (the basic) placement new are better expressed using
standard library classes such as std::vector, which do the dangerous
stuff for you, in a safe way, so that you don't even see it.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Luke Meyers]

mangesh wrote:

void someCode()
{
char memory[sizeof(Fred)];
void* p = memory;
Fred* f = new(p) Fred();
f->~Fred(); // Explicitly call the destructor for the placed
object
}

Here we r passing address of stack memory to new .
I find it baffling that you can take the time to place weird spaces
around your punctuation, but the three letters in the word "are" are
too much effort in the name of readability when you're asking others to
help you.

Anyway, yes, you're doing a placement-new on a stack-allocated array.
New is used to allocate memory on heap .
Not quite -- it allocates memory on the free store, which may or may
not be implemented in terms of the heap. It may also be overridden by
a custom allocator, which incidentally would likely make use of
placement new.
Then how can we pass address
of
stack memory to new operator . It is confusing .

Because a placement new doesn't allocate memory, it uses memory that
you've allocated for it. That's the entire point. It skips the
allocation step and goes straight to construction. It doesn't care
what part of memory the pointer points to, as long as it can be written
to.

Imagine, for example, implementing a custom allocator for small objects
based on a fixed-size arena allocated as a single chunk. That chunk
might be member data of an allocator class, and could therefore be
stack-allocated. Of course, if the allocator class was instantiated
dynamically, then its member data would live on the free store. Since
either could be the case, it would pose a real problem if the compiler
couldn't handle doing a placement new into stack-allocated memory.

Luke

[mangesh]

Hi ,
thanks for reply .
Now in given case is statement " f->~Fred() ; " really needed .
Since memory is on stack it will be automaticaly deleted on exiting
function .

Regards
Mangesh .

Luke Meyers wrote:

mangesh wrote:

void someCode()
{
char memory[sizeof(Fred)];
void* p = memory;
Fred* f = new(p) Fred();
f->~Fred(); // Explicitly call the destructor for the placed
object
}

Here we r passing address of stack memory to new .

I find it baffling that you can take the time to place weird spaces
around your punctuation, but the three letters in the word "are" are
too much effort in the name of readability when you're asking others to
help you.

Anyway, yes, you're doing a placement-new on a stack-allocated array.

New is used to allocate memory on heap .

Not quite -- it allocates memory on the free store, which may or may
not be implemented in terms of the heap. It may also be overridden by
a custom allocator, which incidentally would likely make use of
placement new.

Then how can we pass address
of
stack memory to new operator . It is confusing .

Because a placement new doesn't allocate memory, it uses memory that
you've allocated for it. That's the entire point. It skips the
allocation step and goes straight to construction. It doesn't care
what part of memory the pointer points to, as long as it can be written
to.

Imagine, for example, implementing a custom allocator for small objects
based on a fixed-size arena allocated as a single chunk. That chunk
might be member data of an allocator class, and could therefore be
stack-allocated. Of course, if the allocator class was instantiated
dynamically, then its member data would live on the free store. Since
either could be the case, it would pose a real problem if the compiler
couldn't handle doing a placement new into stack-allocated memory.

Luke

[Ian Collins]

mangesh wrote:

Hi ,
thanks for reply .
Now in given case is statement " f->~Fred() ; " really needed .
Since memory is on stack it will be automaticaly deleted on exiting
function .

Please don't top post.

The memory won't be deleted, it will no longer be usable so any object
created on the stack with placement new will be left in limbo.

That's one reason doing so is a daft idea.

--
Ian Collins.

[Richard Herring]

In message <11************ **********@i40g 2000cwc.googleg roups.com>,
mangesh <ma************ @walla.com> writes

Please don't top-post. I've moved your reply to where it should be.

Luke Meyers wrote:

mangesh wrote:

> void someCode()
> {
> char memory[sizeof(Fred)];
> void* p = memory;
> Fred* f = new(p) Fred();
> f->~Fred(); // Explicitly call the destructor for the placed
> object
> }
>

[big snip]
Hi ,
thanks for reply .
Now in given case is statement " f->~Fred() ; " really needed .
Yes.
Since memory is on stack it will be automaticaly deleted on exiting
function .

No. The memory will be deallocated, but the object's destructor is not
called unless you do so explicitly.

Allocating memory, constructing an object, destroying the object and
freeing the memory are four separate steps.

--
Richard Herring

[Frederick Gotham]

Alf P. Steinbach posted:

Fred* f = new(p) Fred();

Should be

Fred* f = ::new(p) Fred();

Could you please explain that?
--

Frederick Gotham

[Frederick Gotham]

mangesh posted:

char memory[sizeof(Fred)];

This array isn't necessarily suitably aligned. You need to make sure it's
suitably aligned by either:

(1) Dynamically allocating it
(2) Using union trickery
(3) Using boost's "align_for" (or whatever it's called)
--

Frederick Gotham

[Alf P. Steinbach]

* Frederick Gotham:

Alf P. Steinbach posted:

Fred* f = new(p) Fred();

Should be

Fred* f = ::new(p) Fred();

Could you please explain that?

Unqualified placement new might invoke a custom Fred allocation function
instead of the basic placement new.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Frederick Gotham]

Alf P. Steinbach posted:

* Frederick Gotham:

Alf P. Steinbach posted:

Fred* f = new(p) Fred();
Should be

Fred* f = ::new(p) Fred();
Could you please explain that?

Unqualified placement new might invoke a custom Fred allocation

function instead of the basic placement new.

When you want to use "placement new", would it be wise to always use:
::new(p) Type();
(I realise it won't make a difference with intrinsic types, but it's
consistent nonetheless for dealing with class types).

--

Frederick Gotham