// C++ · Лекция 06

Массивы и функции

Как обычный массив связан с указателями, что получает функция вместо массива, зачем нужен int (*)[N] и как передать функцию в сортировку.

Обычные массивы

Массив (array) — объект, состоящий из фиксированного числа элементов одного типа, расположенных подряд в памяти. Длина входит в тип массива.

Запись int a[5]; создаёт пять объектов int. Их индексы: 0…4. Размер должен быть известен во время компиляции. У локального массива без инициализации значения элементов не заданы Неинициализированные элементыЧтение неинициализированного int в стандартном учебном сценарии приводит к неопределённому поведению. Сам факт объявления допустим; опасно именно чтение значения без предварительной записи..

Списковая инициализация / aggregate initialization

int a[5]{2, 3}; задаёт первые два элемента, а остальные обнуляет. Размер можно вывести из списка: int a[]{2,3,4};.

array_init.cpp

#include <iostream>
#include <iterator>
int main() {
    int a[5]{2, 3};       // 2 3 0 0 0
    int b[]{4, 5, 6};     // размер = 3
    a[1] = 10;
    std::cout << std::size(a) << ' ' << a[1] << ' ' << b[0];
}

Инициализация массивов нулями и значениями.

Визуализация / инициализация и индексы

У массива есть один общий тип, но каждый его элемент — отдельный объект. Сравните пустой список инициализации и список из двух значений: оба варианта задают значения всем элементам. Вариант без инициализации оставьте для визуализации: безопасная программа сначала записывает значение и только затем читает его.

a[2] = 0

Пустые фигурные скобки обнуляют все элементы.

Выбранный элемент можно менять нажатием на ячейку. Модель не исполняет небезопасный код.

array-zeroes.cpp

#include <iostream>
#include <iterator>
int main() {
    int values[4]{};
    std::cout << std::size(values) << '\n';
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}

Четыре элемента созданы и инициализированы нулями. Размер принадлежит типу массива и доступен через std::size.

Результат4 0 0 0 0

array-partial-init.cpp

#include <iostream>
int main() {
    int values[5]{2, 3};
    values[1] = 10;
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}

Оставшиеся элементы получают нули. Запись values[1] = 10 происходит позже и является присваиванием.

Результат2 10 0 0 0

Размеры и границы

sizeof(a) возвращает суммарное количество байт массива. Количество элементов можно вычислить как sizeof(a) / sizeof(a[0]), либо использовать std::size(a) (C++17).

Для int a[5], если sizeof(int)=4

sizeof(a) = 5 × 4 = 20 байт

Адрес a[5] — позиция за концом. Читать и записывать a[5] нельзя.

Выход за границы — UB

a[5] и a[-1] недопустимы для массива int a[5], даже если программа иногда «работает». Встроенный массив и vector::operator[] не проверяют индекс. У vector::at() есть проверка с исключением.

Двумерные массивы: строки и столбцы

Начните с двух индексов: a[i][j] выбирает строку i и столбец j. В матрице 2×3 допустимы i=0,1 и j=0,1,2. Первый цикл выбирает строку, второй последовательно обрабатывает её элементы.

matrix_rows.cpp

#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    for (int row = 0; row < 2; ++row) {
        int sum = 0;
        for (int column = 0; column < 3; ++column) sum += values[row][column];
        std::cout << row << ": " << sum << '\n';
    }
}

Два вложенных цикла: сначала строка, затем её элементы.

Результат0: 6 1: 15

Двумерный массив — массив, элементы которого сами являются массивами: int a[2][3] содержит 2 строки по 3 int в последовательной области памяти.

Главный вопрос — где стоит звёздочка относительно квадратных скобок. У int* p[5] первыми связываются [5]: это массив из пяти указателей. У int (*p)[5] скобки связывают *p раньше: это указатель на массив из пяти целых.

int** — не то же самое, что int (*)[5]. Первая форма — указатель на указатель; вторая — указатель на целую строку фиксированной длины.

matrix.cpp

#include <iostream>
int main() {
    int a[2][3]{{1, 2, 3}, {4, 5, 6}};
    int (*row)[3] = a; // указатель на строку
    int* first = a[0]; // указатель на int
    std::cout << row[1][2] << ' ' << first[2];
}

row + 1 шагает на 3 int, first + 1 — на 1 int.

Визуализация / строки и столбцы в памяти

Встроенная двумерная матрица — массив строк, каждая из которых тоже является массивом. Поэтому шаг указателя на строку отличается от шага указателя на отдельный int. Для обхода всех элементов удобно сохранить эту вложенность и использовать два цикла.

int a[2][3] · последовательная память

Ряд 0 и ряд 1 лежат последовательно, каждый содержит по три int.

a[1][2] = 6

&a[1] → int (*)[3]

a + 1 сдвигает на целую строку: три элемента int. int** не описывает такой массив.

Числовые адреса и размеры int здесь условные; типы соответствуют реальному C++.

matrix-row-pointer.cpp

#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    int (*row)[3] = values;
    ++row;
    std::cout << (*row)[0] << ' ' << row[0][2] << '\n';
}

После ++row указатель обозначает вторую строку целиком. Тип int (*)[3] сохраняет её длину.

Результат4 6

matrix-nested-walk.cpp

#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    int total = 0;
    for (const auto& row : values) {
        for (int value : row) total += value;
    }
    std::cout << total << '\n';
}

Ссылка на строку не превращает её в указатель. Внутренний цикл обходит только элементы своей строки.

Результат21

Визуализация / чтение C++-объявлений

Сначала найдите имя, затем читайте связанные с ним конструкции. У массива указателей имя сначала связывается со скобками []; у указателя на массив скобки вокруг * меняют порядок. Эти типы описывают разную организацию данных и не заменяют друг друга.

a → [5] → int

Массив из пяти int.

Скобки меняют то, какая часть объявления связывается с именем первой.

array-pointer-forms.cpp

#include <iostream>
int main() {
    int values[3]{4, 5, 6};
    int* pointers[3]{&values[0], &values[1], &values[2]};
    int (*whole)[3] = &values;
    std::cout << *pointers[1] << ' ' << (*whole)[1] << '\n';
}

pointers хранит три адреса, whole хранит адрес одного массива из трёх int. Оба выражения читают один элемент разными путями.

Результат5 5

array-type-alias.cpp

#include <iostream>
#include <type_traits>
using Row = int[3];
int main() {
    Row matrix[2]{{1, 2, 3}, {4, 5, 6}};
    Row* row = matrix;
    static_assert(std::is_same_v<decltype(row), int (*)[3]>);
    std::cout << row[1][2] << '\n';
}

Псевдоним Row упрощает чтение объявления, сохраняя тот же тип указателя на массив.

Результат6

Объявление	Смысл
`int a[5]`	5 значений int
`int* a[5]`	5 указателей на int
`int (*p)[5]`	указатель на массив из 5 int
`int** p`	указатель на указатель на int
`int a[2][3]`	2 массива по 3 int

Почему важен тип строки?

Для int (*p)[3] выражение p + 1 перемещает указатель на следующую строку, то есть через 3 × sizeof(int) байт. Для int** шаг был бы по размерам указателя, а не целой строки.

Обработка последовательности: сумма и первый минимум

До обхода задайте контракт: 1…20 элементов, значения по модулю до 1000. Сумма начинается с нуля, минимум — с первого существующего элемента. При равенстве не меняйте выбранный индекс, если нужен первый минимум. Для пустого набора минимума нет: проверьте размер до обращения к a[0].

Задание: найдите сумму и первый максимум; затем суммы строк матрицы. Для индексов с нуля главная диагональ квадрата задаётся i=j, побочная — i+j=n−1. Центральный элемент нечётной матрицы учитывается один раз. Поворот и сдвиг слоя требуют отдельного алгоритма из подготовки к лабораторной.

