04 - Aggregates

std::array<float, 3uz> my3DVector;
std::array<char, 250uz> aShortCharacterString {"Some words here."};

The image type we discussed previously was mainly formed of many Bytes, each interpreted as light intensity. Our example image used 88 Bytes. We could declare:

std::array<std::byte, 88uz> imageLightIntensityData;

We have seen how to represent characters with ASCII codes, but in this page, characters also have a size, can use bold or italic, etc. We could create a struct to encode this information:

struct StyledCharacter
{
    char character;
    float fontSize;
    bool bold;
    bool italic;
};

Now we can use this type:

StyledCharacter myStyledCharacter;

We can also initialize it. There are several ways, but our preferred way of initializing it would be:

StyledCharacter myStyledCharacter
{
    .character = 'A',
    .fontSize = 10.0f,
    .bold = true,
    .italic = false
};

This way of initializing it is called "designated initialization" and has been introduced with C++20. If your compiler uses an older version, you can use aggregate initialization instead:

StyledCharacter myStyledCharacter
{
    'A',
    10.0f,
    true,
    false
};

It is more concise, but harder to read. To know that the second boolean value indicates whether the character is in italic, the person reading the code needs to know the exact structure of StyledCharacter, which is why we prefer the designated initialization syntax.

Unfortunately, at this point, our program will not know how to display this new type out-of-the-box. But we can access each member of the variable (character, fontSize, bold, italic) with the . syntax: variableIdentifier.member:

Consider our image type. We saw that an array is convenient to store the light intensity data as a std::array<std::byte, 88uz>, for instance.

But we also discussed that to be able to interpret it correctly as an image, we need to also store the width and height of the image. It would be convenient to store them alongside the light intensity Bytes:

struct GrayscaleImage
{
    std::size_t width;
    std::size_t height;
    std::array<std::byte, 88uz> lightIntensityData;
};

The array size is 88 because our image was 11 pixels wide and 8 pixels high. Now that we store a size alongside, we could now use a larger buffer, allowing for different image sizes. For instance:

struct GrayscaleImage
{
    std::size_t width;
    std::size_t height;
    std::array<std::byte, 1024uz> lightIntensityData;
};

This would allow storing images of any size as long as width×height remains lower or equal to 1024 (e.g. 32×32, 128×8, 4×64, 8×8, ...).

But what if our image was a colour image? Or even a colour image with transparency? One way would be to declare a struct encoding all the information for one pixel of the image:

struct PixelData
{
    std::uint8_t redIntensity;
    std::uint8_t greenIntensity;
    std::uint8_t blueIntensity;
    float transparency;
};

and then to store an array of this data structure in our image type:

struct ColourImage
{
    std::size_t width;
    std::size_t height;
    std::array<PixelData, 1024uz> pixels;
};

Note that we could also do it the other way around: we could in the image store an array of red colour intensities, then an array of green colour intensities, then an array of blue intensities, and finally an array of transparencies.

It would change the order in which the data is written, but would also work. The distinction between these two solutions is often referred to as AoS (Array of Structures) for the first, and SoA (Structure of Arrays) for the second.