dacă (str != str2)
Ce fac aceste programe?

Se pare că a doua implementare rulează de două ori mai repede decât prima. Te asteptai la un asemenea rezultat? Cum explici?

Exercițiul 3.15

Ai putea să îmbunătățești sau să adaugi ceva la setul de operații al clasei șir date în ultima secțiune? Explicați-vă propunerile

3.5. specificatorul const

Să luăm următorul exemplu de cod:< 512; ++index) ... ;

Pentru (index int = 0; index
Există două probleme cu utilizarea literalului 512. Prima este ușurința de a percepe textul programului. De ce ar trebui ca limita superioară a variabilei buclei să fie exact 512? Ce se ascunde în spatele acestei valori? Ea pare la întâmplare...
A doua problemă se referă la ușurința modificării și întreținerii codului. Să presupunem că programul are 10.000 de linii și literalul 512 apare în 4% dintre ele. Să presupunem că în 80% din cazuri numărul 512 trebuie schimbat în 1024. Vă puteți imagina complexitatea unei astfel de lucrări și numărul de greșeli care pot fi făcute prin corectarea valorii greșite?

Rezolvăm ambele probleme în același timp: trebuie să creăm un obiect cu valoarea 512. Dându-i un nume semnificativ, cum ar fi bufSize, facem programul mult mai ușor de înțeles: este clar care este exact variabila buclă. comparativ cu.< bufSize

Index În acest caz, schimbarea dimensiunii bufSize nu necesită parcurgerea a 400 de linii de cod pentru a modifica 320 dintre ele. Cât de mult se reduce probabilitatea de erori prin adăugarea unui singur obiect! Acum valoarea este 512.

localizat< bufSize; ++index)
// ...

Int bufSize = 512; // dimensiunea tamponului de intrare // ... pentru (index int = 0; index

Rămâne o mică problemă: variabila bufSize aici este o valoare l care poate fi schimbată accidental în program, ceea ce duce la o eroare greu de detectat. Iată o greșeală comună: folosirea operatorului de atribuire (=) în loc de operatorul de comparație (==):

// modificare aleatorie a valorii bufSize dacă (bufSize = 1) // ...
Executarea acestui cod va face ca valoarea bufSize să fie 1, ceea ce poate duce la un comportament complet imprevizibil al programului. Erorile de acest fel sunt de obicei foarte greu de detectat deoarece pur și simplu nu sunt vizibile.

Utilizarea specificatorului const rezolvă această problemă. Prin declararea obiectului ca

transformăm variabila într-o constantă cu valoarea 512, a cărei valoare nu poate fi modificată: astfel de încercări sunt suprimate de compilator: utilizarea incorectă a operatorului de atribuire în loc de comparație, ca în exemplul de mai sus, va provoca o eroare de compilare.

// eroare: încercați să atribuiți o valoare unei constante dacă (bufSize = 0) ...

Deoarece unei constante nu i se poate atribui o valoare, ea trebuie inițializată în locul în care este definită. Definirea unei constante fără inițializare provoacă și o eroare de compilare:

Const dublu pi; // eroare: constantă neinițializată

Const dublu minWage = 9,60; // Dreapta? eroare?
dublu *ptr =

Ar trebui compilatorul să permită o astfel de atribuire? Deoarece minWage este o constantă, nu i se poate atribui o valoare. Pe de altă parte, nimic nu ne împiedică să scriem:

*ptr += 1,40; // schimbarea obiectului minWage!

De regulă, compilatorul nu este capabil să protejeze împotriva utilizării pointerilor și nu va putea semnala o eroare dacă acestea sunt utilizate în acest mod. Acest lucru necesită o analiză prea profundă a logicii programului. Prin urmare, compilatorul interzice pur și simplu alocarea de adrese constante către pointerii obișnuiți.
Deci, suntem lipsiți de capacitatea de a folosi pointeri către constante? Nu. În acest scop, există pointeri declarați cu specificatorul const:

Const double *cptr;

unde cptr este un pointer către un obiect de tip const double. Subtilitatea este că indicatorul în sine nu este o constantă, ceea ce înseamnă că îi putem schimba valoarea.

De exemplu:
Const dublu *buc = 0; const double minWage = 9,60; // corect: nu putem schimba minWage folosind computerul
pc = dublu dval = 3,14; // corect: nu putem schimba minWage folosind computerul
// deși dval nu este o constantă
pc = // corect dval = 3,14159; //Dreapta

*buc = 3,14159; // eroare

Adresa unui obiect constant este atribuită doar unui pointer către o constantă. În același timp, unui astfel de indicator îi poate fi atribuită și adresa unei variabile obișnuite:

Pc =
În programele reale, pointerii către constante sunt cel mai adesea folosiți ca parametri formali ai funcțiilor. Utilizarea lor asigură că obiectul transmis unei funcții ca argument real nu va fi modificat de acea funcție. De exemplu:

// În programele reale, pointerii către constante sunt cel mai des // utilizați ca parametri formali ai funcțiilor int strcmp(const char *str1, const char *str2);

(Vom vorbi mai multe despre indicatorii constante în capitolul 7, când vorbim despre funcții.)
Există, de asemenea, indicii constante. (Rețineți diferența dintre un pointer const și un pointer către o constantă!). Un pointer const poate adresa fie o constantă, fie o variabilă. De exemplu:

Int errNumb = 0; int *const currErr =

Aici curErr este un pointer const către un obiect non-const. Aceasta înseamnă că nu îi putem atribui adresa altui obiect, deși obiectul în sine poate fi modificat.

Iată cum ar putea fi folosit indicatorul curErr:
Fă ceva(); dacă (*curErr) (
errorHandler();
}

*curErr = 0; // corect: resetați valoarea errNumb

Încercarea de a atribui o valoare unui pointer const va cauza o eroare de compilare:

CurErr = // eroare

Un indicator constant către o constantă este o unire a celor două cazuri luate în considerare.

Const dublu pi = 3,14159; const double *const pi_ptr = π

Nici valoarea obiectului indicat de pi_ptr, nici valoarea pointerului în sine nu pot fi modificate în program.

Exercițiul 3.16

Explicați semnificația următoarelor cinci definiții. Greșește vreunul dintre ei?

(a) int i; (d) int *const cpi; (b) const int ic; (e) const int *const cpic; (c) const int *pic;

Exercițiul 3.17

Care dintre următoarele definiții sunt corecte? De ce?

(a) int i = -1; (b) const int ic = i; (c) const int *pic = (d) int *const cpi = (e) const int *const cpic =

Exercițiul 3.18

Folosind definițiile din exercițiul anterior, identificați operatorii de atribuire corecti. Explica.

(a) i = ic; (d) pic = cpic; (b) pic = (i) cpic = (c) cpi = pic; (f) ic = *cpic;

3.6. Tip de referință
Un tip de referință este indicat prin specificarea operatorului de adresă (&) înaintea numelui variabilei. Link-ul trebuie inițializat. De exemplu:

Int ival = 1024; // corect: refVal - referire la ival int &refVal = ival; // eroare: referința trebuie inițializată la int

Int ival = 1024; // eroare: refVal este de tip int, nu int* int &refVal = int *pi = // corect: ptrVal este o referință la un pointer int *&ptrVal2 = pi;

Odată definită o referință, nu o puteți modifica pentru a funcționa cu un alt obiect (de aceea referința trebuie inițializată în punctul în care este definită). În exemplul următor, operatorul de atribuire nu modifică valoarea refVal noua valoare este atribuită variabilei ival, cea pe care o adresează refVal;

Int min_val = 0; // ival primește valoarea min_val, // în loc de refVal schimbă valoarea în min_val refVal = min_val;

Val ref += 2; adaugă 2 la ival, variabila referită de refVal. În mod similar int ii = refVal; atribuie ii valoarea curentă a lui ival, int *pi = inițializează pi cu adresa lui ival.

// două obiecte de tip int sunt definite int ival = 1024, ival2 = 2048; // o referință și un obiect definit int &rval = ival, rval2 = ival2; // sunt definite un obiect, un pointer și o referință
int inal3 = 1024, *pi = ival3, &ri = ival3; // două legături sunt definite int &rval3 = ival3, &rval4 = ival2;

O referință const poate fi inițializată printr-un obiect de alt tip (presupunând, desigur, că este posibilă convertirea unui tip în altul), precum și printr-o valoare fără adresă, cum ar fi o constantă literală. De exemplu:

dval dublu = 3,14159; // adevărat numai pentru referințe constante
const int &ir = 1024;
const int &ir2 = dval;
const dublu &dr = dval + 1,0;

Dacă nu am fi specificat specificatorul const, toate cele trei definiții de referință ar fi cauzat o eroare de compilare. Cu toate acestea, motivul pentru care compilatorul nu trece astfel de definiții este neclar. Să încercăm să ne dăm seama.
Pentru literali, acest lucru este mai mult sau mai puțin clar: nu ar trebui să putem schimba indirect valoarea unui literal folosind pointeri sau referințe. În ceea ce privește obiectele de alte tipuri, compilatorul convertește obiectul original într-un obiect auxiliar. De exemplu, dacă scriem:

dval dublu = 1024; const int &ri = dval;

apoi compilatorul îl convertește în ceva de genul acesta:

Int temp = dval; const int &ri = temp;

Dacă am putea atribui o nouă valoare referinței ri, am schimba de fapt nu dval, ci temp. Valoarea dval ar rămâne aceeași, ceea ce este complet neevident pentru programator. Prin urmare, compilatorul interzice astfel de acțiuni, iar singura modalitate de a inițializa o referință cu un obiect de alt tip este să o declarați ca const.
Iată un alt exemplu de link care este greu de înțeles prima dată. Dorim să definim o referință la adresa unui obiect constant, dar prima noastră opțiune provoacă o eroare de compilare:

Const int ival = 1024; // eroare: este necesară o referință constantă
int *&pi_ref =

De asemenea, o încercare de a corecta problema prin adăugarea unui specificator const eșuează:

Const int ival = 1024; // încă o eroare const int *&pi_ref =

Care este motivul? Dacă citim cu atenție definiția, vom vedea că pi_ref este o referință la un pointer constant către un obiect de tip int. Și avem nevoie de un pointer non-const către un obiect constant, astfel încât următoarea intrare ar fi corectă:

Const int ival = 1024; // Dreapta
int *const &piref =

Există două diferențe principale între o legătură și un pointer. În primul rând, legătura trebuie inițializată în locul în care este definită. În al doilea rând, orice modificare a unei legături nu transformă legătura, ci obiectul la care se referă.

Să ne uităm la exemple. Daca scriem:

Int *pi = 0;

inițializam indicatorul pi la zero, ceea ce înseamnă că pi nu indică niciun obiect. În același timp, înregistrarea
const int &ri = 0;
inseamna ceva de genul asta:
int temp = 0;

const int &ri = temp;

În ceea ce privește operațiunea de atribuire, în exemplul următor:

Int ival = 1024, ival2 = 2048; int *pi = &ival, *pi2 = pi = pi2;
variabila ival indicată de pi rămâne neschimbată, iar pi primește valoarea adresei variabilei ival2. Atât pi cât și pi2 indică acum același obiect, ival2.

Dacă lucrăm cu link-uri:

Int &ri = ival, &ri2 = ival2; ri = ri2;
// exemplu de utilizare a legăturilor // Valoarea este returnată în parametrul next_value

bool get_next_value(int &next_value); // operator supraîncărcat Matrix operator+(const Matrix&, const Matrix&);

Int ival; în timp ce (get_next_value(ival))...

Int &next_value = ival;

(Folosirea referințelor ca parametri formali ai funcțiilor este discutată mai detaliat în Capitolul 7.)

Exercițiul 3.19

(a) int ival = 1,01; (b) int &rval1 = 1,01; (c) int &rval2 = ival; (d) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (g) int &rval5 = pi*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (j) const int &*prval2 =

Exercițiul 3.20

Este vreunul dintre următorii operatori de atribuire eronați (folosind definițiile din exercițiul anterior)?

(a) rval1 = 3,14159; (b) prval1 = prval2; (c) prval2 = rval1; (d) *prval2 = ival2;

