const (Constant) Objects and const Member Functions

We have emphasized the principle of least privilege as one of the most fundamental principles of good software engineering. Let us see how this principle applies to objects.


Some objects need to be modifiable and some do not. The programmer may use keyword const to specify that an object is not modifiable and that any attempt to modify the object should result in a compilation error. The statement

const Time noon( 12, 0, 0 );

declares a const object noon of class Time and initializes it to 12 noon.

Software Engineering Observation 10.1

Declaring an object as const helps enforce the principle of least privilege. Attempts to modify the object are caught at compile time rather than causing execution-time errors. Using const properly is crucial to proper class design, program design and coding.

Performance Tip 10.1

Declaring variables and objects const can improve performancetoday's sophisticated optimizing compilers can perform certain optimizations on constants that cannot be performed on variables.

C++ compilers disallow member function calls for const objects unless the member functions themselves are also declared const. This is true even for get member functions that do not modify the object. In addition, the compiler does not allow member functions declared const to modify the object.

A function is specified as const both in its prototype (Fig. 10.1; lines 1924) and in its definition (Fig. 10.2; lines 47, 53, 59 and 65) by inserting the keyword const after the function's parameter list and, in the case of the function definition, before the left brace that begins the function body.

Figure 10.1. Time class definition with const member functions.

(This item is displayed on page 526 in the print version)

 1 // Fig. 10.1: Time.h
 2 // Definition of class Time.
 3 // Member functions defined in Time.cpp.
 4 #ifndef TIME_H
 5 #define TIME_H
 6
 7 class Time
 8 {
 9 public:
10 Time( int = 0, int = 0, int = 0 ); // default constructor
11
12 // set functions
13 void setTime( int, int, int ); // set time
14 void setHour( int ); // set hour
15 void setMinute( int ); // set minute
16 void setSecond( int ); // set second
17
18 // get functions (normally declared const)
19 int getHour() const; // return hour 
20 int getMinute() const; // return minute 
21 int getSecond() const; // return second 
22
23 // print functions (normally declared const) 
24 void printUniversal() const; // print universal time
25 void printStandard(); // print standard time (should be const)
26 private:
27 int hour; // 0 - 23 (24-hour clock format)
28 int minute; // 0 - 59
29 int second; // 0 - 59
30 }; // end class Time
31
32 #endif

Figure 10.2. Time class member-function definitions, including const member functions.

(This item is displayed on pages 527 - 528 in the print version)

 1 // Fig. 10.2: Time.cpp
 2 // Member-function definitions for class Time.
 3 #include 
 4 using std::cout;
 5
 6 #include 
 7 using std::setfill;
 8 using std::setw;
 9
10 #include "Time.h" // include definition of class Time
11
12 // constructor function to initialize private data;
13 // calls member function setTime to set variables;
14 // default values are 0 (see class definition)
15 Time::Time( int hour, int minute, int second )
16 {
17 setTime( hour, minute, second );
18 } // end Time constructor
19
20 // set hour, minute and second values
21 void Time::setTime( int hour, int minute, int second )
22 {
23 setHour( hour );
24 setMinute( minute );
25 setSecond( second );
26 } // end function setTime
27
28 // set hour value
29 void Time::setHour( int h )
30 {
31 hour = ( h >= 0 && h < 24 ) ? h : 0; // validate hour
32 } // end function setHour
33
34 // set minute value
35 void Time::setMinute( int m )
36 {
37 minute = ( m >= 0 && m < 60 ) ? m : 0; // validate minute
38 } // end function setMinute
39
40 // set second value
41 void Time::setSecond( int s )
42 {
43 second = ( s >= 0 && s < 60 ) ? s : 0; // validate second
44 } // end function setSecond
45
46 // return hour value
47 int Time::getHour() const // get functions should be const
48 {
49 return hour;
50 } // end function getHour
51
52 // return minute value
53 int Time::getMinute() const
54 {
55 return minute;
56 } // end function getMinute
57
58 // return second value
59 int Time::getSecond() const
60 {
61 return second;
62 } // end function getSecond
63
64 // print Time in universal-time format (HH:MM:SS)
65 void Time::printUniversal() const
66 {
67 cout << setfill( '0' ) << setw( 2 ) << hour << ":"
68 << setw( 2 ) << minute << ":" << setw( 2 ) << second;
69 } // end function printUniversal
70
71 // print Time in standard-time format (HH:MM:SS AM or PM)
72 void Time::printStandard() // note lack of const declaration
73 {
74 cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 )
75 << ":" << setfill( '0' ) << setw( 2 ) << minute
76 << ":" << setw( 2 ) << second << ( hour < 12 ? " AM" : " PM" );
77 } // end function printStandard

