comprends ce qui est dit

Salut,

J'essaie de comprendre une ligne de code en C++ mais là j'ai du mal
Voici ma ligne

Code:

---

1 2	*n = *p ? 0 : 1;

---

Les données: n et p sont des pointeurs sur des unsigned char
Mais comme il s'agit de paramètres d'une fonction je crois qu'il s'agit de pointeurs sur le 1ier élément d'un tableau d'unsigned char.

D'après ce que je sais quand il y a un ? on vérifie si la condition placée avant lui est vraie si oui le résultat est 0 sinon le résultat est 1.
Problème, ici il n'y a pas de test??? moi j'aurais écris un truc du genre

Code:

---

1 2	(*n == *p) ? 0 : 1;

---

Voilà, est ce que qqu'un comprend?

Voilà du code qu'il est beau...
S'il faut se predre la tête pour ce genre de chose, il est clair que la programmation est réservée à une élite.

Dans ton cas il y utilisation de l'opérateur ternaire dont la sysntaxe est la suivante :

expression_bool ? res_si_vrai : res_si_faux
Ce code peut donc être traduit par

Code:

---

1 2 3 4

if( *p ) *n = 0 ; else *n = 1 ;

---

D'autre part l'état false est représenté par un zéro. Donc si ce qui est pointé par p vaut zéro ce qui est pointé par n sera affecté avec 1...

j'ai toujours du mal avec le "C_Men" qui se prennent pour des cadors à écrire des trucs illisibles de ce style, sous le prétexte (souvent faux) que ça fait du code plus efficace.

Juste des parenthèses aurais suffit à expliciter le code

Code:

---

*n = (*p ? 0 : 1);

---

Il est clair que non commenté c'est une faute de goût.

Cependant c'est plus efficace que l'équivalent if. Pourquoi : L'intégralité de l'instruction est préfécthé dans le pipeline du processeur en un seul coup. De plus, c'est un branchement cours, ça ne peut pas devenir un branchement long, donc deux fois plus rapide.

Cependant, c'est surtout utile pour de portions de codes nécessitant de la rapidité (compression de données, très grands fichiers à traiter, automates embarqués ...)

Citation:

---

Envoyé par tut

j'ai toujours du mal avec le "C_Men" qui se prennent pour des cadors à écrire des trucs illisibles de ce style, sous le prétexte (souvent faux) que ça fait du code plus efficace.

---

Citation:

---

Envoyé par Caine

Cependant c'est plus efficace que l'équivalent if. Pourquoi : L'intégralité de l'instruction est préfécthé dans le pipeline du processeur en un seul coup. De plus, c'est un branchement cours, ça ne peut pas devenir un branchement long, donc deux fois plus rapide.

---

Un gros mouarf pour toi ;-) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

void set1 ( int* a, int* b ) {   if( *b != 0 ) 00401420 mov ecx,dword ptr [esp+8] 00401424 mov edx,dword ptr [esp+4] 00401428 xor eax,eax 0040142A cmp dword ptr [ecx],eax 0040142C sete al 0040142F mov dword ptr [edx],eax *a = 0 ; else *a = 1 ;   } 00401431 ret         void set2 ( int* a, int* b ) { *a = *b ? 0 : 1 ; 00401440 mov ecx,dword ptr [esp+8] 00401444 mov edx,dword ptr [esp+4] 00401448 xor eax,eax 0040144A cmp dword ptr [ecx],eax 0040144C sete al 0040144F mov dword ptr [edx],eax } 00401451 ret

---

Faut arrèter de croire qu'un compilateur est une brèle.

Economie de ligne : Moins ya de ligne moins ya d erreur

autrement ya pas d interet

ca c est la base :wink:

Citation:

---

Economie de ligne : Moins ya de ligne moins ya d erreur

---

Va faire un tour sur http://www.ioccc.org, tu y trouveras ton bonheur :lol:

Code:

---

main(v,c)char**c;{for(v[c++]="Hello, world!\n)";(!!c)[*c]&&(v--||--c&&execlp(*c,*c,c[!!c]+!!c,!c));**c=!c)write(!!*c,*c,!!**c);}

---

Code:

---

int _,O,__??('}'??);main(){while(O?gets((rand()%O++?':':_)+__)||puts(&__??(_??))&_:srand(time((O+++_)))||O);}

---

Code:

---

main(a,b){while((a=getchar())+1)putchar((b=64^a&223)&&b<27?a&96|(b+12)%26+1:a);}

---

c'est quand même la classe ;)

ok, merci pour vos réponses.

Mais j' ai encore un petit pb d'une ligne que je comprends pas:?

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void UneMegaFct(float tab[]) { float* g = tab; *g++ = 0.0;   for (int k=1;k<9;k++) { *g++ = trucbidule; } }

---

En sachant que :

Code:

---

1 2	float tab[9];

---

De ce que je comprends, la variable g pointe sur le 1ier élément de tab.
Donc quand on fait *g++ = 0.0 ça veut dire qu'on met la valeur 0.0 dans la case d'indice 1 de tab.
Mais avec ce raisonnement ya un pb avec la boucle for
quand k=1 on remplit la case d'indice 2
quand k=8 on remplit la case d'indice 9 qui n'existe pas
Donc il y a une err ds mon raisonnement mais où??? 8O

