C++ Primer：模板与泛型编程

1. 模板函数

在C++中，模板与泛型编程是一种强大的编程范式，它允许程序员编写与类型无关的代码。这种类型无关的代码在编译时会被实例化，以支持特定的数据类型。下面是根据您提出的点，对模板函数及其相关概念的一个整理。

模板函数是允许程序员编写一个函数模板，该模板可以与多种数据类型一起工作，而不是仅限于一种数据类型。通过模板，我们可以定义一组在逻辑上相似但操作的数据类型不同的函数。

1.1 模板参数

模板参数是模板定义中用于表示类型或值的占位符。在函数模板中，我们通常使用类型参数来指定函数可以操作的类型。类型参数在模板声明中通过关键字class或typename后跟一个标识符来声明（在模板定义中两者可互换使用，但typename在某些上下文中更为清晰）。

template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}

在上面的例子中，T是一个模板参数，它可以被任何类型所替代。

1.2 函数形参

函数形参是函数模板中除了模板参数以外的参数，它们定义了函数需要接收的实参的类型和数量。在模板函数中，形参的类型可以是模板参数所代表的类型，也可以是其他非模板类型。

template <typename T>
T add(T a, T b) {
    return a + b;
}

在这个例子中，a和b是函数add的形参，它们的类型由模板参数T决定。

1.3 成员模板

成员模板是类模板或普通类中的模板成员（可以是成员函数或成员变量）。成员模板允许我们在类的上下文中定义与类型无关的成员。

• 类模板中的成员函数模板：这种成员模板允许成员函数自身也接受模板参数，从而进一步增强了类的灵活性。

template <typename T>
class Box {
public:
    T value;

    // 成员函数模板
    template <typename U>
    void compare(U other) {
        if (value < other) {
            std::cout << "Box value is less than other." << std::endl;
        } else {
            std::cout << "Box value is not less than other." << std::endl;
        }
    }
};

在这个例子中，Box是一个类模板，它有一个成员函数模板compare，该函数接受一个不同类型的参数other，并与Box的value成员进行比较。

• 非模板类中的成员函数模板：虽然较少见，但即使在一个非模板类中，也可以定义成员函数模板，以提供对多种类型数据的操作。

模板和泛型编程是C++中一个非常重要的概念，它们极大地增强了C++的表达能力，使得代码更加灵活和可重用。通过上面的介绍，您应该对模板函数及其相关概念有了一定的了解。

2. 类模板

在C++中，模板（Templates）是泛型编程的基石，它允许程序员编写与类型无关的代码。类模板（Class Templates）是模板的一种形式，用于定义类，其中类或类的成员在定义时其类型可以是未指定的，直到类被实例化时才确定。下面是对类模板及其相关概念的详细整理，每个部分都包含例子。

2.1 与模板函数的区别

• 模板函数处理的是函数级别的泛型编程，其函数体在编译时根据提供的类型参数实例化。
• 类模板则是对类进行泛型化，可以定义类级别的泛型编程，类的所有成员（包括成员函数和成员变量）都可以是模板化的。

例子：

// 模板函数例子
template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 类模板例子
template<typename T>
class Box {
public:
    T value;
    Box(T val) : value(val) {}
    void print() { std::cout << value << std::endl; }
};

2.2 模板类名的使用

使用模板类时，需要在类名后加上尖括号<>中的类型参数。

例子：

Box<int> intBox(42);
intBox.print();  // 输出 42

Box<std::string> stringBox("Hello");
stringBox.print();  // 输出 Hello

2.3 类模板的成员函数

类模板的成员函数可以在类内部定义（隐式模板），也可以在类外部定义（显式模板）。

内部定义：

template<typename T>
class Box {
public:
    T value;
    Box(T val) : value(val) {}
    void print() { std::cout << value << std::endl; }
};

外部定义：

template<typename T>
class Box {
public:
    T value;
    Box(T val) : value(val) {}
    void print();
};

template<typename T>
void Box<T>::print() {
    std::cout << value << std::endl;
}

2.4 类型成员

类模板中可以包含类型成员，这些类型成员也可以是模板化的。

例子：

