现代C++核心特性与高性能编程实践

1. C++语言的核心定位与演进历程

C++作为一门诞生于1983年的编程语言，至今仍在系统编程、游戏开发、高频交易等对性能要求严苛的领域占据主导地位。与其它现代语言相比，C++最显著的特点是它同时支持底层内存操作和高级抽象机制。这种"既要又要"的设计哲学，使得开发者既能像C语言那样直接操作硬件资源，又能使用面向对象、泛型编程等现代化范式。

Bjarne Stroustrup最初设计C++时，将其命名为"C with Classes"，目标是在C语言的基础上增加类机制。经过数十年的发展，C++标准经历了C++98、C++11、C++14、C++17到最新的C++20五次重大更新。特别是C++11标准的发布，引入了自动类型推导、lambda表达式、右值引用等革命性特性，使得现代C++的编程风格与早期版本有了显著区别。

提示：现代C++项目应至少采用C++11标准，新项目建议直接使用C++17或C++20以获得最佳开发体验。

2. 现代C++的核心特性解析

2.1 自动类型推导与decltype

自动类型推导(auto)是C++11引入的重要特性，它允许编译器根据初始化表达式自动推断变量类型。这不仅减少了代码冗余，还使得模板编程更加简洁：

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

与之配套的decltype可以获取表达式的类型，在模板元编程中尤为有用：

cpp复制std::vector<int> vec;
decltype(vec)::value_type x;  // x的类型是int

2.2 智能指针与资源管理

现代C++用智能指针替代了容易导致内存泄漏的裸指针。三种主要智能指针各有适用场景：

典型用法示例：

cpp复制// 独占资源
auto ptr = std::make_unique<MyClass>(); 

// 共享资源
auto shared = std::make_shared<MyClass>();
auto copy = shared;  // 引用计数+1

// 观察但不拥有
std::weak_ptr<MyClass> observer = shared;

2.3 移动语义与完美转发

C++11引入的移动语义解决了不必要的拷贝问题。通过右值引用(&&)和std::move，可以实现资源的高效转移：

cpp复制class Buffer {
public:
    Buffer(Buffer&& other) noexcept 
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // 转移所有权
    }
    
private:
    char* data_;
    size_t size_;
};

完美转发(forward)则保留了参数的原始类型信息，在模板编程中非常有用：

cpp复制template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

3. 现代C++开发实践

3.1 构建系统与工具链选择

现代C++项目通常采用CMake作为构建系统，它支持跨平台开发并与现代工具链良好集成。一个典型的CMakeLists.txt配置如下：

