http://stackoverflow.com/questions/15851636/why-is-my-integer-math-with-stdpow-giving-the-wrong-answer

n += chara * pow(26, len - 1 - i); 

会使double转成int

引用 2 楼 paschen的回复:

n += chara * pow(26, len - 1 - i); 

会使double转成int

我知道呀，但是为什么VS就结果正确呢

vc用的sse指令, gcc加上 -march=native -mfpmath=sse试试看

能整数运算的就不要引入浮点数，会产生精度问题。
整数乘方可以用快速幂。

引用 5 楼 mewiteor 的回复:

能整数运算的就不要引入浮点数，会产生精度问题。
整数乘方可以用快速幂。

对，包括自己写的用整型的求幂函数都是OK的，但是为什么同一个pow函数在两个编译器下不一样，所以我的问题是能不能教我如何剖开看内部……

才发现有这种奇怪现象  比如下面代码

#include <stdio.h>

#include <math.h>



int main() {

  int n=0,m=3;

  n=pow(26,2);

  printf("pow(26,2)=%d\n",n);

  n=pow(26.0,2.0);

  printf("pow(26.0,2)=%d\n",n);

  n=pow(26,m-1);

  printf("pow(26,int(2))=%d\n",n);

  n=pow(26.0,m-1);

  printf("pow(26.0,int(2))=%d\n",n);

	return 0;

}

在c++结果不同    是函数匹配的问题么

这句 n += chara * pow(26, len - 1 - i);  改成  n += chara * round(pow(26, len - 1 - i));

直接转换int 是直接截取掉小数部分，比如3.1、3.9  都直接变成3
而我单步跟踪发现可能CB里676由于浮点数计算误差，得到的其实比675.999...，这样转换后就变成675了，导致全错了
而用round进行四舍五入后结果可以正常

引用 1 楼 pcboyxhy 的回复:

http://stackoverflow.com/questions/15851636/why-is-my-integer-math-with-stdpow-giving-the-wrong-answer

谢谢，你给的链接讲了浮点，我想的也是因为这个。不过我主要问题还是，同样都是pow函数，为什么两个编译器却不愿意，想知道它们内部是怎么走的……

补充一下……

#include <iostream>

#include <cmath>

using namespace std;



double titleToNumber(string s) {

    double n = 0, len = s.length();

    for(int i = 0; i < s.length(); ++ i) {

        char c = s[i];

        double chara = c - 'A' + 1;

        double a = len - 1 - i;

        n += chara * pow(26.0, a);

    }

    return n;

}



int main() {

    cout<<titleToNumber("AAB");

    return 0;

}

用double的话是OK的，问题还是上一楼回答的，两个编译器内部是如何走的……

引用 9 楼 paschen 的回复:

这句 n += chara * pow(26, len - 1 - i);  改成  n += chara * round(pow(26, len - 1 - i));

直接转换int 是直接截取掉小数部分，比如3.1、3.9  都直接变成3
而我单步跟踪发现可能CB里676由于浮点数计算误差，得到的其实比675.999...，这样转换后就变成675了，导致全错了
而用round进行四舍五入后结果可以正常

嗯嗯，谢谢，那为什么VS是对的呢？

引用 11 楼 NoMasp 的回复:

补充一下……

#include <iostream>

#include <cmath>

using namespace std;



double titleToNumber(string s) {

    double n = 0, len = s.length();

    for(int i = 0; i < s.length(); ++ i) {

        char c = s[i];

        double chara = c - 'A' + 1;

        double a = len - 1 - i;

        n += chara * pow(26.0, a);

    }

    return n;

}



int main() {

    cout<<titleToNumber("AAB");

    return 0;

}

用double的话是OK的，问题还是上一楼回答的，两个编译器内部是如何走的……

pow中的计算导致结果的误差在你转换成int时显现出来，具体可看汇编代码+单步跟踪 比较不同

引用 12 楼 NoMasp 的回复:

