RECOMMENDATION. Don't Write Entire Programs Unless You Want To Spend 3-10 Times As Long Doing Labs! Write 1 Function - Test That Function!

Transcription

1 1

2 2 RECOMMENDATION Don't Write Entire Programs Unless You Want To Spend 3-10 Times As Long Doing Labs! Write 1 Function - Test That Function! 2

3 Function Overloading C++ provides the capability of Using The Same Function Name For More Than One Function (function overloading). Since the Compiler Must Be Able to Determine Which Function To Use Based on the Number & Data Types of the Parameters, the Function Signatures of each function Must Be Unique. 3

4 We Could Create Function Max (int No1, int No2) Coding Might Be As Follows int Max (int No1, int No2) { int NewMax; if(no1 >= No2) NewMax = No1; else NewMax = No2; return (NewMax); } Main int main(int argc, char * argv[] ) { printf ("Max (5, -7) = %d\n", Max (5, -7)); getchar(); return(0); } 4 4

5 We Could Also Create Function Max (double No1, double No2) Coding The Function Overload Might Be As Follows:Max double Max (double No1, double No2) { double NewMax; if(no1 >= No2) NewMax = No1; else NewMax = No2; return (NewMax); } Main int main(int argc, char * argv[] ) { printf ("Max (5, -7) = %d\n", Max (5, -7)); printf ("Max (5.5, 2.9) = %f\n", Max (5.5, 2.9)); getchar(); return(0); } 5 Warning: creating overloaded functions with identical parameter lists and different return types is a syntax error!! 5

6 Function Signature The Signatures Of Each Function Overload Must Be Different! Signature 1 Max(int, int) Signature 2 Max(double, double) "Function overloading is pretty unique to C++"; it is not supported in standard C or most other languages. WIKI But There are a number of languages that do support Function Overloading: Java, Python, Scala, etc. 6

7 7

8 Simple Aggregate Arrays, Structs, Classes Aggregate A Collection Of Objects Stored As One Unit! C/C++ The array is an Aggregate! C/C++ The Struct is an Aggregate! C++ The Class is an Aggregate! 8

9 9

10 10

11 11

12 Each & Every C++ File You Submit This Semester Must Include A Completed Documentation Block At The Top ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // // // main.cpp // // // // Purpose : // // // // // // Written By : Thomas E. Hicks Environment : Windows 10 // // Date...: xx/xx/xxxx Compiler...: Visual Studio 2017 C++ // ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// It Is Time We Update This Documentation Block! 12

13 Add The Following Includes To The Top Of Your Program ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // // // Main.cpp // // // // Purpose : Create and test a Student Class // // This program will demonstrate the includes, defines, class // // definitions, prototypes, all class methods. Included will be // // constructors, destructors, set, display, operator overloads, // // etc. // // // // Written By : Thomas E. Hicks Environment : Windows 10 // // Date...: xx/xx/xxxx Compiler...: Visual Studio 2017 C++ // ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // Includes # include "Utilities.hpp" COMPILE THE PROGRAM! 13

14 Add The Following Defines To The Top Of Your Program ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // // // Main.cpp // // // // Purpose : Create and test a Student Class // // This program will demonstrate the includes, defines, class // // definitions, prototypes, all class methods. Included will be // // constructors, destructors, set, display, operator overloads, // // etc. // // // // Written By : Thomas E. Hicks Environment : Windows 10 // // Date...: xx/xx/xxxx Compiler...: Visual Studio 2017 C++ // ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // Includes # include "Utilities.hpp" COMPILE THE PROGRAM! // Defines # define MALE false # define FEMALE true # define STUDENT_DIAGNOSTIC_LEVEL 1 14

15 We Want To Create A Class That Is Equivalent To Struct Student struct Student { char Name [20]; }; // Set To Be Empty String long No; // Set To Be 0 bool Gender; // Set To MALE 15

16 16

