Tipuri de date fundamentale

Valorile variabilelor sunt stocate undeva într-o locație neprecizată în memoria calculatorului
(adresele sunt numere în baza 16). Programul nostru nu are nevoie să știe care este locația exactă
unde este stocată o variabilă; o poate referi pur și simplu prin numele acesteia. Dar programul
trebuie să știe care este tipul de date stocate în variabilă. Nu e același lucru stocarea unui număr
întreg ca și stocarea unei litere sau a unui număr mare în virgulă mobilă; chiar dacă acestea sunt
toate reprezentate folosind cifre unu și zero, ele nu sunt interpretate în același mod și, în multe
cazuri, ele nu ocupă aceeași cantitate de memorie.

Tipurile de date fundamentale sunt tipuri de bază recunoscute direct de limbaj și reprezintă
unitățile de stocare de bază sprijinite nativ de cele mai multe sisteme. Acestea pot fi clasificate în
principal astfel:

 Tipuri caracter: Acestea pot reprezenta un singur caracter, cum ar fi 'A' sau '$'. Tipul

cel mai de bază este char, care este un caracter (reprezentat pe un octet). Alte tipuri sunt
de asemenea prevăzute de caractere mai largi.
 Tipuri numerice întregi: Ele pot stoca o valoare număr întreg, cum ar fi 7 sau 1024.
Există într-o mare varietate de dimensiuni și pot fi cu semn (signed)sau fără
semn(unsigned), în funcție de capacitatea de a suporta sau nu valori negative.
 Tipuri pentru numere zecimale: Pot reprezenta valori reale, cum ar fi 3.14 sau 0.01,
cu diferite grade de precizie; în funcție de aceasta se decide care dintre cele trei va fi
folosit.
 Tip boolean: Tipul boolean, cunoscut în C ++ ca bool, poate reprezenta date care iau
numai una din cele două stări: true sau false.

Aici este lista completă a tipurilor fundamentale în C ++:

Grup Numele tipurilor* Observații privind dimensiunea / precizia
char Exact un byte în dimensiune. Cel puțin 8 biți.
char16_t Nu mai mic decât char. Cel puțin 16 biți.
Tipuri caracter char32_t Nu mai mic decât char16_t.Cel puțin 32 biți.
Poate reprezenta cea mai mare mulțime de
wchar_t
caractere suportată.
signed char Acceași dimensiune ca și char. Cel puțin 8 biți.
signed short int Nu mai mic decât char. Cel puțin 16 biți.
Tipuri întregi cu
signed int Nu mai mic decât short. Cel puțin 16 biți.
semn(signed)
signed long int Nu mai mic decât int. Cel puțin 32 biți.
signed long long int Nu mai mic decât long. Cel puțin 64 biți.
unsigned char
unsigned short int
Tipuri întregi fără semn unsigned int (aceeași dimensiune ca și corespondentul cu
(unsigned) unsigned long int semn)
unsigned long
long int
Tipuri pentru numere float
zecimale double Precizie nu mai mică decât float
 long double Precizie nu mai mică decât double
Tip boolean bool
Tip vid void fără spațiu
Pointer nul decltype(nullptr)

În fiecare dintre grupele de mai sus, diferența dintre tipuri este doar dimensiunea lor (de
exemplu, cât de mult spațiu ocupă în memorie): primul tip din fiecare grup este cel mai mic, iar
ultimul este cel mai mare. Fiecare tip este cel puțin la fel de mare ca și cel precedent din cadrul
aceluiași grup, excepție făcând tipurile dintr-un grup care au aceleași proprietăți.

Observăm în panoul de mai sus că, în afară de char (care are o dimensiune de exact un octet),
nici unul dintre tipurile fundamentale nu are o dimensiune standard specificată (cel mult o
dimensiune minimă). De aceea, nu este necesar ca tipul să aibă exact dimensiunea minimă (și
chiar nu are, în multe cazuri). Aceasta nu înseamnă că tipurile sunt de dimensiune nedeterminată,
ci doar că nu există o dimensiune standard pentru toate compilatoarele și mașinile; fiecare
compilator implementează acea dimensiune care se potrivește arhitecturii pe care va rula
programul. Această specificație, mai mult decât generică, privind dimensiunea tipurilor de date îi
dă limbajului C++ o mare flexibilitate, astfel încât poate fi adaptat să lucreze optim pe tot felul
de platforme, atât în prezent, cât și în viitor.

