指针（1）

1.内存和地址

在讲内存和地址之前，我们想有个生活中的案例： 假设有⼀栋宿舍楼，把你放在楼里，楼上有100个房间，但是房间没有编号，你的⼀个朋友来找你玩， 如果想找到你，就得挨个房子去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：201，202，203等等。有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。

如果把上面的例子对照到计算中，计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数 据也会放回内存中，计算机其实也是把内存划分为⼀个个的内存单元，每个内存单元的大小取1个字节。其中，每个内存单元，相当于⼀个学生宿舍，⼀ 个人字节空间里面能放8个比特位，每个内存单元也都有⼀个编号（这个编号就相当 于宿舍房间的门牌号），有了这个内存单元的编 号，CPU就可以快速找到⼀个内存空间。生活中我们把门牌号也叫地址，在计算机中我们 把内存单元的编号也称为地址。C语言中给地址起 了新的名字叫：指针。 所以我们可以理解为： 内存单元的编号==地址==指针

2.指针变量和地址

2.1取地址操作符（&）

在C语言中创建变量其实就是向内存申请空间，假如我们创建一个整形变量int a = 10，该代码就会向内存申请4个字节，用于存放整数10，每个字节都有一个地址。

我们通过取地址操作符&就可以得到a的地址，&a取出的是a所占4个字节中地址较小的地址。

#include <stdio.h>
int main()
{
	int a = 10;
	printf("%p", &a);//0000004F858FF6C4
	return 0;
}

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

（1）指针变量

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

比如：

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

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

  int a = 10;   //指针变量的类型是int *
  int* p = &a;  //*说明p是指针变量，
                //而int是在说明是在说明p所指向的是int类型的对象
                

（2）解引用操作符（*）（间接访问操作符） 

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

#include <stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	printf("%d\n" ,* p);//10
	*p = 0;
    //*&a = 0；//取出地址再解引用，其实*&就相互抵消了
	printf("%d", *p);//0
	return 0;
}

 p中存放的是a的地址，而*p的意思就是p中存放的地址，找到指向的空间，*p其实就是a变量了。

（3）指针变量的大小

#include <stdio.h>
int main()
{
	//指针变量的大小取决于地址的大小
	//32位平台下，地址是32个比特位（4个字节）
	//64位平台下，地址是64个bit位（8个字节）
	printf("%zd\n", sizeof(char *));
	printf("%zd\n", sizeof(short *));
	printf("%zd\n", sizeof(int *));
	printf("%zd\n", sizeof(double *));
	//返回值都是8
	return 0;
}

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

3.指针变量类型的意义 

3.1指针的解引用

//代码1
int main()
{
	int a = 0x11223344;
	int* p = &a;
	p = 0;
	return 0;
}

//代码2
int main()
{
	int a = 0x11223344;
	char* p = (char *)&a;
	p = 0;
	return 0;
}

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

3.2指针+-整数

#include <stdio.h>
int main()
{
	int n = 10;
	int* pc = &n;
	char* pi = (char *)&n;  //写成char * pi = &n;编译器会给出一个警告
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return 0;
}

 代码运行结果：

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

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

3.3void*指针

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

int main()
{
	int a = 0x11223344;
	char* p = &a;
	*p = 0;
	return 0;
}

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

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

int main()
{
	int a = 10;
	void* pc = &a;
	void* pi = &a;

	 *pc = 10;
	 *pi = 0;
	return 0;
}

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

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

4.const修饰指针

4.1const修饰变量

const可以给变量加上限制，使其不能被修改 

int main()
{
	const int n = 10;
	n = 20;
	return 0;
}

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

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

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

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

4.2const修饰指针变量

#include <stdio.h>
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 30;//可以，*p=30
	p = &m;//可以，*p为20
	
}
void test2()
{
	int n = 10;
	int m = 20;
	int const* p = &n;
	*p = 30;//不可以，会报错，指针变量指向的内容不可以改变
	p = &m;//可以，指针变量本身的内容可以改变
}
void test1()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 30;//可以，指针变量指向的内容可以改变
	p = &m;//不可以，指针变量本身的内容不能改变

}
void test4()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 30;//不可以
	p = &m;//不可以

}

int main()
{
	//测试无const修饰的情况
	test1();
	//测试const在*左边的情况
	test2();
	//测试const在*右边的情况
	test3();
	//测试*两边都有*的情况
	test4();
	return 0;
}

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

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

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

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 i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{                            //*p指的是数组的第一个元素
		printf("%d ", *(p + i));//输出数组
	}
	return 0;
}

（2）指针-指针 

 指针1 + 整数 = 指针2     指针2-指针1=整数

指针 - 指针得到值的绝对值是两个指针之间的元素个数

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);//9
	printf("%d\n", &arr[0] - &arr[9]);//-9
	return 0;
}

(3)指针的关系运算

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

6.野指针 

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

6.1野指针成因

（1）指针未初始化

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

(2)指针越界访问

#include <stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 5; i++)//当指针指向超出数组arr的范围时，p就是野指针
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

（3）指针指向的空间释放

#include <stdio.h>
int* test()
{
	int n = 100;
	return &n;
}
int main()
{
	int* p = test();//返回局部变量的地址不确定
	printf("%d\n", *p);
	return 0;
}

6.2如何规避成为野指针 

（1）指针初始化

（2）小心指针越界

（3）避免返回局部变量的地址

（4）指针变量不在使用时，及时设置NuLL，指针使用前检查有效性

7.assert断言

assert.h 头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。assert()宏接受⼀个表达式作为参数。如果该表达式为真（返回值非零）， 任何作用，程序继续运行。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误stderr中写入⼀条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。assert() 的使用对程序员是非常友好的，使⽤ assert() 有几个好处：它不仅能自动标识文件和出问题的行号，还有⼀种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问 题，不需要再做断言，就在#include语句的前面，定义⼀个宏NDBUG 。然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 比特就业课 assert() 语 句。assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。 ⼀般我们可以在 Debug 中使用，在Release 版本中选择禁用 assert 就行，在 vs这样的集成开发环境中，，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响用户使用时程序的效率。