1 Class Features and Design Issues COSC 1567 C++ Programming Lecture 5.
-
Upload
geraldine-henry -
Category
Documents
-
view
218 -
download
1
Transcript of 1 Class Features and Design Issues COSC 1567 C++ Programming Lecture 5.
11
Class Features and Design Class Features and Design IssuesIssues
COSC 1567COSC 1567
C++ ProgrammingC++ Programming
Lecture 5
22
ObjectivesObjectives
• 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
33
Introducing Member FunctionsIntroducing 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
44
Understanding ConstructorsUnderstanding 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
55
Understanding ConstructorsUnderstanding 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
ConstructorsConstructors
• 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
66
Constructor DefinitionsConstructor Definitions
• Constructors defined like any member function
– Except:
1. Must have same name as class
2. Cannot return a value; not even void!
77
88
Understanding ConstructorsUnderstanding 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
99
Writing Your Own ConstructorsWriting 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)
1010
Writing Your Own ConstructorsWriting 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
1111
Writing Your Own ConstructorsWriting Your Own Constructors
• The constructor function Employee() shown in Figure 6-2 is called a default constructor because it does not require any arguments
1212
Employee Class and main() Function Employee Class and main() Function that Instantiates an Employeethat Instantiates an Employee
EX5-1.cpp
Another Constructor ExampleAnother 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;}
1313
Constructor NotesConstructor 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!
77
Calling ConstructorsCalling 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 5date1.dat 4 date2.day 5
88
Constructor EquivalencyConstructor Equivalency
• Consider:– DayOfYear date1, date2
date1.DayOfYear(7, 4); // ILLEGAL!date2.DayOfYear(5, 5); // ILLEGAL!
• Seemingly OK…– CANNOT call constructors like other member
functions!
1616
Constructor CodeConstructor 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
1010
Alternative DefinitionAlternative 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
1111
Class with Constructors Example: Class with Constructors Example: Display 7.1 Display 7.1 Class with Constructors (1 of 3)Class with Constructors (1 of 3)
1919
Class with Constructors Example: Class with Constructors Example: Display 7.1 Display 7.1 Class with Constructors (2 of 3)Class with Constructors (2 of 3)
2020
Class with Constructors Example: Class with Constructors Example: Display 7.1 Display 7.1 Class with Constructors (3 of 3)Class with Constructors (3 of 3)
2121
Ex5-2.cpp
Constructor Additional PurposeConstructor 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
2222
2323
Employee Class with Constructor Employee Class with Constructor that Uses Default Argumentsthat Uses Default Arguments
EX5-3.cpp
EX5-4.cpp
2424
Overriding the Constructor’s Overriding the Constructor’s Default ArgumentsDefault 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
2525
Overriding the Constructor’s Overriding the Constructor’s Default ArgumentsDefault 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
2626
Overloading ConstructorsOverloading 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
Overloading ConstructorsOverloading Constructors
• Recall: a signature consists of:– Name of function– Parameter list
• Provide constructors for all possibleargument-lists– Particularly "how many"
2727
2828
Employee Class with Employee Class with Overloaded ConstructorsOverloaded Constructors
EX5-5.cpp
EX5-6.cpp
Default ConstructorDefault 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
2929
Ex5-7.cpp
3030
Using DestructorsUsing 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
3131
Using DestructorsUsing 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
3232
Using DestructorsUsing Destructors
Ex5-8.cpp
Ex5-9.cpp
3333
Using Classes within ClassesUsing 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
Using Classes within ClassesUsing 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
3434
3535
The InventoryItem ClassThe InventoryItem Class
3636
The Salesperson ClassThe Salesperson Class
3737
Using Classes within ClassesUsing 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
3838
The Transaction ClassThe Transaction Class
3939
Using Classes within Using Classes within ClassesClasses
Ex5-10.cpp
Another Example for Class Member VariableAnother Example for Class Member Variable(Using classes in a class) (Using classes in a class)
4040
Class Member Variable Example: Class Member Variable Example: Display 7.3 Display 7.3 A Class Member Variable (2 of 5)A Class Member Variable (2 of 5)
4141
Class Member Variable Example: Class Member Variable Example: Display 7.3 Display 7.3 A Class Member Variable (3 of 5)A Class Member Variable (3 of 5)
4242
Class Member Variable Example: Class Member Variable Example: Display 7.3 Display 7.3 A Class Member Variable (4 of 5)A Class Member Variable (4 of 5)
4343
Class Member Variable Example: Class Member Variable Example: Display 7.3 Display 7.3 A Class Member Variable (5 of 5)A Class Member Variable (5 of 5)
3636
Ex5-11.cpp
4545
Considering Reusability and Considering Reusability and Maintenance IssuesMaintenance 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
Class Header FilesClass 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., <iostream>• < > indicate predefined library header file• Find it in library directory
4646
Class Implementation FilesClass 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 containexecutable code– e.g., Function definitions, including main()
4747
Class FilesClass 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"
4848
Multiple Compiles of Header Multiple Compiles of Header FilesFiles
• 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
4949
Other Library FilesOther 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
5050
5151
Using #IFNDEF, #DEFINE, Using #IFNDEF, #DEFINE, and #ENDIFand #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
5252
Using #IFNDEF, #DEFINE, Using #IFNDEF, #DEFINE, and #ENDIFand #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.cppInventoryItem.cppSalesPerson.cppTransaction.cpp
5353
Improving FunctionsImproving 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
5454
Selecting Member Data Selecting Member Data and Function Namesand 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?
5555
Selecting Member Data Selecting Member Data and Function Namesand 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
5656
Selecting Member Data Selecting Member Data and Function Namesand 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
5757
Reducing Coupling Between Reducing Coupling Between FunctionsFunctions
• 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
5858
Increasing Cohesion within Increasing Cohesion within a Functiona 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
5959
SummarySummary
• 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
6060
SummarySummary
• 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
6161
SummarySummary
• 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
6262
Declarations!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