📌 Оптимизация кода: std::string_view вместо std::string

Привет, друзья! Сегодня хочу рассказать про std::string_view — полезный инструмент, который может значительно ускорить работу с строками в C++. Многие из вас, вероятно, используют std::string, но не всегда это лучший выбор.

❓ Что такое std::string_view?
Это некопируемая, легковесная оболочка над строковыми данными. Она просто хранит указатель на начало строки и её длину, не создавая копии. Использование std::string_view вместо std::string позволяет избежать ненужных аллокаций памяти и ускорить код.

🔥 Пример использования:

#include <iostream>
#include <string_view>

void print(std::string_view str) {  // Без лишнего копирования
    std::cout << str << '\n';
}

int main() {
    std::string s = "Hello, world!";
    print(s);         // Можно передавать std::string
    print("Hi there"); // Можно передавать строковый литерал
}

🛠 Когда использовать?
✅ При передаче строк в функции, если их не нужно модифицировать.
✅ Для работы с подстроками (в отличие от std::string::substr, который делает копию).
✅ Для обработки строк без создания динамических объектов.

⚠️ Важно помнить:
- std::string_view не владеет данными, поэтому нельзя использовать его для длительного хранения указателей на временные строки.
- Нужно быть осторожным с объектами, чей срок жизни может закончиться, пока std::string_view ещё используется.

🚀 Итог:
Использование std::string_view вместо const std::string& может ускорить работу с текстовыми данными и снизить нагрузку на аллокатор. Если не нужно изменять строку — это отличный выбор!

А вы уже используете std::string_view в своих проектах? Делитесь в комментариях! ⬇️

➡️ @cpp_geek

🔥 Оптимизация кода на C++: Ранний возврат вместо вложенных условий

Привет, друзья! Сегодня хочу поговорить об одной важной технике, которая делает код чище и читабельнее — ранний возврат (early return). Часто встречаю код, который уходит в глубину вложенных if, превращаясь в настоящий лабиринт. Давайте разберем, как этого избежать.

❌ Плохой пример: Вложенные условия

void process(int value) {
    if (value > 0) {
        if (value % 2 == 0) {
            if (value < 100) {
                std::cout << "Обрабатываем " << value << std::endl;
            } else {
                std::cout << "Слишком большое число" << std::endl;
            }
        } else {
            std::cout << "Нечетное число" << std::endl;
        }
    } else {
        std::cout << "Отрицательное число" << std::endl;
    }
}

Здесь код уходит вглубь из-за множества вложенных if, что делает его сложным для чтения.

✅ Хороший пример: Ранний возврат

void process(int value) {
    if (value <= 0) {
        std::cout << "Отрицательное число" << std::endl;
        return;
    }
    if (value % 2 != 0) {
        std::cout << "Нечетное число" << std::endl;
        return;
    }
    if (value >= 100) {
        std::cout << "Слишком большое число" << std::endl;
        return;
    }

    std::cout << "Обрабатываем " << value << std::endl;
}

Теперь код сразу проверяет граничные условия и делает ранний возврат (return), если условия не выполнены. В итоге у нас получился плоский код, который проще читать и сопровождать.

🎯 Вывод:
- Избегайте вложенных if, если можно этого не делать.
- Используйте ранний возврат, чтобы код был линейным и понятным.
- Чем меньше уровней вложенности — тем легче отладка и сопровождение.

➡️ @cpp_geek

📌 Оптимизация кода в C++: Используем std::move правильно!

Привет, друзья! Сегодня я расскажу об одной из самых частых ошибок, связанных с std::move. Многие знают, что std::move не перемещает объект, а лишь превращает его в rvalue. Но как его использовать правильно? Давайте разбираться!

❌ Ошибка: Бессмысленный std::move

std::string getString() {
    std::string str = "Hello, world!";
    return std::move(str); // ❌ Неэффективно
}

Что здесь не так? Возвращаемый std::string и так является временным объектом (NRVO — оптимизация возврата), и std::move мешает этой оптимизации! В результате компилятор не сможет выполнить перемещение, а вызовет копирование.

✅ Правильный вариант:

std::string getString() {
    return "Hello, world!"; // ✅ NRVO оптимизация
}

🏆 Где std::move полезен?
Используйте std::move, когда точно знаете, что объект больше не нужен и его можно переместить:

void processString(std::string str) { /* ... */ }

