cómo comprobar el inicio de cadena en C ++

¿Hay alguna manera en C ++ para verificar si una cadena comienza con una cierta cadena (más pequeña que la original)? Como lo podemos hacer en Java

bigString.startswith(smallString); 

 std::string s("Hello world"); if (s.find("Hello") == 0) { std::cout << "String starts with Hello\n"; } 

Puede hacer esto con string::compare() , que ofrece varias opciones para comparar todas o partes de dos cadenas. Esta versión compara smallString con el prefijo de tamaño apropiado de bigString (y funciona correctamente si bigString es más corto que smallString ):

 bigString.compare(0, smallString.length(), smallString) == 0 

startsWith() a envolver esto en una función gratuita llamada startsWith() , ya que de lo contrario puede parecer un poco misterioso.

ACTUALIZACIÓN: C ++ 20 agrega nuevas funciones starts_with y ends_with , por lo que finalmente podrá escribir solo bigString.starts_with(smallString) .

Los enfoques que usan string::find() o string::substr() no son óptimos ya que hacen una copia de su cadena o buscan más que coincidencias al principio de la cadena. Puede que no sea un problema en su caso, pero si lo es, podría usar el algoritmo std::equal . Recuerde verificar que el “pajar” sea al menos tan largo como la “aguja”.

 #include  using namespace std; bool startsWith(const string& haystack, const string& needle) { return needle.length() <= haystack.length() && equal(needle.begin(), needle.end(), haystack.begin()); } 

La solución correcta, como siempre, viene de Boost: boost::algorithm::starts_with .

Para optimizar un poco:

 if ( smallString.size() <= bigString.size() && strncmp( smallString.c_str(), bigString.c_str(), smallString.length() ) == 0 ) 

No olvide #include o #include

El enfoque más simple sería:

 if ( smallString.size() <= bigString.size() && std::equals( smallString.begin(), smallString.end(), bigString.end() ) 

(Esto también funcionará si uno de los dos, o ambos, es un vector o cualquier otro tipo de contenedor estándar).

Con C ++ 20 puede usar std::basic_string::starts_with (o std::basic_string_view::starts_with ):

 #include  std::string_view bigString_v("Winter is gone"); // std::string_view avoids the copy in substr below. std::string_view smallString_v("Winter"); if (bigString_v.starts_with(smallString_v)) { std::cout << "Westeros" << bigString_v.substr(smallString_v.size()); } 

strstr() devuelve un puntero a la primera aparición de una cadena dentro de una cadena.

Pensé que tiene sentido publicar una solución sin formato que no use ninguna función de la biblioteca …

 // Checks whether `str' starts with `start' bool startsWith(const std::string& str, const std::string& start) { if (&start == &str) return true; // str and start are the same string if (start.length() > str.length()) return false; for (size_t i = 0; i < start.length(); ++i) { if (start[i] != str[i]) return false; } return true; } 

Añadiendo un std::tolower simple podemos hacer que este caso no sea sensible

 // Checks whether `str' starts with `start' ignoring case bool startsWithIgnoreCase(const std::string& str, const std::string& start) { if (&start == &str) return true; // str and start are the same string if (start.length() > str.length()) return false; for (size_t i = 0; i < start.length(); ++i) { if (std::tolower(start[i]) != std::tolower(str[i])) return false; } return true; } 

Me sorprende que nadie haya publicado este método todavía:

 #include  using namespace std; bool starts_with(const string& smaller_string, const string& bigger_string) { return (smaller_string == bigger_string.substr(0,smaller_string.length())); } 

Cree una subcadena que sea la longitud de su variable smallString y compare las dos. O haga una búsqueda de la subcadena smallString y vea si devuelve el índice 0

http://www.cplusplus.com/reference/string/string/substr/

Puede usar string.substr () para ver cualquier cantidad de caracteres desde cualquier posición, o puede usar un miembro string.find ().