सी # में, सरणी समान डेटा प्रकार के तत्वों को संग्रहित करने के लिए कंटेनर के रूप में कार्य करती है। एक सरणी बनाते समय, इसे तत्वों के साथ आरंभ करने के लिए कई दृष्टिकोण होते हैं। यह आलेख सी # में सरणियों को आरंभ करने के विभिन्न तरीकों पर चर्चा करता है, प्रत्येक दृष्टिकोण का व्यापक अन्वेषण प्रदान करता है।
सी # में सरणी प्रारंभ करने के तरीके
कंप्यूटर प्रोग्रामिंग में Arrays एक आवश्यक डेटा संरचना है जो आपको समान डेटा प्रकार के तत्वों के संग्रह को सन्निहित मेमोरी स्थानों में संग्रहीत और हेरफेर करने की अनुमति देता है। सी # में सरणी प्रारंभ करने के कुछ तरीके यहां दिए गए हैं:
1: ऐरे इनिशियलाइज़र सिंटैक्स का उपयोग करके एरे को इनिशियलाइज़ करना
किसी सरणी को इनिशियलाइज़ करने के लिए सबसे सीधा तरीका है, एरे इनिशियलाइज़र सिंटैक्स का उपयोग करना, क्योंकि इसमें एरे एलिमेंट्स को ब्रेसिज़ में संलग्न करना शामिल है, उदाहरण के लिए अल्पविराम द्वारा अलग किया गया है:
int यहाँ [ ] संख्या = { 1 , 2 , 3 , 4 , 5 } ;
इस कोड में, 'नंबर' नामक एक पूर्णांक सरणी बनाई जाती है और 1 से 5 के मानों के साथ प्रारंभ की जाती है। इसी प्रकार, आप एक बहुआयामी सरणी को प्रारंभ करने के लिए समान सिंटैक्स को नियोजित कर सकते हैं।
int यहाँ [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
यहाँ एक उदाहरण कोड है जो C# में 1D और 2D सरणी को इनिशियलाइज़ करने के लिए इनिशियलाइज़र सिंटैक्स का उपयोग करता है:
सिस्टम का उपयोग करना;
वर्ग सरणी
{
स्थैतिक शून्य मुख्य ( डोरी [ ] तर्क )
{
// इनिशियलाइज़र सिंटैक्स का उपयोग करके 1D सरणी को प्रारंभ करना
int यहाँ [ ] सरणी 1 डी = { 1 , 2 , 3 , 4 , 5 } ;
कंसोल। राइटलाइन ( 'सरणी 1 डी में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < array1D.Length; मैं++ ) {
कंसोल। राइटलाइन ( array1D [ मैं ] ) ;
}
// इनिशियलाइज़र सिंटैक्स का उपयोग करके 2D ऐरे को इनिशियलाइज़ करना
int यहाँ [ , ] सरणी 2 डी = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
कंसोल। राइटलाइन ( 'Array2D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < array2D.GetLength ( 0 ) ; मैं++ ) {
के लिए ( इंट जे = 0 ; जे < array2D.GetLength ( 1 ) ; जे ++ ) {
कंसोल। राइटलाइन ( '({0}, {1}): {2}' , i, j, array2D [ मैं, जे ] ) ;
}
}
}
}
इस कोड में, हम 1, 2, 3, 4, और 5 मानों के साथ array1D नामक 1-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए प्रारंभकर्ता सिंटैक्स का उपयोग कर रहे हैं।
हम 2-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए इनिशियलाइज़र सिंटैक्स का उपयोग कर रहे हैं, जिसे array2D कहा जाता है, जिसमें मान {1, 2}, {3, 4}, और {5, 6} हैं।
फिर हम प्रत्येक सरणी के प्रत्येक तत्व के माध्यम से लूप के लिए अतिरिक्त का उपयोग कर रहे हैं और कंसोल पर इसका मान प्रिंट कर रहे हैं।
2: नए कीवर्ड का उपयोग करके सरणियों को आरंभ करना
किसी सरणी को प्रारंभ करने के लिए एक अतिरिक्त विधि में उपयोग करना शामिल है नया कीवर्ड। इसमें वर्ग कोष्ठक में सरणी के आकार को निर्दिष्ट करना, उसके बाद नया कीवर्ड और फिर सरणी तत्वों का डेटा प्रकार शामिल है। उदाहरण के लिए:
int यहाँ [ ] नंबर = नया इंट [ 5 ] ;
यह कोड 5 के आकार के साथ संख्याओं के नाम से एक पूर्णांक सरणी बनाता है और सभी तत्वों को उनके डिफ़ॉल्ट मान पर प्रारंभ करता है, जो पूर्णांक सरणियों के लिए 0 है।
यहाँ C # में नए कीवर्ड का उपयोग करके एक बहुआयामी सरणी को आरंभ करने के लिए सिंटैक्स दिया गया है:
< प्रकार > [ , ] < सरणीनाम > = नया < प्रकार > [ < लंबाई1 > , < लंबाई 2 > , ... ] { { < प्रारंभिक मूल्य > } } ;
इस सिंटैक्स में,
2-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए इस सिंटैक्स का उपयोग करने का एक उदाहरण यहां दिया गया है:
int यहाँ [ , ] myArray = नया int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
इस उदाहरण में, हम नए कीवर्ड का उपयोग करके 3 पंक्तियों और 2 कॉलम के साथ myArray नामक 2d पूर्णांक सरणी को प्रारंभ कर रहे हैं। हम डबल कर्ली ब्रेस सिंटैक्स का उपयोग करके सरणी के प्रत्येक तत्व के लिए प्रारंभिक मान भी प्रदान कर रहे हैं। मान {1, 2}, {3, 4}, और {5, 6} हैं, जो प्रत्येक पंक्ति में तत्वों के अनुरूप हैं।
प्रत्येक सरणी में मानों को प्रिंट करने के लिए कोड के साथ-साथ सी # में 1-आयामी और 2-आयामी सरणी दोनों को प्रारंभ करने के लिए नए कीवर्ड का उपयोग करने का एक उदाहरण यहां दिया गया है:
सिस्टम का उपयोग करना;वर्ग सरणी
{
स्थैतिक शून्य मुख्य ( डोरी [ ] तर्क )
{
// ए प्रारंभ कर रहा है 1 -आयामी सरणी
int यहाँ [ ] myArray1D = नया int [ ] { 1 , 2 , 3 , 4 , 5 } ;
कंसोल। राइटलाइन ( 'MyArray1D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < myArray1D.लंबाई; मैं++ )
{
कंसोल। राइटलाइन ( myArray1D [ मैं ] ) ;
}
// ए प्रारंभ कर रहा है 2 -आयामी सरणी
int यहाँ [ , ] myArray2D = नया int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
कंसोल। राइटलाइन ( 'MyArray2D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < myArray2D.GetLength ( 0 ) ; मैं++ )
{
के लिए ( इंट जे = 0 ; जे < myArray2D.GetLength ( 1 ) ; जे ++ )
{
कंसोल। राइटलाइन ( '({0}, {1}): {2}' , आई, जे, myArray2D [ मैं, जे ] ) ;
}
}
}
}
इस कोड में, हम नए कीवर्ड का उपयोग एक-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए कर रहे हैं myArray1D मान 1, 2, 3, 4 और 5 के साथ, और एक 2-आयामी पूर्णांक सरणी कहा जाता है myArray2D मानों {1, 2}, {3, 4}, और {5, 6} के साथ।
फिर हम लूप के लिए प्रत्येक सरणी के प्रत्येक तत्व के माध्यम से पुनरावृति करने के लिए उपयोग कर रहे हैं और इसके मान को कंसोल पर प्रिंट कर सकते हैं। ध्यान दें कि द्वि-आयामी सरणी के लिए, हम उपयोग कर रहे हैं लंबाई प्राप्त करें () पंक्तियों और स्तंभों की संख्या निर्धारित करने के लिए, और प्रत्येक तत्व के माध्यम से पुनरावृति करने के लिए नेस्टेड for लूप का उपयोग करना।
3: लूप्स का उपयोग करके एरे को इनिशियलाइज़ करना
ऐरे को लूप का उपयोग करके भी इनिशियलाइज़ किया जा सकता है। एक दृष्टिकोण के लिए लूप को नियोजित करना है, जो आपको सरणी के माध्यम से पुनरावृति करने और प्रत्येक तत्व को मान निर्दिष्ट करने में सक्षम बनाता है।
int यहाँ [ ] नंबर = नया इंट [ 5 ] ;के लिए ( int मैं = 0 ; मैं < संख्या। लंबाई; मैं++ )
{
नंबर [ मैं ] = मैं + 1 ;
}
यह कोड 5 के आकार के साथ संख्याओं के नाम से एक पूर्णांक सरणी बनाता है और प्रत्येक तत्व को उसके सूचकांक प्लस 1 के बराबर मान प्रदान करता है। यहां एक उदाहरण दिया गया है कि लूप का उपयोग करके C # में 2-आयामी पूर्णांक सरणी को कैसे आरंभ किया जाए:
के लिए ( int मैं = 0 ; मैं < 3 ; मैं++ )
{
के लिए ( इंट जे = 0 ; जे < 2 ; जे ++ )
{
myArray [ मैं, जे ] = मैं + जे;
}
}
इस उदाहरण में, हम 2-आयामी पूर्णांक सरणी के प्रत्येक तत्व के माध्यम से लूप के लिए नेस्टेड का उपयोग कर रहे हैं myArray , जिसमें 3 पंक्तियाँ और 2 स्तंभ हैं। प्रत्येक तत्व के लिए, हम अभिव्यक्ति i + j का उपयोग करके इसके मूल्य को इसकी पंक्ति और स्तंभ सूचकांकों के योग पर सेट कर रहे हैं।
प्रत्येक सरणी में मानों को प्रिंट करने के लिए कोड के साथ-साथ सी # में 1-आयामी और 2-आयामी सरणी दोनों को प्रारंभ करने के लिए लूप का उपयोग करने का एक उदाहरण यहां दिया गया है:
सिस्टम का उपयोग करना;वर्ग सरणी
{
स्थैतिक शून्य मुख्य ( डोरी [ ] तर्क )
{
// ए प्रारंभ कर रहा है 1 एक पाश का उपयोग कर -आयामी सरणी
int यहाँ [ ] myArray1D = नया int [ 5 ] ;
के लिए ( int मैं = 0 ; मैं < myArray1D.लंबाई; मैं++ )
{
myArray1D [ मैं ] = मैं + 1 ;
}
कंसोल। राइटलाइन ( 'MyArray1D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < myArray1D.लंबाई; मैं++ )
{
कंसोल। राइटलाइन ( myArray1D [ मैं ] ) ;
}
// ए प्रारंभ कर रहा है 2 नेस्टेड लूप का उपयोग करके आयामी सरणी
int यहाँ [ , ] myArray2D = नया int [ 3 , 2 ] ;
के लिए ( int मैं = 0 ; मैं < 3 ; मैं++ )
{
के लिए ( इंट जे = 0 ; जे < 2 ; जे ++ )
{
myArray2D [ मैं, जे ] = मैं + जे;
}
}
कंसोल। राइटलाइन ( 'MyArray2D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < 3 ; मैं++ )
{
के लिए ( इंट जे = 0 ; जे < 2 ; जे ++ )
{
कंसोल। राइटलाइन ( '({0}, {1}): {2}' , आई, जे, myArray2D [ मैं, जे ] ) ;
}
}
}
}
इस कोड में, हम 1, 2, 3, 4, और 5 मानों के साथ myArray1D नामक 1-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए लूप का उपयोग कर रहे हैं। हम 2-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए लूप के लिए नेस्टेड का भी उपयोग कर रहे हैं। myArray2D अभिव्यक्ति i + j का उपयोग करके {0, 1}, {1, 2}, और {2, 3} मानों के साथ।
फिर लूप के लिए अतिरिक्त का उपयोग प्रत्येक सरणी के प्रत्येक तत्व के माध्यम से पुनरावृति करने के लिए करें और इसके मूल्य को कंसोल पर प्रिंट करें।
4: Array.Copy () का उपयोग करके सरणियों को आरंभ करना
किसी सरणी को प्रारंभ करने के लिए एक वैकल्पिक दृष्टिकोण में Array.Copy() फ़ंक्शन का उपयोग करना शामिल है। इसमें वांछित तत्वों के साथ एक स्रोत सरणी बनाना और फिर उन्हें लक्ष्य सरणी में कॉपी करना शामिल है। उदाहरण के लिए:
int यहाँ [ ] स्रोत = { 1 , 2 , 3 , 4 , 5 } ;int यहाँ [ ] लक्ष्य = नया इंट [ स्रोत। लंबाई ] ;
ऐरे।कॉपी ( स्रोत , लक्ष्य, स्रोत। लंबाई ) ;
यह कोड 1 से 5 के मान के साथ स्रोत नामक एक पूर्णांक सरणी बनाता है, स्रोत के समान आकार के साथ लक्ष्य नाम का एक नया पूर्णांक सरणी बनाता है, और फिर स्रोत से लक्ष्य तक तत्वों की प्रतिलिपि बनाता है।
मुझे सी # में द्वि-आयामी पूर्णांक सरणी प्रारंभ करने के लिए Array.Copy के उपयोग का प्रदर्शन करने वाला एक उदाहरण प्रस्तुत करने की अनुमति दें:
int यहाँ [ , ] स्रोतअरे = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int यहाँ [ , ] डेस्टिनेशनअरे = नया इंट [ 3 , 2 ] ;
ऐरे।कॉपी ( स्रोतअरे, गंतव्यअरे, स्रोतअरे.लंबाई ) ;
इस उदाहरण में, हमारे पास एक 2-आयामी पूर्णांक सरणी है जिसे कहा जाता है स्रोतअरे 3 पंक्तियों और 2 स्तंभों के साथ। हम प्रयोग कर रहे हैं ऐरे। कॉपी () SourceArray की सामग्री को एक नए 2-आयामी पूर्णांक सरणी में कॉपी करने के लिए जिसे डेस्टिनेशनएरे कहा जाता है, जिसमें 3 पंक्तियाँ और 2 कॉलम भी होते हैं।
ऐरे। कॉपी () विधि लेता है तीन तर्क : द स्रोत सरणी , द गंतव्य सरणी , और यह लंबाई कॉपी किए जाने वाले डेटा की। इस मामले में, हम की संपूर्ण सामग्री की नकल कर रहे हैं स्रोतअरे में डेस्टिनेशनअरे , तो हम गुजरते हैं स्रोतअरे। लंबाई तीसरे तर्क के रूप में।
ध्यान दें कि आप प्रयोग कर सकते हैं ऐरे। कॉपी () किसी भी संख्या के आयामों के साथ सरणियों को आरंभ करने के लिए, जब तक कि स्रोत और गंतव्य सरणियों में आयामों की संख्या समान हो और प्रत्येक आयाम में समान आकार हो।
साथ ही इसका भी ध्यान रखें ऐरे। कॉपी () स्रोत सरणी की उथली प्रतिलिपि करता है, जिसका अर्थ है कि यदि स्रोत सरणी में संदर्भ प्रकार हैं, तो संदर्भों की प्रतिलिपि बनाई जाएगी लेकिन ऑब्जेक्ट स्वयं डुप्लिकेट नहीं होंगे।
यहां पूरा कोड है जो उपयोग करता है ऐरे। कॉपी () सी # में सरणी प्रारंभ करने के लिए कार्य:
सिस्टम का उपयोग करना;वर्ग सरणी
{
स्थैतिक शून्य मुख्य ( डोरी [ ] तर्क )
{
// ए प्रारंभ कर रहा है 1 -आयामी सरणी Array.Copy का उपयोग कर
int यहाँ [ ] स्रोतअरे1डी = { 1 , 2 , 3 , 4 , 5 } ;
int यहाँ [ ] डेस्टिनेशनएरे 1 डी = नया इंट [ 5 ] ;
ऐरे।कॉपी ( स्रोतअरे1डी, गंतव्यअरे1डी, स्रोतअरे1डी.लंबाई ) ;
कंसोल। राइटलाइन ( 'गंतव्य Array1D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < डेस्टिनेशनअरे1डी.लंबाई; मैं++ ) {
कंसोल। राइटलाइन ( डेस्टिनेशनArray1D [ मैं ] ) ;
}
// ए प्रारंभ कर रहा है 2 -आयामी सरणी Array.Copy का उपयोग कर
int यहाँ [ , ] स्रोतअरे2डी = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int यहाँ [ , ] डेस्टिनेशनअरे2डी = नया इंट [ 3 , 2 ] ;
ऐरे।कॉपी ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
कंसोल। राइटलाइन ( 'गंतव्य Array2D में मान:' ) ;
के लिए ( int मैं = 0 ; मैं < डेस्टिनेशनअरे2डी.गेट लेंथ ( 0 ) ; मैं++ ) {
के लिए ( इंट जे = 0 ; जे < डेस्टिनेशनअरे2डी.गेट लेंथ ( 1 ) ; जे ++ ) {
कंसोल। राइटलाइन ( '({0}, {1}): {2}' , आई, जे, डेस्टिनेशनअरे2डी [ मैं, जे ] ) ;
}
}
}
}
इस कोड में, हम उपयोग कर रहे हैं ऐरे। कॉपी () SourceArray1D नामक स्रोत सरणी से 1, 2, 3, 4, और 5 मानों के साथ डेस्टिनेशनएरे1डी नामक 1-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए।
हम भी प्रयोग कर रहे हैं ऐरे। कॉपी () SourceArray2D नामक स्रोत सरणी से {1, 2}, {3, 4}, और {5, 6} मानों के साथ डेस्टिनेशनअरे2डी नामक 2-आयामी पूर्णांक सरणी को प्रारंभ करने के लिए।
फिर हम प्रत्येक सरणी के प्रत्येक तत्व के माध्यम से लूप के लिए अतिरिक्त का उपयोग कर रहे हैं और कंसोल पर इसके मान को प्रिंट कर रहे हैं।
निष्कर्ष
इस लेख में, हमने C # में सरणियों को आरंभ करने के विभिन्न तरीकों की खोज की। हमने नए कीवर्ड का उपयोग करके, लूप का उपयोग करके सरणियों को इनिशियलाइज़ करते हुए, और Array.Copy () विधि का उपयोग करके, ऐरे इनिशियलाइज़र सिंटैक्स को कवर किया। विशिष्ट उपयोग के मामले के आधार पर, इनमें से प्रत्येक विधि के अपने फायदे और नुकसान हैं। इन विविध दृष्टिकोणों से परिचित होने से आप अपनी विशेष आवश्यकताओं के लिए सबसे उपयुक्त एक का चयन करने में सक्षम होंगे।