在 C++ 中，动态内存管理是一个核心概念，它允许在运行时分配和释放内存。以下是 C++ 动态内存管理需要掌握的关键知识点：
new 和 delete 操作符在 C++ 中，new 和 delete 是用于动态内存分配和释放的基本操作符。
new 操作符new 用于在堆（也称为自由存储区）上动态分配内存，并返回指向新分配内存的指针。new 会调用对象的构造函数来初始化对象。
int* ptr = new int; // 分配一个 int 的内存
*ptr = 5; // 初始化该 int
new 还支持直接初始化：
int* ptr = new int(5); // 分配内存并初始化为 5
如果内存分配失败（例如由于内存不足），new 将抛出 std::bad_alloc 异常。
对于数组的分配，new 提供了特殊的语法：
int* array = new int[10]; // 分配一个包含 10 个整数的数组
delete 操作符delete 用于释放由 new 分配的内存，并调用对象的析构函数。
delete ptr; // 释放内存并调用析构函数
释放由 new 分配的数组需要使用 delete[]：
delete[] array; // 释放数组内存
new 分配的内存都应该使用对应的 delete 或 delete[] 来释放。nullptr。delete 会导致未定义行为。new[] 分配的内存必须用 delete[] 释放，用 new 分配的内存必须用 delete 释放。在现代 C++ 开发中，建议使用智能指针（如 std::unique_ptr 和 std::shared_ptr）来自动管理动态分配的内存，以避免手动管理内存的复杂性和风险。智能指针在其析构函数中自动释放它们所拥有的内存，从而帮助防止内存泄漏和其他常见的内存管理错误。
在 C++ 中，动态分配数组涉及使用 new 和 delete 操作符来在堆上分配和释放连续的内存块，用于存储数组。这种机制允许在运行时确定数组的大小，提供了比静态数组更大的灵活性。
new[] 分配数组new[] 用于动态分配一个元素数量已知的数组。
int* myArray = new int[10]; // 分配一个包含 10 个整数的数组
在这个例子中，new[] 分配了一个包含 10 个整数的数组，并返回一个指向数组第一个元素的指针。分配的数组在堆上，其生命周期直到使用 delete[] 显式释放为止。
使用 new[] 分配的数组默认进行值初始化。对于内置类型，如 int，这意味着数组元素被初始化为零。对于类类型的元素，将调用默认构造函数。
delete[] 释放数组使用 delete[] 来释放由 new[] 分配的数组内存。
delete[] myArray; // 释放数组内存
在这个例子中，delete[] 释放了之前分配的数组内存。如果数组元素是类对象，delete[] 还将调用每个对象的析构函数。
new[] 和 delete[]：用 new[] 分配的内存必须用 delete[] 释放。使用不匹配的 delete 形式会导致未定义行为。new[] 分配的数组都应该使用 delete[] 释放。nullptr。std::vector。在现代 C++ 中，推荐使用 std::vector 或其他标准容器来替代手动管理的动态数组。标准容器提供了更安全、更方便的方式来处理动态分配的数组，自动管理内存，并提供了许多额外的功能，如自动调整大小和元素访问的边界检查。
在 C++ 中，动态内存分配可能会失败，尤其是在内存资源紧张的情况下。处理内存分配失败是动态内存管理的一个重要方面，确保程序在内存不足时能够可靠地运行。
new 的内存分配失败当使用 new 进行内存分配时，如果系统无法满足分配请求，将抛出 std::bad_alloc 异常。这是 C++ 标准库中定义的一个异常类型，用来表示内存分配失败。
try {
int* myArray = new int[1000000000]; // 尝试分配大量内存
} catch (const std::bad_alloc& e) {
std::cerr << "Memory allocation failed: " << e.what() << std::endl;
// 处理内存分配失败的情况
}
在这个例子中，如果内存分配失败，程序会捕获 std::bad_alloc 异常，并通过 catch 块来处理这种情况。
new (nothrow) 和内存分配失败C++ 还提供了一种不抛出异常的内存分配方式，即 new (std::nothrow)。如果使用 new (std::nothrow) 进行内存分配，当内存分配失败时，它不会抛出异常，而是返回一个空指针。
#include <new> // 引入 std::nothrow
int* myArray = new(std::nothrow) int[1000000000];
if (myArray == nullptr) {
std::cerr << "Memory allocation failed." << std::endl;
// 处理内存分配失败的情况
}
在这个例子中，如果内存分配失败，则 myArray 会被设置为 nullptr，程序可以检查这一点并相应地处理。
new 或 new (nothrow) 调用的返回值，并在内存分配失败时进行适当处理。在 C++ 中，智能指针是用于自动管理动态分配的内存的对象。智能指针通过在其析构函数中释放关联的内存，帮助避免内存泄漏和指针错误。标准库提供了几种类型的智能指针，最常用的包括 std::unique_ptr、std::shared_ptr 和 std::weak_ptr。
std::unique_ptrstd::unique_ptr 是一个独占式智能指针，它拥有其指向的对象，并在 unique_ptr 对象销毁时自动删除关联的对象。
#include <memory>
std::unique_ptr<int> ptr(new int(10)); // 创建 unique_ptr
std::shared_ptrstd::shared_ptr 是一个共享式智能指针，它允许多个 shared_ptr 实例共享同一个对象。当最后一个拥有对象的 shared_ptr 被销毁时，对象被删除。
shared_ptr 数量。std::shared_ptr<int> shared1(new int(20));
std::shared_ptr<int> shared2 = shared1; // 共享所有权
std::weak_ptrstd::weak_ptr 是一种不拥有对象的智能指针，它被设计用来观察 std::shared_ptr，但不影响其引用计数。
shared_ptr 的引用计数。shared_ptr 相互引用导致的循环引用问题。shared_ptr 或另一个 weak_ptr 创建。std::shared_ptr<int> shared(new int(30));
std::weak_ptr<int> weak = shared; // 观察 shared_ptr
unique_ptr 适用于资源的独占管理。shared_ptr 适用于资源的共享管理，需要注意循环引用问题。weak_ptr 用于“安全观察” shared_ptr 所管理的资源，避免循环引用。智能指针在自动管理资源方面提供了极大的方便，是现代 C++ 中管理动态资源的首选方法。使用智能指针可以减少直接使用 new 和 delete 的需要，降低内存泄漏和其他内存错误的风险。
在 C++ 中，自定义内存管理是指开发者控制内存分配和释放的过程，而不完全依赖于标准的 new 和 delete 操作符或智能指针。这通常涉及到为特定类型的对象创建专用的内存池、使用自定义的分配器或实现特定的内存分配策略。
内存池是一种内存分配技术，预先分配一大块内存，并从中分配小块内存给对象使用。
自定义分配器允许开发者提供自定义的内存分配和释放逻辑。
自定义分配器需要实现分配器的接口，包括分配、释放内存和构造、析构对象的方法。
new 和 delete自定义内存管理有时也涉及重载类的 new 和 delete 操作符，以提供特定的内存分配和释放逻辑。
class MyClass {
public:
void* operator new(size_t size) {
// 自定义内存分配
}
void operator delete(void* pointer) {
// 自定义内存释放
}
};
自定义内存管理是一种高级技术，它可以提供性能优势和特殊需求的解决方案。然而，它也带来了额外的复杂性和潜在风险。在大多数情况下，推荐使用 C++ 标准库提供的内存管理工具，如智能指针和标准分配器，因为它们提供了更好的安全性和足够的灵活性。自定义内存管理应当谨慎使用，并且只在确实有明确的性能或行为需求时采用。
在 C++ 中，资源管理和异常安全是两个关键的概念，特别是在处理动态内存、文件句柄、网络连接等资源时。
资源管理涉及到获取和释放资源，如动态内存、文件句柄等。在 C++ 中，资源管理通常遵循 RAII（Resource Acquisition Is Initialization）原则。
RAII 是一种编程技术，用于确保资源的获取同时初始化对象（acquisition），资源的释放与对象的生命周期同步（destruction）。
std::unique_ptr 和 std::shared_ptr 在析构函数中自动释放所拥有的内存。std::fstream 和 std::lock_guard 在析构时释放资源。异常安全是指代码能够在面对异常时，安全地释放资源并保持程序状态的一致性。
class MyClass {
public:
MyClass() {
resource = new Resource();
}
~MyClass() {
delete resource; // 资源在析构时释放
}
private:
Resource* resource;
};
在上述示例中，即使在构造 MyClass 期间发生异常，资源也会在其析构函数中被安全释放。
资源管理和异常安全是 C++ 高效编程的关键。合理利用 RAII 原则和智能指针可以大大简化这些任务，提高程序的可靠性和维护性。
在 C++ 中，对象的动态创建和销毁涉及使用 new 和 delete 操作符以及它们的变体。除了标准的 new 和 delete，还有一些特殊的用法，允许开发者更精细地控制对象的生命周期和内存布局。
new（Placement new）定位 new 允许在已分配的内存上构造对象。这种方法常用于内存池、自定义分配器或避免额外的内存分配开销。
#include <new> // 必须包含头文件 <new>
char buffer[sizeof(MyClass)];
MyClass* myClassPtr = new (buffer) MyClass(); // 在 buffer 上构造对象
在这个示例中，MyClass 的对象被构造在预先分配的 buffer 上，而不是通过常规的 new 分配新内存。这种做法不会分配内存，但需要手动调用析构函数来销毁对象。
当对象通过定位 new 构造时，或者需要在对象的生命周期结束前显式销毁对象时，可以直接调用其析构函数。
myClassPtr->~MyClass(); // 显式调用析构函数
new 时，开发者需要负责相关内存的分配和释放。new 调用显式调用相应的析构函数。new 时要注意异常安全性，确保在构造发生异常时适当地处理已分配的内存。对象的动态创建和销毁是 C++ 中的高级特性，它们提供了对对象生命周期和内存布局的细粒度控制。这些技术在需要优化性能、管理复杂资源或实现自定义内存管理策略时非常有用。然而，它们也增加了代码的复杂性和出错的可能性，因此应谨慎使用。在大多数情况下，推荐使用标准的内存管理工具和技术，如 RAII、智能指针和标准容器。