在c中创建一个具有多个动态大小数组的结构？

是否可以在c中创建包含两个动态大小数组的结构

我有这样的想法：

#define MAX_DATA 512

    struct Address {
    int id;
    int set;
    char name[MAX_DATA];
    char email[MAX_DATA];
};

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

int
main(int argc, char *argv[])
{
    int len = atoi(argv[1]);

    struct Address {
        int id;
        char name[len];
        int set;
        char email[len];
    };

    printf("sizeof(struct Address) = %zu\n", sizeof(struct Address));
    exit(EXIT_SUCCESS);
}

我希望在运行时定义MAX_数据

我看过struct hack：

但我认为这只适用于每个结构的一个字段

此代码来自

---

该页面底部附近的额外积分部分包含关于将大小更改为动态的部分。

您可以使用struct hack（现在称为灵活数组）来实现这一点。它只需要将两个数组打包到结构的灵活部分

---

假设您希望数组的长度分别为

N

和

M

。然后分配一个灵活的数组，就像分配一个长度为

N+M

的数组一样。然后对第一个数组使用索引

0..N-1

，对第二个数组使用索引

N..N+M-1

。

您可以使用struct hack（现在称为灵活数组）来实现这一点。它只需要将两个数组打包到结构的灵活部分

---

假设您希望数组的长度分别为

N

和

M

。然后分配一个灵活的数组，就像分配一个长度为

N+M

的数组一样。然后对第一个数组使用索引

0..N-1

，对第二个数组使用索引

N..N+M-1

。

您可以使用struct hack（现在称为灵活数组）来实现这一点。它只需要将两个数组打包到结构的灵活部分

---

假设您希望数组的长度分别为

N

和

M

。然后分配一个灵活的数组，就像分配一个长度为

N+M

的数组一样。然后对第一个数组使用索引

0..N-1

，对第二个数组使用索引

N..N+M-1

。

您可以使用struct hack（现在称为灵活数组）来实现这一点。它只需要将两个数组打包到结构的灵活部分

假设您希望数组的长度分别为

N

和

M

。然后分配一个灵活的数组，就像分配一个长度为

N+M

的数组一样。然后对第一个数组使用索引

0..N-1

，对第二个数组使用索引

N..N+M-1

。

如果将

struct Address

定义放在函数中，它会起作用（至少对于GCC 4.7.2），如下所示：

#define MAX_DATA 512

    struct Address {
    int id;
    int set;
    char name[MAX_DATA];
    char email[MAX_DATA];
};

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

int
main(int argc, char *argv[])
{
    int len = atoi(argv[1]);

    struct Address {
        int id;
        char name[len];
        int set;
        char email[len];
    };

    printf("sizeof(struct Address) = %zu\n", sizeof(struct Address));
    exit(EXIT_SUCCESS);
}

如果将

struct Address

定义放在函数中，它会起作用（至少对于GCC 4.7.2），如下所示：

#define MAX_DATA 512

    struct Address {
    int id;
    int set;
    char name[MAX_DATA];
    char email[MAX_DATA];
};

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

int
main(int argc, char *argv[])
{
    int len = atoi(argv[1]);

    struct Address {
        int id;
        char name[len];
        int set;
        char email[len];
    };

    printf("sizeof(struct Address) = %zu\n", sizeof(struct Address));
    exit(EXIT_SUCCESS);
}

如果将

struct Address

定义放在函数中，它会起作用（至少对于GCC 4.7.2），如下所示：

#define MAX_DATA 512

    struct Address {
    int id;
    int set;
    char name[MAX_DATA];
    char email[MAX_DATA];
};

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

int
main(int argc, char *argv[])
{
    int len = atoi(argv[1]);

    struct Address {
        int id;
        char name[len];
        int set;
        char email[len];
    };

    printf("sizeof(struct Address) = %zu\n", sizeof(struct Address));
    exit(EXIT_SUCCESS);
}

如果将

struct Address

定义放在函数中，它会起作用（至少对于GCC 4.7.2），如下所示：

#define MAX_DATA 512

    struct Address {
    int id;
    int set;
    char name[MAX_DATA];
    char email[MAX_DATA];
};

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

int
main(int argc, char *argv[])
{
    int len = atoi(argv[1]);

    struct Address {
        int id;
        char name[len];
        int set;
        char email[len];
    };

    printf("sizeof(struct Address) = %zu\n", sizeof(struct Address));
    exit(EXIT_SUCCESS);
}

我曾经这样做过：

