认识指针（1）

1.内存和地址

1.1内存

要知道计算机CPU在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，就相当于一个仓库。

可以把内存划分为一个个的内存单元，每个内存单元的大小取1个字节（1byte=8bit)。每个内存单元也都有编号（相当于门牌号），便于CPU的快速访问。

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

简易：内存单元的编号==地址==指针

1.2编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址（相当于编号）。计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

地址总线：CPU和内存之间数据交互的连线

地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2.指针变量和地址

2.1取地址操作符&

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

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

内存为a申请了四个字节的空间

如何能得到a的地址？需要使用取地址操作符&（单目操作符）

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

&a取出的是a所占4个字节中地址较小的字节的地址（指针类型不一，访问权限不一）。

虽然整型变量占4个字节，我们只要知道第一个字节地址，就可以访问到4个字节的数据。

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

2.2.1指针变量

我们通过取地址操作符（&）拿到的地址是一个数值，比如：0x006FFD70，这个数值有时候也是需要储存起来，方便后期使用，我们可以将他储存在指针变量里。

比如：

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//取出a的地址并储存到指针变量里
	return 0;
}

int：说明p指向的对象是int类型

*：指指针

p:为指针变量（存放编号的变量）

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

2.2.2如何拆解指针类型

pa左边写的是int*,*是在说明pa是指针变量，而前面的int是在说明pa指向的类型是整型类型的对象。同理：如果有一个char类型的变量ch，ch的地址，如何存放

char*pc = &ch ;

2.2.3解引用操作符

我们将地址保存起来，如果调取使用，我们只要找到地址（指针），就可以通过地址（指针）找到地址（指针）所指的对象，所以要用到解引用操作符（*）。

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//取出a的地址并储存到指针变量里
	*pa = 0;
	return 0;
}

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

*&a=0 => a=0

上面就是用了解引用操作符，*pa的意思就是通过pa中存放的地址，找到只想的空间，*pa其实就是a变量了；所以*p=0，这个操作符是把a改成了0.

2.3指针变量的大小

指针变量是用来存放地址的，那么指针变量的大小就得是4个字节的空间。

//指针变量的大小取决于地址的大小

//32位平台下地址是32个bit位（即4个字节）

//64位平台下地址是64个bit位（即8个字节）

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

3.指针类型的意义

3.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;//把n强制类型转换为char类型
	*pc = 0;
	return 0;
	
}

经调试我们可以看到，代码1会将4个字节全部改为0，而代码2只是将n的第一个字节改为0.

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

3.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个字节。

结论：指针的类型决定了指针向前或者向后移动多少距离。

3.3void*指针

void*类型的指针：指无具体类型的指针（可以接受任何类型的地址）

局限性：该类型的指针不能直接进行指针的+-整数和解引用的运算。

int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上面的代码中，将一个int类型的变量的地址赋值给一个char*类型的指针变量。编译器会给出一个警告：不兼容。

使用void*类型就不会有这样的问题。

int main()
{
	int a = 10;
	void* pa = &a;
	void* pc = &a;
	*pa = 10;
	*pc = 10;
	return 0;
}

结果：

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

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

4.const修饰指针

4.1const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。

但是如果我们希望一个变量加上一些限制，不能被改变，就可以使用const。

n被const修饰，具有了常属性，在语法上加了限制，所以不能被修改。在c++中的const修饰的变量就是常量。

但是如果我们绕过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的意义就是使n不被修改，上面的做法打破了const的限制，这是不合理的，那么怎么让p拿到n的地址也不能修改n，怎么做呢？

4.2、const修改指针变量

看代码：

void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;
	p = &m;
}
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;
	p = &m;
}
void test3()
{
	int n = 10;
	int m = 20;
	int*const p = &n;
	*p = 20;
	p = &m;
}
void test4()
{
	int n = 10;
	int m = 20;
	int const*const p = &n;
	*p = 20;
	p = &m;
}
int main()
{
	//测试无const修饰的情况
	test1();
	//测试const放在*的左边情况
	test2();
	//测试const放在*的右边情况
	test3();
	//测试*的左右两边都有const
	test4();
	return 0;
}

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

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

第二个结论的代码：

5.指针运算

指针的基本运算：三种

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

5.1指针+-整数

数组在内存中是连续存放的，只要知道第一个元素的地址，就可以找到后面的所有元素。

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

指针+-整数

p+1-->跳过4个字节（1*sizeof(int))

type*p

p+1-->跳过1*sizeof(type)

p+n-->跳过n*sizeof(type)

不用指针：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//数组元素的个数
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

5.2指针-指针

指针-指针：得到的是两个指针之间的元素个数（有正负之分，加绝对值）

指针+指针：无意义

指针-指针计算的前提条件一定是：两个指针指向同一块空间（同一类型）

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.

计算字符长度

int my_strlen(char* str)     
{                        
	int count = 0;             
	while (*str != '\0')             
	{                           
		count++;
		str++;//指针运算
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);//数组名arr是数组首元素的地址arr=&arr[0]
	printf("%d\n", len);
	return 0;
}

结果：6

6.野指针

指指针指向的位置是不可知的。

6.1野指针成因

1，指针未初始化

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

2.指针越界访问

int main()
{
	int arr[] = { 0 };
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i <= 11; i++)
	{
		*(p++) = i;//指针指向的范围超过数组arr的范围时，p就是野指针
	}
	return 0;
}

3.指针指向的空间释放

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也是地址，这个地址是无法使用的，读写该地址会报错。

int main()
{
	int num = 10;
	int* p1 = #
	int* p2 = NULL;
	return 0;
}

6.2.2小心指针的越界访问

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

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

6.2.4避免返回局部变量的指针

7.assert断言

assert.h头文件定义了宏assert（），用于在运行时确保程序符合指定条件，如果不符合，就会报错

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

8.1strlen的模拟实现

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

size_t strlen (const char*str)

参数str接收一个字符串的起始地址，然后开始统计字符串中\0之前是我字符个数，最终返回长度。

如果模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是\0，计数器就+1，直到\0停止。

int my_strlen(const char* str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcde";
	int len=my_strlen(arr);
	printf("%d", len);
	return 0;
}

8.2传值调用和传址调用

学会用指针来解决问题

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

void swap1(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("交换之前：%d%d", a, b);
	swap1(a, b);
	printf("交换之后：%d%d", a, b);
	return 0;
}

结果并非如此

原因：实参传递给实参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。

void swap1(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("交换之前：%d %d", a, b);
	swap1(&a, &b);
	printf("交换之后：%d %d", a, b);
	return 0;
}