std::basic_string::compare

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de cadenas

Cadenas terminadas en nulo

Cadenas de bytes

Cadenas multibyte

De caracteres anchos

Clases

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Funciones miembro basic_string::basic_string basic_string::operator= basic_string::assign basic_string::get_allocator Acceso a elementos basic_string::at basic_string::operator[] basic_string::front (C++11) basic_string::back (C++11) basic_string::data basic_string::c_str basic_string::operator basic_string_view (C++17) Iteradores basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Capacidad basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (C++11)

Operaciones basic_string::clear basic_string::insert basic_string::erase basic_string::push_back basic_string::pop_back (C++11) basic_string::append basic_string::operator+= basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::replace basic_string::substr basic_string::copy basic_string::resize basic_string::swap Búsqueda basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of Constantes basic_string::npos

Funciones no miembro operator+ swap(std::basic_string) operator""s (C++14) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) E/S operator<<operator>> getline Comparación operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20) Conversión numérica (C++11) stoistolstoll stoulstoull stofstodstold to_string to_wstring Clases auxiliares hash<std::string>hash<std::wstring>hash<std::u32string>hash<std::u16string>hash<std::u8string> (C++11)(C++11)(C++11)(C++11)(C++20) hash<std::pmr::string>hash<std::pmr::wstring>hash<std::pmr::u32string>hash<std::pmr::u16string>hash<std::pmr::u8string> (C++20)(C++20)(C++20)(C++20)(C++20) Guías de deducción(C++17)

 

	(1)
int compare(const basic_string& str )const;			(hasta C++11)
int compare(const basic_string& str )constnoexcept;			(desde C++11) (hasta C++20)
constexprint compare(const basic_string& str )constnoexcept;			(desde C++20)
		(2)
int compare( size_type pos1, size_type count1,              const basic_string& str )const;				(hasta C++20)
constexprint compare( size_type pos1, size_type count1,                        const basic_string& str )const;				(desde C++20)
			(3)
int compare( size_type pos1, size_type count1,              const basic_string& str,              size_type pos2, size_type count2 )const;					(hasta C++14)
int compare( size_type pos1, size_type count1,              const basic_string& str,              size_type pos2, size_type count2 = npos )const;					(desde C++14) (hasta C++20)
constexprint compare( size_type pos1, size_type count1,                        const basic_string& str,                        size_type pos2, size_type count2 = npos )const;					(desde C++20)
				(4)
int compare(const CharT* s )const;						(hasta C++20)
constexprint compare(const CharT* s )const;						(desde C++20)
					(5)
int compare( size_type pos1, size_type count1,              const CharT* s )const;							(hasta C++20)
constexprint compare( size_type pos1, size_type count1,                        const CharT* s )const;							(desde C++20)
						(6)
int compare( size_type pos1, size_type count1,              const CharT* s, size_type count2 )const;								(hasta C++20)
constexprint compare( size_type pos1, size_type count1,                        const CharT* s, size_type count2 )const;								(desde C++20)
							(7)
template<class T > int compare(const T& t )constnoexcept(/* véase más abajo */);									(desde C++17) (hasta C++20)
template<class T > constexprint compare(const T& t )constnoexcept(/* véase más abajo */);									(desde C++20)
								(8)
template<class T > int compare( size_type pos1, size_type count1,              const T& t )const;										(desde C++17) (hasta C++20)
template<class T > constexprint compare( size_type pos1, size_type count1,                        const T& t )const;										(desde C++20)
									(9)
template<class T > int compare( size_type pos1, size_type count1,              const T& t,              size_type pos2, size_type count2 = npos)const;											(desde C++17) (hasta C++20)
template<class T > constexprint compare( size_type pos1, size_type count1,                        const T& t,                        size_type pos2, size_type count2 = npos)const;											(desde C++20)

Compara dos secuencias de caracteres.

1) Compara esta cadena con str.