Exercițiul 3.21

Găsiți erori în instrucțiunile date:

(a) int ival = 0;
const int *pi = 0;
const int &ri = 0; (b)pi =

ri =

pi =

3.7. Tastați bool
Un obiect de tip bool poate lua una din două valori: adevărat și fals. De exemplu:
// inițializarea șirului de caractere search_word = get_word(); // inițializarea variabilei găsite
bool găsit = fals; string următorul_cuvânt; în timp ce (cin >> următorul_cuvânt)
dacă (next_word == search_word)
găsit = adevărat;
cout<< "ok, мы нашли слово\n";
// ... // scurtătură: dacă (găsit == adevărat)<< "нет, наше слово не встретилось.\n";

daca este gasit)

altfel cout

Deși bool este unul dintre tipurile întregi, nu poate fi declarat ca semnat, nesemnat, scurt sau lung, deci definiția de mai sus este incorectă:

// eroare short bool found = false;
{
Obiectele de tip bool sunt implicit convertite în tipul int. Adevărat devine 1 și fals devine 0. De exemplu:
Bool găsit = fals; int număr_ocurență = 0; în timp ce (/* mormăi */)

găsit = caută(/* ceva */);

// valoarea găsită este convertită la 0 sau 1
număr_ocurență += găsit; )

În același mod, valorile tipurilor întregi și ale indicatorilor pot fi convertite în valori de tip bool. În acest caz, 0 este interpretat ca fals și orice altceva este adevărat:

// returnează numărul de apariții extern int find(const șir&); bool găsit = fals; if (found = find("rosebud")) // corect: found == true // returnează un pointer la element
extern int* find(int value); if (found = find(1024)) // corect: găsit == adevărat

3.8. Transferuri

Adesea trebuie să definiți o variabilă care ia valori dintr-un anumit set. Să presupunem că un fișier este deschis în oricare dintre cele trei moduri: pentru citire, pentru scriere, pentru atașare.

Desigur, trei constante pot fi definite pentru a denota aceste moduri:
Intrare const int = 1; const int output = 2; const int append = 3;

și folosiți aceste constante:
Utilizarea unui tip de enumerare rezolvă această problemă. Când scriem:

Enum open_modes( input = 1, output, append );

definim un nou tip open_modes. Valorile valide pentru un obiect de acest tip sunt limitate la setul de 1, 2 și 3, fiecare dintre valorile specificate având un nume mnemonic. Putem folosi numele acestui nou tip pentru a defini atât un obiect de acel tip, cât și tipul parametrilor formali ai funcției:

Void open_file(string nume_fișier, open_modes om);

intrare, ieșire și anexare sunt elemente de enumerare. Setul de elemente de enumerare specifică setul de valori permis pentru un obiect de un anumit tip.

O variabilă de tip open_modes (în exemplul nostru) este inițializată cu una dintre aceste valori i se poate atribui și oricare dintre ele. De exemplu:

Open_file(„Phoenix și macaraua”, anexează);

O încercare de a atribui o altă valoare decât unul dintre elementele de enumerare unei variabile de acest tip (sau de a o transmite ca parametru unei funcții) va provoca o eroare de compilare. Chiar dacă încercăm să transmitem o valoare întreagă corespunzătoare unuia dintre elementele de enumerare, vom primi o eroare:

// eroare: 1 nu este un element al enumerarii open_modes open_file("Iona", 1);

Există o modalitate de a defini o variabilă de tip open_modes, de a-i atribui valoarea unuia dintre elementele de enumerare și de a o transmite ca parametru funcției:

Open_modes om = intrare;

Cout<< input << " " << om << endl;

// ... om = anexează;

open_file("TailTell", om);

Cout<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

Cu toate acestea, nu este posibil să se obțină denumirile unor astfel de elemente. Dacă scriem instrucțiunea de ieșire:

atunci mai primim:

Această problemă poate fi rezolvată prin definirea unui tablou de șiruri în care elementul cu un index egal cu valoarea elementului de enumerare va conține numele său.

Având în vedere o astfel de matrice, putem scrie:

Valorile întregi corespunzătoare elementelor diferite ale aceleiași enumerații nu trebuie să fie diferite. De exemplu:

// point2d == 2, point2w == 3, point3d == 3, point3w == 4 enum Points ( point2d=2, point2w, point3d=3, point3w=4 );

Un obiect al cărui tip este o enumerare poate fi definit, utilizat în expresii și transmis unei funcții ca argument. Un astfel de obiect este inițializat doar cu valoarea unuia dintre elementele de enumerare și numai acea valoare îi este atribuită, fie în mod explicit, fie ca valoare a altui obiect de același tip. Nici măcar valorile întregi corespunzătoare elementelor de enumerare valide nu îi pot fi atribuite:

Void mumble() ( Puncte pt3d = punct3d; // corect: pt2d == 3 // eroare: pt3w este inițializat cu tipul int Puncte pt3w = 3; // eroare: poligonul nu este inclus în enumerarea de puncte pt3w = poligon; / / corect: ambele obiecte de tip Puncte pt3w = pt3d )

Cu toate acestea, în expresiile aritmetice, o enumerare poate fi convertită automat în tipul int. De exemplu:

Const int array_size = 1024; // corect: pt2w este convertit în int
int chunk_size = array_size * pt2w;

3.9. Tastați „matrice”

Am atins deja matricele în secțiunea 2.1. O matrice este un set de elemente de același tip, accesate de un index - numărul de serie al elementului din matrice. De exemplu:

Int ival;

definește ival ca o variabilă int și instrucțiunea

Int ia[ 10 ];

specifică o matrice de zece obiecte de tip int. La fiecare dintre aceste obiecte, sau elemente de matrice, poate fi accesat folosind operația de index:

Ival = ia[ 2 ];

atribuie variabilei ival valoarea elementului de matrice ia cu indicele 2. La fel

Ia[ 7 ] = ival;

atribuie elementului de la indicele 7 valoarea ival.

O definiție de matrice constă dintr-un specificator de tip, un nume de matrice și o dimensiune.

Dimensiunea specifică numărul de elemente ale matricei (cel puțin 1) și este cuprinsă între paranteze drepte. Mărimea tabloului trebuie să fie cunoscută deja în etapa de compilare și, prin urmare, trebuie să fie o expresie constantă, deși nu este neapărat specificată ca un literal.
Iată exemple de definiții corecte și incorecte ale matricei:
Extern int get_size(); // constantele buf_size și max_files

Obiectele buf_size și max_files sunt constante, astfel încât definițiile matricei input_buffer și fileTable sunt corecte. Dar staff_size este o variabilă (deși inițializată cu constanta 27), ceea ce înseamnă că salariile sunt inacceptabile. (Compilatorul nu poate găsi valoarea variabilei staff_size când este definită matricea de salarii.)
Expresia max_files-3 poate fi evaluată în timpul compilării, astfel încât definiția matricei fileTable este corectă din punct de vedere sintactic.
Numerotarea elementelor începe de la 0, deci pentru o matrice de 10 elemente intervalul de index corect nu este 1 – 10, ci 0 – 9. Iată un exemplu de iterare prin toate elementele matricei:

Int main() (const int dimensiune_matrice = 10; int ia[ dimensiune_matrice]; for (int ix = 0; ix< array_size; ++ ix)
ia[ ix ] = ix;
}

Atunci când definiți o matrice, o puteți inițializa în mod explicit, listând valorile elementelor sale în acolade, separate prin virgule:

Const int array_size = 3; int ia[ array_size ] = ( 0, 1, 2 );

Dacă specificăm în mod explicit o listă de valori, atunci nu trebuie să specificăm dimensiunea matricei: compilatorul însuși va număra numărul de elemente:

// matrice de dimensiune 3 int ia = ( 0, 1, 2 );

Când atât dimensiunea, cât și lista de valori sunt specificate în mod explicit, sunt posibile trei opțiuni. Dacă dimensiunea și numărul de valori coincid, totul este evident. Dacă lista de valori este mai scurtă decât dimensiunea specificată, elementele de matrice rămase sunt inițializate la zero.

Dacă există mai multe valori în listă, compilatorul afișează un mesaj de eroare:

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; int ia[ array_size ] = ( 0, 1, 2 );

O matrice de caractere poate fi inițializată nu numai cu o listă de valori de caractere între acolade, ci și cu un șir literal. Cu toate acestea, există unele diferențe între aceste metode. Sa spunem

Const char cal = ("C", "+", "+" ); const char cal2 = "C++";

Dimensiunea matricei ca1 este 3, matricea ca2 este 4 (în literalele șir, se ia în considerare caracterul nul final). Următoarea definiție va provoca o eroare de compilare:

// eroare: șirul „Daniel” este format din 7 elemente const char ch3[ 6 ] = „Daniel”;

O matrice nu i se poate atribui valoarea unei alte matrice, iar inițializarea unei matrice de către alta nu este permisă. În plus, nu este permisă utilizarea unei matrice de referințe.
{
Iată exemple de utilizare corectă și incorectă a matricelor:
Const int array_size = 3; int ix, jx, kx; // corect: matrice de pointeri de tip int* int *iar = ( &ix, &jx, &kx ); // eroare: tablourile de referință nu sunt permise int &iar = ( ix, jx, kx ); int main()
ia3 = ia;
întoarce 0;
}

Pentru a copia o matrice în alta, trebuie să faceți acest lucru pentru fiecare element separat:

Const int array_size = 7; int ia1 = ( 0, 1, 2, 3, 4, 5, 6 ); int main() (
int ia3[ array_size ];< array_size; ++ix)
pentru (int ix = 0; ix
}

ia2[ ix ] = ia1[ ix ];

întoarce 0;

Un index de matrice poate fi orice expresie care produce un rezultat de tip întreg. De exemplu:

Int someVal, get_index(); ia2[ get_index() ] = someVal;

Subliniem că limbajul C++ nu asigură controlul indicilor de matrice, nici în etapa de compilare, nici în etapa de rulare. Programatorul însuși trebuie să se asigure că indexul nu depășește limitele matricei. Erorile la lucrul cu un index sunt destul de frecvente. Din păcate, nu este foarte dificil să găsești exemple de programe care să compileze și chiar să funcționeze, dar care conțin totuși erori fatale care mai devreme sau mai târziu duc la blocarea.

Exercițiul 3.22

Care dintre următoarele definiții ale matricei sunt incorecte? Explica.

(a) int ia[ buf_size ]; (d) int ia[ 2 * 7 - 14 ] (b) int ia[ get_size() ]; (e) char st[ 11 ] = „fundamental”; (c) int ia[ 4 * 7 - 14 ];

Exercițiul 3.23<= array_size; ++ix)
Următorul fragment de cod trebuie să inițializeze fiecare element al matricei cu o valoare de index. Găsiți greșelile făcute:
}

