命名空间
变体
操作

std::map<Key,T,Compare,Allocator>::operator[]

来自 cppreference.com
< cpp‎ | container‎ | map
 
 
 
 
T& operator[]( const Key& key );
(1)
T& operator[]( Key&& key );
(2) (自 C++11 起)
template< class K >
T& operator[]( K&& x );
(3) (自 C++26 起)

返回对映射到与 keyx 等效的键的值的引用,如果该键不存在,则执行插入操作。

1) 如果键不存在,则插入 value_type(key, T())
-
key_type 必须满足 CopyConstructible 的要求。
-
mapped_type 必须满足 CopyConstructibleDefaultConstructible 的要求。
如果执行插入操作,则映射的值将被 值初始化(类类型为默认构造,否则为零初始化),并将返回对其的引用。
(直到 C++11)
1) 如果键不存在,则插入从 std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() 原地构造的 value_type 对象。
等效于 return this->try_emplace(key).first->second;.(自 C++17 起)当使用默认分配器时,这会导致键从 key 中复制构造,映射的值被 值初始化
-
value_type 必须是 EmplaceConstructible,构造参数为 std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>()。当使用默认分配器时,这意味着 key_type 必须是 CopyConstructible,而 mapped_type 必须是 DefaultConstructible
2) 如果键不存在,则插入从 std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() 原地构造的 value_type 对象。
等效于 return this->try_emplace(std::move(key)).first->second;.(自 C++17 起)
当使用默认分配器时,这会导致键从 key 中移动构造,映射的值被 值初始化
-
value_type 必须是 EmplaceConstructible,构造参数为 std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>()。当使用默认分配器时,这意味着 key_type 必须是 MoveConstructible,而 mapped_type 必须是 DefaultConstructible
(自 C++11 起)
3) 如果没有与值 x 透明比较等效的键,则插入原地构造的 value_type 对象。
等效于 return this->try_emplace(std::forward<K>(x)).first->second;。只有当限定标识符 Compare::is_transparent 有效且表示一个类型时,此重载才会参与重载解析。它允许在不构造 Key 实例的情况下调用此函数。

没有迭代器或引用失效。

内容

[编辑] 参数

key - 要查找的元素的键
x - 可以与键透明比较的任何类型的数值

[编辑] 返回值

1,2) 如果不存在键为 key 的元素,则引用新元素的映射值。否则,引用键与 key 相等的现有元素的映射值。
3) 如果不存在键与值 x 相等的元素,则引用新元素的映射值。否则,引用键与 x 相等的现有元素的映射值。

[编辑] 异常

如果任何操作抛出异常,则插入操作无效。

[编辑] 复杂度

容器大小的对数级。

[编辑] 注释

在已发布的 C++11 和 C++14 标准中,此函数指定需要 mapped_typeDefaultInsertable 以及 key_typeCopyInsertableMoveInsertable*this 中。此规范存在缺陷,并通过 LWG issue 2469 修复,上面的描述包含了该问题的解决方法。

但是,已知一个实现 (libc++) 通过两个单独的分配器 construct() 调用来构造 key_typemapped_type 对象,正如已发布的标准所要求的那样,而不是将 value_type 对象置入。

operator[] 是非 const 的,因为它会在键不存在时插入键。如果此行为不可取或容器为 const,则可以使用 at

insert_or_assign 返回比 operator[] 更多的信息,并且不需要映射类型的默认可构造性。

(自 C++17 起)
功能测试 Std 功能
__cpp_lib_associative_heterogeneous_insertion 202311L (C++26) 有序无序 关联 容器 中剩余成员函数的异构重载。 (3)

[编辑] 示例

#include <iostream>
#include <string>
#include <map>
 
void println(auto const comment, auto const& map)
{
    std::cout << comment << '{';
    for (const auto& pair : map)
        std::cout << '{' << pair.first << ": " << pair.second << '}';
    std::cout << "}\n";
}
 
int main()
{
    std::map<char, int> letter_counts{{'a', 27}, {'b', 3}, {'c', 1}};
 
    println("letter_counts initially contains: ", letter_counts);
 
    letter_counts['b'] = 42; // updates an existing value
    letter_counts['x'] = 9;  // inserts a new value
 
    println("after modifications it contains: ", letter_counts);
 
    // count the number of occurrences of each word
    // (the first call to operator[] initialized the counter with zero)
    std::map<std::string, int>  word_map;
    for (const auto& w : {"this", "sentence", "is", "not", "a", "sentence",
                          "this", "sentence", "is", "a", "hoax"})
        ++word_map[w];
    word_map["that"]; // just inserts the pair {"that", 0}
 
    for (const auto& [word, count] : word_map)
        std::cout << count << " occurrence(s) of word '" << word << "'\n";
}

输出

letter_counts initially contains: {{a: 27}{b: 3}{c: 1}}
after modifications it contains: {{a: 27}{b: 42}{c: 1}{x: 9}}
2 occurrence(s) of word 'a'
1 occurrence(s) of word 'hoax'
2 occurrence(s) of word 'is'
1 occurrence(s) of word 'not'
3 occurrence(s) of word 'sentence'
0 occurrence(s) of word 'that'
2 occurrence(s) of word 'this'

缺陷报告

以下行为改变缺陷报告已追溯应用于之前发布的 C++ 标准。

DR 应用于 已发布的行为 正确行为
LWG 334 C++98 重载 (1) 的效果只是返回
(*((insert(std::make_pair(x, T()))).first)).second
提供了自己的
描述而不是

[编辑] 另请参阅

访问指定元素,并进行边界检查
(公共成员函数) [编辑]
插入元素或将元素赋值给当前元素(如果键已存在)
(公共成员函数) [编辑]
如果键不存在则插入,如果键存在则不执行任何操作
(公共成员函数) [编辑]