C++基础语法与面向对象编程核心概念详解

1. C++基础语法回顾与强化

C++作为一门经典的编程语言，其基础语法是每个开发者必须牢固掌握的基石。在实际开发中，我发现很多看似复杂的问题往往源于对基础概念的理解不够深入。让我们从最基础的语法元素开始，逐步构建完整的知识体系。

1.1 变量与数据类型

C++提供了丰富的数据类型系统，理解它们的特性和使用场景至关重要：

cpp复制// 基本数据类型示例
int age = 25;                   // 整型
double price = 99.99;           // 双精度浮点
char grade = 'A';               // 字符型
bool is_valid = true;           // 布尔型

// 派生类型示例
int numbers[5] = {1, 2, 3, 4, 5};  // 数组
int* ptr = &age;                   // 指针
std::string name = "John";         // 字符串对象

注意：在实际项目中，建议使用std::string而不是C风格的字符数组，它更安全且功能更强大。

变量声明时需要特别注意作用域规则：

• 局部变量：函数或代码块内部声明，生命周期限于所在块
• 全局变量：函数外部声明，整个程序可见
• 静态变量：使用static关键字，生命周期贯穿程序运行期

1.2 控制结构精要

控制结构是程序逻辑的骨架，合理使用可以使代码更清晰：

cpp复制// if-else条件判断
if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else {
    grade = 'C';
}

// switch-case多路分支
switch (month) {
    case 1: std::cout << "January"; break;
    case 2: std::cout << "February"; break;
    // ...其他月份
    default: std::cout << "Invalid month";
}

// 循环结构
for (int i = 0; i < 10; ++i) {  // 前向自增效率更高
    std::cout << i << " ";
}

while (condition) {
    // 循环体
}

do {
    // 至少执行一次
} while (condition);

1.3 函数定义与使用

函数是代码复用的基本单元，良好的函数设计能显著提升代码质量：

cpp复制// 函数声明
double calculateBMI(double weight, double height);

// 函数定义
double calculateBMI(double weight, double height) {
    if (height <= 0) {
        throw std::invalid_argument("Height must be positive");
    }
    return weight / (height * height);
}

// 函数调用
try {
    double bmi = calculateBMI(70.5, 1.75);
    std::cout << "BMI: " << bmi << std::endl;
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
}

函数参数传递方式：

• 值传递：创建副本，不影响原值
• 引用传递：操作原始变量，使用&声明
• 常量引用：避免拷贝大型对象，使用const &

2. 面向对象编程核心概念

C++的面向对象特性是其强大功能的基础，深入理解这些概念对编写高质量代码至关重要。

2.1 类与对象

类是面向对象编程的基本构建块，封装了数据和行为：

cpp复制class Rectangle {
private:    // 访问修饰符
    double width;
    double height;
    
public:
    // 构造函数
    Rectangle(double w, double h) : width(w), height(h) {}
    
    // 成员函数
    double area() const {  // const成员函数，不修改对象状态
        return width * height;
    }
    
    // setter和getter
    void setWidth(double w) { width = w; }
    double getWidth() const { return width; }
};

// 使用示例
Rectangle rect(10.0, 20.0);
std::cout << "Area: " << rect.area() << std::endl;

2.2 继承与多态

继承允许创建层次化的类关系，多态则提供了接口统一性：

cpp复制class Shape {  // 基类
public:
    virtual double area() const = 0;  // 纯虚函数，抽象类
    virtual ~Shape() {}               // 虚析构函数
};

class Circle : public Shape {  // 派生类
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {    // 重写虚函数
        return 3.14159 * radius * radius;
    }
};

// 多态使用
void printArea(const Shape& shape) {
    std::cout << "Area: " << shape.area() << std::endl;
}

Circle circle(5.0);
printArea(circle);  // 输出圆的面积

关键点：基类析构函数应该声明为virtual，确保通过基类指针删除派生类对象时能正确调用派生类的析构函数。

2.3 运算符重载

通过运算符重载可以使自定义类型使用更自然：

