iis服务器助手广告广告
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C语言学习之指针的使用详解
  • 702
分享到

C语言学习之指针的使用详解

C语言指针使用C语言指针 2022-11-13 18:11:09 702人浏览 八月长安
摘要

目录一、指针概念1.指针变量2.指针类型3.二级指针二、野指针1.野指针成因2.规避野指针三、指针运算1.指针±整数2.指针-指针3.指针关系运算四、指针数组1.指针和

一、指针概念

学习指针之前我们先要了解一下内存,内存是存储区域,我们可以把内存划分成一个一个的内存单元,最小的内存单元是字节

计算机将数据存储在内存中,而为了能够快速查找到所需数据,计算机会将内存进行编号,通过查找编号,可以快速查找到数据。指针是内存中一个最小单元的编号,内存单元的编号也被称为地址,指针就是地址。

平时我们说的指针通常指的是指针变量,是用来存放内存地址的变量

1个字节(byte)=8个bit(bit即比特位,由0和1组成)

在32位的机器上(X86环境),地址是32个0或者1组成二进制序列,那地址就得用4个字节的空间来存储,所以一个指针变量的大小就应该是4个字节。在64位的机器上(X64环境),地址是64个0或者1组成二进制序列,那地址就得用8个字节的空间来存储,所以一个指针变量的大小是8个字节。

无论何种数据类型的指针,指针的大小在32位(X86环境)平台下是4个字节,在64位(X64环境)平台下是8个字节。

1.指针变量

我们可以通过&(取地址操作符)取出变量的内存起始地址,把地址可以存放到一个变量中,这个变量就是指针变量。

*(解引用操作符又叫间接访问操作符):对指针变量进行解引用操作,通过指针变量里面的地址找到指向的内容。

#include <stdio.h>
int main()
{
	int  a = 20;
	char ch;
	int* pa = &a;//a向内存申请了4个字节的空间,所以&a的时候应该拿出第1个字节的地址
	//拿出a的第1个字节的地址放在整型指针变量pa里
	char* pc = &ch;//拿出ch的地址放在字符指针变量pc里
	printf("%p\n",&a);//%p打印的是地址
	//printf("%p\n",pa);打印出来的地址和&a打印出来的一样
	printf("%p\n",&ch);
	return 0;
}

指针变量是用来存放地址的变量,存放在指针变量中的值都被当成地址处理,同时地址是唯一标识一个内存单元的

2.指针类型

指针的类型根据你所需要的数据类型进行使用,如

  • //char* pc;指针类型是char*
  • // char** pcc;指针类型是char**
  • //int* pa;指针类型是int*
  • // double* pd;指针类型是double*
  • // …

但是要注意区分指针指向的类型和指针类型之间的区别

  • // char* pc;其中* 指pc是指针,指向的类型是char
  • // char** pcc;其中* 指pcc是指针,指向的类型是char*
  • // int* pa* 指pa是指针,指向的类型是int
  • // double* pd* 指pd是指针,指针指向的类型是double
  • // …

指针类型决定了指针进行解引用操作时访问几个字节

char* 类型的指针解引用访问1个字节;

int* 类型的指针解引用访问4个字节;

double* 类型的指针解引用访问8个字节;

例1:

#include <stdio.h>
int main()
{
	int a = 0x11223344;//用16进制表示
	int* pa = &a;
	*pa = 0;
	return 0;
}

上述代码在VS(小端存储)调试过程中,&a在内存中显示的是

执行完*pa=0;后,&a在内存中变为

将例1中的指针类型改为char* 类型,用char* 类型的指针接收a的地址

int* 和 char*类型的指针都能将int类型的a存放,因为在32位平台下,指针类型的大小都是4个字节。

#include <stdio.h>
int main()
{
	int a = 0x11223344;//用16进制表示
	char* pc = &a;
	*pc = 0;
	return 0;
}

上述代码在VS(小端存储)调试过程中,&a在内存中显示的是

执行完*pc=0;语句后,内存变化为

通过上述两个代码块执行后内存中的变化可以验证指针类型决定了指针进行解引用操作时访问几个字节

指针类型决定了指针的步长,指针加减整数的时候向前或者向后走一步走多大距离

(char*)+1------跳过一个char类型的大小,也就是向后走1个字节;

(int*)+1------跳过一个int类型的大小,也就是向后走4个字节;

