template<typename... _Args>
void emplace_front(_Args&&... __args);

template<類型 ... args>

template<int ... data> xxxxxx;

#include <iostream>
using namespace std;

//這里加一個(gè)空模板函數(shù)是為了編譯可以通過(guò)，否則編譯期間調(diào)用printAmt<int>(int&)就會(huì)找不到可匹配的函數(shù)
//模板參數(shù)第一個(gè)類型實(shí)際上是用不到的，但是這里必須要加上，否則就是調(diào)用printAmt<>(int&)，模板實(shí)參為空，但是模板形參列表是不能為空的
template<class type>
void printAmt(int &iSumAge)
{
    return;
}

template<class type, int age0, int ... age>
void printAmt(int &iSumAge)
{
    iSumAge += age0;
    //這里sizeof ... (age)是計(jì)算形參包里的形參個(gè)數(shù)，返回類型是std::size_t，后續(xù)同理
    if ( (sizeof ... (age)) > 0 )
    {
        //這里的age...其實(shí)就是語(yǔ)法中的一種包展開(kāi)，這個(gè)后續(xù)會(huì)具體說(shuō)明
        printAmt<type, age...>(iSumAge);
    }
}

int main()
{
    int sumAge = 0;
    printAmt<int,1,2,3,4,5,7,6,8>(sumAge);
    cout << "the sum of age is " << sumAge << endl;
    return 0;
}

#include <iostream>
using std::cout;
using std::endl;

void xprintf()
{
    cout << endl;
}

template<typename T, typename... Targs>
void xprintf(T value, Targs... Fargs)
{
    cout << value << ' ';
    if ( (sizeof ...(Fargs)) > 0 )
    {
        //這里調(diào)用的時(shí)候沒(méi)有顯式指定模板，是因?yàn)楹瘮?shù)模板可以根據(jù)函數(shù)參數(shù)自動(dòng)推導(dǎo)
        xprintf(Fargs...);
    }
    else
    {
        xprintf();
    }
}

int main()
{
    xprintf("小明個(gè)人信息:", "小明", "男", 35, "程序員", 169.5);
    return 0;
}

template<template<typename> class _Func, typename _Tp>
    struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
    {
      using type = _Func<_Alloc>;
    };

#include <typeinfo>
#include <cxxabi.h>
#include <iostream>
#include <vector>

//將gcc編譯出來(lái)的類型翻譯為真實(shí)的類型
const char* GetRealType(const char* p_szSingleType)
{
    const char* szRealType = abi::__cxa_demangle(p_szSingleType, nullptr, nullptr, nullptr);
    return szRealType;
}

//這里的func是一個(gè)模板模板形參
template<template<typename, typename> class func, typename tp, typename alloc = std::allocator<tp> >
struct temp_traits
{
    using type = func<tp, alloc>;
    type tt;//根據(jù)模板類型定義一個(gè)成員變量
};

int main()
{
    temp_traits<std::vector, int> _traits;
    //獲取結(jié)構(gòu)體字段tt的類型
    const std::type_info &info = typeid(_traits.tt);
    std::cout << GetRealType(info.name()) << std::endl;
    return 0;
}

#include <typeinfo>
#include <cxxabi.h>
#include <iostream>
#include <vector>
#include <deque>
#include <list>

//將gcc編譯出來(lái)的類型翻譯為真實(shí)的類型
const char* GetRealType(const char* p_szSingleType)
{
    const char* szRealType = abi::__cxa_demangle(p_szSingleType, nullptr, nullptr, nullptr);
    return szRealType;
}
//泛化變參模板
template<typename tp, typename alloc, template<typename, typename> class ... types >
struct temp_traits
{
    temp_traits(tp _tp)
    {
        std::cout << "泛化模板執(zhí)行" << std::endl;
    }
};
//偏特化變參模板
template< typename tp, typename alloc, template<typename, typename> class type, template<typename, typename> class ... types >
struct temp_traits<tp, alloc,type, types...>:public temp_traits<tp, alloc, types...> 
{
    using end_type = type<tp, alloc>;
    end_type m_object;
    temp_traits(tp _tp)
    :temp_traits<tp, alloc, types...>(_tp)
    {
        const std::type_info &info = typeid(m_object);
        std::cout << "偏特化版本執(zhí)行, 此時(shí)類型:" << GetRealType(info.name()) << std::endl;
        m_object.push_back(_tp);
    }
    void print()
    {
        auto it = m_object.begin();
        for(;it != m_object.end(); ++it)
        {
            std::cout << "類型為:" << GetRealType(typeid(end_type).name()) << ", 數(shù)據(jù)為:" << *it << std::endl;
        }
    }
};

