object oriented programming development week 4
Download
Skip this Video
Download Presentation
Object Oriented Programming Development - Week 4

Loading in 2 Seconds...

play fullscreen
1 / 70

Object Oriented Programming Development - Week 4 - PowerPoint PPT Presentation


  • 81 Views
  • Uploaded on

By: Rob Manton University of Luton Email: [email protected] Room: D104. Object Oriented Programming Development - Week 4. Introduction The non object oriented basics Classes Design Approaches Testing. Inheritance Aggregation Polymorphism

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Object Oriented Programming Development - Week 4' - colette


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
object oriented programming development week 4
By:

Rob Manton

University of Luton

Email:

[email protected]

Room:

D104

Object Oriented ProgrammingDevelopment - Week 4
module outline
Introduction

The non object oriented basics

Classes

Design Approaches

Testing

Inheritance

Aggregation

Polymorphism

Multifile Development

Module Outline
today
Today:
  • Functions recap
  • Classes recap
  • Objects recap
  • Object Persistence and Visibility.
functions not oo
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.
working with classes
Working with classes
  • For small classes you can add the definition above main() and the implementation below, but it is more usual to place them in separate files..
working with classes6
Working with classes
  • Definition file (.h) and implementation file (.cpp) are added to project automatically when you do Insert/New Class
the two steps of object oriented programming
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 class
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class

born1997

example the creature class9
class Creature{

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class
  • The definition of a
  • class:
  • The class keyword, followed by the class name.
  • private attributes.
  • public methods.
  • the ; at the end
example the creature class10
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class
  • 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 class11
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class
  • This class has two (public) methods. One to set the attribute value and the other to retrieve the attribute value.
example the creature class12
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year);

int getYearOfBirth();

};

void Creature::setYearOfBirth {

yearOfBirth = year;

}

int Creature::getYearOfBirth() {

return yearOfBirth;

}

Example: The Creature class

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 class13
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class

This method is an example for a ‘modifier’ method. It modifies the attribute. The method changes the state of the object.

example the creature class14
class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class

This method is an example for a ‘selector’ method. It returns information about the attribute but does not change the state of the object.

classes objects
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

objects classes
A class is defined by:

A Unique Name

Attributes

Methods

An object is defined by:

Identity

State

Behaviour

Objects & Classes
instantiating objects
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.

multiple objects
Multiple Objects
  • Of course we can create many objects of the same class:

Creature myDog;

Creature theMilkman;

Creature myBestFriend;

Creates three objects.

sending messages calling methods
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.

back to the instantiation
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 Creature class with a user defined default constructor.
  • 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;

}

};

The Creature with a parametrized constructor.
  • 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();

}

};

The Creature with a copy constructor.
  • Example:
    • Creature myDog(1995);
    • Creature myCat(myDog);
  • creates a cat of the same age as the dog.
constructors summary
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.
classes exercise
Classes exercise
  • On paper for a change….
again objects classes
A class is defined by:

A Unique Name

Attributes

Methods

An object is defined by:

Identity

State

Behaviour

Again: Objects & Classes
again objects classes27
A class is defined by:

A Unique Name

Attributes

Methods

An object is defined by:

Identity

State

Behaviour

Again: Objects & Classes

But: We can give a class state and behaviour with the keyword static!

example the creature class28
class Creature {

private:

int yearOfBirth;

static int numberOfAllCreatures = 0;

public:

Creature() { // Constructor - counts the creatures.

numberOfAllCreatures++;

}

static int getNumberOfAllCreatures() {

return numberOfAllCreatures;

}

};

Example: The Creature class

Note that all objects share the same value of the “class attribute” numberOfAllCreatures.

last week s summary
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).
this week types of object
This week:types of object
  • Four types of object (or any other data type)
    • Automatic (local) objects
    • External (global) objects
    • Static objects
    • Dynamic objects
types of object
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

types of object32
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

types of object33
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 name

Identified by the memory address which they occupy

types of object34
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

automatic objects
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 } )
external global objects
External (global) objects
  • Persistent
  • Visible throughout program module
  • Instantiated 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
static objects
Static objects
  • As mentioned last week
  • Persistent for whole program - the same lifetime as an external (global) object - useful to ‘remember’ state
  • scope as for automatic object
  • uses keyword static
dynamic objects
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 keyword
  • Not destroyed automatically: You have to do it yourself!!
the lifetime of named objects the first three
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
class header file creature h
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

Modifier function (‘set’ something)

Accessor function (‘get’ something)

class implementation file creature cpp
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

automatic objects42
Automatic objects

int main()

{

cout << "beginning of main function." << endl;

creature myDog;

cout << "end of main function." << endl;

return 0;

}

automatic objects43
Automatic objects

With automatic object, object destroyed automatically when it goes out of scope (destructor gets called)

automatic objects44
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

automatic objects45
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

automatic objects46
Automatic objects

{

creature myDog;

myDog.setYearOfBirth(1966);

}

automatic objects47
Automatic objects

{

creature myDog;

myDog.setYearOfBirth(1966);

}

This is legal. myDog is still in scope.

automatic objects48
Automatic objects

{

creature myDog;

}

myDog.setYearOfBirth(1966);

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

external global objects50
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

external global objects51
External (global) objects

With external (global) object, object is automatically destroyed when program ends

external global objects52
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

external global objects53
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
external global objects54
External (global) objects

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

extern creature myDog;

void person::checkDog()

{

int dob=myDog.getYearOfBirth();

cout << "the dog was born in" << dob;

}

This calls the same creature object declared in the other program file

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

static objects56
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

static objects57
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

static objects58
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

dynamic objects59
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( );
dynamic objects60
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.

dynamic objects61
Dynamic objects

Note that there is no message from the destructor - the dynamic object is not automatically destroyed

dynamic objects62
Dynamic objects

This is your job!

You need to manually destroy the object using the delete command otherwise you will get a memory leak!

Note that there is no message from the destructor - the dynamic object is not automatically destroyed

dynamic objects63
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

dynamic objects64
Dynamic objects

Now we are destroying the dynamically generated object manually - very important!!

dynamic objects65
Dynamic objects
  • How do you access the methods of a dynamic object?
  • Use the -> operator instead of the dot (.) syntax
  • pDog->setYearOfBirth(1966);
summary
Summary

Automatic (local) objects

  • destroyed automatically when go out of scope
  • visible only within scope {}

External (global) objects

  • destroyed automatically at end of program
  • visible throughout module
  • visible throughout other modules in program using extern keyword
summary67
Summary

static objects

  • visible only within scope {}
  • persist throughout program

Dynamic objects

  • get a pointer to the object
  • not automatically destroyed
  • your job to delete them otherwise you get a memory leak
summary68
Summary

#define NUMDOGS 5

int 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;

}

summary70
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
ad