1.内存和地址
1.1 内存
生活中我们有了房间号才能够快速找到房间，同样，在计算机中CPU（中央处理器）在处理数据时，需要的数据是在内存中进行读取的，处理完之后又会放回内存中。
在内存空间中，也是将内存划分为一个个的内存单元，每个内存单元的大小为1个字节，1个字节相当于8个比特位，一个比特位可以存储一个二进制的0或1
补充
1byte=8bit
1KB=1024byte
1MB=1024KB
1GB=1024MB
1TB=1024GB
1PB=1024TB
生活中我们将门牌号叫做地址，在计算机中，我们把内存单元的编号叫做地址，c语言中我们把它叫作指针
2.指针变量和地址
2.1
c语言中创建变量其实就是向内存中申请空间
我们使用一个获取地址的操作符（&）得到一个变量的地址
通过观察内存，&a取出的是a所占4个字节中较小的地址
2.2
2.2.1 指针变量
我们将取到的地址存放在指针变量中
int main()
{
int a=10;
int*p=&a;//取出a的地址存放在指针变量p中
return 0;
}指针变量也是一种变量，这个变量就是用来存放地址的，存放在其中的值都可以理解为地址
2.2.2 拆解指针类型
pa左面写的是int*，*说明pa是指针变量，int说明pa指向的是整型类型的对象
2.2.3 解引用操作符（*）
int main()
{
int a=10;
int*pa=&a;//取出a的地址存放在指针变量p中
*pa= 0;
return 0;
}通过解引用，*pa就把a由10 改为0
2.4 指针变量的大小
32位机器就有32根地址总线，把这32根地址总线产生的二进制序列当作一个地址，一个地址就是32byte，就是4个字节
在64位的机器中，就变成了8个字节
所以以后一提到地址的大小就是4个字节（32位）或者8个字节（64位）
x86环境就是32位环境，根据运行结果来看，指针变量的大小是与类型无关的，只要指针类型的变量在相同的平台下，大小就都是相同的
3.指针变量类型的意义
3.1 指针的解引用
指针类型决定了对指针解引用的时候有多大的权限（一次可以操作几个字节）
例如：char*的指针解引用只能访问一个字节，而int*的指针解引用就可以访问4个字节
3.2 指针+-整数
可以看出，char*类型的指针变量+1跳过一个字节，int*类型的指针跳过4个字节
指针的类型决定了指针向前走或向后走一步有多大
3.3 void*指针
void*是一种无类型的指针，可以用来接受任意类型的指针。局限性是，不能进行+-和解引用的运算
int main()
{
int a = 10;
int* p = &a;
char* pa = &a;
return 0;
}运行后编译器给出警告
但是当我们用void*类型就不会出现这种问题
从这里看出，void*可以接收不同类型的指针，但是无法直接进行指针的运算
4.const修饰指针
4.1 const修饰变量
变量是可以被修改的，把变量的地址交给一个指针变量，通过这个指针变量也是可以修改变量的
我们希望加上一些限制，使其不能被修改，这就是const的作用
int main()
{
int m = 0;
m = 20;//m可以被修改
const int n = 0;
n = 20;
return 0;//n不能被修改
}但是如果我们绕过你n，使用n的地址去修改n，就可以了，这样就是在打破语法规则
4.2 const修饰指针变量
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;//Ok n=20，m=20
p = &m;//N0,n=10,m=20
}
void test2()
{
int n = 10;
int m = 20;
int*const p = &n;//const修饰的是指针变量本身，指针变量本身不可以修改，但是指针变量所指向的内容可以改变
*p = 20;//OK
//p = &m;//这里编译器会报错
}
void test3()
{
int n = 10;
int m = 20;
int const* p = &n;//const修饰的是指针指向的内容，保证指针指向的内容不被改变，但是指针本身可以被改变
//*p = 20;//报错
p = &m;//OK
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;//const既修饰了指针变量本身，又修饰了指针所指向的内容，二者都不可以被改变
//*p = 20;//报错
//p=&m;//报错
}
int main()
{
test1();
test2();
test3();
test4();
return 0;
}得出结论
1.const放在*的左边（int const *p）：修饰的是指针所指向的内容，保证指针指向的内容不能通过指针来改变，但是指针变量本身可以改变
2.const放在*的右边（int *const p）：修饰的是指针变量本身，保证了指针变量的内容不能改变，但是指针所指向的内容，可以通过指针改变
5.指针运算
指针的运算一般有三种..
1.指针+-整数
2.指针-指针
3.指针的关系运算
5.1指针+-整数=指针
数组在内存中是连续存放的，只要知道了第一个元素的地址，就可以找到后面所以的元素
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", *(p+i));
}
return 0;
}这里的p+i就是指针+-整数
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指针-指针的运算的前提条件是：两个指针必须指向同一块空间
注意！！！指针+指针是无意义的
5.3 指针的关系运算
指针的大小比较
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz)
{
printf("%d ", *p);
p++;
}
return 0;
}6.野指针
6.1 野指针的成因
1，指针未初始化
int main()
{
int* p;//局部变量未初始化，默认为随机值
*p = 20;
return 0;
}2，指针越界访问
int main()
{
int arr[10] = { 0 };
int* p = arr;
for (int 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;
}在test（）中，我们想让它返回一个指向局部变量n的指针。但是，存在一个问题，当test函数执行完毕是，n这个局部变量所占用的空间就会被释放，指向它的指针就会变为悬空指针。
在main（）函数中，当我们想要打印*p是，实际上访问的是一个已经被释放的内存地址
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，使用之前检查有效性
当指针变量指向一块区域时，我们可以通过指针访问该区域，后期不使用就即使设置为NULL，，只要是NULL指针就不去访问，在使用之前我们就要判断是不是NULL，如果是就不去访问
6.2.4 避免返回局部变量的地址
7.assert断言
assert.h头文件定义了assert（），用于在运行时确保程序符合指定的条件，如果不符合，就报错终止运行
assert(p!=NULL);assert()接受一个表达式作为参数，如果表达式为真，程序继续运行，否则就会报错，并会在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及这个表达式的文件名和行号
如果确认程序没有任何问题的话，无需更改代码，在头文件前定义一个宏NDEBUG，编译器就会禁用所以assert（）
它的缺点就是引入额外的检查，增加了程序的运行时间
我们可以在debug中使用，在release直接禁用就可
8.指针的使用和传址调用
8.1 strlen的模拟实现
strlen（）的功能时求字符串的长度，统计“\0”之前的字符个数
函数原型为
size_t strlen(const char *P);参考代码
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", len);
return 0;
}8.2 传值调用和传址调用
写一个函数，交换两个整型变量的值，我们可能会写出以下代码
运行结果为
void Swap(int x, int y)
{
int temp = x;
x= y;
y= temp;
}
int main()
{
int a = 10, b = 20;
Swap(a, b);
printf("%d %d", a, b);
return 0;
}
我们发现a和b并没有交换
我们在main函数内部，创建了a和b，在调用Swap函数时，将a和b传给了Swap函数，x和y接受了a和b的值，但是x和a的地址不同，是两块独立的空间，只在Swap函数内部交换x和y的值，自然不会影响a和b的值，所以a和b没有交换，这就是传值调用
结论：实参传递给形参时，形参会单独开辟一块空间接收，对形参的修改不会影响实参
我们要达到的目的时在Swap函数中操作的就是main函数中的a和b，所以我们把a和b的地址传给Swap函数就好了
void Swap(int *px, int*py)
{
int temp = *px;
*px= *py;
*py= temp;
}
int main()
{
int a = 10, b = 20;
Swap(&a, &b);
printf("%d %d", a, b);
return 0;
} 
这种方式叫做传址调用
