789 views
2 votes
2 votes
What does the following exactly mean?

int *p=(int*)malloc(23);

Does it mean that the OS allocates a memory of 23 bytes to int(though it requires just 4 bytes)? I know that to make malloc platform independent, we use sizeof, but what if we use the above syntax?

Also, even after writing malloz as above, when I type printf("%d",sizeof(*p)), I get the answer as 4. Why? Should'nt it return 23 since that's what the memory I allocated?

2 Answers

Best answer
2 votes
2 votes
Doing "man malloc" gives all the required information. malloc just allocates the required amount of memory as mentioned to its argument. The typecast (int*) just does explicit typecasting - this does not change any size and type of p is "int *" as that is how it is defined and size of "int *" or any pointer is as defined on the system - 8 on 64 bit systems.

SYNOPSIS
       #include <stdlib.h>

       void *malloc(size_t size);
       void free(void *ptr);
       void *calloc(size_t nmemb, size_t size);
       void *realloc(void *ptr, size_t size);

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

       The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call  to  malloc(),  calloc(),  or  realloc().   Otherwise,  or  if
       free(ptr) has already been called before, undefined behavior occurs.  If ptr is NULL, no operation is performed.

       The calloc() function 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().

       The realloc() function changes the size of the memory block pointed to by ptr to size bytes.  The contents will be unchanged in the range from the start of the region up  to
       the minimum of the old and new sizes.  If the new size is larger than the old size, the added memory will not be initialized.  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.
selected by
0 votes
0 votes
thing is memory allocated will be of 23B but you will have access to only 4B (if system is 64-bit) because you yourself said to p that you point to an integer .so the p will restrict itself upto 4B only .
As far as i think there will be memory leak in this case , maybe of type definately lost.
If someone has valgrind tool in his system please check and report here :)

Related questions

0 votes
0 votes
0 answers
3
Ahsanul Hoque asked Mar 16, 2018
288 views
queue->array = (int*) malloc(queue->capacity *sizeof(int));What is queue->capacity * doing here?