2016-02-23 1 views
1

J'essaie de créer un programme en C qui crypte les messages en «tournant» chaque lettre par position, passant de Z à A selon les besoins, mais je reçois des résultats erronés.Je me trompe de code

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

int main(int argc, char* argv[]) 
{ 
//Checks if the number of arguments are 2 
    if (argc != 2) 
    return 1; 
    int k; 
    int n = strlen(argv[1]); 
//Checks if the second arg(cipher) is a non negative number 
    for (int i = 0; i < n ; i++) 
    { 
     if (!(isdigit(argv[1][i]))) 
     { 
      return 1; 
     } 
     k = atoi(argv[1]); 
     if (k > 26) 
     k = k%26; 
     if (k < 0) 
     return 1; 
    } 

unsigned int len_max = 128; 
unsigned int current_size = 0; 

char *pStr = malloc(len_max); 
current_size = len_max; 

if(pStr != NULL) 
{ 
int c = EOF; 
unsigned int i =0; 
    //accept user input until hit enter or end of file 
while ((c = getchar()) != '\n' && c != EOF) 
{ 

    if (isalpha(c)) 
    { 
     if(isupper(c)) 
     { 
      if ((int)c + k > 90) 
      c = (char)((int)c + k - 26); 
      c = (char)((int)c + k); 
     } 
     else 
     { 
      if ((int)c + k > 122) 
      c = (char)((int)c + k - 26); 
      c = (char)((int)c + k); 
     } 
    } 
    pStr[i++]=(char)c; 

    //if i reached maximize size then realloc size 
    if(i == current_size) 
    { 
     current_size = i+len_max; 
     pStr = realloc(pStr, current_size); 
    } 
} 

pStr[i] = '\0'; 

printf("%s\n",pStr); 
    //free it 
free(pStr); 
pStr = NULL; 
return 0; 
} 
} 

:) caesar.c existe :) caesar.c compile :) encrypte "a" comme "b" en utilisant 1 clé

:(encrypte "barfoo" comme "yxocll" en utilisant 23 comme touche \ sortie attendue, mais pas "yxz \ n"

:) chiffre "BARFOO" comme "EDUIRR" en utilisant comme clé 3 :) chiffre "BaRFoo" comme "FeVJss" en utilisant comme clé 4

:(encrypte "barfoo" comme "onesbb" en utilisant 65 comme la clé \ sortie attendue, mais pas "onrsoo \ n"

:(chiffrent "monde, dire bonjour!" Comme « iadxp, EMK tqxxa ! » en utilisant 12 comme la clé \ sortie attendue, mais pas "umpxp, tqxxm qmw! \ n"

:(poignées manque de argv [1] \ sortie attendue, pas un code de sortie de 1

+2

N'utilisez pas _magic numbers_! Formatez votre code correctement. Et ** seulement ** jeté 1) il est vraiment nécessaire 2) vous comprenez ** toutes ** implications et 3) ** entièrement ** les accepter. – Olaf

+1

Oui, pourquoi lancer 'c' à' int' quand il est (correctement) déjà 'int'? Et pourquoi le jeter à "char" quand ce n'est pas? –

+0

Vous avez absolument raison, j'ai trop avec typecast.Thank pour votre temps. – Spyreto

Répondre

1

Pour une char unique décaler convertir ces derniers 'A' .. 'Z' et 'a' .. 'z' aux nombres de 0 à 25. Ajouter k et calculer le reste de la division par 26:

int c; 
while ((c = getchar()) != '\n' && c != EOF) 
{ 
    if (!isalpha(c)) 
     continue; 

    char firstC = isupper(c) ? 'A' : 'a'; 
    int num = (c - firstC + k) % 26; 
    pStr[i++] = (char)(num + firstC); 

    if (i == current_size-1) // -1 because of '\0' 
    { 
     current_size += len_max; 
     pStr = realloc(pStr, current_size); 
    } 
} 
pStr[i] = '\0'; 
+0

Merci beaucoup c'est de travailler avec des mots simples mais pas avec des espaces. Je vais essayer de le réparer moi-même afin de comprendre votre code. Merci beaucoup pour votre temps – Spyreto

+0

Mais si nous atteignons la taille maximale moins un (127) et le char suivant est un char non alphabétique (128), avec l'instruction continue, nous avons passé le realloc. – Spyreto

1
if ((int)c + k > 90) 
    c = (char)((int)c + k - 26); 
c = (char)((int)c + k); 

J'ai corrigé l'indentation ici. Pensez à ce que cette section de code fera, et ce qui pourrait manquer.

+0

Même si ce n'est pas lié à votre problème réel (où vous avez un bon indice maintenant), vous pouvez également jeter un oeil à la distribution à "int" pour "c" et pourquoi il pourrait être nécessaire. – tofro

+0

Cette section de code fait si le numéro ASCII de la lettre plus la clé dépasse le nombre de z (ou Z) à partir du début (rotation). – Spyreto