【C语言】指针进阶

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

  1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
  2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
  3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
  4. 指针的运算。

这篇博客我们将继续探讨指针的高级主题。

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* 。一般我们这样使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char ch = 'w';
	char* pc = &ch; //这里的pc就是字符指针
	return 0;
}

那么这里我再介绍另一种字符指针的写法，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* p = "abcdef";//这里的“abcdef”可以看作是一个表达式，其值是首字符的地址
	//因此这串代码的意思是把字符串首元素地址存放到指针p中
	return 0;
}

这跟我们之前讲过的另一种写法类似（其实本质上也有一些不同之处），就是将 “abcdef” 创建成一个数组，然后将数组的首元素地址存放到指针p中，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char arr[] = "abcdef";
	char* p = arr;//数组名是首元素地址，相当于将a的地址放入P中
	return 0;
}

通过对代码的分析来看，两者都是将a的地址存放到p中，但是我们先前也提到过本质上也是有不同的：

在这里插入图片描述

通过对字符串进行修改的过程中（将 *p = ‘w’），前者出现程序崩溃的情况，后者则可以正常修改字符串内容。因此，我们要避免在写代码过程存在出现对指针指向的常量字符串进行修改，所以应该在前者前加上 const ，限制了 *p ，p 指向的内容不能被修改，const 的作用就是在代码过程中出现修改常量字符串时警告程序员。代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	const char* p = "abcdef";
	return 0;
}

易错例子：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	//先初始化了两个数组，然后将 hello bit. 放入数组中
	//两个数组分别对应两块不同的内存空间
	//str1指的是数组str1[]首元素地址
	//str2指的是数组str2[]首元素地址
	//因此 str1 不等于 str2
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";
	//str3和str4都是指针，存放的是常量字符串"hello bit."
	//所指的都是同一块内存空间
	//因此 str3 等于 str4。
	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;
}

在这里插入图片描述
在这里插入图片描述

指针数组

字符数组：存放字符的数组，char arr1[10];

整型数组：存放整形的数组，int arr2[10];

指针数组：存放指针的数组。

  • 字符指针数组：存放字符指针的数组，char* arr3[10];
  • 整形指针数组：存放整形指针的数组，int* arr4[10];

字符指针数组的使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* arr[] = { "abcdef","higklmn","opqrst" };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s\n", arr[i]);
	}
	return 0;
}

在这里插入图片描述

整形指针数组的使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 6,7,8,9,10 };
	int arr3[] = { 11,12,13,14,15 };
	int* arr[] = { arr1,arr2,arr3 };
	//arr是一个存放整形指针的数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%2d ", *(arr[i] + j));
			//printf("%d ", *(arr[i] + j))也可写为printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在这里插入图片描述

数组指针

整形指针：指向整形的指针，int a = 10 ；int* pa = &a;

字符指针：指向字符的指针，char ch = ‘w’；char* pc =&ch;

数组指针：指向数组的指针。

  • 字符数组指针：指向字符数组的指针，char arr[10]；char (*pc)[10] = &arr；
  • 整形数组指针：指向整形数组的指针，int arr[10]；int (*pa)[10] = &arr；

数组指针的定义

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
//指针数组：本质是数组，是一种存放指针的数组。
//数组指针：本质是指针，是一种指向数组的指针，存放的是数组的地址
 
int main()
{
	//指针数组
	char* arr[5];
	//数组指针
	int arr[5] = { 0 };
	int(*p)[5] = &arr;
	return 0;
}

&数组名VS数组名

我们大家在学习C语言的过程中经常将 arr 和 &arr 傻傻分不太清楚，我们知道arr是数组名，数组名表示数组首元素的地址。那&arr数组名到底是啥，下面通过一段代码来揭开大家多年的疑问：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//数组名绝大部分情况下是首元素的地址
//但是有两个例外：
// 1.sizeof(数组名)：sizeof内部单独放一个数组名的时候，数组名表示的是整个数组，计算得到的是数组的总大小
// 2.&数组名：这里的数组名表示整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
 
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", arr + 1);
 
	printf("arr+1 = %p\n", &arr[0]);
	printf("&arr+1= %p\n", &arr[0] + 1);
 
	printf("arr+1 = %p\n", &arr);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

