类模板

模板是将类中某些类型变为泛型，从而定义一个模板。
如下：

类模板的语法

直接进行对比：

泛型化之前

泛型化之后

类模板的实例化

注意：只要是对类模版进行实例化，编译器就会生成一个类！！！
显式实例化：

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;}
}