深入理解指针（1）

一、内存和地址

在讲内存前，我们可以引入一下一个生活的列子这样更加好理解：我们刚刚开学还没有知道自己的宿舍时，我们怎么样找到宿舍呢？我们可以看到每个宿舍都有一个自己独立的“名字”，也就是门牌号。也就是因为有了门牌号可以让我们能快速的找到宿舍在哪里。按照上面的例子，把它放在计算机中又是怎么样的呢？

我们知道在计算机上CPU处理数据的时候需要的数据是从内存中读取的，处理后的内存会放回内存中。那这些内存空间又是如何高效的处理的呢?其实也是把内存划分成很多个内存单元，每一个内存单元的大小取1个字节。其中，每一个内存单元就好比一个学生宿舍，一个字节空间里面能放入8个比特位，这个又好比一个宿舍里面住8个同学。每个内存单元都有一个编号，这就好比宿舍的门牌号，有了这个编号CPU也就能更好的找到这个内存空间。
在生活中我们把门牌号叫做地址，在计算机中我们把内存单元的编号叫做地址，而在C语言中我们给地址起了一个新名字叫做：指针
我们可以这样理解：内存单元的编号 == 地址 ==指针

二、指针变量和地址

1、取地址操作符（&）

上面我们讲解了内存和地址，回到我们C语言来，在C语言中创建变量其实就是向内存申请空间，列子如下：

上图可以看到，我们创建了整型a变量，向内存中申请了四个字节的空间，后将10存进a中（上面存储是转换成十六进制位），我们也会发现上面每一个字节都会有自己的地址。那我们又是如何能得到a的地址的呢？
下面我们就来讲一个操作符（&）—取地址操作符。

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

如上代码展示就可以得到a的地址了。
&a取出的是a所占4个字节中地址较小的字节的地址。

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

（1）指针变量

那我们通过取地址操作符（&）拿到的地址是一个数值，那这样数值也是要存储起来的，那我们又要用什么东西把它存起来呢？答案是：指针变量
我们可以写个代码来举个例子：

#include <stdio.h>
int main()
{
    int a = 10;
    int *pa = &a;    //这里我们就是将a的地址取出来存放在指针变量pa中
    return 0;
}

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

（2）如何拆解指针类型

1、int a = 10;
2、int *pa = &a;

我们可以看到a的类型是int，而pa的类型是int*，这我们又怎么样理解指针的类型呢？这里pa左边写的是int，是在说明pa是指针变量，前面的int是在说明pa是指向（int）这个整型类型的对象。

（3）解引用操作符

我们将地址保存了起来，那将来我们要使用的时候我们又该怎么使用呢？
这里我们再举一个生活中的例子：我们使用地址找到一个房间，再房间里我们可以拿去或者存放物品。
如果是换成再C语言中我们是不是也可以这样理解呢？我们只要拿到了地址（指针），就可以通过这个地址找到地址指向的对象呢？所以这里我们就会学到一个操作符——解引用操作符（*）

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

如上图我们可以看到，*pa的意思就是通过pa中存放的地址，找到指向的空间，pa其实就是a的变量。往后看我们可以看到我们将0赋值给了pa，这样的话a就是0了。那这样我们会产生一个疑问：为啥不直接将a改成0，而是要搞这么多的工程（非要搞一个指针）。这个到后面我们就可以慢慢理解了，这个是多一个途径，同时也是可以让我们的代码更加的灵活一些。

3、指针变量的大小

#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位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）

这个是在x64的环境输出的结果

这个是在x86环境输出的结果

综上所述，我们可以得出结论：

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

三、指针变量类型的意义

讲完上述内容，我们会产生一些疑问，指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？下面我们慢慢了解。

1、指针的解引用

我们来看下列两个代码

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

	return 0;
}

输出结果：

#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pn = (char*)&n;
	*pn = 0;

	return 0;
}

输出结果是：

由上述两个代码我们可以看到，代码1会将n的4个字节全部改成0，而代码2只是将n的第一个字节改成0
由此我们又可以得出结论：
指针的类型决定了对指针解引用的时候有多大的权限，简答点说就是决定了一次能操作几个字节。

2、指针 ± 整数

我们直接就是上代码，这样就非常方便理解。

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* 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个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1.
综上所述，我们可以得到结论：
指针的类型决定了指针向前或者向后走多大的距离。

3、void*指针

在指针类型中还存在一种特殊类型的指针——void*类型 ，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，void*类型的指针不能直接进行指针的±整数和解引用的运算.
下面我们来举一个例子，方便我们理解：

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

	return 0;
}

我们看到上述代码，将一个int类型的变量的地址赋值给一个char类型的指针变量。编译器会给出一个警告。

那如果我们用void类型的指针接受地址呢？

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

	return 0;
}

这里我们可以看到，void类型的指针可以接受不同类型的地址，但是无法直接进行指针运算。
这时候我们又会想，那这个void类型的指针到底有什么用呢？void*类型的指针一般是使用在函数参数的部分，用来接受不同类型数据的地址，这样的设计可以实现泛型编程的效果。

四、const修饰指针

1、const修饰变量

变量是可以修改的，如果把一个变量的地址交给一个指针变量，那么通过这个指针变量也是可以修改这个变量的，但是如果我们希望一个变量加上一些限制，不能被修改，那这样怎么做呢？这个时候我们就可以用到const修饰指针。
我们来举个例子：

#include <stdio.h>
int main()
{
	int m = 0;
	m = 20;
	const int n = 0;
	n = 20;

	return 0;
}

