Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::string — memorizzare e modificare testo

std::string è una sequenza di elementi char, proprietaria e di lunghezza variabile. Scopri come creare stringhe, aggiungere contenuti, cercare ed estrarre sottostringhe, e comprendi la differenza tra reserve e resize e le regole per usare data() in sicurezza.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <string>
std::string s;
std::string repeated(count, character);
s.reserve(capacity);
s.resize(count, character);
s += text;
s.push_back(character);
s.append(text);
s.assign(text);
auto position = s.find(text);
if (position != std::string::npos) {
    auto part = s.substr(position, count);
}

std::string di <string> è un alias di std::basic_string<char>; std::basic_string è il modello per una sequenza proprietaria con memoria contigua. std::basic_string(count, character) crea count copie di character, ad esempio std::string(3, '*'). std::basic_string::size() conta gli elementi char, non i caratteri Unicode, ed esclude il \0 finale. std::basic_string::empty() (cioè std::string::empty()) verifica se la dimensione è zero.

std::basic_string::reserve(n) garantisce una capacità di almeno n, ma non modifica la dimensione e non crea elementi. std::basic_string::resize(n, c) accorcia la stringa o aggiunge copie di c; resize(n) aggiunge \0 quando la dimensione aumenta. std::basic_string::operator+= e std::basic_string::append aggiungono dati, std::basic_string::push_back aggiunge un elemento, e std::basic_string::assign sostituisce il contenuto.

std::basic_string::find (cioè std::string::find) restituisce l’indice della prima corrispondenza nella posizione specificata o successiva, da zero per impostazione predefinita, oppure std::basic_string::npos (std::string::npos). Memorizza il risultato in auto e confrontalo con npos prima di usarlo come posizione. std::basic_string::substr(pos, count) (cioè std::string::substr) restituisce una stringa distinta con al massimo count elementi; il valore predefinito count = npos indica il resto della stringa. Se pos > size(), genera std::out_of_range.

std::basic_string::data() espone un buffer terminato da \0, anche quando la stringa contiene zeri incorporati. Per un oggetto non const, si possono modificare gli elementi con indici inferiori a size(); riservare memoria non consente da solo di scrivere oltre. Non cambiare il terminatore in un valore diverso da \0. La riallocazione invalida i puntatori; acquisiscili di nuovo dopo una modifica invece di presumere che siano validi.

Ambito della voce: C++23; l’opzione del compilatore del repository non certifica l’ambiente di esecuzione di produzione. La fonte è un progetto di standard in evoluzione, non un testo C++23 congelato; questa descrizione si limita alle operazioni disponibili in C++23.

Esempi

#include <iostream>
#include <string>

int main() {
    std::string s(3, '*');
    s.reserve(32);
    s += "cat";
    s.push_back('!');
    s.append("?");
    s.resize(7);

    const auto position = s.find("cat");
    if (position != std::string::npos) {
        std::cout << s << '\n';
        std::cout << s.substr(position, 3) << '\n';
    }

    s.assign("ok");
    s.data()[0] = 'O';
    std::cout << s << ' ' << s.size() << ' '
              << std::boolalpha << s.empty() << '\n';
}

Risultato

***cat!
cat
Ok 2 false

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti