Преглед садржаја:
- Шта је вхиле петља у Ц++
- Синтакса вхиле петље
- Како користити вхиле петљу у Ц++
- Ц++ Нестед вхиле Лооп
- Ц++ Бесконачна вхиле петља
- Штампање парних и непарних бројева са вхиле петљама у Ц++
- Закључак
Шта је вхиле петља у Ц++
Док петља је контролна структура која ће наставити да ради све док се услов процењује као тачан, а зауставиће се када услов постане нетачан. Корисно је у случајевима када желите да поновите одређени задатак док се не испуни одређени услов.
На пример , можете користити вхиле петљу да одштампате бројеве од 1 до 10 или израчунате факторијел датог броја.
Синтакса вхиле петље
Основна синтакса вхиле петље у Ц++ је следећа:
док ( стање ) {
// код који треба извршити
}
Код унутар витичастих заграда ће се извршавати више пута све док је услов истинит. Услов ће се проверавати сваки пут када се петља покрене.
Како користити вхиле петљу у Ц++
Један од најчешћих примера док се петље рачунају од почетне до крајње тачке. На пример, следећи код ће се бројати од 1 до 10:
#инцлуде <иостреам>користећи простор имена стд ;
инт главни ( ) {
инт и = 1 ; // иницијализује променљиву бројача на 1
// петља док је променљива бројача мања или једнака 10
док ( и <= 10 ) {
цоут << и << ендл ; // излази тренутна вредност променљиве бројача
и ++; // повећавамо променљиву бројача
}
повратак 0 ;
}
Овај код показује како се користи вхиле петља у Ц++. Програм иницијализује променљиву бројача и до 1, а затим извршава вхиле петљу која ће наставити да се изводи до и постаје већи од 10.
Унутар вхиле петље, тренутна вредност променљиве бројача се штампа на конзоли помоћу цоут изјаву, након чега следи прелом реда користећи ендл . Променљива бројача се затим повећава за 1 коришћењем и++ изјава.
Петља наставља да се извршава до променљиве бројача и достиже вредност од 11, у ком тренутку се излази из вхиле петље и програм се завршава повратном вредношћу од 0.
Ц++ Нестед вхиле Лооп
Док петље такође могу бити угнездио , што значи да можете имати вхиле петљу унутар друге вхиле петље. Ово је корисно у случајевима када треба да извршавате задатак узастопно док се не испуни одређени услов, а у оквиру тог задатка треба да обављате други задатак више пута док се не испуни други услов.
У угнежђеној вхиле петљи, спољна петља се извршава једном, а затим ће се унутрашња извршити сваки пут када се покрене спољна петља. Унутрашња петља се извршава у потпуности једном за сваку итерацију спољашње петље.
Пример
Следи пример кода коришћења Нестед вхиле петље у Ц++:
#инцлуде <иостреам>користећи простор имена стд ;
инт главни ( ) {
инт и = 1 ; // иницијализује променљиву бројача на 1
// петља док је променљива бројача мања или једнака 3
док ( и <= 3 ) {
инт ј = 1 ; // иницијализује променљиву унутрашњег бројача на 1
// петља док је променљива унутрашњег бројача мања или једнака 3
док ( ј <= 3 ) {
цоут << и << ' ' << ј << ' \н ' ; // излази тренутне вредности променљивих бројача
ј ++; // инкремент променљиве унутрашњег бројача
}
и ++; // повећавамо спољашњу променљиву бројача
}
повратак 0 ;
}
У овом коду, спољна вхиле петља траје све док и постаје једнако 3, када је вредност од и постане већи од 3, петља ће се зауставити. Са сваком итерацијом спољне петље, променљива унутрашњег бројача ј је иницијализован на 1 и извршава унутрашњу вхиле петљу. Ова унутрашња петља ће се изводити до вредности од ј постаје већи од 3 .
Унутар унутрашње петље излазимо вредности од и и ј . Након тога смо повећали ј . Ово се наставља све док се унутрашња петља не изврши три пута. Сваки пут када се спољна петља повећава, унутрашња петља ће такође бити поново извршена.
Овај процес се понавља све док се спољна петља не изврши три пута и док се обе петље не заврше. Излаз овог кода је табела вредности у распону од 1 1 до 3 3, као што је приказано на слици испод.
Ц++ Бесконачна вхиле петља
У Ц++ бесконачне вхиле петље су такође могуће. Бесконачна вхиле петља ради континуирано јер ниједан дефинисан услов не може бити лажан. Постоји само један истинит услов , ово омогућава да се вхиле петља изводи непрекидно бесконачан број пута.
На пример , доле дата петља ће се извршавати заувек и да бисмо зауставили ову петљу морамо да дефинишемо наредбу бреак на крају ове петље.
док ( истина ) {// код који треба извршити
}
Бесконачна петља може бити корисна у неким случајевима, као што је у уграђеним системима или када се чека кориснички унос.
Пример
Испод је пример Ц++ програма који покреће бесконачну вхиле петљу у Ц++ коду:
#инцлуде <иостреам>користећи простор имена стд ;
инт главни ( ) {
инт цоунт = 0 ;
док ( истина ) {
цоут << „Инфинитив Вхиле Лооп \н ' ;
цоунт ++;
ако ( цоунт >= 10 ) {
пауза ;
}
}
повратак 0 ;
}
Дати код креира бесконачну петљу која континуирано емитује стринг „Инфинитиве Вхиле Лооп“ на конзолу. То је зато што је услов петље вхиле постављен на тачно, што је увек тачно, петља се неће завршити.
Да бисмо зауставили бесконачну петљу, можемо користити наредбу бреак да изађемо из петље када се испуни одређени услов. У горњем програму поставили смо максималан број итерација на 10, што контролише цоунт променљиву и наредбу бреак.
Горњи код ће се изводити бесконачно, али коришћење наредбе бреак ће га зауставити након 10 итерација.
Штампање парних и непарних бројева помоћу вхиле петље
Још један пример док петље штампају парне и непарне бројеве. На пример , следећи код користи вхиле петљу у Ц++ за излаз парних бројева од 2 до 10.
#инцлуде <иостреам>користећи простор имена стд ;
инт главни ( ) {
инт и = 2 ; // иницијализује променљиву бројача на 2
// петља док је променљива бројача мања или једнака 10
док ( и <= 10 ) {
цоут << и << ендл ; // излази тренутна вредност променљиве бројача
и += 2 ; // повећај променљиву бројача за 2
}
повратак 0 ;
}
Овај Ц++ код иницијализује променљиву бројача и до 2 и користи вхиле петљу да више пута изнесе вредност и све док је мањи или једнак 10. На свакој итерацији петље се повећава и за 2. Сваки пут када се петља покрене излаз ће бити одштампан на терминалу. Након што се петља заврши, програм враћа 0 да означи успешно извршење.
Слично томе, можемо и да штампамо одд бројеви од 1 до 9:
#инцлуде <иостреам>користећи простор имена стд ;
инт главни ( ) {
инт и = 1 ; // иницијализује променљиву бројача на 1
// петља док је променљива бројача мања или једнака 9
док ( и <= 9 ) {
цоут << и << ендл ; // излази тренутна вредност променљиве бројача
и += 2 ; // повећај променљиву бројача за 2
}
повратак 0 ;
}
У овом коду, услов петље ће се изводити до променљиве бројача и је мањи или једнак 9. Тхе цоут наредба унутар петље даје тренутну вредност и , а затим и и променљива се повећава за 2 помоћу и += 2 изјава. Ово осигурава да петља штампа само непарне бројеве.
На крају програма, наредба ретурн се користи да означи да је функција маин() завршена.
Закључак
Док петља је контролна структура која покреће програм све док је дефинисани услов истинит. Овде смо покрили основну синтаксу и примере коришћења вхиле петљи у Ц++. Такође описујемо како да користите вхиле петљу у угнежђеном облику и како се може покренути вхиле петљу бесконачан број пута. За више детаља о Ц++ вхиле петљи, прочитајте чланак.