bonjour c'est toujours moi,
je suis sous winXP,IDE devc++, toujours newbies, et je fait un programme en c.
 
voilà j'ai plusieur pointeurs qui pointe des fichier de même type:
je pointe des fichiers ou seront enregistré des chaine de TV.
je souhaite donc les regrouper dans un "tableau de pointeur de fichier", pour un usage par la suite plus aisé (zapper entre les chaines par exemple).
j'en entend déjà qui s'arrache les cheveux    
donc je fait

le nombre de chaines étant précedement fixé avec un #define NombreDeChaines 5
 
alors ma question est la suivante:
comment passer ce "tableau de pointeur" en argument dans une fonction?  
et comment ecrire le prototype de cette fonction?
(ce serait une fonction qui ne ferait qu'un fopen de chacun des fichiers correspondant au pointeur: qu'elle fasse par exemple :FpChaine[i] = fopen(cNomFichierClient, "w" ); ce qui je tiens à le signaler fonctionne très bien en le laissant dans la fonction principale  )
 

Je vois pas très bien le soucis.

Tu crées ta fonction avec un prototype du style :

Ca devrait te permettre de faire tes fopen sans problème a priori.

On est tous passés par là
...

Pourquoi cet emoticon "sarcastic" ???
 
Tu veux passer un tableau de n'importe quoi (exemple "nimportequoi tab[10]" ) à une fonction, ben tu passes simplement le nom de la variable à la fonction => ex: fct(tab)
La fonction sera déclarée comme recevant un pointeur sur le type en question => void fct(nimportquoi *pt)
 
Chez-toi, c'est quoi ce "nimportequoi" ? Ben c'est un "FILE*" d'où la réponse de Sebxoii => void fct(FILE* *pt)
 
Toutefois, l'équivalence tableau/pointeur ne fonctionne que pour la dernière dimension. Pour les autres dimensions, un tableau reste un tableau.
Exemple: un rectangle d'int 8x10 => int rect[8][10]
Si tu passes ce "rect" à une fonction, elle pourra être déclarée ainsi
- void fct(int rect[8][10])
- void fct(int *rect[10])
Mais ne pourra en aucun cas être déclarée void fct(int **rect). C'est dû au fait que pour adresser l'élement [x][y], le compilo a besoin de connaitre la largeur pour calculer la position. et dans "int **rect", il n'y a pas d'indication de largeur...
 

Merci de le signaler. On ne s'en doutait pas...

merci breaucoup, je vais essayé ça

Quant tu passes un pointeur vers un tableau au sens large, il faut prendre l'habitude de passer la taille du tableau en paramètre. (size_t n)

oui Taz, mais là je ne connais pas la taille du tableau,
ce sont des pointeurs de fichier dont je ne connais pas la taille.
en tout cas ça fonctionne,
je suis tenté de dire Resolu!
même si ce dernier commentaire me laisse perplexe...

Si tu connais pas le nombre de fichiers dans ton tableau, comment tu fais pour les manipuler

J'ose espérer que tu en connais la taillle...

J'imagine que tu fais une boucle for dans ta fonction fopen_tableau :

Dans ce cas, au lieu de mettre "NombreDeChaines" en dur dans ta fonction fopen_tableau, Taz te conseille de changer le prototype ainsi :

et de l'appeler ce cette manière :

erf si la taille je la connais (c'est le nombre de chaine fixe en variable globale), ce que je connais pas c'est la taille du type des pointeurs.
ça se fait un sizeof(FILE)???
 
heu Sebxoii, le compilo comprendra qu'il s'agit d'un tableau de fichier?
je devrais pas plutot faire un :
taille =NombreDeChaines* sizeof (FILE);
mais ça ça me fait vraiment peur quand même ^^
parceque le type FILE on ne sait pas ce qu'il prend...
 
bref, là je suis de retour en plein brouillard

sizeof(FILE *), tu bosses avec des pointeurs sur descripteur de fichier, et non des "FILE".
 
Mais de toute façon, c'est inutile. Je te conseille de relire un peu tes cours sur les pointeurs, tu comprendras ptet mieux comment fonctionne l'adressage avec des tableaux etc...

je comprend bien la notion de pointeur, de tableau, mais dés qu'il faut manipuler des fichier je suis perdu.
et je n'ai pas vraiment de cours, mes cours c'est le site du zero, l'ipst(une univ à strasbourg qu'à un site), deux trois sites, deux trois forums, et google
mais c'est pas toujours évident de comprendre la bonne manip du premier coup. surtout quand on débute

En fait, t'as pas besoin de te préoccuper de quoi que ce soit. Quand tu fais un fopen("fichier", ...), la fonction fopen va remplir une zone bien à elle avec tout un tas d'info pour maniper ledit fichier et te renvoie l'adresse de cette zone.
Tout ce que t'as à faire, c'est stocker cette adresse (un simple nombre quoi) dans un pointeur. Pointeur de quoi ? Pointeur sur le type "FILE" (le type décrivant ladite zone) d'où un "FILE *"
Ce qui donne FILE* fp=fopen("...", ...) => l'adresse de la zone est stockée dans la variable fp. Toute fonction recevant fp saura aller dans la zone en question trouver les outils pour lire/écrire le fichier.
Ainsi, chaque fonction de lecture/écriture/contrôle du fichier doit recevoir ce "fp" et saura s'en servir.
 
Maintenant, tu veux gérer en même temps 10 fichiers, ben soit tu le fais de façon brutos
FILE *fp1;
FILE *fp2;
FILE *fp3
...
 