2) Compara una subcadena [pos1, pos1+count1) de esta cadena con str. Si count1 > size()- pos1 la subcadena es [pos1, size()).

3) Compara una subcadena [pos1, pos1+count1) de esta cadena con una subcadena [pos2, pos2+count2) de str. Si count1 > size()- pos1 la primer subcadena es [pos1, size()). De la misma manera, count2 > str.size()- pos2 la segunda subcadena es [pos2, str.size()).

4) Compara esta cadena con la secuencia de caracteres terminada en nulo que empieza en el carácter al que apunta s con longitud Traits::length(s).

5) Compara una subcadena [pos1, pos1+count1) de esta cadena con la secuencia de caracteres terminada en nulo que empieza en el carácter al que apunta s con longitud Traits::length(s). Si count1 > size()- pos1 la subcadena es [pos1, size()).

6) Compara una subcadena [pos1, pos1+count1) de esta cadena con los caracteres en el rango [s, s + count2). Si count1 > size()- pos1 la subcadena es [pos1, size()). (Nota: los caracteres en el rango [s, s + count2) pueden incluir caracteres nulos.)

7) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces compara esta cadena con sv. Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false.

8) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces compara una subcadena [pos1, pos1+count1) de esta cadena to sv, como si fuera mediante std::basic_string_view<CharT, Traits>(*this).substr(pos1, count1).compare(sv). Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false.

9) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces compara una subcadena [pos1, pos1+count1) de esta cadena con una subcadena [pos2, pos2+count2) de sv como si fuera mediante std::basic_string_view<CharT, Traits>(*this).substr(pos1, count1).compare(sv.substr(pos2, count2)). Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false.

Una secuencia de caracteres que consiste en count1 caracteres que empieza en data1 se compara con una secuencia de caracteres que consiste en count2 caracteres que empiezan en data2 de la manera siguiente. Primero, calcular el número de caracteres a comparar, como si fuera mediante size_type rlen =std::min(count1, count2). Luego comparar las secuencias llamando a Traits::compare(data1, data2, rlen). Para las cadenas estándar, esta función realiza una comparación lexicográfica de carácter por carácter. Si el resultado es cero (hasta ahora las secuencias de caracteres son iguales), entonces se comparan sus tamaños de la manera siguiente:

Condición		Resultado	Valor de retorno
Traits::compare(data1, data2, rlen) < 0		data1 es menor que data2	<0
Traits::compare(data1, data2, rlen) == 0	size1 < size2	data1 es menor que data2	<0
	size1 == size2	data1 es igual a data2	​0​
	size1 > size2	data1 es mayor que data2	>0
Traits::compare(data1, data2, rlen) > 0		data1 es mayor que data2	>0

Parámetros

str	-	La otra cadena a comparar.
s	-	Puntero a la cadena de caracteres a comparar.
count1	-	Número de caracteres de esta cadena a comparar.
pos1	-	Posición del primer carácter en esta cadena a comparar.
count2	-	Número de caracteres de la cadena dada a comparar.
pos2	-	Posición del primer carácter de la cadena dada a comparar.
t	-	Objeto convertible a std::basic_string_view) a comparar.

Valor de retorno

Un valor negativo si *this ocurre antes de la secuencia de caracteres especificada por los argumentos, en orden lexicográfico.

Cero si ambas secuencias de caracteres se comparan como equivalentes.

Un valor positivo si *this ocurre después de la secuencia de caracteres especificada por los argumentos, en orden lexicográfico.

Excepciones

Las sobrecargas que toman los parámetros denominados pos1 o pos2 lanzan std::out_of_range si el argumento se encuentra fuera de rango.

7)

Especificación noexcept:   (desde C++11)

noexcept(std::is_nothrow_convertible_v<const T&, std::basic_string_view<CharT, Traits>>)

8-9) Lanza cualquier cosa que se lance por la conversión a basic_string_view.

