自增自减运算符

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语言加加减减运算符C语言中的加加减减运算符是程序员经常使用的一种运算符。

它们的作用是对变量进行自增或者自减操作，可以简化程序的编写过程，提高代码的可读性和执行效率。

加加运算符（++）是一种自增运算符，用于将变量的值增加1。

它可以用在变量前面（前缀形式）或者变量后面（后缀形式）。

前缀形式表示先对变量自增，再使用变量的值；后缀形式表示先使用变量的值，再对变量自增。

例如，假设有一个整型变量a的初始值为5，我们可以使用加加运算符对a的值进行自增操作。

如果使用前缀形式的加加运算符，则可以写成++a；如果使用后缀形式的加加运算符，则可以写成a++。

无论是前缀形式还是后缀形式，都会将变量a的值增加1。

下面是一个示例代码，演示了加加运算符的使用方式：```#include <stdio.h>int main() {int a = 5;printf("前缀形式自增：%d\n", ++a);printf("后缀形式自增：%d\n", a++);return 0;}```在上述代码中，首先定义了一个整型变量a并初始化为5。

接着使用printf函数分别输出了前缀形式和后缀形式的自增结果。

结果为6和6，这是因为前缀形式的加加运算符先对变量a进行自增操作，再获取其值；后缀形式的加加运算符先获取变量a的值，再对其进行自增操作。

减减运算符（--）与加加运算符类似，是一种自减运算符，用于将变量的值减少1。

它也可以用在变量前面（前缀形式）或者变量后面（后缀形式）。

前缀形式表示先对变量自减，再使用变量的值；后缀形式表示先使用变量的值，再对变量自减。

下面是一个示例代码，演示了减减运算符的使用方式：```#include <stdio.h>int main() {int a = 5;printf("前缀形式自减：%d\n", --a);printf("后缀形式自减：%d\n", a--);return 0;}```在上述代码中，同样定义了一个整型变量a并初始化为5。

c语言的计算符号

c语言的计算符号C语言中常用的计算符号包括：1.加法运算符（+）：用于将两个数相加。

2.减法运算符（-）：用于将一个数减去另一个数。

3.乘法运算符（*）：用于将两个数相乘。

4.除法运算符（/）：用于将一个数除以另一个数。

5.取模运算符（%）：用于求两个数的余数。

6.赋值运算符（=）：用于将一个值赋给一个变量。

7.自增运算符（++）：用于将一个变量的值加1。

8.自减运算符（--）：用于将一个变量的值减1。

9.增量运算符（+=）：用于将一个变量的值加上另一个值。

10.减量运算符（-=）：用于将一个变量的值减去另一个值。

11.乘法赋值运算符（*=）：用于将一个变量的值乘以另一个值。

12.除法赋值运算符（/=）：用于将一个变量的值除以另一个值。

13.取模赋值运算符（%=）：用于将一个变量的余数赋给另一个变量。

这些符号可以组合使用，以实现更复杂的计算和操作。

例如，表达式“a+b*c”表示将a加上b和c的乘积，而“x++”表示将x的值加1，并将结果存储在x中。

除了上述提到的计算符号外，C语言还提供了其他一些计算符号，包括：1.算术运算符：包括加（+）、减（-）、乘（*）、除（/）、取余（%）等。

2.关系运算符：用于比较运算，包括大于（>）、小于（<）、等于（==）、大于等于（>=）、小于等于（<=）和不等于（!=）等。

3.逻辑运算符：包括逻辑与（&&）、逻辑或（||）和逻辑非（！）等。

4.位运算符：用于二进制位运算，包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)等。

5.条件运算符：也称为三元运算符，用于条件求值，格式为“? :”。

6.逗号运算符：用于将多个表达式组合成一个表达式。

7.赋值运算符：包括简单赋值（=）、复合算术赋值（+=、-=、*=、/=、%=）和复合位运算赋值（&=、|=、^=、>>=、<<=）等。

算术运算符

算术运算符1.概述加法运算符减法运算符乘法运算符除法运算符指数运算符余数运算符数值运算符负数值运算符自增运算符自减运算符减法、乘法、除法运算符就是单纯的数学运算,下面介绍其它几个运算符,重点是加法运算符。

