突破编程_C++_STL教程（ copy 算法）_std::copy

1 std::copy 算法的概念与用途

std::copy 是 C++ 标准库中的一种算法，主要用于将一个范围内的元素从一个位置复制到另一个位置。其函数原型如下：

template<class InputIterator, class OutputIterator>  
OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
1
2

这里的 first 和 last 参数定义了源范围的开始和结束，而 result 参数定义了目标范围的开始。换句话说，std::copy 会将从 first 到 last（不包含 last）范围内的所有元素复制到从 result 开始的目标位置。

这个算法特别适用于各种容器（如 vector、list、array 等）及其迭代器，以及其他支持随机访问迭代器的数据结构。此外，它也可以用于拷贝基本类型数组或指针范围内的元素。但是，当需要处理复杂的自定义数据类型时，建议使用拷贝构造函数或赋值操作符进行元素的拷贝。

需要注意的是，std::copy 只负责复制操作，不负责为目标容器申请空间。因此，在调用 std::copy 之前，必须确保目标容器有足够的空间来容纳源容器中的元素。如果目标范围与源范围有重叠，使用 std::copy 可能会导致未定义的行为。在这种情况下，应使用 std::copy_backward 或其他更安全的复制方法。

std::copy 的用途广泛，尤其在处理大量数据时，其效率要优于使用 for 循环逐个复制。通过使用 std::copy，可以更加简洁、高效地实现容器间的数据拷贝操作。

此外，std::copy 与 memcpy 相比，具有更大的灵活性。memcpy 只适用于指针，并且不允许缓冲区中的任何重叠。而 std::copy 可以在任何迭代器上工作，包括 std::map、std::vector、std::deque 等，并支持在一个方向上重叠的复制操作。因此，在需要复制大块数据或在不同类型的容器间进行复制时，std::copy 通常是一个更好的选择。

2 std::copy 算法基础

2.1 std::copy 算法的定义与语法

（1）定义：

std::copy 是 C++ 标准库 <algorithm> 头文件中定义的一个通用算法，它用于将一个范围内的元素从一个位置复制到另一个位置。这个算法非常通用，可以用于任何支持输入和输出迭代器的序列。

（2）语法：

std::copy 函数的语法如下：

template<class InputIt, class OutputIt>  
OutputIt copy(InputIt first, InputIt last, OutputIt d_first);
1
2

std::copy 的语法使用三个迭代器参数：

• first：指向要复制序列的起始位置的输入迭代器。
• last：指向要复制序列结束位置之后一个位置的输入迭代器（即“尾后”迭代器）。
• d_first：指向目标序列起始位置的输出迭代器，用于存储复制的元素。

（3）返回值：

std::copy 返回一个输出迭代器，它指向最后一个被复制元素之后的位置。

2.2 std::copy 算法的基本使用示例

以下是两个基本的例子，它展示了如何将一个 std::vector 中的元素复制到另一个 std::vector，以及复制到一个原始数组。

示例 1：将 vector 中的元素复制到另一个 vector

#include <iostream>  
#include <vector>  
#include <algorithm>  
  
