自增，自减运算符使用注意及案例
 
1.++i , --i (在使用 i 之前，先使 i 的值加（减) 1）
 
2.i++ , i-- (在使用 i 之后，先使 i 的值加（减) 1）
 
3.int i=3;
 
int i=3,j;
j = ++i;// i 的值先变成 4,再赋给j,j的值为4
j = i++;// 先将 i 的值3赋给 j，j的值为 3，然后 i变成4
 
又如：
 
i=3;
printf("%d",++i); //输出 4
//若是
printf("%d\n",i++); //输出 3
 
4.注意
 
自增运算符（++）和自减运算符（--）只能用于变量；
错误表示：5++，（a+b）++；都是错误表达，因为最后得到的结果，没有变量可供存放；
表达式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.结合上面的基本要求和注意事项，来看“先变后用”还是“先用后变” 案例：
 
变量 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)
 
理解上述式子用到的知识：
 
（1）逗号表达式：
 
　逗号运算符是所有运算符中级别最低的。因此，下面两个表达式的作用是不同的:

 　　① x=(a=3，6*3)
 　　② x=a=3，6*a

 　　第①个是一个赋值表达式，将一个逗号表达式的值赋给x，x的值等于18。第②个是逗号表达式，它包括一个赋值表达式和一个算术表达式，x的值为3。
 
（2）三目运算符（结合方向，右到左）
 
      一般形式为：
        表达式1? 表达式2： 表达式3 
        其求值规则为：如果表达式1的值为真，则以表达式2 的值作为条件表达式的值，否则以表达式2的值作为整个条件表达式的值。
 
6.作为初学者，写自增，自减运算符时要特别注意使用的细节；看大佬写的代码，做题时，要认真分析逻辑关系，自增自减运算符与其他运算符相结合，注意优先级，还有要从右向左计算。
 
7.C语言运算符优先级表
 
Ｃ语言中，运算符的运算优先级共分为15 级。
1 级最高，15级最低。
在表达式中，优先级较高的先于优先级较低的进行运算。
而在一个运算量两侧的运算符优先级相同时，则按运算符的结合性所规定的结合方向处理。
运算符的结合性：Ｃ语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。
例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。
最典型的右结合性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。
Ｃ语言运算符中有不少为右结合性，应注意区别，以避免理解错误。
 
说明：
 
同一优先级的运算符，运算次序由结合方向所决定。
 
简单记就是：！ > 算术运算符 > 关系运算符 > && > || >赋值运算符
 
优先级
运算符
名称或含义
使用形式
结合方向
说明
1
[]
数组下标
数组名[常量表达式]
左到右
 
()
圆括号
(表达式)/函数名(形参表)
 
.
成员选择(对象)
对象.成员名
 
->
成员选择（指针)
 
 
2
-
负号运算符
-表达式
右到左
单目运算符
(类型)
强制类型转换
(数据类型)表达式
 
++
自增运算符
++变量名/变量名++
单目运算符
--
自减运算符
--变量名/变量名--
单目运算符
*
取值运算符
*指针变量
单目运算符
&
取地址运算符
&变量名
单目运算符
！
逻辑非运算符
！表达式
单目运算符
~
按位取反运算符
~表达式
单目运算符
sizeof
长度运算符
sizeof(表达式)
 
3
/
除
表达式/表达式
左到右
双目运算符
*
乘
表达式*表达式
双目运算符
%
余数（取模）
整形表达式%整形表达式
双目运算符
4
+
加
表达式+表达式
左到右
双目运算符
-
减
表达式-表达式
双目运算符
5
<<
左移
变量<<表达式
左到右
双目运算符
>>
右移
变量>>表达式
双目运算符
6
>
大于
表达式>表达式
左到右
双目运算符
>=
大于等于
表达式>=表达式
双目运算符
<
小于
表达式<表达式
双目运算符
<=
小于等于
表达式<=表达式
双目运算符
7
==
等于
表达式==表达式
左到右
双目运算符
!=
不等于
表达式!=表达式
双目运算符
8
&
按位与
表达式&表达式
左到右
双目运算符
9
^
按位异或
表达式^表达式
左到右
双目运算符
10
|
按位或
表达式|表达式
左到右
双目运算符
11
&&
逻辑与
表达式&&表达式
左到右
双目运算符
12
||
逻辑或
表达式||表达式
左到右
双目运算符
13
?:
条件运算符
表达式1？表达式2：表达式3
右到左
三目运算符
14
=
赋值运算符
变量=表达式
右到左
 
