用元编程来判断STL类型

  在此之前,先来回顾元编程当中的一个重要概念。

template<typename _Tp, _Tp __v>
    struct integral_constant
    {
      static constexpr _Tp                  value = __v;
      typedef _Tp                           value_type;
      typedef integral_constant<_Tp, __v>   type;
      constexpr operator value_type() const noexcept { return value; }
#if __cplusplus > 201103L

#define __cpp_lib_integral_constant_callable 201304L

      constexpr value_type operator()() const noexcept { return value; }
#endif
    };

  /// The type used as a compile-time boolean with true value.
  using true_type =  integral_constant<bool, true>;

  /// The type used as a compile-time boolean with false value.
  using false_type = integral_constant<bool, false>;

  std::true_type和std::false_type其实就是std::integral_constant传入模板特定参数的情形,注意到integral_constant结构体当中的value_type,顾名思义指的是值的类型,对应到std::true_type和std::false_type就是true和false。

  先尝试着来写一个对std::vector的判断。

// vector
template <typename _Tp>
struct is_vector : std::false_type{};

template <typename _Tp>
struct is_vector<std::vector<_Tp>> : std::true_type{};

template <typename container_type>
bool is_vector_v = is_vector<container_type>::value;

int main() {
    std::vector<int> v1;
    std::vector<double> v2;
    std::vector<std::queue<int>> v3;
    
    std::cout << is_vector_v<decltype(v1)> << '\n';
    std::cout << is_vector_v<decltype(v2)> << '\n';
    std::cout << is_vector_v<decltype(v3)> << "\n\n";

    std::queue<int> q1;
    std::queue<double> q2;
    std::queue<std::vector<int>> q3;

    std::cout << is_vector_v<decltype(q1)> << '\n';
    std::cout << is_vector_v<decltype(q2)> << '\n';
    std::cout << is_vector_v<decltype(q3)> << '\n';
}

  到这里还比较容易,用上面所讲到的std::true_type对is_vector模板类进行特化。拓展到全体STL容器类型,我们可以往此方向进行延申,对其它STL容器反复操作。

// vector
template <typename _Tp>
struct is_vector : std::false_type{};

template <typename _Tp>
struct is_vector<std::vector<_Tp>> : std::true_type{};

template <typename container_type>
bool is_vector_v = is_vector<container_type>::value;

// queue
template <typename _Tp>
struct is_queue : std::false_type{};

template <typename _Tp>
struct is_queue<std::queue<_Tp>> : std::true_type{};

template <typename container_type>
bool is_queue_v = is_queue<container_type>::value;

// string
template <typename _Tp>
struct is_string : std::false_type{};

template <>
struct is_string<std::string> : std::true_type{};

template <typename container_type>
bool is_string_v = is_string<container_type>::value;

// array
template <typename _Tp>
struct is_array : std::false_type{};

template <typename _Tp, std::size_t N>
struct is_array<std::array<_Tp, N>> : std::true_type{};

template <typename container_type>
bool is_array_v = is_array<container_type>::value;

// priority_queue
template <typename _Tp>
struct is_priority_queue : std::false_type{};

template <typename _Tp>
struct is_priority_queue<std::priority_queue<_Tp>> : std::true_type{};

template <typename container_type>
bool is_priority_queue_v = is_priority_queue<container_type>::value;

// map
template <typename _Tp>
struct is_map : std::false_type{};

template <typename _Tp, typename _Up>
struct is_map<std::map<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_map_v = is_map<container_type>::value;

// unordered_map
template <typename _Tp>
struct is_unordered_map : std::false_type{};

template <typename _Tp, typename _Up>
struct is_unordered_map<std::unordered_map<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_unordered_map_v = is_unordered_map<container_type>::value;

// multimap
template <typename _Tp>
struct is_multimap : std::false_type{};

template <typename _Tp, typename _Up>
struct is_multimap<std::multimap<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_multimap_v = is_multimap<container_type>::value;

// unordered_multimap
template <typename _Tp>
struct is_unordered_multimap : std::false_type{};

template <typename _Tp, typename _Up>
struct is_unordered_multimap<std::unordered_multimap<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_unordered_multimap_v = is_unordered_multimap<container_type>::value;