Dimensiunile de tip de mai sus sunt exprimate în biți; cu cât are mai mulți biți, cu atât mai multe
valori distincte pot fi reprezentate cu ajutorul tipului respectiv, dar, în același timp, consumă și
mai mult spațiu de memorie:

Dimensiune Valori unic reprezentabile Notes

8-bit 256 = 2 8

16-bit 65 536 = 216

32-bit 4 294 967 296 = 232 (~4 billion)
64-bit 18 446 744 073 709 551 616 = 264 (~18 billion billion)

Pentru tipurile întregi, a avea mai multe valori reprezentabile înseamnă un interval de valori mai
mari; de exemplu, un tip întreg fără semn pe 16 biți ar putea reprezenta 65536 de valori distincte
în intervalul de la 0 la 65535, în timp ce tipul corespunzător cu semn ar putea reprezenta, în cele
mai multe cazuri, valori între -32768 și 32767. Să observăm că intervalul de valori pozitive este
aproximativ jumătate pentru tipul cu semn față de tipurile fără semn datorită faptului că unul
dintre cei 16 biți este folosit pentru semn; aceasta este o diferență aproape neglijabilă în domeniu
și aproape justifică folosirea unui tip fără semn bazându-ne pe intervalul de valori pozitive pe
care îl poate reprezenta.

Pentru numerele zecimale, dimensiunea afectează precizia, dat fiind că baza și exponentul poate
avea mai mulți sau mai puțini biți..

Dacă dimensiunea și precizia unui tip nu reprezintă o problemă, atunci char, int și double sunt

cele pe care le putem alege pentru a reprezenta respectiv: caractere, întregi și numere zecimale.
Celelate tipuri din grupele respective se folosesc numai în cayuri foarte speciale.
C++ suportă o mare varietate de tipuri construite pe baza tipurilor de date fundamentale discutate
mai sus; aceste alte tipuri sunt cunoscute ca tipuri de date compuse și reprezintă unul dintre atu-
urile limbajului C++. Le vom vedea, de asemenea, în capitolele următoare.

Declarații de variabile
C++ este un limbaj de tip ”strongly-typed” și necesită ca fiecare variabilă să fie declarată cu tipul
de dată corespunzător, înainte de prima sa utilizare. Declarația informează compilatorul cu
privire la dimensiunea pe care să o rezerve în memorie pentru acea variabilă și îi spune cum să
interpreteze valorile sale. Sintaxa pentru declararea unei noi variabile în C++ este extrme de
simplă: doar scriem tipul de dată urmat de numele variabilei (adică de identificatorul său). De
exemplu:

1 int a;
2 float numar;

Acestea sunt două declarații valide de variabile. Prima declară o variabilă de tip int al cărei
identificator este a. A doua declară o variabilă de tip float al cărei identificator este numar.
Odată declarate, variabilele a și numar pot fi folosite în interiorul domeniului lor din program.
Dacă avem mai multe variabile de același tip, ele pot fi toate declarate într-o singură instrucțiune
separaându-le identificatorii cu ajutorul virgulei. De exemplu:

  int a, b, c;

Aceasta declară trei variabile (a, b și c), toate fiind de tip int și având exact același sens ca și:

1 int a;
2 int b;
3 int c;

Pentru a înțelege cum se comportă într-un program, să ne uităm puțin la întregul cod C++ al
exemplului cu exercițiul de memorie mintal propus la începutul acestui capitol:

1 // lucrul cu variabile 4  Edit

2 & Run
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 // declararea variabilelor:
9 int a, b;
10 int rezultat;
11
12 // calcul:
13 a = 5;
14 b = 2;
15 a = a + 1;
16 rezultat = a - b;
17
18 // afisarea rezultatului:
19 cout << rezultat;
20
21 // terminarea programului:
22 return 0;
23 }

Nu vă temeți dacă altceva în afară de declarațiile de variabile mi s-a părut puțin ciudat. În
capitolele următoare vom explica mai în detaliu.

