Conversion en morse

Version imprimable

Conversion en morse

Salut, je me suis remis à la programmation en C depuis peu et j'ai ressortis un ptit programme que j'avais codé à mes heures perdues, seulement, en le recompilant et en le testant il ne marche pas, il m'affiche les ?????? de mon else dans la boucle for.....

Pourriez-vous m'aider à le faire fonctionner et peut-être m'indiquer comment l'améliorer un petit peu.........

Voici le codeur morse :

Code:

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
50
51
52
53
 
#include <stdio.h>
#include <string.h>
#define NL 37                                
 
main()
{
 
   struct code { char lettre ;
                 char * morse ;
               } ;
   struct code table[NL] =                          
 
               { 'A', ".-",       'B', "-...",       'C', "-.-.",
                 'D', "-..",      'E', ".",          'F', "..-.",
                 'G', "--.",      'H', "....",       'I', "..",
                 'J', ".---",     'K', "-.-",        'L', ".-..",
                 'M', "--",       'N', "-.",         'O', "---",
                 'P', ".--.",     'Q', "--.-",       'R', ".-.",
                 'S', "...",      'T', "-",          'U', "..-",
                 'V', "...-",     'W', ".--",        'X', "-..-",
                 'Y', "-.--",     'Z', "--..",
                 '.', ".-.-.-",
                 '0', "-----",    '1', ".----",      '2', "..---",
                 '3', "...--",    '4', "....-",      '5', ".....",
                 '6', "-....",    '7', "--...",      '8', "---..",
                 '9', "----.",
               } ;
 
   char ligne[128] ;                              
   int i, j ;
 
   debut:          
 
   printf ("\n\n         LES CARACTERES SONT A ECRIRE EN MAJUSCULE    \n\n") ;
   printf ("                      128 caracteres maximum  \n") ;
   printf ("                   Introduisez une phrase : \n") ;
 
   gets (ligne) ;
 
   printf ("\n\n           Voici la traduction de votre message : \n\n") ;
 
   for (i=0 ; i<strlen(ligne) ; i++) 
 
      { j=0 ;
        while (ligne[i] != table[j].lettre && j++<NL-1) ;
        if (j<NL) printf ("%7s", table[j].morse) ;
            else  printf (" ??????") ;
        if ( ! ((i+1)%10) ) printf ("\n\n") ; 
 
      }
      goto debut ; 
}

Et voici le décodeur morse que je n'arrive pas à compiler avec code::blocks, ça marchais avec devc++ :

Code:

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
50
51
52
53
54
 
#include <stdio.h>
#include <string.h>
#define NL 37                                 
#define LG 127                                  
 
main()
{
   struct code { char lettre ;
                 char * morse ;
               } ;
   struct code table[NL] =                 
 
               { 'A', ".-",       'B', "-...",       'C', "-.-.",
                 'D', "-..",      'E', ".",          'F', "..-.",
                 'G', "--.",      'H', "....",       'I', "..",
                 'J', ".---",     'K', "-.-",        'L', ".-..",
                 'M', "--",       'N', "-.",         'O', "---",
                 'P', ".--.",     'Q', "--.-",       'R', ".-.",
                 'S', "...",      'T', "-",          'U', "..-",
                 'V', "...-",     'W', ".--",        'X', "-..-",
                 'Y', "-.--",     'Z', "--..",
                 '.', ".-.-.-",
                 '0', "-----",    '1', ".----",      '2', "..---",
                 '3', "...--",    '4', "....-",      '5', ".....",
                 '6', "-....",    '7', "--...",      '8', "---..",
                 '9', "----.",
               } ;
   char ligne[LG+1] ;                       
   char code[7] ;                   
   int i, j ;
 
   debut:                            
 
   printf ("\n\n        Introduiser un code morse a traduire : \n") ;
   gets (ligne) ;
   printf ("\n\n   Le code morse traduit alphabetiquement veut dire : \n") ;
 
 
   i=0 ;
   while (i<strlen(ligne))
      {
        while (ligne[i] == ' ') i++ ;    
        if ( i<strlen(ligne) )          
          { sscanf (&ligne[i], "%6s", code) ;
            i += strlen(code) ;            
            j=0 ;                            
            while ( stricmp (code, table[j].morse) && j++<NL-1) ;
            if (j<NL) printf ("%2c", table[j].lettre) ;   
                else  printf (" ?") ;           
          }
      }
      goto debut ;                
}

