Post on 30-Dec-2015
1
Object Oriented ProgrammingDevelopment - Week 4
By: Rob MantonUniversity of Luton
Email: Rob.Manton@luton.ac.ukRoom: D104
2
Module Outline
IntroductionThe non object
oriented basicsClassesDesign ApproachesTesting
InheritanceAggregationPolymorphismMultifile
Development
3
Today:
Functions recap
Classes recap
Objects recap
Object Persistence and Visibility.
4
Functions (not OO)
void doSomething();
int main(){
doSomething();return 0;
}void doSomething(){
printf("Hello World!\n");}.
Function declaration goes before main(). Function body goes afterwards or alternatively put these in a separate file and #include it.
5
Working with classesFor small classes you can add the definition above main() and the implementation below, but it is more usual to place them in separate files..
6
Working with classes
Definition file (.h) and implementation file (.cpp) are added to project automatically when you do Insert/New Class
7
The two steps of Object Oriented Programming
Making Classes: Creating, extending or reusing abstract data types.
Making Objects interact: Creating objects from abstract data types and defining their relationships.
Example: The Creature classclass Creature { private: int yearOfBirth;public: void setYearOfBirth(year) { yearOfBirth = year; } int getYearOfBirth() { return yearOfBirth; } };
born1997
Example: The Creature classclass Creature {
private:
int yearOfBirth;
public:
void setYearOfBirth(year) {
yearOfBirth = year;
}
int getYearOfBirth() {
return yearOfBirth;
}
};
The definition of a class:•The class keyword, followed by the class name.•private attributes.•public methods.•the ; at the end
Example: The Creature classclass Creature {
private:
int yearOfBirth;
public:
void setYearOfBirth(year) {
yearOfBirth = year;
}
int getYearOfBirth() {
return yearOfBirth;
}
};
This class has anattribute of typeint. Note that each C++data type and also abstract data types can be used as attribute types.
Example: The Creature classclass Creature {
private:
int yearOfBirth;
public:
void setYearOfBirth(year) {
yearOfBirth = year;
}
int getYearOfBirth() {
return yearOfBirth;
}
};
This class has two (public) methods. One to set the attribute value and the other to retrieve the attribute value.
Example: The Creature classclass Creature { private: int yearOfBirth;public: void setYearOfBirth(year); int getYearOfBirth();};void Creature::setYearOfBirth { yearOfBirth = year; }int Creature::getYearOfBirth() { return yearOfBirth; }
Note that unless the methods are very short, declaration and implementation is usually separated.
The declaration goes into a header file (.h), the implementation in a .cpp file.
Example: The Creature classclass Creature { private: int yearOfBirth;public: void setYearOfBirth(year)
{ yearOfBirth = year; } int getYearOfBirth() { return yearOfBirth; } };
This method is an example for a ‘modifier’ method. It modifies the attribute. The method changes the state of the object.
Example: The Creature classclass Creature { private: int yearOfBirth;public: void setYearOfBirth(year)
{ yearOfBirth = year; } int getYearOfBirth() { return yearOfBirth; } };
This method is an example for a ‘selector’ method. It returns information about the attribute but does not change the state of the object.
15
Classes & Objects
What may be different for all objects in a class, and what remains the same?
All the objects in a class may have different attribute values (state data), but their allowed behaviours are all the same.
So a class is a
blueprint for objects
16
Objects & Classes
A class is defined by:
A Unique Name
Attributes Methods
An object is defined by:
Identity State Behaviour
17
Instantiating Objects
An object is instantiated just like any other data type:
int x;char y;Creature z;
Declaring z of type ‘creature’ means we have generated an object with the attributes and methods of the class.
18
Multiple Objects
Of course we can create many objects of the same class:
Creature myDog;Creature theMilkman;Creature myBestFriend;
Creates three objects.
19
Sending Messages / Calling Methods.
A message is send to an object by calling a method of this object. Use the . (dot) for calling a method of an object.
int k; k = theMilkman.getYearOfBirth();myDog.setYearOfBirth(1998);
Messages are sent to my dog
and the milkman.
20
Back to the Instantiation...
An object is instantiated just like any other data type:
int x;char y;Creature z;
Here the “default constructor” of the Creature class is automatically called.If we don’t like this we can specify constructors explicitly!
The Creature class with a user defined default constructor.class Creature { private: int yearOfBirth;public: // … Creature() { yearOfBirth = 1970; cout << “Hello.”; } };
The syntax for a constructoris similar as for a method, but:•It has the same name as the class.•It has no return value.
The Creature with a parametrized constructor.class Creature { private: int yearOfBirth;public: // … Creature(int year) { yearOfBirth = year; } };
This constructor can be used as follows:
Creature theMilkman(1953);
instantiates a 49 years old milkman.
The Creature with a copy constructor.
class Creature { private: int yearOfBirth;public: // … Creature(Creature & otherCreature) { yearOfBirth = otherCreature.getYearOfBirth(); } };
Example:Creature myDog(1995);Creature myCat(myDog);
creates a cat of the same age as the dog.
24
Constructors - summary
A constructor is always called when an object is created.
We can define our own constructors (Note: a class can have more than one constructor).
If an object is copied from another object then the copy constructor is called.
25
Classes exercise
On paper for a change….
26
Again: Objects & Classes
A class is defined by:
A Unique Name
Attributes Methods
An object is defined by:
Identity State Behaviour
27
Again: Objects & Classes
A class is defined by:
A Unique Name
Attributes Methods
An object is defined by:
Identity State Behaviour
But: We can give a class state and behaviour with the keyword static!
Example: The Creature class
class Creature { private: int yearOfBirth;
static int numberOfAllCreatures = 0;public: Creature() { // Constructor - counts the creatures. numberOfAllCreatures++; } static int getNumberOfAllCreatures() { return numberOfAllCreatures; }};
Note that all objects share the same value of the “class attribute” numberOfAllCreatures.
29
Last Week’s Summary.
A class is a blueprint for an object.Objects are created similar to other data
types (int, char, …).The construction of an object can be
defined by the user.Messages are sent to an object by calling
a method.static messes the concept of classes and
objects (but is nevertheless useful).
30
This week:types of object
Four types of object (or any other data type)
Automatic (local) objects External (global) objects Static objects Dynamic objects
31
Types of object
Four types of object (or any other data type)
Automatic (local) objects External (global) objects Static objects Dynamic objects
First three are objects with
specific names
32
Types of object
Four types of object (or any other data type)
Automatic (local) objects External (global) objects Static objects Dynamic objects
When objects are predictable enough to be identified at compile time
33
Types of object
Four types of object (or any other data type)
Automatic (local) objects External (global) objects Static objects Dynamic objects
No fixed unique nameIdentified by the memory
address which they occupy
34
Types of object
Four types of object (or any other data type)
Automatic (local) objects External (global) objects Static objects Dynamic objects
For objects that can’t be
defined at compile time: their number
or identity may vary at run
time
35
Automatic objects
Instantiated within the scope of a part of the program (between curly brackets somewhere)
Automatically destroyed when object falls out of scope
visible only within that scope (between when object declared and closing } )
36
External (global) objects
PersistentVisible throughout program moduleInstantiated outside any scope (curly
brackets in C++) - usually at the top of your .cpp file
automatically destroyed when program finishes
can be referenced from other modules via extern keyword
37
Static objects
As mentioned last weekPersistent for whole program - the
same lifetime as an external (global) object - useful to ‘remember’ state
scope as for automatic objectuses keyword static
38
Dynamic objects
Useful where we can’t predict object identities, number or lifetimes.
Created using the new keyword (you get a pointer to the object)
Destroyed using the delete keywordNot destroyed automatically: You
have to do it yourself!!
39
The lifetime of named objects (the first three)
Automatic (local) objects exist while they are in scope
External (global) objects have file scope and exist for the whole program
Static objects - may be instantiated in local scope with local visibility but persist from their declaration to the end of the program
40
class header file creature.h
class creature{private:
int yearOfBirth;
public:creature();virtual ~creature();void setYearOfBirth(int year); int getYearOfBirth();
};
Private member variable (for encapsulation..)
Public constructor with no parameters
Accessor function (‘get’ something)
Modifier function (‘set’ something)
41
class implementation file creature.cpp
creature::creature(){
cout << "constructor called for creature class." << endl;}
creature::~creature(){
cout << "destructor called for creature class." << endl;}
int creature::getYearOfBirth(){
return yearOfBirth;}void creature::setYearOfBirth(int year){
yearOfBirth = year;}
Text message added to constructor and destructor to demonstrate when objects are
created and destroyed
42
Automatic objects
int main(){
cout << "beginning of main function." << endl;
creature myDog;
cout << "end of main function." << endl;return 0;
}
43
Automatic objects
With automatic object, object
destroyed automatically when it goes out of scope
(destructor gets called)
44
Automatic objects
int main(){
cout << "beginning of main function." << endl;
{creature myDog;}
cout << "end of main function." << endl;return 0;cin;
}
Automatic object now within local scope defined by the curly brackets
45
Automatic objects
Because it is declared in local scope the
automatic object is now automatically destroyed
when it goes out of scope, which is before the end of the main
function
46
Automatic objects
{creature myDog;myDog.setYearOfBirth(1966);}
47
Automatic objects
{creature myDog;myDog.setYearOfBirth(1966);}
This is legal. myDog is still in scope.
48
Automatic objects
{creature myDog;}
myDog.setYearOfBirth(1966);
49
Automatic objects
{creature myDog;}
myDog.setYearOfBirth(1966);This is not legal because myDog has gone out of
scope (and been automatically destroyed)
when the call to setYearOfBirth() is made.
50
External (global) objects
creature myDog;
int main(){
cout << "beginning of main function." << endl;
myDog.setYearOfBirth(1966);
cout << "end of main function." << endl;return 0;
}
Object declared outside of any function or scope.
This is legal because object is visible throughout
entire program
51
External (global) objects
With external (global) object,
object is automatically
destroyed when program ends
52
External (global) objects
creature myDog;myDog.setYearOfBirth(1966);
int main(){
cout << "beginning of main function." << endl; cout << "end of main function." << endl;
return 0;}
Not legal: can only call methods and functions
from within the braces of a function body
53
External (global) objects
When is it useful to have a global object or variable?
To make the object or variable visible in other source files within the same project
only externally declared objects can be referenced in other program modules (other .cpp files)
known as external linkage use extern keyword
54
External (global) objects
extern creature myDog;
void person::checkDog(){int dob=myDog.getYearOfBirth();cout << "the dog was born in" << dob;}
Say we have another class called person declared in
person.h and implemented in person.cpp
To refer to the myDog declared in the main file, we
repeat the declaration creature myDog, but adding
the extern keyword
This calls the same creature object declared in the other
program file
55
Static objects
object::object(){value=0;}void object::addValue(int value_in){
value+=value_in;}int object::getValue(){
return value;}
This is part of the implementation file for a new class called object which we
use to demonstrate the difference between auto and
static objects...
56
Static objects
for (i=0;i<5;i++){ cout << "now on iteration number " << i <<endl;
object auto_object;auto_object.addValue(1);
static object static_object;static_object.addValue(1);cout << "auto object contains " << auto_object.getValue() << endl;
cout << "static object contains " << static_object.getValue() << endl;}
}
We compare two different types of object - the auto
version and the static one. Both are created from the
same class, the only difference is the use of the
keyword static
57
Static objects
Auto object gets destroyed when it
goes out of scope at end of each loop.
Static object persists and doesn’t get destroyed when it goes out of scope
58
Static objects
Auto object gets destroyed when it
goes out of scope at end of each loop.
Static object persists and doesn’t get destroyed when it goes out of scope
59
Dynamic objects
Create a pointer to the object type - good practice to initialize them to NULL
then use the new operator to return a pointer to the newly created object
object * myObjectPtr=NULL;myObjectPtr = new object( );
60
Dynamic objects
int main(){
cout << "beginning of main function." << endl;
creature * pDog=NULL;pDog = new creature();
cout << "end of main function." << endl;return 0;cin;
}
pDog is declared as a pointer to a creature object using
creature * type.
61
Dynamic objects
Note that there is no message from the
destructor - the dynamic object is not automatically
destroyed
62
Dynamic objects
Note that there is no message from the
destructor - the dynamic object is not automatically
destroyed
This is your job!You need to
manually destroy the object using the
delete command otherwise you will
get a memory leak!
63
Dynamic objects
int main(){
cout << "beginning of main function." << endl;
creature * pDog=NULL;pDog = new creature();
delete pDog;Manually destroy dynamic
object when you have finished it using the delete command
64
Dynamic objects
Now we are destroying the dynamically
generated object manually - very
important!!
65
Dynamic objects
How do you access the methods of a dynamic object?
Use the -> operator instead of the dot (.) syntax
pDog->setYearOfBirth(1966);
66
Summary
Automatic (local) objectsdestroyed automatically when go out of scopevisible only within scope {}
External (global) objectsdestroyed automatically at end of programvisible throughout modulevisible throughout other modules in program
using extern keyword
67
Summary
static objectsvisible only within scope {}persist throughout program
Dynamic objectsget a pointer to the object not automatically destroyedyour job to delete them otherwise you get a
memory leak
68
Summary
#define NUMDOGS 5int main(){ creature * myDogs[NUMDOGS];
int i;for (i=0;i<NUMDOGS;i++){
myDogs[i]=NULL;myDogs[i]=new creature();myDogs[i]->setYearOfBirth(1970+i);
}for (i=0;i<NUMDOGS;i++){
cout << "dog number "<<i<<" was born in "<<myDogs[i]->getYearOfBirth() << endl;}for (i=0;i<NUMDOGS;i++){
delete myDogs[i];}return 0;
}
69
Summary
70
Summary
Automatic/external/static objects Have a unique name Useful when objects are predictable enough to be
identified at compile time
Dynamic objects No fixed unique name Identified by the memory address which they occupy For objects that can’t be defined at compile time:
their number or identity may vary at run time