1 / 50

Topics Covered

SEN 909 OO Programming in C++ Final Exam Multiple choice, True/False and some minimal programming will be required. Topics Covered. C++ basic programming concepts Struct and Union Concepts C++ Classes Inheritance Object-Oriented Programming Pointers You will have to write a class

Download Presentation

Topics Covered

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. SEN 909 OO Programming in C++Final ExamMultiple choice, True/False and some minimal programming will be required

  2. Topics Covered • C++ basic programming concepts • Struct and Union Concepts • C++ Classes • Inheritance • Object-Oriented Programming • Pointers • You will have to write a class • You will have to write a struct

  3. 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.

  4. Accessingstruct 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. • EXAMPLES • thisAnimal.weight • anotherAnimal.country

  5. 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

  6. 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

  7. 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

  8. Information Hiding • Class implementation details are hidden from the client’s view. This is called information hiding. • Public functions of a class provide theinterface between the client code and the class objects. client code abstraction barrier specification implementation

  9. Benefits 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.

  10. class TimeType 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 ; • } ;

  11. Use of C++ data Type 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

  12. Using class • 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.

  13. Member 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.

  14. Client Code UsingTimeType • #include “timetype.h” // includes specification of the class • using 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 ; • } ; • } 14

  15. class 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.

  16. C++ Data Type class 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.

  17. Aggregate class 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

  18. 2 separate files Generally Used for class Type • // Specification File ( timetype .h ) • // Specifies the data and function members. • class TimeType • { • public: • . . . • private: • . . . • } ; • // Implementation File ( timetype.cpp ) • // Implements the TimeType member functions. • . . .

  19. Implementation File for TimeType • // 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) ) ; • } • . . .

  20. 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 TimeType • numberZ .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 • { . . . • }

  21. 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

  22. Specification of TimeType Class 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 members • int hrs ; • int mins ; • int secs ; • } ; 22

  23. Implementation of TimeType Default Constructor • TimeType :: TimeType ( ) • // Default Constructor • // Postcondition: • // hrs == 0 && mins == 0 && secs == 0 • { • hrs = 0 ; • mins = 0 ; • secs = 0 ; • }

  24. Implementation of Another TimeType 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 ; • }

  25. For 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.

  26. Pointers • 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.

  27. Pass-by-value CALLING BLOCK FUNCTION CALLED sends a copy of the contents of the actual parameter SO, the actual parameter cannot be changed by the function. 27

  28. Pass-by-reference sends the location (memory address) of the actual parameter CALLING BLOCK FUNCTION CALLED can change value of actual parameter 28

  29. Obtaining 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;

  30. 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

  31. Using 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

  32. Unary operator * is the indirection (deference) operator • int x; • x = 12; • int* ptr; • ptr = &x; • cout << *ptr; • NOTE: The value pointed to by ptr is denoted by *ptr 2000 12 x 3000 2000 ptr

  33. Using the Dereference Operator • int x; • x = 12; • int* ptr; • ptr = &x; • *ptr = 5; // changes the value // at address ptr to 5 2000 12 5 x 3000 2000 ptr

  34. Another Example • char ch; • ch = ‘A’; • char* q; • q = &ch; • *q = ‘Z’; • char* p; • p = q; • // now p and q both point to ch 4000 A Z ch 5000 6000 4000 4000 q p

  35. Operator new 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 pointerto (address of ) the memory allocated. • Otherwise, program terminates with error message. • The dynamically allocated object exists until the delete operator destroys it. 35

  36. 3 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

  37. Dynamically Allocated Data • char* ptr; • ptr = new char; • *ptr = ‘B’; • cout << *ptr; • NOTE: Dynamic data has no variable name 2000 ptr ‘B’

  38. Dynamically 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 ?

  39. Using Operator delete • 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. 39

  40. Operator delete 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. 40

  41. 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

  42. What happens here? • int* ptr = new int; • *ptr = 3; • ptr = new int; // changes value of ptr • *ptr = 4; 3 ptr 3 ptr 4

  43. Inaccessible 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

  44. Making 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

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

  46. Leaving a Dangling PointerA pointer that points to dynamic memory that has been de-allocated • int* ptr = new int; • *ptr = 8; • int* ptr2 = new int; • *ptr2 = -5; • ptr = ptr2; • delete ptr2; • // ptr is left dangling • ptr2 = NULL; 8 ptr -5 ptr2 8 ptr NULL ptr2

  47. 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.

  48. class DynArray Destructor • DynArray::~DynArray( ); • // Destructor. • // POST: Memory for dynamic array deallocated. • { • delete [ ] arr ; • } 48

  49. For 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

  50. SEN 909 OO Programming in C++Final ExamMultiple choice, True/False and some minimal programming will be required

More Related