Classes and OOP

Class basics

class Rectangle {
public:
    Rectangle(double w, double h) : width_{w}, height_{h} {}
    double area() const { return width_ * height_; }

private:
    double width_{};
    double height_{};
};

struct vs class

• struct: default public access
• class: default private access
• Otherwise, they are almost the same language feature

Special member functions

• Default constructor
• Destructor
• Copy constructor
• Copy assignment operator
• Move constructor
• Move assignment operator

Inheritance

class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
};

class Circle : public Shape {
public:
    explicit Circle(double r) : radius_{r} {}
    double area() const override { return 3.14159 * radius_ * radius_; }

private:
    double radius_{};
};

Keywords to know

• explicit
• override
• final
• virtual
• public, protected, private

Best-practice reminders

• Prefer composition over inheritance.
• Make single-argument constructors explicit.
• Keep class invariants valid after construction.
• Use polymorphism only when behavior truly varies by subtype.

Rule of zero and rule of five

• Prefer the rule of zero: let members manage resources so you do not write special members yourself.
• If you define one ownership-sensitive special member, review whether you need all five.

class SocketOwner {
public:
    SocketOwner(SocketOwner&&) noexcept = default;
    SocketOwner& operator=(SocketOwner&&) noexcept = default;

    SocketOwner(const SocketOwner&) = delete;
    SocketOwner& operator=(const SocketOwner&) = delete;
};

Modern class features

struct Config {
    std::string host;
    int port{};
    auto operator<=>(const Config&) const = default;
};

• Default comparisons reduce boilerplate for value types.
• Aggregates with clear field names are often better than overengineered setter-based classes.

Polymorphism alternatives

• Use templates or concepts when behavior varies by type at compile time.
• Use std::variant when the set of alternatives is closed and known.
• Use virtual functions when the set of implementations is open and runtime-selected.