Object-Oriented Programming

Lecture 1
Dr Piotr Cybula <piotr.cybula@wmii.uni.lodz.pl>
 Literature
Bruce Eckel: Thinking in C++. Second edition. Vol. 1.
(http://mindview.net/Books/TICPP/ThinkingInCPP2e.html)

Robert Lafore: Object-Oriented Programming in C++.

Nicolai Josuttis: Object-Oriented Programming in C++.

Stanley Lippman, Josée Lajoie, Barbara Moo: C++ Primer. Forth edition.

Bjarne Stroustrup: Language C++.

Stephen Prata: C++ Primer Plus.

Michael Ben-Ari: Understanding programming languages.

http://cppreference.com

http://www.cplusplus.com

2/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Programming paradigms
● declarative programming (tell the computer what do you want)
● imperative programming (tell the computer how to do it)
● procedural programming (bottom-up design):
● global data structures with free access (risky)
● many loose functions building a program
● object programming (top-down design):
● protected & separated data structures (black-box solution)
● functions operating on small parts of data (encapsulation)
● generic programming (static polymorphism)
● object-oriented programming (object programming + dynamic polymorphism)
● modular programming, event programming, functional programming, ...

3/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Object-oriented paradigm
Four fundamentals of the object-oriented programming (OOP) :
● Abstraction (abstract data types, ADTs):
● classes as the abstract and simplified model of real beings (structural and
behavioral), objects as instances of classes
● Encapsulation (information enclosing and hiding):
● functions tied together with data (methods)
● data protection (public methods, sending messages, object interface)
● Inheritance (code reuse, interface extensions):
● building specialised objects based on general ones
● Polymorphism (object-orientedness):
● single abstract interface – multiple different forms of inherited objects

4/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Advantages of object-orientedness
● structural and behavioral design similar to the human's thinking of the reality
● increased code safety and reuse (data protection and inheritance)
● a code is easier to write and (the most important) it's a lot easier to read
● clear modular code organisation (encapsulation)
● the encapsulation prevents function name clashes
● the encapsulation prevents from «giving a monkey a razor»
● better team support with the code separation
● proper initialisation and cleanup (constructors, destructors)
● abstract, perspective and dynamic programming (late binding, polymorphism)
● better code stability by the exception handling (exception inheritance)

5/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 History of object-orientedness
● 1960s – Simula 67 : classes, static instances, ship simulations
● 1971 – Smalltalk : dynamic objects created «on-the-fly», object-orientedness
● 1983 – C++ : the extension of the procedural language C
● 1980s : extensions of other existing procedural languages (Ada, Fortran,
Pascal , Basic, Eiffel, Lisp, Perl, OCaml)
● 1991 – Java : C++ based language for virtual machine with garbage collector
(cross-platform)
● 1990s : primarily object-oriented, interpreted, dynamic-typed languages
(Python, Ruby), object-oriented scripting languages (JavaScript, PHP)
● 2002 - .NET framework : cross-language inheritance (C#, VB.NET, J#)
● 2000s : newer object-oriented languages (Swift, Kotlin, TypeScript, ...)
● 2017 – C++17 : the newest standard of the C++ language
6/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz
 Classes and objects
Structural approach (without the encapsulation):
struct Obj //static data structure
{
int a, b;
};

void set(Obj &o, int _a, int _b) //global function(& reference)
{
o.a = _a;
o.b = _b;
}

Obj x; //variable
set(x, 1, 2); //function call

7/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Classes and objects
Object approach (the encapsulation):
struct Obj //abstract data type (the class)
{
int a, b; //fields

void set(int _a, int _b) //method

{
a = _a;
b = _b;
}
};

Obj x; //the object (an instance of the class)

x.set(1, 2); //messege to the object

8/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Interface and implementation
File obj.h (abstract type interface):
struct Obj //abstract data type (the class)
{
int a, b; //fields
void set(int _a, int _b); //method prototype
};

File obj.cpp (abstract type implementation):

#include ”obj.h”
void Obj::set(int _a, int _b) //method body (:: scope operator)
{
a = _a; b = _b;
}

File main.cpp:
#include ”obj.h”
int main()
{
Obj x; //the object (an instance of the class)
x.set(1, 2); //messege to the object
}

9/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Object construction
● the constructor - the special method for proper initialisation of the fields
● called automatically on every object creation
● the name of the constructor is the same as the name of the type (class)
● many constructors with arbitrary number of arguments, no return value!
struct Obj
{
int a, b; //fields

Obj(int _a = 0, int _b = 0) //constructor

{
a = _a;
b = _b;
}
};

Obj x, y(1), z(1, 2), v = 3; //the implicit constructor calls

Obj t[5], *s = new Obj, *p = new Obj[3]; //also here

10/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Default constructor
Default constructor:
● which may be called without arguments (any arguments with default values)
● automatically created if (and only if) there are no explicit constructors, but
without any initialisation of the fields (risky when there are any dynamically
allocated fields in the class)
struct Obj
{
int a, b; //fields

Obj() //default constructor

{
a = 0;
b = 0;
}
};

Obj x, t[5]; //default constructor calls

Obj *s = new Obj, *p = new Obj[3]; //also here

11/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Default constructor
Default constructor:
● if any constructors are defined, the default constructor is not created
automatically
● important – always define the default constructor (to simplify future
inhertitance from the class)
struct Obj
{
int a, b; //fields

Obj(int _a, int _b = 0) //1- or 2-parameter constructor

{
a = 0;
b = 0;
}
};

Obj y(1), z(1, 2); //proper creation

Obj x; //compile-time error without the default constructor

12/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Copy constructor
Copy constructor:
● takes as the only argument a reference to an existing object of the same type
● automatically created if (and only if) there is no explicit copy constructor, but
copying the fields by simple bit-copy (risky when there are any pointer fields)
● important – always define the copy constructor for a class with pointer fields
struct Obj
{
int a, b; //fields
… //default constructor here
Obj(const Obj &o) //copy constructor
{
a = o.a;
b = o.b;
}
};
Obj x;
Obj y(x), z = x; //the implicit copy constructor calls

13/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Converting constructor
Converting constructor:
● takes as the only argument a value of another type (converts this type to the
type of a class)
struct Obj
{
int a, b; //fields
… //default constructor here
Obj(int v) //converting constructor (int → Obj)
{
a = b = v;
}
bool equals(const Obj &o) //method with object argument
{
return (a == o.a) && (b == o.b);
}
};

Obj y(1), z = 2; //the implicit converting constructor calls

if (y.equals(5)) ... //also here

14/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Object destruction
● the destructor - the special method for proper cleanup
● called automatically when the object goes out of scope and on explicit deletion
● the name of the destructor is the same as the name of the type (class) but with
leading tilde (~)
● only one destructor without arguments, no return value!
struct Obj
{
int a, b; //fields
… //default constructor here
~Obj() //destructor with any cleaning operations
{ ... }
};

{
Obj x, *p = new Obj; //constructor calls
delete p; //the explicit destructor call (object *p)
} //the implicit destructor call (object x)

15/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz

 Object destruction
The destructor:
● automatically created if (and only if) there is no explicit destructor, but without
any cleanup operations (risky when there are any dynamically allocated fields
in the class)
● important – always define the destructor for a class with the constructor
dynamically allocating its fields
● destructors for objects are called by the compiler in the reverse order of the
object creation order
{
Obj x, *p = new Obj, z;
{
Obj y;
} //y destructed
delete p; //*p destructed
} //z and then x destructed

16/16 Object-Oriented Programming, Lecture 1, dr Piotr Cybula, University of Lodz