17 Class Student No Methods/Function & No Data // Includes # include "Utilities.hpp" // Defines # define MALE false # define FEMALE true # define STUDENT_DIAGNOSTIC_LEVEL 1 COMPILE THE PROGRAM! // Classes & Structs class Student { }; 17

18 int main (int argc, char * argv[]) { Add The Following Class To main COMPILE THE PROGRAM! puts (" "); puts (" "); puts ("++ Class Student Added To Main ++"); puts ("++ ++"); puts ("++ Writen By ++"); puts ("++ Dr. Tom Hicks YOUR NAME ++"); puts (" "); puts (" \n"); puts (" Start Of Main \n"); } { } Student John; puts (" HitCarriageReturnToContinue(); return (0); End Of Main \n"); Does Not Do Much Yet! 18

19 Instantiation Instantiation is one of the most important mechanisms for code reuse in object-oriented programming languages; instantiation of a class is the creation of a new instance of that class. Programmers can define object classes, define their own kinds of objects, and instantiate them as needed. This is one of the most important mechanisms for code reuse in objectoriented programming languages. Student John; Instantiates A Student Type Object Called John it is pretty much an empty object at this point but we will change all that! 19

20 20

21 Classes Are All About Security Add public & private! class Student { public: COMPILE THE PROGRAM! Most Classes Will Contain A Public Portion! The public portion will include constructors, destructors, and other functions/methods that we want the world to access. Most Classes Will Contain A Private Portion! }; private: The private portion will often include the data members and functions that we do not want to be public. As a general rule, we would like to very rigidly control access to the data! 21

22 Add The Student Data Members class Student { public: COMPILE THE PROGRAM! Only Student Methods/Functions, And Friends Of This Class, Will Be Able To Access Private Data Members Name, No, & Gender! We Will Study "Friends" Later! private: }; char Name [20]; long No; // Set To Be 0 bool Gender; // Set To MALE // Set To Be Empty String 22

23 puts (" Try The Following In main Start Of Main \n"); Student John; John.No = 1232; Delete This Line Of Code! COMPILE THE PROGRAM! puts (" End Of Main \n"); Note The Underline Indicating A Problem! 23

24 24

25 class Student { public: Student (void); }; About Constructors The Constructor is a Function Whose Name Is The Same As The Class It Is The Constructors Responsibility To Do All That Is Necessary To Initialize/Assign The Data Members. The Constructor Will Most Often Be In The Public Section Of The Class.. The Constructor Will Often Have Parameters, But Not Always. 25

26 class Student { public: Student (void); }; About Constructors - 2 When an Object of a Class is Created, C++ Automatically Calls the Constructor for that class. If No Constructor Is Defined, C++ creates & invokes a default constructor, which allocates memory for the object, but doesn't initialize it. (Seldom Used) A Class may have multiple Constructors; this function can be OVERLOADED! 26

27 Add The Student Constructor Prototype class Student { public: Student(void); private: char Name [20]; long No; bool Gender; }; COMPILE THE PROGRAM! Linker Error The compiler cannot find a function, called Student Maybe It Does Not Exist YES Maybe It Does Not Exist In The Way We Called It arguments don't match 27

28 Add Code For The Student Constructor Below main We Already Have The Prototype In The Class Student Each & Every Class Method/Function Will Include The Name Student::Student(void) Student:: ) { Of The Class (Student) & The Scope Operator ( :: ) After The Scope Operator ( :: ) Will Be The Name Of The Function Constructor Is Name Of Class Inside The Parenthesis Are The Arguments Passed None This Time } COMPILE THE PROGRAM! 28

29 Finish Student(void) The Constructor Is To Do All That Is Necessary To Create A New Object Never Leave Garbage?? Data Student::Student(void) { } if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student(void)"); strcpy_s(name, ""); No = 0; COMPILE THE PROGRAM! Gender = MALE; COMPILE THE PROGRAM AGAIN! It Compiles, But That Does Not Make It Correct Doubting Thomas I Don't Even Know That It Was Executed! Doubting Thomas 29

30 30

