4. STL編程四

1. 類模板的默認參數規則：

#include <iostream>
using namespace std;

/*
//類模板，不調用不編譯(函數)；變量仍是規範
template<class T = int>    //即便參數默認，調用的時候仍是要指明類型
class myclass
{
public:
    T a;
    T b;

    T add()
    {
        return a + b;
    }

};

int main()
{
    myclass<int> my;
    my.a = 10;
    my.b = 20;
    my.add();

    system("pause");
    return 0;
}
*/

template<class T1, class T2 = double, class T3 = char>    //默認參數，原則上都放在右邊
class myclassT
{
public:

};

int main()
{
    myclassT<int> my1;        //<>不管如何都不能省略,
    //有默認參數原則上能夠省略；若是中間出現一個沒有省略，需輸入若干參數，覆蓋那個位置

    system("pause");
    return 0;
}

 2. 類模板的嵌套：

#include <iostream>
#include <vector>
#include <list>
using namespace std;

/*
//類的懷孕現象
class my
{
public:
    class zi    //嵌套類
    {

    };

    zi z1;
};
*/

template<class T>
class myT
{
public:
    template<class T>    //嵌套類模板
    class ziT
    {
        T a;
    public:
        void seta(T t)
        {
            a = t;
        }

        T geta()
        {
            return a;
        }
    };

    ziT<int>    my1;      //不管外部什麼類型，始終都是int
    ziT<T>      my2;      //外部什麼類型，內部也是該類型
    vector<T>   myv;
    list<T>     myx;
};

int main()
{
    myT<double> d1;

    system("pause");
    return 0;
}

3. 模板參數的嵌套：

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

/*
int main()
{
    vector<int>                        myint1;
    vector< vector<int> >              myint2;    //二維數組
    vector< vector< vector<int> > >    myint3;    //三位數組

    system("pause");
    return 0;
}
*/

template<class T>
class men
{
public:
    men()
    {
        
    }
    ~men()
    {

    }
    T getAge()
    {
        return age;
    }
    T getName()
    {
        return name;
    }
    void setAge(T && a)
    {
        age = a;
    }
    void setName(T & n)
    {
        name = n;
    }

private:
    T name;
    T age;

};

template<template<class T>class T1>        //此時 T1 <==> men
class people
{
public:
    T1<int> s1;            //T1<int> <==> men<int>
    T1<string> s2;

    people()
    {
        
    }
    ~people()
    {

    }

};

int main()
{
    people<men> chinese;

    chinese.s1.setAge(50);
    cout << chinese.s1.getAge() << endl;

    chinese.s2.setAge("中國人");
    cout << chinese.s2.getAge() << endl;

    system("pause");
    return 0;
}

　　　　

4. 模板與友元函數：

　　4.1 類模板 與 友元函數模板：

#include <iostream>
using namespace std;

template<class T>
class myclass
{
public:
    myclass(T m, T n):a(m),b(n)
    {
    }
    ~myclass()
    {

    }
private:
    T a;
    T b;

    template<class T>
    friend void show(myclass<T> my);        //友元函數聲明,聲明也必須帶上template

    friend void show(myclass<double> my);   //明確類型的調用
};

template<class T>
void show(myclass<T> my)
{
    cout << my.a << " " << my.b << endl;
}

void show(myclass<double> my)
{

}

int main()
{
    myclass<int> my1(29, 39);
    show(my1);

    system("pause");
    return 0;
}

　　　　

　　4.2 類模板 與 友元類模板：

#include <iostream>
using namespace std;

template<class T> class showit;    //先聲明showit類,引用友元類，建立引用或指針,惟獨不能建立對象

template<class T>
class myclass
{
public:
    myclass(T m, T n) :a(m), b(n)
    {
    }

private:
    T a; 
    T b;

    friend class showit<T>;    //聲明友元類，該類爲一個類模板
};

template<class T>
class showit
{
public:
    myclass<T> *p;
    void set(T a, T b)
    {
        p = new myclass<T>(a, b);
        cout << p->a << " " << p->b << endl;
    }
};

int main()
{
    showit<int> showit1;
    showit1.set(99, 87);

    system("pause");
    return 0;
}

　　　　

5. 類模板與static靜態成員：

#include <iostream>
using namespace std;

template<class T>
class myclass
{
public:
    //靜態成員不屬於這個類，它在靜態區，不能將其值設定在內部，
    //static int num = 0;    //error C2864: 「myclass<T>::num」: 帶有類內初始值設定項的靜態 數據成員 必須具備不可變的常量整型
    static int num;

    myclass()
    {
        num += 1;
    }
    ~myclass()
    {
        num -= 1;
    }
    void show()
    {
        cout << "num=" << num << endl;
        cout << typeid(*this).name() << endl;
    }
};

template<class T>
int myclass<T>::num = 0;

//static成員，每一個類型實例化都會建立一個變量;類型一致，共享；類型不一致，私有。
int main()
{
    myclass<int> *p1 = new myclass<int>[10];    //調用10次構造函數
    myclass<int> *p3 = new myclass<int>[10];
    p1->show();        //20    類型一致，共享

    myclass<double> *p2 = new myclass<double>[19];    
    p2->show();        //19    類型不一致

    system("pause");
    return 0;
}

　　　　

6. 類模板與static靜態成員函數：

　　6.1 static靜態成員函數沒有this指針：

#include <iostream>
using namespace std;

template<class T>
class myclass
{
public:
    void go1()
    {
        this;
    }
    static void go2()    //靜態成員函數的指針類型不同，沒有this指針
    {
        
    }
};

int main()
{
    auto fun1 = &myclass<int>::go1;
    auto fun2 = &myclass<int>::go2;

    //成員函數與靜態成員函數最大區別，函數指針類型不同，靜態成員函數沒有this指針
    cout << typeid(fun1).name() << endl;
    cout << typeid(fun2).name() << endl;

    myclass<char> mych;

    system("pause");
    return 0;
}

　　　　

　　6.2 靜態成員函數無需建立對象就可調用：

#include <iostream>
using namespace std;

template<class T>
class myclass
{
public:
    void go1()
    {
        cout << "go1" << endl;
    }
    static void go2()    //靜態成員函數的指針類型不同，沒有this指針
    {
        cout << "go2" << endl;
    }
};

int main()
{
    myclass<int>::go2();    //靜態成員函數，無需建立對象就能夠直接調用(既能夠建立對象來調用，也能夠不建立對象來調用)
    //myclass<int>::go1();

    myclass<int> my1;
    my1.go1();
    my1.go2();

    system("pause");
    return 0;
}