【C++】5.2类模板

1. 定义类模板，实例化类模板

  定义：类模板是一种创建类的模板，它允许你定义一个通用的类结构，其中的数据成员和成员函数的类型可以是参数化的。就像模板函数一样，类模板可以根据不同的类型参数生成不同的类，从而实现代码的复用。
  工作原理：在编译阶段，当你使用具体的类型实例化类模板时，编译器会根据给定的类型生成相应的类定义。这个过程类似于模板函数的实例化，生成的类会有自己独立的代码副本，用于处理特定类型的数据。

  一个example如下：

   template<typename T>
   class ClassName {
   private:
       T memberVariable;
   public:
       ClassName(T arg) : memberVariable(arg) {}
       T getMemberVariable() const {
           return memberVariable;
       }
   };

  如下模板定义了一个类模板Array<T>:

#include <iostream>
#include <string.h>
// test01
template <class T> class Array {
  int size;
  T *p;

public:
  // constructor
  Array();
  // override constructor
  Array(int n);
  // override operator
  T &operator[](int) const;
};
template <class T> Array<T>::Array() {
  size = 10;
  p = new T[size];
}
template <class T> Array<T>::Array(int n) {
  size = 10;
  p = new T[size];
}
template <class T> T &Array<T>::operator[](int i) const {
  if (i >= 0 && i < size) {
    return p[i];
  }
}

  定义一个非模板类：

class Student {
  int no;
  char name[10];

public:
  Student() {}
  Student(int n, char *s) {
    no = n;
    strcpy(name, s);
  }
  Student &operator=(Student &s) {
    no = s.no;
    strcpy(name, s.name);
    return *this;
  }
  void Display() const {
    std::cout << "no is " << no << " name is : " << name << std::endl;
  }
};

  测试代码

void test01() {
  std::cout << "test01" << std::endl;
  Array<int> a(5);
  a[0] = 1;
  a[1] = 2;
  a[2] = 3;
  a[3] = 4;
  a[4] = 5;
  for (int i = 0; i < 5; i++) {
    std::cout << a[i] << std::endl;
  }
  ///
  Array<Student> b(3);
  Student x(1, "zhang"), y(2, "wang"), z(3, "li");
  b[0] = x;
  b[1] = y;
  b[2] = z;
  for (int i = 0; i < 3; i++) {
    b[i].Display();
  }
}

输出结果

test01
1
2
3
4
5
no is 1 name is : zhang
no is 2 name is : wang
no is 3 name is : li

2. 类模板作为函数参数

  函数的形参可以是类模板。
先定义一个类模板

template <class T> class A {
  T x;

public:
  A(T a) { x = a; }
  T abs() {
    if (x < 0)
      return -x;
    else
      return x;
  }
};

再定义一个函数

template <class T> 
void fun(A<T> x) { 
	std::cout << x.abs() << std::endl; 
}

测试函数

void test02() {
  A<int> s1(-5);
  A<double> s2(-5.8);
  fun(s1);
  fun(s2);
}

输出结果

5
5.8

3.类模板的友元函数

TODO

4.模板与静态成员

template <class T> class D {
  T m;
  static T n;

public:
  D(T a) {
    m = a;
    n += m;
  }
  void Display() const {
    std::cout << "m = " << m << ", n = " << n << std::endl;
  }
};
template <class T> T D<T>::n = 0;
void test03() {
  D<int> d1(1);
  D<int> d2(2);
  d1.Display();
  d2.Display();
  D<double> d3(3.5);
  D<double> d4(1.2);
  d3.Display();
  d4.Display();
}

m = 1, n = 3
m = 2, n = 3
m = 3.5, n = 4.7
m = 1.2, n = 4.7