Me fue asignado por mi maestro para escribir mi propia strcmp() función en C. me hizo crear mi propia versión de dicha función, y tenía la esperanza de obtener alguna información.

int CompareTwoStrings ( char *StringOne, char *StringTwo ) {
    //Evaluates if both strings have the same length.
    if  ( strlen ( StringOne ) != strlen ( StringTwo ) ) {
        //Given that the strings have an unequal length, it compares between both
        //lengths.
        if  ( strlen ( StringOne ) < strlen ( StringTwo ) ) {
            return ( StringOneIsLesser );
        }
        if  ( strlen ( StringOne ) > strlen ( StringTwo ) ) {
            return ( StringOneIsGreater );
        }
    }
    int i;
    //Since both strings are equal in length...
    for ( i = 0; i < strlen ( StringOne ); i++ ) {
        //It goes comparing letter per letter.
        if  ( StringOne [ i ] != StringTwo [ i ] ) {
            if  ( StringOne [ i ] < StringTwo [ i ] ) {
                return ( StringOneIsLesser );
            }
            if  ( StringOne [ i ] > StringTwo [ i ] ) {
                return ( StringOneIsGreater );
            }
        }
    }
    //If it ever reaches this part, it means they are equal.
    return ( StringsAreEqual );
}

StringOneIsLesser, StringOneIsGreater, StringsAreEqual se define como const int con los respectivos valores: -1, +1, 0.

Cosa es que, no estoy exactamente seguro de que si, por ejemplo, mi StringOne tiene una menor longitud de mi StringTwo, que automáticamente significa StringTwo es mayor, porque no sé cómo strcmp() es particularmente implementado. Necesito algunos de sus comentarios para que.

  • Entonces, ¿cuál es la pregunta?
  • Para obtener algunos de los comentarios de que el código que he publicado. Pensé que me lo dejó claro.
  • Este no es el mejor sitio para comentarios generales. CodeReview.stackexchange.com es bueno para eso. Dado que, la pregunta que me contestó fue «Si StringOne tiene una menor longitud de mi StringTwo, [¿] que significa automáticamente StringTwo es mayor?»
  • Oh, lo siento, yo no sabía que. También, lo siento por la gramática problemas, el inglés no es mi idioma nativo (soy de Chile).
  • No vas a complicar el problema un poco? Un estándar strcmp aplicación del cuerpo puede fácilmente ser escrita en 3 líneas… mover los dos punteros hacia adelante, mientras que el punto de caracteres idénticos (con cuidado de dejar en la cadena de terminadores) y, a continuación, sólo tienes que comparar los caracteres que llegamos, que será la primera distintas.
  • Como he dicho, yo estaba tratando de evitar el uso de punteros para comparar, porque todavía no me siento cómodo usando punteros. Tal vez debería haber dejado claro desde el principio.
  • Esto escanea ambas cadenas de longitud completa, posiblemente varias veces, mientras que los ortodoxos strcmp() normalmente sólo tiene que mirar en el primer carácter de encontrar una diferencia. Eso es un gran impacto en el rendimiento si las cadenas son muchos kilobytes de largo.
  • Sólo un consejo: no usar strlen(cadena1) dentro del bucle for. Es muy malo para la velocidad. El uso de un auxiliar de variables tales como: int tamaño = strlen(cadena1) y, a continuación, utilizar esa variable en el bucle. (for(i=0;i<tamaño);i++)
  • Perdón si me entienden mal que @jofra, pero lo que estás dando a entender es que si puedo utilizar la función strlen (cadena)’ dentro del bucle for, el código DEBE calcular un nuevo valor de ‘strlen (cadena)’ después de cada incremento de «yo», incluso aunque se mantiene el mismo valor? Porque si esa la razón por la que estoy totalmente de por qué se retrasa la ejecución del código.
  • Sí. Se calcula que cada bucle y así es cuadrática (O(N^2)), en lugar de ser lineal O(N). En otras palabras se ejecuta mucho más lento (realmente adjudicar cuando n, el número de caracteres de la cadena, es grande), si usted tiene que calcular la función strlen(cadena) cada vez que se repite.