Массив и указатель

Array-to-pointer conversion — неявное преобразование выражения типа «массив из N элементов T» в указатель T* на его начальный элемент в соответствующем контексте.

Когда пишем a + 2, массив a преобразуется в указатель на a[0]. Поэтому *(a + 2) обозначает a[2].

Указатель можно поставить на середину массива: int* p = a + 3;. Тогда p[-1] означает a[2] и корректен, поскольку адрес остаётся внутри того же массива Отрицательные индексыОтрицательный индекс у указателя не обязательно ошибка. Например, p = a + 3, p[-2] — это a[1]. Но a[-1] выходит за границу и является UB..

pointer_array.cpp

#include <iostream>
int main() {
    int a[5]{10, 20, 30, 40, 50};
    int* p = a + 3;
    std::cout << a[2] << ' ' << *(a + 2) << '\n';
    std::cout << p[-1] << ' ' << p[0] << '\n';
}

p[-1] корректен: это a[2], элемент внутри a.

Визуализация / сдвиг указателя и индексация

Индекс указателя отсчитывается от его текущего положения. Поэтому отрицательный индекс иногда корректен: важен итоговый элемент внутри исходного массива. Отдельно различайте адрес сразу за массивом и адрес за допустимой границей: первый можно использовать как конец диапазона, но разыменовывать его тоже нельзя.

Начальный адрес p = a + 2

10a[0]

20a[1]

30a[2]

40a[3]

50a[4]

p[-1] ≡ *(p - 1)

Смещение относительно p

p[-1] = a[1] = 20

Хотя смещение может быть отрицательным, адрес остался внутри a.

Только p[i] с целевым элементом внутри исходного массива безопасно разыменовывать.

array-negative-offset.cpp

#include <iostream>
int main() {
    int values[]{10, 20, 30, 40, 50};
    int* current = values + 3;
    std::cout << current[-1] << ' ' << current[0] << '\n';
    std::cout << (current - values) << '\n';
}

current[-1] — элемент с индексом 2 исходного массива. Это движение назад внутри того же массива.

Результат30 40 3

array-end-marker.cpp

#include <iostream>
int main() {
    int values[]{4, 5, 6};
    const int* end = values + 3;
    for (const int* current = values; current != end; ++current) {
        std::cout << *current << ' ';
    }
    std::cout << '\n';
}

Условие проверяется до чтения. Когда current достигает end, цикл завершается без разыменования конца диапазона.

Результат4 5 6

Что сравниваем	Массив `int a[5]`	Указатель `int* p`
Тип	`int[5]`	`int*`
Индекс `[i]`	Есть	Есть
`sizeof`	Размер всего массива	Размер самого указателя
Присвоить другой адрес	Нельзя: `a = p`	Можно: `p = a`
Сдвиг `++`	`++a` нельзя	`++p` можно в пределах массива

Массив не равен указателю

Это разные типы. Преобразование происходит во многих выражениях, но не везде: например, sizeof(a) измеряет сам массив, а &a имеет тип «указатель на массив» (здесь int (*)[5]).

Массив при передаче в функцию

Подстройка типа параметра (array parameter adjustment) — правило объявления функций: параметр вида int a[5] интерпретируется как int* a. Указанная цифра не задаёт реального ограничения длины.

Функция не узнаёт число элементов из одного только параметра int a[]. Обычно передают длину отдельно или используют контейнер/ссылку на массив Почему нельзя перегрузить по размеру?void f(int a[3]); и void f(int a[5]); объявляют одну и ту же сигнатуру void f(int*). Перегрузка только по размерам этих параметров невозможна..

array_arguments.cpp

#include <cstddef>
#include <iostream>
void print(const int a[], std::size_t n) {
    // a имеет тип const int*
    for (std::size_t i = 0; i < n; ++i)
        std::cout << a[i] << ' ';
}
int main() {
    int a[5]{1, 2, 3, 4, 5};
    print(a, 5);
}

Размер передаём отдельно: массив внутри print превратился в указатель.

Визуализация / что на самом деле получает функция

Объявление параметра с квадратными скобками выглядит как массив, но такой параметр корректируется до указателя. Число внутри скобок не передаёт длину вызываемой функции. Если длина нужна, передайте её явно или используйте ссылку на массив: во втором варианте размер остаётся частью типа.

int a[5]аргумент в main

f(a)выражение вызова

int*тип получаемого параметра

Вызов получает адрес a[0]. Количество элементов само по себе не передаётся.

int a[5] в заголовке функции трактуется как int* независимо от указанного числа 5.

array-adjusted-parameter.cpp

#include <iostream>
#include <type_traits>
void inspect(int values[7]) {
    static_assert(std::is_same_v<decltype(values), int*>);
    std::cout << values[1] << '\n';
}
int main() {
    int values[]{10, 20, 30};
    inspect(values);
}

Число 7 не заставляет функцию получить семь элементов. Здесь безопасно читается существующий элемент с индексом 1.

Результат20

array-reference-size.cpp

#include <cstddef>
#include <iostream>
template<std::size_t N>
void inspect(const int (&values)[N]) {
    std::cout << N << ' ' << values[N - 1] << '\n';
}
int main() {
    int values[]{10, 20, 30};
    inspect(values);
}

Ссылка привязывается ко всему массиву. Компилятор выводит N из его типа; отдельный аргумент длины не нужен.

Результат3 30

Два объявления — одна сигнатура

void f(int a[5])исходная запись

void f(int* a)тип параметра после корректировки

Реальное число элементов массиву функции не передаётся автоматически.

Не используйте sizeof(a) для длины в такой функции

Внутри void f(int a[5]) параметр a уже имеет тип int*; sizeof(a) измерит указатель. Компилятор может предупредить об этом.

Интерфейс диапазона после указателей и ссылок

Функции обработки последовательности нужны не только элементы, но и границы допустимого обхода. Встроенный параметр вида int a[5] не передаёт функции массив длины пять: тип параметра корректируется к указателю. Поэтому одна цифра в скобках не защищает от неправильного размера. Можно передать указатель и длину отдельно, но они должны соответствовать одному действительному диапазону. Span объединяет доступ к непрерывным элементам и их количество в одном небольшом представлении. Он не владеет элементами и не копирует всю последовательность. В примере span<const int> разрешает чтение, а сумма возвращается отдельным числом. Один интерфейс принимает array и vector. Владелец исходных элементов должен оставаться живым всё время использования span. Наличие размера само по себе не делает любой индекс безопасным: в C++20 operator[] у span не обещает проверку границ. Наш обход берёт только существующие элементы, а пустой диапазон даёт сумму ноль.

code-guided-range.cpp

#include <array>
#include <iostream>
#include <span>
#include <vector>

long long sum(std::span<const int> values) {
    long long result = 0;
    for (int value : values) {
        result += value;
    }
    return result;
}

int main() {
    const std::array<int, 3> fixed{1, 2, 3};
    const std::vector<int> dynamic{4, 5};
    std::cout << sum(fixed) << ' ' << sum(dynamic) << '\n';
}

Span передаёт доступ и длину, но не владеет данными и не обещает проверку operator[].

Результат6 9

Динамические массивы и VLA

new[] возвращает указатель

new int[n]{} создаёт n элементов в динамической памяти, обнуляет их и возвращает int*. Освобождение — строго delete[] p;.

Парное выделение и освобождение / new[] / delete[]

new T[n] должно соответствовать delete[], а new T — delete. Несовпадение — UB.

new_array.cpp

#include <cstddef>
int main() {
    std::size_t n = 100;
    int* a = new int[n]{}; // 100 нулей
    a[2] = 19;
    delete[] a;
    a = nullptr;
}

