Constante în C++

Constantele sunt expresii cu o valoare fixă, ce nu se poate schimba pe parcursul execuției programului. În C++, constantele sunt de trei tipuri:

Constante literale

Constantele literale sunt folosite pentru a exprima o valoare direct în codul sursă al programului. De multe ori folosim o constantă pentru a inițializa o variabilă, de exemplu:

int x = 618; // Aici, 618 este o constantă literală.

Pentru fiecare tip de date, constantele literale corespunzătoare arată altfel:

Numere întregi

Cel mai simplu mod de a specifica o constantă întreagă este prin a scrie numărul respectiv în baza 10, de exemplu 0, 123 și -618. C++ permite și folosirea numerelor în baza 8 și 16. Pentru a specifica faptul că numărul este scris în baza 8, cifrele acestuia trebuie precedate de un 0, iar pentru baza 16, de 0x. Nu contează dacă literele folosite în baza 16 sau x-ul din 0x sunt scrise cu majuscule sau nu. Iată cum putem scrie numărul 618 în toate cele 3 moduri:

618   // decimal
01152 // octal
0x26A // hexadecimal

La fel ca variabilele, constantele sunt și ele de un anumit tip. Implicit, constantele întregi sunt de tip int. Pentru a clarifica tipul întreg al unei constante, putem folosi sufixe. Un sufix este un mic șir de caractere care se adaugă la finalul unei constante literale. Așadar, sufixele pentru tipul întreg sunt:

Din păcate, nu există sufix pentru modificatorul short. Exemple de sufixe:

618    // int
618u   // unsigned int
618l   // long int
618ul  // unsigned long int
618ull // unsigned long long int

Numere reale

Aceste constante pot include un punct (care are rolul de a separa partea întreagă de cea fracționară) și/ sau caracterul e. Acesta trebuie urmat de un întreg, având semnificația că respectiva constantă are valoarea $a \cdot 10^b$ unde a este numărul de dinaintea lui e, iar b cel de după. Exemple:

3.1459   // 3.1459        (aproximare a lui PI)
1.6180   // 1.618         (aproximare a numărului de aur)
6.022e23 // 6.022 * 10^23 (aproximare a numărului lui Avogadro)
1.6e-18  // 1.6 * 10^(-18)

Tipul implicit al acestor constante este double. Pentru a specifica faptul că o constantă reală este de tipul float sau long double, folosim următoarele sufixe:

Exemple:

1.23l // long double
6.1f  // float

Caractere și șiruri de caractere (string-uri)

Constantele caractere au o formă foarte simplă: caracterul încadrat între apostrofuri. Constantele de tip string se scriu asemănător: șirul de caractere încadrat între ghilimele. Exemple:

'x'             // caracter
'\n'            // caracter
"infogenius.ro" // string

Unele caractere sunt greu sau imposibil de reprezentat în codul sursă, așa că în locul acestora se scriu niște coduri speciale, formate din \ + un caracter. Acestea se numesc coduri escape:

Pe Linux enter-ul se reprezintă drept '\n', pe MacOS '\r', iar pe Windows "\r\n". Totuși, orice editor de text pe Windows, cu excepția NotePad-ului, vede '\n' drept enter.

Caracterele se mai pot reprezenta prin codul lor ASCII în baza 8 (codul e precedat de \) sau în baza 16 (codul e precedat de \x). Exemple:

'\50'  // '('
'\x4A' // 'J'

Mai multe constante literale string, separate prin spații, tab-uri sau enter-uri, formează o singură constantă. De exemplu:

"acesta este " "un singur "       "str"
"ing"
// Echivalent cu "acesta este un singur string".

De asemenea, având în vedere că în C++ un \ la sfârșitul unei linii înseamnă că următoarea linie este o continuare a celei curente, putem scrie un string și așa:

"Info\
Genius"
// Echivalent cu "InfoGenius".

Valori booleene

Pentru tipul bool avem doar două constante literale: true (poate fi înlocuit cu orice constantă nenulă, de orice tip) și false (poate fi înlocuit de orice constantă nulă, de orice tip, de exemplu 0 sau nullptr).

Pointeri

Pentru pointeri avem constanta nullptr care semnifică pointer-ul nul. Aceasta s-a introdus în C++11. Echivalentul ei, mai vechi, este NULL.

Constante definite prin const

Folosind keyword-ul const, putem da un nume unei constante, și să folosim acel nume în program când ne referim la ea. Sintaxa este:

const tip nume = valoare;

Exemple:

const double goldenRatio = 1.618;
const char enter = '\n';

Constante definite prin #define

#define este o directivă preprocesor cu următoarea sintaxă:

#define identificator inlocuitor

#define, la fel ca orice directivă preprocesor este interpretată înainte de compilare, și nu se termină cu ;. Directiva #define are rolul de a înlocui în tot codul sursă identificatorul cu înlocuitorul. Deși identificatorul este case-senzitive, prin convenție, acesta se scrie cu majuscule. Exemplu:

#define MAX 618
cout << MAX << '\n'; // Afișează 618, urmat de enter.

Următorul tutorial de C++ este Operatori și expresii în C++, unde veți afla cum se leagă între ele variabilele, tipurile de date și constantele. Dacă aveți vreo întrebare despre constante în C++, nu ezitați să o adresați printr-un comentariu