◤━━ UNIT 9: STRUCTURES ━━◥

[ＭＥＭＢＥＲＳ]

100

// DATA TYPE: FUNCTIONThese are the set of functions that define the behavior of all objects in a class.

Member Functions

200

// TYPE: GETTERA member function that retrieves information from an object without changing its state.

Accessor

300

// TYPE: SETTERA member function, such as reset() or addItem(), that changes the object's data.

Mutator

400

// OPERATORThis specific symbol :: links a function definition to its class.

Scope Resolution Operator

500

👻 G H O S T  P R O T O C O L 👻

Inside a member function, calling add_item(price) requires no dot notation — yet it still knows exactly which object's item_count and total_price to modify.

This is because every member function secretly receives THIS hidden object reference.

The Implicit Parameter

[ＣＬＡＳＳＥＳ]

100

// PARADIGMA programming style in which tasks are solved by collaborating objects.

Object-Oriented Programming

200

// DEFINITIONA programmer-defined type that describes a set of objects with the same behavior.

Class

300

// CODE ANALYSISIn the code Counter tally;, tally represents this specific realization of a class.

Object

400

// STATEAn object stores its current condition or “state” in these storage locations.

Data Members

500

⬡E N T I T Y  R E P L I C A T O R⬡

From the clock analogy: all clocks tick identically but display different times. In C++, each of THESE stores a fully independent copy of every data member in memory — two CashRegister objects can simultaneously ring up different sales because modifying one's item_count never affects the other's.

Objects (or Instances)

[ＩＮＴＥＲＦＡＣＥ]

100

// ACCESSThis consists of all member functions that a user may apply to objects.

Public Interface

200

// SECURITYData members are placed here to hide implementation details from the program.

Private Section

300

// DOT OPERATORThis specific notation  .  is used to invoke a member function on an object.

Dot Notation

400

// ROLESThis is the term for a programmer who uses a class that someone else defined.

Class User

500

📐  T H E   A R C H I T E C T  📐

You are the class implementer. A class user will never see your private section — only the public interface. To let them safely call add_item(double price), you write THESE above each public declaration. According to proper interface design, they must document exactly three things: the function's purpose, its parameter(s), and the third required element.

Documentation Comments
(purpose • parameters • return value)

[ＣＴＯＲＳ]

100

// INITThis special function is called automatically to initialize data members.

Constructor

200

// NAME RULEThis is how the compiler identifies a constructor — it must match this exactly.

Class Name

300

// EXCEPTIONUnlike other functions, constructors are unique because they do not have this.

Return Type

400

// VOID CTORThis constructor is called when you define an object without parameters.

Default Constructor

500

⚙ C O M P I L E R|O V E R L O R D ⚙

A BankAccount class declares two constructors — same class name, no return type. Default: no params, balance = 0. Second: takes a double and sets it. Writing BankAccount savings(500.00); triggers the second; BankAccount checking; triggers the first. What does the compiler examine exclusively to decide?

The Arguments Supplied

[ＲＩＤＤＬＥＳ]

100

/* RIDDLE */I share my name with the class and I am not a function you call manually.

Constructor

200

/* RIDDLE */I am the keyword used to protect data members from being seen by main().

Private

300

/* RIDDLE */If a class is a “Cookie Cutter,” I am the actual “Cookie” in memory.

Object

400

/* RIDDLE */I am the “state” of a CashRegister — the two variables tracked inside.

item_count and total_price

500

🔐  T H E   V A U L T  🔐

I am the reason you can use cin without knowing how it reads from a keyboard — and drive a car without understanding the engine. In C++, I lock item_count and total_price in the private section so a class user cannot corrupt the object's state — they may only interact through the public member functions.

Encapsulation