From Jason Turner

[queue.defn]

C++14 → C++17 2.4 KB 27 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpm0jmgo2k/{from.md → to.md} +15 -8
tmp/tmpm0jmgo2k/{from.md → to.md} RENAMED
@@ -7,15 +7,16 @@ particular, `list` ([[list]]) and `deque` ([[deque]]) can be used.
7
  ``` cpp
8
  namespace std {
9
  template <class T, class Container = deque<T>>
10
  class queue {
11
  public:
12
- typedef typename Container::value_type value_type;
13
- typedef typename Container::reference reference;
14
- typedef typename Container::const_reference const_reference;
15
- typedef typename Container::size_type size_type;
16
- typedef Container container_type;
 
17
  protected:
18
  Container c;
19
 
20
  public:
21
  explicit queue(const Container&);
@@ -32,17 +33,23 @@ namespace std {
32
  const_reference front() const { return c.front(); }
33
  reference back() { return c.back(); }
34
  const_reference back() const { return c.back(); }
35
  void push(const value_type& x) { c.push_back(x); }
36
  void push(value_type&& x) { c.push_back(std::move(x)); }
37
- template <class... Args> void emplace(Args&&... args)
38
- { c.emplace_back(std::forward<Args>(args)...); }
39
  void pop() { c.pop_front(); }
40
- void swap(queue& q) noexcept(noexcept(swap(c, q.c)))
41
  { using std::swap; swap(c, q.c); }
42
  };
43
 
 
 
 
 
 
 
44
  template <class T, class Container>
45
  bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
46
  template <class T, class Container>
47
  bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
48
  template <class T, class Container>
 
7
  ``` cpp
8
  namespace std {
9
  template <class T, class Container = deque<T>>
10
  class queue {
11
  public:
12
+ using value_type = typename Container::value_type;
13
+ using reference = typename Container::reference;
14
+ using const_reference = typename Container::const_reference;
15
+ using size_type = typename Container::size_type;
16
+ using container_type = Container;
17
+
18
  protected:
19
  Container c;
20
 
21
  public:
22
  explicit queue(const Container&);
 
33
  const_reference front() const { return c.front(); }
34
  reference back() { return c.back(); }
35
  const_reference back() const { return c.back(); }
36
  void push(const value_type& x) { c.push_back(x); }
37
  void push(value_type&& x) { c.push_back(std::move(x)); }
38
+ template <class... Args>
39
+ reference emplace(Args&&... args) { return c.emplace_back(std::forward<Args>(args)...); }
40
  void pop() { c.pop_front(); }
41
+ void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
42
  { using std::swap; swap(c, q.c); }
43
  };
44
 
45
+ template<class Container>
46
+ queue(Container) -> queue<typename Container::value_type, Container>;
47
+
48
+ template<class Container, class Allocator>
49
+ queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
50
+
51
  template <class T, class Container>
52
  bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
53
  template <class T, class Container>
54
  bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
55
  template <class T, class Container>