C/C++多级指针与多维数组

news2024/10/5 21:16:02

使用指针访问数组

指针类型的加减运算可以使指针内保存的首地址移动。
指针类型加n后。首地址向后移动 n * 步长 字节。
指针类型减n后。首地址向前移动 n * 步长 字节。
步长为指针所指向的类型所占空间大小。
例如：

int *p = (int *)100;
  • p + 1，结果为首地址向后移动sizeof(int)字节，即104。
  • p - 1，结果为首地址向前移动sizeof(int)字节，即96。

因此，指针加减运算对于访问在内存中连续排布的数据对象非常方便。
而数组这种数据对象，每个元素在内存中一定是连续排布的。下面，我们来探究怎样使用指针访问数组。

使用第一个元素获取数组首地址

既然数组元素在内存中的存储可以保证是连续的，那么第一个元素的首地址，就是整个数组的首地址。

#include <stdio.h>
int main()
{
	int arr[5] = { 111, 222, 333, 444, 555 };
	int* p = &arr[0];
	printf("%d\n", *p); // 第1个元素
	printf("%d\n", *(p + 1)); // 第2个元素
	printf("%d\n", *(p + 2)); // 第3个元素
	printf("%d\n", *(p + 3)); // 第4个元素
	printf("%d\n", *(p + 4)); // 第5个元素
	return 0;
}

我们可以使用取地址运算符&，获取第一个元素的首地址和空间大小，即获取一个 int * 类型的指针。
通过取值运算符*，可以使用指针中的首地址和空间大小访问或修改目标数据对象。

表达式 p + 1 必须先被括号包裹，再使用取值运算符*。

这是因为取值运算符*的优先级高于算术运算符。
我们需要先让首地址移动，再进行取值操作。
若不使用括号，*p会先被取值，之后值再被加1。

  • 不使用括号：
    • *p的值为111，*p + 1的结果为112。
  • 使用括号：
    • (p + 1) 使得首地址移动到第二个元素， *(p + 1) 得到结果为222。

使用数组名获取数组首地址

#include <stdio.h>
int main()
{
	int arr[5] = { 111, 222, 333, 444, 555 };
	int* p = arr;
	printf("sizeof arr = %d\n", sizeof(arr));
	printf("sizeof p = %d\n", sizeof(p));
	printf("sizeof arr + 1 = %d\n", sizeof(arr + 1));
	return 0;
}

使用32位进行编译

sizeof arr = 20
sizeof p = 4
sizeof arr + 1 = 4

arr 的大小为20。
p 的大小为4。
arr + 1 的大小为4。
p 是一个指针大小为4是理所当然的。
但是 arr 的大小为20，那么arr应该不是一个指针类型才对，但是它却又可以成功赋值给 int * 。
而 arr + 1 的大小却又为4。

类型为“以T为元素的数组arr”与“指向T的指针p”的关系。

当数组名arr出现在一个表达式当中，数组名arr将会被转换为指向数组第一个元素的指针。但是，这个规则有两个例外：

  • 对数组名arr使用sizeof时。
  • 对数组名arr使用&时。

也就是说，数组名arr的类型其实是 int [5] ，因此 sizeof(arr) 的结果才会是20。
数组名arr出现在表达式int* p = arr中，会被转换为指向数组第一个元素的指针，即 int [5] 转为 int * 类型。之后进行赋值运算。
arr + 1 也是一个表达式，数组名 arr 被转换为 int * 类型，进行加法运算后，仍然为 int * 类型。

使用指针访问数组等价于下标访问

现在我们学会了访问数组元素的两种办法：

  • 数组名[下标]
  • *(数组名 + 偏移量)

其中，偏移量就是指针指向的地址与数组首地址之间相差几个元素。
事实上，这两种形式是等价的。
中括号 [] ，被称作下标运算符，它的优先级高于一切其他运算符。通常的形式为：

A[k]

而表达式运算时，最终会将下标运算符展开为：

*(A + k)

测试一下

