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
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// <functional>
// template<class R, class ...Args>
// function(R(*)(Args...)) -> function<R(Args...)>;
// UNSUPPORTED: c++03, c++11, c++14
#include <functional>
#include <type_traits>
#include "test_macros.h"
struct R { };
struct A1 { };
struct A2 { };
struct A3 { };
R f0() { return {}; }
R f1(A1) { return {}; }
R f2(A1, A2) { return {}; }
R f3(A1, A2, A3) { return {}; }
R f4(A1 = {}) { return {}; }
int main(int, char**) {
{
// implicit
std::function a = f0;
ASSERT_SAME_TYPE(decltype(a), std::function<R()>);
std::function b = &f0;
ASSERT_SAME_TYPE(decltype(b), std::function<R()>);
// explicit
std::function c{f0};
ASSERT_SAME_TYPE(decltype(c), std::function<R()>);
std::function d{&f0};
ASSERT_SAME_TYPE(decltype(d), std::function<R()>);
}
{
// implicit
std::function a = f1;
ASSERT_SAME_TYPE(decltype(a), std::function<R(A1)>);
std::function b = &f1;
ASSERT_SAME_TYPE(decltype(b), std::function<R(A1)>);
// explicit
std::function c{f1};
ASSERT_SAME_TYPE(decltype(c), std::function<R(A1)>);
std::function d{&f1};
ASSERT_SAME_TYPE(decltype(d), std::function<R(A1)>);
}
{
// implicit
std::function a = f2;
ASSERT_SAME_TYPE(decltype(a), std::function<R(A1, A2)>);
std::function b = &f2;
ASSERT_SAME_TYPE(decltype(b), std::function<R(A1, A2)>);
// explicit
std::function c{f2};
ASSERT_SAME_TYPE(decltype(c), std::function<R(A1, A2)>);
std::function d{&f2};
ASSERT_SAME_TYPE(decltype(d), std::function<R(A1, A2)>);
}
{
// implicit
std::function a = f3;
ASSERT_SAME_TYPE(decltype(a), std::function<R(A1, A2, A3)>);
std::function b = &f3;
ASSERT_SAME_TYPE(decltype(b), std::function<R(A1, A2, A3)>);
// explicit
std::function c{f3};
ASSERT_SAME_TYPE(decltype(c), std::function<R(A1, A2, A3)>);
std::function d{&f3};
ASSERT_SAME_TYPE(decltype(d), std::function<R(A1, A2, A3)>);
}
// Make sure defaulted arguments don't mess up the deduction
{
// implicit
std::function a = f4;
ASSERT_SAME_TYPE(decltype(a), std::function<R(A1)>);
std::function b = &f4;
ASSERT_SAME_TYPE(decltype(b), std::function<R(A1)>);
// explicit
std::function c{f4};
ASSERT_SAME_TYPE(decltype(c), std::function<R(A1)>);
std::function d{&f4};
ASSERT_SAME_TYPE(decltype(d), std::function<R(A1)>);
}
return 0;
}
|
