Discussion :

[MrsFrizz]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Voilà, est ce que qqu'un comprend?

[gelam]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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.

[Ti-R]

Juste des parenthèses aurais suffit à expliciter le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Caine]

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 ...)

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.

[Selenite]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[ankou82]

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

autrement ya pas d interet

ca c est la base

[bigquick]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[MrsFrizz]

ok, merci pour vos réponses.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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ù???

[sg-40]

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

[MrsFrizz]

ok super

[Ti-R]

Idem il aimait pas les parenthèses lui

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*(g++) = 0.0;

[Luc Hermitte]

*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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++))

[ankou82]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[bigquick]

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!

[ankou82]

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

Allez je vais me faire un petit helloworld en une ligne

[sg-40]

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

[Caine]

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...

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.