Hey, a few weeks ago i was introduced to pointers and basic datastructures primarily linked lists and Hash tables. So far as i’ve understood it’s used more for efficiency compared to normal arrays. More on reddit.com

C has the interesting property that it sort of treats structs like...well, what's called a 'primitive' type in Java for example. Suppose you have int a = 2 and then say int b = a, you have made b which holds a complete copy of a's value. Naturally. So, supposing you have struct Foo { int x[999999]; };. Then we say struct Foo a;. If you examine sizeof(a) you'd see that it's a chonker. If we go on to say struct Foo b = a;, then we have created a b which holds an entire separate copy of a's value. sizeof(a) == sizeof(b). Just as if they were ints. This is, frankly, weird. You see how carelessly using this feature could slurp up a ton of memory in a hurry. This plays heavily in function calls. C is call-by-value, so when you pass a struct to a function, you are creating a whole copy of that struct to send as the argument. You might want that, rarely, but often you do not. What you can do instead is send the address of the struct, a pointer, which is a uniformly tiny object. In Java, we'd say it's a reference. So, we can declare a function void baz(struct Foo* c);, and call it by saying baz(&a);. The pointer c that baz sees is a word-sized pointer to the struct a, no matter how big a actually is. sizeof(c) == sizeof(struct Foo*) == sizeof(int*). Significantly, this also lets baz modify the original a. If you don't want that, and also don't want to be passing around entire struct bodies, you use the const qualifier (which doesn't make it a constant, it just makes the compiler nag you if you forget to treat it as one). This explanation probably raises more questions than it answers. More on reddit.com

The struct is the actual location in memory that holds the values of all the variables. The struct* just contains the memory address of the beginning of that location. When you do book->author; it's the same as (*book).author; Edit: Forgot my semicolons More on reddit.com

In addition to the void* method, there's this trick I'd describe as "slightly abusive". Basically you have a "base struct" that just has a next in it. And then you include that struct in your data struct as the first field. Then you can cast your data struct to the base struct to get to the next.

(AFAIK, there's no UB or IB here, but someone please let me know if I'm mistaken.)

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

// Generic linked list stuff up here

struct node {
    struct node *next;
};

struct llist {
    struct node *head;
};

void llist_for_each(struct llist *l, void (*f)(void *))
{
    for (struct node *p = l->head; p != NULL; p = p->next)
        f(p);
}

void llist_init(struct llist *l)
{
    l->head = NULL;
}

// In this function, n must point to a struct node or a struct that has
// struct node as the first member:

void llist_insert(struct llist *l, void *n)
{
    struct node *new_node = n;
    struct node *old_head;

    old_head = l->head;
    new_node->next = old_head;
    l->head = new_node;
}

// Custom stuff below here

struct custom_node {
    struct node llist_data;  // Must be first!

    int a;
    char b;
    float c;
};

struct custom_node *new_custom_node(int a, char b, float c)
{
    struct custom_node *n = malloc(sizeof *n);

    n->a = a;
    n->b = b;
    n->c = c;

    return n;
}

void print_custom_node(void *node)
{
    struct custom_node *n = node;

    printf("%d %c %f\n", n->a, n->b, n->c);
}

int main(void)
{
    struct llist l;

    llist_init(&l);

    llist_insert(&l, new_custom_node(1, 'a', 1.1));
    llist_insert(&l, new_custom_node(2, 'b', 2.2));
    llist_insert(&l, new_custom_node(3, 'c', 3.3));

    llist_for_each(&l, print_custom_node);
}

// Output:
//
// 3 c 3.300000
// 2 b 2.200000
// 1 a 1.100000

More on reddit.com