whats the advantageof malloc over new in c++.

[Muzammil]

whats the beauty of "malloc" over "new" why its helpful for
programmer.for its own memory area.??

[peter koch]

On 20 Aug., 02:07, tony_in_da...@y ahoo.co.uk wrote:

On Aug 20, 6:02 am, "Bo Persson" <[e-mail] te:

Chris Becke wrote:

"Muzammil" <muzammilPeer.. [e-mail] e in message
>news:b1******* *************** ************@56 g2000hsm.google groups.com....
>whats the beauty of "malloc" over "new" why its helpful for
>programmer.f or *its own memory area.??

memory allocated by malloc can be reallocated with realloc.

Which just sometimes might realloc in place, otherwise it has to copy
everything. And this doesn't work for anything with a constructor.

"just sometimes might" is trivialising the benefit a bit ;-). *Anyway,
only the additional elements need then be manually constructed with
placement new... and this doesn't necessarily need to be done using a
default constructor before the meaningful values are available which
can be an advantage... so at least this two-step process can work for
some things with constructors.

Perhaps a bigger issue is that moved existing elements aren't copy
constructed so references/pointers stored therein may end up invalid.

Tony

If you are depending on the realloc-trick, most probably you are
implementing an array. In that case, std::vector is the place to go.
std::vector can take of advantage of whatever low-level memory
management the platform has and do an "in-place realloc" if such a
beast exists.

/Peter

[Sumanth]

On Aug 20, 9:53 am, peter koch <peter.koch.lar [e-mail] ote:

On 20 Aug., 02:07, tony_in_da...@y ahoo.co.uk wrote:

On Aug 20, 6:02 am, "Bo Persson" <[e-mail] te:

Chris Becke wrote:
"Muzammil" <muzammilPeer.. [e-mail] e in message
news:b1******** *************** ***********@56g 2000hsm.googleg roups.com...
whats the beauty of "malloc" over "new" why its helpful for
programmer.for its own memory area.??

memory allocated by malloc can be reallocated with realloc.

Which just sometimes might realloc in place, otherwise it has to copy
everything. And this doesn't work for anything with a constructor.

"just sometimes might" is trivialising the benefit a bit ;-). Anyway,
only the additional elements need then be manually constructed with
placement new... and this doesn't necessarily need to be done using a
default constructor before the meaningful values are available which
can be an advantage... so at least this two-step process can work for
some things with constructors.

Perhaps a bigger issue is that moved existing elements aren't copy
constructed so references/pointers stored therein may end up invalid.

Tony

If you are depending on the realloc-trick, most probably you are
implementing an array. In that case, std::vector is the place to go.
std::vector can take of advantage of whatever low-level memory
management the platform has and do an "in-place realloc" if such a
beast exists.

/Peter

This should help.

http://www.parashift.com/c++-faq-lit....html#faq-16.4

Sumanth

[Juha Nieminen]

peter koch wrote:

The only reason to use malloc is for interfacing with C.

Well, I can imagine a custom allocator using malloc rather than new
because the former allocates uninitialized memory, which is exactly what
a custom allocator should do (it's up to the calling code to actually
initialize the allocated memory).

[Bo Persson]

to***********@y ahoo.co.uk wrote:

On Aug 20, 6:02 am, "Bo Persson" <[e-mail] te:

>Chris Becke wrote:

>>"Muzammil" <muzammilPeer.. [e-mail] e in message
news:b1****** *************** *************@5 6g2000hsm.googl egroups.com...
whats the beauty of "malloc" over "new" why its helpful for
programmer.f or its own memory area.??

>>memory allocated by malloc can be reallocated with realloc.

Which just sometimes might realloc in place, otherwise it has to
copy everything. And this doesn't work for anything with a
constructor.

"just sometimes might" is trivialising the benefit a bit ;-).

Yes.

The problem is that you don't know whether it works or not. If it is
important to realloc very fast, you have to make sure it works. If it
isn't important, it just isn't.

