IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Vérification automatique de l'orthographe


Sujet :

C

  1. #21
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    Bonjour

    je viens de finir de taper le programme et de le teste
    certes il fonctionne
    mais 313 lignes....
    et tout ça à analyser pour comprendre

    je le met pour avoir votre avis, si pour un niveau débutant il convient ou si c'est un extremement lourd et qu'il y a moyen de l'optimiser sans passer non plus par des truc trop calé pour un noob

    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
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
     
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <malloc.h>
    #include <ctype.h>
     
    #define TAILLE_MOT 100
    #define TAILLE_FICHIER 20
     
     
    char c=0, c1, c2, cd=0, cf=0, cpt_tp=0,nb_mot, nb_let, nb_let_max, nb_mot_svg, nb_mot_dico, zz;
    char *tampon, *tampon_tp;
     
    int cpt, n, etat;
    int *mot_fich[TAILLE_MOT];
    int *mot_a_sauvegarder [TAILLE_MOT];
    int *mot_dico [TAILLE_MOT];
     
    int dichotomie(FILE *dico);
    void mem_mot_fich(FILE *fp);
    void tri_dico(FILE *dico);
     
    void main (void)
    {
        char fichier[TAILLE_FICHIER], dico[TAILLE_FICHIER];/*c;/*cd, cd;*/
     
        FILE *fp;
        FILE *fpdico;
     
        printf("\n\t*******************************");
        printf("\n\tVerificateur d'orthographe");
        printf("\n\t*******************************");
     
        printf("\n\n\tIndiquez le nom du fichier (.txt)\x85 verifier: ");   /*x85=à */
        scanf("%s",&fichier);
        strcat(fichier,".txt");
     
        fp=fopen(fichier,"r");
        fpdico=fopen("dico.dat","r");
     
        if (fp==NULL)
        {
            printf("\n\n\t\aERREUR : Impossible d'ouvrir le fichier texte !!!\n");
            getch();
            exit(-1);
         }
     
        else if (fpdico==NULL)
        {
            printf("\n\n\t\aERREUR : Impossible d'ouvrir le dictionnaire!!!\n");
            getch();
            exit(-1);
         }
        else
        {
            mem_mot_fich(fp);
            //verification si les mots du texte sont dans le dictionnaire !!!
            fseek(fpdico, 0L, SEEK_END);
            etat=1;
            nb_mot_svg=0; //etait a 0
            for (n=0; n<nb_mot;n++)
            {
                printf("\n%s", mot_fich[n]);
                if((dichotomie(fpdico))==1)//Si le mot n'a pas pu etre trouvé
                {
                    printf("\n\n\tle mot n'a pas pu \x88tre trouve\x82  dans le dictionnaire!!!");/* \x88=^e, \x82=é*/
                    printf("\n\n\tPour continuer appuyer sur une touchen ou 'o' pour le sauvegarder !!!");
     
                    if ((c=getch())=='o')
                    {
                        etat=0;
                        //reseration memoire
                        mot_a_sauvegarder[nb_mot_svg]=malloc(sizeof(char)*strlen(mot_fich[n]));
     
                        //transfert dans mermoire ç sauvegarder
                        strcpy(mot_a_sauvegarder[nb_mot_svg],mot_fich[n]);
                        nb_mot_svg+=1;
                        printf("\n\n\t********************************");
                        printf("\n\n\t*****le mot a \x82t\x82 ajout\82 a la liste a sauvegarder !!!****");
                        printf("\n\n\t********************************");
                     }
                }
                //si le mot a été trouvé
                else printf("\n\n\tLe mot fait partir du dictionnaire.");
            }
            if(etat==1)
            {
                printf("\n\n\t Le dico ne necessite aucun tri\n\n");
                getch();
            }
            else
            {
                tri_dico(fpdico);//tri du dico uniquement s'il y a du changement
                getch();
            }
    }
     
    //sauvegarde dans fichier
    fseek(fpdico,0L,0);
    fprintf(fpdico,"%s",mot_dico[0]);
    for(zz=1;zz<=nb_mot_dico;zz++)
    {
        c1=mot_dico[zz-1][0];
        c2=mot_dico[zz][0];
        if (c1==c2)
        {
            fprintf(fpdico,"%s",mot_dico[zz]);
        }
        else
        {
            fprintf(fpdico,"\n%s",mot_dico[zz]);
        }
    }
    printf("\n\n\tSauvegarde achevée!!!");
    getch();
    fclose(fpdico);
    fclose(fp);
    }
     
    void tri_dico(FILE *dico)
    {
        //determination de la longueu du mot le plus long
        fseek(dico,0L,0);//retour au debut du fichier
        cpt=0, nb_let_max=0;
     
        do
        {
            c=fgetc(dico);
            cpt+=1;
            if(c==' '||c=='\n')
            {
                if(nb_let_max<cpt)
                {
                    nb_let_max=cpt;
                }
                cpt=0;
            }
        }
        while (c!=EOF);
        /*reservation memoire pour le tampo*/
        tampon=malloc(sizeof(char)*(nb_let_max+1));
     
        fseek(dico,0L,0);
        do
        {
            do
            {
                c=fgetc(dico);
                if(c!='\n'&&c!=' ')
                {
                    tampon[cpt]=c;
                    cpt+=1;
                }
            }
            while(c!='\n'&&c!=' '&&c!=EOF);
            tampon[cpt]='\0';
     
            mot_dico[nb_mot_dico]=malloc(sizeof(char)*strlen(tampon));
            strcpy(mot_dico[nb_mot_dico],tampon);
            nb_mot_dico+=1;
            cpt=0;
        }
        while(c!=EOF);
        /*tri des mots*/
        nb_mot_dico=nb_mot_dico-2;
        for(n=0;n<nb_mot_svg;n++)//pour l'ensemble des mots a sauvegarder
        {
            etat=-5;
            cpt=0;
            //nb_mot_dico=nb_mot_dico-1+n;
            while(etat<0)
            {
                etat=strcmp(mot_dico[cpt],mot_a_sauvegarder[n]);
                cpt++;
            }
            cpt-=1;
            nb_mot_dico+=1;
            //printf("\n\nnb_mot_dico=%d",nb_mot_dico);
            mot_dico[nb_mot_dico]=malloc(sizeof(char)*strlen(mot_dico[cpt]));
            //reservation  memoire pour le mot supplémentaire
            strcpy(mot_dico[nb_mot_dico],mot_dico[cpt]);
            //transfert du mot supérieur à celui à sauvegarder à la dernière position
            mot_dico[cpt]=malloc(sizeof(char)*strlen(mot_a_sauvegarder[n]));
            //reservation  memoire pour le mot à sauvegarder
            strcpy(mot_dico[cpt],mot_a_sauvegarder[n]);
            //transfert du mot à sauvegarder
     
            //rangement par ordre alph
            for(c=1;c<=(nb_mot_dico-cpt);c++)
            {
                tampon=malloc(sizeof(char)*strlen(mot_dico[nb_mot_dico]));
                //reservation memoire egal à la taille du dernier mot
                strcpy(tampon,mot_dico[nb_mot_dico]);
                //mise en memoire tampon du dernier mot
                mot_dico[nb_mot_dico]=malloc(sizeof(char)*strlen(mot_dico[cpt+c]));
                strcpy(mot_dico[nb_mot_dico],mot_dico[cpt+c]);
                mot_dico[cpt+c]=malloc(sizeof(char)*strlen(tampon));
                strcpy(mot_dico[cpt+c],tampon);
            }
        }
    }
     
    int dichotomie(FILE *dico)
    //est-il possible de conservé le même nom (dico) que dans le main
    {
        char buffer[250];//bloc[35];
        etat=1;
        fseek(dico,0L,0);
        //retour au debut du fichier
        //recherche de la ligne correspondant à la première lettre du mot
        cf=*mot_fich[n];//nb_mot
        do
        {
            cpt=0;
            cd=fgetc(dico);
            if(cd==cf)//lorsque le caractere correspond a la 1er lettre du mot
            {
                fgets(buffer,250,dico);
                //lecture de la ligne
                if(strstr(buffer,mot_fich[n])!=NULL)
                //verification si mot contenu dans buffer
                    etat=0;
            }
            else
            {
                do//passer a la ligne suivant
                {
                    cd=fgetc(dico);
                }
                while (cd!='\n'&&cd!=EOF);
            }
        }
        while (cd!=EOF);
        return etat;
    }
     
    void mem_mot_fich(FILE *fp)
    {
        printf("\nMemorisation des mots du fichier!!! "); /*\x85=à*/
        //determination de la longueur necessaire pour le buffer
        do
        {
            c=fgetc(fp);
            cpt+=1;
        }
        while(c!=EOF);
        //reservation memoire pour la chaine
        tampon=malloc(sizeof(char)*(cpt+1));
     
        //suppression des accents et de la ponctuation et stockage dans le buffer
        fseek(fp,0l,0);//retour au debut du fichier
        cpt=0;
        do
        {
            c=tolower(fgetc(fp));
            if(c=='à')
                tampon[cpt]='a';
            else if(c=='ç')
                tampon[cpt]='c';
            else if(c=='é'||c=='è'||c=='ê')
                tampon[cpt]='e';
            else if(c=='ô')
                tampon[cpt]='o';
            else if(c==','||c==';'||c==':'||c=='!'||c=='.')
                cpt=cpt-1;
            else
                tampon[cpt]=c;
            cpt=cpt+1;
        }
        while(c!=EOF);
        tampon[cpt-1]=' ';
        tampon[cpt]='\0';
     
    //comptage du nombre de mots t du nombre de caractère maximum par mot
        cpt=0, nb_let=0, nb_let_max=0, nb_mot=0;
        do
        {
            nb_let+=1;
            if(tampon[cpt]==' ')
            {
                nb_let-=1;
                nb_mot+=1;
                if(nb_let>nb_let_max)
                    nb_let_max=nb_let;
     
                nb_let=0;
                }
            cpt+=1;
        }
        while(tampon[cpt]!='\0');
     
    //recuperation des mots du buffer et memorisation à l'aide de pointeurs
        tampon_tp=malloc(sizeof(char)*(nb_let_max+1));
        cpt=0, cpt_tp=0, nb_mot=0;
        do
        {
            do
            {
                tampon_tp[cpt_tp]=tampon[cpt];
                cpt+=1;
                cpt_tp+=1;
            }
            while (tampon[cpt]!=' ');
            tampon_tp[cpt_tp]='\0';
            cpt_tp=0;
            cpt+=1;
            //memorisation a l'aide de pointeur
            mot_fich[nb_mot]=malloc(sizeof(char)*strlen(tampon_tp));
            strcpy(mot_fich[nb_mot],tampon_tp);
            nb_mot+=1;
        }
        while(tampon[cpt]!='\0');
    }

  2. #22
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 518
    Points
    41 518
    Par défaut
    Il utilise surtout beaucoup trop de variables globales, et des fonctions trop longues.

    Edit: Wow! As-tu vu la PILE de warnings?
    Tous ces tableaux de int*, dont certains que tu passes à strlen()?
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  3. #23
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    Citation Envoyé par Médinoc Voir le message
    Il utilise surtout beaucoup trop de variables globales, et des fonctions trop longues.

    Edit: Wow! As-tu vu la PILE de warnings?
    Tous ces tableaux de int*, dont certains que tu passes à strlen()?
    pour les variables globales je me doutais que c'est pas top.

    les warnings je les ai mais pas le niveau pour les éviter, je dois déjà comprendre ce programme

    par contre pour les int *, je suis plus habitué a voir du char *, donc j'ai pas trop compris pourquoi mettre un pointeur avec des int, alors que ce sont des mot, un char me semblait plus adapté

    même si les mot ne sont qu'une suite de chiffre en réàlité pour le C


    actuellement donc je suis en train d'essayer de comprendre les étapes de ce programme

    j'analyse donc la partie "void mem_mot_fich(FILE *fp)"

    je suis preneur d'explication sur cette première étape

  4. #24
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    je commence mes question de compréhension

    cette partie :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
      do
        {
            c=fgetc(fp);
            cpt+=1;
        }
        while(c!=EOF);
    est-ce que cette partie sert à connaitre le nombre de caractère dans le fichier ?
    et ainsi cpt sera égale au nombre de caractère dans le fichier texte

  5. #25
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 684
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 684
    Points : 30 973
    Points
    30 973
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par bosk1000 Voir le message
    est-ce que cette partie sert à connaitre le nombre de caractère dans le fichier ?
    et ainsi cpt sera égale au nombre de caractère dans le fichier texte
    C'est vrai que ce code est une horreur. void main(), & devant un nom de tableau, du global à ne plus savoir qu'en faire (avec des noms bien entendu super intelligents). C'est EDUCATEL qui pond cette merde ? C'est un truc à envoyer à l'éducation nationale pour qu'ils aillent un peu inspecter ces tocards.

    Sinon pour ta question oui, tu lis un caractère du fichier et tu comptes. Ca renverra donc le nb de caractères du fichier (+1 parce que le test EOF est fait après le comptage). Mais ce n'est pas la méthode la plus rapide qui soit (compter un par un !!! )

    Autre solution possible
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    size_t nb;
    size_t cpt=0;
    char buf[1024];
    while ((nb=fread(fp, sizeof(char), 1024, buf)) > 0) cpt+=nb;
    Voilà. Au lieu de lire un caractère t'en lis X d'un coup (X dimensionné à ce que tu veux) et tu comptabilises le nb de caractères réellement lus...

    Et pour ton autre question à propos du tableau d'int passé à strlen(), si tu garantis que ton tableau d'int contient un 0 dans un de ses éléments tu as alors le droit de le passer à strlen() sans faire planter ton code. Maintenant s'il faut ensuite donner une signification cohérente au résultat que renverra la fonction... A priori je dirais qu'elle donnera le nombre d'entiers qui ont leur octet de poids faible (la partie "char" de l'entier en fait) différent de 0.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  6. #26
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    C'est vrai que ce code est une horreur. void main(), & devant un nom de tableau, du global à ne plus savoir qu'en faire (avec des noms bien entendu super intelligents). C'est EDUCATEL qui pond cette merde ? C'est un truc à envoyer à l'éducation nationale pour qu'ils aillent un peu inspecter ces tocards.
    Je confirme c'est bien avec ça que j’apprends
    c'est la misère....

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
      //reservation memoire pour la chaine
        tampon=malloc(sizeof(char)*(cpt+1));
    avec cette méthode, la taille du tableau tampon est égale à cpt+1 ?

    par contre ici
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
      fseek(fp,0l,0);//retour au début du fichier
    donc fp correspond au fichier texte, fseek sert à se placer dans le fichier, par contre je ne comprend pas l'utilisation de 0l et 0

    est ce que ceci n'aurait pas été plus adapté :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    fseek(f, 0, SEEK_SET)

  7. #27
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 684
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 684
    Points : 30 973
    Points
    30 973
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par bosk1000 Voir le message
    Je confirme c'est bien avec ça que j’apprends. c'est la misère....
    Télécharge les cours tutoriels C de ce site, tu apprendras bien plus vite et bien mieux.

    Citation Envoyé par bosk1000 Voir le message
    avec cette méthode, la taille du tableau tampon est égale à cpt+1 ?
    Elle est très exactement égale à "(cpt+1) * taille_d_un_char_en_octet". Pour l'instant le char fait un octet mais ça peut évoluer (surtout avec l'utf-8)...

    Citation Envoyé par bosk1000 Voir le message
    par contre ici
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
      fseek(fp,0l,0);//retour au début du fichier
    donc fp correspond au fichier texte, fseek sert à se placer dans le fichier, par contre je ne comprend pas l'utilisation de 0l et 0
    est ce que ceci n'aurait pas été plus adapté :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    fseek(f, 0, SEEK_SET)
    0l c'est pour faire genre "je suis super pro je sais que la fonction attend un long donc j'écris 0 à la mode long ça va plus vite". Comme si le cast implicite (0 int donnera forcément 0 long) n'était fait que pour les blaireaux.
    Le dernier 0 en revanche montre que le codeur est un gros nul qui ne sait pas que les constantes mnémoniques ont été créées. Effectivement SEEK_SET est plus adapté. Surtout que même si c'est la même chose (car SEEK_SET vaut 0), c'est évolutif. Si demain la valeur change dans la librairie C, tu n'auras rien d'autre à faire qu'à recompiler. Lui, il faudra qu'il passe en revue tous ses sources ligne par ligne.
    Et sinon t'as aussi rewind() qui est justement fait pour ce cas très particulier de retour au début. Comme ça, le "pro de educatel qui montre qu'il maitrise 0l" il pourra aller se cacher dans la honte...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  8. #28
    Modérateur
    Avatar de jlliagre
    Homme Profil pro
    Ingénieur support avancé & développement
    Inscrit en
    Juin 2007
    Messages
    2 695
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur support avancé & développement
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 2 695
    Points : 7 882
    Points
    7 882
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Pour l'instant le char fait un octet mais ça peut évoluer (surtout avec l'utf-8)...
    Pas vraiment, sizeof(char) = 1 par définition et il n'y a aucun risque que ça change en C ou C++.
    Pour l'UTF-8, il vaut mieux utiliser wchar_t ou, plus récemment, char16_t et char32_t.
    ɹǝsn *sıɹɐlos*

  9. #29
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par jlliagre Voir le message
    Pas vraiment, sizeof(char) = 1 par définition et il n'y a aucun risque que ça change en C ou C++.
    Pour l'UTF-8, il vaut mieux utiliser wchar_t ou, plus récemment, char16_t et char32_t.
    De mémoire, la norme sur les types primitifs fonctionne ainsi :

    Char sur 1 octets minimum, toujours inférieur au nombre d'octets du short.
    Short sur 2octets minimum, toujours inférieur au nombre d'octets du int.
    Int sur 2octets minimum, toujours inférieur au nombre d'octets du long.

    Et ainsi de suite...
    La norme garantis un nombre d'octet minimum, et une règle à respecté, mais pas un nombre fixe.

  10. #30
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    Merci pour ton lien

    merci aussi jlliagre et archMqx. pour vos information

    sur la suite du code
    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
     
        do
        {
            c=tolower(fgetc(fp));
            if(c=='à')
                tampon[cpt]='a';
            else if(c=='ç')
                tampon[cpt]='c';
            else if(c=='é'||c=='è'||c=='ê')
                tampon[cpt]='e';
            else if(c=='ô')
                tampon[cpt]='o';
            else if(c==','||c==';'||c==':'||c=='!'||c=='.')
                cpt=cpt-1;
            else
                tampon[cpt]=c;
            cpt=cpt+1;
        }
        while(c!=EOF);
        tampon[cpt-1]=' ';
        tampon[cpt]='\0';
    Je suppose qu vous allez me dire qu'il y a une autre méthode pour changer les caractère ou cette méthode est-elle correcte ?

    et à quoi serve les 2 dernières lignes ?

  11. #31
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 684
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 684
    Points : 30 973
    Points
    30 973
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par bosk1000 Voir le message
    sur la suite du code
    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
     
        do
        {
            c=tolower(fgetc(fp));
            if(c=='à')
                tampon[cpt]='a';
            else if(c=='ç')
                tampon[cpt]='c';
            else if(c=='é'||c=='è'||c=='ê')
                tampon[cpt]='e';
            else if(c=='ô')
                tampon[cpt]='o';
            else if(c==','||c==';'||c==':'||c=='!'||c=='.')
                cpt=cpt-1;
            else
                tampon[cpt]=c;
            cpt=cpt+1;
        }
        while(c!=EOF);
        tampon[cpt-1]=' ';
        tampon[cpt]='\0';
    Je suppose qu vous allez me dire qu'il y a une autre méthode pour changer les caractère ou cette méthode est-elle correcte ?
    Mouais, ça marche. Mais il y a bien évidemment des trucs plus "pros" que ces bêtes if/else à suivre... On peut par exemple créer une structure destinée à stocker les équivalences et ensuite définir un tableau de ce type structuré et balayer le tableau. Et déporter tout ce travail de batard dans une fonction dédiée qui se chargera de renvoyer le bon caractère. Style

    Code c : 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
    char rectif(char c)
    {
        typedef struct {
            char *src;
            char result;
        } t_truc  // Pas envie de me casser le noeud à trouver un nom intelligent, j'espère que tu comprendras l'idée sans ça
     
        t_truc tab[]={
            {"àâ", 'a'},
            {"ç", 'c'},
            {"éèêë", 'e'},
            {"îï", 'i'},
            {"öô", 'o'},
            {",;:!?.", 0},
            {NULL, 0},
        };
        t_truc *pt;
     
        // On parcours le tableau des chaines à risques
        for (pt=tab; pt->src != NULL; pt++)
            // Si le caractère est trouvé dans la chaine en cours, alors on renvoie son correspondant
            if (strchr(pt->src, c) != NULL) return pt->result;
     
        // Le caractère n'a pas été trouvé, on le renvoie tel quel
        return c;
    }

    Déjà c'est de suite plus évolutif. Si demain tu te rends compte que t'as oublié le cas "ûü" il suffit de rajouter la ligne dans le tableau et recompiler. Certes c'est un poil plus difficile à comprendre au premier abord (notion de structures, de tableau de structures et de balayage de ce type de tableau en utilisant un pointeur qui grace à l'arithmétique des pointeurs saute d'élément en élément avec un simple "++") mais une fois compris, ça ouvre d'autres perspectives.

    Ensuite ça devient de suite plus simple à coder. Surtout qu'en plus j'apprécie pas trop non plus de faire un traitement inutile sur une valeur EOF alors qu'il est si simple de le gérer avant...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    while ((c=fgetc(fp)) != EOF)
    {
        if ((c=rectif(c)) != 0)
                cpt--;                    // La valeur "0" est renvoyée si le caractère est un caractère de ponctuation
        else
            tampon[cpt]=c;   // Ici on est sûr que c est un caractère bien comme il faut ; et qu'en plus il a été rectifié selon les règles de gestion
        cpt=cpt+1;
    }
    Citation Envoyé par bosk1000 Voir le message
    et à quoi servent les 2 dernières lignes ?
    Je pense que comme il a stocké un caractère de trop à cause de l'EOF mal géré (à vérifier) il remplace ce caractère par un blanc. Puis il rajoute un '\0' pour transformer le tableau "tampon" en chaine...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  12. #32
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    c'est sur qu'on voit une sacré différence de niveau...

    donc la suite j'ai bien compris que le but est de compter le nombre de mot que contient le fichier et de combien de caractère est le mot le plus long


    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
     
    //comptage du nombre de mots et du nombre de caractère maximum par mot
        cpt=0, nb_let=0, nb_let_max=0, nb_mot=0;
        do
        {
            nb_let+=1;
            if(tampon[cpt]==' ')
            {
                nb_let-=1;
                nb_mot+=1;
                if(nb_let>nb_let_max)
                    nb_let_max=nb_let;
     
                nb_let=0;
                }
            cpt+=1;
        }
        while(tampon[cpt]!='\0');
    ce code doit je suis sur être bien sur améliorable


    ici on reserve la mémoire pour la taille de "tampon_tp" au mot le plus long ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
        tampon_tp=malloc(sizeof(char)*(nb_let_max+1));
    la ici par contre je suis perdu
    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
     
     do
        {
            do
            {
                tampon_tp[cpt_tp]=tampon[cpt];
                cpt+=1;
                cpt_tp+=1;
            }
            while (tampon[cpt]!=' ');
            tampon_tp[cpt_tp]='\0';
            cpt_tp=0;
            cpt+=1;
            //memorisation a l'aide de pointeur
            mot_fich[nb_mot]=malloc(sizeof(char)*strlen(tampon_tp));
            strcpy(mot_fich[nb_mot],tampon_tp);
            nb_mot+=1;
        }
        while(tampon[cpt]!='\0');
    }
    j'ai pas bien suivie le cheminement... voir même rien compris au fonctionnement de cette partie

  13. #33
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 684
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 684
    Points : 30 973
    Points
    30 973
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par bosk1000 Voir le message
    donc la suite j'ai bien compris que le but est de compter le nombre de mot que contient le fichier et de combien de caractère est le mot le plus long

    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
    //comptage du nombre de mots et du nombre de caractère maximum par mot
        cpt=0, nb_let=0, nb_let_max=0, nb_mot=0;
        do
        {
            nb_let+=1;
            if(tampon[cpt]==' ')
            {
                nb_let-=1;
                nb_mot+=1;
                if(nb_let>nb_let_max)
                    nb_let_max=nb_let;
    
                nb_let=0;
                }
            cpt+=1;
        }
        while(tampon[cpt]!='\0');
    ce code doit je suis sur être bien sur améliorable
    Oui. Dès qu'il y a deux opérations inverses successives tu peux être sûr qu'il y a un algo dans lequel aucune des deux n'est faite...

    Citation Envoyé par bosk1000 Voir le message
    la ici par contre je suis perdu
    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
     
     do
        {
            do
            {
                tampon_tp[cpt_tp]=tampon[cpt];
                cpt+=1;
                cpt_tp+=1;
            }
            while (tampon[cpt]!=' ');
            tampon_tp[cpt_tp]='\0';
            cpt_tp=0;
            cpt+=1;
            //memorisation a l'aide de pointeur
            mot_fich[nb_mot]=malloc(sizeof(char)*strlen(tampon_tp));
            strcpy(mot_fich[nb_mot],tampon_tp);
            nb_mot+=1;
        }
        while(tampon[cpt]!='\0');
    }
    j'ai pas bien suivie le cheminement... voir même rien compris au fonctionnement de cette partie
    Il faudrait connaitre le fichier d'origine pour en être sûr mais je pense que "tampon" contient des mots à suivre séparés par un espace, avec aussi un espace à la fin (n'oublions pas que le premier code rajoutait un espace final à la chaine récupérée du fichier), donc style "bleu blanc rouge ".
    Ce code traite donc chaque caractère de "tampon" en recopiant ce caractère dans un second buffer "tampon_tp". Mais dès que le caractère est un espace, il met alors un '\0' dans "tampon_tp" transformant alors le contenu de ce second buffer en chaine.
    Puis il alloue dans mot_fich[x] (mot_fich semble être un tableau de chaines donc mot_fich[X] sera la Xième chaine de ce tableau) l'espace pour stocker ce mot et le copie alors depuis tampon_tp.
    Au final, le tableau "mot_fich" contiendra "bleu", "blanc" et "rouge". Bref c'est un découpage comme strtok_r() sait le faire. Mais avant d'utiliser strtok_r(), il vaut mieux savoir le faire soi-même. Ceci dit, c'est bien compliqué de recopier deux fois chaque caractère. C'est quand-même pas la mort de positionner un pointeur sur le premier caractère du mot (ici "b"), continuer avec un second pointeur jusqu'à l'espace pour y mettre un '\0' et copier alors tout le contenu à partir du premier pointeur (donc "bleu") dans mot_fich[X]. Puis on remet l'espace à la place du '\0' (au cas où on aurait besoin plus tard du tampon d'origine) et on positionne le premier pointeur sur le caractère suivant et ainsi de suite. Et si on ne connait pas les pointeurs, alors on peut utiliser deux indices [i] et [j] et on joue avec tampon[i] et tampon[j] sans ce tampon_tp bidon...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  14. #34
    Modérateur
    Avatar de jlliagre
    Homme Profil pro
    Ingénieur support avancé & développement
    Inscrit en
    Juin 2007
    Messages
    2 695
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur support avancé & développement
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 2 695
    Points : 7 882
    Points
    7 882
    Par défaut
    Citation Envoyé par archMqx. Voir le message
    De mémoire, la norme sur les types primitifs fonctionne ainsi :

    Char sur 1 octets minimum, toujours inférieur au nombre d'octets du short.
    Short sur 2octets minimum, toujours inférieur au nombre d'octets du int.
    Int sur 2octets minimum, toujours inférieur au nombre d'octets du long.

    Et ainsi de suite...
    La norme garantis un nombre d'octet minimum, et une règle à respecté, mais pas un nombre fixe.
    C'est vrai pour short et int mais pas pour char. Le standard C impose que taille d'un char soit, par définition, strictement égale à un byte.

    L'ambiguïté est due à ce que les deux mots anglais octet et byte sont traduits tous les deux en français par octet.

    Pour des raisons historiques, le standard n'impose pas le nombre maximum de bits que peut contenir un byte et laisse donc la possibilité à une implémentation matérielle d'utiliser par exemple des bytes de 9, 10, voire 16 ou 32 bits. Dans le monde réel, les implémentations matérielles utilisent un "byte" de huit bits et il y a très peu de risque que ça change sous peine de provoquer la nécessité de revoir la masse de code source qui postule qu'un char fait exactement 8 bits.

    L'arrivée de caractères sur 16 ou 32 bits s'est traduite pas l'apparition du type wchar_t, pas par l'extension de la taille d'un char.
    ɹǝsn *sıɹɐlos*

  15. #35
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 189
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 189
    Points : 17 141
    Points
    17 141
    Par défaut
    La norme est un peu plus souple, elle dit que tous les types ont des tailles multiples de celles du char.
    Par ailleurs, elle donne des intervales de valeurs que chaque type doit accepter (mais sans forcément s'y limiter)
    Elle ne parle pas de bits pour ces types (sauf pour dire qu'un char fait un byte)
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  16. #36
    Modérateur
    Avatar de jlliagre
    Homme Profil pro
    Ingénieur support avancé & développement
    Inscrit en
    Juin 2007
    Messages
    2 695
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur support avancé & développement
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 2 695
    Points : 7 882
    Points
    7 882
    Par défaut
    Citation Envoyé par leternel Voir le message
    La norme est un peu plus souple, elle dit que tous les types ont des tailles multiples de celles du char.
    C'est vrai. Le standard C autorise par exemple une implémentation où les char, les short et les int ont tous une taille de 32 bits (ou de 36, ou de 64 bits ...). En revanche, le standard POSIX impose une taille de char exactement égale à 8 bits.
    ɹǝsn *sıɹɐlos*

  17. #37
    Membre averti Avatar de bosk1000
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    706
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 706
    Points : 367
    Points
    367
    Par défaut
    Ce code est vraiment imbuvable à comprendre...

    je préfère passer mon énergie sur le tuto que tu m'as fait suivre

    merci

+ Répondre à la discussion
Cette discussion est résolue.
Page 2 sur 2 PremièrePremière 12

Discussions similaires

  1. [Base de donnée] Vérification automatique MySQL
    Par remss02 dans le forum C++Builder
    Réponses: 2
    Dernier message: 28/05/2015, 19h41
  2. Vérification automatique de programme shell
    Par kromei dans le forum Shell et commandes GNU
    Réponses: 6
    Dernier message: 14/03/2013, 16h57
  3. [AC-2003] vérification automatique commandes
    Par Expensive dans le forum Access
    Réponses: 3
    Dernier message: 08/11/2012, 18h49
  4. Programme de vérification d'orthographe
    Par phil23 dans le forum C
    Réponses: 7
    Dernier message: 05/10/2007, 17h13
  5. Outil pour vérification automatique des liens
    Par zazaraignée dans le forum Balisage (X)HTML et validation W3C
    Réponses: 2
    Dernier message: 20/01/2005, 20h00

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo