type_traits--3

最新推荐文章于 2022-10-14 11:16:16 发布
最新推荐文章于 2022-10-14 11:16:16 发布
阅读量372 收藏 1
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40132943/article/details/122914297
版权

文章目录

一、源码

老规矩先放源码

template <class _Ty>
struct remove_extent { // remove array extent
    using type = _Ty;
};

template <class _Ty, size_t _Ix>
struct remove_extent<_Ty[_Ix]> {
    using type = _Ty;
};

template <class _Ty>
struct remove_extent<_Ty[]> {
    using type = _Ty;
};

template <class _Ty>
using remove_extent_t = typename remove_extent<_Ty>::type;

template <class _Ty>
struct remove_all_extents { // remove all array extents
    using type = _Ty;
};

template <class _Ty, size_t _Ix>
struct remove_all_extents<_Ty[_Ix]> {
    using type = typename remove_all_extents<_Ty>::type;
};

template <class _Ty>
struct remove_all_extents<_Ty[]> {
    using type = typename remove_all_extents<_Ty>::type;
};

template <class _Ty>
using remove_all_extents_t = typename remove_all_extents<_Ty>::type;

template <class _Ty>
struct remove_pointer {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty*> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* const> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* volatile> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* const volatile> {
    using type = _Ty;
};

template <class _Ty>
using remove_pointer_t = typename remove_pointer<_Ty>::type;

template <class _Ty, class = void>
struct _Add_pointer { // add pointer (pointer type cannot be formed)
    using type = _Ty;
};

template <class _Ty>
struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { // (pointer type can be formed)
    using type = remove_reference_t<_Ty>*;
};

template <class _Ty>
struct add_pointer {
    using type = typename _Add_pointer<_Ty>::type;
};

template <class _Ty>
using add_pointer_t = typename _Add_pointer<_Ty>::type;

template <class>
_INLINE_VAR constexpr bool is_array_v = false; // determine whether type argument is an array

template <class _Ty, size_t _Nx>
_INLINE_VAR constexpr bool is_array_v<_Ty[_Nx]> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_array_v<_Ty[]> = true;

template <class _Ty>
struct is_array : bool_constant<is_array_v<_Ty>> {};

#if _HAS_CXX20
template <class>
inline constexpr bool is_bounded_array_v = false;

template <class _Ty, size_t _Nx>
inline constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;

template <class _Ty>
struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};

template <class>
inline constexpr bool is_unbounded_array_v = false;

template <class _Ty>
inline constexpr bool is_unbounded_array_v<_Ty[]> = true;

template <class _Ty>
struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
#endif // _HAS_CXX20

template <class>
_INLINE_VAR constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference

template <class _Ty>
_INLINE_VAR constexpr bool is_lvalue_reference_v<_Ty&> = true;

template <class _Ty>
struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};

template <class>
_INLINE_VAR constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference

template <class _Ty>
_INLINE_VAR constexpr bool is_rvalue_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};

template <class>
_INLINE_VAR constexpr bool is_reference_v = false; // determine whether type argument is a reference

template <class _Ty>
_INLINE_VAR constexpr bool is_reference_v<_Ty&> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_reference : bool_constant<is_reference_v<_Ty>> {};

template <class>
_INLINE_VAR constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty*> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* const> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* volatile> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* const volatile> = true;

template <class _Ty>
struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};

template <class _Ty>
_INLINE_VAR constexpr bool is_null_pointer_v =
    is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t

template <class _Ty>
struct is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};

template <class _Ty>
struct is_union : bool_constant<__is_union(_Ty)> {}; // determine whether _Ty is a union

template <class _Ty>
_INLINE_VAR constexpr bool is_union_v = __is_union(_Ty);

template <class _Ty>
struct is_class : bool_constant<__is_class(_Ty)> {}; // determine whether _Ty is a class

template <class _Ty>
_INLINE_VAR constexpr bool is_class_v = __is_class(_Ty);

template <class _Ty>
_INLINE_VAR constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;

template <class _Ty>
struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; // determine whether _Ty is a fundamental type

template <class _From, class _To>
struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
    // determine whether _From is convertible to _To
};

template <class _From, class _To>
_INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);

template <class _Ty>
struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type

template <class _Ty>
_INLINE_VAR constexpr bool is_enum_v = __is_enum(_Ty);

二、源码解析

1.remove_extent:移除数组的第一层维度

例如remove_extent<int [10] [2]> _Ty = int[2]，第一层维度int[10]被擦除了，剩下int[2]

