Modificarea șirului

Adăugarea la un șir

Dacă dorim să adăugăm la finalul unui șir un alt șir, se folosește metoda append(), căreia i se transmite șirul care urmează să fie adăugat:

#include <iostream>
#include <string>
 
int main()
{
    std::string message{ "hello"};
    message.append(" ");  // adăugăm un spațiu
    message.append("world");
    // se poate adăuga în lanț
    // message.append(" ").append("world");
    std::cout << message << std::endl;    // hello world
}

Inserarea unui șir

Pentru a insera un șir în altul se folosește funcția insert(). Aceasta are mai multe versiuni. Cea mai simplă primește indexul de inserare și șirul de inserat:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"insert into a text"};
    std::string str {"a string "};
    text.insert(7, str);
    std::cout << text << std::endl;  // insert a string into a text
}

În acest caz, în șirul text se inserează șirul str începând cu indexul 7. Astfel, variabila text devine "insert a string into a text".

Se poate insera și un literal de șir:

std::string text {"Hello C++"};
text.insert(6, "C/");    // Hello C/C++

Se poate insera și o parte dintr-un șir:

std::string text {"Langs: C++"};
std::string langs {"Java, C, C#"};
text.insert(6, langs, 5, 3);    // Langs: C, C++

Aici, în text se inserează din langs 3 caractere de la indexul 5, adică subșirul " C,".

Dintre celelalte versiuni ale funcției insert(), merită menționată cea care permite inserarea unui caracter repetat de un anumit număr de ori:

std::string text {"Number: 5678"};
text.insert(8, 5, '*');    // Number: *****5678

În acest caz, inserăm caracterul * de 5 ori începând de la indexul 8.

Înlocuirea unui subșir

Pentru a înlocui o parte dintr-un șir, se folosește funcția replace(). Aceasta are și ea mai multe versiuni, dar vom analiza cele mai frecvent utilizate.

Cea mai simplă versiune acceptă trei parametri:

std::string &std::string::replace(size_t _Off, size_t _Nx, const char *_Ptr)

Primul parametru – indexul de început pentru înlocuire
Al doilea – numărul de caractere care se vor înlocui
Al treilea – șirul cu care se va înlocui

Exemplu:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Lang: Java"};
    text.replace(6, 4, "C++");    // Lang: C++
    std::cout << text << std::endl;  // Lang: C++
}

Aici în șirul text înlocuim 4 caractere începând de la indexul 6 cu șirul "C++". Astfel, din "Lang: Java" obținem "Lang: C++".

În exemplul anterior, înlocuirea s-a făcut cu un literal de șir. Dar putem înlocui și cu un obiect string:

std::string text {"Lang: Java"};
std::string lang {"C++"};
text.replace(6, 4, lang);    // Lang: C++

Adesea apare nevoia de a înlocui o anumită subsecvență a șirului, al cărei index nu este cunoscut. În acest caz, putem folosi o căutare pentru a obține poziția subșirului și dimensiunea lui. De exemplu, luăm textul "Hello, Tom!" și înlocuim subșirul "Tom" cu "Bob":

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Hello, Tom!"};
    const std::string separators {" ,;:.\"!\n"}; // separatori de cuvinte
    size_t start {text.find("Tom")};             // găsim poziția subșirului
    size_t end {text.find_first_of(separators, start + 1)}; // găsim sfârșitul subșirului
    if(end == std::string::npos) // dacă nu găsim separatori
    {
        end = text.length();
    }
    text.replace(start, end - start, "Alice");    // înlocuim subșirul
 
    std::cout << text << std::endl;  // Hello, Alice!
}

Aici, găsim poziția primului caracter al subșirului "Tom" și o salvăm în start. Simbolul de după ultimul caracter al subșirului se determină căutând un separator din șirul separators cu find_first_of(). Apoi, folosim aceste poziții pentru funcția replace().

Totuși, într-un text pot exista mai multe apariții ale unui subșir (în cazul nostru "Tom"), și poate fi necesar să le înlocuim pe toate. Pentru aceasta, putem folosi bucle:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Message to Tom: Hello, Tom!"};
    std::string old_str{"Tom"};       // subșirul care trebuie înlocuit
    std::string new_str{"Alice"};     // șirul cu care se înlocuiește
    size_t start {text.find(old_str)}; // găsim poziția subșirului
    while (start != std::string::npos) // căutăm și înlocuim toate aparițiile lui old_str
    {
        text.replace(start, old_str.length(), new_str); // Înlocuim old_str cu new_str
        start = text.find(old_str, start + new_str.length());
    }
    std::cout << text << std::endl;  // Message to Alice: Hello, Alice!
}

Aici mai întâi găsim indexul primei apariții a subșirului ce trebuie înlocuit și îl salvăm în variabila start. În buclă, înlocuim pe rând toate aparițiile subșirului. După fiecare înlocuire, căutăm următoarea apariție și actualizăm start, apoi reluăm bucla. Când nu mai există apariții, start devine std::string::npos, ceea ce încheie bucla.

Dintre celelalte versiuni ale funcției replace(), putem menționa varianta care înlocuiește o subsecvență cu un anumit caracter repetat de mai multe ori:

std::string text {"Phone: +12345678901"};
text.replace(9, 6, 5, '*'); // Phone: +1*****8901

Aici înlocuim în șirul text 6 caractere de la indexul 9 cu 5 caractere *.

Ștergerea caracterelor

Dacă dorim nu doar să înlocuim caractere, ci să le ștergem complet din text, putem folosi și replace() – în acest caz, caracterele sunt înlocuite cu un șir gol:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Hello Tom!"};
    const std::string empty;
    text.replace(5, 4, empty);      // Înlocuiește "Tom" cu un șir gol
    std::cout << text << std::endl;  // Hello!
}

Totuși, C++ oferă și o funcție specială pentru ștergerea caracterelor – erase(). Aceasta primește ca parametri indexul de început și numărul de caractere de șters:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Hello Tom!"};
    text.erase(5, 4);       // ștergem 4 caractere de la indexul 5
    std::cout << text << std::endl;  // Hello!
}

La fel, putem șterge toate aparițiile unui anumit subșir:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Hello Tom! Good bye Tom..."};
    std::string to_delete{" Tom"};  // subșirul de șters
    size_t start {text.find(to_delete)};            // găsim poziția subșirului
    while (start != std::string::npos) // căutăm și ștergem toate aparițiile lui to_delete
    {
        text.erase(start, to_delete.length()); 
        start = text.find(to_delete, start + to_delete.length());
    }
    std::cout << text << std::endl;  // Hello! Good bye...
}

Funcția erase() are și alte versiuni. De exemplu, putem păstra doar un număr de caractere de la începutul șirului și să ștergem restul:

std::string text {"Hello Tom"};
text.erase(5); // șterge totul după primele 5 caractere – rămâne "Hello"

Dacă funcția este apelată fără parametri, se șterg toate caracterele, iar șirul devine gol:

std::string text {"Hello Tom"};
text.erase(); // șir gol

Merită menționat că în standardul C++20 a fost introdusă funcția std::erase(), care șterge toate aparițiile unui anumit caracter dintr-un șir:

#include <iostream>
#include <string>
 
int main()
{
    std::string text {"Hello Tom! Good bye Tom..."};
    std::erase(text, 'T');    // Ștergem caracterul 'T'
    std::cout << text << std::endl;  // Hello om! Good bye om...
}

În acest caz, din șirul text este eliminat caracterul T.