1. 1 Class Features and Design Issues COSC 1567 C++ Programming Lecture 5

2. 2 Objectives Classify the roles of member functions Constructors Override constructor default values Overload constructors Use a class within another class Preprocessor directives #ifndef, #define, and #endif Managing attributes and functions of classes Coupling and cohesion

3. 3 Introducing Member Functions You can create an infinite number of classes and write an infinite number of functions You can classify the roles of member functions into four basic groups: –Inspector functions, also called access functions –Mutator functions, also known as implementors –Auxiliary functions, also known as facilitators –Manager functions

4. 4 Understanding Constructors A constructor is a function that is called automatically each time an object is created Constructors have been used When declare a simple scalar variable, such as int number, C++ calls an internal constructor function that reserves a memory location of the correct size for an integer, and attaches the name “number” to that location The definition int number = 23; calls a constructor that reserves memory, attaches a name, and assigns a value

5. 5 Understanding Constructors Until now, when you created class objects, you let C++ provide its own constructor for the objects When an object is created, its data fields store whatever values (often called garbage values) happen to be in those positions in computer memory After you instantiated objects in your programs, you used a mutator function with a name such as setValues() to assign useful values to data members

6. Constructors Initialization of objects –Initialize some or all member variables –Other actions possible as well A special kind of member function –Automatically called when object declared Very useful tool –Key principle of OOP 6

7. Constructor Definitions Constructors defined like any member function –Except: 1.Must have same name as class 2.Cannot return a value; not even void! 7

8. 8 Understanding Constructors That process is similar to declaring a variable and assigning a value to it later However, you might want to initialize one or more of an object’s data members immediately upon creation When you want to initialize an object, or perform other tasks when the object is created, then you must write your own constructor for the class

9. 9 Writing Your Own Constructors A constructor that requires no arguments is a default constructor, regardless of whether the constructor has an empty argument list or an argument list in which a default value is provided for each argument Constructor functions differ from other member functions in two ways: –You must give a constructor function the same name as the class for which it is a constructor –You cannot give a constructor function a return type (it’s not necessary because constructors always return an object of the class to which they belong)

10. 10 Writing Your Own Constructors A constructor must have the same name as its class because the constructor is called automatically when an object is created If you named a constructor something other than its class name, C++ would not know it was a constructor Constructor functions are not coded with a return type

11. 11 Writing Your Own Constructors The constructor function Employee() shown in Figure 6-2 is called a default constructor because it does not require any arguments

12. 12 Employee Class and main() Function that Instantiates an Employee EX5-1.cpp

