【Linux C/C++开发】第15章：现代C++最佳实践 - 从理论到实战

最新推荐文章于 2025-11-22 23:05:15 发布

原创最新推荐文章于 2025-11-22 23:05:15 发布 · 767 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#linux #c语言 #c++ #编程范式

Linux C/C++开发专栏收录该内容

29 篇文章

订阅专栏

第15章：现代C++最佳实践 - 从理论到实战

15.1 现代C++编程范式 - 选择合适的工具

15.1.1 泛型编程 - 编写通用代码的艺术

泛型编程就像瑞士军刀：一把刀可以适应不同的使用场景，泛型编程让我们写出能适应不同类型的通用代码。

现实生活中的例子：

排序算法：不管是对数字、名字还是日期排序，算法都是一样的
容器类：vector可以存储int、string或者自定义对象
数学运算：加法可以对整数、小数、复数都适用

// 传统的重复代码 - 每个类型都要写一遍
int add_int(int a, int b) { return a + b; }
double add_double(double a, double b) { return a + b; }
std::string add_string(const std::string& a, const std::string& b) { return a + b; }

// 泛型编程 - 一个函数搞定所有类型
template<typename T>
T add(const T& a, const T& b) {
    return a + b;
}

15.1.2 函数式编程 - 像数学函数一样思考

函数式编程就像乐高积木：每个积木块都是独立的，可以组合成复杂的结构，但不会改变积木本身。

核心思想：

纯函数：同样的输入总是得到同样的输出，没有副作用
函数组合：把小函数组合成大函数
不可变性：数据一旦创建就不能修改

// 函数组合 - 就像流水线作业
auto add_ten = [](int x) { return x + 10; };
auto multiply_by_two = [](int x) { return x * 2; };

// 组合两个函数
auto add_ten_then_multiply_by_two = [=](int x) {
    return multiply_by_two(add_ten(x));
};

15.2 并发编程实战 - 让程序同时做多件事

15.2.1 并发基础 - 多线程就像多窗口服务

生活中的并发例子：

银行柜台：多个窗口同时办理业务
餐厅服务：服务员点菜、厨师做菜、收银员结账同时进行

#include <thread>
#include <mutex>

// 线程安全的计数器 - 就像银行的叫号系统
class ThreadSafeCounter {
private:
    int count;
    std::mutex mtx;  // 互斥锁，确保一次只有一个人能修改
    
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);  // 自动加锁解锁
        ++count;
        std::cout << "计数增加到: " << count << std::endl;
    }
};

15.2.2 线程同步 - 避免混乱的协调机制

线程同步就像交通信号灯：确保车辆（线程）有序通行，避免碰撞。

#include <shared_mutex>

// 线程安全的数据缓存 - 就像图书馆的图书目录
class ThreadSafeLibraryCatalog {
private:
    mutable std::shared_mutex rw_mutex;  // 读写锁
    std::unordered_map<std::string, std::string> books;
    
public:
    // 查询书籍 - 多个读者可以同时查询
    std::optional<std::string> getBook(const std::string& title) const {
        std::shared_lock<std::shared_mutex> lock(rw_mutex);  // 共享读锁
        // ...
    }
    
    // 添加新书 - 需要独占访问
    void addBook(const std::string& title, const std::string& content) {
        std::unique_lock<std::shared_mutex> lock(rw_mutex);  // 独占写锁
        // ...
    }
};

15.3 性能优化实战 - 让程序跑得更快

15.3.1 内存优化 - 聪明地使用内存

内存优化就像整理房间：合理摆放物品，既节省空间又方便取用。

内存布局优化：

// 差的内存布局 - 有很多空隙（填充）
struct BadLayout {
    bool flag;        // 1字节 + 7字节空隙
    double value;     // 8字节
    char ch;          // 1字节 + 7字节空隙
};  // 总大小：24字节

// 好的内存布局 - 紧凑排列
struct GoodLayout {
    double value;     // 8字节
    bool flag;        // 1字节
    char ch;          // 1字节 + 6字节空隙（最少空隙）
};  // 总大小：16字节

15.3.2 算法优化 - 选择更好的方法

算法优化就像选择路线：从北京到上海，可以走路、骑车、坐火车、坐飞机，选择合适的方式很重要。

算法复杂度对比：

