+ leetcode

Author: wxggg

c++/my_shared_ptr.hh

@@ -0,0 +1,55 @@
+#include <iostream>
+
+namespace wxg {
+
+template <typename T>
+class my_shared_ptr {
+   private:
+    T *m_ptr = nullptr;
+
+    int *refcount = 0;
+
+   public:
+    explicit my_shared_ptr(T *p) : m_ptr(p), refcount(new int(1);) {}
+    my_shared_ptr(my_shared_ptr &&p)
+        : m_ptr(p.m_ptr), refcount(new int(1)) noexcept {
+        p.m_ptr = nullptr;
+    }
+
+    my_shared_ptr(const my_shared_ptr &p) noexcept {
+        m_ptr = p.m_ptr;
+        refcount = p.refcount;
+        ++*refcount;
+    }
+
+    my_shared_ptr &operator=(const my_shared_ptr &p) noexcept {
+        if (m_ptr && --*refcount == 0) {
+            delete m_ptr, delete refcount;
+        }
+
+        m_ptr = p.m_ptr;
+        refcount = p.refcount;
+        ++*refcount;
+    }
+
+    inline my_shared_ptr<T> &operator=(my_shared_ptr &&p) noexcept {
+        return operator=(p);
+    }
+
+    explicit operator bool() const noexcept { return m_ptr; }
+
+    ~my_shared_ptr() noexcept {
+        if (--*refcount == 0 && m_ptr) {
+            delete m_ptr;
+            delete refcount;
+        }
+    }
+
+    inline T &operator*() const noexcept { return *get(); }
+    inline T *operator->() const noexcept { return get(); }
+
+    inline T *get() const noexcept { return m_ptr; }
+
+    inline void swap(my_shared_ptr &p) noexcept { std::swap(p.m_ptr, m_ptr); }
+};
+}  // namespace wxg

c++/my_string.hh

@@ -0,0 +1,36 @@
+#include <string.h>
+#include <iostream>
+
+namespace wxg {
+
+class my_string {
+   private:
+    char *data_;
+
+   public:
+    my_string() : data_(new char[1]) { *data_ = '\0'; }
+    my_string(const char *str) : data_(new char[strlen(str) + 1]) {
+        strcpy(data_, str);
+    }
+    my_string(const my_string &rhs) : data_(new char[rhs.size() + 1]) {
+        strcpy(data_, rhs.data_);
+    }
+    my_string(my_string &&rhs) : data_(rhs.data_) { rhs.data_ = nullptr; }
+    ~my_string() { delete[] data_; }
+
+    my_string &operator=(my_string rhs) {
+        std::swap(data_, rhs.data_);
+        return *this;
+    }
+    my_string &operator=(my_string &&rhs) {
+        std::swap(data_, rhs.data_);
+        return *this;
+    }
+
+    inline size_t size() const { return strlen(data_) + 1; }
+    inline size_t length() const { return size(); }
+    inline char *c_str() const { return data_; }
+    inline void swap(my_string &rhs) { std::swap(data_, rhs.data_); }
+};
+
+}  // namespace wxg

c++/my_unique_ptr.hh

@@ -0,0 +1,49 @@
+#include <iostream>
+
+namespace wxg {
+
+template <typename T>
+class my_unique_ptr {
+   private:
+    T *m_ptr = nullptr;
+
+   public:
+    explicit my_unique_ptr(T *p) : m_ptr(p) {}
+    my_unique_ptr(my_unique_ptr &&p) : m_ptr(p.m_ptr) noexcept {
+        p.m_ptr = nullptr;
+    }
+
+    my_unique_ptr(const my_unique_ptr &) = delete;
+    my_unique_ptr &operator=(const my_unique_ptr &) = delete;
+    explicit operator bool() const noexcept { return m_ptr; }
+
+    ~my_unique_ptr() {
+        if (m_ptr) delete m_ptr;
+    }
+
+    inline my_unique_ptr<T> &operator=(my_unique_ptr &&p) noexcept {
+        std::swap(*this, p);
+        return *this;
+    }
+
+    inline T &operator*() const { return *get(); }
+    inline T *operator->() const { return get(); }
+
+    inline void reset(T *q = nullptr) noexcept {
+        if (q != m_ptr) {
+            if (m_ptr) delete m_ptr;
+            m_ptr = q;
+        }
+    }
+
+    inline T *release() noexcept {
+        T *res = m_ptr;
+        m_ptr = nullptr;
+        return res;
+    }
+
+    inline T *get() const noexcept { return m_ptr; }
+
+    inline void swap(my_unique_ptr &p) noexcept { std::swap(p.m_ptr, m_ptr); }
+};
+}  // namespace wxg

c++/rw_lock.hh

@@ -0,0 +1,111 @@
+#include <condition_variable>
+#include <mutex>
+
+using Lock = std::unique_lock<std::mutex>;
+
+/**
+ * implement with unique_lock and condition_variable
+ * read first
+ */
+class readwrite_lock_1 {
+   public:
+    readwrite_lock_1() : stat(0) {}
+
+    void readLock() {
+        Lock lock(mutex);
+        while (stat < 0) cv.wait(lock);
+        ++stat;
+    }
+
+    void readUnlock() {
+        Lock lock(mutex);
+        if (--stat == 0) cv.notify_one();  // 叫醒一个等待的写操作
+    }
+
+    void writeLock() {
+        Lock lock(mutex);
+        while (stat != 0) cv.wait(lock);
+        stat = -1;
+    }
+
+    void writeUnlock() {
+        Lock lock(mutex);
+        stat = 0;
+        cv.notify_all();  // 叫醒所有等待的读和写操作
+    }
+
+   private:
+    std::mutex mutex;
+    std::condition_variable cv;
+    int stat;  // == 0 无锁；> 0 已加读锁个数；< 0 已加写锁
+};
+
+/**
+ * implement with two mutex
+ * read first
+ */
+class readwrite_lock_2 {
+   public:
+    readwrite_lock_2() : read_cnt(0) {}
+
+    void readLock() {
+        read_mtx.lock();
+        if (++read_cnt == 1) write_mtx.lock();
+
+        read_mtx.unlock();
+    }
+
+    void readUnlock() {
+        read_mtx.lock();
+        if (--read_cnt == 0) write_mtx.unlock();
+
+        read_mtx.unlock();
+    }
+
+    void writeLock() { write_mtx.lock(); }
+    void writeUnlock() { write_mtx.unlock(); }
+
+   private:
+    std::mutex read_mtx;
+    std::mutex write_mtx;
+    int read_cnt;  // 已加读锁个数
+};
+
+/**
+ * implement with mutex and condition_variable
+ * write first
+ */
+class readwrite_lock_3 {
+   private:
+    std::mutex mutex;
+    std::condition_variable cv;
+    int rd_cnt;  //等待读的数量
+    int wr_cnt;  //等待写的数量
+
+   public:
+    readwrite_lock_3() : rd_cnt(0), wr_cnt(0) {}
+
+    void readLock() {
+        Lock lock(mutex);
+        ++rd_cnt;
+        while (wr_cnt > 0) cv.wait(lock);
+    }
+
+    void readUnlock() {
+        Lock lock(mutex);
+        --rd_cnt;
+        if (rd_cnt == 0) cv.notify_all();
+    }
+
+    void writeLock() {
+        Lock lock(mutex);
+        ++wr_cnt;
+        while (wr_cnt + rd_cnt >= 2) cv.wait(lock);
+    }
+
+    void writerUnlock() {
+        Lock lock(mutex);
+        --wr_cnt;
+        if (wr_cnt == 0) cv.notify_all();
+    }
+};