庖丁解牛 指针的高端操作

news2024/11/10 13:01:10

本章重点

写在前面

1.字符指针

2.指针数组

3.数组指针

3.1数组指针的定义

3.2 &数组名VS数组名

         3.3 数组指针的使用

二维数组与数组指针

4.数组参数和指指针参数

4.1一维数组传参

4.2 二维数组传参

4.3一级指针传参

4.4二级指针传参

5.函数指针

5.1函数指针的定义

6.函数指针数组

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

8.回调函数

附:


写在前面

在初阶c语言之浅识指针中,我已经详细地介绍了指针的概念:

1. 指针就是个变量,用来存放地址,地址唯一标识一块内存空间。
2. 指针的大小是固定的 4/8 个字节( 32 位平台 /64 位平台)。
3. 指针是有类型,指针的类型决定了指针的 +- 整数的步长,指针解引用操作的时候的权限。
4. 指针的运算。
接下来我们就进入指针的高阶主题继续深入的了解指针。

1.字符指针


在指针的类型中我们知道还有一种指针类型为字符指针char*
简单的使用:
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	return 0;
}

还有一种使用方式如下:

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

代码const char* pstr = "hello world";特别容易让同学以为是把字符串 hello world放到字符指针 pstr

里了,但是本质是把字符串 hello world首字符的地址放到了pstr中

上面代码的意思是把一个常量字符串的首字符 h 的地址(0x0012ff44)存放到指针变量 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.指针数组


在初阶c语言之浅识指针中,我们已经学习过指针数组。这里简单回忆一下:

int* arr1[10]; //整型指针的数组
//描述:
//arr1数组有10个元素,且每个元素都为int*类型

char* arr2[4]; //一级字符指针的数组
//描述:
//arr2数组有4个元素,且每个元素都为char*类型

char** arr3[5];//二级字符指针的数组
//描述:
//arr3数组有5个元素,且每个元素都为char**类型

3.数组指针


3.1数组指针的定义

数组指针是指针?还是数组?
答案是:指针。
我们已经熟悉:
整形指针: int * pint ; 能够指向整形数据的指针。
浮点型指针: float * pf ; 能够指向浮点型数据的指针。
那数组指针应该是:能够指向数组的指针。
那么下面代码哪个是数组指针?
int* p1[10];
int(*p2)[10];
//p1, p2分别是什么?

答案是下面的代码。那么我来解释一下为什么数组指针长这个样子:

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

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;
	int j = 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;
	int j = 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,其实相当于第一行的地址,是一维数组的地址
	//可以数组指针来接收
	printf("-----------------\n");
	print_arr2(arr, 3, 5);
	return 0;
}

二维数组与数组指针

这里有非常重要的一点,我们已经知道数组名就是数组首元素的地址(有两个例外),那么对于二

维数组来说,二维数组的首元素是什么呢?其实就是第一行数组。

如图所示,我们给arr+1之后,它的地址跳过了一个一维数组的大小。所以我们可以通俗的把二维

数组arr理解为,arr数组包含3个元素,每个元素都是元素个数为5、元素类型为int类型的数组。

我们甚至可以换一种方式来定义二维数组:

int arr1[5]={1,2,3,4,5};
int arr2[5]={6,7,8,9,10};
int arr3[5]={0};
int  (  *  (arr[3])  )  [5] = { arr1,arr2,arr3 };

定义太复杂看不懂?

没关系我们细致分解:

arr[3]//首先arr是一个数组,且包含3个元素,所以先和[3]结合

int (*) [5]//这是一个数组指针的类型,表明该指针指向一个数组
//且数组包含5个元素,每个元素是int类型

int (*(arr[3]))[5] //表明arr数组包含3个元素,且每个元素的类型都是数组指针

接下来,我们尝试认识并解释下面代码:

//整型数组:
int arr[5];
//arr是一个数组,包含5个元素,且每个元素的类型是int

//指针数组:
int *parr1[10];
//parr1是一个数组,包含10个元素,且每个元素的类型是int*

//数组指针:
int (*parr2)[10];
//parr2是一个指针,指向的是一个数组,数组包含10个元素,且每个元素的类型是int

//数组指针数组
int (*parr3[10])[5];
//parr3是一个数组,包含10个元素,且每个元素的类型是数组指针
//数组指针指向的是一个数组,包含5个元素,且每个元素的类型是int

4.数组参数和指指针参数


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

4.1一维数组传参

如果我们要将如下两个数组作为参数传递给test函数

#include<stdio.h>

void test1()//参数该如何设计?

void test2()//参数该如何设立?

int main()
{
	int arr1[10] = { 0 };
	int* arr2[20] = { 0 };
	test1(arr1);
	test2(arr2);
}

下面展示的几种设计方式都是正确的:

void test(int arr[])//可以省略10
{}
void test(int arr[10])
{}
void test(int* arr)
{}
void test2(int* arr[20])
{}
void test2(int** arr)
{}

有的小伙伴可能不明白为何可以用指针作为参数来接收一维数组。

是因为,我们调用test函数时,都将数组名传递过去,而数组名又是首地址,当然可以用一个指针

变量来接收。

对于arr1,是一个整型数组,元素类型为int ,所以用int*的指针来接收;

对于arr2,是一个指针数组,元素类型为int* ,所以用int**的二级指针来接收。

4.2 二维数组传参

#include<stdio.h>
int main()
{
    int arr[3][5] = {0};
    test(arr);
    return 0;
}

如果我们要将二维数组arr传递给test函数,那么test函数又该如何如何设计呢?

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(*arr)[5] 或是 二级指针来接收。

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

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

5.函数指针


之前学到,&+变量名可以得到变量的地址,&+数组名可以取出数组的地址(其实是数组首元素的地址)。那么当我们第一次听到函数指针这个概念时,有没有首先想到函数也会有地址吗?怎么得到函数的地址?难道&+函数名就可以得到函数的地址吗?

其实还真是,看以下操作:

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

结果如下:

我们发现,不仅&+函数名可以得到函数的地址,就连函数名本身也是函数的地址。

既然得到了函数的地址,我们如何将函数的地址保存起来呢?

这就要用到函数指针了。

5.1函数指针的定义

下面我们看代码:

void test()
{
	printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址?
void (*pfun1)();
void* pfun2();
首先,能给存储地址,就要求 pfun1 或者 pfun2 是指针,那哪个是指针?
答案是:
pfun1可以存放。pfun1先和*结合,说明pfun1是指针,指针指向的是一个函数,指向的函数无参
数,返回值类型为void
下面我们多练习如何认识函数指针:
int (*pfun3)(int a, int b);

//pfun3先和*结合,说明pfun3是一个指针,指向一个函数,

//函数有两个参数,参数的类型都是int,函数的返回值是int类型

char* (*pfun4)(int* pa, int* (*parr)[10]);

//pfun4先和*结合,说明pfun4是一个指针,指向一个函数,

//函数有两个参数,参数的类型一个是int*,一个是数组指针,函数的返回值是char*类型

6.函数指针数组


首先提问,函数指针数组是一个指针还是数组?答案是是一个数组

数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,
比如:
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中,那这个数组就叫函数指针数组,那函数指针的数组如何定义
呢?
//首先,函数指针数组是数组

parr[];

//数组的每个元素是函数指针,以无参函数,且无返回值的函数为例

void (*) ();

//结合后

void (*) () parr[];

//规范的写法

void (*parr[])()

再多举几个例子吧:

int (*parr1[5]) (int a,int b);

char (*parr2[10]) (int* a,int* b);

double (*parr3[10]) (double a.double* b);

int* (*parr4[10]) (int (*pfun) (int a,int b).int* a);

//....

函数指针数组有什么用途呢?

例如,我们现在要实现一个计算器,包含加减乘除四种功能。我们可以将这四种功能分别用四个函

数来实现。然后将四个函数对应的函数指针保存到一个函数指针数组里。当我们运行计算器的程序

时,可以根据选择不同功能的选项,来找到函数指针数组不同下标所对应的不同函数,进行运算。

由于代码太长,将计算器的代码实现放在文章末尾。

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


首先,指向函数指针数组的指针是一个指针。

指针指向一个数组,数组的每个元素都是函数指针。
那么该如何定义一个指向函数指针数组的指针呢?
#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;
}

如果给我们一个指向函数数组的指针,我们不会辨别怎么办?

没关系,我们逐步来分解:

//指向函数指针数组pfunArr的指针ppfunArr

void (*(*ppfunArr)[5])(const char*) = &pfunArr;

//首先我们看到*与ppfunArr结合

//所以ppfunArr是一个指针,我们将*ppfunArr记作a

