Scopul lucrării:
· Studierea principiilor de
definire şi utilizare a constructorilor
· Studierea principiilor de
definire şi utilizare a destructorilor
· Studierea tipurilor de
constructori
а) Să se creeze clasa Time
– timp cu cîmpurile: ore (0-23), minute (0-59), secunde (0-59).
Să se definească constructorii, funcţiile membru de
setare a timpului; de returnare a orei,
minutelor şi secundelor; funcţiile de afişare conform şablonului: „ora
17 şi 18 minute şi 4 secunde” şi „5 p.m. 18 minute 4 secunde”.
Funcţiile de
setare a cîmpurilor clasei trebuie să verifice corectitudinea parametrilor
primiţi.
b) Să se creeze clasa Matrix – matrice. Clasa conţine pointer
spre double, numărul de rînduri şi
de coloane şi o variabilă – codul
erorii. Să se definească constructorul fără parametri (constructorul implicit),
constructorul cu un parametru – matrice pătrată şi constructorul cu doi
parametri – matrice dreptunghiulară ş. a. Să se definească funcţiile membru de
acces: returnarea şi setarea valorii elementului (i,j). Să se definească
funcţiile de adunare şi scădere a două matrice; înmulţirea unei matrice cu
alta; înmulţirea unei matrice cu un număr. Să se testeze funcţionarea clasei.
În caz de insuficienţă de memorie, necorespondenţă a dimensiunilor matricelor,
depăşire a limitei memoriei utilizate să se stabilească codul erorii.
Noţiuni de bază
Una din cele mai
răspîndite erori de programare (în orice limbaj) constă în utilizarea
obiectelor fără iniţializare anterioară, aşa precum nu toate limbajele asigură
iniţializare automată. Desigur, poate fi definită funcţia de iniţializare şi de
distrugere a obiectului:
class
Book{
char
*author;
int
year;
int
pages;
public:
void Init(char*, int, int);
void Destroy();
};
void
Book::Init(char* a, int y, int p){
author = new char[strlen(a)+1];
strcpy(author,a);
year=y;
pages=p;
}
void
Book::Destroy(){
delete[] author;
}
În acest exemplu,
însă, nimeni nu garantează că iniţializarea va avea loc, sau că va fi eliberată
memoria alocată. Alt neajuns al exemplului dat constă în pericolul scurgerii de
memorie, deoarece funcţia de iniţializare poate fi apelată de nenumărate ori.
De asemenea se poate bloca sistemul din cauza utilizării eronate a memoriei
dinamice, motivul fiind apelul funcţiei Destroy fără iniţializare.
Definire şi utilizare
Pentru a evita
această eroare, C++ asigură mecanismul de iniţializare automată pentru clasele
definite de utilizator – constructorul clasei. Iar pentru operaţiile de distrugere – destructorul clasei.
Constructorul –
este o funcţie membru specială, de acelaşi nume cu numele clasei, care se
apelează automat la crearea obiectului de tipul clasei. Constructorul nu
returnează nici un rezultat, chiar nici void.
Compilatorul garantează apelarea unică a constructorului pentru un singur
obiect.
Destructorul –
este o funcţie membru specială, care se apelează automat la distrugerea
obiectului. Numele unui destructor este numele clasei precedat de caracterul
„~”.Compilatorul garantează apelarea unică a destructorului pentru un singur
obiect. Un destructor nu are parametri, de aceea nu poate fi supraîncărcat, şi
el este unic pentru o clasă.
Tipurile constructorilor
Există patru
tipuri de constructori: implicit, de copiere, de conversie a tipului şi
general. Această clasificare este bazată pe regulile de definire şi utilizare a
constructorilor.
·
Constructorul implicit – constructor fără parametri, sau
constructor cu toţi parametrii impliciţi.
·
Constructorul de copiere – constructor care are ca parametru
referinţă la obiectul clasei respective. Constructorul de copiere poate avea şi
alţi parametri care însă trebuie să fie impliciţi.
·
Constructorul de
conversie a tipului - constructorul,
care transformă un tip de obiect în altul.
·
Constructorul general – constructorul care nu corespunde
categoriilor enumerate mai sus.
Fie exemplul:
class
Book{
char
*author;
int
year;
int
pages;
public:
Book(); // constructor
implicit
Book(const Book&); // constructor de copiere
Book(const char*); // constructor de conversie a tipului
Book(char*, int, int); // constructor general
...
};
...
void
main(){
Book b(“Stroustrup”,1997,890); // general
Book b1 = b, b11(b); // de copiere
Book b2 = “Stroustrup”, b21(“Bjarne”);
// de schimbare a tipului
Book b3; //
implicit
}
Constructori generaţi de compilator. Interacţiunea lor
cu constructorii definiţi de utilizator
Prezenţa
constructorilor nu este obligatorie. Se pot defini clase şi fără constructori.
În acest caz, compilatorul C++ generează în mod automat un constructor implicit
şi de copiere.
Constructorul
implicit generat nu realizează absolut nimic, iar constructorul de copiere
generat automat implică copierea bit cu bit, ceea ce nu întotdeauna este
satisfăcător. În cazul definirii unui constructor de către utilizator se
generează automat numai constructorul de copiere.
Recomandări
Fiecare clasă
trebuie să conţină constructori. Dacă clasa conţine elemente pointeri trebuie
neapărat să se supraîncarce constructorul de copiere, care se utilizează pentru
crearea copiilor obiectului, la apelul obiectului în funcţie. Motivul
supraîncărcării constructorului de copiere constă în necesitatea utilizării
acţiunilor suplimentare în comparaţie cu algoritmul standard de copiere,
deoarece se poate întîmpla ca două obiecte diferite să refere una şi aceeaşi
memorie, ceea ce poate duce la pierderea informaţiei şi la erori în sistemul de
operare.
Exemplu de
constructori de copiere:
Book::Book(const
Book& b){
author
= new char[strlen(b.author)+1];
strcpy(author,
b.author);
year = b.year;
pages = b.pages;
}
Constructorii
trebuie să utilizeze mecanisme numite iniţializatori (lista de iniţializare).
Această regulă contribuie la evitarea cheltuielilor necesare pentru
iniţializarea cîmpurilor clasei, deoarece la execuţia constructorului cîmpurile
trebuie să fie deja iniţializate, iar la execuţia iniţializatorilor – nu.
Book::Book(const Book& b):
year(b.year),pages(b.pages),
author(new char[strlen(b.author)+1])
{
strcpy(author,
b.author);
}
// apelul funcţiei strcpy a rămas în afara iniţializatorului.
În cazul
utilizării tabloului de obiecte se defineşte în mod obligatoriu un constructor
implicit, care se apelează pentru iniţializarea elementelor tabloului.
Realizarea sarcinii a)
Lapornirea
programului apare mesajul (figura 1) de introducere a orei, minutem si secunde
case se indeplineste in functia setare
Codul functiei setare:
 |
