C.C语言刨析指针

文章目录

一. 初始指针

1.1. 指针是什么

1.2. 指针和指针类型

1.2.1. 指针+-整数

1.2.2. 指针的解引用

1.3. 野指针

1.3.1. 野指针成因

1.3.2. 如何规避野指针

1.4. 指针运算

1.4.1. 指针+整数

1.4.2. 指针-指针

1.4.3. 指针的关系运算

1.5. 指针和数组

1.6. 二级指针

1.7. 指针数组

二. 进阶指针

2.1. 字符指针

2.2. 指针数组

2.3. 数组指针

2.3.1. 数组指针的定义

2.3.2. &数组名VS数组名

2.3.3. 数组指针的使用

2.4. 数组参数、指针参数

2.4.1. 一维数组传参

2.4.2. 二维数组传参

2.4.3. 一级指针传参

2.4.4. 二级指针传参

2.5. 函数指针

2.6. 函数指针数组

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

2.8. 回调函数

三. 指针和数组笔试题解析

四. 指针笔试题


一. 初始指针

1.1. 指针是什么

指针理解的2个要点:

  • 指针是内存中一个最小单元的编号,也就是地址。

  • 平时口语中说的指针,通常指的是指针变量,是用来存放内存地址的变量。

总结:指针就是地址,口语中说的指针通常指的是指针变量。

那我们就可以这样理解:

内存:

                                                        

指针变量

我们可以通过&(取地址操作符)取出变量的内存其实地址,把地址可以存放到一个变量中,这个 变量就是指针变量。

d#include <stdio.h>
int main()
{
    int a = 10;// 在内存中开辟一块空间
    int* p = &a;// 这里我们对变量a,取出它的地址,可以使用&操作符。
    // a变量占用4个字节的空间,这里是将a的4个字节的第一个字节的地址存放在p变量中,p就是一个之指针变量。
    
    return 0;
}

总结:

指针变量,用来存放地址的变量。(存放在指针中的值都被当成地址处理),那这里的问题是:

  • 一个小的单元到底是多大?(1个字节)

  • 如何编址?

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。

对于32位的机器,假设有32根地址线,那么假设每根地址线在寻址的时候产生高电平(高电压)和低电 平(低电压)就是(1或者0);

那么32根地址线产生的地址就会是:

  • 这里就有2的32次方个地址。

  • 每个地址标识一个字节,那我们就可以给 (2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB) 4G的空闲进行编址。

  • 同样的方法,那64位机器,如果给64根地址线,那能编址多大空间,自己计算。

这里我们就明白:

  • 在32位的机器上,地址是32个0或者1组成二进制序列,那地址就得用4个字节的空间来存储,所以 一个指针变量的大小就应该是4个字节。

  • 那如果在64位机器上,如果有64个地址线,那一个指针变量的大小是8个字节,才能存放一个地 址。

总结:

  • 指针是用来存放地址的,地址是唯一标示一块地址空间的。

  • 指针的大小在32位平台是4个字节,在64位平台是8个字节。

1.2. 指针和指针类型

这里我们在讨论一下:指针的类型 我们都知道,变量有不同的类型,整形,浮点型等。那指针有没有类型呢? 准确的说:有的。

当有这样的代码:

int num = 10;
p = &num;

要将&num(num的地址)保存到p中,我们知道p就是一个指针变量,那它的类型是怎样的呢?

我们给指针变量相应的类型。

char  *pc = NULL;
int   *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

这里可以看到,指针的定义方式是: type + * 。

其实:

  • char* 类型的指针是为了存放 char 类型变量的地址。

  • short* 类型的指针是为了存放 short 类型变量的地址。

  • int* 类型的指针是为了存放 int 类型变量的地址。

那指针类型的意义是什么?

1.2.1. 指针+-整数

#include <stdio.h>
​
int main()
{
    int n = 10;
    char* pc = (char*)&n;
    int* pi = &n;
​
    printf("%p\n", &n);
    printf("%p\n", pc);
    printf("%p\n", pc + 1);
    printf("%p\n", pi);
    printf("%p\n", pi + 1);
    return  0;
}

