C++ template 模版相关知识

最新推荐文章于 2025-05-19 22:49:24 发布

伏城无嗔

最新推荐文章于 2025-05-19 22:49:24 发布

阅读量908

点赞数 30

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_45281807/article/details/139722809

C++ 专栏收录该内容

21 篇文章

订阅专栏

注意：本文章整理于GPT。

1、元编程（meta programming) 、template详细讲解。模板实例化的优先级、模板是在什么时候进行实例化、谈谈模板和override的关系

元编程（Meta Programming）

元编程是一种编程技术，指编写代码来生成或操控其他代码。元编程主要在编译期或运行期进行。C++的模板是一种编译期元编程的实现方式，通过模板可以在编译时生成代码，从而实现类型安全的泛型编程。

编译期元编程的特点

类型安全：模板元编程允许在编译时进行类型检查。
性能优化：由于代码在编译时生成，减少了运行时开销。
代码复用：通过模板，可以编写通用代码，避免重复编写相同逻辑。

模板（Templates）详细讲解

C++模板是一种强大的泛型编程工具，允许编写独立于具体类型的代码。模板包括函数模板和类模板。

函数模板

函数模板允许创建可以处理不同数据类型的通用函数。

示例：

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

这个模板定义了一个函数，可以接受任意类型的参数，只要该类型支持>操作符。

类模板

类模板允许创建可以处理不同数据类型的通用类。

示例：

template <typename T>
class MyClass {
public:
    MyClass(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};

这个模板定义了一个类，可以接受任意类型的参数。

模板实例化的优先级

模板实例化的优先级指编译器在选择模板实例化时的规则。主要有以下几种情况：

完全特化：优先级最高，为特定类型提供了特定实现。
部分特化：优先级次之，为某些类型提供了特定实现。
普通模板：优先级最低，通用实现。

示例

template <typename T>
void func(T) {
    std::cout << "Primary template\n";
}

template <>
void func<int>(int) {
    std::cout << "Fully specialized template for int\n";
}

template <typename T>
void func<T*>(T*) {
    std::cout << "Partial specialization for pointers\n";
}

调用func(42)会使用完全特化版本，调用func(&x)会使用部分特化版本，调用func('a')会使用普通模板。

模板实例化的时机

模板实例化发生在编译时，当编译器遇到使用模板定义创建具体类型的实例时：

隐式实例化：在编译过程中，当模板被使用时，编译器会自动实例化模板。
显式实例化：可以通过显式实例化指令告知编译器立即实例化模板。

示例

template <typename T>
T square(T x) {
    return x * x;
}

int main() {
    int a = square(5);   // 隐式实例化 square<int>
    double b = square(2.5); // 隐式实例化 square<double>
    return 0;
}

显式实例化：

template int square<int>(int);
template double square<double>(double);

模板和override的关系

override关键字用于虚函数，确保派生类的函数覆盖基类的虚函数。模板和override关键字之间没有直接关系，但可以结合使用模板和虚函数来实现多态性。

示例

#include <iostream>

class Base {
public:
    virtual void foo() {
        std::cout << "Base foo\n";
    }
};

template <typename T>
class Derived : public Base {
public:
    void foo() override {
        std::cout << "Derived foo\n";
    }
};

int main() {
    Base* b = new Derived<int>();
    b->foo();  // 输出: Derived foo
    delete b;
    return 0;
}

在这个示例中，Derived是一个模板类，它继承了Base类，并且重写了foo函数。override关键字确保了Derived类中的foo函数确实覆盖了Base类中的虚函数foo。

总结

元编程：通过模板实现编译期代码生成和类型检查，提高代码复用性和性能。
模板详细讲解：包括函数模板和类模板，提供了编写通用代码的方法。
模板实例化的优先级：完全特化、部分特化和普通模板的优先级顺序。
模板实例化的时机：在编译时发生，包括隐式和显式实例化。
模板和override的关系：尽管没有直接关系，但可以结合使用模板和虚函数来实现多态性，override确保派生类正确覆盖基类虚函数。

2、函数模版，类模版，模版底层怎么实现的，模板类如何实现、用法、使用场景

函数模板

定义和用法

函数模板允许编写独立于具体类型的函数，这些函数可以处理不同的数据类型。

定义示例：

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

这个模板定义了一个max函数，可以接受任意类型的参数，只要该类型支持>操作符。

用法示例：

int main() {
    int a = max(3, 5);          // 使用max<int>
    double b = max(2.5, 4.5);   // 使用max<double>
    std::string c = max(std::string("apple"), std::string("banana")); // 使用max<std::string>
    return 0;
}

底层实现

在使用函数模板时，编译器在编译时生成具体类型的函数实现。这一过程称为模板实例化。

实例化过程：当编译器遇到max(3, 5)时，它会生成一个max<int>的函数实现，类似于：
```
int max(int a, int b) {
    return (a > b) ? a : b;
}
```
代码重用：模板函数的代码逻辑在不同类型实例化时被重复使用。

类模板

定义和用法

类模板允许创建通用类，这些类可以处理不同的数据类型。

定义示例：

template <typename T>
class MyClass {
public:
    MyClass(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};

用法示例：

int main() {
    MyClass<int> obj1(10);          // 使用MyClass<int>
    MyClass<double> obj2(5.5);      // 使用MyClass<double>
    MyClass<std::string> obj3("Hello"); // 使用MyClass<std::string>
    return 0;
}

底层实现

与函数模板类似，类模板在编译时实例化，生成特定类型的类。

实例化过程：当编译器遇到MyClass<int> obj1(10);时，它会生成一个MyClass<int>的类实现，类似于：

class MyClass<int> {
public:
    MyClass(int value) : value_(value) {}
    int getValue() const { return value_; }
private:
    int value_;
};

模板的底层实现机制

模板的底层实现依赖于编译器的模板实例化机制，主要包括以下几个步骤：

模板定义：提供生成代码的蓝图，但不立即生成代码。
模板实例化：在编译时根据模板参数生成具体的代码实现。
代码生成：编译器在实例化时生成具体类型的函数或类，实现代码重用。

模板类的实现、用法和使用场景

模板类的实现

模板类的实现通常包括类模板定义和在需要时进行实例化。

定义示例：

template <typename T>
class Stack {
private:
    std::vector<T> elements; // 元素容器
public:
    void push(T const& elem) {
        elements.push_back(elem);
    }
    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }
    T top() const {
        if (!elements.empty()) {
            return elements.back();
        }
        throw std::out_of_range("Stack<>::top(): empty stack");
    }
};

用法示例：

int main() {
    Stack<int> intStack;       // 使用Stack<int>
    intStack.push(7);
    std::cout << intStack.top() << std::endl; // 输出: 7

    Stack<std::string> stringStack; // 使用Stack<std::string>
    stringStack.push("hello");
    std::cout << stringStack.top() << std::endl; // 输出: hello

    return 0;
}