1. CS201 – Introduction to Computing – Sabancı University 1 Announcements l General rules about homeworks ä Use of global variables (variables defined outside of functions) prohibited ä No abrupt program termination in the middle of the program. ä Modularity and code duplication are important Code duplication must avoided l Common Submission Mistakes ä In HW1, some students submitted empty/wrong files Make sure that you send the cpp file; otherwise we cannot grade ä rar format is not allowed for compression; please use zip ä Do not use blanks, Turkish characters, special symbols in the filenames Only English alphabet letters, digits and underscore are allowed ä Please submit the required files only, not the entire project folder l About HW2 ä Use of functions Proposed functions are just one set of possible function use in such a program If you want to use other set of functions, you should be able to demonstrate understanding of modularity and you should be able to avoid code duplication l Midterm 1: November 22, Saturday 10:40 – 12:20 l Midterm 2: December 26, Friday, 17:40 – 19:20

2. CS201 – Introduction to Computing – Sabancı University 2 Chapter 3 - Continued l Overview of functions ä sequence of statements with its own local variables ä supports modularity, reduces code duplication l Data transfer between function to be called and caller function ä by means of parameters ä currently one-way from caller function into function to be called ä later we will see how to return data back to the caller function

3. CS201 – Introduction to Computing – Sabancı University 3 Function Prototype (from 2.6) l Functions definition has two parts ä function heading name, parameters, return type ä function body (local variables and statements within curly brackets) void display (string name) { cout << “Hello ” << name << endl; } l Like variables, a function must be declared before its first call ä Problem of function declaration order You cannot call a function before you declare it l SOLUTION: You may define function prototypes (a copy of the heading) at the beginning without function declarations

4. CS201 – Introduction to Computing – Sabancı University 4 Function Prototype – Example Problem l What is the problem below (program order.cpp) ? void Hi (string name) { cout << "Hi " << name << endl; Greetings(); } void Greetings() { cout << "Things are happening inside this computer" << endl; } int main() { Hi("Fred"); return 0; } Greetings() is called in Hi() but it is declared afterwards

5. CS201 – Introduction to Computing – Sabancı University 5 Function Prototype – Solution l Add function prototypes to the beginning (order2.cpp) #include #include using namespace std; void Hi (string); void Greetings(); void Hi (string name) { cout << "Hi " << name << endl; Greetings(); } void Greetings() { cout << "Things are happening inside this computer" << endl; } int main() { Hi("Fred"); return 0; } Prototypes Functi on Declar ations

6. CS201 – Introduction to Computing – Sabancı University 6 Function Prototypes l !!!Do not forget semicolon after the prototype definition!!! ä no semicolon after the parameters in normal definition l Sometimes prototypes are not necessary ä if the order of function calls allows ä But it is a good programming practice to have them l Parameter names are not needed in prototypes ä But it is OK if you have the parameter names. In #include d files ä we have the functions’ prototypes only ä implementations of function bodies are in libraries or in other cpp files they are linked together

7. CS201 – Introduction to Computing – Sabancı University 7 Enumerated Types l Section 9.3.4 l You can define your own type by giving its constant values (literals) as identifiers ä type for CardSuit ä type for colors l Type definition syntax enum TypeName { list of literals separated by comma }; l Type definition example enum CardSuit {spade, heart, diamond, club}; l You can define variables of enum types, you can use them as parameters and return types throughout the cpp file  So an enum type must be defined as global (after using namespace std; and before the function declarations) ä Such a global type declaration is not a prohibited use of globals.

8. CS201 – Introduction to Computing – Sabancı University 8 Enum types l Example use CardSuit c; c = club; l 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 l Displaying an enum type variable actually displays its integer code cout << c; // displays 3 l Cannot assign an integer to an enum variable c = 2; //illegal c = CardSuit(2); //legal, c becomes diamond l cannot input cin >> c; //invalid can use comparison operators (, =, ==, != ) ä The relational operators, = compare codes if (c <= heart) cout << "hi" << endl;

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

