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
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <memory>
// template <class T, class ...Args>
// constexpr T* construct_at(T* location, Args&& ...args);
#include <memory>
#include <cassert>
#include <utility>
#include "test_iterators.h"
struct Foo {
constexpr Foo() { }
constexpr Foo(int a, char b, double c) : a_(a), b_(b), c_(c) { }
constexpr Foo(int a, char b, double c, int* count) : Foo(a, b, c) { *count += 1; }
constexpr bool operator==(Foo const& other) const {
return a_ == other.a_ && b_ == other.b_ && c_ == other.c_;
}
private:
int a_;
char b_;
double c_;
};
struct Counted {
int& count_;
constexpr Counted(int& count) : count_(count) { ++count; }
constexpr Counted(Counted const& that) : count_(that.count_) { ++count_; }
constexpr ~Counted() { --count_; }
};
constexpr bool test()
{
{
int i = 99;
int* res = std::construct_at(&i);
assert(res == &i);
assert(*res == 0);
}
{
int i = 0;
int* res = std::construct_at(&i, 42);
assert(res == &i);
assert(*res == 42);
}
{
Foo foo = {};
int count = 0;
Foo* res = std::construct_at(&foo, 42, 'x', 123.89, &count);
assert(res == &foo);
assert(*res == Foo(42, 'x', 123.89));
assert(count == 1);
}
{
std::allocator<Counted> a;
Counted* p = a.allocate(2);
int count = 0;
std::construct_at(p, count);
assert(count == 1);
std::construct_at(p+1, count);
assert(count == 2);
(p+1)->~Counted();
assert(count == 1);
p->~Counted();
assert(count == 0);
a.deallocate(p, 2);
}
{
std::allocator<Counted const> a;
Counted const* p = a.allocate(2);
int count = 0;
std::construct_at(p, count);
assert(count == 1);
std::construct_at(p+1, count);
assert(count == 2);
(p+1)->~Counted();
assert(count == 1);
p->~Counted();
assert(count == 0);
a.deallocate(p, 2);
}
return true;
}
template <class ...Args, class = decltype(std::construct_at(std::declval<Args>()...))>
constexpr bool can_construct_at(Args&&...) { return true; }
template <class ...Args>
constexpr bool can_construct_at(...) { return false; }
// Check that SFINAE works.
static_assert( can_construct_at((int*)nullptr, 42));
static_assert( can_construct_at((Foo*)nullptr, 1, '2', 3.0));
static_assert(!can_construct_at((Foo*)nullptr, 1, '2'));
static_assert(!can_construct_at((Foo*)nullptr, 1, '2', 3.0, 4));
static_assert(!can_construct_at(nullptr, 1, '2', 3.0));
static_assert(!can_construct_at((int*)nullptr, 1, '2', 3.0));
static_assert(!can_construct_at(contiguous_iterator<Foo*>(), 1, '2', 3.0));
// Can't construct function pointers.
static_assert(!can_construct_at((int(*)())nullptr));
static_assert(!can_construct_at((int(*)())nullptr, nullptr));
int main(int, char**)
{
test();
static_assert(test());
return 0;
}
|
