blocks|key|1633491|text|每当它使源代码更清晰或更易于阅读时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633492|对于泛型/模板，我在C#中使用了一种类型定义。与很多"Dictionary“相比，"NodeMapping”更易于阅读/使用和理解。我的天。因此，我建议您将其用于模板。|1633493|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Whenever it makes the source clearer or better to read.

I use kind of typedef in C# for generics/templates. A "NodeMapping" is just better to read/use and understand then a lot of "Dictionary&lt;string, XmlNode&gt;". IMHO. So I'd recommend it for templates.

blocks|key|1418876|text|与函数指针一起使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418877|使用typedef隐藏函数指针声明|1418878|void+(*p[10])+(void+(*)()+);|code-block|syntax|javascript|1418879|只有少数程序员知道p是一个“10个指针组成的数组，指向一个返回void的函数，并将指针指向另一个返回void且不带参数的函数”。繁琐的语法几乎无法辨别。但是，您可以通过使用typedef声明来大大简化它。首先，为“指向返回void且不带参数的函数的指针”声明一个typedef，如下所示：|1418880|++typedef+void+(*pfv)();|1418881|接下来，根据我们之前声明的taking，为“指向返回void并获取pfv的函数的指针”声明另一个typedef：|1418882|+typedef+void+(*pf_taking_pfv)+(pfv);|1418883|现在我们已经创建了pf_taking_pfv类型定义作为笨拙的“指向返回空的函数的指针并接受pfv”的同义词，声明一个由10个这样的指针组成的数组是轻而易举的事：|1418884|++pf_taking_pfv+p[10];|1418885|from|offset|length|1418886|entityMap|0|LINK|mutability|MUTABLE|url|http://www.devx.com/tips/Tip/13829^0|0|0|0|0|0|0|0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1F|8|@]|9|@$W|1G|X|1H|1|1I]]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

use with function pointer

Hide Function Pointer Declarations With a typedef

<pre><code>void (*p[10]) (void (*)() );
</code></pre>

Only few programmers can tell that p is an "array of 10 pointers to a function returning void and taking a pointer to another function that returns void and takes no arguments." The cumbersome syntax is nearly indecipherable. However, you can simplify it considerably by using typedef declarations. First, declare a typedef for "pointer to a function returning void and taking no arguments" as follows:

<pre><code> typedef void (*pfv)();
</code></pre>

Next, declare another typedef for "pointer to a function returning void and taking a pfv" based on the typedef we previously declared:

<pre><code> typedef void (*pf_taking_pfv) (pfv);
</code></pre>

Now that we have created the pf_taking_pfv typedef as a synonym for the unwieldy "pointer to a function returning void and taking a pfv", declaring an array of 10 such pointers is a breeze:

<pre><code> pf_taking_pfv p[10];
</code></pre>

<a href="http://www.devx.com/tips/Tip/13829" rel="noreferrer">from</a>

blocks|key|1633734|text|在Bjarne的书中，他指出，您可以使用typedef来处理具有不同整数大小的系统之间的可移植性问题。(这是一段转述)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633735|在sizeof(int)为4的机器上，您可以|offset|length|style|CODE|1633736|typedef+int+int32;|code-block|syntax|javascript|1633737|然后在你的代码中到处使用int32。当您转到sizeof(int)为2的C%2B%2B实现时，您只需更改typdef|1633738|typedef+long+int32;|1633739|并且您的程序仍然可以在新的实现上工作。|1633740|entityMap^0|0|1|B|0|0|C|5|M|B|1C|6|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

In Bjarne's book he states that you can use typedef to deal with portability problems between systems that have different integer sizes. (this is a paraphrase)

On a machine where <code>sizeof(int)</code> is 4 you can

<pre><code>typedef int int32;
</code></pre>

Then use <code>int32</code> everywhere in your code. When you move to an implementation of C++ where <code>sizeof(int)</code> is 2, then you can just change the <code>typdef</code>

<pre><code>typedef long int32;
</code></pre>

and your program will still work on the new implementation.

blocks|key|1633814|text|typedef在很多情况下都很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633815|基本上，它允许你为一个类型创建一个别名。当/如果您必须更改类型时，其余代码可以保持不变(当然，这取决于代码)。例如，假设您想要在c%2B%2B向量上执行iter|1633816|vector<int>+v;

...

for(vector<int>::const_iterator+i+=+v->begin();+i+!=+v.end();+i%2B%2B)+{

//+Stuff+here

}|code-block|syntax|javascript|1633817|将来你可能会考虑用列表来改变向量，因为你必须在它上面做的操作类型。如果没有typedef，你就必须改变代码中所有出现的向量。但是如果你像这样写的话：|1633818|typedef+vector<int>+my_vect;

my_vect+v;

...

