学习c语言：指针篇（初阶二）

已于 2023-12-04 17:33:00 修改
阅读量164 收藏 3
点赞数 5
分类专栏： c语言 文章标签： 学习 c语言
于 2023-12-04 17:28:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bskmns/article/details/134760193
版权

上期补充： 指针-指针  前提条件 两个指针指向同一块空间

                   指针-指针的绝对值得到的是指针与指针之间的元素个数

目录

一、指针的传址调用

二、指针的基础知识概括

三、冒泡排序

四、二级指针

 五、指针数组

六、数组指针变量

 七、函数指针数组

一、指针的传址调用

学习指针的目的是为了使用指针解决问题，就比如交换两个整型变量的值。

#include <stdio.h>
void Swap1(int x, int y) {
	int tmp =  x;
	x = y;
	y = tmp;
}
void Swap2(int* p, int* s) {
	int tmp = 0;
	tmp = *p;
	*p = *s;
	*s = tmp;
}
int main() {
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	//swap1(a, b);
	Swap2(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

 上面两种交换方式，只有传地址的才能实现a，b交换。

而这种把变量的地址传给函数，这种函数的调用方式叫：传址调用。

传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。

二、指针的基础知识概括

数组名的理解

        在一般情况下，数组名就是首元素的地址，但是有两个例外：

  • sizeof（数组名），sizeof中sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节。
  • &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

 让我们通过下面代码来验证一下。

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

 我们发现&arr+1直接跳过了40个字节。

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//输⼊
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输⼊
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
		//scanf("%d", arr+i);//也可以这样写
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);//*(p+i)
	}
	return 0;
}

本质上p[i]等价于*(p+i).

 数组传参的本质上传递的是数组首元素的地址。

 一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

三、冒泡排序

冒泡排序的核心是：两两相邻的元素进行比较。

#include <stdio.h>
void bubble_sort(int arr[], int sz) {
	int i = 0;
	for (i = 0; i < sz - 1; i++) {
		int flag = 1;
		int j = 0;
		for (j = 0; j < sz-i-1; j++) {
			if (arr[j] > arr[j + 1]) {
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;//发生交换就说明无序
			}
		}
		if (flag == 1) {//这一趟没交换说明以及有序了，后续无需排序了
			break;
		}
	}
}
int main() {
	int arr[] = { 3,1,5,7,6,4,2,9,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

四、二级指针

指针变量也是变量，是变量就会有地址，那么指针变量的地址就存放在二级指针中。

*ppa 通过对ppa中的地址进⾏解引⽤，这样找到的是 pa ， *ppa 其实访问的就是 pa

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作： *pa ，那找到的是 a 

 int b = 20;
*ppa = &b; //等价于 pa = &b;

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

 五、指针数组

指针数组是存放指针的数组。

 指针数组的每个元素都是⽤来存放地址（指针）的。

指针数组的每个元素是地址，⼜可以指向⼀块区域。

六、字符指针变量

#include <stdio.h>
int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");
	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");
	return 0;
}

 试想一下上面代码的输出结果是什么？

 这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

str1,str2相当于是创建了两个内容相同的数组，但是在开辟空间时内存不同。

六、数组指针变量

        数组指针变量存放的是数组的地址，是能够指向数组的指针变量。

思考一下下面两个哪个为数组指针？哪个为指针数组

int *p1[10];  //p1先于[]结合为一个数组，该数组中存放着int*类型的指针变量，所以为指针数组
int (*p2)[10];//p2先于*结合为一个指针，指向的类型为int[10]的数组，所以为数组指针

指向数组的指针被称为数组指针。

⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址。

 a[i][j]等价于*(*(a+i)+j)

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式。

七、函数指针变量

函数指针变量是存放函数地址的指针。

#include <stdio.h>
int Add(int x, int y)
{
return x+y;
}
int main()
{
int(*pf3)(int, int) = Add;
printf("%d\n", (*pf3)(2, 3));
printf("%d\n", pf3(3, 5));
return 0;
}

 结果输出  5

                 8

 接下来看两端有趣的代码

(*(void (*)())0)();

1.先将0强转为一个函数的地址，这个函数没有参数，返回类型是void

2.去调用0地址处的函数。

void (*signal(int , void(*)(int)))(int);

简化

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

 signal函数有两个参数，这个函数的返回类型也是一个函数指针void (*)(int)

typedef关键字

typedef?是⽤来类型重命名的，可以将复杂的类型，简单化。

typedef unsigned int uint;
//将unsigned int 重命名为uint

typedef int* ptr_t; 

typedef int(*parr_t)[5]; //新的类型名必须在*的右边

typedef void(*pfun_t)(int); //新的类型名必须在*的右边

 七、函数指针数组

那要把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组。

int (*parr1[3])();

 parr1 先和 [] 结合，说明?parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。

 函数指针的用途：转移表

计算机一般实现：

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

 使用函数指针数组的实现

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("输⼊有误\n");
		}
	} while (input);
	return 0;
}

