📂 Напоминалка по Bash-скобкам!

На картинке — компактная шпаргалка по скобкам в Bash: (), {}, $(), [], [[ ]] — что они делают и чем отличаются (подстановка команд, группировка в текущем shell/подоболочке, массивы, brace expansion, параметрическое расширение, арифметика и проверки условий).

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

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

push_back vs emplace_back: когда что использовать?

Обе функции добавляют элемент в контейнер, но делают это по-разному.

push_back(...) добавляет уже готовый объект. Если передать lvalue — будет копия, если rvalue — будет перемещение:

v.push_back(s);            // копия
v.push_back(std::move(s)); // move

emplace_back(...) не требует готового объекта — он передаёт аргументы в конструктор элемента и создаёт его *сразу внутри* контейнера:

v.emplace_back(5, 'a'); // string("aaaaa") прямо в vector

Это полезно, когда:
• элемент создаётся “на месте” из нескольких параметров;
• хочется избежать лишнего временного объекта (особенно для тяжёлых типов).

🔥 Важный нюанс: в современном C++ разница часто не драматическая (компилятор умеет оптимизировать временные объекты), так что выбирать стоит по читаемости.

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

👐 Замечательная статья — быстрый чеклист приёмов оптимизации C/C++ для повседневного кода!

В этой статье:
• Поймёшь, какие микроизменения действительно влияют на скорость
• Увидишь примеры про типы, порядок полей, преобразования и “дорогие” операции
• Заберёшь идеи про циклы, ветвления и вызовы, чтобы вычищать лишнее без фанатизма

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

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

Знали что, многие допускают ошибку при использовании оператора delete?

Сегодня как раз ее разберем. Распространенную ошибку в C++ при работе с операторами delete и delete[], она может привести к сбоям программы и утечкам памяти:

Операторы delete и delete[] предназначены для освобождения памяти, выделенной с помощью new и new[] соответственно. Часто можно столкнуться с ошибками, если перепутать эти операторы:

int* ptr = new int[5];  // Выделили память для массива
delete ptr;  // Ошибка! Использован неправильный оператор

Для освобождения памяти, выделенной с помощью new[], нужно использовать delete[].

Правильное использование delete[]:

int* ptr = new int[5];  // Выделили память для массива
delete[] ptr;  // Правильно освобождаем память

Другой распространенный случай — удаление одной и той же памяти дважды. Это может привести к неопределенному поведению:

int* ptr = new int[5];
delete[] ptr;  // Освободили память
delete[] ptr;  // Ошибка: память уже освобождена

Установить указатель в nullptr
После того как память освобождена, всегда обнуляйте указатель:

int* ptr = new int[5];
delete[] ptr;
ptr = nullptr;  // Указатель больше не указывает на освобожденную память

🔥 Правильное использование этих операторов — ключ к предотвращению утечек памяти и ошибок в управлении памятью.

Всегда следите за тем, какой тип памяти вы освобождаете, и избегайте двойного удаления.

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

std::span: безопасная альтернатива T* + size!

Очень часто функции принимают «сырые» данные так:

void process(const int* data, std::size_t size);

Это быстро, но небезопасно:
• указатель и размер легко рассинхронизировать;
• компилятор никак не помогает;
• легко выйти за границы и словить UB.

В C++20 для этого есть std::span — лёгкая обёртка над непрерывным диапазоном памяти. std::span не владеет данными, но всегда знает их размер и тип.

Перепишем сигнатуру функции:

#include <span>

void process(std::span<const int> data) {
    for (int x : data) {
        // безопасный проход по диапазону
        work(x);
    }
}

Теперь функция принимает единое целое, а не два разрозненных аргумента.

Вызывать её можно почти так же просто:

#include <vector>
#include <array>

int main() {
    std::vector<int> v{1, 2, 3};
    std::array<int, 3> a{4, 5, 6};
    int raw[] = {7, 8, 9};

    process(v);    // std::vector
    process(a);    // std::array
    process(raw);  // C-массив
}

Никаких кастов, никаких размеров вручную — всё выводится автоматически.

Если же нужно изменять данные, достаточно убрать const:

void normalize(std::span<int> data) {
    for (int& x : data) {
        x = std::max(x, 0);
    }
}

🔥 std::span — это zero-overhead приём: он не копирует данные, не замедляет код и при этом резко снижает шанс UB из-за выхода за границы или перепутанных размеров.

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

☕️ Awesome-Shell — топовая коллекция утилит, скриптов и приёмов для терминала!

Здесь собраны десятки CLI-инструментов, полезные bash/zsh-скрипты, практичные сниппеты и лайфхаки, которые ускоряют работу. Отличный набор для автоматизации, оптимизации и прокачки навыков работы с командной строкой.

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

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

📂 Шпаргалка по возможностям C++17

На картинке — краткое напоминание о ключевых нововведениях в C++17: if constexpr, шаблоны с auto, структурные привязки, вложенные пространства имён, атрибуты [[nodiscard]], [[maybe_unused]], [[fallthrough]], сложение параметров с помощью fold-выражений, constexpr-лямбды, прямые инициализации enum.

Полезный сжатый обзор для тех, кто пишет на modern C++ и хочет держать язык под контролем.

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

Почему auto иногда делает код более читаемым?

Многие боятся auto, потому что “не видно тип”. Но часто тип как раз мешает чтению: он длинный, шаблонный и не несёт смысла.

Типичный пример — итераторы:

auto it = v.begin();

Вместо:

std::vector<std::string>::iterator it = v.begin();

Смысл строки — “взяли итератор на начало”, а не “прочитай 40 символов типа”.

Ещё один сильный кейс — structured bindings в циклах по map:

for (auto& [key, value] : m) { ... }

Без auto тут обычно появляется std::pair<const std::string, int>&, и читаемость падает.

Где auto особенно уместен:

• когда тип очевиден из правой части (v.begin(), make_unique, find, size())
• когда тип слишком “шумный” и отвлекает
• когда важнее роль переменной, а не её точный тип

А не прятать тип лучше:

• когда это влияет на поведение (int vs size_t, auto vs auto&)
• когда auto может случайно сделать копию вместо ссылки

🔥 Итог: используй auto, чтобы убрать “шум типов”, но следи за ссылками и const: часто правильнее auto& / const auto&, чем просто auto.

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

👐 Отличная статья — про оптимизацию через понимание CPU: где теряются такты и почему компилятор не всесилен.

В этой статье:
• Понять, какие блокировщики оптимизаций мешают компилятору в реальности
• Увидеть, как измерять скорость через CPE и задержки
• Разобраться в приёмах: инварианты, регистры, ветвления, SIMD, циклы

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

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