指针

指针是编程语言中的一个对象，利用地址，它的值直接指向电脑存储器中另一个地方的值，
由于通过地址能找到所需变量单元。说明，地址指向该变量单元，因此，将地址形象化的称为“指针”
意思是通过它。能找到以它为地址的内存单元

---

 

指针大小

指针大小 是根据 多少位 操作系统 决定的，32位【4 byte】（因为存放一个32位二进制序列【地址】，需要32bit，也就是4字节）；64位【8 byte】（因为存放一个64位二进制序列【地址】，需要64bit，也就是8字节）

实例

#include<stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;
    printf("%d",sizeof(pa));// pa是一个指针变量，存储的是 整形变量 a 的地址，又因为是32位操作系统，指针大小为 4 byte
    return 0;
}         

---

 

指针类型

指针类型的意义1

决定 （类型* 指针变量【int* a】）  的解引用（*指针变量）操作的操作时，一次可以访问几个字节

实例1

#include<stdio.h>
int main()
{
    int a = 0x11223344;//一个十六进制数就能换算4个二进制位（4 bit），也就是说2个十六进制就是1字节，8个就是4字节
    // 上表达式在内存中的形式为（地址 左低右高）  44 33 22 11 （2个十六进制就是1字节，8个就是4字节，且存储模式为 小端模式【高位字节内容存于高位地址，低位字节内容存于低地址】 ）
    int* pa = &a;
    *pa = 0;// 把 a 内的 4 个字节的内容改成0
    printf("%p\n",a);//0000 0000
    return 0;
}

---

 

实例2

#include<stdio.h>
int main()
{
    int a = 0x11223344;//内存形式为 44 33 22 11 
    char* pa = &a; //char* 字符指针类型，对其 指针变量（*pa）解引用可以访问 1字节
    指针类型决定了指针解引用操作的时候，一次访问几个字节（访问内存的大小）
    
    *pa = 0;
    内存 存储形式为 小端 ： 44 33 22 11
    由于 指针变量 pa 为 字符指针类型，对其 解引用 访问了 a 在内存中 低地址处 中 第 1 个字节的内容并改成0 
    即 00 33 22 11（低 ~ 高）
    
    printf("%p\n", a);
    打印是从高位开始打印
    //11 22 33 00 
    return 0;
}

---

 

指针类型的意义2

指针类型决定了，指针在加减整数的时候，跳过几个字节

实例1

#include<stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;
    char* pb = &a;
    printf("%p\n", pa);//008FF730
    printf("%p\n", pb);//008FF730
    printf("%p\n", pa+1);//008FF734  int 类型加1，跳过4字节
    printf("%p\n", pb+1);//008FF731  char 类型加1，跳过1个字节
                                        //减法与之同理
    return 0;
}

---

 

实例 2

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };// 40 byte
    int* p = arr;//数组名是首元素地址 等价于 &arr[0] 首元素的地址为 int 类型，所以 需要 一个 整形指针变量（int* p） 来接收 数组首元素的地址
    int i = 0;
    for (i = 0; i < 10; i++)
    {
       *(p+i) = 1; 
       因为 对其 整形指针变量p 解引用，一次访问四个字节的内容，相当于 访问 整形数组 的 一个元素
       而 i 是 一个整形，根据指针类型（指针类型 为 int ） + i 等价于 跳过 i 个 int 类型的数据
       那么 该语句的作用： 是 把 整数数组的每个元素都初始化 为 1

       printf("%d ",*(p+i));// 1 1 1 1 1  1 1 1 1
    }
    return 0;
}

---

 

指针类型的意义3

内存使用更加灵活

实例 1

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };// 40 byte
    char* p = arr;// 注意这里的 指针变量 p 为 字符指针类型，如果 对其 解引用 一次只能访问一个字节的内容
    int i = 0;
    for (i = 0; i < 40; i++)
    {
        *(p + i) = 1;
        我们 以 16 进制来表示 数组 在内存中的存储情况
        01 00 00 00   01 00 00 00   01 00 00 00    01 00 00 00 。。。。。。
        因为 *p 一次只能访问一个字节的内容，又因为 i 是 一个整形，根据指针类型（指针类型 为 char ） + i 等价于 跳过 i 个 char 类型的数据
        通过观察，发现 这是一种 变相 修改 数组元素的值
        printf("%d ",arr[i]);
        01 01 01 01   01 01 01 01  01 01 01 01   01 01 01 01  01 01 01 01   01 01 01 01  01 01 01 01   01 01 01 01  
         16843009      16843009     16843009      16843009      16843009     16843009     16843009     16843009 
01 01 01 01   01 01 01 01  
 16843009      16843009
    }
    return 0;
}

