C++易忘知识点

1. 请讲解一下c++中的模板？

C++中的模板（Templates）是一种用于生成通用代码的编程机制，允许在编写代码时定义通用的数据类型和算法，以适应多种不同类型的数据。模板可以在编译时根据具体的数据类型生成相应的代码，从而实现代码的重用和泛化。

模板在C++中有两种主要形式：函数模板和类模板。

1. 函数模板（Function Templates）： 函数模板允许你编写一个通用的函数，该函数可以在不同的数据类型下工作。函数模板的声明类似于普通函数的声明，但参数类型使用模板参数表示。

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

在调用函数模板时，编译器会根据传递的实际参数类型实例化出一个具体的函数。

int result1 = add(5, 10);         // 实例化为 add<int>(5, 10)
double result2 = add(3.14, 2.71); // 实例化为 add<double>(3.14, 2.71)

2. 类模板（Class Templates）： 类模板允许你定义一个通用的类，可以用于多种数据类型。类模板的定义和使用类似于普通类，但其中的数据类型使用模板参数表示。

template <typename T>
class Stack {
private:
    T data[100];
    int top;

public:
    Stack() : top(-1) {}
    void push(T value) { data[++top] = value; }
    T pop() { return data[top--]; }
};

在使用类模板时，需要提供实际的数据类型作为模板参数。

Stack<int> intStack;
Stack<double> doubleStack;

模板的好处在于可以根据不同的数据类型，自动生成适用的代码，避免了代码的重复编写。模板在STL（标准模板库）中得到广泛应用，包括容器类（如向量、队列）、算法（如排序、查找）等。

需要注意的是，模板的使用需要特别小心，因为错误的使用可能会导致编译器错误或生成不正确的代码。模板还可以使用非类型模板参数、模板特化、模板继承等高级特性，以更灵活和强大的方式实现通用编程。

2. 模板类是什么？

模板类是一种 C++ 编程特性，它允许你编写通用的代码，适用于不同的数据类型。模板类在实现数据结构和算法时非常有用，因为它们可以根据不同的数据类型生成相应的代码，而无需为每种数据类型编写重复的代码。

模板类通过使用模板参数来达到通用性。这些参数可以是数据类型、常数、函数等，使得类或函数可以在编译时根据这些参数生成特定的代码。

在C++中，有两种主要类型的模板：类模板和函数模板。模板类指的是类模板，而模板函数指的是函数模板。

模板类的语法示例：

template <typename T>
class MyTemplateClass {
public:
    MyTemplateClass(T value) : data(value) {}

    T getData() const {
        return data;
    }

private:
    T data;
};

在上面的示例中，MyTemplateClass 是一个模板类，使用了模板参数 T，它表示数据类型。通过将 T 用作数据类型，这个类可以适用于不同类型的数据。

通过实例化模板类，可以为不同的数据类型创建具体的类：

MyTemplateClass<int> intInstance(42);
MyTemplateClass<double> doubleInstance(3.14);

在上面的示例中，intInstance 和 doubleInstance 分别是 MyTemplateClass 的实例，分别使用了 int 和 double 数据类型。

总而言之，模板类是一种用于创建通用代码的强大工具，可以在不同的数据类型上重用代码，从而提高代码的灵活性和可重用性。

3. explicit

在 C++ 中，explicit 是一个关键字，用于修饰类的单参数构造函数，以防止隐式类型转换。它的主要作用是禁止在隐式转换上下文中使用该构造函数，从而避免意外的类型转换。

具体来说，当一个类的构造函数被声明为 explicit 时，它不会被用于隐式类型转换，只能通过显式地调用构造函数来创建对象。这有助于避免一些意外的类型转换，提高代码的可读性和安全性。

下面是一个使用 explicit 关键字的示例：

class MyInt {
public:
    explicit MyInt(int value) : val(value) {}

    int getValue() const {
        return val;
    }

private:
    int val;
};

void printInt(const MyInt& num) {
    std::cout << num.getValue() << std::endl;
}

int main() {
    MyInt a = 5;  // 这里会出错，因为构造函数是 explicit
    MyInt b(10);  // 正确，显式调用构造函数

    printInt(b);  // 正确，通过函数参数隐式转换为 MyInt
    // printInt(15);  // 错误，不能隐式转换为 MyInt，因为构造函数是 explicit

    return 0;
}

在上面的示例中，MyInt 类有一个带有 explicit 关键字的构造函数。这意味着不能将整数隐式转换为 MyInt 对象，而是需要显式地调用构造函数。然而，当调用函数时，可以隐式地将整数转换为 MyInt 对象作为函数参数。

使用 explicit 可以帮助避免一些隐式类型转换引发的问题，特别是在函数重载、类型转换和构造函数之间的交互中。

4. C++11 的特性 function

C++11 引入了一个名为 std::function 的模板类，它允许我们以一种更灵活的方式存储和传递函数、函数对象（可调用对象）或者函数指针。std::function 可以用来保存各种不同类型的可调用对象，使得在编写更加通用和灵活的代码时变得更容易。

以下是一个简单的示例，演示如何使用 std::function：

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}

int main() {
    // 使用 std::function 来保存一个函数
    std::function<int(int, int)> func = add;

    // 调用保存的函数
    int result = func(3, 4);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

在上面的示例中，std::function<int(int, int)> 声明了一个可以存储接受两个 int 参数并返回 int 类型结果的可调用对象。我们使用 add 函数来初始化 std::function，然后通过调用 func(3, 4) 来执行函数并获得结果。

需要注意的是，std::function 可以存储函数、函数指针、以及重载了 () 运算符的函数对象。这使得在 C++ 中可以更灵活地传递函数和函数对象，并支持回调机制等编程技巧。

总之，std::function 是 C++11 引入的一个功能强大的特性，允许我们以一种通用的方式存储和传递可调用对象，从而使代码更具灵活性和可读性。