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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Pour ce qui est de la fonction ci-dessus.
C'est super on voit que le mec maîtrise. Mais à part ça c'est une
horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux
qui vont passer derrière lui.
Après moi le déluge....
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair
et que le compilo écrit la même chose. C'est un exemple extrême j'en
conviens.
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Pierre Maurette
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser selon goût. Nous sommes dans un cas typique d'utilisation efficace de l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var) uniquement quand var a une sémantique (et un nom si possible) de condition. if(var == 0) ou if(var != 0) quand var est un type entier. Pour le pointeur, je suis favorable à la comparaison à NULL, mais il vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur arithmétique pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte pas le cahier des charges qui est:
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;
-- Pierre Maurette
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus.
C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de
lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer
derrière lui.
Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser
selon goût. Nous sommes dans un cas typique d'utilisation efficace de
l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et
que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var)
uniquement quand var a une sémantique (et un nom si possible) de
condition. if(var == 0) ou if(var != 0) quand var est un type entier.
Pour le pointeur, je suis favorable à la comparaison à NULL, mais il
vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur
arithmétique pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte
pas le cahier des charges qui est:
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;
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser selon goût. Nous sommes dans un cas typique d'utilisation efficace de l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var) uniquement quand var a une sémantique (et un nom si possible) de condition. if(var == 0) ou if(var != 0) quand var est un type entier. Pour le pointeur, je suis favorable à la comparaison à NULL, mais il vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur arithmétique pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte pas le cahier des charges qui est:
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;
-- Pierre Maurette
fagotto
Juste une remarque et on va finir là.
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; }
C'est pas plus lisible comme ça ? Quant à la version avec des return en cours de fonction elle ne me choque pas dans ce cas là qui est relativement simple. Seulement si un jour la fonction se complique qu'il faut réserver de la mémoire alors on prend des risques. Voilou Bien à vous tous Fagotto
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser selon goût. Nous sommes dans un cas typique d'utilisation efficace de l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var) uniquement quand var a une sémantique (et un nom si possible) de condition. if(var == 0) ou if(var != 0) quand var est un type entier. Pour le pointeur, je suis favorable à la comparaison à NULL, mais il vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur arithmétique pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte pas le cahier des charges qui est:
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;
Juste une remarque et on va finir là.
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;
}
C'est pas plus lisible comme ça ?
Quant à la version avec des return en cours de fonction elle ne me
choque pas dans ce cas là qui est relativement simple. Seulement si un
jour la fonction se complique qu'il faut réserver de la mémoire alors on
prend des risques.
Voilou
Bien à vous tous
Fagotto
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus.
C'est super on voit que le mec maîtrise. Mais à part ça c'est une
horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux
qui vont passer derrière lui.
Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser
selon goût. Nous sommes dans un cas typique d'utilisation efficace de
l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus
clair et que le compilo écrit la même chose. C'est un exemple extrême
j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var)
uniquement quand var a une sémantique (et un nom si possible) de
condition. if(var == 0) ou if(var != 0) quand var est un type entier.
Pour le pointeur, je suis favorable à la comparaison à NULL, mais il
vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur arithmétique
pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte
pas le cahier des charges qui est:
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;
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; }
C'est pas plus lisible comme ça ? Quant à la version avec des return en cours de fonction elle ne me choque pas dans ce cas là qui est relativement simple. Seulement si un jour la fonction se complique qu'il faut réserver de la mémoire alors on prend des risques. Voilou Bien à vous tous Fagotto
Pierre Maurette wrote:
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.
Parenthésage et indentage sont les 2 mammelles de la lisibilité.
La lisibilité serait donc mammifère ?
Tiens, savez-vous pourquoi les coqs n'ont pas de mains ?
Parce que les poules ont pas de sein.
Oui.
Pour ce qui est de la fonction ci-dessus. C'est super on voit que le mec maîtrise. Mais à part ça c'est une horreur de lisibilité et celui qui a écrit ça surtout se fout de ceux qui vont passer derrière lui. Après moi le déluge....
Pas du tout. J'ai bien précisé que ça peut s'indenter / parenthéser selon goût. Nous sommes dans un cas typique d'utilisation efficace de l'opérateur ternaire.
if (pointeur == NULL) est préférable if (pointeur) parce que plus clair et que le compilo écrit la même chose. C'est un exemple extrême j'en conviens.
Oui, bien sûr. J'en suis également convaincu. if(var) ou if(!var) uniquement quand var a une sémantique (et un nom si possible) de condition. if(var == 0) ou if(var != 0) quand var est un type entier. Pour le pointeur, je suis favorable à la comparaison à NULL, mais il vaut mieux être habitué à lire if(pointeur).
Je ne vois pas où j'ai pêché par rapport à ces règles de style. Dans:
return (x | y) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
il s'agit d'un OU bitwise. Certes, il s'agit d'un opérateur arithmétique pour moi, donc j'eu pu:
return ((x | y) == 0) ? y > 0 ? x / y : x > 0 ? y / x : 1 : 0;
Mais je précisais que je n'aimais pas. De toutes façons, ça ne repecte pas le cahier des charges qui est:
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;
