blocks|key|819952|text|您可以使用查找表，它将是迄今为止最快的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|819953|您还可以考虑使用这:-|offset|length|819954|template+<typename+T>
T+expt(T+p,+unsigned+q)
{
++++T+r(1);

++++while+(q+!=+0)+{
++++++++if+(q+%25+2+==+1)+{++++//+q+is+odd
++++++++++++r+*=+p;
++++++++++++q--;
++++++++}
++++++++p+*=+p;
++++++++q+/=+2;
++++}

++++return+r;
}|code-block|syntax|javascript|819955|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Exponentiation_by_squaring^0|0|8|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|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You can use the lookup table which will be by far the fastest 

You can also consider using <a href="https://en.wikipedia.org/wiki/Exponentiation_by_squaring" rel="nofollow">this</a>:-

<pre><code>template &lt;typename T&gt;
T expt(T p, unsigned q)
{
 T r(1);

 while (q != 0) {
 if (q % 2 == 1) { // q is odd
 r *= p;
 q--;
 }
 p *= p;
 q /= 2;
 }

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

blocks|key|3214911|text|整数幂函数(它不涉及浮点转换和计算)很可能比pow()更快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3214912|int+integer_pow(int+x,+int+n)
{
++++int+r+=+1;
++++while+(n--)
++++++++r+*=+x;

++++return+r;+
}|code-block|syntax|javascript|3214913|编辑：基准测试--天真的整数指数方法似乎比浮点数方法的性能高出大约2倍：|BOLD|3214914|h2co3-macbook:~+h2co3$+cat+quirk.c
#include+<stdio.h>
#include+<stdlib.h>
#include+<limits.h>
#include+<errno.h>
#include+<string.h>
#include+<math.h>

int+integer_pow(int+x,+int+n)
{
++++int+r+=+1;
++++while+(n--)
++++r+*=+x;

++++return+r;+
}

int+main(int+argc,+char+*argv[])
{
++++int+x+=+0;

++++for+(int+i+=+0;+i+<+100000000;+i%2B%2B)+{
++++++++x+%2B=+powerfunc(i,+5);
++++}

++++printf("x+=+%25d\n",+x);

++++return+0;
}
h2co3-macbook:~+h2co3$+clang+-Wall+-o+quirk+quirk.c+-Dpowerfunc=integer_pow
h2co3-macbook:~+h2co3$+time+./quirk
x+=+-1945812992

real++++0m1.169s
user++++0m1.164s
sys+0m0.003s
h2co3-macbook:~+h2co3$+clang+-Wall+-o+quirk+quirk.c+-Dpowerfunc=pow
h2co3-macbook:~+h2co3$+time+./quirk
x+=+-2147483648

real++++0m2.898s
user++++0m2.891s
sys+0m0.004s
h2co3-macbook:~+h2co3$+|3214915|entityMap^0|M|5|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|V|8|@$9|W|A|X|B|M]]|D|@]|E|$]]|$1|N|3|O|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

An integer power function (which doesn't involve floating-point conversions and computations) may very well be faster than <code>pow()</code>:

<pre><code>int integer_pow(int x, int n)
{
 int r = 1;
 while (n--)
 r *= x;

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

Edit: benchmarked - the naive integer exponentiation method seems to outperform the floating-point one by about a factor of two:

<pre><code>h2co3-macbook:~ h2co3$ cat quirk.c
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;limits.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;
#include &lt;math.h&gt;

int integer_pow(int x, int n)
{
 int r = 1;
 while (n--)
 r *= x;

 return r; 
}

int main(int argc, char *argv[])
{
 int x = 0;

 for (int i = 0; i &lt; 100000000; i++) {
 x += powerfunc(i, 5);
 }

 printf("x = %d\n", x);

 return 0;
}
h2co3-macbook:~ h2co3$ clang -Wall -o quirk quirk.c -Dpowerfunc=integer_pow
h2co3-macbook:~ h2co3$ time ./quirk
x = -1945812992

real 0m1.169s
user 0m1.164s
sys 0m0.003s
h2co3-macbook:~ h2co3$ clang -Wall -o quirk quirk.c -Dpowerfunc=pow
h2co3-macbook:~ h2co3$ time ./quirk
x = -2147483648

real 0m2.898s
user 0m2.891s
sys 0m0.004s
h2co3-macbook:~ h2co3$ 
</code></pre>

blocks|key|1896714|text|就像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1896715|int+quick_pow10(int+n)
{
++++static+int+pow10[10]+=+{
++++++++1,+10,+100,+1000,+10000,+
++++++++100000,+1000000,+10000000,+100000000,+1000000000
++++};

++++return+pow10[n];+
}|code-block|syntax|javascript|1896716|显然，可以为long+long做同样的事情。|offset|length|style|CODE|1896717|这应该比任何竞争方法快几倍。然而，如果你有大量的基数，它是非常有限的(尽管数值的数量随着基数的增大而急剧下降)，所以如果没有大量的组合，它仍然是可行的。|1896718|作为比较：|1896719|#include+<iostream>
#include+<cstdlib>
#include+<cmath>

static+int+quick_pow10(int+n)
{
++++static+int+pow10[10]+=+{
++++++++1,+10,+100,+1000,+10000,+
++++++++100000,+1000000,+10000000,+100000000,+1000000000
++++};

++++return+pow10[n];+
}

static+int+integer_pow(int+x,+int+n)
{
++++int+r+=+1;
++++while+(n--)
+++++++r+*=+x;

++++return+r;+
}

static+int+opt_int_pow(int+n)
{
++++int+r+=+1;
++++const+int+x+=+10;
++++while+(n)
++++{
++++++++if+(n+&+1)+
++++++++{
+++++++++++r+*=+x;
+++++++++++n--;
++++++++}
++++++++else
++++++++{
++++++++++++r+*=+x+*+x;
++++++++++++n+-=+2;
++++++++}
++++}

++++return+r;+
}


int+main(int+argc,+char+**argv)
{
++++long+long+sum+=+0;
++++int+n+=+strtol(argv[1],+0,+0);
++++const+long+outer_loops+=+1000000000;

++++if+(argv[2][0]+==+'a')
++++{
++++++++for(long+i+=+0;+i+<+outer_loops+/+n;+i%2B%2B)
++++++++{
++++++++++++for(int+j+=+1;+j+<+n%2B1;+j%2B%2B)
++++++++++++{
++++++++++++++++sum+%2B=+quick_pow10(n);
++++++++++++}
++++++++}
++++}
++++if+(argv[2][0]+==+'b')
++++{
++++++++for(long+i+=+0;+i+<+outer_loops+/+n;+i%2B%2B)
++++++++{
++++++++++++for(int+j+=+1;+j+<+n%2B1;+j%2B%2B)
++++++++++++{
++++++++++++++++sum+%2B=+integer_pow(10,n);
++++++++++++}
++++++++}
++++}

++++if+(argv[2][0]+==+'c')
++++{
++++++++for(long+i+=+0;+i+<+outer_loops+/+n;+i%2B%2B)
++++++++{
++++++++++++for(int+j+=+1;+j+<+n%2B1;+j%2B%2B)
++++++++++++{
++++++++++++++++sum+%2B=+opt_int_pow(n);
++++++++++++}
++++++++}
++++}

++++std::cout+<<+"sum="+<<+sum+<<+std::endl;
++++return+0;
}|1896720|使用g%2B%2B+4.6.3编译，使用-Wall+-O2+-std=c%2B%2B0x提供以下结果：|1896721|$+g%2B%2B+-Wall+-O2+-std=c%2B%2B0x+pow.cpp
$+time+./a.out+8+a
sum=100000000000000000

real++++0m0.124s
user++++0m0.119s
sys+0m0.004s
$+time+./a.out+8+b
sum=100000000000000000

real++++0m7.502s
user++++0m7.482s
sys+0m0.003s

$+time+./a.out+8+c
sum=100000000000000000

real++++0m6.098s
user++++0m6.077s
sys+0m0.002s|1896722|(我也有一个使用pow的选择，但当我第一次尝试它时，它花了1m22.56s，所以当我决定使用优化循环变体时，我删除了它)|1896723|entityMap^0|0|0|6|9|0|0|0|0|G|K|0|0|8|3|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

Something like this:

<pre><code>int quick_pow10(int n)
{
 static int pow10[10] = {
 1, 10, 100, 1000, 10000, 
 100000, 1000000, 10000000, 100000000, 1000000000
 };

 return pow10[n]; 
}
</code></pre>

Obviously, can do the same thing for <code>long long</code>.

This should be several times faster than any competing method. However, it is quite limited if you have lots of bases (although the number of values goes down quite dramatically with larger bases), so if there isn't a huge number of combinations, it's still doable. 

As a comparison:

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

static int quick_pow10(int n)
{
 static int pow10[10] = {
 1, 10, 100, 1000, 10000, 
 100000, 1000000, 10000000, 100000000, 1000000000
 };

 return pow10[n]; 
}

static int integer_pow(int x, int n)
{
 int r = 1;
 while (n--)
 r *= x;

 return r; 
}

static int opt_int_pow(int n)
{
 int r = 1;
 const int x = 10;
 while (n)
 {
 if (n &amp; 1) 
 {
 r *= x;
 n--;
 }
 else
 {
 r *= x * x;
 n -= 2;
 }
 }

 return r; 
}


int main(int argc, char **argv)
{
 long long sum = 0;
 int n = strtol(argv[1], 0, 0);
 const long outer_loops = 1000000000;

 if (argv[2][0] == 'a')
 {
 for(long i = 0; i &lt; outer_loops / n; i++)
 {
 for(int j = 1; j &lt; n+1; j++)
 {
 sum += quick_pow10(n);
 }
 }
 }
 if (argv[2][0] == 'b')
 {
 for(long i = 0; i &lt; outer_loops / n; i++)
 {
 for(int j = 1; j &lt; n+1; j++)
 {
 sum += integer_pow(10,n);
 }
 }
 }

 if (argv[2][0] == 'c')
 {
 for(long i = 0; i &lt; outer_loops / n; i++)
 {
 for(int j = 1; j &lt; n+1; j++)
 {
 sum += opt_int_pow(n);
 }
 }
 }

 std::cout &lt;&lt; "sum=" &lt;&lt; sum &lt;&lt; std::endl;
 return 0;
}
</code></pre>

Compiled with g++ 4.6.3, using <code>-Wall -O2 -std=c++0x</code>, gives the following results:

<pre><code>$ g++ -Wall -O2 -std=c++0x pow.cpp
$ time ./a.out 8 a
sum=100000000000000000

real 0m0.124s
user 0m0.119s
sys 0m0.004s
$ time ./a.out 8 b
sum=100000000000000000

real 0m7.502s
user 0m7.482s
sys 0m0.003s

$ time ./a.out 8 c
sum=100000000000000000

real 0m6.098s
user 0m6.077s
sys 0m0.002s
</code></pre>

(I did have an option for using <code>pow</code> as well, but it took 1m22.56s when I first tried it, so I removed it when I decided to have optimised loop variant)

blocks|key|1896764|text|这里有一个尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1896765|//+specialize+if+you+have+a+bignum+integer+like+type+you+want+to+work+with:
template<typename+T>+struct+is_integer_like:std::is_integral<T>+{};
template<typename+T>+struct+make_unsigned_like:std::make_unsigned<T>+{};

template<typename+T,+typename+U>
T+powT(+T+base,+U+exponent+)+{
++static_assert(+is_integer_like::value,+"exponent+must+be+integer-like"+);
++static_assert(+std::is_same<+U,+typename+make_unsigned_like::type+>::value,+"exponent+must+be+unsigned"+);

++T+retval+=+1;
++T&+multiplicand+=+base;
++if+(exponent)+{
++++while+(true)+{
++++++//+branch+prediction+will+be+awful+here,+you+may+have+to+micro-optimize:
++++++retval+*=+(exponent&1)?multiplicand:1;
++++++//+or+/2,+whatever+--+`>>1`+is+probably+faster,+esp+for+bignums:
++++++exponent+=+exponent>>1;
++++++if+(!exponent)
++++++++break;
++++++multiplicand+*=+multiplicand;
++++}
++}
++return+retval;
}|code-block|syntax|javascript|1896766|上面发生的事情是几件事。|1896767|首先，所以BigNum支持是便宜的，它是template化的。开箱即用，它支持任何支持*=+own_type的基类型，或者可以隐式转换为int，或者int可以隐式转换到它(如果两者都是真的，那么就会出现问题)，您需要专门化一些templates，以指示所涉及的指数类型是无符号的和整数的。|offset|length|style|CODE|1896768|在这种情况下，类整数和无符号意味着它支持&1返回bool和>>1，返回它可以构造的内容，并且最终(在重复的>>1s之后)到达一个在bool上下文中计算它返回false的点。我使用了特性类来表示这种限制，因为像-1这样的值的天真使用会永远编译并(在某些平台上)循环，而(在其他平台上)则不会。|1896769|该算法的执行时间(假设乘法为O(1)+)为O(lg(指数))，其中lg(指数)是exponent在bool上下文中计算为false之前所需的次数。对于传统的整数类型，这将是exponent值的二进制日志:所以不超过32。|1896770|我还消除了循环中的所有分支(或者，对于现有编译器来说，更确切地说，这是不需要分支的)，只使用控制分支(这是一致的，直到它是假的一次)。即使是这个分支也有可能因为高基数和低指数而值得……|1896771|entityMap^0|0|0|0|K|8|17|B|1W|3|22|3|35|8|0|K|2|O|4|T|3|1H|3|1T|4|26|5|2W|2|0|14|8|1D|4|1O|5|2E|8|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|6|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|N]|$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]|$K|1D|L|1E|M|N]|$K|1F|L|1G|M|N]|$K|1H|L|1I|M|N]|$K|1J|L|1K|M|N]|$K|1L|L|1M|M|N]|$K|1N|L|1O|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1P|8|@$K|1Q|L|1R|M|N]|$K|1S|L|1T|M|N]|$K|1U|L|1V|M|N]|$K|1W|L|1X|M|N]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|V|$]]

