10W+字C语言从入门到精通保姆级教程（2021版下）
Posted C语言与CPP编程
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了10W+字C语言从入门到精通保姆级教程（2021版下）相关的知识，希望对你有一定的参考价值。
哈喽，大家好，这篇文章可以说是一本书了，排版，码字耗费了很长的时间，10 万+字 C 语言从入门到精通保姆级教程2021年版，觉得有价值记得一键三连支持。
计数排序（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);}
江哥提示: 对于初学者而言, 排序算法一次不易于学习太多, 咋们先来5个玩一玩, 后续继续讲解其它5个 公众号代码情缘欢迎关注
折半查找
基本思路
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败
实现步骤
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;
若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。
不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败。
代码实现
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][] = {1, 2, 3, 4, 5, 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";
}
共用体
和结构体不同的是, 结构体的每个成员都是占用一块独立的存储空间, 而共用体所有的成员都占用同一块存储空间
和结构体一样, 共用体在使用之前必须先定义共用体类型, 再
以上是关于10W+字C语言从入门到精通保姆级教程（2021版下）的主要内容，如果未能解决你的问题，请参考以下文章
13 万字 C 语言从入门到精通保姆级教程2021 年版 （建议收藏）