i am new in c, and i can not understand following piece of code. If anyone can explain it, i am really happy. Thanks in advance.
if( ! ( st_cur = (struct ST_info *) malloc(sizeof( struct ST_info ) ) ) )
{
perror( "malloc failed" );
return( 1 );
}
Let's start by taking a look at the malloc manual:
The malloc() function allocates size bytes and returns a pointer to the allocated memory.
If we dig in a little bit more and read the "return value" section of the manual:
The malloc() and calloc() functions return a pointer to the allocated memory that is suitably aligned for any kind of variable. On error, these functions return NULL.
With that in mind, what your code does is:
As for all the parenthesis, they are here to ensure the code is executed in this order.
Let's break it down a bit.
if( ! ( st_cur = (struct ST_info *) malloc(sizeof( struct ST_info ) ) ) )
{
perror( "malloc failed" );
return( 1 );
}
Is equivalent to:
struct ST_info * st_cur = NULL;
//...
/* Assign heap memory of native byte size equal to that
* of struct ST_info and save a pointer to the allocated
* memory. */
st_cur = malloc( sizeof( struct ST_info ) );
/* If the malloc succeeded it will have returned a valid
* pointer to some part of the heap, otherwise it returns
* NULL so we check for NULL here. */
if (st_cur == NULL) {
/* Print a relevant error message to stderr. */
perror("malloc failed");
/* Return a non-zero value to indicate that something failed. */
return(1);
}
If you later wish to free the memory, which one should do for all dynamically allocated memory before finishing a program, you can use free(). here you do not need to first check for NULL as A) the if above should have caught it, and B) if passed NULL then free safely does nothing.
malloc can fail due to the system not being able to allocate the amount of memory requested. If the size passed to malloc is zero then the return value is implementation dependent but the returned pointer shall not be dereferenced.
Additionally, it has become good practice to not explicitly cast the value returned by malloc, thus
st_cur = (struct ST_info *) malloc(sizeof( struct ST_info ) )
becomes
st_cur = malloc(sizeof( struct ST_info ) )
In c, an assignment will always return the assigned value.
In your specific case, st_cur is assigned, and after being assigned it's checked if it returned a valid value.
It's equivalent to this.
st_cur = (struct ST_info*)malloc(sizeof(struct ST_info));
if (!st_cur) {
perror("malloc failed");
return 1;
}
If you wonder, why there are so many parentheses, they're required due to = having the lowest precedence of all operators in C.
This is an assignment:
st_cur = (struct ST_info *) malloc(sizeof(struct ST_info))
that allocates memory and returns the pointer to that chunk of memory. If the allocation fails, malloc returns NULL, which is equivalent to 0 (post on NULL and 0). (BTW cast of malloc is pointless, see this post)
Then the result of the assignement, stored in st_cur is tested, so we can se it like in the follwing:
if (! st_cur )
which is equivalent to:
if (st_cur == NULL)
And thus if the allcation fail the perror function is called and the code return with 1
I would rewrite it:
st_cur = malloc(sizeof(struct ST_info));
if (st_cur == NULL) {
perror( "malloc failed" );
return(1);
}
Inside if condition there can be any statement, that has value, which can be identified 0 or not-0, false or true .
st_cur = (struct ST_info *) malloc(sizeof( struct ST_info ) )
In this statement malloc is called and it's return value is assigned to st_cur. Value of all statement is value of st_cur.
!st_cur is true, when st_cur is NULL
So, equivalent code is
st_cur = (struct ST_info *) malloc(sizeof( struct ST_info ) )
if( ! st_cur )
{
perror( "malloc failed" );
return( 1 );
}
malloc(sizeof( struct ST_info ) --> Allocate memory of given size.st_cur = (struct ST_info *) malloc... --> store the pointer returned by malloc in st_cur. Note that the cast (struct ST_info *) is unnecessary and sometimes dangerous. See more information at this answer.if( ! st_cur .. --> After the malloc has completed, check the value of st_cur. If it is 0 (NULL), then report an error, and return.
Malloc function is used to dynamically allocate some memory as required. Syntax to use malloc function is as follows:
(void *) malloc(size_of_memory_block)
Where argument size_of_memory_block is the amount of memory requested in bytes which you can find using sizeof(data_type) function. And it returns a pointer (of type void *) to the block of memory allocated.
In your case:
st_cur = (struct ST_info *) malloc( sizeof (struct ST_info) )
It allocates a memory block of size of your structure (struct ST_info) and returns a pointer to it which you are assigning to st_cur. Sometimes Malloc may fail (primarily due to system being out of memory) to allocate the memory size requested. Then it returns NULL which you are handling in your code with if condition.
Malloc functions return type is always void * which you can cast to the type as required. In your code, you are casting it to type struct ST_info *.
In plain words, it is saying
Hey malloc, give me enough memory for the size of the ST_info struct (Let's say ST_info struct has N bytes).
If there isn't enough memory left for N bytes, malloc() will return NULL. But if there is enough, malloc() will return you a void pointer (void *) to the chunk of memory.
Then you are casting that void pointer to a struct ST_Info pointer (struct ST_info *) and storing it in the variable st_cur.
Then the ! is checking whether or not st_cur is NULL. If st_cur is NULL (meaning malloc() failed to give you memory), the if statement would be true and you would see perror() and return(1)
If st_cur is not NULL, it means malloc() successfully allocated memory and the whole if statement is bypassed