void (*a[])(const char*)

//现在我们看到,a与[]先结合
//说明指针a指向的是一个数组
//接下来将a[]移除

void (*) (const char*)

//剩下的部分我们已经学过,是一个函数指针
//说明数组的元素类型是函数指针

//总结,ppfunArr是一个指针,指向一个数组,数组的每个元素都是函数指针
//所以,ppfunArr称为指向函数指针数组的指针

8.回调函数


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

附:

计算器一般实现:
#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");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

计算器函数指针数组的实现:

#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;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*************************\n");
		printf(" 1:add	      2:sub \n");
		printf(" 3:mul		  4:div \n");
		printf("*************************\n");
		printf("请选择:");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数:");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

本章完!

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

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

相关文章

SSM基于小程序的医院预约挂号系统 毕业设计-附源码260839

SSM医院预约挂号小程序的设计与实现 摘 要 信息化社会内需要与之针对性的信息获取途径&#xff0c;但是途径的扩展基本上为人们所努力的方向&#xff0c;由于站在的角度存在偏差&#xff0c;人们经常能够获得不同类型信息&#xff0c;这也是技术最为难以攻克的课题。针对医院排…

Prometheus系列(2)之EC2安装Node端

目标 为Prometheus安装Node程序。 步骤 node exporter程序 wget https://github.com/prometheus/node_exporter/releases/download/v1.4.0/node_exporter-1.4.0.linux-amd64.tar.gz tar xvzf node_exporter-1.4.0.linux-amd64.tar.gz cd node_exporter-1.4.0.linux-amd64/s…

技术分享 | 专项测试技术初识Hook

本文节选自霍格沃兹测试学院内部教材Hook 技术需要预先分析目标应用的源代码和逻辑&#xff0c;根据目标测试场景设置目标、逻辑和数据&#xff0c;然后运行时动态的对目标函数参数值、逻辑或者返回值做修改&#xff0c;达到修改现有函数逻辑、实现目标测试场景的目的。 Hook的…

汇编语言指令

文章目录算术运算指令ADDADDISUB伪指令LUILIAUIPCLA逻辑运算指令内存读写指令条件分支指令无条件跳转指令算术运算指令 ADD 语法ADD RD&#xff0c;RS1,RS2例子add x5,x6,x7x5x6x7编码格式&#xff1a;R-type opcode(7):0110011(OP) 从RS里面取出数据&#xff0c;把里面的数据…

【MyBatis框架】关联映射

关系映射1. 关联映射概述2. 环境搭建3.处理字段名和属性名不一致的情况4. 处理一对一映射5. 处理多对一映射5.1 级联方式处理5.2 使用association处理映射关系5.3 分步查询6. 处理一对多查询7. 小结1. 关联映射概述 在关系型数据库中&#xff0c;多表之间存在着三种关联关系&a…

Linux文件打包及压缩、解包及解压

目录 前言 什么是压缩&#xff1f; tar的介绍与使用 简介 打包压缩文件 打包文件&#xff08;不压缩&#xff09; gzip压缩类型压缩文件 bzip压缩类型压缩文件 xzip压缩类型压缩文件 解包解压文件 简介 解压缩&#xff08;解压到当前目录&#xff09; 解压缩&#x…

线代 | 【提神醒脑】自用笔记串联

一、初等变换 1、初等行变换与方程组的同解变换 2、初等行变换关系网 ※ 3、关联结论 —— 同解方程 4、行、列变换适用场景

Java 线程池之ThreadPoolExecutor学习总结

前提 java version "1.8.0_25" 池简述 软件开发活动中&#xff0c;我们经常会听到数据库连接池、内存池、线程池等各种“池”概念&#xff0c;这些“池”到底是什么东西呢&#xff1f;程序的世界里&#xff0c;我们可以将池简单的理解为一种容器类数据结构&#x…

哪本计算机书籍,让你有了醍醐灌顶突然开悟的感觉?

计算机书籍每年都会出版很多&#xff0c;但是能影响几代程序员的有这几本书&#xff0c;推荐一下&#xff0c;肯定让你有醍醐灌顶的开悟的感觉。 1、重构 改善既有代码的设计&#xff08;第2版 平装版&#xff09; 豆瓣评分&#xff1a;9.2 本书是一本为专业程序员编写的重构指…

30岁本科男,在测试行业干了五年还只会功能测试,难道真的要去送外卖吗?

