Gestion fichiers txt (insertion, concaténation, dénombrement, filtres etc...)

Soyez le premier à donner votre avis sur cette source.

Vue 11 512 fois - Téléchargée 909 fois

Description

Mon code permet de faire plusieurs actions sur les fichiers txt. Il y a peut etre des sources similaires mais je n'ai pas vérifié (je sens que je vais encore avoir des commentaires du genre : ca y est déjà et mieux codé en plus). Les principales catégories sont Effacage/Copie/Concaténation/Remplacage/Insertion/Dénombrement(lignes,mots...)/Filtres si l'on souhaite seulement sélectionner certains types de mots.
Voilà je crois que ca résume bien.

Attention n'utilisez pas de fichiers qui s'appellent temp.txt ou temp1.txt (déjà utilisés par le programme)

Hésitez pas a commenter la source pour dire ce que vous en pensez

Source / Exemple :


#include <iostream>
#include <vector>

using namespace std;

class LectEcr {

	

private : 

	FILE * f;
	char * nom; 
	
	vector <int> indexDebutMots;	//Table d'indexation de tous les mots (les debuts de mots)
	vector <int> indexFinMots;		//Table d'indexation de tous les mots (les fins de mots)
	vector <int> indexLignes;		//Table d'indexation de toutes les lignes (les debuts):
	
	int nbMots;					//Nombre de mots total (apres passage de la fonction MAJIndex)
	int nbLignes;				//Nombre de lignes total (apres passage de la fonction MAJIndex)

	bool isopen ;
	int mode_open;

public : 

	LectEcr(char * c);			//Constructeur

/////////////////////////////////////////////////////////////////////////
//	Fonctions de Base
/////////////////////////////////////////////////////////////////////////

	//Ecrit la chaine dans le fichier à la position et sur la longueur indiquée
	//Efface les caracteres présents sur ces positions si il le faut
	bool ecrire(char * chaine,int pos,int longueur);  
	
	
	//Lit les caracteres et les place dans le buffer de debut sur la longueur indiquée
	int lire(char * buffer,int deb,int longueur);	   

	//Ouvre le fichier courant
	//mode 1 : "r+" (lecture ecriture) / mode 2 mode concatenation "a"
	bool ouvrir(int mode);

	//Ferme le fichier courant
	int fermer();

/////////////////////////////////////////////////////////////////////////
//	Fonctions de remplacage de chaines
/////////////////////////////////////////////////////////////////////////

	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant  
	bool remplaceChaine(char * a,char * b);					
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant à partir de la
	//position indiquée
	bool remplaceChaineAPartirDe(char * a,char * b,int pos);			
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier courant jusqu'à la
	//position indiquée
	bool remplaceChaineJusqua(char * a,char * b,int pos);				
	
	//Remplace toutes les occurences de la chaine a par la chaine b dans le fichier situées entre pos1 et pos2
	//la methode remplacera les mots qui débordent sur la droite mais pas sur la gauche
	bool remplaceChainePartie(char * a,char * b,int pos1,int pos2);	

/////////////////////////////////////////////////////////////////////////
//	Fonctions d'effacage
/////////////////////////////////////////////////////////////////////////

	//Efface le fichier courant
	bool effacer();							 		
	
	//Efface le fichier spécifié (les données car le fichier existe toujours)
	bool effacer(char * nom_fichier);        		
	
	//Efface la partie du fichier spécifiée (de pos sur longueur)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effacePartie(int pos,int longueur); 		
	
	//Efface le fichier à partir de la position spécifiée
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceAPartirDe(int pos);								
	
	//Efface le fichier jusqu'à la position spécifiée
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceJusqua(int pos);									
	
	//Efface toutes les occurences de la chaine spécifiée (remplace par rien en fait)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	bool effaceChaine(char * chaine);		 			

/////////////////////////////////////////////////////////////////////////
//	Fonctions de copie
/////////////////////////////////////////////////////////////////////////

