C语言进阶-指针进阶（2）

已于 2023-10-27 20:19:13 修改
阅读量68 收藏
点赞数
文章标签： c语言 算法 数据结构
于 2023-10-10 20:57:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syh163/article/details/133742546
版权

目录

6.函数指针数组

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

 8.回调函数

8.1使用回调函数，模拟实现qsort函数

6.函数指针数组

我们现在可以把整型指针或者字符指针放在一个数组中，如下：

    int* arr[10];//整型指针数组
	char* arr2[10];//字符指针数组

那类比一下，函数指针数组就是存放函数指针的数组。

在学习函数指针数组之前，我们先来用前面学过的知识实现一个计算器（加法、减法、乘法、除法） ，

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 (*pf)(int, int) = Add;
	int (*pf1)(int, int) = Sub;
	int (*pf2)(int, int) = Mul;
	int (*pf3)(int, int) = Div;
	return 0;
}

以上代码分别写出加减乘除功能的函数，并将个函数的地址存放在函数指针中，我们可以发现，这几个函数的参数类型和返回类型是相同的，那我们能不能把它们放在一个数组中呢？

当然可以，这个数组就被称为函数指针数组 。

函数指针数组的写法如下：

int main()
{
	//函数指针数组
	int (*pf[4])(int, int) = { Add,Sub,Mul,Div };
	return 0;
}

通过观察其实可以发现，函数指针数组其实就是在函数指针变量pf后面加上[4]，pf和[4]先结合成数组，数组中存放的数据类型是函数指针类型int (*) (int,int)

下面我们来写一个完整的计算器代码：

#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 Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("********************************\n");
	printf("********1.加法   2.减法  *******\n");
	printf("********3.乘法   4.除法  *******\n");
	printf("********0.退出           *******\n");
	printf("********************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		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;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误，请重新选择：\n");
			break;
		}
	} while (input);
	return 0;
}

以上就是实现具有加减乘除功能的计算器，但是我们可以发现，这代码有点冗余，重复的代码太多，这仅仅是加减乘除，如果要实现其他功能（如a&b、a^b、a|b等），那case语句就会越来越多， 这显然不利于我们写代码。

要解决这个问题，这里就可以使用到函数指针数组了。

#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 Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("********************************\n");
	printf("********1.加法   2.减法  *******\n");
	printf("********3.乘法   4.除法  *******\n");
	printf("********0.退出           *******\n");
	printf("********************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//函数指针数组
	int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		if (input >=1 && input <= 4)
		{
			printf("请输入两个数：");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);//通过访问函数指针数组的元素调用函数
			printf("%d\n", ret);
		}
		else if(input == 0)
		{
			printf("退出计算器\n");
			break;
		}
		else
		{
			printf("选择错误，请重新选择：\n");
		}
	} while (input);
	return 0;
}

这里的函数指针数组写成 int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };数组中加上空指针NULL是为了在使用下标访问数组元素时与case语句相对应。

以上用函数指针数组实现的计算器，如果要写其他功能的函数，只需要写出实现相应功能的函数，并在函数指针数组中添加该函数地址即可，不需要再写很多case语句了， 

这种函数指针数组 int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };的使用也被称为转移表。 

在这里补充一点，一定要注意函数指针，和函数指针数组的书写方式。

对比一下：

	int* p;//指针
	int(*p)(int, int);//函数指针
	int(*P[5])(int, int);//函数指针数组

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

 前面我们讲了，int (*pfArr[5])(int, int)是函数指针数组，那既然是数组，就应该可以取地址&pfArr，现在要将这个地址存放在变量p中应该来怎么写呢？

首先，我们可以先写出函数指针数组int(*p[5])(int,int)，此时我们期望p是一个指针而不是一个数组，那就不要让它和 [5] 结合，而是加括号写成指针的形式(*p)，所以指向函数指针数组的指针应该写成：int(*(*p)[5])(int,int) = &pfArr，其中第一个 * 是外面函数指针的类型

这听上去就像是套娃一样，其实还可以继续一层一层的套下去。这里我们只简单了解一下。

void test(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	void (*pf)(const char* str);//pf是函数指针变量
	void(*pfArr[10])(const char* str);//pfArr是存放函数指针的数组
	void(*(*p)[10])(const char* str);//p是指向函数指针数组的指针
	return 0;
}

 8.回调函数

函数指针有一个特别大的用途就是回调函数，下面来看回调函数的概念：

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是有该函数的实现方直接调用的，而是在某种特定的事件或者条件发生时由另外一方调用，用于对该事件的反应。

解释一下：假设有两个函数A和B，把函数A的地址作为参数传给B，在使用B的时候，通过地址调用函数A，这个函数A就被称为回调函数。