总结:指针的类型决定了指针向前或者向后走一步有多大(距离)。

1.2.2. 指针的解引用

#include <stdio.h>
​
int main()
{
    int n = 0x11223344;
    char* pc = (char*)&n;
    int* pi = &n;
    *pc = 0;   //重点在调试的过程中观察内存的变化。
    *pi = 0;   //重点在调试的过程中观察内存的变化。
    return 0;
}

总结: 指针的类型决定了,对指针解引用的时候有多大的权限(能操作几个字节)。 比如: char* 的指针解引用就只能访问一个字节,而 int* 的指针的解引用就能访问四个字节。

1.3. 野指针

概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)

1.3.1. 野指针成因

  • 指针未初始化

#include <stdio.h>
​
int main()
{
    int* p;//局部变量指针未初始化,默认为随机值
    *p = 20;
    return 0;
}
  • 指针越界访问

#include <stdio.h>
​
int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;
    for (i = 0; i <= 11; i++)
    {
        //当指针指向的范围超出数组arr的范围时,p就是野指针
        *(p++) = i;
    }
    return 0;
}
  • 指针指向的空间释放

1.3.2. 如何规避野指针

  • 指针初始化

  • 小心指针越界

  • 指针指向空间释放即使置NULL

  • 避免返回局部变量的地址

  • 指针使用之前检查有效性

#include <stdio.h>
​
int main()
{
    int* p = NULL;
    //....
    int a = 10;
    p = &a;
    if (p != NULL)
    {
        *p = 20;
    }
    return 0;
}

1.4. 指针运算

1.4.1. 指针+整数

#define N_VALUES 5
float values[N_VALUES];
float* vp;
//指针+-整数;指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
    *vp++ = 0;
}

1.4.2. 指针-指针

int my_strlen(char* s)
{
    char* p = s;
    while (*p != '\0')
        p++;
    return p - s;
}

1.4.3. 指针的关系运算

for (vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

代码简化, 这将代码修改如下:

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

实际在绝大部分的编译器上是可以顺利完成任务的,然而我们还是应该避免这样写,因为标准并不保证 它可行。

标准规定:

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较,但是不允许与 指向第一个元素之前的那个内存位置的指针进行比较。

1.5. 指针和数组

我们看一个例子:

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

可见数组名和数组首元素的地址是一样的。

结论:数组名表示的是数组首元素的地址

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr; // p存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中,我们使用指针来访问一个就成为可能。

例如:

#include <stdio.h>
int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int* p = arr;  // 指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
    }
    return 0;
}

运行结果:

所以 p+i 其实计算的是数组 arr 下标为i的地址。 那我们就可以直接通过指针来访问数组。

如下:

int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    int* p = arr;  // 指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(p + i));
    }
    return 0;
}

1.6. 二级指针

指针变量也是变量,是变量就有地址,那指针变量的地址存放在哪里?

这就是 二级指针 。

                                             

对于二级指针的运算有:

  • *ppa 通过对ppa中的地址进行解引用,这样找到的是 pa , *ppa 其实访问的就是 pa .

int b = 20;
*ppa = &b; // 等价于 pa = &b;
  • **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作: *pa ,那找到的是 a .

**ppa = 30;
// 等价于*pa = 30;
// 等价于a = 30;

1.7. 指针数组

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

答案:是数组。是存放指针的数组。 数组我们已经知道整形数组,字符数组。

int arr1[5];
char arr2[6];

                                   

那指针数组是怎样的?

arr3是一个数组,有五个元素,每个元素是一个整形指针。

                                        

2.1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针 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 bit.";// 这里是把一个字符串放到pstr指针变量里了吗?
    printf("%s\n", pstr);
    return 0;
}

代码 const char* pstr = "hello bit." ,特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了,但是/本质是把字符串 hellobit. 首字符的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

那就有可这样的面试题:

#include <stdio.h>

int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";

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

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

2.2. 指针数组

指针数组是一个存放指针的数组。

int* arr1[10];  // 整形指针的数组
char* arr2[4];  // 一级字符指针的数组
char** arr3[5]; // 二级字符指针的数组

