Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::string::find — prima corrispondenza e npos

Trova l’indice di un carattere o di una sottostringa e confrontalo con `std::string::npos` prima di usarlo come indice o di copiare o modificare il testo.

Versione: ISO C++23; implementation support may vary

Sintassi

// C++23 member declarations, with types written for std::string (<string>).
// The template participates only if const T& is implicitly convertible to
// std::string_view but not to const char*.
constexpr size_type find(char ch, size_type pos = 0) const noexcept;
constexpr size_type find(const std::string& needle, size_type pos = 0) const noexcept;
constexpr size_type find(const char* needle, size_type pos = 0) const;
constexpr size_type find(const char* needle, size_type pos, size_type count) const;
template<class T>
constexpr size_type find(const T& needle, size_type pos = 0) const
    noexcept(std::is_nothrow_convertible_v<const T&, std::string_view>);
static constexpr size_type npos = size_type(-1);

std::string::find è una funzione membro const di std::string, dall’header <string>. Restituisce il più piccolo indice, a partire da zero, di una corrispondenza che inizi in pos (per impostazione predefinita 0) o dopo. Il testo cercato deve rientrare interamente nella stringa. Una sequenza vuota corrisponde in pos se pos <= s.size(); una non vuota non può corrispondere se pos >= s.size(). La ricerca distingue maiuscole e minuscole e gli indici contano elementi char, non punti di codice Unicode.

Il risultato ha tipo std::string::size_type. Se non trova una corrispondenza, la funzione non lancia un’eccezione: restituisce std::string::npos, il valore massimo di quel tipo senza segno. Verifica i != std::string::npos prima di usare l’indice o di eseguire calcoli su di esso. if (i) è falso per una corrispondenza valida in 0 e vero per npos. Il risultato è un numero, non un iteratore né una vista, e dopo una modifica del testo potrebbe non indicare più la stessa corrispondenza.

Usa s.find('!') per cercare un carattere. Per una sottostringa passa uno std::string, uno std::string_view o una stringa valida terminata dal carattere nullo, come in s.find("ab"). In s.find(ptr, pos, count), count è la lunghezza della sequenza cercata, non un limite della ricerca; la sequenza può includere \0. Puntatori e viste passati devono riferirsi a dati validi per tutta la chiamata. Un intervallo non valido non produce npos: causa comportamento indefinito.

Gli overload per char e std::string sono noexcept; quelli con puntatori non sono dichiarati noexcept. L’overload template, disponibile da C++17, accetta tipi convertibili implicitamente in std::string_view ma non in const char*; il suo noexcept dipende dalla conversione alla vista. Da C++20 tutti gli overload sono constexpr. Se basta un sì o un no e non serve una posizione iniziale, s.contains('!') è un’alternativa di C++23 se supportata dalla libreria.

Se s è già uno std::string, verifica s.find('!') != std::string::npos prima di creare una copia di lavoro o modificare il testo. La ricerca non copia né modifica s. Questo controllo rifiuta !, ma non sostituisce altre regole di validazione.

Esempi

#include <iostream>
#include <string>

void process(const std::string& input) {
    const auto bad = input.find('!');
    if (bad != std::string::npos) {
        std::cout << "rejected at " << bad << '\n';
        return;
    }

    auto result = input;
    result += '.';
    std::cout << "accepted: " << result << '\n';
}

int main() {
    const std::string invalid = "!abc";
    const std::string valid = "abc";
    process(invalid);
    process(valid);
}

Risultato

rejected at 0
accepted: abc.

In `!abc`, `!` è all’indice `0`, quindi la funzione termina prima di copiare. In `abc` non c’è corrispondenza: solo allora la funzione crea una copia e le aggiunge un punto.

Lezioni correlate

  • C++ · Lezione 15 · Avanzato · Versione: 3

Fonti