int main()
{
    temp_traits<int, std::allocator<int>, std::vector, std::deque, std::list> _traits(100);
    _traits.print();
    return 0;
}

~temp_traits()
    {
        auto it = m_object.begin();
        for(;it != m_object.end(); ++it)
        {
            std::cout << "類型為:" << GetRealType(typeid(end_type).name()) << ", 數(shù)據(jù)為:" << *it << std::endl;
        }
    }

#include <typeinfo>
#include <cxxabi.h>
#include <iostream>
#include <vector>
#include <list>
#include <deque>

//將gcc編譯出來(lái)的類型翻譯為真實(shí)的類型
const char* GetRealType(const char* p_szSingleType)
{
    const char* szRealType = abi::__cxa_demangle(p_szSingleType, nullptr, nullptr, nullptr);
    return szRealType;
}

void xprintf()
{
    std::cout << "調(diào)用空函數(shù)" << std::endl;
}

template<typename tp, typename alloc, template<typename, typename> class T, template<typename, typename> class ... Targs >
void xprintf(T<tp, alloc> value, Targs<tp, alloc>... Fargs)
{
    std::cout << "容器類型:" << GetRealType(typeid(value).name()) << std::endl;
    std::cout << "容器數(shù)據(jù):" << std::endl;
    auto it = value.begin();
    for(; it != value.end(); ++it)
    {
        std::cout << *it << ',';
    }
    std::cout << std::endl;
    if ( (sizeof ...(Fargs)) > 0 )
    {
        //這里調(diào)用的時(shí)候沒(méi)有顯式指定模板，是因?yàn)楹瘮?shù)模板可以根據(jù)函數(shù)參數(shù)自動(dòng)推導(dǎo)
        xprintf(Fargs...);
    }
    else
    {
        xprintf();
    }
}

int main()
{
    std::vector<int> vt;
    std::deque<int> dq;
    std::list<int> ls;
    for(int i =0 ; i < 10 ; ++i)
    {
        vt.push_back(i);
        dq.push_back(i);
        ls.push_back(i);
    }

    xprintf(vt, dq, ls);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class programmer
{
    string name;
    string sex;
    int age;
    string vocation;//職業(yè)
    double height;
public:
    programmer(string name, string sex, int age, string vocation, double height)
    :name(name), sex(sex), age(age), vocation(vocation), height(height)
    {
        cout << "call programmer" << endl;
    }

    void print()
    {
        cout << "name:" << name << endl;
        cout << "sex:" << sex << endl;
        cout << "age:" << age << endl;
        cout << "vocation:" << vocation << endl;
        cout << "height:" << height << endl;

    }
};

template<typename T>
class xprintf
{
    T * t;
public:
    xprintf()
    :t(nullptr)
    {}

    template<typename ... Args>
    void alloc(Args ... args)
    {
        t = new T(args...);
    }

    void print()
    {
        t->print();
    }

    void afree()
    {
        if ( t != nullptr )
        {
            delete t;
            t = nullptr;
        }
    }
};

int main()
{
    xprintf<programmer> xp;
    xp.alloc("小明", "男", 35, "程序員", 169.5);
    xp.print();
    xp.afree();
    return 0;
}

template<typename... _Args>
void emplace_front(_Args&&... __args);

#include <deque>
#include <string>
#include <iostream>

class CMan
{
    int age;
    std::string sex;
    double money;
public:
    CMan(int age, std::string sex, double money)
    :age(age), sex(sex), money(money)
    {
        std::cout << "call contrust" << std::endl;
    }

    CMan(CMan && other)
    :age(other.age), sex(other.sex), money(other.money)
    {
        std::cout << "call move contrust" << std::endl;
    }
};

int main()
{
    std::deque<CMan> dq;
    dq.emplace_front(30, "man", 12.3);

    return 0;
}

#if __cplusplus >= 201103L
  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
#if __cplusplus > 201402L
      typename deque<_Tp, _Alloc>::reference
#else
      void
#endif
      deque<_Tp, _Alloc>::
      emplace_front(_Args&&... __args)
      {
    if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
      {
        _Alloc_traits::construct(this->_M_impl,
                                 this->_M_impl._M_start._M_cur - 1,
                         std::forward<_Args>(__args)...);
        --this->_M_impl._M_start._M_cur;
      }
    else
      _M_push_front_aux(std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
    return front();
#endif
      }