argv dans une fonction

Version imprimable

Voir 40 message(s) de cette discussion en une page

bonjour,
une de mes fonction a besoin des argument de argv[] pour fonctionner, comment je fais pour les récupérer ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int *ma_fontion(char **argv);
 
int main(int argc, char *argv[]){
ma_fontion(argv); // ???? erreur N°1
}
 
int *ma_fontion(char **argv){
int *mes_operations
// .... 
return(mes_operations);
// mes_operations => un tableau qui contient les résultats souhaités
}

erreur

Code:

1
2
ligne 5: attention : assignment from incompatible pointer type [enabled by default]
ligne 10: attention : return from incompatible pointer type [enabled by default]

Bonjour,

Je suis débutant en C, donc je vais essayer de pas dire de bêtises, mais je pense que c'est tout simplement à prendre en compte comme un tableau de char.

L'indice 0 de ton tableau représente le nom du fichier, et l'indice 1 le paramètre suivant, etc...

argc représente le nombre d'arguments, tu peux l'utiliser pour vérifier que le nombre de paramètres est cohérent pour l'exécution de ton code.

Voilà, j'espère pas avoir dis de bêtises :)

Un code fonctionnel pour tester
Code:

1 2 3 4 5 6 7 8 9 10 int main(int argc, char *argv[]) { if (argc == 2) { printf("Le nom de mon fichier est %s\n", argv[0]); printf("mon paramètre est %s\n", argv[1]); return 0; } return 1; }

07/04/2012, 13h42
smitch

"ma_fonction" réalise des opérations avec des arguments, de ce coté là il n'y a pas de problème, et le résultat est stocké dans un tableau "mes_operations"

le problème se situe au niveau de l'appel de la fonction, et aussi dans le "return(mes_operations)"

Pour ta fonction "ma_fonction"

Code:

ma_fontion(argv[1]);

devrait être correct, par contre je ne comprend pas les doubles pointeurs, peut-être ne suis-je pas assez avancé pour comprendre cela.

Mais ça m'étonnerait pas que ton erreur soit une erreur de pointeur, vu ton message d'erreur ;)

Voilà un autre exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void ma_fonction(char *argv) { printf("Mon paramètre est %s\n", argv); } int main(int argc, char *argv[]) { if (argc == 2) { ma_fonction(argv[1]); return 0; } return 1; }
ou ceci est possible aussi
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 char *ma_fonction(char *argv) { return argv; } int main(int argc, char *argv[]) { if (argc == 2) { printf("mon paramètre est %s\n", ma_fonction(argv[1])); return 0; } return 1; }

07/04/2012, 14h02
smitch

moi j'ai seulement écouté les avertissements lorsque je compile, on me dit qu'il faut un double pointeur.

oui ton programme marche très bien, mais c'est pareil de mon coté, lorsque j'utilise un printf dans "ma_fonction", le résultat s'affiche normalement.

Ce que je cherche à faire, c'est de stocker le résultat dans un tableau au lieu de l'afficher, ensuite le renvoyer vers ma fonction principal, et c'est là que sa se complique
07/04/2012, 14h04
fred1599

Tu ne peux pas retourner un tableau :)

Voir ci-dessus j'ai édité mon message précédent
07/04/2012, 14h07
Bktero
Je ne suis pas sûr que les warnings que tu indiques soient causés par les passages d'argv en paramètres. J'ai fait une fonction pour tester :
Code:

1 2 3 4 5 6 7 8 9 void test(char **arguments, int nbarg) { int c; puts("\n\n Fonction test\n"); for(c=0;c<nbarg;c++) { printf("argv[%d] = [%s]\n", c, arguments[c]); } }
que j'appelle dans le main() :
Code:

1 2 3 4 5 6 int main(int argc, char *argv[]) { test(argv, argc); return 0; }
Je n'ai pas de warning à la compilation, en utilisant -Wall -Wextra de gcc.

Une remarque sur ta fonction utilisant argv :

Code:

int *ma_fontion(char **argv);

Il faut aussi que tu passes argc en paramètre, sinon impossible pour toi de savoir combien d'éléments contient le tableau. Que souhaites-tu faire dans cette fonction ?

un pointeur sur un tableau c'est possible

