关于C#：什么是’前向声明’以及’typedef struct X’和’struct X’之间的区别？

What is 'forward declaration' and the difference between 'typedef struct X' and 'struct X'?

我是C编程的初学者，我知道struct类型声明和typedef结构声明之间的区别。我遇到一个答案，说如果我们定义一个struct，就像：

1
2
3

typedef struct {
some members;
} struct_name;

然后它将类似于为匿名结构提供别名(因为它没有标记名)。因此不能用于转发声明。我不知道远期申报是什么意思。

另外，我想知道以下代码：

1
2
3

typedef struct NAME {
some members;
} struct_alias;

NAME和struct_alias有什么区别吗？或者两者都等于struct_alias是结构名的别名吗？

此外，我们可以像这样声明一个struct NAME类型的变量吗？

1	struct_alias variable1;

和/或类似：

1	struct NAME variable2;

或类似：

1	NAME variable3;

当需要使用循环结构声明时，struct转发声明非常有用。例子：

1
2
3
4
5
6
7
8
9

struct a {
struct b * b_pointer;
int c;
};

struct b {
struct a * a_pointer;
void * d;
};

当struct a被宣布时，它还不知道struct b的规格，但是你可以向前参照它。

当您对匿名结构进行typedef时，编译器将不允许您在typedef之前使用它的名称。

这是非法的：

1
2
3
4
5
6
7
8
9
10
11

struct a {
b * b_pointer;
int c;
};

typedef struct {
struct a * a_pointer;
void * d;
} b;

// struct b was never declared or defined

但这是合法的：

1
2
3
4
5
6
7
8
9
10
11

struct a {
struct b * b_pointer;
int c;
};

typedef struct b {
struct a * a_pointer;
void * d;
} b;

// struct b is defined and has an alias type called b

这就是：

1
2
3
4
5
6
7
8
9
10
11
12

typedef struct b b;
// the type b referes to a yet undefined type struct b

struct a {
b * struct_b_pointer;
int c;
};

struct b {
struct a * a_pointer;
void * d;
};

这(仅在C中，在C++中是非法的)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

typedef int b;

struct a {
struct b * struct_b_pointer;
b b_integer_type;
int c;
};

struct b {
struct a * a_pointer;
void * d;
};

// struct b and b are two different types all together. Note: this is not allowed in C++

相关讨论

这是否意味着DAT typedef不允许在typedefined之前引用typedefined标识符。我做了更多的研究，才知道…既然我们必须在struct的typedef声明之前声明typedef的标识符(如果这是wat，则称为forward声明)，那么编译器就无法理解声明的内容是什么？？？？或者像你的例子中那样，struct element;和typedef struct{}element;之间会发生冲突吗？？
@dasbinkenlight.。+我想我得到了答案，如果我们没有一个结构模板的标记名，那么我们不能放弃声明它，因为没有什么可引用的…就像如果我们需要在程序行中声明和使用一个结构，并且在以后的一百行中定义了一个数据结构，那么我们将没有一个标记名来引用来转发声明它……顺便说一下，谢谢……
@"这是否意味着typedefs不允许在typedefed之前引用typedefed标识符"？对。"在您的示例中，struct element;和typedef struct{}element;之间是否会发生冲突？不，不会发生冲突：示例编译并运行良好—请看一看。
@你的理解是正确的。当您想要向前声明一个struct时，另一种情况是您想要声明一个指向它的指针，而不必引入结构的实际定义。当您将struct视为指针指向的"黑匣子"时(即不需要了解其内部结构时)，这可以节省编译时的依赖性。
谢谢@dasbinkenlight…但是它如何保存编译时依赖项呢？？coz每当我引用结构进行forward声明时，编译器都会查找在程序中定义结构的位置…了解cum如何节省编译时间依赖项..我无法理解..
@Akash_Sinha13134如果您只需要一个指针，编译器将不会查找在同一翻译单元中定义的struct。您可以在另一个文件中定义它，创建它，并将指针传递给一个不知道您的struct的内部结构的函数。
@dasbinkenlight.。在e2.next=&e1;行的代码(on ideone)中，该行表示dat struct e2 = struct e1因为printf("%d %d",e1.value,e2.value);正在打印123 0。
@不，这并不意味着：e2.value未初始化，只有e1.value有意义。该行给e2.next分配一个指向e1的指针。
另外，当我在离线devc++(with mingw)编译器中运行上述代码时，它会显示一条警告："来自不兼容指针类型的[warning]赋值[默认启用]"。我不明白为什么？
@我也一样。

前向声明是一种先于实际定义的声明，通常是为了在定义不可用时能够引用声明的类型。当然，不是所有的事情都可以用声明的未定义的结构来完成，但是在特定的上下文中，可以使用它。这种类型被称为不完整类型，对其使用有许多限制。例如：

1
2
3
4
5
6
7
8
9
10

struct X; // forward declaration

void f(struct X*) { } // usage of the declared, undefined structure

// void f(struct X) { } // ILLEGAL
// struct X x; // ILLEGAL
// int n =sizeof(struct X); // ILLEGAL

// later, or somewhere else altogether
struct X { /* ... */ };

这可能很有用，例如打破循环依赖关系，或者减少编译时间，因为定义通常要大得多，因此解析它需要更多的资源。

在您的示例中，struct NAME和struct_alias确实是等效的。

1 2	struct_alias variable1; struct NAME variable2;

是正确的；

1	NAME variable3;

不是，因为在C中，需要struct关键字。

相关讨论

struct_alias和struct NAME相同，struct_alias是struct NAME的别名。

这两个都是一样的

1
2
3

struct_alias variable1;

struct NAME variable1;

这是违法的

1	NAME variable3;

见这篇关于远期申报的文章。

如前所述，C/C++中的前向声明是对实际定义不可用的声明。它是一个声明，告诉编译器"有一个数据类型abc"。

假设这是某个键/值存储区my_dict.h的标题：

1
2
3
4
5
6
7
8

...
struct my_dict_t;
struct my_dict_t* create();

char* get_value(const struct my_dict_t* dict, const char* name);
char* insert(struct my_dict_t* dict, const char* name, char* value);
void destroy(struct my_dict_t* dict);
...

你对my_dict_t一点也不了解，但实际上，是因为使用了商店你不需要知道：

1
2
3
4
5
6
7

#include"my_dict.h"
...
struct my_dict_t* dict = create();
if(0 != insert(dict,"AnEntry", strdup("AValue"))) {
...
}
...

原因是：您只使用指向数据结构的指针。

指针只是数字，处理它们时，你不需要知道它们指向什么。

只有当你尝试真正地访问它们，比如

1
2
3

struct my_dict_t* dict = create();
printf("%s
", dict->value); /* Impossible if only a forward decl is available */

因此，为了实现这些功能，需要实际定义my_struct_t。您可以在源文件my_dict.c中这样做：

1
2
3
4
5
6
7
8
9
10
11

#include"my_dict.h"

struct my_dict_t {
char* value;
const char* name;
struct my_dict_t* next;
}

struct my_dict_t* create() {
return calloc(1, sizeof(struct my_dict_t));
}

这在一些情况下很方便，比如

用于解决循环类型依赖关系，如Sergei L.解释的。
用于封装，如上面的示例中所示。

所以剩下的问题是：当使用上面的函数时，为什么我们不能完全忽略前向声明呢？最后，编译器可以知道所有dict都是指针。

但是，编译器会执行类型检查：它需要确认你没有做类似的事情

1
2
3
4

...
int i = 12;
char* value = get_value(&i,"MyName");
...

它不需要知道my_dict_t是什么样子，但需要知道&i不是get_value()所期望的指针类型。