C++学习路程-5-入门-指针

1. 什么是指针？

指针是一个变量，其值是另一个变量的内存地址。通过指针，可以直接访问和操作内存，这为动态内存分配、数组处理和函数参数传递等提供了强大的灵活性。指针在C++中是非常重要的概念，但由于其直接操作内存的特性，使用不当可能导致程序崩溃或内存泄漏。

2. 指针的定义与初始化

2.1 定义指针

指针的定义格式为类型 *指针名，其中类型表示指针所指向的数据类型。指针的类型决定了它所指向数据的大小和如何解释内存中的数据。

示例：

cpp

int* ptr; // 定义一个指向整数的指针

在这个例子中，ptr是一个指针变量，能够存储一个整数类型的地址。

2.2 初始化指针

指针可以通过一个变量的地址进行初始化。使用&运算符可以获取变量的地址。

示例：

cpp

int value = 10;
int* ptr = &value; // ptr现在指向value的地址

在这个例子中，ptr被初始化为value的地址。要注意，未初始化的指针会指向一个随机地址，可能导致未定义行为。

3. 访问指针所指向的值

可以使用解引用运算符（*）来访问指针所指向的值。解引用是指通过指针访问其指向的内存位置。

示例：

cpp

#include <iostream>
using namespace std;

int main() {
    int value = 10;
    int* ptr = &value; // ptr指向value的地址
    cout << "Value: " << *ptr << endl; // 通过指针访问值，输出10
    *ptr = 20; // 修改指针所指向的值
    cout << "New Value: " << value << endl; // 输出20
    return 0;
}

在上述例子中，*ptr解引用ptr以获取value的值，并且可以通过*ptr修改value的值。

4. 指针的类型

指针的类型与其所指向的数据类型相匹配，指针的类型决定了指针的大小和解引用的方式。常见的指针类型包括：

整型指针：int*，指向整数类型。
字符指针：char*，指向字符类型，常用于字符串。
浮点型指针：float*，指向浮点类型。
双浮点型指针：double*，指向双精度浮点类型。
void指针：void*，可以指向任何类型，但不能直接解引用，通常用于通用指针。

5. 指针的数组与字符串

5.1 指针与数组

数组名在大多数情况下可以被视为指向数组首元素的指针。数组和指针之间的关系使得可以通过指针访问数组元素。

示例：

cpp

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* ptr = arr; // 指针指向数组的首元素

    for (int i = 0; i < 5; i++) {
        cout << *(ptr + i) << " "; // 通过指针访问数组元素
    }
    cout << endl;
    return 0;
}

在这个例子中，ptr指向数组arr的首元素，*(ptr + i)通过指针算术访问数组的每个元素。

5.2 指针与字符串

C风格字符串是以空字符（'\0'）结尾的字符数组，可以通过字符指针访问。

示例：

cpp

#include <iostream>
using namespace std;

int main() {
    char str[] = "Hello";
    char* ptr = str; // 指向字符串的首字符

    while (*ptr != '\0') { // 遍历字符串直到遇到空字符
        cout << *ptr; // 输出字符
        ptr++;
    }
    cout << endl;
    return 0;
}

在这个例子中，ptr指向字符串的首字符，通过解引用和指针递增遍历字符串。

6. 动态内存分配

C++提供了new和delete运算符用于动态内存分配和释放。动态内存分配允许程序在运行时请求内存，这在处理不确定大小的数据结构时非常有用。

6.1 使用`new`分配内存

使用new运算符为指针分配内存。new会返回指向所分配内存的指针。

示例：

cpp

int* ptr = new int; // 动态分配一个整数
*ptr = 10; // 赋值
cout << *ptr << endl; // 输出10

6.2 使用`delete`释放内存

使用delete运算符释放动态分配的内存，以避免内存泄漏。每次使用new分配的内存都应该在不再需要时用delete释放。

示例：

cpp

delete ptr; // 释放内存
ptr = nullptr; // 设置指针为nullptr，避免悬空指针

7. 指针的常见错误

野指针：指向未分配或已释放内存的指针，使用时可能导致未定义行为。确保指针在使用前被初始化，并在释放后将其设置为nullptr。
内存泄漏：未释放动态分配的内存，导致程序占用的内存不断增加。确保每次new分配的内存都有对应的delete释放。
指针算术错误：不当使用指针算术可能导致越界访问，特别是在处理数组时。

8. 指针与函数

8.1 传递指针给函数

可以将指针作为参数传递给函数，这样可以在函数内部修改原始变量的值。这种方式称为通过引用传递。

示例：

cpp

void increment(int* num) {
    (*num)++; // 修改原始变量
}

int main() {
    int value = 10;
    increment(&value); // 传递变量的地址
    cout << value; // 输出11
    return 0;
}

在这个例子中，increment函数接收一个指向整数的指针，通过解引用修改了value的值。

8.2 函数返回指针

函数可以返回指向动态分配内存的指针，但需要小心管理内存，以避免返回指向已释放内存的指针。

示例：

cpp

int* createArray(int size) {
    return new int[size]; // 动态分配数组
}

int main() {
    int* arr = createArray(5);
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " "; // 输出数组元素
    }
    delete[] arr; // 释放数组内存
    return 0;
}

在这个例子中，createArray函数返回一个指向动态数组的指针。在主函数中，使用delete[]释放动态分配的数组内存。

9. 指针的指针

指针的指针是指向指针的指针，可以用于多级指针。指针的指针可以用于动态数组或复杂数据结构的管理。

示例：

cpp

int value = 10;
int* ptr = &value; // 指向整数的指针
int** ptrToPtr = &ptr; // 指向指针的指针

cout << **ptrToPtr << endl; // 输出10

在这个例子中，ptrToPtr是一个指向ptr的指针，通过解引用可以访问value的值。

10. 常用指针运算

解引用：使用*运算符访问指针所指向的值。
指针算术：指针可以进行加法和减法运算，例如通过ptr + 1访问下一个元素的地址。指针算术会根据元素类型自动调整地址。

11. 智能指针

C++11引入了智能指针（如std::unique_ptr和std::shared_ptr），用于自动管理动态内存，减少内存泄漏的风险。

11.1 `std::unique_ptr`

std::unique_ptr是独占所有权的智能指针，确保同一时间内只有一个指针指向某个对象。

cpp

#include <iostream>
#include <memory>
using namespace std;

int main() {
    unique_ptr<int> ptr(new int(10)); // 创建智能指针
    cout << *ptr << endl; // 输出10
    // 不需要手动释放内存，ptr离开作用域时自动释放
    return 0;
}

11.2 `std::shared_ptr`

std::shared_ptr可以多个指针共享同一个对象，使用引用计数来管理内存。当最后一个指向该对象的shared_ptr被销毁时，内存才会被释放。

cpp

#include <iostream>
#include <memory>
using namespace std;

int main() {
    shared_ptr<int> ptr1(new int(10));
    shared_ptr<int> ptr2 = ptr1; // ptr2共享ptr1的所有权
    cout << *ptr1 << " " << *ptr2 << endl; // 输出10
    return 0; // 自动释放内存
}