深入学习指针（一）

1、指针的概念

       我们知道CPU在处理数据时，需要从内存中读取数据，处理后的数据也要放回到内存中。那么数据在内存中是怎么储存的呢？其实内存被划分为一个个的内存单元，每个内存单元都有一个编号。有了这个编号，CPU就可以快速找到目标内存空间。

       在计算机中我们把内存单元的编号也称为地址。在C语言中给地址取了个新的名字：指针。所以我们可以理解为：内存单元的编号==地址==指针。

2、变量和地址

       在C语言中创建变量就是向内存申请空间。例如：

int a=1;
int b=2;

int* pa=&a;
int* pb=&b;

       上述代码创建了a、b、pa和pb四个变量，向内存申请了四块不同的内存空间；分别将1和2的值赋给a和b，又将a和b的地址赋给pa和pb。我们把内存比作学生宿舍楼，那么上述代码的含义可以这样理解：

     （1）有两个学生分别是学生“1”和学生“2”；

     （2）1住在宿舍a中，2住在宿舍b中；

     （3）宿舍a的门牌号就是&a，宿舍b的门牌号就是&b；

     （4）宿舍登记登记簿将门牌号&a记录在pa一栏，将门牌号&b记录在pb一栏。

       像上面我们用取地址操作符（&）拿到a的地址，比如：0x006FFD70，又将这个值赋给pa（即把a的地址存放在变量pa中），像这种存放地址的变量就是指针变量，存放在指针变量中的值都会理解为地址。

3、理解指针变量类型

       我们看变量pa的类型为int*，我们该如何理解指针的类型呢？

int a=10;
int* pa=&a;

       上述代码中pa左边是int*，其中“*”是在说明pa是指针变量类型，而前面的“int”是在说明pa指向的是整型（int）类型的对象。 

       那么char类型的变量ch的地址要放在什么类型的指针变量中呢？

char ch='w';
char* pc=&ch;//放在char*类型的指针变量中

4、使用指针变量

       ~取地址操作符（&）：单目操作符&是用来取操作对象的地址。例如：&a是取变量a的地址。在上面3的代码中，&a取的是a所占4个字符中地址较小的字节的地址，虽然整型变量占4个字节，我们只要知道了第一个字节的地址，顺藤摸瓜访问到4个字节的数据是可行的。

       ~解引用操作符（*）：作用是通过操作对象的地址获取储存的内容。例如：pa=&a，pa为a的地址，*pa则是通过a的地址获取a的内容。下面是简单的代码：

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

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

       有人肯定在想，如果目的就是把a改成改成0的话，写成“a=0；”不就行了，为什么非要用指针呢？其实这里就是把a的修改交给了pa来操作，这样对a的修改就多了一种途径，写代码就会更灵活。

5、指针变量的大小

     5.1、如何理解编址

       要了解指针变量的大小，就要先理解编址。CPU要访问内存中的某个字节空间，就必须知道这个字节空间在内存的哪个位置，而因为内存中字节很多，所以需要给内存进行编址（就和一栋宿舍楼有很多宿舍，需要给宿舍编号一样）。计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

       首先，必须理解计算机内是有很多的硬件单元，而硬件单元是要互相协同工作。所谓协同合作，至少相互之间要能够进行数据传输。而硬件和硬件之间是相互独立的，那么如何通信呢？答案就是：用”线”连起来。而CPU和内存之间也是有大量的数据交互，所以两者之间也必须用线连起来。

       CPU和内存主要靠三组线连接，分别是地址总线、数据总线、控制总线。我们现在只要了解一组线，就是地址总线。可以简单理解，32位机器有32根地址总线。每根线只有两种状态，表示0，1【电脉冲有无】，那么一根线，就可以表示2种含义，2根线就可以表示4种含义。依次类推，32根地址线就可以表示2^32种含义。地址信息通过地址总线，在内存上就可以找到该地址对应的数据，将数据再通过数据总线传入CPU内寄存器。

     5.2、深入了解指针变量的大小

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

       

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

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

      5.3、结论 

       1、32位平台下地址是32个比特位，指针变量的大小是4个字节。

       2、64位平台下地址是64个比特位，指针变量的大小是8个字节。

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

6、指针类型的意义

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

        调试观察在n内存中的变化，我们可以看到代码1会将4个字节全部为0，但是代码2只是将n的第一字节改为0.

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

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

     6.2、void*指针

       6.2.1、void*指针的作用

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

       6.2.2、void*指针的使用

       

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

        在上面的代码中，将一个int类型的地址赋给了一个char*类型的指针变量。编译器给出了警告（如下图所示），是因为类型不兼容。

       如果使用void*类型就不会出现这样的问题：

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

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

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

	*pa1 = 10;
	*pa2 = 0;
	return 0;
}

       观察上面我们可以看到，void*类型的指针虽然可以接收不同类型的地址，但是无法直接进行指针的运算。那么void*类型的指针到底有什么用呢？一般是用在函数参数部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。

