c++ std容器 std::map,std::vector,std::list,std::set初始化

std::map< std::string,double > 初始化

在C++中，std::map是一个关联容器，它存储的元素是键值对（key-value pairs），其中每个键在容器中都是唯一的。你可以使用多种方法来初始化std::map<std::string, double>。以下是一些示例：

默认初始化：创建一个空的std::map。

std::map<std::string, double> my_map;

使用初始化列表：在声明的同时使用初始化列表来填充std::map。

std::map<std::string, double> my_map = {
    {"apple", 0.50},
    {"banana", 0.75},
    {"cherry", 1.25}
};

使用insert成员函数：创建一个空的std::map然后使用insert成员函数来添加元素。

std::map<std::string, double> my_map;
my_map.insert(std::make_pair("apple", 0.50));
my_map.insert(std::make_pair("banana", 0.75));
my_map.insert(std::make_pair("cherry", 1.25));

使用emplace成员函数：类似于insert，但直接在容器中构造元素，可能更高效。

std::map<std::string, double> my_map;
my_map.emplace("apple", 0.50);
my_map.emplace("banana", 0.75);
my_map.emplace("cherry", 1.25);

使用try_emplace成员函数：尝试在容器中就地构造元素，如果键已存在，则不执行任何操作。

std::map<std::string, double> my_map;
my_map.try_emplace("apple", 0.50);
my_map.try_emplace("banana", 0.75);
my_map.try_emplace("cherry", 1.25);

使用std::map的构造函数和std::pair：创建一个空的std::map然后使用std::pair来添加元素。

std::map<std::string, double> my_map;
my_map.insert(std::pair<std::string, double>("apple", 0.50));
my_map.insert(std::pair<std::string, double>("banana", 0.75));
my_map.insert(std::pair<std::string, double>("cherry", 1.25));

以上所有方法都可以用来初始化std::map<std::string, double>，你可以根据你的需求和喜好选择合适的方法。通常，使用初始化列表的方式是最简洁和直观的。

std::vector< double > 初始化方式

std::vector 是C++标准库中的一个动态数组，它可以自动调整大小以容纳新元素。以下是一些初始化 std::vector 的常见方式：

默认初始化：创建一个空的 vector。

std::vector<double> vec;

使用构造函数指定大小：创建一个具有指定大小 n 的 vector，所有元素都使用 double 类型的默认构造函数初始化（即初始化为 0.0）。

std::vector<double> vec(10); // 创建一个包含10个元素的vector，所有元素初始化为0.0

使用构造函数和迭代器：从另一个容器（如另一个 vector、array、list 等）复制元素。

std::array<double, 3> arr = {1.0, 2.0, 3.0};
std::vector<double> vec(arr.begin(), arr.end()); // 复制arr中的所有元素到vec

使用初始化列表：创建一个 vector 并使用初始化列表来指定其初始元素。

std::vector<double> vec = {1.0, 2.0, 3.0, 4.0, 5.0}; // 创建一个包含5个元素的vector

使用 assign 函数：创建一个空的 vector 并使用 assign 函数添加元素。

std::vector<double> vec;
vec.assign(10, 0.0); // 创建一个包含10个元素的vector，所有元素初始化为0.0

使用 resize 函数：创建一个空的 vector 并使用 resize 函数设置大小，然后使用索引运算符或 at 函数设置特定位置的值。

std::vector<double> vec;
vec.resize(5); // 创建一个包含5个元素的vector，所有元素默认初始化为0.0
vec[0] = 1.0; // 设置第一个元素为1.0
vec[1] = 2.0; // 设置第二个元素为2.0
// ...

使用列表初始化与 std::initializer_list：这是C++11及之后版本引入的一种新特性，允许使用花括号 {} 初始化 vector。

std::vector<double> vec = {1.0, 2.0, 3.0}; // 与之前的初始化列表相同

这些初始化方法提供了多种方式来创建和设置 std::vector 的初始状态，你可以根据具体的需求选择最适合你的方法。

std::list< double > 初始化方式

std::list 是 C++ 标准库中的一个双向链表容器，用于存储 double 类型的元素。有多种方法可以初始化 std::list，以下是一些常见的初始化方式：

默认初始化：创建一个空的 std::list。

std::list<double> my_list;

使用初始化列表：在声明的同时使用初始化列表来填充 std::list。

std::list<double> my_list = {1.0, 2.0, 3.0, 4.0, 5.0};

使用 push_back 或 push_front 成员函数：创建一个空的 std::list，然后使用 push_back 或 push_front 添加元素。

std::list<double> my_list;
my_list.push_back(1.0);
my_list.push_back(2.0);
my_list.push_front(0.0); // 在链表头部插入元素

使用 emplace_back 或 emplace_front 成员函数：类似于 push_back 和 push_front，但直接在容器中构造元素，可能更高效。

std::list<double> my_list;
my_list.emplace_back(1.0);
my_list.emplace_back(2.0);
my_list.emplace_front(0.0); // 在链表头部就地构造元素

使用 insert 成员函数：在特定位置插入元素。

std::list<double> my_list;
my_list.insert(my_list.begin(), 0.0); // 在链表开始位置插入元素
my_list.insert(my_list.end(), 1.0);   // 在链表结束位置插入元素