| Figura 1 |
void
Time::setare(){
sus:clrscr();
cout<<"Introdu ora/min/sec"<<endl;
cout<<"Introdu ora: ";
cin>>a.ore;
Beep(800,200);
if ((a.ore>=0) && (a.ore<=23)) {
cout<<"Minute: ";
cin>>a.min;Beep(800,200);
if ((a.min>=0) && (a.min<=59)) {
cout<<"Secunde: ";
cin>>a.sec; Beep(800,200);
if ((a.sec>=0) && (a.sec<=59)) goto stop;
else goto jos;
} else goto jos;
}
else {jos: cout<<"Ati introdus date gresite !";
Sleep(800); goto sus;}
stop: getch();
}
Dupa care revine in meniul principal
main() (figura 2)
 |
| Figura 2 |
Aici este posibila introducerea din nou a orei,minute, secunde dar este posibila modificarea unuia din aceste date, din meniul 3 – Modificare: (figura 3)
Codul functiei modificare:
void Time::modifivare(){
char com;
sus:clrscr();
 |
| Figura 3 |
cout<<"Modificati: "<<endl;
cout<<"1 -
Ora"<<endl;
cout<<"2 - Minute"<<endl;
cout<<"3 - Secunde"<<endl;
cout<<"0 - Inapoi"<<endl;
com=getch();
switch (com) {
case '1':
{cout<<"Ora: ";
cin>>a.ore;
if ((a.ore>=0) &&
(a.ore<=23)){
cout<<endl<<"Succes
!";
Sleep(800); }
else {cout<<"Eroare ati introdus
ora gresita !";
Sleep(800);
goto
sus;}
break;}
case '2':
{cout<<"Minute: ";
cin>>a.min;
if ((a.min>=0) && (a.min<=59))
{cout<<endl<<"Succes
!";
Sleep(800); }
else {cout<<"Eroare ati introdus
minute gresite !";
Sleep(800);
goto sus;}
break;}
case '3':
{cout<<"Secunde: ";
cin>>a.sec;
if ((a.sec>=0) && (a.sec<=59))
{cout<<endl<<"Succes
!";
Sleep(800); }
else {cout<<"Eroare ati introdus
secunde gresite !";
Sleep(800);
goto sus;}
break;}
case '0':
{goto iesire; break;}
default: goto sus;
}
iesire:}
Afisarea orei se efectueaza in doua
moduri AM (from the Latin ante
meridiem, meaning "before midday") si PM (post meridiem,
"after midday") selectarea sabloanelor se face in functia afisare si
ferificarea (AM/PM) se face in functiile sabl1(), si sabl2(), afisarea
sabloanelor se face in functiile colo() si col();
Codul functiei afisare:
 |
| Figura 4 |
void Time::afisare(){
char com;
sus:clrscr();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<"Alege sablonul:
"<<endl;
cout<<"1 - Sablonu 1
\"ora 17 18 minute si 4 secunde\""<<endl;
cout<<"2 - Sablonu 2
\" 5 p.m 18 minute 4 secunde
\""<<endl;
cout<<"Backspace -
Inapoi"<<endl;
com=getch();
switch (com) {
case
'1' : {a.sabl1(); break;};
case
'2' : {a.sabl2(); break;};
case
8 : goto jos;
default: goto sus;
}
jos:}
Selectind sablonul 1 ora,min,sec se
va afisa in formatul AM (figura 5):
Codul functiei sabl():
 |
| Figura 5 |
void Time::sabl1(){
int k=0;
clrscr();
cout<<"Sablonul
1"<<endl;
for (i = 0; i < 12; i++) {
if (pm[i]==a.ore){
a.col();
k++; }}
if (k==0) a.colo();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
2);
cout<<"Tastati tasta Enter
pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
getch();
a.afisare();
}
Codul functiei colo();
void Time::colo(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"ora ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.ore;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<" si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<" minute ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
secunde"<<endl;}
Selectind sablonul 2 ora,min,sec se
va afisa in formatul PM (figura 6):
Codul functiei sab2():
 |
| Figura 6 |
void Time::sabl2(){
int k=0;
clrscr();
cout<<"Sablonul
2"<<endl;
for (i = 0; i < 12; i++) {
if (am[i]==a.ore){
a.col(); k++;}}
if (k==0) colo();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
2);
cout<<"Tastati
tasta Enter pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
getch();
a.afisare(); }
Codul functiei col();
void Time::col(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"ora ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<am[i];
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<" si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<" minute
";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
secunde"<<endl;}
Realizarea sarcinii b)
Executia programului se incepe cu pornirea meniului main() ca tot timpul, in urma executiei acestei functii apare un menu figura1. In meniul de baza main() se gasesc urmatoarele functii: inmultirea a doua matrici matematic
pentru a inmulti doua matrici
este nevoie de a satisface o conditie, anume trebuie numarul de
coloane primei matrici1 trebuie sa
fie egal cu numarul de linii a matrici2, aceasta
conditie se efectuiaza in programul dat.
Inmultirea a doua matrici:
 |
| Figura 1 |
Codul
functiei:
void inmultirea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu dimensiunea
matriciei I:"<<endl;
cout<<"Linii= ";
cin>>l1;
cout<<"Coloane= "; cin>>c1;
cout<<"Introdu dinemsiunea
matrici II:"<<endl;
 |
