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

Télécharger le projet
Commenter

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.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (KissyFroth)