सी मध्ये नेस्टेड लूप

नेस्टेड लूपचा वाक्यरचना

baaRlaupa
{
AMtagaZtaRlaupa
{
// Aataila laupa sTeTmaenT.
}
// baa laupa sTeTmaenT.
}

बाह्य_लूप आणि इनर_लूप हे वैध पळवाट आहेत जे 'लूप' साठी 'लूप' किंवा 'डू-व्हेल' लूप असू शकतात.

लूपसाठी घरटे

लूपसाठी नेस्टेड म्हणजे कोणत्याही प्रकारचे लूप जे 'फॉर' लूपच्या आत परिभाषित केले जाते.

jaeMvh (AarMBa; AT; ALa tana)
{
jaeMvh(AarMBa; AT; ALa tana)
{
// Aataila laupa sTeTmaenT.
}
// baa laupa sTeTmaenT.
}

लूपसाठी नेस्टेडचे ​​उदाहरण

#vaapara <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
paunaZ Pna;// cala oaaeSanaa
laiha("pzavaiST kra D maulya cyaa n :");
// pzaDSZaitaRkritaRAahe D Pna saarnyaa.
jaeMvh(paunaZ mai=1;mai<=Pna;mai++) // baa laupa
{
jaeMvh(paunaZ jae=1;jae<=10;jae++) // Aataila laupa
{
laiha("%paunaZ\t",(mai*jae)); // mauna D maulya.
}
laiha("\n");
}

वरील कोडचे स्पष्टीकरण

प्रथम, 'मी' व्हेरिएबल 1 वर प्रारंभ केला आहे आणि नंतर प्रोग्राम कंट्रोल आय <= एन वर जातो. प्रोग्राम कंट्रोल 'i <= n' सत्य आहे की नाही याची तपासणी करते. जर अट सत्य असेल तर प्रोग्राम कंट्रोल आतील लूपवर जातो. स्थिती सत्य होईपर्यंत अंतर्गत लूप कार्यान्वित होईल. आतील लूपच्या अंमलबजावणीनंतर, नियंत्रण बाह्य लूपच्या अद्यतनावर परत जाते, म्हणजेच, i ++. लूप काउंटरचे मूल्य वाढविल्यानंतर, अट पुन्हा तपासली जाते, म्हणजेच, मी <= एन. जर अट सत्य असेल तर आतील लूप पुन्हा कार्यान्वित होईल. बाह्य लूपची स्थिती खरी होईपर्यंत ही प्रक्रिया चालू राहील.

लूप असताना घरटे

नेस्टेड असताना लूप म्हणजे कोणत्याही प्रकारचे लूप जे 'तर' लूपच्या आत परिभाषित केले आहे.

jaeMvhpayaZMta(AT)
{
jaeMvhpayaZMta(AT)
{
// Aataila laupa sTeTmaenT.
}
// baa laupa sTeTmaenT.
}

लूप असताना नेस्टेडचे ​​उदाहरण

#vaapara <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
paunaZ paMKtai; // cala oaaeSanaa
paunaZ staMBa; // cala oaaeSanaa
paunaZ ke=1; // cala AarMBa
laiha("pzavaiST kra D kzmaaMk cyaa paMKtai :"); // EnapauT D kzmaaMk cyaa paMKtai.
vacaa("%paunaZ",&paMKtai);
laiha("\PnTr D kzmaaMk cyaa staMBa :"); // EnapauT D kzmaaMk cyaa staMBa.
vacaa("%paunaZ",&staMBa);
paunaZ A[paMKtai][staMBa]; //2Rdi AWre oaaeSanaa
paunaZ mai=1;
jaeMvhpayaZMta(mai<=paMKtai) // baa laupa
{
paunaZ jae=1;
jaeMvhpayaZMta(jae<=staMBa) // Aataila laupa
{
laiha("%paunaZ\t",ke); // mauna D maulya cyaa ke.
ke++; // vaaW kaUMTr
jae++;
}
mai++;
laiha("\n");
}
}

वरील कोडचे स्पष्टीकरण.

आम्ही 2 डी अ‍ॅरे तयार केले आहे, म्हणजेच, इंट ए [पंक्ती] [स्तंभ]. प्रोग्राम 1 द्वारे 'मी' व्हेरिएबल प्रारंभ करतो. आता, कंट्रोल लूपवर फिरते आणि ही लूप अट सत्य आहे की नाही हे तपासते, त्यानंतर प्रोग्राम कंट्रोल आतील लूपवर जाते. आतील लूपच्या अंमलबजावणीनंतर, नियंत्रण बाह्य लूपच्या अद्यतनावर जाते, म्हणजेच, i ++. 'मी' चे मूल्य वाढविल्यानंतर, स्थिती (i <= पंक्ती) तपासली जाते. जर अट सत्य असेल तर नियंत्रण पुन्हा आतील लूपवर जाईल. बाह्य लूपची स्थिती खरी होईपर्यंत ही प्रक्रिया सुरूच आहे.

नेस्टेड करा .. लूप

नेस्टेड डू .. लूप म्हणजे कोणत्याही प्रकारचे लूप जे 'kra..' लूपच्या आत परिभाषित केले जाते.

kra
{
kra
{
// Aataila laupa sTeTmaenT.
}jaeMvhpayaZMta(AT);
// baa laupa sTeTmaenT.
}jaeMvhpayaZMta(AT);

नेस्टेड डूचे उदाहरण .. लूप.

#vaapara <PsaTidiAayaAae.Pca>
paunaZ mauqya()
{
/*mauna D namaunaa
********
********
********
******** */
paunaZ mai=1;
kra // baa laupa
{
paunaZ jae=1;
kra // Aataila laupa
{
laiha("*");
jae++;
}jaeMvhpayaZMta(jae<=8);
laiha("\n");
mai++;
}jaeMvhpayaZMta(mai<=4);
}

वरील कोडचे स्पष्टीकरण.

प्रथम, आम्ही बाह्य लूप काउंटर व्हेरिएबल प्रारंभ करतो, म्हणजे, 'मी' 1 द्वारे. जसे आम्हाला माहित आहे की डू..वेळी लूप अट तपासल्याशिवाय एकदा अंमलात आणते, म्हणून बाह्य लूपमध्ये स्थिती न तपासता अंतर्गत लूप कार्यान्वित केली जाते. अंतर्गत लूपच्या अंमलबजावणीनंतर, नियंत्रण आय ++ च्या अद्यतनावर जाते. जेव्हा लूप काउंटर मूल्य वाढविले जाते, तेव्हा अट तपासली जाते. जर बाह्य लूपमधील स्थिती सत्य असेल तर आतील लूप कार्यान्वित होईल. बाह्य लूपमधील स्थिती सत्य होईपर्यंत ही प्रक्रिया चालू राहील.