le premier indice d'un tableau est 0 et non 1 ... g++=postincrémentation

ok super :wink:

Idem il aimait pas les parenthèses lui

Code:

---

*(g++) = 0.0;

---

*p++ est quand même un classique que l'on finit par savoir lire sans plus réfléchir. Mais de toutes façons, ce genre de trucs est limite à réserver à l'implémentation de fonctions assez bas niveau comme std::copy, std::fill, std::for_each, ...

Pour ce qui est de l'opérateur ternaire, j'ai envie de dire que tout dépend de ce qui est important, dans l'algo mis en oeuvre. S'il s'agit de l'affectation, alors l'opérateur est fort pratique -- utiliser des parenthèses n'est pas forcément un luxe. Si ce qui est important c'est le test, alors un if-else est définitivement préférable.

Soit j'aime bien écrire:

Code:

---

1 2 3 4 5 6

void f(std::string const& p) { // option, mise à "defaut" si non initialisée std::string option = p.empty() ? "defaut" : p;   // algo suffisament compliqué (plus de 3 lignes) ...

---

(Je dois avouer que j'utilise plus ce genre de choses en VimL qu'en C++ (pas vraiment l'occasion de traiter des paramètres en C++))

Citation:

---

Envoyé par bigquick

Citation:

---

Economie de ligne : Moins ya de ligne moins ya d erreur

---

Va faire un tour sur http://www.ioccc.org, tu y trouveras ton bonheur :lol:

Code:

---

main(v,c)char**c;{for(v[c++]="Hello, world!\n)";(!!c)[*c]&&(v--||--c&&execlp(*c,*c,c[!!c]+!!c,!c));**c=!c)write(!!*c,*c,!!**c);}

---

Code:

---

int _,O,__??('}'??);main(){while(O?gets((rand()%O++?':':_)+__)||puts(&__??(_??))&_:srand(time((O+++_)))||O);}

---

Code:

---

main(a,b){while((a=getchar())+1)putchar((b=64^a&223)&&b<27?a&96|(b+12)%26+1:a);}

---

c'est quand même la classe ;)

---

Moué mais faut pas non plus tomber dans la connerie ;) ca sert pas a grand chose en plus. Je disais juste que moins ya de ligne moins il y a d'erreur mais pour bien comprendre il en faut quand meme un minimum

hé fallait pas mal le prendre :)
c'est juste que ton post m'a fait penser à ce truc que j'avais vu il y a un moment il qui m'avait fait halluciner!

a je le prend vraiment pas mal ca ma fit beaucoup rire


il y a des personnes qui n'ont rien d'autre a foutre que ca :roll:

Allez je vais me faire un petit helloworld en une ligne

y a des bases de données qui explosent avec ce genrede discussions lol

Je n'ai jamais dit que tous les compilateurs étaient des brèles :) Donc Mouarf pour toi aussi :)
Mais dit toi que si ton compilateur actuel traduit de cette façon, ce n'était pas évident sans optimisation de compilation il y a dix ans :)

Hé oui, les choses se sont bien amélioré depuis. De plus, si le code assembleur est le même, la version en opérateur ternaire est préfecthée en une seule opération.

Une fois encore, ce petit détail était utile avant le 386, premier processeur capable d'un préfetch en parallèle de code.

C'est sûr qu'avec les proc hyper scalaire de nos jours...on s'en fout un peu.

Mais, c'est bien pour cette raison, que l'opérateur ternaire à vu le jour à une certaine époque, où les algorithme d'optimisation de compilation n'était pas courant (comme l'optimisation SSA), ou un processeur devait fetcher les opcodes avant chaque exécution...

Citation:

---

Envoyé par Selenite

Citation:

---

Envoyé par Caine

Cependant c'est plus efficace que l'équivalent if. Pourquoi : L'intégralité de l'instruction est préfécthé dans le pipeline du processeur en un seul coup. De plus, c'est un branchement cours, ça ne peut pas devenir un branchement long, donc deux fois plus rapide.

---

Un gros mouarf pour toi ;-) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

void set1 ( int* a, int* b ) {   if( *b != 0 ) 00401420 mov ecx,dword ptr [esp+8] 00401424 mov edx,dword ptr [esp+4] 00401428 xor eax,eax 0040142A cmp dword ptr [ecx],eax 0040142C sete al 0040142F mov dword ptr [edx],eax *a = 0 ; else *a = 1 ;   } 00401431 ret         void set2 ( int* a, int* b ) { *a = *b ? 0 : 1 ; 00401440 mov ecx,dword ptr [esp+8] 00401444 mov edx,dword ptr [esp+4] 00401448 xor eax,eax 0040144A cmp dword ptr [ecx],eax 0040144C sete al 0040144F mov dword ptr [edx],eax } 00401451 ret

---

Faut arrèter de croire qu'un compilateur est une brèle.

---