C语言进阶(2) ---- 指针的进阶

前言:指针的主题,我们在初阶的《指针》章节已经接触过了,我们知道了指针的概念

1.指针就是个变量,用来存放地址,地址唯一标识一块内存空间。

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

3.指针是有类型的,指针的类型决定了指针的+-整数的步长,指针解引用操作的时候的权限。

4.指针的运算。

目录

1. 字符指针

2.指针数组

3. 数组指针

3.1 数组指针的定义

3.2 &数组名VS数组名

3.3 数组指针的使用

4. 数组参数、指针参数

4.1 一维数组传参

4.2 二维数组传参

4.3 一级指针传参

4.4 二级指针传参

5. 函数指针

6. 函数指针数组

7. 指向函数指针数组的指针

8. 回调函数

8.1.冒泡排序

8.2.qsort函数

8.3.用qsort来改正冒泡排序


1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针char*;

笔记:

        内存会划分字节为单位的空间,每个字节都有一个编号(地址/指针)

        指针/地址要被存储起来,需要一个空间,这个空间就是指针变量!

        指针(变量)

一般使用方式:

int main()
{char ch = 'w';char *pc = &ch;*pc = 'w';return 0;
}

还可以怎么使用呢,如下:

int main()
{const char*  pstr  = "hello bit."; //这里是把一个字符串放到pstr指针变量里了吗?printf("%s\n", pstr);return 0;}

代码 const char* pstr = "hello bit.";

特别容易让同学以为是把字符串hello bit放到字符指针pstr里了,但是-本质上是把字符串hello bit,首字母的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符h的地址存放 指针变量pstr中。
就有可这样的面试题:
#include <stdio.h>
int main O
{char str1[] = "hell o bit.";char str2[] = "hello bit.";const char *str3 = "hell o bit.”;const char *str4 = "hello bit.”;if(str1 == str2)printf("strl and str2 are same\n");elseprintf("str1 and str2 are not same\n") ;if(str3 == str4)printf("str3 and str4 are same\n“);elseprintf("str3 and str4 are not same\n");return 0;
}

这里最终输出的是:

注: 这里str3和str4指向的是一个同一个常量字符串。 C/C++会把常量字符串存储到单独的一个内存区域, 当几个指针,指 向同一个字符串的时候, 实际会指向同一块内存,但是用相同的常量字符串去初始化不同的数组的 候就会开辟出不同的内存块。所以str1和str2不同,str3和str4相同。

2.指针数组

在《指针》章节我们也学了指针数组,指针数组是一个存放指针的数组。
这里我们再复习一下,下面指针数组是什么意思?
1. int* arr1 [ 10 ]; // 整形指针的数组
2. char * arr2 [ 4 ]; // 一级字符指针的数组
3. char ** arr3 [ 5 ]; // 二级字符指针的数组

重要:       

        整形数组 - 存放整形的数组

        字符数组 - 存放字符的数组

        指针数组 - 存放指针的数组

        数组指针 - 指向数组的指针。

3. 数组指针

3.1 数组指针的定义

数组指针是指针?还是数组?

答案是:指针。指向数组的指针

整型指针: int* pint; 能够指向整形数据的指针。

浮点型指针:float* pf; 能够指向浮点型数据的指针。

那数组指针应该是能够指向数组的指针。

下面代码哪个是数组指针?
int * p1 [ 10 ];
>>p1 -> 是一个指针数组,存放的是指针数组,存放类型为int* .
int ( * p2 )[ 10 ];
>>p2 -> 是一种数组指针,存放的是数组指针,存放元素类型int。
//p1, p2 分别是什么?
p1存放的是第一个元素的地址,
p1+1 - 跳过一个int ,
*p 访问一个int数据4个字节。
p2存放的是arr数组的地址,
p2+1 - 跳过了整个数组,
*p2访问到的是arr数组,*p2等价于arr了,那么*p2就是数组名了,数组名有相当于首元素的地址,所以*p2本质上是arr数组第一个元素的地址。
解释:
int ( * p )[ 10 ];
//解释:p先和*结合,说明p是一个指针变量,然后指着指向的是一个大小为10个整型的数组。所以p是一个指针,指向一个数组,叫数组指针。
//这里要注意:[]的优先级要高于*号的,所以必须加上()来保证p先和*结合。
3.2 &数组名VS数组名
对于下面的数组:
int arr[10];
arr &arr 分别是啥?
我们知道 arr 是数组名,数组名表示数组首元素的地址。
&arr 数组名到底是啥?
我们看一段代码:
#include <stdio.h>
int main()
{int arr[10] = {0};printf("%p\n", arr);printf("%p\n", &arr);return 0;
}

运行结果如下:

可见数组名和 & 数组名打印的地址是一样的。
难道两个是一样的吗?
我们再看一段代码:
#include <stdio.h>
int main()
{int arr[10] = { 0 };printf("arr = %p\n", arr);printf("&arr= %p\n", &arr);printf("arr+1 = %p\n", arr+1);printf("&arr+1= %p\n", &arr+1);return 0;
}

运行结果如下:

根据上面的代码我们发现,其实 &arr arr ,虽然值是一样的,但是意义应该不一样的。
实际上: &arr 表示的是数组的地址,而不是数组首元素的地址。(细细体会一下)
本例中 &arr 的类型是: int(*)[10] ,是一种数组指针类型
数组的地址+1,跳过整个数组的大小,所以 &arr+1 相对于 &arr 的差值是40.

//数组的地址存起来,就应该放在数组指针中!

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

3.3 数组指针的使用
那数组指针是怎么使用的呢?
既然数组指针指向的是数组,那数组指针中存放的应该是数组的地址。
看代码:
#include <stdio.h>
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,0};int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p//但是我们一般很少这样写代码return 0;
}
一个数组指针的使用:
#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{int i = 0;for(i=0; i<row; i++){for(j=0; j<col; j++){printf("%d ", arr[i][j]);}printf("\n");}
}
void print_arr2(int (*arr)[5], int row, int col)
{int i = 0;for(i=0; i<row; i++){for(j=0; j<col; j++){printf("%d ", arr[i][j]);}printf("\n");}
}
int main()
{int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};print_arr1(arr, 3, 5);//数组名arr,表示首元素的地址//但是二维数组的首元素是二维数组的第一行//所以这里传递的arr,其实相当于第一行的地址,是一维数组的地址//可以数组指针来接收print_arr2(arr, 3, 5);return 0;
}

