Introduction to Object-Oriented Programming

Throughout this tutorial series, we've written programs that consist of functions operating on data. We define variables to hold data, then pass that data to functions that process it and return results. This style is called procedural programming.

In procedural programming, data and the functions that work on that data are separate. You, the programmer, must combine them correctly to make your program work. Code typically looks like this:

updateBalance(account, 50.00);
calculateInterest(account);

While this works, it doesn't mirror how we think about the real world.

How we think about objects

Look around your environment. You see physical objects everywhere—a laptop, a mug, a desk. Each object has properties (color, weight, temperature) and behaviors (a mug holds liquids, a laptop processes information).

Critically, an object's properties and behaviors are inseparable. You don't think of "laptop" and "processes information" as separate things—the ability to process information is what makes it a laptop.

Procedural programming separates these concepts:

  • Properties become separate variables
  • Behaviors become separate functions

This separation doesn't match our mental model of how things work.

Object-oriented programming

Object-oriented programming (OOP) addresses this by bundling properties and behaviors together into unified entities. Instead of separating data and functions, OOP groups them into program-defined types that represent real-world concepts.

With OOP, code reads more naturally:

account.deposit(50.00);
account.calculateInterest();

The subject (account) clearly owns the behaviors (deposit, calculateInterest). This style better mirrors how we conceptualize the problem we're solving.

Benefits of OOP

Better organization: Related data and functions live together, making code easier to navigate and understand.

Improved modularity: Objects encapsulate their internals, letting you treat them as black boxes. You interact with well-defined interfaces without needing to know implementation details.

Enhanced reusability: Well-designed objects can be reused in different contexts. A BankAccount object works the same whether it's in a mobile app or a desktop program.

More intuitive: Code reads like natural language—"the car accelerates" rather than "accelerate the car."

Comparing styles

Let's examine the difference with a concrete example. Consider a program that handles different vehicles.

Procedural approach:

#include <iostream>
#include <string_view>

enum VehicleType
{
    car,
    truck,
    motorcycle
};

std::string_view getVehicleName(VehicleType type)
{
    switch (type)
    {
    case car: return "Car";
    case truck: return "Truck";
    case motorcycle: return "Motorcycle";
    default: return "Unknown";
    }
}

int getWheelCount(VehicleType type)
{
    switch (type)
    {
    case car: return 4;
    case truck: return 6;
    case motorcycle: return 2;
    default: return 0;
    }
}

void describeVehicle(VehicleType type)
{
    std::cout << getVehicleName(type) << " has "
              << getWheelCount(type) << " wheels\n";
}

int main()
{
    VehicleType myRide{ car };
    describeVehicle(myRide);

    return 0;
}

The data (VehicleType) and behaviors (getVehicleName, getWheelCount) are completely separate. Adding a new vehicle type requires modifying multiple functions.

Object-oriented approach:

#include <iostream>
#include <string_view>

struct Vehicle
{
    std::string_view name{};
    int wheels{};

    void describe()
    {
        std::cout << name << " has " << wheels << " wheels\n";
    }
};

int main()
{
    Vehicle myRide{ "Car", 4 };
    myRide.describe();

    return 0;
}

The data (name, wheels) and behavior (describe) are unified. The Vehicle object knows everything about itself.

Key differences

Procedural:

  • Separate data structures and functions
  • Functions operate on data passed to them
  • Global functions that work with specific types
  • Adding features requires modifying multiple places

Object-oriented:

  • Combined data and functions (called "members")
  • Objects contain their own behaviors
  • Methods (functions) operate on their own data
  • Adding features often means adding to one object

Moving forward

Object-oriented programming isn't inherently better than procedural programming for all situations. However, OOP excels at modeling complex systems with many interacting entities. As your programs grow larger, OOP's organizational benefits become increasingly valuable.

In upcoming lessons, you'll learn how to create your own custom types (classes) that bundle data and functions together, implementing OOP principles in C++.

Core Understanding

Object-oriented programming groups related data and behaviors into cohesive units (objects), making code more intuitive and easier to maintain.

Summary

Procedural programming separates data and functions, requiring programmers to manually combine them correctly. Data is stored in variables and passed to separate functions for processing.

Object-oriented programming (OOP) bundles properties and behaviors together into unified entities called objects, mirroring how we conceptualize real-world things.

Real-world modeling shows that objects have inseparable properties and behaviors—a laptop's ability to process information is fundamental to what makes it a laptop.

Better organization results from grouping related data and functions together, making code easier to navigate and understand.

Improved modularity allows treating objects as black boxes with well-defined interfaces, hiding implementation details and reducing coupling between components.

Enhanced reusability comes from well-designed objects working the same way in different contexts, enabling code reuse across applications.

More intuitive code reads like natural language—"the account deposits" rather than "deposit the account"—making programs easier to understand and maintain.

Comparing styles reveals that procedural code spreads related functionality across multiple functions and requires modifying several places to add features, while OOP consolidates functionality within objects.

When to use OOP depends on the problem—OOP excels at modeling complex systems with many interacting entities, though it's not inherently better than procedural programming for all situations.

Object-oriented programming provides powerful organizational tools that become increasingly valuable as programs grow in size and complexity, enabling developers to manage complexity through encapsulation and intuitive modeling.