C++ 指针#

1
int*   p_int;    // 一个将要指向 int 类型数据的指针
2
char*  p_char;   // 一个将要指向 char 类型数据的指针
3
Student* p_student; // 一个将要指向 Student 对象的指针

1
int score = 95;
2
// &score 的结果就是变量 score 在内存中的地址
3
// 将这个地址赋值给指针 p_score
4
int* p_score = &score;

1
int score = 95;
2
int* p_score = &score;
3

4
// *p_score 的意思是 "访问 p_score 指向的地址上的数据"
5
std::cout << "Value via pointer: " << *p_score << std::endl; // 输出: 95
6

7
// 也可以通过指针修改原始数据
8
*p_score = 100;
9
std::cout << "Original value now: " << score << std::endl; // 输出: 100

1
int* p = nullptr; // 明确地表示这是一个空指针，不指向任何有效地址
2

3
// 在使用指针前，检查它是否为空是一个非常好的习惯
4
if (p != nullptr) {
5
    // ... 安全地使用 p ...
6
}

1
// 分配一个 int
2
int* p_num = new int(42); // 在堆上创建一个int，值为42
3

4
// 分配一个大小为 N 的 int 数组
5
int N = 10;
6
int* p_array = new int[N];
7

8
// ... 使用 p_num 和 p_array ...
9
std::cout << *p_num << std::endl; // 输出 42
10
p_array[0] = 100;
11

12
// ！！！ 必须手动释放内存，否则会造成内存泄漏 ！！！
13
delete p_num;
14
delete[] p_array;

1
int arr[5] = {10, 20, 30, 40, 50};
2
int* p = arr; // arr 退化为 &arr[0]
3

4
// 这两种访问方式等价
5
std::cout << arr[2] << std::endl;      // 输出 30
6
std::cout << *(p + 2) << std::endl;    // 输出 30

1
// 这个函数在堆上创建一个数组并返回它
2
int* create_random_array(int size) {
3
    int* arr = new int[size];
4
    for (int i = 0; i < size; ++i) {
5
        arr[i] = rand() % 100;
6
    }
7
    return arr;
8
}

1
#include <iostream>
2
#include <cstring> // For strlen
3

4
// --- 1. 辅助函数：交换两个字符 ---
5
// 使用指针接收地址，直接修改原始字符
6
void swapChars(char* a, char* b) {
7
    if (a != nullptr && b != nullptr) {
8
        char temp = *a; // 解引用a，读取值
9
        *a = *b;      // 解引用a和b，进行赋值
10
        *b = temp;
11
    }
12
}
13

14
// --- 2. 核心函数：原地逆序字符串 ---
15
// 接受一个指向字符的指针（C风格字符串）
16
void reverseStringInPlace(char* str) {
17
    if (str == nullptr) {
18
        return; // 处理空指针，保证安全
19
    }
20

21
    int len = std::strlen(str);
22
    if (len < 2) {
23
        return; // 长度为0或1的字符串无需逆序
24
    }
25

26
    // [指针的应用] -> 初始化两个指针
27
    char* start = str;               // start 指向字符串的第一个字符
28
    char* end = str + len - 1;       // end 指向字符串的最后一个字符（\0之前）
29

30
    // [指针的应用] -> 循环条件是指针的比较
31
    while (start < end) {
32
        // [指针的应用] -> 将指针传递给另一个函数
33
        swapChars(start, end);
34

35
        // [指针的应用] -> 指针算术
36
        start++; // 指针向右移动一个char的位置
37
        end--;   // 指针向左移动一个char的位置
38
    }
39
}
40

41
// --- 3. main 函数：测试我们的实现 ---
42
int main() {
43
    // [指针的应用] -> 动态分配内存来存储字符串
44
    char* my_string = new char[50];
45
    std::strcpy(my_string, "Hello, Pointer!");
46

47
    std::cout << "Original string: " << my_string << std::endl;
48

49
    // 调用逆序函数
50
    reverseStringInPlace(my_string);
51

52
    std::cout << "Reversed string: " << my_string << std::endl;
53

54
    // [指针的应用] -> 释放动态分配的内存
55
    delete[] my_string;
56
    my_string = nullptr; // 好习惯：释放后置为nullptr
57

58
    // 测试空指针和短字符串
59
    char* empty_str = nullptr;
60
    reverseStringInPlace(empty_str); // 应该能安全处理
61
    std::cout << "Reversing a nullptr is safe." << std::endl;
62

63
    return 0;
64
}