Inițializări de variabile
Când am declarat variabilele din exemplul de mai sus, ele aveau valori nedeterminate până în
momentul în care li s-au atribuit valori pentru prima oară. Dar se poate să atribuim o anumită
valoare unei variabile chiar în momentul declarării. Aceasta se numește inițializarea variabilei.

În C++, există trei modalități de inițializare a variabilelor. Toate sunt echivalente și au rămas
datorită evoluției în timp a limbajului:

Prima dintre ele, cunoscută ca inițializare în stilul c (deoarece a fost moștenită din limbajul C),
constă în adăugarea unui simbol egal urmat de valoarea care se atribuie la inițializare:

tip identificator = valoare_initiala;

De exemplu, pentru a declara o variabilă de tip int, numită x, și pentru a o inițializa cu valoarea
zero chiar în momentul declarării, putem scrie:

  int x = 0;

A doua metodă, cunoscută ca inițializare prin constructor (introdusă de limbajul C++), cuprinde

valoarea inițială între paranteze (()):

tip identificator (valoare_initiala);

De exemplu:

  int x (0);

În fine, a treima metodă, cunoscută care inițializare uniformă, asemănătoare celei de mai sus, dar
care folosește acolade ({}) în loc de paranteze (aceasta a fost introdusă de revizuirea standardului
C++, în 2011):
tip identificator {valaore_initiala};
De exemplu:

  int x {0};

Toate cele trei modalități de inițializare a variabilelor sunt valide și echivalente în C++.

1 // initializari de variabile 6
2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 int a=5; // valoare initiala: 5
9 int b(3); // valoare initiala: 3
 Edit
10 int c{2}; // valoare initiala: 2
& Run
11 int rezultat; // valoare initiala
12 nedeterminata
13
14 a = a + b;
15 rezultat = a - c;
16 cout << rezultat;
17
18 return 0;
}

Introducere în tipul string

Tipurile de date fundamentale reprezintă tipurile de bază gestionate de mașina pe care ar putea
rula programul. Dar unul din punctele forte ale limbajului C++ este multitudinea de tipuri de date
compuse, construite chiar cu ajutorul tipurilor de date fundamentale.

Un exemplu de tip compus este clasa string. Variabilele de acest tip pot memora o secvență de
caractere, precum cuvinte sau propoziții. O proprietate foarte utilă!

O primă diferență față de tipurile de date fundamentale este aceea că pentru a declara și folosi un
obiect (variabilă de tip obiect) de acest tip, în program trebuie să includem antetul (fișierul)în
care este definit tipul respectiv în biblioteca standard (antetul <string>):

1 // primul meu string Acesta este un string  Edit

2 #include <iostream> & Run
3 #include <string>
4 using namespace std;
5
6 int main ()
7{
 8 string sirul_meu;
9 sirul_meu = "Acesta este un string";
10 cout << sirul_meu;
11 return 0;
12 }

După cum am văzut în exemplul anterior, string-urile pot fi inițializate cu orice notație validă,
exact cum variabilele de tip numeric pot fi inițializate cu orice notație numerică. Ca și la tipurile
fundamentale, toate modalitățile de inițializare rămân valide:

1 string sirul_meu = "Acesta este un string";

2 string sirul_meu ("Acesta este un string");
3 string sirul_meu {"Acesta este un string"};

String-urile suportă toate operațiile de bază pe care le avem și la tipurile fundamentale, precum
declarații fără inițializare și schimbarea valorii în timpul execuției programului:

1 // primul meu string Acesta este continutul initial al

2 #include <iostream> sirului
3 #include <string> Acesta este un al continut al
4 using namespace std; sirului
5
6 int main ()
7{
8 string sirul_meu;  Edit
9 sirul_meu = "Acesta este continutul initial & Run
10 al sirului";
11 cout << sirul_meu << endl;
12 sirul_meu = "Acesta este un al continut al
13 sirului";
14 cout << sirul_meu << endl;
return 0;
}

Observație: inserarea manipulatorului endl termină (end ) linia (afișarea caracterului newline și

curățarea stream-ului).

Clasa string este un tip compus. După cum puteți vedea în exemplul de mai sus, tipurile
compuse sunt folosite la fel ca și tipurile de date fundamentale: se folosește aceeași sintaxă
pentru declarații și inițializări.