Just enough C++ II: arrays, structs and text

An array is a row of boxes, all holding the same kind of value, standing side by side. You choose how many boxes when you make the row, and that number never changes. Here is a row of four scores:

std::int32_t scores[4] = {90, 72, 85, 64};

The kind of value each box holds comes first (std::int32_t, a whole number 32 bits wide from the last section). Then comes the name, scores. The 4 in square brackets is how many boxes there are, and the curly braces list what goes in them.

To reach one box, write the name and a position in square brackets. The surprise is that positions start at 0, not 1. scores[0] is the first box (90), scores[1] the second (72), and scores[3] is the fourth and last (64). Think of the number as "how many boxes to walk past from the start". To reach the first box you walk past none. So a row of four boxes has positions 0, 1, 2 and 3, and a loop that visits them all counts from 0 while the count is less than 4.

Two warnings for people coming from Java, C# or Python. First, a C++ array doesn't know its own length; there's no .length or len(). The tool std::size(scores) tells you there are 4. Second, C++ never checks whether a position is real. Ask for scores[4] and C++ won't stop you, even though there is no fifth box. The C++ rules call this undefined behaviour: anything may happen. You might see a nonsense number, the program might crash, or it might look fine and break later. Java would have stopped with an error. C++ trusts you, so you have to be careful.

This section covers three ways to group values. An array is a fixed number of values of one type, stored side by side in order. A struct is a group of named values kept together, and text is a row of characters. Arrays come first, then structs, then text. The declaration gives the element type, the name, and the count in square brackets:

#include <cstdint>

std::int32_t scores[4] = {90, 72, 85, 64};

scores[i] names the element i positions from the start, so the first element is scores[0] and the last is scores[3]. Counting from 0 is not a quirk to memorise. The number in the brackets says how far from the start to go, and the first element is zero steps away. A loop over every element therefore runs i from 0 while i < 4.

A C++ array's size is fixed when it is declared and can't grow. There is no .length on it: std::size(scores) (from <iterator>) gives the count, 4. C++ also never checks an index. scores[4] and scores[-1] are not part of the array, yet the program compiles and runs, and reading them is undefined behaviour: the C++ rules promise nothing about the result. It might print a strange number, crash, or seem to work. Chapter 13 shows what the processor does with such an index, and Chapter 37 shows why attackers look for this bug.

An array groups values of the same kind under positions. A struct groups values that belong together under names. Think of a form with labelled blanks: one blank for x, one for y. Here is how you describe that form to C++:

#include <cstdint>

struct Point {
    std::int32_t x;
    std::int32_t y;
};

This makes a new kind of value called Point. Every Point has two named parts, x and y, each a whole number 32 bits wide. Each named part is called a field. Notice the semicolon after the final curly brace; leaving it out is a classic error.

To make one, write Point p{3, 4};. That's a variable called p, whose x is 3 and whose y is 4, filled in the order the fields were listed. A dot reaches inside: p.x means "the x part of p". You can read it, or change it with p.x = 10;, and y is left alone.

You can also have a row of structs. Point corners[2] is an array holding two points. corners[1].y reads from left to right: go to position 1 in the row (the second point), then take its y.

If you know C#, a C++ struct is like a C# struct: the values live right inside the variable and get copied along with it. If you know Java, which has no struct, think of a class that only holds data, all of it public. The difference: a Java variable only points at its object, while a C++ struct variable is the values. If you know Python, it's like a @dataclass, except the fields can't change kind and can't be added later.

A struct is a type that groups several named values into one. Each named value is a field (the C++ standard says data member):

#include <cstdint>

struct Point {
    std::int32_t x;
    std::int32_t y;
};

The definition creates a new type, Point; note the semicolon after the closing brace. Point p{3, 4}; makes a variable of that type with p.x equal to 3 and p.y equal to 4, the values given in the order the fields are declared. A dot reaches a field: p.x = 10; changes one field and leaves the other alone. Structs and arrays combine: Point corners[2] is an array of two points, and corners[1].y is the y field of the second one.

In C#, the closest match is C#'s own struct: a value type, copied whole on assignment, whose array stores the points back to back. For a struct of plain numbers like this one, C# also keeps the fields in the order you declared them, so [StructLayout] is only needed to pin exact offsets or packing. Java has no struct; the nearest thing is a class (or record) with only public data, but every Java object is reached through a reference, so a Java Point[] holds references to points rather than the points themselves. A Python programmer can read it as a @dataclass, except that the fields and their types are fixed when the program is compiled. In Chapter 13 you will see how the fields sit inside a struct and how machine code reaches corners[1].y.

A char holds one character: a letter, a digit, a space, a symbol. You write a single character between single quotes, as in 'B'. So char grade = 'B'; makes a box called grade holding the letter B. Inside the computer, each character is stored as a small number; Chapter 2 shows which number goes with which character.

Text, like a name or a sentence, goes between double quotes: "cat". Here's the part that surprises everyone. In plain C-style text, the kind this course uses, the text is stored as a row of chars (an array, from earlier in this section). C++ quietly adds one extra char at the end. That extra char is written '\0' (a backslash then a zero). It's a special "the text stops here" marker, called the null terminator. So char name[] = "cat"; gives you four boxes, not three: 'c', 'a', 't', and the end marker. Any code that walks along the text, such as code that counts its letters, keeps going until it meets that marker.

Another backslash combination you've already met is '\n', the "start a new line" character.

There are two ways to print. The first is std::cout. You chain things to it with <<, and it prints each one in turn: std::cout << name << " has " << 9 << '\n'; prints cat has 9 and moves to a new line.

The second is std::printf. You give it a sentence with gaps, then the values to fill the gaps, in order. Each gap is a percent sign plus a letter saying what goes there. Use %d for a whole number, %u for a whole number that can't be negative, %c for one character, and %s for a piece of text. So std::printf("%s: %d\n", name, 9); prints cat: 9. If a gap's letter doesn't match the value you give it, the output is wrong, and the compiler can warn you. This course cares about printf because machine code can use it to print, which you'll do in Chapter 12.

char is the type for a single character. A character value is written in single quotes: char grade = 'B';. Underneath, a char holds a small number, one code per character; Chapter 2 §6 shows the table.

Text in double quotes, such as "cat", is a string literal. In the C-style text this course uses, a piece of text is an array of char followed by one extra character, '\0' (the null terminator, code 0), which marks the end. So char name[] = "cat"; makes an array of four chars: 'c', 'a', 't', '\0'. The empty brackets let the compiler count, and std::size(name) is 4. Code that walks text, such as finding its length, stops when it reaches '\0'. Other escapes start with a backslash too: '\n' is the newline character. (Everyday C++ uses std::string, which manages its own storage; the course uses C-style text because that's what machine code sees.)

Two ways to print appear in this course. std::cout << (from <iostream>) prints each value in turn, using its type to decide how: std::cout << name << " has " << 9 << '\n';. std::printf (from <cstdio>) takes a format string with placeholders and then the values to fill them, in order: %d for an int-sized whole number, %u for an unsigned one, %c for a char, %s for C-style text. A placeholder that doesn't match its value's type is a bug; compilers warn about it with -Wall. printf matters to us because it's an ordinary function that machine code can call, which Chapter 12 does.