III. Classes (Chap. 3)

Transcription

1 III. Classes III-1 III. Classes (Chap. 3) As we have seen, C++ data types can be classified as: Fundamental (or simple or scalar): A data object of one of these types is a single object. int, double, char, bool, complex, and the related types (unsigned, short, etc.) enumerations Structured: These store collections of data. arrays, structs, unions, classes, valarrays, bitsets, and the containers and adapters in STL We have studied all of the fundamental types (except complex) and the data structures C++ gets from C arrays, structs, and unions. We will now look at classes in detail; pointers (and linked structures that use pointers) and vectors, stacks, queues, and lists from STL will be considered soon. A. Structs vs. Classes Similarities between structs and classes 1. Both can be used to model objects with (also called fields or instance variables). They can thus be used to process 2. They have essentially the. Differences between structs and classes 1. C does not provide classes; C++ provides both structs and classes. 2. Members of a struct by default are (can be accessed ). In C++ they can be explicitly declared to be (cannot be accessed outside the struct). Members of a class by default are Thus, choosing which to use is not based on their capabilites. It is common practice to use classes to prevent users of a new data type from (directly) accessing the data members. (We can also enforce this with structs, but this is not their default nature.) Differences between "traditional" (C) structs and OOP (C++) structs and classes C++'s structs and classes are extensions of C's structs. They can be used to model objects that have: Attributes (characteristics) represented as data members and

2 III-2 III. Classes Terminology: It is common to call the two parts of a class data members and member functions (although "data members" and "function members" is really more correct.) We will use the terms interchangeably. This is an important difference because it leads to a whole new style of programming object-oriented rather than procedural. Objects can now be, carrying their own operations around with them commonly called the principle instead of having to be shipped off to some external function that operates on them and sends them back. B. Structure and Design of a Class ( 11.1) 1. Declaring a Class a. Usual Form: class ClassName public: Declarations of public members private: Declarations of private members ; Notes: 1. The data members are normally placed in the section of a class; the function members in the section. 2. Some programmers prefer to put the private section first because this is the default access for classes so the private: specifier could be omitted. However, we will put the public interface part of the class first and the hidden private details last. 3. Although not commonly done, a class may have several private and public sections; the keywords private: and public: mark the beginning of each. b. Access (i) A particular instance of a class is called an : ClassName object_name; (ii) Private members can be accessed (except by functions described later). (iii) Public members can be accessed. ClassName object_name; To access them outside the class, one must use the : c. Where are class declarations placed? Usually in a header file whose name is ClassName.h. The library is then called a.

3 III. Classes III-3 2. Example: Declaring a class Time Version 1 /** Time.h This header file defines the data type Time for processing time. Basic operations are: Set: To set the time Display: To display the time */ #include <iostream> using namespace std; class Time /******** Member functions ********/ /* Set sets the data members of a Time object to specified values. * See Fig. 3.1 for documentation */ void Set( ); /* Display displays time in standard and military format using * output stream out. * See Fig. 3.1 for documentation */ void Display( ) ; /********** Data Members **********/ unsigned, ; char ; // 'A' or 'P' unsigned ; // military time equivalent ; // end of class declaration Notes: 1. The "my" in names of data members is simply to remind us of the "I-can-do-it-myself" nature of a class object. 2. The const at the end of Display()'s prototype makes it a, which means that. It is good practice to protect the data members in this way from accidental modification.

4 III-4 III. Classes 3. Why not make all members public? So they. Why? Otherwise programmers may use them in programs, other classes, libraries, However, the to improve storage, simplify algorithms for operations, etc., and all programs, classes, that access them directly must then be modified. Therefore: Always define data members of a class as private. Keeping the data members "hidden" forces programs to interact with an object through its, which thus provide the then programs that use an object will not require change. between programs and the class. If this interface does not change, 3. Implementation of a Class Usually, only the prototypes of the member functions are placed inside the class declaration to definitions are outside. However, when a declaration of some public item such as a type, constant, or function is inside a class declaration another name for "function prototype" is "function declaration" and is then referenced or defined outside the class declaration, the compiler must be informed where the declaration/prototype is This is accomplished using the which has the form This is referred to as the or name of ItemName. Example: class Something public: const int CAPACITY = 100; typedef double ArrayType[CAPACITY]; void Print(ArrayType a, int itssize);

