C语言之初识指针

苏小瀚

已于 2025-05-05 12:45:04 修改

阅读量712

点赞数 12

文章标签： c语言经验分享

于 2025-05-05 12:44:33 首次发布

本文链接：https://blog.csdn.net/2402_83046353/article/details/147700929

版权

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

1. 内存和地址

1.1 内存

电脑上有内存和硬盘：

内存：8G 或者 16G 或者 32G 等

硬盘：500G 或者 1TB 等

在讲解内存与地址之前，我先举个例子：

假设有一栋宿舍楼，里面有很多房间，有一个人待在其中一个房间里，那如何快速的找到这个人呢，这时候就想到给每个房间编上号码，这样就能方便的找到那个人了。

而计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那这些内存空间如何高效的管理呢？

这里也是把内存划分成一个个内存单元，每个内存单元大小是 1 个字节。

其中，每个内存单元，相当于一个学生宿舍，一个字节空间里面能放8个比特位，就好比同学们住的八人间，每个⼈是一个比特位。

每个内存单元也都有一个编号（这个编号就相当于宿舍房间的门牌号），有了这个内存单元的编 号，CPU就可以快速找到一个内存空间。

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

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

1.2 如何理解编址

首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。而CPU和内存之间也是有大量的数据交互的，所以，两者必须也用线连起来。不过，我们今天只关心一组线，叫做 地址总线。 CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号一样)。

计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

计算机厂商在生产时候已经确定好内存里面每一个内存单元对应的地址，这个地址是唯一确定的，由计算机厂商规定好的。

我们可以简单理解，32位机器有32根地址总线，每根线只有两种态，表示0或1【电脉冲有无】，那么一根线，就能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。

控制总线下达读的命令，CPU将要读取的地址信息通过地址总线传给内存，在内存上找到该地址对应的数据后，再通过数据总线传入CPU内的寄存器中。

控制总线下达写的命令，CPU将要写入数据存储的地址信息通过地址总线传给内存，在内存上找到该地址后，CPU再通过数据总线将要写入的数据存储到找到的地址里面。

2. 指针变量和地址

2.1 取地址操作符（&）

变量创建的本质是什么？

是在内存中申请一块空间，用来存放数据。

左图创建了一个整型变量a = 10，整型变量创建需要向内存申请四个字节，下面就是变量a在内存中的地址，10的二进制表示形式是：00000000000000000000000000001010，十六进制表示形式是：00 00 00 0a，对应下面内存中申请的四个字节的地址，存储变量a=10，而这块地址名叫做a,a 是给程序员看的，不是给编译器还有计算机看的，它们看的是a变量对应的地址。

下面将每行内存变为一个字节，发现内存中每个字节都对应一块内存单元，对应一个地址。

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

这里我们便要学习取地址操作符 ---- &

而取地址操作符取的就是变量在内存中存储的地址。

&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，我们只要知道了第一个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。

2.2 指针变量和解引用操作符（*）

2.2.1 指针变量

我们通过取地址操作符(&)拿到的地址是一个数值，比如：0x000000394C71F844 ，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？

那便是存储到指针变量中：

int * pa = &a;

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

2.2.2 如何拆解指针类型

我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？

int a = 10;

int * pa = &a;

这里pa左边写的是 int* ， * 是在说明pa是指针变量，而前面的 int 是在说明pa存储的地址指向的是整型(int)类型的对象。

如果有一个char类型的变量ch，存储到指针变量pc中，pc应该是char*类型：

char ch = 'a';

char * pc = &ch;

2.2.3 解引用操作符（*）

我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这里要学习一个操作符叫解引用操作符(*)。

上面代码中就使用了解引用操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间里存的变量a， *pa其实就是a变量了；所以*pa=0，这个操作符是把a改成了0。

有人肯定在想，这里目的就是把a改成0的话，写成 a = 0; 不就完了，为啥非要使用指针呢？

其实这里是把a的修改交给了pa来操作，这样对a的修改，就多了一种途径，写代码就会更加灵活，后期当你深入学习后就会慢慢理解。

2.3 指针变量的大小

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

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

由此可见指针变量的大小取决于地址的大小。

32位平台下地址的大小是32个bit位（4个字节）,64位平台下地址的大小是64个bit位（8个字节）。

X86环境下 X64环境下

结论：

• 32位平台下地址是32个bit位，指针变量大小是4个字节

• 64位平台下地址是64个bit位，指针变量大小是8个字节

• 注意指针变量的大小和类型是无关的，只要指针类型的变量, 在相同的平台下, 大小都是相同的。

3. 指针变量类型的意义

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

其实指针类型是有特殊意义的，下面开始分析指针变量类型的意义。

3.1 指针的解引用

对比下面两段代码调试后在内存中的地址的变化：

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0。 结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。

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

3.2 指针+-整数

观察下面代码运行结果：

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

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

3.3 void* 指针

在指针类型中有一种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;

	char* pc = &a;

	void* pd = &a;

	return 0;
}

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

