Programming Languages byRavi SethiChapter 6:

Groupings of Data and Operations

Constructs for Program Structuring

The programming with

• Procedures

• Modules

• Classes

Procedures

Raising the level of a Computation

Program design with Procedures

• Behavior

• Implementation

– Behavior

• In general the behavior of a construct is what is

observable from outside the construct

• Define procedure corresponding to what an

algorithm does

– Implementation• The part that is accessible only from within that

construct

• Hide the details of an algorithm in the

procedure body

Example The evaluation of expression

(512 - 487) * 2;

It can be partitioned into ScanningScanning or Lexical analysis groups

individual characters into tokens

ParsingParsing or Syntax analysis uses the

syntactic structure of the expression to

determine its value.

CHARACTERSTREAM

(512 - 487) * 2;

TOKENSTREAM

EXPRESSIONVALUE

Scanner

Parser

50

lparen number512 minus number487 rparen times number2 semicolon

Modules A module is a collection of declarations,

including both variables and procedures A module serves as a black box with

which the rest of the program interacts through an interface

Program design with Module• Role

• Interface

• Implementation

– Role• Modules are usually organized around

data.• If an operation affects some data, then

the operation and the data may belong together in a module

– Interface• A subset of the declaration in the

module

• Contain types, variables, and procedures

• The procedures in the interface determine the behavior of the module

– Implementation• Consist of everything else about the

module, including the code for procedures and for initialization

• Hide design decision in the private part of a module

Figure 6.2 Public and private view of two modules

Classes : User-defined data type

Design types corresponding to what the

program manipulates

A term class is an abbreviation of “class of

objects”

An object is a run-time entity with data on

which operations can be performed

Comparison of Procedures, Modules and Classes Serve distinct needs can be used in combination with each other procedures - needed to implement

operations in a module or class module - used to statically partition the

source text of program with classes differences in not in activity (the

procedures)but in the organization

Procedures

Define all the details all the representation is known

throughout the program entries are represented as a pointer to a

record containing the data

Modules

Hide the representation provide public operations advantage over procedures is that the

representation is hidden and access is checked

hiding and checking contribute to feel of entries as object rather than pointers

Defined Types

As with modules, the representation is hidden, access is checked

in addition, objects are initialized upon creation

Program Organization Procedures at

the same level– a sequence of

useful procedures

– procedures can call each other

Figure 6.6

Nested procedures– An attempt to manage

programs with many procedures

– The idea is to declare a procedure inside another

– To declare functions close to where they are used

Figure 6.7

Modules– a collection of data

and related actions– a grouping of

declarations, which can include types, variables, and procedures

Figure 6.8

CHAPTER 6: PART II

6.5 CLASS DECLARATIONS IN C++

6.6 DYANAMIC ALLOCATION IN C++

6.7 TEMPLATES: PARAMETERIZED TYPES

6.8 IMPLEMENTATION OF OBJECTS IN C++

6.5 CLASS DECLARATIONS IN C++

C++: User-defined types receive the same support as built-in types.

Classes = generalization of records called structures (grouping of data).

Both data and functions can be structure members.

Variables can be declared and objects created in C++ classes.

STRUCTURE OR CLASS

Structure vs. Class = Public vs. Private All members of a structure are public. All members of a class are private. Take note: These are by default!!!! A structure is a special case of a class of the

same name.

DECLARATION

Keyword: struct Declarations enclosed in braces {}. Declarations in braces are members.

SAMPLE CODE

struct Stack{

int top;

char elements[101];

char pop( );

void push (char);

Stack ( );

};

2 variables – top- data member that

holds an integer– elements- data member

that holds an array of characters

3 functions– pop- takes no parameter

and returns a character– push- takes character

and returns nothing– Stack- constructor

Constructors & Destructors

Stack ( );

…………………….. ~Stack ( );

Constructors and destructors are parameterless functions.

Same name as class.

Called automatically:– constructors initialize– destructors clean up

MEMBER NAMES AND FUNCTION CODE

struct Stack{

int top;

char elements[101];

char pop( );

void push (char);

Stack ( ) { top = 0; }

};

char Stack::pop ( );

top = top - 1;

