Wanneer we in C++ het codeblok moeten herhalen, gebruiken we de “loops” op die plaats. Dit vermindert onze tijd voor het steeds opnieuw typen van dezelfde code. We gebruiken de “loops” in C++ om een codegedeelte te herhalen. De “loops”-methode is een zeer efficiënt en tijdbesparend proces bij het programmeren in C++. Er zijn verschillende soorten lussen die door de C++-taal worden geboden, zoals 'for loop', 'while loop', 'do-while loop' en 'nested loop'. De “geneste lus” betekent dat we twee lussen in elkaar plaatsen, of we kunnen ook zeggen dat in één lus een andere lus zit.
Hier zullen we in deze handleiding alleen de “geneste” lussen in C++ onderzoeken. De codes waarin we deze “geneste” lussen gebruiken, zijn als volgt:
Voorbeeld 1:
We moeten het headerbestand opnemen terwijl we in C++ werken, dus nemen we hier het headerbestand “iostream” op. De headerbestanden zijn opgenomen zodat we de methoden of functies in onze code kunnen gebruiken die daarin worden gedeclareerd. Daaronder voegen we de naamruimte “std” toe en roepen op die plaats de methode “main()” aan.
Vervolgens gebruiken we de “for”-lus waarin we ook nog een “for”-lus plaatsen; het wordt de 'geneste for-lus' genoemd. In de eerste “for”-lus initialiseren we de “a”-variabele van het “int”-gegevenstype met “1”. Hier wordt ook de voorwaarde geplaatst die zegt “a <= 3” en vervolgens “++a” verhoogt in de waarde van “a”. We plaatsen de “cout” onder deze “for”-lus om hier wat tekst af te drukken. In de volgende “for”-lus initialiseren we een “b”-variabele van het datatype “int” met de waarde “1”. De voorwaarde die we hier toevoegen is “b <= 4” en deze wordt ook verhoogd. We plaatsen nog een “cout” onder deze “genest voor”.
Code1:
#includenamespace std; gebruiken;
int. hoofd ( ) {
voor ( int a = 1 ; A < = 3 ; ++ een ) {
uit << ' Mijn for-lus: ' << A << eind;
voor ( int b = 1 ; B < = 4 ; ++b ) {
uit << ' Mijn geneste lus: ' << B << eind;
}
}
opbrengst 0 ;
}
Uitgang:
Het resultaat van de gegeven “geneste lus” wordt nu hier weergegeven. De eerste “cout”-instructie verschijnt drie keer terwijl we de voorwaarde hebben aangepast naar “3”, en de tweede “cout”-instructie verschijnt vier keer terwijl we de voorwaarde hebben aangepast naar “4” in de code.
Voorbeeld 2:
De functie “main()” wordt aangeroepen. Vervolgens initialiseren we de variabelen “myNewWeek” en “weekDays” met respectievelijk de waarden “2” en “7”. De “geneste for-lus” die we hieronder gebruiken, bestaat uit twee “for”-lussen die we in elkaar plaatsen. De voorwaarde “i <= myNewWeek” en de “++i”-verhoging in de waarde van “i” worden hier in de eerste “for”-lus geplaatst waar we de “i”-variabele van het gegevenstype “int” initialiseren met “1”. We plaatsen de “cout” onder deze “for”-lus om hier wat tekst af te drukken. We initialiseren een variabele genaamd “j” van het datatype “int” met de waarde “1” in de volgende “for” lus.
Hier voegen we de voorwaarde “j <= weekDays” toe en verhogen deze. Een andere “cout” bevindt zich onder deze “genest voor”-lus.
Code2:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int mijnNieuweWeek = 2 , weekDagen = 7 ;
voor ( int ik = 1 ; i < = mijnNieuweWeek; ++ik ) {
uit << 'De week is:' << i << eind;
voor ( int j = 1 ; J < = weekdagen; ++j ) {
uit << ' De dag van de week is: ' << J << eind;
}
}
opbrengst 0 ;
}
Uitgang:
Dit is hoe de eerder genoemde “geneste lus” nu wordt weergegeven. De code toont nu drie exemplaren van de eerste “cout”-instructie (waarvan de voorwaarde is vastgesteld op “2”) en vier exemplaren van de tweede “cout”-instructie (waarvan de voorwaarde is vastgesteld op “7”).
Voorbeeld 3:
Hier willen we het “@”-symbool weergeven in een driehoekig patroon met de “geneste voor”-lus. Hiervoor plaatsen we de eerste “for”-lus en passen we de voorwaarde aan naar “i <= 6” na het initialiseren van de “int i”-variabele met de waarde “1”.
Vervolgens passen we ook de verhoging van de waarde van “i” toe. Daaronder hebben we nog een “for” waarin we een andere voorwaarde plaatsen die zegt “j <= i” na het initialiseren van de “j” variabele als de “int” met de waarde “1”. De waarde van deze “j”-variabele wordt hier ook verhoogd. Nu voegen we de “cout” toe waar het “@” -symbool is geplaatst. Dit geeft het “@”-symbool driehoekig weer.
Code 3:
#includenamespace std; gebruiken;
int. hoofd ( ) {
voor ( int ik = 1 ; i < = 6 ; ik++ ) {
voor ( int j = 1 ; J < = ik; j++ ) {
uit << '@' ;
}
uit << eind;
}
opbrengst 0 ;
}
Uitgang:
We krijgen dit resultaat vanwege de “geneste lus” die we in de meegeleverde code hebben gebruikt. Hier kunnen we zien dat het “@”-symbool in een driehoekig patroon verschijnt.
Voorbeeld 4:
We willen de “geneste voor”-lus gebruiken om het “@”-symbool in een driehoekig patroon weer te geven. Om dit te doen, plaatsen we de eerste 'for' -lus. Vervolgens initialiseren we de variabele “int a” met de waarde “1” en stellen we de voorwaarde in op “a <= 8”. Vervolgens verhogen we in dit geval ook de waarde van “a”. Dan hebben we nog een “for” waarbij we de “b” variabele initialiseren als de “int” met de waarde “1” met een andere voorwaarde die “b <= a” aangeeft. De waarde van “a” wordt eveneens verhoogd. De 'cout' is nu toegevoegd waar we het '*'-symbool plaatsen. Dit zorgt er nu voor dat de console het “*”-teken in een driehoekig patroon weergeeft.
Code 4:
#includenamespace std; gebruiken;
int. hoofd ( ) {
voor ( int a = 1 ; A < = 8 ; een++ ) {
voor ( int b = 1 ; B < = een; b++ ) {
uit << '* ' ;
}
uit << eind;
}
opbrengst 0 ;
}
Uitgang:
We hebben dit resultaat verkregen door een 'geneste lus' in de bovengenoemde code te gebruiken. Hier kunnen we zien dat het “@”-symbool in een driehoek is gerangschikt.
Voorbeeld 5:
Nu willen we alleen het priemgetal weergeven. We declareren dus de variabelen “x” en “y” als de variabelen “int”. Vervolgens plaatsen we twee “for”-lussen achter elkaar, waarvan wordt gezegd dat ze de “geneste for”-lus zijn. De eerste lus bevat de voorwaarde die “x <= 50” is na het initialiseren van de “x” variabele met “2”. We voeren ook de verhoging van de waarde van “x” in deze lus uit.
Dan hebben we nog een lus waarin we nog een voorwaarde toevoegen die zegt “y <= (x/y)” nadat we een “2”-waarde hebben toegewezen aan de “y”-variabele. We verhogen ook de waarde van “y” binnen deze lus. Hieronder gebruiken we de “if” die de voorwaarde “!(x%y)” controleert. Als de factor hier niet wordt gevonden, wordt die waarde niet afgedrukt als we de “break”-instructie toevoegen en naar de tweede “if” gaan die we hieronder toevoegen. Hier controleert het opnieuw de voorwaarde, namelijk “y > (x/y)”. Als het waar is, wordt die waarde afgedrukt en ook 'is een priemgetal'.
Code 5:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int x, y;
voor ( x = 2 ; X < = vijftig ; x++ ) {
voor ( j = 2 ; En ( X / En ) ) uit << X << ' is een priemgetal.' << eind;
}
opbrengst 0 ;
}
Uitgang:
Nu worden hier alle priemgetallen weergegeven die we krijgen na het toepassen van de 'geneste voor' -lus in onze code.
Conclusie
Deze handleiding gaat helemaal over de geneste lussen in C++ en legt uit dat we de “geneste lussen” gebruiken wanneer we de herhaling van de codesectie willen. We hebben dit concept grondig onderzocht en geleerd hoe we de ‘geneste lussen’ in onze codes kunnen gebruiken. We hebben verschillende voorbeelden gedemonstreerd waarin we de “geneste lussen” hebben gebruikt, samen met hun uitleg, en de resultaten van al deze codes hier in deze handleiding weergegeven.