int main() {
    std::string s = "Example";
    processString(std::move(s)); // 🔥 Теперь перемещение!
}

1️⃣ Не используйте std::move при возврате локальных объектов — дайте компилятору сделать свое дело!
2️⃣ Используйте std::move, когда объект больше не нужен — это ускорит работу кода.
3️⃣ После std::move не используйте переменную, кроме как для присвоения нового значения.

➡️ @cpp_geek

🚀Это отличный ресурс для программистов, работающих с C++. Можно найти подробную документацию по стандартной библиотеке, STL, различным версиям стандарта C++, а также примеры кода и объяснения по ключевым аспектам языка.

Справочник по C++
C++11, C++14, C++17, C++20, C++23, C++26 │ Поддержка компиляторами C++11, C++14, C++17, C++20, C++23, C++26

Справочник по языку C
C89, C95, C99, C11, C17, C23 │ Поддержка компиляторами C99, C23

https://ru.cppreference.com/w/

➡️ @cpp_geek

Улучшенные версии STL-контейнеров из библиотеки Boost
Илья Мещерин

В любом учебном курсе по C++, даже начального уровня, обязательно изучают, как устроен std::vector. Детали внутреннего устройства std::vector в подробностях продолжают изучать в вузах, спрашивать на собеседованиях, обсуждать на конференциях. То же самое происходит с контейнерами std::list, std::deque, std::map и std::unordered_map: про их реализацию и особенности внутреннего устройства можно говорить бесконечно долго, про них все еще делают доклады, снимают лекции и пишут статьи. И их продолжают использовать в продакшен-коде даже в самых крупных и известных компаниях.

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

Спикер обсудил внутреннее устройство не таких уж стандартных контейнеров: stable_vector, devector, bimap, circular_buffer, а также интрузивных версий list, map, unordered_map и их разновидностей.

источник

➡️ @cpp_geek

🔥 Оптимизация кода на C++: Ранний возврат вместо вложенных условий

Привет, друзья! Сегодня хочу поговорить об одной важной технике, которая делает код чище и читабельнее — ранний возврат (early return). Часто встречаю код, который уходит в глубину вложенных if, превращаясь в настоящий лабиринт. Давайте разберем, как этого избежать.

❌ Плохой пример: Вложенные условия

void process(int value) {
    if (value > 0) {
        if (value % 2 == 0) {
            if (value < 100) {
                std::cout << "Обрабатываем " << value << std::endl;
            } else {
                std::cout << "Слишком большое число" << std::endl;
            }
        } else {
            std::cout << "Нечетное число" << std::endl;
        }
    } else {
        std::cout << "Отрицательное число" << std::endl;
    }
}

Здесь код уходит вглубь из-за множества вложенных if, что делает его сложным для чтения.

✅ Хороший пример: Ранний возврат

void process(int value) {
    if (value <= 0) {
        std::cout << "Отрицательное число" << std::endl;
        return;
    }
    if (value % 2 != 0) {
        std::cout << "Нечетное число" << std::endl;
        return;
    }
    if (value >= 100) {
        std::cout << "Слишком большое число" << std::endl;
        return;
    }

    std::cout << "Обрабатываем " << value << std::endl;
}

Теперь код сразу проверяет граничные условия и делает ранний возврат (return), если условия не выполнены. В итоге у нас получился плоский код, который проще читать и сопровождать.

🎯 Вывод:
- Избегайте вложенных if, если можно этого не делать.
- Используйте ранний возврат, чтобы код был линейным и понятным.
- Чем меньше уровней вложенности — тем легче отладка и сопровождение.

➡️ @cpp_geek

🚀 Микро-оптимизация в C++20: Early Return + Атрибуты вероятности

В прошлом посте мы разобрали, как Early Return (ранний возврат) спасает нас от вложенных if и делает код чище. Но в C++20 мы можем сделать этот код еще и потенциально быстрее!

Встречайте атрибуты [[likely]] и [[unlikely]].

🧠 В чем суть?
Современные процессоры пытаются предсказать, какую ветку кода программа выполнит следующей (Branch Prediction). Если процессор угадал - всё летает. Если ошибся - теряем такты на очистку конвейера.

С помощью атрибутов мы даем компилятору (и процессору) «инсайд»: какая ветка будет выполняться чаще.

🛠 Как это выглядит в коде?

Обычно ошибки и проверки аргументов (Guard Clauses) срабатывают редко. Это идеальное место для [[unlikely]].