代码分析：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
 
	printf("arr = %p\n", arr);//arr表示首元素的地址，类型是 int* 类型
	printf("arr+1 = %p\n", arr + 1);//+1就跳过4个字节
 
	printf("&arr[0] = %p\n", &arr[0]);//&arr[0]表示首元素的地址，类型是 int* 类型
	printf("&arr[0]+1= %p\n", &arr[0] + 1);//+1就跳过4个字节
 
	printf("&arr = %p\n", &arr);//&arr表示一个数组的地址，将其存放到数组指针中去：int (*p)[10] = &arr;
	printf("&arr+1= %p\n", &arr + 1);//类型 int (*)[10]，所以+1跳过去的就是指向的整个数组的大小
	return 0;
}

在这里插入图片描述

简单总结一下：其实&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上 &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）代码中 &arr 的类型是 int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。

数组指针的使用

访问数组中的元素，不但可以使用下标来进行访问，而且还可以使用指针来进行访问，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
 
	//使用下标进行访问
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
 
	//使用指针来访问
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
 
	//使用数组指针来访问，可以用，但是不推荐，有些复杂
	int (*p)[10] = &arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *((*p) + i));
	}
	return 0;
}

我们知道一维数组传参是，形参既可以写成数组也可以写成指针，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
//一维数组传参，参数是数组
void print(int arr[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
 
//一维数组传参，参数是指针
void print(int （*arr）[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(（*arr） + i));//也可以写成 printf("%d ", arr[i]);
	}
	printf("\n");
}
 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	return 0;
}

通过一维数组的传参，而且有了数组指针的学习，二维数组除了将形参写为数组形式，其实也可以写为指针形式，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//二维数组传参，形参可写为二维数组
void print(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%2d ", arr[i][j]);
		}
		printf("\n");
	}
}
//二维数组传参，形参可写为数组指针
void print(int(*arr)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%2d ",*(*(arr+i)+j));    //*(arr+i)==arr[i]==&arr[i][j]
			//也可写为arr[i][j]
		}
		printf("\n");
	}
 
}
 
int main()
{
	int arr[3][5] = { 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 };
	//数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	print(arr, 3, 5);
	return 0;
}

在这里插入图片描述

数组参数、指针参数

一维数组传参

一维数组传参，形参可以是数组，也可以是指针，当形参是指针，要注意指针类型不要写错。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void test(int arr[]) //可以
{}
void test(int arr[10])  //可以
{}
void test(int* arr)  //可以
{}
void test2(int* arr[20])  //可以
{}
void test2(int** arr)  //可以
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

二维数组传参

二维数组传参，形参可以是数组，也可以是指针。当形参是数组，行可以省略，列不能省略。如果形参是指针，传过去的是第一行的地址，形参就应该是数组指针。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void test(int arr[3][5])  //可以
{}
void test(int arr[][])  //不可以
{}
void test(int arr[][5])  //可以
{}
void test(int* arr)  //不可以
{}
void test(int* arr[5])  //不可以
{}
void test(int(*arr)[5])  //可以
{}
void test(int** arr)  //不可以
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

一级指针传参

#define _CRT_SECURE_NO_WARNINGS
#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]);
	print(p, sz);
	return 0;
}

那么思考一下，当函数的参数为一级指针的时候，可以接收什么参数？

在这里插入图片描述

二级指针传参

#define _CRT_SECURE_NO_WARNINGS
#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;
}

那么思考一下，当函数的参数为二级指针的时候，可以接收什么参数？

在这里插入图片描述

函数指针

