Thread: Variable initialization and assignment question

Hello all,

I would like to ask for some little explanation.

Suppose I have a following code:

Code:

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

typedef struct {
        char* firstName;
        char* lastName;
        unsigned int age;
        char gender;
        double hourlySalary;
    }Worker;


Worker* initperson(char*, char*, unsigned int, char, double);

int main(void){

    Worker *emp; 
    emp = initperson("David", "Jhonson", 27, 'M', 1578.45);
       
    printf("%s %s age: %d, gender: %c, salary: %.2lf\n",
            emp->firstName, emp->lastName, emp->age, emp->gender, 
            emp->hourlySalary);
    
    return 0;    
}


Worker* initperson(char* first, char* last, unsigned int Age, char gend, double salary){

    Worker* person = malloc(sizeof(*person));

    if(person != NULL){
        person->firstName = first;
        person->lastName = last;
        person->age = Age;
        person->gender = gend;
        person->hourlySalary = salary;
    }
    
    return person;
    
}

My question is about this line:

Code:

Worker* person = malloc(sizeof(*person));

How this line should be read?

Just've seen some example at old stack-exchange thread and tried to reproduce it with my code.

I mean, normally I would write something like:

Code:

Worker* person;
person = malloc(sizeof(Worker)); 


// possibly adding casting prior malloc, 
// like this: (Worker*)malloc(sizeof(Worker));

But when this have written in a single line, I can't actually get of what actually happens.


It looks like:
Firstly the pointer of Worker type struct is created (still it is not initialized)
Secondly this un-inited pointer is used (or more exactly: a sizeof command evaluates how much memory has been taken by "*person", then this value is used by "malloc" function to create an empty struct in the memory + pass pointer to it.

Anyway, your help will be highly appreciated.

Thanks a lot in advance.

Yep, you did it again ))) My brain was challenged ^_^ (kind of compliment)

Still, would like to ensure I got your answer right.

First, as it turns out I need to work harder on my C terminology. Next time I'll try to be more precise.

Second:

What did you mean by saying:

Worker is a struct type, not a variable length array type, hence the operand of sizeof is not evaluated.

And then again:

... *person is simply not evaluated.

Does "evaluation" means: "To check if the value is True or False?"

Third:

Regard to this line:

Code:

Worker* person = malloc(sizeof *person);

If I tear-down this line into separate chunks, we'll get following picture:

*person ---> is an expression (as you've said) which consists of '*' indirection operator and leads to pointer dereferencing.
Another words, according to Deitel's book:

returns the value of the object to which its operand (i.e., a pointer) points

Then we have the sizeof operator, that according to your citation of "C11 Clause" makes the following:

The size is determined from the type of the operand.

So a sizeof doesn't "care" about actual value which pointer refers to, it cares about:"how much memory this datatype takes?" Furthermore (and this is the thing that drove me crazy):

The 'sizeof' and '*' and '=' have "right to left associativity".

So I've asked myself: "how malloc can allocate memory for something that has no size".

But, in our case Worker datatype has been defined, and since sizeof cares about size of datatype, everything worked out.
Is that right conclusion?

Finally, the equivalent code would be:

Code:

 Worker* person = malloc(sizeof (Worker));

BTW, what about casting prior malloc? Is this necessary?

I mean if the above line would look like this:

Code:

 Worker* person = (Worker *)malloc(sizeof(Worker));

Again thanks for your time.

Thanks a lot Laserlight, you're AWESOME! ^_^