1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <memory>
11
12 // template <class Alloc>
13 // struct allocator_traits
14 // {
15 // template <class Ptr, class... Args>
16 // static void construct(allocator_type& a, Ptr p, Args&&... args);
17 // ...
18 // };
19
20 #include <memory>
21 #include <new>
22 #include <type_traits>
23 #include <cassert>
24
25 template <class T>
26 struct A
27 {
28 typedef T value_type;
29
30 };
31
32 int b_construct = 0;
33
34 template <class T>
35 struct B
36 {
37 typedef T value_type;
38
39 #ifndef _LIBCPP_HAS_NO_VARIADICS
40 template <class U, class ...Args>
constructB41 void construct(U* p, Args&& ...args)
42 {
43 ++b_construct;
44 ::new ((void*)p) U(std::forward<Args>(args)...);
45 }
46 #endif // _LIBCPP_HAS_NO_VARIADICS
47 };
48
49 struct A0
50 {
51 static int count;
A0A052 A0() {++count;}
53 };
54
55 int A0::count = 0;
56
57 struct A1
58 {
59 static int count;
A1A160 A1(char c)
61 {
62 assert(c == 'c');
63 ++count;
64 }
65 };
66
67 int A1::count = 0;
68
69 struct A2
70 {
71 static int count;
A2A272 A2(char c, int i)
73 {
74 assert(c == 'd');
75 assert(i == 5);
76 ++count;
77 }
78 };
79
80 int A2::count = 0;
81
main()82 int main()
83 {
84 {
85 A0::count = 0;
86 A<int> a;
87 std::aligned_storage<sizeof(A0)>::type a0;
88 assert(A0::count == 0);
89 std::allocator_traits<A<int> >::construct(a, (A0*)&a0);
90 assert(A0::count == 1);
91 }
92 {
93 A1::count = 0;
94 A<int> a;
95 std::aligned_storage<sizeof(A1)>::type a1;
96 assert(A1::count == 0);
97 std::allocator_traits<A<int> >::construct(a, (A1*)&a1, 'c');
98 assert(A1::count == 1);
99 }
100 {
101 A2::count = 0;
102 A<int> a;
103 std::aligned_storage<sizeof(A2)>::type a2;
104 assert(A2::count == 0);
105 std::allocator_traits<A<int> >::construct(a, (A2*)&a2, 'd', 5);
106 assert(A2::count == 1);
107 }
108 #ifndef _LIBCPP_HAS_NO_VARIADICS
109 {
110 A0::count = 0;
111 b_construct = 0;
112 B<int> b;
113 std::aligned_storage<sizeof(A0)>::type a0;
114 assert(A0::count == 0);
115 assert(b_construct == 0);
116 std::allocator_traits<B<int> >::construct(b, (A0*)&a0);
117 assert(A0::count == 1);
118 assert(b_construct == 1);
119 }
120 {
121 A1::count = 0;
122 b_construct = 0;
123 B<int> b;
124 std::aligned_storage<sizeof(A1)>::type a1;
125 assert(A1::count == 0);
126 assert(b_construct == 0);
127 std::allocator_traits<B<int> >::construct(b, (A1*)&a1, 'c');
128 assert(A1::count == 1);
129 assert(b_construct == 1);
130 }
131 {
132 A2::count = 0;
133 b_construct = 0;
134 B<int> b;
135 std::aligned_storage<sizeof(A2)>::type a2;
136 assert(A2::count == 0);
137 assert(b_construct == 0);
138 std::allocator_traits<B<int> >::construct(b, (A2*)&a2, 'd', 5);
139 assert(A2::count == 1);
140 assert(b_construct == 1);
141 }
142 #endif // _LIBCPP_HAS_NO_VARIADICS
143 }
144