Operador[] consideraciones en contenedores

Primero mire una tabla, los operator[]contenedores admitidos incluyen string, array, vector, deque, map, unordered_mapy los contenedores secuenciales operator[]no son consistentes con los contenedores asociativos.

stringneutraloperator[]

Devuelve una referencia al carácter pos < size()en la posición especificada cuando , o al carácter que tiene un valor (carácter nulo) cuando. No se realiza comprobación de límites. Si , entonces el comportamiento no está definido.pospos == size()CharT()
pos > size()

int main() {
    
    
    std::string const e("Exemplar");
    for (unsigned i = e.length() - 1; i != 0; i /= 2)
        std::cout << e[i];
    std::cout << '\n';
 
    const char* c = &e[0];
    std::cout << c << '\n'; // 作为 C 字符串打印
    // 将 s 的最后一个字符改成 'y'
    std::string s("Exemplar ");
    s[s.size() - 1] = 'y';
    std::cout << s << '\n';
    return 0;
}

resultado de la operación

rmx
Exemplar
Exemplary

Arrayneutraloperator[]

posDevuelve una referencia al elemento en la posición especificada . No se realiza comprobación de límites.
A diferencia de std::map::operator[], este operador nunca inserta nuevos elementos en el contenedor. Acceder a un elemento inexistente a través de este operador es un comportamiento indefinido.

#include <iostream>
#include <map>
#include <string>
#include <string_view>
#include <vector>
#include <array>

using namespace std;
int main() {
    
    
    std::array<int,4> numbers {
    
    2, 4, 6, 8};

    std::cout << "Second element: " << numbers[1] << '\n';
 
    numbers[0] = 5;
 
    std::cout << "All numbers:";
    for (auto i : numbers) {
    
    
        std::cout << ' ' << i;
    }
    std::cout << '\n';
    return 0;
}

resultado de la operación

Second element: 4
All numbers: 5 4 6 8

vectorneutraloperator[]

posDevuelve una referencia al elemento en la posición especificada . No se realiza comprobación de límites.

#include <vector>
#include <iostream>
 
int main()
{
    
    
    std::vector<int> numbers {
    
    2, 4, 6, 8};
 
    std::cout << "Second element: " << numbers[1] << '\n';
 
    numbers[0] = 5;
 
    std::cout << "All numbers:";
    for (auto i : numbers) {
    
    
        std::cout << ' ' << i;
    }
    std::cout << '\n';
}

resultado de la operación

Second element: 4
All numbers: 5 4 6 8

dequeneutraloperator[]

reference       operator[]( size_type pos );	
const_reference operator[]( size_type pos ) const;

posDevuelve una referencia al elemento en la posición especificada . No se realiza comprobación de límites.

#include <deque>
#include <iostream>
 
int main()
{
    
    
    std::deque<int> numbers {
    
    2, 4, 6, 8};
 
    std::cout << "Second element: " << numbers[1] << '\n';
 
    numbers[0] = 5;
 
    std::cout << "All numbers:";
    for (auto i : numbers) {
    
    
        std::cout << ' ' << i;
    }
    std::cout << '\n';
}

resultado de la operación

Second element: 4
All numbers: 5 4 6 8

mapneutraloperator[]

T& operator[]( const Key& key );(1) 	
T& operator[]( Key&& key );(2) 	(C++11 起)

Devuelve keyuna referencia al valor mapeado a la clave igual a, si dicha clave no existe, se realizará una inserción.

1.  (`C++11 `前) 在键不存在的情况下插入` value_type(key, T())`
   

• key_typeDebe cumplir con los requisitos de copia-construible ( CopyConstructible).
• mapped_typeDebe cumplir con los requisitos de copia-construible ( CopyConstructible) y predeterminado-construible ( DefaultConstructible).
  Si se inserta, el valor inicializa el valor asignado (construido de forma predeterminada para los tipos de clase, inicializado en cero de lo contrario) y devuelve una referencia a él .

2. c++11elevar

• std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>()Inserta un objeto construido desde el lugar si la clave no existe value_type. Esta función es equivalente a return this->try_emplace(key).first->second;. ( C++17 from)
  Cuando se usa el asignador predeterminado, esto hace que la clave se construya a partir de una copia y el valor asignado se inicialice como valor.
• value_type debe std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>()construirse a partir de una construcción in situ (EmplaceConstructible). Cuando se usa el asignador predeterminado, esto indica key_typeque debe ser construible por copia ( CopyConstructible) y mapped_type debe ser construible por defecto ( DefaultConstructible).