Int main() (const int dimensiune_matrice = 10; int ia[ dimensiune_matrice]; for (int ix = 1; ix

ia[ ia ] = ix;

// ...

3.9.1. Matrice multidimensionale

În C++, este posibil să se utilizeze tablouri multidimensionale, atunci când le declarați trebuie să indicați limita dreaptă a fiecărei dimensiuni între paranteze pătrate separate.

Iată definiția unui tablou bidimensional:

Int ia[ 4 ][ 3 ];

Prima valoare (4) specifică numărul de rânduri, a doua (3) – numărul de coloane.

Obiectul ia este definit ca o matrice de patru șiruri de trei elemente fiecare. Matricele multidimensionale pot fi, de asemenea, inițializate:

Int ia[ 4 ][ 3 ] = ( ( 0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

Int ia[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

Când accesați elemente ale unui tablou multidimensional, trebuie să utilizați indecși pentru fiecare dimensiune (aceștia sunt încadrați între paranteze drepte). Iată cum arată inițializarea unei matrice bidimensionale folosind bucle imbricate:

Int main() ( const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; for (int = 0; i< rowSize; ++i)
pentru (int j = 0; j< colSize; ++j)
ia[ i ][ j ] = i + j j;
}

Proiecta

Ia[ 1, 2 ]

este valabil din punctul de vedere al sintaxei C++, dar nu înseamnă deloc ceea ce se așteaptă un programator fără experiență. Aceasta nu este o declarație a unui tablou bidimensional 1 pe 2. Un agregat între paranteze drepte este o listă de expresii separate prin virgulă, care va avea ca rezultat valoarea finală 2 (vezi operatorul virgulă în Secțiunea 4.2). Prin urmare, declarația ia este echivalentă cu ia.

Aceasta este o altă oportunitate de a greși.

3.9.2. Relația dintre tablouri și pointeri

Dacă avem o definiție de matrice:

Int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );

atunci ce înseamnă pur și simplu indicarea numelui său în program?

Utilizarea unui identificator de matrice într-un program este echivalentă cu specificarea adresei primului său element:

În mod similar, puteți accesa valoarea primului element al unui tablou în două moduri:

// ambele expresii returnează primul element *ia; in absenta;

Pentru a lua adresa celui de-al doilea element al matricei, trebuie să scriem:

După cum am menționat mai devreme, expresia

oferă, de asemenea, adresa celui de-al doilea element al matricei. În consecință, sensul său ne este dat în următoarele două moduri:

*(ia+1); in absenta;

Observați diferența dintre expresii:

*ia+1 și *(ia+1); Operația de dereferință are o valoare mai mare o prioritate

decât operația de adăugare (prioritățile operatorului sunt discutate în secțiunea 4.13).

#include Prin urmare, prima expresie dereferențează variabila ia și primește primul element al matricei, apoi adaugă 1 la acesta.<< *pbegin <<; ++pbegin; } }

Pointerul pbegin este inițializat la adresa primului element al matricei. Fiecare trecere prin buclă crește acest indicator cu 1, ceea ce înseamnă că este mutat la următorul element. De unde știi unde să stai? În exemplul nostru, am definit un al doilea indicator pend și l-am inițializat cu adresa care urmează ultimul element al matricei ia. De îndată ce valoarea lui pbegin devine egală cu pend, știm că matricea s-a încheiat. Să rescriem acest program, astfel încât începutul și sfârșitul matricei să fie transmise ca parametri unei anumite funcții generalizate care poate imprima o matrice de orice dimensiune:

#include void ia_print(int *pbegin, int *pend) (
în timp ce (pbegin != pend) (
cout<< *pbegin << " ";
++pbegin;
}
) int main()
{
int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );
ia_print(ia, ia + 9);
}

Funcția noastră a devenit mai universală, totuși, poate funcționa numai cu matrice de tip int. Există o modalitate de a elimina această limitare: convertiți această funcție într-un șablon (șabloanele au fost introduse pe scurt în secțiunea 2.5):

#include șablon void print(elemType *pbegin, elemType *pend) ( în timp ce (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

Acum putem apela funcția print() pentru a imprima matrice de orice tip:

Int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); double da = ( 3.14, 6.28, 12.56, 25.12 ); string sa = ( "purcel", " eeyore", "pooh"); print(ia, ia+9);
print(da, da+4);
print(sa, sa+3);
}

Noi am scris generalizat funcţie. Biblioteca standard oferă un set de algoritmi generici (am menționat deja acest lucru în Secțiunea 3.4) implementați într-un mod similar. Parametrii unor astfel de funcții sunt pointeri către începutul și sfârșitul matricei cu care efectuează anumite acțiuni. Iată, de exemplu, cum arată apelurile la un algoritm de sortare generalizat:

#include int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( „purcel”, „eeyore”, „pooh” ); sort(ia, ia+6);
sort(sa, sa+3);
};

(Vom intra în mai multe detalii despre algoritmii generalizați în Capitolul 12; Anexa va oferi exemple de utilizare a acestora.)
Biblioteca standard C++ conține un set de clase care încapsulează utilizarea containerelor și a indicatorilor. (Acest lucru a fost discutat în Secțiunea 2.8.) În secțiunea următoare, vom arunca o privire asupra vectorului de tip container standard, care este o implementare orientată pe obiect a unui tablou.

3.10. Clasa de vectori

Utilizarea clasei vectoriale (vezi Secțiunea 2.8) este o alternativă la utilizarea tablourilor încorporate. Această clasă oferă mult mai multe funcționalități, așa că utilizarea ei este de preferat. Cu toate acestea, există situații în care nu puteți face fără matrice de tip încorporat. Una dintre aceste situații este procesarea parametrilor liniei de comandă trecuți programului, despre care vom discuta în secțiunea 7.8. Clasa vectorială, ca și clasa șir, face parte din biblioteca standard C++.
Pentru a utiliza vectorul trebuie să includeți fișierul antet:

#include

Există două abordări complet diferite pentru utilizarea unui vector, să le numim idiomul matrice și idiomul STL. În primul caz, un obiect vectorial este utilizat exact în același mod ca o matrice de tip încorporat. Se determină un vector cu o dimensiune dată:

Vector< int >În următoarea definiție:

care este similar cu definirea unei matrice de tip încorporat:

Int ia[ 10 ];

Pentru a accesa elementele individuale ale unui vector, se utilizează operația index:

Void simp1e_examp1e() (const int e1em_size = 10; vector< int >ivec(e1em_size);< e1em_size; ++ix)
int ia[ e1em_size ];
}

pentru (int ix = 0; ix

ia[ ix ] = ivec[ ix ]; // ...< ivec.size(); ++ix)
cout<< ivec[ ix ] << " ";
}

Putem afla dimensiunea unui vector folosind funcția size() și putem verifica dacă vectorul este gol folosind funcția empty(). De exemplu:

Vector< int >Void print_vector(vector

ivec) ( dacă (ivec.empty()) return; pentru (int ix=0; ix
Elementele vectorului sunt inițializate cu valori implicite. Pentru tipurile numerice și pointerii, această valoare este 0. Dacă elementele sunt obiecte de clasă, atunci inițiatorul pentru ele este specificat de constructorul implicit (vezi secțiunea 2.3). Cu toate acestea, inițiatorul poate fi specificat și în mod explicit folosind formularul:

ivec(10, -1);

Toate cele zece elemente ale vectorului vor fi egale cu -1.

O matrice de tip încorporat poate fi inițializată explicit cu o listă:< int >Int ia[6] = (-2, -1, O, 1, 2, 1024);

O acțiune similară nu este posibilă pentru un obiect din clasa vectorului. Cu toate acestea, un astfel de obiect poate fi inițializat folosind un tip de matrice încorporat:

// 6 elemente sunt copiate în vectorul ivec< int >ivec(ia, ia+6);

Constructorului vectorului ivec îi trec doi pointeri - un pointer la începutul tabloului ia și la elementul care urmează ultimului. Ca o listă de valori inițiale, este permisă specificarea nu a întregului tablou, ci a unui anumit interval al acesteia:

Vector< string >svec; void init_and_assign() ( // un vector este inițializat de un alt vector< string >nume_utilizator(svec);
// ... // un vector este copiat pe altul
}

svec = nume_utilizator;

Vector< string >Când vorbim despre idiomul STL, ne referim la o abordare complet diferită a utilizării unui vector. În loc să specificăm imediat dimensiunea dorită, definim un vector gol:

text;

Apoi îi adăugăm elemente folosind diverse funcții. De exemplu, funcția push_back() inserează un element la sfârșitul unui vector. Iată o bucată de cod care citește o secvență de linii de la intrarea standard și le adaugă la un vector:

Cuvânt șir;

Cout<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

în timp ce (cin >> cuvânt) ( text.push_back(cuvânt); // ... )

Cout<< "считаны слова: \n"; for (vectorDeși putem folosi operația de index pentru a itera elementele unui vector:<< *it << " "; cout << endl;

Este mai obișnuit în cadrul acestui idiom să folosiți iteratoare:
::iterator it = text.begin(); it != text.end(); ++it) cout

Un iterator este o clasă de bibliotecă standard care este în esență un pointer către un element de matrice.

Expresie

Vector dereferențiază iteratorul și oferă elementul vectorial însuși. Instrucțiuni

Mută ​​indicatorul la următorul element. Nu este nevoie să amestecăm aceste două abordări.

Dacă urmați limbajul STL când definiți un vector gol:

ivec;

Vector Ar fi o greseala sa scriu:

Nu avem încă un singur element al vectorului ivec; Numărul de elemente este determinat cu ajutorul funcției size().

Se poate face și greșeala inversă. Dacă definim un vector de o anumită dimensiune, de exemplu:< int >ia(10);< size; ++ix) ivec.push_back(ia[ ix ]);

Apoi inserarea elementelor crește dimensiunea acesteia, adăugând elemente noi celor existente.
Deși acest lucru pare evident, un programator începător ar putea scrie:

Const int dimensiune = 7; int ia[ mărime ] = ( 0, 1, 1, 2, 3, 5, 8 ); vector

ivec(dimensiune); pentru (int ix = 0; ix
Aceasta a însemnat inițializarea vectorului ivec cu valorile elementelor ia, ceea ce a rezultat într-un vector ivec de dimensiunea 14.

Urmând limbajul STL, puteți nu numai să adăugați, ci și să eliminați elemente dintr-un vector.< vector< int >(Vom analiza toate acestea în detaliu și cu exemple în capitolul 6.)
Exercițiul 3.24< int >Există erori în următoarele definiții?
int ia[ 7 ] = ( 0, 1, 1, 2, 3, 5, 8 );< int >(a)vector
>ivec;< string >(b) vector
ivec = (0, 1, 1, 2, 3, 5, 8);< string >(c)vector

ivec(ia, ia+7);

(d)vector
svec = ivec;
(e)vector svec(10, string("null"));
Funcția is_equal() compară două containere element cu element. În cazul containerelor de diferite dimensiuni, „coada” celui mai lung nu este luată în considerare. Este clar că dacă toate elementele comparate sunt egale, funcția returnează adevărat, dacă cel puțin unul este diferit, fals. Utilizați un iterator pentru a itera elemente. Scrieți o funcție main() care apelează is_equal().

3.11. complex de clasă

Clasa de complexe de numere complexe este o altă clasă din biblioteca standard.

#include

Ca de obicei, pentru a-l folosi trebuie să includeți fișierul antet:

Un număr complex este format din două părți - real și imaginar. Partea imaginară este rădăcina pătrată a unui număr negativ. Un număr complex este de obicei scris sub formă

unde 2 este partea reală, iar 3i este partea imaginară. Iată exemple de definiții ale obiectelor de tip complex:< double >// număr pur imaginar: complex 0 + 7-i< float >purei(0, 7); // partea imaginară este 0: 3 + complex Oi< long double >rea1_num(3); // atât părțile reale cât și cele imaginare sunt egale cu complexul 0: 0 + 0-i< double >zero; // inițializarea unui număr complex cu un alt complex

purei2(purei);

Deoarece complex, ca și vector, este un șablon, îl putem instanția cu tipurile float, double și long double, ca în exemplele date. De asemenea, puteți defini o matrice de elemente de tip complex:< double >Complex< double >conjugate[ 2 ] = ( complex< double >(2, -3) };

Deoarece complex, ca și vector, este un șablon, îl putem instanția cu tipurile float, double și long double, ca în exemplele date. De asemenea, puteți defini o matrice de elemente de tip complex:< double >(2, 3), complex< double >*ptr = complex

&ref = *ptr;

3.12. directivă typedef

Directiva typedef vă permite să specificați un sinonim pentru un tip de date încorporat sau personalizat. De exemplu: Typedef salarii duble; vector typedef

vec_int; typedef vec_int test_scores; typedef bool in_attendance; typedef int *Pint;

Numele definite folosind directiva typedef pot fi folosite exact în același mod ca specificatorii de tip: // dublu orar, săptămânal; salariu orar, saptamanal; //vector
vecl(10); vec_int vecl(10); //vector< bool >test0(c1ass_size); const int c1ass_size = 34; test_scores test0(c1ass_size); //vector< in_attendance >prezența; vector

prezență(c1ass_size); // int *tabel[ 10 ]; Masa cu halbe [10];
Pentru ce sunt definite numele folosind directiva typedef? Folosind nume mnemonice pentru tipurile de date, puteți face programul mai ușor de înțeles. În plus, este obișnuit să se folosească astfel de nume pentru tipurile compozite complexe care sunt altfel greu de înțeles (vezi exemplul din Secțiunea 3.14), pentru a declara pointeri către funcții și funcții membre ale unei clase (vezi Secțiunea 13.6).
Mai jos este un exemplu de întrebare la care aproape toată lumea răspunde incorect. Eroarea este cauzată de o înțelegere greșită a directivei typedef ca o simplă substituție de macro-text.

Definitie data:

Typedef char *cstring;

Care este tipul variabilei cstr din următoarea declarație:

Extern const cstring cstr;

Răspunsul care pare evident este:

Const char *cstr

Cu toate acestea, acest lucru nu este adevărat. Specificatorul const se referă la cstr, deci răspunsul corect este un pointer const către char:

Char *const cstr;

3.13. specificator volatil
Un obiect este declarat volatil dacă valoarea sa poate fi schimbată fără ca compilatorul să observe, cum ar fi o variabilă actualizată de ceasul sistemului. Acest specificator îi spune compilatorului că nu trebuie să optimizeze codul pentru a lucra cu acest obiect.

Specificatorul volatil este utilizat în mod similar cu specificatorul const:

Volatil int disp1ay_register; sarcină volatilă *curr_task; volatile int ixa[ max_size ]; Ecran volatil bitmap_buf;
display_register este un obiect volatil de tip int. curr_task este un pointer către un obiect volatil din clasa Task. ixa este o matrice instabilă de numere întregi și fiecare element al unei astfel de matrice este considerat instabil. bitmap_buf este un obiect volatil al clasei Screen, fiecare dintre membrii săi de date fiind, de asemenea, considerat volatil.

Singurul scop al utilizării specificatorului volatil este de a spune compilatorului că nu poate determina cine poate schimba valoarea unui anumit obiect și cum.

Prin urmare, compilatorul nu ar trebui să efectueze optimizări pe codul care utilizează acest obiect.

#include

3.14. pereche de clasă

Clasa de perechi a bibliotecii standard C++ ne permite să definim o pereche de valori cu un singur obiect dacă există vreo conexiune semantică între ele.< string, string >Aceste valori pot fi aceleași sau diferite. Pentru a utiliza această clasă trebuie să includeți fișierul antet:

De exemplu, instrucțiuni
Pereche

autor(„James”, „Joyce”);
Joyce.second == „Joyce”)
prima carte = „Stephen Hero”;

Dacă trebuie să definiți mai multe obiecte de același tip din această clasă, este convenabil să utilizați directiva typedef:

Typedef pereche< string, string >Autorii; Autori proust("marcel", "proust"); Autorii joyce ("James", "Joyce"); Autori musil("robert", "musi1");

Iată un alt exemplu de utilizare a unei perechi. Prima valoare conține numele unui obiect, a doua este un pointer către elementul tabelului corespunzător acestui obiect.

Clasa EntrySlot; extern EntrySlot* 1ook_up(string); pereche typedef< string, EntrySlot* >SymbolEntry; SymbolEntry current_entry ("autor", 1ook_up ("autor"));
// ... dacă (EntrySlot *it = 1ook_up("editor")) (
current_entry.first = "editor";
current_entry.second = it;
}

(Vom reveni la clasa perechi când vorbim despre tipurile de containere în Capitolul 6 și despre algoritmi generici în Capitolul 12.)

3.15. Tipuri de clasă

Mecanismul de clasă vă permite să creați noi tipuri de date; cu ajutorul acestuia au fost introduse tipurile de șir, vector, complex și pereche discutate mai sus. În Capitolul 2, am introdus conceptele și mecanismele care suportă abordările orientate pe obiecte și pe obiecte, folosind clasa Array ca exemplu. Aici, pe baza abordării obiectului, vom crea o clasă String simplă, a cărei implementare ne va ajuta să înțelegem, în special, supraîncărcarea operatorului - am vorbit despre aceasta în secțiunea 2.3. (Clasele sunt tratate în detaliu în capitolele 13, 14 și 15.) Am oferit o scurtă descriere a clasei pentru a oferi exemple mai interesante. Un cititor nou în C++ ar putea dori să sări peste această secțiune și să aștepte o descriere mai sistematică a claselor în capitolele ulterioare.)
Clasa noastră String trebuie să accepte inițializarea de către un obiect din clasa String, un literal șir și un tip de șir încorporat, precum și operația de atribuire a valorilor acestor tipuri. Folosim constructori de clasă și un operator de atribuire supraîncărcat pentru aceasta. Accesul la caracterele String individuale va fi implementat ca o operație de index supraîncărcat. În plus, vom avea nevoie de: funcția size() pentru a obține informații despre lungimea șirului; operația de comparare a obiectelor de tip String și a unui obiect String cu un șir de tip încorporat; precum și operațiunile I/O ale obiectului nostru. În cele din urmă, implementăm capacitatea de a accesa reprezentarea internă a șirului nostru ca tip de șir încorporat.
O definiție de clasă începe cu cuvântul cheie class, urmat de un identificator - numele clasei sau tipul. În general, o clasă este formată din secțiuni precedate de cuvintele public (deschis) și privat (închis). O secțiune publică conține de obicei un set de operații suportate de clasă, numite metode sau funcții membre ale clasei. Aceste funcții membre definesc interfața publică a clasei, cu alte cuvinte, setul de acțiuni care pot fi efectuate asupra obiectelor acelei clase. O secțiune privată include de obicei membri de date care oferă implementare internă. În cazul nostru, membrii interni includ _string - un pointer către un caracter, precum și _size de tip int. _size va stoca informații despre lungimea șirului, iar _string va fi o matrice de caractere alocată dinamic. Iată cum arată o definiție de clasă:

