摘要：在這篇文章裡，將從各個角度介紹下std::array的用法，希望能帶來一些啟發。

td::array是在C++11標準中增加的STL容器，它的設計目的是提供與原生陣列類似的功能與效能。也正因此，使得std::array有很多與其他容器不同的特殊之處，比如：std::array的元素是直接存放在例項內部，而不是在堆上分配空間；std::array的大小必須在編譯期確定；std::array的建構函式、解構函式和賦值操作符都是編譯器隱式宣告的……這讓很多用慣了std::vector這類容器的程式設計師不習慣，覺得std::array不好用。
但實際上，std::array的威力很可能被低估了。在這篇文章裡，我會從各個角度介紹下std::array的用法，希望能帶來一些啟發。

本文的程式碼都在C++17環境下編譯執行。當前主流的g++版本已經能支援C++17標準，但是很多版本（如gcc 7.3）的C++17特性不是預設開啟的，需要手工新增編譯選項-std=c++17。

自動推導陣列大小

很多專案中都會有類似這樣的全域性陣列作為配置引數：

uint32_t g_cfgPara[] = {1,2,5,6,7,9,3,4};

當程式設計師想要使用std::array替換原生陣列時，麻煩來了：

array<uint32_t,8> g_cfgPara = {1,4}; // 注意模板引數“8”

程式設計師不得不手工寫出陣列的大小，因為它是std::array的模板引數之一。如果這個陣列很長，或者經常增刪成員，對陣列大小的維護工作恐怕不是那麼愉快的。有人要抱怨了：std::array的宣告用起來還沒有原生陣列方便，選它幹啥？

array g_cfgPara = {1,4}; // 陣列大小與成員型別自動推導

看起來很美好，但很快就會有人發現不對頭：陣列元素的型別是什麼？還是std::uint32_t嗎？
有人開始嘗試只提供元素型別引數，讓編譯器自動推導長度，遺憾的是，它不會奏效。

array<uint32_t> g_cfgPara = {1,4}; // 編譯錯誤

好吧，暫時看起來std::array是不能像原生陣列那樣宣告。下面我們來解決這個問題。

用函式返回std::array

問題的解決思路是用函式模板來替代類模板——因為C++允許函式模板的部分引數自動推導——我們可以聯想到std::make_pair、std::make_tuple這類輔助函式。巧的是，C++標準真的在TS v2試驗版本中推出過std::make_array，然而因為類模板引數推導的問世，這個工具函式後來被刪掉了。

template<typename R,typename P,size_t N,size_t... I>
constexpr array<R,N> to_array_impl(P (&a)[N],std::index_sequence<I...>) noexcept
{
 return { {a[I]...} };
}

template<typename T,size_t N>
constexpr auto to_array(T (&a)[N]) noexcept
{
 return to_array_impl<std::remove_cv_t<T>,T,N>(a,std::make_index_sequence<N>{});
}

template<typename R,N> to_array_impl(P (&&a)[N],std::index_sequence<I...>) noexcept
{
 return { {move(a[I])...} };
}

template<typename T,size_t N>
constexpr auto to_array(T (&&a)[N]) noexcept
{
 return to_array_impl<std::remove_cv_t<T>,N>(move(a),std::make_index_sequence<N>{});
}

細心的朋友會注意到，上面這個定義與C++20的推薦實現有所差異，這是有目的的。稍後我會解釋這麼幹的原因。

現在讓我們嘗試下用新方法解決老問題：

auto g_cfgPara = to_array<int>({1,4}); // 型別不是uint32_t？

不對啊，為什麼元素型別不是原來的std::uint32_t？
這是因為模板引數推導對std::initializer_list的元素拒絕隱式轉換，如果你把to_array的模板引數從int改為uint32_t，會得到如下編譯錯誤：