Bon évidemment, un bon codeur doit savoir coder sans son code.....mais, toutefois si un coup de pouce est possible...heu...bin, je dis pas non....

:calim2:

24/08/2010, 21h03
droggo

Jao,

En jetant un petit coup d'œil, je vois du goto, et je n'insiste pas.
24/08/2010, 21h46
jeroman
Salut

Le premier code semble fonctionner, mais il y a plusieurs choses à revoir :
* Il faut corriger les warning, c'est important.
* Il est préférable de supprimer le "goto", ce n'est pas propre.
* Utilise une variable au lieu d'appeler "strlen" à chaque fois (lorsque cela n'est pas nécessaire), cela consomme des ressources inutilement.
* "gets" est une fonction dangereuse, elle présente une grosse faille de sécurité (elle permet un dépassement de tampon avec les conséquences qui y sont liées), il faut la bannir. Il faut utiliser "fgets" à la place.
* La fonction "main" doit toujours renvoyer un int.
Code:

1 2 3 4 5 int main(void) { (...) return EXIT_SUCCESS; /* si tout est OK */ }
Concernant le second code, mêmes remarques que précédemment. De plus, la fonction "stricmp" semble ne pas exister. Remplace-la par la fonction "strcmp".
24/08/2010, 22h02
Ziarrow

merci

Merci beaucoup pour ces renseignement précieux....

Pour ce qui est du goto, je sais que j'aurais du changer ça avant, c'est une erreur ultra misérable de ma part mais à l'époque celà à du m'arranger pour une raison quelquonque.... je sais que ce n'est franchement pas très....algorithmique et que ça ne s'utilise plus depuis des lustres désolé.

Je viens de me remettre à la programmation car j'ai un peu de temps et je te remercie pour tes conseils, il vont m'être très utiles.....
24/08/2010, 22h09
kiluak

Citation:

Envoyé par Ziarrow

et que ça ne s'utilise plus depuis des lustres désolé.

Le noyau Linux en est truffé... mais le contexte d'utilisation n'est pas le même ;)

J'ai solutionné les warnings et changer mes erreurs pour le codeur morse, merci en tout cas, ça fonctionne :

Code:

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
50
51
52
53
54
55
56
57
58
59
 
#include <stdio.h>
#include <string.h>
#define NL 37
#define MAXLONG 128                 
 
int main(void)
{
 
   struct code { char lettre ;
                 const char * morse ;
               } ;
   struct code table[NL] =                         
               { {'A', ".-"},       {'B', "-..."},       {'C', "-.-."},
                 {'D', "-.."},      {'E', "."},          {'F', "..-."},
                 {'G', "--."},      {'H', "...."},       {'I', ".."},
                 {'J', ".---"},     {'K', "-.-"},        {'L', ".-.."},
                 {'M', "--"},       {'N', "-."},         {'O', "---"},
                 {'P', ".--."},     {'Q', "--.-"},       {'R', ".-."},
                 {'S', "..."},      {'T', "-"},          {'U', "..-"},
                 {'V', "...-"},     {'W', ".--"},        {'X', "-..-"},
                 {'Y', "-.--"},     {'Z', "--.."},
                 {'.', ".-.-.-"},
                 {'0', "-----"},    {'1', ".----"},      {'2', "..---"},
                 {'3', "...--"},    {'4', "....-"},      {'5', "....."},
                 {'6', "-...."},    {'7', "--..."},      {'8', "---.."},
                 {'9', "----."}
               } ;
 
 
   char ligne[MAXLONG] ;         
   unsigned int i, j ;
   size_t length;
  while (1)
  {
   printf ("\n\n         LES CARACTERES SONT A ECRIRE EN MAJUSCULE    \n\n") ;
   printf ("                    128 caracteres maximum  \n") ;
   printf ("        Introduisez une phrase ou un blanc pour quitter : \n") ;
 
   fgets (ligne, MAXLONG, stdin) ;
 
    if (ligne[0] == '\n')
    break;
 
   printf ("\n\n         Voici la traduction de votre message : \n\n") ;
 
 
   length = strlen(ligne);
 
   for (i=0 ; i<length ; i++)                        
 
      { j=0 ;
        while (ligne[i] != table[j].lettre && j++<NL-1) ;
        if (j<NL) printf ("%7s", table[j].morse) ;
        if ( ! ((i+1)%10) ) printf ("\n\n") ;         
      }
 }
return 0;
}

