C 作用域前向声明

如何为每个函数创建结构声明，如下所示：

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

struct additionalVariables;

struct container {
    int am;
    int bm;

    struct additionVariables *variables;
};

void foo(void) {
    struct container myContainer;

    struct additionalVariables {
        int x;
        int y;
    };

    myContainer.variables = malloc(sizeof(struct additionVariables));

    myContainer.variables->x = 5;
    myContainer.variables->y = 6;

    free(myContainer.variables);
}

void bar(void) {
    struct container myContainer;

    struct additionalVariables {
        char a;
        int b;
        int x;
    };

    myContainer.variables = malloc(sizeof(struct additionVariables));

    myContainer.variables->a = 5;
    myContainer.variables->b = 6;
    myContainer.variables->x = 7;

    free(myContainer.variables);
}

int main(void) {
    foo();
    bar();

    return 0;
}

#包括
#包括
结构附加变量；
结构容器{
国际调幅；
int bm；
结构添加变量*变量；
};
无效foo（无效）{
结构容器myContainer；
结构附加变量{
int x；
int-y；
};
myContainer.variables=malloc（sizeof（struct additionVariables））；
myContainer.variables->x=5；
myContainer.variables->y=6；
免费（myContainer.variables）；
}
空心条（空心）{
结构容器myContainer；
结构附加变量{
字符a；
int b；
int x；
};
myContainer.variables=malloc（sizeof（struct additionVariables））；
myContainer.variables->a=5；
myContainer.variables->b=6；
myContainer.variables->x=7；
免费（myContainer.variables）；
}
内部主（空）{
foo（）；
bar（）；
返回0；
}

---

我宁愿不投。不同的additionVariables结构必须具有相同的名称，例如，foo和bar都需要x的属性。

您可以做的是制作容器的本地版本

void foo(void) {
    struct {
        int am;
        int bm;
        struct additionVariables {
            int x, y;
        } *variables;
    } myContainer;

    myContainer.variables = malloc(sizeof(struct additionVariables));
    myContainer.variables->x = 5;
    myContainer.variables->y = 6;

    free(myContainer.variables);
}

然后，如果需要传递

容器

结构，则可以使用空指针声明该结构

struct container {
    int am;
    int bm;
    void *variables;
};

但是，如果要将对象传递给其他函数，则仍需要进行强制转换：

DoSomeThingWithContainer((struct container *)&myContainer);

---

可以使

容器

在主变量中可见，但

附加变量

显然不可见。
我把它分割成几个文件，然后编译（更重要的是链接）ok。

main.c

#include "foobar.h"

int main(void) {
    foo();
    bar();

    return 0;
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    int y;
};

void foo(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->x = 5;
    myContainer.variables->y = 6;

    free(myContainer.variables);
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    char a;
    int b;
};

void bar(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->a = 5;
    myContainer.variables->b = 6;
    myContainer.variables->x = 7;

    free(myContainer.variables);
}

foobar.h

void foo(void);
void bar(void);

struct additionalVariables;

struct container {
    int am;
    int bm;

    struct additionalVariables* variables;
};

foo.c

#include "foobar.h"

int main(void) {
    foo();
    bar();

    return 0;
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    int y;
};

void foo(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->x = 5;
    myContainer.variables->y = 6;

    free(myContainer.variables);
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    char a;
    int b;
};

void bar(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->a = 5;
    myContainer.variables->b = 6;
    myContainer.variables->x = 7;

    free(myContainer.variables);
}

#包括“foobar.h”
#包括
结构附加变量{
int x；
int-y；
};
无效foo（无效）{
结构容器myContainer；
myContainer.variables=（additionalVariables*）malloc（sizeof（struct additionalVariables））；
myContainer.variables->x=5；
myContainer.variables->y=6；
免费（myContainer.variables）；
}

bar.c

#include "foobar.h"

int main(void) {
    foo();
    bar();

    return 0;
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    int y;
};

void foo(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->x = 5;
    myContainer.variables->y = 6;

    free(myContainer.variables);
}

#include "foobar.h"

#include <stdlib.h>

struct additionalVariables {
    int x;
    char a;
    int b;
};

void bar(void) {
    struct container myContainer;

    myContainer.variables = (additionalVariables*)malloc(sizeof(struct additionalVariables));

    myContainer.variables->a = 5;
    myContainer.variables->b = 6;
    myContainer.variables->x = 7;

    free(myContainer.variables);
}

#包括“foobar.h”
#包括
结构附加变量{
int x；
字符a；
int b；
};
空心条（空心）{
结构容器myContainer；
myContainer.variables=（additionalVariables*）malloc（sizeof（struct additionalVariables））；
myContainer.variables->a=5；
myContainer.variables->b=6；
myContainer.variables->x=7；
免费（myContainer.variables）；
}

以下是我解决问题的方法：

struct container {
    int am;
    int bm;
};

您还没有解释清楚为什么需要抽象指针。所以，我把它拿走了

void foo(void) {
    struct mycontainer {
        struct container base;
        int x;
        int y;
    } myContainer;

    myContainer.x = 5;
    myContainer.y = 6;
}

在这里，

foo（）

声明其容器的本地版本，并添加其他字段。

myContainer.base

的地址可以传递给需要

struct container*

的任何函数，并且它将具有与指向

myContainer

的指针相同的地址。由于我们不再处理指针，因此不需要调用

malloc（）

或

free（）

bar（）

也可以创建自己的版本

int main(void) {
    foo();
    bar();

    return 0;
}

---

但是，我有一种感觉，您真正想要的是。

在外部声明结构，并在所有分支中使用您需要的所有名称：

struct additionalVariables {
    int x;
};

struct container {
    int am;
    int bm;
    struct additionalVariables *variables;
};

然后在每个函数中扩展它，将原始元素作为更大结构的第一个元素：

void foo(void) {
    struct container myContainer;

    struct additionalVariablesFoo {
        struct additionalVariables base;
        int y;
    };

    myContainer.variables = malloc(sizeof(struct additionVariablesFoo));

    myContainer.variables.x = 5;
    (struct AdditionalVariablesFoo *)&(myContainer.variables)->y = 6;

    free(myContainer.variables);
}

---

由于向下转换到第一个元素的类型总是可以的，因此您可以访问函数外部的

x

字段，而无需进行转换，代价是需要在初始时间转换到函数内部的

y

字段（如果您只是通过类型为

struct additionalvariablesfo*

的临时变量初始化它，显然也不需要此强制转换）。在函数外部，扩展对象将被视为具有其第一个元素的类型，即声明共享名称的基础。

我认为您正在寻找

联合体

。对于

变量

成员，请使用

无效*

。无法使用联合体，因为我需要将其作为myContainer.variables.x访问（因此必须使用C11匿名继承），但两者都需要一个名为x的属性，因此无法工作。我的条件非常具体，我不确定是否可能。正在寻找最接近的答案。