C++

Tutorials

Constante

Constante sunt expresii cu valoarea fixă.

Valori precizate

Valorile precizate sunt cel mai clar exemplu de constante. Ele sunt folosite pentru a exprima anumite valori în sursa unui program. Deja am folosit unele dintre ele în capitolele anterioare pentru a atribui anumite valori unor variabile sau pentru a transmite mesaje pe care dorim ca programul nostru să le afișeze. Am scris:

1
 
a = 5;

Valoarea 5 reprezintă o valoare precizată în această secvență de cod.

Constantele precizate prin valori sunt clasificate în: întregi, reale, caractere, string-uri, boolean, pointeri și valori precizate definite de utilizator.

Numere întregi


1
2
3
 
1776
707
-

Acestea sunt constante precizate care identifică valori de tip întreg. Să remarcăm că ele nu sunt cuprinse între ghilimele sau între alte caractere speciale; sunt pur și simplu succesiuni de cifre reprezentând un număr în baza 10; de exemplu, 1776 reprezintă întotdeauna valoarea o mie șapte sute șapte zeci și șase.

În plus față de numerele zecimale (cele cu care lucrăm uzual), C++ permite precizarea de constante în formatul numerelor octale (în baza 8) și hexazecimale (în baza 16). Pentru octali, cifrele sunt precedate de un caracter 0 (zero). Pentru hexazecimale, vor fi precedate de combinația 0x (zero, x). De exemplu, următoarele constante precizate sunt echivalente una cu cealaltă: 

1
2
3
 
75         // zecimal
0113       // octal
0x4b       // hexazecimal

Toate reprezinta același număr: 75 (șaptezeci și cinci), exprimat în baza 10, respectiv bazele opt și 16.

Aceste constante precizate au câte un tip, la fel ca și variabilele. În mod implicit, valorile întregi sunt de tipul int. Totuși, putem adăuga anumite sufixe la o constantă pentru a preciza un alt tip întreg:

SufixModificator de tip
u or Uunsigned
l or Llong
ll or LLlong long

Unsigned poate fi combinat cu oricare dintre ceilalți doi, în orice ordine, pentru a forma unsigned long sau unsigned long long.

De exemplu:

1
2
3
4
5
 
75         // int
75u        // unsigned int
75l        // long
75ul       // unsigned long 
75lu       // unsigned long

În toate cazurile de mai sus, sufixul poate fi precizat folosind litere mari sau mici.

Numere reale

Exprimă valori reale, cu zecimale și/sau exponenți. Ele pot conține punct zecimal (virgula) sau un caracter e (care înseamnă "zece la puterea X", unde X este o valoare întreagă ce urmează după caracterul e), sau atât punct zecimal cât și un caracter e:

1
2
3
4
 
3.14159    // 3.14159
6.02e23    // 6.02 x 10^23
1.6e-19    // 1.6 x 10^-19
3.0        // 3.0

Acestea sunt patru numere zecimale valide expimate în C++. Primul număr este PI, al doilea este numărul lui Avogadro, al treilea este încărcarea electrică a unui electron the electric charge of an electron (un număr extrem de mic) - toate aproximate -, iar ultimul este numărul trei exprimat ca valoare reală precizată.

Tipul implicit pentru valorile reale precizate este double. Numerele reale de tipul float sau long double pot fi precizate adăugând următoarele sufixe:

SufixTip
f or Ffloat
l or Llong double

De exemplu:

1
2
 
3.14159L   // long double
6.02e23f   // float

Oricare dintre literele care fac parte dintr-o constantă reală (e, f, l) pot fi scrise fie cu literă mare, fie cu literă mică, fără a avea imortanță deosebită.

Caractere și valori string

Caracterele și constantele de tip string sunt cuprinse între ghilimele:

1
2
3
4
 
'z'
'p'
"Salutare, lume!"
"Ce mai faci?"

Primele două expresii reprezintă câte o constantă caracter iar următoarele două reprezintă câte o constantă string compuse din mai multe caractere. Observați că pentru a reprezenta un singur caracter obișnuim să îl cuprindem între apostrofuri ('), iar pentru a exprima un string (care, în general, este un șir format mai mai mult de un caracter), îl includem între ghilimele (").

Atât constantele caractere, cât și constantele string necesită apostrofuri, respectiv ghilimele, pentru a le deosebi de eventuali identificatori de variabile sau de cuvinte rezervate. Observați diferentța dintre aceste doua expresii:

x
'x'
Aici, x simplu s-ar putea referi la un identificator, cum ar fi numele unei variavile sau un tip de dată compus, în timp ce 'x' (cuprins între apostrofuri) s-ar putea referi la constanta caracter 'x' (caracterul care reprezintă litera mică x).

Constantele caracter si string pot reprezenta, de asemenea, caratere speciale care altefe sunt dificil sau chiar imposibil de reprezentat în sursa unui program, de exemplu newline (\n) sau tab (\t). Totae aceste caractere sunt precedate de un caracter backslash (\).

Aici aveți o listă cu codurile caracterelor escape:

Codul EscapeDescriere
\nnewline
\rcarriage return
\ttab
\vvertical tab
\bbackspace
\fform feed (page feed)
\aalert (beep)
\'single quote (')
\"double quote (")
\?question mark (?)
\\backslash (\)

