Structuring Data with Classes & Structs

The Problem: Disorganized Data

Imagine we're tracking a player in a game. We might have several variables:

// In our main function or somewhere global
int playerX = 5;
int playerY = 10;
int playerSpeed = 2;

Now, if we want a function to move the player, we have to pass all these variables to it:

void movePlayer(int& x, int& y, int speed, int deltaX, int deltaY) {
    x += deltaX * speed;
    y += deltaY * speed;
}

// In main...
movePlayer(playerX, playerY, playerSpeed, 1, -1);

This is already getting messy. What if we add health, armor, or an inventory? The number of parameters would explode, making the code hard to read, maintain, and prone to errors. This is the exact problem we want to solve.

The solution is to group related data and the functions that act on it into a single entity. C++ provides two primary keywords for this: struct and class.

From Data Aggregation to Bundled Behavior

Let's start by watching a video that perfectly illustrates this progression from scattered variables to an organized object.

As the video explained, the core idea of object-oriented programming is to combine data (member variables) and the operations on that data (member functions) into a single user-defined type.

Let's break down the C++ syntax for this.

C++ Structs: More Than Just Data

In C, a struct is purely for grouping data. In C++, a struct can do much more—it can have member functions, just like a class.

Here’s a simple Point struct that contains both data (x, y) and behavior (print):

#include <iostream>

struct Point {
    float x, y;

    // A member function to print the Point's coordinates.
    // Notice it can directly access 'x' and 'y' of the object it's called on.
    void print() {
        std::cout << "Point(" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Point p = {10.0f, 20.0f}; // C-style aggregate initialization

    p.x = 15.0f; // Accessing a member variable with the dot operator
    
    p.print();   // Calling a member function with the dot operator
    // Output: Point(15, 20)

    return 0;
}

This is a huge improvement! The print logic is now intrinsically linked to the Point data. Anyone who has a Point object automatically has the ability to print it.

struct vs. class: The Key Difference

You saw the class keyword in the video, and we just used struct. In C++, they are almost identical. There is only one technical difference:

• class: Members are private by default.
• struct: Members are public by default.

What do public and private mean? They are access specifiers that control visibility.

• public: Members can be accessed from anywhere—both inside and outside the class.
• private: Members can only be accessed by other member functions of the same class.

This concept of hiding data is called encapsulation. It's a cornerstone of robust software design. By making data private, you prevent outside code from putting your object into an invalid or inconsistent state. You expose a public set of functions that provide controlled access to that data.

This next video clarifies the struct vs. class distinction and the semantic conventions for using them.

For a more in-depth text-based explanation that bridges from C-style thinking to C++, the following article is a great resource.

Designing Our TelemetryEvent Class

Now, let's apply these concepts to our project. We need a type to represent a single event captured by our profiler. Given that an event will have internal state (timestamp, event type, payload data) and associated logic (serialization, formatting), a class is the more appropriate choice, following the convention of using classes for objects with behavior and invariants.

Let's define a basic TelemetryEvent class.

#include <iostream>
#include <cstdint> // For integer types like uint64_t

class TelemetryEvent {
// By default, everything after this is private in a class.

// --- Private Members: The internal data of the object ---
// No one outside this class can touch these directly.
uint64_t timestamp;
uint32_t event_id;
const char* message;

public:
    // --- Public Members: The public "interface" or "API" ---
    // This is how other parts of our code will interact with a TelemetryEvent.

    // A function to initialize or update the event's state in a controlled way.
    void set(uint64_t ts, uint32_t id, const char* msg) {
        timestamp = ts;
        event_id = id;
        message = msg;
    }

    // A "read-only" function to display the event.
    // The 'const' keyword is a promise that this function will NOT modify
    // the object's member variables (timestamp, event_id, message).
    void print() const {
        std::cout << "Event ID " << event_id 
                  << " at " << timestamp 
                  << ": " << message << std::endl;
    }
};

int main() {
    TelemetryEvent my_event;

    // my_event.timestamp = 123; // ERROR! 'timestamp' is private.
    
    // We must use the public interface.
    my_event.set(1672531200, 101, "Application Started");

    my_event.print();

    return 0;
}

The const Member Function

Notice the const keyword at the end of the print() function's signature. This is extremely important. It tells the compiler (and other programmers) that calling print() will not change the TelemetryEvent object.

This has two benefits:

1. Safety: It prevents you from accidentally changing state in a function that's only supposed to read data.
2. Flexibility: It allows you to call this function on const objects. Remember from our last lesson how we pass large, read-only objects by const reference for efficiency?

   // This function call is only possible because print() is marked as const.
   void displayEvent(const TelemetryEvent& event) {
       event.print(); 
   }
   

#include <cstdint>

// A dummy function for the example.
uint64_t get_current_time() { return 0; }

class Stopwatch {
private:
    uint64_t start_time;
    uint64_t end_time;

public:
    void start() {
        start_time = get_current_time();
    }

    void stop() {
        end_time = get_current_time();
    }

    // This function is const because it only reads the member variables
    // to perform a calculation; it doesn't change them.
    uint64_t getElapsedTime() const {
        return end_time - start_time;
    }
};

Conclusion

You've made a significant leap forward today. You've moved from manipulating simple data types to defining your own complex types that bundle data and behavior together. This is the essence of building abstractions, which is critical for managing the complexity of any large software project like our telemetry engine.

Key Takeaways:

• struct and class are C++ keywords used to define custom types that group member variables and member functions.
• The only technical difference is default visibility: struct members are public by default, while class members are private by default.
• Encapsulation (using private) is a powerful technique for protecting an object's internal data and ensuring it remains in a valid state. You provide public functions as a controlled interface.
• Member functions are functions that "belong" to a class and operate on its data.
• const member functions are a promise that they will not modify the object's state, which is crucial for both safety and for working with const references.

In this lesson, we created objects like TelemetryEvent my_event; on the stack. But what if we need an object to live longer than the function it was created in? Where in memory do these objects reside? Our next lesson, "Explain the difference between stack and heap allocation and manage memory with new/delete," will tackle these exact questions. This is a vital topic for a high-performance system where you need absolute control over the lifetime and memory location of your data.