Meniu

Clase și obiecte în C ++

classes objects c

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

O scurtă introducere a claselor și obiectelor în C ++.

Clasele și obiectele sunt elementele de bază ale programării orientate pe obiecte în C ++. Fiecare entitate, vie sau non-vie poate fi reprezentată ca un obiect și programată corespunzător folosind C ++. Astfel, entități precum o mașină, birou, persoană, pasăre, animal etc. pot fi reprezentate ca obiecte.

Clasa este un nivel mai înalt decât obiectul și reprezintă categoria obiectelor. Astfel, clasa acționează ca un plan care conturează designul și detaliile obiectului. Aceasta include date care sunt utilizate pentru a descrie obiectul și diverse metode sau funcții care pot acționa asupra datelor obiectului.

=> Urmăriți aici seria de antrenament C ++ simplă.

În acest tutorial, discutăm toate detaliile clasei și obiectelor din C ++ împreună cu reprezentarea lor programatică.

Clase și obiecte în C ++

Ce veți învăța:

Clase

O clasă în C ++ poate fi privită ca un plan sau un schelet al unei anumite entități. Clasa este un tip de date definit de utilizator. Conține informații generale sau date pentru acea entitate anume și funcțiile care operează pe acea entitate.

În sintaxa C ++, definim o clasă cu cuvântul cheie „clasă” urmat de numele clasei.

Numele clasei este urmat de detaliile clasei închise între acolade și este terminat de un punct și virgulă.

Următorul bloc arată sintaxa generală pentru definiția clasei.

Sintaxa generală a claselor

Așa cum se arată în reprezentarea de mai sus, clasa poate avea specificatori de acces, cum ar fi public / protejat / privat. Poate avea membri de date și funcții de membru. Datele și funcțiile sunt numite ca membri ai clasei. În mod implicit, membrii sunt privați la clasă, astfel încât nicio entitate externă să nu aibă acces la acești membri.

De exemplu, un vehicul poate fi o clasă generalizată având proprietăți precum un model, culoare, șasiu, viteză medie, etc. Poate avea funcții precum changeModel, accelerare, încetinire etc., care efectuează acțiuni asupra membrilor datelor. Putem defini o clasă numită „vehicul” care va avea toate aceste date și funcții de date.

După cum sa menționat deja, o clasă este doar un plan pentru entități. Nu este nevoie de spațiu în memorie când este definit. Pentru ca o clasă să fie funcțională, trebuie să definim obiecte care să poată folosi membrii clasei.

Obiecte

Pentru a utiliza funcționalitatea clasei, trebuie să instanțiem clasa pentru a crea un obiect. Un obiect este o instanță a unei clase. Cuvinte simple, putem spune că un obiect este o variabilă a clasei de tip.

Sintaxa generală pentru a crea un obiect este:

classname object_name;

Odată ce obiectul este creat, acesta poate fi folosit pentru a accesa membrii de date și funcțiile clasei respective.

Accesarea membrilor clasei (date și funcții) se face folosind operatorul punct (.), Care este, de asemenea, numit operator de acces membru.

Dacă obj este numele obiectului și există o funcție „display ()” în clasă, atunci funcția poate fi accesată ca „obj.display ()”.

Cu toate acestea, există o captură în declarația de mai sus. Putem accesa afișarea funcției () folosind un obiect și operatorul punct dacă funcția este „publică”.

Specificații de acces

În C ++, accesarea membrilor și funcțiilor de date din clasă depinde de accesul acordat acelui membru sau funcție de date folosind un specificator de acces.

C ++ acceptă următorii specificați de acces:

# 1) Privat

Acesta este specificatorul de acces implicit pentru o clasă în C ++. Aceasta înseamnă că, dacă nu este specificat niciun specificator de acces pentru membrii dintr-o clasă, atunci acesta este considerat privat.

Când un membru este privat, acesta nu poate fi accesat în afara clasei. Nici măcar folosind obiectul și operatorul punct. Membrii de date private pot fi accesați numai utilizând funcțiile de membru ale clasei.

cum se deschide fișierul jar executabil

Cu toate acestea, există o excepție de la această regulă, pe care o vom discuta în subiectele noastre ulterioare.

# 2) Public

Un membru sau funcție de date care este definit ca public în clasă este accesibil tuturor celor din afara clasei. Acești membri pot fi accesați utilizând obiectul și operatorul punct.

# 3) Protejat

Un membru protejat al unei clase este accesibil clasei în sine și claselor copil ale clasei respective.