#include <stdio.h>
int main()
{
	int arr[5] = { 111, 222, 333, 444, 555 };
	printf("arr[2] = %d\n", arr[2]);
	printf("2[arr] = %d\n", 2[arr]);
	printf("*(arr + 2) = %d\n", *(arr + 2));
	return 0;
}
  • arr[2] 展开为 *(arr + 2) 。
  • 2[arr] 展开为 *(2 + arr) 。

因此，使用指针访问数组等价于下标访问。

指针作为参数传递

形参与实参相互独立

#include <stdio.h>
void swap(int x, int y)
{
	// 打印x，y的首地址
	printf("&x= %u\n", &x);
	printf("&y= %u\n", &y);
	int temp = x;
	x = y;
	y = temp;
}
int main()
{
	int a, b;
	int temp;
	a = 1;
	b = 2;
	// 打印a，b的首地址
	printf("&a= %u\n", &a);
	printf("&b= %u\n", &b);
	// 交换a，b变量
	swap(a, b);
	return 0;
}

分析过程

{% gallery::::one %}


{% endgallery %}

将指针作为参数传递

#include <stdio.h>
void swap(int* x, int* y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}
int main()
{
	int a, b;
	int temp;
	a = 1;
	b = 2;
	printf("a=%d b=%d\n", a, b);
	// 交换a，b变量
	swap(&a, &b);
	printf("a=%d b=%d\n", a, b);
	return 0;
}

不是交换指针x，y的值，而是交换目标数据对象a，b的值。所以，需要在指针前使用取值运算符*

为何在使用 scanf 函数时，需要对变量先取地址再传入参数

int n;
scanf("%d", &n);

scanf 会从读取从键盘的输入，转换后存储到变量n当中。被调函数 scanf 无法直接修改在主调函数中的变量n。因此，我们将变量n的指针传入 scanf 函数。通过指针使得被调函数间接地修改主调函数中的变量

指针不仅仅是首地址

再次强调，指针内保存的不仅仅是目标数据对象首地址，指针的类型也非常重要。
要在内存中找到一个数据对象，需要有以下两个信息。

  • 数据对象的首地址。
  • 数据对象占用存储空间大小。

指针的值保存着数据对象首地址，指针类型对应着目标数据对象的类型，用于标记目标数据对象的空间大小和指针运算时的步长。

仅有首地址的指针类型void *

由于指针类型定死了指针所指向的数据类型。为了让函数可以交换更多的数据类型，我们仅需要指针类型中保存的首地址，目标数据大小通过额外的参数传入。

  • 不同指针类型不能相互赋值，相互赋值后会造成目标数据对象类型的改变，无法通过编译。
  • void* 类型为特例，它可以接受任意指针类型的赋值，也可以赋值给任意类型的指针。
void swap(void* x, void* y, int size)
{
	// 指针转为char *，单个字节操作内存
	char* pX = (char*)x;
	char* pY = (char*)y;
	char temp;
	for (int i = 0; i < size; i++)
	{
		temp = pX[i];
		pX[i] = pY[i];
		pY[i] = temp;
	}
}

由于 void _ 不能取值和加减，所以我们将其转换为 char _ 。 char * 可以提供单个单个操作内存的能力。
在C语言中 void *类型不但可以接受任意类型的指针，也可以自动转换为任意类型的指针。
但在C++中，规则稍微严格了一点， void * 仅能接受任意类型的指针，不能自动转换为其他类型的指针。为了保证代码的兼容性，我们将 void * 强制转为 char * ，避免在C++中编译出错。

char *pX = (char *)x;
char *pY = (char *)y;

多级指针与指针数组

int * 的指针的类型为 int **

int **p; // 正确
int**p; // 正确
int* *p; // 正确
int * *p; // 正确
int * * p; // 正确

二级指针为例

#include <stdio.h>
int main()
{
	int n = 123;
	int* pn = &n;
	int** pnn = &pn;
	printf("**pnn = %d\n", **pnn);
	return 0;
}

取地址过程

  • 对n使用取地址运算符，获得n的指针pn，类型为 int * 。
  • 对pn使用取地址运算符，获得pn的指针pnn，类型为 int ** 。