	////Copie le contenu de a dans b (crée b si besoin ou écrase les données de b)
    bool copie(char * source,char * dest); //copie le contenu de a dans b (crée b si besoin ou écrase les données de b)     
	
	//Copie le contenu de f vers le fichier dest
	bool copieVers (char * dest);  											
	
	//Copie le contenu de source dans le fichier f (écrase les données ds f si besoin)
	bool copieDe (char * source);  
	
	//Copie la partie de a spécifiée dans b
	bool copiePartie(char * source,char * dest, int pos, int longueur); //copie la partie de a spécifiée dans b			
	
	//Copie le contenu de a (à partir de pos) dans b
	bool copieAPartirDe (char * source,char * dest, int pos);          

/////////////////////////////////////////////////////////////////////////
//	Insertion
/////////////////////////////////////////////////////////////////////////

	//Insert le contenu d'une chaine à l'endroit spécifié
	bool insertChaine(char * chaine,int pos);																				

	//insert le contenu d'un autre fichier à l'endroit spécifié	
	bool insertFichier(char * fichier,int pos); 	

/////////////////////////////////////////////////////////////////////////
//	Fonctions de concaténation
/////////////////////////////////////////////////////////////////////////

	//Concatene source a la suite de dest (source reste inchangé)
	bool concatFichier(char * source,char * dest); 		
	
	//Concatene source a la suite de f (source reste inchangé)
	bool concatFichierDe(char * source); 						
	
	//Concatene f a la suite de dest (f reste inchangé)
	bool concatFichierVers(char * dest); 

	//Concatene chaine a la suite du fichier courant
	bool concatChaine(char * chaine);																																			
	
	//Concatene chaine à la suite du fichier spécifié
	bool concatChaineFichier(char * chaine,char * fichier,int longueur);

/////////////////////////////////////////////////////////////////////////
//	Fonctions de dénombrement
/////////////////////////////////////////////////////////////////////////
	
	//Renvoie le nombre d'ocurences de 'chaine'
	int nbOccurences(char * chaine);
	
	//Renvoie le nombre de lignes IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNbLignes() {return nbLignes;};
	
	//Renvoie le nombre de mots IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNbMots(){ return nbMots;};
	

/////////////////////////////////////////////////////////////////////////
//	Fonctions pour trouver des positions particulières
/////////////////////////////////////////////////////////////////////////

	//Renvoie la position du début du mot spécifié par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosDebutMot(int a) { 
		if (a>=0 && a<=nbMots) return indexFinMots.at(a-1); //Le premier mot est le mot n°1 (Convention KissyFroth)
		else return -1;
	};  
	
	//Renvoie la position de la fin du mot spécifié par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosFinMot(int a)
	{ 
		if (a>=0 && a<=nbMots) return indexFinMots.at(a-1);
		else return -1;
	};
	
	//Renvoie la position du début de la ligne spécifiée par son numéro (a) 
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getPosLigne(int a) 
	{ 
		if (a>=0 && a<=nbLignes) return indexLignes.at(a-1);
		else return -1;
	};
	
	//Renvoie le numéro du mot spécifié par une position (du moment que la position est dans le mot c'est bon)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNumMot(int pos);
	
	//Renvoie le numéro de la ligne spécifiée par une position (du moment que la position est dans la ligne c'est bon)
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	int getNumLigne(int pos);

