cách ít verbose tuyên bố std :: đa chiều mảng

Question

câu hỏi ngắn: Có cách nào ngắn hơn để làm điều này

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

Tôi đã hy vọng cho một cái gì đó giống như

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

nhưng nó không làm việc. ..

Answer 1

Khi lồng nhau, tiêu chuẩn :: mảng có thể trở nên rất khó đọc và không cần thiết tiết. Thứ tự ngược lại của các kích thước có thể đặc biệt khó hiểu.

Ví dụ:

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

so với

char c_arr [5][3]; 

Ngoài ra, lưu ý rằng bắt đầu(), kết thúc() và kích thước() tất cả trở về giá trị vô nghĩa khi bạn tổ std :: mảng.

Vì những lý do này tôi đã tạo các vùng chứa đa chiều có kích thước cố định của riêng mình, mảng_2d và mảng_3d. Họ có lợi thế là họ làm việc với C++ 98.

Chúng tương tự với std :: array nhưng đối với mảng đa chiều có kích thước 2 và 3. Chúng an toàn hơn và không có hiệu suất kém hơn so với các mảng đa chiều có sẵn. Tôi không bao gồm một vùng chứa cho các mảng đa chiều có kích thước lớn hơn 3 vì chúng không phổ biến. Trong C++ 11, phiên bản mẫu variadic có thể được tạo ra, hỗ trợ một số thứ tự tùy ý (ví dụ như ví dụ của Michael Price).

Một ví dụ về các biến thể hai chiều:

//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 } 
}}; 

Full tài liệu có sẵn ở đây: http://fsma.googlecode.com/files/fsma.html

Bạn có thể tải thư viện ở đây: http://fsma.googlecode.com/files/fsma.zip

Answer 2

Bí danh mẫu có thể trợ giúp:

#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

Một cách giải quyết ngon miệng cho các trình biên dịch không hỗ trợ mẫu bí danh được nêu ra là sử dụng một metafunction đơn giản để tạo ra các loại:

#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

Giải pháp sử dụng mẫu variadic (hơi phức tạp hơn so với mẫu bí danh, nhưng tổng quát hơn mục đích)

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. 
}; 

Có thể có một số cải tiến về việc gán cho không phải là mảng của mảng có thể được thực hiện.

Tôi đã thử nghiệm với công trình xây dựng clang/LLVM tương đối gần đây.

Tận hưởng!

Answer 5

Dưới đây là một đơn giản, chung chung phiên bản:

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);