4.7 Constant Methods, Parameters, and Variables

Limiting methods, variables and parameters in this way is useful for three reasons. First, the additional declaration provides a more specific statement of the intention of the programmer. Often these intentions cannot be expressed and are, perhaps inadvertantly, violated, causing unintended behavior and perhaps system errors. With the additional declaration, the compiler is able to detect and prevent unintended usage. Second, when errors do occur, the additional declarations help to reduce the area of the system that must be examined. If data has been improperly changed, the cause cannot directly be in those areas declared not to cause or allow such changes. Third, the additional information often helps the compiler to optimize better the executable code. For example, if the compiler knows that a variable cannot change, it need never generate code that would save and restore its value.

The keyword "const" is used as a modifier on the declarations of methods, variables and parameters. The Location class below shows how the "const" modifier is used on methods.

  class Location {                         // Version 1
   private:

     int  currentX, currentY;

   public:

        Location(int x, int y);         // specific location
        Location();                     // default location
     int Xcoord() const;                // return x-axis coordinate
     int Ycoord() const;                // return y-axis coordinate
   };

   // the implementation follows

    Location::Location( int x, int y ) { currentX = x; currentY = y; }

    Location::Location () { currentX = -1; currentY = -1; }

int Location::Xcoord() const { return currentX; }

int Location::Ycoord() const { return currentY; }

Note in the above example that the "const" modifier must appear both where the method appears in the class definition and again in the implementation part where the method's implementation is given.

An extended version of the Location class is shown below to illustrate how "const" is used with a parameter. In this extended definition a new method has been added that tests whether the screen coordinates defined by a Location object lies inside the boudaries of a given Frame object. The Frame object is passed by reference (to avoid the expense of copying the Frame object) and it is declared "const" because we do not need to modify the Frame object to determine whether a point lies in the Frame.

  class Location {                         // Version 2
   private:

     int  currentX, currentY;

   public:

        Location(int x, int y);         // specific location
        Location();                     // default location
     int Xcoord() const;                // return x-axis coordinate
     int Ycoord() const;                // return y-axis coordinate
     int Inside(const Frame& frame );   // if location is inside frame
   };

   // the implementation follows

    Location::Location( int x, int y ) { currentX = x; currentY = y; }

    Location::Location () { currentX = -1; currentY = -1; }

int Location::Xcoord() const { return currentX; }

int Location::Ycoord() const { return currentY; }

int Location::Inside (const Frame& frame) {
   Location frameAt    = frame.WhereAt();
   Shape    frameShape = frame.WhatShape();

   if (     frameAt.Xcoord() <= currentX                     
         && currentX <= frameAt.Xcoord() + frameShape.Width()
         && frameAt.Ycoord() <= currentY                      
         && currentY <= frameAt.Ycoord() + frameShape.Height()   )

        return 1;

   else return 0;
 }

Variables can also be declared with a "const" attribute. In some cases these are global variables that are a better alternative to #define preprocessor macros. Some examples of constant variables are:

	const int VersionNumber = 1;
        const int ReleaseNumber = 5;
        const double Pi = 2.141598;

Next Stop Back to Basic Concepts Back to Concept of Aggregation Back to Implementing a Class On to Copying Objects Safely