八、回调函数

回调函数就是⼀个通过函数指针调⽤的函数。

//使⽤回调函数改造前
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输⼊操作数：");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

//使⽤回调函数改造后
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
void calc(int (*pf)(int, int)) {
	int ret = 0;
	int x, y;
	printf("请输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret=%d\n", ret);
}
int main()
{
	int input = 1;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(add);
			break;
		case 2:
			calc(sub);
			break;
		case 3:
			calc(mul);
			break;
		case 4:
			calc(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

 九、排序神器——qsort函数

qsort是stdlib.h中的函数，因此使用前需要声明。

qsort函数包含四个参数，分别是：

1.数组名

2.元素个数（从前往后计算）

3.数组元素所占字节（int，double，char等所占字节）

4.排序原则（递增，递减，奇偶交叉等）

int cmp(const void *a,const void *b) {
    return *(int*)a-*(int*)b;
}
qsort(num, n, sizeof(int), cmp);

 通过一个结构体类型，通过qsort排序char字符串类型，以及排序int类型（整型）数据。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct  stu
{
	char name[20];
	int age;
};
int cmp_stu_by_age(const void* e1, const void* e2) {
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2) {
	return strcmp(((struct stu*)e1)->name,((struct stu*)e2)->name);
}
void test2() {
	struct stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	for (int i = 0; i < sz; i++) {
		printf("%d\n", s[i].age);
	}
}
void test3() {
	struct stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	for (int i = 0; i < sz; i++) {
		printf("%s\n", s[i].name);
	}
}
int main() {
	test2();
	test3();
	return 0;
}

 利用回调函数，模拟实现qsort函数

include <stdio.h> 
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i - 1; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;
	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

 

 希望大家在看完这个文章后能有所收获，加油！感谢观看。

送给努力的人一句话：我今日所做的事远比我往日所作所为更好，更好；我今日享受的安息远比我所知的一切更好，更好......——查尔斯·狄更斯 《双城记》

guoguoqiang.
关注
专栏目录
C语言：指针——初阶指针
weixin_61926920的博客
11-05 331
1.指针是什么 在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址。它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能够找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为"指针"。意思是通过它能找打以它为地址的内存单元
C语言：指针（初阶）
m0_65140768的博客
04-01 813
地址 计算机内存每一块存储空间都有一个编号，就像每家每户都有门牌号一样，一块内存空间占据的大小是一个字节（8个比特位） 指针 什么是指针？ 指针是一种数据类型，就像char int float double这些数据类型一样，也会在内存中占据空间，只不过，指针的作用是用来存储内存空间的地址。 指针的大小 在32位环境下，指针大小为4个字节，在64位环境下，指针大小为8个字节。 指针的类型 char* 类型 int* 类型 float* 类型 ..... 指针的类型有很多，这里只介绍初阶类
c语言基础篇：指针（初阶）
摸鱼胖嘟嘟的博客
07-15 686
c语言基础篇：指针（初阶）
C语言：指针(初阶)
2402_83501061的博客
04-13 264
指针理解的2个要点：1.指针是内存中一个最小单元的编号，也就是地址2.平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量总结：指针就是地址，口语中说的指针通常指的是指针变量。指针变量：我们可以通过（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量所以我们可以得知指针变量是用来存放地址的变量。（存放在指针中的值都被当成地址处理）。同时。
初阶C语言：指针
Yikefore的博客
03-10 354
初阶C语言---指针
C语言:初阶指针和结构体
想学好c++的oMen的博客
06-26 200
文章初步讲解了指针和结构体相关知识,用于初步了解.
C语言笔记:指针(初阶)
记录学习ing
03-17 135
hey,这是我的个人C语言学习笔记,
C语言： 指针初阶的练习题目
blamep的博客
03-30 349
【代码】C语言： 指针初阶的练习题目。
c语言：初阶指针
2301_77649794的博客
06-27 131
1.指针是内存中一个最小单元的编号，也就是地址2.平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量总结：指针就是地址，口语中说的指针通常指的是指针变量图中十六进制的数字就代表地址值32位虚拟空间：CPU- 32位地址(32bit) - 地址线传输 -> 内存64位虚拟空间：CPU- 64位地址(64bit) - 地址线传输 -> 内存。
C语言初阶指针.zip
01-14
以上只是C语言指针基础的简单介绍，实际应用中还有更多高级用法，如指针数组、指针作为函数返回值等。深入理解和熟练运用指针是掌握C语言的关键，也是许多系统编程和底层开发的基础。通过学习"《C语言初阶指针》"，...
C语言-指针（初阶）
MinG的博客
02-22 825
1.野指针 概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的） 1.1野指针成因 1.指针未初始化 2.指针越界访问 3.指针指向的空间释放 1.2如何规避野指针 1.指针初始化 2.小心指针越界 3.指针指向空间释放立即置NULL 4.避免返回局部变量的地址 5.指针使用之前检查有效性 2.指针运算 指针+- 整数 指针-指针 指针的关系运算 2.1指针+-整数 2.2指针-指针 2.3指针的关系运算 3.指
C语言指针篇（初阶与进阶）
liu2286226923的博客
04-07 996
由于指针的内容很长，在这篇博客中我将会把指针分为初阶与进阶。 初阶指针 1.指针基础 认识指针；如果将内存看为街道边的一排房子，那么指针就可以看为每个房子的地址。所以C语言中指针的实质就是地址，是内存的地址。 内存地址；我们可以先定义一个语句 char ch = 'A' 那么它在内存中的地址 取址运算符；既然已经知道指针的本质是内存的地址，那么让我们了解一下地址是如何被取出来的吧。&变量名==变量地址==指针指向的地址 在得到一个变量的地址后...
C语言初阶：指针，C语言的上帝之手
凯凯在此
03-23 554
文章目录1. 指针运算1.1 算术运算符指针的自加++、自减--指针相减的意义1.2 单位长度2. 指针类型3. 二维指针数组指针与指针数组二维指针数组4. 指针常量和常量指针5. 字符串数组与字符串指针数组二维数组字符串 1. 指针运算 1.1 算术运算符 指针加整数：指针指向下一个变量 指针减整数：指针指向上一个变量 指针的自加++、自减– *p++, *p- - 与 *++p, *- -p 与 ++*p, - -*p ++、- -放在三种不同的位置，表示的含义不同，我们逐一实验 *p++, *p- -
D15【python接口自动化学习】-python基础之内置数据类型
tian_nx的博客
09-22 596
为字典增加或移除键值对，如果新增键已存在，则更新该键对应的值...
计算机毕业设计之：基于微信小程序的诗词智能学习系统（源码+文档+解答）
程序员阿龙的博客
09-22 4350
博主介绍： ✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、阿里云、InfoQ等平台的优质作者。通过长期分享和实战指导，我致力于帮助更多学生完成毕业项目和技术提升。 技术范围： 我熟悉的技术领域涵盖SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等方
大模型输入参数学习
AI智能，无处不在
09-25 270
top_p和top_k：用于控制生成文本的多样性和连贯性。较小的值会使生成的文本更连贯但缺乏多样性，较大的值会使生成的文本更随机和多样。：用于控制生成文本的随机性。较高的值增加随机性，较低的值增加确定性。：用于控制生成文本的长度。
Linux入门学习：进程概念
Lvision2的博客
09-24 1043
在课本的概念中，进程程序的一个执行实例，正在执行的程序。其内核观点：担当分配系统资源（CPU时间，内存）的实体。但这些概念太笼统，并不能让我们更加清晰的知道进程是什么，实际上，进程是内核数据结构(pcb) + 程序的代码与数据。pcb(process control block)进程控制块，进程信息被放在一个叫pcb的数据结构中，可以理解为进程属性的集合。在Linux入门学习：深刻理解计算机硬件与OS体系中，我们已经了解到。
H.264学习笔记
最新发布
zfenggo的博客
09-26 535
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值