Common Programming Error 10.1

Defining as const a member function that modifies a data member of an object is a compilation error.

Common Programming Error 10.2

Defining as const a member function that calls a non-const member function of the class on the same instance of the class is a compilation error.

Common Programming Error 10.3

Invoking a non-const member function on a const object is a compilation error.

Software Engineering Observation 10.2

A const member function can be overloaded with a non-const version. The compiler chooses which overloaded member function to use based on the object on which the function is invoked. If the object is const, the compiler uses the const version. If the object is not const, the compiler uses the non-const version.

An interesting problem arises for constructors and destructors, each of which typically modifies objects. The const declaration is not allowed for constructors and destructors. A constructor must be allowed to modify an object so that the object can be initialized properly. A destructor must be able to perform its termination housekeeping chores before an object's memory is reclaimed by the system.


Common Programming Error 10.4

Attempting to declare a constructor or destructor const is a compilation error.

 

Defining and Using const Member Functions

The program of Figs. 10.110.3 modifies class Time of Figs. 9.99.10 by making its get functions and printUniversal function const. In the header file Time.h (Fig. 10.1), lines 1921 and 24 now include keyword const after each function's parameter list. The corresponding definition of each function in Fig. 10.2 (lines 47, 53, 59 and 65, respectively) also specifies keyword const after each function's parameter list.

Figure 10.3 instantiates two Time objectsnon-const object wakeUp (line 7) and const object noon (line 8). The program attempts to invoke non-const member functions setHour (line 13) and printStandard (line 20) on the const object noon. In each case, the compiler generates an error message. The program also illustrates the three other member-function-call combinations on objectsa non-const member function on a non-const object (line 11), a const member function on a non-const object (line 15) and a const member function on a const object (lines 1718). The error messages generated for non-const member functions called on a const object are shown in the output window. Notice that, although some current compilers issue only warning messages for lines 13 and 20 (thus allowing this program to be executed), we consider these warnings to be errorsthe ANSI/ISO C++ standard disallows the invocation of a non-const member function on a const object.


Figure 10.3. const objects and const member functions.

(This item is displayed on pages 528 - 529 in the print version)

 1 // Fig. 10.3: fig10_03.cpp
 2 // Attempting to access a const object with non-const member functions.
 3 #include "Time.h" // include Time class definition
 4
 5 int main()
 6 {
 7 Time wakeUp( 6, 45, 0 ); // non-constant object
 8 const Time noon( 12, 0, 0 ); // constant object
 9
10 // OBJECT MEMBER FUNCTION
11 wakeUp.setHour( 18 ); // non-const non-const
12
13 noon.setHour( 12 ); // const non-const
14
15 wakeUp.getHour(); // non-const const
16
17 noon.getMinute(); // const const
18 noon.printUniversal(); // const const
19
20 noon.printStandard(); // const non-const
21 return 0;
22 } // end main
 

Borland C++ command-line compiler error messages:

 Warning W8037 fig10_03.cpp 13: Non-const function Time::setHour(int)
 called for const object in function main()
 Warning W8037 fig10_03.cpp 20: Non-const function Time::printStandard()
 called for const object in function main()
 
 

Microsoft Visual C++.NET compiler error messages:

 C:cpphtp5_examplesch10Fig10_01_03fig10_03.cpp(13) : error C2662:
 'Time::setHour' : cannot convert 'this' pointer from 'const Time' to
 'Time &'
 Conversion loses qualifiers
 C:cpphtp5_examplesch10Fig10_01_03fig10_03.cpp(20) : error C2662:
 'Time::printStandard' : cannot convert 'this' pointer from 'const Time' to
 'Time &'
 Conversion loses qualifiers
 
 

GNU C++ compiler error messages:

 fig10_03.cpp:13: error: passing `const Time' as `this' argument of
 `void Time::setHour(int)' discards qualifiers
 fig10_03.cpp:20: error: passing `const Time' as `this' argument of
 `void Time::printStandard()' discards qualifiers
 

Notice that even though a constructor must be a non-const member function (Fig. 10.2, lines 1518), it can still be used to initialize a const object (Fig. 10.3, line 8). The definition of the Time constructor (Fig. 10.2, lines 1518) shows that the Time constructor calls another non-const member functionsetTime (lines 2126)to perform the initialization of a Time object. Invoking a non-const member function from the constructor call as part of the initialization of a const object is allowed. The "const ness" of a const object is enforced from the time the constructor completes initialization of the object until that object's destructor is called.

Also notice that line 20 in Fig. 10.3 generates a compilation error even though member function printStandard of class Time does not modify the object on which it is invoked. The fact that a member function does not modify an object is not sufficient to indicate that the function is constant functionthe function must explicitly be declared const.

Initializing a const Data Member with a Member Initializer

The program of Figs. 10.410.6 introduces using member initializer syntax. All data members can be initialized using member initializer syntax, but const data members and data members that are references must be initialized using member initializers. Later in this chapter, we will see that member objects must be initialized this way as well. In Chapter 12 when we study inheritance, we will see that base-class portions of derived classes also must be initialized this way.


The constructor definition (Fig. 10.5, lines 1116) uses a member initializer list to initialize class Increment's data membersnon-const integer count and const integer increment (declared in lines 1920 of Fig. 10.4). Member initializers appear between a constructor's parameter list and the left brace that begins the constructor's body. The member initializer list (Fig. 10.5, lines 1213) is separated from the parameter list with a colon (:). Each member initializer consists of the data member name followed by parentheses containing the member's initial value. In this example, count is initialized with the value of constructor parameter c and increment is initialized with the value of constructor parameter i. Note that multiple member initializers are separated by commas. Also, note that the member initializer list executes before the body of the constructor executes.

Figure 10.4. Increment class definition containing non-const data member count and const data member increment.

(This item is displayed on page 530 in the print version)

 1 // Fig. 10.4: Increment.h
 2 // Definition of class Increment.
 3 #ifndef INCREMENT_H
 4 #define INCREMENT_H
 5
 6 class Increment
 7 {
 8 public:
 9 Increment( int c = 0, int i = 1 ); // default constructor
10
11 // function addIncrement definition
12 void addIncrement()
13 {
14 count += increment;
15 } // end function addIncrement
16
17 void print() const; // prints count and increment
18 private:
19 int count;
20 const int increment; // const data member
21 }; // end class Increment
22
23 #endif

Figure 10.5. Member initializer used to initialize a constant of a built-in data type.

(This item is displayed on page 530 in the print version)

 1 // Fig. 10.5: Increment.cpp
 2 // Member-function definitions for class Increment demonstrate using a
 3 // member initializer to initialize a constant of a built-in data type.
 4 #include 
 5 using std::cout;
 6 using std::endl;
 7
 8 #include "Increment.h" // include definition of class Increment
 9
10 // constructor
11 Increment::Increment( int c, int i )
12 : count( c ), // initializer for non-const member 
13  increment( i ) // required initializer for const member
14 {
15 // empty body
16 } // end constructor Increment
17
18 // print count and increment values
19 void Increment::print() const
20 {
21 cout << "count = " << count << ", increment = " << increment << endl;
22 } // end function print

Figure 10.6. Invoking an Increment object's print and addIncrement member functions.

 1 // Fig. 10.6: fig10_06.cpp
 2 // Program to test class Increment.
 3 #include 
 4 using std::cout;
 5
 6 #include "Increment.h" // include definition of class Increment
 7
 8 int main()
 9 {
10 Increment value( 10, 5 );
11
12 cout << "Before incrementing: ";
13 value.print();
14
15 for ( int j = 1; j <= 3; j++ )
16 {
17 value.addIncrement();
18 cout << "After increment " << j << ": ";
19 value.print();
20 } // end for
21
22 return 0;
23 } // end main
 
 Before incrementing: count = 10, increment = 5
 After increment 1: count = 15, increment = 5
 After increment 2: count = 20, increment = 5
 After increment 3: count = 25, increment = 5
 

Software Engineering Observation 10.3

A const object cannot be modified by assignment, so it must be initialized. When a data member of a class is declared const, a member initializer must be used to provide the constructor with the initial value of the data member for an object of the class. The same is true for references.


Erroneously Attempting to Initialize a const Data Member with an Assignment

The program of Figs. 10.710.9 illustrates the compilation errors caused by attempting to initialize const data member increment with an assignment statement (Fig. 10.8, line 14) in the Increment constructor's body rather than with a member initializer. Note that line 13 of Fig. 10.8 does not generate a compilation error, because count is not declared const. Also note that the compilation errors produced by Microsoft Visual C++.NET refer to int data member increment as a "const object." The ANSI/ISO C++ standard defines an "object" as any "region of storage." Like instances of classes, fundamental-type variables also occupy space in memory, so they are often referred to as "objects."

Figure 10.7. Increment class definition containing non-const data member count and const data member increment.

(This item is displayed on pages 532 - 533 in the print version)

 1 // Fig. 10.7: Increment.h
 2 // Definition of class Increment.
 3 #ifndef INCREMENT_H
 4 #define INCREMENT_H
 5
 6 class Increment
 7 {
 8 public:
 9 Increment( int c = 0, int i = 1 ); // default constructor
10
11 // function addIncrement definition
12 void addIncrement()
13 {
14 count += increment;
15 } // end function addIncrement
16
17 void print() const; // prints count and increment
18 private:
19 int count;
20 const int increment; // const data member
21 }; // end class Increment
22
23 #endif

Figure 10.8. Erroneous attempt to initialize a constant of a built-in data type by assignment.

(This item is displayed on page 533 in the print version)

 1 // Fig. 10.8: Increment.cpp
 2 // Attempting to initialize a constant of
 3 // a built-in data type with an assignment.
 4 #include 
 5 using std::cout;
 6 using std::endl;
 7
 8 #include "Increment.h" // include definition of class Increment
 9
10 // constructor; constant member 'increment' is not initialized
11 Increment::Increment( int c, int i ) 
12 { 
13  count = c; // allowed because count is not constant 
14  increment = i; // ERROR: Cannot modify a const object 
15 } // end constructor Increment 
16
17 // print count and increment values
18 void Increment::print() const
19 {
20 cout << "count = " << count << ", increment = " << increment << endl;
21 } // end function print

Common Programming Error 10.5

Not providing a member initializer for a const data member is a compilation error.

Software Engineering Observation 10.4

Constant data members (const objects and const variables) and data members declared as references must be initialized with member initializer syntax; assignments for these types of data in the constructor body are not allowed.

Note that function print (Fig. 10.8, lines 1821) is declared const. It might seem strange to label this function const, because a program probably will never have a const Increment object. However, it is possible that a program will have a const reference to an Increment object or a pointer to const that points to an Increment object. Typically, this occurs when objects of class Increment are passed to functions or returned from functions. In these cases, only the const member functions of class Increment can be called through the reference or pointer. Thus, it is reasonable to declare function print as constdoing so prevents errors in these situations where an Increment object is treated as a const object.

Error-Prevention Tip 10.1

Declare as const all of a class's member functions that do not modify the object in which they operate. Occasionally this may seem inappropriate, because you will have no intention of creating const objects of that class or accessing objects of that class through const references or pointers to const. Declaring such member functions const does offer a benefit, though. If the member function is inadvertently written to modify the object, the compiler will issue an error message.


Figure 10.9. Program to test class Increment generates compilation errors.

(This item is displayed on pages 533 - 534 in the print version)

 1 // Fig. 10.9: fig10_09.cpp
 2 // Program to test class Increment.
 3 #include 
 4 using std::cout;
 5
 6 #include "Increment.h" // include definition of class Increment
 7
 8 int main()
 9 {
10 Increment value( 10, 5 );
11
12 cout << "Before incrementing: ";
13 value.print();
14
15 for ( int j = 1; j <= 3; j++ )
16 {
17 value.addIncrement();
18 cout << "After increment " << j << ": ";
19 value.print();
20 } // end for
21
22 return 0;
23 } // end main
 

Borland C++ command-line compiler error message:

 Error E2024 Increment.cpp 14: Cannot modify a const object in function
 Increment::Increment(int,int)
 
 

Microsoft Visual C++.NET compiler error messages:

 C:cpphtp5_examplesch10Fig10_07_09Increment.cpp(12) : error C2758:
 'Increment::increment' : must be initialized in constructor
 base/member initializer list
 C:cpphtp5_examplesch10Fig10_07_09Increment.h(20) :
 see declaration of 'Increment::increment'
 C:cpphtp5_examplesch10Fig10_07_09Increment.cpp(14) : error C2166:
 l-value specifies const object
 
 

GNU C++ compiler error messages:

 Increment.cpp:12: error: uninitialized member 'Increment::increment' with
 'const' type 'const int'
 Increment.cpp:14: error: assignment of read-only data-member
 `Increment::increment'
 




C++ How to Program
C++ How to Program (5th Edition)
ISBN: 0131857576
EAN: 2147483647
Year: 2004
Pages: 627
Simiral book on Amazon

Flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net