/////////////////////////////////////////////////////////////////////////
//	Fonctions diverses
/////////////////////////////////////////////////////////////////////////

	//Compare si 2 chaines sont identiques sur la longueur spécifiée (en partant du début) 
	bool egalChaines(char * a,char * b,int longueur);				
	
	//Renvoie vrai si le caractere a appartient a la chaine b faux sinon
	bool appartient(char a,char * b);

	
	
	//Fonction Mise A Jour Index
	//Certainement la fonction la plus importante de la classe
	//Elle sert à remplir les tableaux d'indexations de tous les mots 'indexMots' et de toutes les lignes 'indexLignes'
	//mis en attributs private
	//Elle sert aussi à dénombrer le nombre de mots et de lignes
	//Vous devrez l'appeller avant chaque fonction de statistiques ou de positionnement (fonctions classées dans
	// "denombrement" ou "positions particulieres") à moins qu'aucun changement n'ait été effectué depuis le dernier appel
	//La chaine "separateurs" désigne tous les caractéres que vous souhaitez voir comme étant des séparateurs de mots
	//Par exemple " " ou "*" peuvent etre désignés comme separateurs et ne feront donc jamais parti de mots 
	//Le caractere de saut de ligne '\n' et les guillemets '"' sont considérés comme des séparateurs par défaut
	bool MAJIndex(char * separateurs);
	

	//Met a jour uniquement l'index des lignes
	bool MAJIndexLignes();

	
	
	//Retourne true si le mot n° nb répond aux criteres de la chaine
	//Le caractere * peut désigner n'importe quelle chaine de caracteres
	//EXEMPLE : le mot "banane"
	// motCriteres renverra "true" aux criteres "*a*a*" (il y a bien 2 "a" qui ne sont pas forcés de se suivre) 
	// motCriteres renverra "true" aux criteres "ba*" (banane commence par ba + autre chose après)
	// motCriteres renverra "false" aux criteres "*aa*" (les 2 "a" devraient se suivre pour que ce soit vrai)
	// motCriteres renverra "true" aux criteres "*b*" (le caractere "*" peut ne rien désigner : il ny a rien avant b)
	// motCriteres renverra "false" aux criteres "*u*" (le caractere "u" n'est pas présent dans "banane")
	// motCriteres renverra "false" aux criteres "*n" (banane ne se termine pas par n")
	//
	// min et max sont des filtres de taille du mot recherché
	// si vous voulez des mots de toutes les tailles vous devrez mettre en param 0 pour min et -1 pour max
	//
	//IMPORTANT: appeller MAJIndex AVANT d'appeller cette fonction
	//
	bool motCriteres(char * crit,int nb,int min,int max);

	
	
	//Copie tous les mots du fichier courant qui répondent aux critères "crit" dans le fichier f;
	// min et max sont des filtres de taille du mot recherché
	// si vous voulez des mots de toutes les tailles vous devrez mettre en param 0 pour min et -1 pour max
	int copieMots(char * fichier,char * crit,int min,int max);

};

Conclusion :


J'ai inclus un main où il y a des exemples détaillés de fonctions de la classe. Je pense que c'est plus parlant que des explications.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
38
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
7 avril 2007

Eh ben c'était pas prévu tout simplement mais maintenant ca ne pose plus de problèmes (en réponse à Luthor)
Note : je vais bientot mettre une nouvelle mise a jour dans laquelle je vais reprendre ton conseil, Luthor :
à savoir que je vais supprimmer ces ouvertures/fermetures permananentes pour les remplacer par une fonction "ouvrir"
et une fonction "fermer".
Sur les gros fichiers ca représente un gain de temps hallucinant (on divise le temps de traitement par plus de 10 )
mais au début j'avais fait des tests sur de petits fichiers et je ne m'était pas rendu compte.
Par ailleurs nombre de fonctions vont etre optimisées.
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
5
"(bah le principal c'est quand meme que ca marche non ?)". Bas justement, si t'as plus de 100.000 mots ?
Messages postés
38
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
7 avril 2007

Voilà c'est fait : les tableaux (qui n'avaient pas rencontré un franc succès) ont été remplacé par des vector
J'espère que ca fera taire les raleurs ... :p
Messages postés
38
Date d'inscription
mardi 16 août 2005
Statut
Membre
Dernière intervention
7 avril 2007

Bon bon j'ai compris : je vais modifier ca rapidement (bah le principal c'est quand meme que ca marche non ?)
C'est vrai qu'au point de vue mémoire, c'est pas optimisé.
Messages postés
1787
Date d'inscription
lundi 22 novembre 2004
Statut
Membre
Dernière intervention
31 janvier 2009
2
Ah oui problème de vue désolé lol
Afficher les 9 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.