D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:51:61: error: no matching function for call to 'to_array<uint32_t>(<brace-enclosed initializer list>)'
 auto g_cfgPara = to_array<uint32_t>({1,4});
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:34:16: note: candidate: 'template<class T,long long unsigned int N> constexpr auto to_array(T (&)[N])'
 constexpr auto to_array(T (&a)[N]) noexcept
  ^~~~~~~~
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:34:16: note: template argument deduction/substitution failed:
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:51:61: note: mismatched types 'unsigned int' and 'int'
 auto g_cfgPara = to_array<uint32_t>({1,4});
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:46:16: note: candidate: 'template<class T,long long unsigned int N> constexpr auto to_array(T (&&)[N])'
 constexpr auto to_array(T (&&a)[N]) noexcept
  ^~~~~~~~
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:46:16: note: template argument deduction/substitution failed:
D:\Work\Source_Codes\MyProgram\VSCode\main.cpp:51:61: note: mismatched types 'unsigned int' and 'int'

Hoho，有點慘是不，繞了一圈回到原點，還是不能強制指定型別。
這個時候，之前針對std::array做的修改派上用場了：我給to_array_impl增加了一個模板引數，讓輸入陣列的元素和返回std::array的元素用不同的型別引數表示，這樣就給型別轉換帶來了可能。為了實現轉換到指定的型別，我們還需要新增兩個工具函式：

template<typename R,size_t N>
constexpr auto to_typed_array(P (&a)[N]) noexcept
{
 return to_array_impl<R,P,size_t N>
constexpr auto to_typed_array(P (&&a)[N]) noexcept
{
 return to_array_impl<R,std::make_index_sequence<N>{});
}

這兩個函式和to_array的區別是：它帶有3個模板引數：第一個是要返回的std::array的元素型別，後兩個和to_array一樣。這樣我們就可以通過指定第一個引數來實現定製std::array元素型別了。

auto g_cfgPara = to_typed_array<uint32_t>({1,4}); // 自動把元素轉換成uint32_t

這段程式碼可以編譯通過和執行，但是卻有型別轉換的編譯告警。當然，如果你膽子夠大，可以在to_array_impl函式中放一個static_cast來消除告警。但是編譯告警提示了我們一個不能忽視的問題：如果萬一輸入的數值溢位了怎麼辦？

auto g_a = to_typed_array<uint8_t>({256,-1}); // 數字超出uint8_t範圍

編譯器還是一樣的會讓你編譯通過和執行，g_a中的兩個元素的值將分別為0和255。如果你不明白為什麼這兩個值和入參不一樣，你該複習下整型溢位與迴繞的知識了。
顯然，這個方案還不完美。但我們可以繼續改進。

編譯期字面量數值合法性校驗

首先能想到的做法是在to_array_impl函式中放入一個if判斷之類的語句，對於超出目標數值範圍的輸入丟擲異常或者做其他處理。這當然可行，但要注意的是這些工具函式是可以在執行期呼叫的，對於這種常用的基礎函式來說，效能至關重要。一旦在裡面加入了錯誤判斷，意味著執行時的每一次呼叫效能都會下降。

理想的設計是：只有在編譯期生成的陣列才進行校驗，並且報編譯錯誤。但執行時呼叫函式時不要加入任何校驗。

可惜的是，至少在C++20之前，沒有辦法指定函式只允許在編譯期執行[2]。那有沒有其他手段呢？

熟悉C++的人知道：C++的編譯期處理大多可以用模板的trick來完成——因為模板引數一定是編譯期常量。因此我們可以用模板引數來完成編譯期處理——只要把陣列元素全部作為模板的非型別引數就可以了。當然，這裡有個問題：模板的非型別引數的型別怎麼確定？正好C++17提供了auto模板引數的功能，可以派上用場：

template<typename T>
constexpr void CheckIntRanges() noexcept {} // 用於終結遞迴

template<typename T,auto M,auto... N>
constexpr void CheckIntRanges() noexcept
{
 // 防止無符號與有符號比較
 static_assert(!((std::numeric_limits<T>::min() >= 0) && (M < 0)));

 // 範圍校驗
 static_assert((M >= std::numeric_limits<T>::min()) && 
   (M <= std::numeric_limits<T>::max()));
 
 CheckIntRanges<T,N...>();
}

template<typename T,auto... N>
constexpr auto DeclareArray() noexcept
{
 CheckIntRanges<T,N...>();
 array<T,sizeof...(N)> a{{static_cast<T>(N)...}};
 return a;
};

