当前位置：首页 > article >正文

[C]基础9.深入理解指针(1)

article 2025/3/6 7:26:16

博客主页：算法歌者
本篇专栏：[C]
您的支持，是我的创作动力。

文章目录

0、总结
1、内存和地址
- 1.1 内存
- 1.2 理解编址
2、指针变量和地址
- 2.1 取地址操作符（&）
- 2.2 指针变量
- 2.3 解引用操作符（*）
- 2.4 指针变量的大小
3、指针变量类型的意义
- 3.1 指针的解引用
- 3.2 指针+-整数
- 3.3 void*指针
4、const修饰指针
- 4.1 const修饰变量
- 4.2 const修饰指针变量
5、指针运算
- 5.1 指针+-整数
- 5.2 指针-指针
- 5.3 指针的关系运算
6、野指针
- 6.1 野指针成因
- 6.2 如何规避野指针
- - 6.2.1 指针初始化
  - 6.2.2 小心指针越界
  - 6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性
  - 6.2.4 避免返回局部变量的地址
7、assert断言
8、指针的使用和传址调用
- 8.1 strlen的模拟实现
- 8.2 传值调用和传址调用

0、总结

在这里插入图片描述

1、内存和地址

1.1 内存

CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中。因此，内存空间如何高效的管理呢？

可以把内存划分为一个个的内存单元，每个内存单元的大小取1个字节。每个内存单元能放8个比特位。每个内存单元都有一个编号，有了这个内存单元的编号，CPU就可以快速找到一个内存空间。

说到字节，需要学习计算机中常见的单位，如下：

// 在计算机存储中，最基本的单位是比特（bit），它可以是0或1。
// 字节（Byte）是更常用的单位，每8位（bit）组成一个字节（B）。
// 字节是计算机中存储、处理信息的基本单位。
// 计算机内存单位的换算是基于字节（Byte）的存储单位。
1 Byte（字节）     = 8    bits  (比特)
1 KB  （千字节）   = 1024 Bytes (字节)
1 MB  （兆字节）   = 1024 KB    (千字节)
1 GB  （吉字节）   = 1024 MB    (兆字节)
1 TB  （太字节）   = 1024 GB    (吉字节)
1 PB  （拍字节）   = 1024 TB    (太字节)
1 EB  （艾字节）   = 1024 PB    (拍字节)
1 ZB  （泽字节）   = 1024 EB    (艾字节)
1 YB  （尧字节）   = 1024 ZB    (泽字节)

在计算机中，我们把内存单元的编号称之为地址。C语言中给地址起了新的名字叫：指针。

所以我们可以理解为：内存单元的编号 == 地址 == 指针

1.2 理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址。计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间是互相独立的，那么如何通信呢？答案是用“线”连起来。

而CPU和内存之间也有大量的数据交互的，所以，两者必须也用线连起来。在这里，只关心地址总线。我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0、1（电脉冲有无）。那么，一根线，就能表示2种含义，依此类推，32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。

地址信息被下达给内存，在内存上就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

注意：0xFFFFFFFF是一个32位的数，它可以被32位或更高位数的机器完整表示。

2、指针变量和地址

2.1 取地址操作符（&）

理解了内存和地址的关系，在C语言中，创建变量其实就是向内存申请空间。

#include <stdio.h>
int main()
{
	int a = 10;
	return 0;
}

上述代码，就是创建了整型变量a，内存中申请4个字节，用于存放整数10，其中，每个字节都有地址，上图中4个字节的地址分别是：

0x012FFBE0
0x012FFBE1
0x012FFBE2 
0x012FFBE3

那么我们如何能得到a的地址呢？

这里，需要一个操作符（&），取地址操作符。

#include <stdio.h>
int main()
{
	int a = 10;
	&a; // 取出a的地址
	printf("%p\n", &a);
	return 0;
}

如图所示：

按照我画图的例子，会打印处理：0x012FFBE0，&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，但只要知道了第一个字节地址，就可以顺藤摸瓜访问到4个字节的数据。

注意：在C语言中，符号&有多种用途，总结如下：

取地址运算符
按位与运算符

2.2 指针变量

我们通过取地址操作符（&）拿到的地址是一个数值，比如：0x012FFBE0，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：存放在指针变量中。代码如下：

#include <stdio.h>
int main()
{
	int a = 10;
	// 取出a的地址并存储到指针变量pa中。
	int* pa = &a;
	return 0;
}

指针变量也是一种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

pa的类型是int*，该如何理解指针的类型呢？*是在说明pa是指针变量，int是在说明pa指向的是整型（int）类型的对象。如图：

2.3 解引用操作符（*）

我们将地址保存起来，未来是要使用的，那怎么使用呢？

在现实生活中，我们使用地址要找到一个房间，在房间里可以拿去或者存放物品。C语言中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象。这种方式需要解引用操作符（*）。如下：

#include <stdio.h>
int main()
{
	int a = 100;
	int* pa = &a;
	*pa = 0;
	return 0;
}

