Linux C/C++开发环境搭建与优化指南-嵌云网-嵌入式AI开发资源站

Linux C/C++开发环境搭建与优化指南

打喷嚏的apple

1. Linux C/C++ 开发环境搭建指南

作为一名在Linux环境下开发C/C++程序多年的老手，我深知一个稳定高效的开发环境对程序员的重要性。今天我就来分享一套经过实战检验的Linux C/C++开发环境搭建方案，从编译器选择到调试工具配置，手把手带你搭建完整的开发环境。

2. 编译工具链的选择与安装

2.1 GCC与G++：编译器的核心选择

在Linux环境下，GCC（GNU Compiler Collection）和G++是我们最常用的编译器。虽然它们经常被混为一谈，但实际上有着重要的区别：

GCC：默认将.c文件视为C程序，.cpp文件需要手动指定为C++（使用gcc -xc++选项）
G++：自动将.c和.cpp文件均视为C++程序，并启用C++语法解释

底层实现差异：
G++本质上是GCC的C++专用前端包装器。它们共享相同的编译器核心，但G++会自动处理C++特有的编译选项和链接库。

实际使用建议：

纯C项目：使用GCC更简洁
C++项目：优先使用G++，避免手动链接库的麻烦

安装验证命令：

bash复制gcc --version
g++ --version

提示：建议安装最新版本的GCC/G++以获得更好的C++标准支持。在Ubuntu上可以使用sudo apt install gcc g++安装，Arch Linux使用sudo pacman -S gcc。

2.2 构建工具：Make与CMake

2.2.1 Make：简单项目的首选

Make是最基础的构建工具，通过Makefile定义构建规则。一个典型的Makefile示例如下：

makefile复制CC = gcc
CFLAGS = -Wall -g

all: main

main: main.o func.o
	$(CC) $(CFLAGS) -o main main.o func.o

%.o: %.c
	$(CC) $(CFLAGS) -c $<

clean:
	rm -rf *.o main

使用方式：

bash复制make       # 构建项目
make clean # 清理构建产物

2.2.2 CMake：跨平台大型项目的解决方案

对于更复杂的项目，CMake是更好的选择。它能够生成各种构建系统（如Makefile）的配置文件。基本使用流程：

创建CMakeLists.txt：

cmake复制cmake_minimum_required(VERSION 3.10)
project(MyProject)
add_executable(main main.cpp func.cpp)

构建项目：

bash复制mkdir build && cd build
cmake ..
make

经验分享：在团队协作项目中，CMake的跨平台特性可以大大减少环境配置问题。建议从一开始就使用CMake，即使项目规模很小。

3. 调试与问题排查工具

3.1 GDB：强大的调试器

GDB是Linux下最常用的调试工具。使用步骤：

编译时加入调试信息：

bash复制g++ -g hello.cpp -o hello

启动调试：

bash复制gdb ./hello

常用命令：

break main：在main函数设置断点
run：运行程序
next：单步执行
print var：打印变量值

3.2 Valgrind：内存问题检测神器

内存泄漏是C/C++程序常见的问题。Valgrind可以帮我们检测：

bash复制valgrind ./your_program

结果分析：

"All heap blocks were freed"：无内存泄漏
"definitely lost"：确认的内存泄漏
"indirectly lost"：间接内存泄漏

避坑指南：Valgrind会显著降低程序运行速度，仅用于调试阶段。生产环境不要依赖它来检测内存问题。

4. 开发环境优化技巧

4.1 编辑器配置

推荐使用VSCode或CLion作为开发IDE。VSCode配置建议：

安装C/C++扩展
配置c_cpp_properties.json：

json复制{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "gcc-x64"
        }
    ],
    "version": 4
}

4.2 静态代码分析

使用clang-tidy进行静态代码分析：

bash复制clang-tidy -checks='*' main.cpp -- -std=c++17

4.3 单元测试框架

推荐使用Google Test框架：

