std::vector<T,Allocator>::emplace

Inserts a new element into the container directly before pos.

The element is constructed through std::allocator_traits::construct

The arguments args... are forwarded to the constructor as std::forward <Args> (args) . args...

If after the operation the new size() is greater than old capacity() a reallocation takes place, in which case all iterators (including the end()

Parameters

Return value

Iterator pointing to the emplaced element.

Complexity

Linear in the distance between pos and end of the container.

Exceptions

If an exception is thrown other than by the copy constructor, move constructor, assignment operator, or move assignment operator of T, or if an exception is thrown while emplace is used to insert a single element at the end and T is either CopyInsertable

Otherwise, the effects are unspecified.

Example

#include <iostream>
#include <string>
#include <vector>
 
struct A
{
    std::string s;
 
    A(std::string str) : s(std::move(str)) { std::cout << " constructed\n"; }
 
    A(const A& o) : s(o.s) { std::cout << " copy constructed\n"; }
 
    A(A&& o) : s(std::move(o.s)) { std::cout << " move constructed\n"; }
 
    A& operator=(const A& other)
    {
        s = other.s;
        std::cout << " copy assigned\n";
        return *this;
    }
 
    A& operator=(A&& other)
    {
        s = std::move(other.s);
        std::cout << " move assigned\n";
        return *this;
    }
};
 
int main()
{
    std::vector<A> container;
    // reserve enough place so vector does not have to resize
    container.reserve(10);
    std::cout << "construct 2 times A:\n";
    A two{"two"};
    A three{"three"};
 
    std::cout << "emplace:\n";
    container.emplace(container.end(), "one");
 
    std::cout << "emplace with A&:\n";
    container.emplace(container.end(), two);
 
    std::cout << "emplace with A&&:\n";
    container.emplace(container.end(), std::move(three));
 
    std::cout << "content:\n";
    for (const auto& obj : container)
        std::cout << ' ' << obj.s;
    std::cout << '\n';
}

construct 2 times A:
 constructed
 constructed
emplace:
 constructed
emplace with A&:
 copy constructed
emplace with A&&:
 move constructed
content:
 one two three

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also