黑马程序员C语言基础（第五天）运算符与表达式 程序流程结构 数组和字符串 函数

/video/BV15W411K7k6?p=93&spm_id_from=pageDriver

黑马程序员C语言基础（第五天）运算符与表达式、程序流程结构、数组和字符串、函数

文章目录

运算符与表达式常用运算符分类算术运算符两个数相除，要想得到小数，分子分母必须有一个是小数，否则结果只会取整（可以把其中一个数乘以1.0）前自增和后自增区别赋值运算符比较运算符逻辑运算符逻辑优化示例运算符优先级类型转换隐式类型转换强制类型转换程序流程结构概述选择结构if语句if…else语句if…else if…else语句三目运算符switch语句（电梯模型）循环结构while语句调试QT的调试visual studio的调试do…while语句for语句死循环嵌套循环跳转语句break、continue、gotobreak语句continue语句goto语句(无条件跳转，尽量少用)（注意：有时候去了就回不来了，但是有时候也可让代码精妙绝伦）数组和字符串概述一维数组一维数组的定义和使用一维数组的初始化（初始化：定义的时候同时赋值）数组名（数组名地址是数组首元素地址）示例1：数组名是一个地址的常量，代表数组中`首元素`的地址示例2：求数组的长度，同时遍历每个数组元素（c语言没有len函数，用数组大小除以每个数组元素大小得到数组长度 `int n = sizeof(a)/sizeof(a[0])`）强化训练1) 一维数组的最值2) 一维数组的逆置（如果数组元素个数为奇数，会多交换一次）3) 冒泡法排序（每次把大的数字冒泡到右边）二维数组二维数组的定义和使用二维数组的初始化示例，数组初始化自动推导（第一维度：`sizeof(a)/sizeof(a[0])` 第二维度：`sizeof(a[0])/sizeof(a[0][0])`）数组名强化训练多维数组(了解)字符数组`char a[]`与字符串 `char a[, , , , , ... , '\0']`字符数组与字符串区别字符串的初始化字符串的输入输出强化训练：字符串追加（重要）函数的调用：产生随机数（用系统时间做种子产生随机数 `time_t time(NULL) rand() srand()`）字符串处理函数1) gets() （从键盘获取输入字符【可含空格】，遇换行符结束）（被抛弃了）2) fgets()（可指定字符数获取键盘输入字符，不够的话会取到换行符，超出字符的话只截取指定字符数）3) puts()（输出字符串，能自动换行，但不能像printf那样用%格式化其他数据类型再输出）4) fputs()（也是输出内容，但不止输出到屏幕，也能指定输出到某个文件）5) strlen()（计算字符串长度，但遇到`\0`会结束，感觉还不如用`sizeof`呢）6) strcpy（拷贝字符串，遇到结束符`\0`将停止拷贝，不能指定拷贝字符串长度）7) strncpy()（拷贝字符串，遇到结束符`\0`将停止拷贝，能指定拷贝字符串长度）8) strcat()（字符串追加）9) strncat()（字符串追加，n个字符）10) strcmp()（按ascii码逐个比较字符串中的字符）11) strncmp()（按ascii码逐个比较字符串中的前n个字符）12) sprintf()（将格式化字符串输出到指定数组，返回值是实际格式化字符个数，失败返回 -1）（组包）13) sscanf()（从字符串中以指定格式提取字符，提取字符串%s默认以空格分割，以逗号分割不行，提取数字%d可以以逗号分割）（拆包）14) strchr()（字符类型查询）（int c 指字符）15) strstr()（字符串类型查询）（char * 指字符串）16) strtok()（字符串切割，一个一个返回，要用循环一个一个获取）（会破坏原来字符串，需要复制原字符串后使用）17) atoi() atof() atol()（将字符串转换成整型、浮点、长整型）函数概述函数分类函数的作用函数的定义函数定义格式函数名字、形参、函数体、返回值1) 函数名2) 形参列表3) 函数体4) 返回值函数的调用函数执行流程1)进入main()函数2)调用print_test()函数：3)print_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。函数的形参和实参无参函数调用有参函数调用函数返回值 return函数的声明函数定义和声明的区别：main函数与exit函数多文件(分文件)编程分文件编程防止头文件重复包含怎么看预处理后的文件（`gcc -E main.c -o main.i`）

运算符与表达式

常用运算符分类

运算符类型作用算术运算符用于处理四则运算赋值运算符用于将表达式的值赋给变量比较运算符用于表达式的比较，并返回一个真值或假值逻辑运算符用于根据表达式的值返回真值或假值位运算符用于处理数据的位运算sizeof运算符用于求字节数长度

算术运算符

运算符术语示例结果+正号+33-负号-3-3+加10 + 515-减10 - 55*乘10 * 550/除10 / 52%取模(取余)10 % 31++前自增a=2; b=++a;a=3; b=3;++后自增a=2; b=a++;a=3; b=2;--前自减a=2; b=--a;a=1; b=1;--后自减a=2; b=a--;a=1; b=2;

两个数相除，要想得到小数，分子分母必须有一个是小数，否则结果只会取整（可以把其中一个数乘以1.0）

示例：

#include <stdio.h>int main(){int a = 5;int b = 2;double c;double d;c= a/b;d = a*1.0/b;printf("%lf\n", c);//2.000000printf("%lf\n", d);//2.500000return 0;}

前自增和后自增区别

b = a++ 是先把 a 的值赋给b，再自身+1

#include <stdio.h>int main(){int a;int b;//后置++a = 1;b = 0;b = a++;printf("%d %d\n", a, b);//2 1//前置++a = 1;b = 0;b = ++a;printf("%d %d\n", a ,b);//2 2//其他a = 1;b = 0;a++;//++a也一样的b = a;printf("%d %d\n", a ,b);//2 2return 0;}

赋值运算符

运算符术语示例结果=赋值a=2; b=3;a=2; b=3;+=加等于a=0; a+=2;a=2;-=减等于a=5; a-=3;a=2;*=乘等于a=2; a*=2;a=4;/=除等于a=4; a/=2;a=2;%=模等于a=3; a%2;a=1;

比较运算符

C 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。

运算符术语示例结果==相等于4 == 30!=不等于4 != 31<小于4 < 30>大于4 > 31<=小于等于4 <= 30>=大于等于4 >= 11