Donc merci et n'hésiter pas à critiquer ce bout de code s'il y a lieu. :ccool:

Je changerai le décodeur de la même manière........

;)

Sans vouloir abuser, je voudrais vous demander de m'aider pour le décodeur, j'ai solutionner les warnings, le programme se compile et fonctionne mais lorsque j'écris le code en morse, j'ai en sorti d'affichage deux fois la dernière lettre à convertir.

Exemple :

Introduiser un code morse a traduire : -. --. ---

Le code morse traduit alphabétiquement : n g o o au lieu de n g o

Voici le code revu du décodeur morse :

Code:

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
50
51
52
53
54
55
56
57
58
59
60
61
 
#include <stdio.h>
#include <string.h>
#define NL 37                           
#define LG 127                       
 
int main(void)
{
   struct code { char lettre ;
                 const char * morse ;
               } ;
   struct code table[NL] =                          
              {  {'.', ".-.-.-"},
                 {'0', "-----"},    {'1', ".----"},      {'2', "..---"},
                 {'3', "...--"},    {'4', "....-"},      {'5', "....."},
                 {'6', "-...."},    {'7', "--..."},      {'8', "---.."},
                 {'9', "----."},
                 {'a', ".-"},       {'b', "-..."},       {'c', "-.-."},
                 {'d', "-.."},      {'e', "."},          {'f', "..-."},
                 {'g', "--."},      {'h', "...."},       {'i', ".."},
                 {'j', ".---"},     {'k', "-.-"},        {'l', ".-.."},
                 {'m', "--"},       {'n', "-."},         {'o', "---"},
                 {'p', ".--."},     {'q', "--.-"},       {'r', ".-."},
                 {'s', "..."},      {'t', "-"},          {'u', "..-"},
                 {'v', "...-"},     {'w', ".--"},        {'x', "-..-"},
                 {'y', "-.--"},     {'z', "--.."}
               } ;
 
   char ligne[LG+1] ;                    
   char code[7] ;                     
   unsigned int i, j ;
   size_t length;
 
 while (1)
 {
   printf ("\n\n       Introduiser un code morse a traduire : \n") ;
   fgets (ligne, LG, stdin) ;
 
   if (ligne[0] == '\n')
   break;
 
   printf ("\n\n  Le code morse traduit alphab\202tiquement : \n\n") ;
 
   length = strlen(ligne);                            
   i=0 ;
 
   while (i<length)
      {
        while (ligne[i] == ' ') i++ ;         
        if ( i<length )                                
          { sscanf (&ligne[i], "%6s", code) ;  
            i += strlen(code) ;      
            j=0 ;                        
            while ( strcmp (code, table[j].morse) && j++<NL-1) ;
            if (j<NL) printf ("%2c", table[j].lettre) ;      
                else  printf (" ?") ;                 
          }
      }
   }
  return 0;
}

N'hésiter pas à critiquer mes inepties......

:roll:

25/08/2010, 08h53
fregolo52

Citation:

Envoyé par kiluak

Le noyau Linux en est truffé... mais le contexte d'utilisation n'est pas le même ;)