De exemplu:

'\n'
'\t'
"Stanga \t Dreapta"
"unu\ndoi\ntrei"
Calculatoarele reprezintă intern carecterele prin niște coduri numerice: cel mai adesea, ele folosesc una dintre extensiile sistemului de codificare ASCII (pentru mai multe informații, vedeți ASCII code). Caracterele pot fi reprezentate ca și constante folosind codul lor numeric în octal sau hexazecimal, precedat de un caracter (\). În baza opt, caracterul backslash este urmat imediat de cifre, în timp ce pentru hexazecimal se inserează un caracter x între backslash și cifrele hexazecimale (de exemplu: \x20 sau \x4A).

Mai multe constante string pot fi concatenate petnru a forma o singură constanta string doar prin separarea lor de unul sau mai multe spații, prin includerea de caractere speciale (blank) precum tab, newline. De exemplu:

1
2
 
"Acestea formeaza" "un singur"     " string "
"de caractere"

Mai sus este o constantă string echivalentă cu:

1
 
"Acestea formează un singur string de caractere"

Observați că spațiile dintre ghilimele fac parte din constantă, în timp ce spațiile din afară sunt eliminate.

De asemenea, unii programatori folosesc un truc pentru a extinde constante string pe mai multe rânduri: în C++, un backslash (\) la sfârșitul liniei este considerat un caracter de continuare a liniei, care unește ceea ce este scris pe linia respectivă și pe următoarea într-o singură linie. De aceea, codul următor:

1
2
 
x = "string exprimat pe \
doua linii"

este echivalent cu:

1
 
x = "string exprimat pe doua linii"

Toate constantele caracter și string descrise mai sus sunt formate din caractere de tip char. Un alt tip de caracter poate fi specificat folosind unul dintre umrătoarele prefixe:

PrefixTip caracter
uchar16_t
Uchar32_t
Lwchar_t

Observați că, spre deosebire de sufixele pentru numere întregi, aceste prefixe sunt case sensitive: litere mici pentru char16_t și litere mari pentru char32_t și wchar_t.

Pentru constante string, în afară de cele de mai sus u, U și L, există încă două prefixe:

PrefixDescriere
u8Constanta string este codificată folosind UTF-8
RConstanta string este un rând string

În string-urile rând, caracterele backslash, ghilimele si apostrof sunt toate caractere valide; conținutul constantei este delimitat de o expresie inițială R"secventa( și una finală )secventa", unde secventa este orice secventa de caractere (inclusiv o secvență vidă). Conținutul string-ului este cuprins între paranteze, ignorându-se delimitarea secvenței. De exemplu:

1
2
 
R"(string cu \backslash)"
R"&%$(string cu \backslash)&%$"

Cele două string-uri de mai sus sunt echivalente cu "string cu \\backslash". Prefixul R poate fi combinat cu orice alte prefixe, precum u, L sau u8.

Alte constante precizate

În C++ mai există alte trei cuvinte cheie pentru precizarea de valori: true, false și nullptr:
  • true și false sunt două valori posibile pentru variabilele de tip bool.
  • nullptr este valoarea pointer nul.

1
2
3
 
bool foo = true;
bool bar = false;
int* p = nullptr;

Expresii de tip constant

Uneori, este mult mai convenabil să dăm un nume unei valori constante:

1
2
 
const double pi = 3.1415926;
const char tab = '\t';

Vom putea apoi să folosim numele în loc să precizăm valoarea cu care a fost definit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <iostream>
using namespace std;

const double pi = 3.14159;
const char newline = '\n';

int main ()
{
  double r=5.0;               // raza
  double cerc;

  cerc = 2 * pi * r;
  cout << cerc;
  cout << newline;
}
 
31.4159

Definiții preprocesor (#define)

Alt mecanism pentru a denumi o valoare constantă folosește definițiile preprocesor. Ele au următoarea formă:

#define identificator valoare

După această directivă, orice apariție în cod a lui identificator este interpretată ca valoare, unde valoare este orice secvență de caractere (până la sfârșitul liniei). Această înlocuire este realizată de către preprocesor și se realizează înainte ca programul să fie compilat, deci este un fel de înlocuire ”oarbă”: validitatea tipurilor sau sintaxa implicată nu sunt verificate în niciun fel.

De exemplu:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <iostream>
using namespace std;

#define PI 3.14159
#define NEWLINE '\n'

int main ()
{
  double r=5.0;               // raza
  double cerc;

  cerc = 2 * PI * r;
  cout << cerc;
  cout << NEWLINE;

}
 
31.4159

Observați că liniile #define sunt directive preprocesor și, deși ocupă o singură linie, spre deosebire de instrucțiunile C++, ele nu se termină cu punct și virgulă (;). Directivele se extind automat până la sfârșitul liniei. Dacă se include caracterul punct și virgulă pe acea linie, atunci el este parte din valoarea cu care se va înlocui apariția expresiei (deci va fi inclus în toate aparițiile expresiei înlocuite).
Index
Index