blocks|key|1236640|text|取决于您的体系结构。至少对于ARM，编译器可能会发出有条件地执行的指令，并且生成的机器码不会包含分支。不过，我想不出在C程序中明确这一点的好方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1236641|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|$]]

Depends on your architecture. For ARM, at least, the compiler would probably emit conditionally executed instructions and the resulting machine code wouldn't contain a branch. I can't think of a good way to make that explicit in the C program though.

blocks|key|1236643|text|使用三元运算符:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1236644|return+x+<+0+?+0+:+x+>+some_maximum+?+:+some_maximum+:+x;|code-block|syntax|javascript|1236645|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|$]]

Using the ternary operator :)

<pre><code>return x &lt; 0 ? 0 : x &gt; some_maximum ? : some_maximum : x;
</code></pre>

blocks|key|488375|text|x+=+min(max(x,0),100);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|488376|分支很好地隐藏在具有普通名称的函数中。|unstyled|488377|建议创建一个clip_by模板。|488378|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>x = min(max(x,0),100);
</code></pre>

The branching is hidden away nicely inside functions with normal names.

Suggesting to create a clip_by template.

blocks|key|1941127|text|这将依赖于编译器和处理器，但如果您使用?:，它可以转换为条件移动(至少在基于英特尔的处理器上)，它不使用分支。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1941128|x+=+x+<+0+?+0+:+x;++x+=+x+>+max+?+max+:+x;|1941129|这可以使用CMOV指令(参见http://www.intel.com/software/products/documentation/vlin/mergedprojects/analyzer_ec/mergedprojects/reference_olh/mergedProjects/instructions/instruct32_hh/vc35.htm)，该指令的目的是避免分支(从而避免分支预测损失)。|1941130|编辑：您可能会对此thread感兴趣。基准测试表明，条件移动只会在不可预测的分支上带来速度提升，而高度可预测的分支(例如长时间运行的循环)更喜欢标准方法。|BOLD|1941131|entityMap|0|LINK|mutability|MUTABLE|url|http://www.intel.com/software/products/documentation/vlin/mergedprojects/analyzer_ec/mergedprojects/reference_olh/mergedProjects/instructions/instruct32_hh/vc35.htm|1|https://mail.mozilla.org/pipermail/tamarin-devel/2008-April/000455.html^0|J|2|0|0|16|0|5|4|E|4K|0|0|0|2|9|6|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|J|3|K|5|6|7|18|8|@$9|19|A|1A|B|L]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|M|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

This is going to be compiler- and processor-dependent, but if you use <code>?:</code> it can be translated to a conditional move (at least on Intel-based processors) which does not use a branch.

<code>x = x &lt; 0 ? 0 : x;
 x = x &gt; max ? max : x;</code>

This can use the <code>CMOV</code> instruction (see <a href="http://www.intel.com/software/products/documentation/vlin/mergedprojects/analyzer_ec/mergedprojects/reference_olh/mergedProjects/instructions/instruct32_hh/vc35.htm" rel="nofollow noreferrer">http://www.intel.com/software/products/documentation/vlin/mergedprojects/analyzer_ec/mergedprojects/reference_olh/mergedProjects/instructions/instruct32_hh/vc35.htm</a>), whose purpose is to avoid branching (and thus branch prediction penalties).

Edit: this <a href="https://mail.mozilla.org/pipermail/tamarin-devel/2008-April/000455.html" rel="nofollow noreferrer">thread</a> may be of interest to you. Benchmarks show that conditional moves will give you speed gains only on branches that are not very predictable, whereas highly predictable branches (such as that of a long-running loop) prefer the standard approach.

blocks|key|1233664|text|x+=+++((int)(x+>+some_maximum))+*+some_maximum+
++++%2B+((int)(x+>+0+&&+x+<=+some_maximum))+*+x;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1233665|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>x = ((int)(x &gt; some_maximum)) * some_maximum 
 + ((int)(x &gt; 0 &amp;&amp; x &lt;= some_maximum)) * x;
</code></pre>

blocks|key|489840|text|有一些技巧可以找到两个数字中的最小值或最大值，因此您可以使用这些技巧来查找min(max(x,+0),+some_maximum)。来自here|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|489841|y+%5E+((x+%5E+y)+&+-(x+<+y));+//+min(x,+y)
x+%5E+((x+%5E+y)+&+-(x+<+y));+//+max(x,+y)|code-block|syntax|javascript|489842|但是，正如源代码所述，使用常规方法可能会更快，尽管分支|489843|entityMap|0|LINK|mutability|MUTABLE|url|http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax^0|11|S|1W|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

There are bit-tricks to find the minimum or maximum of two numbers, so you could use those to find <code>min(max(x, 0), some_maximum)</code>. From <a href="http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax" rel="noreferrer">here</a>:

<pre><code>y ^ ((x ^ y) &amp; -(x &lt; y)); // min(x, y)
x ^ ((x ^ y) &amp; -(x &lt; y)); // max(x, y)
</code></pre>

As the source states though, it's probably faster to do it the normal way, despite the branch

blocks|key|488422|text|如果可以限制为2的幂(不包括在内)，那么只需使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488423|int+newx+=+x+&+((highest+power+of+2)+-+1)|offset|length|style|CODE|488424|不太确定是处理(如果x<0情况)还是一般情况(x+|488425|488426|entityMap^0|0|0|15|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@$D|O|E|P|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Q|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

If it's possible to limit to powers of 2 (non inclusive), then just go with 

<code>int newx = x &amp; ((highest power of 2) - 1)</code>

not quite sure to handle the (if x &lt; 0 case) or the generic (x &lt; n case)

blocks|key|1236720|text|对于未来类似的问题，bit+hack页面可能会有用：http://graphics.stanford.edu/~seander/bithacks.html。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1236721|由于min和max的bithack已经发布，这里是一个不同的版本：|1236722|//+CHAR_BIT+is+number+of+bits+per+byte.
//+sign+=+1+if+x+<+0,+sign+=+0+otherwise+(according+to+the+page+above)
int+sign+=+(int)((unsigned+int)((int)x)+>>+(sizeof(int)+*+CHAR_BIT+-+1));

int+y+=+(1-sign)*x;+//+if+x+<+0,+then+y+=+0,+else+y+=+x.

//+Depending+on+arch,+the+below+_might_+cause+a+branch.
//+(on+x64+it+does+not+cause+a+branch,+not+sure+about+MIPS)

int+z+=+!(y/some_maximum);+//+if+0+<=+y+<+some_maximum,+z+=+1,+else+z+=+0

int+ret+=+z*y+%2B+(1-z)*some_maximum;+//+if+z+=1,+then+ret+=+y;+else+ret+=+some_maximum.

return+ret;|code-block|syntax|javascript|1236723|我只是尝试了一下，它在我的几个测试用例中都有效。|1236724|这是我的计算机(英特尔拱门)的汇编代码，它没有显示分支。|1236725|int+cap(int+x)
{
00F013A0++push++++++++ebp++
00F013A1++mov+++++++++ebp,esp+
00F013A3++sub+++++++++esp,0FCh+
00F013A9++push++++++++ebx++
00F013AA++push++++++++esi++
00F013AB++push++++++++edi++
00F013AC++lea+++++++++edi,[ebp-0FCh]+
00F013B2++mov+++++++++ecx,3Fh+
00F013B7++mov+++++++++eax,0CCCCCCCCh+
00F013BC++rep+stos++++dword+ptr+es:[edi]+

++++int+some_maximum+=+100;

00F013BE++mov+++++++++dword+ptr+[some_maximum],64h+

++++//+CHAR_BIT+is+number+of+bits+per+byte.+
++++//+sign+=+1+if+x+<+0,+sign+=+0+otherwise+(according+to+the+page+above)+
++++int+sign+=+(int)((unsigned+int)((int)x)+>>+(sizeof(int)+*+CHAR_BIT+-+1));+

00F013C5++mov+++++++++eax,dword+ptr+[x]+
00F013C8++shr+++++++++eax,1Fh+
00F013CB++mov+++++++++dword+ptr+[sign],eax+

++++int+y+=+(1-sign)*x;+//+if+x+<+0,+then+y+=+0,+else+y+=+x.+

00F013CE++mov+++++++++eax,1+
00F013D3++sub+++++++++eax,dword+ptr+[sign]+
00F013D6++imul++++++++eax,dword+ptr+[x]+
00F013DA++mov+++++++++dword+ptr+[y],eax+

++++//+Depending+on+arch,+the+below+_might_+cause+a+branch.+
++++//+(on+x64+it+does+not+cause+a+branch,+not+sure+about+MIPS)+

++++int+z+=+!(y/some_maximum);+//+if+0+<=+y+<+some_maximum,+z+=+1,+else+z+=+0+

00F013DD++mov+++++++++eax,dword+ptr+[y]+
00F013E0++cdq++++++++++++++
00F013E1++idiv++++++++eax,dword+ptr+[some_maximum]+
00F013E4++neg+++++++++eax++
00F013E6++sbb+++++++++eax,eax+
00F013E8++add+++++++++eax,1+
00F013EB++mov+++++++++dword+ptr+[z],eax+

++++int+ret+=+z*y+%2B+(1-z)*some_maximum;+//+if+z+=1,+then+ret+=+y;+else+ret+=+some_maximum.+

00F013EE++mov+++++++++eax,dword+ptr+[z]+
00F013F1++imul++++++++eax,dword+ptr+[y]+
00F013F5++mov+++++++++ecx,1+
00F013FA++sub+++++++++ecx,dword+ptr+[z]+
00F013FD++imul++++++++ecx,dword+ptr+[some_maximum]+
00F01401++add+++++++++eax,ecx+
00F01403++mov+++++++++dword+ptr+[ret],eax+

++++return+ret;+

00F01406++mov+++++++++eax,dword+ptr+[ret]+
}
00F01409++pop+++++++++edi++
00F0140A++pop+++++++++esi++
00F0140B++pop+++++++++ebx++
00F0140C++mov+++++++++esp,ebp+
00F0140E++pop+++++++++ebp++
00F0140F++ret++++++++++++++|1236726|entityMap|0|LINK|mutability|MUTABLE|url|http://graphics.stanford.edu/~seander/bithacks.html^0|Q|1F|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|16|8|@]|9|@]|C|$I|J]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

For future problems like this, the bit hack page might be useful: <a href="http://graphics.stanford.edu/~seander/bithacks.html" rel="nofollow noreferrer">http://graphics.stanford.edu/~seander/bithacks.html</a>. 

Since the bithack for min and max was already posted, here is a different one:

<pre><code>// CHAR_BIT is number of bits per byte.
// sign = 1 if x &lt; 0, sign = 0 otherwise (according to the page above)
int sign = (int)((unsigned int)((int)x) &gt;&gt; (sizeof(int) * CHAR_BIT - 1));

int y = (1-sign)*x; // if x &lt; 0, then y = 0, else y = x.

// Depending on arch, the below _might_ cause a branch.
// (on x64 it does not cause a branch, not sure about MIPS)

int z = !(y/some_maximum); // if 0 &lt;= y &lt; some_maximum, z = 1, else z = 0

int ret = z*y + (1-z)*some_maximum; // if z =1, then ret = y; else ret = some_maximum.

return ret;
</code></pre>

I just tried it out, and it worked for the few test cases i had.

Here is the assembly code from my computer (intel arch) which shows no branches.

<pre><code>int cap(int x)
{
00F013A0 push ebp 
00F013A1 mov ebp,esp 
00F013A3 sub esp,0FCh 
00F013A9 push ebx 
00F013AA push esi 
00F013AB push edi 
00F013AC lea edi,[ebp-0FCh] 
00F013B2 mov ecx,3Fh 
00F013B7 mov eax,0CCCCCCCCh 
00F013BC rep stos dword ptr es:[edi] 

 int some_maximum = 100;

00F013BE mov dword ptr [some_maximum],64h 

 // CHAR_BIT is number of bits per byte. 
 // sign = 1 if x &lt; 0, sign = 0 otherwise (according to the page above) 
 int sign = (int)((unsigned int)((int)x) &gt;&gt; (sizeof(int) * CHAR_BIT - 1)); 

00F013C5 mov eax,dword ptr [x] 
00F013C8 shr eax,1Fh 
00F013CB mov dword ptr [sign],eax 

 int y = (1-sign)*x; // if x &lt; 0, then y = 0, else y = x. 

00F013CE mov eax,1 
00F013D3 sub eax,dword ptr [sign] 
00F013D6 imul eax,dword ptr [x] 
00F013DA mov dword ptr [y],eax 

 // Depending on arch, the below _might_ cause a branch. 
 // (on x64 it does not cause a branch, not sure about MIPS) 

 int z = !(y/some_maximum); // if 0 &lt;= y &lt; some_maximum, z = 1, else z = 0 

00F013DD mov eax,dword ptr [y] 
00F013E0 cdq 
00F013E1 idiv eax,dword ptr [some_maximum] 
00F013E4 neg eax 
00F013E6 sbb eax,eax 
00F013E8 add eax,1 
00F013EB mov dword ptr [z],eax 

 int ret = z*y + (1-z)*some_maximum; // if z =1, then ret = y; else ret = some_maximum. 

00F013EE mov eax,dword ptr [z] 
00F013F1 imul eax,dword ptr [y] 
00F013F5 mov ecx,1 
00F013FA sub ecx,dword ptr [z] 
00F013FD imul ecx,dword ptr [some_maximum] 
00F01401 add eax,ecx 
00F01403 mov dword ptr [ret],eax 

 return ret; 

00F01406 mov eax,dword ptr [ret] 
}
00F01409 pop edi 
00F0140A pop esi 
00F0140B pop ebx 
00F0140C mov esp,ebp 
00F0140E pop ebp 
00F0140F ret 
</code></pre>

blocks|key|489920|text|在C%2B%2B17中，您可以使用std::clamp|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|489921|header+<algorithm>中定义的|489922|blockquote|489923|489924|模板常量表达式常量T&+clamp(常量T&+v，常量T&+lo，常量T&+hi+)；(1)+(自C%2B%2B17以来)+template常量常量T&+clamp(常量T&+v，常量T&+lo，常量T&+hi，比较组件)；(2)+(自C%2B%2B17以来)|489925|489926|489927|如果v比较小于lo，则返回lo；否则，如果hi比较小于v，则返回hi；否则返回v。使用operator<比较这些值。|ordered-list-item|489928|与(1)相同，但使用comp比较这些值。|489929|489930|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/algorithm/clamp^0|D|A|D|A|0|0|7|B|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|I|7|1B|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1D|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1G|8|@]|D|@]|E|$]]|$1|R|3|S|5|Q|7|1H|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

