/
shared_ptr.h
1559 lines (1324 loc) · 44.4 KB
/
shared_ptr.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// shared_ptr and weak_ptr implementation -*- C++ -*-
// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
// shared_count.hpp
// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
// shared_ptr.hpp
// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// weak_ptr.hpp
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// enable_shared_from_this.hpp
// Copyright (C) 2002 Peter Dimov
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// GCC Note: based on version 1.32.0 of the Boost library.
/** @file bits/shared_ptr.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#ifndef _SHARED_PTR_H
#define _SHARED_PTR_H 1
#ifndef __GXX_EXPERIMENTAL_CXX0X__
#include <c++0x_warning.h>
#endif
#if defined(_GLIBCXX_INCLUDE_AS_TR1)
#error C++0x header cannot be included from TR1 header
#endif
_GLIBCXX_BEGIN_NAMESPACE(std)
/**
* @addtogroup pointer_abstractions
* @{
*/
// counted ptr with no deleter or allocator support
template <typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr : public _Sp_counted_base<_Lp> // 智能指针引用计数管理器
{
public:
_Sp_counted_ptr(_Ptr __p) : _M_ptr(__p)
{
}
virtual void _M_dispose() // nothrow
{
delete _M_ptr;
}
virtual void _M_destroy() // nothrow
{
delete this;
}
virtual void *_M_get_deleter(const std::type_info &__ti)
{
return 0;
}
_Sp_counted_ptr(const _Sp_counted_ptr &) = delete;
_Sp_counted_ptr &operator=(const _Sp_counted_ptr &) = delete;
protected:
_Ptr _M_ptr; // copy constructor must not throw //资源指针
};
// support for custom deleter and/or allocator
template <typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter : public _Sp_counted_ptr<_Ptr, _Lp> // 支持自定义构造和析构
{
typedef typename _Alloc::template rebind<_Sp_counted_deleter>::other _My_alloc_type;
// Helper class that stores the Deleter and also acts as an allocator.
// Used to dispose of the owned pointer and the internal refcount
// Requires that copies of _Alloc can free each other's memory.
struct _My_Deleter : public _My_alloc_type // copy constructor must not throw
{
_Deleter _M_del; // copy constructor must not throw //销毁器成员
_My_Deleter(_Deleter __d, const _Alloc &__a) : _My_alloc_type(__a), _M_del(__d)
{
}
};
protected:
typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type;
public:
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_deleter(_Ptr __p, _Deleter __d) : _Base_type(__p), _M_del(__d, _Alloc())
{
}
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc &__a) : _Base_type(__p), _M_del(__d, __a)
{
}
virtual void _M_dispose() // nothrow
{
_M_del._M_del(_Base_type::_M_ptr);
}
virtual void _M_destroy() // nothrow
{
_My_alloc_type __a(_M_del);
this->~_Sp_counted_deleter();
__a.deallocate(this, 1);
}
virtual void *_M_get_deleter(const std::type_info &__ti)
{
return __ti == typeid(_Deleter) ? &_M_del._M_del : 0;
}
protected:
_My_Deleter _M_del; // copy constructor must not throw //自定义删除器
};
// helpers for make_shared / allocate_shared
template <typename _Tp>
struct _Sp_destroy_inplace // 智能指针删除器
{
void operator()(_Tp *__p) const
{
if (__p)
__p->~_Tp();
}
};
struct _Sp_make_shared_tag // make_shared标签
{
};
template <typename _Tp, typename _Alloc, _Lock_policy _Lp> // 连续内存存放数据的智能指针引用计数器
class _Sp_counted_ptr_inplace : public _Sp_counted_deleter<_Tp *, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
{
typedef _Sp_counted_deleter<_Tp *, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp> _Base_type;
public:
_Sp_counted_ptr_inplace(_Alloc __a) : _Base_type(static_cast<_Tp *>(0), _Sp_destroy_inplace<_Tp>(), __a), _M_storage()
{
void *__p = &_M_storage;
::new (__p) _Tp(); // might throw
_Base_type::_Base_type::_M_ptr = static_cast<_Tp *>(__p);
}
template <typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args &&...__args) : _Base_type(static_cast<_Tp *>(0), _Sp_destroy_inplace<_Tp>(), __a), _M_storage()
{
void *__p = &_M_storage;
::new (__p) _Tp(std::forward<_Args>(__args)...); // might throw
_Base_type::_Base_type::_M_ptr = static_cast<_Tp *>(__p);
}
// override because the allocator needs to know the dynamic type
virtual void _M_destroy() // nothrow
{
typedef typename _Alloc::template rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type;
_My_alloc_type __a(_Base_type::_M_del);
this->~_Sp_counted_ptr_inplace();
__a.deallocate(this, 1);
}
// sneaky trick so __shared_ptr can get the managed pointer
virtual void *_M_get_deleter(const std::type_info &__ti)
{
return __ti == typeid(_Sp_make_shared_tag) ? static_cast<void *>(&_M_storage) : _Base_type::_M_get_deleter(__ti);
}
private:
typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type _M_storage; // 数据作为内部数据成员 和基类_Sp_counted_ptr的其它成员在内存上连续
};
template <_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template <_Lock_policy _Lp = __default_lock_policy>
class __shared_count // 共享引用计数器
{
public:
__shared_count() : _M_pi(0) // nothrow
{
}
template <typename _Ptr>
__shared_count(_Ptr __p) /*通过资源裸指针构造*/ : _M_pi(0)
{
__try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); // 分配计数器
}
__catch(...)
{
delete __p;
__throw_exception_again;
}
}
template <typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
{
// allocator's value_type doesn't matter, will rebind it anyway
typedef std::allocator<int> _Alloc;
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
typedef std::allocator<_Sp_cd_type> _Alloc2;
_Alloc2 __a2;
__try
{
_M_pi = __a2.allocate(1);
::new (static_cast<void *>(_M_pi)) _Sp_cd_type(__p, __d);
}
__catch(...)
{
__d(__p); // Call _Deleter on __p.
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cd_type *>(_M_pi), 1);
__throw_exception_again;
}
}
template <typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2;
_Alloc2 __a2(__a);
__try
{
_M_pi = __a2.allocate(1);
::new (static_cast<void *>(_M_pi)) _Sp_cd_type(__p, __d, __a);
}
__catch(...)
{
__d(__p); // Call _Deleter on __p.
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cd_type *>(_M_pi), 1);
__throw_exception_again;
}
}
template <typename _Tp, typename _Alloc, typename... _Args> // make_shared使用
__shared_count(_Sp_make_shared_tag, _Tp *, _Alloc __a, _Args &&...__args) : _M_pi(0)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2;
_Alloc2 __a2(__a);
__try
{
_M_pi = __a2.allocate(1);
::new (static_cast<void *>(_M_pi)) _Sp_cp_type(__a, std::forward<_Args>(__args)...);
}
__catch(...)
{
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cp_type *>(_M_pi), 1);
__throw_exception_again;
}
}
#if _GLIBCXX_DEPRECATED
// Special case for auto_ptr<_Tp> to provide the strong guarantee.
template <typename _Tp>
explicit __shared_count(std::auto_ptr<_Tp> &&__r) : _M_pi(new _Sp_counted_ptr<_Tp *, _Lp>(__r.get()))
{
__r.release();
}
#endif
// Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
template <typename _Tp, typename _Del>
explicit __shared_count(std::unique_ptr<_Tp, _Del> &&__r) : _M_pi(_S_create_from_up(std::move(__r)))
{
__r.release();
}
// Throw bad_weak_ptr when __r._M_get_use_count() == 0.
explicit __shared_count(const __weak_count<_Lp> &__r);
~__shared_count() // nothrow
{
if (_M_pi != 0)
_M_pi->_M_release();
}
__shared_count(const __shared_count &__r) : _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
// 左值赋值
__shared_count &operator=(const __shared_count &__r) // nothrow
{
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy(); // 右操作数++
if (_M_pi != 0)
_M_pi->_M_release(); // 左操作数--
_M_pi = __tmp;
}
return *this;
}
// 左值交换
void _M_swap(__shared_count &__r) // nothrow
{
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long _M_get_use_count() const // nothrow
{
return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0;
}
bool _M_unique() const // nothrow
{
return this->_M_get_use_count() == 1;
}
void *_M_get_deleter(const std::type_info &__ti) const
{
return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0;
}
bool _M_less(const __shared_count &__rhs) const
{
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
bool _M_less(const __weak_count<_Lp> &__rhs) const
{
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
// friend function injected into enclosing namespace and found by ADL
friend inline bool operator==(const __shared_count &__a, const __shared_count &__b)
{
return __a._M_pi == __b._M_pi;
}
private:
friend class __weak_count<_Lp>;
template <typename _Tp, typename _Del>
static _Sp_counted_base<_Lp> *_S_create_from_up(std::unique_ptr<_Tp, _Del> &&__r, typename std::enable_if<!std::is_reference<_Del>::value>::type * = 0)
{
return new _Sp_counted_deleter<_Tp *, _Del, std::allocator<_Tp>, _Lp>(__r.get(), __r.get_deleter());
}
template <typename _Tp, typename _Del>
static _Sp_counted_base<_Lp> *_S_create_from_up(std::unique_ptr<_Tp, _Del> &&__r, typename std::enable_if<std::is_reference<_Del>::value>::type * = 0)
{
typedef typename std::remove_reference<_Del>::type _Del1;
typedef std::reference_wrapper<_Del1> _Del2;
return new _Sp_counted_deleter<_Tp *, _Del2, std::allocator<_Tp>, _Lp>(__r.get(), std::ref(__r.get_deleter()));
}
_Sp_counted_base<_Lp> *_M_pi; // 指向控制块
};
template <_Lock_policy _Lp>
class __weak_count
{
public:
__weak_count() : _M_pi(0) // nothrow
{
}
__weak_count(const __shared_count<_Lp> &__r) : _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
__weak_count(const __weak_count<_Lp> &__r) : _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
~__weak_count() // nothrow
{
if (_M_pi != 0)
_M_pi->_M_weak_release();
}
__weak_count<_Lp> &operator=(const __shared_count<_Lp> &__r) // nothrow
{
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
__weak_count<_Lp> &operator=(const __weak_count<_Lp> &__r) // nothrow
{
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
void _M_swap(__weak_count<_Lp> &__r) // nothrow
{
_Sp_counted_base<_Lp> *__tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long _M_get_use_count() const // nothrow
{
return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0;
}
bool _M_less(const __weak_count &__rhs) const
{
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
bool _M_less(const __shared_count<_Lp> &__rhs) const
{
return std::less<_Sp_counted_base<_Lp> *>()(this->_M_pi, __rhs._M_pi);
}
// friend function injected into enclosing namespace and found by ADL
friend inline bool operator==(const __weak_count &__a, const __weak_count &__b)
{
return __a._M_pi == __b._M_pi;
}
private:
friend class __shared_count<_Lp>;
_Sp_counted_base<_Lp> *_M_pi; // 计数控制块
};
// now that __weak_count is defined we can define this constructor:
template <_Lock_policy _Lp> // 从weak_ptr创建
inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp> &__r) : _M_pi(__r._M_pi) // 拷贝计数控制块
{
if (_M_pi != 0)
_M_pi->_M_add_ref_lock(); // 增加共享引用计数
else
__throw_bad_weak_ptr();
}
// Forward declarations.
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __shared_ptr;
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __weak_ptr;
template <typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __enable_shared_from_this;
template <typename _Tp>
class shared_ptr;
template <typename _Tp>
class weak_ptr;
template <typename _Tp>
class enable_shared_from_this;
// Support for enable_shared_from_this.
// Friend of __enable_shared_from_this.
template <_Lock_policy _Lp, typename _Tp1, typename _Tp2>
void __enable_shared_from_this_helper(const __shared_count<_Lp> &, const __enable_shared_from_this<_Tp1, _Lp> *, const _Tp2 *);
// Friend of enable_shared_from_this.
template <typename _Tp1, typename _Tp2>
void __enable_shared_from_this_helper(const __shared_count<> &, const enable_shared_from_this<_Tp1> *, const _Tp2 *);
template <_Lock_policy _Lp>
inline void __enable_shared_from_this_helper(const __shared_count<_Lp> &, ...)
{
}
template <typename _Tp, _Lock_policy _Lp>
class __shared_ptr
{
public:
typedef _Tp element_type;
/** @brief Construct an empty %__shared_ptr.
* @post use_count()==0 && get()==0
*/
__shared_ptr() : _M_ptr(0), _M_refcount() // never throws
{
}
/** @brief Construct a %__shared_ptr that owns the pointer @a __p.
* @param __p A pointer that is convertible to element_type*.
* @post use_count() == 1 && get() == __p
* @throw std::bad_alloc, in which case @c delete @a __p is called.
*/
template <typename _Tp1>
explicit __shared_ptr(_Tp1 *__p) /*通过资源裸指针构造*/ : _M_ptr(__p) /*保存资源裸指针*/, _M_refcount(__p) /*构造引用计数器*/
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
// __glibcxx_function_requires(_CompleteConcept<_Tp1*>)
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
//
// Requirements: _Deleter's copy constructor and destructor must
// not throw
//
// __shared_ptr will release __p by calling __d(__p)
//
/** @brief Construct a %__shared_ptr that owns the pointer @a __p
* and the deleter @a __d.
* @param __p A pointer.
* @param __d A deleter.
* @post use_count() == 1 && get() == __p
* @throw std::bad_alloc, in which case @a __d(__p) is called.
*/
template <typename _Tp1, typename _Deleter>
__shared_ptr(_Tp1 *__p, _Deleter __d) : _M_ptr(__p), _M_refcount(__p, __d)
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
// TODO requires _Deleter CopyConstructible and __d(__p) well-formed
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
//
// Requirements: _Deleter's copy constructor and destructor must
// not throw _Alloc's copy constructor and destructor must not
// throw.
//
// __shared_ptr will release __p by calling __d(__p)
//
/** @brief Construct a %__shared_ptr that owns the pointer @a __p
* and the deleter @a __d.
* @param __p A pointer.
* @param __d A deleter.
* @param __a An allocator.
* @post use_count() == 1 && get() == __p
* @throw std::bad_alloc, in which case @a __d(__p) is called.
*/
template <typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1 *__p, _Deleter __d, const _Alloc &__a) : _M_ptr(__p), _M_refcount(__p, __d, __a)
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
// TODO requires _Deleter CopyConstructible and __d(__p) well-formed
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
/** @brief Constructs a %__shared_ptr instance that stores @a __p
* and shares ownership with @a __r.
* @param __r A %__shared_ptr.
* @param __p A pointer that will remain valid while @a *__r is valid.
* @post get() == __p && use_count() == __r.use_count()
*
* This can be used to construct a @c shared_ptr to a sub-object
* of an object managed by an existing @c shared_ptr.
*
* @code
* shared_ptr< pair<int,int> > pii(new pair<int,int>());
* shared_ptr<int> pi(pii, &pii->first);
* assert(pii.use_count() == 2);
* @endcode
*/
template <typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp> &__r, _Tp *__p) : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{
}
// generated copy constructor, assignment, destructor are fine.
/** @brief If @a __r is empty, constructs an empty %__shared_ptr;
* otherwise construct a %__shared_ptr that shares ownership
* with @a __r.
* @param __r A %__shared_ptr.
* @post get() == __r.get() && use_count() == __r.use_count()
*/
template <typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp> &__r) : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
{__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)}
/** @brief Move-constructs a %__shared_ptr instance from @a __r.
* @param __r A %__shared_ptr rvalue.
* @post *this contains the old value of @a __r, @a __r is empty.
*/
__shared_ptr(__shared_ptr && __r) : _M_ptr(__r._M_ptr), _M_refcount() // never throws
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
/** @brief Move-constructs a %__shared_ptr instance from @a __r.
* @param __r A %__shared_ptr rvalue.
* @post *this contains the old value of @a __r, @a __r is empty.
*/
template <typename _Tp1>
__shared_ptr(__shared_ptr<_Tp1, _Lp> &&__r) : _M_ptr(__r._M_ptr), _M_refcount() // never throws
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
/** @brief Constructs a %__shared_ptr that shares ownership with @a __r
* and stores a copy of the pointer stored in @a __r.
* @param __r A weak_ptr.
* @post use_count() == __r.use_count()
* @throw bad_weak_ptr when __r.expired(),
* in which case the constructor has no effect.
*/
template <typename _Tp1> // 从weak_ptr创建
explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp> &__r) : _M_refcount(__r._M_refcount) /*拷贝引用控制块*/ // may throw
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
// It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount)
// did not throw.
_M_ptr = __r._M_ptr;
}
template <typename _Tp1, typename _Del>
explicit __shared_ptr(const std::unique_ptr<_Tp1, _Del> &) = delete;
/**
* If an exception is thrown this constructor has no effect.
*/
template <typename _Tp1, typename _Del>
explicit __shared_ptr(std::unique_ptr<_Tp1, _Del> &&__r) : _M_ptr(__r.get()), _M_refcount()
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
_Tp1 *__tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
#if _GLIBCXX_DEPRECATED
/**
* @post use_count() == 1 and __r.get() == 0
*/
template <typename _Tp1>
explicit __shared_ptr(std::auto_ptr<_Tp1> &&__r) : _M_ptr(__r.get()), _M_refcount()
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1 *, _Tp *>)
// TODO requires _Tp1 is complete, delete __r.release() well-formed
_Tp1 *__tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
#endif
template <typename _Tp1>
__shared_ptr &operator=(const __shared_ptr<_Tp1, _Lp> &__r) // never throws
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
return *this;
}
#if _GLIBCXX_DEPRECATED
template <typename _Tp1>
__shared_ptr &operator=(std::auto_ptr<_Tp1> &&__r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
#endif
__shared_ptr &operator=(__shared_ptr &&__r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template <class _Tp1>
__shared_ptr &operator=(__shared_ptr<_Tp1, _Lp> &&__r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template <typename _Tp1, typename _Del>
__shared_ptr &operator=(const std::unique_ptr<_Tp1, _Del> &__r) = delete;
template <typename _Tp1, typename _Del>
__shared_ptr &operator=(std::unique_ptr<_Tp1, _Del> &&__r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
void reset() // never throws
{
__shared_ptr().swap(*this);
}
template <typename _Tp1>
void reset(_Tp1 *__p) // _Tp1 must be complete.
{
// Catch self-reset errors.
_GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
__shared_ptr(__p).swap(*this);
}
template <typename _Tp1, typename _Deleter>
void reset(_Tp1 *__p, _Deleter __d)
{
__shared_ptr(__p, __d).swap(*this);
}
template <typename _Tp1, typename _Deleter, typename _Alloc>
void reset(_Tp1 *__p, _Deleter __d, const _Alloc &__a)
{
__shared_ptr(__p, __d, __a).swap(*this);
}
// Allow class instantiation when _Tp is [cv-qual] void.
typename std::add_lvalue_reference<_Tp>::type operator*() const // never throws
{
_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
return *_M_ptr;
}
_Tp *operator->() const // never throws
{
_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
return _M_ptr;
}
_Tp *get() const // never throws
{
return _M_ptr;
}
// Implicit conversion to "bool"
private:
typedef _Tp *__shared_ptr::*__unspecified_bool_type;
public:
operator __unspecified_bool_type() const // never throws
{
return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr;
}
bool unique() const // never throws
{
return _M_refcount._M_unique();
}
long use_count() const // never throws
{
return _M_refcount._M_get_use_count();
}
void swap(__shared_ptr<_Tp, _Lp> &&__other) // never throws
{
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
template <typename _Tp1>
bool owner_before(__shared_ptr<_Tp1, _Lp> const &__rhs) const
{
return _M_refcount._M_less(__rhs._M_refcount);
}
template <typename _Tp1>
bool owner_before(__weak_ptr<_Tp1, _Lp> const &__rhs) const
{
return _M_refcount._M_less(__rhs._M_refcount);
}
protected:
// This constructor is non-standard, it is used by allocate_shared.
template <typename _Alloc, typename... _Args> // make_shared使用
__shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args &&...__args) : _M_ptr(), _M_refcount(__tag, (_Tp *)0, __a, std::forward<_Args>(__args)...)
{
// _M_ptr needs to point to the newly constructed object.
// This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
void *__p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp *>(__p); // 重新赋值资源指针
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
template <typename _Tp1, _Lock_policy _Lp1, typename _Alloc, typename... _Args>
friend __shared_ptr<_Tp1, _Lp1> __allocate_shared(_Alloc __a, _Args &&...__args);
private:
void *_M_get_deleter(const std::type_info &__ti) const
{
return _M_refcount._M_get_deleter(__ti);
}
template <typename _Tp1, _Lock_policy _Lp1>
friend class __shared_ptr;
template <typename _Tp1, _Lock_policy _Lp1>
friend class __weak_ptr;
template <typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del *get_deleter(const __shared_ptr<_Tp1, _Lp1> &);
_Tp *_M_ptr; // Contained pointer. //资源指针
__shared_count<_Lp> _M_refcount; // Reference counter. //引用计数控制块
};
// 20.8.13.2.7 shared_ptr comparisons
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator==(const __shared_ptr<_Tp1, _Lp> &__a, const __shared_ptr<_Tp2, _Lp> &__b)
{
return __a.get() == __b.get();
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator!=(const __shared_ptr<_Tp1, _Lp> &__a, const __shared_ptr<_Tp2, _Lp> &__b)
{
return __a.get() != __b.get();
}
template <typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool operator<(const __shared_ptr<_Tp1, _Lp> &__a, const __shared_ptr<_Tp2, _Lp> &__b)
{
return __a.get() < __b.get();
}
template <typename _Sp>
struct _Sp_less : public binary_function<_Sp, _Sp, bool>
{
bool operator()(const _Sp &__lhs, const _Sp &__rhs) const
{
return std::less<typename _Sp::element_type *>()(__lhs.get(), __rhs.get());
}
};
template <typename _Tp, _Lock_policy _Lp>
struct less<__shared_ptr<_Tp, _Lp>> : public _Sp_less<__shared_ptr<_Tp, _Lp>>
{
};
// XXX LessThanComparable<_Tp> concept should provide >, >= and <=
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>(const __shared_ptr<_Tp, _Lp> &__a, const __shared_ptr<_Tp, _Lp> &__b)
{
return __a.get() > __b.get();
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator>=(const __shared_ptr<_Tp, _Lp> &__a, const __shared_ptr<_Tp, _Lp> &__b)
{
return __a.get() >= __b.get();
}
template <typename _Tp, _Lock_policy _Lp>
inline bool operator<=(const __shared_ptr<_Tp, _Lp> &__a, const __shared_ptr<_Tp, _Lp> &__b)
{
return __a.get() <= __b.get();
}
// 2.2.3.8 shared_ptr specialized algorithms.
template <typename _Tp, _Lock_policy _Lp>
inline void swap(__shared_ptr<_Tp, _Lp> &__a, __shared_ptr<_Tp, _Lp> &__b)
{
__a.swap(__b);
}
template <typename _Tp, _Lock_policy _Lp>
inline void swap(__shared_ptr<_Tp, _Lp> &&__a, __shared_ptr<_Tp, _Lp> &__b)
{
__a.swap(__b);
}
template <typename _Tp, _Lock_policy _Lp>
inline void swap(__shared_ptr<_Tp, _Lp> &__a, __shared_ptr<_Tp, _Lp> &&__b)
{
__a.swap(__b);
}
// 2.2.3.9 shared_ptr casts
/** @warning The seemingly equivalent
* <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code>
* will eventually result in undefined behaviour,
* attempting to delete the same object twice.
*/
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> static_pointer_cast(const __shared_ptr<_Tp1, _Lp> &__r)
{
return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp *>(__r.get()));
}
/** @warning The seemingly equivalent
* <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code>
* will eventually result in undefined behaviour,
* attempting to delete the same object twice.
*/
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> const_pointer_cast(const __shared_ptr<_Tp1, _Lp> &__r)
{
return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp *>(__r.get()));
}
/** @warning The seemingly equivalent
* <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code>
* will eventually result in undefined behaviour,
* attempting to delete the same object twice.
*/
template <typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp> dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp> &__r)
{
if (_Tp *__p = dynamic_cast<_Tp *>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
}
// 2.2.3.7 shared_ptr I/O
template <typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
std::basic_ostream<_Ch, _Tr> &operator<<(std::basic_ostream<_Ch, _Tr> &__os, const __shared_ptr<_Tp, _Lp> &__p)
{
__os << __p.get();
return __os;
}
// 2.2.3.10 shared_ptr get_deleter (experimental)
template <typename _Del, typename _Tp, _Lock_policy _Lp>
inline _Del *get_deleter(const __shared_ptr<_Tp, _Lp> &__p)
{
return static_cast<_Del *>(__p._M_get_deleter(typeid(_Del)));
}
template <typename _Tp, _Lock_policy _Lp>
class __weak_ptr
{
public:
typedef _Tp element_type;
__weak_ptr() : _M_ptr(0), _M_refcount() // never throws
{
}
// Generated copy constructor, assignment, destructor are fine.
// The "obvious" converting constructor implementation:
//
// template<typename _Tp1>
// __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
// : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
// { }
//
// has a serious problem.
//
// __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
// conversion may require access to *__r._M_ptr (virtual inheritance).
//
// It is not possible to avoid spurious access violations since
// in multithreaded programs __r._M_ptr may be invalidated at any point.