10. CS201 – Introduction to Computing – Sabancı University 10 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 l 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 l 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

11. CS201 – Introduction to Computing – Sabancı University 11 How to Use Classes? l The behavior of a class is defined by member functions (methods) by which objects of that class are manipulated l You should know about the member functions and what they do ä name of the function ä parameters and parameter types ä return type ä functionality l 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

12. CS201 – Introduction to Computing – Sabancı University 12 Example: Robot Class (not in the book) l A class for robots l You can create robots (objects) at different locations and facing different orientations (east, west, south or north) ä We use “constructor” for this purpose ä “constructor”: general name for object creating functions l You can change the color of the robot; color is parameter of an enumerated type  SetColor member function l Robots can turn right  TurnRight member function ä no parameter l 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 l more robot functions will be given later

13. CS201 – Introduction to Computing – Sabancı University 13 Robot World l 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

14. CS201 – Introduction to Computing – Sabancı University 14 More on robots class and robot world l 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) l Robot world is actually a Windows application ä it needs two files to be added up 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 another separate file. robots.h is to be #include d 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. l When “run” clicked, your 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 do not bother with this detail for now. Caution: cin and cout do not work in robot world

15. CS201 – Introduction to Computing – Sabancı University 15 simplerobot.cpp – sample program that utilizes robots class #include "Robots.h" using namespace std; //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; }

16. CS201 – Introduction to Computing – Sabancı University 16 Where is a Class Defined? l Class definition/interface is in a header file (a file with.h extension) ä member function prototypes and and some other declarations ä function implementations are not in this header file l Implementations of the member functions are in a.cpp file l 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

17. CS201 – Introduction to Computing – Sabancı University 17 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 Continued on the next page

18. CS201 – Introduction to Computing – Sabancı University 18 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

19. CS201 – Introduction to Computing – Sabancı University 19 Parts of Class Definition l 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) l Private ä Mostly the data part of the class ä Necessary for internal implementation of class e.g. xPos, yPos – used by the implementation of Move function, but we do not use it as the programmer using the Robot class ä Not accessible by programmer e.g. in simplerobot.cpp, programmer cannot modify xPos

20. CS201 – Introduction to Computing – Sabancı University 20 How to l How to define objects? class_name object_name_list_separated_by_comma ; ä do not forget arguments for each object, if any. l How to call a member function? object_name. function_name ( arguments ); ä a member function operates on an object for which it is called.

21. CS201 – Introduction to Computing – Sabancı University 21 How to l 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 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

22. CS201 – Introduction to Computing – Sabancı University 22 Some more recommendations l Avoid creating robots in user-defined functions ä Create all necessary robots in main ä If needed pass them as parameters to other functions l 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

23. CS201 – Introduction to Computing – Sabancı University 23 Compiling, Linking l Single file case l Linking is necessary to use the libraries  for example, iostream for cin and cout, string for string class operations  library functions are defined (prototypes) in header files ( #include d) ä library function bodies are ready in object code linked myprog.cpp (source code) myprog.obj (object code) compile myprog.exe link

24. CS201 – Introduction to Computing – Sabancı University 24 Compiling, Linking l 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

25. CS201 – Introduction to Computing – Sabancı University 25 #include l Kind of copy-paste ä specified header file is copied before compilation l Include file locations ä standard ones are in INCLUDE directory under....\Microsoft Visual Studio\VC98 ä Tools  Options  Directories can specify more directories to search for header files l difference between (this is very important) ä #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

26. CS201 – Introduction to Computing – Sabancı University 26 Adding Files to Projects in VC++ l.cpp files that are compiled and linked together (like class implementations) must be added to the project ä otherwise link error l Standard libraries are found and linked automatically ä no need to add anything to the project for these libraries l User-defined libraries, if available in object code (e.g..lib files), must be added to the project ä otherwise link error l 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!