Acest specificator de acces este utilizat în special în caz de moștenire și vom discuta acest lucru în detaliu în timp ce vom discuta subiectul moștenirii.

Să luăm exemplul următor pentru a înțelege mai bine acești specificatori de acces.

#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='<

Ieșire:

var1 = 10
nume = sth

În acest program, avem doi membri de date, dintre care var1 de tip int este privat (specificatorul de acces nu este specificat. Implicit este privat). Un alt membru este numele șirului, care este declarat public. Mai avem încă o afișare a funcției care afișează valoarea ambilor membri.

În funcția principală, declarăm un obiect abc din clasa ABC. Apoi setăm valori la membrii datelor și, de asemenea, afișarea funcției de apel folosind obiectul „abc”.

Cu toate acestea, atunci când compilatorul întâlnește linia abc.var1 = 20; va genera o eroare că „var1 este variabilă privată”.

Acest lucru se datorează faptului că nu putem accesa datele private ale membrilor unei clase din afara clasei. Astfel există o eroare. Dar îl putem accesa în interiorul funcției și, prin urmare, atunci când scoatem valoarea var1 în funcția de afișare; nu aruncă nicio eroare.

Prin urmare, ieșirea programului afișează valoarea inițială cu care este declarat var1.

Până acum, am văzut detaliile despre clase, obiect și specificați de acces, acum să luăm un exemplu complet de student de clasă. Această clasă are membri de date: student_id, student_name și student_age. De asemenea, are funcții de membru pentru a citi informații despre elevi și pentru a afișa informații despre studenți.

Pentru a ușura lucrurile cititorilor, am declarat toți membrii clasei ca publici.

Următorul program arată implementarea completă.

#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<' Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }

Ieșire:

Introduceți codul elevului: 1

Introduceți student_name: abc

Introduceți student_age: 12

ID student: 1
Numele studentului: abc
Vârsta studenților: 12

Astfel, avem o clasă completă definită mai sus. Singura diferență notabilă este că am definit o funcție „print_studentInfo” în cadrul clasei, în timp ce altă funcție „read_studentinfo” este definită în afara clasei. Acestea sunt cele două moduri în care funcțiile membre pot fi definite pentru o clasă.

Rețineți că funcția definită în exterior are încă o declarație / prototip în cadrul clasei. De asemenea, este definit în afara clasei folosind operator de rezoluție a domeniului (: :) . Apoi, în funcția principală, creăm un obiect de clasă student și apoi apelăm funcții pentru a citi și afișa datele.

Constructori

Până în prezent, în acest tutorial, am creat un obiect simplu și apoi atribuim valori fiecărui membru al clasei din funcția principală după ce am citit aceste valori din intrarea standard.

În acest subiect, vom arunca o privire la o funcție specială care este utilizată pentru a inițializa obiectul în timpul creării sale. Această funcție specială se numește constructor.

Un constructor este o funcție membru a clasei, dar diferă de funcția membră normală în următoarele moduri:

  1. Constructorul nu are valoare de returnare, adică constructorul nu returnează niciodată o valoare.
  2. Este o funcție de membru public al clasei.
  3. Este folosit pentru a inițializa membrii de date și a construi obiectul clasei.
  4. Este apelat automat de compilator atunci când obiectul este creat.

Tipuri de constructori

C ++ acceptă următoarele tipuri de constructori.

# 1) Constructor implicit

Un constructor implicit este constructorul de bază și nu are parametri. Putem crea un obiect simplu fără parametri folosind constructorul implicit.

Constructorul implicit are următoarea sintaxă:

