सामग्री

• तुलना चार्ट
• लूपची व्याख्या
• मांडणी
• प्रत्येक लूप आणि त्याचे वाक्यरचना
• उदाहरण
• लूपची व्याख्या
• मांडणी
• उदाहरण
• टीपः
• निष्कर्ष:

सी ++ आणि जावा मध्ये, लूपसाठी व पुनरावृत्ती स्टेटमेंट्स, जबकि लूप आणि डू-वूप लूप, अट अट पूर्ण होईपर्यंत सूचनांचा सेट पुन्हा कार्यान्वित करण्यास परवानगी देतात आणि अट अयोग्य झाल्याबरोबर संपुष्टात येते. लूपसाठी किंवा लूपमध्ये असताना ओपन-एन्ड म्हणून इट्रेशन स्टेटमेंटमधील अटी पूर्वनिर्धारित असू शकतात.

सी ++ मधील अनेक ‘फॉर’ लूप बदलांची अंमलबजावणी, सामर्थ्य आणि लवचिकता वाढविण्यासाठी अंतर्भूत आहेत. उदाहरणार्थ, फॉर लूप आपल्याला नियंत्रित करण्यासाठी लूपच्या आत एकापेक्षा जास्त व्हेरिएबल्स वापरण्यास आणि ‘फॉर’ लूपसह कन्व्हर्जे फंक्शनचा वापर करण्यास परवानगी देते. उलटपक्षी, वूट लूपसह आपण बर्‍याच प्रकारांचा वापर करू शकत नाही, ते मानक वाक्यरचनासह वापरले जाणे आवश्यक आहे.

लूपसाठी आणि दरम्यान काही प्रमुख फरक आहेत, जे तुलना चार्टच्या मदतीने पुढील स्पष्टीकरण दिले आहेत.

1. तुलना चार्ट
2. व्याख्या
3. मुख्य फरक
4. निष्कर्ष

तुलना चार्ट

