关于cout和printf的压栈顺序问题

关于cout和printf的输出相关总结，查了些资料，终于明白了。特别摘录总结如下：

问题：

#include <iostream>

using namespace std;

int rolc = 0;

int f1()

{

cout<<"In f1() "<<rolc<<":\n";

return rolc++ ;

}

int main()

{

cout<<f()<<"\n"<<f()<<endl;

return 0;

}

在看上面的程序，一般想当然会输出：

In f1() 0:

0

In f2() 1:

1

Press any key to continue

可实际结果不是这样的，在VC++ 6.0 运行结果如下：

In f2() 0:

In f1() 1:

1

0

Press any key to continue

为何是这样呢？原因：标准未指定函数参数的求值顺序所导致的。具体分析如下：

c/c++在函数调用时，默认都是右序入栈，这肯定是没有错的。如果不是右序入栈的函数，必须以其它关键字指明

，比如pascal关键字。但是，这里不光涉及到参数的入栈顺序，还涉及到以表达式做为函数参数时，表达式的求值

顺序。

看这个例子：

如果有这样一个函数：

int max(int a, int b);

我这样调用它：

int x = 10;

int y = 6;

int z = max(x, y);

生成代码时，必然是y先入栈，然后x入栈，再call max。这就是右序入栈，c/c++的默认方式。

但是，如果在调用时，以表达式做为参数，又会怎么样呢？看下面

int z = max(x - y, x + y);

要知道，在调用max的时候，不可能把x + y这样的整个表达式入栈，必须求出表达式的值，然后将表达式的值做为

函数调用的参数入栈。可是，这里有两个表达式：x-y 和 x+y，那么先应该求x-y的值，还是先求出x+y的值？

c/c++语言都没有规定这个顺序，编译器实现可以自己定义。也就是说，一个编译器，可以先求出x+y的值，再求x

-y的值，然后将x+y的值入栈，然后再将x-y的值入栈，调用max。也可以先求出x-y的值，再求x+y的值，然后将x+y

值入栈，然后再将x-y的值入栈，调用max。 参数求值顺序不定，但是参数入栈顺序确定。

看下面的例子：

cout << "ljgajagj";

这相当于operator << (cout, "ljgajagj"); 这两句是完全相同的，只是不同的写法而已。在调用时，"ljgajagj"

的地址先入栈，然后cout入栈，然后调用 operator <<，最终的结果就是输出字符串"ljgajagj"。

看下面的例子：

cout<<" ljgajagj"<<endl;

这相当于operator<<( operator << (cout, "ljgajagj") , endl);

红色部分，以一个函数调用的形式，做为最外面的operator <<()的第一个参数。最外面的operator<< 有两个参数

，其中一个是表达式，所以先要对此表达式求值， 也就是先调用里面的operator << (cout, "ljgajagj") 部分

，输出字符串，然后将endl入栈，然后将operator << (cout, "ljgajagj") 的返回值，也就是一个cout对象入栈

，然后调用外面的operator<<()。这样，肯定是先输出字符串，而不会先输出endl。

下面看上面提出的问题，因为最后的endl不影响结果，所以，为了方便，忽略最后的endl，简化成下面的形式：

cout<<f1()<<"\n"<<f2();

这个语句相当于：

operator << ( f1(), operator << (cout, "\n") , f2() );

对于最外面的operator <<()，有三个参数，且有三个参数都是表达式，所以要分别对三个表达式求值，可是对三个表达式的求值顺序是不一定的。

如果是左序，1.调用f1()求值，输出字符串"In f1() 0:"，

2.调用operator << (cout, "\n")求值，得到cout对象

3.调用f2()求值，输出字符串"In f2() 1:"

4.将f2()返回值、cout对象、f1()返回值入栈

5.调用最外面的operator<<()输出

In f1() 0:

In f2() 1:

0

1

Press any key to continue

如果是右序，1.调用f2()求值，输出字符串"In f2() 0:"，

2.调用operator << (cout, "\n")求值，得到cout对象

3.调用f1()求值，输出字符串"In f2() 1:"

4.将f2()返回值、cout对象、f1()返回值入栈

5.调用最外面的operator<<()输出

In f2() 0:

In f1() 1:

1

0

Press any key to continue

2、故总结如下：

a cout和printf 计算表达式的先后未定义行为；从左到右 从右到左 都合法， 先中间再两边也完全可以。先计算表达式的值然后压栈，然后再输出，所以不同的编译器如vc和gcc的表现行为是不一样的。