Posible implementación

template<class CharT, class Traits, class Alloc>int basic_string<CharT, Traits, Alloc>::compare(conststd::basic_string& s)constnoexcept{ size_type lhs_sz = size(); size_type rhs_sz = s.size();int result = traits_type::compare(data(), s.data(), std::min(lhs_sz, rhs_sz));if(result !=0)return result;if(lhs_sz < rhs_sz)return-1;if(lhs_sz > rhs_sz)return1;return0;}

Notas

Para las situaciones donde no se requiera comparación de tres vías, std::basic_string proporciona los operadores relacionales habituales (<, <=, ==, >, etc).

Por defecto (con los rasgos de caracteres std::char_traits por defecto), esta función no es susceptible a la configuración regional. Véase std::collate::compare para comparación de cadenas de tres vías susceptible a la configuración regional.

Ejemplo

Ejecuta este código

#include <cassert>#include <string>#include <iostream>   int main(){// 1) Comparar con otra cadena{int compare_value{std::string{"Batman"}.compare(std::string{"Superman"})};std::cout<<( compare_value <0?"Batman esta antes que Superman\n": compare_value >0?"Superman esta antes que Batman\n":"Superman y Batman son iguales.\n");}   // 2) Comparar subcadena con otra cadena{int compare_value{std::string{"Batman"}.compare(3, 3, std::string{"Superman"})};std::cout<<( compare_value <0?"hombre esta antes que Superman\n": compare_value >0?"Superman esta antes que hombre\n":"hombre y Superman son iguales.\n");}   // 3) Comparar subcadena con otra subcadena{std::string a{"Batman"};std::string b{"Superman"};   int compare_value{a.compare(3, 3, b, 5, 3)};   std::cout<<( compare_value <0?"hombre esta antes que hombre\n": compare_value >0?"hombre esta antes que hombre\n":"hombre y hombre son iguales.\n");// Comparar subcadena con otra subcadena// hasta el final de la otra subcadenaassert(compare_value == a.compare(3, 3, b, 5));}   // 4) Comparar con puntero a char{int compare_value{std::string{"Batman"}.compare("Superman")};   std::cout<<( compare_value <0?"Batman esta antes que Superman\n": compare_value >0?"Superman esta antes que Batman\n":"Superman y Batman son iguales.\n");}   // 5) Comparar subcadena con puntero a char{int compare_value{std::string{"Batman"}.compare(3, 3, "Superman")};   std::cout<<( compare_value <0?"hombre esta antes que Superman\n": compare_value >0?"Superman esta antes que hombre\n":"hombre y Superman son iguales.\n");}   // 6) Comparar subcadena con subcadena de puntero a char{int compare_value{std::string{"Batman"}.compare(0, 3, "Superman", 5)};   std::cout<<( compare_value <0?"Bat esta antes que Super\n": compare_value >0?"Super esta antes que Bat\n":"Super y Bat son iguales.\n");}}

Salida:

Batman esta antes que Superman Superman esta antes que hombre hombre y hombre son iguales. Batman esta antes que Superman Superman esta antes que hombre Bat esta antes que Super

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2946	C++17	La sobrecarga string_view causa ambigüedad en algunos casos.	Se evitó haciéndola una plantilla.
P1148R0	C++11 C++17	noexcept para las sobrecargas (4)/(5) fue accidentalmente eliminado por LWG2064/LWG2946	Se restauró.

Véase también

operator==operator!=operator<operator>operator<=operator>=	Comparación lexicográfica de dos cadenas de texto (plantilla de función)
substr	Devuelve una subcadena (función miembro pública)
collate	Define la comparación lexicográfica y hashing (resumen) de cadenas. (plantilla de clase)
strcoll	Compara dos cadenas de acuerdo a la configuración regional actual (función)
lexicographical_compare	Devuelve true si un rango es lexicográficamente menor que otro. (plantilla de función)