《C++捷径教程》读书笔记--Chapter16--模板（完结）

//--《C++捷径教程》读书笔记--Chapter 16--模板（完结）
//--Chapter 16--模板
//--04/16/2006 Sun.
//--Computer Lab
//--Liwei

//--程序＃1  说明模板函数示例
#include
using namespace std;

//template void swapargs(X &a, X &b)
template void swapargs(X &a, X &b)
{
 X temp;
 temp=a;
 a=b;
 b=temp;
}

int main()
{
 int i=10, j=20;
 double x=10.1, y=23.3;
 char a='x', b='z';

 cout<<"Original i,j: "< cout<<"Original x,y: "< cout<<"Original z,b: "<

 swapargs(i,j);
 swapargs(x,y);
 swapargs(a,b);

 cout<<"/n===============/n";

 cout<<"Swapped i,j: "< cout<<"Swapped x,y: "< cout<<"Swapped z,b: "<

 return 0;
}

//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃2  说明模板函数示例
#include
using namespace std;

template
void myfunc(type1 x, type2 y)
{
 cout<}

int main()
{
 myfunc(10, "hi00000000000000000000");
 myfunc(0.23, 10L);

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃3  重载模板函数示例
#include
using namespace std;

//template void swapargs(X &a, X &b)
template void swapargs(X &a, X &b)
{
 X temp;
 temp=a;
 a=b;
 b=temp;
 cout<<"Inside template swapargs./n";
}

template<> void swapargs(int &a, int &b)
//void swapargs(int &a, int &b)
{
 int temp;
 temp=a;
 a=b;
 b=temp;
 cout<<"Inside swapargs int specialization./n";
}

int main()
{
 int i=10, j=20;
 double x=10.1, y=23.3;
 char a='x', b='z';

 cout<<"Original i,j: "< cout<<"Original x,y: "< cout<<"Original z,b: "<

 swapargs(i,j);
 swapargs(x,y);
 swapargs(a,b);

 cout<<"/n===============/n";

 cout<<"Swapped i,j: "< cout<<"Swapped x,y: "< cout<<"Swapped z,b: "<

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃4  重载模板本身
#include
using namespace std;

template void f(X a)
{
 cout<<"Inside f(X a)./n";
}

template void f(X a, Y b)
{
 cout<<"Inside f(X a, Y b)./n";
}

int main()
{
 f(10);
 f("dddddddd",544);

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃5  标准类型参数
#include
using namespace std;

template
void repeat(X data, int times)
{
 do{
  cout<  times--;
 }while(times);
}

int main()
{
 repeat("This is a test.", 311);
 repeat(100, 5);
 repeat(99.0/2, 4);

 return 0;
}

//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃6  通用函数myabs()
#include
using namespace std;

template
X myabs(X val)
{
 return val<0? -val: val;
}

int main()
{
 cout< cout< cout< cout<

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃7  通用类
#include
using namespace std;

const int SIZE=100;

template
class queue{
 QType q[SIZE];
 int sloc,rloc;
public:
 queue() { sloc=rloc=0; }
 void qput(QType i);
 QType qget();
};

template
void queue::qput(QType i)
{
 if(sloc==SIZE)
 {
  cout<<"Queue is full./n";
  return;
 }
 sloc++;
 q[sloc]=i;
}

template
QType queue::qget()
{
 if(rloc==sloc)
 {
  cout<<"Queue Underflow./n";
  return 0;
 }
 rloc++;
 return q[rloc];
}

int main()
{
 queue a,b;

    a.qput(10);
 b.qput(19);
 a.qput(20);
 b.qput(1);

 cout< cout< cout< cout<

 queue c,d;

 c.qput(10.12);
 d.qput(19.99);
 c.qput(-20.0);
 d.qput(0.986);

 cout< cout< cout< cout<

/////////////////////////////////
 queue s;
 s.qput("liwei");
 s.qput("tanfeng");

 cout< cout< 
 return 0;

}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃8  通用类
#include
using namespace std;

template
class myclass{
 Type1 i;
 Type2 j;
public:
 myclass(Type1 a, Type2 b) { i=a; j=b; }
 void show() { cout<};

int main()
{
 myclass ob1(10, 0.23);
 myclass ob2('X', "This is a test.");

 ob1.show();
 ob2.show();

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃9  通用安全数组
#include
using namespace std;

const int SIZE=10;

template
class atype{
 AType  a[SIZE];
public:
 atype() { register int i;  for(i=0; i AType  &operator[](int i);
};

template
AType &atype::operator [](int i)
{
 if(i<0 || i>SIZE-1)
 {
  cout<<"/nIndex value of "<  exit(1);
 }

 return a[i];
}

int main()
{
 atype intob;
 atype doubleob;

 int i;

 cout<<"Integer array: ";
 for(i=0; i for(i=0; i cout<

 cout<<"Double array: ";
 for(i=0; i for(i=0; i cout<

 intob[12]=100;

 return 0;
}

//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃10  通用安全数组
#include
using namespace std;

//const int SIZE=10;

template
class atype{
 AType  a[size];
public:
 atype() { register int i;  for(i=0; i AType  &operator[](int i);
};

template
AType &atype::operator [](int i)
{
 if(i<0 || i>size-1)
 {
  cout<<"/nIndex value of "<  exit(1);
 }

 return a[i];
}

int main()
{
 atype intob;
 atype doubleob;

 int i;

 cout<<"Integer array: ";
 //for(i=0; i<10; i++) intob[i]=i;
 for(i=0; i<10; i++) cout< cout<

 cout<<"Double array: ";
 //for(i=0; i<15; i++) doubleob[i]=(double)i/3;
 for(i=0; i<15; i++) cout< cout<

 intob[12]=100;

 return 0;
}

//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃11  通用安全数组
#include
using namespace std;

//const int SIZE=10;

template
class atype{
 AType  a[size];
public:
 atype() { register int i;  for(i=0; i AType  &operator[](int i);
};

template
AType &atype::operator [](int i)
{
 if(i<0 || i>size-1)
 {
  cout<<"/nIndex value of "<  exit(1);
 }

 return a[i];
}

int main()
{
 atype  intarray;
 atype doublearray;
 atype<> defarray;

 int i;

 cout<<"int array: ";
 for(i=0; i<100; i++) intarray[i]=i;
 for(i=0; i<100; i++) cout< cout<

 cout<<"double array: ";
 for(i=0; i<10; i++) doublearray[i]=(double)i/3;
 for(i=0; i<10; i++) cout< cout<

 cout<<"defarray array: ";
 for(i=0; i<10; i++) defarray[i]=i;
 for(i=0; i<10; i++) cout< cout<

 return 0;
}

//=================================================================//
//==============================END================================//
//=================================================================//
//--程序＃12  通用类的显式特例化
#include
using namespace std;

template
class myclass{
 T x;
public:
 myclass(T a) { cout<<"Inside generic myclass./n"; x=a; }
 T getx() { return x;}
};

template<> class myclass{
 int x;
public:
 myclass(int a) { cout<<"Inside myclass specialization./n"; x=a*a; }
 int getx() { return x;}
};

int main()
{
 myclass  d(10.1);
 cout<<"double: "<

 myclass  i(5);
 cout<<"int: "<

 return 0;
}
//=================================================================//
//==============================END================================//
//=================================================================//