申报多维STD更简洁的方式::阵列

Question

短的问题： 有一个较短的方式做到这一点

array<array<atomic<int>,n>,m> matrix; 

我希望这样的事情

array< atomic< int>,n,m> matrix;  

，但它不工作。 ..

Answer 1

当嵌套时，性病::阵列可以变得非常难以阅读和不必要的冗长。尺寸的相反顺序可能会特别令人困惑。

例如：

std::array < std::array <int, 3 > , 5 > arr1; 

相比

char c_arr [5][3]; 

另外，还要注意（）开始，结束（），大小（）都返回无意义的值，当你窝的std ::阵列。

基于这些原因，我创建了自己的固定大小的多维数组的容器，array_2d和array_3d。他们的优点是可以与C++ 98一起工作。

它们类似于std :: array，但对于2维和3维的多维数组。它们比内置多维阵列更安全，性能更差。我不包括多维数组的容器，其尺寸大于3，因为他们是罕见的。在C++ 11中，可以创建一个可以支持任意数量维度的可变模板版本（类似Michael Price的例子）。

二维变形的例子：

//Create an array 3 x 5 (Notice the extra pair of braces) 
fsma::array_2d <double, 3, 5> my2darr = {{ 
{ 32.19, 47.29, 31.99, 19.11, 11.19}, 
{ 11.29, 22.49, 33.47, 17.29, 5.01 }, 
{ 41.97, 22.09, 9.76, 22.55, 6.22 } 
}}; 

完整文档，请点击这里： http://fsma.googlecode.com/files/fsma.html

您可以在这里下载库： http://fsma.googlecode.com/files/fsma.zip

Answer 2

模板别名可能助阵：

#include <array> 

template <class T, unsigned I, unsigned J> 
using Matrix = std::array<std::array<T, J>, I>; 

int main() 
{ 
    Matrix<int, 3, 4> matrix; 
} 

Answer 3

对于不支持模板别名尚未编译器可口的解决方法是使用一个简单的元函数生成的类型：

#include <cstddef> 
#include <array> 

template<class T, std::size_t RowsN, std::size_t ColumnsN> 
struct Matrix 
{ 
    typedef std::array<std::array<T, ColumnsN>, RowsN> type; // row major 

private: 
    Matrix(); // prevent accidental construction of the metafunction itself 
}; 

int main() 
{ 
    Matrix<int, 3, 4>::type matrix; 
} 

Answer 4

使用解决方案可变参数模板（略高于模板别名更加复杂，但更普遍目的）

template <typename T, std::size_t thisSize, std::size_t ... otherSizes> 
class multi_array : private std::array<multi_array<T, otherSizes...>, thisSize> 
{ 
using base_array = std::array<multi_array<T, otherSizes...>, thisSize>; 

public: 
    using base_array::operator[]; 
    // TODO: add more using statements to make methods 
    // visible. This is less typing (and less error-prone) 
    // than forwarding to the base_array type. 
}; 

template <typename T, std::size_t thisSize> 
class multi_array<T, thisSize> : private std::array<T, thisSize> 
{ 
using base_array = std::array<T, thisSize>; 

public: 
    using base_array::operator[]; 
    // TODO: add more using statements to make methods 
    // visible. This is less typing (and less error-prone) 
    // than forwarding to the base_array type. 
}; 

分配给数组的非叶子可能会有一些改进。

我有一个相对较新的构建铛/ LLVM的测试。

享受！

Answer 5

这里有一个简单，通用的版本：

template <typename T, size_t d1, size_t d2, size_t... ds> 
struct GetMultiDimArray 
{ 
    using type = std::array<typename GetMultiDimArray<T, d2, ds...>::type, d1>; 
}; 

template <typename T, size_t d1, size_t d2> 
struct GetMultiDimArray<T, d1, d2> 
{ 
    using type = std::array<std::array<T, d2>, d1>; 
}; 

template <typename T, size_t d1, size_t d2, size_t... ds> 
using MultiDimArray = typename GetMultiDimArray<T, d1, d2, ds...>::type; 

// Usage: 
MultiDimArray<int, 3, 2> arr {1, 2, 3, 4, 5, 6}; 
assert(arr[1][1] == 4);