[ＭＥＭＢＥＲＳ]
[ＣＬＡＳＳＥＳ]
[ＩＮＴＥＲＦＡＣＥ]
[ＣＴＯＲＳ]
[ＲＩＤＤＬＥＳ]
100
// DATA TYPE: FUNCTIONThese are the set of functions that define the behavior of all objects in a class.
Member Functions
100
// PARADIGMA programming style in which tasks are solved by collaborating objects.
Object-Oriented Programming
100
// ACCESSThis consists of all member functions that a user may apply to objects.
Public Interface
100
// INITThis special function is called automatically to initialize data members.
Constructor
100
/* RIDDLE */I share my name with the class and I am not a function you call manually.
Constructor
200
// TYPE: GETTERA member function that retrieves information from an object without changing its state.
Accessor
200
// DEFINITIONA programmer-defined type that describes a set of objects with the same behavior.
Class
200
// SECURITYData members are placed here to hide implementation details from the program.
Private Section
200
// NAME RULEThis is how the compiler identifies a constructor — it must match this exactly.
Class Name
200
/* RIDDLE */I am the keyword used to protect data members from being seen by main().
Private
300
// TYPE: SETTERA member function, such as reset() or addItem(), that changes the object's data.
Mutator
300
// CODE ANALYSISIn the code Counter tally;, tally represents this specific realization of a class.
Object
300
// DOT OPERATORThis specific notation  .  is used to invoke a member function on an object.
Dot Notation
300
// EXCEPTIONUnlike other functions, constructors are unique because they do not have this.
Return Type
300
/* RIDDLE */If a class is a “Cookie Cutter,” I am the actual “Cookie” in memory.
Object
400
// OPERATORThis specific symbol :: links a function definition to its class.
Scope Resolution Operator
400
// STATEAn object stores its current condition or “state” in these storage locations.
Data Members
400
// ROLESThis is the term for a programmer who uses a class that someone else defined.
Class User
400
// VOID CTORThis constructor is called when you define an object without parameters.
Default Constructor
400
/* RIDDLE */I am the “state” of a CashRegister — the two variables tracked inside.
item_count and total_price
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
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)
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)
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
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
M
e
n
u