blocks|key|1644539|text|next+=+pow(2,+ceil(log(x)/log(2)));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1644540|它的工作原理是找到要用2乘以得到x的数字(取该数字的对数，然后除以所需基数的对数see+wikipedia+for+more)。然后用ceil进行四舍五入，得到最接近的整数幂。|unstyled|offset|length|1644541|这是一个更通用的目的(即更慢！)方法比其他地方链接的逐位方法更好，但了解数学知识很好，是吧？|1644542|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Logarithm#Change_of_base^0|0|14|M|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@$G|U|H|V|1|W]]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<pre><code>next = pow(2, ceil(log(x)/log(2)));
</code></pre>

This works by finding the number you'd have raise 2 by to get x (take the log of the number, and divide by the log of the desired base, <a href="http://en.wikipedia.org/wiki/Logarithm#Change_of_base" rel="noreferrer">see wikipedia for more</a>). Then round that up with ceil to get the nearest whole number power.

This is a more general purpose (i.e. slower!) method than the bitwise methods linked elsewhere, but good to know the maths, eh?

blocks|key|1429903|text|我认为这也是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1429904|int+power+=+1;
while(power+<+x)
++++power*=2;|code-block|syntax|javascript|1429905|答案是power。|offset|length|style|CODE|1429906|entityMap^0|0|0|3|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I think this works, too:

<pre><code>int power = 1;
while(power &lt; x)
 power*=2;
</code></pre>

And the answer is <code>power</code>.