#include <stdio.h>
int main() {
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	// 存放三个数组的指针数组
	int* arrArray[] = { arr1, arr2, arr3 };

	return 0;
}

2.3. 数组指针

2.3.1. 数组指针的定义

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

答案是:指针。

我们已经熟悉:整形指针: int * pint; 能够指向整形数据的指针,浮点型指针: float * pf; 能够指向浮点型数据的指针,那数组指针应该是:能够指向数组的指针。 下面代码哪个是数组指针?

int *p1[10];
int (*p2)[10];
// p1, p2分别是什么?

解释:

int (*p)[10];
// 解释:p先和*结合,说明p是一个指针变量,然后指着指向的是一个大小为10个整型的数组。所以p是一个指针,指向一个数组,叫数组指针。
// 这里要注意:[]的优先级要高于*号的,所以必须加上()来保证p先和*结合。


int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	// 下面就是arr的数组指针,类型就是 int(*)[10]。
	int(*pA)[10] = &arr;

	return 0;
}

2.3.2. &数组名VS数组名

对于下面的数组:

int arr[10];

arr 和 &arr 分别是啥?-> 我们知道arr是数组名,数组名表示数组首元素的地址,那&arr数组名到底是啥? 我们看一段代码:

#include <stdio.h>

int main() {
	int arrInt[10] = { 0 };

	printf("%p\n", arrInt);
	printf("%p\n", &arrInt);

	// 打印结果:010FF6C4
	//         010FF6C4

	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

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

一个数组指针的使用:

void print_arr2(int (*pArr)[5], int row, int col) // int (*pArr)[5] 二维数组的数组名是首行的地址,所以省略[row]
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf("%d ", *(*(pArr + i) + j));
			// printf("%d ", pArr[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是整型数组
int *parr1[10];        // parr1整型指针数组
int (*parr2)[10];	   // parr2整型数组指针
int (*parr3[10])[5];   // parr3整型存放数组指针的数组

2.4. 数组参数、指针参数

2.4.1. 一维数组传参

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

#include <stdio.h>

void test(int arr[])//ok? --> 可以
{}

void test(int arr[10])//ok? --> 可以
{}

void test(int* arr)//ok? --> 可以
{}

void test2(int* arr[])//ok? --> 可以
{}

void test2(int* arr[20])//ok? --> 可以
{}

void test2(int** arr)//ok? --> 可以
{}

int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };

	test(arr);
	test2(arr2);

	return 0;
}

2.4.2. 二维数组传参

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

2.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函数能接收什么参数?
​
void test2(char* p)
{}
// test2函数能接收什么参数?

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

思考:当函数的参数为二级指针的时候,可以接收什么参数?

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

2.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 Add(int x, int y) {
	return x + y;
}


int main() {
	// 函数指针定义
	int (*pAdd)(int, int) = &Add;

	// 函数指针使用
	printf("%d\n", (*pAdd)(3, 2)); // 5
	printf("%d\n", pAdd(3, 2)); // 5

	return 0;
}

阅读两段有趣的代码:

//代码1
(*(void (*)())0)();

// 代码1解析:以上代码是一次函数调用,调用的是0作为地址处的函数
(* ( void (*)() )0 )();
// 1、把0强制类型转换为:无参,返回类型是void的函数地址。
// 2、调用0地址处的这个函数。
// 代码2
void (*signal(int , void(*)(int)))(int);
							|
     signal(int , void(*)(int))
          		|
        void (*  )(int);
								
// 代码2太复杂,如何简化:
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

函数指针的好用之处,看下面这段代码:

#include <stdio.h>
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, y = 0, ret = 0;

    do{
        printf("请选择计算机功能:0=退出 1=加法 2=减法 3=乘法 4=除法\n");
        scanf("%d", &input);

        switch(input) {
            case 0: {
                break;
            }
            case 1: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);

                ret = Add(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 2: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);

                ret = Sub(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 3: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);

                ret = Mul(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 4: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);

                ret = Div(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
        }

    } while(input);

    return 0;
}

