C语言-指针详解

桥桥桥.

已于 2023-11-06 13:59:02 修改

阅读量52

点赞数 1

文章标签： c语言开发语言学习

于 2023-11-05 21:30:47 首次发布

本文链接：https://blog.csdn.net/QIAO182/article/details/134230801

版权

什么是指针

1.指针是内存中一个最小单元的编号，也就是地址。（地址唯一标识一块内存空间）

2.我们平常所说的指针，通常指的是指针变量，是用来存放内存地址的变量。

#include<stdio.h>
int main()
{
    int a=10;//在内存中开辟一块空间
    int *p=&a;//对变量a，取出它的地址，使用&取地址操作符；
              //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中
             //p就是一个指针变量。
   
    return 0;
}

指针变量

通过&取地址操作符取出变量的内存（地址），把地址存放到一个变量中，这个变量就是指针变量。

那么，一个小的单元到底有多大？如何编址？

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平到低电平就是1或者0，那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

...

11111111 11111111 11111111 11111111

就有2^32次方个地址。每个地址标识一个字节，那我们就可以给2^32Byte==2^32/1024KB==2^32/1024/1024MB==2^32/1024/1024/1024GB==4GB 4G的空闲进行编址。我们可以知道，在32位的机器上，地址是32个0或者1组成的二进制序列，那地址就是得用4个字节的空间来存储，所以一个指针变量的大小应该是4个字节；如果是64位机器上，如果有64个地址线按，那一个指针变量的大小是8个字节，才能存放一个地址。（1个字节byte==8比特位bit）

指针的解引用

#include<stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	int* pi = &n;
	*pc = 0;//解引用只能访问一个字节
	*pi = 0;//可以访问四个字节
	return 0;
}

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。比如：char*的指针解引用只能访问一个字节，int*的指针解引用可以访问四个字节。

野指针

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

野指针的成因：

1指针为初始化

#include<stdio.h>
int main()
{
    int *p;//局部变量指针未初始化，默认为随机值
    *p=20;
    return 0;
}

2指针越界访问

#include<stdio.h>
int main()
{
    int arr[10]={0};
    int *p=arr;
    int i=0;
    for(i=0;i<=11;i++)
    {
    //当指针指向的范围超出数组arr的范围时，p就是野指针
    *(p++)=i;
    }
    return 0;
}

3指针指向的空间释放

（这个放在后面的内容再提^_^）

如何避免野指针：

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

指针的运算

指针+-整数

#include<stdio.h>
#define N_VALUES 5

int main()
{
    float values[N_VALUES];
    float *vp;
    for(vp=&values[0];vp<&values[N_VALUES];)
    {
        *vp++=0;
    }
    return 0;
}

指针-指针

模拟实现strlen函数求字符串长度-CSDN博客第二种方法就是运用了指针-指针的运算

指针的关系运算

for(vp=&values[N_VALUES-1];vp>=&values[0];)
{
    *--vp=0;
}

标准规定：

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

指针和数组

请看下面一组代码：

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

运行结果：

得知数组名和数组首元素地址是一样的。

结论：数组名表示数组首元素的地址。（2种情况除外）

那么以下代码也是可行的：

int arr[10]={1,2,3,4,5,6,7,8,9,0};
int *p=arr;//p存放的是数组首元素的地址

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

例如：

#include<stdio.h>
//使用指针打印数组的内容
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int *p=arr;//arr==p <==> arr+i==p+i <==> *(arr+i)==*(p+i)==arr[i]通过首元素地址+偏移量，找到一个地址，然后解引用找到具体的元素
    int i=0;
    for(i=0;i<10;i++)
    {
        printf("%d ",*(p+i));
    }

    return 0;
}

p指向的是数组首元素；p+i是数组中下标为i的元素的地址；p+i其实是跳过了i*sizeof（int）个字节

二级指针

指针变量也是变量，是变量就有地址，存放指针变量的地址就是二级指针。

*ppa通过对ppa中的地址进行解引用，这样找到的是pa，*ppa其实访问的是pa。

int b=20;
*ppa=&b;//等价于 pa=&b

**ppa先通过*ppa找到pa，然后对pa进行解引用操作：*pa，找到的a 。

**ppa=30；
//等价于*pa=30；
//等价于a=30；

指针类型

指针的定义方式：type（类型）+ * +变量名

（1）简单的类型有：

char *pc = NULL; 字符指针

int *pi = NULL; 整型指针

short *ps = NULL; 短整型指针

long *pl = NULL; 长整型指针

float *pf = NULL; 单精度浮点型指针

double *pd = NULL; 双精度浮点型指针

理解：我们以char *pc = NULL为例，pc是一个 char *类型的指针，存放char类型变量的地址。

指针类型的意义：指针的类型决定了指针向前或向后一步有多大（距离）；或者说，决定了指针的+-整数的步长，指针解引用操作的时候的权限。

（2）复杂的类型有：

Ⅰ.字符指针

一般使用：

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

第二种表示方式：

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

在这const char *pstr="hello world."，本质上是把字符串hello world.中的首字符地址放到了pstr中。

例题：

#include<stdio.h>
    int main()
    {
	char str1[] = "hello world！";     
	char str2[] = "hello world！";     
	const char* str3 = "hello world！";  
	const char* str4 = "hello world！"; 
	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不同。

Ⅱ函数指针

指向函数的指针，存放的是函数的地址

书写形式：类型名（* 指针变量名）（函数参数表列）

看一组代码：

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

运行结果：

可以看到运行的输出结果都是地址，这两个地址是test函数的地址。

那么如何把这个函数地址保存起来呢？

void test()
{
    printf("hello");
}
void (*pf)();//pf就是函数指针变量

void (*pf)(); //pf先和*结合，说明pf是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

图例对函数指针进行说明：

举例：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p\n", &Add);//&函数名就是函数的地址
	printf("%p\n", Add);//函数名也是函数的地址

	//int (*pf1)(int, int) = Add;//pf1就是函数指针变量
	int (*pf2)(int, int) = &Add;

	int ret = (*pf2)(2, 3);//调用函数。1先解引用函数指针变量找到这个函数，再写入实参传参
	//int ret = add(2, 3);//2 函数名也是函数的地址
	int ret = pf2(2, 3);//3 *可以省略不写

	printf("%d\n", ret);

	return 0;
}