blocks|key|1644549|text|unsigned+long+upper_power_of_two(unsigned+long+v)
{
++++v--;
++++v+%7C=+v+>>+1;
++++v+%7C=+v+>>+2;
++++v+%7C=+v+>>+4;
++++v+%7C=+v+>>+8;
++++v+%7C=+v+>>+16;
++++v%2B%2B;
++++return+v;

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1644550|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>unsigned long upper_power_of_two(unsigned long v)
{
 v--;
 v |= v &gt;&gt; 1;
 v |= v &gt;&gt; 2;
 v |= v &gt;&gt; 4;
 v |= v &gt;&gt; 8;
 v |= v &gt;&gt; 16;
 v++;
 return v;

}
</code></pre>

blocks|key|1429877|text|如果你使用的是GCC，你可能想看看Lockless+Inc.的Optimizing+the+next_pow2()+function。本页描述了一种使用内置函数builtin_clz()+(计数前导零)，然后直接使用x86+(ia32)汇编指令bsr+(位扫描反转)的方法，就像another+answer的link+to+gamedev+site中所描述的那样。此代码可能比previous+answer中描述的代码更快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1429878|顺便说一句，如果你不打算使用汇编指令和64位数据类型，你可以使用这个|1429879|/**
+*+return+the+smallest+power+of+two+value
+*+greater+than+x
+*
+*+Input+range:++[2..2147483648]
+*+Output+range:+[2..2147483648]
+*
+*/
__attribute__+((const))
static+inline+uint32_t+p2(uint32_t+x)
{
#if+0
++++assert(x+>+1);
++++assert(x+<=+((UINT32_MAX/2)+%2B+1));
#endif

++++return+1+<<+(32+-+__builtin_clz+(x+-+1));
}|code-block|syntax|javascript|1429880|entityMap|0|LINK|mutability|MUTABLE|url|http://locklessinc.com/articles/next_pow2/|1|https://stackoverflow.com/a/466385/611560|2|http://www.gamedev.net/topic/229831-nearest-power-of-2/|3|https://stackoverflow.com/a/466278/611560^0|28|D|3E|3|V|Z|0|3V|E|1|4A|K|2|58|F|3|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]|$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|F|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]|Y|$5|P|Q|R|E|$S|Z]]]]

If you're using GCC, you might want to have a look at <a href="http://locklessinc.com/articles/next_pow2/" rel="noreferrer" title="Optimizing the next_pow() function">Optimizing the next_pow2() function</a> by Lockless Inc.. This page describes a way to use built-in function <code>builtin_clz()</code> (count leading zero) and later use directly x86 (ia32) assembler instruction <code>bsr</code> (bit scan reverse), just like it's described in <a href="https://stackoverflow.com/a/466385/611560" title="answer by mafutrct">another answer</a>'s <a href="http://www.gamedev.net/topic/229831-nearest-power-of-2/" rel="noreferrer" title="Nearest power of 2 on Gamedev.net">link to gamedev site</a>. This code might be faster than those described in <a href="https://stackoverflow.com/a/466278/611560" title="answer by Eclipse">previous answer</a>.

By the way, if you're not going to use assembler instruction and 64bit data type, you can use this

<pre><code>/**
 * return the smallest power of two value
 * greater than x
 *
 * Input range: [2..2147483648]
 * Output range: [2..2147483648]
 *
 */
__attribute__ ((const))
static inline uint32_t p2(uint32_t x)
{
#if 0
 assert(x &gt; 1);
 assert(x &lt;= ((UINT32_MAX/2) + 1));
#endif

 return 1 &lt;&lt; (32 - __builtin_clz (x - 1));
}
</code></pre>

blocks|key|1645083|text|对于任何无符号类型，构建在位旋转的Hacks上：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645084|#include+<climits>
#include+<type_traits>

template+<typename+UnsignedType>
UnsignedType+round_up_to_power_of_2(UnsignedType+v)+{
++static_assert(std::is_unsigned<UnsignedType>::value,+"Only+works+for+unsigned+types");
++v--;
++for+(size_t+i+=+1;+i+<+sizeof(v)+*+CHAR_BIT;+i+*=+2)+//Prefer+size_t+"Warning+comparison+between+signed+and+unsigned+integer"
++{
++++v+%7C=+v+>>+i;
++}
++return+%2B%2Bv;
}|code-block|syntax|javascript|1645085|实际上没有循环，因为编译器在编译时知道迭代的次数。|1645086|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For any unsigned type, building on the Bit Twiddling Hacks:

<pre><code>#include &lt;climits&gt;
#include &lt;type_traits&gt;

template &lt;typename UnsignedType&gt;
UnsignedType round_up_to_power_of_2(UnsignedType v) {
 static_assert(std::is_unsigned&lt;UnsignedType&gt;::value, "Only works for unsigned types");
 v--;
 for (size_t i = 1; i &lt; sizeof(v) * CHAR_BIT; i *= 2) //Prefer size_t "Warning comparison between signed and unsigned integer"
 {
 v |= v &gt;&gt; i;
 }
 return ++v;
}
</code></pre>

There isn't really a loop there as the compiler knows at compile time the number of iterations.

blocks|key|1430729|text|尽管这个问题在这里被标记为c，但我的五分钱。幸运的是，C%2B%2B+20将包括std::ceil2和std::floor2+(参见here)。它是consexpr模板函数，当前的GCC+implementation使用位移位，可以处理任何整型的无符号类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1430730|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/header/bit|1|https://github.com/gcc-mirror/gcc/blob/master/libstdc%252B%252B-v3/include/std/bit^0|D|1|10|A|1B|B|1Y|8|1Q|4|0|2E|I|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

Despite the question is tagged as <code>c</code> here my five cents. Lucky us, C++ 20 would include <code>std::ceil2</code> and <code>std::floor2</code> (see <a href="https://en.cppreference.com/w/cpp/header/bit" rel="noreferrer">here</a>). It is <code>consexpr</code> template functions, current <a href="https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/std/bit" rel="noreferrer">GCC implementation</a> uses bitshifting and works with any integral unsigned type.

blocks|key|1429810|text|对于IEEE浮点数，你可以这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1429811|int+next_power_of_two(float+a_F){
++++int+f+=+*(int*)&a_F;
++++int+b+=+f+<<+9+!=+0;+//+If+we're+a+power+of+two+this+is+0,+otherwise+this+is+1

++++f+>>=+23;+//+remove+factional+part+of+floating+point+number
++++f+-=+127;+//+subtract+127+(the+bias)+from+the+exponent

++++//+adds+one+to+the+exponent+if+were+not+a+power+of+two,+
++++//+then+raises+our+new+exponent+to+the+power+of+two+again.
++++return+(1+<<+(f+%2B+b));+
}|code-block|syntax|javascript|1429812|如果您需要整数解决方案，并且能够使用内联汇编，BSR将在x86上为您提供整数的log2。它计算设置了多少右位，这恰好等于该数字的log2。其他处理器(通常)也有类似的指令，例如CLZ，根据编译器的不同，可能会有一个内部指令为您完成这项工作。|1429813|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For IEEE floats you'd be able to do something like this.

<pre><code>int next_power_of_two(float a_F){
 int f = *(int*)&amp;a_F;
 int b = f &lt;&lt; 9 != 0; // If we're a power of two this is 0, otherwise this is 1

 f &gt;&gt;= 23; // remove factional part of floating point number
 f -= 127; // subtract 127 (the bias) from the exponent

 // adds one to the exponent if were not a power of two, 
 // then raises our new exponent to the power of two again.
 return (1 &lt;&lt; (f + b)); 
}
</code></pre>

If you need an integer solution and you're able to use inline assembly, BSR will give you the log2 of an integer on the x86. It counts how many right bits are set, which is exactly equal to the log2 of that number. Other processors have similar instructions (often), such as CLZ and depending on your compiler there might be an intrinsic available to do the work for you.

blocks|key|1430219|text|在x86中，您可以使用sse4位操作指令来提高速度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430220|//assume+input+is+in+eax
popcnt+edx,eax
lzcnt+ecx,eax
cmp+edx,1
jle+@done+++++++//popcnt+says+its+a+power+of+2,+return+input+unchanged
mov+eax,2
shl+eax,cl
@done:+rep+ret|code-block|syntax|javascript|1430221|在c中，你可以使用匹配的内部函数。|1430222|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In x86 you can use the sse4 bit manipulation instructions to make it fast.

<pre><code>//assume input is in eax
popcnt edx,eax
lzcnt ecx,eax
cmp edx,1
jle @done //popcnt says its a power of 2, return input unchanged
mov eax,2
shl eax,cl
@done: rep ret
</code></pre>

In c you can use the matching intrinsics.

blocks|key|1430026|text|/*
**+http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
*/
#define+__LOG2A(s)+((s+&0xffffffff00000000)+?+(32+%2B__LOG2B(s+>>32)):+(__LOG2B(s)))
#define+__LOG2B(s)+((s+&0xffff0000)+++++++++?+(16+%2B__LOG2C(s+>>16)):+(__LOG2C(s)))
#define+__LOG2C(s)+((s+&0xff00)+++++++++++++?+(8++%2B__LOG2D(s+>>8))+:+(__LOG2D(s)))
#define+__LOG2D(s)+((s+&0xf0)+++++++++++++++?+(4++%2B__LOG2E(s+>>4))+:+(__LOG2E(s)))
#define+__LOG2E(s)+((s+&0xc)++++++++++++++++?+(2++%2B__LOG2F(s+>>2))+:+(__LOG2F(s)))
#define+__LOG2F(s)+((s+&0x2)++++++++++++++++?+(1)++++++++++++++++++:+(0))

#define+LOG2_UINT64+__LOG2A
#define+LOG2_UINT32+__LOG2B
#define+LOG2_UINT16+__LOG2C
#define+LOG2_UINT8++__LOG2D

static+inline+uint64_t
next_power_of_2(uint64_t+i)
{
#if+defined(__GNUC__)
++++return+1UL+<<(1+%2B(63+-__builtin_clzl(i+-1)));
#else
++++i+=i+-1;
++++i+=LOG2_UINT64(i);
++++return+1UL+<<(1+%2Bi);
#endif
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1430027|如果您不想冒险进入未定义行为的领域，则输入值必须介于1和2%5E63之间。宏对于在编译时设置常量也很有用。|unstyled|1430028|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>/*
** http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
*/
#define __LOG2A(s) ((s &amp;0xffffffff00000000) ? (32 +__LOG2B(s &gt;&gt;32)): (__LOG2B(s)))
#define __LOG2B(s) ((s &amp;0xffff0000) ? (16 +__LOG2C(s &gt;&gt;16)): (__LOG2C(s)))
#define __LOG2C(s) ((s &amp;0xff00) ? (8 +__LOG2D(s &gt;&gt;8)) : (__LOG2D(s)))
#define __LOG2D(s) ((s &amp;0xf0) ? (4 +__LOG2E(s &gt;&gt;4)) : (__LOG2E(s)))
#define __LOG2E(s) ((s &amp;0xc) ? (2 +__LOG2F(s &gt;&gt;2)) : (__LOG2F(s)))
#define __LOG2F(s) ((s &amp;0x2) ? (1) : (0))

#define LOG2_UINT64 __LOG2A
#define LOG2_UINT32 __LOG2B
#define LOG2_UINT16 __LOG2C
#define LOG2_UINT8 __LOG2D

static inline uint64_t
next_power_of_2(uint64_t i)
{
#if defined(__GNUC__)
 return 1UL &lt;&lt;(1 +(63 -__builtin_clzl(i -1)));
#else
 i =i -1;
 i =LOG2_UINT64(i);
 return 1UL &lt;&lt;(1 +i);
#endif
}
</code></pre>

If you do not want to venture into the realm of undefined behaviour the input value must be between 1 and 2^63. The macro is also useful to set constant at compile time.

blocks|key|1645007|text|为了完整起见，这里是一个采用bog标准C的浮点实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645008|double+next_power_of_two(double+value)+{
++++int+exp;
++++if(frexp(value,+&exp)+==+0.5)+{
++++++++//+Omit+this+case+to+round+precise+powers+of+two+up+to+the+*next*+power
++++++++return+value;
++++}
++++return+ldexp(1.0,+exp);
}|code-block|syntax|javascript|1645009|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|$]]