取值过程

  • 对pnn使用取值运算符，将 int ** 还原为 int * 。
  • 对_pnn使用取值运算符，将 int _ 还原为 int 。即，还原为n。

指针数组

p ，指向 pToArr 的第一个元素，类型为 int ** 。
*p ，指向 arr1 的第一个元素，类型为 int * 。
*p + j ，指向 arr1 中的第j个元素，类型为 int * 。
*(*p + j) ，为 arr1 中的第j个元素。

多维数组名与指针

数组指针的移动

#include <stdio.h>
int main()
{
	int b[5][10] =
	{
		{0,1,2,3,4,5,6,7,8,9},
		{10,11,12,13,14,15,16,17,18,19},
		{20,21,22,23,24,25,26,27,28,29},
		{30,31,32,33,34,35,36,37,38,39},
		{40,41,42,43,44,45,46,47,48,49},
	};
	int(*pInt10)[10] = b;   // int[5][10]转为int (*)[10]
	int(*pInt) = *pInt10;   // *pInt10从int[10]转换为int *
	printf("pInt[0]=%d\n", pInt[0]);    // 等价于*(pInt + 0)
	printf("pInt[1]=%d\n", pInt[1]);    // 等价于*(pInt + 1)
	printf("pInt[2]=%d\n", pInt[2]);    // 等价于*(pInt + 2)
	printf("pInt[3]=%d\n", pInt[3]);    // 等价于*(pInt + 3)
	printf("pInt[4]=%d\n", pInt[4]);    // 等价于*(pInt + 4)
	printf("pInt[5]=%d\n", pInt[5]);    // 等价于*(pInt + 5)
	printf("pInt[6]=%d\n", pInt[6]);    // 等价于*(pInt + 6)
	printf("pInt[7]=%d\n", pInt[7]);    // 等价于*(pInt + 7)
	printf("pInt[8]=%d\n", pInt[8]);    // 等价于*(pInt + 8)
	printf("pInt[9]=%d\n", pInt[9]);    // 等价于*(pInt + 9)
	printf("pInt[10]=%d\n", pInt[10]);  // 等价于*(pInt + 10)
	return 0;
}

另一种结果相同的表达

#include <stdio.h>
int main()
{
	int b[5][10] =
	{
		{0,1,2,3,4,5,6,7,8,9},
		{10,11,12,13,14,15,16,17,18,19},
		{20,21,22,23,24,25,26,27,28,29},
		{30,31,32,33,34,35,36,37,38,39},
		{40,41,42,43,44,45,46,47,48,49},
	};
	int(*pInt10)[10] = b;   // int[5][10]转为int (*)[10]
	printf("*pInt10[0]=%d\n", (*pInt10)[0]);    // pInt10先从int(*)[10]转为int *，再通过下标访问
	printf("*pInt10[1]=%d\n", (*pInt10)[1]);
	printf("*pInt10[2]=%d\n", (*pInt10)[2]);
	printf("*pInt10[3]=%d\n", (*pInt10)[3]);
	printf("*pInt10[4]=%d\n", (*pInt10)[4]);
	printf("*pInt10[5]=%d\n", (*pInt10)[5]);
	printf("*pInt10[6]=%d\n", (*pInt10)[6]);
	printf("*pInt10[7]=%d\n", (*pInt10)[7]);
	printf("*pInt10[8]=%d\n", (*pInt10)[8]);
	printf("*pInt10[9]=%d\n", (*pInt10)[9]);
	printf("*pInt10[10]=%d", (*pInt10)[10]);
	return 0;
}

输出结果

*pInt10[0]=0
*pInt10[1]=1
*pInt10[2]=2
*pInt10[3]=3
*pInt10[4]=4
*pInt10[5]=5
*pInt10[6]=6
*pInt10[7]=7
*pInt10[8]=8
*pInt10[9]=9
*pInt10[10]=10

由于下标运算符[]的优先级比取值运算符*的优先级高。我们想要pInt10先从int (*)[10]转为int *，再通过下标访问。所以，需要用括号让取值先进行。

