1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <memory>
11 
12 // shared_ptr
13 
14 // template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
15 
16 #include <memory>
17 #include <type_traits>
18 #include <cassert>
19 
20 struct B
21 {
22     static int count;
23 
BB24     B() {++count;}
BB25     B(const B&) {++count;}
~BB26     virtual ~B() {--count;}
27 };
28 
29 int B::count = 0;
30 
31 struct A
32     : public B
33 {
34     static int count;
35 
AA36     A() {++count;}
AA37     A(const A&) {++count;}
~AA38     ~A() {--count;}
39 };
40 
41 int A::count = 0;
42 
main()43 int main()
44 {
45     {
46         std::unique_ptr<A> pA(new A);
47         A* ptrA = pA.get();
48         {
49             std::shared_ptr<B> pB(new B);
50             pB = std::move(pA);
51             assert(B::count == 1);
52             assert(A::count == 1);
53             assert(pB.use_count() == 1);
54             assert(pA.get() == 0);
55             assert(pB.get() == ptrA);
56         }
57         assert(B::count == 0);
58         assert(A::count == 0);
59     }
60     assert(B::count == 0);
61     assert(A::count == 0);
62     {
63         std::unique_ptr<A> pA;
64         A* ptrA = pA.get();
65         {
66             std::shared_ptr<B> pB(new B);
67             pB = std::move(pA);
68             assert(B::count == 0);
69             assert(A::count == 0);
70 //          assert(pB.use_count() == 1); // no longer true due to LWG 2415
71             assert(pA.get() == 0);
72             assert(pB.get() == ptrA);
73         }
74         assert(B::count == 0);
75         assert(A::count == 0);
76     }
77     assert(B::count == 0);
78     assert(A::count == 0);
79     {
80         std::unique_ptr<A> pA(new A);
81         A* ptrA = pA.get();
82         {
83             std::shared_ptr<B> pB;
84             pB = std::move(pA);
85             assert(B::count == 1);
86             assert(A::count == 1);
87             assert(pB.use_count() == 1);
88             assert(pA.get() == 0);
89             assert(pB.get() == ptrA);
90         }
91         assert(B::count == 0);
92         assert(A::count == 0);
93     }
94     assert(B::count == 0);
95     assert(A::count == 0);
96     {
97         std::unique_ptr<A> pA;
98         A* ptrA = pA.get();
99         {
100             std::shared_ptr<B> pB;
101             pB = std::move(pA);
102             assert(B::count == 0);
103             assert(A::count == 0);
104 //          assert(pB.use_count() == 1); // no longer true due to LWG 2415
105             assert(pA.get() == 0);
106             assert(pB.get() == ptrA);
107         }
108         assert(B::count == 0);
109         assert(A::count == 0);
110     }
111     assert(B::count == 0);
112     assert(A::count == 0);
113 }
114