1

Final ExamFinal ExamTues 3/16/10 (2-3:50)Tues 3/16/10 (2-3:50)

(Same classroom)(Same classroom)

Old Textbook - Chapters 11-16, 18Old Textbook - Chapters 11-16, 18Focus is on 15, 16 and 18Focus is on 15, 16 and 18

Multiple choice, True/False and some minimal programming will be required

2

Topics CoveredTopics Covered

• List Structures (Arrays & Linked List)• C++ Classes• Inheritance• Object-Oriented Programming• Pointers• Dynamic Memory• Recursion

3

Array-Based List

4

Linked List ADT

5

Array List vs. Linked List ADT

Array List

• Pre-allocation Required• Waste-full if you allocate too much• Fatal if you allocate too little• Data has to be shifted when an item is

inserted or deleted at specified position

Linked List• Truly dynamic, memory is allocated as

needed• No shifting when an item is inserted, deleted

6

For the Final Exam

You will NOT be asked to write a Linked List. You don’t have to create an array either.

Questions related to Link List and Arrays are concept based, (no code writing).

7

Structured Data Type Structured Data Type

Definition: A structured data type is a type in which each value is a collection of component items. The entire collection has a single name each component can be accessed individually

Know what is meant by a structured data type. You do not need to create a struct or use one on the final exam.

8

Accessing struct Members

Dot ( period ) is the member selection operator.

After the struct type declaration, the various members can be used in your program only when they are preceded by a struct variable name and a dot.

EXAMPLESthisAnimal.weightanotherAnimal.country

9

Abstraction Abstraction

Abstraction is the separation of the essential qualities of an object from the details of how it works or is composed

It focuses on what, not how

It is necessary for managing large, complex software projects

10

Abstract Data Type (ADT)Abstract Data Type (ADT)

Is a programmer-defined type with a set of

values and allowable operations for the type.

Some ways to define a new C++ type are:

using struct

using class

11

ADT Specification ExampleADT Specification Example

TYPETimeType

DOMAINEach TimeType value is a time in hours, minutes, and seconds.

OPERATIONSSet the timePrint the timeIncrement by one secondCompare 2 times for equalityDetermine if one time is “less than” another

12

ADT Implementation means ADT Implementation means

Choosing a specific data representation for the abstract data using data types that already exist (built-in or programmer-defined) Called “Data Members”

Writing functions (member functions) for each allowable operation

13

Information HidingInformation Hiding

Class implementation details are hidden from the client’s view. This is called information hiding.

Public functions of a class provide the interface between the client code and the class objects.

clientcode

specification implementation

abstraction barrier

14

Benefits of information hidingBenefits of information hiding

Data and details can be concealed from the client of the abstraction.

Code can be changed without affecting the client because the specification and interface are unchanged.

15

class TimeTypeclass TimeType Specification Specification

// Specification File ( timetype.h )

class TimeType // declares a class data type{ // does not allocate

memory

public : // 5 public function members

void Set ( int hours , int mins , int secs ) ;void Increment ( ) ;void Write ( ) const ;bool Equal ( TimeType otherTime ) const ; bool LessThan ( TimeType otherTime ) const ;

private : // 3 private data members

int hrs ; int mins ; int secs ;

} ;

16

Use of C++ data TypeUse of C++ data Type class class

Facilitates re-use of C++ code for an ADT

Software that uses the class is called a client

Variables of the class type are called class objects or class instances

Client code uses public member functions to handle its class objects

17

Using Using classclass

A class is a programmer-defined type whose components (called class members) can be variables or functions.

Class members are private by default. Compiler does not permit client code to access private class members.

Class members declared public form the interface between the client and the class.

In most classes, the private members contain data, and the public members are functions to manipulate that data.

18

Member functions categorized by taskMember functions categorized by task

CONSTRUCTOR -- a member function that actually creates a new instance and initialized some or all of its data members

ACCESS FUNCTION or OBSERVER -- a member function that can inspect (use but not modify) the data members of a class without changing their values. Such a function is declared with const following the parameter list in both the specification and the implementation files.

19

Client Code UsingClient Code Using TimeTypeTimeType

#include “timetype.h” // includes specification of the classusing namespace std ;

int main ( ){

TimeType currentTime ; // declares 2 objects of TimeType TimeType endTime ; bool done = false ;

currentTime.Set ( 5, 30, 0 ) ; endTime.Set ( 18, 30, 0 ) ; while ( ! done )

{ . . .

currentTime.Increment ( ) ;if ( currentTime.Equal ( endTime ) )

done = true ; } ;}

19

