EE3491/EE3490E –
Kỹ thuật lập trình /
Programming Techniques
Chapter 6: Class and
Objects – Part 1
Lecturer: Dr. Hoang Duc Chinh (Hoàng Đức Chính)
Department of Industrial Automation
School of Electrical Engineering
Email: chinh.hoangduc@hust.edu.vn © HĐC 2022.1
Content
6.1. Definitions
6.2. From structure to classs
6.3. Member variables
6.4. Member functions
6.5. Access control
Chapter 6: Class and Objects © DIA 2022.1 2
6.1. Definitions - What is an object?
It is a software entity
Model/representative of a physical object:
Tank, heater, furnace
Motor, Pump, Valve
Sensor, Thermometer, Flowmeter
Control Loop, Control System
Or a logical/conceptual object:
Trend, Report, Button, Window
Matrix, Vector, Polynomial
Chapter 6: Class and Objects © DIA 2022.1 3
An object should have…
Attributes
State
Data
Relationship
Behaviour
Operation
Response
Identity
Semantic/responsibility
Chapter 6: Class and Objects © DIA 2022.1 4
Class
Class is the implementation of objects which have the same:
Semantic
Attributes
Relationship
Behaviour
Class = encapsulation [Data structure + functions]
Class of vectors, matrice (element data + accessing methods + basic
arithmetic operators)
Class of rectangles (coordinate data + draw, erase, …)
Class of transfer functions (coefficients of numerator/denominator
polynomials, stability verification, pole identification, …)
Data of a class member variables
Functions of a class member functions
Class variable an object, an instance
Chapter 6: Class and Objects © DIA 2022.1 5
Object-oriented programming (OOP)
Abstraction: simplify a problem, easy to reuse
Data encapsulation/ information hiding: improve
reusability and reliability of the software
Subtyping/inheritance: make the code and its design
easy to reuse
Polymorphism: reflect the real world accurately and
enhance the software flexibility
OOP methodology enables highly abstract thinking but close to
the real world!
Chapter 6: Class and Objects © DIA 2022.1 6
6.2 From Structure to Class
struct Time { void addSec(Time& t, int s) {
int hour; // gio t.sec+= s;
int min; // phut if (t.sec> 59) {
intsec; // giay addMin(t, t.sec/60);
}; t.sec%= 60;
}
void addHour(Time& t, int h) { else if (t.sec< 0) {
t.hour+= h; addMin(t, t.sec/60 -1);
} t.sec= (t.sec% 60) + 60;
}
void addMin(Time& t, int m) { }
t.min+= m; void main() {
if (t.min> 59) { Time t = {1, 0, 0};
t.hour+= t.min/60; addMin(t,60);
t.min%= 60; addMin(t,-5);
} addSec(t,25);
else if (t.min< 0) { ...
t.hour+= (t.min/60 -1); }
t.min= (t.min% 60) + 60;
}
}
Chapter 6: Class and Objects © DIA 2022.1 7
Issues of Structure
Direct access to the data without strictly control would results in unsafe
operation
Time t1 = {1, 61, -3};// ??!
Time t2;// Uncertain values
int h = t2.hour;// ??!
int m = 50;
t2.min = m + 15;// ??!
There is no difference between “internal details” and “external interface”, a
trivial modification requires users to change the source code
E.g.: the name of one member variable in Time structure has been changed
struct Time {
int h, m, s;
};
The old code cannot be used:
Time t;
t.hour= 5;
Chapter 6: Class and Objects © DIA 2022.1 8
Encapsulating or “Classifying”
class Time {
int hour; // gio
int min; // phut Member variable
int sec; // giay
public:
Time() {hour=min=sec=0;} Constructor
void setTime(int h, int m, int s) {
hour = h;
min = sec = 0;
addSec(s);
addMin(m); Member functions
}
int getHour() { return hour; }
int getMin() { return min; }
int getSec() { return sec; }
void addHour(int h) {hour += h;}
...
Chapter 6: Class and Objects © DIA 2022.1 9
Encapsulating or “Classifying” cont.
void addMin(int m) { void main() {
min += m; Time t;
if (min > 59) {
t.addHour(1);
hour += min/60;
min %= 60; t.addMin(60);
} t.addMin(-5);
else if (min < 0) { t.addSec(25);
hour += (min/60 -1); t.hour= 1; // error
min = (min % 60) + 60;
t.min= 65; // error
}
} t.sec= -3; // error
t.setTime(1, 65, -3);
void addSec(int s) { int h = t.getHour();
sec += s; int m= t.getMin();
if (sec > 59) {
int s= t.getSec();
addMin(sec/60);
sec %= 60; }
}
else if (sec < 0) {
addMin(sec/60 -1);
sec = (sec % 60) + 60;
}
}
};
Chapter 6: Class and Objects © DIA 2022.1 10
6.3 Member variables
Variable declaration of a class is similar to that in structure
class Time {
public:
int hour, min, sec;
...
};
By default, member variables of the class can be neither accessed externally (private
variables) nor initialized conventionally:
Time t = {1, 0, 0};// error!
t.hour= 2;// error!
It is possible to make a member variable enable to be accessed externally (public
variables), however it is hardly required:
class Point {
public:
int x,y;
};
Chapter 6: Class and Objects © DIA 2022.1 11
Member variables
Private variables should be accessed via member functions
The only way to initialize member variable is to use a constructor:
class Time {
...
public:
Time() {hour=min=sec=0;}
};
Time t;// t.hour= t.min= t.sec= 0;
Some member variables are used to store internal states of the object, they should not
be accessed by external entities, even indirectly via member functions
class PID {
double Kp, Ti, Td;// controller parameters
double I;// internal state
...
};
Chapter 6: Class and Objects © DIA 2022.1 12
6.4 Member functions
Definition of structure & functions Definition of classes
struct Time { class Time {
int hour, min, sec int hour,min,sec;
}; public:
void addHour(Time& t, int h) { void addHour(int h) {
t.hour+= h; hour += h;
} }
... ...
};
Function call with structure variable Call of an object member function
Time t; Time t;
... ...
addHour(t,5); t.addHour(5);
Representation is not the same but it is not the key difference
Chapter 6: Class and Objects © DIA 2022.1 13
Declaration and definition of member
functions
Usually, class and member variables are declared in a header file (*.h). E.g. in
“mytime.h”:
class Time {
int hour,min,sec;
public:
void addHour(inth);
void addMin(intm);
void addSec(ints);
...
};
Functions are often defined in source file (*.cpp):
#include “mytime.h”
...
void Time::addHour(inth) {
hour += h;
}
Chapter 6: Class and Objects © DIA 2022.1 14
Declaration and definition of member
functions
It is possible to define a member function in header file as an inline function (applying for simple one
only), e.g.:
inline void Time::addHour(inth) { hour += h;}
A member function can be defined in class declaration ⇒ it is an inline function by default, e.g.:
class Time {
int hour,min,sec;
public:
void addHour(int h) { hour += h; }
};
When defining a member function, it is possible to use member variables and other member functions
without the class name, e.g.:
void Time::addSec(int s) {
...
addMin(sec/60);
...
}
Chapter 6: Class and Objects © DIA 2022.1 15
Member function
class Time {
int hour,min,sec;
public:Time() { hour=min=sec=0; }
void addHour(int h) {
this->hour += h;// this pointer is the address of the object
} // which calls the member function
...
};
void main() {
Time t1,t2; // automatically call the constructor Time() for t1 and t2
t1.addHour(5); // same as addHour(&t1,5);
t2 = t1; // OK
t2.addHour(5); // same as addHour(&t2,5);
...
}
Chapter 6: Class and Objects © DIA 2022.1 16
6.5 Access control
public: members are public, can be used externally
private: members are private, cannot be used externally even
in derived classes (will be discussed later)
class Time {
private:
int hour,min,sec;
...
};
By default, once class is declared, members are private
protected: members are protected, cannot be accessed
externally but can be used by derived classes (will be discussed
later)
Chapter 6: Class and Objects © DIA 2022.1 17
6.6 Object pointer
#include "mytime.h“
void main() {
Time t;// call constructor Time()
t.addHour(5);
Time *pt = &t;// pt is identical to this pointer
pt->addSec(70);
pt = new Time;// call constructor Time()
pt->addMin(25);
...
delete pt;
pt = new Time[5]; // call constructor 5 times
for (inti=0; i < 5; ++ i)
pt[i].addSec(10);
...
delete [] pt;
}
Chapter 6: Class and Objects © DIA 2022.1 18
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 6: Class and Objects © DIA 2022.1 19
TO BE CONTINUED
Chapter 6: Class and Objects © DIA 2022.1 20
