C++ 中使用硬编码元素初始化 Vector

2025 年 5 月 21 日 | 阅读 10 分钟

在 C++ 编程领域，向量已成为开发人员寻求比传统数组更灵活、更动态的替代方案不可或缺的工具。作为标准模板库 (STL) 的一部分，向量提供了动态调整大小和自动内存管理的通用性，使其成为数据大小不固定或未预先确定的场景的理想选择。与需要在编译时知道大小的数组不同，向量可以适应额外元素的容纳，而无需程序员进行显式重新分配。

编程中最常见的用例之一是使用已知、预定义的值初始化向量。这种技术，通常称为硬编码元素，在编码时有特定数据集的应用程序中特别有用。例如，初始化配置参数、设置测试用例或为计算提供默认值。了解如何高效且有效地使用硬编码元素初始化向量对于编写干净、简洁且可维护的 C++ 代码至关重要。

向量的通用性通过可用的初始化方法得到了进一步强调。从使用初始化列表到使用 assign 方法或push_back 函数，C++ 提供了多种方法来填充具有预定义数据的向量。每种方法都有其优点，选择正确的方法取决于初始化复杂度、数据集大小和代码所需的可读性等因素。

初始化向量最简单、最直观的方法是使用初始化列表，这是 C++11 引入的一项功能。这种方法允许开发人员在初始化期间直接在花括号中指定向量的元素。例如，使用 {1, 2, 3, 4, 5} 初始化向量与编写单行代码一样简单。这种方法的易读性和简洁性使其成为许多开发者的热门选择。

但是，也可以使用 push_back 等方法动态初始化向量，该方法一次添加一个元素。虽然这种方法提供了更大的灵活性，例如能够有条件地添加元素，但由于反复的内存分配，对于硬编码初始化可能效率较低。同样，assign 方法虽然使用较少，但提供了一种用预定义值替换向量内容的方法。

除了直接初始化之外，还可以从其他数据结构（如数组、std::array，甚至其他 STL 容器如 std::list 或 std::deque）构造向量。通过利用迭代器，开发人员可以无缝地用这些源中的元素填充向量，从而提高代码的可重用性和互操作性。

选择正确的初始化方法不仅仅是语法问题；它会严重影响代码的性能、可读性和可维护性。例如，在处理大型数据集或重复值时，接受计数和默认值的构造函数可能比 push_back 等方法更有效。同样，使用迭代器初始化向量是在处理现有数据集合时的理想选择。

在本文中，您将学习 C++ 中使用硬编码元素初始化向量的各种方法。您将深入研究它们的语法、用例和性能影响，为您提供选择最适合您的特定编程场景的方法所需的知识。在本次讨论结束时，您将对如何有效地初始化向量有透彻的了解，从而提高您的 C++ 程序的功能和清晰度。

C++ 中的向量是什么？

向量是一个序列容器，它表示一个能够动态改变大小的数组。与标准数组不同，向量会自动处理内存管理，在添加或删除元素时调整自身大小。

主要特点

动态大小： 在添加或删除元素时自动调整其容量。
高效访问： 它支持使用索引随机访问元素。
兼容性： 它可以与 STL 算法无缝协同工作。
丰富的功能： 它包含用于排序、搜索和修改数据的内置方法。

使用硬编码元素初始化向量

当您事先知道向量的元素时，在初始化时硬编码它们通常是最直接的方法。根据程序的特定要求，有多种方法可以在 C++ 中初始化向量。

1. 使用初始化列表

初始化列表是创建具有预定义元素的向量最简单、最直观的方法之一。它允许您在初始化期间在花括号 {} 中列出元素。

语法

它具有以下语法：

示例

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 20 30 40 50

关键点

简洁易读。
非常适合初始化已知元素的向量。
支持不同的数据类型（例如，int、float、std::string）。

2. 使用 push_back 方法

push_back 方法将元素追加到向量的末尾。这种方法涉及创建一个空向量并逐个添加元素。

语法

它具有以下语法：

示例

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);
    numbers.push_back(40);
    numbers.push_back(50);

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 20 30 40 50

关键点

提供有条件或动态添加元素的灵活性。
对于硬编码初始化效率较低，因为每次 push_back 都涉及开销。

3. 使用 assign 方法

assign 方法用指定的值替换向量的内容。您可以通过将初始化列表传递给此方法来初始化带有硬编码值的向量。

语法

它具有以下语法：

示例

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers;
    numbers.assign({10, 20, 30, 40, 50});

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 20 30 40 50

关键点

对于重新初始化现有向量很有用。
为硬编码初始化提供了简洁的语法。

4. 使用构造函数

还可以使用构造函数初始化向量。您可以提供范围或初始化列表来初始化向量。

带有初始化列表的构造函数

带有指定计数和值的构造函数

示例

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers(5, 10); // 5 elements, all initialized to 10

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 10 10 10 10

关键点

初始化列表构造函数非常适合特定的硬编码值。
计数和值构造函数更适合重复值。

5. 使用 std::array 或数组

如果您更喜欢使用传统数组或 std::array，可以通过将它们作为参数传递给向量构造函数来初始化向量。

std::array 示例

#include <iostream>
#include <vector>
#include <array>