Anyway, only the additional elements need then be manually
constructed with placement new... and this doesn't necessarily need
to be done using a default constructor before the meaningful values
are available which can be an advantage... so at least this
two-step process can work for some things with constructors.

But realloc() takes a void* pointer to the memory block, so it doesn't
know what kind of objects it contains.

>
Perhaps a bigger issue is that moved existing elements aren't copy
constructed so references/pointers stored therein may end up
invalid.

Rather important, yes. :-)
Bo Persson

[peter koch]

On 20 Aug., 17:08, Juha Nieminen <nos...@thanks. invalidwrote:

peter koch wrote:

The only reason to use malloc is for interfacing with C.

* Well, I can imagine a custom allocator using malloc rather than new
because the former allocates uninitialized memory, which is exactly what
a custom allocator should do (it's up to the calling code to actually
initialize the allocated memory).

In this case operator new serves just as well.

/Peter

[tony_in_da_uk]

On Aug 21, 1:51*am, "Bo Persson" <[e-mail] te:

tony_in_da...@y ahoo.co.uk wrote:

Anyway, only the additional elements need then be manually
constructed with placement new... and this doesn't necessarily need
to be done using a default constructor before the meaningful values
are available which can be an advantage... so at least this
two-step process can work for some things with constructors.

But realloc() takes a void* pointer to the memory block, so it doesn't
know what kind of objects it contains.

Perhaps I didn't explain that well... sorry... off-the-top-of-my head
coding here:

if (X* p = (X*)realloc(old _p, sizeof(X) * new_capacity))
for (int n = old_size; n < new_capacity; ++n)
new(p[n]) X(fn(n)); // meaningful construction...

Cheers,
Tony

[Chris Becke]

A clear disadvantage. :-)

You have to check the result manually instead.

predictable program flow is a disadvantage? Not even google likes c++ exceptions.

[Ian Collins]

Chris Becke wrote:

>A clear disadvantage. :-)

You have to check the result manually instead.

predictable program flow is a disadvantage? Not even google likes c++ exceptions.

Their loss.

--
Ian Collins.

[Yannick Tremblay]

In article <bd************ *************** *******@x16g200 0prn.googlegrou ps.com>,
<to***********@ yahoo.co.ukwrot e:

>On Aug 21, 1:51*am, "Bo Persson" <[e-mail] te:

>tony_in_da...@ yahoo.co.uk wrote:

Anyway, only the additional elements need then be manually
constructed with placement new... and this doesn't necessarily need
to be done using a default constructor before the meaningful values
are available which can be an advantage... so at least this
two-step process can work for some things with constructors.

But realloc() takes a void* pointer to the memory block, so it doesn't
know what kind of objects it contains.

Perhaps I didn't explain that well... sorry... off-the-top-of-my head
coding here:

if (X* p = (X*)realloc(old _p, sizeof(X) * new_capacity))
for (int n = old_size; n < new_capacity; ++n)
new(p[n]) X(fn(n)); // meaningful construction...

Hmm, tell me what happens in the code above if realloc unfortunately
fail to be able to grow in place and need to malloc new memory at a
different place?

Guess if X is memcpy-able you'll survive but if not, you are dead.

What advantage does this has over (apart from being more bug prone):

std:vector<Xv;
// v.reserve(somen umber); //optional
// ...
for(size_t n = v.size(); v < nerw_capacity ; ++v)
v.append(X(f(n) ));
Yan

[peter koch]

On 21 Aug., 09:26, "Chris Becke" <chris.be...@gm ail.comwrote:

A clear disadvantage. *:-)

You have to check the result manually instead.

predictable program flow is a disadvantage? Not even google likes c++ exceptions.

I don't know about google, but using an exception is the preferred and
standard way to cope with an error that can't be handled locally. If
you believe that you can handle the exception locally, nothing
prevents you from using the non-throwing version of new.

/Peter