逻辑运算符

逻辑运算中，只要不为0都为真

运算符 术语 示例 结果

! 非 !a 如果a为假，则!a为真；

如果a为真，则!a为假。

&& 与 a && b 如果a和b都为真，则结果为真，否则为假。

|| 或 a || b 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

逻辑优化示例

//Dontla#include <stdio.h>int main(){int c = 0;1 || (c = 250);printf("%d\n", c);//0c = 0;0 || (c = 250);printf("%d\n", c);//250return 0;}

运算符优先级

注意特殊情况：

b = a++; 跟 b = (a++);等价，不会因为括号而影响结果

类型转换

数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题。

转换的方法有两种：

自动转换(隐式转换)：遵循一定的规则,由编译系统自动完成。强制类型转换：把表达式的运算结果强制转换成所需的数据类型。

类型转换的原则：占用内存字节数少(值域小)的类型，向占用内存字节数多(值域大)的类型转换，以保证精度不降低。

隐式类型转换

示例1：

#include <stdio.h>int main(){int num = 5;printf("s1=%d\n", num / 2);//s1=2printf("s2=%lf\n", num / 2.0);//s2=2.500000return 0;}

示例2：

#include <stdio.h>int main(){double a;int b = 10;a = b;printf("%lf\n", a);//10.000000return 0;}

强制类型转换

强制类型转换指的是使用强制类型转换运算符，将一个变量或表达式转化成所需的类型，其基本语法格式如下所示：

(类型说明符) (表达式)

示例1：

#include <stdio.h>int main(){float x = 0;int i = 0;x = 3.6f;i = x;//x为实型, i为整型，直接赋值会有警告i = (int)x;//使用强制类型转换printf("x=%f, i=%d\n", x, i);//x=3.600000, i=3return 0;}

示例2：

#include <stdio.h>int main(){double a;a = (double)1/2;printf("%lf\n", a);//0.500000printf("%lu\n", sizeof(int));//4printf("%u\n", (unsigned int)sizeof(int));//4int b = 12;printf("%lf\n", (double)b);//12.000000return 0;}

发现同样的代码在不同编译器运行结果还不一样

linux上：

windows QT上：

程序流程结构

概述

C语言支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。

顺序结构：程序按顺序执行，不发生跳转。选择结构：依据是否满足条件，有选择的执行相应功能。循环结构：依据条件是否满足，循环多次执行某段代码。

选择结构

if语句

注意：

1、果if 语句不加{}，则只有后面第一句代码属于if 语句

2、判断时最好变量放常量放左边（防止少写一个等号导致难以找出错误所在）

#include <stdio.h>int main(){int a = 1;int b = 2;if (a > b){printf("%d\n", a);}return 0;}

/video/BV1jW411K7v2/?spm_id_from=autoNext

if…else语句

#include <stdio.h>int main(){int a;int b;printf("请输入a的值：");scanf("%d", &a);printf("请输入b的值：");scanf("%d", &b);if (a > b){printf("%d\n", a);}else{printf("%d\n", b);}return 0;}

结果：

if…else if…else语句

#include <stdio.h>int main(){unsigned int a;scanf("%u", &a);if (a < 10){printf("个位\n");}else if (a < 100){printf("十位\n");}else if (a < 1000){printf("百位\n");}else{printf("很大\n");}return 0;}

结果：

三目运算符

#include <stdio.h>int main(){int a = 10;int b = 20;int c;if (a > b){c = a;}else{c = b;}printf("c1 = %d\n", c);//c1 = 20a = 1;b = 2;c = ( a > b ? a : b );printf("c2 = %d\n", c);//c2 = 2return 0;}

switch语句（电梯模型）

#include <stdio.h>int main(){char c;c = getchar();switch (c) //参数只能是整型变量{case '1':printf("OK\n");break;//switch遇到break就中断了case '2':printf("not OK\n");break;default://如果上面的条件都不满足，那么执行defaultprintf("are u ok?\n");}return 0;}

结果：

循环结构

while语句

#include <stdio.h>int main(){int a = 20;while (a > 10){scanf("%d", &a);printf("a = %d\n", a);}return 0;}

结果：

调试

QT的调试

qt creator创建cmake构建的程序，无法启动调试（点左下角运行不出结果 No executable specified.）

visual studio的调试

跟qt调试基本上是一样的操作，F9打断点，F5启动调试，F10逐步调试，F11进入函数

do…while语句

#include <stdio.h>int main(){int a = 1;do{a++;printf("a = %d\n", a);} while (a < 10);return 0;}

结果：

a = 2a = 3a = 4a = 5a = 6a = 7a = 8a = 9a = 10

for语句

#include <stdio.h>int main(){int i;int sum = 0;for (i = 0; i <= 100; i++){sum += i;}printf("sum = %d\n", sum);//sum = 5050return 0;}

其实也可以这样：

死循环

嵌套循环

循环语句之间可以相互嵌套：

#include <stdio.h>int main(){int num = 0;int i, j, k;for (i = 0; i < 10; i++){for (j = 0; j < 10; j++){for (k = 0; k < 10; k++){printf("hello world\n");num++;}}}printf("num = %d\n", num);return 0;}

结果：

跳转语句break、continue、goto

break语句

在switch条件语句和循环语句中都可以使用break语句：

当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出当前内循环语句，执行后面的代码。当它出现在嵌套循环语句中，跳出最近的内循环语句，执行后面的代码。

#include <stdio.h>int main(){int i = 0;while (1){i++;printf("i = %d\n", i);if (i == 10){break; //跳出while循环}}int flag = 0;int m = 0;int n = 0;for (m = 0; m < 10; m++){for (n = 0; n < 10; n++){if (n == 5){flag = 1;break; //跳出for (n = 0; n < 10; n++)}}if (flag == 1){break; //跳出for (m = 0; m < 10; m++)}}return 0;}

continue语句

在循环语句中，如果希望立即终止本次循环，并执行下一次循环，此时就需要使用continue语句。

示例：求0-100所有奇数的和

#include<stdio.h>int main(){int sum = 0; //定义变量sumfor (int i = 1; i <= 100; i++){if (i % 2 == 0) //如果i是一个偶数，执行if语句中的代码{continue;//结束本次循环}sum += i;//实现sum和i的累加}printf("sum = %d\n", sum);//sum = 2500return 0;}

