08 Classes and Objects

From Classes to Objects

A class is a user-defined type, while an object is an instance of that type. The class describes the available data and operations; each object stores its own state in storage.

A class definition contains a name and a body of member declarations. The semicolon after the closing brace is required. For example, a Rectangle class can declare public double members named width and height. After the definition, Rectangle first; and Rectangle second; create two objects of the same type. Assigning first.width = 4.0 does not change second.width because the objects have separate non-static state.

A member function can be defined inside the class or outside it. An outside definition identifies the class with the scope-resolution operator ::; a declaration such as double area() const; can be defined as double Rectangle::area() const. A member function defined inside a class definition is implicitly inline when appropriate.

Takeaway: A class defines a type, and an object is a concrete instance with its own state and lifetime.

State and Behavior

Data members represent an object's state. They may have fundamental types, library types, arrays, pointers, or other class types. Every object normally has its own non-static data members, so an Account object can have its own owner, balance, and number independently of other accounts.

A default member initializer supplies a starting value when a constructor does not provide another one. For example, declaring int value = 0; inside a Counter class makes the default state explicit and helps prevent an uninitialized value.

A Member function defines behavior associated with a class. It operates on a particular object when called with the member-access operator, as in account.deposit(50.0). Inside a non-static member function, the implicit this pointer refers to the object on which the function was called, so balance and this->balance refer to the same member in that context.

A const member function promises not to modify the observable state of the object through which it is called. Marking a read-only operation with const allows it to be called on both ordinary and const objects, while a non-const operation generally cannot be called on a const object.

Takeaway: Data members store state, member functions provide behavior, and const communicates that an operation is read-only.

Access Control and Interfaces

Access control determines which code may use each member. public members are accessible from code that can name the object. private members are accessible only to members and friends of the class. protected members are accessible to the class, its friends, and derived classes.

Access specifiers apply to the declarations that follow them until another access specifier appears. Members of a class are private by default, whereas members of a struct are public by default. A class commonly places its public interface first and its implementation details under private.

For example, a Person class can expose set_age(int) and get_age() const as public functions while keeping int age = 0 private. The setter can accept a new value only when it satisfies the class's rule, such as being nonnegative. Outside code can call person.set_age(25) and person.get_age(), but it cannot directly assign person.age.

This separation makes the public operations the interface and keeps representation details hidden. It prevents outside code from bypassing rules that protect a valid object state.

Takeaway: Use public members for intentional operations and private members to protect representation and validity rules.

Constructors and Initialization

A constructor initializes an object automatically when it is created. Its name matches the class name, and it has no return type. Constructors may be overloaded so that objects can be created with different sets of initial values.

For example, a Point class can provide Point() to create the origin and Point(int initial_x, int initial_y) to initialize a chosen location. Point origin; calls the no-argument constructor, while Point location(3, 4); calls the two-argument constructor.

The member initializer list is the portion after the constructor declaration that initializes members before the constructor body runs. It is the preferred mechanism for initializing members, especially const members, reference members, and members whose types do not have a default constructor.

Members are initialized in the order in which they are declared in the class, regardless of the order written in the initializer list. Declare members in a logical dependency order and write the initializer list in that same order.

A constructor with no required arguments is a default constructor. A constructor can also be marked explicit to prevent unintended implicit conversions. With explicit Meters(double value), Meters distance(5.0); is valid, while Meters distance = 5.0; is rejected.

Takeaway: Constructors establish initial state, and member initializer lists are the preferred way to initialize members.

Encapsulation in Practice

Encapsulation combines state and behavior while controlling how state is accessed. A common design keeps data members private and exposes public member functions that enforce the class's rules.

A BankAccount can store a private double balance and provide deposit, withdraw, and get_balance operations. The constructor can replace a negative initial balance with 0.0. A withdrawal can return false when its amount is negative or greater than the current balance; otherwise, it subtracts the amount and returns true. A deposit can accept only an amount that satisfies its validation rule.

Outside code therefore depends on operations rather than on the representation of the balance. It cannot directly assign an invalid value, and the implementation can change later without requiring changes to code that uses the public interface.

Encapsulation protects an invariant: a condition that should remain true for a valid object. Validation at the class boundary ensures that public operations preserve that condition.

Takeaway: Encapsulation protects invariants and reduces coupling by giving users a deliberate, stable interface.

Object Lifetime and Resource Management

Object lifetime begins after storage has been obtained and initialization is complete. For a class object, construction establishes the initial state. The lifetime ends when destruction begins or when the object's storage is released or reused.

An automatic object declared inside a block is constructed when execution reaches its declaration and is usually destroyed when execution leaves that block. For example, a local BankAccount account(100.0); can receive a deposit and then be destroyed automatically when process ends.

An object created with new has dynamic storage duration and remains alive until it is destroyed with delete. In modern C++, owning raw pointers should generally be replaced with resource-managing types such as std::unique_ptr and std::make_unique. An object held by std::unique_ptr is destroyed automatically when the owning pointer leaves its scope.

An object declared at namespace scope or with static can have static storage duration. Such an object is initialized before or during program startup and destroyed during program termination, subject to the language's initialization rules.

A destructor is written with the class name preceded by ~, such as ~Logger(). It can release resources owned by an object. Many classes need no user-written destructor because members such as std::string, std::vector, and smart pointers clean themselves up automatically. This automatic resource management is the basis of RAII.

Using an object after its lifetime has ended, such as dereferencing a pointer to a destroyed object, produces undefined behavior.

Takeaway: Prefer ownership types that make destruction automatic, and never use an object after its lifetime has ended.

Putting the Design Together

A complete design connects private state, construction, controlled operations, and automatic cleanup. Consider a Student class with private std::string name, int id, and double grade data members.

Its constructor can initialize name and id through a member initializer list. A set_grade member function can accept a new value only when it is between 0.0 and 100.0, preserving the class's validity rule. A print const member function can report the state without modifying the object.

A typical use creates `Student student(