// O(n²)算法 - 慢速方法
std::vector<int> findDuplicatesSlow(const std::vector<int>& data) {
    std::vector<int> duplicates;
    for (size_t i = 0; i < data.size(); ++i) {
        for (size_t j = i + 1; j < data.size(); ++j) {
            if (data[i] == data[j]) {
                // ...
            }
        }
    }
    return duplicates;
}

// O(n)算法 - 快速方法
std::vector<int> findDuplicatesFast(const std::vector<int>& data) {
    std::unordered_set<int> seen;      // 已经见过的数字
    std::unordered_set<int> duplicates;  // 重复的数字
    
    for (int value : data) {
        if (seen.count(value)) {  // 如果已经见过，就是重复
            duplicates.insert(value);
        } else {
            seen.insert(value);   // 第一次见，记下来
        }
    }
    
    return std::vector<int>(duplicates.begin(), duplicates.end());
}

15.4 现代C++最佳实践 - 写出更好的代码

15.4.1 智能指针的最佳实践

智能指针就像自动驾驶：帮你管理内存，但你得知道什么时候用什么模式。

所有权语义：

// unique_ptr - 独占所有权，就像你的私人汽车
class Document {
private:
    std::unique_ptr<Content> content_;  // 文档内容，只能有一个拥有者
    
public:
    void setContent(std::unique_ptr<Content> content) {
        content_ = std::move(content);  // 转移所有权
    }
};

// shared_ptr - 共享所有权，就像共享单车
class SharedResource {
private:
    std::shared_ptr<Cache> cache_;  // 多个对象可以共享同一个缓存
};

// weak_ptr - 弱引用，就像观察别人的车，你知道它存在但不拥有
class Observer {
private:
    std::weak_ptr<Subject> subject_;  // 观察目标，但不拥有它
};

15.4.2 异常安全保证

异常安全就像银行的保险系统：即使出问题了，也要确保损失最小。

三个安全级别：

基本保证：出问题时程序不会崩溃，资源不会泄漏
强保证：出问题时程序状态完全不变，就像什么都没发生
无异常保证：承诺操作绝对不会出错

// 强异常安全的实现 - copy-and-swap模式
class SafeBankAccount {
public:
    // 强异常安全的转账操作
    void transferTo(SafeBankAccount& other, double amount) {
        if (amount <= 0) {
            throw std::invalid_argument("转账金额必须为正数");
        }
        
        // 使用临时副本确保强异常安全
        auto temp_this = *this;      // 创建当前账户的副本
        auto temp_other = other;     // 创建目标账户的副本
        
        temp_this.balance -= amount;  // 修改副本
        temp_other.balance += amount;
        
        // 如果上面所有操作都成功了，才应用修改
        *this = std::move(temp_this);
        other = std::move(temp_other);
    }
};

15.4.3 接口设计原则

好的接口就像好的工具设计：易于正确使用，难以错误使用。

// 好的接口设计 - 易于正确使用
class Date {
public:
    // 构造函数验证参数的有效性
    Date(int year, int month, int day) 
        : year_(year), month_(month), day_(day) {
        if (!isValid(year, month, day)) {
            throw std::invalid_argument("无效的日期");
        }
    }
    
    // 工厂函数提供清晰的语义
    static Date today() {
        auto now = std::chrono::system_clock::now();
        auto time_t = std::chrono::system_clock::to_time_t(now);
        auto tm = *std::localtime(&time_t);
        return Date(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
    }
    
    static Date fromString(const std::string& str) {
        std::istringstream iss(str);
        int year, month, day;
        char sep1, sep2;
        
        // 验证格式：YYYY-MM-DD
        if (iss >> year >> sep1 >> month >> sep2 >> day && 
            sep1 == '-' && sep2 == '-' && iss.eof()) {
            return Date(year, month, day);
        }
        
        throw std::invalid_argument("日期格式必须是 YYYY-MM-DD");
    }
    
    // 提供清晰的getter，不提供setter（不可变性）
    int year() const { return year_; }
    int month() const { return month_; }
    int day() const { return day_; }
    
private:
    int year_, month_, day_;
    
    static bool isValid(int year, int month, int day) {
        // 验证日期的有效性
        if (year < 1900 || month < 1 || month > 12 || day < 1) {
            return false;
        }
        // ... 更多验证逻辑
        return true;
    }
};