goto语句(无条件跳转，尽量少用)（注意：有时候去了就回不来了，但是有时候也可让代码精妙绝伦）

#include <stdio.h>int main(){goto End; //无条件跳转到End的标识printf("aaaaaaaaa\n");End:printf("bbbbbbbb\n");return 0;}

数组和字符串

概述

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。

数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。

数组属于构造数据类型：

一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。

int a[10]; struct Stu boy[10];

按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。

int a[10];char s[10];char *p[10];

通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。

一维数组

一维数组的定义和使用

数组名字符合标识符的书写规定(数字、英文字母、下划线)数组名不能与其它变量名相同，同一作用域内是唯一的方括号[]中常量表达式表示数组元素的个数

可以使用常量定义数组大小：define SIZE 10

示例： 用宏定义常量创建一个数组，并给数组元素赋值

#include <stdio.h>#define SIZE 10int main(){int a[SIZE];int i;for (i = 0; i <10; i ++){a[i] = i;printf("a[%d] = %d\n", i, a[i]);}printf("%d\n", i);return 0;}

int a[3]表示数组a有3个元素其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]

定义数组时[]内最好是常量，使用数组时[]内即可是常量，也可以是变量

示例2：

#include <stdio.h>int main(){int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型//a[0]…… a[9]，没有a[10]//没有a这个变量，a是数组的名字，但不是变量名，它是常量a[0] = 0;//……a[9] = 9;int i = 0;for (i = 0; i < 10; i++){a[i] = i; //给数组赋值}//遍历数组，并输出每个成员的值for (i = 0; i < 10; i++){printf("%d ", a[i]);}printf("\n");return 0;}

结果：

0 1 2 3 4 5 6 7 8 9

注意：数组下标越界错误在某些编译器上是不能及时发现的

一维数组的初始化（初始化：定义的时候同时赋值）

在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。

int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量int a[10] = {1, 2, 3 };//初始化前三个成员，后面所有元素都设置为0int a[10] = {0 };//所有的成员都设置为0//[]中不定义元素个数，定义时必须初始化int a[] = {1, 2, 3, 4, 5 };//定义了一个数组，有5个成员

示例：初始化为随机数

#include <stdio.h>int main(){int a[10];for (int i =0; i<10; i ++){printf("%d\n", a[i]);}return 0;}

结果：

-155364562432604369074640219960036907430421996-55992236832765

数组名（数组名地址是数组首元素地址）

示例1：数组名是一个地址的常量，代表数组中首元素的地址

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

示例2：求数组的长度，同时遍历每个数组元素（c语言没有len函数，用数组大小除以每个数组元素大小得到数组长度int n = sizeof(a)/sizeof(a[0])）

#include <stdio.h>int main(){int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量printf("a = %p\n", a);printf("&a[0] = %p\n", &a[0]);int n = sizeof(a); //数组占用内存的大小，10个int类型，10 * 4 = 40int n0 = sizeof(a[0]);//数组第0个元素占用内存大小，第0个元素为int，4int i = 0;for (i = 0; i < sizeof(a) / sizeof(a[0]); i++){printf("%d ", a[i]);}printf("\n");return 0;}

强化训练

1) 一维数组的最值

#include <stdio.h>int main(){int a[] = {1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量int i = 0;int max = a[0];for (i = 0; i < sizeof(a) / sizeof(a[0]); i++){if (a[i] > max){max = a[i];}}printf("数组中最大值为：%d\n", max);//数组中最大值为：10return 0;}

2) 一维数组的逆置（如果数组元素个数为奇数，会多交换一次）

#include <stdio.h>int main(){int a[] = {1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量int i = 0;int j = sizeof(a) / sizeof(a[0]) -1;int tmp;while (i < j){tmp = a[i];a[i] = a[j];a[j] = tmp;i++;j--;}for (i = 0; i < sizeof(a) / sizeof(a[0]); i++){printf("%d ", a[i]);}printf("\n");return 0;}

结果：

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

3) 冒泡法排序（每次把大的数字冒泡到右边）

#include <stdio.h>int main(){int a[] = {1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量int i = 0;int j = 0;int n = sizeof(a) / sizeof(a[0]);int tmp;//1、流程//2、试数for (i = 0; i < n-1; i++){for (j = 0; j < n - i -1 ; j++)//内循环的目的是比较相邻的元素，把大的放到后面{if (a[j] > a[j + 1]){tmp = a[j];a[j] = a[j+1];a[j+1] = tmp;}}}for (i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");return 0;}

结果：

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

二维数组

二维数组的定义和使用

二维数组定义的一般形式是：

类型说明符 数组名[常量表达式1][常量表达式2]

其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。

int a[3][4];

命名规则同一维数组

定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：

二维数组a是按行进行存放的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。

二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。

在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。

#include <stdio.h>int main(){//定义了一个二维数组，名字叫a//由3个一维数组组成，这个一维数组是int [4]//这3个一维数组的数组名分别为a[0],a[1],a[2]int a[3][4];a[0][0] = 0;//……a[2][3] = 12;//给数组每个元素赋值int i = 0;int j = 0;int num = 0;for (i = 0; i < 3; i++){for (j = 0; j < 4; j++){a[i][j] = num++;}}//遍历数组，并输出每个成员的值for (i = 0; i < 3; i++){for (j = 0; j < 4; j++){printf("%d, ", a[i][j]);}printf("\n");}return 0;}

结果：

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,

二维数组的初始化

//分段赋值 int a[3][4] = {{ 1, 2, 3, 4 },{ 5, 6, 7, 8, },{ 9, 10, 11, 12 }};int a[3][4] = {{1, 2, 3, 4 },{5, 6, 7, 8, },{9, 10, 11, 12 }};//连续赋值int a[3][4] = {1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };//可以只给部分元素赋初值，未初始化则为0int a[3][4] = {1, 2, 3, 4 };//所有的成员都设置为0int a[3][4] = {0};//[]中不定义元素个数，定义时必须初始化（不能直接：int a[][4];，会报错）int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8};

示例，数组初始化自动推导（第一维度：sizeof(a)/sizeof(a[0])第二维度：sizeof(a[0])/sizeof(a[0][0])）

