C++中的Template常见用法

沉夢志昂丶

已于 2024-06-04 10:14:26 修改

阅读量1.6k

点赞数 25

分类专栏： C++的自我救赎学习分享文章标签： c++ 算法开发语言数据结构模板

于 2024-06-04 10:11:19 首次发布

本文链接：https://blog.csdn.net/golojo/article/details/139430866

版权

分享同时被 3 个专栏收录

61 篇文章 0 订阅

订阅专栏

学习

59 篇文章 0 订阅

订阅专栏

C++的自我救赎

52 篇文章 2 订阅

订阅专栏

模板特化（Specialization）与偏特化（Partial Specialization）

别名模板（Alias Templates）

基本用法

变量模板（Variable Templates）

基本用法

模板模板参数（Template Template Parameters）

基本用法

总结

摘要

C++中的模板（template）是一种非常强大的工具，用于泛型编程和代码复用。模板可以分为函数模板、类模板、别名模板、变量模板、模板模板参数等。这些模板能够处理任意类型的数据，提高代码的灵活性和可重用性。

函数模板

函数模板允许函数对任意类型的数据进行操作。

基本用法

#include <iostream>

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << "Max of 3 and 7: " << max(3, 7) << std::endl;
    std::cout << "Max of 3.5 and 2.1: " << max(3.5, 2.1) << std::endl;
    std::cout << "Max of 'a' and 'z': " << max('a', 'z') << std::endl;
    return 0;
}

重载与特化

函数模板可以与普通函数重载，并且可以进行模板特化。

#include <iostream>

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 特化版本
template <>
const char* max(const char* a, const char* b) {
    return (std::strcmp(a, b) > 0) ? a : b;
}

// 重载版本
int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << "Max of 3 and 7: " << max(3, 7) << std::endl;
    std::cout << "Max of \"hello\" and \"world\": " << max("hello", "world") << std::endl;
    return 0;
}


// Out
Max of 3 and 7: 7
Max of "hello" and "world": world

类模板

类模板允许类处理任意类型的数据。

基本用法

#include <iostream>

template <typename T>
class Pair {
private:
    T first, second;
public:
    Pair(T a, T b) : first(a), second(b) {}
    T getFirst() const { return first; }
    T getSecond() const { return second; }
};

int main() {
    Pair<int> intPair(1, 2);
    Pair<double> doublePair(3.4, 7.8);

    std::cout << "First of intPair: " << intPair.getFirst() << std::endl;
    std::cout << "Second of doublePair: " << doublePair.getSecond() << std::endl;

    return 0;
}

模板特化（Specialization）与偏特化（Partial Specialization）

类模板可以进行全特化（Full Specialization）和偏特化（Partial Specialization -- 偏特化仅在类模板中支持）。

#include <iostream>

// 主模板
template <typename T>
class Storage {
private:
    T value;
public:
    Storage(T val) : value(val) {}
    void print() const { std::cout << "Value: " << value << std::endl; }
};

// 全特化版本
// 全特化是为模板的某个具体类型提供完全不同的实现。
template <>
class Storage<const char*> {
private:
    const char* value;
public:
    Storage(const char* val) : value(val) {}
    void print() const { std::cout << "Value: " << value << std::endl; }
};

// 偏特化版本
// 偏特化是指为模板的一部分参数提供特定的实现，而不是所有参数。偏特化仅适用于类模板，而不适用于函数模板。
template <typename T>
class Storage<T*> {
private:
    T* value;
public:
    Storage(T* val) : value(val) {}
    void print() const { std::cout << "Pointer Value: " << *value << std::endl; }
};

int main() {
    Storage<int> intStorage(5);
    Storage<const char*> stringStorage("Hello");
    int value = 10;
    Storage<int*> intPointerStorage(&value);

    intStorage.print();
    stringStorage.print();
    intPointerStorage.print();

    return 0;
}


// Out
Value: 5
Value: Hello
Pointer Value: 10

别名模板（Alias Templates）

别名模板用于创建复杂类型的简化别名。

基本用法

#include <iostream>
#include <vector>

// 定义一个别名模板
template <typename T>
using Vec = std::vector<T>;

int main() {
    Vec<int> intVec = {1, 2, 3, 4, 5};
    
    for (int i : intVec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

变量模板（Variable Templates）

变量模板允许定义模板变量。

基本用法

#include <iostream>

// 定义一个变量模板
template <typename T>
constexpr T pi = T(3.1415926535897932385);

int main() {
    std::cout << "pi<int>: " << pi<int> << std::endl;
    std::cout << "pi<float>: " << pi<float> << std::endl;
    std::cout << "pi<double>: " << pi<double> << std::endl;

    return 0;
}


// Out
pi<int>: 3
pi<float>: 3.14159
pi<double>: 3.14159

模板模板参数（Template Template Parameters）

模板模板参数允许模板参数本身是模板。

基本用法

#include <iostream>
#include <vector>

// 定义一个模板类
template <typename T, template <typename, typename> class Container>
class Stack {
private:
    Container<T, std::allocator<T>> elements;
public:
    void push(const T& elem) {
        elements.push_back(elem);
    }

    void pop() {
        if (elements.empty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        elements.pop_back();
    }

    T top() const {
        if (elements.empty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements.back();
    }
};

int main() {
    Stack<int, std::vector> intStack;
    intStack.push(7);
    intStack.push(42);
    
    std::cout << "Top of intStack: " << intStack.top() << std::endl;
    intStack.pop();
    std::cout << "Top of intStack after pop: " << intStack.top() << std::endl;

    return 0;
}


// Out
Top of intStack: 42
Top of intStack after pop: 7