Quote: 引用 9 楼 paschen 的回复:

这句 n += chara * pow(26, len - 1 - i);  改成  n += chara * round(pow(26, len - 1 - i));

直接转换int 是直接截取掉小数部分，比如3.1、3.9  都直接变成3
而我单步跟踪发现可能CB里676由于浮点数计算误差，得到的其实比675.999...，这样转换后就变成675了，导致全错了
而用round进行四舍五入后结果可以正常

嗯嗯，谢谢，那为什么VS是对的呢？

675.999 转成int得到的将是675，而不是676，产生误差的原因可能pow中计算实现方式不同，浮点数计算是有一定误差的，具体可以看pow汇编代码

理解和讨论之前请先学会如何观察！

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

对学习编程者的忠告：
多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步Debug版对应汇编一行！
单步Debug版对应汇编千行不如单步Release版对应汇编一行！
不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）

VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

引用 9 楼 paschen 的回复:

这句 n += chara * pow(26, len - 1 - i);  改成  n += chara * round(pow(26, len - 1 - i));

直接转换int 是直接截取掉小数部分，比如3.1、3.9  都直接变成3
而我单步跟踪发现可能CB里676由于浮点数计算误差，得到的其实比675.999...，这样转换后就变成675了，导致全错了
而用round进行四舍五入后结果可以正常

另外你是怎么跟踪的？

我的这个却没有显示小数点和9999呢……

引用 14 楼 paschen 的回复:

Quote: 引用 12 楼 NoMasp 的回复:

Quote: 引用 9 楼 paschen 的回复:

这句 n += chara * pow(26, len - 1 - i);  改成  n += chara * round(pow(26, len - 1 - i));

直接转换int 是直接截取掉小数部分，比如3.1、3.9  都直接变成3
而我单步跟踪发现可能CB里676由于浮点数计算误差，得到的其实比675.999...，这样转换后就变成675了，导致全错了
而用round进行四舍五入后结果可以正常

嗯嗯，谢谢，那为什么VS是对的呢？

675.999 转成int得到的将是675，而不是676，产生误差的原因可能pow中计算实现方式不同，浮点数计算是有一定误差的，具体可以看pow汇编代码

谢谢，看样子真得去学学汇编、反编译了……

引用 15 楼 zhao4zhong1 的回复:

理解和讨论之前请先学会如何观察！

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

对学习编程者的忠告：
多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步Debug版对应汇编一行！
单步Debug版对应汇编千行不如单步Release版对应汇编一行！
不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）

VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

感谢赵老师的解答，我已截图保存

非常感谢。

一开始您给的学习路线图很赞，也反应了我这课程的各种不合理：一开始大一就是C++，没有C也没有计算机导论；然后大二是数据结构和数据库；大三是操作系统、组成原理、计算机网络；大四没课。

要好好补补汇编、编译原理、正则这些了。

另外，n += chara * pow(26, len - 1 - i);我猜可能匹配了pow的整数版的浮点计算了，因为26和len-1-i都是整数，如果你改成：
n += chara * pow(26.0, len - 1 - i); 算出来也是正确的

从CB的汇编call   0x467cf4 <std::pow<int, int>(int, int)> 得知使用的是int版的pow

引用 19 楼 paschen 的回复:

另外，n += chara * pow(26, len - 1 - i);我猜可能匹配了pow的整数版的浮点计算了，因为26和len-1-i都是整数，如果你改成：
n += chara * pow(26.0, len - 1 - i); 算出来也是正确的

嗯嗯，不过加上.0在我CB上还是703，不过已经不重要了，还是应该早点去补补汇编等，谢啦

引用 21 楼 NoMasp 的回复:

Quote: 引用 19 楼 paschen 的回复:

另外，n += chara * pow(26, len - 1 - i);我猜可能匹配了pow的整数版的浮点计算了，因为26和len-1-i都是整数，如果你改成：
n += chara * pow(26.0, len - 1 - i); 算出来也是正确的