bash复制# 安装
sudo apt install libgtest-dev

示例测试用例：

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

TEST(MyTestSuite, MyTestCase) {
    EXPECT_EQ(2+2, 4);
}

5. 常见问题解决方案

5.1 编译器版本问题

症状：代码在新编译器能编译，旧版本报错

解决方案：

明确指定C++标准版本：-std=c++17
使用特性检测宏：

cpp复制#if __cplusplus >= 201703L
// C++17代码
#endif

5.2 链接错误处理

常见错误：undefined reference to...

排查步骤：

确认函数声明和定义一致
检查是否编译了所有需要的源文件
确认链接了正确的库（-l选项）

5.3 多线程编程问题

建议：

使用-pthread编译选项
优先使用C++标准库的<thread>和<mutex>
避免直接使用pthread API除非必要

6. 性能优化技巧

6.1 编译优化选项

-O1：基本优化
-O2：推荐优化级别
-O3：激进优化（可能增加代码体积）
-Os：优化代码大小

注意：调试时应使用-O0关闭优化，否则可能影响调试体验

6.2 性能分析工具

使用perf进行性能分析：

bash复制perf record ./my_program
perf report

6.3 内联函数优化

使用inline关键字提示编译器：

cpp复制inline int add(int a, int b) {
    return a + b;
}

7. 跨平台开发注意事项

7.1 文件路径处理

避免硬编码路径，使用：

POSIX路径分隔符'/'
<filesystem>（C++17）或Boost.Filesystem

7.2 字节序问题

网络通信或文件存储时注意：

cpp复制#include <endian.h>
uint32_t value = htobe32(0x12345678); // 主机序转网络序

7.3 系统API差异

使用预定义宏处理平台差异：

cpp复制#ifdef __linux__
// Linux专用代码
#elif defined(_WIN32)
// Windows专用代码
#endif

8. 现代C++特性实践

8.1 智能指针

替代裸指针：

cpp复制#include <memory>
auto ptr = std::make_unique<MyClass>();

8.2 Lambda表达式

简化回调：

cpp复制std::sort(v.begin(), v.end(), [](int a, int b) {
    return a > b;
});

8.3 移动语义

提升性能：

cpp复制std::vector<std::string> createStrings() {
    std::vector<std::string> v;
    // ...填充数据
    return v; // 触发移动而非拷贝
}

9. 项目组织结构建议

9.1 目录结构

推荐布局：

code复制project/
├── include/    # 公共头文件
├── src/        # 源文件
├── tests/      # 测试代码
├── thirdparty/ # 第三方库
└── CMakeLists.txt

9.2 头文件保护

防止重复包含：

cpp复制#ifndef MYHEADER_H
#define MYHEADER_H
// 头文件内容
#endif

9.3 命名规范

建议遵循：

类名：PascalCase
函数/变量：camelCase
宏/常量：UPPER_CASE

10. 持续集成配置

10.1 GitHub Actions示例

.github/workflows/build.yml:

yaml复制name: CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - run: |
        sudo apt update
        sudo apt install g++ cmake
        mkdir build && cd build
        cmake .. && make

10.2 静态分析集成

在CI中加入：

yaml复制- run: |
    sudo apt install clang-tidy
    clang-tidy --version
    find src -name '*.cpp' | xargs clang-tidy

11. 依赖管理

11.1 系统包管理

Ubuntu:

bash复制sudo apt install libboost-all-dev

Arch Linux:

bash复制sudo pacman -S boost

11.2 Conan包管理器

安装：

bash复制pip install conan

使用：

bash复制conan install boost/1.75.0@

11.3 Git子模块

添加依赖库：

bash复制git submodule add https://github.com/nlohmann/json.git thirdparty/json

12. 性能关键代码优化

12.1 缓存友好设计

顺序访问数据
减少指针跳转
使用紧凑数据结构

12.2 SIMD指令优化

使用编译器内置函数：

