Classes

Chapter 1: The this Pointer

When you call a member function on an object, how does the function know which object's data to use? Every member function receives a hidden parameter called this — a pointer to the object the function was called on.

c++
struct Sales_data {
    string isbn() const { return bookNo; }
    // compiler sees this as:
    // string isbn(const Sales_data *const this) { return this->bookNo; }

    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

When you write total.isbn(), the compiler passes &total as the this pointer. Inside isbn, using bookNo really means this->bookNo.

Returning *this

Member functions can return *this to enable chaining:

c++
Sales_data& combine(const Sales_data &rhs) {
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;   // return the object this function was called on
}
// enables: total.combine(trans1).combine(trans2);

Chapter 2: const Member Functions

A member function with const after the parameter list promises not to modify the object. The compiler enforces this by making this a pointer to const:

c++
struct Sales_data {
    string isbn() const { return bookNo; }
    // this has type: const Sales_data *const
    // can read members but cannot modify them
};

Why does this matter? If you have a const Sales_data object, you can only call const member functions on it. Without the const qualifier, isbn() would be uncallable on const objects.

Overloading on const

You can overload a member function based on whether the object is const:

c++
class Screen {
public:
    Screen &display(ostream &os)       { do_display(os); return *this; }
    const Screen &display(ostream &os) const { do_display(os); return *this; }
private:
    void do_display(ostream &os) const { os << contents; }
};

Chapter 3: Encapsulation

Encapsulation hides a class's implementation from its users. Users interact only through the public interface. The implementation can change without breaking any code that uses the class.

Access Specifiers

c++
class Sales_data {
public:                       // interface
    Sales_data() = default;
    string isbn() const { return bookNo; }
    Sales_data &combine(const Sales_data&);
private:                      // implementation
    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

Chapter 4: Constructors

A constructor initializes a newly created object. It has the same name as the class and no return type. Every class needs at least one. If you don't write any, the compiler generates a synthesized default constructor.

c++
class Sales_data {
public:
    Sales_data() = default;                   // synthesized default
    Sales_data(const string &s): bookNo(s) {} // initializer list
    Sales_data(const string &s, unsigned n, double p):
        bookNo(s), units_sold(n), revenue(p * n) {}
    Sales_data(istream &is);                   // reads from stream
private:
    string bookNo;
    unsigned units_sold = 0;  // in-class initializer
    double revenue = 0.0;
};

Constructor Initializer List

The colon after the parameter list introduces the constructor initializer list. Each member is initialized directly with the given value. This is more efficient than assigning inside the body, because it initializes rather than default-constructs-then-assigns.

= default

= default tells the compiler to generate the default constructor even though you've defined other constructors. Without it, defining any constructor suppresses the synthesized default constructor.

Chapter 5: Friends

Sometimes a non-member function or another class needs access to private members. Instead of making the data public, you can declare that function or class as a friend:

c++
class Sales_data {
    friend Sales_data add(const Sales_data&, const Sales_data&);
    friend ostream &print(ostream&, const Sales_data&);
    friend istream &read(istream&, Sales_data&);
public:
    // ... constructors and member functions ...
private:
    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

Friend Classes

You can also declare an entire class as a friend, giving all of its member functions access to the private members of the granting class:

c++
class Screen {
    friend class Window_mgr;  // Window_mgr can access Screen's privates
    // ...
};

Chapter 6: Class Memory Layout

Let's visualize how a class object actually lives in memory. A Sales_data object occupies a contiguous block on the stack (or heap). Each data member is laid out in order, with potential padding bytes added by the compiler for alignment.

Chapter 7: static Members

Sometimes a piece of data belongs to the class itself, not to any particular object. A static member exists once, regardless of how many objects exist. Think of it as a class-wide variable.

c++
class Account {
public:
    void calculate() { amount += amount * interestRate; }
    static double rate() { return interestRate; }
    static void rate(double);
private:
    string owner;
    double amount;
    static double interestRate;  // shared by ALL Account objects
    static double initRate();
};

Key Differences from Regular Members

Chapter 8: Beyond — Connections

This chapter introduced the mechanics of classes: how the this pointer connects member functions to objects, how access specifiers enforce encapsulation, how constructors initialize objects, and how friends and static members extend the design.

Continue Reading

Next up: Chapter 9: Sequential Containers — the library types that use classes to manage data for you.