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

CKTIS / C++

std::basic_string::find — búsqueda de subcadenas y separadores obligatorios

Busca la primera coincidencia desde una posición dada, comprueba `npos` e indica la longitud del patrón si el búfer puede contener caracteres nulos internos.

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

Sintaxis

// ISO C++23; member declarations of std::basic_string<CharT, Traits, Allocator> in <string>
constexpr size_type find(const basic_string& str, size_type pos = 0) const noexcept;
constexpr size_type find(const CharT* s, size_type pos, size_type count) const;
constexpr size_type find(const CharT* s, size_type pos = 0) const;
constexpr size_type find(CharT ch, size_type pos = 0) const noexcept;
template<class T>
constexpr size_type find(const T& t, size_type pos = 0) const
    noexcept(std::is_nothrow_convertible_v<const T&, std::basic_string_view<CharT, Traits>>);
// The template participates only if const T& is implicitly convertible to
// std::basic_string_view<CharT, Traits> but not to const CharT*.

std::basic_string::find es una función miembro const de <string>, disponible también en std::string. Devuelve un índice de tipo size_type que empieza en cero: la primera posición desde pos (0 por defecto) en la que cabe y coincide el patrón completo. Compara los elementos mediante Traits::eq. En UTF-8 almacenado en std::string, el índice cuenta bytes, no caracteres visibles para el usuario.

Si no hay coincidencia, devuelve npos, el valor máximo de size_type, sin lanzar una excepción. Un patrón vacío coincide en pos si y solo si pos <= size(); uno no vacío no puede coincidir si pos >= size(). Si el separador es obligatorio, comprueba npos antes de indexar, extraer una subcadena o calcular un desplazamiento. El índice 0 es una coincidencia válida.

find(ch, pos) busca un solo elemento CharT; find(str, pos) usa la longitud completa de un basic_string. find(p, pos) requiere una secuencia terminada en nulo: Traits::length se detiene en el primer carácter nulo. find(p, pos, count) usa exactamente count elementos del patrón, incluidos los nulos internos. El segundo argumento indica la posición inicial, no una longitud; count no limita la cadena en la que se busca. Un rango de puntero no válido provoca comportamiento indefinido: comprueba que count no supere el número de elementos legibles desde p.

Desde C++17, la sobrecarga de plantilla acepta const T& si se puede convertir implícitamente en std::basic_string_view<CharT, Traits>, pero no en const CharT*. Una vista conserva su longitud, pero no es propietaria de los datos. Los datos referenciados por una vista o un puntero deben seguir siendo válidos durante toda la llamada. Para un búfer std::vector<char>, usa data() junto con size(); no des por hecho que haya un nulo final.

Todas las sobrecargas son constexpr desde C++20. En C++23, las de basic_string y CharT son noexcept, las de puntero no se declaran noexcept y la de plantilla es noexcept solo si la conversión a la vista no puede lanzar excepciones. La compatibilidad puede variar según la implementación.

Ejemplos

#include <iostream>
#include <string>
#include <string_view>
#include <vector>

int main() {
    const std::string record{"A:B:\0=C", 7};
    const std::vector<char> separator{':', '\0', '='};

    std::cout << "C string: " << record.find(separator.data()) << '\n';

    const auto split = record.find(separator.data(), 0, separator.size());
    if (split == std::string::npos) {
        std::cout << "Missing required separator\n";
        return 1;
    }
    std::cout << "Counted separator: " << split << '\n';

    const std::string_view marker{separator.data(), separator.size()};
    const auto start = split + 1;
    const auto next = record.find(marker, start);
    std::cout << "From index " << start << ": ";
    if (next == std::string::npos) {
        std::cout << "not found\n";
    } else {
        std::cout << next << '\n';
    }
}

Resultado

C string: 1
Counted separator: 3
From index 4: not found

La llamada con solo el puntero busca `:` y devuelve `1`. La llamada con longitud encuentra el separador obligatorio completo `:\0=` en el índice `3`. Buscar el mismo patrón como vista desde el índice `4` devuelve `npos`.

Lecciones relacionadas

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

Fuentes