使用回调函数也可以简化代码过程，比如之前写的计算器，我们可以把冗余的代码写成一个函数A()，每次调用这个函数就行了，但问题是这几段冗余的代码中也是有差异的，

 每段代码中的计算函数不同，此时仅仅写一个函数A()是不够的，要使用函数指针。

我们可以写一个calc()函数，然后把Add、Sub、Mul、Div作为参数传给它就行，这里的函数Add()、Sub()、Mul()、Div()就是回调函数。

具体实现如下：

#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 Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("********************************\n");
	printf("********1.加法   2.减法  *******\n");
	printf("********3.乘法   4.除法  *******\n");
	printf("********0.退出           *******\n");
	printf("********************************\n");
}
void calc(int(*p)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入两个数：");
	scanf("%d %d", &x, &y);
	ret = (*p)(x,y);
	printf("%d\n", ret);
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(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;
}

下面我们画图分析一下上述代码的调用逻辑：

8.1使用回调函数，模拟实现qsort函数

在此之前，我们先来回忆一下冒泡排序。这个具体在之前的数组章节中讲过，

链接贴在这：

https://blog.csdn.net/syh163/article/details/132279207

冒泡排序：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
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[] = { 3,1,5,2,4,6,8,9,7,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]);
	}
	return 0;
}

冒泡排序有一个明显的局限性，就是它只能排整型数据，如果我们要排一组浮点型、结构体数据、或者其他类型的数据，用冒泡排序法显然不行，那这里我们就来了解一个库函数qsort， 

qsort函数的特点：1.是一种快速排序的方法。2.适用于任意类型数据的排序。

我们可以在www.cplusplus.com中搜索一下该函数：

由上图可知，qsort函数由4个参数，分别是base、num、size、comper，参数类型分别是void*、size_t（无符号整型）、size_t 和 int (*)(const void*,const void*)

void qsort(void* base, //指向需要排序的数组的第一个元素
	       size_t num, //排序的元素个数
	       size_t size,//一个元素的大小，单位是字节
	       int (*compar)(const void*, const void*));//函数指针类型 - 这个函数指针指向的函数， 
                                                      能够比较base指向数组中的两个元素

该函数的功能是排序由base指向的num个元素，每个元素的大小是size个字节，使用compar指向的函数去比较。

了解了这些，我们就可以用qsort函数来实现排序。

我们可以先来测试一下qsort函数对整型数据的排序：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//比较函数
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
//打印函数
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
//测试排序整型数据
test1()
{
	int arr[10] = { 3,1,2,5,4,6,8,9,7,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr,sz);
}

int main()
{
	test1();
	return 0;
}

注意使用库函数qsort时要包含头文件<stdlib.h>

运行后排序结果是可行的。

我们来重点分析上述代码中的这段代码：

int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

这是我们写的比较函数，比较两个元素的大小，qsort的使用说明中规定它的参数类型必须是const void*型的，而且当p1<p2时，返回值<0；p1=p2时，返回值=0；p1>p2时，返回值>0。所以我们可以直接返回p1和p2所指向元素的差，但是注意直接对p1和p2解引用（即 *p1-*p2）是不对的，必须先强制类型转换为int*型，然后进行解引用相减（即 *(int*)p1 - *(int*)p2）。

为什么要强制类型转换呢？

因为指针变量p1和p2的类型都是 void*，而 void* 的指针是无具体类型的指针，不知道它解引用的大小是多少字节，所以这种类型的指针不能直接解引用，也不能进行指针运算。这次测试的是对整型数据的排序，所以强制类型转换为int*

void*的指针还可以接受任意类型的地址，

int main()
{
	int a = 10;
	float f = 3.14f;
	int* pa = &a;
	void* pv = &a;
	pv = &f;
	return 0;
}

这就是 void*的好处了，因为有时候我们也不知道别人要传给函数什么类型的参数，所以干脆写成void*型的，这样不管传过来什么类型的数据都可以被接收。

我们也可以来测试一下，qsort函数对结构体数据的排序：

先来排序结构体数据中的age：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

struct stu
{
	char name[10];
	int age;
};
//排序年龄
int cmp_age(const void* p1, const void* p2)
{
	return ((struct stu*)p1)->age - ((struct stu*)p2) -> age;
}

void test2()
{
	struct stu arr[] = { {"zhangsan",11},{"lisi",32},{"wangwu",20} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_age);
}
int main()
{
	test2();
	return 0;
}

通过监视窗口可以看到按年龄升序排序了：

还可以排序结构体数据中的name:

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