使用函数指针对该代码进行优化:

#include <stdio.h>
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; }

// 函数指针优化的函数,被称为“回掉函数”
void Clc( int(*pf)(int, int)) {
    printf("请输入两个计算的数值:> ");

    int x = 0, y = 0;
    scanf("%d %d", &x, &y);

    int ret = pf(x, y);
    printf("计算结果:> %d\n", ret);
}

int main() {
    int input = 0;
    
    do{
        printf("请选择计算机功能:0=退出 1=加法 2=减法 3=乘法 4=除法\n");
        scanf("%d", &input);

        switch(input) {
            case 0: {
                break;
            }
            case 1: {
                Clc(Add);
                break;
            }
            case 2: {
                Clc(Sub);
                break;
            }
            case 3: {
                Clc(Mul);
                break;
            }
            case 4: {
                Clc(Div);
                break;
            }
        }

    } while(input);

    return 0;
}

2.6. 函数指针数组

数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,比如:

int *arr[10];  // 数组的每个元素是int*

那要把函数的地址存到一个数组中,那这个数组就叫函数指针数组,那函数指针的数组如何定义呢?

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案是:parr1,先和 [] 结合,说明 parr1是数组,数组的内容是什么呢? 是类型的函数指针。

#include <stdio.h>
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 (*pf)(int, int) = &Add;
// 函数指针数组
int (*pfArr[4])(int, int) = { Add, Sub, Mul, Div };
函数指针数组的用途: 转移表

比如继续和上面的计算器代码做比较:

#include <stdio.h>
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, y = 0, ret = 0;
​
    do{
        printf("请选择计算机功能:0=退出 1=加法 2=减法 3=乘法 4=除法\n");
        scanf("%d", &input);
​
        switch(input) {
            case 0: {
                break;
            }
            case 1: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);
​
                ret = Add(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 2: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);
​
                ret = Sub(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 3: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);
​
                ret = Mul(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
            case 4: {
                printf("请输入两个计算的数值:> ");
                scanf("%d %d", &x, &y);
​
                ret = Div(x, y);
                printf("计算结果:> %d\n", ret);
                break;
            }
        }
​
    } while(input);
​
    return 0;
}

使用函数指针数组对该代码进行优化:

#include <stdio.h>
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 (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div }; // 转移表(解决代码冗长的作用)
​
    int input = 0;
    do{
        printf("请选择计算机功能:0=退出 1=加法 2=减法 3=乘法 4=除法\n");
        scanf("%d", &input);
​
        if(input == 0) {
            printf("小程序退出!\n");
            break;
        }
        else {
            int x = 0, y = 0;
            printf("请输入两个计算的数值:> ");
            scanf("%d %d", &x, &y);
​
            int ret = pfArr[input](x, y);
            printf("计算结果:> %d\n", ret);
        }
    } while(input);
​
    return 0;
}

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

指向函数指针数组的指针是一个 指针,指针指向一个 数组 ,数组的元素都是 ; 如何定义?

#include <stdio.h>
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 (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };

// 指向函数指针数组的指针
int (*(*ppfArr)[5])(int, int) = &pfArr;
代码如下:

#include <stdio.h>
void test(const char* str)
{
    printf("%s\n", str);
}

int main() {
    //函数指针pfun
    void (*pfun)(const char*) = test; 
    
    //函数指针的数组pfunArr
    void (*pfunArr[5])(const char* str);
    pfunArr[0] = test; 
    
    //指向函数指针数组pfunArr的指针ppfunArr
    void (*(*ppfunArr)[5])(const char*) = &pfunArr; return 0;
}

2.8. 回调函数

引入冒泡排序:

#include <stdio.h>
#include <assert.h>
#include <stdbool.h>

/* 打印函数 */
void Print(int* buffer, int size) {
	assert(buffer);

	for (int i = 0; i < size; i++) {
		printf("%d ", buffer[i]);
	}

	printf("\n");
}

