Why does pointer to custom struct doesn't work here?

Question

Why pointer to custom struct doesn't work in that code?
Why I'm getting warning in that line with p->x = x?
Why I'm getting second warning in line with strcpy_s?

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

typedef struct sptr {
    int x;
    char* s;
    struct sptr* next;
} ptr;

void add(ptr* p, int x, const char* s) {
    ptr* o = p;
    p = (ptr*) malloc(sizeof(ptr));
    p->x = x; // warning
    p->s = (char*)malloc(20 * sizeof(char));
    strcpy_s(p->s, 20, (char*)s); // warning
    p->next = o;
}

void show(ptr* p) {
    ptr* o = p;
    while (o != NULL) {
        printf("%d %s\n", o -> x, o -> s);
        o = o->next;
    }
}

int main() {
    ptr* p = NULL;

    add(p, 5, "xcvxvxv");
    add(p, 7, "adadad");
    show(p);

    return 0;
}

You are reserving space for a local pointer here in function `add`: `p = (ptr*) malloc(sizeof(ptr));`, in other words: `ptr *p` in `main` is not affected by `add`. You need to either pass a pointer to pointer or `return` a pointer from the function. O.T.: `ptr` is an horrible name for a type. — David Ranieri, Nov 29 '22 at 18:18
1. no prints (stack is empty?) 2. extracting the null pointer? 3. p->s can be element 0 — Freezend, Nov 29 '22 at 18:18
No, you are not forced to use globals, just change the function `add()`: `ptr *add(int x, const char* s) { ptr *p = malloc(sizeof(ptr)); ...; return p; }` — David Ranieri, Nov 29 '22 at 18:29
ok, yeah, it works with return, how to avoid these 2 warnings there? (dw about names, I'll delete that code after I'll understand it) — Freezend, Nov 29 '22 at 18:29
"2. extracting the null pointer (or something like that) 3. p->s can be element 0" — Freezend, Nov 29 '22 at 18:32
Then try to compile with `-Wno-somethinglikethat` to silence the warnings — David Ranieri, Nov 29 '22 at 18:38
but the code is correct? or these lines can lead to memory leaks, compilation errors or something? (C6011 and C6387) — Freezend, Nov 29 '22 at 18:40
Yes, that's right, don't pay too much attention to the compiler, people is asking what is your warning because they are gossipy. — David Ranieri, Nov 29 '22 at 18:45

score 1 · Accepted Answer · answered Nov 29 '22 at 18:46

Pointers are values.

add is receiving a copy of the NULL pointer value. Changing the local variable p, in add, to a new pointer value returned by malloc does not change the separate, local variable p in main.

Just as if you wanted to change the value of an int in the caller's scope, you'd use an int * argument:

void change(int *val)
{   
    *val = 10;
}                   
                                
int main(void)             
{
    int a = 5;             
    change(&a);
}

Changing the value of an int * in the caller's scope would require an int ** argument.

#include <stdlib.h>

void change(int **val)
{
    *val = malloc(sizeof **val);
}

int main(void)
{
    int *a;
    change(&a);
}

This extends to any type.

malloc can fail, and return NULL. Performing indirection on a NULL pointer value is Undefined Behaviour.

You must guard against this happening by checking the return value of malloc.

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

typedef struct node {
    int x;
    char *s;
    struct node *next;
} Node;

void add(Node **p, int x, const char *s) {
    Node *new_node = malloc(sizeof *new_node);

    if (!new_node) {
        perror("allocating node");
        exit(EXIT_FAILURE);
    }

    new_node->s = malloc(1 + strlen(s));

    if (!new_node->s) {
        perror("allocating node string");
        exit(EXIT_FAILURE);
    }

    new_node->x = x;
    strcpy(new_node->s, s);

    new_node->next = *p;
    *p = new_node;
}

void show(Node *p) {
    while (p) {
        printf("%d %s\n", p->x, p->s);
        p = p->next;
    }
}

int main(void) {
    Node *list = NULL;

    add(&list, 5, "xcvxvxv");
    add(&list, 7, "adadad");

    show(list);
}

score 0 · Answer 2 · answered Nov 29 '22 at 18:59

Why pointer to custom struct doesn't work in that code?

TBD

Why I'm getting warning in that line with p->x = x?
Why I'm getting second warning in line with strcpy_s?

2 warnings occur because code de-referenced the pointer from malloc() without first checking if the pointer might be NULL.

Why does pointer to custom struct doesn't work here?

2 Answers2