1+ #pragma once
2+ #include " array.hpp"
3+ #include < algorithm>
4+ // 类模板std::array<T,N>的成员函数及一些非成员函数的定义
5+ template <typename T, std::size_t N>
6+ user::array<T, N>::array(std::initializer_list<T> ilist) : _elem{} {
7+ // 指明我们要定义的函数是user::array<T,N>的成员array
8+ std::size_t i {0 };
9+ for (auto item : ilist) {
10+ _elem[i++] = item;
11+ if (i == N) // 防止ilist长度超过N，避免数组越界
12+ break ;
13+ } // 若ilist长度不足N，那么_elem后面的部分保留初值列中的初始化值，即0
14+ };
15+ template <typename T, std::size_t N>
16+ user::array<T, N>::array(const array &arr) {
17+ for (std::size_t i = 0 ; i < N; i++)
18+ _elem[i] = arr._elem [i];
19+ }
20+ template <typename T, std::size_t N>
21+ auto user::array<T, N>::operator =(const array &arr) -> array& {
22+ // auto占位，->后接返回类型，编译器将会自行推导auto意味着什么
23+ if (this == &arr) // 防止自我赋值
24+ return *this ;
25+ for (std::size_t i = 0 ; i < N; i++)
26+ _elem[i] = arr._elem [i];
27+ return *this ;
28+ }
29+ template <typename T, std::size_t N>
30+ constexpr T& user::array<T, N>::at(std::size_t pos) {
31+ if (pos >= N) // 本来应该有异常抛出机制，但是我们还没学，所以先这样湊合下
32+ pos = N - 1 ;
33+ return _elem[pos];
34+ }
35+ template <typename T, std::size_t N>
36+ constexpr const T& user::array<T, N>::at(std::size_t pos)const {
37+ if (pos >= N)
38+ pos = N - 1 ;
39+ return _elem[pos];
40+ }
41+ template <typename T, std::size_t N>
42+ constexpr T& user::array<T, N>::operator [](std::size_t pos) {
43+ return _elem[pos];
44+ }
45+ template <typename T, std::size_t N>
46+ constexpr const T& user::array<T, N>::operator [](std::size_t pos)const {
47+ return _elem[pos];
48+ }
49+ template <typename T, std::size_t N>
50+ void user::array<T, N>::fill(const T &val) {
51+ for (std::size_t i = 0 ; i < N; i++)
52+ _elem[i] = val;
53+ }
54+ template <typename T, std::size_t N>
55+ constexpr bool user::operator <(
56+ const array<T, N> &lhs, const array<T, N> &rhs
57+ ) {
58+ return std::lexicographical_compare (
59+ lhs._elem , lhs._elem + N,
60+ rhs._elem , rhs._elem + N
61+ );
62+ }
63+ template <typename T, std::size_t N>
64+ constexpr bool user::operator >(
65+ const array<T, N> &lhs, const array<T, N> &rhs
66+ ) {
67+ return rhs < lhs;
68+ }
69+ template <typename T, std::size_t N>
70+ constexpr bool user::operator <=(
71+ const array<T, N> &lhs, const array<T, N> &rhs
72+ ) {
73+ return !(rhs < lhs);
74+ }
75+ template <typename T, std::size_t N>
76+ constexpr bool user::operator >=(
77+ const array<T, N> &lhs, const array<T, N> &rhs
78+ ) {
79+ return !(lhs < rhs);
80+ }
81+ template <typename T, std::size_t N>
82+ constexpr bool user::operator ==(
83+ const array<T, N> &lhs, const array<T, N> &rhs
84+ ) {
85+ return !(lhs != rhs);
86+ }
87+ template <typename T, std::size_t N>
88+ constexpr bool user::operator !=(
89+ const array<T, N> &lhs, const array<T, N> &rhs
90+ ) {
91+ return lhs < rhs || rhs < lhs;
92+ }
93+ template <std::size_t I, typename T, std::size_t N>
94+ T& user::get (array<T, N> &arr) {
95+ return arr._elem [I];
96+ }
97+ template <std::size_t I, typename T, std::size_t N>
98+ const T& user::get (const array<T, N> &arr) {
99+ return arr._elem [I];
100+ }
101+ template <typename T, std::size_t N> // 类模板参数，用来指定user::array<T,N>
102+ template <std::size_t M> // 函数模板参数，用来指定函数参数user::array<T,M>&
103+ void user::array<T, N>::swap(array<T, M> &arr) {
104+ constexpr std::size_t minlen {std::min (N, M)};
105+ for (std::size_t i = 0 ; i < minlen; i++)
106+ std::swap (_elem[i], arr._elem [i]);
107+ }
108+ template <typename T, std::size_t N, std::size_t M>
109+ void user::swap (array<T, N> &lhs, array<T, M> &rhs) {
110+ constexpr std::size_t minlen {std::min (N, M)}; // 这个结果将在编译时求出
111+ for (std::size_t i = 0 ; i < minlen; i++)
112+ std::swap (lhs._elem [i], rhs._elem [i]); // 可以访问私有成员
113+ }
114+ // 类模板特化std::array<bool,N>的成员函数及部分相关非成员函数的定义
115+ template <std::size_t N>
116+ user::array<bool , N>::array(std::initializer_list<bool > ilist) : _elem {} {
117+ std::size_t i {0 };
118+ for (auto item : ilist) {
119+ _elem[i++] = item; // std::bitset支持这样的赋值
120+ if (i == N) // 防止ilist长度超过N，避免数组越界
121+ break ;
122+ } // 若ilist长度不足N，那么_elem后面的部分保留初值列中的初始化值，即0
123+ }
124+ template <std::size_t N>
125+ user::array<bool , N>::array(const array &arr) {
126+ for (std::size_t i = 0 ; i < N; i++)
127+ _elem[i] = arr._elem [i];
128+ }
129+ template <std::size_t N>
130+ auto user::array<bool , N>::operator =(const array &arr) -> array& {
131+ // auto占位，->后接返回类型，编译器将会自行推导auto意味着什么
132+ if (this == &arr) // 防止自我赋值
133+ return *this ;
134+ for (std::size_t i = 0 ; i < N; i++)
135+ _elem[i] = arr._elem [i];
136+ return *this ;
137+ }
138+ template <std::size_t N>
139+ constexpr bool & user::array<bool , N>::at(std::size_t pos) {
140+ if (pos >= N)
141+ pos = N - 1 ;
142+ return _elem[pos];
143+ }
144+ template <std::size_t N>
145+ constexpr const bool & user::array<bool , N>::at(std::size_t pos)const {
146+ if (pos >= N)
147+ pos = N - 1 ;
148+ return _elem[pos];
149+ }
150+ template <std::size_t N>
151+ constexpr bool & user::array<bool , N>::operator [](std::size_t pos) {
152+ return _elem[pos];
153+ }
154+ template <std::size_t N>
155+ constexpr const bool & user::array<bool , N>::operator [](std::size_t pos)const {
156+ return _elem[pos];
157+ }
158+ template <std::size_t N>
159+ void user::array<bool , N>::fill(bool val) {
160+ for (std::size_t i = 0 ; i < N; i++)
161+ _elem[i] = val;
162+ }
163+ // 比较运算符和get函数均无需再重载
164+ template <std::size_t N, std::size_t M>
165+ void user::swap (array<bool , N> &lhs, array<bool , M> &rhs) {
166+ constexpr std::size_t minlen {std::min (N, M)};
167+ for (std::size_t i = 0 ; i < minlen; i++)
168+ std::swap (lhs._elem [i], rhs._elem [i]);
169+ }
170+ template <std::size_t N> // 类模板参数
171+ template <std::size_t M> // 函数模板参数
172+ void user::array<bool , N>::swap(array<bool , M> &arr) {
173+ constexpr std::size_t minlen {std::min (N, M)};
174+ for (std::size_t i = 0 ; i < minlen; i++)
175+ std::swap (_elem[i], arr._elem [i]);
176+ }
0 commit comments