Finish

Author: Zane-Liao

assign7/main.cpp

@@ -8,6 +8,8 @@
 #include <sstream>
 #include <unordered_map>
 #include <vector>
+#include <ranges> // std::views
+// #include <memory> // smart pointer
 
 #include "unique_ptr.h"
 
@@ -52,7 +54,15 @@ template <typename T> struct ListNode {
  */
 template <typename T> cs106l::unique_ptr<ListNode<T>> create_list(const std::vector<T>& values) {
   /* STUDENT TODO: Implement this method */
-  throw std::runtime_error("Not implemented: createList");
+  cs106l::unique_ptr<ListNode<T>> head = nullptr;
+  for (const auto& element : std::views::reverse(values)) {
+    auto node = cs106l::make_unique<ListNode<T>>(element);
+    // node->value = element;
+    node->next = std::move(head);
+    head = std::move(node);
+  }
+
+  return head;
 }
 
 /**

assign7/short_answer.txt

@@ -5,13 +5,21 @@ Unique Pointer
 --------------
 
 Q1. List one or two benefits of using RAII to manage memory instead manually calling `new` and `delete`.
-A1. TODO
+A1. No need to necessary manager memory to avoid forgetting to delete and 
+causing memory leak.
 
-Q2. When implementing move semantics for a `unique_ptr`, for example in the move constructor `unique_ptr(unique_ptr&& other)`, it is essential that we set the underlying pointer of the `other` parameter to `nullptr` before exiting the function. Explain in your own words what problem would arise if we did not.
-A2. TODO
+Q2. When implementing move semantics for a `unique_ptr`, for example in the 
+move constructor `unique_ptr(unique_ptr&& other)`, it is essential that we 
+set the underlying pointer of the `other` parameter to `nullptr` before 
+exiting the function. Explain in your own words what problem would arise 
+if we did not.
+A2. two pointer -> same one address.
 
-Q3. This method of recursive deallocation through RAII works great for small lists, but may pose a problem for longer lists. Why? Hint: what is the limit for how "deep" a recursive function's call stack can grow?
-A3. TODO
+Q3. This method of recursive deallocation through RAII works great for 
+small lists, but may pose a problem for longer lists. Why? Hint: 
+what is the limit for how "deep" a recursive function's call stack can grow?
+A3. windows~1MB linux~8MB macos~8MB
 
-Q4. What does `std::move` do in this context? Why is it safe to use `std::move` and move semantics here?
-A4. TODO
+Q4. What does `std::move` do in this context? Why is it safe to 
+use `std::move` and move semantics here?
+A4. use std::move -> Object not to use copy, Instead 'move'.

assign7/unique_ptr.h

@@ -15,80 +15,73 @@ template <typename T, typename Deleter = std::default_delete<T>> // c++ library
 class unique_ptr {
 private:
   /* STUDENT TODO: What data must a unique_ptr keep track of? */
-  T* ptr;
+  T* _ptr;
   Deleter deleter;
 public:
   /**
    * @brief Constructs a new `unique_ptr` from the given pointer.
    * @param ptr The pointer to manage.
    * @note You should avoid using this constructor directly and instead use `make_unique()`.
    */
-  unique_ptr(T* ptr) {
-    /* STUDENT TODO: Implement the constructor */
-    
-  }
+  unique_ptr(T* ptr) noexcept : _ptr(ptr) {}
 
   /**
    * @brief Constructs a new `unique_ptr` from `nullptr`.
    */
-  unique_ptr(std::nullptr_t) {
-    /* STUDENT TODO: Implement the nullptr constructor */
-    return nullptr_t;
-  }
+  unique_ptr(std::nullptr_t) : _ptr(nullptr) {}
 
   /**
    * @brief Constructs an empty `unique_ptr`.
    * @note By default, a `unique_ptr` points to `nullptr`.
    */
-  unique_ptr() : unique_ptr(nullptr) {
-    
-  }
+  unique_ptr() : unique_ptr(nullptr) {}
 
   /**
    * @brief Dereferences a `unique_ptr` and returns a reference to the object.
    * @return A reference to the object.
    */
-  T& operator*() {
+  T& operator*() noexcept {
     /* STUDENT TODO: Implement the dereference operator */
-    return *ptr;
+    return *_ptr;
   }
 
   /**
    * @brief Dereferences a `unique_ptr` and returns a const reference to the object.
    * @return A const reference to the object.
    */
-  const T& operator*() const {
+  const T& operator*() const noexcept {
     /* STUDENT TODO: Implement the dereference operator (const) */
-
+    return *_ptr;
   }
 
   /**
    * @brief Returns a pointer to the object managed by the `unique_ptr`.
    * @note This allows for accessing the members of the managed object through the `->` operator.
    * @return A pointer to the object.
    */
-  T* operator->() {
+  T* operator->() noexcept {
     /* STUDENT TODO: Implement the arrow operator */
-    return ptr;
+    return _ptr;
   }
 
   /**
    * @brief Returns a const pointer to the object managed by the `unique_ptr`.
    * @note This allows for accessing the members of the managed object through the `->` operator.
    * @return A const pointer to the object.
    */
-  const T* operator->() const {
+  const T* operator->() const noexcept {
     /* STUDENT TODO: Implement the arrow operator */
-    
+    return _ptr;
   }
 
   /**
    * @brief Returns whether or not the `unique_ptr` is non-null.
    * @note This allows us to use a `unique_ptr` inside an if-statement.
    * @return `true` if the `unique_ptr` is non-null, `false` otherwise.
    */
-  operator bool() const {
+  operator bool() const noexcept {
     /* STUDENT TODO: Implement the boolean conversion operator */
+    return _ptr != nullptr;
   }
 
   /** STUDENT TODO: In the space below, do the following:
@@ -98,24 +91,27 @@ class unique_ptr {
    * - Implement the move constructor
    * - Implement the move assignment operator
    */
-  ~unique_ptr() {
-    if (ptr) deleter(ptr);
+  ~unique_ptr() noexcept {
+    deleter(_ptr);
   }
 
-  unique_ptr(const unique_ptr& other) {
-    deleter();
-  }
+  unique_ptr(const unique_ptr& other) = delete;
 
-  unique_ptr& operator=(const unique_ptr& other) {
-    deleter();
-  }
+  unique_ptr& operator=(const unique_ptr& other) = delete;
 
   unique_ptr(unique_ptr&& other) {
-    std::move()
+    _ptr = std::move(other._ptr);
+    other._ptr = nullptr;
   }
 
-  unique_ptr& operator=(unique_ptr&& other) {
-    
+  unique_ptr& operator=(unique_ptr&& other) noexcept {
+    if (this != &other) {
+      deleter(_ptr);
+      _ptr = other._ptr;
+      other._ptr = nullptr;
+    }
+
+    return *this;
   }
 };