Basic dynamic memory allocation problem

[Crosshash]

I'm trying to handle the basics of memory allocation but I've already got a problem.

Here's my code, all I want it to do is return the correct results.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{

	int *pointer = NULL;
	
	printf("The size of the pointer is: %d \n", sizeof(pointer));
	
	pointer = (int *) realloc(pointer, 100*sizeof(int));
	
	printf("The size of the pointer is now: %d \n", sizeof(pointer));
	
	getchar();
	
}

The output is that the pointer is pointing to 4 bytes of memory both times. I don't understand why this is and it's making my coursework impossible right now.

Can someone give me a tip please?

Thanks

[Subsonics]

A few things, sizeof(pointer) give you the size of the variable only. On your platform, 4 bytes.

You shouldn't call realloc without first calling calloc or malloc, on some platforms it is possible to call malloc with size 0, you can then realoc that 0 space. Not that useful, and a bit dangerous, but it's the closest to what you are now doing. Initializing a pointer to NULL, just means that it points nowhere.

[CommonTater]

Look at your code... what are you asking printf() to display?

Pointer is a pointer... in 32 bit compilers pointers are 4 bytes. Thus sizeof(Pointer) will return 4.

If you want to know the size of your reallocated memory you do that separately...

int bs = 0;      // block size
int *ptr = NULL;   // memory pointer

// calc size
bs = 100 * sizeof(int);

// call realloc
ptr = realloc(ptr,bs);

If (!ptr)  // 0 = error
  { printf("Allocation failed");
     bs = 0; }
else
  printf("%d bytes allocated at %X",bs,ptr);

It is up to you to keep track of how much memory you allocate. C does not do it for you.

[nonoob]

Size of pointer does not change. That's correct. It's an address which points to a chunk of memory. That memory can hold 100 integers... or whatever amount.

[Bayint Naung]

You shouldn't call realloc without first calling calloc or malloc, on some platforms it is possible to call malloc with size 0, you can then realoc that 0 space. Not that useful, and a bit dangerous, but it's the closest to what you are now doing. Initializing a pointer to NULL, just means that it points nowhere.

from man 3 malloc

calloc() allocates memory for an array of nmemb elements of size bytes
each and returns a pointer to the allocated memory. The memory is set
to zero. If nmemb or size is 0, then calloc() returns either NULL, or
a unique pointer value that can later be successfully passed to free().

malloc() allocates size bytes and returns a pointer to the allocated
memory. The memory is not cleared. If size is 0, then malloc()
returns either NULL, or a unique pointer value that can later be suc‐
cessfully passed to free().

realloc() changes the size of the memory block pointed to by ptr to
size bytes. The contents will be unchanged to the minimum of the old
and new sizes; newly allocated memory will be uninitialized. If ptr is
NULL, then the call is equivalent to malloc(size), for all values of
size; if size is equal to zero, and ptr is not NULL, then the call is
equivalent to free(ptr). Unless ptr is NULL, it must have been
returned by an earlier call to malloc(), calloc() or realloc(). If the
area pointed to was moved, a free(ptr) is done.

It's defined by C standard.

[Subsonics]

So is gets(), google: "Zero-sized heap allocations vulnerability"

[Bayint Naung]

The point is it's defined by standard. not platform specific.
Edit: Even though it's a good idea not to rely on it :=|

[Subsonics]

Yes, it is. A call to malloc(0) can return either a NULL pointer or a valid pointer. Both are accepted as you can see in the man page section above. Which of the two it is, is platform specific.

[Bayint Naung]

I don't know why C standard committee does not just decide to return NULL!

[nonoob]

It's conflicting. A returned NULL normally indicates a failure. If you ask for malloc(0), it's allocating 0 bytes which should succeed always.

I don't see malloc(0) being the same as free() although the documentation treats is as such.
In my opinion, asking for 0 bytes, although useless, should still allocate whatever structures / pointers / linked lists required internally by the memory pool manager. Possibly some 32-byte header if I recall from some implementations. That's way different from freeing memory. So a malloc(0) should succeed and report as much by returning some non-NULL pointer. But as a programmer you should not store any data through that pointer.

[cas]

Where does malloc(0) even come into play with the original code? He's effectively doing realloc(NULL, 100 * sizeof(int)), which is perfectly valid. There's no need to change it.

[nonoob]

... because for realloc()... "If ptr is NULL, then the call is equivalent to malloc(size), ..."