cpp复制#include <immintrin.h>
__m256i a = _mm256_loadu_si256((__m256i*)src);

12.3 内联汇编

谨慎使用：

cpp复制asm("movl %1, %%eax\n\t"
    "addl $1, %%eax\n\t"
    "movl %%eax, %0"
    : "=r"(result)
    : "r"(input));

13. 安全编程实践

13.1 缓冲区安全

使用安全函数：

cpp复制strncpy(dest, src, sizeof(dest)-1);
dest[sizeof(dest)-1] = '\0';

13.2 整数溢出检查

加法检查：

cpp复制if (a > INT_MAX - b) {
    // 处理溢出
}

13.3 敏感数据清理

安全清除内存：

cpp复制void secure_erase(void *ptr, size_t size) {
    volatile char *p = (volatile char *)ptr;
    while (size--) *p++ = 0;
}

14. 调试技巧进阶

14.1 核心转储分析

启用核心转储：

bash复制ulimit -c unlimited

分析：

bash复制gdb ./program core

14.2 反向调试

使用rr工具：

bash复制rr record ./program
rr replay

14.3 条件断点

设置条件断点：

bash复制(gdb) break foo.cpp:123 if x==42

15. 嵌入式开发特别考虑

15.1 交叉编译工具链

安装：

bash复制sudo apt install gcc-arm-linux-gnueabihf

使用：

bash复制arm-linux-gnueabihf-g++ -o arm_program program.cpp

15.2 内存受限优化

编译选项：

bash复制-Os -ffunction-sections -fdata-sections -Wl,--gc-sections

15.3 裸机编程

启动代码示例：

cpp复制extern "C" void Reset_Handler() {
    // 初始化.data段
    // 清零.bss段
    // 调用main()
}

16. 多语言交互

16.1 C调用C++

使用extern "C"：

cpp复制extern "C" {
    void c_callable_function() {
        // 实现
    }
}

16.2 Python扩展

使用pybind11：

cpp复制#include <pybind11/pybind11.h>
PYBIND11_MODULE(example, m) {
    m.def("add", [](int a, int b) { return a + b; });
}

16.3 Rust FFI

Rust侧：

rust复制#[no_mangle]
pub extern "C" fn rust_function() -> i32 {
    42
}

C侧：

cpp复制extern int rust_function();

17. 实时系统开发

17.1 优先级设置

使用pthread：

cpp复制#include <pthread.h>
sched_param param;
param.sched_priority = 90;
pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);

17.2 内存锁定

防止交换：

cpp复制mlockall(MCL_CURRENT | MCL_FUTURE);

17.3 无锁编程

原子操作：

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

18. 图形编程基础

18.1 OpenGL环境

安装：

bash复制sudo apt install libgl1-mesa-dev libglfw3-dev

18.2 Vulkan环境

安装：

bash复制sudo apt install vulkan-tools libvulkan-dev

18.3 图形调试

使用RenderDoc：

bash复制renderdoccmd capture ./graphics_app

19. 网络编程要点

19.1 Socket基础

TCP服务器示例：

cpp复制int sock = socket(AF_INET, SOCK_STREAM, 0);
sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);
bind(sock, (sockaddr*)&addr, sizeof(addr));
listen(sock, 5);

19.2 高性能网络

使用epoll：

cpp复制int epfd = epoll_create1(0);
epoll_event ev{};
ev.events = EPOLLIN;
ev.data.fd = sockfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

19.3 协议设计

消息头示例：

cpp复制struct MessageHeader {
    uint32_t length;
    uint32_t type;
};

20. 容器化开发

20.1 Docker基础

Dockerfile示例：

dockerfile复制FROM ubuntu:20.04
RUN apt update && apt install -y g++ cmake
COPY . /app
WORKDIR /app/build
RUN cmake .. && make

20.2 开发环境容器

使用volume挂载：

bash复制docker run -v $(pwd):/app -it dev-container bash

20.3 交叉编译容器

