C语言指针详解三

C语言指针详解三

1. 字符指针变量

• 一般的字符指针变量

int main()
{
	char ch = 'w';
	char* pch = &ch;
	*pch = 'x';
	printf("%c", ch);
	return 0;
}

• 还有一种使用方法

int main()
{
	const char* pstr = "hello";
	printf("%s", pstr);
	return 0;
}

注意：const在 * 的左面为不能修改该指针指向变量的值，const在 * 的右面为不能修改该指针指向的变量。

代码 const char pstr = “hello”; 的本质为把该字符串首字符（h）的地址放到了该指针变量中。

• 使用示例：

int main()
{
	char str1[] = "hello";
	char str2[] = "hello";
	const char* str3 = "hello";
	const char* str4 = "hello";
	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. 数组指针变量

指针数组 int parr[ ] = { arr1,arr2,arr3 };* 为存放指针变量的数组，它的本质是一个数组。

而数组指针，存放的是数组的地址，能够指向数组的指针变量，它的本质为指针。

整型指针： int* pa=&a；

数组指针：int (*p)[ 10 ];

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

• 数组指针变量的初始化

如果要存放个数组的地址，就需要存放在数组指针变量中。

int arr[10] = { 0 };
int(*p)[10] = &arr;
//其中的变量p就存放着该数组的地址。

注意 ：类型要完全匹配，两个数组中元素的个数要保持完全一致。

3. 二维数组传参的本质

在二维数组中，可以将每一个一维数组看作二维数组的一个元素，也就是说，二维数组的每个元素是⼀个⼀维数组。那么二维数组的首元素就是第⼀行，是一个一维数组。

例如：

int array[3][5] = { 0 };
//其中的[3]可以理解为这个二维数组有三个元素（即三个一维数组）
//后面的[5]可以理解为二维数组中的每一个元素（一维数组）有五个元素

所以，根据数组名是数组首元素的地址这个规则，二维数组的数组名表示的就是第一行的一维数组的地址。

• 二维数组传参本质上也是传递了地址，传递的是第一行的整个一维数组的地址。（注意不是一维数组首元素的地址）

二维数组传参示例：

#include<stdio.h>
//(*p)表示该二维数组首元素（即第一行的一维数组）的地址
void arrPrint(int(*p)[5], int h, int l)
{
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < l; 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} };
	arrPrint(arr, 3, 5);
	return 0;
}

理解方法：

printf("%d ", *(*(p + i) + j));
//p就是第一行一维数组的地址，+i表示往下一个一维数组（即二维数组的元素）跳转。
//+j表示在一个一维数组中，往后跳一个元素。

4. 函数指针

函数指针变量是用来存放函数地址的，未来可以通过地址调用函数。

函数的地址就是函数名，Fun与&Fun完全等价。

• 函数指针变量的创建方法：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf)(int, int) = &Add;
	return 0;
}

注意：

int (*)(int, int)//这个为该函数指针的类型

• 通过函数指针调用被指针指向的函数。

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

5. 代码分析

( * ( void (*)() ) 0 )();
//void(*)()为函数指针类型，该函数返回类型为void，并且没有参数
//( void (*)() 0 )为强制类型转换，将0转换为void(*)()类型的函数指针变类型
//可以认为在地址0x00000000处放置着一个返回类型为void的无参函数，可以设为pF()
//最终为调用这个函数——(*pF)(void);
//调用时可类比为(*pf)(10, 10)

6. typedef关键字

• typedef 是用来给类型重命名的，可以将复杂的类型简单化。

例如：将 unsigned int 改写为 uint。

#include<stdio.h>
typedef unsigned int uint;
int main()
{
	unsigned int a = 10;
	uint b = 100;
	printf("%u %u ", a, b);
	return 0;
}

• 但是对于数组指针和函数指针有些不同：

例如我们想要把数组指针类型 int( * )[ 5 ] 重命名为 parr 可以这样写：

#include<stdio.h>
typedef int(*parr)[5]; //新的类型名必须在*的右边
int main()
{
	int arr[5] = { 0 };
	parr pa = &arr;
    //parr为类型，pa为变量名。
	return 0;
}

函数指针类型的重命名也一样，例如将 void( * ) ( int ) 类型重命名为 pfv ，就可以这样写：

#include<stdio.h>
typedef void(*pfv)();
void print()
{
	printf("Hello World");
}
int main()
{
	pfv pf = &print;
    //pfv为变量类型，pf为变量名称。
	(*pf)();//函数调用
	return 0;
}

输出示例：

7. 函数指针数组

数组是一个存放相同类型数据的存储空间，例如指针数组（数组的每个元素是指针变量）：

int main()
{
	int arr1[10] = { 0 };
	int arr2[10] = { 0 };
	int arr3[10] = { 0 };
	int* parr[] = { arr1,arr2,arr3 };//指针数组
	return 0;
}

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

• 定义：

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 main()
{
	int(*pfarr[2])(int, int) = { add,sub };
	return 0;
}

• 一个数组中，只可以存放相同类型的函数指针。