注意這個函式中，所有的校驗都通過static_assert完成。這就保證了校驗一定只會發生在編譯期，不會帶來任何執行時開銷。
DeclareArray的使用方法如下：

constexpr auto a1 = DeclareArray<uint8_t,1,4,255>(); // 宣告一個std::array<uint8_t,5>，元素分別為1,255
static_assert(a1.size() == 5);
static_assert(a1[3] == 4);
auto a2 = DeclareArray<uint8_t,-1>(); // 編譯錯誤，-1超出uint8_t範圍
auto a3 = DeclareArray<uint16_t,65536>(); // 編譯錯誤，65536超出uint16_t範圍

這裡有一個誤區需要說明：有些人可能會把DeclareArray宣告成這樣：

template<typename T,T... N> // 注意N的型別為T
constexpr auto DeclareArray() noexcept

這麼做的話，會發現對數值的校驗總是能通過——因為模板引數在進入校驗之前就已經被轉換為T型別了。如果你的編譯器不支援C++17的auto模板引數，那麼可以通過使用std::uint64_t、std::int64_t這些“最大”的型別來間接達到目的。

另一點要說明的是，C++對於非型別模板引數的允許型別存在限制，DeclareArray的方法只能用於陣列元素為基本型別的場景（至少在C++20以前如此）。但是這也足夠了。如果陣列的元素是自定義型別，就可以通過自定義的建構函式等方法來控制型別轉換。

如果你看到這裡覺得有點意思了，那就對了，後面還有更過癮的。

編譯期生成陣列

C++11中新增的constexpr修飾符可以在編譯期完成很多計算工作。但是一般constexpr函式只能返回單個值，一旦你想用它返回一串物件的集合，就會遇到麻煩：STL容器都有動態記憶體申請功能，不能作為編譯期常量（至少在C++20之前如此）；而原生陣列作為返回值會退化為指標，導致返回懸空的指標。即使是返回陣列的引用也是不行的，會產生懸空的引用。

constexpr int* Func() noexcept
{
 int a[] = {1,4};
 return a; // 嚴重錯誤！返回區域性物件的地址
}

直到std::array的出現，這個問題才得到較好解決。std::array既可以作為編譯期常量，又可以作為函式返回值。於是，它成為了編譯期返回集合資料的首選。

在上面to_array等工具函式的實現中，我們已經見過了編譯期返回陣列是怎麼做的。這裡我們再大膽一點，寫一個編譯期氣泡排序：

template<typename T,size_t N>
constexpr std::array<T,N> Sort(const std::array<T,N>& numbers) noexcept
{
 std::array<T,N> sorted(numbers);
 for (int i = 0; i < N; ++i) {
 for (int j = N - 1; j > i; --j) {
  if (sorted[j] < sorted[j - 1]) {
  T t = sorted[j];
  sorted[j] = sorted[j - 1];
  sorted[j - 1] = t;
  }
 }
 }
 return sorted;
}

int main()
{
 constexpr std::array<int,4> before{4,1};
 constexpr std::array<int,4> after = Sort(before);
 static_assert(after[0] == 1);
 static_assert(after[1] == 2);
 static_assert(after[2] == 3);
 static_assert(after[3] == 4);
 return 0;
}

因為整個排序演算法都是在編譯期完成，所以我們沒有必要太關注氣泡排序的效率問題。當然，只要你願意，完全可以寫出一個編譯期快速排序——畢竟constexpr函式也可以在執行期使用，不好說會不會有哪個憨憨在執行時呼叫它。

在編寫constexpr函式時，有兩點需要注意：

1.constexpr函式中不能呼叫非constexpr函式。因此在交換元素時不能用std::swap，排序也不能直接呼叫std::sort。

2. 傳入的陣列是constexpr的，因此引數型別必須加上const，也不能對資料進行就地排序，必須返回一個新的陣列。

雖然限制很多，但編譯期演算法的好處也是巨大的：如果運算中有陣列越界等未定義行為，編譯將會失敗。相比起執行時的測試，編譯期測試constexpr函式能有效的提前攔截問題。而且只要編譯通過就意味著測試通過，比起額外跑白盒測試用例方便多了。