return elements[top+1];

}

void Stack::push (char c) {top = top + 1;

elements[top] = c;

}

Full member name: <class-name>::<member name>

– full names needed to make explicit that belong to class if used outside of class declaration

If class name is known from context, use only the member name.

CLASS NAMES AS DEFINED TYPES

#include <stdio.h>

main( ) {

Stack s;

s.push(‘!’); s.push(‘@’); s.push(‘#”);

printf(“%c %c %c\n”, s.pop( ), s.pop( ), s.pop( ));

}

After declared, a class name can be used to declare variables.

Dot notation refers to members of an object.

C struct Complex x; C++ Complex x;

INITIALIZATION WITH PARAMETERS

struct Complex {

float re;

float im;

Complex(float r, i) {re =r; im = i; }

};

………………………..

Complex x(1, 2)

Initialization of constructor may require passing of parameters.

Here declaration takes 2 parameters.

Declares and initializes complex # x to the parameters in ( ).

OVERLOADED FUNCTION NAMES

struct Complex {

float re;

float im;

Complex(float r)

{re = r; im = 0; }

Complex(float r, i) {re =r; im = i; }

};

Functions can be overloaded (including constructors).

Must differ by number and/or type of parameters in call.

ACCESSIBITLITY: PUBLIC, PRIVATE, PROTECTED

Privacy and access class based. Access to members restricted through keywords (apply

to outside class: in class have access to all objects in same class).

Public members are accessible to outside code. Private members are accessible to member functions in

the class declaration. Accessible to all objects of class. Protected members like private members except for

derived classes, visible through inheritance to derived classes.

PUBLIC vs. PRIVATE

Class Stack {

public:

Stack ( );

char pop( );

void push(char);

private:

int top;

char elements[101];

};

Here the member variables are hidden (private).

By default:– struct = public– class = private

6.6 DYNAMIC ALLOCATION IN C++

Three ways to create objects in C++:– variable declarations– dynamically through new– as static objects

NEW, DELETE

new T;

delete p;

Objects created by new exist until destroyed by delete.

New creates object of type T and returns pointer.

Delete destroys object pointed to.

POINTERS TO OBJECTS

Prefix * is a pointer-deferencing operator. Cell * p; reads as “we get an object of type

cell when we apply * to p.” Summary of pointer notations:

– p->info = member info of object pointed to by p.

– 0 = null pointer, pointing to no object.– this = used within member functions to

point to this object itself.

DYNAMIC ALLOCATION USING CONSTRUCTORS AND DESTRUCTORS

Class Stack {

int top;

char * elements;

int size;

public:

void push(char);

char pop( );

Stack (int);

~Stack( );

};

Here the size of the array is a parameter.

Since dynamically allocated storage is taken off the heap it needs a destructor to explicitly deallocate (release) it.

CELLS AND LINKED LISTS

class Cell {

int info;

Cell * next;

Cell(int I) {info = I; next = this;}

Cell(int I, Cell*n) {info = I; next = n;}

friend class List;

};

Friends– friend declaration within a

class gives nonmember functions access to private members of the class

Cell constructors– empty list is a cell that

points to itself– new Cell c(0) or – next = this

LINKED LISTS

class List {

Cell * rear;

public:

void put(int);

void push(int);

int pop( );

int empty( ) {return rear == rear->next; }

List( ) {rear = new Cell(0);}

~List( ) {while(!empty( )) pop( );}

};

Uses constructors from class Cell (because of friend declaration)

Initializes new list (circularly linked cell)

push adds to front put adds to back pop returns value of

front and deletes cell

6.7 TEMPLATES: PARAMETERIZED TYPES

Data structures are containers that hold objects.

Operations on a container can be defined for any type.

Type parameters denote the type of element in the container.– Template <class T>

6.8 IMPLEMENTATION OF OBJECTS IN C++

Objects laid out like records. (class = structure containing data members)

Pointers used to access indirectly. Functions can be expanded in-line to

reduce function call overhead. Class declaration assists with checking

restrictions and in-line expansion at compile time.

Take you C assignment and translate it directly into C++ using “BIN” objects. See page 246 in PL book for stack objectexample. Due 10/12/2000