内存管理是C++编程中的一个重要主题，涉及如何有效地分配和释放内存，以避免内存泄漏、悬空指针和其他内存相关的问题。以下是关于智能指针和自定义内存分配器的详细讨论。
1. 智能指针
智能指针是C++标准库提供的一种机制，用于自动管理动态分配的内存。它们通过 RAII（资源获取即初始化）原则确保在对象生命周期结束时自动释放内存，从而减少内存泄漏和悬空指针的风险。
1.1 std::unique_ptr
-
定义：
std::unique_ptr是一种独占所有权的智能指针，确保同一时间只有一个unique_ptr指向某个对象。 -
特性：
- 独占所有权：不能复制，只能移动。使用
std::move可以将所有权转移给另一个unique_ptr。 - 自动释放：当
unique_ptr超出作用域时，自动调用delete释放内存。 - 自定义删除器：可以指定自定义删除器，以支持不同的内存管理策略。
- 独占所有权：不能复制，只能移动。使用
-
示例：
#include <iostream> #include <memory> void example() { std::unique_ptr<int> ptr1(new int(10)); // 创建一个 unique_ptr std::cout << *ptr1 << std::endl; // 输出 10 std::unique_ptr<int> ptr2 = std::move(ptr1); // 转移所有权 // std::cout << *ptr1 << std::endl; // 错误，ptr1 现在为空 if (ptr1 == nullptr) { std::cout << "ptr1 is null" << std::endl; } }
1.2 std::shared_ptr
-
定义：
std::shared_ptr是一种共享所有权的智能指针，允许多个shared_ptr指向同一个对象。 -
特性：
- 引用计数：每个
shared_ptr都维护一个引用计数，当引用计数为零时，自动释放内存。 - 线程安全：引用计数的增加和减少是线程安全的。
- 循环引用问题：需要注意避免循环引用，通常使用
std::weak_ptr来解决。
- 引用计数：每个
-
示例：
#include <iostream> #include <memory> void example() { std::shared_ptr<int> ptr1(new int(20)); // 创建一个 shared_ptr { std::shared_ptr<int> ptr2 = ptr1; // 共享所有权 std::cout << *ptr2 << std::endl; // 输出 20 std::cout << ptr1.use_count() << std::endl; // 输出 2 } // ptr2 超出作用域，引用计数减少 std::cout << ptr1.use_count() << std::endl; // 输出 1 }
1.3 std::weak_ptr
-
定义：
std::weak_ptr是一种不拥有对象的智能指针，主要用于解决shared_ptr的循环引用问题。 -
特性：
- 不增加引用计数：
weak_ptr不会影响对象的生命周期。 - 检查有效性：可以通过
lock()方法获取一个shared_ptr，如果对象已被释放，则返回一个空的shared_ptr。
- 不增加引用计数：
-
示例：
#include <iostream> #include <memory> void example() { std::shared_ptr<int> sharedPtr = std::make_shared<int>(30); std::weak_ptr<int> weakPtr = sharedPtr; // 创建 weak_ptr std::cout << "Use count: " << sharedPtr.use_count() << std::endl; // 输出 1 if (auto lockedPtr = weakPtr.lock()) { // 尝试获取 shared_ptr std::cout << *lockedPtr << std::endl; // 输出 30 } sharedPtr.reset(); // 释放内存 if (weakPtr.lock() == nullptr) { std::cout << "The object has been deleted." << std::endl; } }
2. 自定义内存分配器
C++允许开发者自定义内存分配器，以优化特定场景下的内存分配和释放。这在性能敏感的应用程序中尤其重要，例如游戏开发、实时系统和高性能计算。
2.1 自定义分配器的基本结构
自定义内存分配器通常需要实现以下几个方法：
allocate(size_t n)：分配n个对象的内存。deallocate(T* p, size_t n)：释放之前分配的内存。construct(T* p, Args&&... args)：在分配的内存上构造对象。destroy(T* p)：销毁对象并释放资源。
2.2 示例
以下是一个简单的自定义分配器示例：
#include <iostream>
#include <memory>
#include <limits>
template <typename T>
class CustomAllocator {
public:
using value_type = T;
CustomAllocator() = default;
template <typename U>
CustomAllocator(const CustomAllocator<U>&) {}
T* allocate(std::size_t n) {
if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
throw std::bad_alloc();
}
if (auto p = static_cast<T*>(::operator new(n * sizeof(T)))) {
return p;
}
throw std::bad_alloc();
}
void deallocate(T* p, std::size_t) {
::operator delete(p);
}
};
int main() {
std::allocator_traits<CustomAllocator<int>>::rebind_alloc<int> alloc;
int* p = alloc.allocate(1);
alloc.construct(p, 42);
std::cout << *p << std::endl; // 输出 42
alloc.destroy(p);
alloc.deallocate(p, 1);
return 0;
}
3. 总结
智能指针和自定义内存分配器是C++内存管理的重要工具。智能指针通过自动管理内存，减少了内存泄漏和悬空指针的风险，而自定义内存分配器则允许开发者根据特定需求优化内存分配和释放策略。通过合理使用这些工具，开发者可以编写出更安全、高效的C++代码。
std::unique_ptr 的底层代码实现
std::unique_ptr 是 C++ 标准库中的一种智能指针，它的实现涉及到模板、移动语义和自定义删除器等特性。虽然具体的实现可能因编译器和标准库的不同而有所差异，但我们可以概述一个简化的 std::unique_ptr 的底层实现。
以下是一个简化版的 std::unique_ptr 的实现示例，展示了其基本结构和功能：
#include <iostream>
#include <utility> // for std::move
template <typename T>
class UniquePtr {
public:
// 构造函数
explicit UniquePtr(T* ptr = nullptr) : ptr_(ptr) {}
// 移动构造函数
UniquePtr(UniquePtr&& other) noexcept : ptr_(other.ptr_) {
other.ptr_ = nullptr; // 转移所有权
}
// 移动赋值运算符
UniquePtr& operator=(UniquePtr&& other) noexcept {
if (this != &other) {
delete ptr_; // 释放当前持有的资源
ptr_ = other.ptr_; // 转移所有权
other.ptr_ = nullptr; // 置空其他的指针
}
return *this;
}
// 禁用复制构造函数和复制赋值运算符
UniquePtr(const UniquePtr&) = delete;
UniquePtr& operator=(const UniquePtr&) = delete;
// 析构函数
~UniquePtr() {
delete ptr_; // 释放资源
}
// 解引用运算符
T& operator*() const {
return *ptr_;
}
// 成员访问运算符
T* operator->() const {
return ptr_;
}
// 获取原始指针
T* get() const {
return ptr_;
}
// 释放管理的资源
void reset(T* ptr = nullptr) {
delete ptr_; // 释放当前资源
ptr_ = ptr; // 重新管理新的资源
}
// 释放所有权并返回原始指针
T* release() {
T* temp = ptr_;
ptr_ = nullptr; // 置空指针
return temp; // 返回原始指针
}
private:
T* ptr_; // 原始指针
};
// 示例使用
int main() {
UniquePtr<int> uptr(new int(42)); // 创建 UniquePtr
std::cout << *uptr << std::endl; // 输出 42
UniquePtr<int> uptr2 = std::move(uptr); // 移动所有权
if (uptr.get() == nullptr) {
std::cout << "uptr is now null." << std::endl; // uptr 现在为空
}
std::cout << *uptr2 << std::endl; // 输出 42
return 0; // uptr2 超出作用域时，自动释放内存
}
代码解析
- 构造函数：接受一个原始指针并将其存储在
ptr_中。 - 移动构造函数：通过移动语义转移所有权，将
other的指针赋值给当前对象，并将other的指针置为nullptr。 - 移动赋值运算符：首先检查自赋值，然后释放当前持有的资源，接着转移所有权并置空
other的指针。 - 禁用复制：通过将复制构造函数和复制赋值运算符标记为
delete，禁止复制。 - 析构函数：在对象生命周期结束时释放管理的资源。
- 解引用和成员访问运算符：提供对管理对象的访问。
get方法：返回原始指针。reset方法：释放当前资源并重新管理新的资源。release方法：释放所有权并返回原始指针。
总结
这个简化的 std::unique_ptr 实现展示了其基本的内存管理功能。实际的 std::unique_ptr 实现可能会更加复杂，包含更多的特性和优化，例如支持自定义删除器、线程安全等。但这个示例足以帮助理解 std::unique_ptr 的基本工作原理和设计思想。
std::shared_ptr的底层代码实现
std::shared_ptr是 C++11 引入的智能指针，用于管理动态分配的内存，允许多个shared_ptr实例共享同一资源。它通过引用计数机制来管理资源的生命周期，确保在最后一个指向该资源的shared_ptr` 被销毁时，资源会被释放。
以下是一个简化版的 std::shared_ptr 的实现示例，展示了其基本结构和功能。请注意，实际的 std::shared_ptr 实现可能会更加复杂，包含线程安全、异常安全等特性。
简化版 std::shared_ptr 实现
#include <iostream>
#include <utility> // for std::move
template <typename T>
class SharedPtr {
public:
// 默认构造函数
SharedPtr() : ptr_(nullptr), ref_count_(nullptr) {}
// 构造函数
explicit SharedPtr(T* ptr) : ptr_(ptr), ref_count_(new size_t(1)) {}
// 拷贝构造函数
SharedPtr(const SharedPtr& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) {
if (ref_count_) {
++(*ref_count_); // 增加引用计数
}
}
// 移动构造函数
SharedPtr(SharedPtr&& other) noexcept : ptr_(other.ptr_), ref_count_(other.ref_count_) {
other.ptr_ = nullptr; // 置空其他的指针
other.ref_count_ = nullptr; // 置空引用计数
}
// 拷贝赋值运算符
SharedPtr& operator=(const SharedPtr& other) {
if (this != &other) {
release(); // 释放当前资源
ptr_ = other.ptr_;
ref_count_ = other.ref_count_;
if (ref_count_) {
++(*ref_count_); // 增加引用计数
}
}
return *this;
}
// 移动赋值运算符
SharedPtr& operator=(SharedPtr&& other) noexcept {
if (this != &other) {
release(); // 释放当前资源
ptr_ = other.ptr_;
ref_count_ = other.ref_count_;
other.ptr_ = nullptr; // 置空其他的指针
other.ref_count_ = nullptr; // 置空引用计数
}
return *this;
}
// 析构函数
~SharedPtr() {
release(); // 释放资源
}
// 解引用运算符
T& operator*() const {
return *ptr_;
}
// 成员访问运算符
T* operator->() const {
return ptr_;
}
// 获取原始指针
T* get() const {
return ptr_;
}
// 返回当前引用计数
size_t use_count() const {
return ref_count_ ? *ref_count_ : 0;
}
private:
T* ptr_; // 原始指针
size_t* ref_count_; // 引用计数
// 释放资源
void release() {
if (ref_count_ && --(*ref_count_) == 0) {
delete ptr_; // 释放内存
delete ref_count_; // 释放引用计数
}
}
};
// 示例使用
int main() {
{
SharedPtr<int> sp1(new int(42)); // 创建 SharedPtr
std::cout << "Value: " << *sp1 << ", Count: " << sp1.use_count() << std::endl; // 输出 42, Count: 1
{
SharedPtr<int> sp2 = sp1; // 拷贝构造，引用计数增加
std::cout << "Value: " << *sp2 << ", Count: " << sp1.use_count() << std::endl; // 输出 42, Count: 2
} // sp2 超出作用域，引用计数减少
std::cout << "Count after sp2 goes out of scope: " << sp1.use_count() << std::endl; // 输出 Count: 1
} // sp1 超出作用域，内存被释放
return 0;
}
代码解析
-
构造函数：
- 默认构造函数初始化指针和引用计数为
nullptr。 - 带参数的构造函数接受一个原始指针，并初始化引用计数为 1。
- 默认构造函数初始化指针和引用计数为
-
拷贝构造函数：
- 复制另一个
SharedPtr的指针和引用计数，并增加引用计数。
- 复制另一个
-
移动构造函数：
- 转移指针和引用计数的所有权，并将源对象的指针和引用计数置为
nullptr。
- 转移指针和引用计数的所有权，并将源对象的指针和引用计数置为
-
拷贝赋值运算符：
- 释放当前资源，复制另一个
SharedPtr的指针和引用计数，并增加引用计数。
- 释放当前资源，复制另一个
-
移动赋值运算符：
- 释放当前资源，转移指针和引用计数的所有权，并将源对象的指针和引用计数置为
nullptr。
- 释放当前资源，转移指针和引用计数的所有权，并将源对象的指针和引用计数置为
-
析构函数：
- 调用
release方法，减少引用计数并在必要时释放内存。
- 调用
-
release方法：- 减少引用计数，如果引用计数为 0，则释放管理的内存和引用计数本身。
-
解引用和成员访问运算符：提供对管理对象的访问。
-
use_count方法：返回当前的引用计数。
总结
这个简化的 std::shared_ptr 实现展示了其基本的内存管理功能。实际的 std::shared_ptr 实现可能会更加复杂，包含线程安全、异常安全、循环引用检测等特性。但这个示例足以帮助理解 std::shared_ptr 的基本工作原理和设计思想。
std::weak_ptr的底层代码实现
std::weak_ptr 是 C++11 引入的智能指针，用于解决 std::shared_ptr 中的循环引用问题。std::weak_ptr 允许访问由 std::shared_ptr 管理的对象，但不增加引用计数。这意味着 std::weak_ptr 不会阻止所管理对象的销毁。
std::weak_ptr 的基本原理
-
引用计数：
std::shared_ptr使用引用计数来管理资源的生命周期。当最后一个std::shared_ptr被销毁时，资源会被释放。std::weak_ptr维护一个指向同一资源的弱引用，但不增加引用计数。 -
过期检查：
std::weak_ptr提供了方法来检查所管理的对象是否仍然存在（即是否被std::shared_ptr管理）。如果对象已经被销毁，std::weak_ptr将不再有效。 -
锁定：
std::weak_ptr提供了lock()方法，可以将其转换为std::shared_ptr。如果所管理的对象仍然存在，lock()返回一个有效的std::shared_ptr；如果对象已经被销毁，返回的std::shared_ptr将是空的。
简化版 std::weak_ptr 实现
以下是一个简化版的 std::weak_ptr 的实现示例，展示了其基本结构和功能。请注意，实际的 std::weak_ptr 实现可能会更加复杂，包含线程安全、异常安全等特性。
#include <iostream>
#include <utility> // for std::move
template <typename T>
class SharedPtr; // 前向声明
template <typename T>
class WeakPtr;
template <typename T>
class ControlBlock {
public:
ControlBlock() : shared_count_(1), weak_count_(0) {}
void add_shared() {
++shared_count_;
}
void add_weak() {
++weak_count_;
}
void release_shared() {
if (--shared_count_ == 0) {
delete static_cast<T*>(ptr_);
if (weak_count_ == 0) {
delete this; // 删除控制块
}
}
}
void release_weak() {
if (--weak_count_ == 0 && shared_count_ == 0) {
delete this; // 删除控制块
}
}
T* ptr_; // 管理的对象
size_t shared_count_; // 引用计数
size_t weak_count_; // 弱引用计数
};
template <typename T>
class SharedPtr {
public:
explicit SharedPtr(T* ptr = nullptr) : control_block_(new ControlBlock<T>()) {
control_block_->ptr_ = ptr;
}
SharedPtr(const SharedPtr& other) : control_block_(other.control_block_) {
control_block_->add_shared();
}
SharedPtr& operator=(const SharedPtr& other) {
if (this != &other) {
release(); // 释放当前资源
control_block_ = other.control_block_;
control_block_->add_shared();
}
return *this;
}
~SharedPtr() {
release();
}
T& operator*() const {
return *control_block_->ptr_;
}
T* get() const {
return control_block_->ptr_;
}
private:
void release() {
if (control_block_) {
control_block_->release_shared();
}
}
ControlBlock<T>* control_block_; // 控制块
};
template <typename T>
class WeakPtr {
public:
WeakPtr() : control_block_(nullptr) {}
WeakPtr(const SharedPtr<T>& shared) : control_block_(shared.control_block_) {
if (control_block_) {
control_block_->add_weak();
}
}
WeakPtr(const WeakPtr& other) : control_block_(other.control_block_) {
if (control_block_) {
control_block_->add_weak();
}
}
WeakPtr& operator=(const WeakPtr& other) {
if (this != &other) {
release(); // 释放当前资源
control_block_ = other.control_block_;
if (control_block_) {
control_block_->add_weak();
}
}
return *this;
}
~WeakPtr() {
release();
}
SharedPtr<T> lock() const {
if (control_block_ && control_block_->shared_count_ > 0) {
return SharedPtr<T>(*this); // 返回一个有效的 SharedPtr
}
return SharedPtr<T>(); // 返回空的 SharedPtr
}
private:
void release() {
if (control_block_) {
control_block_->release_weak();
}
}
ControlBlock<T>* control_block_; // 控制块
};
// 示例使用
int main() {
{
SharedPtr<int> sp(new int(42)); // 创建 SharedPtr
WeakPtr<int> wp(sp); // 创建 WeakPtr
if (auto sp2 = wp.lock()) { // 尝试锁定
std::cout << "Value: " << *sp2 << std::endl; // 输出 42
} else {
std::cout << "Resource has been released." << std::endl;
}
} // sp 超出作用域，内存被释放
{
WeakPtr<int> wp; // 创建空的 WeakPtr
if (auto sp2 = wp.lock()) {
std::cout << "Value: " << *sp2 << std::endl;
} else {
std::cout << "Resource has been released." << std::endl; // 输出资源已被释放
}
}
return 0;
}
代码解析
-
控制块 (
ControlBlock)：ControlBlock类用于管理shared_ptr和weak_ptr的引用计数。它包含一个指向管理对象的指针、共享计数和弱计数。
-
SharedPtr类：SharedPtr类负责管理资源的生命周期。它在构造时创建一个控制块，并在析构时减少共享计数。
-
WeakPtr类：WeakPtr类持有对控制块的指针，但不增加共享计数。它提供了lock()方法来尝试获取一个有效的SharedPtr。
-
lock()方法：lock()方法检查控制块的共享计数。如果大于 0，则返回一个有效的SharedPtr；否则返回一个空的SharedPtr。
-
资源管理：
- 当最后一个
SharedPtr被销毁时，控制块会释放管理的对象。如果没有WeakPtr仍在使用，控制块本身也会被释放。
- 当最后一个
总结
这个简化的 std::weak_ptr 实现展示了其基本的内存管理功能。实际的 std::weak_ptr 实现可能会更加复杂，包含线程安全、异常安全、循环引用检测等特性。但这个示例足以帮助理解 std::weak_ptr 的基本工作原理和设计思想。
自定义内存分配器
自定义内存分配器在 C++ 中可以用于优化内存管理，特别是在特定场景下，比如游戏开发、实时系统或高性能计算中。通过自定义内存分配器，开发者可以控制内存的分配和释放策略，以提高性能或减少内存碎片。
以下是一个简单的自定义内存分配器的示例，展示了如何实现一个基本的内存池（Memory Pool）。内存池是一种预先分配一块内存并在其中管理小块内存的技术。
简单的内存池实现
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <vector>
class MemoryPool {
public:
MemoryPool(size_t blockSize, size_t blockCount)
: blockSize_(blockSize), blockCount_(blockCount), freeBlocks_(blockCount) {
// 分配内存池
pool_ = std::malloc(blockSize_ * blockCount_);
assert(pool_ != nullptr);
// 初始化空闲块链表
for (size_t i = 0; i < blockCount_; ++i) {
freeBlocks_[i] = static_cast<char*>(pool_) + i * blockSize_;
}
}
~MemoryPool() {
std::free(pool_);
}
void* allocate() {
if (freeCount_ == 0) {
throw std::bad_alloc();
}
// 从空闲块中取出一个块
void* block = freeBlocks_[--freeCount_];
return block;
}
void deallocate(void* ptr) {
// 将释放的块放回空闲链表
if (ptr >= pool_ && ptr < static_cast<char*>(pool_) + blockSize_ * blockCount_) {
freeBlocks_[freeCount_++] = ptr;
} else {
throw std::invalid_argument("Pointer not from this memory pool");
}
}
private:
size_t blockSize_;
size_t blockCount_;
void* pool_;
size_t freeCount_ = 0;
std::vector<void*> freeBlocks_;
};
// 示例使用
int main() {
const size_t blockSize = 32; // 每个块的大小
const size_t blockCount = 10; // 块的数量
MemoryPool pool(blockSize, blockCount);
// 分配内存
void* ptr1 = pool.allocate();
void* ptr2 = pool.allocate();
std::cout << "Allocated memory at: " << ptr1 << std::endl;
std::cout << "Allocated memory at: " << ptr2 << std::endl;
// 释放内存
pool.deallocate(ptr1);
pool.deallocate(ptr2);
std::cout << "Memory deallocated." << std::endl;
return 0;
}
代码解析
-
MemoryPool 类：
MemoryPool类负责管理内存池的创建、分配和释放。- 构造函数接受每个块的大小和块的数量，并分配一块连续的内存。
-
allocate() 方法：
allocate()方法从空闲块中取出一个块并返回其指针。如果没有可用的块，则抛出std::bad_alloc异常。
-
deallocate() 方法：
deallocate()方法将释放的块放回空闲链表中。如果传入的指针不在内存池的范围内，则抛出std::invalid_argument异常。
-
示例使用：
- 在
main()函数中，创建一个MemoryPool实例，分配和释放内存块，并输出分配的内存地址。
- 在
注意事项
- 内存对齐：在实际应用中，可能需要考虑内存对齐，以确保分配的内存满足特定类型的对齐要求。
- 线程安全：如果在多线程环境中使用自定义内存分配器，可能需要添加锁或其他同步机制以确保线程安全。
- 性能优化：可以根据具体需求进一步优化内存池的实现，例如使用更复杂的空闲块管理策略、合并相邻的空闲块等。
总结
自定义内存分配器可以帮助开发者更好地控制内存管理，减少内存碎片，提高性能。上述示例展示了一个简单的内存池实现，适合用于学习和理解自定义内存分配的基本原理。在实际应用中，可以根据具体需求进行扩展和优化。
扫一扫
6739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