7、const修饰指针变量

       7.1、const修饰变量

       变量是可以修改的，但是如果我们希望给一个变量加上一些限制，使它不能被修改，该怎么做呢？很简单，就是用const对该变量进行修饰。请看代码：

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

      可以看到m的值被修改了，但如果： 

       可以看到，被const修改的变量n是不能被修改的，一旦修改VS编译器就会报错。其实n的本质还是变量 ，只不过被const修饰后，在语法上加了限制。

       如果我们绕过变量n，把变量n的地址交给一个指针变量，通过指针变量就可以修改n的值了。请看代码：

#include<stdio.h>
int main()
{
	const int n = 10;
	printf("%d\n", n);

	int* p = &n;
	*p = 20;
	printf("%d\n", n);
	return 0;
}

       可以看到变量n确实被修改了。那问题来了，n为什么要被const修饰呢？不就是为了不被修改吗。如果拿到p拿到n的地址就可修改n，那不就打破了变量被const修饰就不能被修改的语法规则吗？ 这显然是不合理的，所以应该让p即使拿到n的地址也不能修改n。那应该怎么做呢？

     7.2、const修饰指针变量

       分析下面的代码：

#include <stdio.h>
//代码1
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;//ok?->yes
	p = &m; //ok?->yes
}
void test2()
{
	//代码2
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;//ok?->no
	p = &m; //ok?->yes
}
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20; //ok?->yes
	p = &m; //ok?->no
}
void test4()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20; //ok?->no
	p = &m; //ok?->no
}
int main()
{
	//测试⽆const修饰的情况
	test1();
	//测试const放在*的左边情况
	test2();
	//测试const放在*的右边情况
	test3();
	//测试*的左右两边都有const
	test4();
	return 0;
}

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

             （1）const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过 

                 指针来改变，但是指针变量本身的内容可变。

             （2）const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能改，

                 但是指针指向的内容，可以通过指针改变。

8、指针运算

     8.1、指针的三种基本运算：

     （1）指针+-整数

     （2）指针-指针

     （3）指针的关系运算

     8.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跳过一个字节，int*类型的指针变量+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++)
 {
 printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
 }
 return 0;
}

     8.3、指针-指针 

       

       从上面代码及运行结果可以看出，指针-指针的结果可以为正为负但所得结果的绝对值都是一样的。结合&arr[7]-&arr[0]的距离可以知道，指针与指针相减，得出的结果为两者之间的距离。但是两个指针相减需要一个前提：两个指针指向同一块内存空间（同一个数组）。

       观察下面代码，体会指针-指针的运用：

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

     8.4、指针的关系运算 

       两指针之间的关系运算表示它们指向的位置关系。指向地址大的指针大于指向地址小的指针。观察下面代码，体会指针的关系运算的运用：

#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]);
	while (p < arr + sz) //指针的⼤⼩⽐较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

 9、了解野指针

     9.1、野指针的概念

       指向非法的内存内存地址的指针叫作野指针（Wild Pointer），也叫悬挂指针（Danger Pointer），意为无法正常使用的指针。野指针指向的位置是不可知的（随机的，不正确的，没有明确限制的）。

     9.2、野指针的三种成因

       9.2.1指针未初始化       

       9.2.2、指针越界访问 

        9.2.3、指针指向的空间释放

        指针指向一个对象之后，当这个对象的生命周期已经结束，对象已经消亡后，仍使用指针访问该对象，这时会出现运行时错误，请看：

       可以看到，VS编译器给出了警告：返回局部变量或临时变量。这是因为代码自上而下进行，进入test()函数，为变量n开辟空间，出test()函数，该空间释放，并不会将该空间代入main()函数。 

     9.3学会规避野指针

       9.3.1、指针初始化

       如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NIULL。NULL是c语言中定义的一个常量标识符，它的值为0，0也是地址。这个地址是无法使用的，读写该地址时编译器会报错。体会下面的代码中对指针的初始化

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

       9.3.2、小心指针越界

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

       9.3.3、及时置NULL，指针使用前检查有效性

       当指针变量指向一块空间的时候，我们可以通过指针访问该空间；后期不再使用这个指针访问空间的时候，我们应该把该指针置为NULL。因为规则就是：只要是NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。体会下面的代码：

#include<stdio.h>
#include<stddef.h>//使用NULL要包含的头文件
int main()
{
	int arr[10] = { 1,2,3,4,5,67,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;
}

       以上就是深入学习指针（一）的内容了，后续还会有更多指针相关知识。。。