Discussion :

[olivier857]

Bonjour,

Alors je m'explique, j'ai récupérer un programme qui permet de faire du POST en passant en ligne de commande l'url et les paramètre :
exemple : ./Appli URL param1=1 param2=13 ...

Le code code main commence donc évidement comme suit :

Code :

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

1
2
3
4
5
 
int main(int argc, char** argv)
{
...
}

Voici ce que je souhaite faire :

En fait le but et de faire appel à la fonction qui fait le post, sans la modifier (je veut la laiser tel que je l'ai trouvé, mis à part le fait de changer son nom en "post" à la place de "main"). Le but et de lui passer les paramètres en dure depuis mon programme principale au lieu de lancer manuellement la fonction en ligne de commande et tapper les paramètres.

Exemple :

Code :

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

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
int main ()
{
  int argc;
  char **argv;
  char *url;
  char *param1;
  char *param2;
 
 
  //Ici le code de mon programme principale
 
 
  // Préparation des paramètres à envoyer à la fonction post
  param1="Num=22\0";
  param2="Dossier=22025\0";
 
  argv[0]="Appli\0"; 
  argv[1]=url;
  argv[2]=param1;
  argv[3]=param2;
 
  // appel d ela fonction post
  post(argc, argv):
 
  return 0;
}
 
 
 
 
//fonction qui fait le post (celle que j'ai récupéré)
int post(int argc, char** argv)
{
...
}

Hors ca ne marche pas, les paramètres sont bien transmis de mon main à la fonction post, mais la fonction plante par la suite. (erreur de segmentation)


Je suppose que je ne passe pas les parmètres comme il le faut. pourtant quand je les print dans la fonction post, ils ont l'air d'être bienb passé. Mais bon je sais qu'il est tjs délicat de toucher aux tableaux de pointer. Ou est l'erreur?

Un petit coup de main ne ma ferait pas de mal.
Merci d'avance !

[DaZumba]

Le probleme est que si lors de l'appel de ton programme, argc vaut 1 (i.e. pas d'arguments), alors le tableau de pointeurs sur char argv[] a la dimension 2 (avec argv[1] = NULL). Du coup, inutile d'esperer acceder a argv[3] et suivants...
Tu vas devoir allouer la memoire de argv[].

[olivier857]

Le probleme est que si lors de l'appel de ton programme, argc vaut 1 (i.e. pas d'arguments), alors le tableau de pointeurs sur char argv[] a la dimension 2 (avec argv[1] = NULL). Du coup, inutile d'esperer acceder a argv[3] et suivants...
Tu vas devoir allouer la memoire de argv[].

Merde désolé j'ai oublier ca dans mon exemple, mais je l'ai bien fait en fait, le pb ne vient pas de là.
Mais merci tout de même.

Modification :

Code :

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

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
int main ()
{
  int argc;
  char **argv;
  char *url;
  char *param1;
  char *param2;
  

  //Ici le code de mon programme principale


  // Préparation des paramètres à envoyer à la fonction post
  param1="Num=22\0";
  param2="Dossier=22025\0";
  argc=4;
  argv[0]="Appli\0"; 
  argv[1]=url;
  argv[2]=param1;
  argv[3]=param2;

  // appel d ela fonction post
  post(argc, argv):

  return 0;
}




//fonction qui fait le post (celle que j'ai récupéré)
int post(int argc, char** argv)
{
...
}

Voilà c'est mieux comme çà!

[DaZumba]

argc=4

Ben c'est pas comme ca que argv[] va magiquement devenir un tableau de quatre elements. malloc() est necessaire...

[olivier857]

Ben c'est pas comme ca que argv[] va magiquement devenir un tableau de quatre elements. malloc() est necessaire...

Ok d'accord.
Mais j'arrive pas a utiliser malloc.

Serait t'il possible de m'écrire le code avec malloc(), pour que je comprenne comment ca marche. Désolé je suis débutant. J'essaye d'utiliser malloc mais je n'y arrive pas.

Merci de ton aide !

[DaZumba]

