La inversión de una cadena en C

He desarrollado un inversa programa de cadena. Me pregunto si hay una manera mejor de hacer esto, y si mi código tiene cualquier problema potencial. Estoy buscando a la práctica algunas de las características avanzadas de C.

char* reverse_string(char *str)
{
    char temp;
    size_t len = strlen(str) - 1;
    size_t i;
    size_t k = len;

    for(i = 0; i < len; i++)
    {
        temp = str[k];
        str[k] = str[i];
        str[i] = temp;
        k--;

        /* As 2 characters are changing place for each cycle of the loop
           only traverse half the array of characters */
        if(k == (len / 2))
        {
            break;
        }
    }
}
  • Esta pregunta es similar stackoverflow.com/questions/219420/…
  • strlen(cadena)-1 subdesbordamiento si la cadena está vacía
  • Podemos utilizar i < len/2 dentro del bucle ` for(i = 0; i < len/2; i++) { temp = str[k]; str[k] = str[i]; str[i] = temp; j–; } `
InformationsquelleAutor ant2009 | 2009-04-24

23 Kommentare

  1. 61

    Si quieres practicar características avanzadas de C, ¿punteros?
    Podemos echar en macros y xor-swap para la diversión también!

    #include <string.h> //for strlen()
    
    //reverse the given null-terminated string in place
    void inplace_reverse(char * str)
    {
      if (str)
      {
        char * end = str + strlen(str) - 1;
    
        //swap the values in the two given variables
        //XXX: fails when a and b refer to same memory location
    #   define XOR_SWAP(a,b) do\
        {\
          a ^= b;\
          b ^= a;\
          a ^= b;\
        } while (0)
    
        //walk inwards from both ends of the string, 
        //swapping until we get to the middle
        while (str < end)
        {
          XOR_SWAP(*str, *end);
          str++;
          end--;
        }
    #   undef XOR_SWAP
      }
    }

    Un puntero (por ejemplo,char *, se lee de derecha a izquierda como un puntero a una char) es un tipo de datos en C que se utiliza
    para referirse a la ubicación en la memoria de otro valor. En este caso,
    es el lugar donde un char se almacena. Podemos eliminar
    los punteros por un prefijo con un *, lo que nos da el valor
    almacenado en ese lugar. Por lo que el valor almacenado en str es *str.

    Podemos hacer operaciones aritméticas sencillas con punteros. Cuando nosotros incremento (o decremento)
    un puntero, simplemente movemos para referirse a la siguiente (o anterior)
    ubicación de la memoria para ese tipo de valor. El incremento de los punteros de
    diferentes tipos puede mover el puntero por un número diferente de
    bytes debido a que los diferentes valores de bytes diferentes tamaños en C.

    Aquí, se puede utilizar un puntero para referirse a la primera sin procesar
    char de la cadena (str) y otro para referirse a la última (end).
    Podemos cambiar sus valores (*str y *end), y mover los punteros
    al interior, hacia el centro de la cuerda. Una vez str >= end, ya sea
    ambos apuntan a la misma char, lo que significa que nuestra cadena original tenía un
    longitud impar (y el medio char no necesita ser revertido), o
    hemos procesado todo.

    Para hacer el trueque, he definido un macro. Las Macros son la sustitución de texto
    hecho por el preprocesador de C. Son muy diferentes de las funciones,
    y es importante saber la diferencia. Cuando se llama a una función,
    la función opera sobre una copia de los valores que le dan. Cuando llame
    una macro, simplemente hace un texto de sustitución – así que los argumentos que se dan
    se usan directamente.

    Ya que sólo utiliza el XOR_SWAP macro una vez, fue algo excesivo para definir,
    pero hizo más clara de lo que estaba haciendo. Después de que el preprocesador de C se expande la macro,
    el bucle while se parece a esto:

        while (str < end)
        {
          do { *str ^= *end; *end ^= *str; *str ^= *end; } while (0);
          str++;
          end--;
        }

    Tenga en cuenta que la macro argumentos se muestran de una vez por cada vez que se usan en la
    definición de macro. Esto puede ser muy útil, pero también puede romper su código
    si se usan incorrectamente. Por ejemplo, si yo había comprimido el incremento/decremento
    instrucciones y la llamada de macro en una sola línea, como

          XOR_SWAP(*str++, *end--);

    A continuación, este se expande a

          do { *str++ ^= *end--; *end-- ^= *str++; *str++ ^= *end--; } while (0);

    Que ha triple el incremento/decremento de operaciones, y en realidad no
    hacer el swap se supone que debe hacer.

    Mientras estamos en el tema, usted debe saber lo que xor (^) significa. Es un básico
    operaciones aritméticas como suma, resta, multiplicación, división, excepto
    normalmente no se enseña en la escuela primaria. Combina dos enteros de a poco
    – como la adición, pero no nos preocupamos de las prórrogas. 1^1 = 0, 1^0 = 1,
    0^1 = 1, 0^0 = 0.

    Un conocido truco es usar xor para intercambiar dos valores. Esto funciona debido a que de los tres básicos
    propiedades de xor: x ^ 0 = x, x ^ x = 0 y x ^ y = y ^ x para todos los valores x y y. Así que decir que tenemos dos
    variables a y b que inicialmente almacenar dos valores
    va y vb.

     //inicialmente: 
    //a == va 
    //b == va 
    a ^= b; 
    //ahora: a == va ^ va 
    b ^= a; 
    //ahora: b == va ^ (va ^ va) 
    //== va ^ (va ^ va) 
    //== va ^ 0 
    //== va 
    a ^= b; 
    //ahora: a == (va ^ va) ^ va 
    //== (va ^ va) ^ va 
    //== 0 ^ va 
    //== va 
    

    Por lo que los valores se intercambian. Esto tiene un bug cuando a y b son la misma variable:

     //inicialmente: 
    //a == va 
    a ^= a; 
    //ahora: a == va ^ va 
    //== 0 
    a ^= a; 
    //ahora: a == 0 ^ 0 
    //== 0 
    a ^= a; 
    //ahora: a == 0 ^ 0 
    //== 0 
    

    Ya que str < end, esto no ocurre nunca en el código de arriba, así que estamos bien.

    Mientras estamos preocupados acerca de la exactitud debemos revisar nuestros casos de borde. El if (str) línea, debe asegurarse de que no nos dieron un NULL puntero de cadena. ¿Qué acerca de la cadena vacía ""? Bien strlen("") == 0, así que vamos a inicializar end como str - 1, lo que significa que el while (str < end) condición nunca es verdadera, con lo que no podemos hacer nada. Lo cual es correcto.

    Hay un montón de C a explorar. Tener diversión con ella!

    Actualización: mmw trae un buen punto, que es que usted tiene que ser un poco cuidadoso en la forma de invocar este, como lo hace funcionar en el lugar.

     char stack_string[] = "This string is copied onto the stack.";
     inplace_reverse(stack_string);

    Esto funciona bien, ya que stack_string es una matriz, cuyos contenidos se inicializan a la constante de cadena. Sin embargo

     char * string_literal = "This string is part of the executable.";
     inplace_reverse(string_literal);

    Hará que el código llama y de morir en tiempo de ejecución. Eso es porque string_literal simplemente apunta a la cadena que se almacena como parte de su archivo ejecutable – que normalmente es la memoria que no está permitido modificar el sistema operativo. En un mundo más feliz, el compilador sabe de esto, y de la tos de un error cuando trató de compilar, diciendo que string_literal debe ser de tipo char const * ya que no se puede modificar el contenido. Sin embargo, este no es el mundo de mi compilador vive en.

    Hay algunos hacks usted podría tratar de asegurarse de que la memoria está en la pila o en el montón (y por lo tanto es editable), pero no son necesariamente portátil, y que podría ser bastante feo. Sin embargo, yo estoy más que feliz para lanzar esta responsabilidad a la función de invocador. Yo les he dicho que hace esta función en lugar de la memoria de la manipulación, es su responsabilidad para darme un argumento que permite que.

    • Bueno, he de comprobar que con el if(str) de la línea – y ya que estoy invirtiendo en su lugar, sólo tiene que preocuparse acerca de la entrada.
    • Ah. Veo lo que quieres decir ahora. Usted quiere decir que necesita para asegurarse de que el argumento no es para un char const * que es parte de la binaria. Esto es cierto de todos los directamente la inversión y debe tenerse en cuenta. Si usted había dicho char s[] = "Dante Alighieri est né";, entonces eso estaría bien, ya que iba a estar en la pila. Por desgracia, creo que no es un portátil de verificar esto. En un mundo ideal, el compilador habría requerido su ejemplo a ser char const * s = "..." desde el lado derecho es no modificables.
    • Tal vez te importaría que nos revelan por qué xor swap es realmente una buena idea? Es generalmente más lento que el «llano» de la versión, es más difícil de leer y no de forma espectacular si intenta cambiar una dirección de sí mismo.
    • A la vez precisa de los puntos; sin embargo, mi objetivo aquí era no escribir el código más eficiente, pero sólo para tener una excusa para escribir sobre varios C características y Cisms Xor swap es bueno saber acerca de, si sólo lo reconozca.
  2. 24

    Sólo un reordenamiento, y la revisión de seguridad. También he eliminado tu no utilizado tipo de retorno. Creo que este es un lugar seguro y limpio como se consigue:

    #include <stdio.h>
    #include <string.h>
    
    void reverse_string(char *str)
    {
        /* skip null */
        if (str == 0)
        {
            return;
        }
    
        /* skip empty string */
        if (*str == 0)
        {
            return;
        }
    
        /* get range */
        char *start = str;
        char *end = start + strlen(str) - 1; /* -1 for \0 */
        char temp;
    
        /* reverse */
        while (end > start)
        {
            /* swap */
            temp = *start;
            *start = *end;
            *end = temp;
    
            /* move */
            ++start;
            --end;
        }
    }
    
    
    int main(void)
    {
        char s1[] = "Reverse me!";
        char s2[] = "abc";
        char s3[] = "ab";
        char s4[] = "a";
        char s5[] = "";
    
        reverse_string(0);
    
        reverse_string(s1);
        reverse_string(s2);
        reverse_string(s3);
        reverse_string(s4);
        reverse_string(s5);
    
        printf("%s\n", s1);
        printf("%s\n", s2);
        printf("%s\n", s3);
        printf("%s\n", s4);
        printf("%s\n", s5);
    
        return 0;
    }

    Editado para que no apuntan a una posible mala ubicación de memoria cuando strlen es 0.

    • Voy a ser un pedante tirón aquí. Hay algo seguro en esta función: la línea de «char* fin = inicio + strlen(str) – 1;» se traduce en un comportamiento indefinido cuando strlen(str)==0.
    • Je, yo pensé que después de que he publicado, pero justo iba a la esperanza de que nadie vio :> Aunque esto no es indefinido, es? Apuntará a una mala ubicación de la memoria, de lo que es malo, pero es aún bien definido, sí? En cualquier caso, he actualizado mi post para más seguridad. Me dicen que si hay más 🙂 me esfuerzo para la corrección.
    • Aunque esto es poco probable que sea un problema real en la mayoría de los entornos, es un comportamiento indefinido por la norma. El estándar permite la aritmética de punteros a resultado en punteros dentro de la matriz o a uno más allá del último elemento de la matriz (en este último caso, el puntero no está permitido se eliminan las referencias, por supuesto).
    • Ah, ok, es bueno saberlo, gracias. ‘Cept ahora has hecho con mi código más feo 😛
    • Lo siento uglifying el código… desde el strrev() de rutina se utiliza muy a menudo en las entrevistas, este poco es algo que siempre buscamos. No tengo rencor contra alguien (si ese es el peor problema de la función, creo que no hay mucho de qué preocuparse), pero señalando hacia fuera puede estimular aún más la conversación que da una perspectiva adicional.
    • Oh, está bien. 🙂 Mira, he encontrado un modo más limpio 😀 😛
    • Yo dudaba de que @Michael Burr – así que busqué y que está a la derecha de la sección 6.5.6: «Si el puntero operando y el resultado del punto a elementos de la misma matriz de objetos, o uno después del último elemento de la matriz objeto de la evaluación no deberá producir un overflow; de lo contrario, el comportamiento es indefinido.» OTOH, nunca he estado en un compilador donde arbitraria resta era un problema.
    • Como he dicho, es poco probable que sea un problema real – la única que se me ocurre de la parte superior de mi cabeza es el buen viejo, obsoleto, segmentado de MS-DOS de la arquitectura. Si el puntero que pasó a ser en el índice 0 del segmento, entonces esto podría causar un problema.
    • Hay un montón de pequeñas plataformas embebidas en donde no se puede contar con una buena memoria lineal del modelo. En un PC, este no va a ser un problema (a menos que usted está ejecutando DOS), pero que su código no sea portable. Lo mejor es no hacer aritmética de punteros fuera de los límites de la matriz.

  3. 16

    Usted puede poner su (len/2) prueba en el bucle for:

    for(i = 0,k=len-1 ; i < (len/2); i++,k--)
    {
            temp = str[k];
            str[k] = str[i];
            str[i] = temp;
    
    }
    • Bueno +1. También podría escribir un INTERCAMBIO de Macro?
    • ¿cuál es k hacer
    • es en el código de la pregunta – es un índice comenzando por el último carácter de la cadena se mueve hacia el principio de la cadena. Todavía hay un bug que no es manejado – si la longitud de la cadena es 0 la inversa de la función se realiza de forma incorrecta. Esta respuesta no maneja apropiadamente ese escenario. Probablemente me agregue algo así como el equivalente de if (strlen(str) == 0) return; en el inicio de la función.
    • así que tengo que pasar a través de la longitud de la cadena
  4. 14

    Este completo programa muestra cómo iba a hacerlo. Tener en cuenta que fue escrito en C cuando la mayoría de ustedes whippersnappers fueron un brillo en sus madres los ojos por lo que es de la vieja escuela, hacer el trabajo, largo-var-nombres-son-para-los débiles. Revisión de que, si lo desea, estoy más interesado en la corrección del código.

    Se encarga de valores Nulos, cadenas vacías y todos los tamaños de la secuencia. Yo no lo he probado con cadenas de caracteres de tamaño máximo (max(size_t)), pero se debe trabajar, y si vas a manejar cadenas que grande, que estás loco de todos modos 🙂

    #include <stdio.h>
    #include <string.h>
    
    char *revStr (char *str) {
        char tmp, *src, *dst;
        size_t len;
        if (str != NULL)
        {
            len = strlen (str);
            if (len > 1) {
                src = str;
                dst = src + len - 1;
                while (src < dst) {
                    tmp = *src;
                    *src++ = *dst;
                    *dst-- = tmp;
                }
            }
        }
        return str;
    }
    
    char *str[] = {"", "a", "ab", "abc", "abcd", "abcde"};
    
    int main(int argc, char *argv[]) {
        int i;
        char s[10000];
        for (i=0; i < sizeof(str)/sizeof(str[0]); i++) {
            strcpy (s, str[i]);
            printf ("'%s' -> '%s'\n", str[i], revStr(s));
        }
        return 0;
    }

    La salida de la que es:

    '' -> ''
    'a' -> 'a'
    'ab' -> 'ba'
    'abc' -> 'cba'
    'abcd' -> 'dcba'
    'abcde' -> 'edcba'
    • Usted puede querer referirse a la poca conversación en GMan la respuesta: stackoverflow.com/questions/784417/c-reverse-a-string/…
    • Gracias, @MB, a pesar de que nunca va a ocurrir en la práctica, supongo que tenemos que seguir la norma. Actualizado para manejar cadenas vacías, y optimizado para manejar 1-cadenas de caracteres al mismo tiempo.
    • Pero el código no funciona. Se da la misma cadena w/o última char.
    • Absolutamente a la derecha, @Oleg, yo estaba usando strlen (src) (que era no inicializado) en lugar de strlen (str) – fijo ahora. Gracias por decírmelo. Para alguien «más interesado en la corrección del código», puedes pensar que yo he probado un poco 🙂
  5. 7

    Intente esto:

    reverse_string(NULL);
    reverse_string("");
    • Todas las funciones POSIX son indefinidos NULL, strlen, strcat, etc. Esta debe ser la responsabilidad de la persona que llama para comprobar el valor NULL, no la función. La basura en la basura. O en este caso, la basura en la continuación de violación de segmento.
    • Pero él tiene un punto con «».
    • «» es [const char*], no [char*] => usted puede invertir constantes en su lugar.
  6. 6

    Se podía cambiar el bucle for declaración para hacer el código más corto:

    char* reverse_string(char *str)
    {
        char temp;
        size_t len = strlen(str) - 1;
        size_t stop = len/2;
        size_t i,k;
    
        for(i = 0, k = len; i < stop; i++, k--)
        {
            temp = str[k];
            str[k] = str[i];
            str[i] = temp;
        }
        return str;
    }
    • ¿por qué crees que se estrelle?
    • por qué no: for (i = 0, k = len; i < k; i++, k–) …?
  7. 6

    Nadie hace uso de punteros más?

    void inplace_rev( char * s ) {
      char t, *e = s + strlen(s);
      while ( --e > s ) { t = *s;*s++=*e;*e=t; }
    }

    EDIT: lo Siento, acabo de dar cuenta de la anterior XOR ejemplo…

  8. 4

    No veo una instrucción return, y está cambiando la cadena de entrada, que puede ser un problema para el programador. Usted puede desear que la cadena de entrada para ser inmutable.

    También, esto puede ser exigente, pero len/2 debe ser calculado sólo una vez, de la OMI.

    Aparte de eso, va a trabajar, siempre y cuando usted toma el cuidado de que el problema de los casos mencionados por rossfabricant.

  9. 4
    void reverse(char *s)
    {
      char *end,temp;
      end = s;
      while(*end != '\0'){
        end++;
      }
      end--;  //end points to last letter now
      for(;s<end;s++,end--){
        temp = *end;
        *end = *s;
        *s = temp; 
      }
    }
  10. 2
    rev {
    int len = strlen(str)-1;
    for ( int i =0; i< len/2 ; i++ ) {
            char t = str[i];
            str[i] = str[len-i];
            str[len-i] = t;
            }
    
    }
  11. 2
    bool reverse_string(char* str)
    {
        //Make sure str is reversible
        if (!str ||  strlen(str) < 2)
            return false;
    
        char* first = str;
        char* last = str + strlen(str) - 1; //Minus 1 accounts for Index offset
        char temp;
    
        do{
            temp = *first;
            *first = *last;
            *last = temp;
        }
        while (++first < --last); //Update Pointer Addresses and check for equality
    
        return true;
    }

    Esta solución se basa en GManNickG el post con un par de modificaciones. La inicial de la instrucción lógica puede ser peligroso si !str no es evaluado antes de la operación strlen (Por un valor NULL ptr). Este no era el caso con el compilador. Yo quisiera añadir este código porque es un buen ejemplo de un do-while.

  12. 1

    Ya que dices que quieres obtener de fantasía, tal vez usted quiere intercambiar tus personajes utilizando un XOR de intercambio.

    • Idea Terrible :\
    • Ustedes no son divertidas. 🙂
    • Hace el xor truco incluso trabajar para firma de caracteres en cada sistema? De 32 bits de los caracteres?
    • Funciona siempre y cuando no se intercambian con la misma ubicación. Pero es mucho más lento que usar una variable temporal en la mayoría de plataformas de todos modos.
    • XOR swap utiliza las operaciones bit a bit. El resultado final de un XOR de intercambio es que las dos variables se intercambian va a terminar con los mismos valores de los bits que se inició con el, pero intercambian. Mismo los valores de los bits = mismos valores, con o sin signo de 8, 16 o 32 bits. Tal vez si cambiamos de un firmados y sin firmar, o diferentes tamaños de caracteres, no va a funcionar, pero que lo que en ese caso?
  13. 1

    Vez de romper a mitad de camino a través de, usted simplemente debe acortar su ciclo.

    size_t length = strlen(str);
    size_t i;
    
    for (i = 0; i < (length / 2); i++)
    {
        char temp = str[length - i - 1];
        str[length - i - 1] = str[i];
        str[i] = temp;
    }
  14. 1
    #include <stdio.h>
    #include <string.h>
    
    int main() 
    {
        char *data = "hello world";
        int length=strlen(data);
        char bytes[length];
        int n=0;
        while(n<=length)
        {
           bytes[n] = data[length-n-1];
           n++;
        }
        printf("%s\n", bytes);
        return 0;   
    }
  15. 1
    #include <stdio.h>
    
    int main()    
    {
    
        char string[100];
        int i;
    
        printf("Enter a string:\n");
        gets(string);
        printf("\n");
        for(i=strlen(string)-1;i>-1;i--)
    
        printf("%c",string[i]);
    }
  16. 1
    Here is my shot which will handle all the cases 
    char *p ="KDLAKDADKADAD"
    char p[] = "lammdlamldaldladadada"
    also empty string 
    
    #include<stdio.h>
    #include<string.h>enter code here
    #include<stdlib.h>
    char *string_reverse(char *p);
    int main()
    {
    
            char *p = " [email protected]";
            char *temp = string_reverse(p);
            printf("%s", temp);
    }
    char *  string_reverse( char *p )
    {
    
            if(*p == '\0')
            {
                    printf("No charecters are present \n");
                    return 0;
            }
            int count = strlen(p)+1;
            int mid = strlen(p)/2;
            char *q  = (char *)malloc(count * sizeof(char));
            if( q )
            {
                    strcpy(q,p);
                    char *begin,*end,temp;
                    begin = q ;
                    end = q+strlen(p)-1  ;
                    int i = 0;
                    while( i < mid/2 )
                    {
                            temp = *end;
                            *end = *begin;
                            *begin = temp;
                            begin++;
                            end--;
                            i++;
                    }
                    return q;
            }
            else
            {
    
                    printf("Memory Not allocated ");
            }
            free(q);
    }
  17. 1
    /* Author: Siken Dongol */
    #include <stdio.h>
    
    int strLength(char *input) {
        int i = 0;
        while(input[i++]!='\0');
        return --i;
    }
    
    int main()
    {
        char input[] = "Siken Man Singh Dongol";
    
        int len = strLength(input);
        char output[len];
    
        int index = 0;
        while(len >= 0) {
            output[index++] = input[--len];
        }
    
        printf("%s\n",input);
        printf("%s\n",output);
        return 0;
    }
  18. 1

    El código parece innecesariamente complicado. Aquí está mi versión:

    void strrev(char* str) { 
        size_t len = strlen(str);
        char buf[len]; 
    
        for (size_t i = 0; i < len; i++) { 
            buf[i] = str[len - 1 - i]; 
        }; 
    
        for (size_t i = 0; i < len; i++) { 
            str[i] = buf[i]; 
        }
    }
  19. 1

    fácil y simple código xD

    void strrev (char s[]) {
    
    int i;
    int dim = strlen (s);
    char l;
    
    for (i = 0; i < dim / 2; i++) {
        l = s[i];
        s[i] = s[dim-i-1];
        s[dim-i-1] = l;
        }
    
    }
    • muy sencillo de entender y de bajo costo
  20. 1

    Aquí está mi foto. I evitar el intercambio sólo por el uso de la norma strcpy patrón:

    char *string_reverse(char *dst, const char *src)
    {
        if (src == NULL) return NULL;
    
        const char *src_start = src;
        char *dst_end = dst + strlen(src);
        *dst_end = '\0';
    
        while ((*--dst_end = *src_start++)) { ; }
    
        return dst;
    }

    y aquí un ejemplo.

  21. 1

    Mis dos centavos:

    /* Reverses n characters of a string and adds a '\0' at the end */
    void strnrev (char *txt, size_t len) {
        size_t idx;
        for (idx = len >> 1; idx > 0; idx--) {
            txt[len] = txt[idx - 1];
            txt[idx - 1] = txt[len - idx];
            txt[len - idx] = txt[len];
        }
        txt[len] = '\0';
    }
    
    /* Reverses a null-terminated string */
    void strrev (char *txt) {
        size_t len = 0;
        while (txt[len++]);
        strnrev(txt, --len);
    }

    Prueba #1strrev():

    char string[] = "Hello world!";
    strrev(string);
    printf("%s\n", string); //Displays "!dlrow olleH"

    Prueba #2strnrev():

    char string[] = "Hello world!";
    strnrev(string, 5);
    printf("%s\n", string); //Displays "olleH"
  22. 1

    Que es una buena pregunta ant2009. Puede utilizar una función independiente para revertir la cadena. El código es…

    #include <stdio.h>
    #define MAX_CHARACTERS 99
    
    int main( void );
    int strlen( char __str );
    
    int main() {
        char *str[ MAX_CHARACTERS ];
        char *new_string[ MAX_CHARACTERS ];
        int i, j;
    
        printf( "enter string: " );
        gets( *str );
    
        for( i = 0; j = ( strlen( *str ) - 1 ); i < strlen( *str ), j > -1; i++, j-- ) {
            *str[ i ] = *new_string[ j ];
        }
        printf( "Reverse string is: %s", *new_string" );
        return ( 0 );
    }
    
    int strlen( char __str[] ) {
        int count;
        for( int i = 0; __str[ i ] != '\0'; i++ ) {
             ++count;
        }
        return ( count );
    }
    • Nunca, nunca, nunca de usuario gets. Es tan insegura y tan vulnerable a desbordamiento de búfer, que ha sido eliminado de la C11 de la biblioteca. Te recomiendo un cambio rápido de usar fgets y el recorte de la parte final del '\n'. También tenga en cuenta que los nombres de variable precedida por dos subrayados son generalmente reservados para su uso por el compilador…

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea