ปัญหา templating คลาสสิก ต่อไปนี้เป็นวิธีแก้ปัญหาง่ายๆเช่นเดียวกับที่ห้องสมุดมาตรฐาน 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)
แก้ไข:
ตกลงฉันได้ทำการติดตั้งทั่วไปสำหรับคอนเทนเนอร์ประเภทใดแล้ว หมายเหตุที่ผมกำหนดประเภทภาชนะเป็นอะไรที่มีชนิด iterator ดีขึ้นตามการแสดงออกbegin(t)
ที่std::begin
ถูกนำเข้าสำหรับการค้นหา ADL และt
เป็น lvalue 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
}
std::vector
เป็นสิ่งที่ต้องทำไม่ใช่เวลารวบรวมstd::array
หากคุณต้องการภาชนะขนาดรวบรวมเวลามองไปที่ นอกจากนี้ยัง; โปรดจำไว้ว่าconstexpr
หมายถึงเท่านั้น " อาจถูกประเมิน ณ เวลารวบรวม" - ไม่มีสัญญาว่าจะเป็น มันอาจถูกประเมิน ณ รันไทม์