int main() 
{  
    // 创建一个包含一些整数的 vector  
    std::vector<int> source = {1, 2, 3, 4, 5};  
      
    // 创建一个空的目标 vector，它将在复制过程中自动调整大小  
    std::vector<int> destination;  
      
    // 预先为目标 vector 分配足够的空间（可选）  
    destination.resize(source.size());  
      
    // 使用 std::copy 将源 vector 中的元素复制到目标 vector  
    std::copy(source.begin(), source.end(), destination.begin());  
      
    // 输出目标 vector 的内容以验证复制是否成功  
    for (const auto& elem : destination) {  
        std::cout << elem << ' ';  
    }  
    std::cout << std::endl;  
      
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

上面代码的输出为：

1 2 3 4 5
1

这个例子创建了一个包含整数的 source 向量，并初始化了一个空的 destination 向量。然后，使用 std::copy 将 source 向量中的所有元素复制到 destination 向量中。因为 std::vector 是一个动态数组，所以在复制时它会自动调整大小以容纳新的元素。

示例 2：将 vector 中的元素复制到原始数组

#include <iostream>  
#include <vector>  
#include <algorithm>  
  
int main() 
{  
    // 创建一个包含一些整数的 vector  
    std::vector<int> source = {1, 2, 3, 4, 5};  
      
    // 创建一个足够大的原始数组来存储复制的元素  
    int destination[5];  
      
    // 使用 std::copy 将源 vector 中的元素复制到原始数组  
    std::copy(source.begin(), source.end(), destination);  
      
    // 输出数组的内容以验证复制是否成功  
    for (int i = 0; i < 5; ++i) {  
        std::cout << destination[i] << ' ';  
    }  
    std::cout << std::endl;  
      
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

上面代码的输出为：

1 2 3 4 5
1

这个例子创建了一个原始数组 destination，并手动指定了它的大小。然后，使用 std::copy 将 source 向量中的所有元素复制到 destination 数组中。需要注意的是，必须确保数组的大小至少与要复制的元素数量一样大，否则可能会发生数组越界错误。

这两个示例展示了 std::copy 的基本用法，它支持在不同的容器和数组之间复制元素。在实际应用中，std::copy 可以与各种迭代器一起使用，包括指向自定义数据结构元素的迭代器，从而提供了极大的灵活性。

3 std::copy 算法的高级用法

3.1 拷贝自定义类型的对象

std::copy 算法不仅可以用于拷贝基本数据类型的元素，如整数、浮点数等，还可以用于拷贝自定义类型的对象。当需要拷贝自定义类型的对象时，std::copy 会使用对象的拷贝构造函数或赋值操作符来完成拷贝操作。

自定义类型对象的拷贝

假设有一个自定义的类 MyClass，并且有一个包含 MyClass 对象的 std::vector。现在需要将这个 vector 中的所有对象拷贝到另一个 vector 中。则可以使用 std::copy 来完成这个任务。

首先，确保 MyClass 定义了合适的拷贝构造函数和赋值操作符。如果没有显式地定义它们，编译器会为生成默认的版本。但是，在大多数情况下，一般都需要自定义这些函数来满足特定的需求。

下面是一个简单的示例：

#include <iostream>  
#include <vector>  
#include <algorithm>  
  
// 自定义类型 MyClass  
class MyClass {  
public:  
	MyClass() {}
	
    MyClass(int value) : value_(value) {  
        std::cout << "Constructing MyClass with value " << value_ << std::endl;  
    }  
      
    // 拷贝构造函数  
    MyClass(const MyClass& other) : value_(other.value_) {  
        std::cout << "Copying MyClass with value " << value_ << std::endl;  
    }  
      
    // 赋值操作符  
    MyClass& operator=(const MyClass& other) {  
        if (this != &other) {  
            value_ = other.value_;  
            std::cout << "Assigning MyClass with value " << value_ << std::endl;  
        }  
        return *this;  
    }  
      
    void printValue() const {  
        std::cout << "Value: " << value_ << std::endl;  
    }  
      
private:  
    int value_;  
};  
  
int main() 
{  
    // 创建一个包含 MyClass 对象的 vector  
    std::vector<MyClass> source = {MyClass(1), MyClass(2), MyClass(3)};  
      
    // 创建一个空的目标 vector  
    std::vector<MyClass> destination;  
      
    // 预先为目标 vector 分配足够的空间（可选）  
    destination.resize(source.size());  
      
    // 使用 std::copy 拷贝 MyClass 对象  
    std::copy(source.begin(), source.end(), destination.begin());  
      
    // 输出目标 vector 中的对象以验证拷贝是否成功  
    for (const auto& obj : destination) {  
        obj.printValue();  
    }  
      
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

上面代码的输出为：

Constructing MyClass with value 1
Constructing MyClass with value 2
Constructing MyClass with value 3
Copying MyClass with value 1
Copying MyClass with value 2
Copying MyClass with value 3
Assigning MyClass with value 1
Assigning MyClass with value 2
Assigning MyClass with value 3
Value: 1
Value: 2
Value: 3
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，MyClass 定义了一个整数成员变量 value_，以及一个接受整数值的构造函数、一个拷贝构造函数和一个赋值操作符。这些函数在拷贝对象时会被调用。

在 main 函数中，创建了一个包含 MyClass 对象的 source 向量，并初始化了一些对象。然后，创建了一个空的 destination 向量，并使用 std::copy 将 source 向量中的所有对象拷贝到 destination 向量中。

当 std::copy 被调用时，它会遍历 source 向量中的每个对象，并使用对象的拷贝构造函数或赋值操作符将它们逐个拷贝到 destination 向量中。在这个例子中，会看到拷贝构造函数被调用了三次，因为需要创建三个新的 MyClass 对象来填充 destination 向量。

注意事项

• 确保的自定义类型定义了合适的拷贝构造函数和赋值操作符。如果没有定义它们，编译器生成的默认版本可能不适合的需求。
• 当使用 std::copy 拷贝自定义类型的对象时，要特别注意对象的生命周期和内存管理。确保源对象在拷贝过程中保持有效，并且目标容器有足够的空间来存储新对象。
• 如果的自定义类型涉及到动态内存分配（例如，它包含指向动态分配内存的指针），那么需要确保拷贝构造函数和赋值操作符正确地管理这些内存。这通常涉及到深拷贝（deep copy）的概念，即不仅要拷贝对象的指针，还要拷贝指针所指向的内存内容。

3.2 使用 std::copy_if 拷贝带有特定条件的元素

std::copy 算法本身并不直接支持拷贝带有特定条件的元素。std::copy 的作用是简单地复制源范围中的所有元素到目标范围，不进行任何条件判断。如果想要拷贝满足特定条件的元素，需要结合其他算法或手动编写循环逻辑来实现。

一个常见的方法是使用 std::copy_if 算法，它允许指定一个谓词（predicate），即一个返回布尔值的函数或函数对象，用于判断哪些元素应该被拷贝。std::copy_if 会遍历源范围，只拷贝那些使谓词返回 true 的元素到目标范围。

下面是使用 std::copy_if 拷贝带有特定条件元素的示例：

#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <iterator>  
  
int main() {  
    // 创建一个包含整数的 vector  
    std::vector<int> source = {1, 2, 3, 4, 5, 6, 7, 8, 9};  
      
    // 创建一个空的目标 vector  
    std::vector<int> destination;  
      
    // 定义一个谓词，判断元素是否为偶数  
    auto is_even = [](int n) { return n % 2 == 0; };  
      
    // 使用 std::copy_if 拷贝偶数到目标 vector  
    std::copy_if(source.begin(), source.end(), std::back_inserter(destination), is_even);  
      
    // 输出目标 vector 的内容以验证拷贝是否成功  
    for (const auto& elem : destination) {  
        std::cout << elem << ' ';  
    }  
    std::cout << std::endl;  
      
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

上面代码的输出为：

2 4 6 8
1

这个例子定义了一个 lambda 表达式 is_even 作为谓词，用于判断一个整数是否为偶数。然后，使用 std::copy_if 算法将 source 向量中所有的偶数拷贝到 destination 向量中。std::back_inserter 是一个迭代器适配器，它会在每次插入时自动调用 push_back 来扩展目标向量的大小。

3.3 std::copy_n 的用法和限制

std::copy_n 是 C++ 标准库中的一个算法，用于从源容器中复制指定数量的元素到目标容器中。它的主要特点是允许精确地指定要复制的元素数量，并且它支持源和目标容器之间的重叠。下面将详细讲解 std::copy_n 的用法和限制。

用法

std::copy_n 的基本语法如下：

std::copy_n(InputIt first, SizeCount count, OutputIt result);
1

其中：

• first 是一个输入迭代器，指向源容器中开始复制元素的起始位置。
• count 是要复制的元素数量。
• result 是一个输出迭代器，指向目标容器中开始写入复制元素的起始位置。

这个函数会从 first 指向的位置开始，复制 count 个元素到 result 指向的位置。如果 count 大于源容器中从 first 开始到末尾的元素数量，那么 std::copy_n 只会复制源容器中剩余的元素。

示例

下面是一个使用 std::copy_n 的简单示例：

#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <iterator>  
  
int main() 
{  
    std::vector<int> source = {1, 2, 3, 4, 5};  
    std::vector<int> destination(10); // 目标容器有足够空间  
  
    // 从 source 的开始位置复制 3 个元素到 destination 的开始位置  
    std::copy_n(source.begin(), 3, destination.begin());  
  
    // 输出 destination 的内容  
    for (const auto& elem : destination) {  
        std::cout << elem << ' ';  
    }  
    std::cout << std::endl;  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

上面代码的输出为：

1 2 3 0 0 0 0 0 0 0
1

在这个例子中，std::copy_n 将从 source 容器的开始位置复制前三个元素（即 1、2、3）到 destination 容器的开始位置。destination 容器的剩余位置将保持未初始化状态。

限制

std::copy_n 的主要限制如下：

• 源和目标容器的有效性：在复制过程中，源容器和目标容器都必须保持有效。如果源迭代器 first 或目标迭代器 result 在复制过程中变得无效（例如，通过删除元素或改变容器的大小），那么 std::copy_n 的行为将是未定义的。
• 目标容器的空间：目标容器必须有足够的空间来存储从源容器复制过来的元素。如果目标容器没有足够的空间，可能会导致未定义行为，例如缓冲区溢出。
• 迭代器类型：std::copy_n 对迭代器类型没有特殊要求，只要它们满足输入迭代器和输出迭代器的基本要求即可。然而，对于随机访问迭代器（如 std::vector 的迭代器），std::copy_n 的性能通常更优，因为可以高效地计算偏移量。
• 异常安全性：std::copy_n 的异常安全性取决于其使用的迭代器和元素复制操作。如果复制过程中抛出异常，且迭代器不支持回滚操作，那么源容器和目标容器的状态可能是不确定的。因此，在使用 std::copy_n 时，应确保复制操作是安全的，或者考虑使用异常安全的容器和迭代器。

4 std::transform 的用法和与 std::copy 的区别

std::transform 是 C++ 标准库中的一个算法，它用于对容器中的元素进行转换操作。这个算法非常灵活，可以根据需要应用一元或二元操作函数来转换元素。其基本语法如下：

一元操作版本：

std::transform(InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op);
1

二元操作版本：

std::transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op);
1

其中：

• first1 和 last1 是输入范围的迭代器，指定了要进行操作的元素范围。
• first2 是二元操作版本中第二个输入范围的起始迭代器。
• d_first 是输出范围的起始迭代器，std::transform 将结果存储在此位置开始的位置。
• unary_op 是一个一元操作函数（或函数指针、函数对象、lambda 表达式），它定义了对输入元素进行操作的方式。
• binary_op 是一个二元操作函数，它接受两个输入元素并返回一个结果。

对于一元操作，std::transform 将 unary_op 应用于范围内的每个元素，并将结果存储回输出范围。对于二元操作，它将 binary_op 应用于范围内的每对元素（来自 first1 和 first2 的元素），并将结果存储到输出容器中。

op（无论是 unary_op 还是 binary_op）可以是函数指针、函数对象或 lambda 表达式，它定义了转换的具体逻辑。例如，可以定义一个 lambda 表达式将每个元素加 5，然后将其存储到输出容器中。

与 std::copy 相比，std::transform 的主要区别在于它不仅仅复制元素，而是对元素进行转换或处理。std::copy 的主要目的是将一个容器中的元素复制到另一个容器中，而不改变它们的值。而 std::transform 则允许定义转换逻辑，并将转换后的值存储到输出容器中。

使用 std::transform 和 lambda 表达式的简单示例：

#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <iterator>  
  
int main() {  
    std::vector<int> source = {1, 2, 3, 4, 5};  
    std::vector<int> destination(source.size());  
  
    // 使用 lambda 表达式将每个元素乘以 2  
    std::transform(source.begin(), source.end(), destination.begin(), [](int x) { return x * 2; });  
  
    // 输出目标容器的内容  
    for (const auto& elem : destination) {  
        std::cout << elem << ' ';  
    }  
    std::cout << std::endl;  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上面代码的输出为：

2 4 6 8 10
1

在这个例子中，std::transform 结合 lambda 表达式将 source 容器中的每个元素乘以 2，并将结果存储在 destination 容器中。

总结来说，std::transform 和 std::copy 的主要区别在于：std::copy 用于简单地复制元素，而 std::transform 则用于对元素进行转换或应用某种操作。如果需要对元素进行转换或处理，那么 std::transform 是更合适的选择。