31 Add The Student Destructor Prototype class Student { public: Student(void); ~Student(void); private: char Name [20]; long No; bool Gender; }; COMPILE THE PROGRAM! Linker Error The compiler cannot find a function, called ~Student Every Class Has A Destructor. If You Do Not Add A Class Destructor, The Compile Builds One - Which Does Nothing - During Compilation. If You Include The Prototype For The Destructor, You Must Add The Code. 31

32 Add Code For The Student Destructor Below main We Already Have The Prototype In The Class Student Each & Every Class Method/Function Will Include The Name Student::~Student(void) { } Of The Class (Student) & The Scope Operator ( :: ) After The Scope Operator ( :: ) Will Be The Name Of The Function Destructors Begin With ~ Inside The Parenthesis Are The Arguments Passed None This Time COMPILE THE PROGRAM! if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Destructor ~Student(void)"); 32

33 int main (int argc, char * argv[]) { Add The Following Class To main COMPILE THE PROGRAM! puts (" "); puts (" "); puts ("++ Class Student Added To Main ++"); puts ("++ ++"); puts ("++ Writen By ++"); puts ("++ Dr. Tom Hicks ++"); puts (" "); puts (" \n"); puts (" Start Of Main \n"); } { // Object John Created In This Scope Student John; } // Object John Will Be Destroyed In This Scope puts (" End Of Main \n"); HitCarriageReturnToContinue(); return (0); 33

34 34

35 About Classes - 1 Each class has a Public Portion containing Methods & Data Available to All that utilize the class. Each class has a Private Portion containing Methods & Data Available Only Available To Member Functions the & Friends Of This Class. The Constructor, whose name is the same as the class, does all that is necessary to Create An Object. 35

36 About Classes - 2 The Destructor, whose name is ~ + the name of the class, does all that is necessary to Destroy An Object. All Classes have a Destructor; if the programmer does not create one, the compiler creates one which does nothing. Class Functions are called Methods or Member Functions [Constructor, Destructor, Set, Display]. A Class Bundles Both Data & Methods [Encapsulation] this was not so with c structs. Class Data called Data Members [ Name, No, Gender]. 36

37 About Classes - 3 Times When You Need To Code The Destructor 1] When Constructor Opens The File, The Destructor Should Generally Close It. 2] When The Constructor Allocates Dynamic Memory, The Destructor Should Generally Return That Memory To The Operating System. 3] When The Constructor Turns On An A to D Card, the Destructor Should Generally Turn It Off. 37

38 Time To Organize Testing! 38

39 # include "Utilities.hpp" // Defines # define MALE false # define FEMALE true # define STUDENT_CLASS # define STUDENT_DIAGNOSTIC_LEVEL 1 // Classes & Structs class Student Objective: { public: Student(void); ~Student(void); private: char Name[20]; long No; bool Gender; }; Add The Following Class To Your Program Create An Organized Testing Procedure That Can Be Quickly & Easily Turned On & Off. We Will Turn It On During Development Then Turn It Off We Will Turn It Back On When Class Is Modified During Maintenance! // Prototypes # ifdef STUDENT_DIAGNOSTIC_LEVEL // void TestStudent(void); # endif // STUDENT_DIAGNOSTIC_LEVEL

40 Modify Constructor Diagnostic Level Student::Student(void) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student(void)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, ""); No = 0; Gender = MALE; When we first create the constructor and destructor, it is a great idea to make sure that they are being executed. # define STUDENT_DIAGNOSTIC_LEVEL 12 Once we are sure they are being executed, we will set the Diagnostic Level to 2 The message "Evoking Constructor Student(void)" would no longer display. 40