template<typename T, typename Alloc = std::allocator<T>>
class Vec {
public:
    using value_type = T;
    using allocator_type = Alloc;
    // 其他成员...
};

2.5 类模板和友元

友元关系对于类模板可以很复杂，因为友元可以是另一个模板或者非模板。

例子：

template<typename T>
class Box;

template<typename T>
void printBox(const Box<T>& b);

template<typename T>
class Box {
    T value;
    friend void printBox<>(const Box<T>&);
public:
    Box(T val) : value(val) {}
};

template<typename T>
void printBox(const Box<T>& b) {
    std::cout << b.value << std::endl;
}

注意：在某些编译器中，友元模板函数的声明可能需要额外的语法（如使用template<>），但上述简洁形式在现代编译器中通常是可接受的。

2.6 模板类型别名

使用using关键字可以定义模板类型别名，简化模板类型的书写。

例子：

template<typename T>
using Ptr = T*;

Ptr<int> p = new int(10);  // 相当于 int* p = new int(10);

2.7 类模板的 static 成员

类模板的static成员对于所有相同类型参数的实例是共享的。

例子：

template<typename T>
class Box {
private:
    static int count;
public:
    Box() { ++count; }
    ~Box() { --count; }
    static int getCount() { return count; }
};

template<typename T>
int Box<T>::count = 0;

int main() {
    Box<int> b1, b2;
    std::cout << Box<int>::getCount() << std::endl;  // 输出 2
    b1.~Box();  // 显式调用析构函数，仅为演示
    std::cout << Box<int>::getCount() << std::endl;  // 输出 1
    return 0;
}

通过这些例子和解释，你应该对C++中的类模板及其相关概念有了更深入的理解。

3. 模板编译

3.1 实例化声明

实例化声明（Instantiation Declaration）是模板使用的一个阶段，它指的是在编译过程中，编译器根据模板定义和特定的类型参数生成具体类型实例的过程。这个过程是隐式的，即用户不需要显式地编写实例化代码，编译器会根据上下文自动完成。

例子：

假设我们有一个函数模板compare，用于比较两个值：

template <typename T>
int compare(const T& a, const T& b) {
    if (a < b) return -1;
    if (b < a) return 1;
    return 0;
}

当我们在代码中调用compare(1, 2)时，编译器会自动实例化一个int类型的compare函数版本。这个过程就是实例化声明，它不需要用户手动干预。

3.2 实例化定义

实例化定义（Instantiation Definition）是模板编译的另一个关键阶段，它指的是编译器实际生成模板具体类型实例的代码的过程。这个过程可能是隐式的，也可能是显式的。隐式实例化定义发生在编译器自动根据模板定义和类型参数生成具体类型实例时；而显式实例化定义则是用户通过特定的语法告诉编译器生成某个具体类型的实例。

隐式实例化定义例子：

继续上面的compare函数模板例子，当调用compare(1.0, 2.0)时，编译器会自动实例化一个double类型的compare函数版本，这就是隐式实例化定义。

显式实例化定义例子：

用户可以通过extern template声明来显式地实例化模板的某些部分，但这主要用于控制模板实例的生成，以减少编译时间和优化链接过程。不过，更常见的显式实例化定义是直接通过模板实例化语法来完成的，如：

template int compare<int>(const int&, const int&); // 显式实例化int类型的compare函数

但请注意，上面的显式实例化定义语法在C++标准中并不直接支持用于函数模板的实例化（主要用于类或模板成员函数的实例化）。实际上，对于函数模板，我们通常不需要显式实例化定义，因为编译器会根据调用自动进行实例化。然而，为了说明概念，我们可以将其理解为一种“指导编译器生成特定类型实例”的方式。

在类模板的上下文中，显式实例化定义更加常见，例如：

template class SortedArray<int>; // 显式实例化SortedArray模板的int类型版本

这会告诉编译器生成SortedArray<int>类型的具体类定义，即使该类在程序的其他部分没有被直接使用。

模板编译中的实例化声明和实例化定义是模板使用的核心过程。实例化声明是隐式的，由编译器根据上下文自动完成；而实例化定义可以是隐式的，也可以是显式的，其中显式实例化定义主要用于控制模板实例的生成，优化编译和链接过程。通过理解这些过程，可以更好地掌握C++模板编程的精髓。

