前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >【指针合集】全方位理解C语言指针

【指针合集】全方位理解C语言指针

作者头像
Yui_
发布于 2024-10-16 00:33:07
发布于 2024-10-16 00:33:07
28900
代码可运行
举报
文章被收录于专栏：Yui编程知识Yui编程知识
运行总次数：0
代码可运行
关联问题
换一批

1.什么是指针

指针的两个要点 1.指针是内存中的一个最小单元的编号，也就是地址。 2.平时口语所说的指针，通常指的是指针变量，是用来存放内存地址的变量。

总结 指针就是地址，口语所说的指针通常是指针变量

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的。 所以为了有效的使用内存，就要把内存划分成一个个小的内存单元，每个内存单元的大小都是一个字节。 为了能够有效的访问到内存的每个单元，就要给内存单元进行编号，这些编号被称为内存单元的地址。 在写程序时，创建的变量、数组等都要在内存上开辟空间。 每个内存都有唯一的编号，这个编号也被称为地址 地址 == 编号

内存
内存

变量是创建内存中的（在内存中分配空间的），每个内存单位都有地址，所以变量也是有地址的。 可以利用&来取出变量的地址。 指针变量

通过&（取地址符）取出变量内存的地址，把地址可以存放在一个变量当中，这个变量就是指针变量。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;//这里的pa就是指针变量
	*pa = 10;//*就是根据a的地址取找到a
	//这样我们就可以间接的改变a的值
	printf("%d\n",a);
	return 0;
}
//打印结果：10

总结：

指针变量就是用来存放地址的变量。（存放在指针中的值会被当成地址处理）。

在内存当中是如何编址的呢？ 上面我们提到了一个字节对应一个地址，为什么会这样呢？ 其实在计算机当中会存在地址线，32位的机器上就存在32根地址线，这些地址线会发出高电压（高电平）和低电压（低电平）就是（1或者0）； 那么32根地址线就可以产生2的32次方种情况。

00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 … 11111111 11111111 11111111 11111111

2的32次方种情况，每种情况就对应着每个地址，就标识着一个字节。这里右2的32次方字节，大概是4G的空间。 同样的方法在64位机器，可以标识的空间就非常大了。 这里我们明白了：

  • 在32位机器上，地址是32个0或者1组成的二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4字节。
  • 因此在64位的机器上就是一个指针变量大小对应8个字节。 总结：
  • 指针是用来存放地址的，地址就是唯一标识一块地址的。
  • 指针的大小在32位平台是4个字节，在64位平台是8个字节。

2.指针和指针类型

前面我学习了，整型，短整型，浮点型，字符型。这些都是变量的类型，那么指针有没有类型呢？ 有的

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int num = 10;
p = &num

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那么它的类型是怎么样的呢？ 我们给指针变量相应的类型。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
char* pc = NULL;
int* pi = NULL;
short* ps = NULL;
long* pl = NULL;
long long* pll = NULL;

我们可以发现，指针的定义方式是type + * 但是我们又知道，指针变量的大小都是是固定的不是4个字节就是8个字节。那么为什么要搞出指针的类型呢？有什么意义吗？ 意义就在于给*发出信息

指针类型可以决定指针解引用的时候访问多少字节 指针类型决定了指针解引用操作的权限 指针的类型决定了指针向前或者向后走一步有多大距离

2.1 指针±整数

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int a = 0;
	char* pc = (char*)&a;
	int* pi = &a;
	printf("%p\n",&a);
	printf("%p\n",pc);
	printf("%p\n",pc+1);
	printf("%p\n",pi);
	printf("%p\n",pi+1);
	return 0;
}
//打印结果
/*
006FFE20
006FFE20
006FFE21
006FFE20
006FFE24
*/

可以发现用char* 作为指针类型的+1只能向后移动一个字节，而用int*作为指针类型的+1却可以向后移动4个字节。 也就是说： 指针的类型决定了指针向前或者向后走一步有多大距离

2.2 指针的解引用

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	int* pi = &n;
	*pc = 0;
	*pi = 0;
	return 0;
}

下面我们观察在调试过程当中内存的变化。

编译
编译
编译
编译
编译
编译

从这三张图我们可以了解到： 指针的类型决定了，对这种解引用有多大的权限（能操作几个字节） 比如 char*的指针解引用就只能访问一个字节，而int*的指针就能访问4个字节。

3.野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

3.1为什么会有野指针

1.指针未初始化

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int* p;//局部变量指针未初始化，默认为随机值
	*p = 100;
	return 0;
}

2.指针越界访问

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = {0};
	int* p = arr;
	for(int i = 0;i<=10;++i)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*(p++) = i;
	}
	return 0;
}

3.指针指向的局部变量释放

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int* test()
{
	int a = 0;
	return &a;
}
int main()
{
	int* pa = test();
	printf("%p\n",pa);
	return 0;
}

3.2 如何规避野指针

1.指针初始化 2.小心指针越界 3.指针指向空间释放即置为NULL 4.避免返回局部变量的地址 5.指针使用前检查其有效性

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int* p = NULL;
	//明确知道指针应该初始化为谁的地址，就直接初始化
	//不知道指针初始化为什么值，就暂时初始化为NULL；
	//...
	int a = 10;
	p = &a;
	if(p!=NULL)
	{
		*p = 100;
	}
	return 0;
}

4.指针运算

  • 指针±整数
  • 指针-指针
  • 指针的关系运算

4.1 指针±整数

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[5] = {0};
	for(int* p = arr;p<=&arr[4];)
	{
		*p++ = 0;
	}
	return 0;
}

4.2 指针减指针

指针-指针返回绝对值是它们间的元素个数，

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[5] = {0};
	int* pa = &arr[0];
	int* pb = &arr[4]；
	printf("%d\n",pb-pa);
	return 0;
}
//打印结果
//4

4.3 指针的关系运算

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
for(vp = &values[N_VALUES];vp>&values[0];)
{
	*--v = 0;
}