Oui mais là, il a fait un goto qui "remonte", c'est très dangereux !!! Je ne pense pas qu'il y en ait dans le noyau (j'espère).
Un goto sert généralement à sortir (de boucles imbriquées), pas à boucler !!
25/08/2010, 12h00
diogene

Citation:

Le code morse traduit alphabétiquement : n g o o au lieu de n g o

fgets(), à la différence de gets(), met le '\n' dans la chaine et du coup tu fais un tour de plus.
25/08/2010, 12h40
Ziarrow
Merci Ô vénérable, mon problème est arrangé avec un petit if :
Code:

1 2 if (ligne[i] == '\n') i++;
Merci infiniment !!! :ccool:

Citation:

Envoyé par Ziarrow

Donc merci et n'hésiter pas à critiquer ce bout de code s'il y a lieu. :ccool:

C'est pas une critique mais une solution d'optimisation
Tu peux éviter la macro NL de cette façon

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 struct code table[] =                          
              {  {'.', ".-.-.-"},
                 {'0', "-----"},    {'1', ".----"},      {'2', "..---"},
                 {'3', "...--"},    {'4', "....-"},      {'5', "....."},
                 {'6', "-...."},    {'7', "--..."},      {'8', "---.."},
                 {'9', "----."},
                 {'a', ".-"},       {'b', "-..."},       {'c', "-.-."},
                 {'d', "-.."},      {'e', "."},          {'f', "..-."},
                 {'g', "--."},      {'h', "...."},       {'i', ".."},
                 {'j', ".---"},     {'k', "-.-"},        {'l', ".-.."},
                 {'m', "--"},       {'n', "-."},         {'o', "---"},
                 {'p', ".--."},     {'q', "--.-"},       {'r', ".-."},
                 {'s', "..."},      {'t', "-"},          {'u', "..-"},
                 {'v', "...-"},     {'w', ".--"},        {'x', "-..-"},
                 {'y', "-.--"},     {'z', "--.."},
                 {'\0', NULL}
               } ;

Et ta boucle de recherche peut se faire de cette façon

Code:

1
2
3
4
5
6
7
8
struct code *pt;
for (pt=table; pt->morse != NULL; pt++)
{
    if (strcmp(pt->morse, code) == 0)
    {
         ...
    }
}

Accessoirement, nommer une structure "code" et une variable "code" c'est pas tiptop lisible. Tu devrais peut-être prendre l'habitude de nommer tes structures "s_qqchose" et tes types "t_qqchose".

Accessoirement (bis), il me semble que tu analyses ton code sur les espaces qui séparent chaque lettre. Or pour découper une chaine sur un caractère séparateur, tu as à ta disposition strtok_r() qui se charge de tout...

Citation:

Envoyé par Ziarrow

Merci Ô vénérable, mon problème est arrangé avec un petit if :

Code:

1
2
 
if (ligne[i] == '\n') i++;

Tu fais ce test à chaque tour de boucle alors que si tu enlevais le '\n' juste après le fgets, t'aurais plus de soucis

Code:

1
2
3
4
fgets (ligne, LG, stdin) ;
 
if ((carac=strchr(ligne, '\n')) != NULL)
    *carac='\0';

Accessoirement, puisque tu as déjà "length" qui existe, tu peux t'en servir aussi pour ça

Code:

1
2
3
4
fgets (ligne, LG, stdin) ;
length=strlen(ligne);
if (ligne[length - 1] ==  '\n')
   ligne[--length]='\0;

25/08/2010, 13h11
Ziarrow

Wow, je pouvais pas espérer mieux pour améliorer mon p'tit prog......

J'me met direct au travail, grand merci !!!

:)

Est-ce qu'au lieu de :
Code:

1 2 3 4 5 fgets (ligne, LG, stdin) ; if ((carac=strchr(ligne, '\n')) != NULL) *carac='\0';
Puis-je écrire :
Code:

1 2 3 4 fgets (ligne, LG, stdin) ; *(strchr(ligne, '\n')) = '\0';
Ce serait pour tenter d'éviter un pointeur de plus.....

:roll:

25/08/2010, 13h45
diogene
Citation:
Envoyé par Ziarrow

Est-ce qu'au lieu de :
....
Puis-je écrire :

Code:

1 2 3 4 fgets (ligne, LG, stdin) ; *(strchr(ligne, '\n')) = '\0';

Ce serait pour tenter d'éviter un pointeur de plus.....

:roll:
Pour pouvoir écrire ceci, il faut être sûr qu'un '\n' soit dans ligne, sinon, ça plante. Or fgets() ne le garantit pas : si la ligne entrée comporte LG caractères ou plus (y compris le '\n') , elle est tronquée et il n'y a donc pas de '\n'.
La première forme est donc préférable, puisque tu utilises fgets() justement pour ne pas planter en cas de ligne trop longue.

Note : inutile de mettre des parenthèses superflues qui encombrent la lecture :

Code:

*strchr(ligne, '\n') = '\0';
25/08/2010, 17h01
Ziarrow
Citation:

Envoyé par diogene

Pour pouvoir écrire ceci, il faut être sûr qu'un '\n' soit dans ligne, sinon, ça plante. Or fgets() ne le garantit pas : si la ligne entrée comporte LG caractères ou plus (y compris le '\n') , elle est tronquée et il n'y a donc pas de '\n'.
La première forme est donc préférable, puisque tu utilises fgets() justement pour ne pas planter en cas de ligne trop longue.

Ok, je prends note, je ferais plus l'erreur. :roll:
Citation:
Envoyé par Sve@r

Et ta boucle de recherche peut se faire de cette façon

Code:

1 2 3 4 5 6 7 8 struct code *pt; for (pt=table; pt->morse != NULL; pt++) { if (strcmp(pt->morse, code) == 0) { ... } }
Malheureusement, ce qui est simple pour toi, l'est beaucoup moins pour moi...
Je reprends à peine la programmation (5 ans d'abstinence) et je m'y perds un peu dans mes variables étant donné que j'ai compliqué les choses en surchargeant, donc je redécouvre mes début et ...... aussi mon point actuel. :oops:

Mais je vais en découdre de nouveau avec la matrice... aurait-tu un lien d'une page expliquant la manoeuvre que tu me propose d'envisager pour optimiser mon code.... parce que vous m'avez déjà bien aider, je risque de vous prendre la tête avec mes questions.
25/08/2010, 17h15
jeroman

La méthode de Sve@r permet simplement de parcourir tout le tableau sans s'occuper de sa taille. Le dernier membre ("morse", pointeur sur char) du tableau est à NULL, ce qui indique la fin du tableau. D'où la boucle :

Code:

for (pt=table; pt->morse != NULL; pt++)
25/08/2010, 17h37
Ziarrow

D'accord merci, je comprenais pas mais je ne vois pas comment stocker l'équivalence de la touche tapé, je ne suis pas encore à l'aise avec cette méthode pourtant magique.......
25/08/2010, 17h38
matafan

Une autre méthode qui ne demande pas d'ajouter un marqueur de fin est de laisser le compilateur calculer la taille du tableau avec :

Code:

sizeof(table)/sizeof(table[0])
25/08/2010, 17h58
jeroman

Citation:

D'accord merci, je comprenais pas mais je ne vois pas comment stocker l'équivalence de la touche tapé, je ne suis pas encore à l'aise avec cette méthode pourtant magique.......

Ce bout de code concernait le décodeur morse.
"pt" prend au départ comme valeur l'adresse du début du tableau. Si "pt->morse" ne correspond pas au code morse voulu, "pt" est alors incrémenté pour aller à l'élément du tableau suivant, puis teste le code suivant, etc. Si cela correspond, la lettre associée est donc "pt->lettre".

Exemple. Si on tape "...--" :
1) "pt" commence au début du tableau.
2) "pt->morse" est testé avec le code morse tapé, ici "...--". Si cela ne correspond pas, on incrémente "pt", puis on recommence le point 2). (à moins que NULL soit trouvé, ce qui indique la fin du tableau et il faut donc sortir de la boucle)
3) Une fois le code morse trouvé, "pt->lettre" correspond alors au caractère associé. Dans notre exemple, cela correspond à "3".
25/08/2010, 18h21
Ziarrow

Merci, vous êtes de véritables profs !!!!

:ccool:
25/08/2010, 19h29
Ziarrow

Une dernière question avant de considérer que mon sujet est résolu car vous m'avez sacrément aidé...... je n'en désire pas plus...

