|
111
|
1 // { dg-do assemble }
|
|
|
2
|
|
|
3
|
|
|
4
|
|
|
5
|
|
|
6
|
|
|
7
|
|
|
8
|
|
|
9
|
|
|
10
|
|
|
11
|
|
|
12
|
|
|
13
|
|
|
14
|
|
|
15
|
|
|
16
|
|
|
17
|
|
|
18
|
|
|
19 class ref_counted
|
|
|
20 {
|
|
|
21
|
|
|
22 protected:
|
|
|
23 ref_counted( void ) : _count( 0 ) {}
|
|
|
24
|
|
|
25 public:
|
|
|
26
|
|
|
27 unsigned int add_ref( void ) { return ++_count; }
|
|
|
28 unsigned int release( void ) { return --_count; }
|
|
|
29 unsigned int count( void ) const { return _count; }
|
|
|
30
|
|
|
31
|
|
|
32 protected:
|
|
|
33 unsigned int _count;
|
|
|
34 };
|
|
|
35
|
|
|
36
|
|
|
37
|
|
|
38
|
|
|
39
|
|
|
40 template < class T >
|
|
|
41 class ref_ptr
|
|
|
42 {
|
|
|
43
|
|
|
44 public:
|
|
|
45 ref_ptr( T* ptr = 0 ) : _ptr( ptr )
|
|
|
46 {
|
|
|
47 add_ref();
|
|
|
48 }
|
|
|
49
|
|
|
50 ref_ptr( const ref_ptr & rptr ) : _ptr( rptr.get() )
|
|
|
51 {
|
|
|
52 add_ref();
|
|
|
53 }
|
|
|
54
|
|
|
55 ~ref_ptr( void ) { release(); }
|
|
|
56
|
|
|
57
|
|
|
58 T* get( void ) const { return _ptr; }
|
|
|
59 T* operator->( void ) const { return get(); }
|
|
|
60 T& operator*( void ) const { return *get(); }
|
|
|
61
|
|
|
62 bool operator!( void ) const { return get() == 0; }
|
|
|
63 bool operator==( const ref_ptr & rptr ) const { return *get() == *rptr;
|
|
|
64 }
|
|
|
65 bool operator<( const ref_ptr & rptr ) const { return *get() < *rptr; }
|
|
|
66
|
|
|
67
|
|
|
68 bool operator==( T* ptr ) const { return *get() == *ptr; }
|
|
|
69 bool operator<( T* ptr ) const { return *get() < *ptr; }
|
|
|
70
|
|
|
71 const ref_ptr & operator=( const ref_ptr & rptr )
|
|
|
72 {
|
|
|
73 release();
|
|
|
74 _ptr = rptr.get();
|
|
|
75 add_ref();
|
|
|
76
|
|
|
77 return *this;
|
|
|
78 }
|
|
|
79
|
|
|
80 T* operator=( T* ptr )
|
|
|
81 {
|
|
|
82 release();
|
|
|
83 _ptr = ptr;
|
|
|
84 add_ref();
|
|
|
85
|
|
|
86 return _ptr;
|
|
|
87 }
|
|
|
88
|
|
|
89 protected:
|
|
|
90 void add_ref( void )
|
|
|
91 {
|
|
|
92 if( _ptr )
|
|
|
93 _ptr->add_ref();
|
|
|
94 }
|
|
|
95
|
|
|
96 void release( void )
|
|
|
97 {
|
|
|
98 if( _ptr && 0 == _ptr->release() )
|
|
|
99 {
|
|
|
100 delete _ptr;
|
|
|
101 _ptr = 0;
|
|
|
102 }
|
|
|
103 }
|
|
|
104
|
|
|
105
|
|
|
106 protected:
|
|
|
107 T * _ptr;
|
|
|
108 };
|
|
|
109
|
|
|
110
|
|
|
111 template< class T >
|
|
|
112 bool operator==( T* ptr, const ref_ptr< T > & rptr )
|
|
|
113 {
|
|
|
114 return *ptr == *rptr;
|
|
|
115 }
|
|
|
116
|
|
|
117 template< class T >
|
|
|
118 bool operator<( T* ptr, const ref_ptr< T > & rptr )
|
|
|
119 {
|
|
|
120 return *ptr < *rptr;
|
|
|
121 }
|
|
|
122
|
|
|
123
|
|
|
124
|
|
|
125 class Baz : public ref_counted {
|
|
|
126 int dummy;
|
|
|
127 };
|
|
|
128
|
|
|
129
|
|
|
130 class Bar;
|
|
|
131
|
|
|
132 int main() {
|
|
|
133 ref_ptr<Baz> foo;
|
|
|
134 static_cast<Bar *> (foo)->DoSomething; //{ dg-error "" } invalid cast
|
|
|
135 }
|
