[[assume]]

[[assume(expr)]] — атрибут, размещаемый как отдельный оператор в теле функции, сообщающий компилятору, что выражение expr ВСЕГДА истинно в этой точке программы. Компилятор ничего не проверяет — ни в debug, ни в release сборке — а вправе использовать это условие как аксиому для оптимизации: например, устранить проверку на ноль перед делением, если assume гарантирует ненулевое значение, или выбрать более узкий/быстрый путь вычисления, зная границы значения заранее.[[assume(expr)]] is an attribute placed as a standalone statement in a function body, telling the compiler that the expression expr is ALWAYS true at this point in the program. The compiler checks nothing — not in debug, not in release builds — and is free to use that condition as an axiom for optimization: for instance, eliminating a division-by-zero check when assume guarantees a nonzero value, or picking a narrower/faster computation path by knowing the value's bounds ahead of time.

void f_gcc_clang(int x) {
    if (!(x > 0)) __builtin_unreachable();  // непереносимо, нечитаемо// non-portable, unreadable
    int y = 100 / x;
}

void f_msvc(int x) {
    __assume(x > 0);  // свой интринсик, свой синтаксис// its own intrinsic, its own syntax
    int y = 100 / x;
}
// три разных способа сказать одно и то же в трёх компиляторах// three different ways to say the same thing across three compilers

void f(int x) {
    [[assume(x > 0)]];
    int y = 100 / x;  // компилятор может пропустить проверку на 0// the compiler may skip the zero check
}
// один синтаксис, одинаковый смысл на GCC/Clang/MSVC// one syntax, the same meaning across GCC/Clang/MSVC

Подсказки компилятору об "аксиомах" для оптимизации существовали и до C++23, но каждая из них была ущербной по-своему:Hints to the compiler about optimization "axioms" existed before C++23, too, but each was flawed in its own way:

[[assume(expr)]] оформляется как атрибут на пустом операторе (;) — сам по себе он не генерирует никакого кода и не вычисляет expr в рантайме. Он лишь передаёт оптимизатору информацию, которую тот может (но не обязан) использовать при генерации кода для всего, что находится "ниже по потоку" в той же функции.[[assume(expr)]] is written as an attribute on an empty statement (;) — by itself it generates no code and does not evaluate expr at runtime. It merely passes information to the optimizer, which may (but isn't obligated to) use it when generating code for everything "downstream" in that same function.

int divide(int a, int b) {
    [[assume(b != 0)]];       // заявление: b никогда не равен 0 здесь// a claim: b is never 0 here
    return a / b;              // компилятор МОЖЕТ убрать неявную проверку на 0// the compiler MAY drop the implicit zero check
}

int clamp_positive(int x) {
    [[assume(x >= 0 && x <= 100)]];  // диапазон как аксиома// a range as an axiom
    return x * 2;             // компилятор знает: результат в [0, 200]// the compiler knows the result is in [0, 200]
}

Важное следствие модели "аксиома без проверки": expr не обязан быть дешёвым или даже вычисляться вообще в неоптимизированной сборке — стандарт явно разрешает компилятору не вычислять само выражение (в отличие от обычного оператора-выражения), раз оно используется только как источник информации для оптимизатора, а не как код, который должен реально выполниться.An important consequence of the "axiom with no check" model: expr need not be cheap, or even evaluated at all in an unoptimized build — the standard explicitly permits the compiler to skip evaluating the expression itself (unlike an ordinary expression-statement), since it's used purely as a source of information for the optimizer, not as code meant to actually run.

void process(const std::vector<int>& v, std::size_t idx) {
    [[assume(idx < v.size())]];   // v.size() может не вызваться вовсе// v.size() may not even be called
    auto x = v[idx];              // компилятор может убрать неявную проверку границ// the compiler may drop the implicit bounds check
}                                  // если idx >= v.size() в рантайме — UB, без диагностики// if idx >= v.size() at runtime — UB, no diagnostics

• cppreference — [[assume]]
• WG21 P1774 — Portable assumptions