如何使用指针访问递归结构

Question

I am getting a really strange error in my C program and therefore I need your help guys! So I have a recursive structure called path, where sometimes I store the address of the "parent" path in the structure field mother:

 typedef struct path{

  struct path* mother;
  struct path** children;
  int length;
  uint8_t* inf;
 } path;

So in my example I just generate one path like this:

  int child_num=2;
  int bytes=10;
  path* my_path=malloc(sizeof(path));
  if (path==NULL) throw error...

  my_path->inf=malloc(sizeof(uint8_t)*bytes);
  memset(my_path->inf, 4, bytes);

  my_path->children=malloc(sizeof(path*)*child_num);

  for(int i=0; i<child_num; i++){
      my_path->children[i]->mother=my_path;
      my_path->children[i]->inf=malloc(sizeof(uint8_t)*bytes);
      memset(my_path->children[i]->inf, 5, bytes);
  }

So now since I stored the link to the parent structure, I want to use another helping pointer to get access to its information:

  path* my_pointer=my_path->children[0]->mother;  //this is just for the example

So i checked the addresses and everything seems to be alright, but if I know use the pointer in another method, pointing to the field "inf", it works if I use the variable "path" so:

     method(path->inf, bytes);

it is fine, but as soon as I do:

    method(my_pointer->inf, bytes);

the method crashes at the marked line:

 void method(uint8_t* element, int bytes) {

     if (element==NULL) ... //<=== here it crashes
     //do something

}

I really dont get what I am doing wrong, I printed the addresses and everything seems to be good, even if I access a certain byte over the variable "my_pointer", so like

      my_pointer->inf[1]

it returns me the corresponding value, but in the separate method it doesnt work.

Answer 1

Like the comments indicate we can't exactly answer your question with the information provided, but we can point you in the right direction.

First, I noticed in your examples that you're using path as a variable name to a typedef'd path structure. You need to either be more verbose with your variable names or actually copy paste some code to make sure that we can look at the actual problem, because it could simply be an issue with naming.

All in all I think it would do you a world of good to employ a bit of code hygiene. Organize some of the functions you use for data structure overhead at file scope:

static int path_alloc(path* p);
static int path_alloc_kids(path* p, int num);

static int path_alloc(path* p) {
  if(p == NULL) { return -1; }

  p = (path*)malloc(sizeof(path));
  if(p == NULL) { return -2; }

  return 0;
}

static int path_alloc_kids(path* p, int num) {
  if(p == NULL || num <= 0) { return -1; }

  if(!path_alloc(p)) { /* Easier to read and understand, no error handling here to muddle things up */

    /* You don't actually need a path**, do you? Think of char *argv[] a.k.a. char **argv, is that what you're actually going for? */
    p->children = (path*)malloc(sizeof(path) * num);
    if(p->children == NULL) { return -2; }
    p->length = num;
  } else { return -1; } /* Simple */

  return 0;
}

This makes it a LOT easier to understand your code, which is the main issue with pointers. Add in some methods to free the allocated children and roots and you're set to use this path structure in a relatively abstracted way. You may want to consider using a path and a path_node in a linked-list fashion, that way you only allocate what you need.

struct spath_node; /* So it knows of itself */
typedef struct spath_node {
  struct spath_node *parent;
  struct spath_node *next;
  uint8_t *data;
  int data_size;
} path_node;

Then allocate by passing in a data size and parent, a NULL parent could mean it's a root node.

static int path_alloc_node(path_node *parent, int data_size, uint8_t *data);

This makes for relatively slow insert/traversal, but easier to understand where you went wrong.

EDIT : To be clear, this is how we would add children to the linked-list example:

static int path_alloc_node(path_node *parent, int data_size, uint8_t *data) {
  path_node *tmp;

  if(parent == NULL || data_size <= 0) { return -1; }
  if(parent->next != NULL) { return -3; }

  tmp = (path_node*)malloc(sizeof(path_node));
  if(tmp == NULL) { return -2; }
  else parent->next = tmp;

  if(data == NULL) { /* Assume the caller is requesting a new data block of the given size */
    data = (uint8_t*)malloc((size_t)data_size);
    if(data == NULL) { return -2; }
  }

  parent->next->data = data;
  parent->next->data_size = data_size;
  parent->next->next = NULL;
  parent->next->parent = parent;

  return 0;
}