1. Summary of what we learned last week Classes How to use classes/objects Header (.h) and implementation (.cpp) files String class Member functions: length, substr, find/rfind Loops Today’s topics Classes How to use classes/objects Header (.h) and implementation (.cpp) files Robot class

2. You can use enum type when you want to define all the possible values for your type type for CardSuit type for colors Type definition syntax enum TypeName {list of literals separated by comma}; Type definition example enum CardSuit {spade, heart, diamond, club}; You can define variables of enum types, you can use them as parameters and return types throughout the cpp file An enum type must be defined at global level (after using namespace std; and before the function declarations) Enumerated Types ( Section 9.3.4)

3. Enum types Example use enum CardSuit {spade, heart, diamond, club}; CardSuit c; c = club; Each constant of an enum type has an associated integer code starting from 0 spade is 0, heart is 1, diamond is 2, club is 3 Displaying an enum type variable actually displays its integer code cout << c; // displays 3 Cannot assign an integer to an enum variable c = 2; // illegal c = CardSuit(2); // legal, c becomes diamond Cannot input into an enum cin >> c; // invalid Can use comparison operators (, = operators compare codes) if (c <= heart) cout << "hi" << endl;

4. Introduction to Classes and Objects (3.4) In object-oriented programming terminology, a class is defined as a kind of programmer-defined type From the natural language definition of the word “class”: Collection of members that share certain attributes and functionality Likewise classes in object-oriented programming In object oriented programming languages (like C++) classes are used to combine everything for a concept (like date, student) Data (state) (e.g. student id, gpa) Functions (behavior) (e.g. students enroll, students graduate)

5. Introduction to Classes and Objects We define variables of types (like int, double). Similarly, we define objects of classes an object is a member of a class Why classes and objects? In other words, why object- oriented programming? It gives programmers the ability to write programs using off-the- shelf components without dealing with the complexity of those components Saves time and effort Objects are how real-world entities are represented. You may design and implement, and later use your own classes, but we will start with using other-programmers- defined classes this is what a programmer generally does

6. How to Use Classes? The behavior of a class is defined by its member functions (methods) by which objects of that class are manipulated You should know about the member functions and what they do name of the function parameters and parameter types return type functionality You don’t need to know how the function is implemented analogy: you can add two int variables using +, but you don’t need to know how computer really adds more analogy: you can drive cars, but you don’t need to know how the fuel injection works

7. Example: Robots Class (not in the book) A class for robots You can create robots (objects) at different locations and facing different orientations (east, west, south or north) “constructor”: general name for object creating functions You can change the color of the robot; color is parameter SetColor member function Robots can turn right TurnRight member function no parameter Robots can move at the facing direction Move member function can be used with or without parameters without parameter: 1 step with parameter: parameter is number of steps There are more robot functions, let’s use these first

8. Robot World Robots live on a world of cells each cell has a coordinate southwest is (0,0) point south and west bounded east and north unbounded no cells with negative coordinates

9. More on robots class and robot world Robot world also allows you to install/uninstall barriers at cell boundaries plant/remove “things” within cells save, save as, open, run program, etc. (utilities) Robot world is actually a Windows application it needs two files to be added to the project robots.cpp (robot class and other utilities are implemented) miniFW.cpp (for windows programming – out of scope of this course) The file in which you write your main program should be a separate file. robots.h is to be #included at the beginning of the main program robots.cpp, miniFW.cpp, robots.h and miniFW.h files should be in the folder as your actual program file. project should be win32 application – This is very important! In such a project, robot world is created automatically even if you do not have anything in main. When “run” clicked, program is executed on the current robot world. Important Detail: your main is not actually the main program; actual main (WinMain) is in robots.cpp, but ignore this detail for now. Caution: cin and cout do not work in robot world

10. simplerobot.cpp – sample program that utilizes robots class #include "Robots.h" //simple robot test program int main () { Robot Ali(5, 1); // Ali is a robot at (5,1) location and // facing east Ali.SetColor(white); // Ali's color is set to white Robot Ayse(5, 8, north); // Ayse is a robot at (5,8) location // and facing north Ayse.SetColor(red); // Ayse's color is set to red Ali.Move(5); Ayse.TurnRight(); Ayse.Move(); Ayse.TurnRight(); Ayse.Move(10); Ali.TurnRight(); Ali.Move(4); return 0; }

11. Where is a Class Defined? Class definition/interface (member function prototypes and some other declarations) is in a header file (.h file) Function prototype includes function name, return type and parameters. Function body is not there. A function’s prototype is its definition. It allows the program to call that function. Prototype definitions are generally used for library functions. Function body is not known, but its interface must be known by the program in order to call that function. Prototype definitions can be used for user-defined functions too Implementations of the member functions are in a.cpp file Robot example class definition/interface is in robots.h that is why it is included in simplerobot.cpp class implementation is in robots.cpp part of the project – linked together

