在编译时获取多维矢量的深度

Question

我有一个函数，需要一个多维矢量，并且需要将深度（或维数）作为模板参数传递。与其硬编码此值，我不希望编写一个constexpr函数，该函数将采用向量并将深度作为无符号整数值返回。

例如：

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

有什么办法吗？

Answer 1

一个经典的模板问题。这是一个简单的解决方案，例如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)

编辑：

好，我已经完成了所有容器类型的常规实现。请注意，我根据表达式begin(t)将容器类型定义为具有格式正确的迭代器类型的任何类型，其中std::begin导入ADL查找，t是类型T的左值。

这是我的代码以及注释，这些注释解释了为何工作正常以及我使用的测试案例。注意，这需要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
}

Answer 2

假设容器是具有value_type和iterator成员类型的任何类型（标准库容器满足此要求），我们可以轻松地归纳Cruz Jean

Answer 3

一种方法可以通过使GetDepth成为递归函数。但是，这样的功能的有效性有点不好，我不知道是否有更好的方法可以做到。该函数可能看起来像这样：