^-^
终生学习者｜阅读爱好者
C语言：基础语法

一、数据类型与变量

来福是只狗。德福是只猫。张三是个人。A 是一个整型变量。变量是我们计算机中用来存储数据的具体空间的指代，而类型是这个变量所对应的类型。

1、计算机中的数据存储

计算机存储数据的基本单位：字节
计算机表示数据的基本单位：位
表示数据方式：二进制
image.png
位权：十进制每高一位，位权是乘 10，二进制每高一位，位权是乘 2
整型类型占 4 个字节
image.png
这四个格子（字节），每个格子（字节）上面都有一串 16 进制的数字，那是这些格子（字节）的地址。并且这四个地址要是连续的。

2、补码表示法

int 类型的数据范围是：~
为什么负数的范围要比正数多 1 呢？
因为计算机中，会把第一位当成符号位。当第一位为 1 的时候，表示为负数，为 0 的时候为正数。
1 的二进制：0001
0 的二进制：0000
-1 的二进制：1111
-2 的二进制：1110
-3 的二进制：1101
负数的补码等于正数的原码取反后再加 1
例如：1 的原码是：0001 那么-1 的补码就是：取反（1110）再加 1 --> 1111
补码表示法的好处：把十进制的减法，变成二进制的加法。

补码让我想到一个成语，否极泰来，泰卦在《易经》中排序第十一，否卦第十二，泰卦之前还有十个卦，从乾、坤开天辟地起，得历尽艰险、排除万难，才营造出泰的局面。而由泰到否，就不必这么麻烦，直接从云端一路狂泻跌入谷底。事物发展交替更换，由开始0到高峰0111（7），一下跌倒低谷1000（-8），当否到极致了（1111），再往前（0000）就开始转运了。

3、常用数据类型

数据类型 描述 格式化占位符 存储范围
char 用于存储单个字符 %c -128 到 127 或 0 到 255
int 用于存储整数 %d -32,768 到 32,767 或更大范围
float 用于存储单精度浮点数 %f 约 ±3.4e−38 到 ±3.4e+38
double 用于存储双精度浮点数 %lf 约 ±1.7e−308 到 ±1.7e+308

二、输入输出

1、输出函数：printf

printf函数

  • 头文件：stdio.h
  • 原型：int printf(const char *format,...);
  • format：格式控制字符串
  • ...可变参数列表
  • 返回值：输出字符的数量
1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
    printf("hello world\n");
    int a = printf("hello world\n");
    int b = printf("hello world: %d\n",a);
    printf("a = %d   b = %d\n",a, b);
    return 0;
}

2、输入函数：scanf

scanf函数：

  • 头文件：stdio.h
  • 原型：int scanf(const char *format,...);
  • format：格式控制字符串
  • ...可变参数列表
  • 返回值：成功读入的参数个数
1
2
3
4
5
6
7
#include<stdio.h>
int main() {
	int a,b;
	int c = scanf("%d%d", &a,&b);
	printf("a = %d,b = %d,c = %d",a,b,c);
	return 0;
}
1
2
3
4
5
6
7
#include<stdio.h>
int main() {
	char s[100];
	scanf("%s", &s);
	printf("%s", s);
	return 0;
}

scanf函数会以空格作为截断符号，scanf会从第一个非空白符开始，一直往下读取，直到读取到第一个空白符开始截断。

1
2
3
4
5
6
7
#include<stdio.h>
int main() {
	char s[100];
	scanf("%[a-z]", &s);
	printf("%s", s);
	return 0;
}

%[a-z]表示集合读入，允许读入的字母是从 a~z，当读入到第一个不在集合内的字符时，就会停止读入。

scanf小技巧：scanf("%[^\n]", &s) 表示只要不是换行，就全部读入。

在字符串中，会有一个结束符’\0’，虽然 abc 看起来是三个字符，但因为还有一个结束符’\0’，所以其实它占四位。

3、字符串输入：sscanf

sscanf作用是：从字符串中读入数据
scanf 其实是将字符串信息，转化为其他信息的一种方式。

