Bêtement, je fais un trois tests:
− le premier avec un switch
− le deuxième avec un if
− le troisième avec un opérateur ternaire:
Les trois programmes de tests:
Avec switch:
volatile uint8_t N, resultat; // Pour pouvoir faire les tests, volatile pour éviter les optimisations
volatile long temps, // Mesure du temps avec millis()
boucle; // Nombre de boucles pour avoir une certaine précision
void setup()
{
Serial.begin(115200); // Initialisation de la console
}
void loop()
{
Serial.print("Avec switch: ");
N = random(7);
temps = millis(); // Début de la mesure
for (boucle=0; boucle<800000L; boucle++) switch (N)
{
case 0: resultat += 4; break;
case 1: resultat += 6; break;
case 2: resultat += 9; break;
case 3: resultat += 8; break;
case 4: resultat += 2; break;
case 5: resultat += 7; break;
case 6: resultat += 1; break;
case 7: resultat += 8; break;
}
// Calcul avec "resultat" (qui vaut forcément 0) pour éviter un code inutile qui peut être supprimé sans avertissement
Serial.print(millis() - temps + resultat); // Fin de la mesure
Serial.println("ms");
}
Avec if:
volatile uint8_t N, resultat; // Pour pouvoir faire les tests, volatile pour éviter les optimisations
volatile long temps, // Mesure du temps avec millis()
boucle; // Nombre de boucles pour avoir une certaine précision
void setup()
{
Serial.begin(115200); // Initialisation de la console
}
void loop()
{
Serial.print("Avec if: ");
N = random(7);
temps = millis(); // Début de la mesure
for (boucle=0; boucle<800000L; boucle++) if (N < 4)
{{ // N = 0 à 3
if (N < 2)
{{ // N = 0 ou 1
if (N==0) resultat += 4; else resultat += 6;
}}
else
{{ // N = 2 ou 3
if (N==2) resultat += 9; else resultat += 8;
}}
}}
else
{{ // N = 4 à 7
if (N < 6)
{{ // N = 4 ou 5
if (N==4) resultat += 2; else resultat += 7;
}}
else
{{ // N = 6 ou 7
if (N==6) resultat += 1; else resultat += 8;
}}
}}
// Calcul avec "resultat" (qui vaut forcément 0) pour éviter un code inutile qui peut être supprimé sans avertissement
Serial.print(millis() - temps + resultat); // Fin de la mesure
Serial.println("ms");
}
Avec l'opérateur ternaire:
volatile uint8_t N, resultat; // Pour pouvoir faire les tests, volatile pour éviter les optimisations
volatile long temps, // Mesure du temps avec millis()
boucle; // Nombre de boucles pour avoir une certaine précision
void setup()
{
Serial.begin(115200); // Initialisation de la console
}
void loop()
{
Serial.print("Avec ?:; : ");
N = random(7);
temps = millis(); // Début de la mesure
for (boucle=0; boucle<800000L; boucle++) (N < 4)?
// N = 0 à 3
(N < 2)?
// N = 0 ou 1
(N==0)? resultat += 4: resultat += 6:
// N = 2 ou 3
(N==2)? resultat += 9: resultat += 8:
// N = 4 à 7
(N < 6)?
// N = 4 ou 5
(N==4)? resultat += 2: resultat += 7:
// N = 6 ou 7
(N==6)? resultat += 1: resultat += 8;
// Calcul avec "resultat" (qui vaut forcément 0) pour éviter un code inutile qui peut être supprimé sans avertissement
Serial.print(millis() - temps + resultat); // Fin de la mesure
Serial.println("ms");
}
Le résultat avec une Uno et switch:
Le croquis utilise 2398 octets (7%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 218 octets (10%) de mémoire dynamique, ce qui laisse 1830 octets pour les variables locales. Le maximum est de 2048 octets.
Avec switch: 3067ms
Avec switch: 3069ms
Avec switch: 3170ms
Avec switch: 3169ms
Avec switch: 3169ms
Avec switch: 3169ms
Avec switch: 3169ms
Avec switch: 3168ms
Le résultat avec une Uno et if:
Le croquis utilise 2442 octets (7%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 214 octets (10%) de mémoire dynamique, ce qui laisse 1834 octets pour les variables locales. Le maximum est de 2048 octets.
Avec if: 2665ms
Avec if: 2666ms
Avec if: 2817ms
Avec if: 2868ms
Avec if: 2867ms
Avec if: 2867ms
Avec if: 2817ms
Avec if: 2817ms
Le résultat avec une Uno et l'opérateur ternaire:
Le croquis utilise 2444 octets (7%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 216 octets (10%) de mémoire dynamique, ce qui laisse 1832 octets pour les variables locales. Le maximum est de 2048 octets.
Avec ?:; : 2665ms
Avec ?:; : 2666ms
Avec ?:; : 2817ms
Avec ?:; : 2868ms
Avec ?:; : 2867ms
Avec ?:; : 2867ms
Avec ?:; : 2817ms
Avec ?:; : 2816ms
Personnellement j'en pense que le if et l'opérateur ternaire sont la même chose et sont compilés de la même façon. L'avantage de l'opérateur ternaire est que mon compilateur ne râle pas si on ne rajoute pas des {}. Dans mon code je mets {{ quand je n'en mettrais pas mais le compilateur n'est pas content. Mais je ne suis pas sûr que l'opérateur ternaire est plus lisible. Je l'utilise plutôt quand j'ai une affectation conditionnelle.
Le switch semble utiliser moins de code, et semble prendre plus de temps.
Mais quel est l’intérêt ? N'est-ce pas plus simple et lisible de faire le tout avec un 
)
plus rapide pour ≥5 cases contiguës)