嗯嗯，不过加上.0在我CB上还是703，不过已经不重要了，还是应该早点去补补汇编等，谢啦

加上后我这CB最后结果就是704了，一切后VS一样了

浮点数格式 http://bbs.csdn.net/topics/390676437

常量也有类型！
C++ Integer Constants
Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.

Syntax

integer-constant :

decimal-constant integer-suffixopt
octal-constant integer-suffixopt
hexadecimal-constant integer-suffixopt
'c-char-sequence'

decimal-constant :

nonzero-digit
decimal-constant digit

octal-constant :

0
octal-constant octal-digit

hexadecimal-constant :

0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit

nonzero-digit : one of

1 2 3 4 5 6 7 8 9

octal-digit : one of

0 1 2 3 4 5 6 7

hexadecimal-digit : one of

0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F

integer-suffix :

unsigned-suffix long-suffixopt
long-suffix unsigned-suffixopt

unsigned-suffix : one of

u U

long-suffix : one of

l L

64-bit integer-suffix :

i64

To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.

To specify a decimal constant, begin the specification with a nonzero digit. For example:

int i = 157;   // Decimal constant
int j = 0198;  // Not a decimal number; erroneous octal constant
int k = 0365;  // Leading zero specifies octal constant, not decimal

To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:

int i = 0377;   // Octal constant
int j = 0397;   // Error: 9 is not an octal digit

To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:

int i = 0x3fff;   // Hexadecimal constant
int j = 0X3FFF;   // Equal to i

To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:

unsigned uVal = 328u;             // Unsigned value
long lVal = 0x7FFFFFL;            // Long value specified 
                                  //  as hex constant
unsigned long ulVal = 0776745ul;  // Unsigned long value

C++ Floating-Point Constants
Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.

Syntax

floating-constant :

fractional-constant exponent-partopt floating-suffixopt
digit-sequence exponent-part floating-suffixopt

fractional-constant :

digit-sequenceopt . digit-sequence
digit-sequence .

exponent-part :

e signopt digit-sequence
E signopt digit-sequence

sign : one of

+ –

digit-sequence :

digit
digit-sequence digit

floating-suffix :one of

f l F L

Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:

18.46
38.

The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:

18.46e0      // 18.46
18.46e1      // 184.6

If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.

Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.

Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like

void func( double );

and 

void func( long double );

引用 23 楼 zhao4zhong1 的回复:

浮点数格式 http://bbs.csdn.net/topics/390676437

赞

int m=3;  void A(int* x){*x=pow(26,m-1);} 

          void B(float *y){*y=pow(26,m-1); }      

            (A)                                (B)                              

            pushl     %ebp                      pushl     %ebp

            movl      %esp, %ebp                movl      %esp, %ebp

            subl      $40, %esp                 subl      $40, %esp

            movl      _m, %eax                  movl      _m, %eax

            subl      $1, %eax                  subl      $1, %eax

            movl      %eax, -20(%ebp)           movl      %eax, -16(%ebp)

            fildl     -20(%ebp)                 fildl     -16(%ebp)

            fstpl     8(%esp)                   fstpl     8(%esp)

            fldl      LC0                       fldl      LC0

            fstpl     (%esp)                    fstpl     (%esp)

            call      _pow                      call      _pow

            fnstcw    -10(%ebp)                 fstps     -12(%ebp)

            movzwl    -10(%ebp), %eax           flds      -12(%ebp)

            movb      $12, %ah                  movl      8(%ebp), %eax

            movw      %ax, -12(%ebp)            fstps     (%eax)

            fldcw     -12(%ebp)                 nop      

            fistpl    -16(%ebp)                 leave      

            fldcw     -10(%ebp)                 ret      

            movl      -16(%ebp), %edx                        

            movl      8(%ebp), %eax                        

            movl      %edx, (%eax)                        

            nop                              

            leave                              

            ret                              

看汇编代码的话  好像函数调用是一样的  就是转换的问题了