c++11 template 模板练习

直接上代码吧

to do

 // 111111.cpp: 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <iostream>
 #include <map>
 #include <sstream>
 #include <algorithm>
 #include <vector>
 #include <tuple>
 #include <type_traits>

 using namespace std;

 void sample1()
 {
     //基本的type trait
     int i = ;

     if (true == std::is_void<int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }

     if (true == std::is_const<int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }

     if (true == std::is_const<int* const>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }

     if (true == std::is_same<int, signed int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }
 }

 void sample2()
 {
     //从 remove_cv remove_reference 到 decay
     // const volatile int(remove_cv)--> int == signed int
     if (true == std::is_same< std::remove_cv<const volatile int>::type, signed int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }

     // const volatile int&(remove_reference remove_cv )--> int == signed int
     // equal std::decay
     if (true == std::is_same< std::remove_cv< std::remove_reference< const volatile int&>::type>::type, signed int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }

     // const volatile int&(remove_reference remove_cv )--> int == signed int
     // equal std::decay<>
     if (true == std::is_same< std::decay< const volatile int&>::type, signed int>::value) {
         std::cout << true << std::endl;
     }
     else {
         std::cout << false << std::endl;
     }
 }
 //===============================================================
 // std::decay 还可以用于将函数退化成函数指针 保存 用于延时执行

 template<typename F>
 struct SimpleFunction {
     using FnType = typename std::decay<F>::type;
     SimpleFunction(F f) :m_fn(f) {}
     void run() { m_fn(); }
     FnType m_fn;
 };

 void SimpFunctiontest() {
     std::cout << __FUNCTION__ << std::endl;
 }

 void sample3()
 {
     SimpleFunction<void()> f(SimpFunctiontest);
     f.run();
 }
 //===================================================
 template<typename T>
 typename std::enable_if<std::is_same<T, int>::value, T>::type
 foo(T t) {
     return t;
 }

 void sample4()
 {
     //enable_if
     int i = ;
     foo(i);  //编译通过
     char b = 'x';
     //foo(b) //编译无法通过 因为 b的type不是int
 }
 //==============================================================
 class Person {
 public:
     Person(std::string s) :name(s) {}
     std::string name;
 };

 std::string funtion(Person p) {
     return p.name;
 }

 template<typename Fn>
 multimap<typename std::result_of<Fn(Person)>::type,Person>
 GroupBy(const vector<Person>& vt, Fn&& keySelector)
 {
     typedef typename std::result_of<Fn(Person)>::type key_type;
     multimap<key_type, Person> map;
     std::for_each(vt.begin(), vt.end(), [&](const Person& person)
     {
         map.insert(make_pair(keySelector(person), person));
     });
     return map;
 }

 void sample5() {
     // result_of 获取函数返回值类型
     vector<Person> vp;
     vp.push_back(Person(""));
     vp.push_back(Person(""));
     vp.push_back(Person(""));
      GroupBy(vp, funtion);
 }
 //==============================================================
 template<typename T>
 typename std::enable_if<std::is_arithmetic<T>::value,int>::type foo1(T t)
 {
     std::cout << t << std::endl;
     return ;
 }

 template<typename T>
 typename std::enable_if<!std::is_arithmetic<T>::value, int>::type foo1(T t)
 {
     std::cout << typeid(T).name() << std::endl;
     return ;
 }

 void sample6()
 {
     //enable_if
     int i = ;
     std::string b = "123ffdh";
     foo1(i);
     foo1(b);
 }
 //==========================================================================================
 template<typename T>
 typename std::enable_if<std::is_arithmetic<T>::value,std::string>::type
 MyToString(T& t) { return std::to_string(t); }

 template<typename T>
 typename std::enable_if<std::is_same<T,std::string>::value,std::string>::type
 MyToString(T& t) { return t; }

 void sample7()
 {
     //enable_if示例
     int i = ;
     MyToString(i);
     double d = 123.213;
     MyToString(d);
     std::string s = "zxd12";
     MyToString(s);
 }
 //===============================================================
 template<std::size_t I =,typename Tuple>
 typename std::enable_if<I == std::tuple_size<Tuple>::value>::type printtp(std::string s,const Tuple& t){
     std::cout << std::endl <<s << std::endl;
 }

 template<std::size_t I = , typename Tuple>
 typename std::enable_if<I < std::tuple_size<Tuple>::value>::type printtp(std::string& s,const Tuple& t) {
     std::cout << std::get<I>(t) << std::endl;
     s += std::to_string(I);
     s += " ";
     printtp<I + >(s,t);
 }

 template<typename ... Args>
 void MyPinrt(Args... args)
 {
     std::string s;
     printtp(s,std::make_tuple(args...));
 }

 void sample8()
 {
     MyPinrt(,1.2324,false,"safda");
 }

 //===========================================================================
 int main()
 {
     /*sample1();
     sample2();
     sample3();
     sample4();*/
     //sample5();
     //sample6();
     sample7();
     sample8();
     return ;
 }