(double*)+1------跳过一个double类型的大小,也就是向后走8个字节;

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	int* pa = &a;
	char* pc = &a;
	printf("%p\n",pa);
	printf("%p\n",pc);
	printf("%p\n",pa+1);
	printf("%p\n",pc+1);
	return 0;
}

上述代码的运行结果为

说明指针加减整数时的步长和指针指向的类型有关

练习1:

我们可以通过一个练习对其有更好的理解:将数组arr中每个元素赋值为对应下标,arr[0]为0;arr[1]为1……

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = arr;//p指向arr数组的首元素地址
	int i = 0;
	for(i = 0;i < 10; i++)
	{ 
		*(p++) = i;//将数组元素赋值;
		//后置++,对p进行解引用,赋值之后,再向后走int类型的大小,即4个字节,依次循环
	}
	for(i = 0;i < 10; i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

运行结果如图

3.二级指针

#include <stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	int** pp = &p;//pp就是二级指针
	*p = 20;//可以将a修改成20
	**pp = 30;//可以将a修改成30
	printf("%d\n",a);
	return 0;
}

二、野指针

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

1.野指针成因

1.指针未初始化

#include <stdio.h>
int main()
{
	int* p;//p没有初始化,p就是野指针
	*p = 20;//赋值
	return 0;
}

2.指针越界访问

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr)/sizeof(arr[0]);//计算arr数组中元素个数
	int* p = arr;
	for(i = 0;i <= sz; i++)//共循环11次
	{
		*p++ = i;
	}
	return 0;
}

当p越过arr已有空间去越界访问的时候就是野指针了,之前不是野指针。

当指针指向的范围超出数组arr的范围时,p就是野指针

3.指针指向的空间释放

#include <stdio.h>
int* test()
{
	int num = 100;//num是局部变量,进函数创建,函数结束时销毁
	return &num;//返回的是栈空间的地址
}
int main()
{
	int* p = test();//接收到地址,但是地址并不指向num,不知道指向的是哪里,所以*p = 200并不知道修改的是哪里
	//虽然接收到地址,但是num已经销毁
	*p = 200;
	return 0;
}

2.规避野指针

1.指针初始化

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//明确指针
	int* pa = NULL;//当pa不知道指向哪里时,置空
	//NULL就是用来初始化指针的
	//*pa = 20;//error,在对指针置空之后不能这样使用,NULL属于系统(内核),不能访问
	return 0;
}

2.小心指针越界问题

3.指针指向空间释放,及时置NULL;

#include <stdio.h>
#include <stdlib.h>//malloc的头文件
int main()
{
	//动态申请内存空间
	int* p=(int*)malloc(40);
	//使用
	//释放
	free(p);
	p=NULL;
	return 0;
}

4.避免返回局部变量的地址,即避免返回栈空间的地址,这样可以尽量避免指针指向的空间释放这种情况。

5.指针使用之前检查有效性

三、指针运算

1.指针±整数

指针±整数是根据指针指向的数据类型大小向前或者向后走多少个字节。

  • //char* pc;pc+1就是向后走一个char类型大小的字节;
  • //int* pa;pa+1就是向后走一个int类型大小的字节;
  • //double* pd;pd+1就是向后走一个double类型大小的字节;
  • //……

在练习1中已经对其用法进行简单演示。

2.指针-指针

两个指针相减的前提是:指针指向的是同一块连续的空间,且是同一种类型的指针。

指针和指针相减的绝对值是指针之间的元素个数

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n",&arr[9]-&arr[0]);//9
	printf("%d\n",&arr[9]-&arr[0]);//-9
	return 0;
}

练习2:

模拟实现strlen,strlen函数在对字符串中的字符进行统计时,遇见’\0’停止。

#include <stdio.h>
int my_strlen(const char* arr)
{
	const char* start = arr;//将arr数组首元素地址赋给start
	const char* end = arr;
	while(*end)
	{
		end++;
	}
	return end-start;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d",len);//6
	return 0;
}

3.指针关系运算

#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	int* p = &arr[10];
	for(p = &arr[10];p > &arr[0])
	{
		*--p = 0;//先将p向前移动4个字节,再对p赋值;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);// 全为0
	}
	return 0;
}

指针关系运算的标准规定:允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较,但是不允许指向数组元素的指针与指向数组第一个元素前面的那个内存位置的指针进行比较。

四、指针数组

1.指针和数组

指针和数组不是一个东西,指针是一个变量,是用来存放地址的,4/8个字节;数组能够存放一组数,是一个连续的空间,数组的大小取决于元素个数。

