c++中的类（class）-----笔记（类模板）

1，一个类模板至少具有一个类参数，类参数是个符号以表示将要被某个确定数据类型代替的类型。

#include<iostream>
#include<string>

using namespace std;

template <class T>
class Array {
    public:
        T& operator [](int);
        const T& operator [](int);
        Array(int);
        ~Array();
        int get_size() const { return size;}
    private:
        char* a;
        int size;
        Array();    // 实例化的时候必须给出大小 
        T dummy_val;
};

template<class T>
T& Array<T>::operator [](int i) {
    if(i < 0 || i >= size) {
        cerr << "index  "<<i<<"  out of bounds! ";
        return dummy_val;
    }
    return a[i];
} 

template<class T>
T& Array<T>::operator [](int i) const {
    if(i < 0 || i >= size) {
        cerr << "index  "<<i<<"  out of bounds! ";
        return dummy_val;
    }
    return a[i];
} 

template<class T>
Array<T>::Array(int s) {
    a = new T[size = s];
}

template<class T>
Array<T>::~Array() {
    delete[] a;
}

template<class T>
ostream operator<<(ostream& os,const Array<T>& arr) {  // 顶层函数重载 
    for(int i=0;i<arr.get_size();++i)
        os<<arr[i]<<endl;
    return os;
}

由于 Array 类的参数化构造函数与重载的下标操作符在类声明之外定义，因此需要在定义之前加上模板头：template <class T>。

由于 Array 是个模板类，因此类名是 Array<T>，这里 T 是模板头的类参数。

2，类模板可以拥有多个类参数，这些参数用逗号隔开。每个类参数前都必须有关键字 class 或 typename。

template<class T1,class T2,class T3>
class Sample {
    public:
        T2 m(T3 p) { } // expects a T3 arg,returns a T2
    private:
        T1 x;     // var of type T1
}; 

3，模板实例：我们通过 < > 中指定数据类型来使用一个模板类。

int main() {
    Array<int> a1(10);  // Array of 10 int
    
    return 0;
}

以上语法表面用 int 来替换模板类 Array 声明的类参数 T，编译器会将在 Array 声明中所有的类参数 T 替换成 int。

用内建的或自定义的数据类型都可以创建模板实例

class Task {  // user-defined data type
    //...
};

Array<Task> tasks(10); 

4，一个对象不能属于像 Array 或 Array<T> 的对象，但我们可以定义类型为 Array<int> 的对象。

5，参数表中的类模板：类模板可以作为一种数据类型出现在参数表中。

template<class T>
ostream operator<<(ostream& os,const Array<T>& arr) {  // 顶层函数重载 
    for(int i=0;i<arr.get_size();++i)
        os<<arr[i]<<endl;
    return os;
}

6，模板的函数式参数：类模板必须至少有一个类参数，当然可以有多个类参数。类模板、还可以有非类参数的参数，一般称之为函数类型参数，一个模板类可以有多个函数类型参数，所有的参数用逗号分开。

template<class T,int x,float Y>
class Sample {
    //...
};

7，示例程序：模板堆栈类

// stack
template<class T>
class Stack {
    public:
        enum{ DefaultSize = 50,EmptyStack = -1};
        Stack();
        Stack(int);
        ~Stack();
        void push( const T&);
        T pop();
        T getNoPop() const;
        bool empty() const;
        bool full() const;
    private:
        T* elements;
        int top;
        int size;
        void allocate() {
            elements = new T[size];
            top = EmptyStack;
        }
        void msg(const char* m) const {
            cout << "*****  "<<m<<"  *****"<<endl;
        }
        template<class T>
        friend ostream& operator<<(ostream& os,const Stack<T>&);
};

// Stack 类的实现
 template<class T>
 Stack<T>::Stack() {
     size = DefaultSize;
     allocate();
 }
 
template<class T>
Stack<T>::Stack(int s) {
    if(s < 0)
        s *= -1;
    else if(s == 0)
        size = DefaultSize;
    size = s;
    allocate();
}

template<class T>
Stack<T>::~Stack() {
    delete[] elements;
} 
 
template<class T>
void Stack<T>::push(const T& e) {
    assert(!full());
    if(!full())
        elements[++top] = e;
    else
        msg("Stack full!");
}

template<class T>
T Stack<T>::pop() {
    assert(!empty());
    if(!empty())
        return elements[top--];
    else {
        msg("Stack empty!");
        T dummy_val;
        return dummy_val;  // 返回一个不确定的值 
    }    
}

template<class T>
T Stack<T>:: getNoPop() const {
    assert(top > EmptyStack);
    if(!empty)
        return elements[top];
    else {
        msg("Stack empty!");
        T dummy_val;
        return dummy_val;
    }
}

template<class T>
bool Stack<T>::empty() const {
    return top <= EmptyStack;
}

template<class T>
bool Stack<T>::full() const {
    return top + 1 >= size;
}

template<class T>
ostream& operator<<(ostream& os,const Stack<T>& s) {
    s.msg("Stack contents:");
    int t = s.top;
    while(t > s.EmptyStack) 
        cout<<s.elements[t--]<<endl;
    return os;
}

int main() {
    Stack<int> stk(1);
    stk.push(1);
    cout<<stk<<endl;
    
    return 0;
}

8，函数模板

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

// this is a function template
template<class Type>
Type maxValue(Type a,Type b) {
    return a > b ? a : b;
}

int main(){
    stack<int> intStack;  // 类模板的实例化只能由程序员显式指定
    cout <<"模板函数隐式调用：" << maxValue(1,2) << endl;
    cout << "模板函数显式调用：" << maxValue<double>(1.1,2.2) <<endl;
    return 0;
}

note:类模板只能通过显式的调用生成模板类; 函数模板可以通过显式调用或隐式调用生成模板函数。