一次测试测试(C++11)智能指针引用的崩溃结论

项目中用到了智能指针,但是要在智能指针指向的类中获取此类的shared_ptr指针传给其引用的类,结果出现了问题,

测试代码如下: (包括错误解释)

//测试 shared_ptr weak_ptr  map<string,shared_ptr>
#include <stdio.h> //pinrtf ...
#include <string>  //string ...
#include <map>
#include <memory>  //shared_ptr ...

class C;

class A {
public:
    A() { printf("A()
"); }
    ~A() { printf("~A()
"); }

    std::string a;
    std::weak_ptr<C> with;
    virtual std::string geta() = 0;
};

class A1:public A {
public:
    A1(std::string aa) { a = aa; printf("A1(%s)
",aa.c_str()); };
    ~A1() { printf("~A1(%s)
", a.c_str()); }

    std::string geta() { std::string b = "A1 " + a; return b; }
};

class A2:public A {
public:
    A2(std::string aa) { a = aa; printf("A2(%s)
", aa.c_str()); };
    ~A2() { printf("~A2()
"); printf("~A2(%s)
", a.c_str()); }

    std::string geta() { std::string b = "A2 " + a; return b; }
};

typedef std::shared_ptr<A> shrA;
typedef std::shared_ptr<A1> shrA1;
typedef std::shared_ptr<A2> shrA2;

template<class _ty>
class AA {
public:
    AA() { printf("AA()
"); }
    ~AA() { printf("~AA()
"); }

    typedef std::map<std::string, _ty> Atype;
    Atype list;
};


class C
{
public:
    C() { printf("C()
"); }
    ~C() { printf("~C()
"); }//在这个析构函数中下断点会发现进入两次的,两次析构
    shrA h1, h2;
    std::weak_ptr<A> a;

    void add(shrA h) { 
        if (h1 == nullptr) {
            h1 = h;
            //std::shared_ptr<C> p = (std::shared_ptr<C>)this;//此法虽然不会释放内存了,但是引用计数不对(此处是weak_ptr,但是shared_ptr计数也不对的)
            h->with = std::shared_ptr<C>(this); //这样写会在赋值的过程中产生一次创建临时对象(包括构造和析构,会释放掉this的内存)
                                                //因为以这种方式写的话,在这里是用this直接生成了shared_ptr,所以引用计数会变成1,导致在此次析构时释放掉内存
                                                //而导致外面的引用指针指向了被释放掉的内存,,,so,崩溃~~
        }
        else if(h2 == nullptr) {
            h2 = h;
            h->with = std::shared_ptr<C>(this);//同上
        }
        printf("C::add %s
",h->geta().c_str());
    }
};
typedef std::shared_ptr<C> shrC;

class CC
{
public :
    CC() { printf("CC()
"); }
    ~CC() { printf("~CC()
"); }

    typedef std::map<std::string, std::shared_ptr<C>> Ctype;
    Ctype list;
};

int main() {
    {
        AA<shrA1> aa1;
        AA<shrA2> aa2;

        CC cc;

        shrA1 a1 = shrA1(new A1("啊"));
        auto b = aa1.list.emplace(std::make_pair("a1", a1));

        shrA1 a11 = shrA1(new A1("啊啊"));
        b = aa1.list.emplace(std::make_pair("a1", a11));//key 重复,放置失败  (b.seond==false)

        shrA2 a2(new A2("份饭"));
        auto b2 = aa2.list.emplace(std::make_pair("a2", a2));

        printf("
-----  --------
");
        for (auto p : aa1.list)
            printf("%s
", p.second->geta().data());
        printf("
-----  --------
");
        shrC c(new C());
        cc.list.emplace("c1", c);
        //c->add(a11);  c->add  a1/a11/a2  都会导致崩溃
        c->add(a2);
    }
    return 0;
}

结论:

在赋值过程中,用形如

std::shared_ptr<C>(this)

的方式取得本指针的shared_ptr指针,会产生新的shared_ptr指针,,,而不是你想要的那个指针(类外定义的那个指针),

虽然其地址貌似是同样的(调试过程中看了下), 但是其实并不是同一个只能指针,

从其计数不一样就可以看出来,

同理, 其他类似的也是一样会构造出新的对象

但是即使是这样写

std::shared_ptr<C> p = (std::shared_ptr<C>)this;

强制类型转换过来的, 也是一个新的智能指针指针对象.

实际上 

std::shared_ptr<C>(this)

本身就是一个构造新对象的语句