8. 函数指针数组的用途：转移表

• 实现简单计算器

#include <stdio.h>
//函数部分
//加减乘除这四种函数指针的类型均为 int (*pf)(int,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;
}
void menu()
{
  	printf("1.add  2.sub  3.mul  4.div  0.exit\n");
	printf("输入你的选择：");
}
int main()
{
    int x = 0, y = 0;//两个操作数
    int input = 0;//用户输入的调用的函数ID
    int ret = 0;//计算结果
    //转移表
    int(*p[5])(int x, int y) = { 0, add, sub, mul, div };//函数指针数组
        do{
            menu();
            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 != 0);
        return 0;
}

9. 回调函数

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

如果你把函数的指针作为参数传递给另⼀个函数，当这个指针被用来调用它指向的函数时，被调用的函数就是回调函数。

• 回调函数的例子——简单计算器重制

#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 menu()
{
	printf("1.add  2.sub  3.mul  4.div  0.exit\n");
	printf("输入你的选择：");
}
//传入函数指针
int calc(int (*pf)(int, int))
{
	printf("输入两个操作数:\n");
	int a = 0, b = 0, ret = 0;
	scanf("%d %d", &a, &b);
	//执行对应函数的操作
	ret = (*pf)(a, b);
	return ret;
}
int main()
{
	int input = 0;
	do {
		menu();
		scanf("%d", &input);
		if (input >= 1 && input <= 4) {
			//函数指针数组
			int (*pfarr[])(int, int) = { 0,add,sub,mul,div };
			//找到对应数组中存放函数的地址
			int ret = calc(pfarr[input]);
			printf("%d\n", ret);
		}
		else {
			printf("请重新输入\n");
		}
	} while (input != 0);
	printf("已退出\n");
	return 0;
}

• 在上述代码中，函数 calc( )就是回调函数。

10. qsort( )函数的应用

• qsort( )函数的使用方法
• 注意：qsort( ) 需要在头文件 <stdlib.h> 下使用

void qsort(void* base, size_t num, size_t size, int (*comper)(const void*, const void*));
// void* base	-- 指针，指向待排序数组的第一个元素
// size_t num	-- 是待排序数组元素的个数
// size_t size	-- 是待排序数组元素的大小
// int (*comper)(const void*, const void*)	--函数指针，就是两个元素比较大小的函数

• 参数顺序：首元素地址——数组元素个数——每个元素大小——比较函数指针。

• qsort( )函数示例——排序整型数组

#include<stdio.h>
#include<stdlib.h>
//在使用qsort()函数时需要实现一个比较函数
int cmp(const void* a,const void* b)//const修饰为左定值右定址。
{
	return *(int*)a - *(int*)b;//由于a和b均为void*类型，我们要根据排序数据的类型来强制类型转化a和b。
}
//若该函数返回值大于零，则会交换*a与*b两个数，其余情况不交换，即默认为升序模式。
//注意：该函数可以比较两个数的大小，并且告诉qsort()函数它的返回值是正数、零还是负数。
int main()
{
	int arr[10] = { 1,9,2,8,3,7,4,6,5,10 };
	int num = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, num, sizeof(int), cmp);
    //打印数组
	for (int i = 0; i < num; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

输出结果：

• 使用冒泡排序算法模拟实现qsort( )函数

#include<stdio.h>
//比较函数
int cmp(const void* a, const void* b)
{
	return *(int*)a - *(int*)b;
}
//交换函数的写法——因为一次只能交换1B，所以要循环wide（一个元素的大小）次
void swap(char* p1, char* p2,int wide)
{
	for (int i = 0; i < wide; i++) {
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}

}
//类比于qsort( )函数的四个参数，采取冒泡排序算法
void bubbleSort(void* base, int sz, int wide, int (*cmp)(const void*, const void*))
{
	for (int i = 0; i < sz-1; i++) {
		for (int j = 0; j < sz - 1 - i; j++) {
			//在这里由于不知道需要比较的具体类型，根据参数中传递的wide值（元素大小），
			//把void*类型转化为char*类型
			//j*wide与（j+1）*wide可以类比为*(arr+j)和*(arr+j+1)
			if (cmp((char*)base + j * wide, (char*)base + (j + 1) * wide) > 0) {
				swap((char*)base + j * wide, (char*)base + (j + 1) * wide, wide);
			}
		}
	}
}
int main()
{
	int arr[] = { 1,0,2,9,3,7,4,6,5,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, sz, sizeof(int),cmp);
	for (int i = 0; i < sz; i++) {
		printf("%d ", *(arr + i));
	}
	return 0;
}

输出结果：

11. strlen( ) 函数与sizeof( ) 操作符的区别

sizeof( )操作符	strlen( )函数
sizeof( )计算操作数所占内存的大小， 单位是字节（B）	strlen( )是库函数，需要包含头文件<string.h>
sizeof( )不关注内存中存放的是什么数据	srtlen( )是求字符串长度的，统计的是\0之前字符的个数，如果没有\0，就会持续往后寻找，可能发生越界