关于C语言自增自减运算符
c语言自增自减运算例题
c语言自增自减运算例题自增和自减运算是C语言中常用的运算符，用于对变量进行加一或减一操作。
下面是一些关于自增和自减运算的例题，我将从多个角度进行回答。
1. 自增运算符（++）的使用：c.#include <stdio.h>。
int main() {。
int a = 5;printf("a = %d\n", a); // 输出，a = 5。
a++; // 自增操作。
printf("a = %d\n", a); // 输出，a = 6。
return 0;}。
在这个例子中，我们定义了一个整数变量a，并初始化为5。
然后使用自增运算符对a进行加一操作，最后输出a的值。
执行自增运算后，a的值变为6。
2. 自减运算符（--）的使用：c.#include <stdio.h>。
int main() {。
int b = 8;printf("b = %d\n", b); // 输出，b = 8。
b--; // 自减操作。
printf("b = %d\n", b); // 输出，b = 7。
return 0;}。
在这个例子中，我们定义了一个整数变量b，并初始化为8。
然后使用自减运算符对b进行减一操作，最后输出b的值。
执行自减运算后，b的值变为7。
3. 自增运算符的前缀和后缀形式：c.#include <stdio.h>。
int main() {。
int c = 3;int d = 3;printf("c = %d\n", c++); // 输出，c = 3。
printf("c = %d\n", c); // 输出，c = 4。
printf("d = %d\n", ++d); // 输出，d = 4。
printf("d = %d\n", d); // 输出，d = 4。
探讨C语言中自增、自减运算符
ｊ（ ＋＋ｉ＋＋ｉ＋； ＝ｉ 源自（ ）（ ） ＋ ＋ ＋ ② ｐｉｔ“＝ ， ％ｄｎ ， ） ｒ ｆ ｉ％ｄ ＝ ｋ”ｉ ； ｎ（ ｊ
ｉ３ － ：
ｐｉ “＝ ％ｄ ， ＋＋＋ ｉ （＋） ｒ ｉ％ｄ ＝ ”，十 ｉ（＋） 十 ｉ； ｎ ｉ ＋ ）
它们的结合方向 ， 否则就会 出现错误 。 自增与 自减运算符是 ｃ语言特 有 的两 种 ２运用 自增 、自减运算符运算规 则时发现 较常用的运算符 ， 只能用于变量 ， 而不能不能用 的问题 于常量和表达式 。 自增运算使单个变量的值 增 笔者在教 学过程 中运用运用 自增 、自减运 １， 等同于变量 ａ ａ １ ＝ ＋ ；自减运算使单个 变量的 算符运算规则 分析下 面程序时发现 ： 值减 １， 等同于变量 ａ ａ １ ＝ ＋ 。自增与 自减运算符 ｍ ｉＯ ａｎ
１自增 （ ＋ 、 ＋ ） 自减 （ ） 法 与 运算 规 则 一 用
有两种用法 ： ａ． 前 置 运 算 — — 运 算 符 放 在 变 量 之 前 ： （ｉｔＩ３ ； ｎ ＿ ｊ＋ ｉ（＋）（＋） ＝ ＋＋＋ ｉ ＋ ｉ（ ＋ ； ｐ ｎ （ｉ％ｄ ＝ ＼”ｉ） ｉ ｆ ｆ“＿ ％ｄｎ ， ；
责任编辑 ： 宋义
一
９５ —
ａ ，＝１ ＝６ ｂ ８ ａ ６， ９ ＝ ｂ＝
该不 同 ； 同样 ， ｐ ｎ Ｏ 在 ｆ ｆ 函数 中 ， ｉ 其所遵循 的运 算规则与前两者又有所不 同。究其原因， 先用 “ 后变 ， 先变后用 ” 中的“ ” 后” 先 和“ 是一个模糊 的 概念 ， 很难给出顺序或时 间上的准确定论 。 先” “ 到什么时候 ，后” “ 到什么程度？ 通过查阅此 方面 的资料 ， 发现不同的知名教授也有不同的结果 ， 但并不是他们有误 ，而是这类表达式太依 赖编 译 器 ， 同 的 运行 环境 就 有 不 同的 结 果 。 因 此 ， 不 不 宜 在 编 程 实 践 中使 用 类 似 表 达 式 。 总之， 自增 、 自减 运算符 是 Ｃ程 序设计 语 言中特有的且常用 的运算符 。但对于初学者而 言，比较难以理解这两个运算 符的运算 实质。 笔者希望对此所作 的探讨 ，能够有助于初 学者 对 自增 、 自减运算符的使用规则的正确理解 。 同 时， 笔者 希望用 Ｃ语 言设计程序时 ，为了保证 可靠性 ， 程序必须 清晰易读 ， 而表达式的清晰易 读是十分重要的方 面。因此 ， Ｃ程序设计中 ， 在 要慎重使用 自增 、 白减运算符 ， 特别是在一个表 达式 中不要多处出现变量 的 自增 、 自减等运算 。
c语言自增自减运算符详解
c语言自增自减运算符详解C语言中的自增自减运算符是非常常用的运算符，它们可以让我们方便地对变量进行加1或减1的操作。
本文将详细介绍C语言中的自增自减运算符。
一、自增运算符自增运算符是一个加号（+）和一个加号（+）组成的运算符，它的作用是将变量的值加1。
例如：int a = 1;a++; // a的值变为2自增运算符可以放在变量的前面或后面，放在前面时，先将变量加1，再使用变量的值；放在后面时，先使用变量的值，再将变量加1。
例如：int a = 1;int b = ++a; // a的值变为2，b的值也为2int c = 1;int d = c++; // c的值变为2，d的值为1需要注意的是，自增运算符只能用于变量，不能用于常量或表达式。
二、自减运算符自减运算符是一个减号（-）和一个减号（-）组成的运算符，它的作用是将变量的值减1。
例如：int a = 2;a--; // a的值变为1自减运算符也可以放在变量的前面或后面，放在前面时，先将变量减1，再使用变量的值；放在后面时，先使用变量的值，再将变量减1。
例如：int a = 2;int b = --a; // a的值变为1，b的值也为1int c = 2;int d = c--; // c的值变为1，d的值为2需要注意的是，自减运算符也只能用于变量，不能用于常量或表达式。
三、自增自减运算符的优先级自增自减运算符的优先级比较高，但是它们的结合性是从右往左的。
例如：int a = 1;int b = ++a + ++a; // a的值变为3，b的值为5int c = 1;int d = c++ + c++; // c的值变为3，d的值为2需要注意的是，不要在同一个表达式中多次使用自增自减运算符，这样会导致代码的可读性变差，容易出错。
四、总结自增自减运算符是C语言中非常常用的运算符，它们可以方便地对变量进行加1或减1的操作。
需要注意的是，自增自减运算符只能用于变量，不能用于常量或表达式；不要在同一个表达式中多次使用自增自减运算符，这样会导致代码的可读性变差，容易出错。
c语言自增自减运算符的变量类型
c语言自增自减运算符的变量类型在计算机编程中，C语言是一种非常常见和重要的编程语言之一。
在C 语言中，自增和自减运算符是非常基础和常用的运算符。
它们通常用于增加或减少变量的值。
在这篇文章中，我将以深度和广度的方式探讨C语言中自增自减运算符的变量类型，并分享一些我个人的观点和理解。
1. 变量类型的概念在C语言中，变量类型是非常重要的概念。
C语言中的每个变量都具有特定的数据类型，它决定了变量所能表示的值的范围和存储方式。
常见的变量类型包括整型、浮点型、字符型等。
在使用自增和自减运算符时，变量的类型会影响到运算结果。
2. 整型变量的自增自减运算对于整型变量而言，自增运算符（++）会使变量的值增加1，自减运算符（--）会使变量的值减少1。
不同的整型变量（如int、short、long等）在进行自增自减运算时，可能会有不同的表现，特别是在涉及到溢出和上溢的情况下。
对于无符号整型变量，在达到最大值后再进行自增操作会导致变量的值变为0。
3. 浮点型变量的自增自减运算在C语言中，浮点型变量是用来表示实数的，它包括float和double 两种类型。
对于浮点型变量而言，自增自减运算并不常见，因为它们通常被用于表示具有实际意义的数值，而非作为计数器使用。
在实际编程中，应该谨慎使用自增自减运算符来操作浮点型变量，以避免精度丢失或意外的结果。
4. 字符型变量的自增自减运算字符型变量在C语言中被用来表示单个字符，它们对应着ASCII码或Unicode码中的数值。
字符型变量可以进行自增自减运算，这其实是对字符编码值的增减操作。
一个字符型变量的值为'A'，对其进行自增操作后，其值将变为'B'。
字符型变量的自增自减运算在某些情况下可以用于字符集的遍历和操作。
5. 总结与展望通过以上对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。
C语言：自增自减
C语⾔：⾃增⾃减⼀个整数类型的变量⾃⾝加 1 可以这样写：a = a + 1;或者a += 1;不过，C语⾔还⽀持另外⼀种更加简洁的写法，就是：a++;或者++a;这种写法叫做⾃加或⾃增，意思很明确，就是每次⾃⾝加 1。
相应的，也有a--和--a，它们叫做⾃减，表⽰⾃⾝减 1。
++和--分别称为⾃增运算符和⾃减运算符，它们在循环结构中使⽤很频繁。
⾃增和⾃减的⽰例：#include <stdio.h>int main(){int a = 10, b = 20;printf("a=%d, b=%d\n", a, b);++a;--b;printf("a=%d, b=%d\n", a, b);a++;b--;printf("a=%d, b=%d\n", a, b);return0;}运⾏结果：a=10, b=20a=11, b=19a=12, b=18⾃增⾃减完成后，会⽤新值替换旧值，将新值保存在当前变量中。
⾃增⾃减的结果必须得有变量来接收，所以⾃增⾃减只能针对变量，不能针对数字，例如10++就是错误的。
需要重点说明的是，++ 在变量前⾯和后⾯是有区别的：++ 在前⾯叫做前⾃增（例如 ++a）。
前⾃增先进⾏⾃增运算，再进⾏其他操作。
++ 在后⾯叫做后⾃增（例如 a++）。
后⾃增先进⾏其他操作，再进⾏⾃增运算。
⾃减（--）也⼀样，有前⾃减和后⾃减之分。
下⾯的例⼦能更好地说明前⾃增（前⾃减）和后⾃增（后⾃减）的区别：#include <stdio.h>int main(){int a = 10, b = 20, c = 30, d = 40;int a1 = ++a, b1 = b++, c1 = --c, d1 = d--;printf("a=%d, a1=%d\n", a, a1);printf("b=%d, b1=%d\n", b, b1);printf("c=%d, c1=%d\n", c, c1);printf("d=%d, d1=%d\n", d, d1);return0;}输出结果：a=11, a1=11b=21, b1=20c=29, c1=29d=39, d1=40a、b、c、d 的输出结果相信⼤家没有疑问，下⾯重点分析a1、b1、c1、d1：1) 对于a1=++a，先执⾏ ++a，结果为 11，再将 11 赋值给 a1，所以 a1 的最终值为11。
自增自减运算符的规则
自增自减运算符的规则
C语言提供自增运算符“++”和自减运算符“--”，这两个运算符在C语言编程中大量使用，而且使用非常灵活，需要重点理解。
首先，我们来总结这两个运算符使用的规则：
(1)、自增运算符“++”是对变量的值增加1；
(2)、自减运算符“--”是对变量的值减掉1；
(3)、参与自增运算符的变量，可以在前和在后，例如有变量int i；可以有i++和++i这样的表达式，这两种表达式都会使变量i的值增加1；而且i++表达式返回i变量自增之前的值；++i表达式是返回i变量自增之后的值。
例如有：
int i1=6；
int i2=6；
int a1=i1++；
int a2=++i2；
那么，a1变量的值是变量i1自增之前的值，所以，a1变量的值是6数值；变量a2的值是变量i2自增之后的值，所以，a2变量的值是7数值。
所以，i1++是一个表达式，如同1+2是一个算术表达式，那么，1+2算术表达式的值是3；而i1++也是一个表达式，它的表达式值是i1变化自增之前的值。
对应++i2也是一个表达式，表达式是值是i2自增之后的值。
自加、自减运算符和逗号表达式
自加、自减运算符和逗号表达式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语言程序设计(自增、自减运算符)
3.2.2自增、自减运算符在循环结构中会经常碰到某一个变量加1再赋给变量本身的情况，如引例的i=i+1。
在c语言中有专门的运算符来表示这种情况，该运算符称为自增运算符，形式为++，含义是使变量自加1，如i++表示的含义是变量i加1再赋给本身，即i++等价于i=i+1，但前者的执行效率高于后者，跟自增运算符类似的还有自减运算符，形式为--，如i--表示变量i减1再赋给本身，即i--等价于i=i-1。
自增自减运算符是单目运算符，它们只能作用于变量。
i++和++i的区别是：i++是i 参与运算后i的值再自增1（即：先引用i，然后i的值再增1），而++i是i自增1后再参与其它运算（即：先使i的值增1，然后再引用i，）。
例如：设i的初值为5,执行完j=i++后j的值为5，i的值为6，而如果i的初值为5，执行完j=++i;后j的值为6，i的值为6。
关于i--和--i的区别同此类似。
注意：自增自减运算符不能作用于常量和表达式，比如：7++和--（a+b）都为错误表达式。
【例3-10】自增自减运算符的使用/*程序名：3_10.c*//*功能：自增自减运算符的使用*/#include<stdio.h>int main(){int i=8;printf("%d,",++i);/*打印自加后的值*/printf("%d,",--i);/*打印自减后的值*/printf("%d,",i++);/*先打印原值，后自加*/printf("%d,",i--);/*先打印原值，后自减*/printf("%d,",-i++);/*先取原值，做负运算并打印，再自加*/printf("%d\n",-i--);/*先取原值，做负运算并打印，再自减*/return0;}该程序的运行结果为：9,8,8,9,-8,-9。
C语言的自增和自减
1、自增和自减运算符是C语言中特有的一种运算符，他们的作用分别是对运算对象做加1和减1运算，其功能如下：++ 自增运算符，如：a++,++a;-- 自减运算符，如：a--,--a。
从表面上看，a++和++a的作用都是使变量a的值加1，但由于运算符++所处的位置不同，使变量a执行加1的运算过程也不同，++a的运算过程是：先使变量a执行a+1的操作，再使用a的值，a++的运算过程是：先使用变量a的值，再执行a+1的操作。
自增和自减运算符只能用于变量，不能用于常数或者表达式。
1、逗号运算符在C语言中，逗号运算符“，”可以将两个或多个表达式连接起来，称为逗号表达式。
逗号表达式的一般形式为：表达式1，表达式2，表达式3....表达式n逗号表达式的运算过程是：先运算表达式1，再计算表达式2，....以此计算到表达式n。
1、条件运算符是C语言中唯一的一个三目运算符，他要求有3个运算对象，用它可以将3个表达式连接构成一个表达式。
条件表达式的一般形式如下：表达式1？表达式2：表达式3其功能是首先计算表达式1，当其值为真（非0值）时，表达式2的值作为挣个条件表达式的值，否则将表达式3的值作为整个条件表达式的值。
C语言中共有6种位运算符，按优先级从高到低依次是：按位取反（运算符~）--左移（运算符<<）--右移（运算符>>）--按位与（运算符&）--按位异或（运算符^）--按位或（运算符|）1、c语言中的移位运算符有两种，左移运算符、右移运算符。
1）左移运算符（<<），其作用是讲一个数的各个二进制位全部左移若干位。
例如a=a<<2，表示将a的二进制数左移2位，若a=15，即二进制数00001111，左移2位得到的结果是00111100，再如a=240，即二进制数11110000，左移2位后得到的结果是11000000.其中高位左移后溢出，被舍弃了，低位以0进补。
C语言中多个自增自减的运算规律-文档资料
C语言中多个自增自减的运算规律C语言中有两个很奇特的单目运算符：++（自增运算符）和--（自减运算符），自增运算符和自减运算符都有前缀式和后缀式。
这两个运算符在C语句中，尤其是循环语句中使用较为广泛，对于单个的自增运算符或自减运算符，相信大家都易于理解。
但是，C语言允许在一个表达式中使用一个以上的自增运算符、自减运算符，这种灵活性使程序简洁，但同时也会引起副作用。
这种副作用主要表现在：使程序费解，并易于发生误解或错误。
例如，当i=3时，表达式（i++）+（i++）+（i++）的值为多少，各种教材说法不统一或者干脆回避这类问题。
既然前面提到在一个表达式中可以有多个自增或自减运算符，我们不能总是以费解或避免出错为由来回避这个问题，不用归不用，了解一下这些内容还是相当有必要的。
为了弄清楚C语言中多个自增或自减运算符的运算规律，笔者经查阅大量资料并反复上机验证，总结出在VC++6.0环境下多个自增自减的运算规律。
1 连续多个后缀的运算规律先统一取值后依次自增或自减。
如：#includevoid main（）{int a，i=5；a=（i++）+（i++）+（i++）；printf（“a=%d，i=%d＼n”，a，i）；}其运算规律是先对所有的i++统一取值5，然后i依次自增3次，即 a=5+5+5=15，i=5+1+1+1=8。
因此，程序输出结果为：a=15，i=82 连续多个前缀的运算规律前两个连续的前缀（两个连续自增，或者两个连续自减，或者一个自增一个自减），即依次自增（减）后，统一取第二个自增（减）的值，后面的每个自增（减）后即刻取值。
如：#includevoid main（）{int a， i=5；a= （++i）+（++i）+（++i）；printf（“a=%d，i=%d＼n”，a，i）；}第一个++i的值为6，第二个++i的值为7，第三个++i的值为8，但第一个++i和第二个++i统一取第二个++i的值7，即a=7+7+8=22，而i的值则依次自增，即i=5+1+1+1=8。
C语言中自增自减运算符的使用
随 着 电子 计算 机 的迅 速 发 展 和广 泛应 用 ， 语言 Ｃ 在 计 算 机软 件 开发 中的作 用 日益 重要 ， 来 越 显 示 出 越 它 的魅 力 ， 已成 为世界 上 广泛 流行 的 、 最有发 展前 途 的 计算机 高级 语 言 。 它适 用 于编 写各 种 系统软 件 ， 也适用 于编 写 各种应 用 软 件 。在 Ｃ语 言 的学 习过 程 中， 者 笔 对 自增 运算 符 和 自减 运算 符 的使用 作 了分析 。
量 ｚ的值 加 １或减 １ 。
请 看下 例 ： 自增 和 自减 运算 符 前 缀 形式 和 后 缀形
式在 实 际运用 中的区别 。
一
１ ０：
Ｙ一 ＋ ＋ ２： １ ７
此 时 ， 行后 Ｙ ｌ ， １ 。 执 — ｌ 一 １ 如果 程序 改 为 ：
Ｘ 一 １ ０；
１ 自增 和 自减 运 算 符 的作 用 和特 点
２ 自增和 自减运 算符 的优 先级和 结合 性
自增 和 自减 运算 符 的优 先级 比算 术运 算 符高 ， 它 与逻辑 非运 算符 （ ） 负号运算符 的优先级 是一样 的。 ！和 自增 和 自减运算 符 的运算 顺序是从 右到左 。 例如 ： 表达 式一＋＋ ， 中 的初 始值 为 ３ 因为 自 ． 『 其 。
因此 先进 行 ３个 ｉ 加 ， 一３ ＋３ ， 相 愚 ＋３ —９ 然后 ， 再实 现
运算 对 象 的后面 ， 也就是前 缀和后缀形 式都 可 以， 以 所 说 ， 于 运算 对象 而 言 ， 果是 一样 的 ， 对 效 但是 从 表 达式 的角度 看 ， 结果却 是不一样 的 。
c语言自增自减运算例题
c语言自增自减运算例题摘要：1.C语言自增自减运算符简介2.自增自减运算符的实例分析3.自增自减运算在实际编程中的应用4.总结与展望正文：C语言自增自减运算符简介在C语言中，自增（++）和自减（--）运算符是用于改变变量值的快捷方式。
自增运算符会使变量的值递增1，而自减运算符会使变量的值递减1。
需要注意的是，自增自减运算符可以单独使用，也可以与其他运算符一起使用。
自增自减运算符的实例分析下面我们通过几个实例来分析自增自减运算符的使用：例1：```c#include <stdio.h>int main() {int a = 10;int b = a++;printf("a = %d, b = %d", a, b); // 输出：a = 11, b = 10return 0;}```在这个例子中，变量a的值被自增1，然后赋值给变量b。
需要注意的是，自增运算符在变量使用前执行，所以b的值为a自增前的值。
例2：```c#include <stdio.h>int main() {int a = 10;int b = ++a;printf("a = %d, b = %d", a, b); // 输出：a = 11, b = 11return 0;}```在这个例子中，变量a的值被自增1，然后赋值给变量b。
需要注意的是，自增运算符在变量使用后执行，所以b的值为a自增后的值。
自增自减运算在实际编程中的应用自增自减运算符在实际编程中有很多应用，比如计数器、循环次数的控制等。
下面举一个简单的例子，使用自减运算实现一个求1到100的和的功能：```c#include <stdio.h>int main() {int sum = 0;for (int i = 1; i <= 100; i++) {sum += i;}printf("1到100的和为：%d", sum);return 0;}```这个例子中，我们使用自减运算符实现了循环次数的控制，避免了使用额外的变量。
c语言自增自减运算规则
c语言自增自减运算规则逗号运算符逗号运算符优先级最低；逗号运算符是用来分割多个表达式的；由逗号运算符组成的逗号表达式的运算结果是：最后一个表达式的结果注意：int i；i = 3,4,5,；以上语句得到的i的值为3i = (3, 4, 5);得到的i的值为5总结：++i置前自增：先对i的值加1，然后用增1后的值参加所有的后续运算i++滞后自增自减：先用变量原来的值参加所有的后续运算，直到本条语句所有的运算全部运算完毕后，才对变量值加减1滞后自增减在条表中的特殊表现：先利用原值参与条件判断，然后立刻自增减；滞后自增减在逗号表达式中的特殊表现：int i = 3, j = 4, k;k = (++i, j++, i++ * ++j);printf("%d %d %d\n", i, j, k);结果：i = 5;j = 6k = 24总结：滞后自增遇到逗号运算符时立刻自增减，但是函数中的参数逗号除外数据类型转换1.1)自动类型转换在某一次运算中，如果参与运算的两个运算数的数据类型不一致，则C语言会对其自定进行数据类型转换，且遵循如下原则：短整型向长整型靠拢；简单数据类型向复杂数据类型靠拢；如下两个例子：5.0 + 1/2=5.0 +0=5.0+0.0=5.05+1/2.0=5+1.0/2.0=5+0.5=5.0+0.5=5.5数学运算式：1/1+1/2+1/3+.....+1/nint i；double s = 0;for(i = 1; i <= n; i++)s += 1.0/i;1.2.强制类型转换语法：(数据类型转化)表达式s += (double)1 / i;//强制类型转换也是运算符，是单目运算符最低的强制类型转换以人类的意志为原则s +=(double)(1/i);//只是得到0.0强制类型转换运算绝对不可能改变变量的数据类型1.3自动强制类型转换这种运算只发生在赋值运算中char c = 97.14159;在赋值时候会丢失一些精度，输出小写字母adouble f = 'A';输出65.000转换原则：若赋值运算符两侧的数据类型不一致，则，由C语言对赋值运算符右侧表达式时的值，进行自动类型转换工作；且是按照赋值运算符左侧的左值数据类型为依据转换的；。
c语言中的算术运算符
C语言中支持多种算术运算符，以下是常见的几种：
1. 加法运算符（+）：可以对两个整数进行加法运算。
例如：3 + 4 = 7
2. 减法运算符（-）：可以对两个整数进行减法运算。
例如：3 - 4 = -1
3. 乘法运算符（*）：可以对两个整数进行乘法运算。
例如：3 * 4 = 12
4. 除法运算符（/）：可以对两个整数进行除法运算，但要注意不能进行整数除法运算。
例如：10 / 3 = 3.33333333333333
5. 取模运算符（%）：取模运算符用于计算整数除法的余数。
例如：10 % 3 = 1
6. 自增运算符（++）：自增运算符可以将一个整数的值加1。
例如：x = 5; x++ = 6;
7. 自减运算符（--）：自减运算符可以将一个整数的值减1。
例如：x = 5; x-- = 4;
8. 赋值运算符（=）：可以将一个值赋给一个变量。
例如：x = 5;
9. 加等于运算符（+=）：可以将一个值加到一个变量上，并将结果赋给该变量。
例如：x = 5; x += 2; x = 7;
10. 减等于运算符（-=）：可以将一个值从一个变量中减去，并将结果赋给该变量。
例如：x = 5; x -= 2; x = 3;
11. 乘等于运算符（*=）：可以将一个值乘以一个变量，并将结果赋给该变量。
例如：x = 5; x *= 2; x = 10;
12. 除等于运算符（/=）：可以将一个值除以一个变量，并将结果赋给该变量。
例如：x = 5; x /= 2; x = 2.5; 注意整数不能直接这样写，需要定义为浮点型才可以。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言自增、自减运算符使用中应注意的问题
++x 表示取x的地址，增加它的内容，然后把值放在寄存器中；
x++ 则表示取x地址，把它的值装入寄存器中，然后增加内存中x的值。
在程序设计中，经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。
变量i被称为“计数器”，用来记录完成某一操作的次数。
C语言为这种计数器操作提供了两个更为简洁的运算符，即++和--，分别叫做自增运算符和自减运算符。
它们是从右向左结合的一元算术运算符，优先级为2。
学习和应用这两个运算符时应注意以下几点：
1注意表达式的值和变量值的区别
以自增运算符为例，当自增运算符++作用于一个变量时，例如：当i=3时++i这个算术表达式的值为4，同时变量i的值也由原来的3改变为4。
一般情况下，计算表达式后不改变变量本身的值，而++运算符和--运算符组成的表达式计算后，则改变变量的值，这称为运算符的副作用。
这类运算符在计算表达式时，一定要注意区分表达式的值和变量的值。
后面有阐述注意表达式的值和变量值的区别）
2注意前缀运算和后缀运算的区别
仍以自增运算符为例，该运算符可作用在变量之前，例如前面所讲的++i，称为前缀运算；也可作用在变量之后，例如i++，称为后缀运算。
在这两种运算中，表达式的值不同：前缀运算后，表达式的值为原变量值加1；后缀运算后，表达式的值仍为原变量值；（也就是我给你说的作为表达式的一部分）
int m=1;
printf("%d",m++);结果为 1（我给你讲输出的是m本身，表达式的值仍为原变量值）
int m=1;
m=m++;
printf("%d",m);
值为2（这是变量的值，你会问什么时候是变量，像m++单独用是为表达式，在其他式子中是变量如m=1时，m=5+（m++）结果为7）（先把m++的值传给m，然后m再+1，若把原式写为）int n，m=1;
n=m++;
printf("%d",n);值是不一样的，输出为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++)?因为负号运算符和自增运算符优先级相同，哪一个正确就得看结合方向。
自增、自减运算符及负号运算符的结合方向是从右向左。
因此，上式等效于k=-(i++)；若i=5，则表达式k=-i++运算之后k的值为-5，i 的值为6。
此赋值表达式的值即为所赋的值-5。
不要因为k=-i++等效于k=-(i++)就先做“++”运算!这里采用的是“先用后变”，即先拿出i的值做负号“-”运算，把这个值赋给变量k之后变量i才自增。
5注意运算符的副作用
C语言允许在一个表达式中使用一个以上的赋值类运算，包括赋值运算符、自增运算符、自减运算符等。
这种灵活性使程序简洁，但同时也会引起副作用。
这种副作用主要表现在：使程序费解，并易于发生误解或错误。
例如，当i=3时，表达式(i++)+(i++)+(i++)的值为多少，各种教材说法不统一：有的认为是9(3+3+3,如谭浩强的《C程序设计》，清华大学出版社，1991)；也有的认为是12(3+4+5，如王森的《C语言程序设计》，电子工业出版社，1995)。
到底哪一个说法正确呢?不妨看看下面这个程序的运行情况：
main( )
｛int i,j;
i=3; j=(i++)+(i++)+(i++); printf(“＼nj=%d,”j);
i=3; printf(“j=%d”，(i++)+(i++)+(i++));
｝
在TC3.0上运行，其结果则是：j=9,j=12,究其原因，“先用后变，先变后用“中的“先”和“后”是一个模糊的概念，很难给出顺序或时间上的准确定论。
“先”到什么时候，“后”到什么程度?没有此方面的详细资料可供查询。
为此，笔者用各种表达式上机测试，结果发现当表达式的值作为printf函数的直接输出对象时，“先变后用”和“先用后变”中的“后”就是指++i和i++这一小项运算完之后，如上面程序中最后一个语句中的输出对象：第一个(i++)取出i的值3以后i立即变为4，第二个(i++)取出i的值4以后i立即变为5，第三个(i++)取出i的值5以后i立即变为6，这样输出的结果便是3+4+5这个表达式的值，即12。
而在其它一些表达式或语句中，“变”或“用”的时机却很难掌握。
下列各式中变量j的值都是在i=3,k=1的前提下求出的：后缀运算：
(1)j=(5,6,(i++)+(i++)+(i++)): j=9(3+3+3)
(2)j=(k++,6,(i++)+(i++)+(i++)): j=9(3+3+3)
(3)j=1?(i++)+(i++)+(i++): 0: j=9(3+3+3)
(4)j=i?(i++)+(i++)+(i++): 0: j=12(3+4+5)
(5)j=k++?(i++)+(i++)+(i++): 0: j=12(3+4+5)
前缀运算：
(6)j=(5,i,(++i)+(++i)+(++i)): j=18(6+6+6)
(7)j=(5,k++,(++i)+(++i)+(++i)): j=15(4+5+6)
(8)j=1?(++i)+(++i)+(++i): 0: j=18(6+6+6)
(9)j=1?(k++,(+i)+(++i)+++i)): 0: j=15(4+5+6)
(10)j=k++?(++i)+(++i)+(++i): 0: j=15(4+5+6)
其中(3)和(4)、(6)和(7)、(8)和(10)等这几对类型相同的表达式却得到完全不同的运算结果，令人费解!由此可见，在一般表达式中，就i++来说，“先用后变”中何时“变”很难说得清楚；对++i来说，“先变后用”中何时“用”也不易道白(自减运算符与此类似)。
因此，读者在使用这类运算符时一定要特别注意。
克服这类副作用的方法是，尽量把程序写得易懂一些，即将费解处分解成若干个语句。
如：k=i+++j：可写成k=i+j：i++：而类似(i++)+(i++)+(i++)这类连续自增、自减的运算最好不要使用，以避免疑团的出现，同时也可减少程序出错的可性能。
在程序设计中，效率和易读性是一对主要矛盾。
为了提高程序的效率，需要用技巧把程序写得尽可能简洁一些，但这样有可能降低程序的可读性和可理解性。
可读性差的程序容易隐藏错误且难于纠正，不易维护，降低了程序的可靠性。
鉴于“软件危机”的教训，人们在程序设计时遵守的基本规范是：可靠性第一，效率第二。
为了保证可靠性，程序必须清晰易读，而表达式的清晰易读是十分重要的方面。
因此，在C程序设计中，要慎重使用自增、自减运算符，特别是在一个表达式中不要多处出现变量的自增、自减等运算。