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.

Object slicing

void show(Shape shape);  // takes by value

Rectangle rect{3.0, 4.0};
show(rect);  // derived data lost — always pass via reference or pointer

Polymorphic containers

std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(5.0));
shapes.push_back(std::make_unique<Rectangle>(3.0, 4.0));

Store polymorphic objects through smart pointers. Raw owning pointers in a container require manual cleanup and invite leaks.

Quick pitfall list

• forgetting virtual on the base destructor (causes partial destruction of derived objects)
• passing derived objects by value (slicing)
• adding override but forgetting virtual on the base (becomes a hidden function instead)
• inheriting when composition or std::variant would be simpler