C语言——指针(3) (超详细)

文章目录

1.字符指针变量
- 1.1什么是字符指针变量
- 1.2《剑指offer》中⼀道和字符串相关的笔试题
2数组指针变量
3 二维数组传参的本质
4. 函数指针变量
4.1 函数指针变量的创建
5.函数指针数组
6.转移表
- 6.1计算器的⼀般实现
- 6.2使用函数指针数组实现计算器：
7.qsort使用实例

1.字符指针变量

1.1什么是字符指针变量

int main()
{
    
    
 char ch = 'w';
 char *pc = &ch;//pc就是字符指针变量
const char* p = "abcdefghi";//不是将abcdewfghi\0字符串存放到p中,而是将首字符a的地址存储在p中
//"abcdefghi" 是一个常量字符串，是不能被修改的
//[abcdefghi\0]
//b = 2+3;
//表达式都有2个属性：值属性，类型属性
//2+3 值是5/	//2+3 int
//printf("%c\n", *p);
//*p = 'q';//err
printf("%s\n", p);
return 0;
}

其中pc就是字符指针变量，字符指针变量是用来存放地址的，const char* p = “abcdefghi”; 特别容易以为是把字符串 “abcdefghi”;放到字符指针 p 里了

1.2《剑指offer》中⼀道和字符串相关的笔试题

#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;
}

大家猜猜结果是什么？
在这里插入图片描述
这是因为数组名其实是数组的首个地址，而str1和str2数组的内容虽然相同但是（str1 ==str2）这个的是地址的比较，而str3和str4在*前面加上了const指向的是⼀个同⼀个常量字符串，当几个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

2数组指针变量

2.1数组指针是什么？

首先要认识到我们之前学习的指针数组，指针数组是数组，是存放指针的数组
而我们接下来学习的：数组指针
字符指针——指向字符的指针，存放的是字符的地址
char ch = 'w'; char ch * pc = &ch；
整形指针——指向整形的指针，存放的是整形的地址
int n = 100; int * p + &n;
数组指针——指向数组的指针，存放的是数组的地址
int arr[10]; int (* p)[10] = &arr; p就是数组指针

2.2注意事项！！！

int *p[10] =&arr;它是指针数组，是用来存放指针的，两者是用差别的！！！

int main()
{
    
    
	int arr[6];
	int* p = arr;
	int (*ptr)[6] = &arr;//数组的地址
		//ptr是数组指针

	char* ch[8];
	char* (*p2)[8] = &ch;//p2是数组指针

	int a = 1; int b = 2; int c = 3; int d = 4; int e = 5;
	int* parr[5] = {
    
    &a,&b,&c,&d,&e};//这是指针数组
 
	return 0;
}

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

2.3数组指针的初始化

int arr[10] = {
    
    0};
arr;//数组首元素的地址 int *
&arr;//得到的就是数组的地址 int（*）[10]
int(*p)[10] = &arr;

如果要存放个数组的地址，就得存放在数组指针变量中，如下：

在这里插入图片描述

3 二维数组传参的本质

首先我们再次理解一下二维数组，二维数组起始可以看做是每个元素是⼀维数组的数组，也就是而维数组的每个元素是一个一维数组。那么二维数组的首元素就是第⼀行，是个一维数组。所以，根据数组名是数组⾸元素的地址这个规则，二维数组的数组名表⽰的就是第一行的地址，是一维数组的地址。根据上面的例子，第一行的⼀维数组的类型就是 int [5] ，所以第⼀行的地址的类型就是数组指针类型 int(*)[5] 。那就意味着二维数组传参本质上也是传递了地址，传递的是第一行这个⼀维数组的地址，那么形参也是可以写成指针形式的。如下：

void test(int arr[3][5], int r, int c)	//行参部分写的是数组
{
    
    
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
    
    
		for (j = 0; j < c; j++)
		{
    
    
			printf("%d ", arr[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);
}//二维数组传参

大家可以再想想二维数组也是数组，二维数组的数组名也是数组首元素的地址，传递过去的数组名可以表示数组首元素的地址，那么行参是不是就可以写成指针接收？
在这里插入图片描述

代码如下:

void test(int (*arr)[5], int r, int c)
{
    
    
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
    
    
		//*(arr+i) == arr[i]
		int j = 0;
		for (j = 0; j < c; j++)
		{
    
    
			//printf("%d ", *(*(arr + i) + j));
			printf("%d ", arr[i][j]);
			//printf("%d ", (*(arr + 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);
}//二维数组传参

4. 函数指针变量

4.1 函数指针变量的创建

数组指针 —— 是指针 —— 是指向数组的指针 —— 是存放数组地址的指针
函数指针 —— 是指针 —— 是指向函数的指针 —— 是存效函数地址的指针

int Add(int x, int y)
{
    
    
	return x + y;
}

int main()
{
    
    
	//数组名 - 数组首元素的地址
	//&数组名 - 数组的地址

	

	printf("%p\n", &Add);
	printf("%p\n", Add);

	int* p1 = &Add;
	int* p2 = Add;
	
	return 0;
}

在这里插入图片描述
运行结果：

结论：
函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名的方式获得函数的地址,对于函数，（取地址）&函数名和函数名都是函数的地址.

如果我们要将函数的地址存放起来，就得创建函数指针变量咯，函数指针变量的写法其实和数组指针非常类似。如下：

void test()
{
    
    
 printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
    
    
 return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

函数指针类型解析：
在这里插入图片描述

4.2 函数指针变量的使用

int Add(int x, int y)
{
    
    
	return x + y;
}

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

	//int r = pf(3, 5);
	//printf("r = %d\n", r); 

	int r = (*pf)(3, 5); //可以通过（*pf）调用函数
	printf("r = %d\n", r);

	return 0;
}

4.3两段有趣的代码

接下来是长见识的时候啦：

代码 1 ：

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

先看看这个是什么？
void ( * p ) ( )
是不是一个函数指针
void ( * ) ( )这就个给函数指针类型
那么我们给它加上括号
( void ( * ) ( ) )
这时候就要想想了，这其实是个强制类型转换
( void ( * ) ( ) ) 0
我们可以理解为把0这个整数强制类型转换为这个函数的地址。0地址处放置一个函数要调用它，解引用，函数无参。
这样理解 （ * p ）( )
（* ( void ( * ) ( ) ) 0）（无参）

调用0地址处的函数，调用的函数是无参，返回类型是void

代码 2 ：

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

在这里插入图片描述
我们将它这样拆开来理解是不是就清晰明了了呢？可以发现
void (* p) ( int )又是一个函数指针类型

理解：
signal是一个函数的函数名，上面的代码是一次函数声明，声明的siqnal函数有2个参数，第一个参数是int类型的，第二个参数是函数指针类型的，该函数指针指向的函数参数是int类型，返回类型是voidignal函数的返回类型也是一个函数指针，该函数指针指向的函数，参数是int，返回类型是void。

两段代码均取自：《C陷阱和缺陷》这本书

4.4typedef关键字

typedef 是用来类型重命名的，可以将复杂的类型，简单化
比如你觉得 unsigned int 写起来不方便，如果改能写成 uint 就好了，那么我们可以使用typedef

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

那么如果是指针类型，我们可不可以重命名呢？
我们可以将int重命名为 ptr_t：
typedef int* ptr_t;
数组指针类型 int()[5] 重命名为 parr_t：
typedef int(*parr_t)[5]; //新的类型名必须在*的右边
函数指针类型 void(*)(int) 类型重命名为 pf_t ：
typedef void（* pf_t）(int)//新的类型名必须在*的右边

那么之前的void ( * signal ( int , void ( * ) ( int ) ) ) ( int );这个函数是不是可以这样写呢？
pf_t signal ( int , pf_t );

typedef void (*pf_t)(int);//typedef在这里重命名时，这里的pf_t是类型名
int main()
{
    
    
pf_t p1;//这里的P1就是函数指针变量
void (*p2)(int);//这里的P2是指针变量的名字
//这两行代码等价
}
pf_t signal(int , pf_t);

注意，不要想着命名为汉字

5.函数指针数组

整型指针数组:数组，数组中存放的都是整型指针
函数指针数组:数组，数组中存放的都是函数指针
把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组

int Add(int x, int y)
{
    
    
	return x + y;
}

int Sub(int x, int y)
{
    
    
	return x - y;
}

int main()
{
    
    
	int* arr[10];//整型指针的数组
	
	//int (* p1)(int,int) = Add;
	//int (* p2)(int,int) = Sub;
	
	//函数指针数组 - 存放函数指针的数组
	int (* pArr[4])(int, int) = {
    
    Add, Sub};//函数指针数组

	return 0;

6.转移表

6.1计算器的⼀般实现

#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;
}
void menu()
{
    
    
	printf("***************************\n");
	printf("*****  1. add  2.sub  *****\n");
	printf("*****  3. mul  4.div  *****\n");
	printf("*****  0. exit        *****\n");
	printf("***************************\n");
}

void calc(int(*pf)(int, int))
{
    
    
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
    
    
  int input = 0;

  do
  {
    
    
    menu();
    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;
}

6.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;
}


void menu()
{
    
    
	printf("***************************\n");
	printf("*****  1. add  2.sub  *****\n");
	printf("*****  3. mul  4.div  *****\n");
	printf("*****  0. exit        *****\n");
	printf("***************************\n");
}

int main()
{
    
    
	//函数指针的数组
	//转移表
	int (*pfArr[])(int, int) = {
    
    0, Add, Sub, Mul, Div};

	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	do
	{
    
    
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
    
    
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
    
    
			printf("退出计算器\n");
		}
		else
		{
    
    
			printf("选择错误，重新选择\n");
		}
	} while (input);

	return 0;
}

7.qsort使用实例

7.1qsort函数是什么？

qsort 是一个库函数,用来对数据进行排序,它可以排序任意类型的数据。怎么使用它呢?

让我们先来了解qsort函数，qsort函数有4个参数。

//void* 是一种指针类型 ,void*类型的指针变量，可以接收任意数据类型的地址
void qsort(

	   void* base, //base指向待排序的第一个元素

       size_t num,  //待排序的元素个数
       
       size_t size, //待排序的数组元素的大小，单位是字节
       
       int (*compar)(const void*e1, const void*e2) 
       //compar是一个函数指针，指向的函数能够比较2个元素);
       //当e1>e2时返回1当e

qsort函数使用的是[快速排序]的思想排序数据的
排序的算法很多：比如冒泡排序，选择排序，插入排序，希尔排序，快速排序…

7.2 qsort使用举例

注意先引用头文件

#include <stdio.h>
//这个函数能够比较e1和e2指向的两个元素，并且给出返回值
int cmp_int(const void* e1, const void* e2)
{
    
    
	return *(int*)e1 - *(int*)e2;
}

void print_arr(int arr[], int sz)
{
    
    
	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//test1测试qsort排序整型数组
void test1()
{
    
    
	int arr[] = {
    
     3,1,5,7,2,4,8,6,0,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
int main()
{
    
    
  test1();
  return 0;
}

运行结果如下：
在这里插入图片描述

7.3 qsort函数的模拟实现

函数主体部分

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
{
    
    
    //趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
    
    
        //一趟冒泡排序的过程
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
    
    
            //if (arr[j] > arr[j + 1])
            if(cmp((char*)base+j*width, (char*)base +(j+1)*width) > 0)
            {
    
    
                //交换
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

函数交换部分

void Swap(char* buf1, char* buf2, size_t width)
{
    
    
  int i = 0;
  for (i = 0; i < width; i++)
  {
    
    
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}

接下来我们来测试函数

void print_arr(int arr[], int sz)
{
    
    
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    
    
    printf("%d ", arr[i]);
  }
  printf("\n");
}


void test1()
{
    
    
    int arr[] = {
    
     3,1,5,2,4,8,7,6,9,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr, sz);
}


int main()
{
    
    
  test1();
  return 0;
}

运行结果如下：
在这里插入图片描述
完整代码如下：

#include <stdio.h>
void Swap(char* buf1, char* buf2, size_t width)
{
    
    
  int i = 0;
  for (i = 0; i < width; i++)
  {
    
    
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
  }
}

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
{
    
    
    //趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
    
    
        //一趟冒泡排序的过程
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
    
    
            //if (arr[j] > arr[j + 1])
            if(cmp((char*)base+j*width, (char*)base +(j+1)*width) > 0)
            {
    
    
                //交换
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}




int cmp_int(const void* e1, const void* e2)
{
    
    
  return *(int*)e1 - *(int*)e2;
}



void print_arr(int arr[], int sz)
{
    
    
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    
    
    printf("%d ", arr[i]);
  }
  printf("\n");
}


void test1()
{
    
    
    int arr[] = {
    
     3,1,5,2,4,8,7,6,9,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    print_arr(arr, sz);
}

int main()
{
    
    
  test1();
}