4. 模版

4.1 函数模版

注意：typename是用来定义模板参数关键字，也可以使用class切记：不能使用struct代替class)

template<typename T>
void Swap( T& left, T& right) {
 T temp = left;
 left = right;
 right = temp; }

模版参数也可以有多个

#include <iostream>

// 定义一个有两个模板参数的函数模板
template <typename T1, typename T2>
T1 addAndPrint(T1 a, T2 b) {
    std::cout << "Parameter 1: " << a << ", Parameter 2: " << b << std::endl;
    return a + static_cast<T1>(b);  // 返回两个参数之和
}

int main() {
    // 实例化函数模板，T1 为 int，T2 为 double
    int result1 = addAndPrint<int, double>(5, 3.14);
    std::cout << "Result 1: " << result1 << std::endl;

    // 实例化函数模板，T1 为 double，T2 为 int
    double result2 = addAndPrint<double, int>(2.5, 7);
    std::cout << "Result 2: " << result2 << std::endl;

    return 0;
}

4.2 函数模版的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

隐式实例化：让编译器根据实参推演模板参数的实际类型

#include<iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

template<class T>
 T Add(const T& left, const T& right) {
 return left + right; }
int main()
{
 int a1 = 10, a2 = 20;
 double d1 = 10.0, d2 = 20.0;
 Add(a1, a2);
 Add(d1, d2);
 
 /*
 该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
 Add(a1, d1);
 */
 
 // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
 Add(a1, (int)d1);
 return 0; 
 }

显式实例化：在函数名后的<>中指定模板参数的实际类型

就是加个<>

int main(void) {
 int a = 10;
 double b = 20.0;
 
 // 显式实例化
 Add<int>(a, b);
 return 0; 
}

4.3 模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

#include<iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

// 专门处理int的加法函数
int Add(int left, int right)
 {
 return left + right; 
 }
// 通用加法函数
template<class T> 
T Add(T left, T right) 
{
 return left + right; 
}

void Test()
{
 Add(1, 2); // 与非模板函数匹配，编译器不需要特化
 Add<int>(1, 2); // 调用编译器特化的Add版本
}

int main()
{
    Test();
    return 0;
}

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。如果没有模版的情况下，也可以凑合下

#include<iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

// 专门处理int的加法函数
int Add(int left, int right)
 {
 return left + right; 
 }

// // 通用加法函数
// template<class T1, class T2>
// T1 Add(T1 left, T2 right) 
// {
//  return left + right;
// }

void Test()
{
 Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
 Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函 数
}

int main()
{
    Test();
    return 0;
}

4.4 类模版

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include <vector>

// 类模板定义
template <typename T>
class Stack {
private:
    std::vector<T> elements;

public:
    // 压栈操作
    void push(const T& value) {
        elements.push_back(value);
    }

    // 弹栈操作
    T pop() {
        if (elements.empty()) {
            throw std::out_of_range("Stack is empty");
        }
        T top = elements.back();
        elements.pop_back();
        return top;
    }

    // 获取栈顶元素
    T top() const {
        if (elements.empty()) {
            throw std::out_of_range("Stack is empty");
        }
        return elements.back();
    }

    // 检查栈是否为空
    bool isEmpty() const {
        return elements.empty();
    }
};

int main() {
    // 使用 int 类型实例化堆栈
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    std::cout << "Top element of intStack: " << intStack.top() << std::endl;

    // 使用 double 类型实例化堆栈
    Stack<double> doubleStack;
    doubleStack.push(3.14);
    doubleStack.push(2.718);
    std::cout << "Top element of doubleStack: " << doubleStack.top() << std::endl;

    return 0;
}

C++模版（初级）

4. 模版

4.1 函数模版

4.2 函数模版的实例化

4.3 模板参数的匹配原则

4.4 类模版