C语言：指针讲解

为什么需要指针?

（1）指针的使用使得不同区域的代码可以轻易的共享内存数据。当然你也可以通过数据的复制达到相同的效果，但是这样往往效率不太好，因为诸如结构体等大型数据，占用的字节数多，复制很消耗性能。但使用指针就可以很好的避免这个问题，因为任何类型的指针占用的字节数都是一样的。

（2）指针使得一些复杂的链接性的数据结构的构建成为可能，比如链表，链式二叉树等等。

（3）有些操作必须使用指针。如操作申请的堆内存。

C语言中的一切函数调用中，实参传递给形参的机理都是按值传递(pass by value)，如果我们要在函数中修改被传递过来的对象，就必须通过这个对象的指针来完成。

指针是什么？

任何程序数据载入内存后，在内存都有他们的地址，这就是指针。为了保存一个数据在内存中的地址，就需要指针变量。指针是程序数据在内存中的地址，而指针变量是用来保存这些地址的变量。

为什么程序中的数据会有自己的地址？操作系统将DRAM等硬件和软件结合起来，给程序员提供的一种对物理内存使用的抽象。这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作物理存储器。所有的虚拟地址形成的集合就是虚拟地址空间。

虚拟存储器是一个很大的，线性的字节数组。每一个字节都是固定的大小，由8个二进制位组成。最关键的是，每一个字节都有一个唯一的编号,编号从0开始，一直到最后一个字节。由于内存中的每一个字节都有一个唯一的编号，因此，在程序中使用的变量，常量，甚至数函数等数据，当他们被载入到内存中后，都有自己唯一的一个编号，这个编号就是这个数据的地址。指针就是这样形成的。

#include <stdio.h>
int main(void)
{
    char ch = 'a';
    int  num = 97;
    printf("ch 的地址:%p\n",&ch);   //ch 的地址:0028FF47
    printf("num的地址:%p\n",&num);  //num的地址:0028FF40
    return 0;
}

指针的值实质是内存单元（即字节）的编号，所以指针单独从数值上看，也是整数，他们一般用16进制表示。指针的值（虚拟地址值）使用一个机器字的大小来存储。

我们可以大致画出变量ch和num在内存模型中的存储。（假设 char占1个字节，int占4字节）

总结：资源有限的情况下，使用合理的资产使用管理机制。抽象的事物更加简单稳定，特定的事物更加复杂易变。底层通过给上层提供抽象服务来获得利益，上层通过使用底层的抽象来获得便利。

变量和内存

为了简单起见，这里就用上面例子中的 int num = 97 这个局部变量来分析变量在内存中的存储模型。

已知：num的类型是int，占用了4个字节的内存空间，其值是97，地址是0028FF40。从以下几个方面去分析。

1、内存的数据

内存的数据就是变量的值对应的二进制，一切都是二进制。97的二进制是 : 00000000 00000000 00000000 0110000 , 但使用的小端模式存储时，低位数据存放在低地址，所以图中画的时候是倒过来的。

2、内存数据的类型

内存的数据类型决定了这个数据占用的字节数，以及计算机将如何解释这些字节。num的类型是int，因此将被解释为一个整数。相同的内存数据以不同的数据类型去解析的时候，会得到不同的值，所以数据的类型是非常重要的。

3、内存数据的名称

内存的名称就是变量名。实质上，内存数据都是以地址来标识的，根本没有内存的名称这个说法，这只是高级语言提供的抽象机制，方便我们操作内存数据。而且在C语言中，并不是所有的内存数据都有名称，例如使用malloc申请的堆内存就没有。

4、内存数据的地址

如果一个类型占用的字节数大于1，则其变量的地址就是其占用的所有字节的地址值最小的那个字节的地址。因此num的地址是 0028FF40。内存的地址用于标识这个内存块。

5、内存数据的生命周期

num是main函数中的局部变量，因此当main函数被启动时，它被分配于栈内存上，当main执行结束时，消亡。

