blob: 0acd37d69d3820c885dbece472a24ac5ef42de91 (
plain)
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
|
#ifndef ARRAY_H
#define ARRAY_H
#include <utility>
#include <algorithm>
#include <stdexcept>
#undef SOLVED_2
#define SOLVED_2
namespace Ti
{
template<typename T, std::size_t N>
struct array
{
typedef T& reference;
typedef const T& const_reference;
typedef T* iterator;
typedef const T* const_iterator;
typedef std::size_t size_type;
static_assert(N != 0, "array<T, 0> not allowed");
void fill(const T& u)
{
std::fill_n(begin(), N, u);
}
void swap(array<T,N> & other)
{
std::swap_ranges(begin(), end(), other.begin());
}
iterator begin()
{
return m_data;
}
const_iterator begin() const
{
return m_data;
}
iterator end()
{
return m_data + N;
}
const_iterator end() const
{
return m_data + N;
}
size_type size() const
{
return N;
}
size_type max_size() const
{
return N;
}
bool empty() const
{
return false; /* size() == 0 */
}
reference operator[](size_type n)
{
return m_data[n];
}
const_reference operator[](size_type n) const
{
return m_data[n];
}
reference at(size_type n)
{
if (n >= N)
throw std::out_of_range("array::at");
return m_data[n];
}
const_reference at(size_type n) const
{
if (n >= N)
throw std::out_of_range("array::at");
return m_data[n];
}
T* data()
{
return m_data;
}
private:
T m_data[N];
};
/* std::move returns lvalue as rvalue */
template<typename T, std::size_t N>
array<T, N>&& make_array()
{
return std::move(array<T, N>());
}
} // namespace
#endif
/* vim: set et sw=2 ts=2: */
|
