Welcome to OOP course!
description
Transcript of Welcome to OOP course!
Welcome to OOP course!
203.1120
Course detailsCourse details• Teaching team
– Li-Tal Mashiach and Moran Lefler• Grading:
– 30% - Project in 3 parts– 70% - Final exam
• Contact me:– E-mail: [email protected] (Subject: OOP)– Office hours: Jacobs 409, after the lecture– Lecture slides will be available on the course site
http://cs.haifa.ac.il/courses/prog_tech/course_info.html
BibliographyBibliography
• B. Stroustrup, The C++ Programming Language
• S. Lippman and J. LaJoie, C++ Primer• S. Meyers, Effective C++• B. Eckel, Thinking in C++
1. Introduction to OOP and C++
Why OOP?Why OOP?• “Software Crisis”:
– Too many modules…– Too many functions…– Too many variables…
• Better organization of the code• Smaller code• Reuse of code• Easier design, analysis and implementation• User vs. Programmer
Why C++?Why C++?
• Object-oriented extension of C– Any C program is also valid in C++– Remains of non-OOP characteristics (global variables
and functions, main functions…)• C++ main elements:
– Encapsulation (כימוס(– Template (תבניות(– Inheritance (הורשה(– Polymorphism (רב צורתיות(– Exceptions (חריגות(
A bit of historyA bit of history• Time: 1962• Place: Norwegian Computing
Center, Oslo• Kristen Nygaard and Ole-Johan
Dahl work on simulation of ship movement in fjords– Many kinds of ships, each with its
own characteristics…
How it would have looked like?How it would have looked like?typedef struct {float sailArea;…} SailBoatData;typedef struct {float engineVolume;…} MotorBoatData;void move(Environment *env, Location *loc, int boatKind, void
*boatData){if (boatKind == SAIL_BOAT){
sailArea = ((SailBoatData*)boatData)->sailArea;… //compute movement using sail area, env, and loc
}else if (boatKind == MOTOR_BOAT){engineVolume = ((MotorBoatData*)boatData)->engineVolume;… //compute movement using engine volume, env, and loc
} else … //handle other kinds of boats{void turn(Direction * dir, int boatKind, void *boatData){
if (boatKind == SAIL_BOAT){… //handle sail boat case
}else if (boatKind == MOTOR_BOAT){… //handle the motor boat case
} else … //handle other kinds of boats}
//usage:int main(){ … //set up env. and boat data while(…){ move(env, loc, kind, data); }}
What are the problems?What are the problems?
• Difficult to distribute the work within team– Team member responsible for
• Kind of boats?– Must add code to every function
• Particular operation?– Must be expert in all boat kinds
• Difficult to share code between boat types• Difficult to add new boat types and operations• Difficult to maintain
A bit of history (cont.)A bit of history (cont.)
• Time: 1962• Place: Norwegian Computing Center, Oslo• Kristen Nygaard and Ole-Johan Dahl work on
simulation of ship movement in fjords– Many kinds of ships, each with its own characteristics…
• Solution: group the ships into classes– Each class of ships type has its own data and behavior
• Simula 67
How it would have looked like (2)?How it would have looked like (2)?class Boat {
private:Location loc;
public:void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
How it would have looked like (2)?How it would have looked like (2)?“private” means the following elements are visible only inside the Boat class
“public” means anyone can use the following elements (like in struct)
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
class Boat {private:
Location loc;public:
void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}; class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
How it would have looked like (2)?How it would have looked like (2)?Here we declare that every Boat can move (i.e., has a method move)
And this is the C++ way to say that we are not yet going to specify how the boats move
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
class Boat {private:
Location loc;public:
void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}; class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
How it would have looked like (2)?How it would have looked like (2)?
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
This means that a SailBoat is a Boat and can do whatever a Boat can do
Specifically, this method describes how SailBoat movemoves
class Boat {private:
Location loc;public:
void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}; class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
How it would have looked like (2)?How it would have looked like (2)?
We know every boat can move, so we call the movemove method. At runtime, either move()move() from SailBoatSailBoat or move()move() from MotorBoatMotorBoat will be called, based on boat’s actual type
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
class Boat {private:
Location loc;public:
void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}; class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
How it would have looked like (2)?How it would have looked like (2)?
//usage:int main(){ Boat boat= …; Environment * env = …; while(…){ boat.move(env); }}
class Boat {private:
Location loc;public:
void move (Environment *env) = 0;void turn (Direction *dir) = 0;Location getLocation(){return loc;}
}; class SailBoat: public Boat {
private:float sailArea;
public: void move(Environment *env){…}void turn (Direction *dir){…}
} class MotorBoat: public Boat {
private:float engineVolume;
public: void move(Environment *env){…}void turn (Direction *dir){…}
}
What did we achieve?What did we achieve?• Described the problem in terms natural to the
problem– Pre-OO, we talked in terms of intints and floatfloats, like the
computer– Now we can talk in terms of boatboats and maneuvermaneuvers
• Partitioned the problem into encapsulatedencapsulated sub-problems with well-defined interfaces
• Adding new boat types is easy• And so is changing boat behavior
OOP – The Three Big IdeasOOP – The Three Big Ideas• Encapsulation
– Hide your data – then nobody can change it by mistake• private: Location loc;private: Location loc;
– Hide your algorithms – then you may change them at any time• Implementation of move(…)move(…) within each type
• Inheritance– Shared behavior implemented just once
• Boat::getLocation()Boat::getLocation()• Polymorphism
– Provide different method implementations in different types– Allows, when using objects, to keep to the right level of details
• main(){… boat.move(env);…}main(){… boat.move(env);…}
The OO view of the worldThe OO view of the world
• The world is a set of objects interacting with each other
:SailBoat :Environment
move() getLocation()
computeWind(Location)
computeCurrent(Location)
An aside: UMLAn aside: UML
• Unified Modeling Language– For spec, tutorials, etc. visit http://www.uml.org/– Generic description of classes, object interactions, etc.
:SailBoat :Environment
move() getLocation()
computeWind(Location)
computeCurrent(Location)
The interacting objects
This is an interaction diagram
This time is spent executing computeWind(Location)
Call computeCurrent(Location)
Return a value from computeCurrent(Location)
Back to the OO viewBack to the OO view
• The world is a set of objects interacting with each other
• Each object is an instanceinstance of a class– Same behaviorbehavior, different datadata
• Classes may inheritinherit data and functionality from other classes
Inheritance treeInheritance tree
Boat
SailBoat MotorBoatPaddleBoat
AircraftCarrier
UML Class diagramUML Class diagram
Boat
getLocation()move(Env)turn(Dir)
Location……
SailBoatfloat sailAreamove(Env)turn(Dir)
MotorBoatfloat engineVolumemove(Env)turn(Dir)
Data
Functionality
“Has-a” relationship
Hollow arrow means inheritance(“is-a” relationship)
2. Data Abstraction
Data typesData types• Built-in data types: int, float, …
– Have data• E.g., float has exponent, mantissa, sign bit
– Have operations defined on them• +, !=, …• How is the float ‘+’ implemented? Don’t know
• Goal: user-defined types that behave in the same way– Create, initialize, copy instances– Store state– Perform operations
Example: StringExample: StringClass declarationClass declaration
class String}char* chars;
public:char* getString();void setString(char* value);
{
String.h
int main(){String str; str.setString(“Hi everyone”);printf(“%s\n”, str.getString());
}
Example: StringExample: StringClass definitionClass definition
class String}char* chars;
public:char* getString();void setString(char* value);
{
String.cpp
char* String::getString(){return chars;}void String::setString(char* value){
int length = strlen(value);chars = new char[length+1];strcpy(value, chars);
}
String.h -- reminder
EncapsulationEncapsulation• Recall some of our objectives
– Develop classes independently– Facilitate implementation changes
• Example:– Replace float sailArea;sailArea; with float sailAreas[];sailAreas[];– Have to find everyone who uses sailAreasailArea and figure out how
to replace the usage --Potential for bugs!• But: if a field is not accessible outside the class, it
cannot be used there– Data hiding
C++: Limiting data visibilityC++: Limiting data visibility
• Visibility of class members limited in class declaration– private – accessible only within the class – protected – accessible only within the class and classes that inherit
from it– public – accessible anywhere
• private is the default access level class C{
int i; //private by defaultprivate:
int j1;int j2;
protected:int k;
public:int l;
}• This is just the basics…
class String} char* chars;public: char* getString(); void setString(char* value);
{
Example: String (cont.)Example: String (cont.)
• Let’s add string comparison!
class String}char* chars;
public:char* getString();void setString(char* value);int equals(String *other);
{
String.h int main(){String str1, str2; str1.setString(“Hi everyone”);str2.setString(“Hello”);if (str1.equals(str2) ==1)
printf(“equal!\n”); }
String comparison: 1String comparison: 1stst attempt attemptclass String}
char* chars;public:
char* getString();void setString(char* value);int equals(String *other);
{ String.h
char* String::getString(){return chars;}void String::setString(char* value){…}int String::equals(String *other){
if (strcmp(chars, other->chars) == 0)return 1;
return 0;}
String.cpp
Optimizing comparison Optimizing comparison
• Observation: – Most of the strcmpstrcmps are likely false
• Let’s improve performance by saving strcmpstrcmps– Run strcmpstrcmp only on strings of equal length– Cache string lengths
String comparison: 2String comparison: 2ndnd attempt attempt
class String}char* chars;int length;
public:char* getString();void setString(char* value);int equals(String *other);
{
String.h
String comparison: 2String comparison: 2ndnd attempt attempt
char* String::getString(){return chars;}void String::setString(char* value){
int length = strlen(value); chars = new char[length+1];strcpy(value, chars);
}int String::equals(String *other){
if (length != other->length)return 0;
if (strcmp(chars, other->chars) == 0)return 1;
return 0;}
String.cpp
String comparison: 2String comparison: 2ndnd attempt attempt
• Changes to the main() function:
String comparison: SummaryString comparison: Summary
• Defined a type and operations on it• Internal data representation was
concealed from the class clients• Changed implementation without touching
the client code