5 III. Classes III-5 Traditionally, definitions of member functions have been put in an implementation file ClassName.cpp corresponding to the class' header file. This is done to. (Unfortunately, the class data members, which store data and are therefore part of the implementation, must be in the.h file.) With the increasing use of, however, this practice is becoming less common because current compiler technology doesn't permit this split for templates everything has to be in the same file. Thus the reason for dropping the ".h" from standard class libraries. They're really class-template libraries, and there are therefore no corresponding ".cpp" file. 4. Example: Definitions of Member Functions for class Time Version 1 /** Time.cc -- implements the Time member functions **/ #include "Time.h" /*** Utility Functions -- Prototypes ***/ int ToMilitary(unsigned hours, unsigned minutes, char am_pm); //----- Function to implement the Set operation void (unsigned hours, unsigned minutes, char am_pm) // Check if (hours >= 1 && hours <= 12 && minutes >= 0 && minutes <= 59 && (am_pm == 'A' am_pm == 'P')) myhours = hours; myminutes = minutes; myamorpm = am_pm; mymiltime = ToMilitary(hours, minutes, am_pm); else cerr << "*** Can't set time with these values ***\n"; // Object's data members remain unchanged //----- Function to implement the Display operation void (ostream & out) const out << myhours << ':' << (myminutes < 10? "0" : "") << myminutes << ' ' << myamorpm << ".M. (" << mymiltime << " mil. time)";

6 III-6 III. Classes /*** Utility Functions -- Definitions ***/ /* ToMilitary converts standard time to military time. * * Receive: hours, minutes, am_pm * Return: The military time equivalent ********************************************************/ int ToMilitary (unsigned hours, unsigned minutes, char am_pm) if (hours == 12) hours = 0; return hours * minutes + (am_pm == 'P'? 1200 : 0); 5. Testing the class // Test driver #include <iostream> using namespace std; int main() cout << "We'll be eating at "; cout << endl; Execution: We'll be eating at 5:30 P.M. (1730 military time) Again, note the difference from the procedural approach. Rather than package up the object and send it off to some function for processing, we To set my digital watch to 5:30 P.M., I don't wrap it up and mail it off to Casio and have them do it; rather, I push a button! To display the time, I don't wrap up my watch and mail if off to Casio and have them tell me what time it is. Ridiculous! I have it display the time to me itself, perhaps pushing a button to turn on the backlight so I can see it.

7 III. Classes III-7 6. Some Notes a. Member functions: "Inside" an object so don't pass object to them as a parameter. Another way to view this: They receive the class object to be operated on implicitly, rather than explicitly via a parameter. Non-member functions: "Outside" an object, so to operate on an object, they must receive it via a parameter. b. Public items like types and constants declared inside a class declaration must be qualified with the class name when used outside the class: ClassName::ItemName Constants are usually specified to be static so this is a global class property that can be accessed by all objects of that class type rather than having each such object carry around it's own copy of that constant. c. Nontrivial member functions: Usually: Prototypewithin the class Define outsided the class; must qualify their names: ClassName::FunctionName() d. Simple member functions: Usually: Specify that it be an function, which suggests to the compiler that it with parameters replaced by arguments, thus avoiding the usual overhead of a function call. This can be done in two ways: 1. Prototype the function inside the class declaration as usual, but its name as usual: In ClassName.h class ClassName // Public section -- function members ReturnType SimpleFunction(param_list); // Private section -- data members ; ReturnType ClassName::SimpleFunction(param_list) // function body

8 III-8 III. Classes 2. Simply In this case, it need not be prototyped, its name need not be qualified, and the compiler will treat it as an inline function: In ClassName.h class ClassName // Public section -- function members ReturnType SimpleFunction(param_list) // function body // Private section -- data members ; But use this method only for simple functions to avoid interface clutter. d. In Set(), we tested whether the arguments are valid: if (hours >= 1 && hours <= 12 && minutes >= 0 && minutes <= 59 && (am_pm == 'A' am_pm == 'P')) myhours = hours; myminutes = minutes; else This is to ensure that the following class invariant is true: This class invariant is intended to guarantee that the so that other function members can be sure of this Thus, whenever an operation modifies any of the data members, we should always check that. An alternative way to test this is to use the during debugging which: Accepts a boolean condition; If that condition is true, execution continues as usual. If the condition is false, execution halts and an error message is displayed. #include using namespace std; //----- Function to implement the Set operation mechanism (from <cassert> at least void Time::Set(unsigned hours, unsigned minutes, char am_pm) (hours >= 1 && hours <= 12 && minutes <= 59 && (am_pm == 'A' am_pm am_pm == 'P')); myhours = hours; myminutes = minutes;

9 III. Classes III-9 Testing: If we change driver.cpp as: mealtime.set(13, 30, 'P'); execution terminates with the following message: Time.cpp :11: failed assertion `hours >= 1 && hours <= 12 && minutes <= 59 && (am_pm == 'A' am_pm == 'P')' IOT trap A third alternative is to that the calling function can and take appropriate action //----- Function to implement the Set operation void Time::Set(unsigned hours, unsigned minutes, char am_pm) // Check class invariant if (hours >= 1 && hours <= 12 && minutes >= 0 && minutes <= 59 && (am_pm == 'A' am_pm == 'P')) else To catch this exception, a calling function might contain mealtime.set(13, 30, 'P'); cout << "This is a valid time\n"; cout << "ERROR: " << badtime << endl; exit(-1); cout << "Proceeding\n"; When executed, the output produced will be ERROR: *** Illegal initializer values ***

10 III-10 III. Classes 7. Class Constructors a. Recall that constructing an object consists of: (1) for the object, and (2) the object. In our example, after the declaration Time mealtime; memory has been allocated for mealtime, but it's data members are not initialized (and are likely to contain "garbage" values). It would be better if: the programmer could specify initial values for mealtime default values were used if no initial values are specified. b. This can be accomplished using. Properties: (1) Their primary role (for now) is to of an object with values (either default values or values provided as arguments) (2) Their names are always the same as the. (3) They are always function members and are (almost always) prototyped in the public section. (4) They do not return a value; they have (not even void). For this reason, documentation that describes their behavior commonly specify: 1. What values they receive (if any) via parameters: 2. Preconditions: Conditions that must be true before the function is called. and 3. Postconditions: Conditions that must be true when the function terminates. (5) Often they are quite simple and can be inlined in either of the two ways escribed earlier. (6) Constructors get called (7) If no constructor is given in the class, which allocates memory and initializes it with some default (possibly garbage) value. A default constructor is one that is used when the declaration of an object contains no initial values: ClassName object_name; (8) If we supply a constructor for a class, then we must also provide a default constructor.

11 III. Classes III-11 c. Example: Constructors for Time class In Time.h class Time /******** Member functions ********/ public: /***** Class constructors *****/ /* --- Construct a class object (default). * Precondition: A Time object has been declared. * Postcondition: The Time object is initialized to 12:00 A.M.; * that is, the myhours, myminutes, and myamorpm * members are initialized to 12, 0, 'A', respectively, * and mymiltime to 0. **********************************************************************/ /* --- Construct a class object (explicit values). * Precondition: A Time object has been declared. * Receive: Initial values inithours, initminutes, and * initampm * Postcondition: The myhours, myminutes, and myamorpm members * of thetime object are initialized to inithours, * initminutes, and initampm, respectively, and * mymiltime to the corresponding military time. **********************************************************************/ // other member function prototypes /********** Data Members **********/ private: ; // end of class declaration or

12 III-12 III. Classes class Time /******** Function Members ********/ public: /***** Class constructors *****/ /* --- Construct a class object (default) */ Time() myhours = 12; myminutes = 0; myamorpm = 'A'; mymiltime = 0; /* --- Construct a class object (explicit values) */ // other member function prototypes /********** Data Members **********/ private: ; // end of class declaration Add to Time.cpp #include <cassert> using namespace std; //----- Function to implement the explicit-value constructor (unsigned inithours, unsigned initminutes, char initampm) // Check class invariant assert(inithours >= 1 && inithours <= 12 && initminutes >= 0 && initminutes <= 59 && (initampm == 'A' initampm == 'P')); myhours = ; myminutes = ; myamorpm = ; mymiltime = ToMilitary(initHours, initminutes, initampm);

13 III. Classes III-13 Testing # 1 Time mealtime, bedtime(11,30,'p'); Creates and initializes 2 Time objects: Default Constructor Explicit-Value Constructor mealtime myhours myminutes myamorpm mymiltime Member functions bedtime myhours myminutes myamorpm mymiltime Member functions mealtime.display(cout); cout << endl; bedtime.display(cout); cout << endl; Execution: 12:00 A.M. (0 mil. time) 11:30 P.M. (2330 mil. time) Testing # 2 Time mealtime, bedtime(13,0,'p'); Execution: Time.cpp:12: failed assertion `inithours >= 1 && inithours <= 12 && initminutes <= 59 && (initampm == 'A' initampm == 'P')' IOT trap Note: We could combine both constructors into a single constructor function by using : Replace constructors in Time.h with: /* --- Construct a class object. Precondition: A Time object has been declared. Precondition: A Time object has been declared. Receive: Initial values inithours, initminutes, and initampm (defaults 12, 0, 'A') Postcondition: The myhours, myminutes, and myamorpm members of the Time object are initialized to inithours, initminutes, and initampm, respectively */

14 III-14 III. Classes Testing: Time mealtime, t1(5), t2(5, 30), t3(5, 30, 'P'); Creates 4 Time objects: mealtime myhours myminutes myamorpm mymiltime Member functions t1 myhours myminutes myamorpm mymiltime Member functions t2 myhours myminutes myamorpm mymiltime Member functions t3 myhours myminutes myamorpm mymiltime Member functions Execution: mealtime.display(cout); cout << endl; 12:00 A.M. (0 mil. time) t1.display(cout); cout << endl; 5:00 A.M. (500 mil. time) t2.display(cout); cout << endl; 5:30 A.M. (530 mil. time) t3.display(cout); cout << endl; 5:30 P.M. (1730 mil. time) Question: What happens with the declaration Time t(5, 'P'); Will it create Time object t with values 5, 0, 'P' in its data members? All parameters with default arguments must appear after all parameters without default arguments. 9. Copy Operations Two default copy operations are provided: 1. Copy in 2. Copy in Each makes a (byte-by-byte) copy of the data members of the object. Examples: Both: 1. Allocate memory for t 2. Copy data members of bedtime into them so t is a copy of bedtime : t bedtime myhours myminutes myamorpm mymiltime P 2330 Time t = myhours myminutes myamorpm mymiltime P 2330 also does: Right side calls the explicit-value constructor to construct a (temporary) Time object and then copies it into t. Note: These are not assignments; a default is called.