Here is a stab at it:

<pre><code>// specialize if you have a bignum integer like type you want to work with:
template&lt;typename T&gt; struct is_integer_like:std::is_integral&lt;T&gt; {};
template&lt;typename T&gt; struct make_unsigned_like:std::make_unsigned&lt;T&gt; {};

template&lt;typename T, typename U&gt;
T powT( T base, U exponent ) {
 static_assert( is_integer_like&lt;U&gt;::value, "exponent must be integer-like" );
 static_assert( std::is_same&lt; U, typename make_unsigned_like&lt;U&gt;::type &gt;::value, "exponent must be unsigned" );

 T retval = 1;
 T&amp; multiplicand = base;
 if (exponent) {
 while (true) {
 // branch prediction will be awful here, you may have to micro-optimize:
 retval *= (exponent&amp;1)?multiplicand:1;
 // or /2, whatever -- `&gt;&gt;1` is probably faster, esp for bignums:
 exponent = exponent&gt;&gt;1;
 if (!exponent)
 break;
 multiplicand *= multiplicand;
 }
 }
 return retval;
}
</code></pre>

What is going on above is a few things.

First, so BigNum support is cheap, it is <code>template</code>ized. Out of the box, it supports any base type that supports <code>*= own_type</code> and either can be implicitly converted to <code>int</code>, or <code>int</code> can be implicitly converted to it (if both is true, problems will occur), and you need to specialize some <code>template</code>s to indicate that the exponent type involved is both unsigned and integer-like.

In this case, integer-like and unsigned means that it supports <code>&amp;1</code> returning <code>bool</code> and <code>&gt;&gt;1</code> returning something it can be constructed from and eventually (after repeated <code>&gt;&gt;1</code>s) reaches a point where evaluating it in a <code>bool</code> context returns <code>false</code>. I used traits classes to express the restriction, because naive use by a value like <code>-1</code> would compile and (on some platforms) loop forever, while (on others) would not.

Execution time for this algorithm, assuming multiplication is O(1), is O(lg(exponent)), where lg(exponent) is the number of times it takes to <code>&lt;&lt;1</code> the <code>exponent</code> before it evaluates as <code>false</code> in a <code>bool</code>ean context. For traditional integer types, this would be the binary log of the <code>exponent</code>s value: so no more than 32.

I also eliminated all branches within the loop (or, made it obvious to existing compilers that no branch is needed, more precisely), with just the control branch (which is true uniformly until it is false once). Possibly eliminating even that branch might be worth it for high bases and low exponents...

blocks|key|3214993|text|使用模板元编程的任何基的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3214994|template<int+E,+int+N>
struct+pow+{
++++enum+{+value+=+E+*+pow<E,+N+-+1>::value+};
};

template+<int+E>
struct+pow<E,+0>+{
++++enum+{+value+=+1+};
};|code-block|syntax|javascript|3214995|然后，它可以用于生成一个可在运行时使用的查找表：|3214996|template<int+E>
long+long+quick_pow(unsigned+int+n)+{
++++static+long+long+lookupTable[]+=+{
++++++++pow<E,+0>::value,+pow<E,+1>::value,+pow<E,+2>::value,
++++++++pow<E,+3>::value,+pow<E,+4>::value,+pow<E,+5>::value,
++++++++pow<E,+6>::value,+pow<E,+7>::value,+pow<E,+8>::value,
++++++++pow<E,+9>::value
++++};

++++return+lookupTable[n];
}|3214997|这必须与正确的编译器标志一起使用，以便检测可能的溢出。|3214998|用法示例：|3214999|for(unsigned+int+n+=+0;+n+<+10;+%2B%2Bn)+{
++++std::cout+<<+quick_pow<10>(n)+<<+std::endl;
}|3215000|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A solution for any base using template meta-programming :

