c语言指针（三）

孤サ月

已于 2024-03-20 14:20:14 修改

阅读量1.9k

点赞数 67

分类专栏： c语言文章标签： c语言开发语言

于 2024-03-17 07:30:00 首次发布

本文链接：https://blog.csdn.net/qq_52725268/article/details/136765311

版权

c语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

c语言指针（三）

c语言指针（三）

1.字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ；

一般使用：

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	return 0;
}

还有一种使用方式如下：

#include <stdio.h>

int main()
{
	const char* pstr = "hello solity";  //这里是把一个字符串放到pstr指针变量里了吗？
	printf("%s\n", pstr);
	return 0;
}

代码 const char* pstr = “hello solity”;

特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello bit. 首字符的地址放到了pstr中。上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中.

那么用一下代码来显示这个问题的结果：

#include <stdio.h>
int main()
{
	char str1[] = "hello solity";
	char str2[] = "hello solity";
	const char* str3 = "hello solity";
	const char* str4 = "hello solity";
	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相同。

2.指针数组

在指针（一）文章中已经提到，可以翻看这篇文章

c语言指针（一）

3.数组指针

3.1数组指针的定义

数组指针是指针？还是数组？

答案是：指针。

我们已经熟悉：

整形指针： int * pint; 能够指向整形数据的指针。

浮点型指针： float * pf; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

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

解释：

int (*p)[10];

解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

这里要注意：[]的优先级要高于 * 号的，所以必须加上（）来保证p先和*结合

3.2&数组名VS数组名

对于下面的数组：

int arr[10]; //arr 和 &arr 分别是啥？

我们知道arr是数组名，数组名表示数组首元素的地址。

那&arr数组名到底是啥？

我们看一段代码：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr);
	return 0;
}

运行结果如下：

在这里插入图片描述

可见数组名和&数组名打印的地址是一样的。

难道两个是一样的吗？

我们再看一段代码：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

运行结果：

在这里插入图片描述

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）

本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型。

数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.

3.3数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

看代码：

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[10] = &arr;  //把数组arr的地址赋值给数组指针变量p
	return 0;
}

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	printf("\n");
	print_arr2(arr, 3, 5);
	return 0;
}

在这里插入图片描述

数组名arr，表示首元素的地址，但是二维数组的首元素是二维数组的第一行。
所以这里传递的arr2，其实相当于第一行的地址，是一维数组的地址。
可以数组指针来接收。

4. 数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

4.1一维数组传参

⾸先从⼀个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给⼀个函数后，函数内部求数组的元素个数吗？

#include <stdio.h>
void func(int arr[])
{
	int sz2 = sizeof(arr) / sizeof(arr[0]);
	printf("sz2 = %d\n", sz2);
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz1 = sizeof(arr) / sizeof(arr[0]);
	printf("sz1 = %d\n", sz1);
	func(arr);
	return 0;
}

运行结果：

在这里插入图片描述

我们发现在函数内部是没有正确获得数组的元素个数。

这就要学习数组传参的本质了。我们知道数组名是数组⾸元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组⾸元素的地址。

所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址。那么在函数内部我们写sizeof(arr) 计算的是⼀个地址的大小（单位字节）⽽不是数组的⼤⼩（单位字节）。正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

#include <stdio.h>

void func1(int arr[])//参数写成数组形式，本质上还是指针
{
	printf("%d\n", sizeof(arr));
}

void func2(int* arr)//参数写成指针形式
{
	printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	func1(arr);
	func2(arr);
	return 0;
}

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

运行结果：

在这里插入图片描述

4.2二维数组传参

有了数组指针的理解，我们就能够开始了解⼀下⼆维数组传参的本质了。

我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的：

#include <stdio.h>
void test(int a[3][5], int r, int c)
{
	for (int i = 0; i < r; i++)

	{
		for (int j = 0; j < c; j++)
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

运行结果：

在这里插入图片描述

这⾥实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？

⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。

如下图：

在这里插入图片描述

根据数组名是数组⾸元素的地址这个规则，⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址。

根据上⾯的例子，第一行的⼀维数组的类型就是 int [5] ，所以第⼀⾏的地址的类型就是数组指针类型 int(*)[5] 。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第一行这个⼀维数组的地址，那么形参也是可以写成指针形式的。如下：

#include <stdio.h>

void test(int(*p)[5], int r, int c)
{
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

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

4.3一级指针传参

#include <stdio.h>

void func(int* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	func(p, sz); //一级指针p，传给函数
	return 0;
}

运行结果：

在这里插入图片描述

4.4二级指针传参

#include <stdio.h>

void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}

int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

运行结果：

在这里插入图片描述

5.函数指针

首先看一段代码：

#include <stdio.h>

void func()
{
	printf("solity\n");
}
int main()
{
	printf("%p\n", func);
	printf("%p\n", &func);
	return 0;
}

输出结果：

在这里插入图片描述

输出的是两个地址，这两个地址是 func 函数的地址。那我们的函数的地址要想保存起来，怎么保存？

下面我们看代码：

void func()
{
 printf("solity\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？答案是：

pfun1可以存放。

pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

6.函数指针数组

数组是⼀个存放相同类型数据的存储空间，我们已经了解了指针数组，⽐如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

答案是：parr1

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("*************************\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");
			breark;
		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 }; //转移表
	while (input)
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

7.指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针 ;

如何定义？

#include <stdio.h>

void func(const char* str)
{
	printf("%s\n", str);
}

int main()
{
	void (*pfun)(const char*) = func;  //函数指针pfun
	void (*pfunArr[5])(const char* str);  //函数指针的数组pfunArr
	pfunArr[0] = func;
	void (*(*ppfunArr)[5])(const char*) = &pfunArr;  //指向函数指针数组pfunArr的指针ppfunArr
	return 0;
}

8.回调函数qsort

回调函数就是一个通过函数指针调用的函数。qsort是 stdlib.h 中的函数，因此使用前需要声明

#include <stdlib.h>

如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

对上述例子使用回调函数：

#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("*************************\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");
			breark;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

使用前和使用后的对比：
在这里插入图片描述

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函数的使用：

1.使⽤qsort函数排序整型数据

#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;
	qsort(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;
}

2.使⽤qsort排序结构数据:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

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

int stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void func1()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), stu_by_age);
}

int stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void func2()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), stu_by_name);
}

int main()
{
	func1();
	func2();
	return 0;
}

2.使⽤qsort排序结构数据:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

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

int stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void func1()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), stu_by_age);
}

int stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void func2()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), stu_by_name);
}

int main()
{
	func1();
	func2();
	return 0;
}

孤サ月

关注

67
点赞
踩
52

收藏

觉得还不错? 一键收藏
1
评论
c语言指针（三）

数组指针是指针？还是数组？答案是：指针。我们已经熟悉：整形指针： int * pint;能够指向整形数据的指针。浮点型指针： float * pf;能够指向浮点型数据的指针。那数组指针应该是：能够指向数组的指针。下面代码哪个是数组指针？//p1, p2分别是什么？解释：解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。[]的优先级要高于 * 号的，所以必须加上（）来保证p先和*结合。
复制链接

扫一扫