The Object-Oriented Approach
Junaed Sattar September 24, 2008 Lecture 4
Today
object-based and object-oriented approach to software creation
Why OOP? OO basics, terminology Why OOP with C++?
Why do we need an OO approach?
Adaptation to change
non OO approach can be robust, structured but lacks flexibility maintainability (a.k.a. service packs) extensibility (newer releases of software) distributed design and development
Better handling software demands
C++ as an OO language?
Great choice, because:
has a large community of users multiparadigm (remember?) performance legacy code access and reuse
Large user base
thriving community of developers high quality compilers, development aids documentation, forums, organizations
Multiparadigm
Does not need to be OO
unlike Java
Non OO (i.e. procedural) approach can be used as deemed necessary
small subroutines, programs
Performance & Legacy Code
properly written C++ programs are memory and performance optimized
fast code, small memory footprint OO design leads to easy performance tuning makes it easy to port C code to C++
C++ is ~98% compatible with C
OO Fundamentals
Objects Classes Inheritance Polymorphism
Objects ... and classes?!
Aren't they the same thing? Classes are like blueprints; they are the specifications, not instantiations Objects are like houses built from blueprints. It really exists.
Classes
The packaging unit in OO programming localizes (i.e. packages) data and member functions
i.e. combines states and services on those states
Why do we need this?
Classes
Easier to apply changes
changes in abstraction/concept inevitable make changes to one place when needed
Logical association becomes functional, syntactual
imagine a software specification of a car service accelerate should only affect state speed
OO and N-OO
C:
floatspeed=0.0; //thisisaglobal ... voidAccelerate() { speed+=0.1; }
C++
classCar{ floatspeed; ... ... voidAccelerate() { speed+=0.1; } }
Objects
Qualities of an object?
not just a package for data and methods fundamental purpose is to provide services hence should be alive, responsible, intelligent
Alive?
Must do some useful thing
contrast with dead data in procedural languages dead data are declared but lie in memory, not used most of the time data must not be garbage i.e. uninitialized dynamic memory
Must maintain a coherent state
Responsible?
Others should be able to delegate tasks
objects are self contained inner workings are protected should perform task in a reliable, consistent manner
Intelligent?
Should know how to perform task
provides services to other users removes complexity from many to few
Intelligent?
Should know how to perform task
provides services to other users removes complexity from many to few o.e. why not airplane rentals?
First steps
Write down requirements
roles and responsibilities what services to provide? why does it exist? is it required?
simplifies design process, streamlines project
C++ class syntax
classClassName{ private: //memberdataandmethods (declarations/definitions) protected: //memberdataandmethods (declarations/definitions) public: //memberdataandmethods (declarations/definitions) };
Public elements
accessible from outside the class NOT accessible from outside the class we'll see soon.
Private elements
Protected?
Example Class: declaration
classVehicle{ private: intnPass; doublegasCapacity; boolHybrid; floatfSpeed; public: Vehicle();//Constructor ~Vehicle();//Destructor boolLoadPassengers(intnp); voidAccelerate(); boolisHybrid()const; floatGetSpeed()const; };
Synopsis
By default, class members are private
specifying private at the start of the declaration is optional can have many more, just an example for now two special ones
Has four data members (states)
Has six methods
More Synopsis
Constructors are called when object is created
always called during instantiation compiler provides default (invisible) dummy constructor provide our own when data initialization is required compiler provides default as well perform data clean up in here
Destructors are called when object is destroyed
Note
Providing our own constructor (and/or destructor) will disable the default constructor given by the compiler.
Even More Synopsis
What are those consts after the methods?
constant member functions, or methods cannot change member variables C++'s way of enforcing read-only access to member variables will generate compiler error if changes to class member variables are made in constant methods
Example Class: definition
Vehicle::Vehicle{ nPass=5; gasCapacity=100; Hybrid=true; fSpeed=0.0f; } boolVehicle::LoadPassengers(intnp) { if(nPass<=np)nPass=np; } voidVehicle::Accelerate(){ fSpeed+=5.0; } boolVehicle::isHybrid()const{returnHybrid;} floatVehicle::GetSpeed()const{returnfSpeed;}
An alternative declaration/definition
classVehicle{ private: intnPass; doublegasCapacity; boolHybrid; floatfSpeed; public: Vehicle(){ nPass=5; gasCapacity=100; Hybrid=true; fSpeed=0.0f; } ~Vehicle(){};//Destructor boolLoadPassengers(intnp) { if(nPass<=np)nPass=np; } ...
...Continued
voidAccelerate(){ fSpeed+=5.0; } boolisHybrid()const{returnHybrid;} floatGetSpeed()const{returnfSpeed;} };//classdeclarationends
Inline functions
Avoids the overhead of the function call
expanded by the preprocessor like a macro in C equivalent to a C define preprocessor statement also can use the inline keyword
Alternate syntax
classVehicle{ ... boolLoadPassengers(int np) { if(nPass<=np) nPass=np; } classVehicle{ ... boolLoadPassengers(int np); }; inlinebool Vehicle::LoadPassengers( intnp) { if(nPass<=np) nPass=np; }
Inline functions
Use inline for short, frequently-used methods Functions that contain static data, loops, switch statements, or recursive calls cannot be inlined
Instantiation
Creating an object
intmain(){ Vehicleferrari; ferrari.Accelerate(); ... return0; }
Can only access public methods or data Privates are hidden (i.e. encapsulated)
Next class
More about access protection encapsulation object pointers and dynamic objects