上面的一大串static_assert語句讓人看了不舒服。這麼寫的原因是std::array的operator==函式並非constexpr（至少在C++20前如此）。但是我們也可以自己定義一個模板函式用於判斷兩個陣列是否相等：

template<typename T,typename U,size_t M,size_t N>
constexpr bool EqualsImpl(const T& lhs,const U& rhs)
{
 static_assert(M == N);
 for (size_t i = 0; i < M; ++i) {
 if (lhs[i] != rhs[i]) {
  return false;
 }
 }
 return true;
}

template<typename T,typename U>
constexpr bool Equals(const T& lhs,const U& rhs)
{
 return EqualsImpl<T,U,size(lhs),size(rhs)>(lhs,rhs);
}

template<typename T,size_t N>
constexpr bool Equals(const T& lhs,const U (&rhs)[N])
{
 return EqualsImpl<T,const U (&)[N],N>(lhs,rhs);
}

int main()
{
 constexpr std::array<int,4> after = Sort(before);
 static_assert(Equals(after,{1,4})); // 比較std::array和原生陣列
 static_assert(!Equals(before,after)); // 比較兩個std::array
 return 0;
}

我們定義的Equals比std::array的比較運算子更強大，甚至可以在std::array和原生陣列之間進行比較。

對於Equals有兩點需要說明：

1.std::size是C++17提供的工具函式，對各種容器和陣列都能返回其大小。當然，這裡的Equals只會允許編譯期確定大小的容器傳入，否則觸發編譯失敗。

2.Equals定義了兩個版本，這是被C++的一個限制所逼的迫不得已：C++禁止{...}這種std::initializer_list字面量被推導為模板引數型別，因此我們必須提供一個版本宣告引數型別為陣列，以便{1,4}這種表示式能作為引數傳進去。

編譯期排序是一個啟發性的嘗試，我們可以用類似的方法生成其他的編譯期集合常量，比如指定長度的自然數序列：

template<typename T,size_t N>
constexpr auto NaturalNumbers() noexcept
{
 array<T,N> arr{0}; // 顯式初始化不能省
 for (size_t i = 0; i < N; ++i) {
 arr[i] = i + 1;
 }
 return arr;
}

int main()
{
 constexpr auto arr = NaturalNumbers<uint32_t,5>();
 static_assert(Equals(arr,5}));
 return 0;
}

這段程式碼的編譯執行都沒有問題，但它並不是推薦的做法。原因是在NaturalNumbers函式中，先定義了一個內容全0的區域性陣列，然後再挨個修改它的值，這樣沒有直接返回指定值的陣列效率高。有人會想能不能把arr的初始化給去掉，但這樣會導致編譯錯誤——constexpr函式中不允許定義沒有初始化的區域性變數。

可能有人覺得這些計算都是編譯期完成的，對執行效率沒影響——但是不要忘了constexpr函式也可以在執行時呼叫。更好的做法可以參見前面to_array函式的實現，讓陣列的初始化一氣呵成，省掉挨個賦值的步驟。

我們用這個新思路，寫一個通用的陣列生成器，它可以接受一個函式物件作為引數，通過呼叫這個函式物件來生成陣列每個元素的值。下面的程式碼還演示了下如何用這個生成器在編譯期生成奇數序列和斐波那契數列。

template<typename T>
constexpr T OddNumber(size_t i) noexcept
{
 return i * 2 + 1;
}

template<typename T>
constexpr T Fibonacci(size_t i) noexcept
{
 if (i <= 1) {
 return 1;
 }
 return Fibonacci<T>(i - 1) + Fibonacci<T>(i - 2);
}

template<typename T,typename F,size_t... I>
constexpr array<std::remove_cv_t<T>,N> GenerateArrayImpl(F f,std::index_sequence<I...>) noexcept
{
 return { {f(I)...} };
}

template<size_t N,typename T = invoke_result_t<F,size_t>>
constexpr array<T,N> GenerateArray(F f) noexcept
{
 return GenerateArrayImpl<T,N>(f,std::make_index_sequence<N>{});
}