上面代码中第6行就使用了解引用操作符，*pa的意思是，通过pa中存放的地址，找到指向的空间，*pa其实就是a变量，所以*pa = 0，这个操作符是把a改成了0。于是，a的修改多了一种途径，让写代码更加灵活。

注意：在C语言中，符号*有多种用途，总结如下：

乘法运算符
声明指针变量
指针解引用

2.4 指针变量的大小

前面的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产生的2进制序列当做一个地址，那么一个地址就是32个bit位，需要4个字节才能存储。如果指针变量是用来存放地址的，那么指针变量的大小需要4个字节的空间。

同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变量的大小就是8个字节。

#include <stdio.h>
int main()
{
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(double*));
	return 0;
}

// 指针变量的大小取决于地址的大小
32位平台运行：
4
4
4
4
64位平台运行：
8
8
8
8

结论：

32位平台下地址是32个bit位，指针变量大小是4个字节。
64位平台下地址是64个bit位，指针变量大小是8个字节。
注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3、指针变量类型的意义

3.1 指针的解引用

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

// 代码2：
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	*pc = 0;
	return 0;
}

经过调试，观察内存的变化，如下：

代码1的调试情况：

代码2的调试情况：

调试后，观察出代码1会将变量n的4个字节全部改为0，但是代码2只是将变量n的第一个字节改为0。

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

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

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

32位环境的运行：
n    = 004FFC6C
pc   = 004FFC6C
pc+1 = 004FFC6D
pi   = 004FFC6C
pi+1 = 004FFC70

我们可以看出，char*类型的指针变量+1跳过1个字节，int*类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。

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

3.3 void*指针

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

一般void*类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址。

4、const修饰指针

4.1 const修饰变量

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

#include <stdio.h>
int main()
{
	int m = 0;
	// m是可以修改的
	m = 20;
	const int n = 0;
	// n是不能被修改的
	n = 20; //error
	return 0;
}

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

怎么证明n本质上是变量呢？如图证明n是变量：

注意：在C++中const修饰的变量就是常量。

如果我们绕过n，使用n的地址，去修改n就能做到了，代码如下：

#include <stdio.h>
int main()
{
	const int n = 0;
	printf("n = %d\n", n);
	int* p = &n;
	*p = 20;
	printf("n = %d\n", n);
	return 0;
}

运行结果：
n = 0
n = 20

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

4.2 const修饰指针变量

#include <stdio.h>
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;
	p = &m;
}
void test2()
{
	int n = 10;
	int m = 20;
	int const* p = &n;
	*p = 20;
	p = &m;
}
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20;
	p = &m;
}

void test3()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20;
	p = &m;
}
int main()
{
	// 测试无const的情况
	test1();
	// 测试const放在*的左边情况
	test2();
	// 测试const放在*的右边情况
	test3();
	// 测试*的左右两边都有const
	test4();
	return 0;
}

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

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。
const如果放在*的右边，修饰的是指针变量本身，保证指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

5、指针运算

指针的基本运算有三种：

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

5.1 指针±整数

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

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

5.2 指针-指针

#include <stdio.h>
int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}
int main()
{
	printf("%d\n", my_strlen("abc"));
	return 0;
}

为什么指针-指针是元素个数，而不是指针个数？

指针-指针得到的是元素个数，而不是指针个数，这是因为指针的算术运算被设计为计算两个指针之间的元素数量，而不是指针本身的数量。这种设计使得指针运算在处理数组和内存块时更加直观和有用。

注意：形参可以接收实参的地址情况如下：

1、数组名的隐式转换：
- 在C中，数组名在表达式中（例如作为函数参数传递时）会被隐式转换为指向数组第一个元素的指针。
- 例如，char myArray[] = "abc";定义了一个字符数组myArray。当你传递myArray给函数时，实际上传递的是&myArray[0]，即数组第一个元素的地址。
2、字符串字面量：
- 字符串字面量（如"abc"）本身就是一个字符数组常量，存储在程序的只读数据段。
- 当你传递"abc"给函数时，传递的是这个字符串字面量第一个字符'a'的地址。
3、函数参数：
- 在函数定义中，形参char* s是一个指向字符的指针。
- 当调用函数时，实参（如数组名或字符串字面量）被转换为指针，指向其第一个元素，这个指针被传递给函数的形参。

5.3 指针的关系运算

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz) // 指针的大小比较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

6、野指针

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

6.1 野指针成因

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

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

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

总结：

1、指针未初始化
2、指针越界访问
3、指针指向的空间释放

6.2 如何规避野指针

总结：

1、指针初始化
2、小心指针越界
3、指针变量不再使用时，及时置NULL，指针使用之前检查有效性
4、避免返回局部变量的地址

6.2.1 指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL，NULL是C语言中定义的一个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

#ifndef NULL  // 如果没有定义 NULL
    #ifdef __cplusplus  // 如果定义了 __cplusplus（即在使用 C++）
        #define NULL 0  // 则定义 NULL 为 0
    #else  // 否则（即在使用 C）
        #define NULL ((void *)0)  // 则定义 NULL 为指向地址 0 的 void 指针
    #endif
#endif

初始化如下：

#include <stdio.h>
int main()
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;
	return 0;
}

