blocks|key|5805454|text|这真的无关紧要。如果你使用带标签的表单，你可以有指向struct+Foo内部struct+Foo的指针(又称工具栏)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5805455|typedef+struct+Foo{
++int+a;
++struct+Foo+*foop;
}+Bar;|code-block|syntax|javascript|5805456|但是对于第二种形式是无法做到这一点的|5805457|typedef+struct+{
++int+a;
++//Baz+*p;+not+valid+here+since+Baz+isn't+a+typename+yet
}+Baz;|5805458|有些代码库根本不喜欢使用结构体，每次都会简单地用typedef关键字拼写struct+Foo。|5805459|此外，对于第一种形式，您可以通过标记(struct+Foo)或使用typedefs+(Bar或任何将来/以前的typedef)来引用类型(您可以在提供定义之前执行typedef+struct+Foo+PreviousTypedef;+)。|5805460|另一方面，对于第二种形式，您只能使用Baz+typedef和未来可能的typedef(您不能对结构执行前向操作，因为它没有标记)。|5805461|(请注意，typedef并不是真正用C定义类型，而是由struct+optional_tag+{+/*...*/+}部分定义。相反，typedef提供了类型别名(因此可能应该将其命名为typealias)。|5805462|entityMap^0|Q|A|12|A|0|0|0|0|O|7|10|A|0|J|A|X|8|17|3|1J|7|29|Z|0|I|3|M|7|Z|7|0|5|7|R|V|1U|7|2K|9|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|X|$]]

It doesn't really matter much. If you use the tagged form you can
have pointers to <code>struct Foo</code> inside <code>struct Foo</code> (AKA Bar)

<pre><code>typedef struct Foo{
 int a;
 struct Foo *foop;
} Bar;
</code></pre>

but there's no way to do that with the second form

<pre><code>typedef struct {
 int a;
 //Baz *p; not valid here since Baz isn't a typename yet
} Baz;
</code></pre>

Some codebases prefer not to use <code>typedef</code>s at all and simply spell out <code>struct Foo</code> with the struct keyword every time.

