C++内存管理工具primitives怎么用

在C++编程中，内存管理是一个非常重要的主题。C++提供了多种内存管理工具和原语（primitives），帮助开发者更高效地管理内存资源。本文将介绍C++中常用的内存管理工具和原语，并展示如何使用它们。

1. new 和 delete

new 和 delete 是C++中最基本的内存管理工具。new 用于动态分配内存，delete 用于释放内存。

1.1 使用 new 分配内存

int* p = new int;  // 分配一个int类型的内存
*p = 10;           // 给分配的内存赋值

1.2 使用 delete 释放内存

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

1.3 使用 new[] 和 delete[] 分配和释放数组

int* arr = new int[10];  // 分配一个包含10个int的数组
for (int i = 0; i < 10; ++i) {
    arr[i] = i;
}
delete[] arr;  // 释放数组内存
arr = nullptr;

2. malloc 和 free

malloc 和 free 是C语言中的内存管理函数，但在C++中也可以使用。它们与 new 和 delete 的主要区别在于 malloc 和 free 不会调用构造函数和析构函数。

2.1 使用 malloc 分配内存

int* p = (int*)malloc(sizeof(int));  // 分配一个int类型的内存
if (p != nullptr) {
    *p = 10;
}

2.2 使用 free 释放内存

free(p);  // 释放内存
p = nullptr;

3. std::unique_ptr

std::unique_ptr 是C++11引入的智能指针，用于自动管理动态分配的内存。std::unique_ptr 独占所指向的对象，确保同一时间只有一个 unique_ptr 指向该对象。

3.1 使用 std::unique_ptr

#include <memory>

std::unique_ptr<int> p = std::make_unique<int>(10);  // 创建一个unique_ptr
std::cout << *p << std::endl;  // 输出10

3.2 转移所有权

std::unique_ptr<int> p2 = std::move(p);  // 转移所有权
std::cout << *p2 << std::endl;  // 输出10

4. std::shared_ptr

std::shared_ptr 是另一种智能指针，允许多个 shared_ptr 共享同一个对象。当最后一个 shared_ptr 被销毁时，对象才会被释放。

4.1 使用 std::shared_ptr

#include <memory>

std::shared_ptr<int> p = std::make_shared<int>(10);  // 创建一个shared_ptr
std::shared_ptr<int> p2 = p;  // 共享所有权
std::cout << *p << std::endl;  // 输出10
std::cout << *p2 << std::endl;  // 输出10

4.2 查看引用计数

std::cout << p.use_count() << std::endl;  // 输出2，表示有两个shared_ptr共享该对象

5. std::weak_ptr

std::weak_ptr 是一种弱引用指针，用于解决 std::shared_ptr 的循环引用问题。weak_ptr 不会增加引用计数。

5.1 使用 std::weak_ptr

#include <memory>

std::shared_ptr<int> p = std::make_shared<int>(10);
std::weak_ptr<int> wp = p;  // 创建一个weak_ptr

if (auto sp = wp.lock()) {  // 尝试提升为shared_ptr
    std::cout << *sp << std::endl;  // 输出10
}

6. std::allocator

std::allocator 是C++标准库中的内存分配器，用于在容器中分配和释放内存。它提供了更灵活的内存管理方式。

6.1 使用 std::allocator

#include <memory>

std::allocator<int> alloc;
int* p = alloc.allocate(1);  // 分配一个int类型的内存
alloc.construct(p, 10);  // 构造对象
std::cout << *p << std::endl;  // 输出10
alloc.destroy(p);  // 销毁对象
alloc.deallocate(p, 1);  // 释放内存

7. 自定义内存管理

在某些情况下，开发者可能需要自定义内存管理策略。C++允许通过重载 new 和 delete 运算符来实现自定义内存管理。

7.1 重载 new 和 delete

void* operator new(std::size_t size) {
    std::cout << "Custom new: " << size << " bytes" << std::endl;
    return std::malloc(size);
}

void operator delete(void* ptr) noexcept {
    std::cout << "Custom delete" << std::endl;
    std::free(ptr);
}

int* p = new int(10);  // 输出: Custom new: 4 bytes
delete p;  // 输出: Custom delete

8. 总结

C++提供了多种内存管理工具和原语，开发者可以根据具体需求选择合适的方式。new 和 delete 是最基本的内存管理工具，而智能指针（如 std::unique_ptr 和 std::shared_ptr）则提供了更安全和便捷的内存管理方式。此外，std::allocator 和自定义内存管理策略也为开发者提供了更大的灵活性。

通过合理使用这些工具，开发者可以有效地管理内存，避免内存泄漏和悬空指针等问题，从而提高程序的稳定性和性能。