如果一个数据一直占用着他的内存，那么我们就说他是“活着的”，如果他占用的内存被回收了，则这个数据就“消亡了”。C语言中的程序数据会按照他们定义的位置，数据的种类，修饰的关键字等因素，决定他们的生命周期特性。实质上我们程序使用的内存会被逻辑上划分为：栈区，堆区，静态数据区，代码区。不同的区域的数据有不同的生命周期和读写权限。

指针变量和指向关系

用来保存指针的变量，就是指针变量。如果指针变量p1保存了变量 num的地址，则就说：p1指向了变量num，可以说p1指向了num所在的内存块，这种指向关系，在图中一般用箭头表示。

上图中，指针变量p1指向了num所在的内存块，即从地址0028FF40开始的4个byte 的内存块。

定义指针变量

C语言中，定义变量时，在变量名前写一个 * 星号，这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。

int a ; //int类型变量 a
int* p ; //int* 变量p
int arr[3]; //arr是包含3个int元素的数组
int (* parr )[3]; //parr是一个指向【包含3个int元素的数组】的指针变量

int* p_int; //指向int类型变量的指针 
double* p_double; //指向double类型变量的指针 
struct Student *p_struct; //结构体类型的指针
int(*p_func)(int,int); //指向返回类型为int，有2个int形参的函数的指针 
int(*p_arr)[3]; //指向含有3个int元素的数组的指针 
int** p_pointer; //指向 一个整形变量指针的指针

取地址

使用&运算符取得一个变量的地址。

int add(int a , int b)
{
    return a + b;
}
int main(void)
{
    int num = 97;
    float score = 10.00F;
    int arr[3] = {1,2,3};
    int* p_num = &num;
    float* p_score = &score;
    int (*p_arr)[3] = &arr;           
    int (*fp_add)(int ,int )  = &add;  //p_add是指向函数add的函数指针
    return 0;
}

特殊的情况，他们并不一定需要使用&取地址：

数组名的值就是这个数组的第一个元素的地址。

函数名的值就是这个函数的地址。

字符串字面值常量作为右值时，就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。

int add(int a , int b){
    return a + b;
}
int main(void)
{
    int arr[3] = {1,2,3};
    //-----------------------
    int* p_first = arr;
    int (*fp_add)(int ,int )  =  add;
    const char* msg = "Hello world";
    return 0;
}

解地址

我们需要一个数据的指针变量干什么？当然使用通过它来操作（读/写）它指向的数据啦。对一个指针解地址，就可以取到这个内存数据，解地址的写法，就是在指针的前面加一个*号。

解指针的实质是：从指针指向的内存块中取出这个内存数据。

int main(void)
{
    int age = 19;
    int*p_age = &age;
    *p_age  = 20;  //通过指针修改指向的内存数据
    printf("age = %d\n",*p_age);   //通过指针读取指向的内存数据
    printf("age = %d\n",age);
    return 0;
}

指针之间的赋值

指针赋值和int变量赋值一样，就是将地址的值拷贝给另外一个。指针之间的赋值是一种浅拷贝，是在多个编程单元之间共享内存数据的高效的方法。

int* p1  = & num;
int* p3 = p1;
//通过指针 p1 、 p3 都可以对内存数据 num 进行读写，如果2个函数分别使用了p1 和p3，那么这2个函数就共享了数据num。

空指针

指向空，或者说不指向任何东西。在C语言中，我们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是 ((void*)0) ，在C++中，NULL实质是0。

换种说法：任何程序数据都不会存储在地址为0的内存块中，它是被操作系统预留的内存块。

下面代码摘自 stddef.h

#ifdef __cplusplus
     #define NULL    0
#else    
     #define NULL    ((void *)0)
#endif

坏指针

指针变量的值是NULL，或者未知的地址值，或者是当前应用程序不可访问的地址值，这样的指针就是坏指针，不能对他们做解指针操作，否则程序会出现运行时错误，导致程序意外终止。

