Announcements

1. Announcements • HW2is due on Wednesday this week. • HW3will be assigned this week,will be due next week

2. Summary of what we learned last week • Conditional statements (if-else) • Nested if-else as well as normal if-else • Relational and Logical operators + precedence • Function Prototypes • Functions that return value

3. Enumerated Types(Section 9.3.4) • 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)

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

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

6. Introduction to Classes and Objects • We define variables of types (like int, double). Similarly, we define objects of classes • anobjectis 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

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

8. 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 • more robot functions later

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

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

11. 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'scolor is set to red Ali.Move(5); Ayse.TurnRight(); Ayse.Move(); Ayse.Move(); Ayse.TurnRight(); Ayse.Move(10); Ali.TurnRight(); Ali.TurnRight(); Ali.Move(4); return 0; }

12. Where is a Class Defined? • Class definition/interface (member function prototypes and some other declarations) is in a header file (.hfile) • 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 .cppfile • 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

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

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

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

16. How to • How to define objects? class_nameobject_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.

17. How to • 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, intparam) • 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

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

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) myprog.exe compile 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 simplerobot.cpp int main () { Robot Ali(5, 1); Ali.SetColor(white); Ali.Move(5); return 0; } simplerobot.obj robots.cpp robots.obj Robot::Robot (int x, int y, { xPos = x; yPos = y; direction = dir; color = yellow; ... libraries 1101010101101010100110010101010 ...

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 <filename> • 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 <cmath> 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