c++ templates常用函数

说明

c++ templates学习中会遇到大量的模版常用函数，书上不会详细介绍，查看一个之后要永久记录一段时间之后再看看，这里总结一下。

undeclared();

undeclared();//若undeclared();未定义，则在第一阶段编译时报错

undeclared(t);//若t未知，则在第二编译阶段报错

std::decay<T>

在<type_traits>定义，将T类型转换为它的衰变类型。例如去const、去&、去易变性限定符、数组变为*。

#include <type_traits>
#include <iostream>
template<typename T1,typename T2>
auto max(T1 a, T2 b)->typename std::decay<decltype(true ? a : b)>::type
{return a > b ? a : b;
}
template<typename T>
void fun(T&& t)
{//我们希望创建与参数同类型的，而不是引用typedef typename std::decay<T>::type U;U u;//x与t的原始类型相同typename std::decay<T>::type x = t;
}
enum Enuma
{type1,type2
};
class Type{};
void main()
{//类型都是intstd::decay<int&&>::type a;std::decay<int&>::type b;std::decay<const int>::type c;std::decay<volatile int>::type d;//降级为int*std::decay<int[10]>::type e;//void(*)()std::decay<void()>::type f;//enum、class类型std::decay<const Enuma>::type g;std::decay<const Type&>::type h;a = 1;
}

std::remove_reference_t<T> //移除引用
std::remove_cv_t<T>//移除const或volatile
auto初始化是衰变的

std::common_type<typename... T>

函数返回值的类型可以转换的类型。

确定所有类型 T... 的共用类型，即所有 T... 都能隐式转换到的类型。若这种类型（根据后述规则确定）存在，则成员 type 指名该类型。否则，无成员 type 。

#include <type_traits>
#include <iostream>
template<typename T,typename U>
typename std::common_type<T, U>::type max(T t, U u)
{return t > u ? t : u;
}
enum Enuma
{type1,type2
};
class Type{};
void main()
{auto a = max(1, 2.1);//dobuleauto b = max(2, 1.1);//doublestd::cout<< max(1, 2.1)<<std::endl;//2.1std::cout<< max(2, 1.1);//2a = 1;
}

#include <iostream>
#include <type_traits>struct Base {};
struct Derived : Base {};int main(int argc, char** argv)
{{typedef std::common_type<char, short, int>::type A;        typedef std::common_type<float, double>::type B;           typedef std::common_type<Derived, Base>::type C;           typedef std::common_type<Derived*, Base*>::type D;         typedef std::common_type<const int, volatile int>::type E; std::cout << std::boolalpha;std::cout << "typedefs of int:" << std::endl;std::cout << "A: " << std::is_same<int, A>::value << std::endl;std::cout << "B: " << std::is_same<int, B>::value << std::endl;std::cout << "C: " << std::is_same<int, C>::value << std::endl;std::cout << "D: " << std::is_same<int, D>::value << std::endl;std::cout << "E: " << std::is_same<int, E>::value << std::endl;}{typedef std::common_type_t<char, short, int> A;        typedef std::common_type_t<float, double> B;           typedef std::common_type_t<Derived, Base> C;           typedef std::common_type_t<Derived*, Base*> D;         typedef std::common_type_t<const int, volatile int> E; std::cout << std::boolalpha;std::cout << "typedefs of int:" << std::endl;std::cout << "A: " << std::is_same_v<int, A> << std::endl;std::cout << "B: " << std::is_same_v<int, B> << std::endl;std::cout << "C: " << std::is_same_v<int, C> << std::endl;std::cout << "D: " << std::is_same_v<int, D> << std::endl;std::cout << "E: " << std::is_same_v<int, E> << std::endl;}return 0;
}输出：
typedefs of int:
A: true
B: false
C: false
D: false
E: true
typedefs of int:
A: true
B: false
C: false
D: false
E: true

std::is_same<T1,T2>

如果 T 与 U 指名同一类型（考虑 const/volatile 限定），那么成员常量 value 等于 true。

    auto b=std::is_same<int, const int>::value;//false//is_same<>不降级auto b1 = std::is_same<int,std::uint8_t>::value;//false//类型int不相同

constexpr

提供在编译时计算某些值的能力。

template<typename T1,typename T2>constexpr auto max(T1 a,T2 b){return a>b?a:b;}int a[::max(sizeof(int,1000u)];

std::is_default_constructible<T>

T是否有默认的构造函数。


#include <type_traits>
class A {};
class B {B() = delete;
};
int main(int argc, char** argv) {bool b = std::is_default_constructible<A>::value;//truebool b1 = std::is_default_constructible<B>::value;//false
}

std::add_const<T>, std::add_cv<T>, std::add_volatile<T>

增加const， const volatile, volatile.

#include <iostream>
#include <type_traits>struct foo
{void m() { std::cout << "Non-cv\n"; }void m() const { std::cout << "Const\n"; }void m() volatile { std::cout << "Volatile\n"; }void m() const volatile { std::cout << "Const-volatile\n"; }
};int main()
{foo{}.m();//Non-cvstd::add_const<foo>::type{}.m();//Conststd::add_volatile<foo>::type{}.m();//Volatilestd::add_cv<foo>::type{}.m();//Const - volatile
}

std::enable_if<bool B,typename T>

如果B为true，则enable_if拥有T::type,否则无该type。

用于函数返回值、函数参数、模板形参。

template <class _First, class... _Rest>
array(_First, _Rest...) -> 
array<typename _Enforce_same<_First, _Rest...>::type, 1 + sizeof...(_Rest)>;

...补充中