【C语言】指针详解（二）

news2024/11/23 23:55:41

1.指针变量类型的意义

1.1指针的解引用

1.2指针 + - 整数

1.3void*指针

2.const修饰指针

2.1const修饰变量

2.2const修饰指针变量

1.指针变量类型的意义

1.1指针的解引用

指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢?

对比，下面2段代码，主要在调试时观察内存的变化。

//代码1
#include<stdio.h>
int main()
{
	int a = 0x11223344;
	int* p = &a;
	*pa = 0;
	return 0;
}

代码2
#include<stdio.h>
int main()
{
	int a = 0x11223344;
	char* p = (char*) & a;
	*pa = 0;
	return 0;
}

⭐调试我们可以看到，代码1会将a的4个字节全部改为0，但是代码2只是将a的第一个字节改为0。

🔺结论:指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节)。
比如: char* 的指针解引用就只能访问一个字节，而int* 的指针的解引用就能访问四个字节。

1.2指针 + - 整数

先看一段代码，调试观察地址的变化。

代码运行结果如下

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);
	return 0;
}

⭐我们可以看出，char*类型的指针变量+1跳过1个字节，int*类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。
🔺结论:指针的类型决定了指针向前或者向后走一步有多大(距离)。

1.3void*指针

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

举例：

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

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

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

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

那么void*类型的指针到底有什么用呢?
一般void*类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得一个函数来处理多种类型的数据。

2.const修饰指针

2.1const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。但是如果我们希望一个变量加上一些限制，不能被修改，怎么做呢?这就是const的作用。

int main()
{
	int a = 10;
	a = 0;//a是可以修改的
	const int b = 20;
	b = 0;//b是不可修改的
}

上述代码中b是不能被修改的，其实b本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对b进行修改，就不符合语法规则，就报错，致使没法直接修改n。

但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则

如下代码：

int main()
{
	const int b = 20;
	int* pa = &b;
	*pa = 0;
	printf("%d", b);
}

此时可以看到通过指针我们成功修改了b的值

我们可以看到这里b确实修改了，但是我们还是要思考一下，为什么b要被const修饰呢?就是为了不能被修改，如果p拿到b的地址就能修改b，这样就打破了const的限制，这是不合理的，所以应该让p拿到b的地址也不能修改b，那接下来怎么做呢?

2.2const修饰指针变量

void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;//ok?
	p = &m;//ok?
	//在这里无论是通过*p修改n的值，亦或是修改指针变量p的值都是可以的。
}
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;//ok?
	p = &m;//ok?
	//这里我们用const修饰*p,此时发现无法通过*p修改n的值，但是依然可以修改指针变量p的值。
}
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20;//ok?
	p = &m;//ok?
	//这里我们用const修饰p，此时发现依然可以通过*p修改变量n的值。但是无法修改指针变量p的值。
}
void test4()
{
	int n = 10;
	int m = 20;
	const int* const p = &n;
	*p = 20;//ok?
	p = &m;//ok?
	//这里我们用const修饰p和*p，此时发现既不能通过*p修改变量n的值。也无法修改指针变量p的值。
}