41 Suppose We Were To Comment Out The STUDENT_CLASS -1 # include "Utilities.hpp" // Defines # define MALE false # define FEMALE true //# define STUDENT_CLASS # define STUDENT_DIAGNOSTIC_LEVEL 1 // Classes & Structs class Student { If We Were To Comment Out the define for public: STUDENT_CLASS Student(void); ~Student(void); private: char Name[20]; long No; bool Gender; }; I Will Model This With A Lot Of The Test Code That I Give You This Semester! Then The Prototype for TestStudent Would No Longer Be Associated With The Class. IF DONE CORRECTLY We Will Be Able To Leave All Of The Test Code To Reuse When It Is Necessary Modify The Class Later For Maintenance! // Prototypes # ifdef STUDENT_DIAGNOSTIC_LEVEL // void TestStudent(void); # endif // STUDENT_DIAGNOSTIC_LEVEL

42 Suppose We Were To Comment Out The STUDENT_CLASS -2 //# define STUDENT_CLASS Student::Student(void) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student(void)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, ""); No = 0; Gender = MALE; If We Were To Comment Out the define for STUDENT_CLASS Then Diagnostic Level Display Code Would No Longer Be Assocaited With the Class We Will Be Able To Keep All Of Our Test Code And Yet Add 0 Bytes To Our Final Compiled Projects! 2 42

43 Modify Constructor Diagnostic Level //# define STUDENT_CLASS Student::~Student(void) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Destructor ~Student(void)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } If We Were To Comment Out the define for STUDENT_CLASS Then Diagnostic Level Display Code Would No Longer Be Assocaited With the Class 43

44 44

45 Add TestStudent Below main # ifdef STUDENT_DIAGNOSTIC_LEVEL // void TestStudent(void) COMPILE THE PROGRAM! { puts("\n\n"); puts("*******************************************************************"); puts("*******************************************************************"); puts("************************ Start TestStudent ************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("************************ End TestStudent ************************"); puts("*******************************************************************"); puts("*******************************************************************"); } # endif // STUDENT_DIAGNOSTIC_LEVEL All of out test code will go away when we comment out //# define STUDENT_CLASS 45

46 46

47 Add TestStudent Below main # ifdef STUDENT_DIAGNOSTIC_LEVEL // void TestStudent(void) { puts("\n\n"); puts("*******************************************************************"); puts("*******************************************************************"); puts("************************ Start TestStudent ************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("*******************************************************************"); puts("************************ End TestStudent ************************"); puts("*******************************************************************"); puts("*******************************************************************"); } # endif // STUDENT_DIAGNOSTIC_LEVEL

48 Add Diagnostic Level 1-A (In TestStudent) if (STUDENT_DIAGNOSTIC_LEVEL <= 1) { puts("\n\n"); puts("==================================================================="); puts("==================================================================="); puts("=========== Testing Constructor & Destructor =============="); puts("=========== STUDENT_DIAGNOSTIC_LEVEL = 1 =============="); puts("==================================================================="); puts("===================================================================\n"); Student Student1, Class[4]; } HitCarriageReturnToContinue(); 48

49 int main (int argc, char * argv[]) { puts (" "); puts (" "); puts ("++ Class Student Added To Main ++"); puts ("++ ++"); puts ("++ Writen By ++"); puts ("++ Dr. Tom Hicks ++"); puts (" "); puts (" \n"); puts (" Start Of Main \n"); TestStudent(); Add The Following Class To main COMPILE THE PROGRAM! } puts (" HitCarriageReturnToContinue(); return (0); End Of Main \n"); 49

50 50

51 Modify Diagnostic Level 1-B if (STUDENT_DIAGNOSTIC_LEVEL <= 1) { puts("\n\n"); puts("==================================================================="); puts("==================================================================="); puts("=========== Testing Constructor & Destructor =============="); puts("=========== STUDENT_DIAGNOSTIC_LEVEL = 1 =============="); puts("==================================================================="); puts("===================================================================\n"); Student Student1, Student2 ("Pete", 2222, MALE), Class[4]; } HitCarriageReturnToContinue(); Suppose We Would Like Be Able To Create & Initialize A Student Object Our Constructor Only Accepts A Signature Student(-) We Could Create A Constructor To Accept A Signature Student(char[ ], int, bool) 51

