初识C语言：2.指针进阶

指针的基本概念

1. 指针是变量，用来存放地址

2. 指针大小是固定的4/8个字节（32/64位平台）

3. 指针的类型决定了解引用时能访问几个字节，以及指针±整数的步长

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;

而当两个指针变量指向同一常量字符串时，系统会常量字符串单独放到一个内存空间中，这些指针全部指向同一块内存空间。

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

运用函数指针可以在调用函数时更加方便快捷

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

注意：

1. qsort可以对任何数据类型进行排序。

2. //void qsort(void* base, size_t nitems, size_t size, int (*compar)(const void*, const void*))第四个参数是一个函数指针，指向的函数是用来比较大小的，该函数需要使用者根据需要排序的数据类型自己编写。这就是回调函数的应用

3. void *p可以接收任意类型数据的地址

4. 对于此时的p，不能解引用*p，不能对p进行加减，只有对p进行强制类型转换后才可以使用例如 int a=*（*int）p;

输出