C++基础知识【8】模板

最新推荐文章于 2023-05-20 23:08:59 发布

从此不归路

最新推荐文章于 2023-05-20 23:08:59 发布

阅读量598

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/baidu_18624493/article/details/130123367

版权

C++ 专栏收录该内容

14 篇文章 4 订阅

订阅专栏

一、什么是C++模板？

C++模板是C++编程中非常重要的一部分，它允许程序员以一种通用的方式编写代码，以便代码可以在不同类型之间进行重用。

那么，什么是C++模板？C++模板是一种允许程序员编写通用代码的机制。它们允许函数、类和数据类型适用于不同类型的参数，使得代码可以在不同类型之间进行重用。

二、函数模板

函数模板是一种允许程序员编写一个通用函数的机制。函数模板定义了一个函数，它可以适用于不同类型的参数。例如：

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

上面的代码定义了一个函数模板，它可以接受不同类型的参数。当函数被调用时，编译器会根据传递的参数类型推断出T的实际类型。

例如，以下代码将调用max函数，使用double类型的参数：

double result = max(3.14, 2.71);

可以使用函数模板来实现一个通用的排序算法，如快速排序

template<typename T>
void quicksort(T* array, int left, int right) {
    int i = left, j = right;
    T pivot = array[(left + right) / 2];

    while (i <= j) {
        while (array[i] < pivot) i++;
        while (array[j] > pivot) j--;
        if (i <= j) {
            std::swap(array[i], array[j]);
            i++;
            j--;
        }
    }

    if (left < j) quicksort(array, left, j);
    if (i < right) quicksort(array, i, right);
}

三、类模板

类模板是一种允许程序员编写通用类的机制。类模板定义了一个类，它可以适用于不同类型的参数。例如：

template <typename T>
class Stack {
private:
    vector<T> elements; 
public:
    void push(T const&); 
    void pop(); 
    T top() const; 
    bool empty() const { 
        return elements.empty();
    }
};

template <typename T>
void Stack<T>::push(T const& element) {
    elements.push_back(element);
}

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

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

上面的代码定义了一个类模板，它表示一个堆栈数据结构。当类模板被实例化时，编译器会根据传递的类型参数推断出T的实际类型。

例如，以下代码将创建一个堆栈，其中元素的类型为int：

Stack<int> myStack;

可以使用类模板来实现一个通用的容器类，如vector、list和map等。

template<typename T>
class MyContainer {
  public:
    MyContainer(int size);
    ~MyContainer();
    void add(T value);
    T get(int index);
  private:
    T* data;
    int size;
    int count;
};

template<typename T>
MyContainer<T>::MyContainer(int size) {
    this->data = new T[size];
    this->size = size;
    this->count = 0;
}

template<typename T>
MyContainer<T>::~MyContainer() {
    delete[] this->data;
}

template<typename T>
void MyContainer<T>::add(T value) {
    if (this->count >= this->size) {
        // expand container
    }
    this->data[this->count++] = value;
}

template<typename T>
T MyContainer<T>::get(int index) {
    if (index < 0 || index >= this->count) {
        // handle out of bounds error
    }
    return this->data[index];
}

四、模板特化

模板特化是一种允许程序员为特定类型的模板参数提供特定实现的机制。也可以说模板特化是一种针对特定类型参数的特定实现。

例如，以下代码为Stack<int>提供了一个特化实现：

template <>
class Stack<int> {
private:
    vector<int> elements;
public:
    void push(int const&); 
    void pop(); 
    int top() const; 
    bool empty() const {
        return elements.empty();
    }
};

void Stack<int>::push(int const& element) {
    elements.push_back(element);
}

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

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

上面的代码为Stack<int>提供了一个特化实现，其中元素的类型为int。注意，特化实现并不需要完全重写类模板，只需要提供需要特化的成员函数的实现即可。

使用模板特化来提供对某些类型的特定优化，以提高程序的性能。

五、模板参数

模板参数是程序员定义模板时可以传递的参数。它们可以是类型、整数值或指针类型。例如，以下代码定义了一个模板类，它有一个类型参数和一个整数参数：

template <typename T, int N>
class Array {
private:
    T elements[N];
public:
    T& operator[](int index) { 
        if (index < 0 || index >= N) {
            throw out_of_range("Array::operator[](): index out of range");
        }
        return elements[index];
    }
};

上面的代码定义了一个模板类，它表示一个固定大小的数组。当类模板被实例化时，编译器会根据传递的参数推断出T的实际类型和N的实际值。例如，以下代码将创建一个大小为10的int数组：

Array<int, 10> myArray;

六、可变模板参数

可变模板参数允许模板接受任意数量的参数。例如，可以使用可变模板参数来实现一个通用的printf函数。

#include <iostream>
#include <sstream>