//代码简化
for(vp = &values[N_VALUES-1];vp>=&values[0];vp--)
{
	*v = 0;
}

实际上大部分的编译器上都是可以完成上面的代码通过的，然而我们还要要避免这样写，因为标准不保证它可行。

规定：

允许指向数组元素的指针与指向数组最后元素的后面的那个内存的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

5.指针与数组

指针变量就是指针变量，不是数组。指针变量的大小是4/8字节，专门是用来存放地址的 数组就是数组，不是指针，数组是一块连续的空间，可以存放一个或多个类型相同的数据 数组中，数组名就是数组首元素的地址，数组名 == 地址 == 指针 当我们知道数组首元素的地址的时候，因为数组又是连续存放的，所以通过指针就可以遍历访问数组，数组是可以通过指针来访问的。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	printf("%p\n",arr);
	printf("%p\n",&arr[0]);
	return 0;
}
//打印结果：
/*
012FFEB0
012FFEB0
*/

可见数组名和首元素的地址是一样的。 数组名表示的就是数组首元素的地址。（两种情况）

1.sizeof（数组名），计算的是整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。 2.&数组名，取出的整个数组的地址。&数组名，数组名表示整个数组，但是整个数组会以首元素的的地址显示。

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问以数组就成为可能。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int* p  = arr;
	for(int i = 0;i<10;++i)
	{
		printf("&arr[%d] = %p == p+%d = %p\n",i,&arr[i],i,p+i);
	}
	return 0;
}
//打印结果：
/*
&arr[0] = 00B3F708 == p+0 = 00B3F708
&arr[1] = 00B3F70C == p+1 = 00B3F70C
&arr[2] = 00B3F710 == p+2 = 00B3F710
&arr[3] = 00B3F714 == p+3 = 00B3F714
&arr[4] = 00B3F718 == p+4 = 00B3F718
&arr[5] = 00B3F71C == p+5 = 00B3F71C
&arr[6] = 00B3F720 == p+6 = 00B3F720
&arr[7] = 00B3F724 == p+7 = 00B3F724
&arr[8] = 00B3F728 == p+8 = 00B3F728
&arr[9] = 00B3F72C == p+9 = 00B3F72C
*/

所以p+i就是计算的数组arr下标为i的地址。 那我们就可以直接通过指针来访问数组。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int* p  = arr;
	for(int i = 0;i<10;++i)
	{
		printf("%d ",*(p+i));
	}
	return 0;
}
//打印结果：1 2 3 4 5 6 7 8 9 10

也就是说arr[i] = *(p+i)，这样的话，对于计算机来说，肯定是按*(p+i)来处理的，就是把arr[i]转换成*(p+i)。然后我们知道*(p+i)和*(i+p)是没有区别的。所以我们是可以写i[arr]来打印数组的。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ",i[arr]);
	}
	return 0;
}
//打印结果：1 2 3 4 5 6 7 8 9 10

注意：不建议这样写,会有点装了。

6.二级指针

指针变量也是指针，是变量就有地址，那指针变量的地址存放在哪里呢？

二级指针
二级指针

a的地址存放在pa中，pa的地址存放在ppa中，pa是一级指针。而ppa是二级指针。 对于二级指针的运算有：

  • *ppa通过对ppa中的地址进行解引用，这样找到的是pa,*ppa其实访问的是pa
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int a = 10;
*ppa = &a;//等价于pa = &b
  • ppa先通过*ppa找到pa进行解引用操作：*pa，那找到的就是a

7.指针数组

指针数组就是存放指针的数组 比如整型数组是存放整型的数组，字符数组是存放字符的数组。

整型数组
整型数组

那么指针数组就是：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int* arr2[5];

arr2是一个数组，有5个元素，每一个元素是一个整型指针；

整型指针数组
整型指针数组

8.字符指针

在指针的类型中我们知道有一种指针类型为字符指针char* 一般使用情况

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	char c = 'a';
	char* pc = &c;
	*pc = 'y';
	return 0;
}

还有一种情况

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	const char* str = "hello world";//把"hello world"的首元素的地址给了str
	//但是不能单纯的理解为数组，这里的"hello world"是存放代码区中的不可修改，是常量字符串，所以我们在前面加了const修饰
	printf("%s\n",str);
	return 0;
}
指针
指针

本质就是把常量字符串hello world的首元素的地址放到了str当中，也就是将常量字符串的首元素h的地址放到str中 练习

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	char str1[] = "hello world";
	char str2[] = "hello world";

	const char* str3 = "hello bit";
	const char* str4 = "hello bit";

	if(str1==str2)
		printf("same\n");
	else
		printf("not same\n");
	if(str3==str4)
		printf("same\n");
	else
		printf("not same\n");
	return 0;
}

//打印结果：
/*
not same
same
*/

这里比较的都是地址。 str1和str2都是数组，当用相同的常量字符串去初始化不同的数组的时候就会开辟不同的空间。而str3和str4指向的同一个常量字符串。在c/c++中会把常量字符串单独存储在一个内存区域（代码段），当我们用几个指针去指向同一个字符串时，它们实际会指向同一块内存的。 可以这么理解：str1和str2是可以修改数组中的元素的，如果不同数组间的修改会相互影响，那岂不是乱遭了。而str3和str4是不可以被修改的，那么让它们两指向同一块空间也是完全没有问题的。

9.指针数组

指针数组就是存放指针的数组。 我们可以进行类比： 整型数组是存放整型的数组，字符数组是存放字符的数组。那么指针数组肯定就是存放指针的数组咯。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int* arr1[10];//整型指针的数组
char* arr2[4];//一级字符指针数组
char** arr3[10];//二级字符指针数组

10.数组指针

10.1 数组指针的定义

我们知道整型指针是指向整型的指针（存放整型变量的地址的指针变量） 还有字符指针是指向字符的指针（存放字符变量的地址的指针变量） 如此类比的话 数组指针就是指向数组的指针（存放数组变量的地址的指针变量） 数组指针的正确写法

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int *p1[10];//错
int (*p2)[10];//对
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int (*p)[10];
//p与*结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//加（）的原因是因为，根据操作符的优先性，[]的优先级是要高于*的，为了保证*与p的结合需要添加括号