#include clasa String; operator istream&>>(istream&, String&);
ostream& operator<<(ostream&, const String&); class String {
public:
// set de constructori
// pentru inițializare automată
// String strl; // String()
// String str2("literal"); // String(const char*);
// String str3(str2); // String(const String&);
Şir();
String(const char*);
String(const String&);
// distrugător
~String();
// operatori de atribuire
// strl = str2
// str3 = "un șir literal" String& operator=(const String&);
String& operator=(const char*);
// operatori de testare a egalității
// strl == str2;
// str3 == "un șir literal";
operator bool==(const String&);
operator bool==(const char*);
}

// supraîncărcarea operatorului de acces prin index

// strl[ 0 ] = str2[ 0 ];

operator char&(int);
// acces la membrii clasei

int size() ( returnează _size; )

char* c_str() ( return _string; ) privat:

int_size;

char *_string;

Clasa String are trei constructori. După cum sa discutat în Secțiunea 2.3, mecanismul de supraîncărcare vă permite să definiți mai multe implementări ale funcțiilor cu același nume, atâta timp cât toate diferă în numărul și/sau tipurile parametrilor lor.

Primul constructor

Este constructorul implicit, deoarece nu necesită o valoare inițială explicită. Când scriem:
Pentru str1, un astfel de constructor este numit.

Cei doi constructori rămași au fiecare câte un parametru. Da, pentru

Acest lucru va provoca o eroare de compilare, deoarece nu există un constructor cu un parametru de tip int.
O declarație de operator supraîncărcată are următorul format:

Operator tip_return op(lista_parametri);

Unde operator este un cuvânt cheie, iar op este unul dintre operatorii predefiniti: +, =, == și așa mai departe. (Consultați Capitolul 15 pentru o definiție precisă a sintaxei.) Iată declarația operatorului de index supraîncărcat:

operator Char&(int);

Acest operator are un singur parametru de tip int și returnează o referință la un caracter.
Un operator supraîncărcat poate fi el însuși supraîncărcat dacă listele de parametri ale instanțiilor individuale diferă. Pentru clasa noastră String, vom crea doi operatori diferiți de atribuire și egalitate.

Pentru a apela o funcție de membru, utilizați operatorii de acces membru punct (.) sau săgeata (->). Să avem declarații de obiecte de tip String:
obiect șir ("Danny");
String *ptr = new String("Anna");
matrice de șiruri;
Iată cum arată un apel la size() pe aceste obiecte: vector

dimensiuni (3);
// membru de acces pentru obiecte (.); // obiectele au o dimensiune de 5 dimensiuni[ 0 ] = object.size(); // acces membru pentru pointeri (->)
// ptr are dimensiunea 4
sizes[ 1 ] = ptr->size(); // acces membru (.)
// tabloul are dimensiunea 0

sizes[ 2 ] = array.size();
Returnează 5, 4 și, respectiv, 0.

Operatorii supraîncărcați sunt aplicați unui obiect în același mod ca și operatorii obișnuiți:
Nume șir ("Yadie"); String name2 ("Yodie"); // operator bool==(const String&)
dacă (nume == nume2)
întoarcere;
altfel
// String& operator=(const String&)

nume = nume2;

O declarație de funcție membru trebuie să fie în interiorul unei definiții de clasă, iar o definiție a funcției poate fi în interiorul sau în afara unei definiții de clasă. (Atât funcțiile size() cât și c_str() sunt definite în interiorul unei clase.) Dacă o funcție este definită în afara unei clase, atunci trebuie să specificăm, printre altele, cărei clase îi aparține.
În acest caz, definiția funcției este plasată în fișierul sursă, să spunem String.C, iar definiția clasei în sine este plasată în fișierul antet (String.h în exemplul nostru), care trebuie inclus în sursă. :
#include
// conținutul fișierului sursă: String.C // activând definirea clasei String
#include "String.h" // include definiția funcției strcmp().
bool // returnează tipul
String:: // clasa căreia îi aparține funcția
{
operator== // numele funcției: operator de egalitate
(const String &rhs) // listă de parametri
if (_size != rhs._size)
returnează fals;
}

Reamintim că strcmp() este o funcție de bibliotecă standard C Compară două șiruri de caractere încorporate, returnând 0 dacă șirurile sunt egale și diferite de zero dacă șirurile nu sunt egale. Operatorul condiționat (?:) testează valoarea înainte de semnul întrebării. Dacă este adevărată, valoarea expresiei din stânga două puncte este returnată, în caz contrar, valoarea din dreapta este returnată. În exemplul nostru, valoarea expresiei este falsă dacă strcmp() a returnat o valoare diferită de zero și adevărată dacă a returnat o valoare zero. (Operatorul condiționat este discutat în secțiunea 4.7.)
Operația de comparare este folosită destul de des, funcția care o implementează s-a dovedit a fi mică, așa că este util să declarați această funcție încorporată (inline). Compilatorul înlocuiește textul funcției în loc să o apeleze, astfel încât să nu se piardă timp la un astfel de apel. (Funcțiile încorporate sunt discutate în Secțiunea 7.6.) O funcție membru definită într-o clasă este încorporată implicit. Dacă este definit în afara clasei, pentru a o declara încorporată, trebuie să utilizați cuvântul cheie inline:

Inline bool String::operator==(const String &rhs) ( // același lucru)

Definiția unei funcții încorporate trebuie să fie în fișierul antet care conține definiția clasei. Prin redefinirea operatorului == ca operator inline, trebuie să mutăm textul funcției în sine din fișierul String.C în fișierul String.h.
Următoarea este implementarea operației de comparare a unui obiect String cu un tip șir încorporat:

Inline bool String::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

Numele constructorului este același cu numele clasei. Se consideră că nu returnează o valoare, deci nu este nevoie să specificați o valoare returnată nici în definiția sa, nici în corpul său. Pot exista mai mulți constructori. Ca orice altă funcție, acestea pot fi declarate inline.

#include // constructor implicit inline String::String()
{
_dimensiune = 0;
_șir = 0;
) inline String::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) else ( _size = str1en(str); strcpy(_string, str); ) // copiere constructor
inline String::String(const String &rhs)
{
dimensiune = rhs._size;
dacă (! rhs._string)
_șir = 0;
altceva(
_string = new char[ _size + 1 ];
} }

