中山网站建设找阿 n 2万网域名续费

上一篇文章简单介绍了一下智能指针，这次我们简单讲解一下实现和具体的例子，及分析。

1. Unique_Ptr 实现

unique_ptr 是一种独占所有权的智能指针，不允许拷贝，只允许移动。它确保资源只被一个所有者拥有，并在所有者被销毁时自动释放资源。

实现：

// 默认删除器
struct DefaultDeleter {template <typename T>void operator()(T* ptr) const {delete ptr;}
};// UniquePtr 类模板
template <typename T, typename Deleter = DefaultDeleter>
class UniquePtr {
private:T* ptr;public:// 默认构造函数，初始化为 nullptrconstexpr UniquePtr()noexcept : ptr(nullptr) {}// 从指针构造explicit constexpr UniquePtr(T* p) noexcept : ptr(p) {}// 禁止拷贝构造UniquePtr(const UniquePtr& other) = delete;// 禁止拷贝赋值UniquePtr& operator=(const UniquePtr& other) = delete;// 移动构造函数constexpr UniquePtr(UniquePtr&& other) noexcept : ptr(other.ptr) {other.ptr = nullptr;}// 移动赋值运算符UniquePtr& operator=(UniquePtr&& other) noexcept {if (this != &other) {reset(other.ptr);other.ptr = nullptr;}return *this;}// 析构函数，释放资源~UniquePtr() {reset();}// 重置指针void reset(T* p = nullptr) {if (ptr != p) {Deleter()(ptr);ptr = p;}}// 释放所有权T* release() noexcept {T* ret = ptr;ptr = nullptr;return ret;}// 获取指针T* get() const noexcept {return ptr;}// 重载解引用运算符T& operator*() const {return *ptr;}// 重载箭头运算符T* operator->() const {return ptr;}// 转换为 boolexplicit operator bool() const noexcept {return ptr != nullptr;}// 禁止隐式转换为其他指针类型template <typename U>operator U*() const = delete;
};

使用例子：

int main() {UniquePtr<int> up1(new int(42));cout << "*up1 = " << *up1 << endl;UniquePtr<int> up2 = move(up1);if (!up1) {cout << "up1 is empty after move." <<endl;}cout << "*up2 = " << *up2 << endl;up2.reset();if (!up2) {cout << "up2 is empty after reset." << endl;}return 0;
}
//输出
*up1 = 42
up1 is empty after move.
*up2 = 42
up2 is empty after reset.

 

2. Shared_Ptr 实现

shared_ptr 是一种共享所有权的智能指针，使用引用计数来管理对象的生命周期。多个 shared_ptr 可以共享同一个对象，当最后一个 shared_ptr 被销毁时，资源被释放。

 

template <typename T>
class SharedPtr {
private:T* ptr;             // 原始指针size_t* count;      // 引用计数public:// 构造函数explicit SharedPtr(T* p = nullptr) : ptr(p), count(new size_t(1)) {if (p == nullptr) {*count = 0;}}// 拷贝构造函数SharedPtr(const SharedPtr<T>& other): ptr(other.ptr), count(other.count) {if (ptr) {(*count)++;}}// 析构函数~SharedPtr() {release();}// 拷贝赋值运算符SharedPtr<T>& operator=(const SharedPtr<T>& other) {if (this != &other) {release();ptr = other.ptr;count = other.count;if (ptr) {(*count)++;}}return *this;}// 解引用运算符T& operator*() const {return *ptr;}// 箭头运算符T* operator->() const {return ptr;}// 获取引用计数size_t use_count() const {return *count;}// 获取原始指针T* get() const {return ptr;}// 重置指针void reset(T* p = nullptr) {release();ptr = p;count = new size_t(1);if (p == nullptr) {*count = 0;}}private:// 释放资源void release() {if (ptr && --(*count) == 0) {delete ptr;delete count;ptr = nullptr;count = nullptr;}}
};

举例：