For completeness here is a floating-point implementation in bog-standard C.

<pre><code>double next_power_of_two(double value) {
 int exp;
 if(frexp(value, &amp;exp) == 0.5) {
 // Omit this case to round precise powers of two up to the *next* power
 return value;
 }
 return ldexp(1.0, exp);
}
</code></pre>

blocks|key|1645358|text|一个高效的微软(例如，Visual+Studio2017)特定于C/+C%2B%2B的整数输入解决方案。在检查最高有效的1位的位置之前，通过递减来处理输入与2的幂值完全匹配的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645359|inline+unsigned+int+ExpandToPowerOf2(unsigned+int+Value)
{
++++unsigned+long+Index;
++++_BitScanReverse(&Index,+Value+-+1);
++++return+(1U+<<+(Index+%2B+1));
}

//+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

#if+defined(WIN64)+//+The+_BitScanReverse64+intrinsic+is+only+available+for+64+bit+builds+because+it+depends+on+x64

inline+unsigned+long+long+ExpandToPowerOf2(unsigned+long+long+Value)
{
++++unsigned+long+Index;
++++_BitScanReverse64(&Index,+Value+-+1);
++++return+(1ULL+<<+(Index+%2B+1));
}

#endif|code-block|syntax|javascript|1645360|这将为英特尔处理器生成5条左右的内联指令，如下所示：|1645361|dec+eax
bsr+rcx,+rax
inc+ecx
mov+eax,+1
shl+rax,+cl|1645362|显然，Visual+Studio+C%2B%2B编译器并没有针对编译时值对此进行优化，但它并不像是有很多指令。|1645363|编辑：|1645364|如果您希望输入值1产生1+(2的零次方)，对上面代码的小修改仍然会生成没有分支的直通指令。|1645365|inline+unsigned+int+ExpandToPowerOf2(unsigned+int+Value)
{
++++unsigned+long+Index;
++++_BitScanReverse(&Index,+--Value);
++++if+(Value+==+0)
++++++++Index+=+(unsigned+long)+-1;
++++return+(1U+<<+(Index+%2B+1));
}|1645366|只生成更多的几条指令。诀窍是索引可以被一个test替换，后面跟着一条cmove指令。|1645367|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|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|$]]

An efficient Microsoft (e.g., Visual Studio 2017) specific solution in C / C++ for integer input. Handles the case of the input exactly matching a power of two value by decrementing before checking the location of the most significant 1 bit.

<pre><code>inline unsigned int ExpandToPowerOf2(unsigned int Value)
{
 unsigned long Index;
 _BitScanReverse(&amp;Index, Value - 1);
 return (1U &lt;&lt; (Index + 1));
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#if defined(WIN64) // The _BitScanReverse64 intrinsic is only available for 64 bit builds because it depends on x64

inline unsigned long long ExpandToPowerOf2(unsigned long long Value)
{
 unsigned long Index;
 _BitScanReverse64(&amp;Index, Value - 1);
 return (1ULL &lt;&lt; (Index + 1));
}

#endif
</code></pre>

This generates 5 or so inlined instructions for an Intel processor similar to the following:

<pre><code>dec eax
bsr rcx, rax
inc ecx
mov eax, 1
shl rax, cl
</code></pre>

Apparently the Visual Studio C++ compiler isn't coded to optimize this for compile-time values, but it's not like there are a whole lot of instructions there.

Edit:

If you want an input value of 1 to yield 1 (2 to the zeroth power), a small modification to the above code still generates straight through instructions with no branch.

<pre><code>inline unsigned int ExpandToPowerOf2(unsigned int Value)
{
 unsigned long Index;
 _BitScanReverse(&amp;Index, --Value);
 if (Value == 0)
 Index = (unsigned long) -1;
 return (1U &lt;&lt; (Index + 1));
}
</code></pre>

Generates just a few more instructions. The trick is that Index can be replaced by a test followed by a cmove instruction.

blocks|key|1430584|text|这是我在C中的解决方案。希望这能对你有所帮助！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430585|int+next_power_of_two(int+n)+{
++++int+i+=+0;
++++for+(--n;+n+>+0;+n+>>=+1)+{
++++++++i%2B%2B;
++++}
++++return+1+<<+i;
}|code-block|syntax|javascript|1430586|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|$]]