#include <stdio.h>int main(){int a[][4] = {1,2,3,4,5,6,7,8};int n = sizeof(a)/sizeof(a[0][0]);printf("%d\n", n);//8printf("%ld\n", sizeof(a)/sizeof(a[0]));//2printf("%ld\n", sizeof(a[0])/sizeof(a[0][0]));//4for(int i =0; i < sizeof(a)/sizeof(a[0]); i++){for(int j =0; j < sizeof(a[0])/sizeof(a[0][0]); j++){printf("%d ", a[i][j]);}}printf("\n");return 0;}

结果：

数组名

数组名是一个地址的常量，代表数组中首元素的地址。

#include <stdio.h>int main(){//定义了一个二维数组，名字叫a//二维数组是本质上还是一维数组，此一维数组有3个元素//每个元素又是一个一维数组int[4]int a[3][4] = {1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12 };//数组名为数组首元素地址，二维数组的第0个元素为一维数组//第0个一维数组的数组名为a[0]printf("a = %p\n", a);//a = 0x7ffe7750a0a0printf("a[0] = %p\n", a[0]);//a[0] = 0x7ffe7750a0a0//测二维数组所占内存空间，有3个一维数组，每个一维数组的空间为4*4//sizeof(a) = 3 * 4 * 4 = 48printf("sizeof(a) = %ld\n", sizeof(a));//sizeof(a) = 48//测第0个元素所占内存空间，a[0]为第0个一维数组int[4]的数组名，4*4=16printf("sizeof(a[0]) = %ld\n", sizeof(a[0]) );//sizeof(a[0]) = 16//测第0行0列元素所占内存空间，第0行0列元素为一个int类型，4字节printf("sizeof(a[0][0]) = %ld\n", sizeof(a[0][0]));//sizeof(a[0][0]) = 4//求二维数组行数printf("i = %ld\n", sizeof(a) / sizeof(a[0]));//i = 3// 求二维数组列数printf("j = %ld\n", sizeof(a[0]) / sizeof(a[0][0]));//j = 4//求二维数组行*列总数printf("n = %ld\n", sizeof(a) / sizeof(a[0][0]));//n = 12return 0;}

强化训练

#include <stdio.h>int main(){//二维数组： 五行、三列//行代表人： 老大到老五//列代表科目：语、数、外float a[5][3] = {{80, 75, 56 }, {59, 65, 71 }, {59, 63, 70 }, {85, 45, 90 }, {76, 77, 45 } };int i, j, person_low[3] = {0 };float s = 0, lesson_aver[3] = {0 };for (i = 0; i < 3; i++){for (j = 0; j < 5; j++){s = s + a[j][i];if (a[j][i] < 60){person_low[i]++;}}lesson_aver[i] = s / 5;s = 0;}printf("各科的平均成绩:\n");for (i = 0; i < 3; i++){printf("%.2f\n", lesson_aver[i]);}printf("各科不及格的人数:\n");for (i = 0; i < 3; i++){printf("%d\n", person_low[i]);}return 0;}

结果：

多维数组(了解)

多维数组的定义与二维数组类似，其语法格式具体如下：

数组类型修饰符 数组名 [n1][n2]…[nn];

int a[3][4][5];

定义了一个三维数组，数组的名字是a，数组的长度为3，每个数组的元素又是一个二维数组，这个二维数组的长度是4，并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int。

#include <stdio.h>int main(){//int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]int a[3][4][5] = {{{1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 }, {0 }, {0 } }, {{0 }, {0 }, {0 }, {0 } }, {{0 }, {0 }, {0 }, {0 } } };int i, j, k;for (i = 0; i < 3; i++){for (j = 0; j < 4; j++){for (k = 0; k < 5; k++){//添加访问元素代码printf("%d, ", a[i][j][k]);}printf("\n");}}return 0;}

字符数组char a[]与字符串char a[, , , , , ... , '\0']

字符数组与字符串区别

C语言中没有字符串这种数据类型，可以通过char的数组来替代；字符串一定是一个char的数组，但char的数组未必是字符串；数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。

用%s打印字符数组时，会给它一个字符数组名地址，然后系统就一个字符一个字符打印，遇到'\0'就结束，如果没有结束字符，后面打印就会出现一堆乱码（\0就是数字0）

#include <stdio.h>int main(){char c1[] = {'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组printf("c1 = %s\n", c1); //c1 = c progUڋ //乱码，因为没有’\0’结束符//以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串char c2[] = {'c', ' ', 'p', 'r', 'o', 'g', '\0'}; printf("c2 = %s\n", c2);//c2 = c prog//字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出char c3[] = {'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};printf("c3 = %s\n", c3);//c3 = c progreturn 0;}

注意事项：

{‘a’, ‘b’, ‘c’, '\0'}或{‘a’, ‘b’, ‘c’, 0}相当于“abc”

字符串的初始化

#include <stdio.h>// C语言没有字符串类型，通过字符数组模拟// C语言字符串，以字符‘\0’结束, 就是数字0int main(){//不指定长度, 没有0结束符，有多少个元素就有多长char buf[] = {'a', 'b', 'c' };printf("buf = %s\n", buf);//abc̊XP//乱码（有的编译器不会出现乱码，但不代表能这样用）//指定长度，后面没有赋值的元素，自动补0char buf2[100] = {'a', 'b', 'c' };printf("buf2 = %s\n", buf2);//buf2 = abc//所有元素赋值为0char buf3[100] = {0 };//char buf4[2] = { '1', '2', '3' };//数组越界char buf5[50] = {'1', 'a', 'b', '0', '7' };printf("buf5 = %s\n", buf5);//buf5 = 1ab07char buf6[50] = {'1', 'a', 'b', 0, '7' };printf("buf6 = %s\n", buf6);//buf6 = 1abchar buf7[50] = {'1', 'a', 'b', '\0', '7' };printf("buf7 = %s\n", buf7);//buf7 = 1ab//使用字符串初始化，编译器自动在后面补0，常用char buf8[] = "agjdslgjlsdjg";//'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符//'\ddd'八进制字义字符，'\xdd'十六进制转义字符// \012相当于\nchar str[] = "\012abc";printf("str == %s\n", str);return 0;}

