Fichiers et tableau de chaines - Page 1

Salut à tous

Je voudrais recupérer la liste des fichiers d'un repertoire et stocker les noms de fichier dans un tableau de chaines :

int counter;

counter = 0;

SYM_ENTRY *SymPtr = SymFindFirst (SYMSTR ("folder"), FO_SINGLE_FOLDER);

while (SymPtr)
{
strcpy(noms[counter],SymPtr->name);

SymPtr = SymFindNext ();
counter++;
}

Mon problème c'est dans la déclaration de la variable tableau "noms" pour une allocation dynamique. Je vois pas trop comment m'y prendre, si quelqu'un pouvait me donner un coup de main.

Merci !

comme tu ne peux pas connaitre à l'avance le nombre de fichiers, tu es obligé d'allouer petit à petit (ou bien alors te dire que tu ne dépasseras jamais N fichiers, allouer pour cette taille là, et juste vérifier que tu n'atteinds pas ce chiffre mais c'est moins bien je trouve).

le plus simple ça serait probablement de déclarer ta variable "char (*noms)[18] = NULL;", puis à chaque fichier, faire "noms = realloc (noms, (counter + 1) * sizeof (*noms));" pour allouer un nom de plus; ça marche mais c'est super lent (les fonctions d'allocation prennent bcp de temps), donc tu devrais plutôt réallouer par blocs d'un certain nombre de noms, par exemple comme ça :

#define REALLOC_SIZE 64

[ ... ]

char (*noms)[18] = NULL;
char (*ptr)[18] = NULL;
int  counter = 0;
int  size = 0;

[ ... ]

while (SymPtr)
{
    if (counter == size) // limite du tableau atteinte
    {
        size += REALLOC_SIZE;

        if (!(ptr = realloc (noms, size * sizeof (*noms))))
        {
            if (noms) // quand realloc foire, il ne libère pas l'ancien pointeur
                free (noms);

            return;
        }

        noms = ptr;
    }

    strcpy (noms[counter++], SymPtr->name);
    SymPtr = SymFindNext ();
}

(moins les éventuelles erreurs ^^)

En fait on préfère doubler la taille à chaque fois en principe (après faut voir, sur TI, c'est un peu particulier : pas beaucoup de RAM...)

PS1 : faut pas oublier de tronquer le tableau à la fin de la boucle
PS2 : free ne fait rien quand le pointeur est null, non ? (ou alors je confond, ça fait longtment que je n'ai pas fait de C)

ah ben, si, je ne me trompais pas http://www.delorie.com/djgpp/doc/libc-2.02/libc_308.html (à moins que les specs ne soient differentes sur TI..)

Merci pour la rapidité de vos réponses, ça fait plaisir !

Zephyr tu me dis que c'est long comme méthode. Je voulais savoir dans le cas d'un explorer quelle méthode était employée pour que ce soit rapide ? Parce que c'est un peu le même principe non ? On stocke la liste des fichiers puis on l'affiche ?

Pen^2
: (à moins que les specs ne soient differentes sur TI..)

elles le sont, free(null) ça plante ac ams ^^

Lukhan > bah t'as pas trop d'autres solutions en fait, la seule différence c'est que pour un explorer tu auras probablement envie de laisser la liste allouée pour la réutiliser tant que possible (et donc ne pas la tronquer à la fin de la boucle, et peut-être pas faire le "*2" à la taille que proposait Pen², puisque la mémoire d'une Ti est très limitée)

Sinon tu peux faire 2 boucles, une première pour compter le nombre d'entrées, puis tu alloues ce qu'il faut et dans la deuxième boucle tu remplis ton tableau. Mais je ne pense pas que ce soit plus rapide (enfin, ça dépend des cas sûrement...).

Enfin, tu peux aussi allouer ton tableau sur la pile, en utilisant alloca : http://tigcc.ticalc.org/doc/alloc.html#alloca ça me semble plus propre que d'utiliser realloc
[edit] : quoique... finalement ce à quoi je pensais n'est peut-être pas faisable avec alloca, et peut-être qu'il est nécessaire de passer par de l'ASM directement...

Pourquoi ne pas stocker les adresses des noms des fichiers?
Tu évalues le nombre de fichiers dans un dossier, tu alloues ta table d'adresse et tu l'as complète.

ça ne change rien au pb, les noms de fichiers ont déjà une taille fixe, donc en fait tu proposes la même chose que Sasume...

alloca ne serait pas super applicable ici, à moins 1) que le contenu soit assez petit pour tenir dans la pile et 2) de stocker au fur et à mesure dans une liste chaînée, puis après faire une deuxième passe qui copie la liste chaînée dans un tableau malloc-é

