difference b/w using calloc and new

M

mthread

Hi,
I am learning C++ and I have been told that an object can be
created either by using calloc or new. If it is true, can some one
tell me what is the difference b/w using these two function calls.
 
J

James Kanze

I am learning C++ and I have been told that an object can be
created either by using calloc or new. If it is true, can some one
tell me what is the difference b/w using these two function calls.

You've been told wrong. You can't create an object with calloc,
only allocate memory. (In practice, even in C, I've never found
a use for calloc.)
 
A

Alf P. Steinbach

* James Kanze:
You've been told wrong. You can't create an object with calloc,
only allocate memory. (In practice, even in C, I've never found
a use for calloc.)

Depends what's meant by "object". In the usual language-independent
meaning of "object" you're right. However, the standard defines an
object as a region of memory, and goes to pains to specify "class type"
whenever it talks about objects of class type, so as not to confuse them
with objects of non-class type, and in that meaning malloc & friends
allocate objects (although I agree that's probably not what OP means).

Now, C++ "new" combines two operations: allocation and initialization,
where initialization might involve internally calling a constructor for
each class type object created. You get either both effects, or none.
I.e., if initialization fails, the allocated memory is deallocated
again, automatically.

And it has one more useful property, namely that the corresponding
destruction+deallocation operation, C++ "delete", is the operation used
by default by automatic cleanup such as with boost::shared_ptr.

Implementing all that yourself on top of e.g. malloc would be very much
work for no particular gain, since it's unlikely in the extreme that
you'd be able to achieve the same quality.

Hence the only reason for using malloc & the like in C++, is where you
need to interface to code that requires this, e.g. by calling free.


Cheers, & hth.,

- Alf
 
V

vairavans

Hi,
I am learning C++ and I have been told that an object can be
created either by using calloc or new. If it is true, can some one
tell me what is the difference b/w using these two function calls.

new is not a function or a library, it is just an operator...

calloc just allocates the memory, where as new allocates the memory
for the object and also calls the constructor to perform
initialization.
yes calloc does set the memory contents with 0, however new perform's
user defined initialization (if provided).
 
M

mthread

new is not a function or a library, it is just an operator...

calloc just allocates the memory, where as new allocates the memory
for the object and also calls the constructor to perform
initialization.
yes calloc does set the memory contents with 0, however new perform's
user defined initialization (if provided).


Hi,
thanx every one for the help.
 
J

James Kanze

* James Kanze:
Depends what's meant by "object". In the usual
language-independent meaning of "object" you're right.
However, the standard defines an object as a region of memory,
and goes to pains to specify "class type" whenever it talks
about objects of class type, so as not to confuse them with
objects of non-class type, and in that meaning malloc &
friends allocate objects (although I agree that's probably not
what OP means).

Yes, but even a POD is more than just raw memory, at least if it
has a readable value. Using calloc, you're guaranteed that any
subobjects of integral type have a value of 0, but that's about
it. You still have to initialize pointers and floating point
values before you can access them.
Now, C++ "new" combines two operations: allocation and
initialization, where initialization might involve internally
calling a constructor for each class type object created. You
get either both effects, or none. I.e., if initialization
fails, the allocated memory is deallocated again,
automatically.

Most importantly, initialization takes place. Conceptually (in
my mind, at least), there is a difference between raw memory,
and an object, even if that object is of type int. With
calloc/malloc (and the operator new function), you get raw
memory; with new, you get the object. If the constructor is a
no-op (a trivial constructor), of course, there is no real
difference physically, but I still find it cleaner to think of
it as two different things.
And it has one more useful property, namely that the
corresponding destruction+deallocation operation, C++
"delete", is the operation used by default by automatic
cleanup such as with boost::shared_ptr.

It's the only operation used by most automatic cleanup. (It's
what std::auto_ptr uses, for example.) Except
that which works at a much lower level (e.g. garbage
collection).

The important point, of course, is that if you use calloc, you
must use free (and not delete), and if you use new, you must use
delete. Unless you're using some lower level system which more
or less "pirates" them all.
Implementing all that yourself on top of e.g. malloc would be
very much work for no particular gain, since it's unlikely in
the extreme that you'd be able to achieve the same quality.

It's useful when you want to separate initialization and
allocation, e.g. when implementing something like vector.
Today, of course, unless you're implementing the standard
library, the probability of needing to do this is very, very
small, but back in the old days, when the "standard library" was
iostream, complex, and nothing else, it was standard practice
anytime you implemented your in house vector classes.

Even then, I would use the operator new function, rather than
malloc. I reserve malloc for the implementation of custom
operator new functions (e.g. for debugging---although now that
tools like valgrind are readily available for free, there's
practically no reason to write a debugging operator new anymore
either).
Hence the only reason for using malloc & the like in C++, is
where you need to interface to code that requires this, e.g.
by calling free.

In which case, you have no choice. When you have to, you have
to. Similarly, it's the easiest way (and the only portable way)
to get memory if you're implementing your own replacement global
operator new.
 
J

James Kanze

On Dec 11, 2:47 pm, mthread <[email protected]> wrote:

[...]
yes calloc does set the memory contents with 0, however new perform's
user defined initialization (if provided).

You have to be very careful how you say that. Calloc only sets
all of the bits to 0. It does *not* guarantee that the value
of the objects (even POD objects) corresponds to initialization
with 0. In particular, there is absolutely no guarantee that
pointers in memory returned by calloc are null, or that floating
point values are 0.0.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,483
Members
44,901
Latest member
Noble71S45

Latest Threads

Top