C++智能指针《第一篇》

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

//循环引用问题
template <typename T>
class Node
{
public:
    Node(const T& value)
        :_pPre(NULL)
        , _pNext(NULL)
        ,_value(value)
    {
        std::cout << "Node()" << std::endl;
    }
    ~Node()
    {
        std::cout << "<~Node()" << std::endl;
        std::cout << "this" << this << std::endl;
    }
    std::shared_ptr<Node<T>>_pPre;
    std::shared_ptr<Node<T>>_pNext;
    T _value;
};
void Funtest()
{
    std::shared_ptr<Node<int>>sp1(new Node<int>(1));
    std::shared_ptr<Node<int>>sp2(new Node<int>(2));

    std::cout << "sp1.usr_count:" << sp1.use_count() << std::endl;
    std::cout << "sp2.use_count:" << sp2.use_count() << std::endl;

    sp1->_pNext = sp2;
    sp1->_pPre = sp1;

    std::cout << "sp1.user_count:" << sp1.use_count() << std::endl;
    std::cout << "sp2.user_count:" << sp2.use_count() << std::endl;
}
//----普通指针转智能执政问题
void func(std::shared_ptr<int>)
{
    ;
}
void test()
{
    int a = 5;
    auto p = new int(5);
    func(std::shared_ptr<int>(p));//error
    std::cout << *p << std::endl;
}
//-----普通向智能针转换error
void func1(std::shared_ptr<int>)
{
    ;
}
//----智能指针转普通指针
int test1()
{
    int a = 5;
    auto p = new int(5);
    func(std::shared_ptr<int>(p));
    std::cout << *p << std::endl;
    return 0;
}
//---智能指针指向栈区 error
void func2(std::shared_ptr<int>)
{
    ;
}
int test2()
{
    int a = 5;
    auto p = &a;
    func(std::shared_ptr<int>(p));
    std::cout << *p << std::endl;
    return 0;

    // Error! 内存已经被释放
    auto p1 = std::make_shared<int>(42);
    int* iPtr = p1.get();
    {
        std::shared_ptr<int>(iPtr);
    }
}

//总而言之，管理同一资源的 shared_ptr 只能由同一个初始化 shared_ptr 通过一系列赋值或者拷贝构造途径得来
//  释放两次
void funcn()
{

    std::shared_ptr<int> p1(new int(10));
    std::shared_ptr<int> p2(new int(10));

    std::cout << "p1 的引用计数: " << p1.use_count() << std::endl;
    std::cout << "p2 的引用计数: " << p2.use_count() << std::endl;
}

class Shared_ptrProblem
{
public:
    Shared_ptrProblem();
    ~Shared_ptrProblem();
};

//enable_shared_from_this
//当类对象被 shared_ptr 管理时，需要在类自己定义的函数里把当前类对象作为参数传给其他函数时，这时需要传递一个 shared_ptr ，否则就不能保持 shared_ptr 管理这个类对象的语义（因为有一个 raw pointer 指向这个类对象，而 shared_ptr 对类对象的这个引用没有计数，很有可能 shared_ptr 已经把类对象资源释放了，而那个调用函数还在使用类对象——显然，这肯定会产生错误）。
//class A1 {
//public:
//    std::shared_ptr<A1> getShared_ptr() {
//        return std::shared_ptr<A1>(this);
//    }
//};
//int main() {
//    std::shared_ptr<A1> pa = std::make_shared<A1>();
//    std::shared_ptr<A1> pbad = pa->getShared_ptr();
//    return 0;
//}
class A : public enable_shared_from_this<A> {
public:
    A()
    {
        cout << "constructor..." << endl;
    }
    ~A()
    {
        cout << "destructor..." << endl;
    }
};
int main()
{
    shared_ptr<A> pa = make_shared<A>();
    shared_ptr<A> pgood = pa->shared_from_this();
    return 0;
}