12. robots.h - Definition of class Robot (partial) #ifndef Robots_h // to avoid duplicate inclusions of robots.h #define Robots_h // enumerated types for colors and directions enum Direction { east, west, north, south }; enum Color { white, yellow, red, blue, green, purple, pink, orange }; class Robot { public: Robot (int x, int y, Direction dir = east, int things = 0); // robot constructor - color yellow, default direction is east, default // things in bag is zero void Move (int distance = 1); // to move robot, default displacement is 1 void TurnRight (); // to turn the robot right void SetColor (Color color); // to change the color of robot // there are some other functions that we will see later // see next page for the rest of the file

13. robots.h - Definition of class Robot (partial ) private: int xPos; //x-coordinate of the robot int yPos; //y-coordinate of the robot Direction direction; //direction of the robot Color color; //color of the robot int bag; //number of things in the bag of the robot bool stalled; //is the robot dead? bool visible; //is the robot visible on the screen? // the rest of the private part is out of scope of this course, // at least for now }; #endif

14. Parts of Class Definition Public Member functions as seen by programmer Programmer can use the functions defined in the public section only Constructors special member function to create objects (variables) there might be several constructors with same name, but different parameters (not the case for Robot class) Private Mostly the data part of the class Necessary for internal implementation of class e.g. xPos, yPos – used by Move Not accessible by programmer e.g. in simplerobot.cpp, programmer cannot modify xPos

15. How to define objects? class_name object_name_list_separated_by_comma; do not forget arguments for each object, if any. How to call a member function? object_name.function_name(arguments); a member function operates on an object for which it is called. How to

16. How to use Robot class as a parameter if you do not change the color, position, orientation etc. of the robot, then use as other types (at least for now – later we will see more efficient ways) void dothis (Robot myrobot, int param) However, if you change the robot’s characteristics (color, position, orientation, etc.), then you have to use the character & between Robot and the parameter name void Go (Robot & myrobot, int x, int y) Calling such functions is not different Do not use & while calling the function Robot rob(5, 6, west); Go (rob, 12, 5); We will see the & notation in more detail later (Section 6.2.3) this type of parameters are called “reference parameters” Recommended since you generally change the robot characteristics in functions

17. Some more recommendations Avoid creating robots in user-defined functions Create all necessary robots in main If needed pass them as parameters to other functions Addition to scope rules IMPORTANT RULE: An identifier (e.g. an object or a variable) can be referred only in the compound block in which it is declared A compound block is the statements and declarations within matching curly brackets { } e.g. after if or else Implication of this rule in robot programs: when a robot object is created in a compound block, it can be referred only in that block Otherwise, undeclared identifier error occurs Solving this problem by re-creating it is NOT A SOLUTION if (x>0) { Robot r(x, 0); r.Move(3); } r.Move(); Undeclared identifier

18. Example using robot class (see rectangularscan.cpp) Write a program in which the robot starts at 0,0 and searches a rectangular space that covers n*n cells n is input (in the example below, n is 8) during this journey the robot should pick or put things on the cells so that all visited cells occupy one thing

