当前位置：首页 > wzjs >正文

uc投放广告网站要自己做吗网站报价

wzjs 2025/7/27 22:50:53

uc投放广告网站要自己做吗,网站报价,wordpress注册logo,江西建设信息港网站1. std::shared_ptr 1.1 定义与用法 std::shared_ptr 是一种共享所有权的智能指针，允许多个 shared_ptr 实例共享对同一个对象的所有权。通过引用计数机制，管理资源的生命周期。主要特性： 共享所有权：多个 shared_ptr 可以指…

1. `std::shared_ptr`

1.1 定义与用法

std::shared_ptr 是一种共享所有权的智能指针，允许多个 shared_ptr 实例共享对同一个对象的所有权。通过引用计数机制，管理资源的生命周期。

主要特性：

共享所有权：多个 shared_ptr 可以指向同一个对象。
引用计数：跟踪有多少 shared_ptr 实例指向同一对象。
自动释放：当引用计数为0时，自动释放资源。

1.2 引用计数与控制块

shared_ptr 背后依赖一个控制块（Control Block），用于存储引用计数和指向实际对象的指针。控制块的主要内容包括：

强引用计数
弱引用计数

1.3 构造函数与赋值

shared_ptr 提供多种构造函数和赋值操作，以支持不同的使用场景。

默认构造函数：创建一个空的 shared_ptr。
指针构造函数：接受一个裸指针，拥有其所有权。
拷贝构造函数：增加引用计数，共享对象所有权。
移动构造函数：转移所有权，源 shared_ptr 变为空。
拷贝赋值操作符：释放当前资源，增加引用计数，指向新对象。
移动赋值操作符：释放当前资源，转移所有权，源 shared_ptr 变为空。

1.4 代码案例

#include <iostream>
#include <memory>class Test
{
public:Test(int val) : value(val){std::cout << "Test(int val) " << std::endl;}Test(Test &&){std::cout << "Test moved\n";}~Test(){std::cout << "~Test() " << std::endl;}void show() const{std::cout << "Value: " << value << std::endl;}private:int value;
};int main()
{// shared_ptr<T>接受的是一个已经创建好的指针或者nullptrstd::shared_ptr<Test> ptr1(new Test(100)); // 不推荐Test *t1 = new Test(100);std::shared_ptr<Test> ptr2(t1); // 不推荐,原生指针和只能指针共同存在// std::shared_ptr<Test> ptr2_ = t1;  // 不推荐,这是隐式构造，而且shared_ptr也不支持 explicit shared_ptr( T* p) noexcept;Test t2(100);std::shared_ptr<Test> ptr3(&t2); // error,  shared_ptr 默认使用 delete 释放资源，但 t2 是栈上的对象，不能 delete，// 会导致 未定义行为（UB）（通常是程序崩溃）。std::shared_ptr<Test> ptr4(); // 实际上是一个函数声明，不是初始化！可以用std::shared_ptr<Test> ptr4{};std::shared_ptr<Test> ptr4_(nullptr);// make_unique<T>会调用T对应的构造函数std::shared_ptr<Test> ptr5 = std::make_shared<Test>(100); // 推荐!std::shared_ptr<Test> ptr5_ = ptr5; // 调用的是拷贝构造，会增加其引用计数std::cout << "ptr5 use_count: " << ptr5.use_count() << std::endl;/*调用的是shared_ptr里面的operator bool()函数：explicit operator bool() const noexcept{return get() != nullptr;}if (!ptr5) 等价于：if(!ptr5.operator bool())*/if (!ptr5){std::cout << "ptr5 is now nullptr" << std::endl;}ptr5.reset(new Test(300));  //释放detele原资源(如果引用计数为0，否则引用计数-1)、接管新资源，是替换资源最干净、安全的方式。ptr5.get()->show();   //借用原生指针ptr5.reset(); //调用 delete 销毁这个对象(如果引用计数为0，否则引用计数-1)，然后把内部的指针设为 nullptr，并不是销毁了ptr5return 0;
}

输出：

Test(int val) 
Test(int val)
Test(int val)
Test(int val)
ptr5 use_count: 2
Test(int val)
Value: 300
~Test()
~Test()
~Test()

SimpleSharedPtr 的完整实现及其使用示例。

