En programmation C++, il existe diverses situations dans lesquelles nous devons vérifier les conditions. Parfois, nous devons satisfaire plusieurs conditions simultanément. Nous utilisons pour cela la condition « imbriqué si » dans la programmation C++. Si l’on place la condition « si » à l’intérieur de l’autre « si », on dit que c’est le « si imbriqué ». Lorsque la première condition « si » est satisfaite, nous nous déplaçons à l’intérieur de ce « si » où nous plaçons un autre « si ». Ensuite, il vérifie la condition « si » qui est placée à l’intérieur de la première condition « si », et ainsi de suite. Il renvoie le résultat que l'on place à l'intérieur du « si » lorsque toutes les conditions sont satisfaites.
Exemple 1:
Faisons quelques codes dans lesquels nous utilisons le « if imbriqué ». Pour commencer le code C++, nous incluons ici le fichier d'en-tête « iostream », puis l'espace de noms « std ». Après cela, nous plaçons le code du pilote « main() » et initialisons trois variables, « n1 », « n2 » et « n3 », avec les valeurs « 20 », « 10 » et « 2 », respectivement. Ensuite, nous utilisons ici la condition « si » dans laquelle nous vérifions si « n1 » est supérieur à « n2 ». Si cette condition est satisfaite, nous avançons à l’intérieur de ce « si » où nous ajoutons une autre condition « si ».
Maintenant, le deuxième « if » vérifie les valeurs « n1 » supérieures à « n3 ». Si cette condition « imbriquée si » est également satisfaite, l'instruction située en dessous est exécutée dans laquelle nous plaçons l'instruction « cout ». Ainsi, il imprime cette instruction si les deux conditions du « if imbriqué » sont satisfaites dans ce code. Si l’une des conditions est fausse, aucun message n’apparaîtra sur la console.
Codage 1 :
#include
en utilisant l'espace de noms std ;
int main ( )
{
tu n1 = vingt , n2 = dix , n3 = 2 ;
si ( n1 > n2 ) {
si ( n1 > n3 ) {
cout << ' n1 est la plus grande valeur qui est ' << n1 << fin;
}
}
retour 0 ;
}
Sortir:
Ici, il affiche l'instruction sur la console qui signifie que les deux conditions « si » du « si imbriqué » sont vraies. L'instruction que nous avons ajoutée à l'intérieur du « if imbriqué » est également rendue ici.
Exemple 2 :
L'espace de noms « std » et le fichier d'en-tête « iostream » sont inclus ici pour démarrer le code C++. Le code du pilote « main() » est ensuite inséré et trois variables, « var1 », « var2 » et « var3 », sont initialisées avec les valeurs de « 8 », « 91 » et « 32 », respectivement.
Ensuite, nous utilisons la condition « if » pour déterminer si « val1 » est plus petit que « val2 ». Si cette condition est remplie, nous continuons dans la condition « si » et ajoutons une autre condition « si ». Le deuxième 'if' vérifie désormais si la valeur 'val1' est inférieure à 'val3'. Si cette condition « imbriquée si » est également remplie, l'instruction placée à l'intérieur du « cout » est exécutée ci-dessous. Ainsi, si les deux conditions « imbriquées si » sont remplies dans ce code, il imprime cette instruction. La console n'affichera aucun message si les conditions sont fausses.
Code 2 :
#includeen utilisant l'espace de noms std ;
int main ( )
{
int var1 = 8 ,var2 = 91 ,var3 = 32 ;
si ( var1 < var2 ) {
si ( var1 < var3 ) {
cout << ' var1 est la plus petite valeur qui est ' << var1 << fin;
}
}
retour 0 ;
}
Sortir:
L'instruction que nous avons ajoutée dans le « if imbriqué » est maintenant rendue ici. Le message sur la console indique que les deux conditions « if » du « if imbriqué » sont vraies.
Exemple 3 :
Ici, dans « main() », nous initialisons les variables nommées « x », « y » et « z » avec les valeurs de « 11 », « 22 » et « 33 », respectivement. Ensuite, nous utilisons un « si » dans lequel nous plaçons la condition qui est « x == 11 » et plaçons un autre « si » à l'intérieur de ce « si » qui est le « si imbriqué » où nous ajoutons le « y == 22 ». condition. Ce « si imbriqué » n'est mis en œuvre que lorsque la première condition « si » est remplie.
Après cela, nous utilisons un « si » supplémentaire à l'intérieur du deuxième « si » qui est exécuté lorsque les deux « si » que nous avons ajoutés précédemment sont satisfaits. Le troisième « if » contient la condition « z == 33 » et nous incluons le « cout » à l'intérieur de la dernière condition « if ». Cela ne s'exécutera que lorsque les trois conditions « si » sont vraies.
Code 3 :
#includeen utilisant l'espace de noms std ;
int main ( )
{
entier x = onze , y = 22 , z = 33 ;
si ( x == onze ) {
si ( et == 22 ) {
si ( avec == 33 ) {
cout << 'Hé ! C++ imbriqué si ici !!' << fin;
}
}
}
retour 0 ;
}
Sortir:
Ce résultat montre que toutes les conditions « imbriquées si » sont satisfaites. L'instruction à l'intérieur du dernier « si » est affichée ici. Cette déclaration n’apparaîtra pas ici si l’une des conditions répertoriées est fausse.
Exemple 4 :
Les variables « ch1 », « ch2 » et « ch3 » sont initialisées en tant que type de données « char » avec les caractères « a », « b » et « z » après avoir invoqué la fonction « main() ». Ensuite, nous employons une instruction « if » avec la condition « ch1 == a » et un autre « if » à l'intérieur (appelé « if imbriqué ») avec la condition supplémentaire « ch2 == b ». Cela signifie que ce n'est que lorsque la première condition « si » est remplie que ce « si imbriqué » sera exécuté.
Par la suite, nous employons un « si » supplémentaire dans le deuxième « si » qui est effectué lorsque les deux conditions « si » précédemment insérées sont satisfaites. La condition « ch3 == z » se retrouve dans le troisième « if » et le mot « cout » est présent dans la dernière condition « if ». Cela ne sera possible que si toutes les conditions sont remplies.
Code 4 :
#includeen utilisant l'espace de noms std ;
int main ( )
{
caractère ch1 = 'un' , ch2 = 'b' , ch3 = 'Avec' ;
si ( ch1 == 'un' ) {
si ( ch2 == 'b' ) {
si ( ch3 == 'Avec' ) {
cout << 'La programmation C++ imbriquée si.. !!' << fin;
}
}
}
retour 0 ;
}
Sortir:
La phrase à l'intérieur du dernier « si » est affichée ici, ce qui indique que toutes les conditions « imbriquées si » sont satisfaites. Cette déclaration n’apparaîtra pas ici si l’une des conditions est fausse.
Exemple 5 :
Après avoir appelé la méthode « main() », les variables « f1 », « f2 » et « f3 » sont initialisées en tant que type de données « float » avec les valeurs « 2.40 », « 19.7 » et « 43.1 ». Ensuite, nous utilisons une instruction « if » avec la condition « f1 == 2,40 » et un autre « if » (également connu sous le nom de « if imbriqué ») avec la condition « f2 == 19,7 » à l'intérieur. Cela indique que ce « si imbriqué » ne sera effectué que si la première condition « si » est remplie.
Ensuite, nous utilisons le troisième « if » à l'intérieur du deuxième « if » qui est exécuté si les deux conditions « if » précédemment ajoutées sont remplies. La troisième condition « if » a la condition « f3 == 9 », et la dernière condition « if » contient le « cout ». Ce n'est que dans une situation où les trois conditions sont remplies que cette instruction 'cout' s'affichera. Ensuite, en dehors de toutes ces conditions « si », nous ajoutons également le « cout » qui est rendu lorsque la condition « si » n'est pas vraie.
Code 5 :
#includeen utilisant l'espace de noms std ;
int main ( )
{
flotteur f1 = 2h40 , f2 = 19.7 , f3 = 43.1 ;
si ( f1 == 2h40 ) {
si ( f2 == 19.7 ) {
si ( f3 == 9 ) {
cout << 'Tous imbriqués si les conditions sont vraies ici !!' << fin;
}
}
}
cout << ' La condition du if imbriqué n'est pas satisfaite..!! ' << fin;
retour 0 ;
}
Sortir:
Ici, il affiche l'instruction que nous avons ajoutée en dehors de la condition « imbriqué si » et montre que la condition « imbriqué si » n'est pas satisfaite.
Conclusion
Le concept de « if imbriqué » en C++ est appris en profondeur ici. Nous avons exploré le fait que « si imbriqué » signifie que nous avons placé une condition « si » à l'intérieur de l'autre condition « si ». Nous avons utilisé cette condition « imbriquée si » dans laquelle nous devions remplir de nombreuses conditions simultanément. Nous avons exploré quelques exemples dans lesquels nous avons utilisé la condition « imbriqué si » dans nos codes C++ et expliqué comment cela fonctionne.