c++学习记录之模板-永久免费的源码丞旭猿

/*重载函数
include 
using namespace std;
void swap(int &rx,int &ry)
{
    int temp=rx;
    rx=ry;
    ry=temp;
}
void swap(float&ra,float &rb)
{
    float temp=ra;
    ra=rb;
    rb=temp;
}
void swap(double&a,double &b)
{
    double temp=a;
    a=b;
    b=temp;
}
int main()
{
    int x=2,y=5;
    cout<<"交换前，x:"<
using namespace std;
template//定义了一个模板类型Type，template是声明模板的关键字。尖括号中的模板类型跟在关键字template之后，也可以叫做参数。
void Tswap(Type &rx,Type &ry)//由于swap函数与标准库中的swap重名，因此将swap函数换成了Tswap。
{
    Type temp=rx;
    rx=ry;
    ry=temp;
}
int main()
{
    int x=2,y=5;
    cout<<"交换前，x:"<

include 
using namespace std;
template
void Swap(T &a,T &b);
struct people
{
    char name[10];
    int age;
};
template<>void Swap(people&p1,people&p2);
//void Swap(people&a,people&b);
void show(people&p);
int main()
{
    int i=10,j=20;
    cout<<"初始值i="<
void Swap(T &a,T &b)
{
    T temp;
    temp=a;
    a=b;
    b=temp;
}
template<>void Swap(people &a,people &b)
//void Swap(people&a,people&b)
{
    int Age;
    Age=a.age;
    a.age=b.age;
    b.age=Age;
}
void show(people&p)
{
    cout<

include 
using namespace std;
template
void show(T a){cout<(char&);//显示声明了一个实例化模板函数，它的参数为char型字符的引用，这样在程序编译时会根据上面定义的函数模板强制创建void show(char &a){cout<

include 
using namespace std;
template
void show(T a){cout<<"模板函数!"<

include 
using namespace std;
struct people
{
  char name[50];
  int age;
};
template 
void show(T t[],int n)
{
  cout<<"执行函数模板void show(T t[],int n)\n";
  for(int i=0;i
void show(T * t[],int n)
{
  cout<<"执行函数模板void show(T * t[],int n)\n";
  for (int i=0;i

include 
using namespace std;
template    //定义了一个类型为T的模板
class people    //定义了一个people类
{
  public:
    people(T x,T y):X(x),Y(y){}
    T getX(){return X;}
    T getY(){return Y;}
  private:
    T X,Y;   //用T类型声明了2个变量X和Y，这2个变量分别应用到第7行的构造函数、第8行的getX()和第9行的getY()函数中。
};
int main()
{
  people Jack(3,4);//调用people类的构造函数初始化该类的jack对象，people是一个类，其后的则告诉编译器这不是一个普通类，而是一个类模板，编译器将根据这个类模板生成一个类，并具体化模板参数T为int。
  cout<

include 
using namespace std;
const int size=10;
class people
{
    public:
      people(int i):x(i){}
      people():x(0){}
      int GetAge()const{return x;}
      void show()const{cout<
class num 
{
    public:
      num(int Tsize=size);
      num(const num&r);
      ~num(){delete[]pt;}
      num&operator=(const num&);
      T&operator[](int offset){return pt[offset];}
      const T&operator[](int offset)const
      {
        return pt[offset];
      }
      int GetSize() const {return numsize;}
    private:
      int numsize;
      T*pt;
};
template
num::num(int size):numsize(size)
{
    pt=new T[size]; //该语句在堆中创建了一个类型为T的数组，并右指针pt指向该数组，由于T被具体为people，size值为10，该语句相当于pt =new people[10]
    for (int i=0;i
num::num(const num&r)
{
    numsize=r.GetSize();
    pt=new T[numsize];
    for (int i=0;i
num&num::operator=(const num&r)
{
    if (this==&r)
    {
        return *this;
        delete[]pt;
        numsize=r.GetSize();
        pt=new T[numsize];
        for (int i=0;ione;
    numtwo;
    people*p;
    for (int i=0;i

include 
using namespace std;
template
class people
{
    public:
        people();
        people(const T&t);
        T&operator[](int i);
        void show();
    private:
        T a[n];
};
template
people::people()
{
    cout<<"执行构造函数\n";
    for (int i=0;i
people::people(const T&t)
{
    cout<<"执行带一个参数的构造函数\n";
    for (int i=0;i
T&people::operator[](int i)
{
    cout<<"执行下标运算符函数operator[]\n";
    if (i<0||i>=n)
    {
        cerr<<"超出数组限制，第:"<
void people::show()
    {
        for (int i=0;ione;
    one.show();
    people*p=new people[4];//在堆中创建了4个对象，这4个对象按顺序排列在一个数组中，我们把这个数组叫对象数组。
    for (int i=0;i<9;i++)
    {
        p[i]=one[i];//one[i]将会调用第33行的operator[]函数，第7行的输出结果证实了这一点。
        p[i].show();
    }
    return 0;
}
​
    people*p=new people[4];//在堆中创建了4个对象，这4个对象按顺序排列在一个数组中，我们把这个数组叫对象数组。由于people类是一个类模板，因此必须写成people,而不是people，其他都相同。

people ，10>two;//创建了一个包含10个对象元素的对象数组two，每个对象又拥有一个5个int型元素的数组，因此它可以看作如下二维数组：
int two[10][5];
include 
using namespace std;
template
class people
{
    public:
        people();
        people(const T&t);
        T&operator[](int i);
        void show();
    private:
        T a[n];
};
template
people::people()
{
    cout<<"执行构造函数\n";
    for (int i=0;i
people::people(const T&t)
{
    cout<<"执行带一个参数的构造函数\n";
    for (int i=0;i
T&people::operator[](int i)
{
    cout<<"执行下标运算符函数operator[]\n";
    if (i<0||i>=n)
    {
        cerr<<"超出数组限制，第"<
void people::show()
{
        for (int i=0;i,3>two;//因为对象two的3个成员也是对象，对象two加上它的3个对象成员一共是 4个对象。
    int obj=1;
    for (int i=0;i<4;i++)
    {
        int sum=1;
        for (int j=0;j<2;j++)
        {
            cout<<"\ntwo["<

template
​
include 
include 
using namespace std;
template
class People
{
    public:
      T1&getx();
      T2&gety();
      T1 getx()const{return x;}
      T2 gety()const{return y;}
      People(const T1&a,const T2&b):x(a),y(b){cout<<"构造函数\n";}//第12行
    private:
      T1 x;
      T2 y;
};
template
T1&People::getx()
{
    return x;
}
template
T2&People::gety()
{
    return y;
}
int main()
{
    Peopleone[4]={
    People("hello world",5),
    People("good morning",6),
    People("sit down please",8),
    People("have a cup of tea",2)
    };  //这会调用第12行的构造函数，T1类型的参数a用来接收字符串，T2类型的参数b用来接收数值。
    int num=sizeof(one)/sizeof(People);//初始化完成后，此行用来计算对象的数目，即对象数组one共有几个对象。
    cout<<"输出对象数组one的所有元素:\n";
    for (int i=0;i

构造函数
构造函数
构造函数
构造函数
输出对象数组one的所有元素:
5:      hello world
6:      good morning
8:      sit down please
2:      have a cup of tea
修改one[3]的数据并输出:
6:      get out of here
请按任意键继续. . .
​
​

template
​
peopleone;
peopleone;//与上一句相同

T Max(T a,T b)
{
    return(a>b)?(a):(b);
}

//接下来的程序演示了具体化模板函数的使用情况，如下：
include 
include 
using namespace std;
template
T Max(T a,T b)          你
{
    return(a>b)?(a):(b);
}
char*Max(char*a,char*b) //具体化了函数目标的参数和功能，它是一个专门用来比较字符串的特定函数，或者说用来替换函数模板的普通函数。
{
    if(strcmp(a,b)>0)
        return a;
    else
        return b;
}
​
int main()
{
    int x=2,y=3;
    cout<

include 
using namespace std;
template 
class One 
{
    public:
        One(T1 t,int i):first(t),second(i){}
        template
        T1 get(T1 t1,T2 t2)
        {
            cout<<"first.get()返回"<
        class two 
        {   
          public:
            two(T3 t3=0):x(t3){}
            void show()const{cout<first;
        twosecond;
};
int main()
{
    
    Oneone(3.5,4);
    one.show();
    cout<<"\n执行get函数\n";
    cout<

a  tempplate
b template