cpp复制class Vector {
    double x, y;
public:
    Vector(double x, double y) : x(x), y(y) {}
    
    // 重载+运算符
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
    
    // 重载输出运算符
    friend std::ostream& operator<<(std::ostream& os, const Vector& v) {
        os << "(" << v.x << ", " << v.y << ")";
        return os;
    }
};

// 使用示例
Vector v1(1.0, 2.0), v2(3.0, 4.0);
Vector v3 = v1 + v2;  // 使用重载的+运算符
std::cout << v3 << std::endl;  // 输出: (4, 6)

3. 内存管理与智能指针

C++给予开发者对内存的直接控制权，同时也带来了内存管理的责任。现代C++提供了智能指针来简化内存管理。

3.1 原始指针基础

理解指针是掌握C++内存管理的关键：

cpp复制int value = 42;
int* ptr = &value;  // ptr指向value的地址

std::cout << "Value: " << *ptr << std::endl;  // 解引用
*ptr = 100;  // 通过指针修改值

// 动态内存分配
int* arr = new int[10];  // 分配数组
// 使用数组...
delete[] arr;  // 释放内存

指针常见问题：

• 空指针解引用
• 野指针（指向已释放内存）
• 内存泄漏（忘记释放）
• 双重释放

3.2 智能指针实践

现代C++推荐使用智能指针自动管理内存：

cpp复制#include <memory>

// 独占所有权指针
std::unique_ptr<int> uptr(new int(10));
// auto uptr = std::make_unique<int>(10); // C++14后推荐方式

// 共享所有权指针
std::shared_ptr<int> sptr1 = std::make_shared<int>(20);
auto sptr2 = sptr1;  // 引用计数增加

// 弱引用指针
std::weak_ptr<int> wptr = sptr1;
if (auto temp = wptr.lock()) {  // 尝试提升为shared_ptr
    std::cout << *temp << std::endl;
}

智能指针使用场景：

• unique_ptr：资源独占，移动语义
• shared_ptr：共享所有权，引用计数
• weak_ptr：解决循环引用问题

3.3 移动语义与完美转发

C++11引入的移动语义显著提升了性能：

cpp复制class Buffer {
    int* data;
    size_t size;
public:
    // 移动构造函数
    Buffer(Buffer&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;  // 置空源对象
        other.size = 0;
    }
    
    // 移动赋值运算符
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data;  // 释放现有资源
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    
    ~Buffer() { delete[] data; }
};

// 使用示例
Buffer createBuffer() {
    Buffer buf(1024);  // 假设有普通构造函数
    return buf;  // 触发移动语义
}

Buffer newBuf = createBuffer();  // 高效，无额外拷贝

4. 标准库常用组件

C++标准库提供了丰富的工具，熟练掌握能极大提升开发效率。

4.1 容器与算法

STL容器和算法是日常开发中最常用的组件：

cpp复制#include <vector>
#include <algorithm>
#include <unordered_map>

// 向量容器
std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end());  // 排序

// 查找算法
auto it = std::find(nums.begin(), nums.end(), 4);
if (it != nums.end()) {
    std::cout << "Found at position: " << it - nums.begin() << std::endl;
}

// 哈希表
std::unordered_map<std::string, int> wordCount;
wordCount["hello"] = 1;
wordCount["world"] = 2;

// 范围for循环遍历
for (const auto& pair : wordCount) {
    std::cout << pair.first << ": " << pair.second << std::endl;
}

常用容器选择指南：

• vector：默认选择，动态数组
• list/forward_list：频繁插入删除
• deque：双端队列
• map/set：有序关联容器
• unordered_map/unordered_set：哈希实现，快速查找

4.2 字符串处理

std::string提供了丰富的字符串操作功能：

cpp复制std::string str = "Hello, C++ World!";

// 常用操作
size_t pos = str.find("C++");
if (pos != std::string::npos) {
    str.replace(pos, 3, "Modern C++");
}