---

 

野指针

指针 指向 的 位置，是不可预知的（随机的，不正确的，没有明确限制的）

形成野指针的原因

1.指针未初始化

#include<stdio.h>
int main()
{
    int* p;//没有初始化，不知道里面内容，里面放的是随机值
    *p = 20;//通过p里面存的随机值作为地址，找到一块空间，这块空间，不属于当前程序
    //造成了非法访问，程序崩溃，那么 p 就是野指针
    return 0;
}

---

 

2.指针越界访问

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };//10个元素，下标是从0~9
    int i = 0;
    int* p = arr;// arr 这里 代表是 数组首元素地址，被 相对应类型指针变量 p 接收
    for (i = 0; i <= 10; i++)//循环11次（i == 0 也是会进入循环体的），，访问第11个元素，而它只有10个元素，越界访问。造成程序崩溃
    {
        *p = i;
        p++;
    }
    return 0;
}

---

 

3.当一个指针 指向的空间 被释放了,或者 指针 指向的空间 被释放了，还有人在使用它。

#include<stdio.h>

int* test()   
{    
    int a = 10;
    return &a;
    局部变量的生命周期 ，进入这个范围（a 的范围 是 int* test（）这个函数范围）到出这个范围。
它的地址用完就要返还电脑（栈空间，而且栈空间的使用是先使用高地址，再使用低地址），此时此地址已不属于我们，但是 它把这个地址当做返回值，返回给int* p。
}
注意！
虽然这个地址还给电脑，但是里面的内容很可能没改。也就意味着 内容可能还在，但不属于不属于我们，
    //举个例子：宾馆开房，你住的期间，是你的，房屋里面摆放是按照你的要求布置的，
    //等你退房之后，房间使用权你就没有了，你再使用就是违法的。
    //另外等你退房之后，房间并没有改变摆设，等下一个人来住的时候，就按别人的要求摆放，

int main()
{
    int* p = test();// test返回的地址，被 *p记住了（此地址不属于当前程序）
    
    printf("hehe\n");// 打印 hehe 需要向内存申请空间，也就是说 test 函数 还给xt的内存，被占用了，
    // 根据例子 hehe 就是 该房间现在的使用者
    
    printf("%d\n", *p);//所以这时候 *p 就属于非法访问
    //本来上表达式按逻辑来说是随机值，但上表达式a的值还是10；
    //是因为这个地址还给电脑，但没改。所以内容还在，所以访问还是10，但不属于不属于我们，
    //如果在输出前面加一个函数或者其他的，向栈里面申请内存，把test还给电脑的内存，给占用了。
    //那么*p的输出是无法确定的
    return 0;
}

---

 

栈空间，且使用是先使用高地址，再低地址

#include<stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    printf("%p\n",&a);//0113F8 D8
    printf("%p\n", &b); //0113F8 CC
    在十六进制中 D 比 C要大，也就意味着 a 地址 比 b 的地址要大
    //由此可见:栈空间，是先使用高地址，再低地址
    return 0;
}

避免造成野指针

1.指针初始化
2.指针指向空间释放级设置NULL
3.使用地址之前检查有效性
4.避免返回局部变量的地址
5.小心指针越界

---

 

实例1

