C++ 类模板

模板是 C++ 的强大功能，它允许我们编写泛型程序。有两种方法可以实现模板：

• 函数模板
• 类模板

与函数模板类似，我们可以使用类模板创建一个单一的 类 来处理不同的 数据类型。

类模板非常有用，因为它们可以使我们的代码更短、更易于管理。

类模板声明

类模板以关键字 template 开头，后跟 <> 中的模板参数，然后是类声明。

template <class T>
class className {
  private:
    T var;
    ... .. ...
  public:
    T functionName(T arg);
    ... .. ...
};

在上面的声明中，T 是模板参数，它是所用数据类型的占位符，而 class 是一个 关键字。

在类体内，成员变量 var 和成员函数 functionName() 的类型都是 T。

创建类模板对象

声明和定义了类模板后，我们可以使用以下语法在其他类或 函数（如 main() 函数）中创建它的 对象：

className<dataType> classObject;

例如，

className<int> classObject;
className<float> classObject;
className<string> classObject;

示例 1：C++ 类模板

// C++ program to demonstrate the use of class templates

#include <iostream>
using namespace std;

// Class template
template <class T>
class Number {
   private:
    // Variable of type T
    T num;

   public:
    Number(T n) : num(n) {}   // constructor

    T getNum() {
        return num;
    }
};

int main() {

    // create object with int type
    Number<int> numberInt(7);

    // create object with double type
    Number<double> numberDouble(7.7);

    cout << "int Number = " << numberInt.getNum() << endl;
    cout << "double Number = " << numberDouble.getNum() << endl;

    return 0;
}

输出

int Number = 7
double Number = 7.7

在此程序中，我们使用以下代码创建了一个名为 Number 的类模板：

template <class T>
class Number {
   private:
    T num;

   public:
    Number(T n) : num(n) {}
    T getNum() { return num; }
};

请注意，变量 num、构造函数参数 n 和函数 getNum() 的类型都是 T，或者返回类型为 T。这意味着它们可以是任何类型。

在 main() 中，我们通过创建其对象来实现类模板：

Number<int> numberInt(7);
Number<double> numberDouble(7.7);

请注意上面代码中的 Number<int> 和 Number<double> 代码。

这会为 int 和 float 分别创建一个类定义，然后根据需要使用它们。

在声明类模板对象时指定类型是一个好习惯。否则，某些编译器可能会抛出错误。

//Error
Number numberInt(7);
Number numberDouble(7.7);

在类模板外部定义类成员

假设我们需要在类模板外部定义一个函数。我们可以使用以下代码来实现：

template <class T>
class ClassName {
    ... .. ...
    // Function prototype
    returnType functionName();
};

// Function definition
template <class T>
returnType ClassName<T>::functionName() {
    // code
}

请注意，在类外部定义函数时，代码 template <class T> 会重复出现。这是必需的，并且是语法的一部分。

如果我们查看 **示例 1** 中的代码，我们会发现一个名为 getNum() 的函数定义在 Number 类模板内部。

我们可以使用以下代码在 Number 外部定义 getNum()：

template <class T>
class Number {
    ... .. ...
    // Function prototype
    T getnum();
};

// Function definition
template <class T>
T Number<T>::getNum() {
    return num;
}

示例 2：使用类模板的简单计算器

此程序使用类模板对两个 变量 num1 和 num2 执行加、减、乘、除运算。

变量可以是任何类型，尽管在此示例中我们只使用了 int 和 float 类型。

#include <iostream>
using namespace std;

template <class T>
class Calculator {
   private:
    T num1, num2;

   public:
    Calculator(T n1, T n2) {
        num1 = n1;
        num2 = n2;
    }

    void displayResult() {
        cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
        cout << num1 << " + " << num2 << " = " << add() << endl;
        cout << num1 << " - " << num2 << " = " << subtract() << endl;
        cout << num1 << " * " << num2 << " = " << multiply() << endl;
        cout << num1 << " / " << num2 << " = " << divide() << endl;
    }

    T add() { return num1 + num2; }
    T subtract() { return num1 - num2; }
    T multiply() { return num1 * num2; }
    T divide() { return num1 / num2; }
};

int main() {
    Calculator<int> intCalc(2, 1);
    Calculator<float> floatCalc(2.4, 1.2);

    cout << "Int results:" << endl;
    intCalc.displayResult();

    cout << endl
         << "Float results:" << endl;
    floatCalc.displayResult();

    return 0;
}

输出

Int results:
Numbers: 2 and 1.
2 + 1 = 3
2 - 1 = 1
2 * 1 = 2
2 / 1 = 2

Float results:
Numbers: 2.4 and 1.2.
2.4 + 1.2 = 3.6
2.4 - 1.2 = 1.2
2.4 * 1.2 = 2.88
2.4 / 1.2 = 2

在上程序中，我们声明了一个名为 Calculator 的类模板。

该类包含两个类型为 T 的私有成员：num1 和 num2，以及一个用于初始化成员的构造函数。

我们还有返回类型为 T 的 add()、subtract()、multiply() 和 divide() 函数。我们还有一个 void 函数 displayResult()，它打印其他函数的结果。

在 main() 中，我们创建了两个 Calculator 对象：一个用于 int 数据类型，另一个用于 float 数据类型。

Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2);

这会提示编译器在编译期间为相应的数据类型创建两个类定义。

C++ 类模板与多个参数

在 C++ 中，我们可以使用多个模板参数，甚至可以为这些参数使用默认参数。例如：

template <class T, class U, class V = int>
class ClassName {
  private:
    T member1;
    U member2;
    V member3;
    ... .. ...
  public:
    ... .. ...
};

示例 3：C++ 带有多个参数的模板

#include <iostream>
using namespace std;

// Class template with multiple and default parameters
template <class T, class U, class V = char>
class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;

   public:
    ClassTemplate(T v1, U v2, V v3) : var1(v1), var2(v2), var3(v3) {}  // constructor

    void printVar() {
        cout << "var1 = " << var1 << endl;
        cout << "var2 = " << var2 << endl;
        cout << "var3 = " << var3 << endl;
    }
};

int main() {
    // create object with int, double and char types
    ClassTemplate<int, double> obj1(7, 7.7, 'c');
    cout << "obj1 values: " << endl;
    obj1.printVar();

    // create object with int, double and bool types
    ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
    cout << "\nobj2 values: " << endl;
    obj2.printVar();

    return 0;
}

输出

obj1 values: 
var1 = 7
var2 = 7.7
var3 = c

obj2 values: 
var1 = 8.8
var2 = a
var3 = 0

在此程序中，我们创建了一个名为 ClassTemplate 的类模板，它有三个参数，其中一个参数是默认参数。

template <class T, class U, class V = char>
class ClassTemplate {
  // code  
};

请注意 class V = char 代码。这意味着 V 是一个默认参数，其默认类型为 char。

在 ClassTemplate 内部，我们声明了 3 个变量 var1、var2 和 var3，每个变量对应一个模板参数。

class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;
    ... .. ...
    ... .. ...
};

在 main() 中，我们使用以下代码创建了两个 ClassTemplate 对象：

// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');

// create object with double, char and bool types
ClassTemplate<double, char, bool> obj2(8, 8.8, false);

这里，

对于 obj1，T = int、U = double 和 V = char。

对于 obj2，T = double、U = char 和 V = bool。

另请阅读

• C++ 标准模板库