最后一个结果：

字符串的输入输出

由于字符串采用了’\0’标志，字符串的输入输出将变得简单方便。

#include <stdio.h>int main(){char str[100];printf("input string1 : \n");scanf("%s", str);//scanf(“%s”,str)默认以空格分隔printf("output:%s\n", str);return 0;}

强化训练：字符串追加（重要）

#include <stdio.h>int main(){char str1[] = "abcdef";char str2[] = "123456";char dst[13];int i = 0;while (str1[i] != 0){dst[i] = str1[i];i++;}int j = 0;while (str2[j] != 0){dst[i + j] = str2[j];j++;}dst[i + j] = 0; //字符串结束符（也可写成'\0'）printf("dst = %s\n", dst);printf("\n");printf("%ld\n", sizeof(dst));printf("%ld\n", sizeof(dst[0]));printf("\n");for(int k = 0; k < sizeof(dst)/sizeof(dst[0]); k++){printf("%c\n", dst[k]);printf("%d\n", dst[k]);printf("\n");}return 0;}

结果：

dst = abcdef123456131a97b98c99d100e101f1021492503514525536540

注意：结束符就是数字零

函数的调用：产生随机数（用系统时间做种子产生随机数time_t time(NULL) rand() srand()）

当调用函数时，需要关心5要素：

头文件：包含指定的头文件函数名字：函数名字必须和头文件声明的名字一样功能：需要知道此函数能干嘛后才调用参数：参数类型要匹配返回值：根据需要接收返回值

#include <time.h>time_t time(time_t *t);功能：获取当前系统时间参数：常设置为NULL返回值：当前系统时间, time_t 相当于long类型，单位为毫秒#include <stdlib.h>void srand(unsigned int seed);功能：用来设置rand()产生随机数时的随机种子参数：如果每次seed相等，rand()产生随机数相等返回值：无#include <stdlib.h>int rand(void);功能：返回一个随机数值参数：无返回值：随机数

#include <stdio.h>#include <time.h>#include <stdlib.h>int main(){time_t tm = time(NULL);//得到系统时间printf("%ld\n", sizeof(tm));//8srand((unsigned int)tm);//随机种子只需要设置一次即可int r = rand();printf("r = %d\n", r);return 0;}

字符串处理函数

1) gets() （从键盘获取输入字符【可含空格】，遇换行符结束）（被抛弃了）

#include <stdio.h>char *gets(char *s);功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。参数：s：字符串首地址返回值：成功：读入的字符串失败：NULL

gets(str)与scanf(“%s”,str)的区别：

gets(str)允许输入的字符串含有空格scanf(“%s”,str)不允许含有空格

注意：由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。

#include <stdio.h>#include <time.h>#include <stdlib.h>int main(){char str[100];printf("请输入str: ");gets(str);printf("str = %s\n", str);return 0;}

结果：

2) fgets()（可指定字符数获取键盘输入字符，不够的话会取到换行符，超出字符的话只截取指定字符数）

#include <stdio.h>char *fgets(char *s, int size, FILE *stream);功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。参数：s：字符串size：指定最大读取字符串的长度（size - 1）stream：文件指针，如果读键盘输入的字符串，固定写为stdin返回值：成功：成功读取的字符串读到文件尾或出错： NULL

fgets()在读取一个用户通过键盘输入的字符串的时候，同时把用户输入的回车也做为字符串的一部分。通过scanf和gets输入一个字符串的时候，不包含结尾的“\n”，但通过fgets结尾多了“\n”。fgets()函数是安全的，不存在缓冲区溢出的问题。

#include <stdio.h>#include <time.h>#include <stdlib.h>int main(){char str[10];printf("%ld\n", sizeof(str));//10，只会输出9个字符，留一个放结束符0printf("请输入str: ");fgets(str, sizeof(str), stdin);printf("str = \"%s\"\n", str);}

3) puts()（输出字符串，能自动换行，但不能像printf那样用%格式化其他数据类型再输出）

#include <stdio.h>int puts(const char *s);功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。参数：s：字符串首地址返回值：成功：非负数失败：-1

#include <stdio.h>int main(){printf("hello world\n");puts("hello world");return 0;}

4) fputs()（也是输出内容，但不止输出到屏幕，也能指定输出到某个文件）

#include <stdio.h>int fputs(const char * str, FILE * stream);功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0' 不写入文件。 参数：str：字符串stream：文件指针，如果把字符串输出到屏幕，固定写为stdout返回值：成功：0失败：-1

fputs()是puts()的文件操作版本，但fputs()不会自动输出一个’\n’。

#include <stdio.h>int main(){printf("hello world\n");puts("hello world");fputs("hello world\n", stdout);}

结果：

5) strlen()（计算字符串长度，但遇到\0会结束，感觉还不如用sizeof呢）

#include <string.h>size_t strlen(const char *s);功能：计算指定指定字符串s的长度，不包含字符串结束符‘\0’参数：s：字符串首地址返回值：字符串s的长度，size_t为unsigned int类型

#include <stdio.h>#include <string.h>int main(){char str[] = "abcdefg";printf("%ld\n", sizeof(str));//8int n = strlen(str);printf("n = %d\n", n);//n = 7char str2[] = "\0abcdefg";printf("%ld\n", sizeof(str2));//9printf("n = %ld\n", strlen(str2));//n = 0}

6) strcpy（拷贝字符串，遇到结束符\0将停止拷贝，不能指定拷贝字符串长度）

#include <string.h>char *strcpy(char *dest, const char *src);功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去参数：dest：目的字符串首地址src：源字符首地址返回值：成功：返回dest字符串的首地址失败：NULL

注意：如果参数dest所指的内存空间不够大，可能会造成缓冲溢出的错误情况。（在visual studio中会表现出来）

#include <stdio.h>#include <string.h>int main(){char src[] = "abcdefg\0dgf3";char dst[20];strcpy(dst, src);printf("%s\n", dst);//abcdefgprintf("%d %c\n", dst[6],dst[6]);//103 gprintf("%d %c\n", dst[7],dst[7]);//0printf("%d %c\n", dst[8],dst[8]);//-64（不知道为什么一直是这个结果，结束符后面不都是随机的吗？）printf("%d %c\n", dst[9],dst[9]);//随机printf("%d %c\n", dst[10],dst[10]);//随机return 0;}