| Figura 2 |
cout<<"Linii= "; cin>>l2;
cout<<"Coloane= ";
cin>>c2;
if (c1!=l2) { // nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua inmultirea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix mat1(l1,c1);
matrix mat2(l2,c2);
cout<<"Introdu elementele
I matrici: "<<endl;
for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//mat1.afisare();
//*******************
cout<<"Introdu elementele
II matrici: "<<endl;
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea I
"<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
// se efectueaza *
 |
| Figura3 |
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c2; j++) {
for (int k = 0; k < l1; k++)
s+=mat1.valoare(i,k)*mat2.valoare(k,j);
matf.inscriere(i,j,s);
s=0; }
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch(); }
Inmultirea matrici cu un numar
(meniul 2)
Codul functiei:
void inmultirea_numar(){
int l,c,s,nr;
clrscr();
cout<<"Introdu dimensiunea
matrici: "<<endl;
cout<<"Linii= ";
cin>>l;
cout<<"Coloane= ";
cin>>c;
matrix matr_nr(l,c);
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++) {
cout<<"M["<<i<<"]["<<j<<"]=
";
cin>>s;
matr_nr.inscriere(i,j,s);
}
cout<<endl<<"Matricia dreptunghiulara: "<<endl;
matr_nr.afisare();
cout<<"Inmulteste cu
numarul: ";
cin>>nr;
matrix matr_rsp(l,c);
for (int i = 0; i < l; i++) {
for (int j = 0; j < c; j++) {
matr_rsp.inscriere(i,j,matr_nr.valoare(i,j)*nr);
}
}
cout<<endl<<"Raspuns:"<<endl;
matr_rsp.afisare();
getch(); }
Adunarea si scadera a doua
matrici se efectuiaza element cu element
Codul functiei:
void adunarea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu dimensiunea
matriciei I:"<<endl;
cout<<"Linii= ";
cin>>l1;
cout<<"Coloane= ";
cin>>c1;
cout<<"Introdu dinemsiunea
matrici II:"<<endl;
cout<<"Linii= "; cin>>l2;
cout<<"Coloane= ";
cin>>c2;
if ((l1!=l2)&&(c1!=c2)){ // nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua adunarea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
 |
| Figura 4 |
matrix mat1(l1,c1);
matrix mat2(l2,c2);
cout<<"Introdu elementele
I matrici: "<<endl;
for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//mat1.afisare();
//*******************
cout<<"Introdu elementele
II matrici: "<<endl;
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea I
"<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
// se efectueaza *
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c1; j++) {
s=mat1.valoare(i,j)+mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0; }
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
Scaderea a doua matrici:
Codul functiei:
void scaderea_2matrici(){
int l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu dimensiunea
matriciei I:"<<endl;
cout<<"Linii= ";
cin>>l1;
cout<<"Coloane= ";
cin>>c1;
cout<<"Introdu dinemsiunea
matrici II:"<<endl;
cout<<"Linii= "; cin>>l2;
cout<<"Coloane= ";
cin>>c2;
if ((l1!=l2)&&(c1!=c2)){ // nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua inmultirea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
 |
| Figura 5 |
Beep(600,900);
goto sus;
}
else {
matrix mat1(l1,c1);
matrix mat2(l2,c2);
cout<<"Introdu elementele
I matrici: "<<endl;
for (int i = 0; i < l1; i++) {
for (int j = 0; j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//mat1.afisare();
//*******************
cout<<"Introdu elementele
II matrici: "<<endl;
for (int i = 0; i < l2; i++) {
for (int j = 0; j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea I
"<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
matrix matf(l1,c2);
for (int i = 0; i < l1; i++)
for (int j = 0; j < c1; j++) {
s=mat1.valoare(i,j)-mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
Concluzie:
In urma efectuarii lucrarii date am determinat
ca mediul de prgramare C++
este cu mult flexibil ca C, care ne permite sa
manipulam cu informatia intr-un mod rapid si eficient fara a induce erori
grosolane, si am aflat ca utilizarea claselor este cu mult mai comod si mai
rapid in eleborarea unui program.
Bibliografie
1 TOTUL
DESPRE C SI C++ (MANUALUL FUNDAMENTAL DE PROGRAMARE IN C SI C++)[RO][Kris
Jamsa][Lars Kland]
2 PROGRAMARE IN C_C++
CULEGERE DE PROBLEME Valiriu Iorga
3 Initiere in C++,
Programarea orientata pe obiecte (Editie Prevazuta) Cluj-Napoca 1993
Anexa A
Codul sursa
program numarul 1
#include
<iostream.h>
#include
<conio.h>
#include
<windows.h>
class
Time{
private:
int ore,min,sec;
public:
Time();
//Constructor inplicit
Time(int
o, int m, int s); // cu parametru
Time(const
Time &s); // de copiere
~Time();
//Desctructorul
void
setare();
void
afisare(void);
void
sabl1();
void
sabl2();
void
col();
void
colo();
void modifivare();
};
Time
a;
int
am[]={1,2,3,4,5,6,7,8,9,10,11},i=0;
int
pm[]={13,14,15,16,17,18,19,20,21,22,23};
//Constructor*******************************************************************
inline
Time::Time(){
ore=min=sec=0;
}
//Desctructor*******************************************************************
inline
Time::~Time(){
ore=min=sec=0;
}
//******************************************************************************
void
Time::setare(){
sus:clrscr();
cout<<"Introdu
ora/min/sec"<<endl;
cout<<"Introdu
ora: ";
cin>>a.ore;
Beep(800,200);
if
((a.ore>=0) && (a.ore<=23)) {
cout<<"Minute:
";
cin>>a.min;Beep(800,200);
if
((a.min>=0) && (a.min<=59)) {
cout<<"Secunde:
";
cin>>a.sec;
Beep(800,200);
if
((a.sec>=0) && (a.sec<=59)) goto stop;
else
goto jos;
} else
goto jos;
}
else
{jos: cout<<"Ati introdus date gresite !"; Sleep(800); goto
sus;}
stop: getch();
}
//******************************************************************************
void
Time::afisare(){
char
com;
sus:clrscr();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<"Alege
sablonul: "<<endl;
cout<<"1
- Sablonu 1 \"ora 17 18 minute si 4 secunde\""<<endl;
cout<<"2
- Sablonu 2 \" 5 p.m 18 minute 4 secunde
\""<<endl;
cout<<"Backspace
- Inapoi"<<endl;
com=getch();
switch
(com) {
case '1' : {a.sabl1(); break;};
case '2' : {a.sabl2(); break;};
case 8
: goto jos;
default:
goto sus;
}
jos:}
//******************************************************************************
void
Time::sabl1(){
int
k=0;
clrscr();
cout<<"Sablonul
1"<<endl;
for (i
= 0; i < 12; i++) {
if
(pm[i]==a.ore){
a.col();
k++; }}
if
(k==0) a.colo();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
2);
cout<<"Tastati
tasta Enter pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
getch();
a.afisare();
}
//******************************************************************************
void
Time::col(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"ora
";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<am[i];
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
minute ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
secunde"<<endl;}
//******************************************************************************
void
Time::colo(){
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"ora
";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.ore;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
si ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.min;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
minute ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<a.sec;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"
secunde"<<endl;}
//******************************************************************************
void
Time::sabl2(){
int
k=0;
clrscr();
cout<<"Sablonul
2"<<endl;
for (i
= 0; i < 12; i++) {
if
(am[i]==a.ore){
a.col(); k++;}}
if
(k==0) colo();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
2);
cout<<"Tastati
tasta Enter pentru a alege alt sablon:"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
getch();
a.afisare();
}
//******************************************************************************
void
Time::modifivare(){
char
com;
sus:clrscr();
cout<<"Modificati:
"<<endl;
cout<<"1
- Ora"<<endl;
cout<<"2
- Minute"<<endl;
cout<<"3
- Secunde"<<endl;
cout<<"0
- Inapoi"<<endl;
com=getch();
switch
(com) {
case '1': {cout<<"Ora: ";
cin>>a.ore;
if ((a.ore>=0) &&
(a.ore<=23)){
cout<<endl<<"Succes
!";
Sleep(800); }
else
{cout<<"Eroare ati introdus ora gresita !";
Sleep(800);
goto
sus;}
break;}
case '2': {cout<<"Minute:
";
cin>>a.min;
if ((a.min>=0) && (a.min<=59))
{cout<<endl<<"Succes
!";
Sleep(800); }
else {cout<<"Eroare ati introdus
minute gresite !";
Sleep(800);
goto sus;}
break;}
case '3': {cout<<"Secunde:
";
cin>>a.sec;
if ((a.sec>=0) && (a.sec<=59))
{cout<<endl<<"Succes
!";
Sleep(800); }
else {cout<<"Eroare ati introdus
secunde gresite !";
Sleep(800);
goto sus;}
break;}
case '0': {goto iesire; break;}
default:
goto sus;
}
iesire:}
//******************************************************************************
void
main(void){
a.setare();
char
com;
sus:clrscr();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
cout<<"1
- Introdu ora/min/sec"<<endl;
cout<<"2
- Afisarea "<<endl;
cout<<"3
- Modificare"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
14);
cout<<"Esc
- Iesire"<<endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
11);
com=getch();
Beep(800,100);
switch
(com) {
case '1': {a.setare(); break;}
case '2': {a.afisare(); break;
}
case '3': {a.modifivare(); break;}
case 27:exit(1);
default:
goto sus;
}
goto
sus;
getch();}
Anexa B
Codul sursa program numarul
2:
#include<stdio.h>
#include<conio.h>
#include<iostream.h>
#include
<windows.h>
#include<math.h>
#include<stdlib.h>
class matrix{
private:
double **p;
int rind,col,cod_eror;
public:
matrix();
matrix(int); // matricie patratica
matrix(int,int); //matricie
dreptunghiulara
~matrix();
//*******Inscrierea*************************************************************
void
inscriere(int i, int j, int elem){
p[i][j]=elem;
}
//*******Afisarea**************************************************************
void afisare(){
for (int i = 0;
i < rind; i++) {
cout<<" ";
for (int j = 0;
j < col; j++)
cout<<p[i][j]<<" ";
cout<<endl;
} }
int valoare(int
i, int j){
return p[i][j];
}
};
matrix ::
matrix(){
p=NULL;
rind=col=0;
};
matrix ::
matrix(int n){
rind=col=n;
p=new
double*[rind];
for (int i = 0;
i < rind; i++) {
p[i]=new double[rind];
for (int j = 0; j < rind; j++)
p[i][j]=0;
} }
matrix :: matrix(int
r, int c){
rind=r; col=c;
p=new double
*[rind];
for (int i = 0;
i < rind; i++) {
p[i]= new
double [col];
for (int j = 0; j < col; j++)
p[i][j]=0;
}
}
matrix
::~matrix(){
for (int i=0; i
< rind; i++)
for (int j = 0;
j < col; j++)
delete[] p[j];
delete [] p;
}
//******************************************************************************
void
inmultirea_2matrici(){
int
l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu
dimensiunea matriciei I:"<<endl;
cout<<"Linii=
"; cin>>l1;
cout<<"Coloane=
"; cin>>c1;
cout<<"Introdu
dinemsiunea matrici II:"<<endl;
cout<<"Linii=
"; cin>>l2;
cout<<"Coloane=
"; cin>>c2;
if (c1!=l2)
{ // nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua inmultirea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix
mat1(l1,c1);
matrix
mat2(l2,c2);
cout<<"Introdu
elementele I matrici: "<<endl;
for (int i = 0;
i < l1; i++) {
for (int j = 0;
j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//mat1.afisare();
//*******************
cout<<"Introdu
elementele II matrici: "<<endl;
for (int i = 0;
i < l2; i++) {
for (int j = 0;
j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea
I "<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
// se efectueaza *
matrix
matf(l1,c2);
for (int i = 0;
i < l1; i++)
for (int j = 0;
j < c2; j++) {
for (int k = 0;
k < l1; k++)
s+=mat1.valoare(i,k)*mat2.valoare(k,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
//******************************************************************************
void
inmultirea_numar(){
int l,c,s,nr;
clrscr();
cout<<"Introdu
dimensiunea matrici: "<<endl;
cout<<"Linii=
"; cin>>l;
cout<<"Coloane=
"; cin>>c;
matrix
matr_nr(l,c);
for (int i = 0;
i < l; i++)
for (int j = 0;
j < c; j++) {
cout<<"M["<<i<<"]["<<j<<"]=
";
cin>>s;
matr_nr.inscriere(i,j,s);
}
cout<<endl<<"Matricia
dreptunghiulara: "<<endl;
matr_nr.afisare();
cout<<"Inmulteste
cu numarul: ";
cin>>nr;
matrix
matr_rsp(l,c);
for (int i = 0;
i < l; i++) {
for (int j = 0;
j < c; j++) {
matr_rsp.inscriere(i,j,matr_nr.valoare(i,j)*nr);
}
}
cout<<endl<<"Raspuns:"<<endl;
matr_rsp.afisare();
getch(); }
//******************************************************************************
void
adunarea_2matrici(){
int
l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu
dimensiunea matriciei I:"<<endl;
cout<<"Linii=
"; cin>>l1;
cout<<"Coloane=
"; cin>>c1;
cout<<"Introdu
dinemsiunea matrici II:"<<endl;
cout<<"Linii=
"; cin>>l2;
cout<<"Coloane=
"; cin>>c2;
if
((l1!=l2)&&(c1!=c2)){ //
nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua adunarea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix
mat1(l1,c1);
matrix
mat2(l2,c2);
cout<<"Introdu
elementele I matrici: "<<endl;
for (int i = 0;
i < l1; i++) {
for (int j = 0;
j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//*******************
cout<<"Introdu
elementele II matrici: "<<endl;
for (int i = 0;
i < l2; i++) {
for (int j = 0;
j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea
I "<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
// se efectueaza +
matrix
matf(l1,c2);
for (int i = 0;
i < l1; i++)
for (int j = 0;
j < c1; j++) {
s=mat1.valoare(i,j)+mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
//******************************************************************************
void
scaderea_2matrici(){
int
l1,c1,l2,c2,s;
sus:clrscr();
cout<<"Introdu
dimensiunea matriciei I:"<<endl;
cout<<"Linii=
"; cin>>l1;
cout<<"Coloane=
"; cin>>c1;
cout<<"Introdu
dinemsiunea matrici II:"<<endl;
cout<<"Linii=
"; cin>>l2;
cout<<"Coloane=
"; cin>>c2;
if
((l1!=l2)&&(c1!=c2)){ //
nu se poate de efectuat *
cout<<endl<<"Nu se poate
efectua inmultirea matricilor !"<<endl<<"Introdu alte
dimesiuni";
Sleep(800);
Beep(600,900);
goto sus;
}
else {
matrix
mat1(l1,c1);
matrix
mat2(l2,c2);
cout<<"Introdu
elementele I matrici: "<<endl;
for (int i = 0;
i < l1; i++) {
for (int j = 0;
j < c1; j++) {
cout<<"M1["<<i<<"]["<<j<<"]=
";
cin>>s;
mat1.inscriere(i,j,s);
} }
//*******************
cout<<"Introdu
elementele II matrici: "<<endl;
for (int i = 0;
i < l2; i++) {
for (int j = 0;
j < c2; j++) {
cout<<"M2["<<i<<"]["<<j<<"]=
";
cin>>s;
mat2.inscriere(i,j,s);
} }
clrscr();
cout<<"Matricea
I "<<endl; mat1.afisare();
cout<<endl<<endl<<"Matricea
II"<<endl; mat2.afisare();
// se efectueaza -
matrix
matf(l1,c2);
for (int i = 0;
i < l1; i++)
for (int j = 0;
j < c1; j++) {
s=mat1.valoare(i,j)-mat2.valoare(i,j);
matf.inscriere(i,j,s);
s=0;
}
cout<<endl<<"Iata
matricea rezultanta "<<endl;
matf.afisare();
}
getch();
}
void
main(void){
char com;
sus:clrscr();
cout<<"1
- Inmultirea a 2 matrici"<<endl;
cout<<"2
- Inmultirea unei matrice cu un numar"<<endl;
cout<<"3
- Adunarea a 2 matrici"<<endl;
cout<<"4
- Scaderea a 2 matrici"<<endl;
cout<<"Esc
- Iesire"<<endl;
com=getch();
switch (com) {
case '1':{inmultirea_2matrici(); break;}
case '2':{inmultirea_numar(); break;}
case '3':{adunarea_2matrici(); break;}
case '4':{scaderea_2matrici(); break;}
case 27:{exit(1); break;}
}
goto sus;
getch();}