/* 冒泡排序函数 */
void BubbleSort(int* buffer, int size) {
	assert(buffer);

	for (int i = 0; i < size - 1; i++) {
		bool flag = true;

		for (int j = 0; j < size - 1 - i; j++) {
			if (buffer[j] > buffer[j + 1]) {
				int temp = buffer[j];
				buffer[j] = buffer[j + 1];
				buffer[j + 1] = temp;

				flag = false;
			}
		}

		// j(for)中如果falg还是为true,说明已经有序,不需要进行排序了
		if (flag == true) {
			break;
		}
	}
}

/* 主函数 */
int main() {
	int buffer[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int size = sizeof(buffer) / sizeof(buffer[0]);

	// 打印
	Print(buffer, size);

	// 排序
	BubbleSort(buffer, size);

	// 打印
	Print(buffer, size);

	return 0;
}

那如果要对不同的数据类型进行排序呢,BubbleSort实现不了了。

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说

这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。

首先演示一下qsort函数的使用:

// 来自于C语言库中:
void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));
// base 需要排序的其实位置
// num 待排序的数据元素的个数
// size 待排序的数据元素的大小(单位是字节)
// (*compar)(const void*,const void*) 函数指针

// 描述解释:
// 按基数对数组的num个元素进行排序,每个元素的长度为字节大小,使用比较函数确定顺序。
// 此函数使用的排序算法通过调用指定的比较函数来比较元素对,方法是将指向元素对的指针作为参数。
// 该函数不返回任何值,但通过按compare定义的对其元素进行基本重排序来修改所指向的数组的内容。
// 等效元素的顺序未定义。

// 调用qsort示例演示:
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>

/* 打印函数 */
void Print(int* buffer, int size) {
	assert(buffer);

	for (int i = 0; i < size; i++) {
		printf("%d ", buffer[i]);
	}

	printf("\n");
}

// qosrt函数的使用者得实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
	// <  返回 -1
	// == 返回  0
	// >  返回  1
	return (*(int*)p1 - *(int*)p2);
}

/* 主函数 */
int main() {
	int buffer[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int size = sizeof(buffer) / sizeof(buffer[0]);

	// 打印
	Print(buffer, size);

	// 排序
	qsort(buffer, size, sizeof(buffer[0]), int_cmp);

	// 打印
	Print(buffer, size);

	return 0;
}

--------------------------------------------------------------------------------------------------------------------------------

// 调用qsort示例演示:
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

struct Student {
	char name[20];
	int age;
};

// qosrt函数的使用者得实现一个比较函数
int str_cmp(const void* p1, const void* p2) {
	// <  返回 -1
	// == 返回  0
	// >  返回  1
	return strcmp(((struct Student*)p1)->name, ((struct Student*)p2)->name);
}

/* 主函数 */
int main() {
	struct Student students[] = { {"zhang san", 19}, {"li si", 20}, {"wang wu", 21} };
	int size = sizeof(students) / sizeof(students[0]);

	// 排序
	qsort(students, size, sizeof(students[0]), str_cmp);

	return 0;
}
使用回调函数,模拟实现qsort,一定要注意void*(采用冒泡的方式)。

#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
​
/* 打印函数 */
void Print(int* buffer, int size) {
    assert(buffer);
​
    for (int i = 0; i < size; i++) {
        printf("%d ", buffer[i]);
    }
​
    printf("\n");
}
​
/* qosrt函数的使用者得实现一个比较函数 */
int int_cmp(const void* p1, const void* p2) {
    // <  返回 -1
    // == 返回  0
    // >  返回  1
    return (*(int*)p1 - *(int*)p2);
}
​
/* Myqosrt函数模拟实现(交换函数) */
void BubbleSwap(void* buf1, void* buf2, int wight) {
    // 按照字节交换
    for (int i = 0; i < wight; i++) {
        char tmp = *((char*)buf1 + i);
        *((char*)buf1 + i) = *((char*)buf2 + i);
        *((char*)buf2 + i) = tmp;
    }
}
​
/* Myqosrt函数模拟实现(BubbleSort版本) */
void BubbleQsort(void* buffer, int size, int wight, int(*cmp)(void*, void*)) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (cmp((char*)buffer + j * wight, (char*)buffer + (j + 1) * wight) > 0) {
                BubbleSwap((char*)buffer + j * wight, (char*)buffer + (j + 1) * wight, wight);
            }
        }
    }
}
​
/* 主函数 */
int main() {
    int buffer[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int size = sizeof(buffer) / sizeof(buffer[0]);
​
    // 打印
    Print(buffer, size);
​
    // 排序
    BubbleQsort(buffer, size, sizeof(buffer[0]), int_cmp);
​
    // 打印
    Print(buffer, size);
​
    return 0
}
--------------------------------------------------------------------------------------------------------------------------------
​
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
​
/* 测试结构体 */
struct Student {
    char name[20];
    int age;
};
​
// qosrt函数的使用者得实现一个比较函数
int str_cmp(const void* p1, const void* p2) {
    // <  返回 -1
    // == 返回  0
    // >  返回  1
    return strcmp(((struct Student*)p1)->name, ((struct Student*)p2)->name);
}
​
/* Myqosrt函数模拟实现(交换函数) */
void BubbleSwap(void* buf1, void* buf2, int wight) {
    // 按照字节交换
    for (int i = 0; i < wight; i++) {
        char tmp = *((char*)buf1 + i);
        *((char*)buf1 + i) = *((char*)buf2 + i);
        *((char*)buf2 + i) = tmp;
    }
}
​
/* Myqosrt函数模拟实现(BubbleSort版本) */
void BubbleQsort(void* buffer, int size, int wight, int(*cmp)(void*, void*)) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (cmp((char*)buffer + j * wight, (char*)buffer + (j + 1) * wight) > 0) {
                BubbleSwap((char*)buffer + j * wight, (char*)buffer + (j + 1) * wight, wight);
            }
        }
    }
}
​
/* 主函数 */
int main() {
    struct Student students[] = { {"zhang san", 19}, {"li si", 20}, {"wang wu", 21} };
    int size = sizeof(students) / sizeof(students[0]);
​
    // 排序
    BubbleQsort(students, size, sizeof(students[0]), str_cmp);
​
    return 0;
}