Запрос может зависеть от n во время выполнения; освобождение — delete[].

Визуализация / выделение, обнуление и освобождение

Круглые и квадратные скобки в new описывают разные объекты: один int со значением или массив элементов. От этого зависит и форма освобождения памяти. Сравните ручное управление с vector: контейнер сам освобождает своё хранилище при выходе из области видимости.

0p[0]

0p[1]

0p[2]

0p[3]

0p[4]

delete[] p;

Созданные объекты можно использовать, затем необходимо освободить верной формой delete.

new T ↔ delete p; new T[n] ↔ delete[] p. Путать пары нельзя.

array-matched-delete.cpp

#include <iostream>
int main() {
    int* single = new int(5);
    int* values = new int[3]{};
    values[1] = *single;
    std::cout << values[0] << ' ' << values[1] << '\n';
    delete single;
    delete[] values;
}

Один объект освобождается delete, массив — delete[]. После освобождения программа больше не читает эти адреса.

Результат0 5

array-runtime-vector.cpp

#include <iostream>
#include <vector>
int main() {
    int count = 4;
    std::vector<int> values(count);
    values.back() = 9;
    std::cout << values.size() << ' ' << values.front()
              << ' ' << values.back() << '\n';
}

Размер count не обязан быть константой времени компиляции. vector создаёт элементы и управляет памятью без VLA.

Результат4 0 9

Почему int a[n] — не стандартный C++?

Встроенный массив int a[N] требует константного выражения размера. Запись int n; std::cin >> n; int a[n]; — VLA: некоторые компиляторы принимают её как расширение, но стандартный C++ запрещает.

Массив переменной длины / VLA

Массив, размер которого узнаётся только во время выполнения. Для переносимого C++ используем std::vector<int> a(n);.

portable_array.cpp

#include <iostream>
#include <vector>
constexpr int MAX_SIZE = 1000;
int main() {
    int n = 0;
    if (!(std::cin >> n) || n < 0 || n > MAX_SIZE) {
        std::cerr << "Invalid size\n";
        return 1;
    }
    std::vector<int> values(n);
    std::cout << values.size() << '\n';
    // int bad[n]; // VLA не входит в стандарт C++20.
}

До создания vector проверяются чтение и диапазон 0…1000. Пустой массив допустим; неверный ввод отклоняется.

Не трогайте служебную память аллокатора

Примеры чтения a[-1] и ручного delete[] v.data() из лекции демонстрируют опасные последствия, но оба действия недопустимы. Писать их в настоящей программе нельзя.

Указатели на функции и сортировка

Указатель на функцию (function pointer) — значение, позволяющее обратиться к функции определённой сигнатуры через переменную. Например, bool (*cmp)(int,int).

Чтобы передать алгоритму правило сравнения, определяем функцию bool cmp(int a, int b) и передаём её в std::sort. Выражения cmp и &cmp в этом контексте дают указатель на функцию.

Компаратор / comparator

Функция-предикат, отвечающая, должен ли первый элемент идти раньше второго.

Для std::sort(first,last,cmp) диапазон полуоткрытый: [first,last). Компаратор должен задавать строгий слабый порядок Строгий слабый порядокТребуются, в частности, иррефлексивность (cmp(x,x)==false), асимметрия и транзитивность отношения, а также транзитивность эквивалентности. Сравнение a <= b не подходит: cmp(x,x) истинно..

function_pointer_sort.cpp

#include <algorithm>
#include <iostream>
bool descending(int a, int b) {
    return a > b;
}
int main() {
    int a[]{8, 2, 9, 1, 5};
    bool (*cmp)(int, int) = &descending;
    std::sort(a, a + 5, cmp);
    for (int x : a) std::cout << x << ' ';
}

Параметр cmp — указатель на функцию сравнения.

Визуализация / передаём компаратор в алгоритм

Алгоритм получает правило сравнения отдельно от массива. Замена функции-компаратора меняет порядок, сохраняя сам вызов сортировки. Важно договориться, что именно означает «раньше»: сравнение должно быть строгим, поэтому один и тот же элемент не должен считаться предшествующим самому себе.

До сортировки

-7

-3

После сортировки

-3

-7

cmp(a,b) = a > b

sort получает правило как вызываемый объект или указатель на функцию. Здесь моделируется результат, сам алгоритм C++ не запускается.

Компаратор должен задавать строгий слабый порядок: cmp(x,x) всегда false.

sort-function-pointer.cpp

#include <algorithm>
#include <iostream>
bool descending(int left, int right) { return left > right; }
int main() {
    int values[]{8, 2, 9, 1, 5};
    bool (*compare)(int, int) = descending;
    std::sort(values, values + 5, compare);
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}

Указатель compare хранит выбранную функцию. Обратите внимание: при сортировке по убыванию компаратор использует >.

Результат9 8 5 2 1

sort-absolute-values.cpp

#include <algorithm>
#include <cstdlib>
#include <iostream>
bool by_magnitude(int left, int right) {
    if (std::abs(left) != std::abs(right))
        return std::abs(left) < std::abs(right);
    return left < right;
}
int main() {
    int values[]{2, -1, -2, 1};
    std::sort(values, values + 4, by_magnitude);
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}

При равных модулях второе правило задаёт однозначный порядок. Для этих небольших чисел вычисление модуля безопасно.

Результат-1 1 -2 2

Тип указателя

Объявление читается от имени: (*p) — указатель; затем (int,int) — функция с двумя параметрами; слева bool — возвращаемый тип. Типы аргументов и результата входят в тип указателя.

Чтение от имени переменной

(*p)указатель

(int,int)два аргумента

boolрезультат

bool (*p)(int, int);

overloaded_address.cpp

#include <iostream>
void f(int x) { std::cout << x; }
void f(double x) { std::cout << x; }
int main() {
    void (*p)(int) = &f;    // выбирает f(int)
    void (*q)(double) = &f; // выбирает f(double)
    p(3);
    q(2.5);
}

Контекст типа указателя разрешает перегрузку.

Адрес перегруженной функции

Если есть f(int) и f(double), контекст требуемого типа указателя может выбрать нужную перегрузку. Без такого контекста выражение &f неоднозначно. Если определение выбранной функции отсутствует, обычно возникает ошибка компоновки.

Параметры функций

Аргументы по умолчанию

Аргумент по умолчанию (default argument) — выражение, подставляемое при вызове, когда соответствующий аргумент не указан.

Обычно значения по умолчанию образуют концевой непрерывный суффикс параметров. Нельзя оставить обязательный параметр после необязательного.

default_args.cpp

#include <iostream>
int sum(int x = 1, int y = 2, int z = 3) {
    return x + y + z;
}
int main() {
    std::cout << sum() << ' ';
    std::cout << sum(4) << ' ';
    std::cout << sum(4, 8, 10);
}

Результат: 6 9 22.

Визуализация / сколько аргументов передано

Отсутствующие аргументы подставляются справа из объявления функции. Переданное значение заменяет соответствующее значение по умолчанию; пропустить первый аргумент и передать только второй таким способом нельзя. Значение по умолчанию должно быть известно в месте вызова.

x = 1по умолчанию

y = 2по умолчанию

z = 3по умолчанию

f() → 1 + 2 + 3 = 6

Смысл модели: int f(int x=1, int y=2, int z=3).

function-default-values.cpp

#include <iostream>
int sum(int x = 1, int y = 2, int z = 3) { return x + y + z; }
int main() {
    std::cout << sum() << ' ' << sum(4) << ' '
              << sum(4, 8, 10) << '\n';
}

В первом вызове подставляются все три значения, во втором — последние два, в третьем ничего не подставляется.

Результат6 9 22

function-default-declaration.cpp

#include <iostream>
int sum(int x, int y = 10);
int sum(int x, int y) { return x + y; }
int main() {
    std::cout << sum(3) << ' ' << sum(3, 4) << '\n';
}

Повторять значение по умолчанию в определении не нужно. Достаточно объявления, доступного вызывающему коду.

Результат13 7

У std::sort здесь не аргумент по умолчанию

В лекции приведена удобная аналогия, но технически std::sort(first,last) и std::sort(first,last,comp) — разные перегрузки, а не просто единственная функция с третьим параметром по умолчанию.

C-подобное многоточие

Объявление void log(const char* format, ...); разрешает дополнительные аргументы разных типов. Это исторический механизм printf; ручная обработка требует <cstdarg>.

variadic.cpp

#include <cstdio>
int main() {
    std::printf("%d %.1f\n", 5, 2.5);
    // printf принимает формат и аргументы ...
}

В C-вариадических функциях типы контролируются слабее.

Строки из символов (C-строки)

Нуль-терминированная строка (null-terminated string) — последовательность символов char, конец которой обозначается первым символом \0.

Литерал "Hello" в C++ имеет тип массива const char[6]: пять букв и завершающий \0. В записи const char* s = "Hello"; массив преобразуется в указатель. Изменять сам литерал нельзя.

char text[] = "Hello"; создаёт собственный изменяемый массив. Для std::cout << s перегрузка вывода для C-строк печатает символы до первого нуля, а не адрес Почему выводится строка, а не адрес?У operator<< для const char* и char* есть специальная перегрузка: она читает символы до первого \0. Для обычных указателей на объекты вывод обычно показывает представление адреса..

c_strings.cpp

#include <cstring>
#include <iostream>
int main() {
    char s[]{'A', 'B', '\0', 'C', 'D', '\0'};
    const char* literal = "Hello";
    std::cout << s << ' ' << std::strlen(s) << '\n';
    std::cout << literal << '\n';
    // s[3] существует, но за первым \0
}

std::cout выведет AB 2 и Hello.

Визуализация / нулевой терминатор и вывод

Размер массива символов и длина C-строки — разные величины. Нулевой символ завершает строку для strlen и вывода через const char*, хотя за ним могут оставаться другие элементы массива. Изменяемая копия литерала и сам строковый литерал также имеют разные свойства.

Первый нулевой символ: позиция 4

A[0]

B[1]

C[2]

D[3]

\0[4]

F[5]

\0[6]

std::cout << s; → "ABCD"

std::strlen(s) → 4

После первого \0 в памяти могут сохраняться символы, но C-строка логически заканчивается на нём.

Модель использует массив с гарантированным терминатором, чтобы не выполнять UB.

cstring-first-zero.cpp

#include <cstring>
#include <iostream>
int main() {
    char text[]{'A', 'B', '\0', 'C', 'D', '\0'};
    std::cout << text << '\n';
    std::cout << std::strlen(text) << ' ' << sizeof(text) << '\n';
}

strlen останавливается на первом нуле, sizeof учитывает все шесть элементов массива char.

РезультатAB 2 6

cstring-writable-copy.cpp

#include <iostream>
#include <string>
int main() {
    char word[] = "cat";
    word[0] = 'b';
    std::string text{"A\0B", 3};
    std::cout << word << '\n';
    std::cout << text.size() << ' ' << text[2] << '\n';
}

Массив word содержит изменяемую копию. std::string с явно заданной длиной может хранить нулевой символ внутри текста.

Результатbat 3 B

Полная таблица ASCII (коды символов): Полная таблица ASCII

ASCII: символы 0–127

Десятичный код, шестнадцатеричный код и символ. Управляющие коды не отображаются как обычные буквы. \0 обозначает NUL с кодом 0.

Показано 128 из 128

Dec	Hex	Символ	Название
0	0x00	`NUL`	NUL
1	0x01	`SOH`	SOH
2	0x02	`STX`	STX
3	0x03	`ETX`	ETX
4	0x04	`EOT`	EOT
5	0x05	`ENQ`	ENQ
6	0x06	`ACK`	ACK
7	0x07	`BEL`	BEL
8	0x08	`BS`	BS
9	0x09	`TAB`	TAB
10	0x0A	`LF`	LF
11	0x0B	`VT`	VT
12	0x0C	`FF`	FF
13	0x0D	`CR`	CR
14	0x0E	`SO`	SO
15	0x0F	`SI`	SI
16	0x10	`DLE`	DLE
17	0x11	`DC1`	DC1
18	0x12	`DC2`	DC2
19	0x13	`DC3`	DC3
20	0x14	`DC4`	DC4
21	0x15	`NAK`	NAK
22	0x16	`SYN`	SYN
23	0x17	`ETB`	ETB
24	0x18	`CAN`	CAN
25	0x19	`EM`	EM
26	0x1A	`SUB`	SUB
27	0x1B	`ESC`	ESC
28	0x1C	`FS`	FS
29	0x1D	`GS`	GS
30	0x1E	`RS`	RS
31	0x1F	`US`	US
32	0x20	`SPACE`	SPACE
33	0x21	`!`	!
34	0x22	`"`	"
35	0x23	`#`	#
36	0x24	`$`	$
37	0x25	`%`	%
38	0x26	`&`	&
39	0x27	`'`	'
40	0x28	`(`	(
41	0x29	`)`	)
42	0x2A	`*`	*
43	0x2B	`+`	+
44	0x2C	`,`	,
45	0x2D	`-`	-
46	0x2E	`.`	.
47	0x2F	`/`	/
48	0x30	`0`	0
49	0x31	`1`	1
50	0x32	`2`	2
51	0x33	`3`	3
52	0x34	`4`	4
53	0x35	`5`	5
54	0x36	`6`	6
55	0x37	`7`	7
56	0x38	`8`	8
57	0x39	`9`	9
58	0x3A	`:`	:
59	0x3B	`;`	;
60	0x3C	`<`	<
61	0x3D	`=`	=
62	0x3E	`>`	>
63	0x3F	`?`	?
64	0x40	`@`	@
65	0x41	`A`	A
66	0x42	`B`	B
67	0x43	`C`	C
68	0x44	`D`	D
69	0x45	`E`	E
70	0x46	`F`	F
71	0x47	`G`	G
72	0x48	`H`	H
73	0x49	`I`	I
74	0x4A	`J`	J
75	0x4B	`K`	K
76	0x4C	`L`	L
77	0x4D	`M`	M
78	0x4E	`N`	N
79	0x4F	`O`	O
80	0x50	`P`	P
81	0x51	`Q`	Q
82	0x52	`R`	R
83	0x53	`S`	S
84	0x54	`T`	T
85	0x55	`U`	U
86	0x56	`V`	V
87	0x57	`W`	W
88	0x58	`X`	X
89	0x59	`Y`	Y
90	0x5A	`Z`	Z
91	0x5B	`[`	[
92	0x5C	`\`	\
93	0x5D	`]`	]
94	0x5E	`^`	^
95	0x5F	`_`	_
96	0x60	`	`
97	0x61	`a`	a
98	0x62	`b`	b
99	0x63	`c`	c
100	0x64	`d`	d
101	0x65	`e`	e
102	0x66	`f`	f
103	0x67	`g`	g
104	0x68	`h`	h
105	0x69	`i`	i
106	0x6A	`j`	j
107	0x6B	`k`	k
108	0x6C	`l`	l
109	0x6D	`m`	m
110	0x6E	`n`	n
111	0x6F	`o`	o
112	0x70	`p`	p
113	0x71	`q`	q
114	0x72	`r`	r
115	0x73	`s`	s
116	0x74	`t`	t
117	0x75	`u`	u
118	0x76	`v`	v
119	0x77	`w`	w
120	0x78	`x`	x
121	0x79	`y`	y
122	0x7A	`z`	z
123	0x7B	`{`	{
124	0x7C	`\|`	\|
125	0x7D	`}`	}
126	0x7E	`~`	~
127	0x7F	`DEL`	DEL

\0код 0 · NUL

код 10 · LF

'A'код 65 · A

Если терминатора нет — опасное чтение

Функции вроде std::strlen и печать C-строки предполагают наличие \0. Если за границами массива продолжается поиск терминатора, возникает UB. Символ после первого нуля физически остаётся в массиве, но для C-строк он уже за логическим концом.

＋Дополнительно⌄

Почему корректно 2[a]?

Для встроенной индексации a[i] определено через *(a + i). Сложение целого и указателя коммутативно в этой форме, поэтому i[a] синтаксически корректно и даёт тот же элемент. Это интересный факт о C/C++, но такой стиль ухудшает читаемость.

unusual_index.cpp

#include <iostream>
int main() {
    int a[]{10, 20, 30};
    std::cout << a[2] << ' ' << 2[a];
}

Оба выражения обозначают одно значение — 30.

Как сохранить размер массива при передаче?

В современном C++ можно передать параметр по ссылке на массив: template<std::size_t N> void f(int (&a)[N]);. Для обычного кода удобнее использовать std::span (невладеющее представление непрерывной последовательности, C++20), std::array (фиксированный размер) или std::vector (динамический размер).

modern_arrays.cpp

#include <array>
#include <span>
#include <vector>
void print_first(std::span<const int> a) {
    if (!a.empty()) (void)a[0];
}
int main() {
    std::array<int, 3> fixed{1, 2, 3};
    std::vector<int> dynamic(100);
    print_first(fixed);
    print_first(dynamic);
}

std::span сохраняет длину в представлении; не владеет памятью.

Почему нет гарантии про служебные байты перед массивом?

Реальные аллокаторы могут хранить метаданные в разных местах; конкретное расположение является внутренней деталью реализации. Обращение к p[-1] при p, полученном от new[], не становится допустимым из-за того, что там иногда видны «интересные числа».

Современные альтернативы для функции-обратного вызова

Кроме обычных указателей на функции, компаратором могут быть функциональный объект или лямбда. Они поддерживают передачу дополнительного состояния, а компилятор зачастую может инлайнить вызовы.

lambda_sort.cpp

#include <algorithm>
#include <vector>
int main() {
    std::vector<int> a{8, 2, 9, 1, 5};
    std::sort(a.begin(), a.end(),
        [](int x, int y) { return x > y; });
}

Лямбда — современная альтернатива отдельно объявленному cmp.

Почему не стоит использовать ... в прикладном C++

В C-подобных вариадических функциях типы дополнительных аргументов не проверяются по сигнатуре, а при использовании va_arg требуется знать фактически переданный тип с учётом стандартных продвижений. Современная альтернатива — вариадические шаблоны и безопасные обёртки.

Справочник терминов

Термины встречаются внутри глав; здесь можно быстро найти определение.

array

Массив

Объект фиксированного размера из элементов одного типа, размещённых подряд.

Примеры кода

Первый минимум непустого массива

array-cases.cpp

#include <iostream>
int main() {
    constexpr int CAPACITY = 20;
    int values[CAPACITY]{};
    int n = 0;
    if (!(std::cin >> n) || n < 0 || n > CAPACITY) {
        std::cerr << "Invalid size\n";
        return 1;
    }
    for (int i = 0; i < n; ++i) {
        if (!(std::cin >> values[i]) || values[i] < -1000 || values[i] > 1000) {
            std::cerr << "Invalid value\n";
            return 1;
        }
    }
    if (n == 0) {
        std::cout << "No minimum\n";
        return 0;
    }
    int first = 0;
    for (int i = 1; i < n; ++i) {
        if (values[i] < values[first]) first = i;
    }
    std::cout << first << ' ' << values[first] << '\n';
}

Два вложенных цикла: сначала строка, затем её элементы.

matrix_rows.cpp

#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    for (int row = 0; row < 2; ++row) {
        int sum = 0;
        for (int column = 0; column < 3; ++column) sum += values[row][column];
        std::cout << row << ": " << sum << '\n';
    }
}

Обсудить лекцию с ИИ

Скопируйте промпт в свой ИИ-чат. В него уже включены материал этой лекции и примеры кода — можно сразу задавать вопросы и тренироваться.

Посмотреть промпт

Материал для разговора

Ты — мой преподаватель C++. Помоги мне разобраться в лекции «Массивы и функции» (лекция 06).

Кратко о лекции: Как обычный массив связан с указателями, что получает функция вместо массива, зачем нужен int (*)[N] и как передать функцию в сортировку.

Темы:
- Обычные массивы
- Двумерные массивы: строки и столбцы
- Обработка последовательности: сумма и первый минимум
- Массив и указатель
- Массив при передаче в функцию
- Динамические массивы и VLA
- Указатели на функции и сортировка
- Параметры функций
- Строки из символов (C-строки)
- Дополнительно
- Справочник терминов
- Примеры кода

Материал лекции:
Обычные массивы

Массив (array) — объект, состоящий из фиксированного числа элементов одного типа, расположенных подряд в памяти. Длина входит в тип массива.

Запись int a[5]; создаёт пять объектов int. Их индексы: 0…4. Размер должен быть известен во время компиляции. У локального массива без инициализации значения элементов не заданы .

Списковая инициализация / aggregate initialization
int a[5]{2, 3}; задаёт первые два элемента, а остальные обнуляет. Размер можно вывести из списка: int a[]{2,3,4};.

Визуализация / инициализация и индексы

Размеры и границы

sizeof(a) возвращает суммарное количество байт массива. Количество элементов можно вычислить как sizeof(a) / sizeof(a[0]), либо использовать std::size(a) (C++17).

Для int a[5], если sizeof(int)=4
sizeof(a) = 5 × 4 = 20 байт

Адрес a[5] — позиция за концом. Читать и записывать a[5] нельзя.

Выход за границы — UB
a[5] и a[-1] недопустимы для массива int a[5], даже если программа иногда «работает». Встроенный массив и vector::operator[] не проверяют индекс. У vector::at() есть проверка с исключением.

Двумерные массивы: строки и столбцы

Начните с двух индексов: a[i][j] выбирает строку i и столбец j. В матрице 2×3 допустимы i=0,1 и j=0,1,2. Первый цикл выбирает строку, второй последовательно обрабатывает её элементы.

Двумерный массив — массив, элементы которого сами являются массивами: int a[2][3] содержит 2 строки по 3 int в последовательной области памяти.

Главный вопрос — где стоит звёздочка относительно квадратных скобок. У int* p[5] первыми связываются [5]: это массив из пяти указателей. У int (*p)[5] скобки связывают *p раньше: это указатель на массив из пяти целых.

int** — не то же самое, что int (*)[5]. Первая форма — указатель на указатель; вторая — указатель на целую строку фиксированной длины.

Визуализация / строки и столбцы в памяти

Визуализация / чтение C++-объявлений

Объявление | Смысл |

Объявление: int a[5]; Смысл: 5 значений int

Объявление: int* a[5]; Смысл: 5 указателей на int

Объявление: int (*p)[5]; Смысл: указатель на массив из 5 int

Объявление: int** p; Смысл: указатель на указатель на int

Объявление: int a[2][3]; Смысл: 2 массива по 3 int

Почему важен тип строки?
Для int (*p)[3] выражение p + 1 перемещает указатель на следующую строку, то есть через 3 × sizeof(int) байт. Для int** шаг был бы по размерам указателя, а не целой строки.

Обработка последовательности: сумма и первый минимум

До обхода задайте контракт: 1…20 элементов, значения по модулю до 1000. Сумма начинается с нуля, минимум — с первого существующего элемента. При равенстве не меняйте выбранный индекс, если нужен первый минимум. Для пустого набора минимума нет: проверьте размер до обращения к a[0].

Задание: найдите сумму и первый максимум; затем суммы строк матрицы. Для индексов с нуля главная диагональ квадрата задаётся i=j, побочная — i+j=n−1. Центральный элемент нечётной матрицы учитывается один раз. Поворот и сдвиг слоя требуют отдельного алгоритма из подготовки к лабораторной.

Массив и указатель

Array-to-pointer conversion — неявное преобразование выражения типа «массив из N элементов T» в указатель T* на его начальный элемент в соответствующем контексте.

Когда пишем a + 2, массив a преобразуется в указатель на a[0]. Поэтому *(a + 2) обозначает a[2].

Указатель можно поставить на середину массива: int* p = a + 3;. Тогда p[-1] означает a[2] и корректен, поскольку адрес остаётся внутри того же массива .

Визуализация / сдвиг указателя и индексация

Что сравниваем | Массив int a[5] | Указатель int* p |

Что сравниваем: Тип; Массив int a[5]: int[5]; Указатель int* p: int*

Что сравниваем: Индекс [i]; Массив int a[5]: Есть; Указатель int* p: Есть

Что сравниваем: sizeof; Массив int a[5]: Размер всего массива; Указатель int* p: Размер самого указателя

Что сравниваем: Присвоить другой адрес; Массив int a[5]: Нельзя: a = p; Указатель int* p: Можно: p = a

Что сравниваем: Сдвиг ++; Массив int a[5]: ++a нельзя; Указатель int* p: ++p можно в пределах массива

Массив не равен указателю
Это разные типы. Преобразование происходит во многих выражениях, но не везде: например, sizeof(a) измеряет сам массив, а &a имеет тип «указатель на массив» (здесь int (*)[5]).

Массив при передаче в функцию

Подстройка типа параметра (array parameter adjustment) — правило объявления функций: параметр вида int a[5] интерпретируется как int* a. Указанная цифра не задаёт реального ограничения длины.

Функция не узнаёт число элементов из одного только параметра int a[]. Обычно передают длину отдельно или используют контейнер/ссылку на массив .

Визуализация / что на самом деле получает функция

Два объявления — одна сигнатура

void f(int a[5])исходная запись

void f(int* a)тип параметра после корректировки

Реальное число элементов массиву функции не передаётся автоматически.

Не используйте sizeof(a) для длины в такой функции
Внутри void f(int a[5]) параметр a уже имеет тип int*; sizeof(a) измерит указатель. Компилятор может предупредить об этом.

Интерфейс диапазона после указателей и ссылок

Функции обработки последовательности нужны не только элементы, но и границы допустимого обхода. Встроенный параметр вида int a[5] не передаёт функции массив длины пять: тип параметра корректируется к указателю. Поэтому одна цифра в скобках не защищает от неправильного размера. Можно передать указатель и длину отдельно, но они должны соответствовать одному действительному диапазону. Span объединяет доступ к непрерывным элементам и их количество в одном небольшом представлении. Он не владеет элементами и не копирует всю последовательность. В примере span<const int> разрешает чтение, а сумма возвращается отдельным числом. Один интерфейс принимает array и vector. Владелец исходных элементов должен оставаться живым всё время использования span. Наличие размера само по себе не делает любой индекс безопасным: в C++20 operator[] у span не обещает проверку границ. Наш обход берёт только существующие элементы, а пустой диапазон даёт сумму ноль.

Динамические массивы и VLA

new[] возвращает указатель

new int[n]{} создаёт n элементов в динамической памяти, обнуляет их и возвращает int*. Освобождение — строго delete[] p;.

Парное выделение и освобождение / new[] / delete[]
new T[n] должно соответствовать delete[], а new T — delete. Несовпадение — UB.

Визуализация / выделение, обнуление и освобождение

Почему int a[n] — не стандартный C++?

Встроенный массив int a[N] требует константного выражения размера. Запись int n; std::cin >> n; int a[n]; — VLA: некоторые компиляторы принимают её как расширение, но стандартный C++ запрещает.

Массив переменной длины / VLA
Массив, размер которого узнаётся только во время выполнения. Для переносимого C++ используем std::vector<int> a(n);.

Не трогайте служебную память аллокатора
Примеры чтения a[-1] и ручного delete[] v.data() из лекции демонстрируют опасные последствия, но оба действия недопустимы. Писать их в настоящей программе нельзя.

Указатели на функции и сортировка

Указатель на функцию (function pointer) — значение, позволяющее обратиться к функции определённой сигнатуры через переменную. Например, bool (*cmp)(int,int).

Чтобы передать алгоритму правило сравнения, определяем функцию bool cmp(int a, int b) и передаём её в std::sort. Выражения cmp и &cmp в этом контексте дают указатель на функцию.

Компаратор / comparator
Функция-предикат, отвечающая, должен ли первый элемент идти раньше второго.

Для std::sort(first,last,cmp) диапазон полуоткрытый: [first,last). Компаратор должен задавать строгий слабый порядок .

Визуализация / передаём компаратор в алгоритм

Тип указателя

Объявление читается от имени: (*p) — указатель; затем (int,int) — функция с двумя параметрами; слева bool — возвращаемый тип. Типы аргументов и результата входят в тип указателя.

Чтение от имени переменной

(*p)указатель

(int,int)два аргумента

boolрезультат

bool (*p)(int, int);

Адрес перегруженной функции
Если есть f(int) и f(double), контекст требуемого типа указателя может выбрать нужную перегрузку. Без такого контекста выражение &f неоднозначно. Если определение выбранной функции отсутствует, обычно возникает ошибка компоновки.

Параметры функций

Аргументы по умолчанию

Аргумент по умолчанию (default argument) — выражение, подставляемое при вызове, когда соответствующий аргумент не указан.

Обычно значения по умолчанию образуют концевой непрерывный суффикс параметров. Нельзя оставить обязательный параметр после необязательного.

Визуализация / сколько аргументов передано

У std::sort здесь не аргумент по умолчанию
В лекции приведена удобная аналогия, но технически std::sort(first,last) и std::sort(first,last,comp) — разные перегрузки, а не просто единственная функция с третьим параметром по умолчанию.

C-подобное многоточие

Объявление void log(const char* format, ...); разрешает дополнительные аргументы разных типов. Это исторический механизм printf; ручная обработка требует <cstdarg>.

Строки из символов (C-строки)

Нуль-терминированная строка (null-terminated string) — последовательность символов char, конец которой обозначается первым символом \0.

Литерал "Hello" в C++ имеет тип массива const char[6]: пять букв и завершающий \0. В записи const char* s = "Hello"; массив преобразуется в указатель. Изменять сам литерал нельзя.

char text[] = "Hello"; создаёт собственный изменяемый массив. Для std::cout << s перегрузка вывода для C-строк печатает символы до первого нуля, а не адрес .

Визуализация / нулевой терминатор и вывод

Полная таблица ASCII (коды символов):

\0код 0 · NUL

код 10 · LF

'A'код 65 · A

Если терминатора нет — опасное чтение
Функции вроде std::strlen и печать C-строки предполагают наличие \0. Если за границами массива продолжается поиск терминатора, возникает UB. Символ после первого нуля физически остаётся в массиве, но для C-строк он уже за логическим концом.

＋Дополнительно⌄

Почему корректно 2[a]?

Для встроенной индексации a[i] определено через *(a + i). Сложение целого и указателя коммутативно в этой форме, поэтому i[a] синтаксически корректно и даёт тот же элемент. Это интересный факт о C/C++, но такой стиль ухудшает читаемость.

Как сохранить размер массива при передаче?

В современном C++ можно передать параметр по ссылке на массив: template<std::size_t N> void f(int (&a)[N]);. Для обычного кода удобнее использовать std::span (невладеющее представление непрерывной последовательности, C++20), std::array (фиксированный размер) или std::vector (динамический размер).

Почему нет гарантии про служебные байты перед массивом?

Реальные аллокаторы могут хранить метаданные в разных местах; конкретное расположение является внутренней деталью реализации. Обращение к p[-1] при p, полученном от new[], не становится допустимым из-за того, что там иногда видны «интересные числа».

Современные альтернативы для функции-обратного вызова

Кроме обычных указателей на функции, компаратором могут быть функциональный объект или лямбда. Они поддерживают передачу дополнительного состояния, а компилятор зачастую может инлайнить вызовы.

Почему не стоит использовать ... в прикладном C++

В C-подобных вариадических функциях типы дополнительных аргументов не проверяются по сигнатуре, а при использовании va_arg требуется знать фактически переданный тип с учётом стандартных продвижений. Современная альтернатива — вариадические шаблоны и безопасные обёртки.

Справочник терминов

Термины встречаются внутри глав; здесь можно быстро найти определение.

Примеры кода

Примеры кода из лекции:

array_init.cpp
```cpp
#include <iostream>
#include <iterator>
int main() {
    int a[5]{2, 3};       // 2 3 0 0 0
    int b[]{4, 5, 6};     // размер = 3
    a[1] = 10;
    std::cout << std::size(a) << ' ' << a[1] << ' ' << b[0];
}
```
Инициализация массивов нулями и значениями.

array-zeroes.cpp
```cpp
#include <iostream>
#include <iterator>
int main() {
    int values[4]{};
    std::cout << std::size(values) << '\n';
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}
```
Четыре элемента созданы и инициализированы нулями. Размер принадлежит типу массива и доступен через std::size.

array-partial-init.cpp
```cpp
#include <iostream>
int main() {
    int values[5]{2, 3};
    values[1] = 10;
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}
```
Оставшиеся элементы получают нули. Запись values[1] = 10 происходит позже и является присваиванием.

matrix_rows.cpp
```cpp
#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    for (int row = 0; row < 2; ++row) {
        int sum = 0;
        for (int column = 0; column < 3; ++column) sum += values[row][column];
        std::cout << row << ": " << sum << '\n';
    }
}
```
Два вложенных цикла: сначала строка, затем её элементы.

matrix.cpp
```cpp
#include <iostream>
int main() {
    int a[2][3]{{1, 2, 3}, {4, 5, 6}};
    int (*row)[3] = a; // указатель на строку
    int* first = a[0]; // указатель на int
    std::cout << row[1][2] << ' ' << first[2];
}
```
row + 1 шагает на 3 int, first + 1 — на 1 int.

matrix-row-pointer.cpp
```cpp
#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    int (*row)[3] = values;
    ++row;
    std::cout << (*row)[0] << ' ' << row[0][2] << '\n';
}
```
После ++row указатель обозначает вторую строку целиком. Тип int (*)[3] сохраняет её длину.

matrix-nested-walk.cpp
```cpp
#include <iostream>
int main() {
    int values[2][3]{{1, 2, 3}, {4, 5, 6}};
    int total = 0;
    for (const auto& row : values) {
        for (int value : row) total += value;
    }
    std::cout << total << '\n';
}
```
Ссылка на строку не превращает её в указатель. Внутренний цикл обходит только элементы своей строки.

array-pointer-forms.cpp
```cpp
#include <iostream>
int main() {
    int values[3]{4, 5, 6};
    int* pointers[3]{&values[0], &values[1], &values[2]};
    int (*whole)[3] = &values;
    std::cout << *pointers[1] << ' ' << (*whole)[1] << '\n';
}
```
pointers хранит три адреса, whole хранит адрес одного массива из трёх int. Оба выражения читают один элемент разными путями.

array-type-alias.cpp
```cpp
#include <iostream>
#include <type_traits>
using Row = int[3];
int main() {
    Row matrix[2]{{1, 2, 3}, {4, 5, 6}};
    Row* row = matrix;
    static_assert(std::is_same_v<decltype(row), int (*)[3]>);
    std::cout << row[1][2] << '\n';
}
```
Псевдоним Row упрощает чтение объявления, сохраняя тот же тип указателя на массив.

pointer_array.cpp
```cpp
#include <iostream>
int main() {
    int a[5]{10, 20, 30, 40, 50};
    int* p = a + 3;
    std::cout << a[2] << ' ' << *(a + 2) << '\n';
    std::cout << p[-1] << ' ' << p[0] << '\n';
}
```
p[-1] корректен: это a[2], элемент внутри a.

array-negative-offset.cpp
```cpp
#include <iostream>
int main() {
    int values[]{10, 20, 30, 40, 50};
    int* current = values + 3;
    std::cout << current[-1] << ' ' << current[0] << '\n';
    std::cout << (current - values) << '\n';
}
```
current[-1] — элемент с индексом 2 исходного массива. Это движение назад внутри того же массива.

array-end-marker.cpp
```cpp
#include <iostream>
int main() {
    int values[]{4, 5, 6};
    const int* end = values + 3;
    for (const int* current = values; current != end; ++current) {
        std::cout << *current << ' ';
    }
    std::cout << '\n';
}
```
Условие проверяется до чтения. Когда current достигает end, цикл завершается без разыменования конца диапазона.

array_arguments.cpp
```cpp
#include <cstddef>
#include <iostream>
void print(const int a[], std::size_t n) {
    // a имеет тип const int*
    for (std::size_t i = 0; i < n; ++i)
        std::cout << a[i] << ' ';
}
int main() {
    int a[5]{1, 2, 3, 4, 5};
    print(a, 5);
}
```
Размер передаём отдельно: массив внутри print превратился в указатель.

array-adjusted-parameter.cpp
```cpp
#include <iostream>
#include <type_traits>
void inspect(int values[7]) {
    static_assert(std::is_same_v<decltype(values), int*>);
    std::cout << values[1] << '\n';
}
int main() {
    int values[]{10, 20, 30};
    inspect(values);
}
```
Число 7 не заставляет функцию получить семь элементов. Здесь безопасно читается существующий элемент с индексом 1.

array-reference-size.cpp
```cpp
#include <cstddef>
#include <iostream>
template<std::size_t N>
void inspect(const int (&values)[N]) {
    std::cout << N << ' ' << values[N - 1] << '\n';
}
int main() {
    int values[]{10, 20, 30};
    inspect(values);
}
```
Ссылка привязывается ко всему массиву. Компилятор выводит N из его типа; отдельный аргумент длины не нужен.

code-guided-range.cpp
```cpp
#include <array>
#include <iostream>
#include <span>
#include <vector>

