[[assume]] 属性(C++23) ​

什么是 [[assume]] ​

[[assume]] 是 C++23 引入的属性,用于告诉编译器某个表达式在当前位置一定为 true。编译器可以基于这个假设做优化,但不会实际求值这个表达式。

在 C++23 之前,GCC 没有直接对应的内建函数(需要用 if(expr) {} else { __builtin_unreachable(); } 模拟),Clang 有 __builtin_assume(),MSVC 有 __assume()。[[assume]] 统一了这些平台特定的做法。

cpp
void process(int* data, int size) {
    [[assume(size > 0)]];       // 告诉编译器 size 一定大于 0
    [[assume(size % 4 == 0)]];  // 告诉编译器 size 一定是 4 的倍数

    for (int i = 0; i < size; i++) {
        data[i] *= 2;
    }
    // 编译器可以据此做循环展开、消除边界检查等优化
}

基本示例 ​

cpp
#include <iostream>
#include <cmath>
#include <vector>
#include <cassert>
#include <algorithm>

// ============================
// 示例1:基本假设
// ============================

int divide_positive(int a, int b) {
    [[assume(b > 0)]];  // 假设 b 一定是正数
    // 编译器可以用更高效的除法指令(不需要处理负数情况)
    return a / b;
}

void basic_demo() {
    std::cout << "100 / 7 = " << divide_positive(100, 7) << std::endl;
    std::cout << "42 / 3 = " << divide_positive(42, 3) << std::endl;
}

// ============================
// 示例2:数组大小假设
// ============================

void process_array(float* data, std::size_t size) {
    [[assume(size > 0)]];        // 至少有一个元素
    [[assume(size % 32 == 0)]];  // 大小是 32 的倍数

    // 编译器知道循环至少执行一次,且迭代次数是 32 的倍数
    // 可以做更激进的向量化和循环展开
    for (std::size_t i = 0; i < size; i++) {
        data[i] = std::clamp(data[i], -1.0f, 1.0f);
    }
}

void array_demo() {
    std::vector<float> data(64, 0.5f);
    data[10] = 2.0f;
    data[20] = -3.0f;

    process_array(data.data(), data.size());

    std::cout << "data[10] = " << data[10] << std::endl;  // 1.0(被 clamp)
    std::cout << "data[20] = " << data[20] << std::endl;  // -1.0(被 clamp)
    std::cout << "data[5] = " << data[5] << std::endl;    // 0.5(不变)
}

// ============================
// 示例3:枚举值范围假设
// ============================

enum class Direction { North = 0, South = 1, East = 2, West = 3 };

const char* direction_name(Direction d) {
    [[assume(static_cast<int>(d) >= 0 && static_cast<int>(d) <= 3)]];

    switch (d) {
        case Direction::North: return "北";
        case Direction::South: return "南";
        case Direction::East:  return "东";
        case Direction::West:  return "西";
    }
    // 编译器知道 d 一定在 0-3 范围内,可以消除 default 检查
    return "";  // 不会到达
}

void enum_demo() {
    std::cout << direction_name(Direction::East) << std::endl;
}

// ============================
// 示例4:配合 assert 使用
// ============================

int safe_sqrt(int x) {
    // Debug 模式:assert 检查
    assert(x >= 0);
    // Release 模式:assume 优化
    [[assume(x >= 0)]];

    return static_cast<int>(std::sqrt(static_cast<double>(x)));
}

void assert_assume_demo() {
    std::cout << "sqrt(16) = " << safe_sqrt(16) << std::endl;
    std::cout << "sqrt(100) = " << safe_sqrt(100) << std::endl;
}

// ============================
// 示例5:指针非空假设
// ============================

int deref_nonnull(const int* ptr) {
    [[assume(ptr != nullptr)]];
    // 编译器可以省略空指针检查
    return *ptr;
}

void pointer_demo() {
    int value = 42;
    std::cout << "值: " << deref_nonnull(&value) << std::endl;
}

// ============================
// 示例6:对齐假设
// ============================