Here's my solution in C. Hope this helps!

<pre><code>int next_power_of_two(int n) {
 int i = 0;
 for (--n; n &gt; 0; n &gt;&gt;= 1) {
 i++;
 }
 return 1 &lt;&lt; i;
}
</code></pre>

blocks|key|1646044|text|用于C%2B%2B14的constexpr版本的clp2|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1646045|#include+<iostream>
#include+<type_traits>

//+Closest+least+power+of+2+minus+1.+Returns+0+if+n+=+0.
template+<typename+UInt,+std::enable_if_t<std::is_unsigned<UInt>::value,int>+=+0>
++constexpr+UInt+clp2m1(UInt+n,+unsigned+i+=+1)+noexcept
++++{+return+i+<+sizeof(UInt)+*+8+?+clp2m1(UInt(n+%7C+(n+>>+i)),i+<<+1)+:+n;+}

///+Closest+least+power+of+2+minus+1.+Returns+0+if+n+<=+0.
template+<typename+Int,+std::enable_if_t<std::is_integral<Int>::value+&&+std::is_signed<Int>::value,int>+=+0>
++constexpr+auto+clp2m1(Int+n)+noexcept
++++{+return+clp2m1(std::make_unsigned_t<Int>(n+<=+0+?+0+:+n));+}

///+Closest+least+power+of+2.+Returns+2%5EN:+2%5E(N-1)+<+n+<=+2%5EN.+Returns+0+if+n+<=+0.
template+<typename+Int,+std::enable_if_t<std::is_integral<Int>::value,int>+=+0>
++constexpr+auto+clp2(Int+n)+noexcept
++++{+return+clp2m1(std::make_unsigned_t<Int>(n-1))+%2B+1;+}

///+Next+power+of+2.+Returns+2%5EN:+2%5E(N-1)+<=+n+<+2%5EN.+Returns+1+if+n+=+0.+Returns+0+if+n+<+0.
template+<typename+Int,+std::enable_if_t<std::is_integral<Int>::value,int>+=+0>
++constexpr+auto+np2(Int+n)+noexcept
++++{+return+clp2m1(std::make_unsigned_t<Int>(n))+%2B+1;+}

template+<typename+T>
++void+test(T+v)+{+std::cout+<<+clp2(v)+<<+std::endl;+}

int+main()
{
++++test(-5);++++++++++++++++++++++++++//+0
++++test(0);+++++++++++++++++++++++++++//+0
++++test(8);+++++++++++++++++++++++++++//+8
++++test(31);++++++++++++++++++++++++++//+32
++++test(33);++++++++++++++++++++++++++//+64
++++test(789);+++++++++++++++++++++++++//+1024
++++test(char(260));+++++++++++++++++++//+4
++++test(unsigned(-1)+-+1);++++++++++++//+0
++++test<long+long>(unsigned(-1)+-+1);+//+4294967296

++++return+0;
}|code-block|syntax|javascript|1646046|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|$]]

constexpr version of clp2 for C++14
<pre><code>#include &lt;iostream&gt;
#include &lt;type_traits&gt;

// Closest least power of 2 minus 1. Returns 0 if n = 0.
template &lt;typename UInt, std::enable_if_t&lt;std::is_unsigned&lt;UInt&gt;::value,int&gt; = 0&gt;
 constexpr UInt clp2m1(UInt n, unsigned i = 1) noexcept
 { return i &lt; sizeof(UInt) * 8 ? clp2m1(UInt(n | (n &gt;&gt; i)),i &lt;&lt; 1) : n; }

/// Closest least power of 2 minus 1. Returns 0 if n &lt;= 0.
template &lt;typename Int, std::enable_if_t&lt;std::is_integral&lt;Int&gt;::value &amp;&amp; std::is_signed&lt;Int&gt;::value,int&gt; = 0&gt;
 constexpr auto clp2m1(Int n) noexcept
 { return clp2m1(std::make_unsigned_t&lt;Int&gt;(n &lt;= 0 ? 0 : n)); }

/// Closest least power of 2. Returns 2^N: 2^(N-1) &lt; n &lt;= 2^N. Returns 0 if n &lt;= 0.
template &lt;typename Int, std::enable_if_t&lt;std::is_integral&lt;Int&gt;::value,int&gt; = 0&gt;
 constexpr auto clp2(Int n) noexcept
 { return clp2m1(std::make_unsigned_t&lt;Int&gt;(n-1)) + 1; }

/// Next power of 2. Returns 2^N: 2^(N-1) &lt;= n &lt; 2^N. Returns 1 if n = 0. Returns 0 if n &lt; 0.
template &lt;typename Int, std::enable_if_t&lt;std::is_integral&lt;Int&gt;::value,int&gt; = 0&gt;
 constexpr auto np2(Int n) noexcept
 { return clp2m1(std::make_unsigned_t&lt;Int&gt;(n)) + 1; }

template &lt;typename T&gt;
 void test(T v) { std::cout &lt;&lt; clp2(v) &lt;&lt; std::endl; }