/=
除后赋值
变量/=表达式
 
*=
乘后赋值
变量*=表达式
 
%=
取模后赋值
变量%=表达式
 
+=
加后赋值
变量+=表达式
 
-=
减后赋值
变量-=表达式
 
<<=
左移后赋值
变量<<=表达式
 
>>=
右移后赋值
变量>>=表达式
 
&=
按位与后赋值
变量&=表达式
 
^=
按位异或后赋值
变量^=表达式
 
|=
按位或后赋值
变量|=表达式
 
15
,
逗号运算符
表达式，表达式……
左到右
从左到右顺序运算

[案例]说明关系表达式的值关系
 
main()
{
    int result=0;
    int num1=3,num2=4,num3=5;
    result=num1>num2;
    printf("num1>num2 is equal:%d\n",result);
    result=(num1>num2)!=num3;
    printf("(num1>num2)!=num3 is equal:%d\n",result);
    result=num1<num2<num3;
    printf("num1<num2<num3 is equal:%d\n",result);
    result=(num1<num2)+num3;
    printf("(num1<num2)+num3 is equal:%d\n",result);
} 
 
下面的关系表达式都是合法的：
 a>b，a+b>c-d，(a=3)<=(b=5)，‘a’>=‘b’，(a>b)= =(b>c)
 关系表达式的值–逻辑值（非"真"即"假"）。
 由于Ｃ语言没有逻辑型数据，所以用整数"１"表示"逻辑真"，用整数"０"表示"逻辑假"。
 例如，假设num1=3，num2=4，num3=5，则：
 （1）num1>num2的值=0。
 （2）(num1>num2)!=num3的值=1。
 （3）num1<num2<num3的值=1。
 思考题：任意改变num1或num2的值，会影响整个表达式的值吗？为什么？
 （4）(num1<num2)+num3的值=6，因为num1<num2的值=1，1+5=6。
 再次强调：C语言用整数"1"表示"逻辑真"，用整数"0"表示"逻辑假"。所以，关系表达式的值，还可以参与其它种类的运算，例如算术运算、逻辑运算等。

由赋值运算符或复合赋值运算符，将一个变量和一个表达式连接起来的表达式，称为赋值表达式。
 （1）一般格式
 变量 （复合）赋值运算符 表达式
 （2）赋值表达式的值
 任何一个表达式都有一个值，赋值表达式也不例外。被赋值变量的值，就是赋值表达式的值。
 例如，"a = 5"这个赋值表达式，变量a的值"５"就是它的值。

逗号表达式
 
逗号表达式:就是用逗号隔开的多个表达式，从左向右依次执行
exp1,exp2,wxp3,......wxpn
 
注意：整个表达式的结果是最后一个表达式的结果。
 
void test()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, b = a + 1);
	//可知最后一个表达式的结果，就是整个表达式的结果。
	//那么从左到右依次计算就会得到c = 13;
	
}
 
下表引用、函数调用和结构成员
 
1. [ ]:下表引用符操作符
 
操作数 : 一个数组名 + 以后索引值
int arr[10];
arr[9] = 10;
[ ]:有两个操作数一个是arr，另外一个就是9.
注意:下表引用常用与数组的遍历修改
 
2.( )：函数调用操作符
 
操作数 : 一个函数名 + [若干传递给函数的参数] 
#include<stdio.h>
void test()
{
	printf("hehe\n");
}

void test2(const char* str)
{
	printf("%s\n",str);
}