结果：

7) strncpy()（拷贝字符串，遇到结束符\0将停止拷贝，能指定拷贝字符串长度）

#include <string.h>char *strncpy(char *dest, const char *src, size_t n);功能：把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。参数：dest：目的字符串首地址src：源字符首地址n：指定需要拷贝字符串个数返回值：成功：返回dest字符串的首地址失败：NULL

#include <stdio.h>#include <string.h>int main(){char src[] = "abcdefg\0";char dst[20];char dst2[20];strncpy(dst, src, strlen(src)+1);strncpy(dst2, src, sizeof(src));printf("%s\n", dst);printf("%s\n", dst2);return 0;}

8) strcat()（字符串追加）

#include <string.h>char *strcat(char *dest, const char *src);功能：将src字符串连接到dest的尾部，‘\0’也会追加过去参数：dest：目的字符串首地址src：源字符首地址返回值：成功：返回dest字符串的首地址失败：NULL#include <stdio.h>#include <string.h>int main(){char str[20] = "123";char *src = "hello world";printf("%s\n", strcat(str, src));return 0;}

结果：

123hello world

9) strncat()（字符串追加，n个字符）

#include <string.h>char *strncat(char *dest, const char *src, size_t n);功能：将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去参数：dest：目的字符串首地址src：源字符首地址n：指定需要追加字符串个数返回值：成功：返回dest字符串的首地址失败：NULL#include <stdio.h>#include <string.h>int main(){char str[20] = "123";char *src = "hello world";printf("%s\n", strncat(str, src, 7));return 0;}

123hello w

10) strcmp()（按ascii码逐个比较字符串中的字符）

#include <string.h>int strcmp(const char *s1, const char *s2);功能：比较 s1 和 s2 的大小，比较的是字符ASCII码大小。参数：s1：字符串1首地址s2：字符串2首地址返回值：相等：0大于：>0小于：<0

#include <stdio.h>#include <string.h>int main(){char *str1 = "hello world";char *str2 = "hello mike";if (strcmp(str1, str2) == 0){printf("str1==str2\n");}else if (strcmp(str1, str2) > 0){printf("str1>str2\n");}else{printf("str1<str2\n");}return 0;}

结果：

str1>str2

11) strncmp()（按ascii码逐个比较字符串中的前n个字符）

#include <string.h>int strncmp(const char *s1, const char *s2, size_t n);功能：比较 s1 和 s2 前n个字符的大小，比较的是字符ASCII码大小。参数：s1：字符串1首地址s2：字符串2首地址n：指定比较字符串的数量返回值：相等：0大于： > 0小于： < 0

#include <stdio.h>#include <string.h>int main(){char *str1 = "hello world";char *str2 = "hello mike";int i = strncmp(str1, str2, 7);if (i == 0){printf("str1==str2\n");}else if (i > 0){printf("str1>str2\n");}else{printf("str1<str2\n");}return 0;}

结果：

str1>str2

12) sprintf()（将格式化字符串输出到指定数组，返回值是实际格式化字符个数，失败返回 -1）（组包）

#include <stdio.h>int sprintf(char *str, const char *format, ...);功能：根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符 '\0' 为止。参数：str：字符串首地址format：字符串格式，用法和printf()一样返回值：成功：实际格式化的字符个数失败： - 1

#include <stdio.h>#include <string.h>int main(){char dst[100] = {0 };int a = 10;char src[] = "hello world";printf("a = %d, src = %s", a, src);printf("\n");int len = sprintf(dst, "a = %d, src = %s", a, src);printf("dst = \"%s\"\n", dst);printf("len = %d\n", len);return 0;}

结果：

a = 10, src = hello worlddst = "a = 10, src = hello world"len = 25

13) sscanf()（从字符串中以指定格式提取字符，提取字符串%s默认以空格分割，以逗号分割不行，提取数字%d可以以逗号分割）（拆包）

#include <stdio.h>int sscanf(const char *str, const char *format, ...);功能：从str指定的字符串读取数据，并根据参数format字符串来转换并格式化数据。参数：str：指定的字符串首地址format：字符串格式，用法和scanf()一样返回值：成功：参数数目，成功转换的值的个数失败： - 1

#include <stdio.h>#include <string.h>int main(){char src[] = "a=10, b=20";int a;int b;sscanf(src, "a=%d, b=%d", &a, &b);printf("a:%d, b:%d\n", a, b);char src2[] = "sdf dom mike";char a1[10];char b1[10];char c1[10];sscanf(src2, "%s %s %s", a1, b1, c1);//不能取地址&printf("%s %s %s\n", a1, b1, c1 );return 0;}

结果：

a:10, b:20sdf dom mike

14) strchr()（字符类型查询）（int c 指字符）

#include <string.h>char *strchr(const char *s, int c);功能：在字符串s中查找字母c出现的位置参数：s：字符串首地址c：匹配字母(字符)返回值：成功：返回第一次出现的c地址失败：NULL

#include <stdio.h>#include <string.h>int main(){char src[] = "ddda123abcd";char *p = strchr(src, 'a');printf("p = %s\n", p);//p = a123abcdreturn 0;}

15) strstr()（字符串类型查询）（char * 指字符串）

#include <string.h>char *strstr(const char *haystack, const char *needle);功能：在字符串haystack中查找字符串needle出现的位置参数：haystack：源字符串首地址needle：匹配字符串首地址返回值：成功：返回第一次出现的needle地址失败：NULL

#include <stdio.h>#include <string.h>int main(){char src[] = "ddddabcd123abcd333abcd";char *p = strstr(src, "abcd");printf("p = %s\n", p);//p = abcd123abcd333abcdreturn 0;}

16) strtok()（字符串切割，一个一个返回，要用循环一个一个获取）（会破坏原来字符串，需要复制原字符串后使用）

#include <string.h>char *strtok(char *str, const char *delim);功能：来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0。参数：str：指向欲分割的字符串delim：为分割字符串中包含的所有字符返回值：成功：分割后字符串首地址失败：NULL

在第一次调用时：strtok()必需给予参数s字符串往后的调用则将参数s设置成NULL，每次调用成功则返回指向被分割出片段的指针