20

classclass type Declaration type Declaration

The class declaration creates a data type and names the members of the class.

It does not allocate memory for any variables of that type!

Client code still needs to declare class variables.

21

C++ Data Type C++ Data Type classclass represents an ADT represents an ADT

2 kinds of class members: data members and function members

Class members are private by default

Data members are generally private

Function members are generally declared public

Private class members can be accessed only by the class member functions (and friend functions), not by client code.

22

AggregateAggregate class class Operations Operations

Built-in operations valid on class objects are:

Member selection using dot ( . ) operator ,

Assignment to another class variable using ( = ),

Pass to a function as argument

(by value or by reference),

Return as value of a function

Other operations can be defined as class member functions

23

2 separate files Generally Used for2 separate files Generally Used for classclass Type Type

// Specification File ( timetype .h ) // Specifies the data and function members. class TimeType { public: . . .

private: . . . } ;

// Implementation File ( timetype.cpp ) // Implements the TimeType member functions. . . .

24

Implementation File for Implementation File for TimeTypeTimeType

// Implementation File ( timetype.cpp ) // Implements the TimeType member functions.

#include “ timetype.h” // also must appear in client code #include <iostream>

. . .

bool TimeType :: Equal (TimeType otherTime ) const // Function value == true, if this time equals otherTime // == false , otherwise { return ( (hrs == otherTime.hrs) && (mins == otherTime.mins) && (secs == otherTime.secs)

) ; }

. . .

25

Scope Resolution Operator ( :: ) Scope Resolution Operator ( :: )

C++ programs typically use several class types

Different classes can have member functions with the same identifier, like Write( )

Member selection operator is used to determine the class whose member function Write( ) is invoked

currentTime .Write( ) ; // class TimeTypenumberZ .Write( ) ; // class ComplexNumberType

In the implementation file, the scope resolution operator is used in the heading before the function member’s name to specify its class

void TimeType :: Write ( ) const{ . . .

}

26

Class Constructors Class Constructors

A class constructor is a member function whose purpose is to initialize the private data members of a class object

The name of a constructor is always the name of the class, and there is no return type for the constructor

A class may have several constructors with different parameter lists. A constructor with no parameters is the default constructor

A constructor is implicitly invoked when a class object is declared--if there are parameters, their values are listed in parentheses in the declaration

27

Specification of Specification of TimeType TimeType Class Class Constructors Constructors

class TimeType // timetype.h{public : // 7 function members

void Set ( int hours , int minutes , int seconds ) ;void Increment ( ) ;void Write ( ) const ;bool Equal ( TimeType otherTime ) const ; bool LessThan ( TimeType otherTime ) const ;

TimeType ( int initHrs , int initMins , int initSecs ) ; // constructor

TimeType ( ) ; // default constructor

private : // 3 data membersint hrs ; int mins ; int secs ;

} ; 27

28

Implementation of Implementation of TimeTypeTimeType Default Default Constructor Constructor

TimeType :: TimeType ( )// Default Constructor// Postcondition: // hrs == 0 && mins == 0 && secs == 0{

hrs = 0 ; mins = 0 ; secs = 0 ;}

29

Implementation of Another Implementation of Another TimeTypeTimeType Class Constructor Class Constructor

TimeType :: TimeType ( int initHrs, int initMins, int initSecs )

// Constructor

// Precondition: 0 <= initHrs <= 23 && 0 <= initMins <= 59

// 0 <= initSecs <= 59

// Postcondition:

// hrs == initHrs && mins == initMins && secs == initSecs

{

hrs = initHrs ;

mins = initMins ;

secs = initSecs ;

}

30

Separate Compilation and Linking of FilesSeparate Compilation and Linking of Files

timetype.h

client.cpp timetype.cpp

client.obj

client.exe

timetype.obj

Compiler Compiler

Linker

#include “timetype.h”

implementation file

specification file

main program

31

For the Final ExamFor the Final Exam

Note: You will be asked to write a simple class, without using dynamic memory. (no Copy Constructor or Destructor writing will be required.)

You should know what a copy constructor and a destructor is in concept.

32

PointersPointers

• A pointer holds the memory address of another object.• Through the pointer we can indirectly manipulate the

referenced object.

Pointers are useful for

• Creating linked data structures such as linked lists,• management of dynamically allocated objects, and• as a function parameter type for passing large objects

such as arrays.

Pass-by-valuePass-by-value

CALLINGBLOCK

FUNCTION CALLED

sends a copy of the contents of the actual parameter

SO, the actual parameter cannot be changed by the function.

33

