std::vector::emplace back

std::vector::emplace back (tsz. std::vector::emplace backs)

1. (informatika)

A C++ Standard Template Library (STL) egyik leggyakrabban használt konténer típusa a std::vector, amely dinamikusan méretezhető tömbként működik. A std::vector lehetővé teszi, hogy dinamikusan növeljük vagy csökkentsük az elemek számát, miközben az elemek tárolása folyamatos memóriaterületen történik.

Az elemek hozzáadására több lehetőség is van:

• push_back(const T& val) — beszúr egy másolatot az elemről a vektor végére.
• push_back(T&& val) — mozgató (move) verzió, amely átveszi az objektum tulajdonjogát.
• emplace_back(Args&&... args) — új elemet hoz létre közvetlenül a helyén, a megadott paraméterek alapján.

Ez a három közül az emplace_back az egyik leghatékonyabb és legflexibilisebb módja az elemek hozzáadásának, különösen komplex osztályok esetén.

A std::vector::emplace_back C++11-ben került bevezetésre, és egy olyan függvény, amely közvetlenül az adott paraméterekkel létrehozza az új elemet a vektor végén, anélkül, hogy egy külön objektumot először létrehoznánk, majd másolnánk vagy mozdítanánk be.

template <class... Args>
void emplace_back(Args&&... args);

• Az emplace_back egy paramétercsomagot (Args&&...) vár, ami lehetővé teszi bármilyen számú és típusú argumentum továbbítását.
• Ezekkel az argumentumokkal közvetlenül meghívja az elem típusának megfelelő konstruktorát a vektorban.
• A létrehozott elem azonnal a vektor belső tárolóhelyén jön létre, így elkerülhető a felesleges másolás vagy mozgatás.

• Hatékonyabb, mint a push_back: Nem kell először egy ideiglenes objektumot létrehozni, majd azt beszúrni.
• Többféle konstruktor hívása: Olyan objektumok létrehozását teszi lehetővé, amelyekhez több vagy speciális konstruktor szükséges.
• Egyszerűbb és tisztább kód: Nem kell külön példányt létrehozni és azt beadni a vektorba.

Vegyünk egy egyszerű osztályt:

class Szemely {
public:
    std::string nev;
    int kor;

    Szemely(const std::string& n, int k) : nev(n), kor(k) {
        std::cout << "Szemely konstruktor: " << nev << ", " << kor << std::endl;
    }
};

std::vector<Szemely> emberek;
Szemely s("Dani", 30);
emberek.push_back(s);

Ebben az esetben először létrejön az ideiglenes s objektum, majd másolás vagy mozgatás történik a vektorba.

std::vector<Szemely> emberek;
emberek.emplace_back("Dani", 30);

Itt közvetlenül a "Dani" és 30 argumentumokkal hívjuk meg a Szemely konstruktorát, az objektum a vektor memóriájában jön létre, nem kell külön példányt előállítani.

• Az emplace_back általában a vektor aktuális kapacitását ellenőrzi.
• Ha a kapacitás nem elegendő az új elemhez, akkor új, nagyobb memóriaterületet foglal, és átmásolja vagy átmásolja a régi elemeket az új helyre.
• Ez a költséges rész független az emplace_back-tól vagy push_back-tól, viszont az emplace_back segítségével elkerülhető az ideiglenes objektum létrehozásának költsége.
• Az emplace_back tökéletes továbbítást (perfect forwarding) alkalmaz a paramétereken, így az argumentumokat optimálisan továbbítja a konstruktorhoz.

• Ha az osztályodnak többparaméteres vagy komplex konstruktorai vannak.
• Ha el akarod kerülni a fölösleges másolásokat vagy mozgatásokat.
• Ha egyszerűen és tömören akarsz új elemeket létrehozni a konténerben.
• Ha objektumot akarsz létrehozni anélkül, hogy előbb külön példányt kellene inicializálni.

struct Pont {
    int x, y, z;
    Pont(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
};

std::vector<Pont> pontok;
pontok.emplace_back(10, 20, 30);

class Auto {
public:
    std::string marka;
    int evjarat;
    Auto(const std::string& m, int ev) : marka(m), evjarat(ev) {}
};

std::vector<Auto> autok;
autok.emplace_back("Toyota", 2020);

class Ertek {
    int x;
public:
    Ertek(int v) : x(v) {}
};

std::vector<Ertek> vektor;
vulkan.emplace_back(5);  // push_back nem működne így alapértelmezett konstruktor nélkül

• Nem megfelelő paraméterek átadása, amik nem egyeznek az adott típus konstruktoraival.
• Ha a konstruktor explicit, vagy olyan paramétereket vár, amiket nem adtunk meg.
• Elfelejtett C++11 vagy újabb szabvány használata, mert emplace_back csak C++11-től elérhető.

• std::vector::emplace_back egy rugalmas, hatékony módszer új elemek létrehozására és hozzáadására egy vektor végéhez.
• Megszünteti a felesleges másolásokat és mozgatásokat, mert közvetlenül a vektor által fenntartott memóriában hívja meg az elem konstruktorát.
• Használata egyszerűbb és tisztább kódot eredményez, különösen összetett típusok vagy több paraméteres konstruktorok esetén.
• Csak C++11 és újabb szabványokban érhető el.

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

class Szemely {
public:
    std::string nev;
    int kor;

    Szemely(const std::string& n, int k) : nev(n), kor(k) {
        std::cout << "Szemely konstruktor: " << nev << ", " << kor << std::endl;
    }
};

int main() {
    std::vector<Szemely> emberek;

    // push_back példány készítés után
    Szemely s("Anna", 28);
    emberek.push_back(s);

    // emplace_back paraméterek közvetlen átadásával
    emberek.emplace_back("Béla", 35);

    std::cout << "Az emberek száma: " << emberek.size() << std::endl;
    for (const auto& e : emberek) {
        std::cout << e.nev << " (" << e.kor << " éves)" << std::endl;
    }

    return 0;
}

• std::vector::emplace back - Szótár.net (en-hu)
• std::vector::emplace back - Sztaki (en-hu)
• std::vector::emplace back - Merriam–Webster
• std::vector::emplace back - Cambridge
• std::vector::emplace back - WordNet
• std::vector::emplace back - Яндекс (en-ru)
• std::vector::emplace back - Google (en-hu)
• std::vector::emplace back - Wikidata
• std::vector::emplace back - Wikipédia (angol)