Object oriented programming development week 4
Download
1 / 70

Object Oriented Programming Development - Week 4 - PowerPoint PPT Presentation


  • 82 Views
  • Uploaded on

By: Rob Manton University of Luton Email: Rob.Manton@luton.ac.uk 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 l.jpg

By:

Rob Manton

University of Luton

Email:

Rob.Manton@luton.ac.uk

Room:

D104

Object Oriented ProgrammingDevelopment - Week 4


Module outline l.jpg

Introduction

The non object oriented basics

Classes

Design Approaches

Testing

Inheritance

Aggregation

Polymorphism

Multifile Development

Module Outline


Today l.jpg
Today:

  • Functions recap

  • Classes recap

  • Objects recap

  • Object Persistence and Visibility.


Functions not oo l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg

class Creature {

private:

int yearOfBirth;

public:

void setYearOfBirth(year) {

yearOfBirth = year;

}

int getYearOfBirth() {

return yearOfBirth;

}

};

Example: The Creature class

born1997


Example the creature class9 l.jpg

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

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

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

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

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

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

A class is defined by:

A Unique Name

Attributes

Methods

An object is defined by:

Identity

State

Behaviour

Objects & Classes


Instantiating objects l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg

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

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

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 l.jpg
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 l.jpg
Classes exercise

  • On paper for a change….


Again objects classes l.jpg

A class is defined by:

A Unique Name

Attributes

Methods

An object is defined by:

Identity

State

Behaviour

Again: Objects & Classes


Again objects classes27 l.jpg

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

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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
Automatic objects

int main()

{

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

creature myDog;

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

return 0;

}


Automatic objects43 l.jpg
Automatic objects

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


Automatic objects44 l.jpg
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 l.jpg
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 l.jpg
Automatic objects

{

creature myDog;

myDog.setYearOfBirth(1966);

}


Automatic objects47 l.jpg
Automatic objects

{

creature myDog;

myDog.setYearOfBirth(1966);

}

This is legal. myDog is still in scope.


Automatic objects48 l.jpg
Automatic objects

{

creature myDog;

}

myDog.setYearOfBirth(1966);


Automatic objects49 l.jpg
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 l.jpg
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 l.jpg
External (global) objects

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


External global objects52 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
Dynamic objects

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


Dynamic objects62 l.jpg
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 l.jpg
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 l.jpg
Dynamic objects

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


Dynamic objects65 l.jpg
Dynamic objects

  • How do you access the methods of a dynamic object?

  • Use the -> operator instead of the dot (.) syntax

  • pDog->setYearOfBirth(1966);


Summary l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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