C++ 智能指针

#include <memory>

int main() {
    // 使用 std::shared_ptr
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::shared_ptr<int> anotherSharedPtr = sharedPtr;

    // 使用 std::unique_ptr
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(42);
    
    return 0;
}

#include <memory>
#include <iostream>

// 函数参数为智能指针类型
void processObject(std::shared_ptr<int> ptr) {
    // 使用智能指针操作对象
    std::cout << "Object value: " << *ptr << std::endl;
}

// 函数返回智能指针类型
std::unique_ptr<int> createObject() {
    // 创建动态分配的对象，并返回智能指针
    return std::make_unique<int>(42);
}

int main() {
    // 使用智能指针作为函数参数
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    processObject(sharedPtr);

    // 使用智能指针作为函数返回值
    std::unique_ptr<int> uniquePtr = createObject();
    std::cout << "Object value: " << *uniquePtr << std::endl;

    return 0;
}

shared_ptr<Thing> sp(new Thing);
weak_ptr<Thing> wp1(sp); // construct wp1 from a shared_ptr
weak_ptr<Thing> wp2; // an empty weak_ptr - points to nothing
wp2 = sp; // wp2 now points to the new Thing
weak_ptr<Thing> wp3(wp2); // construct wp3 from a weak_ptr
weak_ptr<Thing> wp4
wp4 = wp2; // wp4 now points to the new Thing.

shared_ptr<Thing> sp2 = wp2.lock(); // get shared_ptr from weak_ptr

//第一种方法，通过 sp 和 lock，然后判断 sp 是否为空
void do_it(weak_ptr<Thing> wp){
    shared_ptr<Thing> sp = wp.lock(); // get shared_ptr from weak_ptr
    if(sp) {
        sp->defrangulate(); // tell the Thing to do something
    } else {
        cout << "The Thing is gone!" << endl;
    }
}

//第二种方法，利用 wp 的 expired 函数
bool is_it_there(weak_ptr<Thing> wp) {
    if(wp.expired()) {
        cout << "The Thing is gone!" << endl;
        return false;
    }
    return true;
}

//第三种方式，利用 wp 构造一个 sp，然后捕获异常
void do_it(weak_ptr<Thing> wp){
    shared_ptr<Thing> sp(wp); // construct shared_ptr from weak_ptr
    // exception thrown if wp is expired, so if here, sp is good to go
    sp->defrangulate(); // tell the Thing to do something
}
...

try {
    do_it(wpx);
} catch(bad_weak_ptr&) {
    cout << "A Thing (or something else) has disappeared!" << endl;
}

void Thing::foo()
{
    // we need to transmogrify this object
    shared_ptr<Thing> sp_for_this(this); // danger! a second manager object!
    transmogrify(sp_for_this);
}
//假设 Thing 对象本身就是用 sp 创建的，那么当其调用 foo 函数时，又将创建一个管理对象

class Thing : public enable_shared_from_this<Thing> {
public:
    void foo();
    void defrangulate();
};

void Thing::foo() {
    // we need to transmogrify this object
    // get a shared_ptr from the weak_ptr in this object
    shared_ptr<Thing> sp_this = shared_from_this();
    transmogrify(sp_this);
}

void transmogrify(shared_ptr<Thing> ptr) {
    ptr->defrangulate();
    /* etc. */
}

int main() {
    // The following starts a manager object for the Thing and also
    // initializes the weak_ptr member that is now part of the Thing.
    shared_ptr<Thing> t1(new Thing);
    t1->foo();
    ...
}

shared_ptr<Thing> p(new Thing);

shared_ptr<Thing> p(make_shared<Thing>()); // only one allocation!

shared_ptr<Base> bp(make_shared<Derived1>());

shared_ptr<Thing> p (make_shared<Thing>(42, "I'm a Thing!"));

#include <memory>

class B;  // 前向声明

class A {
public:
    std::shared_ptr<B> bPtr;

