في C # ، تعمل المصفوفات كحاويات لتخزين عناصر من نفس نوع البيانات. عند إنشاء مصفوفة ، هناك طرق متعددة لتهيئتها بالعناصر. تتعمق هذه المقالة في الطرق المختلفة لتهيئة المصفوفات في C # ، مما يوفر استكشافًا شاملاً لكل نهج.
طرق تهيئة المصفوفات في C #
المصفوفات هي بنية بيانات أساسية في برمجة الكمبيوتر تسمح لك بتخزين ومعالجة مجموعة من العناصر من نفس نوع البيانات في مواقع الذاكرة المتجاورة. فيما يلي بعض الطرق لتهيئة المصفوفات في C #:
1: تهيئة المصفوفات باستخدام بناء جملة مُهيئ الصفيف
الطريقة الأكثر وضوحًا لتهيئة المصفوفة هي استخدام بناء جملة مُهيئ المصفوفة حيث يتضمن ذلك إحاطة عناصر المصفوفة بأقواس ، مفصولة بفواصل ، على سبيل المثال:
int [ ] الأرقام = { 1 و 2 و 3 و 4 و 5 } ؛
في هذا الرمز ، يتم إنشاء مصفوفة أعداد صحيحة تسمى 'أرقام' وتهيئتها بالقيم من 1 إلى 5. وبالمثل ، يمكنك استخدام نفس الصيغة لتهيئة مصفوفة متعددة الأبعاد.
int [ و ] myMultiDimensionalArray = { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛
فيما يلي مثال على رمز يستخدم بناء جملة المُهيئ لتهيئة مصفوفة 1D و 2 D في C #:
باستخدام النظام ؛
مجموعة الصف
{
ثابت الفراغ الرئيسي ( خيط [ ] أرجس )
{
// تهيئة مصفوفة 1D باستخدام صيغة المُهيئ
int [ ] array1D = { 1 و 2 و 3 و 4 و 5 } ؛
وحدة التحكم ( 'القيم في array1D:' ) ؛
ل ( int أنا = 0 ؛ أنا < array1D.Length. أنا ++ ) {
وحدة التحكم ( array1D [ أنا ] ) ؛
}
// تهيئة مصفوفة ثنائية الأبعاد باستخدام صيغة المُهيئ
int [ و ] array2D = { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛
وحدة التحكم ( 'القيم في array2D:' ) ؛
ل ( int أنا = 0 ؛ أنا < array2D.GetLength ( 0 ) ؛ أنا ++ ) {
ل ( int j = 0 ؛ ي < array2D.GetLength ( 1 ) ؛ ي ++ ) {
وحدة التحكم ( '({0} ، {1}): {2}' , i, j, array2D [ اي جاي ] ) ؛
}
}
}
}
في هذه الشفرة ، نستخدم صيغة المُهيئ لتهيئة مصفوفة عدد صحيح أحادي البعد تسمى array1D بالقيم 1 و 2 و 3 و 4 و 5.
نستخدم أيضًا بنية التهيئة لتهيئة مصفوفة عدد صحيح ثنائي الأبعاد تسمى array2D بالقيم {1 ، 2} ، {3 ، 4} ، و {5 ، 6}.
ثم نستخدم حلقات for إضافية للتكرار خلال كل عنصر في كل مصفوفة وطباعة قيمته على وحدة التحكم.
2: تهيئة المصفوفات باستخدام الكلمة الرئيسية الجديدة
هناك طريقة إضافية لتهيئة مصفوفة تتضمن استخدام جديد كلمة رئيسية. يتضمن ذلك تحديد حجم المصفوفة بين أقواس مربعة ، متبوعة بالكلمة الأساسية الجديدة ، ثم نوع البيانات لعناصر المصفوفة. على سبيل المثال:
int [ ] أرقام = كثافة العمليات الجديدة [ 5 ] ؛
ينشئ هذا الرمز مصفوفة عدد صحيح باسم أرقام بحجم 5 ويهيئ جميع العناصر إلى قيمتها الافتراضية ، وهي 0 لمصفوفات الأعداد الصحيحة.
فيما يلي بناء الجملة لتهيئة مصفوفة متعددة الأبعاد باستخدام الكلمة الرئيسية الجديدة في C #:
< يكتب > [ و ] < اسم الصفيف > = جديد < يكتب > [ < الطول 1 > و < الطول 2 > ، ... ] { { < القيم الأولية > } } ؛
في بناء الجملة هذا ،
فيما يلي مثال على كيفية استخدام بناء الجملة هذا لتهيئة مصفوفة عدد صحيح ثنائي الأبعاد:
int [ و ] myArray = كثافة العمليات الجديدة [ 3 و 2 ] { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛
في هذا المثال ، نقوم بتهيئة مصفوفة عدد صحيح ثنائي الأبعاد تسمى myArray تتكون من 3 صفوف وعمودين باستخدام الكلمة الأساسية الجديدة. نحن نقدم أيضًا قيمًا أولية لكل عنصر من عناصر المصفوفة باستخدام بنية الأقواس المزدوجة المتعرجة. القيم هي {1 ، 2} ، {3 ، 4} ، و {5 ، 6} ، المقابلة للعناصر في كل صف.
فيما يلي مثال على كيفية استخدام الكلمة الرئيسية الجديدة لتهيئة مصفوفة ثنائية الأبعاد وثنائية الأبعاد في C # ، جنبًا إلى جنب مع رمز لطباعة القيم في كل مصفوفة:
باستخدام النظام ؛مجموعة الصف
{
ثابت الفراغ الرئيسي ( خيط [ ] أرجس )
{
// التهيئة أ 1 مجموعة الأبعاد
int [ ] myArray1D = كثافة العمليات الجديدة [ ] { 1 و 2 و 3 و 4 و 5 } ؛
وحدة التحكم ( 'القيم الموجودة في myArray1D:' ) ؛
ل ( int أنا = 0 ؛ أنا < myArray1D.Length ؛ أنا ++ )
{
وحدة التحكم ( myArray1D [ أنا ] ) ؛
}
// التهيئة أ 2 مجموعة الأبعاد
int [ و ] myArray2D = كثافة العمليات الجديدة [ و ] { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛
وحدة التحكم ( 'القيم الموجودة في myArray2D:' ) ؛
ل ( int أنا = 0 ؛ أنا < myArray2D.GetLength ( 0 ) ؛ أنا ++ )
{
ل ( int j = 0 ؛ ي < myArray2D.GetLength ( 1 ) ؛ ي ++ )
{
وحدة التحكم ( '({0} ، {1}): {2}' ، i ، j ، myArray2D [ اي جاي ] ) ؛
}
}
}
}
في هذا الكود ، نستخدم الكلمة الأساسية الجديدة لتهيئة مصفوفة عدد صحيح أحادي البعد يسمى myArray1D مع القيم 1 و 2 و 3 و 4 و 5 ، وتسمى مصفوفة عدد صحيح ثنائي الأبعاد myArray2D بالقيم {1 و 2} و {3 و 4} و {5 و 6}.
ثم نستخدم حلقات for للتكرار خلال كل عنصر في كل مصفوفة وطباعة قيمته على وحدة التحكم. لاحظ أننا نستخدم المصفوفة ثنائية الأبعاد GetLength () لتحديد عدد الصفوف والأعمدة ، واستخدام حلقات for المتداخلة للتكرار خلال كل عنصر.
3: تهيئة المصفوفات باستخدام الحلقات
يمكن أيضًا تهيئة المصفوفات باستخدام الحلقات. تتمثل إحدى الطرق في استخدام حلقة for ، والتي تمكنك من تكرار المصفوفة وتعيين قيم لكل عنصر.
int [ ] أرقام = كثافة العمليات الجديدة [ 5 ] ؛ل ( int أنا = 0 ؛ أنا < الأرقام. أنا ++ )
{
أعداد [ أنا ] = أنا + 1 ؛
}
تنشئ هذه الشفرة مصفوفة عدد صحيح باسم أرقام بحجم 5 وتخصص لكل عنصر قيمة تساوي الفهرس الخاص به زائد 1. إليك مثال على كيفية تهيئة مصفوفة عدد صحيح ثنائي الأبعاد في C # باستخدام الحلقات:
ل ( int أنا = 0 ؛ أنا < 3 ؛ أنا ++ )
{
ل ( int j = 0 ؛ ي < 2 ؛ ي ++ )
{
صفيفي [ اي جاي ] = أنا + ي ؛
}
}
في هذا المثال ، نستخدم حلقات for المتداخلة للتكرار خلال كل عنصر في مصفوفة عدد صحيح ثنائي الأبعاد تسمى صفيفي ، والتي تتكون من 3 صفوف وعمودين. لكل عنصر ، نقوم بتعيين قيمته على مجموع مؤشري الصفوف والأعمدة باستخدام التعبير i + j.
فيما يلي مثال على كيفية استخدام الحلقات لتهيئة مصفوفة ثنائية الأبعاد وثنائية الأبعاد في C # ، جنبًا إلى جنب مع رمز لطباعة القيم في كل مصفوفة:
باستخدام النظام ؛مجموعة الصف
{
ثابت الفراغ الرئيسي ( خيط [ ] أرجس )
{
// التهيئة أ 1 مصفوفة ذات أبعاد باستخدام حلقة
int [ ] myArray1D = كثافة العمليات الجديدة [ 5 ] ؛
ل ( int أنا = 0 ؛ أنا < myArray1D.Length ؛ أنا ++ )
{
myArray1D [ أنا ] = أنا + 1 ؛
}
وحدة التحكم ( 'القيم الموجودة في myArray1D:' ) ؛
ل ( int أنا = 0 ؛ أنا < myArray1D.Length ؛ أنا ++ )
{
وحدة التحكم ( myArray1D [ أنا ] ) ؛
}
// التهيئة أ 2 مصفوفة ذات أبعاد باستخدام حلقات متداخلة
int [ و ] myArray2D = كثافة العمليات الجديدة [ 3 و 2 ] ؛
ل ( int أنا = 0 ؛ أنا < 3 ؛ أنا ++ )
{
ل ( int j = 0 ؛ ي < 2 ؛ ي ++ )
{
myArray2D [ اي جاي ] = أنا + ي ؛
}
}
وحدة التحكم ( 'القيم الموجودة في myArray2D:' ) ؛
ل ( int أنا = 0 ؛ أنا < 3 ؛ أنا ++ )
{
ل ( int j = 0 ؛ ي < 2 ؛ ي ++ )
{
وحدة التحكم ( '({0} ، {1}): {2}' ، i ، j ، myArray2D [ اي جاي ] ) ؛
}
}
}
}
في هذا الكود ، نستخدم حلقة for لتهيئة مصفوفة عدد صحيح أحادي البعد تسمى myArray1D بالقيم 1 و 2 و 3 و 4 و 5. كما نستخدم حلقات for متداخلة لتهيئة مصفوفة عدد صحيح ثنائي الأبعاد تسمى myArray2D مع القيم {0 ، 1} ، {1 ، 2} ، و {2 ، 3} باستخدام التعبير i + j.
ثم استخدم حلقات for إضافية لتكرار كل عنصر في كل مصفوفة وطباعة قيمته على وحدة التحكم.
4: تهيئة المصفوفات باستخدام Array.Copy ()
طريقة بديلة لتهيئة مصفوفة تتضمن استخدام الدالة Array.Copy (). يتضمن ذلك إنشاء مصفوفة مصدر بالعناصر المطلوبة ثم نسخها إلى مصفوفة هدف. على سبيل المثال:
int [ ] مصدر = { 1 و 2 و 3 و 4 و 5 } ؛int [ ] الهدف = كثافة العمليات الجديدة [ المصدر. الطول ] ؛
مجموعة نسخ ( مصدر الهدف المصدر الطول ) ؛
ينشئ هذا الكود مصفوفة عدد صحيح مسمى المصدر مع القيم من 1 إلى 5 ، وينشئ مصفوفة أعداد صحيحة جديدة باسم target بنفس حجم المصدر ، ثم ينسخ العناصر من المصدر إلى الهدف.
اسمح لي بتقديم مثال يوضح استخدام Array.Copy لتهيئة مصفوفة عدد صحيح ثنائي الأبعاد في C #:
int [ و ] sourceArray = { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛int [ و ] DestinationArray = عدد صحيح جديد [ 3 و 2 ] ؛
مجموعة نسخ ( sourceArray ، destinationArray ، sourceArray.Length ) ؛
في هذا المثال ، لدينا مصفوفة عدد صحيح ثنائي الأبعاد تسمى المصدر مع 3 صفوف وعمودين. نحن نستخدم Array.Copy () لنسخ محتويات sourceArray إلى مصفوفة أعداد صحيحة جديدة ثنائية الأبعاد تسمى DestArray ، والتي تحتوي أيضًا على 3 صفوف وعمودين.
ال Array.Copy () تأخذ الطريقة ثلاث حجج : ال مجموعة المصدر ، ال مجموعة الوجهة ، و ال طول من البيانات المراد نسخها. في هذه الحالة ، نقوم بنسخ محتوى المصدر داخل الوجهة ، لذلك نحن نجتاز المصدر: مصفوفة الطول كالحجة الثالثة.
لاحظ أنه يمكنك استخدام Array.Copy () لتهيئة المصفوفات بأي عدد من الأبعاد ، طالما أن مصفوفات المصدر والوجهة لها نفس عدد الأبعاد ونفس الحجم في كل بُعد.
أيضا ، ضع في اعتبارك ذلك Array.Copy () ينفذ نسخة ضحلة من المصفوفة المصدر ، مما يعني أنه إذا احتوت المصفوفة المصدر على أنواع مرجعية ، فسيتم نسخ المراجع ولكن لن يتم تكرار الكائنات نفسها.
هذا هو الكود الكامل الذي يستخدم Array.Copy () وظيفة لتهيئة المصفوفة في C #:
باستخدام النظام ؛مجموعة الصف
{
ثابت الفراغ الرئيسي ( خيط [ ] أرجس )
{
// التهيئة أ 1 مصفوفة ذات أبعاد باستخدام Array.Copy
int [ ] sourceArray1D = { 1 و 2 و 3 و 4 و 5 } ؛
int [ ] DestinationArray1D = عدد صحيح جديد [ 5 ] ؛
مجموعة نسخ ( sourceArray1D، destinationArray1D، sourceArray1D.Length ) ؛
وحدة التحكم ( 'القيم في destinationArray1D:' ) ؛
ل ( int أنا = 0 ؛ أنا < DestinationArray1D.Length؛ أنا ++ ) {
وحدة التحكم ( الوجهة [ أنا ] ) ؛
}
// التهيئة أ 2 مصفوفة ذات أبعاد باستخدام Array.Copy
int [ و ] sourceArray2D = { { 1 و 2 } و { 3 و 4 } و { 5 و 6 } } ؛
int [ و ] DestinationArray2D = عدد صحيح جديد [ 3 و 2 ] ؛
مجموعة نسخ ( sourceArray2D، destinationArray2D، sourceArray2D.Length ) ؛
وحدة التحكم ( 'القيم في destinationArray2D:' ) ؛
ل ( int أنا = 0 ؛ أنا < DestinationArray2D.GetLength ( 0 ) ؛ أنا ++ ) {
ل ( int j = 0 ؛ ي < DestinationArray2D.GetLength ( 1 ) ؛ ي ++ ) {
وحدة التحكم ( '({0} ، {1}): {2}' ط ، ي ، وجهة Array2D [ اي جاي ] ) ؛
}
}
}
}
في هذا الكود ، نستخدم Array.Copy () لتهيئة مصفوفة عدد صحيح أحادي البعد تسمى destinationArray1D بالقيم 1 و 2 و 3 و 4 و 5 من مصفوفة مصدر تسمى sourceArray1D.
نحن نستخدم أيضًا ملفات Array.Copy () لتهيئة مصفوفة عدد صحيح ثنائي الأبعاد تسمى destinationArray2D بالقيم {1 و 2} و {3 و 4} و {5 و 6} من مصفوفة مصدر تسمى sourceArray2D.
ثم نستخدم حلقات for إضافية للتكرار خلال كل عنصر في كل مصفوفة وطباعة قيمته على وحدة التحكم.
خاتمة
في هذه المقالة ، اكتشفنا طرقًا مختلفة لتهيئة المصفوفات في C #. قمنا بتغطية بناء جملة مُهيئ المصفوفة ، باستخدام الكلمة الأساسية الجديدة ، وتهيئة المصفوفات باستخدام الحلقات ، واستخدام طريقة Array.Copy (). اعتمادًا على حالة الاستخدام المحددة ، تمتلك كل طريقة من هذه الطرق مجموعتها الخاصة من المزايا والعيوب. إن التعرف على هذه الأساليب المتنوعة سيمكنك من اختيار الأنسب لمتطلباتك الخاصة.