指针初步1
⽬录：
1. 内存和地址
2. 指针变量和地址
3. 指针变量类型的意义
4. const修饰指针
5. 指针运算
6. 野指针
7. assert断⾔
8. 指针的使⽤和传址调⽤
正文开始：
1.内存和地址
我们知道计算上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？
其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。
在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。
所以我们可以理解为：
内存单元的编号 == 地址 == 指针
1.2 究竟该如何理解编址
⾸先，必须理解，计算机内是有很多的硬件单元，⽽硬件单元是要互相协同⼯作的。所谓的协同，⾄少相互之间要能够进⾏数据传递。
但是硬件与硬件之间是互相独⽴的，那么如何通信呢？答案很简单，⽤"线"连起来。
⽽CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也⽤线连起来。
我们先主要了解一下地址总线：
我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表⽰0,1【电脉冲有⽆】，那么⼀根线，就能表⽰2种含义，2根线就能表⽰4种含义，依次类推。32根地址线，就能表⽰2^32种含义，每⼀种含义都代表⼀个地址。
地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传⼊CPU内寄存器。
2. 指针变量和地址
2.1 取地址操作符（&）
我们先举一个例子：
在内存中int a = 10相当于向内存申请了4个字节的空间来存放整数10，而每个字节都有地址
这⾥就得学习⼀个操作符(&)-取地址操作符
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int a = 10;
&a;
printf("%p\n", &a);
} &a取出的是a所占4个字节中地址较⼩的字节的地址。
虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。
2.2 指针变量和解引⽤操作符（*）
2.2.1 指针变量
我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int a = 10;
int *p = &a;
printf("%p\n", p);
} 这里p是指针变量，是一块空间，指针变量是用来存放地址的，所以p中存放着a的地址
*在说明p是指针变量
int说明p指向的对象是int类型的
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
char a = 'w';
char *p = &a;
printf("%p\n", p);
}
2.2.3 解引⽤操作符
我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int a = 1;
int* p = &a;
*p = 0;
printf("%d\n",a);
}
这⾥是把a的修改交给了pa来操作，这样对a的修改，就多了⼀种的途径，写代码就会更加灵活，后期慢慢就能理解了。
2.3 指针变量的⼤⼩
32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4个字节才能存储。
如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。
同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要8个字节的空间，指针变的⼤⼩就是8个字节
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(double*));
printf("%zd\n", sizeof(float*));
printf("%zd\n", sizeof(short*));
} 
结论：
• 32位平台下地址是32个bit位，指针变量⼤⼩是4个字节
• 64位平台下地址是64个bit位，指针变量⼤⼩是8个字节
• 注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。
3. 指针变量类型的意义
3.1 指针的解引⽤
结论：
指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。
3.2 指针+-整数
我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。
3.3 void* 指针
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进⾏指针的+-整数和解引⽤的运算。
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int a = 0x11223344;
void* p = &a;
int* p1 = &a;
} 
般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。
4. const修饰指针
4.1 const修饰变量
变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作⽤。
这里面的n虽然是不可以修改的，但是本质上还是一种变量，也叫做常变量
在C++中const修饰的变量为常量
但是我们可不可以通过指针来修改const修饰的值呢?虽然打破了语法规则，但实际上是可以的
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
const int a = 10;
int* p = &a;
*p = 0;
printf("%d\n", a);
}
答案却是是0，但是这不符合const的语法规则，这是不合理的，那么为了保证a不能被修改，应该如何做呢？
4.2 const修饰指针变量
这里const放在*右边修饰的是p的本身，指针变量不能再指向其他变量，但是可以通过指针变量修改指针变量指向的内容
这里const放在*左边限制的是指针指向的内容，不能通过指针来修改指向的内容，但是可以修改指针变量本身的内容
当const放在*的两边时，既限制了指针变量本身也限制了指向，都不能修改
结论：
const修饰指针变量的时候• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。
• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
5. 指针运算
指针的基本运算有三种，分别是：
• 指针+- 整数
• 指针-指针
• 指针的关系运算
5.1 指针+- 整数
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int a = 10;
int* p = &a;
p + 1;//跳过4个字节
//1*sizeof(int)
p + n;
//n*sizeof(int)
}
因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，就可以知道后面的元素
这是通过下标的方式来访问：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//打印数组的内容
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0;i < 10;i++)
{
printf("%d ", arr[i]);
}
} 下面来用指针的方式来访问：
#define _CRT_SECURE_NO_WARNINGS
#include
#include
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);
p++;
}
} #define _CRT_SECURE_NO_WARNINGS
#include
#include
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));
}
}
5.2 指针-指针
首先声明一下不存在指针加指针
指针减指针的前提是两个指针指向同一块空间
#define _CRT_SECURE_NO_WARNINGS
#include
#include
//int my_strelen(char* str)
//{
// int count = 0;
// while (*str != '\0')
// {
// count++;
// str++;
// }
// return count;
//}
int my_strelen(char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return str - start;
}
int main()
{
//strelen求字符串长度,strlen统计的是\0之前的字符个数
char arr[] = "abcdef";
int len = my_strelen(arr);//arr = &arr[0]
//a,b,c,d,e,f,\0
printf("%d\n", len);
}
5.3 指针的关系运算
指针和指针比较大小，地址和地址比较大小
#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;
while (p < sz + arr)
{
printf("%d ", *p);
p++;
}
return 0;
} 6. 野指针
概念： 野指针就是指针指向的位置是不可知的
2. 指针越界访问
#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for(i = 0;i <= 10;i++)
{
printf("%d ", *p);
}
return 0;
} 3. 指针指向的空间释放
这里是因为a位于栈区当调用完之后会释放这份空间，这里p就是一个野指针，非法访问。
6.2 如何规避野指针
6.2.1 指针初始化
1.如果知道指针应该指向哪里，就初始化一个明确的地址
2.如果不知道指向哪里，就初始化NULL
6.2.2 ⼩⼼指针越界
6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性
6.2.4 避免返回局部变量的地址
7. assert断⾔
assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”。
assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零）， assert() 就会报错
assert() 的使⽤对程序员是⾮常友好的，使⽤ assert() 有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断⾔，就在 #include
8. 指针的使⽤和传址调⽤
8.1 strlen的模拟实现
#define _CRT_SECURE_NO_WARNINGS
#include
int my_strelen(const char *str)
{
int count = 0;
assert(str != NULL);
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
} 8.2 传值调⽤和传址调⽤
例如：写⼀个函数，交换两个整型变量的值
这里实际上没有交换成功的是x和y确实接收到了a和b的值，但是x，y和a，b的地址不一样相当于x和y是独⽴的空间 ，自然无法实现交换，但是我们如果把地址传过去呢？
#define _CRT_SECURE_NO_WARNINGS
#include
int swap(int *pa,int*pb)
{
int temp = 0;
temp = *pa;
*pa = *pb;
*pb = temp;
}
int main()
{
int a = 10;
int b = 20;
swap(&a, &b);
printf("a = %d\n", a);
printf("b = %d\n", b);
return 0;
} 
传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；
完！！！