void ProcessImage(Image* img) {
    // 1. Проверка на null.
    // Это случается редко, помечаем как "маловероятно".
    if (img == nullptr) [[unlikely]] {
        return; // Компилятор уведет этот код "подальше" из горячего пути
    }

    // 2. Еще одна проверка
    if (img->IsEmpty()) [[unlikely]] {
        return;
    }

    // --- Happy Path ---
    // Процессор сразу прыгнет сюда, ожидая, что проверки выше ложны.
    img->ApplyFilter();
    img->Save();
}

⚙️ Что происходит под капотом?
Компилятор переставит инструкции ассемблера так, чтобы «счастливый путь» шел линейно, без прыжков (jmp), что улучшает работу кэша инструкций. Код обработки ошибок (ветка [[unlikely]]) будет сдвинут в конец функции или в «холодную» зону.

⚠️ Важный нюанс:
Используйте это только тогда, когда вы уверены в вероятностях (например, ошибки случаются в 1 случае из 1000). Если поставить атрибуты наугад, можно сделать только хуже (pessimization).

🔥 Итог:
Чистый код (Early Return) + Подсказки компилятору ([[unlikely]]) = Читаемость и Производительность.

#cpp #cpp20 #coding #optimization #tips #programming

➡️ @cpp_geek

🏗 Анатомия std::vector: Что происходит, когда место заканчивается?

std::vector - самый популярный контейнер в C++. Мы просто пишем push_back, и магия работает. Но что происходит «под капотом», когда вы пытаетесь добавить элемент, а свободное место (capacity) закончилось?

Происходит Реаллокация. И это гораздо дороже, чем просто добавление числа.

⚙️ Сценарий катастрофы (пошагово):

Допустим, у вектора было место под 4 элемента, и оно занято. Вы добавляете 5-й.

1. Поиск новой земли: Вектор понимает, что текущий буфер полон. Он просит у операционной системы выделить новый блок памяти (обычно в 1.5 или 2 раза больше старого).

2. Великое переселение: Все элементы из старого блока копируются (или перемещаются) в новый.
- Представьте: чтобы поставить на полку одну новую книгу, вам приходится переезжать в новую квартиру и перетаскивать туда всю библиотеку.

3. Зачистка: Старые объекты разрушаются (вызываются деструкторы), а старая память возвращается системе.

4. Вставка: И только теперь новый элемент добавляется в хвост.

🚨 Почему это проблема?

1. Удар по производительности
Операция push_back обычно мгновенна (). Но при реаллокации она превращается в тяжелую операцию . Если вектор огромный, программа может «подвиснуть» в самый неподходящий момент.

2. Инвалидация ссылок (Источник багов №1)
Это самое опасное. Как только произошла реаллокация, старая память удаляется. Все указатели, ссылки и итераторы, которые смотрели на элементы вектора, становятся невалидными.

std::vector<int> data = {1, 2, 3, 4};
int& ref = data[0]; // Ссылка на первый элемент

// Добавляем элемент -> места нет -> реаллокация!
data.push_back(5); 

// ☠️ ОШИБКА: ref ссылается на очищенную память.
// Получим мусор или краш программы.
std::cout << ref; 

🛡 Как лечить?

Если вы знаете (хотя бы примерно), сколько элементов будет в векторе - используйте reserve().

std::vector<int> data;
data.reserve(1000); // Сразу выделяем память

// Теперь реаллокации точно не будет, 
// пока мы не превысим 1000 элементов.

💡 Итог: Помогайте вектору с помощью reserve(). Это спасает и от тормозов, и от сложнейших багов с памятью.

#cpp #stdvector #memory #performance #coding #tips

➡️ @cpp_geek

🔒 const в C++: Скрытый смысл, о котором молчат

Мы привыкли думать, что const после имени метода это просто защита от дурака: "Я обещаю не менять поля класса внутри этой функции".

Но в современном C++ (и в стандартной библиотеке STL) const означает нечто большее. Это контракт потокобезопасности (Thread Safety Contract).

🧵 Золотое правило STL:

1. const методы можно вызывать из разных потоков одновременно без блокировок. (Safe for concurrent reads).

2. Не-const методы требуют внешней синхронизации, если их вызывают несколько потоков.

🚨 Где кроется ловушка?

Ловушка в ключевом слове mutable.
Оно позволяет менять поля даже внутри const метода. Обычно это используют для кэширования или ленивых вычислений.