struct stu
{
	char name[10];
	int age;
};
//排序名字
int cmp_name(const void* p1, const void* p2)
{
	return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);
}
void test2()
{
	struct stu arr[] = { {"zhangsan",11},{"lisi",32},{"wangwu",20} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_name);
}
int main()
{
	/*test1();*/
	test2();
	return 0;
}

 通过监视窗口也可以看到按照名字首字母排序了：

注意，比较结构体数据name时，是两两字符串在比较，所以使用字符串比较函数strcmp，而且strcmp函数中，如果字符串1<字符串2，返回值<0；字符串1=字符串2，返回值=0；字符串1>字符串2，返回值>0。这刚好与我们期望的一样。所以我们把比较的结果直接返回即可。

上文讲了qsort函数的功能和具体使用，下面我们看能不能使用冒泡排序的思想模拟实现一个功能类似qsort的函数bubble_sort()。

在模拟实现之前，我们要解决三个问题：

问题1：冒泡排序法只能对整型数据进行排序，如何使其对其他类型的数据排序？

要解决问题1，我们可以仿照qsort函数，对bubble_sort传 void* 指针，同时传num、size，void*指针可以接收任意类型的指针，并且知道了元素个数和元素大小，我们就能知道需要排序从哪里开始，每次排多大的数据。

此时我们的bubble_sort函数声明应该是这样的：

void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
    ;
}

问题2：对于不同类型数据不能只是简单用大于号比较

要解决问题2，我们可以将两个元素的比较方法以函数参数的方式传递，即根据数据类型写出对应的比较函数，然后将比较函数的地址作为参数传给bubble_sort。因为我们也不知道要比较的两个数据类型，所以比较函数的参数类型最好写成 (const void*,const void*)

比较函数声明应该是这样的：

int cmp_int(const void* p1, const void* p2)
{
	;
}

问题3：不同的数据类型，交换略有差异

问题3如何解决，我们后面再讲。

而不论怎么比较，冒泡排序的比较趟数，和每一趟比较的次数都不会变，即：

void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
		for (i = 0; i < num - 1; i++)
		{
			int j = 0;
			//一趟内部比较的对数
			for (j = 0; j < num - 1 - i; j++)
			{
				//假设需要升序，则cmp_int返回值>0时交换
                ;
			}
		}
}

此时 if 判断语句的条件不能再写成 arr[j] > arr[j+1]，因为数据类型不一定是整型，不能简单的用大于号比较（问题3），这就要调用比较函数了，但该给比较函数传什么参数呢？

传给比较函数的两个参数应该是两个相邻元素的地址，所以我们只要确定 arr[j] 和 arr[j+1] 的地址即可，又因为将arr传给了base，所以base是起始地址，而base又是void*型，所以此时的arr[j]的地址是(*char)base + j*size，arr[j+1]的地址是(*char)base + (j+1)*size，size是元素的大小，每次跳转size个字节大小就到下一个元素了。

这里将base强制类型转换为char*型还是因为：要交换的两个元素类型不知道，只能一字节一字节的去交换。

此时bubble_sort函数应该是这样的：

void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
		for (i = 0; i < num - 1; i++)
		{
			int j = 0;
			//一趟内部比较的对数
			for (j = 0; j < num - 1 - i; j++)
			{
				//假设需要升序，则cmp_int返回值>0时交换
				if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
				{
					//交换函数
					swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
				}
			}
		}
}

交换函数：

void swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		int tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

交换函数中的for循环，一次循环交换一字节的数据，直到将两个大小为size字节的元素完全交换。

下面附上使用冒泡排序的思想模拟实现一个功能类似qsort的函数bubble_sort()的完整代码：

先来测试一下整型数据的交换：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
//交换函数
void swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		int tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
//比较函数
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
//模拟实现
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
		for (i = 0; i < num - 1; i++)
		{
			int j = 0;
			//一趟内部比较的对数
			for (j = 0; j < num - 1 - i; j++)
			{
				//假设需要升序，则cmp_int返回值>0时交换
				if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
				{
					//交换函数
					swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
				}
			}
		}
}
//打印函数
print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
void test1()
{
	int arr[10] = { 3,1,2,5,4,6,8,9,7,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr,sz);
}

int main()
{
	test1();
}

运行结果：

上述代码中函数的调用过程如下图：

我们也可以来测试一下结构体数据的交换：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
struct stu
{
	char name[10];
	int age;
};
//比较函数
int cmp_str(const void* p1, const void* p2)
{
	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}
//交换函数
swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		int tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void*, const void*))
{
	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 * size, (char*)base + (j + 1) * size)>0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
			}
		}
	}
}
 void test2()
{
	struct stu arr[] = { {"zhangsan",11},{"lisi",32},{"wangwu",20} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_str);
}