// set
template <typename _Tp>
struct is_set : std::false_type{};

template <typename _Tp>
struct is_set<std::set<_Tp>> : std::true_type{};

template <typename container_type>
bool is_set_v = is_set<container_type>::value;

// unordered_set
template <typename _Tp>
struct is_unordered_set : std::false_type{};

template <typename _Tp>
struct is_unordered_set<std::unordered_set<_Tp>> : std::true_type{};

template <typename container_type>
bool is_unordered_set_v = is_unordered_set<container_type>::value;

// multiset
template <typename _Tp>
struct is_multiset : std::false_type{};

template <typename _Tp>
struct is_multiset<std::multiset<_Tp>> : std::true_type{};

template <typename container_type>
bool is_multiset_v = is_multiset<container_type>::value;

// unordered_multiset
template <typename _Tp>
struct is_unordered_multiset : std::false_type{};

template <typename _Tp>
struct is_unordered_multiset<std::unordered_multiset<_Tp>> : std::true_type{};

template <typename container_type>
bool is_unordered_multiset_v = is_unordered_multiset<container_type>::value;

// list
template <typename _Tp>
struct is_list : std::false_type{};

template <typename _Tp>
struct is_list<std::list<_Tp>> : std::true_type{};

template <typename container_type>
bool is_list_v = is_list<container_type>::value;

// forward_list
template <typename _Tp>
struct is_forward_list : std::false_type{};

template <typename _Tp>
struct is_forward_list<std::forward_list<_Tp>> : std::true_type{};

template <typename container_type>
bool is_forward_list_v = is_forward_list<container_type>::value;

// stack
template <typename _Tp>
struct is_stack : std::false_type{};

template <typename _Tp>
struct is_stack<std::stack<_Tp>> : std::true_type{};

template <typename container_type>
bool is_stack_v = is_stack<container_type>::value;

// deque
template <typename _Tp>
struct is_deque : std::false_type{};

template <typename _Tp>
struct is_deque<std::deque<_Tp>> : std::true_type{};

template <typename container_type>
bool is_deque_v = is_deque<container_type>::value;

  (可能会有遗漏,我对STL的理解就是上面这些)好,接下来可以定义对STL类型判断的bool变量了。

// STL
template <typename _Tp>
bool is_stl_v = is_vector_v<_Tp>                ||
                is_array_v<_Tp>                 ||
                is_queue_v<_Tp>                 ||
                is_deque_v<_Tp>                 || 
                is_set_v<_Tp>                   ||
                is_unordered_set_v<_Tp>         ||
                is_multiset_v<_Tp>              ||
                is_unordered_multiset_v<_Tp>    ||
                is_map_v<_Tp>                   ||
                is_unordered_map_v<_Tp>         ||
                is_multimap_v<_Tp>              ||
                is_unordered_multimap_v<_Tp>    ||
                is_stack_v<_Tp>                 ||
                is_string_v<_Tp>                ||
                is_priority_queue_v<_Tp>        ||
                is_list_v<_Tp>                  ||
                is_forward_list_v<_Tp>;

  接下来测试一下(其实不难理解,就是写起来比较费劲)。

#include <iostream>
#include <vector>
#include <queue>
#include <type_traits>
#include <string>
#include <array>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <list>
#include <forward_list>
#include <stack>
#include <deque>

// vector
template <typename _Tp>
struct is_vector : std::false_type{};

template <typename _Tp>
struct is_vector<std::vector<_Tp>> : std::true_type{};

template <typename container_type>
bool is_vector_v = is_vector<container_type>::value;

// queue
template <typename _Tp>
struct is_queue : std::false_type{};

template <typename _Tp>
struct is_queue<std::queue<_Tp>> : std::true_type{};

template <typename container_type>
bool is_queue_v = is_queue<container_type>::value;

// string
template <typename _Tp>
struct is_string : std::false_type{};

template <>
struct is_string<std::string> : std::true_type{};

template <typename container_type>
bool is_string_v = is_string<container_type>::value;

// array
template <typename _Tp>
struct is_array : std::false_type{};

template <typename _Tp, std::size_t N>
struct is_array<std::array<_Tp, N>> : std::true_type{};