10.2 &数组名与数组名

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int arr[10];

arr与&arr分别是什么呢？ arr是数组名，数组名又表示数组首元素的地址。 &arr表示的整个数组的地址。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10];
	printf("%p\n",arr);
	printf("%p\n",&arr);
	return 0;
}
//打印结果：
/*
00DCFBDC
00DCFBDC
*/

打印它们的地址可以发现是一样的。但其实又不完全一样。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10];
	printf("%p\n",arr);
	printf("%p\n",arr+1);
	
	printf("%p\n",&arr);
	printf("%p\n",&arr+1);
	return 0;
}
//打印结果：
/*
004FF970
004FF974
004FF970
004FF998
*/

arr+1跳过的4个字节的地址。而&arr跳过的是40个字节的地址。 正如前面所说&arr是整个数组的地址，整个数组大小就是40个字节。 本例中&arr的类型就是int(*)[10],是一种数组指针类型。 数组地址+1，跳过整个数组的大小，所以&arr+1相对于&arr的差值就是40.

10.3 数组指针的使用

了解到数组指针指向的数组，那么数组指针中存放的就是数组的地址。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
	int(*p)[10] = &arr;
	//把整个数组的地址存放在数组指针变量当中
	//但是很少这么写
	return 0;
}

数组指针的使用

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
void print1(int arr[3][5],int row,int col)
{
	for(int i = 0;i<row;++i)
	{
		for(int j = 0;j<col;++j)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int (*arr)[5],int row,int col)
{
	for(int i = 0;i<row;++i)
	{
		for(int 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,0};
	print1(arr,3,5);
	//arr是数组的数组名，表示数组首元素的地址。而这又是一个二维数组，二维数组的首元素地址就是第一行的地址，所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址，可以利用数组指针接收。
	print2(arr,3,5);
	
	return 0;
}

区分

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int arr[5];//整型数组
int* parr1[10];//整型指针数组
int (*parr2)[10];//数组指针
int (*parr3[10])[5];//数组指针数组

11.数组传参、指针参数

在写代码时不可避免的要把【数组】或者【指针】传递给函数，那么函数的参数设计要怎么做呢？

11.1 一维数组传参

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
void test(int arr[])//可行,最容易理解的写法（[]内的数字可以随便写，不影响系统的判断）该传参的本质就是int* arr
{}
void test(int arr[10])//可行，最容易理解的写法。（[]内的数字可以随便写，不影响系统的判断）该传参的本质就是int* arr
{}
void test(int* arr)//可行，实参传递的是arr代表数组首元素的地址，利用整型指针接收合情合理
{}
void test2(int *arr[20])//可行，本质是int** arr
{}
void test2(int **arr)//可行，实参传递的是arr2也代表首元素的地址，因为arr2是指针数组，一维指针的地址要有二级指针接收，合情合理
{}

int main()
{
	int arr[10] = {0};
	int* arr2[20] = {0};
	test(arr);
	test2(arr2);
	return 0;
}

11.2 二维数组传参

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#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);
	return 0;
}

11.3 一级指针传参

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
void print(int* arr,int sz)
{
	for(int i = 0;i<sz;++i)
	{
		printf("%d ",*(arr+i));
	}
}
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
	int sz = 10;
	int* p = arr;
	print(arr,sz);
	return 0;
}
//打印结果：1 2 3 4 5 6 7 8 9 0

当函数的参数部分为1级指针的时候，函数能接受的的参数为该一级指针对应类型的地址。

11.4 二级指针传参

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#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;
}

当函数的参数部分为二级指针的时候，函数能接受的的参数为该二级指针对应一级指针类型的地址。

12.函数指针

其实函数也是有地址的。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
void test()
{
	printf("hello\n");
}
int main()
{
	printf("%p\n",test);
	printf("%p\n",&test);
	return 0;
}
//打印结果
/*
00A41267
00A41267
*/

从这里可以看出，函数不仅有地址，而且函数的函数名就代表了函数的地址，&函数名同样也表示函数的地址。 既然函数有地址，那么也就说明可以利用变量来存储。这个存储函数地址的变量就是函数指针。 函数指针的正确写法

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
void test()
{
	printf("hello\n");
}
int main()
{
	void (*pf1)() = test;//正确写法
	void *pf2() = test;//错误写法
	return 0;
}

pf1可以存储，和数组指针类似，这里的*要先和pf1结合，确定pf1是一个指针，()的优先级有比较高。因此需要用()将*pf1括起来。pf1指向的是一个函数，指向函数无参数，返回类型为void。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int Add(int x,int y)
{
	return x+y;
}
int main()
{
	int (*pf)(int int) = Add//指向有参数的函数指针
	return 0;
}

练习

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
//代码1
(*(void(*)())0)();
/*
解释：
先看void(*)()这是一个函数指针类型。再往外看，这个函数指针类型被括号括住了(void(*)())
一个类型被（）住就是表示强制类型转换的意思。也是说明0被强制类型转换成了函数指针类型。然后*表示对一个函数指针类型进行解引用取出指向的函数*(void(*)())0，最后再调用这个函数。
总结：调用0地址处的函数（实际是无法调用的）
*/

//代码2
void (*signal(int,void(*)(int)))(int);//signal为函数名
/*
解释：signal是函数名，那signal（）中的就是函数的参数类型，类型分别为整型和函数指针类型，现在一个函数有了函数名和函数的参数，就差函数的返回类型，如果我们把signal(int,void(*)(int))删除就得到了void (*)(int)这不就是函数指针类型吗，那也就是说signal的函数的返回类型就是void(*)(int)
总结：这是一个函数的声明，找到其函数参数和函数返回类型就可以了。
*/

