Șiruri de caractere

Definirea șirurilor

Așa cum a fost explicat în articolul „Introducere în șiruri”, limbajul C++ oferă un tip special pentru lucrul cu șiruri: std::string, definit în modulul <string>. Să analizăm în detaliu elementele de bază ale lucrului cu acest tip.

Un obiect de tip string conține o secvență de caractere de tip char, care poate fi și goală. De exemplu, definirea unui șir gol:

std::string message;

Putem de asemenea inițializa sau atribui o valoare concretă unei variabile de tip string:

std::string message {"Hello FABRICADECODURI.COM!"};
// sau
std::string message2 = "Hello FABRICADECODURI.COMM!";
std::string message3("Hello FABRICADECODURI.COM!");

n acest caz, variabila message va conține o copie a literalului "Hello fabricadecoduri.com!". Intern, ea va păstra un tablou de caractere care se termină cu un caracter nul (\0). Totuși, implementarea tipului string și funcțiile sale oferă o interfață mai sigură pentru lucrul cu texte.

Există și alte moduri de inițializare. De exemplu, putem crea un șir repetând un caracter de mai multe ori:

std::string message (4, 'd'); // repetă caracterul 'd' de 4 ori -> "dddd"

Putem inițializa un obiect string cu alt obiect string:

std::string hello{"hello world"};
std::string message {hello};
// sau:
// std::string message(hello);
// std::string message = hello;

Putem inițializa doar o parte a unui șir:

std::string message1 {"hello world", 4};      // primele 4 caractere -> "hell"
std::string message2 {"hello world", 6, 5};   // 5 caractere de la poziția 6 -> "world"

std::string hello{"hello world"};
std::string message3 {hello, 4};              // "hell"
std::string message4 {hello, 6, 5};           // "world"

Putem afișa un astfel de șir în consolă:

#include <iostream>
#include <string>
 
int main()
{
    std::string message {"Hello METANIT.COM!"};
    std::cout << "Message: " << message << std::endl;
}

Cu ajutorul fluxurilor standard cin și cout putem citi și afișa datele:

#include <iostream>
#include <string>
 
int main()
{   
    std::string name;
    std::cout << "Input your name: ";
    std::cin >> name;
    std::cout << "Your name: " << name << std::endl;
}

Ieșirea în consolă:

Input your name: Tom  
Your name: Tom

Pentru a citi un șir întreg (inclusiv spațiile), putem folosi funcția getline():

#include <iostream>
#include <string>
 
int main()
{   
    std::string name;
    std::cout << "Input your name: ";
    getline(std::cin, name);
    std::cout << "Your name: " << name << std::endl;
}

getline() primește două argumente: std::cin și variabila în care se va salva șirul.

Ieșirea:

Input your name: Tom Smith  
Your name: Tom Smith

Dimensiunea șirului

Cu ajutorul metodelor length() și size() putem afla dimensiunea unui șir, adică numărul de caractere pe care le conține (caracterul nul \0 nu este luat în considerare):

#include <iostream>
#include <string>
 
int main()
{
    std::string message {"Hello"};
    std::cout << "Length: " << message.length() << std::endl;   // Length: 5
    std::cout << "Size: " << message.size() << std::endl;       // Size: 5
}

Dacă șirul este gol, atunci conține 0 caractere. În acest caz, putem folosi metoda empty() – ea returnează true dacă șirul este gol:

#include <iostream>
#include <string>
 
int main()
{
    std::string message;
    if(message.empty())
        std::cout << "string is empty " << std::endl;
    else
        std::cout << "string is not empty" << std::endl;
}

Concatenarea șirurilor

Pentru a concatena (uni) șiruri, se folosește operatorul +:

#include <iostream>
#include <string>
 
int main()
{
    std::string hello {"hello"};
    std::string world {"world"};
    std::string message{ hello + " " + world};
    std::cout <<  message  << std::endl;    // hello world
}

Este important de reținut că, atunci când folosim operatorul +, ambii operanzi nu trebuie să fie simultan literali de șir. De exemplu, următorul cod va genera o eroare:

std::string message{ "hello " + "world" + "!"};   // ! Eroare

Dacă totuși este necesar să concatenăm doi literali de șir, putem pur și simplu omite operatorul +:

std::string hello {"hello"};
std::string message{ hello + " world" "!"};   // hello world!

Alternativ, putem converti literalii de șir în obiecte string folosind spațiul de nume std::string_literals și sufixul s:

#include <iostream>
#include <string>
using namespace std::string_literals; 
 
int main()
{
    std::string message{ "hello "s + "world"s + "!"s };
    std::cout <<  message  << std::endl;    // hello world!
}

În acest caz, șirurile cu sufixul s (de exemplu, "hello "s) sunt tratate ca obiecte de tip std::string.

Raw literals

În șiruri de caractere pot fi folosite diverse caractere speciale, care au un sens special. De exemplu, caracterul "\t" reprezintă o tabulare, iar "\n" – trecerea pe o linie nouă.

Totuși, deoarece backslash-ul \ este folosit pentru a introduce astfel de secvențe speciale, dacă vrem să afișăm un singur backslash într-un șir, trebuie să îl precedăm cu alt backslash: "\\".

De asemenea, dacă vrem să afișăm ghilimele duble în interiorul șirului, și acestea trebuie precedate cu un backslash: "\"". De exemplu:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Name: \t\"Tom\"\nAge:\t38"};
    std::cout << text << std::endl;
}

În acest caz, ieșirea în consolă va fi următoarea:

Name:   "Tom"
Age:    38

Raw-literals (literaluri brute) permit simplificarea definirii unor astfel de șiruri. Aceste literaluri sunt precedate de prefixul R, iar textul efectiv este plasat între ghilimele duble și paranteze rotunde:

#include <iostream>
#include <string>
 
int main()
{
    std::string text 
{R"(Name:   "Tom"
Age:    38)"};
    std::cout << text << std::endl;
}

În acest caz, toate tabulările, liniile noi și ghilimelele din interiorul șirului vor fi interpretate exact așa cum sunt scrise. În final, rezultatul afișat va fi identic cu cel din exemplul anterior.