// 字符串分割
std::vector<std::string> tokens;
size_t start = 0, end = 0;
while ((end = str.find(' ', start)) != std::string::npos) {
    tokens.push_back(str.substr(start, end - start));
    start = end + 1;
}
tokens.push_back(str.substr(start));

// 字符串流
std::stringstream ss("10 20 30");
int a, b, c;
ss >> a >> b >> c;

4.3 文件输入输出

文件操作是许多程序的基本需求：

cpp复制#include <fstream>
#include <sstream>

// 写入文件
std::ofstream outFile("data.txt");
if (outFile) {
    outFile << "Line 1\nLine 2\nLine 3";
    outFile.close();
}

// 读取文件
std::ifstream inFile("data.txt");
std::string line;
if (inFile) {
    while (std::getline(inFile, line)) {
        std::cout << line << std::endl;
    }
    inFile.close();
}

// 二进制文件操作
struct Record {
    int id;
    char name[20];
};

Record rec = {1, "Test"};
std::ofstream binFile("data.bin", std::ios::binary);
binFile.write(reinterpret_cast<char*>(&rec), sizeof(Record));
binFile.close();

5. 异常处理与调试技巧

健壮的程序需要妥善处理错误和异常情况。

5.1 异常处理机制

C++异常处理提供了一种结构化的错误处理方式：

cpp复制try {
    // 可能抛出异常的代码
    if (fileNotFound) {
        throw std::runtime_error("File not found");
    }
    
    // 使用资源
    processFile();
    
} catch (const std::runtime_error& e) {
    std::cerr << "Runtime error: " << e.what() << std::endl;
} catch (const std::exception& e) {
    std::cerr << "Standard exception: " << e.what() << std::endl;
} catch (...) {
    std::cerr << "Unknown exception occurred" << std::endl;
}

异常处理最佳实践：

• 按从具体到一般的顺序捕获异常
• 避免在析构函数中抛出异常
• 使用RAII管理资源，确保异常安全

5.2 断言与静态检查

断言是调试阶段的强大工具：

cpp复制#include <cassert>

void processArray(int* arr, size_t size) {
    assert(arr != nullptr && "Array pointer cannot be null");
    assert(size > 0 && "Array size must be positive");
    
    // 处理数组
}

// 静态断言（编译时检查）
static_assert(sizeof(int) == 4, "int must be 4 bytes");

5.3 调试技巧与工具

高效调试能显著提升开发效率：

1. 使用GDB调试器基础命令：

   • break：设置断点
   • run：启动程序
   • next：单步执行
   • print：查看变量值
   • backtrace：查看调用栈

2. 日志调试：

   cpp复制#define LOG(msg) std::cerr << __FILE__ << ":" << __LINE__ << " - " << msg << std::endl
   
   void criticalFunction() {
       LOG("Entering critical function");
       // ...
       if (error) {
           LOG("Error occurred: " << errorCode);
       }
   }
   

3. Valgrind内存检查：

   bash复制valgrind --leak-check=full ./your_program
   

6. 现代C++特性实践

C++11/14/17/20引入了许多改进特性，使代码更简洁高效。

6.1 自动类型推导

auto和decltype简化了类型声明：

cpp复制// auto基本用法
auto i = 42;          // int
auto d = 3.14;        // double
auto s = "hello";     // const char*

// 用于迭代器
std::vector<int> vec = {1, 2, 3};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}

// decltype获取表达式类型
decltype(vec.size()) count = vec.size();

6.2 Lambda表达式

Lambda提供了便捷的匿名函数功能：

cpp复制// 基本lambda
auto square = [](int x) { return x * x; };
std::cout << square(5) << std::endl;  // 25

// 捕获列表
int base = 10;
auto addBase = [base](int x) { return x + base; };

// 在算法中使用
std::vector<int> nums = {1, 2, 3, 4, 5};
std::for_each(nums.begin(), nums.end(), [](int n) {
    std::cout << n << " ";
});

6.3 并发编程基础

现代C++提供了标准线程支持：

cpp复制#include <thread>
#include <mutex>
#include <future>

std::mutex mtx;  // 互斥锁

