如何使用指针来使用嵌套结构中的结构成员？

Question

考虑以下代码：

typedef struct
{
    int out;
    struct
    {
        int in1;
        struct
        {
            int in_int2;
            char in_char2;
        } inner2[3];
    } inner1[2];
} outer;

outer o1;

如何使用指针指向内部结构，例如 o1.inner[0].inner[1] 并将值分配给相同的值？

即（提供了用于解释的伪代码。正在询问确切的语法：

pointer *my_p = o1.inner[0].inner[1];
my_p->in_int2 = 2;

Answer 1

您的所有内部结构都是匿名的，因此无法引用它们。您需要为每个结构命名：

typedef struct
{
int out ;
   struct inner1
   {
      int in1;
      struct inner2
      {
          int in_int2;
          char in_char2;
      }inner2[3];
   }inner1[2];
}outer;

然后你可以创建一个指向正确类型的指针：

struct inner2 *my_p = &o1.inner1[0].inner2[1];

Answer 2

在纯 c 语言中你唯一的选择是：

1。为内部结构命名

这样你可以引用内部结构的具体类型来声明指针：

typedef struct
{
    int out;
    struct inner1
    {
        int in1;
        struct inner2
        {
            int in_int2;
            char in_char2;
        } inner2[3];
    } inner1[2];
} outer;

// Usage:
int main() {
    outer o1;
    struct inner2 *ptr = &o1.inner1[1].inner2[2];
    // ...
}

2。定义第二个等效结构作为指针类型

通过定义具有完全相同成员的结构，您可以将指针强制转换为该已知结构。
如果您无法修改 outer 的定义，这可能是一个选项。

typedef struct
{
    int out;
    struct
    {
        int in1;
        struct
        {
            int in_int2;
            char in_char2;
        } inner2[3];
    } inner1[2];
} outer;

// Usage:
int main() {
    outer o1;

    struct inner_type { int in_int2; char in_char2; };
    struct inner_type* ptr = (struct inner_type*)&o1.inner1[1].inner2[2];

    // ...
}

3。直接使用指向命名成员的指针

您也可以只使用指向in_int2 / in_char2 的指针，这样您就不必处理未命名的结构：

typedef struct
{
    int out;
    struct
    {
        int in1;
        struct
        {
            int in_int2;
            char in_char2;
        } inner2[3];
    } inner1[2];
} outer;

int main() {
    outer o1;

    int* ptr_in_int2 = &o1.inner1[1].inner2[2].in_int2;
    char* ptr_in_char2 =  &o1.inner1[1].inner2[2].in_char2;

    // ...
}

---

4。非标typeof()

如果你可以使用编译器扩展，gcc 和 clang 都提供typeof()，它允许你获取任意表达式的类型。

您可以使用它来创建指向未命名结构的指针，例如：

typedef struct
{
    int out;
    struct
    {
        int in1;
        struct
        {
            int in_int2;
            char in_char2;
        } inner2[3];
    } inner1[2];
} outer;

int main() {
    outer o1;
    typeof(o1.inner1[0].inner2[0])* ptr = &o1.inner1[1].inner2[2];
    // ...
}