CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Destructors (continued)

• Example:

     #include <stdlib.h>
     #include <iostream.>
  
     class rectangle {
        public:
           rectangle();      // default constructor.
           ~rectangle();     // destructor.
        ...
        };
  
     rectangle::rectangle() {
        cout << "a new rectangle" << endl;
     }
  
     rectangle::~rectangle() {
        cout << "one less rectangle" << endl;
     }
  
     int main() {
        rectangle   a;
        rectangle * b = NULL;
  
        cout << "one" << endl;
        b = new rectangle;
        cout << "two" << endl;
        delete b;
        cout << "three" << endl;
        return 0;
     }
           

  • The output of this program is

       a new rectangle
       one
       a new rectangle
       two
       one less rectangle
       three
       one less rectangle               
                   

Classes with Pointers to Dynamic Memory

• If a class instance contains members which point to dynamically allocated memory, constructors and destructors are almost always required in order for the memory to be allocated and released properly.

• Example:
  • A class sentence that we can add words to, find the number of words, and clear the sentence.

       class sentence {
          public:
             sentence();
             sentence(const char * w);
             sentence(const sentence& s);
             ~sentence();
             int wordCount();
             void clear();
             boid appendWord(const char * w);
          private:
             char * words;
             int    count;
          };   
                   

  • The default constructor will set the pointer to NULL and count to 0.

       sentence::sentence() {
          words = NULL;
          count = 0;
       }
                   

  • We can construct a sentence from a word.

       sentence::sentence(const char * w) {
          words = NULL;
          count = 0;
          appendWord(w);
       }
                   

  • The copy constructor makes a "clone" of the given sentence.

       sentence::sentence(const sentence& s) {
          words = new char[strlen(s.words) + 1]
          strcpy(words, s.words);
          count = s.count;
       }
                   

  • The destructor will release any memory pointed to by the words pointer.

       sentence::~sentence() {
          clear();
       }
                   

  • wordCount returns the number of words.

       int sentence::wordCount() {
          return count;
       }
                   

  • clear removes all words from the sentence.

       void sentence::clear() {
          delete [] words;
          words = NULL;
          count = 0;
       }
                   

  • appendWord will allocate a new block of memory big enough to hold the new sentence. (If we will be adding words often, this is an inefficient implementation.)

       void sentence::appendWord(const char * w) {
          if (words == NULL) {
             words = new char[strlen(w) + 1];
             strcpy(words, w);
             count = 1;
             }
          else {
             int    wordsLen = strlen(words);
             char * newWords = new char[wordsLen + 1 + strlen(w) + 1];
             strcpy(newWords, words);
             strcat(newWords, " ");
             strcat(newWords, w);
             delete [] words;
             words = newWords;
             count++;
             }
       }
                   

• If the constructor allocates dynamic memory, the destructor should almost always release it, unless there is a very good reason not to. In that case, the comments in the program should describe exactly what is going on and why.

• If we didn't write our own copy constructor, an implicit copy constructor would be used whenever we needed to copy a sentence.
  • The implicit copy constructor would do a shallow copy. It would copy the pointers, but not what they point to.

  • Since we want a deep copy, we must write our own copy constructor.

Return to lecture notes index

Lectures