struct Thing {
    int Number;
    char *MoreBytes;
    char Bytes[]
}


Thing *MakeThing(int nBytes, int nMoreBytes) 
{
    Thing *th = malloc(sizeof(Thing) + nBytes + nMoreBytes);
    // Error checking is for grrrlz.

    th->Number = 42;
    th->MoreBytes = th->Bytes + nBytes; 

    return th;
}

因此数组

th->Bytes

实际上包含两个“数组”，指针

th->MoreBytes

告诉我们 一个数组结束，另一个数组开始。

我曾经这样做过：

struct Thing {
    int Number;
    char *MoreBytes;
    char Bytes[]
}


Thing *MakeThing(int nBytes, int nMoreBytes) 
{
    Thing *th = malloc(sizeof(Thing) + nBytes + nMoreBytes);
    // Error checking is for grrrlz.

    th->Number = 42;
    th->MoreBytes = th->Bytes + nBytes; 

    return th;
}

struct Address 
{
int id;
int set;
char *name;
char *email;
};

因此数组

th->Bytes

实际上包含两个“数组”，指针

th->MoreBytes

告诉我们 一个数组结束，另一个数组开始。

我曾经这样做过：

struct Thing {
    int Number;
    char *MoreBytes;
    char Bytes[]
}


Thing *MakeThing(int nBytes, int nMoreBytes) 
{
    Thing *th = malloc(sizeof(Thing) + nBytes + nMoreBytes);
    // Error checking is for grrrlz.

    th->Number = 42;
    th->MoreBytes = th->Bytes + nBytes; 

    return th;
}

struct Address 
{
int id;
int set;
char *name;
char *email;
};

因此数组

th->Bytes

实际上包含两个“数组”，指针

th->MoreBytes

告诉我们 一个数组结束，另一个数组开始。

我曾经这样做过：

struct Thing {
    int Number;
    char *MoreBytes;
    char Bytes[]
}


Thing *MakeThing(int nBytes, int nMoreBytes) 
{
    Thing *th = malloc(sizeof(Thing) + nBytes + nMoreBytes);
    // Error checking is for grrrlz.

    th->Number = 42;
    th->MoreBytes = th->Bytes + nBytes; 

    return th;
}

struct Address 
{
int id;
int set;
char *name;
char *email;
};

因此数组

th->Bytes

实际上包含两个“数组”，指针

th->MoreBytes

告诉我们 其中一个数组结束，另一个数组开始

struct Address 
{
int id;
int set;
char *name;
char *email;
};

现在在

main（）

函数中，使用一些变量，比如

len

来存储数组的长度，并使用

malloc（）

动态分配所需的内存

否则，您可以添加

len

作为

struct Address

struct Address 
{
int id;
int set;
int len;
char *name;
char *email;
};

现在进入

main（）

现在在

main（）

函数中，使用一些变量，比如

len

来存储数组的长度，并使用

malloc（）

动态分配所需的内存

否则，您可以添加

len

作为

struct Address

struct Address 
{
int id;
int set;
int len;
char *name;
char *email;
};

现在进入

main（）

现在在

main（）

函数中，使用一些变量，比如

len

来存储数组的长度，并使用

malloc（）

动态分配所需的内存

否则，您可以添加

len

作为

struct Address

struct Address 
{
int id;
int set;
int len;
char *name;
char *email;
};

现在进入

main（）

现在在

main（）

函数中，使用一些变量，比如

len

来存储数组的长度，并使用

malloc（）

动态分配所需的内存

否则，您可以添加

len

作为

struct Address

struct Address 
{
int id;
int set;
int len;
char *name;
char *email;
};

现在进入

main（）

---

---

当然，您只需将数组更改为指针，然后需要为每个动态大小的数组调用一次malloc。。我真的需要先阅读标记，我几乎是建议“使用std:：vector”。这不是一个hack，但在标准中明确提到。它被称为flexible array member或zero-length array。如果你能减少损失，使用普通的malloc而不是struct hack，几年后当你维护代码时，你会为此感谢自己。@MattMcNabb我不知道“普通”malloc（即三个malloc）更容易维护。共享一个缓冲区的任何复杂性通常都可以封装在创建

Address

实例的函数中。使用一个缓冲区意味着可以使用普通的

free（）

释放地址。当然，您只需将数组更改为指针，然后需要为每个动态大小的数组调用一次

malloc

。。我真的需要先读取标记，我几乎建议“使用std:：vector”这不是一个黑客，但在标准中明确提到。这叫做柔性阵列