void threadFunc(int id) {
    std::lock_guard<std::mutex> lock(mtx);  // RAII锁
    std::cout << "Thread " << id << " running\n";
}

// 创建线程
std::thread t1(threadFunc, 1);
std::thread t2(threadFunc, 2);
t1.join();
t2.join();

// 异步任务
auto future = std::async([]() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
});
std::cout << "Result: " << future.get() << std::endl;

7. 常见问题与解决方案

在实际开发中，会遇到各种典型问题，这里总结一些常见场景的解决方法。

7.1 编译错误排查

常见编译错误及解决方法：

1. undefined reference：

   • 确保所有声明都有对应的定义
   • 检查链接的库是否正确

2. 模板实例化错误：

   • 检查模板参数是否满足概念要求
   • 确保模板定义可见

3. 类型不匹配：

   • 使用static_cast等进行显式转换
   • 检查函数签名是否一致

7.2 运行时错误处理

常见运行时问题诊断：

1. 段错误(Segmentation fault)：

   • 使用GDB回溯调用栈
   • 检查指针是否有效
   • 使用智能指针替代原始指针

2. 内存泄漏：

   • Valgrind检测
   • 优先使用RAII对象管理资源

3. 死锁：

   • 按固定顺序获取锁
   • 使用std::lock同时获取多个锁
   • 限制锁的作用范围

7.3 性能优化技巧

提升C++程序性能的实用方法：

1. 避免不必要的拷贝：

   • 使用引用传递大型对象
   • 利用移动语义

2. 缓存友好设计：

   • 顺序访问数据
   • 优化数据结构布局

3. 并行化：

   • 使用多线程处理独立任务
   • 考虑并行算法

4. 编译器优化：

   • 使用-O2或-O3优化级别
   • 合理使用inline关键字

8. 编码规范与最佳实践

良好的编码习惯对长期项目维护至关重要。

8.1 命名约定

一致的命名风格提高代码可读性：

• 类名：PascalCase，如ClassName
• 函数名：camelCase，如memberFunction
• 变量名：snake_case，如local_variable
• 常量：UPPER_CASE，如MAX_SIZE
• 私有成员：后缀_，如data_

8.2 头文件组织

合理的头文件设计减少编译依赖：

cpp复制// example.h
#ifndef EXAMPLE_H  // 头文件保护
#define EXAMPLE_H

#include <string>  // 标准库头文件

// 前置声明
class OtherClass;

namespace example {  // 使用命名空间
    
class Example {
public:
    explicit Example(int value);  // 单参数构造函数用explicit
    
    void publicMethod();
    
private:
    void privateMethod_();
    
    int value_;
    std::string name_;
};

}  // namespace example

#endif  // EXAMPLE_H

8.3 代码注释规范

有效的注释应该解释"为什么"而不是"做什么"：

cpp复制/**
 * @brief 计算两个向量的点积
 * 
 * @param v1 第一个向量
 * @param v2 第二个向量
 * @return double 点积结果
 * 
 * @note 此函数假设两个向量维度相同，
 *       调用者需确保这一点
 */
double dotProduct(const Vector& v1, const Vector& v2);

// 避免无意义的注释
int count = 0;  // 将count设置为0  <- 不好的注释

9. 开发环境配置

高效的开发环境能提升工作效率，这里推荐一些常用配置。

9.1 编译器选择与使用

主流C++编译器比较：

1. GCC：

   • 开源跨平台
   • 命令行：g++ -std=c++17 -Wall -Wextra -o program source.cpp

2. Clang：

   • 优秀错误提示
   • 与LLVM工具链集成

3. MSVC：

   • Windows平台原生支持
   • Visual Studio集成

9.2 构建系统

现代C++项目构建工具：

1. CMake（推荐）：

   cmake复制cmake_minimum_required(VERSION 3.10)
   project(MyProject)
   
   set(CMAKE_CXX_STANDARD 17)
   
   add_executable(my_app main.cpp src/utils.cpp)
   target_include_directories(my_app PRIVATE include)
   

