Classes

What Is a Class?

A class is a blueprint or template that describes how a certain type of object will look and behave in your program.
A class is not the object itself; it is the definition that tells the system how to create objects of that type.

Each class typically contains two main things:

• Data (attributes): the information that each object of that class will store. For example, a user might store name, email, and id.

• Behavior (methods): what the object can do, like login(), updateProfile(), or calculateTotal().

In Low Level Design, the main entities in a problem usually become classes.
For example, in a booking system, entities like User, Order, Booking, or Payment often become separate classes that work together.

Why Classes Matter in LLD

Classes help you organize your code in a way that is easy to understand, extend, and maintain.

By using classes, you:

• Group related data and behavior together under one clear name.

• Hide internal details from other parts of the system (encapsulation).

• Reuse the same structure by creating many objects from a single class.

• Make it easier to model real‑world problems directly in code.

Because of this, understanding classes clearly is the first big step toward solving LLD interview problems like parking lots, elevators, hotel bookings, and more.

How to Think About a Class in LLD

When you are designing a system from an LLD perspective, think of each class as representing a real‑world concept.
Follow a simple mental flow:

1. Identify the entity

   • What main concept appears often in the problem?

   • Examples: User, Order, Product, Booking, Ticket, Vehicle.

2. Ask what data it needs.

   • What information does that entity hold?

   • Examples: id, name, price, status, createdAt.

3. Ask what actions it can perform.

   • What can this entity do?

   • Examples: create(), cancel(), confirm(), update(), calculate().

4. Put them together into one class.s

   • Collect that data and those methods under one class name.

Later, you will also think about how classes relate to each other, but for now, focus on getting comfortable with a single class.

Basic Structure of a Class in C++

Most object‑oriented languages follow a similar pattern for defining a class.

Here is the same structure expressed in C++ style syntax:

Break this down into four parts:

1. Class declaration

• class ClassName { ... }; defines a class.

• ClassName should be a noun that clearly describes the entity (User, Order, Booking).

2. Attributes (data inside the class)

In C++, you declare attributes inside the class body, usually under private:

Each object created from this class will have its own copies of these attributes.

3. Public vs private

C++ groups members under public: or private::

• private

  • Only code inside the class can access these members.

  • Other classes cannot see or change them directly.

• public

  • Code outside the class can access them.

  • Usually used for methods that other parts of the system need to call.

Best practice:

• Keep attributes private.

• Provide public methods (getters, setters, or business methods) to control how the data is accessed or changed.

Example:

This keeps the data protected and your design easier to evolve later.

4. Constructor

In C++, constructors have the same name as the class and no return type:

• The initializer list (: id(id), name(name), ...) sets up the attributes.

• isActive is set  true by default.

Now you can create objects like this:

Each object is created with its own data.

Writing Methods Inside a Class in C++

Methods define what an object can do.
You can declare them under public: and implement them either inside or outside the class.

Extend the User class:

Now you can use it:

This is how you move from understanding what a class is to actually writing and using one in C++.

A More LLD‑Style Example: Order Linked to User in C++

Now let’s connect two classes in a small LLD‑style scenario: a simple order or booking system.

Entities:

• User (who places the order)

• Order (the booking or purchase)

First, reuse the User class we already designed.
Then define the Order class:

Now you can link objects together:

Here you can see how classes and objects work together in a small, real‑world‑style problem in C++.

Common Mistakes When Writing Classes in LLD

When beginners start using classes in LLD, they often make a few repeating mistakes.

• Putting too much in one class

  • Mixing user, order, payment, and notification logic in a single class.

  • Better: separate concerns into User, Order, Payment, NotificationService.

• Making all attributes public

  • Letting any part of the code directly read and change them.

  • Better: keep attributesprivate, expose behavior through carefully designed methods.

• Not using constructors properly

  • Creating objects with required fields left uninitialized.

  • Better: use constructors to set up essential state at creation time.

• Using vague class names

  • Names like Manager, Handler, Wrapper, which do not clearly represent an entity.

  • Better: use concrete names like BookingService, Ticket, ParkingSlot.

Being aware of these pitfalls helps you write cleaner, more interview‑ready classes.

Summary

A class is a blueprint that defines both the data (attributes) and behavior (methods) of a kind of object in your program.
In LLD, classes are the main building blocks for modeling real‑world entities such as User, Order, Booking, or Payment.

You now know:

• What a class is and why it matters in LLD.

• The basic structure of a class in C++: class name, private attributes, public methods, and constructors.

• The meaning of public and private and why you usually keep data private.

• How to write a complete class step‑by‑step and create objects from it in C++.

• How classes can be linked together, as in a simple user–order system.

With this solid understanding of classes, you are ready to move to the next topic: how classes relate to each other (relationships, composition, and inheritance) in Low Level Design.