În comparație cu clasa complexă, noua clasă complexă, pe lângă constructor, introduce și funcțiile componente re () și im (), cu care puteți accesa datele obiectului. Ei returnează referințele respectiv la părțile reale și imaginare ale obiectului pentru care sunt chemați.
Rețineți că constructorul nu specifică tipul returului. Există, de asemenea, caracteristici în apelul constructorului. Fără o indicație explicită a programatorului, constructorul este automat apelat atunci când definește (crea) un obiect de clasă. În acest caz, se folosesc valorile implicite ale parametrilor constructorului. De exemplu, prin definirea obiectului cu un apel constructor implicit
vom primi la un apel СС. re () este setat la 1.0. Funcția cc.im () returnează o referință la cc.imag, iar acest element al obiectului cc va avea o valoare de 0,0, specificată ca valoare implicită a parametrului constructor.
Astfel, "constructorul transformă un fragment de memorie într-un obiect pentru care regulile sistemului de tip sunt îndeplinite" [2], adică Pentru un obiect de tipul care este furnizat de definiția clasei.
Constructorul există pentru orice clasă și poate fi creat fără instrucțiuni explicite din partea programatorului. Astfel, pentru mărfurile și clasele complexe, există constructori automat.
În mod implicit, un constructor este creat fără parametri și un constructor de copie al formularului T :: T (const T) unde T este numele clasei. De exemplu,
Un astfel de constructor există întotdeauna. În mod implicit, constructorul de copiere este creat în mod public. Într-o clasă pot exista mai mulți constructori (supraîncărcare), dar numai unul cu valori implicite ale parametrilor.
Constructorul nu poate fi numit ca o componentă regulată a componentelor. Pentru a apela în mod explicit un constructor, puteți utiliza două forme de sintaxă diferite:
nume_clasă nume_obiect (parametrii actuali ai constructorului);
nume_clasă (parametrii actuali ai constructorului);
Primul formular este permis numai cu o listă non-goală a parametrilor reali. Aceasta implică chemarea constructorului la definirea unui nou obiect din această clasă:
complex SS (10,3,0,22); // SS.real == 10,3;
// SS.imag == 0,22
complexul E (2.345); // EE.real == 2.345;
// default EE.imag == 0.0
complex DD (); // Eroare! Compilatorul decide că acesta este
// funcția prototip fără parametri,
// returnează valoarea complexului tip
A doua formă a unui apel explicit către constructor duce la crearea unui obiect care nu are un nume. Obiectul anonim creat de un astfel de apel poate fi folosit în acele expresii în care este permisă utilizarea obiectului din această clasă. De exemplu:
Această definiție creează un obiect ZZ, căruia i se atribuie valoarea unui obiect anonim (cu elementele real == 4.0, imag == 5.0), create prin apelarea explicită a constructorului.
Există două moduri de a inițializa datele obiectului folosind constructori. Prima modalitate, și anume transferul valorilor parametrilor pe corpul constructorului, a fost deja demonstrată prin exemple. A doua metodă implică aplicarea unei liste de inițializatori de obiecte. Această listă este plasată între lista de parametri și corpul constructorului:
nume_clasă (listă_parametru):
date componente spisok_initsializatorov_ <тело_конструктора>
Fiecare inițializator de listă se referă la o componentă specifică și arată astfel:
datasource_name (expresie) De exemplu:
clasa AZ
AZ (int, float, char cn). ii (5),
(ii * en + in), cc (cn) <>
>;
AZ A (2.3.0, "d"); // Creați un obiect denumit A
// cu componentele A. = = 5,
// A.ee == 17, A.cc == 'd'
AZ X = AZ (0,2,0, 'z'); // Se creează un obiect fără nume, în
// care ii == 5, lui == 10,
// cc == 'z' și copiat
// a obiectului X
Caracteristicile enumerate ale constructorilor, acordul privind starea componentelor de acces și noul concept de "destructor" ilustrează următoarea definiție a clasei "character string":
//STROKA.CPP - fișier cu caracterul definit de clasă " nume_obiect. Element imya_ A doua operație oferă acces la datele componente ale obiectului în funcție de indicatorul specificat la obiect: Să aruncăm o privire la caracteristicile componentelor clasei. Deși în exterior, datele componente ale unei clase pot fi similare cu datele definite într-un bloc sau în corpul unei funcții, dar există unele diferențe semnificative. Nu este necesar ca datele de clasă să fie definite sau descrise înainte de a fi utilizate pentru prima dată în funcțiile deținute de clasă. Același lucru este valabil și pentru funcțiile aparținând clasei, adică Puteți accesa de la o funcție a unei clase la alta înainte de a fi definită în interiorul corpului clasei. Toate componentele clasei sunt "vizibile" la toți operatorii corpului său. De aceea, în plus față de domeniile "file", "block", "function", în C ++ a fost introdus un domeniu special de "clasă". Pentru ca o componentă de clasă să fie o singură instanță și să nu se replice atunci când se creează fiecare obiect de clasă nou, acesta trebuie definit în clasă ca static, adică trebuie să aibă atributul static. Unele posibilități ale componentelor statice au fost deja demonstrate pe exemplul clasei "bunuri în depozitul magazinului". Componentele statice ale clasei după inițializare pot fi utilizate în program chiar înainte de a defini obiecte din această clasă. O astfel de capacitate pentru datele publice este furnizată de numele componentei calificate. Atunci când este definit cel puțin un obiect de clasă, componentele sale statice pot fi accesate ca componente normale, adică utilizând operațiile de selectare a componentelor clasei ("." și "->"). Aici există o dificultate. Datele statice ale clasei fac obiectul regulilor de stare a accesului. Dacă datele statice sunt private sau protejate. atunci acestea pot fi accesate din exterior prin funcții componente. De fiecare dată când apelați o astfel de funcție a componentei, trebuie să specificați numele unui obiect. Până când sunt accesate datele statice ale unei clase, obiectele din clasă nu pot fi definite încă sau pot fi mai multe și fiecare este adecvată pentru a apela funcțiile componentelor. Fără un nume de obiect, funcția obișnuită a componentei nu poate fi apelată în conformitate cu cerințele sintaxei. Dar ce obiect să alegeți pentru un apel, deoarece fiecare element static al clasei este unic în el? Aș vrea să pot face fără numele unui anumit obiect atunci când accesez date statice de clasă. Această caracteristică este furnizată de funcțiile statice ale componentelor. Noi trimitem angajatul pentru beneficii în FSS, revista "cartea principală", numărul 8 pentru 2018 Cartea - al nouălea talisman - watt-evans lourens - citit online, pagina 1
// șirul "
#include * Pentru funcțiile șir ale bibliotecii
#include
clasa stroka
char * ch; // Afișează un șir de text
int len; // Lungimea șirului de text
public: Funcții publice:
// Constructori de obiecte de clasă:
// Crează un obiect ca un nou șir gol:
stroka (int N = 80):
// Linia nu conține informații:
(0)
> // Crează un obiect pe șirul specificat:
stroka (const char * arc)
strcpy (ch, arc);
>
int len_str (void) // Returnează o referință la lungimea șirului
char * string (void) // Returnează un pointer la un șir
void display (void) // Imprimați informații despre șir
Articole similare
Trimiteți-le prietenilor: