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