2.加法运算符加法运算符有两种运算规则:数学意义上的相加连接字符串2.1基本规则非字符串类型的数据相加时执行数学运算1+1 //21 + true // 2false + true //11 + null //11 + undefined // NaN当有字符串参与时会执行连接运算1 + '1' //'11'false + '2' //'false2'注意运算的顺序是从左往右3+'4'+5//'345'3+4+'5'//'75'2.2对象的相加对象在执行连接运算符的时候,先转换为原始类型,然后再相加。

对象转原始类型的值规则如下:先调用valueOf返回对象自身,再调用toString方法将其转为字符串需要注意的是如果valueOf返回的是基础数据类型则直接当作返回值不再执行toString方法var a = {};var b = function({foo};a + 1 // '[object Object]1'a + b; // '[object Object]function({foo}'知道了这个规则以后就可以自定义valueOf或者toString方法得到想要的返回值const obj = {valueOf:function({return 1;}};1 + obj //2const obj1 = {toString: function({return 'custom'}};1 + obj1 // '1custom'这里面有一个特例就是 Date类型,Date类型直接执行toString方法进行转换,不会执行valueOfconst date = new Date(;date.valueOf = function({ return 'jack' };date.toString = function({return 'tom' };1 + date // '1tom'余数运算符余数运算符（%）返回前一个运算子被后一个运算子除，所得的余数。

自增自减运算符自增自减运算符，又称前置和后置运算符，是一类特殊的算术表达符号，用来对被操作数做自增或自减操作。

它有两种形式，一种为++表示自增；另一种为 --表示自减。

自增自减运算符也可以被称之为简化算术表达式”，有助于简化程序中的算术表达式，也为程序设计者提供了更多的灵活性。

二、自增自减运算符的使用（1）变量自增 1置的自增运算符 a++变量 a值增加1，即先计算 a值，然后自增1。

a++语法为： a++ ++a 。

后置的自增运算符 a--变量 a值减少1，即先计算 a值，然后自减1。

a--语法为： a-- --a 。

（2）数组自增或自减自增运算符也可以用于数组上，此时作用是使数组下标自增或自减。

前置自增运算符可以用于某个数组元素的下标，例如++array[i] 。

此运算符先将 i增1，然后返回 i指的元素的值，最终将 i向下一个元素。

而后置自增运算符 array[i]++先将 i指的元素的值返回，然后将 i增1，最终将 i向下一个元素。

三、自增自减运算符的应用（1）处理循环自增自减运算符在循环操作中广泛应用，例如，在for循环中，它们可以很方便地实现循环项之间值的增减，如下所示：for（int i=0;i<100;i++）{//环体}（2）处理字符串自增自减运算符也可以用于处理字符串，例如可以使用前置运算符在字符串中查找一个字符：char c=str[0];//为str的第一个字符while(c!=0//判断当前字符是否为空字符{//其他处理c=str[++i];//使 i增}四、自增自减运算符的安全使用自增自减运算符在 C/C++程序设计语言中是非常常见的，但在使用它们时也要注意安全性，以免出现意外错误。

（1）确保变量范围当使用自增自减运算符时，要先确保变量在有效的范围内，因为它们将使变量的值超过有效范围，从而导致错误。

（2）不要傻傻滥用自增自减运算符具有优雅的表现力，但也不能滥用，否则容易导致程序混乱。

C 自增运算符与自减运算符

C 自增运算符与自减运算符C语言提供了两个用于变量递增与递减的特殊运算符。

自增运算符++使其操作数递增1，自减运算符使其操作数递减1。

我们经常使用++运算符递增变量的值，如下所示：if (c = '\n')++nl;++与--这两个运算符特殊的地方主要表现在：它们既可以用作前缀运算符（用在变量前面，如++n）。

也可以用作后缀运算符（用在变量后面，如n++）。

在这两种情况下，其效果都是将变量n的值加1。

但是，它们之间有一点不同。

表达式++n先将n的值递增1，然后再使用变量n 的值，而表达式n++则是先使用变量n 的值，然后再将n 的值递增1。

也就是说，对于使用变量n的值的上下文来说，++n和n++的效果是不同的。

如果n的值为5，那么x = n++;执行后的结果是将x的值置为5，而x = ++n;将x的值置为6。

这两条语句执行完成后，变量n的值都是6。

自增与自减运算符只能作用于变量，类似于表达式(i+j)++是非法的。

在不需要使用任何具体值且仅需要递增变量的情况下，前缀方式和后缀方式的效果相同。

例如：if (c == '\n')nl++;但在某些情况下需要酌情考虑。

例如，考虑下面的函数squeeze(s, c)，它删除字符串s 中出现的所有字符c：/* squeeze: delete all c from s */void squeeze(char s[], int c){int i, j;for (i = j = 0; s[i] != '\0'; i++)if (s[i] != c)s[j++] = s[i];s[j] = '\0';}每当出现一个不是c 的字符时，该函数把它拷贝到数组中下标为j 的位置，随后才将j 的值增加1，以准备处理下一个字符。

其中的if语句完全等价于下列语句：if (s[i] != c) {s[j] = s[i];j++;}我们在第1章中编写的函数getline是类似结构的另外一个例子。

自加、自减运算符和逗号表达式

自加、自减运算符和逗号表达式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语⾔：⾃增⾃减运算符的操作详解博主在回忆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。

i++、i--、++i、--i

运算符之“特殊问题特殊对待”1.1 什么是自增自减运算符在代码编写过程中值类型是如此的常用，自增自减运算符是值类型操作的一种方便的方法。

自增自减运算符包括（i++、i--、++i、--i这里i是整型也可以是浮点型），如图1所示，演示了一个自增运算符。

例025：自增运算符实例创建一个控制台应用程序，使用控制台输出整型变量i自增后的值，代码如下：class program{static void Main() //入口方法{int i = 20; //定义整型变量i的值为20i++; //i自增1System.Console.WriteLine(i); //输出i的值System.Console.ReadLine(); //等待回车后继续}}程序运行结果为：21。

2.自减运算符例026：自减运算符实例创建一个控制台应用程序，使用控制台输出整型变量i自减后的值，代码如下：class program{static void Main() //入口方法{int i = 20; //定义整型变量i的值为20i--; //i自减1System.Console.WriteLine(i); //输出i的值System.Console.ReadLine(); //等待回车后继续}}程序运行结果为：19。

说明：前面两个实例看起来好像很简单，但是在使用过程中要理解几个概念很重要，首先是自增运算符i++与++i在使用上的区别，然后是自减运算符i--与--i在使用上的区别。

3．自增运算符i++与++i在使用上的区别例027：自增运算符i++与++i在使用上的区别实例1创建一个控制台应用程序，演示i++与++i的区别，代码如下：class program{static void Main() //入口方法{int i = 20; //定义整型变量i值为20u int j = i++ + 10; //定义整型变量j i的值加10，表达式完成后i自加1 System.Console.WriteLine("i={0}", i); //输出变量i的值System.Console.WriteLine("j={0}", j); //输出变量j的值System.Console.ReadLine(); //等待回车继续}}代码导读u i++在使用时i的值先参与表达式的计算后，i的值再自加1。

基本运算符的运算规则(

基本运算符的运算规则（基本运算符是编程语言中常见的运算符，用于进行基本的数学和逻辑运算。

它们是程序中最基本的操作之一，用于对数据进行处理和计算。

在不同的编程语言中，基本运算符的规则可能会有所不同，但是它们都遵循一些基本的原则和规则。

1.算术运算符：-加法运算符（+）：对两个数字进行相加。

-减法运算符（-）：从第一个数字中减去第二个数字。

-乘法运算符（*）：将两个数字相乘。

-除法运算符（/）：将第一个数字除以第二个数字。

-取模运算符（%）：返回两个数字相除的余数。

-运算符的操作数可以是整数、浮点数或其他兼容的类型。

-加法运算符和乘法运算符都是可交换的，即a+b=b+a,a*b=b*a。

-运算符的优先级从高到低为：乘法和除法>加法和减法>括号。

可以使用括号来改变运算的顺序。

2.关系运算符：-等于运算符（==）：判断两个操作数是否相等。

-不等于运算符（!=）：判断两个操作数是否不相等。

-大于运算符（>）：判断第一个操作数是否大于第二个操作数。

-小于运算符（<）：判断第一个操作数是否小于第二个操作数。

-大于等于运算符（>=）：判断第一个操作数是否大于等于第二个操作数。

-小于等于运算符（<=）：判断第一个操作数是否小于等于第二个操作数。

- 关系运算符的结果为布尔值（true或false）。

如果关系成立，则结果为true；否则为false。

-关系运算符可以用于比较数值、字符、字符串等不同类型的数据。

3.逻辑运算符：-逻辑与运算符（&&）：只有两个操作数都为真时，结果才为真。

-逻辑或运算符（，）：只有两个操作数都为假时，结果才为假。

-逻辑非运算符（!）：对操作数取反，如果操作数为真，则结果为假；如果操作数为假，则结果为真。

-逻辑运算符用于对布尔值进行操作和组合。

-逻辑与运算符和逻辑或运算符都是短路运算符，即如果第一个操作数的值已经决定了结果，那么就不会再计算第二个操作数的值。

C语言自增自减运算符深入剖析

发布日期：来源：作者：引子语言地自增，自减运算符对于初学者来说一直都是个难题，甚至很多老手也会产生困惑，最近我在网上看到一个问题：<>() *主函数*{;;;()()();()()();("\");} 结果是什么？而后搜了一下后发现，类似地问题很多，也就是说对自增自减运算符感到迷惑是一个普遍存在地问题，基于此，决定对自增自减运算符做个小小地解析，希望能给语言爱好者们提供参考，解决对此问题地困惑.自增自减运算符语法自增运算符使操作数地值加，其操作数必须为可变左值（可简单地理解为变量）.对于自增就是加这一点，想大家都不会有什么疑问.问题在于：可以置于操作数前面，也可以放在后面，如：;;表示，自增后再参与其它运算；而则是参与运算后，地值再自增.自减运算符与之类似，只不过是变加为减而已，故不重述.实例剖析下面我们通过一些实例来深入理解自增运算符地特性，自减运算符同理自悟例一：;; ;;(", \", , );对此，想大家都不会有什么困惑，结果就是，；下面我们来做一点小改动：;;;;(", \", , );结果又是多少呢？这里就开始体现出前置与后置地区别了，结果是，.结合此例，我们回头再来理解一下“前置：自增后再参与其它运算；后置：参与运算后，地值再自增”.很明显，;由于是先执行赋值运算，再自增，所以结果是＝，＝；而;则因先自增，然后再赋值，所以，均为.其实基本道理就这么简单了，但在更复杂点地情况下又会如何呢，请看：例二：;;;;(", \", , );问题又来了，是先自增一次，相加，再自增，然后赋值呢，还是先相加赋值然后自增两次呢.另外，＋＋又将如何表现呢？结果是：，这下明白了，原来地理解应该是执行完整个表达式地其他操作后，然后才自增，所以例子中地＝＋＝；而后再自增次，＝；相反，是先自增然后再参加其它运算，所以＝＋＝.到此，是否就彻底明了了呢？然后回到引子中地问题：例三：;;;;(", \", , );有人可能会说，这很简单，我全明白了：＝＋＋＝，＝，＝＋＋＝，＝.真地是这样吗？结果却是：，这下可好，又糊涂了.对于;我们已经没有疑问了，后置就是执行完整个表达式地其他操作后，然后才自增，上例中也得到了验证，但;又该如何理解呢？原理表达式中除了预算法本身地优先级外，还有一个结合性问题.在;中，因为存在两个同级地＋运算，根据＋运算符地左结合性，在编译时，其实是先处理前面地（）这部分，然后再将此结果再和相加.具体过程参见汇编代码：;[][] 第一个[][] 第二个[][][][] 第三个[][] 赋值给另外我们看看;地汇编代码：;[][][][] 赋值给[][] 第一次[][] 第二次[][] 第三次果然不出所料.到此，运算符前置后置地问题应该彻底解决了. 为了验证一下上述结论，我们再看：例四：;;; 七个;(", \", , );(", \", , );规则就是规则，咱地计算机可不是黑客帝国地母体，总是要遵循它地,,一切，恭喜你还生活在世纪地地球，不用担心控制你地思维和生活注：以上结果及解释出自编译器，但对于＋＋这个问题是和编译器地解析有关地，不同厂家可能理解不一致，因手头没有其他开发环境，暂无法做全面分析，本文只是为了说明＋＋，－－这运算符地一些特性，尤其是前置后置地区别这个问题.类似地问题如果有困惑，最好是写程序做试验解决，请勿生搬硬套.谢谢！在实际地编程实践中，类似地问题除了要试验搞清外，认为应该尽量避免引入环境相关地编程技巧.。

c语言自增自减问题总结

C语言自增自減问题总结在程序设计中，经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。

C 语言为这种操作提供了两个更为简洁的运算符，即++和--，分别叫做自增运算符和自减运算符。

它们是单目运算符，是从右向左结合的算术运算符。

学习和应用这两个运算符时应注意以下几点：我将自增自减运算符和变量结合在一下的表达式称为自增自减表达式，如x++，--I等。

通常情况下就有以下的结论：1‘’前缀表达式：++x, --x; 其中x表示变量名，先完成变量的自增自减1运算，再用x的值作为表达式的值；即“先变后用”，也就是变量的值先变，再用变量的值参与运算。

2、后缀表达式：x++, x--; 先用x的当前值作为表达式的值，再进行自增自减1运算。

即“先用后变”，也就是先用变量的值参与运算，变量的值再进行自增自减变化，。

如a=8; b=a++; c=++a; 其中赋给变量b的值为表达式(a++)的值，不应该理解为a的值，则b=8, c=10；3、自增、自减运算只能用于单个变量，只要是标准类型的变量，不管是整型、实型，还是字符型变量等，但不能用于表达式或常量。

如：++(a+b), 与5++，const int N=0; N++; 等都是错误的。

而i+++j++、++i+(++j)、++a+b++、++array ［--j］；等，这些都是合法的。

4、再说结合性与结合方向编译器对程序编译时，从左到右尽可能多地将字符组合成一个运算符或标识符，因此i+++j++等效于(i++)+(j++)，两个“++”作用的对象都是变量，这是合法的；而++i+++j等效于++(i++)+j,第1个“++”作用的对象是表达式“i++”，这是不允许的。

自增自减运算符是单目运算符，其结合性是从右到左。

表达式k=-i++等效于k=(-i)++还是k=-(i++)?。

因为负号也是单目运算符，因此，上式从右到左结合，等效于k=-(i++)；若i=5，则表达式k=-i++运算之后k的值为-5，i的值为6。

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语言对赋值运算符右侧表达式时的值，进行自动类型转换工作；且是按照赋值运算符左侧的左值数据类型为依据转换的；。

运算符：三目运算符,运算符优先级,sizeof,自增自减,取余

运算符：三⽬运算符,运算符优先级,sizeof,⾃增⾃减,取余⼀://---------运算符-----------// 1.运算符是告诉编译程序执⾏特定算术或逻辑操作的符号。

2.按照功能划分: 算术运算符、关系运算符与逻辑运算符、按位运算符。

3.运算符根据参与运算的操作数的个数分为: 单⽬运算、双⽬运算、三⽬运算 4.单⽬运算:只有⼀个操作数如 : i++ ! sizeof 双⽬运算:有两个操作数如 : a+b 三⽬运算符:C语⾔中唯⼀的⼀个,也称为问号表达式 a>b ? 1 : 0⼆://---------优先级与结合性-----------// 优先级: 15级在表达式中,优先级较⾼的先于优先级较低的进⾏运算。

⽽在⼀个运算量两侧的运算符优先级相同时,则按运算符的结合性所规定的结合⽅向处理。

结合性: C语⾔中各运算符的结合性分为两种,即左结合性(⾃左⾄右)和右结合性(⾃右⾄左)。

⼩技巧加括号特点:什么样数据类型相互运算结果还是什么数据类型三://---------算术运算符-----------// 结合性:从左到右 1.优先级: (1) * / % 优先级⼤于 + - (2) 优先级相同则左结合计算 2.求余运算符注意: m%n 求余,相当于m/n 获取余数 (1)n等于0 ⽆意义 (2)m等于0 结果为0 (3)m>n 正常求余如:8%3 = 2 (4)m<n 结果是m 如:2%4 = 2 1%4 = 1 3%8=3 2)运算结果的正负性取决于第⼀个运算数,跟后⾯的运算数⽆关四://---------类型转换-----------// 1.类型转换分为:隐式数据类型转换(⾃动转换) 和显⽰数据类型转换(强制装换--强转)(类型说明符) (表达式) 2.显⽰类型转换的⽅法是在被转换对象(或表达式)前加类型标识符,其格式是: (类型标识符)表达式 3.在使⽤强制转换时应注意以下问题: 1)类型说明符和表达式都必须加括号(单个变量可以不加括号),如把(int)(x+y)写成(int)x+y 则成了把x转换成int型之后再与y相加了。