Chapter 8: Object-Oriented

Programming (OOP)

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Introduction to C++

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Overview
Additional features compared to C:

Object-oriented programming (OOP)

Generic programming (template)
Many other small changes

Small changes:

Use // to comment until end of line

area = PI*r*r;
// PI = 3.14

Built-in bool type and false, true boolean constants :

bool b1 = true, b2 = false;

Variables and constants in C++ can be declared anywhere in functions (not

limited to function beginning only), even in for loops
New function-like syntax for type casting: int(5.32)
enum, struct, union keywords become optional in variable declaration

Conventional source files with .cpp extension

main() function can be declared with void return type:
void main() { }

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Some more significant features

Reference types: are pointers by nature

int a = 5;
int& b = a;
b = 10;
// a
int& foo(int& x)
{ x = 2; return
int y = 1;
foo(y);
foo(y) = 3;

= 10
x; }
// y = 2
// y = 3

Namespace

namespace ABC {
int x;
int setX(int y)
}

{ x = y; }

ABC::setX(20);
int z = ABC::x;
using namespace ABC;
setX(40);
4

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Some more significant features (cont.)

Dynamic memory allocation
Allocation: new and new[] operators

Deallocation: delete and delete[] operators

delete a;
delete[] c;

Attn: do not mix malloc()/free() and new/delete:

Memory allocated by malloc() must be deallocated by free()

Memory allocated by new must be deallocated by delete

Function overload (functions with same name but different parameters):

int* a = new int;

float* b = new float(5.23f);
long* c = new long[5];

int sum(int a, int b)

int sum(int a, int b, int c)
double sum(double a, double b)
double sum(double a, double b, double c)

Exception handling try ... catch: self-study

{...}
{...}
{...}
{...}

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

The first C++ program

Example:

#include <iostream>
using namespace std;
void main() {
int n;
cout << "Enter n: ";
cin >> n;
cout << "n = " << n << endl;
}

Input/output with C++:

Using iostream library

cout << used for output to stdout (console by default)
cin >> used for input from stdin (keyboard by default)
Objects of C++ standard library defined in a namespace named std. If using
is not used, one must use std::cout, std::cin, std::endl instead
EE3490E: Programming T1 2015/2016
Dr. o Trung Kin Hanoi Univ. of Science and Technology

Classes and objects

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Introduction
From real world
Objects are things, facts, entities, which are characterized by
properties and can realize certain operations. Ex:
Each student is an object characterized by: name, age,
department, class, year, and can realizes: study, doing
exercises, going to class, doing tests,
Each cellphone is an object characterized by: SIM number,
model, size, and can realizes: making call, texting, answering
to calls, denying calls,
Classes are description of properties and operations of each type
of objects
Simpler consideration: student are objects while the notion of
student is a class, similarly for cellphones and the notion of
cellphone

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Introduction (cont.)
to programming:

Class is a data type extended from structure type (struct). Apart from
fields that correspond to object properties, methods which are similar to
functions are added to realize operations
Object is a variable declared with type of the defined class

From structural programming: function-centered

struct Student {
char name[20];
int year;
};
void go_to_class(Student& s, int room)
void do_test(Student& s)

{ ... }
{ ... }

Student s = { ... };
go_to_class(s, 103);
do_test(s);
9

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Introduction (cont.)

to object-oriented programming:

struct Student {
char name[20];
int year;
void go_to_class(int room) { ... }
void do_test()
{ ... }
};
Student s = { ... };
s.go_to_class(103);
s.do_test();

10

Functions become methods of class and can access directly to properties

(member variables) of called object
Objects (variables) become subject of called methods (functions) instead
of being passed as parameters objects play a central role in
programming
EE3490E: Programming T1 2015/2016
Dr. o Trung Kin Hanoi Univ. of Science and Technology

Scope of members

public properties and methods are accessible from outside of object,

private ones are limited to internal uses
struct Student {
public:
char name[20];
void go_to_class(int room) { ... }
private:
int year;
void do_test()
{ ... }
};
strcpy(s.name, "Nguyen
s.go_to_class(103);
s.year = 2010;
s.do_test();
11

Hung Long"); // OK
// OK
// error
// error
EE3490E: Programming T1 2015/2016
Dr. o Trung Kin Hanoi Univ. of Science and Technology

class and struct

In C++, to avoid confusion with traditional structure types, use class

keyword to declare classes:

class and struct types differ only in default member scopes:

public for struct and private for class

class Student { ... };

struct A {
int a; // public
};
class B {
int b; // private
};

Very often, member variables are defined as private, and are

accessed via member methods hide internal data, better
encapsulation
12

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Class example
#include <iostream>
class Circle {
private:
double r;
public:
void setR(double rr)

{ r = rr; }

double area()

{ return 3.14*r*r; }

double perimeter()

{ return 3.14*2.*r; }

};
void main() {
Circle c;
c.setR(1.23);
std::cout << "Area: " << c.area() << std::endl
<< "Perimeter: " << c.perimeter() << std::endl;
}
13

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Constructors

Are initialization methods for objects. They do not return values, and invoked
automatically every times an object is created.

Possible to define many with different parameters, compiler knows which one
to call based on given parameters. If none defined, a default one is generated.

class Circle {
public:
Circle() { r = 0.; } // default constructor with no parameter)
Circle(double rr) { r = rr; }
...
};
Circle c1, c2(), c3[3];
Circle c4(1.23);
c1 = Circle;
c1 = Circle();
c1 = Circle(2.33);
Circle*
Circle*
Circle*
Circle*

14

c5
c6
c7
c8

=
=
=
=

new
new
new
new

//
//
//
//
//

constructor
constructor
error
constructor
constructor

Circle;
Circle();
Circle(3.22);
Circle[3];

//
//
//
//

1
2
1
2

constructor
constructor
constructor
constructor

1
1
2
1

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Copy constructors

Used in creation of new objects from existing of the same class. Two
syntaxes for invoking copy constructors:

class Circle {
...
Circle(const Circle& c) { r = c.r; }
};
Circle c1(2.5);
Circle c2 = c1, c3(c1);
c2 = c1;

// do not use copy constructor

// use copy constructor
// assignment, not copy constructor

Also used in creation of temporary objects for function calls:

void func1(Circle c) { ... }

void func2(const Circle& c) { ... }
func1(c1); // create temp. obj. c by copying from c1 with CSC
func2(c1); // no obj. created, CSC is not invoked

should use const Circle& c for function parameter instead of Circle& c

for better performance

If no copy constructor defined, compiler generates a default one which

copies all member variables from original object to the new object
15

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Cast constructors

Used in creation of new objects from existing objects of different classes.

Two syntaxes for invoking cast constructors:

class Ellipse {
...
Ellipse(const Circle& c) { rx = ry = c.r; }
};
Ellipse e1(c1), e2 = c2; // use cast constructor: Circle -> Ellipse
e1 = c1; // create a temp. object by implicit cast: Circle -> Ellipse
// then invoke assignment: Ellipse -> Ellipse

Also used in creation of temporary objects for type casting:

void func3(const Ellipse& e) { ... }

func3(c1); // implicit use of cast constructor
cout << ((Ellipse)c1).area(); // explicit use of cast constructor

Possible to add explicit keyword in declaration of cast constructor to avoid being used in
implicit casts

Review Circle class:

16

class Circle {
...
Circle(double rr) {r = rr; }
};

// is cast constructor: int -> Circle

EE3490E: Programming T1 2015/2016
Dr. o Trung Kin Hanoi Univ. of Science and Technology

Initialization lists

There might be an initialization list following a constructors signature for member

variables that need to be initialized

Above constructors can be interpreted as

class Person {
private:
string name;
int age;
public:
Person(const char* n): name(n) { ... }
Person(const char* n, int a): name(n), age(a) { ...}
// ...
};
Person(const char* n) {
name = n;
// ...
}
Person(const char* n, int a) {
name = n;
age = a;
// ...
}

Must be used for constant and reference member variables, and any member variable
of class that does not have default constructor
EE3490E: Programming T1 2015/2016

17

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Destructors

Destructor: method to clean objects before being removed from memory. It

doesnt return value, and is called implicitly every time an object is destroyed.
Do not use malloc()/free() to create or delete C++ objects

At most one destructor for each class

18

class String {
private:
char* str;
public:
String()
{ str = NULL; }
String(const char* s)
{ str = new char[strlen(s)+1]; strcpy(str, s); }
~String()
{ if (str) delete str; }
...
};
String* abc() {
String s1, s2("Hello!"), s3[3];
String *s4 = new String("xyz"), *s5 = new String[3];
String *s6 = new String("abc");
delete s4;
// destroy 1 object
delete[] s5;
// destroy 3 objs, dont use: delete s5
return s6;
// destroy s1, s2, s3[3] but s6 is still there
EE3490E: Programming T1 2015/2016
}

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Separating declaration and definition of methods

string.h

string.cpp

class String {
private:
char* str;
public:
String();
String(const char* s);
~String();
void set(const char* s);
const char* get();
};

String::String()
{ str = NULL; }
String::String(const char* s)
{ str = NULL; set(s); }
String::~String()
{ if (str) delete str; }
void String::set(const char* s) {
if (str) delete str;
if (!s) { str = NULL; return; }
str = new char[strlen(s)+1];
strcpy(str, s);
}
const char* String::get()
{ return str; }

19

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Friend functions and classes

If a function or class is defined as friend of some class, than it has access to

private member variables and methods of that class

class Circle {
private:
double r;
public:
...
friend void printCircle(Circle c);
friend class Ellipse;
};
void printCircle(Circle c)
{ cout << "Radius: " << c.r; }
class Ellipse {
private:
double rx, ry;
public:
void convert(Circle c) {
rx = ry = c.r;
}
};

20

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

this pointer

Is pointer accessible only within the non-static member functions of objects,

points to the object for which the member function being called

class Buffer;
void do_smth(Buffer* buf);
class Buffer {
private:
char* b;
int n;
public:
Buffer(int n)
{ this->n = n; this->b = new char[n]; }
~Buffer()
{ delete this->b; }
void some_method()
{ do_smth(this); }
};
Buffer buf(4096);
buf.some_method();

Texts in red are optional (implicit), in blue are mandatory

21

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Static variables and methods of classes

Static member variables are ones that are unique for all objects of
same classes (even when no object exists)
Static methods are ones that make access only to static member
variables

class C {
public:
static int count;
C()
{ count++; }
~C()
{ count--; }
static int getCount()
{ return count;
}
...
};
int C::count = 0;

C c1, c2, c3[10],

*c4 = new C(),
*c5 = new C[20];
delete c4;
cout <<
<<
// cout
// cout
// cout

"Number of C objects: "

C::getCount() << endl;
<< C::count << endl;
<< c1.count << endl;
<< c2.getCount() << endl;

Its possible to access static members via class name and scope
operator ::, or via objects as normal members of that class
this pointer is not defined in static methods
22

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Constant methods

In a method declared as constant, all member variables are constant.

Consequences:

Impossible to assign or change member variables in constant methods

Impossible to call non-constant methods from constant ones

Within a constant method, only constant member methods of that object are
accessible

One would rather declare all methods that does not change member variables as
constant
Circle c1;
class Circle {
const Circle c2(2.333);
...
void setR(double r) { this->r = r; }
double getR() const { return r; }
c1.setR(1.22); // OK
double area() const { return PI*r*r; }
c2.setR(1.22); // error
void cf(double r) const {
c1.area();
// OK
area();
// OK
c2.area();
// OK
setR(r);
// error
this->r = r; // error
cout << c1.getR() // OK
}
};
<< c2.getR(); // OK
23

EE3490E: Programming T1 2015/2016

Dr. o Trung Kin Hanoi Univ. of Science and Technology

Problems
1.
2.
3.
4.
5.

6.

24

Write a class (String) to encapsulate string-of-characters type

char* with its typical methods
Write a class (File) to encapsulate FILE* type with its typical
methods
Write a class (LList) to manipulate linked lists on the basis of the
library written in C
Write a class (Fraction) to manipulate fractions with its typical
methods
Complete two class Circle and Ellipse with learnt notions in this
lesson: private variable, constructor, copy constructor, cast
constructor, destructor, static variable to count number of
instances, friend class, const method,
Write two class Complex and Vector with necessary methods to
work with complex numbers and 3D vectors
EE3490E: Programming T1 2015/2016
Dr. o Trung Kin Hanoi Univ. of Science and Technology