Pass-by-referencePass-by-reference

sends the location (memory address)of the actual parameter

can change value ofactual parameter

CALLINGBLOCK FUNCTION

CALLED

34

35

Obtaining Memory AddressesObtaining Memory Addresses

the address of a non-array variable can be obtained by using the address-of operator &

int x;float number;char ch;

cout << “Address of x is “ << &x << endl;

cout << “Address of number is “ << &number << endl;

cout << “Address of ch is “ << &ch << endl;

36

What is a pointer variable?What is a pointer variable?

A pointer variable is a variable whose value is the address of a location in memory.

to declare a pointer variable, you must specify the type of value that the pointer will point to, for example,

int* ptr; // ptr will hold the address of an int

char* q; // q will hold the address of a char

37

Using a Pointer VariableUsing a Pointer Variable

int x;

x = 12;

int* ptr;

ptr = &x;

NOTE: Because ptr holds the address of x,

we say that ptr “points to” x

2000

12

x

3000

2000

ptr

38

2000

12

x

3000

2000

ptr

int x; x = 12;

int* ptr; ptr = &x;

cout << *ptr;

NOTE: The value pointed to by ptr is denoted by *ptr

Unary operator Unary operator ** is the indirection is the indirection (deference) operator(deference) operator

39

int x; x = 12;

int* ptr; ptr = &x;

*ptr = 5; // changes the value // at address ptr to 5

Using the Dereference OperatorUsing the Dereference Operator

2000

12 5

x

3000

2000

ptr

40

char ch; ch = ‘A’;

char* q; q = &ch;

*q = ‘Z’; char* p; p = q; // now p and q both point to ch

Another ExampleAnother Example

4000

A Z

ch

5000 6000

4000 4000

q p

Operator Operator newnew Syntax Syntax

new DataType

new DataType [IntExpression]

If memory is available, in an area called the heap (or free store) new allocates the requested object or array, and returns a pointer to (address of ) the memory allocated.

Otherwise, program terminates with error message.

The dynamically allocated object exists until the delete operator destroys it. 41

42

3 Kinds of Program Data3 Kinds of Program Data

STATIC DATA: memory allocation exists throughout execution of program

AUTOMATIC DATA: automatically created at function entry, resides in activation frame of the function, and is destroyed when returning from function

DYNAMIC DATA: explicitly allocated and deallocated during program execution by C++ instructions written by programmer using operators new and delete

43

Dynamically Allocated DataDynamically Allocated Data

char* ptr;

ptr = new char;

*ptr = ‘B’;

cout << *ptr;

NOTE: Dynamic data has no variable name

2000

ptr

‘B’

44

Dynamically Allocated DataDynamically Allocated Data

char* ptr;

ptr = new char;

*ptr = ‘B’;

cout << *ptr;

delete ptr;

2000

ptr

NOTE: delete de-allocates the memory pointed to by ptr

?

Operator delete returns to the free store memory which was previously allocated at run-time by operator new.

The object or array currently pointed to by the pointer is deallocated, and the pointer is considered unassigned.

Using Operator Using Operator deletedelete

45

Operator Operator deletedelete Syntax Syntax

delete Pointer

delete [ ] Pointer

If the value of the pointer is 0 there is no effect.

Otherwise, the object or array currently pointed to by Pointer is deallocated, and the value of Pointer is undefined. The memory is returned to the free store.

Square brackets are used with delete to deallocate a dynamically allocated array. 46

47

Dynamic Array Deallocation Dynamic Array Deallocation

char *ptr ;

ptr = new char[ 5 ];

strcpy( ptr, “Bye” );

ptr[ 1 ] = ‘u’;

delete ptr; // deallocates array pointed to by ptr // ptr itself is not deallocated // the value of ptr is undefined.

ptr

?

48

int* ptr = new int; *ptr = 3;

ptr = new int; // changes value of ptr *ptr = 4;

What happens here?What happens here?

3

ptr

3

ptr

4

49

Inaccessible ObjectInaccessible Object

An inaccessible object is an unnamed object that was created by operator new and which a programmer has left without a pointer to it.

int* ptr = new int;

*ptr = 8;

int* ptr2 = new int;

*ptr2 = -5;

8

ptr

-5

ptr2

50

Making an Object InaccessibleMaking an Object Inaccessible

int* ptr = new int;

*ptr = 8;

int* ptr2 = new int;

*ptr2 = -5;

ptr = ptr2; // here the 8 becomes inaccessible

8

ptr

-5

ptr2

8

ptr

-5

ptr2

51

Memory LeakMemory Leak

