Graph containing node structure with two pointers - c

Question

I am trying to write a simple graph for storing sizes of created tables. I am new to C so I am sorry if I miss some simple pointer operations.
My graph is containing previous and next pointers, where first next will point to the last node and serve as a iterator to grab next->next. I don't want to store any more information then those two pointers and size of the graph, so one can reach the nodes only trough the iteration of next pointer.
Here is a minimal reproducible example of my code:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct GC {
uint data;
uint size;
struct GC *next;
struct GC *prev;
};
void build_gc_root(struct GC **self) {
// Build root node
printf("Allocating gc.\n");
struct GC *tmp = malloc(sizeof *tmp);
tmp->size = 0;
tmp->data = 666;
tmp->prev = tmp;
tmp->next = tmp;
printf("Saving allocation of gc.\n");
(*self) = tmp;
}
void gc_clean(struct GC **self) {
uint _;
printf("Cleaning the gc table.\n");
for (_ = 0; _ < (*self)->size + 1; ++_) {
printf("Free node %hd.\n", (*self)->next->next->data);
free((*self)->next->next);
++(*self)->next;
}
printf("Free last node %hd.\n", (*self)->next->data);
free((*self)->next);
}
void gc_store(struct GC **self, uint data) {
printf("Storing GC value node.\n");
(*self)->next = malloc(sizeof *(*self)->next);
(*self)->next->data = data;
(*self)->next->prev = (*self)->prev;
(*self)->next->next = (*self);
(*self)->prev = (*self)->next;
++(*self)->size;
}
typedef struct {
void (*clean)();
void (*get_size)(uint size);
void (*print_table)();
struct GC *gc;
}__controller;
__controller controller;
void controller_clean() {
gc_clean(&controller.gc);
}
void controller_get_size(uint size) {
gc_store(&controller.gc, size);
}
void controller_print_table() {
uint index;
printf("GC catch: \n");
for (index = 0; index < controller.gc->size + 1; ++index) {
printf(" %hd\n", controller.gc->next->next->data);
--controller.gc->next;
}
putchar('\n');
}
__controller controller = {
controller_clean, controller_get_size, controller_print_table
};
int main (void) {
build_gc_root(&controller.gc);
controller.get_size(1);
controller.get_size(2);
controller.get_size(3);
controller.print_table();
controller.clean();
return 0;
}
After running this, the controller.print_table() method will output only two first node's data and end up with segmentation fault.

Answer 1

Basically you are creating a stack that is linked via prev pointer. The next is rather useless and you should think about removing it.
When it comes to printing or deleting the content, you have used wrong mechanism to iterate over your list.
Operators ++ and -- used on pointers move them to the next/previous consecutive element in memory. This is only valid within an array which you do not use.
Instead you need to follow the links in your structure to reach the next element.
This would look like this:
void gc_clean(struct GC** self) {
uint _;
printf("Cleaning the gc table.\n");
struct GC* gc = (*self)->prev;
for (_ = 0; _ < (*self)->size; ++_) {
printf("Free node %hd.\n", gc->data);
struct GC* tmp = gc;
gc = gc->prev;
free(tmp);
}
printf("Free last node %hd.\n", gc->data);
free(gc);
}
void controller_print_table() {
uint index;
printf("GC catch: \n");
struct GC* gc = controller.gc->prev;
for (index = 0; index < controller.gc->size + 1; ++index) {
printf(" %hd\n", gc->data);
gc = gc->prev;
}
putchar('\n');
}
Please note that this also removes the initial element from your stack which you added during creation. Also the pointers of your controller.gc are not valid any more. You need to initialize again after cleaning the list.
As a side node, you should think about naming.
The function to add an element to your stack, is called get_size which is confusing to put it mildly...

Answer 2

I post the working code bellow in case someone wanna see a working stack:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Garbage collector stack
struct GC {
uint data;
uint size;
struct GC *prev;
};
void build_gc_root(struct GC **self) {
// Build root node
printf("Allocating gc.\n");
struct GC *tmp = malloc(sizeof *tmp);
tmp->size = 0;
tmp->data = 666;
tmp->prev = tmp;
printf("Saving allocation of gc.\n");
(*self) = tmp;
}
void gc_clean(struct GC **self) {
uint _;
printf("Cleaning the gc table.\n");
struct GC *gc = (*self)->prev;
for (_ = 0; _ < (*self)->size; ++_) {
printf("Free node %hd\n", gc->data);
struct GC* tmp = gc;
gc = gc->prev;
free(tmp);
}
printf("Free the last node %hd\n", gc->data);
free(gc);
}
void gc_store(struct GC **self, uint data) {
printf("Storing GC value node.\n");
struct GC *node;
node = malloc(sizeof *(*self)->prev);
node->data = data;
node->prev = (*self)->prev;
(*self)->prev = node;
++(*self)->size;
}
void gc_print(struct GC *self) {
uint index;
struct GC *gc = self->prev`;
printf("GC catch: ");
for (index = 0; index < self->size + 1; ++index) {
printf(" %hd", gc->data);
gc = gc->prev;
}
putchar('\n');
}
typedef struct {
void (*clean)();
void (*get_size)(uint size);
void (*print_table)();
struct GC *gc;
}__controller;
__controller controller;
void controller_clean() {
gc_clean(&controller.gc);
}
void controller_get_size(uint size) {
gc_store(&controller.gc, size);
}
void controller_print_table() {
gc_print(controller.gc);
}
__controller controller = {
controller_clean, controller_get_size, controller_print_table
};
int main (void) {
build_gc_root(&controller.gc);
controller.get_size(1);
controller.get_size(2);
controller.get_size(3);
controller.print_table();
controller.clean();
return 0;
}