EE3491/EE3490E –
Kỹ thuật lập trình /
Programming Techniques
Chapter 7: Class and
Objects – Part 2
Lecturer: Dr. Hoang Duc Chinh (Hoàng Đức Chính)
Department of Industrial Automation
School of Electrical Engineering
Email:
[email protected] © HĐC 2022.1
Content
7.1. Create and destroy an object
7.2. Constructor and destructor
7.3. Operator overloading
7.4. Friend declaration
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 2
7.1. Create and destroy an object
How many ways to create/destroy an object?
Automatically create and destroy: define a variable belonging to a class
Memory space of the object (consisting of member variables) is allocated as
normal variables
Memory space of the object is freed once it exists the scope of definition
class X {
int a, b;
...
};
void f( X x1) {
if (..) {
The object is created in stack
X x2;
... The memory allocated to x2 is freed here
}
} The memory allocated to x1 is freed here
X x; The object is created in data segment
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 3
7.1. Create and destroy an object
Create/destroy an object automatically by using new and
delete
X* pX = 0;
void f(...) {
if (..) {
pX = new X; The object is created in free-store
...
}
}
void g(...) {
...
if (pX != 0) {
Memory space of the object
delete pX;
... in heap is freed
}
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 4
Problem 1: Object initialization
Once it is created, the status of the object includes inner data and
relationships is undefined it is unsafe, less reliable and
inconvenient to use
X x; // x.a= ?, x.b= ?
X *px= new X; // px->a = ?, px->b = ?;
class Vector { int n; double *data; ... };
Vector v; // v.n= ?, v.data= ?
How to initialize an object with its status as desired right after it
is created?
X x = {1, 2};// Error! cannot access private members
How to create an object which is a copy of another object with
different type?
class Y { intc, d; };
Y y = x; // Error, X and Y are not the same type,
// they are not compatible
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 5
Problem 2: Resource management
How to perform dynamic memory allocation and deallocation safely?
class Vector {
intnelem;
double *data;
public:
void create(int n) { data = new double[nelem=n];}
void destroy() { delete[] data; nlem= 0; }
void putElem(inti, double d) { data[i] = d; }
};
Vector v1, v2;
v1.create(5);
// forget to call create for v2
v2.putElem(1,2.5);// BIG problem!
// forget to call destroy for v1, also a BIG problem
Similar issues when working with files, communication ports and other
resources in the computer
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 6
Common solution: Constructor and
destructor
A constructor is always called whenever an object is created, so
is the destructor when the object is destroyed
class X { int a, b;
public:
X() { a = b = 0; } // constructor (1)
X(int s, int t) { a = s; b = t;} // constructor (2)
~X() {} // destructor
};
Call constructor (1) without arguments
void f(X x1) {
(the default constructor)
if (..) {
X x2(1,2); Call constructor (2)
Call
X x3(x2);
destructor
...
of x1 Call copy constructor
} Call destructor
} of x2, x3
X *px1 = new X(1,2), *px2 = new X;
delete px1; delete px2;
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 7
7.2. Writing constructor and
destructor
Constructor is used to initialize and allocate memory resource
Destructor is used to free allocated memory resource
A class can have a few constructors (different in number of arguments or data
type of the arguments)
By default, compiler generates a non-argument constructor and a copy
constructor
Usually, implementation code of the default constructor generated by the compiler is
empty
Usually, implementation code of the default copy constructor generated by the compiler
copies the object data bit by bit
When developing a class, it is possible to rewrite the default constructor, copy constructor
and other constructors as desired
Each class has only one destructor, if the destructor is not defined, the
compiler will generate one
Usually, implementation code of the default constructor generated by the compiler is
empty
If required, it is possible to rewrite the destructor implementation as desired
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 8
Example: improved Time class
class Time {
int hour, min, sec;
public:
Time() : hour(0), min(0), sec(0) {}
Time(int h, int m=0, int s=0) { setTime(h,m,s); }
Time(const Time& t):
hour(t.hour),min(t.min),sec(t.sec) {}
...
};
void main() {
Time t1; // 0, 0, 0 It is unnecessary to define
Time t2(1,1,1); // 1, 1, 1 the copy constructor and
Time t3(1,1); // 1, 1, 0
the destructor for this class!
Time t4(1); // 1, 0, 0
Time t5(t1); // 0, 0, 0
Time t6=t2; // 1, 1, 1
Time* pt1= new Time(1,1); // 1, 1, 0
...
delete pt1;
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 9
Example: improved Vector class
User requirements:
Simple declaration as basic data types
Safe to use, users do not have to call functions to allocate and deallocate
memory
Example of usages:
Vector v1; // v1 has 0 elements
Vector v2(5,0); // v2 has 5 elements init. with 0
Vector v3=v2; // v3 is a copy of v2
Vector v4(v3); // the same as above
Vector f(Vectorb) {
double a[] = {1, 2, 3, 4};
Vector v(4, a);
...
return v;
}
// Do not care about memory management
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 10
Version 1
class Vector {
int nelem;
double* data;
public:
Vector() : nelem(0), data(0) {}
Vector(int n, double d =0.0); const member functions
Vector(int n, double *array); disable the permission for
Vector(const Vector&); changing member variables
~Vector();
int size() const { return nelem; }
double getElem(int i) const { return data[i];}
void putElem(int i, double d) { data[i] = d; }
private:
void create(int n) { data = new double[nelem=n]; }
void destroy(){ if (data != 0) delete [] data; }
};
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 11
Constructor and destructor
Constructor is used to initialize and allocate memory
resource
Destructor is used to free allocated memory resource
Vector::Vector(int n, double d) {
create(n);
while (n--> 0)
data[n] = d;
}
Vector::Vector(int n, double* p) {
create(n);
while (n--> 0)
data[n] = p[n];
}
Vector::~Vector() {
destroy();
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 12
Special case: copy constructor
copy constructor is called when copying an object
Declaring x2-x4 as below:
X x1;
X x2(x1);
X x3 = x1;
X x4 = X(x1);
When passing argument with a value to a function or when a
function return an object
void f(X x) { ... }
X g(..) {
X x1;
f(x1);
...
return x1;
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 13
Syntax of the copy constructor
class X {
int a, b;
public: (1) Pass argument with
value and copy
X() : a(0), b(0) {}
X(X x); // (1) (2) As (1)
X(const X x); // (2)
? (3) Not copy the argument,
X(X& x); // (3)
however x can be changed
X(const X& x); // (4)
unintendedly inside the
... function
};
void main() { (4) Not copy the argument,
safe for the origin
X x1;
correct syntax!
X x2(x1);
...
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 14
When to define the copy constructor?
When the default copy constructor cannot satisfy the requirements
E.g.: if the copy constructor is not defined, code generated by the
compiler automatically is as below:
Vector::Vector(const Vector& b)
: nelem(b.nelem), data(b.data) {}
Problem: simply copy pointers, two objects use the same memory
space allocated for their elements
a.nelem:5 b.nelem:5
Vector a(5);Vector b(a);
a.data b.data
0 0 0 0 0
In this case
Vector::Vector(constVector& a) {
create(a.nelem);
for (inti=0; i < nelem; ++i)
data[i] = a.data[i];
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 15
Attentions
A few constructors but only one destructor destructor must be
consistent with all the constructors
E.g. in Vector class, there is a constructor allocating memory, but not the
default constructor destructor needs to deal with all the cases
When the constructor allocates and occupies resources, it is
required to redefine destructor
In a class, there is destructor definition, it is almost certain to
define the copy constructor if it is allowed
Object copy can be prohibited by defining the copy constructor
in private, e.g.:
class Y { int a, b; Y(const&);
... };
void main() { Y y1;
Y y2=y1;// error!
... }
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 16
7.3. Operator overloading
One of the most well-known technique in C++
It enables to apply arithmetic operators for complex numbers or
vector such as +, -, *, / in the same way as for real numbers. E.g.:
class Complex {
double re, im;
public:
Complex(double r = 0, double i =0): re(r), im(i) {}
...
};
Complex z1(1,1), z2(2,2);
Complex z = z1 + z2;// ???
What’s the basic? The last line can be written as:
Complex z = z1.operator+(z2); Operator function can be
or implemented as a member function
Complex z = operator+(z1,z2); or a non-member function
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 17
Example: arithmetic operators for
complex number
class Complex {
double re, im;
public:
Complex(double r = 0, double i =0): re(r),im(i) {}
double real() const { return re; }
double imag() const { return im; }
Complex operator+(const Complex& b) const {
Complex z(re+b.re, im+b.im);
return z;
}
Complex operator-(const Complex& b) const {
return Complex(re-b.re, im-b.im);
}
Complex operator*(const Complex&) const;
Complex operator/(const Complex&) const;
Complex& operator +=(const Complex&);
Complex& operator -=(const Complex&);
...
};
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 18
Example: arithmetic operators for
complex number
#include “mycomplex.h”
Complex Complex::operator*(const Complex& b) const {
...// left for exercise!
}
Complex Complex::operator/(const Complex& b) const {
...// left for exercise!}
Complex&Complex::operator+=(const Complex& b) {
re += b.re; im+= b.im;
return *this;
}
Complex& operator -=(const Complex&) { ... }
bool operator==(const Complex& a, const Complex& b) {
return a.real() == b.real() && a.imag() == b.imag();
}
void main() {
Complex a(1,1), b(1,2);
Complex c = a+b;
a = c += b;// a.operator=(c.operator+=(b));
if (c == a) { ... }
} return?
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 19
Which operators can be overloaded?
Most of the operators in C++, e.g.:
Arithmetic operators ++ -- + - * / % += -= ...
Logical operators && || ! & &= | |= ...
Relational operators == != > < >= <=
Bitwise operators << >> >>= <<=
Other operators [] () -> * , ...
Only 4 operators cannot be applied
Scope resolution operator ::
Class member access operator .
Pointer to member of pointer ->*
Conditional operator ?:
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 20
7.4 Friend declaration
Problems: some non-member functions implemented externally, or
member functions of another class cannot access directly to an object’s
member less efficient
Solution: Enable the class to declare a “friend”, it can be a non-member
function, a member function of another class, or even another class
Example:
class Complex { ...
friend bool operator==(const Complex&,const Complex&);
friend class ComplexVector;
friend ComplexVectorMatrix::eigenvalues();
...
}
bool operator==(const Complex& a, const Complex& b) {
return a.re== b.re&& a.im== b.im;
}
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 21
Homework
Based on Vector structure and related functions
implemented in Chapter 4, build Vector class with necessary
member functions
Declare a class in order to store student information, it
should include the following attributes:
Student number (identity): Integer
Full name: String
Year of birth: Integer
Declare and define the class to manage students by member
functions which perform:
Input student full name
Input student number
Input year of birth
Search and display student information with given student number
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 22
END OF CHAPTER 7
Chapter 7: Class and Objects - Part 2 © DIA 2022.1 23