多阶段构建：

dockerfile复制FROM arm64v8/ubuntu as builder
# 构建步骤

FROM ubuntu
COPY --from=builder /output /app

21. 性能基准测试

21.1 Google Benchmark

安装：

bash复制sudo apt install libbenchmark-dev

使用：

cpp复制#include <benchmark/benchmark.h>
static void BM_StringCopy(benchmark::State& state) {
    for (auto _ : state) {
        std::string x = "hello";
    }
}
BENCHMARK(BM_StringCopy);

21.2 代码热力图

使用perf：

bash复制perf record -g ./program
perf report -g 'graph,0.5,caller'

21.3 内存分析

使用massif：

bash复制valgrind --tool=massif ./program
ms_print massif.out.*

22. 异常处理策略

22.1 C++异常

基本用法：

cpp复制try {
    throw std::runtime_error("error");
} catch (const std::exception& e) {
    std::cerr << e.what() << std::endl;
}

22.2 错误码设计

枚举示例：

cpp复制enum class ErrorCode {
    Success = 0,
    InvalidInput,
    ResourceExhausted,
    // ...
};

22.3 异常安全保证

基本级别：

无异常安全
基本保证：不泄露资源
强保证：操作原子性
不抛出保证

23. 模板元编程

23.1 类型萃取

示例：

cpp复制template<typename T>
void func(T val) {
    if constexpr (std::is_integral_v<T>) {
        // 整数类型处理
    } else {
        // 其他类型处理
    }
}

23.2 SFINAE

应用：

cpp复制template<typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
void process(T value) {
    // 仅对算术类型有效
}

23.3 编译期计算

constexpr函数：

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

24. 并发模式实践

24.1 线程池实现

基本结构：

cpp复制class ThreadPool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    // ...
};

24.2 生产者-消费者

使用条件变量：

cpp复制std::mutex mtx;
std::condition_variable cv;
std::queue<Data> queue;

// 生产者
{
    std::lock_guard lock(mtx);
    queue.push(data);
    cv.notify_one();
}

// 消费者
std::unique_lock lock(mtx);
cv.wait(lock, []{ return !queue.empty(); });
auto data = queue.front();
queue.pop();

24.3 无锁队列

基于原子操作：

cpp复制template<typename T>
class LockFreeQueue {
    std::atomic<Node*> head;
    std::atomic<Node*> tail;
    // ...
};

25. 代码生成技术

25.1 宏元编程

X宏技巧：

cpp复制#define FRUITS \
    X(Apple)   \
    X(Orange)  \
    X(Banana)

enum class Fruit {
#define X(name) name,
    FRUITS
#undef X
};

25.2 反射模拟

基于宏的反射：