#include<stdio.h>
int main()
{
    int a = 10;//明确地初始化
    int* p = &a;//确定指向

    int* p2 = NULL;//不知道一个指针当前应该指向哪里时，初始化 NULL （空指针； 0的另一种写法）
                   // 初始化 NULL，相当于标记状态，这个指针还没有指向任何对象 ，要注意了
                   //如果不初始化，就不知道它指向那块空间。
                   
    举个例子：指针不初始化相当于 街上有一只没有主人的野狗，可能会伤人。
    指针初始化 NULL，就相当于把它拴在一颗树底下（这棵树，就相当于一个危险标记），防止伤害到人，
    当然前提是你不去接近，所以我们只需绕着走，就可以避免危险，
       int* p2 = NULL; 该语句 相当于 指针初始化 NULL，标记它是野指针，不要去调用它
       
    if (p2 != NULL)// 意思就是 如果 我们 没有将 P2 置为空指针，就执行 下面的 if 语句
       *p2 = 100;
 这就相当于你非要去那棵树底下方便，它肯定就会伤害你（这么挑衅的行为，它不咬你才怪）； 
 所以我们去尿尿时，需要提前看一下树底下有没有狗，
 即 该树下没有狗，意味着我们可以去方便 （该指针初始化了，且是一个有效地址，我们再去使用它）
    // p2是一个空指针，空指针是0，0也是地址，0指向的地址是不可使用的
    // *p2 = 100; 该表达式是错误的，属于非法操作
    return 0;
}

---

指针运算

指针加减整数
/指针 -（减） 指针
指针的关系运算

---

 

指针加减整数

例子

#include<stdio.h>
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]);
    int* p = arr;
    for (i = 0; i < sz; i++)
    {
        printf("%d ",*(p+i));// 1 2 3 4 5 6 7 8 9 10
    }
    printf("\n");
    for (i = sz-1; i >= 0; i--)
    {
        printf("%d ", *(p + i));//10 9 8 7 6 5 4 3 2 1
    }
    return 0;
}
由 该程序我们发现， 数组名（其实就一个指针【地址】），当我们加上一个 整数时，它根据 它 自身的数据类型来判断
就拿上面的程序来说， 数组的类型为int 类型，当我们 用 arr（首元素地址）+ i（i是一个整数） 时， 
整数 i 会 根据 数组 的类型，来进行判断  一次 跳过 i 个 为 int 类型的数据

附图

---

 

指针 -（减） 指针

实例1

#include<stdio.h>
int main()
{
    char ch[5] = { 0 };
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf("%d\n",&arr[9] - &arr[0]);//指针 - 指针  得到是指针和指针之间（ &arr[0]~&arr[9] //左开右闭区间）的元素的个数
    //  输出为 9

    printf("%d\n", &arr[9] - &ch[0]);//这种写法error，因为指针减指针，两者必须是同一块空间里的。
    return 0;
}

附图

---

 

实例 2

#include<stdio.h>
int my_strlen(char* arr)
{
    char* start = arr;
    char* end = arr;
    while (*end !=  '\0')//循环结束后 end == '\0' == arr[3]
    {
        end++;
    }
    return end - start;//arr[3] - arr[0]  左开右闭
    // 第四个元素减去 第一个元素 == 3
}

int main()
{
    char arr[] = "bit";
    int len = my_strlen(arr);
    printf("%d\n",len);
    return 0;
}

---

 

指针的关系运算

#define N_VALLUES 5 // 在程序中 遇见  N_VALLUES 在预编译期间 会被替换成 5
#include<stdio.h>

int main()
{
    float values[N_VALLUES];
    float *vp;
    
    // 1.correct（正确写法）
                 
    for (vp = &values[ N_VALLUES ]  vp > &values[0]/*指针是可以比较大小的*/ ;  /*省略了*/ )
    // 等价于 for (vp = &values[5]  vp > &values[0] ;  )
    在 C语言标准中 允许指向 数组元素 的 指针 与 指向数组 最后一个元素 后面的那个内存位置 的 指针比较;
    而且只是比较地址，并没有对其解引用，所以构不成越界访问
    有人可能会说 &values[ N_VALLUES ] 不是有 [] 操作符吗？不是应该对其解引用，既然解引用，就会造成越界访问
    但是其实 & 把 [] 给抵消了。
    例如： &arr[3] == & *(arr+3) == arr + 3 等价于 首元素地址加上 3，还会一个地址 
    {           
        *--vp = 0;// for 循环条件 的 省略部分在这里
    }





    // 2. error（错误写法）
    for (vp = &values[N_VALLUES-1]; vp >= &values[0];vp--)//C语言的标准，并不保证它能运行
         //不允许与指向第一个元素之前的那个内存位置进行比较 

    C语言标准规定：
    允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较;
    但不允许与指向第一个元素之前的那个内存位置进行比较 

    {
        *vp = 0;
    }
    return 0;
}

附图

---

 

指针和数组

