جديد الصور
جديد البطاقات
جديد الصوتيات
المتواجدون الآن
تغذيات RSS
|
2012-08-10 07:06
المؤشرات في لغة السي#
- ماذا يجب أن تعرف أولا؟
قبل أن نبدأ، و حتى تحصل على الفائدة المرجوة من المقال التالي، يجب أن تكون عندك معرفة جيدة بالأمور التالية:
ما هي المؤشرات (Pointers)؟
ما هي C# و .Net؟
كيفية كتابة برنامج بسيط في C# و ترجمته (Compile).
المواضيع السابقة ليست محل بحث هذا المقال، لكنه يفترض بك المعرفة الجيدة بها، و إن كنت تشعر أن عندك شيئا من القصور في أحد المواضيع السابقة، أرجو أن لا تتردد في القراءة عنه؛ لتحصل على الفائدة المنشودة من المقال التالي، و لا تنس أنه من السهل أن تجد في الإنترنت ضالتك المنشودة.
- محتويات المقال:
المقدمة
كيف و متى تستخدم المؤشرات (Pointers)؟
أنواع المؤشرات (Pointers)
مثال جيد
الخلاصة
- المقدمة:
شاع استخدام المؤشرات (Pointers) في لغات البرمجة، بالخصوص C و C++، حيث لم يكن لها بديل لأداء الكثير من الوظائف و العمليات الحيوية التي لا غنى عنها في العديد من البرامج، مثل المصفوفات غير محددة الحجم (Dynamic Array) و مصفوفة المصفوفات أو ما يسمى بـ (Jagged Arrays) و منها مصفوفة السلاسل الحرفية (Strings Array) و كذلك في عملية (Late or Dynamic Binding) و غيرها من الحالات التي لا غنى عن استخدام المؤشرات (Pointers) فيها.
هذا الاستخدام و إن قدم خدمات جليلة للمبرمجين و سرع من أداء البرامج و التطبيقات، إلا أنه بالمقابل زاد العبء على المبرمج الذي أصبح يخصص جزءا لا بأس به من وقته لمراقبة و إدارة موارد النظام و لاسيما الذاكرة يدويا - عن طريق برنامجه طبعا - حيث ما من وسيلة لعمل ذلك آليا (Dynamically)، و بسبب هذا الوقت "الضائع" و الذي يأخذ جزءا كبيرا من الوقت المخصص لإنجاز البرامج أو التطبيقات، و حاجة الشركات إلى إنجاز مشاريعها بأسرع ما يمكن، إضافة إلى وقوع المبرمجين - هاويهم و محترفهم - في أخطاء "قاتلة" قد تؤدي إلى فشل البرنامج في إنجاز مهامه التي صمم من أجلها، تم طرح البدائل في لغات البرمجة التي تلت C و C++ أو اشتقت منها، و قد يكون المثال الأبرز هنا هو لغة جافا (Java) التي يقوم فيها (Garbage Collector) أو ما يعرف اختصارا بـ (GC) بعملية إدارة الذاكرة و تهيئة المتغيرات فيها و إزالتها منها عند انتفاء الحاجة لها و في الوقت المناسب.
هذه البدائل سرعت من عملية التطوير و إنجاز المشاريع، و قللت من الأخطاء التي كانت تحصل نتيجة الإدارة اليدوية للذاكرة، و أصبح المبرمج يركز اهتمامه على عمل البرنامج بدل التركيز على أفضل السبل لإدارة الذاكرة.
لكن مما يؤسف له أن هذه البدائل نظرت إلى المؤشرات (Pointers) على أنها "شر كلها"، و منعت المبرمج من التعامل المباشر مع الذاكرة، و حرمته من أحد أهم الميزات التي كانت متوفرة في C أو C++، و التي كانت تمكنه بحرية و مرونة من تحديد ما يريد من برنامجه أن يعمل، و هذا - بالتالي - أثر سلبا على قدرات و إمكانيات البرامج و التطبيقات في التعامل مع الذاكرة، و أثر كذلك على سرعة أداء التطبيقات التي تحتاج إلى القيام بعمليات كثيرة في الذاكرة، أو القيام بـ "رحلات" متكررة من و إلى الذاكرة. لاحظ معي المثال التالي - المكتوب بلغة C# -
// NormalCopy.cs
using System;
public class NormalCopy
{
public static void CopyArray(byte [] Src, byte [] Dst)
{
for (int j = 0; j < 10000; ++j)
for (int i = 0; i < Src.Length; ++i)
Dst[i] = Src[i];
}
public static void Main()
{
byte [] MySrcArray = new byte[1000];
byte [] MyDstArray = new byte[1000];
for (int i = 0; i < MySrcArray.Length; ++i)
MySrcArray[i] = (byte) i;
CopyArray(MySrcArray, MyDstArray);
Console.Read();
}
}
ملاحظة مهمة جدا: المثال السابق و كل الأمثلة التالية ما هي إلا وسيلة لإيصال فكرة معينة و ليس مثالا يحتذى في الطريقة المثلى للبرمجة
في المثال السابق، يتطلب نسخ مصفوفة (Array) مكونة من 1000 عنصر من نوع (byte) لأخرى "رحلات منتظمة" ذهابا و إيابا من و إلى الذاكرة، و ما يصاحب ذلك من عمليات قراءة و كتابة و حجز و تفريغ و ما شابه ذلك، مما يؤثر سلبا على سرعة أداء البرنامج. البرنامج السابق استغرق من الوقت حوالي (0.02923) ثانية لتنفيذه أو ما يقارب الثلاثة أجزاء بالمائة من الثانية، وقت قصير، أليس كذلك؟ احفظ هذا الرقم لأننا سنعود إليه لاحقا. أرجو الانتباه هنا إلى أن لا فائدة من التكرار (Loop) الأول غير زيادة الوقت المستغرق لتنفيذ البرنامج، و نحن بحاجة لذلك في مثالنا لحصول على زمن معقول يفيدنا في عملية المقارنة.
و بسبب الحاجة لاستخدام المؤشرات (Pointers) و الحاجة لإدارة الذاكرة آليا تم بناء لغة برمجة تجمع ما بين الإثنين، و هي C#، و تم فيها توفير الإمكانيات لإدارة الذاكرة آليا عن طريق GC - كما في جافا (Java) - إضافة إلى إمكانية الإدارة شبه اليدوية للذاكرة باستخدام المؤشرات (Pointers)، حيث يكون المبرمج مسؤولا عن تعرف و إدارة متغيرات الذاكرة - المؤشرات (Pointers) - دون أن يكون مسؤولا عن عمليات التفريغ و التنظيف كما هو الحال في C و C++.
- كيف و متى تستخدم المؤشرات (Pointers)؟
بسبب صعوبة الجمع بين الإدارة الآلية و اليدوية للذاكرة، إضافة إلى طبيعة بنية و هدف C#، كان لزاما على مصممي اللغة وضع شروط و ضوابط تحكم و تحد استخدام المؤشرات في C#، و لكن قبل أن نتعرف على هذه الشروط و الضوابط يجب الانتباه إلى أن استخدام المؤشرات (Pointers) في C# غير مستحسن، إلا في حالة أن يكون استخدامها يزيد من سرعة أداء برنامجك بنسب معقولة، أو أن تكون بحاجة لاستخدام مكتبات ربط ديناميكي (DLL) و ما شابهها أو كائنات (COM) و غيرها، و التي لا تكون خاضعة لنظام إدارة الذاكرة التابع لـ .Net ففي هذه الحالات يكون استخدام المؤشرات (Pointers) منطقيا أو أمرا لا بد منه، أما ما سوى ذلك فلا، لأن C# و إضافة إلى أنها وفرت على المبرمج أداء العمليات الاعتيادية المرتبطة بالذاكرة، و التي كان عليه إنجازها يدويا في C و C++، و بسرعة تضاهي سرعة برامج هاتين اللغتين، فهي لا تعاني من البطء الذي تعاني منه برامج لغات أخرى مثل جافا (Java)، و أضف إلى هذا و ذاك المجموعة الهائلة من المكتبات (Libraries) و الفئات (Classes) التي تشكل البنية التحتية (Infrastructure) لـ .Net و التي تغني المبرمج - في الغالب - من الحاجة الغوص بنفسه في أعماق النظام، و بالتالي الحاجة لاستخدام المؤشرات (Pointers).
عند استخدام المؤشرات (Pointers) في C#، يجب استخدامها ضمن العبارة (unsafe) و هي كلمة محجوزة (Reserved word or Keyword) تحدد جزء الشيفرة (Code) الذي يتضمن استخداما للمؤشرات (Pointers)، و هذه الكلمة يمكن استخدامها بمفردها أو عند تعريف الأعضاء (Members) سواء كانت من الخصائص (Properties) أو الوظائف (Functions) أو المشيدات (Constructors) أو غيرها و كذلك عند تعريف الفئات (Classes) و ما إلى ذلك، لاحظ الأمثلة التالية:
// Using 'unsafe' as block in a function
void MyFunction()
{
...
unsafe
{
// Unsafe code to be here
}
...
}
// Using 'unsafe' in function declaration
unsafe void MyFunction()
{
// Do something
}
// Using 'unsafe' in class declaration
unsafe class MyClass
{
// Class body to be here
}
و السبب الداعي لاستخدام (unsafe) هو أن .Net تتبع سياسة معينة في الأمان، فلا يتم تنفيذ أي ملف أو جزء منه إلا إن كان ذلك التنفيذ آمنا - بعد قيام .Net بالتأكد من ذلك - و هذا يتحقق في حالة عدم استخدام المؤشرات (Pointers)، أما عند استخدام (unsafe) فلا يتم التنفيذ إلا في حالة توفر بيئة موثوقة، لأن .Net لا تقوم بالتأكد من كون التنفيذ آمنا.
عند ترجمة الشيفرة (Code) المتضمنة عبارة (unsafe) إلى (Intermediate Language) أو ما يعرف اختصارا بـ (IL) و تحويل الشيفرة المصدرية (Source Code) إلى (Assembly) - ملف تنفيذي (exe) أو مكتبة (dll) و غيرها - يتم التعامل مع (Assembly) كاملا باعتباره (unsafe)، لأن (unsafe) في .Net يعرّف على مستوى (Assembly).
يجب أن تعلم أخيرا أنه عند ترجمة شيفرة C# أو (Compile C# Code) تحتوي على عبارة (unsafe) يجب أن ترسل الأمر (/unsafe) إلى مترجم C# أو (C# Compiler) كما في المثال التالي:
csc /unsafe MyFile.cs
حيث إن (csc) هو مترجم C# أو (C# Compiler) - كما هو معلوم -، و (MyFile.cs) هو الملف المراد ترجمته (Compile) إلى (IL)
- أنواع المؤشرات (Pointers):
أنواع المؤشرات (Pointer Types) محدودة في C#، و الأمر ليس مطلقا كما هو الحال في C و C++، و ليس كل نوع من البيانات (Data Type) يمكن الإشارة إليه باستخدام المؤشر (Pointer)، و سبب ذلك يعود إلى محدودية الحالات التي يتطلب استخدام المؤشرات (Pointers) فيها، و الحفاظ على طابع و بنية C# الآمنة (Type Safe)، إضافة إلى أن طبيعة تعرف الكائنات (Objects) في C# يقوم على مبدأ تعريف مؤشر لكائن (Pointer to Object) الموجود في C++، لاحظ المثال التالي:
MyClass MyObject = new MyClass(); // in C#
MyClass * MyObject = new MyClass(); // in C++
المؤشرات في C# على نوعين:
void *: و هو المؤشر (Pointer) غير محدد النوع.
type *
و (type) هو أحد الأنواع التالية:
أنواع القيم (Value Types) و هي: bool, sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, enum
أنواع المؤشرات (Pointer Types): أي المؤشرات على المؤشرات (Pointer to Pointer)
الأنواع المعرفة من قبل المستخدم (User-Define Types): و هي أي أنواع من قبيل التراكيب أو السجلات (Structures) و ليست الفئات (Classes)، فالأولى تعتبر من أنواع القيم (Value Types) و التي يمكن الإشارة إليها (Pointing to)، و الثانية من الأنواع المرجعية (Reference Types) و التي لا يمكن الإشارة إليها بأي حال للسبب المذكور في الفقرة السابقة، و لكن تستثنى المصفوفات (Arrays) من الأنواع المرجعية (Reference Types) التي لا يمكن الإشارة إليها، حيث إن الإشارة للمصفوفات (Arrays) ممكنة لكن بشرط سنأتي على ذكره لاحقا. و أخيرا يجب الانتباه إلى أن التراكيب أو السجلات (Structures) يجب أن لا تحتوي في تركيبها على أي من الأنواع المرجعية (Reference Types) و إلا لن يكون بالإمكان الإشارة إليها.
تأمل معي الأمثلة التالية و التي توضح النقاط السابقة، و طريقة تعريف المؤشرات، و إسناد القيم إليها، و قراءة القيم التي تشير إليها:
byte * pMyByte; // Pointer to byte bool * pMyBool; // Pointer to bool
int * * pMyInt; // Pointer to pointer to int
long * [] pMyLong; // Array of pointers to long
void * pMyVoid; // Pointer to unknown type
char * pC1, pC2; // Two Pointers to char
// string * pMyString; // Error, 'string' is reference type
// The compiler generates the following error message:
// Indirection to managed type is not valid
byte MyByte = 10; // byte variable
pMyByte = & MyByte; // pMyByte now points to MyByte (i.e. The value
// of pMyByte is the address of MyByte)
// Array of bool
bool [] MyBool = {true, false, false, true};
// pMyBool = MyBool // Error, arrays is also reference types
// The compiler generates the following error message:
// Cannot implicitly convert type 'bool[]' to 'bool*'
// To point to an array use 'fixed' statement
fixed (bool * pB = MyBool)
{
for (int i = 0; i < MyBool.Length; ++i)
Console.WriteLine((pB + i)->ToString());
// pB++; // Error, pB is fixed
// The compiler generates the following error message:
// Cannot assign to 'pB' because it is read-only
}
// Print the value of MyByte (Will prints 10)
Console.WriteLine("MyByte is: {0}", * pMyByte);
// Another way to get the value of MyByte (Will prints 10) Console.WriteLine("MyByte is: {0}", pMyByte->ToString());
و مما تقدم و من الأمثلة السابقة يمكننا ملاحظة التالي:
(*) هي جزء من اسم النوع (Type Name) و ليست سابقة لاسم المتغير (Variable Name) كما هو الحال في C و C++، و يتضح ذلك في المثال: (char * pC1, pC2) حيث تم تعريف مؤشرين من نوع (char *)، أما في C و C++ فنتيجة العبارة السابقة هي تعريف مؤشر (Pointer) لـ (char) و هو (pC1) و متغير من نوع (char) هو (pC2)
تستخدم (*) أو ما يعرف بـ (Pointer Indirection Operator) للحصول على القيمة التي يشير إليها المؤشر (Pointer) مثلما هو الحال في C و C++، لكن الاختلاف في C# يكمن في أنه لا يمكن الحصول على قيمة المؤشر نفسه - عنوان المتغير الذي يشير إليه -
المؤشر من نوع (T *) يحتوي - كقيمة له - عنوان متغير من نوع (T)
إن كان نوع الكائن (Object) من أنواع المؤشرات (Pointer Types) يتم استخدام المعامل (Operator) (->) بدل المعامل (Operator) (.) للوصول إلى أعضاء هذا الكائن كما هو واضح في المثال: (pMyByte->ToString())
لأن المصفوفات (Arrays) من الأنواع المرجعية (Reference Types) فهي تخضع نظام الإدارة الآلية للذاكرة، و بالتحديد لـ (GC)، و هي معرضة في أي وقت لتغيير عنوانها - عنوان العنصر الأول فيها - أو للإزالة نهائيا من الذاكرة - عند انتفاء الحاجة إليها - و لذلك عند الإشارة للمصفوفات (Pointing to Arrays) نستخدم العبارة (fixed) التي تحمي الكائن (Object) - مؤقتا - من عمليات (GC)، و تثبته في محله. و لأن استخدام العبارة (fixed) لا يتناسب مع طبيعة و هدف (GC)، لا يمكن حجز و تثبيت الكائن (Object) إلا لفترة قصيرة، و لإنجاز عمليات سريعة تتطلب وجود الكائن (Object) في محله حتى الانتهاء منها. و هنا يجب الانتباه إلى أن المؤشر (Pointer) الذي يتم تعريفه في العبارة (fixed) ثابت القيمة - المكان الذي يشير إليه -، و لا يمكن تغيير قيمته.
- مثال جيد:
الآن و بعد أن عرفنا كيف و متى نستخدم المؤشرات (Pointers)، نستطيع العودة لمثالنا الأول (NormalCopy.cs) و التعديل عليه حتى نسرع من عمليه نسخ المصفوفة (Array)، و فيما يلي المثال بعد التعديل (الفكرة مقتبسة من مكتبة MSDN):
// FastCopy.cs
using System;
public class FastCopy
{
public static unsafe void CopyArray(byte [] Src, byte [] Dst)
{
fixed (byte * pSrc = Src, pDst = Dst)
{
byte * pS = pSrc;
byte * pD = pDst;
int Count = Src.Length;
for (int j = 0; j < 10000; ++j)
{
for (int i = Count >> 2; i != 0; --i)
{
* ((int *) pD) = * ((int *) pS);
pD += 4;
pS += 4;
}
for (Count &= 3; Count != 0; --Count)
{
* pD = * pS;
pD++;
pS++;
}
}
}
}
public static void Main()
{
byte [] MySrcArray = new byte[100];
byte [] MyDstArray = new byte[100];
for(int i = 0; i < MySrcArray.Length; ++i)
MySrcArray[i] = (byte) i;
CopyArray(MySrcArray, MyDstArray);
Console.Read();
}
}
في المثال السابق تم استخدام مؤشر (Pointer) من نوع (int *) للقيام بنسخ كل أربعة عناصر معا، و هذا يقلل من عدد المرات التي نحتاج فيها للقراءة و الكتابة من و إلى الذاكرة. لاحظ في التكرار (Loop) الثاني استخدام المعامل (>>) أو (Right-Shift Operator) الذي يقوم بإزاحة العدد الثنائي - العامل (Operand) الأيسر - نحو اليمين بالمقدار المعطى في العامل (Operand) الأيمن. ففي مثالنا (Count >> 2) تم إزاحة الرقم 1000 و هو (1111101000) بالثنائي خانتين نحو اليمين - أزيل منه رقمان من اليمين - ليصبح (11111010) و هو 250 بالعشري، إي إن إزالة رقمين من اليمين يقسم العدد - قسمة صحيحة - على أربعة (هل تستطيع أن تخمن نتيجة الإزاحة خانة أو ثلاث؟) و أخيرا في التكرار (Loop) الثالث استخدمنا المعامل (&) أو (Bitwise AND) الذي يقوم بضرب كل خانة من الرقم الثنائي - العامل (Operand) الأيمن - مع نظيرتها في الرقم الثنائي الآخر - العامل (Operand) الأيسر -. و في مثالنا (Count &= 3) تكون النتيجة باقي قسمة الرقم 1000 على 4. إن الهدف من التكرار (Loop) الثاني هو نسخ العناصر أربعا أربعا، أما التكرار (Loop) الثالث فهدفه نسخ ما تبقى من عناصر، إن كان عدد عناصر المصفوفة (Array) لا يقبل القسمة على أربعة، و لا ننسى أن التكرار (Loop) الأول فقط لزيادة وقت تنفيذ البرنامج.
على الرغم من أن المثال السابق أطول من المثال الأول، و قد يبدو معقدا كذلك، إلا أنه استغرق (0.00087) ثانية لإتمام التنفيذ، و بالمقارنة مع الزمن الذي حصلنا عليه في المرة السابقة، يبدو فارق السرعة بين المثالين واضحا جدا لصالح المثال السابق، فالزمن الذي سجله المثال الأول أطول بما يزيد عن 36 مرة، و هذا الفارق أكثر من كاف للمبرمج ليتخذ قراره باستخدام المؤشرات (Pointers) إن كان برنامجه يقوم بالكثير من هذه العمليات التي تستهلك وقتا يمكن توفيره لصالح سرعة الأداء.
في الإنترنت تجد العديد من الأمثلة الحقيقية و الأكثر تعقيدا و التي تجعل من استخدام المؤشرات (Pointers) أمرا لا بد منه. كما تجد في مكتبة MSDN مثالا جميلا عن استخدام المؤشرات (Pointers) في معالجة الصور، و ما توفره لك من إمكانيات و سرعة أداء لا يمكن الوصول إليها بدون استخدام المؤشرات (Pointers).
- الخلاصة:
و خلاصة القول أن المؤشرات (Pointers) في C# لا تختلف كثيرا عن نظيراتها في C و C++، و لكن و على الرغم من توفر ميزة استخدام المؤشرات (Pointers) في C#، إلا أن تجنب استخدامها أولى من استخدامها، ما لم تكن تؤدي للمبرمج أعمالا و تنجز له أمورا بحيث لا يمكن الاستغناء عنها بغيرها.
|
|
|
خدمات المحتوى
|
تقييم
|
|
|
الرئيسية
الصور
البطاقات
الأخبار
المقالات
الصوتيات
0 | 
0 | 
697