任何一个指针变量在做解地址操作前，都必须保证它指向的是有效的，可用的内存块，否则就会出错。坏指针是造成C语言Bug的最频繁的原因之一。

下面的代码就是错误的示例。

int*p = NULL;
*p = 10;     //不能对NULL解地址

int*p;
*p = 10;      //不能对一个未知的地址解地址

int*p = (int*)1000; 
*p =10;      //不能对一个可能不属于本程序的内存的地址的指针解地址







int*p = (int*)1000; 
*p =10;      //不能对一个可能不属于本程序的内存的地址的指针解地址

指针的2个重要属性

指针也是一种数据，指针变量也是一种变量，因此指针这种数据也符合前面变量和内存主题中的特性。这里我只想强调2个属性：指针的类型，指针的值。

int main(void)
{
    int num = 97;
    int *p1  = &num;
    char* p2 = (char*)(&num);

    printf("%d\n",*p1);    //输出  97
    putchar(*p2);          //输出  a
    return 0;
}

指针的值：很好理解，如上面的num 变量，其地址的值就是0028FF40 ，因此 p1的值就是0028FF40。数据的地址用于在内存中定位和标识这个数据，因为任何2个内存不重叠的不同数据的地址都是不同的。

指针的类型：指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。一般指针变量的类型要和它指向的数据的类型匹配。

由于num的地址是0028FF40，因此p1 和 p2的值都是0028FF40

*p1 : 将从地址0028FF40 开始解析，因为p1是int类型指针，int占4字节，因此向后连续取4个字节，并将这4个字节的二进制数据解析为一个整数 97。

*p2 : 将从地址0028FF40 开始解析，因为p2是char类型指针，char占1字节，因此向后连续取1个字节，并将这1个字节的二进制数据解析为一个字符，即'a'。

同样的地址，因为指针的类型不同，对它指向的内存的解释就不同，得到的就是不同的数据。

void*类型指针

由于void是空类型，因此void*类型的指针只保存了指针的值，而丢失了类型信息，我们不知道他指向的数据是什么类型的，只知道这个数据在内存中的起始地址，如果想要完整的提取指向的数据，程序员就必须对这个指针做出正确的类型转换，然后再解指针。前面已经提到过，数据的类型是正确解析出内存数据的关键，相同的内存数据以不同的数据类型去解析的时候，会得到不同的值。程序需要得到什么数据，不光要知道其地址，还要明确其类型，因此编译器不允许直接对void*类型的指针做解指针操作。

结构体和指针

结构体指针有特殊的语法： -> 符号

如果p是一个结构体指针，则可以使用 p ->成员的方法访问结构体的成员。p->member 等价于 (*p).member。

typedef struct
{
    char name[31];
    int age;
    float score;
}Student;

int main(void)
{
    Student stu = {"Bob" , 19, 98.0};
    Student*ps = &stu;

    ps->age = 20;
    ps->score = 99.0;
    printf("name:%s age:%d\n",ps->name,ps->age);
    return 0;
}

数组和指针

int ages[5]={10,9,8,7,6};

遍历数组

for(int i=0;i<5;i++)
   printf(“%d\n”,ages[i]);

使用指针遍历数组

int *p;
p=ages;//也可以写成p=&ages[0];，指针变量p指向了数组的首元素

元素的地址

第一个元素的地址p    &ages[0]
第二个元素的地址p+1  &ages[1]
第三个元素的地址p+2  &ages[2]

元素的值

*p     ages[0]
*(p+1) ages[1]
*(p+2) ages[2]

把指针当做数组来用

for(int i=0;i<5;i++)
   printf(“%d\n”,*(p+i));

（1）数组元素的三种访问形式

①数组名[下标]
②指针变量名[下标]
③*（p+1）