学习了指针数组和数组指针,解读下下面代码的意思:

int arr [ 5 ];
arr 是一个整型数组,5个元素,每个元素类型为int。
int * parr1 [ 10 ];
parr1 是一个数组,有10个元素,每个元素的类型是 int* ,所以parr1是指针数组。
int ( * parr2 )[ 10 ];
parr2 和 * 结合,说明parr2是一个指针,该指针指向一个数组,数组是10个元素,每个元素是int类型的。所以 parr2是数组指针。
int ( * parr3 [ 10 ])[ 5 ];
parr3 和 [] 结合,说明parr3是一个数组,数组是10个元素,数组的每个元素是什么类型呢?
是一种数组指针,类型是int(*)[5] . 该类型的指针指向有5个int 类型的元素。
([ ] 优先级高于 * )

那怎么打印数组呢,根据之前学的内容:

int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//最简单的方法,*(p + i),直接首元素地址去打印,然后加一,往后跳去打印int*p = arr;int i = 0;for (i = 0; i < 10; i++){printf("%d ", *(p + i));}return 0;
}

当用数组指针来写的话:

    //用数组指针, 这样不如下面用首元素的地址往后跳,找到数组的地址,然后用下标int (* p)[10] = &arr;int i = 0;for (i = 0; i < 10; i++){printf("%d ", (*p)[i]);}

但是有点大材小用了,我们再来看二维数组中的使用,会不会比以前的方法变的简单呢