52 Student (char[ ], long, bool) 52

53 Add A Prototype For New Constructor To Class Student // Classes & Structs class Student { public: Student(void); Student (char NewName[], long NewNo, bool NewGender); ~Student(void); private: char Name[20]; long No; bool Gender; }; Will Not Work? Student (char Name[], long No, bool Gender); Class Data Member Called Name - Parameter Called Name NO 53

54 Student (char [ ],long, bool) Student::Student(char NewName[], long NewNo, bool NewGender) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student (NewName[], NewNo, NewGender)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, NewName); No = NewNo; Gender = NewGender; COMPILE THE PROGRAM! Constructor Student Is Overloaded! Accepts More Than One Signature! 54

55 55

56 if (STUDENT_DIAGNOSTIC_LEVEL <= 1) { puts("\n\n"); puts("==================================================================="); puts("==================================================================="); puts("=========== Testing Constructor & Destructor =============="); puts("=========== STUDENT_DIAGNOSTIC_LEVEL = 1 =============="); puts("==================================================================="); puts("===================================================================\n"); Student Student1, Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Class[4]; Modify Diagnostic Level 1-C } HitCarriageReturnToContinue(); Suppose We Would Like Be Able To Accept A Signature Student(char[ ], long) We could create "yet another constructor" but this provides me with the opportunity to discuss "Default Arguments" 56

57 57

58 Default Arguments Must Be Placed Only In Prototype Modify Class Student // Classes & Structs class Student { public: Student(void); Student (char NewName[], long NewNo, bool NewGender = MALE); ~Student(void); private: char Name[20]; long No; bool Gender; }; In The Event That We Choose Not To Pass A Gender It Becomes MALE Requires No Change to the this Constructor Student(char [ ], long, bool) to make it accept Student(char [ ], long) Will Sometimes Compile in linux and other times not! Be Careful! 58

59 This Now Accepts The Gender Is Optional Student (char [ ],long) & Student (char [ ],long, bool) Prototype: Student (char NewName[], long NewNo, bool NewGender = MALE); Student::Student(char NewName[], long NewNo, bool NewGender) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student (NewName[], NewNo, NewGender)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, NewName); No = NewNo; Gender = NewGender; COMPILE THE PROGRAM! There May Be More Than One Default Argument but they must all be in a group going Right To Left. Student (char NewName[], long NewNo, bool NewGender = MALE); OK Student (char NewName[], long NewNo = 0, bool NewGender = MALE); OK Student (char NewName[]="", long NewNo = 0, bool NewGender = MALE); OK 59

60 This Now Accepts Compile Student(-), Student (char [ ],long), & Student (char [ ],long, bool) Prototype: Student(void); Student (char NewName[], long NewNo, bool NewGender = MALE); Student::Student(char NewName[], long NewNo, bool NewGender) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student (NewName[], NewNo, NewGender)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, NewName); No = NewNo; Gender = NewGender; COMPILE THE PROGRAM! 60

61 61

62 Modify Diagnostic Level 1-D Final Testing Must Accept All Of The Following if (STUDENT_DIAGNOSTIC_LEVEL <= 1) { puts("\n\n"); puts("==================================================================="); puts("==================================================================="); puts("=========== Testing Constructor & Destructor =============="); puts("=========== STUDENT_DIAGNOSTIC_LEVEL = 1 =============="); puts("==================================================================="); puts("===================================================================\n"); Student Several Different Solutions Student1, Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Student4 ("Amber"), Student5 (5555, "Nathan", MALE), Student6 (6666, "Betty"), Student7 (7777), Class[4]; } HitCarriageReturnToContinue(); 62

63 Suppose: Match Function Calls With Constructors 1 public: (1) Student(void); (2) Student (char NewName[], long NewNo, bool NewGender); Student Student1, Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Student4 ("Amber"), Student5 (5555, "Nathan", MALE), Student6 (6666, "Betty"), Student7 (7777), Class[4]; 63

