类设计思想：参考C++11的智能指针，设计一个自定义的智能指针类，需要考虑哪些元素和因素？

最新推荐文章于 2024-06-20 21:23:57 发布

斗笔丶学徒

最新推荐文章于 2024-06-20 21:23:57 发布

阅读量58

点赞数 1

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/qq_35142086/article/details/131815364

版权

设计一个自定义的智能指针类，需要考虑以下元素和因素：

计数器（Reference Counter）：用于跟踪指向资源的引用数。每当有新的智能指针指向资源时，计数器增加；当智能指针析构或不再使用资源时，计数器减少。当计数器为零时，表示资源不再被引用，可以安全地释放。

资源指针（Resource Pointer）：指向被智能指针管理的资源的原始指针。自定义智能指针需要持有该资源指针，并提供对资源的访问。

构造函数和析构函数：自定义智能指针应该有构造函数来接受原始指针，并将其初始化为自己的资源指针。析构函数应该在引用计数为零时释放资源。

拷贝构造函数和赋值运算符重载：为了正确地管理资源的引用计数，自定义智能指针需要实现拷贝构造函数和赋值运算符重载。它们应该递增目标资源的引用计数，并递减旧资源的引用计数。

解引用操作符重载：为了方便访问资源，自定义智能指针应该重载解引用操作符，以允许像使用原始指针一样访问资源。

重载布尔运算符：自定义智能指针可以通过重载布尔运算符，使得在条件语句中以智能指针的形式进行判断更加方便。

下面是一个示例实现：

template <typename T>
class MySmartPointer {
private:
    T* resource;
    int* refCount;

public:
    // 构造函数
    explicit MySmartPointer(T* ptr) : resource(ptr), refCount(new int(1)) {}

    // 拷贝构造函数
    MySmartPointer(const MySmartPointer& other) : resource(other.resource), refCount(other.refCount) {
        ++(*refCount);
    }

    // 赋值运算符重载
    MySmartPointer& operator=(const MySmartPointer& other) {
        if (this != &other) {
            if (--(*refCount) == 0) {
                delete resource;
                delete refCount;
            }
            resource = other.resource;
            refCount = other.refCount;
            ++(*refCount);
        }
        return *this;
    }

    // 析构函数
    ~MySmartPointer() {
        if (--(*refCount) == 0) {
            delete resource;
            delete refCount;
        }
    }

    // 解引用操作符重载
    T& operator*() const {
        return *resource;
    }

    // 成员访问操作符重载
    T* operator->() const {
        return resource;
    }

    // 布尔运算符重载
    operator bool() const {
        return resource != nullptr;
    }
};

 实际应用场景：多线程中使用智能指针：
在多线程环境中使用智能指针时，需要注意以下几点：

**原子操作：**确保对智能指针的引用计数进行原子操作。这是为了避免竞态条件（race condition）导致计数不正确，从而出现资源释放错误或内存泄漏的问题。

**互斥锁：**在对引用计数进行修改的地方使用互斥锁来保护共享资源。这样可以确保在一个线程修改引用计数期间其他线程无法同时访问和修改它。

**线程安全：**考虑到并发访问资源的情况，确保资源本身的线程安全性。如果资源可能被多个线程同时访问和修改，需要在访问资源时采取适当的同步措施，例如使用互斥锁、读写锁等。

下面是一个简单示例，演示如何在多线程环境中使用自定义智能指针：

#include <iostream>
#include <thread>
#include <mutex>

template <typename T>
class MySmartPointer {
private:
    T* resource;
    std::atomic<int>* refCount;
    std::mutex mtx;

public:
    explicit MySmartPointer(T* ptr) : resource(ptr), refCount(new std::atomic<int>(1)) {}

    MySmartPointer(const MySmartPointer& other) : resource(other.resource), refCount(other.refCount) {
        (*refCount)++;
    }

    MySmartPointer& operator=(const MySmartPointer& other) {
        if (this != &other) {
            std::lock_guard<std::mutex> lock(mtx);
            (*refCount)--;
            if (*refCount == 0) {
                delete resource;
                delete refCount;
            }
            resource = other.resource;
            refCount = other.refCount;
            (*refCount)++;
        }
        return *this;
    }

    ~MySmartPointer() {
        std::lock_guard<std::mutex> lock(mtx);
        (*refCount)--;
        if (*refCount == 0) {
            delete resource;
            delete refCount;
        }
    }

    T& operator*() const {
        return *resource;
    }
};

void worker(MySmartPointer<int> ptr) {
    // 使用智能指针访问资源
    std::cout << *ptr << std::endl;
}

int main() {
    // 创建 MySmartPointer 对象并传入动态分配的整型资源
    MySmartPointer<int> ptr(new int(42));

    // 创建两个线程，每个线程都使用智能指针访问资源
    std::thread t1(worker, ptr);
    std::thread t2(worker, ptr);

    t1.join();
    t2.join();

    return 0;
}