1. Copyright 2003 Scott/Jones Publishing Standard Version of Starting Out with C++, 4th Edition Chapter 13 Introduction to Classes

2. Chapter 13 slide 2 Topics 13.1 Procedural and Object-Oriented Programming 13.2 Introduction to Classes 13.3 Defining an Instance of a Class 13.4 Why Have Private Members? 13.5 Software Design Considerations 13.6 Using Private Member Functions 13.7 Inline Member Functions 13.8 Constructors

3. Chapter 13 slide 3 Topics 13.9 Destructors 13.10 Constructors That Accept Arguments 13.11 Input Validation Objects 13.12 Overloading Constructors 13.13 Only One Default Constructor and One Destructor 13.14 Arrays of Objects 13.18 An Object-Oriented System Development Primer

4. Chapter 13 slide 4 13.1 Procedural and Object- Oriented Programming Procedural programming focuses on the process/actions that occur in a program Object-Oriented programming is based on the data and the functions that operate on it. Objects are instances of ADTs that represent the data and its functions

5. Chapter 13 slide 5 Problems with Procedural Programming Use of global data may allow data corruption Programs based on complex function hierarchies are: – difficult to understand and maintain –difficult to modify and extend –easy to break

6. Chapter 13 slide 6 Object-Oriented Programming Terminology class: like a struct (allows bundling of related variables), but variables and functions in the class can have different properties than in a struct object: an instance of a class, in the same way that a variable can be an instance of a struct

7. Chapter 13 slide 7 Object-Oriented Programming Terminology attributes: members of a class methods or behaviors: member functions of a class

8. Chapter 13 slide 8 More on Objects data hiding: restricting access to certain members of an object public interface: members of an object that are available outside of the object. This allows the object to provide access to some data and functions without sharing its internal details and design, and provides some protection from data corruption objects can be general-purpose or application-specific

9. Chapter 13 slide 9 13.2 Introduction to Classes Objects are created from a class Format: class { declaration; };

10. Chapter 13 slide 10 Class Example class Square { private: int side; public: void setSide(int s) { side = s; } int getSide() { return side; } };

11. Chapter 13 slide 11 Access Specifiers Used to control access to members of the class public: can be accessed by functions outside of the class private: can only be called by or accessed by functions that are members of the class

12. Chapter 13 slide 12 More on Access Specifiers Can be listed in any order in a class Can appear multiple times in a class If not specified, the default is private

13. Chapter 13 slide 13 13.3 Defining an Instance of a Class An object is an instance of a class Defined like structure variables: Square sq1, sq2; Access members using dot operator: sq1.setSide(5); cout << sq2.getSide(); Compiler error if attempt to access private member using dot operator

14. Chapter 13 slide 14 Pointer to an Object Can define a pointer to an object: Square *sqPtr; Can access public members via pointer: sqPtr = &sq1; sqPtr->setSide(12); sqPtr = &sq2; sqPtr->setSide(sq1.getSide()); cout getSide();

15. Chapter 13 slide 15 13.4 Why Have Private Members? Making data members private provides data protection Data can be accessed only through public functions Public functions define the class’s public interface

16. Chapter 13 slide 16 Set vs. Get Functions Set function: function that stores a value in a private member variable Get function: function that retrieves a value from a private member variable Common class design practice: make all member variables private, provide public set and get functions

17. Chapter 13 slide 17 13.5 Software Design Considerations –Place class declaration in a header file that serves as the class specification file. Name the file.h, for example, square.h –Place member function definitions in.cpp, for example, square.cpp File should #include the class specification file –Programs that use the class must #include the class specification file, and be compiled and linked with the member function definitions

18. Chapter 13 slide 18 Defining a Member Function When defining a member function: –Put prototype in class declaration –Define function using class name and scope resolution operator (::) int Square::getSide() { return side; }

19. Chapter 13 slide 19 Input/Output with Objects Class should be designed to provide functions to store, retrieve data Functions that use objects of a class should perform input/output operations, not class member functions Exceptions can occur: class designed to display a menu, or class designed specifically to perform I/O

20. Chapter 13 slide 20 13.6 Using Private Member Functions A private member function can only be called by another member function It is used for internal processing by the class, not for use outside of the class

21. Chapter 13 slide 21 13.7 Inline Member Functions Member functions can be defined –inline: in class declaration –after the class declaration Inline appropriate for short function bodies: int getSide() { return side; }

22. Chapter 13 slide 22 Tradeoffs – Inline vs. Regular Member Functions Regular functions – when called, compiler stores return address of call, allocates memory for local variables, etc. Code for an inline function is copied into program in place of call – larger executable program, but no function call overhead, hence faster execution