1
2
3
4
5
6
7
8
#include<stdio.h>
int main() {
	char s[100] = "123 456 789";
	int a, b, c;
	sscanf(s, "%d%d%d", &a, &b, &c);
	printf("a = %d , b = %d , c = %d\n", a, b, c);
	return 0;
}

4、字符串输出：sprintf

sprintf作用是：输出数据到字符串中
sprintf 其实是将其他信息，转化为字符串信息的一种方式。

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main() {
    char s[100] = "192.168.1.245";
    int a,b,c,d;
    sscanf(s, "%d.%d.%d.%d", &a, &b, &c, &d);
    sprintf(s, "%d:%d:%d:%d", a, b, c, d);
    printf("%d:%d:%d:%d", a, b, c, d);
    return 0;
}

5、给输出内容加个小框框

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
int main() {
	char s[100],t[100];
	scanf("%[^\n]", &s);
	int n = 0;
	n = sprintf(t, "| %s |", s); //上边沿长度
	for (int i = 0; i < n; i++) {
		printf("-");
	}
	printf("\n");
	printf("| %s |\n", s);
	for (int i = 0; i < n; i++) {
		printf("-");
	}
	return 0;
}

三、基本运算符

1、位运算符

按位与 和 按位或

按位与&：两个位都为 1 结果位才为 1，否则为 0

按位或|：只要有一个位置为 1，结果位就为 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>

// 函数声明
void printBinary(int num);

int main() {
    int a = 5;
    int b = 3;
    printf("a的二进制: ");
    printBinary(a);

    printf("b的二进制: ");
    printBinary(b);

    printf("a & b = %d\n", a & b);
    printf("(a & b)的二进制: ");
    printBinary(a & b);

    printf("a | b = %d\n", a | b);
    printf("(a | b)的二进制: ");
    printBinary(a | b);
    return 0;
}
// 函数定义，打印整数的二进制表示
void printBinary(int num) {
    // 32位整数的位数
    int bits = sizeof(num) * 8;

    // 从最高位开始，逐位输出
    for (int i = bits - 1; i >= 0; i--) {
        // 判断第i位是否为1
        int bit = (num >> i) & 1;
        printf("%d", bit);

        // 每4位插入一个空格，方便观察
        if (i % 4 == 0) {
            printf(" ");
        }
    }
    printf("\n");
}

按位异或

按位异或^：相应位置不同结果位则为 1，相同结果位为 0
异或运算又可以被理解为无进位相加，可用统计相应二进制位上 1 的奇偶性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>

// 函数声明
void printBinary(int num);

int main() {
    int a = 5;
    int b = 3;
    printf("a的二进制: ");
    printBinary(a);

    printf("b的二进制: ");
    printBinary(b);

    printf("a ^ b = %d\n", a & b);
    printf("(a ^ b)的二进制: ");
    printBinary(a ^ b);
    return 0;
}
// 函数定义，打印整数的二进制表示
void printBinary(int num) {
    // 32位整数的位数
    int bits = sizeof(num) * 8;

    // 从最高位开始，逐位输出
    for (int i = bits - 1; i >= 0; i--) {
        // 判断第i位是否为1
        int bit = (num >> i) & 1;
        printf("%d", bit);

        // 每4位插入一个空格，方便观察
        if (i % 4 == 0) {
            printf(" ");
        }
    }
    printf("\n");
}

异或运算自己就是自己的逆运算： a^b = c那么 a^c = b，c^b = a

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
    int a = 5;
    int b = 3;
    printf("a = %d  b = %d\n", a, b);
    int c = a ^ b;
    printf("c = a^b = %d\n", c);
    printf("a^c = %d\n", a ^ c);
    printf("b^c = %d\n", b ^ c);
    return 0;
}

小问题：不新开变量，实现交换两个数的值

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main() {
    int a = 5;
    int b = 3;
    printf("a = %d  b = %d\n", a, b);
    a ^= b;
    b ^= a;
    a ^= b;
    printf("a = %d  b = %d\n", a, b);
    return 0;
}

按位取反

按位取反~：将原来数二进制上的 1 变为 0，0 变为 1
补码 = 原码取反再加 1

1
2
3
4
5
6
7
8
#include <stdio.h>
int main() {
    int a = 5;
    printf("a = %d\n", a);

    printf("- a = %d\n",~a + 1);
    return 0;
}