A memory leak is the loss of available memory space that occurs when dynamic data is allocated but never deallocated.

52

int* ptr = new int;

*ptr = 8;

int* ptr2 = new int;

*ptr2 = -5;

ptr = ptr2;

delete ptr2; // ptr is left dangling

ptr2 = NULL;

Leaving a Dangling PointerA pointer that points to dynamic memory that has been de-allocated

8

ptr

-5

ptr2

8

ptr

NULL

ptr2

53

Why is a destructor needed?Why is a destructor needed?

When a DynArray class variable goes out of scope, the memory space for data members size and pointer arr is deallocated.

But the dynamic array that arr points to is not automatically deallocated.

A class destructor is used to deallocate the dynamic memory pointed to by the data member.

54

DynArray::~DynArray( );

// Destructor.

// POST: Memory for dynamic array deallocated.

{

delete [ ] arr ;

}

54

class DynArray Destructorclass DynArray Destructor

55

Shallow CopyShallow Copy vs.vs. Deep CopyDeep Copy

a shallow copy copies only the class data members, and does not make a copy of any pointed-to data

a deep copy copies not only the class data members, but also makes a separate stored copy of any pointed-to data

56

Initialization of Class ObjectsInitialization of Class Objects

C++ defines initialization to mean

•initialization in a variable declaration

•passing an object argument by value

•returning an object as the return value of a function

by default, C++ uses shallow copies for these initializations

57

As a result . . .As a result . . .

when a class has a data member pointer to dynamically allocated data, you should write what is called a copy constructor

the copy constructor is implicitly called in initialization situations and makes a deep copy of the dynamic data in a different memory location

58

Copy ConstructorsCopy Constructors

When there is a copy constructor provided for a class, the copy constructor is used to make copies for pass by value

You do not call the copy constructor

Like other constructors, it has no return type

Because the copy constructor properly defines pass by value for your class, it must use pass by reference in its definition

59

Copy ConstructorCopy Constructor

Copy constructor is a special member function of a class that is implicitly called in these 3 situations:

• passing object parameters by value

• initializing an object variable in its declaration

• returning an object as the return value of a function

60

CONSTRUCTOR

COPY CONSTRUCTOR

DESTRUCTOR

Classes with Data Member Pointers NeedClasses with Data Member Pointers Need

61

For the Final ExamFor the Final Exam

Note: You will not have to write source code using pointers or dynamic memory. Questions related to these topics will be multiple choice or True/False

62

Recursive Function CallRecursive Function Call

A recursive call is a function call in which the called function is the same as the one making the call

In other words, recursion occurs when a function calls itself!

But we need to avoid making an infinite sequence of function calls (infinite recursion)

63

void message(){ cout << “This is a recursive function. \n”;message();}

Recursive Function Example

64

The previous program will eventually crash, because each time a function is called, temporary information is stored on a stack. The stack memory will eventually overflow and cause an error).

A recursive function (as with a loop) must have some algorithm to control the number of times it repeats.

void message(int times){ if(times > 0) { cout << “This is a recursive function. \n”; message(times-1); } return;}

Recursive Function Example

65

Finding a Recursive SolutionFinding a Recursive Solution

The idea is for each successive recursive call to bring you one step closer to a situation in which the problem can easily be solved

This easily solved situation is called the base case

Each recursive algorithm must have at least one base case, as well as a general (recursive) case

66

General format forGeneral format forMany Recursive FunctionsMany Recursive Functions

if (some easily-solved condition) // base case

solution statement

else // general case

recursive function call

67

Example Recursive FunctionExample Recursive FunctionFinding the Sum of the Numbers from 1 to nFinding the Sum of the Numbers from 1 to n

int Summation ( int n )

{

if ( n == 1) // base case

return 1 ;else // general case

return ( n + Summation ( n - 1 ) ) ;

}

68

““Why use recursion?”Why use recursion?”

The previous example could have been written without recursion, by using iteration instead. The iterative solution uses a loop, while the recursive solution uses an if statement.

However, for certain problems the recursive solution is the most natural solution. This often occurs when structured variables are used.

69

For the Final ExamFor the Final Exam

Note: You will not have to write source code using recursion. Questions related to this topics will be multiple choice or True/False

70

Final ExamFinal ExamTues 3/16/10 (2-3:50)Tues 3/16/10 (2-3:50)

(Same classroom)(Same classroom)

Old Textbook - Chapters 11-16, 18Old Textbook - Chapters 11-16, 18Focus is on 15, 16 and 18Focus is on 15, 16 and 18

Multiple choice, True/False and some minimal programming will be required