void print1(int arr[3][4], int row, int col)
{int i = 0;for (i = 0; i < row; i++){int j = 0;for (j = 0; j < col; j++){printf("%d ", arr[i][j]);//i行j列去打印,二维数组的普通打印用下标}printf("\n");}
}

我们用数组指针来写

void print2(int(*p)[4], int row, int col)
{int i = 0;for (i = 0; i < row; i++){int j = 0;for (j = 0; j < col; j++){			printf("%d ", (*(p + i))[j]);
//先拿到数组指针找到这个数组,p是指针哪一行的,加i就是找到所有的行,然后再加上一个下标}printf("\n");}
}

打印的时候还有一种写法

printf("%d ", p[i][j]);

//这样写也是可以的,直接找到整个数组第一行地址,然后往后下一行,每一行的下标j,找到所有元素

4. 数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数,那函数的参数该如何设计呢?
4.1 一维数组传参

数组传参的时候,形参写成数组形式。--- ok

#include<stdio.h>void test1()//如何传参数?void test2()//如何传参数?int main()
{int arr1[10] = { 0 };int* arr2[20] = { 0 };test1(arr1);test2(arr2);
}

参数可以这样写:

#include <stdio.h>
void test(int arr[])//ok?     //ok 可以传参
{}//函数中arr传来,数组传参,参数的部分写为数组
void test(int arr[10])//ok? //ok
{}//函数中arr传来,数组传参,参数的部分写为数组,定义个大小也是可以的
void test(int *arr)//ok?     //ok
{}//函数中arr传来,是首元素地址,每个元素都整型,数组传参,也可以用指针接受,所有用整型指针来接收
void test2(int *arr[20])//ok? //ok
{}//函数中arr2传来,是首元素地址,arr2是数组里面放的指针,传来后,用指针数组来接受地址
void test2(int **arr)//ok?    //ok

{}//函数中arr2传来,是首元素地址,arr2是数组里面放的指针,形参里面的*arr,就是数组首元素地址解引用,就是数组,所有**arr就可以接收传来的指针

void test2(int* arr)
{}//这样是不行的,传来的数组名是首元素地址,都是指针,所有我们接收的时候也要二级指针

4.2 二维数组传参

void test(int arr[3][5])//ok? //ok
{} //形参传是二维数组,行是可以省略的,但是列不能省略。
void test(int arr[][])//ok?    //not ok - 不可传参
{}//列不可以省略
void test(int arr[][5])//ok?  //ok
{}
//总结:二维数组传参,函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素。
//这样才方便运算。

void test(int *arr)//ok?    //error 整型指针
{}
void test(int* arr[5])//ok? //error 数组
{}
void test(int (*arr)[5])//ok? //ok 指针数组
{}
void test(int **arr)//ok?//error 
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);//指的是第一行数组传参
}

4.3 一级指针传参
#include <stdio.h>
void print(int *p, int sz)
{int i = 0;for(i=0; i<sz; i++){printf("%d\n", *(p+i));}
}
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p,传给函数print(p, sz);return 0;
}
思考:
当一个函数的参数部分为一级指针的时候,函数能接收什么参数?

比如:

void test1 ( int * p )
{}
//test1 函数能接收什么参数?
//test2函数能接收一个指向整形的指针作为参数;
//eg:具体数据类型的指针,指向结构体的指针,指向数组的指针,函数指针。
void test2 ( char* p )
{}
//test2 函数能接收什么参数?
//test2函数能接收一个指向字符的指针作为参数;
//eg:字符串字面量,字符数组,单个字符。
4.4 二级指针传参
#include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr); 
}
int main()
{int n = 10;int*p = &n;int **pp = &p;test(pp);test(&p);return 0;
}
思考:
当函数的参数为二级指针的时候,可以接收什么参数?
eg:
1.指向指针的指针;
2.指向数组的指针的指针;
3.指向结构体的指针的指针;
4.函数指针的指针;
void test(char **p)
{ }
int main()
{char c = 'b';char*pc = &c;char**ppc = &pc;char* arr[10];test(&pc);test(ppc);test(arr);//Ok?return 0;
}

5. 函数指针

//函数指针
//函数其实也是有地址的,函数名(或者&函数名)就是函数的地址;
首先看一段代码:
#include <stdio.h>
void test()
{printf("hehe\n");
}
int main()
{printf("%p\n", test);printf("%p\n", &test);return 0;
}

结果:

输出的是两个地址,这两个地址是 test 函数的地址。