#include <stdio.h>#include <string.h>int main(){char a[100] = "adc*fvcv*ebcy*hghbdfg*casdert";char temp[100];strcpy(temp, a);char *s = strtok(temp, "*");//将"*"分割的子串取出while (s != NULL){printf("%s\n", s);s = strtok(NULL, "*");}return 0;}

结果：

adcfvcvebcyhghbdfgcasdert

17) atoi() atof() atol()（将字符串转换成整型、浮点、长整型）

#include <stdlib.h>int atoi(const char *nptr);功能：atoi()会扫描nptr字符串，跳过前面的空格字符，直到遇到数字或正负号才开始做转换，而遇到非数字或字符串结束符('\0')才结束转换，并将结果返回返回值。参数：nptr：待转换的字符串返回值：成功转换后整数

类似的函数有：

atof()：把一个小数形式的字符串转化为一个浮点数。atol()：将一个字符串转化为long类型

#include <stdio.h>#include <string.h>#include <stdlib.h>int main(){char str1[] = " -10ds hjk 55";int num1 = atoi(str1);printf("num1 = %d\n", num1);char str2[] = "0.123";double num2 = atof(str2);printf("num2 = %lf\n", num2);return 0;}

结果：

函数

概述

函数分类

C 程序是由函数组成的，我们写的代码都是由主函数 main()开始执行的。函数是 C 程序的基本模块，是用于完成特定任务的程序代码单元。

从函数定义的角度看，函数可分为系统函数和用户定义函数两种：

系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。用户定义函数：用以解决用户的专门需要。

函数的作用

函数的使用可以省去重复代码的编写，降低代码重复率

// 求两数的最大值#include <stdio.h>#include <string.h>#include <stdlib.h>int max(int a, int b){if (a > b){return a;}else{return b;}}int main(){// 操作1 ……// ……int a1 = 10, b1 = 20, c1 = 0;c1 = max(a1, b1); // 调用max()printf("%d\n", c1);//20// 操作2 ……// ……int a2 = 11, b2 = 21, c2 = 0;c2 = max(a2, b2); // 调用max()printf("%d\n", c2);21// ……return 0;}

函数可以让程序更加模块化，从而有利于程序的阅读，修改和完善

假如我们编写一个实现以下功能的程序：读入一行数字；对数字进行排序；找到它们的平均值；打印出一个柱状图。如果我们把这些操作直接写在main()里，这样可能会给用户感觉代码会有点凌乱。但，假如我们使用函数，这样可以让程序更加清晰、模块化：

#include <stdio.h>int main(){float list[50];// 这里只是举例，函数还没有实现readlist(list, 50);sort(list, 50);average(list, 50);bargraph(list, 50);return 0;}

这里我们可以这么理解，程序就像公司，公司是由部门组成的，这个部门就类似于C程序的函数。默认情况下，公司就是一个大部门( 只有一个部门的情况下 )，相当于C程序的main()函数。如果公司比较小( 程序比较小 )，因为任务少而简单，一个部门即可( main()函数 )胜任。但是，如果这个公司很大( 大型应用程序 )，任务多而杂，如果只是一个部门管理( 相当于没有部门，没有分工 )，我们可想而知，公司管理、运营起来会有多混乱，不是说这样不可以运营，只是这样不完美而已，如果根据公司要求分成一个个部门( 根据功能封装一个一个函数 )，招聘由行政部门负责，研发由技术部门负责等，这样就可以分工明确，结构清晰，方便管理，各部门之间还可以相互协调。

函数的定义

函数定义格式

函数定义的一般形式：

返回类型 函数名(形式参数列表){数据定义部分;执行语句部分;}

函数名字、形参、函数体、返回值

1) 函数名

理论上是可以随意起名字，最好起的名字见名知意，应该让用户看到这个函数名字就知道这个函数的功能。注意，函数名的后面有个圆换号()，代表这个为函数，不是普通的变量名。

2) 形参列表

在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参，表示它们并不是实际存在的数据，所以，形参里的变量不能赋值。

void max(int a = 10, int b = 20) // error, 形参不能赋值{}

在定义函数时指定的形参，必须是，类型+变量的形式：

//1: right, 类型+变量void max(int a, int b){}//2: error, 只有类型，没有变量void max(int, int){}//3: error, 只有变量，没有类型int a, int b;void max(a, b){}

在定义函数时指定的形参，可有可无，根据函数的需要来设计，如果没有形参，圆括号内容为空，或写一个void关键字：

// 没形参， 圆括号内容为空void max(){}// 没形参， 圆括号内容为void关键字void max(void){}

3) 函数体

花括号{ }里的内容即为函数体的内容，这里为函数功能实现的过程，这和以前的写代码没太大区别，以前我们把代码写在main()函数里，现在只是把这些写到别的函数里。

4) 返回值

函数的返回值是通过函数中的return语句获得的，return后面的值也可以是一个表达式。

a)尽量保证return语句中表达式的值和函数返回类型是同一类型。

int max() // 函数的返回值为int类型{int a = 10;return a;// 返回值a为int类型，函数返回类型也是int，匹配}

b)如果函数返回的类型和return语句中表达式的值不一致，则以函数返回类型为准，即函数返回类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

double max() // 函数的返回值为double类型{int a = 10;return a;// 返回值a为int类型，它会转为double类型再返回}

注意：如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。

c)return语句的另一个作用为中断return所在的执行函数，类似于break中断循环、switch语句一样。

int max(){return 1;// 执行到，函数已经被中断，所以下面的return 2无法被执行到return 2;// 没有执行}

d)如果函数带返回值，return后面必须跟着一个值，如果函数没有返回值，函数名字的前面必须写一个void关键字，这时候，我们写代码时也可以通过return中断函数(也可以不用)，只是这时，return后面不带内容( 分号“；”除外)。

void max()// 最好要有void关键字{return; // 中断函数，这个可有可无}

函数的调用

定义函数后，我们需要调用此函数才能执行到这个函数里的代码段。这和main()函数不一样，main()为编译器设定好自动调用的主函数，无需人为调用，我们都是在main()函数里调用别的函数，一个 C 程序里有且只有一个main()函数。

函数执行流程

#include <stdio.h>void print_test(){printf("this is for test\n");}int main(){print_test();// print_test函数的调用return 0;}

