Nos mapas STL, é melhor usar map :: insert do que []?

Há um tempo, tive uma discussão com um colega sobre como inserir valores nos mapas STL . Eu preferi map[key] = value; porque parece natural e é claro de ler, enquanto ele preferia map.insert(std::make_pair(key, value))

Eu apenas perguntei a ele e nenhum de nós pode se lembrar do motivo pelo qual o insert é melhor, mas tenho certeza de que não era apenas uma preferência de estilo, mas havia um motivo técnico, como eficiência. A referência da SGI STL diz simplesmente "Estritamente falando, essa função de membro é desnecessária: existe apenas por conveniência".

Alguém pode me dizer esse motivo, ou estou apenas sonhando que existe um?

Quando você escreve

map[key] = value;

não há como saber se você substituiu o valuefor keyou se criou um novo keycom value.

map::insert() criará apenas:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

Para a maioria dos meus aplicativos, geralmente não me importo se estou criando ou substituindo, então uso o mais fácil de ler map[key] = value.

Os dois têm semântica diferente quando se trata da chave já existente no mapa. Portanto, eles não são diretamente comparáveis.

Mas a versão do operador [] requer a construção padrão do valor e a atribuição, portanto, se isso for mais caro, copie a construção, então será mais caro. Às vezes, a construção padrão não faz sentido e, portanto, seria impossível usar a versão do operador [].

Outra coisa a se notar std::map:

myMap[nonExistingKey];criará uma nova entrada no mapa, digitada para nonExistingKeyinicializada com um valor padrão.

Isso me assustou muito na primeira vez que o vi (enquanto batia minha cabeça contra um inseto legado). Não teria esperado isso. Para mim, isso parece uma operação get, e eu não esperava o "efeito colateral". Prefere map.find()ao sair do seu mapa.

Se o desempenho do construtor padrão não for um problema, por favor, pelo amor de Deus, vá com a versão mais legível.

:)

insert é melhor do ponto de exceção de segurança.

A expressão map[key] = valueé na verdade duas operações:

1. map[key] - criando um elemento do mapa com valor padrão.
2. = value - copiando o valor para esse elemento.

Uma exceção pode acontecer na segunda etapa. Como resultado, a operação será realizada apenas parcialmente (um novo elemento foi adicionado ao mapa, mas esse elemento não foi inicializado com value). A situação em que uma operação não está concluída, mas o estado do sistema é modificado, é chamada de operação com "efeito colateral".

insertA operação oferece uma garantia forte, significa que não possui efeitos colaterais ( https://en.wikipedia.org/wiki/Exception_safety ). inserté completamente feito ou deixa o mapa em estado não modificado.

http://www.cplusplus.com/reference/map/map/insert/ :

Se um único elemento for inserido, não haverá alterações no contêiner em caso de exceção (garantia forte).

Se o seu aplicativo for crítico quanto à velocidade, aconselho o uso do operador [], pois ele cria um total de 3 cópias do objeto original, das quais 2 são objetos temporários e, mais cedo ou mais tarde, serão destruídos como.

Mas no insert (), 4 cópias do objeto original são criadas, das quais 3 são objetos temporários (não necessariamente "temporários") e são destruídas.

O que significa tempo extra para: 1. Uma alocação de memória de objetos 2. Uma chamada de construtor extra 3. Uma chamada de destruidor extra 4. Uma desalocação de memória de objetos

Se seus objetos são grandes, os construtores são típicos, os destruidores liberam muitos recursos, os pontos acima contam ainda mais. Quanto à legibilidade, acho que ambas são justas o suficiente.

A mesma pergunta veio à minha mente, mas não sobre legibilidade, mas velocidade. Aqui está um exemplo de código através do qual eu vim a conhecer o ponto que mencionei.

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

Agora, em c ++ 11, acho que a melhor maneira de inserir um par em um mapa STL é:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

O resultado será um par com:

• Primeiro elemento (result.first), aponta para o par inserido ou aponta para o par com essa chave, se a chave já existir.

• Segundo elemento (result.second), true se a inserção estava correta ou falsa, algo deu errado.

PS: Se você não se interessa pelo pedido, pode usar std :: unordered_map;)

Obrigado!

Uma dica com map :: insert () é que ele não substituirá um valor se a chave já existir no mapa. Eu vi o código C ++ escrito por programadores Java, onde eles esperavam que insert () se comportasse da mesma maneira que Map.put () em Java, onde os valores são substituídos.

Uma observação é que você também pode usar o Boost.Assign :

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

Aqui está outro exemplo, mostrando que operator[] substitui o valor da chave, se ela existir, mas .insert não substitui o valor, se ela existir.

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

Este é um caso bastante restrito, mas, a julgar pelos comentários que recebi, acho que vale a pena notar.

Eu já vi pessoas no passado usarem mapas na forma de

map< const key, const val> Map;

para evitar casos de substituição acidental de valores, mas continue escrevendo outros bits de código:

const_cast< T >Map[]=val;

A razão de fazer isso, pelo que me lembro, era porque eles tinham certeza de que nesses certos bits de código não estavam substituindo os valores do mapa; portanto, seguindo em frente com o método mais 'legível' [].

Na verdade, nunca tive nenhum problema direto com o código que foi escrito por essas pessoas, mas sinto até hoje que riscos - ainda que pequenos - não devem ser tomados quando podem ser facilmente evitados.

Nos casos em que você estiver lidando com valores de mapa que absolutamente não devem ser substituídos, use insert. Não faça exceções apenas para facilitar a leitura.

O fato de a insert()função std :: map não sobrescrever o valor associado à chave nos permite escrever o código de enumeração de objetos assim:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

É um problema bastante comum quando precisamos mapear diferentes objetos não exclusivos para alguns IDs no intervalo 0..N. Esses IDs podem ser usados ​​posteriormente, por exemplo, em algoritmos de gráficos. Alternativa com operator[]pareceria menos legível na minha opinião:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}