RAII

void process()
{
    // Allocation manuelle
    int* data = new int[1024];

    if (!validate(data)) {
        return;  // FUITE ! delete oublié
    }

    transform(data);
    // Si transform() lève une exception
    // → FUITE aussi !

    delete[] data;  // Atteint seulement
                      // si tout va bien
}

void process()
{
    // Le vector gère sa mémoire
    std::vector<int> data(1024);

    if (!validate(data)) {
        return;  // OK : destructeur appelé
    }

    transform(data);
    // Si transform() lève une exception
    // → destructeur appelé quand même

    // Pas de delete — le destructeur
    // de vector libère tout
}

#include <memory>

class Texture {
public:
    Texture(const std::string& path);
    void bind() const;
};

void render()
{
    // Propriété exclusive, zéro coût
    auto tex = std::make_unique<Texture>(
        "wall.png"
    );

    tex->bind();

    // Pas de delete.
    // unique_ptr libère à la fin du scope.
}

// Transfert de propriété (move semantics)
std::unique_ptr<Texture> load(const std::string& p)
{
    return std::make_unique<Texture>(p);
}

#include <memory>

class Config {
public:
    explicit Config(const std::string& file);
    std::string get(const std::string& key) const;
};

// Propriété partagée : plusieurs modules
// référencent le même Config
auto cfg = std::make_shared<Config>(
    "app.toml"
);

module_a(cfg);  // copie du shared_ptr
module_b(cfg);  // ref count = 3

// Quand le dernier shared_ptr est détruit
// → Config est libéré automatiquement

// weak_ptr pour casser les cycles :
std::weak_ptr<Config> observer = cfg;
if (auto locked = observer.lock()) {
    locked->get("key");
}

std::mutex mtx;
std::vector<int> shared_data;

void add(int value)
{
    mtx.lock();

    if (value < 0) {
        return;  // DEADLOCK !
                 // unlock() jamais appelé
    }

    shared_data.push_back(value);
    // Si push_back() lève (bad_alloc)
    // → DEADLOCK aussi !

    mtx.unlock();
}

std::mutex mtx;
std::vector<int> shared_data;

void add(int value)
{
    // Verrouillage automatique
    std::lock_guard<std::mutex> lock(mtx);

    if (value < 0) {
        return;  // OK : unlock automatique
    }

    shared_data.push_back(value);
    // Si exception → unlock automatique

    // Fin du scope → destructeur
    // → unlock() garanti
}

// C++17 : déduction de template
std::lock_guard lock(mtx);

// Pour plus de flexibilité :
std::unique_lock ulock(mtx);
ulock.unlock();  // libération anticipée

#include <cstdio>

void export_data()
{
    FILE* f = fopen("out.csv", "w");
    if (!f) return;

    fprintf(f, "id,name\n");

    auto rows = fetch_rows();
    // Si fetch_rows() lève une exception
    // → fclose() jamais appelé
    // → descripteur fuité

    for (auto& r : rows) {
        fprintf(f, "%d,%s\n", r.id, r.name);
    }

    fclose(f);  // facile à oublier
}

#include <fstream>

void export_data()
{
    // fstream = RAII natif
    std::ofstream out("out.csv");
    if (!out) return;

    out << "id,name\n";

    for (auto& r : fetch_rows()) {
        out << r.id << "," << r.name << "\n";
    }

    // Le destructeur de ofstream
    // ferme le fichier automatiquement.
    // Même en cas d'exception :
    // stack unwinding → ~ofstream()
}

// Pour un FILE* legacy, unique_ptr :
auto fp = std::unique_ptr<FILE, decltype(&fclose)>(
    fopen("data.bin", "rb"), &fclose
);

// Quand vous gérez une ressource brute :
// définissez les 5 opérations spéciales

class Buffer
{
public:
    explicit Buffer(size_t size)
        : data_(new char[size])
        , size_(size) {}

    // 1. Destructeur
    ~Buffer() { delete[] data_; }

    // 2. Copy constructor
    Buffer(const Buffer& o)
        : data_(new char[o.size_])
        , size_(o.size_)
    {
        std::copy(o.data_, o.data_ + size_, data_);
    }

    // 3. Copy assignment
    Buffer& operator=(const Buffer& o) {
        if (this != &o) {
            delete[] data_;
            size_ = o.size_;
            data_ = new char[size_];
            std::copy(o.data_, o.data_ + size_, data_);
        }
        return *this;
    }

    // 4. Move constructor
    Buffer(Buffer&& o) noexcept
        : data_(std::exchange(o.data_, nullptr))
        , size_(std::exchange(o.size_, 0)) {}

    // 5. Move assignment
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {
            delete[] data_;
            data_ = std::exchange(o.data_, nullptr);
            size_ = std::exchange(o.size_, 0);
        }
        return *this;
    }

private:
    char* data_;
    size_t size_;
};

#include <vector>
#include <string>
#include <memory>

// AUCUNE opération spéciale définie.
// Le compilateur génère tout correctement
// car chaque membre est déjà RAII.

class Document
{
public:
    Document(std::string title,
             std::string content)
        : title_(std::move(title))
        , content_(std::move(content))
    {}

    void add_tag(std::string tag)
    {
        tags_.push_back(std::move(tag));
    }

private:
    std::string              title_;
    std::string              content_;
    std::vector<std::string> tags_;
};

// Document est copiable, movable,
// et ne fuit jamais — sans écrire
// une seule ligne de gestion mémoire.

// Préférez toujours la Rule of Zero.
// N'écrivez la Rule of Five que pour
// les classes « ressource » de bas niveau.