En ce qui concerne "strtok_r", j'ai essayer de faire comme on m'a conseillé mais même avec "string.h", la fonction n'est pas reconnue...

J'ai trouvé "strtok_r.c" et "strtok_r.h" grâce à un post sur ce forum mais je ne sais pas comment l'installer dans code::blocks, où les mettre, quoi réglé....

quelqu'un saurait ??

:?
25/08/2010, 21h39
Obsidian

Tu compiles avec quelle machine et quel compilateur ? Selon la man page, strtok_r() (comme beaucoup d'autres) correspond à POSIX.1-2001. Normal, c'est une révision d'une fonction utile parce qu'on s'est rendu compte un peu plus tard qu'elle n'était pas ré-entrante en l'état.

Citation:

SYNOPSIS
#include <string.h>

char *strtok(char *str, const char *delim);

char *strtok_r(char *str, const char *delim, char **saveptr);

Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

strtok_r(): _SVID_SOURCE || _BSD_SOURCE || _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE

CONFORMING TO
strtok()
SVr4, POSIX.1-2001, 4.3BSD, C89, C99.

strtok_r()
POSIX.1-2001.

Donc, si ton compilo est un tout petit peu tatillon, ou bien est réglé sur un standard particulier (C89 ?), la fonction ne sera pas automatiquement définie.
25/08/2010, 21h55
Ziarrow

Je compile sur windows Xp avec Code::blocks svn build rev 6508.

Est-ce que j'ai une possibilité de m'en servir ?
25/08/2010, 23h02
Sve@r
Citation:

Envoyé par matafan

Une autre méthode qui ne demande pas d'ajouter un marqueur de fin est de laisser le compilateur calculer la taille du tableau avec :

Code:

sizeof(table)/sizeof(table[0])

Ouch ça c'est dangereux.
Ca marche si table est toujours un tableau. Mais si on déporte ça dans une fonction et que table est passé en paramètre (et donc reçu dans la fonction dans un pointeur) gros crash...

Citation:

Envoyé par Ziarrow

aurait-tu un lien d'une page expliquant la manoeuvre que tu me propose d'envisager pour optimiser mon code....

Jéroman a bien expliqué le truc. J'ajouterai simplement qu'il s'agit d'une application concrète de l'arithmétique des pointeurs
Si pt pointe vers un élément [X] d'un tableau, alors "pt + 1" pointera vers l'élément [X + 1] du tableau et ce, quelle que soit la taille dudit élément. Mais la vraie astuce de mon code n'était pas là. Elle était surtout sur l'élément NULL que j'avais inséré dans le tableau qui permet de savoir où s'arrêter sans avoir à connaitre la longueur à l'avance
Et donc ceci aurait fait aussi l'affaire
Code:

1 2 3 4 5 6 7 for (i=0; table[i].morse != NULL; i++) { if (strcmp(table[i].morse, code) == 0) { ... } }
Mais l'opération [i] étant une opération lourde, mon premier exemple à base de pointeur pointant directement vers l'élément courant est alors plus rapide...

Citation:

Envoyé par Ziarrow

Je compile sur windows Xp avec Code::blocks svn build rev 6508.

Est-ce que j'ai une possibilité de m'en servir ?

Obsidian a dit que cette fonction était assez récente. En théorie tu as toujours possibilité d'essayer son ancètre strtok()....
Une explication plus complète ici http://www.bash-linux.com/unix-man-s...-francais.html
25/08/2010, 23h16
gl

Citation:

Envoyé par Sve@r

Ouch ça c'est dangereux.
Ca marche si table est toujours un tableau. Mais si on déporte ça dans une fonction et que table est passé en paramètre (et donc reçu dans la fonction dans un pointeur) gros crash...

C'est une construction assez classique. Et lorsqu'on passe le tableau en paramètre de fonction, on passe également la taille tout simplement.

Mais effectivement, dans le cas présent, l'utilisation d'une sentinelle me semble plus approprié.

Citation:
Envoyé par Sve@r
Et donc ceci aurait fait aussi l'affaire
Code:

1 2 3 4 5 6 7 for (i=0; table[i].morse != NULL; i++) { if (strcmp(table[i].morse, code) == 0) { ... } }
Oui, j'ai eu un peu de mal à comprendre, ça revient au même c'est vrai mais à vrai dire ce qui m’embarrasse c'est que de toute façon, tout le tableau est lu et je ne peux pas savoir si le caractère n'a pas été trouvé avec un else par exemple pour afficher un "point d'interrogation" à la place d'un espace dans le cass d'un caractère introuvable, je me suis résolu à un petit bricolage avec une variable "inep" ....

De plus, avec cette méthode que je me suis empressé d'appliquer, lorsque je tape un "espace" après un code morse, il traduit deux fois le dernier caractère une fois de plus....

Et Je ne me sers pas encore de "strtok_r"....."strsep()" ne serait t-il pas intéressant ?

Voici une portion du code :
Code:

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 while (1) { printf ("\n\n Introduiser un code morse a traduire ou un blanc pour quitter : \n\n") ; fgets (ligne, LG, stdin) ; if (ligne[0] == '\n') return 0; else if ((carac=strchr(ligne, '\n')) != NULL) *carac='\0'; printf ("\n\n Le code morse traduit alphab\202tiquement : \n\n") ; length = strlen(ligne); i=0 ; while (i<length) { inep = 0; while (ligne[i] == ' ') i++; { sscanf (&ligne[i], "%6s", d_code); i += strlen(d_code); for (pt=table; pt->morse != NULL; pt++) { if (strcmp(pt->morse, d_code) == 0) { printf ("%2c", pt->lettre); inep = 1; } } if (inep == 0) printf(" ?"); } } } return 0; }