cpp复制#define REGISTER_CLASS(ClassName) \
    template<> \
    const char* ClassNameTrait<ClassName>::name() { return #ClassName; }

25.3 DSL嵌入

表达式模板：

cpp复制auto expr = (x + y) * z; // 生成抽象语法树

26. 硬件特性利用

26.1 CPU特性检测

使用cpuid：

cpp复制void get_cpu_features() {
    unsigned int eax, ebx, ecx, edx;
    __get_cpuid(1, &eax, &ebx, &ecx, &edx);
    // 检查特征位
}

26.2 缓存对齐

指定对齐：

cpp复制alignas(64) char buffer[1024];

26.3 分支预测

提示编译器：

cpp复制#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

27. 嵌入式脚本集成

27.1 Lua绑定

使用sol2：

cpp复制lua["func"] = [](int x) { return x * 2; };

27.2 Python嵌入

Python C API：

cpp复制Py_Initialize();
PyRun_SimpleString("print('Hello from Python!')");
Py_Finalize();

27.3 JavaScript引擎

使用QuickJS：

cpp复制JSValue val = JS_Eval(ctx, "1 + 2", 3, "<input>", JS_EVAL_TYPE_GLOBAL);

28. 代码质量保障

28.1 单元测试覆盖率

使用gcov：

bash复制g++ -fprofile-arcs -ftest-coverage -o test test.cpp
./test
gcov test.cpp

28.2 静态分析集成

使用clang静态分析器：

bash复制scan-build cmake ..
scan-build make

28.3 动态分析持续化

在CI中集成ASan：

bash复制g++ -fsanitize=address -o test test.cpp

29. 性能优化案例

29.1 字符串处理优化

避免临时对象：

cpp复制std::string result;
result.reserve(100); // 预分配
for (const auto& s : strings) {
    result += s;
}

29.2 算法选择策略

根据数据规模：

小数据：插入排序
中等数据：快速排序
大数据：归并排序

29.3 内存池技术

自定义分配器：

cpp复制template<typename T>
class PoolAllocator {
    // 实现分配器接口
};

30. 开发工作流建议

30.1 增量构建技巧

使用ccache加速：

bash复制export CCACHE_DIR="$HOME/.ccache"
ccache -M 5G  # 设置5GB缓存

30.2 预编译头文件

CMake配置：

cmake复制target_precompile_headers(my_target PUBLIC "common.h")

30.3 分布式构建

使用distcc：

bash复制export DISTCC_HOSTS="localhost host2 host3"
make -j$(distcc -j)

31. 跨编译器兼容

31.1 特性检测宏

检查C++版本：

cpp复制#if __cplusplus >= 201703L
// C++17代码
#endif

31.2 编译器特定扩展

处理GCC/Clang/MSVC差异：

cpp复制#ifdef __GNUC__
#define FORCE_INLINE __attribute__((always_inline))
#elif defined(_MSC_VER)
#define FORCE_INLINE __forceinline
#endif

31.3 ABI兼容性

保持稳定接口：

避免直接暴露STL类型
使用PIMPL模式隐藏实现

32. 低级系统编程

32.1 系统调用封装

直接调用：

cpp复制long syscall(long number, ...);

// 调用getpid
auto pid = syscall(SYS_getpid);

32.2 内存映射

使用mmap：

cpp复制void* addr = mmap(NULL, length, PROT_READ|PROT_WRITE, 
                 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

32.3 信号处理

安全信号处理：

cpp复制void handler(int sig) {
    // 仅设置原子标志
}

int main() {
    struct sigaction sa{};
    sa.sa_handler = handler;
    sigaction(SIGINT, &sa, nullptr);
}

33. 嵌入式Linux特有技术

33.1 设备树操作

解析设备树：

bash复制dtc -I fs /sys/firmware/devicetree/base

33.2 内核模块开发

简单模块：

c复制#include <linux/module.h>
MODULE_LICENSE("GPL");
static int __init hello_init(void) {
    printk(KERN_INFO "Hello world\n");
    return 0;
}
module_init(hello_init);

33.3 交叉调试

使用gdbserver：

bash复制# 目标板
gdbserver :1234 ./program

# 主机
gdb-multiarch -ex "target remote 192.168.1.100:1234"

34. 实时信号处理

34.1 定时器使用

timerfd示例：

cpp复制int tfd = timerfd_create(CLOCK_MONOTONIC, 0);
itimerspec its{};
its.it_value.tv_sec = 1;
its.it_interval.tv_sec = 1;
timerfd_settime(tfd, 0, &its, nullptr);

34.2 信号量性能

使用futex：

cpp复制#include <linux/futex.h>
syscall(SYS_futex, &futex, FUTEX_WAIT, 0, nullptr, nullptr, 0);

34.3 优先级继承

避免优先级反转：

cpp复制pthread_mutexattr_t attr;
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);

35. 安全编码实践

35.1 防御性编程

输入验证：

cpp复制if (input_size > MAX_SIZE) {
    return ERROR_INVALID_INPUT;
}

35.2 安全函数使用

替代危险函数：

cpp复制strncpy_s(dest, sizeof(dest), src, _TRUNCATE);

35.3 随机数生成

使用安全随机数：

cpp复制#include <random>
std::random_device rd;
std::uniform_int_distribution<int> dist(0, 100);

36. 多进程编程

36.1 进程创建

fork示例：

cpp复制pid_t pid = fork();
if (pid == 0) {
    // 子进程
} else {
    // 父进程
}

36.2 进程间通信

匿名管道：

cpp复制int pipefd[2];
pipe(pipefd);
write(pipefd[1], buf, len);
read(pipefd[0], buf, sizeof(buf));

36.3 共享内存

shm示例：

cpp复制int shmfd = shm_open("/myshm", O_CREAT|O_RDWR, 0666);
ftruncate(shmfd, size);
void* ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, shmfd, 0);

