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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
| // stack standard header
#pragma once
#ifndef _STACK_
#define _STACK_
#include <yvals_core.h>
#if _STL_COMPILER_PREPROCESSOR
#include <deque>
#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new
_STD_BEGIN
// CLASS TEMPLATE stack
template <class _Ty, class _Container = deque<_Ty>>
class stack {
public:
using value_type = typename _Container::value_type;
using reference = typename _Container::reference;
using const_reference = typename _Container::const_reference;
using size_type = typename _Container::size_type;
using container_type = _Container;
static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");
stack() _NOEXCEPT_COND(is_nothrow_default_constructible_v<_Container>) : c() {} // strengthened
explicit stack(const _Container& _Cont) : c(_Cont) {}
explicit stack(_Container&& _Cont) _NOEXCEPT_COND(is_nothrow_move_constructible_v<_Container>) // strengthened
: c(_STD move(_Cont)) {}
template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
explicit stack(const _Alloc& _Al) _NOEXCEPT_COND(is_nothrow_constructible_v<_Container, const _Alloc&>)
: c(_Al) {} // strengthened
template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
stack(const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al) {}
template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
stack(_Container&& _Cont, const _Alloc& _Al)
_NOEXCEPT_COND(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
: c(_STD move(_Cont), _Al) {}
template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
stack(const stack& _Right, const _Alloc& _Al) : c(_Right.c, _Al) {}
template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
stack(stack&& _Right, const _Alloc& _Al)
_NOEXCEPT_COND(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
: c(_STD move(_Right.c), _Al) {}
_NODISCARD bool empty() const {
return c.empty();
}
_NODISCARD size_type size() const {
return c.size();
}
_NODISCARD reference top() {
return c.back();
}
_NODISCARD const_reference top() const {
return c.back();
}
void push(const value_type& _Val) {
c.push_back(_Val);
}
void push(value_type&& _Val) {
c.push_back(_STD move(_Val));
}
template <class... _Valty>
decltype(auto) emplace(_Valty&&... _Val) {
#if _HAS_CXX17
return c.emplace_back(_STD forward<_Valty>(_Val)...);
#else // ^^^ C++17 or newer / C++14 vvv
c.emplace_back(_STD forward<_Valty>(_Val)...);
#endif // _HAS_CXX17
}
void pop() {
c.pop_back();
}
void swap(stack& _Right) _NOEXCEPT_COND(_Is_nothrow_swappable<_Container>::value) {
_Swap_adl(c, _Right.c);
}
template <class _Ty, class _Container>
friend bool operator==(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
template <class _Ty, class _Container>
friend bool operator!=(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
template <class _Ty, class _Container>
friend bool operator<(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
template <class _Ty, class _Container>
friend bool operator>(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
template <class _Ty, class _Container>
friend bool operator<=(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
template <class _Ty, class _Container>
friend bool operator>=(const stack<_Ty, _Container>&, const stack<_Ty, _Container>&);
protected:
_Container c;
};
#if _HAS_CXX17
template <class _Container, enable_if_t<!_Is_allocator<_Container>::value, int> = 0>
stack(_Container)->stack<typename _Container::value_type, _Container>;
template <class _Container, class _Alloc,
enable_if_t<
conjunction_v<negation<_Is_allocator<_Container>>, _Is_allocator<_Alloc>, uses_allocator<_Container, _Alloc>>,
int> = 0>
stack(_Container, _Alloc)->stack<typename _Container::value_type, _Container>;
#endif // _HAS_CXX17
template <class _Ty, class _Container>
_NODISCARD bool operator==(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c == _Right.c;
}
template <class _Ty, class _Container>
_NODISCARD bool operator!=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c != _Right.c;
}
template <class _Ty, class _Container>
_NODISCARD bool operator<(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c < _Right.c;
}
template <class _Ty, class _Container>
_NODISCARD bool operator>(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c > _Right.c;
}
template <class _Ty, class _Container>
_NODISCARD bool operator<=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c <= _Right.c;
}
template <class _Ty, class _Container>
_NODISCARD bool operator>=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
return _Left.c >= _Right.c;
}
template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
void swap(stack<_Ty, _Container>& _Left, stack<_Ty, _Container>& _Right) _NOEXCEPT_COND(noexcept(_Left.swap(_Right))) {
_Left.swap(_Right);
}
template <class _Ty, class _Container, class _Alloc>
struct uses_allocator<stack<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
_STD_END
#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)
#endif // _STL_COMPILER_PREPROCESSOR
#endif // _STACK_
/*
* Copyright (c) by P.J. Plauger. All rights reserved.
* Consult your license regarding permissions and restrictions.
V6.50:0009 */ |
(
Сообщение от npanop_xx