数组

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("%p\n",arr);//打印首元素地址
    printf("%p\n", &arr);//打印数组的起始地址【数组的地址】
    printf("%p\n", &arr[0]);//打印首元素地址
    //在绝大部分情况，数组名表示是首元素地址
    //但有两种情况例外
    // &数组名，arr代表的是整个数组的起始地址。
    //sizeof(数组名)，arr代表的是整个数组，sizeof计算的是整个数组的大小，单位byte


    printf("------------------------\n");


    printf("%p\n", &arr[0]); // 00F3F8E8 首地址
    printf("%p\n", &arr[0] + 1);//00F3F8EC加了4字节，因为数组元素类型 int

    printf("%p\n", &arr);// 00F3F8E8 数组的起始地址【数组的地址】
    printf("%p\n", &arr + 1);// 00F3F910 加了40字节（2 * pow（16，1） + 8 * pow（16,0） == 8 + 32 = 40），
                           //即跳过一个数组
    你会发现 数组的地址 和 数组首元素地址 是一样的 ，但是意义却不一样， 我们通过 指针加减整数 可以发现 两者的不同
    return 0;
}

---

 

指针（一级）

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };
    int* p = arr;// 指针变量p 存的是 arr首地址
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%p........%p\n",p+i,&arr[i]);// 两种写法是等价的
                p+i 是根据数组首元素地址 加减 整数 i（其实可以说是下标 i），跳过 i 个 int类型的额元素，来找到我们想要打印的元素地址

              如果输出是 %d 型，输出元素，需要解引用操作符* 
              //例： *(p+i) 或者 arr[i]
    }
    return 0;
}

---

 

二级指针、

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

    //pa 一级指针变量，变量的创建，需要在内存中开辟空间，也就意味着 pa 有着自己的地址
    int * pa = &a;//一级指针类型 ；最右边的*，告诉我们 pa 是一个指针
             // 而int，告诉我们 pa 指向的那个对象的类型为 int

    int* * ppa = &pa;// 二级指针    最右边的*，告诉我们 ppa 是一个指针
             // 而int*，告诉我们 ppa 指向的那个对象的类型为 int*

    int** * pppa = &ppa;// 三级指针 最右边的*，告诉我们 pppa 是一个指针
             // 而int**，告诉我们 pppa 指向的那个对象的类型为 int**

    // n 级指针，可按照上表达式的规律写出
、


 //二级指针使用方法
    printf("%d\n", **ppa);//*ppa == pa ； *（pa）= a ；**ppa == a
         // 上下两个表达式是等价的 输出为 10
    printf("%d\n", a);


    **ppa = 20;
    printf("%d\n", **ppa); 
    printf("%d\n", a);//两个表达式输出的结果 是 20 
    return 0;
}

---

 

指针数组

指针数组 本质上是一个数组 ： 数组就是主语（subject）， 指针是个形容词（adjective）

指针数组 是 存放 指针的数组 

举个例子：
整形数组 -> 存放整形 
字符数组 -> 存放字符

---

#include<stdio.h>
int main()
{
        int a = 10;
        int b = 20;
        int c = 30;
     // int* a = &a;
     // int* b = &b;
     // int* c = &c;

        int* arr2[3] = { &a,&b,&c };//它就是一个指针数组
        int i = 0;
        for (i = 0; i < 3; i++)
        {
            printf("%p\n", arr2[i]);
            arr2[i] 就是 a,b,c其中一个元素，而这些元素都是地址
            所以该表达式 打印的是  a,b,c 的地址

            printf("%d\n", *(arr2[i]));
            这里就是通过 指针数组 里 存储的 a，b，c的地址，找到 a，b，c，打印其值
            所以 输出的结果为 
            10
            20
            30
            
        }
        return 0;
 }

---

 

数组指针

数组指针 本质上是一个指针： 指针 是主语（subject）， 数组是个形容词（adjective）

int* p[5];
// 指针数组 
是一个大小为5（能存放 5 个元素），且每个元素 的 元素类型 是 整形指针 类型

int(*p)[5];
//数组指针 
通过括号，让 指针变量p 和 * 先结合，使其成为一个指针，该指针指向一个大小为 5（能存放 5 个元素，【且每个元素 的 元素类型 是 整形】 的 数组，所以int(*p)[5]即为一个数组指针

数组指针 与 指针数组的区别

本文结束