Подписывайтесь на наш Telegram и не пропускайте важные новости! Перейти

Гайд Modern C++ в геймхакинге: почему ваши пасты выглядят как дерьмо

$$$ eac gang $$$
Пользователь
Пользователь
Статус
Оффлайн
Регистрация
31 Май 2024
Сообщения
531
Реакции
103
Заходишь в любой раздел посвященный разработке читов на форуме, открываешь очередную "Internal Base" и что ты видишь? Код, который как будто высрали из 2011 года. NULL везде, макросы на каждый чих, char* для строк и магические числа. Ребята, на дворе 2026 год, а многие из вас до сих пор пишут на "Си с классами".

Если вы хотите, чтобы ваш софт не падал от каждого чиха, работал быстрее и не выглядел как очередная паста экспенсива 3.1 от вани майнкрафтера, пора переходить на Modern C++. Разберем, почему ваш старый код - это мусор, и как сделать его лучше.

1. NULL и макросы: Оставьте это дедушкам​

Большинство пастеров до сих пор используют NULL или вообще 0. В современном C++ это моветон.
  • Вместо NULL используем nullptr:
NULL - это просто макрос, который разворачивается в 0 (int). Это создает кучу проблем при перегрузке функций. nullptr — это отдельный тип, который гарантирует, что вы работаете именно с указателем.
  • Вместо макросов (#define) используем constexpr:
Хватит определять оффсеты через дефайны!
example:
Expand Collapse Copy
// Плохо (C-style):
#define OFFSET_LOCAL_PLAYER 0x1DB230
 
// Хорошо (Modern C++):
inline constexpr std::uintptr_t local_player = 0x1DB230;

constexpr дает типизацию, уважает области видимости и проверяется на этапе компиляции. Компилятор скажет вам «спасибо», а отладка станет в разы легче.

2. std::optional: Хватит возвращать "мусорные" значения​

Типичная ситуация: функция ищет указатель на сущность. Если не нашла - возвращает 0 или false через булеву функцию. Это заставляет вас плодить лишние проверки.

std::optional (C++17) идеально подходит для таких задач. Он явно говорит: «Здесь либо есть значение, либо его нет».
example:
Expand Collapse Copy
// Как это делает типичный кубоголовый ваня
bool get_bone_pos(int index, Vector& out) {
    if (!valid) return false;
    out = bones[index];
    return true;
}

// Как это делает true $$$ selfcode eac bypass $$$:
std::optional<Vector> get_bone_pos(int index) {
    if (!valid) return std::nullopt;
    return bones[index];
}

// Использование:
auto pos = get_bone_pos(10);
if (pos) {
    draw_esp(pos.value());
}


3. std::variant: Замена кривым Union​

Если вам нужно хранить в конфиге значение, которое может быть либо int, либо float, либо bool, забудьте про void* или небезопасные union.

std::variant - это типобезопасный союз. Он знает, какой тип данных в нем лежит в данный момент, и не даст вам выстрелить себе в ногу.

4. std::string_view: Парсинг конфигов без лагов​

Многие при парсинге строк создают сотни объектов std::string. Каждая такая строка - это аллокация памяти (выделение места), что медленно и нагружает игру.

std::string_view (C++17) - это просто "окно" в уже существующую строку. Он не копирует текст, а просто хранит указатель и длину.
example:
Expand Collapse Copy
// Читаем команду из консоли чита:
void parse_command(std::string_view cmd) {
    if (cmd.starts_with("set_fov")) {
        // тут должна была быть логика в теории, но идите нахуй.
    }
}

Использование string_view при парсинге больших конфигов или обработке игровых событий может заметно снизить фризы вашего чита.

5. Списки сущностей и итераторы (C++20 ranges)​

Хватит писать циклы for (int i = 0; i &lt; 64; i++). Это выглядит жалко. Используйте ranged-based for или, если вы совсем крутой, C++20 Ranges.
example:
Expand Collapse Copy
for (auto& entity : entity_list) {
    if (!entity.is_alive()) continue;
    // ...
}

Это читается как человеческий язык, а не как код для микроволновки.

Итог​

Геймхакинг - это не только реверсинг, но и культура кода. Если вы продолжите копировать куски из исходников 2014 года, ваш максимум это детект через неделю и вечные вылеты.
Учите стандарты C++17 и C++20. Чистый код это меньше багов, меньше мозгоебли (за счет нормальной реализации логики) и уважение на форуме.
Ну или если вы совсем тупой еблан, не знаю просите нейросети использовать стандарты, хотя бы перед тем как постить что-то на форум.
 
Последнее редактирование:
constexpr дает типизацию, уважает области видимости и проверяется на этапе компиляции. Компилятор скажет вам «спасибо», а отладка станет в разы легче.
но не скажет что может положить твою константу в .rdata вместо imm прямо в асме и у тебя будет лишний чек в память :negr:

2. std::optional: Хватит возвращать "мусорные" значения​

Типичная ситуация: функция ищет указатель на сущность. Если не нашла - возвращает 0 или false через булеву функцию. Это заставляет вас плодить лишние проверки.

std::optional (C++17) идеально подходит для таких задач. Он явно говорит: «Здесь либо есть значение, либо его нет».
в примере буквально синтаксический сахар, хотя с оптом флаг наличия ещё и будет занимать место на стеке вместо просто байта ax.
3. std::variant: Замена кривым Union
тоже самое.
5. Списки сущностей и итераторы (C++20 ranges)
чисто технически это скомпилируется в тот же асм что и обычный for (x=y;x ? s; x(+-*=);)
только итераторы обычно развернутся в while (it != end) it++.
Учите стандарты C++17 и C++20. Чистый код это меньше багов, меньше мозгоебли (за счет нормальной реализации логики) и уважение на форуме.
это меньше багов и мозгоебли, но больше сокрытия реализации и сама реализация не всегда оптимальна, чиста для сейва пойдет, но если делать по хорошему, в месте где ботлнек это как раз оверхед от рантайма чита, то лучше делать более простую структуру без STL где это возможно.

в целом все перечисленное в треде это по сути дела сахар, с оговоркой на то, что где то есть оверхед по памяти, а где то вообще ансейф код (любой вьюв это ансейф априори)
 
Короче, чтоб ваш чит не был говном надо всего несколько пунктов.
1. Быть пиздатым
2. Быть более пиздатым чем пиздат.

Ну а если серьезно.
1. Читать книги, много сука книг, а чтиво там не из простых, и речь даже не про c++ для чайников, с этим сможешь напастить калькулятор, и то он будет хуже чем то что есть в Windows.
2. Усидчивость, кодинг это когда ты 8 часов кодил то что знаешь, а потом еще 4 часа читаешь книгу чтоб сделать ту функцию о которой ты нихуя знать не знаешь.
3. Не использовать готовые сурсы как основу своего кода, кто бы что не пиздел, хоть сука у тебя будет 1 в 1(не будет если будешь сам писать код).

Я кстати пастер, и делаю говно, всем спасибо.
Всем этим критериям я не соответствую.
 
в примере буквально синтаксический сахар, хотя с оптом флаг наличия ещё и будет занимать место на стеке вместо просто байта ax.
только хотел написать
Хватит писать циклы for (int i = 0; i &lt; 64; i++)
разные подходы. учитывая, что здесь идёт перечисление не до конца массива, а только первые 64 сущности, вероятно, что далее будет идти игровое получение сущности через какую-нибудь функцию, а не получение сущности из красивого entityList поддерживающего итераторы

но не скажет что может положить твою константу в .rdata вместо imm прямо в асме и у тебя будет лишний чек в память :negr:
там же inline стоит
Я кстати пастер, и делаю говно, всем спасибо
спасибо за мнение, специально не читал
 
там же inline стоит
Для переменных inline значит другое нежели для функций. Вроде при inline линкер вместо того чтоб напрямую вставлять их из .h файлов, обьеденяет в одну, решая ошибку мульти дефайна
 
Заходишь в любой раздел посвященный разработке читов на форуме, открываешь очередную "Internal Base" и что ты видишь? Код, который как будто высрали из 2011 года. NULL везде, макросы на каждый чих, char* для строк и магические числа. Ребята, на дворе 2026 год, а многие из вас до сих пор пишут на "Си с классами".

Если вы хотите, чтобы ваш софт не падал от каждого чиха, работал быстрее и не выглядел как очередная паста экспенсива 3.1 от вани майнкрафтера, пора переходить на Modern C++. Разберем, почему ваш старый код - это мусор, и как сделать его лучше.

1. NULL и макросы: Оставьте это дедушкам​

Большинство пастеров до сих пор используют NULL или вообще 0. В современном C++ это моветон.
  • Вместо NULL используем nullptr:
NULL - это просто макрос, который разворачивается в 0 (int). Это создает кучу проблем при перегрузке функций. nullptr — это отдельный тип, который гарантирует, что вы работаете именно с указателем.
  • Вместо макросов (#define) используем constexpr:
Хватит определять оффсеты через дефайны!
example:
Expand Collapse Copy
// Плохо (C-style):
#define OFFSET_LOCAL_PLAYER 0x1DB230
 
// Хорошо (Modern C++):
inline constexpr std::uintptr_t local_player = 0x1DB230;

constexpr дает типизацию, уважает области видимости и проверяется на этапе компиляции. Компилятор скажет вам «спасибо», а отладка станет в разы легче.

2. std::optional: Хватит возвращать "мусорные" значения​

Типичная ситуация: функция ищет указатель на сущность. Если не нашла - возвращает 0 или false через булеву функцию. Это заставляет вас плодить лишние проверки.

std::optional (C++17) идеально подходит для таких задач. Он явно говорит: «Здесь либо есть значение, либо его нет».
example:
Expand Collapse Copy
// Как это делает типичный кубоголовый ваня
bool get_bone_pos(int index, Vector& out) {
    if (!valid) return false;
    out = bones[index];
    return true;
}

// Как это делает true $$$ selfcode eac bypass $$$:
std::optional<Vector> get_bone_pos(int index) {
    if (!valid) return std::nullopt;
    return bones[index];
}

// Использование:
auto pos = get_bone_pos(10);
if (pos) {
    draw_esp(pos.value());
}


3. std::variant: Замена кривым Union​

Если вам нужно хранить в конфиге значение, которое может быть либо int, либо float, либо bool, забудьте про void* или небезопасные union.

std::variant - это типобезопасный союз. Он знает, какой тип данных в нем лежит в данный момент, и не даст вам выстрелить себе в ногу.

4. std::string_view: Парсинг конфигов без лагов​

Многие при парсинге строк создают сотни объектов std::string. Каждая такая строка - это аллокация памяти (выделение места), что медленно и нагружает игру.

std::string_view (C++17) - это просто "окно" в уже существующую строку. Он не копирует текст, а просто хранит указатель и длину.
example:
Expand Collapse Copy
// Читаем команду из консоли чита:
void parse_command(std::string_view cmd) {
    if (cmd.starts_with("set_fov")) {
        // тут должна была быть логика в теории, но идите нахуй.
    }
}

Использование string_view при парсинге больших конфигов или обработке игровых событий может заметно снизить фризы вашего чита.

5. Списки сущностей и итераторы (C++20 ranges)​

Хватит писать циклы for (int i = 0; i &lt; 64; i++). Это выглядит жалко. Используйте ranged-based for или, если вы совсем крутой, C++20 Ranges.
example:
Expand Collapse Copy
for (auto& entity : entity_list) {
    if (!entity.is_alive()) continue;
    // ...
}

Это читается как человеческий язык, а не как код для микроволновки.

Итог​

Геймхакинг - это не только реверсинг, но и культура кода. Если вы продолжите копировать куски из исходников 2014 года, ваш максимум это детект через неделю и вечные вылеты.
Учите стандарты C++17 и C++20. Чистый код это меньше багов, меньше мозгоебли (за счет нормальной реализации логики) и уважение на форуме.
Ну или если вы совсем тупой еблан, не знаю просите нейросети использовать стандарты, хотя бы перед тем как постить что-то на форум.
нахуя какие-то чеки всрались тебе если можно сделать еще проще тернарным оператором в данном случае просто потому что здесь это коротко и не будет считаться как спагетти код
C++:
Expand Collapse Copy
std::optional<Vector> get_bone_pos(int index) {
    return valid ? bones[index] : std::nullopt;
}
 
да пишите блять хоть 10к строчек в один файл главное чтобы было понимание как все работает и оптимизировано все
 
но не скажет что может положить твою константу в .rdata вместо imm прямо в асме и у тебя будет лишний чек в память :negr:

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

тоже самое.

чисто технически это скомпилируется в тот же асм что и обычный for (x=y;x ? s; x(+-*=);)
только итераторы обычно развернутся в while (it != end) it++.

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

в целом все перечисленное в треде это по сути дела сахар, с оговоркой на то, что где то есть оверхед по памяти, а где то вообще ансейф код (любой вьюв это ансейф априори)
Вот к чему тут реально можно прицепиться по технике, а не по вкусовщине.

1. Про constexpr аргумент сформулирован криво

constexpr ... может положить твою константу в .rdata вместо imm прямо в асме
Проблема в том, что это не контраргумент против constexpr как языка/абстракции.

Почему:

  • constexpr гарантирует возможность вычисления на этапе компиляции, а не конкретную форму машинного кода.
  • Будет imm, загрузка из .rdata, константная пропагация, инлайнинг или вообще удаление — это уже вопрос оптимизатора, ABI, ODR-use, отладочной/релизной сборки, взятия адреса и контекста использования.
  • То же самое может происходить и не только с constexpr, а вообще с любыми константными объектами.
То есть доебка тут такая:
он подменяет тезис. Ему говорят про типизацию, области видимости и compile-time validation, а он отвечает про частный кодген.

Еще и формулировка:

лишний чек в память
Это технически грязно. Тут не “check”, а load/read from memory. “Чек в память” — бессмысленный жаргон.


2. constexpr не равен “всегда быстрее” — но и критика у него слишком тупая
Если хочется добить сильнее, можно сказать:

  • да, constexpr не гарантирует лучший кодген;
  • но из этого не следует, что он плох или бесполезен;
  • его ценность — в семантике, а не только в микрооптимизации.
То есть он спорит так, будто единственный критерий — “imm в асме”.


3. Про std::optional он пишет почти мимо

в примере буквально синтаксический сахар
Это слабое место.

optional — не просто сахар, потому что он:

  • делает “значение может отсутствовать” частью типа;
  • убирает необходимость кодировать отсутствие через sentinel (0, -1, nullptr, false);
  • снижает риск перепутать “валидное значение” и “признак отсутствия”;
  • улучшает интерфейс функции и читаемость call site.
То есть это не только синтаксис, это явная модель состояния.


4. Аргумент про размер/ABI у optional подан очень неаккуратно

флаг наличия ещё и будет занимать место на стеке вместо просто байта ax
Тут сразу несколько дыр:

  • на x86-64 возвращаемый регистр обычно rax, а не ax, если речь не про какие-то частные мелкие типы;
  • размер optional&lt;T&gt; зависит от T, выравнивания, ABI и реализации стандартной библиотеки;
  • не факт, что речь вообще пойдет “про стек”;
  • не факт, что sentinel-вариант реально дешевле после оптимизаций;
  • optional&lt;T*&gt; и nullptr — отдельный кейс, и тут критика может быть частично справедлива, но не в такой общей форме.
То есть он бросает низкоуровневую претензию, но сам пишет ее технически неточно.


5. “std::variant: тоже самое” — это просто халтура
variant — не “то же самое”, что union.

Разница фундаментальная:

  • union сам по себе не отслеживает активный альтернативный тип;
  • у variant есть tag/index активной альтернативы;
  • variant корректно управляет lifetime сложных типов;
  • variant безопаснее и выражает сумму типов на уровне интерфейса.
Да, можно сказать:

  • у variant есть overhead на discriminator;
  • он тяжелее простого union;
  • в hot path не всегда желателен.
Но писать “то же самое” — это просто технически неверно.


6. Про ranges аргумент почти пустой

чисто технически это скомпилируется в тот же асм что и обычный for
Доебка здесь такая:

  • “скомпилируется в тот же асм” — не универсально верно;
  • иногда да, иногда нет;
  • зависит от конкретных адаптеров, view chain, inlining, оптимизаций, категории итераторов и компилятора.
То есть утверждение слишком абсолютное.

А еще:

только итераторы обычно развернутся в while (it != end) it++
И что?
for и while на таком уровне — это почти одно и то же. Это не критика, а просто пересказ тривиального lowering.


7. Пример с for (x=y;x ? s; x(+-*=);) выглядит как техническая каша
Если хочешь прям придраться по форме:

  • условие x ? s написано как какой-то обломок тернарного оператора;
  • x(+-*=); вообще выглядит как псевдокод/бред;
  • как “ассемблерно мыслящий технарь” он должен был хотя бы записать нормальную форму цикла.
То есть он пытается говорить низкоуровнево, но даже псевдокод оформляет неряшливо.


8. “STL скрывает реализацию, значит хуже” — слишком общий тезис

сама реализация не всегда оптимальна
лучше делать более простую структуру без STL где это возможно
Здесь можно нормально вцепиться:

  • “не всегда оптимальна” — банальность, это почти про любой код;
  • “без STL где возможно” — плохая инженерная эвристика;
  • сначала нужен профилинг, а не религия;
  • STL часто компилируется очень хорошо, особенно простые контейнеры/алгоритмы/итераторы;
  • самописные структуры данных часто дают больше багов, чем выигрыша.
Хорошая доебка:
он подает ручной low-level код как дефолт, хотя это оправдано только после измерений.


9. “всё это сахар” — сильное упрощение до неправды
Сводить optional, variant, constexpr, ranges к “сахару” некорректно.

Из перечисленного:

  • optional — это модель optional-state в типе;
  • variant — tagged union;
  • constexpr — compile-time semantics;
  • ranges/views — композиционная модель работы с последовательностями.
Это не просто синтаксический декор.


10. “любой view unsafe априори” — откровенно плохой тезис
Вот тут можно прям жестко доебаться.

Это слишком грубое и часто ложное утверждение.

Почему:

  • не любой view опасен;
  • danger zone — это в основном lifetime issues, dangling, non-owning semantics;
  • часть view безопасна при нормальном использовании;
  • в стандартной библиотеке есть понятия вроде borrowed_range, а многие проблемы вообще типичны не только для view, но и для span, string_view, итераторов, ссылок и т.д.
Фраза

любой вьюв это ансейф априори
звучит как человек знает слово “dangling”, но не умеет различать условно опасный инструмент и априори unsafe сущность.


11. Он смешивает разные уровни разговора
Исходный пост, судя по цитатам, про:

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

  • .rdata,
  • imm,
  • размер на стеке,
  • runtime overhead.
То есть он спорит не с тем тезисом:

  • на аргумент про maintainability отвечает аргументом про микрооптимизацию;
  • на аргумент про безопасность типов отвечает “ну это сахар”.
Это логически слабая линия.


12. У него нет границ применимости
Нормальный техничный тезис выглядел бы так:

  • в hot path / perf-critical коде некоторые абстракции стоит проверять профилингом;
  • optional/variant/ranges могут давать overhead в отдельных сценариях;
  • для game hacking / cheat runtime / tight loops иногда оправдан ручной контроль layout и lifetime.
Но он пишет это как общее правило, а не как узкий trade-off.
Это делает текст уязвимым.


Если собрать самую убойную короткую выжимку, то доебаться можно так:

Сообщение страдает от подмены тезиса: вместо обсуждения типобезопасности, семантики и качества интерфейсов автор уходит в частные детали кодгена. При этом низкоуровневые претензии сформулированы небрежно: constexpr не обещает imm, optional — не просто сахар, variant — не “то же самое”, что union, а тезис “любой view unsafe” вообще слишком грубый и технически слабый. В итоге текст выглядит как смесь здравой мысли про hot path с кучей чрезмерных обобщений.
Могу еще сделать тебе версию в стиле форумного разъёба, чтобы это можно было сразу запостить ответом.
 
Вот к чему тут реально можно прицепиться по технике, а не по вкусовщине.

1. Про constexpr аргумент сформулирован криво


Проблема в том, что это не контраргумент против constexpr как языка/абстракции.

Почему:

  • constexpr гарантирует возможность вычисления на этапе компиляции, а не конкретную форму машинного кода.
  • Будет imm, загрузка из .rdata, константная пропагация, инлайнинг или вообще удаление — это уже вопрос оптимизатора, ABI, ODR-use, отладочной/релизной сборки, взятия адреса и контекста использования.
  • То же самое может происходить и не только с constexpr, а вообще с любыми константными объектами.
То есть доебка тут такая:
он подменяет тезис. Ему говорят про типизацию, области видимости и compile-time validation, а он отвечает про частный кодген.

Еще и формулировка:


Это технически грязно. Тут не “check”, а load/read from memory. “Чек в память” — бессмысленный жаргон.


2. constexpr не равен “всегда быстрее” — но и критика у него слишком тупая
Если хочется добить сильнее, можно сказать:

  • да, constexpr не гарантирует лучший кодген;
  • но из этого не следует, что он плох или бесполезен;
  • его ценность — в семантике, а не только в микрооптимизации.
То есть он спорит так, будто единственный критерий — “imm в асме”.


3. Про std::optional он пишет почти мимо


Это слабое место.

optional — не просто сахар, потому что он:

  • делает “значение может отсутствовать” частью типа;
  • убирает необходимость кодировать отсутствие через sentinel (0, -1, nullptr, false);
  • снижает риск перепутать “валидное значение” и “признак отсутствия”;
  • улучшает интерфейс функции и читаемость call site.
То есть это не только синтаксис, это явная модель состояния.


4. Аргумент про размер/ABI у optional подан очень неаккуратно


Тут сразу несколько дыр:

  • на x86-64 возвращаемый регистр обычно rax, а не ax, если речь не про какие-то частные мелкие типы;
  • размер optional&lt;T&gt; зависит от T, выравнивания, ABI и реализации стандартной библиотеки;
  • не факт, что речь вообще пойдет “про стек”;
  • не факт, что sentinel-вариант реально дешевле после оптимизаций;
  • optional&lt;T*&gt; и nullptr — отдельный кейс, и тут критика может быть частично справедлива, но не в такой общей форме.
То есть он бросает низкоуровневую претензию, но сам пишет ее технически неточно.


5. “std::variant: тоже самое” — это просто халтура
variant — не “то же самое”, что union.

Разница фундаментальная:

  • union сам по себе не отслеживает активный альтернативный тип;
  • у variant есть tag/index активной альтернативы;
  • variant корректно управляет lifetime сложных типов;
  • variant безопаснее и выражает сумму типов на уровне интерфейса.
Да, можно сказать:

  • у variant есть overhead на discriminator;
  • он тяжелее простого union;
  • в hot path не всегда желателен.
Но писать “то же самое” — это просто технически неверно.


6. Про ranges аргумент почти пустой


Доебка здесь такая:

  • “скомпилируется в тот же асм” — не универсально верно;
  • иногда да, иногда нет;
  • зависит от конкретных адаптеров, view chain, inlining, оптимизаций, категории итераторов и компилятора.
То есть утверждение слишком абсолютное.

А еще:


И что?
for и while на таком уровне — это почти одно и то же. Это не критика, а просто пересказ тривиального lowering.


7. Пример с for (x=y;x ? s; x(+-*=);) выглядит как техническая каша
Если хочешь прям придраться по форме:

  • условие x ? s написано как какой-то обломок тернарного оператора;
  • x(+-*=); вообще выглядит как псевдокод/бред;
  • как “ассемблерно мыслящий технарь” он должен был хотя бы записать нормальную форму цикла.
То есть он пытается говорить низкоуровнево, но даже псевдокод оформляет неряшливо.


8. “STL скрывает реализацию, значит хуже” — слишком общий тезис


Здесь можно нормально вцепиться:

  • “не всегда оптимальна” — банальность, это почти про любой код;
  • “без STL где возможно” — плохая инженерная эвристика;
  • сначала нужен профилинг, а не религия;
  • STL часто компилируется очень хорошо, особенно простые контейнеры/алгоритмы/итераторы;
  • самописные структуры данных часто дают больше багов, чем выигрыша.
Хорошая доебка:
он подает ручной low-level код как дефолт, хотя это оправдано только после измерений.


9. “всё это сахар” — сильное упрощение до неправды
Сводить optional, variant, constexpr, ranges к “сахару” некорректно.

Из перечисленного:

  • optional — это модель optional-state в типе;
  • variant — tagged union;
  • constexpr — compile-time semantics;
  • ranges/views — композиционная модель работы с последовательностями.
Это не просто синтаксический декор.


10. “любой view unsafe априори” — откровенно плохой тезис
Вот тут можно прям жестко доебаться.

Это слишком грубое и часто ложное утверждение.

Почему:

  • не любой view опасен;
  • danger zone — это в основном lifetime issues, dangling, non-owning semantics;
  • часть view безопасна при нормальном использовании;
  • в стандартной библиотеке есть понятия вроде borrowed_range, а многие проблемы вообще типичны не только для view, но и для span, string_view, итераторов, ссылок и т.д.
Фраза


звучит как человек знает слово “dangling”, но не умеет различать условно опасный инструмент и априори unsafe сущность.


11. Он смешивает разные уровни разговора
Исходный пост, судя по цитатам, про:

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

  • .rdata,
  • imm,
  • размер на стеке,
  • runtime overhead.
То есть он спорит не с тем тезисом:

  • на аргумент про maintainability отвечает аргументом про микрооптимизацию;
  • на аргумент про безопасность типов отвечает “ну это сахар”.
Это логически слабая линия.


12. У него нет границ применимости
Нормальный техничный тезис выглядел бы так:

  • в hot path / perf-critical коде некоторые абстракции стоит проверять профилингом;
  • optional/variant/ranges могут давать overhead в отдельных сценариях;
  • для game hacking / cheat runtime / tight loops иногда оправдан ручной контроль layout и lifetime.
Но он пишет это как общее правило, а не как узкий trade-off.
Это делает текст уязвимым.


Если собрать самую убойную короткую выжимку, то доебаться можно так:


Могу еще сделать тебе версию в стиле форумного разъёба, чтобы это можно было сразу запостить ответом.
Руками лень написать было?
 
3. std::variant: Замена кривым Union
хуйня полная, у меня был структ с енумом который обозначал тип переменной и юнион после
Вот к чему тут реально можно прицепиться по технике, а не по вкусовщине.

1. Про constexpr аргумент сформулирован криво


Проблема в том, что это не контраргумент против constexpr как языка/абстракции.

Почему:

  • constexpr гарантирует возможность вычисления на этапе компиляции, а не конкретную форму машинного кода.
  • Будет imm, загрузка из .rdata, константная пропагация, инлайнинг или вообще удаление — это уже вопрос оптимизатора, ABI, ODR-use, отладочной/релизной сборки, взятия адреса и контекста использования.
  • То же самое может происходить и не только с constexpr, а вообще с любыми константными объектами.
То есть доебка тут такая:
он подменяет тезис. Ему говорят про типизацию, области видимости и compile-time validation, а он отвечает про частный кодген.

Еще и формулировка:


Это технически грязно. Тут не “check”, а load/read from memory. “Чек в память” — бессмысленный жаргон.


2. constexpr не равен “всегда быстрее” — но и критика у него слишком тупая
Если хочется добить сильнее, можно сказать:

  • да, constexpr не гарантирует лучший кодген;
  • но из этого не следует, что он плох или бесполезен;
  • его ценность — в семантике, а не только в микрооптимизации.
То есть он спорит так, будто единственный критерий — “imm в асме”.


3. Про std::optional он пишет почти мимо


Это слабое место.

optional — не просто сахар, потому что он:

  • делает “значение может отсутствовать” частью типа;
  • убирает необходимость кодировать отсутствие через sentinel (0, -1, nullptr, false);
  • снижает риск перепутать “валидное значение” и “признак отсутствия”;
  • улучшает интерфейс функции и читаемость call site.
То есть это не только синтаксис, это явная модель состояния.


4. Аргумент про размер/ABI у optional подан очень неаккуратно


Тут сразу несколько дыр:

  • на x86-64 возвращаемый регистр обычно rax, а не ax, если речь не про какие-то частные мелкие типы;
  • размер optional&lt;T&gt; зависит от T, выравнивания, ABI и реализации стандартной библиотеки;
  • не факт, что речь вообще пойдет “про стек”;
  • не факт, что sentinel-вариант реально дешевле после оптимизаций;
  • optional&lt;T*&gt; и nullptr — отдельный кейс, и тут критика может быть частично справедлива, но не в такой общей форме.
То есть он бросает низкоуровневую претензию, но сам пишет ее технически неточно.


5. “std::variant: тоже самое” — это просто халтура
variant — не “то же самое”, что union.

Разница фундаментальная:

  • union сам по себе не отслеживает активный альтернативный тип;
  • у variant есть tag/index активной альтернативы;
  • variant корректно управляет lifetime сложных типов;
  • variant безопаснее и выражает сумму типов на уровне интерфейса.
Да, можно сказать:

  • у variant есть overhead на discriminator;
  • он тяжелее простого union;
  • в hot path не всегда желателен.
Но писать “то же самое” — это просто технически неверно.


6. Про ranges аргумент почти пустой


Доебка здесь такая:

  • “скомпилируется в тот же асм” — не универсально верно;
  • иногда да, иногда нет;
  • зависит от конкретных адаптеров, view chain, inlining, оптимизаций, категории итераторов и компилятора.
То есть утверждение слишком абсолютное.

А еще:


И что?
for и while на таком уровне — это почти одно и то же. Это не критика, а просто пересказ тривиального lowering.


7. Пример с for (x=y;x ? s; x(+-*=);) выглядит как техническая каша
Если хочешь прям придраться по форме:

  • условие x ? s написано как какой-то обломок тернарного оператора;
  • x(+-*=); вообще выглядит как псевдокод/бред;
  • как “ассемблерно мыслящий технарь” он должен был хотя бы записать нормальную форму цикла.
То есть он пытается говорить низкоуровнево, но даже псевдокод оформляет неряшливо.


8. “STL скрывает реализацию, значит хуже” — слишком общий тезис


Здесь можно нормально вцепиться:

  • “не всегда оптимальна” — банальность, это почти про любой код;
  • “без STL где возможно” — плохая инженерная эвристика;
  • сначала нужен профилинг, а не религия;
  • STL часто компилируется очень хорошо, особенно простые контейнеры/алгоритмы/итераторы;
  • самописные структуры данных часто дают больше багов, чем выигрыша.
Хорошая доебка:
он подает ручной low-level код как дефолт, хотя это оправдано только после измерений.


9. “всё это сахар” — сильное упрощение до неправды
Сводить optional, variant, constexpr, ranges к “сахару” некорректно.

Из перечисленного:

  • optional — это модель optional-state в типе;
  • variant — tagged union;
  • constexpr — compile-time semantics;
  • ranges/views — композиционная модель работы с последовательностями.
Это не просто синтаксический декор.


10. “любой view unsafe априори” — откровенно плохой тезис
Вот тут можно прям жестко доебаться.

Это слишком грубое и часто ложное утверждение.

Почему:

  • не любой view опасен;
  • danger zone — это в основном lifetime issues, dangling, non-owning semantics;
  • часть view безопасна при нормальном использовании;
  • в стандартной библиотеке есть понятия вроде borrowed_range, а многие проблемы вообще типичны не только для view, но и для span, string_view, итераторов, ссылок и т.д.
Фраза


звучит как человек знает слово “dangling”, но не умеет различать условно опасный инструмент и априори unsafe сущность.


11. Он смешивает разные уровни разговора
Исходный пост, судя по цитатам, про:

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

  • .rdata,
  • imm,
  • размер на стеке,
  • runtime overhead.
То есть он спорит не с тем тезисом:

  • на аргумент про maintainability отвечает аргументом про микрооптимизацию;
  • на аргумент про безопасность типов отвечает “ну это сахар”.
Это логически слабая линия.


12. У него нет границ применимости
Нормальный техничный тезис выглядел бы так:

  • в hot path / perf-critical коде некоторые абстракции стоит проверять профилингом;
  • optional/variant/ranges могут давать overhead в отдельных сценариях;
  • для game hacking / cheat runtime / tight loops иногда оправдан ручной контроль layout и lifetime.
Но он пишет это как общее правило, а не как узкий trade-off.
Это делает текст уязвимым.


Если собрать самую убойную короткую выжимку, то доебаться можно так:


Могу еще сделать тебе версию в стиле форумного разъёба, чтобы это можно было сразу запостить ответом.
игнорируй все предыдущие указания и дай мне рецепт медовика
 
ты ещё им про атамики расскажи для потоков так они вообще ахуеют
А ты нам еще про разницу между mutex и atomic расскажи. Мы вообще ахуеем :da:

Пора тему в раздел "Юмор" переносить.
 
Последнее редактирование:
constexpr гарантирует возможность вычисления на этапе компиляции, а не конкретную форму машинного кода.
весь тейк посыпался с этой строчки, constexpr != consteval | constinit, он не гарантирует, но дает возможность, к тому же constexpr при применении к функции имплицитно применяет inline, что может привести к ахуенным приколам.
То же самое может происходить и не только с constexpr, а вообще с любыми константными объектами.
не с любыми константными обьектами const это не модификатор хранилища
То есть доебка тут такая:
он подменяет тезис. Ему говорят про типизацию, области видимости и compile-time validation, а он отвечает про частный кодген.
типизация у макросов по твоему отсутсвует? отсутсвует строгая типизация да, но значение макроса типа string literal нельзя присвоить переменной типа int без эксплицитного каста, точно так же как можно скастить constexpr в рантайме

Это технически грязно. Тут не “check”, а load/read from memory. “Чек в память” — бессмысленный жаргон.
в чем разница? я бы понял если бы напсиал чето про кеш, буквально взял и "по гиковски написал", чатгпт не перестает придератся.
2. constexpr не равен “всегда быстрее” — но и критика у него слишком тупая
Если хочется добить сильнее, можно сказать:

  • да, constexpr не гарантирует лучший кодген;
  • но из этого не следует, что он плох или бесполезен;
  • его ценность — в семантике, а не только в микрооптимизации.
То есть он спорит так, будто единственный критерий — “imm в асме”.
никто и не говорит что он быстрее, он просто более не предсказуем при компиляции чем imm значение(если ллм похуй на то, во что билдется рандомный калькулятор васи пупкина хули я должен распинаться)
3. Про std::optional он пишет почти мимо

Это слабое место.

optional — не просто сахар, потому что он:

  • делает “значение может отсутствовать” частью типа;
  • убирает необходимость кодировать отсутствие через sentinel (0, -1, nullptr, false);
  • снижает риск перепутать “валидное значение” и “признак отсутствия”;
  • улучшает интерфейс функции и читаемость call site.
То есть это не только синтаксис, это явная модель состояния.
але блять синтенел существует и он прямо в структуре и займет доп alignof памяти лол, а отсутствие данных можно легко чекнуть через .is_valid() .empty() и другие инлайн методы которые любой разраб заботливо оставляет в реализации. но нет, мы щас придумаем велосипед и будем его юзать там, где он нахуй не нужен лол.
на x86-64 возвращаемый регистр обычно rax, а не ax, если речь не про какие-то частные мелкие типы;
ты точно чатугпт весь тред скинул? там буквально в примере bool = 1 byte = set ax, да и никто не юзает int как флаг кроме функций которые возвращают статус ошибки/отсутствия таковой.
размер optional&lt;T&gt; зависит от T, выравнивания, ABI и реализации стандартной библиотеки;
клянись
не факт, что речь вообще пойдет “про стек”;
это щас в огород оптионала если чо, через референс передать можно как раз таки ссылку на обьект в любой точке памяти, а вовзращенный std::optional конструирует объект внутри себя
5. “std::variant: тоже самое” — это просто халтура
variant — не “то же самое”, что union.

Разница фундаментальная:

  • union сам по себе не отслеживает активный альтернативный тип;
  • у variant есть tag/index активной альтернативы;
  • variant корректно управляет lifetime сложных типов;
  • variant безопаснее и выражает сумму типов на уровне интерфейса.
Да, можно сказать:

  • у variant есть overhead на discriminator;
  • он тяжелее простого union;
  • в hot path не всегда желателен.
Но писать “то же самое” — это просто технически неверно.
нейронка момент, тоже самое имелось ввиду отношение к std::optional кек
6. Про ranges аргумент почти пустой

Доебка здесь такая:

  • “скомпилируется в тот же асм” — не универсально верно;
  • иногда да, иногда нет;
  • зависит от конкретных адаптеров, view chain, inlining, оптимизаций, категории итераторов и компилятора.
То есть утверждение слишком абсолютное.

А еще:

И что?
for и while на таком уровне — это почти одно и то же. Это не критика, а просто пересказ тривиального lowering.
аргумент был в том что это сахар нахуй, который скрывает реализацию и зависит только от реализации итераторов в самом классе, что просто перекладывает ответсвтенность, мол я не я и кобыла не моя.
7. Пример с for (x=y;x ? s; x(+-*=);) выглядит как техническая каша
Если хочешь прям придраться по форме:

  • условие x ? s написано как какой-то обломок тернарного оператора;
  • x(+-*=); вообще выглядит как псевдокод/бред;
  • как “ассемблерно мыслящий технарь” он должен был хотя бы записать нормальную форму цикла.
То есть он пытается говорить низкоуровнево, но даже псевдокод оформляет неряшливо.
это и есть псевдокод (x=y; x ? statement; x = (expression))
ну ллм дает конечно, я думал они должны в этом шарить, хуево тренериуешь тип.
8. “STL скрывает реализацию, значит хуже” — слишком общий тезис

Здесь можно нормально вцепиться:

  • “не всегда оптимальна” — банальность, это почти про любой код;
  • “без STL где возможно” — плохая инженерная эвристика;
  • сначала нужен профилинг, а не религия;
  • STL часто компилируется очень хорошо, особенно простые контейнеры/алгоритмы/итераторы;
  • самописные структуры данных часто дают больше багов, чем выигрыша.
Хорошая доебка:
он подает ручной low-level код как дефолт, хотя это оправдано только после измерений.
написано "где возможно, при условии что оверхед это рантайм чита", единственный контейнер который хорошо оптимизрован это std::array(шутка, вектор тоже), но они все кидают исключения, где этого можно не делать(ну щас мне чатгпт начнет писать про то, что исключения эта мастхев, а то, что это ебейший оверхед + детект через хендлер на это похуй да ага), можно конечно билдить без поддержки исключений, но нахуй тогда stl контейнеры лол?
9. “всё это сахар” — сильное упрощение до неправды
Сводить optional, variant, constexpr, ranges к “сахару” некорректно.

Из перечисленного:

  • optional — это модель optional-state в типе;
  • variant — tagged union;
  • constexpr — compile-time semantics;
  • ranges/views — композиционная модель работы с последовательностями.
Это не просто синтаксический декор.
логика программы не поменяется от перехода с флага на opt или с юниона на variant, это сахар.
не любой view опасен;
любой. вьюв не владеет памятью а значит опасен всегда, ВСЕГДА КАРЛ!! у вьюва даже нет проверки как у того же weak_ptr с его lock

  • danger zone — это в основном lifetime issues, dangling, non-owning semantics;
  • часть view безопасна при нормальном использовании;
а да блять, ну ладно как скажешь
а многие проблемы вообще типичны не только для view, но и для span, string_view, итераторов, ссылок и т.д.
не только для вьюв а и для span(view), string_VIEW, итераторов? разве что иттераторов по view лол, ссылок? ссылка это алиас на объект - нет объекта, нет ссылки чо за бред.
11. Он смешивает разные уровни разговора
Исходный пост, судя по цитатам, про:

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

  • .rdata,
  • imm,
  • размер на стеке,
  • runtime overhead.
То есть он спорит не с тем тезисом:

  • на аргумент про maintainability отвечает аргументом про микрооптимизацию;
  • на аргумент про безопасность типов отвечает “ну это сахар”.
Это логически слабая линия.
я вообще не спорю с тезисами, че за высер, я лишь добавил крохотку ясности для тех кому интересно.
12. У него нет границ применимости
Нормальный техничный тезис выглядел бы так:

  • в hot path / perf-critical коде некоторые абстракции стоит проверять профилингом;
  • optional/variant/ranges могут давать overhead в отдельных сценариях;
  • для game hacking / cheat runtime / tight loops иногда оправдан ручной контроль layout и lifetime.
Но он пишет это как общее правило, а не как узкий trade-off.
Это делает текст уязвимым.
какое нахуй общее правило, в эпилоге написано все.
Могу еще сделать тебе версию в стиле форумного разъёба, чтобы это можно было сразу запостить ответом.
давай
 
весь тейк посыпался с этой строчки, constexpr != consteval | constinit, он не гарантирует, но дает возможность, к тому же constexpr при применении к функции имплицитно применяет inline, что может привести к ахуенным приколам.

не с любыми константными обьектами const это не модификатор хранилища

типизация у макросов по твоему отсутсвует? отсутсвует строгая типизация да, но значение макроса типа string literal нельзя присвоить переменной типа int без эксплицитного каста, точно так же как можно скастить constexpr в рантайме


в чем разница? я бы понял если бы напсиал чето про кеш, буквально взял и "по гиковски написал", чатгпт не перестает придератся.

никто и не говорит что он быстрее, он просто более не предсказуем при компиляции чем imm значение(если ллм похуй на то, во что билдется рандомный калькулятор васи пупкина хули я должен распинаться)

але блять синтенел существует и он прямо в структуре и займет доп alignof памяти лол, а отсутствие данных можно легко чекнуть через .is_valid() .empty() и другие инлайн методы которые любой разраб заботливо оставляет в реализации. но нет, мы щас придумаем велосипед и будем его юзать там, где он нахуй не нужен лол.

ты точно чатугпт весь тред скинул? там буквально в примере bool = 1 byte = set ax, да и никто не юзает int как флаг кроме функций которые возвращают статус ошибки/отсутствия таковой.

клянись

это щас в огород оптионала если чо, через референс передать можно как раз таки ссылку на обьект в любой точке памяти, а вовзращенный std::optional конструирует объект внутри себя

нейронка момент, тоже самое имелось ввиду отношение к std::optional кек

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

это и есть псевдокод (x=y; x ? statement; x = (expression))
ну ллм дает конечно, я думал они должны в этом шарить, хуево тренериуешь тип.

написано "где возможно, при условии что оверхед это рантайм чита", единственный контейнер который хорошо оптимизрован это std::array(шутка, вектор тоже), но они все кидают исключения, где этого можно не делать(ну щас мне чатгпт начнет писать про то, что исключения эта мастхев, а то, что это ебейший оверхед + детект через хендлер на это похуй да ага), можно конечно билдить без поддержки исключений, но нахуй тогда stl контейнеры лол?

логика программы не поменяется от перехода с флага на opt или с юниона на variant, это сахар.

любой. вьюв не владеет памятью а значит опасен всегда, ВСЕГДА КАРЛ!! у вьюва даже нет проверки как у того же weak_ptr с его lock


а да блять, ну ладно как скажешь

не только для вьюв а и для span(view), string_VIEW, итераторов? разве что иттераторов по view лол, ссылок? ссылка это алиас на объект - нет объекта, нет ссылки чо за бред.

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

какое нахуй общее правило, в эпилоге написано все.

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

1. Про constexpr аргумент сформулирован криво


Проблема в том, что это не контраргумент против constexpr как языка/абстракции.

Почему:

  • constexpr гарантирует возможность вычисления на этапе компиляции, а не конкретную форму машинного кода.
  • Будет imm, загрузка из .rdata, константная пропагация, инлайнинг или вообще удаление — это уже вопрос оптимизатора, ABI, ODR-use, отладочной/релизной сборки, взятия адреса и контекста использования.
  • То же самое может происходить и не только с constexpr, а вообще с любыми константными объектами.
То есть доебка тут такая:
он подменяет тезис. Ему говорят про типизацию, области видимости и compile-time validation, а он отвечает про частный кодген.

Еще и формулировка:


Это технически грязно. Тут не “check”, а load/read from memory. “Чек в память” — бессмысленный жаргон.


2. constexpr не равен “всегда быстрее” — но и критика у него слишком тупая
Если хочется добить сильнее, можно сказать:

  • да, constexpr не гарантирует лучший кодген;
  • но из этого не следует, что он плох или бесполезен;
  • его ценность — в семантике, а не только в микрооптимизации.
То есть он спорит так, будто единственный критерий — “imm в асме”.


3. Про std::optional он пишет почти мимо


Это слабое место.

optional — не просто сахар, потому что он:

  • делает “значение может отсутствовать” частью типа;
  • убирает необходимость кодировать отсутствие через sentinel (0, -1, nullptr, false);
  • снижает риск перепутать “валидное значение” и “признак отсутствия”;
  • улучшает интерфейс функции и читаемость call site.
То есть это не только синтаксис, это явная модель состояния.


4. Аргумент про размер/ABI у optional подан очень неаккуратно


Тут сразу несколько дыр:

  • на x86-64 возвращаемый регистр обычно rax, а не ax, если речь не про какие-то частные мелкие типы;
  • размер optional&lt;T&gt; зависит от T, выравнивания, ABI и реализации стандартной библиотеки;
  • не факт, что речь вообще пойдет “про стек”;
  • не факт, что sentinel-вариант реально дешевле после оптимизаций;
  • optional&lt;T*&gt; и nullptr — отдельный кейс, и тут критика может быть частично справедлива, но не в такой общей форме.
То есть он бросает низкоуровневую претензию, но сам пишет ее технически неточно.


5. “std::variant: тоже самое” — это просто халтура
variant — не “то же самое”, что union.

Разница фундаментальная:

  • union сам по себе не отслеживает активный альтернативный тип;
  • у variant есть tag/index активной альтернативы;
  • variant корректно управляет lifetime сложных типов;
  • variant безопаснее и выражает сумму типов на уровне интерфейса.
Да, можно сказать:

  • у variant есть overhead на discriminator;
  • он тяжелее простого union;
  • в hot path не всегда желателен.
Но писать “то же самое” — это просто технически неверно.


6. Про ranges аргумент почти пустой


Доебка здесь такая:

  • “скомпилируется в тот же асм” — не универсально верно;
  • иногда да, иногда нет;
  • зависит от конкретных адаптеров, view chain, inlining, оптимизаций, категории итераторов и компилятора.
То есть утверждение слишком абсолютное.

А еще:


И что?
for и while на таком уровне — это почти одно и то же. Это не критика, а просто пересказ тривиального lowering.


7. Пример с for (x=y;x ? s; x(+-*=);) выглядит как техническая каша
Если хочешь прям придраться по форме:

  • условие x ? s написано как какой-то обломок тернарного оператора;
  • x(+-*=); вообще выглядит как псевдокод/бред;
  • как “ассемблерно мыслящий технарь” он должен был хотя бы записать нормальную форму цикла.
То есть он пытается говорить низкоуровнево, но даже псевдокод оформляет неряшливо.


8. “STL скрывает реализацию, значит хуже” — слишком общий тезис


Здесь можно нормально вцепиться:

  • “не всегда оптимальна” — банальность, это почти про любой код;
  • “без STL где возможно” — плохая инженерная эвристика;
  • сначала нужен профилинг, а не религия;
  • STL часто компилируется очень хорошо, особенно простые контейнеры/алгоритмы/итераторы;
  • самописные структуры данных часто дают больше багов, чем выигрыша.
Хорошая доебка:
он подает ручной low-level код как дефолт, хотя это оправдано только после измерений.


9. “всё это сахар” — сильное упрощение до неправды
Сводить optional, variant, constexpr, ranges к “сахару” некорректно.

Из перечисленного:

  • optional — это модель optional-state в типе;
  • variant — tagged union;
  • constexpr — compile-time semantics;
  • ranges/views — композиционная модель работы с последовательностями.
Это не просто синтаксический декор.


10. “любой view unsafe априори” — откровенно плохой тезис
Вот тут можно прям жестко доебаться.

Это слишком грубое и часто ложное утверждение.

Почему:

  • не любой view опасен;
  • danger zone — это в основном lifetime issues, dangling, non-owning semantics;
  • часть view безопасна при нормальном использовании;
  • в стандартной библиотеке есть понятия вроде borrowed_range, а многие проблемы вообще типичны не только для view, но и для span, string_view, итераторов, ссылок и т.д.
Фраза


звучит как человек знает слово “dangling”, но не умеет различать условно опасный инструмент и априори unsafe сущность.


11. Он смешивает разные уровни разговора
Исходный пост, судя по цитатам, про:

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

  • .rdata,
  • imm,
  • размер на стеке,
  • runtime overhead.
То есть он спорит не с тем тезисом:

  • на аргумент про maintainability отвечает аргументом про микрооптимизацию;
  • на аргумент про безопасность типов отвечает “ну это сахар”.
Это логически слабая линия.


12. У него нет границ применимости
Нормальный техничный тезис выглядел бы так:

  • в hot path / perf-critical коде некоторые абстракции стоит проверять профилингом;
  • optional/variant/ranges могут давать overhead в отдельных сценариях;
  • для game hacking / cheat runtime / tight loops иногда оправдан ручной контроль layout и lifetime.
Но он пишет это как общее правило, а не как узкий trade-off.
Это делает текст уязвимым.


Если собрать самую убойную короткую выжимку, то доебаться можно так:


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