❌ ОПАСНЫЙ КОД (Логический const, но физическая гонка):

class Widget {
    mutable int cachedValue_ = -1; // Можно менять в const методе

public:
    // Метод помечен const. Пользователь думает, что он безопасен 
    // для вызова из 10 потоков одновременно.
    int GetValue() const {
        if (cachedValue_ == -1) {
            // 💥 DATA RACE! 
            // Два потока могут одновременно зайти сюда и начать писать.
            cachedValue_ = HeavyCalculation(); 
        }
        return cachedValue_;
    }
};

Если вы пишете библиотеку и помечаете метод как const, пользователи будут вызывать его параллельно, не используя мьютексы. Если внутри у вас есть несинхронизированный mutable - программа упадет.

✅ Правильный подход:

Если вы используете mutable, вы обязаны защитить его мьютексом.

class Widget {
    mutable std::mutex mtx_; // Мьютекс тоже должен быть mutable!
    mutable int cachedValue_ = -1;

public:
    int GetValue() const {
        std::lock_guard<std::mutex> lock(mtx_); // Блокируем поток
        
        if (cachedValue_ == -1) {
            cachedValue_ = HeavyCalculation();
        }
        return cachedValue_;
    }
};

💡 Итог: В C++ const - это не только "я не меняю данные". Это обещание: "Этот метод безопасен для одновременного вызова". Если вы нарушаете это обещание (используя mutable без защиты), вы создаете бомбу замедленного действия.

#cpp #multithreading #const #safety #coding #tips

➡️ @cpp_geek

😱 std::vector<bool>: Великий обман C++

Вы думаете, что std::vector<bool> это просто вектор, который хранит булевы значения? Нет. Это совершенно уникальный монстр, который нарушает правила стандартной библиотеки.

📉 В чем подвох? Обычный bool занимает 1 байт (минимум адресуемой памяти). Но создатели C++ решили сэкономить память. std::vector<bool> - это специализация. Внутри него каждый bool занимает всего 1 бит.

В одном байте хранится сразу 8 значений true/false. Экономия памяти в 8 раз! Круто?

🛑 Проблема: Вы не можете взять адрес элемента

В C++ нельзя создать указатель или ссылку на отдельный бит. Память адресуется байтами.

std::vector<int> nums = {1, 2};
int* p = &nums[0]; // ✅ ОК. Указатель на первый int.

std::vector<bool> flags = {true, false};
bool* b = &flags[0]; // ❌ ОШИБКА КОМПИЛЯЦИИ!
// Мы не можем получить адрес бита.

🤖 Проблема: Прокси-объекты

Когда вы пишете flags[0], вектор возвращает не bool& (ссылку), а специальный временный объект - Proxy Class (std::vector<bool>::reference).

Этот объект "притворяется" ссылкой. Когда вы присваиваете ему значение, он делает побитовые сдвиги и маски (&, |, <<), чтобы изменить нужный бит внутри байта.

Это медленно.

⚠️ Ловушка с auto

std::vector<bool> vec = {true, false};

// Вы думаете, что val — это bool.
// На самом деле val — это 'std::vector<bool>::reference'.
auto val = vec[0]; 

vec.push_back(true); // Реаллокация памяти!

// 💥 Если val — это прокси, он может ссылаться на 
// старую, уже удаленную память вектора.
val = false; // Undefined Behavior / Crash

💡 Что делать?

1. Если вам важна память: Используйте std::vector<bool> (или std::bitset для фиксированного размера).

2. Если вам важна скорость: Используйте std::vector<char> или std::vector<uint8_t>. Это займет в 8 раз больше памяти, но будет работать мгновенно, и вы получите нормальные ссылки.

3. Осторожно с auto: Всегда пишите тип явно: bool val = vec[0];, чтобы заставить прокси превратиться в значение.

#cpp #stl #vector #gotchas #memory #coding #tips

➡️ @cpp_geek

🗺 std::map или std::unordered_map: Битва за кэш

Когда нам нужно хранить пары «Ключ - Значение», рука сама тянется написать std::map. Это стандарт, это удобно, это сортировка из коробки.

Но с точки зрения производительности std::map это часто худший выбор. Почему?

🌲 1. std::map - Это Дерево (Red-Black Tree)
Каждый элемент в map - это отдельный узел (Node), выделенный в куче (new). Узлы разбросаны по памяти хаотично.

