C++ 核心面试题与底层原理详解 | 极客日志

C++ 核心面试题与底层原理详解 | 极客日志

shared_ptr

unique_ptr

class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance; // C++11 保证线程安全
        return instance;
    }
};

void quickSort(vector<int>& a, int l, int r) {
    if (l >= r) return;
    int i = l, j = r, pivot = a[l];
    while (i < j) {
        while (i < j && a[j] >= pivot) j--;
        while (i < j && a[i] <= pivot) i++;
        if (i < j) swap(a[i], a[j]);
    }
    swap(a[l], a[i]);
    quickSort(a, l, i - 1);
    quickSort(a, i + 1, r);
}

int binarySearch(vector<int>& nums, int target) {
    int l = 0, r = nums.size() - 1;
    while (l <= r) {
        int mid = l + (r - l) / 2;
        if (nums[mid] == target) return mid;
        else if (nums[mid] < target) l = mid + 1;
        else r = mid - 1;
    }
    return -1;
}

class Buffer {
    size_t n_;
    int* data_;
public:
    Buffer(size_t n = 0) : n_(n), data_(n ? new int[n]() : nullptr) {}
    ~Buffer() { delete[] data_; }

    // copy
    Buffer(const Buffer& o) : n_(o.n_), data_(o.n_ ? new int[o.n_] : nullptr) {
        std::copy(o.data_, o.data_ + n_, data_);
    }
    Buffer& operator=(Buffer o) { // copy-and-swap 提供强异常安全
        swap(*this, o);
        return *this;
    }

    // move
    Buffer(Buffer&& o) noexcept : n_(o.n_), data_(o.data_) {
        o.n_ = 0; o.data_ = nullptr;
    }
    Buffer& operator=(Buffer&& o) noexcept {
        if (this != &o) {
            delete[] data_;
            n_ = o.n_; data_ = o.data_;
            o.n_ = 0; o.data_ = nullptr;
        }
        return *this;
    }

    friend void swap(Buffer& a, Buffer& b) noexcept {
        using std::swap;
        swap(a.n_, b.n_);
        swap(a.data_, b.data_);
    }
};

template<typename T>
void push_back_emplace(std::vector<T>& v, T&& val) {
    v.emplace_back(std::forward<T>(val)); // 保持传入值类别
}

int a = INT_MAX;
int b = a + 1; // 有符号溢出 —— UB（不要假设会 wrap-around）

MySingleton& instance() {
    static MySingleton inst; // C++11 保证线程安全的局部静态初始化
    return inst;
}

std::mutex mu;
std::condition_variable cv;
std::queue<int> q;

void producer() {
    {
        std::lock_guard lk(mu);
        q.push(42);
    }
    cv.notify_one();
}

void consumer() {
    std::unique_lock lk(mu);
    cv.wait(lk, []{ return !q.empty(); });
    int v = q.front();
    q.pop();
}

class LRUCache {
    int cap;
    list<int> keys;
    unordered_map<int, pair<int, list<int>::iterator>> mp;
public:
    LRUCache(int capacity) : cap(capacity) {}

    int get(int k) {
        auto it = mp.find(k);
        if (it == mp.end()) return -1;
        keys.splice(keys.begin(), keys, it->second.second);
        return it->second.first;
    }

    void put(int k, int v) {
        auto it = mp.find(k);
        if (it != mp.end()) {
            it->second.first = v;
            keys.splice(keys.begin(), keys, it->second.second);
            return;
        }
        if ((int)mp.size() == cap) {
            int old = keys.back();
            keys.pop_back();
            mp.erase(old);
        }
        keys.push_front(k);
        mp[k] = {v, keys.begin()};
    }
};

class S {
public:
    static S& instance() {
        static std::once_flag f;
        static S* p = nullptr;
        std::call_once(f, []{ p = new S(); });
        return *p;
    }
private:
    S() = default;
};