Константность и права доступа

#include <iostream>
int main() {
    int x = 5;
    int& writable = x;
    const int& readable = x;
    writable = 6;         // OK
    // readable = 7;      // CE
    std::cout << readable; // 6
    // int& error = readable; // CE
}

#include <iostream>
int main() {
    int value = 5;
    const int& view = value;
    std::cout << view << '\n';
    value = 12;
    std::cout << view << '\n';
    std::cout << std::boolalpha << (&view == &value) << '\n';
}

#include <iostream>
int main() {
    const int limit = 7;
    const int& view = limit;
    int copy = view;
    ++copy;
    std::cout << limit << ' ' << view << ' ' << copy << '\n';
    // ++view; // ошибка: изменение через const int& запрещено
    // ++limit; // ошибка: сам limit тоже константный
}

Создание константного объекта в динамической памяти

new const int(5) возвращает const int*. Поскольку объект константный, его нужно инициализировать сразу. Обычный int* не может принять такой указатель неявно.

int main() {
    const int* one = new const int(5);
    const int* many = new const int[3]{1, 2, 3};
    // const int* bad = new const int; // CE: объект не инициализирован
    // int* bad2 = new const int(5);   // CE: теряется const
    delete one;
    delete[] many;
}

#include <iostream>
#include <string>
void consume(int x) { ++x; }                    // копия
void modify(std::string& s) { s += "!"; }         // меняем оригинал
void inspect(const std::string& s) {
    std::cout << s.size();                       // только чтение
}
int main() {
    int x = 3;
    std::string s = "abc";
    consume(x);                // x всё ещё 3
    modify(s);                 // s стало "abc!"
    inspect(s);
}

#include <cstddef>
#include <iostream>
#include <string>
int squared(int value) { return value * value; }
std::size_t textLength(const std::string& text) { return text.size(); }
int main() {
    int number = 4;
    std::string message = "hello";
    std::cout << squared(number) << ' ' << textLength(message) << '\n';
    std::cout << number << ' ' << message << '\n';
}

#include <iostream>
#include <string>
std::string decorate(std::string text) {
    text += "!";
    return text;
}
int main() {
    std::string original = "hello";
    std::string result = decorate(original);
    std::cout << original << ' ' << result << '\n';
    std::cout << decorate(std::string{"ready"}) << '\n';
}

#include <iostream>
int incrementCopy(int value) {
    ++value;
    return value;
}
int main() {
    int original = 5;
    int result = incrementCopy(original);
    std::cout << original << ' ' << result << '\n';
}

#include <iostream>
void increment(int& value) { ++value; }
int read(const int& value) { return value; }
int main() {
    int original = 5;
    increment(original);
    std::cout << original << ' ' << read(original) << '\n';
}

Разобранный пример и самостоятельная проверка

Перед написанием функции задайте три вопроса. Нужно ли изменить объект вызывающего кода? Нужно ли только прочитать большой объект? Нужна ли функции собственная копия? Для небольшого int или double обычно выбирают значение. Для изменения исходной строки подойдёт string&. Для чтения уже существующей строки без её копирования удобно const string&. Слово const здесь ограничивает операции через данный параметр, а не делает исходную неконстантную строку навсегда неподвижной. Другой разрешённый путь может её изменить. Если функция должна получить собственный объект, передача по значению остаётся осмысленным выбором даже для строки. Это стартовые рекомендации, а не утверждение, что любая ссылка быстрее любой копии. Сначала выберите нужное поведение и владение, затем проверяйте стоимость. Именованная константа задаётся при создании; последующее присваивание ей недопустимо. Указатели с несколькими уровнями const для этого первого выбора не нужны.

#include <cstddef>
#include <iostream>
#include <string>

std::size_t length(const std::string& text) {
    return text.size();
}

void addMark(std::string& text) {
    text += '!';
}

int main() {
    std::string text = "hello";
    const std::size_t oldLength = length(text);
    addMark(text);
    std::cout << oldLength << ' ' << text << '\n';
}

Этот раздел нужен перед лабораторной 7 «Файлы». Он использует уже знакомые строки, циклы, указатели и время жизни объектов. Файл позволяет сохранить данные после завершения программы (проще говоря, значения остаются на диске, а не только в переменных).

#include <fstream> подключает std::ifstream для чтения и std::ofstream для записи. Они похожи на std::cin и std::cout, но связаны с именованным файлом. Относительный путь отсчитывается от рабочей папки запущенной программы, которая может отличаться от папки исходника.

Первое занятие: текстовые строки и слова

Файловый поток похож на знакомый cin, но читает из указанного файла. Перед первым чтением проверим, удалось ли его открыть. Путь notes.txt отсчитывается от рабочей папки процесса, поэтому место сохранения исходника не всегда подходит. Getline получает очередную строку; пустая строка тоже считается строкой. Внутри неё istringstream последовательно выделяет слова, разделённые пробельными символами. Число строк увеличивается после успешного getline, число слов — после успешного извлечения слова. Проверять eof до чтения не нужно: он не предсказывает успех следующей операции. После завершения цикла отдельно проверяем, был ли обычный конец файла, а не ошибка ввода. Пустой файл даёт два нуля. Локальный ifstream автоматически закрывает ресурс при выходе из main. Для записи понадобится ещё одна проверка: перед сообщением об успехе убедиться, что поток успешно завершил сохранение. Бинарные числа и изменение исходного файла изучаются отдельным шагом.

#include <cstddef>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::ifstream input("notes.txt");
    if (!input) {
        std::cerr << "Cannot open notes.txt\n";
        return 1;
    }
    std::size_t lines = 0;
    std::size_t words = 0;
    std::string line;
    while (std::getline(input, line)) {
        ++lines;
        std::istringstream row(line);
        std::string word;
        while (row >> word) {
            ++words;
        }
    }
    if (input.bad() || !input.eof()) {
        std::cerr << "Read error\n";
        return 1;
    }
    std::cout << lines << ' ' << words << '\n';
}

Открытие, чтение и конец файла

Сразу после открытия проверьте поток: if (!input) означает, что читать нельзя. Проверка eof() до попытки чтения не предсказывает её успех. В обычном цикле while (input >> value) тело выполняется только после успешного извлечения; последнюю переменную нельзя использовать ещё раз после неудачного чтения.

Для строгой проверки файла нужно отличить чистый конец данных от испорченной записи. Пример ниже сначала пропускает пробельные символы через std::ws, проверяет конец, а затем читает число. Поэтому пустой файл даёт нулевую сумму, а текст вместо числа, переполнение типа и обрыв недопустимой записи дают отказ. bad() указывает на серьёзную ошибку ввода-вывода.

Создайте рядом с программой numbers.txt с содержимым 4 -2 7. Результат будет count=3 sum=9. Вариант без завершающего перевода строки тоже должен работать. Константы имени файла и допустимых границ объявлены вне main.

#include <fstream>
#include <iostream>

constexpr char INPUT_FILE[] = "numbers.txt";
constexpr int MAX_RECORDS = 1000000;
constexpr int MAX_ABSOLUTE_VALUE = 1000000;

int main() {
    std::ifstream input(INPUT_FILE);
    if (!input) {
        std::cerr << "Cannot open input\n";
        return 1;
    }
    long long sum = 0;
    int count = 0;
    while (true) {
        input >> std::ws;
        if (input.bad()) {
            std::cerr << "Read error\n";
            return 1;
        }
        if (input.eof()) break;
        int value = 0;
        if (!(input >> value) || value < -MAX_ABSOLUTE_VALUE
                || value > MAX_ABSOLUTE_VALUE || count == MAX_RECORDS) {
            std::cerr << "Invalid record\n";
            return 1;
        }
        sum += value;
        ++count;
    }
    std::cout << "count=" << count << " sum=" << sum << '\n';
}

Запись и владение ресурсом

std::ofstream output("result.txt"); открывает файл для записи и по умолчанию заменяет прежнее содержимое. Для добавления используют std::ios::app. Записывайте через output << value << '\n'; и проверяйте состояние после операций. Для проверяемого завершения вызовите output.close() и ещё раз проверьте поток: ошибка может обнаружиться при сбросе буфера.

Файловый поток закрывает свой ресурс при разрушении объекта — это пример RAII из лекции 9. Ранний return тоже разрушает локальные потоки. Но автоматическое закрытие не заменяет проверку результата записи: перед сообщением об успехе нужно убедиться, что данные сохранены.

«Типизированный» файл целых чисел

В условиях лабораторной этим словом обозначен двоичный файл последовательных значений int. Режим std::ios::binary отключает текстовые преобразования. write и read получают адрес байтов и их количество. В примере reinterpret_cast даёт доступ к представлению int через указатель на char; это не преобразование числа в текст.

Такой учебный формат читается той же программой на той же платформе: размер int, порядок байтов и представление зависят от реализации. Не применяйте этот способ к std::string или std::vector: байты их служебных объектов не являются сохранённым содержимым контейнера.

Следующий пример создаёт собственный демонстрационный файл, записывает три числа и читает их без массива-буфера. После неуспешного чтения gcount() показывает число реально извлечённых байтов: ненулевой неполный хвост означает повреждённую запись. Чистый конец наступает, когда извлечено ноль байтов.

#include <fstream>
#include <iostream>

constexpr char DATA_FILE[] = "binary-demo.dat";

int main() {
    // This example deliberately creates its own demonstration file.
    std::ofstream output(DATA_FILE, std::ios::binary | std::ios::trunc);
    if (!output) return 1;
    const int values[]{4, -2, 7};
    for (int value : values) {
        output.write(reinterpret_cast<const char*>(&value), sizeof(value));
        if (!output) return 1;
    }
    output.close();
    if (!output) return 1;

    std::ifstream input(DATA_FILE, std::ios::binary);
    if (!input) return 1;
    int value = 0;
    int count = 0;
    long long sum = 0;
    while (input.read(reinterpret_cast<char*>(&value), sizeof(value))) {
        ++count;
        sum += value;
    }
    if (input.bad() || !input.eof() || input.gcount() != 0) {
        std::cerr << "Incomplete record or read error\n";
        return 1;
    }
    std::cout << "count=" << count << " sum=" << sum << '\n';
}

Матрица неизвестного размера без загрузки в массив

Читайте файл построчно через std::getline. std::istringstream из <sstream> позволяет читать числа из одной строки тем же оператором >>. Это строковый поток, а не массив всей матрицы. Число значений первой строки задаёт ожидаемое число столбцов; остальные строки должны иметь столько же значений.

Создайте matrix.txt из двух строк: 1 2 и 3 4. Пример определит размер 2 × 2 и сумму 10 без хранения таблицы. Пустой файл, пустая строка, нечисловой элемент и строки разной длины отклоняются. Для задания со столбцами сделайте повторный проход, выбирая нужную позицию в каждой строке.

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

constexpr char MATRIX_FILE[] = "matrix.txt";
constexpr int MAX_SIDE = 100;
constexpr int MAX_ABSOLUTE_VALUE = 1000000;

int main() {
    std::ifstream input(MATRIX_FILE);
    if (!input) return 1;
    std::string line;
    int rows = 0;
    int columns = -1;
    long long sum = 0;
    while (std::getline(input, line)) {
        std::istringstream row(line);
        int currentColumns = 0;
        while (true) {
            row >> std::ws;
            if (row.eof()) break;
            int value = 0;
            if (!(row >> value) || currentColumns == MAX_SIDE
                    || value < -MAX_ABSOLUTE_VALUE
                    || value > MAX_ABSOLUTE_VALUE) return 1;
            sum += value;
            ++currentColumns;
        }
        if (currentColumns == 0 || rows == MAX_SIDE) return 1;
        if (columns == -1) columns = currentColumns;
        if (columns != currentColumns) return 1;
        ++rows;
    }
    if (input.bad() || !input.eof() || rows == 0) return 1;
    std::cout << "rows=" << rows << " columns=" << columns
              << " sum=" << sum << '\n';
}

Повторные проходы и рабочие файлы

Для нового прохода проще создать новый std::ifstream с тем же именем. Если используете прежний поток, сначала вызовите clear(), чтобы снять признаки конца и ошибки, затем seekg(0) и проверьте результат. tellg() возвращает позицию потока, а не порядковый номер числа. Номер записи считайте отдельной переменной с нуля.

Для удаления участка сначала найдите его границы, затем новым проходом перепишите сохраняемые записи в другой файл. Не перезаписывайте исходник до проверки результата. Для учебного отчёта достаточно оставить оба файла и показать их содержимое. Сортировку файла без массива можно выполнить несколькими проходами: на каждом искать следующий минимум и записывать нужное число его повторений.

Перед защитой проверьте пустой файл, одну запись, повторные экстремумы, отсутствие нужного элемента, недоступный путь, испорченный текст и неполную двоичную запись. Состояние операций чтения и gcount() описаны в разделе проекта стандарта C++ о неформатированном вводе.

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