移位

左移位<<将一个数的所有二进制位向左移动指定的位数，右边空出的位用0填充。左移运算的效果就是将原数乘以2的指定次方。
右移位>>：将一个数的所有二进制位向右移动指定的位数，左边空出的位的填充方式通常是取决于原数的符号位。对于正数，左边空出的位用0填充；对于负数，左边空出的位用符号位的值填充。 右移运算的效果就是将原数除以2的指定次方。
但是要注意：/是向 0 取整，>>是向下取整。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>

// 函数声明
void printBinary(int num);

int main() {
    int a = 5;
    printf("a的二进制: ");
    printBinary(a);

    printf("(a << 1)的二进制: ");
    printBinary(a << 1);
    printf("(a >> 1)的二进制: ");
    printBinary(a >> 1);
    return 0;
}
// 函数定义，打印整数的二进制表示
void printBinary(int num) {
    // 32位整数的位数
    int bits = sizeof(num) * 8;

    // 从最高位开始，逐位输出
    for (int i = bits - 1; i >= 0; i--) {
        // 判断第i位是否为1
        int bit = (num >> i) & 1;
        printf("%d", bit);

        // 每4位插入一个空格，方便观察
        if (i % 4 == 0) {
            printf(" ");
        }
    }
    printf("\n");
}

2、常用数学函数

函数 描述 头文件
fabs(x) 返回 x 的绝对值 #include <math.h>
sqrt(x) 返回 x 的平方根 #include <math.h>
cbrt(x) 返回 x 的立方根 #include <math.h>
pow(x, y) 返回 x 的 y 次方 #include <math.h>
exp(x) 返回 e 的 x 次方 #include <math.h>
log(x) 返回 x 的自然对数（以e为底） #include <math.h>
log10(x) 返回 x 的常用对数（以10为底） #include <math.h>
floor(x) 返回不大于 x 的最大整数 #include <math.h>
ceil(x) 返回不小于 x 的最小整数 #include <math.h>
round(x) 返回最接近 x 的整数，四舍五入 #include <math.h>
fmod(x, y) 返回 x 除以 y 的余数 #include <math.h>
remainder(x, y) 返回 x 除以 y 的余数，保留符号 #include <math.h>

3、关系运算符

运算符 描述
== 相等
! 真变假，假变真
< 小于
> 大于
<= 小于等于
>= 大于等于
&& 逻辑与
&#124;&#124; 逻辑或

四、流程控制

1、CPU 的分支预测

1
2
#define linkely(x)  _builtin_expect(!!(x),1) 	//大概率为真
#define unlinkely(x)  _builtin_expect(!!(x),0)  //大概率为假

linkely(x)表示 X 经常成立，加载条件分支内部的代码。
unlinkely(x)表示 X 经常不成立，加载条件分支外部的代码。
这叫逻辑值的归一化，什么意思？
比如：!!(5) = 1 不关 x 为和值，通过两次的非后!!所有的真值都会变为 1，假值都会变成 0

2、分支语句

2.1 if 语句

if 语句的语法形式如下:

1
2
if ( 表达式 )
    语句;
  • 在C语言中，0为假，非0表示真，也就是表达式的结果如果是0，则语句不执行，表达式的结果如果不是0，则语句执行。
  • 进而理解，表达式成立（为真），则语句执行，表达式不成立（为假），则语句不执行。

下面我们通过一个样例，来理解一下上面的语法。

示例代码

输入一个整数，判断是否为奇数

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main()
{
    int num = 0;
    scanf("%d", &num);    // 让用户输入整数
    if (num % 2 == 1)     // 判断num % 2 == 1这个表达式是否成立，如果成立，执行后续printf语句
        printf("%d 是奇数\n", num);
    return 0;
}

2.2 if-else 语句

如果一个数不是奇数，那就是偶数了，如果任意一个整数，我们要清楚的判断是奇数还是偶数怎么表示呢？

这里就需要if...else...语句了，语法形式如下：

1
2
3
4
if ( 表达式 )
    语句1;
else
    语句2;

示例代码

