[Résolu] Quelques questions sur les conditionnelles

Bonjour,

Je me pose quelques questions sur les conditionnelles.

Dans un premier temps, j'ai un « if » avec plusieurs conditions de la forme :

if((condition1)&&(condition2)&&(conditions3)) {
  Instructions à effectuer
}

Je voudrai savoir si par exemple la « condition1 » n'est pas vérifiée, alors les conditions « condition2 » et « condition3 » sont évaluées. En effet, si la première condition n'est pas vérifiée, alors pourquoi tester les autres. Je sais que certains langages de programmation et/ou options d'optimisation de compilation permettent la non évaluation des conditions multiples dès que la condition globale ne pourra plus être vraie. Qu'en est-il avec l'environnement Arduino ? Afin d'éviter les évaluations des conditions inutiles (et par conséquent accélérer l’exécution du code), faut-il passer à un code de la forme :

if(condition1) {
  if(condition2) {
    if(condition3) {
      Instructions à effectuer
    }
  }
}

qui rend le code plus lourd et plus susceptible aux erreurs d'écritures (essentiellement avec les accolades ouvrantes/fermantes).

Une deuxième question concerne les « switch case » de la forme :

switch (condition) {
  case 0 : Instructions0;
  break;
  case 1 : Instructions1;
  break;
  case 2 : Instructions2;
  break;
  ...
  ...
  case N : InstructionsN;
  break;
}

En entrant dans la « loop », la « condition » vaut 0. Dans les instructions du « case 0 », sous certaines conditions, la « condition » prend la valeur 1. Et ainsi de suite, dans le « case 1 », sous certains conditions, la « condition » prend la valeur 2... Dans le « case N », sous certaines conditions, la « condition » reprend sa valeur initiale 0... Et ça repart pour un tour...
Je voudrai savoir si en sortant du « case 0 » avec la « condition » a 1, le « case 1 » est immédiatement exécuté (sans sortir du switch) ou si le « case 1 » est exécuté à la prochaine exécution de la « loop » ?
C'est juste une interrogation sur le fonctionnement du « switch case » qui ne change rien pour mon application (que le « case 1 » soit exécuté immédiatement ou au prochain passage dans la « loop » il faudra qu'il soit évalué). C'est juste que dans le cas d'une programmation asynchrone, l’exécution immédiate « retarde » la suite du code se trouvant dans la « loop ».

D'avance merci pour les quelques éclaircissements que vous pourrez me fournir.

Cordialement.
MB_F_45

Salut

Les conditions sont évaluées de la gauche vers la droite.
Si condition1 vaut ZERO, alors condition2 et condition3 ne sont pas évaluées.

Essaie ceci:

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
}

int Delay1(void)
{
  Serial.println("Delay1");
  delay(1000);
  return 0;
}

int Delay2(void)
{
  Serial.println("Delay2");
  delay(1000);
  return 0;
}

int Delay3(void)
{
  Serial.println("Delay3");
  delay(1000);
  return 0;
}

void loop() {
  if(Delay1()&&Delay2()&&Delay3()) {
    Serial.println("OK");
  }
  else {
    Serial.println("KO");
  }
}

Je voudrai savoir si en sortant du « case 0 » avec la « condition » a 1, le « case 1 » est immédiatement exécuté (sans sortir du switch) ou si le « case 1 » est exécuté à la prochaine exécution de la « loop » ?

immédiatement exécuté

@+

Merci beaucoup pour les réponses et l’exemple.

Cordialement.
MB_F_45

Le ET logique (noté &&) peut se voir comme une multiplication :

X = IF (A && B)
x = a . b vaut 0 en sortie dès qu'il y a un 0 en entrée, élément neutre de la multiplication.

Oui, le "ET logique" se comporte comme une multiplication.
Ma question portait plus sur le comportement du code dans l'évaluation du "ET" : Est-ce que le code "s'évertue" a évaluer tous les arguments ou s'arrête-t-il dès qu'il s'aperçoit que le résultat ne va plus changer parce qu'il est nul ?

Du coup on peut se poser la même question pour la multiplication :
Si on a une multiplication de la forme M=0a1a2a3a4..., le code va-t-il effectuer toutes les multiplications alors qu'il est évident dès le premier argument que le résultat est nul ? Pour l'humain qui voit de "haut" la multiplication, dès qu'il aperçoit un 0 dans la multiplication il connaît le résultat sans l'effectuer. Qu'en est-il des machines ?

Ma question originale sous-entendait autre question concernant l'optimisation (bien mineure je le conçois, de l'ordre du temps pour évaluer ou pas 2 conditions) dans la vitesse d’exécution du code. Faut-il ordonner les arguments du "if" afin de placer en premier celui qui est nul le plus souvent et ainsi de suite ?
Cette optimisation peut devenir pertinente quand les arguments du "if" sont des sous fonctions qui effectuent un certain nombre d'opération, comme le code qu'a proposé hbachetti.

Encore merci pour la réponse.

Cordialement.
MB_F_45.

Christian_R:
x = a . b vaut 0 en sortie dès qu'il y a un 0 en entrée, élément neutre de la multiplication.

0 est l'élément neutre de l'addition (ne change pas le résultat de la somme) mais l'élément absorbant de la multiplication.
C'est 1 qui est l'élément neutre de la multiplication. :wink:

Si on a une multiplication de la forme M=0a1a2a3a4..., le code va-t-il effectuer toutes les multiplications alors qu'il est évident dès le premier argument que le résultat est nul ?

Oui, il effectuera toutes les multiplications.