विषयसूची:
- चरण 1: लूप के लिए
- चरण 2: गणितीय समस्याओं को हल करने के लिए लूप का उपयोग करें
- चरण 3: लूप ड्राइंग के लिए
- चरण 4: एक यादृच्छिक गोल बिंदु बनाने के लिए लूप के लिए उपयोग करें
- चरण 5: रेखा खींचने के लिए लूप का उपयोग करें
- चरण 6: लूप नेस्टेड के लिए
- चरण 7: जबकि लूप
- चरण 8: स्रोत
वीडियो: डिजाइनर के लिए दिलचस्प प्रोग्रामिंग गाइडेंस--प्रोग्राम प्रोसेस कंट्रोल- लूप स्टेटमेंट: 8 स्टेप्स
2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:23
प्रोग्राम प्रोसेस कंट्रोल- लूप स्टेटमेंट
इस अध्याय से, आप एक महत्वपूर्ण और शक्तिशाली ज्ञान बिंदु-लूप स्टेटमेंट के संपर्क में रहेंगे।
इस अध्याय को पढ़ने से पहले, यदि आप कार्यक्रम में १०,००० वृत्त बनाना चाहते हैं, तो आप केवल एक भयानक विधि से कर सकते हैं। यानी दीर्घवृत्त कोड की 10,000 पंक्तियाँ लिखना। वे आलसी कोड डिजाइनर जो हर तरह से दक्षता में सुधार करना चाहते हैं, निश्चित रूप से ऐसा नहीं होने देंगे। तो, लूप स्टेटमेंट बनाया जाता है। इस कथन से आप कंप्यूटर ऑटोमेशन की शक्ति को सहजता से महसूस कर सकते हैं।
चरण 1: लूप के लिए
बहुत सारे लूप स्टेटमेंट हैं, जिनमें से सबसे अधिक इस्तेमाल किया जाने वाला फॉर लूप है। हम सभी जानते हैं कि फंक्शन ड्रॉ लगातार सर्कुलेशन में ऑपरेट होता है। शुरुआत में पहले वाक्य से शुरू करें, यह ऊपर से नीचे तक अंतिम वाक्य तक लागू होगा। एक ऑपरेशन समाप्त करने के बाद, यह पहले वाक्य से फिर से शुरू होगा। स्टेटमेंट के लिए फंक्शन ड्रा के समान ही है। स्टेटमेंट के लिए कोड को बार-बार निष्पादित किया जा सकता है।
यहाँ इसकी व्याकरण संरचना है:
के लिए(अभिव्यक्ति १; व्यंजक २; व्यंजक ३){
लूप बॉडी
}
जाहिर है, लूप बॉडी के भीतर वाक्य वही है जो हमें बार-बार लागू होने की उम्मीद है। एक्सप्रेशन 1 का उपयोग लूप वेरिएबल को पहला मान इनिशियलाइज़ करने और असाइन करने के लिए किया जाता है। एक्सप्रेशन 2 लूप कंडीशन के लिए है। एक्सप्रेशन 3 लूप वेरिएबल वैल्यू को अपडेट करेगा।
लूप वेरिएबल क्या है? यह वास्तव में एक स्थानीय चर के बराबर है। आइए एक नज़र डालते हैं एक संपूर्ण लेखन पर।
for(int i = 0;i <10;i++){
लूप बॉडी
}
लूप फ़ंक्शन को महसूस करने के लिए, स्टेटमेंट के लिए मुख्य रूप से एक स्थानीय चर पर निर्भर करता है, जिसका उपयोग लूप टर्मिनेशन पर किया जाएगा। उपरोक्त उदाहरण में स्थानीय चर i है। अभिव्यक्ति 1 ने स्थानीय चर का आरंभीकरण पूरा कर लिया है। बाद में, हर बार जब लूप एक बार संचालित होता है, तो इस चर को अद्यतन किया जाना चाहिए। उपरोक्त उदाहरण में, अभिव्यक्ति 3 में i++ का उपयोग अद्यतन फ़ंक्शन को प्राप्त करने के लिए किया जाता है। इसके माध्यम से, हर बार अपडेट होने पर वेरिएबल 1 बढ़ जाएगा। अंत में, लूप बॉडी के भीतर कोड अनिश्चित काल तक लूप नहीं कर सकता है, अन्यथा बाद के बयानों को निष्पादित नहीं किया जा सकता है। इस प्रकार, हमें एक टर्मिनल स्थिति की आवश्यकता है। एक्सप्रेस 2 सिर्फ इसके लिए है। यहां, कार्यक्रम यह निर्धारित करेगा कि क्या मैं 10 से कम हूं। यदि ऐसा है, तो ऑपरेशन पर जाएं। यदि ऐसा नहीं है, तो लूप से बाहर कूदें।
इसलिए, स्टेटमेंट के लिए ऑपरेशन सीक्वेंस इस तरह है।
अभिव्यक्ति 1 (स्थानीय चर आरंभीकरण)
अभिव्यक्ति 2 (संतुष्ट, फिर काम करना जारी रखें)
लूप बॉडी (पहला सर्कुलेशन)
अभिव्यक्ति ३ (अद्यतन)
अभिव्यक्ति 2 (संतुष्ट, फिर काम करना जारी रखें)
लूप बॉडी (दूसरा सर्कुलेशन)
अभिव्यक्ति 3 (अद्यतन)
अभिव्यक्ति 2 (संतुष्ट, फिर काम करना जारी रखें)
लूप बॉडी (थर्ड सर्कुलेशन)…
अभिव्यक्ति 3 (अद्यतन)
अभिव्यक्ति 2 (संतुष्ट नहीं है, फिर लूप से बाहर कूदें)
आप निष्पादन के इस क्रम को अपने सिर में कई बार अनुकरण कर सकते हैं। लेकिन कोड को एक बार हाथ से टाइप किए बिना उसे वास्तव में समझना असंभव है। जब हम एक अजीब अवधारणा का पता लगाना चाहते हैं, तो हम कंसोल में मान को प्रिंटलाइन स्टेटमेंट के माध्यम से प्रिंट कर सकते हैं।
कोड उदाहरण (5-1): शून्य सेटअप () {
for(int i = 0; i <10; i++){
प्रिंट्लन ("रन");
}
}
आप कंसोल में रन आउटपुट की संख्या गिन सकते हैं। यहां, यह ठीक 10 है। यह आपको बताता है कि लूप बॉडी में कोड कितनी बार निष्पादित किया गया है। हालाँकि, हम अभी भी यह पता नहीं लगा सकते हैं कि लूप में वास्तव में क्या परिवर्तन हुए हैं। तो हम चरित्र "रन को वेरिएबल" i "में बदलने की कोशिश कर सकते हैं, और देखें कि क्या होगा।
कोड उदाहरण (5-2): शून्य सेटअप () {
for(int i = 0; i <10; i++){
प्रिंट्लन (आई);
}
}
अब, हम देख सकते हैं कि लूप बॉडी में i का मान लगातार बढ़ रहा है। बाद में, हम इस मान का उपयोग लूप की वर्तमान प्रक्रिया को समझने के लिए कर सकते हैं।
कोड उदाहरण (5-2) में, i का मान 0 से 9 तक बदल दिया गया है। वास्तविक लूप समय की तुलना में, ऐसा लगता है कि हमेशा 1 कम होता है। यदि आप इसके अभ्यस्त नहीं हैं, तो for स्टेटमेंट के ब्रैकेट में दिए गए एक्सप्रेशन को निम्नलिखित में लिखा जा सकता है:
for(int i = 1; i <＝ 10; i++)
इस प्रकार, i सही ढंग से लूप समय के अनुरूप है। "<＝" का अर्थ इससे छोटा और बराबर है। तो जब मैं 10 के बराबर होता हूं, तब भी यह शर्त को पूरा करेगा। इसलिए, यह i <10 में लिखे जाने की तुलना में एक बार फिर से काम करेगा। हालांकि यह 1 से शुरू होता है, लूप का समय अभी भी 10 है। बेशक, अगर कुछ खास जरूरत नहीं है, तो मैं आपको सुझाव देना चाहूंगा कि आप लेखन पद्धति को अपनाएं। शुरुआत में उदाहरण। बाद में हम आपको सदिश या सरणी का परिचय देंगे, जो दोनों इसके तत्व को इसके सबस्क्रिप्ट द्वारा प्राप्त करते हैं। और डिफ़ॉल्ट सबस्क्रिप्ट सभी 0 से शुरू होते हैं। प्रारंभिक मान को 0 के रूप में परिभाषित करना तुलनात्मक रूप से सामान्य अभ्यास है।
उपरोक्त उदाहरण में, यदि हम लिखते हैं कि i 0 से परे है, तो पोग्राम क्रैश हो जाएगा। चूंकि चर लगातार बढ़ रहा है, यह इस शर्त को कभी भी संतुष्ट नहीं करेगा। यह वैसा ही है जैसे इसे कभी रोका नहीं जा सकता ताकि कार्यक्रम अंतहीन लूप में चले।
फॉर स्टेटमेंट में स्थानीय चर न केवल प्लास्टिक प्रकारों की घोषणा कर सकते हैं, बल्कि फ्लोटिंग-पॉइंट प्रकारों में चर भी घोषित कर सकते हैं। उदाहरण के लिए, इसे (फ्लोट i = 0; i <10; i + = 0.02) के रूप में लिखा जा सकता है।
चरण 2: गणितीय समस्याओं को हल करने के लिए लूप का उपयोग करें
क्या आपको आज भी गणितज्ञ गॉस के बचपन की एक कहानी याद है? उस समय गुआस 10 साल के थे। उनके शिक्षक कक्षा में एक कार्य सौंपना चाहते थे और प्रश्न था
1＋2＋3＋4……＋97＋98＋99+100＝？
यदि आप अपने हाथों से गणना करते हैं, तो इसमें आपको बहुत समय लगेगा। लेकिन ऐसा लगता है कि गुआस ने पहले से ही अंकगणितीय अनुक्रम के योग की विधि का पता लगा लिया है। तो प्रश्न दिए जाने के ठीक बाद, उन्होंने आराम से उत्तर बोला, जिससे उनके शिक्षक को बहुत आश्चर्य हुआ था।
अब, हमें अभी भी याद नहीं है कि अंकगणितीय अनुक्रम का योग क्या है, लेकिन हम इसका उत्तर आदिम और हिंसक तरीके से प्राप्त कर सकते हैं। और वह लूप के लिए है। चूंकि यह कंप्यूटर के लिए गिनने के लिए केक का एक छोटा सा टुकड़ा है, इसलिए हमें प्रश्न का वर्णन ऐसी भाषा में करना है जिसे कंप्यूटर द्वारा पहचाना जा सके, तब हम आसानी से अपना उत्तर प्राप्त कर सकते हैं।
कोड उदाहरण (5-3):
व्यर्थ व्यवस्था(){
इंट उत्तर = 0;
for(int i = 1; i <= 100; i++){
उत्तर += मैं;
}
प्रिंट्लन (उत्तर);
}
मेरा मानना है कि आपको जो परिणाम मिलता है वह गुआस द्वारा बताए गए उत्तर के समान है: यह 5050 है!
सुझाव: लूप के लिए स्थानीय चरों का नाम इस शर्त पर बदला जा सकता है कि यह चर नामकरण नियमों का पालन करता है। आप इसे होने के लिए लिख सकते हैं (int k = 1;k <= 100;k++)। यदि कोई विशेष स्थिति नहीं होती है, तो यह चर के नाम के रूप में डिफ़ॉल्ट रूप से i होता है।
चरण 3: लूप ड्राइंग के लिए
प्रतीत होता है कि उबाऊ बिस्तरों की एक श्रृंखला के बाद, अंत में हम एक और दिलचस्प खंड में आ सकते हैं। यानी चित्रों को खींचने के लिए लूप के लिए उपयोग करना। अब हम उन थकाऊ गणितीय गणनाओं को अलग रख सकते हैं। हम डिजाइनर ग्राफिक्स के प्रति अधिक संवेदनशील होते हैं।
लूप के लिए एक सर्कल ऐरे को आकर्षित करने के लिए उपयोग करें
जब हम दोहराए गए तत्वों के समूह का प्रतिनिधित्व करने के लिए लूप के लिए उपयोग करना चाहते हैं, तो हमें पहले से इन तत्वों के अंक संबंध को सुनिश्चित करना होगा, फिर हम बड़े पैमाने पर दोहराने के काम के बजाय इसे आसानी से महसूस करने के लिए लूप के लिए उपयोग कर सकते हैं। मान लीजिए यदि हम क्षैतिज दिशा में समान रूप से फैले हुए वृत्त की एक पंक्ति बनाना चाहते हैं। इसका लंबवत निर्देशांक अपरिवर्तित रहता है जबकि इसका क्षैतिज समन्वय बदल जाता है। और बाएँ से दाएँ, क्षैतिज निर्देशांक लगातार बढ़ रहा है और बढ़ती दूरी समान है। इस समय, हम प्रत्येक सर्कल के क्षैतिज समन्वय प्राप्त करने के लिए लूप के लिए i का उपयोग कर सकते हैं।
कोड उदाहरण (5-4): शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (83, 51, 194);
नोस्ट्रोक ();
}
शून्य ड्रा () {
for(int i = 0; i <7; i++){
दीर्घवृत्त(50.0 + i * 100.0, ऊंचाई/2.0, 80.0, 80.0);
}
}
50 बाईं ओर पहले सर्कल की प्रारंभिक स्थिति के लिए खड़ा है। १०० in i * १०० बढ़ती दूरी को दर्शाता है।
चरण 4: एक यादृच्छिक गोल बिंदु बनाने के लिए लूप के लिए उपयोग करें
उपरोक्त ग्राफिक स्थिति पूर्वानुमेय है। यह बहुत सारे ब्याज को कम करेगा। हम पिछले अध्याय में संदर्भित फ़ंक्शन यादृच्छिक का उपयोग कर सकते हैं और इसे ड्राइंग फ़ंक्शन में लिखने का प्रयास कर सकते हैं।
कोड उदाहरण (5-5):
व्यर्थ व्यवस्था(){
आकार (700, 700);
पृष्ठभूमि (0);
नोस्ट्रोक ();
}
शून्य ड्रा () {
पृष्ठभूमि (0);
for(int i = 0;i <10;i++){
फ्लोट रैंडमविड्थ = रैंडम (60.0);
अंडाकार (यादृच्छिक (चौड़ाई), यादृच्छिक (ऊंचाई), यादृच्छिक विड्थ, यादृच्छिक विड्थ);
}
}
यहां, सर्कल की स्थिति लगातार चमकती होने का कारण यह है कि हर बार फ़ंक्शन यादृच्छिक रूप से एक बार संचालित होता है, परिणाम यादृच्छिक होता है। क्योंकि फंक्शन ड्रा 60 फ्रेम प्रति सेकेंड चलाने के लिए डिफ़ॉल्ट है, इसलिए एक सेकंड में खींचे गए प्रत्येक 10 सर्कल 60 बार अपनी स्थिति बदल देंगे। यह तेज फ्लैश तस्वीर को सिर्फ 10 से अधिक सर्कल बनाता है। कार्यक्रम में एक साधारण मूल्य बदलें आप एक पूरी तरह से अलग प्रभाव लाएंगे। हम टर्मिनल की स्थिति को संशोधित करके लूप के समय को बदल सकते हैं। नीचे दी गई तस्वीर में टर्मिनल कंडीशन i <100 है।
- यहाँ प्रभाव है जब टर्मिनल की स्थिति i <1000 है:
- यादृच्छिक बीज
- अगर मैं नहीं चाहता कि सर्कल की स्थिति यादृच्छिक रूप से उत्पन्न हो और साथ ही उसका फ्लैश भी हो, तो मैं क्या कर सकता हूं? एक तरीका यह है कि प्रत्येक सर्कल के लिए स्वतंत्र वेरिएबल्स का निर्माण और भंडारण किया जाए और इन वेरिएबल्स को सेटअप में इनिशियलाइज़ किया जाए। इन चरों को एक यादृच्छिक मान निर्दिष्ट करें। इस प्रकार, ड्रा के भीतर ड्राइंग फ़ंक्शन का उपयोग करते समय, हम जो कहते हैं वह वेरिएबल्स में संग्रहीत मान है। यह किसी भी समय नहीं बदलेगा। 10 वृत्त बनाने के लिए हम केवल इस विधि का उपयोग कर सकते हैं। लेकिन क्या होगा अगर हम १००० वृत्त, या १०,००० वृत्त बनाना चाहते हैं? यदि हम इन चरों को बनाने और नाम देने के लिए इस पारंपरिक पद्धति का उपयोग करते हैं तो यह काफी परेशानी भरा होगा। हमें एक नई चर निर्माण विधि नहीं सीखनी है। यहां एक लचीली विधि है जो इस लक्ष्य को प्राप्त करने में हमारी सहायता कर सकती है। वह है randomSeed का उपयोग करना। आइए अब उपयोग के बाद इसके प्रभाव पर एक नजर डालते हैं। कोड उदाहरण (5-6): [cceN_cpp विषय = "डॉन"] शून्य सेटअप () {आकार (700, 700); बैकग्राउंड (0); नोस्ट्रोक ();}
-
शून्य ड्रा () {
पृष्ठभूमि (0);
यादृच्छिक बीज(1);
for(int i = 0;i <10;i++){
फ्लोट रैंडमविड्थ = रैंडम (20.0, 60.0);
अंडाकार (यादृच्छिक (चौड़ाई), यादृच्छिक (ऊंचाई), यादृच्छिक विड्थ, यादृच्छिक विड्थ);
}
} [/cceN_cpp]
पहले के कोड की तुलना में, इसमें केवल बीज रैंडम के वाक्य के साथ सर्कल की त्रिज्या सीमा को 10 से 30 से आगे बदलने के अलावा कोई बदलाव नहीं है। इस वाक्य को जोड़ने के बाद, ग्राफिक स्थिर हो गया लगता है।
आह्वान प्रारूप:
यादृच्छिक बीज (ए);
इस प्रारूप में, a की सेटिंग बीज है। आपको इसमें एक पूर्णांक भरना है (पी ५ में एफ़्लोटिंग पॉइंट मान लिखें, यह गलत नहीं होगा बल्कि इसे पूर्णांक के रूप में मानेंगे)। RandomSeed का कार्य यादृच्छिक मान के लिए बीज सेट करना है। फिर यह अलग-अलग बीज के अनुसार अलग-अलग यादृच्छिक सरणी उत्पन्न करेगा। इसके बाद, हम फ़ंक्शन को यादृच्छिक रूप से आमंत्रित करते हैं ताकि वापसी का परिणाम निश्चित हो। यहाँ, निश्चित परिणाम के लिए नहीं है, एक निश्चित मान है, बल्कि उत्पन्न सरणी के लिए है। कहने का तात्पर्य यह है कि वापसी का परिणाम निश्चित समय के सापेक्ष निश्चित है।
कोड उदाहरण (5-7): [cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
यादृच्छिक बीज (0);
for(int i = 0;i <5;i++){
प्रिंट्लन (यादृच्छिक (10));
}
} [/cceN_cpp]
अब हम एक प्रयोग करने के लिए println का उपयोग करते हैं। randomSeed का उपयोग करने के बाद, हर बार जब आप प्रोग्राम को बंद करते हैं और प्रोग्राम को पुनरारंभ करते हैं, तो यह उसी परिणाम की एक स्ट्रिंग पर वापस आ जाएगा। मान एक-एक करके अनुक्रम के अनुरूप होगा। यदि आप इसे हटाते हैं, तो हर बार यह अलग-अलग मान पर वापस आ जाएगा। इसकी यह सेटिंग क्यों है? ऐसा इसलिए है क्योंकि कार्यक्रम में ही यादृच्छिक मूल्य छद्म यादृच्छिक है। परिणाम यादृच्छिक लगता है लेकिन वास्तव में यह एक निश्चित और दोहराने योग्य गणना पद्धति द्वारा उत्पन्न होता है। यह रैंडमसीड के लिए एक आदिम मान निर्दिष्ट करने के बराबर है, फिर इस बीज के अनुसार निम्नलिखित परिणाम की गणना की जाएगी। हालांकि, अगर हम बीज को नामित नहीं करते हैं, तो प्रोग्राम बीज उत्पन्न करने के लिए सिस्टम के वर्तमान समय का उपयोग करने के लिए डिफ़ॉल्ट होगा। इसलिए हर ऑपरेशन का परिणाम अलग होता है। नीचे दिया गया उदाहरण आपको randomSeed को बेहतर ढंग से समझने में मदद कर सकता है।
उदाहरण कोड (5-8): [cceN_cpp विषय = "डॉन"] शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (0);
नोस्ट्रोक ();
}
शून्य ड्रा () {
यादृच्छिक बीज(1);
for(int i = 0;i <10;i++){
फ्लोट रैंडमविड्थ01 = रैंडम (10, 60);
अंडाकार (यादृच्छिक (चौड़ाई), यादृच्छिक (ऊंचाई), यादृच्छिकविड्थ 01, यादृच्छिक विड्थ 01);
प्रिंट्लन (रैंडमविड्थ01);
}
यादृच्छिक बीज(1);
for(int i = 0;i <10;i++){
फ्लोट रैंडमविड्थ02 = रैंडम (10, 60);
अंडाकार (यादृच्छिक (चौड़ाई), यादृच्छिक (ऊंचाई), यादृच्छिक विड्थ02, यादृच्छिक विड्थ02);
प्रिंट्लन (रैंडमविड्थ02);
}
} [/cceN_cpp]
दूसरे randomSeed(1) को randomSeed(0) में संशोधित करने का प्रयास करें और अंतिम परिणामों की तुलना करें।
टिप्स: P5 में, हमें ड्रॉ के अंत में केवल फंक्शन noLoop को इनवाइट करना होता है ताकि हम समान प्रभाव प्राप्त कर सकें। इसका कार्य प्रोग्राम को समाप्त करना है। यह प्रकृति में उपरोक्त कार्य सिद्धांतों से काफी भिन्न है।
चरण 5: रेखा खींचने के लिए लूप का उपयोग करें
रैंडमसीड के उपयोग में महारत हासिल करने के बाद, हम ड्राइंग फ़ंक्शन को बदलने का प्रयास कर सकते हैं। उदाहरण के लिए, सर्कल ड्रॉइंग को लाइन ड्रॉइंग में बदलें। केवल अगर हम लाइन के अंत में कुछ बदलते नियमों को डिजाइन करते हैं, तो हम एक अद्वितीय पैटर्न बनाने के लिए बहुत सी लाइनों का उपयोग कर सकते हैं।
कोड उदाहरण (5-9):
[cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (0);
}
शून्य ड्रा () {
यादृच्छिक बीज (0);
for(int i = 0; i <2000; i++){
फ्लोट X1 = चौड़ाई/2.0;
फ्लोट x2 = यादृच्छिक (50.0, 650.0);
स्ट्रोक (255, 20);
लाइन (एक्स 1, 50, एक्स 2, 650);
}
} [/cceN_cpp]
सरल ब्रश बनाएं
वापस लूप के लिए फिर से। उपरोक्त उदाहरण संवादात्मक नहीं हैं। यदि हम परिणाम को और अधिक रोचक बनाना चाहते हैं, तो हम अपने कोड में माउसएक्स और माउसवाई को जोड़ना नहीं भूल सकते।
कोड उदाहरण (5-10):
[cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (255);
नोस्ट्रोक ();
}
शून्य ड्रा () {
for(int i = 0;i <1000;i++){
भरें (0, 30);
फ्लोट एक्स = माउसएक्स + रैंडम (-50, 50);
फ्लोट वाई = माउसवाई + यादृच्छिक (-50, 50);
अंडाकार (एक्स, वाई, 2, 2);
}
} [/cceN_cpp]
एक "बिखरने वाले बिंदु" ब्रश बनाया जाता है। चूंकि प्रत्येक गहन मिनी गोल बिंदु माउस की स्थिति पर आधारित होता है, यह बाएं, दाएं, ऊपर और नीचे की चार दिशाओं से सीमित दिशाओं को स्थानांतरित कर सकता है। तो ब्रश का अंतिम आकार एक वर्ग के समान होता है।
कोड उदाहरण (5-11):
[cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (255);
नोस्ट्रोक ();
}
शून्य ड्रा () {
for(int i = 0;i <1000;i++){
फ्लोट अनुपात = माउसएक्स/(फ्लोट) चौड़ाई;
फ्लोट एक्स = माउसएक्स + रैंडम (-50, 50);
फ्लोट वाई = माउसवाई + यादृच्छिक (-50, 50);
भरें (0, अनुपात * 255, 255 * (1 - अनुपात), 30);
अंडाकार (एक्स, वाई, 2, 2);
}
}
[/cceN_cpp]
यदि हम भरने वाले रंग को प्रभावित करने के लिए माउसएक्स के मूल्य का उपयोग करते हैं, तो हमें बहुत अधिक जादुई रंग ढाल मिलेगा।
चरण 6: लूप नेस्टेड के लिए
लूप के लिए नेस्टेड किया जा सकता है। आप लूप के लिए लूप में फिर से लिख सकते हैं। जब आपको दो आयामी डॉट मैट्रिक्स बनाने की आवश्यकता होती है, तो आप इस विधि को चुन सकते हैं।
कोड उदाहरण (5-12):
[cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
आकार (700, 700, पी 2 डी);
पृष्ठभूमि(२०२, २४०, १०७);
}
शून्य ड्रा () {
भरें (0);
for(int i = 0;i <5;i++){
के लिए (इंट जे = 0; जे <5; जे ++) {
फ्लोट एक्स = १५० + आई * १००;
फ्लोट वाई = १५० + जे * १००;
अंडाकार (एक्स, वाई, 60, 60);
प्रिंट्लन (i + ":" + जे);
}
}
}
[/cceN_cpp]
पहली बार नेस्टेड लूप का उपयोग करने के लिए, आपको इसके तर्क संबंधों का पता लगाना होगा। कार्यक्रम में कोड कार्यान्वयन हमेशा ऊपर से नीचे तक होता है। इसलिए, लागू किया गया पहला निश्चित रूप से सबसे बाहरी लूप है। हर बार जब बाहरी लूप एक बार काम करता है, तो आंतरिक लूप तब तक लगातार काम करता रहेगा जब तक कि वह किसी भी स्थिति को पूरा नहीं कर सकता। उसके बाद, यह दूसरा बाहरी लूप ऑपरेशन शुरू करेगा। दूसरा ऑपरेशन शुरू होने के बाद, आंतरिक लूप तब तक लागू रहेगा जब तक कि वह शर्त को पूरा नहीं कर सकता। ऐसा दोहराव तब तक करता है जब तक कि सभी शर्तों को पूरा नहीं किया जा सकता है और यह लूप से बाहर निकल जाता है।
उपरोक्त कोड में, बाहरी लूप में लूप बॉडी ने कुल 5 बार संचालित किया है, जबकि आंतरिक लूप में लूप बॉडी ने 25 बार संचालित किया है। 25 गुना के भीतर, i, j मान के अंतर के अनुसार, हम सर्कल के क्षैतिज और लंबवत समन्वय को अलग-अलग आश्वस्त कर सकते हैं। मैंने प्रिंट का एक खंड एम्बेड किया है, आप डेटा आउटपुट देख सकते हैं और इसके परिवर्तन के बारे में सोच सकते हैं। केवल दो नेस्टेड लूप के साथ, हम i, j डेटा के सभी संयोजनों का अनुभव कर सकते हैं।
टिप्स
दूसरी परत में लूप के लिए आमतौर पर शुरुआत में टैब के साथ संघनित होता है। यह कोड संरचना को और अधिक स्पष्ट कर सकता है। आपको अलग-अलग नामों के साथ लूप की दो परतों में स्थानीय चरों को नाम देना होगा। इनमें "i", "j", "k" सबसे अधिक प्रयोग किया जाता है।
लचीला उपयोग "i", "j"
"i", "j" के दो चर नाम लूप के लिए दो परतों के स्थानीय चर का प्रतिनिधित्व करते हैं। नीचे दिया गया उदाहरण "i" "j" के लिए आपकी समझ को गहरा करेगा। "i", "j" के विभिन्न मान के अनुसार, हम तत्वों को समूहित करने के लिए पैरामीटर इनपुट कर सकते हैं।
कोड उदाहरण (5-13): [cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
आकार (700, 700);
पृष्ठभूमि (0);
नोस्ट्रोक ();
}
शून्य ड्रा () {
पृष्ठभूमि (0);
भरें (२५०, २३३, ७७);
के लिए (int i = 0; i <7; i++) {
के लिए (इंट जे = 0; जे <7; जे ++) {
पुशमैट्रिक्स ();
अनुवाद (५० + आई * १००, ५० + जे * १००);
// सेटिंग 1
// फ्लोट कोण = पाप (मिली () / 1000.0) * पीआई / 2;
// सेटिंग 2
// फ्लोट अनुपात = i/7.0;
// फ्लोट कोण = पाप (मिली () / 1000.0 + अनुपात * (पीआई / 2)) * पीआई / 2;
// सेटिंग 3
फ्लोट अनुपात = (i * 7 + j)/49.0;
फ्लोट कोण = पाप (मिली () / १०००.० + अनुपात * (पीआई / २)) * पीआई / २;
घुमाएँ (कोण);
रेक्टमोड (केंद्र);
// चित्र बनाएं 1
रेक्ट (0, 0, 80, 80);
// चित्र बनाएं 2
// रेक्ट (0, 0, 100, 20);
// चित्र बनाएं 3
// रेक्ट (0, 0, अनुपात * 50);
पॉपमैट्रिक्स ();
}
}
} [/cceN_cpp]
कोड स्पष्टीकरण
rectMode(CENTER) वर्ग की ड्राइंग विधि को बदल सकता है। रेक्ट के ओरिंगिनल पूर्व दो पैरामीटर स्क्वायर के बाएं शीर्ष कोने के समन्वय को परिभाषित करने के लिए उपयोग किए जाते हैं। इस कमांड को शुरू करने के बाद, इन दो मापदंडों का उपयोग वर्ग केंद्र बिंदु के लिए निर्देशांक सेट करने के लिए किया जाएगा।क्योंकि यहां हम रोटेशन के माध्यम से पैटर्न रोटेशन को संचालित करते हैं, इसलिए हमें केंद्र बिंदु को समन्वय के मूल बिंदु पर खींचने के लिए इस पद्धति का उपयोग करने की आवश्यकता है।
मिलिस () कार्यक्रम शुरू से वर्तमान तक का समय प्राप्त करता है। इकाई एमएस है। यह मान पाप आउटपुट मूल्य की बदलती गति को प्रभावित करेगा। अगर हम सीधे मिलिस लिखते हैं, तो बदलता पैमाना बहुत बड़ा है। इस प्रकार, हमें इसे 1000.0 से विभाजित करना होगा।
कोड के इस भाग में, हम कई सेटिंग्स को छिपाने के लिए टिप्पणी चिह्न "//" का उपयोग करते हैं। आप प्रभाव को प्रारंभ या बंद करके स्थानांतरित कर सकते हैं। उदाहरण के लिए, यदि हम "सेटिंग 3" के पीछे वाक्य शुरू करते हैं, तो हमें "सेटिंग 1" और "सेटिंग 2" के पीछे कोड ब्लॉक को बंद करने के लिए टिप्पणी चिह्न का उपयोग करना होगा। विभिन्न स्थानीय चरों के साथ इस समान कार्यक्रम संरचना के उदाहरणों के लिए, हम इस प्रारूप में लिख सकते हैं। इस प्रकार हमें कई इंजीनियरिंग दस्तावेजों को अलग से स्टोर करने की आवश्यकता नहीं है। हम अभ्यास और निर्माण के दौरान अक्सर इस कौशल का उपयोग कर सकते हैं और कुछ संतोषजनक पैरामीटर सेटिंग्स को संरक्षित कर सकते हैं।
इसमें से, कार्यक्रम के लिए i, j मान का प्रभाव मुख्य रूप से "सेटिंग 1 (सेटिंग 2) (सेटिंग 3)" को स्थानांतरित करके दर्शाया गया है। आप नीचे दिए गए आउटपुट परिणामों की तुलना कर सकते हैं।
चित्र 1 बनाएं: सेटिंग 1
चित्र 1 बनाएं: सेटिंग 2
चित्र 1 बनाएं: सेटिंग 3
चित्र 2 बनाएं: सेटिंग 1
चित्र 2 बनाएं: सेटिंग 2
चित्र 2 बनाएं: सेटिंग 3
सेटिंग 1 में, हमने प्रत्येक तत्व के घूर्णन कोण को प्रभावित करने के लिए i और j का उपयोग नहीं किया है। इस प्रकार हम देख सकते हैं कि प्रत्येक तत्व की गति समान है। सेटिंग 2 में, हमने सेटिंग 3 में i मान और i और j दोनों का उपयोग किया है। अंत में उन्होंने अनुपात के माध्यम से फ़ंक्शन पाप के पैरामीटर इनपुट को प्रभावित किया है। इसने कोण के आवधिक परिवर्तन को बदल दिया है। एनिमेटेड ग्राफिक्स में सेटिंग 2 और सेटिंग 3 का वास्तविक प्रभाव इतना स्पष्ट नहीं होने के कारण, हम इसे निम्नलिखित स्क्रीनशॉट से देख सकते हैं।
चित्र 2 बनाएं (बाएं: सेटिंग 2; दाएं: सेटिंग 3)
चित्र 3 बनाएं (बाएं: सेटिंग 2; दाएं: सेटिंग 3)
पहली तस्वीर में, वर्ग घुमाव कोण को प्रभावित करने के लिए अनुपात का उपयोग किया जाता है। जबकि दूसरी तस्वीर, यह सीधे वृत्त की त्रिज्या को नियंत्रित करने के लिए है। हम देख सकते हैं कि इसने i value वाक्य का उपयोग किया है:
फ्लोट अनुपात = i/7.0;
इसका ऊर्ध्वाधर तत्व परिवर्तन सुसंगत है। चूँकि चित्र को नियंत्रित करने के लिए क्षैतिज निर्देशांक केवल i के मान पर निर्भर करता है, इसलिए समान क्षैतिज निर्देशांक वाले पैटर्न समान होंगे। और अनुपात का मान, घूर्णन कोण और वृत्त की त्रिज्या भी समान होती है।
उसी समय, हम i, j वाक्य का उपयोग करते हैं:
फ्लोट अनुपात = (i * 7 + j)/49.0;
यह "ढाल" का वर्णन कर सकता है। यहाँ, गुणनखंड को गुणा करने की विधि के साथ, इसने पंक्तियों और स्तंभों के प्रभाव को जोड़ दिया है। तो प्रत्येक तत्व अलग है।
चरण 7: जबकि लूप
लूप के लिए एक भाई है। वह है जबकि लूप। लूप के लिए क्या कर सकता है, जबकि लूप भी कर सकता है। लेकिन क्रिएटिव कोडिंग में जबकि लूप की आवृत्ति लूप के लिए अधिक नहीं है।
कोड उदाहरण (5-14): [cceN_cpp विषय = "सुबह"] शून्य सेटअप () {
इंट ए = 0;
जबकि (ए <10) {
प्रिंट्लन (ए);
ए++;
}
} [/cceN_cpp]
जबकि की व्याकरण संरचना को समझने में आसान है। हम स्टेटमेंट से पहले वेरिएबल बना सकते हैं। फिर वर्गाकार कोष्ठक में व्यंजक भरें। जब यह संतुष्ट हो जाए, तो वाक्यों को लूप बॉडी के भीतर संचालित करें। अंत में हम लूप बॉडी में वेरिएबल को अपडेट करने के लिए एक एक्सप्रेशन डालते हैं, फिर जबकि लूप खत्म हो जाता है। सुनिश्चित लूप समय के लिए, हम अक्सर लूप के लिए उपयोग करते हैं। जहां तक अनंत चर मान का सवाल है, हम आपको लूप के दौरान उपयोग करने की सलाह देते हैं।
सोचना:
विभिन्न अलग-अलग ब्रश बनाने के लिए लूप के लिए ड्राइंग तत्वों को बदलने के लिए सभी प्रकार के मूल तत्वों का उपयोग करने का प्रयास करें।
पिछले अध्याय में दिए गए त्रिकोणमितीय फ़ंक्शन के साथ संयोजन करें, "स्कैटरिंग पॉइंट्स" ब्रश को गोल आकार के ब्रश में संशोधित करने का प्रयास करें।
केवल लूप के साथ द्वि-आयामी डॉट मैट्रिक्स बनाने का प्रयास करें।
अगला अध्याय पूर्वावलोकनइस पाठ्यक्रम के साथ, आप अपने द्वारा सीखे गए हर नए ज्ञान को पाएंगे, खेलने की संभावना तुरंत बहुत बढ़ जाएगी। कार्यक्रम एक पेंडोरा बॉक्स है। आप जो कुछ भी कल्पना कर सकते हैं, वह आपके लिए कर सकता है। इसलिए हमारे लिए इस भाषा को नहीं सीखने का कोई कारण नहीं है जो कंप्यूटर के साथ संचार कर सके। हमारे अगले अध्याय में, हम आपके लिए एक और प्रक्रिया नियंत्रण विवरण पेश करेंगे। यह प्रक्रिया प्रवाह को नियंत्रित कर सकता है और अधिक जटिल और परिवर्तनशील परिणाम उत्पन्न कर सकता है। इफ स्टेटमेंट के साथ, आप आसानी से अपना टेक्स्ट एडवेंचर गेम बना सकते हैं! यह लेख डिज़ाइनर वेन्ज़ी से आता है। सापेक्ष रीडिंग: डिज़ाइनर के लिए दिलचस्प प्रोग्रामिंग गाइडेंस--प्रोसेसिंग इनिशियल टच डिज़ाइनर के लिए दिलचस्प प्रोग्रामिंग गाइडेंस- डिज़ाइनर के लिए अपना पहला प्रोसेसिंग प्रोग्राम दिलचस्प प्रोग्रामिंग गाइडेंस बनाएं। -अपना चित्र चलाना (भाग एक) डिज़ाइनर के लिए दिलचस्प प्रोग्रामिंग मार्गदर्शन-अपना चित्र चलाना (भाग दो) प्राप्त करें
चरण 8: स्रोत
यह लेख यहां से है:
यदि आपके कोई प्रश्न हैं, तो आप संपर्क कर सकते हैं： [email protected]।