Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::string::find — primera coincidencia y npos

Busca el índice de un carácter o una subcadena y compáralo con `std::string::npos` antes de usarlo como índice o de copiar o modificar el texto.

Versión: ISO C++23; implementation support may vary

Sintaxis

// 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 es una función miembro const de std::string, de la cabecera <string>. Devuelve el menor índice de coincidencia, contando desde cero, que sea mayor o igual que pos (por defecto 0). El patrón debe caber por completo en el texto. Un patrón vacío coincide en pos si pos <= s.size(); uno no vacío no puede coincidir si pos >= s.size(). La búsqueda distingue mayúsculas y minúsculas, y los índices cuentan elementos char, no puntos de código Unicode.

El resultado es de tipo std::string::size_type. Si no hay coincidencia, no se lanza una excepción: se devuelve std::string::npos, el mayor valor de ese tipo sin signo. Comprueba i != std::string::npos antes de usar el índice o hacer cálculos con él. if (i) es falso para una coincidencia válida en 0 y verdadero para npos. El resultado es un número, no un iterador ni una vista, y puede dejar de identificar la misma coincidencia si cambia el texto.

Usa s.find('!') para buscar un carácter. Para una subcadena, pasa un std::string, un std::string_view o una cadena válida terminada en nulo, como en s.find("ab"). En s.find(ptr, pos, count), count indica la longitud del patrón, no un límite de búsqueda; el patrón puede incluir \0. Todo puntero o vista que se pase debe referirse a datos válidos durante toda la llamada. Un rango no válido no devuelve npos: provoca comportamiento indefinido.

Las sobrecargas para char y std::string son noexcept; las que reciben punteros no se declaran noexcept. La sobrecarga de plantilla, disponible desde C++17, acepta tipos convertibles implícitamente a std::string_view pero no a const char*; su noexcept depende de la conversión a la vista. Todas las sobrecargas son constexpr desde C++20. Si basta con un sí o un no y no necesitas una posición inicial, s.contains('!') es una alternativa de C++23 si la biblioteca la admite.

Si s ya es un std::string, comprueba s.find('!') != std::string::npos antes de crear una copia de trabajo o modificar el texto. La búsqueda en sí no copia ni modifica s. Esta comprobación rechaza !, pero no sustituye otras reglas de validación.

Ejemplos

#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);
}

Resultado

rejected at 0
accepted: abc.

En `!abc`, `!` está en el índice `0`, así que la función termina antes de copiar. En `abc` no hay coincidencia y solo entonces se crea una copia y se le añade un punto.

Lecciones relacionadas

  • C++ · Lección 15 · Avanzado · Versión: 3

Fuentes