avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
On Sat, 21 Apr 2007 21:49:19 +0200, matt wrote:avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
OK, recommence avec les tests et après on verra.
On Sat, 21 Apr 2007 21:49:19 +0200, matt wrote:
avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
OK, recommence avec les tests et après on verra.
On Sat, 21 Apr 2007 21:49:19 +0200, matt wrote:avec bien sur les tests qui vont bien pour le retour de la fonction getenv.
OK, recommence avec les tests et après on verra.
Bonjour,
dans le premier cas :
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
pour le deuxieme cas :
int recup()
{
char *value = NULL;
char rep_entree[FILENAME_MAX] = {0};
char rep_sortie[FILENAME_MAX] = {0};
value = getenv("REP_ENTREE");
if(value == NULL)
return 1;
strcpy(rep_entree, value);
value = getenv("REP_SORTIE");
if(value == NULL)
return 1;
strcpy(rep_sortie, value);
return 0;
}
Voici les tests que j'effectue.
dans les deux cas, ca fonctionne.
Mais quelle est la bonne methode ?
Bonjour,
dans le premier cas :
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
pour le deuxieme cas :
int recup()
{
char *value = NULL;
char rep_entree[FILENAME_MAX] = {0};
char rep_sortie[FILENAME_MAX] = {0};
value = getenv("REP_ENTREE");
if(value == NULL)
return 1;
strcpy(rep_entree, value);
value = getenv("REP_SORTIE");
if(value == NULL)
return 1;
strcpy(rep_sortie, value);
return 0;
}
Voici les tests que j'effectue.
dans les deux cas, ca fonctionne.
Mais quelle est la bonne methode ?
Bonjour,
dans le premier cas :
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
pour le deuxieme cas :
int recup()
{
char *value = NULL;
char rep_entree[FILENAME_MAX] = {0};
char rep_sortie[FILENAME_MAX] = {0};
value = getenv("REP_ENTREE");
if(value == NULL)
return 1;
strcpy(rep_entree, value);
value = getenv("REP_SORTIE");
if(value == NULL)
return 1;
strcpy(rep_sortie, value);
return 0;
}
Voici les tests que j'effectue.
dans les deux cas, ca fonctionne.
Mais quelle est la bonne methode ?
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Si tu vas par la, tu as oublie de l'allumer parce qu'il ne fait pas
de declaration de fonctions K&R ;-)
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Si tu vas par la, tu as oublie de l'allumer parce qu'il ne fait pas
de declaration de fonctions K&R ;-)
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Si tu vas par la, tu as oublie de l'allumer parce qu'il ne fait pas
de declaration de fonctions K&R ;-)
On Sun, 22 Apr 2007 08:14:57 +0000, Marc Espie wrote:Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Désolé, je ne savais pas. Enfin qu'on est en 2007 si...
Je me demande d'ailleurs si c'est souvent utile.
On Sun, 22 Apr 2007 08:14:57 +0000, Marc Espie wrote:
Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Désolé, je ne savais pas. Enfin qu'on est en 2007 si...
Je me demande d'ailleurs si c'est souvent utile.
On Sun, 22 Apr 2007 08:14:57 +0000, Marc Espie wrote:Faudra te mettre a jour, hein. C'est parfaitement standard en C99, et on
est quand meme en 2007, maintenant.
Désolé, je ne savais pas. Enfin qu'on est en 2007 si...
Je me demande d'ailleurs si c'est souvent utile.
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
int recup()
{
char *rep_entree = getenv("REP_ENTREE");
if(rep_entree == NULL)
return 1;
char *rep_sortie = getenv("REP_SORTIE");
if(rep_sortie == NULL)
return 1;
return 0;
}
La première, bien que tu mélanges les déclarations et les autres
instructions, ce qui n'est pas standard et ne marche qu'en raison de la
permissivité du compilateur, tu devrais mettre plus d'options de warning.
Je me demande d'ailleurs si c'est souvent utile.
C'est juste du sucre syntaxique en plus. Ca permet d'introduire des
variables juste au bon moment sans avoir besoin de rajouter des blocs
en rab.
Pour ma part, le principal avantage que j'y vois, c'est que ca permet
simplement de coupler systematiquement l'initialisation a la declaration
de la variable. Ca evite d'etre le cul entre deux chaises: - entre les
variables pas initialisees au point de declaration, qu'on risque
d'oublier plus tard.
- et celles qu'on initialise a n'importe quoi, juste parce que, alors
qu'on ne sait pas encore ce qu'il faut mettre dedans.
Tu me diras que le compilateur donne des avertissements pour les
variables non initialisees, ce qui est vrai. Encore faut-il que le
programmeur les lise.
Et ca necessite de regarder des choses en plus
quand on fait de l'audit.
Ca depend aussi du style de commentaires. Si on programme ses boucles
dans l'optique de les prouver (invariant de boucle et condition de
terminaison), la declaration de variable se place `naturellement' en
entree de boucle, juste a cote de l'invariant...
A cote de ca, on perd le cote bien net et psycho-rigide de `j'ai un gros
bloc de declarations de variables en tete de ma fonction'. Bof. Ca ne me
gene pas trop.
Mais je bosse beaucoup avec des langages assez
dynamiques, et retrouver le type d'une variable simplement n'est pas
quelque chose de crucial en ce qui me concerne... meme en C. C'est la
semantique de la variable qui m'interesse le plus souvent. Son type
devrait (doit ?) aller de soit.
J'ai peut-etre passe trop de temps avec
le RAII (Resource Acquisition Is Initialization) du C++. Mais bon, pour
du code critique, faut bien avouer qu'avoir un chemin d'initialisation
des ressources/recuperation d'erreur le plus simple et le plus clair
posssible peut servir.
Je me demande d'ailleurs si c'est souvent utile.
C'est juste du sucre syntaxique en plus. Ca permet d'introduire des
variables juste au bon moment sans avoir besoin de rajouter des blocs
en rab.
Pour ma part, le principal avantage que j'y vois, c'est que ca permet
simplement de coupler systematiquement l'initialisation a la declaration
de la variable. Ca evite d'etre le cul entre deux chaises: - entre les
variables pas initialisees au point de declaration, qu'on risque
d'oublier plus tard.
- et celles qu'on initialise a n'importe quoi, juste parce que, alors
qu'on ne sait pas encore ce qu'il faut mettre dedans.
Tu me diras que le compilateur donne des avertissements pour les
variables non initialisees, ce qui est vrai. Encore faut-il que le
programmeur les lise.
Et ca necessite de regarder des choses en plus
quand on fait de l'audit.
Ca depend aussi du style de commentaires. Si on programme ses boucles
dans l'optique de les prouver (invariant de boucle et condition de
terminaison), la declaration de variable se place `naturellement' en
entree de boucle, juste a cote de l'invariant...
A cote de ca, on perd le cote bien net et psycho-rigide de `j'ai un gros
bloc de declarations de variables en tete de ma fonction'. Bof. Ca ne me
gene pas trop.
Mais je bosse beaucoup avec des langages assez
dynamiques, et retrouver le type d'une variable simplement n'est pas
quelque chose de crucial en ce qui me concerne... meme en C. C'est la
semantique de la variable qui m'interesse le plus souvent. Son type
devrait (doit ?) aller de soit.
J'ai peut-etre passe trop de temps avec
le RAII (Resource Acquisition Is Initialization) du C++. Mais bon, pour
du code critique, faut bien avouer qu'avoir un chemin d'initialisation
des ressources/recuperation d'erreur le plus simple et le plus clair
posssible peut servir.
Je me demande d'ailleurs si c'est souvent utile.
C'est juste du sucre syntaxique en plus. Ca permet d'introduire des
variables juste au bon moment sans avoir besoin de rajouter des blocs
en rab.
Pour ma part, le principal avantage que j'y vois, c'est que ca permet
simplement de coupler systematiquement l'initialisation a la declaration
de la variable. Ca evite d'etre le cul entre deux chaises: - entre les
variables pas initialisees au point de declaration, qu'on risque
d'oublier plus tard.
- et celles qu'on initialise a n'importe quoi, juste parce que, alors
qu'on ne sait pas encore ce qu'il faut mettre dedans.
Tu me diras que le compilateur donne des avertissements pour les
variables non initialisees, ce qui est vrai. Encore faut-il que le
programmeur les lise.
Et ca necessite de regarder des choses en plus
quand on fait de l'audit.
Ca depend aussi du style de commentaires. Si on programme ses boucles
dans l'optique de les prouver (invariant de boucle et condition de
terminaison), la declaration de variable se place `naturellement' en
entree de boucle, juste a cote de l'invariant...
A cote de ca, on perd le cote bien net et psycho-rigide de `j'ai un gros
bloc de declarations de variables en tete de ma fonction'. Bof. Ca ne me
gene pas trop.
Mais je bosse beaucoup avec des langages assez
dynamiques, et retrouver le type d'une variable simplement n'est pas
quelque chose de crucial en ce qui me concerne... meme en C. C'est la
semantique de la variable qui m'interesse le plus souvent. Son type
devrait (doit ?) aller de soit.
J'ai peut-etre passe trop de temps avec
le RAII (Resource Acquisition Is Initialization) du C++. Mais bon, pour
du code critique, faut bien avouer qu'avoir un chemin d'initialisation
des ressources/recuperation d'erreur le plus simple et le plus clair
posssible peut servir.