Introducere în clase și obiecte C ++

Obiecte sunt cea mai mare diferență între C ++ și C. Unul dintre cele mai vechi nume pentru C ++ a fost C cu clase.

O clasă este o definiție a unui obiect. Este un tip la fel int. O clasă seamănă cu a struct cu o singură diferență: toți membrii struct sunt publici în mod implicit. Toți membrii claselor sunt privați.

Amintiți-vă - o clasă este un tip, iar un obiect al acestei clase este doar un variabil.

Înainte de a putea folosi un obiect, acesta trebuie creat. Cea mai simplă definiție a unei clase este:

 numele clasei {

 // membri

 }

Acest exemplu de clasă de mai jos modelează o carte simplă. Utilizarea OOP vă permite să rezumați problema și să vă gândiți la ea și nu doar la variabile arbitrare.

 // exemplu unu

 #include 

 #include 

 carte de clasă

 {

 int PageCount;

 int CurrentPage; 

 public:

 Book (int Numpages); // Constructor

 ~ Book () {}; // Distrugător

 void SetPage (int PageNumber);

 int GetCurrentPage (nul);

 }; 

 Carte:: Carte (NumPages int) {

 PageCount = NumPages;

 }

 void Book:: SetPage (număr de pagini int) {

 CurrentPage = PAGENUMBER;

 }

 Int Book:: GetCurrentPage (nul) {

 returnare CurrentPage;

 }

 int main () {

 Carte ABook (128);

 O carte. SetPage (56);

 std:: cout << "Pagina curentă" << ABook. GetCurrentPage () << std:: endl;

 returnare 0;

 }

Tot codul de la carte de clasă până la Int Book:: GetCurrentPage (nul) { funcția face parte din clasă. principal() funcția este acolo pentru a face din această aplicație rulantă.

În principal() funcție o variabilă ABook de tip Book este creată cu valoarea 128. Imediat ce execuția ajunge în acest punct, obiectul ABook este construit. Pe linia următoare metoda O carte. SetPage () se numește și valoarea 56 atribuită variabilei obiect O carte. Pagina curenta. Apoi cout produce această valoare prin apelarea O carte. GetCurrentPage () metodă.

Când execuția ajunge la returnare 0; obiectul ABook nu mai este necesar de aplicație. Compilatorul generează un apel către distrugător.

Totul între Carte de clasă si } este declarația de clasă. Această clasă are doi membri privați, ambii de tip int. Acestea sunt private, deoarece accesul implicit la membrii clasei este privat.

public: directivă spune compilator că accesele de aici înainte sunt publice. Fără aceasta, tot ar fi privat și ar împiedica accesarea membrilor Abook a celor trei linii din funcția principală (). Încercați să comentați public: aliniați și recompilați pentru a vedea erorile de compilare care urmează.

Această linie de mai jos declară un Constructor. Aceasta este funcția numită atunci când obiectul este creat pentru prima dată.

 Book (int Numpages); // Constructor 

Se numește din linie

 Carte ABook (128); 

Aceasta creează un obiect numit ABook de tip Book și apelează funcția Book () cu funcția parametru 128.

În C ++, constructorul are întotdeauna același nume ca și clasa. Constructorul este numit atunci când obiectul este creat și este locul în care ar trebui să puneți codul dvs. pentru a inițializa obiectul.

În carte Următoarea linie după constructor constructorul. Acesta are același nume ca și constructorul, dar cu un ~ (tilde) în fața lui. În timpul distrugerii unui obiect, distrugătorul este chemat să ordoneze obiectul și să se asigure că sunt eliberate resurse precum memoria și mânerul de fișiere utilizate de obiect.

Tine minte—O clasă xyz are o funcție de constructor xyz () și funcția de distrugere ~ xyz (). Chiar dacă nu declarați, compilatorul le va adăuga în tăcere.

Distrugătorul este apelat întotdeauna atunci când obiectul este încheiat. În acest exemplu, obiectul este distrus implicit atunci când iese din sfera de aplicare. Pentru a vedea acest lucru, modificați declarația de distrugere la aceasta:

 ~ Book () {std:: cout << "Distrugător numit";}; // Distrugător 

Aceasta este o funcție inline cu cod în declarație. Un alt mod de a inline este adăugarea cuvântului inline

 inline ~ Carte (); // Distrugător