2. Makefile：

   makefile复制CXX = g++
   CXXFLAGS = -std=c++17 -Wall -Wextra
   
   my_app: main.o utils.o
       $(CXX) $(CXXFLAGS) -o $@ $^
   
   %.o: %.cpp
       $(CXX) $(CXXFLAGS) -c $<
   

9.3 IDE与编辑器

常用开发工具配置建议：

1. Visual Studio Code：

   • 安装C/C++扩展
   • 配置tasks.json和launch.json
   • 使用Clang-Format自动格式化

2. CLion：

   • 内置CMake支持
   • 强大的代码分析功能

3. Vim/Emacs：

   • 配置语法高亮
   • 集成LSP（Language Server Protocol）

10. 项目结构与代码组织

良好的项目结构使代码更易于维护和扩展。

10.1 典型项目布局

中等规模项目推荐结构：

code复制project/
├── CMakeLists.txt
├── include/
│   └── project/
│       ├── module1.h
│       └── module2.h
├── src/
│   ├── module1.cpp
│   ├── module2.cpp
│   └── main.cpp
├── tests/
│   ├── test_module1.cpp
│   └── test_module2.cpp
└── third_party/
    └── external_lib/

10.2 模块化设计

将功能分解为独立模块：

1. 按功能划分：

   • 网络模块
   • 数据处理模块
   • UI模块

2. 接口设计原则：

   • 最小化接口
   • 高内聚低耦合
   • 依赖倒置

10.3 单元测试集成

使用测试框架确保代码质量：

cpp复制// 使用Catch2测试框架示例
#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>

#include "calculator.h"

TEST_CASE("Calculator addition", "[calculator]") {
    Calculator calc;
    REQUIRE(calc.add(2, 3) == 5);
    REQUIRE(calc.add(-1, 1) == 0);
}

TEST_CASE("Calculator division", "[calculator]") {
    Calculator calc;
    REQUIRE(calc.divide(10, 2) == Approx(5.0));
    REQUIRE_THROWS_AS(calc.divide(1, 0), std::invalid_argument);
}

测试驱动开发(TDD)流程：

1. 编写失败的测试
2. 实现最小功能使测试通过
3. 重构代码，保持测试通过

11. 性能分析与优化

系统化的性能优化方法能有效提升程序效率。

11.1 性能分析工具

常用性能分析工具：

1. gprof：

   bash复制g++ -pg -o program source.cpp
   ./program
   gprof program gmon.out > analysis.txt
   

2. perf（Linux）：

   bash复制perf record ./program
   perf report
   

3. VTune（Intel）：

   • 图形化界面
   • 详细硬件事件分析

11.2 热点识别与优化

典型性能瓶颈及优化策略：

1. CPU密集型：

   • 算法优化（降低复杂度）
   • 循环展开
   • SIMD指令

2. 内存密集型：

   • 改善局部性
   • 预取数据
   • 优化数据结构

3. I/O密集型：

   • 异步I/O
   • 批量处理
   • 缓存策略

11.3 并行计算模式

利用多核CPU的并行技术：

1. 多线程：

   cpp复制std::vector<std::thread> threads;
   for (int i = 0; i < 4; ++i) {
       threads.emplace_back([i] {
           processChunk(i);
       });
   }
   for (auto& t : threads) {
       t.join();
   }
   

2. 并行算法（C++17）：

   cpp复制#include <execution>
   
   std::vector<int> data(1000000);
   std::sort(std::execution::par, data.begin(), data.end());
   

3. OpenMP：

   cpp复制#pragma omp parallel for
   for (int i = 0; i < N; ++i) {
       process(i);
   }
   

12. 跨平台开发考虑

现代C++项目常需支持多平台，需要注意兼容性问题。

12.1 平台相关代码处理

条件编译处理平台差异：

cpp复制#if defined(_WIN32)
    // Windows特定代码
    #include <windows.h>
#elif defined(__linux__)
    // Linux特定代码
    #include <unistd.h>
#elif defined(__APPLE__)
    // macOS特定代码
    #include <mach/mach.h>