6.2.2 小心指针越界

一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

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

我们可以把野指针想象成野狗，野狗放任不管是非常危险的，所以我们可以找一颗树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗拴前来，就是把野指针暂时管理起来。

不过野狗即使拴起来我们也要绕着走，不能去挑逗野狗，有点危险；对于指针也是，在使用之前，我们也要判断是否为NULL，看看是不是被拴起来的野狗，如果是，不能直接使用，如果不是我们再去使用。

#include <stdio.h>
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的时候再使用
	// ...
	p = &arr[0]; // 重新让p获得地址
	if (p != NULL) // 判断
	{

	}

	return 0;
}

6.2.4 避免返回局部变量的地址

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

此例造成野指针，不要返回局部变量的地址。

7、assert断言

assert.h头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

assert(P != NULL);

上面代码在程序运行到这一行语句时，验证变量p是否等于NULL。如果确实不等于NULL，程序继续运行，否则就会终止运行，并且给出报错信息提示。

assert()宏接受一个表达式作为参数。如果该表达式为真（返回值非零），assert()不会产生任何作用，程序继续运行。如果该表达式为假（返回值为零），assert()就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

assert()的使用对程序员是非常友好的，使用assert()有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert()的机制。如果已经确认程序没有问题，不需要再做断言，就在#include <assert.h>语句的前面，定义一个宏NDEBUG。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的assert()语句。如果程序又出现问题，可以移除这条#define NDEBUG指令（或者把它注释掉），再次编译，这样就重新启用了assert()语句。

assert()的缺点是，因为引入了额外的检查，增加了程序的运行时间。

一般我们可以在Debug中使用，在Release版本中选择禁用assert就行，在VS这样的集成开发环境中，在Release版本中，直接就是优化掉了。这样在Debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

#include <assert.h>
#include <stdio.h>
int main()
{
	int a = 10;
	int* p = NULL;
	assert(p != NULL);
	*p = 20;
	printf("%d\n", *p);
	return 0;
}

运行：
发出警告，中止运行。

思考：为什么不用if，而是assert？

判断条件占用时间。
调试方便。
快速失败原则（fail-fast）。

8、指针的使用和传址调用

8.1 strlen的模拟实现

库函数strlen的功能是求字符串长度，统计的是字符串中\0之前的字符的个数。

函数原型如下：

size_t strlen(const char * str);

参数str接收一个字符串的起始地址，然后开始统计字符串中\0之前的字符个数，最终返回长度。

如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是\0字符，计数器就+1，这样直到\0就停止。代码如下：

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	size_t count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	size_t len = my_strlen("abcdef");
	printf("%zd\n", len);
	return 0;
}

8.2 传值调用和传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？

例如，写一个函数，交换两个整型变量的值：

一番思考，可能写出这样的代码：

#include <stdio.h>
void swap1(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a = %d b = %d\n", a, b);
	swap1(a, b);
	printf("交换后：a = %d b = %d\n", a, b);
	return 0;
}

运行：
10 20
交换前：a = 10 b = 20
交换后：a = 10 b = 20

我们发现,在main函数中创建a和b，传递给swap1函数时，swap1的形参x和y接收的是a和b的值，而非地址。因x、y有独立空间，交换它们不影响a、b。此为传值调用，形参修改不影响实参，故交换失败。

要解决交换问题，可以使用指针。在main函数中，将a和b的地址传递给swap函数。swap函数通过地址操作a和b，直接交换它们的值。这样，swap函数就能有效交换main函数中的变量。

#include <stdio.h>
void swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a = %d b = %d\n", a, b);
	swap(&a, &b);
	printf("交换后：a = %d b = %d\n", a, b);
	return 0;
}

运行：
10 20
交换前：a = 10 b = 20
交换后：a = 20 b = 10

通过传址调用swap函数，我们完成了变量交换。传址调用将变量地址传给函数，使函数能修改主调函数中的变量。若函数仅需变量值进行计算，可用传值调用；若需修改变量值，则需传址调用。

完。

查看全文

http://www.kler.cn/a/526223.html

接口使用实例（1）

SAP SD学习笔记27 - 贩卖契约(框架协议)3 - 基本契约 - 定期请求(开票计划)

pandas基础学习：常用基本函数

hdfs:介绍三个脚本

jQuery小游戏（一）

向上调整算法（详解）c++

基于STM32的智能停车场管理系统设计

【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】1.28 存储之道：跨平台数据持久化方案

玩转大语言模型——使用langchain和Ollama本地部署大语言模型

简易计算器（c++ 实现)

UE4.27打包安卓报错

【C语言】如何写一个扫雷游戏

【llm对话系统】大模型源码分析之llama kv cache缓存逻辑

2.1.1 视觉与光学成像

爬虫基础（五）爬虫基本原理

云计算技术深度解析与实战案例

6.进程的使用方式

深入解析现代计算机内存访问机制：从虚拟地址到物理地址的转换与缓存优化

九大服务构建高效 AIOps 平台，全面解决GenAI落地挑战

实现智能教室能耗监测与管理系统的详细方案