输入一个整数，判断是否为奇数，如果是奇数，就打印"奇数"，否则打印"偶数"

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int num = 0;
    scanf("%d", &num);
    if (num % 2 == 1)    // 判断num % 2 == 1这个表达式是否成立，如果成立，执行后续printf语句
        printf("%d 是奇数\n", num);
    else                 // 否则，执行else后面的printf语句
        printf("%d 是偶数\n", num);
    return 0;
}

示例代码

输入一个年龄，>= 18岁就输出：“成年”，否则就输出：“未成年”

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int age = 0;
    scanf("%d", &age);
    if (age >= 18)    // 判断age >= 18这个表达式是否成立，如果成立，执行后续printf语句
        printf("成年\n");
    else              // 否则，执行else后面的printf语句
        printf("未成年\n");
    return 0;
}

2.3 switch 语句

除了if语句外，C语言还提供了switch语句来实现分支结构。switch 语句是一种特殊形式的 if...else 结构，用于判断条件有多个结果的情况。它把多重的else if改成更易用、可读性更好的形式。

语法格式

1
2
3
4
5
switch (expression) {
  case value1: statement
  case value2: statement
  default: statement
}

上面代码中，根据表达式expression的运算结果，匹配不同case中的value的值，匹配成功，执行相应的case分支。如果找不到对应的值，就执行default分支。

注：

  • switch后的expression必须是整型表达式
  • case 后的值，必须是整形常量表达式

2.4 if和switch对比

直接通过一组对比代码，来看看两者的区别

示例代码 - 输入任意一个整数值，计算除3之后的余数

if版本 - 如果使用if语句完成，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main()
{
    int n = 0;
    scanf("%d", &n);
    if(n%3 == 0)
        printf("整除，余数为0\n");
    else if(n%3 == 1)
        printf("余数是1\n");
    else
        printf("余数是2\n");
    return 0;
}

switch版本 - 如果使用switch语句改写，就可以是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>

int main()
{
    int n = 0;
    scanf("%d", &n);
    switch (n % 3)
    {
    case 0:
        printf("整除，余数为0\n");
        break;
    case 1:
        printf("余数是1\n");
        break;
    case 2:
        printf("余数是2\n");
        break;
    }
    return 0;
}

上述的代码中，我们要注意的点有：

  1. case 和 后边的数字之间必须有空格
  2. 每一个case语句中的代码执行完成后，需要加上break，才能跳出这个switch语句。

3、循环语句

3.1 while循环

C语言提供了3种循环语句，while就是其中一种，接下来就介绍一下while语句。

while语句的语法结构和if语句非常相似。

1
2
3
4
5
6
if(表达式)       //如果if分支想包含更多的语句，可以加上大括号
    语句;
    
    
while(表达式)    //如果循环体想包含更多的语句，可以加上大括号
    语句;

为了快速说明问题，我们通过if和while的对比，先看看他们的共性和区别。

示例代码 - if

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main()
{
    if (1) // 这里1为真，表示该条件永远满足
    {
        //if条件满足，打印一次 "我是if"
        printf("我是if\n");  
    }
    return 0;
}

示例代码 - while

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main()
{
    while (1)
    {
        printf("我是while\n"); //while后边的条件满足，死循环的打印"我是while"
    }
    return 0;
}

通过运行结果，能看出他们的区别，while语句是可以实现循环打印效果的。关于if我们就不再浪费笔墨了，重点来看看while。

首先需要说明的是:

while本身就具有判断能力。即while条件为真的时候，while匹配的语句才会执行，这点和if一致。所以，当while条件不满足条件，while匹配的代码块也就不会执行，比如：

示例代码：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main()
{
    while (0)    // 此处，0表示假，while条件不满足
    {
        printf("我是while\n");
    }
    return 0;
}

其次需要说明的是:

while条件满足的时候，执行完匹配的语句之后，要回到while判断中，继续判断。不像if语句，条件满足，执行完匹配的语句之后，会继续向后执行。这点是两者的不同。

示例代码：

