【C语言进阶】- 指针 (秒懂令人头疼的指针)

最新推荐文章于 2024-06-07 15:52:19 发布

难吃的茄子

最新推荐文章于 2024-06-07 15:52:19 发布

阅读量1k

点赞数 9

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/m0_62605243/article/details/136285236

版权

指针

1.1 指针的概念

指针就是一个变量，用来存放地址，地址标识一块内存空间
指针的大小是固定4/8个字节(32位平台/64位平台)
指针的类型决定了指针的加减整数的步长，指针解引用操作时候的权限。

1.2 字符指针

#include <stdio.h>
int main()
{
	const char *p = "abcdef";
	// *p = 'w'; // err，因为abcdef为常量
	printf("%s\n",p);
	return 0;
}

这里是把abcdef字符串的首字符a的地址给到了p，const 来修饰*p，意为不可修改所指向的地址的值

在这里插入图片描述
练习：

#include <stdio.h>
int main()
{
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";


	
	if (p1 == p2)
		printf("p1 == p2\n");
	else 
		printf("p1 != p2\n");


	char arr1[] = "abcdef";
	char arr2[] = "abcdef";


	if (arr1 == arr2)
		printf("arr1 == arr2\n");
	else
		printf("arr1 != arr2\n");

	return 0;
}

在这里插入图片描述

这里p1和p2指向的都是常量池中的同一块地址，所以，是相同的

在这里插入图片描述

这里比较的是两个数组的地址，很明显，这是两个数组啊，地址肯定不相同，所以是不等于的。

在这里插入图片描述

2.1 指针数组

根据指针的前置的内容，我们知道了这些

int *arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

那么，我们也自然得出了，指针数组，也就是存放指针的数组

#include <stdio.h>

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int *parr[] = { arr1,arr2,arr3 }; // 存放1,2,3的地址，也就是各个数组首元素的地址
	
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			// *(p+i) -> p[i]
			printf("%d ",*(parr[i]+j));
			//printf("%d ",parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在这里插入图片描述

2.2 数组指针

我们知道

int *p1;   //整型指针
float *p2;   //浮点型指针

那么数组指针也就是指向数组的指针

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

p1是指针数组
p2是数组指针，p2指向一个数组，数组有10个元素，每个元素时int类型

前置知识

1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
2.数组名，这里的数组名表示的是整个数组，所以&数组名取出的是整个数组的地址
3.sizeof和& 时数组名是代表整个数组其他时候数组名都是首元素的地址

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };

	printf("%p\n",arr);  // arr -> int*
	printf("%p\n",arr+1);

	printf("%p\n", &arr[0]); // &arr[0] -> int*
	printf("%p\n", &arr[0] + 1);

	printf("%p\n", &arr);
	printf("%p\n", &arr + 1);
	return 0;
}

在这里插入图片描述

第一个arr+1是取出数组首元素的地址，再加1，我们指定arr是int*类型，再加1是4个字节。
第二个也是取出数组首元素的地址，再加1，我们指定arr是int*类型，再加1是4个字节。
第三个则不同了，取出的是整个数组，整个数组加1，跳过了40个字节

有了上面的知识我们再看下面的代码

int arr[10] = {0};
int *p = arr;  // 取出的是首元素的地址
int (*p2)[10] = &arr; // 取出的是整个数组的地址

我们知道，去变量名就是这个变量的类型
例如:int *p;
类型就是int*
那么同理int (*p2)[10];
类型就是int (*)[10]
这个就是数组指针类型

数组指针的使用

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int (*p)[10] = &arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ",*(*p+i)); //  p是指向数组，*p就是数组名，数组名是首元素的地址，所以*p是数组首元素的地址
	}

	return 0;
}

在这里插入图片描述

#include <stdio.h>

void print1(int arr[3][5], int r, int w)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < w; j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int (*p)[5], int r, int w)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < w; j++)
		{
			// *(p + i)   拿到每一行的数据，进行解引用
			// (*(p+i)+j) 拿到每一个数据，进行解引用
			
			//printf("%d ",*( *(p + i) + j) );
			printf("%d ", p[i][j]);
		}
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print1(arr,3,5); // 数组传参
	print2(arr,3,5)
	return 0;
}

arr传参，传递的首元素的地址
对于二维数组来说，就是传递的是第1行的地址
int (*p)[5] 指向的是第1行的一维数组

在这里插入图片描述
学了指针数组和数组指针我们来一起回顾并看看下面代码的意思

int arr[5];        // 整型数组
int *parr1[10];    // 整型指针数组
int (*parr2)[10];  // 指针数组
int (*parr3[10])[5]; // 存放数组指针的数组

类型是 int (*[10])[5]

在这里插入图片描述

3.1 一维数组传参

在这里插入图片描述

3.2 二维数组传参

在这里插入图片描述

4.1 一级指针传参

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
一级指针
一维数组的数组名

4.2 二级指针传参

当函数的参数为二级指针的时候，可以接收什么参数？
一级指针
二级指针
指针数组

5.1 函数指针

先来看一段代码

void Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p ",&Add);
	return 0;
}

在这里插入图片描述

没想到吧！还有函数指针这种东西！

