Scan récursif des répertoire, sa ne liste pas tous

Signaler
Messages postés
20
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
7 août 2009
-
Messages postés
20
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
7 août 2009
-
hello


Bon essayer depuis un moment de me faire une petite appli qui va lister les droit des fichier et répertoire voir plus. donc:


1.- Cela scanne presque tou, mai pas tout regarder du coter de la ligne 144 , chose importante laisser le /home dans le main


2.-le code est fonctionnel je donne le lien directement
http://www.panthere-noire.com/fichier/source/surf_find_file_main.cpphttp://www.panthere-noire.com/fichier/source/surf_find_file_main.cpp

Le code est quand même donner plus bas

3.- Astuce utilise un tube genre: le_prog |wc -l

il vous suffi de regarder si le nombre d'entrée est identique a ce que vous utiliser nautilus/konqueror etc


si vous avez une piste je suis preneur:


Je débute depuis 15 jours environ avec quelque base dans d'autre language, mai rien a voir avec e c++

CODE
#include
#include <vector>
#include <string>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
 
using std::string;
 
/*
_______________________________
/______________________________/|
|| Coder par panthere noire ||
|| liscence GPL v3 ||
|/_____________________________|/
 
Ce code est destiner a lister.
Les fichier et les répertoire sous linux.
Avec leur atribbus aux complet.
 
*/
 
// prototype
 
//permet de filtrer les donnée fourni en paramettre nottament
//et initialise la majoriter des variables
void init_source_prepare(std::vector<string> &french_only, std::string &source_path_filtre_anti_slach);
 
//Recherche des fichier
void search_find_file_dir(std::string *,std::vector<string> &done_rep_only,
std::vector<string> &done_rep_and_file, std::vector<string> &done_file_only);
 
//Recherche les informations sur les fichier chmod,chown etc
void info_stat(string,std::vector<string> &french_only);
 
//Contien un tableau du language français,pour une traduction ulterieur
void langue_fr(std::vector<string> &french_only);
 
//gestion de l'affichage
void affichage(std::vector<string> &french_only,std::vector<string> &done_rep_only, std::vector<string> &done_rep_and_file, std::vector<string> &done_file_only);
 
//code
 
void langue_fr (std::vector<string> &french_only)
{
/*
on commente les lignes
de manière a éventuelement
les charger depuis un fichier
Et pour changer facilment la langue (traduction en anglais par exemple)
*/
french_only.push_back("Démmarage de la recherche des répertoires"); //1
french_only.push_back("Type de fichier : périphérique bloc"); //2
french_only.push_back("Type de fichier : périphérique caractère"); //3
french_only.push_back("Type de fichier : répertoire"); //4
french_only.push_back("Type de fichier : FIFO/tube"); //5
french_only.push_back("Type de fichier : lien symbolique"); //6
french_only.push_back("Type de fichier : fichier ordinaire"); //7
french_only.push_back("Type de fichier : socket"); //8
french_only.push_back("Type de fichier : inconnu ?"); //9
french_only.push_back("Numéro d’inœud : "); //10
french_only.push_back("Mode : "); //11
french_only.push_back("(Octal)"); //12
french_only.push_back("Nombre de liens : "); //13
french_only.push_back("Propriétaires : UID="); //14
french_only.push_back(" GID="); //15
french_only.push_back("Taille de bloc d’E/S : "); //16
french_only.push_back(" octets"); //17
french_only.push_back("Taille du fichier : "); //18
french_only.push_back("Blocs alloués : "); //19
french_only.push_back("Dernier changement d’état "); //20
french_only.push_back("Dernier accès au fichier "); //21
french_only.push_back("Dernière modification du fichier "); //22
french_only.push_back("Opération terminée "); //23
}
 
void init_source_prepare(std::vector<string> &french_only, std::string &source_path_filtre_anti_slach)
{
std::vector<std::string> done_rep_only;
std::vector<string> done_rep_and_file;
std::vector<string> done_file_only;
 

std:string path_ok;
 
if(source_path_filtre_anti_slach == "")
{
return;
}

int lp = source_path_filtre_anti_slach.length();
if(source_path_filtre_anti_slach.substr((lp- 1), lp) != "/")
{
path_ok = source_path_filtre_anti_slach += "/";
}
search_find_file_dir(&path_ok,done_rep_only,done_rep_and_file,done_file_only);
//affichage(french_only,done_rep_only,done_rep_and_file, done_file_only);
}
 
 
void search_find_file_dir(std::string *dir_source, std::vector<string> &done_rep_only,
std::vector<string> &done_rep_and_file,std::vector<string> &done_file_only)
{
//variable
DIR *pointeur_flux_dir;
struct dirent *pointeur_flux_file;
std:string read_flux_file;
std::string N="";
std::string NB="";
//code
 
pointeur_flux_dir = opendir((*dir_source).c_str());
if(pointeur_flux_dir == NULL)
{
//std::cout << "POINTEUR NULL ------------------------------EXITED :" << std::endl;
return;
}
while((pointeur_flux_file = readdir(pointeur_flux_dir)) != NULL)
{
read_flux_file = pointeur_flux_file->d_name;if( read_flux_file "." || read_flux_file "..")
{
continue;
}
if(pointeur_flux_file->d_type == DT_DIR){
//ajout
NB=*dir_source;
//std::cout << "DEBUG2 :" << NB << std::endl;
int lp = NB.length();
if(NB.substr((lp- 1), lp) != "/")
{
N=*dir_source + "/" + pointeur_flux_file->d_name;
}
else
{
N=*dir_source + pointeur_flux_file->d_name;
}
//N=*dir_source + "/" + pointeur_flux_file->d_name;
done_rep_only.push_back(N);
std::cout << "DB---->|: " << N << std::endl;
search_find_file_dir(&N,done_rep_only,done_rep_and_file,done_file_only);
}
else
{
done_rep_and_file.push_back(*dir_source + "/" + pointeur_flux_file->d_name);
done_file_only.push_back(pointeur_flux_file->d_name);
}
}
}
 