在屏幕上打印 1~10 的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int main()
{
    int i = 1;
    // 注意：while检测的不是i，不是10，而是表达式1 <= 10的逻辑结果
    while (i <= 10)        // while检测条件是否满足，当条件不满足的时候，就结束while，执行后续代码
    {                      // {}表示while自己的代码块
        printf("%d\n", i); // 如果满足就执行打印语句
        i = i + 1;         // 也要执行i=i+1，进行条件更新，方便while循环结束
    }
    
    // 后续代码的位置
    return 0;
}

运行结果

1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

如果上述代码，把while更换成为if，代码块最多被执行一次，这里可以看出来，while在条件满足的情况下，是会重复执行的。

结合上面的代码样例，我们总结一下while执行的步骤：

  1. while(表达式)中，先执行表达式，得到表达式的结果。如：表达式i <= 10先要计算自己的逻辑结果(即：真或假)
  2. 根据表达式结果，while进行判断
  3. 如果条件为真，就执行匹配的代码块，否则结束while
  4. 重复1、2、3

而上面的样例代码中，while (1)、while(0)是上面的流程的特殊情况，相当于已经有了逻辑结果，直接判断即可。

说明一下while语句的执行流程：

首先执行表达式，然后判断表达式的结果，表达式的结果值为0(假)，循环判断直接结束；表达式的结果值不为0(真)，循环判断条件满足，则执行循环语句，语句执行完后，再继续判断。

结论：

当while中的表达式结果为真的时候，就要执行while后续的语句，执行完毕之后，不像if会运行后续代码，while要重新回到()括号中的表达式中，再次执行表达式，得到逻辑结果，判断逻辑结果是否为真，如果还是真，就继续重复上面所说的工作。如果为假，就结束while。

3.2 有限次数whlie循环

如果我们想执行指定次数的循环，一般先要确认的就是循环条件。循环条件就是while(表达式)中圆括号中的表达式。一般而言，我们会首先定义一个计数器变量来跟踪循环的次数，每次循环开始执行时，计数器会增加1或者减少1，通过控制计数器，来控制循环次数。下面我们用代码进行一下简单说明

示例代码

求1-100的和是多少，并输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main()
{
    int sum = 0;
    int loop_cnt = 1;        // 1. 定义循环变量并初始化
    while (loop_cnt <= 100)  // 2. 编写循环对应的表达式，充当循环判断条件
    {
        sum += loop_cnt;
        loop_cnt++;          // 3. 更新循环变量的值，控制循环次数
    }
    printf("[1-100] sum is: %d\n", sum);
    return 0;
}

运行结果

1
[1-100] sum is: 5050

一般而言，我们要编写一个有限次数的循环，基本要有下面的循环三要素：

  1. 定义并初始化循环变量
  2. 定义循环判断表达式，充当判断条件
  3. 更新循环变量

while循环也比较灵活，有时候会有很多缺省写法。

3.3 while死循

如果我们想写一个一直在运行的循环，不让其退出，那么只要想办法让它的循环条件一直满足即可，这种循环我们叫做死循环。

示例代码

1
2
3
4
5
6
7
8
9
10
11
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
    while (1)   // 直接设置while(1), 1是常量，永远为真，这个就是死循环
    {
        printf("dead loop!\n");
    }
    return 0;
}

运行结果

1
2
3
4
5
dead loop!
dead loop!
dead loop!
dead loop!
...          // 无数个dead loop!

C99 已经支持bool类型，所以如果你想写一个基于bool类型的死循环，可以采用如下方式

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdbool.h> // 需要包含这个头文件哦

int main()
{
    while (true)     // true为真
    {
        printf("dead loop!\n");
    }
    return 0;
}

目前我们使用死循环的场景还是很少的，但是需要知道哦

3.4 for循环

语法形式

for循环是三种循环中使用最多的，for循环的语法形式如下：

1
2
for(表达式1; 表达式2; 表达式3) // 注意，三个表达式中间用的是英文分号
    语句；        //如果循环体想包含更多的语句，可以加上大括号
  • 表达式1 用于循环变量的初始化
  • 表达式2 用于循环结束条件的判断
  • 表达式3 用于循环变量的调整

for循环如果满足条件的时候，也想执行多行语句，也强烈建议在for之后带上{},限定代码块范围

