在C++编程中，模板是一个极具表现力的工具，它允许程序员编写泛型代码，从而实现高度复用与灵活性。本文将深入探讨C++模板的若干关键特征与技巧，包括模板参数作用域、非类型参数、模板特例化、引用折叠、std::move的使用以及模板函数匹配的特殊性。文章旨在为初学者和进阶开发者提供清晰、实用的理解。
模板的基本声明和定义
C++模板是编译时的代码生成机制，允许我们根据类型参数或非类型参数生成多个版本的代码。模板可以用于函数和类，提供高度通用的接口。
模板的声明
模板声明通常包含一个模板参数列表，该列表定义了模板将使用的参数类型或值。例如：
template <typename T>
int compare(T t1, T t2);
这种声明方式告诉编译器，compare函数是一个模板函数，它的参数类型由模板参数T决定。模板参数T可以是任何类型，包括内置类型、用户定义类型或指针类型。
定义一个模板函数
模板函数的定义应与声明保持一致，包括参数类型和返回类型。例如：
template <typename T>
int compare(T & t1, T & t2)
{
if(t1 > t2)
return 1;
if(t1 == t2)
return 0;
if(t1 < t2)
return -1;
}
这里的函数定义使用了引用传递，确保了传入的参数不会被复制，从而提升了性能。
定义一个模板类
模板类的定义方式与函数类似，但需要特别注意类的成员函数与模板参数的作用。例如：
template <typename T>
class compare
{
private:
T _val;
public:
explicit compare(T & val) : _val(val) { }
explicit compare(T && val) : _val(val) { }
bool operator==(T & t)
{
return _val == t;
}
};
在这个类中，_val是模板参数T的一个实例，而operator==则是一个模板成员函数，它接受T类型参数并进行比较。
模板参数作用域
在模板中，参数T的作用域与其他函数参数相似，它仅在模板内部有效。例如：
using T = int;
T a = 10;
template <typename T> class A
{
U val; // 错误！U未定义
};
在这个例子中，T在模板类A内部的作用域是独立的，因此无法访问外部定义的T。
模板工作原理
模板定义并不是真正的定义，而是编译器在需要时根据模板参数生成具体版本的代码。这一过程被称为模板实例化。例如：
template <typename T>
int compare(T & t1, T & t2);
当调用compare(10, 20)时，编译器会生成int compare(int & t1, int & t2)的实现。这种机制类似于宏替换，但提供了类型安全。
模板类实例化
模板类在没有调用之前不会生成代码，因此它的定义通常放在头文件中。例如：
template <typename T>
class compare
{
T _val;
};
在使用时，编译器会根据调用时的模板参数生成具体的类实例。
非类型模板参数
非类型模板参数是指在模板中使用具体的值，而不是类型。这些值通常为常量表达式，例如大小、数组长度等。
template <size_t N, size_t M>
int str_compare(const char (&str1)[N], const char (&str2)[M])
{
return strcmp(str1, str2);
}
在这个例子中，N和M是非类型模板参数，分别表示两个字符串的长度。编译器会根据传入的字符串长度自动推断N和M的值。
非类型模板参数的范围
非类型模板参数可以是整数类型、指针或引用类型。例如：
template <int N>
void func(int (&arr)[N]);
在这个例子中，N是一个非类型模板参数，表示数组的长度。由于数组长度必须在编译时确定，因此N必须是一个常量表达式。
inline和constexp
在C++中，inline关键字用于指示编译器不要对函数进行内联展开，而constexp（常量表达式）用于指示编译器在编译时计算表达式的值。
template <typename T>
inline int compare(T t1, T t2);
inline关键字有助于减小编译时间，因为它告诉编译器不要生成函数调用的代码，而是直接插入到调用点。constexp则用于确保某些表达式可以在编译时计算。
在模板类中使用模板类
模板类可以包含其他模板类作为成员。例如：
template <typename T>
class A
{
private:
std::vector<T> vec;
};
在这个例子中，std::vector<T>是一个模板类，它被作为A类的成员使用。类似的，我们也可以定义一个模板类B，其成员是std::vector<int>。
友元与模板类
模板类的友元关系需要特别处理，因为每个实例化的模板类都会生成一个对应的类。例如：
template <typename N>
class C
{
friend class A<N>;
friend class B<int>;
};
在这个例子中，A<N>和B<int>是C类的友元类。这意味着A<N>和B<int>中的成员函数可以访问C类的私有成员。
模板友元
模板友元可以声明为所有实例化的类的友元，例如：
template <typename N>
class C
{
template <typename T> friend class D;
};
这表示D类的所有实例化版本都是C类的友元类。
默认模板实参
模板可以有默认的参数值，这与普通函数的默认参数类似。例如：
template <typename T = int> class A;
在这种情况下，T的默认值为int，如果未显式指定，则会使用默认值。
:: 二义性的解决
在模板中，使用::时需要特别注意，因为编译器可能无法确定它是一个类型还是一个静态成员。例如：
template <typename T>
typename T::val_typefunc();
在这里，T::val_typefunc表示一个类型，因此使用typename来明确表示这一点。如果没有typename，编译器可能会将其解析为静态成员。
类模板成员函数
类模板的成员函数与普通类的成员函数类似，但需要特别注意模板参数的作用。例如：
template <typename T>
class Math
{
public:
template <typename N> inline static N sqrt(N);
};
template <typename N>
N Math::sqrt(N val)
{
return val * val;
}
在这个例子中，sqrt是一个类模板的静态成员函数，它的参数类型由N决定。定义时需要使用作用域解析符来指示它是哪个类的成员函数。
类模板的成员模板
类模板可以包含成员模板，这允许在类内部定义其他模板。例如：
template <typename T>
class A
{
public:
template <typename It> T sum(It _begin, It _end);
};
template <typename T>
template <typename It>
T A<T>::sum(It _begin, It _end)
{
T tot;
while (_begin != _end)
{
tot += *_begin++;
}
return tot;
}
在这个例子中，sum是类模板A的一个成员模板，它接受两个迭代器作为参数。由于模板参数T和It是独立的，因此需要使用作用域解析符来指示该函数是A类的成员函数。
实例化优化
模板实例化可能导致多个文件中生成相同的代码，这会增加编译时间。为了解决这一问题，可以使用extern关键字来控制实例化。
extern template class A<string>;
template int compare(const int &, const int &);
extern声明表明该实例化版本在其他文件中已经定义，因此编译器不会重复生成。
类型转换和参数推断
模板在传递参数时会进行类型转换，但这一过程遵循特定的规则。例如：
template <typename T>
bool func(const T & t1, const T & t2);
在这个函数中，const T &允许通过非const参数进行转换。然而，如果函数的参数是T &，则无法通过const参数进行转换。
返回值类型推断
在某些情况下，编译器可以自动推断函数的返回值类型，例如通过尾置返回类型：
auto func(It & _beg, It & _end) -> decltype(*_beg)
{
// 实现
}
这种方式允许编译器在函数声明之后推断返回值类型，从而提高代码的可读性和灵活性。
兼容类型的模板问题
在使用模板时，需要确保传递的参数类型与模板参数兼容。例如：
template <typename T>
T func(const T & t1, const T & t2);
如果t1和t2是不同的类型，编译器将无法正确推断T的值，导致编译错误。
函数指针实参推断
在某些情况下，函数指针可以作为模板参数传递。例如：
template <typename T>
void func(T (*ptr)(T, T));
这里的ptr是一个函数指针，它接受两个T类型参数并返回一个T类型值。
模板实参推断
模板实参推断允许编译器根据调用时的参数自动推断模板参数的值。例如：
template <typename T>
void func(T a, T b);
当调用func(10, 20)时，编译器会推断T为int。
左值引用与右值引用
在C++中，左值引用和右值引用是两种不同的引用类型，它们允许我们区分值的来源。左值引用允许我们绑定到一个对象，而右值引用允许我们绑定到一个临时对象。
template <typename T>
void func(T & a, T && b);
在这个函数中，a是一个左值引用，b是一个右值引用。通过这种区分，我们可以实现移动语义，提高程序的性能。
引用折叠
引用折叠是C++11引入的一个特性，它允许我们对左值引用和右值引用进行操作。例如：
template <typename T>
void func(T && a);
在这个函数中，a是一个右值引用，但如果我们传递一个左值，它将被折叠为左值引用。
std::move
std::move是一个用于将左值转换为右值引用的函数，它允许我们实现移动语义。例如：
template <typename T>
void func(T && a)
{
// 使用std::move
T b = std::move(a);
}
通过std::move，我们可以将a从左值转换为右值引用，从而允许其被移动。
模板函数匹配的特殊性
模板函数匹配遵循特定的规则，这些规则与普通函数的匹配不同。例如：
template <typename T>
void func(T a, T b);
当调用func(10, 20)时，T将被推断为int，而调用func(10.0, 20.0)时，T将被推断为double。
模板特例化
模板特例化允许我们为特定类型或值定义模板的具体版本。例如：
template <typename T>
class A
{
// 普通模板实现
};
template <>
class A<int>
{
// 特例化实现
};
在这个例子中，A<int>是一个特例化版本，它提供了特定于int类型的实现。
特例化与重载的区别
特例化和重载有明显的区别。特例化为模板生成一个特定版本的代码，而重载则为同一个函数名生成多个实现。例如：
void func(int a);
void func(double a);
这两个函数是重载，而特例化则是一个函数或类为特定类型生成具体实现。
类模板特例化
类模板的特例化与函数模板的特例化类似，但需要特别注意类名和模板参数的匹配。例如：
template <typename T>
class A
{
// 普通模板实现
};
template <>
class A<int>
{
// 特例化实现
};
在这个例子中，A<int>是A类的一个特例化版本。
部分模板特例化
部分模板特例化允许我们为模板的一部分参数定义特例化版本。例如：
template <typename T>
class A
{
// 普通模板实现
};
template <typename T>
class A<T*>
{
// 特例化实现
};
在这个例子中，A<T*>是一个部分特例化版本。
特例化成员
特例化成员允许我们为特定类型定义模板类的成员函数。例如：
template <typename T>
class A
{
public:
void func();
};
template <typename T>
void A<T>::func()
{
// 普通成员函数实现
}
template <>
void A<int>::func()
{
// 特例化成员函数实现
}
在这个例子中，A<int>::func是一个特例化成员函数。
可变参数模板
可变参数模板允许我们定义接受可变数量参数的模板函数或类。例如：
template <typename... Args>
void func(Args... args);
在这个例子中，Args...表示一个可变参数列表，args...表示这些参数的包展开。
可变模板参数的具体作用
可变参数模板在C++中非常有用，特别是在实现通用函数或类时。例如，std::make_shared就是一个可变参数模板，它允许我们创建一个共享指针并初始化其指向的对象。
template <typename T, typename... Args>
std::shared_ptr<T> make_shared(Args... args);
在这个例子中，make_shared接受任意数量的参数并创建一个共享指针。
模板技巧
转发
转发是C++11引入的一个特性，它允许我们将参数从一个函数转发到另一个函数。例如：
template <typename T>
void func(T && a)
{
// 转发
bar(std::forward<T>(a));
}
通过std::forward，我们可以保持参数的左值或右值特性。
使用std::forward
std::forward用于转发参数，它允许我们在模板函数中保持参数的原始类型特征。例如：
template <typename T>
void func(T && a)
{
bar(std::forward<T>(a));
}
在这个例子中，std::forward<T>(a)将a作为右值引用转发给bar函数。
转发参数包
转发参数包用于将多个参数转发给另一个函数。例如：
template <typename... Args>
void func(Args... args)
{
bar(std::forward<Args>(args)...);
}
在这个例子中，std::forward<Args>(args)...将所有参数转发给bar函数。
make_shared的工作原理
std::make_shared是一个可变参数模板，它允许我们创建一个共享指针并初始化其指向的对象。例如：
std::shared_ptr<int> ptr = std::make_shared<int>(10);
通过make_shared，我们可以创建一个共享指针，其指向的对象由传入的参数初始化。
总结
C++模板是一个非常强大的工具，它允许我们编写泛型代码，从而实现高度复用与灵活性。通过掌握模板的声明、定义、参数作用域、非类型参数、inline和constexp、模板类的使用、友元关系、默认模板实参、实例化优化、类型转换、参数推断、返回值类型推断、左值引用与右值引用、引用折叠、std::move、模板函数匹配、特例化、可变参数模板等特性，我们可以写出更加高效和灵活的代码。模板的使用需要谨慎，以避免常见的问题和错误，同时也要注意性能优化，以确保代码的高效运行。
关键字列表：
C++模板, 模板实例化, 非类型模板参数, inline, constexp, 友元, 默认模板实参, 类模板成员函数, 可变参数模板, std::move, 引用折叠, 类型转换, 参数推断, 返回值类型推断, 零开销抽象, 模板特例化, 模板函数匹配, 编译器优化