int (*)(int,int)是一个函数指针类型

Ⅲ数组指针

指向数组的指针-是指针

看两组代码：

#include <stdio.h>
int main()
{
	int arr[10];
	printf("%p\n", arr);
	printf("%p\n", arr+1);//跳过一个字节

	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);//跳过一个字节

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);//跳过整个数组

	//指针类型决定了指针+1，到底跳过几个字节
	return 0;
}

int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;//p是用来存放数组的地址的，p是数组指针
	                    //而p+1跳过的是10个整型元素的大小，跳过整个数组
	                    //[]里·的10一定不能省略
	char* arr2[5];
	char*(*pc)[5] = &arr2;
	return 0;
}

int(*)[10];//是一个数组指针类型,并且[ ]里的10一定不能省略！

数组指针的使用-一般用在二维数组上

#include<stdio.h>
//形参的部分是数组
void print(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[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;
}


//形参的部分是指针
void print(int(*p)[5], int r, int c)//数组名传过去的·就是首元素的地址，所以p指向的二维数组里首元素的地址就是第一行一维数组的地址
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", p[i][j]);//p[i]的意思是 *（p+i）
		}
		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);//arr是二维数组的数组名，是首元素的地址，是第一行的地址
	                 //二维数组传参
	return 0;
}

指针数组

用来存放指针变量的数组-是数组

arr3是一个数组，有五个元素，每个元素是一个整型指针。

#include<stdio.h>
//指针数组模拟二维数组
int main()
{
	int arr1[] = { 1,2,3,4 };
	int arr2[] = { 2,3,4,5 };
	int arr3[] = { 3,4,5,6 };
	int* arr[] = { arr1,arr2,arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

//指针数组打印字符串
int main()
{
	char* arr[5] = { "Hello bit","xinxin","C++","Java","WTU" };
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%s\n", arr[i]);
	}
	return 0;
}

以上，学习了数组指针和指针数组，可以看下以下代码的含义：

int arr[5];//arr是一个能够存放5个整型数据的数组

int *parr1[10];//parr1是一个指针数组，数组10个元素，每个元素类型是int*

int (*parr2)[10];//parr2是一个数组指针，该指针指向数组，指向的数组有10个元素，每个元素是int

int (*parr3[10])[5];//parr3是一个数组，是存放数组指针的数组，存放的这个数组指针，指向的数组有5个元素，每个元素是int类型

函数指针数组

存放的是函数的地址-是数组

例题：

#include<stdio.h>
int add(int x, int y)
{
	return x + y;
}
int sub(int x, int y)
{
	return x -y;
}
int main()
{
	int(*pf1)(int,int) = &add;
	int(*pf2)(int, int) = &sub;
	int(*pfarr[2])(int, int) = { &add,&sub };//pfarr是函数指针数组--存放函数指针的数组
	return 0;
}

以上代码中，pfarr是函数指针数组--存放函数指针的数组，是int（*）（）类型的函数指针

函数指针数组的用途：转移表

#include<stdio.h>
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 menu()
{
	printf("***************************\n");
	printf("*****1.ADD   2.SUB*********\n");
	printf("*****3.MUL   4.DIV*********\n");
	printf("*****0.EXIT       *********\n");
	printf("***************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：>");
		scanf("%d", &input);
		//创建函数指针数组-像这种称其为转移表
		int(*pfArr[])(int, int) = { NULL,ADD,SUB,MUL,DIV };//函数的参数和返回类型都是int
                                                         //pfArr是函数指针数组
		                           //0    1    2   3   4
		if (0 == input)
		{
			printf("退出计算器\n");
		}
		else if (input>=1&&input<=4)
		{
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);//调用函数指针数组，下标为输入的input值
			printf("ret=%d\n", ret);
		}
		else
		{
			printf("选择错误，请重新选择\n");
		}
	} while (input);
	return 0;
}

// 扩展：
//指向函数指针数组-数组-存放的是函数的地址
//int(*pfArr[])(int, int) = { NULL,ADD,SUB,MUL,DIV };//pfArr是函数指针数组
// p=&pfArr;
//int(*（*p）[5])(int, int)=&pfArr;//p是指针，是指向函数指针数组的指针 -------》p的类型

回调函数

指针进阶--回调函数-CSDN博客

数组传参，指针传参

数组传参：一维数组传参，传递的是第一个元素的地址；二维数组传参，传递的是第一行的地址；数组在传参的时候，形参可以写成数组，也可以写成指针。
指针传参：一级指针的实参部分可以传整型/浮点型/字符型...一维数组的数组名，传整型/浮点型...变量的地址，传整型/浮点型...指针；而形参部分可以写成一级指针的形式。

桥桥桥.

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
C语言-指针详解

1.指针是内存中一个最小单元的编号，也就是地址。（地址唯一标识一块内存空间）2.我们平常所说的指针，通常指的是指针变量，是用来存放内存地址的变量。//在内存中开辟一块空间int *p=&a;//对变量a，取出它的地址，使用&取地址操作符；//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中//p就是一个指针变量。return 0;指针变量通过&取地址操作符。
复制链接

扫一扫