64 Suppose: Match Function Calls With Constructors 2 public: (1) Student(void); (2) Student (char NewName[], long NewNo = 0, bool NewGender); Student Student1, Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Student4 ("Amber"), Student5 (5555, "Nathan", MALE), Student6 (6666, "Betty"), Student7 (7777), Class[4]; 64

65 Suppose: Match Function Calls With Constructors 3 public: (1) Student(void); (2) Student (char NewName[] = "", long NewNo = 0, bool NewGender); Student Student1(), Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Student4 ("Amber"), Student5 (5555, "Nathan", MALE), Student6 (6666, "Betty"), Student7 (7777), Class[4]; The Compiler Does Not Know What To Do Since There Are Two Constructors That Accept Student(-) Not Compile! Constructor (1) Accepts Signatures : Student(-) Constructor(2) Accepts Signatures : Student(-) Student(char [ ]) Student(char [ ], long) Student(char [ ], long, bool) 65

66 Suppose: Match Function Calls With Constructors 4 public: (1) Student (long NewNo,char NewName[] = "", bool NewGender); (2) Student (char NewName[] = "", long NewNo = 0, bool NewGender); Student Student1, Student2 ("Pete", 2222, MALE), Student3 ("Sandra", 3333), Student4 ("Amber"), Student5 (5555, "Nathan", MALE), Student6 (6666, "Betty"), Student7 (7777), Class[4]; Suppose We Get Rid Of Constructor (1) As It Is Was & Replace It No Conflicts We Have A Plan! Constructor(1) Accepts Signatures : Student (long) Student (long, char [ ]) Student (long, char [ ], bool) 66

67 Student (long, char[ ], bool) 67

68 Double-Check Your Prototypes In Class Student // Classes & Structs class Student { public: Student (char NewName[] = "", long NewNo = 0, bool NewGender); Student (long NewNo,char NewName[] = "", bool NewGender = MALE); ~Student(void); private: char Name[20]; long No; bool Gender; }; 68

69 Student (char [ ],long, bool) Student::Student (long NewNo, char NewName[], bool NewGender) { # ifdef STUDENT_DIAGNOSTIC_LEVEL // if (STUDENT_DIAGNOSTIC_LEVEL <= 1) puts("evoking Constructor Student (NewNo, NewName[], NewGender)"); # endif // STUDENT_DIAGNOSTIC_LEVEL } strcpy_s(name, NewName); No = NewNo; Gender = NewGender; COMPILE THE PROGRAM! Class[4] Should Call The Constructor 4 times You Can Look At The Output & Match Up The Function Calls! 69

70 Look At Total Output Note that 11 constructors are fired & 11 destructors are fired! But We Still Don't Know If The Constructors Are Working Correctly! 70

71 71

72 Add The Following Block Of Code Immediately Above Your Constructors ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // Method Student // // // // Purpose : Constructors for Class Student. Set Name to NewName and No to // // NewNo and Gender to NewGender. Default NewName = blank. // // Default NewNo = 0. Default Sex = FEMALE = false. // // // // Written By : Dr. Tom Hicks Environment : Windows 10 // // Date...: xx/xx/xxxx Compiler...: Visual Studio 2017 C++ // ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// Use Your Name & Today's Date 72

73 My Constructor Code 73

74 74

75 Add The Following Block Of Code Immediately Above Your Destructor ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// // ~Student // // // // Purpose : Do all that is necessary to destroy an object. In this class we // // are only going to insert a diagnostic display to verify the the // // destructor is firing properly. // // // // Written By : Dr. Tom Hicks Environment : Windows 10 // // Date...: xx/xx/xxxx Compiler...: Visual Studio 2017 C++ // ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// Use Your Name & Today's Date 75

76 My Destructor Code 76

77 77

78 Always Back Up Your Class Work Make a copy of folder TomH-Student-1 Your Name on your Y Drive. Make a copy of folder TomH-Student-1 Your Name on your personal computer. Make a copy of folder TomH-Student-1 Your Name on your personal flash drive. 78