void process_aligned(float* data, int n) {
    [[assume(reinterpret_cast<std::uintptr_t>(data) % 16 == 0)]];
    [[assume(n > 0)]];

    // 编译器知道 data 是 16 字节对齐的
    // 可以使用对齐的 SIMD 指令
    for (int i = 0; i < n; i++) {
        data[i] *= 2.0f;
    }
}

void alignment_demo() {
    alignas(16) float data[4] = {1.0f, 2.0f, 3.0f, 4.0f};
    process_aligned(data, 4);

    for (float f : data) {
        std::cout << f << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例7:表达式不会被求值
// ============================

void not_evaluated_demo() {
    int x = 10;

    // 表达式不会被求值!只是告诉编译器这个条件成立
    // 即使表达式有副作用,也不会执行
    [[assume(x > 0)]];

    // 下面这个假设不会导致 f() 被调用
    // [[assume((f(), true))]];  // f() 不会被调用

    std::cout << "表达式不会被求值,x = " << x << std::endl;
}

int main() {
    std::cout << "=== 基本假设 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 数组处理 ===" << std::endl;
    array_demo();

    std::cout << "\n=== 枚举范围 ===" << std::endl;
    enum_demo();

    std::cout << "\n=== assert + assume ===" << std::endl;
    assert_assume_demo();

    std::cout << "\n=== 指针非空 ===" << std::endl;
    pointer_demo();

    std::cout << "\n=== 对齐 ===" << std::endl;
    alignment_demo();

    std::cout << "\n=== 不求值 ===" << std::endl;
    not_evaluated_demo();

    return 0;
}

assume vs 其他机制 ​

机制效果违反时求值标准
[[assume(expr)]]编译器优化未定义行为不求值C++23
assert(expr)Debug 检查Debug 崩溃求值(Debug)C
std::unreachable()标记不可达未定义行为不适用C++23
__builtin_assume(expr)编译器优化未定义行为不求值Clang
__assume(expr)编译器优化未定义行为不求值MSVC

适用场景 ​

  • 高性能代码中提供循环边界信息
  • 音频/视频处理中的数据对齐和大小假设
  • 数值计算中的值范围假设
  • 消除不必要的边界检查和分支
  • 配合 assert 使用——Debug 检查 + Release 优化

常见问题 ​

假设不成立会怎样?

未定义行为。编译器基于假设做了优化,如果实际运行时假设不成立,程序可能产生错误结果、崩溃或其他不可预测的行为。

assume 的表达式会被执行吗?

不会。表达式不会被求值。即使表达式中有函数调用或副作用,也不会执行。这和 assert 不同——assert 在 Debug 模式下会求值表达式。

应该大量使用 assume 吗?

不应该。assume 应该谨慎使用,只在你确定假设一定成立时使用。错误的假设会导致难以调试的 bug。推荐的做法是配合 assert:Debug 模式用 assert 验证,Release 模式用 assume 优化。

assume 和 [[likely]]/[[unlikely]] 有什么区别?

[[likely]] 只是提示某个分支更可能执行,不改变语义。[[assume]] 断言条件一定为真,如果不为真就是未定义行为。assume 的优化效果更强,但风险也更大。

注意事项 ​

  • 假设不成立时是未定义行为
  • 表达式不会被求值——不要依赖副作用
  • 只能应用于空语句(后面必须加分号)
  • 应该谨慎使用,只在确信假设成立时
  • 推荐配合 assert 使用
  • 不能用逗号运算符(但可以用括号包裹)

总结 ​

[[assume]] 是 C++23 引入的标准化优化属性,告诉编译器某个表达式在当前位置一定为 true,让编译器据此做优化。它替代了以前各编译器的非标准扩展(__builtin_assume 和 __assume)。表达式不会被求值,如果假设不成立则是未定义行为。典型用法包括提供循环边界信息、值范围假设、指针非空假设等。最安全的使用方式是配合 assert——Debug 模式用 assert 验证假设,Release 模式用 assume 获得优化收益。