class MyClass {
public:MyClass(){ cout << "MyClass constructed\n";}~MyClass(){cout << "MyClass destroyed\n";}void print() 
{cout << "Hello from MyClass\n"; 
}
};int main() {// 创建shared_ptrSharedPtr<MyClass> ptr1(new MyClass());cout << "Use count: " << ptr1.use_count() << endl;  //输出1{// 拷贝构造SharedPtr<MyClass> ptr2 = ptr1;cout << "Use count: " << ptr1.use_count() << endl;  // 输出2ptr2->print();}cout << "Use count: " << ptr1.use_count() << endl;  // 输出1// 赋值操作SharedPtr<MyClass> ptr3;ptr3 = ptr1;cout << "Use count: " << ptr1.use_count() << endl;  //输出 2// 重置指针ptr1.reset(new MyClass());cout << "Use count: " << ptr1.use_count() << endl;  //输出 1return 0;
}

3. Weak_Ptr 实现

weak_ptr 是一种不拥有所有权的智能指针，用于配合 shared_ptr 使用，以解决循环引用问题。weak_ptr 不影响引用计数，但可以通过 lock() 方法获取一个 shared_ptr，以访问对象。

实现代码：

template <typename T>
class WeakPtr {
private:T* ptr;             // 指向被管理的对象size_t* shared_count;  // 指向 shared_ptr 的引用计数size_t* weak_count;    // 指向 weak_ptr 的引用计数public:// 默认构造函数WeakPtr() : ptr(nullptr), shared_count(nullptr), weak_count(nullptr) {}// 从 shared_ptr 构造WeakPtr(const SharedPtr<T>& shared) : ptr(shared.get()),shared_count(shared.get_count_ptr()),weak_count(new size_t(1)) {if (shared_count) {(*weak_count)++;}}// 拷贝构造函数WeakPtr(const WeakPtr<T>& other): ptr(other.ptr), shared_count(other.shared_count),weak_count(other.weak_count) {if (weak_count) {(*weak_count)++;}}// 析构函数~WeakPtr() {release();}// 拷贝赋值运算符WeakPtr<T>& operator=(const WeakPtr<T>& other) {if (this != &other) {release();ptr = other.ptr;shared_count = other.shared_count;weak_count = other.weak_count;if (weak_count) {(*weak_count)++;}}return *this;}// 从 shared_ptr 赋值WeakPtr<T>& operator=(const SharedPtr<T>& shared) {release();ptr = shared.get();shared_count = shared.get_count_ptr();weak_count = new size_t(1);if (shared_count) {(*weak_count)++;}return *this;}// 尝试提升为 shared_ptrSharedPtr<T> lock() const {if (expired()) {return SharedPtr<T>();}return SharedPtr<T>(*this);}// 检查是否过期bool expired() const {return shared_count == nullptr || *shared_count == 0;}// 获取引用计数信息size_t use_count() const {return shared_count ? *shared_count : 0;}private:// 释放资源void release() {if (weak_count && --(*weak_count) == 0) {if (shared_count && *shared_count == 0) {delete ptr;delete shared_count;}delete weak_count;}}
};

这里我们得修改shared_ptr用来支持weak_ptr

修改：

template <typename T>
class SharedPtr {// ... (之前的实现保持不变)// 新增方法，供 WeakPtr 访问size_t* get_count_ptr() const { return count; }// 新增构造函数，供 WeakPtr::lock() 使用SharedPtr(const WeakPtr<T>& weak) : ptr(weak.ptr), count(weak.shared_count) {if (count && *count > 0) {(*count)++;} else {ptr = nullptr;count = nullptr;}}
};

使用例子：

int main() {// 创建 shared_ptrSharedPtr<MyClass> shared(new MyClass());// 创建 weak_ptrWeakPtr<MyClass> weak = shared;// 使用 weak_ptrif (auto locked = weak.lock()) {locked->print();  // 安全使用:cout << "Use count: " << locked.use_count() << endl;}// 释放 shared_ptrshared.reset();// 检查 weak_ptr 是否过期if (weak.expired()) {cout << "Object has been deleted" << endl;}return 0;
}

实现就结束了，基本定义参考我上篇文章，如有错误还请评论区纠正。