（2）指针变量的+1究竟是加多少？这取决于指针的类型，如果是char类型则加1个字节，如果是int类型的，则加4个字节。

（3）利用指针来接收一个数组，指针变量指向了数组的首元素。

void change(int array[])等价于void change(int *array)。

前者存储的虽然是数组元素的首地址，但是在传递时就已经变成指针了。

void change(int *array){
//Printf(“%d\n”,array[2]);
Printf(“%d\n”,*(array+2));
}
Int main(){
Int ages[5]={1,2,3,4,5};
Change(ages);
}

调用的结果为：数组的第三个元素3。

掌握字符串定义的两种方式。

① 利用数组：字符串里边的字符是可以修改的，适用于内容需要经常修改时。

② 利用指针：一个常量字符串，里面的字符不能修改，适用于字符串的内容不需要修改，且这个字符串经常被使用时。

（二）指针数组

整型数组：数组中存放的都是整型数组。

指针数组：数组中存放的都是指针。

int ages[5];
char *name[5]={“jack”,“rose”,“yang”};//字符串数组的常见写法

对应于

char name2[3][10]={“jack”,“rose”,“yang”};

保存字符串数组的两种方式：

①指针数组（字符串数组）

②二维字符数组（字符串数组）

函数的参数和指针

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面一样，而不是同一个内存数据对象。这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数无法修改传递的参数达到回传的效果。

有时候我们可以使用函数的返回值来回传数据，在简单的情况下是可以的，但是如果返回值有其它用途（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。

传递变量的指针可以轻松解决上述问题。

通过指针传递数据给函数不是为了在函数中改变他指向的对象，相反，我们防止这个目标数据被改变。传递指针只是为了避免拷贝大型数据。考虑一个结构体类型Student。我们通过show函数输出Student变量的数据。

typedef struct
{
    char name[31];
    int age;
    float score;
}Student;

//打印Student变量信息
void show(const Student * ps)
{
    printf("name:%s , age:%d , score:%.2f\n",ps->name,ps->age,ps->score);   
}

只是在show函数中取读Student变量的信息，而不会去修改它，为了防止意外修改，我们使用了常量指针去约束。另外我们为什么要使用指针而不是直接传递Student变量呢？

从定义的结构看出，Student变量的大小至少是39个字节，那么通过函数直接传递变量，实参赋值数据给形参需要拷贝至少39个字节的数据，极不高效。而传递变量的指针却快很多，因为在同一个平台下，无论什么类型的指针大小都是固定的：X86指针4字节，X64指针8字节，远远比一个Student结构体变量小。

应用：

现在有个要求：写一个函数swap，接收2个整型参数，功能是互换两个实参的值。

void swap(char v1, char v2) {
     printf("更换前：v1=%d, v2=%d\n", v1, v2);
      // 定义一个中间变量
     char temp;
      // 交换v1和v2的值
     temp = v1;
     v1 = v2;
     v2 = temp;     
     printf("更换后：v1=%d, v2=%d\n", v1, v2);
}
 
int main(){
     char a = 10, b = 9;
     printf("更换前：a=%d, b=%d\n", a, b);     
     swap(a, b);     
     printf("更换后：a=%d, b=%d", a, b);
     return 0;
}

虽然v1和v2的值被交换了，但是变量a和b的值根本就没有换过来。因为基本数据类型作为函数实参时，只是纯粹地将值传递给形参，形参的改变并不影响实参。

应该使用交换两个值。

// 使用引用重写swap函数
void swap(int *v1, int *v2) {
    int temp = v1;
    v1 = v2;
    v2 = temp;
}

如果没有指针，使用值传递在一个函数的内部改变不了外部的实参。

应用：

默认情况下，一个函数只能有一个返回值，有了指针，我们可以实现函数有"多返回值"。

