1/*
2Copyright 2012-2015 Glen Joseph Fernandes
3(glenjofe@gmail.com)
4
5Distributed under the Boost Software License, Version 1.0.
6(http://www.boost.org/LICENSE_1_0.txt)
7*/
8#include <boost/config.hpp>
9#if !defined(BOOST_NO_CXX11_ALLOCATOR)
10#include <boost/core/lightweight_test.hpp>
11#include <boost/smart_ptr/make_shared.hpp>
12
13struct allow { };
14
15template<class T = void>
16struct creator {
17 typedef T value_type;
18
19 template<class U>
20 struct rebind {
21 typedef creator<U> other;
22 };
23
24 creator() { }
25
26 template<class U>
27 creator(const creator<U>&) { }
28
29 T* allocate(std::size_t size) {
30 return static_cast<T*>(::operator new(sizeof(T) * size));
31 }
32
33 void deallocate(T* ptr, std::size_t) {
34 ::operator delete(ptr);
35 }
36
37 template<class U>
38 void construct(U* ptr) {
39 ::new(static_cast<void*>(ptr)) U(allow());
40 }
41
42 template<class U>
43 void destroy(U* ptr) {
44 ptr->~U();
45 }
46
47};
48
49template<class T, class U>
50inline bool
51operator==(const creator<T>&, const creator<U>&)
52{
53 return true;
54}
55
56template<class T, class U>
57inline bool
58operator!=(const creator<T>&, const creator<U>&)
59{
60 return false;
61}
62
63class type {
64public:
65 static unsigned instances;
66
67 explicit type(allow) {
68 ++instances;
69 }
70
71 ~type() {
72 --instances;
73 }
74
75private:
76 type(const type&);
77 type& operator=(const type&);
78};
79
80unsigned type::instances = 0;
81
82int main()
83{
84 {
85 boost::shared_ptr<type[]> result =
86 boost::allocate_shared<type[]>(allocator: creator<type>(), count: 3);
87 BOOST_TEST(result.get() != 0);
88 BOOST_TEST(result.use_count() == 1);
89 BOOST_TEST(type::instances == 3);
90 result.reset();
91 BOOST_TEST(type::instances == 0);
92 }
93 {
94 boost::shared_ptr<type[3]> result =
95 boost::allocate_shared<type[3]>(allocator: creator<type>());
96 BOOST_TEST(result.get() != 0);
97 BOOST_TEST(result.use_count() == 1);
98 BOOST_TEST(type::instances == 3);
99 result.reset();
100 BOOST_TEST(type::instances == 0);
101 }
102 {
103 boost::shared_ptr<type[][2]> result =
104 boost::allocate_shared<type[][2]>(allocator: creator<>(), count: 2);
105 BOOST_TEST(result.get() != 0);
106 BOOST_TEST(result.use_count() == 1);
107 BOOST_TEST(type::instances == 4);
108 result.reset();
109 BOOST_TEST(type::instances == 0);
110 }
111 {
112 boost::shared_ptr<type[2][2]> result =
113 boost::allocate_shared<type[2][2]>(allocator: creator<>());
114 BOOST_TEST(result.get() != 0);
115 BOOST_TEST(result.use_count() == 1);
116 BOOST_TEST(type::instances == 4);
117 result.reset();
118 BOOST_TEST(type::instances == 0);
119 }
120 {
121 boost::shared_ptr<const type[]> result =
122 boost::allocate_shared<const type[]>(allocator: creator<>(), count: 3);
123 BOOST_TEST(result.get() != 0);
124 BOOST_TEST(result.use_count() == 1);
125 BOOST_TEST(type::instances == 3);
126 result.reset();
127 BOOST_TEST(type::instances == 0);
128 }
129 {
130 boost::shared_ptr<const type[3]> result =
131 boost::allocate_shared<const type[3]>(allocator: creator<>());
132 BOOST_TEST(result.get() != 0);
133 BOOST_TEST(result.use_count() == 1);
134 BOOST_TEST(type::instances == 3);
135 result.reset();
136 BOOST_TEST(type::instances == 0);
137 }
138 {
139 boost::shared_ptr<const type[][2]> result =
140 boost::allocate_shared<const type[][2]>(allocator: creator<>(), count: 2);
141 BOOST_TEST(result.get() != 0);
142 BOOST_TEST(result.use_count() == 1);
143 BOOST_TEST(type::instances == 4);
144 result.reset();
145 BOOST_TEST(type::instances == 0);
146 }
147 {
148 boost::shared_ptr<const type[2][2]> result =
149 boost::allocate_shared<const type[2][2]>(allocator: creator<>());
150 BOOST_TEST(result.get() != 0);
151 BOOST_TEST(result.use_count() == 1);
152 BOOST_TEST(type::instances == 4);
153 result.reset();
154 BOOST_TEST(type::instances == 0);
155 }
156 return boost::report_errors();
157}
158#else
159int main()
160{
161 return 0;
162}
163#endif
164

source code of boost/libs/smart_ptr/test/allocate_shared_array_construct_test.cpp