cmake复制cmake_minimum_required(VERSION 3.15)
project(ModernCpp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(main_app 
    src/main.cpp
    src/utility.cpp
)

target_include_directories(main_app PRIVATE include)

配套工具链建议：

• 编译器：GCC ≥10 / Clang ≥12 / MSVC ≥2019
• 静态分析：clang-tidy
• 格式化：clang-format
• 包管理：vcpkg/conan

3.2 异常安全与RAII原则

资源获取即初始化(RAII)是C++资源管理的核心理念。通过构造函数获取资源，析构函数释放资源，可以确保异常安全：

cpp复制class FileHandle {
public:
    explicit FileHandle(const std::string& path) 
        : handle_(fopen(path.c_str(), "r")) {
        if (!handle_) throw std::runtime_error("Open failed");
    }
    
    ~FileHandle() { if (handle_) fclose(handle_); }
    
    // 禁用拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 允许移动
    FileHandle(FileHandle&& other) noexcept 
        : handle_(other.handle_) {
        other.handle_ = nullptr;
    }
    
private:
    FILE* handle_;
};

3.3 并发编程模型

现代C++提供了丰富的并发编程支持：

1. 线程管理：

cpp复制std::vector<std::thread> workers;
for (int i = 0; i < 4; ++i) {
    workers.emplace_back([]{
        std::cout << "Running in thread " 
                 << std::this_thread::get_id() << "\n";
    });
}
for (auto& t : workers) t.join();

2. 原子操作：

cpp复制std::atomic<int> counter{0};
counter.fetch_add(1, std::memory_order_relaxed);

3. 异步任务：

cpp复制auto future = std::async(std::launch::async, []{
    std::this_thread::sleep_for(1s);
    return 42;
});
int result = future.get();

4. 性能优化关键技巧

4.1 内存布局优化

缓存友好的内存布局能显著提升性能。对比两种数据结构设计：

cpp复制// 低效版本：指针间接访问，缓存不友好
struct Node {
    Data* data;
    Node* next;
};

// 高效版本：连续内存，缓存友好
struct ContiguousNodes {
    std::vector<Data> data;
    std::vector<size_t> next_indices;
};

4.2 编译器优化选项

合理使用编译器优化标志可以提升20-300%性能：

注意：高优化级别可能增加编译时间并影响调试，开发阶段建议使用-Og优化。

4.3 内联与热点分析

使用__attribute__((always_inline))或[[gnu::always_inline]]强制内联关键函数：

cpp复制[[gnu::always_inline]] inline int fast_add(int a, int b) {
    return a + b;
}

通过perf工具分析热点函数：

bash复制perf record ./your_program
perf report

5. 现代C++工程实践

5.1 单元测试框架

Google Test是现代C++项目的首选测试框架。典型测试用例：

cpp复制TEST(StringTest, Compare) {
    std::string s1 = "hello";
    std::string s2 = "world";
    EXPECT_NE(s1, s2);
    EXPECT_EQ(s1.length(), 5);
}

TEST(AlgorithmTest, Sort) {
    std::vector<int> v{3,1,4,2};
    std::sort(v.begin(), v.end());
    ASSERT_EQ(v, std::vector<int>{1,2,3,4});
}

5.2 持续集成配置

示例GitLab CI配置(.gitlab-ci.yml)：

yaml复制stages:
  - build
  - test

build:
  stage: build
  script:
    - mkdir build
    - cd build
    - cmake ..
    - cmake --build . --config Release

test:
  stage: test
  script:
    - cd build
    - ctest --output-on-failure

5.3 代码质量保障

1. 静态分析：

bash复制clang-tidy --checks='*' --warnings-as-errors='*' src/*.cpp

2. 格式化检查：

bash复制clang-format -i --style=file src/*.cpp include/*.h

3. 动态分析：

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

6. 跨平台开发注意事项

6.1 平台特定代码处理

使用预定义宏隔离平台相关代码：

cpp复制#if defined(_WIN32)
    // Windows特定实现
    #include <windows.h>
#elif defined(__linux__)
    // Linux特定实现
    #include <unistd.h>
#endif

6.2 字节序处理

网络编程中需要注意字节序转换：

cpp复制inline uint32_t htonl(uint32_t hostlong) {
#if __BYTE_ORDER == __LITTLE_ENDIAN
    return __builtin_bswap32(hostlong);
#else
    return hostlong;
#endif
}

6.3 文件系统操作

使用C++17的<filesystem>跨平台操作文件：

cpp复制namespace fs = std::filesystem;
fs::path p = "/var/log";
if (fs::exists(p)) {
    for (auto& entry : fs::directory_iterator(p)) {
        std::cout << entry.path() << "\n";
    }
}

7. 模板元编程进阶技巧

7.1 SFINAE与概念(Concepts)

C++20之前使用SFINAE进行模板约束：

cpp复制template<typename T>
auto foo(T t) -> decltype(t.serialize(), void()) {
    // 只有T有serialize()方法才会实例化
}

C++20引入更简洁的概念(Concepts)：

cpp复制template<typename T>
concept Serializable = requires(T t) {
    { t.serialize() } -> std::convertible_to<std::string>;
};

template<Serializable T>
void bar(T t) {
    // 编译时确保T满足Serializable概念
}

7.2 编译时字符串处理

利用constexpr实现编译时字符串操作：

cpp复制constexpr size_t strlen_ct(const char* str) {
    size_t len = 0;
    while (str[len] != '\0') ++len;
    return len;
}

static_assert(strlen_ct("hello") == 5);

7.3 模板特化与变参模板

模板特化允许为特定类型提供特殊实现：

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

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

变参模板实现类型安全的printf：

cpp复制void safe_printf(const char* fmt) {
    std::cout << fmt;
}

template<typename T, typename... Args>
void safe_printf(const char* fmt, T value, Args... args) {
    for (; *fmt != '\0'; ++fmt) {
        if (*fmt == '%') {
            std::cout << value;
            safe_printf(fmt + 1, args...);
            return;
        }
        std::cout << *fmt;
    }
}

8. 嵌入式与高性能场景优化

8.1 寄存器变量与volatile

嵌入式开发中常用技巧：

cpp复制register int counter asm("r12");  // 建议编译器使用特定寄存器
volatile uint32_t* const reg = reinterpret_cast<uint32_t*>(0x40021000);

8.2 内存对齐控制

确保数据结构正确对齐：

cpp复制struct alignas(64) CacheLine {
    char data[64];
};

static_assert(alignof(CacheLine) == 64);

8.3 内联汇编集成

特定平台性能关键代码：

cpp复制uint64_t rdtsc() {
    uint32_t lo, hi;
    asm volatile (
        "rdtsc" : "=a"(lo), "=d"(hi)
    );
    return (static_cast<uint64_t>(hi) << 32) | lo;
}

9. 现代C++设计模式

9.1 策略模式与std::function

运行时多态替代方案：

cpp复制class Processor {
public:
    using Strategy = std::function<void(const std::string&)>;
    
    void set_strategy(Strategy s) { strategy_ = std::move(s); }
    void process(const std::string& data) { strategy_(data); }
    
private:
    Strategy strategy_;
};

9.2 观察者模式实现

基于标准库的观察者模式：

cpp复制template<typename... Args>
class Event {
public:
    using Callback = std::function<void(Args...)>;
    
    void subscribe(Callback cb) {
        callbacks_.push_back(std::move(cb));
    }
    
    void notify(Args... args) {
        for (auto& cb : callbacks_) {
            cb(args...);
        }
    }
    
private:
    std::vector<Callback> callbacks_;
};

9.3 类型擦除技术

std::any和std::variant的替代实现：

cpp复制class Any {
public:
    template<typename T>
    Any(T value) : 
        data_(new Model<T>(std::move(value))),
        getter_([](void* data) -> void* {
            return static_cast<T*>(data);
        }) {}
        
    template<typename T>
    T* get() {
        return static_cast<T*>(getter_(data_.get()));
    }
    
private:
    struct Concept {
        virtual ~Concept() = default;
    };
    
    template<typename T>
    struct Model : Concept {
        Model(T value) : data(std::move(value)) {}
        T data;
    };
    
    std::unique_ptr<Concept> data_;
    void* (*getter_)(void*);
};

10. C++20/23新特性前瞻

10.1 协程支持

C++20引入的协程框架：

cpp复制#include <coroutine>

struct Generator {
    struct promise_type {
        int current_value;
        
        Generator get_return_object() {
            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { std::terminate(); }
        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
    };
    
    std::coroutine_handle<promise_type> handle;
    
    explicit Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Generator() { if (handle) handle.destroy(); }
    
    int next() {
        handle.resume();
        return handle.promise().current_value;
    }
};

Generator range(int from, int to) {
    for (int i = from; i < to; ++i) {
        co_yield i;
    }
}

10.2 模块化编程

C++20模块示例：

cpp复制// math.ixx
export module math;

export namespace math {
    int add(int a, int b) {
        return a + b;
    }
}

// main.cpp
import math;

int main() {
    return math::add(1, 2);
}

10.3 范围(Ranges)库

简化容器操作的现代方式：

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

void process_data() {
    std::vector<int> data{1,2,3,4,5,6,7,8,9};
    
    auto even = data | std::views::filter([](int x) { return x % 2 == 0; })
                   | std::views::transform([](int x) { return x * 2; });
    
    for (int x : even) {
        std::cout << x << " ";  // 输出: 4 8 12 16
    }
}

11. 性能关键系统设计模式

11.1 对象池模式

减少动态内存分配开销：

cpp复制template<typename T>
class ObjectPool {
public:
    template<typename... Args>
    std::unique_ptr<T, std::function<void(T*)>> acquire(Args&&... args) {
        if (pool_.empty()) {
            pool_.push_back(new T(std::forward<Args>(args)...));
        }
        
        auto obj = pool_.back();
        pool_.pop_back();
        
        return {
            obj,
            [this](T* p) { release(p); }
        };
    }
    
private:
    void release(T* obj) {
        pool_.push_back(obj);
    }
    
    std::vector<T*> pool_;
};

11.2 数据导向设计

面向缓存优化的设计范式：

cpp复制struct EntityDatabase {
    std::vector<int> health;
    std::vector<float> position_x;
    std::vector<float> position_y;
    
    void update_positions(float delta) {
        for (size_t i = 0; i < position_x.size(); ++i) {
            position_x[i] += delta;
            position_y[i] += delta;
        }
    }
};

11.3 无锁数据结构

原子操作实现的无锁队列：

cpp复制template<typename T>
class LockFreeQueue {
public:
    void push(T value) {
        auto node = new Node(std::move(value));
        Node* old_tail = tail_.load();
        
        while (!tail_.compare_exchange_weak(old_tail, node)) {}
        
        old_tail->next.store(node);
    }
    
    bool pop(T& value) {
        Node* old_head = head_.load();
        Node* new_head;
        
        do {
            new_head = old_head->next.load();
            if (!new_head) return false;
        } while (!head_.compare_exchange_weak(old_head, new_head));
        
        value = std::move(new_head->value);
        delete old_head;
        return true;
    }
    
private:
    struct Node {
        explicit Node(T val) : value(std::move(val)) {}
        T value;
        std::atomic<Node*> next{nullptr};
    };
    
    std::atomic<Node*> head_{new Node(T{})};
    std::atomic<Node*> tail_{head_.load()};
};

12. 调试与性能分析技巧

12.1 自定义内存分配追踪

重载new/delete跟踪内存分配：

cpp复制namespace {
    std::atomic<size_t> allocated{0};
}

void* operator new(size_t size) {
    allocated += size;
    return malloc(size);
}

void operator delete(void* p) noexcept {
    free(p);
}

void print_memory_stats() {
    std::cout << "Total allocated: " << allocated << " bytes\n";
}

12.2 条件断点设置

GDB/LLDB中的条件断点：

bash复制# 设置当i==42时触发的断点
break foo.cpp:15 if i == 42

# 设置当指针p非空时触发的断点
break bar.cpp:30 if p != nullptr

12.3 性能剖析技巧

使用Google Benchmark进行微基准测试：

cpp复制#include <benchmark/benchmark.h>

static void BM_StringCopy(benchmark::State& state) {
    std::string x = "hello";
    for (auto _ : state) {
        std::string copy(x);
        benchmark::DoNotOptimize(copy);
    }
}
BENCHMARK(BM_StringCopy);

BENCHMARK_MAIN();

13. 跨语言交互实践

13.1 C接口设计原则

导出稳定的C接口：

cpp复制// mylib.h
#ifdef __cplusplus
extern "C" {
#endif

typedef void* MyHandle;

MyHandle create_instance();
void destroy_instance(MyHandle h);
int process_data(MyHandle h, const char* input, char* output, size_t out_len);

#ifdef __cplusplus
}
#endif

13.2 Python扩展开发

使用pybind11创建Python扩展：

cpp复制#include <pybind11/pybind11.h>

namespace py = pybind11;

int add(int a, int b) {
    return a + b;
}

PYBIND11_MODULE(example, m) {
    m.def("add", &add, "A function that adds two numbers");
}

13.3 WebAssembly编译

使用Emscripten编译为WebAssembly：

bash复制emcc -O3 -s WASM=1 -s EXPORTED_FUNCTIONS='["_malloc","_free"]' \
     -o module.js module.cpp

对应的JavaScript调用：

javascript复制const module = await import('./module.js');
const ptr = module._malloc(1024);
// 使用内存...
module._free(ptr);

14. 安全编程实践

14.1 边界检查技术

安全数组访问包装器：

cpp复制template<typename T, size_t N>
class SafeArray {
public:
    T& operator[](size_t index) {
        if (index >= N) {
            throw std::out_of_range("Index out of bounds");
        }
        return data_[index];
    }
    
    const T& operator[](size_t index) const {
        if (index >= N) {
            throw std::out_of_range("Index out of bounds");
        }
        return data_[index];
    }
    
private:
    T data_[N];
};

14.2 敏感数据清理

安全清理内存中的敏感数据：

cpp复制void secure_clean(void* ptr, size_t size) {
    volatile char* p = static_cast<volatile char*>(ptr);
    while (size--) {
        *p++ = 0;
    }
    __asm__ __volatile__ ("" : : "r"(ptr) : "memory");
}

14.3 防御性编程技巧

输入验证与状态检查：

cpp复制class SecureProcessor {
public:
    void process(const std::vector<uint8_t>& input) {
        if (input.empty()) {
            throw std::invalid_argument("Input cannot be empty");
        }
        
        if (!is_initialized_) {
            throw std::logic_error("Processor not initialized");
        }
        
        // 实际处理逻辑
    }
    
private:
    bool is_initialized_ = false;
};

15. 现代C++项目架构

15.1 模块化设计原则

典型项目目录结构：

code复制project/
├── include/           # 公共头文件
│   └── module1/
├── src/               # 实现文件
│   ├── module1/
│   └── module2/
├── tests/             # 单元测试
├── third_party/       # 第三方依赖
└── CMakeLists.txt     # 构建配置

15.2 依赖管理策略

使用现代包管理器管理依赖：

1. vcpkg：

bash复制vcpkg install fmt boost-asio

2. Conan：

python复制# conanfile.txt
[requires]
fmt/8.1.1
boost/1.78.0

[generators]
cmake_find_package

15.3 跨平台构建配置

处理平台差异的CMake脚本：

cmake复制if(UNIX AND NOT APPLE)
    add_definitions(-D_LINUX)
    find_package(Threads REQUIRED)
elseif(WIN32)
    add_definitions(-D_WINDOWS)
    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
elseif(APPLE)
    add_definitions(-D_MACOS)
endif()

16. 模板元编程实战

16.1 类型特征检测

使用SFINAE检测类型特性：

cpp复制template<typename T>
struct has_serialize {
private:
    template<typename U>
    static auto test(int) -> decltype(std::declval<U>().serialize(), std::true_type{});
    
    template<typename>
    static std::false_type test(...);
    
public:
    static constexpr bool value = decltype(test<T>(0))::value;
};

template<typename T>
constexpr bool has_serialize_v = has_serialize<T>::value;

16.2 编译时字符串哈希

constexpr字符串哈希函数：

cpp复制constexpr uint32_t hash_str(const char* str, uint32_t h = 0) {
    return *str ? hash_str(str + 1, (h * 31) + *str) : h;
}

constexpr uint32_t operator"" _hash(const char* str, size_t) {
    return hash_str(str);
}

static_assert("hello"_hash == 0x4f9f2cab);

16.3 模板递归展开

编译时循环展开技术：

cpp复制template<size_t N>
struct Unroller {
    template<typename Func>
    static void execute(Func&& f) {
        Unroller<N-1>::execute(f);
        f(N-1);
    }
};

template<>
struct Unroller<0> {
    template<typename Func>
    static void execute(Func&&) {}
};

// 使用示例
Unroller<8>::execute([](size_t i) {
    std::cout << "Iteration " << i << "\n";
});

17. 并发编程模式进阶

17.1 无锁队列优化

基于环形缓冲区的无锁队列：

cpp复制template<typename T, size_t Capacity>
class RingBuffer {
public:
    bool push(T value) {
        size_t head = head_.load();
        size_t next_head = (head + 1) % Capacity;
        
        if (next_head == tail_.load()) return false;
        
        buffer_[head] = std::move(value);
        head_.store(next_head);
        return true;
    }
    
    bool pop(T& value) {
        size_t tail = tail_.load();
        if (tail == head_.load()) return false;
        
        value = std::move(buffer_[tail]);
        tail_.store((tail + 1) % Capacity);
        return true;
    }
    
private:
    std::array<T, Capacity> buffer_;
    alignas(64) std::atomic<size_t> head_{0};
    alignas(64) std::atomic<size_t> tail_{0};
};

17.2 线程池实现

现代C++线程池实现：

cpp复制class ThreadPool {
public:
    explicit ThreadPool(size_t threads = std::thread::hardware_concurrency()) {
        for (size_t i = 0; i < threads; ++i) {
            workers_.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex_);
                        condition_.wait(lock, [this] {
                            return !tasks_.empty() || stop_;
                        });
                        
                        if (stop_ && tasks_.empty()) return;
                        
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    
                    task();
                }
            });
        }
    }
    
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) {
        using return_type = std::invoke_result_t<F, Args...>;
        
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            if (stop_) throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks_.emplace([task](){ (*task)(); });
        }
        
        condition_.notify_one();
        return res;
    }
    
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (std::thread &worker : workers_) {
            worker.join();
        }
    }
    
private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_ = false;
};

17.3 协程与异步IO集成

结合协程与异步IO的高性能网络服务：

cpp复制#include <cppcoro/task.hpp>
#include <cppcoro/io_service.hpp>
#include <cppcoro/socket.hpp>

cppcoro::task<void> handle_client(cppcoro::socket client) {
    char buffer[1024];
    size_t bytes_read = co_await client.recv(buffer, sizeof(buffer));
    while (bytes_read > 0) {
        co_await client.send(buffer, bytes_read);
        bytes_read = co_await client.recv(buffer, sizeof(buffer));
    }
}

cppcoro::task<void> server(cppcoro::io_service& io_service, uint16_t port) {
    auto listening_socket = cppcoro::socket::create_tcpv4(io_service);
    listening_socket.bind(cppcoro::ipv4_endpoint{ {}, port });
    listening_socket.listen();
    
    while (true) {
        auto client = co_await listening_socket.accept();
        handle_client(std::move(client)).schedule_on(io_service);
    }
}

18. 嵌入式系统开发技巧

18.1 寄存器映射技术

类型安全的寄存器访问：

cpp复制template<typename T, uintptr_t Addr>
struct Register {
    static_assert(std::is_unsigned_v<T>, "Register type must be unsigned");
    
    static volatile T* ptr() {
        return reinterpret_cast<volatile T*>(Addr);
    }
    
    static T read() { return *ptr(); }
    static void write(T value) { *ptr() = value; }
    
    struct Bit {
        T mask;
        constexpr explicit Bit(T m) : mask(m) {}
        
        void set() { *ptr() |= mask; }
        void clear() { *ptr() &= ~mask; }
        bool test() const { return *ptr() & mask; }
    };
};

// 使用示例
using GPIOA = Register<uint32_t, 0x40020000>;
constexpr GPIOA::Bit LED(1 << 5);

void toggle_led() {
    if (LED.test()) LED.clear();
    else LED.set();
}

18.2 低功耗模式实现

微控制器低功耗处理：

cpp复制class PowerManager {
public:
    enum class Mode { Active, Sleep, DeepSleep };
    
    void enter_mode(Mode m) {
        switch (m) {
            case Mode::Sleep:
                prepare_sleep();
                __asm__ volatile("wfi");
                break;
            case Mode::DeepSleep:
                prepare_deep_sleep();
                __asm__ volatile("wfi");
                reconfigure_clock();
                break;
            default: break;
        }
    }
    
private:
    void prepare_sleep() {
        // 配置外设进入低功耗状态
    }
    
    void prepare_deep_sleep() {
        // 关闭非必要外设
    }
    
    void reconfigure_clock() {
        // 唤醒后重新配置时钟
    }
};

18.3 实时系统任务调度

简单的协作式调度器：

cpp复制class Scheduler {
public:
    using Task = void(*)();
    
    void add_task(Task t) {
        tasks_[count_++] = t;
    }
    
    void run() {
        while (true) {
            for (size_t i = 0; i < count_; ++i) {
                tasks_[i]();
            }
            PowerManager::enter_mode(PowerManager::Mode::Sleep);
        }
    }
    
private:
    static constexpr size_t MaxTasks = 8;
    Task tasks_[MaxTasks];
    size_t count_ = 0;
};

19. 图形与计算密集应用

19.1 SIMD向量化编程

使用编译器内置函数：

cpp复制#include <immintrin.h>

void vector_add(float* a, float* b, float* c, size_t n) {
    size_t i = 0;
    for (; i + 8 <= n; i += 8) {
        __m256 va = _mm256_load_ps(a + i);
        __m256 vb = _mm256_load_ps(b + i);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(c + i, vc);
    }
    
    // 处理剩余元素
    for (; i < n; ++i) {
        c[i] = a[i] + b[i];
    }
}

19.2 GPU计算集成

使用SYCL进行异构计算：

cpp复制#include <CL/sycl.hpp>

void matrix_multiply(const float* a, const float* b, float* c, size_t n) {
    sycl::queue q(sycl::gpu_selector{});
    
    auto buf_a = sycl::buffer<float, 2>(a, sycl::range<2>(n, n));
    auto buf_b = sycl::buffer<float, 2>(b, sycl::range<2>(n, n));
    auto buf_c = sycl::buffer<float, 2>(c, sycl::range<2>(n, n));
    
    q.submit([&](sycl::handler& h) {
        auto acc_a = buf_a.get_access<sycl::access::mode::read>(h);
        auto acc_b = buf_b.get_access<sycl::access::mode::read>(h);
        auto acc_c = buf_c.get_access<sycl::access::mode::write>(h);
        
        h.parallel_for(sycl::range<2>(n, n), [=](sycl::id<2> idx) {
            float sum = 0.0f;
            for (size_t k = 0; k < n; ++k) {
                sum += acc_a[idx[0]][k] * acc_b[k][idx[1]];
            }
            acc_c[idx] = sum;
        });
    });
    
    q.wait();
}

19.3 图像处理优化

使用SIMD优化的图像卷积：

cpp复制void apply_kernel(const uint8_t* src, uint8_t* dst, int width, int height,
                 const float* kernel, int ksize) {
    const int radius = ksize / 2;
    
    for (int y = radius; y < height - radius; ++y) {
        for (int x = radius; x < width - radius; x += 8) {
            __m256 sum = _mm256_setzero_ps();
            
            for (int ky = -radius; ky <= radius; ++ky) {
                for (int kx = -radius; kx <= radius; ++kx) {
                    float k = kernel[(ky + radius) * ksize + (kx + radius)];
                    __m256 pixels = _mm256_cvtepi32_ps(
                        _mm256_cvtepu8_epi32(
                            _mm_loadu_si128(
                                reinterpret_cast<const