C++ 类模板

在本教程中，我们将通过示例了解 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 中定义 .

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

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 ，以及用于初始化成员的构造函数。

我们还有 add() , subtract() , multiply() , 和 divide() 返回类型为 T 的函数 .我们还有一个 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);

在这里，

对象	T	你	V
`obj1`	`int`	`double`	`char`
`obj2`	`double`	`char`	`bool`

对于 obj1 , T = int , U = double 和 V = char .

对于 obj2 , T = double , U = char 和 V = bool .

C++ 虚函数 C 关键字和标识符

C语言