Accessing array of pointer to structure inside a structure

Question

I am trying to assign char array value in a structure and retrieving the data but facing some problem while retrieving.

struct first {
    int a;
    int b; 
};

struct second {
    int c;
    int d;
    struct first * f_t[2]; 
};

int main()
{
    struct second *p;
    char a[24] = {1, 0, 0, 0, 
                  2, 0, 0, 0, 
                  3, 0, 0, 0, 
                  4, 0, 0, 0,
                  5, 0, 0, 0,
                  6, 0, 0, 0};
    p = (struct second *)a;
    p->f_t[0] = (struct first *) (a + 8);
    p->f_t[1] = (struct first *) (a + 16);
    printf("%d %d %d %d %d %d", 
         p->c, p->d, p->f_t[0]->a, p->f_t[0]->b, p->f_t[1]->a, p->f_t[1]->b);
}

Output:

1 2 1245008 1245016 1245024 6

First two values are coming properly (1 and 2) but the rest seems like some garbage values.

Please help to identify some wrong initialization or some other method for the same.

Answer 1

First of all, never assume the padding in a struct. It works fairly reliably, but is technically undefined behavior.

And much more importantly, you are breaking the strict aliasing rule. This is an assumption by the compiler that you never access the same memory location with pointers of different types (in this case, struct first* and char*). You can get around this with the -fno-strict-aliasing or use unions to do type-punning, as it's usually called. Go here for more info.

The more correct version of this code will be -

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

struct first {
  int a;
  int b; 
};
struct second {
  int c;
  int d;
  struct first * f_t[2]; 
};
int main()
{
  struct second *p;
  char a[24] =        {1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,5,0,0,0,6,0,0,0};
  p = alloca(sizeof(struct second));
  memset(p, 0, sizeof(struct second));
  memcpy(p, a, sizeof(int)*2);
  p->f_t[0]= alloca(sizeof(struct first));
  p->f_t[1]= alloca(sizeof(struct first));
  memset(p->f_t[1], 0, sizeof(struct first));
  memset(p->f_t[0], 0, sizeof(struct first));
  memcpy(p->f_t[0], a + 8, sizeof(struct first));
  memcpy(p->f_t[1], a + 16, sizeof(struct first));
  printf("%d %d %d %d %d %d",p->c,p->d,p->f_t[0]->a,p->f_t[0]->b,p->f_t[1]->a,p->f_t[1]->b);

}

NOTE: Using alloca() is bad practice. Don't use it unless you know what you're doing. It's fine here since it's simply one small struct being allocated on the stack, but in general steer away from it and use malloc() or just use local variables.

This still technically falls under undefined behavior, since we're assuming how the structs are padded, which is implementation specific, but most platforms use self aligned data types and are a lot faster when using properly aligned structures, so it's easy to guess. For more information on this, go here. I still strongly discourage this as this is undefined behavior, and it's very easy to mess up.

Also, the next time onward, make sure to provide a minimal, complete and compilable example.

Answer 2

Well, you have a lot of (potential) problems with strict aliasing rule, possible padding, size of variables, alignment.

But let's assume that your compiler is set to no-strict-aliasing and that all sizes, padding and alignment match.

Then look at these lines:

p->f_t[0]=(Struct first *) (a+8);
p->f_t[1]=(Struct first *) (a+16);

What they will do is to overwrite a[8] and forward with the value of the pointer (aka address). Consequently a is no longer equal to the initialized value.

Try this to see for your self:

// Print all element in a
p->f_t[0]=(Struct first *) (a+8);
// Print all element in a
p->f_t[1]=(Struct first *) (a+16);
// Print all element in a

So your problem is that you try to use a[8] to a[23] for storing

a) two pointers

and

b) two struct first

Of cause that's impossible

Answer 3

Other comments and posts have already addressed the strict aliasing problems that accompany casting one type to another, and have detailed other issues as well.

It is appears from your existing code that you are attempting to reference each member of an array of struct usingpointer variables.

This answer is limited to an illustration of how to do what I think you are trying to do in simple terms: (read in-line comments for explantions)

typedef struct  { //using struct instead of Struct
  int a;
  int b; 
}FIRST;           //create typedef tag (improved readability throughout code)
typedef struct  {
  int c;
  int d;
  FIRST f_t[2]; // changed from *[] to [] 
}SECOND;        // (the rest of your post indicates that is what you meant) 

int main()
{
  SECOND *p1; //for illustration, create two pointers to reference 2 elements of arr[2]
  SECOND *p2;

  //Create array of SECOND, populate with unique values in each location
  //to provide verification during printf that assignments were made correcly.                                                                                                                                             
  SECOND arr[2] = {{1,2,{3,4,5,6}},{7,8,{9,10,11,12}}}; 
                  //note values are arranged to follow the definitions of 2 elements of SECOND arr[2]. 

  //Create 2 pointers, 1 for each element of SECOND arr[2]
  p1 = &arr[0]; //assigns address of 1st element of SECOND arr[0], to pointer p1

  p2 = &arr[1];//assigns address of 1st element of SECOND arr[1], to pointer p2

  printf("Elements of p1[0]:\n%d, %d, %d, %d, %d, %d\n", p1[0].c, p1[0].d, p1[0].f_t[0].a,p1[0].f_t[0].b,p1[0].f_t[1].a,p1[0].f_t[1].b );
  printf("Elements of p2[0]:\n%d, %d, %d, %d, %d, %d\n", p2[0].c, p2[0].d, p2[0].f_t[0].a,p2[0].f_t[0].b,p2[0].f_t[1].a,p2[0].f_t[1].b );
  getchar();//stop execution to view result (needed in my environment)

}