1)进入main()函数

2)调用print_test()函数：

a.它会在main()函数的前面寻找有没有一个名字叫“print_test”的函数定义；

b.如果找到，接着检查函数的参数，这里调用函数时没有传参，函数定义也没有形参，参数类型匹配；

c.开始执行print_test()函数，这时候，main()函数里面的执行会阻塞( 停 )在print_test()这一行代码，等待print_test()函数的执行。

3)print_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。

函数的形参和实参

形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。实参出现在主调函数中，进入被调函数后，实参也不能使用。实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放。实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。

无参函数调用

如果是调用无参函数，则不能加上“实参”，但括号不能省略。

// 函数的定义void test(){}int main(){// 函数的调用test();// right, 圆括号()不能省略test(250); // error, 函数定义时没有参数return 0;}

有参函数调用

a)如果实参表列包含多个实参，则各参数间用逗号隔开。

// 函数的定义void test(int a, int b){}int main(){int p = 10, q = 20;test(p, q);// 函数的调用return 0;}

b)实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。

c)实参可以是常量、变量或表达式，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。所以，这里的变量是在圆括号( )外面定义好、赋好值的变量。

// 函数的定义void test(int a, int b){}int main(){// 函数的调用int p = 10, q = 20;test(p, q);// righttest(11, 30 - 10); // righttest(int a, int b); // error, 不应该在圆括号里定义变量return 0;}

函数返回值 return

a）如果函数定义没有返回值，函数调用时不能写void关键字，调用函数时也不能接收函数的返回值。

// 函数的定义void test(){}int main(){// 函数的调用test(); // rightvoid test(); // error, void关键字只能出现在定义，不可能出现在调用的地方int a = test();// error, 函数定义根本就没有返回值return 0;}

b）如果函数定义有返回值，这个返回值我们根据用户需要可用可不用，但是，假如我们需要使用这个函数返回值，我们需要定义一个匹配类型的变量来接收。

// 函数的定义, 返回值为int类型int test(){}int main(){// 函数的调用int a = test(); // right, a为int类型（visual studio会报错，说函数必须返回一个值）int b;b = test();// right, 和上面等级char *p = test(); // 虽然调用成功没有意义, p为char *, 函数返回值为int, 类型不匹配// error, 必须定义一个匹配类型的变量来接收返回值// int只是类型，没有定义变量int = test();return 0;}

函数的声明

如果使用用户自己定义的函数，而该函数与调用它的函数（即主调函数）不在同一文件中，或者函数定义的位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。

所谓函数声明，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，相当于告诉编译器，函数在后面定义，以便使编译能正常进行。

注意：一个函数只能被定义一次，但可以声明多次。

1、声明时可在前面加extern关键字，加不加没有区别

2、声明不一定必须要放在main函数前，在使用前一句代码声明也是可以的（声明直接把函数定义的第一行代码后面加分号即可）

3、声明函数里的形参变量名可以跟定义的形参变量名不一样（甚至形参变量名都可以不写）

#include <stdio.h>extern int max(int, int); // 函数的声明，分号不能省略// int max(int, int); // 另一种方式int main(){int a = 10, b = 25, num_max = 0;int max(int gg, int sffd);//可在使用前声明，形参变量名随意num_max = max(a, b); // 函数的调用printf("num_max = %d\n", num_max);return 0;}// 函数的定义int max(int x, int y){return x > y ? x : y;}

结果：

num_max = 25

函数定义和声明的区别：

1）定义是指对函数功能的确立，包括指定函数名、函数类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。

2）声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意，不包括函数体)通知编译系统，以便在对包含函数调用的语句进行编译时，据此对其进行对照检查（例如函数名是否正确，实参与形参的类型和个数是否一致）。

main函数与exit函数

在main函数中调用exit和return结果是一样的，但在子函数中调用return只是代表子函数终止了，在子函数中调用exit，那么程序终止。

#include <stdio.h>#include <stdlib.h>void fun(){printf("fun\n");//return;exit(0);//exit什么数字这里结果都一样，具体不同数字含义学了系统编程再讲}int main(){fun();printf("here\n");while (1);return 0;}

结果：

多文件(分文件)编程

分文件编程

把函数声明放在头文件xxx.h中，在主函数中包含相应头文件在头文件对应的xxx.c中实现xxx.h声明的函数

示例：

main.c

//#include <stdio.h>//#include <stdlib.h>#include "my_add.h"//void my_add(int, int);//可以不用指定哪个.c文件而直接找到函数，所以一般项目中不允许存在同名函数int main(){my_add(1, 2);return 0;}

my_add.c

#include <stdio.h>void my_add(int a, int b){printf("%d\n", a + b);}

my_add.h

void my_add(int, int);

运行指令gcc *.c -o test编译并执行：

注意：

1、同个项目的多个.c文件中，不能出现同名函数（static静态函数除外）

2、.c文件是用来定义函数的，.h头文件是用来声明函数的

防止头文件重复包含

当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。

a.h 中包含 b.h ：

#include "b.h"

b.h 中包含 a.h：

#include "a.h"

main.c 中使用其中头文件：

#include "a.h"int main(){return 0;}

编译上面的例子，会出现如下错误：

为了避免同一个文件被include多次，C/C++中有两种方式，一种是 #ifndef 方式，一种是 #pragma once 方式。

方法一：

#ifndef __SOMEFILE_H__#define __SOMEFILE_H__// 声明语句#endif

关于下划线，说是一种编程风格，用不用，用几个，都不影响（意思是如果文件名为somefile.h，你可以写成SOMEFILE_H，也可以_SOMEFILE_H_，也可以_SOMEFILE_H等等）

其实，貌似只要上面下面相同，写啥都无所谓，都能实现功能：

参考文章1：#ifndef详解

参考文章2：#ifndefSTDIO_H中的下划线含义分别是什么哦

方法二：

将这个放在.h头文件最上面

#pragma once// 声明语句

怎么看预处理后的文件（gcc -E main.c -o main.i）

gcc -E main.c -o main.i

如果觉得《黑马程序员C语言基础（第五天）运算符与表达式 程序流程结构 数组和字符串 函数》对你有帮助，请点赞、收藏，并留下你的观点哦！