[[assume]] 属性(C++23)
什么是 [[assume]]
[[assume]] 是 C++23 引入的属性,用于告诉编译器某个表达式在当前位置一定为 true。编译器可以基于这个假设做优化,但不会实际求值这个表达式。
在 C++23 之前,GCC 没有直接对应的内建函数(需要用 if(expr) {} else { __builtin_unreachable(); } 模拟),Clang 有 __builtin_assume(),MSVC 有 __assume()。[[assume]] 统一了这些平台特定的做法。
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;
}
// 编译器可以据此做循环展开、消除边界检查等优化
}基本示例
#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 获得优化收益。