j'essaie en ce moment de modifier un code qui fonctionnait, mais je l'ai pas encore fini, j'ai une erreur de segmentation, je repasserai tout à l'heure car je dois y aller
merci pour le coup de main en tout cas

voila un code un plus complet, la fonction ne fait pas grand chose, elle réalise juste une copie de argv, mais c'est juste un exemple dont je vais m'inspirer pour réaliser mon programme du même style.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
 
/*  Prototype  */
int * Function(int la_taille,char **argv);
 
/*  Main  */
int main(int argc, char *argv[])
{
  char *tableau_final;
  int nombre_case = argc;
  int i;
  /* Allocation */
  printf("Affichage depuis la fonction Function:\n");
  tableau_final = Function(nombre_case,argv); // fonction
 
  printf("\n");
  printf("Affichage depuis la fonction main :\n");
  for(i=0;i<nombre_case;i++){
    printf("%s\n",tableau_final[i]);
  }
  printf("\n");
 
  return 0;
}
 
/*  Function  */
int * Function(int la_taille, char **argv)
{  
  char * tab_a_renvoyer;
  int i;
  /* Allocation */
  if( (tab_a_renvoyer = (char*) calloc (la_taille,sizeof(char))) == NULL)
    {
      perror("Echec");
      exit(0);
    }  
  for(i=0;i<la_taille;i++){
    tab_a_renvoyer[i]=argv[i];
  }
   for(i=1;i<la_taille;i++){
     printf("%s |",argv[i]);
  }
 
  return tab_a_renvoyer;
}

Si tu veux jouer avec les doubles pointeurs, il faudra l'adresse de ton argument, je propose ceci, sans trop bien comprendre l'intérêt, je dois dire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 char *ma_fonction(char *argv) { return argv; } int main(int argc, char **argv) { if (argc == 2) { char **tab = &argv[1]; printf("mon paramètre est %s\n", ma_fonction(*tab)); return 0; } return 1; }

07/04/2012, 15h15
Bktero

1) La fonction renvoie un int* d'après son prototype mais elle renvoie en fait un char*. A corriger.

2)

Code:

tab_a_renvoyer[i]=argv[i];

On ne copie pas des tableaux de cette façon en C. On utilise strcpy() ou memcpy().

3)

Code:

char * tab_a_renvoyer;

Ce n'est qu'une chaîne de caractères et non un tableau de chaîne de caractères comme l'est argv.

4) A quoi cela va t-il te servir de copier argv ? Normalement, quand tu utilises les arguments de ton main, tu les parses et les enregistre dans des variables adaptées.

tab_a_renvoyer est tableau dynamique

la fonction que je cherche à faire ne copie pas argv, ce n'est pas le but, mais elle réalise plusieurs choses avant d'insérer les résultats dans tab_a_renvoyer et le renvoyer vers main, et elle a besoin des données qui se trouvent dans argv

Ce n'est pas un très bon exemple celui que je vous ai donné, mais c'est juste pour faire court et ne pas compliqué la situation.

J'ai appliqué les modifications, maintenant j'ai plusieurs messages d'avertissement, sans vraiment les comprendre, et lors de l'exécution j'ai une erreur de segmentaion

Main
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <stdio.h> #include <stdlib.h> #include <errno.h> /* Prototype */ char * Function(int la_taille, char **argv); /* Main */ int main(int argc, char *argv[]){ char *tableau_final; int nombre_case = argc; int i; /* Allocation */ printf("Affichage depuis la fonction Function:\n"); tableau_final = Function(nombre_case,argv); // fonction printf("\n"); printf("Affichage depuis la fonction main :\n"); for(i=0;i<nombre_case;i++){ printf("%s\n",tableau_final[i]); } printf("\n"); return 0; }
Function
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 /* Function */ char * Function(int la_taille, char **argv){ char * tab_a_renvoyer; int i; /* Allocation */ if( (tab_a_renvoyer = (char*) calloc (la_taille,sizeof(char))) == NULL){ perror("Echec"); exit(0); } strcpy (tab_a_renvoyer,argv); for(i=1;i<la_taille;i++){ printf("%s |",argv[i]); } return tab_a_renvoyer; }

Code:

strcpy (tab_a_renvoyer, *argv); /* Pour l'argument 0 */

Mais je n'arrive toujours pas à voir pourquoi utiliser un double pointeur?