void info_stat (std::string file_or_rep, std::vector<string> &french_only)
{
struct stat sb;
std:string Buff;
if(stat(file_or_rep.c_str(), &sb) == -1)
{
perror("stat");
}
else
{
switch(sb.st_mode & S_IFMT)
{
case S_IFBLK: std::cout << french_only[1] << std::endl;break;
case S_IFCHR: std::cout << french_only[2] << std::endl;break;
case S_IFDIR: std::cout << french_only[3] << std::endl;break;
case S_IFIFO: std::cout << french_only[4] << std::endl;break;
case S_IFLNK: std::cout << french_only[5] << std::endl;break;
case S_IFREG: std::cout << french_only[6] << std::endl;break;
case S_IFSOCK: std::cout << french_only[7] << std::endl;break;
default: std::cout << french_only[8] << std::endl;break;

}
 
std::cout << french_only[9] << ((long) sb.st_ino) << std::endl;
std::cout << french_only[10] << ((unsignedlong) sb.st_mode)<< french_only[11]<< std::endl;
std::cout << french_only[12] << ((long) sb.st_nlink) << std::endl;
std::cout << french_only[13] << ((long) sb.st_uid) << french_only[14] << ((long) sb.st_gid)<< std::endl;
std::cout << french_only[15] <<((long) sb.st_blksize) << french_only[16] << std::endl;
std::cout << french_only[17] <<((longlong) sb.st_size)<< french_only[16] << std::endl;
std::cout << french_only[18] <<((longlong) sb.st_blocks) << std::endl;
std::cout << french_only[19] <<(ctime(&sb.st_ctime)) << std::endl;
std::cout << french_only[20] <<(ctime(&sb.st_atime)) << std::endl;
std::cout << french_only[21] <<(ctime(&sb.st_mtime)) << std::endl;
}
}
 
 
void affichage(std::vector<string> &french_only, std::vector<string> &done_rep_only, std::vector<string> &done_rep_and_file, std::vector<string> &done_file_only)
{
for(long i = 0; i < done_rep_only.size(); ++i )
{
std::cout << done_rep_only[i] << std::endl;
}
info_stat(done_rep_only[0],french_only);
}
 
int main()
{
//chargement de la langue initialisation du tableaux
std::vector<string> french_only;
langue_fr(french_only);
//variable
std::string source_scan;
//répertoire a scanner
source_scan = "/home";
//code
std::cout << french_only[0] << std::endl;
init_source_prepare(french_only,source_scan);
std::cout << french_only[22] << std::endl;
return0;
}
 
 

4 réponses

Messages postés
3840
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
19 février 2021
119
Je sais que ça ne réponds pas à ta question, néanmoins... pourquoi n'utilise-tu pas boost ?
C'est un choix volontaire, une contrainte, ou tu n'y avais pas pensé ?
Messages postés
20
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
7 août 2009

le choix de ne pas être dépendant d'une lib annexe qui néssaisit l'installation de paquet sur mes distribution.
Je considère aussi que pour apprendre l'utilisation d'une lib n'est pas une bonne idée.

j'ai par contre trouvé d'ou provenais l'erreur, je compte aussi me passer de vector, afin justement d'apprendre a mieux gérer les tableaux. je pense également apprendre a y placer des pointeur ou des références.

je ne posterai pas le code final ici, car il est trop lourd pour le moment 13'000 fichier scanner = 17 mg en ram ... je pense que vector y est pour quelque chose.

désoler pour la réponse tardive
Messages postés
3840
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
19 février 2021
119
C'est donc un choix de ta part que de ne pas utiliser de bibliothèque. Oui, std::vector est "lourd", et si tu veux vraiment économiser de la mémoire, n'utilise pas std::string non plus (l'utilisation d'un design pattern flyweight pourrait être pas mal si tu as beaucoup de doublon).
Messages postés
20
Date d'inscription
vendredi 18 avril 2008
Statut
Membre
Dernière intervention
7 août 2009

l'utilisation d'un design pattern flyweight pourrait être pas mal si tu as beaucoup de doublon

euh je connaît pas ,c est quoi ,je peux trouver un tutô ou ?
a la place de std::string  j'utilise char ?
car je débute ^^