+- منتدى فيجوال بيسك لكل العرب | منتدى المبرمجين العرب (http://vb4arb.com/vb)
+-- قسم : قسم لغة السي شارب C#.NET (http://vb4arb.com/vb/forumdisplay.php?fid=175)
+--- قسم : قسم مقالات C#.NET (http://vb4arb.com/vb/forumdisplay.php?fid=177)
+--- الموضوع : [مقال] المؤشرات Pointers (/showthread.php?tid=2851)
المؤشرات Pointers - الشاكي لله - 12-05-14
السلام عليكم ورحمة الله وبركاته
المؤشرات هي نوع بيانات - وكما يشير إسمها هي أنها تؤشر أو تشير إلى شيء ما ، وذلك الشيء هو موقع في الذاكرة يحوي قيمة ما،تكمن أهميتها في أنها تتعامل مع الذاكرة مباشرة و تعطيك سرعة في برنامجك وأن هناك دوال API تتطلب إعطائها قيم من نوع مؤشرات - خاصة عندما نريد معرفة سرعة أو معلومات عن الهاردوير (المعالج أو الذاكرة...) والكثير من الأمور التي تتطلب إستعمال المؤشرات.
-بشكل آخر : المؤشرات هي نوع بيانات تحمل عنوانا في الذاكرة .
-كل موقع في الذاكرة له عنوان يبدأ من الـ0 إلى نهاية عدد غرف أو صناديق أو مواقع الذاكرة وفي الأصل يكون الترقيم فيها بالنضام السداسي عشريHex 0123456789ABCDEF
مثال بسيط :
انت سائق ويجب عليك توصل ضرف لاحد الاشخاص وسوف اعطيك عنوان ويجب عليك
اخذ ذالك الطريق للوصول للعنوان
تماما المؤشرات هي عنوان يشير الى مكان في الذاكره
--
فائده المؤشرات :
• احتياج بعض ال COM Components او ال dll's الى استخدام pointers
• محاولة تحسين اداء وسرعة مهمة معينة من خلال الوصول المباشر للذاكرة ، مثل عمليات الImage Processing التي تتطلب رحلات متكررة الى الذاكرة
• التحكم في قيم الذاكره بعيد عن قيود الدوت نت
--
المؤشرات هيه العباره التي اغلب المبرمجين يرتعبون منها حتى المحترفين
لانه التعامل معها ليس بلامر السهل
لاكن مع الوقت والممارسه سوف تصبح سهله جدا
شاع استخدام المؤشرات (Pointers) في لغات البرمجة، بالخصوص C و C++، حيث لم يكن لها بديل لأداء الكثير من الوظائف و العمليات الحيوية التي لا غنى عنها في العديد من البرامج، مثل المصفوفات غير محددة الحجم (Dynamic Array) و مصفوفة المصفوفات أو ما يسمى بـ (Jagged Arrays) و منها مصفوفة السلاسل الحرفية (Strings Array) و كذلك في عملية (Late or Dynamic Binding) و غيرها من الحالات التي لا غنى عن استخدام المؤشرات (Pointers) فيها .
هذا الاستخدام و إن قدم خدمات جليلة للمبرمجين و سرع من أداء البرامج و التطبيقات، إلا أنه بالمقابل زاد العبء على المبرمج الذي أصبح يخصص جزءا لا بأس به من وقته لمراقبة و إدارة موارد النظام و لاسيما الذاكرة يدويا – عن طريق برنامجه طبعا – حيث ما من وسيلة لعمل ذلك آليا (Dynamically)، و بسبب هذا الوقت "الضائع” و الذي يأخذ جزءا كبيرا من الوقت المخصص لإنجاز البرامج أو التطبيقات، و حاجة الشركات إلى إنجاز مشاريعها بأسرع ما يمكن، إضافة إلى وقوع المبرمجين – هاويهم و محترفهم – في أخطاء "قاتلة” قد تؤدي إلى فشل البرنامج في إنجاز مهامه التي صمم من أجلها، تم طرح البدائل في لغات البرمجة التي تلت C و C++ أو اشتقت منها، و قد يكون المثال الأبرز هنا هو لغة جافا (Java) التي يقوم فيها (Garbage Collector) أو ما يعرف اختصارا بـ (GC) بعملية إدارة الذاكرة و تهيئة المتغيرات فيها و إزالتها منها عند انتفاء الحاجة لها و في الوقت المناسب.
هذه البدائل سرعت من عملية التطوير و إنجاز المشاريع، و قللت من الأخطاء التي كانت تحصل نتيجة الإدارة اليدوية للذاكرة، و أصبح المبرمج يركز اهتمامه على عمل البرنامج بدل التركيز على أفضل السبل لإدارة الذاكرة.
لكن مما يؤسف له أن هذه البدائل نظرت إلى المؤشرات (Pointers) على أنها "الشر كله”، و منعت المبرمج من التعامل المباشر مع الذاكرة، و حرمته من أحد أهم الميزات التي كانت متوفرة في C أو C++، و التي كانت تمكنه بحرية و مرونة من تحديد ما يريد من برنامجه أن يعمل، و هذا – بالتالي – أثر سلبا على قدرات و إمكانيات البرامج و التطبيقات في التعامل مع الذاكرة، و أثر كذلك على سرعة أداء التطبيقات التي تحتاج إلى القيام بعمليات كثيرة في الذاكرة، أو القيام بـ "رحلات” متكررة من و إلى الذاكرة. لاحظ معي المثال التالي – المكتوب بلغة سي شارب
PHP كود :
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) و ما إلى ذلك، لاحظ الأمثلة التالية:
PHP كود :
// 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) و إلا لن يكون بالإمكان الإشارة إليها.
تأمل معي الأمثلة التالية و التي توضح النقاط السابقة، و طريقة تعريف المؤشرات، و إسناد القيم إليها، و قراءة القيم التي تشير إليها:
PHP كود :
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)
{
// 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):
PHP كود :
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 i = 0; i > 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#، إلا أن تجنب استخدامها أولى من استخدامها، ما لم تكن تؤدي للمبرمج أعمالا و تنجز له أمورا بحيث لا يمكن الاستغناء عنها بغيرها.
* منقول من مصادر عديدة .
انتهى
RE: المؤشرات Pointers - Sajad - 12-05-14
السلام عليكم
جزاك الله خيرا معلومات رائعة
تحياتي