简化代码2

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
typedef void (*pf)(int);
pf signal (int,pf);//利用typedef将类型重命名，来简化代码

13.函数指针数组

数组是存放相同类型数据的存储空间 前面我们已经学习了指针数组

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int* arr[10];
//数组的每个元素类型是int*

同样的我们也可以把函数指针存放进数组，就叫做函数指针数组，那函数指针数组的是如何定义的呢？

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int (*pf)();//这是一个函数指针
//我们将[]添加到变量名后面就可以了
int (*pf[10])();//这就是函数指针数组

pf先[]结合说明pf是一个数组，然后数组存放的类型就是int(*)()。 函数指针数组的运用 下面以实现一个简单的计算器为例

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#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 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 input = 0;
	int a = 0,b = 0;
	int ret = 0;
	do
	{
		menu();
		printf("选择你所要用到的功能>\n");
		scanf("%d",&input);
		switch(input)
		{
			case 1:
				printf("请输入两数>");
				scanf("%d %d",&a,&b);
				ret = Add(a,b);
				printf("ret = %d\n",ret);
				break;
			case 2:
				printf("请输入两数>");
				scanf("%d %d",&a,&b);
				ret = Sub(a,b);
				printf("ret = %d\n",ret);
				break;
			case 3:
				printf("请输入两数>");
				scanf("%d %d",&a,&b);
				ret = Mul(a,b);
				printf("ret = %d\n",ret);
				break;
			case 4:
				printf("请输入两数>");
				scanf("%d %d",&a,&b);
				ret = Div(a,b);
				printf("ret = %d\n",ret);
				break;
			case 0:
				printf("退出\n");
				break;
			default:
				printf("输入错误\n");
				break;
		}
	}while(input);
	return 0;
}

这样写的话其实是很繁琐的。实现这种简单的功能都写了这么长的代码，而且如果后续在添加什么函数功能的话，代码又要增加好的。所以我们要简化。 通过观察，这4个函数的参数和返回类型都是相同的，那么不就说明了可以写成函数指针数组吗。数组中存放这个函数指针类型就可以了。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#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 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 input = 0;
	int a = 0,b = 0;
	int ret = 0;
	do
	{
		menu();
		printf("选择你所要用到的功能>\n");
		scanf("%d",&input);
		int(*pf[5])(int,int) = {NULL,Add,Sub,Mul,Div};//存入NULL是为了可以和菜单对应
		if(input>0&&input<5)
		{
			printf("请输入两数>");
			scanf("%d %d",&a,&b);
			ret = pf[input](a,b);
			printf("ret = %d\n",ret);
		}
		else if(input == 0)
			printf("退出\n");
		else
			printf("输入有误\n");
	}while(input);
	return 0;
}

利用函数指针数组我们将该程序充分简化，而且如果后续还要添加类似的函数功能的话，我们只需要将新写的函数添加进数组，在改变一下判断条件即可。

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

指向函数指针数组的指针是一个指针。 指针指向一个数组，数组的元素都是函数指针；

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
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的指针ppfunarr
	void(*(*ppfunarr)[5])(const char*) = &pfunarr;
}

还可以再绕下去的

15.回调函数

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

首先演示一下qsort函数的使用：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
//对整型数组进行排序
#include<stdio.h>
int int_cmp(const void* a,const void* b)
{
	return (*(int*)a) - (*(int*)b);
}
int main()
{
	int arr[10] = {1,3,5,7,9,2,4,6,8,0};
	qsort(arr,10,sizeof(int),int_cmp);
	for(int i = 0;i<10;++i)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
	return 0;
}
//打印结果：
//0 1 2 3 4 5 6 7 8 9

//对结构体数组进行排序
#include <stdio.h>
#include <string.h>
struct stu
{
	int age;
	char name[10];
};
int struct_cmp_age(const void* a, const void* b)//利用年龄排序
{
	return ((struct stu*)a)->age - ((struct stu*)b)->age;
}
int struct_cmp_name(const void* a, const void* b)//利用名字排序，因为字符串无法相减
//所以这里利用了strcmp进行字符串的比较
{
	return strcmp(((struct stu*)a)->name,((struct stu*)b)->name);
}
int main()
{
	struct stu s[3] = { {17,"yui"},{14,"anna"},{20,"hua"} };
	qsort(s, 3, sizeof(s[0]), struct_cmp_age);
	printf("调用struct_cmp_age\n");
	for (int i = 0; i < 3; ++i)
	{
		printf("%d %s\n", s[i].age, s[i].name);
	}
	qsort(s, 3, sizeof(s[0]), struct_cmp_name);
	printf("调用struct_cmp_name\n");
	for (int i = 0; i < 3; ++i)
	{
		printf("%d %s\n", s[i].age, s[i].name);
	}
	return 0;
}
//打印结果：
/*
调用struct_cmp_age
14 anna
17 yui
20 hua
调用struct_cmp_name
14 anna
20 hua
17 yui

*/

qsort 打开cplusplus网站->qsort

qsort
qsort
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
void qsort(void* base,//需要排序的数组首元素地址
		  size_t num,//需要排序的数组的元素个数
		  size_t size,//需要排序数组的单个元素的大小
		  int (*compar)(const void*,const void*)//传递函数指针，需要自己写
		  }

