Discussion :

[KaNDeL]

Bonjour, je cherche a mettre en place un algorithme de chiffrement utilisant césar mais à la compilation j'ai un probleme que je n'arrive pas a dterminer....merci d'avance pour votre aide !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/////////////////////////////////////////
///// chiffrement utilisant cesar //////
///////////////////////////////////////
char* cesar_crypt(int decallage, char * texte)
{
int i;
int c;
char* crypt;
int cp = decallage;
size_t sz = strlen(texte) + 1;
crypt = malloc(sz);
 
for(i=0; i < sz ; i++)
{     	
	c = texte[i];
	c = (char(int((c-'a') + (cp-'a'))%26) + 'a');
	crypt[i] = c;
}
return crypt;
free(crypt);
}

[SofEvans]

quelque petite remarque :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
int main()
{
    ...
    return crypt;
    free(crypt);
}

free(crypt); ne sera jamais atteint.

Il y a beaucoup de chose bizarre dans ce code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int cp = decallage;

Inutile de declarer une autre variable pour la valeur de decallage; Tu peux directement utilisé la variable "decallage".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        c = texte[i];
        c = (char(int((c-'a') + (decallage-'a'))%26) + 'a');

Cela est bizarre, tu fais deux affectation coup sur coup:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
        c = (char(int((texte[i]-'a') + (decallage-'a'))%26) + 'a');

Cela fait la meme chose.


Bref, il y a beaucoup de chose pour lequel je ne vois pas ce que tu veux faire.
Le code me semble hasardeux.
Voici ce que je te propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void cesar_crypt (int decallage, char *texte)
{
    /* Explication de la conversion pour un caractere minuscule 
    
        texte[i] - 'a'                           -> on recupere un nombre represantante le caractere contenue 
                                                    dans texte[i] (0=a, 1=b, ...)
        (texte[i] - 'a') + decallage             -> on lui applique le decallage
        ((texte[i] - 'a') + decallage)%26        -> on fait %26 pour revenir au debut si on a depasser 'z'
        'a' + ((texte[i] - 'a') + decallage)%26  -> on retrouve le bon caractere en ajoutant 'a'
    */
 
 
 
    int i;
    for(i=0 ; i<strlen(texte) ; i++)
        /* Si le caractere est une minuscule */
        if ('a' <= texte[i] && texte[i] <= 'z')
            texte[i] = 'a' + ((texte[i] - 'a') + decallage)%26;
        else
            /* Si le caractere est une majuscule */
            if ('A' <= texte[i] && texte[i] <= 'Z')
                texte[i] = 'A' + ((texte[i] - 'A') + decallage)%26;
            else
                /* Si le caractere est un chiffre */
                if ('0' <= texte[i] && texte[i] <= '9')
                    texte[i] = '0' + ((texte[i] - '0') + decallage)%10;
                else
                {
                    /* Caractere qui n'est ni une lettre, ni un chiffre.
                        A toi de voir les actions a faire ici  */
                }
}
 
 
int main()
{
    char Test[] = "aBcDeF";
 
    cesar_crypt(2, Test);
 
    printf("%s\n\n", Test);
 
    return EXIT_SUCCESS;
}

[diogene]

Bonjour, je cherche a mettre en place un algorithme de chiffrement utilisant césar mais à la compilation j'ai un probleme que je n'arrive pas a dterminer....

Le problème est sur cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c = (char(int((c-'a') + (cp-'a'))%26) + 'a');

Je suppose que ces char et int ont pour objectif de faire un transtypage. En C le transtypage se fait par (nouveau_type) valeur pas par nouveau_type(valeur).

D'ailleurs, le transtypage en int est inutile : c, cp, 'a' et 26 sont des int. Cette expression est déjà un int.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c = (char) ((c-'a' + cp-'a')%26 + 'a');

A noter que
- Le test sur la validité du malloc est absent
- La chaîne crypt n'a pas de zéro terminal

[SofEvans]

D'ailleurs, le transtypage en int est inutile : c, cp, 'a' et 26 sont des int. Cette expression est déjà un int.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c = (char) ((c-'a' + cp-'a')%26 + 'a');

Ce qui est bizarre, c'est que c est un int, alors pourquoi faire un transtipage en char ?

[Sve@r]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
char* cesar_crypt(int decallage, char * texte)
{
  ...
  return crypt;
  free(crypt);
}

Déjà le free ne se fera jamais. Mais même si les lignes étaient inversées, alors ce serait pire que tout. Tu renverrais une zone libérée (donc contenu perdu) alors que justement le contenu (la chaine cryptée) est utilisé par l'appelant. Crash assuré

D'une façon générale, quand on veut créer une chaine, alors
1) soit on passe à la fonction la zone destinée à recevoir la chaine
2) soit on alloue et on remplit la chaine dans la fonction puis on renvoie le pointeur alloué. Charge alors à l'appelant de libérer ledit pointeur quand il n'en a plus besoin. C'est par exemple le cas de strdup().

[diogene]

SofEvans :

Ce qui est bizarre, c'est que c est un int, alors pourquoi faire un transtipage en char ?

Ici, ça ne sert à rien. Mais dans le cas général, la conversion int->char->int peut n'être pas neutre.
Par exemple, pour un char de 8 bits, le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 int i= 256;
 int j = (char) i;

donnera pour j une valeur différente de celle de i

[SofEvans]

J'y crois pas

Effectivement, un char va de -128 à 127.

Si on fait on trantype par un char, un modulo implicite est fait, c'est fourbe !

Comme quoi, caster pour faire disparaitre un warning est dangereux, surtout si les deux type n'ont pas le meme nombre d'octet.

[gl]

Effectivement, un char va de -128 à 127.

Juste une petite précision, la plage garantie pour un signed char est -127 (et non -128) à 127.
Cependant :

• la plage réelle sur une implémentation peut être plus étendue (c'est effectivement souvent -128 à 127, mais ça peut être plus important).
• contrairement aux autres types entiers, char peut être signé ou non en fonction des environnements.

Dans tous les cas, il faut voir dans limits.h les valeurs exactes correspondantes à l'environnement utilisé.

[diogene]

SofEvans :

Si on fait on trantype par un char, un modulo implicite est fait, c'est fourbe !

C'est pire que ça : le résultat peut dépendre de l'implémentation si char est signé. Heureusement, si char équivaut à unsigned char, le résultat est indépendant de l'implémentation (opération du type modulo).

[Médinoc]

mais le fait que le char soit signé ou non dépend justement de l'implémentation, non?

Il me semble qu'en fait, pour un char tout court, la seule plage garantie est 0-127. Après, il faut utiliser explicitement un signed char ou unsigned char...

D'ailleurs, en C++, du moins sous Visual, c'est considéré comme trois types différents.

[diogene]

mais le fait que le char soit signé ou non dépend justement de l'implémentation, non?

Oui et je me suis mal exprimé.
Je voulais dire que sur les implémentations où char était unsigned le résultat obtenu était le même sur toutes ces implémentations alors que sur les implémentations où char était signed ce n'était pas forcément le cas.

Il me semble qu'en fait, pour un char tout court, la seule plage garantie est 0-127. Après, il faut utiliser explicitement un signed char ou unsigned char...

D'ailleurs, en C++, du moins sous Visual, c'est considéré comme trois types différents

Oui, ce sont trois types différents, mais la norme dit :

The implementation shall define char to have the same range, representation, and behavior as either signed char or unsigned char

Je crois d'ailleurs que souvent une option du compilateur permet de choisir.