C语言-指针深入理解

于 2019-11-10 22:06:58 发布
阅读量265 收藏 1
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44695386/article/details/102981243
版权

指针的进阶

1. 字符指针

字符指针 char*使用方法
在这里插入图片描述
代码 char* pstr = "hello world"; 特别让人以为是把字符串 hello world 放到字符指针 pstr 里了，但是/本 质是把字符串 hello world 首字符h的地址放到了pstr中。

面试题
在这里插入图片描述
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。 指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开 辟出不同的内存块。所以str1和str2不同，str3和str4不同。

2.指针数组

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

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

数组指针：能够指向数组的指针。

int (*p) [10];

p先和结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
注意：[]的优先级要高于号的，所以必须加上（）来保证p先和 * 结合

&数组名和数组名
对如下代码：

#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 表示的是数组的地址，而不是数组首元素的地址。
  • 数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40
  • 数组名在两个情况下代表整个数组：&arr和sizeof(arr)
    数组指针的使用
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int(*p)[10] = &arr;
	printf("%p\n", p);//p代表整个数组
	printf("%p\n", *p);
	printf("%d\n", **p);
	printf("%d\n", *((*p)+2));//打印3
	return 0;
}

运行结果：
在这里插入图片描述
一个数组指针的使用（数组元素的打印）

void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0, j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	int i = 0, j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void Show(int (*arr)[5])
{
	int i = 0, j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; 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);
	print_arr2(arr, 3, 5);
	Show(arr);
	return 0;
}

总结

  • 数组名arr,表示首元素地址。
  • 二维数组的首元素是二维数组的第一行
  • 二维数组是特殊的一维数组
  • 可以用数组指针来接受
  • []自带解引用
arr[i]=*(arr+i)
arr[i][j]=*(*(arr+i)+j)
4. 数组传参和指针传参

一维数组传参

void test(int arr[])//ok
{} 
void test(int arr[10])//ok 
{} 
void test(int *arr)//ok
{} 
void test2(int *arr[20])//ok
{} 
void test2(int **arr)//ok
{} 
int main() 
{    
	int arr[10] = {0};    
	int *arr2[20] = {0};    
	test(arr);    
	test2(arr2); 
}

二维数组传参

void test(int arr[3][5])//ok
{}
void test(int arr[][])//no
{}
void test(int arr[][5])//ok
{} 
void test(int *arr)//ok
{} 
void test(int* arr[5])//no
{} 
void test(int (*arr)[5])//ok
{} 
void test(int **arr)//no
{} 
int main() 
{    
	int arr[3][5] = {0};    
	test(arr); 
}

总结

  • 二维数组传参，函数形参的设计只能省略第一个[]的数字。
  • 因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
  • 一级指针访问二维数组：i*col+j

一级指针传参

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

当一个函数的参数部分为一级指针时，函数可以接受什么类型的参数？

void test1(int *p) 
{} 
//test1函数能接收int* 类型的参数
void test2(char* p) 
{} 
//test2函数能接收char* 类型的参数

二级指针传参

void test(int** ptr) 
{ 
	printf("num = %d\n", **ptr); 
} 
int main() 
{ 
	int n = 10;    
	int*p = &n;    
	int **pp = &p;    
	test(pp);// num=10
	test(&p);// num=10    
	return 0; 
}

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

void test(char **p) 
{ 

} 
int main() 
{
	char c = 'b';    
	char *pc = &c;    
	char **ppc = &pc;    
	char* arr[10];    
	test(&pc);    
	test(ppc); 
	test(arr);   
	return 0; 
}

当函数的参数为二级指针的时候，可以接收一级指针的地址，二级指针，指针数组。

5. 函数指针
void test() 
{ 
	printf("hehe\n"); 
} 
int main()
{
	test();
	(*test)();
	(*(&test))();
	void(*p)()=test;
	p();
	return 0;
}

p是一个指针，指向一个函数，没有参数，返回值为void

分析如下代码：

代码1
(*(void(*)())0)();

把0强转为函数指针（地址），调用0号地址的无参，返回值为void类型的函数

//代码2
(*signal(int , void(*)(int)))(int);

signal是一个函数，它有两个参数，一个是int,一个是函数指针。
函数的返回值是函数指针 void(*)(int)
代码2的化简：

typedef void(*p)(int);
p signal(int, p);
6. 函数指针数组

void (*p[10])(int) 存放函数指针的数组

函数指针数组的使用：转移表

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;
	while (input)
	{
		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);
			break;
		case 2:
			printf("输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			break; 
		case 3:
			printf("输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			break; 
		case 4:
			printf("输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			break;
		dafault:
			printf("选择错误\n");
			break;
		}
		printf("ret=%d\n", ret);
	}
	return 0;
}
//使用函数指针数组实现
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. 指向函数指针数组的指针

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

// void (*p) (); 函数指针
// void (*p[5]) (); 函数指针数组
// void(*(*p)[5]) (); 指向函数指针数组的指针

如何定义？

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

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这 个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而 是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

使用回调函数，模拟实现qsort（采用冒泡的方式）

//模拟实现 myqsort
int _cmpInt(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 MyQsort(void *base, int len, int  size,
	int(*cmp)(const void *p1, const void *p2))
{
	//冒泡排序
	int i = 0;//趟数
	for (i = 0; i < len - 1; i++)
	{
		int j = 0;//次数
		for (j = 0; j < len - 1 - i; j++)
		{
			if (cmp((char *)base + j*size,
				(char *)base + (j + 1)*size) > 0)
			{
				//交换   一个字节一个字节进行交换
				_swap((char *)base + j*size,
					(char *)base + (j + 1)*size, size);
			}
		}
	}
}
void Show(int *arr, int len)
{
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 12, 6, 3, 1, 9, 7, 2, 8, 19, 5 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Show(arr, len);
	MyQsort(arr, len, sizeof(int), _cmpInt);
	Show(arr, len);
	return 0;
}
vitobo
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值