C++结构体与指针的黄金搭档：高效内存操作实战指南

02-09 1770阅读

在C++编程中，结构体（struct） 与 指针（pointer） 的结合堪称经典组合。它们不仅能够提升程序性能，还能实现灵活的数据组织与动态内存管理。然而，对于初学者而言，这种组合常常带来困惑甚至错误。本文将深入浅出地讲解结构体与指针联合使用的技巧、常见陷阱及最佳实践，助你掌握这一强大工具。

一、基础回顾：结构体与指针各自的角色

结构体：自定义数据类型的容器

结构体允许我们将不同类型的数据成员组合成一个逻辑单元。例如：

struct Student {
    std::string name;
    int age;
    double gpa;
};

指针：内存地址的“遥控器”

指针存储变量的内存地址，通过解引用（*）可访问或修改该地址上的值。

int x = 10;
int* p = &x;  // p 指向 x
*p = 20;      // 修改 x 的值为 20

当两者结合，我们就能以更高效、灵活的方式操作复杂数据。

二、结构体指针的声明与使用

1. 声明结构体指针

Student s1 = {"Alice", 20, 3.8};
Student* ptr = &s1;  // ptr 指向 s1

2. 访问成员：两种方式

解引用后用点运算符：(*ptr).name
箭头运算符（推荐）：ptr->name

✅ 技巧：优先使用 ->，代码更简洁且不易出错。

std::cout << ptr->name << " is " << ptr->age << " years old.\n";

三、动态分配结构体：堆内存的灵活运用

使用 new 在堆上创建结构体实例，适用于生命周期不确定或需要大量数据的场景。

Student* pStudent = new Student{"Bob", 22, 3.9};
// 使用...
delete pStudent;  // 别忘了释放！
pStudent = nullptr; // 避免悬空指针

⚠️ 注意：务必配对使用 new/delete，否则会导致内存泄漏。

进阶：动态数组 of 结构体

const int N = 3;
Student* students = new Student[N]{
    {"Charlie", 19, 3.5},
    {"Diana", 21, 4.0},
    {"Evan", 20, 3.7}
};

for (int i = 0; i < N; ++i) {
    std::cout << students[i].name << "\n";  // 可用下标或指针算术
}

delete[] students;  // 注意是 delete[]

四、函数参数传递：传指针 vs 传值

传值（Pass by Value）

void updateGPA(Student s, double newGPA) {
    s.gpa = newGPA;  // 修改的是副本，原对象不变
}

传指针（Pass by Pointer）

void updateGPA(Student* s, double newGPA) {
    if (s != nullptr) {
        s->gpa = newGPA;  // 直接修改原对象
    }
}

✅ 优势：避免复制大对象，提升性能；支持修改原始数据。

更现代的选择：引用（Reference）

虽然本文聚焦指针，但值得提及：

void updateGPA(Student& s, double newGPA) {
    s.gpa = newGPA;
}

引用语法更安全（无空指针风险），但指针在需要表示“可选”或动态重定向时仍不可替代。

五、链表：结构体+指针的经典应用

结构体与指针最著名的应用场景之一是链表。每个节点包含数据和指向下一个节点的指针。

struct Node {
    int data;
    Node* next;

    Node(int val) : data(val), next(nullptr) {}
};

// 创建简单链表
Node* head = new Node(1);
head->next = new Node(2);
head->next->next = new Node(3);

// 遍历
Node* current = head;
while (current != nullptr) {
    std::cout << current->data << " -> ";
    current = current->next;
}

💡 提示：链表、树、图等数据结构都依赖结构体+指针的组合。

六、常见陷阱与避坑指南

1. 悬空指针（Dangling Pointer）

Student* p = new Student{"Tom", 18, 3.6};
delete p;
// 此时 p 仍持有地址，但内存已释放
std::cout << p->name;  // ❌ 未定义行为！

解决：delete 后立即将指针置为 nullptr。

2. 野指针（Wild Pointer）

未初始化的指针：

Student* p;  // 未初始化，值随机
p->age = 20; // ❌ 危险！

解决：始终初始化指针，如 Student* p = nullptr;

3. 内存泄漏

忘记 delete 动态分配的结构体。解决：使用智能指针（如 std::unique_ptr）自动管理内存。

#include <memory>
auto p = std::make_unique<Student>("Lisa", 23, 3.9);
// 无需手动 delete，作用域结束自动释放

七、现代C++中的演进：智能指针与结构体

虽然原始指针仍有其地位，但C++11引入的智能指针大幅提升了安全性：

std::unique_ptr<Student> createStudent(const std::string& name, int age, double gpa) {
    return std::make_unique<Student>(name, age, gpa);
}

auto student = createStudent("Mike", 20, 3.85);
std::cout << student->name << "\n";  // 仍用 -> 访问