CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

testSharedPtr.cc
Go to the documentation of this file.
1// ======================================================================
2//
3// Test compilability and basic functionality of Utility/memory.h
4//
5// Author: W. E. Brown, 2010-03-19, adapted from the boost library's
6// shared_ptr and related functionality whose internal attributions bear
7// the following various notices:
8//
9// Copyright (c) 2002, 2003 Peter Dimov
10// Distributed under the Boost Software License, Version 1.0.
11// See http://www.boost.org/LICENSE_1_0.txt
12//
13// ======================================================================
14
15
16#include "CLHEP/Utility/memory.h"
17
18#include <cassert>
19#include <map>
20#include <vector>
21
22
23using namespace CLHEP;
25using CLHEP::weak_ptr;
26
27
28#if defined(_MSC_VER) && (_MSC_VER >= 1310)
29# pragma warning (disable : 4675) // suppress ADL warning
30#endif
31
32
34{
35
36void
37 f(int &)
38{ }
39
40void
42{
44 T t;
45 f(t);
46}
47
48} // namespace n_element_type
49
51{
52
53class incomplete;
54
55void
57{
58 {
60 assert(pi? false: true);
61 assert(!pi);
62 assert(pi.get() == 0);
63 assert(pi.use_count() == 0);
64 }
65
66 {
68 assert(pv? false: true);
69 assert(!pv);
70 assert(pv.get() == 0);
71 assert(pv.use_count() == 0);
72 }
73
74 {
76 assert(px? false: true);
77 assert(!px);
78 assert(px.get() == 0);
79 assert(px.use_count() == 0);
80 }
81}
82
83struct A
84{
85 int dummy;
86};
87
88struct X
89{
90 static long instances;
91
92 X()
93 {
94 ++instances;
95 }
96
98 {
99 --instances;
100 }
101
102private:
103 X(X const &);
104 X & operator= (X const &);
105};
106
107long X::instances = 0;
108
109// virtual inheritance stresses the implementation
110
111struct Y
112 : public A
113 , public virtual X
114{
115 static long instances;
116
118 {
119 ++instances;
120 }
121
123 {
124 --instances;
125 }
126
127private:
128 Y(Y const &);
129 Y & operator= (Y const &);
130};
131
132long Y::instances = 0;
133
134template< class T >
135 void
136 pc0_test(T * p)
137{
138 assert(p == 0);
139 shared_ptr<T> pt(p);
140 assert(pt? false: true);
141 assert(!pt);
142 assert(pt.get() == 0);
143 assert(pt.use_count() == 1);
144 assert(pt.unique());
145}
146
147void
149{
150 pc0_test(static_cast<int*>(0));
151
152 pc0_test(static_cast<int const*>(0));
153 pc0_test(static_cast<int volatile*>(0));
154 pc0_test(static_cast<int const volatile*>(0));
155
156 {
157 shared_ptr<int const> pi(static_cast<int*>(0));
158 assert(pi? false: true);
159 assert(!pi);
160 assert(pi.get() == 0);
161 assert(pi.use_count() == 1);
162 assert(pi.unique());
163 }
164
165 {
166 shared_ptr<int volatile> pi(static_cast<int*>(0));
167 assert(pi? false: true);
168 assert(!pi);
169 assert(pi.get() == 0);
170 assert(pi.use_count() == 1);
171 assert(pi.unique());
172 }
173
174 {
175 shared_ptr<void> pv(static_cast<int*>(0));
176 assert(pv? false: true);
177 assert(!pv);
178 assert(pv.get() == 0);
179 assert(pv.use_count() == 1);
180 assert(pv.unique());
181 }
182
183 {
184 shared_ptr<void const> pv(static_cast<int*>(0));
185 assert(pv? false: true);
186 assert(!pv);
187 assert(pv.get() == 0);
188 assert(pv.use_count() == 1);
189 assert(pv.unique());
190 }
191
192 pc0_test(static_cast<X*>(0));
193 pc0_test(static_cast<X const*>(0));
194 pc0_test(static_cast<X volatile*>(0));
195 pc0_test(static_cast<X const volatile*>(0));
196
197 {
198 shared_ptr<X const> px(static_cast<X*>(0));
199 assert(px? false: true);
200 assert(!px);
201 assert(px.get() == 0);
202 assert(px.use_count() == 1);
203 assert(px.unique());
204 }
205
206 {
207 shared_ptr<X> px(static_cast<Y*>(0));
208 assert(px? false: true);
209 assert(!px);
210 assert(px.get() == 0);
211 assert(px.use_count() == 1);
212 assert(px.unique());
213 }
214
215 {
216 shared_ptr<X const> px(static_cast<Y*>(0));
217 assert(px? false: true);
218 assert(!px);
219 assert(px.get() == 0);
220 assert(px.use_count() == 1);
221 assert(px.unique());
222 }
223
224 {
225 shared_ptr<void> pv(static_cast<X*>(0));
226 assert(pv? false: true);
227 assert(!pv);
228 assert(pv.get() == 0);
229 assert(pv.use_count() == 1);
230 assert(pv.unique());
231 }
232
233 {
234 shared_ptr<void const> pv(static_cast<X*>(0));
235 assert(pv? false: true);
236 assert(!pv);
237 assert(pv.get() == 0);
238 assert(pv.use_count() == 1);
239 assert(pv.unique());
240 }
241
242 {
243 int * p = new int(7);
244 shared_ptr<int> pi(p);
245 assert(pi? true: false);
246 assert(!!pi);
247 assert(pi.get() == p);
248 assert(pi.use_count() == 1);
249 assert(pi.unique());
250 assert(*pi == 7);
251 }
252
253 {
254 int * p = new int(7);
256 assert(pi? true: false);
257 assert(!!pi);
258 assert(pi.get() == p);
259 assert(pi.use_count() == 1);
260 assert(pi.unique());
261 assert(*pi == 7);
262 }
263
264 {
265 int * p = new int(7);
266 shared_ptr<void> pv(p);
267 assert(pv? true: false);
268 assert(!!pv);
269 assert(pv.get() == p);
270 assert(pv.use_count() == 1);
271 assert(pv.unique());
272 }
273
274 {
275 int * p = new int(7);
277 assert(pv? true: false);
278 assert(!!pv);
279 assert(pv.get() == p);
280 assert(pv.use_count() == 1);
281 assert(pv.unique());
282 }
283
284 assert(X::instances == 0);
285
286 {
287 X * p = new X;
288 shared_ptr<X> px(p);
289 assert(px? true: false);
290 assert(!!px);
291 assert(px.get() == p);
292 assert(px.use_count() == 1);
293 assert(px.unique());
294 assert(X::instances == 1);
295 }
296
297 assert(X::instances == 0);
298
299 {
300 X * p = new X;
302 assert(px? true: false);
303 assert(!!px);
304 assert(px.get() == p);
305 assert(px.use_count() == 1);
306 assert(px.unique());
307 assert(X::instances == 1);
308 }
309
310 assert(X::instances == 0);
311
312 {
313 X * p = new X;
314 shared_ptr<void> pv(p);
315 assert(pv? true: false);
316 assert(!!pv);
317 assert(pv.get() == p);
318 assert(pv.use_count() == 1);
319 assert(pv.unique());
320 assert(X::instances == 1);
321 }
322
323 assert(X::instances == 0);
324
325 {
326 X * p = new X;
328 assert(pv? true: false);
329 assert(!!pv);
330 assert(pv.get() == p);
331 assert(pv.use_count() == 1);
332 assert(pv.unique());
333 assert(X::instances == 1);
334 }
335
336 assert(X::instances == 0);
337 assert(Y::instances == 0);
338
339 {
340 Y * p = new Y;
341 shared_ptr<X> px(p);
342 assert(px? true: false);
343 assert(!!px);
344 assert(px.get() == p);
345 assert(px.use_count() == 1);
346 assert(px.unique());
347 assert(X::instances == 1);
348 assert(Y::instances == 1);
349 }
350
351 assert(X::instances == 0);
352 assert(Y::instances == 0);
353
354 {
355 Y * p = new Y;
357 assert(px? true: false);
358 assert(!!px);
359 assert(px.get() == p);
360 assert(px.use_count() == 1);
361 assert(px.unique());
362 assert(X::instances == 1);
363 assert(Y::instances == 1);
364 }
365
366 assert(X::instances == 0);
367 assert(Y::instances == 0);
368}
369
370int m = 0;
371
372void
373 deleter(int * p)
374{
375 assert(p == 0);
376}
377
378void
379 deleter2(int * p)
380{
381 assert(p == &m);
382 ++*p;
383}
384
386{
388 {
389 assert(p == 0);
390 }
391};
392
394
395void
397{
398 {
399 shared_ptr<int> pi(static_cast<int*>(0), deleter);
400 assert(pi? false: true);
401 assert(!pi);
402 assert(pi.get() == 0);
403 assert(pi.use_count() == 1);
404 assert(pi.unique());
405 }
406
407 {
408 shared_ptr<void> pv(static_cast<int*>(0), &deleter);
409 assert(pv? false: true);
410 assert(!pv);
411 assert(pv.get() == 0);
412 assert(pv.use_count() == 1);
413 assert(pv.unique());
414 }
415
416 {
417 shared_ptr<void const> pv(static_cast<int*>(0), deleter);
418 assert(pv? false: true);
419 assert(!pv);
420 assert(pv.get() == 0);
421 assert(pv.use_count() == 1);
422 assert(pv.unique());
423 }
424
425 {
427 assert(px? false: true);
428 assert(!px);
429 assert(px.get() == 0);
430 assert(px.use_count() == 1);
431 assert(px.unique());
432 }
433
434 {
436 assert(pv? false: true);
437 assert(!pv);
438 assert(pv.get() == 0);
439 assert(pv.use_count() == 1);
440 assert(pv.unique());
441 }
442
443 {
445 assert(pv? false: true);
446 assert(!pv);
447 assert(pv.get() == 0);
448 assert(pv.use_count() == 1);
449 assert(pv.unique());
450 }
451
452 assert(m == 0);
453
454 {
456 assert(pi? true: false);
457 assert(!!pi);
458 assert(pi.get() == &m);
459 assert(pi.use_count() == 1);
460 assert(pi.unique());
461 }
462
463 assert(m == 1);
464
465 {
467 assert(pi? true: false);
468 assert(!!pi);
469 assert(pi.get() == &m);
470 assert(pi.use_count() == 1);
471 assert(pi.unique());
472 }
473
474 assert(m == 2);
475
476 {
478 assert(pv? true: false);
479 assert(!!pv);
480 assert(pv.get() == &m);
481 assert(pv.use_count() == 1);
482 assert(pv.unique());
483 }
484
485 assert(m == 3);
486
487 {
489 assert(pv? true: false);
490 assert(!!pv);
491 assert(pv.get() == &m);
492 assert(pv.use_count() == 1);
493 assert(pv.unique());
494 }
495
496 assert(m == 4);
497}
498
499void
501{
502 {
504
505 shared_ptr<int> pi2(pi);
506 assert(pi2 == pi);
507 assert(pi2? false: true);
508 assert(!pi2);
509 assert(pi2.get() == 0);
510 assert(pi2.use_count() == pi.use_count());
511
512 shared_ptr<void> pi3(pi);
513 assert(pi3 == pi);
514 assert(pi3? false: true);
515 assert(!pi3);
516 assert(pi3.get() == 0);
517 assert(pi3.use_count() == pi.use_count());
518
519 shared_ptr<void> pi4(pi3);
520 assert(pi4 == pi3);
521 assert(pi4? false: true);
522 assert(!pi4);
523 assert(pi4.get() == 0);
524 assert(pi4.use_count() == pi3.use_count());
525 }
526
527 {
529
530 shared_ptr<void> pv2(pv);
531 assert(pv2 == pv);
532 assert(pv2? false: true);
533 assert(!pv2);
534 assert(pv2.get() == 0);
535 assert(pv2.use_count() == pv.use_count());
536 }
537
538 {
540
542 assert(px2 == px);
543 assert(px2? false: true);
544 assert(!px2);
545 assert(px2.get() == 0);
546 assert(px2.use_count() == px.use_count());
547
548 shared_ptr<void> px3(px);
549 assert(px3 == px);
550 assert(px3? false: true);
551 assert(!px3);
552 assert(px3.get() == 0);
553 assert(px3.use_count() == px.use_count());
554 }
555
556 {
557 shared_ptr<int> pi(static_cast<int*>(0));
558
559 shared_ptr<int> pi2(pi);
560 assert(pi2 == pi);
561 assert(pi2? false: true);
562 assert(!pi2);
563 assert(pi2.get() == 0);
564 assert(pi2.use_count() == 2);
565 assert(!pi2.unique());
566 assert(pi2.use_count() == pi.use_count());
567 assert(!(pi < pi2 || pi2 < pi)); // shared ownership test
568
569 shared_ptr<void> pi3(pi);
570 assert(pi3 == pi);
571 assert(pi3? false: true);
572 assert(!pi3);
573 assert(pi3.get() == 0);
574 assert(pi3.use_count() == 3);
575 assert(!pi3.unique());
576 assert(pi3.use_count() == pi.use_count());
577 assert(!(pi < pi3 || pi3 < pi)); // shared ownership test
578
579 shared_ptr<void> pi4(pi2);
580 assert(pi4 == pi2);
581 assert(pi4? false: true);
582 assert(!pi4);
583 assert(pi4.get() == 0);
584 assert(pi4.use_count() == 4);
585 assert(!pi4.unique());
586 assert(pi4.use_count() == pi2.use_count());
587 assert(!(pi2 < pi4 || pi4 < pi2)); // shared ownership test
588
589 assert(pi3.use_count() == pi4.use_count());
590 assert(!(pi3 < pi4 || pi4 < pi3)); // shared ownership test
591 }
592
593 {
594 shared_ptr<X> px(static_cast<X*>(0));
595
596 shared_ptr<X> px2(px);
597 assert(px2 == px);
598 assert(px2? false: true);
599 assert(!px2);
600 assert(px2.get() == 0);
601 assert(px2.use_count() == 2);
602 assert(!px2.unique());
603 assert(px2.use_count() == px.use_count());
604 assert(!(px < px2 || px2 < px)); // shared ownership test
605
606 shared_ptr<void> px3(px);
607 assert(px3 == px);
608 assert(px3? false: true);
609 assert(!px3);
610 assert(px3.get() == 0);
611 assert(px3.use_count() == 3);
612 assert(!px3.unique());
613 assert(px3.use_count() == px.use_count());
614 assert(!(px < px3 || px3 < px)); // shared ownership test
615
616 shared_ptr<void> px4(px2);
617 assert(px4 == px2);
618 assert(px4? false: true);
619 assert(!px4);
620 assert(px4.get() == 0);
621 assert(px4.use_count() == 4);
622 assert(!px4.unique());
623 assert(px4.use_count() == px2.use_count());
624 assert(!(px2 < px4 || px4 < px2)); // shared ownership test
625
626 assert(px3.use_count() == px4.use_count());
627 assert(!(px3 < px4 || px4 < px3)); // shared ownership test
628 }
629
630 {
631 int * p = new int(7);
632 shared_ptr<int> pi(p);
633
634 shared_ptr<int> pi2(pi);
635 assert(pi2 == pi);
636 assert(pi2? true: false);
637 assert(!!pi2);
638 assert(pi2.get() == p);
639 assert(pi2.use_count() == 2);
640 assert(!pi2.unique());
641 assert(*pi2 == 7);
642 assert(pi2.use_count() == pi.use_count());
643 assert(!(pi < pi2 || pi2 < pi)); // shared ownership test
644 }
645
646 {
647 int * p = new int(7);
648 shared_ptr<void> pv(p);
649 assert(pv.get() == p);
650
651 shared_ptr<void> pv2(pv);
652 assert(pv2 == pv);
653 assert(pv2? true: false);
654 assert(!!pv2);
655 assert(pv2.get() == p);
656 assert(pv2.use_count() == 2);
657 assert(!pv2.unique());
658 assert(pv2.use_count() == pv.use_count());
659 assert(!(pv < pv2 || pv2 < pv)); // shared ownership test
660 }
661
662 assert(X::instances == 0);
663
664 {
665 X * p = new X;
666 shared_ptr<X> px(p);
667 assert(px.get() == p);
668
669 shared_ptr<X> px2(px);
670 assert(px2 == px);
671 assert(px2? true: false);
672 assert(!!px2);
673 assert(px2.get() == p);
674 assert(px2.use_count() == 2);
675 assert(!px2.unique());
676
677 assert(X::instances == 1);
678
679 assert(px2.use_count() == px.use_count());
680 assert(!(px < px2 || px2 < px)); // shared ownership test
681
682 shared_ptr<void> px3(px);
683 assert(px3 == px);
684 assert(px3? true: false);
685 assert(!!px3);
686 assert(px3.get() == p);
687 assert(px3.use_count() == 3);
688 assert(!px3.unique());
689 assert(px3.use_count() == px.use_count());
690 assert(!(px < px3 || px3 < px)); // shared ownership test
691
692 shared_ptr<void> px4(px2);
693 assert(px4 == px2);
694 assert(px4? true: false);
695 assert(!!px4);
696 assert(px4.get() == p);
697 assert(px4.use_count() == 4);
698 assert(!px4.unique());
699 assert(px4.use_count() == px2.use_count());
700 assert(!(px2 < px4 || px4 < px2)); // shared ownership test
701
702 assert(px3.use_count() == px4.use_count());
703 assert(!(px3 < px4 || px4 < px3)); // shared ownership test
704 }
705
706 assert(X::instances == 0);
707 assert(Y::instances == 0);
708
709 {
710 Y * p = new Y;
711 shared_ptr<Y> py(p);
712 assert(py.get() == p);
713
714 shared_ptr<X> px(py);
715 assert(px == py);
716 assert(px? true: false);
717 assert(!!px);
718 assert(px.get() == p);
719 assert(px.use_count() == 2);
720 assert(!px.unique());
721 assert(px.use_count() == py.use_count());
722 assert(!(px < py || py < px)); // shared ownership test
723
724 assert(X::instances == 1);
725 assert(Y::instances == 1);
726
728 assert(pv == px);
729 assert(pv? true: false);
730 assert(!!pv);
731 assert(pv.get() == px.get());
732 assert(pv.use_count() == 3);
733 assert(!pv.unique());
734 assert(pv.use_count() == px.use_count());
735 assert(!(px < pv || pv < px)); // shared ownership test
736
738 assert(pv2 == py);
739 assert(pv2? true: false);
740 assert(!!pv2);
741 assert(pv2.get() == py.get());
742 assert(pv2.use_count() == 4);
743 assert(!pv2.unique());
744 assert(pv2.use_count() == py.use_count());
745 assert(!(py < pv2 || pv2 < py)); // shared ownership test
746
747 assert(pv.use_count() == pv2.use_count());
748 assert(!(pv < pv2 || pv2 < pv)); // shared ownership test
749 }
750
751 assert(X::instances == 0);
752 assert(Y::instances == 0);
753}
754
755void
757{
758 {
759 weak_ptr<Y> wp;
760 assert(wp.use_count() == 0);
761
762 try
763 {
764 shared_ptr<Y> p2(wp);
765 throw "shared_ptr<Y> p2(wp) failed to throw";
766 }
767 catch(bad_weak_ptr)
768 {
769 }
770
771 try
772 {
773 shared_ptr<X> p3(wp);
774 throw "shared_ptr<X> p3(wp) failed to throw";
775 }
776 catch(bad_weak_ptr)
777 {
778 }
779 }
780
781 {
783 weak_ptr<Y> wp(p);
784
785 if(wp.use_count() != 0) // 0 allowed but not required
786 {
787 shared_ptr<Y> p2(wp);
788 assert(p2.use_count() == wp.use_count());
789 assert(p2.get() == 0);
790
791 shared_ptr<X> p3(wp);
792 assert(p3.use_count() == wp.use_count());
793 assert(p3.get() == 0);
794 }
795 }
796
797 {
798 shared_ptr<Y> p(new Y);
799 weak_ptr<Y> wp(p);
800
801 {
802 shared_ptr<Y> p2(wp);
803 assert(p2? true: false);
804 assert(!!p2);
805 assert(p2.get() == p.get());
806 assert(p2.use_count() == 2);
807 assert(!p2.unique());
808 assert(p2.use_count() == wp.use_count());
809
810 assert(p.use_count() == p2.use_count());
811 assert(!(p < p2 || p2 < p)); // shared ownership test
812
813 shared_ptr<X> p3(wp);
814 assert(p3? true: false);
815 assert(!!p3);
816 assert(p3.get() == p.get());
817 assert(p3.use_count() == 3);
818 assert(!p3.unique());
819 assert(p3.use_count() == wp.use_count());
820
821 assert(p.use_count() == p3.use_count());
822 }
823
824 p.reset();
825 assert(wp.use_count() == 0);
826
827 try
828 {
829 shared_ptr<Y> p2(wp);
830 throw "shared_ptr<Y> p2(wp) failed to throw";
831 }
832 catch(bad_weak_ptr)
833 {
834 }
835
836 try
837 {
838 shared_ptr<X> p3(wp);
839 throw "shared_ptr<X> p3(wp) failed to throw";
840 }
841 catch(bad_weak_ptr)
842 {
843 }
844 }
845}
846
847void
849{
850 {
851 std::auto_ptr<int> p;
852 shared_ptr<int> pi(p);
853 assert(pi? false: true);
854 assert(!pi);
855 assert(pi.get() == 0);
856 assert(pi.use_count() == 1);
857 assert(pi.unique());
858 assert(p.get() == 0);
859 }
860
861 {
862 std::auto_ptr<int> p;
864 assert(pi? false: true);
865 assert(!pi);
866 assert(pi.get() == 0);
867 assert(pi.use_count() == 1);
868 assert(pi.unique());
869 assert(p.get() == 0);
870 }
871
872 {
873 std::auto_ptr<int> p;
874 shared_ptr<void> pv(p);
875 assert(pv? false: true);
876 assert(!pv);
877 assert(pv.get() == 0);
878 assert(pv.use_count() == 1);
879 assert(pv.unique());
880 assert(p.get() == 0);
881 }
882
883 {
884 std::auto_ptr<int> p;
886 assert(pv? false: true);
887 assert(!pv);
888 assert(pv.get() == 0);
889 assert(pv.use_count() == 1);
890 assert(pv.unique());
891 assert(p.get() == 0);
892 }
893
894 {
895 std::auto_ptr<X> p;
896 shared_ptr<X> px(p);
897 assert(px? false: true);
898 assert(!px);
899 assert(px.get() == 0);
900 assert(px.use_count() == 1);
901 assert(px.unique());
902 assert(p.get() == 0);
903 }
904
905 {
906 std::auto_ptr<X> p;
908 assert(px? false: true);
909 assert(!px);
910 assert(px.get() == 0);
911 assert(px.use_count() == 1);
912 assert(px.unique());
913 assert(p.get() == 0);
914 }
915
916 {
917 std::auto_ptr<Y> p;
918 shared_ptr<X> px(p);
919 assert(px? false: true);
920 assert(!px);
921 assert(px.get() == 0);
922 assert(px.use_count() == 1);
923 assert(px.unique());
924 assert(p.get() == 0);
925 }
926
927 {
928 std::auto_ptr<Y> p;
930 assert(px? false: true);
931 assert(!px);
932 assert(px.get() == 0);
933 assert(px.use_count() == 1);
934 assert(px.unique());
935 assert(p.get() == 0);
936 }
937
938 {
939 std::auto_ptr<Y> p;
940 shared_ptr<void> pv(p);
941 assert(pv? false: true);
942 assert(!pv);
943 assert(pv.get() == 0);
944 assert(pv.use_count() == 1);
945 assert(pv.unique());
946 assert(p.get() == 0);
947 }
948
949 {
950 std::auto_ptr<Y> p;
952 assert(pv? false: true);
953 assert(!pv);
954 assert(pv.get() == 0);
955 assert(pv.use_count() == 1);
956 assert(pv.unique());
957 assert(p.get() == 0);
958 }
959
960 {
961 std::auto_ptr<int> p(new int(7));
962 int * q = p.get();
963 shared_ptr<int> pi(p);
964 assert(pi? true: false);
965 assert(!!pi);
966 assert(pi.get() == q);
967 assert(pi.use_count() == 1);
968 assert(pi.unique());
969 assert(*pi == 7);
970
971 assert(p.get() == 0);
972 }
973
974 {
975 std::auto_ptr<int> p(new int(7));
976 int * q = p.get();
978 assert(pi? true: false);
979 assert(!!pi);
980 assert(pi.get() == q);
981 assert(pi.use_count() == 1);
982 assert(pi.unique());
983 assert(*pi == 7);
984
985 assert(p.get() == 0);
986 }
987
988 {
989 std::auto_ptr<int> p(new int(7));
990 int * q = p.get();
991 shared_ptr<void> pv(p);
992 assert(pv? true: false);
993 assert(!!pv);
994 assert(pv.get() == q);
995 assert(pv.use_count() == 1);
996 assert(pv.unique());
997
998 assert(p.get() == 0);
999 }
1000
1001 {
1002 std::auto_ptr<int> p(new int(7));
1003 int * q = p.get();
1005 assert(pv? true: false);
1006 assert(!!pv);
1007 assert(pv.get() == q);
1008 assert(pv.use_count() == 1);
1009 assert(pv.unique());
1010
1011 assert(p.get() == 0);
1012 }
1013
1014 assert(X::instances == 0);
1015
1016 {
1017 std::auto_ptr<X> p(new X);
1018 X * q = p.get();
1019 shared_ptr<X> px(p);
1020 assert(px? true: false);
1021 assert(!!px);
1022 assert(px.get() == q);
1023 assert(px.use_count() == 1);
1024 assert(px.unique());
1025 assert(X::instances == 1);
1026
1027 assert(p.get() == 0);
1028 }
1029
1030 assert(X::instances == 0);
1031
1032 {
1033 std::auto_ptr<X> p(new X);
1034 X * q = p.get();
1035 shared_ptr<X const> px(p);
1036 assert(px? true: false);
1037 assert(!!px);
1038 assert(px.get() == q);
1039 assert(px.use_count() == 1);
1040 assert(px.unique());
1041 assert(X::instances == 1);
1042
1043 assert(p.get() == 0);
1044 }
1045
1046 assert(X::instances == 0);
1047
1048 {
1049 std::auto_ptr<X> p(new X);
1050 X * q = p.get();
1051 shared_ptr<void> pv(p);
1052 assert(pv? true: false);
1053 assert(!!pv);
1054 assert(pv.get() == q);
1055 assert(pv.use_count() == 1);
1056 assert(pv.unique());
1057 assert(X::instances == 1);
1058
1059 assert(p.get() == 0);
1060 }
1061
1062 assert(X::instances == 0);
1063
1064 {
1065 std::auto_ptr<X> p(new X);
1066 X * q = p.get();
1068 assert(pv? true: false);
1069 assert(!!pv);
1070 assert(pv.get() == q);
1071 assert(pv.use_count() == 1);
1072 assert(pv.unique());
1073 assert(X::instances == 1);
1074
1075 assert(p.get() == 0);
1076 }
1077
1078 assert(X::instances == 0);
1079 assert(Y::instances == 0);
1080
1081 {
1082 std::auto_ptr<Y> p(new Y);
1083 Y * q = p.get();
1084 shared_ptr<X> px(p);
1085 assert(px? true: false);
1086 assert(!!px);
1087 assert(px.get() == q);
1088 assert(px.use_count() == 1);
1089 assert(px.unique());
1090 assert(X::instances == 1);
1091 assert(Y::instances == 1);
1092
1093 assert(p.get() == 0);
1094 }
1095
1096 assert(X::instances == 0);
1097 assert(Y::instances == 0);
1098
1099 {
1100 std::auto_ptr<Y> p(new Y);
1101 Y * q = p.get();
1102 shared_ptr<X const> px(p);
1103 assert(px? true: false);
1104 assert(!!px);
1105 assert(px.get() == q);
1106 assert(px.use_count() == 1);
1107 assert(px.unique());
1108 assert(X::instances == 1);
1109 assert(Y::instances == 1);
1110
1111 assert(p.get() == 0);
1112 }
1113
1114 assert(X::instances == 0);
1115 assert(Y::instances == 0);
1116}
1117
1118void
1120{
1127}
1128
1129} // namespace n_constructors
1130
1132{
1133
1134class incomplete;
1135
1136struct A
1137{
1139};
1140
1141struct X
1142{
1143 static long instances;
1144
1146 {
1147 ++instances;
1148 }
1149
1151 {
1152 --instances;
1153 }
1154
1155private:
1156 X(X const &);
1157 X & operator= (X const &);
1158};
1159
1160long X::instances = 0;
1161
1162struct Y
1163 : public A
1164 , public virtual X
1165{
1166 static long instances;
1167
1169 {
1170 ++instances;
1171 }
1172
1174 {
1175 --instances;
1176 }
1177
1178private:
1179 Y(Y const &);
1180 Y & operator= (Y const &);
1181};
1182
1183long Y::instances = 0;
1184
1185void
1187{
1188 {
1190
1191 p1 = p1;
1192
1193 assert(p1 == p1);
1194 assert(p1? false: true);
1195 assert(!p1);
1196 assert(p1.get() == 0);
1197
1199
1200 p1 = p2;
1201
1202 assert(p1 == p2);
1203 assert(p1? false: true);
1204 assert(!p1);
1205 assert(p1.get() == 0);
1206
1208
1209 p1 = p3;
1210
1211 assert(p1 == p3);
1212 assert(p1? false: true);
1213 assert(!p1);
1214 assert(p1.get() == 0);
1215 }
1216
1217 {
1219
1220 p1 = p1;
1221
1222 assert(p1 == p1);
1223 assert(p1? false: true);
1224 assert(!p1);
1225 assert(p1.get() == 0);
1226
1228
1229 p1 = p2;
1230
1231 assert(p1 == p2);
1232 assert(p1? false: true);
1233 assert(!p1);
1234 assert(p1.get() == 0);
1235
1236 shared_ptr<void> p3(p1);
1237
1238 p1 = p3;
1239
1240 assert(p1 == p3);
1241 assert(p1? false: true);
1242 assert(!p1);
1243 assert(p1.get() == 0);
1244
1245 shared_ptr<void> p4(new int);
1246 assert(p4.use_count() == 1);
1247
1248 p1 = p4;
1249
1250 assert(p1 == p4);
1251 assert(!(p1 < p4 || p4 < p1));
1252 assert(p1.use_count() == 2);
1253 assert(p4.use_count() == 2);
1254
1255 p1 = p3;
1256
1257 assert(p1 == p3);
1258 assert(p4.use_count() == 1);
1259 }
1260
1261 {
1262 shared_ptr<X> p1;
1263
1264 p1 = p1;
1265
1266 assert(p1 == p1);
1267 assert(p1? false: true);
1268 assert(!p1);
1269 assert(p1.get() == 0);
1270
1271 shared_ptr<X> p2;
1272
1273 p1 = p2;
1274
1275 assert(p1 == p2);
1276 assert(p1? false: true);
1277 assert(!p1);
1278 assert(p1.get() == 0);
1279
1280 shared_ptr<X> p3(p1);
1281
1282 p1 = p3;
1283
1284 assert(p1 == p3);
1285 assert(p1? false: true);
1286 assert(!p1);
1287 assert(p1.get() == 0);
1288
1289 assert(X::instances == 0);
1290
1291 shared_ptr<X> p4(new X);
1292
1293 assert(X::instances == 1);
1294
1295 p1 = p4;
1296
1297 assert(X::instances == 1);
1298
1299 assert(p1 == p4);
1300 assert(!(p1 < p4 || p4 < p1));
1301
1302 assert(p1.use_count() == 2);
1303
1304 p1 = p2;
1305
1306 assert(p1 == p2);
1307 assert(X::instances == 1);
1308
1309 p4 = p3;
1310
1311 assert(p4 == p3);
1312 assert(X::instances == 0);
1313 }
1314}
1315
1316void
1318{
1319 {
1321
1323
1324 p1 = p2;
1325
1326 assert(p1 == p2);
1327 assert(p1? false: true);
1328 assert(!p1);
1329 assert(p1.get() == 0);
1330
1331 shared_ptr<int> p4(new int);
1332 assert(p4.use_count() == 1);
1333
1334 shared_ptr<void> p5(p4);
1335 assert(p4.use_count() == 2);
1336
1337 p1 = p4;
1338
1339 assert(p1 == p4);
1340 assert(!(p1 < p5 || p5 < p1));
1341 assert(p1.use_count() == 3);
1342 assert(p4.use_count() == 3);
1343
1344 p1 = p2;
1345
1346 assert(p1 == p2);
1347 assert(p4.use_count() == 2);
1348 }
1349
1350 {
1351 shared_ptr<X> p1;
1352
1353 shared_ptr<Y> p2;
1354
1355 p1 = p2;
1356
1357 assert(p1 == p2);
1358 assert(p1? false: true);
1359 assert(!p1);
1360 assert(p1.get() == 0);
1361
1362 assert(X::instances == 0);
1363 assert(Y::instances == 0);
1364
1365 shared_ptr<Y> p4(new Y);
1366
1367 assert(X::instances == 1);
1368 assert(Y::instances == 1);
1369 assert(p4.use_count() == 1);
1370
1371 shared_ptr<X> p5(p4);
1372 assert(p4.use_count() == 2);
1373
1374 p1 = p4;
1375
1376 assert(X::instances == 1);
1377 assert(Y::instances == 1);
1378
1379 assert(p1 == p4);
1380 assert(!(p1 < p5 || p5 < p1));
1381
1382 assert(p1.use_count() == 3);
1383 assert(p4.use_count() == 3);
1384
1385 p1 = p2;
1386
1387 assert(p1 == p2);
1388 assert(X::instances == 1);
1389 assert(Y::instances == 1);
1390 assert(p4.use_count() == 2);
1391
1392 p4 = p2;
1393 p5 = p2;
1394
1395 assert(p4 == p2);
1396 assert(X::instances == 0);
1397 assert(Y::instances == 0);
1398 }
1399}
1400
1401void
1403{
1404 {
1405 shared_ptr<int> p1;
1406
1407 std::auto_ptr<int> p2;
1408
1409 p1 = p2;
1410 assert(p1? false: true);
1411 assert(!p1);
1412 assert(p1.get() == 0);
1413 assert(p1.use_count() == 1);
1414
1415 int * p = new int;
1416 std::auto_ptr<int> p3(p);
1417
1418 p1 = p3;
1419 assert(p1.get() == p);
1420 assert(p1.use_count() == 1);
1421
1422 assert(p3.get() == 0);
1423
1424 p1 = p2;
1425 assert(p1? false: true);
1426 assert(!p1);
1427 assert(p1.get() == 0);
1428 assert(p1.use_count() == 1);
1429 }
1430
1431 {
1433
1434 std::auto_ptr<int> p2;
1435
1436 p1 = p2;
1437 assert(p1? false: true);
1438 assert(!p1);
1439 assert(p1.get() == 0);
1440 assert(p1.use_count() == 1);
1441
1442 int * p = new int;
1443 std::auto_ptr<int> p3(p);
1444
1445 p1 = p3;
1446 assert(p1.get() == p);
1447 assert(p1.use_count() == 1);
1448
1449 assert(p3.get() == 0);
1450
1451 p1 = p2;
1452 assert(p1? false: true);
1453 assert(!p1);
1454 assert(p1.get() == 0);
1455 assert(p1.use_count() == 1);
1456 }
1457
1458
1459 {
1460 shared_ptr<X> p1;
1461
1462 std::auto_ptr<Y> p2;
1463
1464 p1 = p2;
1465 assert(p1? false: true);
1466 assert(!p1);
1467 assert(p1.get() == 0);
1468 assert(p1.use_count() == 1);
1469 assert(X::instances == 0);
1470 assert(Y::instances == 0);
1471
1472 Y * p = new Y;
1473 std::auto_ptr<Y> p3(p);
1474
1475 assert(X::instances == 1);
1476 assert(Y::instances == 1);
1477
1478 p1 = p3;
1479 assert(p1.get() == p);
1480 assert(p1.use_count() == 1);
1481 assert(X::instances == 1);
1482 assert(Y::instances == 1);
1483
1484 assert(p3.get() == 0);
1485
1486 p1 = p2;
1487 assert(p1? false: true);
1488 assert(!p1);
1489 assert(p1.get() == 0);
1490 assert(p1.use_count() == 1);
1491 assert(X::instances == 0);
1492 assert(Y::instances == 0);
1493 }
1494}
1495
1496void
1498{
1502}
1503
1504} // namespace n_assignment
1505
1506namespace n_reset
1507{
1508
1509class incomplete;
1510
1512
1513void
1515{
1516}
1517
1518struct X
1519{
1520 static long instances;
1521
1523 {
1524 ++instances;
1525 }
1526
1528 {
1529 --instances;
1530 }
1531
1532private:
1533 X(X const &);
1534 X & operator= (X const &);
1535};
1536
1537long X::instances = 0;
1538
1539void
1541{
1542 {
1543 shared_ptr<int> pi;
1544 pi.reset();
1545 assert(pi? false: true);
1546 assert(!pi);
1547 assert(pi.get() == 0);
1548 assert(pi.use_count() == 0);
1549 }
1550
1551 {
1552 shared_ptr<int> pi(static_cast<int*>(0));
1553 pi.reset();
1554 assert(pi? false: true);
1555 assert(!pi);
1556 assert(pi.get() == 0);
1557 assert(pi.use_count() == 0);
1558 }
1559
1560 {
1561 shared_ptr<int> pi(new int);
1562 pi.reset();
1563 assert(pi? false: true);
1564 assert(!pi);
1565 assert(pi.get() == 0);
1566 assert(pi.use_count() == 0);
1567 }
1568
1569 {
1571 px.reset();
1572 assert(px? false: true);
1573 assert(!px);
1574 assert(px.get() == 0);
1575 assert(px.use_count() == 0);
1576 }
1577
1578 {
1580 px.reset();
1581 assert(px? false: true);
1582 assert(!px);
1583 assert(px.get() == 0);
1584 assert(px.use_count() == 0);
1585 }
1586
1587 {
1588 shared_ptr<X> px;
1589 px.reset();
1590 assert(px? false: true);
1591 assert(!px);
1592 assert(px.get() == 0);
1593 assert(px.use_count() == 0);
1594 }
1595
1596 {
1597 assert(X::instances == 0);
1598 shared_ptr<X> px(new X);
1599 assert(X::instances == 1);
1600 px.reset();
1601 assert(px? false: true);
1602 assert(!px);
1603 assert(px.get() == 0);
1604 assert(px.use_count() == 0);
1605 assert(X::instances == 0);
1606 }
1607
1608 {
1610 pv.reset();
1611 assert(pv? false: true);
1612 assert(!pv);
1613 assert(pv.get() == 0);
1614 assert(pv.use_count() == 0);
1615 }
1616
1617 {
1618 assert(X::instances == 0);
1619 shared_ptr<void> pv(new X);
1620 assert(X::instances == 1);
1621 pv.reset();
1622 assert(pv? false: true);
1623 assert(!pv);
1624 assert(pv.get() == 0);
1625 assert(pv.use_count() == 0);
1626 assert(X::instances == 0);
1627 }
1628}
1629
1630struct A
1631{
1633};
1634
1635struct Y
1636 : public A
1637 , public virtual X
1638{
1639 static long instances;
1640
1642 {
1643 ++instances;
1644 }
1645
1647 {
1648 --instances;
1649 }
1650
1651private:
1652 Y(Y const &);
1653 Y & operator= (Y const &);
1654};
1655
1656long Y::instances = 0;
1657
1658void
1660{
1661 {
1662 shared_ptr<int> pi;
1663
1664 pi.reset(static_cast<int*>(0));
1665 assert(pi? false: true);
1666 assert(!pi);
1667 assert(pi.get() == 0);
1668 assert(pi.use_count() == 1);
1669 assert(pi.unique());
1670
1671 int * p = new int;
1672 pi.reset(p);
1673 assert(pi? true: false);
1674 assert(!!pi);
1675 assert(pi.get() == p);
1676 assert(pi.use_count() == 1);
1677 assert(pi.unique());
1678
1679 pi.reset(static_cast<int*>(0));
1680 assert(pi? false: true);
1681 assert(!pi);
1682 assert(pi.get() == 0);
1683 assert(pi.use_count() == 1);
1684 assert(pi.unique());
1685 }
1686
1687 {
1688 shared_ptr<X> px;
1689
1690 px.reset(static_cast<X*>(0));
1691 assert(px? false: true);
1692 assert(!px);
1693 assert(px.get() == 0);
1694 assert(px.use_count() == 1);
1695 assert(px.unique());
1696 assert(X::instances == 0);
1697
1698 X * p = new X;
1699 px.reset(p);
1700 assert(px? true: false);
1701 assert(!!px);
1702 assert(px.get() == p);
1703 assert(px.use_count() == 1);
1704 assert(px.unique());
1705 assert(X::instances == 1);
1706
1707 px.reset(static_cast<X*>(0));
1708 assert(px? false: true);
1709 assert(!px);
1710 assert(px.get() == 0);
1711 assert(px.use_count() == 1);
1712 assert(px.unique());
1713 assert(X::instances == 0);
1714 assert(Y::instances == 0);
1715
1716 Y * q = new Y;
1717 px.reset(q);
1718 assert(px? true: false);
1719 assert(!!px);
1720 assert(px.get() == q);
1721 assert(px.use_count() == 1);
1722 assert(px.unique());
1723 assert(X::instances == 1);
1724 assert(Y::instances == 1);
1725
1726 px.reset(static_cast<Y*>(0));
1727 assert(px? false: true);
1728 assert(!px);
1729 assert(px.get() == 0);
1730 assert(px.use_count() == 1);
1731 assert(px.unique());
1732 assert(X::instances == 0);
1733 assert(Y::instances == 0);
1734 }
1735
1736 {
1738
1739 pv.reset(static_cast<X*>(0));
1740 assert(pv? false: true);
1741 assert(!pv);
1742 assert(pv.get() == 0);
1743 assert(pv.use_count() == 1);
1744 assert(pv.unique());
1745 assert(X::instances == 0);
1746
1747 X * p = new X;
1748 pv.reset(p);
1749 assert(pv? true: false);
1750 assert(!!pv);
1751 assert(pv.get() == p);
1752 assert(pv.use_count() == 1);
1753 assert(pv.unique());
1754 assert(X::instances == 1);
1755
1756 pv.reset(static_cast<X*>(0));
1757 assert(pv? false: true);
1758 assert(!pv);
1759 assert(pv.get() == 0);
1760 assert(pv.use_count() == 1);
1761 assert(pv.unique());
1762 assert(X::instances == 0);
1763 assert(Y::instances == 0);
1764
1765 Y * q = new Y;
1766 pv.reset(q);
1767 assert(pv? true: false);
1768 assert(!!pv);
1769 assert(pv.get() == q);
1770 assert(pv.use_count() == 1);
1771 assert(pv.unique());
1772 assert(X::instances == 1);
1773 assert(Y::instances == 1);
1774
1775 pv.reset(static_cast<Y*>(0));
1776 assert(pv? false: true);
1777 assert(!pv);
1778 assert(pv.get() == 0);
1779 assert(pv.use_count() == 1);
1780 assert(pv.unique());
1781 assert(X::instances == 0);
1782 assert(Y::instances == 0);
1783 }
1784}
1785
1786void
1787 * deleted = 0;
1788
1789void
1790 deleter2(void * p)
1791{
1792 deleted = p;
1793}
1794
1795void
1797{
1798 {
1799 shared_ptr<int> pi;
1800
1801 pi.reset(static_cast<int*>(0), deleter2);
1802 assert(pi? false: true);
1803 assert(!pi);
1804 assert(pi.get() == 0);
1805 assert(pi.use_count() == 1);
1806 assert(pi.unique());
1807
1808 deleted = &pi;
1809
1810 int m = 0;
1811 pi.reset(&m, deleter2);
1812 assert(deleted == 0);
1813 assert(pi? true: false);
1814 assert(!!pi);
1815 assert(pi.get() == &m);
1816 assert(pi.use_count() == 1);
1817 assert(pi.unique());
1818
1819 pi.reset(static_cast<int*>(0), deleter2);
1820 assert(deleted == &m);
1821 assert(pi? false: true);
1822 assert(!pi);
1823 assert(pi.get() == 0);
1824 assert(pi.use_count() == 1);
1825 assert(pi.unique());
1826
1827 pi.reset();
1828 assert(deleted == 0);
1829 }
1830
1831 {
1832 shared_ptr<X> px;
1833
1834 px.reset(static_cast<X*>(0), deleter2);
1835 assert(px? false: true);
1836 assert(!px);
1837 assert(px.get() == 0);
1838 assert(px.use_count() == 1);
1839 assert(px.unique());
1840
1841 deleted = &px;
1842
1843 X x;
1844 px.reset(&x, deleter2);
1845 assert(deleted == 0);
1846 assert(px? true: false);
1847 assert(!!px);
1848 assert(px.get() == &x);
1849 assert(px.use_count() == 1);
1850 assert(px.unique());
1851
1852 px.reset(static_cast<X*>(0), deleter2);
1853 assert(deleted == &x);
1854 assert(px? false: true);
1855 assert(!px);
1856 assert(px.get() == 0);
1857 assert(px.use_count() == 1);
1858 assert(px.unique());
1859
1860 Y y;
1861 px.reset(&y, deleter2);
1862 assert(deleted == 0);
1863 assert(px? true: false);
1864 assert(!!px);
1865 assert(px.get() == &y);
1866 assert(px.use_count() == 1);
1867 assert(px.unique());
1868
1869 px.reset(static_cast<Y*>(0), deleter2);
1870 assert(deleted == &y);
1871 assert(px? false: true);
1872 assert(!px);
1873 assert(px.get() == 0);
1874 assert(px.use_count() == 1);
1875 assert(px.unique());
1876
1877 px.reset();
1878 assert(deleted == 0);
1879 }
1880
1881 {
1883
1884 pv.reset(static_cast<X*>(0), deleter2);
1885 assert(pv? false: true);
1886 assert(!pv);
1887 assert(pv.get() == 0);
1888 assert(pv.use_count() == 1);
1889 assert(pv.unique());
1890
1891 deleted = &pv;
1892
1893 X x;
1894 pv.reset(&x, deleter2);
1895 assert(deleted == 0);
1896 assert(pv? true: false);
1897 assert(!!pv);
1898 assert(pv.get() == &x);
1899 assert(pv.use_count() == 1);
1900 assert(pv.unique());
1901
1902 pv.reset(static_cast<X*>(0), deleter2);
1903 assert(deleted == &x);
1904 assert(pv? false: true);
1905 assert(!pv);
1906 assert(pv.get() == 0);
1907 assert(pv.use_count() == 1);
1908 assert(pv.unique());
1909
1910 Y y;
1911 pv.reset(&y, deleter2);
1912 assert(deleted == 0);
1913 assert(pv? true: false);
1914 assert(!!pv);
1915 assert(pv.get() == &y);
1916 assert(pv.use_count() == 1);
1917 assert(pv.unique());
1918
1919 pv.reset(static_cast<Y*>(0), deleter2);
1920 assert(deleted == &y);
1921 assert(pv? false: true);
1922 assert(!pv);
1923 assert(pv.get() == 0);
1924 assert(pv.use_count() == 1);
1925 assert(pv.unique());
1926
1927 pv.reset();
1928 assert(deleted == 0);
1929 }
1930
1931 {
1933
1934 px.reset(p0, deleter2);
1935 assert(px? false: true);
1936 assert(!px);
1937 assert(px.get() == 0);
1938 assert(px.use_count() == 1);
1939 assert(px.unique());
1940
1941 deleted = &px;
1942 px.reset(p0, deleter2);
1943 assert(deleted == 0);
1944 }
1945}
1946
1947void
1949{
1950 plain_reset();
1951 pointer_reset();
1952 deleter_reset();
1953}
1954
1955} // namespace n_reset
1956
1957namespace n_access
1958{
1959
1960struct X
1961{
1962};
1963
1964void
1966{
1967 {
1968 shared_ptr<X> px;
1969 assert(px.get() == 0);
1970 assert(px? false: true);
1971 assert(!px);
1972
1973 assert(get_pointer(px) == px.get());
1974 }
1975
1976 {
1977 shared_ptr<X> px(static_cast<X*>(0));
1978 assert(px.get() == 0);
1979 assert(px? false: true);
1980 assert(!px);
1981
1982 assert(get_pointer(px) == px.get());
1983 }
1984
1985 #if 0
1986 {
1987 shared_ptr<X> px(static_cast<X*>(0), checked_deleter<X>());
1988 assert(px.get() == 0);
1989 assert(px? false: true);
1990 assert(!px);
1991
1992 assert(get_pointer(px) == px.get());
1993 }
1994 #endif // 0
1995
1996 {
1997 X * p = new X;
1998 shared_ptr<X> px(p);
1999 assert(px.get() == p);
2000 assert(px? true: false);
2001 assert(!!px);
2002 assert(&*px == px.get());
2003 assert(px.operator ->() == px.get());
2004
2005 assert(get_pointer(px) == px.get());
2006 }
2007
2008 #if 0
2009 {
2010 X * p = new X;
2011 shared_ptr<X> px(p, checked_deleter<X>());
2012 assert(px.get() == p);
2013 assert(px? true: false);
2014 assert(!!px);
2015 assert(&*px == px.get());
2016 assert(px.operator ->() == px.get());
2017
2018 assert(get_pointer(px) == px.get());
2019 }
2020 #endif // 0
2021}
2022
2023} // namespace n_access
2024
2026{
2027
2028struct X
2029{
2030};
2031
2032void
2034{
2035 {
2036 shared_ptr<X> px(static_cast<X*>(0));
2037 assert(px.use_count() == 1);
2038 assert(px.unique());
2039
2040 shared_ptr<X> px2(px);
2041 assert(px2.use_count() == 2);
2042 assert(!px2.unique());
2043 assert(px.use_count() == 2);
2044 assert(!px.unique());
2045 }
2046
2047 {
2048 shared_ptr<X> px(new X);
2049 assert(px.use_count() == 1);
2050 assert(px.unique());
2051
2052 shared_ptr<X> px2(px);
2053 assert(px2.use_count() == 2);
2054 assert(!px2.unique());
2055 assert(px.use_count() == 2);
2056 assert(!px.unique());
2057 }
2058
2059 #if 0
2060 {
2061 shared_ptr<X> px(new X, checked_deleter<X>());
2062 assert(px.use_count() == 1);
2063 assert(px.unique());
2064
2065 shared_ptr<X> px2(px);
2066 assert(px2.use_count() == 2);
2067 assert(!px2.unique());
2068 assert(px.use_count() == 2);
2069 assert(!px.unique());
2070 }
2071 #endif // 0
2072}
2073
2074} // namespace n_use_count
2075
2076namespace n_swap
2077{
2078
2079struct X
2080{
2081};
2082
2083void
2085{
2086 {
2087 shared_ptr<X> px;
2088 shared_ptr<X> px2;
2089
2090 px.swap(px2);
2091
2092 assert(px.get() == 0);
2093 assert(px2.get() == 0);
2094
2095 using std::swap;
2096 swap(px, px2);
2097
2098 assert(px.get() == 0);
2099 assert(px2.get() == 0);
2100 }
2101
2102 {
2103 X * p = new X;
2104 shared_ptr<X> px;
2105 shared_ptr<X> px2(p);
2106 shared_ptr<X> px3(px2);
2107
2108 px.swap(px2);
2109
2110 assert(px.get() == p);
2111 assert(px.use_count() == 2);
2112 assert(px2.get() == 0);
2113 assert(px3.get() == p);
2114 assert(px3.use_count() == 2);
2115
2116 using std::swap;
2117 swap(px, px2);
2118
2119 assert(px.get() == 0);
2120 assert(px2.get() == p);
2121 assert(px2.use_count() == 2);
2122 assert(px3.get() == p);
2123 assert(px3.use_count() == 2);
2124 }
2125
2126 {
2127 X * p1 = new X;
2128 X * p2 = new X;
2129 shared_ptr<X> px(p1);
2130 shared_ptr<X> px2(p2);
2131 shared_ptr<X> px3(px2);
2132
2133 px.swap(px2);
2134
2135 assert(px.get() == p2);
2136 assert(px.use_count() == 2);
2137 assert(px2.get() == p1);
2138 assert(px2.use_count() == 1);
2139 assert(px3.get() == p2);
2140 assert(px3.use_count() == 2);
2141
2142 using std::swap;
2143 swap(px, px2);
2144
2145 assert(px.get() == p1);
2146 assert(px.use_count() == 1);
2147 assert(px2.get() == p2);
2148 assert(px2.use_count() == 2);
2149 assert(px3.get() == p2);
2150 assert(px3.use_count() == 2);
2151 }
2152}
2153
2154} // namespace n_swap
2155
2157{
2158
2159struct X
2160{
2162};
2163
2164struct Y
2165{
2167};
2168
2169struct Z
2170 : public X
2171 , public virtual Y
2172{
2173};
2174
2175void
2177{
2178 {
2179 shared_ptr<X> px;
2180 assert(px == px);
2181 assert(!(px != px));
2182 assert(!(px < px));
2183
2184 shared_ptr<X> px2;
2185
2186 assert(px.get() == px2.get());
2187 assert(px == px2);
2188 assert(!(px != px2));
2189 assert(!(px < px2 && px2 < px));
2190 }
2191
2192 {
2193 shared_ptr<X> px;
2194 shared_ptr<X> px2(px);
2195
2196 assert(px2 == px2);
2197 assert(!(px2 != px2));
2198 assert(!(px2 < px2));
2199
2200 assert(px.get() == px2.get());
2201 assert(px == px2);
2202 assert(!(px != px2));
2203 assert(!(px < px2 && px2 < px));
2204 }
2205
2206 {
2207 shared_ptr<X> px;
2208 shared_ptr<X> px2(new X);
2209
2210 assert(px2 == px2);
2211 assert(!(px2 != px2));
2212 assert(!(px2 < px2));
2213
2214 assert(px.get() != px2.get());
2215 assert(px != px2);
2216 assert(!(px == px2));
2217 assert(px < px2 || px2 < px);
2218 assert(!(px < px2 && px2 < px));
2219 }
2220
2221 {
2222 shared_ptr<X> px(new X);
2223 shared_ptr<X> px2(new X);
2224
2225 assert(px.get() != px2.get());
2226 assert(px != px2);
2227 assert(!(px == px2));
2228 assert(px < px2 || px2 < px);
2229 assert(!(px < px2 && px2 < px));
2230 }
2231
2232 {
2233 shared_ptr<X> px(new X);
2234 shared_ptr<X> px2(px);
2235
2236 assert(px2 == px2);
2237 assert(!(px2 != px2));
2238 assert(!(px2 < px2));
2239
2240 assert(px.get() == px2.get());
2241 assert(px == px2);
2242 assert(!(px != px2));
2243 assert(!(px < px2 || px2 < px));
2244 }
2245
2246 {
2247 shared_ptr<X> px(new X);
2248 shared_ptr<Y> py(new Y);
2249 shared_ptr<Z> pz(new Z);
2250
2251 assert(px.get() != pz.get());
2252 assert(px != pz);
2253 assert(!(px == pz));
2254
2255 assert(py.get() != pz.get());
2256 assert(py != pz);
2257 assert(!(py == pz));
2258
2259 assert(px < py || py < px);
2260 assert(px < pz || pz < px);
2261 assert(py < pz || pz < py);
2262
2263 assert(!(px < py && py < px));
2264 assert(!(px < pz && pz < px));
2265 assert(!(py < pz && pz < py));
2266
2267 shared_ptr<void> pvx(px);
2268
2269 assert(pvx == pvx);
2270 assert(!(pvx != pvx));
2271 assert(!(pvx < pvx));
2272
2273 shared_ptr<void> pvy(py);
2274 shared_ptr<void> pvz(pz);
2275
2276 assert(pvx < pvy || pvy < pvx);
2277 assert(pvx < pvz || pvz < pvx);
2278 assert(pvy < pvz || pvz < pvy);
2279
2280 assert(!(pvx < pvy && pvy < pvx));
2281 assert(!(pvx < pvz && pvz < pvx));
2282 assert(!(pvy < pvz && pvz < pvy));
2283 }
2284
2285 {
2286 shared_ptr<Z> pz(new Z);
2287 shared_ptr<X> px(pz);
2288
2289 assert(px == px);
2290 assert(!(px != px));
2291 assert(!(px < px));
2292
2293 shared_ptr<Y> py(pz);
2294
2295 assert(px.get() == pz.get());
2296 assert(px == pz);
2297 assert(!(px != pz));
2298
2299 assert(py.get() == pz.get());
2300 assert(py == pz);
2301 assert(!(py != pz));
2302
2303 assert(!(px < py || py < px));
2304 assert(!(px < pz || pz < px));
2305 assert(!(py < pz || pz < py));
2306
2307 shared_ptr<void> pvx(px);
2308 shared_ptr<void> pvy(py);
2309 shared_ptr<void> pvz(pz);
2310
2311 // pvx and pvy aren't equal...
2312 assert(pvx.get() != pvy.get());
2313 assert(pvx != pvy);
2314 assert(!(pvx == pvy));
2315
2316 // ... but they share ownership ...
2317 assert(!(pvx < pvy || pvy < pvx));
2318
2319 // ... with pvz
2320 assert(!(pvx < pvz || pvz < pvx));
2321 assert(!(pvy < pvz || pvz < pvy));
2322 }
2323}
2324
2325} // namespace n_comparison
2326
2328{
2329
2330struct X
2331{
2332};
2333
2334struct Y
2335 : public X
2336{ };
2337
2338void
2340{
2341 {
2343
2344 shared_ptr<int> pi = static_pointer_cast<int>(pv);
2345 assert(pi.get() == 0);
2346
2347 shared_ptr<X> px = static_pointer_cast<X>(pv);
2348 assert(px.get() == 0);
2349 }
2350
2351 {
2352 shared_ptr<int> pi(new int);
2353 shared_ptr<void> pv(pi);
2354
2355 shared_ptr<int> pi2 = static_pointer_cast<int>(pv);
2356 assert(pi.get() == pi2.get());
2357 assert(!(pi < pi2 || pi2 < pi));
2358 assert(pi.use_count() == 3);
2359 assert(pv.use_count() == 3);
2360 assert(pi2.use_count() == 3);
2361 }
2362
2363 {
2364 shared_ptr<X> px(new X);
2365 shared_ptr<void> pv(px);
2366
2367 shared_ptr<X> px2 = static_pointer_cast<X>(pv);
2368 assert(px.get() == px2.get());
2369 assert(!(px < px2 || px2 < px));
2370 assert(px.use_count() == 3);
2371 assert(pv.use_count() == 3);
2372 assert(px2.use_count() == 3);
2373 }
2374
2375 {
2376 shared_ptr<X> px(new Y);
2377
2378 shared_ptr<Y> py = static_pointer_cast<Y>(px);
2379 assert(px.get() == py.get());
2380 assert(px.use_count() == 2);
2381 assert(py.use_count() == 2);
2382
2383 shared_ptr<X> px2(py);
2384 assert(!(px < px2 || px2 < px));
2385 }
2386}
2387
2388} // namespace n_static_cast
2389
2391{
2392
2393struct X;
2394
2395void
2397{
2398 {
2400
2401 shared_ptr<void> px2 = const_pointer_cast<void>(px);
2402 assert(px2.get() == 0);
2403 }
2404
2405 {
2407
2408 shared_ptr<int> px2 = const_pointer_cast<int>(px);
2409 assert(px2.get() == 0);
2410 }
2411
2412 {
2414
2415 shared_ptr<X> px2 = const_pointer_cast<X>(px);
2416 assert(px2.get() == 0);
2417 }
2418
2419 {
2421
2422 shared_ptr<void> px2 = const_pointer_cast<void>(px);
2423 assert(px.get() == px2.get());
2424 assert(!(px < px2 || px2 < px));
2425 assert(px.use_count() == 2);
2426 assert(px2.use_count() == 2);
2427 }
2428
2429 {
2431
2432 shared_ptr<int> px2 = const_pointer_cast<int>(px);
2433 assert(px.get() == px2.get());
2434 assert(!(px < px2 || px2 < px));
2435 assert(px.use_count() == 2);
2436 assert(px2.use_count() == 2);
2437 }
2438}
2439
2440} // namespace n_const_cast
2441
2443{
2444
2445struct V
2446{
2447 virtual ~V() {}
2448};
2449
2450struct W
2451 : public V
2452{ };
2453
2454void
2456{
2457 {
2458 shared_ptr<V> pv;
2459 shared_ptr<W> pw = dynamic_pointer_cast<W>(pv);
2460 assert(pw.get() == 0);
2461 }
2462
2463 {
2464 shared_ptr<V> pv(static_cast<V*>(0));
2465
2466 shared_ptr<W> pw = dynamic_pointer_cast<W>(pv);
2467 assert(pw.get() == 0);
2468
2469 shared_ptr<V> pv2(pw);
2470 assert(pv < pv2 || pv2 < pv);
2471 }
2472
2473 {
2474 shared_ptr<V> pv(static_cast<W*>(0));
2475
2476 shared_ptr<W> pw = dynamic_pointer_cast<W>(pv);
2477 assert(pw.get() == 0);
2478
2479 shared_ptr<V> pv2(pw);
2480 assert(pv < pv2 || pv2 < pv);
2481 }
2482
2483 {
2484 shared_ptr<V> pv(new V);
2485
2486 shared_ptr<W> pw = dynamic_pointer_cast<W>(pv);
2487 assert(pw.get() == 0);
2488
2489 shared_ptr<V> pv2(pw);
2490 assert(pv < pv2 || pv2 < pv);
2491 }
2492
2493 {
2494 shared_ptr<V> pv(new W);
2495
2496 shared_ptr<W> pw = dynamic_pointer_cast<W>(pv);
2497 assert(pw.get() == pv.get());
2498 assert(pv.use_count() == 2);
2499 assert(pw.use_count() == 2);
2500
2501 shared_ptr<V> pv2(pw);
2502 assert(!(pv < pv2 || pv2 < pv));
2503 }
2504}
2505
2506} // namespace n_dynamic_cast
2507
2508namespace n_map
2509{
2510
2511struct X
2512{
2513};
2514
2515void
2517{
2518 std::vector< shared_ptr<int> > vi;
2519
2520 {
2521 shared_ptr<int> pi1(new int);
2522 shared_ptr<int> pi2(new int);
2523 shared_ptr<int> pi3(new int);
2524
2525 vi.push_back(pi1);
2526 vi.push_back(pi1);
2527 vi.push_back(pi1);
2528 vi.push_back(pi2);
2529 vi.push_back(pi1);
2530 vi.push_back(pi2);
2531 vi.push_back(pi1);
2532 vi.push_back(pi3);
2533 vi.push_back(pi3);
2534 vi.push_back(pi2);
2535 vi.push_back(pi1);
2536 }
2537
2538 std::vector< shared_ptr<X> > vx;
2539
2540 {
2541 shared_ptr<X> px1(new X);
2542 shared_ptr<X> px2(new X);
2543 shared_ptr<X> px3(new X);
2544
2545 vx.push_back(px2);
2546 vx.push_back(px2);
2547 vx.push_back(px1);
2548 vx.push_back(px2);
2549 vx.push_back(px1);
2550 vx.push_back(px1);
2551 vx.push_back(px1);
2552 vx.push_back(px2);
2553 vx.push_back(px1);
2554 vx.push_back(px3);
2555 vx.push_back(px2);
2556 }
2557
2558 std::map< shared_ptr<void>, long > m;
2559
2560 {
2561 for(std::vector< shared_ptr<int> >::iterator i = vi.begin(); i != vi.end(); ++i)
2562 {
2563 ++m[*i];
2564 }
2565 }
2566
2567 {
2568 for(std::vector< shared_ptr<X> >::iterator i = vx.begin(); i != vx.end(); ++i)
2569 {
2570 ++m[*i];
2571 }
2572 }
2573
2574 {
2575 for(std::map< shared_ptr<void>, long >::iterator i = m.begin(); i != m.end(); ++i)
2576 {
2577 assert(i->first.use_count() == i->second + 1);
2578 }
2579 }
2580}
2581
2582} // namespace n_map
2583
2585{
2586
2587struct X
2588{
2589 X(): next() {}
2591};
2592
2593void
2595{
2596 shared_ptr<X> p(new X);
2597 p->next = shared_ptr<X>(new X);
2598 assert(!p->next->next);
2599 p = p->next;
2600 assert(!p->next);
2601}
2602
2603} // namespace n_transitive
2604
2605#if 0
2606namespace n_report_1
2607{
2608
2609class foo
2610{
2611public:
2612
2613 foo(): m_self(this)
2614 { }
2615
2616 void suicide()
2617 { m_self.reset(); }
2618
2619private:
2620 shared_ptr<foo> m_self;
2621};
2622
2623void
2624 test()
2625{
2626 foo * foo_ptr = new foo;
2627 foo_ptr->suicide();
2628}
2629
2630} // namespace n_report_1
2631#endif // 0
2632
2633// Test case by Per Kristensen
2634namespace n_report_2
2635{
2636
2637class foo
2638{
2639public:
2640
2642 {
2643 w = s;
2644 }
2645
2646private:
2647
2648 weak_ptr<foo> w;
2649};
2650
2652{
2653public:
2654
2655 deleter(): lock(0)
2656 {
2657 }
2658
2660 {
2661 assert(lock == 0);
2662 }
2663
2665 {
2666 ++lock;
2667 delete p;
2668 --lock;
2669 }
2670
2671private:
2672
2673 int lock;
2674};
2675
2676void
2678{
2679 shared_ptr<foo> s(new foo, deleter());
2680 s->setWeak(s);
2681 s.reset();
2682}
2683
2684} // namespace n_report_2
2685
2687{
2688
2689class file;
2690
2691shared_ptr<file> fopen(char const * name, char const * mode);
2692void
2693 fread(shared_ptr<file> f, void * data, long size);
2694
2696
2697void
2699{
2700 assert(file_instances == 0);
2701
2702 {
2703 shared_ptr<file> pf = fopen("name", "mode");
2704 assert(file_instances == 1);
2705 fread(pf, 0, 17041);
2706 }
2707
2708 assert(file_instances == 0);
2709}
2710
2711} // namespace n_spt_incomplete
2712
2714{
2715
2716class file
2717{
2718private:
2719 class impl;
2720 shared_ptr<impl> pimpl_;
2721
2722public:
2723
2724 file(char const * name, char const * mode);
2725
2726 // compiler generated members are fine and useful
2727
2728 void read(void * data, long size);
2729
2730 long total_size() const;
2731};
2732
2734
2735void
2737{
2738 assert(file_instances == 0);
2739
2740 {
2741 file f("name", "mode");
2742 assert(file_instances == 1);
2743 f.read(0, 152);
2744
2745 file f2(f);
2746 assert(file_instances == 1);
2747 f2.read(0, 894);
2748
2749 assert(f.total_size() == 152+894);
2750
2751 {
2752 file f3("name2", "mode2");
2753 assert(file_instances == 2);
2754 }
2755
2756 assert(file_instances == 1);
2757 }
2758
2759 assert(file_instances == 0);
2760}
2761
2762} // namespace n_spt_pimpl
2763
2765{
2766
2767class X
2768{
2769public:
2770
2771 virtual void f(int) = 0;
2772 virtual int g() = 0;
2773
2774protected:
2775
2776 virtual ~X() {}
2777};
2778
2780
2782
2783void
2785{
2786 assert(X_instances == 0);
2787
2788 {
2789 shared_ptr<X> px = createX();
2790
2791 assert(X_instances == 1);
2792
2793 px->f(18);
2794 px->f(152);
2795
2796 assert(px->g() == 170);
2797 }
2798
2799 assert(X_instances == 0);
2800}
2801
2802} // namespace n_spt_abstract
2803
2805{
2806
2808
2809class X
2810{
2811private:
2812 X()
2813 {
2814 ++X_instances;
2815 }
2816
2817 ~X()
2818 {
2819 --X_instances;
2820 }
2821
2822 class deleter;
2823 friend class deleter;
2824
2825 class deleter
2826 {
2827 public:
2828
2829 void operator()(X * p) { delete p; }
2830 };
2831
2832public:
2833
2835 {
2836 shared_ptr<X> px(new X, X::deleter());
2837 return px;
2838 }
2839};
2840
2841void
2843{
2844 assert(X_instances == 0);
2845
2846 {
2847 shared_ptr<X> px = X::create();
2848 assert(X_instances == 1);
2849 }
2850
2851 assert(X_instances == 0);
2852}
2853
2854} // namespace n_spt_preventing_delete
2855
2857{
2858
2860
2861struct X
2862{
2864 {
2865 ++X_instances;
2866 }
2867
2869 {
2870 --X_instances;
2871 }
2872};
2873
2874void
2876{
2877 assert(X_instances == 0);
2878
2879 #if 0
2880 {
2881 shared_ptr<X> px(new X[4], checked_array_deleter<X>());
2882 assert(X_instances == 4);
2883 }
2884 #endif // 0
2885
2886 assert(X_instances == 0);
2887}
2888
2889} // namespace n_spt_array
2890
2892{
2893
2894class X
2895{
2896public:
2897
2899 {
2900 }
2901
2902private:
2903 void operator delete(void *)
2904 {
2905 throw "n_spt_static::X::operator delete() called.";
2906 }
2907};
2908
2910{
2911 void operator()(void const *) const
2912 {
2913 }
2914};
2915
2916static X x;
2917
2918void
2920{
2921 shared_ptr<X> px(&x, null_deleter());
2922}
2923
2924} // namespace n_spt_static
2925
2927{
2928
2930
2931struct X
2932{
2933 long count;
2934
2935 X(): count(0)
2936 {
2937 ++X_instances;
2938 }
2939
2941 {
2942 --X_instances;
2943 }
2944};
2945
2946void
2948{
2949 ++p->count;
2950}
2951
2952void
2954{
2955 if(--p->count == 0) delete p;
2956}
2957
2958template< class T >
2960{
2961 void operator()(T * p)
2962 {
2963 if(p != 0) intrusive_ptr_release(p);
2964 }
2965};
2966
2968{
2969 if(p != 0) intrusive_ptr_add_ref(p);
2971 return px;
2972}
2973
2974void
2976{
2977 assert(X_instances == 0);
2978
2979 {
2980 X * p = new X;
2981 assert(X_instances == 1);
2982 assert(p->count == 0);
2984 assert(px.get() == p);
2985 assert(p->count == 1);
2986 shared_ptr<X> px2(px);
2987 assert(px2.get() == p);
2988 assert(p->count == 1);
2989 }
2990
2991 assert(X_instances == 0);
2992}
2993
2994} // namespace n_spt_intrusive
2995
2997{
2998
2999template< class T >
3001 : private shared_ptr<T>
3002{
3003private:
3004 typedef shared_ptr<T> base_type;
3005
3006public:
3007
3008 explicit another_ptr(T * p = 0): base_type(p)
3009 {
3010 }
3011
3012 void reset()
3013 {
3015 }
3016
3017 T * get() const
3018 {
3019 return base_type::get();
3020 }
3021};
3022
3024{
3025public:
3026
3027 virtual ~event_handler() {}
3028 virtual void begin() = 0;
3029 virtual void handle(int event) = 0;
3030 virtual void end() = 0;
3031};
3032
3036
3038 : public event_handler
3039{
3040public:
3041
3042 virtual void begin()
3043 {
3044 ++begin_called;
3045 }
3046
3047 virtual void handle(int event)
3048 {
3049 handle_called = event;
3050 }
3051
3052 virtual void end()
3053 {
3054 ++end_called;
3055 }
3056};
3057
3059{
3061 return p;
3062}
3063
3065
3066void
3068{
3069 p->begin();
3070 current_handler = p;
3071}
3072
3073void
3074 handle_event(int event)
3075{
3076 current_handler->handle(event);
3077}
3078
3079void
3081{
3082 current_handler->end();
3083 current_handler.reset();
3084}
3085
3086template< class P >
3088{
3089private:
3090 P p_;
3091
3092public:
3093
3094 smart_pointer_deleter(P const & p): p_(p)
3095 {
3096 }
3097
3098 void operator()(void const *)
3099 {
3100 p_.reset();
3101 }
3102};
3103
3104void
3106{
3108
3110
3111 p.reset();
3112
3113 assert(begin_called == 0);
3114
3116
3117 assert(begin_called == 1);
3118
3119 assert(handle_called == 0);
3120
3121 handle_event(17041);
3122
3123 assert(handle_called == 17041);
3124
3125 assert(end_called == 0);
3126
3128
3129 assert(end_called == 1);
3130}
3131
3132} // namespace n_spt_another_sp
3133
3134#if 0
3135namespace n_spt_shared_from_this
3136{
3137
3138class X
3139{
3140public:
3141
3142 virtual void f() = 0;
3143
3144protected:
3145
3146 ~X() {}
3147};
3148
3149class Y
3150{
3151public:
3152
3153 virtual shared_ptr<X> getX() = 0;
3154
3155protected:
3156
3157 ~Y() {}
3158};
3159
3160class impl
3161 : public X, public Y
3162{
3163private:
3164 weak_ptr<impl> weak_this;
3165
3166 impl(impl const &);
3167 impl & operator=(impl const &);
3168
3169 impl() {}
3170
3171public:
3172
3173 static shared_ptr<impl> create()
3174 {
3175 shared_ptr<impl> pi(new impl);
3176 pi->weak_this = pi;
3177 return pi;
3178 }
3179
3180 virtual void f() {}
3181
3182 virtual shared_ptr<X> getX()
3183 {
3184 shared_ptr<X> px = weak_this.lock();
3185 return px;
3186 }
3187};
3188
3189void
3190 test()
3191{
3192 shared_ptr<Y> py = impl::create();
3193 assert(py.get() != 0);
3194 assert(py.use_count() == 1);
3195
3196 shared_ptr<X> px = py->getX();
3197 assert(px.get() != 0);
3198 assert(py.use_count() == 2);
3199
3200 shared_ptr<Y> py2 = dynamic_pointer_cast<Y>(px);
3201 assert(py.get() == py2.get());
3202 assert(!(py < py2 || py2 < py));
3203 assert(py.use_count() == 3);
3204}
3205
3206} // namespace n_spt_shared_from_this
3207#endif // 0
3208
3209namespace n_spt_wrap
3210{
3211
3212void
3214{
3215}
3216
3217} // namespace n_spt_wrap
3218
3219int main()
3220{
3224 n_reset::test();
3227 n_swap::test();
3232
3233 n_map::test();
3234
3236 #if 0
3238 #endif // 0
3240
3249 //n_spt_shared_from_this::test();
3251
3252 return 0;
3253}
3254
3255namespace n_spt_incomplete
3256{
3257
3258class file
3259{
3260public:
3261
3263 {
3265 }
3266
3268 {
3269 assert(fread_called);
3271 }
3272
3274};
3275
3276shared_ptr<file> fopen(char const *, char const *)
3277{
3278 shared_ptr<file> pf(new file);
3279 return pf;
3280}
3281
3282void
3283 fread(shared_ptr<file> pf, void *, long)
3284{
3285 pf->fread_called = true;
3286}
3287
3288} // namespace n_spt_incomplete
3289
3290namespace n_spt_pimpl
3291{
3292
3294{
3295private:
3296 impl(impl const &);
3297 impl & operator=(impl const &);
3298
3299 long total_size_;
3300
3301public:
3302
3303 impl(char const *, char const *): total_size_(0)
3304 {
3306 }
3307
3309 {
3311 }
3312
3313 void read(void *, long size)
3314 {
3315 total_size_ += size;
3316 }
3317
3318 long total_size() const
3319 {
3320 return total_size_;
3321 }
3322};
3323
3324file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
3325{
3326}
3327
3328void
3329 file::read(void * data, long size)
3330{
3331 pimpl_->read(data, size);
3332}
3333
3335{
3336 return pimpl_->total_size();
3337}
3338
3339} // namespace n_spt_pimpl
3340
3341namespace n_spt_abstract
3342{
3343
3345 : public X
3346{
3347private:
3348 X_impl(X_impl const &);
3349 X_impl & operator=(X_impl const &);
3350
3351 int n_;
3352
3353public:
3354
3355 X_impl(): n_(0)
3356 {
3357 ++X_instances;
3358 }
3359
3360 virtual ~X_impl()
3361 {
3362 --X_instances;
3363 }
3364
3365 virtual void f(int n)
3366 {
3367 n_ += n;
3368 }
3369
3370 virtual int g()
3371 {
3372 return n_;
3373 }
3374};
3375
3377{
3378 shared_ptr<X> px(new X_impl);
3379 return px;
3380}
3381
3382} // namespace n_spt_abstract
void swap(shared_ptr< P > &)
shared_ptr< P > lock() const
void operator()(foo *p)
void setWeak(shared_ptr< foo > s)
virtual void f(int n)
virtual int g()=0
virtual void f(int)=0
virtual void handle(int event)=0
void read(void *, long size)
impl(char const *, char const *)
long total_size() const
file(char const *name, char const *mode)
void read(void *data, long size)
static shared_ptr< X > create()
P * get_pointer(shared_ptr< P > const &)
void swap(shared_ptr< P > &, shared_ptr< P > &)
void auto_ptr_assignment()
void conversion_assignment()
void copy_assignment()
incomplete * p0
void deleter2(int *p)
void pc0_test(T *p)
void weak_ptr_constructor()
void auto_ptr_constructor()
void deleter(int *p)
void pointer_constructor()
void copy_constructor()
void deleter_constructor()
void default_constructor()
void f(int &)
void test()
void deleter_reset()
void plain_reset()
void pointer_reset()
void deleter2(void *p)
incomplete * p0
void deleter(incomplete *)
void * deleted
void test()
shared_ptr< X > createX()
void handle_event(int event)
void install_event_handler(shared_ptr< event_handler > p)
another_ptr< event_handler > get_event_handler()
shared_ptr< event_handler > current_handler
void fread(shared_ptr< file > f, void *data, long size)
shared_ptr< file > fopen(char const *name, char const *mode)
shared_ptr< X > make_shared_from_intrusive(X *p)
void intrusive_ptr_release(X *p)
void intrusive_ptr_add_ref(X *p)
void test()
static long instances
static long instances
static long instances
static long instances
void operator()(incomplete *p)
static long instances
static long instances
void operator()(void const *) const
shared_ptr< X > next
int(* f2)(int)
int(* f3)(int, bool)
int main()