Ministerul Educaţiei, Culturii, Inovației și Cercetării al

Republicii Moldova
Universitatea Tehnică a Moldovei
Catedra Informatica şi Ingineria Sistemelor

Raport
Lucrarea de laborator nr.3
La Programarea Orientată pe Obiecte

Tema: ,,Supaîncărcarea operatorilor”

Varianta 10

A efectuat: st. gr. IA-162

Matei Cristian

A verificat: lector.univ.
Mariana Osovschi

Chişinău 2017
 Lucrarea de laborator nr. 3
Tema: Supraîncarcarea operatorilor

Scopul lucrării: familiarizarea studenţilor cu noţiunile operatori supraîncărcaţi.

Sarcina:
Varianta 10:
Scrieţi un program care efectuează următoarele operaţii asupra unităţilor de timp
(de exemplu, ceasul, minuta, secunda):
– adunarea,
– înmulţirea cu un coeficient,
– scăderea,
– împărţirea la un coeficient,
valoarea numerică a unităţilor de timp să se tipărească cu cuvinte.

Listingul programului :
#include <iostream>
#include <string>
#include <time.h>

using namespace std;

class Time
{
int ore, min, sec;

void Convert()
{
ore = (ore >= 0) ? ore : 0;
min = (min >= 0) ? min : 0;
sec = (sec >= 0) ? sec : 0;

if (sec > 59)

{
min += sec / 60;
sec %= 60;
}

if (min > 59)

{
ore += min / 60;
min %= 60;
}
}

int GetAllInSec()
{
return (ore * 3600 + min * 60 + sec);
}

public:
Time() {
ore = min = sec = 0;
}
Time(int ore, int min, int sec)
{
this->ore = ore;
this->min = min;
this->sec = sec;

Convert();
}

void Init();

void Edit(int, int, int);

Time operator + (Time &t)

{
ore += t.ore;
min += t.min;
sec += t.sec;

Convert();
return *this;
}

Time operator - (Time &T)

{
int T_sec = T.GetAllInSec();
sec = GetAllInSec();
ore = min = 0;

if (T_sec < sec) sec -= T_sec;

else sec = 0;

Convert();
return *this;
}

Time operator * (int coef)

{
ore *= coef;
min *= coef;
sec *= coef;

Convert();
return *this;
}

Time operator / (int coef)

{
sec = GetAllInSec();
ore = min = 0;

sec /= coef;

Convert();
return *this;
}
 void Display()
{
string single_unit[3] = { "ora", "minuta", "secunda" };
string multi_units[3] = { "ore", "minute", "secunde" };
string numerotation[20] = { "", "una", "doua", "trei", "patru", "cinci", "sase",
"sapte", "opt", "noua", "zece", "unsprezece", "doisprezece", "treisprezece",
"paisprezece", "cincisprezece", "saisprezece", "nouasprezece", "optsprezece",
"nouasprezece" };
string out_ore = "", out_min = "", out_sec = "";

// Secundele
if (sec > 1)
{
if (sec >= 20)
{
out_sec += numerotation[sec / 10] + "zeci";
if (sec % 10 != 0)
out_sec += " si " + numerotation[sec % 10] + " " +
multi_units[2];
else out_sec += " " + multi_units[2];
}
else out_sec += numerotation[sec] + " " + multi_units[2];
}
else if (sec == 1) out_sec += "o " + single_unit[2];
else if (sec == 0) out_sec += "zero " + multi_units[2];

// Minutele
if (min > 1)
{
if (min >= 20)
{
out_min += numerotation[min / 10] + "zeci";
if (min % 10 != 0)
out_min += " si " + numerotation[min % 10] + " " +
multi_units[1];
else out_min += " " + multi_units[1];
}
else out_min += numerotation[min] + " " + multi_units[1];
}
else if (min == 1) out_min += "o " + single_unit[1];
else if (min == 0) out_min += "zero " + multi_units[1];

// Orele
if (ore > 1)
{
// De ordinul #-##
if (ore < 20) out_ore += numerotation[ore] + " " + multi_units[0];
else if (ore >= 20 && ore < 100)
{
out_ore += numerotation[ore / 10] + "zeci " + multi_units[0];
if (ore % 10 != 0)
out_ore += " si " + numerotation[ore % 10] + " " +
multi_units[0];
}
// De ordinul ###
else if (ore >= 100 && ore < 1000)
 {
// De ordinul 100-199
if (ore >= 100 && ore < 200) out_ore += "o suta";
else out_ore += numerotation[ore / 100] + " sute";

int temp = ore % 100;

if (temp >= 20)

{
out_ore += " " + numerotation[temp/10] + "zeci";
if (temp % 10 != 0)
out_ore += " si " + numerotation[temp % 10] + " "
+ multi_units[0];
}
else if (temp && temp < 20)
out_ore += " " + numerotation[temp] + " " + multi_units[0];
else out_ore += " " + multi_units[0];
}
else out_ore = to_string(ore ) + " ore";
}
else if (ore == 1) out_ore += "o " + single_unit[0];
else if (ore == 0) out_ore += "zero " + multi_units[0];

out_ore[0] = toupper(out_ore[0]);
out_min[0] = toupper(out_min[0]);
out_sec[0] = toupper(out_sec[0]);

cout << out_ore << endl << out_min << endl << out_sec << endl;
}

};

void Time::Init()
{
cout << "Ore = "; cin >> ore;
cout << "Minute = "; cin >> min;
cout << "Secunde = "; cin >> sec;

Convert();
}

void Time::Edit(int ore, int min, int sec)

{
this->ore = ore;
this->min = min;
this->sec = sec;

Convert();
}

void main()
{
Time ob1, ob2(2, 30, 140), ob3(0,-2,45);
Time ob5(1, 0, 0);
Time ob4(101, 30,5);
ob4 + ob5;
ob4.Display();
 system("PAUSE");
}
Rezultatul programului:

Concluzie: În lucrarea de laborator nr.3 ne-am familiarizat cu noțiunile de

operatori supraîncărcați. Am supraîncărcat operatorul binar () pentru căutarea
unui substring într-un string și pentru inversarea unui string, / pentru
extragerea unui substring dintr-un string și == pentru compararea a două
string-uri.
Am creat o clasă Time, în care am supraîncărcat operatorii
“+,-,*,/”, necesari pentru a opera cu unitățile de timp: adunarea lor, scăderea,
înmulțirea cu un coeficient, împărțirea la un coeficient. Pentru a ușura
calculele, am descris o metodă de convertire a orelor și minutelor în secunde,
însă pentru a reprezenta corect unitățile de timp, am descris o metodă de
convertire a secundelor, rămase în plus, în minute; a minutelor, rămase în plus,
în ore.