{"title":"Classes & Objects","description":null,"content":"A class is the C++ tool for describing a kind of thing once and creating many instances of it. Where a struct is usually just a bundle of data, a class is what most C++ code reaches for when a type carries both data and the operations that go with it. This lesson covers what a class is, how to define one, how to create objects on the stack and the heap, how to access their members, and how to split a class across header and implementation files. Constructors, destructors, access modifiers, and the rest of the OOP machinery get their own dedicated chapters; here we're staying at the level of \"what is a class and how do you use one\".\n\n---\n\n# What a Class Is\n\nA class is a user-defined type. It tells the compiler that \"a `Product` is a thing that has a name, a price, a stock count, and the following operations: print itself, restock, mark out of stock\". The class itself isn't a product; it's the description. You then create **objects** (also called **instances**) of that class. Each object is a separate `Product` with its own name, its own price, its own stock count.\n\nThe class-vs-object distinction is the one to internalize first. The class is the blueprint. The object is the thing built from the blueprint. From one `Product` class, you can create thousands of `Product` objects, each independent.\n\n\n```mermaid\nflowchart LR\n BP[Product class
blueprint]:::cyan --> O1[mouse object
name: Wireless Mouse
price: 24.99
stock: 50]:::orange\n BP --> O2[keyboard object
name: Mechanical Keyboard
price: 89.99
stock: 12]:::orange\n BP --> O3[cable object
name: USB Cable
price: 7.49
stock: 100]:::orange\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe class on the left says \"this is what a product looks like\". The three objects on the right are separate values that all match that description. They share a layout, not their data.\n\nWhy do this at all? Two reasons. First, it lets the code talk in domain terms (`Product`, `Cart`, `Order`) instead of loose primitives. A function that takes a `Product` is clearly about products, not about a string, a double, and an int that just happen to be related. Second, a class can keep its data and the operations on that data together, so calling `mouse.restock(10)` is right next to the field it modifies.\n\n---\n\n# Defining a Class\n\nHere's a minimal `Product` class with three data members and two member functions.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n void print() {\n std::cout << name << \" | $\" << price << \" | stock \" << stock << std::endl;\n }\n\n void restock(int amount) {\n stock = stock + amount;\n }\n};\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\";\n mouse.price = 24.99;\n mouse.stock = 50;\n\n mouse.print();\n mouse.restock(10);\n mouse.print();\n return 0;\n}\n```\n\n\nThe pieces:\n\n- `class Product { ... };` declares a new type named `Product`. The trailing semicolon after the closing brace is required, same as for structs.\n- The fields (`name`, `price`, `stock`) are **member variables** (also called **data members** or **fields**). Each object of the class gets its own copy of every member variable.\n- The functions (`print`, `restock`) are **member functions** (also called **methods**). When called through an object, they operate on that object's data.\n- The `public:` label says \"everything below me can be used from outside the class\". Without it, the members would be private by default and `main` couldn't touch them. The full mechanics of public, private, and protected come later in this section; for now, marking everything `public:` keeps the examples readable.\n\nInside `print()`, the names `name`, `price`, and `stock` refer to the data members of whichever object the function was called on. `mouse.print()` reads `mouse.name`, `mouse.price`, `mouse.stock`. Calling the same function through a different object reads different data. The function is shared across all objects; the data is not.\n\n---\n\n# Creating Objects on the Stack\n\nThe simplest way to create an object is to declare it as a local variable. The object lives on the **stack**, which is the region of memory that holds local variables and function call frames. Its lifetime is tied to the surrounding scope: when the function returns or the block ends, the object is destroyed automatically.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\";\n mouse.price = 24.99;\n mouse.stock = 50;\n\n Product keyboard;\n keyboard.name = \"Mechanical Keyboard\";\n keyboard.price = 89.99;\n keyboard.stock = 12;\n\n std::cout << mouse.name << \" $\" << mouse.price << std::endl;\n std::cout << keyboard.name << \" $\" << keyboard.price << std::endl;\n return 0;\n}\n```\n\n\nBoth `mouse` and `keyboard` live on the stack inside `main`. They're separate objects, each with its own copies of `name`, `price`, and `stock`. When `main` returns, both objects are destroyed automatically. The string memory inside `name` is also cleaned up at the same time, because `std::string` knows how to free its own buffer.\n\nStack allocation is the default and what most local code should reach for. It's fast (just a pointer bump), and the cleanup is automatic, so there's no way to forget to destroy the object.\n\n---\n\n# Creating Objects on the Heap\n\nThe other place an object can live is the **heap**, which is a region of memory you allocate explicitly and manage yourself. You ask for an object with `new`, get back a pointer to it, and must release it later with `delete`. The object stays alive across function calls until you delete it.\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n Product* mouse = new Product;\n mouse->name = \"Wireless Mouse\";\n mouse->price = 24.99;\n mouse->stock = 50;\n\n std::cout << mouse->name << \" $\" << mouse->price << std::endl;\n\n delete mouse;\n return 0;\n}\n```\n\n\n`new Product` allocates space for one `Product` on the heap and returns a `Product*` pointing at it. The arrow operator `->` reaches into the object through the pointer (more on that below). `delete mouse` releases the heap memory and runs the cleanup that destroys the object's data members. Forgetting the `delete` leaks the memory; deleting it twice corrupts the heap. Both are undefined behavior.\n\n\n```mermaid\nflowchart LR\n subgraph Stack\n SM[mouse pointer
address: 0x7ffe...]:::cyan\n end\n subgraph Heap\n HO[Product object
name, price, stock]:::orange\n end\n SM -->|points to| HO\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe pointer variable `mouse` lives on the stack inside `main`. The actual `Product` object lives on the heap. When `main` ends, the pointer is destroyed automatically, but the heap object isn't, because the heap is not tied to scope. That's why the explicit `delete` is needed.\n\nHeap allocation is useful when an object's lifetime needs to outlast the current function, when its size isn't known at compile time, or when ownership is being passed around. The downsides are real: every `new` needs a matching `delete`, and getting that wrong is one of the most common sources of bugs in older C++ code. Modern C++ avoids raw `new`/`delete` in favor of smart pointers (`std::unique_ptr`, `std::shared_ptr`), which automate the cleanup. For this lesson, raw `new`/`delete` is fine to see the mechanics.\n\n\n> **INFO**\n>\n> **Cost:** Stack allocation is essentially free, a single subtraction from the stack pointer. Heap allocation calls into the allocator (typically `malloc` under the hood) and can take hundreds of cycles, more if the allocator has to fall back to the operating system. Prefer the stack when an object's lifetime fits a scope.\n\n\n---\n\n# Accessing Members with `.` and `->`\n\nThere are two operators for reaching into an object's members, and which one you use depends on whether you have the object or a pointer to it.\n\n- **Dot operator `.`** is used when you have the object directly (or a reference to it).\n- **Arrow operator `->`** is used when you have a pointer to the object. It's shorthand for \"dereference the pointer, then apply the dot\".\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n};\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\"; // object: use the dot\n mouse.price = 24.99;\n\n Product* ptr = &mouse; // pointer to the object\n ptr->price = 19.99; // pointer: use the arrow\n (*ptr).price = 17.99; // equivalent: dereference, then dot\n\n std::cout << mouse.name << \" $\" << mouse.price << std::endl;\n return 0;\n}\n```\n\n\n`ptr->price` and `(*ptr).price` mean exactly the same thing. The arrow is just easier to read and easier to type. Both modify the same `mouse` object, because `ptr` is just an alias for its address.\n\nA handy rule: if the expression on the left is a pointer, use `->`. If it's the object itself or a reference, use `.`. The compiler will flag the wrong one, but knowing the rule up front saves time. The same applies to objects created with `new`: those return pointers, so you always use `->` on them until you dereference.\n\n\n```cpp\nProduct* cable = new Product;\ncable->name = \"USB Cable\"; // arrow: cable is a pointer\ndelete cable;\n```\n\n\n---\n\n# Class Definition vs Declaration\n\nSo far the entire class has lived in one file. That works for small examples, but real codebases split a class across two files: a **header file** (`.h` or `.hpp`) that declares the class and its members, and an **implementation file** (`.cpp`) that defines what the member functions do.\n\nThe header lets other source files use the class without seeing the full implementation. The implementation file is compiled once and linked in.\n\nHere's the same `Product` class split across two files:\n\n\n```cpp\n// product.h\n#ifndef PRODUCT_H\n#define PRODUCT_H\n\n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n void print();\n void restock(int amount);\n};\n\n#endif\n```\n\n\n\n```cpp\n// product.cpp\n#include \"product.h\"\n#include \n\nvoid Product::print() {\n std::cout << name << \" | $\" << price << \" | stock \" << stock << std::endl;\n}\n\nvoid Product::restock(int amount) {\n stock = stock + amount;\n}\n```\n\n\n\n```cpp\n// main.cpp\n#include \"product.h\"\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\";\n mouse.price = 24.99;\n mouse.stock = 50;\n\n mouse.print();\n mouse.restock(10);\n mouse.print();\n return 0;\n}\n```\n\n\nCompile with:\n\n\n```shell\ng++ -std=c++17 product.cpp main.cpp -o store\n```\n\n\nA few things to unpack:\n\n- The header declares the class shape: which data members and which member functions exist. The function bodies are not in the header.\n- The implementation file uses `Product::print()` syntax (the `Product::` part is the **scope resolution operator**) to say \"this is the `print` function that belongs to `Product`\". Without that prefix, the compiler would think you're defining a free function called `print`.\n- The `#ifndef PRODUCT_H` / `#define PRODUCT_H` / `#endif` block is an **include guard**. It prevents the header's contents from being processed twice if multiple files include it, which would otherwise cause \"redefinition\" errors.\n- `main.cpp` only sees the header. It doesn't need to know how `print` is implemented to use it.\n\nYou can also leave a member function defined inline in the class body, the way the earlier examples did. Inline definitions are convenient for short functions and tell the compiler it can substitute the function body at the call site if it chooses. The trade-off is that changing the body forces every file that includes the header to recompile. As a rough rule, keep one-liners inline and put anything bigger in the `.cpp` file.\n\n---\n\n# Default Access: `struct` vs `class`\n\nIn C++, `struct` and `class` are almost the same keyword. They build the same kind of type with the same machinery: data members, member functions, inheritance, the works. The one language-level difference is the **default access level** for their members.\n\n- `struct` members are **public** by default.\n- `class` members are **private** by default.\n\n\n```cpp\n#include \n\nstruct ProductA {\n double price; // public by default (struct)\n};\n\nclass ProductB {\n double price; // private by default (class)\n};\n\nint main() {\n ProductA a;\n a.price = 24.99; // fine, struct members are public\n std::cout << a.price << std::endl;\n\n ProductB b;\n // b.price = 24.99; // compile error: 'price' is private\n return 0;\n}\n```\n\n\nUncommenting the `b.price = 24.99;` line gives an error like:\n\n\n```shell\nerror: 'double ProductB::price' is private within this context\n```\n\n\nThat's it. That's the only mandatory difference. Everything else, member functions, constructors, inheritance, the rest, works identically for both keywords.\n\nIn practice, the convention most C++ codebases follow is:\n\n- Use `struct` for small data aggregates with no real invariants. Plain old data, like a 2D point, a color, or a config record.\n- Use `class` for types with real behavior, encapsulated state, or non-trivial invariants. A `Product` with stock validation, a `ShoppingCart` with rules about adding items, an `Order` with state transitions.\n\nThe compiler doesn't care which one you pick. It's a signaling convention that helps readers know what kind of type they're looking at. The full mechanics of access modifiers, why you'd want private members in the first place, and how getters and setters interact with them, live in the access modifiers and encapsulation lessons later in this section.\n\n---\n\n# Memory Layout: A Class Is a Struct With Methods\n\nHere's a useful intuition for what a class actually is at runtime. The object's storage holds only its data members, laid out the same way a struct with those same members would be. The member functions are not stored per object; they're stored once in the code section of the program and called with a hidden \"which object\" argument.\n\n\n```cpp\n#include \n\nclass Product {\npublic:\n double price; // 8 bytes\n int stock; // 4 bytes\n\n void print() {\n std::cout << price << \" \" << stock << std::endl;\n }\n\n void restock(int amount) {\n stock = stock + amount;\n }\n};\n\nint main() {\n std::cout << \"sizeof(Product) = \" << sizeof(Product) << std::endl;\n return 0;\n}\n```\n\n\nThe size is 16 bytes: 8 for `price`, 4 for `stock`, and 4 bytes of padding so that an array of `Product` keeps `price` 8-byte aligned. There's no extra space for the functions. Two `Product` objects are 32 bytes total, not 32 plus the function code, because the functions live elsewhere in the binary.\n\n\n```mermaid\nflowchart LR\n subgraph Code[\"Program code (one copy)\"]\n F1[Product::print]:::orange\n F2[Product::restock]:::orange\n end\n subgraph Data[\"Object storage (per instance)\"]\n O1[mouse
price, stock]:::cyan\n O2[keyboard
price, stock]:::cyan\n end\n O1 -.calls.-> F1\n O1 -.calls.-> F2\n O2 -.calls.-> F1\n O2 -.calls.-> F2\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nWhen you call `mouse.print()`, the compiler effectively passes `&mouse` as a hidden argument to `print`, so the function knows which object's `price` and `stock` to read. The next lesson section in the OOP material formalizes this hidden pointer as `this`. For now, the takeaway is: an object is its data, and the functions are shared.\n\nThis is also why `sizeof(class WithMethods)` equals `sizeof(equivalent struct)`: methods don't take object space. The one exception is virtual functions, which add a single pointer (the vtable pointer) to each object. Virtual functions and inheritance are covered in later sections.\n\n---\n\n# Putting It Together: A Small Cart Example\n\nTo pull the pieces into one program, here's a tiny `Cart` class that holds a list of products and a few helpers. The example uses everything covered above: defining a class, member variables, member functions, dot access, range-based iteration over members, and a clean main.\n\n\n```cpp\n#include \n#include \n#include \n\nclass Product {\npublic:\n std::string name;\n double price;\n int stock;\n\n void print() {\n std::cout << \" \" << name << \" - $\" << price << \" (stock \" << stock << \")\" << std::endl;\n }\n};\n\nclass Cart {\npublic:\n std::vector items;\n\n void add(Product p) {\n items.push_back(p);\n }\n\n double total() {\n double sum = 0.0;\n for (Product& item : items) {\n sum = sum + item.price;\n }\n return sum;\n }\n\n void print() {\n std::cout << \"Cart contents:\" << std::endl;\n for (Product& item : items) {\n item.print();\n }\n std::cout << \"Total: $\" << total() << std::endl;\n }\n};\n\nint main() {\n Product mouse;\n mouse.name = \"Wireless Mouse\";\n mouse.price = 24.99;\n mouse.stock = 50;\n\n Product keyboard;\n keyboard.name = \"Mechanical Keyboard\";\n keyboard.price = 89.99;\n keyboard.stock = 12;\n\n Cart cart;\n cart.add(mouse);\n cart.add(keyboard);\n cart.print();\n return 0;\n}\n```\n\n\nA few things to notice. `Cart` holds a `std::vector` as a member, so each `Cart` object has its own independent list of products. The `add` function takes a `Product` by value, which means `cart.add(mouse)` copies `mouse` into the cart; later changes to `mouse` won't affect the cart's copy. `Cart::print` calls `Product::print` on each item, which shows methods working together cleanly. `total()` uses a range-based loop over the cart's own `items` member, no other state needed.\n\n\n> **INFO**\n>\n> **Cost:** `void add(Product p)` copies the product on every call, including allocating new memory for the `std::string name`. For a busy cart, switching the parameter to `const Product& p` and then `items.push_back(p)` avoids one copy per call. By-value is shown here for simplicity.\n\n\nThis is a workable shape for a class even before constructors. The next several lessons fill in the parts that make it more robust: setting up an object's state in one go (constructors), making sure resources are released cleanly (destructors), copying objects correctly, and protecting the internals from the outside world.\n\n---\n\n# Summary\n\n- A class is a user-defined type that bundles data (member variables) and behavior (member functions) under one name. An object is one specific instance of a class, with its own storage for each member variable.\n- Member variables hold per-object data; member functions are shared across all objects and operate on the object they're called on. `sizeof(Class)` is determined by the data members, not the function count.\n- Stack-allocated objects (`Product p;`) live in the surrounding scope and are destroyed automatically when the scope ends. Heap-allocated objects (`new Product`) live until you explicitly `delete` them, and they're reached through pointers.\n- Use the dot operator `.` to access members through an object or reference, and the arrow operator `->` to access them through a pointer. `ptr->name` is shorthand for `(*ptr).name`.\n- A class can be split between a header file (declarations) and an implementation file (function bodies). The implementation file uses the `Class::function` syntax to attach a definition to a class member.\n- `struct` defaults to public member access; `class` defaults to private. That's the only mandatory difference; otherwise the two keywords build the same kind of type. Convention is to use `struct` for plain data and `class` for types with real behavior.\n- Conceptually, a class is a struct plus methods. The object's storage is its data; the methods live once in the binary and receive a hidden pointer to the object they were called on.\n\nIn the next lesson, we'll look at **Constructors**, which let an object be set up with valid data in one step rather than assigning to each field separately after creation.","pageType":"cpp"}

Classes & Objects

Get Premium