1
std::unique_ptr<int> p1(new int(5));
2
// std::unique_ptr<int> p2 = p1; // 编译会出错
3
std::unique_ptr<int> p3 = std::move(p1); // 转移所有权, 现在那块内存归p3所有, p1成为无效的指针

1
#include <iostream>
2
// 为了演示目的，我们将添加一些日志来追踪函数调用
3
template <typename T>
4
class SmartPointer {
5
public:
6
    // 构造函数
7
    SmartPointer(T* p = nullptr) : _ptr(p), _reference_count(new size_t(1)) {
8
        std::cout << "构造函数被调用，SmartPointer(T* p=" << (p ? "valid ptr" : "nullptr") << ")" << std::endl;
9
        if(p) {
10
            std::cout << "  初始化引用计数为: " << *_reference_count << std::endl;
11
        }
12
    }
13
    // 拷贝构造函数
14
    SmartPointer(const SmartPointer<T>& other) : _ptr(other._ptr), _reference_count(other._reference_count) {
15
        std::cout << "拷贝构造函数被调用，SmartPointer(const SmartPointer& src)" << std::endl;
16
        if(_ptr) {
17
            (*_reference_count)++;
18
            std::cout << "  引用计数增加到: " << *_reference_count << std::endl;
19
        }
20
    }
21
    // 赋值操作符
22
    SmartPointer<T>& operator=(const SmartPointer<T>& other) {
23
        std::cout << "赋值操作符被调用，SmartPointer& operator=(const SmartPointer& src)" << std::endl;
24
        if (this != &other) {  // 防止自我赋值
25
            // 减少当前对象的引用计数，如果为0则删除资源
26
            if (_ptr && --(*_reference_count) == 0) {
27
                std::cout << "  释放旧资源，引用计数为0，删除内存" << std::endl;
28
                delete _ptr;
29
                delete _reference_count;
30
            } else if (_ptr) {
31
                std::cout << "  旧资源引用计数减少到: " << *_reference_count << std::endl;
32
            }
33

34
            // 获取新资源
35
            _ptr = other._ptr;
36
            _reference_count = other._reference_count;
37
            if(_ptr) {
38
                (*_reference_count)++;
39
                std::cout << "  新资源引用计数增加到: " << *_reference_count << std::endl;
40
            }
41
        } else {
42
            std::cout << "  自我赋值，直接返回" << std::endl;
43
        }
44
        return *this;
45
    }
46
    // 解引用操作符
47
    T& operator*() {
48
        std::cout << "operator*被调用，T& operator*()" << std::endl;
49
        if(_ptr) {
50
            return *_ptr;
51
        }
52
        throw std::runtime_error("Null pointer dereference");
53
    }
54
    // 箭头操作符
55
    T* operator->() {
56
        std::cout << "operator->被调用，T* operator->()" << std::endl;
57
        return _ptr;
58
    }
59
    // 析构函数
60
    ~SmartPointer() {
61
        std::cout << "析构函数被调用，~SmartPointer()" << std::endl;
62
        if (_ptr && --(*_reference_count) == 0) {
63
            std::cout << "  引用计数为0，删除资源和引用计数对象" << std::endl;
64
            delete _ptr;
65
            delete _reference_count;
66
        } else if (_ptr) {
67
            std::cout << "  引用计数减少到: " << *_reference_count << std::endl;
68
        }
69
    }
70
    // 获取引用计数
71
    size_t use_count() const {
72
        return _ptr ? *_reference_count : 0;
73
    }
74
private:
75
    T* _ptr;
76
    size_t* _reference_count;
77
};
78
int main() {
79
    std::cout << "主函数被调用，main function called" << std::endl;
80

81
    std::cout << "------SmartPointer<char> cp1(new char('a'))" << std::endl;
82
    SmartPointer<char> cp1(new char('a'));
83
    std::cout << "------SmartPointer<char> cp2(cp1)" << std::endl;
84
    SmartPointer<char> cp2(cp1);
85
    std::cout << "------SmartPointer<char> cp3" << std::endl;
86
    SmartPointer<char> cp3(nullptr);
87
    std::cout << "------cp3 = cp2" << std::endl;
88
    cp3 = cp2;
89
    std::cout << "------cp3 = cp1" << std::endl;
90
    cp3 = cp1;
91
    std::cout << "------cp3 = cp3" << std::endl;
92
    cp3 = cp3;
93
    std::cout << "------SmartPointer<char> cp4(new char('b'))" << std::endl;
94
    SmartPointer<char> cp4(new char('b'));
95
    std::cout << "------cp3 = cp4" << std::endl;
96
    cp3 = cp4;
97
    std::cout << "主函数结束，main function ending" << std::endl;
98
    return 0;
99
}