三. 指针和数组笔试题解析

// 一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));           // 16    :  sizeof(数组名),数组名表示整个数组,计算的是整个数组大小,单位是字节
printf("%d\n",sizeof(a+0));			// 4/8   : a不是单独放在sizeof内部,也没有取地址,所以a就是首元素的地址,a+0还是首元素的地址,是地址就是4/8
printf("%d\n",sizeof(*a));			// 4/8   :	
printf("%d\n",sizeof(a+1));			// 4/8   : 
printf("%d\n",sizeof(a[1]));		// 4/8   :
printf("%d\n",sizeof(&a));			// 4/8   :  
printf("%d\n",sizeof(*&a));			// 16    :  &a拿到的是数组名的地址,类型是int(*)[4],是一种数组指针。
printf("%d\n",sizeof(&a+1)); 		// 4/8   :
printf("%d\n",sizeof(&a[0]));		// 4/8   :
printf("%d\n",sizeof(&a[0]+1));		// 4/8   :

// 字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));		// 6
printf("%d\n", sizeof(arr+0));		// 4
printf("%d\n", sizeof(*arr));		// 1
printf("%d\n", sizeof(arr[1]));		// 1
printf("%d\n", sizeof(&arr));		// 4/8
printf("%d\n", sizeof(&arr+1));		// 4/8
printf("%d\n", sizeof(&arr[0]+1));	// 4/8

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));		// 随机值-6
printf("%d\n", strlen(&arr[0]+1));	// 随机值-1

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));		// 7
printf("%d\n", sizeof(arr+0));		// 4
printf("%d\n", sizeof(*arr));		// 1
printf("%d\n", sizeof(arr[1]));		// 1
printf("%d\n", sizeof(&arr));		// 4/8
printf("%d\n", sizeof(&arr+1));		// 4/8
printf("%d\n", sizeof(&arr[0]+1));	// 4/8