//定义基础类型
template <class _Ty>
struct remove_extent { // remove array extent
    using type = _Ty;
};
//对上述特化，利用模板特化反向推导出Ix的大小，并且移除掉[Ix]。
//例如传入的是int[10][2]最后剩下的类型也就是_Ty的类型是int[2]
//特化擦除会将已有的擦除掉，因为[Ix]也就是[10]已经被定义了，剩下的_Ty = int[2]
template <class _Ty, size_t _Ix>
struct remove_extent<_Ty[_Ix]> {
    using type = _Ty;
};
//当传入的是没有指定大小的数组例如int[],这类的
template <class _Ty>
struct remove_extent<_Ty[]> {
    using type = _Ty;
};
//重新定义类型。注意typename显示声明一个类型时使用
template <class _Ty>
using remove_extent_t = typename remove_extent<_Ty>::type;

测试demo

#include <iostream>
using namespace std;

template<class T>
struct MyStruct
{
    using type = T;
};

template<class T, size_t Ix>
struct MyStruct<T[Ix]>
{
    constexpr static size_t value = Ix;
    using type = T;
};

template<class T>
struct MyStruct<T[]>
{
    using type = T;
};

int main()
{
    MyStruct<int>::type a;
    MyStruct<int[]>::type b;
    MyStruct<int[10]>::type c;
    MyStruct<int[10][2]>::type d;
    auto e = MyStruct<int[10][2]>::value;
    MyStruct<int*>::type f;
    return 0;
}

在这里插入图片描述
我还是喜欢根据现象反推导实际的实现。根据定义看现象，容易陷入误区，还是实践靠谱。

根据demo测试尝试推测模板类型推导：实际就是有啥擦除啥，你自己特化了什么他就把那部分去除掉，感觉编译器实现的方式就是字符串匹配。找到最合适那个匹配到，已有的去除掉。就像int【10】【2】最后被提取了【10】，其实我以为会是【2】被提取走，剩下int【10】，但实际是先匹配的第一层。直接看结果比看啥定义靠谱。

2.remove_all_extents: 移除所有数组维度

实际就是递归调用，直到所有数组都被擦除，然后返回最后的类型。

typename remove_all_extents<_Ty>::type

就是递归调用

type=<int[10] [2]>::type，type=<int [2]>::type, type=::type=int

template <class _Ty>
struct remove_all_extents { // remove all array extents
    using type = _Ty;
};

template <class _Ty, size_t _Ix>
struct remove_all_extents<_Ty[_Ix]> {
    //和上述这里不一致。
    //这里递归调用自身,将全部数组擦除
    using type = typename remove_all_extents<_Ty>::type;
};

template <class _Ty>
struct remove_all_extents<_Ty[]> {
    //和上述这里不一致。
    //这里递归调用自身,将全部数组擦除
    using type = typename remove_all_extents<_Ty>::type;
};
//重新定义类型。注意typename显示声明一个类型时使用
template <class _Ty>
using remove_all_extents_t = typename remove_all_extents<_Ty>::type;

3.remove_pointer: 移除指针类型

//这对大家来说看的实在太多了。就是利用特化移除掉某个属性。这类的基本实现都一样。
template <class _Ty>
struct remove_pointer {
    using type = _Ty;
};
//特化，擦除掉指针类型
template <class _Ty>
struct remove_pointer<_Ty*> {
    using type = _Ty;
};
//特化，擦除掉const指针类型
template <class _Ty>
struct remove_pointer<_Ty* const> {
    using type = _Ty;
};
//特化，擦除掉volatile指针类型
template <class _Ty>
struct remove_pointer<_Ty* volatile> {
    using type = _Ty;
};
//特化，擦除掉const volatile指针类型
template <class _Ty>
struct remove_pointer<_Ty* const volatile> {
    using type = _Ty;
};
//新定义一个类型，方便使用
template <class _Ty>
using remove_pointer_t = typename remove_pointer<_Ty>::type;

4.add_pointer : 添加指针类型

与之前说过的添加引用类型类似

//普通模板+第二个参数是void因为特化要单参数使用void_t
template <class _Ty, class = void>
struct _Add_pointer { // add pointer (pointer type cannot be formed)
    using type = _Ty;
};
//remove_reference_t移除引用类型，之前讲过，就如上述实现方式一直，利用特化<Ty&><Ty&&>擦除掉引用
//void_t<remove_reference_t<_Ty>*>擦除掉引用，后判断该类型能否定义为指针类型。不能则调用失败。
template <class _Ty>
struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { // (pointer type can be formed)
    using type = remove_reference_t<_Ty>*;
};
//中转战一样，又定义了一次。应该是为了隐藏实现。便于查看
template <class _Ty>
struct add_pointer {
    using type = typename _Add_pointer<_Ty>::type;
};
//_t类型，统一格式利于使用。
template <class _Ty>
using add_pointer_t = typename _Add_pointer<_Ty>::type;