函数指针：指向函数的指针。 通过之前的学习我们知道数组指针中存放的是数组的地址，那么函数指针存放的是函数的地址吗？这里的答案是肯定的，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void test()
{
	printf("hello world\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}

在这里插入图片描述

我们可以观察到，函数指针确实可以得到函数的地址。C语言中 函数名和&函数名 都是函数地址。接下来，我将为大家说明函数地址怎样存起来，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = Add; //函数的地址要存起来，就得放在【函数指针变量】中去
    int ret = (*pf)(3,5); //使用指针进行函数调用
    //int ret = pf(3,5);
    //int ret = Add(3,5);
    //这三种写法都可以成功调用Add函数，其中第一种的*是一个摆设，写与不写都可以，写上是为了理解方便
    printf("%d\n",ret);
	return 0;
}

函数指针的写法说明示例：

在这里插入图片描述

下面来阅读两段有趣的代码：

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

想要真正阅读这个代码的意思，分为以下几步：

  1. 将0强制类型转化为void(*)()类型的函数指针
  2. 这就意味着0地址处放着一个函数，函数没有参数，返回类型是void。
  3. 调用0地址处的这个函数。
//代码2
void (*signal(int , void(*)(int)))(int);

代码二的括号内部是一个函数的声明，函数名字是signal，signal函数的第一个参数是 int 类型，第二个是 void(*)(int) 类型的函数指针，该函数指针指向的函数参数是 int ，函数返回类型为 void，signal 函数的返回类型也是一个函数指针。该函数指向的函数参数是 int ，返回类型为 void 。

这里给大家补充一个简化代码2的方法，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
typedef int* ptr_t;    //将 int* 重新命名为 ptr_t
typedef void(*pf_t)(int); //意思是将 void(*)(int) 重新命名为 pf_t，pf_t是类型
 
int main()
{
	void(* signal( int, void(*)(int) ) )(int);
	//化简后
	pf_t signal(int, pf_t);
	return 0;
}

这里要注意区分：typedef void(*pf_t)(int)中的 pf_t 是类型名；不写 typedef 时，void(*pf)(int) 中的pf是指针变量的名字。

函数指针数组

我们之前了解了指针数组中的整形指针数组，知道它是一个数组，每个元素都是 int* 类型的指针，通过类比，我们可以推断出函数指针数组的每个元素都是一个函数指针。举一个例子吧，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#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 (*pf[4])(int, int) = { Add,Sub,Mul,Div };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", pf[i](6, 4));
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述

函数指针数组应用实例

实现一个计算器，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
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 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 = 0;
	int y = 0;
	int input = 1;
	int ret = 0;
	//转移表
	int (*pfArr[])(int, int) = { NULL,Add,Sub,Mul,Div };
	           //对应菜单的选项：0     1   2   3   4
	int sz = sizeof(pfArr) / sizeof(pfArr[0]);
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器。");
		}
		else if (input < sz)
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			printf("%d\n", pfArr[input](x, y));
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

这个计算器的实例利用了函数指针数组的优势，避免使用switch case语句，从而大大缩减了代码纵长，但是使用前提是函数的返回类型，参数个数和参数类型必须一致。我们称这种函数指针数组为转移表。

指向函数指针数组的指针

在这里简单复习一下前面学习的内容，指针数组，数组指针，函数指针，函数指针数组，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
int my_strlen(const char* str)
{
	//……
	return 0;
}
 
int main()
{
	//指针数组
	int* arr[5] = { 0 };
 
	//数组指针
	int arr2[5] = { 0 };
	int (*p)[5] = &arr2;//p是一个指向数组的指针变量
 
	//函数指针
	int (*pf)(const char*) = my_strlen;//pf是一个指向函数的函数指针变量
	//如何调用函数：
	//写法一：（*pf)("abcdef")
	//写法二：my_strlen("abcdef") / pf("abcdef")
 
	//函数指针数组——存放函数指针的数组
	int(*pfArr[5]) = my_strlen;
 
	return 0;
}

其中要注意的是：由于函数名本质也是地址，因此不加&也是可以的。

指向函数指针数组的指针是一个指针，指针指向一个数组 ，数组的元素都是函数指针 ，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
int Add(int x, int y)
{
	return x + y;
}
 
int Sub(int x, int y)
{
	return x - y;
}
 
int main()
{
	//函数指针
	int (*pf)(int, int) = Add;
	//函数指针数组
	int (*pfArr[5])(int, int) = { Add,Sub };
	//指向函数指针数组的指针
	int (*(*ppfArr)[5])(int, int) = &pfArr;//ppfArr是一个指向函数指针数组的指针变量
	return 0;
}

回调函数

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