Tu ne peux pas retourner un tableau, je me répète, mais c'est une chose dont je suis sûr :)

Si on part sur le principe qu'on ne retourne pas un tableau, on pourrait modifier ton code pour qu'il soit fonctionnel. Il te reste des erreurs de pointeurs.

D'ailleurs je suis débutant aussi et je te conseille de jouer avec un seul pointeur pour commencer, tu joueras avec la "modification de pointeur" un peu plus tard :)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 #include <stdio.h> #include <stdlib.h> #include <string.h> /* Function */ char *Function(int la_taille, char **argv){ char *tab_a_renvoyer = malloc(80*sizeof(char)); int i; /* Allocation */ if(tab_a_renvoyer == NULL){ perror("Echec"); exit(0); } strcpy (tab_a_renvoyer, argv[1]); for(i=1;i<la_taille;i++){ printf("%s |",argv[i]); } return tab_a_renvoyer; } /* Main */ int main(int argc, char *argv[]){ char *tableau_final; int nombre_case = argc; /* Allocation */ printf("Affichage depuis la fonction Function:\n"); tableau_final = Function(nombre_case,argv); printf("\n"); printf("Affichage depuis la fonction main :\n"); printf("%s\n", tableau_final); printf("\n"); return 0; }

07/04/2012, 19h13
gerald3d
Prenons un exemple simple : un tableau de 10 char. C'est à dire un tableau dont les éléments sont des octets.

Si nous déclarons char tab[10] l'ordinateur va allouer en mémoire 10 octets qui seront les uns à côté des autres. Cette façon de faire est très importante à comprendre pour la suite.

En partant de ce constat en C il est possible d'accéder aux données de ce tableau de deux manières :
1. soit en utilisant l'écriture tab[x] avec 0<x<9,
2. soit en utilisant le pointeur du premier élément du tableau.
La première écriture est simple à comprendre, je ne m'étends pas plus. Regardons d'un peu plus prés la deuxième méthode.

Pour accéder au pointeur du tableau il suffit d'enlever les [] lors de l'écriture. Ainsi tab équivaut à tab[0]. À partir de là il faut bien comprendre que tab est le pointeur du premier élément du tableau. Pour accéder à l'élément n il suffit de faire tab+n.

Mais pourquoi parler de ca?

Dés qu'on comprend comment fonctionne en mémoire un tableau on peut l'adresser un peu comme on veut. Si on revient au prototype de la fonction main(); on voit char *argv[]. Si on traduit cette écriture en pointeur, comme je viens de l'expliquer, on peut écrire : char **argv. Et au miracle nous voila avec deux *! Je reçois bien l'adresse d'un tableau.

Si on pousse un peu plus loin, il est donc tout à fait possible de transmettre un tableau à une fonction (et c'est tant mieux parce que sinon on serait bien embêté ;)) mais on peut aussi "renvoyer" un tableau depuis une fonction. Je vois que les sourcils de fred1599 se froncent. Quoi, on m'aurait menti! :P

Si je déclare par exemple cette fonction :

Code:

void init_tab (char **tab);

Je peux dans cette fonction initialiser le tableau tab[] avec une simple boucle par exemple :
Code:

1 2 3 4 5 6 7 void init_tab (char **tab) { int i = 0; for (i = 0; i <10; i++) tab[i] = i; }
En retour de cette fonction mon tableau est initialisé. Bien sûr, je n'ai pas "renvoyer" au sens propre du terme un tableau. J'ai simplement eu accès à son adresse et j'ai fait le reste.

Pour finir, il est tout à fait possible de renvoyer un tableau au sens propre du terme cette fois en effectuant une allocation dans le tas. Mais c'est un autre sujet...
07/04/2012, 19h35
smitch

C'est une bonne chose de programmer avec des pointeur, mais j'ai jamais su m'en servir correctement :aie:

J'ai réussi à obtenir ce que je voulais grâce à vous tous

Merci :ccool:
07/04/2012, 19h43
smitch

fred, voila pour toi un exemple de tableau renvoyé par une fonction, avec une bonne explication de diogene : http://www.developpez.net/forums/d12...eau-dynamique/

Je vais devoir lire au moins 20x la réponse de gerald3d pour ne jamais l'oublier
merci à tous
07/04/2012, 23h54
fred1599
Bonsoir,

Citation:

Bien sûr, je n'ai pas "renvoyer" au sens propre du terme un tableau. J'ai simplement eu accès à son adresse et j'ai fait le reste

On est bien d'accord, on ne peut retourner un tableau, on ne m'avait donc pas menti. ;)

