兰理鲲鹏-指针各类应用【大厂面试真题】

已于 2023-04-16 21:24:12 修改
阅读量2k 收藏 26
点赞数 52
分类专栏： 总和 文章标签： 面试 链表 数据结构 c语言 后端
于 2022-01-21 00:08:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62852431/article/details/122573343
版权

指针各类应用及大厂面试真题解析

文章目录

前言

初学者或普通高校所学习的指针大多浅显，即明白指针是地址，通过解引用操作可以操作地址内容，往往仅限于简单变量与数组，但要对指针有明确进一步的认识提高，其中有许多知识我们尚未涉足。本文将对指针进行简单系统的概括总结，且附上数道面试真题，帮助大家理解与掌握。干货满满，求大家支持一下。

一、我们目前掌握的指针

1.字符指针

指针类型为char*
使用方法

int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	return 0;
}

另一种

int main()
{
	const char* ps = "hello";
	printf("%s\n", ps);
	return 0;
}

运行结果
运行结果
这里实际上是讲‘hello’首元素地址存入了指针变量ps中。
在这里插入图片描述
以%s字符串打印即可通过地址找到首元素向后寻址打印字符串数组

相关面试题

int main()
{
	char str1[] = "hello";
	char str2[] = "hello";
	const char* str3 = "hello";
	const char* str4 = "hello";
	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;
}

运行结果
str1 与str2 是数组名，数组名表示数组首元素地址但str1与str2是两个不同的数组，只不过是其内所有元素相同，开辟的是不同的地址空间。故其二者不相同
str3与str4虽然是不同变量名，但都指向了‘hello’的字符常量，C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。故其二者相同

拓展：const修饰指针

const修饰指针无非有三种情况

const在*左边
const int* pi;
int const* pi;
//这种类型讲*pi即指针变量常定义，*pi即地址所指向的内容不能改变，但内容所指向的地址可以改变

描述

const在*右边
int * const h;
//类别上文，地址h不可改变，但h解引用*h可改变

在这里插入图片描述

const在*左右都有
const int * const k;//两者等价
int const * const k;

在这里插入图片描述

2.数组指针

定义方法
int （*p）[10]//p是一个地址，地址指向有10个元素的整形数组
//指针数组
int *p[10]//p中有十个元素类型为int*

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

顾名思义，指向数组的指针，我们都知道，数组名是数组首元素地址，数组指针也固然指向数组首元素。那数组名与数组指针有什么区别呢

注意：&数组名取出的是整个数组的地址，与数组首元素不同，数组名+1前进一个元素，但&数组名+1跳过整个数组
在这里插入图片描述
指针数组常用于二维数组

void print_arr(int (*arr)[5], int row, int col)
{
int i = 0;
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
{
printf("%d ", arr[i][j]);//arr[i] = *(arr+1) arr[i][j] = *(*(arr+i)+j)
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print_arr(arr, 3, 5);
return 0;
}

数组传参

一维数组

void test(int arr[])
{}
void test(int arr[10])//为方便初学者学习，设计时可以这样传入
{}
void test(int* arr)//数组名本为首元素地址，用指针接收合乎情理
{}
void test2(int* arr[20])
{}
void test2(int** arr)//arr2本为指针，指针用二级指针接收
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

二维数组

void test(int arr[3][5])
{}
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);
}

一级指针

#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 (*p)(int,float)//可与数组指针类比p先与*结合，后有函数调用操作符，即p作为一个指针指向函数，函数类型void(int，float）

与函数指针相关有许多套娃操作，不在本文重点，随手带过
函数指针数组

int  (*p[10])();

数组中存放着10个函数指针
在这里插入图片描述
函数指针数组所对应的指针

void(*(*p)[5])(int)

在这里插入图片描述

重点

二、指针和数组笔试题解析

数组名的两个例外
数组名是数组首元素地址，单独&数组名和sizeof（数组名）是取出的是数组的地址

铺垫

在这里插入图片描述

1.一维数组