23. Chapter 13 slide 23 13.8 Constructors Member function that is called when an object is created Called automatically Constructor function name is class name Has no return type

24. Chapter 13 slide 24 Constructor Example class Square { public: Square(); // prototype... }; Square::Square() // heading { side = 1; }

25. Chapter 13 slide 25 13.9 Destructors Member function automatically called when an object is destroyed Destructor name is ~ classname, e.g., ~Square Has no return type; takes no arguments Only 1 destructor per class, i.e., it cannot be overloaded If constructor allocates dynamic memory, destructor should release it

26. Chapter 13 slide 26 13.10 Constructors That Accept Arguments Default constructor: constructor that takes no arguments To create an object using the default constructor, use no argument list and no () : Square square1; To create a constructor that takes arguments: –indicate parameters in prototype, definition –provide arguments when object is created: Square square2(12);

27. Chapter 13 slide 27 Constructors That Accept Arguments Constructor may have default arguments: Square(int = 1); // prototype Square::Square(int s) // heading { side = s; }

28. Chapter 13 slide 28 13.11 Input Validation Objects Objects can be designed to validate user input: –Acceptable menu choice –Test score in range of valid scores –etc.

29. Chapter 13 slide 29 13.12 Overloading Constructors A class can have > 1 constructor Overloaded constructors in a class must have different parameter lists: Square(); Square(int);

30. Chapter 13 slide 30 Member Function Overloading Non-constructor member functions can also be overloaded: void setSide(); void setSide(int); Must have unique parameter lists as for constructors

31. Chapter 13 slide 31 13.13 Only One Default Constructor and One Destructor Do not provide > 1 default constructor for a class: one that takes no arguments and one that has default arguments for all parameters Square(); Square(int = 0); // will not compile Since a destructor takes no arguments, there can only be one destructor for a class

32. Chapter 13 slide 32 13.14 Arrays of Objects Objects can be the elements of an array: Square lottaSquares[10]; Default constructor for object is used when array is defined Must use initializer list to invoke constructor that takes arguments: Square triSqu[3] = {5,7,11}; More complex initialization if constructor takes > 1 argument

33. Chapter 13 slide 33 Accessing Objects in an Array Objects in an array are referenced using subscripts Member functions are referenced using dot notation: lottaSquares[3].setSide(6); cout << triSqu[i].getSide;

34. Chapter 13 slide 34 13.18 An Object-Oriented System Development Primer Procedural Programming: –program is made up of procedures: sets of programming statements that perform tasks Object-Oriented Programming: –program is made up of objects: entities that contain data (attributes) and actions (methods)

35. Chapter 13 slide 35 Benefits of Object-Oriented Programming Simplification of software development for graphical (GUI) applications –visual components (menus, text boxes, etc.) modeled as objects –visual components (e.g., windows) may be made up of multiple objects –some objects (e.g., buttons) may have methods associated with them

36. Chapter 13 slide 36 Benefits of Object-Oriented Programming Simplification of software development for non-GUI applications - the problem: –procedural programming enforces separation between code and data –changes in data format require extensive analysis, testing to ensure program functionality

37. Chapter 13 slide 37 Benefits of Object-Oriented Programming Simplification of software development for non-GUI applications - a solution: –OO programming addresses the problem through encapsulation: combination of data and actions in an object data hiding: protection of an object’s data by its public member functions

38. Chapter 13 slide 38 Component Reusability Component: a software object that performs a well-defined task or that provides a service Component Reusability: the ability to use a component in multiple programs without (or with little) modification

39. Chapter 13 slide 39 Relationships Between Objects A program may contain objects of different classes Objects may be related by one of the following: –Access (‘knows’ relationship) –Ownership (‘has a’ relationship) –Inheritance (‘is a’ relationship)

40. Chapter 13 slide 40 Messages and Polymorphism Message: request to an object to perform a task. Implemented as a member function call Polymorphism: ability to take many forms. Sending the same message to different objects may produce different behaviors

41. Chapter 13 slide 41 Object Oriented Analysis Used to create the logical design of a system, what the system is to do Usually includes –examine the problem domain; model the system from within that perspective –identify the objects that exist within the boundaries of that system –identify the relationships between the objects –realize that there may be many ‘right’ solutions

42. Chapter 13 slide 42 Object Oriented Design Used to determine how requirements from OO Analysis will be implemented Usually includes –determine hierarchical relation between objects –determine object ownership of attributes –implement and test; refine as required

43. Copyright 2003 Scott/Jones Publishing Standard Version of Starting Out with C++, 4th Edition Chapter 13 Introduction to Classes