上面的代码运行结果：

我们可以看到代码无法运行，是因为n已经被限制不能被修改了。如果想强行修改编译器就会报错。但是如果我们绕过n，使用n的地址去修改n就能做到了，虽然这样子做是在打破语法规则。

int main()
{
	const int n = 0;
	printf("n = %d\n", n);
	int* p = &n;
	*p = 20;
	printf("n = %d\n", n);

	return 0;
}

上述代码的运行结果：

根据上述的输出结果我们可以看到确实是可以修改的，但是我们还是要思考一下，为什么n要被const修饰呢？就是为了不能被修改,如果p拿到了n的地址就可以修改n的话，是不是这样就可以打破const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那我们又该怎么做呢？

2、const修饰指针变量

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

1、int * p; //这个是没有const修饰
2、int const * p; //const放在*的左边做修饰
3、int * const p; //const放在*的右边做修饰

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

五、指针运算

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

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

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++0)
    {
        printf("%d ",*(p + i));
    }
    return 0;
}

以下是运行结果

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

以下是代码运行结果

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

以下是代码的运算结果

六、野指针

下面我们来介绍一下野指针：野指针就是指针指向的位置是不可知的（可以说是随机的、不正确的）

1、野指针的成因

（1）指针未初始化

我们可以直接上代码：

#include <stdio.h>

int main()
{
	int* p;  //局部变量指针未初始化，默认是随机值
	*p = 20;

	return 0;
}

（2）指针越界访问

#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	int i = 0;

	for (i = 0; i <= 11; i++)
	{
	    //当指针指向的范围超出数组的范围时，p就为野指针
		*(p++) = 1;
	}
	return 0;
}

运算结果：

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

#include <stdio.h>

int* test()
{
	int n = 100;
	return &n;
}

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

	return 0;
}

2、如何避免野指针

（1）指针初始化

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

#include <stdio.h>

int main()
{
    int num = 10;
    int *p1 = &num;
    int *p2 = NULL;

    return 0;
}

(2)小心指针越界

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

（3）指针变量不再使用时，及时设置为NULL，指针使用之前检查有效性

当指针变量指向一块区域的时候，我们可以通过指针访问该区域，如果后面不再使用这个指针访问空间的时候，我们可以吧该指针置为NULL。只要时NULL 指针就不去访问，同时使用指针之前可以判断指针是否为NULL。

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

如果造成野指针的第3个列子，不要返回局部变量的地址。

七、assert断言

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

assert(p != NULL);

我们可以看到上述的代码在程序运行时，验证变量p是否等于NULL。如果等于则就会终止运行，并且给出报错信息提示。反之，则可以继续运行。
**assert（）**宏接受一个表达式作为参数。如果表达式为真，assert（）不会产生任何作用，程序可以继续进行。如果表达式为假，assert（）就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。
assert（）的使用对程序员是非常友好的，用assert（）有几个好处：
它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert（）的机制。如果已经确认程序没有问题，就不需要再做断言，就在#intclude <assert.h>前面加上定义一个宏NDEBUG。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的assert（）语句。如果程序又出现问题，就可以移除这条指令（把它注释掉），再次编译，就像上面一样重新启用这个语句。
assert（）的缺点是：因为引入了额外的检查，增加了程序的运行时间。
一般我们可以在Debug中使用，在Release版本中选择禁用assert就行，在VS这样的集成开发环境中，在Release版本中，直接就是优化掉了。这样在Debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

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

1、strlen的模拟实现

库函数strlen的功能就是求字符串长度，统计的时\0之前的字符的个数。
函数原型如下：

size_t strlen(const char *str);

参数str接收一个字符串的起始地址，然后开始统计字符串中\0之前的字符个数，最终返回长度。如果要模拟实现只要从起始地址开始向后逐个字符遍历，只要不是\0字符，计数器就+1，这样到\0就结束。
我们可以来自己创建一个strlen函数：

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

int My_strlen(const char *str)
{
    int count = 0;
    assert(str);
    while(*str)
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    int len = My_strlen("abcdef");
    printf("%d\n",len);
    
    return 0;
}

以上就是模拟实现strlen函数的代码。

2、传值调用和传址调用

不用指针也可以解决很多问题，那为什么我们还要学习指针呢？指针又有什么用呢？那又啥是非指针不可呢？
下面我们来举一个例子：写一个函数，交换两个整型变量的值
不用指针进行操作：

#include <stdio.h>

void Swap(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);
	Swap(a, b);
	printf("交换后：a = %d  b = %d", a, b);

	return 0;
}

以下是代码的运算结果：

我们在main函数内部创建了a和b，在调用函数的时候将a和b传递给了Swap函数，在Swap函数内部创建了形参x和y接受a和b的值，x和y确实接受到了a和b的值，不过x的地址和a的地址不一样，y的地址和b的地址也不一样，相当于x和y是独立的空间，那么Swap函数内部交换x和y的值，自然是不会影响a和b，当Swap函数调用结束后回到main函数
a和b没法交换。Swap函数在使用的时候，是把变量本身直接传递给了函数，这样调用函数的方法就是传值调用
结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。

那我们想交换这两个值又该怎么做呢？

#include <stdio.h>

void Swap(int* px, int* py)
{
	int tmp = 0;
	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", a, b);

	return 0;
}

以下为代码运行结果

我们看到上述代码结果，我们得到了我们想要的结果，这种方式就叫做：传址调用
传址调用可以让函数和主函数之间建立真正的联系，在函数内部可以修改主调函数中的变量，所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用。