C mettre **arg dans un string

Bonjour, question un peu noob j’ne conviens mais je bloque, comment mettre une variable ma variable char **arg dans un string ?

1
2
3
4
5

const char testvar;

int main(char **arg) {
    const char testvar = arg;
}

je voudrais récupérer le contenue de arg et le mettre dans ma variable testvar

Pour autant que je sache, le prototype attendu de main est le suivant :

1
2
3

int main (int argc, char *argv[]) {

}

argv, dans ce cas précis, est un tableau de pointeurs vers des chaînes de caractères ; argc est le nombre d’éléments dans ce tableau.

Tu dois donc indexer argv pour accéder à un élément en particulier (l’élément 0 étant le nom de l’exécutable). Ainsi, le programme suivant :

1
2
3
4
5
6
7
8
9

int main (int argc, char *argv[]) {
  int i = 0;

  for (; i < argc; ++i) {
    printf ("[%d] %s\n", i, argv[i]);
  }

  return 0;
}

va imprimer dans la sortie standard chaque argument passé à ton programme :

1
2
3
4

$ ./a.out bonjour "tout le monde"                                                                                                                                                                                                /home/lethom
[0] ./a.out
[1] bonjour
[2] tout le monde

oui mais pas dans mon cas… (j’utilise une api proprio)

ma fonction main est bien de ce type

1

int main(char **arg) {}

si cela perturbe, vous pouvez imaginer quelle s’appelle init.

1

int init(char **arg) {}

Bonjour,

Qu’est censée contenir la variable arg ? Pourquoi serait-elle convertible en char ?

Tu parles dans ton message d’un type string, mais testvar est de type char.

char **arg et char *arg[] ne sont pas strictement équivalent, mais globalement on peut les utiliser d’une manière similaire. À mon avis, pour se passer de argc, le dernier élément de argv doit être NULL.

On doit donc pouvoir s’en sortir comme ça :

1
2
3
4

int i = 0;
while (arg[i] != NULL) {
  printf ("[%d] %s\n", i, arg[i]);
}

C’est à tester, sans garanti étant donné le peu de contexte fourni.

char **av c’est une chaine de caractere elle contient par exemple : "init_dx=0" sans les ""

Si c’est un pointeur simple sur un char*, tu peux le déréférencer pour obtenir le char* pointé.

j’ai peut etre mal exprimé mon probleme : ce que je voudrais c’est faire un memcpy sur ma variable :

1
2
3
4
5
6
7

const char testvar;
int init (int length, char **arg)
{
    memcpy(testvar, arg, length);
}

`

Salut,

Les prototypes int main (int argc, char *argv[]) et int main (int argc, char **argv) sont identiques, dans les deux cas le deuxièmes paramètres est un pointeur de pointeur sur char.

Juste pour dire, du point de vue du typage ce n’est pas un tableau, c’est un pointeur de pointeur sur char, en témoigne la valeur produite par sizeof(argv) qui sera celle d’un pointeur.

Tu ne peux malheureusement pas le faire simplement. Il faut t’imaginer que, techniquement, la variable argv ressemble à ceci.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

+------+           +--------------+--------------+--------------+
| argv |---------->| addr_chaine1 | addr_chaine2 | addr_chaine3 |
+------+           +------+-------+------+-------+------+-------+
                          |              |              |
                          |              |              |
                          |              |              |
                          |              |              |
                          |              |              |
                          v              v              v
                   +------+-------+------+-------+------+-------+
                   |   chaine1    |   chaine2    |   chaine3    |
                   +------+-------+------+-------+------+-------+

Édit : si tu veux faire une copie, tu dois allouer un tableau de pointeurs du même nombres d’éléments qu’argv et ensuite copier chaque chaîne en allouant un espace de sa taille et en en copiant le contenu (avec strcpy() par exemple).

En vrai, de manière standard, en plus de int argc on a : argv[argc] == NULL.
(En réponse à ce qu’a dis lthms à propos de cette technique).

Tu peux imaginer une case en plus à au tableau de argv …