37. 文件系统操作

37.1 高效文件IO

使用sendfile：

cpp复制sendfile(out_fd, in_fd, nullptr, file_size);

37.2 异步IO

Linux AIO：

cpp复制struct iocb cb{};
io_prep_pread(&cb, fd, buf, count, offset);
io_submit(ctx, 1, &cb);

37.3 文件监控

inotify示例：

cpp复制int fd = inotify_init();
inotify_add_watch(fd, "/path", IN_MODIFY);

38. 时间处理技巧

38.1 高精度计时

使用clock_gettime：

cpp复制timespec ts{};
clock_gettime(CLOCK_MONOTONIC, &ts);

38.2 时区转换

使用ICU或date库：

cpp复制date::zoned_time zt{"Asia/Shanghai", sys_time{}};

38.3 定时任务调度

使用cron表达式：

cpp复制cron::make_cron("0 0 * * *");
auto next = cron::cron_next(cron, now);

39. 数学计算优化

39.1 SIMD向量化

自动向量化：

bash复制g++ -O3 -march=native -ffast-math

39.2 近似计算

快速平方根：

cpp复制float Q_rsqrt(float number) {
    // 著名的Quake III算法
    long i; float x2, y;
    x2 = number * 0.5F;
    y  = number;
    i  = *(long*)&y;
    i  = 0x5f3759df - (i >> 1);
    y  = *(float*)&i;
    return y * (1.5F - (x2 * y * y));
}

39.3 多精度计算

使用GMP库：

cpp复制mpz_t a, b, c;
mpz_init_set_str(a, "123456789", 10);
mpz_init_set_str(b, "987654321", 10);
mpz_init(c);
mpz_mul(c, a, b);

40. 密码学基础

40.1 哈希计算

使用OpenSSL：

cpp复制#include <openssl/sha.h>
SHA256_CTX ctx;
SHA256_Init(&ctx);
SHA256_Update(&ctx, data, len);
SHA256_Final(digest, &ctx);

40.2 对称加密

AES示例：

cpp复制EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);

40.3 非对称加密

RSA操作：

cpp复制RSA *rsa = RSA_new();
RSA_generate_key_ex(rsa, 2048, e, NULL);

41. 国际化和本地化

41.1 Unicode处理

使用ICU库：

cpp复制UnicodeString str("你好世界");
std::string utf8;
str.toUTF8String(utf8);

41.2 本地化文本

使用gettext：

cpp复制#include <libintl.h>
bindtextdomain("myapp", "/usr/share/locale");
textdomain("myapp");
printf(gettext("Hello world"));

41.3 文本渲染

使用HarfBuzz：

cpp复制hb_buffer_t *buf = hb_buffer_create();
hb_buffer_add_utf8(buf, text, -1, 0, -1);

42. 音频处理基础

42.1 PCM处理

基本操作：

cpp复制void apply_gain(int16_t *samples, size_t count, float gain) {
    for (size_t i = 0; i < count; ++i) {
        samples[i] = static_cast<int16_t>(samples[i] * gain);
    }
}

42.2 重采样

使用libsamplerate：

