比如 b=a++ 是先把a的值赋给b之后a再自增，但是++的优先级比=高啊，这样++的运算符优先级岂不是没有用了
28 个解决方案
#1
无聊的问题，
分两步写不就得了
a++;
b=a;
分两步写不就得了
a++;
b=a;
#2
++在前优先级高，++在后优先级低
#3
++的优先级高，但a++的值还是a，不知道这样说明白不
#4
为什么没用了啊，它使a增加了1呀
#5
跟优先级有什么关系？
后++是赋值完了在加
后++是赋值完了在加
#6
#7
不是那个意思
我知道++的用法 我是说在运算符级别的表中 ++是第二个级别 是比较高的 但比如在b=a++中 是先把a的值赋给b之后a再自增 就是说遇到a++都是先把a的值传到表达式 再自增 或者++a是先自增 似乎就跟优先级别没有关系了啊 为什么还会出现在优先级的表中
我知道++的用法 我是说在运算符级别的表中 ++是第二个级别 是比较高的 但比如在b=a++中 是先把a的值赋给b之后a再自增 就是说遇到a++都是先把a的值传到表达式 再自增 或者++a是先自增 似乎就跟优先级别没有关系了啊 为什么还会出现在优先级的表中
#8
.....
#9
优先级就是告诉编译器哪些先做，哪些后做~它可不关心效果怎么样
b=a++ ;
++优先级高，所以先执行a++，这种优先级高的先执行的效果已经达到，怎么能说没用呢？
b=a++ ;
++优先级高，所以先执行a++，这种优先级高的先执行的效果已经达到，怎么能说没用呢？
#10
什么叫“运算级有用”？
你把a++当成一个函数，运行该函数有两个作用：让a自增1 ，返回a的旧值。
执行a++的时候，a++整个表达式等于a的旧值，而a已经是新值了。
你把a++当成一个函数，运行该函数有两个作用：让a自增1 ，返回a的旧值。
执行a++的时候，a++整个表达式等于a的旧值，而a已经是新值了。
#11
楼主的理解有问题。同意3楼和10楼的观点。也同意9楼的观点，但这种说法可能会误导楼主。
运算符的本质仍然是函数，做过运算符重载的朋友应该都非常清楚。
设a++对应的函数为plus1，而++a对应的函数为plus2,两函数分别定义如下（这是帮且楼理解这两个操作符，具体指针使用是否有问题请不要太计较）
int plus1(int &x) {
int b=x;
*x++;
return b;
}
int plus2(int &x) {
*x++;
return *x;
}
b=a++;
可以写成
b=plus1(a);
其执行结果应该等同于
b=a;
a++;
而
b=++a;
可以写成
b=plus2(a);
执行结果才等同于
a++;
b=a;
运算符的本质仍然是函数，做过运算符重载的朋友应该都非常清楚。
设a++对应的函数为plus1，而++a对应的函数为plus2,两函数分别定义如下（这是帮且楼理解这两个操作符，具体指针使用是否有问题请不要太计较）
int plus1(int &x) {
int b=x;
*x++;
return b;
}
int plus2(int &x) {
*x++;
return *x;
}
b=a++;
可以写成
b=plus1(a);
其执行结果应该等同于
b=a;
a++;
而
b=++a;
可以写成
b=plus2(a);
执行结果才等同于
a++;
b=a;
#12
学了一段时间了 突然想到这个问题 也许没意义 但就是不明白
b=a++;先是a把值赋给表达式，a再自增，但是如果安运算优先级的话，++比=高，这样不是应该先执行++，在执行赋值吗，可是实际不是这样
b=a++;先是a把值赋给表达式，a再自增，但是如果安运算优先级的话，++比=高，这样不是应该先执行++，在执行赋值吗，可是实际不是这样
#13
yeyumin89,
“++”的优先级高于“＝”，这一点没有任何疑问。
要注意的是，++操作符前置和++操作符后置是两完全独立的函数。如果误将它们当作一个函数，当然没办法理解。
这两个函数虽然都可以使传入的参数值加1；但前置++函数返回的是加1以后的值，而后置++函数返回的是加1之前的参数值。也就是说，两个函数返回的值是不同的。（参见11楼回复）
如果讲到这个份上楼主还不能理解的话，别人可能真就帮不上什么忙了。
“++”的优先级高于“＝”，这一点没有任何疑问。
要注意的是，++操作符前置和++操作符后置是两完全独立的函数。如果误将它们当作一个函数，当然没办法理解。
这两个函数虽然都可以使传入的参数值加1；但前置++函数返回的是加1以后的值，而后置++函数返回的是加1之前的参数值。也就是说，两个函数返回的值是不同的。（参见11楼回复）
如果讲到这个份上楼主还不能理解的话，别人可能真就帮不上什么忙了。
#14
当用a做控制变量的时候就有用
比如int a=10,b;while(b=a--);
比如int a=10,b;while(b=a--);
#15
楼主还没弄明白优先级和返回值的问题。
a++ 是先返回 a 的值，然后 a 自增。
a++ 是先返回 a 的值，然后 a 自增。
#16
b=a++;
这里可以认为编译器做优化了
如果楼主实在想验证=和++优先级的话
就重载这两个操作符，因为重载之后符号的优先级保持不变
这里可以认为编译器做优化了
如果楼主实在想验证=和++优先级的话
就重载这两个操作符，因为重载之后符号的优先级保持不变
#17
首先要明白一点，那就是++表达式是一份拷贝，而不是变量的值。
其次，操作符在操作数的前面时，首先增加操作数的值，然后拷贝该值作为表达式的值，
操作符在操作数的后面时，首先拷贝该值作为表达式的值，然后在增加操作数的值。
举例说明
这样够明了了吧，嘿么嘿么^_^
其次，操作符在操作数的前面时，首先增加操作数的值，然后拷贝该值作为表达式的值，
操作符在操作数的后面时，首先拷贝该值作为表达式的值，然后在增加操作数的值。
举例说明
int a,b,c,d;
a = b = 10;
c = ++a; //首先根据运算符优先级，先进行++a（先对a加1，a等于11，然后拷贝a的值作为表达式的值），在执行赋值，因为赋值操作是将表示式的值赋给变量，也就是把拷贝的值赋给变量，此时c 等于11。
d = b++; //同上，先进行b++（先拷贝b的值作为表达式的值，表达式为10，然后b加1，b等于11），在执行赋值操作，将表达式的值赋给变量d，d 等于10。
//下面用法错误：
++a = 10； //因为此时=左边为a值的拷贝，不是变量，你无法向一个值赋值。
这样够明了了吧，嘿么嘿么^_^
#18
楼主要记得结贴啊
#19
LZ可以这样理解，
b = a++;
++的优先级比=高，所以先执行++，那么a++返回值是a，所以接下来把a的值赋值给b；
但是++有个副作用，就是执行之后将a的值增1，所以当这语句整体执行完了后，a变成了a + 1的。
b = a++;
++的优先级比=高，所以先执行++，那么a++返回值是a，所以接下来把a的值赋值给b；
但是++有个副作用，就是执行之后将a的值增1，所以当这语句整体执行完了后，a变成了a + 1的。
#20
搞不清楚优先级就多加括号呗
VC调试时按Alt+8,TC或BC用TD调试,打开汇编窗口看每句C对应的汇编不就啥都明白了吗。
（Linux或Unix下应该也可以在用GDB调试时,看每句C对应的汇编。）
VC调试时按Alt+8,TC或BC用TD调试,打开汇编窗口看每句C对应的汇编不就啥都明白了吗。
（Linux或Unix下应该也可以在用GDB调试时,看每句C对应的汇编。）
#21
成天整些无聊的问题来困惑自己
#22
这个用得着讨论嘛
#23
其实很简单，你的理解错了。b=a++，是先把a的值增加1，再把a以前的值赋给b,而不是像你说的先把a的值赋给b。
---------------------------------------------------------------------------------------
++在前面和后面分别是先自增和后自增，那这样++/--的运算符优先级岂不是没有用处了?
比如 b=a++ 是先把a的值赋给b之后a再自增，但是++的优先级比=高啊，这样++的运算符优先级岂不是没有用了
---------------------------------------------------------------------------------------
++在前面和后面分别是先自增和后自增，那这样++/--的运算符优先级岂不是没有用处了?
比如 b=a++ 是先把a的值赋给b之后a再自增，但是++的优先级比=高啊，这样++的运算符优先级岂不是没有用了
#24
蛋疼·······
#25
个人觉得：
b=a++;
优先级还是++比=高
因为a++在b=a++这个等式中充当了一个表达式的作用
a++先运算，但是（a++）这个表达式本身=a(old)，同时这个时候a=a(old)+1
b=a++，并不是b=a
楼主纠结的也许还是：b=a++和b=a结果一样，为什么还要向前面那样？
很简单，b=a++得目的是将原来的a赋值给b，同时希望a赋值后自加1；b=a这样的目的只是将a赋值给b
b=a++;
优先级还是++比=高
因为a++在b=a++这个等式中充当了一个表达式的作用
a++先运算，但是（a++）这个表达式本身=a(old)，同时这个时候a=a(old)+1
b=a++，并不是b=a
楼主纠结的也许还是：b=a++和b=a结果一样，为什么还要向前面那样？
很简单，b=a++得目的是将原来的a赋值给b，同时希望a赋值后自加1；b=a这样的目的只是将a赋值给b
#26
懂了 这下。。。
#27
你的说法是错误的
b=a++不是算把a的值赋给b，而是先算a++，返回值为a原来的值
再把返回值赋给b
LZ没有开明白自增运算
前自增与后自增不光是使变量的值+1,既然它们是运算符，那么a++与++a就是运算表达式
必然是要有个结果的，前自增与后自增的区别就是这个结果
#28
现在懂了 谢谢
#1
无聊的问题，
分两步写不就得了
a++;
b=a;
分两步写不就得了
a++;
b=a;
#2
++在前优先级高，++在后优先级低
#3
++的优先级高，但a++的值还是a，不知道这样说明白不
#4
为什么没用了啊，它使a增加了1呀
#5
跟优先级有什么关系？
后++是赋值完了在加
后++是赋值完了在加
#6
#7
不是那个意思
我知道++的用法 我是说在运算符级别的表中 ++是第二个级别 是比较高的 但比如在b=a++中 是先把a的值赋给b之后a再自增 就是说遇到a++都是先把a的值传到表达式 再自增 或者++a是先自增 似乎就跟优先级别没有关系了啊 为什么还会出现在优先级的表中
我知道++的用法 我是说在运算符级别的表中 ++是第二个级别 是比较高的 但比如在b=a++中 是先把a的值赋给b之后a再自增 就是说遇到a++都是先把a的值传到表达式 再自增 或者++a是先自增 似乎就跟优先级别没有关系了啊 为什么还会出现在优先级的表中
#8
.....
#9
优先级就是告诉编译器哪些先做，哪些后做~它可不关心效果怎么样
b=a++ ;
++优先级高，所以先执行a++，这种优先级高的先执行的效果已经达到，怎么能说没用呢？
b=a++ ;
++优先级高，所以先执行a++，这种优先级高的先执行的效果已经达到，怎么能说没用呢？
#10
什么叫“运算级有用”？
你把a++当成一个函数，运行该函数有两个作用：让a自增1 ，返回a的旧值。
执行a++的时候，a++整个表达式等于a的旧值，而a已经是新值了。
你把a++当成一个函数，运行该函数有两个作用：让a自增1 ，返回a的旧值。
执行a++的时候，a++整个表达式等于a的旧值，而a已经是新值了。
#11
楼主的理解有问题。同意3楼和10楼的观点。也同意9楼的观点，但这种说法可能会误导楼主。
运算符的本质仍然是函数，做过运算符重载的朋友应该都非常清楚。
设a++对应的函数为plus1，而++a对应的函数为plus2,两函数分别定义如下（这是帮且楼理解这两个操作符，具体指针使用是否有问题请不要太计较）
int plus1(int &x) {
int b=x;
*x++;
return b;
}
int plus2(int &x) {
*x++;
return *x;
}
b=a++;
可以写成
b=plus1(a);
其执行结果应该等同于
b=a;
a++;
而
b=++a;
可以写成
b=plus2(a);
执行结果才等同于
a++;
b=a;
运算符的本质仍然是函数，做过运算符重载的朋友应该都非常清楚。
设a++对应的函数为plus1，而++a对应的函数为plus2,两函数分别定义如下（这是帮且楼理解这两个操作符，具体指针使用是否有问题请不要太计较）
int plus1(int &x) {
int b=x;
*x++;
return b;
}
int plus2(int &x) {
*x++;
return *x;
}
b=a++;
可以写成
b=plus1(a);
其执行结果应该等同于
b=a;
a++;
而
b=++a;
可以写成
b=plus2(a);
执行结果才等同于
a++;
b=a;
#12
学了一段时间了 突然想到这个问题 也许没意义 但就是不明白
b=a++;先是a把值赋给表达式，a再自增，但是如果安运算优先级的话，++比=高，这样不是应该先执行++，在执行赋值吗，可是实际不是这样
b=a++;先是a把值赋给表达式，a再自增，但是如果安运算优先级的话，++比=高，这样不是应该先执行++，在执行赋值吗，可是实际不是这样
#13
yeyumin89,
“++”的优先级高于“＝”，这一点没有任何疑问。
要注意的是，++操作符前置和++操作符后置是两完全独立的函数。如果误将它们当作一个函数，当然没办法理解。
这两个函数虽然都可以使传入的参数值加1；但前置++函数返回的是加1以后的值，而后置++函数返回的是加1之前的参数值。也就是说，两个函数返回的值是不同的。（参见11楼回复）
如果讲到这个份上楼主还不能理解的话，别人可能真就帮不上什么忙了。
“++”的优先级高于“＝”，这一点没有任何疑问。
要注意的是，++操作符前置和++操作符后置是两完全独立的函数。如果误将它们当作一个函数，当然没办法理解。
这两个函数虽然都可以使传入的参数值加1；但前置++函数返回的是加1以后的值，而后置++函数返回的是加1之前的参数值。也就是说，两个函数返回的值是不同的。（参见11楼回复）
如果讲到这个份上楼主还不能理解的话，别人可能真就帮不上什么忙了。
#14
当用a做控制变量的时候就有用
比如int a=10,b;while(b=a--);
比如int a=10,b;while(b=a--);
#15
楼主还没弄明白优先级和返回值的问题。
a++ 是先返回 a 的值，然后 a 自增。
a++ 是先返回 a 的值，然后 a 自增。
#16
b=a++;
这里可以认为编译器做优化了
如果楼主实在想验证=和++优先级的话
就重载这两个操作符，因为重载之后符号的优先级保持不变
这里可以认为编译器做优化了
如果楼主实在想验证=和++优先级的话
就重载这两个操作符，因为重载之后符号的优先级保持不变
#17
首先要明白一点，那就是++表达式是一份拷贝，而不是变量的值。
其次，操作符在操作数的前面时，首先增加操作数的值，然后拷贝该值作为表达式的值，
操作符在操作数的后面时，首先拷贝该值作为表达式的值，然后在增加操作数的值。
举例说明
这样够明了了吧，嘿么嘿么^_^
其次，操作符在操作数的前面时，首先增加操作数的值，然后拷贝该值作为表达式的值，
操作符在操作数的后面时，首先拷贝该值作为表达式的值，然后在增加操作数的值。
举例说明
int a,b,c,d;
a = b = 10;
c = ++a; //首先根据运算符优先级，先进行++a（先对a加1，a等于11，然后拷贝a的值作为表达式的值），在执行赋值，因为赋值操作是将表示式的值赋给变量，也就是把拷贝的值赋给变量，此时c 等于11。
d = b++; //同上，先进行b++（先拷贝b的值作为表达式的值，表达式为10，然后b加1，b等于11），在执行赋值操作，将表达式的值赋给变量d，d 等于10。
//下面用法错误：
++a = 10； //因为此时=左边为a值的拷贝，不是变量，你无法向一个值赋值。
这样够明了了吧，嘿么嘿么^_^
#18
楼主要记得结贴啊
#19
LZ可以这样理解，
b = a++;
++的优先级比=高，所以先执行++，那么a++返回值是a，所以接下来把a的值赋值给b；
但是++有个副作用，就是执行之后将a的值增1，所以当这语句整体执行完了后，a变成了a + 1的。
b = a++;
++的优先级比=高，所以先执行++，那么a++返回值是a，所以接下来把a的值赋值给b；
但是++有个副作用，就是执行之后将a的值增1，所以当这语句整体执行完了后，a变成了a + 1的。
#20
搞不清楚优先级就多加括号呗
VC调试时按Alt+8,TC或BC用TD调试,打开汇编窗口看每句C对应的汇编不就啥都明白了吗。
（Linux或Unix下应该也可以在用GDB调试时,看每句C对应的汇编。）
VC调试时按Alt+8,TC或BC用TD调试,打开汇编窗口看每句C对应的汇编不就啥都明白了吗。
（Linux或Unix下应该也可以在用GDB调试时,看每句C对应的汇编。）
#21
成天整些无聊的问题来困惑自己
#22
这个用得着讨论嘛
#23
其实很简单，你的理解错了。b=a++，是先把a的值增加1，再把a以前的值赋给b,而不是像你说的先把a的值赋给b。
---------------------------------------------------------------------------------------
++在前面和后面分别是先自增和后自增，那这样++/--的运算符优先级岂不是没有用处了?
比如 b=a++ 是先把a的值赋给b之后a再自增，但是++的优先级比=高啊，这样++的运算符优先级岂不是没有用了
---------------------------------------------------------------------------------------
++在前面和后面分别是先自增和后自增，那这样++/--的运算符优先级岂不是没有用处了?
比如 b=a++ 是先把a的值赋给b之后a再自增，但是++的优先级比=高啊，这样++的运算符优先级岂不是没有用了
#24
蛋疼·······
#25
个人觉得：
b=a++;
优先级还是++比=高
因为a++在b=a++这个等式中充当了一个表达式的作用
a++先运算，但是（a++）这个表达式本身=a(old)，同时这个时候a=a(old)+1
b=a++，并不是b=a
楼主纠结的也许还是：b=a++和b=a结果一样，为什么还要向前面那样？
很简单，b=a++得目的是将原来的a赋值给b，同时希望a赋值后自加1；b=a这样的目的只是将a赋值给b
b=a++;
优先级还是++比=高
因为a++在b=a++这个等式中充当了一个表达式的作用
a++先运算，但是（a++）这个表达式本身=a(old)，同时这个时候a=a(old)+1
b=a++，并不是b=a
楼主纠结的也许还是：b=a++和b=a结果一样，为什么还要向前面那样？
很简单，b=a++得目的是将原来的a赋值给b，同时希望a赋值后自加1；b=a这样的目的只是将a赋值给b
#26
懂了 这下。。。
#27
你的说法是错误的
b=a++不是算把a的值赋给b，而是先算a++，返回值为a原来的值
再把返回值赋给b
LZ没有开明白自增运算
前自增与后自增不光是使变量的值+1,既然它们是运算符，那么a++与++a就是运算表达式
必然是要有个结果的，前自增与后自增的区别就是这个结果
#28
现在懂了 谢谢