1

Languages and Compilers(SProg og Oversættere)

Bent Thomsen

Department of Computer Science

Aalborg University

With acknowledgement to John Mitchell who’s slides this lecture is based on.

2

Varieties of OO languages

• class-based languages– behavior of object determined by its class

• object-based– objects defined directly

• multi-methods – operation depends on all operands

3

History

• Simula 1960’s– Object concept used in simulation

• Smalltalk 1970’s– Object-oriented design, systems

• C++ 1980’s – Adapted Simula ideas to C

• Java 1990’s– Distributed programming, internet

4

Objects• An object consists of

– hidden data

instance variables, also called member data

hidden functions also possible– public operations

methods or member functions

can also have public variables in some languages

• Object-oriented program:– Send messages to objects

hidden data

method1msg1

. . .. . .

methodnmsgn

5

What’s interesting about this?

• Universal encapsulation construct– Data structure

– File system

– Database

– Window

– Integer

• Metaphor usefully ambiguous– sequential or concurrent computation

– distributed, sync. or async. communication

6

Object-oriented programming

• Programming methodology– organize concepts into objects and classes

– build extensible systems

• Language concepts– encapsulate data and functions into objects

– subtyping allows extensions of data types

– inheritance allows reuse of implementation

– dynamic lookup

7

Dynamic Lookup

• In object-oriented programming,object message (arguments)

object.method(arguments)

code depends on object and message

• In conventional programming,operation (operands)

meaning of operation is always the same

8

Example

• Add two numbers x add (y)

different add if x is integer, complex

• Conventional programming add (x, y)

function add has fixed meaning

Important distinction:Overloading is resolved at compile time, Dynamic lookup at run time.

9

Encapsulation

• Builder of a concept has detailed view• User of a concept has “abstract” view• Encapsulation is the mechanism for separating these two

views

message

Object

10

Comparison

• Traditional approach to encapsulation is through abstract data types

• Advantage– Separate interface from implementation

• Disadvantage– Not extensible in the way that OOP is

We will look at ADT’s example to see what problem is

11

Abstract data types

abstype q with mk_Queue : unit -> q is_empty : q -> bool insert : q * elem -> q remove : q -> elem is … in program end

12

Priority Q, similar to Queue

abstype pq

with mk_Queue : unit -> pq

is_empty : pq -> bool

insert : pq * elem -> pq

remove : pq -> elem

is …

in

program

end

But cannot intermix pq’s and q’s

13

Abstract Data Types

• Guarantee invariants of data structure– only functions of the data type have access to the internal

representation of data

• Limited “reuse”– Cannot apply queue code to pqueue, except by explicit

parameterization, even though signatures identical

– Cannot form list of points, colored points

• Data abstraction is important part of OOP, innovation is that it occurs in an extensible form

14

Subtyping and Inheritance

• Interface– The external view of an object

• Subtyping– Relation between interfaces

• Implementation– The internal representation of an object

• Inheritance– Relation between implementations

15

Object Interfaces

• Interface– The messages understood by an object

• Example: point– x-coord : returns x-coordinate of a point

– y-coord : returns y-coordinate of a point

– move : method for changing location

• The interface of an object is its type.

16

Subtyping

• If interface A contains all of interface B, then A objects can also be used B objects.

• Colored_point interface contains Point• Colored_point is a subtype of Point

Pointx-coordy-coordmove

Colored_pointx-coordy-coordcolormovechange_color

17

Inheritance

• Implementation mechanism • New objects may be defined by reusing

implementations of other objects

18

Example

class Point private

float x, y

public

point move (float dx, float dy);

class Colored_pointprivate

float x, y; color c

public

point move(float dx, float dy);

point change_color(color newc);

Subtyping• Colored points can be

used in place of points

• Property used by client program

Inheritance• Colored points can be

implemented by resuing point implementation

• Propetry used by implementor of classes

19

OO Program Structure

• Group data and functions• Class