#include <iostream>// 控制块结构
struct ControlBlock {int ref_count;ControlBlock() : ref_count(1) {}
};// 简化版的 shared_ptr 实现
template <typename T>
class SimpleSharedPtr {
private:T* ptr;                // 指向管理的对象ControlBlock* control; // 指向控制块// 释放当前资源void release() {if (control) {control->ref_count--;std::cout << "Decremented ref_count to " << control->ref_count << std::endl;if (control->ref_count == 0) {delete ptr;delete control;std::cout << "Resource and ControlBlock destroyed." << std::endl;}}ptr = nullptr;control = nullptr;}public:// 默认构造函数SimpleSharedPtr() : ptr(nullptr), control(nullptr) {std::cout << "Default constructed SimpleSharedPtr (nullptr)." << std::endl;}// 参数化构造函数explicit SimpleSharedPtr(T* p) : ptr(p) {if (p) {control = new ControlBlock();std::cout << "Constructed SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;} else {control = nullptr;}}// 拷贝构造函数SimpleSharedPtr(const SimpleSharedPtr& other) : ptr(other.ptr), control(other.control) {if (control) {control->ref_count++;std::cout << "Copied SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;}}// 拷贝赋值操作符SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {if (this != &other) {release();ptr = other.ptr;control = other.control;if (control) {control->ref_count++;std::cout << "Assigned SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;}}return *this;}// 移动构造函数SimpleSharedPtr(SimpleSharedPtr&& other) noexcept : ptr(other.ptr), control(other.control) {other.ptr = nullptr;other.control = nullptr;std::cout << "Moved SimpleSharedPtr." << std::endl;}// 移动赋值操作符SimpleSharedPtr& operator=(SimpleSharedPtr&& other) noexcept {if (this != &other) {release();ptr = other.ptr;control = other.control;other.ptr = nullptr;other.control = nullptr;std::cout << "Move-assigned SimpleSharedPtr." << std::endl;}return *this;}// 析构函数~SimpleSharedPtr() {release();}// 解引用操作符T& operator*() const {return *ptr;}// 箭头操作符T* operator->() const {return ptr;}// 获取引用计数int use_count() const {return control ? control->ref_count : 0;}// 获取裸指针T* get() const {return ptr;}// 重置指针void reset(T* p = nullptr) {release();ptr = p;if (p) {control = new ControlBlock();std::cout << "Reset SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;} else {control = nullptr;}}
};// 测试类
class Test {
public:Test(int val) : value(val) {std::cout << "Test Constructor: " << value << std::endl;}~Test() {std::cout << "Test Destructor: " << value << std::endl;}void show() const {std::cout << "Value: " << value << std::endl;}private:int value;
};int main() {std::cout << "Creating default constructed shared_ptr..." << std::endl;SimpleSharedPtr<Test> ptr1; // 默认构造std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "\nCreating shared_ptr with resource..." << std::endl;SimpleSharedPtr<Test> ptr2(new Test(100)); // 非默认构造std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;ptr2->show();std::cout << "\nCopying ptr2 to ptr3..." << std::endl;SimpleSharedPtr<Test> ptr3 = ptr2; // 拷贝构造std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;ptr3->show();std::cout << "\nAssigning ptr3 to ptr1..." << std::endl;ptr1 = ptr3; // 拷贝赋值std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;std::cout << "\nResetting ptr2..." << std::endl;ptr2.reset(new Test(200)); // 重新指向新的对象std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;ptr2->show();std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;std::cout << "\nExiting scope..." << std::endl;} // ptr2, ptr1, ptr3 离开作用域std::cout << "End of main." << std::endl;return 0;
}

1.5 enable_shared_from_this

它允许一个对象在 不自己持有自身的 shared_ptr 的情况下，获得一个指向自己的 shared_ptr 实例。

为什么不能直接用 `std::shared_ptr(this)`？

看这个反面例子：

class MyClass {
public:void doSomething() {std::shared_ptr<MyClass> ptr(this);  // ❌危险！会 double delete！}
};

这里你直接用 shared_ptr(this) 会产生一个新的 shared_ptr 实例，它并不知道有没有其他 shared_ptr 管理着这个对象。
如果你之前已经用 std::make_shared<MyClass>() 创建过一个，这里再来一次相当于有两个独立的 shared_ptr，它们都会尝试在析构时删除这个对象，就爆炸了（double free）。

正确做法：用 `enable_shared_from_this`

#include <memory>
#include <iostream>class MyClass : public std::enable_shared_from_this<MyClass> {
public:void doSomething() {std::shared_ptr<MyClass> ptr = shared_from_this(); // 安全！std::cout << "use_count: " << ptr.use_count() << std::endl;}
};int main() {std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();obj->doSomething(); // ✅ 没问题
}

当你继承了 enable_shared_from_this，并用 make_shared 构造对象时，enable_shared_from_this 内部会记录这个对象的 shared_ptr。
所以调用 shared_from_this() 就能安全地返回一个新的 shared_ptr 指向自己，而不是重新创建一个。

🧠 小总结：

用途	作用
`std::enable_shared_from_this<T>`	允许类内部通过 `shared_from_this()` 获取自身的 `shared_ptr`
解决问题	避免 `shared_ptr(this)` 导致的双重删除 / 崩溃
依赖前提	对象必须是由 `shared_ptr` 创建的，否则 `shared_from_this()` 会抛异常