Also, with the first form, you can refer to the type either via the tag (<code>struct Foo</code>) or with <code>typedefs</code> (<code>Bar</code> or any future/previous <code>typedef</code>s (you can do <code>typedef struct Foo PreviousTypedef;</code> before you provide the definition).

With the second form, on the other hand, you can only use the <code>Baz</code> <code>typedef</code> and possible future <code>typedef</code>s (you can't forward-<code>typedef</code> the struct since it doesn't have a tag).

(Note that <code>typedef</code> doesn't really define types in C. The <code>struct optional_tag { /*...*/ }</code> part does. Rather, <code>typedef</code> provides type aliases (so perhaps it should have been named <code>typealias</code>).)

blocks|key|2467910|text|有一次，如果你正在制作一个链表，就需要使用前者：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2467911|typedef+struct+list+{
++++int+data;
++++struct+list+*next;
}+list;|code-block|syntax|javascript|2467912|类型定义list在结构定义中不可见，因此您需要使用实际的结构名称来创建指向它的指针。|offset|length|style|CODE|2467913|如果你没有这样的结构，你可以使用任何一种。|2467914|但是，您不应该使用以下划线开头的标记名，例如：|2467915|typedef+struct+_list+{
++++int+data;
++++struct+list+*next;
}+list;|2467916|因为以下划线开头的名称由实现保留。|2467917|entityMap^0|0|0|4|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

One time where the former is required is if you're making a linked list:

<pre><code>typedef struct list {
 int data;
 struct list *next;
} list;
</code></pre>

The typedef <code>list</code> is not visible inside of the struct definition, so you need to use the actual struct name to create a pointer to it.

If you don't have such a structure, you can use either one.

What you shouldn't do however is use a tag name that starts with an underscore, i.e.:

<pre><code>typedef struct _list {
 int data;
 struct list *next;
} list;
</code></pre>

Because names starting with a underscore are reserved by the implementation.

blocks|key|3692687|text|匿名结构这个术语已经用于其他方面:在根本没有名称的嵌套结构(或联合)中，其字段被引用为父级中的条目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3692688|关于何时使用其中之一的实际问题是，如果您想在其中添加指向其自身类型的指针，则必须使用第一种形式，如下所示：|3692689|typedef+struct+Foo+{+struct+Foo*+Child;+...+}+Foo;|code-block|syntax|javascript|3692690|但是，我更倾向于使用如下所示的类型定义函数来实现此目的：|3692691|typedef+struct+Foo+Foo;
struct+Foo+{Foo*+Child;};|3692692|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The term anonymous struct is already used for something else: in nested structs (or unions) that don't have a name at all and whose fields are referred to as if they were entries in the parent.

The actual question about when to use one or the other is that you have to use the first form if you want to add a pointer to its own type inside it like so: 

<pre><code>typedef struct Foo { struct Foo* Child; ... } Foo;
</code></pre>

However, what I would prefer is to do that with a typedef like so:

<pre><code>typedef struct Foo Foo;
struct Foo {Foo* Child;};
</code></pre>

blocks|key|5805559|text|它们几乎是等同的。实际上，您可以并且应该在这两个位置使用相同的名称。使用相同的名称，除非你能想出一个很好的理由不这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5805560|需要非匿名的一种情况是，当您希望指针指向相同类型的对象时，例如在链表中。|5805561|typedef+struct+Node+{
++++struct+Node*+next;
++++int+data;
}+Node;|code-block|syntax|javascript|5805562|一种替代方案：|5805563|typedef+struct+Node+Node;

struct+Node+{
++++Node+*+next;
++++int+data;
};|5805564|根据Linus+Torvalds的说法，你应该避免使用typedefing+structs，除非你想隐藏它。从Linux+kernel+coding+style+guide|offset|length|5805565|请不要使用像vps_t这样的东西。使用vps_t作为结构和指针是错误的。当您在源代码中看到vps_t+a;时，它是什么意思？相反，如果它写的是struct+virtual_container+*a;，你实际上就能知道a是什么。|style|CODE|5805566|很多人认为typedefs有助于提高可读性。事实并非如此。它们仅在以下情况下有用：|5805567|a)完全不透明的对象(其中typedef被用来隐藏对象是什么)。|5805568|..。|5805569|5805570|根据这一点，你永远不应该使用匿名结构，而且typedefs是严格针对接口的。所以它应该看起来像这样：|5805571|typedef+struct+Node+{
++++struct+Node*+next;
++++int+data;
}+Node;|5805572|但是如果你真的在创建一个接口，你通常应该把它分成一个头文件和一个源文件。在这种情况下，将type放在头文件中，并且在源文件中根本不使用type:ed类型。|5805573|.c|5805574|struct+Node+{
++++struct+Node*+next;
++++int+data;
}+Node;

void+insert(struct+Node*+head,+int+data)+
{
//+Code
}++++|5805575|.h|5805576|typedef+struct+Node+Node;

void+insert(Node*+head,+int+data);|5805577|考虑到以上所有情况，使用匿名结构的唯一有效情况是同时声明一个对象，如下所示：|5805578|struct+{
++++int+data;
++++float+more_data;
}+myObject;+|5805579|entityMap|0|LINK|mutability|MUTABLE|url|https://www.kernel.org/doc/html/v4.10/process/coding-style.html#typedefs^0|0|0|0|0|0|1J|V|0|0|19|8|1Z|S|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1S|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1T|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1U|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1V|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1W|8|@]|9|@$O|1X|P|1Y|1|1Z]]|A|$]]|$1|Q|3|R|5|6|7|20|8|@$O|21|P|22|S|T]|$O|23|P|24|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|25|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|26|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|27|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|29|8|@]|9|@]|A|$]]|$1|13|3|14|5|F|7|2A|8|@]|9|@]|A|$G|H]]|$1|15|3|16|5|6|7|2B|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2C|8|@]|9|@]|A|$]]|$1|19|3|1A|5|F|7|2D|8|@]|9|@]|A|$G|H]]|$1|1B|3|1C|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|F|7|2F|8|@]|9|@]|A|$G|H]]|$1|1F|3|1G|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|F|7|2H|8|@]|9|@]|A|$G|H]]|$1|1J|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]]|1K|$1L|$5|1M|1N|1O|A|$1P|1Q]]]]

They are pretty much equivalent. Actually, you can and should use the same name on both places. Use the same name unless you can come up with a good reason not to.
One situation where you want the non-anonymous is when you want pointers to an object of the same type, like in a linked list.
<pre><code>typedef struct Node {
 struct Node* next;
 int data;
} Node;
</code></pre>
One alternative:
<pre><code>typedef struct Node Node;

struct Node {
 Node * next;
 int data;
};
</code></pre>
According to Linus Torvalds, you should avoid typedefing structs unless you want to hide it. From the <a href="https://www.kernel.org/doc/html/v4.10/process/coding-style.html#typedefs" rel="nofollow noreferrer">Linux kernel coding style guide</a>:
<blockquote>
Please don’t use things like vps_t. It’s a mistake to use typedef for structures and pointers. When you see a <code>vps_t a;</code> in the source, what does it mean? In contrast, if it says <code>struct virtual_container *a;</code> you can actually tell what a is.
Lots of people think that typedefs help readability. Not so. They are useful only for:
a) totally opaque objects (where the typedef is actively used to hide what the object is).
...
</blockquote>
According to that, you should never use anonymous structs, and the typedefs are strictly for interfaces. So it should look like this:
<pre><code>typedef struct Node {
 struct Node* next;
 int data;
} Node;
</code></pre>
But if you are really creating an interface, you should in general separate it into a header file and a source file. In this case, put the typedef in the header file and do NOT use the typedef:ed type at all in the source file.
.c
<pre class="lang-c prettyprint-override"><code>struct Node {
 struct Node* next;
 int data;
} Node;

