Data Types and Variables

What are Variables?

At a high level, a variable is a named piece of storage in the computer's memory. The data type of a variable tells the compiler two crucial things:

1. How much memory to allocate for the variable.
2. What kinds of operations are valid for that variable.

Think of it as a set of labeled boxes, where each box is designed to hold a specific kind of item.

To get a solid introduction to variables and the primary data types, let's start with a video.

As the video explained, you declare a variable by specifying its type, giving it a name, and optionally providing an initial value.

The classic way is using the assignment operator (=):
int my_number = 42;

However, a more modern and generally safer approach in C++ is to use uniform initialization with curly braces {}:
int my_number{42};

We recommend using this style as it helps prevent certain types of bugs, like accidental "narrowing" conversions (e.g., trying to fit a large number into a smaller type).

The Fundamental Data Types

C++ provides a set of built-in types for handling integers, floating-point numbers, characters, and boolean values. The primary difference between them is their size in memory, which in turn determines the range of values they can store.

Integer Types

Integers are whole numbers. C++ offers several types to accommodate different ranges.

• char: The smallest integer type. Typically 1 byte. As its name implies, it's also used to store characters.
• short: A short integer. Typically 2 bytes.
• int: The "natural" integer size for the machine. Usually 4 bytes on modern systems.
• long: A long integer. Its size is platform-dependent, often 4 or 8 bytes.
• long long: A very long integer. Typically 8 bytes.

You can check the size of any data type using the sizeof operator, which returns the size in bytes.

#include <iostream>

int main() {
    std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "Size of short: " << sizeof(short) << " bytes" << std::endl;
    std::cout << "Size of long long: " << sizeof(long long) << " bytes" << std::endl;
    return 0;
}

Signed vs. Unsigned Integers

By default, integer types are signed, meaning they can hold both positive and negative values. One bit is used to store the sign. If you know a variable will only ever hold non-negative values (like counts or sizes), you can declare it as unsigned. This uses the sign bit for the value itself, effectively doubling the maximum positive value it can hold.

unsigned int positive_counter{100};

This concept is crucial for understanding data representation at the bit level.

Floating-Point Types

For numbers with fractional parts, you use floating-point types:

• float: Single-precision floating-point number. Typically 4 bytes.
• double: Double-precision floating-point number. Typically 8 bytes, offering greater precision than float.

When writing a floating-point literal, it's good practice to add an f suffix for floats to distinguish them from doubles:
float pi_approx{3.14f};
double precise_pi{3.1415926535};

Numeric Bases and Data Representation

Your telemetry engine will need to serialize data into a compact binary format. Understanding how numbers are represented in memory is key. Computers work in binary (base-2), but for readability, programmers often use hexadecimal (base-16) as a compact way to represent binary data.

For example, a 32-bit color value with full red and full alpha might be written in hex as 0xFF0000FF. This is much clearer than the decimal or binary equivalent.

A Deeper Dive for Systems Programming: Fixed-Width Integers

The fundamental types like int and long are problematic for systems programming because their size is implementation-defined. An int might be 32 bits on your desktop but could be different on another platform. This lack of portability is unacceptable when defining data structures for serialization or network protocols.

To solve this, C++ provides fixed-width integer types in the <cstdint> header. These types guarantee their exact size in bits, regardless of the platform.

For your telemetry engine, you should almost exclusively use these types for your data structures. For instance, a high-resolution timestamp should be a uint64_t. An event type identifier could be a uint8_t. This ensures your data format is consistent everywhere.

A rule of thumb for systems programming:

• Use fixed-width types (int32_t, uint64_t, etc.) for data that will be part of a structure, serialized, or sent over a network.
• It's generally fine to use a plain int for temporary variables like loop counters where the exact size isn't critical.

Variable Naming and Initialization

Finally, a few practical rules are essential for writing clean, bug-free code.

1. Always Initialize Your Variables: Using a variable before it has been given a value leads to undefined behavior. Your program might crash or produce strange results.
2. Use Meaningful Names: thread_id is much better than t. Good names make code self-documenting.
3. Follow Naming Conventions: Common C++ conventions include camelCase (e.g., myVariable) or snake_case (e.g., my_variable). Pick one and stick to it for consistency.

Conclusion

In this lesson, we've drilled down into the fundamental units of data storage in C++. Understanding these concepts is not just academic; it's the first step in engineering a high-performance system.

Key Takeaways:

• Variables are named storage locations in memory. Their data type determines their size and behavior.
• The main fundamental types are for integers (char, int, long long), floating-point numbers (float, double), and booleans (bool).
• The sizeof operator is a key tool for querying the memory size of a type.
• The unsigned keyword is used for integers that will only ever be non-negative, doubling their positive range.
• For performance-critical and portable systems like your profiler, you should prefer fixed-width integers from <cstdint> (e.g., uint64_t, int32_t) to ensure consistent data layouts.
• Always initialize your variables upon declaration to avoid undefined behavior.

Now that you know how to store data, our next lesson, "Control program flow using conditionals (if/else) and loops (for/while)," will teach you how to make your program execute different code paths and perform repetitive tasks. This will allow you to start building logic that acts upon the data you've stored.