template<typename... Args>
std::string format(const std::string& formatString, Args... args) {
    std::ostringstream oss;
    int argIndex = 0;
    size_t pos = 0;
    while (pos < formatString.size()) {
        size_t nextPos = formatString.find_first_of("%", pos);
        if (nextPos == std::string::npos) {
            oss << formatString.substr(pos);
            break;
        }
        oss << formatString.substr(pos, nextPos - pos);
        if (nextPos == formatString.size() - 1) {
            // handle error: incomplete format specifier
        }
        char formatChar = formatString[nextPos + 1];
        if (formatChar == '%') {
            oss << "%";
        } else {
            if (argIndex >= sizeof...(args)) {
                // handle error: too few arguments
            }
            if (formatChar == 'd') {
                oss << std::to_string(std::get<argIndex>(std::make_tuple(args...)));
            } else if (formatChar == 's){
                oss << std::get<argIndex>(std::make_tuple(args...));
        } else {
            // handle error: invalid format specifier
        }
        argIndex++;
    }
    pos = nextPos + 2;
    }
    if (argIndex < sizeof...(args)) {
    // handle error: too many arguments
}
    return oss.str();
}

int main() {
    std::cout << format("%d + %d = %d, %s\n", 2, 3, 5, "hello world");
    return 0;
}

上述代码中，format函数的参数列表使用了可变模板参数Args，它表示任意数量的参数。在函数体内，我们使用std::make_tuple(args...)将所有参数打包成一个std::tuple对象，然后使用std::get<argIndex>来获取其中的某个参数，argIndex表示当前获取的参数在参数列表中的索引。在函数体内，我们还使用了std::ostringstream来将所有参数转换为字符串，并使用了一些C++11特性，例如auto、decltype和std::initializer_list。

七、模板元编程

模板元编程是一种利用C++模板机制实现编译时计算的技术。它允许程序员在编译时生成代码，以便在运行时获得更好的性能。例如，以下代码使用模板元编程实现斐波那契数列的计算：

template <int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

template <>
struct Fibonacci<0> {
    static const int value = 0;
};

template <>
struct Fibonacci<1> {
    static const int value = 1;
};

上面的代码定义了一个模板类，它表示斐波那契数列中的第N个数字。当类模板被实例化时，编译器会递归地计算Fibonacci<N-1>::value和Fibonacci<N-2>::value，直到计算到Fibonacci<0>或Fibonacci<1>为止。这种技术可以在编译时生成高效的代码，以便在运行时获得更好的性能。

八、嵌套模板

嵌套模板是指在一个模板类或函数中使用另一个模板类或函数作为其成员。例如，可以使用嵌套模板来实现一个通用的二叉树数据结构，其中每个节点都存储一个键和一个值。

template<typename K, typename V>
class BinaryTree {
  private:
    struct Node {
        K key;
        V value;
        Node* left;
        Node* right;
        Node(K key, V value) : key(key), value(value), left(nullptr), right(nullptr) {}
    };
    Node* root;
  public:
    BinaryTree() : root(nullptr) {}
    void insert(K key, V value);
    V find(K key);
};

template<typename K, typename V>
void BinaryTree<K, V>::insert(K key, V value) {
    Node** node = &root;
    while (*node != nullptr) {
        if (key < (*node)->key) {
            node = &((*node)->left);
        } else if (key > (*node)->key) {
            node = &((*node)->right);
        } else {
            // handle duplicate key error
        }
    }
    *node = new Node(key, value);
}

template<typename K, typename V>
V BinaryTree<K, V>::find(K key) {
    Node* node = root;
    while (node != nullptr) {
        if (key < node->key) {
            node = node->left;
        } else if (key > node->key) {
            node = node->right;
        } else {
            return node->value;
        }
    }
    // handle key not found error
}

九、注意事项

使用C++模板时需要注意以下几点：

代码可读性：使用模板可以提高代码的通用性，但是也可能导致代码的可读性下降。如果不小心过度使用模板，代码可能会变得难以阅读和理解。因此，应该在使用模板时保持适度，只在必要的情况下使用它们。
代码复杂性：模板代码可能会变得非常复杂，因为它们需要支持多种不同的类型和值。这可能会导致编译时间和二进制文件大小的增加。为了避免这种情况，应该尽可能简化模板代码，并且在需要使用模板的地方进行分离编译。
模板特化和重载：当为特定类型的参数提供特定的实现时，需要注意模板特化和重载的使用。如果模板特化和重载不正确使用，可能会导致编译错误或运行时错误。
模板参数的类型限制：模板参数的类型限制可以确保模板只能用于特定类型的参数。这可以帮助避免在使用模板时出现类型错误。如果没有类型限制，可能会导致编译错误或运行时错误。
编译错误：在使用模板时，可能会遇到许多编译错误。这些错误可能很难调试，因为它们通常发生在编译期间。这就是有些公司禁止程序员使用模板的原因。为了避免这种情况，应该仔细检查所有的错误消息，并尝试使用一些工具来调试代码。

总之，在使用C++模板时，需要权衡代码的通用性和可读性，以及代码的复杂性和性能。同时，需要遵循模板参数类型限制和模板特化和重载的规则，以避免在使用模板时出现错误。

从此不归路

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++基础知识【8】模板

C++模板是一种允许程序员编写通用代码的机制。它们允许函数、类和数据类型适用于不同类型的参数，使得代码可以在不同类型之间进行重用。C++模板是C++编程中非常重要的一部分，它允许程序员以一种通用的方式编写代码，以便代码可以在不同类型之间进行重用。
复制链接

扫一扫