void insert(struct Node* head, int data) 
{
// Code
} 
</code></pre>
.h
<pre><code>typedef struct Node Node;

void insert(Node* head, int data);
</code></pre>
Taking all of the above into consideration, the only valid situation to use an anonymous struct is if you declare an object at the same time like this:
<pre><code>struct {
 int data;
 float more_data;
} myObject; 
</code></pre>

blocks|key|2467966|text|当创建一个不透明的数据类型时，即头文件只包含struct的前向声明，而它的成员的实际定义在源文件中。因为你不能转发声明一个+typedef，所以你必须给一个命名一个。示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|2467967|Foo.h|2467968|typedef+struct+Foo_+Foo;|code-block|syntax|javascript|2467969|Foo.c|2467970|struct+Foo_+{
++++int+a;
};|2467971|另外，当你有一个递归数据结构时，比如其他人都提到过的链表。|2467972|entityMap^0|M|6|1Q|7|1Q|7|26|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|D]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|14|8|@]|E|@]|F|$]]|$1|I|3|J|5|K|7|15|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|16|8|@]|E|@]|F|$]]|$1|P|3|Q|5|K|7|17|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|18|8|@]|E|@]|F|$]]|$1|T|3|-4|5|6|7|19|8|@]|E|@]|F|$]]]|U|$]]

When creating an opaque data type which is when the header only contains a forward declaration of the <code>struct</code> and the actual definition of it's members is in the source file. Since you cannot forward declare a <code>typedef</code> you'll have to give a <code>struct</code> a name. Example:

Foo.h

<pre><code>typedef struct Foo_ Foo;
</code></pre>

Foo.c

<pre><code>struct Foo_ {
 int a;
};
</code></pre>

Also when you have a recursive data structure such as linked list which everyone else has mentioned.

blocks|key|2461352|text|很多人关注的是自引用方面，但避免这样做的另一个原因是，由于C中缺少名称空间，在某些圈子中，为了避免使用完整的typedef+struct限定符，而是引用带有完整说明符(例如void+foo(struct+Foo*+foo_ptr))的结构，而不使用，这是标准的做法。因此，如果你想保持这样的风格，你就不能选择滥用匿名结构，所以这是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2461353|typedef+struct+{
++int+a;
}+Bar;

Bar+bar1+=+{5};|code-block|syntax|javascript|2461354|应该始终是|2461355|struct+Bar{
++int+a;
};

struct+Bar+bar1+=+{5};|2461356|否则，如果不去掉struct限定符，您甚至无法编译bar1的实例化|2461357|entityMap^0|1I|7|1Q|6|1I|7|1Q|6|2E|T|0|0|0|0|8|6|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|D]|$9|10|A|11|B|D]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|14|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|15|8|@]|E|@]|F|$]]|$1|N|3|O|5|I|7|16|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|17|8|@$9|18|A|19|B|D]]|E|@]|F|$]]|$1|R|3|-4|5|6|7|1A|8|@]|E|@]|F|$]]]|S|$]]

A lot of other people are focusing on the self referential aspect of this, but another reason to avoid doing this is that due to the lack of namespaces in C. In some circles it is standard practice to not <code>typedef</code> structs to avoid <code>struct</code> qualifier and instead refer to structs with the full specifier (eg <code>void foo(struct Foo* foo_ptr)</code>). So if you wanted to maintain such a style, you wouldn't have the option to abuse anonymous structs, so this:

<pre><code>typedef struct {
 int a;
} Bar;

Bar bar1 = {5};
</code></pre>

should always instead be 

<pre><code>struct Bar{
 int a;
};

struct Bar bar1 = {5};
</code></pre>

otherwise you couldn't even compile bar1's instantiation with out <code>typedef</code>ing away the <code>struct</code> qualifier

When should one of the following statements be used over the other?

<pre><code>typedef struct Foo {
 int a;
} Bar;
</code></pre>

and

<pre><code>typedef struct {
 int a;
} Bar;
</code></pre>

and use it like

<pre><code>Bar bar1 = { 5 };
</code></pre>

I understand the second on is an anonymous struct but not sure when should one be used over the other.

Using an anonymous struct vs a named struct with typedef

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么时候应该使用以下语句中的一种而不是另一种？typedef struct Foo {    int a;} Bar;和typedef struct {    int a;} Bar;并像这样使用它Bar bar1 = { 5 };我知道第二个是匿名结构，但不确定什么时候应该使用一个而不是另一个。

问使用匿名结构与使用带有typedef的命名结构
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用匿名结构与使用带有typedef的命名结构EN