C++ 内存管理如何用于创建自定义数据结构？

C++的内存管理机制为自定义数据结构的创建提供了灵活的内存操作能力，开发者可以通过动态内存分配在运行时按需申请内存空间，从而构建出适配不同业务场景的自定义数据结构。合理运用内存管理不仅能提升内存利用率，还能避免内存泄漏、重复释放等常见问题。

C++动态内存管理基础

C++中主要通过new和delete操作符完成动态内存的分配与释放。和静态内存分配不同，动态分配的内存位于堆区，生命周期由开发者手动控制，非常适合用于自定义数据结构中不确定大小、需要动态扩展的场景。

new和delete的基本用法

new操作符会在堆区申请指定类型大小的内存空间，并返回该空间的首地址，如果申请失败会抛出std::bad_alloc异常。对应的delete操作符则用于释放new申请的内存，避免内存泄漏。

下面是基本的使用示例：

#include <iostream>
using namespace std;

int main() {
    // 动态分配一个int类型的内存
    int* numPtr = new int;
    *numPtr = 10;
    cout << "动态分配的int值：" << *numPtr << endl;
    
    // 释放内存
    delete numPtr;
    numPtr = nullptr; // 避免野指针
    
    // 动态分配数组
    int* arrPtr = new int[5];
    for (int i = 0; i < 5; i++) {
        arrPtr[i] = i * 2;
    }
    // 释放数组内存，需要加[]
    delete[] arrPtr;
    arrPtr = nullptr;
    
    return 0;
}

用内存管理创建自定义链表结构

链表是最典型的依赖动态内存管理的自定义数据结构，每个节点需要在运行时单独申请内存，节点之间通过指针关联，不需要连续的内存空间。

链表节点的定义与创建

首先定义链表节点的结构体，节点包含数据域和指向下一个节点的指针域：

#include <iostream>
using namespace std;

// 定义链表节点结构体
struct ListNode {
    int data;       // 数据域
    ListNode* next; // 指向下一个节点的指针
    
    // 构造函数，初始化节点
    ListNode(int val) : data(val), next(nullptr) {}
};

链表的基本操作实现

链表的插入、删除操作都需要通过new和delete管理节点内存，下面是简单的单向链表实现：

// 在链表头部插入节点
ListNode* insertAtHead(ListNode* head, int val) {
    // 为新节点申请内存
    ListNode* newNode = new ListNode(val);
    newNode->next = head;
    return newNode;
}

// 删除指定值的节点
ListNode* deleteNode(ListNode* head, int val) {
    if (head == nullptr) return nullptr;
    // 处理头节点是要删除的节点的情况
    if (head->data == val) {
        ListNode* temp = head;
        head = head->next;
        delete temp; // 释放被删除节点的内存
        temp = nullptr;
        return head;
    }
    // 遍历查找要删除的节点
    ListNode* curr = head;
    while (curr->next != nullptr) {
        if (curr->next->data == val) {
            ListNode* temp = curr->next;
            curr->next = temp->next;
            delete temp; // 释放内存
            temp = nullptr;
            break;
        }
        curr = curr->next;
    }
    return head;
}

// 释放整个链表的内存
void freeList(ListNode* head) {
    ListNode* curr = head;
    while (curr != nullptr) {
        ListNode* temp = curr;
        curr = curr->next;
        delete temp; // 逐个释放节点内存
        temp = nullptr;
    }
}

// 打印链表
void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
    ListNode* head = nullptr;
    // 插入节点
    head = insertAtHead(head, 3);
    head = insertAtHead(head, 2);
    head = insertAtHead(head, 1);
    cout << "链表内容：";
    printList(head); // 输出 1 2 3
    
    // 删除节点
    head = deleteNode(head, 2);
    cout << "删除2后的链表：";
    printList(head); // 输出 1 3
    
    // 释放链表内存
    freeList(head);
    head = nullptr;
    
    return 0;
}

用内存管理创建动态数组结构

动态数组是另一种常见的自定义数据结构，它可以在运行时根据需求调整容量，底层依赖动态内存分配实现空间的扩展和收缩。

动态数组的实现逻辑

动态数组需要维护三个核心属性：存储数据的指针、当前元素个数、数组总容量。当元素个数达到容量上限时，需要申请更大的内存空间，拷贝原有数据后释放旧内存。

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

class DynamicArray {
private:
    int* data;     // 指向堆区存储空间的指针
    int size;      // 当前元素个数
    int capacity;  // 数组总容量
    
    // 扩容函数，当容量不足时调用
    void resize(int newCapacity) {
        // 申请新的内存空间
        int* newData = new int[newCapacity];
        // 拷贝原有数据到新空间
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        // 释放旧内存
        delete[] data;
        data = newData;
        capacity = newCapacity;
    }
    
public:
    // 构造函数，初始化容量
    DynamicArray(int initCapacity = 4) : size(0), capacity(initCapacity) {
        data = new int[capacity];
    }
    
    // 析构函数，释放内存
    ~DynamicArray() {
        delete[] data;
        data = nullptr;
    }
    
    // 添加元素
    void pushBack(int val) {
        // 容量不足时扩容，这里扩容为原来的2倍
        if (size >= capacity) {
            resize(capacity * 2);
        }
        data[size] = val;
        size++;
    }
    
    // 获取指定位置的元素
    int get(int index) {
        if (index < 0 || index >= size) {
            throw "索引越界";
        }
        return data[index];
    }
    
    // 获取当前元素个数
    int getSize() {
        return size;
    }
    
    // 获取当前容量
    int getCapacity() {
        return capacity;
    }
};

int main() {
    DynamicArray arr;
    // 添加元素
    for (int i = 0; i < 10; i++) {
        arr.pushBack(i);
    }
    cout << "数组元素个数：" << arr.getSize() << endl;
    cout << "数组容量：" << arr.getCapacity() << endl;
    // 输出元素
    cout << "数组元素：";
    for (int i = 0; i < arr.getSize(); i++) {
        cout << arr.get(i) << " ";
    }
    cout << endl;
    return 0;
}

自定义数据结构内存管理的注意事项

在使用C++内存管理创建自定义数据结构时，需要注意以下几个常见问题：

• 申请内存后要及时判断是否申请成功，虽然new默认抛异常，但如果是使用new (nothrow)的方式申请，需要手动检查返回的指针是否为nullptr。
• 释放内存后要将对应的指针置为nullptr，避免产生野指针，后续误访问野指针会导致程序崩溃。
• 申请数组内存时使用new[]，释放时必须对应使用delete[]，如果混用会导致未定义行为。
• 如果自定义数据结构包含析构函数，要注意深拷贝和浅拷贝的问题，默认的拷贝构造函数只会拷贝指针值，导致两个对象的指针指向同一块内存，释放时会出现重复释放的问题。

总结

C++的内存管理是创建自定义数据结构的核心支撑，通过new和delete操作符可以灵活控制内存的分配和释放，适配链表、动态数组、树、图等不同结构的存储需求。在实际开发中，需要根据数据结构的特性合理设计内存管理逻辑，同时注意避免内存泄漏、野指针、重复释放等常见问题，必要时可以结合智能指针简化内存管理的工作，提升代码的稳定性和可维护性。

C++内存管理自定义数据结构new_delete动态内存分配修改时间：2026-07-03 14:42:39