• Чтобы найти элемент, процессор прыгает по указателям: Root -> Left -> Right -> ...
• Каждый прыжок - это потенциальный Cache Miss (промах кэша). Процессор ждет сотни тактов, пока данные подтянутся из RAM.
• Сложность поиска: O(log N).

⚡ 2. std::unordered_map - Это Хеш-таблица
Здесь нет деревьев. Ключ превращается в число (хеш), и мы сразу прыгаем в нужную ячейку массива (Bucket).

• Массивы любят кэш процессора (Cache Locality).
• Сложность поиска: O(1) (в среднем). Это мгновенно.

🐢 Насколько велика разница?
На маленьких объемах (до 100 элементов) разницы почти нет.
Но на 1,000,000 элементов std::unordered_map может быть в 3-5 раз быстрее просто за счет отсутствия прыжков по памяти.

🤔 Когда использовать std::map?
Только в одном случае: Вам жизненно важен порядок ключей.
Например, если вы хотите вывести пользователей по алфавиту или найти диапазон дат (lower_bound / upper_bound).

🚀 Бонус: C++23 std::flat_map
В новом стандарте завезли std::flat_map. Это гибрид: интерфейс как у map (сортированный), но внутри - сплошной вектор.
Это самый быстрый вариант для поиска, но медленный для вставки. Если у вас C++23 - присмотритесь!

💡 Итог: если вам не нужна сортировка, всегда пишите std::unordered_map. Не заставляйте процессор бегать по дереву указателей без причины.

#cpp #stl #optimization #performance #map #hashing #coding #tips

➡️ @cpp_geek

🌉 Забудьте про передачу указателей и размеров! (std::span)

Помните, мы обсуждали std::string_view - легковесное «окно» для строк? В C++20 у него появился старший брат для массивов и векторов - std::span.

До C++20 у нас была классическая проблема. Допустим, вы пишете функцию, которая должна обработать список чисел.

🐢 Как мы писали раньше:

Вариант 1: Принимать const std::vector<int>&.
Минус: Функция теперь намертво привязана к std::vector. Если у вас данные лежат в std::array или обычном си-массиве int arr[10], придется копировать их в вектор. Аллокации, тормоза.

Вариант 2: Си-стайл (Указатель + размер).
Минус: Легко ошибиться с размером, потерять контекст, код выглядит грязно.

void ProcessOld(const int* data, size_t size) { /* ... */ }

🚀 Как мы пишем теперь (C++20):

#include <span>

// Принимаем любой непрерывный кусок памяти!
void ProcessNew(std::span<const int> data) {
    for (int val : data) {
        std::cout << val << " ";
    }
}

👀 Что такое std::span?
Как и string_view, это просто указатель на начало данных и их длина (обычно 16 байт). Он не владеет памятью, он только на нее смотрит.

Магия в том, что std::span умеет автоматически создаваться из чего угодно:

std::vector<int> vec = {1, 2, 3};
std::array<int, 3> arr = {4, 5, 6};
int raw[3] = {7, 8, 9};

// Одна функция работает со всеми типами контейнеров! Без копирования!
ProcessNew(vec); 
ProcessNew(arr);
ProcessNew(raw);

✂️ Суперсила: Subspan (Подмассивы)
Вам нужно передать в функцию только часть вектора, например, со 2-го по 5-й элемент? Никаких итераторов и копирования:

// Передаем кусок вектора за O(1)
ProcessNew( std::span{vec}.subspan(1, 4) ); 

⚠️ Важный нюанс:
std::span не умеет изменять размер данных (никаких push_back). Но он может изменять сами элементы, если вы передадите std::span<int> (без const).

💡 Итог: Если ваша функция принимает набор данных только для чтения или изменения элементов на месте, всегда используйте std::span. Это золотой стандарт современного C++.

#cpp #cpp20 #stdspan #optimization #memory #coding #tips

➡️ @cpp_geek

🚀 Подборка полезных IT каналов в Max


Системное администрирование, DevOps 📌

https://max.ru/i_odmin Все для системного администратора
https://max.ru/bash_srv Bash Советы
https://max.ru/sysadminof Книги для админов, полезные материалы
https://max.ru/i_odmin_book Библиотека Системного Администратора
https://max.ru/i_devops DevOps: Пишем о Docker, Kubernetes и др.

1C разработка 📌
https://max.ru/odin1c_rus Cтатьи, курсы, советы, шаблоны кода 1С

Программирование C++📌
https://max.ru/cpp_lib Библиотека C/C++ разработчика

Программирование Python 📌
https://max.ru/python_of Python академия.
https://max.ru/BookPython Библиотека Python разработчика

Java разработка 📌
https://max.ru/bookjava Библиотека Java разработчика

GitHub Сообщество 📌
https://max.ru/githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://max.ru/database_info Все про базы данных

Фронтенд разработка 📌
https://max.ru/frontend_1 Подборки для frontend разработчиков

Библиотеки 📌
https://max.ru/programmist_of Книги по программированию
https://max.ru/proglb Библиотека программиста
https://max.ru/bfbook Книги для программистов

Программирование 📌
https://max.ru/bookflow Лекции, видеоуроки, доклады с IT конференций
https://max.ru/itmozg Программисты, дизайнеры, новости из мира IT
https://max.ru/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻

Шутки программистов 📌
https://max.ru/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://max.ru/thehaking Канал о кибербезопасности
https://max.ru/xakkep_1 Хакер Free

Книги, статьи для дизайнеров 📌
https://max.ru/odesigners Статьи, книги для дизайнеров

Математика 📌
https://max.ru/Pomatematike Канал по математике
https://max.ru/phismat_1 Обучающие видео, книги по Физике и Математике

Вакансии 📌
https://max.ru/progjob Вакансии в IT

Мир технологий 📌
https://max.ru/mir_teh Канал для любознательных


Бонус 📌
https://max.ru/piterspb_78 Свежие новости Санкт-Петербурга
https://max.ru/mockva_life Свежие новости Москвы

⏳ C++: Заставьте компилятор работать за вас (constexpr и consteval)

Вы когда-нибудь хотели, чтобы ваша программа мгновенно выдавала результат сложных вычислений в момент запуска? Это возможно, если переложить тяжелую математику на... ваш компилятор!

В современном C++ мы можем «запекать» результаты функций прямо в итоговый .exe файл. Для этого есть два инструмента.

1. constexpr - «Вычисли до запуска, если сможешь» (C++11)

Ключевое слово constexpr говорит компилятору: "Если все аргументы этой функции известны заранее, вычисли её прямо сейчас. Если нет - оставь до выполнения программы (Run-time)".

Это невероятно удобно для универсальных функций.

// Функция может работать и до запуска, и во время!
constexpr int GetArea(int width, int height) {
    return width * height;
}

int main() {
    // 🚀 Вычислится компилятором! В код вставится просто "200".
    // Zero runtime cost.
    int a = GetArea(10, 20); 

    int w;
    std::cin >> w;
    // 🐢 Вычислится процессором во время работы (w неизвестно заранее).
    int b = GetArea(w, 20); 
}

2. consteval - «Вычисли до запуска, или умри!» (C++20)

У constexpr есть проблема: мы не всегда уверены, вычислилась ли функция компилятором, или она тихо «соскользнула» в Run-time, замедляя программу.

Поэтому в C++20 добавили consteval. Это строгий приказ (Immediate Function). Если компилятор не может выполнить функцию прямо сейчас - он выдаст ошибку компиляции.

// Обязана выполниться во время компиляции
consteval int MagicHash(std::string_view str) {
    int hash = 0;
    for (char c : str) hash += c;
    return hash;
}

int main() {
    // ✅ Отлично. Компилятор сам посчитает хэш слова "admin".
    int h1 = MagicHash("admin"); 

    std::string user_input = "test";
    // ❌ ОШИБКА КОМПИЛЯЦИИ! user_input нельзя знать заранее.
    int h2 = MagicHash(user_input); 
}

📈 Зачем это нужно?

1. Максимальная производительность: Вы переносите время выполнения на этап сборки программы. Для пользователя всё работает за O(1).

2. Замена #define: Раньше константы и простые формулы писали через макросы препроцессора. Теперь constexpr делает это безопасно, с проверкой типов.

3. Безопасность: С consteval вы гарантируете, что тяжелая инициализация (например, генерация таблиц поиска) не ударит по производительности в продакшене.

💡Итог: Пишете математику или чистые функции без побочных эффектов? Ставьте constexpr.
Хотите 100% гарантию, что вычисления не попадут в готовый бинарник? Ставьте consteval.

#cpp #cpp20 #constexpr #optimization #performance #coding #tips

➡️ @cpp_geek