int main()
{
 test(-5); // 0
 test(0); // 0
 test(8); // 8
 test(31); // 32
 test(33); // 64
 test(789); // 1024
 test(char(260)); // 4
 test(unsigned(-1) - 1); // 0
 test&lt;long long&gt;(unsigned(-1) - 1); // 4294967296

 return 0;
}
</code></pre>

blocks|key|1429956|text|许多处理器架构支持log+base+2或非常类似的操作--+count+leading+zeros。许多编译器都有针对它的内部机制。请参阅https://en.wikipedia.org/wiki/Find_first_set|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1429957|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Find_first_set^0|9|A|U|J|1X|18|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Many processor architectures support <code>log base 2</code> or very similar operation – <code>count leading zeros</code>. Many compilers have intrinsics for it. See <a href="https://en.wikipedia.org/wiki/Find_first_set" rel="nofollow">https://en.wikipedia.org/wiki/Find_first_set</a>

blocks|key|1430322|text|假设你有一个很好的编译器&它可以在这一点上完成比我更多的工作，但不管怎样，这是有效的！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430323|++++//+http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
++++#define+SH1(v)++((v-1)+%7C+((v-1)+>>+1))++++++++++++//+accidently+came+up+w/+this...
++++#define+SH2(v)++((v)+%7C+((v)+>>+2))
++++#define+SH4(v)++((v)+%7C+((v)+>>+4))
++++#define+SH8(v)++((v)+%7C+((v)+>>+8))
++++#define+SH16(v)+((v)+%7C+((v)+>>+16))
++++#define+OP(v)+(SH16(SH8(SH4(SH2(SH1(v))))))+++++++++

++++#define+CB0(v)+++((v)+-+(((v)+>>+1)+&+0x55555555))
++++#define+CB1(v)+++(((v)+&+0x33333333)+%2B+(((v)+>>+2)+&+0x33333333))
++++#define+CB2(v)+++((((v)+%2B+((v)+>>+4)+&+0xF0F0F0F)+*+0x1010101)+>>+24)
++++#define+CBSET(v)+(CB2(CB1(CB0((v)))))
++++#define+FLOG2(v)+(CBSET(OP(v)))|code-block|syntax|javascript|1430324|测试代码如下：|1430325|#include+<iostream>

using+namespace+std;

//+http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
#define+SH1(v)++((v-1)+%7C+((v-1)+>>+1))++//+accidently+guess+this...
#define+SH2(v)++((v)+%7C+((v)+>>+2))
#define+SH4(v)++((v)+%7C+((v)+>>+4))
#define+SH8(v)++((v)+%7C+((v)+>>+8))
#define+SH16(v)+((v)+%7C+((v)+>>+16))
#define+OP(v)+(SH16(SH8(SH4(SH2(SH1(v))))))+++++++++

#define+CB0(v)+++((v)+-+(((v)+>>+1)+&+0x55555555))
#define+CB1(v)+++(((v)+&+0x33333333)+%2B+(((v)+>>+2)+&+0x33333333))
#define+CB2(v)+++((((v)+%2B+((v)+>>+4)+&+0xF0F0F0F)+*+0x1010101)+>>+24)
#define+CBSET(v)+(CB2(CB1(CB0((v)))))
#define+FLOG2(v)+(CBSET(OP(v)))+

#define+SZ4+++++++++FLOG2(4)
#define+SZ6+++++++++FLOG2(6)
#define+SZ7+++++++++FLOG2(7)
#define+SZ8+++++++++FLOG2(8)+
#define+SZ9+++++++++FLOG2(9)
#define+SZ16++++++++FLOG2(16)
#define+SZ17++++++++FLOG2(17)
#define+SZ127+++++++FLOG2(127)
#define+SZ1023++++++FLOG2(1023)
#define+SZ1024++++++FLOG2(1024)
#define+SZ2_17++++++FLOG2((1ul+<<+17))++//+
#define+SZ_LOG2+++++FLOG2(SZ)

#define+DBG_PRINT(x)+do+{+std::printf("Line:%25-4d"+"++%2510s+=+%25-10d\n",+__LINE__,+#x,+x);+}+while(0);

uint32_t+arrTble[FLOG2(63)];

int+main(){
++++int8_t+n;

++++DBG_PRINT(SZ4);++++
++++DBG_PRINT(SZ6);++++
++++DBG_PRINT(SZ7);++++
++++DBG_PRINT(SZ8);++++
++++DBG_PRINT(SZ9);+
++++DBG_PRINT(SZ16);
++++DBG_PRINT(SZ17);
++++DBG_PRINT(SZ127);
++++DBG_PRINT(SZ1023);
++++DBG_PRINT(SZ1024);
++++DBG_PRINT(SZ2_17);

++++return(0);
}|1430326|输出：|1430327|Line:39+++++++++++SZ4+=+2
Line:40+++++++++++SZ6+=+3
Line:41+++++++++++SZ7+=+3
Line:42+++++++++++SZ8+=+3
Line:43+++++++++++SZ9+=+4
Line:44++++++++++SZ16+=+4
Line:45++++++++++SZ17+=+5
Line:46+++++++++SZ127+=+7
Line:47++++++++SZ1023+=+10
Line:48++++++++SZ1024+=+10
Line:49++++++++SZ2_16+=+17|1430328|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|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Assuming you have a good compiler &amp; it can do the bit twiddling before hand thats above me at this point, but anyway this works!!!

<pre><code> // http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
 #define SH1(v) ((v-1) | ((v-1) &gt;&gt; 1)) // accidently came up w/ this...
 #define SH2(v) ((v) | ((v) &gt;&gt; 2))
 #define SH4(v) ((v) | ((v) &gt;&gt; 4))
 #define SH8(v) ((v) | ((v) &gt;&gt; 8))
 #define SH16(v) ((v) | ((v) &gt;&gt; 16))
 #define OP(v) (SH16(SH8(SH4(SH2(SH1(v)))))) 

 #define CB0(v) ((v) - (((v) &gt;&gt; 1) &amp; 0x55555555))
 #define CB1(v) (((v) &amp; 0x33333333) + (((v) &gt;&gt; 2) &amp; 0x33333333))
 #define CB2(v) ((((v) + ((v) &gt;&gt; 4) &amp; 0xF0F0F0F) * 0x1010101) &gt;&gt; 24)
 #define CBSET(v) (CB2(CB1(CB0((v)))))
 #define FLOG2(v) (CBSET(OP(v)))