联系:数组名就是地址(指针);数组把首元素的地址交给一个指针变量之后,可以通过指针来访问数组。

2.指针数组的概念

//char arr[n]——字符数组:存放字符的数组

//int arr[n]——整型数组:存放整型的数组

指针数组:存放指针的数组

//char* arr[n]——字符指针数组:存放字符指针的数组

//int* arr[n]——整型指针数组:存放整型指针的数组

练习3:

通过指针数组打印a,b,c,d的值

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* arr[4] = {&a,&b,&c,&d};
	for(i = 0;i < 4;i++)
	{
		printf("%d  ",*(arr[i]));
	}
	return 0;
}

运行结果为

练习4:

用一维数组模拟二维数组,打印出各个数组的值

#include <stdio.h>
int main()
{
	int arr1[4] = {1,2,3,4};
	int arr2[4] = {2,3,4,5};
	int* arr[2] = {arr1, arr2};//指针数组中存放的是每个数组中首元素的地址
	int i = 0;
	for(i = 0;i < 2;i++)
	{
		int j = 0;
		for(j = 0;j < 4;j++)
		{
			printf("%d  ",arr[i][j]);
			//arr[i][j]还可以写为*(arr[i]+j)或者*(*(arr+i)+j);arr是数组首元素的地址
		}
		printf("\n");
	} 
	return 0;
}

运行结果为

练习5:

用指针数组打印字符串

#include <stdio.h>
int main()
{
	char* arr[4] = {"abc","bcd","cde","def"};//常量字符串
	//arr中存放的是每个字符串中首个字符的地址
	int i = 0;
	for(i = 0;i < 4;i++)
	{
		printf("%s\n",arr[i]);//%s打印字符串,只要有字符串起始地址就可以打印
	}
	return 0;
}

运行结果为

五、字符指针

在指针的类型中,我们知道有一种指针类型叫字符指针char*。

#include <stdio.h>
int main()
{
	char* pc = "abcdef";
	printf("%s\n", pc);//abcdef
	printf("%c", *pc);//a
	return 0;
}

字符指针可以存放字符串的起始地址,把字符串首元素的地址存在pc中,但这种做法不合理;"abcdef"是常量字符串,不能修改,这时让"*pc = 'w'"程序会崩,可以将char* pc = "abcdef"修改为const char* pc = "abcdef",const放在* 的左边,限制*pc,不能改变字符串内容。

练习6:

判断下列代码的输出内容;

#include <stdio.h>
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";
	const char* arr3 = "abcdef";
	const char* arr4 = "abcdef";
	if(arr1 == arr2)//数组名表示数组首元素的地址,比较地址是否相同
		printf("arr1 and arr2 are same\n");
	else
		printf("arr1 and arr2 are not same\n");
	if(arr3 == arr4)
		printf("arr3 and arr4 are same\n");
	else
		printf("arr3 and arr4 are not same\n");
	return 0;
}

输出结果为

if(arr1 == arr2)if(arr3 == arr4)比较的是他们的首元素地址是否相同。

数组名是数组首元素的地址,arr1和arr2是数组,他们的首元素地址不同,所以他们不相同。

而arr3和arr4是char*类型的指针,他们指向的是常量字符串,常量字符串在内存中只保存一份,地址相同,所以arr3和arr4指向的都是a的地址。

六、数组指针

//char* pc——字符指针-指向字符的指针,存放字符变量的地址

//int* pa ——整型指针-指向整型的指针,存放整型变量的地址

//int(*p)[n]——数组指针-指向数组的指针,存放数组的地址,p是数组指针变量

数组指针在一维数组里面的应用

void print(int(*p)[5])
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", (*p)[i]);
	}
}
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	print(&arr);//&arr取的是整个数组的地址
	return 0;
}

运行结果为

注意是数组指针也是指针,p应该先与 * 结合,再与[ ]结合, (*p)要用( )括起来

数组指针很少在一维数组中应用,一般在二维数组中应用