int main()

{

int i=2;

cout<<i++<<++i<<i<<i++<<endl;

cout<<i<<endl;

}

对于如上程序 不同的编译器结果是不一样的，所以

C++中有两种"未定义行为".

一种叫 "undefined".比如未初始化局部变量的值. 一般来说,这种行为的结果是未知的.

另一种叫 "unspecified".比如参数的计算顺序. 这种行为的结果通常是可预期的.但其结果是和实现相关的.

楼主的问题就是第二种.这种东西看似有些规律.但却是完全不通用的东西...

不过似乎考试却经常考第二种东西...呵呵

cout<<i++<<++i<<i<<i++<<endl;

写这样的代码会被公司辞退的

看看编译出的来的汇编代码就知道是如何压栈的了。

真相都在这里

C/C++ codestatic char sprint_buf[1024];

int printf(char *fmt, ...)

{

va_list args;

int n;

va_start(args, fmt);

n = vsprintf(sprint_buf, fmt, args);

va_end(args);

write(stdout, sprint_buf, n);

return n;

}

int vsprintf(char *buf, const char *fmt, va_list args)

{

int len;

unsigned long num;

int i, base;

char *str;

char *s;

int flags; // Flags to number()

int field_width; // Width of output field

int precision; // Min. # of digits for integers; max number of chars for from string

int qualifier; // 'h', 'l', or 'L' for integer fields

for (str = buf; *fmt; fmt++)

{

if (*fmt != '%')

{

*str++ = *fmt;

continue;

}

// Process flags

flags = 0;

repeat:

fmt++; // This also skips first '%'

switch (*fmt)

{

case '-': flags |= LEFT; goto repeat;

case '+': flags |= PLUS; goto repeat;

case ' ': flags |= SPACE; goto repeat;

case '#': flags |= SPECIAL; goto repeat;

case '0': flags |= ZEROPAD; goto repeat;

}

// Get field width

field_width = -1;

if (is_digit(*fmt))

field_width = skip_atoi(&fmt);

else if (*fmt == '*')

{

fmt++;

field_width = va_arg(args, int);

if (field_width < 0)

{

field_width = -field_width;

flags |= LEFT;

}

}

// Get the precision

precision = -1;

if (*fmt == '.')

{

++fmt;

if (is_digit(*fmt))

precision = skip_atoi(&fmt);

else if (*fmt == '*')

{

++fmt;

precision = va_arg(args, int);

}

if (precision < 0) precision = 0;

}

// Get the conversion qualifier

qualifier = -1;

if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')

{

qualifier = *fmt;

fmt++;

}

// Default base

base = 10;

switch (*fmt)

{

case 'c':

if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';

*str++ = (unsigned char) va_arg(args, int);

while (--field_width > 0) *str++ = ' ';

continue;

case 's':

s = va_arg(args, char *);

if (!s) s = "<NULL>";

len = strnlen(s, precision);

if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';

for (i = 0; i < len; ++i) *str++ = *s++;

while (len < field_width--) *str++ = ' ';

continue;

case 'p':

if (field_width == -1)

{

field_width = 2 * sizeof(void *);

flags |= ZEROPAD;

}

str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);

continue;

case 'n':

if (qualifier == 'l')

{

long *ip = va_arg(args, long *);

*ip = (str - buf);

}

else

{

int *ip = va_arg(args, int *);

*ip = (str - buf);

}

continue;

case 'A':

flags |= LARGE;

case 'a':

if (qualifier == 'l')

str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);

else

str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);

continue;

// Integer number formats - set up the flags and "break"

case 'o':

base = 8;

break;

case 'X':

flags |= LARGE;

case 'x':

base = 16;

break;

case 'd':

case 'i':

flags |= SIGN;

case 'u':

break;

case 'E':

case 'G':

case 'e':

case 'f':

case 'g':

str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);

continue;

default:

if (*fmt != '%') *str++ = '%';

if (*fmt)

*str++ = *fmt;

else

--fmt;

continue;

}

if (qualifier == 'l')

num = va_arg(args, unsigned long);

else if (qualifier == 'h')

{

if (flags & SIGN)

num = va_arg(args, short);

else

num = va_arg(args, unsigned short);

}

else if (flags & SIGN)

num = va_arg(args, int);

else

num = va_arg(args, unsigned int);

str = number(str, num, base, field_width, precision, flags);

}

*str = '\0';

return str - buf;

}