<pre><code>template&lt;int E, int N&gt;
struct pow {
 enum { value = E * pow&lt;E, N - 1&gt;::value };
};

template &lt;int E&gt;
struct pow&lt;E, 0&gt; {
 enum { value = 1 };
};
</code></pre>

Then it can be used to generate a lookup-table that can be used at runtime :

<pre><code>template&lt;int E&gt;
long long quick_pow(unsigned int n) {
 static long long lookupTable[] = {
 pow&lt;E, 0&gt;::value, pow&lt;E, 1&gt;::value, pow&lt;E, 2&gt;::value,
 pow&lt;E, 3&gt;::value, pow&lt;E, 4&gt;::value, pow&lt;E, 5&gt;::value,
 pow&lt;E, 6&gt;::value, pow&lt;E, 7&gt;::value, pow&lt;E, 8&gt;::value,
 pow&lt;E, 9&gt;::value
 };

 return lookupTable[n];
}
</code></pre>

This must be used with correct compiler flags in order to detect the possible overflows.

Usage example :

<pre><code>for(unsigned int n = 0; n &lt; 10; ++n) {
 std::cout &lt;&lt; quick_pow&lt;10&gt;(n) &lt;&lt; std::endl;
}
</code></pre>

blocks|key|820107|text|基于垫彼得森的方法，但编译时生成缓存。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|820108|#include+<iostream>
#include+<limits>
#include+<array>

//+digits

template+<typename+T>
constexpr+T+digits(T+number)+{++++
++return+number+==+0+?+0+
+++++++++++++++++++++:+1+%2B+digits<T>(number+/+10);
}

//+pow

//+https://stackoverflow.com/questions/24656212/why-does-gcc-complain-error-type-intt-of-template-argument-0-depends-on-a
//+unfortunatly+we+can't+write+`template+<typename+T,+T+N>`+because+of+partial+specialization+`PowerOfTen<T,+1>`

template+<typename+T,+uintmax_t+N>
struct+PowerOfTen+{
++enum+{+value+=+10+*+PowerOfTen<T,+N+-+1>::value+};
};

template+<typename+T>
struct+PowerOfTen<T,+1>+{
++enum+{+value+=+1+};
};

//+sequence

template<typename+T,+T...>
struct+pow10_sequence+{+};

template<typename+T,+T+From,+T+N,+T...+Is>
struct+make_pow10_sequence_from+
:+make_pow10_sequence_from<T,+From,+N+-+1,+N+-+1,+Is...>+{+
++//++
};

template<typename+T,+T+From,+T...+Is>
struct+make_pow10_sequence_from<T,+From,+From,+Is...>+
:+pow10_sequence<T,+Is...>+{+
++//
};

//+base10list

template+<typename+T,+T+N,+T...+Is>
constexpr+std::array<T,+N>+base10list(pow10_sequence<T,+Is...>)+{
++return+{{+PowerOfTen<T,+Is>::value...+}};
}

template+<typename+T,+T+N>
constexpr+std::array<T,+N>+base10list()+{++++
++return+base10list<T,+N>(make_pow10_sequence_from<T,+1,+N%2B1>());
}

template+<typename+T>
constexpr+std::array<T,+digits(std::numeric_limits<T>::max())>+base10list()+{++++
++return+base10list<T,+digits(std::numeric_limits<T>::max())>();++++
};

//+main+pow+function

template+<typename+T>
static+T+template_quick_pow10(T+n)+{

++static+auto+values+=+base10list<T>();
++return+values[n];+
}

//+client+code