int main()
{
 constexpr auto oddNumbers = GenerateArray<5>(OddNumber<uint8_t>);
 static_assert(Equals(oddNumbers,9}));
 constexpr auto fiboNumbers = GenerateArray<5>(Fibonacci<uint32_t>);
 static_assert(Equals(fiboNumbers,5}));

 // 甚至可以傳入lambda來定製要生成的數字序列（限定C++17）
 constexpr auto specified = GenerateArray<3>([](size_t i) { return i + 10; });
 static_assert(Equals(specified,{10,11,12}));
 return 0;
}

最後那個傳入lambda來定製陣列的做法存在一個疑問：lambda是constexpr函式嗎？答案為：可以是，但需要C++17支援。

GenerateArray這個陣列生成器將會在後面發揮重大作用，繼續往下看。

擷取子陣列

std::array並未提供輸入一個指定區間來建立新容器的建構函式，但是藉助上面的陣列生成器，我們可以寫個輔助函式來實現子陣列生成操作（這裡再次用上了lambda函式作為生成演算法）。

template<size_t N,typename T>
constexpr auto SubArray(T&& t,size_t base) noexcept
{
 return GenerateArray<N>([base,t = forward<T>(t)](size_t i) { return t[base + i]; });
}

template<size_t N,typename T,size_t M>
constexpr auto SubArray(const T (&t)[M],&t](size_t i) { return t[base + i]; });
}

int main()
{
 // 以std::initializer_list字面量為原始資料
 constexpr auto x = SubArray<3>({1,6},2); // 下標為2開始，取3個元素
 static_assert(Equals(x,{3,5}));

 // 以std::array為原始資料
 constexpr auto x1 = SubArray<2>(x,1); // 下標為1開始，取2個元素
 static_assert(Equals(x1,{4,5}));

 // 以原生陣列為原始資料
 constexpr uint8_t a[] = {9,8,5};
 constexpr auto y = SubArray<2>(a,3);
 static_assert(Equals(y,{6,5})); // 下標為3開始，取2個元素

 // 以字串為原始資料，注意生成的陣列不會自動加上'\0'
 constexpr const char* str = "Hello world!";
 constexpr auto z = SubArray<5>(str,6);
 static_assert(Equals(z,{'w','o','r','l','d'})); // 下標為6開始，取5個元素
 
 // 以std::vector為原始資料，非編譯期計算
 vector<int32_t> v{10,12,13,14};
 size_t n = 2;
 auto d = SubArray<3>(v,n); // 執行時生成陣列
 assert(Equals(d,{12,14})); // 注意不能用static_assert，不是編譯期常量
 return 0;
}

使用SubArray時，模板引數N是要擷取的子陣列大小，入參t是任意能支援下標操作的型別，入參base是擷取元素的起始位置。由於std::array的大小在編譯期是確定的，因此N必須是編譯期常量，但引數base可以是執行時變數。

當所有入參都是編譯期常量時，生成的子陣列也是編譯期常量。

SubArray提供了兩個版本，目的也是為了讓std::initializer_list字面量可以作為引數傳入。

拼接多個數組

採用類似的方式可以做多個數組的拼接，這裡同樣用了lambda作為生成函式。

template<typename T>
constexpr auto TotalLength(const T& arr) noexcept
{
 return size(arr);
}

template<typename P,typename... T>
constexpr auto TotalLength(const P& p,const T&... arr) noexcept
{
 return size(p) + TotalLength(arr...);
}

template<typename T>
constexpr auto PickElement(size_t i,const T& arr) noexcept
{
 return arr[i];
}

template<typename P,typename... T>
constexpr auto PickElement(size_t i,const P& p,const T&... arr) noexcept
{
 if (i < size(p)) {
 return p[i];
 }
 return PickElement(i - size(p),arr...);
}

template<typename... T>
constexpr auto ConcatArrays(const T&... arr) noexcept
{
 return GenerateArray<TotalLength(arr...)>([&arr...](size_t i) { return PickElement(i,arr...); });
}