现在有个要求：写一个函数sumAndMinus，可以同时计算2个整型的和与差，函数执行完毕后，返回和与差(注意了，这里要返回2个值）

// 计算2个整型的和与差
int sumAndMinus(int v1, int v2, int *minus) {
    // 计算差，并赋值给指针指向的变量
    *minus = v1 - v2;
    // 计算和，并返回和
    return v1 + v2;
}
int main()
{
    // 定义2个int型变量
    int a = 6, b = 2;
    // 定义2个变量来分别接收和与差
    int sum, minus;
    // 调用函数
    sum = sumAndMinus(a, b, &minus);
    // 打印和
    printf("%d+%d=%d\n", a, b, sum);
    // 打印差
    printf("%d-%d=%d\n", a, b, minus);
    return 0;
}

和与差都由同一个函数计算并返回出来。和是函数的直接返回值，差是通过函数的第3个指针参数间接返回。因此有了指针，我们可以让函数有"无限个"返回值。

深拷贝和浅拷贝

如果2个程序单元（例如2个函数）是通过拷贝他们所共享的数据的指针来工作的，这就是浅拷贝，因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了，在每个单元中都有自己的一份，对目标数据的操作相互不受影响，则叫做深拷贝。

指针和引用这个2个名词的区别。他们本质上来说是同样的东西。指针常用在C语言中，而引用，则用于诸如Java，C#等在语言层面封装了对指针的直接操作的编程语言中。引用是编程语言提供给程序员的抽象机制，而指针是操作系统提供给软件开发模型的抽象机制。

局部变量指针

如果不了解程序栈如何工作，就很容易犯返回指向局部数据指针的错误，看下面的例子：

#include<stdio.h>
#include<stdlib.h>
int* allocateArray(int size, int value)
{
    int arr[size];
    for(int i = 0; i < size; i++) {
        arr[i] = value;
    }
    return arr;
}
int main()
{
    int* vector = allocateArray(5, 45);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", vector[i]);
    }
    return 0;
}

一旦函数返回，返回的数组地址也就无效，因为函数的栈帧从栈中弹出了。有一种方法是把arr变量声明为static，这样会把变量的作用域现在在函数内部，但是分配在栈帧的外面，避免其他函数覆写变量值

#include<stdio.h>
#include<stdlib.h>
int* allocateArray(int size, int value)
{
    static int arr[10];
    for(int i = 0; i < size; i++) {
        arr[i] = value;
    }
    return arr;
}
int main()
{
    int* vector = allocateArray(5, 45);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", vector[i]);
    }
    return 0;
}

返回指针

从函数返回对象经常使用以下两种技术：

使用malloc在函数内部分配内存并返回其地址，调用者负责释放返回的内存
传递一个对象给函数，让函数修改它，这样分配和释放对象的内存都是调用者的责任

#include<stdio.h>
#include<stdlib.h>
int* allocateArray(int size, int value)
{
    int* arr  = (int*)malloc(size * sizeof(int));
    for(int i = 0; i < size; i++) {
        arr[i] = value;
    }
    return arr;
}
int main()
{
    int* vector = allocateArray(5, 45);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", vector[i]);
    }
    free(vector);
    return 0;
}

下面这个版本的allocateArray函数传递了一个数组指针、数组的长度和用来初始化数组元素的值，返回指针只是为了方便

#include<stdio.h>
#include<stdlib.h>
int* allocateArray(int *arr, int size, int value)
{
    if(arr != NULL) {
        for(int i = 0; i < size; i++) {
            arr[i] = value;
        }
    }
    return arr;
}
int main()
{
    int* vector = (int*)malloc(5 * sizeof(int));
    allocateArray(vector, 5, 45);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", vector[i]);
    }
    free(vector);
    return 0;
}

传递指针的指针

将指针传递给函数的时候，传递的是值，如果希望修改原指针而不是指针的副本，就需要传递指针的指针

