Lecture 22

Constant Data Members

• Data members of a class can be made constant.

• Example:

     class sentence {
        ...
        private:
  	 const int maxLength;
  	 ...
        };
  	 

  • maxLength is a constant, but each instance of a sentence can have a different value for its maxLength.

  • We could have put maxLength in the public area if we wanted anyone to be able to access it.

• Problem: How are constant data members initialized?

• Solution: Use initialization lists.

• By using constant instances, constant member functions, and constant data members, we can be very precise about which parts of an instance can and cannot be changed.
  • Remember that many bugs in programs are caused by values being changed incorrectly. If a value should not change, make it a constant.

Initialization Lists

• An initialization list is used to initialize the data member of an instance before the constructor is executed. (The initialization list is also used to initialize the base classes from which the instance is derived. More on this when we cover class inheritance.)

• Example:

     class sentence {
        public:
  	 sentence();
  	 ...
        private:
  	 const int maxLength;
  	 char *    words;
  	 int       count;
        }:
  
     sentence::sentence()
        : maxLength(10), words(NULL), count(0) {
        // body is now empty.
     }
  	 

• Example:

     class myClass {
        public:
  	 myClass();
  	 myClass(char * w);
  	 myClass(char * a, char * b);
  	 ...
        private:
  	 sentence one;
  	 sentence two;
  	 ...
        };
  
     myClass::myClass() {
     }
  
     myClass::myClass(char * w) 
        : one(w) {
     }
  
     mytClass::myClass(char * a, char * b)
        : one(a), two(b) {
     }
  	 

• Initialization lists appear only the constructor's definition, not in its prototype.

• Initialization lists are the only way to initialize members that are references or constants. They can also be used to initialize normal data members, as the examples show.

• A constructor can initialize members of a constant instance, but cannot initialize constant members of an instance. For that, we must use initialization lists.

Static Object Polymorphism

• We can have a pointer to an instance.
  • Example:

       Point * p = new Point;
       p->move(3.0, 4.0);
       p->display();
       delete p;
    	       

• A pointer defined to point to an instance of some base class can also point to instances of derived classes.
  • Example:

       Point * p = new Circle;
       p->move(3.0, 4.0);
       p->display();      // which "display" function?
       delete p;
    	       

• However, we can only access data members and member functions which are present in the base class.
  • A pointer which is defined to point to a Point can point to any Point instance (including a Circle instalce or a Disk instance), but it can only use those properties and functions which are common to all Point instances.

• The ability to treat instances of different classes the same by using only their common properties and functions is called static object polymorphism.

Return to lecture notes index

Lectures