Discussion :

[tintin72]

Bonjour,

Juste une petite question d'ordre pratique à propos du if et else.
Dans un schéma classique ça se présente comme ça;

Code :

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

1
2
3
4
5
6
7
8
9
 
if(monBool)
{
  ...
}
 else
 {
  ...
 }

mais je trouve ça vraiment trop long surtout si il n'y a que des petites instruction.
J'aurais plutot tendance à faire comme ça:

Code :

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

1
2
3
 
if(monBool) ...
if(!monBool) ...

ça ne prend que 2 lignes au lieu de 8 et le résultat est le même.
Toutefois, j'aimerais savoir si les 2 formes sont identiques au niveau de la rapidité
et si il existe un autre moyen d'abréger un if else.

Merci

[Médinoc]

Code :

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

1
2
if(monBool) ...
else ...

[millie]

C'est rare d'avoir des blocs énormes (sinon, il faut penser à réaliser des découpages avec des fonctions supplémentaires éventuellement).

En tout cas, en parlant juste en terme de rapidité, le fait de faire :

Code :

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

1
2
if(monBool) ...
if(!monBool) ...

Peut être différent, notamment car monBool peut être changé au premier ... De plus, tu réalises deux fois une évaluation, si tu as un appel du style :

Code :

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

if(fonction())

et que la fonction demande pas mal de temps en exécution, dans ta méthode, tu vas faire deux appels (donc perte de temps)

[Invité]

Déjà, je ne vois pas en quoi faire :

Code :

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

1
2
if(monBool) ...
else ...

Est plus long que :

Code :

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

1
2
if(monBool) ...
if(!monBool) ...

Ensuite, comme précisé ci-dessus, dans le second cas tu as deux évaluations, ce qui peut être deux fois plus lent (et faux si monBool est susceptible d'être différent la seconde fois).

Enfin, je ne trouve pas ça très élégant et lisible. Pour ma part, je fais toujours :

Code :

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

1
2
3
4
if(monBool)
    ...
else
    ...

[koala01]

Salut,

Déjà, je ne vois pas en quoi faire :

Code :

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

1
2
if(monBool) ...
else ...

Est plus long que :

Code :

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

1
2
if(monBool) ...
if(!monBool) ...

En fait, il faut savoir que, du point de vue du processeur, et de son jeu d'instruciton, tu as différentes possiblités pour provoquer un saut de mémoire, sans appeler une sous fonction:
le saut inconditionnel JMP (Jump)
et une instruction pour chaque (in)égalité existante:
JUMP EQUAL
JUMP NOT EQUAL
JUMP GREATER
JUMP LESSER
JUMP LESSER OR EQUAL
JUMP GREATEROR EQUAL

Le saut inconditionnel est celui qui prend le moins de cycles d'horloge:
1-Lecture instruction
2-Lecture nouvelle adresse
3- acces nouvelle adresse

Alors que les saut conditionnels utilisent la valeur du dernier accu chargé, doivent lire la valeur de comparaison, tester l'(in)égalité, et sauter à la nouvelle adresse memoire en fonction du résultat (cout total: entre 7 et 9 cycles d'horloge, si mes souvenirs sont bons)...sans compter qu'il faut sans doute recharger l'accu pour s'assurer que la comparaison aie lieu avec la bonne valeur...

Quand tu écrit un test du genre de

Code :

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

1
2
3
4
5
 
if(variable==valeur)
...
else
...