</code></pre>

Test code below:

<pre><code>#include &lt;iostream&gt;

using namespace std;

// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
#define SH1(v) ((v-1) | ((v-1) &gt;&gt; 1)) // accidently guess this...
#define SH2(v) ((v) | ((v) &gt;&gt; 2))
#define SH4(v) ((v) | ((v) &gt;&gt; 4))
#define SH8(v) ((v) | ((v) &gt;&gt; 8))
#define SH16(v) ((v) | ((v) &gt;&gt; 16))
#define OP(v) (SH16(SH8(SH4(SH2(SH1(v)))))) 

#define CB0(v) ((v) - (((v) &gt;&gt; 1) &amp; 0x55555555))
#define CB1(v) (((v) &amp; 0x33333333) + (((v) &gt;&gt; 2) &amp; 0x33333333))
#define CB2(v) ((((v) + ((v) &gt;&gt; 4) &amp; 0xF0F0F0F) * 0x1010101) &gt;&gt; 24)
#define CBSET(v) (CB2(CB1(CB0((v)))))
#define FLOG2(v) (CBSET(OP(v))) 

#define SZ4 FLOG2(4)
#define SZ6 FLOG2(6)
#define SZ7 FLOG2(7)
#define SZ8 FLOG2(8) 
#define SZ9 FLOG2(9)
#define SZ16 FLOG2(16)
#define SZ17 FLOG2(17)
#define SZ127 FLOG2(127)
#define SZ1023 FLOG2(1023)
#define SZ1024 FLOG2(1024)
#define SZ2_17 FLOG2((1ul &lt;&lt; 17)) // 
#define SZ_LOG2 FLOG2(SZ)

#define DBG_PRINT(x) do { std::printf("Line:%-4d" " %10s = %-10d\n", __LINE__, #x, x); } while(0);

uint32_t arrTble[FLOG2(63)];

int main(){
 int8_t n;

 DBG_PRINT(SZ4); 
 DBG_PRINT(SZ6); 
 DBG_PRINT(SZ7); 
 DBG_PRINT(SZ8); 
 DBG_PRINT(SZ9); 
 DBG_PRINT(SZ16);
 DBG_PRINT(SZ17);
 DBG_PRINT(SZ127);
 DBG_PRINT(SZ1023);
 DBG_PRINT(SZ1024);
 DBG_PRINT(SZ2_17);

 return(0);
}
</code></pre>

Outputs:

<pre><code>Line:39 SZ4 = 2
Line:40 SZ6 = 3
Line:41 SZ7 = 3
Line:42 SZ8 = 3
Line:43 SZ9 = 4
Line:44 SZ16 = 4
Line:45 SZ17 = 5
Line:46 SZ127 = 7
Line:47 SZ1023 = 10
Line:48 SZ1024 = 10
Line:49 SZ2_16 = 17
</code></pre>

blocks|key|1645299|text|我试着得到最接近的2的低次幂，并制作了这个函数。希望它能帮助you.Just将最近的低位数乘以2，得到最接近的2的高次幂|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645300|int+nearest_upper_power(int+number){
++++int+temp=number;
++++while((number&(number-1))!=0){
++++++++temp<<=1;
++++++++number&=temp;
++++}
++++//Here+number+is+closest+lower+power+
++++number*=2;
++++return+number;
}|code-block|syntax|javascript|1645301|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|$]]

I'm trying to get nearest lower power of 2 and made this function. May it help you.Just multiplied nearest lower number times 2 to get nearest upper power of 2

<pre><code>int nearest_upper_power(int number){
 int temp=number;
 while((number&amp;(number-1))!=0){
 temp&lt;&lt;=1;
 number&amp;=temp;
 }
 //Here number is closest lower power 
 number*=2;
 return number;
}
</code></pre>

blocks|key|1430511|text|改编了保罗·迪克森对Excel的回答，效果非常好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430512|+=POWER(2,CEILING.MATH(LOG(A1)/LOG(2)))|code-block|syntax|javascript|1430513|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|$]]

Adapted Paul Dixon's answer to Excel, this works perfectly.

<pre><code> =POWER(2,CEILING.MATH(LOG(A1)/LOG(2)))
</code></pre>

blocks|key|1430550|text|@YannDroneaud+answer的变体对x==1有效，仅适用于x86平台、编译器、gcc或clang：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1430551|__attribute__+((const))
static+inline+uint32_t+p2(uint32_t+x)
{
#if+0
++++assert(x+>+0);
++++assert(x+<=+((UINT32_MAX/2)+%2B+1));
#endif
++int+clz;
++uint32_t+xm1+=+x-1;
++asm(
++++"lzcnt+%251,%250"
++++:"=r"+(clz)
++++:"rm"+(xm1)
++++:"cc"
++++);
++++return+1+<<+(32+-+clz);
}|code-block|syntax|javascript|1430552|entityMap^0|O|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

A variant of @YannDroneaud answer valid for <code>x==1</code>, only for x86 plateforms, compilers, gcc or clang:

<pre><code>__attribute__ ((const))
static inline uint32_t p2(uint32_t x)
{
#if 0
 assert(x &gt; 0);
 assert(x &lt;= ((UINT32_MAX/2) + 1));
#endif
 int clz;
 uint32_t xm1 = x-1;
 asm(
 "lzcnt %1,%0"
 :"=r" (clz)
 :"rm" (xm1)
 :"cc"
 );
 return 1 &lt;&lt; (32 - clz);
}
</code></pre>

