1. 共享指针
#include <atomic>
#include <iostream>
template <typename T> class sharedptr {
private:
T *ptr;
std::atomic<size_t> *count;
public:
sharedptr(T *p) : ptr(p), count(new std::atomic<size_t>(1)) {}
sharedptr(const sharedptr &other) : ptr(other.ptr), count(other.count) {
(*count)++;
}
sharedptr(sharedptr &&other) : ptr(other.ptr), count(other.count) {
other.ptr = nullptr;
other.count = nullptr;
}
// 拷贝赋值运算符
// 何时调用？当用一个 已存在的对象（左值）
// 赋值给另一个已存在的对象时： Myclass a,b;
sharedptr &operator=(const sharedptr &other) {
if (this != &other) {
release();
ptr = other.ptr;
count = other.count;
(*count)++;
}
return *this;
}
// 移动赋值运算符
sharedptr &operator=(sharedptr &&other) {
if (this != &other) {
ptr = other.ptr;
count = other.count;
other.ptr = nullptr;
other.count = nullptr;
}
return *this;
}
void release() {
if (count != nullptr && (--(*count)) == 0) {
delete ptr;
delete count;
}
}
~sharedptr() { release(); }
T *operator->() { return ptr; }
T &operator*() { return *ptr; }
};
int main() {}1. 快速记忆
双成员结构：
T* ptr管理资源atomic<size_t>* count保证线程安全
五大特殊函数：
// 1. 构造 explicit Shared_Ptr(T* p = nullptr) // 2. 拷贝构造 Shared_Ptr(const Shared_Ptr&) // 3. 移动构造（noexcept优化） Shared_Ptr(Shared_Ptr&&) noexcept // 4. 拷贝赋值（自检+释放旧值：等号左） operator=(const Shared_Ptr&) // 5. 移动赋值（自检+释放旧值：等号右） operator=(Shared_Ptr&&) noexcept建议手写时按以下顺序实现
成员变量
- 构造函数
- 拷贝构造/赋值
- 移动构造/赋值
- 析构函数
- 操作符重载
- 辅助方法
2. 多线程交替打印
代码：
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
int m;
std::mutex mtx;
std::condition_variable cv;
void print(int target) {
for (int i = 0; i < 10; i++) {
// 这行代码相当重要
std::unique_lock<std::mutex> lock(mtx);
// 条件谓词不接受参数
cv.wait(lock, [&]() { return m == target; });
std::cout << m << std::endl;
m = (m + 1) % 3;
cv.notify_all();
}
}
int main() {
m = 0;
std::thread t1(print, 0);
std::thread t2(print, 1);
std::thread t3(print, 2);
t1.join();
t2.join();
t3.join();
}1. std::unique_lock<std::mutex>对象lock和std::mutex对象mtx是什么关系？
std::unique_lock<std::mutex> 是一个管理互斥量（std::mutex）的 RAII（资源获取即初始化）包装器。两者的关系如下：
绑定关系：当你创建一个
std::unique_lock<std::mutex>对象时，通常会将一个std::mutex对象（比如mtx）传递给它。此时，unique_lock会自动尝试锁定这个互斥量。自动管理：
unique_lock在其生命周期内拥有并管理这个mtx的锁定状态。当unique_lock对象销毁时（例如超出作用域），它会自动解锁mtx，避免手动解锁带来的错误风险。灵活性：与
std::lock_guard相比，unique_lock提供了更多的灵活性，比如能够延迟锁定、手动解锁或重新锁定，以及支持条件变量等待时的锁管理。个人理解：所谓mutex(mutual exclusion)，本身仅是声明了一个互斥量，此时并不包含锁的意义
2. 简述一下cv.wait和notify做了什么？
cv.wait
等待与解锁：调用
cv.wait(lock, predicate)时，线程会进入等待状态，同时自动释放传入的std::unique_lock持有的互斥量。这使得其他线程可以获得该互斥量，从而修改共享数据。阻塞与恢复：当等待的条件（通常由传入的 lambda 表达式 predicate 检查）不满足时，线程会一直阻塞。待其他线程调用
notify方法后，等待线程会被唤醒并重新尝试获取锁，随后检查条件，直到条件满足为止。
notify
唤醒等待线程：
cv.notify_one()会唤醒一个正等待此条件变量的线程，而cv.notify_all()则会唤醒所有等待的线程。同步机制：当某个线程修改了共享数据并满足了等待线程所期望的条件后，它会调用
notify方法通知等待线程，促使它们从阻塞状态中恢复，继续执行。
3. LRU缓存
class LRUCache {
private:
int capacity;
list<pair<int,int>> mylist;
unordered_map<int,list<pair<int,int>>::iterator> umap;
public:
LRUCache(int capacity):capacity(capacity) {
}
int get(int key) {
if(umap.find(key)==umap.end()) {return -1;}
int value=umap[key]->second;
mylist.erase(umap[key]);
mylist.push_front({key,value});
umap[key]=mylist.begin();
return value;
}
void put(int key, int value) {
if(umap.find(key)!=umap.end()){
mylist.erase(umap[key]);
mylist.push_front({key,value});
umap[key]=mylist.begin();
} else{
if(umap.size()==capacity){
// 不能直接删除end()
// umap.erase(mylist.end());
int old_key=mylist.back().first;
umap.erase(old_key);
mylist.pop_back();
}
mylist.push_front({key,value});
umap[key]=mylist.begin();
}
}
};