Comment réparer le code qui extrait les valeurs d'index numérotées paires dans un tableau d'une phrase et les combine avec des valeurs d'index numérotées impaires?

Les chaînes en C ne connaissent pas leur longueur, ce ne sont que des pointeurs. Les chaînes doivent être terminées par un caractère nul pour que des fonctions telles que printf et strlen sachent quand s'arrêter.

void copy_every_other_character(const char *src, char *dst) {
    int i,j,length = 0;
    length = strlen(src);
    for( i=0,j=0; i<length; i+=2,j++ ) {
        dst[j] = src[i];
    }
    dst[j] = '\0';
}

copy_every_other_character(message, even);
copy_every_other_character(message+1, odd);

À ce stade pair et impair contiennent tous les deux les déchets qui se trouvaient en mémoire à ce moment-là.

for( i=0,j=0; i<length; i+=2,j++ ) {
    even[j]=message[i];
}
even[j] = '\0';

for( i=1,j=0; i<length; i+=2,j++ ) {
    odd[j]=message[i];
}
odd[j] = '\0';

Maintenant, le début de impair et pair ont été renseignés, mais ils ne sont pas terminés par une valeur nulle.

for(i=0;i<length;i+=2){
    even[i/2]=message[i];
}
even[i/2] = '\0';

for(i=1;i<length;i+=2){
    odd[j]=message[i];
    j++;
}
odd[j] = '\0';

Ceux-ci commenceront à l'endroit où pair et impair , imprimez les caractères que vous avez mis là-dedans, puis continuez à imprimer les déchets qui se trouvaient en mémoire jusqu'à ce qu'ils atteignent un caractère nul.

Le correctif consiste soit à remettre à zéro la mémoire avec memset.

memset(even, '\0', SIZE);
memset(odd, '\0', SIZE);

soit à s'assurer que même et impairs sont annulés une fois que vous en avez terminé avec eux.

printf("The even letters are: %s\n",even);
printf("The odd letters are: %s\n",odd);

Remarque, pair et impaires peuvent être faites avec la même technique.

for(int i=0;i<length;i+=2){
    even[i/2]=message[i];
}

for(int i=1;i<length;i+=2){
    odd[j]=message[i];
    j++;
}

Ensuite, nous pouvons observer que la seule différence est l'endroit où nous commençons à lire message . Cela signifie que nous pouvons mettre cela dans une fonction et toujours nous souvenir de null pour terminer le résultat.

char even[SIZE];
char odd[SIZE];

Ajouter 1 à message signifie copy_every_other_character obtiendra un pointeur vers le deuxième caractère du message et continuera à partir de là. Si message est 01234 , il verra 1234.

Vous pouvez adopter une approche légèrement plus courte en utilisant simplement deux index pour créer votre chaîne chiffrée (comme evenstart et oddstart ) en fonction de la longueur totale du message saisi par l'utilisateur. evenstart = 0; et oddstart = (msglen + 1) / 2;

Ensuite, bouclez simplement sur les caractères du message saisi par l'utilisateur en écrivant des caractères pairs à encrypt [evenstart ++] et les caractères impairs à encrypt [oddstart ++] . (n'oubliez pas de nul-terminate encrypt si vous comptez l'utiliser comme chaîne à des fins de sortie.

En l'assemblant, vous pouvez le faire :

$ ./bin/encrevenodd
enter message: tes
message : 'tes'
encrypt : 'tse'

$ ./bin/encrevenodd
enter message: test
message : 'test'
encrypt : 'tset'

$ ./bin/encrevenodd
enter message: tests
message : 'tests'
encrypt : 'tsset'

$ ./bin/encrevenodd
enter message: my dog has fleas
message : 'my dog has fleas'
encrypt : 'm o a laydghsfes'

( remarque: vous pouvez utiliser i% 2 pour vérifier pair / impair si vous le souhaitez, ou simplement i & 1 - en binaire, si le bit à un est 1 c'est impair, sinon c'est pair - à vous de décider)

Exemple d'utilisation / de sortie

#include <stdio.h>
#include <string.h>

#define MAXC 1024

int main (void) {

    char message[MAXC],
        encrypt[MAXC];
    size_t len, evenstart = 0, oddstart;

    fputs ("enter message: ", stdout);
    if (!fgets (message, MAXC, stdin)) {    /* validate message entered */
        fputs ("(user canceled input)\n", stdout);
        return 1;
    }

    message[(len = strcspn(message, "\r\n"))] = 0;  /* trim '\n', get len */
    oddstart = (len + 1) / 2;       /* get oddstart (add 1 before divide) */

    for (size_t i = 0; i < len; i++)        /* loop over each char */
        if (i & 1)      /* if odd, write char at oddstart */
            encrypt[oddstart++] = message[i];
        else            /* if even, write at evenstart */
            encrypt[evenstart++] = message[i];
    encrypt[len] = 0;   /* nul-terminate */

    printf ("message : '%s'\nencrypt : '%s'\n", message, encrypt);
}

Regardez les choses et faites-moi savoir si vous avez des questions.

Les chaînes en C se terminent par l'octet nul ('\ 0' ou valeur ascii 0) juste pour qu'il sache où la chaîne se termine. Les tableaux de caractères pairs et impairs n'étant pas terminés par l'octet nul, strcat ne sait pas quand arrêter l'ajout de caractères. Les valeurs inutiles que vous voyez sont donc dues au fait que strcat continue d'ajouter des caractères jusqu'à ce que vous trouviez heureusement un 0 en mémoire.