可以看到的时，这里接受数组首元素的地址是用void*来接收。 提问：为什么呢？ 回答：Void*指针 是无具体类型的指针。Void* 类型的指针可以接任意类型的地址（这种类型的指针是不能直接解引用操作的，也不能直接进行指针运算的）。 所以用void*接收是没问题的。然后，这个qsort函数不仅可以对整型数组排序，还可以对字符数组，浮点型数组，甚至是结构体数组。这也就造成了不能使用特定类型指针来接收的情况，如果使用了特定的类型，那其它类型就不能被接收了，所以才会选择使用void*来接收。 模拟实现qsort，但是因为目前还没有学快速排序，所以这里我们利用冒泡排序替代。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
//主要逻辑
void swap(char* a, char* b, int size)
{
	char tmp = 0;
	for (int i = 0; i < size; ++i)//交换的实质其实就是指针所指向内容的交换.
	//因为char只能指向一个字节，所以我们需要传递size了解到要交换的字节大小，然后一个字节一个字节的交换。
	{
		tmp = *a;
		*a = *b;
		*b = tmp;
		a += 1;
		b += 1;
	}
}
void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	for (int i = 0; i < num - 1; ++i)
	{
		for (int j = 0; j < num - i - 1; ++j)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)//因为void类型的指针是不能直接解引用操作的，也不
			//能直接进行指针运算的。为了拿到比较位置的地址，我们需要将base强转为（char*），因为char*的加减整数时只会跳过一个字节，
			//这是最小的位移距离了。所以我们可以通过强转后的base拿到base[j]和base[j+1]的地址进行比较。
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);//开始交换
			}
		}
	}
}

测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <string.h>
struct stu
{
	int age;
	char name[10];
};
int int_cmp(const void* a, const void* b)
{
	return (*(int*)a) - (*(int*)b);
}
int struct_cmp_age(const void* a, const void* b)//利用年龄排序
{
	return ((struct stu*)a)->age - ((struct stu*)b)->age;
}
int struct_cmp_name(const void* a, const void* b)//利用名字排序，因为字符串无法相减
//所以这里利用了strcmp进行字符串的比较
{
	return strcmp(((struct stu*)a)->name,((struct stu*)b)->name);
}
void swap(char* a, char* b, int size)
{
	char tmp = 0;
	for (int i = 0; i < size; ++i)//交换的实质其实就是指针所指向内容的交换，因为char只能指向一个字节，所以我们需要传递size了解到要交换的字节大小，然后一个字节一个字节的交换。
	{
		tmp = *a;
		*a = *b;
		*b = tmp;
		a += 1;
		b += 1;
	}
}
void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	for (int i = 0; i < num - 1; ++i)
	{
		for (int j = 0; j < num - i - 1; ++j)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)//因为void类型的指针是不能直接解引用操作的，也不能直接进行指针运算的。为了拿到比较位置的地址，我们需要将base强转为（char*），因为char*的加减整数时只会跳过一个字节，这是最小的位移距离了。所以我们可以通过强转后的base拿到base[j]和base[j+1]的地址进行比较。
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int arr[10] = { 1,3,5,7,9,2,4,6,8,0 };
	bubble_sort(arr, 10, sizeof(int), int_cmp);//冒泡排序
	printf("对arr排序:\n");
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	struct stu s[3] = { {17,"yui"},{14,"anna"},{20,"hua"} };
	bubble_sort(s, 3, sizeof(s[0]), struct_cmp_age);
	printf("调用struct_cmp_age:\n");
	for (int i = 0; i < 3; ++i)
	{
		printf("%d %s\n", s[i].age, s[i].name);
	}
	bubble_sort(s, 3, sizeof(s[0]), struct_cmp_name);
	printf("调用struct_cmp_name:\n");
	for (int i = 0; i < 3; ++i)
	{
		printf("%d %s\n", s[i].age, s[i].name);
	}
	return 0;
}
//打印结果：
/*
对arr排序:
0 1 2 3 4 5 6 7 8 9
调用struct_cmp_age:
14 anna
17 yui
20 hua
调用struct_cmp_name:
14 anna
20 hua
17 yui
*/

16. 练习

数组名的意义：

1.sizeof(数组名)，这里的数组表示整个数组，计算的整个数组的大小 2.&数组名，这里的数组名表示整个数组的，取出的是整个数组的地址 3.除此之外所有的数组名都是表示首元素的地址。

16.1一维数组

