blocks|key|2019797|text|register会提示编译器将变量放在寄存器中，而不是放在内存/堆栈空间中。在某些情况下，没有足够的寄存器为您放置此关键字的每个变量提供寄存器，因此将其放在太多变量上可能会迫使其他一些变量再次退出寄存器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2019798|不过，这只是一个提示，编译器不需要理解它。|2019799|entityMap^0|0|8|0|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|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

<code>register</code> gives the compiler a hint to place the variable in a register instead of memory/stack space. In some cases, there won't be enough registers for every variable you place this keyword on so placing it on too many variables can force some of the others out of registers again.

This is just a hint, though, and the compiler doesn't have to take it.

blocks|key|719681|text|你是怎么计时的？实际上，register通常什么也不做。这是在编译器技术非常原始，编译器自己无法确定寄存器分配时留下的一块残留物。它被认为是为该变量分配一个寄存器的提示，并且对于经常使用的变量很有用。如今，大多数编译器简单地忽略它，并根据自己的算法分配寄存器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|719682|entityMap^0|C|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

How did you time this? In practice, <code>register</code> usually does nothing. It's a piece of cruft from when compiler technology was extremely primitive and compilers couldn't figure out register allocation themselves. It was supposed to be a hint to allocate a register to that variable and was useful for variables used very frequently. Nowadays, most compilers simply ignore it and allocate registers according to their own algorithms.

blocks|key|2022992|text|可用的寄存器数量有限，因此将所有内容标记为register并不会将所有内容都放入寄存器中。基准测试是知道它是否会有帮助的唯一方法。一个好的编译器应该能够自己找出将哪些变量放到寄存器中，所以在决定寄存器关键字有帮助之前，您可能应该进行更多的基准测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2022993|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|$]]

There are a limited number of registers available, so marking everything as register won't put everything in registers. Benchmarking is the only way to know if it's going to help or not. A good compiler should be able to figure out what variables to put into registers on its own, so you should probably benchmark some more before you decide that the register keywords helps.

blocks|key|906315|text|可分配寄存器是有限制的。如果你超过了它，你只会得到效率更低的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|906316|我的观点是，如果你所做的事情是如此重要，以至于你必须自己决定什么在寄存器中，什么不在寄存器中，你应该用汇编语言来编写它。|906317|对于通用语言，我坚信编译器比人类更能决定寄存器中的内容。证据是，虽然您不确定可以在寄存器中放入多少个变量，但您的编译器可以确定。|906318|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There's a limit to allocatable registers. If you outgo it, you just end up with less efficient code.

My take is that if what you do is so important that you have to decide yourself what goes in a register and what doesn't, you should write it using assembly language.

For general purpose languages, I strongly believe that a compiler is better able to decide what goes in a register than a human. The proof being that while you're not sure how many variables you can put in registers, your compiler knows for sure.

blocks|key|2019934|text|在gcc中，register绝对不会被忽略，除非您指定优化选项。使用如下代码测试您的代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2019935|unsigned+int+array[10];

int+n;

#define+REG+register

int+main()
{
++++REG+unsigned+int+a,+b,+c;

++++for+(n+=+0;+n+<+10;+%2B%2Bn){
++++++++c+=+a+%2B+b;
++++++++b+=+a;
++++++++a+=+c;
++++++++array[n]+=+c;
++++}
}|code-block|syntax|javascript|2019936|获取(取决于REG是定义的还是空的)|2019937|​|2019938|📷|atomic|offset|length|2019939|http://picasaweb.google.com/lh/photo/v2hBpl6D-soIdBXUOmAeMw?feat=directlink|2019940|左边显示的是使用寄存器的结果。|2019941|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://lh3.googleusercontent.com/-lIYVP6NLrE8/S0_KnXCRvyI/AAAAAAAAK7g/SxNIkLvBobw/w2120-h1384-no/Screenshot-regs.s.normal%252B%25253A%252Bregs.s.normal-noregs%252B-%252BMeld.png|imageAlt|1|LINK|MUTABLE|url^0|0|0|0|0|0|1|0|0|0|23|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1A|8|@]|9|@$N|1B|O|1C|1|1D]]|A|$]]|$1|P|3|Q|5|6|7|1E|8|@]|9|@$N|1F|O|1G|1|1H]]|A|$]]|$1|R|3|S|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10|11|-4]]|12|$5|13|X|14|A|$15|Q]]]]

In gcc, register is definitely not ignored, unless you specify optimization options.
Testing your code with something like this

<pre><code>unsigned int array[10];

int n;

#define REG register

int main()
{
 REG unsigned int a, b, c;

 for (n = 0; n &lt; 10; ++n){
 c = a + b;
 b = a;
 a = c;
 array[n] = c;
 }
}
</code></pre>

you obtain (depending on whether REG is defined or empty)

<img src="https://lh3.googleusercontent.com/-lIYVP6NLrE8/S0_KnXCRvyI/AAAAAAAAK7g/SxNIkLvBobw/w2120-h1384-no/Screenshot-regs.s.normal%2B%253A%2Bregs.s.normal-noregs%2B-%2BMeld.png" alt="diff">
<a href="http://picasaweb.google.com/lh/photo/v2hBpl6D-soIdBXUOmAeMw?feat=directlink" rel="nofollow noreferrer">http://picasaweb.google.com/lh/photo/v2hBpl6D-soIdBXUOmAeMw?feat=directlink</a>

On the left is shown the result of using registers.

blocks|key|2314975|text|使用register的想法是，您的变量被非常频繁地使用。如果你的变量有任何操作，它都会被复制到一个寄存器中。所以counter+(索引变量)是这个修饰符的候选者。以10年1月15日1:57的迭戈·托雷斯·米兰诺为例，我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2314976|unsigned+int+array[10];++++

int+main()
{
++++register+int+n;
++++unsigned+int+a+=+1,+b+=+2,+c;

++++for+(n+=+0;+n+<+10;+%2B%2Bn){
++++++++c+=+a+%2B+b;
++++++++b+=+a;
++++++++a+=+c;
++++++++array[n]+=+c;
++++}
}|code-block|syntax|javascript|2314977|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The idea of using register is, your variable is used extremely often. If there is any operation with your variable, it will be copied to a register anyway. So counter (index variables) are candidates for this modifier. In the example of Diego Torres Milano from Jan 15 '10 at 1:57 I would make it this way:

<pre><code>unsigned int array[10]; 

int main()
{
 register int n;
 unsigned int a = 1, b = 2, c;

 for (n = 0; n &lt; 10; ++n){
 c = a + b;
 b = a;
 a = c;
 array[n] = c;
 }
}
</code></pre>

I have something like this

<pre><code>register unsigned int a, b, c;
int n;
for (n = 0; n &lt; 10; ++n){
c = a + b
b = a
a = c
array[n] = c;
}
</code></pre>

what it does, it doesn't matter. The code runs quickly the way it is now, slower if the register keyword is removed. However, when I add in register before int n, it actually runs slower than now, but faster than if no registers is used.

Can someone explain this to me? Thanks.

when to use registers in C?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有这样的东西register unsigned int a, b, c;int n;for (n = 0; n < 10; ++n){c = a + bb = aa = carray[n] = c;}不管它做什么，都无关紧要。代码以现在的方式运行得很快，如果删除register关键字，则运行速度会变慢。然而，当我在i...

问在C中什么时候使用寄存器？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中什么时候使用寄存器？EN