如果第一次没有看懂这句话的意思，没关系，我在这里就以上篇博客中的实现一个计算器的例子，使用回调函数来进行实现，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
void menu()
{
	printf("*************************\n");
	printf("****** 1:Add 2:Sub ******\n");
	printf("****** 3:Mul 4:Div ******\n");
	printf("*************************\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 x, y;
	int input = 1;
	int ret = 0;
	do
	{
		menu();
		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");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

我们发现 switch case 语句中有大量重复的代码，非常挫，那我们就可以将重复部分封装为一个函数，再将不一样的运算部分的函数进行传递给封装的函数就应该可以了，这个过程就被称为回调函数，代码优化示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
void menu()
{
	printf("*************************\n");
	printf("****** 1:Add 2:Sub ******\n");
	printf("****** 3:Mul 4:Div ******\n");
	printf("*************************\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;
}
 
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("ret = %d\n", ret);
}
int main()
{
	int input = 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;
}

qsort函数

qsort 是一个库函数(quicksort)，被用来排序的库函数，并且是使用快速排序的方法进行排序。qsort 底层用的是快速排序的算法，不是我们之前用过的冒泡排序。

qsort 函数的几个优点：

  • 是现成的，可以直接使用。
  • 可以排序任何类型的数据

qsort 函数的具体形式，代码示例如下：

void qsort(void* base, //指向待排序数组的第一个元素
	       size_t num, //待排序的元素个数
	       size_t size,//每个元素的大小，单位是字节
	       int(*cmp)(const void*, const void*) //指向一个函数，这个函数可以比较两个元素的大小
          )

利用 qsort 函数对元素进行排序，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
//qsort函数的使用者提供这个函数
int cmp_int(const void* p1, const void* p2)
{
	//排升序
	return *(int*)p1 - *(int*)p2;
	//排降序
	//return *(int*)p2 - *(int*)p1;
}
 
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
test1()
{
	int arr[] = {3,5,8,2,4,1,6,9,4,7,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//使用qsort函数来排序整形数组，这里就要提供一个比较函数，这个比较函数能够比较两个整数的大小
	//qsort函数默认排成升序，要想排成降序需要在比较函数那里做文章
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
 
int main()
{
	test1();
	return 0;
}

大家要注意的是，这里第一次使用 void* 的指针，就简单说明一下void* 的作用吧：

void* ：无具体类型的指针，它可以接受任何类型的地址，void*类型指针解引用时会出现非法寻址，正是因为它无具体类型，因此在进行解引用时到底是访问几个字节，这就是一个问题。在使用无具体类型指针的解引用时，通常进行强制类型转换后在对其进行解引用。

int main()
{
	int a = 10;
	int* p = &a;//ok
	char* p = &a;//err
	void* p = &a;//ok
	return 0;
}

通过对以上的例子的解读和说明，相信大家也对qsort函数的基本用法也有了一些了解，接下来我们一起再看看qsort函数是怎样排序结构体函数的。

按照年龄进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
 
test2()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
 
int main()
{
	test2();
	return 0;
}

调试结果如下：

在这里插入图片描述

按照名字进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name , ((struct Stu*)p2)->name);
}
 
test2()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
int main()
{
	test2();
	return 0;
}

调试结果如下：

在这里插入图片描述

模拟实现qsort（采用冒泡的方式）

qsort 底层是快速排序，但是因为还没有了解到快速排序的思想，因此这篇博客使用冒泡排序的思想来实现一个类似于 qsort 这个功能的冒泡排序函数 bubble_sort()。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
 
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
 
test3()
{
	int arr[] = { 3,5,8,2,4,1,6,9,4,7,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
 
int main()
{
	test3();
	return 0;
}

代码思路分析：

在这里插入图片描述
排序结构体：

1. 按照年龄进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
 
test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
 
int main()
{
	test4();
	return 0;
}

2. 按照名字进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
 
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
 
test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
int main()
{
	test4();
	return 0;
}

对模拟代码进行优化，加入flag：

void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int flag = 1;
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				flag = 0;
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

指针和数组笔试题解析

接下来带大家一起来练习一些容易让人凌乱的题目，通过这些题目来进一步加深和巩固对数组，指针，sizeof() 和 strlen() 使用的熟练度。话不多说，开始今天的内容：

简单复习一下数组和指针：

数组：能够存放一组相同类型的元素，数组的大小取决于数组的元素个数和元素类型。

指针：地址/指针变量，大小是4/8个字节。

数组是数组，指针是指针，二者是不等价的。但又存在一定的联系：

数组名是数组首元素的地址，这个地址就可以存放在指针变量中；因此我们就可以使用指针来遍历数组。

数组名：

大部分情况下数组名是数组首元素的地址，但是有两个例外：

  1. sizeof(数组名)：这里的数组名表示整个数组，计算的是整个数组的大小。
  2. &数组名：这里的数组名表示整个数组，取出的是整个数组的地址。

一维数组：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16
	//sizeof(数组名)，计算的是数组总大小，单位是字节
	printf("%d\n", sizeof(a + 0));//4/8
	//+0不可以被忽略，因此 a+0 表示的是数组首元素的地址
	printf("%d\n", sizeof(*a));//4
	//a 表示的是数组首元素的地址，相当于 &a[0]
	//*a == *&a[0] == a[0]
	printf("%d\n", sizeof(a + 1));//4/8
	//a 是数组首元素的地址，类型是 int*
	//a+1 就是跳过一个 int* ，是第二个元素的地址
	printf("%d\n", sizeof(a[1]));//4
	printf("%d\n", sizeof(&a));//4/8
	//&a 取出的是数组的地址，数组的地址也是地址，大小是4/8个字节
	// int (*pa)[4] = &a
	printf("%d\n", sizeof(*&a));//16
	//*&a == a，sizeof(a)计算的是数组总大小
	printf("%d\n", sizeof(&a + 1));//4/8
	//&a 取出的是整个数组的地址，类型是int (*)[4]
	//&a+1 就跳过整个数组，指向的是紧跟数组后的地址
	printf("%d\n", sizeof(&a[0]));//4/8
	//&a[0] 取出数组首元素的地址
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]+1 取出数组第二个元素的地址
	return 0;
}

字符数组：

必备知识清单：

  1. sizeof 计算的是占用内存空间的大小，单位是字节，不关注内存中到底存放的是什么。

  2. sizeof 不是函数，是操作符。

  3. strlen 是函数。

  4. strlen 针对字符串，求的是字符串的长度，本质上统计的是 \0 之前出现的字符个数。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6
	printf("%d\n", sizeof(arr + 0));//4/8
	//arr+0 是数组首元素的地址
	printf("%d\n", sizeof(*arr));//1
	//arr 数组首元素的地址，*arr 表示数组首元素 
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8
	//&arr 取出的是数组的地址
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr+1 跳过一个数组后的地址
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0] 数组首元素的地址，+1 数组第二个元素的地址
 
    printf("%d\n", strlen(arr));//随机值
	//arr 数组首元素地址
	printf("%d\n", strlen(arr + 0));//随机值
	//arr+0 数组首元素地址
	printf("%d\n", strlen(*arr));//非法访问
	//*arr 代表首元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(arr[1]));//非法访问
	//arr[1] 代表数组第二个元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(&arr));//随机值
	//&arr 数组的地址，传给strlen后从起始位置开始计算
	printf("%d\n", strlen(&arr + 1));//随机值-6
	//&arr+1 整个数组后的地址
	printf("%d\n", strlen(&arr[0] + 1));//随机值-1
	//&arr[0]+1 数组第二个元素的地址
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";// a,b,c,d,e,f,\0
	printf("%d\n", sizeof(arr));//7
	//sizeof(arr) 计算的是整个数组的大小
	printf("%d\n", sizeof(arr + 0));//4/8
	//arr+0 首元素的地址
	printf("%d\n", sizeof(*arr));//1
	//*arr 数组首元素
	printf("%d\n", sizeof(arr[1]));//1
	//arr[1] 数组第二个元素
	printf("%d\n", sizeof(&arr));//4/8
	//&arr 取出的是整个数组的地址
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr+1 整个数组后的地址
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0]+1 数组第二个元素的地址
 
 
	printf("%d\n", strlen(arr));//6
	//arr 首元素的地址
	printf("%d\n", strlen(arr + 0));//6
	//arr+0 首元素的地址
	printf("%d\n", strlen(*arr));//非法访问
	//*arr 代表首元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(arr[1]));//非法访问
	//arr[1] 代表数组第二个元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(&arr));//6
	//&arr 表示整个数组的地址，从起始位置开始计算
	printf("%d\n", strlen(&arr + 1));//随机值
	//&arr+1 数组后的地址
	printf("%d\n", strlen(&arr[0] + 1));//5
	//&arr[0]+1 数组第二个元素的地址
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main
{
    char* p = "abcdef";
	printf("%d\n", sizeof(p));//4/8
	//p 存放的是 字符串的起始地址，也就是a的地址
	printf("%d\n", sizeof(p + 1));//4/8
	//p 的类型是char*，+1就跳过一个char*，也就是说跳过一个字符的地址，相当于b的地址
	printf("%d\n", sizeof(*p));//1
	//*p 表示首字符
	printf("%d\n", sizeof(p[0]));//1
	//p[0]相当于*（p+0)，表示字符串首元素
	printf("%d\n", sizeof(&p));//4/8
	//&p 取出的是指针变量在内存中的地址
	printf("%d\n", sizeof(&p + 1));//4/8
	//&p+1 跳过p的地址，但还是一个地址
	printf("%d\n", sizeof(&p[0] + 1));//4/8
	//&p[0]+1 得到a的地址，再跳过去，得到的就是b的地址
 
 
	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));//随机值
	printf("%d\n", strlen(&p[0] + 1));//5
    
    return 0;
}

