Qu'est-ce que la décision en programmation C ?
En programmation C, la prise de décision est une compétence de base que les programmeurs doivent maîtriser pour créer des programmes efficaces. La prise de décision est le processus d'évaluation de différentes conditions et de choix du meilleur plan d'action en fonction des résultats. Avec une instruction if-else, la prise de décision est implémenté en C. Les décisions sont basées sur des conditions et sont prises à l'aide de l'instruction if-else. Si la condition est vraie, le code s'exécute ; en revanche, s'il est faux, le code contenu dans l'instruction else est exécuté.
Qu'est-ce que la création de branches en programmation C ?
En programmation C, ramification est la technique qui permet au flux d'exécution de changer en fonction du résultat d'une condition. Ramification permet au programme d'exécuter des blocs de code spécifiques en fonction du résultat d'une circonstance spécifique.
Il existe différents types de branchement dans la programmation C, y compris sinon , changer , et opérateurs conditionnels . Dans un déclaration de commutateur , le programme évalue une valeur et choisit l'option appropriée dans la liste des cas disponibles. Les opérateurs conditionnels sont des raccourcis sinon instructions qui vous permettent d'écrire un code plus court.
Décisions et branchement en programmation C
Le la prise de décision Le processus en programmation C implique l'utilisation d'instructions conditionnelles pour contrôler le flux d'exécution du programme. Ramification permet au programme d'exécuter différents ensembles de code en fonction du résultat de certaines conditions.
En programmation C, la prise de décision , et ramification sont atteints grâce à :
- si déclaration
- instruction if-else
- déclaration de commutateur
- Imbriqué si
- Sinon-si Échelle
- déclaration de pause
- continuer Déclaration
1 : si Déclaration
La méthode la plus simple de faire des décisions offert par la programmation C est le si déclaration . Le si déclaration teste une condition donnée et exécute le code dans le corps de l'instruction si la condition est vraie. Sinon, le programme ignore le bloc de code associé au si déclaration , et il continue avec le code suivant.
La syntaxe de instruction if est:
si ( condition )
{
Bloc de déclarations ;
}
Regardez le code ci-dessous :
#includeint main ( )
{
nombre entier = vingt ;
si ( sur une > 5 )
{
printf ( 'num est supérieur à 5 \n ' ) ;
}
printf ( 'la valeur de num est : %d \n ' , sur une ) ;
retour 0 ;
}
Le code ci-dessus définit une variable ' sur une ' avec une valeur de 20 et utilise une instruction if pour vérifier si elle est supérieure à 5. Si c'est le cas, le programme affiche ' num est supérieur à 5 “. Enfin, il imprime la valeur de ' sur une “.
Sortir
2 : instruction if-else
L'instruction if-else est une modification de l'instruction if qui permet l'exécution de différents blocs de code selon que la condition est vraie ou fausse.
si ( condition ) {// code à exécuter si l'état est vrai
} autre {
// code à exécuter si l'état est FAUX
}
En conséquence, le premier bloc de code sera exécuté si la condition est vraie, et le deuxième bloc de code sera exécuté si la condition est fausse.
Considérez le code suivant comme exemple :
#includeint main ( )
{
nombre entier = dix ;
si ( sur une > 5 )
{
printf ( 'num est supérieur à 5 \n ' ) ;
} autre {
printf ( 'num est inférieur à 10' ) ;
}
retour 0 ;
}
Le programme ci-dessus crée la variable num et lui donne la valeur 10. Ensuite, à l'aide d'un si déclaration , il détermine si le ' sur une ” est supérieur à 5. Le “ num est supérieur à 5 ' est imprimé si le ' sur une » dépasse 5. Il affiche « num est inférieur à 10 ” si num n'est pas supérieur à 5. Le programme renvoie alors 0, signifiant qu'il s'est exécuté avec succès.
Sortir
3: déclaration de commutateur
Un autre outil important pour la prise de décision en programmation C est le changer déclaration. Le changer l'instruction vérifie des conditions spécifiques, tout comme instructions if-else faire, mais il peut vérifier plusieurs possibilités pour cette condition. Ceci est utile lorsque nous avons affaire à de nombreux résultats différents.
La syntaxe d'utilisation du déclaration de commutateur en programmation C est :
changer ( expression ) {cas constante1 :
// code à exécuter si expression est égale à constante1
casser ;
cas constante2 :
// code à exécuter si expression est égale à constante2
casser ;
...
défaut:
// code à exécuter si aucun des cas ne correspond
casser ;
}
Expression est la variable évaluée dans ce cas, et la déclarations de cas inclure les valeurs qui lui sont comparées.
Considérez le code suivant comme exemple :
#includeint main ( ) {
nombre entier = 2 ;
changer ( sur une ) {
cas 1 :
printf ( 'le nombre est 1' ) ;
casser ;
cas 2 :
printf ( 'le nombre est 2' ) ;
casser ;
cas 3 :
printf ( 'le nombre est 3' ) ;
casser ;
défaut:
printf ( 'nombre autre que 1, 2 et 3' ) ;
casser ;
}
retour 0 ;
}
Le programme ci-dessus montre comment utiliser l'instruction switch pour examiner la valeur de la variable ' sur une ” et exécutez le bloc de code correspondant. Dans ce cas, puisque « sur une ' est initialisé à 2, la sortie sera ' le nombre est 2 “.
Sortir
4 : Imbriqué si
Instructions if imbriquées sont des instructions de branchement qui sont intégrées dans d'autres instructions if imbriquées. Il permet une logique de branchement plus complexe en vérifiant plusieurs conditions dans d'autres instructions conditionnelles. L'intérieur si les déclarations ne sont exécutés que si les instructions if externes ont la valeur true.
La syntaxe de base pour instructions if imbriquées sont donnés ci-dessous :
si ( condition ) {si ( expression ) {
Bloc de déclarations ;
} autre {
Bloc de déclarations ;
}
} autre {
Bloc de déclarations ;
}
Considérez le code suivant comme exemple :
#includeint main ( ) {
entier num1 = 1 ;
entier num2 = quinze ;
entier num3 = 7 ;
si ( num1 > num2 ) {
si ( num1 > numéro 3 ) {
printf ( 'num1=1 est le plus grand nombre \n ' ) ;
}
autre {
printf ( 'num3=7 est le plus grand nombre \n ' ) ;
}
}
autre {
si ( num2 > numéro 3 ) {
printf ( 'num2=15 est le plus grand nombre \n ' ) ;
}
autre {
printf ( 'num3=7 est le plus grand nombre \n ' ) ;
}
}
retour 0 ;
}
Le programme ci-dessus compare trois nombres entiers, ' num1 ', ' num2 ', et ' numéro 3 “, et utilise des instructions if imbriquées pour déterminer laquelle est le plus grand nombre. Il compare d'abord ' num1 ' et ' num2 ', puis compare le plus grand de ces deux avec' numéro 3 “. La sortie indiquera quelle variable a la plus grande valeur.
Sortir
5 : Échelle sinon si
Nous pouvons facilement résoudre un problème complexe lorsque de nombreux critères sont présents dans un ordre séquentiel en employant un échelle-si ou expression else-if .
Ci-dessous la syntaxe de échelle sinon si déclaration:
si ( condition1 ){
Bloc de déclarations ;
}
autre si ( condition2 )
{
Bloc de déclarations ;
}
autre si ( état3 )
{
Bloc de déclarations ;
}
autre
{
déclaration par défaut
}
Considérez le code suivant comme exemple :
#includeint main ( ) {
marques int = 80 ;
si ( Des marques > = 90 && marques = 80 && marques = 70 && marques = 60 && marques = cinquante && Des marques < 60 ) {
printf ( 'Note : D' ) ;
}
autre {
printf ( 'Note : Échec' ) ;
}
retour 0 ;
}
Le programme ci-dessus emploie logique if-else pour déterminer une note en fonction de la valeur courante de la variable « notes ». En fonction de la valeur des 'notes', le programme produira une note correspondante allant de A + à Échec.
Sortir
6 : Pause Déclaration
Le déclaration de rupture est une instruction de flux de contrôle importante dans la programmation C qui permet aux programmeurs de contrôler le comportement des boucles et des instructions de commutation. Le déclaration de rupture a deux applications en programmation C :
- Lorsqu'une boucle atteint un casser instruction, elle se termine immédiatement et le contrôle du programme est confié à l'instruction qui suit la boucle.
- Il peut être utilisé pour terminer un cas en l'utilisant pour l'instruction switch.
La syntaxe pour le casser déclaration:
casser ;Regardez l'exemple de code :
#includeint main ( ) {
nombre entier = 12 ;
alors que ( sur une quinze ) {
casser ;
}
}
retour 0 ;
}
Ce morceau de code C déclare une boucle while qui s'exécute tant que la variable entière ' sur une ' est inférieur à 22 et l'initialise à 12. Dans la boucle, ' sur une ” est augmenté de 1 et sa valeur est signalée à la console à l'aide de printf . La boucle se termine alors par un instruction break si 'num' est supérieur à 15 tel que déterminé par une instruction if. Ce code termine effectivement la boucle après avoir imprimé les valeurs de 'num' entre 12 et 15 (inclus). Le programme se termine en retournant 0, ce qui montre qu'il s'est exécuté correctement.
Sortir
7 : continuer Déclaration
En programmation C, le continuer déclaration est similaire à la casser déclaration. Au lieu d'imposer la terminaison, il force la prochaine itération de la boucle et ignore tout code entre les deux. Les sections de test conditionnel et d'incrémentation de la boucle for sont exécutées par le continuer expression. Les tests conditionnels des boucles while et do-while sont passés par le contrôle du programme à la suite de la continuer déclaration.
Syntaxe de continuer les déclarations est:
continuer ;Regardez cet exemple.
#includeint main ( ) {
nombre entier = 12 ;
alors que ( sur une quinze ) {
continuer ;
}
}
retour 0 ;
}
La boucle while du programme ci-dessus est utilisée pour imprimer la valeur de la variable ' sur une ” s'il est inférieur à 22. Si “ sur une » dépasse 15 pendant la boucle, le continuer est exécutée et l'itération actuelle de la boucle est ignorée. Dans ce cas, la boucle s'exécutera cinq fois, en imprimant la valeur de 'num' à chaque fois, jusqu'à ce que ' sur une » atteint 16 et la boucle saute l'itération où « sur une » est 16, puis continue avec les itérations restantes jusqu'à ce que la boucle soit terminée.
Sortir
Conclusion
La prise de décision et ramification sont des composants critiques du langage C qui permettent de créer des applications complexes et interactives qui gèrent diverses conditions du monde réel. Les instructions conditionnelles, if-else et switch, sont les principaux cas utilisés dans la création décisionnel algorithmes. Bien que ramification peut poser un défi dans l'organisation des codes, avec une planification et une exécution appropriées, les programmeurs peuvent créer des programmes efficaces et sans erreur qui répondent à des exigences spécifiques.