19. Compiling, Linking Single file case Linking is necessary to use the libraries Examples: iostream for cin and cout, string for string class operations Library functions are defined (prototypes) in header files (#included) library function bodies are ready in object code linked myprog.cpp (source code) myprog.obj (object code) compile myprog.exe link

20. Compiling, Linking several.cpp files user-defined class implementations and some utility functions can be written in different.cpp files those files are independently compiled and then linked together to create the executable code libraries are linked too int main () { Robot Ali(5, 1); Ali.SetColor(white); Ali.Move(5); return 0; } simplerobot.cpp Robot::Robot (int x, int y, { xPos = x; yPos = y; direction = dir; color = yellow;... robots.cpp simplerobot.obj robots.obj 110101010110101010 0110010101010... libraries

21. #include Kind of copy-paste specified header file is copied before compilation Include file locations standard ones are in INCLUDE directory under …\Microsoft Visual Studio 9.0\VC\include Tools  Options  Projects and Solutions  VC++ Directories can specify more directories to search for header files difference between #include only search in directories specified in options mostly used for standard header files like iostream #include “filename” first search in the local directory, then the ones in options for user defined header files

22. Adding Files to Projects in VC++.cpp files that are compiled and linked together (like class implementations) must be added to the project otherwise link error Standard libraries are found and linked automatically no need to add anything for them User-defined libraries, if available in object code (e.g..lib files), must be added to the project otherwise link error Header files may or may not be added in project if not added, they are shown as “external dependencies” and this is OK No matter added to the project or not, the compiler still needs to find the header files in a folder they may not be found if directory settings are wrong, so be careful!

23. Functions that return values from the Robot Class Robot class has several member functions Move, TurnRight and SetColor are void functions Robot class also has member functions that return values. Some are below: bool Blocked () is the robot blocked? bool FacingEast () is the robot facing east? See RobotWorld.pdf file for the complete list of those functions.

24. Free functions and member functions The functions in are free functions, they aren’t part of a class C++ is a hybrid language, some functions belong to a class, others do not Java and C# are pure object-oriented languages, every function belongs to a class Similarly, IsLeapYear is also a free function Actually any function that does not operate on an object is a free function However, Move, TurnRight are functions for Robot class they are not free, they operate on robots only that is why they are called member functions all robot functions are member functions

25. RandGen Class A Tapestry class for random number generation Add randgen.cpp to your project and have #include "randgen.h" in your program Four member functions int RandInt(int max = INT_MAX); returns a random integer in [0..max) int RandInt(int low, int max); returns a random integer in [low..max] double RandReal(); returns a random double value in [0..1) double RandReal(double low, double max); returns a random double value in the range of [low..max] see numberguess.cpp for an example program that use RandGen

26. Overloading In RandGen class, there are two different functions named RandInt so as RandReal Using the same name for more than one function is called overloading. They are differentiated by parameter types Return types do not differentiate funtions All member and free functions can be overloaded.

27. Implementation of Robot Class - 1 Your next homework will be about updating the Robot class you will add some new member functions that requires to deal with robots.h and robots.cpp files (actually in the homework, you will use an updated class for which the file names are robots_modified.h and robots_modified.cpp) and you will use those newly added functions in an application It is a good idea to have a look at how this class is implemented It is designed and implemented by Ersin Karabudak We have made some changes later Robot class implementation is quite complex Robot, RobotWindow and RobotWorld are different structures we will not deal with RobotWindow and RobotWorld, but the implementation file contains robot class implementation and the details of RobotWindow and RobotWorld too. Do not get confused. Robots are maintained as a circular doubly linked list it is a data structure that uses pointers (probably will see in CS300) but do not get thrilled! you will not need those complex structures for the member functions that you will add. Some details you have to know will be given now and more details will be given in recitations this week

28. Implementation of Robot Class - 2 enum Direction { east, west, north, south }; enum Color { white, yellow, red, blue, green, purple, pink, orange }; class Robot { public: Robot (int x, int y, Direction dir = east, int things = 0); ~Robot (); void Move (int distance = 1); bool Blocked (); void TurnRight (); bool PickThing (); bool PutThing (); void SetColor (Color color); bool FacingEast (); bool FacingWall (); bool CellEmpty (); bool BagEmpty (); constructor Destructor (not needed in HW5) member functions continued on the next slide

29. Implementation of Robot Class - 3 private: int xPos; //x coordinate of the location of robot int yPos; //y coordinate of the location of robot Direction direction; //current direction of robot Color color; //current color of robot int bag; //current # of things in the bag of robot bool stalled; //true if the robot is dead bool visible; //true if the robot is visible Robot *next; Robot *prev; static Robot *list; friend struct RobotWindow; }; Private Data pointers for the data structure you will not need them RobotWindow may refer Robot’s private data

30. Implementation of Robot Class - 4 Previous two slides were in the robots.h (now robots_modified.h). Now let’s go over the robots.cpp (now robots_modified.cpp) file in VC++ environment In the next homework, you are going to add 6-8 member functions to the robot class Some of the member functions will be done in recitations this week Hints try to use currently available member functions e.g. for PickThings, try to use PickThing in a loop rather than writing some thing similar to PickThing do not hesitate to modify or access private data members when needed e.g. you will need such an update for TurnFace function if you change the state of a robot within the current cell, use the following to update the window theRobotWindow->Redraw(this);

31. Implementation of Robot Class - 5 Hints for the next homework (cont’d) you will need to use the function called IsPressed defined in miniFW.h (it is going to be renamed as miniFW_modified.h) so include this header file to your main program file this function ( IsPressed ) is to check whether a key (e.g. an arrow key) is pressed or not - details are in recitations Some other changes in the Robot World and Robot Class If a robot hits another robot, both die! No automatic message is displayed when a robot dies Now the bag content is written in robots (if not zero) Use robots_modified.h, robots_modified.cpp, miniFW_modified.h and miniFW_modified.cpp files in HW4 They will be provided to you in the homework and/or recitation package

32. Example using robot class (see rectangularscan.cpp) Write a program in which the robot starts at 0,0 and searches a rectangular space that covers n*n cells n is input (in the example below, n is 8) during this journey the robot should pick or put things on the cells so that all visited cells occupy one thing