C++ 类型安全实战：告别 95% 的运行时错误

union UserData {
    int user_id;      // 有时我是用户ID
    double balance;    // 有时我是账户余额
    char name[32];     // 有时我又是用户名
}; 

void processUser(UserData data) {
    // 糟糕!我们根本不知道data现在是哪种类型
    // 就像闭着眼睛过马路一样危险! 💀
    printf("%d", data.user_id);  // 祝你好运...
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

#include <variant>
#include <string>

// 优雅地使用std::variant - 再也不用担心认错类型啦!
using UserData = std::variant<int, double, std::string>;

void processUser(const UserData& data) {
    // 类型检查清清楚楚,明明白白 🔍
    if (std::holds_alternative<int>(data)) {
        std::cout << "找到用户ID啦: " << std::get<int>(data);
    } else if (std::holds_alternative<double>(data)) {
        std::cout << "这是余额呢: " << std::get<double>(data);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override { /* ... */ }
    void setRadius(double r) { radius = r; }
private:
    double radius;
};

void updateShape(Shape* shape) {
    Circle* circle = (Circle*)shape;  // 哇!这操作太野了! 💣
    circle->setRadius(5.0);  // 祈祷吧,要是shape不是Circle,后果很严重... 🙏
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

void updateShape(Shape* shape) {
    // 优雅地使用dynamic_cast,就像带上了探测器一样安全! 🔍
    if (auto* circle = dynamic_cast<Circle*>(shape)) {
        circle->setRadius(5.0);  // 安全又可靠,就是这么简单! 🎯
    }
    // 如果转换失败?没关系,我们优雅地跳过它~
}
1.
2.
3.
4.
5.
6.
7.

void calculateAverage(int scores[], int size) {
    // 糟糕!数组变成了"裸指针",完全不知道自己有多长了! 😱
    for (int i = 0; i < size; ++i) {  
        // size参数可能是错的,这简直就像在玩俄罗斯轮盘! 💀
    }
}

int main() {
    int scores[] = {85, 92, 77, 68, 95};
    calculateAverage(scores, 6);  // 啊哦...数组明明只有5个元素,却传了6! 🎲
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

#include <span>

double calculateAverage(std::span<const int> scores) {
    // std::span就像给数组装上了GPS定位器! 🛰️
    double sum = 0;
    for (int score : scores) {  // 安全又优雅的遍历~
        sum += score;
    }
    return sum / scores.size();  // size()永远准确,不会骗人! 📏
}

int main() {
    int scores[] = {85, 92, 77, 68, 95};
    auto avg = calculateAverage(scores);  // 魔法般自动推导正确的大小! ✨
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

void processMatrix(int* matrix, int rows, int cols) {
    // 看到这个 <= 了吗？这就是一个定时炸弹! 💣
    for (int i = 0; i <= rows; i++) {  // 糟糕的越界访问
        for (int j = 0; j < cols; j++) {
            matrix[i * cols + j] = 0;  // 祈祷吧,这里随时可能崩溃... 🙏
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.

#include <span>

// std::span就像给矩阵请了个保镖! 💪
void processMatrix(std::span<int, 12> matrix, int rows = 3, int cols = 4) {
    for (int i = 0; i < rows; i++) {     // 注意这里是 < 而不是 <= 
        for (int j = 0; j < cols; j++) {
            // span会自动帮我们检查范围,越界就立刻报警! 🚨
            matrix[i * cols + j] = 0;  
        }
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

void processData(int value) {
    short small = value;      // 危险！大数变小数可能丢失数据 😱
    unsigned int positive = -value;  // 险！负数变无符号会出问题 💀
    float less_precise = 123456789.0;  // 危险！精度悄悄丢失了 😨
}

int main() {
    processData(50000);    // 超出short范围了！
    processData(-42);      // 负数变无符号，结果完全错误！
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

#include <limits>
#include <stdexcept>

void processData(int value) {
    // 1. 使用大括号初始化，防止窄化转换
    // short small{value};  // 编译器直接报错，帮你找到问题！ 🚫
    
    // 2. 使用std::numeric_limits进行范围检查
    if (value > std::numeric_limits<short>::max() || 
        value < std::numeric_limits<short>::min()) {
        throw std::out_of_range("数值超出short范围啦！"); 
    }
    short small = static_cast<short>(value);  // 安全！已经检查过范围了 ✅
    
    // 3. 使用static_cast替代隐式转换，让代码意图更明确
    if (value >= 0) {
        unsigned int positive = static_cast<unsigned int>(value);  // 清晰！ 🎯
    }
    
    // 4. 处理浮点数精度问题
    double precise = 123456789.0;
    float less_precise = static_cast<float>(precise);
    if (static_cast<double>(less_precise) != precise) {
        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.