【C/C++】一文带你彻底玩转C/C++中的指针！(万字解读，非常详细！适合初学者或老手回顾)

目录

• 一、指针简介
• 二、指针入门
• • 1.初见指针
  • 2.指针的解引用
  • 3.指针的类型
  • 4.野指针和空指针
  • • （1）野指针
    • （2）空指针
    • 5.指针的简单应用
    • 6.结构体与指针
    • 三、指针进阶
    • • 1.指针与数组
      • 2.指针的运算
      • 3.常量指针与指针常量
      • • （1）常量指针
        • （2）指针常量
        • （3）总结
        • 3.字符指针与字符串、字符数组
        • 4.指针数组与数组指针
        • • （1）指针数组
          • （2）数组指针
          • （3）总结
          • 5.函数指针和指针函数
          • • （1）函数指针
            • （2）指针函数
            • 6.多级指针
            • 四、指针高级
            • • 1.复杂指针类型的辨认
              • 2.数组名隐式转换
              • 3.void型指针
              • 4.回调函数
              • 5.零长数组（柔性数组）
              • 6.数组与指针的补充
              • 五、总结

                一、指针简介

                在C/C++编程中，**指针是一种极为特殊且关键的变量类型，它存储的是数据的内存地址而非数据值本身。**尽管指针的概念相对抽象，用法也颇为复杂，使得不少初学者感到晕头转向，但一旦能灵活运用指针，你便能实现对程序内存的精准把控，甚至细化到字节级别的控制。因此，学会并熟练使用指针，无疑是掌握C/C++编程的必经之路。

                二、指针入门

                1.初见指针

                在正式介绍指针之前，需要先简单介绍一下计算机内存。首先需要明确的一点是，程序是运行在计算机内存里的，你可以将内存看成一个个可以存储数据的小盒子（内存单元），而且这些小盒子有自己在内存中唯一的编号（地址），而指针实际上存储的就是这些编号的值。

                

                接下来介绍一下指针的基础语法。

                声明一个指针的语法很简单：类型* 变量名，然后因为指针存放的是变量的内存地址，所以C/C++中可以通过 “&” 这个关键字来获取一个变量的地址，具体用法为：&变量 。具体使用如下代码所示：

                #include 
                using namespace std;
                int main() {
                    int a = 10; //声明一个变量
                    int* p = &a; //通过&对变量a取地址，并将地址赋值给指针p
                    cout 
                    int a = 10; //声明一个变量
                    int* p = &a; //通过&对变量a取地址，并将地址赋值给指针p
                    cout 
                    int a = 10;
                    int *p = &a;
                    cout 
                    int a = 10; 
                    char c = 'a';
                    float f = 1.0f;
                    int* p_a = &a;
                    char* p_c = &c;
                    float* p_f = &f;
                    return 0;
                }
                
                    int a = 10;
                    char c = 'a';
                    int* p_a = &a;
                    char* p_c = &c;
                    cout 
                    int id;
                    char ch;
                };
                int main() {
                    A a;
                    A* p = &a; // 对结构体取地址，赋值给指针p
                    return 0;
                }
                
                    int* p = (int*) malloc(4); // 开辟4字节大小的内存，并将内存地址赋值给指针p
                    *p = 10; // 将p指向的内存中的值设置为10
                    cout 
                    int *p = NULL;
                    return 0;
                }
                
                    // int* p = NULL;
                    int *p = nullptr;
                    return 0;
                }
                
                    a = 99; //给a赋值99
                }
                int main() {
                    int a = 10;
                    change(a); // 调用函数
                    cout 
                    *p = 99; //把指针解引用，直接改变内存中的值
                }
                int main() {
                    int a = 10;
                    int* p = &a;
                    change(p); // 调用函数，传入a的指针p
                    cout 
                    int id;
                    char name[100];
                    double score;
                };
                int main() {
                    Student stu = {19, "test", 89.4};
                    Student* p = &stu;
                    return 0;
                }
                
                    int id;
                    char name[100];
                    double score;
                };
                int main() {
                    Student stu = {19, "test", 89.4};
                    Student* p = &stu;
                    (*p).id = 129;
                    cout 
                    int id;
                    char name[100];
                    double score;
                };
                int main() {
                    Student stu = {19, "test", 89.4};
                    Student* p = &stu;
                    // (*p).id = 129;
                    p-id = 129;
                    cout 
                    int a[5] = {1, 2, 3, 4, 5};
                    int* p = a; //将数组名赋值给一个指针
                    cout 
                    int* p_int = NULL;
                    double* p_double = NULL;
                    cout 
                    int arr[5] = {1, 2, 3, 4, 5};
                    // 通过数组下标访问
                    cout 
                    int arr[5] = {1, 2, 3, 4, 5};
                    // 直接将数组名当作指针进行运算
                    cout 
                    int a = 10;
                    // 声明一个指向常量的指针
                    const int* p = &a;
                    //或者
                    int const* p_t = &a;
                    return 0;
                }
                
                    int a = 10;
                    int b = 20;
                    const int* p = &a;
                    p = &b;
                    cout 
                    int a = 10;
                    int* const p = &a;
                    return 0;
                }
                
                    int a = 10;
                    int* const p = &a;
                    *p = 99;
                    cout 
                    char c = 'A';
                    char* p = &c;
                    cout 
                    char arr[5] = {'h', 'e', 'l', 'l', 'o'};
                    char* p = arr;
                    cout 
                    char arr[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
                    char* p = arr;
                //    printf("%s\n", arr);
                    cout 
                    const char* str = "hello";
                    cout 
                    char str[] = "hello";
                    cout