二维数组：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48
	//二维数组的数组名a单独放在sizeof内部,计算的是整个数组的大小
	printf("%d\n", sizeof(a[0][0]));//4
	//a[0][0] 第一行第一个元素
	printf("%d\n", sizeof(a[0]));//16
	//a[0] 第一行的数组名，数组名单独放在sizeof内部，计算的是第一行数组的大小
	printf("%d\n", sizeof(a[0] + 1));//4/8
	//a[0]+1 第一行第一个元素的地址，得到的是第一行第二个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4
	//*(a[0]+1) 第一行第二个元素a[0][1]
	printf("%d\n", sizeof(a + 1));//4/8
	//a+1 跳过数组第一行，指向下一行起始的地址
	printf("%d\n", sizeof(*(a + 1)));//16
	//*(a+1) 第二行的元素
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]+1 去除第一行地址，+1跳过后指向第二行起始地址
	printf("%d\n", sizeof(*(&a[0] + 1)));//16
	//*(&a[0]+1) 第二行的元素
	printf("%d\n", sizeof(*a));//16
	//*a 第一行的元素
	printf("%d\n", sizeof(a[3]));//16
	//由于sizeof内部的表达式是不会真正计算的，因此sizeof是通过括号内的类型来推断结果是多少
	return 0;
}