template <typename container_type>
bool is_array_v = is_array<container_type>::value;

// priority_queue
template <typename _Tp>
struct is_priority_queue : std::false_type{};

template <typename _Tp>
struct is_priority_queue<std::priority_queue<_Tp>> : std::true_type{};

template <typename container_type>
bool is_priority_queue_v = is_priority_queue<container_type>::value;

// map
template <typename _Tp>
struct is_map : std::false_type{};

template <typename _Tp, typename _Up>
struct is_map<std::map<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_map_v = is_map<container_type>::value;

// unordered_map
template <typename _Tp>
struct is_unordered_map : std::false_type{};

template <typename _Tp, typename _Up>
struct is_unordered_map<std::unordered_map<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_unordered_map_v = is_unordered_map<container_type>::value;

// multimap
template <typename _Tp>
struct is_multimap : std::false_type{};

template <typename _Tp, typename _Up>
struct is_multimap<std::multimap<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_multimap_v = is_multimap<container_type>::value;

// unordered_multimap
template <typename _Tp>
struct is_unordered_multimap : std::false_type{};

template <typename _Tp, typename _Up>
struct is_unordered_multimap<std::unordered_multimap<_Tp, _Up>> : std::true_type{};

template <typename container_type>
bool is_unordered_multimap_v = is_unordered_multimap<container_type>::value;

// set
template <typename _Tp>
struct is_set : std::false_type{};

template <typename _Tp>
struct is_set<std::set<_Tp>> : std::true_type{};

template <typename container_type>
bool is_set_v = is_set<container_type>::value;

// unordered_set
template <typename _Tp>
struct is_unordered_set : std::false_type{};

template <typename _Tp>
struct is_unordered_set<std::unordered_set<_Tp>> : std::true_type{};

template <typename container_type>
bool is_unordered_set_v = is_unordered_set<container_type>::value;

// multiset
template <typename _Tp>
struct is_multiset : std::false_type{};

template <typename _Tp>
struct is_multiset<std::multiset<_Tp>> : std::true_type{};

template <typename container_type>
bool is_multiset_v = is_multiset<container_type>::value;

// unordered_multiset
template <typename _Tp>
struct is_unordered_multiset : std::false_type{};

template <typename _Tp>
struct is_unordered_multiset<std::unordered_multiset<_Tp>> : std::true_type{};

template <typename container_type>
bool is_unordered_multiset_v = is_unordered_multiset<container_type>::value;

// list
template <typename _Tp>
struct is_list : std::false_type{};

template <typename _Tp>
struct is_list<std::list<_Tp>> : std::true_type{};

template <typename container_type>
bool is_list_v = is_list<container_type>::value;

// forward_list
template <typename _Tp>
struct is_forward_list : std::false_type{};

template <typename _Tp>
struct is_forward_list<std::forward_list<_Tp>> : std::true_type{};

template <typename container_type>
bool is_forward_list_v = is_forward_list<container_type>::value;

// stack
template <typename _Tp>
struct is_stack : std::false_type{};

template <typename _Tp>
struct is_stack<std::stack<_Tp>> : std::true_type{};

template <typename container_type>
bool is_stack_v = is_stack<container_type>::value;

// deque
template <typename _Tp>
struct is_deque : std::false_type{};

template <typename _Tp>
struct is_deque<std::deque<_Tp>> : std::true_type{};

template <typename container_type>
bool is_deque_v = is_deque<container_type>::value;

// STL
template <typename _Tp>
bool is_stl_v = is_vector_v<_Tp>                ||
                is_array_v<_Tp>                 ||
                is_queue_v<_Tp>                 ||
                is_deque_v<_Tp>                 || 
                is_set_v<_Tp>                   ||
                is_unordered_set_v<_Tp>         ||
                is_multiset_v<_Tp>              ||
                is_unordered_multiset_v<_Tp>    ||
                is_map_v<_Tp>                   ||
                is_unordered_map_v<_Tp>         ||
                is_multimap_v<_Tp>              ||
                is_unordered_multimap_v<_Tp>    ||
                is_stack_v<_Tp>                 ||
                is_string_v<_Tp>                ||
                is_priority_queue_v<_Tp>        ||
                is_list_v<_Tp>                  ||
                is_forward_list_v<_Tp>;     

