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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
template <typename Type = int, int N = 10>
concept bool C3 = true;
template <typename Type>
concept bool ID()
{
return true;
}
template <typename Type>
concept bool IncAndDec()
{
return
requires(Type par)
{
++par; // `Type' variables/objects must
--par; // support pre- and postfix
par++; // increment and decrement
par--; // operators
};
}
template <typename Type>
concept bool ReturnTypes()
{
return
requires(Type par)
{
{ ++par } -> Type &; // prefix inc. returns a Type &
{ par[0] } -> char; // the index operator returns a char
};
}
template <typename Type>
concept bool MultiArgs()
{
return
requires(Type lhs, Type rhs)
{
{ lhs + rhs } -> Type;
{ lhs += rhs } -> Type &;
{ lhs.c_str() } -> char const *;
};
}
template <typename Type>
concept bool CombiOps()
{
return
requires(Type lhs, Type rhs)
{
{ lhs + rhs } -> Type;
{ lhs += rhs } -> Type &;
}
and
requires(Type lhs)
{
{ lhs.c_str() } -> char const *;
};
}
template <typename Type>
concept bool ValueType()
{
return
requires()
{
typename Type::value_type;
};
}
template <ValueType Type>
class Data
{
};
struct EnumStruct
{
enum value_type
{
VALUE
};
};
template <typename Type>
concept bool InputIterator()
{
return true;
}
template <typename Type>
concept bool OutputIterator()
{
return true;
}
template <typename Type>
concept bool ForwardIterator()
{
return
requires
{
requires InputIterator<Type>();
requires OutputIterator<Type>();
};
}
template <typename Type>
concept bool BidirectionalIterator()
{
return
requires
{
requires ForwardIterator<Type>();
requires IncAndDec<Type>();
};
}
template <typename Type>
concept bool RandomAccessIterator()
{
return
requires
{
requires BidirectionalIterator<Type>();
}
and
requires(Type lhs, Type rhs)
{
{ lhs + rhs };
{ lhs - rhs };
};
}
template <BidirectionalIterator Type>
struct Iterator
{
void fun();
};
template <RandomAccessIterator RAI>
void rSort(RAI begin, RAI end)
{}
int main()
{
// Data<EnumStruct> data;
Iterator<int> iter;
iter = iter;
rSort(10, 20);
iter.fun();
}
|
