如何使用指針來使用嵌套結構內的結構成員？

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];
    // ...
}