C语言自增自减运算符总结
C语言中的运算符总结解读
C语言中的运算符总结C语言中的操作符:算术操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号表达式、下标引用、函数调用和结构成员。
1.算术操作符:+ - * / %1除了% 操作符之外,其他的几个操作符均可以作用于整数和浮点数。
2对于/ 操作符,如果两个操作数都为整数,执行整数除法;而只要有浮点数执行的就是浮点数除法。
3% 操作符的两个操作数必须为整数,返回的是整除之后的余数。
2.移位操作符: << 左移操作符和 >> 右移操作符(针对二进制位、是对整数的操作1左移操作符移位规则:左边丢弃、右边补0。
2右移操作符移位规则:(1算术移位:左边补符号位,右边丢弃。
(2逻辑移位:左边补0,右边丢弃。
注:对于移位运算符,不能移动负数位,这个是标准未定义的。
3.位操作符:& 按位与 | 按位或 ^ 按位异或(操作数都必须是整数,是针对二进制数的操作4.赋值操作符:= 可以重新为变量赋值(赋值操作符是可以连续使用的,从右向左执行,不建议使用。
5.复合赋值符:+= = *= /= %= >>= <<= &= |= ^=6.单目操作符:! 逻辑反操作(真---假- 负值+ 正值& 取地址从内存中取地址,不能从寄存器register 中取址。
sizeof 操作数的类型长度(以字节为单位~ 一个数的二进制按位取反-- 前置、后置-- ++ 前置、后置++ (1前置++和--:先自增后使用,表达式的值是自增之后的值。
先自减后使用,表达式的值是自减之后的值。
(2后置++和--:先使用再自加。
先使用再自减。
* 间接访问操作符(解引用操作符(类型强制类型转换7.关系操作符:> >= < <= != 不相等 == 相等注:== 相等 = 赋值,二者易混淆,需注意。
8.逻辑操作符:&& 逻辑与|| 逻辑或注:逻辑与、逻辑或是判断真假的,按位与、按位或是对二进制数进行操作的。
c语言34种运算符意义和用法
文章标题：深度解析C语言34种运算符的意义和用法在计算机编程世界中，C语言是一种广泛应用的计算机程序设计语言，它为程序员提供了丰富的运算符来完成各种数学和逻辑运算。
作为一个编程语言中至关重要的部分，了解和掌握C语言的运算符对于程序员来说至关重要。
在本文中，我们将深度解析C语言的34种运算符，包括它们的意义和用法，以帮助读者全面了解这些运算符的特点和功能。
1. 赋值运算符赋值运算符是C语言中最基本的运算符之一，用于将右侧的数值或表达式赋给左侧的变量。
赋值运算符由等号（=）表示，例如：a = 10;将10这个数值赋给变量a。
2. 算术运算符算术运算符用于执行基本的数学运算，包括加法（+）、减法（-）、乘法（*）、除法（/）和求模（%）等。
这些运算符在C语言中十分常见，用于处理数字类型的变量。
3. 自增、自减运算符自增（++）和自减（--）运算符用于增加或减少变量的值，它们可以用作前缀或后缀运算符，分别表示在表达式中先执行运算或者先获取变量的值再执行运算。
4. 关系运算符关系运算符用于比较两个值的大小关系，包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）等。
这些运算符经常用于条件判断和逻辑运算中。
5. 逻辑运算符逻辑运算符用于执行逻辑运算，包括与（&&）、或（||）和非（!）运算。
它们通常用于条件判断和逻辑组合中，能够帮助程序员处理复杂的逻辑关系。
6. 位运算符位运算符用于对整数类型的数值进行位操作，包括按位与（&）、按位或（|）、按位取反（~）、按位异或（^）和左移（<<）、右移（>>）等。
位运算符在处理底层数据操作时十分重要。
7. 条件运算符条件运算符（？：）是C语言中唯一的三目运算符，用于根据条件的真假选择不同的值。
它使得代码更加简洁和可读性更强。
8. sizeof运算符sizeof运算符用于获取数据类型或变量的字节大小，它在编程时经常用于内存分配和操作中。
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+b。
2. 减号'-'：用于两个数相减，例如a-b，也可以用于表示负数，例如-a。
3. 乘号'*'：用于两个数相乘，例如a*b。
4. 除号'/'：用于两个数相除，例如a/b。
除号还有一个特殊用法，即求余数，也称为模运算，表示a除以b的余数为c，可以用a%b表示。
在C语言中，可以使用这些符号进行数学运算，例如：int a = 10;int b = 5;int c = a + b; // c的值为15int d = a - b; // d的值为5int e = a * b; // e的值为50int f = a / b; // f的值为2int g = a % b; // g的值为0除了基本的加减乘除符号，C语言还提供了一些其他的符号，例如自增符号'++'和自减符号'--'，用于对变量进行自增或自减操作。
例如：int a = 10;a++; // a的值变为11a--; // a的值变回10需要注意的是，在C语言中，除法运算时要特别小心，因为整数除以整数的结果可能不是精确的，例如：int a = 5;int b = 2;int c = a / b; // c的值为2，而不是2.5为了得到精确的结果，可以将其中一个操作数转换为浮点数，例如：int a = 5;float b = 2.0;float c = a / b; // c的值为2.5总之，在C语言中，加减乘除符号是非常基础的，使用非常频繁，掌握它们的使用方法非常重要。
C语言运算符优先级等级口诀
= += -= *= /= %= &= ^= |= <<= >>= … 从左至右
第一、像() [] -> .之类的理所当然是最优先的，其实它们压根也不算什么运算符了 第二、除了上面的四种运算符之外，接下来就是单目运算符，也就是! ~ ++ -- - (type) * & sizeof 了。记住它们的顺序可是自右向左啊！其实结合实例是很容易理解的，比如i++等。 第三、跟着就是双目运算符了，也是C语言运算符优先级中最容易让人混淆的地方了。其 实也没有那么可怕，你认真观察就会发现。在双目运算符中，算术运算符优先级最高，然后是移位运算符，接着是关系运算符，再着是逻辑运算符。不过这边需要说的是，在关系运算符中，< <= > >=比== !=的优先级来得高。此外，在逻辑运算符中，与运算又比或运算优先级来得高，异或则处于二者之间。同样的，你可以类比出&&与||的优先级关系. 第四、在双目操作符之后，就是三目操作符了，没有什么好说的了。 第五、然后是赋值操作符，你也许会把赋值操作符与三目运算符的优先级搞混。没有关系，我想你一定写过这样的语句（如果没有，请你记住！）：max = (a>b)?a:b; ,从这个语句里，你就不难记住赋值运算符为什么比三目运算符的优先级低了！ 第六、逗号运算符是分割各个子语句的（感觉这么说有点不准确，不过我想大家会明白我的意思的），自然优先级最低了，我想这个应该不是很容易混淆的。 总结一下，按运算符优先级从高到低：单目运算符->双目运算符->三目运算符->赋值运算符->逗号运算符 特别在双目运算符中,按 运算符优先级从高到低:算术运算符->移位运算符->关系运算符（其中== 和 !=优先级又较低）->逻辑运算符（按位与-〉按位异或-〉按位或-〉逻辑与-〉逻辑或）！
c语言加减乘除符号
c语言加减乘除符号
在C语言中，加减乘除运算是最基本的数学运算。
以下是C语言中常用的加减乘除符号：
加法：+
减法：-
乘法：*
除法：/
这些符号可以用来进行简单的数学运算，例如：
int a = 5 + 3;
int b = 10 - 2;
int c = 2 * 4;
int d = 12 / 3;
在程序中使用这些符号时需要注意一些问题：
1. 除法运算时，如果除数为0，将会出现错误。
因此需要在程
序中进行判断，避免出现除0错误。
2. 乘法运算时，如果两个数相乘过大，可能会超出C语言支持
的数据类型的范围，导致程序出错。
因此需要进行数据类型转换或者使用其他方法避免这个问题。
3. 加法和减法运算不存在数据类型转换的问题，但是需要注意
溢出的情况。
如果两个数相加或相减的结果超出数据类型的最大范围，将会出现错误。
总之，在进行加减乘除运算时，需要注意数据类型转换、溢出和
除0错误等问题，以确保程序的正确性和稳定性。
自增自减运算符的规则
自增自减运算符的规则
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自增之后的值。
c语言自增与自减运算符详解
c语言自增与自减运算符详解C语言中的自增和自减运算符是一种特殊的运算符，可以用来对变量进行增加或减少操作。
它们不仅可以用于数值类型的变量，还可以用于指针类型的变量。
在本文中，我们将详细介绍自增和自减运算符的使用方法和注意事项。
让我们来了解一下自增运算符（++）的用法。
自增运算符可以将变量的值增加1。
它可以用在变量前面或后面，分别表示先增加再使用和先使用再增加。
当自增运算符用在变量前面时，它会先将变量的值增加1，然后再使用增加后的值。
例如：```cint a = 1;int b = ++a;// 此时a的值为2，b的值为2```当自增运算符用在变量后面时，它会先使用变量的值，然后再将变量的值增加1。
例如：```cint a = 1;int b = a++;// 此时a的值为2，b的值为1```自增运算符也可以用于指针类型的变量。
当自增运算符用在指针变量前面时，它会将指针的值增加指针指向的数据类型的大小。
例如：```cint arr[5] = {1, 2, 3, 4, 5};int *p = arr;p++; // p指向arr[1]```当自增运算符用在指针变量后面时，它会先使用指针的值，然后再将指针的值增加指针指向的数据类型的大小。
例如：```cint arr[5] = {1, 2, 3, 4, 5};int *p = arr;int a = *p++; // a的值为1，p指向arr[1]```接下来，让我们来了解一下自减运算符（--）的用法。
自减运算符可以将变量的值减少1。
它的使用方法和自增运算符类似，可以用在变量的前面或后面。
当自减运算符用在变量前面时，它会先将变量的值减少1，然后再使用减少后的值。
例如：```cint a = 2;int b = --a;// 此时a的值为1，b的值为1```当自减运算符用在变量后面时，它会先使用变量的值，然后再将变量的值减少1。
例如：```cint a = 2;int b = a--;// 此时a的值为1，b的值为2```自减运算符也可以用于指针类型的变量。
c语言自增自减运算例题
c语言自增自减运算例题（原创版）目录1.C 语言自增自减运算概述2.自增自减运算符的用法3.自增自减运算的注意点4.自增自减运算例题解析5.自增自减运算的实际应用正文【1.C 语言自增自减运算概述】C 语言中的自增自减运算符是一种非常有用的运算符，它可以使程序员在编写程序时更加简洁明了地表达某些操作。
自增自减运算符分别有四种：++、--、+++、--。
前两个用于自增自减运算，后两个用于自减自增运算。
【2.自增自减运算符的用法】自增自减运算符主要用于对变量进行加 1 或减 1 操作。
在 C 语言中，自增自减运算符有两种用法：前置和后置。
前置：变量++或--，表示在运算之前加 1 或减 1。
例如：a++表示在运算之前 a 加 1，而 a--表示在运算之前 a 减 1。
后置：变量+++或-－，表示在运算之后加 1 或减 1。
例如：a+++表示在运算之后 a 加 1，而 a-－表示在运算之后 a 减 1。
【3.自增自减运算的注意点】在使用自增自减运算符时，应注意以下几点：（1）自增自减运算符不能与数值进行运算，只能与变量进行运算。
（2）自增自减运算符的运算对象必须为整型或浮点型变量。
（3）自增自减运算符在一个表达式中只能出现一次。
（4）自增自减运算符的运算结果仍为整型或浮点型。
【4.自增自减运算例题解析】例题：编写一个 C 程序，求 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;}```【5.自增自减运算的实际应用】自增自减运算符在实际编程中应用广泛，它可以提高程序的运行效率和可读性。
自加、自减运算符和逗号表达式
自加、自减运算符和逗号表达式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语言34种运算符
说明：
（1）同一优先级的运算符，运算次序由结合方向决定。
例如 * 与 / 具有相同的优先级别，其结合方向为自左至右，因此3*5/4的运算符次序是先乘后除。
- 和 ++ 为同一优先级，结合方向为自右至左，因此 -i++相当于-（i++）。
（2）不同的运算符要求有不同的运算对象个数，如 + （加）和 - （减）为双目运算符，要求在运算符两侧各有一个运算对象（3+5、8-3等）。
而 ++ 和 - （负
号）运算符是单目运算符，只能在运算符的一侧出现一个运算对象（如– a、
i++、--i、（float）i、sizeof （int）、*p等）。
条件运算符是C语言中唯一的
一个三目运算符，如 x ？ a：b。
（3）从上表中可以大致归纳出各类运算符的优先级：
初等运算符 ( ) [ ] -> .
↓
单目运算符
↓
算术运算符（先乘除后加减）
↓
关系运算符
↓
逻辑运算符（不包括!）
↓
条件运算符
↓
赋值运算符
↓
逗号运算符
以上的优先级别由上到下递减。
初等运算符优先级最高，逗号运算符优先级最低。
位运算符的优先级比较分散（有的在算术运算符之前（如~），有的在关系运算符之前（如>>和<<），有的在关系运算符之后（如&，^、|））。
为了容易记忆，使用位运算符时可加圆括号。
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语言中的运算符和我们平时用的基本上都差不多。
运算符包括赋值运算符、算术运算符、逻辑运算符、位逻辑运算符、位移运算符、关系运算符、自增自减运算符。
大多数运算符都是二目运算符，即运算符位于两个表达式之间。
单目运算符的意思是运算符作用于单个表达式。
(具体什么是表达式下一节再说)一、赋值运算符赋值语句的作用是把某个常量或变量或表达式的值赋值给另一个变量。
符号为‘=’。
这里并不是等于的意思，只是赋值，等于用‘==’表示。
注意：赋值语句左边的变量在程序的其他地方必须要声明。
得已赋值的变量我们称为左值，因为它们出现在赋值语句的左边；产生值的表达式我们称为右值，因为她它们出现在赋值语句的右边。
常数只能作为右值。
例如：count=5;total1=total2=0;第一个赋值语句大家都能理解。
第二个赋值语句的意思是把0同时赋值给两个变量。
这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。
这样它先total2=0;然后total1=total2;那么我们这样行不行呢？(total1=total2)=0;这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表达式，而赋值语句的左边是不允许表达式存在的。
二、算术运算符在C语言中有两个单目和五个双目运算符。
符号功能+ 单目正- 单目负* 乘法/ 除法% 取模+ 加法- 减法下面是一些赋值语句的例子，在赋值运算符右侧的表达式中就使用了上面的算术运算符：Area=Height*Width;num=num1+num2/num3-num4;运算符也有个运算顺序问题，先算乘除再算加减。
单目正和单目负最先运算。
取模运算符(%)用于计算两个整数相除所得的余数。
例如：a=7%4;最终a的结果是3，因为7%4的余数是3。
那么有人要问了，我要想求它们的商怎么办呢？b=7/4;这样b就是它们的商了，应该是1。
也许有人就不明白了，7/4应该是1.75，怎么会是1呢？这里需要说明的是，当两个整数相除时，所得到的结果仍然是整数，没有小数部分。
c语言的34种运算符
c语言的34种运算符C语言是一种广泛使用的编程语言，它的运算符非常丰富，共有34种。
本文将详细介绍C语言的34种运算符及其应用。
一、算术运算符（共9种）1. 加法运算符：+2. 减法运算符：-3. 乘法运算符：*4. 除法运算符：/5. 取余运算符：%6. 递增运算符：++7. 递减运算符：--8. 求幂运算符：^9. 复合赋值运算符：a = a + b、a = a - b、a = a * b、a = a / b、a = a % b、a = a++、a = a--、a = a^b二、关系运算符（共6种）1. 等于运算符：==2. 不等于运算符：!=3. 小于关系运算符：<4. 大于关系运算符：>5. 小于等于关系运算符：<=6. 大于等于关系运算符：>=三、逻辑运算符（共3种）1. 与运算符：&&（双与）2. 或运算符：||（双或）3. 非运算符：!（单引号）四、赋值运算符（共6种）1. 简单赋值运算符：=2. 复合赋值运算符：+=、-=、*=、/=、%=、++、--、^=3. 指针赋值运算符：= *ptr、*p1 = p2、p1 = &p24. 数组赋值运算符：a[i] = value5. 结构体赋值运算符：struct_name.member = value6. union赋值运算符：union_name.member = value五、逗号运算符（共1种）,,用于变量列表，每个变量先初始化再使用六、指针与地址运算符（共7种）1. &（取地址符号）：获取变量的地址2. *（解引用符号）：访问地址指向的值3. (类型) *ptr：获取ptr指向的变量的类型和值4. ptr1 ++：移动ptr1指向的地址，ptr1指向下一个地址5. ptr1 --：移动ptr1指向的地址，ptr1指向前一个地址6. ptr1 = ptr2：将ptr2指向的地址赋给ptr17. &variable_name：获取变量名的内存地址（注意：获取的是字符在内存中的地址，不是变量的值）七、三目运算符（共1种）:条件表达式八、sizeof运算符（共1种）sizeof(变量或类型)，用于计算变量或类型在内存中占用的字节数以上就是C语言中的34种运算符的详细介绍。
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;}```这个例子中，我们使用自减运算符实现了循环次数的控制，避免了使用额外的变量。
运算符：三目运算符,运算符优先级,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相加了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言自增自减运算符总结
978299005@
【例】
int i=5, j=5, p, q;
p = (i++) + (i++);
q = (++j) + (++j);
printf("%d, %d, %d, %d\n", i, j, p, q);
i=5;
j=5;
p = (i++) + (i++) + (i++);
q = (++j) + (++j) + (++j);
printf("%d, %d, %d, %d\n", i, j, p, q);
i=5;
j=5;
p = (i++) + (i++) + (i++) + (i++);
q = (++j) + (++j) + (++j) + (++j);
printf("%d, %d, %d, %d\n", i, j, p, q);
i=5;
j=5;
p = (i++) + (i++) + (i++) + (i++) + (i++);
q = (++j) + (++j) + (++j) + (++j) + (++j);
printf("%d, %d, %d, %d\n", i, j, p, q);
【讲解】
在VC6.0下编译，运行。
这段程序的运行结果是
7, 7, 10, 14
8, 8, 15, 22
9, 9, 15, 22
10, 10, 25, 41
可见a++这类运算，是整个式子算完以后，统计一下有几个++，再统一给a加上几。
而
++a这类运算，在2个以下的时候，是先统计下有几个++，然后都加上去，然后再进行赋值。
超过两个了，那么第三个开始，就是分步来，前两个算完了，第三个把前面得到的值拿来用。
所以，q = (++j) + (++j) + (++j); (j=5)q就等于7+7+8=22.
总结一句话：vc环境中：
++i++i先使i的值自增两次再赋值！
i++i++先赋值再使i的值自增两次！
【注意】
自增自减运算符的对象是变量，不是常量或表达式。
如+ + i + + +j就不合法。
这是因为C 语言的编译器对程序编译时，从左到右尽可能多地将字符组成一个运算符或标识符，因此+ + i + + +j 等效于+ + ( i + + ) + j , 第1 个“ + + ”作用的对象是表达式“i + + ” 这是不允许的。
【汇编的依据】
原理表达式中除了预算法本身的优先级外，还有一个结合性问题。
在++j + ++j + ++j;中，因为存在两个同级的＋运算，根据＋运算符的左结合性，在编译时，其实是先处理前面的（++j + ++j）这部分，然后再将此结果再和++j相加。
具体过程参见汇编代码：
int b = ++j + ++j + ++j;
0040B7DD mov ecx,dword ptr [ebp-8]
0040B7E0 add ecx,1
0040B7E3 mov dword ptr [ebp-8],ecx // 第一个++j
0040B7E6 mov edx,dword ptr [ebp-8]
0040B7E9 add edx,1
0040B7EC mov dword ptr [ebp-8],edx // 第二个++j
0040B7EF mov eax,dword ptr [ebp-8]
0040B7F2 add eax,dword ptr [ebp-8] // ++j + ++j
0040B7F5 mov ecx,dword ptr [ebp-8]
0040B7F8 add ecx,1
0040B7FB mov dword ptr [ebp-8],ecx // 第三个++j
0040B7FE add eax,dword ptr [ebp-8] // ++j + ++j + ++j
0040B801 mov dword ptr [ebp-10h],eax // 赋值给b
另外我们看看a = i++ + i++ + i++;的汇编代码：
int a = i++ + i++ + i++;
0040B7B6 mov eax,dword ptr [ebp-4]
0040B7B9 add eax,dword ptr [ebp-4] // i+i
0040B7BC add eax,dword ptr [ebp-4] // i+i+i
0040B7BF mov dword ptr [ebp-0Ch],eax // 赋值给a
0040B7C2 mov ecx,dword ptr [ebp-4]
0040B7C5 add ecx,1
0040B7C8 mov dword ptr [ebp-4],ecx // 第一次i++
0040B7CB mov edx,dword ptr [ebp-4]
0040B7CE add edx,1
0040B7D1 mov dword ptr [ebp-4],edx // 第二次i++
0040B7D4 mov eax,dword ptr [ebp-4]
0040B7D7 add eax,1
0040B7DA mov dword ptr [ebp-4],eax // 第三次i++
果然不出所料。
到此，++运算符前置后置的问题应该彻底解决了。
为了验证一下上述结论，我们再看：
例四：
int i=1;
int j=1;
int a = i++ + i++ + i++ + i++ + i++ + i++ + i++; // 七个
int b = ++j + ++j + ++j + ++j + ++j + ++j + ++j;
printf("%d, %d\n", a, b);
printf("%d, %d\n", i, j);
规则就是规则，咱的计算机可不是黑客帝国的母体，总是要遵循它的
a = 1+1+1+1+1+1+1 = 7, i=8
b = 3+3+4+5+6+7+8 = 36, j=8
注：以上结果及解释出自VC编译器
参考资料：
/u/20100329/23/2fc2d30e-3c79-4f55-ada6-cd7b3bbed3ba.html。