類模板

模板是將類中某些類型變為泛型，從而定義一個模板。
如下：

類模板的語法

直接進行對比：

泛型化之前

泛型化之后

類模板的實例化

注意：只要是對類模版進行實例化，編譯器就會生成一個類！！！
顯式實例化：

template class Stack<int>;  // 將類模板實例化為一個處理int類型的Stack類

隱式實例化：
生成一個處理char類型的對象：

Stack<char>  charStack; // 先實例化一個CharStack類(名字由編譯器按規則生成)// class CharStack { … char elements[100]; … };// 然后用 CharStack charStack; 創建一個對象

code附錄

泛型化之前的：

#pragma once//編寫StackOfIntegers類
class Stack {
private:int elements[100];int size{ 0 };
public:bool empty();int peek();int push(int value);int pop();int getSize();Stack();
};
Stack::Stack() {size = 0;for (int& i : elements) {i = 0;}
}bool Stack::empty() {return (size == 0 ? true : false);
}int Stack::getSize() {return size;
}int Stack::peek() {return elements[size - 1];
}int Stack::pop() {int temp = elements[size - 1];elements[size - 1] = 0;size--;return temp;
}int Stack::push(int value) {elements[size] = value;size++;return value;
}

泛型化之后的：

#pragma once//泛型化
template <typename T>
//編寫StackOfIntegers類
class Stack {
private:T elements[100];int size{ 0 };
public:bool empty();T peek();T push(T value);T pop();int getSize();Stack();
};
template <typename T>
Stack<T>::Stack() {size = 0;for (auto & i : elements) {i = 0;}
}
template <typename T>
bool Stack<T>::empty() {return (size == 0 ? true : false);
}
template <typename T>
int Stack<T>::getSize() {return size;
}
template <typename T>
T Stack<T>::peek() {return elements[size - 1];
}
template <typename T>
T Stack<T>::pop() {T temp = elements[size - 1];elements[size - 1] = 0;size--;return temp;
}
template <typename T>
T Stack<T>::push(T value) {elements[size] = value;size++;return value;
}

main測試代碼

#include "Stack.h"
#include <iostream>
#include <string>
int main()
{Stack<char> c;std::string s{ "Hello World!"};for (auto i : s) {c.push(i);}while (c.empty() != true) {std::cout << c.pop() << std::endl;}
}