Serait t'il possible de m'écrire le code avec malloc(), pour que je comprenne comment ca marche. Désolé je suis débutant. J'essaye d'utiliser malloc mais je n'y arrive pas.

J'ai un peu reflechi, et meme si la norme assure que argc et argv sont accessibles en ecriture, je ne sais pas si argv[] est alloue ou non par le symbole _start (celui qui appelle main() au lancement du programme). Donc je ne sais pas si faire un malloc() sur argv va entrainer une fuite memoire ou non...
Dans le doute, je te conseille de faire:

Code :

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

1
2
3
 
int my_argc;
char *my_argv[10];

puis envoyer my_argc et my_argv a post() (apres avoir donne une valeur, evidemment).

[DaZumba]

Je viens de regarder le code que tu postes au premier message (il est peut etre temps, tu vas me dire), et je m'apercois que ton argc et argv sont des variables locales a main(), pas ses arguments. Tant mieux - c'est equivalent a mon message precedent.
Par contre, ton argv n'a pas de memoire allouee. Il faut ecrire:

Code :

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

1
2
3
4
5
6
7
8
 
int main(void)
{
   int argc;
   char *argv[10];
 
   ...
}

La, tu peux assigner des valeurs a argv[0], etc...

[Foobar1329]

Hello,

Merde désolé j'ai oublier ca dans mon exemple, mais je l'ai bien fait en fait, le pb ne vient pas de là.
Mais merci tout de même.

Modification :

Code :

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

int main ()

Les 2 protos valides dans un programme C standard sont int main(void) et int main(int argc, char **argv). Si tu veux récupérer des paramètres de la ligne de commande, tu es obligé de prendre la seconde, c'est le point d'entree de ton programme.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  int argc;
  char **argv;
  char *url;
  char *param1;
  char *param2;
  

  //Ici le code de mon programme principale


  // Préparation des paramètres à envoyer à la fonction post
  param1="Num=22\0";
  param2="Dossier=22025\0";
  argc=4;

Ici, il faut bien de l'espace pour argv, pour les pointeurs.

Code :

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

1
2
3
4
5
6
 
argv = malloc((argc+1)*sizeof*argv);
if (!argv) {
  fprintf(stderr,"Erreur allocation\n");
  exit(EXIT_FAILURE);
}

Code :

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

1
2
3
4
5
6
7
8
 
  argv[0]="Appli\0"; 
  argv[1]=url;
  argv[2]=param1;
  argv[3]=param2;
 
  // appel d ela fonction post
  post(argc, argv):

Ici, il faut liberer la memoire. Ne pas oublier d'include <stdlib.h>.

Code :

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

1
2
3
 
 
free(argv);

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  return 0;
}
 
 
 
 
 
//fonction qui fait le post (celle que j'ai récupéré)
int post(int argc, char** argv)
{
...
}

Voilà c'est mieux comme çà!

A+

[gege2061]

Serait t'il possible de m'écrire le code avec malloc(), pour que je comprenne comment ca marche. Désolé je suis débutant. J'essaye d'utiliser malloc mais je n'y arrive pas.

Description des mécanismes d'allocation dynamique de mémoire en langage C

J'ai un peu reflechi, et meme si la norme assure que argc et argv sont accessibles en ecriture, je ne sais pas si argv[] est alloue ou non par le symbole _start (celui qui appelle main() au lancement du programme). Donc je ne sais pas si faire un malloc() sur argv va entrainer une fuite memoire ou non...
Dans le doute, je te conseille de faire:

Code DaZumba :

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

int my_argc; char *my_argv[10];

puis envoyer my_argc et my_argv a post() (apres avoir donne une valeur, evidemment).

Si le prototype de main est :

Code :

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

int main (void)

ou

Code :

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

int main (int nb_arg, char **arg_value)

rien ne t'empêche d'utiliser argc et argv comme nom de variable.

Ne pas oublier que argv est un tableau de argc+1 éléments avec le dernier élément à NULL.

Si tu veux te passer le l'allocation dynamique :

Code :

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

1
2
3
4
5
6
7
8
9
#include <stdlib.h>
 