那我们的函数的地址要想保存起来,怎么保存?
下面我们看代码:
void test()
{printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址?
void (*pfun1)();
void *pfun2();
首先,能给存储地址,就要求 pfun1 或者 pfun2 是指针,那哪个是指针?
答案是:
pfun1 可以存放。 pfun1 先和 * 结合,说明 pfun1 是指针,指针指向的是一个函数,指向的函数无参数,返回值类型为void
分析下两段有趣的代码:
#include<stdio.h>
int main()
{//代码1(*(void (*)())0)();//代码2void (*signal(int, void(*)(int)))(int);return 0;
}
// 代码 1
( * ( void ( * )()) 0 )();
//( void ( * )()) - 函数指针类型
//把0强制转换为一种函数指针类型,无参无返回类型;
这段代码的意思是是将0强制类型转化为void (*)()类型的函数指针,然后再去调用0地址处的这个函数;
// 代码 2
void ( * signal(int , void(*)(int )))( int );
//signal 是一个函数声明,声明的函数名字是signal,
signal 的参数有2个,第一个是int类型,第二个是函数指针:void(*)(int),
该指针指向的函数参数int, 返回类型是void。
//signal 函数的返回类型也是函数指针,该指针指向的函数参数int , 返回类型是void .

//void (*p)(int) ;  //p 是函数指针变量的名字

//typedef void(*pf_t)(int) ; //pf_t 是类型名

void (*signal(int, void(*)(int) )  )(int);
该代码是一次函数的声明,声明的函数名字叫signal
    signal函数的参数有2个,第一个是int类型,第二个是函数指针类型
    该函数指针能够指向的那个函数的参数是int,返回类型是void
 
    signal函数的返回类型是一个函数指针
    该函数指针能够指向的那个函数的参数是int, 返回类型是void
    相当于三个套娃函数指针
 
简化一下(typedef)类型简化,typedef unsigned int uint;(简化方法)
 
    typedef void(*pf_t)(int); //pfun_t就是函数指针的类型
    pf_t signal(int, pf_t);//这就是简化完,

6. 函数指针数组

数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,
比如:
int * arr [ 10 ];
// 数组的每个元素是 int*
那要把函数的地址存到一个数组中,那这个数组就叫 函数指针数组 ,那函数指针的数组如何定义呢?
int ( * parr1 [ 10 ])();
int * parr2 [ 10 ]();
int ( * )() parr3 [ 10 ];
答案是: parr1
parr1 先和 [] 结合,说明 parr1 是数组,数组的内容是什么呢?
int (*)() 类型的函数指针。
函数指针数组的用途: 转移表
1.(计算器)
用我们以前的知识写出加减乘除计算器;
#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( "*************************\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");breark;default:printf( "选择错误\n" );break;}} while (input);return 0;
}

使用函数指针数组的实现

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;
}//函数指针数组存放上述函数的地址
//但是也限定死了,只能是两个整型的操作数才能
//需要注意的是,我设置的计算是1,2,3,4,进入计算,所以第一个函数指针设置为0,后面对应1,2,3,4
int main()
{int input = 0;int x = 0;int y = 0;int (*p[5])(int, int) = { NULL, Add, Sub, Mul, Div };int ret = 0;do{menu();printf("请选择:>");scanf("%d", &input);//也需要判断我们输入的数进行选择if (input == 0){printf("退出计算器\n");break;}else if (input >= 1 && input <= 4){//直接用函数指针数组,用函数指针,直接进入到函数里,用不用*都一样printf("请输入两个操作数:>");scanf("%d %d", &x, &y);ret = pf[input](x, y);printf("ret = %d\n", ret);}else{printf("选择错误\n");}} while (input);return 0;
}

7. 指向函数指针数组的指针

指向函数指针数组的指针是一个 指针,
指针指向一个 数组 ,数组的元素都是 函数指针 ;
如何定义?
函数指针数组——存放函数指针的数组(存放函数的地址)
int my_strlen(const char* str)
{return 0;
}int main()
{//指针数组char* ch[5];int arr[10] = {0};//pa是数组指针int (*pa)[10] = &arr;//pf是函数指针int (*pf)(const char*) = &my_strlen;//函数指针数组int (*pfA[5])(const char*) = { &my_strlen };return 0;
}

定义:int (*parr1[10])();      parr1 先和 [] 结合,说明 parr1是数组,数组的内容是什么呢?
是 int (*)() 类型的函数指针。

//首先,函数指针数组是数组
parr[];


//数组的每个元素是函数指针,以无参函数,且无返回值的函数为例
void (*) ();
 
//结合后
void (*) () parr[];
 
//规范的写法
void (*parr[])()

void test(const char* str)
{printf("%s\n", str);
}
int main()
{//函数指针pfunvoid (*pfun)(const char*) = test;//函数指针的数组pfunArrvoid (*pfunArr[5])(const char* str);pfunArr[0] = test;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfunArr)[5])(const char*) = &pfunArr;return 0;
}

8. 回调函数

  回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。
如果我们用回调函数来优化上面我们写的计算器
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;
}
//回调函数,写一个函数指针指向函数,传进来都是计算用的函数指针
//把我计算用的这些Add,Sub等等这些函数,传给calc这个函数,然后用clac函数参数的部分是函数指针
//这个clac函数通用了,可以加减乘除,就看传谁的地址,通过传来的函数地址,去找到这个函数
void calc(int (*pf)(int, int))
{int x = 0;int y = 0;int ret = 0;printf("请输入两个操作数:>");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);//把Add这个函数地址传给clac里面,就是pf这个函数指针,这个pf函数指针指向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;
}