#include<stdio.h>
#include<stdlib.h>
void allocateArray(int **arr, int size, int value)
{
    *arr = (int*)malloc(size * sizeof(int));
    if(arr != NULL) {
        for(int i = 0; i < size; i++) {
            *(*arr + i) = value;
        }
    }
}
int main()
{
    int* vector = NULL;
    allocateArray(&vector, 5, 45);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", vector[i]);
    }
    free(vector);
    return 0;
}

指针与字符串

一个字符串由一个或多个字符组成，因此我们可以用字符数组来存放字符串，不过在数组的尾部要加上一个空字符'\0'。

char s[] = "mj";

上面的代码定义了一个字符数组s来存储字符串"mj"，系统会自动在尾部加上一个空字符'\0'。

我们也可以直接用指针指向一个字符串，省略定义字符数组这个步骤

#include <string.h> 
int main(){
     // 定义一个字符串，用指针s指向这个字符串
     char *s = "mj";
     // 使用strlen函数测量字符串长度
     int len = strlen(s);
     printf("字符串长度：%D", len);
     return 0;
 }

注意第6行，我们直接用指针s指向了字符串"mj"，并没有先创建一个字符数组。

指针指向字符串的其他方式

char *s;
s = "mj";

上面的指向方式也是正确的：先定义指针变量，再指向字符串。如果是字符数组就不允许这样做，下面的做法是错误的。

char s[10];
s = "mj";

编译器肯定报第2行的错，因为s是个常量，代表数组的首地址，不能进行赋值运算。

下面的做法也是错误的：

char *s = "mj";
   *s = "like";

第3行代码相当于把字符串"like"存进s指向的那一块内存空间，由第1行代码可以看出，s指向的是"mj"的首字符'm'，也就是说s指向的一块char类型的存储空间，只有1个字节，要"like"存进1个字节的空间内，肯定内存溢出由第1行代码可以看出，指针s指向的是字符串常量"mj"！因此是不能再通过指针来修改字符串内容的！就算是*s = 'A'这样"看起来似乎正确"的写法也是错误的，因为s指向的一个常量字符串，不允许修改它内部的字符。

指针处理字符串的注意

// 定义一个字符串变量"lmj"
 char a[] = "lmj"; 
 // 将字符串的首字符改为'L'
 *a = 'L'; 
 printf("%s", a);

可以实现。

 char *p2 = "lmj";
 *p2 = 'L'; 
 printf("%s", p2);

指针变量p2指向的是一块字符串常量，正因为是常量，所以它内部的字符是不允许修改的。

指向指针的指针

Int a=10;
Int *p=&a;//指向int型的指针
Int **p1=&p;//指向指针的指针
Int ***p2=&p1;//三级指针

*p2相当于访问p1；

**p2相当于访问p;

***p2相当于访问a;

*p1相当于访问p;

指向函数的指针

每一个函数本身也是一种程序数据，一个函数包含了多条执行语句，它被编译后，实质上是多条机器指令的合集。在程序载入到内存后，函数的机器指令存放在一个特定的逻辑区域：代码区。既然是存放在内存中，那么函数也是有自己的指针的。

C语言中，函数名作为右值时，就是这个函数的指针。

void echo(const char *msg){
    printf("%s",msg);
}
int main(void){
    void(*p)(const char*) = echo;   //函数指针变量指向echo这个函数
    p("Hello ");      //通过函数的指针p调用函数，等价于echo("Hello ")
    echo("World\n");
    return 0;
}

1.一个指针变量占用多少个字节的内存空间？占用的空间是否会跟随所指向变量的类型而改变？

指针变量在计算机内存中占用的空间大小并不会跟随它所指向的变量类型而改变。指针变量本身的大小是由其所运行的操作系统和处理器架构决定的，主要用于存储一个内存地址。

在32位操作系统和处理器架构中，指针变量通常占用4个字节，这是因为32位地址能够寻址的最大空间为2^32个内存单元，每个内存单元通常是一个字节，所以需要32位来表示一个地址。