तुलनासाठी आधार	च्या साठी	तर
घोषणा	साठी (आरंभ; स्थिती; पुनरावृत्ती) { // लूप फॉर लूप }	(स्थिती) while स्टेटमेन्ट्स; // लूपचा मुख्य भाग }
स्वरूप	लूपच्या शीर्षस्थानी इनिशिएलायझेशन, कंडिशन तपासणी, इट्रेशन स्टेटमेंट लिहिलेले आहे.	लूपच्या शीर्षस्थानी केवळ आरंभ आणि कंडिशन तपासणी केली जाते.
वापरा	जेव्हा आपल्याला आधीच पुनरावृत्तीची संख्या माहित असेल तेव्हाच लूप वापरा.	जेव्हा पुनरावृत्तीची संख्या अचूक माहित नसते तेव्हाच लूप वापरला जातो.
परिस्थिती	अट लूपमध्ये ठेवली नसल्यास लूप अनंत वेळा पुनरावृत्ती होते.	लूप चालू असताना अट ठेवली नाही तर ती संकलित त्रुटी प्रदान करते.
आरंभ	लूपसाठी एकदा केलेली आरंभिक पुनरावृत्ती कधीच होत नाही.	लूप जर कंडीशन तपासणी दरम्यान इनिशिएलायझेशन केले असेल तर प्रत्येक वेळी लूप पुनरावृत्ती झाल्यावर इनिशिएलायझेशन केले जाईल.
Iteration विधान	मध्ये लूप इट्रेशन स्टेटमेंट वर लिहिलेले आहे, म्हणून लूपमधील सर्व स्टेटमेंट्स कार्यान्वित झाल्यानंतरच कार्यान्वित होईल.	इन लूपमध्ये, पुनरावृत्ती स्टेटमेंट लूपमध्ये कोठेही लिहिले जाऊ शकते.

लूपची व्याख्या

जावा मध्ये, दोन प्रकार आहेत च्या साठी पळवाट. प्रथम फॉर्म "पारंपारिक" फॉर्म आहे आणि दुसरा फॉर्म "प्रत्येकासाठी" फॉर्म आहे.

मांडणी

लूप स्टेटमेंटसाठी पारंपारिक चे सामान्य स्वरूप.

साठी (आरंभ; स्थिती; पुनरावृत्ती) {// लूप फॉर लूप}

• आरंभ - लूपच्या पहिल्या पुनरावृत्ती दरम्यान, लूपच्या लूप नियंत्रित चलच्या आरंभिकतेची अंमलबजावणी फक्त एकदाच केली जाते. येथे लूप कंट्रोलिंग व्हेरिएबल इनिशियलाइझ केले जाते, कधीकधी जर लूप व्हेरिएबल प्रोग्राममध्ये कुठेही पुन्हा वापरला गेला नाही आणि फक्त लूपचा कंट्रोलिंग व्हेरिएबल म्हणून वापरला गेला तर तो 'फॉर' लूपमध्ये घोषित आणि आरंभित दोन्ही आहे.
• परिस्थिती - प्रत्येक वेळी लूप पुनरावृत्ती झाल्यावर ‘फॉर’ लूपची अट चालविली जाते.
• वाढ आणि पुनरावृत्ती- इट्रेशन स्टेटमेंट ही एक अभिव्यक्ती आहे जी लूप कंट्रोलिंग व्हेरिएबलला वाढवते किंवा कमी करते.

जेव्हा जेव्हा लूप कार्यान्वित होते तेव्हा त्याची आरंभिक स्थिती प्रथम कार्यान्वित केली जाते; नंतर कंडीशन तपासली जाईल. जर कंडिशन समाधानी असेल तर, लूपचा मुख्य भाग कार्यान्वित होईल, तर पुनरावृत्ती स्टेटमेंट कार्यान्वित होईल. नंतर पुन्हा लूप आणखी पुनरावृत्ती होईल की नाही ते थांबेल हे जाणून घेण्यासाठी अट तपासली गेली.

जावामध्ये इनिशिएलायझेशन स्टेटमेंट आणि इट्रेशन स्टेटमेंटमध्ये एकापेक्षा जास्त स्टेटमेन्ट असू शकतात. प्रत्येक स्टेटमेन्ट स्वल्पविरामाने विभक्त केले जाते, जावा मध्ये स्वल्पविराम विभक्त आहे तर C ++ मध्ये “स्वल्पविराम” एक ऑपरेटर आहे जो कोणत्याही वैध अभिव्यक्तीमध्ये वापरता येतो.

प्रत्येक लूप आणि त्याचे वाक्यरचना

“प्रत्येकासाठी” फॉर्म लूपसाठी वर्धित आहे. प्रत्येक लूपचे सामान्य स्वरूप खालीलप्रमाणे आहे.

(प्रकार iter_variable: संग्रह) स्टेटमेंट-ब्लॉक साठी

येथे “टाइप” पुनरावृत्ती व्हेरिएबलचा प्रकार निर्दिष्ट करते, त्यानंतर आयटरेशन व्हेरिएबल. पुनरावृत्ती व्हेरिएबल कलेक्शन व्हेरिएबलमधून घटक प्राप्त करेल. प्रकार संग्रह व्हेरिएबलमध्ये संग्रहित घटकांच्या प्रकाराप्रमाणेच असणे आवश्यक आहे. लूपचा प्रत्येक प्रकार अनुक्रमिक क्रमाने मूल्यांमध्ये प्रवेश करणे सुरू होण्यापासून लूपच्या पुनरावृत्तीस स्वयंचलित करतो.

उदाहरण

लूपसाठी अनेक प्रकारचे संग्रह वापरले जातात. संग्रह म्हणून अ‍ॅरेसह त्याबद्दल चर्चा करूया.

सार्वजनिक वर्ग मुख्य {सार्वजनिक स्थीर शून्य मुख्य (स्ट्रिंग आर्ग्स) gs इंट अ‍ॅरे = {10, 20, 30, 40, 50, 60}; इंट अ‍ॅड = 0; (int c: अ‍ॅरे) साठी {System.out.ln ("c मधील मूल्य" + c); जोडा = जोडा + सी; . सिस्टम.out.ln ("अ‍ॅरे घटकांचे अ‍ॅडिटॉन" + जोडा); }} // अरे मधील आउटपुट मूल्य 10 मधील मूल्य 20 सी मधील मूल्य 30 सी मधील मूल्य 40 सी मधील मूल्य सी 50 मधील मूल्य 60 itरे घटकांचे अ‍ॅडिटॉन 210 आहे

येथे, ‘सी’ एक पुनरावृत्ती व्हेरिएबल आहे; हे अ‍ॅरे वरुन सर्वात कमी निर्देशांकापासून अ‍ॅरेमधील निर्देशांकांमधून एका वेळी एक मिळवतात. येथे अ‍ॅरेच्या सर्व घटकांची तपासणी होईपर्यंत लूप पुनरावृत्ती होईल. ब्रेकचा वापर करून लूप संपविणे शक्य आहे. तथापि, पुनरावृत्ती व्हेरिएबलमधील बदल अ‍ॅरेवर परिणाम करत नाही, कारण केवळ वाचनीय व्हेरिएबल आहे.

लूपची व्याख्या

द तर लूप ही सी ++ आणि जावामध्ये उपलब्ध असलेली सर्वात मूलभूत पळवाट आहे. सी लूपचे कार्य सी ++ आणि जावा या दोहोंमध्ये समान आहे.

मांडणी

खाली असलेल्या लूपची घोषणा खालीलप्रमाणे आहे

(स्थिती) {स्टेटमेन्ट्स; // लूपचा मुख्य भाग}

सुरुवातीच्या काळात लूप कंडीशनची तपासणी करते आणि नंतर लूप बरोबर असल्याचे दिसून येईपर्यंत स्टेटमेंट्स कार्यान्वित करते. लूप मधील अट ही कोणतीही बुलियन एक्सप्रेशन असू शकते. जेव्हा एखादी अभिव्यक्ती कोणतीही शून्य मूल्य मिळवते तेव्हा अट खरी असते आणि जर एक्सप्रेशन शून्य व्हॅल्यू मिळवते तर अट चुकीची बनते.

जर स्थिती खरी बनली तर लूप स्वतःच पुनरावृत्ती होईल आणि जर ही स्थिती चुकीची झाली तर नियंत्रण लूपनंतर कोडच्या पुढील ओळीवर जाईल. स्टेटमेन्ट्स किंवा बॉडी लूप एकतर रिक्त विधान किंवा एकल विधान किंवा विधानांचे ब्लॉक असू शकते.

उदाहरण

चला थोड्या वेळाच्या लूपच्या कामकाजाबद्दल चर्चा करूया. खाली दिलेल्या उदाहरणात कोड 1 ते 10 पर्यंत असेल.

// उदाहरण जावा मध्ये आहे. पब्लिक क्लास मेन stat पब्लिक स्टॅटिक रिक्त मुख्य (स्ट्रिंग आर्ट्स) {इंट एन = 0; असताना (n <10) {n ++; सिस्टम.आउट.एलएन ("एन =" + एन); }}} // आउटपुट एन = 1 एन = 2 एन = 3 एन = 4 एन = 5 एन = 6 एन = 7 एन = 8 एन = 9 एन = 10

येथे ‘एन’ चे प्रारंभिक मूल्य 0 आहे, जे कंडिशनला लूपमध्ये खरे करते. त्यानंतर कंट्रोल लूपच्या मुख्य भागामध्ये प्रवेश करते आणि थोडा लूपच्या मुख्य भागातील पहिल्या विधानानुसार ‘एन’ चे मूल्य वाढविले जाते. ‘एन’ ची व्हॅल्यू एड आहे, नंतर कंट्रोल थोड्या वेळात पुन्हा कंडिशनवर जाईल, आता ‘एन’ ची व्हॅल्यू 1 आहे जी पुन्हा कंडिशनला पूर्ण करते, आणि लूपची बॉडी पुन्हा कार्यान्वित होते. ही स्थिती सत्य होईपर्यंत चालू राहते, कंडिशन खोटी होताच लूप बंद होते.

‘फॉर’ लूप प्रमाणेच, ‘जबकि’ लूप देखील लूपच्या शीर्षस्थानी असलेल्या कंट्रोल व्हेरिएबलची सुरूवात करू शकते अर्थात स्थिती तपासणी दरम्यान.

// उदाहरणार्थ ((ch = getchar ())! = A). System.out.ln ("इनपुट वर्णमाला" + सीएच); }

येथे कंट्रोल व्हेरिएबल ‘सीएच’ इनिशियलाइज केले आहे आणि लूपच्या अट लूपच्या शीर्षस्थानी पडताळले जाते.

टीपः

हे लूपसाठी किंवा थोडी पळवाट असू शकते, जर लूपच्या शरीरात एकच विधान असेल तर त्या स्थितीत कुरळे कंस आवश्यक नाहीत.

1. मध्ये च्या साठी लूप, इनिशिएलायझेशन, कंडिशन तपासणी, आणि इन्ट्रीशन व्हेरिएबलची वाढ किंवा घट फक्त लूपच्या सिंटॅक्समध्ये स्पष्टपणे केली जाते. च्या विरुद्ध, मध्ये तर लूप आपण केवळ आरंभ करू शकतो आणि लूपच्या वाक्यरचना मध्ये कंडिशन तपासू शकतो.
2. जेव्हा आपल्याला लूपच्या अंमलबजावणीमध्ये पुनरावृत्ती होणा .्या पुनरावृत्तीची जाणीव असते, तेव्हा आपण वापरतो च्या साठी पळवाट दुसरीकडे, जर आपल्याला लूपमध्ये पुनरावृत्ती होणा ite्या पुनरावृत्तीच्या संख्येबद्दल माहिती नसेल तर आपण वापरतो तर पळवाट
3. आपण अट स्टेटमेंट ठेवण्यात अयशस्वी झाल्यास च्या साठी लूप, हे लूपची असीम पुनरावृत्ती करेल. याउलट, आपण अट स्टेटमेंट मध्ये अयशस्वी झाल्यास तर लूपमुळे संकलनात त्रुटी येईल.
4. च्या वाक्यरचना मध्ये आरंभ विधान च्या साठी लूप सुरू झाल्यावर एकदाच कार्यान्वित करते. उलट, तर तर लूप त्याच्या सिंटॅक्समध्ये इनिशिएलायझेशन स्टेटमेंट घेऊन जाईल, तर जेव्हा लूप प्रत्येक वेळी लूप पुनरावृत्ती होईल तेव्हा लूपमधील इनिशिएशन स्टेटमेंट कार्यान्वित करेल.
5. मधील पुनरावृत्ती विधान च्या साठी लूप कार्यान्वित करण्यासाठी शरीरानंतर कार्यान्वित होईल. उलटपक्षी, पुनरावृत्ती विधान विधानाच्या मुख्य भागात कुठेही लिहिले जाऊ शकते तर लूप सो, अशी काही स्टेटमेन्ट्स असू शकतात जी व्हेट लूपच्या मुख्य भागामध्ये इट्रेशन स्टेटमेंटच्या अंमलबजावणीनंतर कार्यान्वित होतील.

निष्कर्ष:

लूपसाठी आणि लूपमध्ये दोन्ही पुनरावृत्ती स्टेटमेंट आहेत, परंतु दोघांचे वेगळे वैशिष्ट्य आहे. लूपच्या मुख्य भागाच्या शीर्षस्थानी त्याची सर्व घोषणा (आरंभिकरण, स्थिती, पुनरावृत्ती) असते. याउलट लूपच्या मुख्य भागाच्या वरच्या बाजूला फक्त आरंभ आणि स्थिती असते तर लूपच्या शरीरात कोठेही लिहिले जाऊ शकते.