指针笔试题

笔试题1：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
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：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
    p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

在这里插入图片描述

笔试题3：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
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：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	//                 1       3       5
	//逗号表达式的结果是最后一个表达式的结果
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

在这里插入图片描述

笔试题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;
}

在这里插入图片描述
在这里插入图片描述

笔试题6：

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

在这里插入图片描述

笔试题7：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

在这里插入图片描述

笔试题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;
}

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

如何使用Imagewheel搭建一个简单的的私人图床无公网ip也能访问

如何使用Imagewheel搭建一个简单的的私人图床无公网ip也能访问

文章目录 1.前言2. Imagewheel网站搭建2.1. Imagewheel下载和安装2.2. Imagewheel网页测试2.3.cpolar的安装和注册 3.本地网页发布3.1.Cpolar临时数据隧道3.2.Cpolar稳定隧道&#xff08;云端设置&#xff09;3.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 4.公网访问测…
阅读更多...
每日一题——LeetCode1200.最小绝对差

每日一题——LeetCode1200.最小绝对差

方法一 个人方法 排序一次遍历&#xff1a; 最小差值一定是出现在大小相邻的两个元素之间&#xff0c;所以将数组从小到大排序 循环求两元素之间的差值&#xff0c;先假设当前差值为最小差值&#xff0c;先往res数组里面push数据&#xff0c;当碰到更小差值的时候&#xff0c…
阅读更多...
Vue-Router 路径匹配与重定向

Vue-Router 路径匹配与重定向

一、效果与描述 通过设置路由匹配同时设置重定向&#xff0c;让输错的网址重定向到指定页面&#xff0c;例如在网页输入网页地址把路径进行任意修改&#xff0c;重定向到登录页面。 二、Vue-Router代码 import { createRouter, createWebHashHistory } from vue-routerimport …
阅读更多...
PyCharm安装插件后重启报错：java.lang.RuntimeException