int main() 
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//数组名a单独放在sizeof内部，计算的整个数组的大小，单位是字节，4*4 = 16
	printf("%d\n", sizeof(a + 0));//a表示的首元素的地址，a+0还是数组首元素的地址，是地址大小4/8
	printf("%d\n", sizeof(*a));//a表示的首元素的地址,*a就是对首元素的地址的解引用，就是首元素，大小是4个字节
	printf("%d\n", sizeof(a + 1));//a表示的首元素的地址，a+1是第二个元素的地址，是地址，大小就4/8个字节
	printf("%d\n", sizeof(a[1]));//a[1]是数组的第二个元素，大小是4个字节
	printf("%d\n", sizeof(&a)); //&a 表示是数组的地址，数组的地址也是地址，地址大小就是4/8字节
	printf("%d\n", sizeof(*&a));//可以理解为*和&抵消效果，*&a相当于a,sizeof(a)是16 &a -> int(*)[4] &a是数组的地址，它的类型是int(*)[4]数组指针，如果解引用，访问的就是4个int的数组，大小是16个字节
	printf("%d\n", sizeof(&a + 1));//&a是数组的地址，&a+1 跳过整个数组后的地址，是地址就是4/8
	printf("%d\n", sizeof(&a[0]));//&a[0]取出数组第一个元素的地址，是地址就是4/8
	printf("%d\n", sizeof(&a[0] + 1));//&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节

	return 0;
}

在这里插入图片描述

sizeof只关注占用空间的大小，单位是字节
/sizeof不关注类型
sizeof是操作符

strlen

#include <string.h>
//strlen关注的字符串中\0的为止，计算的是\0之前出现了多少个字符
//strlen只针对字符串
//strlen是库函数

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };

	printf("%d\n", strlen(arr));//arr是首元素的地址，但是arr数组中没有\0，计算的时候就不知道什么时候停止，结果是：随机值
	printf("%d\n", strlen(arr + 0));//arr是首元素的地址，arr+0还是首元素的地址，结果是：随机值
	printf("%d\n", strlen(*arr)); //err,strlen需要的是一个地址，从这个地址开始向后找字符,直到\0，
	//统计字符的个数。但是*arr是数组的首元素，也就是'a',这是传给strlen的就是'a'的ascii码值97，
	//strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突
	
	printf("%d\n", strlen(arr[1]));//err 和上一个一样，内存访问冲突

	printf("%d\n", strlen(&arr));//&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，
	//但是传参过去后，还是从第一个字符的位置向后数字符，结果还是随机值。

	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值

	printf("%d\n", sizeof(arr));//arr作为数组名单独放在sizeof内部，计算的整个数组的大小，单位是字节，6
	printf("%d\n", sizeof(arr + 0));//arr就是首元素的地址，arr+0还是首元素的地址，地址大小就是4/8
	printf("%d\n", sizeof(*arr));//arr就是首元素的地址，*arr就是首元素，是一个字符，大小是一个字节，1
	printf("%d\n", sizeof(arr[1]));//arr[1]就是数组的第二个元素，是一个字符，大小是1个字节
	printf("%d\n", sizeof(&arr));//&arr取出的是数组的地址，数组的地址也是地址，地址就是4/8个字节
	printf("%d\n", sizeof(&arr + 1));//&arr取出的是数组的地址，&arr+1，跳过了整个数组，&arr+1还是地址，地址就是4/8个字节
	printf("%d\n", sizeof(&arr[0] + 1));//&arr[0]是第一个元素的地址，&arr[0]+1就是第二个元素的地址，地址就是4/8个字节
	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
		char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//"abcdef"后隐藏\0，strlen计算\0前的字符个数，结果是6
	printf("%d\n", strlen(arr + 0));//arr是字符串首元素地址，arr+0仍然是，结果是+
	printf("%d\n", strlen(*arr));//arr是数组首元素地址，*arr即是‘a’，a的ASCII码为97，strlen会以97作为地址向后寻址\0，会形成内存访问冲突
	printf("%d\n", strlen(arr[1]));//arr[1]同上，形成内存访问冲突
	printf("%d\n", strlen(&arr));//&arr取出整个数组地址，数据仍与数组首元素地址相同，但传入strlen后仍然以字符为单位向后寻找\0；还是随机值
	printf("%d\n", strlen(&arr + 1));//传入了数组\0后的地址，向后寻找\0，还是随机值
	printf("%d\n", strlen(&arr[0] + 1));//传入了b的地址，5

	printf("%d\n", sizeof(arr));//sizeof中arr单独存在表示整个数组，6
	printf("%d\n", sizeof(arr + 0));//arr+0是数组首元素，1
	printf("%d\n", sizeof(*arr));//arr是数组首元素地址，*arr即是a，1
	printf("%d\n", sizeof(arr[1]));//是‘b’，1
	printf("%d\n", sizeof(&arr));//&arr即使是整个数组地址，但还是一个指针变量，4/8
	printf("%d\n", sizeof(&arr + 1));//指针变量，4/8
	printf("%d\n", sizeof(&arr[0] + 1));//指针变量，4/8
	return 0;
}

int main()
{
	char* p = "abcdef";
		
	printf("%d\n", strlen(p));//p中存放的是'a'的地址，strlen(p)就是从'a'的位置向后求字符串的长度，长度是6
	printf("%d\n", strlen(p + 1));//p+1是'b'的地址，从b的位置开始求字符串长度是5
	printf("%d\n", strlen(*p));//'a',err
	printf("%d\n", strlen(p[0]));//err
	printf("%d\n", strlen(&p));//取出另一个地址,随机值
	printf("%d\n", strlen(&p + 1));//同上，随机值
	printf("%d\n", strlen(&p[0] + 1));//p[0] -> *(p+0) -> *p ->'a' ,&p[0]就是首字符的地址，&p[0]+1就是第二个字符的地址
	//从第2 字符的位置向后数字符串，长度是5
		
		
	printf("%d\n", sizeof(p)); //p是一个指针变量，sizeof(p)计算的就是指针变量的大小，4 / 8个字节
	printf("%d\n", sizeof(p + 1));//p是指针变量，是存放地址的，p+1也是地址，地址大小就是4/8字节
	printf("%d\n", sizeof(*p));//*p访问的是1个字节
	printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0) -> *p   1个字节
	printf("%d\n", sizeof(&p));//&p也是地址，是地址就是4/8字节，&p是二级指针
	printf("%d\n", sizeof(&p + 1)); //&p是地址， + 1后还是地址，是地址就是4 / 8字节
	//&p + 1,是p的地址+1，在内存中跳过p变量后的地址
	printf("%d\n", sizeof(&p[0] + 1));//p[0]就是a，&p[0]就是a的地址，&p[0]+1就是b的地址，
	//是地址就是4/8字节
	return 0;

}

2.二维数组

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

int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//数组名单独放在sizeof内部，计算的是整个数组的大小，48
	printf("%d\n", sizeof(a[0][0]));//一个元素的大小，是int类型，4
	printf("%d\n", sizeof(a[0]));//a[0]表示第一行的数组名，a[0]作为数组名单独放在sizeof内部，计算的是第一行的大小。，16
	printf("%d\n", sizeof(a[0] + 1));//a[0]作为数组第一行，且单独存在，即第一行第二个元素的地址，是指针变量4/8
	printf("%d\n", sizeof(*(a[0] + 1)));//接上，是一个元素，4
	printf("%d\n", sizeof(a + 1));//第二行地址，指针变量 4/8
	printf("%d\n", sizeof(*(a + 1)));//接上 16
	printf("%d\n", sizeof(&a[0] + 1));//&一整行，+1即第二行地址 4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//接上 是一行 16
	printf("%d\n", sizeof(*a));//取到了第一行，与sizeof结合。16
	printf("%d\n", sizeof(a[3]));//感觉越界，但没关系，16
	return 0;
}

在这里插入图片描述

三，面试真题

int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);//取到了5后的地址并强制类型转化为int*
printf( "%d,%d", *(a + 1), *(ptr - 1));//*(ptr-1)向前寻回了5
return 0;
}

运行结果
2.

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);//结构体类型加一跳过20字节，转化16进制为14
printf("%p\n", (unsigned long)p + 0x1);//转换为无符号的长整形，即加了数字1用%p的形式打印
printf("%p\n", (unsigned int*)p + 0x1);//强制类型转换为无符号整形指针，+1跳过4，已%p形式打印
return 0;
}

运行结果
3.

int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);//取到4后地址并强制类型转化为int*
int *ptr2 = (int *)((int)a + 1);//a是数组首元素地址，转化为int类型，如图。
printf( "%x,%x", ptr1[-1], *ptr2);//都以16进制打印
return 0;
}

以vs2019小端字节序为例
讲地址转化为int类型，+1就是地址+1，数字1，即一个字节，又转化为int*,如图所示，又为小端排序，低位放在低地址，高位放在高地址，02是高位
02000000
在这里插入图片描述
运行结果
4.

#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };//大坑，坑，是括号不是大括号，是逗号表达式！！
//实际上 int a[3][2] = {1,3,5};
int *p;
p = a[0];//第一行
printf( "%d", p[0]);//首元素
return 0;
}

在这里插入图片描述

在这里插入图片描述
5.

int main()
{
int a[5][5];
int(*p)[4];//注意，只有[4],草稿纸画图建议横着画
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//地址相减为元素个数，小地址-大地址为负即-4
return 0;
}

在这里插入图片描述
将-4以%p打印时
原码 10000000000000000000000000000100
反码 11111111111111111111111111111011
补码 11111111111111111111111111111100
转化为16进制 ff ff ff fc
在这里插入图片描述
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;

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

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

总结

以上就是今天要讲的内容，本文仅仅简单介绍了指针的使用，而指针提供了对数据强有力的处理方法。还是比较重要
本文仅仅以学习笔记梳理为目的，如有建议以及错误还请指正.

码文不易，期待三连