思路:先写一个calc函数,参数用函数指针来接受,前面写的有功能函数,在主函数中,调用calc函数,把功能函数的地址传到calc函数中,calc函数正好用函数指针来接受,calc函数中指针pf通过传来的功能函数地址,找到这些函数,去进行计算,然后返回值再打印,相当于calc就是一个实现计算过程的模型。

8.1.冒泡排序

两两相邻函数进行比较:(从小到大排序)

缺点:只能排序整数

void bubble_sort(int arr[], int sz)
{//趟数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]){int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}
}
int main()
{int arr[] = { 9,8,7,6,5,4,3,2,1,0 };int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr, sz);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}
8.2.qsort函数
void qsort(void* base, //待排序的数组的起始地址size_t num,    //元素个数size_t width,  //一个元素的大小int (*cmp)(const void* e1, const void* e2)//两个元素的比较函数
);

首先演示一下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;int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz , sizeof (int), int_cmp);for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++){printf( "%d ", arr[i]);}printf("\n");return 0;
}

qsort就是这样实现的,把你提供的函数 cmp_int 地址传到qsort,qsort里用函数指针去接收,然后去指向这个函数,也就是一个回调函数,e1,e2,是要比较的这两个元素的地址,e1<e2返回小于零的数

8.3.用qsort来改正冒泡排序

冒泡排序可以排任何类型的,进行改造,怎么改

第一层循环是不变的,内部两两比较也不变,变的是判断,整型大小比较才能用大小号,字符或者浮点型比较方法不一样,当我们想让这个冒泡排序任何地方使用,是不是就是把比较的部分抽出来,你想排序整型,你自己提供一个排序整型的方法,想排序啥样的,就提供什么样子的

函数1是用库函数qsort排序整型

函数2是用库函数qsort排序结构体

函数3是用冒泡排序模拟实现库函数qsort排序整型

函数4是用冒泡排序模拟实现库函数qsort排序结构体

int cmp_int(const void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;//参数是无类型的指针来接受,所以这里要强制类型转化为int,然后再解引用
}
//对于整型的排序
void test1()
{int arr[] = { 9,8,7,6,5,4,3,2,1,0 };int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_int);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}
//先定义一个结构体
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;//参数是无类型的指针来接受,所以这里要强制类型转化为struct Stu*,相当于拿到了结构体指针,然后再箭头指向年龄
}
//再对结构体的名字比较
int cmp_stu_by_name(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);//参数是无类型的指针来接受,所以这里要强制类型转化为struct Stu*,相当于拿到了结构体指针,然后再箭头指向名字//名字比是字符串比较不能用减号了,用函数strcmp,比较对应位置上的字符,strcmp返回值跟qsort返回值一样的
}
//对于结构体的排序
void test2()
{//结构体的描述struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };int sz = sizeof(s) / sizeof(s[0]);qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}上面test1和test2是用库函数qsort来排序整型和结构体
上面test3和test4是用冒泡排序的思想模拟实现qsort来排序整型和结构体//改造冒泡排序函数,使得这个函数可以排序任意指定的数组
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
//为了能接收各种类型所以void* base,sz就是元素的个数, width宽度你只知道个数,宽度为了知道几个字节,最后用函数指针用来,在这个函数中指针接收要比较的地址
{size_t i = 0;for (i = 0; i < sz - 1; i++){size_t j = 0;for (j = 0; j < sz - 1 - i; j++){if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//这里是找我们要比较的那俩地址,最开始是base,我们用width去找这一对,往后跳对应字节去找,用j可以找后面所有的要比较的数了//然后这俩地址传给e1,e2,就是通过指针找到比较函数{Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);//交换,交换函数,先把这俩地址给我,再把宽度给我}}}
}
//交换函数,用char接收,然后也接收宽度,交换的细节,是一个字节的交换,不是整个的交换,然后往后跳
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++;}
}//使用我们自己写的bubble_sort函数排序整型数组
void test3()
{int arr[] = { 9,8,7,6,5,4,3,2,1,0 };int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);//我们arr传给base,最开始的地址是base,第二个是加上一个,但是是无类型的,要给她类型//但是给他什么类型,也不能写死,所以我们用我们写的宽度,单位是字节,所以我们转化为char的指针//然后我找base后面的地址,就可以用字节(宽度)跳过int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}
}//使用我们自己写的bubble_sort函数排序结构体数组
//结构体的时候跟上面的是一样的
void test4()
{struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };int sz = sizeof(s) / sizeof(s[0]);bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}int main()
{//用库函数qsort实现排序test1();//整型test2();//结构体//自己用冒泡排序的思想模拟实现qsorttest3();//整型test4();//结构体return 0;
}