blocks|key|1430806|text|如果输入是一个常量表达式，下面是我用来使它成为常量表达式的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430807|#define+uptopow2_0(v)+((v)+-+1)
#define+uptopow2_1(v)+(uptopow2_0(v)+%7C+uptopow2_0(v)+>>+1)
#define+uptopow2_2(v)+(uptopow2_1(v)+%7C+uptopow2_1(v)+>>+2)
#define+uptopow2_3(v)+(uptopow2_2(v)+%7C+uptopow2_2(v)+>>+4)
#define+uptopow2_4(v)+(uptopow2_3(v)+%7C+uptopow2_3(v)+>>+8)
#define+uptopow2_5(v)+(uptopow2_4(v)+%7C+uptopow2_4(v)+>>+16)

#define+uptopow2(v)+(uptopow2_5(v)+%2B+1)++/*+this+is+the+one+programmer+uses+*/|code-block|syntax|javascript|1430808|举个例子，一个表达式如下：|1430809|uptopow2(sizeof+(struct+foo))|1430810|将会很好地减少到一个常数。|1430811|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is what I'm using to have this be a constant expression, if the input is a constant expression.

<pre><code>#define uptopow2_0(v) ((v) - 1)
#define uptopow2_1(v) (uptopow2_0(v) | uptopow2_0(v) &gt;&gt; 1)
#define uptopow2_2(v) (uptopow2_1(v) | uptopow2_1(v) &gt;&gt; 2)
#define uptopow2_3(v) (uptopow2_2(v) | uptopow2_2(v) &gt;&gt; 4)
#define uptopow2_4(v) (uptopow2_3(v) | uptopow2_3(v) &gt;&gt; 8)
#define uptopow2_5(v) (uptopow2_4(v) | uptopow2_4(v) &gt;&gt; 16)

#define uptopow2(v) (uptopow2_5(v) + 1) /* this is the one programmer uses */
</code></pre>

So for instance, an expression like:

<pre><code>uptopow2(sizeof (struct foo))
</code></pre>

will nicely reduce to a constant.

blocks|key|1430887|text|您可能会发现以下澄清对您的目的有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430888|​|1430889|📷|atomic|offset|length|1430890|1430891|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/e5dc72f135d7f1958764cec0c7c7cc87.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@$G|V|H|W|1|X]]|A|$]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

You might find the following clarification to be helpful towards your purpose:

<a href="https://i.stack.imgur.com/V6fin.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/V6fin.png" alt=""></a>

blocks|key|1431032|text|g%2B%2B编译器提供了一个计算前导零的内置函数__builtin_clz：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1431033|所以我们可以这样做：|1431034|int+nextPowerOfTwo(unsigned+int+x)+{
++return+1+<<+sizeof(x)*8+-+__builtin_clz(x);
}

int+main+()+{
++std::cout+<<+nextPowerOfTwo(7)++<<+std::endl;
++std::cout+<<+nextPowerOfTwo(31)+<<+std::endl;
++std::cout+<<+nextPowerOfTwo(33)+<<+std::endl;
++std::cout+<<+nextPowerOfTwo(8)++<<+std::endl;
++std::cout+<<+nextPowerOfTwo(91)+<<+std::endl;
++
++return+0;
}|code-block|syntax|javascript|1431035|结果：|1431036|8
32
64
16
128|1431037|但请注意，对于x+==+0，__builtin_clz返回是未定义的。|offset|length|style|CODE|1431038|entityMap^0|0|0|0|0|0|7|6|E|D|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

The g++ compiler provides a builtin function __builtin_clz that counts leading zeros:
So we could do:
<pre class="lang-cpp prettyprint-override"><code>int nextPowerOfTwo(unsigned int x) {
 return 1 &lt;&lt; sizeof(x)*8 - __builtin_clz(x);
}

int main () {
 std::cout &lt;&lt; nextPowerOfTwo(7) &lt;&lt; std::endl;
 std::cout &lt;&lt; nextPowerOfTwo(31) &lt;&lt; std::endl;
 std::cout &lt;&lt; nextPowerOfTwo(33) &lt;&lt; std::endl;
 std::cout &lt;&lt; nextPowerOfTwo(8) &lt;&lt; std::endl;
 std::cout &lt;&lt; nextPowerOfTwo(91) &lt;&lt; std::endl;
 
 return 0;
}
</code></pre>
Results:
<pre><code>8
32
64
16
128
</code></pre>
But note that, for <code>x == 0</code>, <code>__builtin_clz</code> return is undefined.

blocks|key|1429753|text|如果您需要它来处理与OpenGL相关的内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1429754|/*+Compute+the+nearest+power+of+2+number+that+is+
+*+less+than+or+equal+to+the+value+passed+in.+
+*/
static+GLuint+
nearestPower(+GLuint+value+)
{
++++int+i+=+1;

++++if+(value+==+0)+return+-1;++++++/*+Error!+*/
++++for+(;;)+{
+++++++++if+(value+==+1)+return+i;
+++++++++else+if+(value+==+3)+return+i*4;
+++++++++value+>>=+1;+i+*=+2;
++++}
}|code-block|syntax|javascript|1429755|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|$]]

If you need it for OpenGL related stuff:

<pre><code>/* Compute the nearest power of 2 number that is 
 * less than or equal to the value passed in. 
 */
static GLuint 
nearestPower( GLuint value )
{
 int i = 1;

 if (value == 0) return -1; /* Error! */
 for (;;) {
 if (value == 1) return i;
 else if (value == 3) return i*4;
 value &gt;&gt;= 1; i *= 2;
 }
}
</code></pre>