4. 模板参数

4.1 默认模板实参

默认模板实参允许为模板参数指定默认值，这样在使用模板时，如果没有为这些参数提供具体的值，就会使用默认值。这个功能在定义模板时非常有用，特别是当模板的某些参数在大多数情况下都有相同的值时。

例子

#include <iostream>
#include <vector>

// 定义一个模板，具有默认模板实参
template<typename T, int N = 10>
class Buffer {
public:
    T elem[N]; // 使用模板参数N作为数组大小

    // 初始化数组
    Buffer() {
        for (int i = 0; i < N; ++i) {
            elem[i] = T(); // 使用T的默认构造函数
        }
    }

    // 打印数组
    void print() const {
        for (int i = 0; i < N; ++i) {
            std::cout << elem[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // 使用默认模板实参
    Buffer<int> b1;
    b1.print(); // 打印10个0

    // 明确指定模板实参
    Buffer<double, 5> b2;
    b2.print(); // 打印5个0.0

    return 0;
}

4.2 模板实参推断

模板实参推断是编译器根据函数调用或模板实例化时提供的参数类型，自动推导出模板参数类型的过程。这个过程极大地简化了模板的使用，使得程序员无需显式指定模板参数的类型。

例子

首先，定义一个简单的模板函数：

#include <iostream>
#include <vector>

// 模板函数，用于打印容器的所有元素
template<typename Container>
void printContainer(const Container& c) {
    for (const auto& elem : c) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // 模板实参自动推断为std::vector<int>
    printContainer(vec);

    // 对于基本类型数组，模板实参推断不会工作，因为数组类型在模板实参推断中有特殊规则
    // 下面的代码会导致编译错误，除非使用显式模板实参或使用std::begin/std::end
    // int arr[] = {1, 2, 3, 4, 5};
    // printContainer(arr); // 错误

    // 使用std::begin和std::end绕过这个问题
    printContainer(std::begin(arr), std::end(arr)); // 假设修改printContainer以接受迭代器

    return 0;
}

// 注意：上面的例子在最后使用了迭代器而不是直接传递数组，因为直接传递数组给模板函数通常不会按预期工作。
// 正确的做法是为printContainer提供迭代器版本，或者使用std::array或std::vector等容器。

// 迭代器版本的printContainer可能如下：
template<typename Iter>
void printContainer(Iter begin, Iter end) {
    for (Iter it = begin; it != end; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

在上面的例子中，printContainer函数能够自动推断出Container的类型，这是基于传递给函数的容器对象的类型。然而，对于原生数组，直接传递通常会导致编译错误，因为数组名在大多数上下文中会退化为指向数组首元素的指针，而不是传递整个数组。为了处理数组，我们可以使用std::begin和std::end来获取数组的迭代器，或者将数组封装在如std::array或std::vector这样的容器中。

5. 重载与模板

5.1 模板函数与非模板函数的重载

模板函数可以与非模板函数共存，并基于函数调用时提供的参数类型进行重载解析。编译器会首先尝试将函数调用与任何非模板函数匹配。如果没有找到完全匹配的非模板函数，编译器将尝试使用模板函数进行匹配，并通过模板实参推断来确定模板参数的具体类型。

例子：

#include <iostream>
#include <string>

// 非模板函数
void print(const std::string& s) {
    std::cout << "Printing string: " << s << std::endl;
}

// 模板函数
template<typename T>
void print(T value) {
    std::cout << "Printing generic type: " << value << std::endl;
}

int main() {
    int num = 42;
    std::string str = "Hello, world!";

    // 调用非模板函数
    print(str); // 输出：Printing string: Hello, world!

    // 调用模板函数
    print(num); // 输出：Printing generic type: 42

    return 0;
}

在这个例子中，print函数被重载了：一个版本接受std::string类型，另一个版本是模板函数，可以接受任何类型。根据传入的参数类型，编译器会选择合适的函数进行调用。

5.2 模板函数之间的重载

模板函数之间也可以进行重载，这要求模板函数之间在参数数量或类型上存在差异，以便编译器能够根据函数调用时的参数来区分它们。

例子：

#include <iostream>

// 第一个模板函数，接受一个参数
template<typename T>
void func(T x) {
    std::cout << "Function with one parameter called." << std::endl;
}

// 第二个模板函数，接受两个参数，且两个参数类型相同
template<typename T>
void func(T x, T y) {
    std::cout << "Function with two identical parameters called." << std::endl;
}

// 第三个模板函数，接受两个参数，但参数类型可能不同
template<typename T, typename U>
void func(T x, U y) {
    std::cout << "Function with two different parameters called." << std::endl;
}

int main() {
    func(42);           // 调用第一个模板函数
    func(1.0, 2.0);     // 调用第二个模板函数
    func('a', 3.14);    // 调用第三个模板函数

    return 0;
}

在这个例子中，func函数被重载了三次：一次接受一个参数，一次接受两个相同类型的参数，另一次接受两个可能不同类型的参数。根据函数调用时提供的参数数量和类型，编译器会选择合适的模板函数进行实例化。

5.3 模板特化与重载的交互

模板特化允许为模板的特定类型提供定制化的实现。当模板特化与模板函数或其他模板特化共存时，重载解析规则同样适用。

例子：

#include <iostream>

// 通用模板函数
template<typename T>
void specialFunc(T x) {
    std::cout << "Generic version called." << std::endl;
}

// 模板特化
template<>
void specialFunc<int>(int x) {
    std::cout << "Specialized for int called." << std::endl;
}

// 另一个模板函数，可以与上面的模板函数共存
template<typename T>
void anotherFunc(T x) {
    std::cout << "Another function called." << std::endl;
}

int main() {
    specialFunc(42);      // 调用特化版本
    specialFunc(3.14);    // 调用通用模板版本
    anotherFunc(42);      // 调用另一个模板函数

    return 0;
}

在这个例子中，specialFunc模板函数有一个针对int类型的特化版本。当调用specialFunc并传入int类型的参数时，会调用特化版本；如果传入其他类型的参数，则会调用通用模板版本。同时，anotherFunc是另一个模板函数，与specialFunc共存且不受其特化的影响。

通过这些例子，我们可以看到模板与重载之间的交互为C++提供了极大的灵活性和表达能力。

6. 可变参数模板

可变参数模板是C++11中引入的一个新特性，它允许我们定义一个可以接受可变数目参数的模板函数或模板类。这对于编写能够处理任意数量和类型参数的函数或类非常有用。

6.1 定义可变参数模板

可变参数模板通过模板参数包（Template Parameter Pack）和函数参数包（Function Parameter Pack）来实现。模板参数包用于在模板定义中声明可变数量的类型参数，而函数参数包则用于在函数定义中声明可变数量的函数参数。

模板参数包使用typename...或class...来声明，后跟一个名称，表示这个包可以包含零个或多个类型。

函数参数包使用类型名称后跟省略号（…）来声明，表示这个函数可以接受零个或多个该类型的参数。

例子：可变参数模板函数

#include <iostream>

// 定义一个可变参数模板函数，用于打印任意数量和类型的参数
template<typename T, typename... Args>
void print(std::ostream& os, const T& first, const Args&... rest) {
    os << first; // 打印第一个参数
    if constexpr (sizeof...(Args) > 0) { // 如果Args不为空
        os << ", "; // 在参数之间添加逗号
        print(os, rest...); // 递归调用，打印剩余参数
    }
}

// 特化版本，用于处理参数包为空的情况，防止无限递归
template<typename T>
void print(std::ostream& os, const T& last) {
    os << last;
}

int main() {
    std::cout << "Printing with variadic templates: ";
    print(std::cout, 1, 3.14, "Hello, world!"); // 输出: 1, 3.14, Hello, world!
    return 0;
}

6.2 参数包的扩展

参数包的扩展是将参数包分解为单独的参数，并对每个参数执行某种操作的过程。在C++中，这通常通过递归函数或逗号表达式与初始化列表来实现。

递归方式：如上例所示，通过递归调用函数本身，每次传递除第一个参数外的剩余参数包。

逗号表达式与初始化列表：利用C++11的初始化列表和逗号运算符，可以在不显式递归的情况下扩展参数包。

6.3 转发参数包

可变参数模板经常与完美转发（Perfect Forwarding）结合使用，以确保参数在传递给其他函数时保持其原始值类别（左值或右值）。这通常通过std::forward和模板参数包中的右值引用来实现。

例子：转发参数包

#include <utility> // for std::forward
#include <vector>

template<typename... Args>
void wrapper(std::vector<int>& vec, Args&&... args) {
    vec.emplace_back(std::forward<Args>(args)...); // 转发参数包到emplace_back
}

int main() {
    std::vector<int> vec;
    wrapper(vec, 1, 2, 3, 4); // vec现在包含{1, 2, 3, 4}
    return 0;
}

在这个例子中，wrapper函数接受一个std::vector<int>和一个可变数量的参数。它使用std::forward将参数包转发给emplace_back，从而保持参数的原始值类别。

总结

可变参数模板是C++中非常强大的一个特性，它允许我们编写能够处理任意数量和类型参数的函数和类。通过模板参数包和函数参数包，我们可以灵活地定义和使用这些模板。此外，结合完美转发，我们可以确保参数在传递过程中保持其原始特性，从而编写出更加高效和通用的代码。

7.1 完全特例化（Full Specialization）

在C++中，模板特例化（Template Specialization）是模板编程的一个重要概念，它允许程序员为模板类或模板函数提供特定类型或值的定制实现。这在进行性能优化、处理特殊数据类型或当模板的通用实现不适用于特定情况时特别有用。模板特例化可以分为完全特例化和偏特例化两种形式。

完全特例化是指为模板的所有模板参数提供具体的类型或值。这允许你为特定的类型组合提供定制的实现。

例子

假设我们有一个通用的模板类，用于打印容器的大小，但我们想为std::string提供一个特别的实现，因为std::string的大小不是通过size()成员函数获得的，而是通过length()或size()（std::string同时提供了这两个成员函数）。然而，为了演示，我们可以假装std::string没有size()函数。

#include <iostream>
#include <vector>
#include <string>

// 通用模板类
template<typename Container>
class ContainerSize {
public:
    static void printSize(const Container& c) {
        std::cout << "Size: " << c.size() << std::endl;
    }
};

// std::string的完全特例化
template::<>cout
 <<class " ContainerLengthSize:< "std <<:: sstring> {
public:
    static void printSize(const std::string& s) {
.        stdlength() << std::endl; // 使用length()而不是size()
    }
};

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    ContainerSize<std::vector<int>>::printSize(vec); // 输出: Size: 5

    std::string str = "Hello, World!";
    ContainerSize<std::string>::printSize(str); // 输出: Length: 13

    return 0;
}

7.2 偏特例化（Partial Specialization）

偏特例化允许你为模板的一部分（而不是全部）模板参数提供具体的类型或值。这仅适用于模板类（不适用于模板函数）。

例子

假设我们有一个模板类，它接受两个类型参数，但我们只想为第一个类型为指针的类型组合提供定制实现。

#include <iostream>

// 通用模板类
template<typename T1, typename T2>
class PairOperations {
public:
    static void perform() {
        std::cout << "Performing generic operations." << std::endl;
    }
};

// 偏特例化，第一个类型为指针
template<typename T2>
class PairOperations<void*, T2> {
public:
    static void perform() {
        std::cout << "Performing special operations for void* and " << typeid(T2).name() << std::endl;
    }
};

int main() {
    PairOperations<int, double>::perform(); // 输出: Performing generic operations.
    PairOperations<void*, double>::perform(); // 输出: Performing special operations for void* and d

    return 0;
}

注意：在上面的偏特例化例子中，我使用了void*作为第一个类型的特例化条件，但这仅仅是为了演示。在实际应用中，你可能会选择更具体的类型或类型组合进行偏特例化。

另外，请注意typeid(T2).name()的使用，它用于获取T2的类型名称，但请注意，由于类型名称的实现依赖于编译器，因此得到的名称可能在不同编译器之间有所不同，且可能包含编译器特定的前缀或后缀。