16.1.1 整型数组
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
int main()
{
	int a[] = {1,2,3,4};
	printf("%d\n",sizeof(a));//16,sizeof单独加上数组名计算的是整个数组的大小
	printf("%d\n",sizeof(a+0));//4或者8，这里数组名不是单独在sizeof内，所以会变成数组首元素的地址，而指针的大小根据选择的是32位还是64位而不同。
	printf("%d\n",sizeof(*a));//4，a是首元素的地址，被解引用后就是首元素。整型为4个字节大小
	printf("%d\n",sizeof(a+1));// 4/8，表示数组第二个元素的地址
	printf("%d\n",sizeof(a[1]));//4，表示数组第一个元素是整型
	printf("%d\n",sizeof(&a));// 4/8，&数组名拿到是整个数组的地址，而整个数组的地址也是指针，所以大小还是4或者8
	printf("%d\n",sizeof(*&a));//16，取地址和解引用相互抵消，使得本质上是sizeof（a）
	printf("%d\n",sizeof(&a[0]));//4/8，计算的数组首元素的地址，也就是指针
	printf("%d\n",sizeof(&a[0]+1));//4/8，计算的是数组第二个元素的地址，也就是指针
	return 0;
}
//打印结果
/*
16
8
4
8
4
8
16
8
8
*/
16.1.2 字符数组
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	char arr[] = {'a','b','c','d','e','f'};
	printf("%d\n",sizeof(arr));
	printf("%d\n",sizeof(arr+1));
	printf("%d\n",sizeof(arr+0));
	printf("%d\n",sizeof(*arr));
	printf("%d\n",sizeof(arr[1]));
	printf("%d\n",sizeof(&arr));
	printf("%d\n",sizeof(&arr+1));
	printf("%d\n",sizeof(&arr[0]+1));
	return 0;
	//与上面解释类似
}
//打印结果：
/*
6
8
8
1
1
8
8
8
*/
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = {'a','b','c','d','e','f'};
	printf("%d\n",strlen(arr));//随机值，表示的是从数组的首元素开始计算直到碰到'\0'为止的长度
	printf("%d\n",strlen(arr+0));//随机值，表示的是从数组的首元素开始计算直到碰到'\0'为止的长度
	printf("%d\n",strlen(*arr));//错误写法，strlen函数参数要传地址
	printf("%d\n",strlen(arr[1]));//错误写法，strlen函数参数要传地址
	printf("%d\n",strlen(&arr));/*随机值，虽然&arr表示的是整个数组的地址，但是整个数组的地
	址依旧是用数组首元素的地址代表。表示的是从数组的首元素开始计算直到碰到'\0'为止的长度*/
	printf("%d\n",strlen(&arr+1));//随机值，表示的是从数组的最后一个元素后的地址开始计算直到碰到'\0'为止的长度。会比第一个随机值数少6个字节
	printf("%d\n",strlen(&arr[0]+1));//随机值，表示从数组第二个元素地址开始计算直到碰到'\0'为止的长度。会比第一个随机值数少1个字节
	
	return 0;
}
//打印结果：
/*（注释掉错误写法后）
42
42
42
36
41
*/
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n",sizeof(arr));
	printf("%d\n",sizeof(arr+1));
	printf("%d\n",sizeof(arr+0));
	printf("%d\n",sizeof(*arr));
	printf("%d\n",sizeof(arr[1]));
	printf("%d\n",sizeof(&arr));
	printf("%d\n",sizeof(&arr+1));
	printf("%d\n",sizeof(&arr[0]+1));
	//整体解释和第一道题类型，不过要注意的是sizeof会计算隐藏的'\0'的大小。
	return 0;
}
//打印结果：
/*
7
8
8
1
1
8
8
8
*/
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n",strlen(arr));//6，该数组arr最后隐藏了一个'\0'，strlen计算到'\0'为止
	printf("%d\n",strlen(arr+0));//6，该数组arr最后隐藏了一个'\0'，strlen计算到'\0'为止
	printf("%d\n",strlen(*arr));//错误写法，strlen函数参数要传地址
	printf("%d\n",strlen(arr[1]));//错误写法，strlen函数参数要传地址
	printf("%d\n",strlen(&arr));//6，&arr虽然表示整个数组的地址，但是地址是用数组首元素地址来代表的。
	printf("%d\n",strlen(&arr+1));//随机值，&arr表示整个数组的地址，+1跳过整个数组，也跳过了'\0'，直到找到后面的'\0'才会停止
	printf("%d\n",strlen(&arr[0]+1));//5，表示从数组的第二的元素地址开始往后计算长度。	
	return 0;
}
//打印结果
/*（注释掉错误写法后）
6
6
6
26
5
*/
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	char* arr = "abcdef";
	printf("%d\n",sizeof(arr));//4/8,这里的arr不能等同于数组，arr就是指针，这个指针指向了"abcdef"这个常量字符串
	printf("%d\n",sizeof(arr+1));//4/8，arr+1就表示该常量字符串第二个元素的地址
	printf("%d\n",sizeof(*arr));//1，对指针解引用得到的就是首元素'a'，类型char大小为1字节。
	printf("%d\n",sizeof(arr[0]));//1，arr[0]数组首元素'a'
	printf("%d\n",sizeof(&arr));//4/8，&arr表示arr的地址也就是一个二级指针
	printf("%d\n",sizeof(&arr+1));//4/8，&arr+1也是二级指针，
	printf("%d\n",sizeof(&arr[0]+1));//4/8，表示第二个元素'b'的地址
	return 0;
}
//打印结果：
/*
8
8
1
1
8
8
8
*/
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
#include <string.h>
int main()
{
	char* arr = "abcdef";
	printf("%d\n",strlen(arr));//6，arr存放的就是首元素的地址
	printf("%d\n",strlen(arr+1));//5，传入第二个元素的地址
	printf("%d\n",strlen(*arr));//错误写法，strlne必须传地址进去
	printf("%d\n",strlen(arr[0]));//错误写法，strlne必须传地址进去
	printf("%d\n",strlen(&arr));//随机值，&arr是首元素'a'地址的地址，是一个二级指针，会一直找到下一个'\0'为止。
	printf("%d\n",strlen(&arr+1));//随机值，是一个二级指针(不一定在&arr后面)，会一直找到下一个'\0'为止。
	printf("%d\n",strlen(&arr[0]+1));//5，传入第二个元素的地址
	return 0;
}
//打印结果：
/*（注释掉错误写法后）
6
5
3
11
5
*/

16.2 二维数组

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
int main()
{
	int a[3][4] = {0};
	printf("%d\n",sizeof(a));//48,sizeof(数组名)计算的整个数组的大小
	printf("%d\n",sizeof(a[0][0]));//4，a[0][0]就是首元素
	printf("%d\n",sizeof(a[0]));//16，a[0]是第一行这个一维数组的数组名
	//数组名算是单独放在sizeof内部了，计算的是整个数组的大小，大小是16个字节
	printf("%d\n",sizeof(a[0]+1));//4/8，a[0]是第一行数组名，+1就不算单独放到sizeof中了。
	printf("%d\n",sizeof(*(a[0]+1)));//4，相当于a[0][1],拿到了数组第1行第2列的元素
	printf("%d\n",sizeof(a+1));// 4/8，数组名除俩个的特殊情况外都是数组首元素的地址，
	//这里加1拿到就是第二行的地址，是指针
	printf("%d\n",sizeof(*(a+1)));//16，相当于a[1],计算的第二行的大小
	printf("%d\n",sizeof(&a[0]+1));//4/8，&a[0]+1,a[0]相当于第一行的数组名，&a[0]就是第一行数组的地址，加1跳过第一行，就是第二行数组的地址，是指针。
	printf("%d\n",sizeof(*(&a[0]+1)));//16,计算的是第二行的大小，&a[0]拿到第一行的地址，然后+1拿到第2行的地址，再解引用拿到就是第二行了。
	printf("%d\n",sizeof(*a));//16，a表示的一行的地址，*a就是拿到第一行，
	printf("%d\n",sizeof(a[3]));//16，虽然数组越界了但是，在sizeof的执行过程中是不会使用a[3]的，sizof(a[3])会把a[3]理解为第4行的数组名,
	return 0;
}
//打印结果:
/*
48
4
16
8
4
8
16
8
16
16
16
*/

