Three Other Two Other Methods that are Needed

• Let's try a simple experiment.
  • I copyied listTest.cpp to listBomb.cpp.
  • I deleted a bunch of stuff and added a simple main.
  • I changed the function prototype for PrintList to pass the list by value, not by reference.

  • void PrintList(ListT list); 

• What happened?
  • Draw the diagram to understand
  • This is a case of a invalid pointer.
  • Gregorie discusses this briefly on page 234.
  • But it is a major issue.
• A copy constructor.
  • Discussed starting on page 269 of the book.
  • A copy constructor is called when an item is
    • Passed by value.
    • When a new instance of an object is created by copying another object.

      • ItemT x;
        ...
        
        ItemT y{x};
        ItemT z(x); 

      • We will discuss the this later.
  • For now we need to build a copy constructor to handle pass by value.
• The problem is a difference between a shallow copy and a deep copy
  • In a shallow copy the fields of a structure are copied from one instance of a structure to another.
  • This is the default for c++
  • For everything but pointer data this makes sense.
  • For pointers, only the pointer is copied.
  • This means that two structures will be pointing the the same memory.
  • This is most likely a problem.
    • There can be supprising changes to the value of the memory that one instance does not expect.
    • Most likely the first to be destroyed will deallocate the memory, thus a dangling pointer.
    • If this does not cause a problem, when the second instance is destroyed, there will be a double free.
• In a deep copy
  • New memory is allocated and the data is copied over.
  • This must be done by hand
  • static fields are just copied
  • Dynamic fields
    • Allocate memory
    • Copy the data to the new memory
• We need to build a copy constructor that will do a deep copy.
• But one tricky thing before we do
  • The copy constructor will take an instance of the class we want to copy.
  • This instance needs to be passed by reference, why?

  • ListT(const ListT & src);
    ListT(ListT src);
    

• Building the copy constructor
  • I know from experience that I will need to copy one list to another in several places.
  • So I am going to build a function that takes a pointer to a list and returns a pointer to a duplicated list.
  • This doesn't need to be part of the class.
  • So I am not going to add it to the class prototype.
  • Make sure you copy the size.
  • And adjust the current pointer as well.
• There is another problem.

  • ListT list;
    ListT b;
    
    ...
    b = list; 

  • Right now, this will cause a problem, why?
  • The compiler will catch it

  • listBomb.cpp:26:10: warning: implicitly-declared 'constexpr ListT& ListT::operator=(const ListT&)' is deprecated [-Wdeprecated-copy]
       26 |     b  = list;
          |          ^~~~
    In file included from listBomb.cpp:2:
    ListT.h:8:7: note: because 'ListT' has user-provided 'ListT::ListT(const ListT&)'
        8 |       ListT(const ListT & src);
          |       ^~~~~
    
              

  • What is this complaining about?
• The = operator in c++
  • a = b actually returns the value of a, once b has been copied.
• this
  • Inside an object, this is a pointer that points to the object.
  • We will use the this pointer to solve the next two problems.
• Overloading the = operator is discussed on page 278
  • It takes a const reference to the thing to be copied (right hand side)
  • It returns a refernce to the thing copied.
• A problem overloading the = operator
  • With the copy constructor, there was no worrys about the new item already containing data.
  • It was a constructor after all.
  • In this case, the thing on the left hand side mgith have data.
  • Or even worse a = a
• The syntax for the function prototype is just a bit strange

  • ListT & operator =(const ListT & src); 

• For the actual function
  • First test to see if the left hand side is different from the right hand side.

    • if (this != &src) 

  • If that passes
    • Delete the memory the left hand side is pointing at
    • Copy the memory (deep copy) on the right hand side
    • Copy the other data.
  • In any case, return a reference to the left hand side.

    • return *this;

• Take a look at the new ListT.h
• Take a look at the new ListT.cpp