C语言—— 指针学习（第三节）

一、字符指针变量

通过之前的学习，我们了解了指针，int是整型指针，指向的是整型；那么，指向字符型的指针就是字符指针，即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 world";
 printf("%s\n", pstr);
 return 0;
}

看上述代码，是把"hello world"这个字符串放在pstr里了吗？其实不然，这里只是把这个字符串首字符的地址存放到了指针pstr里。有了对字符指针的理解，看以下代码：

#include <stdio.h>
int main()
{
 char str1[] = "hello world";
 char str2[] = "hello world";
 const char *str3 = "hello world";
 const char *str4 = "hello world";
 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都是数组名，代表首元素的地，址不都是存放'h'的地址吗，怎么不一样呢？

​ 这里需要注意，str1与str2是两个不同的数组，虽然存放的内容是一样的，但是在内存中的存放的位置是不一样的。

编辑

这里str3和str4都是指向一个常量字符串，C/C++中会把常量字符串存储到单独的内存空间，当多个指针指向同一个常量字符串是，所指向的是同一个地址。

二、数组指针

​ 在之前的学习中，我们学习到了指针数组，知道指针数组是存放指针变量的数组。

​ 之前还学到整型指针变量，存放的是整型变量的地址，它所指向的是一个整形变量。

那这里，数组指针，就也是一种指针，存放数组的地址，那个指向数组的指针变量

<1>数组指针变量

int (*p)[10];

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

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

<2>数组指针变量的初始化

定义数组指针变量以后，那该怎么初始化与赋值呢？在学习指针（2）中数组名的理解，我们知道&数组名取的是整个数组的地址，那么这里就可以讲数组的地址赋值给数组指针变量。

int arr[10]={0};
int (*p)[10]=&arr;

这里需要注意的是，数组指针变量int (*p)[10];10表示指针所指向数组的元素个数；int表示所指向数组中存放的数据类型是整型。

三、函数指针

<1>函数指针变量

之前我们学习过数组指针，它是一个存放数组的地址的指针。那函数指针就应该是存放函数的地址的指针，在以后编写代码过程中，通过指针来调用函数。

​ 首先，我们应该知道，函数也是有地址的，

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("test: %p\n", test);
 printf("&test: %p\n", &test);
 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写上或者省略都是可以的

注意：函数指针变量 int(*p)(int, int)中，int代表指针指向函数的返回类型；(int, int)代表指针指向函数的参数类型；p呢是函数指针变量名。

<2>函数指针变量的使用

​ 创建好函数指针变量并存储了函数的地址，那该任何去用呢

我们可以通过指针来调用函数：

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

<3>ytpedef关键字

1.重命名普通类型

​ typedef关键字是用来类型重命名的，不如要定义应该无符号整型 unsigned int，但是写起来比较麻烦，这时就可以利用typedef来进行类型重命名，

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

这样重命名以后，就可以用uint来代替unsigned int。

2.重命名指针类型

 typedef int* ptr_t;

3.重命名数组指针

当我们需要将数组指针类型 int(*)[5]重命名维parr_t时，就有所不同

typedef int(*parr_t)[5]; //新的类型名必须在*的右边

4重命名函数指针类型

与数组指针一样，重命名函数指针时，也需要将新的类型名放在*的右边。

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

四、函数指针数组

​ <1>定义函数指针数组

我们知道，指针数组呢时存发指针变量的数组，同理呢，函数指针数组应该是存放函数指针的数组，那该如何定义呢？

int (*parr1[3])();

*parr1[3]说明这是整个存放指针的数组，而int()()就说明指针所指向的是一个函数（也是指针所指向函数的类型）。

​ <2>转移表

​ 函数指针数组的⽤途：转移表

在没有学函数指针数组的时候，用代码实现计算器，我们会这样写：

#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(" 0:exit \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");
 break;
 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 }; //转移表
 do
 {
 printf("*************************\n");
 printf(" 1:add 2:sub \n");
 printf(" 3:mul 4:div \n");
 printf(" 0:exit \n");
 printf("*************************\n");
 printf( "请选择：" );
 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);
 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;
}
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");
 break;
 default:
 printf("选择错误\n");
 break;
 }
 } while (input);
 return 0;
}

六、qsort函数

之前，我们学过很多排序方式，冒泡排序，快速排序等，但是这只能排序一种类型的数据，而qsort函数可以排序所以类型的数据

使用qsort函数需要引入头文件<stdlib.h>,qsort函数是一个排序函数

函数类型：编辑

其中，base表示需要排序数组的地址；num表示数组中的元素个数；size表示数组中存放的元素的大小，单位是字节；int（compar）（const void，const void*）是函数指针，(指针指向的是判断大小的函数，返回值要求编辑

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

qsort可以排序任何类型的数据，那是不是也可以排序结构体呢？

struct Stu //学⽣
{
 char name[20];//名字
 int age;//年龄
};
//假设按照年龄来⽐较
int cmp_stu_by_age(const void* e1, const void* e2)
{
 return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
//strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的
//假设按照名字来⽐较
int cmp_stu_by_name(const void* e1, const void* e2)
{
 return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//按照年龄来排序
void test2()
{
 struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
 int sz = sizeof(s) / sizeof(s[0]);
 qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
//按照名字来排序
void test3()
{
 struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
 int sz = sizeof(s) / sizeof(s[0]);
 qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
int main()
{
 test2();
 test3();
 return 0;
}

在使用qsort函数时，需要写一个比较大小的函数来作为函数参数，qsort默认排序的是升序，但需要降序排序，也只需要将比较大小函数的返回值正负交换即可。

<2>qsort的模拟实现

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

#include <stdio.h>
int int_cmp(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 bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
 int i = 0;
 int j = 0;
 for (i = 0; i< count - 1; i++)
 {
 for (j = 0; j<count-i-1; j++)
 {
 if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
 {
 _swap(( char *)base + j*size, (char *)base + (j + 1)*size, 
size);
 }
 }
 }
}
int main()
{
 int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
 int i = 0;
 bubble(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;
}

C语言指针学习（第三节）就分享到这里了，

​ 我会一直分享我个人的学习记录，欢迎大家来讨论。