C n’exécute pas seulement le code de manière linéaire. Cela fait des choix. Au cœur de chaque décision prise par un programme C se trouve l’expression booléenne. Que vous utilisiez une instruction « if » ou une boucle « while », la logique se résume à une chose : cette condition est-elle vraie ou fausse ?
Regardons un exemple basique.
Ici, le programme demande une entrée. Il stocke ce nombre dans la variable « b ». Ensuite, il vérifie une condition. L’expression booléenne en question est (b < 0). C évalue cela. Si le résultat est vrai, le programme imprime "La valeur est négative". Si c'est faux, le programme ne fait rien. Il reste silencieux.
La règle est simple. Si l'expression est évaluée à True, C exécute la seule ligne qui suit immédiatement le « if ». Ou, si vous utilisez des accolades {}, il exécute tout le bloc à l'intérieur. Si l'expression est False, C ignore entièrement cette ligne ou ce bloc.
Mais les programmes traitent rarement d’un seul résultat. Vous devez souvent également gérer des nombres nuls ou positifs.
Cette structure utilise « else if » et « else » pour couvrir les cas restants. Il teste ensuite zéro. Si cela échoue, il suppose que la valeur est positive.
Parfois, les décisions sont compliquées. Vous devrez peut-être vérifier plusieurs conditions à la fois.
Cette déclaration se lit comme un langage naturel. Si x est égal à y ET j est supérieur à k, alors définissez z sur 1. Sinon, définissez q sur 10. Vous utiliserez ce type d'instructions tout au long de votre carrière C. La plupart des décisions seront simples. Parfois, ils deviendront complexes.
Portez une attention particulière à la syntaxe. Un piège courant pour les débutants est de confondre affectation et comparaison.
C utilise == pour tester l'égalité.
C utilise = pour attribuer une valeur à une variable.
Les mélanger provoque des bugs difficiles à trouver. On fixe une valeur. L'autre vérifie une condition. Ils ne sont pas interchangeables.
C s'appuie également sur des opérateurs spécifiques pour les opérations logiques. Le symbole && représente une opération booléenne ET. Cela garantit que les deux côtés de la condition doivent être vrais.
Voici une référence rapide pour tous les opérateurs booléens en C :
- == : égalité
- != : inégalité
- **< : moins de
- * * : supérieur à
- <= : inférieur ou égal à
- >= : supérieur à
Logique de boucle en C : while, do-while et for
Utiliser une boucle while est simple. Cela reflète la simplicité d’une instruction if standard. Considérez cet extrait :
while (a < b) { printf("%d\n", a); une = une + 1 ; }
Cette structure exécute les deux lignes à l’intérieur des accolades de manière répétée. Il s'arrête uniquement lorsque a est supérieur ou égal à b. La logique est linéaire. Vérifiez l'état. Exécuter le corps. Répéter.
C propose également une construction do-while. Contrairement à la boucle while standard, celle-ci vérifie la condition après la première exécution. Cela garantit que le bloc de code s'exécute au moins une fois.
Remarque : L'exemple ci-dessus utilise une instruction if dans la fonction. Un véritable exercice consisterait à envelopper le corps et à vérifier son état à la fin.
La boucle for comme raccourci
La boucle for est essentiellement une instruction while compressée. Il regroupe l'initialisation, les tests et l'incrémentation sur une seule ligne.
Regardez cette boucle while standard :
x=1 ;
tandis que (x<10) {
bla bla bla
x++ ; // x++ est identique à x=x+1
}
Vous pouvez réécrire ceci sous forme de boucle for :
pour(x=1; x<10; x++) { bla bla bla }
Les composants sont clairs. x=1 s'initialise. x<10 essais. x++ incréments. La boucle for les condense simplement. Vous n’êtes pas limité à de simples variables. Vous pouvez intégrer une logique complexe dans ces emplacements.
Prenons cet exemple :
une = 1 ;
b = 6 ;
tandis que (a < b) {
un++;
printf("%d\n",a);
}
Cela devient :
pour (a=1,b=6; a < b; a++,printf("%d\n",a));
Ça marche. C’est également déroutant. L'opérateur virgule autorise plusieurs instructions dans les sections d'initialisation et d'incrémentation. Cela ne fonctionne pas dans la section test. De nombreux développeurs C aiment cette compacité. D'autres le trouvent illisible. Ils le brisent. Les deux approches sont valables. Choisissez en fonction de qui conservera le code plus tard.
Le danger de = vs. == en C
L'opérateur == provoque des maux de tête. Les développeurs tapent fréquemment un seul = par erreur dans les expressions booléennes. Le compilateur accepte les deux. Le comportement diffère énormément.
En C, les expressions booléennes sont évaluées sous forme d’entiers. Zéro est faux. Tout entier non nul est vrai. Cela signifie que n'importe quel entier peut exister dans un contexte booléen.
Considérez ce code C légal :
if (a) { printf("Non nul"); }
Si a est autre chose que 0, le bloc s'exécute.
Regardez maintenant if (a=b). Cela ne compare pas les valeurs. Il attribue b à a, puis teste la nouvelle valeur de a. Si b vaut 0, la condition est fausse. Si b est autre chose, c'est vrai. La variable a change. Ce n’est probablement pas ce que vous vouliez. Vous vouliez probablement dire == à titre de comparaison.
Cette fonctionnalité n'est pas inutile. Il a des cas d’utilisation valides. Mais c'est un piège. Soyez prudent avec votre utilisation de = et ==. Un personnage change la logique de la comparaison à l'affectation.
