KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::vector::emplace_back — een element aan het einde construeren

Construeert uit de meegegeven argumenten één element aan het einde van de vector. Lees wat de functie teruggeeft en wanneer bestaande verwijzingen ongeldig worden.

Versie: ISO C++23; implementation support may vary

Syntax

#include <vector>

// Member declaration inside std::vector<T, Allocator> (C++23):
template<class... Args>
constexpr reference emplace_back(Args&&... args);

// Call on a vector v:
v.emplace_back(args...);

std::vector::emplace_back uit <vector> voegt één element toe aan het einde van de vector en verhoogt bij succes size() met één. De parameters Args&&... zijn forwardingreferenties: std::forward behoudt het onderscheid tussen lvalue en rvalue, maar geeft een prvalue door als xvalue. In het primaire sjabloon wordt het element van type T rechtstreeks in het geheugen van de vector geconstrueerd door std::allocator_traits<Allocator>::construct aan te roepen met de doorgegeven argumenten. T moet voor die argumenten aan EmplaceConstructible voldoen en voor die vector aan MoveInsertable, ook als er al voldoende capaciteit is. De specialisatie std::vector<bool> hoeft allocator_traits::construct niet te gebruiken om haar waarden te construeren.

emplace_back kan een explicit-constructor gebruiken zonder dat je bij de aanroep een tijdelijke T maakt. Heb je al een T, dan maakt push_back duidelijk dat je die wilt kopiëren (const T&) of wilt doorgeven om te verplaatsen (T&&). Rechtstreekse constructie sluit kopiëren of verplaatsen niet uit. In C++11 en C++14 gaf de functie void terug; vanaf C++17 geeft ze reference naar het nieuwe element terug (T& in het primaire sjabloon, een proxyobject bij std::vector<bool>). Vanaf C++20 is de functie constexpr, met inachtneming van de regels voor constante evaluatie.

Toevoegen aan het einde kost geamortiseerd constante tijd; bij herallocatie is de tijd lineair in het aantal elementen. Als de nieuwe grootte de oude capacity() overschrijdt, maakt herallocatie alle bestaande pointers, referenties en iterators naar elementen ongeldig, evenals de oude end(). Zonder herallocatie wordt alleen de oude end() ongeldig. Een geslaagde reserve(n) zorgt voor minstens n aan capaciteit, maar verandert size() niet en maakt geen elementen aan.

Als het invoegen een uitzondering opwerpt, blijft de vector normaal gesproken ongewijzigd. Komt de uitzondering echter uit de moveconstructor van een T dat voor die vector niet aan CopyInsertable voldoet, dan zijn de effecten niet gespecificeerd. Benader elementen niet via ongeldig geworden referenties of pointers.

Voorbeelden

#include <iostream>
#include <string>
#include <utility>
#include <vector>

struct Result {
    std::string name;
    int score;

    explicit Result(std::string n, int s) : name(std::move(n)), score(s) {}
};

int main() {
    std::vector<Result> results;
    results.reserve(2);
    std::cout << "size after reserve: " << results.size() << '\n';

    auto& first = results.emplace_back("Ada", 40);
    results.emplace_back("Lin", 35);
    first.score += 2;

    std::cout << "size after insertion: " << results.size() << '\n';
    for (const auto& result : results) {
        std::cout << result.name << ": " << result.score << '\n';
    }
}

Resultaat

size after reserve: 0
size after insertion: 2
Ada: 42
Lin: 35

`reserve(2)` maakt geen elementen aan, maar zorgt ervoor dat bij geen van beide invoegingen herallocatie nodig is. `first` verwijst dus nog steeds naar het eerste resultaat; de wijziging verhoogt Ada’s score van 40 naar 42.

Gerelateerde lessen

  • C++ · Les 18 · Gevorderd · Versie: 3
  • C++ · Les 32 · Gevorderd · Versie: 3
  • C++ · Les 36 · Gevorderd · Versie: 3

Bronnen