C++模板是实现泛型编程的核心工具之一，它允许开发者编写与类型无关的代码，从而提高代码的复用性和可维护性。本文将深入解析C++模板的定义、实例化、参数类型、成员函数、构造函数、友元以及静态成员等内容，帮助读者掌握模板编程的精髓。
函数模板
函数模板是C++中实现泛型编程的重要方式之一。它允许我们定义一个通用的函数，可以处理多种数据类型，而无需为每种类型编写单独的函数。
函数模板的定义以关键字 template 开始，后接一个模板参数列表，该列表用 < 和 > 括起来。模板参数可以是类型参数，也可以是非类型参数。例如：
template<typename T>
int compare(const T& v1, const T& v2)
{
if (v1 < v2) return -1;
if (v2 < v1) return 1;
return 0;
}
在这个函数模板中，T 是一个类型参数，compare 函数接受两个 T 类型的常量引用，并返回一个整数值，表示它们的大小关系。
实例化函数模板
当我们调用一个函数模板时，编译器会根据传入的实参推断模板参数。例如：
cout << compare(1, 0) << endl; // T 推断为 int
在这个例子中，compare 被实例化为 int compare(const int&, const int&)，并返回相应的结果。
模板类型参数
在模板参数列表中，使用 typename 或 class 来定义类型参数。例如：
template<typename T>
void print(T value) {
std::cout << value << std::endl;
}
这里，T 是一个类型参数，表示一个通用的数据类型。在函数体内，我们可以像使用任何其他类型一样使用 T。
非类型模板参数
非类型模板参数允许我们在模板中使用常量值。例如：
template<int N>
int multiplyByN(int value) {
return value * N;
}
在这个例子中，N 是一个非类型参数，表示一个整数常量值。
inline 和 constexpr 的函数模板
函数模板可以声明为 inline 或 constexpr，这与非模板函数的声明方式相同。例如：
template <typename T> inline T min(const T&, const T&);
编写类型无关的代码
将参数定义为 const 的引用可以避免不必要的拷贝操作，这对于处理不能拷贝的类型尤为重要。例如：
template <typename T>
int compare(const T &v1, const T &v2) {
if (v1 < v2) return -1;
if (v2 < v1) return 1;
return 0;
}
在这个函数中，我们只使用 < 进行比较，这样可以确保被比较的类型只需要支持这个运算符即可。
类模板
类模板是面向对象编程中实现泛型编程的另一个重要工具。它允许我们定义一个通用的类，可以处理多种数据类型。
类模板的定义以关键字 template 开始，后接一个模板参数列表。例如：
template <typename T1, typename T2>
class Pair {
private:
T1 first;
T2 second;
public:
Pair(const T1& f, const T2& s) : first(f), second(s) {}
T1 getFirst() const { return first; }
T2 getSecond() const { return second; }
};
在这个类模板中，T1 和 T2 是类型参数，分别表示两个不同的数据类型。
实例化类模板
实例化一个类模板时，需要指定具体的类型参数。例如：
Pair<int, double> myPair(5, 3.14);
在这个例子中，myPair 是一个 Pair<int, double> 的实例。
类模板的成员函数
类模板的成员函数可以定义在类模板内部或外部。如果定义在类模板外部，需要显式指定模板参数。例如：
template <typename T>
class MyContainer {
private:
T element;
public:
MyContainer(const T& elem) : element(elem) {}
T getElement() const;
};
// 在类模板外部定义成员函数
template <typename T>
T MyContainer<T>::getElement() const {
return element;
}
类模板构造函数
类模板的构造函数可以定义在类模板内部或外部。如果定义在外部，需要显式指定模板参数。例如：
template <typename T>
class MyContainer {
private:
T element;
public:
MyContainer(const T& element);
};
// 在类模板外部定义构造函数
template <typename T>
MyContainer<T>::MyContainer(const T& element) : element(element) {}
在类模板外使用类模板名
在类模板外部使用类模板名时，需要显式指定模板参数。例如：
template <typename T>
class MyTemplate {
public:
void doSomething(const T& value);
};
// 在类模板外部定义成员函数
template <typename T>
void MyTemplate<T>::doSomething(const T& value) {
// 实现类模板的成员函数
}
在类模板中的友元
类模板可以声明友元函数或友元类，这些友元可以访问类模板的私有成员。
声明友元函数模板
template <typename T>
class MyClass {
public:
MyClass(T value) : value(value) {}
template <typename U>
friend void printValue(const MyClass<U>& obj);
private:
T value;
};
template <typename U>
void printValue(const MyClass<U>& obj) {
std::cout << "Value: " << obj.value << std::endl;
}
声明友元类模板
template <typename T>
class MyClass {
public:
MyClass(T value) : value(value) {}
friend class FriendClass<T>;
private:
T value;
};
template <typename T>
class FriendClass {
public:
void showValue(const MyClass<T>& obj);
};
template <typename T>
void FriendClass<T>::showValue(const MyClass<T>& obj) {
std::cout << "Value: " << obj.value << std::endl;
}
声明特定实例的友元函数
template <typename T>
class MyClass {
public:
MyClass(T value) : value(value) {}
friend void printValue(const MyClass<T>& obj) {
std::cout << "Value: " << obj.value << std::endl;
}
private:
T value;
};
类模板的 static 成员
类模板可以声明静态成员变量和静态成员函数。这些成员在所有模板实例之间共享。
template <typename T>
class MyContainer {
private:
static T default_value;
T element;
public:
MyContainer() : element(default_value) {}
static T getDefault() {
return default_value;
}
};
// 静态成员变量的定义
template <typename T>
T MyContainer<T>::default_value = T{};
模板参数
模板参数可以是类型参数或非类型参数。类型参数通常命名为 T，但可以使用任何名称。
默认模板实参
模板参数可以有默认值，这样在实例化时可以省略某些实参。例如：
template<typename T = int>
class MyContainer {
private:
T element;
public:
MyContainer() : element(T{}) {}
};
在这个例子中，T 的默认值是 int，所以在实例化时可以省略类型参数。
模板默认实参与类模板
类模板可以有默认实参，这在某些情况下非常有用。例如：
template<typename T = int>
class MyContainer {
private:
T element;
public:
MyContainer() : element(T{}) {}
};
成员模板
成员模板是指定义在类模板内部的模板函数或模板类。它们可以访问类模板的成员和类型。
非模板类的成员模板
非模板类的成员模板是指类中的某个成员是模板函数或模板类。例如：
class MyContainer {
private:
int element;
public:
template<typename T>
void setElement(T value) {
element = value;
}
};
在这个例子中，setElement 是一个成员模板函数，接受一个泛型参数 T。
类模板的成员模板
类模板的成员模板是指类模板中的某个成员是模板函数或模板类。例如：
template<typename T>
class MyContainer {
private:
T element;
public:
template<typename U>
void setElement(U value) {
element = value;
}
};
在这个例子中，setElement 是一个成员模板函数，接受一个泛型参数 U。
实例化与成员模板
实例化成员模板时，需要指定具体的类型参数。例如：
MyContainer<int> myContainer;
myContainer.setElement<double>(3.14);
在这个例子中，myContainer 是一个 MyContainer<int> 的实例，setElement 是一个成员模板函数，接受一个 double 类型的参数。
继承关系
模板类之间的继承关系可以根据父类和子类的类型进行定义。
父类是一般类，子类是模板类
如果父类是一个普通类，而子类是一个模板类，那么子类可以继承父类的成员和方法。例如：
class Base {
public:
void print() {
std::cout << "Base class" << std::endl;
}
};
template<typename T>
class Derived : public Base {
public:
void print(T value) {
std::cout << "Derived class with value: " << value << std::endl;
}
};
在这个例子中，Derived 继承自 Base，并添加了一个新的方法 print(T value)。
父类是模板类，子类是普通类
如果父类是一个模板类，而子类是一个普通类，那么子类可以继承父类的成员和方法。例如：
template<typename T>
class Base {
public:
void print() {
std::cout << "Base class with value: " << value << std::endl;
}
T value;
};
class Derived : public Base<int> {
public:
void show() {
std::cout << "Derived class" << std::endl;
}
};
在这个例子中，Derived 继承自 Base<int>，并添加了一个新的方法 show()。
父类和子类都是模板类
如果父类和子类都是模板类，那么子类可以继承父类的成员和方法。例如：
template<typename T>
class Base {
public:
void print() {
std::cout << "Base class with value: " << value << std::endl;
}
T value;
};
template<typename T>
class Derived : public Base<T> {
public:
void show() {
std::cout << "Derived class with value: " << value << std::endl;
}
};
在这个例子中，Derived 继承自 Base<T>，并添加了一个新的方法 show()。
注意事项
在使用模板时，需要注意一些常见问题和最佳实践，以确保代码的正确性和效率。
- 类型推断：在调用函数模板时，编译器通常会根据实参推断模板参数。但有时需要显式指定模板参数，以避免歧义。
- 模板实例化：模板在实例化时生成特定类型的代码，这可能导致编译时间增加。
- 模板参数使用：模板参数可以是类型或非类型，但在某些情况下需要特别注意参数的类型和值。
- 静态成员：类模板中的静态成员在所有实例之间共享，这在某些情况下非常重要。
- 友元函数：友元函数可以访问类模板的私有成员，但需要正确声明和定义。
- 性能优化：使用模板可以提高性能，但需要注意避免不必要的实例化和复杂的模板元编程。
总结
C++模板是实现泛型编程的强大工具，它允许开发者编写与类型无关的代码，提高代码的复用性和可维护性。通过函数模板和类模板，我们可以处理多种数据类型，而无需为每种类型编写单独的函数或类。在使用模板时，需要注意类型推断、实例化、参数使用、静态成员、友元函数和性能优化等方面的问题。掌握这些概念和技巧，能够帮助开发者更好地利用C++模板进行高效、灵活的编程。
关键字列表：
C++模板, 函数模板, 类模板, 静态成员, 友元函数, 类型参数, 非类型参数, 模板实例化, 性能优化, 泛型编程