Question

我无法找到这个问题的答案;我在网上找到了类似的例子，但都没有解决我的问题。

我有一个struct用于公司，公司的数据，第二个struct用于公司集合，Consortium。第二个struct将包含第一个struct的可变长度数组，即公司数据struct。可变长度数组的元素数量将取决于联盟中的公司数量。

我想动态分配所需的任何东西，但我有点迷失。这些是结构：

typedef struct {
    char  code[];
    double sharePrice;
    int numShares;
    double totalVal;
    double totalDebts;
} Company;

typedef struct {
    int numCore;
    int numAssoc;
    Company core[];
    Company assoc[];
} Consortium;

将会有许多核心公司，这个数字将是联盟struct中核心阵列的大小。联营公司也是如此。

我想出了这个表达，但我不确定我错过了什么：

Consortium *consort=((Consortium*)malloc((numCore+numAssoc)*(sizeof(Consortium));

Answer 1

您需要使用指针并分别分配数组：

typedef struct
{
    char  *code;
    double sharePrice;
    int numShares;
    double totalVal;
    double totalDebts;
} Company;

typedef struct
{
    int numCore;
    int numAssoc;
    Company *core;
    Company *assoc;
} Consortium;

Consortium *c = malloc(sizeof(*c));    // Error check
c->numCore = 4;
c->core = malloc(sizeof(*c->core) * c->numCore);    // Error check
c->numAssoc = 3;
c->assoc = malloc(sizeof(*c->assoc) * c->numAssoc);    // Error check

for (int i = 0; i < c->numCore; i++)
    c->core[i].code = malloc(32);    // Error check

for (int i = 0; i < c->numAssoc; i++)
    c->assoc[i].code = malloc(32);    // Error check

// Worry about other data member initializations!

将Company类型修改为：

会更简单，也可能更好

typedef struct
{
    char   code[32];
    double sharePrice;
    int    numShares;
    double totalVal;
    double totalDebts;
} Company;

保存了分配代码元素的循环。

Answer 2

您可能会认为您使Consortium结构更简单一些。由于你有每种类型，核心和关联的计数，你可以只有一个数组，第一部分是核心，第二部分是关联。

所以你的结构看起来像下面的源代码（它没有被编译，只是记下来而不是经过测试，因此需要注意）：

typedef struct {
    int numCore;    // number of core companies, first part of m_companies
    int numAssoc;   // number of assoc companies, second part of m_companies
    Company m_companies[1];
} Consortium;

然后，您将通过以下内容创建实际的数据结构：

Consortium *makeConsortium (int numCore, int numAssoc) {
  Consortium *pConsortium = malloc (sizeof(Consortium) + sizeof(Company) * (numCore, numAssoc));
  if (pConsortium) {
      pConsortium->numCore = numCore;
      pConsortium->numAssoc = numAssoc;
  }
  return pConsortium;
}

在此之后，您可以通过一些表明成功的函数填写它：

int addCompanyCore (Consortium *pConsortium, int index, Company *pCompany) {
  int iRetStatus = 0;
  if (pConsortium && index < pConsortium->numCore) {
    pConsortium->m_companies[index] = *pCompany;
    iRetStatus = 1;
  }
  return iRetStatus;
}
int addCompanyAssoc (Consortium *pConsortium, int index, Company *pCompany) {
  int iRetStatus = 0;
  if (pConsortium && index < pConsortium->numAssoc) {
    index += pConsortium->numCore;
    pConsortium->m_companies[index] = *pCompany;
    iRetStatus = 1;
  }
  return iRetStatus;
}

然后你将使用另一组辅助函数访问它们。

Company  *getCompanyCore (Consortium *pConsortium, int index) {
  Company *pCompany = 0;
  if (pConsortium && index < pConsortium->numCore) {
    pCompany = pConsortium->m_companies + index;
  }
  return pCompany;
}
Company * getCompanyAssoc (Consortium *pConsortium, int index) {
  Company *pCompany = 0;
  if (pConsortium && index < pConsortium->numAssoc) {
    index += pConsortium->numCore;
    pCompany = pConsortium->m_companies + index;
  }
  return pCompany;
}

对结构中的结构进行mallocing数组（C）

2 个答案: