Пишем вывод последних строк файла на C++!

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

Для этого удобно использовать std::deque. Он позволяет добавлять строки в конец и удалять самые старые строки из начала.

Сначала подключим нужные заголовки:

#include <deque>
#include <fstream>
#include <iostream>
#include <string>

Теперь открываем файл и готовим контейнер:

std::ifstream in(path);
std::deque<std::string> tail;
std::string line;

При чтении добавляем новую строку в конец:

while (std::getline(in, line)) {
    tail.push_back(line);
}

Если строк стало больше лимита, удаляем самую старую:

if (tail.size() > limit) {
    tail.pop_front();
}

В итоге печатаем то, что осталось в deque:

for (const auto& row : tail) {
    std::cout << row << '\n';
}

Такой подход работает потоково. Даже если лог большой, в памяти одновременно лежит только нужное количество последних строк.

📣 C++ Ready | #практика

Почему setprecision не всегда означает количество знаков после точки?

В C++ для форматирования дробных чисел часто используют std::setprecision. На первый взгляд кажется, что он задаёт количество цифр после запятой.

Но без std::fixed это не так:

std::cout << std::setprecision(3) << 123.456;

Результат будет не 123.456 с тремя знаками после точки. Поток выведет три значащие цифры:

123

Если нужны знаки после точки, добавляют std::fixed:

std::cout << std::fixed << std::setprecision(3)
          << 123.456;

Теперь результат будет предсказуемым:

123.456

Для маленьких чисел разница ещё заметнее:

std::cout << std::setprecision(2) << 0.012345;

Без fixed поток снова считает значащие цифры и может перейти к компактной форме вывода.

std::setprecision сам по себе управляет точностью, а не обязательно количеством символов после точки.

📣 C++ Ready | #совет

👨‍💻 CppCourse — курс по C++ и объектно-ориентированному программированию!

Обучение идёт от работы с памятью, классов и наследования до шаблонов, STL, RAII, умных указателей и других возможностях C++. Теория закрепляется на учебном проекте, а ещё есть лабораторные, экзаменационные материалы и отдельный демо-проект с юнит-тестами, паттернами и архитектурой MVP.

Оставляю ссылочку: GitHub 📱

📣 C++ Ready | #репозиторий

Почему std::move сам ничего не перемещает?

Кажется, что вызов уже перенёс данные из одного объекта в другой.

На деле std::move только сообщает компилятору, что объект можно рассматривать как временный. Само перемещение происходит, когда другой код выбирает move-конструктор или move-присваивание.

std::string source = "report";
std::string target = std::move(source);

Здесь строка target забирает ресурсы source. После этого source остаётся валидной, но её содержимое не определено контрактом и часто оказывается пустым.

Поэтому нельзя писать логику, которая рассчитывает на конкретное значение после перемещения.

send(std::move(message));
// message больше не используем как прежнее значение

У std::move есть ещё одна ловушка. Перемещение из const-объекта обычно превращается в копирование, потому что move-конструктор не может менять источник.

const std::string name = "ready";
auto copy = std::move(name);

Такой код компилируется, но для std::string будет создана копия. Полезно применять std::move на последнем использовании объекта, когда прежнее значение действительно больше не нужно.

📣 C++ Ready | #совет

Большой разбор C++ механик!

Автор собрал масштабный материал по приёмам, которые встречаются в современном и легаси C++ коде. Внутри есть RAII, Scope Guard, умные указатели, move-семантика, шаблоны, исключения, Pimpl и десятки других идей с объяснением, откуда они появились.

В статье разбирают:
• как связывать владение ресурсом со временем жизни объекта
• почему noexcept влияет на производительность контейнеров
• где старые идиомы помогают понять код движков и библиотек

Продолжай читать на Habr

📣 C++ Ready | #статья

Почему std::move иногда вообще ничего не двигает?

std::move не перемещает объект сам по себе. Он только превращает выражение в rvalue-ссылку, чтобы компилятор мог выбрать move-конструктор или move-присваивание.

Но если объект const, перемещение может неожиданно превратиться в обычное копирование:

const std::string name = "ready";

std::string copy = std::move(name);

Кажется, что здесь будет move.

Но move-конструктор строки обычно принимает неконстантную rvalue-ссылку:

std::string(std::string&& other);

А из const объекта нельзя безопасно “забрать” внутреннее состояние, потому что это изменило бы объект.

Поэтому компилятор выбирает копирование:

const std::string name = "ready";
std::string result = std::move(name); // copy

Нормальное перемещение работает с неконстантным объектом:

std::string name = "ready";
std::string result = std::move(name); // move

После такого name остаётся валидным, но его содержимое уже не стоит использовать как прежнее значение:

std::cout << result << '\n';

std::move не гарантирует перемещение. Если объект const, чаще всего ты получишь копирование, просто записанное очень уверенным синтаксисом.

📣 C++ Ready | #совет

Шпаргалка по форматированию через библиотеку fmt!

На картинке собраны плейсхолдеры, именованные аргументы, выравнивание, ширина поля, точность, форматы чисел, строк, указателей и диапазонов.

Например, fmt::format собирает строку по шаблону, fmt::print выводит её сразу в консоль, а fmt::format_to пишет результат в готовый буфер или итератор.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс