move02.pass.cpp revision 73d21a4f0774d3fadab98e690619a359cfb160a3
1//===----------------------------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10// <memory> 11 12// unique_ptr 13 14// Test unique_ptr move ctor 15 16#include <memory> 17#include <cassert> 18 19// test move ctor. Should only require a MoveConstructible deleter, or if 20// deleter is a reference, not even that. 21 22struct A 23{ 24 static int count; 25 A() {++count;} 26 A(const A&) {++count;} 27 ~A() {--count;} 28}; 29 30int A::count = 0; 31 32template <class T> 33class Deleter 34{ 35 int state_; 36 37#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 38 Deleter(const Deleter&); 39 Deleter& operator=(const Deleter&); 40#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 41 Deleter(Deleter&); 42 Deleter& operator=(Deleter&); 43#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 44 45public: 46#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 47 Deleter(Deleter&& r) : state_(r.state_) {r.state_ = 0;} 48 Deleter& operator=(Deleter&& r) 49 { 50 state_ = r.state_; 51 r.state_ = 0; 52 return *this; 53 } 54#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 55 operator std::__rv<Deleter>() {return std::__rv<Deleter>(*this);} 56 Deleter(std::__rv<Deleter> r) : state_(r->state_) {r->state_ = 0;} 57 Deleter& operator=(std::__rv<Deleter> r) 58 { 59 state_ = r->state_; 60 r->state_ = 0; 61 return *this; 62 } 63#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 64 65 Deleter() : state_(5) {} 66 67#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 68 template <class U> 69 Deleter(Deleter<U>&& d, 70 typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) 71 : state_(d.state()) {d.set_state(0);} 72 73private: 74 template <class U> 75 Deleter(const Deleter<U>& d, 76 typename std::enable_if<!std::is_same<U, T>::value>::type* = 0); 77#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 78 template <class U> 79 Deleter(Deleter<U> d, 80 typename std::enable_if<!std::is_same<U, T>::value>::type* = 0) 81 : state_(d.state()) {} 82#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 83public: 84 int state() const {return state_;} 85 void set_state(int i) {state_ = i;} 86 87 void operator()(T* p) {delete p;} 88}; 89 90class CDeleter 91{ 92 int state_; 93 94 CDeleter(CDeleter&); 95 CDeleter& operator=(CDeleter&); 96public: 97 98 CDeleter() : state_(5) {} 99 100 int state() const {return state_;} 101 void set_state(int s) {state_ = s;} 102 103 void operator()(A* p) {delete p;} 104}; 105 106std::unique_ptr<A> 107source1() 108{ 109 return std::unique_ptr<A>(new A); 110} 111 112void sink1(std::unique_ptr<A> p) 113{ 114} 115 116std::unique_ptr<A, Deleter<A> > 117source2() 118{ 119 return std::unique_ptr<A, Deleter<A> >(new A); 120} 121 122void sink2(std::unique_ptr<A, Deleter<A> > p) 123{ 124} 125 126std::unique_ptr<A, CDeleter&> 127source3() 128{ 129 static CDeleter d; 130 return std::unique_ptr<A, CDeleter&>(new A, d); 131} 132 133void sink3(std::unique_ptr<A, CDeleter&> p) 134{ 135} 136 137int main() 138{ 139 sink1(source1()); 140 sink2(source2()); 141 sink3(source3()); 142 assert(A::count == 0); 143} 144