#endif

// 平台无关代码
void sleepFor(int seconds) {
    #if defined(_WIN32)
        Sleep(seconds * 1000);
    #else
        sleep(seconds);
    #endif
}

12.2 字节序与对齐

处理二进制数据时的注意事项：

cpp复制#include <cstdint>

// 网络字节序转换
uint32_t ntohl(uint32_t netlong);  // 网络字节序转主机字节序
uint32_t htonl(uint32_t hostlong);  // 主机字节序转网络字节序

// 内存对齐控制
struct alignas(16) AlignedStruct {
    int a;
    double b;
    char c;
};

static_assert(alignof(AlignedStruct) == 16, "Alignment error");

12.3 第三方库管理

跨平台库集成策略：

1. 包管理器：

   • vcpkg
   • Conan
   • Hunter

2. 源码集成：

   • 添加为子模块
   • CMake ExternalProject

3. 动态链接：

   • 分发动态库
   • 运行时加载

13. 安全编程实践

安全是高质量软件的重要属性，C++需要特别注意以下方面。

13.1 常见漏洞防范

C++典型安全问题及防护：

1. 缓冲区溢出：

   • 使用std::vector/std::array替代原始数组
   • 边界检查

2. 整数溢出：

   cpp复制int a = INT_MAX;
   int b = a + 1;  // 未定义行为
   // 安全方式
   if (a > INT_MAX - b) {
       throw std::overflow_error("Integer overflow");
   }
   

3. 格式化字符串漏洞：

   • 避免用户控制的格式字符串
   • 使用std::format(C++20)

13.2 资源管理安全

确保资源正确释放：

1. 文件操作：

   cpp复制{  // 限制作用域
       std::ofstream file("data.txt");
       if (!file) {
           throw std::runtime_error("Failed to open file");
       }
       file << "Data";
   }  // 自动关闭
   

2. 锁管理：

   cpp复制std::mutex mtx;
   {
       std::lock_guard<std::mutex> lock(mtx);
       // 临界区
   }  // 自动释放
   

13.3 密码学基础

基本加密操作示例：

cpp复制#include <openssl/sha.h>

std::string sha256(const std::string& str) {
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, str.c_str(), str.size());
    SHA256_Final(hash, &sha256);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; ++i) {
        ss << std::hex << std::setw(2) << std::setfill('0') 
           << static_cast<int>(hash[i]);
    }
    return ss.str();
}

警告：密码学实现容易出错，生产环境应使用经过严格验证的库。

14. 设计模式应用

经典设计模式解决常见设计问题。

14.1 创建型模式

对象创建的最佳实践：

1. 工厂方法：

   cpp复制class Product {
   public:
       virtual ~Product() = default;
       virtual void operation() = 0;
   };
   
   class ConcreteProduct : public Product {
   public:
       void operation() override { /*...*/ }
   };
   
   class Creator {
   public:
       virtual std::unique_ptr<Product> create() = 0;
   };
   
   class ConcreteCreator : public Creator {
   public:
       std::unique_ptr<Product> create() override {
           return std::make_unique<ConcreteProduct>();
       }
   };
   

2. 单例模式（谨慎使用）：

   cpp复制class Singleton {
   private:
       Singleton() = default;
       
   public:
       Singleton(const Singleton&) = delete;
       Singleton& operator=(const Singleton&) = delete;
       
       static Singleton& instance() {
           static Singleton instance;
           return instance;
       }
   };
   

14.2 结构型模式

类和对象组合的方式：

1. 适配器模式：

   cpp复制class LegacyComponent {
   public:
       void oldOperation() { /*...*/ }
   };
   
   class TargetInterface {
   public:
       virtual void operation() = 0;
   };
   
   class Adapter : public TargetInterface {
       LegacyComponent legacy;
   public:
       void operation() override {
           legacy.oldOperation();
       }
   };
   

