Correcteur de ponctuation

Soyez le premier à donner votre avis sur cette source.

Snippet vu 19 543 fois - Téléchargée 301 fois

Contenu du snippet

Mon petit programme corrige les fautes de ponctuation telleque un espace avent un poin, la virgule, poin virgule, deux poins etc...
ou le menque d'espace après la vigule, le point etc...

Source / Exemple :

#include <windows.h>
#include <fstream>
using namespace std;
bool bMaj=false;
const char*PtCcin;
int u;
string cCint;
int param(int u);//déclaration de param (fonction pour les testes voir plus bas)

main(int argc,char**argv)
{        
         
         ofstream Fichier;
         ifstream fStr;
         /*déclaration des constantes*/
         const char CcTestVir=',';   
         const char CcTestPoin='.';
         const char CcTestDbPoin=':';
         const char CcTestPoinVir=';';
         const char CcTestExclam='!';
         const char CcTestIntero='?';
         const char CcTestParent=')';
         
         fStr.open(argv[1], fstream::in);//ouverture du texte qui a ouvert le programme
         if(fStr)
         {
            /*Création d'une copy de chemin d'accès pour ne pas toucher au texte originale*/   
                 char*teste=argv[1];//récupération du chemin d'accès qui a ouvert le programme
                 int ilongChemin=strlen(teste);//récupération de la longueur du chemin
                 char suit[ilongChemin+10];//création d'un tableau pour stoquer le chemin
                 strncpy(suit,teste,ilongChemin-4);//copy du chemin sans le .txt
                 strcat(suit,"_corriger.txt");//rajout de "_corriger.txt" dans le chemin d'accès
            /*************************************************************************/
                       Fichier.open(suit);//ouverture du texte en mode écriture 
                
                        while(getline(fStr, cCint) ){//boucle sur le numbre de ligne
                                        PtCcin=cCint.c_str();
                                 int ii=strlen(PtCcin);
                                 u=0;
                                 for(int i=0;i<=ii;i++){//boucle sur le numbre de lettre dans une ligne
                                  
                                         if(*PtCcin==' ') 
                                         {
                                                       PtCcin++;
                                                       if(*PtCcin==CcTestVir)
                                                       {PtCcin--;cCint.erase(u,1);}else
                                                       if(*PtCcin==CcTestPoin)
                                                       {PtCcin--;cCint.erase(u,1);}else
                                                       if(*PtCcin==' ')
                                                       {PtCcin--;cCint.erase(u,1);}else
                                                       if(*PtCcin==CcTestParent)
                                                       {PtCcin--;cCint.erase(u,1);}else
                                                       {PtCcin--;}
                                                       }      
                                                       
                                                       
                                                     
                         /*un switch pour voir quel lettre/signe nous avons*/
                                        switch(*PtCcin)
                                        {
                                                       case ',':
                                                             PtCcin++;
                                             if(*PtCcin!=' '){
                                                          u++;cCint.insert(u," ");
                                                          *PtCcin--;u--; 
                                                         }
                                                          else{PtCcin--;}
                                                          break;
                                                            
                                                       
                                                       case '.':
                                             bMaj=true;
                                             PtCcin++;
                                             if(*PtCcin==CcTestPoin)
                                             {PtCcin--; break;}else
                                             if(*PtCcin!=' '){
                                                          ii++; u++;cCint.insert(u," ");
                                                          *PtCcin--;u--; 
                                                         }
                                                          else{PtCcin--;}
                                                          break;   
                                                       case':':     
                                                            PtCcin++; 
                                                            if(*PtCcin==CcTestParent) 
                                                            { 
                                                            PtCcin--; 
                                                            break; 
                                                            }else{PtCcin--; 
                                                            param(u);}
                                                            break;
                                                       case';':     
                                                            param(u);
                                                            break;
                                                       case'!':    
                                                            param(u);
                                                            bMaj=true;
                                                            break;
                                                       case'?':     
                                                            param(u);
                                                            bMaj=true;
                                                            break;    
                                                  
                                                     default: 
                                                     { 
                                                     if(bMaj==true && islower(*PtCcin)) { 
                                                      bMaj=false; 
                                                      char temp[2]; 
                                                      temp[0] = (char)((*PtCcin)&0xDF); 
                                                      temp[1]=0;
                                                      cCint.replace(u,1,&temp[0]); 
                                                      }
                                                      bMaj=false; 
                                                      break; 
                                                        }  
                                                         }
                                                            
                                         
          u++;  PtCcin++;
              }
                Fichier << cCint<<"\n";//écriture du texte dans le fichier _corriger.txt 
                  }
                  //on ferme   
                 Fichier.close();
                 fStr.close(); 
 MessageBox(NULL,"Correction terminé","Fin",MB_OK);//message de fin
   }else 
    {
    MessageBox(NULL,"FICHIER ERREUR","ERREUR",MB_ICONERROR);
    MessageBox(NULL,
    "Ce progamme a besoin d'un fichier texte (.txt) pour fonctionner\nOuvrez le avec un fichier !",
    "Info",MB_OK|MB_ICONASTERISK);
     return 0;
     }	
}
int param(int u)
{
 /*vérifiquation de l'espace avant notre signe*/       
         PtCcin--;
         if(*PtCcin==' ')
         {*PtCcin++;}else{
                              cCint.insert(u," ");
                              PtCcin++; 
                              u++;
                              }
 /*vérifiquation de l'espace après notre signe*/        
         PtCcin++;
         if(*PtCcin==' ')
         {
                       *PtCcin--;
                        }else{
                             u++;cCint.insert(u," ");
                             PtCcin--; 
                              }

}

