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 = 3;

    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 = 1;
    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("1"));
    vp.push_back(Person("2"));
    vp.push_back(Person("3"));
     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 0;
}

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 1;
}

void sample6()
{
    //enable_if
    int i = 1;
    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 = 1;
    MyToString(i);
    double d = 123.213;
    MyToString(d);
    std::string s = "zxd12";
    MyToString(s);
}
//===============================================================
template<std::size_t I =0,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 = 0, 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 + 1>(s,t);
}

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

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

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