【C++基础】 类模板

类模板

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

类模板的语法

直接进行对比：

泛型化之前	泛型化之后

类模板的实例化

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

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