在64位操作系统和处理器架构中，指针变量通常占用8个字节，对应64位地址空间，可以寻址更大的内存空间。

2.既然每个指针变量所占用的内存空间是一样的，而且存储的都是地址，为何指针变量还要分类型？而且只能指向一种类型的变量？比如指向int类型的指针、指向char类型的指针。

（1）指针运算的语义
不同类型的指针在进行指针算术运算时，如增加或减少指针值时，步长是不一样的。例如，int *p 类型的指针加1，将会移动到下一个int 变量的位置，而char *p类型的指针加1，则只会移动到下一个字符变量的位置。这是因为不同类型的变量在内存中占用的字节数不同。

（2)数据的安全访问：
- 编译器需要知道指针指向的数据类型，以便在解引用时正确读取或写入适当数量的字节。例如，解引用`int *p`时会读取4个字节，而解引用`char *p`时仅读取1个字节。

(3)类型系统的安全性：
C/C++语言的类型系统要求指针必须与其指向的数据类型匹配，以防止错误的数据访问和转换。这样有助于在编译阶段发现潜在的类型不匹配错误，增强程序的健壮性和安全性。

(4)编译器的类型检查：
编译器通过指针类型来执行类型检查，确保只有兼容类型的指针之间才能互相赋值或比较，这样可以阻止非法的内存访问。

(5) 函数接口的清晰性：
当指针作为函数参数时，指针类型明确了函数期望处理的数据类型，使得函数接口更加清晰，调用者不会混淆。

使用裸指针可能存在的问题

问题一：难以区分指向的是单个对象还是一个数组


int *p = new int; // 分配一个整型对象
*p = 10;

// 或者
int *arr = new int[5]; // 分配一个包含5个整型元素的数组
arr[0] = 10;

在指针 p 或 arr 上，仅凭指针本身无法区分其指向的是单个对象还是数组。

问题二：使用完指针之后无法判断是否应该销毁指针

void someFunction(int *ptr) {
    // ... 使用 ptr ...
} // 函数结束时，如果不显式 delete ptr，则可能会造成内存泄漏

int main() {
    int *p = new int;
    someFunction(p); // 函数结束后，p 指向的内存如果没有被释放则会泄漏
    // 此处应加上 delete p;
    return 0;
}

问题三：销毁方式不确定

struct CustomObject {
    ~CustomObject() { /* 特殊清理逻辑 */ }
};

CustomObject *createObject() {
    return new CustomObject();
}

void cleanup(CustomObject *obj) {
    delete obj; // 可能有特殊清理方式
}

int main() {
    CustomObject *obj = createObject();
    // 如果不知道这里应该调用 cleanup(obj) 还是直接 delete obj，
    // 则无法正确销毁对象
    // 正确做法取决于对象的实际生命周期管理策略
    // ...
    // 不清楚的情况下，可能错误地：
    // delete obj; // 或者忘记销毁
    return 0;
}

问题四：无法确定使用 delete 还是 delete[]

int *singleInt = new int;
int *arrayOfInts = new int[5];

// 错误的释放方式，如果忘记了数组
delete singleInt; // 对数组应用了错误的 delete
delete arrayOfInts; // 应该使用 delete[]

// 正确的释放方式应该是
delete singleInt;
delete[] arrayOfInts;

问题五：路径控制问题和悬挂指针

class MyClass {
public:
    void useResource(int *resource) {
        if (resource != nullptr) {
            // 使用 resource...
            // 如果在这条路径上抛出了异常，那么下面的 delete 可能不会被执行
            delete resource;
        }
    }

    void errorProne() {
        int *p = new int;
        try {
            useResource(p);
        } catch (...) {
            // 异常处理，但没有释放 p，这会导致内存泄漏
        }
    }
};
int main() {
    MyClass mc;
    mc.errorProne(); // 即使我们知道应该在这里释放 p，也可能因为异常路径而导致泄漏
    return 0;
}