int main()
{
 constexpr int32_t a[] = {1,3}; // 原生陣列
 constexpr auto b = to_typed_array<int32_t>({4,6}); // std::array
 constexpr auto c = DeclareArray<int32_t,8>(); // std::array
 constexpr auto x = ConcatArrays(a,b,c); // 把3個數組拼接在一起
 static_assert(Equals(x,8}));
 return 0;
}

和之前一樣，ConcatArrays使用了模板引數來同時相容原生陣列和std::array，它甚至可以接受任何編譯期確定長度的自定義型別參與拼接。

ConcatArrays函式因為可變引數的語法限制，沒有再對std::initializer_list字面量進行適配，這導致std::initializer_list字面量不能再直接作為引數：

constexpr auto x = ConcatArrays(a,6}); // 編譯錯誤

但是我們有辦法規避這個問題：利用前面介紹過的工具把std::initializer_list先轉成std::array就可以了：

constexpr auto x = ConcatArrays(a,to_array({4,6})); // OK

編譯期拼接字串

std::array適合用來表示字串麼？回答這個問題前，我們先看看原生陣列是否適合表示字串：

char str[] = "abc"; // str陣列大小為4，包括結尾的'\0'

上面是很常見的寫法。由於陣列名可退化為指標，str可用於各種需要字串的場合，如傳給cout列印輸出。

std::array作為對原生陣列的替代，自然也適合用來表示字串。有人可能會覺得std::array沒法直接作為字串型別使用，不太方便。但實際上只要呼叫data方法，std::array就會返回能作為字串使用的指標：

constexpr auto str = to_array("abc"); // to_array可以將字串轉換為std::array
static_assert(str.size() == 4);
static_assert(Equals(str,"abc")); // Equals也可以接受字串字面量
cout << str.data(); // 列印字串內容

由於字串字面量是char[]型別，因此前面所編寫的工具函式，都可以將字串作為輸入引數。上面的Equals只是其中一個例子。

那之前寫的陣列拼接函式ConcatArrays能用於拼接字串麼？能，但結果和我們想的有差異：

constexpr auto str = ConcatArrays("abc","def");
static_assert(str.size() == 8); // 長度不是7？
static_assert(Equals(str,{'a','b','c','\0','d','e','f','\0'}));

因為每個字串結尾都有'\0'結束符，用陣列拼接方法把它們拼到一起時，中間的'\0'沒有被去掉，導致結果字串被切割為了多個C字串。

這個問題解決起來也很容易，只要在拼接陣列時把所有陣列的最後一個元素（'\0'）去掉，並且在返回陣列的末尾加上'\0'就可以了。下面的程式碼實現了字串拼接功能，非型別引數E是字串的結束符，通常為'\0'，但是也允許定製。我們甚至可以利用它來拼接結束符為其他值的物件，比如訊息、報文等。

// 最後一個字元，放入結束符
template<auto E>
constexpr auto PickChar(size_t i)
{
 return E;
}

template<auto E,typename... T>
constexpr auto PickChar(size_t i,const T&... arr)
{
 if (i < (size(p) - 1)) {
 if (p[i] == E) { // 結束符不允許出現在字串中間
  throw "terminator in the middle";
 }
 return p[i];
 }
 if (p[size(p) - 1] != E) { // 結束符必須是最後一個字元
 throw "terminator not at end";
 }
 return PickChar<E>(i - (size(p) - 1),arr...);
}

template<typename... T,auto E = '\0'>
constexpr auto ConcatStrings(const T&... str)
{
 return GenerateArray<TotalLength(str...) - sizeof...(T) + 1>([&str...](size_t i) { 
  return PickChar<E>(i,str...);
  });
}

int main()
{
 constexpr char a[] = "I "; // 原生陣列形式的字串
 constexpr auto b = to_array("love "); // std::array形式的字串
 constexpr auto str = ConcatStrings(a,"C++"); // 拼接 陣列 + std::array + 字串字面量
 static_assert(Equals(str,"I love C++"));
 return 0;
}

