自加-自减运算符在应用中需要注意几点问题
试析C语言表达式中自加、自减运算
ｅ ｅ ｏ ｆｐ ｏ ｒ ｍｍｉ ｇ ｅ ｐ ｒ ｗｉ ｒ ｄ ｃ ｏ ｆ ｓｏ ． ｈ ｓ ｐ ｐ ｒ ａ ａｙ ｅ ｎ ｕ ｖ ｎ ａ ｌｔｏ ｒ ｇａ ｎ ｘ ｅｔ ｌ ｐ ｏ ｕ ｅ ｃ ｎ ｕ ｉｎ Ｔ ｉ ａ ｅ ｎ ｌ ｚ ｄ ａ ｄ ｓ ｍｍａ ｚ ｄ ｂ ｘ ｍｐ ｅ ｒ ｍ ｎ ｒ ｍｅ ｔ ｌ ｉ ｒ ｅ ｙ ｅ ａ ｌｓ ｆ ｏ ｉｃｅ ｎ
Ｆ ＥＮＧ ｉ ｕ ｎ Ｚｈ ｇ ａ ｇ
（ｈ ｎ ｎ ｏ ａ ｏ ａ Ｃ ｌ ｇ ｆｎ ｕｔ Ｓ ａ ｄ ｎ ｉｏ２ ６ １ ） Ｓ ａＤｏ ｇＶ ｃｔ ｎｌ ｏｌ ｅｏ ｄ ｓ ｙ， ｈｎ ｏ ｇＺｂ ５４ ４ ｉ ｅ Ｉ ｒ
Ａｂ ｔ ａ ｔ ｎ ｒｍｅ ｔ ｓｒ ｃ ：Ｉ ｃ ｅ ｎ Ａｎ Ｄ ｃ ｅ ｎ Ｏｐ ｒｔ ｎ ｉ ａ Ｃ ｌｎ ｕ ｇ ｙ ｔｘ ｄ ｆ ｃ ｌ ｐ ｒ ｆｒｂ ｇ ｎ ｅ ｓｉ ａｗａ ｓａ ｐ ｏ ｌｍ。 ｒ ｄ ｅ ｒ ｍｅ ｔ ｅａ ｉ ａ ｇ ａ ｅ ｓ ｎａ ｉ ｉｕ ｔ ａ ｔ ｏ ｅ ｉ ｎ ｒ ｌ ｙ ｒｂ ｅ ｏ ｏ ｓ ｆ ｓ
运算过程 ：每个 ｘ ＋ ＋ 表达式 的运算都是取 ｘ初值 ５参加运 算后 ，ｘ再分别 自加 ，５ ５ ５－ｙ ５ １ １ ｌ ＋ ＋ － ＋ ＋ ＋ — 。 ＊
例 ３ ：
＃ ｎ ｌｄ ｉ ｃｕ ｅ＜ ｔ ｉ ．＞ ｓ ｏｈ ｄ
自加运算符优先级 ：低于 （ 口 一 ， ） ＞． 与逻 辑非！ 运算
左结合 ，等价于 ｙ ｘ ＋ ＋（ ＋ ＋（ ＋ ：（ ） ｘ ） ｘ ） ＋ ＋ ＋ ／
ｐｉ ｆ（ ＝ ，＝ ”， ｘ ８ ＝ ５ ／ ｒ ｔ ”ｘ ％ｄ ％ｄ ｎ ｙ Ｙ ）； ＝ ， １ ＊ ｙ
｝
自加运算符功能 ：使运算对象值加 １ 。
关于C语言中的自增.减的运算原理
C语言中的自增/自检运算原理总结自增（i++）、自减（i--）运算符的作用是使变量的值加1或减1，例如：++ i，-- i（在使用i之前，先使i值加（减）1）；i++，i -- （在使用i之后，使i值加（减）1）；粗略的来看，++ i和i++的作用是相当于i=i+1。
但是++i和i++的不同之处在于：++i是先执行i=i+1，再使用i的值；而i++是先使用i的值，再执行i=i+1。
如果i的原值等于3，则计算结果如下：①j=++I；（i的值先变成4，再赋给j，j的值为4）例：i=3;Printf(“%d”,++i);输出结果：4；②j=i++；(先将i的值3赋给j，j的值为3然后i变为4)例：i=3;Printf(“%d”,i++);输出结果：3；看下面程序：程序1：#include<stdio.h>void main(){int a,b;a=5;b=(a++)+(a++);printf("%d\n",a);printf("%d\n",b);}分析：a经过两次自加1的运算变成了7；然而b=(a++)+(a++);这里的a++表达式等于a不进行自加运算前的值，b相当于两个没有进行自加1运算前的值相加即：b=5+5; → b=10；程序2：#include<stdio.h>void main(){int a,b;a=5;b=(a++)+(a++)+(a++);printf("%d\n",a);printf("%d\n",b);}分析：a经过两次自加1的运算变成了8；然而b=(a++)+(a++);这里的a++表达式等于a不进行自加运算前的值，b相当于两个没有进行自加1运算前的值相加即：b=5+5+5; → b=15；a++已经介绍的差不多了，那么再说一下++a,程序3：#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析：a的计算结果为7这个好理解，就是b值的计算，由上面的介绍可知++a是先将a的值进行自加1之后，再取出a值，这里有两个++a的运算式，即a先自加1变成7，再参与b 值的计算：b=7+7; → b=14；那么b=(++a)+(++a) +(++a);的计算结果是不是24呢？看下面的程序：程序4：#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析：这里的b并不等于24，而是22，之前已经计算出b=(++a)+(++a)的值为14，这时a=7,那么又经过一个（++a）式，a=8，且最后一个表达式（++a）也是等于8，则b=(7+7)+8→b=14+8; 即：b=22，那么b=(++a)+(++a)+(++a) +(++a)又等于多少呢？程序5：#include<stdio.h>void main(){int a,b;a=5;b=(++a)+(++a)+(++a)+(++a);printf("%d\n",a);printf("%d\n",b);}分析：由上面程序可知：这里的a=9,再由b=(++a)+(++a)与b=(++a)+(++a)+(++a)可得，b=(++a)+(++a)+(++a)+(++a)即：b=(7+7)+8+9，那么- -a呢？程序6：#include<stdio.h>void main(){int a,b;a=5;b=(--a)+(--a);printf("%d\n",a);printf("%d\n",b);}分析：与++a原理相同：--a这里的值为a=3,则b=3+3→b=6;那么b=(--a)+(--a) +(--a);原理与++a相同，即：b=(--a)+(--a) +(--a); → b=3+3+2; →b=8。
自增自减运算符运算顺序 -回复
自增自减运算符运算顺序-回复什么是自增和自减运算符运算顺序？在计算机编程中，自增和自减运算符是用于增加或减少变量的值的特殊运算符。
自增运算符（++）将变量的值增加1，自减运算符（）将变量的值减少1。
这两个运算符都是可以直接应用在变量名之前（前缀形式）或变量名之后（后缀形式）的。
然而，它们的运算顺序可能会引起一些混淆和错误，因此我们需要了解它们的运算顺序。
运算顺序的概念是指多个运算符出现在一个表达式中时，它们的计算顺序。
对于自增和自减运算符，有两种运算顺序：前缀运算和后缀运算。
在使用这些运算符时，很重要的一点是要知道它们的运算顺序，以便正确地使用它们。
首先，我们来看一下前缀运算。
前缀自增和自减运算符（++variable和variable）将变量的值分别增加1或减少1，然后返回运算后的值。
这意味着在运算符之后立即使用变量时，将使用更新后的值。
例如：int x = 5;System.out.println(++x); 输出6在这个例子中，变量x首先自增1，然后输出更新后的值6。
而后缀运算符（variable++和variable）也是将变量的值分别增加1或减少1，但是它们先返回变量的原始值，然后再将变量的值增加1或减少1。
这意味着在后缀运算符之后使用变量时，将使用原始值。
例如：int y = 5;System.out.println(y++); 输出5System.out.println(y); 输出6在这个例子中，变量y首先输出原始值5，然后再将其增加1，所以第二个输出语句输出的是更新后的值6。
根据这些示例，我们可以看出前缀和后缀运算符的运算顺序的差异。
在前缀运算中，变量的值会在其他运算之前被更新，而在后缀运算中，变量的值会在其他运算之后被更新。
这可能会导致一些意想不到的结果，特别是在多个运算符连续出现时。
让我们来看一个例子来说明这一点：int a = 10;int b = ++a + a++;System.out.println(a); 输出12System.out.println(b); 输出23在这个例子中，变量a首先被自增1，然后在同一表达式中使用了两次。
C语言自增、自减运算符的应用
，、 ｛ ＿ 五
一 ， 口
． － －
－－ ＿．
目
自 增 、 自 减 运 算 符 的 应 用
李春 玲
（ 陕西 理 工 学 院 计 算 机 科 学 与 技 ቤተ መጻሕፍቲ ባይዱ 系 ， 西 汉 中 陕
摘 要 ： 语 言 的 一 个 主 要 特 点 是 运 算符 丰 富 、 围 广 。 Ｃ 范 灵 活地 使 用 各 种 运 算 符 可 以 实现 在 其 它 高级 语 言 中难 以 实现 的运 算 。本 文 主要 对 Ｃ 言 中 自增 、 语 自减 两 个 运 算 符 的使 用 作
ｐ ｉ ｆ” ， ＼” ｉ ） ｒ ｔ ％ｄ ％ｄｎ ，， ； ｎ（ ｊ ｝ 程 序 中 对 于 同 一 个 运 算 对 象 ｉ 言 ， 和 ＋ 都 是 单 目运 算 而 一 ＋ 符 ， 先 级相 同 ， 么 到底 是 先 运 算 一 呢 ， 是先 运 算 ｉ＋ 由于 优 那 ｉ 还 ＋ 。 单 目运 算 符 具 有 从 右 向左 的 结 合 性 ， 所 以ｉｅ 右 边 的运 算 Ｙ于 符＋ 结合 ， ＋ 即先 计 算ｉ ＋ 在 计 算 一 ， 达式 等 价 于 一 ｉ＋ 。 序 ＋ ， ｉ表 （ ）程 ＋ 运行结果为 ：，１ ２一 。 ２ ． ５自增 、 自减运 算 符 在 函数 中的 应 用 。 例 ： ａｎ ） ｍ ｉ （ ｛ ｔ＿ ； ｉ ｉ３ ｎ ｐｉｔ（％ｄ， ＼”，，＋ ； ｒ ｆ” ｎ ％ｄｎ ｉｉ ＋） ） 在 调 用 函 数 时 ，对 实 参 的 求 值 顺 序 ． 标 准 并 无 统 一 规 Ｃ 定 。 有 的 系 统 中 ， 左 至 右 求 值 ， 序 运 行 结 果 为 ： ， 。但 在 从 程 ３３ 在 多 数 系 统 （ ： ｕｂ 中对 函数 参 数 的 求 值 顺 序 是 从 右 如 Ｔ ｒｏＣ） 向 左 ， 面 ｐｉｆ 数 中 药 输 出 两 个 表 达 式 的值 （和 ｉ＋ ， 上 ｒ 函 ｎ ｉ ＋ ） 先 求 出第 二 个 表 达 式 ｉ＋ 值 ３ ｉ 自 增 时 的 值 ） 然 后 在 求 解 ＋的 （Ｓ ． 第 一 个 表 达 式 的值 ， 于在 求 解 第 二 个 表 达 式 后 ，自增 １ ｉ 由 ｉ ， 变 为４， 以ｐｉｆ 数 中 的 第 一 个 参 数 ｉ 所 ｒ 函 ｎ 的值 为４ 程 序 运 行 结 果 ．
计算机C语言考试常见错误分析
C语言常见错误分析1、书写标识符时，忽略了大小写字母的区别C语言认为大写字母和小写字母是两个不同的字符，如在编译程序过程中，系统会把a和A看做是两个不同的变量名。
习惯上，符号常量名用大写表示，变量名用小写表示，以增加程序的可读性。
2、忽略了变量的类型，进行了不合法的运算main(){float a=3.4,b=0.4;printf(“%d”,a%b);}%是求余运算符，得到a/b的余数。
整形变量a和b可以进行求余运算，而实型变量则不允许进行“求余”运算。
3、将字符常量与字符串常量混淆char c;c=”a”;这里就是混淆了字符常量和字符串常量，字符常量是由一对单引号括起来的单个字符，字符串常量是由一对双引号括起来的字符序列。
4、忽略了“=”与“= =”的区别C语言中，“=”是赋值运算符，“= =”是关系运算符。
例如：if(a= =3) a=b;前者是进行比较运算，a是否和3相等；后者表示如果a和3相等，把b的值赋给变量a。
由于习惯问题，我们往往会犯这样的错误：if(a=3) a=b; 结果a总是等于b的值，原因是条件a=3是给a赋值3，判断条件非0，总是执行a=b。
5、忘记加分号或多加分号考试过程中应特别注意这种情况，分号是C语句中不可缺少的一部分，语句末尾必须有分号，但也不能乱加。
例如：#include <stdio.h>float fun(int n){}main(){ int n;float s;printf(“\nPlease enter N:”); scanf(“%d”,&n);s=fun(n);printf(“the result is : %f\n”,s);}这是一个函数调用，在函数首部float fun(int n)后是没有分号的。
少加或多加分号系统在编译时都会报错。
还有一种情况在系统编译时并不会报错，但是程序的执行顺序被改变了，如：if(a%3= =0) ;i++;本意是如果3整除a，则i加1，但由于if(a%3= =0)后多加了分号，即if语句后为空语句，程序将无条件执行i++语句，不论3是否整除a，i都将自动加1。
C语言程序设计中值得注意的几个问题
有什么错误 ，但是仔细考虑后会发现假
设输 入 字符 Ａ ，先 计算 ’ａ’ ＜＝’Ａ ’ ， 结果 为 ０ （ ） 假 ，然后再 计算 ０ ＜＝’Ｚ’ ， 结果 为 １ （ ） 真 ，则表 达 式 ’ａ’ ＝Ｃ ＜ ｈ ＜＝’Ｚ’值 为 １ （ ） 真 ，即 ｉ ｆ条件 成立 ，
的作用是使 变量 的值增 １或减 １ ，如 ： ＋＋ｉ ， ｉ（ 在使 用 ｉ 前 ，先使 ｉ 之
的值 加 （ ）１ ） 减 ｉ ＋＋，ｉ 一一 （ 使用 ｉ 后 ，再使 ｉ 在 之 的 值加 （ ） １ ） 减 例 ：ｉｔ ｉ＝ ３；Ｐｒ Ｆｔ （ ％ｄ” Ｆｔ ｉｔｆ “ ， ｉ ＋＋） ；执 行结果 为 ３。
ｎ自增。显然这样做是不符 合题 意 ，所以 最后 语句应该 为 Ｉ （ ｆ ’ａ’ ＜＝Ｃ ｈ＆＆Ｃ ｈ
＜＝’Ｚ’ ＋＋； 。 ）ｎ
如果有 ｉ ＋＋，ｉ 的左面 是取负运算 符 ，右 边是 自加 运算 符 ，而 且运 算级 别 相通 ，按 照 “ 自右至 左”的结合方 向，一 ｉ ＋＋相 当于 （＋＋） ｉ
ｓ ｎｆ （ ％ ｄ” ｃ ａ “ ，＆ ｓ ｕ． ｔ ｎｕＩ ） ｎ ；
若 “ 的左运 算对象值为非 ０ ，则不再 对 右运 算 符求值 ，因 整个式 子 的结果 必
定 为 １。
ｇ ｔ ｈａ （ ； ｅＣ ） ｒ ｇ ｔ （ｔ Ｆ ｍ） ｅ ｓ ｓ ｕ．ｔ ｕ ； 因而 ，在 ｓ Ｆｆ （ ｃ ａ ｔ ）函数之后 ，一 般总有一个额外的 ｇ ｔｈ ｒ（ ｅ ｃ ａ ）以清除缓 冲 区 中 的 ’＼Ｆ 。 ｔ’ 当然 ，更直接 的方法 是在 Ｓ ａｔ （ Ｃ Ｆｆ ） 函数之后使 用另一个 函数 ｆｌ ｓ （ ，此 ｆｕ ｈ ）
■■一
潘 爹 毒程 浚
c程序设计语言中两个疑难问题的探讨
｛ｎａ ３ ，Ｊ ｉｔ＝ ，ｆ ；
ｆｒ（ Ｏ；ｉ ２； ＋） ｏ 芦 ＜
ｊｆｎ（ ＋ －ｕ ａ ＋）； ｐｎ （ ｉ ｆ ｆ ”％（ｎ ，ｊ ｎ” ）；｝
３ 对 于结 合 方向 的影 响 结合方 向就是 同级运 算符在一个 表达式 出现 的时候 ，运算 符与前 后变量 的连接关系。 自 增或 自减运算符 的结合方 向都是 “ 右至左” 。 白
要 从 以下 几 个方 面 进 行探 讨 ： １１ 对 于 变 量 的 影 响 ．
无论是前缀运算还是后缀运算 ， 于变量奉身来说 ， 对 效果都是相 同 的 ，都使变量增 １ 或减１ 。 例如 ： ＋ ＋ ， 的原值是４ ＋ｊ ＋ ｆ 和ｆ ，这两个运算的结果变量睹Ｂ 。 是５
１２ 对 于 运算 对 象 的 要 求 ．
不合法的 ，因而 ，编译时编译系统会报错的。
４ ቤተ መጻሕፍቲ ባይዱ态 局部 变量
当在函数体 （ 或复合语 ／ ）内部用ｓ ｔ 来定 义说 明一些变量 时，这 口 Ｊ ｔｉ ａＣ 里的变量就是静态局部变量。 在程序运行 过程 中，静 态局部变量 在内存 中占据永久性 的存储 单 元 。就是退 出函数 以后 ，再进入该 函数时 ，静态局 部变量仍使用原米 的存储单元。由于并不释放存储单元 ，这样静态局部变量 的值会予以保 留，也就是说静态局部变量的初值 只在 函数第一次调用 时赋值一次 ，以 后再调用该 函数时 ，静态局部变量 的值就是上一次调用 函数结束时静态 局部变量的值 。并且 ，静态局部变量 的生存期 可以一直延长到程序运行 结束。同时 ， 静态局部变量的初值是在编译时赋予的，不是在程序运行 期间赋予的 ，对于没有赋予初值的静态局部变量 ，编译 系统会 自动赋予 初值为０ 。 例如 ：
操作子的名词解释
操作子的名词解释操作子是计算机科学中的一个重要概念，用于表示计算机程序中的基本运算操作。
操作子是编程语言中的核心元素，它们是构建算法和逻辑的基础单位。
本文将对操作子进行详细的名词解释，并探讨它们在计算机程序中的作用和应用。
一、操作子的定义和分类操作子是指用于对一个或多个操作数进行操作的符号或函数。
操作子可以分为一元操作子和二元操作子两种类型。
1. 一元操作子：一元操作子只需要一个操作数进行运算。
常见的一元操作子包括正负号（+、-）、逻辑非（!）、自增（++）、自减（--）等。
一元操作子通常用于数值运算、逻辑判断和变量自增减等场景。
2. 二元操作子：二元操作子需要两个操作数进行运算。
常见的二元操作子包括加法（+）、减法（-）、乘法（*）、除法（/）、逻辑与（&&）、逻辑或（||）、赋值（=）等。
二元操作子用于表示数学运算、逻辑运算和变量赋值等操作。
二、操作子的作用和应用操作子在计算机程序中起着举足轻重的作用，它们可以帮助程序员进行各种运算和操作，实现复杂的逻辑和功能。
以下是操作子的几个典型应用场景：1. 数学计算：操作子可以用于进行各种数学运算，包括加减乘除、求余、幂等运算等。
通过使用不同的操作子，可以对数字进行精确计算和逻辑判断，从而实现复杂的数学运算。
2. 逻辑判断：操作子可以用于实现逻辑判断和条件控制。
比如使用比较操作子（<、<=、>、>=、==、!=）可以对数值进行比较，使用逻辑操作子（&&、||、!）可以进行逻辑运算，根据不同的条件判断结果进行不同的操作。
3. 变量操作：操作子可以用于对变量进行赋值和操作。
通过赋值操作子（=）可以将一个值赋给一个变量，使得变量拥有指定的数值或对象。
同时，还可以使用自增（++）和自减（--）等操作子对变量进行加减操作，实现对变量的增减功能。
4. 字符串处理：对于字符串类型的数据，操作子可以实现字符串连接、截取、替换等功能。
自加、自减运算符和逗号表达式
自加、自减运算符和逗号表达式1. 自加、自减运算符（1）自加运算符（++）对于自加运算符的使用需注意以下几点。
①自加运算符“++”的运算结果是使运算对象增1。
i++，相当于i=i+1。
因此，自加运算是一种赋值运算。
②运算符“++”是单目运算符，运算对象可以是整型变量也可以是实整型变量，不能是常量或表达式。
所以像++3、（i+j）++是不合法的。
③用自加运算符构成表达式时，既可以是前缀形式，也可以是后缀形式。
这两种形式对于变量来说，其结果是相同的都是加1，但对表达式来说其值是不同的。
例如，已定义变量int i=5。
若表达式为++i，则先进行i增1运算，i的值为6，表达式的值也为6；若表达式为i++，则表达式先取i的值为5，然后i进行增1运算，使i中的值为6。
④运算符“++”的结合方向是“自右向左”。
⑤不要在一个表达式中对同一个变量进行多次诸如i++或++i等运算。
（2）自减运算符（——）对于自减运算符的使用需注意以下几点：①自减运算符“--”的运算结果是使运算对象减1。
i--，相当于i=i-1。
因此，自减运算是一种赋值运算。
②运算符“--”是单目运算符，运算对象可以是整型变量也可以是实整型变量，不能是常量或表达式。
所以像--3、（i+j）--是不合法的。
③用自减运算符构成表达式时，既可以是前缀形式，也可以是后缀形式。
这两种形式对于变量来说，其结果是相同的都是减1，但对表达式来说其值是不同的。
例：已定义变量int i=5。
若表达式为--i，则先进行i减1运算，i的值为4，表达式的值也为4；若表达式为i--，则表达式先取i的值为5，然后i进行减1运算，使i中的值为4。
④运算符“--”的结合方向是“自右向左”。
⑤不要在一个表达式中对同一个变量进行多次诸如i--或--i等运算。
2．逗号运算符和逗号表达式（1）逗号运算符“，”是C语言提供的一种特殊运算符，称为逗号运算符。
逗号运算符的结合性为从左到右。
在所有运算符中，逗号运算符的优先级最低。
C语言中自加和自减运算符（a++、++a、a--、--a）
C语⾔中⾃加和⾃减运算符（a++、++a、a--、--a） 以⾃增运算符为例，当⾃增运算符++作⽤于⼀个变量时，例如：当i=3时++i这个算术表达式的值为4，同时变量i的值也由原来的3改变为4。
⼀般情况下，计算表达式后不改变变量本⾝的值，⽽++运算符和--运算符组成的表达式计算后，则改变变量的值，这称为运算符的副作⽤。
这类运算符在计算表达式时，⼀定要注意区分表达式的值和变量的值。
2 注意前缀运算和后缀运算的区别 仍以⾃增运算符为例，该运算符可作⽤在变量之前，例如前⾯所讲的++i，称为前缀运算；也可作⽤在变量之后，例如i++，称为后缀运算。
在这两种运算中，表达式的值不同：前缀运算后，表达式的值为原变量值加1；后缀运算后，表达式的值仍为原变量值；⽽变量值不论前缀运算还是后缀运算都加1。
⾃减运算符与⾃增运算符类似，只要将加1改为减1即可。
即前缀运算是“先变后⽤”，⽽后缀运算是“先⽤后变”。
3 注意运算符的运算对象 ⾃增、⾃减运算符只能作⽤于变量，⽽不能作⽤于常量或表达式。
因为⾃增、⾃减运算符具有对运算量重新赋值的功能，⽽常量、表达式⽆存储单元可⾔，当然不能做⾃增、⾃减运算。
只要是标准类型的变量，不管是整型、实型，还是字符型、枚举型都可以作为这两个运算符的运算对象。
如以下四个表达式都是合法的：i+++j++、++i+(++j)、++a+b++、++array［--j］；⽽++6、(i+j)++、‘A’++、++i+++j、(&p)++这五个表达式却是不合法的。
为什么i+++j++合法，⽽++i+++j却不合法?C的编译器对程序编译时，从左到右尽可能多地将字符组合成⼀个运算符或标识符，因此i+++j++等效于(i++)+(j++)，两个“++”作⽤的对象都是变量，这是合法的；⽽++i+++j等效于++(i++)+j,第1个“++”作⽤的对象是表达式“i++”，这是不允许的。
4 注意运算符的结合⽅向 表达式k=-i++等效于k=(-i)++还是k=-(i++)?因为负号运算符和⾃增运算符优先级相同，哪⼀个正确就得看结合⽅向。
C语言自增自减运算符的应用
C语⾔⾃增\⾃减运算符的应⽤2019-06-27摘要: Ca语⾔的⼀个主要特点是运算符丰富、范围⼴。
灵活地使⽤各种运算符可以实现在其它⾼级语⾔中难以实现的运算。
本⽂主要对C语⾔中⾃增、⾃减两个运算符的使⽤作详细说明。
关键词: C语⾔⾃增、⾃减运算符功能运算规则C语⾔中的运算符⾮常丰富,把除了控制语句和输⼊输出以外的⼏乎所有的基本操作都作为运算符处理,灵活使⽤各种运算符可以实现在其他⾼级语⾔中难以实现的运算。
在这些运算符中,最难理解、最易出错也最为灵活的便是⾃增、⾃减运算符。
下⾯我详细归纳了使⽤⾃增、⾃减运算符时的注意事项,并结合运算符的优先级和其本⾝的特点,对Turbo C环境下的⾃增、⾃减运算符的功能与运算规则加以分析。
1.⾃增、⾃减运算符的作⽤及形式C语⾔中的⾃增运算符“++”和⾃减运算符“--”的作⽤是使运算对象的值增1或减1,如i++,相当于i=i+1;i--,相当于i=i-1。
因此,⾃增、⾃减运算本⾝也是⼀种赋值运算,其运算对象只要是标准类型的变量,不论是字符型、整型、实型或是枚举型都可作为运算对象,⽽由于常量和表达式不占存储单元,因此不能使⽤常量或表达式作运算对象,如1++、(a+b)--等都是⾮法的。
⾃增、⾃减运算符有两种使⽤形式:前置式(++i,--i)和后置式(i++,i--)。
前置式中先使i加减1,再使⽤i,后置式中先使⽤i,再使i加减1。
2.⾃增、⾃减运算符的应⽤很多C语⾔教材和参考书都说明⾃增、⾃减运算符具有“从右向左”的结合性,并且由于操作数只有⼀个,属于单⽬操作,因此优先级也⾼于其它双⽬运算符和三⽬运算符的优先级。
但在实际的编程中我们发现,⾃增、⾃减运算符的运算规则在不同的表达式中也不尽相同。
下⾯我们就从⾃增、⾃减运算符的以下⼏点应⽤来进⾏分析。
2.1⾃增、⾃减运算符在赋值表达式中的应⽤。
例1:main(){int i=1,j=2,k;k=i+++j;printf("k=%d,i=%d,j=%d\n",k,i,j);}这⾥的i+++j是理解成i+(++j),还是理解成(i++)+j呢?Turbo C编译处理将⾃左向右解释为(i++)+j,⽽不是i+(++j),因此程序运⾏结果为:k=3,i=2,j=2。
c语言：自增自减运算符的操作详解
c语⾔：⾃增⾃减运算符的操作详解博主在回忆c语⾔的基本知识时，突然发现⾃增⾃减运算符（--、++）这个知识点有些模糊不清，故博主为了给同为⼩⽩的同学们提供⼀些经验，特写下这篇⽂章。
⾸先，⾃增⾃减运算符共有两种操作⽅式。
⽐如，我先定义⼀个变量a，以“++”为例，共有“a++”、“++a”种操作⽅式。
“下⾯我们在实际的代码中看⼀下。
#include<stdio.h>//⾃增⾃减运算符的测试int main(){int a = 21;int c;c = a--;printf("%d\n", c);a = 21;c = a++;printf("%d\n", c);a = 21;c = --a;printf("%d\n", c);a = 21;c = ++a;printf("%d\n", c);getchar();}运⾏后，很轻易的就可以得到输出结果：21、21、20、22。
由此可知，我们可以得到⼀个结论：诸如“a++”类⾃增⾃减运算符在变量之后的，进⾏操作时是先赋值，后运算；⽽“++a”类的操作则正是与此相反。
其次，我们来看⼀下上⾯代码中变量c的变化情况：int main(){int a = 21;int c;c = a++;printf("%d\n", c);c = a--;printf("%d\n", c);c = --a;printf("%d\n", c);c = ++a;printf("%d\n", c);getchar();}运⾏结果则变成了：21、22、20、21,。
为什么会出现这种情况呢？以c=a++为例，由上述结论可知，这个表达式实际上是先将a的值赋给c，这样c就等于21，⽽后续符号操作的则直接是a，所以经过这个表达式之后，a的值实际上变成了22。
C语言自增自减运算符的解析与应用
C语言自增自减运算符的解析与应用雷玉梅【摘要】自增自减是C语言运算符里比较有特色的运算符,也是在使用时最容易出错的运算符.结合教学和使用经验对Turbo C 2.0中的自增自减运算符进行研究,根据自增自减运算符的特点和不同使用形式,剖析自增自减运算符的使用规则,总结各种解题技巧和使用方法,以便更好地帮助初学者学习和使用自增自减运算符.【期刊名称】《辽宁师专学报（自然科学版）》【年(卷),期】2011(013)001【总页数】3页(P22-23,94)【关键词】自增运算符;自减运算符;三层计算法;解题技巧;使用方法【作者】雷玉梅【作者单位】阜新高等专科学校,辽宁阜新123000【正文语种】中文【中图分类】TP312C0 引言自增自减是C语言中比较有特色的运算符.合理使用自增自减运算符,在编程中可以节省代码,提高效率,事半功倍;如果掌握不好或使用不当,则极易造成错误.在互联网的搜索引擎中随意打入C语言自增自减运算符,寻求解题方法的比比皆是.本文根据自增自减运算符的特点,针对不同题型,给出不同的解题规律,以期为初学者学习和使用自增自减运算符提供帮助.1 自增自减运算符的含义及使用形式1.1 含义自增运算符即“++”,其含义是把变量的值取出加1,再存回该变量,相当于变量自身加1.自减运算符即“--”,其含义是把变量的值取出减1,再存回该变量,相当于变量自身减1.1.2 使用形式使用形式分为前缀形式和后缀形式两种.前缀形式:运算符在变量前,例如:++i,--j.后缀形式:运算符在变量后,例如:i++,j--.不论前缀运算还是后缀运算,变量值都相应增加(减少)1,区别是前缀运算是“先变后用”,而后缀运算是“先用后变”.虽然运算法则简单明了,可在实际应用中,在不同的使用场合,这个法则却不是万能的,死记硬套法则,结果往往是错误的.下面根据不同的使用形式,论述如何灵活运用法则.2 各类含有自增自减运算符题型的解题技巧2.1 一个自增或自减运算符组成的表达式例1:i=3k1=++ik2=i++k1=?,k2=?,i=?解题技巧:应用“加号在前,先加后用,加号在后,先用后加”法则,自减同理.解题过程:(1)第一个表达式,因为++在前,所以“先加后用”,先把i的值增1,变成i=4,再把i的值赋给k1,k1=4;(2)第二个表达式,因为++在后,所以“先用后加”,先把i的值赋给k2,k2=3,再把i的值增1,i=4.结论:此类题型,使用“加号在前,先加后用,加号在后,先用后加”法则可以轻松解决.2.2 多个自增自减运算符组成的表达式例1:多个自增运算符组成的表达式i=3k=(++i)+(i++)+(++i)k=?i=?例2:多个自减运算符组成的表达式i=3k=(i--)+(--i)+(i--)k=?i=?例3:多个自增自减运算符混合组成的表达式i=3k=(i++)+(--i)+(i--)k=?i=?解题技巧:使用“三层计算法”.所谓三层计算法,即先变层,使用层,后变层,然后逐层从左向右计算[1].在解例1时,很多初学者本着“加号在前,先加后用;加号在后,先用后加”的原则,认为k=4+4+6=14.但在Turbo C和MS C系统中运行时,得出的结果却是15,那么此类问题应该如何计算呢?使用三层计算法解决此类问题将变得非常简单.三层计算法的具体步骤为:先把式子划分三层,分别是先变层,使用层,后变层,然后逐层计算,计算完一层后,再进入下一层的计算,最后得出正确结果.例1的解题过程如下:先变层i+1 —— i+1使用层k=i+i+i后变层i+1先计算第一层:i+1和i+1,i原来是3,加了两次1,结果为i=5.再计算第二层:k=i+i+i,相当于k=5+5+5,结果为k=15,i还是5.最后计算第三层:一个i+1,i的结果变成6.所以最终结果为:k=15,i=6.例2的解题过程如下:先变层—— i-1 ——使用层k=i+i+i后变层i-1 —— i-1计算第一层:i-1,所以i变成2.计算第二层:k=2+2+2=6.计算第三层:2个“i-1”,i 的值变成0.最终结果:k=6,i=0.例3的解题过程如下:先变层—— i-1 ——使用层k=i+i+i后变层i+1——i-1计算第一层:i-1,所以i变成2.计算第二层:k=2+2+2=6.计算第三层:i+1,i-1,i的值还是2.最终结果:k=6,i=2.结论:对于这样多个自增自减运算符组成的表达式,不可简单地应用“加号在前,先加后用,加号在后,先用后加”原则,只需设置三个层,逐层计算,即可轻松获得结果. 2.3 printf()函数直接输出自增自减表达式形式1:单个自增自减组成一个输出项.解题技巧:输出项表列按着“从右向左”的顺序输出,还是加号在前,先加后用,加号在后,先用后加,自减同理.例1:int i=3printf(“%d,%d”,i,i++);很多初学者认为输出结果是:3,3,其实不然.printf函数输出时,求值顺序是从右向左的,那么应该先输出后者i++项,因为++在后,所以先输出i的值3,输出后再加1,所以到下一个输出项i的值时,i已经变成4了,所以结果为:4,3.结论:对于单个自增自减表达式作为一个输出项,使用“加号在前,先加后用,加号在后,先用后加”原则,只不过运算顺序要从右向左.形式2:多个自增自减组成一个输出项.解题技巧:也适用“加号在前,先加后用,加号在后,先用后加”规则,不过这里的“先变后用”和“先用后变”中的“后”就是指++i和i++这一小项运算完之后.例2:i=3;printf(“j=%d”,(++i)+(i++)+(i++));解题:第一个(++i)先给i的值加1,表达式值是4,i的值也是4,第二个(i++)先取出i 的值,表达式的值是4,然后i再加1变为5,第三个(i++)先取出表达式的值为5,i再加1变为6,这样输出的结果便是三个表达式的和,即4+4+5=13.结论:对于多个自增自减表达式组成一个输出项,不可使用三层计算法,而是适用于“加号在前,先加后用,加号在后,先用后加”规则.3 自增自减运算符在不同场合的使用方法3.1 自增自减运算符在循环结构中的使用方法自增自减运算符在循环结构中一般用于修改循环变量,例如“i++”“i--”,其中i 称为循环变量,通过自增自减运算,才能使循环执行若干次后,达到不满足循环条件的情形,从而结束循环[2].如果没有这样的语句,那么循环变量的值将始终不变,程序将无限次循环下去,从而进入死循环.在while和do…while循环结构,循环变量的自增自减运算应放在循环体内,例如:i=1;while(i<100){sum=sum+i;i++},do…while亦是如此.在for循环中,可以把循环变量的自增自减运算放在for结构中,也可以放在循环体内,例如:for(i=1;i<100;i++)sum+=i;也可以for(i=1;i<100;){sum+=i;i++;}.3.2 自增自减运算符在指针中的使用方法指针是C语言的一大特色.指针使用非常灵活,可以指向各种类型的变量、数组、函数和文件.当指向变量和数组时,“p++,p--”可以使指针移动,找到相邻元素的地址.这里要注意,p++是使指针指向内存中下一个元素,而不是简单地将值加1,p--指向内存中上一个元素而不是地简单将值减1,实际上p++(p--)是p+1×d(p-1×d),d 是一个数据对象所占的字节数[3].在C语言中,整数d=2,单精度实数d=4,字符型数d=1.下面来看一个程序段:int a[6]={1,2,3,4,5,6},＊p;p=a;printf(“%d”,＊p++);printf(“%d”,＊++p);此程序段中,定义了一个一维数组,指针指向数组的首地址,即指向存储单元a[0],第一个printf函数输出＊p++,＊和++优先级相同,++在变量后,所以先用后加,即先取出＊p的值,然后再自增.第一个的输出结果为a[0]的值1,p指向存储单元a[1],第二个printf函数输出＊++p,++在变量前,所以先加后用,先指针加1,指向存储单元a[2],再取其值,结果为3.4 结语自增自减运算符使用灵活,利用这一点可以巧妙地处理许多在其他语言中难以处理的问题,但另一方面,有时会出现一些令人容易混淆的问题,因此使用者务必小心谨慎使用.参考文献:【相关文献】[1]胡方.探讨C语言自增、自减运算符的应用[J].辽宁师专学报(自然科学版),2008,(1):22.[2]秦玉平,戴心来.C语言中的自加自减运算[J].渤海大学学报,2004,(4):367-368.[3]陈仲民.关于C语言教学方法和程序设计的探讨[J].计算机教育,2007,(6):3-6.。
自增自减运算符
自增自减运算符自增自减运算符是计算机编程中常用的符号，它们分别使变量增加或减少一次预定的值。
这种运算符在大多数编程语言中都能够找到，其中最常见的是C语言。
它们可以用来减少程序员的编码工作量，提高程序的执行效率。
自增自减运算符可以说是数学中熟悉的算术运算符号的计算机程序化表达方式。
它们包括自增（++）和自减（--）两类运算符。
自增运算符号经常用来将变量的值递增1，而自减运算符则会将变量的值递减1。
很多编程语言都支持这种操作，其中C语言在其中占有主导地位。
自增自减运算符主要用于简化一些重复性的编码工作，比如对变量的运算。
例如，如果要对一个变量进行原子性的递增，我们可以使用自增运算符：int x = 0;x++;在上面的示例中，我们在变量x的基础上增加1，即x = x + 1，同时会简化减少变量值的操作，类似的，如果要减少变量值，我们可以使用自减运算符：int x = 0;x--;在这个示例中，我们同样也是对变量x递减1，即x = x - 1，两个操作都非常简单而且高效，只需要一行代码就可以完成。
此外，自增自减也常被用于循环语句中。
例如，C语言中的for 循环中经常会出现自增自减的形式：for(int i = 0; i < 10; i++){//Do something here}在上面的示例中，在循环的最后一行中会对变量i进行递增1操作，也就是将变量i的值由0递增到10，再次强调，使用自增自减运算符可以大大减少程序员编码的工作量，使程序更加简洁。
总结，自增自减运算符是编程中非常常见的符号，主要用于减少程序员编码工作量，提高程序的执行效率。
其中自增（++）和自减（--）是计算机程序中常用的运算符号，涉及到变量的加减和循环操作，经常被用于简化程序的代码，有效提高程序的执行效率。
数学运算中的注意事项与规则(知识点总结)
数学运算中的注意事项与规则（知识点总结）一、整数的加减乘除运算1. 加法运算在进行整数的加法运算时，我们需要注意以下几点：- 同号相加，保留符号并将绝对值相加。
例如：(2) + (3) = 5, (-2) + (-3) = -5- 异号相加，减去绝对值较大的数，并取其符号。
例如：(2) + (-3) = -1, (-2) + (3) = 12. 减法运算整数的减法运算可以转化为加法运算，即被减数加上减数的相反数。
例如：(5) - (3) 可转化为 (5) + (-3) = 23. 乘法运算整数的乘法运算遵循以下规则：- 同号相乘，结果为正数。
例如：(2) * (3) = 6, (-2) * (-3) = 6- 异号相乘，结果为负数。
例如：(2) * (-3) = -6, (-2) * (3) = -64. 除法运算整数的除法运算需要注意以下几点：- 被除数除以除数，相同符号的结果为正数，异号的结果为负数。
例如：(8) / (2) = 4, (-8) / (-2) = 4, (8) / (-2) = -4, (-8) / (2) = -4 - 除数不能为0，除以0是没有意义的。
二、分数的加减乘除运算1. 加法运算分数的加法运算需要注意以下几点：- 分母相同时，分子相加，并保持分母不变。
例如：1/4 + 2/4 = 3/4- 分母不同时，需要进行通分后再相加。
例如：1/4 + 2/3 = 3/12 + 8/12 = 11/122. 减法运算分数的减法运算可以转化为加法运算，即被减数加上减数的相反数。
例如：3/4 - 1/4 可转化为 3/4 + (-1/4) = 2/4 = 1/23. 乘法运算分数的乘法运算遵循以下规则：- 分子相乘，分母相乘。
例如：1/2 * 3/4 = 3/84. 除法运算分数的除法运算需要注意以下几点：- 被除数乘以除数的倒数。
例如：(1/2) / (3/4) = (1/2) * (4/3) = 2/3- 除数不能为0，除以0是没有意义的。
自增、自减运算
＄recPerPage 是每次查询的记录数 (即每页显示的图书数) ,它 们是 limit 字句的两个参数 ,决定每次从哪条记录开始 ,最多查 出几条记录 ,即实现分页查询 。分页查询可以提高查询速度 , 减轻服务器的负担 ,显著提高网站运行效率 ,并使浏览器显示 页面简洁美观 ,便于用户浏览 。
五 、结束语
而 + + m 3 + + m + + + m 的操作过程是 :
式求值顺序为从左到右 ,前置自增为先修改操作数使之增 1 ,增
步骤 OPTR OPND 输入字符
1 后的值作为表达式的值 。第一次做加法时 ,取的两个操作数
1
ቤተ መጻሕፍቲ ባይዱ
+ +m
为 m 增 1 再增 1 的值 ,即 5 ,故和为 10 ;当做第二个加法时 ,第
# include < iostream. h >
void main ()
{int a = 3 ,b = 5 ,c = 7 ; cout < < a < < ’\ t’< < a + + < < endl ; cout < < b < < ’\ t’< < + + b < < endl ; cout < < + + c < < ’\ t’< < c < < endl ;
C语言中几个知识点的学习技巧
摘 要: 对于初学者, 自加自减运算符、变量、指针等知识点是 C 语言中较难理解且易混淆的内容, 但这几个知识点也是C 语言中精华的部分, 也是全国计算机等级考试必考的内容。文章对这几个知识点 的学习技巧进行了分析与探讨, 以提高 C 语言教学效果。
关键词: 自加自减; 变量作用域; 指针; 学习技巧 中图分类号: T P312 文献标识码: B 文章编号: 1007—6921( 2012) 03—0121—01
C 语言是结构化的面向过程的高级语言, 是在
国内外广泛使用的一种计算机语言。在大量使用面
向对象程序设计语言的今天, 由于 C 语言的诸多优 点, C 语言仍是计算机专业或其他工科专业学生必
修的课程之一。但是对于初学者, 自加自减运算符、
变量、指针等知识点是 C 语言中较难理解且易混淆
的内容, 但这几个知识点也是C 语言中精华的部分,
表1
+ + - - 运算符的运算规则
使用 表达式
环境
运算规则
运算 结果 表达式 变量
的值 的值
a+ + 在表达 + + b 式中作 c- - 为子表 - - d 达式
先取 a 的值作为表达式的值, 后 a 做加 1 运算 b 先做加1 运算, 后取 b 的值作为表达式的值 先取 c 的值作为表达式的值, 后 c 做减 1 运算 d 先做减1 运算, 后取 d 的值作为表达式的值
也是全国计算机等级考试必考的内容。所以有必要
对这几个知识点的学习技巧进行分析与探讨, 以提
高 C 语言的教学效果和学生的学习效果。
1 “+ + , - - ”运算符的使用
“+ + , - - ”的使用是 C 语言灵活性和简洁性
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
自加\自减运算符在应用中需要注意的几点问题
摘要：自加、自减运算符是具有副作用的运算符，在实际应用中，单个自加、自减运算符容易理解，但多个自加、自减运算符同时出现在表达式中时，就不容易理解了，而且很容易出错，所以在应用中对一个表达式中的多个自加、自减运算符要特别小心谨慎。
关键词：自加；自减；运算符；变量；表达式
中图分类号：tp312
关于自加、自减运算符，有如下定义和性质：
（1）自加、自减运算符是具有副作用的运算符。
它的运算结果是使运算对象的值增1或减1。
如i++，相当于i=i+1；i--，相当于i=i-1。
因此，自加或自减运算本身也是一种赋值运算。
（2）++、--运算符是单目运算符，运算对象可以是整型变量也可以是实型变量，不能是常量和表达式，因为不能给常量和表达式赋值；因此，如++3、(i+j)--等都是不合法的。
（3）自加、自减运算符既可作为前缀运算符，也可作为后缀运算符而构成一个表达式，如++i，--i、i++、i--等都是合法的表达式。
但无论是作为前缀还是作为后缀运算符，对于变量本身来说自增1或自减1都具有相同的效果，但作为表达式来说却有着不同的值。
如，若变量i为int类型，且已有值为5；则表达式++i，先进行i增1运算，表达式的值为6；--i先进行i减1运算，表达式的值为4；i++表达式的值为5，然后i进行增1运算，使i中的值为6；i--表达式的值为5，然后i进行减1运算，使i中的值为4。
（4）++和—运算符的结合方向是“自右向左”。
如表达式-i++，负号运算符和自加运算符优先级相同，结合方向“自右向左”，即相当于对表达式-(i++)进行运算。
如果需要输出表达式-i++的值，则应先取出i的值使用，输出-i的值-3，然后使i的值增1为4。
（5）请不要在一个表达式中对同一个变量进行多次诸如i++或++i等运算，如写成：
i++*++i+i++*--i，这种表达式不仅可读性差，而且不同的编译系统对这样的表达式将作不同的解释，进行不同的处理，因而所得结果也各不相同。
（6）++和--是具有副作用的运算符，由它们构成的表达式称为具有副作用的表达式。
所谓表达式的副作用就是指除了产生一个计算结果外，还要改变参与计算过程的某些变量的值或产生其他的某些效应。
下面通过几个案例来说明自加、自减运算符在具体应用中需注意的几点问题。
案例一：
main()
{inti=3，b，c；
b=i++；
c=++i；
printf(“%d，%d\n”，b，c)；
}
分析：语句：b=i++；相当于两条语句：
b=i；/*b=3*/(先取变量i的值3赋给变量b)
i=i+1；/*i=3+1*/(副作用：改变变量i的值，使变量i由3增1为4)
语句：c=++i；相当于两条语句：
i=i+1；/*i=4+1*/(副作用：先改变变量i的值，不要以为这里i=3+1，因为在语句b=i++；中，i的值已改变为4)
c=i；/*c=5*/（将改变后的变量i的值5赋给变量c）
所以输出结果为：3，5
案例二：
main()
{inti=3，b，c；
b=(i++)+(i++)；
c=(++i)+(++i)；
printf(“%d，%d\n”，b，c)；
}
分析：语句：b=(i++)+(i++)；相当于三条语句：
b=i+i；/*b=3+3*/(先取变量i的值3参与计算，并将结果赋给变量b。
注意：不要以为：b=3+4，因为(i++)+(i++)是被“同时”取变量i的初值，不能分“先后”。
)
i=i+1；/*i=3+1*/(副作用：改变变量i的值，使变量i由3增1为4)
i=i+1；/*i=4+1*/(副作用：改变变量i的值，使变量i由4增1为5)
语句：c=(++i)+(++i)；相当于四条语句：
i=i+1；/*i=5+1*/(副作用：先改变变量i的值，使变量i由5增1为6)
i=i+1；/*i=6+1*/(副作用：再改变变量i的值，使变量i由6增1为7)
c=7+6；
c=c+1；/*c=13+1*/(副作用：由于表达式中连续两个(++i)参与运算，导致了新的“惯性”副作用，使变量c的值也产生增1的作用。
)
所以输出结果为：6，14
案例三：
main()
{inti=3，b，c；
b=(i++)+(i++)+(i++)；
c=(++i)+(++i)+(++i)；
printf(“%d，%d\n”，b，c)；
}
分析：语句：b=(i++)+(i++)+(i++)；相当于四条语句：
b=i+i+i；/*b=3+3+3*/(先取变量i的值3参与计算，并将结果赋给变量b。
注意：不要以为：b=3+4+5，因为(i++)+(i++)+(i++)
是被“同时”取变量i的初值，不能分“先后”。
)
i=i+1；/*i=3+1*/(副作用：改变变量i的值，使变量i由3增1为4)
i=i+1；/*i=4+1*/(副作用：改变变量i的值，使变量i由4增1为5)
i=i+1；/*i=5+1*/(副作用：改变变量i的值，使变量i由5增1为6)
语句：c=(++i)+(++i)+(++i)；相当于五条语句：
i=i+1；/*i=6+1*/(副作用：先改变变量i的值，使变量i由6增1为7)
i=i+1；/*i=7+1*/(副作用：再改变变量i的值，使变量i由7增1为8)
i=i+1；/*i=8+1*/(副作用：再改变变量i的值，使变量i由8增1为9)
c=9+8+7；
c=c+1；/*c=24+1*/(副作用：由于表达式中连续三个(++i)参与运算，导致了新的“惯性”副作用，使变量c的值也产生增1的作用。
)
所以输出结果为：9，25
对于自减运算符，具有同样的结论，仅以案例四进行说明。
案例四：
main()
{inti=9，b，c；
b=(i--)+(i--)；
c=(--i)+(--i)；
printf(“%d，%d\n”，b，c)；
}
分析：语句：b=(i--)+(i--)；相当于三条语句：
b=i+i；/*b=9+9*/(先取变量i的值9参与计算，并将结果赋给变量b。
注意：不要以为：b=9+8，因为(i--)+(i--)是被“同时”取变量i的初值，不能分“先后”。
)
i=i-1；/*i=9-1*/(副作用：改变变量i的值，使变量i由9减1为8)
i=i-1；/*i=8-1*/(副作用：改变变量i的值，使变量i由8减1为7)
语句：c=(--i)+(--i)；相当于四条语句：
i=i-1；/*i=7-1*/(副作用：先改变变量i的值，使变量i由7减1为6)
i=i-1；/*i=6-1*/(副作用：再改变变量i的值，使变量i由6减1为5)
c=5+6；
c=c-1；/*c=11-1*/(副作用：由于表达式中连续两个(--i)参与运算，导致了新的“惯性”副作用，使变量c的值也产生减1的作用。
)
所以输出结果为：18，10
综上所述，自加与自减运算符构成的表达式以其简洁、灵活的特点，在c语言的具体应用中发挥着重要的作用。
但是要注意，不要在一个表达式中对同一个变量进行多次诸如自加或自减等具副作用的运算，因为这种表达式不仅可读性差，而且容易产生一些不可预知和难以查找的错误。
作者简介：付亮(1972-)，男，贵州省铜仁市人，1993年毕业于贵州大学数学系，讲师，主要从事信息技术的教学与研究。