John Hopcroft class Project3 : Smart-Pointers

Project3 - 2023 Fall
Deadline: Tuesday November 28th - 18:55

Outline

In this homework we are going to implement our own smart pointers. Specifically we want to implement our custom SharedPtr and UniquePtr classes with almost all functionality of std::shared_ptr and std::unique_ptr.

We want to implement 2 class templates called UniquePtr and SharedPtr with the functions described in the following sections.

UniquePtr Class

Define a template class named UniquePtr and add the following functions to the class.

This class should use a member variable called T* _p (T is a template argument) to store a given pointer.

• Constructor Implement a constructor for your class so the below code would work. Your constructor should be able to store the given dynamic pointer properly inside the class using _p variable.

   UniquePtr<int> ptr{new int{10}};

• make_unique (outside the class) The prefered way to construct a std::unique_ptr is to use a function called std::make_unique. implement a similar function and make this code work:

   UniquePtr<int> ptr{make_unique<int>(10)};
   UniquePtr<std::vector<int>> ptr2{make_unique<std::vector<int>>(0,1,2,3)};

• Default Constructor Implement a default constructor for your class so the below code works and assign nullptr to _p.

   UniquePtr<int> ptr;

• Destructor As you know when dealing a with dynamic pointer in a class, implementing destructor is a neccessaty so implement a proper destructor and delete your dynamic pointer (hint: assign nullptr after deletion).

   ~UniquePtr()

• Copy Constructor As you already know you cannot copy a UniquePtr, make arrangements so the following code would cause a compile error.

   UniquePtr<int> ptr1{new int{10}};
   UniquePtr<int> ptr2{ptr1};

• Operator= Exactly like the previous section we should not be able to write the following code as well. Make the compiler to produce an error for this code.

   UniquePtr<int> ptr1{new int{10}};
   UniquePtr<int> ptr2{new int{11}};
   ptr2 = ptr1;

• get The get() function should return the raw pointer stored in the class.

   UniquePtr<int> ptr{new int{10}};
   std::cout << ptr.get() << std::endl; // output: raw pointer stored in the class

• Operator* Smart pointers should be able to be dereferenced exactly like raw pointers. make this code work:

   UniquePtr<int> ptr{new int{10}};
   std::cout << *ptr << std::endl; // output: 10

• Operator-> Smart pointers can use the arrow operator like normal pointers. make this code work as well:

   UniquePtr<std::string> ptr{new std::string{"hello"}};
   std::cout << ptr->length() << std::endl; // output: 5

• reset The reset() function will delete the pointer and assign nullptr to it:

   void reset();

• reset The reset() function can have a input and make a new pointer with it after deleting the old pointer:

   UniquePtr<std::string> ptr{new std::string{"hello"}};
   ptr.reset(new std::string{"nice"});
   std::cout << *ptr << std::endl; // output: nice

• release The release() function returns the stored pointer in the class (like get) with two differences: The UniquePtr class won't store the pointer anymore and also deleting the pointer should not be done by UniquePtr class after calling release().

   UniquePtr<double> ptr{new double{1.567}};
   double *tmp{ptr.release()};
   std::cout << *tmp << std::endl; // output: 1.567
   delete tmp; // manual deletion

SharedPtr Class

Define a template class named SharedPtr and add the following functions to the class.

This class should use a member variable called T* _p (T is a template argument) to store a given pointer.

• Constructor Implement a constructor for your class so the below code would work. Your constructor should be able to store the given dynamic pointer properly inside the class using _p variable.

   UniquePtr<int> ptr{new int{10}};

• make_shared (outside the class) The prefered way to construct a std::shared_ptr is to use a function called std::make_shared. implement a similar function and make the code below work.

   SharedPtr<int> ptr{make_shared<int>(10)};

• Default Constructor Implement a default constructor for your class so the below code works and assign nullptr to _p.

   SharedPtr<int> ptr;

• Destructor As you know when dealing with dynamic pointers inside a class implementing destructor is a neccessaty so implement a proper destructor and delete your dynamic pointers (do not forget to assign nullptr after deletion).

   ~SharedPtr()

• Copy Constructor As you already know A key difference between SharedPtr and UniquePtr classes is that we can use copy constrctor and make a copy of SharedPtrs. so the code below should run smoothly.

   SharedPtr<int> ptr1{new int{10}};
   SharedPtr<int> ptr2{ptr1};

• Operator= Exactly like the previous section we can have operator= for SharedPtrs. again the code below should run without any errors.

   SharedPtr<int> ptr1{new int{10}};
   SharedPtr<int> ptr2{new int{11}};
   ptr2 = ptr1;

• use_count In SharedPtrs we should have the ability to count the number of instances pointing to a same place. to do this you have to define another member variabel for your SharedPtr class and keep track of this number.

  note. you may have to make some adjusments in the previous functions (such as constructor and ...) to do this.

   SharedPtr<int> ptr1{make_shared<int>(10)};
   std::cout << ptr1.use_count() << std::endl; // output: 1
   SharedPtr<int> ptr2{ptr1};
   std::cout << ptr1.use_count() << std::endl; // output: 2
   std::cout << ptr2.use_count() << std::endl; // output: 2

• get The get() function should return the raw pointer stored in the class.

   SharedPtr<int> ptr{new int{10}};
   std::cout << ptr.get() << std::endl; // output: raw pointer of the class

• Operator* Smart pointers should be able to be dereferenced exactly like raw pointers. make this code work:

   SharedPtr<int> ptr{new int{10}};
   std::cout << *ptr << std::endl; // output: 10

• Operator-> Smart pointers can use the arrow operator like raw pointers. make this code work:

   SharedPtr<std::string> ptr{new std::string{"hello"}};
   std::cout << ptr->length() << std::endl; // output: 5

• reset The reset() function will delete the pointer and assigns nullptr to it:

   void reset();

• reset The reset() function can have a input and make a new pointer with it after deleting the old pointer:

   SharedPtr<std::string> ptr{new std::string{"hello"}};
   ptr.reset(new std::string{"nice"});
   std::cout << *ptr << std::endl; // output: nice

Challenge

• If you reached this section congratulations, there is only one part left. Make arrangements so you can use your custom smart pointers in an if condition, the condition should return false if your smart pointer contains a nullptr and otherwise it should return true.

   UniquePtr<double> ptr{new double{1.567}};
   if(ptr) // => true
       // something
   ptr.reset();
   if(ptr) // => false
       // some other thing

  Make this arrangement for both UniquePtr and SharedPtr classes.

Note

You can communicate with your classmates, but plagiarism is forbidden in John Class. We welcome idea exchanges, but any form of cheat will be taken seriously. If you're not sure about your behavior, please talk with us in case of misunderstandings.

You can test your code on https://acm.sjtu.edu.cn/OnlineJudge/problemset/654.

Grade

• Allocator: 30%
• Shared_ptr: 30%
• Unique_ptr: 30%
• Code Review: 10%

GOOD LUCK

Acknowledgement : Amirkabir University of Technology 1400-2 —— Advanced Programming Course Project 4 'Smart Pointers'