resource acquisition is initialization

resource acquisition is initialization (tsz. resource acquisition is initializations)

1. (informatika) A Resource Acquisition Is Initialization (röviden RAII) egy rendkívül fontos C++ programozási elv, amely szinte minden modern C++ kódbázisban alapstratégiaként jelenik meg.

A RAII egy tervezési minta, amelynek lényege:

👉 egy erőforrás élettartama kötődjön egy objektum élettartamához.

Az “erőforrás” lehet például:

• memória (new/delete),
• fájl fogantyú (file handle),
• hálózati kapcsolat,
• mutex lock,
• adatbázis kapcsolat,
• grafikai erőforrás (pl. texture),
• bármilyen más külső erőforrás, amelyet manuálisan kell lefoglalni és felszabadítani.

A lényeg:

• amikor az objektum létrejön (konstruktorban), megszerezzük az erőforrást (acquire),
• amikor az objektum elpusztul (destruktorban), automatikusan felszabadítjuk (release).

“Resource Acquisition Is Initialization” szó szerint:

“Az erőforrás megszerzése az inicializálás során történik.”

Vagyis:

• amikor egy objektumot példányosítasz (inicializálod), azonnal hozzárendeled hozzá az erőforrást is.
• amikor az objektum megszűnik (kilép a scope-ból, pl. függvényből), az erőforrást automatikusan felszabadítja.

Manuális erőforrás-kezelés során könnyű hibázni:

void myFunction() {
    FILE* f = fopen("data.txt", "r");

    if (!f) return; // Oops, early return → resource leak

    // Use the file
    processFile(f);

    if (someError) return; // Oops again → resource leak

    fclose(f); // ok, ha ide eljutunk
}

Hiba:

• Ha korán visszatérünk a függvényből, a fclose(f) már nem fut le → fájl leak lesz.

RAII mintával a fenti kód így nézne ki:

#include <fstream>

void myFunction() {
    std::ifstream f("data.txt");

    if (!f) return; // Ok! Ha elhagyjuk a scope-ot, a destructor bezárja a fájlt.

    // Use the file
    processFile(f);

    if (someError) return; // Ok! Destructor automatikusan lezárja.
}

Itt a std::ifstream osztály RAII-t alkalmaz:

• konstruktorban megnyitja a fájlt,
• destruktorban bezárja a fájlt.

Tehát a return hívások teljesen biztonságosak lettek.

✅ Nincs resource leak — automatikusan tisztítunk.

✅ Exception safety — ha kivétel dobódik, a destructor mindenképp lefut, és felszabadítja az erőforrást.

✅ Egyszerű, tiszta kód — nincs szükség külön release() hívásokra.

✅ Scope-hoz kötött élettartam — ha kilépünk egy scope-ból, az erőforrás automatikusan tisztul.

#include <memory>

void foo() {
    std::unique_ptr<MyObject> ptr(new MyObject());

    ptr->doSomething();

} // amikor kilépünk a foo()-ból, a MyObject automatikusan törlődik.

A std::unique_ptr alkalmazza a RAII mintát:

• megszerzi a memóriát (new),
• elengedi a memóriát (delete) a destruktorban.

#include <mutex>

std::mutex mtx;

void criticalSection() {
    std::lock_guard<std::mutex> lock(mtx);

    // A lock_guard megszerzi a lockot, scope végén automatikusan elengedi.
    doCriticalWork();
}

A std::lock_guard is RAII:

• konstruktorban lockol,
• destruktorban unlockol.

Exception-safe! Ha kivétel dobódik, a lock felszabadul.

#include <fstream>

void readData() {
    std::ifstream file("data.txt");

    std::string line;
    while (std::getline(file, line)) {
        // process line
    } // file automatikusan lezáródik scope végén
}

• Konstruktorban: megszerezzük az erőforrást.
• Destruktorban: felszabadítjuk.

Pl.:

class MyFile {
    FILE* file;
public:
    MyFile(const char* filename) {
        file = fopen(filename, "r");
        if (!file) throw std::runtime_error("Cannot open file");
    }

    ~MyFile() {
        if (file) fclose(file);
    }

    // Egyéb függvények...
};

Használat:

void myFunction() {
    MyFile f("data.txt");

    // Use f...

} // f destruktora automatikusan hívódik → fclose megtörténik.

Az RAII különösen kivételbiztos:

• Ha exception történik, a stack visszagörgetése során a scope-ból kilépő objektumok destruktorai garantáltan lefutnak.

Ezért RAII kötelező minden olyan erőforrás kezelésénél, ahol leak veszély áll fenn.

• Erőforráshoz élettartamot kell kötni → nem alkalmas, ha hosszú távon explicit erőforrás-átadást akarunk.
• Egyes C API-k nem mindig könnyen “becsomagolhatók” RAII-ba — de ilyenkor is érdemes wrapper osztályt írni.

A C++ egyik legfontosabb elve:

“Ami megszületik, az automatikusan pusztuljon is el a megfelelő időben.”

Vagy:

👉 “Kövesd az objektumok életciklusát, ne kezeld kézzel az erőforrásokat.”

Ezért a modern C++-ban:

❌ new / delete — ne használd közvetlenül, inkább std::unique_ptr

❌ malloc / free — ne használd

❌ fopen / fclose — inkább std::ifstream

❌ pthread_mutex_lock / unlock — inkább std::lock_guard

A RAII a C++ egyik legerősebb és legbiztonságosabb mintája. Használata:

• könnyebb kódot eredményez,
• kevesebb bug,
• exception safety garantált,
• kódkarbantartás jobb.

Ma már alapszabálynak számít:

👉 “Ha valamilyen erőforrást használsz, rakd RAII-be!”

• resource acquisition is initialization - Szótár.net (en-hu)
• resource acquisition is initialization - Sztaki (en-hu)
• resource acquisition is initialization - Merriam–Webster
• resource acquisition is initialization - Cambridge
• resource acquisition is initialization - WordNet
• resource acquisition is initialization - Яндекс (en-ru)
• resource acquisition is initialization - Google (en-hu)
• resource acquisition is initialization - Wikidata
• resource acquisition is initialization - Wikipédia (angol)