for循环的执行流程：

  1. 执行表达式1，初始化循环变量
  2. 接下来就是执行表达式2的判断部分，表达式2的结果如果==0，则循环结束；表达式2的结果如果!=0则执行循环语句
  3. 循环语句执行完后，再去执行表达式3,调整循环变量，然后再去表达式2的地方执行判断，表达式2的结果是否为0，决定循环是否继续。

注意：

整个循环的过程中，表达式1初始化部分只被执行1次，剩下的就是表达式2、循环语句、表达式3在循环。

示例代码

在屏幕上打印1~10的值

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int i = 0;
    for(i=1; i<=10; i++) 
    {
        printf("%d\n", i);
    }
    
    return 0;
}

结合上面的代码，可以看出来：

  1. i=1; 表达式1，循环变量的初始化
  2. i<=10;表达式2，循环结束条件的判断
  3. i++; 表达式3，循环变量的调整

其中表达式1只在最开始执行一次，剩下的都是表达式2和表达式3在进行控制

注意：

上面的例子，也是一次有限次数的for循环，我们就不在写重复的代码来进行说明了

3.5 for死循环

for也支持死循环写法，而且更简单。在思路上，其实只要保证表达式2即循环结束条件永远为真就可以。类似：

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int flag = 1;
    for (; flag == 1; )     // 循环条件永远成立为真
    {
        printf("dead loop!\n");
    }

    return 0;
}

for有更简洁的写法。

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int flag = 1;
    for ( ; ; )    //三个表达式全部省略哦 
    {
        printf("dead loop!\n");
    }

    return 0;
}

运行结果

1
2
3
4
5
dead loop!
dead loop!
dead loop!
dead loop!
...          // 无数个dead loop!

没错，for循环中的3个表达式，支持省略写法

比较常见的省略除了上面的死循环，还有初始化部分省略，比如

如果我们已经把变量进行初始化了，就可以省略表达式1了

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main()
{
    int i = 1;
    for(/*省略*/; i<=10; i++)  // i已经在上面初始化了，表达式1可以不写
    {
        printf("%d\n", i);
    }
    
    return 0;
}

3.5 do-while 循环

语法形式：在循环语句中do while语句的使用最少，它的语法如下：

1
2
3
do
    语句；
while(表达式)；

while和for这两种循环都是先判断，条件如果满足就进入循环，执行循环语句，如果不满足就跳出循环；

而do while循环则是先直接进入循环体，执行循环语句，然后再执行while后的判断表达式，表达式为真，就会进行下一次，表达式为假，则不再继续循环。

  • 也就是说，do while内部的语句，至少会执行一次
  • 为了有更好的阅读体验，也强烈建议在编写do while的时候，使用{}限定代码块范围

下面我们用代码先进行一下do while语法的基本特征

示例代码

验证至少执行一次

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main()
{
    do
    {
        printf("do while execute at least once!\n");
    } while (0); // while(表达式)中，表达式故意写成0，表示假。注意while后面的 ; 哦，不要忘记
    //while (0); // 位置A
    return 0;
}

运行结果

1
do while execute at least once!
  • do while 先执行，后判断
  • while(表达式)习惯写在}的后面，不要忘记while(表达式)后面的; 哦。当然，新启一行也是可以，如写在位置A，不过不太推荐

当然，do while也是循环，也能实现while，for的循环功能。

示例代码

验证do while循环功能

题目要求: 在屏幕上打印1~10的值

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

int main()
{
    int i = 1;              // 循环变量的初始化
    do
    {
        printf("%d\n", i);
        i = i + 1;          // 循环变量的调整
    }while(i<=10);          // 循环结束条件的判断
     
    return 0;
}

通过上面的代码我们可以看出来

  • do while 也能实现循环效果
  • do while也有循环三要素哦

我们几乎可以用对for，while的理解，来理解do while，三者共性较多，就不在花太多篇幅重复介绍了。

上面的循环形式，也是do while的有限次数的循环，和while，for一致。此处不再赘言。

下面我们用简单的流程图说明一下do while的执行逻辑

3.6 do while死循环

do while也一定可以执行无限次数的循环 - 死循环。因为之前已经有过类似的介绍，这里以代码形式展示用法即可。

