操作符详解（二）

前言：

上一篇讲了操作符详解（一）http://t.csdnimg.cn/C3LX4，这期继续讲解剩余的操作符。

操作符的分类

算术操作符： + - * / %

移位操作符: >> <<

位操作符: & | ^ ~

赋值操作符: = += -= *= /= %= <<= >>= &= |= ^=

单⽬操作符：! ++ -- & * + - ~ sizeof 、 ( 类型 )

关系操作符: > >= < <= == !=

逻辑操作符： && ||

条件操作符：? :

逗号表达式： ,

下标引⽤： []

函数调⽤： ()

结构成员访问： . -> ————————————————

赋值操作符: = += -= *= /= %= <<= >>= &= |= ^= 单⽬操作符：! ++ -- & * sizeof 、 ( 类型 ) 关系操作符: > >= < <= == != 条件操作符：? : 函数调⽤： () 结构成员访问： . ->

1.0 赋值操作符

1.1 =

常见的用法：变量=表达式

	int a = 100;//初始化
	a = 20;//赋值，这里使用的就是赋值操作符

什么是初始化？什么又是赋值？

在创建变量后给一个值，这就是初始化，在创建变量好后，再给一值这叫做赋值。

1.1.1 连续赋值

赋值操作符也可以

	int a = 3;
	int b = 4;
	int c = 6;
	a = c = a + b

赋值从到右一次进行，虽然C语言支持这样赋值，但是这并不利于我们的观察，最好将其拆开来。

	int a = 3;
	int b = 4;
	int c = 6;
    c = a + b
    a = c

这样的代码方便我们理解和调试。

1.2 += -= *= /= %= <<= >>= &= |= ^=

以上都是赋值复合运算符，什么是赋值复合运算符？

复合赋值操作符是一种简化变量赋值操作符的特色符号，在赋值符“=”之前加上其它二目操作符可构成复合赋值操作符。

我们直接上代码演示：

	int x = 4;
	x += 3;//x = x + 3
	int y = 10;
	y -= 2;//y = y - 2
	int z = 4;
	z *= 2;//z = z * 2
	float a = 6;
	a /= 2;// a = a / 2
	int b = 15;
	b %= 4;//b = b % 4
	int c = 16;
	c <<= 2;//c = c << 2
	int d = 8;
	d >>= 1;//d = d >> 1
	int e = 15;
	e &= 8;//e = e & 8
	int f = 2;
	f |= 3;//f = f | 3
	int g = 9;
	g ^= 5;//g = g ^ 5

最后输出结果

x = 7 y = 8 z = 8 a = 0 b = 3 c = 64 d = 4 e = 8 f = 3 g = 12

复合赋值操作符，能简化表达式；提高代码的可读性，更加简洁易读；自动类型转换，减少代码中的错误。

2.0 单目操作符

2.1 !（逻辑取反运算操作符）

不仅是是单目操作符还是逻辑操作符，上一篇已经讲过了，这里就不重复了。

2.2 ++ --

++是⼀种⾃增的操作符，⼜分为前置++和后置++，--是⼀种⾃减的操作符，也分为前置--和后置--.

2.2.1++

2.2.1.1 前置++

前置++就是，++在变量的前面。

口诀：先+1，后使用。

int main()
{
	int a = 3;
	int b = ++a;
	printf("%d %d",b, a);
	return 0;
}

a=3,b的值是a先+1再将其赋值给b,所以a=4,b=4。

2.2.1.2 后置++

后置++顾名思义，就是++在变量后面。

口诀：先使用，后+1。

int main()
{
	int a = 3;
	int b = a++;
	printf("%d %d",b, a);
	return 0;
}

a=3,b要初始化，先将a的值赋值给b，后a在进行+1，所以a=4，b=3。

2.2.2 --

2.2.2.1 前置--

前置--的用法跟前置++的用法是一样的，只是一个是+一个是-

口诀：先-1，后使用

int main()
{
	int a = 3;
	int b = a--;
	printf("%d %d",b, a);
	return 0;
}

看懂了前置++后置--也是一样的，只需要吧+换成-。

2.2.2.2 后置--

同理后置--类似于后置++，只是把加⼀换成了减⼀

⼝诀：先使⽤，后-1

int main()
{
	int a = 3;
	int b = --a;
	printf("%d %d",b, a);
	return 0;
}

2.2.3 sizeof

sizeof既是操作符，也是关键字，专门用来计算类型的长度。

sizeof 操作符的操作数可以是类型，也可是变量或者表达式。

对应的printf()占位符分别是%u、%lu、%llu。

int main()
{
	printf("%zd\n", sizeof(char));
	printf("%zd\n", sizeof(_Bool));
	printf("%zd\n", sizeof(short));
	printf("%zd\n", sizeof(int));
	printf("%zd\n", sizeof(long));
	printf("%zd\n", sizeof(long long));
	printf("%zd\n", sizeof(float));
	printf("%zd\n", sizeof(double));
	printf("%zd\n", sizeof(long double));
	return 0;
}

输出结果 1 1 2 4 4 8 4 8 8

2.2.4 强制类型转换

强制类型转换是把变量从一种类型转换为另一种数据类型。

float a = 3.14;
int b = (int) a;

以上代码是，浮点数转化为整数。

强制类型转换可能会导致数据的丢失或错误的结果。所以，我们需要谨慎使用强制类型转换。

3.0 关系操作符

4.0 条件操作符

条件操作符也叫三目操作符，作用是根据条件来选择执行不同的操作，从而实现更复杂的的控制逻辑。

condition ？expression1 ： expression2 如果condition为真（非零），则执行expression1并返回其值； 如果condition为假（零），则执行expression2并返回其值。

看下列代码

int main()
{
	int a = 5;
	int ret = 0;
	if (a > 3)
		ret = 10;
	else
		ret = 5;
	return 0;
}

如果将上面代码，用条件操作符实现应该怎么做呢？

int main()
{
	int a = 5;
	int ret = (a > 3) ? 10 : 5;
}

5.0 函数调⽤

函数的调用比较简单，我们写个代码就明白了。

int Add(int a ,int b)
{
	return a + b;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", a, b);
	int ret = Add(a,b);
	pritnf("%d", ret);
	return 0;
}

以上代码Add()就是属于函数的调用。

6.0 结构成员访问

6.1 结构体的定义和初始化

C语言已经提供了很多的内置类型，但这些内置类型还不以满足我们的需求。为了解决这一问题C语言提供了结构题自定义的数据类型，让程序员可以自己创造适合的类型。

struct tag {
    member-list
    member-list
    member-list  
    ...
} variable-list ;

tag 是结构体标签。

member-list 是标准的变量定义。

variable-list 结构变量。

//代码1
struct num
{
	int x;
	int y;
}p1;//声明类型的同时定义p1

struct num p2;//定义结构体变量2

6.1.1 结构成员访问操作符

6.1.1. 1 结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。

方式：结构体变量 .成员名

struct people 
{
	int age;
	char name[20];
}p1 = { 20,{"zhangsan"}};

int main()
{
	printf("%d %s", p1.age, p1.name);
	return 0;
}

6.1.1.2 结构体成员的间接访问

有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。

⽅式：结构体指针->成员名

struct Point
{
	int x;
	int y;
};
int main()
{
	struct Point p = { 3, 4 };
	struct Point* ptr = &p;
	ptr->x = 10;
	ptr->y = 20;
	printf("x = %d y = %d\n", ptr->x, ptr->y);
	return 0;
}