Course1

Universitatea de Vest din Timişoara Facultatea de Matematică şi Informatică

Object Oriented Programming

Lect. Dr. Daniel POP

“Getting around”
New things will be thought both in courses and in labs; don’t
miss them; they all matter for the final exam!
In the ‘Further Reading’ sections – what’s in bold is mandatory,
the rest being optional reading
Feedback is always welcome; there’s no stupid question!; don’t
be afraid to interrupt!
Attendance to courses and labs: according to faculty’s rules
Final examination: practical + written tests (to be further refined)
Contact information:
– Email: danielpop@info.uvt.ro
– Web: http://web.info.uvt.ro/~danielpop

Programming II Object-Oriented Programming 2

Scope and objectives
Scope
Develop the knowledge and skills for building
small/medium-sized object-oriented programs

Objectives
To learn object-oriented concepts
To know C++ language syntax
To build console applications using C++ language (GUI,
database access and other additional libraries are not in the
scope of this course and will be covered by further courses)
Introduction to object-oriented analysis and design


Course Outline
• Programming techniques and object-oriented history
• Abstract data types
• Object-oriented concepts: classes and objects
• Operator overloading
• Class relationships
• Inheritance. Multiple inheritance. Class hierarchies
• Exception handling
• Generic programming. Template class & functions. Standard
Template Library (STL)
• Object-oriented analysis and design. UML. Design patterns

Course #1 Agenda
• The Road To Object-Oriented Programming and
Beyond
• Object-oriented Programming and C++ History


The Road to OOP and Beyond

Unstructured programming
Procedural programming
Modular programming
Data abstraction
Object-oriented programming
Generic programming


Unstructured Programming
Simple / small application consisting of one main program
Program = sequence of commands (statements) which modify global
data
Drawback: unmanageable as program gets bigger; a lot of
copy/paste-ed code
Example: in Assembler, C, Pascal etc.
test.c

// data
void main(int argc, char* argv[]) {
// local data
// statements
}


Procedural Programming
Based on the notion of procedure (function)
Decide which procedures you want; use the best algorithms you can find.
Drawback: handling different the data structures and the algorithms operating on
data
Example: programs written using C, Pascal, Fortran, Algol
test.c
double sqrt(double arg1) { void f(double arg1, sometype arg2) {
…. ….
…. sqrt(arg1);
} ….
}
void main(int argc, char* argv[]) {
// local data
f(10, data1);
// statements
sqrt(14.6);
}

Modular Programming
Program size grows  Organizing data
Decide which modules you want; partition the program so that data is hidden in
modules. (data hiding principle)
Drawback: only one state per module + each module exists only once in one program
user-defined types doesn’t behave the same way as built-in types
Example: programs written in C, Modula-2
stack.h stack.c
// declaration of the interface of module #include "stack.h"
char pop(); // ‘‘static’’ means local to this file/module
void push(char); static char v[stack_size];
const stack_size = 100;
static char* p = v; // the stack is initially empty
main.c
char pop() {
#include "stack.h"
// check for underflow and pop
void some_function() {
}
push(’c’);
char c = pop(); void push(char c) {
if (c != ’c’) error("impossible"); // check for overflow and push
} }

