La culminación STRMCP se utiliza para comparar dos cadenas
La función memcmp se utiliza para comparar los primeros caracteres TAMAÑO de las cadenas s1 y s2.
Si los bloques de caracteres superiores de las dos cadenas son iguales, memcmp devolverá 0.
Función: int strcmp (const char *s1, const char *s2)
Esta función se utiliza para comparar las cadenas s1 y s2. Esta función devolverá un valor numérico cuyo signo es. lo mismo que Los resultados de la primera comparación de diferentes personajes están relacionados.
Si las dos cadenas son iguales, strcmp devolverá 0.
Si s1 es una subcadena de s2, entonces s1 es menor que s2
También hay funciones
int strncmp (const char *s1, const char * s2, size_t size)
Esta función es muy similar a strcmp. La diferencia es que la función strncmp especifica el tamaño de los caracteres a comparar. Es decir, si los primeros caracteres de tamaño de s1 y s2 son iguales, la función devuelve 0.
Comparación de funciones:
Ambas se pueden usar para comparar cadenas, pero hay una gran diferencia porque strcmp compara cadenas por bytes y busca el terminador "\0", una vez Cualquiera El puntero de cadena que encuentra un terminador mientras avanza finalizará la comparación. La función memcmp se usa para comparar si el contenido de dos bloques de memoria es igual. En la comparación de cadenas, generalmente se usa para verificar si las cadenas son iguales, en lugar de comparar cadenas por bytes. Si los objetos que se comparan contienen espacios rellenados en objetos de estructura debido a requisitos de alineación de límites, espacios adicionales al final de las uniones o "agujeros" causados por porciones no utilizadas del espacio de asignación de cadenas, es mejor usar memcmp para completar la comparación. El contenido de estos "agujeros" no está definido, al igual que el resultado de la comparación de bytes.
Diferencia de eficiencia:
strcmp compara cadenas, mientras que memcmp compara bloques de memoria. strcmp siempre necesita verificar si encuentra el carácter 0 al final de la cadena, pero memcmp no tiene que preocuparse por este problema en absoluto, por lo que memcmp es más eficiente que strcmp
Ejemplo de uso:
Tenemos la siguiente estructura.
La definición de la estructura se proporciona de la siguiente manera:
struct foo
{
etiqueta char unsigned;
unión
{
doble f;
largo i;
char *p;
} valor;
p>
};
Si desea comparar dos objetos struct foo, se recomienda utilizar memcmp.
Tomando la comparación de cadenas como ejemplo, determine si los primeros cuatro caracteres de la cadena str son 0x80100001, porque 0x00 es el terminador de la cadena.
Si usa strncmp, strncmp (str, "\x80\x10\x00\x01", 4), el efecto real es solo determinar si contiene 0x8010, es decir, una vez que los dos primeros caracteres de str son 0x8010, Se devolverá 0, es decir, lo mismo, ¡lo cual obviamente no es correcto! En este momento, se debe usar memcmp(str, "\x80\x10\x00\x01", 4), para que se pueda lograr el propósito
Adjunto: strcmp, strncmp, código fuente de memcmp Linux
/**
* strcmp - compara dos cadenas
* @cs: una cadena
* @ct:
*/
int strcmp(const char *cs, const char *ct)
{
char firmado __res;
while (1) {
if ((__res = *cs - *ct ) != 0 || !*cs )
//Comparación con el terminador \0, en esta vez, completado__res = *cs - *ct, pero en este momento los valores de *cs y *ct son ambos \0, por lo que el valor de retorno debe ser 0
break;
}
Devuelve __res
}
/**
* strncmp - compara dos longitudes Cadena restringida
* @cs: una cadena
* @ct: otra cadena
* @count: el número máximo de bytes para comparar
*/
int strncmp(const char *cs, const char *ct, size_t count)
{
char firmado __res = 0;
while (count) {
if ((__res = *cs - *ct ) != 0 || !*cs ) //comparar con el terminador \0, cuando, tener hecho __res = *cs - *ct, longitud tan desigual, ciertamente no devuelve 0
break;
count--;
}
return __res;
}
/**
* memcmp - compara dos áreas de memoria
* @ cs: una memoria area
* @ct: otra área de memoria
* @count: el tamaño del área.
*/
int memcmp(const void *cs, const void *ct, size_t count)
{
const unsigned char *su1, *su2;
int res = 0;
for (su1 = cs, su2 = ct; 0 lt; contar; su1, su2, contar--)
if ((res = *su1 - *su2) != 0)
break
return res; >
Programa de prueba:
#include lt;iostreamgt;
#include lt;stdio.hgt;
#include lt;stringgt;
p>
#include lt;stringgt;
#include lt;stringgt;
#include lt;stringgt;
Usar espacio de nombres std;
int main()
{
cadena str1 = "abcd";
cadena str2 = "abcdef";
int resultado1 = 0;
int resultado2 = 0;
int resultado3 = 0
resultado1 = strcmp(str1.c_str; (), str2 .c_str());
resultado2 = strncmp(str1.str(), str2.c_str(),
resultado3 = memcmp(str1.c_str). (), str2 .c_str(),7);
coutlt;lt; "strcmp:"lt;lt;result1lt;lt;endl;
coutlt; lt; "strncmp : "lt;lt;result2lt;lt;endl;
coutlt;lt; "memcmp: "lt;lt;result3lt;lt;endl;
getchar( );<
devuelve 0;
}
Conclusión:
Cadenas de ejemplo str1 = "abcd";
srr2 = "abcdef";
(1) El resultado de la comparación de strmcp es distinto de cero (no es igual).
(2) strncmp, si cuenta lt; = 4, el resultado es 0 (igual); si cuenta lt 4, el resultado es -101 (porque la longitud de la cadena más corta es 4, la la comparación se realiza en el quinto carácter, el valor de '\0' es el código ascii menos el valor ascii de 'e').
(3) memcpy, si el recuento es <= 4, el resultado es 0 (igual); si el recuento es >4, el resultado es -1 (finaliza la comparación con el recuento de bytes).