但是也有局限性，void* 类型的指针不能直接进行指针的+-整数和解引用的运算。

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

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

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

4. 指针运算

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

• 指针+-整数

• 指针-指针

• 指针的关系运算

4.1 指针+-整数

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

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

#include <stdio.h>
//指针 +- 整数
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 (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));//p+i 这里就是指针+整数

	}
	return 0;
}

4.2 指针 - 指针

指针 - 指针前提，两个指针必须指向同一块空间，否则不能相减。

下面代码中用到指针减指针的操作，求的是两个指针间的元素个数，求出的是字符串的长度。

#include <stdio.h>
int me_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}

int main()
{
	printf("%d\n",me_strlen("abc"));
	return 0;
}

数组随着下标的增长，地址是由底到高变化的。即：

&arr[0] + 9 = &arr[9]

4.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;
}

5. const 修饰指针

5.1 const 修饰变量

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

#include <stdio.h>
int main()
{
    int a = 10;
    a = 20;//可以被修改

    const int b = 20;
    b = 10;//错误，不能被修改

    return 0;
}

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

但如果我们绕过变量，通过地址去更改，就可以实现：

 #include <stdio.h>
 int main()
 {
     const int n = 0;
     int* p = &n;

     *p = 20;
  
     return 0;
 }

上述代码就可以实现n的值的修改，n被const修饰，就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让 p拿到n的地址也不能修改n，那接下来怎么做呢？

5.2 const 修饰指针变量

一般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，意义是不一样的。

int * p;//没有const修饰
 
int const * p;//const 放在*的左边做修饰

const int * p;//const 放在*的左边做修饰
 
int * const p;//const 放在*的右边做修饰

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

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

6. 野指针

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

6.1 野指针成因

6.1.1 指针未初始化

下面代码中*p指针变量未初始化，所以指向地址里面的值是随机值，然后随机找到一块地址，修改里面的值为20。

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

    return 0;
}

6.1.2 指针越界访问

下面代码，当指针变量*p访问数组时，越界访问到大于数组大小的值时，就是野指针。

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

6.1.3 指针指向的空间释放

下面代码中，指针变量*p接收了函数test()返回的n的地址，但是n是函数test()里面的局部变量，在出函数test后n变量就释放了。此时*p指向的地址里面的值就是随机值。

#include <stdio.h>
int* test()
{
    int n = 100;
    return &n;
}

int main()
{
    int* p = test();
    printf("%d\n", *p);

    return 0;
}

6.2 如何规避野指针

6.2.1 指针初始化

如果明确知道指针指向哪里就直接赋值地址。

如果不知道指针应该指向哪里，可以给指针赋值NULL，这样指针会有一块明确的地址指向。

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

#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。

#include <stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	for (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 避免返回局部变量的地址

不要把返回局部变量的地址赋值给指针变量。

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 版本中不使用有利于不影响用户使用时程序的效率。

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

8.1 strlen的模拟实现

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

原型如下：

size_t strlen ( const char * str );

参数str接收一个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回长度。如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停止。

代码如下：

代码中 const 修饰指针变量str，是防止字符串的值被改变。因为返回的值是字符串的长度，是无符号整型，用size_t 修饰更好一些。在len函数中使用 assert 函数判断下指针是否为空，再使用更加保险一些。打印size_t（无符号整型时），使用%zd格式控制符更好一些。

#include <stdio.h>
#include <assert.h>

size_t len(const char* str)
{
	size_t count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	size_t a = len(arr);
	printf("%zd\n", a);

	return 0;
}

8.2 传值调用和传址调用

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

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

错误方法：

#include <stdio.h>

void swap(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	
	printf("交换前：a = %d,b = %d\n", a, b);

	swap(a, b);

	printf("交换后：a = %d,b = %d\n", a, b);

	return 0;
}

我们发现其实没产生交换的效果，这是为什么呢？

通过调试中的监视，如下：

我们发现在main函数内部，创建了a和b，a的地址是0x0000006db8f1f964，b的地址是0x0000006db8f1f984 ，在调用 Swap 函数时，将a和b传递给了swap 函数，在swap函数内部创建了形参 x 和 y 接收 a 和 b 的值，但是 x 的地址是 0x0000006db8f1f940 ，y的地址是0x0000006db8f1f948 ，x和y确实接收到了a和b的值，不过x的地址和a的地址不一样，y的地址和b的地址不一样，相当于x和y是独立的空间，那么在swap函数内部交换x和y的值，自然不会影响a和b，当swap函数调用结束后回到main函数，a和b的没法交换。

swap函数在使用的时候，是把变量本身的值直接传递给了函数，这种调用函数的方式叫

传值调用。

结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。所以上面代码是失败的。

正确方法：

#include <stdio.h>

void swap1(int* pa, int* pb)
{
	int tmp = 0;
	tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
int main()
{
	int a = 10;
	int b = 20;

	printf("交换前：a = %d,b = %d\n", a, b);

	swap1(&a, &b);

	printf("交换后：a = %d,b = %d\n", a, b);

	return 0;
}