PyCharm安装插件后重启报错：java.lang.RuntimeException

一、问题描述 某次Pycharm 安装Sourcegraph Cody插件后&#xff0c;重启报错:java.lang.RuntimeException: com.intellij.ide.plugins.PluginManager$StartupAbortedException: Fatal error initializing ‘com.intellij.openapi.actionSystem.ActionManager’ &#xff0c;现…
阅读更多...
Unity中URP下 SimpleLit框架

Unity中URP下 SimpleLit框架

文章目录 前言一、整体框架1、该Shader是用于低端设备的2、包含一个Properties3、只有一个SubShader4、如果SubShader错误&#xff0c;返回洋葱紫5、调用自定义ShaderGUI面板 二、SubShader中1、Tags2、Pass 三、我们看一下ForwardLit的Pass1、混合模式、深度写入、面皮剔除、透…
阅读更多...
Python教程44：海龟画图turtle画卡塔尔世界杯吉祥物

Python教程44：海龟画图turtle画卡塔尔世界杯吉祥物

---------------turtle源码集合--------------- Python教程42&#xff1a;海龟画图turtle画海绵宝宝 Python教程41&#xff1a;海龟画图turtle画蜡笔小新 Python教程40&#xff1a;使用turtle画一只杰瑞 Python教程39&#xff1a;使用turtle画美国队长盾牌 Python教程38&a…
阅读更多...
庆祝安科瑞企业微电网智慧能源管理系统生态交流会圆满举办-安科瑞 蒋静

庆祝安科瑞企业微电网智慧能源管理系统生态交流会圆满举办-安科瑞 蒋静

2024年1月12日&#xff0c;安科瑞企业微电网智慧能源管理系统生态交流会顺利举行&#xff0c;本次会议旨在围绕双碳目标&#xff0c;共同探讨如何抓住新机遇、新市场&#xff0c;充分利用安科瑞企业微电网智慧能源的一站式服务&#xff0c;为企业节能、减碳、降本赋能&#xff…
阅读更多...
深入类加载机制及底层

深入类加载机制及底层

深入类加载机制 初识类加载过程 使用某个类时&#xff0c;如果该类的class文件没有加载到内存时&#xff0c;则系统会通过以下三个步骤来对该类进行初始化 1.类的加载&#xff08;Load&#xff09; → 2.类的连接&#xff08;Link&#xff09; → 3.类的初始化&#xff08;In…
阅读更多...
element upload 自定义上传 报错Cannot set properties of null (setting ‘status‘)

element upload 自定义上传 报错Cannot set properties of null (setting ‘status‘)

element upload 自定义上传 报错Cannot set properties of null (setting ‘status’) 问题展示 原因分析 自定义上传方式 fileList 显示一切正常&#xff0c;状态也是成功 文件url通过URL.createObjectURL(file.raw) 进行添加 以下为配置代码 <el-uploadclass"uplo…
阅读更多...
Nginx初体验

Nginx初体验

文章目录 定义正向代理 & 反向代理安装与尝试 之前没怎么用过代理服务器Nginx&#xff0c;主要也是因为没有架构知识&#xff0c;根本不会去部署相关的机器。但是最近公司内部在调试的时候&#xff0c;经常用本机去充当Ngnix代理服务器&#xff0c;由于对这块知识掌握得还不…
阅读更多...
Linux网络通信

Linux网络通信

网络模型 七层模型 四层模型 TCP : 面向连接&#xff0c;可靠的&#xff0c;面向字节流&#xff0c;支持点对点通信。 UDP : 无连接&#xff0c;不可靠&#xff0c;面向数据报文&#xff0c;支持一对一&#xff0c;一对多&#xff0c;多对多。通信原理 常用函数 #include <…
阅读更多...
深入理解 go reflect - 要不要传指针

深入理解 go reflect - 要不要传指针

在我们看一些使用反射的代码的时候&#xff0c;会发现&#xff0c;reflect.ValueOf 或 reflect.TypeOf 的参数有些地方使用的是指针参数&#xff0c;有些地方又不是指针参数&#xff0c; 但是好像这两者在使用上没什么区别&#xff0c;比如下面这样&#xff1a; var a 1 v1 :…
阅读更多...
学习笔记-数据库概念介绍