A voir également

Ajouter un commentaire

Commentaires

Messages postés
216
Date d'inscription
samedi 11 août 2007
Statut
Membre
Dernière intervention
30 mai 2011

top ça marche merci pour l'info, je vais regarder tous ça :)
pour les smiley dans un texte normal personne ne les fais
au pire des cas je rajoute dans case ':':
PtCcin++;
if(*PtCcin==CcTestParent)
{
PtCcin--;
break;
}

et pour ce smiley xD rien besoin de fair ^^
Messages postés
239
Date d'inscription
vendredi 20 octobre 2006
Statut
Membre
Dernière intervention
20 avril 2009

Heu, desole... la virgule, c'etait juste une virgule dans la phrase :o)
Il ne faut bien sur pas d'espace avant la virgule !

Les caracteres qui ont une espace avant et apres sont ! ? : ;

Mais en tappant cette reponse, je viens de me rendre compte que ton programme peut poser des problemes avec les smiley: ":)" ne doit pas etre change en ": )".
Comme je disais, tu t'attaques a un probleme plus complique que ce qu'il en a l'air :o)

Pour l'erreur, il faut que tu castes le resultat du & arithmetique en char (ou const char) et ca devrait passer (si la methode replace() de string est surchargee pour les chars:
cCint.replace(u,1,(const char)((*PtCcin)&0xDF));

Cela est du a la "promotion entiere" que pratiquent les compilateurss modernes (google t'expliquera les details si ca t'interesse, mais en gros tout ce qui est plus petit qu'un entier (y compris les chars) est caste en entier.


Si ca ne marche pas (string::replace() ne prend que des const char* comme troisieme argument) le plus simple est de declarer un char et d'utiliser son adresse:

char temp;
temp = (char)((*PtCcin)&0xDF);
cCint.replace(u,1,&temp);

Voila,
Bonne chance !
Messages postés
216
Date d'inscription
samedi 11 août 2007
Statut
Membre
Dernière intervention
30 mai 2011

heu dans ce que tu nous dis il y a une faute on met pas d'espace avant une virgule ! ?
Messages postés
216
Date d'inscription
samedi 11 août 2007
Statut
Membre
Dernière intervention
30 mai 2011

ton idée est sympa mais elle me retourne une erreur d'invalidité de converstion ent un int et const char* je vais regardé ou ça bloc
Messages postés
239
Date d'inscription
vendredi 20 octobre 2006
Statut
Membre
Dernière intervention
20 avril 2009

Salut,

C'est une bonne idee de programme, vu le nombre de personnes qui ignorent les regles de ponctuation, mais c'est plus complique que ce que ca en a l'air :o)

C'est dommage que ton programme n'implemente que la ponctuation anglaise.
En francais, pour les caracteres !?: et ;, il faut en effet mettre une espace AVANT et une APRES (et oui, en typographie, espace est au feminin :op ).

Sinon pour la gestion des majuscules, tu pourrais remplacer tous tes case 'a' ... case 'z' par

default:
{
if(bMaj==true && islower(*PtCcin)) {
bMaj=false;
cCint.replace(u,1,(*PtCcin)&0xDF);
}
break;
}

islower() te renvoie vrai si le caractere passe en argument est une minuscule et faire &0xDF a une minuscule la transforme en majuscule (attention, ca ne marche que si le caractere est une minuscule (resultat hasardeux sinon)).
Afficher les 18 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.