Or it's the same in c/c++?
+11
A:
There's no new/delete expression in C.
The closest equivalent are the malloc and free functions, if you ignore the constructors/destructors and type safety.
#include <stdlib.h>
int* p = malloc(sizeof(*p)); // int* p = new int;
...
free(p); // delete p;
int* a = malloc(12*sizeof(*a)); // int* a = new int[12];
...
free(a); // delete[] a;
KennyTM
2010-05-15 09:07:22
*@KennyTM:* Does `sizeof(*p)` actually dereference `p`, or is it fully equivalent to writing `sizeof(int)`? It seems that in the former case, this expression would potentially cause a segmentation fault (because `p` is not yet assigned at this point). In the latter case, I would probably still prefer writing `sizeof(int)` because there's less potential for misunderstanding what this statement does.
stakx
2010-05-15 10:51:29
@stakx: The `sizeof` operator is evaluated at compile time. There's no dereferencing. `sizeof(*p)` is preferred to `sizeof(int)` because if you change the type of `p` to `double` the compiler cannot warn you of size mismatch.
KennyTM
2010-05-15 12:04:03
@stakx The `sizeof` operator is a mapping from **type** to `size_t`. The **value** of its operand is not interesting at all. For example, in `sizeof(1 + 2)`, there is absolutely no need to compute the result `3`. The `sizeof` operator simply sees an expression of type `int + int` and infers that the result is also an `int`. Then it maps `int` to 4 (or 2 or 8, depending on the platform). It's the same thing with `sizeof(*p)`. The type system knows that, on the type level, dereferencing an `int*` yields an `int`. `sizeof` is not interested in the value of `*p` at all, only the type matters.
FredOverflow
2010-05-15 13:59:40
@stakx For exactly the same reason, `sizeof(1/0)` does NOT crash horribly with an arithmetic exception, but instead yields `sizeof(int)`, because `1` is of type `int`, `0` is of type `int`, and the division of two `int`s also yields an `int` on the type level. The division is never executed, neither at compile time nor at runtime!
FredOverflow
2010-05-15 14:04:20
Thanks to both of you for replying. I thought I'd ask because I haven't seen this usage of `sizeof` before. Good thing to know, though!
stakx
2010-05-15 15:56:26
+3
A:
Not directly an exact replica but compatible equivalents are malloc and free.
<data-type>* variable = (<data-type> *) malloc(memory-size);
free(variable);
No constructors/destructors - C anyway doesn't have them :)
To get the memory-size, you can use sizeof operator.
If you want to work with multidimensional arrays, you will need to use it multiple times (like new):
int** ptr_to_ptr = (int **) malloc(12 * sizeof(int *)); //assuming an array with length 12.
ptr[0] = (int *) malloc(10 * sizeof(int)); //1st element is an array of 10 items
ptr[1] = (int *) malloc(5 * sizeof(int)); //2nd element an array of 5 elements etc
MasterGaurav
2010-05-15 09:13:38
In C you don't need to cast from void* to other pointers. Its justint* p = malloc( sizeof(int) * cElements);
Chris Becke
2010-05-15 09:19:19
Chris: Are you sure? I haven't worked with C for quite some time now, but IIRC, I had to do it because the return type of malloc is void *.
MasterGaurav
2010-05-15 09:51:49
In c `void*` automatically converts to other pointer types. Casting the return of malloc can cause errors if you haven't included `stdlib.h`, as the parameters will have been assumed to be `int`.
Scott Wales
2010-05-15 10:09:38
@MasterGaurav: Explicitly casting from `void*` to other pointer types is necessary in C++ but not in C.
jamesdlin
2010-05-15 16:43:41
+2
A:
Note that constructors might throw exceptions in C++. The equivalent of player* p = new player(); would be something like this in C.
struct player *p = malloc(sizeof *p);
if (!p) handle_out_of_memory();
int err = construct_player(p);
if (err)
{
free(p);
handle_constructor_error();
}
The equivalent of delete p is simpler, because destructors should never "throw".
destruct(p);
free(p);
FredOverflow
2010-05-15 09:41:34
+3
A:
Use of new and delete in C++ combines two responsibility - allocating/releasing dynamic memory, and initialising/releasing an object.
As all the other answers say, the most common way to allocate and release dynamic memory is calling malloc and free. You also can use OS-specific functions to get a large chunk of memory and allocate your objects in that, but that is rarer - only if you have fairly specific requirements that malloc does not satisfy.
In C, most APIs will provide a pair of functions which fulfil the other roles of new and delete.
For example, the file api uses a pair of open and close functions:
// C++
fstream* fp = new fstream("c:\\test.txt", "r");
delete fp;
// C
FILE *fp=fopen("c:\\test.txt", "r");
fclose(fp);
It may be that fopen uses malloc to allocate the storage for the FILE struct, or it may statically allocate a table for the maximum number of file pointers on process start. The point is, the API doesn't require the client to use malloc and free.
Other APIs provide functions which just perform the initialisation and releasing part of the contract - equivalent to the constructor and destructor, which allows the client code to use either automatic , static or dynamic storage. One example is the pthreads API:
pthread_t thread;
pthread_create( &thread, NULL, thread_function, (void*) param);
This allows the client more flexibility, but increases the coupling between the library and the client - the client needs to know the size of the pthread_t type, whereas if the library handles both allocation and initialisation the client does not need to know the size of the type, so the implementation can vary without changing the client at all. Neither introduces as much coupling between the client and the implementation as C++ does. (It's often better to think of C++ as a template metaprogramming language with vtables than an OO language)
Pete Kirkham
2010-05-15 10:47:27