学习笔记-数据库概念介绍

一.数据库概述 1.数据库: 存储数据的仓库,本质是一个文件系统. 用户可以对数据库中的数据进行 增加,修改,删除以及查询操作 2.特点 可以结构化存储大量的数据可以有效的保持数据的一致性,完整性读写效率高 3.常用数据库 二.数据库分类及其常用 关系型数据库 指的是二维表格…
阅读更多...
肯尼斯·里科《C和指针》第6章 指针（5）概念的练习

肯尼斯·里科《C和指针》第6章 指针（5）概念的练习

肯尼斯里科《C和指针》第6章 指针&#xff08;1&#xff09;-CSDN博客 肯尼斯里科《C和指针》第6章 指针&#xff08;2&#xff09;-CSDN博客 肯尼斯里科《C和指针》第6章 指针&#xff08;3&#xff09;-CSDN博客 肯尼斯里科《C和指针》第6章 指针&#xff08;4&#xff09…
阅读更多...
领域驱动设计解决汉诺塔问题-文风批评（1）

领域驱动设计解决汉诺塔问题-文风批评（1）

DDD领域驱动设计批评文集 做强化自测题获得“软件方法建模师”称号 《软件方法》各章合集 以下文章内容纯属虚构&#xff0c;用来批评某些领域驱动设计文风。后续将挑一些近期的文章作为例子来批评。 ********** 领域驱动设计是革命性的创新&#xff0c;是划时代的洞见。领…
阅读更多...
DaisyDisk for mac 中文激活版 可视化磁盘清理工具

DaisyDisk for mac 中文激活版 可视化磁盘清理工具

DaisyDisk 是一款专为 Mac 设计的磁盘空间分析工具。它以直观、图形化的方式展示硬盘使用情况&#xff0c;帮助用户迅速找到占用空间大的文件和文件夹。通过扫描磁盘&#xff0c;DaisyDisk 生成彩色的扇形图表&#xff0c;每个扇区代表一个文件或文件夹&#xff0c;大小直观反映…
阅读更多...
构建基于RHEL9系列(CentOS9,AlmaLinux9,RockyLinux9等)的支持63个常见模块的PHP8.1.20的RPM包

构建基于RHEL9系列(CentOS9,AlmaLinux9,RockyLinux9等)的支持63个常见模块的PHP8.1.20的RPM包

本文适用&#xff1a;rhel9系列&#xff0c;或同类系统(CentOS9,AlmaLinux9,RockyLinux9等) 文档形成时期&#xff1a;2023年 因系统版本不同&#xff0c;构建部署应略有差异&#xff0c;但本文未做细分&#xff0c;对稍有经验者应不存在明显障碍。 因软件世界之复杂和个人能力…
阅读更多...
Python 两种多值参数

Python 两种多值参数

有时可能需要一个函数中处理的参数的个数是不确定的&#xff0c;就需要使用多值参数 参数名前加上*&#xff0c;代表可以接收元组参数名前加上**&#xff0c;代表可以接收字典 代码&#xff1a; def demo(*args, **kwargs):print(args)print(kwargs)demo(1, 2, 3, 4, 5, nam…
阅读更多...
采样次数与频率的关系

采样次数与频率的关系

采样次数&#xff08;Sampling Points&#xff09; 在给定时间内记录信号值的次数。 假设在1秒内对一个连续信号采样10次&#xff0c;这意味着每0.1秒记录一次信号值。 假设在1秒内对一个连续信号采样100次&#xff0c;这意味着每0.01秒记录一次信号值。 频率&#xff08;Fre…
阅读更多...
【昕宝爸爸小模块】守护线程、普通线程、两者之间的区别

【昕宝爸爸小模块】守护线程、普通线程、两者之间的区别

➡️博客首页 https://blog.csdn.net/Java_Yangxiaoyuan 欢迎优秀的你&#x1f44d;点赞、&#x1f5c2;️收藏、加❤️关注哦。 本文章CSDN首发&#xff0c;欢迎转载&#xff0c;要注明出处哦&#xff01; 先感谢优秀的你能认真的看完本文&…
阅读更多...
最新文章

Copyright @ 2022~2023