컴파일 타임에 다차원 std :: vector의 깊이를 얻으려면 어떻게해야합니까?

다차원을 취하고 std::vector깊이 (또는 차원 수)를 템플릿 매개 변수로 전달 해야하는 함수가 있습니다. 이 값을 하드 코딩하는 대신 깊이를 값 으로 반환 하는 constexpr함수 를 작성하고 싶습니다 .std::vectorunsigned integer

예를 들면 다음과 같습니다.

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

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

이 깊이는 템플릿 매개 변수로 템플릿 함수에 전달되므로 컴파일 타임에 수행해야합니다 .

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

이것을 할 수있는 방법이 있습니까?

고전적인 템플릿 문제입니다. 다음은 C ++ 표준 라이브러리와 같은 간단한 솔루션입니다. 기본 아이디어는 벡터가 아닌 모든 유형에 대해 기본 대소 문자가 0 인 각 차원마다 하나씩 계산하는 재귀 템플릿을 사용하는 것입니다.

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

따라서 다음과 같이 사용할 수 있습니다.

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

편집하다:

좋아, 모든 컨테이너 유형에 대한 일반적인 구현을 마쳤습니다. I는 식에 따라 잘 형성 반복자 타입 가지고 아무것도 컨테이너 타입을 정의 유의 ADL 조회 수입되고 형식의 좌변이다 .begin(t)std::begintT

다음은 왜 작동하는 이유와 내가 사용한 테스트 사례를 설명하는 주석과 함께 내 코드입니다. 컴파일하려면 C ++ 17이 필요합니다.

#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
}

컨테이너가있는 모든 유형이라고 가정 value_type및 iterator회원 유형 (표준 라이브러리 컨테이너가이 요구 사항을 만족) 또는 C 스타일 배열, 우리가 쉽게 일반화 할 수 크루즈 진 '의 솔루션 :

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
}

필요한 경우 컨테이너 유형을 추가로 제한 할 수 있습니다.

vector_depth<>모든 유형과 일치 하는 다음 클래스 템플릿 을 정의 할 수 있습니다 .

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

이 기본 템플릿은 재귀를 끝내는 기본 사례에 해당합니다. 그런 다음에 해당하는 전문화를 정의하십시오 std::vector<T>.

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

이 전문화는와 일치하며 std::vector<T>재귀 사례에 해당합니다.

마지막으로 GetDepth()위의 클래스 템플릿에 의존 하는 함수 템플릿을 정의하십시오 .

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

예:

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

이 프로그램의 출력은 다음과 같습니다.

0 1 2 3