函数1,函数2,就是我们上面用库函数来进行排序,很方便,只要我们创建一个类型函数,是要去排序整型还是结构体还是其他的,我们去创建一个,然后用函数指针去接收;

函数3,函数4,就是我们用冒牌排序的思想模拟实现这个库函数,在分析一下。

bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);

传要排序的数组,个数,字节,还有我们提供的函数地址

bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);

bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);

结构体也是一样的,要传过去什么,最重要的是我们提供的函数

首先就是用什么去接收 

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
为了能接收各种类型所以void* base,sz就是元素的个数, width宽度你只知道个数,宽度为了知道几个字节,最后用函数指针用来,在这个函数中指针接收要比较的地址

然后就是去判断两个比较数

 if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
这里是找我们要比较的那俩地址,最开始是base,我们用width去找这一对,往后跳对应字节去找,用j可以找后面所有的要比较的数了,然后这俩地址传给e1,e2,就是通过指针找到比较函数

判断完去交换位置

Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);

交换,交换函数,先把这俩地址给我,再把宽度给我

思路:

当我们整体看的时候,我们先进入到test3函数中,到我们的冒泡排序bubble_sort中传入数据

传到cmp_int时候,是把cmp_int函数的地址传到bubble_sort函数中的参数int(*cmp)(const void* e1, const void* e2)函数指针中,也就是cmp

所以我bubble_sort函数中的cmp指针指向的就是cmp_int函数,然后我们开始进入循环然后到判断,利用base和wide宽度找到要比较的两个数的地址

由cmp指针指向到cmp_int函数(把这俩比较数的地址传来,给e1,e2)然后算出返回值,然后看是否进行交换,进入到swap交换函数中去交换。

9. 指针和数组笔试题解析
// 一维数组
int a [] = { 1 , 2 , 3 , 4 };
printf ( "%d\n" , sizeof ( a ));
//数组名a单独放在sizeof内部,计算的是整个数组的大小,单位是字节,4*4=16;
printf ( "%d\n" , sizeof ( a + 0 ));
//a表示数组首元素地址,a+0还是数组首元素的地址,是地址大小4/8;
printf ( "%d\n" , sizeof ( * a ));
//a表示的首元素的地址,*a就是对首元素的地址的解引用,就是首元素,大小为4字节;
printf ( "%d\n" , sizeof ( a + 1 ));
//a表示首元素的地址,a+1是第二个元素的地址,是地址,大小就是4/8个字节;
printf ( "%d\n" , sizeof ( a [ 1 ]));
//a[1]是第二个元素,大小是4个字节;
printf ( "%d\n" , sizeof ( & a ));
//&a表示的是数组的地址,但也是地址,地址大小就是4/8个字节;
printf ( "%d\n" , sizeof ( *& a ));
printf ( "%d\n" , sizeof ( & a + 1 ));
printf ( "%d\n" , sizeof ( & a [ 0 ]));
printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 ));
// 字符数组
char arr [] = { 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };
printf ( "%d\n" , sizeof ( arr ));
printf ( "%d\n" , sizeof ( arr + 0 ));
printf ( "%d\n" , sizeof ( * arr ));
printf ( "%d\n" , sizeof ( arr [ 1 ]));
printf ( "%d\n" , sizeof ( & arr ));
printf ( "%d\n" , sizeof ( & arr + 1 ));
printf ( "%d\n" , sizeof ( & arr [ 0 ] + 1 ));
printf ( "%d\n" , strlen ( arr ));
printf ( "%d\n" , strlen ( arr + 0 ));
printf ( "%d\n" , strlen ( * arr ));
printf ( "%d\n" , strlen ( arr [ 1 ]));
printf ( "%d\n" , strlen ( & arr ));
printf ( "%d\n" , strlen ( & arr + 1 ));
printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 ));
char arr [] = "abcdef" ;
printf ( "%d\n" , sizeof ( arr ));
printf ( "%d\n" , sizeof ( arr + 0 ));
printf ( "%d\n" , sizeof ( * arr ));
printf ( "%d\n" , sizeof ( arr [ 1 ]));
printf ( "%d\n" , sizeof ( & arr ));
printf ( "%d\n" , sizeof ( & arr + 1 ));
printf ( "%d\n" , sizeof ( & arr [ 0 ] + 1 ));
printf ( "%d\n" , strlen ( arr ));
printf ( "%d\n" , strlen ( arr + 0 ));
printf ( "%d\n" , strlen ( * arr ));
printf ( "%d\n" , strlen ( arr [ 1 ]));
printf ( "%d\n" , strlen ( & arr ));
printf ( "%d\n" , strlen ( & arr + 1 ));
printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 ));
char * p = "abcdef" ;
printf ( "%d\n" , sizeof ( p ));
printf ( "%d\n" , sizeof ( p + 1 ));
printf ( "%d\n" , sizeof ( * p ));
printf ( "%d\n" , sizeof ( p [ 0 ]));
printf ( "%d\n" , sizeof ( & p ));
printf ( "%d\n" , sizeof ( & p + 1 ));
printf ( "%d\n" , sizeof ( & p [ 0 ] + 1 ));
printf ( "%d\n" , strlen ( p ));
printf ( "%d\n" , strlen ( p + 1 ));
printf ( "%d\n" , strlen ( * p ));
printf ( "%d\n" , strlen ( p [ 0 ]));
printf ( "%d\n" , strlen ( & p ));
printf ( "%d\n" , strlen ( & p + 1 ));
printf ( "%d\n" , strlen ( & p [ 0 ] + 1 ));
// 二维数组
int a [ 3 ][ 4 ] = { 0 };
printf ( "%d\n" , sizeof ( a ));
printf ( "%d\n" , sizeof ( a [ 0 ][ 0 ]));
printf ( "%d\n" , sizeof ( a [ 0 ]));
printf ( "%d\n" , sizeof ( a [ 0 ] + 1 ));
printf ( "%d\n" , sizeof ( * ( a [ 0 ] + 1 )));
printf ( "%d\n" , sizeof ( a + 1 ));
printf ( "%d\n" , sizeof ( * ( a + 1 )));
printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 ));
printf ( "%d\n" , sizeof ( * ( & a [ 0 ] + 1 )));
printf ( "%d\n" , sizeof ( * a ));
printf ( "%d\n" , sizeof ( a [ 3 ]));
总结:
数组名的意义:
1. sizeof( 数组名 ) ,这里的数组名表示整个数组,计算的是整个数组的大小。
2. & 数组名,这里的数组名表示整个数组,取出的是整个数组的地址。
3. 除此之外所有的数组名都表示首元素的地址。