Data Abstraction (I)
Based on user-defined types that behave the same way as built-in types (Abstract
Data Types)
Decide which types you want; provide a full set of operations for each type.
Drawback:no way of adapting an ADT to new uses except by modifying its
definition (need for “type fields” that distinguish between various instantiations)
Example: programs written using Ada, C++, Clu, Java
complex.h main.c
class complex {
double re, im; void f() {
public: int ia = 2,ib = 1/a;
complex(double r, double i) { re=r; im=i; } complex a = 2.3;
complex(double r) { re=r; im=0; } // float->complex conversion complex b = 1/a;
friend complex operator+(complex, complex); complex c = a+b*complex(1,2.3);
friend complex operator-(complex, complex); // binary minus
friend complex operator-(complex); // unary minus c = -(a/b)+2;
// ... }
};

Data Abstraction (II)
Drawback:no way of adapting an ADT to new uses except by
modifying its definition (need for “type fields” that distinguish between
various instantiations) shape.cpp
void shape::draw() {
Example: switch (k) {
shape.h case circle: // draw a circle
enum kind { circle, triangle, square }; break;

class shape { case triangle: // draw a triangle
point center; break;
color col;
kind k; case square: // draw a square
// representation of shape break;
public:
point where() { return center; } default: // unknown shape
void move(point to) { center = to; draw(); } }
void draw(); }
};


Object-Oriented Programming
World of interacting objects, each one managing its own state
Decide which classes you want; provide a full set of
operations for each class; make commonality explicit by
using inheritance.
Example: programs written using Simula, C++, Java, Eiffel, Smalltalk
etc.
shape.h rectangle.h
class shape { class rectangle : public shape {
point center; double width, height;
color col; // representation of rectangle
// representation of shape public:
public: void draw() {
point where() { return center; } // draw the rectangle
void move(point to) { center = to; draw(); } }
virtual void draw(); };
};


Generic Programming
Express algorithms independently of representation details
Decide which algorithms you want; parameterize them so
that they work for a variety of suitable types and data
structures.
Example: programs written using C++, Java (≥ 1.5)
stack.h file.cpp
template<class T> class stack { void f() {
T* v; stack<char> schar;
int max_size, top; stack<complex> scomplex;
Public: stack<list<int>> slistint;
stack(int s);
~stack(); schar.push(‘c’);
void push(T v); if(schar.pop()!=‘c’) throw Impossible();
T pop(); scomplex.push(complex(3, 2));
}; }


Object-Oriented Programming

1. What is Object-Oriented Programming?
2. Short history of OOP
3. What is C++?
4. Short history of C++


Definitions (I)
• DEFINITION [Object Oriented Programming] A language or technique is
object-oriented if and only if it directly supports [Stroustrup, 1995]:
[1] Abstraction – providing some form of classes and objects
[2] Inheritance – providing the ability to build new abstractions out of existing
ones
[3] Runtime polymorphism – providing some form of runtime binding.

• This definition includes all major languages commonly referred to as
object-oriented: Ada95, Beta, C++, Java, CLOS, Eiffel, Simula, Smalltalk,
and many other languages fit this definition. Classical programming
languages without classes, such as C, Fortran4, and Pascal, are excluded.
Languages that lack direct support for inheritance or runtime binding, such
as Ada88 and ML are also excluded.

Definitions (II)
• DEFINITION A typical dictionary definition reads: object: a visible or tangible thing of
relative stable form; a thing that may be apprehended intellectually; a thing to which
thought or action is directed [The Random House College Dictionary, 1975]

• DEFINITION [Object] Samplings from the OO literature include:
[1] An object has identity, state and behavior ([Booch, 1990]).
[2] An object is a unit of structural and behavioral modularity that has properties ([Buhr,
1998]).
[3] An object as a conceptual entity that: is identifiable, has features that span a local
state space, has operations that can change the status of the system locally, while also
inducing operations in peer objects. ([de Champeaux, 1993])

• Not easy to think “object-oriented”; shift from structural thinking; using classes,
methods and attributes is not OO!


A Short History of Object-Oriented Programming
Simula 67 – the first OO programming language; extension of ALGOL60
Smalltalk – conceived by Alan Kay (Smalltalk-72, Smalltalk-80); dynamically
typed; Strongtalk (1993) – Smalltalk + type system
mid 80’s – many languages added support for OO: Objective C, C++, Object
Pascal, Modula 3, Oberon, Objective CAML, CLOS.
Eiffel – Bertrand Meyer (1988) – Pascal-like syntax, design-by-contract
Other “exotic” OO languages: Sather, Trellis/Owl, Emerald, Beta (evolution
of Simula), Self
Java – James Gosling (1995); Java 1.5 (2004) – support for generic
programming
(Theoretical) extensions to Java: e.g. GJ (1998)

[Bruce, 2002]

What is C++?
• DEFINITION 1: C++ is a general-purpose programming language with a
bias towards systems programming that supports efficient low-level
computation, data abstraction, object-oriented programming, and generic
programming. [Stroustrup, 1999]

• DEFINITION 2: C++ is a statically-typed general-purpose language
relying on classes and virtual functions to support object-oriented
programming, templates to support generic programming, and providing
low-level facilities [Stroustrup, 1996]
to support detailed systems programming.


C++ Design Ideas
C++ was designed to support a range of good and useful styles. Whether they were object-oriented,
and in which sense of the word, was either irrelevant or a minor concern [Stroustrup, 1995]:

[1] Abstraction – the ability to represent concepts directly in a program and hide incidental details
behind well-defined interfaces – is the key to every flexible and comprehensible system of any
significant size.
[2] Encapsulation – the ability to provide guarantees that an abstraction is used only according to
its specification – is crucial to defend abstractions against corruption.
[3] Polymorphism – the ability to provide the same interface to objects with differing
implementations – is crucial to simplify code using abstractions.
[4] Inheritance – the ability to compose new abstractions from existing one – is one of the most
powerful ways of constructing useful abstractions.
[5] Genericity – the ability to parameterize types and functions by types and values – is essential
for expressing type-safe containers and a powerful tool for expressing general algorithms.
[6] Coexistence with other languages and systems – essential for functioning in real-world
execution environments.
[7] Runtime compactness and speed – essential for classical systems programming.
[8] Static type safety – an integral property of languages of the family to which C++ belongs and
valuable both for guaranteeing properties of a design and for providing runtime and space
efficiency.

A Short History of C++
1979 – 1983 C with Classes: Bjarne Stroustrup (AT&T Bell Labs)
ports concepts (e.g. classes, inheritance) from Simula67 to C
1982 – 1985 From C with Classes to C++: the first commercial
release and the printing of the book that defined C++ in October 1985
1985 – 1988 Release 2.0: Evolutions from the first release
1987 – today The Explosion in Interest and Use: growth of C++ tools
and library industry.
1988 – today Standardization: formal ISO and ANSI standardization.
1994 : Standard Template Library
1998 : International C++ standard

[Stroustrup 1992, Stroustrup 1997]


Further Reading
Programming Techniques
• [Stroustrup, 1997] Bjarne Stroustrup – The C++ Programming Language 3rd Edition, Addison Wesley, 1997 [Chapter 2]
• [Mueller, 1996] Peter Müller – Introduction to Object-Oriented Programming Using C++, Globewide
Network Academy (GNA) www.gnacademy.org, 1996 [Chapter 2]
• [Stroustrup, 1991] Bjarne Stroustrup
- What is Object-Oriented Programming? (1991 revised version). Proc. 1st European Software Festival. February, 1991
• [Stroustrup, 1999] Bjarne Stroustrup - An Overview of the C++ Programming Language in “The Handbook of Object
Technology” (Editor: Saba Zamir). CRC Press LLC, Boca Raton. 1999. ISBN 0-8493-3135-8.
Short History of Object-Oriented Programming and C++
• [Bruce, 2002] Kim B. Bruce – Foundations of Object-Oriented Languages, MIT Press, 2002 [Page 113-116]
• [Stroustrup, 1992] Bjarne Stroustrup - A History of C++: 1979−1 991
• [Stroustrup, 1995] Bjarne Stroustrup - Why C++ is not just an Object-Oriented Programming Language, AT&T Bell
Laboratories Murray Hill, New Jersey; Invited talk given at OOPSLA’95, Austin, Texas.
• [Stroustrup, 1996] Bjarne Stroustrup
– A Brief Look at C++. IEEE AI Expert, Intelligent Systems and their Applications, pp 13-15. February 1996
• [de Champeaux, 1993] Dennis de Champeaux, Douglas Lea, and Penelope Faure - Object-Oriented System
Development, Addison Wesley,1993
• [Booch, 1990] G. Booch. Object Oriented Design with Applications. Benjamin/Cummings, 1990.
• [Buhr, 1998] R. Buhr. Machine charts for visual prototyping in system design. Technical Report 88-2, Carlton
University, August 1988.

Course1

More Related Content

What's hot (19)

Viewers also liked (11)

Similar to Course1 (20)

Recently uploaded (20)

Course1