– Defines behavior of all objects that are instances of the class

• Subtyping– Place similar data in related classes

• Inheritance– Avoid reimplementing functions that are already defined

20

Example: Geometry Library

• Define general concept shape• Implement two shapes: circle, rectangle• Functions on implemented shapes

center, move, rotate, print

• Anticipate additions to library

21

Shapes

• Interface of every shape must includecenter, move, rotate, print

• Different kinds of shapes are implemented differently– Square: four points, representing corners

– Circle: center point and radius

22

Subtype hierarchy

Shape

Circle Rectangle

• General interface defined in the shape class• Implementations defined in circle, rectangle• Extend hierarchy with additional shapes

23

Code placed in classes

• Dynamic lookup– circle move(x,y) calls function c_move

• Conventional organization– Place c_move, r_move in move function

center move rotate print

Circle c_center c_move c_rotate c_print

Rectangle r_center r_move r_rotate r_print

24

Example use: Processing Loop

Remove shape from work queue

Perform action

Control loop does not know the type of each shape

25

Subtyping differs from inheritance

Collection

Set

Sorted Set

Indexed

Array Dictionary

StringSubtyping

Inheritance

26

Representation of objects

Object is represented by activation record with access link to find global variables according to static scoping

p access link

real x 1.0

real y 2.5

proc equals

proc distance

code for equals

code for distance

27

Run-time representation of point

class

x 3

y 2

x

y

newX:Y:

...

move

Point object

Point class

Template

Method dictionary

to superclass Object

code

...

code

Detail: class method shown in dictionary, but lookup procedure distinguishes class and instance methods

28

Access Control

• In many OOPLs it is possible to declare attributes (and methods) private or public or protected etc.

• This has no effect on the running program, but simply means that the compiler will reject programs which violate the access-rules specified

• The control is done as part of static semantic analysis

29

Dynamic (late) Binding• Consider the method call:

– x.f(a,b) where is f defined?in the class (type)of x? Or in a predecessor?

• If multiple inheritance is supported then the entire predecessor graph

must be searched:– This costs a large overhead in dynamic typed languages like Smalltalk

(normally these languages don’t support multiple inheritance)– In static typed languages like Java, Eiffel, C++ the compiler is able to

analyse the class-hierarchy (or more precise: the graph) for x and create a display-array containing addresses for all methods of an object (including inherited methods)

– According to Meyer the overhead of this compared to static binding is at most 30%, and overhead decreases with complexity of the method

30

» fig14.2

31

» fig14.3

32

Multiple Inheritance

• In the case of simple inheritance, each class may have one direct predecessor; multiple inheritance allows a class to have several direct predecessors.

• In this case the simple ways of accessing attributes and binding method-calls (shown previously) don’t work.

• The problem: if class C inherits class A and class B the objects of class C cannot begin with attributes inherited from A and at the same time begin with attributes inherited from B.

• In addition to these implementation problems multiple inheritance also introduces problems at the language (conceptual) level.

33

Attribute Offset with Multiple Inheritance

• The problem is actually a graph colouring problem:– let each name be represented by a vertex

– if two names are in the same scope (perhaps through inheritance) then they are connected by an edge

– all vertices which are adjacent must have different offsets

– this approach may cause empty slots in an object (fig. 14.4)

– the offsets (and the waste of space) may be moved to the class-descriptor (and there much more objects than classes) costing an overhead of two instructions per fetch or store (fig. 14.5)

– this analysis can be done compile-time

– a similar technique may be used for dynamic binding of methods

34

Implementation of Object Oriented Languages

• Implementation of Object Oriented Languages differs only slightly from implementations of block structured imperative languages

• Some additional work to do for the contextual analysis– Access control, e.g. private, public, procted directives

– Subtyping can be tricky to implement correctly

• The main difference is that methods usually have to be looked up dynamically, thus adding a bit of run-time overhead– Only multiple inheritance poses a bigger problem