结束语

指针有很多需要学习的地方,本文有借鉴前人经验,非常感谢。。。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/64318.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Web JavaScript Encrypt

Web JavaScript Encrypt 客户端加密解密

#代码实践 Springboot3.4.0 热部署

一、环境 Spring3.4.0 idea2024.3.1 二、热部署配置 1、pom.xml增加 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency> …

基于 mzt-biz-log 实现接口调用日志记录

&#x1f3af;导读&#xff1a;mzt-biz-log 是一个用于记录操作日志的通用组件&#xff0c;旨在追踪系统中“谁”在“何时”对“何事”执行了“何种操作”。该组件通过简单的注解配置&#xff0c;如 LogRecord&#xff0c;即可实现接口调用的日志记录&#xff0c;支持成功与失败…

DateRangePickerDialog组件的用法

文章目录 概念介绍使用方法示例代码我们在上一章回中介绍了DatePickerDialog Widget相关的内容,本章回中将介绍DateRangePickerDialog Widget.闲话休提,让我们一起Talk Flutter吧。 概念介绍 我们在这里说的DateRangePickerDialog是一种弹出窗口,只不过窗口的内容固定显示为…

JAVA企业级项目的日志记录技术

记录日志的作用 常用的日志框架 记录日志的准备工作 配置文件详解 日志级别

程序设计考题汇总(四:SQL练习)

文章目录 查询结果限制返回行数 查询结果限制返回行数 select device_id from user_profile LIMIT 2;

C++对象数组对象指针对象指针数组

一、对象数组 对象数组中的每一个元素都是同类的对象&#xff1b; 例1 对象数组成员的初始化 #include<iostream> using namespace std;class Student { public:Student( ){ };Student(int n,string nam,char s):num(n),name(nam),sex(s){};void display(){cout<&l…

时钟分频模块

实现时钟的二分频&#xff0c;四分频 1.时钟分频模块&#xff1a; module clk_div(input clk, //50Mhzinput rst_n,input [15:0] lcd_id,output reg lcd_pclk);reg clk_25m; reg clk_12_5m; reg …

盛元广通畜牧与水产品检验技术研究所LIMS系统

一、系统概述 盛元广通畜牧与水产品检验技术研究所LIMS系统集成了检测流程管理、样品管理、仪器设备管理、质量控制、数据记录与分析、合规性管理等功能于一体&#xff0c;能够帮助实验室实现全流程的数字化管理。在水产、畜牧产品的质检实验室中&#xff0c;LIMS系统通过引入…

