Common Problems with Pointers.

• Assume you have a QueueT class with a linked list implementation.
• What happens if there is no destructor
  • First: what is a destructor and when is it called?
  • Take a look at destructorTest.cpp
    • I'm afraid that this is part of chapter 8 or 9.
    • But we need it now.
• When a class is destroyed
  • A destructor is invoked
  • If the programmer does not supply a destructor, the compiler will write one for you.
  • But this destructor will do nothing.
• Do you know about valgrind?
  • valgrind valgrind-args progname progam-args
  • valgrind destructorTest
• Differences between new and new[]
  • If you allocate a class instance, new calls the constructor.
  • If you allocate multiple class instances new[] calls each constructor.
  • The same is true of delete and delete[]
  • If you used new, use delete to match it somewhere.
  • If you used new[], use delete[] to match it somewhere.
• If a class allocates dynamic memory, it must have a destructor.
  • This must free all allocated dynamic memory.
• Implement the destructor for the queue class.
• What happens with a pass by value?
  • Try implementing void PrintQueue(QueueT q)
    • Call it inside a loop.
    • Something went wrong. What?
  • What is a
    • Shallow copy?
    • What is a deep copy?
• When a class is passed by value
  • A copy constructor is invoked.
    • If the programmer does not supply one, the compiler will create one for you.
  • This copy constructor does a shallow copy.
• Draw a diagram of a shallow copy of the QueueT class.
• Building a copy constructor
  • This is a constructor.
  • It is invoked when a pass by value occurs.
  • It can be invoked when declaring an instance class as well

    • QueueT a;
      ...
      QueueT b(a); 

    • in this example, a QueueT b is constructed, and should be a copy of the QueueT a.
  • The prototype should be:

    • ClassT(const ClassT & src); 

    • This is important. We don't want a recursive call here.

    • ClassT(ClassT src); 

    • This would be recursive, why?
  • Writing a CopyList function:
    • void CopyList(QueueListT * & head, QueueListT src);
    • You do not necessarily need a function prototype.
    • And you do not need to put this into the .h file.
• Assignment operator
  • In C++ we can overload most operators.
  • QueueT & QueueT::operator =(const QueueT & src)
    • Overloads the assignment operator.
    • We can also overload the comparison operator if we wish, but ...
    • It returns a reference to a QueueuT because
    • a = b = c = d = e; is legal in c/c++
• Writing an assignment operator

  • QueueT & QueueT::operator =(const QueueT & src) {
           if (this != &src) {
                // delete the existing memory
                // deep copy any dynamic memory
                // shallow copy other fields.
           }
    
           return *this;
    
    }
             

• We will encounter this as we go along
  • Do not free the same memory twice, this is a double free and will crash the program
  • Do free all allocated memory, otherwise this is a memory leak.
  • The third problem is a dangling pointer.

  • SomeType * a = new SomeType
    SomeType * b = a;
    delete b;
    // what is a pointing at?
            

• All three of these problems can happen outside of a class too.
  • Please be careful when writing pointer code.