c++ 编程小技巧

在 C++ 开发过程中，掌握一些实用的编程技巧能够显著提升代码质量和开发效率。本文总结了几个在实际项目中非常有用的 C++ 编程模式和最佳实践。

前向声明: 减少头文件依赖

将核心类的声明集中在一个头文件中，减少编译依赖：

cpp 复制代码

// forward.h
#pragma once

class Document;
class Element;

在其他文件中只需要包含前向声明头文件：

cpp 复制代码

// my_class.h
#include "forward.h"
#include <memory>

class MyClass {
    std::unique_ptr<Document> document;  // 只需要指针，前向声明足够
    Element* element;        
};

优势：

减少编译时间: 只包含类声明而非完整定义，避免引入大量依赖文件
解决循环依赖问题: 统一的声明中心让相互依赖的类不再需要直接包含对方的头文件

静态工厂方法: 处理可能失败的对象创建

构造函数无法返回错误信息，但可以使用静态工厂方法来处理可能失败的初始化：

cpp 复制代码

#include <memory>
#include <optional>
#include <fstream>

class FileProcessor {
public:
    // 静态工厂方法，可以返回失败信息
    static std::optional<FileProcessor> create(const std::string& filename) {
        std::ifstream file(filename);
        if (!file.is_open()) {
            return std::nullopt;  // 创建失败
        }
        
        // 私有构造函数，确保初始化成功
        return FileProcessor(std::move(file));
    }
    
    void process() {}

private:
    explicit FileProcessor(std::ifstream file) : file_(std::move(file)) {}
    
    std::ifstream file_;
};

// 使用方式
auto processor = FileProcessor::create("data.txt");
if (processor) {
    processor->process();
} else {
    // 处理创建失败的情况
    std::cerr << "Failed to create processor\n";
}

优势：

明确的错误处理
避免部分初始化的对象
构造成功即可用

作用域守卫: 确保某些逻辑离开作用域后执行

cpp 复制代码

#include <functional>

// 简单的作用域守卫实现
class ScopeGuard {
public:
    explicit ScopeGuard(std::function<void()> cleanup) 
        : cleanup_(std::move(cleanup)), active_(true) {}
    
    ~ScopeGuard() {
        if (active_) cleanup_();
    }
    
    void dismiss() { active_ = false; }  // 取消守卫
    
    ScopeGuard(const ScopeGuard&) = delete;
    ScopeGuard& operator=(const ScopeGuard&) = delete;

private:
    std::function<void()> cleanup_;
    bool active_;
};

void complex_operation() {
    FILE* file = fopen("temp.txt", "w");
    ScopeGuard file_guard([file] { if (file) fclose(file); });
    
    // 复杂操作...
    if (some_condition1()) {
        return;  // 自动关闭文件
    }

    if (some_condition2()) {
        rollback_guard.dismiss();  // 取消回滚
        return;
    }
    
    // 正常结束也会自动关闭文件
}

优势：

异常安全
自动资源管理
代码简洁

constexpr: 编译时计算

使用 constexpr 将计算从运行时移到编译时：

cpp 复制代码

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int pow2(int exp) {
    return 1 << exp;
}

void example() {
    constexpr int size = factorial(5);     // 编译时计算: 120
    constexpr int buffer_size = pow2(10);  // 编译时计算: 1024
    
    int array[size];           // 可用于数组大小
    char buffer[buffer_size];  // 性能零开销
}

优势：

零运行时开销：计算在编译时完成
可用于常量表达式：数组大小、模板参数等
更好的优化：编译器能做更多优化

模板特化: 处理特殊情况

为特定类型提供优化实现：

cpp 复制代码

// 通用模板
template<typename T>
void print(const T& value) {
    // 默认实现
    std::cout << value;
}

// 特化：bool 类型特殊处理
template<>
void print<bool>(const bool& value) {
    std::cout << (value ? "true" : "false");
}

// 特化：指针类型
template<typename T>
void print(T* ptr) {
    if (ptr) {
        print(*ptr);
    } else {
        std::cout << "null";
    }
}

void example() {
    print(42);        // 输出: 42
    print(true);      // 输出: true (不是 1)
    int x = 10;
    print(&x);        // 输出: 10
    print<int*>(nullptr); // 输出: null
}

优势：

类型特定优化：为不同类型提供最佳实现
保持统一接口：调用方式一致
编译时选择：无运行时开销