实现智能指针 Smart pointer , 包含一些C++高级用法，如Move constructor / Move assignment operator, 需要使用C++
17标准。
Requirement
In this assignment we implement our simplified versions ofsmart pointers.
Smart pointers are included in STL (C++ standard template library) and
implement some level of automatic garbage collection. Thus, smart pointers
help to fight memory leaks. The idea is simple: make it so that once a block
of dynamically allocated memory is no longer pointed by any smart pointer, it
is automatically released/deleted.
You should submit me one or two files: my_memory.hand possiblymy_memory.cpp.
my_memory.h contains the declarations of both classes.
my_unique_ptr
Class templat emy_unique_ptr is a pointer management class template. The
object of this class points to the dynamically allocated memory. Only one
object of the my_unique_ptr class can point to a given block of memory. Once
the object of the my_unique_ptr class is destroyed it releases/deletes the
block of memory to which it was pointing. We say that the my_unique_ptr object
owns the memory.
The innards of the my_unique_ptr class are very simple: it contains a pointer
to the datatype Type specified in the template (well, the actual unique_ptr
also contains the deleter for the objects of Type but we don’t need it). Also,
it contains the following public methods:
- Default constructor that initializes the object to point to nullptr.
- Constructor that takes a pointer Type * as a parameter and sets the object to point there. We say that the newly created object takes ownership of the pointed memory.
- Move constructor that takes my_unique_ptr object and constructs a new object from it.
- Copy constructor should be explicitly disabled/deleted !!!
- Destructor that releases/deletes the block of memory pointed by the object.
- Dereference operator * that returns a reference to the item pointed by the object.
- Operator -> that returns the pointer to the object. It allows to use the my_unique_ptr object for class member access.
- Move assignment operator.
- Copy assignment operator must be explicitly disabled/deleted !!!
- method isNullptr() that returns true if the pointer points to null ptr and false otherwise. This operator will help us to write tests.
my_shared_ptr
Class template my_shared_ptris a pointer management class template. The object
of this class points to the dynamically allocated memory. Multiple
my_shared_ptr objects can point to the same block of memory. When the
my_shared_ptr object stops pointing to the block of memory it checks if any
other my_shared_ptr object still points at it. If it finds that no other
my_shared_ptr object points to that block of memory, it releases/deletes it.
Two main pieces of data that we need in the my_shared_ptr class are:
- pointer to the datatype Type stated in the template parameter.
- pointer to an integer counter, that keeps track of how many my_shared_ptr objects point to the same block of memory.
The following methods should be implemented:
- Default constructor that sets all inner pointers to nullptr.
- Constructor that takes Type * as a parameter and sets the object to point there. The object considers itself to be the first my_shared_ptr object to point to that block of memory. So the counter should be set to 1.
- Copy constructor. Since the original object already points to the block of memory and now the newly created object points there too, you must increase the counter by 1.
- Move constructor. Since the original rvalue wont point to the block of memory no more, the counter should remain the same.
- Destructor that releases/deletes the block of memory and the counter if no other shared pointer points there.
- Dereference operator * that returns a reference to the item pointed by the object.
- Operator -> that returns the pointer to the object. It allows to use the my_shared_ptr object for class member access.
- Copy and move assignment operators. If prior to the assignment the my_shared_ptr object was already pointing somewhere, the counter for the old block of memory should be decreased by 1, and if it reaches 0, the old block of memory should be released/deleted. Copy assignment should also increase the counter for the newly pointed block of memory.
- method isNullptr() that returns true if the pointer points to null ptrand false otherwise. This operator will help us to write tests.
This assignment has a lot of places to mess up memory management. In
situations like that, we need additional tools to help us out. One of the best
tools here will bememory sanitizerand luckily we got one built in gcc
compiler. We will discuss the idea in class but here is the short reminder on
how to use it (main.cpp here is the driver with your library included in it)
g++ -std=c++17 -g -fsanitize=address,undefined main.cpp -o program_name
Also, I strongly recommend you to add-Walland maybe even-Wextraand inspect the
resulting warning messages.
