المؤشر (برمجة الحاسوب)

في لغة C ، الصيغة الأساسية لتعريف المؤشر هي: ^{[ 4 ]}

int * ptr ;

يُعلن هذا عن متغير ptrيخزن مؤشرًا إلى كائن من النوع int. يمكن استخدام أنواع أخرى بدلاً من int؛ على سبيل المثال، bool *ptrسيُعلن عن مؤشر إلى كائن من النوع bool.

بعد تعريف المؤشر، يمكن إسناد عنوان إليه. في لغة C، يمكن استرجاع عنوان المتغير باستخدام &المعامل الأحادي :

// تعريف متغير لمؤشر إلى عدد صحيح int * ptr ; // تعريف متغير لعدد صحيح int a = 5 ; // إسناد عنوان a إلى متغير المؤشر ptr = &a a ؛

لإلغاء مرجعية المؤشر، مما ينتج عنه الكائن الذي يشير إليه، *يمكن استخدام علامة النجمة ( ):

printf ( "%d \n " , * ptr ); // يطبع: 5

هناك نمطان لإعلان المؤشر intالمسمى ptr:

• int*ptr;مما يؤكد أن التعبير *ptrله نوع int. ^{[ 5 ]}
• int*ptr;وهذا يؤكد على أن ptrله نوعًا int*. هذا الأسلوب أكثر شيوعًا في لغة C++ منه في لغة C. ^{[ 6 ] [ 7 ]}

يُصرّح كل من و بأنه مؤشر إلى ، بينما يُصرّح بأنه . وذلك لأن ينطبق فقط على المتغير الذي يليه مباشرةً. ^{[ 5 ]}int*x,y;int*x,y;xintyint*

يمكن أيضًا استخدام علامة النجمة على الجانب الأيسر من عملية التعيين لتغيير الكائن aدون الحاجة إلى أن يكون في نفس النطاق.

* ptr = 8 ;

إذا aتم الوصول إليها لاحقًا، فستكون قيمتها الجديدة 8.

لأن لغة C لا تُحدد تهيئة ضمنية للكائنات ذات مدة التخزين التلقائي، ^{[ 8 ]} فقد تُشير متغيرات المؤشر أحيانًا إلى مواقع غير متوقعة، مما يُسبب سلوكًا غير مُحدد. ولمعالجة هذه المشكلة، تُهيأ المؤشرات أحيانًا بقيمة مؤشر فارغة ، ممثلة في لغة C بواسطة NULLالماكرو؛ ^{[ 9 ]} وفي C23 والإصدارات الأحدث، nullptrيتوفر أيضًا كبديل، وهو من النوع nullptr_t. ^{[ 10 ]}

int * ptr = NULL ; int * ptr = nullptr ; // منذ C23

يؤدي إلغاء مرجعية مؤشر فارغ إلى سلوك غير محدد ، ^{[ 11 ]} مما قد يؤدي إلى أخطاء ونتائج غير متوقعة.

قد يكون هذا المثال أوضح إذا تم فحص الذاكرة مباشرةً. افترض أن المتغير aموجود في العنوان 0x8130 في الذاكرة، وأن ptrالمتغير الآخر موجود في العنوان 0x8134؛ وافترض أيضًا أن هذا جهاز 32 بت، بحيث يكون عرض نوع البيانات int هو 32 بت. فيما يلي ما سيكون موجودًا في الذاكرة بعد تنفيذ مقتطف الشفرة التالي:

int a = 5 ; int * ptr = NULL ;

(المؤشر الفارغ الموضح هنا هو 0x00000000 .) عن طريق تعيين عنوان إلى :aptr

ptr = &a a ؛

ينتج عنه قيم الذاكرة التالية:

ثم عن طريق فك المرجع ptrبالترميز:

* ptr = 8 ;

سيقوم الكمبيوتر بأخذ محتويات ptr(وهو 0x8130)، وتحديد موقع ذلك العنوان، وتعيين 8 لذلك الموقع مما ينتج عنه الذاكرة التالية:

من الواضح أن الوصول إلى القيمة aسيؤدي إلى القيمة 8 لأن التعليمات السابقة عدّلت محتويات aالمؤشر ptr.

عند إنشاء هياكل بيانات مثل القوائم والطوابير والأشجار، من الضروري استخدام المؤشرات للمساعدة في إدارة كيفية تنفيذ الهيكل والتحكم فيه. من الأمثلة الشائعة على المؤشرات: مؤشرات البداية، ومؤشرات النهاية، ومؤشرات المكدس . يمكن أن تكون هذه المؤشرات مطلقة ( العنوان الفعلي أو عنوان افتراضي في الذاكرة الافتراضية ) أو نسبية ( إزاحة من عنوان بداية مطلق ("أساس")، والتي عادةً ما تستخدم عددًا أقل من البتات مقارنةً بالعنوان الكامل، ولكنها تتطلب عادةً عملية حسابية إضافية واحدة لحلها).

تُعدّ العناوين النسبية شكلاً من أشكال تجزئة الذاكرة اليدوية ، وتتشارك في العديد من مزاياها وعيوبها. يُمكن استخدام إزاحة ثنائية البايت، تحتوي على عدد صحيح غير مُوقّع من 16 بت، لتوفير عناوين نسبية لما يصل إلى 64 كيلوبايت (2^ ¹⁶ بايت) من بنية البيانات. يُمكن توسيع هذا بسهولة إلى 128 أو 256 أو 512 كيلوبايت إذا تم إجبار العنوان المُشار إليه على المحاذاة على حدود نصف كلمة أو كلمة أو كلمتين (ولكن يتطلب ذلك عملية إزاحة بتية إضافية إلى اليسار - بمقدار 1 أو 2 أو 3 بتات - لضبط الإزاحة بمعامل 2 أو 4 أو 8، قبل إضافتها إلى العنوان الأساسي ). عمومًا، تُعدّ هذه المخططات مُرهقة، ولتسهيل الأمر على المُبرمج، يُفضّل استخدام العناوين المطلقة (والتي تستند إلى مساحة عناوين مُسطّحة ).