au passage, il parait que sur ti l'implémentation de realloc n'est pas tout à fait standard (bicause HeapRealloc derrière), et qu'en cas d'échec le pointeur est libéré, donc "if (ptr) free (ptr)" à supprimer dans #1

Lukhan :
Zephyr tu me dis que c'est long comme méthode.

Il te disait que ce qui est lent, c'est d'augmenter la taille du tableau d'une seule unité à chaque fois. Sa solution (augmenter la taille de REALLOC_SIZE) fonctionnera très bien en pratique.. (en théorie aussi, d'ailleurs)

Zephyr
:

Pen^2
: (à moins que les specs ne soient differentes sur TI..)

elles le sont, free(null) ça plante ac ams ^^

hé bé, super


En tous cas, c'est quand même bien, les Vectors

J'ai utilisé la solution de Sasume avec deux boucles et ça marche bien, mais j'ai un autre problème : je veux utiliser le tableau dans une autre fonction. Donc j'utilise le passage par adresse comme ceci :

noms est le tableau de chaines, counter le nombre d'entrées du tableau
[7]
fonction(&noms,counter); // Appel de la fonction

// Fonction :

fonction(char *tabnoms, int count)
{

int a;
a=0;

DrawStr(10,10,tabnoms[a] , A_NORMAL);

}

Le problème c'est que ça n'affiche pas le bon résultat, comme si l'adresse avait changée. Pourtant il me semble que la syntaxe est bonne.

heu tabnoms est censé être un tableau de chaines ? parceque ta fonction prend un tableau, donc c'est incompatible (et tu passes "&noms" en paramètre, ce qui est curieux aussi puisqu'un tableau est déjà un pointeur)

Oui, plus précisément "char *" c'est un tableau de caractères donc c'est une seule chaîne, pour faire un tableau de chaînes il faut "char**" ; et d'autre part un tableau est toujours représenté par un pointeur vers son premier élément, donc c'est déjà automatiquement du passage par adresse et si tu ajoutes un & tu te retrouves avec l'adresse du pointeur (soit un char***), qui n'est pas ce que tu veux. Tu as bien activé les warnings à la compilation ? parce que le compilateur devrait te prévenir qu'il y a des problèmes, là...

et surtout si tu as utilisé la même structure de donnée que zephyr, tes chaînes ne seront pas stockée en tant que char *, mais en tant que char[18] ^^

Je l'ai modifié comme ça :

fonction(noms,counter); // Appel de la fonction

// Fonction :

fonction(char **tabnoms, int count)
{

int a;
a=0;

DrawStr(10,10,tabnoms[a] , A_NORMAL);

}

Mais ça ne fonctionne toujours pas...

Savez-vous où je peux trouver une explication sur les warnings parce que j'ai ceux là que je ne comprends pas :

Extra tokens at end of #include directive
No newline at end of file

le 1er c'est que tu as du mettre quelque chose après le "#include <fichier>", ce qui n'est pas censé être valide, le 2eme c'est qu'il faut ajouter un retour à la ligne après la dernière ligne. sinon ton code devrait marcher, tu peux le mettre en entier ?

Pollux :
et surtout si tu as utilisé la même structure de donnée que zephyr, tes chaînes ne seront pas stockées en tant que char *, mais en tant que char[18] ^^

ah ui merde on était parti là-dessus; du coup c'est un char (*var)[18] qu'il faut que tu passes à ta fonction, pas un ** (d'ailleurs ça aurait du faire un warning non ?)

Ouais ça fait pas mal de warning
J'ai résolu le premier, je mettait des ";" a la fin des #include

en règle génerale quand y'a des warnings c'est mauvais, t'aurais du directement poster les warnings en fait, ça aide pas mal pr répondre à la question

"Passing argument 1 of 'fonction' from incompatible pointer type"

Y'a pas le detail des warnings dans l'aide de TIGCC ?

non mais bon là c'est quand même plutôt explicite...

Merci c'est résolu maintenant