异常教程

C++ 指针 vs 数组（手把手讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在 C++ 程序开发中，指针和数组是两个核心概念，它们在内存管理、数据操作和函数参数传递中扮演着关键角色。对于编程初学者而言，两者在语法和行为上的相似性容易引发混淆，而中级开发者则可能因理解不深入导致内存错误或代码效率问题。本文将通过对比分析、案例演示和实用建议，系统解析 C++ 指针 vs 数组 的差异与应用场景，帮助读者建立清晰的认知框架。

一、基础概念：指针与数组的定义与特性

1.1 数组：连续内存的集合

数组是存储相同类型数据的连续内存块。例如，声明 int arr[5]; 会分配 5 个 int 类型的连续空间，每个元素通过索引（如 arr[0]）直接访问。

  • 特性：
    • 内存地址固定，无法重新指向其他内存区域。
    • 大小在编译时确定（静态数组），或通过 new 动态分配（动态数组）。
    • 数组名本身表示其首地址，但不能重新赋值。

示例：

int arr[3] = {10, 20, 30};  
cout << "数组首地址：" << arr << endl; // 输出 arr 的首地址  
arr[1] = 25; // 直接修改第二个元素

1.2 指针：内存地址的“指示器”

指针是一个变量，存储另一个变量的内存地址。例如，int* ptr; 声明了一个指向 int 类型的指针。通过解引用操作符 *，可以访问指针指向的内存值。

  • 特性：
    • 可以动态指向不同内存区域，甚至通过 new 或 malloc 分配新内存。
    • 需要手动管理内存生命周期，可能存在悬空指针或内存泄漏风险。
    • 可以进行算术运算（如 ptr++），实现类似数组的遍历。

示例：

int num = 100;  
int* ptr = &num; // ptr 存储 num 的地址  
cout << "*ptr 的值：" << *ptr << endl; // 输出 100  
ptr = new int(200); // 动态分配内存并重新指向

二、语法对比：声明、访问与操作

2.1 声明与初始化

特性数组指针
声明语法类型 数组名[大小];类型* 指针名;
初始化可直接初始化（如 int arr[3] = {1,2,3};）需通过地址赋值（如 int* ptr = &var;）
动态分配需 new[] 显式分配（如 int* arr = new int[5];）支持 new 或直接指向现有变量

示例对比：

// 数组初始化  
int arr[3] = {1, 2, 3};  

// 指针初始化  
int val = 42;  
int* ptr = &val;

2.2 访问元素与内存地址

  • 数组：通过索引 arr[index] 访问元素，索引从 0 开始。
  • 指针：通过解引用 *ptr 获取值，或通过 ptr[index] 访问偏移地址的元素。

关键区别：

  • 数组名 arr 等价于 &arr[0]（首地址），但无法重新赋值（如 arr = new int[5]; 会报错）。
  • 指针 ptr 可以重新指向其他内存（如 ptr = new int[10];）。

示例：

int arr[3] = {10, 20, 30};  
int* ptr = arr; // ptr 指向数组首地址  

cout << "arr[1] = " << arr[1] << endl; // 输出 20  
cout << "*ptr = " << *ptr << endl;     // 输出 10（首元素）  
ptr++;  
cout << "*ptr = " << *ptr << endl;     // 输出 20（第二个元素）

三、内存管理：静态与动态的博弈

3.1 数组的内存特性

  • 静态数组：内存在栈上分配，大小固定，生命周期由作用域决定。
  • 动态数组：通过 new[] 在堆上分配，需手动释放（delete[]），适合大小不确定的场景。

案例：

// 静态数组（栈内存）  
void staticArray() {  
    int arr[5]; // 函数结束时自动释放  
}  

// 动态数组（堆内存）  
void dynamicArray() {  
    int* arr = new int[10];  
    // ... 使用后必须释放 ...  
    delete[] arr; // 忘记会导致内存泄漏  
}

3.2 指针的灵活性与风险

