目录
本篇文字继续为大家讲解操作符
思维导图：
1、关系操作符
> >= < <= != ==
关系操作符比较简单，但需要注意的是，在条件判断的时候，可能会出错，例如
错误代码：
int main()
{
int a = 2;
int b = 3;
if (a = b)//if语句里面的判断等于应该是双等号，一个等号是赋值
{
printf("a=b");
}
else
{
printf("a!=b");
}
return 0;
}修正：
int main()
{
int a = 2;
int b = 3;
if (a ==b)//if语句里面的判断等于应该是双等号，一个等号是赋值
{
printf("a=b");
}
else
{
printf("a!=b");
}
return 0;
}对比：
2、逻辑操作符
&& 逻辑与（并且）
|| 逻辑或（或者）
我们上篇文章讲过
& --> 按位与
| --> 按位或
这两类符号不能混淆一起，按位与（按位或）是针对二进制位计算的，而逻辑与（逻辑或）只是判断真假。
&&（按位与）：
int main()
{
int a = 3;//非0为真
int b = 0;//0为假
if (a && b)//有假为假
{
printf("true");
}
else
{
printf("false");
}
return 0;
}
||（按位或）
int main()
{
int a = 3;//非0为真
int b = 0;//0为假
if (a || b)//有真为真
{
printf("true");
}
else
{
printf("false");
}
return 0;
}
对比：
另外还补充一个点，我们来看下面一段代码：
int main()
{
int a = 0;
int b = 2;
int c = 3;
int i = 0;
i = a++ && ++b && c++;
printf("a=%d b=%d c=%d i=%d", a, b, c, i);
return 0;
}按我们正常思路来
a=1 b=2 c=4
但其实不是，我们来看看运行结果
发现和我们想的不一样，其实该表达式在判断的时候，发现前面a = 0，为假，那么后面的就没必要计算了（可以理解为，计算机也会偷懒），所以a++后面的表达式就没有计算了，这一点需要记住。
3、条件操作符
exp1 ? exp2 : exp3
这翻译过来就是：表达式exp1为真的话，那么就执行表达式exp2，否则执行exp3
代码演示：
int main()
{
int a = 10;
int b = 20;
int c = 0;
int d = 0;
if (a > b)
{
c = a;
}
else
{
c = b;
}
d = (a > b) ? a : b;//等价于上面的if-else 表达式
printf("c=%d d=%d", c, d);
return 0;
}输出：
c=20 d=204、逗号表达式
exp1, exp2, exp3,...expN
从左至右依次执行，表达式的结果就是最后一个表达式的结果
int main()
{
int a = 1;
int b = 2;
int c = 3;
c = (a++, a + b, a+c);
printf("a=%d b=%d c=%d", a, b, c);//逗号表达式
return 0;
}
5、下标引用、函数调用和结构成员
5.1 下标引用操作符
[] 下标引用操作符，用于数组
int main()
{
int arr[5] = { 1,2,3,4,5 };
printf("%d", arr[2]);//[] -- 下标引用操作符，操作数是arr 和 2
return 0;
}5.2 函数调用操作符
() 函数调用操作符
操作数为函数名和参数（必须有用函数名，是否有参数根据情况而定）
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
int add(int x, int y)
{
return x + y;
}
void print()
{
printf("hehe");
}
int main()
{
int a = 1;
int b = 2;
int c = add(a, b); //() 函数调用操作符 操作数为add 和 a b
int sz = strlen("qwer");//() 函数调用操作符 操作数为strlen 和 "qwer"
print(); //() 函数调用操作符 操作数为print
return 0;
}5.3 访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
首先我们来了解一下什么是结构体
我们用的char、short、int、long、long long、float、double这些类型，都叫内置类型；
除了这些类型，zaiC语言里面还有自定义类型，顾名思义就是自己定义的类型，这里面就包括结构体
结构体 ——自定义类型（聚合类型）
在生活中有些对象要被描述的话，不能用简单的内置类型描述
比如：
人:性别、姓名、年龄、身高、体重.......
代码演示如下：
struct Human//结构体创建
{
char gender[5];
char name[10];
int age;
int height;
double weight;
};
void print(struct Human* p)
{
printf("性别:%s 姓名:%s 年龄:%d 身高:%d 体重:%.2lf\n", p->gender, p->name, p->age, p->height, p->weight);
//结构体指针->成员名
}
int main()
{
struct Human h1 = { "男","张一三",21,171,65.4 };//初始化
struct Human h2 = { "女","王花花",20,151,45.2 };//初始化
printf("性别:%s 姓名:%s 年龄:%d 身高:%d 体重:%.2lf\n", h1.gender, h1.name, h1.age, h1.height, h1.weight);
printf("性别:%s 姓名:%s 年龄:%d 身高:%d 体重:%.2lf\n", h2.gender, h2.name, h2.age, h2.height, h2.weight);
//结构体变量.成员名
print(&h1);
return 0;
}输出：
性别:男 姓名:张一三 年龄:21 身高:171 体重:65.40
性别:女 姓名:王花花 年龄:20 身高:151 体重:45.20
性别:男 姓名:张一三 年龄:21 身高:171 体重:65.406、表达式求值
我们在前面介绍了那么多的操作符，这些操作符就会放到我们的表达式里面，我们写的任何一个表达式都有可能里面有操作符，这些操作符就会影响我们表达式的计算
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
6.1 隐式类型转换
见名知意，隐式，偷偷的发生类型转换，这个类型转换我们没有感知或者是压根不知道，但实际上是它时刻在发生着。
C语言的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
我们先来看一个例子：
// char short int
// 1byte 2byte 4byte
int main()
{
//char 类型，占1个字节，4个比特位，取值范围为-128~127
char a = 1;
//00000001 - a
//整型提升
//00000000000000000000000000000001
char b = 127;
//01111111 - b
//整型提升
//00000000000000000000000001111111
char c = a + b;//先将a和b转换为整型计算，然后在放入c中
//00000000000000000000000000000001
//00000000000000000000000001111111
//00000000000000000000000010000000
//10000000 - c
printf("%d", c);
//整型提升
//11111111111111111111111110000000(按符号位提升) <-- 补码
//10000000000000000000000010000000 <-- 原码
return 0;
}输出：
-128换一种理解方式：
例题：
int i;//全局变量，如果未初始化，系统默认为0
int main()
{
i--;
if (i > sizeof(i))
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}运行结果：
我们发现输出的内容和我们想象中的不一样，这就是类型提升的效果
6.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换（排名由高到低）。
long double
double
floatunsigned long int
long int
unsigned int
int
int main()
{
int a = 2;
float b = 2.2f;
a + b;
return 0;
}
6.3 操作符的属性
复杂表达式的求值有三个影响的因素。
1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
优先级：
操作符优先级只考虑相邻的两个操作符，这个我们只需大概了解一下。
int main()
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 4;
a = a * b + c * d + e * f;//存在歧义
printf("%d", a);
return 0;
}
这段代码其实就存在了歧义，实际写代码过程中，我们就用括号控制我们想要执行的流程，这样也方面自己观察（好的代码风格）。
a = (a * b) + (c * d) + (e * f);总结：
虽然写了2篇文章为大家介绍了各种操作符的使用以及属性，当我们掌握了这些东西后，也不能确定一个表示的唯一计算路径。所以我们应该考虑好这些东西，然后正确对待我们的操作符，避免写出问题代码，我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
最后，如果本篇文章对大家有帮助，不妨点个赞支持一下，本次分享就到这里。
再见，下机！
1796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
