双11狂欢大促

盲盒赢 定制羽绒服

开启惊喜盲盒，抽取你的专属好礼

— 惊喜奖品抢先看 —

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

为什么原文说total+=start++和total+=(start++)是等价的？

2015-03-20 02:22:52 723 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

R2Freedom 墨衍会员 · AI 创作全网分发关注 + 加入社区

PCB设计之ODB++文件格式详解 ODB++（Open Database++）是一种广泛应用于PCB（印制电路板）设计和制造领域的开放数据交换格式。它由Valor Computerized Systems（现为Siemens EDA的一部分）开发，旨在替代传统的Gerber文件格式，提供更完整、结构化的制造数据，从而优化PCB设计到生产的流程。ODB++通过结构化数据整合了PCB设计到制造的全流程信息，显著提高了生产效率和准确性。尽管存在一定的兼容性挑战，但其在复杂项目和高可靠性场景中的价值不可替代。阅读详情

《C primer plus》中的一道题目，文中说total+=*start++和total+=*(start++)是一样的，这里我想不通，加了括号后不是应该先算括号里的内容么？怎么会是一样的呢。请高手解答！

#include <stdio.h>

#define SIZE 10

int sump(int *start,int *end);



int main()

{

    int marbles[SIZE]={20,10,5,39,4,16,19,26,31,20};

    long answer;



    answer=sump(marbles,marbles+SIZE);

    printf("%ld.\n",answer);

    return 0;

}



int sump(int *start,int *end)

{

    int total=0;

    while(start<end)

        total+=*(start++);

    return total;

}

...全文

C/C++中i++与++i的深度解析：从原理到性能优化自增运算符是编程语言中的基础概念，用于对变量进行加一操作。其核心原理在于运算符的返回值机制：前缀形式返回变量自身的引用，后缀形式返回变量旧值的临时副本。这一底层差异直接影响了表达式的求值顺序和编译器的优化策略。从技术价值看，理解自增运算符有助于掌握内存模型、表达式副作用和编译器行为，是编写高效、安全代码的基础。在实际应用场景中，对于内置类型，现代编译器通常能优化掉性能差异；但对于迭代器和自定义类型，前缀形式可避免不必要的临时对象构造，在紧密循环中可能带来性能优势。本文聚焦于C/C++中的自增运算符，通过分析阅读详情

R2Freedom

C语言 70,039 成员 243,237 内容

+ 关注 + 加入社区

切换为时间正序

愿你变作彩霞 2016-05-16

打赏
举报

引用 6 楼 my_live_123 的回复:

C99

想知道这张图的出处，顺便primary-expression应该是前++，postfix-expression应该是后++吧

飞行1-5 2015-03-23

打赏
举报

start++这句还没结束时，start指针地址不变，所以取*不变

fly_dragon_fly 2015-03-23

打赏
举报

把start++这个表达式看成一个函数，看看它的返回值，它是这样的 tmp=start, ++start, return tmp; 而(start++) 是这样的 ( tmp=start, ++start,return tmp) 比较一下，显然是一样的

一根烂笔头 2015-03-23

打赏
举报

引用 11 楼 cfvmario 的回复:

就算编译角度有差别，现代计算机需要在乎这点？我强烈建议一律加括号，可读性才是第一位的

鱼和熊掌不可兼得，看个人选择！爱速度的人，还是喜欢压榨时间的，无论编译还是运行！

cfvmario 2015-03-23

打赏
举报

就算编译角度有差别，现代计算机需要在乎这点？我强烈建议一律加括号，可读性才是第一位的

左眼看到鬼 2015-03-21

打赏
举报

引用 8 楼 luckyaslan 的回复:

根据运算符优先级来看： total+=*start++ 的执行顺序是这样的：total += (*start)++ 所以等同于下面两个表达式： total+=(*start)++ total+=*(start++) 在这里把++的作用理解了，这个问题就看明白了。例如:i++ i++的实现如下：
{
int temp;
temp = i;
i = i+1;
return temp;
}
可以看出来i++；执行后，得到的值，是一个临时变量，这个值和i之前的值是相同的。

写错了。二楼说的对。

左眼看到鬼 2015-03-21

打赏
举报

根据运算符优先级来看： total+=*start++ 的执行顺序是这样的：total += (*start)++ 所以等同于下面两个表达式： total+=(*start)++ total+=*(start++) 在这里把++的作用理解了，这个问题就看明白了。例如:i++ i++的实现如下：


{
int temp;
temp = i;
i = i+1;
return temp;
}

可以看出来i++；执行后，得到的值，是一个临时变量，这个值和i之前的值是相同的。

一根烂笔头 2015-03-20

打赏
举报

解释一下： total+=*start++和total+=*(start++)从结果上讲是一样的，从编译角度讲不太一样 *属于unary-operator ++放在表达式之后，构成：postfix-expression ++ total+=*start++ 从语法分析上要先分析postfix-expression ++，然后转到unary-expression，过度到cast-expression，整合 * 的unary-operator组合成unary-operator cast-expression，最后转一圈回到赋值表达式因此先执行++，再执行* total+=*(start++) 要比上面不加括号的情况下，多一圈语法分析；即start++自身走一圈回到exp，然后再转一圈把*整合进去。因此从编译角度讲，如果想让代码编译更快点，在知道优先级的情况下，优先选择total+=*start++，因为每加一个括号，就要从上面12点钟方向重新开始一遍语法分析。不过，编译出来的指令都是一样的，因此运算结果也都是一样的。