In C++17 you can use <a href="https://en.cppreference.com/w/cpp/algorithm/clamp" rel="nofollow noreferrer"><code>std::clamp</code></a> 

<blockquote>
 Defined in header <code>&lt;algorithm&gt;</code>

<pre><code>template&lt;class T&gt;
constexpr const T&amp; clamp( const T&amp; v, const T&amp; lo, const T&amp; hi ); (1) (since C++17)
template&lt;class T, class Compare&gt;
constexpr const T&amp; clamp( const T&amp; v, const T&amp; lo, const T&amp; hi, Compare comp ); (2) (since C++17)
</code></pre>
 
 <ol>
 <li>If v compares less than lo, returns lo; otherwise if hi compares
 less than v, returns hi; otherwise returns v. Uses operator&lt; to
 compare the values.</li>
 <li>Same as (1), but uses comp to compare the values.</li>
 </ol>
</blockquote>

Just out of curiosity. If I have something like:

<pre><code>if(x &lt; 0)
 x = 0;
if(x &gt; some_maximum)
 x = some_maximum;

return x;
</code></pre>

Is there a way to not branch? This is c++.

Addendum: I mean no branch instructions in the assembly. It's a MIPS architecture.

Is there a way to limit an integer value to a certain range without branching?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

只是出于好奇。如果我有类似这样的东西：if(x < 0) x = 0;if(x > some_maximum) x = some_maximum;return x;有没有不分支的方法？这是c++。附录:我的意思是在程序集中没有分支指令。这是一个MIPS架构。

问有没有一种方法可以将整数值限制在某个范围内而不进行分支？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有一种方法可以将整数值限制在某个范围内而不进行分支？EN