int+main(int+argc,+char+**argv)+{

++long+long+sum+=+0;
++int+n+=+strtol(argv[1],+0,+0);
++const+long+outer_loops+=+1000000000;

++if+(argv[2][0]+==+'t')+{

++++for(long+i+=+0;+i+<+outer_loops+/+n;+i%2B%2B)+{

++++++for(int+j+=+1;+j+<+n%2B1;+j%2B%2B)+{

++++++++sum+%2B=+template_quick_pow10(n);
++++++}
++++}
++}

++std::cout+<<+"sum="+<<+sum+<<+std::endl;
++return+0;
}|code-block|syntax|javascript|820109|代码不包含quick_pow10、integer_pow、opt_int_pow以获得更好的可读性，而是在代码中使用它们进行测试。|820110|使用gcc版本4.6.3+(Ubuntu/Linaro4.6.3-1+ubuntu5)编译，使用-Wall+-O2+-std=c%2B%2B0x提供以下结果：|820111|$+g%2B%2B+-Wall+-O2+-std=c%2B%2B0x+main.cpp

$+time+./a.out++8+a
sum=100000000000000000

real++0m0.438s
user++0m0.432s
sys+0m0.008s

$+time+./a.out++8+b
sum=100000000000000000

real++0m8.783s
user++0m8.777s
sys+0m0.004s

$+time+./a.out++8+c
sum=100000000000000000

real++0m6.708s
user++0m6.700s
sys+0m0.004s

$+time+./a.out++8+t
sum=100000000000000000

real++0m0.439s
user++0m0.436s
sys+0m0.000s|820112|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/1919155/mats-petersson^0|2|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Based on <a href="https://stackoverflow.com/users/1919155/mats-petersson">Mats Petersson</a> approach, but compile time generation of cache.

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

// digits

template &lt;typename T&gt;
constexpr T digits(T number) { 
 return number == 0 ? 0 
 : 1 + digits&lt;T&gt;(number / 10);
}

// pow

// https://stackoverflow.com/questions/24656212/why-does-gcc-complain-error-type-intt-of-template-argument-0-depends-on-a
// unfortunatly we can't write `template &lt;typename T, T N&gt;` because of partial specialization `PowerOfTen&lt;T, 1&gt;`

template &lt;typename T, uintmax_t N&gt;
struct PowerOfTen {
 enum { value = 10 * PowerOfTen&lt;T, N - 1&gt;::value };
};

template &lt;typename T&gt;
struct PowerOfTen&lt;T, 1&gt; {
 enum { value = 1 };
};

// sequence

template&lt;typename T, T...&gt;
struct pow10_sequence { };

template&lt;typename T, T From, T N, T... Is&gt;
struct make_pow10_sequence_from 
: make_pow10_sequence_from&lt;T, From, N - 1, N - 1, Is...&gt; { 
 // 
};

template&lt;typename T, T From, T... Is&gt;
struct make_pow10_sequence_from&lt;T, From, From, Is...&gt; 
: pow10_sequence&lt;T, Is...&gt; { 
 //
};

// base10list

template &lt;typename T, T N, T... Is&gt;
constexpr std::array&lt;T, N&gt; base10list(pow10_sequence&lt;T, Is...&gt;) {
 return {{ PowerOfTen&lt;T, Is&gt;::value... }};
}

template &lt;typename T, T N&gt;
constexpr std::array&lt;T, N&gt; base10list() { 
 return base10list&lt;T, N&gt;(make_pow10_sequence_from&lt;T, 1, N+1&gt;());
}

template &lt;typename T&gt;
constexpr std::array&lt;T, digits(std::numeric_limits&lt;T&gt;::max())&gt; base10list() { 
 return base10list&lt;T, digits(std::numeric_limits&lt;T&gt;::max())&gt;(); 
};

// main pow function

template &lt;typename T&gt;
static T template_quick_pow10(T n) {

 static auto values = base10list&lt;T&gt;();
 return values[n]; 
}

// client code

int main(int argc, char **argv) {

 long long sum = 0;
 int n = strtol(argv[1], 0, 0);
 const long outer_loops = 1000000000;

 if (argv[2][0] == 't') {

 for(long i = 0; i &lt; outer_loops / n; i++) {

 for(int j = 1; j &lt; n+1; j++) {

 sum += template_quick_pow10(n);
 }
 }
 }

 std::cout &lt;&lt; "sum=" &lt;&lt; sum &lt;&lt; std::endl;
 return 0;
}
</code></pre>

