skyler_sdf

:D

salut:D vreau si eu un mic retus nu vreau sa mi mai apara inca o data linia din dreapta, daca de ex: cineva are un monitor cu o rezolutie ceva mai mare. My link ps: stau prost la capitolul html si css /*documents's title*/ h1{ font-size: 18pt; font-family: Comic Sans MS; text-align: center; color: #330000; margin: 0px 0px 0 px 0px; padding: 10px 0px 0px 0px; } /*document's subtitle*/ h2{ font-family: Comic Sans MS; font-size: 14pt; text-align: left; color: #330000; margin: 0px 0px 0px 0px; padding: 0px 0px 0px 0px; } /*text from left list*/ h3 { font-family: Comic Sans MS; font-size: 14pt; text-align: center; color: #330000; border: 3px; border-style: solid; border-width: 2px 0px 2px 0px; padding : 0px; margin-top: 20px; } /*line(s) at the begining of the text and text in left column*/ h4{ font-family: Comic Sans MS; font-style: italic; text-align: left; font-size: 14pt; font-weight: normal; color: #330000; border: 3px; border-style: solid; border-width: 2px 0px 2px 0px; padding: 0px; margin-top: 20px; } /*table style*/ table{ border-collapse: collapse; border-spacing: 0px; padding: 0px; empty-cells: show; } /* document's body*/ body{ background-color:#FEEBAE; } /*links*/ a { color: #1860B3; text-decoration: none; } a:link { color: #0D0DBA; } a:visited { color:#5959F7; } a:hover { color:#FF0000; cursor: hand; } ul { font-size: 14pt; list-style-type: square; } #textcontainer { background-image: url(pictures/paper2.gif); padding: 0pt 15pt 5pt 50pt; width: 100%; vertical-align: top; } #textcontainertop { background-image: url(pictures/images_076.jpeg); } #papercol { background: url(pictures/papercol.gif); width: 145px; height: 450px; height: "531px"; } #home { font-family: Comic Sans MS; text-align: center; font-size: 16pt; color: #330000; border: 4px; border-style: solid; border-width: 2px 0px 2px 0px; padding: 10px; margin-top: 20px; } #leftlist { background: url(pictures/paper1.gif); width: 10%; padding: 5pt; vertical-align: top; }

//if a constructor only has one parameter, there is a third way to pass an initial value to that constructor #include <iostream> using namespace std; class X{ int a; public: X(int j) { a=j;} int get_a() {return a;} }; int main() { X ob=99; //passes 99 to j cout<<ob.get_a(); //outputs 99 system("PAUSE"); return 0; }

Sa se creeze o clasa care retine informatii despre carti #include <iostream> #include <string> #include <cstring> #include <cstdlib> using namespace std; const int IN=1; const int checked_out=0; class book{ char author[40]; char title[40]; int status; public: book(char *n, char *t, int s); int get_status(){return status;} void get_status(int s){status=s;} void show(); }; book::book(char *n, char *t, int s) { strcpy_s(author, n); strcpy_s(title, n); status=s; } void book::show() { cout<<title<<" by "<<author; cout<<" is"; if(status==IN) cout<<"in. \n"; else cout<<"out. \n"; } int main() { book b1("Twain", "Tom Sawyer", IN); book b2("Melville", "Moby Dick", checked_out); b1.show(); b2.show(); system("PAUSE"); return 0; }

tareeee

Clasele friend au acces nu doar la datele si metodele private, ci si la metodele clasei. NU reprezinta un exemplu de mostenire. Metodele din clasa de baza nu devin metode si pentru clasa declarata friend. //using a friend class #include<iostream> using namespace std; class TwoValues{ int a; int b; public: TwoValues(int i, int j){ a=i; b=j;} friend class Min; }; class Min{ public: int min(TwoValues x); }; int Min::min(TwoValues x) { return x.a <x.b ? x.a : x.b; //i.e. if(x.a<x.b) return x.a; else return x.b; } int main() { TwoValues ob(10, 20); Min m; cout<<m.min(ob); system("PAUSE"); return 0; }

il iertam de data asta...nu i merge netul probabil

Este posibil sa declaram o clasa, si mai tarziu sa o detaliem... Acest lucru este posibil atata timp cat nu construim obiecte(s.a.) de tipul clasei careia ii amanam detalierea.. De ex: #include<iostream> using namespace std; const int IDLE=0; const int INSUE=1; //forward declaration class C2; class C1{ int status; //IDLE if off, INSUE if on screen public: void set_status(int state); friend int idle(C1 a, C2 b); }; class C2 { int status; //IDLE if off, INSUE if on screen public: void set_status(int state); friend int idle(C1 a, C2 b); }; void C1::set_status(int state) { status=state; } void C2::set_status(int state) { status=state; } int idle(C1 a, C2 b) { if(a.status || b.status) return 0; else return 1; } int main() { C1 x; C2 y; x.set_status(IDLE); y.set_status(IDLE); if(idle(x, y)) cout<<"Screen can be used."; else cout<<"in use. "; x.set_status(INSUE); if(idle(x, y)) cout<<"screen can be used. "; else cout<<"in use"; system("PAUSE"); return 0; }

#include<iostream> using namespace std; class myclass { int a, b; public: friend int sum(myclass x); void set_ab(int i, int j); }; void myclass:: set_ab(int i, int j) { a=i; b=j; } int sum(myclass x) { //pentru ca sum() este "friend" pentru myclass, poate accesa direct a si b return x.a+x.b; } int main() { myclass n; n.set_ab(4, 2); cout<<sum(n); system("PAUSE"); return 0; }

Datele si metodele declarate public intr o clasa pot fi accesate de oriunde din program. #include<iostream> using namespace std; class my_class { public: int i, j, k; //accesibile ptr tot programul }; int main() { my_class a, b; a.i=100; a.j=4; a.k=a.i*a.j; b.k=12; //ATENTIE, a.k si b.k sunt diferiti cout<<a.k<<" " <<b.k; system("PAUSE"); return 0; }

Putem declara pointeri la clase. Acestia pot accesa date si metode din clasa respectiva. #include<math.h> class complex { public: float x, y; float modul(); }; float complex::modul() { return sqrt(x*x+y*y); } #include<iostream> #include "complex.cpp" using namespace std; int main() { complex *next=new complex; //obs ca este instantiat din clasa de baza next->x=9; next->y=2; cout<<next->modul()<<" "; delete next; system("PAUSE"); return 0; }

#include<math.h> class complex { public: float x, y; float modul(); }; float complex::modul() { return sqrt(x*x+y*y); } #include<iostream> #include "complex.cpp" using namespace std; int main() { complex v[100]; float max; int n, i; cout<<"dati nr de elemente al vectorului: "; cin>>n; for(i=0; i<n; i++) { cout<<"numarul complex:"<<i+1; cout<<"dati partea reala: "; cin>>v[i].x; cout<<"dati partea imaginara: "; cin>>v[i].y; } max=v[0].modul(); for(i=1; i<n; i++) if(v[i].modul()>max) max=v[i].modul(); cout<<"max este egal cu: "<<max; system("PAUSE"); return 0; }

Pentru a crea un program mai bine structurat, este de preferat sa asezam clasele cu metode, etc, intr-un modul(fis.h sau .cpp) dupa care in programul principal doar includem acel modul. Acest mod de lucru usureaza munca. de ex: #include<math.h> class complex { public: float x, y; float modul(); }; float complex::modul() { return sqrt(x*x+y*y); } #include<iostream> #include "complex.cpp" using namespace std; int main() { complex z; z.x=3; z.y=-6; //avem acces la x si y deoarece le am declarat de tip public in clasa complex cout<<z.x<<" "<<z.y<<" "<<z.modul(); system("PAUSE"); return 0; } Modulul cu functia complex il putem utiliza in felul acesta de fiecare data cand avem nevoie, fara a mai scrie inca o data codul necesar. Este de mare ajutor in cazul programelor mai mari, unde avem un cod mult mai bogat.

#include<iostream> #include<string> #include<cstring> #include <cstdlib> using namespace std; class sir { char *q; public: //constructor sir(char s[]) { q=new char[strlen(s)+1]; //aloca spatiu de cat are nevoie strcpy(q, s); //se copie in q sirul sir } //constructor de copiere sir(sir &x) { q=new char[strlen(x.q)+1]; strcpy(q, x.q); } void operator=(sir &x) { delete q; q=new char[strlen(x.q)+1]; strcpy(q, x.q); } void afiseaza() { cout<<q<<" "; } }; int main() { sir a("MEMEMEME"), b("WOWWW"), c=a; a.afiseaza(); b.afiseaza(); c.afiseaza(); a=b; a.afiseaza(); b.afiseaza(); system("PAUSE"); return 0; }

#include<iostream> #include<string> #include <cstring> #include <cstdlib> using namespace std; class persoana { int varsta; public: char *pnume; persoana(char *n,int v):varsta(v) { pnume=new char[strlen("Anonim")+1]; strcpy(pnume, n); } int spune_varsta() { return varsta; } }; int main() { persoana p1("vasilache",45); persoana p2=p1;//apel constructor de copiere cout<<"\n"<<p1.pnume<<"are"<<p1.spune_varsta()<<"ani"; cout<<"\n"<<p2.pnume<<"are"<<p2.spune_varsta()<<"ani"; strcpy(p2.pnume,"Gigi"); cout<<"\n"<<p1.pnume<<"are"<<p1.spune_varsta()<<"ani"; cout<<"\n"<<p2.pnume<<"are"<<p2.spune_varsta()<<"ani" << endl; system("PAUSE"); return 0; }

#include<iostream> using namespace std; class vector { int v[100]; //de tip private public: int &operator[](int i); }; int &vector::operator[](int i) //fara & nu am fi putut face atribuiri: a[o pozitie] ia valoarea x. { return v[i]; //am acces la v pentru ca operator[] este metoda a clasei vector } int main() { vector a; a[1]=5; cout<<a[1]<<" "; a[3]=10; cout<<a[3]<<" "; system("PAUSE"); return 0; }

O metoda friend a clasei poate accesa orice din clasa din care face parte, inclusiv metode/var. de tip private, protected. Functiile friend returneaza un obiect de tipul clasei. Sunt folosite deobicei la supraincarcarea operatorilor "<<" si ">>". #include<iostream> #include<math.h> using namespace std; class complex { float x, y; public: complex(float , float ); friend float modul(complex &z); friend complex operator+(complex &z, float nr); friend complex operator+(float nr, complex &z); }; complex::complex(float a, float b) { x=a; y=b; } //cele de tip friend se "definesc" folosind doar tipul intors si numele float modul(complex &z) { return sqrt(z.x*z.x+z.y*z.y); } complex operator+(complex &z, float nr) { complex h(z.x+nr, z.y); //nr va primi valoarea numarului real dat de noi //si evident se va aduna la partea reala a numarului complex z return h; } complex operator+(float nr, complex &z) { complex h(z.x+nr, z.y); return h; } int main() { complex z(5, 8); z=z+9; //aduna o valoare reala la z z=3+z; //se poate, pentru ca am dorit ca operatia de adunare sa fie comutativa, si am declarat in plus, inca o functie de tip friend cu parametri in ordinea inversa fata de cealalta cout<<"afisez modulul numarului nou: "<<modul(z)<<" "; system("PAUSE"); return 0; }

//supraincarcarea operatorului [] //a[3] se poate scrie ca *(a+3) #include<iostream> using namespace std; class vector { //de tip private int v[20]; public: void initializeaza(int , int ); //obs ca parametri pot lipsi la declarare, insa NU si TIPUL acestora int afiseaza(int ); }; void vector::initializeaza(int i, int a) { v[i]=a; //pune a pe pozitia i din vector } int vector::afiseaza(int i) { return v[i]; } int main() { vector w; w.initializeaza(4, 8); //se pune valoarea 8 pe pozitia 4 cout<<w.afiseaza(4)<<" "; //afiseaza ce este pe pozitia 4 system("PAUSE"); return 0; } //acest operator este binar. a[3] se poate scrie ca *(a+3) //dorim sa retinem un vector, ca tip class. astfel o functie ca putea intoarce un vector, ceea ce constituie un avantaj. //de asemenea, dorim ca data membru sa fir privata si accesul la ea sa aiba loc exclusiv prin intermediul unor metode

#include<iostream> using namespace std; class dnd { public: int a; dnd(int b=0); //constructor }; dnd::dnd(int b) { cout<<"valoarea data este: "<<b; } dnd h; //declaram un obiect de tip dnd int main() { dnd x(6), y=122, z; //pentru z se apeleaza constuctorul implicit, si anume cu valoarea 0 system("PAUSE"); return 0; }

se citesc z1 si z2 numere complexe si un numar natural n, se cere sa se scrie un program care calculeaza (z1/z2)^n. La acest tip de problema vom avea nevoie de supraincarcarea functiilor. Compilatorul de c++ stie sa lucreze cu +, -, / si * pe numere, insa nu si pentru obiecte. De aceea trebuie sa defin noi metodele de +, - si / pentru lucrul cu obiecte de tip complex. O metoda supraincarcata are acelasi nume ca al clasei din care face parte, urmata de "operator +", -, dupa cazuri. Nu se pot folosi mai mult de un parametru pentru aceasta. In cazul in care vrem sa folosim doi, functia va trebui declara de tip friend. Acest tip de metode vor fi detaliate in exemplele urmatoare. #include<iostream> #include<math.h> using namespace std; class complex { public: float x, y; float modul(); //il folosim pentru a returna modulul complex(); // vom initializa pe x si y cu 0 complex(float a, float b); //il folosim pentru a copia a in x si b in y complex operator+(complex k); complex operator-(complex k); complex operator*(complex k); complex operator/(complex k); }; complex::complex() { x=0; y=0; } complex::complex(float a, float b) //constructor de copiere { x=a; y=b; } //pentru adunarea a doua numere complexe folosim formula // ... =x1+x2 +i(y1+y2) complex complex::operator+(complex k) { complex h; //ne folosim de un obiect "auxiliar" h.x=x+k.y; h.y=y+k.y; return h; } //pentru scaderea a doua numere complexe folosim formula // ...=x1-x2+i(y1-y2) complex complex::operator-(complex k) { complex h; h.x=x-k.x; h.y=x-k.y; return h; } //pentru inmultirea a doua numere complexe folosim formula // ...=x1x2-y1y2+i(x1y2+x2y1) complex complex::operator*(complex k) { complex h; h.x=x*k.x; h.y=y*k.y; return h; } //pentru impartire folosim formula: // ...=(x1x2+y1y1+i(x2y1-x1y2))/x2^2+x1^2 complex complex::operator/(complex k) { complex h; float aux=k.x*k.x+k.y*k.y; //retine x^2+y^2 if(aux) { h.x=(x*k.x+y*k.y)/aux; h.y=(k.x*y-x*k.y)/aux; } else cout<<"impartire la 0!!"; return h; } float complex::modul() { return sqrt(x*x+y*y); } int main() { complex z1, z2, z3, z4(1, 0); //pentru z1, z2, z3 se apeleaza constructorul implicit care va initializa pe x si y pentru fiecare obiect cu 0. //in cazul lui z4 se apeleaza cel cu 2 parametri int n,i; cout<<"n="; cin>>n; cout<<"z1="<<endl; cin>>z1.x>>z1.y; //se citesc noi valori pentru x si y, atat in cazul lui z1, cout<<"z2="<<endl; cin>>z2.x>>z2.y; //cat si in cazul lui z2 z3=z1/z2; //z3 are x=0 si y=0, acestia se vor primi noi valori in urma operatiei de "/" for(i=1; i<=n; i++) z4=z4*z3; cout<<z4.x<<" "<<z4.y; system("PAUSE"); return 0; } //obs: functiile obtinute prin supraincarcarea operatorilor au aceeasi prioritate si asociativitate ca operatorii respectivi //functiile obtinute prin supaincarcarea operatorilor au aceeasi n-aritate ca si operatorii respecttivi, astfel: //daca operatorul este unar si functia este unara, deci nu are parametri //daca operatorul este binar si functia este binara, aceasta inseamna ca are un singur parametru

#include<iostream> #include<string> using namespace std; class sir{ char nume[80]; public: void punenume(char *n); void afiseaza(char *n); }; void sir::punenume(char *n) { strcpy_s(nume, n); } void sir::afiseaza(char *n) { cout<< n; } int main() { sir obiect; char nume[80]; obiect.punenume("MARIA oprescu"); //se va apela metoda punenume obiect.afiseaza(nume); //afieaza "MARIA oprescu" system("PAUSE"); return 0; }

Constructorul reprezinta o metoda a clasei, care are acelasi nume ca al clase din care face parte. Constructorul nu returneaza nici o valoare, nici macar void. Nu se pot declara pointeri la constructor. Nu poate fi derivat(i.e. mostenit). Tipuri de constructori: -implicit: compilatorul ne asigura un constructor implicit. Atunci cand declaram un obiect fara lista de parametri(ex: A x; unde A este clasa), sau cand este alocat dinamic, la fel fara lista de argumente(ex: new A, unde A este clasa), atunci constructorul implicit este apelat pentru a initializa obiectul. Cand un vector de obiecte este declarat(de ex: A v[10]) sau cand este alocat dinamic(de ex: new A[10]), atunci constructorul implicit este apelat pentru a initializa toate elementele. Cand constructorul unei clase derivate nu apeleaza explicit constructorul clasei de baza, atunci este apelat constructorul implicit din clasa de baza. -cu mai multi parametri(sau unul singur) -de copiere(defineste actiunile ce urmeaza a fi efectuate de compilator atunci cand se efectueaza o copiere a obiectelor de tipul clasei date. Are un singur parametru formal, care e de tipul clasei(ex: A(A ob) ) -dinamic: atunci cand alocam memorie obiectelor cu new -de conversie: constructorii de conversie inseamna pentru compilator crearea de obiecte din alte obiecte. Acest tip de constructor este diferit de constructorul de copiere pentru ca acesta creaza un obiect din alta clasa, dar constructorul de copiere este din aceeasi clasa. Destructorul reprezinta o metoda a clasei care este apelata la sfarsitul programului cand se distrug toate obiectele. Are acelasi nume ca al clasei din care face parte precedat de un "~" in fata. Nu pot fi declarati pointeri la un destructor, nu poate fi derivat. Este apelat la sfarsitul programului cand obiectele sunt distruse. In cazul alocarii dinamice, acesta va elibera memoria alocata cu new. In cazul pointerilor avem : delete p; in cel al listelor, resp.t vectorilor: delete [] p; Mai jos avem un exemplu de stiva folosind constructor si destructor. #include<iostream> using namespace std; class stiva { int st[80]; int valoare; public: stiva(); //constructor ~stiva(); //destructor void push(int i); int pop(); }; //functia constructor pentru stiva stiva::stiva() { valoare=0; cout<<"stiva a fost initializata!"; } //functia destructor pentru stiva stiva::~stiva() { cout<<"stiva a fost distrusa!"; } void stiva::push(int i) { if(valoare==80) cout<<"stiva plina. nu pot pune mai multe elemente"; else st[valoare]=i; valoare++; } int stiva::pop() { if(valoare==0) cout<<"stiva vida. nu am ce elemente sa scot"; else valoare--; return st[valoare]; } int main() { stiva obiect1, obiect2; //apeleaza constructorul pentru obiectele obiect1 si obiect2 obiect1.push(1); //obs cum este apelata metoda in main obiect1.push(4); obiect1.push(6); obiect1.push(3); obiect2.push(2); obiect2.push(7); obiect2.push(12); cout<<obiect1.pop()<<" "; cout<<obiect1.pop()<<" "; cout<<obiect1.pop()<<" "; cout<<obiect2.pop()<<" "; cout<<obiect2.pop()<<" "; cout<<obiect2.pop()<<" "; system("PAUSE"); return 0; }

Mostenirea reprezinta procesul prin care un obiect poate prelua prototipul altui obiect. Acest lucru este important deoarece se admite conceptul de clasificare. De exemplu daca ne gandim un mar ionatan face parte din clasificarea mar, care la randul ei face parte din clasa fructe, care se afla in marea clasa a hranei. Fara utilizarea claselor, un obiect ar trebui definit explicitandu-se toate caracteristicile sale. Insa, prin folosirea clasificarilor, un obiect are nevoie doar de definirea acelor calitati care il fac unic in clasa sa. #include<iostream> using namespace std; class cladire { //sunt de tip private int camere; int etaje; int suprafata; //sunt de tip public public: void nr_camere(int numar); int cate_camere(); void nr_etaje(int numar); int cate_etaje(); void nr_suprafata(int numar); int cate_suprafata(); }; //casa este derivat din cladire class casa: public cladire { int dormitoare; int bai; public: void nr_dormitoare(int numar); int cate_dormitoare(); void nr_bai(int numar); int cate_bai(); }; //scoala este derivat din cladire class scoala:public cladire { int sali_clasa; int laboratoare; public: void nr_sali_clasa(int numar); int cate_sali_clasa(); void nr_laboratoare(int numar); int cate_laboratoare(); }; void cladire::nr_camere(int numar) { camere=numar; } void cladire::nr_etaje(int numar) { etaje=numar; } void cladire::nr_suprafata(int numar) { suprafata=numar; } int cladire::cate_camere() { return camere; } int cladire::cate_etaje() { return etaje; } int cladire::cate_suprafata() { return suprafata; } void casa::nr_dormitoare(int numar) { dormitoare=numar; } void casa::nr_bai(int numar) { bai=numar; } int casa::cate_dormitoare() { return dormitoare; } int casa::cate_bai() { return bai; } void scoala::nr_sali_clasa(int numar) { sali_clasa=numar; } void scoala::nr_laboratoare(int numar) { laboratoare=numar; } int scoala::cate_sali_clasa() { return sali_clasa; } int scoala::cate_laboratoare() { return laboratoare; } int main() { casa h; //avem un obiect de tip "casa" scoala s; //si unul de tip "scoala" h.nr_camere(12); //setam numarul de camere al casei h.nr_etaje(3); //nr de etaje h.nr_suprafata(4500); //suprafata h.nr_dormitoare(6); //dormitoare h.nr_bai(4); //nr de bai cout<<"casa are "<<h.cate_dormitoare(); cout<<" dormitoare\n"; s.nr_camere(16); s.nr_sali_clasa(80); s.nr_laboratoare(15); s.nr_suprafata(1200); cout<<"scoala are "<<s.cate_sali_clasa(); cout<<" sali de clasa "; cout<<" suprafata este de"<< s.cate_suprafata(); system("PAUSE"); return 0; } Daca nu am fi folosit mostenirea, pentru obiectul de tip scoala de exemplu, ar fi trebuit sa definim din nou metoda nr_camere.

#include<iostream> #include<math.h> using namespace std; class complex { public: //acum metodele si variabilele sunt de tip public, deci pot fi accesate din afara clasei float x, y; float modul(); //metoda modul, care returneaza modulul a doua numere complexe complex(float a, float b); complex(float c=0); }; complex::complex(float a, float b) //constructor de copiere //nu mai avem la dispozitie constructorul implicit //adica daca nu mai putem declara un obiect fara parametri { x=a; y=b; } complex::complex(float c) { x=1; y=c; } float complex::modul() { return sqrt(x*x+y*y); } int main() { complex z1(3, 2), z2(4); //in cazul lui z2 se apeleaza constructorul cu un parametru, cel in care valoarea lui x este by default 1 iar y primeste valoarea 4 cout<<z1.x<<" "<<z1.y<<" "<<z2.x<<" "<<z2.y<<" "; //avem voie deoarece x si y au fost declarati de tip public system("PAUSE"); return 0; }