Classes and objects: data plus behaviour

Why classes?

So far, data and functions lived separately. A bank account has a balance AND rules: you cannot withdraw more than you have, deposits must be positive. If the balance is a plain variable, any code anywhere can set it to -5000 by mistake. A class keeps the data and its rules together and controls who can touch the data. This idea is called encapsulation.

A first class

#include <iostream>
#include <string>

class BankAccount {
public:
    void deposit(long long paise) {
        if (paise > 0) balance_ += paise;
    }
    bool withdraw(long long paise) {
        if (paise <= 0 || paise > balance_) return false;
        balance_ -= paise;
        return true;
    }
    long long balance() const { return balance_; }

private:
    long long balance_ = 0;   // only member functions can touch this
};

int main() {
    BankAccount acc;              // an object
    acc.deposit(50000);
    std::cout << acc.withdraw(80000) << '\n';   // 0: refused
    std::cout << acc.balance() << '\n';         // 50000
    // acc.balance_ = -1;   // error: balance_ is private
}

Member functions and the dot operator

Functions written inside a class are member functions (often called methods). You call them on an object with a dot: acc.deposit(500). Inside a member function, the class's members are used directly by name. Behind the scenes, each member function receives a hidden pointer called this, which points to the object it was called on, so balance_ really means this->balance_.

const member functions

long long balance() const promises that the function does not change the object. You can call const functions on const objects (for example on a const BankAccount& parameter). Mark every function that only reads as const; the compiler then stops accidental changes and your class works with const references.

public, private and protected

struct versus class

In C++, struct and class are almost the same thing. The only difference is the default access: members of a struct are public by default, members of a class are private by default. By convention, use struct for simple bundles of data with no rules (like a Point with x and y) and class when there are rules to protect.

struct Point {
    double x = 0;
    double y = 0;
};

Point p{3.0, 4.0};
std::cout << p.x + p.y << '\n';   // 7

Splitting a class into .h and .cpp

// account.h
#pragma once
class BankAccount {
public:
    void deposit(long long paise);
    long long balance() const;
private:
    long long balance_ = 0;
};

// account.cpp
#include "account.h"
void BankAccount::deposit(long long paise) {
    if (paise > 0) balance_ += paise;
}
long long BankAccount::balance() const { return balance_; }

Static members

A static member belongs to the class itself, not to each object. A static counter, for example, can count how many accounts were opened. Since C++17 you can write inline static int count = 0; inside the class.

Common mistakes

• Forgetting the semicolon after the closing brace of a class: class A { }; — the ; is required.
• Making all data public "to make it easy", which loses the protection classes give.
• Forgetting const on getters, then getting errors when calling them through a const reference.
• Writing getters and setters for every field automatically. Expose operations that make sense (deposit, withdraw), not raw fields.