OOP & RAII

class Sensor {
private:
    int    id_;
    float  value_;
    bool   active_;

public:
    // Constructor
    Sensor(int id, float initial = 0.0f)
        : id_(id), value_(initial), active_(false) {}

    // Member functions
    void activate()       { active_ = true; }
    float read() const    { return value_; }   // const = doesn't modify object
    int   id()   const    { return id_; }

    // Operator overload
    bool operator<(const Sensor& other) const {
        return value_ < other.value_;
    }
};

Sensor s(42, 23.5f);
s.activate();
std::cout << s.read() << '\n';   // 23.5

// Abstract base class (interface)
class IDevice {
public:
    virtual ~IDevice() = default;        // virtual destructor — ALWAYS!
    virtual bool  open(const char* path) = 0;   // pure virtual
    virtual int   read(uint8_t* buf, int len)  = 0;
    virtual void  close() = 0;
    virtual std::string name() const = 0;
};

// Concrete implementation
class UartDevice : public IDevice {
    int fd_ = -1;
public:
    bool  open(const char* path) override;
    int   read(uint8_t* buf, int len) override;
    void  close() override;
    std::string name() const override { return "UART"; }
};

class SpiDevice : public IDevice { /* ... */ };

// Polymorphic usage
void read_sensor(IDevice& dev) {
    uint8_t buf[64];
    int n = dev.read(buf, sizeof(buf));   // calls the right override at runtime
}

UartDevice uart;
read_sensor(uart);

class Buffer {
    uint8_t* data_;
    size_t   size_;

public:
    // 1. Constructor
    explicit Buffer(size_t size)
        : data_(new uint8_t[size]), size_(size) {
        std::memset(data_, 0, size_);
    }

    // 2. Destructor
    ~Buffer() { delete[] data_; }

    // 3. Copy constructor
    Buffer(const Buffer& other)
        : data_(new uint8_t[other.size_]), size_(other.size_) {
        std::memcpy(data_, other.data_, size_);
    }

    // 4. Copy assignment operator
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            delete[] data_;
            data_ = new uint8_t[other.size_];
            size_ = other.size_;
            std::memcpy(data_, other.data_, size_);
        }
        return *this;
    }

    // 5. Move constructor
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }

    // 5b. Move assignment
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }
};

class FileHandle {
    FILE* fp_;
public:
    explicit FileHandle(const char* path, const char* mode)
        : fp_(std::fopen(path, mode)) {
        if (!fp_) throw std::runtime_error(
            std::string("Cannot open ") + path);
    }
    ~FileHandle() { if (fp_) std::fclose(fp_); }

    // Delete copy — no two FileHandle objects should own the same FILE*
    FileHandle(const FileHandle&)            = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    FILE* get() const { return fp_; }
    operator FILE*() const { return fp_; }
};

void process_config(const char* path) {
    FileHandle f(path, "r");   // opens here
    // ... read file ...
    // f goes out of scope: destructor closes FILE* automatically
    // even if an exception is thrown inside the function!
}

void swap_strong(Buffer& a, Buffer& b) noexcept {
    // swap pointers — cannot throw, O(1)
    std::swap(a.data_, b.data_);
    std::swap(a.size_, b.size_);
}