Làm thế nào tôi có thể có được độ sâu của một vectơ std :: chiều đa chiều tại thời gian biên dịch?

Tôi có một hàm có nhiều chiều std::vectorvà yêu cầu độ sâu (hoặc số lượng kích thước) được truyền vào dưới dạng tham số mẫu. Thay vì mã hóa giá trị này, tôi muốn viết một constexprhàm sẽ lấy std::vectorvà trả về độ sâu làm unsigned integergiá trị.

Ví dụ:

std::vector<std::vector<std::vector<int>>> v =
{
    { { 0, 1}, { 2, 3 } },
    { { 4, 5}, { 6, 7 } },
};

// Returns 3
size_t depth = GetDepth(v);

Điều này cần phải được thực hiện tại thời điểm biên dịch bởi vì độ sâu này sẽ được chuyển đến hàm mẫu dưới dạng tham số mẫu:

// Same as calling foo<3>(v);
foo<GetDepth(v)>(v);

Có cách nào để làm điều này?

Một vấn đề templating cổ điển. Đây là một giải pháp đơn giản như cách thư viện chuẩn C ++ thực hiện. Ý tưởng cơ bản là có một mẫu đệ quy sẽ đếm từng cái một, với trường hợp cơ bản là 0 cho bất kỳ loại nào không phải là vectơ.

#include <vector>
#include <type_traits>

template<typename T>
struct dimensions : std::integral_constant<std::size_t, 0> {};

template<typename T>
struct dimensions<std::vector<T>> : std::integral_constant<std::size_t, 1 + dimensions<T>::value> {};

template<typename T>
inline constexpr std::size_t dimensions_v = dimensions<T>::value; // (C++17)

Vì vậy, sau đó bạn có thể sử dụng nó như vậy:

dimensions<vector<vector<vector<int>>>>::value; // 3
// OR
dimensions_v<vector<vector<vector<int>>>>; // also 3 (C++17)

Biên tập:

Ok, tôi đã hoàn thành việc triển khai chung cho bất kỳ loại container nào. Lưu ý rằng tôi đã xác định một loại container như bất cứ điều gì mà có một loại iterator tốt được hình thành theo các biểu hiện begin(t)nơi std::beginđược nhập khẩu để tra cứu ADL và tlà một vế trái của loại T.

Đây là mã của tôi cùng với các bình luận để giải thích lý do tại sao công cụ hoạt động và các trường hợp thử nghiệm tôi đã sử dụng. Lưu ý, điều này đòi hỏi C ++ 17 để biên dịch.

#include <iostream>
#include <vector>
#include <array>
#include <type_traits>

using std::begin; // import std::begin for handling C-style array with the same ADL idiom as the other types

// decide whether T is a container type - i define this as anything that has a well formed begin iterator type.
// we return true/false to determing if T is a container type.
// we use the type conversion ability of nullptr to std::nullptr_t or void* (prefers std::nullptr_t overload if it exists).
// use SFINAE to conditionally enable the std::nullptr_t overload.
// these types might not have a default constructor, so return a pointer to it.
// base case returns void* which we decay to void to represent not a container.
template<typename T>
void *_iter_elem(void*) { return nullptr; }
template<typename T>
typename std::iterator_traits<decltype(begin(*(T*)nullptr))>::value_type *_iter_elem(std::nullptr_t) { return nullptr; }

// this is just a convenience wrapper to make the above user friendly
template<typename T>
struct container_stuff
{
    typedef std::remove_pointer_t<decltype(_iter_elem<T>(nullptr))> elem_t;    // the element type if T is a container, otherwise void
    static inline constexpr bool is_container = !std::is_same_v<elem_t, void>; // true iff T is a container
};

// and our old dimension counting logic (now uses std:nullptr_t SFINAE logic)
template<typename T>
constexpr std::size_t _dimensions(void*) { return 0; }

template<typename T, std::enable_if_t<container_stuff<T>::is_container, int> = 0>
constexpr std::size_t _dimensions(std::nullptr_t) { return 1 + _dimensions<typename container_stuff<T>::elem_t>(nullptr); }

// and our nice little alias
template<typename T>
inline constexpr std::size_t dimensions_v = _dimensions<T>(nullptr);

int main()
{
    std::cout << container_stuff<int>::is_container << '\n';                 // false
    std::cout << container_stuff<int[6]>::is_container<< '\n';               // true
    std::cout << container_stuff<std::vector<int>>::is_container << '\n';    // true
    std::cout << container_stuff<std::array<int, 3>>::is_container << '\n';  // true
    std::cout << dimensions_v<std::vector<std::array<std::vector<int>, 2>>>; // 3
}

Giả sử rằng một container là bất kỳ loại nào có value_typevà iteratorcác loại thành viên (các thùng chứa thư viện tiêu chuẩn đáp ứng yêu cầu này) hoặc mảng kiểu C, chúng ta có thể dễ dàng khái quát hóa giải pháp của Cruz Jean :

template<class T, typename = void>
struct rank : std::integral_constant<std::size_t, 0> {};

// C-style arrays
template<class T>
struct rank<T[], void> 
    : std::integral_constant<std::size_t, 1 + rank<T>::value> {};

template<class T, std::size_t n>
struct rank<T[n], void> 
    : std::integral_constant<std::size_t, 1 + rank<T>::value> {};

// Standard containers
template<class T>
struct rank<T, std::void_t<typename T::iterator, typename T::value_type>> 
    : std::integral_constant<std::size_t, 1 + rank<typename T::value_type>::value> {};

int main() {
    using T1 = std::list<std::set<std::array<std::vector<int>, 4>>>;
    using T2 = std::list<std::set<std::vector<int>[4]>>;

    std::cout << rank<T1>();  // Output : 4
    std::cout << rank<T2>();  // Output : 4
}

Các loại container có thể được hạn chế hơn nữa nếu cần thiết.

Bạn có thể định nghĩa mẫu lớp sau vector_depth<>phù hợp với bất kỳ loại nào:

template<typename T>
struct vector_depth {
   static constexpr size_t value = 0;
};

Mẫu chính này tương ứng với trường hợp cơ sở kết thúc đệ quy. Sau đó, xác định chuyên môn tương ứng của nó chostd::vector<T> :

template<typename T>
struct vector_depth<std::vector<T>> {
   static constexpr size_t value = 1 + vector_depth<T>::value;
};

Chuyên môn này phù hợp với một std::vector<T>và tương ứng với trường hợp đệ quy.

Cuối cùng, định nghĩa mẫu hàm GetDepth(),, dùng cho mẫu lớp ở trên:

template<typename T>
constexpr auto GetDepth(T&&) {
   return vector_depth<std::remove_cv_t<std::remove_reference_t<T>>>::value;
}

Thí dụ:

auto main() -> int {
   int a{}; // zero depth
   std::vector<int> b;
   std::vector<std::vector<int>> c;
   std::vector<std::vector<std::vector<int>>> d;

   // constexpr - dimension determinted at compile time
   constexpr auto depth_a = GetDepth(a);
   constexpr auto depth_b = GetDepth(b);
   constexpr auto depth_c = GetDepth(c);
   constexpr auto depth_d = GetDepth(d);

   std::cout << depth_a << ' ' << depth_b << ' ' << depth_c << ' ' << depth_d;
}

Đầu ra của chương trình này là:

0 1 2 3