2.2.
Vocabularul și sintaxa limbajului C++: Unități lexicale - Șiruri de
caractere, Etichete, Directive
Unitățile lexicale reprezintă elementele de bază ale vocabularului C++. În această secțiune
vom analiza șirurile de caractere, etichetele și directivele, care au un rol esențial în scrierea și
organizarea codului.
a) Șiruri de caractere (Strings)
Un șir de caractere este o secvență de caractere care este utilizată pentru a reprezenta textul
în C++. Șirurile sunt foarte importante pentru manipularea datelor textuale, cum ar fi afișarea
mesajelor sau gestionarea intrărilor de la utilizator.
Declarație și inițializare:
În C++, șirurile de caractere pot fi manipulate în două moduri:
1. Folosind tablouri de caractere:
Șirurile sunt declarate ca tablouri de caractere, unde fiecare caracter este un element
al tabloului, iar șirurile se termină cu caracterul special `\0` (null-terminator).
Ex.:
```cpp
char str[] = "Hello";
```
Aici, șirul `str` este un tablou de caractere cu valoarea "Hello", terminat automat cu `\0`.
2. Folosind clasa `string`:
`std::string` din biblioteca `<string>` este o clasă care oferă metode și funcționalități
avansate pentru manipularea șirurilor de caractere.
Ex.:
```cpp
#include <string>
std::string greeting = "Hello, World!";
```
Operarea pe șiruri:
Funcțiile și metodele disponibile în clasa `string` permit concatenarea, compararea,
inserarea, și ștergerea caracterelor.
Ex.:
```cpp
std::string firstName = "John";
std::string lastName = "Doe";
std::string fullName = firstName + " " + lastName; // Concatenare de șiruri
```
Funcții utile pentru șiruri de caractere:
- `strlen()`: returnează lungimea unui șir de caractere.
- `strcmp()`: compară două șiruri de caractere.
- `substr()`: returnează un subșir dintr-un șir.
Exemplu de utilizare a unui șir de caractere:
```cpp
#include <iostream>
#include <string>
int main() {
std::string name = "Alice";
std::cout << "Hello, " << name << "!" << std::endl;
return 0;
}
```
---
b) Etichete (Labels)
Etichetele sunt utilizate în C++ în contextul instrucțiunilor de control al fluxului, mai ales
în legătură cu instrucțiunea `goto`. Deși folosirea etichetelor și a instrucțiunii `goto` nu este
recomandată în programarea modernă, deoarece poate duce la cod dificil de întreținut, ele pot fi
utile în anumite situații particulare.
- Definirea și utilizarea etichetelor:
- O etichetă este un identificator care este urmat de două puncte (`:`). Poate fi folosită ca țintă a
unei instrucțiuni `goto`.
- Ex.:
```cpp
#include <iostream>
int main() {
int x = 0;
label: // Etichetă
std::cout << "x = " << x << std::endl;
x++;
if (x < 3)
goto label; // Săritura la etichetă
return 0;
}
```
În acest exemplu, eticheta `label` este un punct de referință pentru instrucțiunea `goto`.
Programul va continua să afișeze valoarea lui `x` și să sară înapoi la etichetă până când `x`
devine 3.
- Recomandare: Utilizarea instrucțiunii `goto` este descurajată în general, deoarece poate
complica controlul fluxului programului. De obicei, buclele și funcțiile recursivă sunt soluții mai
potrivite și mai ușor de înțeles.
c) Directivele (Preprocessor Directives)
Directivele preprocesorului sunt instrucțiuni care sunt procesate înainte de compilarea
efectivă a programului. Ele încep cu simbolul `#` și sunt folosite pentru a include fișiere de antet,
a defini constante și macrocomenzi, sau pentru a controla compilarea condiționată.
- Principalele directive:
1. `#include`: Include fișiere de antet care conțin declarații de funcții sau variabile utilizate în
program.
- Ex.:
```cpp
#include <iostream> // Include biblioteca de intrare/ieșire
```
2. `#define`: Definește constante sau macrocomenzi. Este utilizat pentru a crea constante
simbolice sau macro-uri care sunt substituite în cod înainte de compilare.
- Ex.:
```cpp
#define PI 3.14159 // Definește o constantă pentru valoarea lui Pi
```
3. Compilare condiționată:
- `#if`, `#ifdef`, `#ifndef`, `#else`, `#elif`, `#endif`: Aceste directive sunt utilizate pentru a
include sau exclude anumite părți ale codului în funcție de anumite condiții.
- Ex.:
```cpp
#define DEBUG
#ifdef DEBUG
std::cout << "Debugging is enabled." << std::endl;
#endif
```
4. `#pragma`: O directivă specifică compilatorului, care permite setarea anumitor
comportamente particulare ale acestuia. De exemplu, se poate folosi pentru a dezactiva anumite
avertismente.
- Ex.:
```cpp
#pragma warning(disable: 4996) // Dezactivează avertismentul pentru funcțiile depreciate
```
- Utilitatea directivelor:
- `#include` este fundamental pentru a permite reutilizarea codului prin includerea fișierelor de
antet, cum ar fi cele standard (`<iostream>`, `<cmath>`, etc.) sau fișiere definite de utilizator.
- `#define` este utilizat pentru a crea constante și macrocomenzi care pot simplifica codul și pot
îmbunătăți lizibilitatea acestuia.
- Compilarea condiționată este utilă în situațiile în care anumite porțiuni de cod trebuie
compilate numai în anumite condiții, cum ar fi modul de depanare sau compilarea pe platforme
diferite.
Concluzie
- Șirurile de caractere sunt folosite pentru manipularea datelor textuale și pot fi implementate fie
ca tablouri de caractere, fie folosind clasa `std::string`.
- Etichetele sunt folosite în combinație cu instrucțiunile de control al fluxului, cum ar fi `goto`,
deși folosirea acestora nu este recomandată în programarea modernă.
- Directivele preprocesorului permit manipularea codului la nivelul preprocesării, facilitând
includerea fișierelor externe, definirea constantelor și controlul compilării condiționate.