指针可以动态分配、释放内存，甚至指向堆或栈中的任意合法地址。但需注意：

  • 悬空指针：指向已释放的内存（如 delete 后未置 nullptr）。
  • 野指针：未初始化的指针（如 int* ptr; *ptr = 10; 可能崩溃）。
  • 内存泄漏：未释放不再使用的内存。

示例（危险操作）：

int* dangerousFunction() {  
    int* data = new int(42); // 在堆上分配  
    return data; // 调用者需负责释放，否则泄漏  
}

四、函数参数中的角色差异

4.1 数组作为参数

当数组传递给函数时，其首地址会退化为指针，失去原始大小信息。例如：

void printArray(int arr[], int size) {  
    for (int i = 0; i < size; i++) {  
        cout << arr[i] << " ";  
    }  
}  

int main() {  
    int myArr[] = {1, 2, 3};  
    printArray(myArr, 3); // 需手动传递 size  
    return 0;  
}

4.2 指针作为参数

指针参数更灵活，可指向任意内存区域，甚至修改外部数据：

void modifyData(int* ptr) {  
    *ptr = 100; // 修改调用者的数据  
}  

int main() {  
    int num = 5;  
    modifyData(&num); // num 变为 100  
    return 0;  
}

五、动态行为与操作差异

5.1 指针的可移动性

指针可以重新赋值指向其他内存，而数组地址固定。例如：

int main() {  
    int a = 10, b = 20;  
    int* ptr = &a; // 指向 a  
    ptr = &b;      // 重新指向 b，合法  
    // int arr1[5]; arr1 = arr2; // 数组赋值会报错  
    return 0;  
}

5.2 内存操作的算术运算

指针支持加减运算，实现类似数组的遍历：

int arr[3] = {1, 2, 3};  
int* ptr = arr;  
for (int i = 0; i < 3; i++) {  
    cout << *(ptr + i) << " "; // 输出 1 2 3  
}

六、实际案例：指针与数组的协作

6.1 实现字符串复制函数

通过指针操作模拟 strcpy 功能：

void myStrcpy(char* dest, const char* src) {  
    while (*src != '\0') {  
        *dest = *src;  
        dest++;  
        src++;  
    }  
    *dest = '\0'; // 添加终止符  
}  

int main() {  
    char src[] = "Hello";  
    char dest[10];  
    myStrcpy(dest, src);  
    cout << dest << endl; // 输出 "Hello"  
    return 0;  
}

6.2 动态二维数组的创建

使用指针实现动态二维数组：

int main() {  
    int rows = 3, cols = 4;  
    int** matrix = new int*[rows]; // 分配行指针数组  
    for (int i = 0; i < rows; i++) {  
        matrix[i] = new int[cols]; // 每行分配列空间  
    }  
    // ... 使用后释放 ...  
    for (int i = 0; i < rows; i++) {  
        delete[] matrix[i];  
    }  
    delete[] matrix;  
    return 0;  
}

七、最佳实践与常见陷阱

7.1 数组的使用场景

  • 优先选择数组：当数据大小已知且固定时（如 int scores[5];）。
  • 静态数组的优势：内存管理简单，无需手动释放。

7.2 指针的使用场景

  • 动态内存需求：如 new 分配的数组或对象。
  • 指向外部数据：函数参数传递或跨作用域修改数据。

7.3 避免常见错误

  • 内存泄漏：始终在 new 后匹配 delete。
  • 越界访问：确保索引不超过数组长度。
  • 指针未初始化：声明后立即赋值或置为 nullptr。

结论

通过对比 C++ 指针 vs 数组，我们可以总结：

  • 数组 是静态内存的有序集合，适合简单、固定长度的数据存储。
  • 指针 是灵活的内存地址引用工具，支持动态操作但需谨慎管理。

在实际开发中，两者常协同工作：例如，用指针遍历数组、动态分配内存或实现复杂数据结构。理解它们的差异与互补性，是编写高效、安全 C++ 代码的关键。对于初学者，建议从数组入手，逐步掌握指针的进阶技巧；中级开发者则需通过代码审查和工具（如 Valgrind）减少内存相关错误，提升程序的健壮性。

最新发布

查看更多文章