基础语法
基础概念
编写代码
定义程序的目标、设计程序、编写代码是一个整理，有时，要在不同的步骤之间往复。
用C语言编写程序时，编写的内容被存储在文本文件中，该文件被称为源代码文件。通常以.c拓展名结尾。
编译与链接
C编程的基本策略是，用程序把源代码文件转换为可执行文件（其中包含可直接运行的机器语言代码）。
典型的C实现通过编译和链接两个步骤来完成这一过程。编译器把源代码转换成中间代码，链接器把中间代码和其他代码(启动代码和库代码)合并，生成可执行文件。
-
编译：C使用这种分而治之的方法方便对程序进行模块化，可以独立编译单独的模块，稍后再用链接器合并已编译的模块。通过这种方式，如果只更改某个模块，不必因此重新编译其他模块。
-
链接：另外，链接器还将你编写的程序和预编译的库代码合并。目标文件中存储的是编译器翻译的源代码，这还不是一个完整的程序。链接器的作用是，把你编写的目标代码、系统的标准启动代码和库代码这3部分合并成一个文件，即可执行文件。对于库代码，链接器只会把程序中要用到的库函数代码提取出来
有些系统中，必须分别运行编译程序和链接程序，而在另一些系统中，编译器会自动启动链接器，用户只需给出编译命令即可。
info
这样的设计让一份C的源代码，在不同操作系统上通过对应的编译器编译，即可适配到特定的目标机器指令集上。
即：一次编写，处处编译。
UNIX系统提供的C编译器通常来自一些其他源，然后以cc命令作为编译器的别名。因此，虽然在不同的系统中会调用不同的编译器，但用户仍可以继续使用相同的命令。
编译inform.c，要输入以下命令： cc inform.c 等价于：gcc inform.c
inform.c
#include <stdio.h>
int main(void)
{
printf("C 语言程序的源代码文件以 .c 作为后缀。\n");
return 0;
}
如果使用ls命令列出文件，会发现有一个a.out文件。该文件是包含已翻译（或已编译）程序的可执行文件。
要运行该文件，只需输入：a.out
tip
a.out 的全称是 Assembler Output（汇编器输出）。 在 Unix 系统的极早期阶段（大约 1971 年左右），由于当时的汇编器和链接器非常简单，它们并不需要用户去思考如何命名输出文件，所以开发者直接将其硬编码为 a.out。
早期的计算机内存和磁盘空间极其珍贵。如果汇编器每次都问你“你想把文件存成什么名字？”，不仅程序代码会变复杂，操作起来也麻烦。
系统默认你每次编译都是为了测试当前的代码。如果你编译了程序 A 生成 a.out，测试完后再编译程序 B，它会自动覆盖掉原来的 a.out。这样你就不必手动删除旧的二进制文件，磁盘空间也不会被各种名字的测试文件塞满。
如果要存储可执行文件（a.out），应该把它重命名。否则，该文件会被下一次编译程序时生成的新a.out文件替换。
随着 Unix 的发展，虽然出现了更先进、支持动态链接的格式（如现在 Linux 通用的 ELF 格式），但编译器（如 GCC）为了保持向后兼容性和历史传统，依然将默认的输出文件名保留为 a.out。
info
在该例中，目标代码文件是inform.o。然而，却找不到这个文件，因为一旦链接器生成了完整的可执行程序，就会将其删除。
如果原始 程序有多个源代码文件，则保留目标代码文件。学到后面多文件程序时，你会明白到这样做的好处。
main函数
一个 C 语言程序有且只有一个main函数，程序运行时系统会自动调用。
如果一个程序没有main函数，则这个程序不具备运行能力。如果一个程序有多个main函数，则编译时会报错。
函数定义格式
- main函数定义的格式:
int代表函数执行之后会返回一个整数类型的值main代表这个函数的名字叫做 main()代表这是一个函数{}代表这个程序段的范围（花括号还可用于把函数中的多条语句合并为一个单元或块。）return 0;代表函数执行完之后返回整数 0
test.c
// test.c是完整的文件名
// 其中test是文件名
// .c 是C语言的文件拓展名。
int main() {
// insert code here...
return 0;
}
info
- C 语言中,每条完整的语句后面都必须以英文分号结尾
- main 函数前面的 int 可以不写或换成 void
- 养成在main()函数中保留return语句的好习惯。因为main 函数中的 return 0 可以不写。
- 其它函数定义的格式
int代表函数执行之后会返回一个整数类型的值call代表这个函数的名字叫做 call()代表这是一个函数{}代表这个程序段的范围return 0;代表函数执行完之后返回整数 0
int call() {
return 0;
}
info
无论main()在程序文件中处于什么位置，所有的C程序都从main()开始执行。
main函数会由系统自动调用, 其它函数需要开发者在 main 函数中手动调用。
但是，C的惯例是把main()放在开头，因为它提供了程序的基本框架。
two_func.c
/* two_func.c -- 一个文件中包含两个函数 */
#include <stdio.h>
// 第1个void表明，butler()函数没有返回值
// 第2个void（butler(void)中的void）的意思是butler()函数不带参数
void butler(void); /* ANSI/ISO C函数原型 */
int main(void)
{
printf("肚子饿了，我给外卖小哥打个电话。\n");
butler();
printf("真香！吃饱了继续写代码。\n");
return 0;
}
void butler(void) /* 函数定义开始 */
{
printf("外卖小哥：同学你好，你的螺蛳粉到了，请下楼取餐！\n");
}
butler()函数在程序中出现了3次。
- 第1次是函数原型（prototype），告知编译器在程序中要使用该函数；
- 第2次以函数调用（functioncall）的形式出现在main()中；
- 最后一次出现在函数定义（functiondefinition）中，函数定义即是函数本身的源代码。
butler 是经典的英式家庭男管家的首领,相比于起名叫 func1() 这种冷冰冰的名字，叫 butler() 能让初学者感受到：函数就是一个帮你办事儿的角色。
#include
处理器根据#include指令把另一个文件中的内容添加到该指令所在的位置。
通过#include指令可以包含其他文件的内容。使用别人已经写好的代码，例如，标准库的打印函数printf()，避免重复造轮子。
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
注释
注释是代码中不会被解释器执行的文本。用于解释代码，方便阅读。
C 支持//单行注释 和 /* 多行注释 */
// 单行注释
// 以//开头，到这一行末尾
// 任何地方都可以写注释：函数外面、里面，每一条语句后面
// 快捷键:Ctrl+/
/*
// 多行注释可以嵌套单行注释
多行注释不能嵌套多行注释
因为多行注释以/*开头，到最近的一个* /结尾
初学者编写程序可以养成习惯：先写注释再写代码
将自己的思想通过注释先整理出来，在用代码去体现
因为代码仅仅是思想的一种体现形式而已
*/
内置内容
C语言的核心设计理念是小而精，它只提供了一套非常精简的内置功能，将大部分功能都留给库来实现。
关键字
关键字是语言中预先定义的标识符。(在开发工具中会显示特殊颜色。)
我们把它们用作标识符名称会 引发错误或导致其功能失效。
数据类型
- 作为程序员, 我们最关心的是内存中的动态数据,因为我们写的程序就是在内存中运行的
- 程序在运行过程中会产生各种各样的临时数据,为了方便数据的运算和操作, C 语言对这些数据进行了分类, 提供了丰富的数据类型
- C 语言中有 4 大类数据类型:基本类型、空类型、构造类型、指针类型
1个二进制位可以存储0或1，称为位?。
8个二进制位就可以存储2^8=256个不同的数值（0~255），称为字节?。
在计算机中以整数形式存储的就是整型。字符型（char）本质上也是小整数（通常对应ASCII码值），所以字符型也属于整型家族，可以进行算术运算。
数据类型使用建议
- 选择合适的类型：根据数据范围选择最小满足需求的类型
- 避免溢出：注意数据范围，防止溢出导致的错误结果
- 浮点数比较：不要直接用==比较浮点数，使用epsilon比较
- 类型转换：明确类型转换的规则，避免精度丢失
- 内存对齐：了解结构体内存对齐规则，优化内存使用
常见陷阱
- 整数除法截断：
5/2结果是2而不是2.5 - 无符号整数下溢：
unsigned int x = 0; x--;结果是很大的正数 - 浮点精度问题：
0.1 + 0.2可能不等于0.3 - 数组越界：访问数组时要检查 边界，C语言不会自动检查
标准库
虽然C语言的内置内容少，但它拥有一个庞大且功能强大的标准库 (Standard Library)，这是C语言功能的核心所在。
这个标准库被分成了许多头文件，每个头文件都包含了一组相关的函数、宏和类型定义。
标准库的设计理念是精简(基本功能)、高效（通用功能）和可移植（与操作系统无关的）。
info
#include <stdio.h>作用相当于把stdio.h文件中的所有内容都输入该行所在的位置。实际上，这是一种“拷贝-粘贴”的操作。
这行代码是一条C预处理器指令（preprocessor directive）。通常，C编译器在编译前会对源代码做一些准备工作，即预处理（preprocessing）。
运算符
运算符和关键字一样，可以直接使用。
算术运算符
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 3 | 乘法运算符 | * | 双目运算符,具有左结合性 |
| 3 | 除法运算符 | / | 向零取整 |
| 3 | 求余运算符 (求模运算符) | % | 双目运算符,具有左结合性 |
| 4 | 加法运算符 | + | 双目运算符,具有左结合性 |
| 4 | 减法运算符 | - | 双目运算符,具有左结合性 |
- 如果参与运算的两个操作数皆为整数, 那么结果也为整数
- 如果参与运算的两个操作数其中一个是浮点数, 那么结果一定是浮点数
- 求余运算符, 被除数a
%除数b,a=(a 整除 b) × b + 余数，其中(a 整除 b)的结果总是向 0 取整。（四舍五入时也总是向 0 取整） - 求余运算符, 参与运算的两个操作数必须都是整数, 不能包含浮点数。且除数不能为 0 (没有意义)
- 求余运算符, 结果的正负与第1个运算对象相同。?求模的结果的正负与第1个运算对象相同。
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
// 加法
int result = a + b;
printf("%i\n", result); // 15
// 减法
result = a - b;
printf("%i\n", result); // 5
// 乘法
result = a * b;
printf("%i\n", result); // 50
// 除法
result = a / b;
printf("%i\n", result); // 2
// 算术运算符的结合性和优先级
// 结合性: 左结合性, 从左至右
int c = 50;
result = a + b + c; // 15 + c; 65;
printf("%i\n", result);
// 优先级: * / % 大于 + -
result = a + b * c; // a + 250; 260;
printf("%i\n", result);
// 整数除以整数, 结果还是整数
printf("%i\n", 10 / 3); // 3
// 参与运算的任何一个数是小数, 结果就是小数
printf("%f\n", 10 / 3.0); // 3.333333
// 10 / 3 商等于3, 余1
int result_2 = 10 % 3;
printf("%i\n", result_2); // 1
// 左边小于右边, 那么结果就是左边
result_2 = 2 % 10;
printf("%i\n", result_2); // 2
// 被除数是正数结果就是正数,被除数是负数结果就是负数
result_2 = 10 % 3;
printf("%i\n", result_2); // 1
result_2 = -10 % 3;
printf("%i\n", result_2); // -1
result_2 = 10 % -3;
printf("%i\n", result_2); // 1
}
赋值运算符
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 14 | 赋值运算符 | = | 双目运算符,具有右结合性 |
| 14 | 除后赋值运算符 | /= | 双目运算符,具有右结合性 |
| 14 | 乘后赋值运算符 (模运算符) | *= | 双目运算符,具有右结合性 |
| 14 | 取模后赋值运算符 | %= | 双目运算符,具有右结合性 |
| 14 | 加后赋值运算符 | += | 双目运算符,具有右结合性 |
| 14 | 减后赋值运算符 | -= | 双目运算符,具有右结合性 |
- 简单赋值运算符
#include <stdio.h>
int main(){
// 简单的赋值运算符 =
// 会将=右边的值赋值给左边
int a = 10;
printf("a = %i\n", a); // 10
}
- 复合赋值运算符
#include <stdio.h>
int main(){
// 复合赋值运算符 += -= *= /= %=
// 将变量中的值取出之后进行对应的操作, 操作完毕之后再重新赋值给变量
int num1 = 10;
// num1 = num1 + 1; num1 = 10 + 1; num1 = 11;
num1 += 1;
printf("num1 = %i\n", num1); // 11
int num2 = 10;
// num2 = num2 - 1; num2 = 10 - 1; num2 = 9;
num2 -= 1;
printf("num2 = %i\n", num2); // 9
int num3 = 10;
// num3 = num3 * 2; num3 = 10 * 2; num3 = 20;
num3 *= 2;
printf("num3 = %i\n", num3); // 20
int num4 = 10;
// num4 = num4 / 2; num4 = 10 / 2; num4 = 5;
num4 /= 2;
printf("num4 = %i\n", num4); // 5
int num5 = 10;
// num5 = num5 % 3; num5 = 10 % 3; num5 = 1;
num5 %= 3;
printf("num5 = %i\n", num5); // 1
}
- 结合性和优先级
#include <stdio.h>
int main(){
int number = 10;
// 赋值运算符优先级是14, 普通运算符优先级是3和4, 所以先计算普通运算符
// 普通运算符中乘法优先级是3, 加法是4, 所以先计算乘法
// number += 1 + 25; number += 26; number = number + 26; number = 36;
number += 1 + 5 * 5;
printf("number = %i\n", number); // 36
}
自增减运算符
- 在程序设计中,经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。
- C 语言为这种操作提供了两个更为简洁的运算符,即++和--
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 自增运算符(在后) | i++ | 单目运算符,具有左结合性 |
| 2 | 自增运算符(在前) | ++i | 单目运算符,具有右结合性 |
| 2 | 自减运算符(在后) | i-- | 单目运算符,具有左结合性 |
| 2 | 自减运算符(在前) | --i | 单目运算符,具有右结合性 |
- 自增
- 如果只有单个变量, 无论++写在前面还是后面都会对变量做+1 操作
#include <stdio.h>
int main(){
int number = 10;
number++;
printf("number = %i\n", number); // 11
++number;
printf("number = %i\n", number); // 12
}
- 如果出现在一个表达式中, 那么++写在前面和后面就会有所区别
- 前缀表达式:++x, --x;其中 x 表示变量名,先完成变量的自增自减 1 运算,再用 x 的值作为表达式的值;即“先变后用”,也就是变量的值先变,再用变量的值参与运算
- 后缀表达式:x++, x--;先用 x 的当前值作为表达式的值,再进行自增自减 1 运算。即“先用后变”,也就是先用变量的值参与运算,变量的值再进行自增自减变化
#include <stdio.h>
int main(){
int number = 10;
// ++在后, 先参与表达式运算, 再自增
// 表达式运算时为: 3 + 10;
int result = 3 + number++;
printf("result = %i\n", result); // 13
printf("number = %i\n", number); // 11
}
#include <stdio.h>
int main(){
int number = 10;
// ++在前, 先自增, 再参与表达式运算
// 表达式运算时为: 3 + 11;
int result = 3 + ++number;
printf("result = %i\n", result); // 14
printf("number = %i\n", number); // 11
}
- 自减
#include <stdio.h>
int main(){
int number = 10;
// --在后, 先参与表达式运算, 再自减
// 表达式运算时为: 10 + 3;
int result = number-- + 3;
printf("result = %i\n", result); // 13
printf("number = %i\n", number); // 9
}
#include <stdio.h>
int main(){
int number = 10;
// --在前, 先自减, 再参与表达式运算
// 表达式运算时为: 9 + 3;
int result = --number + 3;
printf("result = %i\n", result); // 12
printf("number = %i\n", number); // 9
}
自增、自减运算只能用于单个变量,只要是标准类型的变量,不管是整型、实型,还是字符型变量等,但不能用于表达式或常量。
- 错误用法:
++(a+b); 5++;
开发中++、--不要和其它运算符混合在一起，因为 C 语言标准没有明确的规定"同一个表达式中同一个变量自增或自减后如何运算", 所以不同编译器得到结果也不同。
int a = 1;
// 下列代码利用Qt运行时6, 利用Xcode运行是5
// 但是无论如何, 最终a的值都是3
// 在C语言中这种代码没有意义, 不用深究也不要这样写
// 特点: 参与运算的是同一个变量, 参与运算时都做了自增自减操作, 并且在同一个表达式中
int b = ++a + ++a;
printf("b = %i\n", b);
sizeof 运算符
sizeof()由 sizeof 和()两个部分组成, 是一个优先级为 2 的运算符, 不是一个函数。
签名: sizeof(常量 or 变量 or 数据类型); 返回值类型为size_t。
info
C头文件系统可以使用typedef把size_t作为unsigned int或unsigned long的别名。
这样，在使用size_t类型时，编译器会根据不同的系统替换标准类型。
-
sizeof 的几种形式
- sizeof( 变量\常量 );
sizeof(10);char c = 'a'; sizeof(c);
- sizeof 变量\常量;
sizeof 10;char c = 'a'; sizeof c;
- sizeof( 数据类型);
sizeof(float);如果是数据类型不能省略括号
- sizeof( 变量\常量 );
#include <stdio.h>
int main(){
int a = 10;
double b = 3.14;
// 由于sizeof的优先级比+号高, 所以会先计算sizeof(a);
// a是int类型, 所以占4个字节得到结果4
// 然后再利用计算结果和b相加, 4 + 3.14 = 7.14
double res = sizeof a+b;
printf("res = %lf\n", res); // 7.14
}
逗号运算符
- 在 C 语言中逗号“,”也是一种运算符,称为逗号运算符。 其功能是把多个表达式连接起来组成一个表达式,称为逗号表达式
- 逗号运算符会从左至右依次取出每个表达式的值, 最后整个逗号表达式的值等于最后一个表达式的值
- 格式:
表达式1，表达式2，… …，表达式n;
- 例如:
int result = a+1,b=3*4;
#include <stdio.h>
int main(){
int a = 10, b = 20, c;
// ()优先级高于逗号运算符和赋值运算符, 所以先计算()中的内容
// c = (11, 21);
// ()中是一个逗号表达式, 结果是最后一个表达式的值, 所以计算结果为21
// 将逗号表达式的结果赋值给c, 所以c的结果是21
c = (a + 1, b + 1);
printf("c = %i\n", c); // 21
}
关系运算符
- 为什么要学习关系运算符
- 默认情况下，我们在程序中写的每一句正确代码都会被执行。但很多时候，我们想在某个条件成立的情况下才执行某一段代码
- 这种情况 的话可以使用条件语句来完成，但是学习条件语句之前，我们先来看一些更基础的知识：如何判断一个条件是否成立
- C 语言中的真假性
- 在 C 语言中，条件成立称为“真”，条件不成立称为“假”，因此，判断条件是否成立，就是判断条件的“真假”
- 怎么判断真假呢？C 语言规定，任何数值都有真假性，任何非 0 值都为“真”，只有 0 才为“假”。也就是说，108、-18、4.5、-10.5 等都是“真”，0 则是“假”
- 关系运算符的运算结果只有 2 种：如果条件成立，结果就为 1，也就是“真”；如果条件不成立，结果就为 0，也就是“假”
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 6 | 大于运算符 | > | 双目运算符,具有左结合性 |
| 6 | 小于运算符 | < | 双目运算符,具有左结合性 |
| 6 | 大于等于运算符 | >= | 双目运算符,具有左结合性 |
| 6 | 小于等于运算符 | <= | 双目运算符,具有左结合性 |
| 7 | 等于运算符 | == | 双目运算符,具有左结合性 |
| 7 | 不等于运算符 | != | 双目运算符,具有左结合性 |
#include <stdio.h>
int main(){
int result = 10 > 5;
printf("result = %i\n", result); // 1
result = 5 < 10;
printf("result = %i\n", result); // 1
result = 5 > 10;
printf("result = %i\n", result); // 0
result = 10 >= 10;
printf("result = %i\n", result); // 1
result = 10 <= 10;
printf("result = %i\n", result); // 1
result = 10 == 10;
printf("result = %i\n", result); // 1
result = 10 != 9;
printf("result = %i\n", result); // 1
}
- 优先级和结合性
#include <stdio.h>
int main(){
// == 优先级 小于 >, 所以先计算>
// result = 10 == 1; result = 0;
int result = 10 == 5 > 3;
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
// == 和 != 优先级一样, 所以按照结合性
// 关系运算符是左结合性, 所以从左至右计算
// result = 0 != 3; result = 1;
int result = 10 == 5 != 3;
printf("result = %i\n", result); // 1
}
- 注意点:
- 无论是 float 还是 double 都有精度问题, 所以一定要避免利用==判断浮点数是否相等
#include <stdio.h>
int main(){
float a = 0.1;
float b = a * 10 + 0.00000000001;
double c = 1.0 + + 0.00000000001;
printf("b = %f\n", b);
printf("c = %f\n", c);
int result = b == c;
printf("result = %i\n", result); // 0
}
逻辑运算符
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 逻辑非运算符 | ! | 单目运算符,具有右结合性 |
| 11 | 逻辑与运算符 | && | 双目运算符,具有左结合性 |
| 12 | 逻辑或运算符 | || | 双目运算符,具有左结合性 |
- 逻辑非
-
格式:
! 条件A; -
运算结果: 真变假,假变真
-
运算过程:
- 先判断条件 A 是否成立，如果添加 A 成立, 那么结果就为 0，即“假”；
- 如果条件 A 不成立，结果就为 1，即“真”
- 使用注意:
- 可以多次连续使用逻辑非运算符
- !!!0;相当于(!(!(!0)));最终结果为 1
#include <stdio.h>
int main(){
// ()优先级高, 先计算()里面的内容
// 10==10为真, 所以result = !(1);
// !代表真变假, 假变真,所以结果是假0
int result = !(10 == 10);
printf("result = %i\n", result); // 0
}
-
逻辑与
- 格式:
条件A && 条件B; - 运算结果:一假则假
- 运算过程:
- 总是先判断"条件 A"是否成立
- 如果"条件 A"成立，接着再判断"条件 B"是否成立, 如果"条件 B"也成立，结果就为 1，即“真”
- 如果"条件 A"成立，"条件 B"不成立，结果就为 0，即“假”
- 如果"条件 A"不成立，不会再去判断"条件 B"是否成立, 因为逻辑与只要一个不为真结果都不为真
- 使用注意:
- "条件 A"为假, "条件 B"不会被执行
- 格式:
#include <stdio.h>
int main(){
// 真 && 真
int result = (10 == 10) && (5 != 1);
printf("result = %i\n", result); // 1
// 假 && 真
result = (10 == 9) && (5 != 1);
printf("result = %i\n", result); // 0
// 真 && 假
result = (10 == 10) && (5 != 5);
printf("result = %i\n", result); // 0
// 假 && 假
result = (10 == 9) && (5 != 5);
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
int a = 10;
int b = 20;
// 逻辑与, 前面为假, 不会继续执行后面
int result = (a == 9) && (++b);
printf("result = %i\n", result); // 1
printf("b = %i\n", b); // 20
}
-
逻辑或
- 格式:
条件A || 条件B; - 运算结果:一真则真
- 运算过程:
- 总是先判断"条件 A"是否成立
- 如果"条件 A"不成立，接着再判断"条件 B"是否成立, 如果"条件 B"成立，结果就为 1，即“真”
- 如果"条件 A"不成立，"条件 B"也不成立成立, 结果就为 0，即“假”
- 如果"条件 A"成立, 不会再去判断"条件 B"是否成立, 因为逻辑或只要一个为真结果都为真
- 使用注意:
- "条件 A"为真, "条件 B"不会被执行
- 格式:
#include <stdio.h>
int main(){
// 真 || 真
int result = (10 == 10) || (5 != 1);
printf("result = %i\n", result); // 1
// 假 || 真
result = (10 == 9) || (5 != 1);
printf("result = %i\n", result); // 1
// 真 || 假
result = (10 == 10) || (5 != 5);
printf("result = %i\n", result); // 1
// 假 || 假
result = (10 == 9) || (5 != 5);
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
int a = 10;
int b = 20;
// 逻辑或, 前面为真, 不会继续执行后面
int result = (a == 10) || (++b);
printf("result = %i\n", result); // 1
printf("b = %i\n", b); // 20
}
位运算符
- 程序中的所有数据在计算机内存中都是以二进制的形式储存的。
- 位运算就是直接对整数在内存中的二进制位进行操作
- C 语言提供了 6 个位操作运算符, 这些运算符只能用于整型操作数
| 符号 | 名称 | 运算结果 |
|---|---|---|
| & | 按位与 | 同 1 为 1 |
| | | 按位或 | 有 1 为 1 |
| ^ | 按位异或 | 不同为 1 |
| ~ | 按位取反 | 0 变 1,1 变 0 |
<< | 按位左移 | 乘以 2 的 n 次方 |
>> | 按位右移 | 除以 2 的 n 次方 |
- 按位与:
- 只有对应的两个二进位均为 1 时，结果位才为 1，否则为 0
- 规律: 二进制中，与 1 相&就保持原位，与 0 相&就为 0
9&5 = 1
1001
&0101
------
0001
- 按位或:
- 只要对应的二个二进位有一个为 1 时，结果位就为 1，否则为 0
9|5 = 13
1001
|0101
------
1101
- 按位异或
- 当对应的二进位相异（不相同）时，结果为 1，否则为 0
- 规律:
- 相同整数相的结果是 0。比如 55=0
- 多个整数相^的结果跟顺序无关。例如: 567=576
- 同一个数异或另外一个数两次, 结果还是那个数。例如: 577 = 5
9^5 = 12
1001
^0101
------
1100
- 按位取反
- 各二进位进行取反（0 变 1，1 变 0）
~9 =-10
0000 0000 0000 0000 0000 1001 // 取反前
1111 1111 1111 1111 1111 0110 // 取反后
// 根据负数补码得出结果
1111 1111 1111 1111 1111 0110 // 补码
1111 1111 1111 1111 1111 0101 // 反码
1000 0000 0000 0000 0000 1010 // 源码 == -10
三目运算符
- 三目运算符，它需要 3 个数据或表达式构成条件表达式
- 格式:
表达式1？表达式2(结果A)：表达式3(结果B)
- 示例:
考试及格 ? 及格 : 不及格;
- 求值规则:
- 如果"表达式 1"为真，三目运算符的运算结果为"表达式 2"的值(结果 A)，否则为"表达式 3"的值(结果 B)
示例:
int a = 10;
int b = 20;
int max = (a > b) ? a : b;
printf("max = %d", max);
输出结果: 20
等价于:
int a = 10;
int b = 20;
int max = 0;
if(a>b){
max=a;
}else {
max=b;
}
printf("max = %d", max);
- 注意点
- 条件运算符的运算优先级低于关系运算符和算术运算符,但高于赋值符
- 条件运算符?和:是一个整体,不能分开使用
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
// 先计算 a > b
// 然后再根据计算结果判定返回a还是b
// 相当于int max= (a>b) ? a : b;
int max= a>b ? a : b;
printf("max = %i\n", max); // 10
}
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
int c = 20;
int d = 10;
// 结合性是从右至左, 所以会先计算:后面的内容
// int res = a>b?a:(c>d?c:d);
// int res = a>b?a:(20>10?20:10);
// int res = a>b?a:(20);
// 然后再计算最终的结果
// int res = 10>5?10:(20);
// int res = 10;
int res = a>b?a:c>d?c:d;
printf("res = %i\n", res);
}
优先级和结合性
"从左往右,先乘除后加减,有括号的先算括号里面的", 这句话就蕴含了优先级和结合性的问题。
运算优先级1 级最高,15 级最低。相同优先级的运算符, 运算次序按照结合性规定的方向执行。
复杂表达式推荐使用括号()来明确运算顺序，提高代码可读性。
| 优先级 | 运算符 | 说明 | 结合性 |
|---|---|---|---|
| 1 | () [] -> . | 圆括号(函数调用)、下标引用、指向结构体成员、结构体成员 | 从左到右 |
| 2 | ! ~ ++ -- + - * & sizeof (type) | 逻辑非、按位取反、自增自减、正负号、指针、取地址、长度、强制类型转换 | 从右到左 |
| 3 | * / % | 乘法、除法、取余 | 从左到右 |
| 4 | + - | 加法、减法 | 从左到右 |
| 5 | << >> | 左移、右移 | 从左到右 |
| 6 | < <= > >= | 小于、小于等于、大于、大于等于 | 从左到右 |
| 7 | == != | 等于、不等于 | 从左到右 |
| 8 | & | 按位与 | 从左到右 |
| 9 | ^ | 按位异或 | 从左到右 |
| 10 | | | 按位或 | 从左到右 |
| 11 | && | 逻辑与 | 从左到右 |
| 12 | || | 逻辑或 | 从左到右 |
| 13 | ?: | 条件运算符(三目运算符) | 从右到左 |
| 14 | = += -= *= /= %= &= ^= |= <<= >>= | 各种赋值运算符 | 从右到左 |
| 15 | , | 逗号运算符 | 从左到右 |