void print(int(*p)[5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", *( * (p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print(&arr, 3, 5);
	return 0;
}

运行结果

数组名相当于数组首元素的地址,对于二维数组来说,首元素理解为他的第0行,p里面存的是第0行的地址,p是数组指针类型,p+1相当于向后走了5个int类型的大小,p+1指向第1行,(p+i)指向的就是第i行的地址。* (p+i) 相当于第i行的数组名; * (p+i)=p[i]。

扩展:int(*p[10])[5]——p是数组,有10个元素,每个元素都是数组指针,每个数组指针指向一个具有5个int类型的数组的地址。我们可以说p是存放数组指针的数组。

七、数组传参和指针传参

1.一维数组传参

数组传参,形参可以是数组,也可以是指针。

int arr[10] = {0}传参,他的参数用数组接收可以是int arr[]或者int arr[10];用指针接收是int* arr

int* arr[10] = {0}传参,他的参数用数组接收是int* arr[10],用指针接收是int** arr

2.二维数组传参

int arr[3][5]传参,他的参数用数组接收是int arr[3][5]或者int arr[][5],用指针接收int (*arr)[5]

3.一级指针传参

int* p传参,参数部分直接写成指针形式:int* p

4.二级指针传参

int** p传参,参数部分直接写成指针形式:int** p

八、函数指针

#include <stdio.h>
int Add(int x,int y)
{
	return x+y;
}
int main()
{
	int a = 10;
	int b = 20;
	int(*pf)(int,int)=Add;
	//int(*pf)(int,int)中,int是函数返回类型,pf是函数指针变量,(int,int)是函数的参数类型
	//int ret = Add(a,b);
	int ret = (*pf)(a,b);//输出结果是30
	//使用函数指针时,也可以省略*
	//int ret = pf(a,b);
	printf("%d",ret);
	return 0;
}

九、函数指针数组

函数指针数组:可以存放多个返回类型相同和参数相同的函数的地址。

我们通过构造一个简单的计算器来实现对函数指针数组的应用

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 x = 0;
	int y = 0;
	int ret = 0;
	int(*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };//利用数组下标引用函数
	do
	{
		menu();
		printf("请选择>:");
		scanf("%d", &input);
		if (input == 0)//input为0时,直接退出计算器
		{
			printf("退出计算器\n");
			break;
		}
		if (input >= 1 && input <= 4)//判断input是否符合要求
		{
			printf("请输入两个操作数:");
			scanf("%d%d", &x, &y);
			ret = (*pf[input])(x, y);
			printf("结果为%d\n", ret);
		}
		else
		{
			printf("选择错误\n");//input不符合要求,给与提示
		}
	} while (input);
	return 0;
}

扩展:指向函数指针数组的指针int(*(*pf)[5])(int,int)=&pf

十、回调函数

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

我们通过对上面那个计算器进行改写,从而让我们能够更好的理解回调函数。

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;
}
void calc(int(*p)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入两个操作数:");
	scanf("%d%d", &x, &y);
	printf("%d\n", (*p)(x,y));
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	int(*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };
	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("EXIT");
		}
	} while (input);
	return 0;
}

把函数地址传给一个函数calc,在calc函数内部通过函数指针p调用Add时,Add就被称为回调函数。

以上就是C语言学习之指针的使用详解的详细内容,更多关于C语言指针的资料请关注编程网其它相关文章!

--结束END--

本文标题: C语言学习之指针的使用详解