5.is_array: 判断是否是数组类型

和之前数组类型擦除类似，不过那个是直接擦除重定义一个类型，这个是判断，特化的变量

//普通模板，也就是最后的出口。当所有特化都不满足才会被匹配到
template <class>
_INLINE_VAR constexpr bool is_array_v = false; // determine whether type argument is an array
//是数组类型则能跟此特化匹配到，最后结果为true;
template <class _Ty, size_t _Nx>
_INLINE_VAR constexpr bool is_array_v<_Ty[_Nx]> = true;
//是数组类型则能跟此特化匹配到，最后结果为true;
template <class _Ty>
_INLINE_VAR constexpr bool is_array_v<_Ty[]> = true;
//定义一个bool_constant类型，判断是否是数组，最后会是true_type, false_type
template <class _Ty>
struct is_array : bool_constant<is_array_v<_Ty>> {};
//就是将是否指定了大小分离开了，分成两个进行判断了
#if _HAS_CXX20
template <class>
inline constexpr bool is_bounded_array_v = false;
//指定了大小
template <class _Ty, size_t _Nx>
inline constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;

template <class _Ty>
struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};

template <class>
inline constexpr bool is_unbounded_array_v = false;
//没有指定了大小
template <class _Ty>
inline constexpr bool is_unbounded_array_v<_Ty[]> = true;

template <class _Ty>
struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
#endif // _HAS_CXX20

6.is_reference:是否是引用类型。is_lvalue_reference: 左值引用，is_rvalue_reference: 右值引用

这个实现看的太多了，都是利用特化进行判断类型。

template <class>
_INLINE_VAR constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference

template <class _Ty>
_INLINE_VAR constexpr bool is_lvalue_reference_v<_Ty&> = true;

template <class _Ty>
struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};

template <class>
_INLINE_VAR constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference

template <class _Ty>
_INLINE_VAR constexpr bool is_rvalue_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};

template <class>
_INLINE_VAR constexpr bool is_reference_v = false; // determine whether type argument is a reference

template <class _Ty>
_INLINE_VAR constexpr bool is_reference_v<_Ty&> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_reference : bool_constant<is_reference_v<_Ty>> {};

7.is_pointer: 是否是指针类型

都是利用特化变量，判断是否是指针类型。is开头的实现都差不多。

template <class>
_INLINE_VAR constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty*> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* const> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* volatile> = true;

template <class _Ty>
_INLINE_VAR constexpr bool is_pointer_v<_Ty* const volatile> = true;

template <class _Ty>
struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};

需要注意为很么需要单独_Ty* const,因为又函数是const的，而模板匹配const int * 和int * const显然不是同一个概念。
demo

#include <iostream>
using namespace std;

template <class>
 constexpr bool is_pointers = false; // determine whether _Ty is a pointer

template <class _Ty>
constexpr bool is_pointers<_Ty*> = true;

int main()
{
    auto a = is_pointers<int*>;
    auto b = is_pointers<int* const>;
    return 0;
}

在这里插入图片描述

8.is_null_pointer: 判断指针是否是空，利用is_same

template <class _Ty>
_INLINE_VAR constexpr bool is_null_pointer_v =
    is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t
//remove_cv_t<_Ty>移除掉const,volatile属性
//利用is_same判断remove_cv_t<_Ty和nullptr_t是不是一个类型，是则为ture，不是则为false.
template <class _Ty>
struct is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};
//继承bool_constant最后为true_type, false_type;

9.判断是否是基本类型(整形，浮点数，void，nullptr)

template <class _Ty>
_INLINE_VAR constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
//is_arithmetic_v判断是不是算数类型，利用模板继承+is_same可变参数，一次提取比较，
//is_void_v判断是不是void类型
//is_null_pointer_v判断是不是空指针。
//is_arithmetic_v, is_void_v具体见其他文章。有介绍。
template <class _Ty>
struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; // determine whether _Ty is a fundamental type

10.is_union:判断是不是内联结构，is_class：判断是不是类对象。is_convertible:判断能否转化从from到to。is_enum：判断是不是枚举类型（只能看到定义。没有找到具体实现。待日后找到后补上）

template <class _Ty>
struct is_union : bool_constant<__is_union(_Ty)> {}; // determine whether _Ty is a union

template <class _Ty>
_INLINE_VAR constexpr bool is_union_v = __is_union(_Ty);

template <class _Ty>
struct is_class : bool_constant<__is_class(_Ty)> {}; // determine whether _Ty is a class

template <class _Ty>
_INLINE_VAR constexpr bool is_class_v = __is_class(_Ty);

emplate <class _From, class _To>
struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
    // determine whether _From is convertible to _To
};

template <class _From, class _To>
_INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);

template <class _Ty>
struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type

template <class _Ty>
_INLINE_VAR constexpr bool is_enum_v = __is_enum(_Ty);
整理行囊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
std::remove_extent返回数组降低一个维度后的数据类型, std::rank返回数组维度, std::extent返回数组第一个维度的长度
u010196624的博客
05-10 1526
std::remove_extent 返回数组降低一个维度后的数据类型。不改变数据类型的限制属性(const, volatile, const volatile) 一维数组降低到0维度； 二维数组降低到一维数组； 三维数组降低到二维数组； std::extent 返回数组第一个维度的长度 std::remove_all_extents 返回数组的实际类型, int[] -> ...
头文件cmath的用法
Carry20120102的博客
12-23 189
【代码】头文件cmath的用法。
c++11 type_traits类型萃取
Wujinchuang的博客
02-22 692
一. c++ traits定义 type_traits使用模板技术来萃取类型(包含自定义类型和内置类型)的某些特性，用以判断该类型是否含有某些特性，从而在泛型算法中来对该类型进行特殊的处理用来提高效率或者其他。 通过type_traits可以实现在编译期计算、查询、判断、转换和选择，增强了泛型编程的能力，也增强了程序的弹性，使得我们在编译期就能做到优化改进甚至排错，能进一步提高代码质量。 二.几个栗子 http://www.cplusplus.com/reference/type_traits/?kw=ty
C++11系列 make_shared
CoderAldrich的专栏
05-15 9006
转载自：http://bitdewy.github.io/blog/2014/01/12/why-make-shared/C++11 中引入了智能指针, 同时还有一个模板函数 std::make_shared 可以返回一个指定类型的 std::shared_ptr, 那与 std::shared_ptr 的构造函数相比它能给我们带来什么好处呢 ?优点效率更高shared_ptr 需要维护引用计数的...
【C++11】C++类型完全退化（拓展std::decay的功能）
几罗星人的专栏
11-19 1万+
C++11提供了一个模板类，来为我们移除类型中的一些特性，比如引用、常量、volatile，但是注意不包括指针特性，这个类就是std::decay，在头文件type_traits（类型萃取）中。如果我们希望将指针特性也退化掉，则需要自己写代码实现。但是np_decay类只能退化一重的修饰，fulltype通过不断递归继承，每继承一次退化一次，退化到没效果了就是全部特性都移除了，这时候的T作为结果的type类型，实现完全的退化。
ft_containers:列表，向量，地图（基于红黑树），堆栈和队列STL容器的实现。 此外，重新实现了默认分配器，reverse_iterator，iterator_traits，一些type_traits，pair和几个关系运算符模板。 参考标准C ++ 98
04-05
ft_containers 42 ft_containers项目关于一些C ++ 98的STL容器 ... iterator_traits和一些type_traits改编 对和一些关系运算符模板 运行测试 clang++ main.cpp -std=c++98 -Wall -Wextra -Werror && ./a.out
stm32-rcc-traits：STM32 RCC通用特征
02-15
stm32-rcc-特征STM32 RCC通用特性
c++_traits.pdf
08-29
c++_traits Classes which encapsulate properties of types Is this an integer type? An arithmetic type? A pointer type?... Closely related to partial specialization
abseil-cpp grpc编译基础库
06-09
GRPC交叉编译必须的基础库之一，目前最新的发布版本。在交叉编译GRPC时候，必须先编译好此库，并放到third_party的对应的abseil中。
Predicting-Myers-Briggs-Type-Indicator-with-Recurrent-Neural-Networks
05-25
预测具有递归神经网络的迈尔斯布里格斯类型指标 作者 伊恩·斯科特·奈特（Ian Scott Knight） 斯坦福大学符号系统系 雷恩·埃尔南德斯（Rayne Hernandez） 斯坦福大学数学与计算科学系 抽象的 ...
Boost-源码分析笔记5-remove-bounds
fightinggg的博客
03-19 156
喜欢这篇文章吗？喜欢的话去看博主的置顶博客，即可依据分类找到此文章的原版得到更好的体验， 图片及代码显示的问题，笔者深感抱歉，想要更好的体验去原博文即可。 title: Boost 源码分析笔记5 - remove_bounds mathjax: true date: 2020-03-17 16:14:10 categories: [c++笔记,Boost源码分析笔记] tags: [c++笔记...
C++11/14/17 nullptr
Cynhard的专栏
05-16 1129
nullptr的引入 什么是nullptr呢？为什么要引入nullptr呢？任何事物的产生都有其缘由和意义，nullptr也不例外。一切还得从0开始说。C++98中的0即表示整数字面值0，又表示指针的0值： class Foo { public: void bar() {} }; int *p = 0; // 0表示普通指针的0值 void (Foo::*pBar)() =
Windows多线程及其相关标准库源码剖析（1）：thread
lzx的博客
04-18 720
标准库位置 作为一名C++的学习者，想要进阶，阅读源码是必不可少的 我们首先来看看源码的位置：首先引入头文件，然后按住CTRL点击进去，可以看到标准库的位置 下面来看看源码吧 可见thread文件主要包括四个部分 thread类 命名空间this_thread thread的内部类id 解释部分 #if _HAS_CXX20 class jthread; #endif // _HAS_CXX20 此处意思是如果是cpp20，则使用jthread类，此类在该头文件中也已经定义了，可见，其内容和th
C++ 中using 的使用
热门推荐
私房菜
12-07 9万+
若不是特别熟悉函数指针与typedef的童鞋，我相信第一眼还是很难指出FP其实是一个别名，代表着的是一个函数指针，而指向的这个函数返回类型是void，接受参数是int, const std::string&。我想，即使第一次读到这样代码，并且不知道 C++11 using 用法的童鞋也能很容易知道 FP 是一个别名，using 的写法把别名的名字强制分离到了左边，而把别名指向的放在了右边，比较清晰。今天在看vector.h的时候，碰到一个using的奇怪用法，才疏学浅之前没有碰到过，整理一下。
c++11 之type_traits
lq123的博客
07-25 1744
1.type_traits-类型萃取  （1）type_traits可以在一定程度上消除 switch-case 或者 if-else语句，降低程序的复杂度 （2）可以在编译期就检查出是否是正确类型 1.1基本的type_traits 定义编译期常量   struct GetLeftSize {    static const int value =1; } 或  st
using关键字作用小结
qq_43148810的博客
07-02 172
1）、using-directives(打开命名空间) using namespace std;using std::cout;using Base::date;(Base为类名) 2）、type alias： using value_type = _Ty; using allocator_type = _Alloc; using pointer = typename _Mybase::pointer; using const_pointer = typename _Mybase::const_pointe
模板函数2
m0_51918781的博客
10-14 89
Min(const char* const & a,const char* const & b) //没有泛化版本 就没有特化 //版本 为了特化T const char* 特化T const & 保留。void func(T&& x) //右值模板是一个未定义的模板 根据传入的实参确定 x并不是一个确定的 //右值引用。
262-C++ C11标准
weixin_45964837的博客
03-17 1036
1.C++中的类型转换分为四种形式： C语言中的转换都是没有意义的，就是说C语言中的强转都是(int) (int*)这样的类型，你不知道它这么转的意义是什么，意义不够明确，所以C++中给出了4种类型转换 ①static_cast：值的转换，相当于C语言中的强转，这个转换意义很明确就是将float类型转成整型 int a = 10; float ft = 12.23; a = static_cast<int>(ft);//转成int ft = static_cast<float>(a)
STL中__type_traits
simon的博客
07-27 207
[TOC] # 概述 `iterator_traits`是萃取迭代器的特性，而`__type_traits`是萃取型别的特性。萃取的型别如下： - non-trivial default ctor? - non-trivial copy ctor? - non-trivial assignment operator? - non-trivial dto...
type_traits
最新发布
06-06
type_traits 是 C++ 标准库中的一个头文件，该头文件中定义了许多用于类型特性萃取的模板类和函数。它可以在编译期间对类型进行相关的属性判断和操作，包括但不限于以下内容： 1. 判断是否是指针类型、引用类型、函数类型、数组类型、类类型等； 2. 判断是否是 const、volatile、trivial、POD 等类型； 3. 获取类型的基本类型、成员变量类型、返回值类型等； 4. 实现类型转换、类型萃取、类型选择等功能。 type_traits 提供了对类型的静态检查和转换功能，可以在编译期间优化代码、避免运行时错误、提高代码的可读性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值