classname() { //constructor code }

Dacă o clasă nu are un constructor implicit, atunci compilatorul îl creează.

# 2) Constructor parametrizat

Un constructor parametrizat este unul care are o listă de parametri folosind care putem inițializa membrii clasei. Când declarăm un obiect într-un constructor parametrizat, atunci trebuie să trecem valorile inițiale funcției constructor ca parametri.

O funcție constructor parametrizată arată așa cum se arată mai jos.

classname(argument list){ //constructor code }

Un constructor parametrizat este folosit pentru supraîncărcarea constructorilor. Vom vedea mai multe despre supraîncărcare în subiectele noastre ulterioare.

Un constructor parametrizat este utilizat în scopul inițializării membrilor datelor diferitelor obiecte. Făcând acest lucru, putem transmite diferite valori ale membrilor datelor către diferite obiecte.

# 3) Copiați constructorii

C ++ acceptă un al treilea tip de constructor cunoscut sub numele de constructor Copy. Forma sa generală este

classname (const classname & obj);

Așa cum se arată în declarația de mai sus, în constructorul de copiere se creează un obiect nou folosind valorile unui alt obiect din aceeași clasă. Parametrul care este transmis constructorului este referința constantă a unui obiect ale cărui valori vor fi utilizate pentru construcția noului obiect.

Un constructor de copii este de obicei apelat în următoarele situații:

  1. Când un obiect de clasă este returnat în funcție de valoare.
  2. Când un obiect este transmis unei funcții ca argument și este trecut de valoare.
  3. Când un obiect este construit dintr-un alt obiect din aceeași clasă.
  4. Când un obiect temporar este generat de compilator.

Cu toate acestea, nu putem garanta că constructorul de copii va fi apelat cu siguranță în toate cazurile de mai sus, deoarece compilatorul C ++ are o modalitate de a optimiza operațiile de copiere.

Un constructor de copii efectuează o copiere membrană între obiecte. La fel ca și constructorul implicit, compilatorul C ++ creează un constructor de copiere implicit dacă nu oferim unul în programul nostru. Dar când o clasă are anumiți membri de date, cum ar fi indicii, referințe sau orice alocare a resurselor în timp de execuție, atunci trebuie să avem propriul nostru constructor de copii definit de utilizator.

Motivul este că constructorul implicit de copiere efectuează doar o copie superficială a membrilor datelor, adică ambele obiecte vor partaja aceeași locație de memorie. Acest lucru este în regulă pentru membrii de date simpli care nu sunt indicatori.

Cu toate acestea, atunci când vine vorba de indicatori sau de alți membri dinamici ai datelor, am dori ca datele să fie îndreptate către o nouă locație de memorie. Aceasta este copia profundă și poate fi realizată numai folosind un constructor de copii definit de utilizator.

Dat mai jos un program C ++ complet care implementează toate cele trei tipuri de constructori și utilizarea lor în construirea unui obiect.

#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<' Student ID : '<

Ieșire:

********** s **********
ID student: 1
Numele studentului: abc
Vârsta studentului: 10 ani

********** s2 **********
ID student: 2
Numele studentului: xyz
Vârsta studenților: 12

cel mai bun curățător și optimizator gratuit pentru PC

Captura de ecran pentru același lucru este dată mai jos.

ieșirea constructorilor

În acest program, am definit un elev de clasă similar cu cel definit în programul anterior. Diferența este că, în loc să citim valorile membrilor de date de la intrarea standard printr-o funcție, definim trei constructori.

Este absolut posibil ca o clasă să aibă mai mult de un constructor. Avem un constructor implicit care inițializează membrii de date la valorile inițiale. Apoi, definim un constructor parametrizat care transmite valorile inițiale ca parametri constructorului.

cel mai bun mod de a descărca audio YouTube

Apoi, definim un constructor de copii la care trecem o referință constantă la un obiect al clasei elevilor.

În funcția principală, creăm trei obiecte separat folosind trei constructori. Primul obiect s este creat folosind constructorul implicit. Al doilea obiect s1 este creat folosind constructorul parametrizat în timp ce al treilea obiect s2 este creat folosind un constructor de copiere.

Rețineți crearea celui de-al treilea obiect s2. Aici atribuim obiectul deja creat s1 noului obiect s2. Astfel, atunci când construim un obiect nou folosind obiectul deja existent, un compilator de copiere este apelat de către compilator.

Operator de misiune

De asemenea, putem atribui valorile unui obiect altuia folosind un operator de atribuire (=). În acest caz, vom avea o afirmație ca s1 = s.

Diferența dintre constructorul de copiere și operatorul de alocare este că, în timp ce constructorul de copie construiește cu totul un obiect nou, operatorul de alocare atribuie doar valorile unui membru al obiectului pe RHS la acel obiect al LHS. Aceasta înseamnă că obiectele de pe ambele părți ale unui operator de atribuire trebuie să fie existente înainte de atribuire.

Distrugători

Un destructor este, de asemenea, o funcție specială ca un constructor, dar implementează funcționalitatea care este exact opusă constructorului. În timp ce constructorul este utilizat pentru a crea un obiect, un destructor este folosit pentru a distruge sau șterge un obiect.

Unele dintre caracteristicile distructorului includ:

  • Un nume distructor este același cu numele clasei, dar începe cu un semn tilde (~).
  • Distructorul nu are niciun tip de returnare.
  • Un destructor nu are argumente.
  • Nu poate exista decât un singur destructor într-o clasă.
  • Compilatorul creează întotdeauna un destructor implicit dacă nu reușim să oferim unul pentru o clasă.

Sintaxa generală a unui destructor este:

~classname(){ //cleanup code }

Distructorul unei clase este numit de obicei în următoarele situații:

  1. Când obiectul iese din scop, atunci distructorul clasei este apelat automat.
  2. În mod similar, distructorul este apelat când programul termină execuția. Aceasta înseamnă că și toate obiectele încetează să mai existe. Prin urmare, va fi chemat distructorul fiecărui obiect.
  3. Distructorul clasei este, de asemenea, apelat atunci când operatorul „șterge” pentru a șterge un obiect este executat.
  4. De asemenea, putem apela distructorul în mod explicit pentru a efectua orice activități de curățare după ce am terminat cu funcționalitatea obiectului.

Exemplul dat mai jos demonstrează funcționarea unui distructor.

#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'<

Ieșire:

Constructor :: eșantion numit

Aceasta este clasa eșantion

Destructor :: ~ eșantion numit

Captura de ecran pentru ieșirea de mai sus este prezentată mai jos.

ieșire distructor

Am definit un eșantion de clasă în care am definit un constructor, un destructor și un afișaj de funcții. În funcția principală, creăm un obiect obiect al eșantionului de clasă și apoi apelăm funcția de afișare pe acest obiect.

După aceea, se returnează 0. În ieșire, putem vedea că în momentul în care funcția de afișare revine și controlul programului ajunge la declarația returnează 0, distructorul este executat. Aceasta înseamnă că este executat în momentul în care obiectul iese din scop.

Pointerul „acesta”

C ++ folosește un concept special legat de obiecte, care este cunoscut sub numele de „acest” indicator. Pointerul „acesta” indică întotdeauna spre obiectul curent. Astfel, în funcție de situație, ori de câte ori trebuie să ne referim la obiectul curent, folosim indicatorul „acest”.

Știm că de fiecare dată când se creează o instanță a clasei, adică un obiect, se face o copie separată a datelor de membru ale clasei pentru obiect. Dar când vine vorba de funcțiile membre ale clasei, toate obiectele au aceeași copie.

Deci, atunci când unul sau mai multe obiecte accesează funcțiile de membru simultan, atunci cum ne asigurăm că membrii de date corespunzători sunt accesate și modificate de funcțiile de membru?

Acesta este locul în care „acest” indicator apare în acțiune. Compilatorul trece un pointer implicit cu numele funcției ca „acesta”. Acesta este numit indicatorul „acesta”.

Pointerul „acesta” este transmis ca argument ascuns tuturor apelurilor de funcție membru. De obicei este o variabilă locală. Prin urmare, „acest” indicator este un indicator constant și conținutul său este adresa de memorie a obiectului curent.

Rețineți că acest indicator este disponibil numai pentru funcții de membru nestatice și nu pentru funcții statice. Acest lucru se datorează faptului că funcțiile statice nu trebuie accesate folosind un obiect. Pot fi accesate direct folosind numele clasei.

De obicei, folosim indicatorul „acesta” în situații în care variabilele membre și parametrii sunt trecuți pentru a inițializa variabilele membre care au același nume. De asemenea, îl folosim atunci când trebuie să returnăm obiectul curent din funcție.

Să vedem mai jos demonstrația indicatorului „acesta”.

#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '<

Ieșire:

num = 100
ch = A

În programul de mai sus, avem o clasă numită Exemplu, cu doi membri num și num. Avem o funcție membru setParam care transmite parametrii cu aceleași nume, num și ch pentru a seta valorile variabilelor membre.

În interiorul funcției, atribuim aceste valori variabilelor membre ale obiectului curent indicate de acest indicator. Odată ce valorile sunt setate, obiectul curent „acesta” este returnat din funcție.

În funcția principală, creăm mai întâi un obiect din clasa Sample, obj și apelăm o funcție setParam pentru a seta valorile și apoi apelăm funcția printValues ​​pentru a imprima valorile.

Concluzie

Am învățat elementele de bază ale OOP în C ++ în acest tutorial. Înțelegerea claselor și obiectelor sunt cerințele primare, pentru început, OOP în C ++. De asemenea, am aflat în detaliu despre constructori și destructori cu exemple.

În viitorul nostru tutorial, vom afla despre listele de inițializatoare în C ++.

=> Urmăriți aici seria de antrenament C ++ simplă.

Lectură recomandată

^