在网上看到一个帖子 从发帖内容可以看出&#xff0c;题主是一位拥有五年功能测试经验的IT从业者&#xff0c;他也深知功能测试现在的处境艰难&#xff0c;想改变&#xff0c;却又因为年龄和经济压力的原因迟迟不敢迈出第一步&#xff0c;其实这是很多年近30岁的人事业危机的缩影…

【Java】之File类

个人主页&#xff1a;天寒雨落的博客_CSDN博客-C,CSDN竞赛,python领域博主 特别标注&#xff1a;仅为自己的学习记录笔记&#xff0c;方便复习和加深记忆&#xff0c;仅供借鉴参考&#xff01; 前篇回顾&#xff1a;【java】之File类_天寒雨落的博客-CSDN博客 目录 目录的遍历…

五 系统安全分析与设计

目录 一、安全基础技术 1.1 对称与非对称加密 1.2 数字签名&#xff08;防抵赖&#xff09; 1.3 信息摘要&#xff08;防篡改&#xff09; 1.4 加密、数字签名、信息摘要结合使用 1.5 数字证书&#xff08;防止公钥被截取篡改&#xff09; 二、网络安全 2.1 安全协议 …

Android LayerDrawable 使用

1. 前言 Android LayerDrawble 包含一个Drawable数组&#xff0c;系统将会按照这些Drawable对象的数组顺序来绘制他们&#xff0c;索引最大的 Drawable 对象将会被绘制在最上面。 LayerDrawable对象的xml文件的根元素是<layer-list>&#xff0c; 该元素内部包含多个<i…

【Linux】开发工具之gdb调试器

目录&#x1f308;前言&#x1f337;1、debug与release&#x1f338;2、gdb选项&#x1f308;前言 本篇文章进行调试器gdb的学习&#xff01;&#xff01;&#xff01; &#x1f337;1、debug与release debug会生成需要调试的信息&#xff0c;release不会生成 程序的发布方式有…

【Node.js】模块的加载机制

✍️ 作者简介: 前端新手学习中。 &#x1f482; 作者主页: 作者主页查看更多前端教学 &#x1f393; 专栏分享&#xff1a;css重难点教学 Node.js教学 从头开始学习 目录 模块的加载机制 优先从缓存中加载 内置模块的加载机制 自定义模块的加载机制 第三方模块的加载机…

2022年浙江省中职组“网络空间安全”赛项模块B--Linux系统渗透提权

2022年中职组浙江省“网络空间安全”赛项 B-3:Linux系统渗透提权一、竞赛时间 420分钟 共计7小时 吃饭一小时 二、竞赛阶段 竞赛阶段 任务阶段 竞赛任务 竞赛时间 分值 第①阶段: 单兵模式系统渗透测试 任务一: Windows操作系统渗透测试 任务二: Linux操作系统渗透测试 任务…

经典算法|水仙花数|自幂数

算法题目 水仙花数&#xff08;Narcissistic number&#xff09;也被称为超完全数字不变数&#xff08;pluperfect digital invariant, PPDI&#xff09;、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数&#xff08;Armstrong number&#xff09;&#xff0c;水仙花数是指一个 3 位…

高精度RC振荡器的设计

1. 一些技术指标 应用于数字模拟混合信号芯片的高频率精度&#xff0c;高频率稳定度&#xff0c;全集成RC振荡器设计 由于数字电路指标仅与复杂度有关&#xff0c;此仅考虑模拟电路的设计指标。 项目Value电源电压2.5V~5.5V工作温度-40~125目标频率Ftyp 2MHZ频率精度&#x…

常用流媒体服务器

1、Mediasoup mediasoup是相对比较新的一个WebRTC服务器端的开源项目。它更多是通过集成包方式和其他应用服务器来集成。它支持SFU模式&#xff0c;主要支持视频聊天&#xff0c;媒体流广播等。 其特点是&#xff1a; 通过底层API实现和第三方集成&#xff0c;安装简单&#…

java自学第一天

1.1.体系&#xff1a; JavaSE&#xff08;J2SE&#xff09;&#xff08;Java2 Platform Standard Edition&#xff0c;java平台标准版&#xff09; JavaEE(J2EE)(Java 2 Platform,Enterprise Edition&#xff0c;java平台企业版) JavaME(J2ME)(Java 2 Platform Micro Edition&a…