一 指针变量
1.1 指针的概念
本质上指针就是地址，我们所说的指针就是指针变量，指针变量是一个用来存放地址的指针。
我们知道计算机上CPU(中央处理器)在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们电脑上内存是8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？
其实是我们把内存划分为一个个内存单元，每个内存单元也都有一个编号，有了这个内存单元的编号，cpu就可以快速找到一个内存空间。c语言中给地址起的名字叫指针。所以我们可以理解为：
内存单元的编号==地址==指针
二 指针变量与地址
2.1 取地址操作符（&）
在c语言中创建变量其实就是向内存申请空间，比如：
上述代码中，创建了整型变量a，内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：
0x0033171B
0x0033171C
0x0033171D
0x0033171E
#include <stdio.h>
int main()
{
int a = 10;
&a;//取出a的地址
printf("%p\n", &a);
return 0;
}上述代码，运行之后，打印：00AFFB48
&a取出来的是a所占4个字节中地址最小的字节的地址。
虽然整型变量占用四个字节，但只要知道第一个字节地址，就可以顺藤摸瓜访问到4个字节的数据。
2.2 指针变量和解引用操作符
2.2.1 指针变量
那我们通过取地址操作符(&)拿到的地址是⼀个数值，⽐如：0x006FFD70，这个数值有时候也是需要存储起来，⽅便后期再使⽤的，那我们把这样的地址值存放在指针变量中。比如：
PS：变量a和指针变量pa都有各自的地址，只是把变量a的地址存放在指针变量pa中。
指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址。
其中，pa左边写的是 int* , * 是在说明pa是指针变量，而 int 是在说明pa指向的是整型类型的对象。
2.2.2 解引用操作符
C语⾔中，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
*pa = 0;//解引用
printf("%d", *pa);
return 0;
}*pa 的意思就是通过pa中存放的地址,找到指向的空间，*pa其实就是a变量了；所以*pa = 0，这个操作符是把a改成了0。这⾥是把a的修改交给了pa来操作，这样对a的修改，就多了⼀种的途径，写代码就会更加灵活。
解引用的概念：* 的作用是引用指针指向的变量值，引用就是引用该变量的地址，解 就是把该地址对应的东西解开，像打开一个包裹一样，那就是该变量的值了。也就是说，解引用是返回内存地址中对应的对象。
PS：在变量声明时，*不能当作解引用来使用，只表示你声明的变量是一个指针类型。
2.3 指针变量的大小
注意：
32位平台下地址是32个bit位，指针变量⼤⼩是4个字节
64位平台下地址是64个bit位，指针变量⼤⼩是8个字节
注意指针变量的⼤⼩和类型⽆关，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。
三 指针类型的意义
3.1 指针解引用
#include <stdio.h>
int main()
{
int n = 0x11223344;
int* p1 = &n;
*p1 = 0;
return 0;
}结果：将n的4个字节全部改为0.
#include <stdio.h>
int main()
{
int n = 0x11223344;
char* p2 = (char *) & n;
*p2 = 0;
return 0;
}结果：只将n的第一个字节改为0.
结论：指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。
3.2 void* 指针
在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进⾏指针的+-整数和解引⽤的运算。
⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。
四 const修饰指针
4.1 int const *p 和 int *const p 的区别
⼀般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，意义是不⼀样的。
#include <stdio.h>
// 测试const放在*左边的情况
void test1(){
int n = 10;
int m = 20;
/* const放在*左边，修饰的是*p，表示的是指针指向的内容，
不能通过指针来改变，但是指针变量本身是可以被修改的 */
const int* p = &n;//const放在*的左边 等价于 int const* p
*p = 20;//err *p不可改变(指针指向的内容不能被修改)
p = &m; //ok 指针变量p可以修改
}
// 测试const放在*右边的情况
void test2(){
int n = 10;
int m = 20;
/* const放在*右边，修饰的是指针变量p本身，表示的是指针变量不可以被修改，
但是指针指向的内容是可以被修改的 */
int* const p = &n;//const放在*的右边
*p = 20;//ok //指针指向的内容可以被修改
p = &m; //err p不可改变（指针变量p不能被修改）
}
// 测试两边都有const
void test3() {
int n = 10;
int m = 20;
//*的左右两边都有const，修饰的是*p和p，所以*p和p都不能被修改
int const * const p = &n;
*p = 20;//err *p不可改变(指针指向的内容不能被修改)
p = &m;//err p不可改变（指针变量p不能被修改）
}
int main(){
test1();//const放在*的左边
test2();//const放在*的右边
tset3();// 测试两边都有const
return 0;
}总结：
const int* p (int const *p)：const放在*的左边。修饰的是*p，*p（指针指向的内容）不能修改；p(指针变量本身)可以修改。
int * const p :const放在*的右边。修饰的是p，p(指针变量本身)不可以修改；*p（指针指向的内容）可以修改。
int const * const p (const int * const p)：*的左右两边都有const，修饰的是*p和p，所以*p和p都不能被修改。
五 指针运算
5.1 指针+-整数
结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。
因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。
数组元素和下标
#include <stdio.h>
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int* p = arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
//p+i 这就是指针的+-整数 *(p+i)相当于arr[i]
//指针p+i表示指针向后移动i个单位。
}
return 0;
}5.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;
}在my_strlen函数中运行指针-指针，即p-s(结束指针地址-开始指针地址)，得到二者的差值就是指针之间元素的个数 。
5.3 指针的关系运算
#include <stdio.h>
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int* p = &arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz) //指针的大小比较
{
printf("%d ", *p);
p++;
}
return 0;
}六 野指针
6.1 野指针的概念
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。
6.2 野指针的成因
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];
for (int i = 0; i <= 11; i++) {
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}3. 指针指向的空间释放
#include <stdio.h>
int* test() {
int n = 100;
return &n;
}
int main(){
int* p = test();
printf("%d\n", *p);
return 0;
}6.3 如何规避野指针
1.如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL.NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使用的，读写该地址会报错。
2. 小心指针越界
⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。
3.指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性
4.避免返回局部变量的地址
七 assert断言
assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”。
assert (p != 0);
上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。
八 指针的使用和传址调用
8.1strlen 函数的模拟实现
库函数strlen的功能是求字符串⻓度，统计的是字符串中 \0 之前的字符的个数。 函数原型如下：
1 size_t strlen ( const char * str );
参数str接收⼀个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回⻓度。 如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停⽌。
代码如下：
#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;
}8.2 传值调用和传址调用
例如：写一个函数，交换两个变量的值
#include <stdio.h>
void Swap(int x, int y){
int tmp = x;
x = y;
y = tmp;
}
int main(){
int a = 10;
int b = 20;
printf("交换之前a = %d b = %d\n", a, b);
Swap(a, b);
printf("交换之后a = %d b = %d\n", a, b);
return 0;
}输出的结果如下：
Swap函数在使用的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫 传值调⽤。
#include <stdio.h>
void Swap(int *px, int *py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 10;
int b = 20;
printf("交换之前a = %d b = %d\n", a, b);
Swap(&a, &b);
printf("交换之后a = %d b = %d\n", a, b);
return 0;
}运行结果如下：
这⾥调⽤Swap2函数的时候是将变量的地址传递给了函数，这种函数调⽤⽅式叫：传址调⽤
传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。
7345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