16.3 指针笔试题

16.3.1 练习1
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.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,5
/*
解释：&a拿到的是整个数组的地址，加1后跳过整个数组来到数组最后一个元素后面。也就说明了ptr的指向的地址再5的地址的后面，然后强制类型转换成整型指针，而整型指针-1只会前移动4个字节，ptr会指向5的地址。而a是数组名，表示数组首元素的地址，+1后就来到了第二个元素的地址。
*/
指针的指向
指针的指向
3.2 练习2
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <stdio.h>
//这个结构体的大小是20个字节
struct test
{
	int Num;
	char* pcname;
	short sdata;
	char cha[2];
	short sba[4];
}*p = (struct Test*)0x100000;
//假设p的值为0x100000.
//已知test结构体的大小是20个字节
int main()
{
	printf("%p\n",p+0x1);
	printf("%p\n",(unsigned long)p+0x1);
	printf("%p\n",(unsigned long*)p+0x1);
	return 0;
}
//打印结果：
/*
00100014
00100001
00100004
*/
/*
解释：这里p指向的地址是0x100000。0x1就是1的16进制表达。p加1，因为p指向类型是struct test，类型大小20个字节，加1后也会跳过20这个字节（转换成16进制就是14）.
后面p指针被强制类型转换成了一个无符号长整形的变量，这个类型不是指针变量，加1就是整数加1.
最后一个强制类型转换成了一个无符号长整形指针变量，是指针，然后无符号长整形的大小是4个字节，加1也就是跳过4个字节。
*/
3.3 练习3
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#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);//%x为16进制打印
	return 0;
}
//打印结果：4,2000000
/*
解释放下面
*/

ptr1：&a+1表示的跳过这个数组后的地址，也就是4后面的地址，然后被强制类型转换为了int* ptr2：a是数组首元素的地址，都是被强制类型转换为了整型，然后+1，因为是整型加1就是数字加1.然后又被强制类型转换成了int*。 此时的指向如图所示

指针的指向
指针的指向

因为元素在系统当中是小端存储的， 1会被存储为：01 00 00 00 此时ptr2指向的就是01后面00的位置。 我们又知道数组中1的后面是2。 小端存储就是 01 00 00 00 02 00 00 00 ptr2被强制类型转换为了int*，解引用会一次取出4个字节，取出的就是00 00 00 02，将顺序反转成正常顺序就是02000000，打印时省略掉了第一个0变成了200000 ptr1[-1]的意思就是*(prt1-1).就拿出来4.

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2024-08-22，如有侵权请联系 cloudcommunity@tencent.com 删除
int
变量
函数
数组
指针

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

