C++性能优化的秘密武器：这个关键字让性能翻倍！

// 看看我们的数学魔法师！✨
consteval double power_of_pi(int n) {
    constexpr double pi = 3.14159265358979323846;
    double result = 1.0;
    while (n > 0) {
        result *= pi;
        --n;
    }
    return result;
}

// 太棒了！在编译时就计算好π²和π³ 🎯
constexpr double pi_squared = power_of_pi(2);  // π² ≈ 9.8696...
constexpr double pi_cubed = power_of_pi(3);    // π³ ≈ 31.0062...

// 但是如果我们这样做...
int user_power;
std::cout << "请输入一个数字：" << std::endl;
std::cin >> user_power;
// double result = power_of_pi(user_power); // 哎呀！魔法师：这不是魔法水晶球能预见的数字！🔮❌

// 再来看一个游戏中常用的角度计算 🎯
consteval double deg_to_rad(double degrees) {
    constexpr double pi = 3.14159265358979323846;
    return degrees * (pi / 180.0);
}

// 编译时就计算好常用角度，超快！⚡️
constexpr double angle_45 = deg_to_rad(45.0);   // π/4
constexpr double angle_90 = deg_to_rad(90.0);   // π/2
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

// 首先，我们需要一个精确的 π 值，让它成为我们的魔法常数 🎯
consteval double magic_pi() {
    return 3.14159265358979323846;
}

// 这是我们的角度转弧度转换器，它可以在编译时完成所有计算 📐
consteval double to_radians(double degrees) {
    return degrees * (magic_pi() / 180.0);
}

// 看看这个！一个编译时正弦查找表生成器 🧮
consteval double compile_time_sin(double degrees) {
    // 在真实项目中，这里会有完整的泰勒级数展开
    // 这里简化版本用于演示
    double radians = to_radians(degrees);
    double x = radians;
    double x3 = x * x * x;
    double x5 = x3 * x * x;
    return x - x3/6.0 + x5/120.0;  // 泰勒级数前几项
}

class GameEngine {
public:
    // 编译时生成常用角度的正弦值查找表 🎮
    static constexpr double sin_table[] = {
        compile_time_sin(0.0),    // 0.0
        compile_time_sin(30.0),   // 0.5
        compile_time_sin(45.0),   // 0.707...
        compile_time_sin(60.0),   // 0.866...
        compile_time_sin(90.0)    // 1.0
    };
    
    void update_player_position() {
        // 在游戏运行时，直接使用查找表，超快！⚡️
        double angle = get_player_angle();  // 获取玩家角度
        // 使用查找表和插值来获取近似值
        // 这比运行时计算快多了！🚀
    }
};

// 让我们看看编译时魔法的威力！
int main() {
    // 完美！所有计算都在编译时完成 ✨
    constexpr double sin_45 = compile_time_sin(45.0);
    
    // 但是如果我们尝试运行时计算...
    double user_angle;
    std::cout << "请输入一个角度：" << std::endl;
    std::cin >> user_angle;
    // double result = compile_time_sin(user_angle); // 🚫 魔法师：抱歉，这超出了我的能力范围！
    
    // 相反，我们应该使用查找表和插值 📊
    std::cout << "提示：请使用预计算的查找表！" << std::endl;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.

// constexpr 是一位随和的法师，既可以提前算好答案，也可以临时计算 🎭
constexpr int fib_flexible(int n) {
    if (n <= 1) return n;
    return fib_flexible(n-1) + fib_flexible(n-2);
}

// consteval 是一位严谨的法师，坚持所有计算都必须提前完成 ⚡️
consteval int fib_strict(int n) {
    if (n <= 1) return n;
    return fib_strict(n-1) + fib_strict(n-2);
}

int main() {
    // 看看两位法师的不同表现...
    
    // 编译时计算：两位法师都很开心 🌟
    constexpr int magic_number = fib_flexible(10);  // 算出 55
    constexpr int strict_magic = fib_strict(10);    // 也是 55
    
    // 运行时计算：情况就不一样啦！
    int user_input = 42;
    int flexible_result = fib_flexible(user_input);  // constexpr 法师：没问题，我来算！✨
    // int strict_result = fib_strict(user_input);   // consteval 法师：抱歉，我只算编译时的！🚫
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

// constexpr 法师的碰撞检测函数，随时可用 🎮
constexpr bool check_collision_flexible(float x1, float y1, float x2, float y2) {
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) < 100.0f;
}

// consteval 法师的版本，用于生成查找表 📊
consteval bool check_collision_strict(float x1, float y1, float x2, float y2) {
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) < 100.0f;
}

void game_loop() {
    // 编译时生成的碰撞表，两位法师都能处理 ✨
    constexpr bool collision_table[2][2] = {
        { check_collision_flexible(0, 0, 1, 1), check_collision_flexible(0, 0, 10, 10) },
        { check_collision_strict(0, 0, 1, 1), check_collision_strict(0, 0, 10, 10) }
    };
    
    // 但是处理实时游戏物体...
    float player_x = get_player_x();  // 运行时获取玩家位置
    float player_y = get_player_y();
    
    bool runtime_check = check_collision_flexible(player_x, player_y, 0, 0);  // ✅ 完全没问题！
    // bool strict_check = check_collision_strict(player_x, player_y, 0, 0);  // ❌ 编译都通不过！
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

// 这是一个灵活的厨师，可以随时为你服务
constexpr unsigned factorial(unsigned n) {
    return n < 2 ? 1 : n * factorial(n - 1);
}

// 这是我们的米其林大厨，只在"营业时间"（编译期）工作
consteval unsigned magic_factorial(unsigned n) {
    return factorial(n);  // 调用我们的助手厨师
}

int main() {
    // 完美！提前预订的美味佳肴 ✨
    constexpr auto result = magic_factorial(5);  // 120
    
    int user_number;
    std::cin >> user_number;
    // magic_factorial(user_number);  // 抱歉，不接受临时加单！🚫
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

consteval int get_answer() { return 42; }
consteval auto get_magic() { return &get_answer; }

// 这样可以！都在编译时完成 👍
constexpr int answer = get_answer();

// 但这样不行！不能让编译时的魔法泄露到运行时 🚫
// constexpr auto magic_ptr = get_magic();
1.
2.
3.
4.
5.
6.
7.
8.