C语言进阶
计数排序(Counting Sort)
- 计数排序是一个非基于比较的排序算法,该算法于 1954 年由 Harold H. Seward 提出。它的优势在于在
对一定范围内的整数排序
时,快于任何比较排序算法。 - 排序思路:
- 1.找出待排序数组最大值
- 2.定义一个索引最大值为待排序数组最大值的数组
- 3.遍历待排序数组, 将待排序数组遍历到的值作新数组索引
- 4.在新数组对应索引存储值原有基础上+1
- 简单代码实现:
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 用于排序数组
int newNums[4] = {0};
// 计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 遍历待排序数组
for(int i = 0; i < len; i++){
// 取出待排序数组当前值
int index = nums[i];
// 将待排序数组当前值作为排序数组索引
// 将用于排序数组对应索引原有值+1
newNums[index] = newNums[index] +1;
}
// 计算待排序数组长度
int len2 = sizeof(newNums) / sizeof(newNums[0]);
// 输出排序数组索引, 就是排序之后结果
for(int i = 0; i < len2; i++){
for(int j = 0; j < newNums[i]; j++){
printf("%i\n", i);
}
}
/*
// 计算待排序数组长度
int len2 = sizeof(newNums) / sizeof(newNums[0]);
// 还原排序结果到待排序数组
for(int i = 0; i < len2; i++){
int index = 0;
for(int i = 0; i < len; i++){
for(int j = 0; j < newNums[i]; j++){
nums[index++] = i;
}
}
}
*/
return 0;
}
选择排序
- 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
- 排序思路:
- 假设按照升序排序
- 1.用第 0 个元素和后面所有元素依次比较
- 2.判断第 0 个元素是否大于当前被比较元素, 一旦小于就交换位置
- 3.第 0 个元素和后续所有元素比较完成后, 第 0 个元素就是最小值
- 4.排除第 0 个元素, 用第 1 个元素重复 1~3 操作, 比较完成后第 1 个元素就是倒数第二小的值
- 以此类推, 直到当前元素没有可比较的元素, 排序完成
- 代码实现:
// 选择排序
void selectSort(int numbers[], int length) {
// 外循环为什么要-1?
// 最后一位不用比较, 也没有下一位和它比较, 否则会出现错误访问
for (int i = 0; i < length; i++) {
for (int j = i; j < length - 1; j++) {
// 1.用当前元素和后续所有元素比较
if (numbers[i] < numbers[j + 1]) {
// 2.一旦发现小于就交换位置
swapEle(numbers, i, j + 1);
}
}
}
}
// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
冒泡排序
- 冒泡排序(Bubble Sort)是一种简单的排序算法。它重复 地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
- 排序思路:
- 假设按照升序排序
- 1.从第 0 个元素开始, 每次都用相邻两个元素进行比较
- 2.一旦发现后面一个元素小于前面一个元素就交换位置
- 3.经过一轮比较之后最后一个元素就是最大值
- 4.排除最后一个元素, 以此类推, 每次比较完成之后最大值都会出现再被比较所有元素的最后
- 直到当前元素没有可比较的元素, 排序完成
- 代码实现:
// 冒泡排序
void bubbleSort(int numbers[], int length) {
for (int i = 0; i < length; i++) {
// -1防止`角标越界`: 访问到了不属于自己的索引
for (int j = 0; j < length - i - 1; j++) {
// 1.用当前元素和相邻元素比较
if (numbers[j] < numbers[j + 1]) {
// 2.一旦发现小于就交换位置
swapEle(numbers, j, j + 1);
}
}
}
}
// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
插入排序
- 插入排序(Insertion-Sort) 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
- 排序思路:
- 假设按照升序排序
- 1.从索引为 1 的元素开始向前比较, 一旦前面一个元素大于自己就让前面的元素先后移动
- 2.直到没有可比较元素或者前面的元素小于自己的时候, 就将自己插入到当前空出来的位置
- 代码实现:
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = 1; i < len; i++)
{
// 2.取出用于比较元素
int temp = nums[i];
int j = i;
while(j > 0){
// 3.判断元素是否小于前一个元素
if(temp < nums[j - 1]){
// 4.让前一个元素向后移动一位
nums[j] = nums[j - 1];
}else{
break;
}
j--;
}
// 5. 将元素插入到空出来的位置
nums[j] = temp;
}
}
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = 1; i < len; i++)
{
// 2.遍历取出前面元素进行比较
for(int j = i; j > 0; j--)
{
// 3.如果前面一个元素大于当前元素,就交换位置
if(nums[j-1] > nums[j]){
int temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
}else{
break;
}
}
}
}
希尔排序
- 1959 年 Shell 发明,第一个突破 O(n2)的排序算法,是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
- 排序思路:
- 1.希尔排序可以理解为插入排序的升级版, 先将待排序数组按照指定步长划分为几个小数组
- 2.利用插入排序对小数组进行排序, 然后将几个排序的小数组重新合并为原始数组
- 3.重复上述操作, 直到步长为 1 时,再利用插入排序排序即可
- 代码实现:
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 2.计算步长
int gap = len / 2;
do{
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = gap; i < len; i++)
{
// 2.遍历取出前面元素进行比较
int j = i;
while((j - gap) >= 0)
{
printf("%i > %i\n", nums[j - gap], nums[j]);
// 3.如果前面一个元素大于当前元素,就交换位置
if(nums[j - gap] > nums[j]){
int temp = nums[j];
nums[j] = nums[j - gap];
nums[j - gap] = temp;
}else{
break;
}
j--;
}
}
// 每个小数组排序完成, 重新计算步长
gap = gap / 2;
}while(gap >= 1);
}
折半查找
- 基本思路
- 在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
- 若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败
-
实现步骤
-
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;
-
若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
-
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。
-
不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败。
-
代码实现
int findKey(int values[], int length, int key) {
// 定义一个变量记录最小索引
int min = 0;
// 定义一个变量记录最大索引
int max = length - 1;
// 定义一个变量记录中间索引
int mid = (min + max) * 0.5;
while (min <= max) {
// 如果mid对应的值 大于 key, 那么max要变小
if (values[mid] > key) {
max = mid - 1;
// 如果mid对应的值 小于 key, 那么min要变
}else if (values[mid] < key) {
min = mid + 1;
}else {
return mid;
}
// 修改完min/max之后, 重新计算mid的值
mid = (min + max) * 0.5;
}
return -1;
}
进制转换(查表法)
- 实现思路:
- 将二进制、八进制、十进制、十六进制所有可能的字符都存入数组
- 利 用按位与运算符和右移依次取出当前进制对应位置的值
- 利用取出的值到数组中查询当前位输出的结果
- 将查询的结果存入一个新的数组, 当所有位都查询存储完毕, 新数组中的值就是对应进制的值
- 代码实现
#include <stdio.h>
void toBinary(int num)
{
total(num, 1, 1);
}
void toOct(int num)
{
total(num, 7, 3);
}
void toHex(int num)
{
total(num, 15, 4);
}
void total(int num , int base, int offset)
{
// 1.定义表用于查询结果
char cs[] = {
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f'
};
// 2.定义保存结果的数组
char rs[32];
// 计算最大的角标位置
int length = sizeof(rs)/sizeof(char);
int pos = length;//8
while (num != 0) {
int index = num & base;
rs[--pos] = cs[index];
num = num >> offset;
}
for (int i = pos; i < length; i++) {
printf("%c", rs[i]);
}
printf("\n");
}
int main()
{
toBinary(9);
return 0;
}
二维数组
- 所谓二维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。
- 示例:
int a[2][3] = { {80,75,92}, {61,65,71}};
- 可以看作由一维数组 a[0]和一维数组 a[1]组成,这两个一维数组都包含了 3 个 int 类型的元素
二维数组的定义
- 格式:
- 数据类型 数组名[一维数组的个数][一维数组的元素个数]
- 其中"一维数组的个数"表示当前二维数组中包含多少个一维数组
- 其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数
二维数组的初始化
- 二维数的初始化可分为两种:
- 定义的同时初始化
- 先定义后初始化
- 定义的同时初始化
int a[2][3]={ {80,75,92}, {61,65,71}};
- 先定义后初始化
int a[2][3];
a[0][0] = 80;
a[0][1] = 75;
a[0][2] = 92;
a[1][0] = 61;
a[1][1] = 65;
a[1][2] = 71;
- 按行分段赋值
int a[2][3]={ {80,75,92}, {61,65,71}};
- 按行连续赋值
int a[2][3]={ 80,75,92,61,65,71};
- 其它写法
- 完全初始化,可以省略第一维的长度
int a[][3]={{1,2,3},{4,5,6}};int a[][3]={1,2,3,4,5,6};
- 部分初始化,可以省略第一维的长度
int a[][3]={{1},{4,5}};int a[][3]={1,2,3,4};
- 注意: 有些人可能想不明白,为什么可以省略行数,但不可以省略列数。也有人可能会问,可不可以只指定行数,但是省略列数?其实这个问题很简单,如果我们这样写: int a[2][] = 6; // 错误写法 大家都知道,二维数组会先存放第 1 行 的元素,由于不确定列数,也就是不确定第 1 行要存放多少个元素,所以这里会产生很多种情况,可能 1、2 是属于第 1 行的,也可能 1、2、3、4 是第一行的,甚至 1、2、3、4、5、6 全部都是属于第 1 行的
- 指定元素的初始化
int a[2][3]={[1][2]=10};int a[2][3]={[1]={1,2,3}}
二维数组的应用场景
二维数组的遍历和存储
二维数组的遍历
- 二维数组 a[3][4],可分解为三个一维数组,其数组名分别为:
- 这三个一维数组都有 4 个元素,例如:一维数组 a[0]的 元素为 a[0][0],a[0][1],a[0][2],a[0][3]。
- 所以遍历二维数组无非就是先取出二维数组中得一维数组, 然后再从一维数组中取出每个元素的值
- 示例
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
printf("%c", cs[0][0]);// 第一个[0]取出一维数组, 第二个[0]取出一维数组中对应的元素
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
for (int i = 0; i < 2; i++) { // 外循环取出一维数组
// i
for (int j = 0; j < 3; j++) {// 内循环取出一维数组的每个元素
printf("%c", cs[i][j]);
}
printf("\n");
}
注意: 必须强调的是,a[0],a[1],a[2]不能当作下标变 量使用,它们是数组名,不是一个单纯的下标变量
二维数组的存储
- 和以为数组一样
- 给数组分配存储空间从内存地址大开始分配
- 给数组元素分配空间, 从所占用内存地址小的开始分配
- 往每个元素中存储数据从高地址开始存储
#include <stdio.h>
int main()
{
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
// cs == &cs == &cs[0] == &cs[0][0]
printf("cs = %p\n", cs); // 0060FEAA
printf("&cs = %p\n", &cs); // 0060FEAA
printf("&cs[0] = %p\n", &cs[0]); // 0060FEAA
printf("&cs[0][0] = %p\n", &cs[0][0]); // 0060FEAA
return 0;
}
二维数组与函数
- 值传递
#include <stdio.h>
// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是基本类型在函数中修改形参不会影响实参
void change(char ch){
ch = 'n';
}
int main()
{
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
printf("cs[0][0] = %c\n", cs[0][0]); // a
change(cs[0][0]);
printf("cs[0][0] = %c\n", cs[0][0]); // a
return 0;
}
- 地址传递
#include <stdio.h>
// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是数组类型在函数中修改形参会影响实参
void change(char ch[]){
ch[0] = 'n';
}
int main()
{
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
printf("cs[0][0] = %c\n", cs[0][0]); // a
change(cs[0]);
printf("cs[0][0] = %c\n", cs[0][0]); // n
return 0;
}
#include <stdio.h>
// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是数组类型在函数中修改形参会影响实参
void change(char ch[][3]){
ch[0][0] = 'n';
}
int main()
{
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
printf("cs[0][0] = %c\n", cs[0][0]); // a
change(cs);
printf("cs[0][0] = %c\n", cs[0][0]); // n
return 0;
}
- 形参错误写法
void test(char cs[2][]) // 错误写法
{
printf("我被执行了\n");
}
void test(char cs[2][3]) // 正确写法
{
printf("我被执行了\n");
}
void test(char cs[][3]) // 正确写法
{
printf("我被执行了\n");
}
- 二维数组作为函数参数,在被调函数中不能获得其有多少行,需要通过参数传入
void test(char cs[2][3])
{
int row = sizeof(cs); // 输出4或8
printf("row = %zu\n", row);
}
- 二维数组作为函数参数,在被调函数中可以计算出二维数组有多少列
void test(char cs[2][3])
{
size_t col = sizeof(cs[0]); // 输出3
printf("col = %zd\n", col);
}
作业
-
玩家通过键盘录入 w,s,a,d 控制小人向不同方向移动,其中 w 代表向上移动,s 代表向 下移动,a 代表向左移动,d 代表向右移动,当小人移动到出口位置,玩家胜利
-
思路:
-
1.定义二维数组存放地图
######
#O #
# ## #
# # #
## #
######
- 2.规定地图的方向
- 3.编写程序控制方向
- 当输入 w 或者 W, 小人向上移动. x-1
- 当输入 s 或者 S, 小人向下. x+1
- 当输入 a 或者 A, 小人向左. y-1
- 当输入 d 或者 D, 小人向右. y+1
- 4. 移动小人
- 用变量记录小人当前的位置
- 1)如果小人将要移动的位置是墙,则无法移动
- 2)如果小人将要移动的位置是路,则可以移动
- 5.判断是否走出迷宫
字符串的基本概念
- 字符串是位于双引号中的字符序列
- 在内存中以“\0”结束,所占字节比实际多一个
字符串的初始化
- 在 C 语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。
- 当把一个字符串存入一个数组时,会把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。
- 有了‘\0’标志后,就不必再用字符数组 的长度来判断字符串的长度了
- 初始化
char name[9] = "lnj"; //在内存中以“\0”结束, \0ASCII码值是0
char name1[9] = {'l','n','j','\0'};
char name2[9] = {'l','n','j',0};
// 当数组元素个数大于存储字符内容时, 未被初始化的部分默认值是0, 所以下面也可以看做是一个字符串
char name3[9] = {'l','n','j'};
- 错误的初始化方式
//省略元素个数时, 不能省略末尾的\n
// 不正确地写法,结尾没有\0 ,只是普通的字符数组
char name4[] = {'l','n','j'};
// "中间不能包含\0", 因为\0是字符串的结束标志
// \0的作用:字符串结束的标志
char name[] = "c\0ool";
printf("name = %s\n",name);
输出结果: c
字符串输出
- 如果字符数组中存储的是一个字符串, 那么字符数组的输入输出将变得简单方便。
- 不必使用循环语句逐个地输入输出每个字符
- 可以使用 printf 函数和 scanf 函数一次性输出输入一个字符数组中的字符串
- 使用的格式字符串为“%s”,表示输入、输出的是一个字符串 字符串的输出
- 输出
- %s 的本质就是根据传入的 name 的地址逐个去取数组中的元素然后输出,直到遇到\0 位置
char chs[] = "lnj";
printf("%s\n", chs);
- 注意点:
- \0 引发的脏读问题
char name[] = {'c', 'o', 'o', 'l' , '\0'};
char name2[] = {'l', 'n', 'j'};
printf("name2 = %s\n", name2); // 输出结果: lnjcool
- 输入
char ch[10];
scanf("%s",ch);
- 注意点:
- 对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度
- ch 最多存放由 9 个字符构成的字符串,其中最后一个字符的位置要留给字符串的结尾标示‘\0’
- 当用 scanf 函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符
字符串常用方法
- C 语言中供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转 换、复制、搜索几类。
- 使用这些函数可大大减轻编程的负担。
- 使用输入输出的字符串函数,在使用前应包含头文件"stdio.h"
- 使用其它字符串函数则应包含头文件"string.h"
- 字符串输出函 数:puts
- 格式: puts(字符数组名)
- 功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。
- 优点:
- 自动换行
- 可以是数组的任意元素地址
- 缺点
- 不能自定义输出格式, 例如 puts("hello %i");
char ch[] = "lnj";
puts(ch); //输出结果: lnj
- puts 函数完全可以由 printf 函数取代。当需要按一定格式输出时,通常使用 printf 函数
- 字符串输入函数:gets
- 格式: gets (字符数组名)
- 功能:从标准输入设备键盘上输入一个字符串。
char ch[30];
gets(ch); // 输入:lnj
puts(ch); // 输出:lnj
- 可以看出当输入的字符串中含有空格时,输出仍为全部字符串。说明 gets 函数并不以空格作为字符串输入结束的标志,而只以回车作为输入结束。这是与 scanf 函数不同的。
- 注意 gets 很容易导致数组下标越界,是一个不安全的字符串操作函数
- 字符串长度
- 利用 sizeof 字符串长度
- 因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。
char name[] = "it666";
int size = sizeof(name);// 包含\0
printf("size = %d\n", size); //输出结果:6
- 利用系统函数
- 格式: strlen(字符数组名)
- 功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。
char name[] = "it666";
size_t len = strlen(name2);
printf("len = %lu\n", len); //输出结果:5
- 以“\0”为字符串结束条件进行统计
/**
* 自定义方法计算字符串的长度
* @param name 需要计算的字符串
* @return 不包含\0的长度
*/
int myStrlen2(char str[])
{
// 1.定义变量保存字符串的长度
int length = 0;
while (str[length] != '\0')
{
length++;//1 2 3 4
}
return length;
}
/**
* 自定义方法计算字符串的长度
* @param name 需要计算的字符串
* @param count 字符串的总长度
* @return 不包含\0的长度
*/
int myStrlen(char str[], int count)
{
// 1.定义变量保存字符串的长度
int length = 0;
// 2.通过遍历取出字符串中的所有字符逐个比较
for (int i = 0; i < count; i++) {
// 3.判断是否是字符串结尾
if (str[i] == '\0') {
return length;
}
length++;
}
return length;
}
- 字符串连接函数:strcat
- 格式: strcat(字符数组名 1,字符数组名 2)
- 功能:把字符数组 2 中的字符串连接到字符数组 1 中字符串的后面,并删去字符串 1 后的串标志 “\0”。本函数返回值是字符数组 1 的首地址。
char oldStr[100] = "welcome to";
char newStr[20] = " lnj";
strcat(oldStr, newStr);
puts(oldStr); //输出: welcome to lnj"
- 本程序把初始化赋值的字符数组与动态赋值的字符串连接起来。要注意的是,字符数组 1 应定义足 够的长度,否则不能全部装入被连接的字符串。
- 字符串拷贝函数:strcpy
- 格式: strcpy(字符数组名1,字符数组名2)
- 功能:把字符数组 2 中的字符串拷贝到字符数组 1 中。串结束标志“\0”也一同拷贝。字符数名 2, 也可以是一个字符串常量。这时相当于把一个字符串赋予一个字符数组。
char oldStr[100] = "welcome to";
char newStr[50] = " lnj";
strcpy(oldStr, newStr);
puts(oldStr); // 输出结果: lnj // 原有数据会被覆盖
- 本函数要求字符数组 1 应有足够的长度,否则不能全部装入所拷贝的字符串。
- 字符串比较函数:strcmp
- 格式: strcmp(字符数组名 1,字符数组名 2)
- 功能:按照 ASCII 码顺序比较两个数组中的字符串,并由函数返回值返回比较结果。
- 字符串 1=字符串 2,返回值=0;
- 字符串 1
>
字符串 2,返回值>
0; - 字符串 1
<
字符串 2,返回值<
0。
char oldStr[100] = "0";
char newStr[50] = "1";
printf("%d", strcmp(oldStr, newStr)); //输出结果:-1
char oldStr[100] = "1";
char newStr[50] = "1";
printf("%d", strcmp(oldStr, newStr)); //输出结果:0
char oldStr[100] = "1";
char newStr[50] = "0";
printf("%d", strcmp(oldStr, newStr)); //输出结果:1
练习
- 编写一个函数 char_contains(char str[],char key), 如果字符串 str 中包含字符 key 则返回数值 1,否则返回数值 0
字符串数组基本概念
- 字符串数组其实就是定义一个数组保存所有的字符串
- 1.一维字符数组中存放一个字符串,比如一个名字 char name[20] = “nj”
- 2.如果要存储多个字符串,比如一个班所有学生的名字,则需要二维字符数组,char names[15][20]可以存放 15 个学生的姓名(假设姓名不超过 20 字符)
- 如果要存储两个班的学生姓名,那么可以用三维字符数组 char names[2][15][20] ##字符串数组的初始化
char names[2][10] = { {'l','n','j','\0'}, {'l','y','h','\0'} };
char names2[2][10] = { {"lnj"}, {"lyh"} };
char names3[2][10] = { "lnj", "lyh" };
指针基本概念
- 什么是地址
- 生活中的地址:
- 内存地址:
- 地址与内存单元中的数据是两个完全不同的概念
- 地址如同房间编号, 根据这个编号我们可以找到对应的房间
- 内存单元如同房间, 房间是专门用于存储数据的
- 变量地址:
- 系统分配给"变量"的"内存单元"的起始地址
int num = 6; // 占用4个字节
//那么变量num的地址为: 0ff06
char c = 'a'; // 占用1个字节
//那么变量c的地址为:0ff05
什么是指针
-
在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据.
-
由于通过地址能找到所需的变量单元,所以我们说该地址指向了该变量单元。将地址形象化的称为“指针”
-
内存单元的指针(地址)和内存单元的内容是两个不同的概念。
什么是指针变量
- 在 C 语言中,允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
- 示例:
int age;// 定义一个普 通变量
num = 10;
int *pnAge; // 定义一个指针变量
pnAge = &age;
定义指针变量的格式
- 指针变量的定义包括两个内容:
- 指针类型说明,即定义变量为一个指针变量;
- 指针变量名;
- 示例:
char ch = 'a';
char *p; // 一个用于指向字符型变量的指针
p = &ch;
int num = 666;
int *q; // 一个用于指向整型变量的指针
q = #
- 其中,*表示这是一个指针变量
- 变量名即为定义的指针变量名
- 类型说明符表示本指针变量所指向的变量的数据类型
指针变量的初始化方法
- 指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化
- 定义的同时进行初始化
int a = 5;
int *p = &a;
- 先定义后初始化
int a = 5;
int *p;
p=&a;
- 把指针初始化为 NULL
int *p=NULL;
int *q=0;
- 不合法的初始化:
- 指针变量只能存储地址, 不能存储其它类型
int *p;
p = 250; // 错误写法
- 给指针变量赋值时,指针变量前不能再加“*”
int *p;
*p=&a; //错误写法
- 注意点:
- 多个指针变量可以指向同一个地址
- 指针的指向是可以改变的
int a = 5;
int *p = &a;
int b = 10;
p = &b; // 修改指针指向
- 指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针
- 野指针可能会导致程序崩溃
- 野指针访问你不该访问数据
- 所以指针必须初始化才可以访问其所指向存储区域
访问指针所指向的存储空间
- C 语言中提供了地址运算符&来表示变量的地 址。其一般形式为:
- &变量名;
- C 语言中提供了*来定义指针变量和访问指针变量指向的内存存储空间
- 在定义变量的时候 * 是一个类型说明符,说明定义的这个变量是一个指针变量
int *p=NULL; // 定义指针变量
- 在不是定义变量的时候 *是一个操作符,代表访问指针所指向存储空间
int a = 5;
int *p = &a;
printf("a = %d", *p); // 访问指针变量
指针类型
-
在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。
-
虽然在同一种编译器下, 所有指针占用的内存空间是一样的,但不同类型的变量却占不同的字节数
- 一个 int 占用 4 个字节,一个 char 占用 1 个字节,而一个 double 占用 8 字节;
- 现在只有一个地址,我怎么才能知道要从这个地址开始向后访问多少个字节的存储空间呢,是 4 个,是 1 个,还是 8 个。
- 所以指针变量需要它所指向的数据类型告诉它要访问多少个字节存储空间
二级指针
- 如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针  变量。也称为“二级指针”
char c = 'a';
char *cp;
cp = &c;
char **cp2;
cp2 = &cp;
printf("c = %c", **cp2);
- 多级指针的取值规则
int ***m1; //取值***m1
int *****m2; //取值*****m2
练习
- 定义一个函数交换两个变量的值
- 写一个函数,同时返回两个数的和与差
数组指针的概念及定义
- 数组元素指针
- 一个变量有地址,一个数组包含若干元素,每个数组元素也有相应的地址, 指针变量也可以保存数组元素的地址
- 只要一个指针变量保存了数组元素的地址, 我们就称之为数组元素指针
printf(“%p %p”, &(a[0]), a); //输出结果:0x1100, 0x1100
- 注意: 数组名 a 不代表整个数组,只代表数组首元素的地址。
- “p=a;”的作用是“把 a 数组的首元素的地址赋给指针变量 p”,而不是“把数组 a 各元素的值赋给 p”
指针访问数组元素
int main (void)
{
int a[5] = {2, 4, 6, 8, 22};
int *p;
// p = &(a[0]);
p = a;
printf(“%d %d\n”,a[0],*p); // 输出结果: 2, 2
}
- 在指针指向数组元素时,允许以下运算:
- 加一个整数(用+或+=),如 p+1
- 减一个整数(用-或-=),如 p-1
- 自加运算,如 p++,++p
- 自减运算,如 p--,--p
- 如果指针变量 p 已指向数组中的一个元素,则 p+1
指向
同一数组中的下一个元素,p-1指向
同 一数组中的上一个元素。
- 结论: 访问数组元素,可用下面两种方法:
- 下标法, 如 a[i]形式
- 指针法, *(p+i)形式
- 注意:
- 数组名虽然是数组的首地址,但是数组名所所保存的数组的首地址是不可以更改的
int x[10];
x++; //错误
int* p = x;
p++; //正确
指针与字符串
- 定义字符串的两种方式
- 字符数组
char string[]=”I love lnj!”;
printf("%s\n",string);
- 字符串指针指向字符串
// 数组名保存的是数组第0个元素的地址, 指针也可以保存第0个元素的地址
char *str = "abc"
- 字符串指针使用注意事项
- 可以查看字符串的每一个字符
har *str = "lnj";
for(int i = 0; i < strlen(str);i++)
{
printf("%c-", *(str+i)); // 输出结果:l-n-j
}
-
- 不可以修改字符串内容
// + 使用字符数组来保存的字符串是保存栈里的,保存栈里面东西是可读可写,所有可以修改字符串中的的字符
// + 使用字符指针来保存字符串,它保存的是字符串常量地址,常量区是只读的,所以我们不可以修改字符串中的字符
char *str = "lnj";
*(str+2) = 'y'; // 错误
-
- 不能够直接接收键盘输入
// 错误的原因是:str是一个野指针,他并没有指向某一块内存空间
// 所以不允许这样写如果给str分配内存空间是可以这样用 的
char *str;
scanf("%s", str);
指向函数指针
- 为什么指针可以指向一个函数?
- 函数作为一段程序,在内存中也要占据部分存储空间,它也有一个起始地址
- 函数有自己的地址,那就好办了,我们的指针变量就是用来存储地址的。
- 因此可以利用一个指针指向一个函数。其中,函数名就代表着函数的地址。
- 指针函数的定义
- 格式:
返回值类型 (*指针变量名)(形参1, 形参2, ...);
int sum(int a,int b)
{
return a + b;
}
int (*p)(int,int);
p = sum;
- 指针函数定义技巧
- 1、把要指向函数头拷贝过来
- 2、把函数名称使用小括号括起来
- 3、在函数名称前面加上一个*
- 4、修改函数名称
- 应用场景
- 调用函数
- 将函数作为参数在函数间传递
- 注意点:
- 由于这类指针变量存储的是一个函数的入口地址,所以对它们作加减运算(比如 p++)是无意义的
- 函数调用中"(指针变量名)"的两边的括号不可少,其中的不应该理解为求值运算,在此处它 只是一种表示符号
什么是结构体
- 结构体和数组一样属于构造类型
- 数组是用于保存一组相同类型数据的, 而结构体是用于保存一组不同类型数组的
- 例如,在学生登记表中,姓名应为字符型;学号可为整型或字符型;年龄应为整型;性别应为字符型;成绩可为整型或实型 。
- 显然这组数据不能用数组来存放, 为了解决这个问题,C 语言中给出了另一种构造数据类型——“结构(structure)”或叫“结构体”。
定义结构体类型
- 在使用结构体之前必须先定义结构体类型, 因为 C 语言不知道你的结构体中需要存储哪些类型数据, 我们必须通过定义结构体类型来告诉 C 语言, 我们的结构体中需要存储哪些类型的数据
- 格式:
struct 结构体名{
类型名1 成员名1;
类型名2 成员名2;
……
类型名n 成员名n;
};
- 示例:
struct Student {
char *name; // 姓名
int age; // 年龄
float height; // 身高
};
定义结构体变量
-
定好好结构体类型之后, 我们就可以利用我们定义的结构体类型来定义结构体变量
-
格式:
struct 结构体名 结构体变量名;
-
先定义结构体类型,再定义变量
struct Student {
char *name;
int age;
};
struct Student stu;
- 定义结构体类型的同时定义变量
struct Student {
char *name;
int age;
} stu;
- 匿名结构体定义结构体变量
struct {
char *name;
int age;
} stu;
- 第三种方法与第二种方法的区别在于,第三种方法中省去了结构体类型名称,而直接给出结构变量,这种结构体最大的问题是结构体类型不能复用
结构体成员访问
- 一般对结构体变量的操作是以成员为单位进行的,引用的一般形式为:
结构体变量名.成员名
struct Student {
char *name;
int age;
};
struct Student stu;
// 访问stu的age成员
stu.age = 27;
printf("age = %d", stu.age);
结构体变量的初始化
- 定义的同时按顺序初始化
struct Student {
char *name;
int age;
};
struct Student stu = {“lnj", 27};
- 定义的同时不按顺序初始化
struct Student {
char *name;
int age;
};
struct Student stu = {.age = 35, .name = “lnj"};
- 先定义后逐个初始化
struct Student {
char *name;
int age;
};
struct Student stu;
stu.name = "lnj";
stu.age = 35;
- 先定义后一次性初始化
struct Student {
char *name;
int age;
};
struct Student stu;
stu2 = (struct Student){"lnj", 35};
结构体类型作用域
- 结构类型定义在函数内部的作用域与局部变量的作用域是相同的
- 从定义的那一行开始, 直到遇到 return 或者大括号结束为止
- 结构类型定义在函数外部的作用域与全局变量的作用域是相同的
- 从定义的那一行开始,直到本文件结束为止
//定义一个全局结构体,作用域到文件末尾
struct Person{
int age;
char *name;
};
int main(int argc, const char * argv[])
{
//定义局部结构体名为Person,会屏蔽全局结构体
//局部结构体作用域,从定义开始到“}”块结束
struct Person{
int age;
};
// 使用局部结构体类型
struct Person pp;
pp.age = 50;
pp.name = "zbz";
test();
return 0;
}
void test() {
//使用全局的结构体定义结构体变量p
struct Person p = {10,"sb"};
printf("%d,%s\n",p.age,p.name);
}
结构体数组
- 结构体数组和普通数组并无太大差异, 只不过是数组中的元素都是结构体而已
- 格式:
struct 结构体类型名称 数组名称[元素个数]
struct Student {
char *name;
int age;
};
struct Student stu[2];
- 结构体数组初始化和普通数组也一样, 分为先定义后初始化和定义同时初始化
- 定 义同时初始化
struct Student {
char *name;
int age;
};
struct Student stu[2] = {{"lnj", 35},{"zs", 18}};
-
- 先定义后初始化
struct Student {
char *name;
int age;
};
struct Student stu[2];
stu[0] = {"lnj", 35};
stu[1] = {"zs", 18};
结构体指针
- 一个指针变量当用来指向一个结构体变量时,称之为结构体指针变量
- 格式:
struct 结构名 *结构指针变量名
- 示例:
// 定义一个结构体类型
struct Student {
char *name;
int age;
};
// 定义一个结构体变量
struct Student stu = {“lnj", 18};
// 定义一个指向结构体的指针变量
struct Student *p;
// 指向结构体变量stu
p = &stu;
/*
这时候可以用3种方式访问结构体的成员
*/
// 方式1:结构体变量名.成员名
printf("name=%s, age = %d \n", stu.name, stu.age);
// 方式2:(*指针变量名).成员名
printf("name=%s, age = %d \n", (*p).name, (*p).age);
// 方式3:指针变量名->成员名
printf("name=%s, age = %d \n", p->name, p->age);
return 0;
}
- 通过结构体指针访问结构体成员, 可以通过以下两种方式
- (*结构指针变量).成员名
- 结构指针变量->成员名(用熟)
- (pstu)两侧的括号不可少,因为成员符“.”的优先级高于“”。
- 如去掉括号写作 pstu.num 则等效于(pstu.num),这样,意义就完全不对了。
结构体内存分析
- 给结构体变量开辟存储空间和给普通开辟存储空间一样, 会从内存地址大的位置开始开辟
- 给结构体成员开辟存储空间和给数组元素开辟存储空间一样, 会从所占用内存地址小的位置开始开辟
- 结构体变量占用的内存空间永远是所有成员中占用内存最大成员的倍数(对齐问题)
+多实际的计算机系统对基本类型数据在内存中存放的位置有限制,它们会要求这些数据的起始地址的值是 某个数 k 的倍数,这就是所谓的内存对齐,而这个 k 则被称为该数据类型的对齐模数(alignment modulus)。
- 这种强制的要求一来简化了处理器与内存之间传输系统的设计,二来可以提升读取数据的速度。比如这么一种处理器,它每次读写内存的时候都从某个 8 倍数的地址开始,一次读出或写入 8 个字节的数据,假如软件能 保证 double 类型的数据都从 8 倍数地址开始,那么读或写一个 double 类型数据就只需要一次内存操作。否则,我们就可能需要两次内存操作才能完成这个动作,因为数据或许恰好横跨在两个符合对齐要求的 8 字节 内存块上
结构体变量占用存储空间大小
struct Person{
int age; // 4
char ch; // 1
double score; // 8
};
struct Person p;
printf("sizeof = %i\n", sizeof(p)); // 16
- 占用内存最大属性是 score, 占 8 个字节, 所以第一次会分配 8 个字节
- 将第一次分配的 8 个字节分配给 age4 个,分配给 ch1 个, 还剩下 3 个字节
- 当需要分配给 score 时, 发现只剩下 3 个字节, 所以会再次开辟 8 个字节存储空间
- 一共开辟了两次 8 个字节空间, 所以最终 p 占用 16 个字节
struct Person{
int age; // 4
double score; // 8
char ch; // 1
};
struct Person p;
printf("sizeof = %i\n", sizeof(p)); // 24
- 占用内存最大属性是 score, 占 8 个字节, 所以第一次会分配 8 个字节
- 将第一次分配的 8 个字节分配给 age4 个,还剩下 4 个字节
- 当需要分配给 score 时, 发现只剩下 4 个字节, 所以会再次开辟 8 个字节存储空间
- 将新分配的 8 个字节分配给 score, 还剩下 0 个字节
- 当需要分配给 ch 时, 发现上一次分配的已经没有了, 所以会再次开辟 8 个字节存储空间
- 一共开辟了 3 次 8 个字节空间, 所以最终 p 占用 24 个字节
结构体嵌套定义
- 成员也可以又是一个结构,即构成了嵌套的结构
struct Date{
int month;
int day;
int year;
}
struct stu{
int num;
char *name;
char sex;
struct Date birthday;
Float score;
}
- 在 stu 中嵌套存储 Date 结构体内容
- 注意:
- 结构体不可以嵌套自己变量,可以嵌套指向自己这种类型的指针
struct Student {
int age;
struct Student stu;
};
- 对嵌套结构体成员的访问
- 如果某个成员也是结构体变量,可以连续使用成员运算符"."访问最低一级成员
struct Date {
int year;
int month;
int day;
};
struct Student {
char *name;
struct Date birthday;
};
struct Student stu;
stu.birthday.year = 1986;
stu.birthday.month = 9;
stu.birthday.day = 10;
结构体和函数
- 结构体虽然是构造类型, 但是结构体之间赋值是值拷贝, 而不是地址传递
struct Person{
char *name;
int age;
};
struct Person p1 = {"lnj", 35};
struct Person p2;
p2 = p1;
p2.name = "zs"; // 修改p2不会影响p1
printf("p1.name = %s\n", p1.name); // lnj
printf("p2.name = %s\n", p2.name); // zs
- 所以结构体变量作为函数形参时也是值传递, 在函数内修改形参, 不会影响外界实参
#include <stdio.h>
struct Person{
char *name;
int age;
};
void test(struct Person per);
int main()
{
struct Person p1 = {"lnj", 35};
printf("p1.name = %s\n", p1.name); // lnj
test(p1);
printf("p1.name = %s\n", p1.name); // lnj
return 0;
}
void test(struct Person per){
per.name = "zs";
}
共用体
- 和结构体不同的是, 结构体的每个成员都是占用一块独立的存储空间, 而共用体所有的成员都占用同一块存储空间
- 和结构体一样, 共用体在使用之前必须先定义共用体类型, 再定义共用体变量
- 定义共用体类型格式:
union 共用体名{
数据类型 属性名称;
数据类型 属性名称;
... ....
};
- 定义共用体类型变量格式:
union 共用体名 共用体变量名称;
- 特点: 由于所有属性共享同一块内存空间, 所以只要其中一个属性发生了改变, 其它的属性都会受到影响
- 示例:
union Test{
int age;
char ch;
};
union Test t;
printf("sizeof(p) = %i\n", sizeof(t));
t.age = 33;
printf("t.age = %i\n", t.age); // 33
t.ch = 'a';
printf("t.ch = %c\n", t.ch); // a
printf("t.age = %i\n", t.age); // 97
- 共用体的应用场景
- (1)通信中的数据包会用到共用体,因为不知道对方会发送什么样的数据包过来,用共用体的话就简单了,定义几种格式的包,收到包之后就可以根据包的格式取出数据。
- (2)节约内存。如果有 2 个很长的数据结构,但不会同时使用,比如一个表示老师,一个表示学生,要统计老师和学生的情况,用结构体就比较浪费内存,这时就可以考虑用共用体来设计。 +(3)某些应用需要大量的临时变量,这些变量类型不同,而且会随时更换。而你的堆栈空间有限,不能同时分配那么多临时变量。这时可以使用共用体让这些变量共享同一个内存空间,这些临时变量不用长期保存,用完即丢,和寄存器差不多,不用维护。
枚举
- 什么是枚举类型?
- 在实际问题中,有些变量的取值被限定在一个有限的范围内。例如,一个星期内只有七天,一年只有十二个月,一个班每周有六门课程等等。如果把这些量说明为整型,字符型或其它类型 显然是不妥当的。
- C 语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值, 被说明为该“枚举”类型的变量取值不能超过定义的范围。
- 该说明的是,枚举类型是一种基本数据类型,而不是一种构造类型,因为它不能再分解为任何基本类型。
- 枚举类型的定义
- 格式:
enum 枚举名 {
枚举元素1,
枚举元素2,
……
};
- 示例:
// 表示一年四季
enum Season {
Spring,
Summer,
Autumn,
Winter
};
- 枚举变量
- 先定义枚举类型,再定义枚举变量
enum Season {
Spring,
Summer,
Autumn,
Winter
};
enum Season s;
- 定义枚举类型的同时定义枚举变量
enum Season {
Spring,
Summer,
Autumn,
Winter
} s;
- 省略枚举名称,直接定义枚举变量
enum {
Spring,
Summer,
Autumn,
Winter
} s;
- 枚举类型变量的赋值和使用
enum Season {
Spring,
Summer,
Autumn,
Winter
} s;
s = Spring; // 等价于 s = 0;
s = 3; // 等价于 s = winter;
printf("%d", s);
- 枚举使用的注意
- C 语言编译器会将枚举元素(spring、summer 等)作为整型常量处理,称为枚举常量。
- 枚举元素的值取决于定义时各枚举元素排列的先后顺序。默认情况下,第一个枚举元素的值为 0,第二个为 1,依次顺序加 1。
- 也可以在定义枚举类型时改变枚举元素的值
enum Season {
Spring,
Summer,
Autumn,
Winter
};
// 也就是说spring的值为0,summer的值为1,autumn的值为2,winter的值为3
enum Season {
Spring = 9,
Summer,
Autumn,
Winter
};
// 也就是说spring的值为9,summer的值为10,autumn的值为11,winter的值为12
全局变量和局部变量
- 变量作用域基本概念
- 变量作用域:变量的可用范围
- 按照作用域的不同,变量可以分为:局部变量和全局变量
- 局部变量
- 定义在函数内部的变量以及函数的形参, 我们称为局部变量
- 作用域:从定义的那一行开始, 直到遇到}结束或者遇到 return 为止
- 生命周期: 从程序运行到定义哪一行开始分配存储空间到程序离开该变量所在的作用域
- 存储位置: 局部变量会存储在内存的栈区中
- 特点:
- 相同作用域内不可以定义同名变量
- 不同作用范围可以定义同名变量,内部作用域的变量会覆盖外部作用域的变量
- 全局变量
- 定义在函数外面的变量称为全局变量
- 作用域范围:从定义哪行开始直到文件结尾
- 生命周期:程序一启动就会分配存储空间,直到程序结束
- 存储位置:静态存储区
- 特点: 多个同名的全局变量指向同一块存储空间
auto 和 register 关键字
- auto 关键字(忘记)
- 只能修饰局部变量, 局部变量如果没有其它修饰符, 默认就是 auto 的
- 特点: 随用随开, 用完即销
auto int num; // 等价于 int num;
- register 关键字(忘记)
- 只能修饰局部变量, 原则上将内存中变量提升到 CPU 寄存器中存储, 这样访问速度会更快
- 但是由于 CPU 寄存器数量相当有限, 通常不同平台和编译器在优化阶段会自动转换为 auto
register int num;
static 关键字
- 对局部变量的作用
- 延长局部变量的生命周期,从程序启动到程序退出,但是它并没有改变变量的作用域
- 定义变量的代码在整个程序运行期间仅仅会执行一次
#include <stdio.h>
void test();
int main()
{
test();
test();
test();
return 0;
}
void test(){
static int num = 0; // 局部变量
num++;
// 如果不加static输出 1 1 1
// 如果添加static输出 1 2 3
printf("num = %i\n", num);
}
- 对全局变量的作用
- 全局变量分类:
- 内部变量:只能在本文件中访问的变量
- 外部变量:可以在其他文件中访问的变量,默认所有全局变量都是外部变量
- 默认情况下多个同名的全局变量共享一块空间, 这样会导致全局变量污染问题
- 如果想让某个全局变量只在某个文件中使用, 并且不和其他文件中同名全局变量共享同一块存储空间, 那么就可以使用 static
// A文件中的代码
int num; // 和B文件中的num共享
void test(){
printf("ds.c中的 num = %i\n", num);
}
// B文件中的代码
#include <stdio.h>
#include "ds.h"
int num; // 和A文件中的num共享
int main()
{
num = 666;
test(); // test中输出666
return 0;
}
// A文件中的代码
static int num; // 不和B文件中的num共享
void test(){
printf("ds.c中的 num = %i\n", num);
}
// B文件中的代码
#include <stdio.h>
#include "ds.h"
int num; // 不和A文件中的num共享
int main()
{
num = 666;
test(); // test中输出0
return 0;
}
extern 关键字
- 对局部变量的作用
- extern 不能用于局部变量
- extern 代表声明一个变量, 而不是定义一个变量, 变量只有定义才会开辟存储空间
- 所以如果是局部变量, 虽然提前声明有某个局部变量, 但是局部变量只有执行到才会分配存储空间
#include <stdio.h>
int main()
{
extern int num;
num = 998; // 使用时并没有存储空间可用, 所以声明了也没用
int num; // 这里才会开辟
printf("num = %i\n", num);
return 0;
}
- 对全局变量的作用
- 声明一个全局变量, 代表告诉编译器我在其它地方定义了这个变量, 你可以放心使用
#include <stdio.h>
int main()
{
extern int num; // 声明我们有名称叫做num变量
num = 998; // 使用时已经有对应的存储空间
printf("num = %i\n", num);
return 0;
}
int num; // 全局变量, 程序启动就会分配存储空间
static 与 extern 对函数的作用
-
内部函数:只能在本文件中访问的函数
-
外部函数:可以在本文件中以及其他的文件中访问的函数
-
默认情况下所有的函数都是外部函数
-
static 作用
-
声明一个内部函数
static int sum(int num1,int num2);
- 定义一个内部函数
static int sum(int num1,int num2)
{
return num1 + num2;
}
- extern 作用
- 声明一个外部函数
extern int sum(int num1,int num2);
- 定义一个外部函数
extern int sum(int num1,int num2)
{
return num1 + num2;
}
- 注意点:
- 由于默认情况下所有的函数都是外部函数, 所以 extern 一般会省略
- 如果只有函数声明添加了 static 与 extern, 而定义中没有添加 static 与 extern, 那么无效
Qt Creator 编译过程做了什么?
- 当我们按下运行按钮的时, 其实 Qt Creator 编译器做了 5 件事情
- 对源文件进行预处理, 生成预处理文件
- 对预处理文件进行编译, 生成汇编文件
- 对汇编文件进行编译, 生成二进制文件
- 对二进制文件进行链接, 生成可执行文件
- 运行可执行文件
- Qt Creator 编译过程验证
-
1.编写代码, 保存源文件:
#include <stdio.h>
int main(){
printf("hello lnj\n");
return 0;
}
-
2.执行预处理编译
-
执行预处理编译后生成的文件
-
打开预处理编译后生成的文件
- 处理源文件中预处理相关的指令
- 处理源文件中多余注释等
- 3.执行汇编编译
- 执行汇编编译后生成的文件
- 打开汇编编译后生成的文件
- 4.执行二进制编译
- 执行二进制编译后生成的文件
- 打开二进制编译后生成的文件
- 5.执行链接操作
- 将依赖的一些 C 语言函数库和我们编译好的二进制合并为一个文件
- 执行链接操作后生成的文件
- 6.运行链接后生成的文件