    ~A() {
        std::cout << "A destructor called" << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> aPtr;

    ~B() {
        std::cout << "B destructor called" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> aPtr = std::make_shared<A>();
    std::shared_ptr<B> bPtr = std::make_shared<B>();

    // 建立循环引用
    aPtr->bPtr = bPtr;
    bPtr->aPtr = aPtr;

    return 0;
}

//于是，只需要把上面的其中一个指针声明为weak_ptr即可
#include <iostream>
#include <memory>

class B;  //Forward declaration
class A {
public:
    std::shared_ptr<B> bPtr;
    ~A() {
        std::cout << "A destructor called" << std::endl;
    }
};

class B {
public:
    // std::shared_ptr<A> aPtr;
    std::weak_ptr<A> aPtr;  //use weak ptr to break the loop

    ~B() {
        std::cout << "B destructor called" << std::endl;
    }
};

int main() {
    while(1) {
        std::shared_ptr<A> aPtr = std::make_shared<A>();
        std::shared_ptr<B> bPtr = std::make_shared<B>();
        // make it loop
        aPtr->bPtr = bPtr;
        bPtr->aPtr = aPtr;
        std::cout << "in while loop..." << std::endl;
    } return 0;
}

unique_ptr<Thing> p1 (new Thing); // p1 owns the Thing
unique_ptr<Thing> p2(p1); // error - copy construction is not allowed.
unique_ptr<Thing> p3; // an empty unique_ptr;
p3 = p1; // error, copy assignment is not allowed

//create a Thing and return a unique_ptr to it:
unique_ptr<Thing> create_Thing() {
    unique_ptr<Thing> local_ptr(new Thing);
    return local_ptr; // local_ptr will surrender ownership
}

void foo() {
    unique_ptr<Thing> p1(create_Thing()); // move ctor from returned rvalue
    // p1 now owns the Thing
    unique_ptr<Thing> p2; // default ctor'd; owns nothing
    p2 = create_Thing(); // move assignment from returned rvalue
    // p2 now owns the second Thing
}

unique_ptr<Thing> p1(new Thing); // p1 owns the Thing
unique_ptr<Thing> p2; // p2 owns nothing
// invoke move assignment explicitly
p2 = std::move(p1); // now p2 owns it, p1 owns nothing
// invoke move construction explicitly
unique_ptr<Thing> p3(std::move(p2)); // now p3 owns it, p2 and p1 own nothing

#include <memory>
template <class T> class shared_ptr;

std::shared_ptr<int> p1;	//指向 int 类型的智能指针，此时不传入任何实参，为空指针
std::shared_ptr<int> p2(nullptr);	//传入空指针 nullptr
//空指针的引用计数为 0，此时并未指向任何内存，合情合理

std::shared_ptr<int> p3(new int(10));	//指向一个值为 3 的 int 型的内存
//此时引用计数为 1

//另外，也可以通过 C++11 提供的模板函数来初始化智能指针
std::shared_ptr<int> p4 = std::make_share<int>(10);

//拷贝构造函数
std::shared_ptr<int> p5(p4);
std::shared_ptr<int> p6 = p5;

//移动构造
std::shared_ptr<int> p7(std::move(p6));
std::shared_ptr<int> p8 = std::move(p7);

m_dds_ctx.reset(new minieye::DDS::Context(FLAGS_config_json_radar, true));
...
if (radar_topic != nullptr)
{
    std::shared_ptr<minieye::DDS::Reader> r(new minieye::DDS::Reader(
        m_dds_ctx.get(), radar_topic->topic, OnRecvDDS, this));

    m_readers = r;
}
...

std::shared_ptr<int> num{new int(5)};

template <class U, class D> shared_ptr(U* p, D del);
template <class D> shared_ptr(nullptr_t p, D del);
#其中 del 是一个删除器

// 使用 Lambda 表达式作为 deleter 的 std::shared_ptr
std::shared_ptr<MyClass> sharedPtr(new MyClass(24), [](MyClass* ptr) {
    std::cout << "Lambda deleter is called" << std::endl;
    delete ptr;
});

#include <iostream>
#include <memory>
using namespace std;

//Custom deleter function declaration
void my_deleter(int* ptr){
    cout << "Deleting integer pointer with value: " << *ptr << endl;
    delete ptr;
    cout << "Delete Successful.";
}


int main()
{
    //int type smart pointer object
    shared_ptr<int> ptr {new int{5}, my_deleter};
    return 0;
}

template< class Y >
explicit shared_ptr( Y* ptr );

template< class Y, class Deleter >
shared_ptr( Y* ptr, Deleter d );

int* rp = new int(5);

if(rp) {
    //...
}

std::shared_ptr<int> ptr = std::make_shared<int>(42);

if (ptr) {
    // 指针不为空
    // 执行代码...
} else {
    // 指针为空
    // 执行其他代码...
}

std::shared_ptr<int> ptr = std::make_shared<int>(42);

if (ptr.get() != nullptr) {
    // 指针不为空
    // 执行代码...
} else {
    // 指针为空
    // 执行其他代码...
}

class MyClass {
public:
    // 类型转换运算符的重载
    explicit operator bool() const {
        // 返回用于将对象转换为布尔值的逻辑表达式
        // 返回 true 表示对象非空，返回 false 表示对象为空
        return someCondition;  // 替换为实际的逻辑表达式
    }
};

class SmartPtr {
public:
    // 类型转换运算符的重载
    explicit operator bool() const {
        return ptr != nullptr;
    }

private:
    int* ptr;  // 以 int* 为例，实际上可能是其他类型
};

SmartPtr ptr = ...;  // 通过某种方式初始化
if (ptr) {
    // 智能指针不为空，执行代码...
} else {
    // 智能指针为空，执行其他代码...
}