琅時壹
关注
专栏目录
指针 面试题（经典）
07-10
只有真正的把试题做一遍才能达到效果，看完试题立马看答案达不到思考的效果，所以博主在这里就暂时不给答案了，想要答案的可以留下邮箱，谢谢
关于指针的一个面试题
编程语言小筑
05-24 166
前几天，去一个公司面试实习生，遇到下面这个题： void test(void) { char *str = NULL; get_memory(str); strcpy(str, "hello world"); printf("%s\n", str); } void get_memory(char *p) { p = (char *)mallo...
面试题-指针-引用
用来学习的地方
09-16 509
返回目录：https://blog.csdn.net/chen1083376511/article/details/82723709 +问题： 问：引用与指针有什么区别？ 答： 1.引用必须初始化，指针可以不用。 2.引用初始化以后就不能被改变（即只能初始化一次，始终只指向指定的对象），而指针可以改变所指向的对象。 3.不存在指向空值的引用，而指针可以指向一个空值，即空指针。 4.因...
指针的经典面试题
10-18 3537
指针的经典面试题
指针面试题
mingren_1314的博客
11-11 213
经典指针面试题 一维数组 整型数组 字符数组 再看一组strlen（求字符串长度） 字符串 再看一组strlen 上面的随机值，我们假设a的一个地址，然后找到向后传，但是并不确定\0的位置 二维数组 总结 笔试题 1. 2. 3. 4. 5. 6. 7. 8. 指针到这就结束了，希望可以帮助到大家！ 2020年11月11日 ...
兰理工数据库课设--毕业设计管理
07-31
一．设计的目的和意义 该设计要求学生以毕业设计管理业务为背景，设计、开发一套“毕业设计管理系统”软件。 通过该题目的设计、开发，使学生初步得到信息管理系统开发的训练，全面培养软件开发过程中的分析、设计、...
兰理工网页作业之个人简历制作
07-31
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <title>link</title> <meta name="description" ...
兰理工软件学院：顺序与链式堆栈、队列基础操作详解
这对于程序设计，特别是算法设计和系统分析有着直接的应用，例如在内存管理、任务调度、函数调用栈等方面。 总结来说，本实验不仅锻炼了学生的编程技能，还提升了他们对数据结构的理解，有助于他们在实际项目中灵活...
兰理工春季学期：数据结构与算法设计实例解析
1. 集合运算问题部分着重于实际编程应用，要求学生编写算法实现集合的基本操作，如输入、输出、删除重复元素、求交、并、差等。通过使用单链表作为数据结构，学生们得以深化对链表的理解，并提升将理论知识应用于...
开题报告大学生创业服务系统 已通过开题答辩的.docx
最新发布
07-26
- **基于 Java Web 的大学生科研实训与创新创业系统**：李明星和兰理琪的研究提出了一种基于 Java Web 的云应用方案，旨在提升大学生的创新创业能力。 - **基于大数据技术的大学生就业创业平台**：王雯的研究探讨...
指针的面试题
asd25415129591的博客
05-02 765
1.指针的面试题： ①数组名代表数组的首地址 ②p[i]用下标法可以直接访问该地址里面存储的值 ③*arr，可以*直接访问arr这个地址的值 ④*（arr+1）；也可以用指针偏移的方式进行访问，但不能arr++，arr是指针常量，不是指针变量 ⑤sizeof（指针）的大小都是8个字节，因为指针==地址 ⑥int *p=（int *）地址；该地址是16进制数，这=用这样的方式给指针一个地址 ...
指针---面试题
weixin_58389786的博客
03-20 284
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { /*一维数组 除了sizeof(a) &a表示整个数组 其余都表示数组首元素*/ int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a));//整个数组的大小 16 printf("%d\n", sizeof(a +.
一些指针面试题
weixin_46117546的博客
11-18 155
写之前需注意strlen与sizeof的区别 strlen取的是到\0的距离长度 sizeof取的是字节数 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { int arr[4] = {1, 2, 3, 4}; printf("%d\n", sizeof(arr));//16 数组指针 printf("%d\n", sizeof(arr + 0));//4 与sizeof(in
指针——面试题详解
m0_58232983的博客
03-20 1952
指针面试题详解，保姆级步骤带你作答指针题目
一些面试题：关于指针的一些理解
StudyRecord的专栏
04-06 1035
1、main()  {      int a[5]={1,2,3,4,5};      int *ptr=(int *)(&a+1);       printf("%d,%d",*(a+1),*(ptr-1));  }  答：2,5       *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5
一道面试题帮你深入了解指针（C语言）
FriedrichSong的博客
03-24 2225
代码块如下，不过直接看图片可能会更清晰一点（0V0）； 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", .
C语言面试题目之指针和数组
weixin_30727835的博客
06-06 613
说明：所有题目均摘录于网络以及我所见过的面试题目，欢迎补充！ 无特殊说明情况下，下面所有题s目都是linux下的32位C程序。 先来几个简单的热热身。 1、计算以下sizeof的值。 char str1[] = {'a', 'b', 'c', 'd', 'e'}; char str2[] = "abcde";char *ptr = "abcde";char book[][80]...
指针与指针面试真题
qq_55439426的博客
10-27 1330
文章目录前言：内存指针的重要性指针变量的定义NULL指针（博主目前也解释不清楚，但是知道怎么用就行了）指针的大小：指针类型指针的运算普通指针数组指针与指针数组函数指针一级指针与二级指针经典有趣的代码指向函数指针数组的指针回调函数指针笔试题笔试题一笔试题二笔试三笔试四总结刷题网站： 前言： 本篇介绍指针。指针是一个很抽象的概念，博主不是太能解释清楚。唯一的建议是自己在实践中悟。… 内存 了解指针前，我们需要了解内存 正如图中所说，通过地址可以找到内存唯一的存储单元。因此说知道了地址，就知道了数
评论 55
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

琅時壹

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

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

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

打赏作者

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

抵扣说明：

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

余额充值