și adăugați distrugătorul ca o funcție de acest fel.

 inline Book:: ~ Book (void) { 

 std:: cout << "Distrugător numit";

 }

Funcțiile în linie sunt indicii pentru compilator pentru a genera cod mai eficient. Acestea trebuie utilizate numai pentru funcții mici, dar dacă sunt utilizate în locuri adecvate - cum ar fi în interior bucle- poate face o diferență considerabilă în ceea ce privește performanța.

Cea mai buna practica pentru obiecte este de a face ca toate datele să fie private și să le acceseze prin funcții cunoscute sub numele de funcții de accesor. SetPage () și GetCurrentPage () sunt cele două funcții utilizate pentru a accesa variabila obiect Pagina curenta.

Schimba clasă declarație de structurare și recompilare. Ar trebui să compileze și să funcționeze corect. Acum cele două variabile Numărul de pagini și Pagina curenta sunt accesibile publicului. Adăugați această linie după Book ABook (128) și va compila.

 O carte. PageCount = 9;

Dacă schimbați struct înapoi la clasă și recompila, acea linie nouă nu va mai fi compilată ca Numărul de pagini acum este din nou privat.

După declarația de clasă a cărții, există cele patru definiții ale funcțiilor de membru. Fiecare este definit cu prefixul Book:: pentru a-l identifica ca aparținând acelei clase.:: se numește identificatorul de scop. Identifică funcția ca făcând parte din clasă. Acest lucru este evident în declarația de clasă, dar nu în afara acesteia.

Dacă ați declarat funcția de membru într-o clasă, trebuie să furnizați corpul funcției în acest fel. Dacă doriți ca clasa Book să fie utilizată de alte fișiere, atunci puteți muta declarația de carte într-un separat antet fișier, probabil numit book.h. Orice alt fișier ar putea apoi să îl includă cu

 #includeți "book.h" 

Acest exemplu va demonstra moștenirea. Aceasta este o aplicație de două clase cu o clasă derivată de la alta.

 #include 

 #include 

 clasa Point

 {

 int x, y;

 public:

 Punct (int atx, int aty); // Constructor

 inline virtual ~ Point (); // Distrugător

 virtual void Draw ();

 }; 

 clasă Cerc: public Point {

 raza int;

 public:

 Cerc (int atx, int aty, int the Radius);

 inline virtual ~ Circle ();

 virtual void Draw ();

 };

 Point:: Point (int atx, int aty) {

 x = atx;

 y = aty;

 }

 inline Point:: ~ Point (null) { 

 std:: cout << "Punctul distrugător numit";

 }

 void Point:: Draw (void) {

 std:: cout << "Point:: Draw point at" << x << "" << y << std:: endl;

 }

 Cercul:: Cercul (int atx, int aty, int theRadius): Point (atx, aty) {

 raza = radiu;

 }

 inline Circle:: ~ Circle () {

 std:: cout << "Circul Distructor numit" << std:: endl;

 }

 void Circle:: Draw (void) {

 Punct:: Draw ();

 std:: cout << "cerc:: punct desen" << "Radius" << raza << std:: endl;

 }

 int main () {

 Cerc cerc (10,10,5);

 Un cerc. A desena() ;

 returnare 0;

 }

Exemplul are două clase, Point și Circle, modelând un punct și un cerc. Un punct are coordonate x și y. Clasa Circle este derivată din clasa Point și adaugă o rază. Ambele clase includ a A desena() funcția de membru. Pentru a menține scurt acest exemplu, rezultatul este doar text.