Par contre rien n'empêche de retourner une structure, ça c'est cool !

Citation:

Dés qu'on comprend comment fonctionne en mémoire un tableau on peut l'adresser un peu comme on veut. Si on revient au prototype de la fonction main(); on voit char *argv[]. Si on traduit cette écriture en pointeur, comme je viens de l'expliquer, on peut écrire : char **argv. Et au miracle nous voila avec deux *! Je reçois bien l'adresse d'un tableau.

Si tu regardes bien j'ai placé un argument de ce type dans mon code précédent, reste que je n'en vois pas l'intérêt, surtout dans ce type d'exercice.

Souvent il est dit qu'on peut toujours se débrouiller sans ** et n'utiliser que *. Je pense que c'est pas faux, ai-je tort?

D'ailleurs ton code exemple, je pourrais le représenter de cette manière
Code:

1 2 3 4 5 6 7 8 9 void init(char *tab) { int i = 0; while (tab[i] != '\0') { tab[i]= i; i++; } }
Je trouve, dis moi si je me trompe que de renvoyer une structure est un bon compromis...

Merci pour les explications, mais j'ai plus l'impression que tu confirmes ce qu'on m'avait déjà dis, que de me prouver le contraire, à moins que je n'ai pas tout pigé, dans ce cas "mea culpa" ;)
08/04/2012, 10h13
gerald3d

Le seul moyen pour renvoyer un tableau est de l'allouer dans le tas dans la dite fonction. Cette technique est intéressante, par exemple pour faire de la programmation orienté objet en C (il y a d'autres cas bien sûr).

Oui tu as raison pour la fonction init();. L'adressage de pointeur est surtout utilisé lorsque tu ne connais pas la longueur du tableau que tu veux récupérer à la sortie.

Je m'explique. Imagine une fonction de ce type :

Code:

int load (const char *filename, char **error);

Cette fonction renvoie 0 si tout c'est bien passé, 1 dans le cas contraire. Dans ce dernier cas error contient alors un texte d'explication sur l'erreur survenue.

Comme je ne connais pas à priori la longueur de error, je transmets à la fonction l'adresse du pointeur error. En interne le pointeur error est initialisé avec une allocation dans le tas. En retour je peux afficher l'erreur et ensuite faire un free(error); pour libérer le tout.

Pour finir renvoyer une structure revient à renvoyer un type particulier. Ce qui est en définitif la même chose ;).

Une dernière remarque : l'idée générale est d'éviter le plus possible de faire des allocations dynamiques. Simplement pour éviter l'oubli de la libération derrière. Utiliser le double adressage est souvent lié à une allocation dynamique (pas systématique). CFQD.
08/04/2012, 10h43
fred1599

Citation:

Comme je ne connais pas à priori la longueur de error, je transmets à la fonction l'adresse du pointeur error

Je débute depuis 2 semaines, donc dis moi, est-ce une règle?

Lorsque je ne connais pas la longueur d'un texte, je ne vois toujours pas l'intérêt du double pointeur, ou pourrais-tu continuer ta fonction load?

Citation:

En interne le pointeur error est initialisé avec une allocation dans le tas

Allocation dans le tas? un malloc, tu veux dire?

Pourquoi pas une utilisation de ce type?

Code:

char ma_chaine[] = "Vous avez fait une erreur"

et dans ta fonction load

Code:

int load (const char *filename, char *error);

?

Citation:

Une dernière remarque : l'idée générale est d'éviter le plus possible de faire des allocations dynamiques. Simplement pour éviter l'oubli de la libération derrière. Utiliser le double adressage est souvent lié à une allocation dynamique (pas systématique). CFQD.

Donc si je comprend bien, tu es d'accord sur le fait qu'il n'est pas utile d'utiliser le double adressage, ou dans des cas assez restreints?

Sinon valgrind permet d'éviter ces oublis, non? ;)

On va écrire un code un peu plus complet.