Deoarece am alocat dinamic memorie folosind noul operator, trebuie să o eliberăm apelând delete atunci când nu mai avem nevoie de obiectul String. O altă funcție specială membru servește acestui scop - destructorul, care este apelat automat pe un obiect în momentul în care acest obiect încetează să existe. (Vezi capitolul 7 despre durata de viață a obiectului.) Numele unui destructor este format din caracterul tilde (~) și numele clasei. Iată definiția destructorului de clasă String. Aici apelăm operația de ștergere pentru a elibera memoria alocată în constructor:

Șir inline: :~String() ( șterge _șirul; )

Ambii operatori de atribuire supraîncărcați folosesc cuvântul cheie special this.
Când scriem:

String namel("orville"), name2("wilbur");
nume = "Orville Wright";
acesta este un pointer care se adresează obiectului name1 din corpul funcției operației de atribuire.
aceasta indică întotdeauna obiectul de clasă prin care este apelată funcția.
Dacă
ptr->size();

obj[ 1024 ];

Apoi, în interiorul size() valoarea acesteia va fi adresa stocată în ptr. În cadrul operației de index, aceasta conține adresa obj. Dereferențând acest lucru (folosind *this), obținem obiectul în sine. (Acest indicator este descris în detaliu în Secțiunea 13.4.)