cpp复制SRC_DATA data{};
data.input_frames = in_frames;
data.output_frames = out_frames;
src_process(state, &data);

42.3 音频编码

使用libopus：

cpp复制OpusEncoder *enc = opus_encoder_create(48000, 2, OPUS_APPLICATION_AUDIO, &err);
opus_encode(enc, pcm, frame_size, packet, max_packet);

43. 视频处理入门

43.1 像素格式转换

使用libyuv：

cpp复制libyuv::I420ToRGB24(y_plane, y_stride,
                   u_plane, u_stride,
                   v_plane, v_stride,
                   rgb, rgb_stride,
                   width, height);

43.2 视频编码

使用x264：

cpp复制x264_picture_t pic_in{};
x264_picture_alloc(&pic_in, X264_CSP_I420, width, height);
x264_encoder_encode(enc, &nal, &i_nal, &pic_in, &pic_out);

43.3 硬件加速

VAAPI示例：

bash复制ffmpeg -vaapi_device /dev/dri/renderD128 -i input.mp4 -vf 'format=nv12,hwupload' -c:v h264_vaapi output.mp4

44. 机器学习集成

44.1 TensorFlow C API

加载模型：

cpp复制TF_Graph* graph = TF_NewGraph();
TF_Status* status = TF_NewStatus();
TF_SessionOptions* opts = TF_NewSessionOptions();
TF_Session* session = TF_NewSession(graph, opts, status);

44.2 ONNX运行时

推理示例：

cpp复制Ort::Session session(env, "model.onnx", Ort::SessionOptions{});
session.Run(Ort::RunOptions{}, input_names, inputs, 1, output_names, outputs, 1);

44.3 特征工程

使用Eigen：

cpp复制Eigen::MatrixXf data(100, 10);
Eigen::VectorXf mean = data.colwise().mean();

45. 数据库连接

45.1 SQLite操作

基本流程：

cpp复制sqlite3 *db;
sqlite3_open(":memory:", &db);
sqlite3_exec(db, "CREATE TABLE test(id INTEGER);", NULL, NULL, NULL);

45.2 MySQL客户端

使用Connector/C++：

cpp复制sql::Driver *driver = get_driver_instance();
auto con = driver->connect("tcp://127.0.0.1:3306", "user", "pass");

45.3 Redis交互

使用hiredis：

cpp复制redisContext *c = redisConnect("127.0.0.1", 6379);
redisReply *reply = (redisReply*)redisCommand(c, "SET key value");

46. Web服务开发

46.1 HTTP服务器

使用cpp-httplib：

cpp复制httplib::Server svr;
svr.Get("/", [](const auto& req, auto& res) {
    res.set_content("Hello World", "text/plain");
});
svr.listen("0.0.0.0", 8080);

46.2 RESTful API

设计原则：

资源导向URL
HTTP方法对应CRUD
JSON请求/响应

46.3 WebSocket

使用libwebsockets：

cpp复制static int callback(struct lws *wsi, enum lws_callback_reasons reason,
                   void *user, void *in, size_t len) {
    // 处理各种事件
}

47. GUI开发基础

47.1 Qt入门

简单窗口：

cpp复制#include <QApplication>
#include <QLabel>
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QLabel label("Hello Qt!");
    label.show();
    return app.exec();
}

47.2 GTK编程

基本示例：

cpp复制#include <gtk/gtk.h>
int main(int argc, char *argv[]) {
    gtk_init(&argc, &argv);
    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_show(window);
    gtk_main();
}

47.3 ImGui集成

即时模式GUI：

cpp复制ImGui::Begin("Window");
ImGui::Text("Hello, world!");
if (ImGui::Button("Save")) {
    // 处理点击
}
ImGui::End();

48. 移动开发交叉编译

48.1 Android NDK

基础配置：

cmake复制cmake_minimum_required(VERSION 3.10)
project(HelloWorld)
add_library(native-lib SHARED native-lib.cpp)
find_library(log-lib log