long long sum(std::span<const int> values) {
    long long result = 0;
    for (int value : values) {
        result += value;
    }
    return result;
}

int main() {
    const std::array<int, 3> fixed{1, 2, 3};
    const std::vector<int> dynamic{4, 5};
    std::cout << sum(fixed) << ' ' << sum(dynamic) << '\n';
}
```
Span передаёт доступ и длину, но не владеет данными и не обещает проверку operator[].

new_array.cpp
```cpp
#include <cstddef>
int main() {
    std::size_t n = 100;
    int* a = new int[n]{}; // 100 нулей
    a[2] = 19;
    delete[] a;
    a = nullptr;
}
```
Запрос может зависеть от n во время выполнения; освобождение — delete[].

array-matched-delete.cpp
```cpp
#include <iostream>
int main() {
    int* single = new int(5);
    int* values = new int[3]{};
    values[1] = *single;
    std::cout << values[0] << ' ' << values[1] << '\n';
    delete single;
    delete[] values;
}
```
Один объект освобождается delete, массив — delete[]. После освобождения программа больше не читает эти адреса.

array-runtime-vector.cpp
```cpp
#include <iostream>
#include <vector>
int main() {
    int count = 4;
    std::vector<int> values(count);
    values.back() = 9;
    std::cout << values.size() << ' ' << values.front()
              << ' ' << values.back() << '\n';
}
```
Размер count не обязан быть константой времени компиляции. vector создаёт элементы и управляет памятью без VLA.

portable_array.cpp
```cpp
#include <iostream>
#include <vector>
constexpr int MAX_SIZE = 1000;
int main() {
    int n = 0;
    if (!(std::cin >> n) || n < 0 || n > MAX_SIZE) {
        std::cerr << "Invalid size\n";
        return 1;
    }
    std::vector<int> values(n);
    std::cout << values.size() << '\n';
    // int bad[n]; // VLA не входит в стандарт C++20.
}
```
До создания vector проверяются чтение и диапазон 0…1000. Пустой массив допустим; неверный ввод отклоняется.

function_pointer_sort.cpp
```cpp
#include <algorithm>
#include <iostream>
bool descending(int a, int b) {
    return a > b;
}
int main() {
    int a[]{8, 2, 9, 1, 5};
    bool (*cmp)(int, int) = &descending;
    std::sort(a, a + 5, cmp);
    for (int x : a) std::cout << x << ' ';
}
```
Параметр cmp — указатель на функцию сравнения.

sort-function-pointer.cpp
```cpp
#include <algorithm>
#include <iostream>
bool descending(int left, int right) { return left > right; }
int main() {
    int values[]{8, 2, 9, 1, 5};
    bool (*compare)(int, int) = descending;
    std::sort(values, values + 5, compare);
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}
```
Указатель compare хранит выбранную функцию. Обратите внимание: при сортировке по убыванию компаратор использует >.

sort-absolute-values.cpp
```cpp
#include <algorithm>
#include <cstdlib>
#include <iostream>
bool by_magnitude(int left, int right) {
    if (std::abs(left) != std::abs(right))
        return std::abs(left) < std::abs(right);
    return left < right;
}
int main() {
    int values[]{2, -1, -2, 1};
    std::sort(values, values + 4, by_magnitude);
    for (int value : values) std::cout << value << ' ';
    std::cout << '\n';
}
```
При равных модулях второе правило задаёт однозначный порядок. Для этих небольших чисел вычисление модуля безопасно.

overloaded_address.cpp
```cpp
#include <iostream>
void f(int x) { std::cout << x; }
void f(double x) { std::cout << x; }
int main() {
    void (*p)(int) = &f;    // выбирает f(int)
    void (*q)(double) = &f; // выбирает f(double)
    p(3);
    q(2.5);
}
```
Контекст типа указателя разрешает перегрузку.

default_args.cpp
```cpp
#include <iostream>
int sum(int x = 1, int y = 2, int z = 3) {
    return x + y + z;
}
int main() {
    std::cout << sum() << ' ';
    std::cout << sum(4) << ' ';
    std::cout << sum(4, 8, 10);
}
```
Результат: 6 9 22.

function-default-values.cpp
```cpp
#include <iostream>
int sum(int x = 1, int y = 2, int z = 3) { return x + y + z; }
int main() {
    std::cout << sum() << ' ' << sum(4) << ' '
              << sum(4, 8, 10) << '\n';
}
```
В первом вызове подставляются все три значения, во втором — последние два, в третьем ничего не подставляется.

function-default-declaration.cpp
```cpp
#include <iostream>
int sum(int x, int y = 10);
int sum(int x, int y) { return x + y; }
int main() {
    std::cout << sum(3) << ' ' << sum(3, 4) << '\n';
}
```
Повторять значение по умолчанию в определении не нужно. Достаточно объявления, доступного вызывающему коду.

variadic.cpp
```cpp
#include <cstdio>
int main() {
    std::printf("%d %.1f\n", 5, 2.5);
    // printf принимает формат и аргументы ...
}
```
В C-вариадических функциях типы контролируются слабее.

c_strings.cpp
```cpp
#include <cstring>
#include <iostream>
int main() {
    char s[]{'A', 'B', '\0', 'C', 'D', '\0'};
    const char* literal = "Hello";
    std::cout << s << ' ' << std::strlen(s) << '\n';
    std::cout << literal << '\n';
    // s[3] существует, но за первым \0
}
```
std::cout выведет AB 2 и Hello.

cstring-first-zero.cpp
```cpp
#include <cstring>
#include <iostream>
int main() {
    char text[]{'A', 'B', '\0', 'C', 'D', '\0'};
    std::cout << text << '\n';
    std::cout << std::strlen(text) << ' ' << sizeof(text) << '\n';
}
```
strlen останавливается на первом нуле, sizeof учитывает все шесть элементов массива char.

cstring-writable-copy.cpp
```cpp
#include <iostream>
#include <string>
int main() {
    char word[] = "cat";
    word[0] = 'b';
    std::string text{"A\0B", 3};
    std::cout << word << '\n';
    std::cout << text.size() << ' ' << text[2] << '\n';
}
```
Массив word содержит изменяемую копию. std::string с явно заданной длиной может хранить нулевой символ внутри текста.

unusual_index.cpp
```cpp
#include <iostream>
int main() {
    int a[]{10, 20, 30};
    std::cout << a[2] << ' ' << 2[a];
}
```
Оба выражения обозначают одно значение — 30.

modern_arrays.cpp
```cpp
#include <array>
#include <span>
#include <vector>
void print_first(std::span<const int> a) {
    if (!a.empty()) (void)a[0];
}
int main() {
    std::array<int, 3> fixed{1, 2, 3};
    std::vector<int> dynamic(100);
    print_first(fixed);
    print_first(dynamic);
}
```
std::span сохраняет длину в представлении; не владеет памятью.

lambda_sort.cpp
```cpp
#include <algorithm>
#include <vector>
int main() {
    std::vector<int> a{8, 2, 9, 1, 5};
    std::sort(a.begin(), a.end(),
        [](int x, int y) { return x > y; });
}
```
Лямбда — современная альтернатива отдельно объявленному cmp.

array-cases.cpp
```cpp
#include <iostream>
int main() {
    constexpr int CAPACITY = 20;
    int values[CAPACITY]{};
    int n = 0;
    if (!(std::cin >> n) || n < 0 || n > CAPACITY) {
        std::cerr << "Invalid size\n";
        return 1;
    }
    for (int i = 0; i < n; ++i) {
        if (!(std::cin >> values[i]) || values[i] < -1000 || values[i] > 1000) {
            std::cerr << "Invalid value\n";
            return 1;
        }
    }
    if (n == 0) {
        std::cout << "No minimum\n";
        return 0;
    }
    int first = 0;
    for (int i = 1; i < n; ++i) {
        if (values[i] < values[first]) first = i;
    }
    std::cout << first << ' ' << values[first] << '\n';
}
```

Как вести занятие:
1. Начни с одного вопроса, чтобы проверить, как я понял основную идею лекции. Дождись моего ответа.
2. Задавай по одному вопросу за раз. Подстраивай сложность под мои ответы.
3. Если я ошибаюсь, сначала дай подсказку и предложи подумать ещё раз. Затем объясни ошибку на небольшом примере.
4. Чередуй объяснение, чтение кода и короткие задания. Предлагай предсказать результат до объяснения.
5. Уточняй стандарт C++, если от него зависит ответ. Различай ошибки компиляции, выполнения и неопределённое поведение. Если результат не гарантирован, объясни почему.
6. Не выдавай готовое решение практического задания сразу. Помоги мне дойти до него самостоятельно.
7. В конце предложи краткий итог: что я понял, где ошибался и что повторить.

Начни с первого вопроса по этой лекции.