InformationsquelleAutor ShadowGeist | 2014-04-09

6 Comentarios

  1. 6

    Mucho para una tarea simple. Creo que algo tan simple como esto haría:

    int my_strcmp(char *a, char *b)
    {
        while (*a && *b && *a == *b) { ++a; ++b; }
        return (unsigned char)(*a) - (unsigned char)(*b);
    }
    • Yo echaría a int antes de restar para evitar desbordamientos/underflows. También, los argumentos deben ser const.
    • Si me permiten, para ser totalmente honesto, no tengo idea de lo que hace. Yo estaba tratando de evitar el uso de punteros porque todavía estoy muy verde en el uso de punteros. Mi idea de la comparación de ambas cadenas, fue la comparación de ellos, letra por letra.
    • Tenga en cuenta que el » reparto a int la sugerencia es especialmente importante si char es un entero de tipo.
    • Todos los tipos primitivos son signed a menos que se indique lo contrario, así que no pienso que sea un problema. Además, strcmp se supone comparar el texto legible y no necesita ser binario caja fuerte, tan inesperado comportamiento de la envolvente aritmética con «negativo» de los símbolos es algo que no se preocupe con la consideración de que usted está usando strcmp para realizar la tarea para la que fue diseñado-comparar y ordenar texto.
    • while (*a && *a == *b) { ++a; ++b; } iba a hacer.
    • UTF8 texto es el ser más aplicada en estos días y se utiliza con strcmp(), así char está en el rango de -128 a -1 (o (de 128 a 255) en el más común que es el uso de ser,
    • La funcionalidad de strcmp() hace no dependen de la señal-ness de char. strcmp() se especifica a realizar como si «cada personaje será interpretado como si tuviera el tipo de unsigned char«. C11 7.23.1. Así unsigned char los yesos son buenas. Este código se compila con strcmp() siempre que 1) int mucho más alcance que unsigned char (en general esto es cierto) y 2) char utiliza el complemento a 2 (en general esto es cierto también). Pero es no coincidir con el const parte de la strcmp() firma.

  2. 3

    strcmp compara alfabéticamente: así "aaa" < "b" a pesar de que «b» es más corto.

    Debido a esto, puede omitir la comprobación de la longitud y no con la letra por letra comparación. Si se llega a un carácter NULO, mientras que las dos cadenas son iguales, por lo que ahora, el más corto es el menos uno.

    También: hacer StringsAreEqual == 0, no 1 para la compatibilidad con el estándar de funciones de clasificación.

  3. 1
        int mystrncmp(const char * str1, const char * str2, unsigned int n)
         {
          while (*str1 == *str2) {
              if (*str1 == '
        int mystrncmp(const char * str1, const char * str2, unsigned int n)
    {
    while (*str1 == *str2) {
    if (*str1 == '\0' || *str2 == '\0')
    break;
    str1++;
    str2++;
    }
    if (*str1 == '\0' && *str2 == '\0')
    return 0;
    else
    return -1;
    }
    '
    || *str2 == '
        int mystrncmp(const char * str1, const char * str2, unsigned int n)
    {
    while (*str1 == *str2) {
    if (*str1 == '\0' || *str2 == '\0')
    break;
    str1++;
    str2++;
    }
    if (*str1 == '\0' && *str2 == '\0')
    return 0;
    else
    return -1;
    }
    '
    ) break; str1++; str2++; } if (*str1 == '
        int mystrncmp(const char * str1, const char * str2, unsigned int n)
    {
    while (*str1 == *str2) {
    if (*str1 == '\0' || *str2 == '\0')
    break;
    str1++;
    str2++;
    }
    if (*str1 == '\0' && *str2 == '\0')
    return 0;
    else
    return -1;
    }
    '
    && *str2 == '
        int mystrncmp(const char * str1, const char * str2, unsigned int n)
    {
    while (*str1 == *str2) {
    if (*str1 == '\0' || *str2 == '\0')
    break;
    str1++;
    str2++;
    }
    if (*str1 == '\0' && *str2 == '\0')
    return 0;
    else
    return -1;
    }
    '
    ) return 0; else return -1; }
    • Mientras este fragmento de código se puede resolver la cuestión, , incluyendo una explicación de realmente ayuda a mejorar la calidad de tu post. Recuerde que usted está respondiendo a la pregunta para los lectores en el futuro, y esas personas pueden no saber las razones de su sugerencia de código.
    • ¿Cuál es el propósito del tercer parámetro de la función: unsigned int n?
  4. 0

    Pruebe esto también para su mejor comprensión:

    #include <stdio.h>
    #include <string.h>
    int main(void)
    {
    char string1[20], string2[20];
    int i=0,len=0, count=0;
    puts("enter the stirng one to compare");
    fgets(string1, sizeof(string1), stdin);
    len = strlen(string1);
    if(string1[len-1]=='\n')
    string1[len-1]='\0';
    puts("enter the stirng two to compare");
    fgets(string2, sizeof(string2), stdin);
    len = strlen(string2);
    if(string2[len-1]=='\n')
    string2[len-1]='\0';
    if(strlen(string1)==strlen(string2))
    {
    for(i=0;string1[i]!='\0', string2[i]!='\0', i<strlen(string1);i++)
    {
    count=string1[i]-string2[i];
    count+=count;
    }
    if(count==0)
    printf("strings are equal");
    else if(count<0)
    printf("string1 is less than string2");
    else if(count>0)
    printf("string2 is less than string1");
    }
    if(strlen(string1)<strlen(string2))
    {
    for(i=0;string1[i]!='\0', i<strlen(string1);i++)
    {
    count=string1[i]-string2[i];
    count+=count;
    }
    if(count==0)
    printf("strings are equal");
    else if(count<0)
    printf("string1 is less than string2");
    else if(count>0)
    printf("string2 is less than string1");
    }
    if(strlen(string1)>strlen(string2))
    {
    for(i=0;string2[i]!='\0', i<strlen(string2);i++)
    {
    count=string1[i]-string2[i];
    count+=count;
    }
    if(count==0)
    printf("strings are equal");
    else if(count<0)
    printf("string1 is less than string2");
    else if(count>0)
    printf("string2 is less than string1");
    }
    return 0;
    }
  5. 0

    strcmp() es bastante fácil de código. El habitual mal codificaciones de problemas incluyen:

    Tipo de parámetro

    strcmp(s1,s2) utiliza const char * tipos, no char *. Esto permite que la función sea llamada con punteros a const de datos. Transmite al usuario la función de la no alteración de los datos. Puede ayudar con la optimización.

    Signo menos comparar

    Todos str...() función de realizar como si char fue unsigned char, incluso si char está firmado. Esto fácilmente afecta el resultado cuando las cadenas de caracteres diferentes y un carácter fuera de la gama [1...CHAR_MAX] se encuentra.

    Gama

    De seleccionar las implementaciones, la gama de unsigned char menos unsigned char está fuera de la int gama. El uso de 2 compara (a>b) - (a-b) evita cualquier problema en lugar de a-b;. Aún más: muchos compiladores reconocido que el lenguaje y emiten un buen código.

    int my_strcmp(const char *s1, const char *s2) {
    //All compares done as if `char` was `unsigned char`
    const unsigned char *us1 = (const unsigned char *) s1;
    const unsigned char *us2 = (const unsigned char *) s2;
    //As long as the data is the same and '\0' not found, iterate
    while (*us1 == *us2 && *us1 != '\0') {
    us1++;
    us2++;
    }
    //Use compares to avoid any mathematical overflow 
    //(possible when `unsigned char` and `unsigned` have the same range).
    return (*us1 > *us2) - (*us1 < *us2);
    }
  6. 0
    bool str_cmp(char* str1,char* str2)
    {
    if (str1 == nullptr || str2 == nullptr)
    return false;
    const int size1 = str_len_v(str1);
    const int size2 = str_len_v(str2);
    if (size1 != size2)
    return false;
    for(int i=0;str1[i] !='\0' && str2[i] !='\0';i++)
    {
    if (str1[i] != str2[i])
    return false;
    }
    return true;
    }
    • Sería bueno si usted explicar su solución

Dejar respuesta

Please enter your comment!
Please enter your name here