系列文章目录
前言
1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。
一、字符指针
1.字符指针的定义
存放字符的指针
2.字符指针的实现
代码如下：
int main()
{
char ch = 'a'; //字符指针
char* pa = &ch;
char* pstr = "hello bit.";
printf("%c\n", *pb);
printf("%s\n", pb);
}
代码 char* pstr = “hello bit.”; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello bit. 首字符的地址放到了pstr中。
经典例题：
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
char *str3 = "hello bit.";
char *str4 = "hello bit.";
if (str1 == str2) //str1与str2是两块完全不同的空间
{
printf("str1 and str2 are same\n");
}
else
{
printf("str1 and str2 are not same\n");
}
if (str3 == str4) //str3与str4指向的常量字符串，存放的是hello bit首字符的地址，字符串在内存中是连续存放的，所以可以找到字符串hello bit
{
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不同。
二、指针数组
1.指针数组的定义
指针数组是一个存放指针的数组
2.指针数组的实现
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() //指针数组--数组--存放指针的数组
{
char* arr1[10] = {
0 };
//arr1数组有10个元素，每个元素是char*类型
int* arr2[10] = {
0 };
//arr2数组有10个元素，每个元素是int*类型
char** arr3[10] = {
0 };
//arr3数组有10个元素，每个元素是char**类型
return 0;
}
三、数组指针
1.数组指针的定义
能够指向数组的指针
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() //数组指针--指针--指向数组的指针
{
int arr1[10] = {
0 };
int(*pa)[10] = &arr1;
//&arr取出的是整个数组的地址，pa与*结合是指针，指向的数组arr有10个元素，每个元素类型是int类型
int* pb[10] = {
0 };
//这里是指针数组，pa数组中有10个元素，每个元素类型是int* 类型
char ch[5] = {
0 };
char(*p3)[5] = &ch;
2.区分&数组名和数组名
&arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。
代码如下：
int main()
{
int arr2[10] = {
1, 2, 3, 4, 5 };
int* pc = arr2;
int(*pd)[10] = &arr2;
printf("%p\n", pc); //pc指向的是首元素的地址，pc+1是跳过一个整形
printf("%p\n", pc + 1);
printf("%p\n", pd); // pb指向的是一个的数组，pb+1是跳过一个整形数组
printf("%p\n", pd + 1);
}
2.数组指针的使用
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void print1(int arr2[3][5], int x, int y) //普通的二位数组打印，数组传参，数组接收
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", arr2[i][j]);
}
printf("\n");
}
}
void print2(int(*pd)[5], int x, int y) //用数组指针来接收一维数组
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", *((*pd + i) + j)); //(*pd+i)是找到第i行的地址，*((*pd+i)+j)是找到第i行第j列的元素
}
printf("\n");
}
}
int main() //数组指针的使用->指向数组的指针
{
int arr[] = {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* pa = &arr;
int(*pb)[10] = &arr;
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", *(pa + i));
printf("%d ",(*pb)[i]); //*pa<==>arr
printf("%d ", *(*pb + i));
}
printf("\n");
int arr2[3][5] = {
{
1, 2, 3, 4, 5 }, {
2, 3, 4, 5, 6 }, {
3, 4, 5, 6, 7 } };
//二维数组传参，数组名也是首元素地址，二位数组的首元素是第一行
//传过去的是第一行的地址->一维数组的地址
print1(arr2, 3, 5);
print2(arr2, 3, 5);
return 0;
}
3.区分数组指针和指针数组
代码如下：
int arr4[5];
int* arr5[10];
int(*pe)[10];
int(*pf[10])[5];
1.整形数组。
2.指针数组，arr5里面有10个元素，每个元素类型是int*。
3.数组指针，pe指针指向的数组里面有10个元素，每个元素 类型是int类型。
4.int(*)[5] ,存放数组指针的数组,pf数组中有10个元素，每个元素类型是数组指针，数组指针有5个元素，元素类型是int。
四、数组传参、指针传参
1.数组传参的定义
将数组或数组地址作为参数传递过去。
2.一维数组和二维数组
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//一维数组传参
void test1(int arr1[])
{
}
void test1(int arr1[10])
{
}
void test1(int* arr1)
{
}
void test2(int *arr2[20])
{
}
void test2(int **arr2) //指针数组传参，传参的是首元素地址，首元素地址类型是int*,所以用int** 来接收
{
}
//二维数组传参
void test3(int arr[3][5])
{
}
void test3(int arr3[][]) //错误的写法->,行可以不写,列不能不写
{
}
void test3(int arr3[][5])
{
}
void test3(int* arr3) //错误的写法，arr3是一个二维数组，不能用整形指针来接收
{
}
void test3(int* arr3[5]) //错误的写法，arr3是一个二维数组，不能一个指针数组来接收
{
}
void test3(int(*arr3)[5]) //arr3是一个指针，指向的arr3有个元素，每个元素类型是int类型
{
}
void test3(int** arr3) //错误的写法，二级指针是用来接收一级指针的地址
{
}
int main()
{
//一维数组传参
int arr1[10] = {
0 };
int* arr2[20] = {
0 };
test1(arr1);
test2(arr2);
//二维数组传参
int arr3[3][5] = {
0 };
test3(arr3);
return 0;
}
3.指针传参的定义
将指针的地址或二级指针传递过去
4.一维指针和二维指针
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void print(int* pa, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(pa + i));
}
printf("\n");
}
void test1(int** pb)
{
}
void test2(int** pc)
{
}
int main()
{
int arr1[] = {
1, 2, 4, 5, 6, 7, 8, 9, 10 };
int* pa = &arr1;
int sz = sizeof(arr1) / sizeof(arr1[0]);
//一级指针pa,传给函数
print(pa, sz);
//二级指针传参,二级指针来接收
int i = 0;
int* pb = &i;
int** pc = &pb;
test1(&pb); //传一级指针的地址
test2(pc); //传二级指针pc
return 0;
}
五、函数指针
1.函数指针的定义
存放函数的地址
2.函数指针的使用
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
void test1(int* pa)
{
}
void test2(int(*pc)[5])
{
}
int add(int x, int y)
{
return x + y;
}
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
str++;
count++;
}
return count;
}
int main()
{
int arr1[10]; //一维数组
int* pa = arr1; //首元素的地址
int(*pb)[10] = &arr1; //整个数组的地址
test1(arr1);
int arr2[3][5];
int(*pc)[5] = arr2; //首元素的地址，二维数组首元素的地址代表第一行的地址，所以用数组指针接收
int(*pd)[3][5] = &arr2;
test2(arr2);
//整形指针---->存放整形的地址
//数组指针---->存放数组的地址
//函数指针---->存放函数的地址
int a = 10;
int* pe = &a;
char arr3[10] = {
0 };
char(*pf)[10] = &arr3;
printf("%p\n", &add);
printf("%p\n", add); //&函数名和函数名都是函数的地址
int(*pg)(int, int) = &add; //pg就是函数指针
int(*ph)(int, int) = add; //ph和pg表达的意思一样
//函数指针的调用
int sum = (*pg)(2, 3); //== int usm=add(2,3);
int ret = (pg)(2, 3);
printf("%d\n", ret);
printf("%d\n", sum);
int(*str)(const char*) = &my_strlen;
int len = (*str)("bit education");
printf("%d\n", len);
}
1.类型在()里面就是强制类型转换–>把0强制类型转换为函数指针类型，然后解引用调用0地址处的函数，该函数返回值为void，参数为无参数。
2.这是一个函数声明，声明的函数是signal,signal函数有两个参数，第一个参数类型是int,第二个参数类型是函数指针，该函数的返回值是空，参数是int ，signal函数的返回类型是一个函数指针，该函数指针指向的函数参数是int，返回类型是void。
五、函数指针数组
1.函数指针数组的定义
存放函数指针的数组
2.函数指针数组的使用
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main() //函数指针数组
{
int a = 10;
int b = 20;
int* arr[] = {
&a, &b };
//函数指针->存放函数的地址
int(*pf1)(int, int) = Add;
int(*pf2)(int, int) = Sub;
//函数指针数组->存放函数指针的数组
int(*pfarr[2])(int, int) = {
Add, Sub };
return 0;
}
3.函数指针数组的应用之转移表(计算器)
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void menu()
{
printf("*****************************\n");
printf("*****1.ADD 2.Sub ****\n");
printf("*****3.Mul 4.Div ****\n");
printf("***** 0.Exit ****\n");
printf("*****************************\n");
}
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;
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
int(*pfarr[])(int, int) = {
0, Add, Sub, Mul, Div }; //函数指针数组的应用->转移表,把4个函数的地址存放到函数指针数组里面
do
{
menu();
printf("请输入你的选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出程序!\n");
break;
}
else if (input > 0 && input <= 4)
{
printf("请输入两个操作数:");
scanf("%d%d", &x, &y);
ret = pfarr[input](x, y);
printf("结果是:%d\n", ret);
}
else
{
printf("你的选择错误，请重新选择!\n");
}
} while (input);
return 0;
}
六、回调函数
1.回调函数的定义
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
2.回调函数之qsort的用法
1.void* base 待排序的数据的起始地址
2.size_t num 待排序的数据的元素个数
3.size_t width 待排序的数据的大小，单位是字节
4.函数 比较两个元素的地址
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//冒泡排序只对整形排序
void Bubble_Sort(int arr[], int sz)
{
int i = 0;
int j = 0;
for (i = 0; i < sz-1; i++) //趟数
{
for (j = 0; j < sz - i - 1;j++) //次数
{
if (arr[j]>arr[j + 1])
{
int tmp = 0;
tmp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = tmp;
}
}
}
}
void qsort(void *base,
size_t num,
size_t width,
int(__cdecl *compare)(const void *elem1, const void *elem2)
);
//void* base 待排序的数据的起始地址
//size_t num 待排序的数据的元素个数
//size_t width 待排序的数据的大小，单位是字节
//函数 比较两个元素的地址
struct stu
{
char name[20];
int age;
};
//e1和e2是要比较元素的两个地址
int cmp_int(const void* e1, const void* e2) //按照整形来排序
{
return(*(int*)e1 - *(int*)e2);
}
int cmp_by_age(const void* e1, const void* e2) //按照结构体中年龄来排序
{
return (((struct stu*)e1)->age - ((struct stu*)e2)->age);
}
int cmp_by_name(const void* e1, const void* e2) //按照结构体中名字来排序
{
return (strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name));
}
int main()
{
//void*的指针变量，可以接收任意类型的地址
//因为void*的指针，没有具体类型，所以不能进行解引用操作，不能++/--
int a = 10;
int* p = &a;
int arr[] = {
1, 4, 5, 6, 3, 8, 9, 10, 2 };
int sz = sizeof(arr) / sizeof(arr[0]);
Bubble_Sort(arr, sz);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
//qsort实现对整形的排序
qsort(arr, sz, sizeof(arr[0]), cmp_int); //数组名，数组大小，数据占多少字节，比较函数
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
struct stu Stu[] = {
{
"zhangsan", 15 }, {
"lisi", 12 }, {
"wangwu", 18 }, {
"wanger", 14 } };
int num = sizeof(Stu) / sizeof(Stu[0]);
qsort(Stu, num, sizeof(Stu[0]), cmp_by_age); //按年龄来排序
for (i = 0; i < num; i++)
{
printf("%d->%s ", Stu[i].age,Stu[i].name);
}
printf("\n");
qsort(Stu, num, sizeof(Stu[0]), cmp_by_name); //按照名字来排序,相当于比较字符串
for (i = 0; i < num; i++)
{
printf("%s->%d ", Stu[i].name, Stu[i].age);
}
printf("\n");
return 0;
}
3.回调函数之qsort的模拟实现
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int cmp_int(const void* e1, const void* e2)
{
return (*(char*)e1 - *(char*)e2);
}
void _swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp =*buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void Bubble_Sort(void* base, int num, int width, int(*cmp)(const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (cmp((char*)base + j*width, (char*)base + (j + 1)*width)>0)
{
_swap((char*)base + j*width, (char*)base + (j + 1)*width, width);
}
}
}
}
int main()
{
int i = 0;
int arr[] = {
3, 2, 5, 7, 4 };
int sz = sizeof(arr) / sizeof(arr[0]);
Bubble_Sort(arr, sz, sizeof(arr[0]), cmp_int);
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
总结
以上就是今天要讲的指针进阶的大部分内容，本文详细的介绍了C语言中指针的难点和重点，而指针提供了大量便利我们快速便捷地处理数据，希望大家掌握。另外，如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。
