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 <  || 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 <  || 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=;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();  // Array of 10 int

     return ;
 }

模板实例

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

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

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

 Array<Task> tasks(); 

自定义类型实例

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

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

 template<class T>
 ostream operator<<(ostream& os,const Array<T>& arr) {  // 顶层函数重载
     for(int i=;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 = ,EmptyStack = -};
         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 < )
         s *= -;
     else if(s == )
         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 +  >= 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();
     stk.push();
     cout<<stk<<endl;

     return ;
 }

Stack 类的实现

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(,) << endl;
     cout << "模板函数显式调用：" << maxValue<double>(1.1,2.2) <<endl;
     return ;
 }

类模板和函数模板实例

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