Dynamic Memory Allocate, how to use pointer correctly when dealing with Structure?

Question

I am learning about Dynamic Memory Allocate now and it's hard to understand, especially when the lecturer mentioned about DMA and structure using pointer.

First, at the line 1 in my code, i get confused what "&ptr->eno" means. we initiate ptr as a pointer so it means ptr hold the address of the memory we reserved, lets say ptr hold the address 2046, is that "&ptr->eno" means writing value to the address of 2046 it point to?

Second, at the line 2, how i can print out the value, cause "ptr->eno" contains value "2046" than when i print it out, it gonna give me the number 2046, not the value i try to stored in the memory location 2046.

My code was copied from the lecture note, i tried to run it on Visual studio, it crashed after i input the values. I am so new with C, my assumption may looks stupid and painful to understand. if you can't understand my explanation, please tell me how to use pointer with structure, may be i can figure out my mistake. Thank you

#include<stdio.h>
#include<stdlib.h>
struct emp
{
    int eno;
    char ename[20];
    float esal;
};
void main()
{
    struct emp* ptr;
    ptr = (struct emp*)malloc(sizeof(struct emp));
    if (ptr=NULL)
    {
        printf("out of memory error");
    }
    else
    {
        printf("enter the value of employee: \n");
        scanf_s("%d%s%f", &ptr->eno, ptr->ename, &ptr->esal); // line 1
    }
    printf("the name is: %s \t the number: %d \t the salary: %f", ptr->ename, ptr->eno, ptr->esal); //line2
}

Answer 1

This:

if (ptr=NULL)

doesn't do what you want. You want the comparison operator ==, not the assignment operator =. This will always set ptr to NULL, making the rest of the code have undefined behavior (which often leads to crashes in practice). Enabling, and looking at, compiler warnings is a very good way of avoiding this problem.

For the actual question, &ptr->eno means "the address of the field eno in the struct pointed to by ptr". In practice it will evaluate to the value of ptr, plus the offset from the start of the structure to the field eno, which in this case will be 0 since eno is the first field.

Furthermore, the printf() should of course be inside the else, since you can only run that if ptr is not NULL.

And, importantly: you must provide a buffer size for the string to scanf_s().):

Unlike scanf and wscanf, scanf_s and wscanf_s require the buffer size to be specified for all input parameters of type c, C, s, S, or string control sets that are enclosed in []. The buffer size in characters is passed as an additional parameter immediately following the pointer to the buffer or variable.

So, it should be:

const int num = scanf_s("%d%s%f", &ptr->eno, ptr->ename, (unsigned int) sizeof ptr->ename, &ptr->esal);
if (num == 3)  // All conversions succeeded, we can rely on them
{
  printf("the name is: %s \t the number: %d \t the salary: %f", ptr->ename, ptr->eno, ptr->esal); //line2
}

And you should check its return value, otherwise you risk using non-initialized variables if the input fails for some reason.

Note that the size of the buffer seems to be specified as unsigned int, and not size_t, which is ... not optimal in my point of view so the cast is needed.

By the way, "DMA" typically means "direct memory access" and has nothing to do with this; that was confusing me for a while.

Answer 2

Assuming that

if (ptr=NULL)

was a typo (since the subsequent "it crashed after i input the values" could not have happened), there is a fault here:

scanf_s("%d%s%f", &ptr->eno, ptr->ename, &ptr->esal);

is missing the required size argument for %s

scanf_s("%d%s%f", &ptr->eno, ptr->ename, 20, &ptr->esal);

or instead of hard coding, perhaps

scanf_s("%d%s%f", &ptr->eno, ptr->ename, (unsigned)sizeof ptr->ename, &ptr->esal);

Answer 3

It is not a good practice to cast the output of malloc (check [ this ] ), the simplest way to do it would be

struct emp *ptr;
ptr = malloc(1 * sizeof *ptr);

Then, == is used for equal to logical comparison, so

if (NULL == ptr)
/* = changed to ==, also put the value first which will help you easily
* fix accidental omission of the second =
*/
{
    printf("out of memory error");
    exit(1); // Exiting with a non-zero status
} 

^{Note This should be taken as a supplement to [ this ] answer}