CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Inline Member Functions

• A member function can be made inline by defining the function in the class definition.
  • Example:

       class rectangle {
          public:
             ...
             int getWidth() { return width; }
             ...
          };
                   

    is the same as

       class rectangle {
          public:
             ...
             inline int getWidth();
             ...
          };
    
       inline int rectangle::getWidth() {
          return width;
       }
                   

    provided that the definition of getWidth is in the same file as the definition of rectangle.

Constructors

• Problem: How can we initialize the value of a class instance when it is created?
  • For primitive data types, we can initialize a variable when it is defined.

       int    i = 37;
       char * c = NULL;
                   

  • How can we do this for more complicated data structures?

• Solution: Use a constructor.

• A constructor is a member function (possibly overloaded) which initializes instances of the class which it belongs to.

• The name of the constructor is always the name of the class.

• Constructors have no return value, not even void.

• Example:

     class rectangle {
        public:
           rectangle();
           void setSize(int x, int y);
           int  getWidth();
           int  getLength();
        private:
           int  width;
           int  length;
        };
  
     rectangle::rectangle() {
        width  = 4;
        length = 10;
     }
           

  • Note that we could have defined the constructor in the class definition, making it an inline function.

  • Now all rectangles have a default size of 4 by 10.

       rectangle   a;
       rectangle * b = new rectangle;
       cout << a.getWidth();            // outputs 4.
       cout << b->getLength();          // outputs 10.
                   

• We can have constructors that take parameters.

     class rectangle {
        public:
           rectangle();
           rectangle(int x, int y);
           ...
        };
  
     rectangle   a(6, 7);
     rectangle * b = new rectangle(3, 2);
     rectangle   c;        // defaults to 4 by 10.
           

• A constructor which can be called with no parameters (either because it has no formal parameters or because all of the parameters are defaulted) is called the default constructor.
  • If we do not have a default constructor, we must always pass parameters when creating an instance.

  • Example:

       class rectangle {
          public:
             rectangle(int x, int y);     // no default constructor.
          ...
          };
    
         rectangle   a;                   // error.
         rectangle * b = new rectangle;   // error.
                   

  • If you do not define any constructors, an implicit default constructor with an empty body is automatically provided.

• A constructor which takes a reference to a const instance of the class to which it belongs is called a copy constructor.
  • classname(const classname& parametername);

  • Copy constructors are used in three places:
    1. To initialize an instance by using an existing instance.

          rectangle a(12, 9);
          rectangle b(a);      // b is also 12 by 9.
                            

    2. To initialize a formal parameter when an instance is passed by value.

          void myFunc(rectangle r);
          ...
          rectangle a;
          myFunc(a);
                            

    3. When a function value is returned by value (rather than by reference).

          rectangle myFunc();
          ...
          rectangle a;
          a = myFunc();
                            

• Constructors cannot be explicitly called.

Destructors

• A destructor is a member function which is implicitly called whenever a class instance ceases to exist.

• The name of the destructor is always the name of the class preceded by the ~ (tilde) character.

• Like constructors, destructors have no return value, and cannot be explicity called.

• A destructor never has parameters.

• 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               
                   

Return to lecture notes index

Lectures