C# இல், வரிசைகள் ஒரே தரவு வகையின் கூறுகளை சேமிப்பதற்கான கொள்கலன்களாக செயல்படுகின்றன. ஒரு வரிசையை உருவாக்கும் போது, அதை உறுப்புகளுடன் துவக்க பல அணுகுமுறைகள் உள்ளன. இந்தக் கட்டுரையானது சி# இல் வரிசைகளை துவக்குவதற்கான வெவ்வேறு முறைகளை ஆராய்கிறது, இது ஒவ்வொரு அணுகுமுறையின் விரிவான ஆய்வையும் வழங்குகிறது.
C# இல் வரிசைகளை துவக்குவதற்கான முறைகள்
வரிசைகள் என்பது கணினி நிரலாக்கத்தில் ஒரு இன்றியமையாத தரவுக் கட்டமைப்பாகும், இது தொடர்ச்சியான நினைவக இடங்களில் ஒரே தரவு வகையின் தனிமங்களின் தொகுப்பைச் சேமிக்கவும் கையாளவும் உங்களை அனுமதிக்கிறது. C# இல் வரிசைகளை துவக்க சில வழிகள்:
1: Array Initializer தொடரியல் பயன்படுத்தி வரிசைகளை துவக்குதல்
ஒரு வரிசையை துவக்குவதற்கான மிக நேரடியான அணுகுமுறை வரிசை துவக்கி தொடரியல் பயன்படுத்துவதாகும், ஏனெனில் இது காற்புள்ளிகளால் பிரிக்கப்பட்ட பிரேஸ்களில் வரிசை கூறுகளை இணைப்பதை உள்ளடக்குகிறது, எடுத்துக்காட்டாக:
முழு எண்ணாக [ ] எண்கள் = { 1 , 2 , 3 , 4 , 5 } ;
இந்தக் குறியீட்டில், 'எண்கள்' என்ற பெயரில் ஒரு முழு எண் வரிசை 1 முதல் 5 வரையிலான மதிப்புகளுடன் உருவாக்கப்பட்டு துவக்கப்படுகிறது. இதேபோல், பல பரிமாண வரிசையை துவக்க அதே தொடரியல் பயன்படுத்தலாம்.
முழு எண்ணாக [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
C# இல் 1D மற்றும் 2D வரிசையை துவக்குவதற்கு இனிஷியலைசர் தொடரியல் பயன்படுத்தும் எடுத்துக்காட்டு குறியீடு இங்கே:
கணினியைப் பயன்படுத்துதல்;
வகுப்பு வரிசை
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
// துவக்கி தொடரியல் பயன்படுத்தி 1D வரிசையை துவக்குகிறது
முழு எண்ணாக [ ] வரிசை1D = { 1 , 2 , 3 , 4 , 5 } ;
கன்சோல்.WriteLine ( 'வரிசை1D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < வரிசை1D.நீளம்; நான்++ ) {
கன்சோல்.WriteLine ( வரிசை1D [ நான் ] ) ;
}
// துவக்கி தொடரியல் பயன்படுத்தி 2D வரிசையை துவக்குதல்
முழு எண்ணாக [ , ] வரிசை2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
கன்சோல்.WriteLine ( 'வரிசை2D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < array2D.GetLength ( 0 ) ; நான்++ ) {
க்கான ( int j = 0 ; ஜே < array2D.GetLength ( 1 ) ; j++ ) {
கன்சோல்.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ நான், ஜே ] ) ;
}
}
}
}
இந்தக் குறியீட்டில், 1, 2, 3, 4 மற்றும் 5 மதிப்புகளுடன் array1D எனப்படும் 1-பரிமாண முழு எண் வரிசையைத் துவக்குவதற்கு நாம் துவக்கி தொடரியல் பயன்படுத்துகிறோம்.
{1, 2}, {3, 4} மற்றும் {5, 6} மதிப்புகளுடன் array2D எனப்படும் 2-பரிமாண முழு எண் வரிசையைத் தொடங்குவதற்கு நாங்கள் துவக்கி தொடரியல் பயன்படுத்துகிறோம்.
ஒவ்வொரு வரிசையின் ஒவ்வொரு தனிமத்தின் வழியாகச் செயல்படுவதற்கும் அதன் மதிப்பை கன்சோலில் அச்சிடுவதற்கும் லூப்களுக்கு கூடுதல் பயன்படுத்துகிறோம்.
2: புதிய முக்கிய சொல்லைப் பயன்படுத்தி அணிவரிசைகளைத் தொடங்குதல்
ஒரு வரிசையை துவக்குவதற்கான கூடுதல் முறையானது, பயன்படுத்துவதை உள்ளடக்கியது புதிய முக்கிய வார்த்தை. சதுர அடைப்புக்குறிக்குள் வரிசையின் அளவைக் குறிப்பிடுவதும், அதைத் தொடர்ந்து புதிய திறவுச்சொல்லைக் குறிப்பிடுவதும், பின்னர் வரிசை உறுப்புகளின் தரவு வகையும் இதில் அடங்கும். உதாரணத்திற்கு:
முழு எண்ணாக [ ] எண்கள் = புதிய எண்ணாக [ 5 ] ;
இந்த குறியீடு 5 அளவு கொண்ட எண்கள் என்ற பெயரில் ஒரு முழு எண் வரிசையை உருவாக்குகிறது மற்றும் அனைத்து உறுப்புகளையும் அவற்றின் இயல்புநிலை மதிப்பிற்கு துவக்குகிறது, இது முழு எண் வரிசைகளுக்கு 0 ஆகும்.
C# இல் உள்ள புதிய முக்கிய சொல்லைப் பயன்படுத்தி பல பரிமாண வரிசையைத் தொடங்குவதற்கான தொடரியல் இங்கே:
< வகை > [ , ] < வரிசை பெயர் > = புதியது < வகை > [ < நீளம்1 > , < நீளம்2 > ,... ] { { < ஆரம்ப மதிப்புகள் > } } ;
இந்த தொடரியல்,
2 பரிமாண முழு எண் வரிசையை துவக்க இந்த தொடரியல் எவ்வாறு பயன்படுத்த வேண்டும் என்பதற்கான எடுத்துக்காட்டு இங்கே:
முழு எண்ணாக [ , ] myArray = புதிய எண்ணாக [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
இந்த எடுத்துக்காட்டில், புதிய முக்கிய சொல்லைப் பயன்படுத்தி 3 வரிசைகள் மற்றும் 2 நெடுவரிசைகளுடன் myArray எனப்படும் 2d முழு எண் வரிசையை துவக்குகிறோம். இரட்டை சுருள் பிரேஸ் தொடரியலைப் பயன்படுத்தி அணிவரிசையின் ஒவ்வொரு உறுப்புக்கும் ஆரம்ப மதிப்புகளையும் வழங்குகிறோம். ஒவ்வொரு வரிசையிலும் உள்ள உறுப்புகளுடன் தொடர்புடைய மதிப்புகள் {1, 2}, {3, 4} மற்றும் {5, 6} ஆகும்.
C# இல் 1-பரிமாண மற்றும் 2-பரிமாண வரிசையை தொடங்குவதற்கு புதிய முக்கிய சொல்லை எவ்வாறு பயன்படுத்துவது என்பதற்கான எடுத்துக்காட்டு இங்கே உள்ளது, மேலும் ஒவ்வொரு அணிவரிசையிலும் உள்ள மதிப்புகளை அச்சிட குறியீட்டுடன்:
கணினியைப் பயன்படுத்துதல்;வகுப்பு வரிசை
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
// தொடங்குதல் a 1 - பரிமாண வரிசை
முழு எண்ணாக [ ] myArray1D = புதிய எண்ணாக [ ] { 1 , 2 , 3 , 4 , 5 } ;
கன்சோல்.WriteLine ( 'myArray1D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < myArray1D.Length; நான்++ )
{
கன்சோல்.WriteLine ( myArray1D [ நான் ] ) ;
}
// தொடங்குதல் a 2 - பரிமாண வரிசை
முழு எண்ணாக [ , ] myArray2D = புதிய எண்ணாக [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
கன்சோல்.WriteLine ( 'myArray2D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < myArray2D.GetLength ( 0 ) ; நான்++ )
{
க்கான ( int j = 0 ; ஜே < myArray2D.GetLength ( 1 ) ; j++ )
{
கன்சோல்.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ நான், ஜே ] ) ;
}
}
}
}
இந்த குறியீட்டில், ஒரு பரிமாண முழு எண் வரிசையை துவக்க புதிய முக்கிய சொல்லைப் பயன்படுத்துகிறோம் myArray1D 1, 2, 3, 4 மற்றும் 5 மதிப்புகள் மற்றும் 2 பரிமாண முழு எண் வரிசை எனப்படும் myArray2D {1, 2}, {3, 4} மற்றும் {5, 6} மதிப்புகளுடன்.
ஒவ்வொரு வரிசையின் ஒவ்வொரு உறுப்பின் மூலம் மீண்டும் செயல்படுவதற்கும் அதன் மதிப்பை கன்சோலில் அச்சிடுவதற்கும் லூப்களைப் பயன்படுத்துகிறோம். 2 பரிமாண வரிசைக்கு, நாங்கள் பயன்படுத்துகிறோம் என்பதை நினைவில் கொள்க நீளம்() வரிசைகள் மற்றும் நெடுவரிசைகளின் எண்ணிக்கையைத் தீர்மானிக்கவும், மேலும் ஒவ்வொரு உறுப்பு வழியாகவும் லூப்களுக்கு உள்ளமைவைப் பயன்படுத்தவும்.
3: லூப்களைப் பயன்படுத்தி வரிசைகளை துவக்குதல்
சுழல்களைப் பயன்படுத்தி அணிவரிசைகளையும் துவக்கலாம். ஒரு அணுகுமுறை for loop ஐப் பயன்படுத்துவதாகும், இது வரிசையின் மூலம் மீண்டும் மீண்டும் செய்யவும் மற்றும் ஒவ்வொரு உறுப்புக்கும் மதிப்புகளை ஒதுக்கவும் உதவுகிறது.
முழு எண்ணாக [ ] எண்கள் = புதிய எண்ணாக [ 5 ] ;க்கான ( int i = 0 ; நான் < எண்கள்.நீளம்; நான்++ )
{
எண்கள் [ நான் ] = நான் + 1 ;
}
இந்தக் குறியீடு 5 அளவு கொண்ட எண்கள் என்ற பெயரில் ஒரு முழு எண் வரிசையை உருவாக்குகிறது மற்றும் ஒவ்வொரு உறுப்புக்கும் அதன் குறியீட்டு மற்றும் 1 க்கு சமமான மதிப்பை ஒதுக்குகிறது. சுழல்களைப் பயன்படுத்தி C# இல் 2 பரிமாண முழு எண் வரிசையை எவ்வாறு துவக்குவது என்பதற்கான எடுத்துக்காட்டு இங்கே:
க்கான ( int i = 0 ; நான் < 3 ; நான்++ )
{
க்கான ( int j = 0 ; ஜே < 2 ; j++ )
{
myarray [ நான், ஜே ] = i + j;
}
}
இந்த எடுத்துக்காட்டில், 2-பரிமாண முழு எண் வரிசையின் ஒவ்வொரு தனிமத்தின் மூலமாகவும் மீண்டும் செயல்பட, லூப்களுக்கான நெஸ்ட்டைப் பயன்படுத்துகிறோம். myarray , இதில் 3 வரிசைகள் மற்றும் 2 நெடுவரிசைகள் உள்ளன. ஒவ்வொரு உறுப்புக்கும், i + j என்ற வெளிப்பாட்டைப் பயன்படுத்தி அதன் வரிசை மற்றும் நெடுவரிசை குறியீடுகளின் கூட்டுத்தொகைக்கு அதன் மதிப்பை அமைக்கிறோம்.
C# இல் 1-பரிமாண மற்றும் 2-பரிமாண வரிசை இரண்டையும் தொடங்குவதற்கு சுழல்களை எவ்வாறு பயன்படுத்துவது என்பதற்கான எடுத்துக்காட்டு இங்கே உள்ளது, மேலும் ஒவ்வொரு அணிவரிசையிலும் உள்ள மதிப்புகளை அச்சிடுவதற்கான குறியீட்டுடன்:
கணினியைப் பயன்படுத்துதல்;வகுப்பு வரிசை
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
// தொடங்குதல் a 1 ஒரு வளையத்தைப் பயன்படுத்தி பரிமாண வரிசை
முழு எண்ணாக [ ] myArray1D = புதிய எண்ணாக [ 5 ] ;
க்கான ( int i = 0 ; நான் < myArray1D.Length; நான்++ )
{
myArray1D [ நான் ] = நான் + 1 ;
}
கன்சோல்.WriteLine ( 'myArray1D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < myArray1D.Length; நான்++ )
{
கன்சோல்.WriteLine ( myArray1D [ நான் ] ) ;
}
// தொடங்குதல் a 2 உள்ளமை சுழல்களைப் பயன்படுத்தி பரிமாண வரிசை
முழு எண்ணாக [ , ] myArray2D = புதிய எண்ணாக [ 3 , 2 ] ;
க்கான ( int i = 0 ; நான் < 3 ; நான்++ )
{
க்கான ( int j = 0 ; ஜே < 2 ; j++ )
{
myArray2D [ நான், ஜே ] = i + j;
}
}
கன்சோல்.WriteLine ( 'myArray2D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < 3 ; நான்++ )
{
க்கான ( int j = 0 ; ஜே < 2 ; j++ )
{
கன்சோல்.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ நான், ஜே ] ) ;
}
}
}
}
இந்தக் குறியீட்டில், 1, 2, 3, 4, மற்றும் 5 மதிப்புகளுடன் myArray1D எனப்படும் 1-பரிமாண முழு எண் வரிசையை துவக்குவதற்கு for loop ஐப் பயன்படுத்துகிறோம். 2-பரிமாண முழு எண் வரிசையை துவக்குவதற்கு nested for loops ஐப் பயன்படுத்துகிறோம். i + j என்ற வெளிப்பாட்டைப் பயன்படுத்தி {0, 1}, {1, 2} மற்றும் {2, 3} மதிப்புகளுடன் myArray2D.
ஒவ்வொரு வரிசையின் ஒவ்வொரு தனிமத்தின் வழியாகவும், அதன் மதிப்பை கன்சோலில் அச்சிடுவதற்கு கூடுதல் சுழல்களைப் பயன்படுத்தவும்.
4: Array.Copy()ஐப் பயன்படுத்தி வரிசைகளை துவக்குதல்
ஒரு வரிசையை துவக்குவதற்கான மாற்று அணுகுமுறை Array.Copy() செயல்பாட்டைப் பயன்படுத்துகிறது. இது தேவையான கூறுகளுடன் ஒரு மூல வரிசையை உருவாக்கி பின்னர் அவற்றை இலக்கு வரிசையில் நகலெடுப்பதை உள்ளடக்குகிறது. உதாரணத்திற்கு:
முழு எண்ணாக [ ] ஆதாரம் = { 1 , 2 , 3 , 4 , 5 } ;முழு எண்ணாக [ ] இலக்கு = புதிய எண்ணாக [ ஆதாரம்.நீளம் ] ;
வரிசை. நகல் ( ஆதாரம் , இலக்கு, ஆதாரம்.நீளம் ) ;
இந்தக் குறியீடு 1 முதல் 5 வரையிலான மதிப்புகளைக் கொண்ட ஒரு முழு எண் வரிசையை உருவாக்குகிறது, அதே அளவு மூலத்துடன் இலக்கு என்ற புதிய முழு எண் வரிசையை உருவாக்குகிறது, பின்னர் மூலத்திலிருந்து இலக்குக்கு உறுப்புகளை நகலெடுக்கிறது.
C# இல் இரு பரிமாண முழு எண் வரிசையை துவக்க Array.Copy இன் பயன்பாட்டை நிரூபிக்கும் ஒரு உதாரணத்தை முன்வைக்க என்னை அனுமதிக்கவும்:
முழு எண்ணாக [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;முழு எண்ணாக [ , ] destinationArray = புதிய முழு எண்ணாக [ 3 , 2 ] ;
வரிசை. நகல் ( sourceArray, destinationArray, sourceArray.Length ) ;
இந்த எடுத்துக்காட்டில், எங்களிடம் 2 பரிமாண முழு எண் வரிசை உள்ளது மூலவரிசை 3 வரிசைகள் மற்றும் 2 நெடுவரிசைகளுடன். பயன்படுத்தி வருகிறோம் வரிசை. நகல்() sourceArray இன் உள்ளடக்கங்களை destinationArray எனப்படும் புதிய 2 பரிமாண முழு எண் வரிசையில் நகலெடுக்க, இதில் 3 வரிசைகள் மற்றும் 2 நெடுவரிசைகள் உள்ளன.
தி வரிசை. நகல்() முறை எடுக்கும் மூன்று வாதங்கள் : தி மூல வரிசை , தி இலக்கு வரிசை , மற்றும் இந்த நீளம் நகலெடுக்க வேண்டிய தரவு. இந்த வழக்கில், நாங்கள் முழு உள்ளடக்கத்தையும் நகலெடுக்கிறோம் மூலவரிசை உள்ளே இலக்குவரிசை , அதனால் நாங்கள் கடந்து செல்கிறோம் sourceArray.Length மூன்றாவது வாதமாக.
நீங்கள் பயன்படுத்தலாம் என்பதை நினைவில் கொள்க வரிசை. நகல்() ஒவ்வொரு பரிமாணத்திலும் ஒரே எண்ணிக்கையிலான பரிமாணங்கள் மற்றும் ஒரே அளவு இருக்கும் வரை, எந்த எண்ணிக்கையிலான பரிமாணங்களுடனும் வரிசைகளை துவக்குவதற்கு.
மேலும், என்பதை நினைவில் கொள்ளவும் வரிசை. நகல்() மூல வரிசையின் மேலோட்டமான நகலை செய்கிறது, அதாவது மூல வரிசையில் குறிப்பு வகைகள் இருந்தால், குறிப்புகள் நகலெடுக்கப்படும், ஆனால் பொருள்களே நகலெடுக்கப்படாது.
பயன்படுத்தப்படும் முழுமையான குறியீடு இங்கே வரிசை. நகல்() C# இல் வரிசையை துவக்குவதற்கான செயல்பாடு:
கணினியைப் பயன்படுத்துதல்;வகுப்பு வரிசை
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
// தொடங்குதல் a 1 - பரிமாண வரிசை வரிசையைப் பயன்படுத்தி. நகல்
முழு எண்ணாக [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
முழு எண்ணாக [ ] destinationArray1D = புதிய முழு எண்ணாக [ 5 ] ;
வரிசை. நகல் ( sourceArray1D, destinationArray1D, sourceArray1D.நீளம் ) ;
கன்சோல்.WriteLine ( 'destinationArray1D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < destinationArray1D.Length; நான்++ ) {
கன்சோல்.WriteLine ( இலக்குவரிசை1D [ நான் ] ) ;
}
// தொடங்குதல் a 2 - பரிமாண வரிசை வரிசையைப் பயன்படுத்தி. நகல்
முழு எண்ணாக [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
முழு எண்ணாக [ , ] destinationArray2D = புதிய முழு எண்ணாக [ 3 , 2 ] ;
வரிசை. நகல் ( sourceArray2D, destinationArray2D, sourceArray2D.நீளம் ) ;
கன்சோல்.WriteLine ( 'destinationArray2D இல் உள்ள மதிப்புகள்:' ) ;
க்கான ( int i = 0 ; நான் < destinationArray2D.GetLength ( 0 ) ; நான்++ ) {
க்கான ( int j = 0 ; ஜே < destinationArray2D.GetLength ( 1 ) ; j++ ) {
கன்சோல்.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ நான், ஜே ] ) ;
}
}
}
}
இந்த குறியீட்டில், நாங்கள் பயன்படுத்துகிறோம் வரிசை. நகல்() sourceArray1D எனப்படும் மூல வரிசையில் இருந்து 1, 2, 3, 4, மற்றும் 5 மதிப்புகளுடன் destinationArray1D எனப்படும் 1-பரிமாண முழு எண் வரிசையை துவக்க.
நாங்களும் பயன்படுத்தி வருகிறோம் வரிசை. நகல்() sourceArray2D எனப்படும் மூல அணிவரிசையிலிருந்து {1, 2}, {3, 4} மற்றும் {5, 6} மதிப்புகளுடன் destinationArray2D எனப்படும் 2-பரிமாண முழு எண் வரிசையைத் தொடங்க.
ஒவ்வொரு வரிசையின் ஒவ்வொரு தனிமத்தின் வழியாகச் செயல்படுவதற்கும் அதன் மதிப்பை கன்சோலில் அச்சிடுவதற்கும் லூப்களுக்கு கூடுதல் பயன்படுத்துகிறோம்.
முடிவுரை
இந்த கட்டுரையில், C# இல் வரிசைகளை துவக்குவதற்கான பல்வேறு வழிகளை நாங்கள் ஆராய்ந்தோம். புதிய முக்கிய சொல்லைப் பயன்படுத்தி, லூப்களைப் பயன்படுத்தி வரிசைகளைத் துவக்கி, மற்றும் Array.Copy() முறையைப் பயன்படுத்தி, வரிசை துவக்கி தொடரியல் உள்ளடக்கியுள்ளோம். குறிப்பிட்ட பயன்பாட்டு வழக்கைப் பொறுத்து, இந்த முறைகள் ஒவ்வொன்றும் அதன் சொந்த நன்மைகள் மற்றும் தீமைகள் உள்ளன. இந்த மாறுபட்ட அணுகுமுறைகளுடன் உங்களைப் பழக்கப்படுத்துவது உங்கள் குறிப்பிட்ட தேவைகளுக்கு மிகவும் பொருத்தமான ஒன்றைத் தேர்ந்தெடுக்க உதவும்.