『C语言初阶』第四章-指针（1）

Dklau-c

已于 2024-02-25 21:18:40 修改

阅读量966

点赞数 23

分类专栏： C语言初阶知识文章标签： c语言数据结构开发语言

于 2024-02-17 21:43:37 首次发布

本文链接：https://blog.csdn.net/m0_54443558/article/details/135680679

版权

C语言初阶知识专栏收录该内容

19 篇文章 2 订阅

订阅专栏

引言

针对指针，之前的文章中也就简单介绍过了，本章是针对已经简单了解了解指针，进行的一系列扩展与探究，所以如果读者还未简单了解指针，请先去看一下我之前对于指针的文章，再回来阅读。

1.指针变量类型的意义

1.1指针的解引用

指针变量的大小和类型无关，只要是指针变量，就是为了储存地址的，而地址大小与地址总线有关，所以在同一个平台下，指针变量大小都是一样的，那为什么还要有各种各样的指针类型呢？

这里有两段代码就可以说明这个问题：

//代码1
int main()
{
	int n = 0x11223344;
	int* pi = &n;
	*pi = 0;
	printf("%x", n);
	return 0;
}
//代码2
int main()
{
	int n = 0x11223344;
	char* pi = &n;
	*pi = 0;
	printf("%x", n);
	return 0;
}

调试运行之后，我们可以发现，代码1会将n的4个字节全部改为0，而代码2却只是将n的第一个字节改成0，结果是11223300，但为什么n的第一个字节是44，这个我们之后再做解释。

结论： 指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而int* 的指针解引用就能访问四个字节。

1.2.指针+-整数

首先先看一段代码

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

运行结果如下：

这是在32位环境下运行出来的结果，我们可以看出，char* 类型的指针变量+1跳过了1个字节，int* 类型的指针变量+1 跳过了4个字节，这就是指针变量的类型差异所带来的变化。

结论：指针的类型决定了指针向前或者向后一步有多大（距离）。

1.3 void*指针

在指针类型中有一种特别的类型是void* 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，void* 类型的指针不能直接进行指针的+- 整数呵解引用的运算。

例如：

int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上面的代码中，将一个int类型的变量的地址赋值给一个char* 类型的指针变量。编译器给出了一个警告（如下图），是因为类型不兼容。而使用void* 类型就不会有这样的问题。

使用void* 类型的指针接收地址：

int main()
{
	int a = 10;
	void* pa = &a;
	void * pc = &a;
	*pa = 0;
	*pc = 0;
	return 0;
}

运行结果：

这里我们可以看到，void*类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。

那么void*类型的指针到底有什么用呢？

因为它的泛型特性，即可以接收不同类型的地址，一般void* 类型的指针是使用在函数参数的部分，这样的设计可以实现泛型编程的效果。是一个函数可以用来处理多种类型的数据。

2.const 修饰指针

2.1 const修饰指针变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的解引用也可以修改这个变量。但是如果我们不希望变量可以通过解引用的方式来进行修改呢? 我们应该怎么操作?

这就是const 的作用。

‘ 在前面的学习中，我们知道了const 的作用是可以将所修饰的变量转化为常变量，使其无法被直接赋值修改，但是却可以通过地址解引用修改，那么，const 能否修饰指针，来达到通过地址也无法修改呢？

下面我们看代码，来分析

代码1
测试无const修饰的情况
int main()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;
	p = &m;
	return 0;
}

运行结果：可以正常运行。

代码2
测试const 放在*的左边情况
int main()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;
	p = &m;
	printf("%d %d", n, m);
	return 0;
}

运行结果：*p出错，无法解引用，但是指针p还是可以赋值。

代码3
测试const 放在*的右边情况
int main()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20;
	p = &m;
	printf("%d %d", n, m);
	return 0;
}

运行结果： p出错，无法给指针p赋值，但是可以进行解引用赋值操作。

代码4
测试*的左右两边都有const 
int main()
{
	int n = 10;
	int m = 20;
	cosnt int * const p = &n;
	*p = 20;
	p = &m;
	printf("%d %d", n, m);
	return 0;
}

运行结果： p,*p出错，无法给指针p赋值，同时无法进行解引用赋值操作。

结论： const修饰指针变量的时候

const 如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变，但是指针变量本身的内容可变。即可以进行赋值操作，无法进行解引用赋值操作。
const 如果放在*的右边，修饰的是指针本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。即无法进行赋值操作，可以进行解引用赋值操作。

3. 指针运算

指针的基本运算又三种，分别是：

指针+ - 整数
指针-指针
指针的关系运算

3.1指针+-整数

因为数组在内存中是连续存放的（地址由低到高），只要知道第一个元素的地址，就能顺藤摸瓜找到后面的所有元素。

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i)); // p+i 这里就是指针 + 整数 
    // 这里p的增值是看p的类型的 如 p是int 那么 p+1 则为p向后4个字节，指向下一个整数变量
    // 指针变量移动大小看 具体是什么类型的指针变量 如 char* a a+1 就是a指针向后移动一个字节
    // int* a a+1 则是移动4个字节
	}
	return 0;
}

3.2指针-指针

注：指针-指针的运算前提是两个指针指向的是同一块内存空间（语法上不出错，但不提倡）

int  my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0') p++;
	return s-p;  //这里指针-指针 
}
int main()
{
	printf("%d\n", my_strlen("abc")); // "abc" 这种形式的字符串，本质上就是字符型数组
									 // "abc"就是首元素的地址
	return 0;
}

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);
	char ch[20] = { 0 };
	printf("%d\n", &arr[0] - &ch[0]); 
	//这种的语法上不出错，但是得到的值没有意义

	return 0;
}

3.3指针的关系运算

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz) //指针的大小比较，其实就是地址之间的比较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

4.野指针

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

4.1野指针成因

局部变量如果没有初始化的话，由于它是存储在内存的栈区，所以它的值将会是随机值（0xcccccccc）这也就诞生了野指针，但如果是全局变量，或静态变量，由于他们是存储在静态区，所以他们的值为0。

1.指针未初始化

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

2.指针越界访问

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

3.指针指向的空间释放

int* test()
{
	int n = 100;
	return &n;
}

int main()
{
	int* p = test();  
	//函数中n是局部变量，函数结束后就会自动销毁
	//所以所返回的指针就为野指针
	printf("%d\n", *p);

	return 0;
}

根据我们所学的函数栈帧知识，思考为什么将代码改为下面这样它的p值就改变了？

int* test()
{
	int n = 100;
	return &n;
}

int main()
{
	int* p = test();  

    printf("haha\n");

	printf("%d\n", *p);

	return 0;
}

4.2如何规避野指针

4.2.1 指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。

NULL 是C语言中定义的一个标识符常量，值为0，0也是地址，但是这个地址是无法使用的，读写该地址会报错。

#ifdef __cplusplus
    #define NULL 0
#else
    #define NULL ((void *)0)
#endif

初始化如下：

int main()
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;

	return 0;
}

4.2.2 小心指针越界

一个程序向内存申请了那些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问，所得到的值也是不可预料的。

4.2.3 指针变量不再使用时，即使置为NULL，指针使用之前检查有效性

当指针变量指向一块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的一个规则就是：只要时NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	for (int i = 0; i < 10; i++)
	{
		*(p++) = i;
	}
	//出来后p已经越界了，可以把p置为NULL
	p = NULL;
	//下次使用的时候，判断p不为NULL的时候再使用
	//...
	//...
	if (p != NULL)
	{
		//...
	}
	return 0;
}