Discussion :

[M4xim3]

Bonjour à tous,

J'ai crée un programme permettant d'ouvrir et de lire un ensemble de fichier contenu dans un répertoire et de réécrire les infos contenu dans ces derniers dans un fichier.

Cependant, il y a un fichier (dans toute la liste) que je souhaiterais lire en premier. Est-il possible d'établir une priorité de lecture ? Dire que je veux lire ce fichier avant les autres ?

Merci

[gbdivers]

Bonjour et bienvenue sur le forum

Si c'est un fichier en particulier, tu le mets en haut de la liste simplement, non ?
Avec du code, on comprendra peut être mieux le problème

[Jean-Marc.Bourguet]

Je ne comprends pas ta question. Qu'est-ce qui t’empêche de le faire?

Au mieux, tu t'arranges pour que ta liste de fichiers soit ordonnée comme ça t'arrange (si elle provient d'arguments sur la ligne de commande ou d'un fichier), au pire tu lis toute ta liste et tu l'ordonnes suivant les critères qui t'intéresses avant de commencer à lire les fichiers eux-mêmes. Éventuellement, tu peux traiter d'office le fichier qui doit être lu en premier puis quand il arrive à sa place dans ta liste, tu le sautes.

[Neckara]

Je pense qu'il doit ouvrir son dossier avec opendir() puis qu'il lit le contenu avec readdir() et traite directement les fichiers ?


Dans ce cas là, il doit d'abord créer une liste de struct dirent et commencer à traiter les fichiers après avoir lu le dossier.

Sinon il y a quelques fonctions qui pourraient être utile (partie voir aussi) :
http://man.developpez.com/man3/opendir.3.php

[M4xim3]

Merci de vos réponses.

Je ne peux pas mettre manuellement le fichier "prioritaire" en haut de la liste; mon programme doit être autonome car je dois scruter tout un répertoire contenant des groupes de fichiers, chaque groupe comprenant eux mêmes le fichier "prioritaire" en question.

J'espère que vous m'avez suivi, en gros:

-Répertoires

-Dossier 1

titi.aze
titi.ert
titi.hor (mon fichier devant être lu en premier)
titi.wxc

-Dossier 2

toto.aze
toto.ert
toto.hor
toto.wxc

Mon objectif est de pouvoir lire en premier le fichier ayant pour extension .hor

Mon programme exécute les fonctions suivantes:

-J'ouvre mon fichier principal (celui dans lequel sera stocké toutes les données)
-Je me place dans le chemin des Répertoires

-Pour chaque dossiers contenu dans Répertoires

-Pour chaque fichiers contenu dans chaque dossiers

-Je lis mon fichier
-J'écris dans mon fichier principal

Je me suis donc demandé s'il était possible de définir des priorités dans des traitement de groupe comme ça, du style "je veux que mon fichier .hor soit lu en premier".

Ordonnées mes fichiers est peut être la solution ... Comment cela fonctionne ?

Merci beaucoup

[Neckara]

Dans ce cas là pourquoi ne pas faire un tableau de liste (ou de vecteur) ?

Pour chaque dossier, tu as une liste (ou un vecteur) de fichiers à traiter.
Lors de la lecture du dossier, tu peux alors mettre à jour ta liste ou ton vecteur et ensuite traiter les fichiers dans l'ordre.

Sachant que selon ce que tu souhaites faire, tu peux ne pas mettre à jour ta liste à chaque fois que tu veux faire un traitement ou effectuer un traitement si et seulement si la liste a été mise à jour.

Sinon la fonction scandir me semble appropriée pour ce que tu veux faire :
http://man.developpez.com/man3/scandir.3.php

[gbdivers]

Je recommande quand même l'utilisation de code portable, donc d'utiliser boost filesystem (http://www.boost.org/doc/libs/1_50_0.../doc/index.htm)

Pour la priorité, plusieurs solutions :
* tu fais une première lecture pour tes fichiers prioritaires, puis une seconde pour les autres fichiers
* tu remplis un std::vector<std::string> puis tu fais un trie avec std::sort
* tu fais une map<unsigned, std::string> contenant un numéro de priorité

Pour l'évolutivité de ton programme (sans temps de dev supplémentaire important), tu pourrais prendre des arguments en ligne de commandes avec des couples "nom d'extension + numéro de priorité"
par exemple : prog /dir hor 1 defaut 2

[koala01]

Salut,

Tu vas donc récupérer une liste de noms de fichiers pour chaque dossier que tu vas parcourrir.

A partir de là, tu peux parcourir la liste pour faire "ce que tu veux", comme :

1. déterminer si le fichier prioritaire existe bel et bien, et à quelle position
2. déplacer le nom du fichier prioritaire dans la liste pour qu'il prenne la première position
3. trier les noms de fichiers selon différents critères
4. traiter chaque fichier un à un
5. ...

De toute évidence, le simple tri des noms de fichiers risque de ne pas suffir, car tu n'a aucune certitude de trouver un critère de tri qui t'assure que le fichier prioritaire se retrouve effectivement en première position.

De même, il semble inoportun de traiter les différents fichiers tant que tu n'as pas la certitude d'avoir effectivement identifié le fichiers prioritaire

Il ne te reste plus donc, dans la liste ci-dessus, que les possibilités (1) et (2)

Je crois que le plus facile sera de toutes manières de créer une fonction proche de bool isPrior( nom_de_fichier ) qui aura simplement pour but de déterminer si le nom fourni en paramètre respecte les règles (qu'il te faut définir ) pour être considéré comme le fichier prioritaire

Elle ressemblerait sans doute à quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
bool isPrior(std::string const & filename)
{
    if( LesConditionsPourEtrePrioritaire )
    {
        return true;
    }
    return false;
}

A partir de là, pour la solution (1), tu pourrais parcourrir une première fois ta liste de fichiers sous une forme proche de
size_t priorFileIndex = std::numeric_limits<size_t>::max();

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
for(size_t i totest = 0; i< allFilenames.size();++i)
{
    if( isPrior(allFilenames[i])
    {
        priorFileIndex = i;
        break;
    }
}

puis tu effectuerais le traitement réel sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* d'abord le fichier prioritaire, s'il existe */
if( priorFileIndex !== std::numeric_limits<size_t>::max())
{
    traitementFichier(allFilenames[priorFileIndex];
}
/* puis tous les autres */
for(size_t i = 0; i< allFilenames.size();++i)
{
    if(    priorFileIndex !== std::numeric_limits<size_t>::max()
        && i == priorFileIndex)
    {
        traitementFichier(allFilenames[i]);
    }
}

La solution (2) pourrais assez facilement utiliser les algorithmes offerts par la STL, sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
for(size_t i =  0; i< allFilenames.size();++i)
{
    if( isPrior(allFilenames[i])
    {
        if(i != 0 ) // il n'est pas judicieux de swaper un élément avec lui-même :-S
        {
            std::swap(allFilenames[0],allFilenames[i]);
        }
        break; // il ne sert à rien d'aller plus loin ;)
    }
}

Puis tu n'aurais plus qu'à traiter tous les fichiers dans l'ordre dans lequel ils sont dans ta liste, sans t'en inquiéter outre mesure.

Cela deviendrait alors une boucle proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(size_t i = 0; i< allFilenames.size();++i)
{
    traitementFichier(allFilenames[i]);
}

[M4xim3]

Merci beaucoup,
vos réponses m'ont vraiment bien aidé. Cela m'a pris un peu de temps tout de même mais l'important c'est le résultat ...

A bientôt merci encore.