int main()
{
	test2();
	return 0;
}

运行结果：


 

这是模拟函数对结构体数据age的交换，大家可以试着自己写一下对结构体数据name的交换。

今天就学到这里，未完待续。。。 

成屿
关注
C语言进阶－第2讲C语言复习共25页.pdf.zip
11-22
【标签】"**C语言进阶－第2讲C语言复习共2**"可能是个误输入，正确的标签应该是"**C语言进阶－第2讲**"，强调了这是C语言进阶系列的第二部分。 【压缩包子文件的文件名称列表】提及的"**赚钱项目**"看起来与C语言...
C语言进阶-深度剖析.zip
10-15
在C语言进阶学习中，会深入探讨指针这一核心概念。指针是C语言的精髓，能够直接操作内存，实现高效的数据操作和算法实现。书中会详细讲解指针的类型、运算符、指针与数组的关系，以及指针在函数参数传递和动态内存...
Linux C语言进阶-D10指针数组
zhaojiazb的博客
11-02 130
指针变量构成的数组理解下面printf中的a和p的表示，其中p[0]、p[1]、p[2]表示存储的a,a+1和a+2这几个地址，而再加个*，相当于对地址解引用，从而得到数组中的值。如下图，要想得到a[0][1]的值可以直接打印a[0][1]，也可以打印*(a[0]+1)，而想用指针数组p来打印，由于p[0]表示的就是a[0]这个地址，所以就可以*(p[0]+1)
C语言--指针进阶2
m0_75233943的博客
02-27 1032
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
【C语言进阶】--- 指针详解 3.0
weixin_59005084的博客
05-31 2248
指针进阶版，超详细
C语言进阶-1.指针基础
weixin_47219891的博客
10-18 367
指针概念,这是大一留下的坑
C语言进阶-指针运算
小柚子的博客
12-27 533
【代码】C语言进阶-指针运算。
C语言蓝桥杯:语言基础
kkkkkkkok的博客
09-07 1731
、
Codeforces Round 969 (Div. 2) A-C
iwant_的博客
09-11 438
Codeforces Round 969 (Div. 2) A-C
详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
hw_happy的博客
09-13 369
但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为 TypeScript 和 Vue 的默认导出行为在某些情况下不完全一致，特别是在与一些工具链（如 Vite、Webpack）和 TypeScript 配置一起使用时。在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有export default ，在。如果你使用的是 Vite 或 Webpack，确保它们的配置能够正确处理 Vue 文件。
C语言双向链表
2301_79840227的博客
09-11 860
2。
C/C++ let __DATE__ format to “YYYY-MM-DD“
大道之行，始于足下
09-10 194
C/C++ : Let '__DATE__' format to "YYYY-MM-DD"
C语言---程序设计练习题目及学习方法1
Wanyu667的博客
09-06 691
学习方法 1.多练习 2.学会画图 3.学会调试
C/C++内存管理
m0_74402251的博客
09-11 1253
delete p2;// new/delete和malloc/free最大区别是new/delete对于自定义类型除了开空间，还会调用构造函数和析构函数free(p3);delete p4;//内置类型几乎是一样的free(p5);return 0;*/运行结果说明：new和delete调用了构造函数和析构函数。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 738
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
C和指针：高级指针话题
暮色年华的博客
09-09 510
进一步探讨指向指针的指针这些声明在内存中创建了下列变量。如果它们是自动变量，无法猜测它们的初始值。二级指针指向一级指针因为函数传参使用值传递不会修改原值，传递指针可以修改原变量，如只有传入一个链表节点的指针才可以进行链表的插入或删除操作。
【C语言】（指针系列3）数组指针+函数指针+typedef+函数数组指针+转移表
最新发布
wheeldown的博客
09-14 837
根据前面学习整型指针，数组指针的时候，类比一下，我们不难得出结论函数指针变量应该是用来存放函数地址的，未来通过地址能够调用函数的。那么函数是否有地址呢？函数的地址确实是有的，同时也验证了函数的地址也是可以用&调取出来的。同时我们观察发现，函数名和取出来的地址是一样的。
C语言——二分法搜索数组中特定元素并返回下标
qq_59990833的博客
09-14 158
分享一些二分法需要注意得细节
凌明老师讲解：嵌入式C语言进阶-存储器与指针解析
"凌明老师在东南大学集成电路中心的嵌入式高级C语言进阶课程的第四讲，主要探讨了存储器与指针的相关概念，包括指针的基础知识、存储器分类、动态内存分配以及相关的编程实践。" 本文将详细阐述存储器与指针在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

成屿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值