blocks|key|1430930|text|将其转换为浮点型，然后使用.hex()，它显示标准化的IEEE表示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1430931|>>>+float(789).hex()+'0x1.8a80000000000p%2B9'|offset|length|style|CODE|1430932|然后提取指数并加1。|1430933|>>>+int(float(789).hex().split('p%2B')[1])+%2B+1+10|1430934|并将2的幂。|1430935|>>>+2+**+(int(float(789).hex().split('p%2B')[1])+%2B+1)+1024|1430936|entityMap^0|0|0|17|0|0|0|1B|0|0|0|1K|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

Convert it to a float and then use .hex() which shows the normalized IEEE representation.

<code>&gt;&gt;&gt; float(789).hex()
'0x1.8a80000000000p+9'
</code>

Then just extract the exponent and add 1.

<code>&gt;&gt;&gt; int(float(789).hex().split('p+')[1]) + 1
10
</code>

And raise 2 to this power.

<code>&gt;&gt;&gt; 2 ** (int(float(789).hex().split('p+')[1]) + 1)
1024
</code>

blocks|key|1645853|text|import+sys


def+is_power2(x):
++++return+x+>+0+and+((x+&+(x+-+1))+==+0)


def+find_nearest_power2(x):
++++if+x+<=+0:
++++++++raise+ValueError("invalid+input")
++++if+is_power2(x):
++++++++return+x
++++else:
++++++++bits+=+get_bits(x)
++++++++upper+=+1+<<+(bits)
++++++++lower+=+1+<<+(bits+-+1)
++++++++mid+=+(upper+%2B+lower)+//+2
++++++++if+(x+-+mid)+>+0:
++++++++++++return+upper
++++++++else:
++++++++++++return+lower


def+get_bits(x):
++++"""return+number+of+bits+in+binary+representation"""
++++if+x+<+0:
++++++++raise+ValueError("invalid+input:+input+should+be+positive+integer")
++++count+=+0
++++while+(x+!=+0):
++++++++try:
++++++++++++x+=+x+>>+1
++++++++except+TypeError+as+error:
++++++++++++print(error,+"input+should+be+of+type+integer")
++++++++++++sys.exit(1)
++++++++count+%2B=+1
++++return+count|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1645854|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 class="lang-py prettyprint-override"><code>import sys


def is_power2(x):
 return x &gt; 0 and ((x &amp; (x - 1)) == 0)


def find_nearest_power2(x):
 if x &lt;= 0:
 raise ValueError("invalid input")
 if is_power2(x):
 return x
 else:
 bits = get_bits(x)
 upper = 1 &lt;&lt; (bits)
 lower = 1 &lt;&lt; (bits - 1)
 mid = (upper + lower) // 2
 if (x - mid) &gt; 0:
 return upper
 else:
 return lower


def get_bits(x):
 """return number of bits in binary representation"""
 if x &lt; 0:
 raise ValueError("invalid input: input should be positive integer")
 count = 0
 while (x != 0):
 try:
 x = x &gt;&gt; 1
 except TypeError as error:
 print(error, "input should be of type integer")
 sys.exit(1)
 count += 1
 return count

</code></pre>

blocks|key|1645927|text|如果您想要一个单行模板。就是这里|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645928|int+nxt_po2(int+n)+{+return+1+%2B+(n%7C=(n%7C=(n%7C=(n%7C=(n%7C=(n-=1)>>1)>>2)>>4)>>8)>>16);+}|code-block|syntax|javascript|1645929|或|1645930|int+nxt_po2(int+n)+{+return+1+%2B+(n%7C=(n%7C=(n%7C=(n%7C=(n%7C=(n-=1)>>(1<<0))>>(1<<1))>>(1<<2))>>(1<<3))>>(1<<4));+}|1645931|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you want an one-line-template. Here it is

<pre class="lang-cpp prettyprint-override"><code>int nxt_po2(int n) { return 1 + (n|=(n|=(n|=(n|=(n|=(n-=1)&gt;&gt;1)&gt;&gt;2)&gt;&gt;4)&gt;&gt;8)&gt;&gt;16); }
</code></pre>

or 

<pre class="lang-cpp prettyprint-override"><code>int nxt_po2(int n) { return 1 + (n|=(n|=(n|=(n|=(n|=(n-=1)&gt;&gt;(1&lt;&lt;0))&gt;&gt;(1&lt;&lt;1))&gt;&gt;(1&lt;&lt;2))&gt;&gt;(1&lt;&lt;3))&gt;&gt;(1&lt;&lt;4)); }
</code></pre>

blocks|key|1431102|text|from+math+import+ceil,+log2
pot_ceil+=+lambda+N:+0x1+<<+ceil(log2(N))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1431103|测试：|unstyled|1431104|for+i+in+range(10):
++++print(i,+pot_ceil(i))|1431105|输出：|1431106|1+1
2+2
3+4
4+4
5+8
6+8
7+8
8+8
9+16
10+16|1431107|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre class="lang-py prettyprint-override"><code>from math import ceil, log2
pot_ceil = lambda N: 0x1 &lt;&lt; ceil(log2(N))
</code></pre>
Test:
<pre><code>for i in range(10):
 print(i, pot_ceil(i))
</code></pre>
Output:
<pre><code>1 1
2 2
3 4
4 4
5 8
6 8
7 8
8 8
9 16
10 16
</code></pre>

I want to write a function that returns the nearest next power of 2 number. For example if my input is 789, the output should be 1024. Is there any way of achieving this without using any loops but just using some bitwise operators?

Rounding up to next power of 2

我想写一个函数，返回最接近的下一个2的幂。例如，如果我的输入是789，那么输出应该是1024。有什么方法可以不使用任何循环而只使用一些按位运算符来实现这一点吗？

问向上舍入到2的下一个幂
EN

回答 26

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问向上舍入到2的下一个幂EN

回答 26

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问向上舍入到2的下一个幂
EN