int
变量
函数
数组
指针
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
BATJ面试必会之Java IO 篇
文件存储javasocket编程自动驾驶编程算法
实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
乔戈里
2019/03/10
5880
Java NIO深入理解ServerSocketChannel
自动驾驶javasocket编程
JAVA NIO有两种解释：一种叫非阻塞IO（Non-blocking I/O），另一种也叫新的IO（New I/O），其实是同一个概念。它是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。
用户1251985
2019/07/02
1.5K0
Java NIO深入理解ServerSocketChannel
Java面试必问通信框架NIO，原理详解
java
新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
李红
2019/05/31
1.3K0
Java面试必问通信框架NIO，原理详解
java——IO与NIO
ionio模型数据java
Java中的IO（输入输出）是用于在程序中读取和写入数据的一种机制。Java提供了两种不同的IO模型：传统的IO模型和NIO（New IO）模型。
一只
2024/07/05
1240
java——IO与NIO
NIO 和 IO 到底有什么区别？别说你不会！
自动驾驶socket编程编程算法java
通道是对原 I/O 包中的流的模拟。到任何目的地(或来自任何地方)的所有数据都必须通过一个 Channel 对象（通道）。
Java技术栈
2020/03/17
1.3K0
NIO 和 IO 到底有什么区别？别说你不会！
Java进阶 | IO流核心模块与基本原理
api自动驾驶文件存储
IO技术在JDK中算是极其复杂的模块，其复杂的一个关键原因就是IO操作和系统内核的关联性，另外网络编程，文件管理都依赖IO技术，而且都是编程的难点，想要整体理解IO流，先从Linux操作系统开始。
知了一笑
2021/07/29
3490
NIO
笔记
详细知识参考我有道云笔记 package com.shi.nio; import java.nio.ByteBuffer; /** * * @author shiye * 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据 * * 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区： * ByteBuffer * CharBuffer * ShortBuffer * IntBuffer * LongBuf
用户5927264
2019/10/15
7510
【面试题精讲】javaIO模型之NIO
nio连接模型数据线程
NIO（New I/O）是Java提供的一种非阻塞I/O模型，它在JDK 1.4中引入。与传统的I/O模型相比，NIO提供了更高效、更灵活的I/O操作方式。
程序员朱永胜
2023/10/22
2220
Java IO 与 NIO：高效的输入输出操作探究
java面试
输入输出（IO）是任何编程语言中的核心概念，而在Java中，IO操作更是应用程序成功运行的基石。随着计算机系统变得越来越复杂，对IO的要求也日益增加。在本文中，我们将探讨Java IO和非阻塞IO（NIO）的重要性以及如何在Java中实现高效的输入输出操作。
程序那些事
2023/10/17
2590
Java NIO与IO 区别和比较
java
NIO包（java.nio.*）引入了四个关键的抽象数据类型，它们共同解决传统的I/O类中的一些问题。
IT工作者
2022/03/30
2160
NIO~~
自动驾驶java编程算法socket编程
NIO 有三大核心部分：Channel( 通道) ，Buffer( 缓冲区), Selector( 选择器)
大忽悠爱学习
2022/05/06
9150
NIO~~
Java I/O不迷茫，一文为你导航！
其他
学习过计算机相关课程的童鞋应该都知道，I/O 即输入Input/ 输出Output的缩写，最容易让人联想到的就是屏幕这样的输出设备以及键盘鼠标这一类的输入设备，其广义上的定义就是：数据在内部存储器和外部存储器或其他周边设备之间的输入和输出；
我没有三颗心脏
2018/09/14
5410
Java I/O不迷茫，一文为你导航！
java NIO浅析
自动驾驶socket编程java
NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区)，Selector(选择器)。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。
Java阿呆
2020/11/04
7080
java NIO浅析
彻底搞懂高性能I/O之道
自动驾驶编程算法缓存socket编程java
本文介绍操作系统I/O工作原理，Java I/O设计，基本使用，开源项目中实现高性能I/O常见方法和实现，彻底搞懂高性能I/O之道
用户1260737
2019/11/15
1.2K0
NIO最全教程，看这一篇就够了
javaspringspring bootspring cloud
Java NIO（New IO 或 Non Blocking IO）是从 Java 1.4 版本开始引入的一个新的 IO API，可以替代标准的 Java IO API。NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。
公众号 IT老哥
2020/09/16
6890
NIO最全教程，看这一篇就够了
java的IO模型
自动驾驶socket编程tcp/ip
本文主要是重新梳理了Java的IO模型，基于之前NIO的文章进行补充，为学习Netty做准备。
贪挽懒月
2020/07/14
7360
Netty系列| Netty创始人告诉你为什么选择NIO
自动驾驶socket编程java
NIO模型 同步非阻塞 NIO有同步阻塞和同步非阻塞两种模式，一般讲的是同步非阻塞，服务器实现模式为一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
狼王编程
2021/06/01
1.3K0
Netty系列| Netty创始人告诉你为什么选择NIO
NIO详解
事件数据线程nio客户端
NIO (New lO)也有人称之为java non-blocking lO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。
冬天vs不冷
2025/01/21
1870
NIO详解
Java NIO？看这一篇就够了！
socket编程自动驾驶
✎前言 现在使用NIO的场景越来越多，很多网上的技术框架或多或少的使用NIO技术，譬如Tomcat，Jetty。学习和掌握NIO技术已经不是一个JAVA攻城狮的加分技能，而是一个必备技能。在前面2篇文
方志朋
2019/06/21
1.1K0
Java NIO？看这一篇就够了！
为什么一个还没毕业的大学生能够把 IO 讲的这么好？
自动驾驶java编程算法
Java IO 是一个庞大的知识体系，很多人学着学着就会学懵了，包括我在内也是如此，所以本文将会从 Java 的 BIO 开始，一步一步深入学习，引出 JDK1.4 之后出现的 NIO 技术，对比 NIO 与 BIO 的区别，然后对 NIO 中重要的三个组成部分进行讲解（缓冲区、通道、选择器），最后实现一个简易的客户端与服务器通信功能。
cxuan
2020/09/14
6140
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
相关讨论
Bugly全量更新后台策略各种操作失败？Bugly全量更新？Bugly全量更新失败？
相关课程
腾讯云向量数据库-RAG七天入门训练营云开发微搭低代码平台-一人构建企业级应用实战训练营TDSQL for PG训练营
BATJ面试必会之Java IO 篇
5880
Java NIO深入理解ServerSocketChannel
1.5K0
Java面试必问通信框架NIO，原理详解
1.3K0
java——IO与NIO
1240
NIO 和 IO 到底有什么区别？别说你不会！
1.3K0
Java进阶 | IO流核心模块与基本原理
3490
NIO
7510
【面试题精讲】javaIO模型之NIO
2220
Java IO 与 NIO：高效的输入输出操作探究
2590
Java NIO与IO 区别和比较
2160
NIO~~
9150
Java I/O不迷茫，一文为你导航！
5410
java NIO浅析
7080
彻底搞懂高性能I/O之道
1.2K0
NIO最全教程，看这一篇就够了
6890
java的IO模型
7360
Netty系列| Netty创始人告诉你为什么选择NIO
1.3K0
NIO详解
1870
Java NIO？看这一篇就够了！
1.1K0
为什么一个还没毕业的大学生能够把 IO 讲的这么好？
6140
相关推荐
BATJ面试必会之Java IO 篇
更多 >
默 语0
LV.1
架构师国家电网
文章
995
获赞
959
排名
622
专栏
2
目录
  • 1.什么是指针
  • 2.指针和指针类型
    • 2.1 指针±整数
    • 2.2 指针的解引用
  • 3.野指针
    • 3.1为什么会有野指针
    • 3.2 如何规避野指针
  • 4.指针运算
    • 4.1 指针±整数
    • 4.2 指针减指针
    • 4.3 指针的关系运算
  • 5.指针与数组
  • 6.二级指针
  • 7.指针数组
  • 8.字符指针
  • 9.指针数组
  • 10.数组指针
    • 10.1 数组指针的定义
    • 10.2 &数组名与数组名
    • 10.3 数组指针的使用
  • 11.数组传参、指针参数
    • 11.1 一维数组传参
    • 11.2 二维数组传参
    • 11.3 一级指针传参
    • 11.4 二级指针传参
  • 12.函数指针
  • 13.函数指针数组
  • 14.指向函数指针数组的指针
  • 15.回调函数
  • 16. 练习
    • 16.1一维数组
      • 16.1.1 整型数组
      • 16.1.2 字符数组
    • 16.2 二维数组
    • 16.3 指针笔试题
      • 16.3.1 练习1
      • 3.2 练习2
      • 3.3 练习3
加入讨论
的问答专区 >
王新栋0
相关课程
一站式学习中心 >
腾讯云向量数据库-RAG七天入门训练营
2128人在学
向量数据库
腾讯云安灯
云开发微搭低代码平台-一人构建企业级应用实战训练营
1917人在学
腾讯云微搭低代码
云开发
TDSQL for PG训练营
181人在学
分布式数据库 TDSQL
数据库
云数据库 PostgreSQL
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
1