reprenons la fonction int load (const char *filename, char *error); à ta façon. Lorsque tu appelles cette fonction le pointeur error que tu transmets, tu l'initialises comment?

Par exemple si je fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include <stdio.h> #include <stdlib.h> int load (const char *filename, char *error) { printf ("adresse de error dans load() : %u\n", error); return 0; } int main (int argc, char *argv[]) { char *error = 0; printf ("adresse de error dans le main() : %u\n", error); if (load ("./essai.txt", error)==1) { fprintf (stderr, "%s\n", error); } return 0; }
Le résultat à l'exécution donne :
Code:

1 2 adresse de error dans le main() : 0 adresse de error dans load() : 0
Pour l'instant tout va bien. On récupère bien le même pointeur dans la fonction load();.

Maintenant reprenons notre exemple précédent mais cette fois en initialisant la variable error à l'interieur de load(); :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include <stdio.h> #include <stdlib.h> int load (const char *filename, char *error) { error = "Erreur de lecture"; printf ("adresse de error dans load() : %u\n", error); return 0; } int main (int argc, char *argv[]) { char *error = 0; printf ("adresse de error dans le main() : %u\n", error); if (load ("./essai.txt", error)==1) { fprintf (stderr, "%s\n", error); } return 0; }
Le résultat à l'exécution donne :
Code:

1 2 3 adresse de error dans le main() : 0 adresse de error dans load() : 4197100
Les adresses ne sont plus les mêmes. Le coupable est l'affectation de la chaîne de caractères. Une allocation mémoire implicite a été faite par le compilateur et l'adresse du premier octet de la chaîne a été affectée à error. En retour de la fonction tu n'as aucun moyen de récupérer cette adresse.

Comment faire ?

La solution est donc le double adressage. On transmet à la fonction load(); l'adresse du pointeur. Cette adresse ne change pas. Par contre on va pouvoir lui affecter comme valeur à l'intérieur l'adresse que nous renvoie l'affectation de la chaîne. En retour dans le main(); on retrouvera cette nouvelle adresse. CQFD.

Voila l'exemple complet. La fonction load(); renvoie 1 pour montrer la gestion de la variable error :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 #include <stdio.h> #include <stdlib.h> int load (const char *filename, char **error) { *error = "Erreur de lecture"; printf ("adresse de error dans load() : %u\n", *error); return 1; } int main (int argc, char *argv[]) { char *error = 0; printf ("adresse de error dans le main() : %u\n", error); if (load ("./essai.txt", &error)==1) { printf ("adresse de error en retour de load() dans le main() : %u\n", error); fprintf (stderr, "%s\n", error); } return 0; }
En console on obtient :
Code:

1 2 3 4 5 Erreur de lecture adresse de error dans le main() : 0 adresse de error dans load() : 4197132 adresse de error en retour de load() dans le main() : 4197132
on voit bien ici que l'on récupère l'adresse nouvellement affectée en retour de la fonction load();.

Je pense qu'avec cet exemple on comprend mieux pourquoi le fait de transmettre simplement le pointeur de la variable ne suffit pas. Même si elle est allouée dans le tas (avec malloc) on ne la récupérera pas à la sortie. Il nous faut transmettre l'adresse du pointeur pour faire cette opération.

Merci pour ta réponse, ça devient un peu plus clair ;)

Ok c'est un peu complexe pour moi, dis moi si j'ai compris.

En gros il est utile d'avoir un double adressage quand on veut récupérer l'adresse d'une variable se trouvant dans une fonction autre que main() ?

Ainsi on peut récupérer (presque comme une variable globale) la valeur de error se trouvant dans la fonction load() pour l'utiliser dans notre main?

C'est un peu le flou artistique, peut-on à l'aide du double adressage, faire une fonction echange?

J'ai testé en essayant de rester cohérent dans ma syntaxe.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void echange(int **a, int **b) { int *temp = *a; *a = *b; *b = temp; } int main(void) { int *c, *d; int e = 12; int f = 25; c = &e; d = &f; echange(&c, &d); printf("e vaut %d et f vaut %d", *c, *d); return 0; }
J'ai bien pigé la syntaxe je pense, mais il me semble que l'on ne peut pas modifier une adresse ?

Tu vois encore beaucoup de questions :)

Voir 40 message(s) de cette discussion en une page