C++基础夯实

std::copy
std::search
std::back_inserter
std::equal
memcpy

演示如何使用

std::copy、

std::search、

std::back_inserter 

std::equal 这四个方法。

我们假设有两个向量，一个源向量 source，一个目标向量 destination。我们将首先使用 std::copy 方法将源向量中的元素复制到目标向量中，然后使用 std::search 方法在目标向量中搜索一个子序列，最后使用 std::back_insert 方法向目标向量中插入一些元素，再使用 std::equal 方法比较两个向量是否相等。

下面是完整的示例代码：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 定义源向量
    std::vector<int> source = {1, 2, 3, 4, 5};
    // 定义目标向量
    std::vector<int> destination;

    // 使用 std::copy 方法将源向量中的元素复制到目标向量中
    std::copy(source.begin(), source.end(), std::back_inserter(destination));

    // 使用 std::search 方法在目标向量中搜索子序列 {3, 4, 5}
    std::vector<int> subsequence = {3, 4, 5};
    auto it = std::search(destination.begin(), destination.end(), subsequence.begin(), subsequence.end());

    if (it != destination.end()) {
        std::cout << "Subsequence found at index: " << std::distance(destination.begin(), it) << std::endl;
    } else {
        std::cout << "Subsequence not found" << std::endl;
    }

    // 使用 std::back_insert 方法向目标向量中插入一些元素
    std::back_insert_iterator<std::vector<int>> backInserter(destination);
    *backInserter = 6;
    *backInserter = 7;

    // 使用 std::equal 方法比较两个向量是否相等
    if (std::equal(source.begin(), source.end(), destination.begin())) {
        std::cout << "Source and destination vectors are equal" << std::endl;
    } else {
        std::cout << "Source and destination vectors are not equal" << std::endl;
    }

    return 0;
}

std::back_inserter 是 C++ 标准库中的一个函数模板，用于创建一个 std::back_insert_iterator 对象，从而方便地向容器的末尾插入元素。它通常用于简化代码，使得在使用算法时能够直接将元素插入到容器的末尾，而无需手动创建 std::back_insert_iterator 对象。

下面是一个示例，演示了如何使用 std::back_inserter 向 std::vector 中插入元素：

#include <iostream>
#include <vector>
#include <iterator> // 包含 back_inserter

int main() {
    // 定义一个目标向量
    std::vector<int> vec;

    // 使用 std::back_inserter 创建 back_insert_iterator
    auto backInserter = std::back_inserter(vec);

    // 使用 * 操作符向 back_insert_iterator 插入元素
    *backInserter = 1;
    *backInserter = 2;
    *backInserter = 3;

    // 使用算法 std::copy 将另一个向量的元素插入到目标向量的末尾
    std::vector<int> anotherVec = {4, 5, 6};
    std::copy(anotherVec.begin(), anotherVec.end(), backInserter);

    // 输出目标向量的元素
    std::cout << "Target vector elements:";
    for (const auto& elem : vec) {
        std::cout << " " << elem;
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，我们使用 std::back_inserter 创建了一个插入器 backInserter，并将其用于向 std::vector 容器 vec 中插入元素。接着，我们使用 * 操作符将元素插入到 backInserter，它会自动将元素插入到 vec 的末尾。然后，我们使用 std::copy 算法将另一个向量 anotherVec 的元素插入到目标向量 vec 的末尾。最后，我们遍历目标向量，并输出其元素。

这样，使用 std::back_inserter 能够简化向容器插入元素的过程，特别是在使用算法时非常方便。

memcpy 是 C 语言和 C++ 语言中的一个标准库函数，用于在内存块之间进行字节级别的复制。它通常用于将数据从一个内存地址复制到另一个内存地址，其原型定义在 <cstring> 头文件中：

void* memcpy(void* destination, const void* source, size_t num);

其中，destination 是目标内存地址的指针，source 是源内存地址的指针，num 表示要复制的字节数。

以下是 memcpy 函数的一些关键特点和使用方法：

1. 字节级别复制： memcpy 以字节为单位进行复制，它不关心内存块中存储的具体类型，只是简单地从源地址复制字节到目标地址。因此，它是一种非常底层的复制操作。

2. 内存重叠问题： 如果源内存区域和目标内存区域有重叠部分，memcpy 的行为是未定义的，可能会导致意想不到的结果。为避免这种情况，可以使用 memmove 函数，它可以处理内存重叠的情况。

3. 效率： memcpy 函数通常由平台提供高效的实现，因此在性能上表现很好。它可能会利用 CPU 的特定指令集或者其他优化来实现高效的复制操作。

4. 没有空指针检查： memcpy 函数不会检查指针是否为空，因此在使用时需要确保传入的指针是有效的，否则可能会导致程序崩溃或者未定义行为。

以下是一个简单的示例，演示了如何使用 memcpy 函数进行内存复制：

#include <iostream>
#include <cstring> // 包含 memcpy 函数的头文件

int main() {
    const char* source = "Hello, world!"; // 源字符串
    char destination[20]; // 目标内存区域，足够大以容纳源字符串

    // 使用 memcpy 将源字符串复制到目标内存区域
    std::memcpy(destination, source, std::strlen(source) + 1);

    // 输出目标字符串
    std::cout << "Copied string: " << destination << std::endl;

    return 0;
}

在这个示例中，我们将源字符串 "Hello, world!" 复制到了目标内存区域 destination 中，然后输出了目标字符串。需要注意的是，我们在调用 memcpy 函数时，通过 std::strlen(source) + 1 计算了源字符串的长度，并将其作为要复制的字节数传递给了 memcpy 函数。

std::copy(queuebuffer.begin(), queuebuffer.end(), std::back_inserter(window)); 这行代码的作用是将 queuebuffer 容器中的所有元素复制到 window 容器的末尾。

下面是一个示例代码，演示了如何使用这行代码：

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>

int main() {
    std::vector<int> queuebuffer = {1, 2, 3, 4, 5}; // 源容器
    std::vector<int> window; // 目标容器

    // 使用 std::copy 和 std::back_inserter 将 queuebuffer 中的元素复制到 window 的末尾
    std::copy(queuebuffer.begin(), queuebuffer.end(), std::back_inserter(window));

    // 输出目标容器 window 中的元素
    std::cout << "Copied elements:";
    for (const auto& elem : window) {
        std::cout << " " << elem;
    }
    //Copied elements: 1 2 3 4 5
    std::cout << std::endl;
   
    return 0;
}

在这个示例中，我们创建了一个 queuebuffer 容器，并初始化了一些元素。然后，使用 std::copy 算法和 std::back_inserter 辅助函数将 queuebuffer 中的元素复制到 window 容器的末尾，最后输出了 window 容器中的元素。