這段程式碼中用了兩個throw，這是為了校驗輸入的引數是否都為合法的字串，即：字串長度=容器長度-1。如果不符合該條件，會導致拼接結果的長度計算錯誤。

當編譯期的計算丟擲異常時，只會出現編譯錯誤，因此只要不在執行時呼叫ConcatStrings，這兩個throw語句不會有更多影響。但因為這個校驗的存在，強烈不建議在執行期呼叫ConcatStrings做拼接，何況執行期也沒必要用這種方法——std::string的加法操作它不香麼？

有人會想：能否在編譯期計算字串的實際長度，而不是用容器的長度呢？這個方法看似可行，定義一個編譯期計算字串長度的函式確實很容易：

template<typename T,auto E = '\0'>
constexpr size_t StrLen(const T& str) noexcept
{
 size_t i = 0;
 while (str[i] != E) {
 ++i;
 }
 return i;
}

constexpr const char* g_str = "abc";

int main()
{
 // 利用StrLen把一個字串按實際長度轉成std::array
 constexpr auto str = SubArray<StrLen(g_str) + 1>(g_str,0);
 static_assert(Equals(str,"abc"));
 return 0;
}

但是，一旦你試圖把StrLen放到ConcatStrings的內部去宣告陣列長度，就會產生問題：C++的constexpr機制要求只有在能看到輸入引數的constexpr屬性的地方，才允許StrLen的返回結果確定為constexpr。而在函式內部時，看到的引數型別並不是constexpr。

當然我們可以變通一下，做出一些有趣的工具，比如使用萬惡的巨集：

// 把一個字串按實際長度轉成std::array
#define StrToArray(x) SubArray<StrLen(x) + 1>(x,0)

constexpr const char* g_str = "abc";

int main()
{
 // 使用巨集，可以讓constexpr指標型別也參與編譯期字串的拼接
 constexpr auto str = ConcatStrings(StrToArray(g_str),"def");
 static_assert(Equals(str,"abcdef"));
 return 0;
}

使用巨集以後，ConcatStrings連編譯期不確定大小的指標型別都可以間接作為輸入了[3]。如果你狠得下心使用變參巨集，甚至可以定義出按實際字串長度計算結果陣列長度的更通用拼接函式。但我嚴重懷疑這種需求的必要性——畢竟我們只是做編譯期的拼接，而編譯期的字串不應該會有結束符位置不在末尾的場景。

看到這裡的人，或多或少該佩服一下std::array的強大了。上面這些編譯期操作，用原生陣列很難完成吧？

展望C++20——打破更多的枷鎖

我在文章中說了多少次“至少在C++20之前如此”？不記得了，但是能確定的是：C++20會帶來很多美好的東西：std::array會有constexpr版本的比較運算子；函式可以用consteval限定只在編譯期呼叫；模板非型別引數允許更多的型別；STL容器物件可以作為constexpr常量……所有這一切，都只是C++20的minor更新而已，在絕大多數的特性介紹中，它們連提都不會被提到！

可想而知，用上C++20以後，程式設計會發生多大的變化。那時我們再來找找更多有趣的用法

尾註

[1]to_array定義了兩個版本，分別以左值引用和右值引用作為引數型別。按照C++11的最優實踐，這樣的函式本應該只定義一個版本並且使用完美轉發。但是to_array的場景如果用萬能引用會帶來一個問題：C++禁止std::initializer_list字面量{...}被推導為模板型別引數，完美轉發方案會導致std::initializer_list字面量不能作為to_array的入參。在後面內容中我們會看到多次這個限制所帶來的影響。

[2]C++20加入了consteval修飾符，可以指定函式只允許在編譯期呼叫。

[3] 需要注意的是：constexpr用於修飾指標時，表示的是指標本身為常量（而不是其指向的物件）。和const不同，constexpr並不允許放在型別宣告表示式的中間。因此如果要在編譯期計算一個constexpr指標指向的字串長度，這個字串必須位於靜態資料區裡，不能位於棧或者堆上（否則其地址無法在編譯期確定）。

到此這篇關於C++語言中std::array的用法小結(神器用法)的文章就介紹到這了,更多相關C++中std::array的用法內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！