2. std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>()Inserta un objeto construido desde el lugar si la clave no existe value_type. Esta función es equivalente a return this->try_emplace(std::move(key)).first->second; . ( C++17from)
   Cuando se usa el asignador predeterminado, esto hace que keylas claves se construyan a partir de movimientos y que los valores asignados se inicialicen como valor.

• value_type Debe construirse desde std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>()in situ ( EmplaceConstructible). Cuando se usa el asignador predeterminado, esto indica key_typeque debe ser construible por movimiento ( MoveConstructible) y mapped_typedebe ser construible por defecto ( DefaultConstructible).

parámetro

key- la clave del elemento a buscar

valor de retorno

keyDevuelve una referencia al valor asignado del nuevo elemento cuando no existe ningún elemento con la clave . key De lo contrario, devuelve una referencia al valor asignado del elemento cuya clave es equivalente a .

anormal

Si alguna operación arroja una excepción, la inserción no tiene efecto.

anotación

Publicado C++11 y C++14Estándares especifican que esta función debe mapped_typeser insertable por defecto ( DefaultInsertable) e key_typeinsertable por copia ( CopyInsertable) o insertable por mover ( MoveInsertable) a *this. Esta disposición fue defectuosa y solucionada por LWGel problema 2469 , y ​​la descripción anterior incorpora la solución a ese problema.

Sin embargo, se sabe que una implementación llama al constructor y al objeto libc++a través de dos asignadores separados , que pueden considerarse como requeridos por el estándar en el momento de la publicación, en lugar de construir el objeto en el lugar. No , porque inserta la clave si no existe. Se puede usar si este comportamiento no es deseable o si el contenedor lo es . Devuelve más información que , y no es necesario que sea construible por defecto. ( de)construct()key_type mapped_typevalue_type
operator[] constconstat()
insert_or_assign() operator[]mapped_typeC++17

#include <iostream>
#include <map>
#include <string>

auto print = [](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}};

    print("letter_counts 初始状态下包含：", letter_counts);

    letter_counts['b'] = 42;  // 更新既存值
    letter_counts['x'] = 9;   // 插入新值

    print("修改后它包含：", letter_counts);

    // 统计每个单词的出现次数
    // （首次调用 operator[] 会初始化计数为零）
    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"];  // 插入对 {"that", 0}

    for (const auto& [word, count] : word_map)
        std::cout << "单词 '" << word << "' 出现 " << count << "次\n";
}

Ejecute el resultado, tenga en cuenta que esto word_map["that"]; // 插入对 {"that", 0}es para insertar un valor de mapa

letter_counts 初始状态下包含：{
    
    {
    
    a: 27}{
    
    b: 3}{
    
    c: 1}}
修改后它包含：{
    
    {
    
    a: 27}{
    
    b: 42}{
    
    c: 1}{
    
    x: 9}}
单词 'a' 出现 2次
单词 'hoax' 出现 1次
单词 'is' 出现 2次
单词 'not' 出现 1次
单词 'sentence' 出现 3次
单词 'that' 出现 0次
单词 'this' 出现 2次

unordered_mapneutraloperator[]

T& operator[]( const Key& key );(1) 	(C++11 起)
T& operator[]( Key&& key );(2) 	(C++11 起)

Devuelve keyuna referencia al valor asignado a la clave igual a , que se habría insertado si no existiera.

#include <iostream>
#include <string>
#include <unordered_map>
 
auto print = [](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::unordered_map<char, int> letter_counts{
    
    {
    
    'a', 27}, {
    
    'b', 3}, {
    
    'c', 1}};
 
    print("letter_counts 初始状态下包含：", letter_counts);
 
    letter_counts['b'] = 42; // 更新既存值
    letter_counts['x'] = 9;  // 插入新值
 
    print("修改后它包含：", letter_counts);
 
    // 统计每个单词的出现次数
    // （首次调用 operator[] 会初始化计数为零）
    std::unordered_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"]; // 插入对 {"that", 0}
 
    for (const auto& [word, count] : word_map)
        std::cout << "单词 '" << word << "' 出现 " << count << "次\n";
}

resultado de la operación

letter_counts 初始状态下包含：{
    
    {
    
    c: 1}{
    
    b: 3}{
    
    a: 27}}
修改后它包含：{
    
    {
    
    x: 9}{
    
    c: 1}{
    
    b: 42}{
    
    a: 27}}
单词 'a' 出现 2次
单词 'not' 出现 1次
单词 'is' 出现 2次
单词 'that' 出现 0次
单词 'hoax' 出现 1次
单词 'sentence' 出现 3次
单词 'this' 出现 2次

referencia

Contenedor del sitio web oficial