Question

我有这种复杂的结构：

#include <stdlib.h>

typedef struct {
    int x;
    int y;
} SUB;

typedef struct {
    int a;
    SUB *z;
} STRUCT;

#define NUM  5

int main(void)
{
    STRUCT *example;
    int i;

    example = malloc(sizeof(STRUCT));

    example->z = malloc(NUM * sizeof(SUB));

    for(i = 0; i < NUM; ++i) {
        /* how do I access variable in certain struct of array of z's */
    }

    return 0;
}

example是动态分配的结构，z内的example是动态分配的SUB结构数组。

如何访问结构z的某个元素中的某个变量？

我一直在尝试这样的事情： example->z[i].x 但它似乎无法正常工作。

目前我正在使用这个看起来很破旧的工作区：

SUB *ptr = example->z;
int i;

for(i = 0; i < amount_of_z_structs; ++i) {
    /* do something with  'ptr->x' and 'ptr->y' */
    ptr += sizeof(SUB);
}

Answer 1

你的问题不在你说的地方。您发布的代码会产生编译错误：

error: request for member ‘z’ in something not a structure or union

在

行

example.z = malloc(sizeof(STRUCT));

因为您打算写example->z，因为example是指向STRUCT的指针，而不是STRUCT。

从那时起，您可以完全按照说法访问example->z[i].x。这种语法一直很好。

例如：

/* your declarations here */

example = malloc(sizeof(STRUCT));
example->z = malloc(NUM * sizeof(SUB));

for(i = 0; i < NUM; ++i) {
    example->z[i].x = i;
    example->z[i].y = -i;
    printf("%d %d\n", example->z[i].x, example->z[i].y);
}

/* output:
0 0
1 -1
2 -2
3 -3
4 -4
*/

Answer 2

当你有指向指针的指针时，你经常会遇到优先问题。我不记得这是否是一个，但您可以尝试(example->b)[i].x。

Answer 3

试试这个：

int my_x = example[3].z[2].x;

上面的代码将首先访问示例[3]（示例数组的第四个元素）。
获得该特定元素后，其内容可以像使用普通对象一样自动访问。
然后从该元素访问z [2]。请注意，example[3]是一个元素，因此您可以使用.来访问其成员;如果它是一个数组，你可以作为数组访问它。
到目前为止，example[3].z[2]是{strong>一个元素，位于example数组的一个元素内。
现在，您只需使用上面显示的方式访问成员x即可。


typedef struct {
    int x;
    int y;
} SUB;

typedef struct {
    int a;
    SUB *z;
} STRUCT;

STRUCT *example;

int main() {
    example = malloc(sizeof(STRUCT)*10); //array of 10;
    int i=0,j=0;
    for (;i<10;i++){
        example[i].a = i;
        example[i].z = malloc(sizeof(SUB)*5);
        for (j=0; j<5; j++)
            example[i].z[j].x = example[i].z[j].y = j;
    }
    //access example[3] and access z[2] inside it. And finally access 'x'
    int my_x = example[3].z[2].x;
    printf("%d",my_x);

    for (i=0;i<10;i++){
        printf("%d |\n",example[i].a);
        //example[i].z = malloc(sizeof(SUB)*5);
        for (j=0; j<5; j++)
            printf("%d %d\n",example[i].z[j].x,example[i].z[j].y);
        free(example[i].z);
    }
    free(example);
}

Answer 4

首先，你的第二个malloc是错误的; example是一个指针，所以：

example.z = malloc(NUM * sizeof(SUB));

应该是这样的：

example->z = malloc(NUM * sizeof(SUB));

然后在你的循环中你可以这样说：

example->z[i].x = i;
example->z[i].y = i;

您还希望将此文件放在文件的顶部：

#include <stdlib.h>

Answer 5

在'破旧的解决方法'中，您写道：

SUB *ptr = example->z;
int i;

for(i = 0; i < amount_of_z_structs; ++i) {
    /* do something with  'ptr->x' and 'ptr->y' */
    ptr += sizeof(SUB);
}

这里的问题是C根据指向的对象的大小来缩放指针，因此当您向SUB指针添加1时，该值会提前sizeof(SUB)。所以，你只需要：

SUB *ptr = example->z;
int i;

for (i = 0; i < NUM; ++i) {
    ptr->x = ptr->y = 0;
    ptr++;
}

当然，正如其他人所说，你也可以这样做（假设C99）：

for (int i = 0; i < NUM; ++i)
    example->z[i].x = example->z[i].y = 0;

Answer 6

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

#define NUM 5

typedef struct
{
    int x;
    int y;
}SUB;

typedef struct
{
    int a;
    SUB* z;
}STRUCT;

void main(void)
{
    clrscr();
    printf("Sample problem..\n\n");

    STRUCT* example;
    int i;

    example = (STRUCT*)malloc(sizeof(STRUCT));
    example->z = (SUB*)malloc(NUM * sizeof(SUB));

    for(i = 0; i < NUM; i++)
    {
        example->z[i].x = i +1;
        example->z[i].y = (example->z[i].x)+1;
        printf("i = %d: x:%d y:%d\n", i, example->z[i].x, example->z[i].y);
    }
}

C和动态结构元素访问

6 个答案: