clarity. In the first form, the access specifier public : is needed to {

Transcription

1 Structure Time CSC 211 Intermediate Programming Classes in C++ // Create a structure, set its members, and print it. struct Time // structure definition int hour; // 0-23 int minute; // 0-59 int second; // 0-59 ; void printmilitary( const Time & ); // prototype void printstandard( const Time & ); // prototype 1 2 Time dinnertime; // variable of new type Time // set members to valid values dinnertime.hour = 18; dinnertime.minute = 30; dinnertime.second = 0; cout << "Dinner will be held at "; printmilitary( dinnertime ); cout << " military time,\nwhich is "; printstandard( dinnertime ); cout << " standard time.\n"; // set members to invalid values dinnertime.hour = 29; dinnertime.minute = 73; cout << "\ntime with invalid values: "; printmilitary( dinnertime ); cout << endl; 3 // Print the time in military format void printmilitary( const Time &t ) cout << ( t.hour < 10? "0" : "" ) << t.hour << ":" << ( t.minute < 10? "0" : "" ) << t.minute; // Print the time in standard format void printstandard( const Time &t ) cout << ( ( t.hour == 0 t.hour == 12 )? 12 : t.hour % 12 ) << ":" << ( t.minute < 10? "0" : "" ) << t.minute << ":" << ( t.second < 10? "0" : "" ) << t.second << ( t.hour < 12? " AM" : " PM" ); Output Dinner will be held at 18 : 30 military time, Which is 6 : 30 : 00 PM standard time. Time with invalid values : 29 : 73 4 Implementing a Time Abstract Data Type with a Classes Notes Class Declaration By default, members are private; thus, in the second form, the Form 1 access specifier is optional, but is commonly included for class ClassName clarity. In the first form, the access specifier is needed to specify the public section of the class and private : to specify where the public section ends and the private section begins. Declarations of public members Although not commonly done, a class may have several private and public sections; the keyword private : marks the beginning of Declarations of private members each private section and the keyword marks the beginning ; Form 2 of each public section. class ClassName The data members are normally placed in the private section(s) of a class and the function members in the public section(s). // optional Private members can be accessed only by member functions and by Declarations of private members friend functions. Declarations of public members Public members can be accessed by both member and nonmember ; 5 functions. 6 1

2 Notes cont d OOP encapsulates data (attributes) and functions (behavior) into packages called classes. Out of a class, a programmer can create an object. One class can be reused many times to make many objects of the same class. Classes have the property of information hiding. This means that although class objects may know how to communicate with one other across well-defined interfaces, classes are not normally allowed to know how other classes are implemented implementation details are hidden within the classes themselves. In C and other procedural programming languages, programming tends to be action-oriented, whereas in C++ programming it is object-oriented. In C, the unit of programming is the function. In C++, the unit of programming is the class from which objects are eventually instantiated (created). Notes cont d C++ programmers concentrate on creating their own user-defined types called classes. Classes are also referred to as programmerdefined types. Each class contains data as well as the set of functions that manipulate the data. The data components of a class are called data members. The function components of a class are called member functions ( or methods in other OOLanguages ). Just as an instance of a builtin type such as int is called a variable, an instance of a class is called an object. Classes in C++ are a natural evolution of the C notion of struct. Classes enable the programmer to model objects that have attributes (represented as data members ) and behaviors or operations (represented as member functions). Types containing data members and member functions are defined in C++ using the keyword class. Member functions are sometimes called methods in other OO programming languages, and are invoked in response to messages sent to an object. A message corresponds to a member-function C programmers concentrate on writing functions. Data is certainly important, but the view is that data exists primarily in call sent from one object to another or sent from a function to an support of the actions that functions perform. 7 object. 8 Similarities: Structures and Classes Both can be used to model objects with different attributes represented as data members. They can thus be used to organize nonhomogeneous data sets. They have essentially the same syntax. Differences: Members of a class by default are private (cannot be accessed by nonmember functions). Members of a struct by default are public (can be accessed by nonmember functions via the dot operator. Because the data in a struct is public by default, we think of a struct as a passive data structure. The operations that are performed on a struct are usually global functions to which the struct is passed as a parameter. Although a struct may have member functions, they are seldom defined. In contrast, a class is an active data structure where the operations defined on the data members are member functions of the class. 9 Here is the equivalent class representation of a struct complex. //Show complex number in both struct and class representations //Implement as a struct (default is public) struct complex void assign(double r, double i); void print() cout << real << " + " << imag << "i "; double real, imag; ; inline void complex::assign(double r, double i = 0.0) real = r; imag = i; 10 Class complex Class complex cont d //Make public and private explicit in class class complex_c1 //need to know style- our preference void assign(double r, double i); void print() cout << real << " + " << imag << "i "; double real, imag; ; inline void complex_c1::assign(double r, double i = 0.0) real = r; imag = i; 11 //Implement as a class (default is private) class complex_c2 //old private-implicit style double real, imag; void assign(double r, double i); void print() cout << real << " + " << imag << "i "; ; void complex_c2::assign(double r, double i = 0.0) real = r; imag = i; 12 2

3 Test file main() complex a; complex_c1 b; complex_c2 c; a.assign(1.1, 2.2); b.assign(3.3, 4.4); c.assign(5.5, 6.6); cout << "\ncomplex from struct definition: "; a.print(); cout << "\ncomplex from class definition: "; b.print(); cout << "\ncomplex from explicit class definition: "; c.print(); Example - Fig. 6.3 Once a class has been defined, the class name can be used to declare objects of that class. Fig. 6.3 contains a simple definition for class Time. class Time Time ( ) ; void settime (int, int, int) ; void printmilitary ( ) ; void printstandard ( ) ; private : int hour ; // 0 23 int minute ; ; // 0 59 int second ; // 0 59 ; Discussions Our Time class definition begins with the keyword class. The body of the class definition is enclosed within left and right braces. The class definition terminates with a semicolon. Our Time class definition and our Time structure definition each contain integer members hour, minute and second. The and private : labels are called member accessed specifiers. Any data member or member function declared after member specifier public is accessible wherever the program has access to an object of class Time. Any data member or member function declared after member access specifier private is accessible only to member functions of the class. Member access specifiers are always followed by a colon ( : ) and can appear multiple times and in any order in a class definition. 15 Discussions cont d Notice the member function with the same name as the class; it ia called a constructor function of that class. A constructor is a special member function that initializes the data members of a class object. A class s constructor function is called automatically when an object of that class is created. Note that no return type is specified for the constructor. The three integer members appear after the private member access specifier. This indicates that these data members of the class are only accessible to member functions and to friend of the class. Thus, the data members can only be accesses by the four functions whose prototypes appear in the class definition (or by friends of the class). Data members are normally listed in the private portion of a class and member functions are normally listed in the public portion. It is possible to have private member functions as well as public data, but it is considered a poor programming practice. 16 Discussions cont d Example Once the class has been defined, it can be used as a type in declarations as follows: Fig. 6.3 uses the Time class. The program instantiates a single object of class Time called t. When Time sunset, arrayoftime[5], *pointertotime, &dinnertime = sunset ; // object of type Time // array of Time objects // pointer to a Time object // reference to a Time object an object is instantiated, the Time constructor is called automatically and explicitly initializes each private data member to 0. The time is then printed in military and standard formats to confirm that the members have been properly initialized. The time is then set using the settime member function and is printed The class name becomes a new type specifier. There may be many objects of a class, just as there may be many variables of a type such as int. again in both formats. Then settime attempts to set the data members to invalid values, and the time is again printed in both formats

4 // Fig. 6.3 // Time class. // Time abstract data type (ADT) definition class Time Time(); // constructor void settime( int, int, int ); // set hour, minute, second void printmilitary(); // print military time format void printstandard(); // print standard time format int hour; // 0-23 int minute; // 0-59 int second; // 0-59 ; // Time constructor initializes each data member to zero. // Ensures all Time objects start in a consistent state. Time::Time() hour = minute = second = 0; 19 // Set a new Time value using military time. Perform validity // checks on the data values. Set invalid values to zero. void Time::setTime( int h, int m, int s ) hour = ( h >= 0 && h < 24 )? h : 0; minute = ( m >= 0 && m < 60 )? m : 0; second = ( s >= 0 && s < 60 )? s : 0; // Print Time in military format void Time::printMilitary() cout << ( hour < 10? "0" : "" ) << hour << ":" << ( minute < 10? "0" : "" ) << minute; // Print Time in standard format void Time::printStandard() cout << ( ( hour == 0 hour == 12 )? 12 : hour % 12 ) << ":" << ( minute < 10? "0" : "" ) << minute << ":" << ( second < 10? "0" : "" ) << second << ( hour < 12? " AM" : " PM" ); 20 // Driver to test simple class Time Output Time t; // instantiate object t of class Time cout << "The initial military time is "; t.printmilitary(); cout << "\nthe initial standard time is "; t.printstandard(); t.settime( 13, 27, 6 ); cout << "\n\nmilitary time after settime is "; t.printmilitary(); cout << "\nstandard time after settime is "; t.printstandard(); t.settime( 99, 99, 99 ); // attempt invalid settings The initial military time is 00 : 00 The initial standars time is 12 : 00 : 00 AM Military time after settime is 13 : 27 Standard time after settime is 1 : 27 : 06 PM After attempting invalid settings: Military time : 00 : 00 Standard time : 12 : 00 : 00 AM cout << "\n\nafter attempting invalid settings:" << "\nmilitary time: "; t.printmilitary(); Note that the data members of a class cannot be initialized where they cout << "\nstandard time: "; t.printstandard(); cout << endl; are declared in the class body. These data members should be initialized by the class s constructor, or they can be assigned values by set function Constructor Constructors - Syntax A constructor is a member function of a class that has the same name as the class. A constructor is called automatically when an object of the class is declared. Constructors are used to initialize objects. A constructor must have the same name as the class of which it is a member. A constructor can also be called explicitly in order to create a new object. When we declare an object and want the constructor with zero arguments to be called, we do not include any parentheses after the object declaration. Syntax (for an object declaration when we have constructors) : Class_Name Object_Name (Arguments_for_Constructor) ; Syntax (for an explicit constructor call) : Object = Constructor_Name (Arguments_for_Constructor) ;

5 The Default Constructor: Example: this can be a constructor with no arguments or a constructor where all arguments have default values. It has the special purpose of iinitializing arrays of objects of its class. If a class does not have a constructor, the system provides a default constructor that does nothing This constructor will be called if class objects are declared. If a class has constructors, but does not have a default constructor, array allocation causes a syntactic error. In this case C++ compiler will generate no other constructors. class SampleClass SampleClass(int parameter1, double parameter2) ; with two arguments void do_stuff( ) ; private : int data1 ; double data2 ; ; SampleClass my_object(7, 7.77) ; // legal SampleClass your_object ; // illegal // constructor Solution: To add two arguments to the declaration of your_object To add a constructor definition for a constructor with no arguments SampleClass( ) ; If we do not want the default constructor to initialize any member variables, we leave the constructor s body empty. The following constructor definition is perfectly legal. It does nothing when called except make the compiler happy. SampleClass : : SampleClass( ) Do nothing. The implicit call to the constructor without arguments does not include parentheses. However when we explicitly call a constructor without arguments in an assignment statements, we do use parentheses. BankAccount account2( ) ; // this will cause problems Account1 = BankAccount( ) ; // OK Discussions A function with the same name as the class but preceded with a tilde character (~) is called the destructor of that class. The destructor does termination housekeeping on each class object before the memory for the object is reclaimed by the system. Destructors cannot take arguments and hence cannot be overloaded. The class definition contains declarations of the class s data members and the class s member functions. The member function declarations are the function prototypes. Member functions can be defined inside a class, but it is a good programming practice to define the functions outside the class definition Syntax: Member Function Definition ( non- constructor) Returned_Type Class_Name : : Function_Name(Parameter_List) Function_Body_Statements Action : The operation Funtion_Name( ) is a member function of the class called Class_Name. The scope resolution operator : : associates the function with the class. We use the dot operator or arrow operator to specify a member of the class object. We use the scope resolution opearator : : to specify the class name when giving the function definition for a member function. 29 Discussions Note the use of the binary scope resolution operator ( : : ) in each member function definition following the class definition in Fig Once a class is defined and its member functions are declared, the member functions must be defined. Each member function of the class can be defined directly in the class body (rather than including the function prototype of the class), or the member function can be defined after the class body. When a member function is defined after its corresponding class definition, the function name is preceded by the class name and the binary scope resolution operator ( : : ). Even though a member function declared in a class definition may be defined outside that class definition, that member function is still within that class s scope, i.e. its name is known only to other members of the class unless referred to via an object of the class, a reference to an object of the class, or a pointer to an object of the class. If a member function is defined in a class definition, the member function is automatically inlined. Member functions defined outside a class definition may be made inline by explicitly using the keyword inline. Remember that the compiler reserves the right not to inline any 30 function. 5

6 Discussions Classes simplify programming because the client need only be concerned with the operations encapsulated and embedded in the objects. Clients need not be concerned with a class s implementation. Interfaces do change, but less frequently than implementations. By hiding the implementation we eliminate the possibility of other program parts becoming dependent on the details of the class implementation. Often classes may be derived from other classes that provide attributes and behaviors the new class can use. Deriving new classes from existing classes is called inheritance. Classes can also include objects of other classes as members. Including class objects as members of other class is called composition. 31 Example: class StudentAccount private : string studentid ; // ID in the form ##.#### string studentname ; // student name double balance ; // account balance // constructor that initializes the data attributes StudentAccount(string ID, string name, double initbal) ; double getbalance( ) ; // return current balance void writeaccount( ) ; // output account information ; // return current value of private data member balance double StudentAccount : : getbalance( ) return balance ; 32 Example cont d: General Initializer Constructor with Initialization List // output account information along with labels void StudentAccount : : writeaccount( ) cout << ID : << studentid << endl ; cout << Name : << studentname << endl ; cout.setf(ios : : fixed, ios : : floatfield) ; // flags for real numbers cout.precision(2) ; // #include <iomanip.h> cout << Balance : << $ << balance << endl ; // general initializer constructor without initialization list StudentAccount : : StudentAccount (string ID, string name, double initbal) studentid = ID ; studentname = name ; balance = initbal ; 33 Syntax ClassName : : ClassName(T1 arg1, T2 arg2,, Tn argn) : datax (argm),, datay (argk) Statements initialize remaining data members Action: From the initialization list, data member datax is assigned the value argm, datay is assigned the value argk, and so forth. The remaining data members are assigned initial values in the body of the constructor. 34 Example: StudentAccount : : StudentAccount (string ID, string name, double initbal) : studentid ( ID), studentname(name), balance( initbal) In the above example, the function body is empty since no other statements are required. With simple constructors, all data members are given values by the initialization list and the function body is empty. 35 Example: Implementing the Rectangle class Class Rectangle // constructor Rectangle(double l = 0.0, double w = 0.0); // compute rectangle measurements double perimeter ( ) ; double area ( ) ; // data access functions double getlenght ( ) ; // return length double getwidth ( ) ; // return width // data update function void setsides(double l, double w) ; // update dimensions // length and width of the rectangle object double length, width ; ; 36 6

7 Implementing the Rectangle class cont d Constructor: // implementation of the Rectangle constructor Rectangle : : Rectangle (double l, double w) : length(l), width(w) Access Functions: // return the value of the length atribute double Rectangle : : getlength ( ) return length ; // return the value of the width atribute double Rectangle : : getwidth ( ) return width ; 37 Implementing the Rectangle class cont d Update Function: The values of length and width are initially set by the constructor. Their values can be updated during run-time by using the member function setsides( ). Since an initialization list is available only to the constructor, the new values must be assigned in the body of the function. // assign new values for the length and width void Rectangle : : setsides(double l, double w) length = l ; width = w ; 38 Implementing the Rectangle class cont d Measurement Functions : // the area is the product of the length and width double Rectangle : : area( ) return length * width ; // the perimeter is twice the sum of the length and width double Rectangle : : perimeter ( ) return 2 * (length + width) ; 39 // main program #include <math.h> // access sqrt function #include rect.h // access Rectangle class int main( ) double diagonal ; Rectangle rect(4.5, 8.2) ; cout.setf(ios : : fixed, ios : : floatfield) ; // flags for real numbers cout.precision(2) ; // #include <iomanip.h> cout << Area is << rect.area( ) << endl ; diagonal = sqrt(rect.getlength( ) * rect.getlength( ) + (rect.getwidth( ) * rect.getwidth( ) ) ; cout << Diagonal is << diagonal << endl ; return 0 ; Area is Diagonal is Class Scope and Accessing Class Members Nonmember functions are defined at file scope. Member functions have function scope in a class. // Fig. 6.4: fig06_04.cpp // Demonstrating the class member access operators. and -> // CAUTION: IN FUTURE EXAMPLES WE AVOID PUBLIC DATA! // Simple class Count class Count int x; void print() cout << x << endl; ; 41 Count counter, // create counter object *counterptr = &counter, // pointer to counter &counterref = counter; // reference to counter cout << "Assign 7 to x and print using the object's name: "; counter.x = 7; // assign 7 to data member x counter.print(); // call member function print cout << "Assign 8 to x and print using a reference: "; counterref.x = 8; // assign 8 to data member x counterref.print(); // call member function print cout << "Assign 10 to x and print using a pointer: "; counterptr->x = 10; // assign 10 to data member x counterptr->print(); // call member function print Assign 7 to x and print using the object s name : 7 Assign 8 to x and print using a reference : 8 Assign 10 to x and print using a pointer :

8 Separating Interface from Implementation Syntax : Class Header File (public interface) // Declaration of the class (including the function prototypes) // type of the file: header file (.h) // Prevent multiple inclusions of header file #ifndef ClassName_H #define ClassName_H // class declaration class ClassName. private :. ; #endif 43 Syntax: Member Function Definitions (implementation of the class) // class implementation // type of the file: source file (.cpp) #include <C++ system header files> #include programmer-defined header files // constructor implementation classname : : classname (... ) : // member functions implementation returntype classname : : memberfunction (... ) Example: Syntax : Driver Program // Driver to test the class // type of the file: source file (.cpp) #include <C++ system header files> #include programmer-defined header files returntype main ( ) Fig. 6.6 splits the program of Fig. 6.3 into multiple files.. It consists of the header file time1.h in which class Time is declared, the file time2.cpp in which the member functions of class Time are defined, and the file fig06_o5.cpp in which function main is defined Controlling Access to Members Only member functions and friends of that class can access a class s private members. The public members of a class may be accessed by any function in the program. The primary purpose of public members is to present to the class s clients a view of the services (behavior) the class provides. This set a services forms the public interface of the class. The private members of a class as well as the definitions of its public member functions are not accessible to the clients of a class. These components form the implementation of the class. 47 // Fig. 6.6: time1.h // Declaration of the Time class. #ifndef TIME1_H #define TIME1_H // Time abstract data type definition class Time Time(); // constructor void settime( int, int, int ); // set hour, minute, second void printmilitary(); // print military time format void printstandard(); // print standard time format int hour; // 0-23 int minute; // 0-59 int second; // 0-59 ; #endif 48 8

9 // Fig. 6.6: time1.cpp // Member function definitions for Time class. #include "time1.h" // Time constructor initializes each data member to zero. // Ensures all Time objects start in a consistent state. Time::Time() hour = minute = second = 0; // Set a new Time value using military time. Perform validity // checks on the data values. Set invalid values to zero. void Time::setTime( int h, int m, int s ) hour = ( h >= 0 && h < 24 )? h : 0; minute = ( m >= 0 && m < 60 )? m : 0; second = ( s >= 0 && s < 60 )? s : 0; // Print Time in military format void Time::printMilitary() cout << ( hour < 10? "0" : "" ) << hour << ":" << ( minute < 10? "0" : "" ) << minute; // Print time in standard format void Time::printStandard() cout << ( ( hour == 0 hour == 12 )? 12 : hour % 12 ) << ":" << ( minute < 10? "0" : "" ) << minute << ":" << ( second < 10? "0" : "" ) << second << ( hour < 12? " AM" : " PM" ); 49 // Fig. 6.6: fig06_06.cpp // Demonstrate errors resulting from attempts // to access private class members. #include "time1.h" int main( ) Time t; // Error: 'Time::hour' is not accessible t.hour = 7; // Error: 'Time::minute' is not accessible cout << "minute = " << t.minute; Compiling FIG06_06.CPP : Error FIG06_06.CPP 12 : Time : : hour is not accessible Error FIG06_06.CPP 12 : Time : : minute is not accessible 50 Using Default Arguments with Constructors // Fig. 6.8: time2.h // Declaration of the Time class. #ifndef TIME2_H #define TIME2_H // Time abstract data type definition class Time Time( int = 0, int = 0, int = 0 ); void settime( int, int, int ); void printmilitary(); void printstandard(); int hour; // 0-23 int minute; // 0-59 int second; // 0-59 ; #endif // default constructor // set hour, minute, second // print military time format // print standard time format 51 // Fig. 6.8: time2.cpp // Member function definitions for Time class. #include "time2.h" // Time constructor initializes each data member to zero. // Ensures all Time objects start in a consistent state. Time::Time( int hr, int min, int sec ) settime( hr, min, sec ); // Set a new Time value using military time. Perform validity // checks on the data values. Set invalid values to zero. void Time::setTime( int h, int m, int s ) hour = ( h >= 0 && h < 24 )? h : 0; minute = ( m >= 0 && m < 60 )? m : 0; second = ( s >= 0 && s < 60 )? s : 0; // Print Time in military format void Time::printMilitary() cout << ( hour < 10? "0" : "" ) << hour << ":" << ( minute < 10? "0" : "" ) << minute; // Print Time in standard format void Time::printStandard() cout << ( ( hour == 0 hour == 12 )? 12 : hour % 12 ) << ":" << ( minute < 10? "0" : "" ) << minute << ":" << ( second < 10? "0" : "" ) << second << ( hour < 12? " AM" : " PM" ); 52 // Fig. 6.8: fig06_08.cpp // Demonstrating a default constructor // function for class Time. #include "time2.h" Time t1, // all arguments defaulted t2(2), // minute and second defaulted t3(21, 34), // second defaulted t4(12, 25, 42), // all values specified t5(27, 74, 99); // all bad values specified cout << "Constructed with:\n << "all arguments defaulted:\n "; t1.printmilitary(); cout << "\n "; t1.printstandard(); cout << "\nhour specified; minute and second defaulted:" << "\n "; t2.printmilitary(); cout << "\n "; t2.printstandard(); cout << "\nhour and minute specified; second defaulted:" << "\n "; t3.printmilitary(); cout << "\n "; t3.printstandard(); cout << "\nhour, minute, and second specified:" << "\n "; t4.printmilitary(); cout << "\n "; t4.printstandard(); cout << "\nall invalid values specified:" << "\n "; t5.printmilitary(); cout << "\n "; t5.printstandard(); cout << endl; 53 Constructed with : All arguments defaulted : 00 : : 00 : 00 AM hour specified ; minute and second defaulted : 02 : 00 2 : 00 : 00 AM hour and minute specified ; second defaulted : 21 : 34 9 : 34 : 00 PM hour, minute, and second specified : 12 : : 25 : 42 PM all invalid values specified : 00 : : 00 : 00 AM 54 9

10 Using Destructors A destructor is a special member function of a class. The name of the destructor for a class is the tilde (~) character followed by the class name. A class s destructor is called when an object is destroyed e.g. when program execution leaves the scope in which an object of that class was instantiated. The destructor itself does not actually destroy the object it performs termination housekeeping before the systems reclaims the object s memory so that memory may be reused to hold new objects. A destructor receives no parameters and returns no value. A class may have only one destructor destructor overloading is not allowed. 55 When Constructors and Destructors are Called Constructors and destructors are called automatically. Generally, destructor calls are made in the reverse order of the constructor calls. Constructors are called for objects defined in global scope before any other function (including main) in that file begins execution. The corresponding destructors are called when main terminates or the exit function is called. Constructors are called for automatic local objects when execution reaches the point where the objects are defined. The corresponding destructors are called when the objects leave scope ( i.e., the block in which they are defined is exited). Constructors and destructors for automatic objects are called each time the objects enter and leave scope. Constructors are called for static local objects only once when execution first reaches the point where the objects are defined. Corresponding destructors are called when main terminates or the exit function is called. 56 // Fig. 6.9: create.h // Definition of class CreateAndDestroy. #ifndef CREATE_H #define CREATE_H class CreateAndDestroy CreateAndDestroy( int ); // constructor ~CreateAndDestroy(); // destructor int data; ; #endif 57 // Fig. 6.9: create.cpp // Member function definitions for class CreateAndDestroy #include "create.h" CreateAndDestroy::CreateAndDestroy( int value ) data = value; cout << "Object " << data << " constructor"; CreateAndDestroy::~CreateAndDestroy() cout << "Object " << data << " destructor " << endl; 58 // Fig. 6.9: fig06_09.cpp // Demonstrating the order in which constructors and // destructors are called. #include "create.h" void create( void ); // prototype CreateAndDestroy first( 1 ); // global object cout << " (global created before main)" << endl; CreateAndDestroy second( 2 ); // local object cout << " (local automatic in main)" << endl; static CreateAndDestroy third( 3 ); // local object cout << " (local static in main)" << endl; create(); // call function to create objects CreateAndDestroy fourth( 4 ); // local object cout << " (local automatic in main)" << endl; Object 1 constructor (global created before main) Object 2 constructor (local automatic in main) Object 3 constructor (local static in main) Object 5 constructor (local automatic in create) Object 6 constuctor (local static in create) Object 7 constructor (local automatic in create) Object 7 destructor Object 5 destructor Object 4 constructor (local automatic in main) Object 4 destructor Object 2 destructor Object 6 destructor Object 3 destructor // Function to create objects void create( void ) CreateAndDestroy fifth( 5 ); cout << " (local automatic in create)" << endl; static CreateAndDestroy sixth( 6 ); cout << " (local static in create)" << endl; CreateAndDestroy seventh( 7 ); cout << " (local automatic in create)" << endl; 59 Object 1 destructor 60 10

11 Function main declares three objects. Objects second and fourth are local automatic objects, and object third is a static local object. The constructor for each of these objects are called when execution reaches the point where each object is declared. The destructors for objects fourth and second are called in that order when the end of main is reached. Because object third is static, it exists until program termination. The destructor for object third is called before the destructor for first, but Function create declares three objects fifth and seventh are local automatic objects, and sixth is a static local object. The destructors for objects seventh and fifth are called in that order when the end of create is reached. Because sixth is static, it exists until program termination. The destructor of sixth is called before the destructors for third and first, but after all other objects are destroyed. after all other objects are destroyed Assignment by Default Memberwise Copy The assignment operator ( = ) can be used to assign an object to another object of the same type. Such assignment is by default performed by memberwise copy each member of one object is copied individually to the same member in another object. 63 // Fig. 6.12: fig06_12.cpp // Demonstrating that class objects can be assigned // to each other using default memberwise copy // Simple Date class class Date Date( int= 1, int= 1, int= 1990 ); // default constructor void print(); int month; int day; int year; ; // Simple Date constructor with no range checking Date::Date( int m, int d, int y ) month = m; day = d; year = y; // Print the Date in the form mm-dd-yyyy void Date::print() cout << month << '-' << day << '-' << year; 64 Date date1( 7, 4, 1993 ), date2; // d2 defaults to 1/1/90 cout << "date1 = "; date1.print(); cout << "\ndate2 = "; date2.print(); date2 = date1; // assignment by default memberwise copy cout << "\n\nafter default memberwise copy, date2 = "; date2.print(); cout << endl; date1 = date2 = After default memberwise copy, date2 =