如果数组名B出现在表达式中，会从int[5][10]转为int (*)[10]。
*B又可以看作*(B + 0)，所以*B等价于B[0]。

对数组取地址

当数组名arr出现在一个表达式当中，数组名arr将会被转换为指向数组首元素的指针。但是，这个规则有两个例外：

  • 对数组名arr使用sizeof时。
  • 对数组名arr使用&时。

现在开始讨论第二个例外。

int arr[10];
&arr;

arr的类型为int[10]，而对数组使用取地址运算符&。触发第二个例外，数组不会进行类型转换，而是直接取地址。

  • 对int取地址为int (*)类型的指针。
  • 对int[10]取地址为int (*)[10]类型的指针。
#include <stdio.h>
int main()
{
	int arr[10];
	int(*pInt10)[10] = &arr;
	printf("pInt10=%u\n", pInt10);
	printf("pInt10+1=%u\n", pInt10 + 1);
	return 0;
}

pInt10是类型int (*)[10]类型的数组指针，步长为40。

pInt10=7601480
pInt10+1=7601520

如果再对pInt10取地址呢？

  • 对int[10]类型的数组取地址为int (*)[10]类型的数组指针，它指向int[10]的数组。
  • 对int (*)[10]类型的数组指针取地址为int (**)[10]的二级指针，它指向int(*)[10]的指针。

注意&&arr是不对的，&arr确实可以获得一个指针。但是，这个指针是一个临时数据对象，应当将其赋值给变量才能保存它的值。

指针与三维数组示例

