#include <iostream>
#include <string>
#include <deque>
#include <stdexcept>
template <typename T>
class my_stack
{
private:
std::deque<T> elems;
public:
void push(T const &);
void pop();
T top()const;
bool empty()const{return elems.empty();}
//operator =
template <typename T2>
my_stack<T> & operator=(my_stack<T2> const&);
}; template <typename T>
void my_stack<T>::push(T const &elem)
{
elems.push_back(elem);
} template <typename T>
void my_stack<T>::pop()
{
if (this->empty())
{
throw std::out_of_range("the list is empty,please insert the elems\n");
}
elems.pop_back();
}
template <typename T>
T my_stack<T>::top()const
{
if(this->empty())
{
throw std::out_of_range("No elements\n"); }
return elems.back();
}
template <typename T>
template <typename T2>
my_stack<T>& my_stack<T>::operator=(my_stack<T2> const&op2)
{
if( (void*)this == (void *)&op2)
{
return *this;
}
my_stack<T2> tmp(op2); //copy constructor
elems.clear();
while(!tmp.empty())
{
elems.push_front(tmp.top()); //put in the front !...
tmp,pop(); // while loop breakdown
}
return *this;
} int main()
{
my_stack <int> int_stack;
my_stack <float> float_stack; float_stack = int_stack; return ;
}
<2> 模板作为模板的参数:
//
// Created by Administrator on 2017/5/7.
// #ifndef TASARG_TEMPPARM_H
#define TASARG_TEMPPARM_H #include <iostream>
///Value handle define here
template <typename T>
class GLY_handle
{
public:
GLY_handle();
T getValue() const ;
void setValue( T data) ; private:
T mValue;
}; template <typename T>
GLY_handle<T>::GLY_handle()
{
}
template <typename T>
T GLY_handle<T>::getValue() const {
return mValue;
}
template <typename T>
void GLY_handle<T>::setValue(T data) {
mValue = data;
} /// ----------------------GLY MAP----------------------------------------------
/// Ting is template class can handle value
template <template <typename T> class Ting,typename KeyT,typename ValueT>
class GLY_Map
{
public:
/// default
GLY_Map(); /// copy function
GLY_Map(const GLY_Map<Ting,KeyT,ValueT>&); /// getMethod
KeyT first() const;
ValueT second() const;
/// setMethod
void setMapValue(KeyT key,ValueT data); /// dataHandle
Ting<KeyT> &firstHandle() ;
Ting<ValueT> &secondHandle(); private:
Ting <KeyT> mKey;
Ting <ValueT> mValue;
}; template <template <typename T> class Ting,typename KeyT,typename ValueT>
GLY_Map<Ting,KeyT,ValueT>::GLY_Map()
{ }
/// GLY_MAP copy function define here
template <template <typename T> class Ting,typename KeyT,typename ValueT>
GLY_Map<Ting,KeyT,ValueT>::GLY_Map(const GLY_Map<Ting, KeyT, ValueT> & rhs)
{
// copy function
mKey = rhs.mKey;
mValue = rhs.mValue;
} template <template <typename T> class Ting,typename KeyT,typename ValueT>
KeyT GLY_Map<Ting,KeyT,ValueT>::first() const
{
return mKey.getValue();
} template <template <typename T> class Ting,typename KeyT,typename ValueT>
ValueT GLY_Map<Ting,KeyT,ValueT>::second() const
{
return mValue.getValue();
}
template <template <typename T> class Ting,typename KeyT,typename ValueT>
void GLY_Map<Ting,KeyT,ValueT>::setMapValue(KeyT key, ValueT data)
{
mKey.setValue(key);
mValue.setValue(data);
}
template <template <typename T> class Ting,typename KeyT,typename ValueT>
Ting<KeyT> & GLY_Map<Ting,KeyT,ValueT>::firstHandle()
{
return mKey;
}
template <template <typename T> class Ting,typename KeyT,typename ValueT>
Ting<ValueT> &GLY_Map<Ting,KeyT,ValueT>::secondHandle()
{
return mValue;
}
// Operator for std::cout
template <template <typename T> class Ting,typename KeyT,typename ValueT>
std::ostream &operator<<(std::ostream &os ,const GLY_Map<Ting,KeyT,ValueT> &data)
{
os << "Data key " <<data.first() <<"," << data.second();
return os;
}; #endif //TASARG_TEMPPARM_H
tempparm.h
#include <iostream>
#include "tempparm.h"
#include <vector> int main()
{
GLY_Map <GLY_handle,std::string,int> testMap;
testMap.setMapValue("houdini",);
std::cout << testMap <<std::endl;
return ;
}
main.cpp
<3> 默认模板参数:
template<class T1,class T2 = int>
class Topo{...}
Topo<double,double> T2 //as double
Topo<double>T2 //as int
<4> 显示具体化模板:
#include <iostream>
template <typename T>
class GLY_Handle
{
public:
T var;
void printData()
{
std::cout << "print as generic type " << var <<std::endl;
}
}; /// explicit the int type
template <>
class GLY_Handle<int>
{
public:
void printData()
{
std::cout << "print as int type " << var <<std::endl;
}
int var;
}; template <>
class GLY_Handle<float>
{
public:
void printData()
{
std::cout << "print as float type " <<var <<std::endl;
}
float var;
}; int main()
{
GLY_Handle<int> var1;
var1.var = ;
var1.printData(); GLY_Handle<double> var2;
var2.var = 10.0;
var2.printData(); GLY_Handle<float> var3;
var3.var = 10.0f;
var3.printData();
return ;
}
<5> 部分具体化模板：
<6>模板和友元函数，以及静态成员分配:
#include <iostream>
template <typename T>
class HasFriend
{
public:
HasFriend(const T & i):item(i) { ct++; }
~HasFriend() { ct--; }
friend void counts();
friend void reports(HasFriend<T> &);
private:
T item;
static int ct;
};
/// each specialization has its own static data member
template <typename T>
int HasFriend<T>::ct = ;
void counts()
{
std::cout << "int count " << HasFriend<int>::ct <<std::endl;
std::cout << "double count " <<HasFriend<double>::ct <<std::endl;
}
/// non-template friend to HasFriend<int> class
void reports(HasFriend <int> &pt) {
// 为什么能访问pt的私有函数，因为reports函数是在public接口上。
std::cout << "HasFriend<int>: " <<pt.item <<std::endl;
}
/// non-template friend to HasFriend<double> class
void reports(HasFriend <double> &pt) {
// 为什么能访问pt的私有函数，因为reports函数是在public接口上。
std::cout << "HasFriend<double>: " <<pt.item <<std::endl;
}
int main()
{
counts();
HasFriend<int> i_01();
HasFriend<int> i_02();
HasFriend<double> d_03(10.00); std::cout << "After i_01,i_02,d_03 declared\n\n";
counts(); reports(i_01);
reports(i_02);
reports(d_03); return ;
}
./out
int count 0
double count 0
After i_01,i_02,d_03 declared
int count 2
double count 1
HasFriend<int>: 1
HasFriend<int>: 10
HasFriend<double>: 10
<7>重载函数模版问题:
#include <iostream>
template <typename T>
int func(T) // first
{
return ;
} template <typename T>
int func(T*) //
{
return ;
} int main()
{
std::cout << func() <<std::endl; //
std::cout << func<int>() <<std::endl; //
std::cout << func((int*)) <<std::endl; // 2,T=int ,arg is int* // will create this function func<int*>(int*),
// and will create func<int*>(int**),because the second template function
// but (int*)5 is int* , so will match func<int*>((int*)) better
std::cout << func<int*>((int*)) <<std::endl; //-> func<int*>(int*) std::cout << func<int> ((int*)) <<std::endl; // 2,T=int , but arg is int* ->T* return ;
}
结果:
1
1
2
1
2
<8>explicit specialization（深入显式特化）
显式特化不一定非得特化类，才能特化类中内容。例如下面，类Outer<void>就没特化出来，但是成员函数和一个静态变量被特化
也就是说把泛型定义的Outer里的函数和静态变量给替换了
#include <iostream> using std::cout;
using std::endl; template<typename T>
class Outer {
public:
template<typename U>
class Inner {
private:
static int count;
}; static int code; void print() const {
cout << "generic\n";
}
}; template <typename T>
int Outer<T>::code = ; template <typename T>
template <typename U>
int Outer<T>::Inner<U>::count =; template <>
class Outer<bool>
{
public:
template <typename U>
class Inner
{
private:
static int count;
}; static int code;
void print() const {
cout << " bool trait\n";
}
}; template <>
int Outer<bool>::code = ; // part of Outer<void> Specialization , but not have "Outer class definition"
template <>
int Outer<void>::code = ; template <>
void Outer<void>::print() const {
cout << "void trait\n";
}
// part of Outer<void> Specialization , but not have "Outer class definition" int main()
{
Outer<bool> val;
val.print(); cout << Outer<bool>::code <<endl;
return ;
}
<9> typedef
std::list 作为模版实参进去第二个默认参数的问题。所以std::list是不能作为默认模版的模版参数.
(1)即使我们用了typedef
template <typename T>
typedef list<T> MyList; template <typename T1, typename T2,
template <typename> class Container>
class MapList
{
public:
Container<T1> &First()
{
return mFirstList;
}
Container<T1> &Scend()
{
return mSecondList;
}
private:
Container<T1> mFirstList;
Container<T2> mSecondList;
}; int main()
{ MapList<string,int,MyList> list_01;
}
(2) C++11 ,decltype暴力用法
template <typename T1,typename T2>
??? operator+ (vector<T1> &x,vector<T2> &y)
对于这样的问题如何返回正确的vector<???>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; template <typename T1,typename T2>
auto operator+ (vector<T1> &x,vector<T2> &y) -> vector<decltype(x[]+y[])>
{
typedef decltype(x[]+y[]) types;
vector<types> temp;
temp.resize(x.size()); for(int i=;i<x.size();i++)
{
temp[i] = x[i] + y[i];
}
return temp;
}; void unit_test()
{
int ttt = ;
vector<decltype(ttt)> aaaa ;
aaaa.resize();
fill(aaaa.begin(),aaaa.end(),);
for_each(begin(aaaa),end(aaaa),[](int &val){cout << val <<endl;});
} int main()
{
vector<int> a;
vector<float> b;
a.resize();
b.resize();
fill(a.begin(),a.end(),);
fill(b.begin(),b.end(),);
auto n = a+b;
for_each(begin(n),end(n),[&n](decltype(n[]) &val){cout << val <<endl;});
return ;
}
(3)ElementT类的设计，typedef ,typename实用:
#include<iostream>
#include<vector>
#include<algorithm>
#include<initializer_list>
#include<list>
#include<stack> template <typename T>
T sumOfElements(const std::initializer_list<T> &varList)
{
T sum = ;
auto func = [&sum,&varList](const T &val)
{
sum +=val;
};
std::for_each(std::begin(varList),std::end(varList),func);
return sum;
} template <typename T>
typename std::vector<T>::value_type sumOfVector(const std::vector<T> &varList)
{
T sum = ;
auto func = [&sum,&varList](const T &val)
{
sum +=val;
};
std::for_each(std::begin(varList),std::end(varList),func);
return sum;
} // ElementT Design
template <typename T>
class ElementT; template <typename T>
class ElementT< std::vector<T> >
{
public:
typedef T TYPE;
}; template <typename T>
class ElementT< std::initializer_list<T> >
{
public:
typedef T TYPE;
}; template <typename T>
class ElementT< std::stack<T> >
{
public:
typedef T TYPE;
}; template <typename T>
typename ElementT<T>::TYPE sum_of_elements(T & container)
{
typedef typename ElementT<T>::TYPE valType;
valType sum = valType();
auto func = [&container,&sum](const valType&val)
{
sum += val;
};
std::for_each(container.begin(),container.end(),func);
return sum; } int main()
{
std::cout << "initlist->:"<<sumOfElements({,,,,,}) <<std::endl;
std::cout << "vector->: "<<sumOfVector(std::vector<int>{,,,,,}) <<std::endl;
std::cout <<"ElementT->: "<<sumOfVector(std::vector<int>{,,,,,}) <<std::endl;
return ;
}
<10>
template<char const*msg>
class Var{}
Var<"X"> 和Var<"X">其实是两个不同的实例，但是"X"实际类型是char const[2],传递给模版实参decay "char const *" type.
.
<11> 求max(1,2,3,4,3,4,1) 最大值 递归
template <typename T>
T const &tmax(const T &a,const T&b)
{
cout << "basic:"<< a <<"|"<< b <<endl;
return a<b?b:a;
} template <typename T,typename ...Args>
T const&tmax(const T&a,const T&b,const Args&... args)
{
cout<<"...args" << a <<"|"<< b <<endl;
return tmax(a,tmax(b,args...));
}; int main()
{
cout << tmax(,,) ;
//show_list(1,2,3,4,5);
return ;
}
.