Je pensais connaitre les bases du C, et pourtant ce langage étonnant permet d´apprendre tout le temps de nouvelle chose (ça c´était mon captatio benevolentiae comme dirait ma prof de français) :

je suis tombé par hasard tout à l´heure sur la syntaxe :
main(int argc, char **argv, char **env)
qui permet de récupérer les variables d´environnements lors du démarage d´un programme.

Hors une recherche là dessus sur google ne me donne quasiment pas de réponse de fond.

Donc je me demandais s´il s´agit d´un truc standard (j´ai l´impression que ça doit marcher sur tout les système) car la MSDN classe celà dans "Microsoft Specific" bien qu´il précise que c´est utilisé couremment.

je suis presque sur de l´avoir deja vu sur linux...
la réponse en image

mandan:~/test> cat test.c

1. include <stdio.h>

int main (int argc, char* argv[], char** env)
{
printf ("coin\n");
return 0;
}
mandan:~/test> make test
cc test.c -o test
mandan:~/test> ./test
coin
mandan:~/test>

Hum ! je ne connaissais pas non plus !
Mais une chose m´étonne, il n´y a pas de "argc" si j´ose dire, pour le env : autrement dit, quelle est la taille de ce tableau de char* qu´est env ?

peut etre que le dernier élément est a un terminator, un \0 et que c´est ainsi on détecte la taille !

Faudra que j´essaie, mais la, j´ai la flemme, lol !

finalement, j´ai essayé en passant le débuggueur sur le programme simpliste suivant :

1. include <iostream>

using namespace std;

int main(int argc,char** argv,char** env)
{
char* t = env[0];
return 0;
}

ça marche tres tres bien
Et le derniere élément, comme c´est un tableau de char*, est tout simplement le pointeur NULL

Tres fort cette astuce !!

Oué ça marche "partout" apparemment.

Je trouve quand même l´efficacité douteuse : on obtient bien un tableau de chaînes qu´il faut parcourir pour trouver la variable qui nous intéresse, et séparer la valeur de son nom et du signe égal, non ?

oui c´est l´idée.
C´est plus simple de faire un appel system mais je conjecture qu´il fait exactement la meme chose

Bigloo > Ah oui, une fois la chaine aquise, il faut travailler dessus pour la décomposer
Mais bon, une fois qu´on a le flux d´entrée, le décomposer est simplement appliquer quelques petits algorithmes pas tres complexes

A ce que je lis dans la MSDN non car le tableau en question est "statique", c´est à dire que si les variables d´environnements sont modifié après le lancement du programme, le tableau ne sera pas modifié. Alors que les appel système (genre _getenv je crois) donneront les nouvelles variables. Donc ce tableau est créé spécifiquement pour l´application (ça serait une copie de la variable globale _environ qui existe de toute manière, mais alors, je ne vois pas trop son interet).

Pour l´exploiter, je suppose qu´une "map" en C++ est idéal, non ?

Tout a fait une map avec comme clé le nom de la variable et comme élément sa valeur est idéal

par contre : piege !
Une map doit avoir une clé triable.
Donc si tu gardes un char* comme clé, surtout redéfinir un foncteur de comparaison, car a défaut, il va comparer les valeurs des pointeurs, et il ne retrouvera pas les éléments
un peu comme quand tu fais l´erreur classique :

char* p = "plouf";
char* q = "plouf";
if (p==q)
...

Mais ça peut marcher selon les cas : VC++ a une optimisation pour que lorsque la même chaine apparait plusieurs fois, elle ne se trouve qu´une fois dans l´exécutable et donc qu´une fois dans le tas. Ce qui fait que p et q pointeraient vers la même chose. Bien sur la plupart du temps, on veut l´éviter car ça veut dire que si on modifie la chaine pointé par p, celle pointé par q est aussi modifié.

C´était HS, mais ça peut toujours servir.

Au passage, le C/C++ ne definit pas le prototype de main, mais dit seulement que l´entry point du programme doit s´appeler comme cela:
"The function called at program startup is named main. The implementation declares no prototype for this function."

C´est donc totalement compiler dependent.

Ensuite pour revenir aux map, utilisez des string a la place de char* ;)