示例代码

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main()
{
    do
    {
        printf("dead loop!\n");
    } while (1);             // 设置条件永远为真

    return 0;
}

运行结果

1
2
3
4
5
dead loop!
dead loop!
dead loop!
dead loop!
...          // 无数个dead loop!

所以，do while的循环三要素也可以省略。

4、break 和 continue

break：跳出 switch 语句和最近一层的循环。
continue ：结束本次循环，继续下一次循环。

五、函数

1、函数的结构

数学中我们其实就见过函数，比如：一次函数y=kx+b，k和b都是常数，给一个任意的x，就得到一个y值。C语言也引入函数的概念。

C语言中的函数就是一个完成某项特定的任务的一小段代码 ，这段代码通常有特殊的语法和调用形式。

风格良好的C语言程序，应该是由无数个小的函数组合而成的。简单来说，比如一个大的计算任务可以被分解成若干个较小的函数（对应较小的任务），通过各个较小函数的组合调用，完成整体的计算任务。同时，如果一个函数能完成某项特定的、大家都需要的功能，我们就没必要重新写，直接用就行，即该函数被复用，从而在一定程度提升了软件开发的效率。

我们可以把函数想象成小型的一个加工厂，首先需要输入若干原材料，经过工厂加工才能生产出产品。那函数也是一样的，函数一般会输入一些值（可以是0个，也可以是多个），经过函数内的计算，得出结果。

函数描述

1
2
3
4
返回值 函数名（参数列表）函数体；
int sum (int a,int b){
    return a+b;
}

😐 为什么一定要有函数这种结构？

  1. 模块化和组织性： 函数允许将代码划分为小的模块或单元。这种模块化的结构使得程序更易于组织、理解和维护。每个函数都负责执行特定的任务，从而使整体程序结构更清晰。
  2. 可维护性： 将代码划分为函数使得对程序的修改和维护更加容易。如果程序中的某个功能需要修改，只需关注与该功能相关的函数，而无需改动整个程序。
  3. 可重用性： 函数可以被多次调用，从而实现了代码的重用。一旦定义了一个函数，可以在程序的不同部分多次调用它，而无需重复编写相同的代码。
  4. 抽象： 函数允许将复杂的操作封装在一个抽象的接口中。调用者只需要知道如何使用函数，而无需了解函数内部的具体实现细节。这提高了代码的抽象层次，使得程序更易于理解。
  5. 可测试性： 函数的独立性使得它们更易于测试。可以对单个函数进行单元测试，确保其在各种输入情况下都能正确运行。这有助于提高代码的质量和可靠性。
  6. 分离关注点： 使用函数可以将不同关注点分离开来。每个函数负责执行一个特定的任务，使得代码更符合单一职责原则。这样的设计使得修改和维护代码更加简单。
  7. 提高可读性： 函数允许用有意义的名字来描述一个操作，从而提高了代码的可读性。函数的命名应该清晰、简洁，有助于理解代码的意图。

2、实参与形参

形参的作用是用来接收实参的值，实参的作用是给形参传递值的。

1
2
3
4
5
6
7
//形参
int sum (int a,int b){
    return a+b;
}
//实参
int a = 4;
int x = sum(3,a*2);

实参：李逵，形参：李鬼。形参的所有修改，都不会改变实参。

3、函数的定义与声明

声明：说明函数的形式
定义：实现函数的内容

1
2
3
4
5
6
//声明
int sum (int,int);
//定义
int sum (int a,int b){
    return a+b;
}

函数定义在调用的前面时，不需要声明也能调用。如果函数的定义在调用的后面，需要声明一下。

4、递归函数

递归函数：自己调用自己的函数。递归 = 递推 + 回归。

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

int sum(int n) {
    if (n == 1)
        return 1;
    else 
        return n + sum(n - 1);
}
int main() {
    int a = 5;
    printf("%d", sum(5));
    return 0;
}

递归描述

2022-08-01 该篇文章被 子夜 打上标签: C语言 归为分类: 编程手札
© 2022-2024 Blog
🌦️疏影横斜水清浅，暗香浮动月黄昏。 本站由Hexo驱动