Citation:

Oui, j'ai eu un peu de mal à comprendre, ça revient au même c'est vrai mais à vrai dire ce qui m’embarrasse c'est que de toute façon, tout le tableau est lu et je ne peux pas savoir si le caractère n'a pas été trouvé avec un else par exemple pour afficher un "point d'interrogation" à la place d'un espace dans le cass d'un caractère introuvable, je me suis résolu à un petit bricolage avec une variable "inep" ....

Il y a sinon moyen de mettre un "break" lorsque l'occurence est trouvée, ce qui provoque la sortie de la boucle.

Ceci permet, une fois sorti de la boucle, d'effectuer un test de "pt->morse" (ou de "table[i].morse" si on utilise l'autre méthode) avec NULL pour savoir si tout le tableau a été parcouru (si c'est le cas, c'est que la chaine n'a pas été trouvée).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for (i=0; table[i].morse != NULL; i++) { if (strcmp(table[i].morse, code) == 0) { ... break; } } if ( table[i].morse == NULL ) /* la chaîne n'a pas été trouvée ? */ { ... }
ou
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 struct code *pt; for (pt=table; pt->morse != NULL; pt++) { if (strcmp(pt->morse, code) == 0) { ... break; } } if ( pt->morse == NULL) /* la chaîne n'a pas été trouvée ? */ { ... }

26/08/2010, 12h15
Obsidian

Citation:

Envoyé par Ziarrow

Je compile sur windows Xp avec Code::blocks svn build rev 6508.

Est-ce que j'ai une possibilité de m'en servir ?

Certainement, oui. Ce doit être une option à passer à ton compilo. Seulement, comme je n'utilise ni Windows ni Code::Blocks, je ne sais pas laquelle.

Ok, j'ai utilisé strtok, mon code est allégé.... voici à quoi ça ressemble :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
    printf ("\n\n Le code morse traduit alphab\202tiquement : \n\n") ;
 
    inep = 0;
    d_code = strtok (ligne," ");
    while (d_code != NULL)
    {
        for (pt=table; pt->morse != NULL; pt++)
            {
                if (strcmp(pt->morse, d_code) == 0)
                {
                    printf ("%2c", pt->lettre);
                    inep = 1;
                }
            }
        if (inep == 0)
        printf(" ?");
        d_code = strtok (NULL, " ");
    }
  }
  return 0;
}

Merci à tous pour votre aide.....

:ccool: