Zagnieżdżone If w C++

Zagniezdzone If W C



W programowaniu w C++ są różne sytuacje, w których musimy sprawdzić warunki. Czasami musimy spełnić wiele warunków jednocześnie. Wykorzystujemy do tego warunek „zagnieżdżony jeśli” w programowaniu w C++. Jeśli umieścimy warunek „jeśli” wewnątrz drugiego „jeśli”, mówimy, że jest to „zagnieżdżony warunek”. Kiedy pierwszy warunek „jeśli” jest spełniony, wchodzimy do środka „jeśli”, gdzie umieszczamy kolejny „jeśli”. Następnie sprawdza warunek „jeśli” umieszczony wewnątrz pierwszego warunku „jeśli” i tak dalej. Zwraca wynik, który umieszczamy wewnątrz „jeśli”, gdy wszystkie warunki zostaną spełnione.

Przykład 1:







Zróbmy kilka kodów, w których wykorzystamy „zagnieżdżone if”. Aby rozpocząć kod C++, dołączamy tutaj plik nagłówkowy „iostream”, a następnie przestrzeń nazw „std”. Następnie umieszczamy kod sterownika „main()” i inicjujemy trzy zmienne „n1”, „n2” i „n3” z wartościami odpowiednio „20”, „10” i „2”. Następnie wykorzystujemy tutaj warunek „if”, w którym sprawdzamy, czy „n1” jest większe niż „n2”. Jeśli ten warunek jest spełniony, przechodzimy dalej w tym „jeśli”, gdzie dodajemy kolejny warunek „jeśli”.



Teraz drugie „if” sprawdza wartości „n1”, które są większe niż „n3”. Jeżeli warunek „zagnieżdżony if” jest również spełniony, wykonywana jest poniższa instrukcja, w której umieszczamy instrukcję „cout”. Zatem drukuje tę instrukcję, jeśli w tym kodzie spełnione są oba warunki „zagnieżdżonego if”. Jeśli którykolwiek z warunków jest fałszywy, na konsoli nie zostanie wyświetlony żaden komunikat.



Kod 1:





#include
używając przestrzeni nazw std;
int główny ( )
{
ty n1 = 20 , n2 = 10 , n3 = 2 ;
Jeśli ( n1 > n2 ) {
Jeśli ( n1 > n3 ) {
cout << „ n1 to największe wartości, czyli „ << n1 << koniec;
}
}
powrót 0 ;
}

Wyjście:



Tutaj pokazuje instrukcję na konsoli, która oznacza, że ​​oba warunki „if” z „zagnieżdżonego if” są prawdziwe. Instrukcja, którą dodaliśmy wewnątrz „zagnieżdżonego if”, jest również renderowana tutaj.

Przykład 2:

Przestrzeń nazw „std” i plik nagłówkowy „iostream” znajdują się tutaj, aby uruchomić kod C++. Następnie wstawiany jest kod sterownika „main()”, a trzy zmienne „var1”, „var2” i „var3” są inicjowane odpowiednio wartościami „8”, „91” i „32”.

Następnie używamy warunku „if”, aby określić, czy „val1” jest mniejszy niż „val2”. Jeśli ten warunek jest spełniony, kontynuujemy warunek „jeśli” i dodajemy kolejny warunek „jeśli”. Drugie „if” sprawdza teraz, czy wartość „val1” jest mniejsza niż „val3”. Jeśli spełniony jest również warunek „zagnieżdżony if”, instrukcja umieszczona wewnątrz „cout” zostanie uruchomiona w następujący sposób. Zatem, jeśli w tym kodzie spełnione są oba warunki „zagnieżdżonego if”, drukuje tę instrukcję. Konsola nie wyświetli żadnego komunikatu, jeśli warunki nie będą spełnione.

Kod 2:

#include
używając przestrzeni nazw std;
int główny ( )
{

int zmienna1 = 8 , zmienna2 = 91 , zmienna3 = 32 ;
Jeśli ( zm.1 < zmienna2 ) {
Jeśli ( zm.1 < var3 ) {
cout << „var1 to najmniejsza wartość, która wynosi” << zm.1 << koniec;
}
}
powrót 0 ;
}

Wyjście:

Instrukcja, którą dodaliśmy w ramach „zagnieżdżonego if”, jest teraz wyświetlana tutaj. Komunikat na konsoli wskazuje, że oba warunki „if” w „zagnieżdżonym if” są prawdziwe.

Przykład 3:

Tutaj, w „main()”, inicjujemy zmienne o nazwach „x”, „y” i „z” wartościami odpowiednio „11”, „22” i „33”. Następnie używamy „if”, w którym umieszczamy warunek „x == 11” i umieszczamy w tym „if” kolejny „if”, czyli „zagnieżdżony if”, do którego dodajemy „y == 22” stan : schorzenie. To „zagnieżdżone if” jest implementowane tylko wtedy, gdy spełniony jest pierwszy warunek „if”.

Następnie używamy jeszcze jednego „jeśli” w drugim „jeśli”, które jest wykonywane, gdy oba „jeśli” są spełnione, co wcześniej dodaliśmy. Trzecie „if” zawiera warunek „z == 33”, a „cout” umieszczamy w ostatnim warunku „if”. Zostanie to wykonane tylko wtedy, gdy wszystkie trzy warunki „jeśli” zostaną spełnione.