#include <stdio.h>
void Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p ",&Add); // 写法1
	printf("%p ",Add); // 写法2，这两种方法一样都是拿到了函数的地址

	// 利用函数指针来接收函数的地址
	int (*pf) (int,int) = &Add;

	// 通过函数指针来调用方法
	int r = pf(10, 20);
	//int r = Add(2, 3); // 传统方法来调用函数

	printf("%d\n",r);
	
	return 0;
}

函数指针就是用来存放函数地址的

5.2 函数指针数组

#include <stdio.h>

int Add(int x,int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}

int main()
{
	// 函数指针
	int(*pf)(int,int) = Add;

	// 函数指针数组
	int(*pArr[4])(int, int) = { Add,Sub,Mul,Div };
	return 0;
}

int(*pArr[4])(int, int);
这颗*,说明pArr是指针，[4]说明是数组，int(*)(int,int)，说明是函数指针，所以合起来就是函数指针数组

5.3 指向函数指针数组的指针

// //指向函数指针数组的指针

int (*parr[4])(int, int) = { Add,Sub,Mul,Div };

int(*(*pparr)[4])(int,int) = &parr;

// int (*(*)[4])(int,int) // 类型

int(*(*pparr)[4])(int,int) = &parr;
前面的*，说明pparr是指针，int(*pparr[4])(int,int)是函数指针数组，合起来就是说指向函数指针数组的指针

6.1 void*指针

什么是void*的指针呢？看下面的代码

#include <stdio.h>
int main()
{
	int a = 10;
	char* pa = &a; // int*

	void* pv = &a; 
	return 0;
}

void*是无具体类型的指针，可以接受任意类型的地址
void* 是无具体类型的指针，所以不能进行解引用操作，也不能±整数

6.2 冒泡排序和qsort函数的使用

普通冒泡排序

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	int flag = 1; // 当数组是默认为升序时，进行处理
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			}
			
		}
		if (flag)
		{
			break;
		}
	}
}

普通冒泡排序产生的问题：只能排序整型数组的数据，不能排序其他类型的数据，那么怎么解决呢？我们先说明qsort函数的使用

qsort函数
在这里插入图片描述

//void qsort(void* base,      // 排序的数据的起始位置
//	size_t num,				  // 排序的数据个数
//	size_t width,			  // 排序的数据元素的大小 (字节)
//	int(__cdecl* compare)(const void* elem1, const void* elem2)); // 函数指针 - 比较函数

int cmp_int(const void* e1, const void* e2)
{
	// >0 返回1
	// =0 返回0
	// <0 返回-1
	return (*(int*)e1) > (*(int*)e2); // 因为是void*类型，需要转换为int*类型
}

void test1()
{
	int arr[] = { 1,2,3,5,4,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort(arr,sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

对结构体的数据进行排序

struct Stu
{
	char name[10];
	int age;
};

int cmp_stu_by_name(const void* e1,const void* e2)
{
	// strcmp 返回值是int
	return strcmp(
		((struct Stu*)(e1))->name,
		((struct Stu*)(e2))->name
	);
}

int cmp_stu_by_age(const void* e1, const void* e2)
{
	return
		((struct Stu*)(e1))->age,
		((struct Stu*)(e2))->age
	;
}

// 测试结构体数据的排序
void test2()
{
	
	struct Stu s[] = { {"zhangsan",18},{"lisi",20},{"wangwu",40} };
	int sz = sizeof(s) / sizeof(s[0]);
	// 按照姓名排序
	qsort(s,sz,sizeof(s[0]), cmp_stu_by_name);
	// 按照年龄排序
	//qsort(s,sz,sizeof(s[0]), cmp_stu_by_age);
}

基于qsort函数来对上面的冒泡排序进行改造，这样就能排序任意数据了


int cmp_int(const void* e1, const void* e2)
{
	// >0 返回1
	// =0 返回0
	// <0 返回-1
	return (*(int*)e1) > (*(int*)e2);
}

// 交换两个元素，不知道是什么类型，用char，一个字节一个字节来交换
void Swap(char* buf1,char* buf2,int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char temp = *buf1;
		*buf1=*buf2;
		*buf2=temp;

		buf1++;
		buf2++;
	}
}
void bubble_sort2(void* base, int num,int width, int (*cmp)(const void* e1,const void* e2))
{
	int i = 0;
	int flag = 1; // 当数组是默认为升序时，进行处理
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
		    // 比较两个元素，不知道是什么类型，用char
			if (cmp((char*) base + j * width, (char*)base + (j + 1) * width ) > 0)
			{
				// 交换
				Swap((char*)base+j*width,(char*)base+(j+1)*width,width);
				flag = 0;
			}
			
		}
		if (flag)
		{
			break;
		}
	}
}


void test3()
{
	int arr[] = { 1,2,3,5,4,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort2(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

在这里插入图片描述

难吃的茄子

关注

9
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
【C语言进阶】- 指针 (秒懂令人头疼的指针)

前面的*，说明pparr是指针，int(*pparr[4])(int,int)是函数指针数组，合起来就是说指向函数指针数组的指针。这颗*,说明pArr是指针，[4]说明是数组，int(*)(int,int)，说明是函数指针，所以合起来就是函数指针数组。1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。这里比较的是两个数组的地址，很明显，这是两个数组啊，地址肯定不相同，所以是不等于的。2.数组名，这里的数组名表示的是整个数组，所以&数组名取出的是整个数组的地址。
复制链接

扫一扫