Vscode搭建C语言多文件开发环境

一、文章内容简介 本文介绍了 “Vscode搭建C语言多文件开发环境”需要用到的软件&#xff0c;以及vscode必备插件&#xff0c;最后多文件编译时tasks.json文件和launch.json文件的配置。即目录顺序。由于内容较多&#xff0c;建议大家在阅读时使用电脑阅读&#xff0c;按照目录…

系统思考—持续修炼

昨天每周一下午的学习实验室&#xff0c;大家聊到“知行合一”&#xff0c;不禁感慨&#xff1a;人生其实就是一场修炼。就像我们分享的《第五项修炼》和《系统思考》的方法论&#xff0c;不仅仅是传授给他人&#xff0c;更是我们自己持续在实践的过程。 上周&#xff0c;庄老…

Android Studio、JDK、AGP、Gradle、kotlin-gradle-plugin 兼容性问题

文章目录 问题&#xff1a;解决办法&#xff1a;gradle与 java的版本兼容AGP与Gradle的版本兼容kotlin 与 jvm 的版本兼容KGP、Gradle、AGP兼容关系kotlin 与 java 的编译版本配置 问题&#xff1a; 你从githb上clone了一个项目&#xff0c;本地跑的时候&#xff0c;各种报错。…

Linux文件属性 --- 七种文件类型---文件.目录、软硬链接、字符设备文件

目录 七种文件类型 1、普通文件和目录 2、链接文件 2.1硬链接 2.2软链接 3、字符设备文件 一、七种文件类型 Linux的文件属性中一共有以下七种类型 &#xff1a; 符号类型含义解释-普通文件纯文本文件&#xff08;ASCII&#xff09;和二进制文件&#xff08;binary&#xff…

【WPF】把DockPanel的内容生成图像

要在WPF中将一个 DockPanel 的内容生成为图像并保存&#xff0c;可以按照与之前类似的步骤进行&#xff0c;但这次我们将专注于 DockPanel 控件而不是整个窗口。 DockPanel的使用 WPF&#xff08;Windows Presentation Foundation&#xff09;中的 DockPanel 是一种布局控件&…

Linux DNS 协议概述

1. DNS 概述 互联网中&#xff0c;一台计算机与其他计算机通信时&#xff0c;通过 IP 地址唯一的标志自己。此时的 IP 地址就类似于我们日常生活中的电话号码。但是&#xff0c;这种纯数字的标识是比较难记忆的&#xff0c;而且数量也比较庞大。例如&#xff0c;每个 IPv4 地址…

cursor的composer功能

1、对project概括 这个项目是关于什么&#xff1f; what is this project about? 网友表示&#xff1a;「带有 Cursor Agent 的 Cursor 0.43.3 太疯狂了。」

C++中类和对象的细节原理

文章目录 一、C中的构造函数二、C中的析构函数三、两者的配合与注意事项四、C中的静态成员变量五、C中的静态成员函数六、C中普通成员函数和静态成员函数的区别七、C中的const成员变量八、C中的const 成员函数九、C中构造函数的初始化列表十、C中的浅拷贝操作十一、C中的深拷贝…

vue CSS 自定义宽高 翻页 剥离 效果

新增需求&#xff0c;客户需要类似PPT的剥离效果用于WEB页面翻页&#xff0c;查找资料后&#xff0c;参考下方的掘金博主的文章&#xff0c;并将HTML修改成vue的页面进行使用。其中宽度、高度改成了变量&#xff0c;样式style中的属性与宽高的关系整理成了公式进行动态计算。 …

拿到小米 Offer,却迷茫了。。

大家好&#xff0c;我是程序员鱼皮&#xff0c;12 月了&#xff0c;很多小伙伴也拿到了秋招的 Offer&#xff08;没拿到也不要灰心&#xff09;&#xff0c;但即使拿到 Offer&#xff0c;可能还会有一些其他的顾虑。今天分享我们编程导航一位鱼友的提问&#xff0c;给大家作为学…

transformer学习笔记-自注意力机制(2)

经过上一篇transformer学习笔记-自注意力机制&#xff08;1&#xff09;原理学习&#xff0c;这一篇对其中的几个关键知识点代码演示&#xff1a; 1、整体qkv注意力计算 先来个最简单未经变换的QKV处理&#xff1a; import torch Q torch.tensor([[3.0, 3.0,0.0],[0.5, 4…