本文链接: https://www.lsjlt.com/news/170235.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • C语言学习之指针的使用详解
    目录一、指针概念1.指针变量2.指针类型3.二级指针二、野指针1.野指针成因2.规避野指针三、指针运算1.指针±整数2.指针-指针3.指针关系运算四、指针数组1.指针和...
    99+
    2022-11-13
    C语言指针使用 C语言指针
  • 详解C语言学习记录之指针
    目录1指针是什么2指针和指针类型3野指针(1)三种情况(2)如何规避野指针4指针运算5指针和数组6字符指针7数组指针8指针数组9其他总结1指针是什么 指针是汇编语言中的一个对象,利用...
    99+
    2022-11-12
  • C++学习之指针的使用详解
    C++中指针储存一个地址 声明: datatype* p;  datatype表示指针指向的数据类型。 int num=0; int* pnum=&num; //&...
    99+
    2023-03-02
    C++指针使用 C++指针
  • Go语言学习之指针的用法详解
    目录引言一、定义结构体1. 语法格式2. 示例二、访问结构体成员三、结构体作为函数参数四、结构体指针总结引言 Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义...
    99+
    2022-11-13
  • C语言进阶学习之指针
    目录1.指针概念回顾2.字符指针3.数组指针和指针数组3.1数组指针的含义3.2&数组名vs数组名3.3数组指针4.数组传参和指针传参4.1一维数组传参4.2二维数组传参4....
    99+
    2022-11-12
  • Go语言基础学习之指针详解
    目录1. 什么是指针2. 指针地址 & 指针类型3. 指针取值4. 空指针5. make6. new7. make 和 new 的区别8. 问题今天来说说 Go 语言基础中的...
    99+
    2022-12-30
    Go语言指针使用 Go语言指针 Go 指针
  • C语言指针详解之野指针
    目录指针是什么?怎么表示?什么是指针变量?指针类型又是什么?指针类型存在的意义野指针是什么?野指针产生的原因一、 指针未初始化二、 指针越界访问如何避免野指针(野狗)的出现呢?指针运...
    99+
    2022-11-12
  • C语言学习之指针知识总结
    目录一、地址二、指针与指针变量三、指针的作用四、初学指针时常见的错误五、通过调用函数修改主调函数中的值六、指针与一维数组七、使用函数操作一维数组八、指针变量所占字节数九、静态数组的缺...
    99+
    2022-11-13
  • C++指针学习详解
    目录指针的基本概念一、指针变量的定义和使用二、指针所占的空间内存1.空指针 野指针2. const修饰指针利用指针访问数组中的每个元素.总结指针的基本概念 指针的作用:可以通过指针间...
    99+
    2022-11-12
  • Go语言学习教程之指针的示例详解
    目录前言练习1练习2练习3前言 关于指针的主要几点: 指针类型:一个指针类型*T表示指向给定类型的变量的所有指针的集合,该给定类型T称为基本类型。未初始化的指针的值是nil。变量:一...
    99+
    2022-11-11
  • 从头学习C语言之指针和数组
    目录指针和数组:示例:总结指针和数组: 数组名其实是数组第一个元素的地址。 %p用来打印地址,为十六进制 &:取址操作符 如果用一个指针指向数组,应该怎么做呢? char ...
    99+
    2022-11-13
  • C++学习之移动语义与智能指针详解
    目录移动语义 1.几个基本概念的理解 2.移动构造函数 3.移动赋值函数 4.std::move函数 5.面试题,关于实现String 资源管理和智能指针 一、C语言中的问题 二、C...
    99+
    2022-11-12
  • C语言指针详解
    目录前言:复杂类型说明一、细说指针1.指针的类型2.指针所指向的类型3.指针的值----或者叫指针所指向的内存区或地址4 指针本身所占据的内存区二、指针的算术运算三、运算符&...
    99+
    2022-11-12
  • C语言学习之标识符的使用详解
    目录命名规则命名规范示例代码总结C语言标识符是用于表示变量、函数、常量、类型等程序元素的名称。在 C语言中,标识符的命名规则和命名规范非常重要,它们直接影响到代码的可读性、可维护性和...
    99+
    2023-05-20
    C语言标识符用法 C语言标识符使用 C语言标识符
  • C语言的空类型指针,空指针,野指针详解
    目录空类型指针-void*空指针-NULL野指针造成野指针的原因1.指针未初始化2.指针越界访问3.指针指向的空间已经释放避免野指针总结空类型指针-void* void是空类型,vo...
    99+
    2022-11-12
  • C语言函数指针详解
    目录Introduction函数指针 Function PointersExercise 1:qsort中的函数指针Exercise 2:总结Introduction 上一个lab的...
    99+
    2022-11-12
  • C语言指针基础详解
    目录1.1:概述1.1.1:内存1.1.2:内存1.1.3:指针和指针变量1.2:指针基础知识1.2.1:指针变量的定义和使用1.2.2:通过指针间接修改变量的值1.2.3:指针的大...
    99+
    2022-11-12
  • c语言的指针数组详解
    指针如何指向数组,并读取数组中的元素: #include <stdio.h> int main() { int arr[3] = {1,2,3}; int *p;...
    99+
    2022-11-12
  • C语言指针的图文详解
    目录指针是什么?指针和指针变量1. 指针类型决定了指针进行解引用操作的时候,能访问空间的大小2. 指针加减整数野指针野指针的成因指针和数组二级指针指针数组、数组指针总结指针是什么? ...
    99+
    2022-11-12
  • 详解C语言的void*空指针
    目录void的应用空指针类型(void*)总结在C语言中,void称为无类型,相应的void*称为无类型指针或者空指针类型。 void的应用 对函数返回值的限定。 例如void fu...
    99+
    2022-11-13
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作