Kod 3:

#include
używając przestrzeni nazw std;
int główny ( )
{
int x = jedenaście , y = 22 , z = 33 ;
Jeśli ( x == jedenaście ) {
Jeśli ( i == 22 ) {
Jeśli ( z == 33 ) {
cout << „Hej! C++ zagnieżdżony, jeśli tutaj!” << koniec;
}
}
}
powrót 0 ;
}

Wyjście:

Wynik ten pokazuje, że wszystkie zagnieżdżone warunki „jeśli” są spełnione. Tutaj wyświetlana jest instrukcja znajdująca się wewnątrz ostatniego „if”. To stwierdzenie nie pojawi się tutaj, jeśli którykolwiek z wymienionych warunków jest fałszywy.

Przykład 4:

Zmienne „ch1”, „ch2” i „ch3” są inicjowane jako typ danych „char” ze znakami „a”, „b” i „z” po wywołaniu funkcji „main()”. Następnie używamy instrukcji „if” z warunkiem „ch1 == a” i kolejnego „if” w środku (określanego jako „zagnieżdżony if”) z dodatkowym warunkiem „ch2 == b”. Oznacza to, że tylko wtedy, gdy spełniony zostanie pierwszy warunek „jeśli”, zostanie uruchomione zagnieżdżone polecenie „jeśli”.

Następnie w ramach drugiego „jeśli” stosujemy dodatkowe „jeśli”, które następuje po spełnieniu obu wcześniej wprowadzonych warunków „jeśli”. Warunek „ch3 == z” znajduje się w trzecim „if”, a słowo „cout” występuje w ostatnim warunku „if”. Stanie się to możliwe tylko wtedy, gdy zostaną spełnione wszystkie warunki.

Kod 4:

#include
używając przestrzeni nazw std;

int główny ( )
{

znak ch1 = 'A' , ch2 = 'B' , ch3 = 'z' ;

Jeśli ( kanał1 == 'A' ) {
Jeśli ( kanał2 == 'B' ) {
Jeśli ( rozdział 3 == 'z' ) {
cout << „Programowanie w C++ zagnieżdżone, jeśli…!!” << koniec;
}
}
}
powrót 0 ;
}

Wyjście:

Pokazane jest tutaj zdanie wewnątrz ostatniego „if”, które wskazuje, że wszystkie zagnieżdżone warunki „if” są spełnione. To stwierdzenie nie pojawi się tutaj, jeśli którykolwiek z warunków jest fałszywy.

Przykład 5:

Po wywołaniu metody „main()” zmienne „f1”, „f2” i „f3” są inicjalizowane jako typ danych „float” z wartościami „2.40”, „19.7” i „43.1”. Następnie używamy instrukcji „if” z warunkiem „f1 == 2,40” i kolejnej instrukcji „if” (znanej również jako „zagnieżdżona instrukcja if”) z warunkiem „f2 == 19,7” w środku. Oznacza to, że to „zagnieżdżone jeśli” zostanie wykonane tylko wtedy, gdy spełniony zostanie pierwszy warunek „jeśli”.

Następnie używamy trzeciego „if” wewnątrz drugiego „if”, które jest wykonywane, jeśli spełnione są oba wcześniej dodane warunki „if”. Trzeci warunek „if” ma warunek „f3 == 9”, a ostatni warunek „if” zawiera „cout”. Ta instrukcja „cout” zostanie wyrenderowana tylko w sytuacji, gdy zostaną spełnione wszystkie trzy wymagania. Następnie poza tymi wszystkimi warunkami „jeśli” dodajemy także „cout”, który jest renderowany, gdy warunek „jeśli” nie jest prawdziwy.

Kod 5:

#include
używając przestrzeni nazw std;

int główny ( )
{

pływak f1 = 2.40 , f2 = 19,7 , f3 = 43.1 ;
Jeśli ( f1 == 2.40 ) {
Jeśli ( f2 == 19,7 ) {
Jeśli ( f3 == 9 ) {
cout << „Wszystkie zagnieżdżone, jeśli warunki są tutaj spełnione!!” << koniec;
}
}
}
cout << 'Warunek zagnieżdżonego if nie jest spełniony..!! ' << koniec;
powrót 0 ;
}

Wyjście:

Tutaj wyświetla instrukcję, którą dodaliśmy poza warunkiem „zagnieżdżony, jeśli” i pokazuje, że warunek „zagnieżdżony, jeśli” nie jest spełniony.

Wniosek

Tutaj dokładnie poznaliśmy koncepcję „zagnieżdżonego if” w C++. Zbadaliśmy, że „zagnieżdżony jeśli” oznacza, że ​​umieściliśmy warunek „jeśli” wewnątrz drugiego warunku „jeśli”. Wykorzystaliśmy ten zagnieżdżony warunek „jeśli”, w którym musieliśmy spełnić wiele warunków jednocześnie. Przeanalizowaliśmy kilka przykładów, w których wykorzystaliśmy warunek „zagnieżdżony jeśli” w naszych kodach C++ i wyjaśniliśmy, jak to działa.