使用 assign 成员函数：创建一个具有指定大小和值的 std::list。

std::list<double> my_list;
my_list.assign(5, 2.0); // 创建一个包含5个值为2.0的元素的list

复制构造函数：使用另一个 std::list 来初始化新的 std::list。

std::list<double> first_list = {1.0, 2.0, 3.0};
std::list<double> second_list(first_list); // 复制first_list的内容

移动构造函数：使用另一个 std::list 的资源来初始化新的 std::list（C++11 及以后版本）。

std::list<double> first_list = {1.0, 2.0, 3.0};
std::list<double> second_list(std::move(first_list)); // 移动first_list的内容

以上方法都是初始化 std::list 的有效方式，你可以根据具体的需求和场景选择适合的方法。

std::set< double > 初始化方式

std::set 是 C++ 标准库中的一个关联容器，它存储的元素是唯一的，并且元素按照升序自动排序。初始化 std::set 的方式有多种，下面是一些常见的方法：

默认初始化：创建一个空的 std::set。

std::set<double> my_set;

使用初始化列表：在声明的同时使用初始化列表来填充 std::set。

std::set<double> my_set = {1.0, 2.0, 3.0, 4.0, 5.0};

使用 insert 成员函数：创建一个空的 std::set，然后使用 insert 添加元素。

std::set<double> my_set;
my_set.insert(1.0);
my_set.insert(2.0);
// 由于 set 中的元素是唯一的，再次插入相同的值不会有任何效果
my_set.insert(2.0); // 这行代码不会产生任何效果

使用 emplace 成员函数：类似于 insert，但直接在容器中构造元素，可能更高效。

std::set<double> my_set;
my_set.emplace(1.0);
my_set.emplace(2.0);
// 同样，由于元素唯一性，再次emplace相同的值不会有任何效果
my_set.emplace(2.0); // 这行代码不会产生任何效果

使用 std::initializer_list：使用 std::initializer_list 来初始化 std::set。

std::initializer_list<double> init_list = {1.0, 2.0, 3.0, 4.0, 5.0};
std::set<double> my_set(init_list);

复制构造函数：使用另一个 std::set 来初始化新的 std::set。

std::set<double> first_set = {1.0, 2.0, 3.0};
std::set<double> second_set(first_set); // 复制first_set的内容

移动构造函数：使用另一个 std::set 的资源来初始化新的 std::set（C++11 及以后版本）。

std::set<double> first_set = {1.0, 2.0, 3.0};
std::set<double> second_set(std::move(first_set)); // 移动first_set的内容

请注意，由于 std::set 中的元素是唯一的，因此任何尝试插入重复元素的操作都将被忽略。同时，std::set 会自动对其元素进行排序，所以你不需要担心元素的顺序。

c++ std 容器

C++标准库提供了多种容器（containers），这些容器用于存储和管理数据。容器的主要特点是它们能够动态地调整大小以适应存储的元素数量。这些容器可以大致分为两类：序列容器（sequence containers）和关联容器（associative containers）。

序列容器

vector: 动态数组，支持随机访问，高效地在尾部添加和删除元素。

std::vector<int> vec = {1, 2, 3, 4, 5};

list: 双向链表，支持在任意位置高效地插入和删除元素，但访问元素（特别是访问中间元素）相对较慢。

std::list<int> lst = {1, 2, 3, 4, 5};

deque: 双端队列，支持在头部和尾部高效地添加和删除元素。

std::deque<int> dq = {1, 2, 3, 4, 5};

array: 固定大小的数组，与C风格的数组类似，但更安全，支持范围for循环。

std::array<int, 5> arr = {1, 2, 3, 4, 5};

forward_list: 单向链表，与list类似，但只支持单向迭代。

std::forward_list<int> flist = {1, 2, 3, 4, 5};

关联容器

set: 无序集合，存储唯一元素，不允许重复，元素自动排序。

std::set<int> s = {1, 2, 3, 4, 5};

multiset: 无序多重集合，允许存储重复元素，元素自动排序。

std::multiset<int> ms = {1, 2, 2, 3, 4, 4, 5};

map: 无序映射，存储键值对，键唯一，根据键自动排序。

std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};

multimap: 无序多重映射，允许存储具有相同键的多个键值对，根据键自动排序。

std::multimap<std::string, int> mm = {{"apple", 1}, {"banana", 2}, {"apple", 3}};

unordered_set: 无序集合，使用哈希表实现，存储唯一元素，不允许重复。

std::unordered_set<int> us = {1, 2, 3, 4, 5};

unordered_multiset: 无序多重集合，使用哈希表实现，允许存储重复元素。

std::unordered_multiset<int> ums = {1, 2, 2, 3, 3, 3};

unordered_map: 无序映射，使用哈希表实现，存储键值对，键唯一。

std::unordered_map<std::string, int> um = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};

unordered_multimap: 无序多重映射，使用哈希表实现，允许存储具有相同键的多个键值对。

std::unordered_multimap<std::string, int> umm = {{"apple", 1}, {"banana", 2}, {"apple", 3}};

每个容器都有其自身的特点，适合不同的使用场景。选择容器时，应根据具体需求（如是否需要保持元素有序、是否允许重复元素、是否需要快速访问等）来选择合适的容器。