Code does not contain quick_pow10, integer_pow, opt_int_pow for better readability, but tests done with them in the code.

Compiled with gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5), using -Wall -O2 -std=c++0x, gives the following results:

<pre><code>$ g++ -Wall -O2 -std=c++0x main.cpp

$ time ./a.out 8 a
sum=100000000000000000

real 0m0.438s
user 0m0.432s
sys 0m0.008s

$ time ./a.out 8 b
sum=100000000000000000

real 0m8.783s
user 0m8.777s
sys 0m0.004s

$ time ./a.out 8 c
sum=100000000000000000

real 0m6.708s
user 0m6.700s
sys 0m0.004s

$ time ./a.out 8 t
sum=100000000000000000

real 0m0.439s
user 0m0.436s
sys 0m0.000s
</code></pre>

blocks|key|1896853|text|没有乘法，也没有表格版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1896854|//Nx10%5En
int+Npow10(int+N,+int+n){
++N+<<=+n;
++while(n--)+N+%2B=+N+<<+2;
++return+N;
}|code-block|syntax|javascript|1896855|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|$]]

No multiplication and no table version:

<pre><code>//Nx10^n
int Npow10(int N, int n){
 N &lt;&lt;= n;
 while(n--) N += N &lt;&lt; 2;
 return N;
}
</code></pre>

blocks|key|820153|text|这个函数计算x%5Ey比pow快得多。如果是整数值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820154|int+pot(int+x,+int+y){
int+solution+=+1;
while(y){
++++if(y&1)
++++++++solution*=+x;
++++x+*=+x;
++++y+>>=+1;
}
return+solution;|code-block|syntax|javascript|820155|}|820156|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|$]]

This function will calculate x ^ y much faster then pow. In case of integer values.

<pre><code>int pot(int x, int y){
int solution = 1;
while(y){
 if(y&amp;1)
 solution*= x;
 x *= x;
 y &gt;&gt;= 1;
}
return solution;
</code></pre>

}

blocks|key|1896930|text|现在，使用constexpr，您可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1896931|constexpr+int+pow10(int+n)+{
++++int+result+=+1;
++++for+(int+i+=+1;+i<=n;+%2B%2Bi)
++++++++result+*=+10;
++++return+result;
}

int+main+()+{
++++int+i+=+pow10(5);
}|code-block|syntax|javascript|1896932|i将在编译时计算。为x86-64+gcc+9.2生成的ASM：|1896933|main:
++++++++push++++rbp
++++++++mov+++++rbp,+rsp
++++++++mov+++++DWORD+PTR+[rbp-4],+100000
++++++++mov+++++eax,+0
++++++++pop+++++rbp
++++++++ret|1896934|entityMap^0|5|9|0|0|0|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Now, with <code>constexpr</code>, you can do like so:

<pre><code>constexpr int pow10(int n) {
 int result = 1;
 for (int i = 1; i&lt;=n; ++i)
 result *= 10;
 return result;
}

int main () {
 int i = pow10(5);
}
</code></pre>

<code>i</code> will be calculated at compile time. ASM generated for x86-64 gcc 9.2:

<pre><code>main:
 push rbp
 mov rbp, rsp
 mov DWORD PTR [rbp-4], 100000
 mov eax, 0
 pop rbp
 ret
</code></pre>

blocks|key|820203|text|如果要计算，例如10%5E5，则可以：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820204|int+main()+{
+++cout+<<+(int)1e5+<<+endl;+//+will+print+100000
+++cout+<<+(int)1e3+<<+endl;+//+will+print+1000
+++return+0;
}+|code-block|syntax|javascript|820205|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 want to calculate, e.g.,10^5, then you can:

<pre><code>int main() {
 cout &lt;&lt; (int)1e5 &lt;&lt; endl; // will print 100000
 cout &lt;&lt; (int)1e3 &lt;&lt; endl; // will print 1000
 return 0;
} 
</code></pre>

blocks|key|3215202|text|result+*=+10也可以编写为result+=+(result+<<+3)+%2B+(result+<<+1)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3215203|constexpr+int+pow10(int+n)+{
++int+result+=+1;
++for+(int+i+=+0;+i+<+n;+i%2B%2B)+{
++++result+=+(result+<<+3)+%2B+(result+<<+1);
++}
++return+result;
}|code-block|syntax|javascript|3215204|entityMap^0|0|C|I|12|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

