如何索引包含指向struct的指针的struct，该指针是malloc块

Question

i am created a struct

typedef struct t{
     int top;
     int value;
  }s;

and another structure

typedef struct y{
      int top1;
      s **p
 }z;
  z *p1;

created a block by malloc

p1 = (z*) malloc(sizeof(z));
p1->p = (s**) malloc(10 * sizeof(s));

I tried with indexing the s structured block by

p1->p[4]->top;

but i got error. is there a way to index pointer to pointer type in C

Answer 1

Address them with single pointer.

typedef struct y{
    int top1;
    s *p; //Single pointer only
}z;

z *p1;
p1 = malloc(sizeof(z)); //Don't cast...
p1->p = malloc(10 * sizeof(s));

//And then:
p1->p[4].top;

---

If you still want double pointers, then:

typedef struct y{
    int top1;
    s **p;
} z;

z *p1;
size_t i;

p1 = malloc(sizeof(z)); //Create z structure object
p1->p = malloc(10 * sizeof(*p1->p)); //Create array of pointers to objects

//Now fill that array with your objects
for (i = 0; i < 10; i++) {
    p1->p[i] = malloc(sizeof(*p1->p[i]));
}

//Now access to property as:
p1->p[4]->top; //Do something.

The second option is less preferable but depends on you, because doing single malloc for 10 objects in a row is more efficient than doing 10x times single object and 11th time for initializing base array of pointers.

Answer 2

In struct y{ ...; s **p } struct y{ ...; s **p } , member p represents a pointer to a pointer to structure s , and not a pointer to structure s . So p1->p[4] is a pointer to an s , not an s itself, so you cannot access member top with accessor . . To get around the compiler error, you would have to use accessor -> , which dereferences the pointer value, but then you yield undefined behaviour at runtime, since the pointer value is not initialized.

To solve the problem, you could either change the data type of p to s *p (as suggested by @tilz0R), or you could adapt your code to actually deal with pointers to pointers:

typedef struct t{
    int top;
    int value;
}s;

typedef struct y{
    int top1;
    s **p;
}z;
z *p1;

int main() {
    p1 = malloc(sizeof(z));
    p1->p = malloc(10 * sizeof(s*));
    for (int i=0; i<10; i++) {
        p1->p[i] = malloc(sizeof(s));
    }

    p1->p[4]->top = 5;

}

Note that pointers to pointers are more complicated to handle, as you need an extra step/loop to initialize the pointers and to free them later on. So actually I'd prefer the s *p -way; But sometimes pointers to pointers are more appropriate, eg if particular slots of the array shall remain "empty"; then you could set the respective pointer to NULL , which would not be possible in an array of struct objects.