2. 装饰器模式：

   cpp复制class Component {
   public:
       virtual void execute() = 0;
   };
   
   class ConcreteComponent : public Component {
   public:
       void execute() override { /*...*/ }
   };
   
   class Decorator : public Component {
       std::unique_ptr<Component> component;
   public:
       Decorator(std::unique_ptr<Component> c) : component(std::move(c)) {}
       
       void execute() override {
           component->execute();
       }
   };
   
   class ConcreteDecorator : public Decorator {
   public:
       using Decorator::Decorator;
       
       void execute() override {
           preOperation();
           Decorator::execute();
           postOperation();
       }
   };
   

14.3 行为型模式

对象间的交互与职责分配：

1. 策略模式：

   cpp复制class Strategy {
   public:
       virtual void execute() = 0;
   };
   
   class Context {
       std::unique_ptr<Strategy> strategy;
   public:
       void setStrategy(std::unique_ptr<Strategy> s) {
           strategy = std::move(s);
       }
       
       void executeStrategy() {
           if (strategy) {
               strategy->execute();
           }
       }
   };
   

2. 观察者模式：

   cpp复制class Observer {
   public:
       virtual void update(int data) = 0;
   };
   
   class Subject {
       std::vector<Observer*> observers;
   public:
       void attach(Observer* o) {
           observers.push_back(o);
       }
       
       void notify(int data) {
           for (auto o : observers) {
               o->update(data);
           }
       }
   };
   

15. 模板元编程入门

C++模板的强大功能支持编译期计算。

15.1 基础模板

函数模板和类模板：

cpp复制// 函数模板
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 类模板
template <typename T, size_t N>
class Array {
    T data[N];
public:
    T& operator[](size_t i) { return data[i]; }
    constexpr size_t size() const { return N; }
};

// 使用
Array<int, 10> arr;

15.2 模板特化

为特定类型提供定制实现：

cpp复制template <typename T>
class TypeInfo {
public:
    static const char* name() { return "unknown"; }
};

template <>
class TypeInfo<int> {
public:
    static const char* name() { return "int"; }
};

template <>
class TypeInfo<std::string> {
public:
    static const char* name() { return "string"; }
};

15.3 可变参数模板

处理任意数量类型参数：

cpp复制template <typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl;  // C++17折叠表达式
}

// 使用
printAll(1, " ", 2.0, " ", 'a');

16. 嵌入式C++特性

嵌入式开发中的C++特殊考虑。

16.1 资源受限环境

优化内存和性能的策略：

1. 禁用RTTI和异常：

   cmake复制add_compile_options(-fno-rtti -fno-exceptions)
   

2. 静态分配内存：

   cpp复制class PoolAllocator {
       static constexpr size_t POOL_SIZE = 1024;
       static std::array<uint8_t, POOL_SIZE> memoryPool;
       // 管理逻辑...
   };
   

3. 自定义new/delete：

   cpp复制void* operator new(size_t size) {
       void* p = customAllocate(size);
       if (!p) throw std::bad_alloc();
       return p;
   }
   
   void operator delete(void* p) {
       customDeallocate(p);
   }
   

16.2 硬件访问

寄存器操作模式：

cpp复制class GPIO {
    volatile uint32_t* const reg;
public:
    explicit GPIO(uintptr_t addr) : reg(reinterpret_cast<uint32_t*>(addr)) {}
    
    void set() { *reg |= 0x01; }
    void clear() { *reg &= ~0x01; }
    bool read() const { return *reg & 0x01; }
};

// 使用
GPIO led(0x40021000);
led.set();

16.3 实时性保证

满足实时要求的技术：

1. 避免动态内存分配
2. 限制递归深度
3. 使用constexpr计算
4. 控制中断延迟

17. 调试与性能分析实战

通过实际案例演示调试和优化过程。

17.1 内存泄漏调试

使用Valgrind检测内存问题：

bash复制valgrind --leak-check=full --show-leak-kinds=all ./program

典型输出分析：

code复制==12345== 40 bytes in 1 blocks are definitely lost in loss record 1 of 2
==12345==    at 0x483BE63: operator new(unsigned long) (vg_replace_malloc.c:342)
==12345==    by 0x1091FE