cout顺序，i++和++i，*p++和*++p

1.cout输出流顺序

cout是从右到左读取参数，如果参数是函数，则先执行函数体，再将返回的值压栈，否则直接将值压栈，最后再将栈中的值输出来

#include <iostream>
using namespace std;
int hello1();
int hello2();
int main() 
{
    int a, b;
    cout << "a=" << hello1() << endl << "b=" << hello2() << endl;
    return 0;
}
int hello1()
{
    cout << "hello1" << endl;
    return 1;
}
int hello2() 
{
    cout << "hello2" << endl;
    return 2;
}

其输出为：

hello2
hello1
a=1
b=2

因为cout输出时，先从右往左扫描，将数据读入缓冲区，然后再从左往右输出。所以，从右往左读取缓冲区的时候，先遇到函数hello2()，那么先执行函数，然后将函数的返回值作为数据读取缓冲区。

cout的输出流顺序_吕白_的博客-CSDN博客

2.i++ , ++i 的本质可视为有返回值的函数

T operator ++()                    //++var
{
    var = var+1;
    return var;
}
T operator ++(int dummy)        //var++(dummy)
{
    T tmp = var;
    var = var+1;
    return tmp;  
}

那么同样，cout是从右到左读取参数，若遇到i++，则立即将i的值压栈（注意是值，而不是i的引用），再执行i+1；若遇到++i，则先执行i+1，再将i的引用压栈（而不是i的值，是引用！！！）；若遇到i，则将i的引用压栈。

 

3.*p++和*++p

p++：等同于：*p;  p += 1;
解析：由于*和++的运算优先级一样，且是右结合。故*p++相当于*(p++)，p先与++结合，然后p++整体再与*结合。前面陈述是一种最常见的错误，很多初学者也是这么理解的。但是，因为++后置的时候，本身含义就是先运算后增加1（运算指的是p++作为一个整体与前面的*进行运算；增加1指的是p+1），所以实际上*p++符号整体对外表现的值是*p的值，运算完成后p再加1.

【注意】是运算后p再加1，而不是p所指向的变量*p再加1

 

*++p：等同于 p += 1;    *p;
解析：由于++在p的前面，++前置的含义是，先加1，得到一个新的p（它的值是原来p的值加1）。然后这个新的p再与前面的*结合.

【总结】无论是*p++还是*++p，都是指针p += 1，即p的值+1，而不是p所指向的变量*p的值+1。

++前置与++后置，只是决定了到底是先p += 1，还是先*p。++前置表示先p += 1，再*p。++后置表示先*p，在p += 1；

--前置与--后置的的分析方法++前置与++后置的一样。

 

【补充】  (*p)++  与 ++(*p)

 (*p)++，使用()强制将*与p结合，只能先计算*p，然后对*p整体的值++。

 ++(*p)，先*p取值，再前置++，[该值+1后]作为整个表达式的值。

举例：

int a[5]={1,2,3,4,5};
int *p = a;

*p++ 先取指针p指向的值（数组第一个元素1），再将指针p自增1；

cout << *p++; // 结果为 1

cout <<(*p++); // 1

(*p)++ 先去指针p指向的值（数组第一个元素1），再将该值自增1（数组第一个元素变为2

cout << (*p)++; // 1

cout <<((*p)++) //2

*++p 先将指针p自增1（此时指向数组第二个元素），* 操作再取出该值

cout << *++p; // 2

cout <<(*++p) //2

++*p 先取指针p指向的值（数组第一个元素1），再将该值自增1（数组第一个元素变为2）

cout <<++*p; // 2

cout <<(++*p) //2

 对*p++与*++p；(*p)++ 与 ++(*p)的理解_请叫我皮皮虾的博客-CSDN博客_*p++和*++p

 

cout输出流的执行顺序

下面是IBM的一道笔试题