Inline String& String::operator=(const char *s) ( if (! s) ( _size = 0; delete _string; _string = 0; ) else ( _size = str1en(s); delete _string; _string = new char[ _size + 1 ]; strcpy(_string, s);

La implementarea unei operațiuni de atribuire, o greșeală care se face adesea este că ei uită să verifice dacă obiectul copiat este același în care este făcută copia. Vom efectua această verificare folosind același indicator:

Inline String& String::operator=(const String &rhs) ( // în expresia // namel = *pointer_to_string // aceasta reprezintă name1, // rhs - *pointer_to_string. if (acest != &rhs) (

Iată textul complet al operației de atribuire a unui obiect de același tip unui obiect String:
_șir = 0;
altceva(
_string = new char[ _size + 1 ];
Inline String& String::operator=(const String &rhs) ( dacă (acest != &rhs) ( șterge _string; _size = rhs._size; dacă (! rhs._string)
}
}
strcpy(_string, rhs._string);
}

returnează *aceasta;

#include Operația de preluare a unui index este aproape identică cu implementarea sa pentru matricea Array pe care am creat-o în secțiunea 2.3:
inline char&
{
String::operator (int elem)< _size);
assert(elem >= 0 && elem
}

Operatorii de intrare și de ieșire sunt implementați ca funcții separate, mai degrabă decât membri de clasă.

#include (Vom vorbi despre motivele acestui lucru în Secțiunea 15.2. Secțiunile 20.4 și 20.5 vorbesc despre supraîncărcarea operatorilor de intrare și de ieșire ai bibliotecii iostream.) Operatorul nostru de intrare poate citi maximum 4095 de caractere. setw() este un manipulator predefinit, citește un număr dat de caractere minus 1 din fluxul de intrare, asigurându-ne astfel că nu ne depășim tamponul intern inBuf. (Capitolul 20 discută manipulatorul setw() în detaliu.) Pentru a utiliza manipulatoare, trebuie să includeți fișierul antet corespunzător:

operator istream& inline>>(istream &io, String &s) ( // limită artificială: 4096 caractere const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() este inclus în biblioteca iostream // limitează dimensiunea blocul citibil la 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf s = mBuf // String::operator=(const char*);<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

Operatorul de ieșire are nevoie de acces la reprezentarea internă a șirului.<<(ostream& os, const String &s) { return os << s.c_str(); }

Din moment ce operator

#include Ostream și operator inline
Mai jos este un exemplu de program folosind clasa String. Acest program preia cuvinte din fluxul de intrare și numără numărul lor total, precum și numărul de cuvinte „the” și „it” și înregistrează vocalele întâlnite.
#include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / Cuvintele „The” și „It”
// vom verifica folosind operator==(const char*)
String dar, the("the"), it("it");<<(ostream&, const String&)
cout<< buf << " "; if (wdCnt % 12 == 0)
cout<< endl; // String::operator==(const String&) and
// operator>>(ostream&, String&)
în timp ce (cin >> buf) (
++wdCnt;
// operator
// String::operator==(const char*);
dacă (buf == the | | buf == "The")
++theCnt;< buf.sizeO; ++ix)
{
altfel
if (buf == it || buf == "It")
{
++itCnt;
// invocă String::s-ize()
pentru (int ix =0; ix
// invocă String::operator(int)
comutați (buf[ix])
case "a": caz "A": ++aCnt; pauză;
}
}
case "e": caz "E": ++eCnt; pauză;<<(ostream&, const String&)
cout<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

case "i": caz "I": ++iCnt; pauză;

Alice Emma are părul lung și roșcat. Tatăl ei spune că atunci când vântul îi bate prin păr, pare aproape viu, ca o pasăre de foc în zbor. O pasăre frumoasă de foc, îi spune el, magică, dar neîmblânzită. „Tati, taci, nu există așa ceva”, îi spune ea, dorind în același timp să-i spună mai multe. Sfioasă, ea întreabă: „Vreau să spun, tati, este acolo?” Cuvinte: 65
cel/Cele: 2
it/It: 1
consoane: 190
a: 22
e: 30
eu: 24
o: 10
u:7

Exercițiul 3.26

Implementările noastre de constructori și operatori de atribuire conțin multă repetiție. Luați în considerare mutarea codului duplicat într-o funcție separată de membru privat, așa cum sa făcut în Secțiunea 2.3. Asigurați-vă că noua opțiune funcționează.

Exercițiul 3.27

Modificați programul de testare astfel încât să numere și consoanele b, d, f, s, t.

Exercițiul 3.28

Scrieți o funcție membru care numără numărul de apariții ale unui caracter într-un șir folosind următoarea declarație:

Class String ( public: // ... int count(char ch) const; // ... );

Exercițiul 3.29

Implementați operatorul de concatenare a șirurilor (+) astfel încât să concateneze două șiruri și să returneze rezultatul într-un nou obiect String. Iată declarația funcției:

Clasa String ( public: // ... String operator+(const String &rhs) const; // ... );

Variabilele sunt folosite pentru a stoca diverse date în limbaje de programare. O variabilă este o zonă de memorie care are un nume, altfel numit identificator.

Dând un nume unei variabile, programatorul numește în același timp zona de memorie în care valorile variabilei vor fi scrise pentru stocare.

Este un stil bun să numești variabilele în mod semnificativ. Este permisă utilizarea literelor mici și mari, a cifrelor și a liniuței de subliniere, care este considerată o literă în C. Primul caracter trebuie să fie o literă și nu trebuie să existe spații în numele variabilei. În versiunile moderne ale compilatoarelor, lungimea numelui este practic nelimitată. Numele variabilei nu poate corespunde cuvintelor cheie rezervate. Literele mari și mici din numele variabilelor sunt diferite, variabile AȘi A- variabile diferite.

Cuvinte cheie rezervate auto double int struct break else lung comutare registru tupedef char extern return void case float unsigned implicit pentru uniunea semnată do if sizeof volatile continue enumerarea scurtă
În C, toate variabilele trebuie declarate. Aceasta înseamnă că, în primul rând, la începutul fiecărui program sau funcție trebuie să furnizați o listă cu toate variabilele utilizate și, în al doilea rând, să indicați tipul fiecăreia dintre ele.

Când o variabilă este declarată, compilatorul îi alocă spațiu de memorie în funcție de tipul acesteia. AVR GCC lucrează cu tipuri de date folosind instrumente standard caz(tip de caracter) și int(tip întreg).

Tastați char

caz- este cel mai economic tip. Tipul de caracter poate fi semnat sau nesemnat. Notat în consecință ca „ semnat char„ (tip semnat) și „ nesemnat char" (tip nesemnat). Tipul semnat poate stoca valori în intervalul de la -128 la +127. Unsigned - de la 0 la 255. O variabilă char are 1 octet de memorie (8 biți).

Cuvinte cheie (modificatoare) semnatȘi nesemnat indicați modul în care este interpretat bitul zero al variabilei declarate, adică dacă este specificat cuvântul cheie fără semn, atunci bitul zero este interpretat ca parte a unui număr, în caz contrar bitul zero este interpretat ca semnat.

Tastați int

Valoare intreaga int Pot fi Inregistreaza-te(scurt) sau dacă(lung).

Cuvânt cheie (modificator) Inregistreaza-te plasat după cuvinte cheie semnat sau nesemnat. Astfel, se disting următoarele tipuri: signed short int, unsigned short int, signed long int, unsigned long int.

Variabila de tip semnat scurt int(întreg scurt cu semn) poate lua valori de la -32768 la +32767, nesemnat scurt int(întreg scurt fără semn) - de la 0 la 65535. Pentru fiecare dintre ei sunt alocați exact doi octeți de memorie (16 biți).

La declararea unei variabile de tip semnat scurt int Cuvinte cheie semnatȘi Inregistreaza-te poate fi omis, iar un astfel de tip de variabilă poate fi declarat simplu int. De asemenea, este posibil să declarați acest tip cu un singur cuvânt cheie Inregistreaza-te.

Variabil nesemnat scurt int poate fi declarat ca nesemnat int sau scurt nesemnat.

Pentru fiecare dimensiune semnat lung int sau nesemnat lung int Sunt alocați 4 octeți de memorie (32 de biți). Valorile variabilelor de acest tip pot fi în intervalele de la -2147483648 la 2147483647 și, respectiv, de la 0 la 4294967295.

Există și variabile precum lung lung int, pentru care sunt alocați 8 octeți de memorie (64 de biți). Ele pot fi, de asemenea, semnate sau nesemnate. Pentru un tip semnat, intervalul de valori este de la -9223372036854775808 la 9223372036854775807, pentru un tip nesemnat - de la 0 la 18446744073709551615. Un tip semnat poate fi declarat pur și simplu prin două cuvinte cheie lung lung.

Variabilele sunt declarate într-o declarație. O instrucțiune de declarație constă dintr-o specificație de tip și o listă de nume de variabile separate prin virgulă. Trebuie să existe un punct și virgulă la sfârșit.

O declarație de variabilă are următorul format:

[modificatoare] type_specifier identificator [, identificator] ...

Modificatori- Cuvinte cheie semnat, nesemnat, Inregistreaza-te, dacă.
Specificator de tip- cuvânt cheie caz sau int, care determină tipul variabilei declarate.
Identificator- numele variabilei.

Exemplu: char x;
int a, b, c; nesemnat long long y;, A, În acest fel variabilele vor fi declarate, X, b c nesemnat long long y; y A, În acest fel variabilele vor fi declarate, X. La o variabilă b se vor putea scrie valori de la -128 la 127. În variabile

- de la -32768 la +32767. La o variabilă

- de la 0 la 18446744073709551615. nesemnat long long y; Inițializarea valorii unei variabile la declarare

Când este declarată, o variabilă poate fi inițializată, adică i se poate atribui o valoare inițială. Puteți face acest lucru după cum urmează.

Când este anunțat, numărul 100 va fi imediat notat. char Este mai bine să evitați amestecarea variabilelor inițializate într-o singură declarație, adică este mai bine să declarați variabilele inițializate pe linii separate. char constante char O variabilă de orice tip poate fi declarată nemodificabilă. Acest lucru se realizează prin adăugarea cuvântului cheie int sau lung int la specificatorul de tip. Variabile cu tip int sunt date numai pentru citire, ceea ce înseamnă că variabilei nu i se poate atribui o nouă valoare. Dacă după cuvânt lung int.

Dacă nu există un specificator de tip, atunci constantele sunt tratate ca valori semnate și li se atribuie un tip în funcție de valoarea constantei: dacă constanta este mai mică de 32768, atunci i se atribuie tipul, in caz contrar Exemplu: const long int k = 25;

// implicit const int m=-50

const n = 100000;
// implicit const long int n=100000

Misiune Semnul „=" este folosit pentru atribuire în C. Se evaluează expresia din dreapta semnului de atribuire, iar valoarea rezultată este atribuită variabilei din stânga semnului de atribuire. În acest caz, valoarea anterioară stocată în variabilă este ștearsă și înlocuită cu una nouă. Operatorul „=" nu trebuie înțeles ca egalitate. De exemplu, expresia a = 5; ar trebui citit ca „atribuiți variabila a la 5”. Exemple: x = 5 + 3; // adăugați 2 la valoarea stocată în variabila b, // atribuiți rezultatul rezultat variabilei b (scrieți variabilei b)
În partea dreaptă, valoarea variabilei poate fi folosită de mai multe ori: c = b * b + 3 * b;

Exemplu: x = 3; // variabilei x i se va atribui valoarea 3 y = x + 5; // numărul 5 va fi adăugat la valoarea stocată în variabila x, // rezultatul rezultat va fi scris în variabila y z = x * y; // valorile variabilelor x și y vor fi înmulțite, // rezultatul va fi scris în variabila z z = z - 1; // 1 va fi scăzut din valoarea stocată în variabila z // rezultatul va fi scris în variabila z
Astfel, în variabila z numărul 23 va fi stocat

Pe lângă operatorul simplu de atribuire „=", există mai mulți operatori de atribuire combinați în C: „+=", "-=", "*=
Exemple: x += y; // la fel ca x = x + y; - se adaugă x și y // și se scrie rezultatul la variabila x x -= y; // la fel ca x = x - y; - se scade valoarea y din x // si se scrie rezultatul in variabila x x *= y; // la fel ca x = x * y; - înmulțiți x cu y // și scrieți rezultatul în variabila x x /= y; // la fel ca x = x / y; - împărțiți x la y // și scrieți rezultatul în variabila x x %= y; // la fel ca x = x % y;

Creșteți și descreșteți Dacă trebuie să modificați valoarea unei variabile la 1, atunci utilizați sau creştere.

scăderea Creştere

- operația de creștere a valorii stocate într-o variabilă cu 1. Exemplu: x++;// valoarea variabilei x va fi mărită cu 1
$WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?> Decrementează

- operația de scădere a valorii stocate într-o variabilă cu 1. Exemplu: x--;
// valoarea variabilei x va fi redusă cu 1

Creșterea și descreșterea sunt operatori de atribuire. Când utilizați decrementarea și creșterea împreună cu operatorul de atribuire "=", utilizați notația postfix (x++) sau prefix (++x). Prefixul este executat mai întâi.
Exemple: y = x++; nesemnat long long y; Să presupunem că în variabilă b valoarea 5 a fost stocată nesemnat long long y; se va scrie valoarea 5, după care valoarea variabilei b va fi majorat cu 1. Astfel, in nesemnat long long y; va fi 5, iar în
- 6. y = --x; nesemnat long long y; Dacă în nesemnat long long y; Dacă valoarea 5 a fost stocată, atunci decrementarea va fi efectuată mai întâi b la 4 și apoi această valoare va fi atribuită variabilei nesemnat long long y;Și b. Prin urmare,

i se va atribui valoarea 4.

Tipurile de date sunt deosebit de importante în C#, deoarece este un limbaj puternic tipizat. Aceasta înseamnă că toate operațiunile sunt supuse unei verificări stricte de tip de către compilator, iar operațiunile ilegale nu sunt compilate. În consecință, verificarea strictă a tipului elimină erorile și crește fiabilitatea programelor. Pentru a impune verificarea tipului, toate variabilele, expresiile și valorile trebuie să fie de un anumit tip. Nu există deloc o variabilă „fără tip” în acest limbaj de programare. Mai mult, tipul unei valori determină operațiunile care pot fi efectuate asupra acesteia. O operațiune care este legală pentru un tip de date poate să nu fie valabilă pentru altul.

Există două categorii generale de tipuri de date încorporate în C#: tipuri de valoriȘi tipuri de referință. Ele diferă în conținutul variabilei. Din punct de vedere conceptual, diferența dintre cele două este că un tip de valoare stochează date direct, în timp ce un tip de referință stochează o referință la o valoare.

Aceste tipuri sunt stocate în diferite locații din memorie: tipurile de valori sunt stocate într-o zonă cunoscută sub numele de stivă, iar tipurile de referință sunt stocate într-o zonă cunoscută sub numele de heap gestionat.

Hai să aruncăm o privire tipuri de valori.

Tipuri întregi

C# definește nouă tipuri de numere întregi: char, byte, sbyte, short, ushort, int, uint, long și ulong. Dar tipul char este folosit în primul rând pentru a reprezenta caractere și, prin urmare, este tratat separat. Restul de opt tipuri de numere întregi sunt pentru calcule numerice. Mai jos sunt gama lor de numere și adâncimea de biți:

După cum arată tabelul de mai sus, C# definește atât variante semnate, cât și nesemnate ale diferitelor tipuri de numere întregi. Tipurile de numere întregi semnate diferă de omologii lor nesemnați în modul în care interpretează cel mai semnificativ bit al întregului. Astfel, dacă un program specifică o valoare întreagă cu semn, compilatorul C# va genera cod care folosește cel mai semnificativ bit al întregului ca indicator de semn. Un număr este considerat pozitiv dacă semnul este 0 și negativ dacă este 1.

Numerele negative sunt aproape întotdeauna reprezentate prin metoda complementului a două, prin care toate cifrele binare ale numărului negativ sunt mai întâi inversate și apoi 1 este adăugat la acel număr.

Probabil cel mai comun tip de număr întreg în programare este tip int. Variabilele de tip int sunt adesea folosite pentru controlul buclei, indexarea matricei și calcule matematice de uz general. Când aveți nevoie de o valoare întreagă cu o gamă mai mare de reprezentări numerice decât tipul int, există o serie de alte tipuri întregi disponibile în acest scop.

Deci, dacă valoarea trebuie stocată fără semn, atunci puteți selecta pentru aceasta tip uint, pentru valori mari semnate - tip lung, iar pentru valori mari nesemnate - tip ulong. Ca exemplu, mai jos este un program care calculează distanța de la Pământ la Soare în centimetri. Pentru a stoca o valoare atât de mare, folosește o variabilă lungă:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( clasa Program ( static void Main(string args)) ( rezultat lung; const long km = 149800000; // distanță în km. rezultat = km * 1000 * 100; Console.WriteLine (rezultat); Console.ReadLine(); ) ) )

Tuturor variabilelor întregi li se pot atribui valori în notație zecimală sau hexazecimală. În acest din urmă caz, este necesar un prefix 0x:

Long x = 0x12ab;

Dacă există vreo incertitudine dacă o valoare întreagă este de tip int, uint, long sau ulong, atunci Mod implicit int este acceptat. Pentru a specifica în mod explicit ce alt tip întreg ar trebui să aibă o valoare, următoarele caractere pot fi adăugate unui număr:

Uint ui = 1234U; lung l = 1234L; ulong ul = 1234UL;

U și L pot fi scrise și cu litere mici, deși un L mic poate fi ușor confundat vizual cu numărul 1 (unu).

Tipuri în virgulă mobilă

Tipurile cu virgulă mobilă vă permit să reprezentați numere cu o parte fracțională. Există două tipuri de tipuri de date în virgulă mobilă în C#: plutiȘi dubla. Ele reprezintă valori numerice cu precizie simplă și, respectiv, dublă. Astfel, lățimea tipului float este de 32 de biți, ceea ce corespunde aproximativ intervalului de reprezentare a numerelor de la 5E-45 la 3.4E+38. Și lățimea tipului dublu este de 64 de biți, ceea ce corespunde aproximativ intervalului de reprezentare a numerelor de la 5E-324 la 1.7E+308.

Tipul de date float este destinat valorilor mai mici în virgulă mobilă care necesită mai puțină precizie. Tipul de date dublu este mai mare decât float și oferă un grad mai mare de precizie (15 biți).

Dacă în codul sursă este codificată o valoare non-întreg (de exemplu, 12.3), atunci compilatorul presupune de obicei că este intenționată o valoare dublă. Dacă valoarea trebuie specificată ca un float, va trebui să îi adăugați caracterul F (sau f):

Float f = 12,3F;

Tip de date zecimal

De asemenea, este furnizat un tip zecimal pentru a reprezenta numere în virgulă mobilă de înaltă precizie. zecimal, care este destinat utilizării în calcule financiare. Acest tip are o lățime de 128 de biți pentru a reprezenta valori numerice cuprinse între 1E-28 și 7.9E+28. Probabil știți că aritmetica obișnuită în virgulă mobilă este predispusă la erori de rotunjire zecimală. Aceste erori sunt eliminate prin utilizarea tipului zecimal, care permite reprezentarea numerelor cu 28 (și uneori 29) zecimale. Deoarece acest tip de date poate reprezenta valori zecimale fără erori de rotunjire, este util în special pentru calculele financiare:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args)) ( // *** Calculul costului unei investiții cu *** // *** rata fixă ​​de rentabilitate*** zecimală bani, procent; int i; const byte ani = 15 bani = 1000.0m procente = 0.045m;

Rezultatul acestui program va fi:

Simboluri

În C#, caracterele sunt reprezentate nu în cod de 8 biți, ca în multe alte limbaje de programare, cum ar fi C++, ci în cod de 16 biți, numit Unicode. Setul de caractere Unicode este atât de larg încât acoperă caractere din aproape fiecare limbă naturală din lume. În timp ce multe limbi naturale, inclusiv engleză, franceză și germană, au alfabete relativ mici, unele alte limbi, cum ar fi chineza, folosesc seturi de caractere destul de mari care nu pot fi reprezentate printr-un cod de 8 biți. Pentru a depăși această limitare, C# definește tip char, care reprezintă valori nesemnate de 16 biți, cuprinse între 0 și 65.535. Cu toate acestea, setul de caractere ASCII standard de 8 biți este un subset de Unicode cuprins între 0 și 127. Prin urmare, caracterele ASCII sunt încă valabile în C#.

O diferență importantă între limbajul SI și alte limbi (PL1, FORTRAN etc.) este absența unui principiu implicit, ceea ce duce la necesitatea declarării explicite a tuturor variabilelor utilizate în program împreună cu indicarea tipurilor lor corespunzătoare. .

Declarațiile de variabile au următorul format:

[memory-class-specifier] descriptor de specificator de tip [=inițiator] [,descriptor [= inițiator] ]...

Un descriptor este un identificator pentru o variabilă simplă sau un construct mai complex cu paranteze pătrate, paranteze sau un asterisc (un set de asteriscuri).

Un specificator de tip este unul sau mai multe cuvinte cheie care determină tipul variabilei care este declarată. Limbajul SI are un set standard de tipuri de date, cu ajutorul cărora puteți construi noi tipuri de date (unice).

Inițiator - specifică valoarea inițială sau lista de valori inițiale care sunt atribuite variabilei atunci când este declarată.

Specificatorul clasei de memorie - definit de unul dintre cele patru cuvinte cheie SI: auto, extern, register, static și indică modul în care va fi alocată memoria pentru variabila declarată, pe de o parte, și, pe de altă parte, domeniul de aplicare al acestei variabile, adică din ce părți ale programului poate fi accesat.

1.2.1 Categorii de tipuri de date

Cuvinte cheie pentru definirea tipurilor de date de bază

Tipuri întregi: Tipuri flotante: char float int dublu scurt lung dublu lung semnat nesemnat

O variabilă de orice tip poate fi declarată nemodificabilă. Acest lucru se realizează prin adăugarea cuvântului cheie const la specificatorul de tip. Obiectele cu tipul const reprezintă date numai în citire, de exemplu. acestei variabile nu i se poate atribui o nouă valoare. Rețineți că, dacă nu există un specificator de tip după cuvântul const, atunci este implicat specificatorul de tip int. Dacă cuvântul cheie const vine înainte de declararea tipurilor compozite (matrice, structură, amestec, enumerare), atunci aceasta duce la faptul că fiecare element trebuie să fie, de asemenea, nemodificabil, adică. i se poate atribui o valoare o singură dată.

Const dublu A=2,128E-2;

const B=286; (const int B=286 este implicat)

Exemple de declarare a datelor compozite vor fi discutate mai jos.

Pentru a defini datele de tip întreg, sunt utilizate diverse cuvinte cheie, care determină intervalul de valori și dimensiunea zonei de memorie alocată pentru variabile (Tabelul 6).

Tabelul 6

Rețineți că cuvintele cheie semnate și nesemnate sunt opționale. Ele indică modul în care este interpretat bitul zero al variabilei declarate, adică dacă este specificat cuvântul cheie fără semn, atunci bitul zero este interpretat ca parte a unui număr, în caz contrar, bitul zero este interpretat ca semnat. Dacă cuvântul cheie nesemnat lipsește, variabila întreagă este considerată semnată. Dacă specificatorul de tip constă dintr-un tip de cheie semnat sau nesemnat urmat de un identificator de variabilă, atunci acesta va fi tratat ca o variabilă de tip int. De exemplu:

Unsigned int n;

unsigned int b;

int c; (semnatul int c este implicit);

nesemnat d; (implică int d nesemnat);

semnat f; (este subînțeles semnatul int f).

Rețineți că modificatorul de tip char este folosit pentru a reprezenta un caracter (dintr-o reprezentare matrice de caractere) sau pentru a declara literale șir. Valoarea unui obiect char este codul de 1 octet corespunzător caracterului pe care îl reprezintă. Pentru a reprezenta caracterele alfabetului rus, modificatorul tipului de identificare a datelor este caracter nesemnat, deoarece codurile literelor rusești depășesc valoarea de 127.

nesemnat d; (implică int d nesemnat);

Trebuie făcută următoarea notă: limbajul SI nu definește reprezentarea memoriei și intervalul de valori pentru identificatorii cu modificatorii de tip int și unsigned int. Mărimea memoriei pentru o variabilă cu modificatorul de tip int semnat este determinată de lungimea cuvântului mașină, care are o dimensiune diferită pe diferite mașini. Deci, pe mașinile pe 16 biți dimensiunea cuvântului este de 2 octeți, pe mașinile pe 32 de biți este de 4 octeți, adică. tipul int este echivalent cu tipurile short int sau long int, în funcție de arhitectura PC-ului utilizat. Astfel, același program poate funcționa corect pe un computer și incorect pe altul. Pentru a determina lungimea memoriei ocupate de o variabilă, puteți utiliza operatorul SI language sizeof, care returnează lungimea modificatorului de tip specificat.

1.2.3. Date flotante

Pentru variabilele care reprezintă un număr în virgulă mobilă, se folosesc următorii modificatori de tip: float, double, long double (în unele implementări ale limbajului long double nu există SI).

O valoare cu modificatorul de tip float are 4 octeți. Dintre aceștia, 1 octet este alocat pentru semn, 8 biți pentru excesul de exponent și 23 de biți pentru mantise. Rețineți că cel mai semnificativ bit al mantisei este întotdeauna 1, deci nu este completat, astfel încât intervalul de valori pentru o variabilă în virgulă mobilă este de aproximativ 3.14E-38 până la 3.14E+38.

O valoare dublă ocupă 8 biți în memorie. Formatul său este similar cu formatul float. Biții de memorie sunt distribuiți după cum urmează: 1 bit pentru semn, 11 biți pentru exponent și 52 de biți pentru mantise. Luând în considerare bitul înalt omis al mantisei, intervalul de valori este de la 1,7E-308 la 1,7E+308.

Float f, a, b;

dublu x,y;

1.2.4. Indicatoare

Un pointer este adresa memoriei alocată pentru a găzdui un identificator (identificatorul poate fi numele unei variabile, al unei matrice, al unei structuri sau al unui șir literal). Dacă o variabilă este declarată ca pointer, atunci aceasta conține o adresă de memorie unde poate fi localizată o valoare scalară de orice tip. Când declarați o variabilă de tip pointer, trebuie să specificați tipul de obiect de date a cărui adresă o va conține variabila și numele pointerului precedat de un asterisc (sau grup de asteriscuri). Formatul declarației pointerului:

tip-specificator [ modificator ] * specificator.

Cuvintele cheie const, near, far, huge pot fi folosite ca modificatori la declararea unui pointer. Cuvântul cheie const indică faptul că pointerul nu poate fi modificat în program. Mărimea unei variabile declarate ca pointer depinde de arhitectura computerului și de modelul de memorie utilizat pentru care programul va fi compilat. Indicatorii către diferite tipuri de date nu trebuie să aibă aceeași lungime.

Pentru a modifica dimensiunea indicatorului, puteți utiliza cuvintele cheie aproape, departe, imens.

Unsigned int * a; /* variabila a este un pointer pentru a tasta unsigned int */ double * x; /* variabila x indică tipul de date în virgulă mobilă cu precizie dublă */ char * fuffer ; /* declară un pointer numit fuffer care indică o variabilă de tip char */ double nomer;

void *adrese;

adrese = &nomer;

(dublu *)adresa++;

/* Variabila adresa este declarată ca un pointer către un obiect de orice tip.

Prin urmare, i se poate atribui adresa oricărui obiect (& este operația de calcul a adresei). Cu toate acestea, după cum sa menționat mai sus, nicio operație aritmetică nu poate fi efectuată pe un pointer decât dacă tipul de date către care indică este determinat în mod explicit. Acest lucru se poate face folosind o operație de turnare (double *) pentru a converti adresa într-un pointer pentru a tasta double și apoi incrementând adresa. */ const * dr;

/* Variabila dr este declarată ca un pointer către o expresie constantă, i.e. Valoarea unui pointer se poate modifica în timpul execuției programului, dar valoarea la care indică nu poate. */ unsigned char * const w = &obj.

O variabilă de tip enumerare poate lua valoarea uneia dintre constantele numite ale listei. Constantele listei denumite sunt de tip int. Astfel, memoria corespunzătoare unei variabile de enumerare este memoria necesară pentru a găzdui o valoare int.

Variabilele de tip enum pot fi folosite în expresii de index și ca operanzi în operații aritmetice și relaționale.

În primul format 1, numele și valorile enumerate sunt specificate într-o listă de enumerare. Opțional enumeration-tag-name este un identificator care denumește eticheta de enumerare definită de lista de enumerare. Descriptorul denumește o variabilă de enumerare. Într-o declarație poate fi specificată mai mult de o variabilă de tip enumerare.

O listă de enumerare conține unul sau mai multe constructe de forma:

identificator [= expresie constantă]

Fiecare identificator denumește un element al enumerației. Toți identificatorii din lista de enumerare trebuie să fie unici. Dacă nu există o expresie constantă, primul identificator corespunde valorii 0, următorul identificator valorii 1 etc. Numele unei constante de enumerare este echivalent cu valoarea acesteia.

Un identificator asociat cu o expresie constantă ia valoarea specificată de acea expresie constantă. Expresia constantă trebuie să fie de tip int și poate fi fie pozitivă, fie negativă. Următorul identificator din listă i se atribuie valoarea expresiei constante plus 1 dacă acel identificator nu are propria sa expresie constantă. Utilizarea elementelor de enumerare trebuie să respecte următoarele reguli:

1. Variabila poate conține valori duplicat.

2. Identificatorii dintr-o listă de enumerare trebuie să fie distincți de toți ceilalți identificatori din același domeniu, inclusiv numele de variabile obișnuite și identificatorii din alte liste de enumerare.

3. Denumirile de tipuri de enumerare trebuie să fie distincte de alte denumiri de tipuri de enumerare, structuri și amestecuri din același domeniu.

4. Valoarea poate urma ultimul element al listei de enumerare.

Săptămâna enumerare ( SUB = 0, /* 0 */ VOS = 0, /* 0 */ POND, /* 1 */ VTOR, /* 2 */ SRED, /* 3 */ HETV, /* 4 */ PJAT /* 5 */ ) rab_ned ;

În acest exemplu, este declarată o săptămână etichetă enumerabilă, cu un set corespunzător de valori, iar o variabilă rab_ned este declarată de tipul săptămâni.

Al doilea format folosește numele etichetei enum pentru a se referi la un tip de enumerare definit în altă parte. Numele etichetei de enumerare trebuie să se refere la o etichetă de enumerare deja definită în domeniul curent. Deoarece eticheta de enumerare este declarată în altă parte, lista de enumerare nu este reprezentată în declarație.

În declararea unui pointer către un tip de date de enumerare și declararea typedefs pentru tipurile de enumerare, puteți utiliza numele unei etichete de enumerare înainte ca eticheta de enumerare să fie definită. Cu toate acestea, definiția de enumerare trebuie să preceadă orice utilizare a indicatorului declarației typedef către tip. O declarație fără o listă ulterioară de descriptori descrie o etichetă sau, ca să spunem așa, un model de enumerare.

1.2.6. Matrice

Matricele sunt un grup de elemente de același tip (double, float, int etc.). Din declarația matricei, compilatorul trebuie să obțină informații despre tipul elementelor matricei și numărul acestora. O declarație de matrice are două formate:

descriptor de specificator de tip [const - expresie];

descriptor al specificatorului de tip;

Descriptorul este identificatorul matricei.

Specificatorul de tip specifică tipul elementelor matricei declarate. Elementele de matrice nu pot fi funcții sau elemente void.

Expresia constantă între paranteze pătrate specifică numărul de elemente din matrice. Când se declară o matrice, o expresie constantă poate fi omisă în următoarele cazuri:

Când este declarată, matricea este inițializată,

Matricea este declarată ca parametru formal al funcției,

SI definește doar tablouri unidimensionale, dar deoarece un element al unei matrice poate fi o matrice, și tablourile multidimensionale pot fi definite. Ele sunt formalizate printr-o listă de expresii constante care urmează identificatorul de matrice, fiecare expresie constantă fiind inclusă în propriile paranteze pătrate.

Fiecare expresie constantă între paranteze pătrate specifică numărul de elemente de-a lungul acelei dimensiuni a matricei, astfel încât o declarație de matrice bidimensională conține două expresii constante, o matrice tridimensională conține trei și așa mai departe. Rețineți că în SI, primul element al unui tablou are un indice de 0.

Int a; /* reprezentat ca o matrice a a a a a a */ dublu b; /* vector de 10 elemente de tip double */ int w = ( ( 2, 3, 4 ), ( 3, 4, 8 ), ( 1, 0, 9 ) );

În ultimul exemplu, matricea w este declarată. Listele cuprinse între acolade corespund șirurilor de matrice, dacă nu există acolade, inițializarea nu va fi efectuată corect.

În limba SI, puteți utiliza secțiuni de matrice, ca și în alte limbi de nivel înalt (PL1 etc.), cu toate acestea, sunt impuse o serie de restricții privind utilizarea secțiunilor. Secțiunile sunt formate prin omiterea uneia sau mai multor perechi de paranteze pătrate. Perechile de paranteze pătrate pot fi aruncate numai de la dreapta la stânga și strict secvenţial. Secțiunile de matrice sunt folosite pentru a organiza procesul de calcul în funcții SI dezvoltate de utilizator.

Dacă scrieți s când apelați o funcție, atunci șirul zero al matricei s va fi transmis.

Când accesați o matrice b, puteți scrie, de exemplu, b și va fi transferat un vector de patru elemente, iar accesarea b va da o matrice bidimensională de dimensiunea 3 cu 4. Nu puteți scrie b, ceea ce implică faptul că un vector va fi transferat, deoarece aceasta nu respectă restricția impusă secțiunilor de matrice de utilizare.

Un exemplu de declarație de matrice de caractere.

char str = "declarație matrice de caractere";

Rețineți că mai există un element într-un caracter literal, deoarece ultimul element este secvența de escape „\0”.

1.2.7. Structuri

Structurile sunt un obiect compus care include elemente de orice tip, cu excepția funcțiilor. Spre deosebire de o matrice, care este un obiect omogen, o structură poate fi eterogenă. Tipul structurii este determinat de o intrare de forma:

struct (lista de definiții)

Cel puțin o componentă trebuie specificată în structură. Definiția structurilor este următoarea:

descriptor de tip de date;

unde tipul de date specifică tipul de structură pentru obiectele definite în descriptori. În forma lor cea mai simplă, mânerele sunt identificatori sau matrice.

Struct ( dublu x,y; ) s1, s2, sm;

struct (int year; char moth, day; ) data1, data2;

Variabilele s1, s2 sunt definite ca structuri, fiecare dintre acestea fiind formată din două componente x și y. Variabila sm este definită ca o matrice de nouă structuri. Fiecare dintre cele două variabile data1, data2 este formată din trei componente an, molie, zi. >p>Există o altă modalitate de a asocia un nume cu un tip de structură, se bazează pe utilizarea unei etichete de structură. O etichetă de structură este similară cu o etichetă de tip enumerare. Eticheta de structură este definită după cum urmează:

struct tag(lista descrierilor; );

unde eticheta este un identificator.

Exemplul de mai jos descrie identificatorul studentului ca o etichetă de structură:

Eticheta de structură este utilizată pentru a declara ulterior structuri de acest tip sub forma:

struct id-list tag;

struct studeut st1,st2;

Utilizarea etichetelor de structură este necesară pentru a descrie structuri recursive. În cele ce urmează, se discută utilizarea etichetelor de structură recursive.

Struct node ( int date; struct node * next; ) st1_node;

Nodul de etichetă de structură este într-adevăr recursiv, deoarece este folosit în propria sa descriere, de exemplu. în formalizarea următorului indicator. Structurile nu pot fi direct recursive, de exemplu. o structură de nod nu poate conține o componentă care este o structură de nod, dar orice structură poate avea o componentă care este un pointer către tipul său, așa cum se face în exemplul de mai sus.

Componentele structurii sunt accesate prin specificarea numelui structurii și a următoarelor, separate printr-un punct, numele componentei selectate, de exemplu:

St1.name="Ivanov";

st2.id=st1.id;

st1_node.data=st1.age;

1.2.8. Combinații (amestecuri)

O unire este similară cu o structură, dar numai unul dintre elementele unirii poate fi folosit (sau, cu alte cuvinte, la care se poate răspunde) în orice moment. Tipul de unire poate fi specificat după cum urmează:

Unire ( element 1 descriere; ... element n descriere; );

Caracteristica principală a unei uniuni este că aceeași zonă de memorie este alocată pentru fiecare dintre elementele declarate, de exemplu. se suprapun. Deși această regiune de memorie poate fi accesată folosind oricare dintre elemente, elementul în acest scop trebuie selectat astfel încât rezultatul obținut să nu fie lipsit de sens.

Membrii unui sindicat sunt accesați în același mod ca și structurile. Eticheta de unire poate fi formalizată exact în același mod ca eticheta de structură.

Asociația este utilizată în următoarele scopuri:

Inițializarea unui obiect de memorie în uz dacă la un moment dat doar unul dintre multe obiecte este activ;

Interpretați reprezentarea de bază a unui obiect de un tip ca și cum acel obiect i-ar fi fost atribuit un alt tip.

Când utilizați un obiect infor de tip unire, puteți procesa numai elementul care a primit valoarea, adică. După atribuirea unei valori elementului inform.fio, nu are rost să accesezi alte elemente. Concatenarea ua permite acces separat la octeții ua.al scăzut și ua.al ridicat ai numărului de doi octeți ua.ax .

1.2.9. Câmpuri de biți

Un element al structurii poate fi un câmp de biți care oferă acces la biți individuali de memorie. Câmpurile de biți nu pot fi declarate în afara structurilor. De asemenea, nu puteți organiza matrice de câmpuri de biți și nu puteți aplica operația de determinare a adresei la câmpuri. În general, tipul de structură cu un câmp de biți este specificat după cum urmează:

Struct (identificator nesemnat 1: lungime câmp 1; identificator nesemnat 2: lungime câmp 2; )

lungime - câmpurile sunt specificate printr-o expresie întreagă sau constantă. Această constantă specifică numărul de biți alocați câmpului corespunzător. Un câmp de lungime zero indică alinierea la următoarea limită a cuvântului.

Struct ( nesemnat a1: 1; nesemnat a2: 2; nesemnat a3: 5; nesemnat a4: 2; ) prim;

Structurile câmpurilor de biți pot conține și componente semnate. Astfel de componente sunt plasate automat pe granițele de cuvinte adecvate, iar unii biți de cuvinte pot rămâne neutilizați.

1.2.10. Variabile cu structură mutabilă

Foarte des, unele obiecte de program aparțin aceleiași clase, diferă doar în unele detalii. Luați în considerare, de exemplu, reprezentarea formelor geometrice. Informațiile generale despre forme pot include elemente precum suprafața, perimetrul. Cu toate acestea, informațiile corespunzătoare dimensiunilor geometrice pot diferi în funcție de forma lor.

Luați în considerare un exemplu în care informațiile despre formele geometrice sunt reprezentate pe baza utilizării combinate a structurii și unirii.

Struct figure ( suprafață dublă, perimetru; /* componente comune */ tip int; /* atribut component */ unire /* enumerarea componentelor */ ( rază dublă; /* cerc */ a dublu; /* dreptunghi */ b dublu ; /* triunghi */ ) geom_fig ) fig1, fig2;

În general, fiecare obiect figura va fi format din trei componente: zonă, perimetru, tip. Componenta de tip este numită etichetă de componentă activă deoarece este utilizată pentru a indica ce componentă a uniunii geom_fig este activă în prezent. Această structură se numește structură variabilă deoarece componentele sale se modifică în funcție de valoarea etichetei componentei active (valoarea tipului).

Rețineți că în loc de o componentă de tip int, ar fi recomandabil să utilizați un tip enumerat. De exemplu, așa

Enum figure_chess ( CERCUL, CUTIE, TRIANGUL ) ;

Constantele CIRCLE, BOX, TRIANGLE vor primi valori egale cu 0, 1, 2, respectiv Variabila de tip poate fi declarată ca având un tip enumerat:

enumerare figure_chess type;

În acest caz, compilatorul SI va avertiza programatorul despre atribuiri potențial eronate, cum ar fi

figură.tip = 40;

În general, o variabilă de structură va consta din trei părți: un set de componente comune, o etichetă pentru componenta activă și o parte cu componente în schimbare. Forma generală a unei structuri variabile este următoarea:

Struct (componente comune; etichetă componentă activă; unire (descrierea componentei 1; descrierea componentei 2; ::: descrierea componentei n; ) union-identifier; ) structura-identificator;

Exemplu de definire a unei variabile de structură numită helth_record

Struct ( /* informații generale */ nume de caracter ; /* nume */ vârstă; /* vârstă */ sex de caractere; /* gen */ /* etichetă componentă activă */ /* (starea civilă) */ enumerare starea_meritale ins ; /* parte variabilă */ uniune ( /* singur */ /* fără componentă */ struct ( /* căsătorit */ char nume_soț; int no_copii; ) informație_căsătorie; /* divorțat */ data_divorțată; ) informație_conjugală;

enum stare_conjugală ( SINGUR, /* singur */ MARRIGO, /* căsătorit */ DIVORAT /* divorțat */ ) ;

Puteți accesa componentele structurii folosind link-uri:

Helth_record.neme, helth_record.ins, helth_record.marriage_info.marriage_date .

1.2.11. Definirea obiectelor și a tipurilor

După cum sa menționat mai sus, toate variabilele utilizate în programele SI trebuie să fie declarate. Tipul de variabilă care este declarată depinde de cuvântul cheie folosit ca specificator de tip și dacă specificatorul este un identificator simplu sau o combinație de un identificator și un indicator (asterisc), matrice (paranteze) sau modificator de funcție (paranteze).

Să remarcăm o caracteristică importantă a limbajului SI: atunci când declarăm, mai mult de un modificator poate fi utilizat simultan, ceea ce face posibilă crearea multor descriptori de tip complex diferiți.

Cu toate acestea, trebuie să ne amintim că unele combinații de modificatori sunt inacceptabile:

Elementele matricei nu pot fi funcții.

Funcțiile nu pot returna matrice sau funcții.

La inițializarea descriptorilor complecși, parantezele pătrate și parantezele (în dreapta identificatorului) au prioritate față de asterisc (în stânga identificatorului). Pătratul sau parantezele au aceeași prioritate și sunt extinse de la stânga la dreapta. Specificatorul de tip este luat în considerare la ultimul pas, când descriptorul a fost deja interpretat complet. Puteți folosi parantezele pentru a modifica ordinea interpretării după cum este necesar.

Pentru interpretarea descrierilor complexe, se propune o regulă simplă care sună ca „din interior spre exterior” și constă din patru pași.

1. Începeți cu identificatorul și priviți în dreapta pentru a vedea dacă există pătrat sau paranteze.

2. Dacă sunt, atunci interpretați această parte a descriptorului și apoi priviți spre stânga în căutarea unui asterisc.

3. Dacă în orice stadiu se întâlnește o paranteză de închidere în dreapta, atunci toate aceste reguli trebuie mai întâi aplicate în interiorul parantezei și apoi interpretarea trebuie să continue.

4. Interpretați specificatorul de tip.

Int * (*) comp ) ();

6 5 3 1 2 4

Acest exemplu declară variabila comp (1) ca o matrice de zece (2) pointeri (3) la funcții (4) care returnează pointerii (5) la valori întregi (6).

Char * (* (*) var) ()) ;

7 6 4 2 1 3 5

Variabila var (1) este declarată ca un pointer (2) la o funcție (3) care returnează un pointer (4) la o matrice (5) de 10 elemente, care sunt pointeri (6) la valorile caracterului.

Rețineți că orice tip poate fi declarat folosind cuvântul cheie typedef, inclusiv tipurile pointer, funcție sau matrice. Un nume cu cuvântul cheie typedef pentru tipurile pointer, structură și unire poate fi declarat înainte ca acele tipuri să fie definite, dar în sfera declaratorului.

Typedef double(*MATH)();

/* MATH - nume de tip nou reprezentând un pointer către o funcție care returnează valori duble */ MATH cos;

/* cos pointer către o funcție care returnează valori de tip double */ /* Se poate face o declarație echivalentă */ double (* cos)();

typedef char FIO /* FIO - matrice de patruzeci de caractere */ FIO persoană;

/* Variabila person este o matrice de patruzeci de caractere */ /* Aceasta este echivalentă cu o declarație */ char person;

La declararea variabilelor și a tipurilor, aici au fost folosite numele de tip (MATH FIO). În plus, denumirile de tip pot fi folosite în alte trei cazuri: în lista de parametri formali, în declarațiile de funcții, în operațiunile de turnare a tipului și în dimensiunea operației (operație de turnare a tipului).

Numele de tip pentru tipurile de bază, enumerare, structură și amestec sunt specificatorii de tip pentru acele tipuri. Numele de tip pentru pointerul de matrice și tipurile de funcție sunt specificate folosind descriptori abstracti, după cum urmează:

descriptor-abstract-specificator-tip;

Un handler abstract este un handle non-identificator care constă dintr-unul sau mai mulți indicatori, matrice sau modificatori de funcție. Modificatorul pointerului (*) este dat întotdeauna înaintea identificatorului din descriptor, iar modificatorii de matrice și de funcție () sunt dați după acesta. Astfel, pentru a interpreta corect un descriptor abstract, trebuie să începem interpretarea cu identificatorul implicit.

Descriptorii abstracti pot fi complexi. Parantezele din descriptori abstracti complecși specifică ordinea interpretării într-un mod similar cu interpretarea descriptorilor complecși în declarații.

1.2.12. Inițializarea datelor

Când o variabilă este declarată, i se poate atribui o valoare inițială prin adăugarea unui inițiator la un declarator. Inițiatorul începe cu semnul „=" și are următoarele forme.

Format 1: = initiator;

Format 2: = (lista - inițiatori);

Formatul 1 este folosit la inițializarea variabilelor de tipuri și pointeri de bază, iar formatul 2 este utilizat la inițializarea obiectelor compuse.

O matrice bidimensională de valori întregi este inițializată; elementelor matricei li se atribuie valori din listă. Aceeași inițializare se poate face astfel:

static int b = ( ( 1,2 ), ( 3,4 ) );

Când inițializați o matrice, puteți omite unul sau mai multe dimensiuni

int static b)