POO-Laborator 1 1. Pointeri 2. Transmiterea pointerilor prin valoare, adresa, referinta 3.Alocare/dezalocare memorie pentru matrice
//pentru ca folosim cin si cout pt citire/scriere avem nevoie de biblioteca iostream #include
using namespace std;
//transmiterea parametrilor prin valoare (raman neschimbate), in subprogram se lucreaza pe niste copii ale variabilelor void transmitere_valoare(int x, int y) { x = x + y; } void transmitere_referinta(int &x, int y) { x = x + y; } void transmitere_adresa(int *z, int w) { (*z) = (*z) + w; } void main() { int x = 9; int y = -5; int w = 2; int z = 3; //definim un pointer la intreg int *px; //atribuim pointerului adresa la care se afla valoarea lui x px = &x; //afisam adresa la care se afla valoarea lui x cout << "Adresa la care se afla valoarea lui x este: " << px<
for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) //adica ne aflam pe diagonala principala a matricei a[i][j] = 1; else a[i][j] = 0; } } cout << endl<<"Matricea unitate este"<
//definim o clasa Statie_metrou class Statie_metrou { char denumire[30]; char peron[20]; public: int legatura; //definim o functie inline public: void init(char* d = "O statie", char* p = "stanga", int l = 0) { strcpy(denumire, d); strcpy(peron, p); legatura = l;
} void anunta_statia(); }; void Statie_metrou::anunta_statia() { if (legatura > 0) cout << "Urmeaza statia " << denumire << " cu peronul pe partea " << peron << " corespondenta cu magistrala M" << legatura; else cout << "Urmeaza statia " << denumire << " cu peronul pe partea " << peron; } void main() { //obiectul este o variabila de tipul clasei Student S; //obiect de tip Student S.init(); cout << endl<returneaza_nume()<' cout << ps->nume<
Daca functiile nu se declara direct in clasa, atunci in clasa se scrie prototipul, si se definesc in afara clasei folosind sintaxa: tip { .... }
nume_c::nume_m(lista_p_f)
numele metodei sau a functiei membre numele clasei
tipul functiei membre
lista_p_f =lista parametrilor formali _______________________________________________________________________________ //folosim biblioteca iostream.h atunci cand folosim cin pt citire si cout pt scriere #include #include #include //definim clasa persoana using namespace std; class persoana { //poate fi accesat de functiile care apartin clasei persoana private: int varsta; //similar cu private, doar ca da drepturi de acces functiilor membre ale claselor derivate din ea protected: float salariu; //pot fi apelate de oricare alte functii din cadrul programului public: char nume[20]; //functie inline(in interiorul clasei) void init(char *n = "Anonim", int v = 0, float s = 0) { strcpy(nume, n); varsta = v; salariu = s;
};
} //doar prototipul functiei spune_nume, aceasta urmand sa fie definita in afara clasei char *spune_nume(); //functie inline int spune_varsta() { return varsta; }
//definim functia spune_nume, deoarece in clasa ea contine doar prototipul char *persoana::spune_nume() { return nume; } void main() { //definim un obiect de tipul clasei persoana persoana p1; //apelam functiile definite in clasa si in afara clasei p1.init(); cout<
_getch(); } _____________________________________________________________________________________
//folosim biblioteca iostream.h atunci cand folosim cin pt citire si cout pt scriere #include #include #include //definim clasa persoana using namespace std; class persoana { int varsta; float salariu; char nume[20]; public:
//constructor implicit persoana() { strcpy(nume, "Anonim"); varsta = 0; salariu = 0; } persoana(char *n, int v, float s) { strcpy(nume, n); varsta = v; salariu = s; } char *spune_nume() { return nume; } int spune_varsta() { return varsta; }
se foloseste doar pt a genera obiecte de tipul clasei
};
void main() { //definim un obiect de tipul clasei persoana persoana p1; cout << "Se apeleaza constructorul implicit" << p1.spune_nume() << " " << p1.spune_varsta()<<"\n"; persoana p2("Gigi", 25, 756); cout << "Se apeleaza constructorul explicit, cu parametri" << p2.spune_nume() << " " << p2.spune_varsta();
}
_getch();
//folosim biblioteca iostream.h atunci cand folosim cin pt citire si cout pt scriere #include #include #include //definim clasa persoana using namespace std; class persoana { int varsta; float salariu; char nume[20]; public:
};
//constructor implicit persoana() { strcpy(nume, "Anonim"); varsta = 0; salariu = 0; } persoana(char *n, int v, float s) { strcpy(nume, n); varsta = v; salariu = s; } char *spune_nume() { return nume; } int spune_varsta() { return varsta; }
void main() { //definim un obiect de tipul clasei persoana si este initializat cu o constanta de tipul persoana persoana p1 = persoana("Vasile Liviu", 30, 8900); cout << p1.spune_nume();
}
_getch();
_____________________________________________________________________________________
//folosim biblioteca iostream.h atunci cand folosim cin pt citire si cout pt scriere #include #include #include //definim clasa persoana using namespace std; class persoana {
public:
};
int varsta; float salariu; char nume[20]; //constructor implicit persoana() { strcpy(nume, "Anonim"); varsta = 0; salariu = 0; } persoana(char *n, int v, float s) { strcpy(nume, n); varsta = v; salariu = s; } char *spune_nume() { return nume; } int spune_varsta() { return varsta; }
void main() { //definim un obiect de tipul clasei persoana si este initializat cu o constanta de tipul persoana persoana p1 = persoana("Vasile Liviu", 30, 8900); cout << p1.spune_nume(); persoana p2 = p1, p3; cout <<"\n"<
}
_getch();
Laborator 3 1. Pointerul this(contine adresa obiectului curent) 2.Functii de acces :Get si set
#include using namespace std; #include #include class student { public: char nume[40]; private: int nr_matricol; protected: float medie; //functie inline, folosita pt initializare public: void init(char* n = "Anonim", int nr=0, float m=0) { strcpy(nume, n); nr_matricol = nr; medie = m; } //prototipul metodei care returneaza numele, urmand sa fie definita in afara clasei char* returneaza_nume(); void afiseaza_adresa(); }; char* student::returneaza_nume() { return this->nume; } void student::afiseaza_adresa()
{ cout<<"Adresa obiectului curent este :"<
#include using namespace std; #include #include class student { public: char nume[40]; private: int nr_matricol; protected: float medie; //functie inline, folosita pt initializare
public: void init(char* n = "Anonim", int nr=0, float m=0) { strcpy(nume, n); nr_matricol = nr; medie = m; } //prototipul metodei care returneaza numele, urmand sa fie definita in afara clasei char* returneaza_nume() { return this->nume; } void modifica_nume(char *n) { strcpy(this->nume, n); } //facem un get pt medie float getMedie() { //daca vrem sa oferim acces controlat la date, folosim o conditie if (this->medie > 5) { return this->medie; } else { return -1; } } //facem un set pt medie void setMedie(float m) { this->medie = m; } void afiseaza_adresa(); };
void student::afiseaza_adresa() { cout<<"Adresa obiectului curent este :"<
inceput de x si 0 //joc X si 0 #include #include #include using namespace std; class Jucatori { public: char Jucator1[40]; char Jucator2[40]; char simbol[1]; void init(char* n1 = "Anonim1", char* n2 = "Anonim2", char* s = "X") { strcpy(Jucator1, n1); strcpy(Jucator2, n2); strcpy(simbol, s); } void setNumeJucator1(char* n1) { strcpy(this->Jucator1,n1); } void setNumeJucator2(char* n2) { strcpy(this->Jucator2, n2); } char* returneaza_primul_jucator() { return this->Jucator1; } char* returneaza_al_doilea_jucator() {
return this->Jucator2; };
}
void main() { Jucatori j; j.setNumeJucator1("Mihai"); j.setNumeJucator2("Simi"); cout << "Jucatorii sunt:" << endl << j.returneaza_primul_jucator() << " " << endl << j.returneaza_al_doilea_jucator() << endl; _getch(); }
Laborator 4 Constructori (fara parametru, cu parametru, hibrizi, constructor de copiere) Destructori Clase cu membri pointeri Supraincarcare=definirea mai multor functii cu aceeasi denumire dar cu nr sau tip de paramtetri diferiti.
#include using namespace std; #include #include class student { public: char nume[40]; private: int nr_matricol; protected: float media; //constructor fara parametru public:
student() { strcpy(nume, "Anonim"); nr_matricol = 0; media = 0; cout << endl<<"S-a apelat constructorul cu parametru" << endl; } //constructor cu parametru
public:
student(char* n, int nr, float m) { strcpy(nume, n); nr_matricol = nr; media = m; cout << endl << "S-a apelat constructorul fara parametru" << endl; } char* getNume() { return this->nume; } void setNume(char* n) { strcpy(nume, n); } }; void main() { //definim un obiect de tip student student s1; cout << "Numele studentului este :" << s1.getNume(); student s2("Vasile Ion", 101, 8); cout << endl << "Numele studentului este :" << s2.getNume(); }
_getch();
#include using namespace std; #include #include class student { public: char nume[40]; private:
int nr_matricol; protected: float media; //in loc sa folosim constructor implicit si constructor cu parametru, ii putem combina pe amandoi intr-unul singur // : ->operator de conlucrare intre constructori //nr_matricol(nr) e echivalent cu nr_matricol=nr public: student(char* n = "Anonim", int nr = 0, float m = 0) :nr_matricol(nr), media(m) { strcpy(nume, n); cout << endl<<"s-a apelat constructorul hibrid"<
};
char* getNume() { return this->nume; } void setNume(char* n) { strcpy(nume, n); }
void main() { //definim un obiect de tip student student s1; cout << "Numele studentului este :" << s1.getNume(); student s2("Vasile Ion", 101, 8); cout << endl << "Numele studentului este :" << s2.getNume(); _getch(); }
#include using namespace std; #include #include class student { public: char nume[40]; private: int nr_matricol; protected: float media; //in loc sa folosim constructor implicit si constructor cu parametru, ii putem combina pe amandoi intr-unul singur // : ->operator de conlucrare intre constructori //nr_matricol(nr) e echivalent cu nr_matricol=nr public: student(char* n = "Anonim", int nr = 0, float m = 0) :nr_matricol(nr), media(m) { strcpy(nume, n); cout << endl<<"s-a apelat constructorul hibrid"<nume; } void setNume(char* n) { strcpy(nume, n); } }; void main() { //definim un obiect de tip student student s1; cout << "Numele studentului este :" << s1.getNume(); //se apeleaza constructorul student s2("Vasile Ion", 101, 8); cout << endl << "Numele studentului este :" << s2.getNume(); //definirea unui obiect caruia i se atribuie o constanta, nu se apeleaza nici un constructor student sconst = student("Ghita Ion", 256, 7.8); cout << endl << "Numele studentului este " << sconst.getNume(); sconst.setNume("Marian"); cout << endl << "Noul nume este :" << sconst.getNume(); _getch(); }
Constructorul de copiere
1.lucreaza cu doua obiecte, unul implicit(pointerul this), altul explicit transmis ca parametru prin referinta. student(&s); apelat la constructii de genul: student s1; student s2(s1);
IMPORTANT!!! Intr-o clasa cu membri pointeri trebuie sa fie definiti: 1. 2. 3. 4.
constructorul destructorul constructorul de copiere operatorul =
Diferenta intre constructorul de copiere si operatorul =
constructorul de copiere copiaza informatii intr-un spatiu de memorie nealocat operatorul = copiaza informatii intr-un spatiu de memorie deja alocat
ex: student s1; student s2(s1);
se apeleaza constructorul de copiere student s3; s3=s1;
se apeleaza operatorul =
#include using namespace std; #include #include class student { public: char nume[40]; private: int nr_matricol; protected: float media; //in loc sa folosim constructor implicit si constructor cu parametru, ii putem combina pe amandoi intr-unul singur // : ->operator de conlucrare intre constructori //nr_matricol(nr) e echivalent cu nr_matricol=nr public: student(char* n = "Anonim", int nr = 0, float m = 0) :nr_matricol(nr), media(m) { strcpy(nume, n); cout << endl<<"s-a apelat constructorul hibrid"<nume, s.nume); this->nr_matricol = s.nr_matricol; this->media = s.media; cout << "s-a apelat constructorul de copiere"<nume; } void setNume(char* n) { strcpy(nume, n);
} }; void main() { {
}
//variabile locale //definim un obiect de tip student student s1("Vasile Gheorghe", 1234, 5); //copiem in obiectul s2. informatiile din s1 student s2(s1); cout << s2.getNume(); student s3; //operatorul egal e supraincarcat automat s3 = s1; cout << s3.getNume();
_getch(); }
#include using namespace std; #include #include class student { //numele e alocat dinamic public: char *nume; private: int nr_matricol; protected: float media;
//constructor fara parametru public: student() { nume = new char[7]; //al 7 caracter e /0 care inseamna sfarsitul sirului de caracter strcpy(nume, "Anonim"); nr_matricol = 0; media = 0; cout << "s-a apelat constructorul fara parametru"<nume = new char[strlen(n) + 1]; strcpy(nume, n); nr_matricol = nr; media = m; cout << "s-a apelat constructorul cu parametru" << endl; } //constructor de copiere student(const student &s) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->media = s.media; cout << "s-a apelat constructorul de copiere"<nume; cout << endl<<"s-a apelat destructorul"; } char* getNume() { return this->nume; } void setNume(char* n) { strcpy(nume, n); } }; void main() { {
}
student s1; student s2("Vasilica", 523, 8); cout << s1.getNume()<
} _getch();
Laborator 5 1.Pointeri la obiecte 2.Compunerea obiectelor (o clasa poate avea ca membru o alta clasa) 3.Tipuri de membri in clasa 4.Clase si functii prietene- cu ajutorul functiilor prietene se pot accesa membri private sau protected ai unei clase, aceste functii trebuie sa primeasca referinta la un obiect de tipul clasei.
Pointeri la obiecte #include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float media; public:
//constructor fara parametru student() { //alocam memorie pt nume nume = new char[strlen("Anonim") + 1]; strcpy(nume, "Anonim"); nr_matricol = 0;
} public:
media = 0; cout << "s-a apelat constructorul fara parametru" << endl;
//constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(nume, n); nr_matricol = nr; media = m; cout << "s-a apelat constructorul cu parametru" << endl; } //functii de acces pt nume char* getNume() { return this->nume; } void setNume(char* n) { strcpy(this->nume, n); } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; }
}; void main() { {
student s1; cout << "Numele studentului este: " << s1.getNume() << endl; student s2("Gheorghe", 123, 8.5); cout << "Numele studentului este:" << s2.getNume() << endl; //pointer la obiect de tip student student *ps; //ii atribuim adresa la care se afla un obiect deja existent //ps = &s1; //daca vrem sa pointeze catre un obiect nou ps = new student(); ps = new student("Vasile", 563, 9);
} _getch(); }
memory leaks(pierderi de memorie), pt a evita acest lucru, trebuie sa se faca dezalocare
#include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float media; public:
public:
//constructor fara parametru student() { //alocam memorie pt nume nume = new char[strlen("Anonim") + 1]; strcpy(nume, "Anonim"); nr_matricol = 0; media = 0; cout << "s-a apelat constructorul fara parametru" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(nume, n); nr_matricol = nr; media = m; cout << "s-a apelat constructorul cu parametru" << endl;
} //functii de acces pt nume char* getNume() { return this->nume; } void setNume(char* n) { strcpy(this->nume, n); } public:
};
float getMedie() { return this->media; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; }
void main() {
student s1; cout << "Numele studentului este: " << s1.getNume() << endl; student s2("Gheorghe", 123, 8.5); cout << "Numele studentului este:" << s2.getNume() << endl; //pointer la obiect de tip student student *ps; //ii atribuim adresa la care se afla un obiect deja existent //ps = &s1; //daca vrem sa pointeze catre un obiect nou ps = new student(); delete ps; ps = new student("Vasile", 563, 9); delete ps; //masive de obiecte
//vector de studenti student grupa[3]; grupa[0] = student("Nume1", 1, 5); grupa[1] = student("Nume2", 2, 8); grupa[2] = student("Nume3", 3, 10); cout <<"Media primului student din grupa este "<
#include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float media; public:
public:
//constructor fara parametru student() { //alocam memorie pt nume nume = new char[strlen("Anonim") + 1]; strcpy(nume, "Anonim"); nr_matricol = 0; media = 0; cout << "s-a apelat constructorul fara parametru" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(nume, n); nr_matricol = nr; media = m; cout << "s-a apelat constructorul cu parametru" << endl; }
//functii de acces pt nume char* getNume() { return this->nume; } void setNume(char* n) { strcpy(this->nume, n); } public:
};
float getMedie() { return this->media; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; }
void main() {
student s1; cout << "Numele studentului este: " << s1.getNume() << endl; student s2("Gheorghe", 123, 8.5); cout << "Numele studentului este:" << s2.getNume() << endl; //pointer la obiect de tip student student *ps; //ii atribuim adresa la care se afla un obiect deja existent //ps = &s1; //daca vrem sa pointeze catre un obiect nou ps = new student(); delete ps; ps = new student("Vasile", 563, 9); delete ps; //masive de obiecte
//pointer la vector de studenti student *grupa=new student[3]; grupa[0] = student("Nume1", 1, 5); grupa[1] = student("Nume2", 2, 8); grupa[2] = student("Nume3", 3, 10); cout <<"Media primului student din grupa este "<
pointer la vector de studenti, de fiecare daca se apeleaza constructorul cu parametru, iar apoi automat se apeleaza destructorul care va dezaloca de fiecare data memoria alocata pt nume, astfel, pt fiecare element al vectorului avem aceeasi adresa la care se salveaza numele, dar fiind dezalocata in destructor , se va realoca pt urmatorul nume din urmatorul element, nu se va Compunerea obiectelor
//compunerea claselor #include using namespace std; #include #include class student { public: static int nr_studenti; char* nume; static int IsStudentBursier(student& s) { if (s.media > 9) { return 1; } else { return 0; } } private: //const arata faptul ca nr_matricol nu poate fi modificat const int nr_matricol; protected: float media;
public: class Catalog { public: int nr_note; int* note; //constructor fara parametru Catalog() { nr_note = 0; note = NULL; } //constructor cu parametru //fortat de compilator sa nu fie inline, deoarece contine o structura repetitiva Catalog(int *v, int nr) { this->nr_note = nr; this->note = new int[nr]; for (int i = 0; i < nr; i++) { this->note[i] = v[i]; } } //constructor de copiere Catalog(Catalog& c) { this->nr_note = c.nr_note; this->note = new int[c.nr_note]; for (int i = 0; i < c.nr_note; i++) this->note[i] = c.note[i]; } //destructor ~Catalog() { delete[] this->note; cout << "s-a apelat destructorul"; } } situatie_scolara; //situatie_scolara e un membru public in clasa student de tip Catalog public: //constructor fara parametru student() :nr_matricol(0) { //alocam memorie pt nume nume = new char[7]; strcpy(nume, "Anonim"); media = 0; student::nr_studenti++; cout << "s-a apelat constructorul fara parametru" << endl; } public:
//constructor cu parametru student(char* n, int nr, float m):nr_matricol(nr) { this->nume = new char[strlen(n) + 1]; strcpy(nume, n);
media = m; student::nr_studenti++; cout << "s-a apelat constructorul cu parametru" << endl; } //constructor de copiere public:
student(const student &s) :nr_matricol(s.nr_matricol) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->media = s.media; cout << "s-a apelat constructorul de copiere"<nume; } void setNume(char* n) { strcpy(this->nume, n); }
public:
};
float getMedie() { return this->media; } void setMedie(float m) { this->media = m; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; //student::nr_studenti--; cout << "s-a apelat destructorul" << endl; }
int student::nr_studenti = 0; void main() { int v[3] = { 10, 9, 8 }; //accesare membru public al clasei student de tipul Catalog (clasa inclusa in clasa student) student s; s.situatie_scolara = student::Catalog(v, 3); cout <
Functii si clase prietene #include using namespace std; #include #include class angajat; //daca facem get pt clasa angajat, atunci membrii lui vor putea fi accesati de orice clasa //daca vrem ca doar clasa angajat_hr sa poata accesa informatiile, atunci ne folosim de functii prietene (friend) class angajat_hr { public: char functie[20]; //trebuie sa primeasca o referinta de tipul clasei angajat, pt ca ii accesam o data membra char* returneaza_cnp(angajat& a); }; class angajat { public: char nume[40]; void setNume(char* cod) { strcpy(cnp, cod); } private: char cnp[13]; //clasa angajat acorda drepturi clasei angajat_hr pentru a accesa membri friend char* angajat_hr::returneaza_cnp(angajat&); }; char* angajat_hr::returneaza_cnp(angajat& a)
{ }
return a.cnp;
void main() { angajat a; //strcpy(a.cnp, "1234567894568"); a.setNume("123456987"); angajat_hr a_hr; cout<
Tipologia membrilor unei clase Clase cu membri constanti CONST (nu se poate face set pt el) #include using namespace std; #include #include class muncitor { public: //nu poate fi modificat, trebuie initializat in constructor const double tarif; int nr_piese; public:
//constructor hibrid muncitor( int nr=0) :tarif(5.5) { this->nr_piese = nr; }
double getTarif() { return this->tarif; } }; void main() { muncitor m1(9); cout << m1.getTarif();
}
_getch();
Laborator 6 Supraincarcarea operatorului = #include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float medie;
public:
//constructor fara parametru student() { nume = new char[7]; strcpy(nume, "Anonim"); nr_matricol = 0; medie = 0; cout << "s-a apelat constructorul implicit" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); nr_matricol = nr; medie = m; cout << "s-a apelat constructorul cu parametru" << endl; } //constructor de copiere student(const student& s) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat constructorul de copiere" << endl; }
//operator =, asemanator cu constructorul de copiere student& operator=(const student& s) { //sterge membri alocati dinamic //daca am ceva in this, si vrem sa copiem altceva, trebuie dezalocat si alocat din nou if (this->nume != NULL) { delete[] this->nume; } this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat operatorul =" << endl; return *this; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; } char* returneaza_nume()
{ }
};
return this->nume;
void modifica_nume(char* n) { strcpy(this->nume, n); } float getMedie() { if (this->medie > 9) { return this->medie; } else { return 1; } } void setMedie(float m) { this->medie = m; } void afiseaza_adresa();
void student::afiseaza_adresa() { cout << "adresa obiectului curent este " << this << endl; } void main() {
}
student s1; student s2("Mihai", 456, 10); cout << s1.nume<
#include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float medie; public:
//constructor fara parametru student() { nume = new char[7]; strcpy(nume, "Anonim"); nr_matricol = 0; medie = 0; cout << "s-a apelat constructorul implicit" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); nr_matricol = nr; medie = m; cout << "s-a apelat constructorul cu parametru" << endl; }
//constructor de copiere student(const student& s) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat constructorul de copiere" << endl; } //operator =, asemanator cu constructorul de copiere student& operator=(const student& s) { //sterge membri alocati dinamic //daca am ceva in this, si vrem sa copiem altceva, trebuie dezalocat si alocat din nou if (this->nume != NULL) { delete[] this->nume; } this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat operatorul =" << endl; return *this; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; } char* returneaza_nume() { return this->nume; } void modifica_nume(char* n) { strcpy(this->nume, n); } float getMedie() { if (this->medie > 9) { return this->medie; } else { return 1; } } void setMedie(float m) { this->medie = m; } void afiseaza_adresa();
//operator ++ de preincrementare friend const student& operator++(student&); //operator ++ de postincrementare friend const student operator++(student&, int); }; //operator ++ preincrementare const student& operator++(student &s) { s.medie++; cout << "s-a apelat operatorul de preincrementare" << endl; return s; } //operator postincrementare const student operator++(student &s, int i) { //parametrul i nu e folosit la nimic, se foloseste doar pt a nu se face confuzie intre operatorii pre si postincrementare student aux = s; s.medie++; cout << "s-a apelat operatorul de postincrementare" << endl; return aux; } void student::afiseaza_adresa() { cout << "adresa obiectului curent este " << this << endl; } void main() {
student s1; student s2("Mihai", 456, 10); student s4; //apeluri pt operatorii ++ //mai intai se face atribuirea, si apoi se incrementeaza media din s2 //se apeleaza operatorul de postincrementare s4 = s2++; cout << s2.getMedie()<
}
#include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float medie; public:
//constructor fara parametru student() { nume = new char[7]; strcpy(nume, "Anonim"); nr_matricol = 0; medie = 0; cout << "s-a apelat constructorul implicit" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); nr_matricol = nr; medie = m; cout << "s-a apelat constructorul cu parametru" << endl; } //constructor de copiere student(const student& s)
{
}
this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat constructorul de copiere" << endl;
//operator =, asemanator cu constructorul de copiere student& operator=(const student& s) { //sterge membri alocati dinamic //daca am ceva in this, si vrem sa copiem altceva, trebuie dezalocat si alocat din nou if (this->nume != NULL) { delete[] this->nume; } this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat operatorul =" << endl; return *this; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; } char* returneaza_nume() { return this->nume; } void modifica_nume(char* n) { strcpy(this->nume, n); } float getMedie() { if (this->medie > 9) { return this->medie; } else { return 1; } } void setMedie(float m) { this->medie = m; } void afiseaza_adresa(); double operator+(student& s) {
//returneaza suma mediilor a doi studenti return this->medie + s.medie;
} //operator ++ de preincrementare, unar friend const student& operator++(student&); //operator ++ de postincrementare, unar friend const student operator++(student&, int); //operatorul + binar friend double operator+(student&, double); friend double operator+(double, student&); };
//operator ++ preincrementare const student& operator++(student &s) { s.medie++; cout << "s-a apelat operatorul de preincrementare" << endl; return s; } //operator postincrementare const student operator++(student &s, int i) { //parametrul i nu e folosit la nimic, se foloseste doar pt a nu se face confuzie intre operatorii pre si postincrementare student aux = s; s.medie++; cout << "s-a apelat operatorul de postincrementare" << endl; return aux; } void student::afiseaza_adresa() { cout << "adresa obiectului curent este " << this << endl; } //operatorii unari +, verificam si asociativitatea double operator+(double x, student& s) { return x+s.medie; } double operator+(student& s, double x) { return s.medie + x; } void main() { student s1; student s2("Mihai", 456, 10); student s4; //apeluri pt operatorii ++ //mai intai se face atribuirea, si apoi se incrementeaza media din s2 //se apeleaza operatorul de postincrementare s4 = s2++; cout << s2.getMedie()<
cout cout cout cout cout cout _getch();
<< << << << << <<
s2.getMedie() << endl; s4.getMedie() << endl; "Supraincarcarea operatorului +" << endl; s4 + 2 << endl; 2 + s4 << endl; s2 + s4 << endl;
}
Supraincarcarea operatorilor << si >> #include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float medie; //constructor fara parametru public:
student() { nume = new char[7]; strcpy(nume, "Anonim"); nr_matricol = 0; medie = 0;
cout << "s-a apelat constructorul implicit" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); nr_matricol = nr; medie = m; cout << "s-a apelat constructorul cu parametru" << endl; } //constructor de copiere student(const student& s) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat constructorul de copiere" << endl; } //operator =, asemanator cu constructorul de copiere student& operator=(const student& s) { //sterge membri alocati dinamic //daca am ceva in this, si vrem sa copiem altceva, trebuie dezalocat si alocat din nou if (this->nume != NULL) { delete[] this->nume; } this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat operatorul =" << endl; return *this; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; } char* returneaza_nume() { return this->nume; } void modifica_nume(char* n) { if (this->nume) { delete[] this->nume;
} this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n);
} float getMedie() { if (this->medie > 9) { return this->medie; } else { return 1; } } void setMedie(float m) { this->medie = m; } void afiseaza_adresa(); double operator+(student& s) { //returneaza suma mediilor a doi studenti return this->medie + s.medie; } //operator ++ de preincrementare, unar friend const student& operator++(student&); //operator ++ de postincrementare, unar friend const student operator++(student&, int); //operatorul + binar friend double operator+(student&, double); friend double operator+(double, student&); //operatorii << si >> friend istream& operator >> (istream&, student&); friend ostream& operator<<(ostream&, student); };
//operator ++ preincrementare const student& operator++(student &s) { s.medie++; cout << "s-a apelat operatorul de preincrementare" << endl; return s; } //operator postincrementare const student operator++(student &s, int i) { //parametrul i nu e folosit la nimic, se foloseste doar pt a nu se face confuzie intre operatorii pre si postincrementare student aux = s; s.medie++; cout << "s-a apelat operatorul de postincrementare" << endl; return aux; } void student::afiseaza_adresa() { cout << "adresa obiectului curent este " << this << endl;
} //operatorii unari +, verificam si asociativitatea double operator+(double x, student& s) { return x+s.medie; } double operator+(student& s, double x) { return s.medie + x; }
//definire operatori << si >> istream& operator>>(istream& intrare, student &s) { cout << "Nume="; char nume[30]; intrare >> nume; s.modifica_nume(nume); cout << "Medie="; intrare >> s.medie; cout << "Nr matricol="; intrare >> s.nr_matricol; return intrare; } ostream& operator<<(ostream& iesire, student s) { iesire << "Studentul " << s.nume << " are media " << s.medie << " si nr matricol =" << s.nr_matricol<
}
//supraincarcarea operatorilor << si >> student s6; cin >> s6; cout << s6; _getch();
#include using namespace std; #include #include class student { public: char* nume; private: int nr_matricol; protected: float medie; //constructor fara parametru public:
student() { nume = new char[7]; strcpy(nume, "Anonim"); nr_matricol = 0; medie = 0; cout << "s-a apelat constructorul implicit" << endl; } //constructor cu parametru student(char* n, int nr, float m) { this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); nr_matricol = nr; medie = m; cout << "s-a apelat constructorul cu parametru" << endl; }
//constructor de copiere student(const student& s) { this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat constructorul de copiere" << endl; } //operator =, asemanator cu constructorul de copiere student& operator=(const student& s) { //sterge membri alocati dinamic //daca am ceva in this, si vrem sa copiem altceva, trebuie dezalocat si alocat din nou if (this->nume != NULL) { delete[] this->nume; } this->nume = new char[strlen(s.nume) + 1]; strcpy(this->nume, s.nume); this->nr_matricol = s.nr_matricol; this->medie = s.medie; cout << "s-a apelat operatorul =" << endl; return *this; } //destructor ~student() { //dezalocam memoria alocata pt nume delete[] this->nume; cout << "s-a apelat destructorul" << endl; } char* returneaza_nume() { return this->nume; } void modifica_nume(char* n) { if (this->nume) { delete[] this->nume; } this->nume = new char[strlen(n) + 1]; strcpy(this->nume, n); } float getMedie() { if (this->medie > 9) { return this->medie; } else { return 1; }
} void setMedie(float m) { this->medie = m; } void afiseaza_adresa(); //operatorii << si >> friend istream& operator >> (istream&, student&); friend ostream& operator<<(ostream&, student); //operatorul [] char operator[](int i) { if (this->nume != NULL) if (i >= 0 && i < strlen(this->nume)) { return nume[i]; } } };
void student::afiseaza_adresa() { cout << "adresa obiectului curent este " << this << endl; } //definire operatori << si >> istream& operator>>(istream& intrare, student &s) { cout << "Nume="; char nume[30]; intrare >> nume; s.modifica_nume(nume); cout << "Medie="; intrare >> s.medie; cout << "Nr matricol="; intrare >> s.nr_matricol; return intrare; } ostream& operator<<(ostream& iesire, student s) { iesire << "Studentul " << s.nume << " are media " << s.medie << " si nr matricol =" << s.nr_matricol<
//supraincarcarea operatorilor << si >> student s6; cin >> s6; cout << s6; //supraincarcarea operatorului []
}
cout << s6[2]; _getch();
Supraincarcarea operatorului binar + de adunare si a operatorului +=
ATENTIE Operatorul+ se foloseste doar pt EVALUARE, operatorul += se foloseste pt MODIFICARE. #include #include #include #include using namespace std; class persoana { private: //definirea operatorilor ca si functii friend friend double operator+(persoana&,double); friend double operator+(double, persoana&); public: char nume[20]; double salariu;
//constructor hibrid public:
persoana(char *n = "Anonim", double sal=0) :salariu(sal) { strcpy(nume, n); cout << "s-a apelat constructorul hibrid" << endl; } double operator+(persoana&); double operator+=(double);
}; //definirea corpului operatorilor double operator+(persoana& p, double spor) { cout << "s-a apelat operatorul+ pt un obiect referit si o valoare de tip double care sa se adune la salariu" << endl; return p.salariu + spor; } double operator+(double spor, persoana& p) { cout << "s-a apelat operatorul+ pt un obiect referit si o valoare de tip double care sa se adune la salariu" << endl; return spor + p.salariu; } double persoana::operator+(persoana& p) { cout << "s-a apelat operatorul+ care face suma salariilor dintre doua obiecte"; return this->salariu + p.salariu; } double persoana::operator+=(double spor) { cout << "s-a apelat operatorul care afiseaza salariul obiectului referit marit cu valoarea sporului" << endl; return salariu += spor; } void main() { double spor = 1; persoana p1("Popa Ion", 85000), p2 = persoana("Popa Elena", 87000); persoana p3("Sandu Marcela", 75000); //nu se modifica salariul, doar se face adunarea intre salariu si spor cout << "\nDupa spor " << p3.nume << " ar avea " << p3 + spor<
se returneaza un double, iar apoi se face suma dintre un double si un obiect
Supraincarcarea operatorilor << si >> #include #include #include #include #include #include using namespace std; class persoana { public: char nume[30]; int varsta; //folosim friend pt ca folosim clasele ostream si istream pt operatorul de intrare/iesire //citeste de la tastatura friend ostream& operator<<(ostream&, persoana); //scrie pe ecran friend istream& operator>>(istream&, persoana&); //scrie pe ecran din fisier friend ifstream& operator>>(ifstream&, persoana&); }; ostream& operator<<(ostream& iesire, persoana p) { iesire << p.nume << " " << p.varsta << endl; return iesire; } istream& operator>>(istream& intrare, persoana &p) { cout << "Nume="; intrare >> p.nume; cout << "Varsta="; intrare >> p.varsta; return intrare; }
ifstream& operator>>(ifstream& intrare, persoana &p) { intrare >> p.nume >> p.varsta; return intrare; } void main() { persoana p1; cin >> p1; //incarcare obiect cout << p1;//afisare obiect //scriere obiect in fisier pe disc { ofstream fisout("fis.dat"); if (!fisout) { cout << "\nEroare de alocare fisier"; exit(1); } fisout << p1; fisout.close(); } { //citire obiect din fisier pe disc si afisare pe ecran ifstream fisin("fis.dat"); if (!fisin) { cout << "\nFisier negasit"; exit(1); } fisin >> p1; cout << "\nS-a citit din fisier "; cout << p1; fisin.close(); _getch(); }
}
Supraincarcarea operatorului [] 1.Pentru verificarea indicelui (transmis ca parametru) intr-un domeniu
#include using namespace std; #include #include class vector { double *pe; int dim; static double err; public: vector(int n = 1) { //trebuie sa cunoastem dimensiunea vectorului pt a aloca memorie exact pt cat are nevoie dim = n; //alocam memorie vectorului de double in functie de dimensiunea lui pe = new double[n]; } //destructor ~vector() { cout << "s-a apelat destructorul " << endl; //dezalocam memoria pt vectorul de double delete[] pe; } //operatorul[] double& operator[](int i) { if (i > 0 && i < dim) return pe[i]; else { cout << "Eroare indice " << i<
2.Pentru a scurtcircuita un nivel de adresare
v[2]=10 operatorul[] e membru in clasa, deci poate accesa membri ai clasei (privati) acest operator permite sa adresam un element, chiar daca nu stim cum se numeste membrul clasei.
3. Pentru a ascunde prelucrari complexe
Supraincarcarea operatorilor new si delete #include using namespace std;
#include #include class persoana { private: int marca; char nume[20]; public: //constructor hibrid persoana(char* n = "Anonim", int m=0) { cout << "\nHey rup"<
}; char* persoana::spune_nume() { return nume; } void main() { persoana *pp; pp = new persoana[3]; cout << (pp + 2)->spune_nume(); delete pp; _getch(); }
Laborator 7 Derivare(mostenire) (relatia este IS A) RELATIE DE SPECIALIZARE #include using namespace std; #include #include class Vehicul { public: char* denumire; private: int nr_locuri; protected: float capCilindrica; public:
Vehicul() { denumire = new char[strlen("Necunoscuta") + 1]; strcpy(denumire, "Necunoscuta"); nr_locuri = 0; capCilindrica = 0; } Vehicul(char* d, int nr, float cap) :nr_locuri(nr), capCilindrica(cap) { this->denumire = new char[strlen(d) + 1]; strcpy(this->denumire, d); } Vehicul(const Vehicul& v) { nr_locuri = v.nr_locuri; capCilindrica = v.capCilindrica; denumire = new char[strlen(v.denumire) + 1]; strcpy(denumire, v.denumire); } Vehicul operator=(const Vehicul& v) { nr_locuri = v.nr_locuri; capCilindrica = v.capCilindrica; if (this->denumire) { delete[] this->denumire; } this->denumire = new char[strlen(v.denumire) + 1]; strcpy(denumire, v.denumire); return *this; } friend ostream& operator<<(ostream&, Vehicul&); ~Vehicul() { cout << "s-a apelat destructorul pt vehiculul " << this->denumire<
{ }
};
delete[] denumire;
}
ostream& operator<<(ostream& iesire, Vehicul& v) { iesire <<"Vehiculul cu denumirea "<< v.denumire << " are " << v.nr_locuri << " locuri si o capacitate cilindrica de " << v.capCilindrica << endl; return iesire; } //clasa derivata class Masina :public Vehicul { //nu poate accesa membrul privat nr_locuri din clasa de baza public: char nr_inmatriculare[8]; Masina() { strcpy(nr_inmatriculare, "AAXXAAA"); } Masina(char* d, int n, float c, char* nr) :Vehicul(d, n, c) { strcpy(nr_inmatriculare, nr); } ~Masina() { cout << "s-a apelat destructorul pt masina " << this->denumire << endl; } }; void main() { {
clasa de baza
Vehicul v1; Vehicul v2("Terestru", 1, 1.2); Vehicul v3 = v2; Vehicul v4; v4 = v1; cout << v2; //intai se apeleaza constructorul din clasa de baza, apoi din clasa derivata //apoi se apeleaza mai intai destructorul din clasa derivata, urmat de cel din Masina m; Masina m2("Logan", 5, 1.6, "B100ABC"); //conversia se face implicit //orice masina e un vehicul, invers nu //conversia derivat-baza //se atribuire doar pt elem comune v1 = m2;
} _getch(); }
Laborator 8 1.Mostenire multipla 2.Functii virtuale 3.Functii virtuale pure 4.Clase abstracte #include using namespace std; #include #include class Vehicul { public: char* denumire; private: int nr_locuri; protected: float capacitate_cilindrica; public: Vehicul() { denumire = new char[strlen("Necunoscuta") + 1]; strcpy(denumire, "Necunoscuta"); nr_locuri = 0; capacitate_cilindrica = 0; }
Vehicul(char* d, int nr, float cap) :nr_locuri(nr), capacitate_cilindrica(cap) { this->denumire = new char[strlen(d) + 1]; strcpy(this->denumire, d); } //constructor de copiere Vehicul(const Vehicul& v) { denumire = new char[strlen(v.denumire) + 1]; strcpy(denumire, v.denumire); nr_locuri = v.nr_locuri; capacitate_cilindrica = v.capacitate_cilindrica; } //operator = Vehicul operator=(Vehicul& v) { nr_locuri = v.nr_locuri; capacitate_cilindrica = v.capacitate_cilindrica; if (denumire != NULL) { delete[] denumire; } denumire = new char[strlen(v.denumire) + 1]; strcpy(denumire, v.denumire); return *this; } //destructor ~Vehicul() { cout << "s-a apelat destructorul" << endl; if (denumire) { delete[] denumire; } } //functie virtuala virtual void deplasare() { cout << "Vehiculul se deplaseaza " << endl; } friend ostream& operator<<(ostream&, Vehicul&); }; ostream& operator<<(ostream& iesire, Vehicul& v) { iesire << "Vehiculul cu denumirea " << v.denumire << " are " << v.nr_locuri << " locuri si o capacitate cilindrica de " << v.capacitate_cilindrica << endl; return iesire; } class Impozit { public: //functie virtuala pura virtual float Impozitare() = 0;
}; //clasa derivata class Masina :public Vehicul,private Impozit { //nu poate accesa membrul privat nr_locuri din clasa de baza public: char nr_inmatriculare[8]; Masina() { strcpy(nr_inmatriculare, "AAXXAAA"); } Masina(char* d, int n, float c, char* nr) :Vehicul(d, n, c) { strcpy(nr_inmatriculare, nr); } ~Masina() { cout << "s-a apelat destructorul pt masina " << this->denumire << endl; } //supradefinirea functiei virtuale din clasa de baza void deplasare() { cout << "Masina se deplaseaza pe uscat " << endl; } float Impozitare() { if (this->capacitate_cilindrica < 2) { return 50; } return 100; } }; void main() { Vehicul v2("Terestru", 1, 1.2); Masina m2("Logan", 5, 1.6, "B100ABC"); Vehicul *pv = &v2; Masina *pm = &m2; pv->deplasare(); pm->deplasare(); //pointerul isi da seama ca se salveaza un obiect de tip masina, motiv pt care apeleaza metoda din clasa derivata pv = pm; pv->deplasare(); cout << m2.Impozitare(); _getch(); }
Laborator 9 Lucrul cu obiecte istream Lucrul cu fisiere cin.getline(); pt a citi siruri de caractere cu spatii write()-scrierea unui sir de lungime fixa cout.wrote(nume,strlen(nume)); put() ->scrierea unui singur caracter get() ->citirea unui singur caracter ???????????????? #include //pt a folosi manipulatorii #include #include using namespace std; #include #include class Angajat { char* nume; float salariu; const int tipContract; //1-determinata, 0-nedeterminata int* pontaj; int numarZile; public: Angajat() :tipContract(1) { nume = NULL; salariu = 0;
}
pontaj = NULL; numarZile = 0;
Angajat(char* n, float s, int t): tipContract(t) { if (t == 0 || t == 1) { nume = new char[strlen(n) + 1]; strcpy(nume, n); salariu = s; pontaj = NULL; numarZile = 0; } else { throw new exception("tipul contractului poate fi doar 1 sau 0,adica pe perioada determinata sau pe perioada nedet"); } } //constructor cu toti parametri Angajat(char*n, float s, int t, int* p, int nr) :tipContract(t) { nume = new char[strlen(n) + 1]; strcpy(nume, n); salariu = s; if (nr > 0 && p != NULL) { pontaj = new int[nr]; numarZile = nr; for (int i = 0; i <= nr; i++) { pontaj[i] = p[i]; } } else { }
throw new exception("Pontajul nu poate fi vid ");
}
Angajat(const Angajat& a) :tipContract(a.tipContract) { nume = new char[strlen(a.nume) + 1]; strcpy(nume, a.nume); salariu = a.salariu; if (a.numarZile > 0 && a.pontaj != NULL) { pontaj = new int[a.numarZile]; numarZile = a.numarZile; for (int i = 0; i < numarZile; i++) { pontaj[i] = a.pontaj[i]; } } else { throw new exception("Pontajul nu poate fi vid"); } } ~Angajat()
{ if (nume != NULL) { delete[] nume; } if (pontaj != NULL) { delete[] pontaj; } } Angajat& operator=(const Angajat& a) { if (nume != NULL) { delete[] nume; } nume = new char[strlen(a.nume) + 1]; strcpy(nume, a.nume); salariu = a.salariu; if (a.numarZile > 0 && a.pontaj != NULL) { if (pontaj != NULL) { delete[] pontaj; } pontaj = new int[a.numarZile]; numarZile = a.numarZile; for (int i = 0; i < numarZile; i++) { pontaj[i] = a.pontaj[i]; } } else { throw new exception("Pontajul nu poate fi vid"); } return *this; } int& operator[](int i) { if (i >= 0 && i < numarZile) { return pontaj[i]; } else throw new exception("Index invalid"); } char* getNume() { return nume; } void setNume(char* n) { if (nume != NULL) { delete[] nume; } nume = new char[strlen(n) + 1]; strcpy(nume, n); } float getSalariu()
{ }
return salariu;
void setSalariu(float s) { salariu = s; } int getTipContract() { return tipContract; } //citeste angajati de la tastatura friend istream& operator>>(istream&, Angajat&); //citesc si scriu in fisier friend ifstream& operator>>(ifstream&, Angajat&); friend ofstream& operator<<(ofstream&, Angajat); //lucru cu fisiere binare void scriePontajFisier() { fstream f; f.open("pontaj.dat", ios::out | ios::binary); if (f) { for (int i = 0; i < numarZile; i++) { f.write((char*)&pontaj[i], sizeof(int)); } } f.close(); } //citire din fisier binar static void citirePontajFisier() { fstream f; f.open("pontaj.dat", ios::in | ios::binary); cout << "Pontaj : "; if (f) { int x; while (f.read((char*)&x, sizeof(int))) { cout << x << " "; } } cout << endl; f.close(); } //supraincarcare static void citirePontajFisier(int i) { fstream f; f.open = ("pondaj.dat", ios::in | ios::binary); if (f) { if (i > 0) { int x; f.seekg(i*sizeof(int), ios::beg); f.read((char*)&x, sizeof(int)); cout << "Pontajul pe ziua " << " este " << x; }
} cout << endl; f.close(); } }; istream& operator>>(istream& intrare, Angajat& a) { cout << "Nume="; char n[40]; //getline citeste siruri de caractere cu spatii intrare.getline(n, 40); a.setNume(n); return intrare; } ifstream& operator>>(ifstream& f, Angajat a) { //modalitate de intrare, fara crearea acestuia daca nu exista f.open("nume.txt", ios::in | ios::_Nocreate); if (f) { char n[40]; f .getline(n,40); a.setNume(n); } f.close(); return f; } //afisare fisier text ofstream& operator<<(ofstream& f, Angajat a) { f.open("afisare.txt", ios::out); if (f) { f << "Nume=" << a.getNume() << endl; f << "Salariu:" << setfill('$') << setw(4) << a.getSalariu(); } f.close(); return f; } void main() { Angajat a; cin >> a; Angajat b("Ionescu", 680, 1); int v[5] = { 4, 4, 8, 4, 8 }; Angajat c("Popescu", 800, 2, v, 5); cout.put(c.getNume()[0]); cout << endl << setfill('$') << setw(10) << c.getSalariu() << endl; Angajat d = c; Angajat e; e = c; Angajat g; ifstream f; f >> g; ofstream x; x << c; c.scriePontajFisier();
Angajat::citirePontajFisier(); Angajat::citirePontajFisier(2); _getch(); }
Laborator 10 Functii si clase template
#include using namespace std; #include
template class Vector { T* elemente; int dimensiune; public: Vector(int); ~Vector() { delete[] elemente; } //returnarea elem de la indicele primit ca parametru T& operator[](int i) { if (i >= 0 && i < dimensune) { return elemente[i]; } else { return NULL; } } void afisare(); void sortare(); }; template Vector::Vector(int n): dimensiune(n) { elemente = new T[n]; for (int i = 0; i < dimensiune; i++) { cout << "elementul " << i << " "; cin >> elemente[i]; cout << endl; } }
template void Vector ::afisare() { cout << endl; for (int i = 0; i < dimensiune; i++) { cout << elemente[i] << " "; } } template void Vector::sortare() { int i, j; T aux; for (int i = 0; i < dimensiune - 1;i++) for (int j = i + 1; j < dimensiune; j++) { if (elemente[i]>elemente[j]) { aux = elemente[i]; elemente[i] = elemente[j]; elemente[j] = aux; } } } void main() { Vector vi(4); vi.afisare(); vi.sortare(); vi.afisare(); Vector vf(4); vf.afisare(); vf.sortare(); vf.afisare(); _getch(); }
#include #include using namespace std; class student { public: char nume[40]; int matricol; float medie; int operator>(student s) { //daca cele doua nume sunt scrise alfabetic //strcmp compara doua siruri return strcmp(this->nume, s.nume) > 0 ? 1 : 0; } friend ostream& operator<<(ostream&, student); friend istream& operator>>(istream&, student&); }; ostream& operator<<(ostream& iesire, student s) { iesire << "Nume: " << s.nume; return iesire; } istream& operator>>(istream& intrare, student &s) { cout << "Nume: ";
}
intrare.getline(s.nume,40); return intrare;
template class Vector { T* elemente; int dimensiune; public: Vector(int); ~Vector() { delete[] elemente; } //returnarea elem de la indicele primit ca parametru T& operator[](int i) { if (i >= 0 && i < dimensune) { return elemente[i]; } else { return NULL; } } void afisare(); void sortare(); }; template Vector::Vector(int n) : dimensiune(n) { elemente = new T[n]; for (int i = 0; i < dimensiune; i++) { cout << "elementul " << i << " "; cin >> elemente[i]; cout << endl; } } template void Vector ::afisare() { cout << endl; for (int i = 0; i < dimensiune; i++) { cout << elemente[i] << " "; } } template void Vector::sortare() { int i, j; T aux; for (int i = 0; i < dimensiune - 1; i++) for (int j = i + 1; j < dimensiune; j++)
{ if (elemente[i]>elemente[j]) { aux = elemente[i]; elemente[i] = elemente[j]; elemente[j] = aux; } }
}
void main() { Vector vs(2); vs.afisare(); vs.sortare(); vs.afisare(); _getch(); }
#include using namespace std; #include template class Vector { T elemente[n]; public: int get_dimensiune() { return n;
} }; //compara doi vectori template int masoara(TT1 &v1, TT2 &v2) { int dim1 = v1.get_dimensiune(); int dim2 = v2.get_dimensiune(); if (dim1 == dim2) return 0; if (dim1 < dim2) return -1; else return 1; } void main() { Vector vi; Vector vd; int x = masoara(vi, vd); cout << x; _getch(); }
#include #include #include using namespace std; class Pozitie { public: int ziua; int ora; char explicatie[30]; virtual void display() { cout << "ZZ: " << ziua << " OO: " << ora << " explicatie: " << explicatie; } friend ostream& operator<<(ostream&, Pozitie &); };
virtual bool operator&() =0;
ostream& operator<<(ostream& iesire, Pozitie &poz) { poz.display(); return iesire; } class ApelTelefonic : public Pozitie { public: char tel[12]; virtual void display() { Pozitie::display(); cout << " tel: " << tel; } virtual bool operator&(ApelTelefonic &apel) {
if (strcmp(this->tel, apel.tel) == 0 && (this->ora == apel.ora) && (this->ziua == apel.ziua))
return true; else
};
return false;
} friend ostream& operator<<(ostream&, ApelTelefonic &);
ostream& operator<<(ostream& iesire, ApelTelefonic &apel) { apel.display(); return iesire; } class Sedinta :public Pozitie { public: char* tema; int durata; virtual void display() { Pozitie::display(); cout << " tema: " << tema; } friend ostream& operator<<(ostream&, Sedinta &); virtual bool operator&(Sedinta &sedinta) { if ((this->ora == sedinta.ora) && (this->durata == sedinta.durata)) return true; else return false; } }; ostream& operator<<(ostream& iesire, Sedinta &sedinta) { sedinta.display(); return iesire; } void main() { _getch(); }
#include
