【重学C++】02 脱离指针陷阱：深入浅出 C++ 智能指针

void foo(int n) {
    int* ptr = new int(42);
    ...
    if (n > 5) {
	    return;
    }
    ...
    delete ptr;
}


void other_fn(int* ptr) {
	...
};
void bar() {
    int* ptr = new int(42);
    other_fn(ptr);
    // ptr == ?
}

#include <memory>
#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructed" << std::endl;
    }

    ~MyClass() {
        std::cout << "MyClass destroyed" << std::endl;
    }
};
int main() {
	std::unique_ptr<MyClass> ptr1(new MyClass);
	// C++14开始支持std::make_unique
    std::unique_ptr<int> ptr2 = std::make_unique<int>(10);
    return 0;
}

MyClass constructed
MyClass destroyed

MyClass* naked_ptr = ptr1.get();
std::cout << *ptr2 << std::endl; // 输出 10

template<class T> 
void unique_ptr<T>::reset(pointer ptr = pointer()) noexcept { 
	// 释放指针指向的对象
	delete ptr_; 
	// 重置指针
	ptr_ = ptr;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructed" << std::endl;
    }

    ~MyClass() {
        std::cout << "MyClass destroyed" << std::endl;
    }
};

int main() {
    // 创建一个 std::unique_ptr 对象，指向一个 MyClass 对象
    std::unique_ptr<MyClass> ptr(new MyClass);

    // 调用 reset，将 std::unique_ptr 重置为管理另一个 MyClass 对象
    ptr.reset(new MyClass);
    return;
}

#include <memory>
int main() {
    std::unique_ptr<int> p1 = std::make_unique<int>(42);
    std::unique_ptr<int> p2 = p1; // 编译报错
    return 0;
}

#include <memory>
#include <iostream>
int main() {
    std::unique_ptr<int> p1 = std::make_unique<int>(42);
    std::unique_ptr<int> p2 = std::move(p1); // ok
    std::cout << *p2 << std::endl; // 42
    std::cout << (p1.get() == nullptr) << std::endl; // true
    return 0;
}

#include <memory>
int main() {
	std::shared_ptr<int> p1(new int(10));
	std::shared_ptr<int> p2 = std::make_shared<int>(20);
	return;
}

std::shared_ptr<int>p3 = p2;

std::cout << "p1 use count: " << p1.use_count() << std::endl;

void reset(T* ptr = nullptr) {
	if (ref_count != nullptr) { 
		(*ref_count)--;
		if (*ref_count == 0) { 
			delete data; 
			delete ref_count; 
		} 
	} 
	data = ptr; 
	ref_count = (data == nullptr) ? nullptr : new size_t(1); 
}

struct Node { 
	std::shared_ptr<Node> next; 
};

int main() {
	std::shared_ptr<Node> node1(new Node);
	std::shared_ptr<Node> node2(new Node); 
	node1->next = node2; 
	node2->next = node1;
}

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sp = std::make_shared<int>(42);
    // 创建shared_ptr对应的weak_ptr指针
    std::weak_ptr<int> wp(sp);

	// 通过lock创建一个对应的shared_ptr
    if (auto p = wp.lock()) {
        std::cout << "shared_ptr value: " << *p << std::endl;
        std::cout << "shared_ptr use_count: " << p.use_count() << std::endl;
    } else {
        std::cout << "wp is expired" << std::endl;
    }

	// 释放shared_ptr指向的资源，此时weak_ptr失效
    sp.reset();
    std::cout << "wp is expired: " <<  wp.expired() << std::endl;
    return 0;
}

shared_ptr value: 42
shared_ptr use_count: 2
wp is expired: 1

```cpp
struct Node { 
	std::weak_ptr<Node> next; 
};

int main() {
	std::shared_ptr<Node> node1(new Node);
	std::shared_ptr<Node> node2(new Node); 
	node1->next = std::weak_ptr<Node>(node2); 
	node2->next = std::weak_ptr<Node>(node1); ;
}

int* q = new int(9);
{
	std::shared_ptr<int> p(new int(10));
	...
	q = p.get();
}
std::cout << *q << std::endl;

int* p = new int(10);
std::shared_ptr<int> ptr1(p);
// error: 两个shared_ptr指向同一个资源，会导致重复释放
std::shared_ptr<int> ptr2(p);