<code>result *= 10</code> can also be written as <code>result = (result &lt;&lt; 3) + (result &lt;&lt; 1)</code>
<pre><code>constexpr int pow10(int n) {
 int result = 1;
 for (int i = 0; i &lt; n; i++) {
 result = (result &lt;&lt; 3) + (result &lt;&lt; 1);
 }
 return result;
}
</code></pre>

blocks|key|820228|text|基于constexpr函数的泛型表生成器。浮点部分需要c%2B%2B20和gcc，但非浮点部分适用于c%2B%2B17。如果将"auto“类型改为"long”，则可以使用c%2B%2B14。测试不正确。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820229|#include+<cstdio>
#include+<cassert>
#include+<cmath>

//+Precomputes+x%5EN
//+Inspired+by+https://stackoverflow.com/a/34465458
template<auto+x,+unsigned+char+N,+typename+AccumulatorType>
struct+PowTable+{
++++constexpr+PowTable()+:+mTable()+{
++++++++AccumulatorType+p{+1+};
++++++++for+(unsigned+char+i+=+0;+i+<+N;+%2B%2Bi)+{
++++++++++++p+*=+x;
++++++++++++mTable[i]+=+p;
++++++++}
++++}

++++AccumulatorType+operator[](unsigned+char+n)+const+{
++++++++assert(n+<+N);
++++++++return+mTable[n];
++++}

++++AccumulatorType+mTable[N];
};

long+pow10(unsigned+char+n)+{
++++static+constexpr+PowTable<10l,+10,+long>+powTable;
++++return+powTable[n-1];
}

double+powe(unsigned+char+n)+{
++++static+constexpr+PowTable<2.71828182845904523536,+10,+double>+powTable;
++++return+powTable[n-1];
}


int+main()+{
++++printf("10%5E3=%25ld\n",+pow10(3));
++++printf("e%5E2=%25f",+powe(2));
++++assert(pow10(3)+==+1000);
++++assert(powe(2)+-+7.389056+<+0.001);
}|code-block|syntax|javascript|820230|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|$]]

A generic table builder based on constexpr functions. The floating point part requires c++20 and gcc, but the non-floating point part works for c++17. If you change the &quot;auto&quot; type param to &quot;long&quot; you can use c++14. Not properly tested.
<pre><code>#include &lt;cstdio&gt;
#include &lt;cassert&gt;
#include &lt;cmath&gt;

// Precomputes x^N
// Inspired by https://stackoverflow.com/a/34465458
template&lt;auto x, unsigned char N, typename AccumulatorType&gt;
struct PowTable {
 constexpr PowTable() : mTable() {
 AccumulatorType p{ 1 };
 for (unsigned char i = 0; i &lt; N; ++i) {
 p *= x;
 mTable[i] = p;
 }
 }

 AccumulatorType operator[](unsigned char n) const {
 assert(n &lt; N);
 return mTable[n];
 }

 AccumulatorType mTable[N];
};

long pow10(unsigned char n) {
 static constexpr PowTable&lt;10l, 10, long&gt; powTable;
 return powTable[n-1];
}

double powe(unsigned char n) {
 static constexpr PowTable&lt;2.71828182845904523536, 10, double&gt; powTable;
 return powTable[n-1];
}


int main() {
 printf(&quot;10^3=%ld\n&quot;, pow10(3));
 printf(&quot;e^2=%f&quot;, powe(2));
 assert(pow10(3) == 1000);
 assert(powe(2) - 7.389056 &lt; 0.001);
}
</code></pre>

I know power of 2 can be implemented using &lt;&lt; operator. 
What about power of 10? Like 10^5? Is there any way faster than pow(10,5) in C++? It is a pretty straight-forward computation by hand. But seems not easy for computers due to binary representation of the numbers... Let us assume I am only interested in integer powers, 10^n, where n is an integer.

Any way faster than pow() to compute an integer power of 10 in C++?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我知道2的幂可以用<<算子实现。那10倍的功率呢？比如10^5？在C++中有比pow(10,5)更快的方法吗？这是一个相当直截了当的手工计算.但对计算机来说似乎不容易因为数字的二进制表示..。假设我只对整数幂，10^n感兴趣，其中n是整数。

问在C++中，有比pow()更快的计算整数幂10的方法吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中，有比pow()更快的计算整数幂10的方法吗？EN