#include <stdio.h>
int main()
{
	int S[2][5][10] = {
	{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
	{10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
	{20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
	{30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
	{40, 41, 42, 43, 44, 45, 46, 47, 48, 49}},
	{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
	{10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
	{20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
	{30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
	{40, 41, 42, 43, 44, 45, 46, 47, 48, 49}}
	};
	// 访问元素S[1][2][3]
	printf("S[1][2][3] = %d", *(*(*(S + 1) + 2) + 3));
	return 0;
}

分析

S + 1 类型为 int(*)[5][10] 的指针。
*(S + 1) 类型为 int[5][10] 的数组。
*(S + 1) + 2 类型为 int(*)[10] 的指针。
*(*(S + 1) + 2) 类型为 int[10] 的数组。
*(*(S + 1) + 2) + 3 类型为 int(*) 的指针。
*(*(*(S + 1) + 2) + 3) 类型为 int 的整型。

{% gallery::::one %}






{% endgallery %}

也可以故意将表达式结果赋值给一个无法转换的变量。让报错信息告诉我们表达式结果具体的类型

验证


指针的大小为4，整型的大小为4。
int[5][10] 数组的大小为200。
int[10] 数组的大小为40。

对数组取地址

对 int[2][5][10] 取地址为 int (*)[2][5][10] 类型的指针。

多级指针应用

从函数中返回指针

return关键词可以从被调函数中返回一个值到主调函数。
现在我们尝试让它返回一个指针到主调函数中。

#include <stdio.h>
int* func()
{
	int n = 100;
	return &n;
}
int main()
{
	int* p = func();
	printf("%d\n", *p);
	return 0;
}

我们在函数 func 中定义了变量n。接着return &n;取得变量n的指针，并返回到main函数。
main函数收到返回值后赋值给p，并使用指针p来访问变量n。

这个程序看似正确，并且可以通过编译。但是，却存在潜在问题。
这是因为函数结束后，函数内部的变量也会被回收。所以，变量 n 已经失效了。再去访问它有可能正常，也有可能得到一些无意义的值或者引发错误。
这样设计的原因是因为函数与函数之间的变量是独立的，即使是同一个函数多次运行，这些变量也是独立的。在函数返回后，函数内的变量没有继续存在的意义了。所以，函数内的变量将被回收，回收后的内存空间将给接下来运行的函数使用。
如果不想让变量被回收，那么可以在变量前加上关键词**static**

int* func()
{
	static int n = 100; // 关键词static让变量n不被回收
	n++; // 变量n自增
	return &n;
}
#include <stdio.h>
int main()
{
	int* p = func();
	printf("%d\n", *p);
	func();
	printf("%d\n", *p);
	func();
	printf("%d\n", *p);
	func();
	printf("%d\n", *p);
	func();
	printf("%d\n", *p);
	return 0;
}

现在函数 func 结束后，变量n不会被回收了。并且，重复调用func函数，使用的是同一个地址上的变量n。
因此，我们只需获取一次变量n的地址，即可观察到变量n每次调用函数都被自增。

从函数中返回多个变量

将指针的指针，也就是二级指针作为参数传入函数。即可让被调函数“返回”多个指针。

void func(int** a, int** b)
{
	static int x = 100;
	static int y = 200;
	*a = &x;
	*b = &y;
}
#include <stdio.h>
int main()
{
	// 两个指针，初始化为空
	int* a = NULL;
	int* b = NULL;
	func(&a, &b); // 将指针的指针传入被调函数
	if (a != NULL && b != NULL)
		printf("a=%d b=%d\n", *a, *b);
	return 0;
}

在main函数中，声明两个指针并把它们初始化为 NULL 。
**NULL**** 是一个由 **#define NULL 0** 定义的符号常量。**
将指针初始化为NULL，也就是将指针内保存的地址设置为0。
让指针初始化为零是一个非常好的编码习惯。
一般结合指针判空，即 if (a != NULL && b != NULL) ，来判断指针是不是有一个正确的指向了。
调用函数 func 后，两个指针均被修改为有效指针，即非0。
我们通过判断指针是不是非零来确定函数 func 已经给指针赋值了。
若指针仍然为0，则说明函数 func 并未给指针赋值，不可以使用没有明确指向的指针。
函数 func 内部， &x 、 &y 取得变量 x 、 y 的指针，类型为 int * 。
在被调函数内，为了修改主调函数中的变量，先对二级指针 a、b 取值，将 int ** 转换为 int * ，再赋
值一个 int 给它。
类似于使用一级指针作为参数时，先对一级指针 a、b 取值，将 int * 转换为 int ，再赋值一个 int 给它。

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

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

相关文章

校园报修抢修小程序系统开发 物业小区报修预约上门维修工单系统

校园报修抢修小程序系统开发 物业小区报修预约上门维修工单系统

开发的功能模块有&#xff1a; 1.报修工单提交&#xff1a;学生、教职员工等可以使用小程序提交报修请求。这通常包括选择报修的问题类型&#xff08;如水漏、电器故障、照明问题等&#xff09;&#xff0c;地点&#xff0c;报修联系人&#xff0c;联系电话等&#xff0c;并提供…
阅读更多...
iPaaS和RPA，企业自动化应该如何选择？

iPaaS和RPA，企业自动化应该如何选择？

全球著名的咨询调查机构Gartner在2022年初再次发布了《2022年12大技术趋势》报告。 Gartner是全球最具权威的IT研究与顾问咨询公司&#xff0c;成立于1979年&#xff0c;在界定及分析那些决定了商业进程的发展趋势与技术方面&#xff0c;它拥有二十年以上的丰富经验&#xff0c…
阅读更多...
苹果CMS首涂第30套可装修DIY主题模板免授权版

苹果CMS首涂第30套可装修DIY主题模板免授权版

这是一款可以装修的主题&#xff0c;类似淘宝店装修一样&#xff0c;可以针对首页、栏目页、详情页、播放页进行自定义装修&#xff0c;内置10个模块自由选择、添加、修改、删除、排序操作&#xff0c;后续升级还会增加更多实用和个性模块供选择&#xff0c;主题内包含的导航、…
阅读更多...
自定义歌曲试听SeekBar

自定义歌曲试听SeekBar

看到这个效果&#xff0c;可能会想到完全自定义一个控件&#xff0c;其实我们在系统Seekbar的基础上&#xff0c;将progressDrawable中progress背景设为透明后&#xff0c;叠加绘制试听状态下的进度区域即可 class PlayerSeekBar JvmOverloads constructor(context: Context,a…
阅读更多...
广州华锐互动VRAR | VR课件内容编辑器解决院校实践教学难题

广州华锐互动VRAR | VR课件内容编辑器解决院校实践教学难题

VR课件内容编辑器由VR制作公司广州华锐互动开发&#xff0c;是一款专为虚拟现实教育领域设计的应用&#xff0c;它能够将传统的教学内容转化为沉浸式的三维体验。通过这款软件&#xff0c;教师可以轻松创建和编辑各种虚拟场景、模型和动画&#xff0c;以更生动、直观的方式展示…
阅读更多...
【亚马逊云科技产品测评】活动征文｜aws云服务器 + 微服务Spring Cloud Nacos 实战

【亚马逊云科技产品测评】活动征文｜aws云服务器 + 微服务Spring Cloud Nacos 实战

文章目录 前言一、拥有一台Aws Linux服务器1.1、选择Ubuntu版本Linux系统1.2、创建新密钥对1.3、网络设置1.4、配置成功&#xff0c;启动实例1.5、回到实例区域1.6、进入具体的实例1.7、设置安全组 二、在Mac上连接Aws云服务&#xff0c;并安装配置JDK112.1、解决离奇的错误2.2…
阅读更多...
四川天蝶电子商务有限公司服务可靠吗？

四川天蝶电子商务有限公司服务可靠吗？

作为当今最热门的社交媒体平台之一&#xff0c;抖音已经成为许多消费者和企业的重要销售渠道。然而&#xff0c;对于许多新手来说&#xff0c;如何在这个平台上开展电商服务却是一大难题。在这篇文章中&#xff0c;我们将探讨四川天蝶电子商务有限公司的抖音电商服务是否可靠&a…
阅读更多...
俄罗斯方块游戏制作

俄罗斯方块游戏制作

创建包和文件夹 1.创建小方块类 package eluosifangkuai; import java.awt.image.BufferedImage; import java.util.Objects;/*** author xiaoZhao* date 2022/5/7* describe* 小方块类* 方法&#xff1a; 左移、右移、下落*/ public class Cell {// 行private int row;//…
阅读更多...
基于野狗算法优化概率神经网络PNN的分类预测 - 附代码

基于野狗算法优化概率神经网络PNN的分类预测 - 附代码

基于野狗算法优化概率神经网络PNN的分类预测 - 附代码 文章目录 基于野狗算法优化概率神经网络PNN的分类预测 - 附代码1.PNN网络概述2.变压器故障诊街系统相关背景2.1 模型建立 3.基于野狗优化的PNN网络5.测试结果6.参考文献7.Matlab代码 摘要&#xff1a;针对PNN神经网络的光滑…
阅读更多...
IPO解读丨高处不胜寒，澜沧古茶低头取暖？

IPO解读丨高处不胜寒，澜沧古茶低头取暖？

自A股注册制改革不断深化并全面落地后&#xff0c;不少意欲登陆资本市场的企业转战港股。这个过程中&#xff0c;诞生了很多以“港股”为前缀的“第一股”——“白酒第一股”珍酒李渡、“水果零售第一股”百果园、“智能驾驶第一股”知行汽车、“运动科技第一股”Keep…… 由A…
阅读更多...
以“防方视角”观Shiro反序列化漏洞

以“防方视角”观Shiro反序列化漏洞

为方便您的阅读&#xff0c;可点击下方蓝色字体&#xff0c;进行跳转↓↓↓ 01 案例概述02 攻击路径03 防方思路 01 案例概述 这篇文章来自微信公众号“潇湘信安”&#xff0c;记录的某师傅如何发现、利用Shiro反序列化漏洞&#xff0c;又是怎样绕过火绒安全防护实现文件落地、…
阅读更多...
.NET 8 Video教程介绍（开篇）

.NET 8 Video教程介绍（开篇）

教程简介 本文将简单描述视频网站教程&#xff0c;视频网站是一个类似于腾讯视频一样的网站&#xff0c;视频资源用户自己上传&#xff0c;然后提供友好的界面查看视频和搜索视频&#xff0c;并且提供管理页面对于视频进行管理&#xff0c;我们将使用Blazor作为前端&#xff0…
阅读更多...
chatGPT PLUS 绑卡提示信用卡被拒的解决办法

chatGPT PLUS 绑卡提示信用卡被拒的解决办法

一、 ChatGPT Plus介绍 作为人工智能领域的一项重要革新&#xff0c;ChatGPT Plus的上线引起了众多用户的关注&#xff0c;其背后的OpenAI表现出傲娇的态度&#xff0c;被誉为下一个GTP 4.0。总的来说&#xff0c;ChatGPT Plus的火爆主要有两个原因。首先&#xff0c;其在人工…
阅读更多...
虹科示波器 | 汽车免拆检修 | 1994款凯迪拉克fleetwood车发动机无法起动

虹科示波器 | 汽车免拆检修 | 1994款凯迪拉克fleetwood车发动机无法起动

一、故障现象 一辆1994款凯迪拉克fleetwood车&#xff0c;搭载5.7L发动机&#xff08;燃油系统采用进气歧管多点喷射&#xff0c;每个气缸都有独立的喷油器&#xff1b;点火系统只有一个点火线圈&#xff0c;带机械分电器和高压线&#xff09;&#xff0c;发动机无法起动。 二、…
阅读更多...
车载毫米波雷达行业发展5——企业

车载毫米波雷达行业发展5——企业

5.1 博世 5.1.1 公司简介 博世集团创立于 1886 年&#xff0c;业务涵盖汽车与智能交通技术、工业技术、消费品、能源与建 筑技术四大领域&#xff0c;是德国最大的工业企业之一、全球最大的汽车零部件供应商、最早研究车载毫米波雷达的企业之一。博世在高级辅助驾驶和自动驾驶…
阅读更多...
【NI-RIO入门】CompactRIO介绍及环境安装

【NI-RIO入门】CompactRIO介绍及环境安装

CompactRIO是什么&#xff1f; CompactRIO系统提供了高处理性能、传感器专用I/O和紧密集成的软件工具&#xff0c;使其成为工业物联网、监测和控制应用的理想之选。实时处理器提供可靠&#xff0c;可预测的行为&#xff0c;而FPGA在需要高速逻辑和精确定时的较小任务上表现出色…
阅读更多...
在网络攻击之前、期间和之后应采取的步骤

在网络攻击之前、期间和之后应采取的步骤

在当今复杂的威胁形势下&#xff0c;网络攻击是不可避免的。 恶意行为者变得越来越复杂&#xff0c;出于经济动机的攻击变得越来越普遍&#xff0c;并且每天都会发现新的恶意软件系列。 这使得对于各种规模和跨行业的组织来说&#xff0c;制定适当的攻击计划变得更加重要。 …
阅读更多...
顶部动态菜单栏的使用

顶部动态菜单栏的使用

效果图 开发环境 vue3 关键逻辑 //导航栏状态选择 const navbarSolid ref(false); //初始化导航栏高度 const navbarHeight ref(0);/*** 根据滚动距离改变样式*/ function checkNavbarOpacity() {navbarSolid.value window.pageYOffset > navbarHeight.value / 2; }/**…
阅读更多...
五、程序员指南：数据平面开发套件

五、程序员指南：数据平面开发套件

服务质量 (QoS) 框架 本章介绍 DPDK 服务质量 (QoS) 框架。 21.1 带有 QoS 支持的数据包流水线 下图显示了一个具有 QoS 支持的复杂数据包处理流水线的示例 表21.1&#xff1a;带有 QoS 支持的复杂数据包处理流水线 这个流水线可以使用可重用的 DPDK 软件库构建。在这个流…
阅读更多...
Unity模拟薄膜干涉效果

Unity模拟薄膜干涉效果

Unity制作薄膜干涉效果&#xff0c;色彩斑斓的黑色石头 大家好&#xff0c;我是阿赵。   这次来做一个模拟薄膜干涉的彩色效果&#xff0c;Shader是使用ASE来连接&#xff0c;也算是ASE做复杂一点的效果的一个例子吧。 一、什么是薄膜干涉 以下解释来源于百度百科&#xff1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023