for(my_vect::const_iterator+i+=+v->begin();+i+!=+v.end();+i%2B%2B)+{

//+Stuff+here

}|1633819|现在，您只需更改一行代码(即从"typedef+vector<int>+my_vect“更改为"typedef+list<int>+my_vect")，一切都会正常工作。|offset|length|style|CODE|1633820|当你有复杂的数据结构需要写很长的时间(并且很难读)时，typedef也可以节省你的时间。|1633821|entityMap^0|0|0|0|0|0|G|R|1C|P|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

typedef is useful in a lot of situations.

Basically it allows you to create an alias for a type. When/if you have to change the type, the rest of the code could be unchanged (this depends on the code, of course).
For example let's say you want to iter on a c++ vector

<pre><code>vector&lt;int&gt; v;

...

for(vector&lt;int&gt;::const_iterator i = v-&gt;begin(); i != v.end(); i++) {

// Stuff here

}
</code></pre>

In the future you may think to change the vector with a list, because the type of operations you have to do on it. Without typedef you have to change ALL occurrences of vector within your code.
But if you write something like this:

<pre><code>typedef vector&lt;int&gt; my_vect;

my_vect v;

...

for(my_vect::const_iterator i = v-&gt;begin(); i != v.end(); i++) {

// Stuff here

}
</code></pre>

Now you just have to change one row of code (i.e from "<code>typedef vector&lt;int&gt; my_vect</code>" to "<code>typedef list&lt;int&gt; my_vect</code>") and everything works.

typedef also saves you time when you have complex data structures which are very long to write (and difficult to read)

blocks|key|1633893|text|使用typedef的一个很好的理由是，如果某些东西的类型可能会发生变化。例如，就目前而言，16位整数可以很好地索引某些数据集，因为在可预见的将来，您将拥有不到65535个项目，而且空间限制很大，或者您需要良好的缓存性能。但是，如果您需要在包含超过65535个项的数据集上使用程序，那么您希望能够轻松地切换到更宽的整数。使用类型定义，你只需要在一个地方修改它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633894|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One good reason to use typedef is if the type of something may change. For example, let's say that for now, 16-bit ints are fine for indexing some dataset because for the foreseeable future, you'll have less than 65535 items, and that space constraints are significant or you need good cache performance. However, on the off chance that you need to use your program on a dataset with more than 65535 items, you want to be able to easily switch to a wider integer. Use a typedef, and you only have to change this in one place.

blocks|key|1633943|text|..。而且您不需要为枚举或结构使用Typedef。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633944|或者你有吗？|1633945|typedef+enum+{+c1,+c2+}+tMyEnum;
typedef+struct+{+int+i;+double+d;+}+tMyStruct;|code-block|syntax|javascript|1633946|可以更好地写成|1633947|enum+tMyEnum+{+c1,+c2+}
struct++tMyStruct+{+int+i;+double+d;+};|1633948|对吗？那C呢？|1633949|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

... and you Don't Need a Typedef for an enum or a struct.

Or do you?

<pre><code>typedef enum { c1, c2 } tMyEnum;
typedef struct { int i; double d; } tMyStruct;
</code></pre>

can be better written as

<pre><code>enum tMyEnum { c1, c2 }
struct tMyStruct { int i; double d; };
</code></pre>

Is that correct? What about C?

blocks|key|1419210|text|typedef不仅允许为复杂类型提供别名，还为您提供了一个记录类型的自然位置。我有时会将其用于文档目的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1419211|有时我也会使用字节数组。现在，一个字节数组可能意味着很多事情。使用typedef可以方便地将字节数组定义为"hash32“或"fileContent”，从而提高代码的可读性。|1419212|entityMap^0|0|7|0|X|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

<code>typedef</code> allows to not only have an alias for complex types, but gives you a natural place to document a type. I sometimes use it for documentation purposes.

There are also times when I use an array of bytes. Now, an array of bytes could mean a lot of things. <code>typedef</code> makes it handy to define my byte array as "hash32", or "fileContent" to make my code more readable.

blocks|key|1634057|text|Typedef允许在您的类中实现灵活性。当您想要更改程序中的数据类型时，您不需要更改多个位置，只需更改一个匹配项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634058|typedef+<datatype+example++int+or+double>+value_type|code-block|syntax|javascript|1634059|您可以使用不同的名称来代替value_type，但value_type通常是标准名称。|offset|length|style|CODE|1634060|所以你可以像这样使用typedef|1634061|value_type+i=0;+++++//same+as+a+int+or+double+i=0;+|1634062|entityMap^0|0|0|D|A|P|A|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Typedef allows flexibility in your class. When you want to change the data type in the program, you do not need to change multiple locations but just need to change one occurrence.

<pre><code>typedef &lt;datatype example int or double&gt; value_type
</code></pre>

you can give nay name instead of <code>value_type</code>, but <code>value_type</code> is normally the standard name.

So u can use typedef like

<pre><code>value_type i=0; //same as a int or double i=0; 
</code></pre>

blocks|key|1634137|text|size_t是typedef的一个实际示例。它保证足够大，以容纳主机系统可以处理的最大对象的大小。允许的最大大小取决于编译器；如果编译器是32位的，那么它就是unsigned+int的typedef；但是如果编译器是64位的，那么它就是unsigned+long+long的typedef。size_t数据类型从不为负。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1634138|entityMap^0|0|6|7|7|27|C|2K|7|3A|I|3T|7|41|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

1 practical example of <code>typedef</code> is <code>size_t</code>. It is guaranteed to be big enough to contain the size of the biggest object the host system can handle. The maximum permissible size is dependent on the compiler; if the compiler is 32 bits then it is simply a <code>typedef</code> for <code>unsigned int</code> but if the compiler is 64 bits then it would be a <code>typedef</code> for <code>unsigned long long</code>. The <code>size_t</code> data type is never negative.

In my years of C++ (MFC) programming in I never felt the need to use <code>typedef</code>, so I don't really know what is it used for. Where should I use it? Are there any real situations where the use of <code>typedef</code> is preferred? Or is this really more a C-specific keyword?

When should I use typedef in C++?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在我多年的C++编程中，我从来没有觉得有必要使用typedef，所以我真的不知道它是用来做什么的。我应该在哪里使用它？是否存在首选使用typedef的实际情况？或者这真的是一个C语言特有的关键字？

问我应该在什么时候在C++中使用typedef？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该在什么时候在C++中使用typedef？EN