printf("%d\n", strlen(arr));		// 6	
printf("%d\n", strlen(arr+0));		// 6
printf("%d\n", strlen(*arr));		// 越界访问,错误
printf("%d\n", strlen(arr[1]));		// 越界访问,错误
printf("%d\n", strlen(&arr));		// 6	
printf("%d\n", strlen(&arr+1));		// 随机值
printf("%d\n", strlen(&arr[0]+1));	// 5

char *p = "abcdef";
printf("%d\n", sizeof(p));			// 4/8
printf("%d\n", sizeof(p+1));		// 4/8
printf("%d\n", sizeof(*p));			// 4/8
printf("%d\n", sizeof(p[0]));		// 4/8
printf("%d\n", sizeof(&p));			// 4/8
printf("%d\n", sizeof(&p+1));		// 4/8
printf("%d\n", sizeof(&p[0]+1));	// 4/8

printf("%d\n", strlen(p));			// 6
printf("%d\n", strlen(p+1));		// 5
printf("%d\n", strlen(*p));			// 越界访问,错误
printf("%d\n", strlen(p[0]));		// 越界访问,错误
printf("%d\n", strlen(&p));			// 随机值	
printf("%d\n", strlen(&p+1));		// 5
printf("%d\n", strlen(&p[0]+1));	// 5

//二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));			// 48
printf("%d\n",sizeof(a[0][0]));		// 4
printf("%d\n",sizeof(a[0]));		// 16
printf("%d\n",sizeof(a[0]+1));		// 4
printf("%d\n",sizeof(*(a[0]+1)));	// 4
printf("%d\n",sizeof(a+1));			// 4
printf("%d\n",sizeof(*(a+1)));		// 16
printf("%d\n",sizeof(&a[0]+1));		// 4
printf("%d\n",sizeof(*(&a[0]+1)));	// 16
printf("%d\n",sizeof(*a));			// 16
printf("%d\n",sizeof(a[3]));		// 16

总结数组名的意义:

  • sizeof(数组名),这里的数组名表示整个数组,计算的是整个数组的大小。

  • &数组名,这里的数组名表示整个数组,取出的是整个数组的地址。

  • 除此之外所有的数组名都表示首元素的地址。

四. 指针笔试题

笔试题1:

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int* ptr = (int*)(&a + 1);
    
    printf("%d,%d", *(a + 1), *(ptr - 1));
    return 0;
}
​
// 程序的结果是什么?
2 5

笔试题2:

// 由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;
​
// 假设p 的值为0x100000。 如下表表达式的值分别为多少?
// 已知,结构体Test类型的变量大小是20个字节
int main()
{
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}
​
// 程序的结果是什么?
00000014
00000001
00000004

笔试题3:

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int* ptr1 = (int*)(&a + 1);
    int* ptr2 = (int*)((int)a + 1);
​
    printf("%x,%x", ptr1[-1], *ptr2);
    return 0;
}
​
// 程序的结果是什么?
4,2000000

笔试题4:

int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int* p;
    p = a[0];
​
    printf("%d", p[0]);
    return 0;
}
// 程序的结果是什么?
1

笔试题5:

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
​
    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}
​
// 程序的结果是什么?
FFFFFFFC, -4

笔试题6:

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int* ptr1 = (int*)(&aa + 1);
    int* ptr2 = (int*)(*(aa + 1));
​
    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}
​
// 程序的结果是什么?
10,5

笔试题7:

int main()
{
    char* a[] = { "work","at","alibaba" };
    char** pa = a;
    pa++;
​
    printf("%s\n", *pa);
    return 0;
}
​
// 程序的结果是什么?
at

笔试题8:

