What Are Compound Data Types?

Compound data types are types built from fundamental types (like int and double) that allow you to represent more complex data. They include references, pointers, arrays, structs, classes, and more, each enabling you to organize and work with data in ways that fundamental types alone cannot.

Throughout earlier chapters, we explored fundamental data types like int, double, bool, and char. These basic building blocks have served us well for simple computations and straightforward programs. However, as our programs grow in complexity, we quickly encounter scenarios where fundamental types alone aren't sufficient.

Consider building a weather monitoring system. You need to track temperature, humidity, atmospheric pressure, wind speed, and timestamp data for each reading. How would you organize this information? You might try something like this:

#include <iostream>

int main()
{
    // Sensor reading at 10:00 AM
    double temp1{22.5};
    double humidity1{65.0};
    double pressure1{1013.25};

    // Sensor reading at 11:00 AM
    double temp2{23.1};
    double humidity2{63.0};
    double pressure2{1012.80};

    std::cout << "10 AM: " << temp1 << "C, " << humidity1 << "%\n";
    std::cout << "11 AM: " << temp2 << "C, " << humidity2 << "%\n";

    return 0;
}

This approach has several problems. First, the relationships between related data points are only implied by naming conventions. Second, writing a function to process a sensor reading would require passing many separate parameters. Third, managing dozens or hundreds of readings becomes unmanageable with individual variables.

Here's another example: imagine you're creating a music playlist application. How would you store 1,000 song titles? Creating individual variables like song1, song2, song3 through song1000 is clearly not practical. You'd need to write repetitive code for even basic operations like searching or sorting.

int main()
{
    std::string song1{"Bohemian Rhapsody"};
    std::string song2{"Stairway to Heaven"};
    std::string song3{"Hotel California"};
    // ... 997 more variables?

    return 0;
}

These limitations demonstrate that fundamental types alone aren't enough for real-world programs.

Compound Data Types

To address these challenges, C++ provides compound data types (also called composite data types). These are types constructed from other types, combining multiple values into organized structures with additional capabilities.

Core Understanding

Every C++ type is either fundamental or compound. The language standard explicitly categorizes each type accordingly.

With compound types, we can elegantly solve the problems presented earlier. We can group related sensor readings together, create collections of songs, and build sophisticated data structures that model real-world entities.

C++ provides these compound types:

  • Functions
  • Arrays (C-style)
  • Pointer types:
    • Pointer to object
    • Pointer to function
  • Pointer to member types:
    • Pointer to data member
    • Pointer to member function
  • Reference types:
    • Lvalue references
    • Rvalue references
  • Enumerated types:
    • Unscoped enumerations
    • Scoped enumerations
  • Class types:
    • Structs
    • Classes
    • Unions

You're already familiar with one compound type: functions. Every function has a compound type composed of its return type and parameter types:

int calculateArea(int width, int height)
{
    return width * height;
}

The function calculateArea has type int(int, int). This type indicates it returns an int and accepts two int parameters. The type itself is constructed from fundamental types, making it a compound type. Functions also have special behaviors like being callable.

Learning Path

This material spans multiple chapters due to its breadth. In this chapter, we'll cover lvalue references and pointers. The next chapter introduces unscoped enumerations, scoped enumerations, and our first class type: structs. Subsequent chapters delve into classes and various array types, including std::string (actually a class type, as you'll learn!).

Terminology

A class type is any struct, class, or union. This term appears frequently in advanced lessons.

Let's begin our journey into compound types!

Summary

Fundamental types: Basic building blocks provided by C++ (int, double, char, bool, etc.) that store single values.

Compound types: Types constructed from other types, combining multiple values into organized structures with additional capabilities.

Motivation: Fundamental types alone are insufficient for real-world programs. Related data needs grouping, collections need managing, and complex entities need modeling.

Categories of compound types:

  • Functions (return type + parameter types)
  • Arrays (C-style)
  • Pointer types (to objects or functions)
  • Reference types (lvalue and rvalue references)
  • Enumerated types (scoped and unscoped enumerations)
  • Class types (structs, classes, unions)

Learning path: This chapter covers lvalue references and pointers. Subsequent chapters explore enumerations, structs, classes, and array types.

Functions as compound types: Already familiar - every function has a type composed of its return type and parameter types (e.g., int(int, int) for a function returning int and taking two int parameters).

Understanding compound types is essential for writing practical C++ programs that model real-world data and solve complex problems efficiently.