يمكن استخدام إزاحة بايت واحد، مثل قيمة ASCII السداسية العشرية لحرف ما (مثلاً X'29')، للإشارة إلى قيمة عددية بديلة (أو فهرس) في مصفوفة (مثلاً X'01'). وبهذه الطريقة، يمكن ترجمة الأحرف بكفاءة عالية من " البيانات الخام " إلى فهرس تسلسلي قابل للاستخدام ، ثم إلى عنوان مطلق دون الحاجة إلى جدول بحث .

int a [ 5 ]; // يُعلن عن 5 أعداد صحيحة متجاورة int * ptr = a ; // تُقيّم أسماء المصفوفات في التعبيرات إلى مؤشرات في معظم الحالات ptr [ 0 ] = 1 ; // يمكن فهرسة المؤشرات باستخدام صيغة المصفوفة * ( a + 1 ) = 2 ; // يمكن فهرسة المصفوفات باستخدام صيغة المؤشر * ( 1 + a ) = 2 ; // جمع المؤشرات تبديلي 2 [ a ] = 4 ; // عامل الفهرسة تبديلي (ربما غير شائع)

int a [ 5 ] = { 2 , 4 , 3 , 1 , 5 };

struct LinkedList { void * data ; // بيانات هذا الرابط struct LinkedList * next ; // الرابط التالي؛ NULL إذا لم يكن هناك رابط };

data LinkedList a = Nil | Cons a ( LinkedList a )

يمكن استخدام المؤشرات لتمرير المتغيرات عبر عناوينها، مما يسمح بتغيير قيمتها. على سبيل المثال، انظر إلى كود C التالي :

// يمكن تغيير نسخة من المتغير الصحيح n داخل الدالة دون التأثير على الكود المُستدعي void passByValue ( int n ) { n = 12 ; }// يتم تمرير مؤشر m بدلاً من ذلك. لا يتم إنشاء نسخة من القيمة التي يشير إليها m. void passByAddress ( int * m ) { * m = 14 ; }int main ( void ) { int x = 3 ;// مرر نسخة من قيمة x كوسيط passByValue ( x ); // تم تغيير القيمة داخل الدالة، لكن x ستظل 3 من الآن فصاعدًا// مرر عنوان x كوسيط passByAddress ( & x ); // تم تغيير قيمة x فعليًا بواسطة الدالة، وهي الآن تساوي 14 هناreturn 0 ; }

في بعض البرامج، يعتمد حجم الذاكرة المطلوبة على ما يُدخله المستخدم . في هذه الحالة، يحتاج المبرمج إلى تخصيص الذاكرة ديناميكيًا. ويتم ذلك بتخصيص الذاكرة في الكومة (heap) بدلًا من المكدس (stack )، حيث تُخزَّن المتغيرات عادةً (مع العلم أنه يمكن أيضًا تخزين المتغيرات في سجلات وحدة المعالجة المركزية). لا يُمكن تخصيص الذاكرة ديناميكيًا إلا من خلال المؤشرات، ولا يُمكن إعطاء أسماء لها ، كما هو الحال مع المتغيرات الشائعة .

تُستخدم المؤشرات لتخزين وإدارة عناوين كتل الذاكرة المُخصصة ديناميكيًا . تُستخدم هذه الكتل لتخزين كائنات البيانات أو مصفوفات الكائنات. توفر معظم لغات البرمجة الهيكلية والموجهة للكائنات مساحة من الذاكرة، تُسمى الكومة أو المخزن الحر ، يتم من خلالها تخصيص الكائنات ديناميكيًا.

يوضح مثال كود C أدناه كيفية تخصيص كائنات البنية ديناميكيًا والإشارة إليها. توفر مكتبة C القياسية دالة malloc()لتخصيص كتل الذاكرة من الكومة. تأخذ هذه الدالة حجم الكائن المراد تخصيصه كمعامل، وتعيد مؤشرًا إلى كتلة ذاكرة مُخصصة حديثًا مناسبة لتخزين الكائن، أو مؤشرًا فارغًا في حال فشل التخصيص.

// عنصر مخزون قطع الغيار typedef struct { int id ; // رقم القطعة char * name ; // اسم القطعة float cost ; // التكلفة } Item ;// تخصيص وتهيئة كائن Item جديد Item * makeItem ( const char * name ) { Item * item ;// تخصيص كتلة من الذاكرة لكائن Item جديد item = malloc ( sizeof ( * item )); if ( ! item ) { return NULL ; }// تهيئة عناصر الكائن الجديد memset ( item , 0 , sizeof ( * item )); item -> id = -1 ; item -> name = NULL ; item -> cost = 0.0 ;// احفظ نسخة من الاسم في العنصر الجديد item- > name = malloc ( strlen ( name ) + 1 ); if ( ! item- > name ) { free ( item ); return NULL ; } strcpy ( item- > name , name );// إرجاع كائن العنصر الذي تم إنشاؤه حديثًا return item ; }

يوضح الكود أدناه كيفية تحرير كائنات الذاكرة ديناميكيًا، أي إعادتها إلى الكومة أو منطقة التخزين الحرة. توفر مكتبة لغة C القياسية دالة free()لتحرير كتلة ذاكرة تم تخصيصها مسبقًا وإعادتها إلى الكومة.

// تحرير كائن Item void destroyItem ( Item * item ) { // التحقق من مؤشر الكائن إذا كان فارغًا if ( ! item ) { return ; }// تحرير اسم السلسلة المخزنة داخل العنصر إذا كان ( item- > name ) { تحرير ( item- > name )؛ item- > name = NULL ؛ }// تحرير كائن العنصر نفسه free ( item ); }

في بعض بنى الحوسبة، يمكن استخدام المؤشرات لمعالجة الذاكرة أو الأجهزة المرتبطة بالذاكرة بشكل مباشر.

يُعدّ تعيين عناوين للمؤشرات أداةً لا غنى عنها عند برمجة المتحكمات الدقيقة . فيما يلي مثال بسيط لتعريف مؤشر من نوع int وتهيئته إلى عنوان سداسي عشري، وفي هذا المثال، الثابت 0x7FFF :

int * hardware_address = ( int * ) 0x7FFF ;

في منتصف ثمانينيات القرن الماضي، كان استخدام نظام الإدخال والإخراج الأساسي (BIOS) للوصول إلى إمكانيات الفيديو في أجهزة الكمبيوتر الشخصية بطيئًا. كانت التطبيقات التي تتطلب عرضًا مكثفًا تستخدم عادةً الوصول إلى ذاكرة فيديو CGA مباشرةً عن طريق تحويل الثابت السداسي العشري 0xB8000 إلى مؤشر إلى مصفوفة من 80 قيمة عددية صحيحة غير مُوقّعة من 16 بت. تتكون كل قيمة من رمز ASCII في البايت الأدنى، ولون في البايت الأعلى. وبالتالي، لوضع الحرف ' A ' في الصف 5، العمود 2 باللون الأبيض الساطع على خلفية زرقاء، كان المستخدم يكتب رمزًا برمجيًا مشابهًا لما يلي:

#define VID ((unsigned short (*)[80])0xB8000)void foo ( void ) { VID [ 4 ] [ 1 ] = 0x1F00 | "أ" ؛ }

تستخدم جداول التحكم ، التي تُستخدم للتحكم في تدفق البرنامج، المؤشرات بشكل مكثف. تُستخدم هذه المؤشرات، التي عادةً ما تكون مُضمنة في مدخل الجدول، على سبيل المثال، لتحديد نقاط دخول الإجراءات الفرعية المراد تنفيذها، بناءً على شروط مُحددة في نفس مدخل الجدول. مع ذلك، يمكن أن تكون المؤشرات مجرد فهارس لجداول أخرى منفصلة، ​​ولكنها مرتبطة، تتضمن مصفوفة من العناوين الفعلية أو العناوين نفسها (بحسب بنيات لغة البرمجة المُتاحة). كما يمكن استخدامها للإشارة إلى مداخل سابقة في الجدول (كما في معالجة الحلقات) أو لتجاوز بعض مداخل الجدول (كما في عبارة switch أو الخروج المبكر من حلقة). لهذا الغرض الأخير، قد يكون "المؤشر" هو رقم مدخل الجدول نفسه، ويمكن تحويله إلى عنوان فعلي من خلال عمليات حسابية بسيطة.

في لغتي C و C++، حتى لو تشابه مؤشران في القيمة، فهذا لا يعني بالضرورة أنهما متكافئان. في هاتين اللغتين و LLVM ، تُفسَّر القاعدة على أنها تعني أن "مجرد إشارة مؤشرين إلى نفس العنوان لا يعني بالضرورة أنهما متساويان بمعنى إمكانية استخدامهما بشكل تبادلي"، ويُشار إلى الفرق بين المؤشرين باسم مصدرهما . [ ^{15 ] إن} تحويل نوع البيانات إلى عدد صحيح، مثل ` uintptr_tint`، مُعرَّفٌ من قِبل التنفيذ، والمقارنة الناتجة عنه لا تُضيف أي معلومات إضافية حول إمكانية استخدام المؤشرين بشكل تبادلي. علاوة على ذلك، فإن أي تحويل إضافي إلى بايتات وإجراء عمليات حسابية سيُربك مُحسِّنات الأداء التي تحاول تتبُّع استخدام المؤشرات، وهي مشكلة لا تزال قيد البحث الأكاديمي. ^{[ 16 ]}

لغة آدا هي لغة ذات كتابة قوية، حيث تكون جميع المؤشرات مُحددة النوع، ولا يُسمح إلا بتحويلات الأنواع الآمنة. تُهيأ جميع المؤشرات افتراضيًا إلى نوع `null` null، وأي محاولة للوصول إلى البيانات من خلال nullمؤشر تُؤدي إلى ظهور استثناء . تُسمى المؤشرات في آدا أنواع الوصول . لم تسمح آدا  83 بإجراء العمليات الحسابية على أنواع الوصول (على الرغم من أن العديد من مُوردي المُترجمات وفروا ذلك كميزة غير قياسية)، لكن آدا  95 تدعم العمليات الحسابية "الآمنة" على أنواع الوصول عبر الحزمة System.Storage_Elements`.

كانت العديد من الإصدارات القديمة من لغة BASIC لمنصة Windows تدعم STRPTR()إرجاع عنوان سلسلة نصية، وإرجاع VARPTR()عنوان متغير. كما دعمت Visual BasicOBJPTR() 5 إرجاع عنوان واجهة كائن، ومعامل ADDRESSOF لإرجاع عنوان دالة. جميع هذه المتغيرات من نوع عدد صحيح، لكن قيمها تُعادل قيم أنواع المؤشرات.

تتميز لهجات BASIC الأحدث ، مثل FreeBASIC و BlitzMax ، بتطبيقات شاملة للمؤشرات. في FreeBASIC، تُعامل العمليات الحسابية على مؤشرات ANY (المكافئة لمؤشرات C ) كما لو كان مؤشر ANY بعرض بايت واحد. لا يمكن الوصول إلى مؤشرات ANY مباشرةً، كما هو الحال في C. كذلك، لن يُصدر التحويل بين مؤشرات ANY ومؤشرات أي نوع آخر أي تحذيرات.void *

dim as teger f = 257 dim as any ptr g = @f dim as teger ptr i = g assert ( * i = 257 ) assert ( ( g + 4 ) = ( @f + 1 ) )​​

في لغة C ، المؤشرات عبارة عن متغيرات تخزن عناوين، ويمكن أن تكون قيمتها فارغة (null ). لكل مؤشر نوع يشير إليه، ولكن يمكن التحويل بين أنواع المؤشرات بحرية. مع ذلك، لا يمكن التحويل بين مؤشر دالة ومؤشر كائن. يسمح نوع مؤشر خاص يُسمى "مؤشر فارغ" بالإشارة إلى أي كائن (غير دالة)، ولكنه محدود بعدم إمكانية الوصول إليه مباشرةً. غالبًا ما يمكن التلاعب بالعنوان نفسه مباشرةً عن طريق تحويل المؤشر من وإلى نوع عدد صحيح ذي حجم كافٍ، على الرغم من أن النتائج غير محددة؛ في حين أن معايير C السابقة لم تكن تتضمن نوعًا صحيحًا مضمونًا أن يكون كبيرًا بما يكفي، فإن معيار C99 يُحدد uintptr_tالنوع المُعرّف في C99 <stdint.h>، ولكن ليس من الضروري أن يُوفره التطبيق.

تُقيّد معايير اللغة عمليات الحساب على المؤشرات ، أي القدرة على تعديل عنوان المؤشر المستهدف باستخدام العمليات الحسابية (وكذلك مقارنات المقادير)، بحيث تقتصر على حدود كائن مصفوفة واحد أو ما يليه مباشرةً، وإلا ستؤدي إلى سلوك غير مُعرّف . تؤدي إضافة أو طرح قيمة من المؤشر إلى تحريكه بمقدار مُضاعف لحجم نوع بياناته . على سبيل المثال، إضافة 1 إلى مؤشر يشير إلى قيم عددية صحيحة بحجم 4 بايتات ستزيد عنوان البايت الذي يُشير إليه المؤشر بمقدار 4. يؤدي هذا إلى زيادة المؤشر ليُشير إلى العنصر التالي في مصفوفة متصلة من الأعداد الصحيحة، وهو غالبًا ما يكون النتيجة المقصودة. لا يُمكن إجراء عمليات حسابية على voidالمؤشرات لأن نوع void ليس له حجم، وبالتالي لا يُمكن إضافة قيمة إلى العنوان الذي يُشير إليه، على الرغم من أن مُجمّع gcc وغيره من المُجمّعات تُجري عمليات حسابية على البايتات void *كامتداد غير قياسي، مُعاملةً إياه كما لو كان مؤشرًا char *.

تُتيح حسابات المؤشرات للمبرمج طريقةً واحدةً للتعامل مع الأنواع المختلفة: جمع وطرح عدد العناصر المطلوبة بدلاً من الإزاحة الفعلية بالبايتات. على وجه الخصوص، يُصرّح معيار لغة C صراحةً بأنّ الصيغة `n` a[n]، التي تُمثّل العنصر رقم n في المصفوفة `x` ، تُكافئ الصيغة `n`، التي تُمثّل محتوى العنصر الذي يُشير إليه ` x`. هذا يعني، على سبيل المثال، أنّ كلاً من `n` و` n` يصلان إلى العنصر الرابع في المصفوفة `x` .a*(a + n)a + na[3]3[a]a

على الرغم من قوتها، قد تُشكّل حسابات المؤشرات مصدرًا لأخطاء برمجية . فهي تُربك المبرمجين المبتدئين ، وتُجبرهم على التعامل مع سياقات مختلفة: فقد يكون التعبير حسابيًا عاديًا أو حسابيًا باستخدام المؤشرات، ومن السهل أحيانًا الخلط بينهما. ولذلك، لا تسمح العديد من لغات البرمجة الحديثة عالية المستوى بالوصول المباشر إلى الذاكرة باستخدام العناوين.

يدعم معيار ANSI C المؤشر العام (أو voidالمؤشرvoid * ) كنوع مؤشر عام. voidيمكن للمؤشر تخزين عنوان أي كائن (وليس دالة)، ^{ويتم تحويله ضمنيًا} إلى أي نوع مؤشر كائن آخر عند التعيين، ولكن يجب تحويله صراحةً عند إلغاء مرجعيته. قبل معيار ANSI C، استخدم K&Rchar * المؤشر العام لغرض "المؤشر غير المحدد النوع".

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // تم تحويل void * ضمنيًا إلى int * int a = * p2 ; int b = * ( int * ) p1 ; // عند فك المرجع مباشرةً، لا يوجد تحويل ضمني

تدعم لغة C++ بشكل كامل مؤشرات C وتحويل أنواع البيانات في C. كما تدعم مجموعة جديدة من عوامل تحويل الأنواع للمساعدة في اكتشاف بعض عمليات التحويل غير المقصودة والخطيرة أثناء الترجمة. وتدعم C++ أيضًا شكلاً آخر من أشكال المراجع، يختلف تمامًا عن المؤشر، ويُسمى ببساطة مرجعًا أو نوع مرجعي .

منذ C++11 ، توفر مكتبة C++ القياسية أيضًا مؤشرات ذكية ، والتي يمكن استخدامها في بعض الحالات كبديل أكثر أمانًا لمؤشرات C البدائية.

• std::unique_ptr(يمثل ملكية فريدة لمورد، لا يمكن نسخه ولكن يمكن نقله)
• std::shared_ptr(يمثل الملكية المشتركة لمورد، ولا يتم حذف المورد إلا بعد تدمير أو إعادة تعيين آخر مؤشر مشترك)
• std::weak_ptr(لا يمثل ملكية، ويمكنه الإشارة إلى موارد مؤشر مشترك دون زيادة عدد المراجع)
• std::hazard_pointer(مؤشر أحادي الكتابة ومتعدد القراءة يمكن أن يمتلكه خيط واحد على الأكثر في أي وقت)

std::unique_ptrيحل محل المؤشر الذكي السابق std::auto_ptr ، الذي تم إهماله في C++11 وإزالته في C++17.

على عكس لغة C، لا تسمح لغة C++ بالتحويل الضمني void*إلى أنواع مؤشرات أخرى، حتى في عمليات الإسناد. كان هذا قرارًا تصميميًا لتجنب التحويلات غير المقصودة أو حتى غير الدقيقة، مع أن معظم المترجمات لا تُظهر سوى تحذيرات، لا أخطاء، عند مواجهة تحويلات أخرى.

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // هذا يفشل: لا يوجد تحويل ضمني من void* int * p3 = reinterpret_cast < int *> ( p1 ); // تحويل C++

في لغة C++، لا يوجد void&(مرجع إلى void) ليكمل void*(مؤشر إلى void)، لأن المراجع تتصرف مثل أسماء مستعارة للمتغيرات التي تشير إليها، ولا يمكن أن يكون هناك متغير من نوعه void.

struct Integer { int value ; [[ nodiscard ]] int get () const noexcept { return value ; } };عدد صحيح s1 ؛ // تم إنشاؤه افتراضيًا، قيمة s1 = 0 عدد صحيح * ps = & s1 ؛int Integer ::* ptr = & Integer :: value ; // مؤشر إلى Integer::value int ( Integer ::* fp )() const = & Integer :: get ; // مؤشر إلى Integer::gets1 . * ptr = 1 ; std :: println ( "{}" , ( s1 . * fp )()); // يطبع 1 ps ->* ptr = 2 ; std :: println ( "{}" , ( ps ->* fp )()); // يطبع 2

class X { // ... };class Y { // ... };char X ::* a ; // مؤشر إلى عضو من نوع char char X ::* b [ 5 ]; // مصفوفة من المؤشرات إلى أعضاء من نوع char char * X ::* c ; // مؤشر إلى مؤشر إلى حرف (أحرف) char X ::** d ; // مؤشر إلى مؤشر إلى عضو من نوع char char ( * e )[ 5 ]; // مؤشر إلى مصفوفة (مصفوفات) من الأحرف char X ::* f (); // دالة تُرجع مؤشرًا إلى عضو من نوع char char Y ::* X ::* g ; // مؤشر إلى مؤشر إلى مؤشر إلى عضو إلى مؤشر إلى حرف (أحرف) char X ::* X ::* h ; // مؤشر إلى مؤشر إلى مؤشر إلى عضو إلى مؤشر إلى حرف (أحرف) char ( X ::* i ())[ 5 ]; // دالة تُرجع مؤشرًا إلى عنصر في مصفوفة من الأحرف char ( X ::* j )() // دالة مؤشر إلى عنصر تُرجع حرفًا char ( X :: * k [ 5 ])(); // مصفوفة من مؤشرات الدوال التي تُرجع حرفًا

في لغة البرمجة C# ، تُدعم المؤشرات إما بتحديد كتل التعليمات البرمجية التي تتضمن مؤشرات باستخدام الكلمة unsafeالمفتاحية `<input>`، أو من خلال System.Runtime.CompilerServicesمساحة الاسم `<input>` للوصول إلى المؤشرات. يتشابه بناء الجملة بشكل أساسي مع لغة C++، ويمكن أن يكون العنوان المُشار إليه ذاكرة مُدارة أو غير مُدارة . مع ذلك، يجب تعريف المؤشرات إلى الذاكرة المُدارة (أي مؤشر إلى كائن مُدار) باستخدام الكلمة fixedالمفتاحية `<input>`، مما يمنع جامع البيانات المهملة من نقل الكائن المُشار إليه كجزء من إدارة الذاكرة أثناء وجود المؤشر ضمن النطاق، وبالتالي الحفاظ على صلاحية عنوان المؤشر.

مع ذلك، يُستثنى من ذلك استخدام IntPtrالبنية، وهي مكافئ مُدار بالذاكرة لـ int*، ولا تتطلب الكلمة unsafeالمفتاحية ولا CompilerServicesالتجميع. غالبًا ما يُعاد هذا النوع عند استخدام طرق من System.Runtime.InteropServices، على سبيل المثال:

باستخدام System ؛ باستخدام System.Runtime.InteropServices ؛// الحصول على 16 بايت من الذاكرة من الذاكرة غير المُدارة للعملية IntPtr pointer = Marshal.AllocHGlobal ( 16 ) ;// قم بتنفيذ إجراء ما باستخدام الذاكرة المخصصة// تحرير الذاكرة المخصصة Marshal.FreeHGlobal ( pointer ) ;

يتضمن إطار عمل .NET العديد من الفئات والأساليب في Systemمساحات System.Runtime.InteropServicesالأسماء (مثل Marshalالفئة) التي تحوّل أنواع .NET (على سبيل المثال، System.String) إلى العديد من الأنواع والمؤشرات غير المُدارةLPWSTR (على سبيل المثال، ) أو العكس void*، وذلك للسماح بالتواصل مع التعليمات البرمجية غير المُدارة . وتخضع معظم هذه الأساليب لنفس متطلبات أذونات الأمان الخاصة بالتعليمات البرمجية غير المُدارة، نظرًا لقدرتها على التأثير في أي مكان في الذاكرة.

تسمح لغة C# باستخدام المصفوفات المُخصصة في المكدس في التعليمات البرمجية الآمنة باستخدام System.Span. ^{[ 24 ]}

namespace Wikipedia.Examples ;باستخدام النظام ؛public class Example { static void Main ( string [] args ) { int num = 1024 ; unsafe { // تحويل عدد صحيح إلى بايتات عن طريق إنشاء مؤشر بايت byte * p = ( byte * ) & number ; Console . Write ( " The 4 bytes of the integer are: " ); for ( int i = 0 ; i < sizeof ( int ); ++ i ) { Console . Write ( " {0:X2}" , * p ); ++ p ; } Console . WriteLine (); }// يمكن تخصيص المصفوفات في الذاكرة المكدسة إما باستخدام المؤشرات أو Span<T> unsafe { int * numbers = stackalloc int [ 5 ]; } Span < int > numbers = stackalloc int [ 5 ]; } }

تحتوي لغة C#، مثل لغتي C و C++، على void*نوع (مؤشر فارغ)، ولكن لا يُنصح باستخدامه إطلاقاً. ^{[ 25 ]}

على عكس لغتي C و C++، لا يقبل المترجم علامات النجمة المحاذية لليمين. على سبيل المثال:

int * a , b ; int * a , * b ; // غير مسموح به في لغة C#

في لغتي C و C++، سيتم تعريف المتغيرين aكـ int*و bكـ int، ولكن في لغة C# سيتم تعريف كلا المتغيرين كـ int*. ^{[ 25 ]}

تدعم لغة برمجة كوبول المؤشرات إلى المتغيرات. كائنات البيانات الأولية أو الجماعية (السجلات) المُعلنة داخل LINKAGE SECTIONالبرنامج تعتمد بطبيعتها على المؤشرات، حيث أن الذاكرة الوحيدة المُخصصة داخل البرنامج هي مساحة عنوان عنصر البيانات (عادةً كلمة ذاكرة واحدة). في شفرة المصدر للبرنامج، تُستخدم عناصر البيانات هذه تمامًا مثل أي WORKING-STORAGEمتغير آخر، ولكن يتم الوصول إلى محتوياتها ضمنيًا بشكل غير مباشر من خلال LINKAGEمؤشراتها.

يتم عادةً تخصيص مساحة الذاكرة لكل كائن بيانات يتم الإشارة إليه بشكل ديناميكي باستخدام CALLعبارات خارجية أو عبر بنيات لغة موسعة مضمنة مثل عبارات EXEC CICSأو EXEC SQLعبارات.

توفر الإصدارات الموسعة من لغة كوبول أيضًا متغيرات مؤشر مُعلنة باستخدام USAGEISPOINTERعبارات. يتم تحديد قيم هذه المتغيرات المؤشرة وتعديلها باستخدام SETعبارات SETADDRESS.

توفر بعض الإصدارات الموسعة من لغة COBOL أيضًا PROCEDURE-POINTERمتغيرات قادرة على تخزين عناوين التعليمات البرمجية القابلة للتنفيذ .

توفر لغة PL/I دعمًا كاملاً للمؤشرات إلى جميع أنواع البيانات (بما في ذلك المؤشرات إلى الهياكل)، والاستدعاء الذاتي ، وتعدد المهام ، ومعالجة السلاسل النصية، ووظائف مدمجة واسعة النطاق . مثّلت PL/I نقلة نوعية مقارنةً بلغات البرمجة في عصرها. مؤشرات PL/I غير مُحددة النوع، وبالتالي لا يتطلب الأمر تحويلًا عند الوصول إلى المؤشر أو تعيين قيمته. صيغة تعريف المؤشر هي `<pre>` ، والتي تُعرّف مؤشرًا باسم "xxx". تُستخدم المؤشرات مع المتغيرات. يمكن تعريف متغير أساسي باستخدام مُحدد موقع افتراضي (`<pre>` أو بدونه (`<pre>` )، حيث `xxx` هو متغير أساسي، والذي قد يكون متغير عنصر، أو هيكلًا، أو مصفوفة، و`ppp` هو المؤشر الافتراضي). يمكن الوصول إلى هذا المتغير بدون مرجع مؤشر صريح (` <pre>`)، أو باستخدام مرجع صريح إلى مُحدد الموقع الافتراضي (`ppp`)، أو إلى أي مؤشر آخر (`<pre> `).DECLARE xxx POINTER;BASEDDECLARE xxx BASED(ppp);DECLARE xxx BASED;xxx=1;qqq->xxx=1;

لا تُعدّ العمليات الحسابية على المؤشرات جزءًا صريحًا من معيار PL/I، ولكن UNSPECالدالة المدمجة والمتغير الوهمي يسمحان بها، كما تسمح العديد من المترجمات بتعبيرات من هذا الشكل ptr = ptr±expression. يحتوي IBM PL/I أيضًا على دالة مدمجة PTRADDلإجراء هذه العمليات. تُجرى العمليات الحسابية على المؤشرات دائمًا بالبايتات.

تحتوي مُجمّعات IBM Enterprise PL/I على شكل جديد من المؤشرات المكتوبة يُسمى HANDLE.

لغة البرمجة D هي لغة مشتقة من لغتي C و C++، وتدعم بشكل كامل مؤشرات C وتحويل أنواع البيانات في C. كما تدعم العمليات الحسابية على المؤشرات، بالإضافة إلى شرائح المؤشرات. ويمكن للمؤشر في D أن يتحول void*ضمنيًا إلى نوع آخر. ^{[ 26 ]}

في لغة D، من الممكن استخدام refمرجع، والذي يقوم تلقائيًا بإلغاء المرجع، ويمنع العمليات الحسابية على المؤشرات، ولا يسمح بالهروب من دالة (أي من خلال return).

يمكن اعتبار شريحة المؤشر بمثابة مؤشر ذي طول.

استيراد std.stdio ؛​​void main () { int [] arr = [ 10 , 20 , 30 , 40 , 50 ]; int * ptr = & arr [ 0 ]; int [] slice = ptr [ 0 .. 3 ]; // تقسيم المصفوفة من الفهرس 0 إلى 3 (باستثناء الفهرس 3) writeln ( "Slice: " , slice ); // الناتج: Slice: [10, 20, 30] }

تستخدم لغة البرمجة الكائنية Eiffel دلالات القيمة والمراجع دون استخدام حساب المؤشرات. ومع ذلك، فهي توفر فئات المؤشرات. وتوفر هذه الفئات حساب المؤشرات، وتحويل الأنواع، وإدارة الذاكرة الصريحة، والتفاعل مع البرامج غير المبنية على Eiffel، وغيرها من الميزات.

قدمت لغة فورتران 90 إمكانية استخدام المؤشرات ذات الأنواع المحددة بدقة. لا تقتصر مؤشرات فورتران على مجرد عنوان ذاكرة بسيط، بل تشمل أيضًا الحدود الدنيا والعليا لأبعاد المصفوفة، والخطوات (على سبيل المثال، لدعم أقسام المصفوفة العشوائية)، وبيانات وصفية أخرى. يُستخدم عامل الربط ( ,) =>لربط POINTERمؤشر بمتغير له TARGETسمة. يمكن أيضًا استخدام عبارة فورتران 90 ALLOCATEلربط مؤشر بكتلة من الذاكرة. على سبيل المثال، يمكن استخدام الكود التالي لتعريف وإنشاء بنية قائمة مرتبطة:

نوع real_list_t حقيقي :: بيانات_العينة ( 100 ) نوع ( real_list_t )، مؤشر :: التالي => فارغ () نهاية النوعنوع ( real_list_t )، الهدف :: my_real_list نوع ( real_list_t )، المؤشر :: real_list_tempreal_list_temp => my_real_list do  read ( 1 , iostat = ioerr ) real_list_temp % sample_data if ( ioerr /= 0 ) exit  allocate ( real_list_temp % next ) real_list_temp => real_list_temp % next end do

يُضيف Fortran-2003 دعمًا لمؤشرات الإجراءات. كما يدعم، كجزء من ميزة التوافق مع لغة C ، وظائف مضمنة لتحويل مؤشرات نمط C إلى مؤشرات Fortran والعكس.

تحتوي لغة Go على مؤشرات، تُعرَّف بطريقة مشابهة لمؤشرات C/C++ ولكن مع وضع علامة النجمة (*) أولاً. على سبيل المثال، Tيُكتب المؤشر إلى *T`<input>` على النحو التالي: `<input>`. على عكس لغة C، تحتوي Go على خاصية جمع البيانات المهملة، وتمنع العمليات الحسابية على المؤشرات. لا توجد أنواع مرجعية، كما هو الحال في C++. بعض الأنواع المضمنة، مثل الخرائط والقنوات، مُغلَّفة (أي أنها داخليًا مؤشرات إلى هياكل قابلة للتغيير)، ويتم تهيئتها باستخدام الدالة ` make<input>`. في محاولة لتوحيد بناء الجملة بين المؤشرات وغير المؤشرات، ->تم حذف عامل السهم (<input>): يشير عامل النقطة على المؤشر إلى الحقل أو الأسلوب الخاص بالكائن الذي تم فك مرجعيته. ومع ذلك، يعمل هذا فقط مع مستوى واحد من التوجيه غير المباشر.

لا يوجد تمثيل صريح للمؤشرات في جافا . بدلاً من ذلك، تُنفَّذ هياكل البيانات الأكثر تعقيدًا، مثل الكائنات والمصفوفات ، باستخدام المراجع . لا توفر اللغة أي عوامل تشغيل صريحة لمعالجة المؤشرات. ومع ذلك، لا يزال من الممكن للبرنامج محاولة الوصول إلى مرجع فارغ (مؤشر فارغ)، مما يؤدي إلى ظهور استثناء java.lang.NullPointerException . يتم استعادة المساحة التي تشغلها كائنات الذاكرة غير المُشار إليها تلقائيًا بواسطة عملية جمع البيانات المهملة أثناء التشغيل. ^{[ 27 ]}

توفر لغة جافا الفئات java.lang.ref.WeakReferenceو java.lang.ref.PhantomReference، والتي تقوم على التوالي بتنفيذ المراجع الضعيفة والمراجع الوهمية .

تُنفَّذ المؤشرات بنفس طريقة تنفيذها في لغة باسكال، وكذلك VARالمعاملات في استدعاءات الإجراءات. تتميز لغة Modula-2 بنظام كتابة أكثر صرامة من باسكال، مع عدد أقل من طرق تجاوز نظام الأنواع. تتضمن بعض إصدارات Modula-2 (مثل Modula-3 ) خاصية جمع البيانات المهملة.

كما هو الحال مع Modula-2، تتوفر المؤشرات. ومع ذلك، لا تزال طرق التحايل على نظام الأنواع أقل، لذا فإن Oberon ومشتقاتها أكثر أمانًا فيما يتعلق بالمؤشرات من Modula-2 ومشتقاتها. وكما هو الحال مع Modula-3 ، يُعدّ جمع البيانات المهملة جزءًا من مواصفات اللغة.

على عكس العديد من اللغات التي تدعم المؤشرات، فإن معيار ISO Pascal لا يسمح للمؤشرات إلا بالإشارة إلى متغيرات مجهولة المصدر يتم إنشاؤها ديناميكيًا، ولا يسمح لها بالإشارة إلى متغيرات ثابتة أو محلية قياسية. ^{[ 28 ]} كما أنه لا يدعم العمليات الحسابية على المؤشرات. يجب أن يكون للمؤشرات نوع بيانات مرتبط بها، ولا يتوافق المؤشر إلى نوع بيانات معين مع المؤشر إلى نوع بيانات آخر (على سبيل المثال، لا يتوافق المؤشر إلى حرف مع المؤشر إلى عدد صحيح). يساعد هذا في التخلص من مشكلات أمان النوع المتأصلة في تطبيقات المؤشرات الأخرى، وخاصة تلك المستخدمة في PL/I أو C. كما أنه يزيل بعض المخاطر الناجمة عن المؤشرات المعلقة ، ولكن إمكانية تحرير المساحة المشار إليها ديناميكيًا باستخدام disposeالإجراء القياسي (الذي له نفس تأثير freeدالة المكتبة الموجودة في C ) تعني أن خطر المؤشرات المعلقة لم يُقضَ عليه تمامًا. ^{[ 29 ]}

مع ذلك، في بعض تطبيقات مُترجمات باسكال (أو مشتقاتها) التجارية والمفتوحة المصدر - مثل Free Pascal ، ^{و Turbo Pascal} ، و Object Pascal في Embarcadero Delphi - يُسمح للمؤشر بالإشارة إلى متغيرات ثابتة أو محلية قياسية، ويمكن تحويله من نوع مؤشر إلى آخر. علاوة على ذلك، فإن العمليات الحسابية على المؤشرات غير مقيدة: فإضافة أو طرح قيمة من المؤشر يُحركه بمقدار تلك القيمة من البايتات في أي اتجاه، ولكن استخدام الإجراءات Incالقياسية Decمعه يُحرك المؤشر بمقدار حجم نوع البيانات الذي يُشير إليه. كما يُوفر مؤشر غير مُحدد النوع تحت اسم `<type>` Pointer، وهو متوافق مع أنواع المؤشرات الأخرى.

يكتبالأشهر = ( يناير ، فبراير ، مارس ، أبريل ، مايو ، يونيو ، يوليو ، أغسطس ، سبتمبر ، أكتوبر ، نوفمبر ، ديسمبر ) ؛calptr = ^ Calendar_Type ;نوع_التقويم = سجلالسابق ، التالي : CalPtr ؛الشهر : أشهر ؛يوم : بايت ؛السنة : عدد صحيح ؛الحدث : سلسلة نصية ؛نهاية ؛متغيرذلك : ^ عدد صحيح ؛NextCalendar​التقويم : ^ calptr ;يبدأجديد ( التقويم )calendar ^. prev := nil ;calendar ^. next := nil ;التقويم ^. الشهر := سبتمبر ;التقويم ^. اليوم := 11 ؛التقويم ^. السنة := 2001 ؛جديد ( ذلك ) ؛That ^ := 1 ;جديد ( التقويم التالي ) ؛nextCalendar ^. prev := Calendar ;nextCalendar ^. Next := NIL ;جديد ( التقويم ) ؛...تخلص ( من ذلك ) ؛تخلص من ( التقويم ) ؛تخلص من ( التقويم التالي ) ؛نهاية ؛

تدعم لغة برمجة بيرل المؤشرات ، وإن كان استخدامها نادرًا، وذلك من خلال دالتي التعبئة والفك. تُستخدم هاتان الدالتان فقط للتفاعلات البسيطة مع مكتبات نظام التشغيل المُجمَّعة. في جميع الحالات الأخرى، تستخدم بيرل المراجع ، وهي مُحدَّدة النوع ولا تسمح بأي شكل من أشكال العمليات الحسابية على المؤشرات. تُستخدم المراجع لإنشاء هياكل بيانات معقدة. ^{[ 31 ]}

تستخدم لغة Rust المراجع، وهي مشابهة للمؤشرات ولكنها تضمن الإشارة إلى قيمة صحيحة. يُعدّ التعامل مع المؤشرات الخام أقل شيوعًا، ويُستخدم عادةً في برمجة الأنظمة منخفضة المستوى. لا يمكن الوصول إلى المؤشرات الخام إلا داخل كتلة unsafe. [ ^{32 ] [ 33 ] [ 34 ] توجد} العمليات المتعلقة بالمؤشرات الخام في std::ptr.

في لغة Rust، لا يوجد ثابت مؤشر فارغ. يتم تحديده بدلاً من ذلك بواسطة std::ptr::null().

يحتوي Rust أيضًا على عدة أنواع من المؤشرات الذكية:

• std::boxed::Box^{: مكافئ لـ [ 35 ]} في لغة C++std::unique_ptr
• std::rc::Rc: يعادل مؤشرًا مشتركًا أحادي الخيوط مع عد المراجع
• std::sync::Arc: يعادل مؤشرًا مشتركًا آمنًا للخيوط مع عد المراجع الذرية
• std::rc::Weak^{: مكافئ لـ [ 36 ]} في لغة C++std::weak_ptr

Tيُكتب المؤشر على النحو التالي في لغة Rust: *const Tأو *mut T. فيما يلي توضيح للمؤشرات الخام في Rust:

fn main () { let mut num : i32 = 42 ;let r1 = & num as * const i32 ; let r2 = & mut num as * mut i32 ;غير آمن { println! ( "r1 يشير إلى: {}" , * r1 ); println! ( "r2 يشير إلى: {}" , * r2 );r2 = 100 ; println! ( " num is now: {}" , num ); } }