slide1
Download
Skip this Video
Download Presentation
OBJECT ORIENTED FEATURES AND IMPLEMENTATION OF UNIVERSAL QUANTIFICATION IN C++

Loading in 2 Seconds...

play fullscreen
1 / 9

OBJECT ORIENTED FEATURES AND IMPLEMENTATION OF UNIVERSAL QUANTIFICATION IN C++ - PowerPoint PPT Presentation


  • 92 Views
  • Uploaded on

OBJECT ORIENTED FEATURES AND IMPLEMENTATION OF UNIVERSAL QUANTIFICATION IN C++. Karoly Bosa RISC SS2000. OVERVIEW: - Class definition - Object declaration - Inheritance - Virtual functions - Templates and Universal Quantification. 1. Class definition. C++: class Cell {

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 FEATURES AND IMPLEMENTATION OF UNIVERSAL QUANTIFICATION IN C++' - mei


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
slide1

OBJECT ORIENTED FEATURES AND IMPLEMENTATION OF UNIVERSAL QUANTIFICATION IN C++

Karoly Bosa RISC SS2000

slide2

OVERVIEW:

- Class definition

- Object declaration

- Inheritance

- Virtual functions

- Templates and Universal Quantification

slide3

1. Class definition

C++:

class Cell {

public :

int contents;

Cell() { contents=0; }

int get()

{ return contents; }

void set(int n)

{ contents = n; }

}

In the untyped -calculus:

Cell =

[Cell = (z)[contents =

(s)z.contents(s), get =

(s)z.get(s), set =

(s)z.set(s)],

contents = (s) 0;

get = (s) s.contents;

set = (s) (n) s.contents:=n]

When the constructor method is called, the system substitute class name Cell for self parameter Z.

slide4

2. Object declaration

C++:

Cell cellobject;

The C++ call the constructor automatically.

In the untyped -calculus:

cellobject = Cell.Cell =

[contents = (s) 0; get = (s) s.contents;

set = (s) (n) s.contents:=n]

When a method is called:

cellobject.get() 

s.contents {{scellobject}} =

cellobject.contents;

slide5

3. Inheritance

C++:

class reCell : public Cell {

public :

int backup;

reCell()

{ backup = 0; }

void set(int n)

{ backup = contents;

Cell::set(n); }

void restore()

{ contents = backup;}

}

  • In the untyped -calculus:
  • reCell =
  • [reCell = (z)[contents =
  • (s)z.contents(s), get =
  • (s)z.get(s), set =
      • (s)z.set(s), backup = (s)z.backup(s), restore = (s)z.restore(s)],
  • contents = Cell.contents,
  • get = Cell.get,
  • set = (s) (n) Cell.set(s.backup :=
  • s.contents)(n),
  • backup = (s) 0;
  • restore (s) s.contents := s.backup ]
slide6

4. Virtual functions (Self Application Semantics) I.

C++ Example:

class A{

public :

void aa() { bb(); }

virtual void bb() { cout << “Called: method bb of class A \n”; }

}

class B : public A {

public:

void bb() { cout <<

”Called: method bb of class B \n”; }

}

...

Declaration of objects:

A objectA;

B objectB;

Self Application Semantics:

objectA  [aa = (x1){x1.bb}, bb =

(x2){cout << ...bb of A;}]

When B extends A:

A.bb() (y){cout <<...bb of B;}

objectB  [aa = (x1){x1.bb}, bb =

(y){cout << ...bb of B;}]

Question : if we call objectB.aa(), which method bb() will be done?

slide7

4. Virtual functions (Self Application Semantics) II.

If we call

objectA.aa()  x1.bb() {{x1  objectA}} objectA.bb()

then the output will be:

Called: method bb of class A

If we call objectB.aa()  x1.bb() {{x1  objectB}} objectB.bb()

then the output will be:

Called: method bb of class B

slide8

5. Templates and Universal Quantification

Simple Template:

template<class T> class Vector {

...}

Function Template:

template<class T> void sort(Vector<T>& v)

{

unsigned int n = v.size();

for (int i=0; i<n-1; i++)

for (int j=n-1; i<j; j--)

if (v[j] < v[j-1]) {

T temp = v[j]; v[j] = v[j-1];

v[j-1] = temp;

}

}

Vector <int> vi; ... sort(vi);

Vector<complex> vc; ... sort(vc);

Universal Quantification:

type Generic_sort = T.Generic_sortWRT[T]

type Generic_sort[T] = {sort:(Vector[T] Vector[T]}

value int_sort : Generic_sortWRT[int] = {sort=fun(v : Vector[int]) st(v);}

In this case, the generic block contains only one function always.

ad