C++ Core Guidelines 阅读笔记（4）：表达式与语句

// 好的：使用标准库算法
auto it = std::find(vec.begin(), vec.end(), value);
if (it != vec.end()) {
    process(*it);
}

// 不好：手写循环
for (auto it = vec.begin(); it != vec.end(); ++it) {
    if (*it == value) {
        process(*it);
        break;
    }
}

// 好的：简单表达式
bool condition1 = check_condition1();
bool condition2 = check_condition2();
bool is_valid = condition1 && condition2;

// 不好：复杂表达式
bool is_valid = (a > b && c < d) || (e == f && g != h) && (i > j);
// 难以理解，容易出错

// 好的：使用括号
if ((a > b) && (c < d)) {
    // 优先级明确
}

// 不好：依赖运算符优先级
if (a > b && c < d) {  
    // 虽然正确，但需要记住优先级
}

// 好的：范围 for
for (const auto& item : container) {
    process(item);
}

// 不好：传统 for 循环
for (auto it = container.begin(); it != container.end(); ++it) {
    process(*it);
}

// 好的：使用结构化控制流
void process() {
    if (error) {
        return;
    }
    // 继续处理
}

// 不好：使用 goto
void process() {
    if (error) {
        goto cleanup;
    }
cleanup:
    // 清理
}

// 好的：switch
switch (value) {
    case 1: return "one";
    case 2: return "two";
    default: return "unknown";
}

// 不好：长 if-else
if (value == 1) return "one";
else if (value == 2) return "two";
else return "unknown";

// 好的：在使用前声明
void process() {
    // ... 其他代码
    int value = compute_value();  // 在使用前声明
    use(value);
}

// 不好：在函数开头声明所有变量
void process() {
    int value;  // 声明太早
    // ... 很多代码
    value = compute_value();
    use(value);
}

// 好的：初始化变量
int count = 0;
std::string name;

// 不好：未初始化
int count;  // 未初始化
std::string name;  // 默认构造，但最好明确

// 好的：使用 auto
auto value = compute_value();
auto it = vec.begin();

// 不好：显式类型（如果类型复杂）
std::vector<int>::iterator it = vec.begin();

// 好的：if constexpr
template<typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        // 编译期分支
    } else {
        // 其他类型
    }
}

// 好的：早期返回
bool is_valid(const Data& data) {
    if (data.empty()) return false;
    if (data.size() > MAX_SIZE) return false;
    if (!data.check()) return false;
    return true;
}

// 不好：深层嵌套
bool is_valid(const Data& data) {
    if (!data.empty()) {
        if (data.size() <= MAX_SIZE) {
            if (data.check()) {
                return true;
            }
        }
    }
    return false;
}

// 好的：范围 for
for (const auto& item : items) {
    process(item);
}

// 不好：传统 for
for (size_t i = 0; i < items.size(); ++i) {
    process(items[i]);
}

// 好的：使用算法
bool found = std::any_of(vec.begin(), vec.end(),
                         [](int x) { return x > 10; });

// 不好：手写循环
bool found = false;
for (int x : vec) {
    if (x > 10) {
        found = true;
        break;
    }
}

// 好的：使用异常
void process() {
    if (error) {
        throw std::runtime_error("Error occurred");
    }
}

// 不好：使用错误码
int process() {
    if (error) {
        return -1;  // 错误码
    }
    return 0;
}

// 好的：捕获具体异常
try {
    process();
} catch (const std::runtime_error& e) {
    handle_error(e);
} catch (const std::exception& e) {
    handle_generic_error(e);
}

// 不好：捕获所有异常
try {
    process();
} catch (...) {
    // 不知道是什么错误
}

// 好的：使用 C++ 转换
int value = static_cast<int>(double_value);
Base* ptr = dynamic_cast<Derived*>(base_ptr);

// 不好：C 风格转换
int value = (int)double_value;
Base* ptr = (Derived*)base_ptr;

// 好的：避免 const_cast
void process(const Data& data) {
    // 不修改 data
}

// 不好：使用 const_cast
void process(const Data& data) {
    const_cast<Data&>(data).modify();  // 危险
}

// 好的：使用 Lambda
std::sort(vec.begin(), vec.end(),
          [](int a, int b) { return a > b; });

// 不好：函数对象
struct Compare {
    bool operator()(int a, int b) const {
        return a > b;
    }
};
std::sort(vec.begin(), vec.end(), Compare());

// 好的：只捕获需要的变量
int threshold = 10;
std::count_if(vec.begin(), vec.end(),
              [threshold](int x) { return x > threshold; });

// 不好：捕获所有
std::count_if(vec.begin(), vec.end(),
              [&](int x) { return x > threshold; });  // 捕获所有引用

// 好的：使用引用
void process(const std::vector<int>& vec);

// 不好：值传递
void process(std::vector<int> vec);  // 拷贝开销

// 好的：移动语义
std::vector<int> create_data() {
    std::vector<int> data;
    // ...
    return data;  // 移动
}

// 不好：拷贝
std::vector<int> data = create_data();  // 可能拷贝

// 原始代码：复杂表达式
if ((a > b && c < d) || (e == f && g != h) && (i > j)) {
    process();
}

// 改进代码：简单表达式
bool condition1 = (a > b) && (c < d);
bool condition2 = (e == f) && (g != h);
bool condition3 = (i > j);
bool is_valid = condition1 || (condition2 && condition3);
if (is_valid) {
    process();
}

// 原始代码：手写循环
for (size_t i = 0; i < vec.size(); ++i) {
    if (vec[i] > threshold) {
        result.push_back(vec[i]);
    }
}

// 改进代码：标准库算法
std::copy_if(vec.begin(), vec.end(), std::back_inserter(result),
             [threshold](int x) { return x > threshold; });

// 性能测试
void benchmark() {
    std::vector<int> vec(1000000);
    
    // 范围 for
    auto start = std::chrono::high_resolution_clock::now();
    for (const auto& x : vec) {
        process(x);
    }
    auto end = std::chrono::high_resolution_clock::now();
    
    // 标准库算法
    start = std::chrono::high_resolution_clock::now();
    std::for_each(vec.begin(), vec.end(), process);
    end = std::chrono::high_resolution_clock::now();
    // 通常性能相同，但算法更安全
}