# V837. The 'emplace' / 'insert' function does not guarantee that arguments will not be copied or moved if there is no insertion. Consider using the 'try_emplace' function.

The analyzer has detected the use of the 'emplace' / 'insert' function from the standard library's associative container ('std::map', 'std::unordered_map'), while the 'try_emplace' function is available. The 'emplace' / 'insert' function can cause arguments to be copied or moved, even if there is no insertion (the element with the same key has already been added to the container). This can reduce performance and, if the argument is moved, can result in the premature release of resources.

Depending on the implementation of the standard library, the 'emplace' / 'insert' function may create a temporary object of the 'std::pair' type before checking for the element with the key value. The function's arguments will be copied or moved into 'std::pair'. Since C++17, the 'try_emplace' function has been introduced to the 'std::map' and 'std::unordered_map' containers. If the element with the key value exists, the function guarantees that the function arguments will not be copied or moved.

Here is a code example:

    class SomeClass
    {
      std::string name, surname, descr;

    public:
      // User-defined constructor
      SomeClass(std::string name, std::string surname, std::string descr);

      // ....
    };

    std::map<size_t, SomeClass> Cont;

    bool add(size_t id,
             const std::string &name,
             const std::string &surname,
             const std::string &descr)
    {
      return Cont.emplace(id, SomeClass { name, surname, descr })
                 .second;
    }

In the example, the object of the 'SomeClass' type is inserted into the 'Cont' container by the 'id' key. If the object has already been added by that key, the following unnecessary operations may be performed:

- The copy constructor of the string is called 3 times when creating a temporary object of the 'SomeClass' type;
- The move constructor of the string is called 3 times when a temporary object of the 'SomeClass' type is perfectly forwarded to a temporary object of the 'std::pair<const size_t, SomeClass>' type.

If you use the 'try_emplace' function instead of 'emplace', you can avoid creating an unnecessary temporary object of the 'std::pair<const size_t, SomeClass>' type:

    bool add(size_t id,
             const std::string &name,
             const std::string &surname,
             const std::string &descr)
    {
      return Cont.try_emplace(id, SomeClass { name, surname, descr })
                 .second;
    }

Using 'try_emplace' also enables you to create objects in-place, inside an associative container. In the example, the 'SomeClass' type is not an aggregate and contains a user-declared constructor. So, you can also avoid calling the copy constructors of the string 3 times:

    bool add(size_t id,
             const std::string &name,
             const std::string &surname,
             const std::string &descr)
    {
      return Cont.try_emplace(id, name, surname, descr)
                 .second;
    }

Since C++20, the 'try_emplace' function also works with aggregate types:

    struct SomeClass
    {
      std::string name, surname, descr;
    };

    bool add(size_t id,
             const std::string &name,
             const std::string &surname,
             const std::string &descr)
    {
      return Cont.try_emplace(id, name, surname, descr)
                 .second;
    }