soit tu le fais de façon fine => FILE *fp[10]. Ensuite quand tu voudras maniper le fichier "i", tu passeras à ta fonction l'élément fp[i] (qui reste toujours un simple nombre)...

merci de vos reponse.
 
oui, la deuxième solution, c'est ce que j'ai fais.
mon programme fonctionne comme je le voulais, mais c'est un peu du charlatanisme:
je n'ai pas mi la taille du tableau, quand je passe ce dernier en paramètre à une fonction. pourquoi je ne l'ai pas fais?
par ce que cette taille est définie en variable globale:
#define tailleTableau 5
quand une fonction se voit passer en paramètre un tableau et la taille de ce dernier, elle fait une copiet du pointeur tab, par exemple et cette copie pointe sur tab[0]. la fonction (je pense) fait donc un malloc (sizeof(taille)), pour avoir la place nécéssaire pour traiter le tableau, et je pense ne pas déborder audelà, enfin seulement si j'ai bien compris.
 
donc est ce génant de ne pas mettre la taille du tableau en paramètre,
sachant qu'elle est tout de même visible dans ladite fonction car c'est une variable globale?
est ce que c'est tout à fait hors jeu ou est ce que ça marche?
si oui comment met on en paramètre une variable globale du genre
#define?
 
ps: j'ai quand même mis des securité dans la fonction pour que le tableau ne deborde pas.

bah disons que si un jour tu te mets à coder correctement ou tu tentes de réutiliser ta fonction dans un autre contexte ça va être problématique.

oui ça c'est vrai, mais je ne penses pas reprendre le code.
ce que je veux savoir c'est si c'est pas hors jeu, s'il y a un risque, si ça penalise la mémoire, le temps proc,etc...
 
si c'est juste mal écrit mais que ça marche nikel moi ça me va

Toujours coder une future reutilisation ...
 

A ton niveau, on se moque de ces considérations
 

Mauvaise habitude

heu... non je m'en fou pas des ressources.
c'est vrai que je débute et que qu'il marrive de faire totalement nimp,
mais c'est pas pour ça que je dois apprendre avec des erreurs, ou des mauvaise habitude.
quand je disait que ça marche nikel, c'est justement vis à vis de ces ressources, et pas juste "ça marche".
et les nom associé au commentaires de mon code me permettent de m'y retrouver, donc à la limite si faut reprendre j'en suis capable.
mais sur ce coup ci c'est vrai que je ne pense pas le reprendre, c'est du code pour ce former, non optimiser, pour comprendre, je pense que ce serait dangereux de le reprendre par la suite. mieux vaut recommencer une fois que tout est bien integré.

T'as tout compris.
 
En fait, quand tu manipes un tableau quel qu'il soit et où que ce soit, tu peux aller où tu veux même en dehors du tableau. Exemple t'as un int tab[10], rien ne t'interdit d'aller voir tab[125] ou tab[-422]. Le compilo ne dira absolument rien. Toutefois, à l'exécution, ça produit un comportement indéterminé (c.a.d. un comportement imprévisible => ça peut planter comme ça peut marcher comme ça peut faire rebooter ton PC => imprévisible)
 
C'est pour ça que quand tu passes un tableau à une fonction, tu peux récupérer ce tableau dans un pointeur, un tableau sans taille ou un tableau avec taille, peu importe. De toute façon, la taille ne sert pas (en dimension 1 bien sûr car dans les autres dimensions, la taille sert à calculer la position).
 
Philosophie du C => tu gères ton tableau, tu dois savoir en permanence où tu te trouves dans ton tableau et c'est à toi de faire tes propres contrôles.
 

Tu fais erreur. Dans ton source, le nb d'éléments n'est pas une variable mais un define. Quand ton code est compilé, tout le source est réécrit et tous les define sont remplacés par la valeur correspondante.  
 

Par définition, une variable globale est connue de tout le programme donc c'est inutile de la passer en paramètre.
Par ailleurs, les variables globales sont généralement très mal considérées par les programmeurs car elles affaiblissent le code
1) n'oublie pas que tu peux travailler en collaboration. Que se passera-t-il si le projet sur lequel tu es a une globale "toto" que tu ne connais pas et que tu déclares dans ta fonction ta propre variable "toto" => ta variable masquera la globale et ta fonction ne pourra pas l'utiliser
2) si au cours des tests la globale est modifiée par erreur, on ne saura jamais où est-ce qu'elle a été modifiée et faudra passer tout le code à la loupe
3) toute info portée par la globale peut être portée par une locale qui est passée en paramètre
 
Conclusion: les globales, généralement on évite. Mais un #define ce n'est pas une globale. Cependant, pour éviter de confondre un define avec une variable, on met généralement les define en majuscule car les define amènent d'autres soucis donc les programmeurs aiment bien savoir qu'ils sont en train de maniper un define...
 

C'est en forgeant qu'on devient forgeron.

merci, oui je me suis trompé, je parlais bien de "define" et non de variables globales.

Bonjour, j'ai moi aussi un problème de passage de tableau bidimensionnelle de pointeur dans une fonction, j'aimerais s'il vous plait obtenir votre aide car personne dans ma prepa ne veut bien m'aider ^^
 
en déclaration j'ai
Bloc *pbloc[6][8]; // ma grille de pointeur que je souhaite transmettre à mon timer // bien sur j'ai malloc
..
..
..
..
..
timer=gtk_timeout_add(10000,fluideaction,pbloc);
 
void fluideaction(gpointer data){
        Bloc *pbloc[6][8]=(Bloc***)pbloc; // je trouver illogique de mettre pbloc mais mon prof m'y a contraint // j'ai aussi essayer en mettant data