int main() {
    std::array<int, 5> arr = {10, 20, 30, 40, 50};
    std::vector<int> numbers(arr.begin(), arr.end());

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 20 30 40 50

关键点

当从数组或 std::array 转换时很有用。
允许不同容器之间的互操作性。

6. 使用迭代器

当从另一个容器或元素范围初始化向量时，迭代器是必不可少的。您可以通过指定源容器的开始和结束迭代器来创建向量。在从 std::list、std::deque 甚至数组等其他容器初始化向量时，迭代器提供了一种无缝传输数据的方式。使用迭代器可确保代码灵活且适用于任何容器类型。

示例

#include <iostream>
#include <vector>
#include <list>

int main() {
    std::list<int> lst = {10, 20, 30, 40, 50};
    std::vector<int> numbers(lst.begin(), lst.end());

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}   

输出

10 20 30 40 50

关键点

对于从其他容器初始化向量效率很高。
依赖于源容器的 begin() 和 end() 方法。

性能考虑

内存分配： push_back 等方法可能涉及频繁的重新分配，这会影响性能。当知道大小已知时，请使用 reserve 预先分配内存。
初始化开销： 对于硬编码元素，初始化列表和构造函数方法最有效。
可读性： 倾向于简洁且自明的、方法，例如初始化列表，以提高代码的可维护性。

C++ 中初始化带有硬编码元素的向量的最佳实践

在 C++ 中使用向量时，选择最佳的初始化实践可以带来更简洁、更高效、更易于维护的代码。正确的初始化不仅是为了分配值，还包括优化性能、确保可读性和为可伸缩性做准备。在这里，我们将深入探讨 C++ 中使用硬编码元素初始化向量的最佳实践，探索技术注意事项和风格方法。

向量的通用性通过可用的初始化方法得到了进一步强调。从使用初始化列表到使用 assign 方法或 push_back 函数，C++ 提供了多种方法来填充具有预定义数据的向量。每种方法都有其优点，选择正确的方法取决于初始化复杂度、数据集大小和代码所需的可读性等因素。

1. 使用初始化列表以提高可读性和简洁性

对于硬编码元素，初始化列表是初始化向量最简洁、最易读的方法。这种方法消除了不必要的样板代码，并使代码的意图一目了然。

示例

此方法非常适合值固定且数量较少的情况。其紧凑的语法对于单行初始化向量尤其有益，可提高代码的可读性。

为什么它是最好的

清晰易懂。
避免重复的方法调用（例如，push_back）。
适用于包括用户定义类型在内的不同数据类型。

2. 为大型向量预留内存以避免重新分配

在动态填充向量时，例如使用 push_back 或在循环中添加元素，频繁的重新分配会影响性能。为避免这种情况，请使用 reserve 函数在向量大小已知的情况下预先分配内存。

示例

std::vector<int> numbers;
numbers.reserve(100); // Preallocate memory for 100 elements

for (int i = 1; i <= 100; ++i) {
    numbers.push_back(i);
}   

为什么它是最好的

减少了重复内存分配的开销。
提高了大型数据集的性能。
在不牺牲灵活性的情况下保持代码高效。

3. 优先使用构造函数处理重复值

在初始化具有重复值的向量时，使用计数和值构造函数比使用 push_back 循环或使用 assign 方法更好。它更简洁，并消除了不必要的代码。

示例

std::vector<int> numbers(5, 10); // Creates a vector with 5 elements, all set to 10   

为什么它是最好的

简洁最小的语法。
对于重复初始化效率很高。
防止因错误编写的循环而可能出现的错误。

4. 利用迭代器进行互操作性

当从 std::list、std::deque 甚至数组等其他容器初始化向量时，迭代器提供了一种无缝传输数据的方式。使用迭代器可确保代码灵活且适用于任何容器类型。

示例

std::list<int> lst = {10, 20, 30, 40, 50};
std::vector<int> numbers(lst.begin(), lst.end());   

为什么它是最好的

鼓励容器之间的互操作性。
减少了手动复制元素的需要。
能很好地适应源容器的变化。

5. 对静态初始化使用 const 引用

当向量使用在程序中保持不变的硬编码值进行初始化时，请考虑将其声明为 const。这种做法可防止意外修改并提高代码安全性。

示例

为什么它是最好的

确保数据完整性。
将意图传达给其他开发人员。
避免因修改向量而导致的意外副作用。

6. 最小化不必要的副本

当使用其他容器或数组初始化向量时，避免不必要的副本以保持性能。如果可能，直接初始化向量或使用移动语义。

示例

std::vector<int> source = {10, 20, 30, 40, 50};
std::vector<int> numbers(std::move(source));   

为什么它是最好的

通过转移所有权减少内存开销。
在资源受限的应用程序中保持效率。
遵循现代 C++ 实践以获得最佳性能。

7. 保持代码模块化和可重用

对于大型硬编码数据集，避免直接将数据嵌入到主逻辑中的向量初始化中。相反，使用单独的函数或文件来定义和检索数据集。

示例

std::vector<int> getHardcodedValues() {
    return {10, 20, 30, 40, 50};
}
int main() {
    std::vector<int> numbers = getHardcodedValues();
}   

为什么它是最好的

提高代码的可重用性。
保持主逻辑简洁和专注。
简化了对硬编码数据的未来更改。

8. 确保类型安全

使用硬编码值初始化向量时，请确保元素的类型与向量的模板类型匹配。类型不匹配可能由于隐式转换而导致意外行为或性能问题。

std::vector<int> numbers = {10, 20, 30.5}; // Avoid unintentional type conversion   

为什么它是最好的

防止意外的数据丢失或舍入错误。
保持代码行为可预测。
有助于在编译期间捕获潜在的错误。

9. 使用结构化绑定提高可读性

在迭代初始化向量时，使用结构化绑定（C++17 及更高版本）可提高可读性并避免与复杂类型混淆。

示例

for (const auto& [index, value] : enumerate(numbers)) {
    std::cout << "Index: " << index << ", Value: " << value << '\n';
}   

为什么它是最好的

在处理复杂数据类型时提高了清晰度。
减少了代码的冗长性。
与现代 C++ 功能无缝协同工作。