int main()
{
    char* c[] = { "ENTER","NEW","POINT","FIRST" };
    char** cp[] = { c + 3,c + 2,c + 1,c };
    char*** cpp = cp;
​
    printf("%s\n", **++cpp);
    printf("%s\n", *-- * ++cpp + 3);
    printf("%s\n", *cpp[-2] + 3);
    printf("%s\n", cpp[-1][-1] + 1);
    return 0;
}
​
// 程序的结果是什么?
POINT
ER
ST
EW

  • 9
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: "C语言指针详解.pdf" 是一份详细介绍C语言指针概念和使用的PDF文档。C语言中,指针是一种特殊的变量类型,用于存储其他变量的内存地址。 该PDF文档首先详细介绍了指针的定义和声明。指针的声明需要指定指针变量的类型和名称,并使用星号(*)来表示该变量是一个指针指针变量名的前面加上一个星号,可以获取所指向的变量的值,这被称为"解引用"。 文档还介绍了指针的运算。指针可以进行自增和自减运算,指针之间可以进行相减操作,返回的结果表示它们之间的距离或者偏移量。此外,还可以将指针赋值给另一个指针,或者将指针赋值给一个变量,反之亦然。 除了基本的指针概念,文档还详细介绍了指针的常见应用场景。这包括指针作为函数参数,用于在函数内部对传入的变量进行修改。还有通过指针来实现动态内存分配和释放,以及使用指针实现数据结构(如链表和树)等。 此外,该文档还包含一些常见的指针错误和问题的解决方案。这些错误包括空指针引用、野指针引用以及内存泄漏等。文档指出了这些错误的影响以及如何避免它们。 总的来说,"C语言指针详解.pdf" 是一份详细介绍C语言指针概念、使用和常见问题解决方案的文档,对于学习和理解C语言指针的人们是一份宝贵的资料。 ### 回答2: 《C语言指针详解.pdf》是一本关于C语言指针的详细解析的电子书。在这本书中,作者详细介绍了C语言指针的概念、用途和基本语法。 首先,指针C语言中非常重要的概念,它是一种数据类型,用于存储和操作内存地址。指针可以指向各种数据类型,如整数、字符、数组和结构体等。 在《C语言指针详解.pdf》中,作者详细讲解了指针的声明和初始化,以及如何通过指针来访问和修改变量的值。作者还介绍了指针与数组的关系,以及指针和函数之间的关联。 此外,书中还涵盖了指针的高级应用,如指针的算术运算、指向指针指针指针数组等。作者通过丰富的例子和代码来帮助读者理解这些概念和技巧。 《C语言指针详解.pdf》不仅适合C语言初学者,也适合有一定编程基础的读者。通过阅读此书,读者将能够更深入地理解C语言指针的功能和用法,掌握指针在编程中的灵活运用。 总之,《C语言指针详解.pdf》是一本内容详尽且易于理解的C语言指针教程。读者通过阅读此书,可以提高自己在C语言编程中的指针应用能力,从而更好地实现程序的设计和开发。 ### 回答3: 《C语言指针详解.pdf》是一本介绍C语言指针概念和使用方法的详细手册。C语言中的指针是一种非常重要和特殊的数据类型,它提供了直接访问内存地址的能力,使得C语言具有了更高的灵活性和效率。 这本手册首先会介绍指针的基本概念,包括指针变量的定义和声明、指针的初始化和赋值。它会详细讲解指针和变量之间的关系,以及指针的运算规则和使用方法。读者可以学习到如何通过指针操作变量的值和地址,以及如何利用指针实现函数的参数传递和返回值。 接下来,手册会介绍指针和数组之间的关系。C语言中,数组名本质上是一个指向数组首元素的常量指针,因此可以通过指针来操作数组。手册将详细讲解指针和数组的指针算术运算,以及指针和多维数组的关系。 此外,手册还会介绍指针和字符串之间的关系。C语言中,字符串本质上是以空字符结尾的字符数组,可以通过指针来操作字符串。手册将详细讲解指针和字符串的操作,包括字符串的输入输出、字符串的比较和拷贝。 最后,手册还会介绍指针和结构体之间的关系。C语言中,结构体是用户自定义的复合数据类型,可以通过指针来操作结构体。手册将详细讲解指针和结构体的操作,包括结构体指针的定义和使用,以及结构体指针作为函数参数的传递方式。 总之,《C语言指针详解.pdf》是一本深入浅出的指针教程,对于想更深入理解C语言指针的读者来说,是一本非常实用的参考书。无论是初学者还是有一定基础的读者,都可以从中获得很多宝贵的知识和技巧。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值