You have to free() the allocated memory in exact reverse order of how it was allocated using malloc(). Note that You should free the memory only after you are done with your usage of the allocated pointers. memory allocation for 1D arrays: buffer = malloc(num_items*sizeof(double)); memory deallocation for 1D arrays: free(buffer); memory allocation for 2D … Read more
You want to use a pointer-to-pointer: void someFunction (int **data) { *data = malloc (sizeof (int)); } void useData (int *data) { printf (“%p”, data); } int main () { int *data = NULL; someFunction (&data); useData (data); return 0; } Why? Well, you want to change your pointer data in the main function. In … Read more
You need to do some work in embedded systems, you’ll frequently get NULL returned there 🙂 It’s much harder to run out of memory in modern massive-address-space-and-backing-store systems but still quite possible in applications where you process large amounts of data, such as GIS or in-memory databases, or in places where your buggy code results … Read more
To answer your numbered points. Yes. All the bytes. Malloc/free doesn’t know or care about the type of the object, just the size. It is strictly speaking undefined behaviour, but a common trick supported by many implementations. See below for other alternatives. The latest C standard, ISO/IEC 9899:1999 (informally C99), allows flexible array members. An … Read more
Since the question was asked, a new function was standardized by C11: void *aligned_alloc(size_t alignment, size_t size); and it is available in glibc (not on windows as far as I know). It takes its arguments in the same order as memalign, the reverse of Microsoft’s _aligned_malloc, and uses the same free function as usual for … Read more
This is actually a really hard, imponderable question. Pro (in favor of freeing everything before exit): no bugs or memory leaks later if code is rearranged no false positives from valgrind or memory leak checker no memory leaks if you’re running under a buggy OS, or no OS at all Con (just exit, don’t worry … Read more
Just give the exact size you need. The only reason that a power-of-two size might be “better” is to allow quicker allocation and/or to avoid memory fragmentation. However, any non-trivial malloc implementation that concerns itself with being efficient will internally round allocations up in this way if and when it is appropriate to do so. … Read more
Er…use new? That’s kind of the point. You can also call the constructor explicitly, but there’s little reason to do it that way Using new/delete normally: A* a = new A(); delete a; Calling the constructor/destructor explicitly (“placement new”): A* a = (A*)malloc(sizeof(A)); new (a) A(); a->~A(); free(a);
Each page that is allocated for the process (be it a virtual memory page that has the stack on it or the heap) is copied for the forked process to be able to access it. Actually, it is not copied right at the start, it is set to Copy-on-Write, meaning once one of the processes … Read more
OK, there’s a fair deal of confusion explaining exactly what order the necessary free() calls have to be in, so I’ll try to clarify what people are trying to get at and why. Starting with the basics, to free up memory which has been allocated using malloc(), you simply call free() with exactly the pointer … Read more