1. 现代C++与并发编程核心概念解析
这份模拟试卷涵盖了现代C++和并发编程中的关键知识点，对于中高级C++开发者来说具有重要的学习价值。我们将从实际应用角度深入分析这些题目背后的技术原理。
1.1 移动语义与右值引用
移动语义是现代C++的重要特性，std::move的本质是将左值转换为右值引用，而非真正移动对象。在实际编码中，理解这一点至关重要：
cpp复制std::string str1 = "Hello";
std::string str2 = std::move(str1);
// str1现在处于有效但未定义状态
移动构造函数应标记为noexcept，这对标准容器优化至关重要。当vector需要扩容时，如果元素的移动构造函数是noexcept的，vector会优先使用移动而非拷贝。
1.2 容器与迭代器安全性
STL容器的迭代器失效问题是实际开发中的常见陷阱。以vector为例：
cpp复制std::vector<int> v = {1,2,3,4,5};
auto it = v.begin() + 2;
v.erase(v.begin()); // it失效！
// 此时解引用it是未定义行为
经验法则：任何可能引起内存重新分配的操作（insert/erase/push_back等）都会使迭代器失效。在循环中修改容器时，要特别注意迭代器有效性。
2. 并发编程核心机制剖析
2.1 原子操作与内存序
std::atomic提供原子操作保证，但不同内存序的语义差异很大：
cpp复制std::atomic<int> counter(0);
void increment() {
counter.fetch_add(1, std::memory_order_relaxed); // 最宽松，无同步
counter.fetch_add(1, std::memory_order_release); // 释放语义
counter.fetch_add(1, std::memory_order_seq_cst); // 顺序一致性(默认)
}
实际开发建议：
- 默认使用memory_order_seq_cst（最安全）
- 性能关键路径可考虑relaxed，但需充分理解happens-before关系
- acquire/release配对使用可实现高效同步
2.2 线程同步原语
现代C++提供了丰富的同步工具：
cpp复制// 互斥锁（最基础）
std::mutex mtx;
{
std::lock_guard<std::mutex> lock(mtx);
// 临界区
}
// 读写锁（C++14）
std::shared_mutex smtx;
{
std::shared_lock<std::shared_mutex> read_lock(smtx); // 共享读
std::unique_lock<std::shared_mutex> write_lock(smtx); // 独占写
}
// 条件变量
std::condition_variable cv;
cv.wait(lock, []{ return ready; }); // 避免虚假唤醒
3. 现代C++特性深度应用
3.1 智能指针与资源管理
智能指针的正确使用能有效避免资源泄漏：
cpp复制// 独占所有权
std::unique_ptr<Resource> res1 = std::make_unique<Resource>();
// 共享所有权（引用计数）
std::shared_ptr<Resource> res2 = std::make_shared<Resource>();
// 弱引用（打破循环引用）
std::weak_ptr<Resource> weak = res2;
if(auto shared = weak.lock()) {
// 使用shared
}
循环引用是常见问题，典型场景：
cpp复制class A {
std::shared_ptr<B> b_ptr;
};
class B {
std::shared_ptr<A> a_ptr; // 循环引用！
};
// 解决方案：将其中一个改为weak_ptr
3.2 C++17/20新特性实战
新标准带来的重要改进：
cpp复制// std::optional（C++17）
std::optional<int> find(int key) {
if(key == 42) return 42;
return std::nullopt;
}
// std::variant（C++17）
std::variant<int, std::string> v = "hello";
std::visit([](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, int>) { /*...*/ }
else if constexpr (std::is_same_v<T, std::string>) { /*...*/ }
}, v);
// Concept（C++20）
template<typename T>
concept Integral = std::is_integral_v<T>;
template<Integral T>
T add(T a, T b) { return a + b; }
4. 并发编程模式与最佳实践
4.1 线程安全数据结构实现
实现线程安全队列的几种方式：
cpp复制// 基于互斥锁的简单实现
template<typename T>
class ThreadSafeQueue {
std::queue<T> data;
mutable std::mutex mtx;
std::condition_variable cv;
public:
void push(T value) {
std::lock_guard<std::mutex> lock(mtx);
data.push(std::move(value));
cv.notify_one();
}
std::optional<T> pop() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]{ return !data.empty(); });
T value = std::move(data.front());
data.pop();
return value;
}
};
// 无锁队列（更复杂但性能更高）
// 通常基于原子操作和CAS实现
4.2 异步编程模型
现代C++提供了多种异步编程方式：
cpp复制// std::async + std::future
auto future = std::async(std::launch::async, []{
return compute();
});
auto result = future.get();
// std::promise + std::future
std::promise<int> p;
auto f = p.get_future();
std::thread([&p]{ p.set_value(42); }).detach();
auto r = f.get();
// C++20协程
task<int> compute() {
co_await some_async_op();
co_return 42;
}
5. 性能优化与陷阱规避
5.1 避免常见性能问题
容器使用中的优化技巧：
cpp复制// 预先分配内存
std::vector<int> vec;
vec.reserve(1000); // 避免多次扩容
// 使用emplace_back替代push_back
vec.emplace_back(42); // 避免临时对象构造
// 高效过滤算法
std::vector<int> filter(const std::vector<int>& input) {
std::vector<int> result;
std::copy_if(input.begin(), input.end(),
std::back_inserter(result),
[](int x){ return x % 2 == 0; });
return result;
}
5.2 死锁预防与调试
死锁的四种必要条件：
- 互斥条件
- 占有并等待
- 非抢占条件
- 循环等待
预防死锁的策略：
cpp复制// 1. 固定加锁顺序
void transaction(Account& a, Account& b) {
std::lock_guard<std::mutex> lock1(a.mtx);
std::lock_guard<std::mutex> lock2(b.mtx);
// 操作a和b
}
// 2. 使用std::lock同时锁定多个互斥量
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
// 3. 使用超时锁
std::unique_lock<std::mutex> lock(mtx, std::chrono::milliseconds(100));
if(lock) { /* 获取锁成功 */ }
6. 现代C++工程实践建议
6.1 资源管理准则
- 优先使用智能指针而非裸指针
- 遵循RAII原则管理所有资源
- 避免全局变量，使用依赖注入
- 模块间通过接口而非具体类交互
6.2 并发编程最佳实践
- 最小化临界区范围
- 避免在锁内执行耗时操作
- 优先使用高级抽象（如任务队列）
- 谨慎使用线程局部存储(TLS)
- 充分测试多线程场景
6.3 代码质量保障
- 使用静态分析工具（Clang-Tidy等）
- 编写全面的单元测试
- 进行压力测试和竞态检测
- 使用AddressSanitizer等工具检测内存问题
在现代C++开发中，深入理解语言特性和并发模型是写出高效、安全代码的基础。这份试卷涵盖的知识点需要在实际项目中不断实践和深化，才能真正掌握其精髓。