fix: change unique_ptr to cs106l::unique_ptr

Author: jacobrobertsbaca

assign7/README.md

@@ -131,9 +131,9 @@ Now that we have a `unique_ptr` implementation, let's use it! Take a look at `ma
 int main()
 {
 
-  auto head = make_unique<ListNode<int>>(1);
-  head->next = make_unique<ListNode<int>>(2);
-  head->next->next = make_unique<ListNode<int>>(3);
+  auto head = cs106l::make_unique<ListNode<int>>(1);
+  head->next = cs106l::make_unique<ListNode<int>>(2);
+  head->next->next = cs106l::make_unique<ListNode<int>>(3);
 
   // memory of head:
   //
@@ -158,11 +158,11 @@ Notice that we didn't have to make any calls to `delete`! The RAII behaviour of
 > ##### `short_answer.txt`  
 > **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?
 
-**Your task is to implement the function `create_list` which converts a `std::vector<T>` into a `unique_ptr<ListNode<T>>`.** The order of elements in the vector should be preserved in the list, and `nullptr` should be returned for an empty vector. There are many ways you could go about this; one is to construct the list in reverse (starting at the tail and working towards the head). Here is an algorithm you should follow in your implementation:
+**Your task is to implement the function `create_list` which converts a `std::vector<T>` into a `unique_ptr<ListNode<T>>`.** The order of elements in the vector should be preserved in the list, and `nullptr` should be returned for an empty vector. There are many ways you could go about this; one is to construct the list in reverse (starting at the tail and working towards the head). **Note that you must use the `cs106l::unique_ptr` under the `cs106l` namespace, and not the `std::unique_ptr`!** Here is an algorithm you should follow in your implementation:
 
-1. Initialize a `unique_ptr<ListNode<T>> head = nullptr`.
+1. Initialize a `cs106l::unique_ptr<ListNode<T>> head = nullptr`.
 2. Iterate through the `std::vector` **backwards.** For each element in the vector:
-    - 2a. Create a new `unique_ptr<ListNode<T>> node` whose value is the element in the vector.
+    - 2a. Create a new `cs106l::unique_ptr<ListNode<T>> node` whose value is the element in the vector.
     - 2b. Set `node->next` to `head`.
     - 2c. Set `head` to `node`
 3. Finally, return `head`

assign7/autograder/utils.hpp

@@ -70,12 +70,12 @@ void test_linked_list_example() {
 void test_destructor() {
   MemoryDiagnostics::MemoryGuard guard("Failed to deallocate memory in unique_ptr destructor!");
   for (size_t i = 0; i < 1000; ++i) {
-    auto ptr = ::make_unique<std::string>("hello");
+    auto ptr = cs106l::make_unique<std::string>("hello");
   }
 
   // Ensure that deallocation of empty unique_ptr is successful
   for (size_t i = 0; i < 1000; ++i) {
-    unique_ptr<std::string> ptr;
+    cs106l::unique_ptr<std::string> ptr;
   }
 }
 
@@ -85,7 +85,7 @@ void test_move_constructor() {
       "lecture on move semantics!");
   size_t sum = 0;
   for (size_t i = 0; i < 1000; ++i) {
-    auto ptr = ::make_unique<std::string>(kReallyLongString);
+    auto ptr = cs106l::make_unique<std::string>(kReallyLongString);
     auto size = ptr->size();
     auto other = std::move(ptr);
     ptr.~unique_ptr(); // Forcibly destroy old pointer
@@ -107,8 +107,8 @@ void test_move_assignment() {
       "the existing data before assigning the private fields? It may help to review the lecture on "
       "move semantics!");
   for (size_t i = 0; i < 1000; ++i) {
-    auto ptr1 = ::make_unique<std::string>("hello");
-    auto ptr2 = ::make_unique<std::string>("world");
+    auto ptr1 = cs106l::make_unique<std::string>("hello");
+    auto ptr2 = cs106l::make_unique<std::string>("world");
     ptr1 = std::move(ptr2);
     if (ptr2) {
       std::cerr << "Move assignment failed to set other pointer to nullptr! It may help to review "
@@ -125,7 +125,7 @@ void test_move_self_assignment() {
       "to review the lecture on move semantics!");
   size_t sum = 0;
   for (size_t i = 0; i < 1000; ++i) {
-    auto ptr = ::make_unique<std::string>(kReallyLongString);
+    auto ptr = cs106l::make_unique<std::string>(kReallyLongString);
     ptr = std::move(ptr);
 
     // If we don't check for self-assignment in the move constructor,
@@ -160,7 +160,7 @@ const std::unordered_map<std::string, std::function<void()>> test_functions = {
     {"memory_leak_exit_code",
      []() { std::cout << MemoryDiagnostics::MemoryGuard::get_exit_code() << "\n"; }},
     {"destructor", test_destructor},
-    {"copy", test_copy<unique_ptr<std::string>>},
+    {"copy", test_copy<cs106l::unique_ptr<std::string>>},
     {"move_constructor", test_move_constructor},
     {"move_assignment", test_move_assignment},
     {"move_self_assignment", test_move_self_assignment},

assign7/main.cpp

@@ -24,7 +24,7 @@ template <typename T> struct ListNode {
   T value;
 
   /** @brief The smart pointer to the next node. May be null. */
-  unique_ptr<ListNode<T>> next;
+  cs106l::unique_ptr<ListNode<T>> next;
 
   /**
    * @brief Constructs a single element linked list, setting `next` to `nullptr`.
@@ -50,7 +50,7 @@ template <typename T> struct ListNode {
  * @param values The values to store in the list.
  * @return A `unique_ptr` to the head of the list.
  */
-template <typename T> unique_ptr<ListNode<T>> create_list(const std::vector<T>& values) {
+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");
 }
@@ -63,7 +63,7 @@ template <typename T> unique_ptr<ListNode<T>> create_list(const std::vector<T>&
  * @paragraph func The function to apply to each element.
  */
 template <typename T, typename Func>
-void map_list(const unique_ptr<ListNode<T>>& head, const Func& func) {
+void map_list(const cs106l::unique_ptr<ListNode<T>>& head, const Func& func) {
   if (!head)
     return;
   func(head->value);

assign7/unique_ptr.h

@@ -3,6 +3,8 @@
 #include <cstddef>
 #include <utility>
 
+namespace cs106l {
+
 /**
  * @brief A smart pointer that owns an object and deletes it when it goes out of scope.
  * @tparam T The type of the object to manage.
@@ -101,6 +103,9 @@ template <typename T> class unique_ptr {
  * @tparam Args The types of the arguments to pass to the constructor of T.
  * @param args The arguments to pass to the constructor of T.
  */
-template <typename T, typename... Args> unique_ptr<T> make_unique(Args&&... args) {
+template <typename T, typename... Args> 
+unique_ptr<T> make_unique(Args&&... args) {
   return unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
 }