Week 11 (#13)

* Add task 09.09

* Add task 09.05 unique pointer

* Add task 09.06 shared pointer

* Add task 09.11 two-linked list

* Fix shared_ptr cycle in List

* task 09.02: logger implementation

* task 09.14: odd iterator

Author: c71n93

.clang-tidy

@@ -5,6 +5,7 @@ Checks:     '
     misc-const-correctness,
     -readability-identifier-length,
     -readability-else-after-return,
+    -readability-qualified-auto,
     -readability-math-missing-parentheses
             '
 CheckOptions:

CMakeLists.txt

@@ -56,8 +56,13 @@ function(cpp_test SOURCE_NAME)
     add_dependencies(all-tests ${TARGET_NAME}-run)
 endfunction(cpp_test)
 
+
+##### shared library #####
+include_directories(shared)
+
+
 ##### subdirectories #####
-set(DIRS week-W week-2 week-3 week-4 week-5 week-6 week-7 week-8 week-9 week-10)
+set(DIRS week-W week-2 week-3 week-4 week-5 week-6 week-7 week-8 week-9 week-10 week-11)
 foreach(DIR ${DIRS})
     add_subdirectory(${DIR})
 endforeach()

shared/noncopyable.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace share::util {
+
+class NonCopyable {
+protected:
+    NonCopyable() = default;
+
+public:
+    NonCopyable(const NonCopyable& other) = delete;
+    NonCopyable& operator=(const NonCopyable& other) = delete;
+};
+
+}  // namespace share::util

week-11/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(DIRS task-09-09 task-09-05 task-09-06 task-09-11 task-09-02 task-09-14)
+foreach(DIR ${DIRS})
+    add_subdirectory(${DIR})
+endforeach()

week-11/task-09-02/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+
+add_subdirectory(test)

week-11/task-09-02/include/logger.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cassert>
+#include <iostream>
+#include <source_location>
+
+#include "noncopyable.hpp"
+
+namespace logger {
+
+class Logger : share::util::NonCopyable {
+public:
+    explicit Logger(const std::source_location location = std::source_location::current())
+        : loc_(location) {
+        for (int i = 0; i < nesting; ++i) {
+            std::cout << "  ";
+        }
+        std::cout << "\033[1;34m[Logger]\033[0m Begin  function " << loc_.function_name()
+                  << std::endl;
+        ++nesting;
+    }
+
+    ~Logger() {
+        --nesting;
+        assert(nesting >= 0);
+        for (int i = 0; i < nesting; ++i) {
+            std::cout << "  ";
+        }
+        std::cout << "\033[1;33m[Logger]\033[0m End of function " << loc_.function_name()
+                  << std::endl;
+    }
+
+private:
+    std::source_location loc_;
+
+    static int nesting;
+};
+
+int Logger::nesting = 0;
+
+}  // namespace logger

week-11/task-09-02/test/CMakeLists.txt

@@ -0,0 +1 @@
+cpp_test(test-09-02.cpp)

week-11/task-09-02/test/test-09-02.cpp

@@ -0,0 +1,19 @@
+#include <gtest/gtest.h>
+
+#include <source_location>
+
+#include "logger.hpp"
+
+using logger::Logger;
+
+void foo() { const Logger logger{}; }
+
+void bar() {
+    const Logger logger{};
+    foo();
+}
+
+TEST(Logger, logs) {
+    const Logger log{};
+    bar();
+}

week-11/task-09-05/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+
+add_subdirectory(test)

week-11/task-09-05/include/unique.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#include "noncopyable.hpp"
+#include "utility"
+
+namespace memory {
+
+template <typename T>
+class Unique : private share::util::NonCopyable {
+public:
+    explicit Unique(T* ptr = nullptr) : data_(ptr) {}
+    template <typename U>
+        requires std::convertible_to<U*, T*>
+    explicit Unique(Unique<U>&& other) : Unique() {
+        data_ = other.release();
+    }
+    Unique(Unique&& other) : Unique() { swap(other); }
+
+    template <typename U>
+        requires std::convertible_to<U*, T*>
+    auto& operator=(Unique<U>&& other) {
+        reset(other.release());
+        return *this;
+    }
+    auto& operator=(Unique&& other) noexcept {
+        reset(other.release());
+        return *this;
+    }
+
+    ~Unique() { reset(); }
+
+    void swap(Unique& other) { std::swap(data_, other.data_); }
+    T* get() const { return data_; }
+    T* release() { return std::exchange(data_, nullptr); }
+    void reset(T* ptr = nullptr) {
+        delete data_;
+        data_ = ptr;
+    }
+
+    T& operator*() const { return *get(); }
+    T* operator->() const { return get(); }
+    explicit operator bool() const { return get() != nullptr; }
+
+private:
+    T* data_ = nullptr;
+};
+
+template <typename T, typename... Ts>
+auto make_unique(Ts&&... xs) {
+    return Unique<T>(new T(std::forward<Ts>(xs)...));
+}
+
+}  // namespace memory

week-11/task-09-05/test/CMakeLists.txt

@@ -0,0 +1 @@
+cpp_test(test-09-05.cpp)

week-11/task-09-05/test/test-09-05.cpp

@@ -0,0 +1,105 @@
+#include <gtest/gtest.h>
+
+#include "unique.hpp"
+
+using memory::Unique;
+
+class Base {
+public:
+    explicit Base(int a) : a_(a) {}
+    virtual ~Base() {}
+
+    int a_;
+};
+
+class Derived : public Base {
+public:
+    Derived(int a, int b) : Base(a), b_(b) {}
+
+    int b_;
+};
+
+TEST(UniquePtr, DefaultConstructor) {
+    const Unique<int> ptr;
+    EXPECT_EQ(ptr.get(), nullptr);
+}
+
+TEST(UniquePtr, ConstructorWithValue) {
+    const Unique<int> ptr(new int(42));
+    EXPECT_EQ(*ptr, 42);
+}
+
+TEST(UniquePtr, ConstructorWithValueInheritance) {
+    const Unique<Base> ptr(new Derived(41, 42));
+    EXPECT_EQ(ptr->a_, 41);
+    EXPECT_EQ(dynamic_cast<Derived*>(ptr.get())->b_, 42);
+}
+
+TEST(UniquePtr, MoveConstructor) {
+    Unique<int> ptr1(new int(42));  // NOLINT
+    const Unique<int> ptr2(std::move(ptr1));
+    EXPECT_EQ(*ptr2, 42);
+    EXPECT_EQ(ptr1.release(), nullptr);  // NOLINT
+}
+
+TEST(UniquePtr, MoveConstructorInheritance) {
+    Unique<Derived> ptr_derived(new Derived(41, 42));  // NOLINT
+    const Unique<Base> ptr_base(std::move(ptr_derived));
+    EXPECT_EQ(ptr_base->a_, 41);
+    EXPECT_EQ(dynamic_cast<Derived*>(ptr_base.get())->b_, 42);
+    EXPECT_EQ(ptr_derived.release(), nullptr);  // NOLINT
+}
+
+TEST(UniquePtr, MoveAssignment) {
+    Unique<int> ptr1(new int(42));  // NOLINT
+    Unique<int> ptr2;
+    ptr2 = std::move(ptr1);
+    EXPECT_EQ(*ptr2, 42);
+    EXPECT_EQ(ptr1.release(), nullptr);  // NOLINT
+}
+
+TEST(UniquePtr, MoveAssignmentInheritance) {
+    Unique<Derived> ptr_derived(new Derived(41, 42));  // NOLINT
+    Unique<Base> ptr_base;
+    ptr_base = std::move(ptr_derived);
+    EXPECT_EQ(ptr_base->a_, 41);
+    EXPECT_EQ(dynamic_cast<Derived*>(ptr_base.get())->b_, 42);
+    EXPECT_EQ(ptr_derived.release(), nullptr);  // NOLINT
+}
+
+TEST(UniquePtr, Reset) {
+    Unique<int> ptr(new int(42));  // NOLINT
+    ptr.reset(new int(99));        // NOLINT
+    EXPECT_EQ(*ptr, 99);
+    ptr.reset();
+    EXPECT_EQ(ptr.get(), nullptr);
+}
+
+TEST(UniquePtr, Release) {
+    Unique<int> ptr(new int(42));  // NOLINT
+    int* raw = ptr.release();
+    EXPECT_EQ(*raw, 42);
+    EXPECT_EQ(ptr.get(), nullptr);
+    delete raw;
+}
+
+TEST(UniquePtr, Swap) {
+    Unique<int> ptr1(new int(42));  // NOLINT
+    Unique<int> ptr2(new int(99));  // NOLINT
+    ptr1.swap(ptr2);
+    EXPECT_EQ(*ptr1, 99);
+    EXPECT_EQ(*ptr2, 42);
+}
+
+TEST(UniquePtr, BooleanConversion) {
+    const Unique<int> ptr1(new int(42));  // NOLINT
+    const Unique<int> ptr2;
+    EXPECT_TRUE(ptr1);
+    EXPECT_FALSE(ptr2);
+}
+
+TEST(UniquePtr, ArrowOperator) {
+    const Unique<Derived> ptr(new Derived(41, 42));  // NOLINT
+    EXPECT_EQ(ptr->a_, 41);
+    EXPECT_EQ(ptr->b_, 42);
+}

week-11/task-09-06/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+
+add_subdirectory(test)