int main (void)
{
  char argv[4][5] = {"arg1", "arg2", "arg3", NULL};
  int argc = sizeof (argv) / sizeof (*argv) - 1;
[...]
  return 0;
}

[olivier857]

Ok un grand merci à tous le monde.

Ca marche avec çà :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
    argv[0] =(char *) malloc( strlen("chaine0" ) + 1 );
    strcpy(argv[0],"chaine0" );
    argv[1] =(char *) malloc( strlen("chaine1" ) + 1 );
    strcpy(argv[1],"chaine1" );
    argv[2] =(char *) malloc( strlen("chaine2" ) + 1 );
    strcpy(argv[2],"chaine2" );
    argv[3] =(char *) malloc( strlen("chaine3" ) + 1 );
    strcpy(argv[3],"chaine3" );
 
    post(argc,argv);

[Médinoc]

Note: sur un système compatible POSIX (cad, tous les unixoïdes) et sous Windows, tu peux utiliser la fonction strdup() (_strdup() sous Windows) qui cumule le malloc() et le strcpy()...

[Foobar1329]

Ok un grand merci à tous le monde.

Ca marche avec çà :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
    argv[0] =(char *) malloc( strlen("chaine0" ) + 1 );
    strcpy(argv[0],"chaine0" );
    argv[1] =(char *) malloc( strlen("chaine1" ) + 1 );
    strcpy(argv[1],"chaine1" );
    argv[2] =(char *) malloc( strlen("chaine2" ) + 1 );
    strcpy(argv[2],"chaine2" );
    argv[3] =(char *) malloc( strlen("chaine3" ) + 1 );
    strcpy(argv[3],"chaine3" );
 
    post(argc,argv);

N'empêche, tu te compliques la vie avec ces allocations dont tu ne contrôles pas en plus les éventuels échecs (et pas besoin de caster malloc() ). Il y a effectivement un intérêt à faire de l'allocation dynamique dans ton cas, qui est de pouvoir fournir des données modifiables en argv à la fonction post() (comme les vrais argv, cf norme), mais modifier argc et argv dans un programme, ce n'est pas courant.

Code :

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

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
 
#include <stdio.h>
#include <stdlib.h>
 
int post(int argc, char ** argv)
{
    int i;
    for(i=0; i<argc; ++i) puts(argv[i]);
    return 0;
}
 
int main(void)
{
    int rc = 0, argc = 5;
    char ** argv = NULL;
 
    argv = malloc((argc+1)*sizeof*argv);
    if (argv) {
        argv[0] = "exe";
        argv[1] = "param1";
        argv[2] = "param2";
        argv[3] = "param3";
        argv[4] = "param4";
 
        post(argc, argv);
 
        free(argv);
    }
    else {
        rc = EXIT_FAILURE;
    }
 
    return rc;
}

A+

[Médinoc]

Puisque c'est non-modifiable, ajoutons-y un peu de rigueur:

Code :

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

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>
 
int post(int argc, char const * const * argv)
{
    int i;
    for(i=0; i<argc; ++i) puts(argv[i]);
    return 0;
}
 
int main(void)
{
    int rc = 0, argc = 5;
    char const ** argv = NULL;
 
    argv = malloc((argc+1)*sizeof*argv);
    if (argv) {
        argv[0] = "exe";
        argv[1] = "param1";
        argv[2] = "param2";
        argv[3] = "param3";
        argv[4] = "param4";
 
        post(argc, argv);
 
        free(argv);
    }
    else {
        rc = EXIT_FAILURE;
    }
 
    return rc;
}

Je n'ai pas de quoi tester sous la main, mais ça devrait compiler sans warning, même avec le paramètre -Wwrite-strings de GCC.
Edit: Testé, ça compile.

[gege2061]

Note: sur un système compatible POSIX (cad, tous les unixoïdes) et sous Windows, tu peux utiliser la fonction strdup() (_strdup() sous Windows) qui cumule le malloc() et le strcpy()...

http://www.developpez.net/forums/sho...7&postcount=45

[Médinoc]

Ah, ce n'est pas du POSIX ?

Je me suis fait avoir par Microsoft, qui dit que le nom POSIX de la fonction est deprecated...