#include <iostream> using namespace std; 
int fun( ) { 
cout << "f" ; return 1; } int main() { 
int i = 1; // cout << i++ << i++ << i++ << endl; cout << "m" << fun() << fun() << fun() << endl; 
return 1; } 
输出fffm111 
问题：cout这种连接写法的输出的执行顺序是啥呢？ 
cout<<"m"<<fun1()<<fun2()<<fun3()<<endl; 
<<运算是左结合的。 必然先求cout<<"m"的值，值仍然是cout 
然后试图求cout<<fun1()的值，这必须先求出fun1()的值。整个表达式的值仍然是cout 然后试图求cout<<fun2()的值，这必须先求出fun2()的值。整个表达式的值仍然是cout 
然后试图求cout<<fun3()的值，这必须先求出fun3()的值。整个表达式的值仍然是cout 
最后是cout<<endl的值，值是cout 整个表达式语句以分号结尾 
注意：问题就在这里：“这必须先求出fun1()的值”，“这必须先求出fun2()的值”，“这必须先求出fun3()的值”，这3句。这是计算<<运算的前提。只要分别在计算cout<<fun1()，cout<<fun2()，cout<<fun3()，之前完成就可以了。 
因此，具体是先计算fun1()的值，还是先计算fun2()的值，还是先计算fun3()的值，还是先计算cout<<"m"的值，都不影响表达式的值。 
问题就在这里： 这是个<<表达式。<<本来是位运算，但是这里cout却是来利用运算的“副作用”。 
所谓副作用，就是计算一个表达式的时候，除了得到它的值以外，对环境产生的影响都是副作用。 比如： int a=1,b=2,c=3,d; 
d=a<<b: 
这一步，a<<b计算出1左移2位得到的结果。结果是4。也就是说，赋值表达式结束后，d的值变成4，其它地方都没有改变。这就是说这个<<运算没有副作用。 
但是，cout<<"a"就不一样了。这个表达式的值我们根本就不关心。我们只关心，这个表达式“计算”完以后，"a"被输出到屏幕上了。这里“a被输出到屏幕上”就是副作用。 
   再看这个例子： int foo(int a, int b) { return a+b; } int bar(int a, int b) { return a-b; } int a=1,b=2,c=3,d; d=foo(a,b)+bar(b,d); 
这里，foo()和bar()都没有副作用。因此，这个表达式，不论是先计算foo(a,b)的值，还是先计算bar(b,c)的值，都不会影响计算的结果。 
但是，如果是这个例子： int foo(int* a) { (*a)++; return *a;} int bar(int* a) { (*a)--; return *a;} int a=5,b; b=foo(&a)+bar(&a); 
这个表达式，foo()和bar()都有副作用，所以，先计算foo(&a)还是先计算bar(&a)，将直接影响到b的值。 
假如先计算foo，再计算bar。 首先，a=5 计算foo(&a)，a变成6，foo(&a)的值是6 
计算bar(&a)，a变成5，bar(&a)的值是5 这样，b=6+5=11 假如先计算bar，再计算foo。 
首先，a=5 计算bar(&a)，a变成4，foo(&a)的值是4 
计算foo(&a)，a变成5，bar(&a)的值是5 这样，b=5+4=9 这就造成了计算结果不一致。    ＝＝＝ 那。。。怎么办 一般来说，编c/c++程序有一个纪律：一个语句中不要有两个表达式有副作用。 
典型的这类行为包括：b=(a++)+(a++)+(a++); 
这是典型的违反这条纪律的行为。每个a++都有副作用（改变a的值）。整个表达式的值跟求值顺序直接相连。 还有就是 char* fun() { cout<<"q"; return ""; } 
cout<<"m"<<fun()<<fun()<<fun()<<endl; 
每个fun()都有副作用（向屏幕上显示字符）。因此效果直接与求值顺序相关。（而整个表达式的值我们根本就不关心。虽然我知道，值就是cout）。 
＝＝＝＝＝＝ 
在c/c++中，求值顺序是怎么样的？ 
不知道。 
C/C++的规范中，求值顺序是不规定的。这是为了给编译器以优化的空间。 
比如： 
b=(a+2)+(a+2);，那么如果只计算一次a+2的值，而不是两次，那么计算量会大大降低。 
因此， 
不要在C语言里面做这种事情： 
char* fun() { cout<<"q"; return ""; } 
cout<<"m"<<fun()<<fun()<<fun()<<endl; 
要这样： 
char* fun() { return "q"; } 
cout<<"m"<<fun()<<fun()<<fun()<<endl; // 输出的一定是 "mqqq\n" 
这样更好： 
string fun() { return string("q"); } 
cout<<"m"<<fun()<<fun()<<fun()<<endl; // 输出的一定是 "mqqq\n" 
这样就更好了： 
string f="q"; // 隐式转换 
cout<<"m"<<fun()<<fun()<<fun()<<endl; // 输出的一定是 "mqqq\n" 
但是这样不好吗？： cout<<"mqqq"<<endl; 
  这应该只是个测验。我相信IBM的软件工程师们不会编出这种垃圾代码的。

代码稍微修改了下 
#include <iostream> 
using namespace std; 
int fun(int i) { cout << "f"<<i; return i; } 
int main() { 
int i = 1; cout << i++ << i++ << i++ << endl; cout << "m" << fun(1) << fun(2) << fun(3) << endl; cin.get(); return 1; } 
输出结果： 321 f3f2f1m123

如果只针对题来说的话，实际是这样的 
cout<<"m"<<fun()<<fun()<<fun(); 
对于<<其实是从右往左处理的。于是碰到fun()必然先输出f,然后返回1，于是就变成了 
cout<<"m"<<fun()<<fun()<<1; 继续往左走，直到 cout<<"m"<<1<<1<<1 ;的时候已经输出了fff ,之后就是按顺序输出了m111, 所以看到的结果就是 fffm111 

cout 计算顺序问题 - little_by - 博客园 (cnblogs.com)