目录
创新互联为企业级客户提高一站式互联网+设计服务，主要包括成都网站制作、做网站、
App定制开发、
重庆小程序开发公司、宣传片制作、LOGO设计等，帮助客户快速提升营销能力和企业形象，创新互联各部门都有经验丰富的经验，可以确保每一个作品的质量和创作周期，同时每年都有很多新员工加入，为我们带来大量新的创意。
零. 前言
一. 算术操作符
1. 加法 +
2. 减法 -
3. 乘法 *
4. 除法 /
5. 取模 %
总结
二. 移位操作符
1. 左移操作符<<
2. 右移操作符 >>
总结
三. 位操作符
1. 按位与 &
2. 按位或 |
3. 按位异或 ^
四. 赋值操作符 =
五. 单目操作符
1. 逻辑反操作符 !
2. 负值操作符 -
3. 正值操作符 +
3. 取地址操作符 &
4. 解引用操作符 *
5. 类型长度操作符 sizeof
6. 按位取反操作符 ~
7. 前置/后置 ++ --
8. 强制类型转换 (数据类型)
六. 关系操作符
七. 逻辑操作符
1. 逻辑与 &&
2. 逻辑或 ||
八. 逗号表达式
九. 下标引用, 函数调用及成员访问符
1. 下标引用操作符 [ ]
2. 函数调用操作符 ( )
3. 结构体成员访问操作符 . ->
十. 三目操作符(条件操作符)
零. 前言
C语言中有很多数据类型, 通过这些数据类型可以像日常生活中那样存储数据了. 日常生活中除了要存储数据, 还需要对数据进行计算, 就像去超市购买商品进行价格的计算, 通过今天是星期几来判断还有几天到周末. 离春节还有几个星期, 几个月等等...... 当然C语言中也可以对数据进行计算, 这就必须先了解C语言所包含的种种操作符.
在C语言中, 按照操作数的个数可以分为三种, 单目操作符, 双目操作符和三目操作符. 单目操作符的意思就是这个操作符只有一个操作数, 双目操作符有两个操作数, 三目操作符有三个操作数.
还可以通过操作符运算的逻辑分为以下这10种, 接下来我会详细介绍他们的用法和注意事项.
一. 算术操作符
加法: +
减法: -
乘法: *
除法: /
取模/取余: %
在我们日常生活中, 最常见的运算就是加减乘除四则运算符, 可能对于 取模/取余% 操作符比较陌生, 没关系, 下文我会详细讲解.
1. 加法 +
加法+很容易理解, 就是两个数相加, 在C语言中可以进行加法运算:
int a = 10;
a + 10;
printf("a = %d\n", a);
// 结果:a = 10
变量a的结果为什么是10呢, 明明已经对变量a进行了加法操作. 那是因为在C语言中, a+10 这个表达式的值确实是20, 但是这个表达式的值并没有通过 赋值操作符= 赋给变量a, 所以 变量a 的值还是10.
如果需要将a的值更改为20, 上文说过需要使用 赋值操作符= 将表达式 a+10 的值赋给 变量a, 或者使用 赋值操作符= 直接将 变量a 更改为 20即可. 赋值操作符= 在下文也有详细的讲解.
// 需求:将a的值更改为20
int a = 10;
a = a + 10;
printf("a = %d\n", a);
// 结果: a = 20
详细解剖
2. 减法 -
其实加减乘除四则运算的使用方法都是一样的, 本文中就不再过多的赘述了(｀∇´)
int a = 10;
int b = 20;
int ret = b - a;
printf("ret = %d\n", ret);
// 结果:ret = 10
ret = a - b;
printf("ret = %d\n", ret);
// 结果:ret = -10
3. 乘法 *
int a = 0;
int b = 2;
int c = 3;
printf("%d\n", a * a); // 结果:0
printf("%d\n", a * b); // 结果:0
printf("%d\n", b * c); // 结果:6
和数学乘法运算一样, 零乘以任何数的结果都为零.
4. 除法 /
int a = 5;
int b = 2;
int ret = a / b;
printf("ret = %d\n", ret);
// 结果:ret = 2
按照数学逻辑来讲, 5除上2的值不应该是2.5吗? 那是因为在C语言中, 如果 除法/ 操作符左右两个操作数的类型都是整型进行的就是整数除法, 整数除法会舍弃小数位, 而且不会进行四舍五入, 计算的结果永远是整数.
那我将输出格式符更改为%f以浮点类型输出总可以了吧 ☆▽☆
int a = 5;
int b = 2;
int ret = a / b;
printf("ret = %f\n", ret);
// 结果:ret = 0.000000
结果输出了0.000000, 所以当然不行啦, 因为整数和小数在计算机内存中存储方式都不同, 整数除法的结果为整型, 整型以浮点型格式进行输出肯定是不行的, 编译器也会发出如下警告:
那我强制类型转换总可以了吧:
int a = 5;
int b = 2;
int ret = a / b;
printf("ret = %f\n", (float)ret);
// 结果:ret = 2.000000
强制类型转换虽然可以, 但是这种方法很粗暴, 而且不建议经常使用强制类型转换, 因为两个数据的类型本来就不同, 如果进行强制类型转换的话, 可能会发生精度的丢失. 虽然现在并没有感觉到精度的丢失. 当进行更加复杂的计算时, 自然会发生, 所以应该少量的使用强制类型转换, 养成良好的编程习惯.
这里有一个简单的方法, 就是 除法/ 操作符左右的两个操作数有一个或两个为小数(浮点型)计算结果都是浮点型.
int a = 5;
float b = 2.0f; // 将变量b的类型更改为float类型
float ret = a / b;
printf("ret = %f\n", ret);
// 结果:ret = 2.500000
将其中任意一个变量类型更改为浮点类型, 还需将存放a/b结果的 变量ret 类型更改为浮点类型.
这样, 精度就不会丢失了, 由于计算机存储数据只能由二进制来存储, 所以浮点类型在内存中存放会有很细微的误差. 浮点类型是如何在内存中存放的我会在之后的文章中进行详细的讲解, 这里我们主要的目标是讲解C语言中的操作符, 切勿跑题了.
可以发现, float浮点型变量打印的时候会默认在小数点后面打印6个0, 然而double浮点型变量在打印的时候小数点后也是6个0.
5. 取模 %
取模操作符, 表达式结果为整数相除之后的余数, 切记取模操作符的两个操作数必须为整数.
printf("%d\n", 5%2); // 结果:1
printf("%d\n", 6%2); // 结果:0
printf("%d\n", -5%2); // 结果:-1
printf("%d\n", 5%-2); // 结果:1
printf("%d\n", -5%-2); // 结果:-1
通过结果可以发现, 左操作数的正负号影响取模结果的正负号.
总结
1. 除了 取模操作符%, 其他操作符都可用于整数和浮点数;
2. 除法/ 操作符左右操作数为整数时, 进行的是正数除法, 计算结果为整数, 舍弃小数位, 不进行四舍五入. 左右操作数有一个或两个时进行的都是小数除法, 结果为小数;
3. 由于计算机内存是通过二进制来存放数据的, 然而在存放浮点数的时候, 会存在一定的精度丢失;
4. 取模操作符% 的两个操作数必须为整数, 且左操作数的正负号影响取模结果的正负号.
二. 移位操作符
<< 二进制位左移操作符
>>二进制位右移操作符
在讲解移位操作符之前, 先要了解数据是如何在内存中存储的. 例如x86(32位)系统举例吧, 32位操作系统中有32根地址线, 一根地址线所能表示形式为真或假(1/0), 即通电或不用电. 通过1/0能够组成2^32种表达形式.
一个 整型int 在x86系统中占用4个字节的空间, 1个字节(Byte)等于8个比特位(bit), 所以一个int类型写成一个由32个二进制位组成的数列:
这里只是简单了解int类型变量是如何在内存中存放的. 既然了解了一个数是如何在内存中存放的, 就可以知道 移位操作符其实就是对一个数的二进制位来进行操作, 接下来就开始介绍两个移位操作符:
1. 左移操作符<<
语法格式:
int a = 1;
int ret = a<< 1;
printf("ret = %d\n", ret);
结果:ret = 2
移位规则:
二进制位左侧丢弃, 右侧补0
剖析代码:
左操作数是负数的情况下, 同样左侧丢弃, 右侧补0. 而且操作数都不能为小数, 右操作数不能是负数.
通过代码可以看出来, 其实左移操作就是对左操作数进行 乘2 的操作.
2. 右移操作符 >>
语法格式:
int a = 4;
int ret = a >>1;
printf("ret = %d\n", ret);
// 结果:ret = 2
通过代码可以看出, 右移操作其实就是对左操作数进行 除2 的操作.
移位规则:
首先, 因为编译器的不同, 移位运算共分为两种:
1. 逻辑右移: 左边用0填充, 右边丢弃
2. 算术右移: 左边用符号位填充, 右边丢弃
如下图:
现在大多数编译器都是算术右移, 即左边补符号位, 右侧丢弃.
总结
1. 移位操作表达式的左操作数必须是整数;
2. 右操作数不能为负数, 标准中未定义这种写法;
3. 左移运算: 左侧丢弃, 右侧补0;
4. 右移运算: 右侧丢弃, 左侧补符号位.
三. 位操作符
& 按位与
| 按位或
^ 按位异或
位操作符也是对整数的二进制位进行操作, 这三个操作符的操作大逻辑致相同:
1. 按位与 &
语法规定:
对两个操作数进行按位与, 二进制相等则为1, 不同为0.
a : 00000000 00000000 00111000 10001010
&
b : 00000000 00000000 10110111 00010111
=
r : 00000000 00000000 00110000 00001010
语法格式:
int a = 3;
int b = 2;
int ret = a & b;
printf("ret = %d\n", ret);
// 结果:ret = 2
// a:00000000 00000000 00000000 00000011 = 3
// b:00000000 00000000 00000000 00000010 = 2
// r:00000000 00000000 00000000 00000010 = 2
2. 按位或 |
语法规定
对两个操作数进行 按位或 运算, 二进制位有一个1则为1, 都是0则为0.
a : 00000000 00000000 00111000 10001010
|
b : 00000000 00000000 10110111 00010111
=
r : 00000000 00000000 10111111 10011111
语法格式
int a = 3;
int b = 4;
int ret = a | b;
printf("ret = %d\n", ret);
// 结果:ret = 7;
// a:00000000 00000000 00000000 00000011 = 3
// b:00000000 00000000 00000000 00000100 = 4
// r:00000000 00000000 00000000 00000111 = 7
3. 按位异或 ^
语法规定
对两个操作数进行 按位异或 运算, 二进制位相异为1, 相同为0.
a : 00000000 00000000 00111000 10001010
|
b : 00000000 00000000 10110111 00010111
=
r : 00000000 00000000 10001111 11111101
语法格式
int a = 31;
int b = 24;
int ret = a ^ b;
printf("ret = %d\n", ret);
// 结果:ret = 7;
// a:00000000 00000000 00000000 00011111 = 31
// b:00000000 00000000 00000000 00011000 = 24
// r:00000000 00000000 00000000 00000111 = 7
四. 赋值操作符 =
C语言中的 赋值操作符= 和数学中的 等于号= 书写格式是一样的, 但是C语言和数学中的含义却完全不同, 在数学中表达的可能是表示两个数相等, 而C语言中是将一个值赋给一个变量. 正因如此, 在日常编程中, 会犯这种小错误. 例如本来是比较两个值的是否相等, 符号却写成了 单等于号=, 这样表达式的结果就变成了赋值的值.
语法格式
int num = 10; // 这里的等号是给num变量初始化(赋初值)
num = 20; // 这里的等号是更改num的值, 用常量20覆盖原来的10
num = 10 + 20; // 右值也可以是表达式
赋值操作符也可以连续使用
int a = 10;
int b, c, d, e; // 连续定义整型int变量
a = b = c = d = e = 9; // 连续赋值
但是这种的代码风格不清晰, 这是一种不良的编程习惯, 不推荐使用. 如下代码就是比较好的代码风格, 这样的代码比较清晰, 一眼能看出每个变量的值是多少.
int a = 10;
int b = 9;
int c = 9;
int d = 9;
int e = 9;
有时候我们需要对当前变量进行运算:
int a = 10;
a = a + 10;
printf("%d\n", a);
语句2 是将 表达式 a+10 的值赋给a, 也就是给a加上一个10, 但是C语言有一个更加方便易懂的操作符, 就是复合赋值符:
+=
-=
*=
/=
%=
>>=<<=
&=
|=
^=
根据上面罗列的符合操作符, 我们可以将语句2写成如下样式
int a = 10;
a += 10; // 拆分: a = a + 10
其他的复合赋值符用法和上方一样, 这样去编写, 能够让代码看起来更加清晰, 易懂.
五. 单目操作符
! 逻辑反操作符
- 负值操作符
+ 正值操作符
& 取地址操作符
sizeof 操作数的类型长度（单位:Byte）
~ 对一个数的二进制按位取反
-- 前置/后置--
++ 前置/后置++
* 解引用操作符
(数据类型) 强制类型转换
1. 逻辑反操作符 !
在我们编写代码的时候, 经常会使用到判断和循环语句, 在C语言中0表示假, 非0表示真, 而这里的逻辑反操作符的作用就是将假转换为真, 真转换为假.
语法格式
int score = 0;
if (!score)
{
printf("分数为0, 该挨打了!\n");
}
这条语句的意思就是, 如果你考了0分你就该挨打了, 但是在C语言中, 0代表的是假, 然而并不会执行if语句中的语句, 但是我们使用了逻辑反操作符, 将这个表达式的值转变成了真(默认1).
2. 负值操作符 -
注意, 这里的负号和双目操作符的负号不一样, 这个是单目操作符-, 虽然它们长得一样, 但是用途却完全不一样, 这里的-号是代表这个数为负数, 也可以将一个数变为负数:
int a = 10;
a = -a;
printf("a = %d\n", a);
// 结果: -10
-a表达式的结果为-10, 并没有真的将a的值更改为-10, 需要通过赋值操作符= 将-a表达式的值赋值给变量a, 这样a变量的值就变成了-10.
3. 正值操作符 +
正值操作符在代码编写的过程中基本上不会使用到, 因为不能将一个负数更改为整数, 和数学中一样.
int a = -10;
a = +a;
printf("a = %d\n", a);
// 结果: -10
这样是行不通的, 单目操作符的+号只能表示一个数为正数
int a = +10;
但是这样编写代码就大可不必了, 因为不写这个正号编译器默认也会把这个常量值识别为正数, 或者本就隐藏了这个正号+.
3. 取地址操作符 &
在C语言中, 创建一个变量首先需要在内存中开辟一块内存空间, 然后使用取地址操作符就可以将该变量的地址取出来, 这个表达式的结果就是该变量的地址, 所以可以通过printf( )函数来打印一个变量的地址
int num = 10;
printf("num = %p\n", &num); // %p是打印地址的格式化字符
// 打印出来的是十六进制数
如果可以将num变量的地址打印出来, 那能不能将num变量的地址存储起来呢? 当然是可以的. 一个整数需要存储的话, 需要整型变量来存储, 那整型变量的地址需要什么来存储呢? 需要使用指针变量, 也就是整型指针变量.
语法格式
int num = 10;
int* p_num = #
*p_num中的这个*号代表 p_num 是一个指针变量,
而int代表p_num指针变量所指向的类型为int类型
然后通过取地址操作符将num的地址取出来再赋给整型指针变量p_num
既然存储了num变量的地址, 那么这个指针变量该如何使用呢? 接下来我会讲解解引用操作符, &和* 这两个操作符之间是紧密相关的.
4. 解引用操作符 *
双目操作符*的作用是将两个数相乘, 然而在单目操作符中, 指针变量可以通过*号访问到地址所指向的那块内存地址(也就是这块地址所存储的内容)
语法格式
int num = 10;
int* p_num = #
*p_num = 20;
printf("num = %d\n", num);
// 结果: 20
printf("*p_num = %d\n", *p_num);
// 结果: 20
可以发现, num变量本来存储的是10, 然后p_num指针变量通过地址解引用将这块地址所存储的数值更改为了20, 所以打印变量num也是20. 这就是解引用操作符的用处, 这里只讲解引用操作符的用处, 关于指针更详细的内容我会在以后的文章中详细讲解.
5. 类型长度操作符 sizeof
在刚接触C语言的使用, 使用sizeof操作符的时, 总会以为sizeof是一个函数, 因为它实在是太像一个函数了, 会见到这样写的 sizeof(value), 这也难怪会有人将sizeof理解为一个函数, 然而我也不例外. 但是它的操作数是变量/常量的时候, 它是可以不用加括号的, 但是操作数为类型关键字的时候, 就必须要加上括号了. 所以证明这个操作符不是一个函数.
这个操作符的用处就是计算出类型, 变量, 值所在内存中所占的内存大小, 它在编译期间就能够计算出表达式的值.
// 基本数据类型
printf("%u\n", sizeof(short)); // 结果:2
printf("%u\n", sizeof(int)); // 结果: 4
printf("%u\n", sizeof(long)); // 结果: 4
printf("%u\n", sizeof(long long)); // 结果: 8
printf("%u\n", sizeof(float)); // 结果: 4
printf("%u\n", sizeof(double)); // 结果: 8
// 指针类型
printf("%u\n", sizeof(short*)); // 结果:4
printf("%u\n", sizeof(int*)); // 结果: 4
printf("%u\n", sizeof(long*)); // 结果: 4
printf("%u\n", sizeof(long long*)); // 结果: 4
printf("%u\n", sizeof(float*)); // 结果: 4
printf("%u\n", sizeof(double*)); // 结果: 4
可以看到, 使用sizeof操作符可以打印变量在内存中所站字节, 但是这里的指针类型不论是short还是int都是4个字节呢, 那是因为指针变量所存储的只是地址, 而非这个地址的值, 所以不需要很大的值, 所以就统一将指针变量的值设置为4个字节.
还需要注意的就是sizeof表达式的结果为无符号类型的, 也就是没有负数, 不可能一个数存放在内存中占用了负几的空间吧.
6. 按位取反操作符 ~
这个操作符也是对一个数的二进制位进行操作的, 对一个数的二进制位进行按位取反, 1为0, 0为1
语法格式
int a = 10;
a = ~a;
// ~ 00000000 00000000 00000000 00001010
// 11111111 11111111 11111111 11110101
7. 前置/后置 ++ --
这里的前置/后置++和前面的复合运算符有着异曲同工之处, 也是为了语法更加的整洁, 易书写. 例如我们需要对num变量＋1的操作时, 有可能需要这样写:
int num = 10;
num += 1; // 或者 num = num + 1;
这样写也可以, 但是有一种更加简单易懂方式, 那就是使用++操作符
int num = 10;
num++; // 剖析: num++ 可以理解为 num = num + 1;
但是要注意的是, 这里前置++和后置++是由区别的, 前置++是先进行+1, 然后在使用, 然而后置++是先使用变量的值, 等到这条语句结束后(分号结尾为一个语句), 这个变量才+1, 所以在使用的时候一定要区别开来.
代码1:
int num = 10;
printf("num = %d\n", num++); // 结果: num = 10 因为先使用值后+1
printf("num = %d\n", num); // 结果: num = 11 因为num已经通过++ +1为11
代码2:
int num = 20;
printf("num = %d\n", ++num); // 结果: num = 21; 因为先+1后使用
8. 强制类型转换 (数据类型)
强制类型转换, 可以将一个数的类型强制转换成另一个类型, 例如下面的代码, 我们需要将浮点型13.14的值赋值给整型变量num的时候, 编译器就会发出警告,直接将浮点类型常量赋值给整型变量可能会发生数据丢失的问题.
int num = 3.14;
然而就需要使用强制类型转换将3.14这个浮点型常量强制转换为int类型的常量在再赋值给num整型变量
int num = (int)3.14;
这样, 编译器就不会发出警告了, 这只是介绍了强制类型转化的用法, 在实际代码编写的时候还有其他的用法, 但是不建议使用强制类型转换, 因为总会发生数据丢失的.
六. 关系操作符
>大于
>= 大于或等于< 小于<= 小于或等于
!= 不等于
== 等于
这里的关系操作符和数学中语法是一样的, 但是还有几点需要注意:
1. C语言中关系操作符连续使用和数学中要表达的意思不一样, 例如数学中想要表达10到100, 可以写成10<= 100, 但是C语言中可不能这样写, 虽然语法支持, 但是表达的意思会有出入.
[表示10~100的区间]
1.数学:
10<= x<= 100
2.C语言:
x >= 10 && x<= 100
如果非要写成数学中的关系表达式, 可能会和想要表达的意思有一定的出入:
所以, 数学中的逻辑和C语言还是有一定的出入的, 但是大体上的语法还是一致的, 所以这里想要表达的意思是如果num大于等于10并且小于等于100就打印字符串"这样行吗?", 所以说应该写成: (10<= num && num<= 100)就可以了.
2. 数学中表示相等的是一个等于号, 而C语言中表示相等是双等号, 一个等号表示赋值操作. 前面已经说过了, 现在再说一遍;
有时候我们只是想在if中判断一下两个值是否相等, 总是会有犯迷糊的时候嘛, 会将双等号写成一个等号, 导致程序出现问题, 而不好排查, 可以将常量放在操作符的左边.
int num = 0;
if (num = 0) // error
{
printf("num 等于 0\n");
}
if (0 == num) // √
{
printf("num 等于 0\n");
}
这样, 尽管粗心写成了一个等号, 语法上都是错误的, 编译器会报错, 因为不能将一个值赋给一个常量, 这样就能够快速的定义到问题出现的位置了.
七. 逻辑操作符
&& 逻辑与(并且)
|| 逻辑或(或者)
1. 逻辑与 &&
操作符两边的表达式结果都为真(非0)的话, 那么逻辑与表达式的结果为真(1), 如果逻辑与表达式两边的表达式值有一个为假(0), 则整个逻辑与表达式结果为假(0).
2. 逻辑或 ||
操作符两边的表达式结果如果有一个为真(非0), 则整个逻辑或表达式的结果为真(1), 如果都是假(0)则整个逻辑或表达式为假(0). 这里的逻辑与&&优先级要比逻辑或||要高
需要注意的是, 这两个逻辑操作符会发生短路的现象:
八. 逗号表达式
语法格式
int a = (1,2,3,4,5,6,7,8,9,10);
printf("a = %d\n", a);
// 结果: a = 10
变量a的值为10, 原因是逗号表达式是从左往右依次开始执行, 一直执行到最后一个值, 表达式最后一个值为整个表达式的值, 所以a的值为10.
逗号表达式中可以填写表达式和变量等等......
九. 下标引用, 函数调用及成员访问符
[] 下标引用操作符
() 函数调用操作符
. 结构体成员访问符
->结构体指针成员访问符
1. 下标引用操作符 [ ]
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; // 这里的方括号是规定int类型的数组有多少个元素
arr[9] = 11; // 这里数组名通过下标引用操作符[]将下表为9元素的值更改为11
这里需要注意的是, 这就是一个双目操作符, 有两个操作数, 数组名和下标值, 这里的arr[9]也可以写成9[arr], 这是为什么呢? 可以理解成 a == 10 也可以写成 10 == a 一样, 其实应该写成 arr[ ]9 这样的, 但是语法规定要将下标值或者数组名写在方括号中 , 但是不建议写成 9[arr], 虽然语法规定可以这样去写, 但是并没有 arr[9] 这样写看起来直观易懂.
2. 函数调用操作符 ( )
// 自定义: 两数相加(int, int)
int add(int x, int y)
{
return x + y;
}
int main(void)
{
int a = 10;
int b = 20;
printf("%d + %d = %d\n", a, b, add(a, b)); // 对函数名add使用()号来调用add函数
// 结果:10 + 20 = 30
return 0;
}
这里的函数调用符号其实也和下标引用操作符大差不差, 左操作数为函数名, 右操作数为被调函数所需要的参数(需要放在括号中).
3. 结构体成员访问操作符 . ->
语法格式
#include// 学生结构
struct Student
{
char name[20];
int age;
char tel[20];
};
// 打印结构体成员
void print_Student(struct Student* p_stu)
{
printf("name = %s, age = %d, tel = %s\n", p_stu->name, p_stu->age, p_stu->tel);
//printf("name = %s, age = %d, tel = %s\n", (*p_stu).name, (*p_stu).age, (*p_stu).tel);
}
int main(void)
{
struct Student stu1 = {"小红", 16, "123456789"};
struct Student stu2 = {"小明", 17, "123456789"};
printf("name = %s, age = %d, tel = %s\n", stu1.name, stu1.age, stu1.tel);
// 运行结果:name = 小红, age = 16, tel = 123456789
print_Student(&stu2);
// 运行结果:name = 小明, age = 17, tel = 123456789
return 0;
}
结构体变量传参的时候, 被调函数可以将指针解引用再使用.号来访问结构体成员, 要注意的是.号要比*的优先级要高, 所以需要将*p_stu用括号括起来再访问结构体成员.
十. 三目操作符(条件操作符)
条件操作符是C语言中唯一一个三目操作符, 它的语法和if else一样, 如下代码所示:
// 求a和b的大值
int a = 10;
int b = 20;
int max = 0;
if(a >b)
{
max = a;
}
else
{
max = b;
}
可以发现, 上面的代码可以求出a和b的大值, 代码行数过于多, 可以使用条件操作符:
int a = 10;
int b = 20;
int max = a >b : a ? b;
// 如果a大于b, 则整个表达式的值为问号左边的a
// 如果a不大于b,则整个表达式的值为问号右边的b
这样的代码风格是比较好的, 而且也比较清晰易懂, 但是最好不要嵌套使用, 因为一旦嵌套使用就会变得不那么易懂了.
好了, C语言的操作符基本介绍就到此为止了, 当然, 我目前的状态仍是小白一名, 还有很多地方没有讲明白甚至讲错了, 希望大佬们狠狠的批评吧, 也希望能够通过大佬们的指点和批评中吸取经验并逐渐进步.✿✿ヽ(°▽°)ノ✿
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站题目：C语言操作符详解-创新互联
分享链接：
http://cdkjz.cn/article/djgoig.html