13. Another Constructor Example Class definition with constructor: –class DayOfYear { public: DayOfYear(int monthValue, int dayValue); //Constructor initializes month & day void input(); void output(); … private: int month; int day; } 13

14. Constructor Notes Notice name of constructor: DayOfYear –Same name as class itself! Constructor declaration has no return-type –Not even void! Constructor in public section –It’s called when objects are declared –If private, could never declare objects! 7

15. Calling Constructors Declare objects: DayOfYear date1(7, 4), date2(5, 5); Objects are created here –Constructor is called –Values in parens passed as arguments to constructor –Member variables month, day initialized: date1.month  7 date2.month  5 date1.dat  4 date2.day  5 8

16. Constructor Equivalency Consider: –DayOfYear date1, date2 date1.DayOfYear(7, 4);// ILLEGAL! date2.DayOfYear(5, 5);// ILLEGAL! Seemingly OK… –CANNOT call constructors like other member functions! 16

17. Constructor Code Constructor definition is like all other member functions: DayOfYear::DayOfYear(int monthValue, int dayValue) { month = monthValue; day = dayValue; } Note same name around :: –Clearly identifies a constructor Note no return type –Just as in class definition 10

18. Alternative Definition Previous definition equivalent to: DayOfYear::DayOfYear(int monthValue, int dayValue) : month(monthValue), day(dayValue)  {…} Third line called "Initialization Section" Body left empty Preferable definition version 11

19. Class with Constructors Example: Display 7.1 Class with Constructors (1 of 3) 19

20. Class with Constructors Example: Display 7.1 Class with Constructors (2 of 3) 20

21. Class with Constructors Example: Display 7.1 Class with Constructors (3 of 3) 21 Ex5-2.cpp

22. Constructor Additional Purpose Not just initialize data Body doesn’t have to be empty –In initializer version Validate the data! –Ensure only appropriate data is assigned to class private member variables –Powerful OOP principle 22

23. 23 Employee Class with Constructor that Uses Default Arguments EX5-3.cpp EX5-4.cpp

24. 24 Overriding the Constructor’s Default Arguments To replace the default values assigned by a constructor, you can use a mutator function such as setValues() You also can override a constructor’s default values by passing arguments to the constructor when you instantiate an object Two rules apply to the use of default parameters with constructor functions: –If you want to override constructor default values for an object you are instantiating, you also must override all parameters to the left of that value –If you omit any constructor argument when you instantiate an object, you must use default values for all parameters to the right of that argument

25. 25 Overriding the Constructor’s Default Arguments The result of the three instantiations is as follows: –An assistant with the default ID of 9999, an an hourly rate of 5.65 –A clerk whose 1111 ID overrides the default idNumber, but whose hourly rate is the default 5.65 –A driver show 2222 ID and hourly rate of 18.95 both override the default values in the constructor

26. 26 Overloading Constructors Just like other C++ functions, constructors can be overloaded Overloading a function name allows you to use the same name for separate functions that have different argument lists Constructor functions for a given class must all have the same name as their class If you provide two or more constructors for the same class, they are overloaded by definition

27. Overloading Constructors Recall: a signature consists of: –Name of function –Parameter list Provide constructors for all possible argument-lists –Particularly "how many" 27

28. 28 Employee Class with Overloaded Constructors EX5-5.cpp EX5-6.cpp

29. Default Constructor Defined as: constructor without arguments One should always be defined Auto-Generated? –Yes & No –If no constructors AT ALL are defined  Yes –If any constructors are defined  No If no default constructor: –Cannot declare: MyClass myObject; With no initializers 29 Ex5-7.cpp

30. 30 Using Destructors A destructor is a function that is called automatically each time an object is destroyed An object is destroyed when it goes out of scope The rules for creating destructor function prototypes are similar to the rules for constructor function prototypes –As with constructors, you must give a destructor function the same name as its class ( and therefore the same name as any constructor for that class) –As with constructors, you cannot give a destructor function a return type –Unlike constructors, you cannot pass any values to a destructor

31. 31 Using Destructors A destructor must have the same name as its class (plus the tilde) because it is called automatically when an object is destroyed Only one destructor can exist for each class The Object class in Figure 6-13 contains one field, a constructor, and a destructor

32. 32 Using Destructors Ex5-8.cpp Ex5-9.cpp

33. 33 Using Classes within Classes On many occasions you might want to use a class within another class Just as you build any complex real-life item, such as an automobile, from other well-designed parts, complex classes are easier to create if you use previously written, well-designed classes as components

34. Using Classes within Classes Class member variables can be any type –Including objects of other classes! –Type of class relationship Powerful OOP principle Need special notation for constructors –So they can call "back" to member object’s constructor 34

35. 35 The InventoryItem Class

36. 36 The Salesperson Class

37. 37 Using Classes within Classes To represent a sales transaction, you want to include information about the item sold and the salesperson who sold it You could write a transaction class that contained individual fields, such as item stock number and salesperson ID number, but it is more efficient to reuse the InventoryItem and Salesperson classes that are already created and tested

38. 38 The Transaction Class

39. 39 Using Classes within Classes Ex5-10.cpp

40. Another Example for Class Member Variable (Using classes in a class) 40

41. Class Member Variable Example: Display 7.3 A Class Member Variable (2 of 5) 41

42. Class Member Variable Example: Display 7.3 A Class Member Variable (3 of 5) 42

43. Class Member Variable Example: Display 7.3 A Class Member Variable (4 of 5) 43

44. Class Member Variable Example: Display 7.3 A Class Member Variable (5 of 5) 36 Ex5-11.cpp

45. 45 Considering Reusability and Maintenance Issues Reusability is a major focus of thinking in an object- oriented manner Creating self-contained components such as InventoryItem that you include in other classes makes program maintenance easier More than half of most programmers time on the job (and almost all of new programmers’ time) is spent maintaining or changing existing programs The more places a change must be made, the more time it takes, the more likely that an error occurs when that change is made, and the greater the change that one of the necessary changes is overlooked

46. Class Header Files Class interface always in header file –Use.h naming convention Programs that use class will "include" it –#include "myclass.h" –Quotes indicate you wrote header Find it in "your" working directory –Recall library includes, e.g., indicate predefined library header file Find it in library directory 46

47. Class Implementation Files Class implementation in.cpp file –Typically give interface file and implementation file same name myclass.h and myclass.cpp –All class’s member function defined here –Implementation file must #include class’s header file.cpp files in general, typically contain executable code –e.g., Function definitions, including main() 47

48. Class Files Class header file #included by: –Implementation file –Program file Often called "application file" or "driver file" Organization of files is system dependent –Typical IDE has "project" or "workspace" Implementation files "combined" here Header files still "#included" 48

49. Multiple Compiles of Header Files Header files –Typically included multiple times e.g., class interface included by class implementation and program file –Must only be compiled once! –No guarantee "which #include" in which file, compiler might see first Use preprocessor –Tell compiler to include header only once 49

50. Other Library Files Libraries not just for classes Related functions –Prototypes  header file –Definitions  implementation file Other type definitions –structs, simple typedefs  header file –Constant declarations  header file 50

51. 51 Using #IFNDEF, #DEFINE, and #ENDIF After you have created a collection of useful classes, often called a library, you might find that many class files contain the same #include statement Using the #define directive alone does not provide much benefit Instead, it is usually coupled with two other directives #ifndef and #endif The C++ directive #ifndef allows you to test whether a class has already been defined in a project

52. 52 Using #IFNDEF, #DEFINE, and #ENDIF The #ifndef directive means “if not defined” If you place an #ifndef at the beginning of a class, and the class has not been defined, then the #define directive will be implemented Ex5-12.cpp InventoryItem.cpp SalesPerson.cpp Transaction.cpp

53. 53 Improving Functions As you write larger and more complicated programs, be sure to spend time on planning and design Each class you design must be well thought out A final product is great only if each component is well designed—just ask anyone with a $30,000 car that leaks oil

54. 54 Selecting Member Data and Function Names When you begin to design a class and select its member functions, you need to consider the following questions: –Will special initialization tasks be necessary? –Will any special clean-up tasks be carried out when a class object goes out of scope? –Will class data members be assigned values after their construction?

55. 55 Selecting Member Data and Function Names C++ identifiers must not include spaces and cannot begin with a number, but you also must apply other general guidelines: –Use meaningful names –Use pronounceable names –Be judicious in your use of abbreviations –Avoid using digits in a name –Use capitalization freely in multi-word names –Include a form of “to be,” such as “is” or “are,” in names for variables that hold a status –Often a verb-noun provides a good combination for a function

56. 56 Selecting Member Data and Function Names Luckily, you do not have to write a C++ class or program completely before you can see whether the overall plan works Most programmers use stubs during the initial phases of a project Stubs are simple routines that do nothing (or very little); you incorporate them into a program as placeholders

57. 57 Reducing Coupling Between Functions Coupling is a measure of the strength of the connection between two functions; it expresses the extent to which information is exchanged by functions Coupling is either tight coupling or loose coupling, depending on how much one function depends on information from another Tight coupling, which features much dependence between functions, makes programs more prone to errors

58. 58 Increasing Cohesion within a Function Cohesion refers to how well the operations in a function relate to one another In highly cohesive functions, all operations are related Functional cohesion occurs when all of the function operations contribute to the performance of only one task The function square() is highly cohesive; it performs one simple task, squaring a number Sequential cohesion arises when a function performs operations that must be carried out in a specific order, on the same data

59. 59 Summary You can classify the roles of member functions into four basic groups: –Inspector— Mutator –Auxillary— Manager A constructor is a function that is called automatically each time an object is created If you want to override constructor default values for an object you are instantiating, you also must override all parameters to the left of that value If you provide two or more constructors for the same class, they are overloaded by definition

60. 60 Summary A destructor is a function that is called automatically each time an object is destroyed It has the same name as its class, preceded with a tilde You can use a class within another class, which gives you the ability to reuse well-crafted components instead of starting from scratch each time you create a class You cannot compile a program that includes the same file multiple times

61. 61 Summary When you create classes, you must decide on attributes and functions Coupling is a measure of the strength of the connection between two functions Tight coupling, which features dependence between functions, makes programs more prone to errors; loose coupling occurs when functions do not depend on others Cohesion refers to how well the operations in a function relate to one another

62. 62 Declarations! Test 1 –Feb. 14, 2011 –7:30pm-9:30pm –This room –Closed books and closed notes. Contents –Lecture 1-Lecure 5 Question types: –True or False –Multiple choices –Fill in blanks –Reading programs