指针的基本概念
指针是变量,用来存放地址
指针大小是固定的4/8个字节(32/64位平台)
指针的类型决定了解引用时能访问几个字节,以及指针±整数的步长
1.字符指针
char arr[]="abcdef";
char* p=arr;//arr此时表示数组首元素的地址
*p='w';
printf("%s",arr);
wbcdef
指针指向数组首元素的地址,数组的内容是可以改变的。
数组名除了在sizeof(arr)、&arr时,其余一切数组名都代表数组首元素地址。(&arr表示整个数组的地址)
char str1[]="hello world";
char str2[]="hello world";
const char* str3="hello world";
const char* str4="hello world";
if(str1==str2)
printf("same\n");
else
printf("not same\n");
if(str3==str4)
printf("same\n");
else
printf("not same\n");
//结果
not same
same
当用相同的常量字符串初始化不同的数组时,系统会开辟两块不同的内存分别给这两个数组用,所以str1≠str2;
而当两个指针变量指向同一常量字符串时,系统会常量字符串单独放到一个内存空间中,这些指针全部指向同一块内存空间。
![](https://i-blog.csdnimg.cn/blog_migrate/d3009c296941df0b2a86f2a8aa5668b6.png)
2.指针数组
就是存放指针的数组,本质上是数组
int* arr1[10];
char* arr2[10];
char** arr3[10];
char* arr[]={"abc","hehe","qwer"};
数组里每个元素都是一个指针变量,指向该元素首地址
3.数组指针
本质上是指针,指向数组的指针,和指向整型的指针,指向字符的指针是一样的
int* p1=NULL;
float* p2=NULL;
int (*p3)[10]={0};
char arr[10];
char (*pc)[10]=&arr;
int* a[10];
int* (*pc)[10]=&arr;//指向指针数组的数组指针;第一个*代表指向的数组的每个元素为指针类型,可以和int连起来看成int*类型,第二个*代表pc是一个指针,指向数组的指针。
int arr[5];//整型数组
int *parr1[10];//指针数组,指针类型为整型指针
int (*parr2)[10];//数组指针,指向整型数组的指针
int (*parr3[10])[5];//指针数组,parr3先和[10]结合,再与*结合,说明parr3是个数组这个数组含有10个元素,每个元素是 指向数组的数组指针
4.数组参数,指针参数
4.1一维数组传参
int arr1[10];
int* arr2[20]={0};
void func(int arr[]);
void func(int arr[10]);
void func(int* arr[20]);
void func(int **arr);//arr2是一个指针数组,每个元素都是指针变量,而数组名表示首元素地址,arr就代表一个指针的地址,所以用二级指针来接收是合适的
func(arr1);
func(arr2);
4.2二维数组传参
int arr[3][5]={0};
func(arr);
void func(int arr[3][5]);
void func(int arr[][5]);
void func(int (*arr)[5]);//形参中存放数组首元素地址,而二维数组首元素为第一行的一维数组,所以用一个数字指针来接受一维数组的地址
4.3一级指针传参
void func(int* p);
int arr[10]={0};
int *p=arr;
int *p=&a;
func(p);
func(&a);
func(arr);//arr就是首元素地址
4.4二级指针传参
func(二级指针变量);
func(一级指针变量的地址);
func(指针数组);//传的是指针数组的首元素地址,首元素为指针,即指针的地址
5.函数指针
void func(int x);
void (*pfunc)(int);
(*(void(*)())0)();//void(*)()是函数指针类型的声明,将一个类型放在一个变量前的括号中代表将该变量强制转换,即将0强制转换为一个函数指针。此时再对0这个指针解引用,即调动其所指向的函数,该函数没有参数。整体为一次函数调用
void (*signal(int,void(*)(int)))(int);//这是一个函数声明,函数名为signal,其第一个参数为int,第二个参数为void(*)(int),这是一个返回类型为void的函数指针,指向的函数有一个int类型参数。分析到这里已经知道了signal函数的函数名和参数类型,还剩它的返回类型不知道,即 void(*)(int)为他的返回类型,说明signal的返回类型是一个函数指针,该指针指向的函数参数为int,返回类型为void
//可以利用typedef来使这个声明变得更容易读懂,将void(*)(int)这个类型简化为pfun_t
typedef void(* pfun_t)(int);
pfun_t signal(int pfun_t);
6.函数指针数组
这是一种数组,数组中每个元素都是一个函数指针
int(*pfun[10])(int,int);//pfun是一个数组,有10个元素,每个元素都是指针,是什么类型的指针呢?去掉函数名后int()(int,int),是指向函数的指针,即函数指针,指向的函数有两个int类型的参数,返回类型为int
可以利用函数指针数组写一个简单的计算器功能
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void menu()
{
printf("您想进行哪种操作\n");
printf("1.加法 2.减法\n");
printf("3.乘法 4.除法\n");
printf("0.退出\n");
}
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 input;
int (*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };
do
{
menu();
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
int a, b;
printf("请输入操作数\n");
scanf("%d %d", &a, &b);
printf("%d\n", pf[input](a, b));
}
else
break;
} while (input);
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/19bad542ba9e5ac4e01c3a27f6f265ab.png)
运用函数指针可以在调用函数时更加方便快捷
7.回调函数
回调函数就是通过函数指针调用的函数。当我们把函数的指针(地址)组为参数传给另一个函数时,当这个指针被用来调用其所指的函数时,就称回调函数。
利用回调函数模拟实现qsort(采用冒泡排序的方法)
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//void qsort(void* base, size_t nitems, size_t size, int (*compar)(const void*, const void*))
void Swap(char* buf1, char* buf2, size_t size)//buf1,buf2都是将要比较的两个元素分成一个一个字节后来进行逐一交换
{
for (int i = 0; i < size; i++)
{
char t = *buf2;
*buf2 = *buf1;
*buf1 = t;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, size_t n, size_t size, int (*compar)(const void*, const void*))//const void*, const void*就分别是要比较数组的两个相邻元素
{
for (size_t i = 0; i < n - 1; i++)
{
int flag = 0;
for (size_t j = 0; j < n - 1 - i; j++)
{
if (compar((char*)base + j * size, (char*)base + (j + 1) * size)>0)//
{
flag = 1;//发生交换flag置1
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
if (flag == 0)
{
break;
}
}
}
int cmpint(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
}
void test1()
{
int arr1[5] = { 5,4,3,2,1 };
int sz = sizeof(arr1) / sizeof(arr1[0]);
bubble_sort(arr1, sz, sizeof(arr1[0]), cmpint);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
}
struct S
{
char name[7];
int age;
};
int cmpstru_name(const void* p1, const void* p2)
{
int ret = strcmp(((struct S*)p1)->name, ((struct S*)p2)->name);
return ret;
}
void test2()
{
struct S s[3] = { { "zhao",22 },{ "ma",21 },{ "lu",20 } };
int sz = sizeof(s) / sizeof(s[0]);
bubble_sort(s, sz, sizeof(s[0]), cmpstru_name);
for (int i = 0; i < sz; i++)
{
printf("%s ", s[i]);
}
}
int cmpchar(const void* p1, const void* p2)
{
return = strcmp(*(char**)p1, *(char**)p2);
}
void test3()
{
char* arr2[] = { "pklnsr","olzxni","rigyqo","pgirjr","jbwgvs" };//用指针数组来存放字符串,因此传参时需要传二级指针(77行)
int sz = sizeof(arr2) / sizeof(arr2[0]);
bubble_sort(arr2, sz, sizeof(arr2[0]), cmpchar);
for (int i = 0; i < sz; i++)
{
printf("%s\n", arr2[i]);
}
}
int main()
{
test1();
printf("\n");
test2();
printf("\n");
test3();
return 0;
}
注意:
qsort可以对任何数据类型进行排序。
//void qsort(void* base, size_t nitems, size_t size, int (*compar)(const void*, const void*))第四个参数是一个函数指针,指向的函数是用来比较大小的,该函数需要使用者根据需要排序的数据类型自己编写。这就是回调函数的应用
void *p可以接收任意类型数据的地址
对于此时的p,不能解引用*p,不能对p进行加减,只有对p进行强制类型转换后才可以使用例如 int a=*(*int)p;
输出
![](https://i-blog.csdnimg.cn/blog_migrate/4070c4c702e085b9dfd114ae7016af67.png)