I've been on this problem all morning with no result whatsoever.
Basically, I need a simple metaprogramming thing that allows me to branch to different specializations if the parameter passed is a kind of std::vector or not.
Some kind of is_base_of for templates.
Does such a thing exist ?
In C++11 you can also do it in a more generic way:
#include <type_traits>
#include <iostream>
#include <vector>
#include <list>
template<typename Test, template<typename...> class Ref>
struct is_specialization : std::false_type {};
template<template<typename...> class Ref, typename... Args>
struct is_specialization<Ref<Args...>, Ref>: std::true_type {};
int main()
{
typedef std::vector<int> vec;
typedef int not_vec;
std::cout << is_specialization<vec, std::vector>::value << is_specialization<not_vec, std::vector>::value;
typedef std::list<int> lst;
typedef int not_lst;
std::cout << is_specialization<lst, std::list>::value << is_specialization<not_lst, std::list>::value;
}
If you need a trait class it's pretty simple, you only need a general template and a specialization over any std::vector:
#include <type_traits>
#include <iostream>
#include <vector>
template<typename>
struct is_std_vector : std::false_type {};
template<typename T, typename A>
struct is_std_vector<std::vector<T,A>> : std::true_type {};
int main()
{
typedef std::vector<int> vec;
typedef int not_vec;
std::cout << is_std_vector<vec>::value << is_std_vector<not_vec>::value;
}
vector<T,A> to also catch vectors with custom allocators. –
Performing template <typename T, typename... Ts> struct is_std_vector<std::vector<T, Ts...>> : std::true_type { } –
Annulus std::vector are such that passing std::vector as a template template argument of the form template<typename, typename> class T is mandated to work -- meaning no extra parameter is allowed. –
Mealymouthed std::vector to a function taking a template<typename,typename> template argument. –
Palace std::vector takes the type T, the allocator A and an enum E that controls some other behavior and is defaulted to e_default. Now consider the trait above and typedef std::vector<int,std::allocator<int>,e_not_default> myvector;. Up to here all is valid, right? What will be is_std_vector<myvector>::value? The trait will compile, but it will mark all vectors that have non-default values for the extra arguments as non-vector. –
Palace No, but you can overload with a template function which only accepts std::vector<T>. The compiler will choose the most specialized template in such cases.
Defining the following two functions should work:
template<class T>
bool is_vector(const std::vector<T>& x) {return true;}
template<class T>
bool is_vector(const T& x) {return false;}
Example:
auto x {std::vector<double> {23, 32, 33}};
auto y {1.2};
std::cout << is_vector(x) << std::endl;
std::cout << is_vector(y) << std::endl;
I recently encountered almost the same question, which I need to figure out if something is a kind of another, for example, if a std::vector<std::vector<float>> is a kind of std::vector<WHATEVER> in my open cxx reflection lib. So I implement a generic is_fuzzy_type_match_v to check them, by using this consteval function, you can finish it in any kind of template, even variadic parameters template.
Here the code:
#include <type_traits>
namespace noaland {
struct i_dont_care {};
template<typename T>
struct is_i_dont_care : std::false_type {};
template<>
struct is_i_dont_care<i_dont_care> : std::true_type {};
// if two type are not the same
template<typename X, typename Y>
struct is_fuzzy_type_matched {
consteval auto operator()() {
if constexpr (noaland::is_i_dont_care<X>::value || noaland::is_i_dont_care<Y>::value || std::is_same_v<X, Y>) {
return std::true_type{};
} else {
return std::false_type{};
}
}
};
template<typename X, typename Y>
inline constexpr auto is_fuzzy_type_matched_v = decltype(is_fuzzy_type_matched<X, Y>()())::value;
template<bool... R>
consteval bool conjunction() {
return (R && ...);
}
template<template<typename...> typename X, template<typename...> typename Y, typename... SUB_X, typename... SUB_Y>
struct is_fuzzy_type_matched<X<SUB_X...>, Y<SUB_Y...>> {
consteval auto operator()() {
if constexpr (!conjunction<is_fuzzy_type_matched_v<SUB_X, SUB_Y>...>()) {
return std::false_type{};
} else {
return std::true_type{};
}
}
};
}
You can use this function like this:
int main() {
static_assert(noaland::is_fuzzy_type_matched_v<std::vector<std::vector<std::vector<int>>>, std::vector<noaland::i_dont_care>>);
return 0;
}
Since I use consteval which is a C++20 feature, you need to add --std=c++20, or you can just change consteval to constexpr.
If you are interested in the content presented in this article, please take a look at my work-in-progress cxx-reflection repository on GitHub. Your stars and forks are welcome.
© 2022 - 2024 — McMap. All rights reserved.
typedef)? Or a specialized implementation for a certain type (likestd::vector<bool>is)? – Lancastrianstd::vectorfor a type, you shouldn't be able to do it (not in a clean way anyway). If you want to determine if a type is inherited from std::vector<XXX>, this is explicitly advised against (std::vector doesn't have a virtual destructor and SHOULD NOT be inherited, only encapsulated). If you want to determine if a class/typedef/template parameter is a std::vector<XYZ, ...>, you should use a templated traits class (see answer from jrok). – Fossstruct is_std_vector<std::vector<T,A>>is a particularized implementation ofstruct is_std_vectorin jirok's answer). Is there a way of doing that? – Foss