1. Announcements HW2 is due on Wednesday this week.
HW3 will 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
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

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

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's color is set to red Ali.Move(5); Ayse.TurnRight(); Ayse.Move(); Ayse.Move(10); 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 (.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

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? How to call a member function?
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.

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

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
Robot::Robot (int x, int y, {
xPos = x;
yPos = y;
direction = dir;
color = yellow;
...
robots.obj
libraries

21. #include Kind of copy-paste Include file locations difference between
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
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