struct Node {
    int a;
    int b;
};

int main() {
    std::cout << std::boolalpha;
    std::cout << is_stl_v<std::vector<int>> << '\n';
    std::cout << is_stl_v<std::queue<int>> << '\n';
    std::cout << is_stl_v<std::deque<int>> << '\n';
    std::cout << is_stl_v<std::list<int>> << '\n';
    std::cout << is_stl_v<std::forward_list<int>> << '\n';
    std::cout << is_stl_v<std::array<int, 3>> << '\n';
    std::cout << is_stl_v<std::priority_queue<int>> << '\n';
    std::cout << is_stl_v<std::stack<int>> << '\n';
    std::cout << is_stl_v<std::map<int, int>> << '\n';
    std::cout << is_stl_v<std::unordered_map<int, int>> << '\n';
    std::cout << is_stl_v<std::multimap<int, int>> << '\n';
    std::cout << is_stl_v<std::unordered_multimap<int, int>> << '\n';
    std::cout << is_stl_v<std::set<int>> << '\n';
    std::cout << is_stl_v<std::unordered_set<int>> << '\n';
    std::cout << is_stl_v<std::multiset<int>> << '\n';
    std::cout << is_stl_v<std::unordered_multiset<int>> << '\n';
    std::cout << is_stl_v<std::string> << '\n';
    std::cout << is_stl_v<int> << '\n';
    std::cout << is_stl_v<Node> << '\n';
}

  吃饭去了。

原文地址:https://www.cnblogs.com/ChebyshevTST/p/17891215.html

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐


对象的传值与返回说起函数,就不免要谈谈函数的参数和返回值。一般的,我们习惯把函数看作一个处理的封装(比如黑箱),而参数和返回值一般对应着处理过程的输入和输出。这种情况下,参数和返回值都是值类型的,也就是说,函数和它的调用者的信息交流方式是用过数据的拷贝来完成,即我们习惯上称呼的“值传递”。但是自从引
从实现装饰者模式中思考C++指针和引用的选择最近在看设计模式的内容,偶然间手痒就写了一个“装饰者”模式的一个实例。该实例来源于风雪涟漪的博客,我对它做了简化。作为一个经典的设计模式,本身并没有太多要说的内容。但是在我尝试使用C++去实现这个模式的实例的时候,出现了一些看似无关紧要但是却引人深思的问题
关于vtordisp知多少?我相信不少人看到这篇文章,多半是来自于对标题中“vtordisp”的好奇。其实这个关键词也是来源于我最近查看对象模型的时候偶然发现的。我是一个喜欢深究问题根源的人(有点牛角尖吧),所以当我第一次发现vtordisp的时候,我也是很自然的把它输进google查找相关资料,但
那些陌生的C++关键字学过程序语言的人相信对关键字并不陌生。偶然间翻起了《C++ Primer》这本书,书中列举了所有C++的关键字。我认真核对了一下,竟然发现有若干个从未使用过的关键字。一时间对一个学了六年C++的自己狠狠鄙视了一番,下决心一定要把它们搞明白!图1红色字体给出的是我个人感觉一般大家
命令行下的树形打印最近在处理代码分析问题时,需要将代码的作用域按照树形结构输出。问题的原型大概是下边这个样子的。图中给了一个简化的代码片段,该代码片段包含5个作用域:全局作用域0、函数fun作用域1、if语句作用域2、else语句作用域3和函数main作用域4。代码作用域有个显著的特点就是具有树形结
虚函数与虚继承寻踪封装、继承、多态是面向对象语言的三大特性,熟悉C++的人对此应该不会有太多异议。C语言提供的struct,顶多算得上对数据的简单封装,而C++的引入把struct“升级”为class,使得面向对象的概念更加强大。继承机制解决了对象复用的问题,然而多重继承又会产生成员冲突的问题,虚继
不要被C++“自动生成”所蒙骗C++对象可以使用两种方式进行创建:构造函数和复制构造函数。假如我们定义了类A,并使用它创建对象。Aa,b;Ac=a;Ad(b);对象a和b使用编译器提供的默认构造函数A::A()创建出来,我们称这种创建方式为对象的定义(包含声明的含义)。对象c和d则是使用已有的对象,
printf背后的故事 说起编程语言,C语言大家再熟悉不过。说起最简单的代码,Helloworld更是众所周知。一条简单的printf语句便可以完成这个简单的功能,可是printf背后到底做了什么事情呢?可能很多人不曾在意,也或许你比我还要好奇!那我们就聊聊printf背后的故事。 一、printf
定义 浮点数就是小数点位置不固定的数,也就是说与定点数不一样,浮点数的小数点后的小数位数可以是任意的,根据IEEE754-1985(也叫IEEE Standard for Binary Floating-Point Arithmetic)的定义,浮点数的类型有两种:单精度类型(用4字节存储)和双精度
在《从汇编看c++的引用和指针》一文中,虽然谈到了引用,但是只是为了将两者进行比较。这里将对引用做进一步的分析。1 引用的实现方式在介绍有关引用的c++书中,很多都说引用只是其引用变量的一个别名。我自己不是很喜欢这种解释,因为觉得这种解释会给人误解,好像引用和变量就是一回事,而且,书中也没有给出,为
今天写程序的时候,创建了一个结构体:struct BufferObj {char* buf;int bufLen;SOCKADDR_STORAGE addr;int addrLen;struct BufferObj* next;};该结构体有一个next指针,本意是这个指针初始的时候应该为NULL,
placement operator new是重载的operator new运算符,它允许我们将对象放到一个指定的内存中。下面来看c++源码:class X {private: int _x;public: X(int xx = 0) : _x(xx) {} ~X() {} void* operat
编码的目的,就是给抽象的字符赋予一个数值,好在计算机里面表示。常见的ASCII使用8bit给字符编码,但是实际只使用了7bit,最高位没有使用,因此,只能表示128个字符;ISO-8859-1(也叫Latin-1,或者直接8859)使用全8bit编码,可以看成是ASCII的超集,因为它的低128个字
在宏定义当中,常常可以看到宏的参数以及整个宏的定义都被小括号包围,就像下面的 MIN、MAX、ABS 宏一样: 上面的图截取自 iOS 的系统库,那为什么它们需要这些括号包围起来呢? 下面假如我们自定义了宏 ceil_div,代码如下: #define ceil_div(x, y) (x + y -
c++中,当继承结构中含有虚基类时,在构造对象时编译器会通过将一个标志位置1(表示调用虚基类构造函数),或者置0(表示不调用虚基类构造函数)来防止重复构造虚基类子对象。如下图菱形结构所示:当构造类Bottom对象时,Bottom构造函数里面的c++伪码如下(单考虑标志位,不考虑其他)://Botto
在C中,使用fopen打开文件有两种模式:一种是文本模式,一种是二进制模式。那这两种模式之间有什么区别,是不是使用文本模式打开的文件就只能使用文本函数比如fprintf来操作,而使用二进制打开的文件就只能使用二进制函数比如fwrite来操作呢? 答案是否定的。C里面之所以有文本模式和二进制模式,完全
尾数英文名叫mantissa,significand,coefficient,用于科学计数法中。科学计数法的表示方法为: Mantissa x Base^Exponent 举个例子,123.45用科学计数法可以表示为: 12345 x 10^(-2) 其中12345就是尾数Mantissa,10是基
定义宏时可以让宏接收可变参数,对于可变参数的定义,标准 C 和 GNU C(GNU 对 C的扩展)是不一样的。 标准 C 标准 C 对于可变参数的定义如下,使用...: #define eprintf(...) fprintf (stderr, __VA_ARGS__) 在宏定义中,__VA_ARG
宏分为两种,一种是 object-like 宏,比如: #define STR &quot;Hello, World!&quot; 另一种是 function-like 宏,比如: #define MIN(X, Y) ((X) &lt; (Y) ? (X) : (Y)) 对于 function-li
副作用(Side Effect) 在计算机当中,副作用指当调用一个函数时,这个函数除了返回一个值之外,还对主调函数产生了影响,比如修改了全局变量,修改了参数等等。 宏的重复副作用 对于求两个数中的最小数,常常可以定义一个宏 MIN,定义如下: #define MIN(X, Y) ((X) &lt;