En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement. Quoi qu'il arrive on sort à la fin en libérant et en fermant tout ce qu'on a réservé et ouvert. Quand on fait comme ça on risque moins d'oublier quelque chose. On est prié de laisser cet endroit dans l'état où on l'a trouvé en entrant.
Seule exception que je m'autorise pour les return en cours de fonction sont les fonctions de description d'enum
const char * CADbTypeDescription(CADbType type) { switch (type) { case CADbType_Undefined: return "undefined database server type"; case CADbType_Oracle: return "Oracle"; case CADbType_MSSql: return "MSSql"; case CADbType_MySql: return "MySql"; } caerror(glcore, "Unknown database server type %d", type); return "unknown database server type"; }
Le 17/09/06 11:35, dans <1hlt3h3.u6mtczr02lt5N%, « Une bévue »
bon, je continue mes périgrinations C-esques.
je lis un tuto sur le net : <http://irc.essex.ac.uk/www.iota-six.co.uk/c/i4_fwrite_fscanf_fprintf.as p>
donc ça lit le fichier source "file.c" et ça écrit dans le fichier destination "file2.c".
Donc ce code fait n'importe quoi.
mais, au runtime j'ai droit à une "segmentation fault" dont je ne vois pas la raison...
C'est un jeu des 1000 erreurs ?
En regle générale les return dans la fonction c'est caca.
Fuites de mémoire assurées
les else sont faits pour ça. Sinon on utilise une variable booleene
qu'on teste pour savoir si on continue le traitement. Quoi qu'il arrive
on sort à la fin en libérant et en fermant tout ce qu'on a réservé et
ouvert. Quand on fait comme ça on risque moins d'oublier quelque chose.
On est prié de laisser cet endroit dans l'état où on l'a trouvé en entrant.
Seule exception que je m'autorise pour les return en cours de fonction
sont les fonctions de description d'enum
const char *
CADbTypeDescription(CADbType type)
{
switch (type) {
case CADbType_Undefined: return "undefined database server type";
case CADbType_Oracle: return "Oracle";
case CADbType_MSSql: return "MSSql";
case CADbType_MySql: return "MySql";
}
caerror(glcore, "Unknown database server type %d", type);
return "unknown database server type";
}
Le 17/09/06 11:35, dans
<1hlt3h3.u6mtczr02lt5N%pere.noel@laponie.com.invalid>, « Une bévue »
bon, je continue mes périgrinations C-esques.
je lis un tuto sur le net :
<http://irc.essex.ac.uk/www.iota-six.co.uk/c/i4_fwrite_fscanf_fprintf.as
p>
En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement. Quoi qu'il arrive on sort à la fin en libérant et en fermant tout ce qu'on a réservé et ouvert. Quand on fait comme ça on risque moins d'oublier quelque chose. On est prié de laisser cet endroit dans l'état où on l'a trouvé en entrant.
Seule exception que je m'autorise pour les return en cours de fonction sont les fonctions de description d'enum
const char * CADbTypeDescription(CADbType type) { switch (type) { case CADbType_Undefined: return "undefined database server type"; case CADbType_Oracle: return "Oracle"; case CADbType_MSSql: return "MSSql"; case CADbType_MySql: return "MySql"; } caerror(glcore, "Unknown database server type %d", type); return "unknown database server type"; }
Le 17/09/06 11:35, dans <1hlt3h3.u6mtczr02lt5N%, « Une bévue »
bon, je continue mes périgrinations C-esques.
je lis un tuto sur le net : <http://irc.essex.ac.uk/www.iota-six.co.uk/c/i4_fwrite_fscanf_fprintf.as p>
donc ça lit le fichier source "file.c" et ça écrit dans le fichier destination "file2.c".
Donc ce code fait n'importe quoi.
mais, au runtime j'ai droit à une "segmentation fault" dont je ne vois pas la raison...
C'est un jeu des 1000 erreurs ?
Harpo
fagotto wrote:
En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine réglementation qu'on s'impose.
int f(int x, int y) { if (x == 0) return 0; if (y == 0) return 0; if (y > 0) return x / y; if (x > 0) return y/x; return 1; }
Quelle que soit l'inutilité de cette fonction, elle me semble plus facilement compréhensible que :
int f(int x, int y) { int ret; if (x == 0) { ret = 0; } else { if (y == 0) { ret = 0; } else { if (y > 0) { ret = x / y; } else { if (x > 0) { ret = y / x; } else { ret = 1; } } } } return ret; }
Pour moi, yapafoto.
-- http://patrick.davalan.free.fr/
fagotto wrote:
En regle générale les return dans la fonction c'est caca.
Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene
qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine
réglementation qu'on s'impose.
int
f(int x, int y) {
if (x == 0) return 0;
if (y == 0) return 0;
if (y > 0) return x / y;
if (x > 0) return y/x;
return 1;
}
Quelle que soit l'inutilité de cette fonction, elle me semble plus
facilement compréhensible que :
int
f(int x, int y) {
int ret;
if (x == 0) {
ret = 0;
}
else {
if (y == 0) {
ret = 0;
}
else {
if (y > 0) {
ret = x / y;
}
else {
if (x > 0) {
ret = y / x;
}
else {
ret = 1;
}
}
}
}
return ret;
}
En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine réglementation qu'on s'impose.
int f(int x, int y) { if (x == 0) return 0; if (y == 0) return 0; if (y > 0) return x / y; if (x > 0) return y/x; return 1; }
Quelle que soit l'inutilité de cette fonction, elle me semble plus facilement compréhensible que :
int f(int x, int y) { int ret; if (x == 0) { ret = 0; } else { if (y == 0) { ret = 0; } else { if (y > 0) { ret = x / y; } else { if (x > 0) { ret = y / x; } else { ret = 1; } } } } return ret; }
Pour moi, yapafoto.
-- http://patrick.davalan.free.fr/
Pierre Maurette
fagotto wrote:
En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine réglementation qu'on s'impose.
int f(int x, int y) { if (x == 0) return 0; if (y == 0) return 0; if (y > 0) return x / y; if (x > 0) return y/x; return 1; }
Quelle que soit l'inutilité de cette fonction, elle me semble plus facilement compréhensible que :
int f(int x, int y) { int ret; if (x == 0) { ret = 0; } else { if (y == 0) { ret = 0; } else { if (y > 0) { ret = x / y; } else { if (x > 0) { ret = y / x; } else { ret = 1; } } } } return ret; }
Pour moi, yapafoto.
Je suis bien d'accord, dans certains cas loin d'être rares la structure d'une fonction induit tellement le return multiple que je ne vois pas pourquoi s'en passer. Dans certains cas on pourrait utiliser un switch ... case, mais il est très rudimentaire en C.
Sinon, j'aime bien, avec en prime uns seul return:
int f(int x, int y) { return (x == 0)||(y == 0) ? 0 : y > 0 ? x / y : x > 0 ? y / x : 1; }
Les plus timides peuvent parenthéser / indenter.
-- Pierre Maurette
fagotto wrote:
En regle générale les return dans la fonction c'est caca.
Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene
qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine
réglementation qu'on s'impose.
int
f(int x, int y) {
if (x == 0) return 0;
if (y == 0) return 0;
if (y > 0) return x / y;
if (x > 0) return y/x;
return 1;
}
Quelle que soit l'inutilité de cette fonction, elle me semble plus
facilement compréhensible que :
int
f(int x, int y) {
int ret;
if (x == 0) {
ret = 0;
}
else {
if (y == 0) {
ret = 0;
}
else {
if (y > 0) {
ret = x / y;
}
else {
if (x > 0) {
ret = y / x;
}
else {
ret = 1;
}
}
}
}
return ret;
}
Pour moi, yapafoto.
Je suis bien d'accord, dans certains cas loin d'être rares la structure
d'une fonction induit tellement le return multiple que je ne vois pas
pourquoi s'en passer. Dans certains cas on pourrait utiliser un switch
... case, mais il est très rudimentaire en C.
Sinon, j'aime bien, avec en prime uns seul return:
int f(int x, int y) {
return (x == 0)||(y == 0) ? 0 : y > 0 ? x / y : x > 0 ? y / x : 1;
}
En regle générale les return dans la fonction c'est caca. Fuites de mémoire assurées
Ca se discute.
les else sont faits pour ça. Sinon on utilise une variable booleene qu'on teste pour savoir si on continue le traitement.
Ca complique donc la fonction pour se complier à une certaine réglementation qu'on s'impose.
int f(int x, int y) { if (x == 0) return 0; if (y == 0) return 0; if (y > 0) return x / y; if (x > 0) return y/x; return 1; }
Quelle que soit l'inutilité de cette fonction, elle me semble plus facilement compréhensible que :
int f(int x, int y) { int ret; if (x == 0) { ret = 0; } else { if (y == 0) { ret = 0; } else { if (y > 0) { ret = x / y; } else { if (x > 0) { ret = y / x; } else { ret = 1; } } } } return ret; }
Pour moi, yapafoto.
Je suis bien d'accord, dans certains cas loin d'être rares la structure d'une fonction induit tellement le return multiple que je ne vois pas pourquoi s'en passer. Dans certains cas on pourrait utiliser un switch ... case, mais il est très rudimentaire en C.
Sinon, j'aime bien, avec en prime uns seul return:
int f(int x, int y) { return (x == 0)||(y == 0) ? 0 : y > 0 ? x / y : x > 0 ? y / x : 1; }
Les plus timides peuvent parenthéser / indenter.
-- Pierre Maurette
Sylvain
Pierre Maurette wrote on 30/09/2006 14:08:
Sinon, j'aime bien, avec en prime uns seul return:
int f(int x, int y) { return (x == 0)||(y == 0) ? 0 : y > 0 ? x / y : x > 0 ? y / x : 1; }
c'est encore trop ;)
return (x * y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Sylvain.
Pierre Maurette wrote on 30/09/2006 14:08:
Sinon, j'aime bien, avec en prime uns seul return:
int f(int x, int y) {
return (x == 0)||(y == 0) ? 0 : y > 0 ? x / y : x > 0 ? y / x : 1;
}
c'est encore trop ;)
return (x * y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
