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


• 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


• 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


• 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


• 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


2020


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


• 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


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


• 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


• 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


4242


4343


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


• 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


• 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

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

Documents

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