Niujiubaba1. C++语言基础深度解析
1.1 基础数据类型范围与精度详解
C++作为强类型语言，其基础数据类型的范围和精度直接影响程序的正确性和性能。理解这些特性对于编写健壮高效的代码至关重要。
整数类型的内存布局与范围
整数类型分为有符号和无符号两大类，其内存表示采用补码形式。以32位系统为例：
cpp复制// 有符号整数示例
int32_t signed_int = -2147483648; // 最小值
int32_t max_signed = 2147483647; // 最大值
// 无符号整数示例
uint32_t unsigned_int = 0; // 最小值
uint32_t max_unsigned = 4294967295;// 最大值
浮点数精度与IEEE 754标准
C++浮点数遵循IEEE 754标准，其内存结构包含符号位、指数位和尾数位：
cpp复制// 浮点数内存结构示例
struct FloatLayout {
uint32_t mantissa : 23; // 尾数部分
uint32_t exponent : 8; // 指数部分
uint32_t sign : 1; // 符号位
};
类型选择实践建议
-
整数选择原则：
- 明确需要负数时使用有符号类型
- 处理位操作或模运算时使用无符号类型
- 固定大小需求使用
int32_t等明确类型
-
浮点选择原则：
- 一般计算使用
double - 内存敏感场景考虑
float - 高精度需求使用
long double
- 一般计算使用
关键经验：在嵌入式系统中，要特别注意
int和long的大小可能随平台变化，建议使用<cstdint>中的固定大小类型。
1.2 作用域与生命周期管理
作用域规则深度解析
C++作用域体系构建了程序的可见性框架：
- 块作用域实践：
cpp复制void demo() {
int x = 10; // 函数级作用域
{
int y = x; // 可以访问外层变量
// x = y; // 合法
}
// y = x; // 错误：y不可见
}
- 类作用域的特殊性：
cpp复制class ScopeDemo {
static int class_var; // 类作用域
int instance_var; // 对象作用域
public:
void method() {
class_var = 10; // 访问静态成员
instance_var = 20; // 访问实例成员
}
};
生命周期管理实战
-
自动变量优化技巧：
- 小对象优先栈分配
- 避免大对象栈分配（可能引发栈溢出）
-
静态变量初始化顺序问题：
cpp复制// 解决静态初始化顺序问题
int& getGlobal() {
static int instance = 42; // 首次使用时初始化
return instance;
}
- 动态内存管理陷阱：
cpp复制void dynamicDemo() {
int* arr = new int[100];
// ...使用数组...
delete[] arr; // 必须配对使用
// 更安全的做法：
std::unique_ptr<int[]> safe_arr(new int[100]);
}
1.3 const关键字的工程级应用
const修饰体系全解
- 指针const的四种变体：
cpp复制int value = 10;
const int* ptr1 = &value; // 指向常量
int const* ptr2 = &value; // 同上
int* const ptr3 = &value; // 常量指针
const int* const ptr4 = &value; // 双重const
- 函数const的正确用法：
cpp复制class ConstDemo {
mutable int counter; // 可在const方法修改
int value;
public:
int getValue() const {
++counter; // 合法，因为counter是mutable
// value = 10; // 错误
return value;
}
};
const优化与类型安全
- constexpr编译期计算：
cpp复制constexpr int factorial(int n) {
return n <= 1 ? 1 : n * factorial(n - 1);
}
int arr[factorial(5)]; // 编译期确定数组大小
- 类型安全替代宏定义：
cpp复制// 替代#define PI 3.14159
constexpr double PI = 3.141592653589793;
- const与API设计：
cpp复制class SafeAPI {
public:
void unsafeMethod() { /*...*/ }
void safeMethod() const { /*...*/ }
};
void user(const SafeAPI& api) {
api.safeMethod(); // 安全调用
// api.unsafeMethod(); // 编译错误
}
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 指针与引用高级技巧
2.1 内存布局与访问优化
现代CPU缓存体系下的内存访问
- 缓存行对齐优化：
cpp复制struct alignas(64) CacheAligned { // 典型缓存行64字节
int data[16];
};
- 指针遍历优化策略：
cpp复制// 低效的随机访问
void randomAccess(int* arr, int* indices, int n) {
for (int i = 0; i < n; ++i) {
process(arr[indices[i]]);
}
}
// 高效的顺序访问
void sequentialAccess(int* arr, int n) {
for (int i = 0; i < n; ++i) {
process(arr[i]);
}
}
内存模型实战
- 栈内存的高效利用：
cpp复制void stackEfficiency() {
int buffer[1024]; // 适合小数据量
// vs
int* heapBuffer = new int[1024]; // 需要额外管理
delete[] heapBuffer;
}
- 内存池自定义实现：
cpp复制class MemoryPool {
struct Block { /*...*/ };
static constexpr size_t POOL_SIZE = 4096;
char pool[POOL_SIZE];
// ...管理逻辑...
};
2.2 指针与引用的性能对比
底层汇编视角分析
- 引用实现的本质：
cpp复制int x = 10;
int& ref = x;
// 汇编层面通常等同于指针操作
- 性能关键差异：
- 引用访问可能减少一次解引用
- 编译器对引用优化空间更大
工程实践选择标准
-
必须使用指针的场景：
- 需要NULL/空值表示
- 需要重新绑定
- 需要指针算术运算
-
优先使用引用的场景：
- 函数参数传递
- 操作符重载
- 保证对象存在的别名
高级引用技巧
- 引用折叠规则：
cpp复制template<typename T>
void forwardRef(T&& param) { // 万能引用
// 根据T类型发生引用折叠
}
- 引用限定成员函数：
cpp复制class RefQualifier {
public:
void process() & { /* 左值调用 */ }
void process() && { /* 右值调用 */ }
};
2.3 空指针与野指针防御编程
现代空指针最佳实践
- nullptr的优势：
cpp复制void legacy(int* p) {}
void modern(std::nullptr_t p) {}
int main() {
legacy(NULL); // 可能引发重载歧义
modern(nullptr); // 明确类型安全
}
- 可选值表示：
cpp复制std::optional<int> findValue() {
if (found) return 42;
return std::nullopt;
}
野指针检测机制
- 智能指针策略：
cpp复制void safeDemo() {
auto ptr = std::make_shared<int>(10);
std::weak_ptr<int> observer = ptr;
if (auto locked = observer.lock()) {
// 安全使用
}
}
- 调试模式检测：
cpp复制class DebugPointer {
int* raw_ptr;
bool valid;
public:
~DebugPointer() { valid = false; }
int operator*() {
assert(valid && "Dangling pointer!");
return *raw_ptr;
}
};
- 内存标记技术：
cpp复制void* operator new(size_t size) {
void* p = malloc(size);
memset(p, 0xAA, size); // 填充特殊模式
return p;
}
bool isMemoryCorrupted(void* p, size_t size) {
// 检查模式是否改变
}
3. 面向对象与设计模式深度实践
3.1 OOP三大特性工程实现
封装的高级技法
- Pimpl惯用法：
cpp复制// 头文件
class PublicInterface {
struct Impl;
std::unique_ptr<Impl> pimpl;
public:
PublicInterface();
~PublicInterface();
};
// 源文件
struct PublicInterface::Impl {
// 私有实现细节
};
- 友元控制策略：
cpp复制class SecureContainer {
friend class SecureAccessor;
int sensitive_data;
};
class SecureAccessor {
public:
static int getData(SecureContainer& c) {
return c.sensitive_data;
}
};
继承体系设计原则
-
继承关系判断标准：
- 严格满足LSP原则
- 优先组合而非继承
- 接口继承与实现继承分离
-
虚继承实战：
cpp复制class Base { /*...*/ };
class VirtualDerived : virtual public Base {
// 虚基类只保留一份实例
};
多态性能优化
- 虚函数表剖析：
cpp复制class PolymorphicBase {
public:
virtual ~PolymorphicBase() = default;
virtual void interface() = 0;
};
// 查看虚表指针
void inspectVTable(PolymorphicBase* obj) {
void** vptr = *(void***)obj;
// 分析vptr指向的函数表
}
- 运行时类型识别：
cpp复制void safeCast(PolymorphicBase* ptr) {
if (auto derived = dynamic_cast<DerivedType*>(ptr)) {
// 类型安全转换
}
}
3.2 设计模式现代C++实现
单例模式演进
- Meyers' Singleton：
cpp复制class ThreadSafeSingleton {
public:
static ThreadSafeSingleton& instance() {
static ThreadSafeSingleton inst;
return inst;
}
private:
ThreadSafeSingleton() = default;
};
- 单例销毁顺序控制：
cpp复制class OrderedSingleton {
static OrderedSingleton& instance() {
static OrderedSingleton inst;
static Cleanup cleanup(inst);
return inst;
}
struct Cleanup {
~Cleanup() { /* 清理逻辑 */ }
};
};
工厂模式进阶
- 类型安全工厂：
cpp复制template<typename Base>
class GenericFactory {
using Creator = std::function<std::unique_ptr<Base>()>;
std::map<std::string, Creator> creators;
public:
template<typename Derived>
void registerClass(const std::string& name) {
creators[name] = [] { return std::make_unique<Derived>(); };
}
};
- 编译期工厂：
cpp复制template<typename... Products>
class CompileTimeFactory {
template<typename T>
static std::unique_ptr<T> create() { /*...*/ }
};
观察者模式优化
- 线程安全实现：
cpp复制template<typename... Args>
class Observable {
std::vector<std::function<void(Args...)>> observers;
mutable std::shared_mutex mtx;
public:
void subscribe(std::function<void(Args...)> f) {
std::unique_lock lock(mtx);
observers.push_back(f);
}
void notify(Args... args) {
std::shared_lock lock(mtx);
for (auto& obs : observers) {
obs(args...);
}
}
};
- 性能优化版本：
cpp复制class HighPerformanceObserver {
struct Node {
std::function<void()> callback;
Node* next = nullptr;
};
Node* head = nullptr;
MemoryPool pool;
};
4. 现代C++资源管理
4.1 智能指针深度优化
shared_ptr控制块剖析
- 控制块内存布局：
code复制+-------------------+
| 引用计数 (atomic) |
+-------------------+
| 弱引用计数 |
+-------------------+
| 删除器 |
+-------------------+
| 分配器 |
+-------------------+
- 定制分配器：
cpp复制auto customAlloc = [](size_t size) {
void* p = aligned_alloc(64, size);
return std::shared_ptr<void>(p, [](void* p) { free(p); });
};
std::shared_ptr<int> sp(new(customAlloc) int(10));
unique_ptr高级用法
- 自定义删除器：
cpp复制auto fileDeleter = [](FILE* f) { if(f) fclose(f); };
using FilePtr = std::unique_ptr<FILE, decltype(fileDeleter)>;
FilePtr openFile(const char* path) {
return FilePtr(fopen(path, "r"), fileDeleter);
}
- 类型擦除技巧：
cpp复制class AnyUniquePtr {
struct Concept {
virtual ~Concept() = default;
};
template<typename T>
struct Model : Concept {
std::unique_ptr<T> ptr;
};
std::unique_ptr<Concept> impl;
};
4.2 RAII模式扩展应用
文件资源管理
- 安全文件操作：
cpp复制class SafeFile {
int fd;
public:
explicit SafeFile(const char* path) : fd(open(path, O_RDONLY)) {
if (fd == -1) throw std::runtime_error("Open failed");
}
~SafeFile() { if (fd != -1) close(fd); }
// 移动语义支持
SafeFile(SafeFile&& other) : fd(other.fd) { other.fd = -1; }
};
网络连接管理
- 套接字包装：
cpp复制class SocketGuard {
SOCKET sock;
public:
explicit SocketGuard(SOCKET s = INVALID_SOCKET) : sock(s) {}
~SocketGuard() {
if (sock != INVALID_SOCKET) {
closesocket(sock);
}
}
// 释放所有权
SOCKET release() {
SOCKET tmp = sock;
sock = INVALID_SOCKET;
return tmp;
}
};
锁管理自动化
- 作用域锁模板：
cpp复制template<typename Mutex>
class ScopeLock {
Mutex& mtx;
public:
explicit ScopeLock(Mutex& m) : mtx(m) { mtx.lock(); }
~ScopeLock() { mtx.unlock(); }
// 禁止复制
ScopeLock(const ScopeLock&) = delete;
};
5. STL与泛型编程进阶
5.1 容器内部机制剖析
vector内存管理策略
- 扩容算法实现：
cpp复制template<typename T>
class Vector {
T* data;
size_t size;
size_t capacity;
void grow() {
size_t new_cap = capacity ? capacity * 2 : 1;
T* new_data = static_cast<T*>(operator new(new_cap * sizeof(T)));
// 移动构造元素
operator delete(data);
data = new_data;
capacity = new_cap;
}
};
unordered_map哈希冲突处理
- 桶迭代器实现：
cpp复制template<typename Key, typename Value>
class HashTable {
std::vector<std::list<std::pair<Key, Value>>> buckets;
size_t bucket_index(const Key& key) const {
return std::hash<Key>{}(key) % buckets.size();
}
};
5.2 算法性能优化
sort算法优化策略
-
内省排序实现：
- 快速排序递归深度过大时转为堆排序
- 小范围转为插入排序
-
自定义比较优化：
cpp复制struct Person {
std::string name;
int age;
};
void sortPeople(std::vector<Person>& people) {
std::sort(people.begin(), people.end(),
[](const Person& a, const Person& b) {
return a.age < b.age; // 按年龄排序
});
}
并行算法实践
- 执行策略选择：
cpp复制std::vector<int> data(1000000);
std::sort(std::execution::par, data.begin(), data.end());
5.3 Lambda表达式深入
Lambda实现原理
- 编译器生成类：
cpp复制// 对于 [capture](params) -> ret { body }
class Lambda_XXXX {
// 捕获成员
public:
ret operator()(params) const { body }
};
泛型Lambda技巧
- auto参数支持：
cpp复制auto generic = [](auto x, auto y) { return x + y; };
- 模板Lambda（C++20）：
cpp复制auto templateLambda = []<typename T>(T x) { /*...*/ };
6. 现代C++关键特性
6.1 类型推导最佳实践
auto使用准则
-
推荐场景：
- 迭代器类型
- 复杂模板类型
- lambda表达式类型
-
避免场景：
- 影响可读性的基础类型
- 需要显式转换的场合
decltype规则详解
- 值类别保留：
cpp复制int i = 0;
decltype(i) var1; // int
decltype((i)) var2; // int&
6.2 移动语义深入
完美转发实现
- 引用折叠示例：
cpp复制template<typename T>
void forwarder(T&& arg) {
target(std::forward<T>(arg));
}
移动构造函数优化
- 异常安全实现：
cpp复制class Moveable {
int* data;
public:
Moveable(Moveable&& other) noexcept
: data(std::exchange(other.data, nullptr)) {}
};
7. 并发编程模型
7.1 内存模型基础
原子操作保证
- 内存顺序选择：
cpp复制std::atomic<int> counter;
void increment() {
counter.fetch_add(1, std::memory_order_relaxed);
}
7.2 锁策略对比
互斥锁性能分析
- 自旋锁实现：
cpp复制class SpinLock {
std::atomic_flag flag;
public:
void lock() {
while (flag.test_and_set(std::memory_order_acquire));
}
void unlock() {
flag.clear(std::memory_order_release);
}
};
8. 异常安全与设计原则
8.1 异常安全等级
- 基本保证实现：
cpp复制class ExceptionSafe {
Resource* res;
public:
void method() {
Resource* newRes = new Resource;
delete res; // 可能抛出异常
res = newRes;
}
};
- 强保证实现：
cpp复制void strongGuarantee() {
auto backup = currentState;
try {
modifyState();
} catch (...) {
currentState = backup;
throw;
}
}
8.2 接口设计规范
- 契约式设计：
cpp复制template<typename T>
class Stack {
public:
void push(const T& item) {
assert(!full() && "Stack overflow");
// 实现
}
};
9. 性能优化专题
9.1 缓存友好设计
- 数据布局优化：
cpp复制struct BadLayout {
int key;
char padding[60];
int value;
};
struct GoodLayout {
int key;
int value;
char padding[56];
};
9.2 分支预测优化
- 可能性提示：
cpp复制if (__builtin_expect(condition, 1)) {
// 很可能执行的路径
}
10. 跨平台开发技巧
10.1 字节序处理
- 安全转换函数：
cpp复制uint32_t ntohl_safe(uint32_t net) {
static const union {
uint32_t i;
uint8_t c[4];
} test = {0x01020304};
return test.c[0] == 1 ? net :
((net & 0xFF) << 24) |
((net & 0xFF00) << 8) |
((net >> 8) & 0xFF00) |
((net >> 24) & 0xFF);
}
10.2 编译器特性利用
- 属性扩展：
cpp复制[[gnu::always_inline]] void criticalPath() {
// 强制内联
}
11. 调试与诊断技术
11.1 内存调试工具
- 自定义分配器：
cpp复制class DebugAllocator {
static std::map<void*, std::string> allocations;
public:
void* allocate(size_t size, const char* info) {
void* p = malloc(size);
allocations[p] = info;
return p;
}
void deallocate(void* p) {
allocations.erase(p);
free(p);
}
static void dumpLeaks() {
for (const auto& [ptr, info] : allocations) {
std::cerr << "Leak: " << info << std::endl;
}
}
};
11.2 性能分析技巧
- 微基准测试：
cpp复制void benchmark() {
auto start = std::chrono::high_resolution_clock::now();
// 测试代码
auto end = std::chrono::high_resolution_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << "μs\n";
}
12. C++20/23新特性前瞻
12.1 概念约束
- 模板参数约束：
cpp复制template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
template<Arithmetic T>
T square(T x) { return x * x; }
12.2 协程基础
- 生成器实现：
cpp复制generator<int> range(int start, int end) {
for (int i = start; i < end; ++i)
co_yield i;
}
13. 项目实战经验
13.1 大型项目架构
- 模块划分原则：
- 功能内聚性
- 接口最小化
- 编译防火墙
13.2 代码审查要点
- 常见问题检查表：
- 资源泄漏风险
- 线程安全问题
- 异常安全保证
- 性能热点
14. 性能调优案例
14.1 热点分析实例
- 缓存未命中优化：
cpp复制// 优化前
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
process(matrix[j][i]); // 列访问导致缓存效率低
}
}
// 优化后
for (int j = 0; j < M; ++j) {
for (int i = 0; i < N; ++i) {
process(matrix[j][i]); // 行访问提高缓存命中
}
}
14.2 算法优化实例
- 查找算法选择：
cpp复制// 小数据集
std::vector<int> smallData;
auto it = std::find(smallData.begin(), smallData.end(), value);
// 大数据集排序后
std::vector<int> largeData;
bool found = std::binary_search(largeData.begin(), largeData.end(), value);
15. 跨语言交互技术
15.1 C接口设计
- 兼容性包装：
cpp复制extern "C" {
struct CppObject;
CppObject* create_object() {
return reinterpret_cast<CppObject*>(new MyClass);
}
void use_object(CppObject* obj) {
reinterpret_cast<MyClass*>(obj)->method();
}
}
15.2 FFI集成
- Rust互操作：
cpp复制#[no_mangle]
pub extern "C" fn rust_function(input: i32) -> i32 {
input * 2
}
16. 代码生成技术
16.1 模板元编程
- 编译期计算：
cpp复制template<size_t N>
struct Factorial {
static constexpr size_t value = N * Factorial<N-1>::value;
};
template<>
struct Factorial<0> {
static constexpr size_t value = 1;
};
16.2 反射模拟
- 类型注册系统：
cpp复制class TypeInfo {
std::string name;
std::function<void*()> factory;
// ...
};
template<typename T>
class TypeRegistrar {
public:
TypeRegistrar(const std::string& name) {
TypeInfo info;
info.factory = [] { return new T; };
// 注册到全局表
}
};
17. 安全编程实践
17.1 缓冲区安全
- 安全字符串处理：
cpp复制void safeCopy(char* dest, const char* src, size_t destSize) {
if (destSize == 0) return;
size_t len = std::min(strlen(src), destSize - 1);
memcpy(dest, src, len);
dest[len] = '\0';
}
17.2 加密基础
- 哈希算法使用：
cpp复制#include <openssl/sha.h>
std::string sha256(const std::string& input) {
unsigned char hash[SHA256_DIGEST_LENGTH];
SHA256(reinterpret_cast<const unsigned char*>(input.data()),
input.size(), hash);
std::string result;
for (int i = 0; i < SHA256_DIGEST_LENGTH; ++i) {
result += fmt::format("{:02x}", hash[i]);
}
return result;
}
18. 测试驱动开发
18.1 单元测试框架
- 测试夹具设计：
cpp复制class DatabaseTest : public ::testing::Test {
protected:
void SetUp() override {
db.connect(":memory:");
}
void TearDown() override {
db.disconnect();
}
Database db;
};
TEST_F(DatabaseTest, InsertQuery) {
EXPECT_TRUE(db.execute("INSERT..."));
}
18.2 模拟对象
- 接口模拟实现：
cpp复制class MockNetwork : public NetworkInterface {
public:
MOCK_METHOD(bool, send, (const Packet&), (override));
MOCK_METHOD(Packet, receive, (), (override));
};
19. 持续集成实践
19.1 自动化构建
- CMake最佳实践：
cmake复制add_library(MyLibrary STATIC
src/file1.cpp
src/file2.cpp
)
target_include_directories(MyLibrary PUBLIC include)
target_compile_features(MyLibrary PUBLIC cxx_std_17)
19.2 静态分析集成
- 扫描工具配置：
yaml复制# .github/workflows/analysis.yml
jobs:
clang-tidy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- run: |
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..
run-clang-tidy
20. 领域特定设计
20.1 游戏开发模式
- 实体组件系统：
cpp复制class Entity {
std::vector<std::unique_ptr<Component>> components;
public:
template<typename T, typename... Args>
T& addComponent(Args&&... args) {
auto comp = std::make_unique<T>(std::forward<Args>(args)...);
auto& ref = *comp;
components.push_back(std::move(comp));
return ref;
}
};
20.2 金融计算优化
- 定点数实现：
cpp复制class FixedPoint {
int64_t value;
static constexpr int FRACTION_BITS = 16;
public:
FixedPoint(double d) : value(d * (1 << FRACTION_BITS)) {}
FixedPoint operator+(FixedPoint rhs) const {
return FixedPoint::fromRaw(value + rhs.value);
}
static FixedPoint fromRaw(int64_t raw) {
FixedPoint fp;
fp.value = raw;
return fp;
}
};
21. 嵌入式开发技巧
21.1 寄存器操作
- 类型安全封装：
cpp复制template<typename T, uintptr_t Addr>
class Register {
volatile T* const ptr = reinterpret_cast<T*>(Addr);
public:
T read() const { return *ptr; }
void write(T val) { *ptr = val; }
};
Register<uint32_t, 0x40021000> RCC_CR;
21.2 低功耗优化
- 休眠模式控制：
cpp复制void enterLowPower() {
asm volatile("wfi" ::: "memory");
}
22. 模板高级技巧
22.1 SFINAE应用
- 条件重载：
cpp复制template<typename T>
auto print(const T& val) -> decltype(std::cout << val, void()) {
std::cout << val;
}
template<typename T>
auto print(const T&) -> decltype(std::to_string(val), void()) {
std::cout << std::to_string(val);
}
22.2 变参模板
- 完美转发包装：
cpp复制template<typename... Args>
auto make_unique(Args&&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
23. 多范式编程
23.1 函数式风格
- 不可变数据结构：
cpp复制class ImmutableList {
struct Impl;
std::shared_ptr<Impl> impl;
public:
ImmutableList prepend(int value) const {
return ImmutableList(newNode(value));
}
};
23.2 元编程应用
- 类型列表处理：
cpp复制template<typename... Ts>
struct TypeList {};
template<typename List>
struct Front;
template<typename Head, typename... Tail>
struct Front<TypeList<Head, Tail...>> {
using type = Head;
};
24. 代码质量保证
24.1 静态断言
- 类型特性检查：
cpp复制template<typename T>
void process() {
static_assert(std::is_arithmetic_v<T>,
"T must be arithmetic type");
}
24.2 契约编程
- 前置条件检查：
cpp复制class Account {
public:
void withdraw(double amount) {
assert(balance >= amount && "Insufficient funds");
balance -= amount;
}
};
25. 工具链精通
25.1 编译器优化
- PGO实践：
bash复制# 生成分析数据
g++ -fprofile-generate -o app app.cpp
./app training_inputs
# 使用分析数据优化
g++ -fprofile-use -o app_optimized app.cpp
25.2 调试技巧
- 条件断点：
cpp复制for (int i = 0; i < 10000; ++i) {
// 只在i=5000时中断
if (i == 5000) {
asm volatile("int3");
}
}
26. 内存模型深入
26.1 原子操作内存序
- 顺序一致性：
cpp复制std::atomic<int> x, y;
int r1, r2;
void thread1() {
x.store(1, std::memory_order_seq_cst);
r1 = y.load(std::memory_order_seq_cst);
}
void thread2() {
y.store(1, std::memory_order_seq_cst);
r2 = x.load(std::memory_order_seq_cst);
}
26.2 无锁编程
- CAS模式：
cpp复制template<typename T>
class LockFreeStack {
struct Node { T value; Node* next; };
std::atomic<Node*> head;
public:
void push(const T& value) {
Node* new_node = new Node{value, nullptr};
new_node->next = head.load();
while (!head.compare_exchange_weak(new_node->next, new_node));
}
};
27. 异常处理策略
27.1 错误码设计
- 强类型错误码：
cpp复制enum class DatabaseError {
ConnectionFailed,
QueryTimeout,
ConstraintViolation
};
std::error_code make_error_code(DatabaseError e);
27.2 异常安全事务
- 范围保护：
cpp复制class Transaction {
Database& db;
bool committed = false;
public:
explicit Transaction(Database& d) : db(d) {
db.begin();
}
~Transaction() {
if (!committed) db.rollback();
}
void commit() {
db.commit();
committed = true;
}
};
28. 标准库扩展
28.1 自定义分配器
- 内存池分配器：
cpp复制template<typename T>
class PoolAllocator {
static MemoryPool pool;
public:
T* allocate(size_t n) {
return static_cast<T*>(pool.allocate(n * sizeof(T)));
}
void deallocate(T* p, size_t n) {
pool.deallocate(p, n * sizeof(T));
}
};
28.2 扩展算法
- 并行查找：
cpp复制template<typename It, typename Pred>
It parallel_find(It first, It last, Pred pred) {
// 实现任务分割和并行查找
}
29. 多线程调试
29.1 死锁检测
- 锁顺序验证：
cpp复制class LockOrderValidator {
static thread_local std::vector<Lock*> heldLocks;
static std::map<Lock*, int> lockOrders;
public:
void beforeLock(Lock* lock) {
for (auto held : heldLocks) {
if (lockOrders[held] >= lockOrders[lock]) {
reportDeadlockRisk();
}
}
}
};
29.2 竞态条件捕获
- 数据竞争检测：
cpp复制template<typename T>
class RaceDetector {
T value;
std::thread::id owner;
public:
T operator=(T newVal) {
if (owner != std::thread::id() &&
owner != std::this_thread::get_id()) {
reportDataRace();
}
value = newVal;
owner = std::this_thread::get