l'instruction sera du genre
1 charge accu
2- JUMP 5 NOT EQUAL
3- ce qu'il faut faire si c'est egal
4- JUMP 6 (pour retourner en sortie du test
5- ce qu'il faut faire si c'est pas egal
6- la suite du programme

Par contre, si tu écrit un code du genre de

Code :

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

1
2
3
4
if(variable== valeur)
...
if(variable!=valeur)
...

les instructions pour le processeurs prendront sans doute plutot la forme de
1- charge accu
2- JUMP 4 NOT EQUAL (on passe la partie pour variable==valeur)
3- ce qu'il faut faire si la valeur est correcte
4- charge accu
5- JUMP 7 EQUAL (on passe la partie pour variable!=valeur)
6- ce qu'il faut faire si la valeur est fausse
7- la suite du programme

Tu te retrouvera donc avec un chargement d'accu et un saut conditionnel supplémentaire... donc, avec quelque chose qui prendra (beaucoup) plus de cycles d'horloge...

Si, en plus, tu utilises une fonction pour évaluer ton test, cela deviendra
1- CALL fonction
2- JUMP 4 NOT EQUAL (on passe la partie pour variable==valeur)
3- ce qu'il faut faire si la valeur est correcte
4- CALL fonction
5- JUMP 7 EQUAL (on passe la partie pour variable!=valeur)
6- ce qu'il faut faire si la valeur est fausse
7- la suite du programme

et tu perdra, en plus, le temps nécessaire à la double exécution de la fonction...

Je sais qu'avec les fréquences atteintes par les processeurs actuels, une dizaine de cycles d'horloge ne représentent rien... mais, met cela dans une boucle qui doit etre effectuée 300.000 fois, et tu auras perdu entre une seconde et une seconde et demie à l'exécution :p (beaucoup plus si tu utilise une fonction dans ton test)

tintin72==>
Les accolades ne sont indispensables que lorsque tu veux créer un "bloc d'instructions insécable" (on exécute tout le bloc, ou on n'exécute rien, mais on ne peut pas exécuter seulement une partie du bloc), un peu à la manière de ce qu'on appelle les "transactions" en langage SQL...

Quand tu n'a qu'une instruction dans chaque partie du test, que tu écrives

Code :

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

1
2
3
4
5
6
7
8
9
10
 
if (nomBool)
{
    une instruction unique
}
else
{
    une instruction unique
}
//suite du programme

ou

Code :

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

1
2
3
4
5
6
 
if (nomBool)
    une instruction unique
else
    une instruction unique
//suite du programme

cela reviendra exactement au meme...

Exception faite d'une certaine idée de la lisibilité du code (pour autant que le code soit correctement indenté et "présenté", cela va de soi )

Par contre, et je te reporte au début de mon message pour les explications, il y a de fortes chances qu'il sera plus rapide à l'exécution que si tu écrivais

Code :

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

1
2
3
4
5
6
 
if(monBool)
    instruction unique
if(!monBool)
    instruction unique
//suite du programme

Maintenant, s'i tu envisages (cela peut arriver) de modifier (sous conditions) monBool dans le premier test, puis de revérifer sa valeur avant de faire un test sur monBool étant faux, ce sera vraissemblablement le dernier test qu'il faudra effectuer sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if(monBool)
{
    //quelques instructions sans importances
    if(un test quelconque)
        monBool=false;
    else
        monBool=true;
}
if(!monBool)
{
    //ce qui sera fait si monBool est faux
    //que ce soit apres avoir exécute MonBool a vrai ou non
}

[Invité]

Je sais tout cela, si tu relis mon post, tu verras que tu as compris ma comparaison à l'envers. Je remarquais que if(abc)... else... n'est pas plus long à écrire que if(abc)... if(!abc)...
Je suis tout à fait d'accord que dans un cas il y a deux évaluations, et qu'une seule dans l'autre.

Ce qui amène la question ci-après (puisqu'on est dans le sujet) : vaut-il mieux placer le code le plus fréquement exécuté dans le bloc du else ou celui du if ?

Code :

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

1
2
3
4
5
bool bMachin; // vrai 99% du temps
if(bMachin)
    /* ... */
else
    /* ... */

Code :

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

1
2
3
4
5
bool bNotMachin; // faux 99% du temps
if(bNotMachin)
    /* ... */
else
    /* ... */

Ca éveille ma curiosité, faut que je vérifie

PS : Oui je sais je détourne un peu le topic...

edit : après test, j'obtient :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    ; Comparaison
    cmpl    $0, -4(%ebp)
    ; Si faux, on saute (instruction exécutée dans les deux cas)
    je  .L2
    ; Si vrai : action puis saut
    movl    $42, -8(%ebp)
    jmp .L3
    ; Fin
 
.L2:
    ; Si faux : action
    movl    $666, -8(%ebp)
.L3:

Ici, on a une instruction en plus (un saut inconditionnel) quand l'instruction est vraie...