Clasa Cerc este derivat din Punct clasă. Acest lucru se face în această linie:

 clasă Cerc: Punct {

Deoarece este derivat dintr-o clasă de bază (punct), Circle moștenește toți membrii clasei.

 Punct (int atx, int aty); // Constructor

 inline virtual ~ Point (); // Distrugător

 virtual void Draw ();

 Cerc (int atx, int aty, int the Radius);

 inline virtual ~ Circle ();

 virtual void Draw ();

Gândiți-vă la clasa Circle ca la clasa Point cu un membru suplimentar (raza). Moștenește funcțiile membrilor clasei de bază și variabilele private X și y.

Nu poate să le atribuie sau să le utilizeze, cu excepția celor implicate, deoarece sunt private, așa că trebuie să o facă prin lista Initializer a constructorului Circle. Acest lucru ar trebui să accepți așa cum este deocamdată. Voi reveni la listele de inițiator într-un viitor tutorial.

În Constructorul Cercului, înainte theRadius este atribuit rază, partea Point of Circle este construită printr-un apel către constructorul Point din lista inițializatorului. Această listă este cuprinsă între: și {de mai jos.

 Circul:: Cerc (int atx, int aty, int the Radius): Point (atx, aty) 

De altfel, inițializarea tipului de constructor poate fi utilizată pentru toate tipurile încorporate.

 int a1 (10);

 int a2 = 10;

Ambele fac la fel.

Polimorfismul este un termen generic care înseamnă „multe forme”. În C ++, cea mai simplă formă de polimorfism este supraîncărcarea funcțiilor. De exemplu, sunt apelate mai multe funcții SortArray (arraytype) unde sortarray ar putea fi un mulțime de ints sau duble.

Totuși, suntem interesați doar de forma OOP a polimorfismului. Acest lucru se realizează prin realizarea unei funcții (de exemplu, Draw ()) virtual în clasa de bază Punct și apoi trecând-o peste clasa derivată Cerc.

Deși funcția A desena() este virtuală în clasa derivată Cerc, acest lucru nu este de fapt necesar - este doar un reamintire pentru că este virtual. Dacă funcția dintr-o clasă derivată se potrivește cu o funcție virtuală din clasa de bază pe tipuri de nume și parametri, aceasta este automat virtuală.

Desenarea unui punct și desenarea unui cerc sunt două operațiuni foarte diferite, având doar coordonatele punctului și ale cercului în comun, deci este important ca corect A desena() se numește. Modul în care compilatorul reușește să genereze cod care obține funcția virtuală corectă va fi acoperit într-un viitor tutorial.

Un constructor este o funcție care inițializează membrii unui obiect. Un constructor nu știe decât să construiască un obiect din propria sa clasă.

Constructorii nu sunt moșteniți automat între baza și clasele derivate. Dacă nu furnizați una din clasa derivată, va fi furnizată o valoare implicită, dar acest lucru nu poate face ceea ce doriți.

Dacă nu este furnizat niciun constructor, atunci compilatorul creează unul implicit fără niciun parametru. Întotdeauna trebuie să existe un constructor, chiar dacă acesta este implicit și gol. Dacă furnizați un constructor cu parametri, atunci o valoare implicită NU va fi creată.

Câteva puncte despre constructori:

• Constructorii sunt doar funcții cu același nume ca și clasa.
• Constructorii au intenția de a inițializa membrii clasei atunci când este creată o instanță a clasei respective.
• Constructorii nu sunt numiți direct (cu excepția listelor de inițiator)
• Constructorii nu sunt niciodată virtuali.
• Se pot defini mai mulți constructori pentru aceeași clasă. Trebuie să aibă parametri diferiți pentru a-i distinge.

Există multe mai multe pentru a afla despre constructori, de exemplu, constructori impliciti, alocări și constructori de copiere. Acestea vor fi discutate în lecția următoare.

Un distrugător este o funcție de membru al clasei care are același nume ca și constructorul (și clasa), dar cu un ~ (tilde) în față.

 ~ Cerc ();

Când un obiect iese din raza de acțiune sau mai rar este explicit distrus, se numește distrugătorul său. De exemplu, dacă obiectul are variabile dinamice, cum ar fi indicatoarele, atunci acestea trebuie eliberate și distrugătorul este locul potrivit.

Spre deosebire de constructori, distrugătorii pot și trebuie făcuți virtual dacă aveți clase derivate. În Punct și Cerc exemplu de clase, distrugătorul nu este necesar, deoarece nu există nicio lucrare de curățare (doar servește ca exemplu). Au existat variabile dinamice ale membrilor (cum ar fi indicii) atunci acestea ar fi necesitat eliberarea pentru a preveni scurgerile de memorie.

De asemenea, atunci când clasa derivată adaugă membri care necesită redactare, sunt necesare distrugătoare virtuale. Când este virtual, cel mai derivat distrugător de clasă este denumit mai întâi, apoi este numit destructorul strămoșului său imediat și așa mai departe până la clasa de bază.

În exemplul nostru,

 ~ Cerc ();

apoi

 ~ Punct ();

Clasele de bază distrugător este numit ultimul.

Acest lucru completează această lecție. În lecția următoare, aflați despre constructori impliciti, constructori de copiere și atribuire.