C++指针与数组:指针详解

编辑: admin 分类: c#语言 发布时间: 2022-03-15 来源:互联网
目录
  • 一. What(什么是指针)
    • 1. 地址初了解
    • 2. 指针概念
    • 3. 指针与指针变量
  • 二. Why(为什么要有指针)
    • 三. How(如何使用指针)
      • 1. 基本定义
      • 2. 取地址操作符 &
      • 3. 解引用操作符 *
      • 4. 结构体指针
      • 5. 多级指针
      • 6.指针变量的命名规范
    • 四. 我对指针的一些理解
      • 总结

        本文主要介绍C语言中指针的基本概念与用法,本博文从零开始讲解指针,只要你了解基本的C语法,相信你看完本文后一定会有所收获。

        一. What(什么是指针)

        1. 地址初了解

        要搞明白什么是指针,首先我们得先了解一个概念:地址。

        什么是地址呢?

        我们知道,计算机的内存是一块连续的大块存储空间,为了提高 CPU 查找数据的效率,我们将这块连续的存储空间以字节为单位进行编号,每个字节都一一对应了一个编号,这个编号就叫做地址。

        举个形象的例子:

        如果我们把一座宿舍楼看做是内存,那么宿舍楼里的房间我们就可以看成是内存里的每一个字节,那么每个房间的门牌号就可以看做是地址。

        为什么要有地址?

        通过上面的例子,我们很容易了解到地址存在的意义。试想,如果宿舍楼里的房间都没有门牌号,我们就很难描述一指定房间的具体位置。CPU 对内存的处理也是如此,如果没有地址,CPU 就没有办法确定指定内存的具体位置,从而正确且快速的访问到该内存空间。

        2. 指针概念

        • 指针就是地址
        • 指针就是地址
        • 指针就是地址

        重要的事情说三遍,我们必须明确的知道一件事,指针就是地址,可以理解为,指针是地址在C语言里的一种特殊叫法。

        #include <stdio.h>
        int main()
        {
        	int a = 10;
        	int *p = &a;		// p是不是指针?
        	printf("%p\n", p);  // %p 可以格式化输出地址。
        	return 0;
        }
        

        既然如此,上述代码中 p 是不是指针呢?

        我们说过指针就是地址,而 p 是不是地址?当然不是!地址是一个单独的数据,就像 int a = 10; 我们能说 a 就是 10 吗?当然不能,10是一个整形常量,而 a 是一个整形变量,我们只能说 a 里面存放的值是 10,而不能简单的说 a 就是 10。

        同理,上述代码中的 p 是一个变量,里面存放的是 a 的地址,我们称它为指针变量。所以严格意义上来说,p 不是指针,而是指针变量。就像 a 不是整数10,而是整形变量一样

        那么什么是指针呢,我们把这段代码运行起来:

        结果

        没错,严格意义上来说,这段数字才真正的叫做指针 (地址值在计算机中一般以16进制显示)。

        3. 指针与指针变量

        通过上面的讲解,相信大家可以理解,指针是地址,是一个常量,而指针变量是一个变量,里面存放的是指针,这两者之间有着本质区别。

        看到这,相信有些同学就有疑问了:明明上课的时候,或者某些书上都将指针变量统称为指针,就像 上例中的 p 平时都叫做指针,为什么现在又说 p 不是指针呢?

        请大家注意,我说 p 不是指针是在严格意义上来说。

        在日常使用中,我们经常把指针和指针变量混为一谈。这似乎成为了一种习惯,甚至我在下面的表述中都可能将指针变量表述为指针。

        结论是:我们在日常使用中,可以模糊指针与指针变量的概念,把指针变量统称为指针,但是,我们心里必须清楚的意识到,指针和指针变量的本质区别,以及你叫的这个东西到底是指针还是指针变量。

        二. Why(为什么要有指针)

        经过上面的讲解,相信这个问题就非常简单了。指针就是地址,那么为什么要有地址?究其原因就是,为了提高查找效率

        试想如果没有地址的存在,我们写下 int a = 10; 的时候,系统会自动在内存中开辟一4字节的空间存放10这个数值。而我们 CPU 在访问的时候,由于没有地址的存在只能在内存中一块一块的遍历对比查找,而有了地址,内存就可以把地址值告诉 CPU,CPU 就可以根据地址值直接定位到该内存,大大提高了 CPU 访问内存的效率与准确性。

        三. How(如何使用指针)

        1. 基本定义

        指针变量的定义格式较简单,只要在类型和变量名之间加上 * 操作符,就可以定义该类型的指针变量。

        int *a = NULL;				//定义整形指针变量
        double *d = NULL;			//定义双精度浮点型指针变量
        struct stdnt *ps = NULL;	//定义结构体指针变量
        

        注: NULL 是指针变量初始化的时候常用的宏定义,称其为空指针,本质为 0 值。

        如果定义时不初始化,如:

        int *a;
        

        我们知道,变量如果不初始化,其中的值就是随机值,也就是此时的指针变量 a 里面存放的是随机值,如果此时访问 a 变量就会以这个随机值作为地址访问对应的内存,这种操作是非法的。这种不初始化的指针我们称之为野指针。

        所以,为了避免野指针的出现,我们在定义指针变量时尽量对其进行初始化。

        2. 取地址操作符 &

        我们使用指针就是使用地址,那么地址从何而来?我们可不可以这么写代码:

        int *a = 0x11223344;
        

        我们把 0x11223344 看做是地址值交给整形指针变量 a 来存储。语法上没有问题,但是这样写毫无意义!因为 0x11223344 这个地址对于我们来说是未知的,我们并没有读取和访问的权限,这时候的 a 变量就相当于一个野指针。

        事实上,我们的地址是由 & 取地址符取出来的。

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

        这里我们定义了整形变量 a,取地址符取出了 a 的地址并把它赋给整形指针变量 p。

        这里就有一个疑问,a 是一个整形变量,占4字节的空间,而通过上面的介绍,我们知道内存的地址编号是以字节为单位的,这就意味着变量 a 其实存在4个地址,那么 &a 究竟取出的是哪一个地址呢?

        上结论:

        在C语言中,对任意类型的变量或者数组取地址,永远取得是数值上最小的那个地址。

        我们画一下上面代码的内存分布图:

        内存分布图

        假设从左向右地址依次升高,那么 p 里面存放的就是 a 变量4字节中地址最低的那个字节的地址。

        3. 解引用操作符 *

        我们上面说到,对变量取地址取得是地址最低的字节即首字节地址,那么我们如何通过这一个字节的地址访问到原变量里的数据呢,这里就需要使用 * 操作符:

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

        看上面的代码,我们把 a 变量的地址赋值给指针变量 p,通过 *p 即可访问到该变量的内容。

        那么 * 操作符到底是如何使用的呢,下面给出结论:

        对指针解引用,就是指针指向的目标。

        就像上例中 *p 是什么?*p 就是 a,*p 就是 a,*p就是a,重要的事情说三遍。所以,如果我改变 *p 的值,完全等价于直接改变 a 变量的值。

        上面的代码运行结果:

        运行结果

        那么,我们看下面这段代码:

        int main()
        {
        	int a = 0x11223344;
        	int *p = &a;
        	printf("0x%x\n", *(char*)p);
        	return 0;
        }
        

        注意,我们说 *p 就是 a,但是,这里的 *p 被强制类型转化为 char* 类型之后再进行的解引用操作,此时的 p 就是一个字符类型的指针,因为字符 char 类型在C中只占一个字节,对其进行解引用只能访问一个字节的内容。而我们说过 p 中存放的是 a 变量的首字节的地址,即 44 的地址 (至于为什么,请读者自己了解大小端的内容),解引用就只访问到了 44:

        运行结果

        4. 结构体指针

        下面定义一个结构体:

        typedef struct Student
        {
        	int age;
        	char name[20];
        	char sex[2];
        }STD;
        

        C语言中任何数据类型都有其对于的指针类型,结构体也不例外,如下:

        int main()
        {
        	STD s = { 18, "张三", "男" };
        	STD *ps = &s;		// 定义结构体指针
        	printf("%s\n%d\n%s\n", s.name, s.age, s.sex);
        }
        

        我们定义一个结构体变量并初始化,通过 . 操作符可以很容易访问到结构体的内容。那么我们如何通过结构体指针变量 ps 来访问结构体的内容呢?

        我们说过对指针解引用,就是指针指向的目标,那么请读者思考,*ps 是什么呢?没错 *ps 就是 s变量,既然如此,我们就可以这么访问:

        	printf("%s\n%d\n%s\n", (*ps).name, (*ps).age, (*ps).sex);
        	//注:因 . 操作符优先级高于 * 操作符,故 (*ps) 必须加括号
        

        结果

        C语言可能认为这样写太麻烦,于是对于结构体指针我们可以使用 -> 操作符直接访问到结构体的内容:

        	printf("%s\n%d\n%s\n", ps->name, ps->age, ps->sex);
        

        ps->name 写法完全等价于 (*ps).name 这样的写法。
        注:-> 操作符只在结构体指针变量访问结构体成员时使用。

        5. 多级指针

        首先问大家一个问题,指针变量是不是变量?是变量。既然是变量,那么就有地址,我们依然可以把指针变量的地址存入一个新的变量,此变量我们可以称为二级指针变量:

        int a = 10;
        int *pa = &a;
        int **ppa = &pa;  // 定义二级指针变量
        *ppa;  //等价于 pa
        **ppa; //等价于 *pa,即等价于 a
        

        二级指针大家不要看的多么神秘,所谓二级指针其实也就是一个指针变量,只不过里面存放的是另一个指针变量的地址而已。
        既然如此,二级指针变量是不是变量呢?它能不能取地址存入另外一个三级指针变量呢?那么,三级指针变量是不是变量呢?… 如果你愿意,可以一直这么套娃下去~

        6.指针变量的命名规范

        之所以把这块单独分出来讲,是因为对指针变量进行一个好的命名规范,不仅有利于提高代码的可读性,更有助于我们理解一些复杂的数据结构的代码。

        指针的命名习惯上在原变量名前加字母 p。 如定义整形变量 a ,其指针变量就命名为 pa, 定义结构体变量 std 其对应指针变量命名为 pstd,如果对 pstd 再次取地址存入二级指针变量,那么该二级指针变量就应该命名为 ppstd。

        四. 我对指针的一些理解

        都说指针是C语言的灵魂,那么指针的魅力究竟在何处?

        我们看这段交换两个数的代码:

        #include <stdio.h>
        void Swap(int a, int b)
        {
        	int t = a;
        	a = b;
        	b = t;
        }
        int main()
        {
        	int a = 10;
        	int b = 20;
        	Swap(a, b);
        	printf("a = %d\n", a);
        	printf("b = %d\n", b);
        	return 0;
        }
        

        我们应该知道,这段代码是无法完成 a, b 的交换的,因为 Swap() 里的 a, b 只不过是 main() 函数里 a, b 的一份拷贝。即,Swap() 函数里 a, b 的改变是不会影响 main() 函数的。这种传参的方式我们称之为传值。

        可是我们这么写:

        #include <stdio.h>
        void Swap(int *pa, int *pb)
        {
        	int t = *pa;
        	*pa = *pb;
        	*pb = t;
        }
        int main()
        {
        	int a = 10;
        	int b = 20;
        	Swap(&a, &b);
        	printf("a = %d\n", a);
        	printf("b = %d\n", b);
        	return 0;
        }
        

        main() 传参时传 a, b 的地址,Swap() 函数使用指针进行接收,内部使用解引用方式进行交换,我们就可以完成真正的交换功能。这种传参的方式我们称之为传址。

        我在一篇文章上看到这样一个说法,可谓是对指针理解到了本质:

        • 传值就是传值。
        • 传址就是传值本身。

        值和值本身两个概念希望大家能够深刻理解。

        如同我们 Swap() 函数的第一种写法,main() 函数仅仅是将 a, b 的值传递给了 Swap() 函数进行处理,可无论 Swap() 函数对其做什么样的处理,也依然无法改变原来 a, b 的值。

        而 Swap() 的第二种写法,main() 函数传的是 a, b 的地址,相当于传的是 a, b 本身,这样 Swap() 在进行处理时便可直接改变原来的 a, b 的值。

        总结

        本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注海外IDC网的更多内容!