[Emmanuel Delahaye]

Code :

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

1
2
3
4
int main ()
{
  char **argv;
  argv[0]="Appli\0";

argv est un pointeur non initialisé. Le comportement est indéfini.

Tu veux sans doute un truc comme ça :

Code :

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

1
2
3
4
5
6
7
 
  /* Definition d'un tableau de 10 pointeurs sur char */
  char *argv[10];
 
  argv[0]="Appli"; 
  <...>
  argv[9]="...";

[Emmanuel Delahaye]

Ca marche avec çà :

Code :

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

1
2
3
4
 
    argv[0] =(char *) malloc( strlen("chaine0" ) + 1 );
    strcpy(argv[0],"chaine0" );
<...>

Ca 'marche' par hasard... Tu n'as toujours pas alloué d'espace pour argv... Et ça sert à quoi de faire des copies des chaines ? Un tableau de char * avec les adresses des chaines suffit.

[Emmanuel Delahaye]

http://www.developpez.net/forums/sho...7&postcount=45

Mais si strdup() est bien POSIX.1 :

The Open Group Base Specifications Issue 6
IEEE Std 1003.1, 2004 Edition
Copyright © 2001-2004 The IEEE and The Open Group, All Rights reserved.
NAME

strdup - duplicate a string

SYNOPSIS

[XSI] [Option Start] #include <string.h>

char *strdup(const char *s1); [Option End]

DESCRIPTION

The strdup() function shall return a pointer to a new string, which is a duplicate of the string pointed to by s1. The returned pointer can be passed to free(). A null pointer is returned if the new string cannot be created.

RETURN VALUE

The strdup() function shall return a pointer to a new string on success. Otherwise, it shall return a null pointer and set errno to indicate the error.

ERRORS

The strdup() function may fail if:

[ENOMEM]
Storage space available is insufficient.

The following sections are informative.
EXAMPLES

None.

APPLICATION USAGE

None.

RATIONALE

None.

FUTURE DIRECTIONS

None.

SEE ALSO

free(), malloc(), the Base Definitions volume of IEEE Std 1003.1-2001, <string.h>

CHANGE HISTORY

First released in Issue 4, Version 2.

Issue 5

Moved from X/OPEN UNIX extension to BASE.

End of informative text.

[olivier857]

Bon ok très bien j'ai compris pour le "char *argv[10]"
Mon "char **argv" marché effectivement par hazard en fait c'était grace a un char *toto[5] déclaré juste après que ca passé (bizarre). Si je l'enlève ca plante.

Mais effectivement "char *argv[10]" et la bonne solution je comprend mieux pourquoi maintenant. Il faut initialiser le pointeur, c'est finalement logique mais j'ai encore du mal avec çà. Ca vient doucement. Dsl, je viens du monde VB alors rien à voir .

Voici mon code actuel :

Code :

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

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
#include <iostream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int main(void)
{
  int nb_param;
  char *param[10];
  const char *var0, *var1, *var2, *var3, *var4, *var5;
 
 
  var0="Appli\0";
  var1="http://.......\0";
  var2="Num=295\0";
  var3="Num2=282\0";
  var4="Num3=51\0";
  var5="MonNum=1\0";
 
  nb_param=4; 
  param[0]=(char *)malloc(strlen(var0)+1);
  strcpy(param[0],var0);
  param[1]=(char *)malloc(strlen(var1)+1);
  strcpy(param[1],var1);
  param[2]=(char *)malloc(strlen(var2)+1);
  strcpy(param[2],var2);
  param[3]=(char *)malloc(strlen(var3)+1);
  strcpy(param[3],var3);
  param[4]==NULL; 
 
  post(nb_param, param);
 
  free(param);
 
  return 0;
}
 
int post (int argc, char **argv)
{
  ...
}

Il me faut encore ajouter le strdup(), mais je cherche comment ca fonctionne.

[DaZumba]

J'espere que tu es au courant que tu fais du C++ et pas du C. Et en C++, on prefere utiliser les operateurs new et delete que les fonctions malloc() et free(), respectivement. Mais c'est un autre forum...