Lecture 13: Structures and Pointers

## An array of structs · Many records of one type, stored together

~~~cpp
#include <array>
#include <iostream>

struct Reading {
    int sensorId;
    double value;
    bool valid;
};

int main() {
    std::array<Reading, 3> samples{{
        {1, 30.1, true}, {2, 29.8, true}, {3, 0.0, false}
    }};
    for (const Reading& reading : samples) {
        if (reading.valid) std::cout << reading.sensorId << ": " << reading.value << '\n';
    }
}
~~~

~~~text
1: 30.1
2: 29.8
~~~

Each element is a whole <code>Reading</code>. The <code>const</code> reference reads each one without copying it, and the <code>valid</code> member decides which to print.

## A pointer holds an address · The address-of operator & gives an object's address

~~~cpp
#include <iostream>

int main() {
    int score = 95;
    int* scorePointer = &score;          // holds the address of score
    *scorePointer += 5;                  // dereference: reach score through the pointer
    std::cout << score << '\n';
    std::cout << (scorePointer == &score) << '\n';
    int* none = nullptr;                 // points to no object
    std::cout << (none == nullptr) << '\n';
}
~~~

~~~text
100
1
1
~~~

The pointer is a separate object. <code>&score</code> obtains the address of <code>score</code>; <code>*scorePointer</code> is the object at that address.

## Structs and pointers: the general forms

~~~cpp
struct <TypeName> {                    // define a record type
    <type> <member>;                   // one member per line
    <type> <member>;
};

<TypeName> <object>{<value>, <value>}; // members initialized in order
<object>.<member>                      // access a member of an object

<type>* <pointer> = &<object>;         // pointer to an object of <type>
<type>* <pointer> = nullptr;           // pointer to no object
*<pointer>                             // dereference: the object pointed to
<pointer>-><member>                    // same as (*<pointer>).<member>
~~~

| Part | Meaning |
| --- | --- |
| `struct` | Defines a new type from members. The closing `;` is required. |
| `.` | Member access through an object (or a reference). |
| `&<object>` | Address-of: the address where the object lives. |
| `*<pointer>` | Dereference: access the pointed-to object. Valid only when the pointer holds the address of a live object. |
| `->` | Member access through a pointer. |
| `nullptr` | The null pointer: it points to no object. Never dereference it. |

A pointer that might be null must be checked before it is dereferenced.

## Check before you dereference · A pointer must point to an object

~~~cpp
int score = 95;
int* scorePointer = &score;
int* none = nullptr;

if (scorePointer != nullptr) {
    *scorePointer += 5;           // safe: it points to score
}

if (none != nullptr) {
    *none = 0;                    // skipped: no object to reach
} else {
    std::cout << "no object\n";
}
~~~

- Dereferencing accesses the pointed-to object. <code>nullptr</code> explicitly means “no object”.
- Dereferencing a null pointer is undefined behavior. On a typical desktop system it crashes, but the language does not promise that.
- Initialize every pointer: to the address of an object, or to <code>nullptr</code>.

## Return a pointer when “not found” is an answer · Look up a sensor

~~~cpp
#include <array>
#include <iostream>

struct Reading {
    int sensorId;
    double value;
    bool valid;
};

// returns a pointer to the matching reading, or nullptr when there is none
const Reading* findSensor(const std::array<Reading, 3>& readings, int id) {
    for (const Reading& reading : readings) {
        if (reading.sensorId == id) return &reading;
    }
    return nullptr;
}

int main() {
    std::array<Reading, 3> samples{{
        {1, 30.1, true}, {2, 29.8, true}, {3, 0.0, false}
    }};
    for (int id : {2, 3, 9}) {
        const Reading* found = findSensor(samples, id);
        if (found == nullptr) {
            std::cout << "sensor " << id << ": not found\n";
        } else if (!found->valid) {
            std::cout << "sensor " << id << ": invalid reading\n";
        } else {
            std::cout << "sensor " << id << ": " << found->value << '\n';
        }
    }
}
~~~

| Sensor | Output |
|---|---|
| 2 | <code>sensor 2: 29.8</code> |
| 3 | <code>sensor 3: invalid reading</code> |
| 9 | <code>sensor 9: not found</code> |

**Takeaways**

- “Not found” is a normal outcome of a search, so the caller checks the result with <code>if</code>.
- The pointer points into <code>samples</code>, which outlives the call, so it stays valid.
- Check <code>nullptr</code> before <code>found->valid</code>: the <code>else if</code> is reached only when <code>found</code> is not null.

## Member access · Dot through an object, arrow through a pointer

~~~cpp
#include <iostream>

struct Reading {
    int sensorId;
    double value;
    bool valid;
};

int main() {
    Reading reading{7, 31.5, true};
    Reading* pointer = &reading;

reading.value = 32.0;       // dot: through the object
    pointer->value = 32.5;      // arrow: through the pointer
    (*pointer).value += 0.5;    // the same thing, spelled out
    std::cout << reading.value << '\n';
}
~~~

~~~text
33
~~~

`pointer->value` is shorthand for `(*pointer).value`. The parentheses are needed because `.` binds tighter than `*`.

## Alignment and padding · A struct can be larger than the sum of its members

~~~cpp
#include <cstddef>
#include <iostream>

struct Reading {
    int sensorId;
    double value;
    bool valid;
};

int main() {
    std::cout << "sizeof(int) = " << sizeof(int) << '\n';
    std::cout << "sizeof(double) = " << sizeof(double) << '\n';
    std::cout << "sizeof(bool) = " << sizeof(bool) << '\n';
    std::cout << "sizeof(Reading) = " << sizeof(Reading) << '\n';
    std::cout << "offsetof sensorId = " << offsetof(Reading, sensorId) << '\n';
    std::cout << "offsetof value = " << offsetof(Reading, value) << '\n';
    std::cout << "offsetof valid = " << offsetof(Reading, valid) << '\n';
}
~~~

~~~text
sizeof(int) = 4
sizeof(double) = 8
sizeof(bool) = 1
sizeof(Reading) = 24
offsetof sensorId = 0
offsetof value = 8
offsetof valid = 16
~~~

This output is implementation-specific (here: 64-bit Apple clang). The members add up to 13 bytes, but the compiler inserts padding so each member meets its alignment: <code>value</code> starts at offset 8, and the total is rounded up to a multiple of 8. Never assume a struct's size from its members.

## Pointer arithmetic · It moves by whole elements, inside one array

~~~cpp
#include <iostream>

int main() {
    int a[4]{10, 20, 30, 40};
    int* p = a;                       // the array name converts to &a[0]
    std::cout << *p << ' ' << *(p + 2) << ' ' << p[3] << '\n';
    ++p;                              // move to the next int
    std::cout << *p << '\n';
    int* end = a + 4;                 // one past the end: may be compared, never dereferenced
    std::cout << (end - p) << '\n';   // elements between p and end
    for (int* q = a; q != end; ++q) std::cout << *q << ' ';
    std::cout << '\n';
}
~~~

~~~text
10 30 40
20
3
10 20 30 40 
~~~

<code>p + 1</code> advances by <code>sizeof(int)</code> bytes, not one byte. Arithmetic is valid only within one array object, or one past its end. Anything else is undefined behavior. Prefer indexed or range-based traversal.

## Questions about structs and pointers (1)

| Question | Answer |
|---|---|
| Why does `&` appear in `int& r` and in `&score`? | In a declaration, `int&` means a reference. In an expression, `&score` is the address-of operator. Likewise `*` declares a pointer in `int* p` and dereferences in `*p`. |
| Reference or pointer? | A reference is an alias that always refers to an object. A pointer can be null and can be reassigned to point elsewhere. Prefer a reference unless "no object" is a valid argument. |
| Is `nullptr` the same as `0` or `NULL`? | `nullptr` is the null pointer literal, of its own type, `std::nullptr_t`, so it cannot be mistaken for an integer. Use it. |
| What does `std::cout << p` print? | An address, in an implementation-specific form such as `0x16f2b3c9c`. It changes between runs, so never depend on it. |
| Does `int* a, b;` declare two pointers? | No. `a` is an `int*` and `b` is an `int`. Write one declaration per line. |
| Does dereferencing `nullptr` always crash? | No. It is undefined behavior. Desktop systems usually stop the program, but the language promises nothing. |

## Lab practice: structs and pointers

**IC151 lab practice · 5 problems**

1. **Struct basics.** Define `struct Student { int roll; double marks; };`. Read three students into a `std::array<Student, 3>` and print the roll number of the one with the highest marks.
1. **Find or nullptr.** Write `const Student* findRoll(const std::array<Student, 3>& s, int roll)` that returns `nullptr` when the roll is absent. Print `not found` when it is.
1. **Dot or arrow.** Take `Student* p = &s[1];` and set the marks to 90 through `p`, then print them through `s[1]`. Write the update both as `p->marks` and as `(*p).marks`.
1. **Pre-condition.** Write `void curve(Student* s)` that adds 5 marks. Guard it with `assert(s != nullptr)`. Which call aborts: `curve(&s[0])` or `curve(nullptr)`?
1. **Layout.** Print `sizeof(Student)` and `offsetof(Student, marks)`. Add `char grade;` at the end and again at the start. Does the size change? Why?

Reaching this set marks the lecture as studied in this browser. [Open the IC151 lab setup and batch schedule](ic151.html).