15 III. Classes III-15 There is a default copy operation for assignment. Example: copies the members of mealtime into t, replacing any previous values: t myhours myminutes myamorpm 12 0 A mymiltime 0 mealtime myhours myminutes myamorpm 12 0 A mymiltime 0 9. Access (Extractor) Functions Data members are private; they cannot be accessed outside the class. It is often necessary, however, to make the values stored in some or all of these members accessible. For this, access (or extractor) member functions can be provided. Example: Problem: To add extractors to class Time: (We will do this only for the myhours member; the others are essentially the same.) Specification: Receives: Returns: As usual, the specification tells us how to prototype the function: If we declare it as a member function, then it will be "inside" the Time object and so no parameters (Time or otherwise) will be needed. The function returns myhours, which is an integer. In addition, because this function simply retrieves the value stored in a data member, it is simple enough to. Also because it does not modify any data members it should be prototyped (and defined) as a function. Add to Time.h class Time /********** Data Members **********/ /******** Member functions ********/ public: /***** Data Retrievers *****/ /* Hour Accessor * Receive: The Time object containing this function (implicitly) * Return: The value stored in the myhours member of the Time * object containing this function *****************************************************************/ // and similar functions for myminutes, myamorpm, and mymiltime retrieval

16 III-16 III. Classes /********** Data Members **********/ private: ; // end of class declaration //----- Definition of Hour() inline unsigned Time::Hour() const; Testing: Time mealtime; Execution: cout << "Hour: " << mealtime.hour() << endl; Hour: Output and Input Overloading Operators Friend Functions Add output operation to a class early so that it can be used for debugging. It is convenient to overload operator<< for a Time object so we can write instead of cout << "We'll be eating at " << mealtime << endl; cout << "We'll be eating at " ; mealtime.display(cout); cout << endl; a. Overloading operators: In C++, operator can be implemented with the function If a member function of a class C, and a is of type C, the compiler treats a b as If not a member function of a class C the compiler treats a b as b. Overloading Output Operator << Can operator<<() be a member function? No, because the compiler will treat cout << t as which would mean that operator<<() would have to be a member of class ostream! Putting the prototype ostream & operator<<(ostream & out, const Time & t); inside the class declaration causes a compiler error like: `Time::operator <<(ostream &, const Time &)' must take exactly one argument because making operator<<() a member function of Time means that it already has the Time object containing it as an (implicit) parameter, so it can't have two more.

17 III. Classes III-17 Option 1: Put its prototype in the header file Time.h but outside the class declaration. and it's definition in Time.cpp Actually, because it is so simple, we inline it by putting it's definition in Time.h: class Time public: // documentation omitted to save space here Time(); Time(unsigned inithours, unsigned initminutes, char initampm); int Hour() const return myhour; int Minute() const return myminute; char AMPM() const return myamorpm; int MilTime() const return mymiltime; void Display(ostream & out); private: unsigned myhours, myminutes; char myamorpm; // 'A' or 'P' unsigned mymiltime; // military time equivalent ; // end of class declaration /* --- operator<< displays time in standard and military format using ostream out. Receives: An ostream out and a Time object t Output: The time represented by the Time object t Passes back: The ostream out with t inserted into it. Return value: out */ Why 1st parameter a reference parameter? The ostream gets modified so must be passed back. Why 2nd parameter a const reference parameter? To avoid the overhead of having to copy a class object. Why return a reference to out? So we can. For example: cout << t1 << endl << t2 << endl; Because << is, this is evaluated as Output So first function must return so expression becomes which is evaluated as 5:00 A.M. (500 mil. time) 5:30 A.M. (530 mil. time)

18 III-18 III. Classes Option 2: Replace Display() with operator<< : Replace the prototype of Display() in Time.h class Time public: ; /***** I/O Functions *****/ /* --- operator<< displays time in standard and military format using ostream out. Receives: An ostream out and a Time object t Output: The time represented by t Passes back: The ostream out with representation of t inserted into it. Return value: out */ ostream & operator<<(ostream & out, const Time & t); And replace the definition of Display() in Time.cpp //----- Function to implement ostream output ostream & operator<<(ostream & out, const Time & t) out << t.myhours << ':' << (t.myminutes < 10? "0" : "") << t.myminutes << ' ' << t.myamorpm << ".M. (" << t.mymiltime << " mil. time)"; return out; A function that a class names as a friend is a: to which the class has granted permission to. Note: Because a friend function is not a function member: It's definition is not qualified using the class name and the scope operator (::). It receives the time object on which it operates as a parameter It uses the dot operator to access the data members. b. Input To add an input operator to our Time class, we proceed in much the same way as for output. We could either: 1. Add a member function ReadTime() that reads values and stores them in the data members of a Time object; then call it from non-member function operator>>() 2. Declare operator>>() to be a friend function so that it can access the data members of a Time object and store input values in them.

19 III. Classes III-19 In our original version of this new data type, we had two other basic operations, comparing two Times to determine if one is less than another, and advancing a Time by a given number of hours and minutes. We will now consider how these can be added to the class. 10. Adding Relational Operators: We will describe how to add only one of the relational operators less than the others are similar. Specification: Receives: Two Time objects Returns: True if the first Time object is less than the second; false otherwise. Question: Should it be a member function? Question to help in deciding: Should it be inside the Time class from where it can operate on the Time object that contains it and another external Time object or should it be outside the class from where it can operate on any two Time objects? Answer: Either will work, but in keeping with the OOP "I-can-do-it-myself" principle of making objects selfcontained, we usually opt for using member functions whenever possible. In this case, we might better rephrase our specification as: Receives: Returns: A Time object (and the current object implicitly) True if I (the Time object containing this function) am less than the time object received; false otherwise. Add to Time.h: /***** Relational operators *****/ /* --- operator< determines if one Time is less than another Time Receive: A Time t (and the current object implicitly) Return: True if time represented by current object is < t */ Because of the simplicity of this function we inline it in either of the two ways described earlier; for example, put it's inlined definition after the end of the class declaration in Time.h: ; // end of class declaration

20 III-20 III. Classes For the external perspective:... class Time public: // member functions... /***** Relational operators *****/ /* --- operator< determines if one Time is less than another Time Receive: Two Times t1 and t2 Return: True if time t1 is less than time t2/ */ ; // end of class declaration 12. Adding Increment/Decrement Operators: Specification: Receives: Returns: A Time object (perhaps implicitly) The Time object with minutes incremented by 1 minute. Question: Should it be a member function? Yes Add to Time.h: /***** Increment operator *****/ /* --- Advance() increments a Time by 1 minute. Receive: Current time object (implicitly) Pass back: The Time object with its minutes incremented by */ void Advance(); Add to Time.cpp: //----- Function to implement Advance() void Time::Advance() myminutes++; myhours += myminutes / 60; myminutes %= 60; if (mymiltime == 1159) myamorpm = 'P'; else if (mymiltime == 2359) myamorpm = 'A'; // else no change mymiltime = ToMilitary(myHours, myminutes, myamorpm);

21 III. Classes III-21 We could overload operator++() but how do we distinguish between prefix ++ and postfix ++? Solution: In C++, operator++() with no parameters is prefix operator++(int) with one int parameter is postfix [The int parameter is not used in the definition.] 13. Problem of Redundant Declarations A class like Time might be used in a program, libraries, other class libraries, and so it could easily happen that it gets included several times in the same file e.g., Program needs Time class, so it #includes "Time.h" Program also needs library Lib, so it #includes "Lib.h" but Lib.h also #includes "Time.h" This would cause "redeclaration" errors during compiling. How do we prevent the declarations in Time.h from being included more than once in a file? Use Wrap the declarations in Time.h inside preprocessor directives like the following: [The preprocessor scans through a file removing comments, #including files, and processing other directives (which begin with #)before the file is passed to the compiler.] : : Usually the name of the class in all caps The first directive tests to see whether the identifier TIME has been defined. If it has not: Processing proceeds to the second directive, which defines TIME (to be 1), and then continues on through what follows and on to the #endif and beyond. If it has been defined: The preprocessor removes all code that follows until a #elif, #else, of #endif directive is encountered. Thus, the first time the preprocessor encounters a class declaration like Time, it defines the name TIME. If it encounters the class declaration again, since TIME has been defined, all code between #ifndef TIME and #endif is stripped, thus removing the redeclaration.