一根烂笔头 2015-03-20

打赏
举报

C99

dooX8086 2015-03-20

打赏
举报


//只要了解后缀 ++ 就很清楚了
// 后缀 ++ 其实就是豆号表达式组
// 如: 把 start++ 展开就是
int *tmp;   //编译器创建的临时变量
(tmp = start, start = start + 1, tmp);

//那么: total+=*(start++);  就是 
int *tmp;   
total += *( (tmp = start, start = start + 1, tmp) );   // 所以外面这对 () 添加以否都是一样的

// 一目了然了.....
//

赵4老师 2015-03-20

打赏
举报

//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//| Operator         | Name or Meaning                         | Associativity |
//+------------------+-----------------------------------------+---------------+
//| ::               | Scope resolution                        | None          |
//| ::               | Global                                  | None          |
//| [ ]              | Array subscript                         | Left to right |
//| ( )              | Function call                           | Left to right |
//| ( )              | Conversion                              | None          |
//| .                | Member selection (object)               | Left to right |
//| ->               | Member selection (pointer)              | Left to right |
//| ++               | Postfix increment                       | None          |
//| --               | Postfix decrement                       | None          |
//| new              | Allocate object                         | None          |
//| delete           | Deallocate object                       | None          |
//| delete[ ]        | Deallocate object                       | None          |
//| ++               | Prefix increment                        | None          |
//| --               | Prefix decrement                        | None          |
//| *                | Dereference                             | None          |
//| &                | Address-of                              | None          |
//| +                | Unary plus                              | None          |
//| -                | Arithmetic negation (unary)             | None          |
//| !                | Logical NOT                             | None          |
//| ~                | Bitwise complement                      | None          |
//| sizeof           | Size of object                          | None          |
//| sizeof ( )       | Size of type                            | None          |
//| typeid( )        | type name                               | None          |
//| (type)           | Type cast (conversion)                  | Right to left |
//| const_cast       | Type cast (conversion)                  | None          |
//| dynamic_cast     | Type cast (conversion)                  | None          |
//| reinterpret_cast | Type cast (conversion)                  | None          |
//| static_cast      | Type cast (conversion)                  | None          |
//| .*               | Apply pointer to class member (objects) | Left to right |
//| ->*              | Dereference pointer to class member     | Left to right |
//| *                | Multiplication                          | Left to right |
//| /                | Division                                | Left to right |
//| %                | Remainder (modulus)                     | Left to right |
//| +                | Addition                                | Left to right |
//| -                | Subtraction                             | Left to right |
//| <<               | Left shift                              | Left to right |
//| >>               | Right shift                             | Left to right |
//| <                | Less than                               | Left to right |
//| >                | Greater than                            | Left to right |
//| <=               | Less than or equal to                   | Left to right |
//| >=               | Greater than or equal to                | Left to right |
//| ==               | Equality                                | Left to right |
//| !=               | Inequality                              | Left to right |
//| &                | Bitwise AND                             | Left to right |
//| ^                | Bitwise exclusive OR                    | Left to right |
//| |                | Bitwise OR                              | Left to right |
//| &&               | Logical AND                             | Left to right |
//| ||               | Logical OR                              | Left to right |
//| e1?e2:e3         | Conditional                             | Right to left |
//| =                | Assignment                              | Right to left |
//| *=               | Multiplication assignment               | Right to left |
//| /=               | Division assignment                     | Right to left |
//| %=               | Modulus assignment                      | Right to left |
//| +=               | Addition assignment                     | Right to left |
//| -=               | Subtraction assignment                  | Right to left |
//| <<=              | Left-shift assignment                   | Right to left |
//| >>=              | Right-shift assignment                  | Right to left |
//| &=               | Bitwise AND assignment                  | Right to left |
//| |=               | Bitwise inclusive OR assignment         | Right to left |
//| ^=               | Bitwise exclusive OR assignment         | Right to left |
//| ,                | Comma                                   | Left to right |
//+------------------+-----------------------------------------+---------------+

晓石头 2015-03-20

打赏
举报

total+=*start++和total+=*(start++)
因为不管是那种情况都是先执行*start，再赋值运算，最后start+1，
除非是*(++start)才先执行start+1，再*start，再赋值运算，
我理解形如i++的操作，是等赋值运算完后再执行的操作

zuxi 2015-03-20

打赏
举报

这里是优先级表： http://www.slyar.com/blog/c-operator-priority.html 虽然*和++优先级一样，但是结合性是从右到左，也就是说它们在一起时右边的优先级高。

只此冒泡君 2015-03-20

打赏
举报

因为自增++ 在这里面的优先级最高加不加括号都一样！

✦双11狂欢大促✦

为什么原文说total+=*start++和total+=*(start++)是等价的？

相关推荐

双11狂欢大促

为什么原文说total+=start++和total+=(start++)是等价的？