int main()
{
	test();
	test2("hello worl");
	return 0;
}
 
3.访问一个结构体成员
 
. :结构体.成员名
-> :结构体指针->成员名

#include<stdio.h>
struct stu{
	char name[20];
	int age;
};
void test(struct stu stu)
{
	stu.age = 18;
}

void test2(struct stu * pstu)
{
	pstu->age = 18;
}

itn main()
{
	struct stu stu;
	struct stu* pstu = &stu;
	
	stu.age = 10;
	test(stu);
	
	pstu->age = 20;
	test2(pstu);
	return 0;
}
 
表达式求值
 
众所周知表达式的求值，一部分有操作符的优先级和结合性决定，但是还有一部分在求职的过程中需要进行类型转换才能够进行计算。
 隐式类型转换：
 关于隐式类型转换，是指发生在没有明确说明的情况下（C语言风格的强制类型转换就是属于我们程序员有明确说明的），编译器自动帮我们执行的类型转换。通常同类型的数据进行运算、比较和赋值的时候我们是不需要担心的，这里我只是说明不同类型的数据进行运算、比较和赋值时，且我们程序员没有指定类型转换时，编译器是如何帮我们进行处理类型之间的转换的，只有知道这个过程，才能让我们知道程序设计时应该注意和避免的地方。
 
（1）比int类型小的隐式类型转换：整型提升（Integer Promotion）。
 
C语言的整形算术运算总是以缺省整形的精度来进行的，为了获得这个精度那么，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升
 
（2） 为什么要整型提升（Integer Promotion）？
 
我们知道表达式的整形运算要在CPU的相应的运算器件中完成，而这个期间就是逻辑运算单元(ALU)我们也叫做整形运算器，ALU的操作数长度就是int的字节长度一也就是32个比特位，同时也就是cpu通用寄存器的长度。那么此时如果我们要就是计算两个char类型的相加，而CPU中执的标椎长度是32位，但是char只有8位，如果要进行计算就要先报char类型变成32位然后通过寄存器送入ALU进行计算。因此，表达式中比int类型小的类型就要先转换成int或unsigned int类型，才能计算。而这个转换过程也就是整形提升，这也是整形提升存在的意义；；；；
 
（3）如何进行整形提升
 
整形提升是按照变量的数据类型的符号位来提升的
 
//负数的提升
char c1 = -1;变量c1的二进制位(补码)中只有8个
比特位:11111111
因为char为有符号的char,所以整形提升时，高位补
符号位，
提升之后:11111111111111111111111111111111


//正数的整形提升
char c2 = 1;变量c1的二进制位(补码)中只有8个
比特位:00000001
因为char为有符号的char,所以整形提升时，高位补
符号位，
提升之后:00000000000000000000000000000001

//无符号整形提升，，/*高位补0*/就OK了


//栗子
void test()
{
	char c = 1;
	printf("%u\n", sizeof(c));//输出1
	printf("%u\n", sizeof(+c));//输出4
	printf("%u\n", sizeof(!c));//输出1
}
//只要c参加表达式运算就会发生整形提升，所以+c就会发送提升，所以输出4，而其他没有发生表达式运算
 
（4）赋值时的隐式类型转换
 
上面说到都是在计算式的隐式类型转换，但是还要特别说明的就是在进行赋值操作时，赋值运算符右边的数据类型必须转换成赋值号左边的类型，若右边的数据类型的长度大于左边，则要进行截断或舍入操作。
 
char ch;
int i,result;
float f;
double d;
result = ch/i + (f*d-i);

(1)首先计算 ch/i,ch → int型，ch/i → int型。

(2)接着计算 f*d-i，由于最长型为double型，故f→double型，i→double型，f*d-i→double型。

(3)(ch/i) 和(f*d-i)进行加运算，由于f*d-i为double型，故ch/i→double型，ch/i+(f*d-i)→double型。

(4)由于result为int型，故ch/i+(f*d-i)→double→int，即进行截断与舍入，最后取值为整型