Naser Dakhel

تُستخدم لغة سي على نطاق واسع في تطبيقات المعالجة والتعامل بالمحارف characters والسلاسل النصية strings، وهذا الأمر غريب بعض الشيء لأن اللغة لا تحتوي على مزايا موجهة لهذا الغرض بالتحديد،؛ وإذا كنت معتادًا على لغات البرمجة التي تحتوي على مزايا موجهة للتعامل مع المحارف والسلاسل النصية، فستجد التعامل مع لغة سي بهذا الخصوص مضجرًا على أقل تقدير. تحتوي المكتبة القياسية على العديد من الدوال التي تساعدك في التعامل مع السلاسل النصية، إلا أن الأمر يبقى صعبًا بعض الشيء مقارنةً بلغاتٍ أخرى. على سبيل المثال، عليك استدعاء دالة مخصصة للمقارنة ما بين سلسلتين نصيتين بدلًا من استخدام عامل المساواة "="، ولكن هناك جانبٌ مشرقٌ لهذا الأمر، إذ يعني ذلك أن اللغة غير مُثقلة بطرق دعم معالجة السلاسل النصية مما يساعد بالمحافظة على برامج أصغر وأقل تشعّبًا، وحالما تكتب برنامجًا لمعالجة السلاسل النصية بلغة سي بنجاح أخيرًا، ستكون قادرًا على تشغيله بسرعة أكبر مقارنةً باللغات الأخرى. التعامل مع المحارف يجري التعامل مع محارف السلسلة النصية في لغة سي عن طريق التصريح عن مصفوفات، أو حجزهم ديناميكيًا، والتعامل مع المحارف وتحريكها "يدويًّا". إليك مثالًا عن برنامج يقرأ نصًّا سطرًا بسطر من دخل البرنامج القياسي، ويتوقف البرنامج عن القراءة إذا كان السطر مكوّنًا من السلسلة النصية "stop"، ويُطبع طول السطر فيما عدا ذلك. يعتمد البرنامج على تقنية تُستخدم في معظم برامج سي ألا وهي: يقرأ البرنامج المحارف ويحوّلها إلى مصفوفة ويحدّد نهاية المصفوفة بمحرفٍ إضافي له القيمة صفر؛ كما يستخدم هذا المثال دالة strcmp للمقارنة بين سلسلتين نصيتين من خلال تضمين المكتبة string.h. #include <stdio.h> #include <stdlib.h> #include <string.h> #define LINELNG 100 /* الطول الأعظمي لسطر الدخل الواحد */ main(){ char in_line[LINELNG]; char *cp; int c; cp = in_line; while((c = getc(stdin)) != EOF){ if(cp == &in_line[LINELNG-1] || c == '\n'){ /*إدخال ما يدل على نهاية السطر*/ *cp = 0; if(strcmp(in_line, "stop") == 0 ) exit(EXIT_SUCCESS); else printf("line was %d characters long\n", (int)(cp-in_line)); cp = in_line; } else *cp++ = c; } exit(EXIT_SUCCESS); } [مثال 1] يوضح لنا هذا المثال مزيدًا من مزايا وطرق لغة سي المُستخدمة في برامجها، وأهمها هو طريقة تمثيل السلاسل النصية ومعالجتها. إليك تطبيقًا عمليًّا عن الدالة strcmp التي تقارن بين سلسلتين نصيتين وتعيد القيمة صفر إن تساوت قيمتهما، وللدالة هذه في الحقيقة تطبيقات أكثر ولكننا سنتجاهل المعلومات التي قد تزيد من تعقيد شرحنا. لاحظ استخدام الكلمة المفتاحية const في التصريح عن الوسطاء، والذي يوضِّح أن الدالة لن تعدل على محتويات السلسلة النصية بل ستفحص قيم محتوياتها فقط، ونلاحظ استخدام هذه الطريقة في التعريف عن العديد من دوال المكتبة القياسية. /* * برنامج يختبر مساواة سلسلتين نصيتين * يُعيد القيمة "خطأ" إذا تساوت السلسلتين */ int str_eq(const char *s1, const char *s2){ while(*s1 == *s2){ /* * إعادة 0 عند نهاية السلسلة النصية */ if(*s1 == 0) return(0); s1++; s2++; } /* عُثر على فرق بين السلسلتين */ return(1); } [مثال 2] السلاسل النصية يعرف كل مبرمجٍ للغة سي معنى السلسلة النصية، فهي مصفوفةٌ من متغيرات من نوع "char"، ويكون المحرف الأخير لهذه السلسلة النصية متبوعًا بمحرف فراغ null. ربما تصرخ الآن وتقول "ولكنني اعتقدت أن السلسلة النصية هي نصٌ محتوًى داخل إشارتي تنصيص!" أنت محقّ، إذ تُعد السلسلة التالية في لغة سي مصفوفةً من المحارف: "a string" وهذا الشيء الوحيد الذي يمكنك التصريح عنه لحظة استخدامه، أي دون التصريح عن مصفوفة المحارف وتحديد حجمها. احذر: كانت السلاسل النصية في لغة سي القديمة تُخزّن مثل أي سلسلة محارف اعتيادية، وكانت قابلةً للتعديل. إلا أن المعيار ينص على أن محاولة التعديل على سلسلة نصية سيتسبب بسلوك غير محدد على الرغم من كون السلاسل النصية مصفوفةً من نوع "char" وليس "const char". لاستخدام السلسلة النصية داخل علامتي تنصيص أثران: أولهما أن السلسلة النصية تحلّ محل تصريح وبديل عن الاسم، كما أنها تمثِّل تصريحًا خفيًّا لمصفوفة من المحارف، وتُهيّأ قيمة هذه المصفوفة إلى قيم المحارف الموجودة في السلسلة النصية متبوعةً بمحرف قيمته صفر، ولا يوجد لهذه المصفوفة أي اسم، لذا باستثناء الاسم، يكون الوضع مشابهًا للتالي: char secret[9]; secret[0] = 'a'; secret[1] = ' '; secret[2] = 's'; secret[3] = 't'; secret[4] = 'r'; secret[5] = 'i'; secret[6] = 'n'; secret[7] = 'g'; secret[8] = 0; وهي مصفوفةٌ من المحارف متبوعةٌ بقيمة صفر، وتحتوي جميع قيم المحارف بداخلها، لكنها عديمة الاسم إذا صُرِّح عنها باستخدام طريقة السلسلة النصية المحاطة بعلامتي تنصيص، فكيف نستطيع استخدامها؟ يكون وجود السلسلة النصية بمثابة اسمٍ مخفي لها حالما تراها لغة سي محاطةً بعلامتي تنصيص، إذ أن وجود السلسلة النصية بهذا الشكل لا يؤدي إلى تصريح ضمني فقط، بل يؤدي إلى إعطاء اسمٍ لمصفوفة موافقة. نتذكر جميعنا أن اسم المصفوفة مساوٍ لعنوان عنصرها الأول (تفقد مقالة المؤشرات) فما نوع السلسلة التالية؟ "a string" النوع مؤشر طبعًا، إذ أن السلسلة النصية المكتوبة بالشكل السابق تكافئ مؤشرًا إلى أول عناصر المصفوفة الخفية عديمة الاسم، وهي مصفوفةٌ من نوع char، فالمؤشر من نوع "مؤشر إلى char"، ويوضح الشكل 1 هذه الحالة. شكل 1 أثر استخدام السلسلة النصية للبرهان على السابق، ألقِ نظرةً على البرنامج التالي: #include <stdio.h> #include <stdlib.h> main(){ int i; char *cp; cp = "a string"; while(*cp != 0){ putchar(*cp); cp++; } putchar('\n'); for(i = 0; i < 8; i++) putchar("a string"[i]); putchar('\n'); exit(EXIT_SUCCESS); } [مثال 3] تضبط الحلقة الأولى مؤشرًا يشير إلى بداية المصفوفة، ويُمرّر المؤشر على المصفوفة إلى أن يصل المؤشر إلى القيمة صفر في النهاية، بينما "تَعرف" الحلقة الثانية طول السلسلة النصية وهي أقل فائدة مقارنةً بسابقتها. لاحظ أن الحلقة الأولى غير معتمدة على طول السلسلة النصية بل على وصولها لنهايتها وهو الشيء الأهم الذي ينبغي عليك تذكره من هذا المثال. يجري التعامل مع السلاسل النصية في لغة سي بطريقة ثابتة دون أي استثناءات وهي الطريقة التي تتوقعها جميع دوال التعامل مع السلاسل النصية، فيسمح الصفر في نهاية السلسلة النصية للدوال بمعرفة نهاية السلسلة النصية. عُد للمثال السابق الخاص بدالة str_eq، إذ تأخذ الدالة مؤشرين يشيران لمحرفين مثل وسطاء (تُقبل السلسلة النصية ذاتها بكونها واحدًا من الوسيطين أو كلاهما) وتُقارن السلسلة النصية بالتحقق من كل محرف واحدًا تلو الآخر، وإذا تساوى المحرفين فتتحقّق من أن المؤشر لم يصل إلى نهاية السلسلة عن طريق الجملة الشرطية التالية: if(*s1 == 0): وإذا وصل المؤشر للنهاية فإنها تُعيد 0 للدلالة على أن السلسلتين متساويتين، يمكن إجراء الاختبار ذاته باستخدام المؤشر s2* دون أي فارق؛ أما في حالة الفرق بين المحرفين تُعاد القيمة 1 للدلالة على فشل المساواة. تُستدعى الدالة strcmp في المثال باستخدام وسيطين مختلفين عن بعضهما، إذ أن الوسيط الأول هو مصفوفة محارف والثاني سلسلة نصية، لكنهما في الحقيقة يمثلان الشيء ذاته؛ فمصفوفة المحارف التي تنتهي بالعنصر صفر (يسند برنامجنا القيمة صفر إلى أول عنصر فارغ في مصفوفة in_line) والسلسلة النصية بين قوسين (التي تُمثّل بدورها أيضًا مصفوفة محارف تنتهي بصفر) من نفس الطبيعة، واستخدامهما مثل وسيطين للدالة strcmp ينتج بتمرير مؤشرَي محارف (وقد شرحنا السبب بذلك بإفاضة سابقًا). المؤشرات وعامل الزيادة ذكرنا سابقًا التعبير التالي، وقلنا أنّنا ستعيد النظر فيه لاحقًا: (*p)++; حان الوقت الآن للكلام عن ذلك؛ إذ تُستخدم المؤشرات بكثرة مع المصفوفات والتمرير بينها، لذلك من الطبيعي استخدام العاملين -- و ++ معها. يوضح المثال التالي إسناد القيمة صفر إلى مصفوفة باستخدام المؤشر وعامل الزيادة: #define ARLEN 10 int ar[ARLEN], *ip; ip = ar; while(ip < &ar[ARLEN]) *(ip++) = 0; [مثال 4] يُضبط المؤشر ip ليبدأ من بداية المصفوفة، وعلى الرغم من إشارة المؤشر إلى داخل المصفوفة إلا أن القيمة التي يشير إليها تساوي الصفر، وعند وصولنا للحركة التكرارية ينجز عامل الزيادة ما هو متوقع ويُنقل المؤشر للعنصر الذي يليه داخل المصفوفة، وبالتالي استخدام العامل ++ عامل إلحاق postfix مفيدٌ في هذه الحالة. معظم الأشياء التي ناقشناها شائعة الوجود، وستجدها في معظم البرامج (استخدام عامل الزيادة والمؤشرات بالشكل الموضح في المثال السابق) ليس مرةً واحدةً أو مرتين بل تقريبًا كل عدّة أسطر ضمن الشيفرة البرمجية، وستعتقد أنك تراها بصورةٍ أكثر إذا كنت تجد استخدامها صعب الفهم. لكن ما هي التشكيلات التي يمكننا الحصول عليها؟ بالنظر إلى أن * تعني التأشير و ++ تعني الزيادة و -- تعني النقصان، كما أنه لدينا خياري وضع العاملين السابقين مثل عامل إلحاق postfix أو عامل إسباق prefix، نحصل على الاحتمالات التالية (بغض النظر عن عامل الزيادة أو النقصان) مع التركيز على موضع الأقواس: table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } (p*)++ زيادة سابقة للشيء الذي يشير إليه المؤشر ++(p*) زيادة لاحقة للشيء الذي يشير إليه المؤشر (++p)* زيادة لاحقة على المؤشر *(p++)* زيادة سابقة على المؤشر [جدول 1 معاني المؤشرات] اقرأ الجدول السابق بحرص وتأكد أنك تفهم جميع التركيبات التي ذُكرت. يمكن فهم محتوى الجدول السابق بعد تفكير بسيط، ولكن هل يمكنك توقع ما الذي سيحدث عند إزالة الأقواس بالنظر إلى أن الأسبقية للعوامل الثلاث * و -- و ++ متساوية؟ تتوقع حدوث أخطاء كارثية، أليس كذلك؟ يوضّح الجدول 1 أن هناك حالةٌ واحدةٌ يجب أن تحافظ فيها على الأقواس. مع أقواس دون أقواس إن أمكن (p*)++ p*++ ++(p*) ++(p*) (++p)* ++p* (p++)* p++* [جدول 2 المزيد من معاني المؤشرات] لعلّ الأشكال المثيرة للتشويش في الجدول السابق ستدفعك لاستخدام الأقواس بغض النظر عن أهمية استعمالها في أي حالة سعيًا منك لتحسين قابلية قراءة الشيفرة البرمجية وفهمها، لكن يتخلى معظم مبرمجي لغة سي عن استخدام الأقواس بعد تعلُّم قوانين الأسبقية ونادرًا ما يستخدمون الأقواس في تعابيرهم، لذا عليك الاعتياد على قراءة الأمثلة التالية سواءٌ كانت مع أقواس أو بدونها، فالاعتياد على هذا الأمر سيساعدك بحقّ في تعلمك. المؤشرات عديمة النوع من المهم في بعض الأحيان تحويل نوعٍ من المؤشرات إلى نوع آخر بمساعدة التحويل بين الأنواع مثل التعبير التالي: (type *) expression يُحوَّل التعبير expression في المثال السابق إلى مؤشر من نوع "مؤشر إلى نوع type" بغض النظر عن نوع التعبير السابق، إلا أنه يجب تفادي هذه الطريقة إلا في حال كنت مدركًا تمامًا لما تفعله، فمن غير المحبّذ استخدامها إلا إذا كنت مبرمجًا خبيرًا. لا تفترض أن التحويل بين الأنواع يلغي أي حسابات أخرى بخصوص "الأنواع غير المتوافقة مع بعضها" التي تقع على عاتق المصرّف، إذ من المهم إعادة حساب القيم الجديدة للمؤشر بعد تغيير نوعه على العديد من معماريات الحاسوب. هناك بعض الحالات التي ستحتاج فيها لاستخدام مؤشر "معمّم generic"، وأبرز مثال على ذلك هو تطبيق لدالة المكتبة القياسية malloc التي تُستخدم لحجز المساحة على الذاكرة للكائن الذي لم يصرّح عنه بعد، ويجري تزويد الحجم المراد حجزه عن طريق تزويد مثل وسيطٍ سواءٌ كان الكائن متغيرًا من نوع float أو مصفوفة من نوع int أو أي شيء آخر. تعيد الدالة مؤشرًا إلى عنوان التخزين المحجوز التي تختاره بطريقتها الخاصة (والتي لن نتطرق إليها) من مجموعةٍ من عناوين الذاكرة الفارغة، ومن ثم يُحوَّل المؤشر إلى النوع المناسب. على سبيل المثال، تحتاج القيمة من نوع float إلى 4 بايتات من الذاكرة، وبالتالي نكتب ما يلي لحجز مساحة للقيمة: float *fp; fp = (float *)malloc(4); تعثر الدالة malloc على 4 بايتات من الذاكرة الفارغة، ويُحوَّل عنوان الذاكرة إلى مؤشر من نوع "مؤشر إلى float"، ثم تُسند القيمة إلى المؤشر (fp في حالة مثالنا السابق). لكن ما هو نوع المؤشر الذي ستُسند قيمة malloc إليه؟ نحن بحاجة نوع يمكن أن يحتوي جميع أنواع المؤشرات فنحن لا نعلم نوع المؤشر الذي ستعيده الدالة malloc. الحل هو باستخدام نوع المؤشر * void الذي تكلمنا عنه سابقًا، إليك المثال السابق مع إضافة تصريح للدالة malloc: void *malloc(); float *fp; fp = (float *)malloc(4); لا حاجة لاستخدام تحويل الأنواع على القيمة المُعادة من الدالة malloc حسب قوانين الإسناد للمؤشرات، ولكن استُخدم تحويل الأنواع لممارسة الأمر لا أكثر. لا بد من طريقة لمعرفة قيمة وسيط malloc الدقيقة في نهاية المطاف، ولكن القيمة ستكون مختلفةً على أجهزة بمعماريات مختلفة، لذا لا يمكنك الاكتفاء باستخدام القيمة الثابتة 4 فقط، بل يجب علينا استخدام عامل sizeof. ترجمة -وبتصرف- لقسم من الفصل Arrays and Pointers من كتاب The C Book اقرأ أيضًا المقال التالي: عامل sizeof وحجز مساحات التخزين في لغة سي C المقال السابق: المؤشرات Pointers في لغة سي C المحارف المستخدمة في لغة سي C العوامل المنطقية في لغة سي C وعوامل أخرى البنية النصية لبرامج سي C

يشابه استخدام المؤشرات Pointers في لغة سي عملية تعلُّم قيادة الدراجة الهوائية، فعندما تصل إلى النقطة التي تعتقد أنك لن تتعلمها أبدًا، تبدأ بإتقانها، وبعد أن تتعلمها سيكون من الصعب نسيانها. لا يوجد هناك أي شيء مميّز بخصوص المؤشرات، ونعتقد أن معظم القرّاء يعرفون عنها مسبقًا، وفي الحقيقة، واحدةٌ من ميزات لغة سي هي اعتمادها الكبير على استخدام المؤشرات مقارنةً باللغات الأخرى، إضافةً إلى الأشياء الأخرى الممكن إنجازها بواسطة المؤشرات بسهولة ودون قيود إلى حدٍّ ما. التصريح عن المؤشرات ينبغي التصريح عن المؤشرات قبل استخدامها بصورةٍ مماثلة لأي متغير آخر تعاملنا معه مسبقًا. يتشابه التصريح عن المؤشر مع أي تصريح آخر، ولكن هناك نقطة مهمّة، إذ تدلّ الكلمة المفتاحية عند التصريح عن المؤشر في البداية، مثل int أوchar وغيرها عن نوع المتغير الذي سيشير المؤشر إليه، وليس نوع المؤشر بذات نفسه، ويشير المؤشّر على قيمة واحدة كل مرة من ذلك النوع وليس جميع القيم من النوع ذاته. إليك مثالًا يوضح التصريح عن مصفوفة ومؤشر: int ar[5], *ip; يصبح لدينا بعد التصريح مصفوفة ومؤشر، كما يوضح الشكل 1: شكل 1 مصفوفة ومؤشر يوضح الرمز * الموجود أمام ip أن هذا مؤشر، وليس متغيرًا اعتياديًا، وهو مؤشرٌ من النوع pointer to int، أي يشير إلى قيمة من نوع int فقط، لكن لم تُسند له قيمة أوليّة بعد، ولا يمكننا استخدامه في هذه الحالة قبل أن نجعله يؤشّر على قيمةٍ ما. لاحظ أنه لا يمكنك تعيين قيمةٍ من نوع int فورًا، لأن القيم الصحيحة لها النوع int ونحن نريد هنا قيمةً من نوع "مؤشر إلى نوع صحيح pointer to int". لكن، ما الذي سيشير إليه ip في هذه الحالة إذا كانت التعليمة التالية صحيحة ؟ ip = 6; قد تختلف الإجابة هنا، ولا يوجد إجابةً واحدةً عمّا قد يشير إليه ip، ولكن خلاصة الأمر أن هذا النوع من الإسناد غير صحيح في لغة سي. إليك الطريقة الصحيحة لإسناد قيمة أولية لمؤشر ما: int ar[5], *ip; ip = &ar[3]; يؤشّر المؤشر في هذا المثال إلى عنصرٍ من المصفوفة ar بدليل 3، أي العنصر الرابع من المصفوفة. تحذير هام: يمكنك إسناد القيم إلى المؤشرات كما في أي متغير اعتدت عليه، ولكن تكمن الأهمية في نوع هذه القيمة وما الذي تعنيه. يدل الشكل 2 على قيم المتغيرات الموجودة بعد التصريح، ويدل ?? على كون المتغير غير مُسند لقيمة أولية أي غير مهيَّأ. شكل 2 مصفوفة ومؤشر مهيّأ نلاحظ أن قيمة المتغير ip مساوية لقيمة التعبير ‎&ar[3]‎، ويشير السهم إلى أن المؤشر ip يشير إلى المتغير [ar[3‏. لكن ما الذي يعنيه العامل الأحادي &؟ يُشار إلى هذا العامل بكونه عامل "عنوان المتغير"، إذ أن المؤشرات تخزّن عنوان المتغير الذي تؤشّر عليه في معظم الأنظمة. ربّما ستواجه صعوبةً بخصوص هذا الأمر إذا كنت تفهم ما نعني هنا بالعنوان مقارنةً بالأشخاص الذين لا يفهمون هذا الأمر، إذ أن التفكير بالمؤشرات كونها عناوينًا يؤدي إلى كثيرٍ من المشاكل في الفهم. قد تكون عملية التلاعب بعناوين معالج "أ" مستحيلةً على متحكّم آلة غسيل من نوع "ب" يستخدم عناوينًا بسعة 17-بِت عندما تكون في طور الغسيل، ويقلب ترتيب البِتات الزوجية والفردية عندما ينفد من مسحوق الغسيل. من المستبعد لأي أحد أن يستخدم لغة سي بمعمارية مشابهة لمثالنا السابق، ولكن هناك بعض الحالات الأخرى والأقل شدّة التي قد يمكن تشغيل لغة سي على معماريتها. لكننا سنتابع استخدام الكلمة "عنوان المتغير"، لأن استخدام مصطلح أو كلمة مغايرة لذلك سيتسبب بمزيدٍ من المشكلات. يعيد تطبيق العامل & لمعامل ما مؤشّرًا لهذا المعامل: int i; float f; /* مؤشر إلى عدد صحيح '&i' */ /* مؤشر إلى عدد حقيقي '&f'*/ وسيشير المؤشر في كل حالة إلى الكائن الذي يوافق اسمه اسم المستخدم في التعبير. المؤشر مفيدٌ فقط في حال وجود طريقة للوصول إلى الشيء الذي يشير إليه، وتستخدم لغة سي العامل الأحادي * لتحقيق ذلك؛ فإذا كان p من نوع "مؤشر إلى نوعٍ ما pointer to something"، فيشير التعبير ‎*p‎ إلى الشيء الذي يشير إليه ذلك المؤشر. على سبيل المثال، نتبع مايلي للوصول إلى المتغير x باستخدام المؤشر p: #include <stdio.h> #include <stdlib.h> main(){ int x, *p; p = &x; //تهيئة المؤشر *p = 0; // ‪ x إسناد القيمة 0 إلى المتغير printf("x is %d\n", x); printf("*p is %d\n", *p); *p += 1; /* زيادة القيمة التي يشير إليها المؤشر */ printf("x is %d\n", x); (*p)++; /* زيادة القيمة التي يشير إليها المؤشر */ printf("x is %d\n", x); exit(EXIT_SUCCESS); } [مثال 1] من الجدير بالذكر معرفة أن استخدام التركيب المؤلف من & و * بالشكل &* يلغي تأثير كلٍّ منهما، لأن & تعيد عنوان الكائن أي قيمة مؤشّره، و* تعني "القيمة التي يشير إليها المؤشر". لكن انتبه، فليس لبعض الأشياء مثل الثوابت أي عنوان، وبذلك لا يمكن تطبيق العامل & عليها، والتعبير 1.5& ليسَ مؤشّرًا بل تعبيرًا خاطئًا. من المثير للانتباه أيضًا إلى أن لغة سي من اللغات القليلة التي تسمح بوجود تعبير على الجانب الأيسر من عامل الإسناد. انظر مجدّدًا إلى المثال؛ إذ نصادف التعبير p* مرتين، ومن ثم التعليمة ‎(‎*p)++‎;‎ المثيرة للاهتمام، وستثير هذه التساؤلات من معظم المبتدئين حتى لو استطعت فهم أن التعليمة p = 0* تسند القيمة 0 إلى المتغير المُشار إليه بواسطة المؤشر p، وأن التعليمة p += 1* تضيف واحدًا إلى المتغير المُشار إليه بالمؤشر p، فاستخدام العامل ++ مع p* يبدو صعب الفهم قليلًا. تستحق أسبقية التعبير ++(p*) النظر إليها بدقة، وسنناقش مزيدًا من التفاصيل بهذا الخصوص، ولكن دعونا نركّز عمّا يحدث في هذا المثال تحديدًا. تُستخدم الأقواس للتأكد بأن * تُطبَّق على p فقط، ومن ثم تحدث زيادةً بمقدار واحد على الشيء المُشار إليه بالمؤشر p، وبالنظر إلى جدول الأسبقية في مقال العوامل في لغة سي C نلاحظ أن للعاملين ++ و* الأسبقية ذاتها، ولكن العاملين يرتبطان من اليمين إلى اليسار، وبمعنى آخر تصبح العملية بالتخلص من الأقواس مكافئةً للعملية (++p)*، وبغض النظر عن معنى هذه العملية (التي سنتكلم عن معناها لاحقًا)، لا بُدّ من الحفاظ على الأقواس في هذه الحالة والانتباه إلى مواضعها الصحيحة. لذا، وبما أن المؤشر يعطي عنوان الشيء الذي يشير إليه، فاستخدام pointer* (إذ أن pointer هو أيضًا مؤشر) يعيد الشيء بذاته مباشرةً، ولكن ما الذي نستفيد من ذلك؟ أول الأمور التي نستفيد منها هي تجاوز قيد الاستدعاء بالقيمة call-by-value عند استخدام الدوال؛ فعلى سبيل المثال تخيل دالةً تعيد قيمتين ممثلتين بأعداد صحيحة تمثّل الشهر واليوم لهذا الشهر، وأن لهذه الدالة طريقةً (غير محددة) لتحديد هذه القيم، والتحدي هنا هو إعادة قيمتين منفصلتين بنفس الوقت. إليك طريقةً لتجاوز هذه العقبة بالمثال: #include <stdio.h> #include <stdlib.h> void date(int *, int *); /* التصريح عن الدالة */ main(){ int month, day; date (&day, &month); printf("day is %d, month is %d\n", day, month); exit(EXIT_SUCCESS); } void date(int *day_p, int *month_p){ int day_ret, month_ret; /*حساب قيمة day و month في day_ret و month_ret*/ *day_p = day_ret; *month_p = month_ret; } [مثال 2] لاحظ طريقة التصريح عن date المتقدمة، التي توضح أنها دالةٌ تأخذ وسيطين من نوع "مؤشر إلى قيمة من نوع int"، وتعيد void لأن القيم التي تُمرّر بواسطة المؤشرات ليست من نوع قيمة اعتيادية. تمرِّر الدالة main المؤشرات إلى الدالة date على أنها وسطاء باستخدام المتغيرات الداخلية day_ret و month_ret، ومن ثم تأخذ قيمتهما وتسندها إلى الأماكن التي تشير إليها وسطاء الدالة (المؤشرات). يوضح الشكل 3 ما الذي يحدث عند استدعاء الدالة date: شكل 3 عند استدعاء الدالة date تُمرَّر الوسطاء إلى date، ولكن المتغيرين day و month غير مهيّأين بقيمةٍ أولية ضمن الدالة main. يوضح الشكل 4 ما الذي يحدث عندما تصل الدالة date إلى تعليمة return، بفرض أن قيمة day هي "12" وقيمة month هي "5". شكل 4 عندما تصل الدالة date إلى تعليمة return واحدةٌ من المزايا الرائعة التي قدّمتها لغة سي المعيارية هي السماح بالتصريح عن أنواع وسطاء دالة date مسبقًا، إذ كان نسيان أن الدالة تقبل مؤشرات وسطاءً لها وتمرير نوع آخر أمرًا شائع الحدوث. تخيل استدعاء الدالة date دون أي تصريح واضح مُسبقٍ لها على النحو التالي: date(day, month); لن يعرف المصرّف هنا أن الدالة تقبل المؤشرات وسطاءً لها وستُمرر قيمًا من نوع int افتراضيًا لكل من day و month، وبما أن تمرير المؤشرات والأعداد الصحيحة يجري على معظم الحواسيب بالطريقة نفسها، لذا ستُنفَّذ الدالة في هذه الحالة، ثم تعيد القيم في النهاية وتسندها إلى المكان الذي يشير إليه كلًا من day و month، إذا كانا مؤشرين. لن يعطي ذلك أي نتيجة بل وربما يتسبب بضرر مفاجئ للبيانات في مكان آخر بذاكرة الحاسوب، وتعقُّب هذا النوع من الأخطاء صعبٌ جدًا. لحسن الحظ، يمكن أن يعرف المصرّف المعلومات الكافية عن date بالتصريح عن الدالة مسبقًا، وذلك من شأنه أن يحذره بخصوص أي أخطاء مرتكبة. قد يفاجئك سماع أن المؤشرات لا تستخدم كثيرًا لتمكين طريقة الاستدعاء بالإشارة call-by-reference، إذ يُعدّ استخدام الاستدعاء بالقيمة call-by-value وإعادة قيمة واحدة باستخدام return كافٍ في معظم الحالات، والاستخدام الأكثر شيوعًا للمؤشرات هو الانتقال ما بين المصفوفات. المصفوفات والمؤشرات تملك عناصر المصفوفة عناوينًا مثل أي متغير اعتيادي آخر. int ar[20], *ip; ip = &ar[5]; *ip = 0; // ‫يكافئ التعبير ar[5] = 0;‎ في المثال السابق، يُخزَّن عنوان العنصر ar[5]‎ في المؤشر ip، ثم تُسند القيمة صفر إلى موضع المؤشر في السطر الذي يليه. هذا الشيء غير مثير للإعجاب بحد ذاته، بل إن طريقة عمل العمليات الحسابية والمؤشر سويًّا هي التي تستدعي الاهتمام، فعلى الرغم من بساطة هذا الأمر، إلا أنه يُعد واحدًا من أساسات لغة سي المميزة. نحصل على مؤشر إذا أضفنا قيمة عدد صحيح إلى مؤشر ما، ويكون للمؤشر الذي حصلنا عليه نفس نوع المؤشر الأصلي؛ فبإضافة العدد "n" إلى مؤشر ما يشير إلى عنصر في مصفوفة، سنحصل على عنصر يشير إلى العنصر الذي يلي العنصر السابق بمقدار "n" داخل المصفوفة ذاتها، ويمكن تطبيق حالة الطرح بما أن العدد "n" يمكن أن يكون سالبًا. بالرجوع إلى المثال السابق، ينتج عن التعبير التالي: *(ip+1) = 0; تغيير قيمة ar[6]‎ إلى صفر، وهكذا. لا تعدّ هذه الطريقة تحسينًا على طرق الوصول إلى عناصر المصفوفة الاعتيادية، إليك مثالًا عن ذلك بدلًا من السابق: int ar[20], *ip; for(ip = &ar[0]; ip < &ar[20]; ip++) *ip = 0; يوضّح المثال السابق ميزةً كلاسيكيةً للغة سي، إذ يشير المؤشر إلى بداية المصفوفة، وبينما يشير المؤشر إلى المصفوفة يمكن الوصول إلى عناصر المصفوفة واحدًا تلو الآخر بزيادة المؤشر بمقدار واحد كلّ مرة. يدعم معيار سي بعض الممارسات الموجودة وذلك بالسماح لاستخدام عنوان العنصر ar[20]‎ على الرغم من عدم وجود هذا العنصر، ويسمح لك هذا باستخدام المؤشرات لاختبار حدود المصفوفة ضمن الحلقات التكرارية كما هو الحال في المثال السابق، إذ أن ضمان عمله يمتد لعنصر واحد فقط خارج نهاية المصفوفة وليس أكثر من ذلك. لكن ما المميز في هذه الطريقة مقارنةً باستخدام دليل المصفوفة للوصول إلى العنصر بالطريقة الاعتيادية؟ يمكن الوصول إلى عناصر المصفوفات في معظم الحالات بالتعاقب، واستعرضت القليل من الأمثلة البرمجية السابقة خيار الوصول إلى العناصر "عشوائيًا". إذا أردت الوصول إلى عناصر المصفوفة بالتعاقب فسيقدّم استخدام المؤشرات تنفيذًا أسرع، إذ يتطلب الأمر على معظم معماريات الحاسوب عملية ضرب وجمع واحدةً للوصول إلى عنصر ضمن مصفوفة أحادية البعد باستخدام دليله، بينما لا يتطلب الأمر باستخدام المؤشرات إجراء أي عمليات حسابية إطلاقًا، إذ يخزن المؤشر العنوان الدقيق للكائن (عنصر المصفوفة في هذه الحالة). العملية الحسابية الوحيدة المُجراة في المثال السابق هي ضمن حلقة for التكرارية، إذ تحدث عملية إضافة ومقارنة كل دورة داخل الحلقة. إذا أردنا استخدام طريقة الوصول لعناصر المصفوفة باستخدام الأدلة، نكتب: int ar[20], i; for(i = 0; i < 20; i++) ar[i] = 0; تحدث العمليات الحسابية ذاتها في الحلقة التكرارية كما في المثال السابق، لكن بإضافة حسابات العنوان المُجراة كل دورة في الحلقة. لا تعدّ نقطة توفير الوقت والفاعلية مشكلةً كبيرةً في معظم الأحيان، إلا أن الأمر مهمٌ هنا في حالة الحلقات التكرارية، إذ تتكرر الحلقات عددًا كبيرًا من المرات وكل جزء من الثانية يمكن توفيره في كل دورة له تأثير، ولا يستطيع المصرّف مهما كان ذكيًّا التعرُّف على جميع الحالات التي يمكن له استخدام المؤشرات بدلًا من طريقة دليل المصفوفة ضمنيًا. إذا استوعبت جميع ما قرأته حتى الآن فتابع معنا، وإلّا فتجاوز هذا القسم واذهب للمقال التالي، فعلى الرغم من المعلومات المثيرة للاهتمام في الأقسام التالية إلا أنها غير ضرورية وتُعرَف برهبتها لمبرمجي لغة سي المتمرسين حتى. في حقيقة الأمر، لا "تفهم" لغة سي مبدأ الوصول لعناصر المصفوفة باستخدام أدلتها (باستثناء نقطة التصريح عن المصفوفة)، فالتعبير x[n]‎ يُترجم بالنسبة للمصرّف على النحو التالي: (x+n)*، إذ يُحوَّل اسم المصفوفة إلى مؤشر يشير إلى العنصر الأول للمصفوفة وذلك أينما وجد اسم المصفوفة ضمن تعبير ما. يُعد هذا سببٌ من ضمن أسباب أخرى لبدء عناصر المصفوفة بالرقم صفر؛ فإذا كان x اسم المصفوفة، سيكون التعبير ‎&x[0]‎‎ مساوٍ للمصفوفة x، أي مؤشر إلى العنصر الأول من المصفوفة. نستطيع الوصول إلى x[0]‎ باستخدام المؤشرات باستخدام التعبير ‎*(‎&x[0]‎)‎، مما يعني أن ‎*‎(&x[0] + 5‎‎)‎ مساوٍ للتعبير ‎*(x + 5)‎ وهو ذات التعبير [x[5. يفتح ذلك الأمر سيلًا من التساؤلات عن الإمكانيات الناتجة، فإذا كان التعبير x[5]‎ يُترجم إلى ‎*(x + 5)‎ والتعبير x + 5 يعطي النتيجة ذاتها للتعبير: 5 + x فالتعبير 5[x] مساوٍ للتعبير x[5]‎. إليك برنامجًا يُصرّف وينفذ دون أي أخطاء إن لم تصدق هذا الأمر: #include <stdio.h> #include <stdlib.h> #define ARSZ 20 main(){ int ar[ARSZ], i; for(i = 0; i < ARSZ; i++){ ar[i] = i; i[ar]++; printf("ar[%d] now = %d\n", i, ar[i]); } printf("15[ar] = %d\n", 15[ar]); exit(EXIT_SUCCESS); } [مثال 3] لتلخيص ما سبق: تبدأ العناصر في أي مصفوفة من الدليل ذي الرقم صفر. ليس هناك أي وجود للمصفوفات متعددة الأبعاد، بل هي في حقيقة الأمر مصفوفاتٌ تحتوي على مصفوفات. تُشير المؤشرات إلى أشياء، والمؤشرات التي تشير إلى أشياء من أنواع مختلفة هي بدورها من أنواع مختلفة أيضًا ولا يوجد أي تشابه بين الأنواع المختلفة في لغة سي وأي تحويل ضمني تلقائي بينهما. يمكن استخدام المؤشرات لمحاكاة استخدام الاستدعاء بالإشارة ضمن الدوال، ولكن الأمر يستغرق بعضًا من الجهد لتحقيقه. تُستخدم زيادة أو نقصان قيمة مؤشر ما للتنقل بين عناصر المصفوفة. يضمن المعيار أن محاولة الوصول إلى العنصر ذي الدليل "n" في مصفوفة ذات حجم "n" محاولةٌ صالحة على الرغم من عدم وجود هذا العنصر وذلك لتسهيل أمر التنقل داخل المصفوفة بزيادة قيمة المؤشر، ويكون مجال قيم مصفوفة مصرّح عنها على النحو int ar[N]‎ هو ‎&ar[0]‎ وصولًا إلى ‎&ar[N]‎ ولكن يجب عليك تفادي الوصول إلى قيمة العنصر الأخير الزائف. الأنواع المؤهلة Qualified تابع قراءة الفقرات التالية إن كنت واثقًا من فهمك لأساسيات عملية التصريح عن المؤشرات واستخدامها، وإلا فمن المهم العودة إلى الفقرات السابقة ومحاولة فهمها جيّدًا قبل قراءة الفقرات التالية، إذ أن المعلومات المذكورة في الفقرات التالية أكثر تعقيدًا، ولا داعِ لجعل الأمر أسوأ بعدم تحضيرك وفهمك لما سبق. قدم المعيار شيئان باسم مؤهلات النوع type qualifiers، إذ لم يكونا في لغة سي القديمة مسبقًا، ويمكن تطبيقهما لأي نوع مصرّحٌ عنه للتعديل من تصرفه، ومن هنا أتى اسمهما. سنتجاهل إحداهما (المدعو باسم "volatile") إلا أنه لا يمكننا تجاهل الآخر "const". إذا سبقت الكلمة المفتاحية "const" أي تصريح، فهذا يعني أن الشيء الذي صُرّح عنه هو ثابت، ويجب عليك تجنب محاولة التغيير على قيمة الكائنات الثابتة "const" وإلا فستحصل على سلوك غير محدّد undefined behaviour، وسيحذّرك المصرّف عادةً بمنعك من هذه المحاولة إلا إذا تجاوزت هذا القيد بحيلةٍ ما. هناك فائدتان مرجوتان من تصريح كائن ما بكونه ثابتًا "const": يشير استخدام الكلمة المفتاحية "const" إلى أن القيمة غير قابلة للتغيير، مما يجبر المصرّف على التحقق من أي تغييرات طرأت على هذه القيمة ضمن الشيفرة البرمجية، وهذا الأمر باعث للطمأنينة في حال أردت استخدام قيمٍ ثابتة، مثل المؤشرات التي تُستخدم وسطاءً في بعض الدوال. إذا احتوى التصريح عن الدالة مؤشرات تشير إلى كائنات ثابتة على أنها وسطاء، فهذا يعني أن الدالة لن تشير إلى أي كائن آخر. عندما يعلم المصرّف بأن الأشياء هي كائنات ثابتة، ينعكس ذلك إيجابيًا على قدرته برفع فاعلية الشيفرة البرمجية وسرعتها. الثوابت عديمة الفائدة في حال لم تسند إليها أي قيمة، لن نتطرق بالتفصيل بخصوص تهيئة الثوابت (سنناقش الأمر لاحقًا)، كل ما عليك تذكره الآن هو أنه من الممكن لأي تصريح إسناد القيمة لتعبيرٍ ثابت. إليك بعض الأمثلة عن التصريح عن ثوابت: const int x = 1; /* ثابت x */ const float f = 3.5; /* ثابت f*/ const char y[10]; /* y مصفوفة من 10 عناصر ذات قيم صحيحة ثابتة */ /* لا تفكر بخصوص تهيئة قيمها بعد */ ما يثير الاهتمام هو كون هذا المؤهل ممكن التطبيق على المؤشرات بطريقتين: إما بجعل الشيء الذي يشير إليه المؤشر ثابتًا، بحيث يصبح نوع المؤشر "مؤشر إلى ثابت"، أو بجعل المؤشر بذات نفسه ثابتًا (مؤشرًا ثابتًا)، إليك مثالًا عن ذلك: int i; /* عدد صحيح اعتيادي i */ const int ci = 1; /* عدد صحيح ثابت ci */ int *pi; /* مؤشر إلى عدد صحيح pi */ const int *pci; /* مؤشر إلى عدد صحيح ثابت pci */ /* بالانتقال إلى الأمثلة الأكثر تعقيدًا */ // مؤشر ثابت يشير إلى قيمة عدد صحيح ‪‪cpi int *const cpi = &i; // مؤشر ثابت يشير إلى قيمة عدد صحيح ثابتة cpci const int *const cpci = &ci; التصريح الأول (للمتغير i) اعتيادي، ولكن تصريح ci يوضح أنه عدد صحيح ثابت وبذلك لا يمكن التعديل على قيمته، وسيكون بلا فائدة إن لم يُهيّأ (إسناد قيمة أولية له). ليس من الصعب فهم الغرض من مؤشر لعدد صحيح، ومؤشر لعدد صحيح ثابت، ولكن يجب الانتباه إلى أنواع المؤشرات المختلفة، إذ لا يجوز الخلط بينهم. يمكنك تغيير قيمة كل من pi و pci بجعلهما يشيران إلى أشياء أخرى، كما يمكنك تغيير قيمة الشيء الذي يشير إليه المؤشر pi بالنظر إلى كونه عدد صحيح غير ثابت، ولكن لا يمكنك إلّا الوصول إلى قيمة الشيء الذي يشير إليه المؤشر pci دون التعديل عليه نظرًا لكونه ثابتًا. يُعد التصريحان الأخيران أكثر التصريحات تعقيدًا ضمن المثال؛ فإذا كانت المؤشرات بذات نفسها ثابتةً، فمن غير المسموح تغيير المكان الذي تشير إليه، وبالتالي يجب تهيأتهما بقيمة أولية مثل ci. يمكن للشيء المُشار إليه بالمؤشر أن يكون ثابتًا أو غير ثابت بغض النظر عن كون المؤشر ثابتًا بدوره أم لا، وهذا يملي بعض القيود على استخدام الكائن المُشار إليه. أخيرًا للتوضيح: ما الذي يملي وجود نوع مؤهّل؟ كان ci في المثال السابق نوعًا مؤهلًا بكل وضوح، ولكن pci لم تنطبق عليه هذه الحالة بما أن المؤشر ليس من نوع مؤهّل بل الشيء الذي يشير إليه. الأشياء الوحيدة الذي كانت ذات أنواع مؤهلة في المثال هي: ci و cpi و cpci. سيتطلب منك الأمر بعض الوقت للاعتياد على هذا النوع من التصريحات، ولكن استخدامها سيكون تلقائيًّا وطبيعيًا بعد فترة فلا تقلق، إلا أن التعقيدات تبدأ بالظهور لاحقًا عندما يتوجب عليك الإجابة على السؤال: "هل من المسموح لي -على سبيل المثال- مقارنة مؤشر اعتيادي مع مؤشر ثابت؟ وإذا كان الجواب نعم، ما الذي تعنيه المقارنة؟". معظم القوانين واضحة بهذا الخصوص، ولكن يجب ذكرها وتوضيحها بغض النظر عن سهولتها. سنتكلم عن أنواع البيانات المؤهلة بتوسعٍ أكبر لاحقًا. عمليات المؤشرات الحسابية سنتكلم بالتفصيل لاحقًا عن عمليات المؤشرات الحسابية، ولكننا سنكتفي الآن بإصدار مختصرٍ يفي بالغرض. يمكنك الطرح أو المقارنة بين مؤشرين من النوع نفسه بالإضافة إلى إضافة قيمة عددية صحيحة إلى المؤشر، ويجب أن يشير كلا المؤشرين إلى المصفوفة ذاتها وإلا حصلنا على سلوك غير محدد. نتيجة طرح مؤشرين هي قيمة العناصر التي تفصل بينهما في المصفوفة، ونوع النتيجة معرفٌ بحسب التطبيق وسيكون إما "short" أو "int" أو "long"، ويوضح المثال القادم مثالًا على حساب الفرق بين مؤشرين واستخدام النتيجة، ولكن قبل أن ننتقل إلى المثال يجب أن تعرف معلومةً مهمة. يُحوَّل اسم المصفوفة في أي تعبير إلى مؤشر يشير إلى العنصر الأول ضمن هذه المصفوفة، والحالة الوحيدة الاستثنائية هي عند استخدام اسم المصفوفة مع الكلمة المفتاحية "sizeof"، أو عند استخدام سلسلة نصية لتهيئة قيمة مصفوفة ما، أو عندما يكون اسم المصفوفة مرتبطًا بعامل "عنوان الكائن" (العامل الأحادي "&")، لكننا لم نتطرق إلى أيّ من الحالات السابقة بعد، وسنناقشها لاحقًا. إليك المثال: #include <stdio.h> #include <stdlib.h> #define ARSZ 10 main(){ float fa[ARSZ], *fp1, *fp2; fp1 = fp2 = fa; /* عنوان العنصر الأول */ while(fp2 != &fa[ARSZ]){ printf("Difference: %d\n", (int)(fp2-fp1)); fp2++; } exit(EXIT_SUCCESS); } [مثال 4] يشير المؤشر fp2 إلى عناصر المصفوفة، ويُطبع الفرق بين قيمته الحالية وقيمته الأصلية، وللتأكد من عدم تمرير النوع الخاطئ للوسيط للدالة printf تُحوَّل القيمة الناتجة عن فرق المؤشرين قسريًّا إلى int باستخدام تحويل الأنواع (int)، وهذا يجنّبنا من الأخطاء على الحواسيب التي تعيد قيمة long لهذا النوع من العمليات. قد يعود إلينا المثال السابق بإجابات خاطئة إذا كان الفرق بين القيمتين من نوع long وكانت المصفوفة كبيرة الحجم، ونلاحظ في المثال التالي إصدارًا آمنًا من المثال السابق، إذ يُستخدم تحويل الأنواع قسريًا للسماح بوجود قيم long: #include <stdio.h> #define ARSZ 10 main(){ float fa[ARSZ], *fp1, *fp2; fp1 = fp2 = fa; /* عنوان العنصر الأول */ while(fp2 != &fa[ARSZ]){ printf("Difference: %ld\n", (long)(fp2-fp1)); fp2++; } return(0); } [مثال 5] مؤشرات void و null والمؤشرات الإشكالية لغة سي حريصة بشأن أنواع المؤشرات، ولن تسمح لك عمومًا باستخدام مؤشرات ذات أنوع مختلفة ضمن التعبير ذاته. يختلف مؤشر إلى نوع "char" عن مؤشر إلى نوع "int" ولا يمكنك -على سبيل المثال- إسناد قيمة أحدهما إلى الآخر أو المقارنة فيما بينهما أو طرحهما من بعضهما واستخدام النتيجة مثل وسيط في دالة ما، كما يمكن أيضًا تخزين النوعين في الذاكرة بصورةٍ مختلفة وأن يكونا بأطوال مختلفة. لكن نريد في بعض الحالات تجاوز هذه القيود، فكيف نفعل ذلك؟ يكمن الحل هنا باستخدام أنواع خاصة، وقد قدمنا واحدًا من هذه الأنواع سابقًا ألا وهو "مؤشر إلى void"، وقُدّمت هذه الميزة مع سي المعيارية إذ افتُرض سابقًا أن المؤشر من نوع "مؤشر إلى char" كافٍ لهذه المهمة، وكان الافتراض صحيحًا إلى حدٍّ ما إلا أنه كان حلًّا غير منظّمًا، بينما قدّم الحل الجديد طريقةً أكثر أمانًا وأقل تشويشًا. لا يوجد أي استخدام للمؤشر هذا، لأن "* void" لا يشير إلى أي قيمة، لذا يحسّن هذا الأمر من سهولة قراءة الشيفرة البرمجية. يمكن أن يخزن المؤشر من النوع "* void" أي قيمة من أي مؤشر آخر، ويمكن إسناده إلى مؤشر آخر من أي نوع أيضًا، إلا أنه يجب استخدام هذا النوع من المؤشرات بحذر لأنه قد ينتهي الأمر بك ببعض الأخطاء الوخيمة، وسنناقش استخدامه الآمن مع دالة "malloc" لاحقًا. قد تحتاج أيضًا في بعض الحالات إلى مؤشر مضمون أنه لا يشير إلى أي كائن والذي يُدعى مؤشر من نوع "null" أو مؤشر الفراغ null pointer. من الشائع في لغة سي كتابة بعض الإجراءات routines التي تعيد مؤشرات، بحيث يمكن الدلالة على فشل ذلك الإجراء بعدم قدرته على إعادة مؤشر صالح عن طريق إعادة مؤشر الفراغ. ومن الأمثلة على ذلك إجراء فحصٍ لقيم موجودة في جدول ما بحثًا عن قيمة معينة ويعيد مؤشرًا على الكائن المُطابق إن وُجدت النتيجة أو مؤشر الفراغ إن لم تُوجد أي نتيجةٍ مطابقة. لكن كيف يمكن كتابة مؤشر فراغ؟ هناك طريقتان لفعل ذلك وكلا الطريقتين متماثلتين في النتيجة، إما باستخدام رقم صحيح ثابت بقيمة "0" أو تحويل القيمة إلى نوع "* void" باستخدام التحويل بين الأنواع، وتدعى نتيجة الطريقتين بمؤشر الفراغ الثابت null pointer constant. إذا أسندت مؤشر فراغ إلى أي مؤشر آخر أو قارنت بين مؤشر الفراغ ومؤشر آخر فسيُحوَّل مؤشر الفراغ إلى نوع المؤشر الآخر تلقائيًّا، مما سيحلّ أي مشكلة بخصوص توافقية الأنواع، ولن تُساوي القيمة التي يشير إليها ذلك المؤشر -مؤشر الفراغ- أي قيمة كائن آخر يشير إليها أي مؤشر داخل البرنامج (أي سيشير إلى قيمة فريدة). القيم الوحيدة الممكن إسنادها للمؤشرات باستثناء القيمة "0" هي قيم المؤشرات الأخرى من نفس النوع، إلا أن الأمر الذي يجعل من لغة سي مميزة وبديلًا مفيدًا للغة التجميعية هو سماحها لك بفعل بعض الأشياء التي لا تسمح لك بها معظم لغات البرمجة الأخرى، جرّب التالي: int *ip; ip = (int *)6; *ip = 0xFF; ما نتيجة السابق؟ تُهيأ قيمة المؤشر إلى 6 (لاحظ تحويل نوع 6 من int إلى مؤشر)، وهذه عملية تُجرى على مستوى الآلة غالبًا ويكون تمثيل قيمة المؤشر بالبتات غير مشابه لما قد يكون تمثيل الرقم 6، كما تُسند القيمة الست عشرية FF بعد التهيئة إلى الكائن الذي يشير إليه المؤشر. تُكتب القيمة 0xFF على الرقم الصحيح ذو الموضع 6، إذ يعتمد الموضع 6 على تفسير الآلة له على الذاكرة. قد تحتاج لهذا النوع من الأشياء وقد لا تحتاج إليها إطلاقًا، ولكن لغة سي تعطيك الخيار، ومن الواجب معرفتها إذ أنه من الممكن كتابتها على نحوٍ خاطئ غير مقصود مما سيتسبب بنتائج مفاجئة جدًا. ترجمة -وبتصرف- لقسم من الفصل Arrays and Pointers من كتاب The C Book‪‏. اقرأ أيضًا المقال التالي: التعامل مع المحارف والسلاسل النصية في لغة سي C المقال السابق: مدخل إلى المصفوفات في لغة سي C مفهوم النطاق Scope والربط Linkage على مستوى الدوال في لغة C مفهوم التعاود Recursion وتمرير الوسطاء إلى الدوال في لغة سي C البنية النصية لبرامج سي C

تستخدم لغة سي المصفوفات Arrays مثل سائر اللغات الأخرى لتمثيل مجموعة من متغيرات ذات خصائص متماثلة، إذ يكون لهذه المجموعة اسمًا واحدًا وتُحدّد عناصرها عن طريق دليل Index. إليك مثالًا للتصريح عن مصفوفةٍ ما: double ar[100]; في هذا المثال اسم المصفوفة هو ar ويمكن الوصول لعناصر المصفوفة عن طريق دليل كلٍّ منها كما يلي: ar[0]‎ وصولًا إلى ar[99]‎ لا غير، كما يوضح الشكل 1: شكل 1 مصفوفة ذات 100 عنصر يمثّل كلّ عنصر من عناصر المصفوفة المئة متغيّرًا منفصلًا من نوع double، ويُرمز لكل عنصر من أي مصفوفة في لغة سي بدءًا من الدليل 0 وصولًا إلى الدليل الذي يساوي حجم المصفوفة المُصرّح عنه ناقص واحد، ويعدّ البدء بالترقيم من 0 مفاجئًا لبعض المبتدئين فركّز على هذه النقطة. عليك أن تنتبه أيضًا إلى أن المصفوفات لا تقبل حجمًا متغيّرًا عند التصريح عنها، إذ يجب أن يكون الرقم تعبيرًا ثابتًا يمكن معرفة قيمته الثابتة وقت تصريف البرنامج compile time وليس وقت التشغيل run time. يوضح المثال التالي طريقة خاطئة للتصريح عن مصفوفة باستخدام الوسيط x: f(int x){ char var_sized_array[x]; /* هذه الطريقة ممنوعة*/ } وهذا ممنوع لأن قيمة x غير معروفة عند تصريف البرنامج، فهي قيمة تُعرف عند تشغيل البرنامج وليس عند تصريفه. من الأسهل لو كان مسموحًا استخدام المتغيرات لتحديد حجم المصفوفات وبالأخص البعد الأوّل لها، ولكن هذا الأمر لم تسمح به سي القديمة أو سي المعيارية، إلا أن هناك مصرّف قديم جدًا للغة سي اعتاد السماح بهذا. المصفوفات متعددة الأبعاد يمكن التصريح عن المصفوفات متعددة الأبعاد Multidimensional arrays على النحو التالي: int three_dee[5][4][2]; int t_d[2][3] تُستخدم الأقواس المعقوفة بعد كلٍّ من المصفوفات السابقة، وإذا نظرت إلى جدول الأسبقية في مقال العوامل في لغة سي C، فستلاحظ أن قراءة القوسين [] تكون من اليسار إلى اليمين وبذلك تكون نتيجة التصريح مصفوفةً تحتوي على خمس عناصر باسم three_dee، ويحتوي كل عنصر من عناصر هذه المصفوفة بدوره على مصفوفة بحجم أربعة عناصر وكل عنصر من هذه المصفوفة الأخيرة يحتوي على مصفوفة من عنصرين، وجميع العناصر من نوع int، وبهذه الحالة فنحن صرحنا عن مصفوفة مصفوفات، ويوضح الشكل 2 مثالًا على مصفوفة ثنائية البعد باسم t_d في مثال التصريح. شكل 2 هيكل مصفوفة ثنائية البعد ستلاحظ في الشكل السابق أن t_d[0]‎ عنصرٌ واحدٌ متبوعٌ بعنصر t_d[1]‎ دون أي فواصل، وكلا العنصرين يمثّلان مصفوفةً بحدّ ذاتهما بسعة ثلاث أعداد صحيحة. يأتي العنصر t_d[1][0]‎ مباشرةً بعد العنصر t_d[0][2]‎، ومن الممكن الوصول إلى t_d[1][0]‎ بالاستفادة من عدم وجود أي طريقة للتحقق من حدود المصفوفة باستخدام التعبير t_d[0][3]‎ إلا أن هذا غير محبّذ أبدًا، لأن النتائج ستكون غير متوقعة إذا تغيّرت تفاصيل التصريح عن المصفوفة t_d. حسنًا، لكن هل هذا الأمر يؤثر على سلوك البرنامج عمليًّا؟ في الحقيقة لا، إلا أنه من الجدير بالذكر أن موقع تخزين العنصر الواقع على أقصى اليمين ضمن المصفوفة "يتغير بسرعة"، ويؤثر ذلك على المصفوفات عند استخدام المؤشرات معها، ولكن يمكن استخدامها بشكلها الطبيعي عدا عن تلك الحالة، مثل التعابير التالية: three_dee[1][3][1] = 0; three_dee[4][3][1] += 2; التعبير الأخير مثيرٌ للاهتمام لسببين، أولهما أنه يصل إلى قيمة العنصر الأخير من المصفوفة والمصرّح أنها بحجم [2][4][5]، والدليل الذي نستطيع استخدامه هو أقل بواحد دائمًا من العدد الذي صرّحنا عنه، أما ثانيًا، فنلاحظ أهمية وسهولة استخدام عامل الإسناد المُركّب في هذه الحالة. يفضّل مبرمجو لغة سي المتمرسون هذه الطريقة المختصرة، إليك كيف سيبدو الأمر لو كان التعبير مكتوبًا بلغة أخرى لا تسمح باستخدام هذا العامل: three_dee[4][3][1] = three_dee[4][3][1] + 2; ففي هذه الحالة يجب أن يتحقق القارئ أن العنصر على يمين عامل الإسناد هو ذات العنصر على يسار عامل الإسناد، كما أن الطريقة المُختصرة أفضل عند تصريفها، إذ يُحسب دليل العنصر وقيمته مرةً واحدة، مما ينتج شيفرةً برمجيةً أقصر وأسرع. قد ينتبه بعض المصرّفات طبعًا إلى أن العنصرين على طرفَي عامل الإسناد متساويين ولن تلجأ للوصول للقيمة مرتين، ولكن هذه الحالة لا تنطبق على جميع المصرّفات، وهناك العديد من الحالات أيضًا التي لا تستطيع فيها المصرفات الذكية هذه باختصار الخطوات. على الرغم من تقديم لغة سي دعمًا للمصفوفات متعددة الأبعاد، إلا أنه من النادر أن تجدها مُستخدمةً عمليًّا، إذ تُستخدم المصفوفات أحادية البعد أكثر في معظم البرامج، وأبسط هذه الأسباب هو أن السلسلة النصية String تُمثّل بمصفوفة أحادية البعد، وقد تلاحظ استخدام المصفوفات ثنائية البعد في بعض الحالات، ولكن استخدام المصفوفات ذات أبعاد أكثر من ذلك نادرة الحدوث، وذلك لكون المصفوفة هيكل بيانات غير مرن بالتعامل، كما أن سهولة عملية إنشاء ومعالجة هياكل البيانات وأنواعها في لغة سي تعني إمكانية استبدال المصفوفات في معظم البرامج متقدمة المستوى، وسننظر إلى هذه الطرق عندما ننظر إلى المؤشرات. ترجمة -وبتصرف- لقسم من الفصل Arrays and Pointers من كتاب The C Book اقرأ أيضًا المقال التالي: المؤشرات Pointers في لغة سي C المقال السابق: مفهوم النطاق Scope والربط Linkage على مستوى الدوال في لغة C مفهوم التعاود Recursion وتمرير الوسطاء إلى الدوال في لغة سي C الدوال في لغة C البنية النصية لبرامج سي C

على الرغم من تفادينا لموضوعَي النطاق Scope والربط Linkage في أمثلتنا البسيطة سابقًا، إلا أن الوقت قد حان لشرح هذين المفهومين وأثرهما على قابلية الوصول للكائنات المختلفة في برنامج سي C، ولكن لمَ علينا الاكتراث بذلك على أي حال؟ لأن البرامج العملية التي نستخدمها تُبنى من عدّة ملفات ومكتبات، وبالتالي من المهم للدوال في ملف ما أن تكون قادرةً على الإشارة إلى دوال، أو كائنات في ملفات أو مكتبات أخرى، وهناك عدّة قوانين ومفاهيم تجعل من ذلك ممكنًا. عُد لاحقًا إلى هذه الجزئية إن كنت جديدًا على لغة سي، لأن هناك بعض المفاهيم الأهم التي يجب عليك معرفتها أوّلًا. الربط Linkage هناك نوعان أساسيان من الكائنات في لغة سي C، هما: الكائنات الخارجية والكائنات الداخلية، والفرق بين الاثنين مُعتمدٌ على الدوال؛ إذ أن أيّ شيء يُصرّح عنه خارج الدالة فهو خارجي؛ وأي شيء يُصرّح عنه داخل الدالة بما فيه مُعاملات الدالة فهو داخلي. بما أننا لا نستطيع تعريف دالة ما داخل دالة أخرى، فهذا يعني أن الدوال هي كائنات خارجية دائمًا، وإذا نظرنا إلى بنية برنامج سي على المستوى الخارجي، سنلاحظ أنه يمثّل مجموعةً من الكائنات الخارجية External objects. يمكن للكائنات الخارجية فقط أن تُشارك في هذا الاتصال عبر الملفات والمكتبات، وتُعرف قابلية الوصول للكائنات هذه من ملف إلى آخر أو ضمن الملف نفسه وفقًا للمعيار باسم الربط Linkage، وهناك ثلاثة أنواع للربط، هي: الربط الخارجي External linkage والربط الداخلي Internal Linkage وعديم الربط No linkage. يكون أي شيء داخلي في الدالة سواءٌ كان وسطاء الدالة أو متغيراتها عديم الربط دائمًا ويمكن الوصول إليه من داخل الدالة فقط، ويمكنك التصريح عن الشيء الذي تريده داخل الدالة مسبوقًا بالكلمة المفتاحية extern لتجاوز هذا القيد، وهذا سيدل على أن الكائن ليس داخليًّا، وليس عليك القلق بهذا الشأن في الوقت الحالي. تكون الكائنات ذات الربط الخارجي موجودةً على المستوى الخارجي لبنية البرنامج، وهذا هو نوع الربط الافتراضي للدوال ولأي شيء آخر يُصرَّح عنه خارج الدوال، وتُشير جميع الأسماء المماثلة لاسم الكائن ذو الربط الخارجي إلى الكائن نفسه. ستحصل على سلوك غير محدد من البرنامج، إذا صرحت عن كائن بنفس الاسم مرتين أو أكثر بربط خارجي وبأنواع غير متوافقة. المثال الذي يأتي إلى بالنا مباشرةً بخصوص الربط الخارجي هو الدالة printf والمُصرّح عنها في ملف الترويسة <stdio.h> على النحو التالي: int printf(const char *, ...); يمكننا فورًا بالنظر إلى التصريح السابق معرفة أن الدالة printf تُعيد قيمةً من نوع int باستخدام النموذج الأولي الموضّح، كما نعرف أن للدالة ربطًا خارجيًّا لأنها كائن خارجي (تذكّر، كل دالة هي كائن خارجي افتراضيًا)، وبالتالي فنحن نقصد هذه الدالة تحديدًا عندما نكتب الاسم printf في أي مكان ضمن البرنامج، إذا استخدمنا الربط الخارجي. ستحتاج في بعض الأحيان لطريقة تمكّنك من التصريح عن الدوال والكائنات الأخرى في ملفٍ واحد بحيث تسمح لهم بالإشارة إلى بعضهم البعض دون القدرة على الوصول إلى تلك الكائنات والدوال من خارج الملف. نحتاج هذه الطريقة غالبًا في الوحدات modules التي تدعم دوال المكتبات، إذ من الأفضل في هذه الحالة إخفاء بعض الكائنات التي تجعل استخدام هذه الدالة ضمن المكتبة ممكنًا، فهي ليست ضرورية المعرفة لمستخدم المكتبة وستكون سببًا للإزعاج لا غير، ونستطيع تحقيق ذلك الأمر عن طريق استخدام الربط الداخلي. تُشير الأسماء ذات الربط الداخلي للكائن ذاته ضمن ملف الشيفرة المصدرية الواحد، ويمكنك التصريح عن كائن ذي ربط داخلي عن طريق بدء التصريح بالكلمة المفتاحية "static" التي ستغيّر ربط الكائن من ربط خارجي (افتراضي) إلى ربط داخلي، كما يمكنك التصريح عن كائنات داخلية باستخدام "static" بهدف استخدامٍ آخر ولكننا لن نتطرق لهذا الاستخدام حاليًا. من المُربك استخدام المصطلحين "داخلي" و"خارجي" لوصف نوع الربط ونوع الكائن، ولكن يعود ذلك لأسباب تاريخية، إذ سيتذكر مبرمجو لغة سي القدماء كون الاستخدامين متساويين، وأن استخدام أحدهما يتضمن تحقّق الآخر، ولكن تغيّر ذلك الأمر للأسف حديثًا وأصبح معنى الاستخدامين مختلف، ولنلخّص الفرق فيما يلي: table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } نوع الربط نوع الكائن قابلية الوصول خارجي خارجي يمكن الوصول إليه من أي مكان ضمن البرنامج داخلي خارجي يمكن الوصول إليه عبر ملف واحد فقط لا يوجد ربط داخلي محلّي لدالة واحدة [جدول 1 الربط وقابلية الوصول] أخيرًا وقبل أن ننتقل إلى مثالٍ آخر، علينا أن نعرف أن لجميع الكائنات ذات الربط الخارجي تعريفٌ واحدٌ فقط، مع أنه بالإمكان أن يوجد عدة تصريحات متوافقة حسب حاجتك. إليك المثال: /* الملف الأول */ int i; /* تعريف*/ main () { void f_in_other_place (void); /* تصريح*/ i = 0 } /* نهاية الملف الأول */ /* بداية الملف الثاني */ extern int i; /* تصريح*/ void f_in_other_place (void){ /* تعريف*/ i++; } /* نهاية الملف الثاني */ [مثال 1] على الرغم من تعقيد القوانين الكاملة التي تحدد الفرق بين التعريف والتصريح إلا أن هناك طريقةً بسيطةً وسهلة، هي: التصريح عن الدالة دون تضمين متن الدالة هو تصريحٌ لا غير. التصريح عن الدالة مرفقًا بمتن الدالة هو تعريف. عمومًا، التصريح عن كائن على المستوى الخارجي للبرنامج (مثل المتغير i في المثال السابق) هو تعريف، إلا إذا سُبق بالكلمة المفتاحية extern وعندها يصبح تصريحًا فقط. وسنتكلم لاحقًا عن التعريف والتصريح بصورةٍ أعمق لا تبقي مجالًا للشك. من الواضح في مثالنا السابق أنه من السهل الوصول من أي ملف للكائنات المعرفة في ملفات أخرى باستخدام أسمائها فقط، وسيدلك المثال على كيفية بناء برامج ذات ملفات ودوال ومتغيرات متعددة سواءٌ كانت مُعرّفةً أو مصرّحٌ عنها وفق ما يناسب كل حالة. إليك مثالًا آخر يوضح استخدام "static" لتقييد قابلية الوصول إلى الدوال والأشياء الأخرى. /* مثال عن وحدة في مكتبة */ /* الدالة callable هي الدالة الوحيدة المرئية على المستوى الخارجي */ static buf [100]; static length; static void fillup(void); int callable (){ if (length ==0){ fillup (); } return (buf [length--]); } static void fillup (void){ while (length <100){ buf [length++] = 0; } } [مثال 2] يمكن للمستخدم -بفرض استخدام المثال السابق وحدةً مستقلّة- إعادة استخدام الأسماء "length" و "buf" و "fillup" بأمان دون أي تأثيرات جانبية أو أخطاء غير متوقعة، ونستثني من ذلك الاسم "callable"، إذ إنه قابل الوصول خارج الملف (الوحدة المستقلة). تكون قيمة الكائن الخارجي الذي يمتلك مُهيّئًا initializer واحدًا مساوية للصفر قبل بدء البرنامج (لم نتكلم عن أي مُهيّئات عدا الدوال حتى الآن)، وتعتمد الكثير من البرامج على ذلك، بما فيها المثال السابق لقيمة length الابتدائية. تأثير النطاق لا تقتصر عملية مشاركة الأسماء وقابلية الوصول إليها على الربط ببساطة، فالربط يسمح لك باستخدام عدة أسماء والوصول إليها سويًّا ضمن البرنامج أو ضمن الملف، ولكن النطاق Scope يحدد رؤية الأسماء، وقواعد النطاق لحسن الحظ مستقلةٌ عن مبدأ الربط، لذا ليس عليك حفظ أي قواعد مركبة بين المفهومين. تزيد الكلمة المفتاحية "extern" من تعقيد البرنامج، فعلى الرغم من وضوح استخدامها وتأثيرها إلا أنها تغيّر من بنية برنامج لغة سي الكُتلية التي اعتدنا عليها، وسنناقش المشاكل الناتجة عن استخدامها الخاطئ وغير المسؤول لاحقًا، وقد نظرنا إلى استخدامها مُسبقًا للتأكد من أن التصريح لشيء ما ضمن المستوى الخارجي للبرنامج هو تصريحٌ وليس تعريف. ملاحظة: يمكنك تجاوز الكلمة المفتاحية "extern" عن طريق مُهيّئ للكائن. التصريح عن أي كائن بيانات (ليس بدالة) ضمن المستوى الخارجي للبرنامج هو تعريفٌ، إلا إذا سبق التصريح الكلمة المفتاحية "extern"، راجع المثال 9.4 من أجل ملاحظة هذه النقطة عمليًّا. تحتوي تصريحات الدوال الكلمة المفتاحية "extern" ضمنيًّا سواءٌ كانت مكتوبةً أم لا، والطريقتان التاليتان للتصريح عن الدالة some_function متكافئتان، وتُعدان تصريحًا وليس تعريفًا: void some_function(void); extern void some_function(void); الشيء الوحيد الذي يفصل التصريحات السابقة عن كونها تعريفات هو متن الدالة، الذي يُعد مُهيِّئًا للدالة، لذلك عند إضافة المُهيّئ يتحول التصريح إلى تعريف، لا توجد أي مشكلة بخصوص ذلك. لكن ما الذي يحدث في المثال التالي؟ void some_function(void){ int i_var; extern float e_f_var; } void another_func(void){ int i; i = e_f_var; /* مشكلة تتعلق بالنطاق */ } ما الهدف من المثال السابق؟ من المفيد في بعض الأحيان أن تستخدم كائنًا خارجيًّا ضمن دالة ما، وإن اتبعت الطريقة الاعتيادية بالتصريح عن الكائن في بداية ملف الشيفرة المصدرية، فسيكون صعبًا على القارئ معرفة أي من الدوال تستخدم ذلك الكائن؛ بدلًا من ذلك، يمكنك تقييد نطاق الكائن وقابلية الوصول إليه في المكان الذي تريد الوصول إليه، ممّا سيسهّل على القارئ معرفة أن الاسم سيُستخدم فقط في هذا المكان المحدود وليس على كامل نطاق ملف الشيفرة المصدرية. يجدر الانتباه إلى أن معظم طرق إدارة الوسطاء في هذه الحالة عمليةٌ صعبةٌ بعض الشيء. سنناقش المزيد من القواعد عن الطريقة الأمثل لإنشاء برنامج ذو ملفات متعددة، وما الممكن حدوثه عند المزج بين التصريحات الداخلية والخارجية والكلمات المفتاحية "extern" و "static". لن تكون عملية قراءة هذه القواعد ممتعةً، لكنها ستكون إجابةً لأسئلة من نوع "ماذا لو؟". الكائنات الداخلية الساكنة يمكنك التصريح عن كائنات داخلية على أنها كائنات داخلية ساكنة باستخدام الكلمة المفتاحية "static"، وتكتسب المتغيرات الداخلية بعضًا من الخصائص باستخدامها هذه الكلمة المفتاحية ألا وهي: تُهيّأ قيمتها إلى الصفر عند بداية البرنامج. تحافظ على قيمتها من بداية التعليمة التي تضم تصريحها إلى نهايتها. يوجد نسخةٌ واحدةٌ من كل متغيّر داخلي ساكن تتشاركه الاستدعاءات التعاودية للدوال التي تحوي هذه المتغيرات. يمكن أن تُستخدم المتغيرات الداخلية الساكنة لعدة أمور، أحدها هو عدّ مرات استدعاء دالةٍ ما، إذ تحافظ المتغيرات الداخلية الساكنة على قيمتها بعد الخروج من الدالة بعكس المتغيرات الداخلية الاعتيادية. إليك دالةً تُعيد عددًا بين 0 و15، ولكنها تُبقي عدد المرات التي استُدعيت بها: int small_val (void) { static unsigned count; count ++; return (count % 16); } [مثال 3] يمكن أن نستخدم هذه الطريقة للكشف عن الاستدعاءات التعاودية مفرطة الحدوث: void r_func (void){ static int depth; depth++; if (depth > 200) { printf ("excessive recursion\n"); exit (1); } else { /* .r_func() نفّذ بعض الأوامر الاعتيادية. قد تتسبب النتائج باستدعاء آخر لدالة التعاود */ x_func(); } depth--; } [مثال 4] ترجمة -وبتصرف- لقسم من الفصل Functions من كتاب The C Book اقرأ أيضًا المقال التالي: مدخل إلى المصفوفات في لغة سي C المقال السابق: مفهوم التعاود Recursion وتمرير الوسطاء إلى الدوال في لغة سي C الدوال في لغة C البنية النصية لبرامج سي C العوامل في لغة سي C

نظرنا سابقًا إلى كيفية تعيين نوع للدالة Funtion type (كيفية التصريح عن القيمة المُعادة ونوع أيّ وسيط argument تأخذه الدالة)، وأن تعريف definition الدالة يمثّل متنها أو جسمها body، ولننظر الآن إلى استخدامات الوسطاء. استدعاء الوسيط بقيمته call by value تُعامل لغة سي C وسطاء الدالة بطريقة بسيطة وثابتة دون أي استثناءات فردية؛ إذ تُعامل وسطاء الدالة عندما تُستدعى الدالة مثل أي تعبير اعتيادي، وتُحوّل قيم هذه التعابير وتُستخدم فيما بعد لتهيئة القيمة الأولية لمعاملات الدالة المُستدعاة الموافقة، التي تتصرف بدورها مثل أيّ متغير محلي داخل الدالة، كما هو موضح في المثال: void called_func(int, float); main(){ called_func(1, 2*3.5); exit(EXIT_SUCCESS); } void called_func(int iarg, float farg){ float tmp; tmp = iarg * farg; } [مثال 1] يوجد للدالة called_func تعبيران يحلّان محل الوسطاء في دالة main، وتُقيّم قيمتهما ويُستخدمان في إسناد قيمة مبدئية للمعاملين irag و frag في الدالة called_func، ويملك المعاملان الخصائص ذاتها التي يملكها أي متغير داخلي مصرّحٌ عنه في الدالة called_func دون أي تفريق، مثل tmp. تُعد عملية إسناد القيمة المبدئية للمعاملات الفعلية التواصل الأخير بين مستدعي الدالة والدالة المُستدعاة، إذا استثنينا القيمة المُعادة. يجب أن ينسى من اعتاد البرمجة باستخدام فورتران FORTRAN وباسكال Pascal طريقة استخدام وسطاء من نوع var، والتي يمكن للدالة أن تغير من قيم وسطائها؛ إذ لا يمكنك في لغة سي أن تؤثر على قيم وسطاء الدالة بأي شكل من الأشكال، إليك مثالًا نوضّح فيه المقصود. #include <stdio.h> #include <stdlib.h> main(){ void changer(int); int i; i = 5; printf("before i=%d\n", i); changer(i); printf("after i=%d\n", i); exit(EXIT_SUCCESS); } void changer(int x){ while(x){ printf("changer: x=%d\n", x); x--; } } [مثال 2] ستكون نتيجة المثال السابق على النحو التالي: before i=5 changer: x=5 changer: x=4 changer: x=3 changer: x=2 changer: x=1 after i=5 تَستخدم الدالة changer معاملها الفعلي x بمثابة متغير اعتيادي (وهو فعلًا متغير اعتيادي)، ورغم أن قيمة x تغيرت إلا أن المتغير i في الدالة main لم يتأثر بالتغيير، وهذه هي النقطة التي نريد توضيحها لك بمثالنا، إذ تُمرَّر الوسطاء في سي C إلى الدالة باستخدام قيمها فقط ولا تُمرر أي تغييرات من الدالة بالمقابل. استدعاء الوسيط بمرجعه call by reference من الممكن كتابة دوال تأخذ المؤشرات pointers على أنها وسطاء، مما يعطينا شكلًا من أشكال الاستدعاء بالمرجع. سنناقش هذا لاحقًا، إذ ستسمح هذه الطريقة للدالة بتغيير قيم المتغيرات التي استدعتها. التعاود Recursion بعد أن تكلمنا عن كيفية تمرير الوسطاء بأمان، حان الوقت للتكلم على التعاود Recursion، إذ يثير هذا الموضوع جدلًا طويلًا غير مثمرٍ بين المبرمجين، فالبعض يعدّه رائعًا ويستخدمه متى ما أتيحت له الفرصة، بينما يتجنَّب الطرف الآخر استخدامه بأي ثمن، لكن دعنا نوضّح أنك ستضطرّ لاستخدامه في بعض الحالات دون أي مفرّ. لا يتطلب دعم التعاود أيّ جهد إضافي لتضمينه في أي لغة برمجة، وبذلك -وكما توقّعت- تدعم لغة سي C التعاود. يمكن لأي دالة أن تستدعي نفسها من داخلها أو من داخل أي دالة أخرى في لغة سي، ويتسبب كل استدعاء للدالة بحجز متغيراتٍ جديدة مصرّح عنها داخل الدالة، وفي الحقيقة، كانت تفتقر التصريحات التي استخدمناها حتى اللحظة إلى شيءٍ ما، ألا وهو الكلمة المفتاحية auto التي تعني "الحجز التلقائي". /* مثال عن الحجز التلقائي */ main(){ auto int var_name; . . . } تُحجز وتُحرّر مساحة التخزين للمتغيرات التلقائية تلقائيًا عند البدء بتنفيذ الدالة وعند إعادتها للقيمة، أي الخروج منها، وبذلك سيحتاج البرنامج فقط لحجز مساحة لمصفوفتين مثلًا، في حال صرَّحت دالتين عن مصفوفتين تلقائيتين automatic ونُفِّذت الدالتان في الوقت نفسه. على الرغم من كون "auto" كلمةً مفتاحية في لغة سي، لكنها لا تُستخدم عمليًا لأنها الحالة الافتراضية لعمليات التصريح عن المتغيرات الداخلية وغير صالحة في حال استخدامها مع عمليات التصريح عن المتغيرات الخارجية. تكون قيمة المتغير التلقائي غير معروفةٍ عند التصريح عنه إذا لم تُسند أي قيمة ابتدائية إليه، وسيتسبب استخدام قيمة المتغير في هذه الحالة في ظهور سلوكٍ غير محدد. يجب علينا انتقاء الأمثلة التي سنشرح عن طريقها مفهوم التعاود، إذ لا توضّح الأمثلة البسيطة مفهوم التعاود على النحو المناسب، والأمثلة التي توضح المفهوم كاملًا صعبة الفهم على المبتدئين، الذين يواجهون بعض الصعوبة في التمييز بين التصريح والتعريف على سبيل المثال، وسنتكلم لاحقًا عن مفهوم التعاود وفائدته باستخدام بعض الأمثلة عندما نتكلم عن هياكل البيانات. يوضح المثال التالي برنامجًا يحتوي دالةً تعاوديةً تتحقق من التعابير المُدخلة إليها بما فيها الأرقام (0-9) والعوامل "*" و "%" و "/" و "+" و "-"، إضافةً إلى الأقواس، بالطريقة نفسها التي تستخدمها لغة سي، كما استخدم ستروستروب Stroustrup في كتابه عن لغة ++C المثال ذاته لتوضيح مفهوم التعاود، وهذا من قبيل الصدفة لا غير. يُقيّم التعبير في المثال التالي، ثُم تُطبع قيمته إن صادف محرفًا غير موجودًا في لغته (المحارف التي ذكرناها سابقًا)، ولغرض البساطة لن يكون في المثال أي طريقة للتحقق من الأخطاء. يعتمد المثال كثيرًا على الدالة ungetc التي تسمح للمحرف الأخير الذي قُرأ بواسطة الدالة getchar أن يُعيّن على أنه "غير مقروء" للسماح بقراءته مرةً أخرى، والمُعامل الثاني المُستخدم في المثال مُصرّحٌ عنه في stdio.h. سيرغب من يفهم صيغة باكوس نور BNF بمعرفة أن التعبير سيُفهم عن طريق استخدام الصيغة التالية: <primary> ::= digit | (<exp>) <unary> ::= <primary> | -<unary> | +<unary> <mult> ::= <unary> | <mult> * <unary> | <mult> / <unary> | <mult> % <unary> <exp> ::= <exp> + <mult> | <exp> - <mult> | <mult> يكمن التعاود في مثالنا ضمن مكانين أساسيين، هما: الدالة unary_exp التي تستدعي نفسها، والدالة primary التي تستدعي الدالة الموجودة على المستوى العلوي للبرنامج (نقصد دالة expr) لتقييم التعابير المكتوبة بين قوسين. حاول تشغيل البرنامج باستخدام كل من الأمثلة التالية إذا لم تفهم عمله، وتتبَّع عمله يدويًّا على المُدخلات، كما يلي: 1 1+2 1+2 * 3+4 1+--4 1+(2*3)+4 سيستغرق هذا بعض الوقت منك. /* * برنامج يتحقق من تعابير لغة سي على نحوٍ تعاودي * لم يُشدّد على حالات الإدخال الخاطئة من المستخدم */ #include <stdio.h> #include <stdlib.h> int expr(void); int mul_exp(void); int unary_exp(void); int primary(void); main(){ int val; for(;;){ printf("expression: "); val = expr(); if(getchar() != '\n'){ printf("error\n"); while(getchar() != '\n') /* فارغ */; } else{ printf("result is %d\n", val); } } exit(EXIT_SUCCESS); } int expr(void){ int val, ch_in; val = mul_exp(); for(;;){ switch(ch_in = getchar()){ default: ungetc(ch_in,stdin); return(val); case '+': val = val + mul_exp(); break; case '-': val = val - mul_exp(); break; } } } int mul_exp(void){ int val, ch_in; val = unary_exp(); for(;;){ switch(ch_in = getchar()){ default: ungetc(ch_in, stdin); return(val); case '*': val = val * unary_exp(); break; case '/': val = val / unary_exp(); break; case '%': val = val % unary_exp(); break; } } } int unary_exp(void){ int val, ch_in; switch(ch_in = getchar()){ default: ungetc(ch_in, stdin); val = primary(); break; case '+': val = unary_exp(); break; case '-': val = -unary_exp(); break; } return(val); } int primary(void){ int val, ch_in; ch_in = getchar(); if(ch_in >= '0' && ch_in <= '9'){ val = ch_in - '0'; goto out; } if(ch_in == '('){ val = expr(); getchar(); /* “')” تخطي قوس الإغلاق */ goto out; } printf("error: primary read %d\n", ch_in); exit(EXIT_FAILURE); out: return(val); } [مثال 3] ترجمة -وبتصرف- لقسم من الفصل Functions من كتاب The C Book اقرأ أيضًا المقال التالي: مفهوم النطاق Scope والربط Linkage على مستوى الدوال في لغة C المقال السابق: الدوال في لغة C البنية النصية لبرامج سي C العوامل في لغة سي C

تكلّمنا سابقًا عن أهمية الدوال في لغة سي C وكيف أنها تشكّل اللبنة الأساسية لبرامج سي. إذًا، ليس من المُستغرب أن نخصص هذا المقال بالكامل للتعريف عنها وعن استخدامها، إذ سنطرّق إلى كيفية التصريح عنها واستخدامها بالإضافة إلى أنواع وسطائها وبعض الأمثلة العملية. ما التغييرات التي طرأت على لغة سي المعيارية بخصوص الدوال؟ كانت أسوأ ميزة في لغة سي القديمة هي عدم إمكانية التصريح عن عدد وأنواع وسطاء الدالة، إذ لم يكن ممكنًا للمصرّف compiler حينها أن يتحقق من صحة استخدام الدالة ضمن البرنامج وفق تصريحها، وعلى الرغم من أنها لم تؤثر على نجاح لغة سي، إلا إنها تسببت بمشاكل تخص قابلية نقل البرنامج وصيانته التي كان من الممكن تفاديها جميعًا. غيّرت لغة سي المعيارية من ذلك بقدومها، إذ أصبح من الممكن الآن التصريح عن الدوال بطريقة تسمح للمصرف بالتحقق من صحة استخدامها، وهذه الطريقة الجديدة متوافقة كثيرًأ مع الطريقة القديمة، لذا ستعمل البرامج المكتوبة بلغة سي القديمة دون أي أخطاء، شرط ألا يحتوي البرنامج طبعًا على أخطاء. يُعد استخدام عدة متغيرات على أنها وسطاء عند استخدام الدالة ميزةً أخرى مفيدة مثل استخدام الدالة printf التي اعتاد استخدامها أن يكون غير قابل للنقل، وكانت الطريقة الوحيدة التي يمكن استخدامها لتصبح قابلة للنقل هي بالاعتماد على معرفة عميقة بالعتاد الصلب. أخذت لغة سي المعيارية الحل لهذه المشاكل من لغة ++C، إذ سبق لها وطبّقت هذه الأفكار بنجاح، كما تبنّت العديد من مصرّفات لغة سي القديمة هذه الحلول من C المعيارية نظرًا لنجاحها. ستظل لغة سي المعيارية متوافقةً مع طريقة تصريح الدوال في سي القديمة بهدف الإبقاء على صحة عمل البرامج السابقة فحسب، ويجب على أي برنامج يُكتب من جديد استخدام هذه الطريقة الجديدة الأكثر صرامةً التي قدمتها سي المعيارية وتفادي طريقة لغة سي القديمة بشدة، والتي ستندثر في المستقبل على الأرجح. أنواع الدوال تمتلك جميع الدوال نوعًا ما، والذي يكون هو نوع القيمة التي تُعيدها عند استخدامها. السبب في عدم احتواء لغة سي على "إجراءات procedures"، والتي هي في معظم اللغات دوال بدون قيمة، هو أنها تسمح بصورةٍ إجبارية في بعض الأحيان بتجاهل القيمة النهائية لمعظم التعابير، وإن فاجئك ذلك تذكر تعبير الإسناد التالي: a = 1; الإسناد السابق صالح ويعيد قيمةً ما، لكن القيمة تُهمل. إذا أردت مفاجأةُ أكبر من السابقة، جرِّب التعبير التالي: 1; إذ إنه تعبيرٌ متبوعٌ بفاصلةٍ منقوطة، وهذه تعليمةٌ صالحةٌ وفق قواعد اللغة ولا يوجد أي خطأ فيها، ولكنها عديمة الفائدة. يمكنك التفكير بخصوص الدالة التي تُستخدم مثل إجراء بنفس الطريقة، إذ إنها تُعيد قيمةً دائمًا لكنها لا تُستخدم: f(argument); التعبير السابق هو تعبير ذو قيمةٍ مُهملة. من السهل فهم نقطة أن القيمة المُعادة من الدالة يمكن إهمالها، لكن هذا يعني أن عدم استخدام القيمة المُعادة هو خطأ برمجي، وعلى العكس تمامًا إن لم يكن هناك أي قيمة مفيدة مُعادة من الدالة، إذًا من الأفضل أن يكون لدينا القدرة على مراقبة فيما إذا كانت القيمة مُستخدمةً عن طريق الخطأ، وللسببين السابقين، يجب التصريح عن أي دالة بكونها لا تعيد أي قيمة مفيدة بالنوع void. يمكن أن تُعيد الدوال أي نوع مدعوم من لغة سي C عدا المصفوفات arrays والدوال بحد ذاتها، وهذا يتضمن المؤشرات pointers والبُنى structures والاتحادات unions، وسنتكلم عنهم لاحقًا. يمكننا التحايل على الأنواع التي لا يُمكن إعادتها من الدوال باستخدام المؤشرات بدلًا منها، كما يمكن استدعاء جميع الدوال تعاوديًّا recursively. التصريح عن الدوال علينا الآن للأسف تقديم بعض المصطلحات بهدف التقليل من النص الوصفي المتكرر بعد ذكر كل مصطلح برمجي للوصول إلى نتيجة أقصر وأكثر دقة دون أي تشويش للقارئ، إليك المصطلحات: التصريح declaration: نذكر فيه النوع type الذي يرتبط باسم ما. التعريف definition: يماثل التصريح، لكنه يحجز أيضًا مساحة تخزينية للكائن المذكور، وقد تكون القواعد التي تفصل بين التصريح والتعريف معقدة، لكن الأمر بسيط بالنسبة للدوال؛ إذ يصبح التصريح تعريفًا عندما يُضاف محتوى الدالة على أنه تعليمةٌ مُركّبة compound statement. المُعاملات parameters والمعاملات الصوريّة formal parameters: الأسماء التي تُشير إلى الوسطاء بداخل الدالة. الوسطاء arguments والوسطاء الفعلية actual arguments: القيم المُستخدمة مثل وسطاء في دالة ما، أي قيم المُعاملات الصوريّة عند تنفيذ الدالة. يُستخدم المصطلحان "مُعامل" و"وسيط" على نحوٍ تبادلي، لذا لا تتساءل عن سبب استخدامنا لمصطلح عن الآخر في الفقرات القادمة. تُصرّح الدالة ضمنيًا على أنها "تُعيد قيمة من نوع int"، إذا استخدمتها قبل التصريح عنها، ولكن تعد هذه من الممارسات الخاطئة في لغة سي المعيارية، على الرغم من استخدام هذه الطريقة على نحوٍ واسع في لغة سي القديمة؛ إذ يؤدي استخدام الدوال دون التصريح عنها إلى مشاكل معقدة مرتبطة بعدد ونوع الوسطاء المُتوقّعة، ويجب أن يُصرّح عن الدوال بصورةٍ كاملة قبل استخدامها. على سبيل المثال، إذا أردت استخدام دالة موجودة في مكتبة خاصة، لا تأخذ أي وسطاء، وتعيد القيمة double، وتسمى aax1، فعليك التصريح عنها كما يلي: double aax1(void); وإليك مثالًا عن استخدامها الخاطئ: main(){ double return_v, aax1(void); return_v = aax1(); exit(EXIT_SUCCESS); } [مثال 1] التصريح في المثال السابق مثير للاهتمام، إذ عرّفنا return_v مما تسبب بإنشاء متغيرٍ جديد، كما صرّحنا عن aax1 دون تعريفها، إذ أن الدوال تُعرّف فقط في حالة وجود متن الدالة، كما ذكرنا سابقًا، وفي هذه الحالة يُفترض أن تُعيد الدالة aax1 النوع int ضمنيًّا مع أنها تعيد النوع double، مما يعني أن ذلك سيتسبب بتصرف غير محدد، وهو أمر كارثي دائمًا. يوضِّح وجود النوع void ضمن لائحة الوسطاء عند التصريح بأن الدالة لا تقبل أي وسيط، وإن كانت مفقودةً من لائحة الوسطاء فلن يترك التصريح أي معلومات عن وسطاء الدالة، وبهذه الطريقة نحافظ على التوافقية مع لغة سي C القديمة على حساب قدرة المصرّف على التحقق. ينبغي كتابة متن للدالة مثل تعليمةٍ مركّبة حتى تعرّفها، إذ لا يمكن لتعريف دالةٍ ما أن يكون محتوًى بتعريف دالةٍ أخرى. ونتيجةً لذلك، جميع الدوال مستقلةٌ عن بعضها بعضًا وموجودةٌ في المستوى الخارجي لهيكل البرنامج. يوضح التعريف التالي طريقةً ممكنةً للتعريف عن الدالة aax1: double aax1(void) { /*متن الدالة هنا*/ return (1.0); } من غير الاعتيادي أن تمنعك لغةٌ تعتمد على الهيكلية الكُتلية عن تعريف الدوال داخل دوالٍ أخرى، ولكن هذه سمةٌ من سمات لغة سي C، ويساعد ذلك على تحسين الأداء وقت التنفيذ run-time للغة سي، لأنه يقلل المهام المطلوبة المتعلقة بتنظيم استدعاء الدوال. تعليمة الإعادة return تُعد تعليمة return مهمةً للغاية، إذ تستخدمها جميع الدوال -عدا التي تُعيد void- مرةً واحدةً على الأقل، وتوضِّح التعليمة return عند ذكرها القيمة التي يجب أن تُعيدها. من الممكن أن نعيد قيمةً من دالةٍ ما عن طريق وضع return في نهاية الدالة قبل القوس المعقوص الأخير "{"؛ إلا أن هذا الأمر سيتسبب بتصرف غير محدد عند استخدامها في دالة تُعيد void، إذ ستُعاد قيمةٌ غير معروفة. إليك مثالًا عن دالة أخرى تستخدم getchar لقراءة المحارف من دخل البرنامج ومن ثمّ تعيدها باستثناء المسافة space ومسافة الجدولة tab والأسطر الجديدة newline. #include <stdio.h> int non_space(void){ int c; while ( (c=getchar ())=='\t' || c== '\n' || c==' ') ; /*تعليمة فارغة*/ return (c); } لاحظ عملية التحقق من المحارف عن طريق تعليمة while، والتي لا تحتوي على أي تعليمة في متنها، إذ أن وجود فاصلة منقوطة لوحدها ليست نادرة الحدوث وإنما هي شائعة الاستخدام، وعادةً ما تُصحب بتعليق بسيط لمواساة وحدتها، لكن رجاءً ثمّ رجاءً لا تكتبها على النحو التالي: while (something); فمن السهل ألّا تلاحظ الفاصلة المنقوطة في نهاية السطر عند قراءة البرنامج، وتفترض أن التعليمات أسفلها تتبع لتعليمة while. يجب أن يكافئ نوع التعبير المُعاد نوع الدالة ضمن تعليمة return، أو على الأقل أن يكون بالإمكان تحويله ضمن تعليمة إسناد. على سبيل المثال، يمكن أن تحتوي دالة مُصرح عنها أنها تُعيد النوع double التعليمة: return (1); سيحوَّل بذلك العدد الصحيح إلى نوع double، ومن الممكن أيضًا كتابة return دون أي تعبير مصاحب لها، لكن ذلك سيتسبب بخطأ برمجي إن استخدمت هذه الطريقة ما لم تُعيد الدالة النوع void. من غير المسموح إلحاق تعبير بتعليمة return إذا كانت الدالة تعيد النوع void. وسطاء الدوال لم يكن بالإمكان قبل مجيء لغة سي C المعيارية إضافة أي معلومات عن وسطاء الدالة عدا داخل تعريف الدالة نفسها، وكانت هذه المعلومات تُستخدم داخل متن الدالة فقط وتُنسى في نهاية المطاف. كان من الممكن -في تلك الأيام القديمة البائسة- تعريف دالةٌ بثلاث وسطاء من نوع double وتمرير وسيط من نوع int لها عند استدعائها، وسيُصرِّف البرنامج بصورةٍ طبيعية دون إظهار أي أخطاء ولكنه لن يعمل بالنحو الصحيح، إذ كان من واجب المبرمج التحقق من صحة عدد وأنواع الوسطاء للدالة. كما ستتوقع، كان هذا المسبب الأساسي لكثيرٍ من الأخطاء الأولية في البرنامج ومشكلات قابلية التنقل. إليك مثالًا عن تعريف دالة واستخدامها مع وسطائها لكن دون التصريح عن الدالة كاملًا. #include <stdio.h> #include <stdlib.h> main(){ void pmax(); /* التصريح */ int i,j; for(i = -10; i <= 10; i++){ for(j = -10; j <= 10; j++){ pmax(i,j); } } exit(EXIT_SUCCESS); } /* * Function pmax. * Returns: void * Prints larger of its two arguments. */ void pmax(int a1, int a2){ /* التعريف*/ int biggest; if(a1 > a2){ biggest = a1; }else{ biggest = a2; } printf("larger of %d and %d is %d\n", a1, a2, biggest); } [مثال 2] ما الذي يمكنك تعلُّمه من المثال السابق؟ بدايةً، لاحظ بحذر أن التصريح هو للدالة pmax التي تُعيد void، إذ يقع النوع void الموافق للدالة عند تعريفها السطر الذي يسبق اسمها، وهذه الطريقة في الكتابة أسلوبٌ وتحبيذٌ شخصي، إذ من السهل إيجاد التصريح عن الدالة إذا كان اسم الدالة يقع في بداية السطر. لا يشير التصريح عن الدالة في main إلى وجود أي وسطاء لها، إلا أن استخدام الدالة بعد عدة أسطر يدل على استخدام وسيطين، وهذا مسموح في كلٍّ من لغة سي المعيارية وسي C القديمة ولكنه يُعد ممارسةً برمجيةً سيئة، فمن الأفضل تضمين معلومات عن الوسطاء في التصريح عن الدالة كما سنرى لاحقًا. هذا الأسلوب القديم في الكتابة هو ميزةٌ عفا عليها الزمن ومن الممكن أن تختفي في إصدارات سي المعيارية القادمة. دعنا ننتقل الآن إلى تعريف الدالة حيث يقع متنها، ولاحظ أنه يدل على أن الدالة تأخذ وسيطين باسم a1 وa2، كما أن نوع الوسطاء محدد بالنوع int. لا يتوجب عليك تحديد نوع كلّ الوسطاء في هذه الحالة لأن النوع سيكون int افتراضيًا، ولكن هذه ممارسة سيئة، إذ يجب عليك الاعتياد على تحديد نوع الوسطاء في كل مرة حتى لو كانت من نوع int، لأن ذلك يسهل عملية قراءة شيفرة البرنامج ويشير إلى أنك تتعمد استخدام النوع int ولم يحصل ذلك عن طريق الخطأ بنسيانك لتحديد نوع الوسيط. يمكن تعريف الدالة pmax بهذه الطريقة ولكنها ممارسة سيئة كما ذكرنا سابقًا: /* مثال سيء على التصريح عن الدالة */ void pmax(a1, a2){ /* and so on */ الطريقة المثالية للتصريح والتعريف عن الدوال هي باستخدام ما يُدعى النماذج الأولية prototypes. نماذج الدوال الأولية كان تقديم نماذج الدوال الأولية function prototypes من أكبر التغييرات في لغة سي C المعيارية؛ إذ أن نموذج الدالة الأولية هو تصريح أو تعريف يتضمن معلومات عن عدد وأنواع الوسطاء التي تستخدمها الدالة. على الرغم من إمكانية إهمال تحديد أي معلومات بخصوص وسطاء الدالة عند التصريح عنها، إلا أن ذلك يحدث بهدف التوافقية مع لغة سي القديمة فقط، وينبغي تجنُّبه، ولا يعدّ التصريح دون أي معلومات عن وسطاء الدالة نموذجًا أوّليًّا. إليك المثال السابق مكتوبًا "بطريقة صحيحة": #include <stdio.h> #include <stdlib.h> main(){ void pmax(int first, int second); /*التصريح*/ int i,j; for(i = -10; i <= 10; i++){ for(j = -10; j <= 10; j++){ pmax(i,j); } } exit(EXIT_SUCCESS); } void pmax(int a1, int a2){ /*التعريف*/ int biggest; if(a1 > a2){ biggest = a1; } else{ biggest = a2; } printf("largest of %d and %d is %d\n", a1, a2, biggest); } [مثال 3] احتوى التصريح هذه المرة على معلومات بخصوص وسطاء الدالة، لذا يصنّف على أنه نموذج أوّلي. لا يُعد الاسمان first و second جزءًا ضروريًا من التصريح، لكنهما موجودان لتصبح عملية الإشارة إلى الوسطاء عند توثيق عمل الدالة عمليّةً أسهل، إذ نستطيع وصف عمل الدالة ببساطة عن طريق استخدامهما عن طريق التصريح التالي: void pmax (int xx, int yy ); وهنا نستطيع القول أن الدالة pmax تطبع القيمة الأكبر ضمن الوسيطين xx و yy بدلًا عن الإشارة إلى الوسطاء بتموضعها، أي الوسيط الثاني واﻷول وهكذا، لأنها طريقةٌ معرضةٌ لسوء الفهم أو الخطأ في عدّ الترتيب. عدا عن ذلك، تستطيع التخلص من أسماء الوسطاء في تصريح الدالة ويكون التصريح التالي مساويًا للتصريح السابق: void pmax (int,int); الفرق بين التصريحين هو فقط أسماء الوسطاء. يكون التصريح عن دالة لا تأخذ أي وسطاء على النحو التالي: void f_name (void); وللتصريح عن دالة تأخذ وسيطًا من نوع int وآخرًا من نوع double وعددًا غير محدّد من الوسطاء الآخرين، نكتب: void f_name (int,double,...); توضّح هنا النقاط الثلاث ... أن هناك المزيد من الوسطاء، وهذا مفيدٌ في حال كانت الدالة تسمح بوجود عددٍ غير محدد من الوسطاء، مثل دالة printf، إذ أن تصريح الدالة هذه يكون على النحو التالي: int printf (const char *format_string,...) الوسيط الأول هو "مؤشر pointer للقيمة من النوع const char"، وسنناقش معنى ذلك لاحقًا. يتحقق المصرّف من استخدام الدالة بما يتوافق مع تصريحها وذلك حالما يُعلَم بأنواع وسطاء الدالة أثناء قراءتهم من النموذج الأولي للدالة، وتحوّل قيمة الوسيط إلى النوع الصحيح حسب النموذج الأولي في حال استُدعيت الدالة باستخدام نوع وسيطٍ مغاير "بصورةٍ مشابهة للتحويل الحاصل عند عملية الإسناد". إليك مثالًا توضيحيًّا: دالةٌ تحسب الجذر التربيعي لقيمةٍ ما باستخدام طريقة نيوتن للتقريبات المتعاقبة Newton's method of successive approximations. #include <stdio.h> #include <stdlib.h> #define DELTA 0.0001 main(){ double sq_root(double); /* النموذج الأولي*/ int i; for(i = 1; i < 100; i++){ printf("root of %d is %f\n", i, sq_root(i)); } exit(EXIT_SUCCESS); } double sq_root(double x){ /* التعريف*/ double curr_appx, last_appx, diff; last_appx = x; diff = DELTA+1; while(diff > DELTA){ curr_appx = 0.5*(last_appx + x/last_appx); diff = curr_appx - last_appx; if(diff < 0) diff = -diff; last_appx = curr_appx; } return(curr_appx); } [مثال 4] يوضّح النموذج الأولي للدالة أن sq_root تأخذ وسيطًا واحدًا من نوع double، وفي حقيقة الأمر، تُمرّر قيمة الوسيط ضمن الدالة main بنوع int لذا يجب تحويلها إلى double أوّلًا؛ لكن يجدر الانتباه هنا إلى أن سي ستفترض أن المبرمج تقصَّد تمرير قيمة int، إذا لم يكُن هناك أي نموذج أولي وفي هذه الحالة ستُعامَل القيمة على أنها int دون تحويل. يشير المعيار ببساطة إلى أن هذا سيتسبب بسلوك غير محدّد، إلا أن ذلك الوصف يقلل من خطورة الخطأ تمامًا مثل القول أن الإصابة بمرض قاتل أمرٌ مؤسفٌ فقط، إذ أن هذا الخطأ خطير جدًا وتسبب سابقًا في برامج سي القديمة بالكثير والكثير من المشكلات. السبب في التحويل من int إلى double في هذه الحالة هو بسبب رؤية المصرّف للنموذج الأولي مما دلّه على ما يجب فعله، وكما توقعت، هناك العديد من القواعد المستخدمة لتحديد التحويل المناسب في كل حالة، وسنتكلم عنها. تحويلات الوسطاء تُجرى عدة تحويلات عند استدعاء دالةٍ ما حسب كل حالة وفقًا لقيم الوسطاء وحسب وجود أو عدم وجود النموذج الأولي، ولا بُدّ أن نوضّح قبل أن نبدأ أنه من الممكن لك استخدام هذه القوانين لمعرفة قيم الوسطاء الناتجة دون استخدام نموذج أولي، ولكن هذه وصفةٌ لكارثة تُطهى على نار هادئة، ولا يوجد أي عذر لعدم استخدام النماذج الأولية فهي سهلة الاستخدام؛ لذا استخدم هذه القواعد فقط في الدوال ذات عدد الوسطاء المتغيّر باستخدام علامة الاختصار Ellipsis "…" كما سنشرح لاحقًا. تتضمن هذه القواعد ترقيات الوسطاء الافتراضية default argument promotions والأنواع المتوافقة compatible types، وفيما يخص ترقية الوسطاء الافتراضية، فهي: تُطبَّق الترقية العددية الصحيحة على كل قيمة وسيط. يُحوَّل الوسيط إلى نوع double إذا كان نوعه float. أبرزَ ظهور النماذج الأولية -إضافةً إلى أشياء أخرى- الحاجة للدقة بخصوص "الأنواع المتوافقة"، التي لم تكن مشكلةً في سي القديمة. سنستعرض لائحة قوانين الأنواع المتوافقة كاملةً لاحقًا، لأننا نعتقد أن معظم مبرمجي لغة سي لن يكونوا محتاجين لتعلمها كاملةً، وعوضًا عن ذلك سنكتفي في الوقت الحالي بمعرفة أن الأنواع المتماثلة متوافقة فيما بينها. تُطبّق التحويلات بالاعتماد على القوانين التالية (ليست اقتباسًا مباشرًا من المعيار، بل ستدلك على كيفية تطبيق قوانين سي المعيارية): أولًا، تُرقّى وسطاء الدالة وفق ترقية الوسطاء الاعتيادية، إذا لم يكن هناك أي نموذج أولي يسبق نقطة استدعاء الدالة، وذلك وفق التفاصيل: نحصل على سلوكٍ غير محدد إذا كان عدد الوسطاء المزوَّد لا يكافئ عدد الوسطاء الفعلي للدالة. يجب أن تكون أنواع الوسطاء المزوّدة للدالة متوافقة مع أنواع الوسطاء الفعلية وفق تعريف الدالة بعد تطبيق الترقية عليهم وذلك إذا لم يكن لتعريف الدالة نموذجٌ أولي، ونحصل على سلوك غير محدد فيما عدا ذلك. نحصل على سلوك غير محدد إذا لم تحتوي الدالة على نموذج أولي في تعريفها وكانت أنواع الوسطاء المزوّدة غير متوافقة مع أنواع الوسطاء الفعلية، كما يكون السلوك غير محدد أيضًا إذا تضمّن النموذج الأولي للدالة علامة الاختصار "…". ثانيًا، تُحوّل الوسطاء إلى الأنواع المُسندة إلى كلٍّ منها وفقًا للنموذج الأولي، وبصورةٍ مشابهة للتحويل الذي يحصل عند الإسناد، وذلك إذا كان النموذج الأولي ضمن النطاق scope عند استدعاء الدالة، ويشمل ذلك جميع المتغيرات في لائحة الوسطاء بما فيها المتغيرات المُشار إليها بعلامة الاختصار "…". من الممكن كتابة برنامج يحتوي على نموذج أولي ضمن النطاق عند استدعاء الدالة لكن دون وجود نموذج أولي داخل تعريف الدالة، وهذا طبعًا أسلوبٌ سيءٌ جدًا، وفي هذه الحالة يجب على نوع الدالة المُستدعاة أن يكون متوافقًا مع النوع المُستخدم عند استدعاء هذه الدالة. لا يحدّد المعيار صراحةً ترتيب تقييم وسطاء الدالة عند استدعائها. تعريف الدوال تسمح النماذج الأولية للدوال باستخدام النص ذاته للتصريح عن الدالة والتعريف عنها. لتحويل تصريح الدالة التالي إلى تعريف: double some_func(int a1, float a2, long double a3); نضيف متنًا إلى الدالة: double some_func(int a1, float a2, long double a3){ /* متن الدالة */ return(1.0); } وذلك باستبدال الفاصلة المنقوطة في نهاية التصريح بتعليمة مركّبة. يعمل تعريف الدالة أو التصريح عنها مثل نموذج أولي شرط تحديد أنواع المُعاملات parameters، ويُعدّ المثالين السابقين نموذجين أوليين. ما تزال لغة C المعيارية تدعم طريقة سي القديمة في التصريح عن دالة باستخدام وسائطها، ولكن يجب تجنُّب استخدامها. يمكننا التصريح عن الدالة بالطريقة المذكورة على النحو التالي: double some_func(a1, a2, a3) int a1; float a2; long double a3; { /* متن الدالة */ return(1.0); } لا يمثّل التعريف السابق نموذجًا أوليًا، لعدم وجود أي معلومات بخصوص المُعاملات عند تسميتها، ويقدِّم التعريف السابق معلومات حول النوع الذي تُعيده الدالة، وبهذا لا يتذكر المصرّف Compiler أي معلومات تخص أنواع الوسطاء بنهاية التعريف. يحذِّر المعيار بخصوص هذه الطريقة بقوله أنها ستختفي غالبًأ في إصدارات قادمة، ولذلك لن نذكرها مرةً أخرى. دعنا نلخّص ما تكلمنا عنه سابقًا بإيجاز: يمكن استدعاء الدوال على نحوٍ تعاودي. يمكن للدوال إعادة أي قيمة تصرح عنها عدا المصفوفات والدوال (إلا أنه يمكنك التحايل على هذا القيد باستخدام المؤشرات)، ويجب أن تكون الدوال من النوع void إذا لم تُعد أي قيمة. استخدم نماذج الدوال الأولية دائمًا. نحصل على سلوك غير محدد، إذا استُدعيت دالة أو تعريفها إلا إذا: كان النموذج الأولي دائمًا ضمن النطاق في كل مرة تُستدعى فيها الدالة أو تُعرَّف. كنت حريصًا جداً بهذا الخصوص. تُحوّل قيم الوسطاء عند استدعاء الدالة إلى أنواع المُعاملات الفعلية للدالة (المعرّفة وفقها)، بصورةٍ مشابهة للتحويل عند عملية الإسناد باستخدام العامل operator "="، وذلك بفرض أنك تستخدم نموذجًا أوّليًّا. يجب أن يشير النموذج الأولي إلى النوع void، إذا لم تأخذ الدالة أي وسطاء. يجب تحديد اسم وسيط واحد على الأقل في دالة تقبل عددًا متغيرًا من الوسطاء، ومن ثم الإشارة إلى العدد المتغير من الوسطاء بالعلامة "…"، كما هو موضح: int vfunc(int x, float y, ...); سنناقش لاحقًا استخدام هذا النوع من الدوال. التعليمات المركبة والتصريحات يتألف متن الدالة من تعليمة مركبة Compound statement، ومن الممكن التصريح عن متغيرات جديدة داخل هذه التعليمة المركبة. تغطّي أسماء المتغيرات الجديدة على أسماء المتغيرات الموجودة مسبقًا، إذا تشابهت أسماؤهم ضمن التعليمة المركبة، وهذا مماثلٌ لأي لغة تعتمد تنسيقً كتليًا مشابهًا للغة سي. تقيد لغة سي C التصريحات لتكون ضمن بداية التعليمة المركبة أو "الكتلة البرمجية"، ويُمنع استخدام التصريحات داخل الكتلة حالما يُكتب أي نوع من التعليمات statements داخلها. كيف يمكن التغطية على أسماء المتغيرات؟ يوضح المثال التالي ما نقصد بذلك: int a; /* يمكن رؤيته من هذه النقطة فصاعدًا */ void func(void){ float a; /* مختلف a يمثّل متغير*/ { char a; /* مختلف أيضًا a متغير */ } /* يمكن رؤية المتغير ذو النوع قيمة حقيقية */ } /* يمكن رؤية المتغير ذو النوع قيمة صحيحة */ [مثال 5] عند التصريح عن اسم ما داخل كتلة فهذا يتسبب بإهمال أي اسم مشابه خارج الكتلة حتى الوصول لنهايتها، كما يمكنك التصريح عن الاسم ذاته في كتلة داخلية، وتكرار هذه العملية إلى ما لانهاية. نطاق Scope الاسم هو المجال الذي يكون فيه لهذا الاسم معنًى، ويبدأ نطاق الاسم من نقطة ذكر الاسم إلى نهاية الكتلة التي ذُكر فيها، ويستمر إلى نهاية الملف إذا كان الاسم خارجي External (خارج أي دالة)، ويختفي في نهاية الدالة إذا كان الاسم داخلي Internal (داخل دالة)، ويمكن إعادة تعيين النطاق عند إعادة التصريح عن الاسم داخل الكتلة ذاتها. يمكنك تنفيذ حيل طريفة مثل المثال التالي باستخدام قوانين النطاق: main () {} int i; f () {} f2 () {} يمكن للدالتين f و f2 استخدام المتغير i، لكن main لا تستطيع لأن التصريح عن الدالة أتى بعد الدالة main، ولا تُستخدم كثيرًا هذه الطريقة بالضرورة ولكنها تستفيد من طريقة لغة سي C الضمنية في معالجة التصريحات. قد تتسبب هذه الطريقة ببعض من الحيرة لمن يقرأ ملف الشيفرة البرمجية، ويجب تجنُّبها عن طريق التصريح عن المتغيرات الخارجية قبل تعريف أي دالة في الملف. غيّرت لغة سي C المعيارية بعض الأمور بخصوص معاملات الدالة الفعلية، إذ افتُرض تصريحها داخل التعليمة المركبة الأولى حتى لو لم تكن هذه الحالة محققة فعلًا كتابيًّا، وهذا ينطبق على الطريقة القديمة والجديدة في التعريف عن الدالة. بناءً على ما سبق، نحصل على خطأ إذا كان اسم معاملات الدالة الفعلية مطابقًا لاسمٍ قد صُرِّح عنه في التعليمة المركّبة الخارجية. كان خطأ إعادة التعريف غير المقصود في لغة سي C القديمة خطأً صعب التتبع والحل، إليك ما قد يبدو عليه الخطأ: /* إعادة تصريح خاطئة للوسطاء */ func(a, b, c){ int a; /* AAAAgh! */ } الجزء المسبب للمتاعب هنا هو التصريح الجديد للمتغير a في متن الدالة، الذي سيغطّي على المعامل a، ولن نتكلم بالمزيد عن هذه المشكلة بما أنها غير ممكنة الحدوث بعد الآن. ترجمة -وبتصرف- لقسم من الفصل Functions من كتاب The C Book. اقرأ أيضًا المقال التالي: مفهوم التعاود Recursion وتمرير الوسطاء إلى الدوال في لغة سي C المقال السابق: العوامل المنطقية في لغة سي C وعوامل أخرى البنية النصية لبرامج سي C العوامل في لغة سي C

تحدثنا في المقال السابق عن حكم بالتدفق في برنامج C والتعبيرات المنطقية وسنكمل الحديث حول العوامل المنطقية في لغة سي C والعوامل الأخرى فيها. العوامل المنطقية وضحنا سابقًا كيف أن لغة سي C لا تميّز بين القيم "المنطقية" والقيم الأخرى، إذ تعطي المُعاملات العلاقيّة relational operators نتيجة متمثلةً بالقيمة 0 للخطأ، أو 1 للصواب. وتُقيّم قيمة تعبير منطقي لتحديد ما إذا كانت تعليمة تحكم بتدفق البرنامج ستنفّذ أم لا، إذ تعني القيمة 0 "لا تنفِّذ" وأي قيمة أخرى تعني "نفِّذ". تُعد جميع الأمثلة التالية تعابير منطقية صالحة: while (a<b)... while (a).... if ( (c=getchar()) != EOF )... لن يتفاجأ أي مبرمج لغة سي متمرس بأي تعبير من التعابير السابقة، إذ يمثّل التعبير الثاني (while (a اختصارًا شائعًا للتعبير (while (a != 0 (على الأغلب استنتجت معناه ضمنيًّا). نحتاج الآن إلى طريقةٍ تمكِّننا من كتابة تعابير أكثر تعقيدًا باستخدام هذه القيم المنطقية "خطأ وصواب"، إذ استخدمنا حتى الآن الطريقة التالية لكتابة التعبير الذي يعطينا (if(a<b AND c<d، إلا أن هناك طريقةٌ أخرى لكتابة التعليمة. if (a < b){ if (c < d)... } هناك ثلاثة عوامل مشاركة في هذا النوع من العمليات، هي: العامل المنطقي AND أو "&&" والعامل المنطقي OR أو "||" والعامل NOT أو "!"، إذ يُعد العامل الأخير عاملًا أحاديًا، أما العاملان الآخران فهما ثنائيان. تستخدِم هذه العوامل تعابيرًا مثل مُعاملات وتعطي نتيجةً مساويةً إلى "1" أو "0"؛ إذ يعطي العامل "&&" القيمة "1" فقط في حال كانت قيمة المُعاملان غير صفرية؛ ويعطي "||" القيمة "0" فقط في حال كانت قيمة المُعاملان صفر؛ بينما يعطي "!" القيمة صفر إذا كانت قيمة المُعامل غير صفرية وبالعكس، فالأمر بسيطٌ للغاية، وتكون نتيجة العوامل الثلاث من النوع "int". لا تخلط عوامل العمليات الثنائية bitwise operators "|" و"&" مع عواملها المنطقية المشابهة، فهي مختلفةٌ عن بعضها البعض؛ إذ أن للعوامل المنطقية ميزةٌ لا نجدها في العوامل الأخرى، ألا وهي تأثيرها على عملية تقييم التعبير، إذ تُقيّم من اليسار إلى اليمين بعد أخذ الأسبقية في الحسبان، ويتوقف أي تعبير منطقي عن عملية التقييم عند التوصُّل إلى قيمة التعبير النهائية. على سبيل المثال، تتوقف سلسلة من عوامل "||" عن التقييم حالما تجد مُعاملًا ذا قيمةٍ غير صفرية. يوضِّح المثالين التاليين تعبيرين منطقيين يمنعان القسمة على صفر. if (a!=0 && b/a > 5)... /* alternative */ if (a && b/a > 5) ستُقيَّم قيمة b/a في كلا الحالتين فقط في حالة كون قيمة a غير صفرية؛ وفي حال كانت a مساويةً الصفر، ستُقيّم قيمة التعبير فورًا، وبذلك ستتوقف عملية تقييم التعبير وفق قوانين لغة سي C للعوامل المنطقية. عامل النفي الأحادي NOT بسيط، لكن استخدامه غير شائع جدًا نظرًا لإمكانية كتابة معظم التعبيرات دون استخدامه، كما توضح الأمثلة التالية: if (!a)... /* alternative */ if (a==0)... if(!(a>b)) /* alternative */ if(a <= b) if (!(a>b && c<d))... /* alternative */ if (a<=b || c>=d)... توضح الأمثلة السابقة مع بدائلها طريقةً لتجنُّب أو على الأقل الاستغناء عن استخدام العامل !. في الحقيقة، يُستخدم هذا العامل بهدف تسهيل قراءة التعبير، فإذا كانت المشكلة التي تحلّها تستخدم علاقة منطقية مثل العلاقة "b*b-4*a*c) > 0)" الموجودة في حل المعادلات التربيعية، فمن الأفضل كتابتها بالطريقة: ( !((b*b-4*a*c) > 0)) بدلًا من كتابتها بالطريقة: if( (b*b-4*a*c) <= 0) لكن التعبيران يؤديان الغرض ذاته، فاختر الطريقة التي تناسبك. تعمل معظم التعابير التي تستخدم العوامل المنطقية وفق قوانين الأسبقية الاعتيادية، لكن الأمر لا يخلو من بعض المفاجآت، فإذا أخذت نظرةً أخرى على جدول الأسبقية، فستجد أن هناك بعض العوامل في مستوى أسبقية أقل موازنةً بالعوامل المنطقية، ويسبب ذلك خطأ شائعًا: if(a&b == c){... إذ تُوازَن b بالمساواة مع c أولًا في هذه الحالة، ومن ثم تُضاف القيمة إلى a سواءٌ كانت 0 أو 1، مما يتسبب بسلوك غير متوقع للبرنامج بسبب هذا الخطأ. عوامل غريبة تبقَّى عاملان لم نتكلم عنهما بعد، ويتميزان بشكلهما الغريب، إذ لا تُعد هذه العوامل "أساسية"، لكنها تُستخدم من حينٍ إلى آخر، فلا تتجاهلهما كليًّا، وستكون هذه الفقرة الوحيدة التي سنتكلم فيها عنهما، إذ سيتضمن الشرح سلوكهما عند مزجهما مع أنواع المؤشر، مما يوحي أنهما معقدَين أكثر من اللازم. عامل الشرط :? كما هو الحال في عزف آلة الأكورديون، سيكون من الأسهل النظر إلى كيفية عمل هذا العامل بدلًا من وصفه. expression1?expression2:expression3 إذا كان التعبير expression1 صحيحًا، فهذا يعني أن قيمة التعبير بالكامل هي من قيمة التعبير expression2، وإلا فهي قيمة التعبير expression3، إذ ستُقيَّم قيمة واحدٍ من التعبيرين حسب قيمة التعبير expression1. تُعد أنواع البيانات المختلفة المسموح استخدامها في التعبير expression2 و expression3 والأنواع الناتجة عن التعبير بالكامل معقدة، والسبب في هذا التعقيد هو بعض الأنواع والمفاهيم التي لم نشرحها بعد. سنشرح هذه النقاط في الأسفل، لكن كن صبورًا بخصوص بعض المفاهيم التي سنشرحها لاحقًا. أبسط حالة ممكنة هي حالة تعبير بأنواع حسابية (أعداد صحيحة أو حقيقية)، إذ تُطبَّق في هذه الحالة التحويلات الحسابية لإيجاد نوع مشترك لكلا التعبيرين، وهو نوع النتيجة. لنأخذ المثال التالي: a>b?1:3.5 يحتوي المثال الثابت 1 من النوع int والثابت 3.5 من النوع double، وبتطبيق قوانين التحويل الحسابية نحصل على نتيجة النوع double. هناك بعض الحالات المسموحة أيضًا، هي: إذا كان المُعاملان من نوع ذا هيكلية structure أو اتحاد union متوافق، فالنتيجة هي من هذا النوع. إذا كان المُعاملان من نوع "void"، فالنتيجة هي من هذا النوع. ويمكن مزج عدة أنواع مؤشرات على النحو التالي: يمكن للمُعاملين أن يكونا من أنواع مؤشرات متوافقة (من المحتمل أن تكون مُؤهلة qualified). يمكن لمُعامل أن يكون مؤشرًا والمُعامل الآخر مؤشر ثابت فارغ Null pointer constant. يمكن لمُعامل أن يكون مؤشرًا لكائن pointer to an object أو نوع غير مكتمل incomplete type والمُعامل الآخر مؤشر إلى نوع "void" (من المحتمل أن يكون مُؤهل). لمعرفة النوع الناتج عن التعبير عند استخدام المؤشرات نتبع الخطوتين: إذا كان أيٌ من المُعاملَين مؤشرًا إلى نوع قيمة مؤهلة، فستكون النتيجة مؤشرًا إلى نوع مؤهل من جميع المؤهِّلات في كلا المُعاملين. إذا كان أحد المُعاملات مؤشر ثابت فارغ، فستكون النتيجة هي نوع المُعامل الآخر؛ فإذا كان أحد المُعاملات يؤشر إلى الفراغ، سيُحوَّل المُعامل الآخر إلى مؤشر إلى "void" وسيكون هذا نوع النتيجة؛ أما إذا كان كلا المُعاملات مؤشرات من أنواع متوافقة (بتجاهل أي مؤهلات) فالنوع الناتج هو من نوع مركب composite type. سنناقش كلًا من المؤهّلات والأنواع المركبة والمتوافقة في المقالات القادمة. نلاحظ استخدام هذا العامل في المثال البسيط أدناه، الذي يختار السلسلة النصية لطباعتها باستخدام الدالة printf: #include <stdio.h> #include <stdlib.h> main(){ int i; for(i=0; i <= 10; i++){ printf((i&1) ? "odd\n" : "even\n"); } exit(EXIT_SUCCESS); } [مثال 10.3] يُعد هذا العامل جيدًا عندما تحتاجه، مع أن بعض الناس يشعرون بالغرابة عندما يرونه للمرة الأولى إلا أنهم سرعان ما يبدأون باستخدامه. بعد الانتهاء من تقييم قيمة المُعامل الأول، هناك مرحلة نقاط التسلسل sequence points التي سنشرحها لاحقًا. عامل الفاصلة يربح هذا العامل جائزة "أكثر العوامل غرابةً"، إذ يسمح لك بإنشاء قائمة طويلة من التعابير المفصول بينها بالفاصلة: expression-1,expression-2,expression-3,...,expression-n يمكنك استخدام أي عدد من التعابير، وتُقيّم التعابير من اليسار إلى اليمين حصرًا وتُهمل قيمها، عدا التعبير الأخير الذي يحدد قيمة ونوع التعبير كاملًا. لا تخلط هذه الفاصلة مع الفواصل المستخدمة في لغة سي C لأغراض أخرى، بالأخص الفواصل المُستخدمة للفصل بين وسطاء الدالة. إليك عدة أمثلة لاستخدام هذا العامل: #include <stdio.h> #include <stdlib.h> main(){ int i, j; /* comma used - this loop has two counters */ for(i=0, j=0; i <= 10; i++, j = i*i){ printf("i %d j %d\n", i, j); } /* * In this futile example, all but the last * constant value is discarded. * Note use of parentheses to force a comma * expression in a function call. */ printf("Overall: %d\n", ("abc", 1.2e6, 4*3+2)); exit(EXIT_SUCCESS); } [مثال 11.3] عامل الفاصلة مُتجاهل أيضًا، إلا إذا أردت تجربة هذه الميزة واستخدامها شخصيًّا، لذلك لن تراها إلا في بعض المناسبات الخاصة. بعد تقييم كل مُعامل، تأتي مرحلة نقاط التسلسل sequence points التي سنشرحها لاحقًا. ترجمة -وبتصرف- لقسم من الفصل Control of Flow and Logical Expressions من كتاب The C Book. اقرأ أيضًا المقال التالي: الدوال في لغة C المقال السابق: التعابير المنطقية والتحكم بالتدفق في برنامج C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

سننظر في هذا المقال إلى الطرق المختلفة التي تُستخدم بها تعليمات التحكم بتدفق Flow control statements في برنامج سي C، بما فيها بعض التعليمات التي لم نتطرق إليها بعد، والتي تُستخدَم في معظم الحالات مع تعبيرات منطقية تحدّد الخطوة القادمة، وتُعد تعابير if و while البسيطة المُستخدمة سابقًا مثالًا على هذه التعابير المنطقية Logical expressions، ويمكنك استخدام تعابير أكثر تعقيدًا من الموازنات البسيطة، مثل > و => و == وغيرها، لكن ما قد يفاجئك هو نوع النتيجة. التعابير المنطقية والعوامل العلاقية تجنبنا عمدًا التعقيد باستخدام تعابير منطقية في تعليمات التحكم بالتدفق في جميع الأمثلة المُستخدمة سابقًا، إذ صادفنا مثلًا تعابيرًا تشابه: if(a != 100){... ومن المفترض الآن أنك تعرف دعم لغة C لمفهوم "صواب True" و"خطأ False" لهذه العلاقات، لكنها تدعمها بطريقةٍ مختلفة عن المتوقّع. تُستخدم العوامل العلاقية Relational operators المذكورة في الجدول 1 للموازنة بين مُعاملين بالطريقة المذكورة، وعندما تكون المُعاملات من أنواع عددية، تطبّق التحويلات الحسابية الموافقة إليهما. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } العامل العملية > أصغر من => أصغر من أو يساوي < أكبر من =< أكبر من أو يساوي == يساوي =! لا يساوي [الجدول 1. العوامل العلاقيّة] كما أشرنا سابقًا، لا بُدّ من الانتباه لعامل اختبار المساواة == وإمكانية خلطه مع عامل الإسناد =، إذ لا تحذرك لغة سي C عند حدوث ذلك كون التعبير صالح، ولكن ستكون نتائج التعبيرين مختلفة، ويستغرق المبتدئون وقتًا طويلًا للاعتياد على استخدام == و =. لعلّك تطرح على نفسك السؤال "لماذا؟"، أي "لماذا التعبيران صالحان؟" الإجابة بسيطة، إذ تفسر لغة سي مفهوم "صواب True" و"خطأ False" بقيمة "غير صفرية" و" صفريّة"، وعلى الرغم من استخدامنا للعوامل العلاقيّة في التعابير المُستخدمة للتحكم بتعليمات if و do، إلا أننا نستخدم في الحقيقة القيمة العددية الناتجة عن هذا التعبير؛ فإذا كانت قيمة التعبير غير صفرية، فهذا يعني أن النتيجة صحيحة؛ أما إذا تحققت الحالة المعاكسة فالنتيجة خاطئ، وينطبق هذا على جميع التعابير والعوامل العلاقيّة. توازن العوامل العلاقيّة ما بين المُعاملات وتعطي نتيجة صفر للنتيجة الخاطئة (موازنة غير محقّقة) وواحد للنتيجة الصحيحة، وتكون النتيجة من نوع int، ويوضح المثال التالي كيفية عملها: #include <stdio.h> #include <stdlib.h> main(){ int i; i = -10; while(i <= 5){ printf("value of i is %d, ", i); printf("i == 0 = %d, ", i==0 ); printf("i > -5 = %d\n", i > -5); i++; } exit(EXIT_SUCCESS); } يعطينا المثال السابق الخرج القياسي التالي: value of i is -10, i == 0 = 0, i > -5 = 0 value of i is -9, i == 0 = 0, i > -5 = 0 value of i is -8, i == 0 = 0, i > -5 = 0 value of i is -7, i == 0 = 0, i > -5 = 0 value of i is -6, i == 0 = 0, i > -5 = 0 value of i is -5, i == 0 = 0, i > -5 = 0 value of i is -4, i == 0 = 0, i > -5 = 1 value of i is -3, i == 0 = 0, i > -5 = 1 value of i is -2, i == 0 = 0, i > -5 = 1 value of i is -1, i == 0 = 0, i > -5 = 1 value of i is 0, i == 0 = 1, i > -5 = 1 value of i is 1, i == 0 = 0, i > -5 = 1 value of i is 2, i == 0 = 0, i > -5 = 1 value of i is 3, i == 0 = 0, i > -5 = 1 value of i is 4, i == 0 = 0, i > -5 = 1 value of i is 5, i == 0 = 0, i > -5 = 1 ما الذي تعتقد حدوثه عند تنفيذ هذه التعليمة المحتمل أنها تكون خاطئة؟ if(a = b)... تُسند قيمة b إلى قيمة a، وكما نعلم تعطي عملية الإسناد نتيجةً من نوع a مهما كانت القيمة المُسندة إلى a، وبالتالي ستنفِّذ تعليمة if الشرطية التعليمة التالية لها إذا كانت القيمة المُسندة لا تساوي الصفر؛ أما إذا كانت القيمة تساوي الصفر، فستتجاهل التعليمة التالية. لذا يجب أن تفهم الآن ما الذي يحدث إن أخطأت استخدام عامل الإسناد بدلًا عن عامل المساواة! سيُفحَص التعبير في تعليمات if و while و do فيما إذا كان مساويًا للصفر أم لا، وسننظر إلى كلٍّ من هذه التعليمات عن كثب. التحكم بالتدفق يتم التحكم بالتدفق في لغة C من خلال التعليمات الآتية: تعليمة إذا if الشرطية تُكتب تعليمة if بطريقتين: if(expression) statement if(expression) statement1 else statement2 تُنفّذ تعليمة إذا الشرطية في الطريقة الأولى، إذا (وفقط إذا) كان التعبير expression لا يساوي إلى الصفر؛ أما إذا كان التعبير مساويًا للصفر، ستهُمل التعليمة statement. تذكر بأن التعليمة قد تكون مُركبّة، وذلك بوضع عدة تعليمات تابعة لتعليمة if واحدة. تُشابه الطريقة الثانية سابقتها، باختلاف أن التعليمة statement1 تُفحص قبل statement2 وتُنفّذ واحدةٌ منهما. تصنَّف الطريقتان بكونهما تعليمةً واحدة حسب قواعد صياغة لغة سي، وبالتالي يكون المثال التالي صالح تمامًا. if(expression) if(expression) statement إذ تُتبع تعليمة (if (expression بتعليمة if متكاملة أخرى، وبما أنها تعليمةٌ صالحة، يمكننا قراءة التعليمة الشرطية الأولى على النحو التالي: if(expression) statement وبذلك فهي مكتوبة بصورةٍ صحيحة، كما يمكن إضافة مزيدٍ من الوسطاء arguments كما تريد، ولكنها عادةٌ برمجيةٌ سيئة، ومن الأفضل أن تحاول جعل التعليمة مختصرةً قدر الإمكان حتى لو لم يكن الأمر ضروريًا في حالة استخدامها، ﻷن ذلك سيسهّل إضافة مزيدٍ من التعابير إن احتجت إلى الأمر لاحقًا ويحسِّن من سهولة القراءة. ينطبق ما سبق على طريقة كتابة تعليمة else، ويمكنك كتابتها على النحو التالي: if(expression) if(expression) statement else statement ما تزال طريقة الكتابة هذه باستخدام المسافات فقط غامضة وغير واضحة، فأي تعليمات else تتبع لتعليمات if؟ إذا اتبعنا المسافات في مثالنا فسيوحي هذا لنا بأن التعليمة if الثانية متبوعةٌ بالتعليمة statement مما يجعل كل منها تعليمةً مستقلة، و else إذًا تنتمي للتعليمة الشرطية الأولى. هذه ليست الطريقة التي تنظر بها لغة C إلى المثال، إذ تنص القاعدة على أن else تتبع التعليمة الشرطية if التي تسبقها إن لم تحتوي هذه التعليمة على else؛ وبالتالي تتبع else إلى التعليمة الشرطية الثانية في المثال الذي ناقشناه. لتجنُّب أي مشكلة بخصوص else و if كما لاحظنا في المثال السابق، يمكن إهمال التعليمة الشرطية باستخدام تعليمة مركّبة. بالعودة إلى مثالنا السابق في الجزئية الأولى من هذه السلسلة: if(expression){ if(expression) statement }else statement والذي يصبح باستخدام أقواس التعليمات المركّبة على النحو التالي: if(expression){ if(expression){ statement } }else{ statement } إن لم يرق لك مكان الأقواس في المثال السابق، فتغيير مكانها هو تفضيل شخصي ويمكنك تعديله لما تراه مناسبًا، لكن فقط كن متسقًا حيال ذلك، كما تجدر الإشارة إلى أن هناك كثيرٌ من التعصُّب بين المبرمجين بخصوص المكان الصحيح. تعليمة do و while التكرارية تعليمة while بسيطة: while(expression) statement تُنفَّذ التعليمة في حال كانت قيمة التعبير لا تساوي الصفر، وتُفحص قيمة التعبير مجدّدًا بعد كل تكرار وتُعاد التعليمة إذا لم تكن قيمة التعبير مساويةً لصفر. هل هناك أي شيء أكثر وضوحًا من ذلك؟ النقطة الوحيدة الواجب الانتباه بشأنها هي إمكانية عدم تنفيذ التعليمة على الإطلاق، أو تنفيذها بدون توقُّف إذا لم تتضمن التعليمة أي شيء يؤثر على قيمة التعبير المبدئيّة. نحتاج في بعض الأحيان تنفيذ التعليمة مرةً واحدةً على الأقل، ونستطيع في هذه الحالة استخدام الطريقة المعروفة بتعليمة do على النحو التالي: do statement while(expression); ينبغي الانتباه على الفاصلة المنقوطة، فهي غير اختيارية. تضمن بهذه الطريقة تنفيذ التعليمة مرةً واحدةً على الأقل قبل تقييم التعبير. كان استخدام الكلمة المفتاحية while للاستخدامين السابقين خيارًا غير موفّقًا، لكن لا يبدو أن هناك الكثير من الأخطاء الناتجة عن ذلك. فكّر طويلًا قبل استخدام التعليمة do، فعلى الرغم من أهميتها في بعض الحالات إلا أن استخدامها المفرط ينتج شيفرةً برمجيةً سيئة التصميم. هذا الأمر غير محقق في معظم الحالات، لكن يجب أن تتوقف وتسأل نفسك عن أهمية استخدام تعليمة do في كل حالة قبل استخدامها للتأكد من أن هذا هو الاستخدام الصحيح لها، إذ يدل استخدامها على تفكير غير مخطّط له وتوظيف وسائل تُستخدم في لغات أخرى، أو تصميمًا سيئًا ببساطة. عندما تقتنع بأهمية استخدامها دونًا عن أي وسيلة أخرى، فاستخدمها بحرص. اختصار عملية الإسناد والتحقق في تعبير واحد يُعد استخدام نتيجة عملية الإسناد للتحكم بعمل حلقات while و do التكرارية حيلةً مستخدمةً كثيرًا في برامج سي C، وهي شائعة الاستخدام كثيرًا إذ سترغب بتعلُّمها إن صادفتها. تقع هذه الحيلة تحت تصنيف لغة سي "الاصطلاحية" واستخدامها طبيعيٌ وتلقائي لكل من يستخدم اللغة. إليك المثال اﻷكثر شيوعًا لاستخدامها: #include <stdio.h> #include <stdlib.h> main(){ int input_c; /* The Classic Bit */ while( (input_c = getchar()) != EOF){ printf("%c was read\n", input_c); } exit(EXIT_SUCCESS); } [مثال 2.3] تكمن الحيلة في تعبير إسناد input_c، إذ يُستخدم هذا التعبير في إسناد القيمة إلى المتغير وموازنته مع EOF (نهاية الملف End of File) والتحكم بعمل الحلقة التكرارية في آنٍ واحد. يُعد تضمين عملية الإسناد على هذا النحو تحسينًا عمليًا سهلًا، وعلى الرغم من كونها تختصر سطرًا واحدًا فقط إلا أن فائدتها في تسهيل عملية القراءة (بعد الاعتياد على استخدامها) كبيرة. لا بُد أيضًا من تعلُّم مكان استخدام الأقواس أيضًا، فهي مهمةٌ في تحديد الأسبقية. لاحظ أن input_c من النوع int، وذلك لتمكين الدالة getchar من إعادة أي قيمة ممكنة لأي char إضافةً لقيمة EOF، ولهذا احتجنا لنوع أطول من char. تُعد التعليمتان while و do وفق قواعد صياغة لغة سي تعليمةً واحدةً مثل تعليمة if، ويمكن استخدامهما في أي مكان يُمكن استخدام تعليمةٍ واحدةٍ فيه. ينبغي عليك استخدام تعليمة مركّبة إذا أردت التحكُّم بعدّة تعليمات، كما وضّحت أمثلة فقرة تعليمة if. تعليمة for التكرارية يعدّ استخدام الحلقات التكرارية والمتغيرات عدّاداتٍ لها ميزةً شائعةً في لغات البرمجة، إذ لا ينبغي للعداد أن يكون ذا قيمٍ متعاقبة حصرًا، والاستخدام الشائع له هو تهيئته خارج الحلقة وتفقُّد قيمته عند كل تكرار للتأكد من انتهاء الحلقة التكرارية وتحديث قيمته كل دورة. هناك ثلاث خصائص مهمة مرتبطة بتحكم الحلقة، هي: التهيئة initialize والتحقق check والتحديث update، كما هو موضح في المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int i; /* initialise التهيئة*/ i = 0; /* check التحقق*/ while(i <= 10){ printf("%d\n", i); /* update التحديث*/ i++; } exit(EXIT_SUCCESS); } مثال 3.3 اﻷجزاء المرتبطة بعملية التهيئة والتحقق متقاربين كما تلاحظ، وموقعهما واضح بسبب استخدام الكلمة المفتاحية while، أما الجزء الأكثر صعوبةً لتحديده هو التحديث وبالأخص إذا استُخدمت قيمة المتغير الذي يتحكم بالحلقة داخلها؛ وفي هذه الحالة -الأكثر شيوعًا- يجب أن يكون التحديث في نهاية الحلقة، بعيدًا عن التهيئة والتحقق. يؤثر ذلك في سهولة القراءة بصورةٍ سلبية، إذ من الصعب فهم وظيفة الحلقة إلا بعد قراءة محتواها كاملًا بحرص. إذًا، نحن بحاجة إلى طريقة لجمع أجزاء التهيئة والتحقق والتحديث في مكانٍ واحد لنستطيع قراءتها بسرعة وسهولة، وهذا الغرض من تصميم تعليمة for، إذ تُكتب على النحو التالي: for (initialize; check; update) statement جزء التهيئة هو تعبير إسناد معظم الحالات، ويُستخدم لتهيئة المتحول الذي يتحكم بالحلقة. يأتي تعبير التحقق بعد التهيئة، إذ تُنفَّذ التعليمة داخل الحلقة إذا كان هذا التعبير ذو قيمةٍ غير صفرية، ويُتبع ذلك بتعبير التحديث الذي يزيد من قيمة المتغير المُتحكم (في معظم الحالات)، وتُعاد هذه العملية عند كل دورة، وتنتهي الحلقة التكرارية في حال كانت قيمة تعبير التحقق مساويةً الصفر. هناك أمران مهمان يجب معرفتهما بخصوص الوصف السابق: الأول وهو أن كل جزء من أجزاء تعليمة حلقة for التكرارية الثلاث بين القوسين هو تعبير، الثاني وهو أن الشرح وصَفَ بحرص وظيفة الحلقة التكرارية for الأساسية دون ذكر أي استخدامات بديلة. يمكنك استخدام التعابير على النحو الذي تراه مناسبًا، لكن ذلك سيكون على حساب قابلية القراءة إذا لم تُستخدم للغرض المقصود منها. إليك البرنامج التالي الذي ينجز المهمة ذاتها بطريقتين، الطريقة الأولى باستخدام حلقة while والطريقة الثانية باستخدام حلقة for، واستُخدام عامل الزيادة بالطريقة المعتادة التي يُستخدم بها في هذه الحلقات. #include <stdio.h> #include <stdlib.h> main(){ int i; i = 0; while(i <= 10){ printf("%d\n", i); i++; } /* the same done using ``for'' */ for(i = 0; i <= 10; i++){ printf("%d\n", i); } exit(EXIT_SUCCESS); } [مثال 4.3] ليس هناك أي اختلاف بين الطريقتين، عدا أن استخدام الحلقة for مناسب وقابل للتعديل بصورةٍ أفضل من تعليمة while. حاول استخدام التعليمة for في معظم الحالات المناسبة، أي عندما تحتاج إلى حلقة يتحكم فيها عدّاد ما مثلًا؛ بينما يُعد استخدام حلقة while أنسب عندما يكون العدد الذي يتحكم في عدد الدورات جزءًا من عمل البرنامج. يتطلب الأمر تحكيمًا من كاتب البرنامج وفهمًا لشكل وتنسيق البرنامج المكتوب بطريقةٍ جيّدة، إذ لا يوجد أي دليل يقول أن زيادة هذه الخصائص ينعكس سلبًا على شركات كتابة البرمجيات، فتمرّن على هذه الأمور قدر الإمكان. يمكن حذف وإهمال أيٍّ من أجزاء التهيئة والتحقق والتحديث في تعليمة for التكرارية، إلا أن الفواصل المنقوطة يجب أن تبقى، ويمكن اتباع هذا الأسلوب عندما يكون العداد مهيّأً مسبقًا أو يُحدّث بداخل متن الحلقة. إذا حُذف جزء تعبير التحقق، فهذا يعطينا نتيجةً افتراضيةً تتمثل بالقيمة "صحيح true" وهذا سيجعلها حلقةً لا نهائية. الطريقة الشائعة في كتابة حلقات تكرارية لا نهائية، هي: for(;;) أو while(1) يمكنك ملاحظة هذه التعليمات في بعض البرامج المكتوبة بلغة سي C. أهمية تعليمات التحكم بالتدفق يمكننا كتابة برامج بدرجات تعقيد متفاوتة باستخدام تعليمات التحكم بالتدفق، إذ تعد هذه التعليمات من صلب لغة C وستوضح قراءتك لبعض البرامج الأساسية في لغة C أهمية هذه التعليمات بما يخص تقديم الأدوات الأساسية وهيكلة البرامج. ستعطي التعليمات المتبقية التي سنذكرها للمبرمج تحكمًا أكبر بهذه الحلقات أو ربما ستساعده في بعض الحالات الاستثنائية. لا تحتاج تعليمة switch إلى أي شرح بخصوص أهمية استخدامها؛ فمن الممكن استبدالها بالعديد من تعليمات if، ولكنها تسهِّل قراءة البرنامج كثيرًا. يمكنك النظر إلى break و continue و goto على أنها بهارات لصلصةٍ حساسة المقادير، إذ يمكن لاستخدامها الحريص أن يجعل من هذه الصلصة أكلةً لذيذة، وبالمقابل سيجعل الاستخدام المفرط لها طعم الصلصة مشتّتًا وضائعًا. تعليمة switch يمكنك الاستغناء عن هذه التعليمة، فهي ليست جزءً أساسيًّا من لغة سي C، لكن استخدامك لها سيجعل اللغة أقلّ تعبيرًا ومتعةً للاستخدام؛ إذ تُستخدم هذه التعليمة لاختيار عددٍ من الإجراءات المختلفة حسب قيمة تعبيرٍ ما، وتجعل من تعليمة break تعليمةً مستخدمةً كثيرًا ضمنها، إذ تُكتب على النحو التالي: switch (expression){ case const1: statements case const2: statements default: statements } تُقدَّر قيمة التعبير expression وتُوازن قيمته مع جميع تعابير const1 وconst2 إلى آخره، والتي تكون قيمها مختلفة (من نوع تعابير أعداد صحيحة ثابتة حصرًا)؛ فإذا تساوت القيمة مع قيمة التعبير، تُنفّذ التعليمة التي تتبع الكلمة المفتاحية case؛ وتُنفَّذ الحالة الافتراضية التابعة للكلمة المفتاحية default -إن وجدت- في حال عدم وجود أي قيمة مكافئة؛ وإن لم تتواجد هذه الكلمة المفتاحية (ولم تتواجد أي قيمة مكافئة)، فلن تنفِّذ التعليمة switch أي شيء وسيتابع البرنامج تنفيذ التعليمة التالية. من الميزات المثيرة للاهتمام هي أن الحالات ليست استثنائية، كما هو موضح في المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int i; for(i = 0; i <= 10; i++){ switch(i){ case 1: case 2: printf("1 or 2\n"); case 7: printf("7\n"); default: printf("default\n"); } } exit(EXIT_SUCCESS); } [مثال 5.3] تتكرّر الحلقة بحسب قيمة i، إذ تأخذ قيمًا من 0 إلى 10، تتسبب قيمة 1 أو 2 بطباعة الرسالة "1or 2" عن طريق تنفيذ تعليمة printf الأولى. وما قد يفاجئك هنا هو طباعة الرسائل التي تليها أيضًا، ﻷن تعليمة switch تختار نقطة دخول واحدة إلى متن التعليمة، فبعد البدء في نقطة معينة، تُنفّذ جميع التعليمات التي تليها. تُستخدم عناوين case و default ببساطة لتحديد أي من التعليمات التي سيقع عليها الاختيار. عندما تكون قيمة i مساويةً للقيمة 7، ستُطبع الرسالتان الأخيرتان فقط، وأي قيمة لا تساوي إلى 1 أو 2 أو 7 ستتسبّب بطباعة الرسالة الأخيرة فقط. يمكن أن تُكتب العناوين labels بأي ترتيب كان، لكن لا يجب أن تتكرر أي قيمة ويمكنك استخدام عنوان default واحد فقط أو الاستغناء عنه، وليس من الضروري أن يكون العنوان الأخير، كما يمكن وضع تعليمةٍ واحدةٍ لعدّة عناوين أو عدّة تعليمات لعنوان واحد. يمكن أن يكون التعبير الذي يتحكم بتعليمة switch من أي نوع عدد صحيح. كانت لغة سي C القديمة تقبل نوع int فقط، واقتطعت المصرفات قسريًّا الأنواع الأطول مما تسبب ببعض الأخطاء الغامضة بعض الأحيان. أكبر قيود تعليمة Switch تكمن المشكلة الأكبر بخصوص تعليمة switch في عدم إمكانية تحديد أجزاء معينة من التعليمات بصورةٍ استثنائية، إذ تنفَّذ جميع التعليمات الموجود بداخل تعليمة switch التي تلي التعليمة المُنفذة على نحوٍ متعاقب، والحل هنا هو استخدام تعليمة break. ألقِ نظرةً على المثال السابق المُعدّل بحيث لا تُطبع الرسائل تباعًا بعد طباعة حالة ما، إذ تتسبب التعليمة break بمغادرة تنفيذ تعليمة switch مباشرةً وتمنع تنفيذ أي تعليمات أخرى ضمنها. #include <stdio.h> #include <stdlib.h> main(){ int i; for(i = 0; i <= 10; i++){ switch(i){ case 1: case 2: printf("1 or 2\n"); break; case 7: printf("7\n"); break; default: printf("default\n"); } } exit(EXIT_SUCCESS); } [مثال 6.3] يوجد مزيدٌ من الاستخدامات لتعليمة break سنتكلم عنها في فقرتها الخاصة. تعبير العدد الصحيح الثابت سنتكلم لاحقًا عن التعابير الثابتة، ولكن من المهم التطرق إلى طبيعة تعبير العدد الصحيح الثابت كونه التعبير الذي يجب أن تُلحقه بعنوان case في تعليمة switch. عمومًا، لا يحتوي تعبير العدد الصحيح الثابت أي عوامل تغيِّر من قيمته، مثل عامل الزيادة أو الإسناد، أو استدعاءٍ للدوال أو عوامل الفاصلة، ويجب أن تكون جميع المُعاملات في التعبير ثوابت صحيحة وثوابت محرفية وثوابت تعداد numeration constants وتعابير sizeof وثوابت الفاصلة العائمة وهي المُعاملات المباشرة لمحوّلات النوع casts، كما يجب أن تكون أنواع العدد الصحيح هي الأنواع الناتجة عن أي مُعامل محوِّلٍ للنوع، وجميع هذه القيم يمكن أن تتوقعها بكونها تحت تصنيف تعبير العدد الصحيح الثابت. تعليمة break هذه التعليمة بسيطة، ويمكن فهمها في سياق استخدامها ضمن تعليمة switch، أو do، أو while، أو for، إذ يقفز تدفق البرنامج عند استخدامها إلى التعليمة التالية خارج متن التعليمة الحالية التي تتضمن تعليمة break؛ وتُستخدم كثيرًا في تعليمات switch، إذ إنها ضرورية بطريقةٍ أو بأخرى للحصول على التحكم الذي يحتاجه معظم الناس. استخدام تعليمة break بداخل الحلقات التكرارية استخدامٌ غير محبّذ بحسب الحالة، إذ إنه مبرّر عند حدوث ظروف استثنائية بداخل الحلقة مما يتطلب مغادرتها. من الجيد أن نستطيع مغادرة عدة حلقات دفعةً واحدة باستخدام تعليمة break واحدة فقط، لكن هذا غير محقّق. ألقِ نظرةً على المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int i; for(i = 0; i < 10000; i++){ if(getchar() == 's') break; printf("%d\n", i); } exit(EXIT_SUCCESS); } [مثال 7.3] يقرأ البرنامج السابق محرفًا وحيدًا من الدخل قبل طباعة قيمة i وفق سلسلةٍ من الأعداد، وتتسبب تعليمة break بالخروج من الحلقة في حال إدخال المحرف s. يُعد استخدام break خيارًا خاطئًا إذا أردت الخروج من عدة مستويات من الحلقات، إذ أن استخدام goto هو الطريقة السهلة الوحيدة لكن سنتركها إلى النهاية بما أن ذكرها يتطلب وجود ذكر أشياء أخرى قبلها. تعليمة continue يوجد لهذه التعليمة عددٌ محدودٌ من حالات الاستخدام، وقواعد استخدامها مطابقةٌ لقواعد استخدام break عدا أنها لا تُطبَّق في تعليمات switch. يبدأ التكرار التالي لأصغر تعليمة (أقلها مستوى) سواء كانت do، أو while، أو for فور تنفيذ تعليمة continue، ويقتصر استخدامها في بداية الحلقات حيث يجب اتخاذ قرار بشأن تنفيذ بقية متن الحلقة أم لا. تَضمَن تعليمة continue في المثال التالي عدم تنفيذ القسمة على صفر، والتي تتسبب بسلوك غير محدد. #include <stdio.h> #include <stdlib.h> main(){ int i; for(i = -10; i < 10; i++){ if(i == 0) continue; printf("%f\n", 15.0/i); /* * Lots of other statements ..... */ } exit(EXIT_SUCCESS); } [مثال 8.3] قد تنظر إلى التعليمة continue بكونها غير ضرورية، وأنه ينبغي أن يكون تنفيذ متن الحلقة شرطيًّا بدلًا من ذلك، لكنك لن تجد الكثير من المؤيدين لرأيك، إذ يفضِّل معظم مبرمجو لغة سي C استخدام continue بدلًا من استخدام مستوًى إضافي من المسافات لتضمين جزءٍ معين من الحلقة وبالأخص إن كان كبيرًا. يمكنك طبعًا استخدام continue في أجزاء أخرى من الحلقة، بهدف تبسيط منطق الشيفرة وتحسين قابلية قراءتها، ولكن لا بُد من استخدامها باعتدال. أبقِ في بالك أن التعليمة continue ليس لها أي معنًى داخل تعليمة switch على عكس break، إذ أن استخدام continue بداخل switch ذو قيمةٍ فقط في حالة وجود حلقة تكرارية تحتوي switch، وفي هذه الحالة يبدأ التكرار التالي من الحلقة عند تنفيذ continue. هناك فرقٌ مهمٌ بين الحلقات التكرارية المكتوبة باستخدام while و for؛ ففي حلقات while وعند استخدام continue يقفز التنفيذ إلى فحص قيمة التعبير التي تتحكم بالحلقة؛ بينما تُنفذ تعليمة التحديث وتعبير التحكم في حالة for. تعليمة goto والعناوين labels يعرف الجميع أن استخدام تعليمة goto هو "تصرف سيء"، إذ أنها تجعل برنامجك صعب المتابعة والقراءة، وتشتِّت هيكله وتدفقه إذا استُخدمت من دون عناية. كتبت مجموعة دايجكسترا Dijkstra ورقةً شهيرةً في 1968 باسم "تعليمة Goto مُضرة Goto Statement Considered Harmful" التي يذكرها الجميع ولكن لم يقرأها أي أحد. الشيء الأكثر إزعاجًا هو عندما يكون استخدامها في بعض الحالات ضروريًّا للغاية، إذ تُستخدم في لغة سي C للخروج من عدة حلقات تكرارية متداخلة أو للانتقال إلى مخرج للتعامل مع الأخطاء في نهاية الدالة، وستحتاج لاستخدام عنوان label عندما تقرر استخدام goto، ويوضح المثال التالي استخدامهما: goto L1; /* whatever you like here */ L1: /* anything else */ العنوان هو معرّفٌ متبوعٌ بنقطتين، ويوجد للعناوين "مجال أسماء namespace" خاص بهم لتجنب الخلط بينهم وبين أسماء المتغيرات والدوال. مجال الأسماء هذا متواجدٌ فقط بداخل الدالة التي تحتويه، لذلك يمكنك إعادة استخدام أسماء العناوين في دوال مختلفة، كما يُمكن للعنوان أن يُستخدم قبل التصريح عنه أيضًا عن طريق ذكره ضمن تعليمة goto ببساطة. يجب أن تكون العناوين جزءًا من تعليمةٍ كاملة، حتى لو كانت فارغة، وعادة ما يكون هذا مهمًا فقط عندما تحاول وضع عنوان في نهاية التعليمة المركبة على النحو التالي: label_at_end: ; /* empty statement */ } تعمل goto بطريقة واضحة، إذ تنتقل إلى التعليمة المعنونة، ولأن اسم العنوان مرئي فقط من داخل الدالة التي تحتويه فمن غير الممكن الانتقال من دالةٍ إلى دالةٍ أخرى. من الصعب إعطاء قوانين صارمة حول استخدام تعليمة goto ولكن على نحوٍ مشابه لتعليمات do و continue و break (عدا وجودها في تعليمة switch)، فإن الاستخدام المفرط لها غير محبذ. فكّر طويلًا قبل استخدماها وليكن استخدامها بالنسبة لهيكلية البرنامج مقنعًا، إذ استخدامك لتعليمة goto كل 3 أو 5 دوال يدل على مشكلة ويجب أن تجد طريقةً مختلفة لكتابة برنامجك. خلاصة الآن وبعد استعراضنا لتعليمات التحكم بتدفق البرنامج المختلفة ورأينا أمثلةً عن استخدامها، يجب أن تستخدم بعضها في أي فرصة تُتاح لك، بينما يُستخدم بعضها الآخر لأغراض خاصة ولا يجب الإفراط في استخدامها. يجعل الانتباه إلى استخدام التعليمات برامجك المكتوبة بلغة سي C أنيقة، إذ تعطيك تعليمات التحكم بالتدفق المخصصة الفرصة لإضافة خصائص غير موجودة في بعض اللغات الأخرى. وبذلك يبقى التكلُّم عن العوامل المنطقية كل ما تبقى للانتهاء من جانب التحكم بتدفق البرنامج في لغة سي C. ترجمة -وبتصرف- لقسم من الفصل Control of Flow and Logical Expressions من كتاب The C Book. اقرأ أيضًا المقال التالي: العوامل المنطقية في لغة سي C وعوامل أخرى المقال السابق: الثوابت وسلاسل الهروب في لغة سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

يشرح المقال الأعداد الحقيقية والصحيحة الثابتة وسلاسل الهروب في لغة C. الأعداد الصحيحة الثابتة مبدأ الأعداد الصحيحة الثابتة بسيط، فهي تمثل أي عدد صحيح مثل 1 أو 1034 وغيرها، ويمكنك إضافة الحرف l أو L في نهاية عدد صحيح ثابت لتحويله قسريًّا إلى نوع long، وإضافة u أو U لتحويلها إلى unsigned، ويمكن كتابة الأعداد الصحيحة الثابتة بالنظام الست عشري عن طريق استخدام 0x أو 0X قبل كتابة الثابت، والأحرف a و b و c و d و e و f. وتُكتب الأعداد الصحيحة الثابتة بالنظام الثماني أيضًا باستخدام 0 في بداية الرقم، وتستخدم الأرقام 0، 1، 2، 3، 4، 5، 6، 7 فقط. عليك الحذر هنا بهذا الشأن، إذ من السهل النظر إلى 015 ومعاملته على أنه رقم صحيح بالنظام العشري، يقع المبتدئون في هذا الخطأ أغلب الأحيان، ولكنك ستبدأ بالاعتياد على الأمر بعد اقتراف بعض الأخطاء. قدّم معيار سي طريقًة جديدة لمعرفة نوع العدد الصحيح الثابت، إذ تحدث ترقية promoted للثابت في لغة سي القديمة إلى النوع long في حال كان كبيرًا ولا يتسع في النوع int دون أي تحذيرات، وتنص القاعدة على أن التحويل يجري بهذا الترتيب إلى أن تتسع قيمة الثابت بالنظام العشري: int long unsigned long بينما تستخدم الأعداد الست عشرية والثمانية الصحيحة هذه القائمة: int unsigned int long unsigned long إذا كان الثابت مسبوقًا بالحرف "u" أو "U": unsigned int unsigned long إذا كان مسبوقًا بالحرف "l" أو "L": long unsigned long وأحيرًا، إذا كان مسبوقًا بكلٍّ من u أو U و l أو L فالنوع هو unsigned long حصرًا. تُجرى جميع هذه التحويلات لإعطائك النوع "الذي قصدته"، وهذا يعني أن معرفة نوع الثابت ضمن تعبير أمرٌ صعب بعض الشيء إن لم تكن تعرف أي شيء بخصوص عتاد الجهاز. لحسن الحظ هناك بعض المصرّفات التي تحذّرك عند ترقية ثابت ما إلى طول آخر ولم يُحدَّد النوع باستخدام U أو L أو غيرها. تحوي هذه التعليمة على خطأ مُخبأ: printf("value of 32768 is %d\n", 32768); سيكون العدد 32768 طويلًا بالنسبة لآلة تعمل بنظام المتمم الثنائي ذي 16 بتًا وفقًا للقواعد المذكورة أعلاه، ولكن تتوقع الدالة printf عددًا صحيحًا فقط على أنه وسيط، ويشيرd% إلى ذلك، إلا أن نوع هذا الوسيط خاطئ وينبغي عليك توخي الحذر وتحويل مثل هذه الحالات إلى النوع الصحيح: printf("value of 32768 is %d\n", (int)32768); من الجدير بالذكر أنه لا وجود للثوابت السالبة، فكتابة 23- هو تعبيرٌ مكون من ثابت موجب وعامل. تمتلك ثوابت المحارف نوع int لأسباب تاريخية، وتُكتب عن طريق وضعها بين علامتي تنصيص أحادية على النحو التالي: 'a' 'b' 'like this' تُكتب المحارف الموسعة الثابتة بالطريقة ذاتها ولكن يسبقها وجود L: L'a' L'b' L'like this' للأسف، يمكن أن تحتوي المحارف الثابتة على أكثر من محرف واحد، ولكن تنفيذها يعطي نتيجةً مرتبطةً بالجهاز الذي تعمل عليه. تُعد المحارف الوحيدة من أفضل الحلول للبرامج المحمولة Portable، إذ تعطي قيمة عدد صحيح ثابت اعتيادي حسب تمثيل الجهاز لهذا الحرف. صادفت في تعريفنا عن المحارف الموسعة هذا المحرف <a> الذي يمثّل محرفًا متعدّد البايتات (مُرمّزًا لعمليات الإدخال بالإزاحة والإخراج بالإزاحة)، ويُعد <a> هنا محرفًا ثابتًا، مثل المحرف abcde. سيتسبب هذا النوع من المحارف بالعديد من المشاكل في المستقبل، نأمل أن يحذّرك المصرّف بشأنهم. هناك ما يُدعى باسم سلسلة الهروب Escape sequence، والتي تهدف إلى تسهيل عملية تمثيل بعض المحارف الخاصة التي سيكون من الصعب استخدامها ضمن محرف ثابت (هل المحرف ' ' هو محرف مسافة space أم مسافة جدولة tab؟). يوضح الجدول 10.2 سلاسل الهروب المُعرفة في المعيار. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } السلسلة الغرض منها a\ تحذير صوتي b\ فراغ للخلف Backspace f\ فاصل صفحة n\ سطر جديد r\ إرجاع المؤشر t\ مسافة جدولة v\ مسافة جدولة شاقولية \\ شرطة مائلة للخلف '\ علامة تنصيص فردية "\ علامة تنصيص مزدوجة ?\ إشارة استفهام [جدول 10.2. سلاسل الهروب في لغة C] من الممكن أيضًا استخدام سلاسل هروب عددية لتحديد محرف باستخدام القيمة الداخلية التي تمثّله، مثل السلسلة 000\ أو xhhh\، إذ أن 000 هي ثلاث خانات ثمانية و hhh هو أي عدد ممثل بالنظام الست عشري. أكثر السلاسل شيوعًا هي 033\، التي تُستخدم لتمثل زرّ ESC (الهروب Escape) على لوحة المفاتيح في الحواسيب التي تعمل بترميز ASCII. انتبه إلى أن المحارف الثابتة الممثلة بالقيمة الست عشرية تشمل جميع المحارف الموجودة ضمنها، فعلى سبيل المثال إذا أردت سلسلةً نصيةً تحتوي على القيمة الست عشرية ff متبوعةً بالحرف f، فالطريقة الآمنة لكتابة ذلك هو استخدام خاصية ضمّ السلاسل النصية: "\xff" "f" إذ تمثّل السلسلة النصية: "\xfff" محرفًا واحدًا، مكوّنًا من ثلاثة حروف f تمثل قيمة السلسلة الست عشرية. تتطلب بعض محارف الهروب تفسيرًا إذ أن بعضها غير واضح الوظيفة. للحصول على علامة تنصيص فردية على أنها محرف ثابت نستخدم '\، وللحصول على علامة استفهام نستخدم ?\، للحصول على علامتي استفهام لا يمكنك استخدام ??، لأن السلسلة ?? تعد ثلاثية محارف Trigraph، وبالتالي، عليك استخدام ?\?\. محرف الهروب "\ مهمٌ فقط في حالة السلاسل النصية، وسنتكلم عن ذلك لاحقًا. هناك هدفان مختلفان وراء سلاسل الهروب، إذ من المهم طبعًا تمثيل بعض المحارف مثل علامة التنصيص الفردية والشرطة المائلة للخلف بوضوح، وهذا الهدف الأول، أما الهدف الثاني فهو مرتبطٌ بسلاسل الهروب التالية التي تتحكم في حركة أجهزة الطباعة، على النحو التالي: \a اقرع الجرس في حال وجود شيء ما للطباعة، ولا تتحرك. \b فراغ للخلف. \f اِذهب إلى أول موضع في "الصفحة التالية"، وقد يعني هذا أشياءً مختلفة لأجهزة الخرج المختلفة. \n اِذهب إلى بداية السطر التالي. \r عُد إلى بداية السطر الحالي. \t اِذهب إلى مسافة الجدولة الأفقية التالية. \v اذهب إلى بداية السطر الواقع في موضع مسافة الجدولة الأفقية التالية. بالنسبة للمحارف b\ و t\ و v\ إن لم يكن هناك موضع موافق فسيكون التصرف غير محدد. يتجنب المعيار ذكر الوجهات الفيزيائية للحركة بالنسبة لأجهزة الخرج، لأنها لا تعمل من الأعلى إلى الأسفل ومن اليسار إلى اليمين بالضرورة كما في بيئات العمل الموجودة في الثقافة الغربية في جميع الحالات. من المضمون أن لكل محرف هروب قيمة عدد صحيح فريدة، وتُخزَّن في النوع char. الأعداد الحقيقية الثابتة تتبع هذه الأعداد التنسيق الاعتيادي للأعداد الحقيقية: 1.0 2. .1 2.634 .125 2.e5 2.e+5 .125e-3 2.5e5 3.1E-6 وإلى آخره. حتى لو كان هناك جزء من الرقم الحقيقي ذو قيمة صفرية يجب إظهاره بهدف تسهيل القراءة: 1.0 0.1 يدل الجزء الأسي exponent على مرتبة قوة العدد، مثلًا: 3.0e3 يكافئ قيمة العدد الصحيح الثابت: 3000 وكما ترى، يمكن استبدال e بالحرف E أيضًا لنفس الغرض، وهذه الثوابت من نوع double إلا في حال سبق القيمة المحرف f أو F وفي هذه الحالة هي من نوع float؛ وإذا سبقها l أو L فهي في هذه الحالة من نوع long double. بهدف الوصف الكامل، إليك وصف رسمي يصف طبيعة الأعداد الحقيقية الثابتة: العدد الحقيقي الثابت يحقق واحدةً من الحالات التالية: عدد كسري ثابت متبوعٌ بأُس اختياري. سلسلة أرقام متبوعة بأُس. في الحالتين السابقتين، يمكن أن يُتبع العدد الحقيقي بالأحرف الاختيارية f و l و F و L، بحيث يتحقق: الثابت الكسري واحدٌ من الحالات التالية: سلسلة اختيارية من الخانات متبوعةٌ بفاصلة عشرية متبوعةٌ بسلسلة من الخانات. سلسلةٌ من الخانات متبوعةٌ بفاصلةٍ عشرية. الأس واحدٌ من الحالات التالية: الحرف e أو E متبوعٌ برمز + أو - اختياري متبوعٌ بسلسلة من الخانات. سلسلة من الخانات هي تركيب اعتباطي من خانةٍ واحدة أو أكثر. ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: التعابير المنطقية والتحكم بالتدفق في برنامج C المقال السابق: العوامل في لغة سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

يعرض هذا المقال مفهوم العوامل في لغة C وكيفية استخدامها في العمليات والتعليمات. عوامل المضاعفة تتضمن عوامل المضاعفة multiplicative operators عامل الضرب "*" والقسمة "/" وباقي القسمة "%"، ويعمل عاملا الضرب والقسمة بالطريقة التي تتوقع أن تعملان بها، لكلٍّ من الأنواع الحقيقية والصحيحة، إذ تنتج قيمة مقتطعة دون فواصل عشرية عند تقسيم الأعداد الصحيحة ويكون الاقتطاع باتجاه الصفر. يعمل عامل باقي القسمة وفق تعريفه فقط مع الأنواع الصحيحة، لأن القسمة الناتجة عن الأعداد الحقيقية لن تعطينا باقيًا. إذا كانت القسمة غير صحيحة، وكان أيٌ من المُعاملان غير سالب، فنتيجة العامل "/" هي موجبة ومقرّبة باتجاه الصفر، ونستخدم العامل "%" للحصول على الباقي من هذه العملية، على سبيل المثال: 9/2 == 4 9%2 == 1 إذا كان أحد المُعاملات سالب، فنتيجة العامل "/" قد تكون أقرب عدد صحيح لنتيجة القسمة على أي من الاتجاهين (باتجاه الأكبر أو الأصغر)، وقد تكون إشارة نتيجة العامل "%" موجبةً أو سالبة، وتعتمد النتيجتين السابقتين حسب تعريف التنفيذ. التعبير الآتي مساوٍ الصفر في جميع الحالات عدا حالة b مساوية للصفر. (a/b)*b + a%b - a تُطبّق التحويلات الحسابية الاعتيادية على كلا المُعاملين. عوامل الجمع تتضمن عوامل الجمع additive operators عامل الجمع "+" والطرح "-"، وتتبع طريقة عمل هذه الدوال قواعدها المعتادة التي تعرفها. للعامل الثنائي والأحادي نفس الرمز، ولكن لكل واحد منهما معنًى مختلف؛ فعلى سبيل المثال، يَستخدم التعبيران a+b وa-b عاملًا ثنائيًّا (العامل - للجمع و + للطرح). إذا أردنا استخدام العوامل الأحادية بذات الرموز، فسنكتب b+ أو b-، ولعامل الطرح الأحادي وظيفةٌ واضحة ألا وهي أخذ القيمة السالبة لقيمة المُعامل، ولكن ما وظيفة عامل الجمع الأحادي؟ في الحقيقة لا يؤدي أي دور؛ ويُعد عامل الجمع الأحادي إضافةً جديدة إلى اللغة، إذ يعادل وجوده وجود عامل الطرح الأحادي ولكنه لا يؤدي أي دور لتغيير قيمة التعبير. القلة من مستخدمي لغة سي القديمة لاحظ عدم وجوده. تُطبّق التحويلات الحسابية الاعتيادية على كلٍّ من مُعاملات العوامل الثنائية (للجمع والطرح)، وتُطبّق الترقية العددية الصحيحة على مُعاملات العوامل الأحادية فقط. عوامل العمليات الثنائية واحدة من مزايا لغة سي هي الطريقة التي تسمح بها لمبرمجي النظم بالتعامل مع الشيفرة البرمجية وكأنها شيفرة تجميعية Assembly code، وهو نوع شيفرة برمجية كان شائعًا قبل مجيء لغة سي، وكان هذا النوع من الشيفرات صعب التشغيل على عدة منصات (غير محمول non-portable). كما وضحت لنا لغة سي أن هذا الأمر لا يتطلب سحرًا لجعل الشيفرة محمولة، لكن ما هو هذا الشيء؟ هو ما يُعرف أحيانًا باسم "العبث بالبِتات bit-twiddling" وهي عملية التلاعب ببتات متغيرات الأعداد الصحيحة على نحوٍ منفرد. لا يمكن استخدام عوامل العمليات الثنائية bitwise operators على مُعاملات من نوع أعداد حقيقية إذ لا تُعد البتات الخاصة بها منفردة individual أو يمكن الوصول إليها. هناك ستة عوامل للعمليات الثنائية موضحة في الجدول 7.2، الذي يوضح أيضًا نوع التحويلات الحسابية المُطبّقة. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } العامل التأثير التحويل & العملية الثنائية AND التحويلات الحسابية الاعتيادية \ العملية الثنائية OR التحويلات الحسابية الاعتيادية ^ العملية الثنائية XOR التحويلات الحسابية الاعتيادية >> إزاحة إلى اليسار الترقية العددية الصحيحة << إزاحة إلى اليمين الترقية العددية الصحيحة ~ المتمم الأحادي الترقية العددية الصحيحة [جدول 7.2. عوامل العمليات الثنائية] العامل الوحيد الأحادي هو الأخير (المتمم الأحادي)، إذ يعكس حالة كل بِت في قيمة المُعامل وله نفس تأثير عامل الطرح الأحادي في حاسوب يعمل بنظام المتمم الأحادي، لكن معظم الحواسيب الآن تعمل بنظام المتمم الثنائي، لذلك وجوده مهم. سيسهّل استخدام النظام الست عشري عن استخدام النظام العشري فهم طريقة هذه العوامل، لذا حان الوقت الآن لأن نعرفك على الثوابت الست عشرية. أي رقم يُكتب في بدايته "0x" يفسّر على أنه رقم ست عشري، على سبيل المثال القيمة "15" و"0xf"، أو "0XF" متكافئتان، جرّب تشغيل المثال التالي على حاسوبك، أو الأفضل من ذلك تنبّأ بوظيفة البرنامج قبل تشغيله. #include <stdio.h> #include <stdlib.h> main(){ int x,y; x = 0; y = ~0; while(x != y){ printf("%x & %x = %x\n", x, 0xff, x&0xff); printf("%x | %x = %x\n", x, 0x10f, x|0x10f); printf("%x ^ %x = %x\n", x, 0xf00f, x^0xf00f); printf("%x >> 2 = %x\n", x, x >> 2); printf("%x << 2 = %x\n", x, x << 2); x = (x << 1) | 1; } exit(EXIT_SUCCESS); } [مثال 2.9] لنتكلم أوّلًا عن طريقة عمل الحلقة التكرارية في مثالنا، إذ أن المتغير الذي يتحكم بالحلقة هو x ومُهيّأ بالقيمة صفر، وفي كل دورة تُوازن قيمته مع قيمة y الذي ضُبِط بنمطٍ مستقل بنفس طول الكلمة ومكون من الواحدات، وذلك بأخذ المتمم الأحادي للصفر، وفي أسفل الحلقة يُزاح المتغير x إلى اليسار مرةً واحدةً وتُجرى العملية الثنائية OR عليه، مما ينتج سلسلةً تبدأ على النحو التالي: "0، 1، 11، 111، …" بالنظام الثنائي. تُجرى العمليات الثنائية على x باستخدام كل من عوامل AND وOR وXOR (أي OR الحصرية أو دارة عدم التماثل) إضافةً إلى مُعاملات أخرى جديرة بالاهتمام، ومن ثم تُطبع النتيجة. نجد أيضًا عوامل الإزاحة إلى اليمين واليسار، التي تعطينا نتيجةً بنوع وقيمة المُعامل الموجود على الجهة اليسرى مزاحةً إلى الجهة المحددة عددًا من المراتب حسب المُعامل الموجود على جهتها اليمنى، ويجب أن يكون المُعاملان أعدادًا صحيحة. تختفي البِتات المُزاحة إلى أي من طرفي المُعامل الأيسر، وينتج عن إزاحة مقدار من البتات أكبر من البتات الموجودة في الكلمة نتيجةً معتمدةً على التنفيذ. تضمن الإزاحة إلى اليسار إزاحة الأصفار إلى البتات منخفضة الترتيب، بينما تكون الإزاحة إلى اليمين أكثر تعقيدًا، إذ إن الأمر متروك لتنفيذك للاختيار بين إجراء إزاحة منطقية أو حسابية إلى اليمين عند إزاحة المُعاملات ذات الإشارة. هذا يعني أن الإزاحة المنطقية تُزيح الأصفار باتجاه البت ذو الأكثر أهمية، بينما تنسخ الإزاحة الحسابية محتوى البت الأكثر أهمية الحالي إلى البت نفسه، ويصبح الخيار أوضح إذا أُزيح مُعامل عديم الإشارة إلى اليمين، ولا يوجد أي خيار هنا، إذ يجب أن تكون الإزاحة منطقية. ولهذا السبب يجب أن تتوقع أن تكون القيمة المُزاحة عند استخدام الإزاحة إلى اليمين مصرحٌ عنها مثل قيمةٍ عديمة الإشارة، أو أن يُحوّل نوعها cast إلى عديمة الإشارة لإجراء عملية الإزاحة كما يصف المثال التالي ذلك: int i,j; i = (unsigned)j >> 4; لا ينبغي على المُعامل الثاني (على الطرف الأيمن) لعامل الإزاحة أن يكون ثابتًا، إذ من الممكن استخدام أي دالة ذات نوع عدد صحيح؛ ومن المهم هنا الإشارة إلى أن قوانين مزج أنواع المُعاملات لا تنطبق على عوامل الإزاحة، إذ أن نوع نتيجة الإزاحة هي النوع المُزاح ذاته (بعد الترقية العددية الصحيحة) ولا تعتمد على أي شيءٍ آخر. لنتكلم عن شيء مختلف قليلًا، وهي إحدى الحيل المفيدة التي يستخدمها مبرمجو لغة سي لكتابة برامجهم على نحوٍ أفضل. إذا أردت تشكيل قيمةٍ تحتوي على واحدات "1" في جميع خاناتها عدا البِت الأقل أهمية، بهدف تخزين نمطٍ آخر فيها، فمن غير المطلوب معرفة طول الكلمة في النظام الذي تستخدمه. على سبيل المثال، تستطيع استخدام الطريقة التالية لضبط البتات الأقل ترتيبًا لمتغيرٍ من نوع int إلى 0x0f0 وجميع البتات الأخرى إلى 1: int some_variable; some_variable = ~0xf0f; أُجري المتمم الأحادي على المتمم الأحادي لنمط البتات منخفضة الترتيب المرغوب، وهذا يُعطي بدوره القيمة المطلوبة والمستقلة تمامًا عن طول الكلمة، وهو شيء متكرر الحدوث في شيفرة لغة سي. لا يوجد هناك مزيدٌ من الأشياء لقولها عن عوامل التلاعب بالبتات، وتجربتنا في تعليم لغة سي تدلنا على أنها سهلة الفهم والتعلم من معظم الناس، لذا دعنا ننتقل للموضوع التالي. عوامل الإسناد العنوان ليس خطأً مطبعيًا بل قصدنا "عوامل" بالجمع، إذ أن لدى لغة سي عدة عوامل إسناد على الرغم من رؤيتنا للعامل "=`"فقط حتى الآن. المثير للاهتمام بخصوص هذه العوامل هو أنها تعمل مثل العوامل الثنائية الأخرى، إذ تأخذ مُعاملين وتعطينا نتيجة، وتستخدم النتيجة لتكون جزءًا من التعبير. مثلًا في هذا التعبير: x = 4; تُسند القيمة 4 إلى المتغير x، والنتيجة عن إسناد القيمة إلى المتغير x هو استخدامها على النحو التالي: a = (x = 4); إذ ستخزِّن a القيمة 4 المُسندة إليها بعد أن تُسنَد إلى x. تجاهلت جميع عمليات الإسناد السابقة التي نظرنا إليها لحد اللحظة (عدا مثال واحد) ببساطة القيمة الناتجة عن عملية الإسناد بالرغم من وجودها. بفضل هذه القيمة، يمكننا كتابة تعابير مشابهة لهذه: a = b = c = d; إذ تُسند قيمة المتغير d إلى المتغير c وتُسند هذه النتيجة إلى b وهكذا دواليك، ونلاحظ هنا معالجة تعابير الإسناد من الجهة اليمنى إلى الجهة اليسرى، ولكن ماعدا ذلك فهي تعابير اعتيادية (القوانين التي تصف اتجاه المعالجة من اليمين أو من اليسار موجودةٌ في الجدول 9.2.). هناك وصف موجود في القسم الذي يتكلم عن "التحويلات"، يصف ما الذي سيحدث في حالة التحويل من أنواع طويلة إلى أنواع قصيرة، وهذا ما يحدث عندما يكون المُعامل الذي يقع على يسار عامل الإسناد البسيط أقصر من المُعامل الذي يقع على يمينه. عوامل الإسناد المتبقية هي عوامل إسناد مركّبة، وتعد اختصاراتٌ مفيدة يمكن اختصارها عندما يكون المُعامل ذاته على يمين ويسار عامل الإسناد، على سبيل المثال، يمكن اختصار التعبير التالي: x = x + 1; إلى التعبير: x += 1; وذلك باستخدام إحدى عوامل الإسناد المركّبة، وتكون النتيجة للتعبير الأول هي ذاتها للتعبير الثاني المختصر في أي حالة. يصبح هذا الأمر مفيدًا عندما يكون الجانب الأيسر من العامل تعبيرًا معقّدًا، وليس متغيرًا وحيدًا، وذلك في حالة استخدام المصفوفات والمؤشرات. يميل معظم مبرمجي لغة سي لاستخدام التعبير في المثال الثاني لأنه يبدو "أكثر منطقية"، وهذا ما يختلف عنده الكثير من المبتدئين عند تعلُّم هذه اللغة. يوضح الجدول 8.2 عوامل الإسناد المركبة، وستلاحظ استخدامنا المكثّف لها من الآن فصاعدًا. =* =/ =% =+ =- =& =\ =^ =<< =>> [جدول 8.2. عوامل الإسناد المركبة] تُطبَّق التحويلات الحسابية في كل حالة وكأنها تُطبق على كامل التعبير، أي كأن التعبير a+=b مثلًا مكتوبٌ على النحو a=a+b. عوامل الزيادة والنقصان قدّمت لغة سي عاملين أحاديين مميزين لإضافة واحد أو طرحه من تعبيرٍ ما نظرًا لشيوع هذه العملية البسيطة؛ إذ يضيف عامل الزيادة "++" واحدًا، ويطرح عامل النقصان "--" واحدًا، وتُستخدم هذه العوامل على النحو التالي: x++; ++x; x--; --x; إذ من الممكن أن يقع العامل قبل أو بعد المُعامل، ولا يختلف عمل العامل في الحالات الموضحة سابقًا حتى لو اختلف موقعه، ولكن الحالة تصبح أكثر تعقيدًا في بعض الأحيان ويصبح الفرق وفهمه مهمّان للاستخدام الصحيح. إليك الفرق موضحًا في المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int a,b; a = b = 5; printf("%d\n", ++a+5); printf("%d\n", a); printf("%d\n", b++ +5); printf("%d\n", b); exit(EXIT_SUCCESS); } مثال 10.2 خرج المثال السابق هو: 11 6 10 6 يعود السبب في الفرق في النتائج إلى تغيير مواضع العوامل؛ فإذا ظهر عامل الزيادة أو النقصان قبل المتغير، فستتغيّر القيمة بمقدار واحد و تُستخدم القيمة الجديدة ضمن التعبير؛ أما إذا ظهر العامل بعد المتغير فستُستخدم القيمة القديمة في التعبير، ثم تُغيّر قيمة المتغير. لا يستخدم مبرمجو سي عادةً التعليمة التالية لطرح أو جمع واحد: x += 1; بل يستخدمون التعليمة التالية: x++; /* or */ ++x; ينبغي تجنُّب استخدام المتغير ذاته أكثر من مرة في ذات التعبير إذا كان هذا النوع من العوامل مرتبطًا به، إذ لا يوجد هناك أي قاعدة واضحة تدلك على الجزء المحدد من التعبير الذي ستتغير فيه قيمة المتغير. قد يختار المصرّف "حفظ" جميع التغييرات وتطبيقها دفعةً واحدة، فعلى سبيل المثال لا يضمن التعبير التالي إسناد قيمة x الأصلية مرّتين إلى y: y = x++ + --x; وقد يُقيّم كما لو كان قد جرى توسعته إلى التعبير التالي: y = x + (x-1); لأن المصرّف يلاحظ عدم وجود تأثير أبدًا على قيمة x. تُجرى العمليات الحسابية في هذه الحالة تمامًا كما في حالة تعبير جمع، مثلًا x=x+1، وتُطبّق التحويلات الحسابية الاعتيادية. الأسبقية والتجميع علينا النظر إلى الطريقة التي تعمل بها هذه العوامل بعد التكلم عنها. قد تعتقد أن عملية الجمع ليست بتلك الأهمية، فنتيجة التعبير a + b + c مساويةٌ للتعبير: (a + b) + c أو التعبير: a + (b + c) أليس كذلك؟ في الحقيقة لا، فهناك فرقٌ بين التعابير السابقة؛ فإذا تسبَّب التعبير a+b بحالة طفحان، وكانت قيمة المتغير c قريبة من قيمة b-، فسيعطي التعبير الثاني الإجابة الصحيحة، بينما سيتسبب الأول بسلوك غير محدد. يمكننا ملاحظة هذه المشكلة بوضوح أكبر باستخدام قسمة الأعداد الصحيحة، إذ يعطي التعبير التالي: a/b/c نتائج مختلفةً تمامًا عند تجميعه بالطريقة: a/(b/c) أو بالطريقة: (a/b)/c يمكنك تجربة استخدام القيم a=10 و b=2 و c=3 للتأكُّد، إذ سيكون التعبير الأول: (2/3)/10، ونتيجة 2/3 في قسمة الأعداد الصحيحة هي 0، لذلك سنحصل على 10/0، مما سيسبب طفحانًا overflow؛ بينما سيعطينا التعبير الثاني القيمة (10/2)، وهي 5، وبتقسيمها على 3 تعطينا 1. يُعرَف تجميع العوامل على هذا النحو بمصطلح الارتباط associativity، والمكون الثاني لتحديد طريقة عمل العوامل هو الأسبقية precedence، إذ لبعض العوامل أسبقيةٌ عن عوامل أخرى، وتُحسب قيم العوامل هذه في التعابير الفرعية أولًا قبل الانتقال إلى العوامل الأقل أهمية. تُستخدم قوانين الأسبقية في معظم لغات البرمجة عالية المستوى. "نعلم" أن التعبير: a + b * c + d يُجمّع على النحو التالي: a + (b * c) + d إذ أن عملية الضرب ذات أسبقية أعلى موازنةً بعملية الجمع. تحظى لغة سي بوجود 15 مستوى أسبقية بفضل مجموعة العوامل الكبيرة التي تحتويها، يحاول القلة من الناس تذكرها جميعًا. يوضح الجدول 9.2 جميع المستويات، ويصف كلًّا من الأسبقية والارتباط. لم نتكلم عن جميع العوامل المذكورة في الجدول بعد. كن حذدرًا من استخدام نفس الرمز لبعض العوامل الأحادية والثنائية، والموضحة في الجدول أيضًا. العامل الاتجاه ملاحظات () [] <- . من اليسار إلى اليمين 1 ! ~ ++ -- - + (cast) * & sizeof من اليمين إلى اليسار جميع العوامل أحادية * / % من اليسار إلى اليمين عوامل ثنائية + - من اليسار إلى اليمين عوامل ثنائية << >> من اليسار إلى اليمين عوامل ثنائية < =< > => من اليسار إلى اليمين عوامل ثنائية == =! من اليسار إلى اليمين عوامل ثنائية & من اليسار إلى اليمين عامل ثنائي ^ من اليسار إلى اليمين عامل ثنائي \ من اليسار إلى اليمين عامل ثنائي && من اليسار إلى اليمين عامل ثنائي \\ من اليسار إلى اليمين عامل ثنائي :? من اليمين إلى اليسار 2 = =+ وجميع عوامل الإسناد المركّبة من اليمين إلى اليسار عوامل ثنائية , من اليسار إلى اليمين عامل ثنائي [جدول 9.2. أسبقية العوامل وترابطها] حيث أن: الأقواس بهدف تجميع التعابير، وليس استدعاء الدوال. هذا العامل غير مألوف، راجع القسم 1.4.3. السؤال هنا هو، كيف أستطيع الاستفادة من هذه المعلومات؟ من المهم طبعًا أن تكون قادرًا على كتابة تعابير تعطي قيمًا صحيحة بمعرفة ترتيب تنفيذ العمليات، إضافةً إلى فهم وقراءة تعابير مكتوبة من مبرمجين آخرين. تبدأ خطوات كتابة تعبير أو قراءة تعبير مكتوب بالعثور على العامل الأحادي والمُعاملات المرتبطة معه، وهذه ليست بالمهمة الصعبة ولكنها تحتاج إلى بعض التمرين، بالأخص عندما تعرف أنه يمكن استخدام العوامل عددًا من المرات الاعتباطية بجانب مُعاملاتها، مثل التعبير التالي باستخدام العامل * الأحادي: a*****b يعني التعبير السابق أن المتغير a مضروبٌ بقيمة ما، وهذه القيمة هي تعبير يتضمن b وعددًا من عوامل * الأحادية. تحديد العوامل الأحادية في التعبير ليست بالمهمة الصعبة، إليك بعض القواعد التي يجب أن تلجأ إليها: العاملان "++" و "-" أحاديان في جميع الحالات. العامل الذي يقع على يمين المُعامل مباشرةً هو عامل ثنائي (في حالة لم تتحقق القاعدة 1)، إذا كان العامل الذي يقع على يمين المُعامل ذاك ثنائيًّا. جميع العوامل الواقعة على يسار المُعامل أحادية (في حالة لم تتحقق القاعدة 2). يمكنك دائمًا التفكير بعمل العوامل الأحادية أولًا قبل العوامل الأخرى بسبب أسبقيتها المرتفعة، إذ من الأشياء التي يجب عليك الانتباه عليها هي مواضع العاملين "++" و "--" إذا كانا قبل أو بعد المُعامل، فعلى سبيل المثال يحتوي التعبير التالي: a + -b++ + c على عاملين أحاديين مُطبقّان على b. ترتبط العوامل الأحادية من اليمين إلى اليسار، إذًا على الرغم من قدوم - أولًا، يُكتب التعبير على النحو التالي (باستخدام الأقواس للتوضيح): a + -(b++) + c تصبح الحالة أكثر وضوحًا إذا استُخدم العامل في البداية prefix بدلًا من النهاية postfix مثل عامل زيادة أو نقصان، ويكون الترتيب من اليمين إلى اليسار في هذه الحالة أيضًا، ولكن العوامل ستظهر متتاليةً بجانب بعضها بعضًا. بعد تعلُّمنا لطريقة فهم العوامل الأحادية، أصبح من السهل قراءة التعبير من اليسار إلى اليمين، وعندما تجد عاملًا ثنائيًا أبقِه في بالك، وانظر إلى يمينه؛ فإذا كان العامل الثنائي التالي ذو أسبقية أقل فسيكون العامل الذي تنظر إليه (الذي تبقيه في بالك) هو جزء من تعبير جزئي عليك تقييم قيمته قبل أي خطوة أخرى؛ أما إذا كان العامل الثنائي التالي من نفس الأسبقية فأعِد تنفيذ العملية حتى تصل إلى عامل ذو أسبقية مختلفة؛ وعندما تجد عاملًا ذا أسبقية منخفضة، قيّم قيمة التعبير الجزئي الواقع على يسار العامل وفقًا لقوانين الارتباط؛ أما إذا وجدت عاملًا ذا أسبقية عالية فانسَ جميع ما سبقه، إذ أن المُعامل الواقع على يسار العامل عالي الأسبقية هو جزءٌ من تعبير جزئي آخر يقع على الطرف الأيسر وينتمي إلى العامل الجديد. لا تقلق إذا لم تضّح لديك الصورة بعد، إذ يواجه العديد من مبرمجي لغة سي مشكلات تتعلق بهذه النقطة، ويعتادون فيما بعد على تجميع التعابير "بنظرة عين"، دون الحاجة لتطبيق القوانين مباشرةً. لكن الأمر المهم هنا هو الخطوة التي تلي تجميعك لهذه التعابير، أتذكر "التحويلات الحسابية الاعتيادية"؟ إذ فسَّرت هذه التحويلات كيف يمكنك التنبؤ بنوع التعبير عن طريق النظر إلى المُعاملات الموجودة. والآن إذا مزجت أنواعًا مختلفة في تعبير معقد، ستُحدّد أنواع التعابير الجزئية فقط من خلال أنواع المُعاملات الموجودة في التعبير الجزئي، ألقِ نظرةً على المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int i,j; float f; i = 5; j = 2; f = 3.0; f = f + j / i; printf("value of f is %f\n", f); exit(EXIT_SUCCESS); } [مثال 11.2] قيمة الخرج هي 3.0000 وليس 5.0000 مما يفاجئ البعض الذي اعتقد أن القسمة ستكون قسمة أعداد حقيقية فقط لأن متغير من نوع float كان موجودًا في التعليمة. كان عامل القسمة بالطبع يحتوي على متغيرين من نوع int فقط على الجانبين، لذا أُجريت العملية الحسابية على أنها قسمة أعداد صحيحة وأنتجت صفرًا، واحتوى عامل الجمع على float و int على طرفيه، وبذلك -وحسب قوانين التحويلات الحسابية الاعتيادية- يُحوَّل النوع int إلى float، وهو النوع الصحيح لإجراء عملية الإسناد أيضًا، مما أعفانا من تحويلات أخرى. استعرض القسم السابق عن تحويل الأنواع casts طريقةً لتغيير نوع التعبير من نوعه الطبيعي إلى النوع الذي تريده، ولكن كُن حذرًا، إذ سيستخدم التحويل التالي قسمة صحيحة: (float)(j/i) ثم يحوّل النتيجة إلى float، وللمحافظة على باقي القسمة، يجب عليك كتابة التحويل بالطريقة: (float)j/i مما سيجبر استخدام القسمة الحقيقية. الأقواس كما وضّح المثال السابق، يمكنك تجاوز أسبقية وارتباط لغة سي الاعتيادية عن طريق استخدام الأقواس. لم يكن للأقواس أي معنًى آخر في لغة سي القديمة، ولم تضمن أيضًا ترتيب تقييم القيمة ضمن التعابير، مثل: int a, b, c; a+b+c; (a+b)+c; a+(b+c); إذا كان عليك استخدام متغيرات مؤقتة للحصول على ترتيب التقييم كما أردته، وهو أمر مهم إذا كنت تعرف أن هناك بعض التعابير التي تكون عرضةً للطفحان overflow، ولتجنُّب هذا الأمر عليك أن تعدّل ترتيب تقييم التعبير. ينص معيار سي على أن تقييم التعبير يجب أن يحدث بناءً على الترتيب المحدد وفق الأسبقية وتجميع التعابير، ويمكن للمصرّف أن يعيد تجميع التعابير إن لم يؤثر ذلك على النتيجة النهائية بهدف زيادة الكفاءة. على سبيل المثال، لا يمكن للمصرّف أن يعيد كتابة التعبير التالي: a = 10+a+b+5; إلى: a = 15+a+b; إلا في حالة تأكُّده من أن القيمة النهائية لن تكون مختلفةً عن التعبير الأولي الذي يتضمن قيم a وb، وهذه الحالة محققةٌ إذا كان المتغيران من نوع عدد صحيح عديم الإشارة، أو عدد صحيح ذو إشارة وكانت العملية لا تتسبب في بإطلاق استثناء عند التشغيل run-time exception والناتج عن طفحان. الآثار الجانبية نعيد ونكرر التحذير الوارد بشأن عوامل الزيادة: ليس من الآمن استخدام المتغير ذاته أكثر من مرة في نفس التعبير، وذلك في حالة كان تقييم التعبير يغيّر من قيمة المتغير ويؤثر على القيمة النهائية للتعبير، وذلك بسبب التغيير (أو التغييرات) "المحفوظة" والمُطبّقة فقط عند الوصول لنهاية التعليمة. على سبيل المثال التعبير f = f+1 آمن على الرغم من ظهور المتغير f مرتين في تعبير يغير من قيمتها، والتعبير ++f آمن أيضًا، ولكن ;f = f++ غير آمن. تنبع المشكلة من استخدام عامل الإسناد أو عوامل الزيادة والنقصان أو استدعاء دالة تغيّر من قيمة متغير خارجي External مُستخدم في تعبير ما، وتُعرف هذه المشاكل باسم "الآثار الجانبية Side Effects"، ولا تحدد سي ترتيب حدوث هذه الآثار الجانبية ضمن تعبير ما (سنتوسّع لاحقًا بخصوص هذه المشكلة، ونناقش "نقاط التسلسل Sequence points"). ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: الثوابت وسلاسل الهروب في لغة سي C المقال السابق: التحويلات ما بين الأنواع في تعابير لغة سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

سنتعرف في هذا المقال عن كيفية إجراء التحويلات ما بين الأنواع في تعابير لغة سي C التعابير والعمليات الحسابية من الممكن أن تكون التعابير في لغة سي معقدةً بعض الشيء نظرًا لاستخدام عدد من الأنواع المختلفة والعوامل operators في التعبير الواحد. سيشرح هذا القسم من الكتاب كيفية عمل التعابير هذه، وقد نتطرق للتفاصيل الصغيرة في بعض الأحيان، لذلك سيتوجب عليك قراءتها عدّة مرات حتى تتحقق من فهمك للفكرة. دعنا نبدأ أولًا ببعض المصطلحات، إذ تُبنى التعابير في لغة سي من مزيجٍ يتكون من العوامل والمُعاملات operands. لنأخذ على سبيل المثال التعبير التالي: x = a+b*(-c) لدينا العوامل = و + و * و -، والمُعاملات التي هي المتغيرات x و a و b و c، كما يمكنك ملاحظة القوسين أيضًا اللذين يمكن استخدامهما في تجميع التعبيرات الجزئية مثل c-. تنقسم معظم مجموعة عوامل لغة سي الواسعة إلى عوامل ثنائية binary operators تأخذ مُعاملين، أو عوامل أحادية unary operators تأخذ مُعاملًا واحدًا؛ ففي مثالنا كان - مُستخدمًا مثل عاملٍ أحادي، ويؤدي دورًا مختلفًا عن عامل الطرح الثنائي الذي يُمثّل بالرمز ذاته. قد تنظر إلى الفرق بأنه لا يستحق الذكر وأن وظيفة العامل ذاتها أو متشابهة في الحالتين، ولكنه على النقيض تمامًا فإنه يستحقّ الذكر، لأن لبعض العوامل -كما ستجد لاحقًا- شكل ثنائي وآخر أحادي وكلّ وظيفة مختلفة كاملًا عن الأخرى، ويُعد عامل الضرب الثنائي * الذي يعمل عمل الموجّه باستخدام المؤشرات في حالته الأحادية مثالًا جيدًا على ذلك. تتميز لغة سي بأن العوامل قد تظهر بصورةٍ متتالية دون الحاجة للأقواس للفصل فيما بينهما في تعبيرٍ ما، إذ يمكننا كتابة المثال السابق على النحو التالي وسيظلّ تعبيرًا صالحًا. x = a+b*-c; بالنظر إلى عدد العوامل في لغة سي والطريقة الغريبة التي تعمل بها عملية الإسناد، تُعد أسبقية precedence العامل وارتباطه associativity مسألةً هامةً جدًا بالنسبة لمبرمجٍ بلغة سي موازنةً باللغات الأخرى، وستُناقش هذه النقطة بالتفصيل بعد التكلم عن أهمية عوامل العمليات الحسابية. لكن علينا قبل ذلك أن ننظر إلى عملية تحويل النوع التي قد تحصل. التحويلات تسمح لغة سي بمزج عدّة أنواع ضمن التعبير الواحد، وتسمح أيضًا بالعوامل التي يؤدي استخدامها إلى تحويلات للأنواع ضمنيًا، يصف هذا القسم الطريقة التي تحدث بها هذه التحويلات. ينبغي على مبرمجي لغة سي القديمة (التي سبقت المعيار) قراءة هذا القسم بانتباه، إذ تغيّرت العديد من القواعد وبالأخص التحويل من float إلى double والتحويل من أنواع الأعداد الصحيحة short، كما أن القواعد الأساسية في حفظ القيم value preserving قد تغيرت جدًأ في لغة سي المعيارية. على الرغم من عدم ارتباط هذه المعلومة مباشرةً في هذا السياق، تجدر الإشارة هنا إلى أن أنواع الأعداد العشرية floating والصحيحة تُعرف باسم الأنواع الحسابية arithmetic types وتدعم لغة سي عدة أنواع أخرى، أبرزها أنواع المؤشر pointer. تنطبق القوانين التي سنناقشها هنا على التعابير التي تحتوي الأنواع الحسابية فقط، إذ أن هناك بعض القواعد الإضافية عند إضافة أنواع مؤشر مع الأنواع الحسابية إلى هذا المزيج وسنناقشها لاحقًا. إليك أنواع التحويلات المتنوعة في التعابير الحسابية: الترقيات العددية الصحيحة integral promotions. التحويلات بين الأنواع العددية الصحيحة. التحويلات بين الأنواع العددية العشرية. التحويلات ما بين الأنواع العددية الصحيحة والعشرية. سبق وأن ناقشنا التحويلات بين الأنواع العددية الصحيحة في مقال الأنواع الحقيقية والصحيحة في لغة سي فقرة الأعداد الصحيحة، وما سنفعله في الوقت الحالي هو تحديد طريقة عمل التحويلات الأخرى، ومن ثم سننظر متى يجب استخدامها، عليك أن تحفظ هذه التحويلات عن ظهر قلب إذا أردت أن تصبح مبرمجًا بارعًا بلغة سي. من الأشياء المختلف عليها التي قدمها المعيار، هي قواعد الحفاظ على القيمة value preserving، إذ تتطلب معرفةً معينةً من الحاسوب الهدف الذي ينفذ البرنامج من أجل معرفة نوع القيمة الناتجة من التعبير. عندما كنا نصادف في السابق نوعًا عديم الإشارة ضمن تعبير ما، كان هذا يعني ضمانًا بأن القيمة الناتجة من نوع unsigned أيضًا، ولكن في الوقت الحالي النتيجة ستكون من نوع unsigned فقط إذا كان التحويل يتطلب ذلك، وهذا يعني أنه في معظم الحالات ستكون النتيجة من نوع signed. السبب في هذا التغيير هو تقليل القيم التي قد تفاجئك عند مزج قيم من نوع ذو إشارة مع آخر عديم الإشارة، ففي معظم الحالات لا تعرف سبب هذا التغيير، وكان الدافع هنا التحويل إلى نتيجة "أكثر استخدامًا وطلبًا". الترقية العددية الصحيحة أقل العمليات الحسابية دقةً في لغة سي هي باستخدام نوع الأعداد الصحيحة int، لذلك تحصل هذه التحويلات ضمنيًّا في كل مرة تُستخدم الكائنات المذكورة في الأسفل ضمن تعبيرٍ ما. التحويل مُعرّف كما يلي: عند تطبيق الترقية العددية الصحيحة إلى نوع short أو char (أو حقل البِت bitfield أو نوع المعدّد enumeration type الذَين لم نتطرق إليهما بعد): ستُحّول القيمة إلى int، إذا كان من الممكن للمتغير تخزين جميع قيم النوع الأصل. عدا ذلك، ستُحوَّل إلى unsigned int. يحفظ هذا التحويل كلًا من القيمة والإشارة الخاصة بالقيمة الأصلية، تذكر أن موضوع معاملة نوع char بإشارة أو دون إشارة يعود إلى التنفيذ. تُطبَّق هذه الترقيات على نحوٍ متكرر بمثابة جزءٍ من التحويلات الحسابية الاعتيادية ومُعاملات عوامل الإزاحة الأحادية، مثل + و - و ~، كما تُطبّق عندما يكون التعبير مُستخدمًا مثل وسيط لدالة ما دون أي معلومات عن النوع ضمن نموذج الدالة الأولي function prototype، كما سنشرح لاحقًا. الأعداد الصحيحة ذات الإشارة وعديمة الإشارة هناك الكثير من التحويلات الناتجة بين عدد من أنواع الأعداد الصحيحة المختلفة ومزج نكهاتها (أنواعها) المختلفة ضمن تعبير ما، وعند حدوث ذلك، ستحدث الترقية العددية الصحيحة. يمكن للنوع الجديد الناتج في جميع الحالات أن يخزن جميع القيم التي يستطيع النوع القديم تخزينها، وبذلك يمكن الحفاظ على القيم دون تغييرها. في حال التحويل من عدد صحيح ذو إشارة إلى عدد صحيح عديم الإشارة وكان طول هذا العدد مساويًا لطول (أو أطول من) النوع الأصلي، فلن تتغير القيمة بعد التحويل إذا كان العدد ذو الإشارة موجبًا؛ أما إذا كانت القيمة سالبة فهذا يعني تحويلها إلى صيغة ذات إشارة للنوع الأطول وجعلها عديمة الإشارة عن طريق إضافة قيمتها إلى القيمة العظمى التي يستطيع النوع عديم الإشارة تخزينها زائد واحد. تُحافظ هذه العملية على نمط البِتّات الأصلي للأرقام الموجبة وتضمن "خانة الإشارة الموسّعة" للأرقام السالبة وذلك في نظام المتمّم الثنائي. لا يوجد هناك أي حالات "طفحان overflow" في جميع حالات تحويل عدد صحيح إلى نوع عديم إشارة قصير، فالنتيجة معرّفةٌ وفق "الباقي غير السالب مقسومًا على القيمة العظمى للرقم عديم الإشارة الذي يمكن تمثيله باستخدام النوع القصير زائد واحد". يعني هذا ببساطة أنه في بيئة تعمل بنظام المتمم الثنائي، تُنسخ البِتات منخفضة الترتيب low-order إلى الهدف ويكون التخلُّص من البتات مرتفعة الترتيب high-order. قد تحصل بعض المشاكل عند تحويل العدد الصحيح إلى نوع ذي إشارة قصير إن لم يكن هناك مساحةٌ كافيةٌ لتخزين القيمة، وفي هذه الحالة تكون النتيجة حسب التنفيذ implementation defined، كما قد يتوقع معظم من اعتاد على سي القديمة أن يُنسخ نمط البِتات منخفضة الترتيب. من الممكن أن يكون البند الأخير مثيرًا للقلق بعض الشيء إذا كنت تتذكر الترقية العددية الصحيحة، لأنك قد تنظر إلى الأمر على النحو التالي: إذا أسندت متغيرًا من نوع char إلى متحولٍ من نوع char، فسيُرقّى المتغير على اليمين إلى نوع من أنوع int. إذًا، هل من الممكن أن يؤدي الإسناد إلى تحويل int إلى char (مثلًا) وتفعيل البند "التعريف حسب التنفيذ"؟ الإجابة هي لا، لأن عملية الإسناد لا تضمّ ترقية الأعداد الصحيحة، لذا لا تقلق. الأعداد العشرية والصحيحة يتخلّص تحويل نوع عدد عشري floating إلى نوع عدد صحيح بسيط من جميع الأجزاء العشرية للقيمة، فإذا كان نوع العدد الصحيح غير قابل لتخزين القيمة المتبقية، فسيصبح لدينا سلوك غير محدد، أي حالة شبيهة بالطفحان overflow. كما ذكرنا سابقًا، لا توجد هناك أي مشكلة إذا حدث التحويل بصورةٍ تصاعدية من float إلى double إلى long double، إذ من الممكن لجميع الأنواع السابقة تخزين جميع القيم التي تتسع في الأنواع الأصغر منها، وبذلك تحصل عملية التحويل دون أي فقدان للمعلومات؛ بينما سينتج في التحويل في الاتجاه المعاكس سلوكٌ غير محدد في حال كانت القيمة خارج مجال القيم التي يمكن للنوع تخزينها، وفي حال كانت القيمة ضمن المجال ولكن لا يمكن تخزينها بدقتها بالضبط النتيجة، ستكون واحدةً من القيمتين المجاورتين الممكن تخزينها، ويجري اختيارها حسب التنفيذ، وهذا يعني أن القيمة ستفقد جزءًا من دقتها. التحويلات الحسابية الاعتيادية هناك العديد من التعابير التي تتضمن استخدام تعابير فرعية subexpressions تحتوي على خليطٍ من الأنواع مع عوامل، مثل "+" و"*" وما شابه. إذا كانت للمُعاملات ضمن التعبير عدّة أنواع، فهذا يعني أن هناك بعض التحويلات الواجب إجراؤها حتى تكون النتيجة النهائية من نوع معين، والتحويلات هي: إذا كان أي من المُعاملَين من نوع long double يُحوَّل المُعامل الآخر إلى long double ويكون هذا هو نوع النتيجة. ماعدا ذلك، إذا كان أيٌ من المُعاملَين من نوع double، يُحوَّل المُعامل الآخر إلى double ويكون هذا هو نوع النتيجة. ماعدا ذلك، إن كان أي من المُعاملَين من نوع float، يُحوًل المُعامل الآخر إلى float ويكون هذا هو نوع النتيجة. ماعدا ذلك، تُطبّق الترقية العددية الصحيحة لكلا المُعاملين حسب التحويلات التالية: إذا كان أيٌ من المُعاملَين من نوع unsigned long int، يُحوَّل المُعامل الآخر إلى unsigned long int ويكون هذا نوع النتيجة. ماعدا ذلك، إذا كان أيٌ من المُعاملَين من نوع long int، يُحوَّل المُعامل الآخر إلى long int ويكون هذا هو نوع النتيجة. ماعدا ذلك، إذا كان أيٌ من المُعاملَين من نوع unsigned int، يُحوَّل المُعامل الآخر إلى unsigned int ويكون هذا نوع النتيجة. ماعدا ذلك، يجب أن يكون كلا المُعاملين من نوع int وعلى هذا نوع النتيجة أيضًا. يتضمن المعيار جملةً غريبة: "يمكن تمثيل قيم المُعاملات من نوع الأعداد العشرية ونتائج تعابيرها بدقة ومجال أكبر من المطلوبة بالنسبة لنوعها، بالتالي لا يحدث تغيير للأنواع". السبب في هذا هو الحفاظ على معاملة لغة سي القديمة للمتغيرات من أنواع الأعداد العشرية، إذ كانت تُرقّى المتغيرات من نوع float في سي القديمة تلقائيًّا إلى double بالطريقة ذاتها التي تُرقّى متغيرات من نوع char إلى int، لذلك يمكن إنجاز التعبير الذي يحوي متغيرات من نوع float فقط كما لو كانت المتغيرات من نوع double، ولكن نوع النتيجة سيكون دائمًا float. التأثير الوحيد لهذه العملية هو على حساب الأداء، وهو غير مهم لمعظم المستخدمين؛ ويُحدَّد ما إذا كانت التحويلات ستُطبّق أم لا، وأي نوع منها سيطبّق، عند الوصول إلى العامل operator. لا تسبّب التحويلات بين الأنواع ومزجها أي مشكلات عمومًا، ولكن هناك بعض النقاط التي يجب الانتباه إليها؛ إذ يُعد المزج بين الأنواع ذات الإشارة وعديمة الإشارة بسيطًا إلى أن يحتوي النوع ذو الإشارة قيمة سالبة، إذ لا يمكن تمثيل قيمته باستخدام متغير عديم الإشارة، وعلينا إيجاد حل لهذه المشكلة. ينص المعيار على أن نتيجة تحويل عدد سالب إلى نوع عديم الإشارة هي أكبر قيمة يمكن تخزينها في النوع عديم الإشارة زائد واحد مضافةً إلى العدد السالب، ولأن الطفحان غير ممكن الحدوث في الأنواع عديمة الإشارة فالنتيجة دائمًا معرّفة على المجال. ولنأخذ int بطول 16 بِت مثالًا، إذ أن مجال النوع عديم الإشارة هو 0 إلى 65535، وبتحويل قيمة سالبة (ولتكن "7-") للنوع هذا يجب إضافة 7- إلى 65536 الذي يعطينا الناتج 65529. يحتفظ المعيار بالطريقة القديمة في لغة سي، إذ يُسند نمط البتات في الرقم ذي الإشارة إلى الرقم عديم الإشارة، والطريقة التي يصفها المعيار هي الطريقة ذاتها التي تنتج عن إسناد نمط بِتّات على حاسوب يعمل بنظام المتمم الثنائي، وعلى أنظمة المتمم الأحادي أن تبذل مزيدًا من المجهود لتصل للنتيجة المرجوّة. لتوضيح الأمر أكثر، سينتج عن رقمٍ صغيرٍ سالب رقمٌ كبيرٌ موجب عند تحويله إلى نوع عديم الإشارة، وإذا لم تُعجبك هذه الطريقة فحاول التفكير بطريقةٍ أفضل من هذه. يُعد إسناد رقم سالب إلى متغير عديم الإشارة خطأً فادحًا، وستكون عواقب هذا الخطأ على عاتقك. من السهل القول "لا تفعل هذا"، ولكن الأمر قد يحدث عن طريق الخطأ وفي هذه الحالة ستكون النتائج مفاجئة جدًا. ألقِ نظرةً على المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int i; unsigned int stop_val; stop_val = 0; i = -10; while(i <= stop_val){ printf("%d\n", i); i = i + 1; } exit(EXIT_SUCCESS); } [مثال 7.2] ربما تتوقع أن يطبع البرنامج لائحة قيم من "10-" إلى "0"، لكن هذا خاطئ، إذ تكمن المشكلة هنا في الموازنة؛ أي يُوازَن المتغير i الذي يخزن القيمة 10- مع متغير عديم الإشارة يخزن القيمة 0، ووفقًا لقواعد الحساب (استذكرها إن أردت) يجب أن نحوّل كلا النوعين إلى unsigned int أوّلًا ومن ثم نجري الموازنة، وتصبح القيمة 10- مساوية 65526 على الأقل (تفقد ملف الترويسة <limits.h>) بعد تحويلها، وتُوازن فيما بعد مع 0 وهي أكبر من القيمة كما هو واضح، وبذلك لا تُنفّذ الحلقة التكرارية إطلاقًا. العبرة هنا هو أنه عليك تجنُّب استخدام الأعداد عديمة الإشارة إلا في حالة استخدامك المقصود لها، وعندما تستخدمها انتبه جيّدًا بخصوص مزجها مع الأعداد ذات الإشارة. المحارف العريضة كما ذكرنا سابقًا، يسمح المعيار بمجموعات المحارف الموسّعة، إذ يمكنك استخدام ترميز الإدخال بالإزاحة shift-in والإخراج بالإزاحة shift-out، التي تسمح بتخزين المحارف متعددة البايتات في سلاسل نصية اعتيادية في لغة سي، والتي في حقيقة الأمر مصفوفات من نوع char كما سنتعرف لاحقًا؛ أو يمكنك استخدام التمثيل الذي يستخدم أكثر من بايت واحد لتخزين كل محرف من المحارف. يمكننا استخدام سلاسل الإزاحة فقط في حالة معالجة المحارف بترتيب محدد، إذ إن الطريقة عديمة الفائدة في حال أردت إنشاء مصفوفة محارف والوصول إليهم بغض النظر عن ترتيبهم. إليك مثالًا استخدمناه سابقًا مضافًا إليه أدلة indexes مصفوفة منطقية وفعلية: 0 1 2 3 4 5 6 7 8 9 (actual array index) a b c <SI> a b g <SO> x y 0 1 2 3 4 5 6 7 (logical index) حتى لو استطعنا الوصول إلى المُدخلة "الصالحة correct" ذات الدليل "5" في المصفوفة، فلن تنتهِ المشكلة، إذ لا يمكن تمييز النتيجة التي حصلنا عليها إن كانت مرمّزة أو هي "g" حرفيًّا. الحل الواضح لهذه المشكلة هو استخدام قيم مميّزة لجميع المحارف في مجموعة المحارف التي نستخدمها، لكن هذا الأمر يتطلب مزيدًا من البتات الموجودة في char اعتيادي، وأن نكون قادرين على تخزين كل قيمة على نحوٍ منفصل دون استخدام تقنية الإزاحة أو أي تقنية تعتمد على موضع القيم، وهذا هو الغرض من استخدام النوع wchar_t؛ إذ يُعدّ هذا النوع مرادفًا لأنواع الأعداد الصحيحة الأخرى (يمكنك الاطلاع على تعريفه في ملف الترويسة "")، وهو نوعٌ معرّفٌ حسب التنفيذ ويُستخدم في تخزين المحارف الموسعة عندما تريد إنشاء مصفوفة منها. يضمن المعيار التفاصيل التالية المتعلقة بقيمة المحارف العريضة: يستطيع المتغير من نوع wchar_t تخزين قيم فريدة لكل محرف من أكبر مجموعة محارف يدعمها التنفيذ. المحرف الفارغ null قيمته الصفر. تماثل قيمة ترميز كل محرف من مجموعة المحارف الأساسية (ألقِ نظرةً على مقال المحارف المُستخدمة في لغة C فقرة الأبجدية الاعتيادية) في النوع wchar_t القيمة المُخزنة في char. هناك دعم أكبر لطريقة ترميز المحارف هذه، مثل السلاسل النصية strings التي تكلمنا عنها سابقًا، إذ تُنفَّذ على أنها مصفوفة من المحارف char، مع أن قيمتها تبدو على النحو التالي: "a string" للحصول على سلاسل نصية من نوع wchar_t، اكتب السلسلة النصية كما هي مسبوقة بالحرف L، على سبيل المثال: L"a string" علينا أن نفهم الفرق بين المثالين السابقين، إذ أن السلاسل النصية هي في حقيقة الأمر مصفوفات وعلى الرغم من غرابة الأمر إلا أنّنا نستطيع استخدام دليل المصفوفة عليها: "a string"[4] L"a string"[4] كلا التعبيرين السابقين صالح، إذ أن التعبير الأول من نوع char وقيمته ممثلةٌ بالحرف r (تذكر أن دليل المصفوفات يبدأ من صفر وليس واحد)، والتعبير الثاني من نوع wchar_t وقيمته ممثلةٌ أيضًا بالحرف r. يصبح الأمر مثيرًا للاهتمام عند استخدامنا للمحارف الموسعة، إذ تظهر لنا بعض المشكلات إذا استخدمنا الترميز <a> و <b> للدلالة على محارف "إضافية" عن مجموعة المحارف الاعتيادية، أي ترميز هذه المحارف باستخدام تقنية إزاحة ما، لاحظ المثالين: "abc<a><b>"[3] L"abc<a><b>"[3] الحالة الثانية سهلة الفهم، فهي مصفوفةٌ من نوع wchar_t والترميز الموافق لها يبدأ بالمحرف <a> أيًّا كان هذا الترميز (لنفترض أنه ترميز إلى الحرف اليوناني الموافق)؛ أما الحالة الأولى فهي غير ممكنة التنبؤ، إذ أن النوع هو char بلا شك لكن قيمته هي وسم الإدخال بالإزاحة غالبًا. كما هو الحال مع السلاسل النصية، هناك ثوابت محارف عريضة، مثل 'a' التي لها نوع char وقيمة الترميز متجاوبة مع قيمة المحرف a، أما المحرف التالي: L'a' فهو ثابت من نوع wchar_t، وعند استخدام المحارف متعددة البايتات في المثال الذي سبقه، فهذا يعني أن قيمته تساوي محارف متعددة في محرف ثابت واحد على سبيل المثال: 'xy' في الحقيقة، يُعد هذا التعبير صحيحًا ولكنه يعني شيئًا طريفًا. وسيُحوَّل المحرف متعدد البايتات في المثال الثاني إلى قيمة wchar_t الموافقة. إذا لم تفهم جميع التفاصيل المتعلقة بالمحارف العريضة، فكل ما هنالك قوله هو أننا حاولنا أفضل ما لدينا لشرحها، عُد مرةً أخرى لاحقًا واقرأها من جديد، لعل التفاصيل تصبح مفهومة عندها. تدعم المحارف العريضة عمليًّا استخدام مجموعات المحارف الموسعة في لغة سي وستفهمها حالما تعتاد عليها. التحويل بين الأنواع في بعض الأحيان، ينتج نوع بيانات من تعبير ما ولكنك لا تريد استخدام هذا النوع، وتريد تحويله قسريًّا إلى نوع مختلف، وهذا هو الغرض من التحويل بين الأنواع casts. عند وضع اسم النوع بين قوسين على النحو التالي: (int) فأنت تنشئ هنا عاملًا أحاديًا unary operator يُسمّى بالتحويل بين الأنواع cast، إذ يغير التحويل بين الأنواع قيمة التعبير الواقع على يمينه إلى النوع المحدد بداخل الأقواس. على سبيل المثال، إذا كنت تجري عملية القسمة بين عددين صحيحين a/b فسيستخدم التعبير الناتج قسمة الأعداد الصحيحة ويتخلص من أي باقي، ويمكنك استخدام متغيرات وسيطة من نوع أعداد عشرية للحفاظ على الجزء العشري من القيمة الناتجة أو استخدام التحويل بين الأنواع. يوضح المثال التالي الطريقتين: #include <stdio.h> #include <stdlib.h> /* * Illustrates casts. * For each of the numbers between 2 and 20, * print the percentage difference between it and the one * before */ main(){ int curr_val; float temp, pcnt_diff; curr_val = 2; while(curr_val <= 20){ /* * % difference is * 1/(curr_val)*100 */ temp = curr_val; pcnt_diff = 100/temp; printf("Percent difference at %d is %f\n", curr_val, pcnt_diff); /* * Or, using a cast: */ pcnt_diff = 100/(float)curr_val; printf("Percent difference at %d is %f\n", curr_val, pcnt_diff); curr_val = curr_val + 1; } exit(EXIT_SUCCESS); } [مثال 8.2] الطريقة الأسهل لتتذكر الاستخدام الصحيح للتحويل بين الأنواع هو كتابته وكأنك تُصرّح عن متحول من نوع تريده، ومن ثم ضع الأقواس حول التصريح بالكامل واحذف اسم المتغير، مما سيعطيك التحويل بين الأنواع. يوضح الجدول 6.2 بعض الأمثلة البسيطة، قد تلاحظ أن بعض الأنواع لم تُقدّم بعد، لكن سيتوضّح التحويل بين الأنواع أكثر عند استخدام الأنواع المعقدة. تجاهل الأمثلة التي لا تفهمها بعد، لأنك ستكون قادرًا على استخدام هذا الجدول مثل مرجعٍ لاحقًا. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } التصريح التحويل بين الأنواع النوع ;int x (int) int ;float f (float) float ;char x[30] (char [30]) مصفوفة من char ;int *ip (* int) مؤشر إلى int ;()int (*f) (() (*) int) مؤشر لدالة تُعيد النوع int [جدول 6.2. التحويل بين الأنواع] ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: العوامل في لغة سي C المقال السابق: الأنواع الحقيقية والصحيحة في لغة سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

سنتطرق في هذا المقال إلى الأنواع الحقيقية والصحيحة في لغة سي C الأنواع الحقيقية سيكون من الأسهل التعامل مع الأنواع الحقيقية real أوّلًا، لأن هناك تفاصيل وتعقيدات أقل بخصوصها موازنةً بنوع الأعداد الطبيعية Integers. يقدّم المعيار تفاصيلًا جديدةً بخصوص دقة ونطاق الأعداد الحقيقية، ويمكن أن تجدهم في ملف الترويسة "float.h" الذي سنناقشه بالتفصيل لاحقًا. هذه التفاصيل مهمة جدًا ولكنها ذات طبيعة تقنية للغاية، ولن تُفهم بالكامل غالبًا إلا من قبل مختصّي التحليل العددي. أنواع الأعداد الحقيقية هي: float: العدد العشري double: العدد العشري مضاعف الدقة long double: العدد العشري الأدق يسمح لنا كل واحد من هذه الأنواع بتمثيل الأعداد الحقيقية بطريقة معينة باستخدام الحاسوب؛ فإذا كان هناك نوعٌ واحدٌ لتمثيل الأعداد الحقيقية، فهذا يعني أن تمثيل الأعداد سيكون متماثلًا بغض النظر عن الاستخدام؛ أما إذا كان العدد يتجاوز الثلاثة أنوع، فهذا يعني أن لغة سي لن تستطيع تصنيف أي من الأنواع الإضافية. يُستخدم النوع float للتمثيل السريع والبسيط للأرقام الصغيرة وهو مشابهٌ للنوع REAL في لغة فورتران؛ أما double فيستخدم للدقة الإضافية، و long double لدقة أكبر من سابقتها. التركيز الأساسي هنا هو أنّ الزيادة في "دقة" كلٍ من float و double و long double تعطي لكل نوعٍ نطاقًا ودقّة مساويةً للنوع الذي يسبقها على الأقل، فأخذ القيمة من متغير نوع double مثلًا، وتخزينها في متغير من نوع long double، يجب أن يمثِّل القيمة ذاتها. لا توجد هناك أي متطلبات للأنواع الثلاثة من متغيرات الأعداد "الحقيقية" لتختلف في خصائصها، وبالتالي إن لم توفّر الآلة سوى نوع واحدٍ من أنواع متغيرات الأعداد الحقيقية، فيمكن عندئذٍ تمثيل جميع أنواع الأعداد الحقيقية الثلاثة في لغة سي بهذا النوع المتوفِّر. لكن بغض النظر، يجب أن يُنظر إلى هذه الأنواع الثلاثة بأنها مختلفة، وكأنّ هناك فرقٌ بينها حقًأ، وهذا يساعد في نقل البرنامج إلى نظام تختلف فيه هذه الأنواع حقًّا، بحيث لن يظهر لك مجموعةٌ من التحذيرات من المصرّف بخصوص عدم توافق الأنواع التي لم تكُن موجودةً على النظام الأول. تسمح لغة سي بمزج جميع أنواع البيانات العددية في التعابير بعكس كثيرٍ من لغات البرمجة الصارمة بخصوص قواعد كتابتها، وذلك يضم مختلف أنواع الأعداد الصحيحة إضافةً إلى الأعداد الحقيقية وأنواع المؤشرات؛ وعندما يتضمن التعبير مزيجًا من أنواع الأعداد الحقيقية والصحيحة، سيُستدعى تحويلٌ ضمني يعمل بدوره على معرفة نوع المزيج الكلّي الناتج. هذه القواعد مهمةٌ جدًا وتدعى التحويلات الحسابية الاعتيادية usual arithmetic conversions، ومن المفيد أن تتذكرها، إذ سنشرح كامل هذه القواعد لاحقًا، إلا أننا سننظر في الوقت الحالي إلى الحالات التي تتضمن مزيجًا من float و double و long double ونحاول فهمها. الحالة الوحيدة التي نحتاج فيها إجراء التحويلات المذكورة هي عندما يُمزج نوعان من البيانات في تعبير، كما في هو موضح في المثال التالي: int f(void){ float f_var; double d_var; long double l_d_var; f_var = 1; d_var = 1; l_d_var = 1; d_var = d_var + f_var; l_d_var = d_var + f_var; return(l_d_var); } [مثال 1.2] نلاحظ في المثال السابق وجود كثيرٍ من التحويلات القسرية، لنبدأ بأسهلها أوّلًا، ولننظر إلى تعيين القيمة الثابتة 1 لكلٍ من المتغيرات الثلاثة. لا بُد من التنويه (كما سيشير القسم الذي يتكلم عن القيم الثابتة constants لاحقًا) إلى أن القيمة 1 هي من نوع int، أي تمثّل عددًا صحيحًا وليس قيمةً ثابتةً حقيقية، ويحوّل الإسناد قيمة العدد الصحيح إلى نوع العدد الحقيقي المناسب والأسهل للتعامل معه. التحويلات المثيرة للاهتمام تأتي بعدها، وأولها ضمن السطر التالي: d_var = d_var + f_var; ما هو نوع التعبير الذي يتضمن العامل +؟ الإجابة عن هذا السؤال سهلة ما دمت ملمًّا ببعض القواعد؛ إذ يُحوَّل النوع الأقل دقةً ضمنيًا إلى النوع الأكثر دقةً وتُنجز العملية الحسابية باستخدام هذه الدقة، وذلك عندما يجتمع نوعان من الأعداد الحقيقية في التعبير ذاته. يتضمن المثال السابق استخدام كلٍّ من double و float، لذلك تُحوّل قيمة المتغير f_var إلى النوع double وتُضاف فيما بعد إلى قيمة النوع double أي المتغير d_var، وتكون نتيجة هذا التعبير هي من نوع double أيضًا، لذا من الواضح أن عملية الإسناد إلى المتغير d_var صائبة. عملية الجمع الثانية أكثر تعقيدّا، ولكنها ما زالت سهلة الفهم، إذ تُحوّل قيمة المتغير f_var وتُجرى العملية الحسابية باستخدام دقة النوع double، ألا وهي عملية جمع المتغيرين، لكن هناك مشكلة، وهي أن نتيجة عملية الجمع من نوع double، لكن عملية الإسناد من نوع long double، ويكون مجدّدًا الحل البديهي في هذه الحالة هو تحويل القيمة الأقل دقة إلى الأكبر دقّة، وهو ما يُجرى ضمنيًّا قبل عملية الإسناد. الآن بعد أن أخذنا نظرةً سريعةً على الأمثلة السهلة، حان وقت الأمثلة الأكثر صعوبة وهي الحالة التي يتسبب فيها التحويل القسري بتحويل نتيجةٍ بدقةٍ عالية إلى دقةٍ أقل منها، ففي مثل هذه الحالات قد يكون من الضروري خسارة الدقة بطريقة محدّدة من تنفيذ التحويل. ببساطة، يجب أن يحدد التنفيذ طريقة تقريب أو اقتطاعٍ للقيمة، وفي أسوأ الحالات قد يكون نوع الهدف غير قادرٍ على تخزين تلك القيمة الضرورية (على سبيل المثال محاولة جمع أكبر قيمة لعدد إلى نفسه)، وتُعد نتيجة التنفيذ في هذه الحالة غير محددة، والبرنامج يشكو من خطأ ولا يمكنك التنبؤ بتصرفه. لا ضرر من تكرار فكرتنا السابقة، إذ يقصد المعيار بحالة السلوك غير المحدد undefined behaviour معنى اسمه حرفيًا، وحالما يدخل البرنامج منطقة السلوك غير المحدد، يمكن لأي شيء أن يحدث؛ فمن الممكن إيقاف البرنامج من طرف نظام التشغيل مصحوبًا برسالة معيّنة؛ أو قد يحدث شيء غير مُلاحظ ويستمر البرنامج للعمل باستخدام قيم خاطئة مُخزَّنة في المتغير. منع البرنامج من إبداء أي سلوك غير محدّد تعد من مسؤولياتك، فتوخّ الحذر. لتلخيص ما سبق: تُجرى العمليات الحسابية التي تتضمن نوعين باستخدام النوع الأعلى دقّة منهما. قد يتضمن الإسناد خسارة لدقة القيمة في حال كان نوع المتغير الهدف ذو دقة أقل من دقة القيمة التي تُسنَد لهذا المتغير. هناك مزيدٌ من التحويلات التي تُجرى عند مزج الأنواع ضمن تعبير واحد، إذ لم نصِف جميعها بعد. طباعة الأعداد الحقيقية يمكن استخدام دالة الخرج التقليدي printf لتنسيق الأعداد الحقيقية وطباعتها، كما يوجد العديد من الطرق لتنسيق هذه الأعداد، ولكننا سنتطرق إلى طريقة واحدة في الوقت الحالي. يوضح الجدول 4.2 التنسيق الموافق لكل نوعٍ من أنواع الأعداد الحقيقية. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } النوع التنسيق float f% double f% long double Lf% [جدول 4.2. رموز التنسيق للأعداد الحقيقية] ألقِ نظرةً على المثال التالي لتجربة المعلومة السابقة: #include <stdio.h> #include <stdlib.h> #define BOILING 212 /* degrees Fahrenheit */ main(){ float f_var; double d_var; long double l_d_var; int i; i = 0; printf("Fahrenheit to Centigrade\n"); while(i <= BOILING){ l_d_var = 5*(i-32); l_d_var = l_d_var/9; d_var = l_d_var; f_var = l_d_var; printf("%d %f %f %Lf\n", i, f_var, d_var, l_d_var); i = i+1; } exit(EXIT_SUCCESS); } [مثال 2.2] جرّب المثال السابق على حاسوبك الشخصي، ولاحظ النتائج. الأنواع الصحيحة كانت الأنواع الحقيقية أسهل الأنواع، إذ تتصف القوانين الخاصة بالأنواع الصحيحة بتعقيد أكبر، ولكنها ما زالت مفهومة وينبغي تعلُّمها. لحسن الحظ، الأنواع الوحيدة المستخدمة في لغة سي لتخزين البيانات هي الأنواع الحقيقية والصحيحة، إضافةً إلى الهياكل structures والمصفوفات arrays المبنيّة عليهما، إذ لا تحتوي لغة سي على أنواع مميزة للتلاعب بالمحارف، أو التعامل مع القيم البوليانية boolean، وإنما تستخدم الأنواع الصحيحة بدلًا من ذلك، وهذا يعني أنه حالما تفهم الأنواع الصحيحة والحقيقية فأنت تعرف جميع الأنواع. سنبدأ بالنظر إلى الأنواع المختلفة للأعداد الصحيحة وقوانين التحويل فيما بينها. الأعداد الصحيحة البسيطة هناك نوعان من متغيرات الأعداد الصحيحة يطلق عليهما "نكهات flavours"، ويمكن بناء أنواع أخرى انطلاقًا من هذين النوعين كما سنرى لاحقًا، لكن تبقى الأنواع البسيطة int هي الأساس. النوع الأكثر شهرةً هو العدد الصحيح ذو الإشارة signed أو int، أما النوع الأقل شهرة هو العدد الصحيح عديم الإشارة أو unsigned int، ومن المفترض أن تُخزّن القيم في المتغيرات ذات النوع المناسب حسب الآلة التي تشغل البرنامج. عندما تبحث عن نوع بيانات بسيط لتمثيل عدد صحيح، فإن النوع int هو الاختيار البديهي لأي استخدام مُتساهل، مثل عدّاد ضمن حلقة تكرارية قصيرة، إذ لا توجد هناك أي قاعدة تحدّد عدد البتّات التي يخزنها نوع int لقيمةٍ ما، لكنه سيكون دائمًا مساويًا إلى 16 بِت أو أكثر، ويفصِّل ملف الترويسة القياسي "" العدد الفعلي للبتات المُتاحة في تنفيذٍ معين. لم تحتوِ لغة سي القديمة على أية معلومات بخصوص طول متغيّر من نوع int، ولكن الجميع كان يفترض اصطلاحًا أنها على الأقل 16 بِت. في الحقيقة، لا يحدّد ملف الترويسة "" العدد الدقيق للبتات، ولكنه يقدِّم تقديرًا لأعظم عدد وأقل عدد بتات لقيمةٍ في متغيرٍ من نوع int، والقيم التي يحددها هي ما بين 32767 و32767- أي 16 بت فما فوق، سواءٌ كانت عملية المتمم الأحادي أو الثنائي الحسابية مستخدمةُ أم لا، وبالطبع لا يوجد هناك أي قيود من توفير نطاق أكبر في أي الطرفين في حال توفرت الطريقة المناسبة. يتراوح النطاق المحدد وفق المعيار للمتغير من نوع unsigned int من 0 إلى 65535، مما يعني أن القيمة لا يمكن أن تكون سالبة، وسنتكلم بإسهاب عن هذه النقطة لاحقًا. إذا لم تعتَد التفكير بعدد البتات لمتغيّر ما، وبدأت بالقلق عمّا إذا سيؤثر ذلك على قابلية نقل البرنامج كون هذه المشكلة مرتبطةً بوضوح بالآلة (أي الحاسوب الذي يشغّل البرنامج)، فقلقك في محلّه. تأخذ لغة سي قابلية نقل البرنامج على محمل الجدّ كما تدلّك على القيم والمجالات الآمنة، وتشجِّعك أيضًا عوامل العوامل الثنائية bitwise operators على التفكير بعدد البتّات في متغيرٍ ما، لأنها تمنحك الوصول المباشر إلى بتات المتغيرالتي تعالجها بصورةٍ منفردة (كل بت على حدى) أو في مجموعات. ونتيجة لذلك تكوَّن لدى مبرمجي لغة سي المعرفة الكافية بخصوص مشكلات قابلية نقل البرنامج، ممّا يتسبب ببرمجة برامج قابلة للنقل، لكننا لا ننفي هنا إمكانية كتابة برامج غير قابلة للنقل إطلاقًا. متغيرات المحارف المتغير char هو النوع الثاني من أنواع الأعداد الصحيحة البسيطة، فهو نوعٌ آخر من int ولكن بتطبيقٍ مختلف، إذ تُعدّ فكرة تخصيص نوعٍ خاص للتعامل مع المحارف فكرةً جيّدة خاصةً وأن كثيرًا من برامج سي تتعامل بالمحارف، لأن تمثيل القيم باستخدام النوع int يأخذ كثيرًا من المساحة غير الضرورية لتمثيل المحرف. يصف ملف ترويسة الحدود "limits" ثلاثة أشياء عن النوع char ألا وهي: عدد البتات 8 على الأقل. يمكنها تخزين قيمة 127+ على الأقل. القيمة الدنيا للنوع char هي صفر أو أقل، مما يعني أن المجال يتراوح ما بين 0 إلى 127. يحدِّد تنفيذ المتحول char فيما إذا كان سيتصرف تصرُّف المتحولات ذات الإشارة signed أو عديمة الإشارة unsigned. باختصار، تحتل متغيرات المحارف مساحةً أقل من المتغيرات الصحيحة int التقليدية، ويمكن استخدامها لمعالجة المحارف، لكنها تندرج تحت تصنيف الأعداد الصحيحة، ويمكن استخدامها لإجراء العمليات الحسابية كما هو موضح في المثال التالي: include <limits.h> include <stdio.h> include <stdlib.h> main(){ char c; c = CHAR_MIN; while(c != CHAR_MAX){ printf("%d\n", c); c = c+1; } exit(EXIT_SUCCESS); } [مثال 3.2] تشغيل البرنامج في المثال السابق تمرينٌ لك، وربما ستثير النتائج إعجابك. إذا كنت تتسائل عن قيمة CHAR_MIN وCHAR_MAX، فاطّلع على ملف الترويسة limits.h واقرأه. إليك مثالٌ آخر مثيرٌ للإعجاب حقًا، إذ سنستخدم فيه محارف ثابتة constants، والتي يمكن كتابتها بين إشارتين تنصيص أحاديّة على النحو التالي: 'x' لأن القواعد الحسابية تُطبَّق هنا، فسيُحوّل المحرف الثابت السابق ليكون من النوع int، ولكن هذا لا يهم حقًّا لأن قيمة المحرف صغيرة دائمًا ويمكن تخزينها في متغير من نوع char دون فقدان أي دقة (لسوء الحظ هناك بعض الحالات التي لا ينطبق فيها هذا الكلام، تجاهلها في الوقت الحالي). عندما يُطبع محرف باستخدام الرمز c% ضمن دالة printf، يُطبع المحرف كما هو، لكن يمكنك استخدام الرمز d% إذا أردت طباعة قيمة العدد الصحيح الموافقة لهذا المحرف. لماذا استُخدم الرمز d%؟ كما ذكرنا سابقًا، النوع char هو في الحقيقة نوع من أنواع الأعداد الصحيحة. من المهم أيضًا وجود طريقة لقراءة المحارف إلى البرنامج، وتتكفل الدالة getchar بهذه المهمة، إذ تقرأ المحارف من الدخل القياسي standard input للبرنامج وتُعيد قيمةً صحيحةً int موافقة لتخزين هذا المحرف في متغير من نوع char، تخدم هذه القيمة المُمرّرة من نوع int غرضين، هما: تمثيل جميع قيم المحارف الممكنة بواسطتها، إضافةً إلى تمرير قيمة إضافية للدلالة على نهاية الدخل. لا يتسع مجال قيم متغير من نوع char في جميع الحالات لهذه القيمة الإضافية، لذلك يُستخدم النوع int. يقرأ البرنامج التالي الدخل ويعدّ الفواصل والنقاط المُدخلة، وعند وصولة لنهاية الدخل يطبع النتيجة. #include <stdio.h> #include <stdlib.h> main(){ int this_char, comma_count, stop_count; comma_count = stop_count = 0; this_char = getchar(); while(this_char != EOF){ if(this_char == '.') stop_count = stop_count+1; if(this_char == ',') comma_count = comma_count+1; this_char = getchar(); } printf("%d commas, %d stops\n", comma_count, stop_count); exit(EXIT_SUCCESS); } [مثال 4.2] هناك ميزتان نستطيع ملاحظتهما من المثال السابق، الأولى هي الإسناد المتعدّد للعدادين، والثانية هي استخدام الثابت المعرّف EOF؛ وهي قيمة تُمرّر من الدالة getchar في نهاية الدخل وتمثِّل اختصارًا لكلمة نهاية الملف End Of File، وتكون معرفةً ضمن ملف الترويسة ""؛ أما الإسناد المتعدد فهي ميزةٌ شائعةٌ الاستخدام في برامج لغة سي. لنأخذ مثالًا آخر، وليكن برنامجًا لطباعة جميع الأحرف الأبجدية بأحرف صغيرة إذا كان تنفيذك يحتوي على محارف مخزنة بصورةٍ متتالية، أو طباعة نتيجةٍ مثيرةٍ للاهتمام إذا لم يكن كذلك. لا تقدّم لغة سي العديد من الضمانات بترتيب المحارف داخليًّا، لذلك قد يتسبب هذا البرنامج بنتائج مختلفة ويكون غير محمول. #include <stdio.h> #include <stdlib.h> main(){ char c; c = 'a'; while(c <= 'z'){ printf("value %d char %c\n", c, c); c = c+1; } exit(EXIT_SUCCESS); } [مثال 5.2] يذكرنا هذا المثال مرةً أخرى بأن char شكلٌ مختلفٌ من أشكال متغيرات الأعداد الصحيحة ويمكن استخدامه مثل أي عدد صحيح آخر، فهو ليس نوع مميّز بقواعد مختلفة. تصبح المساحة التي يوفرها char موازنةً مع int ملحوظةً ومهمةً عندما يُستخدام الكثير من المتغيرات. تستخدم معظم عمليات معالجة المحارف مصفوفات كبيرة منها وليس محرفًا واحدًا أو اثنين فقط، وفي هذه الحالة يصبح الفرق واضحًا بين الاثنين. لنتخيل سويًّا مصفوفةً مؤلفةً من 1024 متغيرًا من نوع int، تحجز هذه المصفوفة مساحة 4098 بايت (كل بايت 8-بت) من التخزين على معظم الآلات، على افتراض أن طول كل int هو 4 بايت؛ فإذا كانت معمارية الحاسوب تسمح بتخزين هذه المعلومات بطريقة فعّالة، قد تطبّق لغة سي هذا عن طريق متغيرات من نوع char بحيث يأخذ كل متغير بايتًا واحدًا، وبذلك ستأخذ المصفوفة مساحة 1024 بايت، مما سيوفّر مساحة 3072 بايت. لا يهمنا في بعض الحالات إن كان سيوفِّر البرنامج مساحةً أم لا، ولكنه يوفِّرها بغض النظر، ومن الجيد أن تعطينا لغة سي فرصة اختيار نوع المتغير المناسب لاستخدامنا. المزيد من الأنواع المعقدة النوعان السابقان الذين تكلمنا عنهما سابقًا بسيطان، سواءٌ بخصوص تصريحهما أو استخدامهما، ولكن دقتهما في التحكم بالتخزين وسلوكهما غير كافيين في استخدامات نظم البرمجة المعقدة. تقدّم لغة سي أنواعًا إضافية من أنواع الأعداد الصحيحة للتغلُّب على هذه المشكلة وتُقسم إلى تصنيفين، الأنواع ذات الإشارة signed والأنواع عديمة الإشارة unsigned (بالرغم من هذه المصطلحات كلمات محجوز في لغة سي إلا أن معناها يدلّ على غرضها أيضًا)، والفرق بين النوعين واضح؛ إذ يمكن للأنواع ذات الإشارة أن تكون قيمتها سالبة؛ بينما يكون من المستحيل أن تخزِّن الأنواع عديمة الإشارة قيمةً سالبة، وتُستخدم الأنواع عديمة الإشارة في معظم الأحيان لحالتين، هما: إعطاء القيمة دقةً أكبر، أو عندما نضمن أن المتغير لن يخزن أي قيمٍ سالبة في استخدامه، والحالة الثانية هي الحالة الأكثر شيوعًا. تملك الأنواع عديمة الإشارة خاصيةً مميزة ألا وهي أنها ليست عرضةً للطفحان الحسابي overflowing عند إجراء العمليات الحسابية، إذ سيتسبب إضافة 1 إلى متغيرٍ من نوعٍ ذي إشارة يخزّن أكبر قيمة يمكن تخزينها بحدوث طفحان، ويصبح سلوك البرنامج نتيجةً لذلك غير محدّد، ولا يحصل هذا الأمر مع المتغيرات من نوعٍ عديم الإشارة، لأنّها تعمل وفق "باقي قسمة واحد زائد القيمة العظمى التي يمكن للمتغير تخزينها على هذه القيمة"، أي باقي قسمة "max+1)/max)"، والمثال التالي يوضح ما نقصده: #include <stdio.h> #include <stdlib.h> main(){ unsigned int x; x = 0; while(x >= 0){ printf("%u\n", x); x = x+1; } exit(EXIT_SUCCESS); } [مثال 6.2] بفرض أن المتغير x يحتل مساحة 16 بِت، فهذا يعني أن مجال قيمته يترواح بين 0 و 65535، وأن الحلقة التكرارية في المثال ستتكرر لأجل غير مسمّى، إذ أن الشرط التالي محققٌ دائمًا: x >= 0 وذلك بالنسبة لأي متغير عديم الإشارة. يوجد ثلاثة أنواع فرعية لكلٍ من الأعداد الصحيحة ذات الإشارة وعديمة الإشارة، هي: short والنوع الاعتيادي و long، ونستطيع بعد أخذ هذه المعلومة بالحسبان كتابة لائحة بجميع أنواع متغيرات الأعداد الصحيحة في لغة سي باستثناء نوع تخزين المحرف char، على النحو التالي: unsigned short int unsigned int unsigned long int signed short int signed int signed long int ليس مهمًّا استخدام الكلمة المفتاحية signed ويمكن الاستغناء عنها في الأنواع الثلاث الأخيرة، إذ أن نوع int ذو إشارة افتراضيًا، ولكن ينبغي عليك استخدام الكلمة المفتاحية unsigned إذا أردت الحصول على نتيجة مغايرة لذلك. من الممكن أيضًا التخلِّي عن الكلمة المفتاحية int من أي تعليمة تصريح شرط أن تحتوي على كلمة مفتاحية أخرى، مثل long أو short، وسيُفهم المتغير على أنه int ضمنيًّا ولكنه أمرٌ غير محبّذ، على سبيل المثال الكلمة المفتاحية long مساوية للكلمات signed long int. يمنحك النوع long و short تحكّمًا أكبر بمقدار المساحة التي تريد حجزها للمتغير، ولكلّ منهما مجال أدنى محدّد في ملف الترويسة <limits.h>، وهو 16 بِت على الأقل لكل من short و int، و32 بتًا على الأقل للنوع long، سواءً كان ذو إشارة signed أو دون إشارة unsigned. وكما ذكرنا آنفًا من الممكن للتنفيذ أن يحجز مقدارًا يزيد على المقدار الأدنى من البتات إذا أراد ذلك، والقيد الوحيد هنا هو أن حدود المجال يجب أن تكون متساويةً أو محسّنة، وألا تحصل على عددٍ أكبر من البتات في متغيرٍ من نوع أصغر موازنةً بنوعٍ أكبر منه، وهي قاعدة منطقية. أنواع متغيرات المحارف الوحيدة هي signed char و unsigned char، ويتمثّل الفرق بين متغيرات من نوع int و char في أن جميع متغيرات int ذات إشارة إن لم يُذكر عكس ذلك، وهذا لا ينطبق على أنواع المحارف char التي قد تكون ذات إشارة أو عديمة الإشارة اعتمادًا على اختيار المُنفّذ، وعادةً ما يُتخذ القرار بناءً على أسس الكفاءة. يمكنك طبعًا اختيار نوع المتغير قسريًا إذا أردت باستخدام الكلمة المفتاحية الموافقة، ولكن هذه النقطة لا تهمّك إلا في حالة استخدامك لمتغيرات المحارف بنوعها القصير short لتوفير مساحة التخزين. لتلخيص ما سبق: تتضمن أنواع الأعداد الصحيحة short و long و signed و unsigned و النوع الاعتيادي int. النوع الأكثر استخدامًا وشيوعًا هو النوع الاعتيادي int وهو ذو إشارة إلا في حالة تحديد عكس ذلك. يمكن للمتغيرات من نوع char أن تكون ذات إشارة أو عديمة الإشارة حسب تفضيلك، ولكن في حال غياب تخصيصك لها ستُخصّص الحالة الأفضل افتراضيًا. طباعة أنواع الأعداد الصحيحة يمكننا طباعة هذه الأنواع المختلفة أيضًا باستخدام الدالة printf، إذ تعمل متغيرات المحارف بنفس الطريقة التي تعمل بها الأعداد الصحيحة الأخرى، ويمكنك استخدام الترميز القياسي لطباعة محتوياتها (أي العدد الذي يمثل المحرف)، على الرغم من كون القيم الخاصة بها غير مثيرة للاهتمام أو مفيدة في معظم الاستخدامات. نستخدم الرمز c% لطباعة محتويات متغيرات المحارف كما أشرنا سابقًا، كما يمكن طباعة جميع قيم الأعداد الصحيحة بالنظام العشري باستخدام الرمز d% أو ld% لأنواع long، ويوضح الجدول 5.2 المزيد من الرموز المفيدة لطباعة القيم بتنسيقٍ مختلف. لاحظ أنّه في كل حالة تبدأ بالحرف l تُطبع قيمةٌ من نوع long، وهذا التخصيص ليس موجودًا فقط لعرض القيمة الصحيحة بل لتجنُّب السلوك غير المحدد لدالة printf إذا أُدخل الترميز الخاطئ. التنسيق يُستخدم مع c% char (طباعة المحرف) d% القيمة العشرية للأنواع signed int و short و char u% القيمة العشرية للأنواع unsigned int و unsigned short وunsigned char x% القيمة الست عشرية للأنواع int وshort وchar o% القيمة الثمانية للأنواع int وshortوchar ld% القيمة العشرية للنوع signed long lu% lx% lo% كما ذُكر في الأعلى ولكن للنوع long [جدول 5.2. المزيد من رموز التنسيق] سنتكلم على نحوٍ مفصّل حول التنسيق المستخدمة مع الدالة printf لاحقًا. ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: التحويلات ما بين الأنواع في تعابير لغة سي C المقال السابق: البنية النصية لبرامج سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

يشرح هذا المقال تخطيط البرنامج المكتوب بلغة سي C بالإضافة للتعليقات التي يمكن إضافتها عليه والكلمات المفتاحية والمعرفات التي يمكن استخدامها فيه ثم سنعرج على مفهوم التصريح عن المتغيرات في البرنامج. تخطيط البرنامج اعتمدت أمثلتنا حتى اللحظة في تنسيقها على المسافات البادئة indentation والأسطر الجديدة newlines، وهذا الأسلوب في التنسيق شائع في لغات البرمجة التي تنتمي إلى عائلة لغة سي، إذ تُعد هذه اللغات لغات "حرة التنسيق free format" وتُستخدم هذه الحرية في كتابة وتنسيق السطور البرمجية بحيث يحسِّن قراءتها ويبرز تسلسل منطقها. تُستخدم محارف المسافات الفارغة space بما فيها مسافات الجدولة tab الأفقية لإنشاء المسافات البادئة في أي مكان دون أن تؤثّر على عمل البرنامج عدا ضمن المعرِّفات identifiers والكلمات المفتاحية. تعمل الأسطر الجديدة على نحوٍ مماثل لعمل المسافات الفارغة ومسافات الجدولة باستثناء أسطر أوامر المعالج المسبق، الذي يمتلك بنية سطريّة line-by-line. هناك حلان يمكنك اللجوء إليهما في حال كان أحد السطور طويلًا جدًا وغير مريحًا للقراءة، إذ يمكنك استبدال محرف المسافة space بمحرف سطر جديد، بحيث يصبح لديك سطرين بدلًا من سطرٍ واحد. ألقِ نظرةً على المثال التالي للتوضيح: /* a long line */ a = fred + bill * ((this / that) * sqrt(3.14159)); /* the same line */ a = fred + bill * ((this / that) * sqrt(3.14159)); لن تستطيع في بعض الحالات استبدال المحارف بالطريقة السابقة، وذلك بسبب اعتماد المعالج المسبق على "تعليمات" السطر الواحد، ولحلّ هذه المشكلة يمكننا استخدام السلسلة "n\" التي تعني الانتقال لسطرٍ جديد، إذ يصبح هذا المحرف غير مرئي لنظام تصريف لغة سي، ويمكن نتيجةً لذلك استخدام هذه السلسلة في أماكن لا نستطيع استخدام الفراغات فيها في الحالات الاعتيادية، أي ضمن المعرّفات مثلًا أو الكلمات المفتاحية أو السلاسل النصية أو غيرها، وتسبق مرحلة معالجة هذه المحارف مرحلة معالجة ثلاثيات المحارف Trigraphs فقط. /* * Example of the use of line joining */ #define IMPORTANT_BUT_LONG_PREPROCESSOR_TEXT \ printf("this is effectively all ");\ printf("on a single line ");\ printf("because of line-joining\n"); ينبغي أن تُستخدم هذه الطريقة في تقسيم الأسطر (بعيدًا عن أسطر تحكم المعالج المُسبق) في حالة واحدة فقط، ألا وهي لمنع السلاسل النصية الطويلة من أن تختفي إلى اليمين عند النظر لسطور البرنامج. بما أن السطور الجديدة غير مسموحة داخل السلاسل النصية والمحارف الثابتة، قد تعتقد أن هذه الفكرة جيّدة: /* not a good way of folding a string */ printf("This is a very very very\ long string\n"); سيعمل المثال السابق بالتأكيد، ولكن من المحبّذ استخدام ميزة ضمّ السلاسل النصية string-joining التي قُدّمَت ضمن المعيار عند التعامل مع السلاسل النصية: /* This string joining will not work in Old C */ printf("This is a very very very" "long string\n"); يسمح لك المثال الثاني بإضافة الفراغات دون تغيير مضمون السلسلة النصية، إذ إنّ المثال الأول يضيف الفراغات إلى مضمون السلسلة النصية. لكن هل انتبهت أن المثالين يحتويان على خطأ؟ لا يوجد هناك أي مسافة فارغة تسبق الكلمة "long"، مما يعني أن خرج البرنامج سيكون "verylong" دون مسافة بين الكلمتين. التعليق تكلمنا عن التعليق سابقًا وقلنا أن التعليق يبدأ بالمحرفَين "*/" وينتهي بالمحرفين "/*"، ويُترجم التعليق إلى مسافة فارغة واحدة أينما وجد وهو يتبِّع القوانين ذاتها الخاصة بالمسافة الفارغة. من المهم هنا معرفة أن هذا التعليق لا يختفي -كما كان الحال في لغة سي القديمة- ومن غير الممكن وضع التعليق بداخل سلسلة نصية أو محرف ثابت وإلا أصبح جزءًا منهما: /*"This is comment"*/ "/*The quotes mean that this is a string*/" لم تكن لغة C القديمة واضحةً بشأن تفاصيل حذف التعليق، إذ كان من الممكن أن يكون الناتج هنا: int/**/egral(); هو حذف التعليق، أي أن المصرف سينظر للتعليمة السابقة بكونها استدعاءً لدالة اسمها integral، لكنه سيُبدَّل التعليق بالاعتماد على معيار سي بمسافة فارغة وستكون التعليمة السابقة مساويةً للتعليمة التالية: int egral(); التي تصرح عن دالة باسم egral تُعيد قيمةً من نوع int. مراحل الترجمة تُجرى ترجمة المحارف المختلفة وضمّ الأسطر والتعرف على التعليقات ومراحل أخرى من الترجمة المبكّرة وفق ترتيبٍ معيّن، إذ يقول المعيار أن هذه المراحل تحدث بالترتيب التالي: ترجمة المحارف الثلاثية. ضمّ الأسطر. ترجمة التعليقات إلى مسافات فارغة (عدا التعليقات الموجودة ضمن السلاسل النصية والمحارف الثابتة)، إذ من الممكن في هذه المرحلة جمع عدّة مسافات فارغة إلى مسافة فارغة وحيدة. ترجمة البرنامج. تُنهى كل مرحلة قبل أن تبدأ المرحلة التي تليها. الكلمات المفتاحية والمعرفات بعد أن تكلمنا عن أبجدية لغة سي، سنلقي نظرةً على مزيدٍ من عناصر اللغة المثيرة للاهتمام، إذ تُعد الكلمات المفتاحية keywords والمعرفات identifiers المكونات الأكثر وضوحًا، وعلى الرغم من تشابه تركيبها إلا أنها مختلفة. الكلمات المفتاحية تحجز لغة سي مجموعةً صغيرةً من الكلمات المفتاحية لاستخدامها الخاص، ولا يمكن استعمال هذه الكلمات المفتاحية على أنها معرّفات داخل البرنامج، وهذا أمرٌ شائعٌ في معظم لغات البرمجة الحديثة. قد يتفاجئ بعض مستخدمو لغة سي القديمة بوجود بعض الكلمات المفتاحية الجديدة، وإن كانت هذه الكلمات المفتاحية مُستخدمةٌ مثل معرّفات في برامج سابقة فيجب عليك تغييرها، ولحسن الحظ الانتباه لهذا النوع من الأخطاء والعثور عليها سهل وبسيط، إذ سيخبرك المصرّف أن هناك بعض الأسماء غير الصالحة. يضمّ الجدول التالي الكلمات المفتاحية المُستخدمة في معيار سي، إذ ستلاحظ أن جميع الكلمات لا تبدأ بأحرف كبيرة. table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } struct int double auto switch long else break typedef register enum case union return extern char unsigned short float const void signed for continue volatile sizeof goto default while static if do [جدول 3.2. كلمات مفتاحية] الكلمات المفتاحية المُضافة جديدًا التي قد تفاجئ المبرمجين السابقين للغة سي هي: const وsigned وvoid وvolatile (على الرغم من وجود void منذ فترة). سيلاحظ بعض القراء شديدي الانتباه أن الكلمات المفتاحية entry و asm و fortran غير موجودة في الجدول، إذ أنها ليست من ضمن المعيار، وسيفتقدها القليل منهم فقط. المعرفات يُعد المعرف Identifier مرادفًا لما نطلق عليه "اسم name"، وتُستخدم المعرفات في لغة سي للدلالة على العديد من الأشياء، فقد لاحظنا استخدامها حتى الآن في تسمية المتغيرات والدوال، ولكنها تُستخدم أيضًا في تسمية مزيدٍ من الأشياء التي لم نراها بعد، مثل: العناوين labels "وسوم" الهياكل tags of structures الاتحادات unions المعدّدات enums قواعد إنشاء معرف بسيطةً جدًا، إذ يمكنك استخدام الأحرف البالغ عددها 52 حرفًا من الأبجدية الإنجليزية (أحرف كبيرة أو صغيرة)، والأرقام العشرة من 0 حتى 9 وأخيرًا الشرطة السفلية "_"، التي يمكن عدّها حرفًا من الأبجدية في حالتنا هذه، لكن هناك قيدٌ واحدٌ ألا وهو أن المعرّف يجب أن يبدأ بحرف أبجدي. على الرغم من أن المعيار لا ينص صراحةً على حد أقصى لطول اسم المعرّف، إلا أننا نحتاج أن نتكلم عن هذه النقطة، إذ لا يوجد هناك أي حد في لغة سي القديمة ومعيار سي لطول اسم المعرف، ولكن المشكلة هي أنه لا يوجد هناك أي ضمانات أن جميع محارف اسم المعرف تُفحص أثناء موازنة المساواة، فقد كان حد الموازنة في لغة سي القديمة 8 محارف، أما في المعيار فهو 31 محرف. وبذلك يكون عمليًّا الحد الجديد للمعرف في المعيار هو 31 محرف، ومع ذلك يمكن للمعرفات تجاوز هذا الطول ولكنها يجب أن تختلف في أول 31 محرفًا إذا كنت تريد التأكُّد من أن برامجك محمولة portable. يسمح المعيار بالأسماء الطويلة لبعض التطبيقات، لذا إذا استخدمت الأسماء الطويلة وكان لا بدّ منها، فتأكد من أنها فريدةً قبل أن يتوقف التحقُّق من اسمها في المحرف ذو الرقم 31. يُعد طول المعرفات الخارجية external identifiers واحدًا من أكثر الأشياء المثيرة للجدل في الإصدار الجديد؛ إذ تُعرف المعرفات الخارجية بأنها المعرفات التي يجب أن تكون مرئية خارج نطاق الشيفرة المصدرية المستخدمة فيها، وتُعد برامج المكتبة أو الدوال التي يجب أن تُستدعى من عدّة ملفات مصدرية مثالًا جيدًا عليها. اختار المعيار الحفاظ على القيود القديمة التي تخص هذه المعرفات، إذ لا تعدّ المعرفات الخارجية مختلفةً عن بعضها إلا في حالة اختلافها مع بعضها في المحارف الستّ الأولى، وليزداد الأمر سوءًا فقد تُعامل الأحرف الكبيرة والصغيرة بنفس الطريقة؛ والسبب وراء هذا عملي، إذ أن معظم أنظمة تصريف لغة سي تعمل بمساعدة أدوات نظام معينة للربط بين دوال المكتبات والبرنامج المكتوب بلغة سي C، وهذه الأدوات هي خارج تحكم مصرّف لغة C، ولذا على المعيار أن يضع بعض الحدود العملية التي ستتوافق مع شروط هذه الأدوات. لا يوجد أي قيود إجبارية على عدد الأحرف، ولكن الالتزام بهذا القيد (الأحرف الست الأولى متكافئة الحالة بين الأحرف الكبيرة والصغيرة) يزيد من فرصة عمل البرنامج على مختلف الأجهزة دون مشاكل (برنامج محمول). يذكرنا المعيار دائمًا بأنه ينظر إلى استخدام تكافؤ الحالة بين الأحرف الصغيرة والكبيرة إضافةً لحدّ المحارف في تسمية المعرفات على كونها ميزاتٍ قديمة، ومن الممكن أن يلغي المعيار القادم استخدام هذه القيود. لنأمل أن يحصل ذلك قريبًا. التصريح عن المتغيرات ذكرنا في المقالات السابقة أنه يجب التصريح عن أسماء الأشياء قبل استخدامها، والاستثناء الوحيد هنا لهذه القاعدة هو أسماء الدوال التي تُعيد قيمةً من النوع int، لأنه مصرّحٌ عنها افتراضيًا بالإضافة لأسماء العناوين labels. بإمكانك إما التصريح declaration عن الأشياء، وهي العملية التي تصف اسم ونوع الشيء ولكنها لا تحجز أيّ مكان على الذاكرة، أو التعريف definition، الذي يحجز مكانًا في الذاكرة للشيء المُصرَّح عنه. الفرق بين التصريح والتعريف مهم، وللأسف فإنّ الكلمتين متشابهتان مما يسبب الخلط لدى الكثير، ومن هذه النقطة فصاعدًا سنستخدم هاتين الكلمتين في سياقهما الصحيح، لذلك إذا نسيت الفرق بين المصطلحين وأردت التأكد مرةً أخرى فارجع لهذه الفقرة. القواعد المتعلقة بجعل التصريح ضمن التعريف معقّدةٌ بعض الشيء، لذا سنؤجلها ونكتفي حاليًّا ببعض الأمثلة والقواعد التي ستؤدي الغرض لأمثلتنا القادمة. /* * A function is only defined if its body is given * so this is a declaration but not a definition */ int func_dec(void); /* * Because this function has a body, it is also * a definition. * Any variables declared inside will be definitions, * unless the keyword 'extern' is used. * Don't use 'extern' until you understand it! */ int def_func(void){ float f_var; /* a definition */ int counter; /* another definition */ int rand_num(void); /* declare (but not define) another function */ return(0); } سنستمرّ قدُمًا في القسم التالي ونتكلم عن نوع المتغيرات والتعابير. ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: الأنواع الحقيقية والصحيحة في لغة سي C المقال السابق: المحارف المستخدمة في لغة سي C بنية برنامج لغة سي C

سنلقي في الجزئية الثانية من السلسلة، نظرةً على الأجزاء التي لم نلقِ لها بالًا في المقال السابق من هذه السلسلة، الذي كان بمثابة مقدمة سريعة عن لغة سي، التحدي هنا هو التكلم عن أساسيات اللغة بصورةٍ موسّعة وكافية للسماح لك بفهم المزيد عن اللغة دون إغراق المبتدئين بالمعلومات والتفاصيل غير الضرورية في هذه المرحلة. سنغطي في هذه الجزئية من السلسلة بعض المفاهيم والمشاكل الدقيقة التي لا تقرأ عنها في النصوص التقديمية للغة، فيجب عليك أن تقرأه بعقلية منفتحة وبمزاج جيّد. قد يجد دماغك المرهَق التمارين الموجودة بين الفقرات استراحةً مفيدة، إذ ننصحك بشدّة أن تحاول حلّ التمارين هذه بينما تقرأ المقال، إذ أن ذلك من شأنه أن يساعدك في موازنة الكفة بين تعلُّم المفاهيم الجديدة -التي قد تشعر في بعض المراحل بغزارتها- والتمارين. حان الوقت لتقديم بعض الأساسيات في لغة سي. المحارف المستخدمة في لغة سي هذه الفقرة مثيرة للاهتمام، وسندعو المحارف المُستخدمة في لغة سي بأبجدية سي C، وهذه الأبجدية مهمة جدًا، وربما يكون هذا الجزء الوحيد من هذا المقال الذي يمكنك قراءته بصورةٍ سطحية وفهم جميع محتوياته من المرة الأولى. لذلك، اقرأه لتضمن أنك تعرف محتوياته والمعلومات الواردة فيه جيّدًا وتذكر أن تعود إليه في حال أردت مرجعًا بهذا الخصوص. الأبجدية الاعتيادية تعرّف قلةٌ من لغات البرمجة أبجديتها أو تلقي بالًا لهذا الأمر، إذ أن هناك افتراضًا مسبقًا بأن أحرف الأبجدية الإنجليزية وخليطًا من علامات الترقيم والرموز ستكون متاحةً في أي بيئة داعمة للّغة، ولكن هذا الافتراض غير محقّقٍ دائمًا. تعاني لغات البرمجة القديمة من هذه المشكلة بدرجةٍ أقل حدّة، ولكن تخيل إرسال برنامج مكتوب بلغة سي عبر جهاز تلكس Telex أو عن طريق نظام بريد إلكتروني يحتوي على بعض القيود، أتعي أهمية الأمر الآن؟ يوصّف المعيار مجموعتين مختلفتين من المحارف: واحدةٌ تُكتب بها البرامج وأخرى تُنفَّذ بها، وذلك للسماح للأنظمة المختلفة بتصريف البرنامج وتنفيذه بغض النظر عن اختلاف طرق ترميز المحارف لكل نظام. في الحقيقة، الأمر مهمّ فقط في حال استخدامك محارفًا ثابتة constant في المعالج المُسبق preprocessor، إذ من الممكن أن تختلف قيم هذه المحارف عند التنفيذ، وهذا السلوك معرّف عند التنفيذ implementation-defined، فهو موثّق بالتأكيد، ولكن لا تقلق بخصوص هذا الأمر الآن. يملي المعيار وجود أبجدية مؤلفة من 96 رمزًا للغة سي، وهي: المسافات ومسافات الجدولة الأفقية والعمودية ومحرف السطر الجديد وفاصل الصفحة table { width: 100%; } thead { vertical-align: middle; text-align: center; } td, th { border: 1px solid #dddddd; text-align: right; padding: 8px; text-align: inherit; } tr:nth-child(even) { background-color: #dddddd; } a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ {|} ~ [جدول 1 أبجدية لغة سي] اتّضح أن معظم أبجديات الحاسوب الشائعة تحتوي على جميع الرموز اللازمة للغة سي، عدا بعض الحالات الشاذة النادرة مثل المحارف الموجودة في الأسفل، والتي تُعد مثالًا عن محارف أبجدية لغة سي المفقودة من مجموعة المحارف ذات 7 بت لمعيار منظمة المعايير العالمية International Standards Organization المدعوّ ISO 646، وهي مجموعة جزئية من المحارف المُستخدمة في أبجديات الحاسوب على نطاقٍ واسع. # [ \ ] ^ { | } ~ لتضمين هذه الأنظمة التي لا تحتوي على مجموعة المحارف البالغ عددها 96 والمطلوبة لكتابة برامج بلغة سي، حدّد المعيار طريقةً لاستخدام معيار ISO 646 لتمثيل المحارف المفقودة ألا وهي تقنية ثُلاثيات المحارف trigraphs. ثلاثيات المحارف ثلاثيات المحارف Trigraphs هي سلسلةٌ من ثلاثة محارف ضمن المعيار ISO 646، وتُعامل معاملة محرفٍ واحدٍ ضمن أبجدية لغة سي. تبدأ جميع ثلاثيات المحارف بعلامتَي استفهام "??"، ويساعد هذا في الدلالة على أن هناك شيءٌ "خارجٌ عن المألوف" ضمن البرنامج. يوضّح الجدول 2 أدناه جميع ثلاثيات المحارف المُعرّفة ضمن المعيار. محرف أبجدية سي C ثلاثي المحرف # =?? ] )?? [ (?? } >?? { <?? \ /?? \ !?? ~ -?? ^ '?? [جدول 2 ثلاثيات المحارف] دعنا نفترض مثلًا، أن طرفيتك terminal لا تحتوي على الرمز "#" لكتابة سطر المعالج المُسبق التالي: #define MAX 32767 عندها، نستطيع استخدام طريقة ثلاثيات المحارف على النحو التالي: ??=define MAX 32767 ستعمل ثلاثيات المحارف حتى لو كان المحرف "#" موجودًا، ولكن هذه التقنية موجودةٌ لمساعدتك في الحالات الحرجة ولا يُحبَّذ استخدامها بديلًا عن محارف أبجدية سي دومًا. ترتبط إشارة الاستفهام "?" بالمحرف الواقع على يمينها، لذا في أي سلسلة مؤلفة من عدّة إشارات استفهام، تشكِّل إشارتان فقط ضمن السلسلة ثلاثي محارف، ويعتمد المحرف الذي تمثِّله على المحرف الذي يقع بعد الإشارتين مباشرةً، وهذا من شأنه أن يجنّبك كثيرًا من الالتباس. من الخطأ الاعتقاد أن البرامج المكتوبة بلغة سي، والتي تلقي بالًا كبيرًا لإمكانية تشغيلها على نحوٍ محمول portable وعلى جميع الأنظمة مكتوبةٌ باستخدام ثلاثيات المحارف "إلا في حال ضرورة نقلها إلى نظام يدعم معيار ISO 646 فقط"؛ فإذا كان نظامك يدعم جميع المحارف البالغ عددها 96 محرفًأ، واللازمة لكتابة البرامج بلغة سي، فيجب استخدامها دون الاستعانة بثلاثيات المحارف، إذ وُجدت هذه التقنية لتنفيذها ضمن بيئات محدودة، ومن السهل جدًا كتابة مفسّر يحوِّل برنامجك بين التمثيلين عن طريق فحص كل محرف بمحرفه. ستميّز جميع المصرّفات المتوافقة مع المعيار ثلاثيات المحارف عندما تجدها، إذ أن تبديل ثلاثيات الأحرف هو من أولى العمليات التي يجريها المصرّف على البرنامج. المحارف متعددة البايت أُضيف دعم المحارف متعددة البايت multibyte characters إلى المعيار، ولكن ما هو السبب؟ تتضمن نسبةٌ كبيرة من الحوسبة الاعتيادية اليومية بياناتٍ ممثّلة بنص بشكلٍ أو بآخر، وساد الاعتقاد في مجال الحوسبة أنه من الكافي دعم ما يقارب مئة محرف مطبوع فقط، ومن هنا كان عدد المحارف الممثلة لأبجدية سي 96 محرفًا، وذلك بناءً على متطلبات اللغة الإنجليزية وهذا الأمر ليس مفاجئًا بالنظر إلى أن معظم سوق تطوير البرمجيات والحوسبة التجاري كان في الولايات المتحدة الأمريكية. تُعرف مجموعة المحارف هذه باسم المخزون repertoire وتتناسب مع 7 أو 8 بتات من الذاكرة، وهذا السبب في أهمية استخدام 8-بت واحدةً لتخزين وقياس للبيانات بصورةٍ أساسية في معيار US-ASCII ومعمارية الحواسيب المصغرة minicomputers والحواسيب الدقيقة microcomputers. تتّبع لغة سي أيضًا توجّهًا في تخزين البيانات باستخدام البايت byte، إذ أن أصغر وحدات التخزين الممكن استخدامها مباشرةً في لغة سي هي البايت، والمعرّفة بكونها تتألف من 8 بِت. قد تشكو الأنظمة والمعماريات القديمة التي لم تُصمم مباشرةً لدعم ذلك من بطء بسيط في الأداء عند تشغيل لغة سي، لكن لا ينظر معظم الناس لذلك الأمر بكونه مشكلةً كبيرة. لربما كانت الأبجدية الإنجليزية مقبولةً لتطبيقات معالجة البيانات حول العالم في وقتٍ مضى، إذ استُخدمت الحواسيب في أماكن يتوقّع من مستخدميها الاعتياد على هذا الأمر، لكن هذا لا يصلح في زمننا الحالي؛ إذ أصبح من الضروري في وقتنا المعاصر تزويد الأنظمة بوسائل معالجة البيانات وتخزينها باللغة الأم لمستخدميها. قد نستطيع حشر جميع المحارف المستخدمة في لغات كلٍّ من الولايات المتحدة الأمريكية وأوروبا الغربية ضمن مجموعة محارف لا يتجاوز حجمها 8 بِت لكل محرف، ولكن الأمر مستحيلٌ بالنسبة للغات الآسيوية. هناك طريقتان لتوسعة مجموعة المحارف، الأولى عن طريق إضافة عددٍ معين من البايتات (عادةً اثنين) لكل محرف، وهذه هي الطريقة المصممة لدعم محارف أكبر حجمًا في لغة سي؛ أما الطريقة الأخرى فهي باستخدام مخطط ترميز الإدخال بالإزاحة shift-in والخرج بالإزاحة shift-out؛ وهو ترميزٌ شائع في قنوات الاتصال ذات سعة 8-بت. ألقِ نظرةً على سلسلة المحارف التالية: a b c <SI> a b g <SO> x y إذ يعني المحرف <SI> "بدّل إلى اليونانية" والمحرف <SO> "بدّل مجددًَا إلى الإنجليزية"، ويعرض جهاز العرض المُهيّأ للعمل وفق هذا الترميز النتيجة على النحو التالي: a, b, c, alpha, beta, gamma, x, y. هذه هي الطريقة المُتبعة تقريبًا في معيار shift-JIS الياباني، والاختلاف في ذلك المعيار هو أن المحارف الموجودة ضمن الإدخال بالإزاحة تتألف من مِحرفين يُستخدمان في تمثيل محرفٍ واحدٍ باللغة اليابانية، وهناك العديد من الطرق البديلة التي تستخدم عدة محارف مدخلة بالإزاحة، ولكنها أقل شيوعًا. يسمح المعيار الآن باستخدام مجموعات المحارف الموسّعة extended character sets، إذ تُستخدم المحارف المُعرفة مُسبقًا والبالغ عددها 96 في كتابة برنامج بلغة سي، ولكن مجموعة المحارف المُوسعة مسموحة في كتابة التعليقات والسلاسل النصية والمحارف الثابتة وأسماء ملفات الترويسة (جميع ما ذُكر يمثل بيانات وليسَ جزءًا من كتابة البرنامج). يضع المعيار بعض القواعد البديهية لوصف طريقة استخدام هذه المجموعات، ولن نكررها هنا، لكن أبرزها هو أن البايت ذو القيمة الصفرية يُفسّر محرفًا فارغًا null بغض النظر عن أي حالة إزاحة. هذا المحرف مهم لأن لغة سي ترمز لنهاية السلسلة النصية به وتعتمد عليه العديد من دوال المكتبات. هناك متطلبٌ آخر ألا وهو أن سلاسل المحارف متعددة البايت يجب أن تبدأ وتنتهي ضمن حالة الإزاحة المبدئية. يصف المعيار النوع char بكونه مناسبًا لتخزين قيمة جميع المحارف ضمن "مجموعة محارف التنفيذ execution character set" التي ستكون مُعرفةً في توثيق نظامك؛ وهذا يعني (في المثال السابق) أن نوع char يمكنه تخزين 'a' أو 'b' أو محرف الإزاحة إلى اللغة اليونانية بنفسه <SI>، إذ لا يوجد أي فرق في القيم المخزنة بداخل المتغير من نوع char بسبب تقنية الإدخال والإخراج بالإزاحة؛ وهذا يعني أنه لا يمكننا تمثيل 'a' على أنه محرف "ألفا" في اللغة اليونانية، وحتى نستطيع تحقيق ذلك يلزمنا أكثر من 8 بتات، وهو أكبر من حجم char في معظم الأنظمة، وهنا يأتي دور نوع المتغير wchar_t الذي قدَّمه المعيار، ولكن يجب تضمين ملف الترويسة <stddef.h> قبل استخدامه، لأن wchar_t معرّفٌ على أنه اسم بديل عن نوعٍ موجودٍ في لغة سي. سنناقش هذا الأمر بتوسع أكبر لاحقًا. ختامًا، نستطيع تلخيص ما سبق: تتطلب لغة سي مجموعة محارف عددها 96 محرف على الأقل لاستخدامها في محارف الشيفرة المصدرية للبرنامج. لا تحتوي جميع مجموعات المحارف على 96 محرف، بالتالي تسمح ثلاثيات المحارف للمعيار ISO 646 الأساسي كتابة برامج سي في حال الضرورة. أُضيفت المحارف متعددة البايت حديثًا مع المعيار، وتدعم: المحارف متعددة البايت المُرمّزة بالإزاحة Shift-encoded multibyte characters، التي تسمح بحشر المحارف الإضافية ضمن سلاسل محارف "اعتيادية"، بحيث يمكننا استخدام النوع char معها. المحارف الموسّعة wide characters التي تتسع لمساحة أكبر من المحارف الاعتيادية، ولها نوع بيانات مختلف عن النوع char. ترجمة -وبتصرف- لقسم من الفصل Variables and Arithmetic من كتاب The C Book. اقرأ أيضًا المقال التالي: البنية النصية لبرامج سي C المقال السابق: بعض البرامج البسيطة بلغة سي C: المصفوفات والعمليات الحسابية بنية برنامج لغة سي C

بما أننا ما زلنا في مرحلة التكلم عن لغة سي عمومًا، دعونا نتناول مثالين آخرين، إذ ستجد أن بعض التعليمات الموجودة ضمن هذين المثالين أصبحت معروفةً بالنسبة لك ولن نتطرّق إليها، ولكننا سنتكلّم عن المزايا والتعليمات الجديدة التي لم نشرحها بعد عن اللغة. برنامج لإيجاد الأعداد الأولية /* * * * Dumb program that generates prime numbers. */ #include <stdio.h> #include <stdlib.h> main(){ int this_number, divisor, not_prime; this_number = 3; while(this_number < 10000){ divisor = this_number / 2; not_prime = 0; while(divisor > 1){ if(this_number % divisor == 0){ not_prime = 1; divisor = 0; } else divisor = divisor-1; } if(not_prime == 0) printf("%d is a prime number\n", this_number); this_number = this_number + 1; } exit(EXIT_SUCCESS); } [مثال 2.1] هناك الكثير من الأمور الجديدة المثيرة للاهتمام في هذا البرنامج. أوّلًا، البرنامج يعمل بغباء بعض الشيء، إذ يقسِّم العدد على جميع الأرقام الواقعة في المجال بين نصف قيمته والرقم 2 للتحقّق ما إذا كان أوليًّا أم لا، وإذا كان هناك أي قسمةٍ دون باقٍ فهذا يعني أنه ليس أوليًّا. هذه المرة الأولى التي نستخدم فيها كلًا من العامل % وعامل المساواة المُمثَّل بإشارتَي مساواة ==، إذ يتسبب هذا العامل بكثير من الأخطاء في برنامجك عادةً، نظرًا للخلط بينه وبين عامل الإسناد =، فكن حذرًا. المشكلة في فحص المساواة هذا وأيّ فحص آخر، هي أن استبدال == بالرمز = هو تعليمة صالحة، ففي الحالة الأولى (استخدام ==) تُوازَن القيمتان وتُفحص حالة المساواة، كما في المثال التالي: if(a == b) while (c == d) كما يمكن استخدام عامل الإسناد = في الموضع ذاته، ولكن لإسناد القيمة الواقعة على يسار الإشارة للمتغيّر على يمينها. تصبح المشكلة مهمةً أكثر إذا كنت معتادًا على البرمجة باللغات التي تستخدم عامل المساواة بصورةٍ مماثلة لما تستخدمه لغة سي لعامل الإسناد، إذ لا يوجد أي شيء يمكنك فعله لتغيير ذلك سوى الاعتياد على هذا الأمر من الآن فصاعدًا، ولحسن الحظ تعطيك بعض المصرّفات الحديثة بعض التحذيرات عندما تلاحظ استخدامًا غريبًا لعامل الإسناد في غير موضعه المعتاد، ولكن يصبح الأمر مزعجًا أحيانًا إذا كان هذا فعلًا ما تريد فعله وليس خطأً. نلاحظ في مثالنا السابق أيضًا أول استخدام للتعليمة if، إذ تفحص هذه التعليمة تعبيرًا expression موجودًا داخل القوسين على نحوٍ مشابه لتعليمة while، إذ تتطلب جميع التعليمات الشرطية التي تتحكّم بتدفق البرنامج تعبيرًا محتوًى داخل قوسين بعد الكلمة المفتاحية، وفي هذه الحالة الكلمة المفتاحية هي if. تُكتب التعليمة if على النحو التالي: if(expression) statement if(expression) statement else statement يوضِّح المثال المبين أعلاه أن التعليمة تأتي بنموذجين، إذ يحتوي الأول على الكلمة if والثاني على الكلمة else؛ فإذا كان التعبير صحيحًا وفقًا للنموذج الأول، فستُنفَّذ مجموعة التعليمات الموجودة داخل متن if، أما إذا كان التعبير خاطئًا فلن تُنفّذ؛ بينما تنفّذ التعليمات الموجودة ضمن else وفقًا للنموذج الثاني فقط في حالة كان التعبير خاطئًا (أي تعبير if السابق لها). يتميز استخدام تعليمة if بمشكلة شائعة، ألقِ نظرةً على المثال التالي وأجِب، هل ستُنفَّذ التعليمة statement-2 أم لا؟ if(1 > 0) if(1 < 0) statement-1 else statement-2 الإجابة هي نعم ستُنفَّذ التعليمة. لا تركّز تفكيرك على مسافة الإزاحة فهي مضللةٌ غالبًا، فقد تكون تعليمة else تابعةً لتعليمة if الأولى أو الثانية بحسب وصف كلٍّ منهما، لذا علينا اللجوء لقاعدةٍ ما لجعل الأمور أوضح. القاعدة ببساطة هي أن else تابعةٌ لتعليمة if الأقرب (التي تسبق else)، والتي لا تحتوي على تعليمة else مسبقًا. لنجعل البرنامج يعمل كما نريد وفق تنسيق مسافات الإزاحة، علينا إنشاء تعليمة مركبة باستخدام الأقواس المعقوصة كما يلي: if(1 > 0){ if(1 < 0) statement-1 } else statement-2 تتبَع لغة سي -على الأقل في هذه الحالة- لعمل معظم لغات البرمجة واصطلاحاتهم. في الحقيقة، قد يشعر بعض القراء أن هذه القاعدة "بديهية" إن سبق وتعاملوا مع لغة برمجة مشابهة للغة سي وأنها لا تستحق الذكر. لنأمل أن يفكر الجميع بهذه الطريقة. عامل القسمة يُشار إلى عامل القسمة بالرمز "/"، وعامل باقي القسمة بالرمز "%". تفعل عملية القسمة المتوقّع منها، إلا أن إجراء القسمة على أعداد صحيحة int ستعطي نتيجةً مقربةً باتجاه الحد الأدنى (الصفر)، إذ تعطي العملية 5/2 مثلًا النتيجة 2، وتعطي التعليمة 5/3 النتيجة 1؛ وللحصول على القيمة المقتطعة من الناتج نستخدم عامل باقي القسمة، إذ تعطينا العملية 2%5 النتيجة 1، والعملية 3%5 النتيجة 2. تعتمد إشارة باقي القسمة وناتج القسمة على المقسوم والمقسوم عليه وهي مُعرّفة في المعيار. مثال عن تنفيذ عملية الدخل من المفيد أن نكون قادرين على الحصول على الدخل وكتابة برامج قادرة على طباعة وعرض النتائج ضمن قوائم أو جداول في الخرج، والطريقة الأبسط لتنفيذ هذا هي عن طريق استخدام الدالة getchar، وهي الطريقة الوحيدة التي سنناقشها حاليًّا؛ إذ تقرأ هذه الدالة كلّ محرف على حدى من دخل البرنامج وتعيد قيمةً عدديّة int تمثّله، ويمكن استخدام هذه القيمة الممثلة للمحرف في طباعة المحرف ذاته في خرج البرنامج، ويمكن أيضًا موازنة هذا المحرف (القيمة) مع محارف معيّنة أو محارف قُرأت مسبقًا، إلا أن الاستخدام الأكثر منطقية هو موازنة المحرف المُدخل مع محرف معيّن. لا تُعد موازنة قيمة المحارف ما إذا كانت أصغر أو أكبر خيارًا جيّدًا، إذ لا يوجد أي ضمان بأن قيمة a أصغر من قيمة b، مع أن ذلك الأمر محققٌ في معظم الأنظمة، ولكن الضمان الوحيد هنا الذي يقدمه لك المعيار هو أن القيمة ستكون متتابعة من 0 إلى 9. ألقِ نظرةً على المثال التالي: #include <stdio.h> #include <stdlib.h> main(){ int ch; ch = getchar(); while(ch != 'a'){ if(ch != '\n') printf("ch was %c, value %d\n", ch, ch); ch = getchar(); } exit(EXIT_SUCCESS); } [مثال 3.1] هناك ملاحظتان جديرتان بالاهتمام، هما: سنجد في نهاية كل سطر دخل المحرف n\ (محرف ثابت)، وهو المحرف ذاته الذي نستخدمه في دالة printf عندما نريد طباعة سطر جديد. نظام الدخل والخرج الخاص بلغة سي غير مبني على مفهوم الأسطر بل على مفهوم المحارف؛ فإذا كنت تريد التفكير بالأمر من منطلق مفهوم الأسطر، فانظر للمحرف n\ على أنه إعلان لنهاية السطر. استخدام c% لطباعة المحرف بواسطة الدالة printf، إذ يسمح لنا هذا الأمر بطباعة المحرف على أنه محرف على الشاشة، بالموازنة مع استخدام d% الذي سيطبع المحرف ذاته ولكن بتمثيله العددي المُستخدم ضمن البرنامج. إذا جربت تنفيذ هذا البرنامج بنفسك، قد تجد أن بعض الأنظمة لا تمرّر المحرف الواحد تلو الآخر عند كتابته، بل تجبرك على كتابة سطر كاملٍ للدخل أولًا، ثم تبدأ معالجة المحرف الواحد تلو الآخر. قد يبدو الأمر مشوّشًا لبعض المبتدئين عندما يكتبون محرفًا ما ولا يحدث شيء بعد ذلك، وليس للغة سي أي علاقةٍ بذلك، بل يعتمد الأمر على حاسوبك ونظام تشغيله. المصفوفات البسيطة يكون غالبًا استخدام المصفوفات arrays في لغة سي للمبتدئين بمثابة تحدٍ، إذ أن التصريح عن المصفوفات ليس صعبًا، بالأخص المصفوفات أحادية البعد one-dimensional، ولكن سبب الأخطاء هنا هو بدء الدليل index الخاص بها من الرقم 0. للتصريح عن مصفوفة مؤلفة من 5 أعداد من نوع int، نكتب: int something[5]; تستخدم لغة سي الأقواس المعقوفة square brackets للتصريح عن المصفوفات، ولا تدعم أيّ مصفوفة لا تقع أدلتها بين 0 وما فوق. العناصر الصالحة في مثالنا هي [something[0 إلى [something[4، و [something[5 غير موجود في المصفوفة وهو عنصر غير صالح. يقرأ البرنامج التالي المحارف من الدخل، ويرتبها وفقًا لقيمتها العددية، ويطبعها في الخرج مرةً أخرى. ألقِ نظرةً على البرنامج وحاول فهم ما يحصل، إذ لن نتكلم عن الخوارزمية مفصلًا في شرحنا. #include <stdio.h> #include <stdlib.h> #define ARSIZE 10 main(){ int ch_arr[ARSIZE],count1; int count2, stop, lastchar; lastchar = 0; stop = 0; /* * Read characters into array. * Stop if end of line, or array full. */ while(stop != 1){ ch_arr[lastchar] = getchar(); if(ch_arr[lastchar] == '\n') stop = 1; else lastchar = lastchar + 1; if(lastchar == ARSIZE) stop = 1; } lastchar = lastchar-1; /* * Now the traditional bubble sort. */ count1 = 0; while(count1 < lastchar){ count2 = count1 + 1; while(count2 <= lastchar){ if(ch_arr[count1] > ch_arr[count2]){ /* swap */ int temp; temp = ch_arr[count1]; ch_arr[count1] = ch_arr[count2]; ch_arr[count2] = temp; } count2 = count2 + 1; } count1 = count1 + 1; } count1 = 0; while(count1 <= lastchar){ printf("%c\n", ch_arr[count1]); count1 = count1 + 1; } exit(EXIT_SUCCESS); } [مثال 4.1] ستلاحظ استخدام الثابت المُعرّف ARSIZE في كل مكان ضمن المثال السابق بدلًا من كتابة حجم المصفوفة الفعلي بصورةٍ صريحة، ويمكننا بفضل ذلك تغيير العدد الأقصى من المحارف الممكن ترتيبها ضمن هذا البرنامج بتغيير سطرٍ واحدٍ منه وإعادة تصريفه. الانتباه إلى امتلاء المصفوفة هي نقطة غير مشدّد عليها ولكنها هامّة لأمان برنامجنا؛ فإذا نظرت بتمعّن للمثال، ستجد أن البرنامج يتوقف عند تمرير العنصر ذو الدليل ARSIZE-1 للمصفوفة، وذلك لأن أي مصفوفة بحجم N عنصر تحتوي العناصر من 0 إلى N-1 فقط أي ما مجموعه N عنصر. على عكس بعض اللغات، لا تُعْلمك لغة سي أنك وصلت إلى نهاية المصفوفة، بل تُنتج ذلك بما يعرف باسم التصرف غير المحدد undefined behaviour في البرنامج، وهذا ما يتسبب ببعض الأخطاء الغامضة في برنامجك. يتجنّب المبرمجون الخبراء هذا الخطأ عن طريق اختبار البرنامج المتكرّر للتأكد من عدم حصول ذلك عند تطبيق الخوارزميّة المستخدمة، أو عن طريق فحص القيمة قبل محاولة الحصول عليها من المصفوفة. وتُعد هذه المشكلة من أبرز مصادر أخطاء وقت التشغيل run-time في لغة سي، لقد حذرتك! خلاصة القول: تبدأ المصفوفات بالدليل 0 دائمًا، ولا يمكنك تجنّب هذا الاصطلاح. تحتوي المصفوفة من الحجم "N" على عناصر من الدليل "0" إلى الدليل "N-1"، والعنصر "N" غير موجود داخل المصفوفة هذه، ومحاولة الوصول إليه هو خطأ فادح. مصطلحات هناك نوعان من الأشياء المختلفة في البرامج المكتوبة بلغة سي، أشياء تُستخدم لتخزين القيَم، وأشياء تدعى بالدوال، وبدلًا عن الإشارة للشيئين بصورةٍ منفصلة بعبارة طويلة، نعتقد أنه من الأفضل أن نرمز إليهما بتسميةٍ واحدةٍ عامّة ألا وهي "الكائنات objects"، وسنستخدم هذه التسمية كثيرًا في الفصول القادمة، إذ يتبع الشيئان نفس القواعد إلى حدٍّ ما؛ ولكن يجدر الذكر هنا إلى أن معنى المصطلح هذا مختلف عمّا يقصده المعيار، إذ يُستخدم مصطلح "كائن" في المعيار على نحوٍ خاص لوصف منطقة من الذاكرة المحجوزة لتمثيل قيمة، والدالة مختلفة عن هذا التعريف تمامًا. يؤدي هذا لاستخدام المعيار المصطلحين على نحوٍ منفصل وغالبًا ما ستجد العبارة "… الدوال والكائنات …"؛ ونظرًا لأن هذا الاختلاف لا يؤدي لكثيرٍ من الخلط ويحسِّن قراءة النص في كثيرٍ من الحالات، فسنستمرّ في استخدام المصطلح العامّ "كائن" للدلالة على الدوال والقيَم، وسنستخدم المصطلح "دالة" و"كائن بيانات Data object" عندما نريد التمييز بين الاثنين وفقًا للحالة. لذا، قد تجد اختلافًا بسيطًا في المعنى إن كنت تقرأ المعيار. ترجمة -وبتصرف- لقسم من الفصل Chapter 1 An Introduction to C من كتاب The C Book. اقرأ أيضًا المقال السابق: بنية برنامج لغة سي C إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

إذا كنت معتادًا على لغات تتبع بنية الكُتل مثل لغة باسكال Pascal، فستجد بنية برنامج لغة سي C مفاجئًا لك؛ وإذا كانت خبرتك في مجال لغات مشابهة للغة فورتران FORTRAN، فستجد البنية مشابهةً لما اعتدت عليه -بالرغم من اختلافها بصورةٍ كبيرة في التفاصيل، وفي الحقيقة استعارت لغة سي من كلا الأسلوبين المُستخدمين بصورةٍ واضحة، ومن أماكن أخرى أيضًا. نتيجةً لأخذ بعض القواعد من مصادر مختلفة، تبدو لغة سي أشبه بنتيجة تزاوج فصيلة كلاب ترير Terrier غير الأنيقة والمعروفة بعنادها وقوتها لكنها متسامحة مع أفراد العائلة. يطلق علماء الأحياء على هذا النوع من الفصائل "القوة الهجينة"، قد يذكرك كلامنا أيضًا بمخلوق كمير Chimera الأسطوري الذي يبدو خليطًا من الخرفان والماعز، قد يمنحنا الحليب والصوف، ولكنه سيزعجنا بثغائه المرتفع ورائحته غير اللطيفة. إذا نظرنا للأمر عمومًا نلاحظ أن ميزة لغة سي C العامة هي بنية البرنامج الموزعة على عدة ملفات، لأنها تسمح بتصريف منفصل لهذه الملفات، إذ تسمح لغة سي بتوزيع أجزاء من برنامج مكتمل على عدة ملفات مصدرية والتصريف على نحوٍ متفرق عن بعضها بعضًا. مبدأ العمل هنا هو أن جميع عمليات التصريف هذه ستعطينا ملفات يمكن ربطها Linked سويًّا عن طريق أي محرر ربط، أو محمّل ربط يستخدمه نظامك، ولكن بنية الكتل لبعض لغات البرمجة المشابهة للغة ألغول ALGOL تجعل هذه الطريقة صعبة التنفيذ، نظرًا لأن البرنامج مكتوبٌ بطريقة تجعل منه كتلةً واحدةً مترابطة، إلا أن هناك بعض الطرق للتغلُّب على هذه المشكلة. تتغلب لغة سي على هذه المشكلة بطريقةٍ مثيرة للاهتمام، إذ من المفترض أن تسرّع عملية التصريف، لأن تصريف البرنامج إلى تعليمات مصرَّفة Object Code بطيء ومكلف من ناحية الموارد، فالتصريف عملية شاقة. أتت من هنا فكرة استخدام المحمّل في ربط مجموعة من التعليمات المصرفة، إذ تتطلب هذه العملية ترتيب التعليمات حسب عنوانها للتوصل للبرنامج الكامل ببساطة. يُفترض أن يكون هذا الحل خفيف الاستهلاك للموارد، وعلى المحمّل طبعًا فحص المكتبات المستخدمة في التعليمات المصرفة واختيارها أيضًا. الفائدة المكتسبة هنا هو أننا لسنا بحاجة تصريف كامل البرنامج بعد تعديل جزءٍ بسيط منه، في هذه الحالة نحن بحاجة إعادة تصريف الجزء المُعدّل من البرنامج فقط؛ ولكن قد يصبح المحمّل في بعض الأحيان أبطأ عمليات تصريف البرنامج وأكثرها استهلاكًا للموارد بزيادة العمل المطلوب منه، وقد تكون العملية أسرع في بعض الأنظمة إذا صُرّف كل شيء دفعةً واحدة، وتُعد لغة أدا Ada إحدى الأمثلة المعروفة باتباعها لهذا الأسلوب. بالنسبة للغة سي فالعمل المنجز من المصرف ليس ضخمًا ومعقول إلى حدٍّ ما، يوضح الشكل 1.1 طريقة عمل المصرف في لغة سي. هذه الطريقة مهمة في لغة سي، إذ من الشائع أن تجد جميع البرامج باستثناء الصغيرة منها مؤلفةٌ من عددٍ من ملفات الشيفرة المصدرية، هذا يعني أيضًا أن جميع البرامج مهما كانت بسيطة ستمرّ بالمحمّل، نظرًا لاعتماد لغة سي المكثف على المكتبات، وهذا ما قد يكون غير واضح عند النظرة الأولى أو للمتعلّم الجديد. الدوال تتكون لغة C من مجموعة عناصر تشكل لبنات البناء الأساسية لها، مثل الدوالّ Functions وما نطلق عليه تسمية المتغيرات العامة global variables، إذ تُسمى هذه العناصر في نقطة ما من البرنامج عند تعريفها، وتحتوي طريقة الوصول لهذه العناصر باستخدام اسمائهم ضمن البرنامج على بعض القواعد، وتُوصف هذه القواعد في المعيار بمصطلح الربط Linkage. سنتكلم في الوقت الحالي فقط عن الربط الخارجي External Linkage وانعدام الربط No linkage، إذ تُدعى العناصر التي يمكن الوصول إليها ضمن البرنامج كاملًا، مثل دوال مكتبة معينة، بعناصر الربط الخارجي، وتُستخدم العناصر عديمة الربط بكثرة أيضًا ولكن الوصول إليها محدودٌ بصورةٍ أكبر. تُسمى المتغيرات المستخدمة داخل الدالة بالمتغيرات "المحلية Local" وهي عديمة الربط، وعلى الرغم من أننا نتفادى المصطلحات المعقدة قدر الإمكان في هذا الكتاب مثل المصطلحات التي ذكرناها سابقًا، ولكن لا توجد طريقة أبسط من شرح هذه المصطلحات. ستألف مصطلح الربط ضمن هذا الكتاب، والنوع الوحيد من الربط الخارجي الذي ستراه حاليًّا هو استخدام الدوال. تكافئ الدوال في لغة سي الدوال والبرامج الفرعية في لغة فورتران FORTRAN والدوال والإجراءات في لغة باسكال Pascal وألغول ALGOL، بينما لا تمتلك لغة بيسك BASIC ومعظم طفراتها mutations البسيطة أو لغة كوبول COBOL مقدار الدوال التي تمتلكه لغة سي. الفكرة من الدالة بسيطة وتتمثّل بإعطائك الإمكانية بتضمين فكرةٍ واحدة أو عملية ضمن قالب، وإعطائها اسمًا ما واستدعائها ضمن أجزاءٍ مختلفة من برنامجك باستخدام اسمها فقط. تكون تفاصيل العملية هذه غير واضحة عند ذكر الاسم ضمن البرنامج، وهذا الأمر طبيعي. وفي البرامج المصممة المهيكلة بصورةٍ جيدة، يمكنك تغيير طريقة عمل دالة ما (شرط ألّا يغير ذلك من طبيعة العمل) دون أن تؤثر على الأجزاء الأخرى من البرنامج. هناك دالةٌ ذات اسم مميز في البيئات المستضافة ألا وهي دالة "main"، إذ تمثِّل هذه الدالة نقطة بداية البرنامج عند تشغيله، أما في البيئات المستقلة فالذي يحدد أولى خطوات البرنامج هي دالة معرفة مسبقًا Implementation defined؛ وهذا يعني أنه على الرغم من أن المعيار لا يحدد ما الذي سيحدث، إلا أن سلوك البرنامج يجب أن يكون محدّدًا وموثقًا. يتوقف البرنامج عندما يغادر دالة "main". ألقِ نظرةً على البرنامج البسيط التالي الذي يحتوي على دالتَين: #include <stdio.h> /* * Tell the compiler that we intend * to use a function called show_message. * It has no arguments and returns no value * This is the "declaration". * */ void show_message(void); /* * Another function, but this includes the body of * the function. This is a "definition". */ main(){ int count; count = 0; while(count < 10){ show_message(); count = count + 1; } return(0); } /* * The body of the simple function. * This is now a "definition". */ void show_message(void){ printf("hello\n"); } [تمرين 1.1] شرح تمرين 1.1 ما الذي احتواه التمرين السابق؟ يمكن لمثال صغير جدًا أن يقدِّم لك الكثير عن لغة سي، إذ احتوى التمرين السابق على دالتين وتعليمة include#، وبعض التعليقات، بالإضافة لأشياء أخرى، وبما أنّ التعليق هو أبسط الأجزاء في البرنامج دعونا نبدأ به. التنسيق والتعليق تخطيط برنامج مكتوب بلغة سي ليس مهمًّا للمصرف، ولكنه هام لنقل بعض المعلومات عن البرنامج للقارئ البشري ولتسهيل عملية قراءته، إذ تسمح لك لغة سي باستخدام محرف المسافة space ومسافات الجدولة tabs والسطور الجديدة newline دون أن تؤثر على عمل البرنامج. تُدعى المحارف الثلاث المذكور سابقًا باسم المسافة الفارغة white space، ولا يميّز بينها المصرّف لأنها ببساطة تغير من موضع الكلمات دون التأثير "مرئيًّا" على ما يُعرض على جهاز الخرج. يمكن أن نلاحظ المسافة البيضاء في أي مكان من البرنامج عدا وسط المعرّفات Identifiers والسلاسل النصية Strings والمحارف الثابتة Character constants؛ إذ نقصد بالمعرفات هنا اسم الدالة أو كائن Object آخر، لا تشغل بالك بالسلاسل النصية والمحارف الثابتة إذ سنناقشها في الفصول القادمة. يُعد الفصل بين شيئين مختلفين من الحالات التي يصبح فيها استخدام المسافات الفارغة ضروريًّا، إذ قد يتسبب تلاصقهما بتفسيرهما شيئًا آخر، مثل الجزء void show_message، إذ نحتاج لمسافة فارغة للفصل بين الكلمتين void وshow_message، لكن احتواء )show_message على مسافة بيضاء بينها وبين القوس المفتوح غير ضروري، ووجودها مجرّد أسلوب تنسيقي في كتابة الشيفرة لا أكثر. يبدأ التعليق في لغة C باستخدام المحرفين "*/" المتلاصقين دون أي فراغ بينهما، ويُعد أي شيء يأتي بعدهما إضافةً للمحرفين "/*" مسافةً فارغةً واحدة. لم يكن الأمر مماثلًا في معيار سي القديم، إذ كانت تنص القاعدة على إمكانية استخدام التعليق في أي مكان يمكن أن تُستخدم فيه المسافة الفارغة، أما الآن يُعد التعليق بحد ذاته مسافةً فارغة؛ التغيير الحاصل طفيف وستكون الأمور أكثر وضوحًا في جزئية لاحقة من هذه السلسلة عندما نناقش المعالج المُسبق preprocessor. يجعل تنسيق تعليقات لغة سي بهذا الشكل تضمين تعليق بداخل تعليق آخر غير ممكنٍ، نظرًا لإغلاق أول زوج محارف "*/" في التعليق الثاني كتلة التعليق، وهذا إزعاجٌ بسيط ستعتاد عليه لاحقًا. من الممارسات الشائعة وضع زوج المحارف "*/" في بداية كل سطر من تعليق متعدد الأسطر لإبراز كلّ منهم، كما هو موضحٌ في مثالنا السابق. تعليمات المعالج المسبق التعليمة الأولى في مثالنا السابق هي موجّه للمعالج المُسبق Preprocessor directive، إذ تضمَّن مصرّف لغة سي سابقًا مرحلتين، هما المعالجة المُسبقة ومرحلة التصريف الاعتيادية؛ إذ تمثّل المعالجة المُسبقة معالج ماكرو macro processor تجري بعض عمليات التلاعب النصي البسيطة على البرنامج قبل أن تمرّر النص الناتج إلى المصرّف، وقد أصبحت عملية المعالجة المسبقة جزءًا أساسيًّا من عمل المصرّف ولهذا تُعد جزءًا لا يتجزّأ من اللغة. على الرغم من أن لغة سي حساسة لما يقع في نهاية الأسطر إلا أن عملية المعالجة المسبقة تلاحظ الأسطر فقط، ومع ذلك من الممكن كتابة موجّه معالجة مسبقة متعدد الأسطر، ولكنه غير شائع، وستشعر بالغرابة عندما تجد هذه الطريقة متبعة. يُعد أي سطرٍ يبدأ بالمحرف # توجيهًا للمعالج المسبق. في التمرين 1.1 يؤدي موجّه المعالجة المسبقة include# إلى تبديل السطر هذا بمحتويات ملف آخر، وفي هذه الحالة اسم الملف يوجد ما بين القوسين < و>، وهذه طريقة شائعة لتضمين محتوى ملفات الترويسات Header files القياسية ضمن برنامجك، دون الاضطرار لكتابتها بنفسك. يحتوي ملف <stdio.h> المهم العديد من المعلومات الضرورية التي تسمح لك باستخدام مكتبة الدخل والخرج القياسية، بهدف الحصول على الدخل وإظهار الخرج، فإذا أردت استخدام هذه المكتبة عليك أن تتأكد من وجود <stdio.h>. كان معيار سي السابق متساهلًا أكثر بهذا الشأن. تعليمات التعريف Define تُعد تعليمة define# من الإمكانيات الأخرى والمستخدمة كثيرًا للمُعالج المُسبق، إذ تُستخدم على النحو التالي: #define IDENTIFIER replacement تعني التعليمة السابقة أنه على المعالج المُسبق استبدال جميع الكلمات المطابقة إلى IDENTIFIER بالكلمة replacement عند جميع نقاط ورودها ضمن البرنامج. يُكتب دائمًا المعرِّف بأحرف كبيرة IDENTIFIER، وهذا اصطلاحٌ برمجي يساعد قارئ الشيفرة على فهمها، أما الجزء المُبدّل به replacement فقد يكون أي سلسلة نصية. تذكر أن المعالج المسبق لا يعرف قواعد لغة سي، إذ أن مهمته هي التلاعب النصي فقط. يكون الاستخدام الأكثر شيوعًا لهذه التعليمة هو التصريح Declare عن أسماء القيم العددية الثابتة كما هو موضح فيما يلي: #define PI 3.141592 #define SECS_PER_MIN 60 #define MINS_PER_HOUR 60 #define HOURS_PER_DAY 24 واستخدام القيم على النحو التالي: circumf = 2*PI*radius; if(timer >= SECS_PER_MIN){ mins = mins+1; timer = timer - SECS_PER_MIN; } سيكون الخرج الناتج عن المعالج المُسبق مماثلًا فيما لو كتبت الشيفرة التالية: circumf = 2*3.141592*radius; if(timer >= 60){ mins = mins+1; timer = timer - 60; } أخيرًا، نستطيع تلخيص ما سبق على النحو التالي: تتعامل تعليمات المعالج المُسبق مع الملفات النصية سطرًا بسطر، على نقيض لغة سي. تُستخدم التعليمات من النوع include# لقراءة محتوًى من ملفٍ معين، عادةً لتسهيل التعامل مع دوال مكتبةٍ ما. تُستخدم تعليمات define# لتسمية الثوابت، وتُكتب الأسماء اصطلاحًا بحروفٍ كبيرة. تعريف وتصريح الدالة التصريح نلاحظ وجود ما يُسمى تصريح الدالة function declaration بعد تضمين ملف <stdio.h>، الذي يخبر المصرّف أن show_message دالة لا تأخذ أي وسيط ولا تُعيد أي قيمة، ويوضح لنا هذا تغييرًا جرى على المعيار، ألا وهو النموذج الأولي للدالة function prototype، وسنناقش هذا الموضوع بتوسّع لاحقًا. ليس من الضروري التصريح عن الدالة مسبقًا، إذ ستستخدم لغة سي بعض القواعد القديمة الافتراضية في هذه الحالة، إلا أنه ينصح بشدة التصريح عن الدالة في البداية. الفرق بين التصريح والتعريف هو أن التصريح يصف نوع الدالة والوسطاء المُمرّرة له، بينما يحتوي التعريف على بنية الدالة بالكامل. سيهمّنا فهم الفرق بين المصطلحين لاحقًا. يستطيع المصرّف تفقد استعمال الدالة show_message فيما إذا كان صحيحًا أم لا بالتصريح المُسبق عنها قبل استخدامها، ويصف التصريح ثلاث خصائص عن الدالة، هي: اسمها ونوعها وعدد الوسطاء ونوعهم؛ إذ يشير الجزء )void show_message إلى نوع الدالة والقيمة التي تُعيدها بعد استدعائها وهي void (سنناقش معناها لاحقًا). نستطيع رؤية الاستخدام الثاني لكلمة void في قائمة الوسطاء للدالة (void)، والذي يعني أن الدالة لا تقبل أي وسطاء. التعريف تلاحظ في نهاية البرنامج تعريف الدالة، وبالرغم من أنّ أن طولها ثلاث أسطر فقط، إلا أنها تُعد مثالًا على تعريف دالة متكامل. تنفِّذ دوال لغة سي المهام التي قد تقسِّمها بعض اللغات الأخرى إلى جزأين، إذ تستخدم لغات البرمجة الدوال لإعادة قيمةٍ ما، مثل دالة الجيب المثلثي sin وجيب التمام cos أو ربما دالة تُعيد الجذر التربيعي لعددٍ ما، وهذه الطريقة التي تعمل بها دوالّ لغة سي، بينما تجري بعض لغات البرمجة هذه العملية باستخدام ما يشبه الدوال ولكن الفرق هنا هو عدم إعادة القيمة، مثل استخدام فورتران للبرامج الفرعية واستخدام باسكال وألغول للإجراءات. تنجز لغة سي كل هذه المهام باستخدام الدوال عن طريق تحديد نوع القيمة المُعادة عند التصريح عن الدالة، ولا تُعيد الدالة show_message أي قيمة، لذلك نوعها void. إما أن يكون استخدام القيمة void بديهيًّا لك، أو صعب الفهم حسب الطريقة التي تنظر لها للأمر. ففي الحقيقة، يمكننا الدخول في نقاشات فلسفيّة جانبية وغير مثمرة عن كون void يصف نوع قيمةٍ أو لا، لكن أفضل تجنب ذلك. بغض النظر عن رأيك، استخدام النوع void التي تعني: "أنا لا أهتم بأي قيمة ترجعها هذه الدالة (أو لا ترجعها)". إذًا، نوع الدالة هو void واسمها show_message، أما القوسان () اللذان يتبعان هذه المعلومات، فهما لتنبيه المصرّف أننا نقصد التعريف، أو التصريح عن دالة. إذا كانت الدالة تقبل أي وسيط، فيجب وضع اسمه داخل القوسين. الدالة التي نتكلم عليها في مثالنا لا تأخذ أي وسطاء وهذا الأمر موضّح عن طريق استعمال الكلمة void بداخل القوسين. وبالتالي اتّضح أن للكلمة التي تصف الفراغ والرفض أهميّةٌ بالغة. يشكّل متن الدالة تعليمة مركبة compound statement، وهي مجموعةٌ من التعليمات المُحاطة بأقواس معقوصة {}، على الرغم من وجود تعليمة واحدة فقط إلا أن الأقواس مطلوبة، وعمومًا، تسمح لك لغة سي باستخدام تعليمة مركبة في أي مكان تسمح به عادةً باستخدام تعليمة واحدة بسيطة، وتهدف الأقواس المعقوصة لتحويل عدة تعليمات متتالية إلى تعليمة واحدة. إذا سألت السؤال المبرَّر "هل يتوجب استخدام الأقواس المعقوصة في كل مكان، إذا كان الهدف منها جمع عدّة تعليمات لتعليمة واحدة؟" الإجابة: نعم، عليك استخدام الأقواس المعقوصة، والمكان الوحيد الذي لا تستطيع فيه استخدام تعليمة واحدة عوضًا عن تعليمة مركبة هو عند تعريف دالةٍ ما. بالتالي، أبسط دالة يمكننا إنشاؤها هي دالةٌ فارغة، لا تفعل أي عملٍ إطلاقًا: void do_nothing(void){} التعليمة الموجودة بداخل دالة show_message هي استدعاءٌ لدالةٍ من مكتبة printf، إذ تُستخدم هذه الدالة لتنسيق وطباعة الأشياء، والاستخدام الموجود في المثال هو أبسط استخدامات هذه الدالة. تقبل الدالة printf وسيطًا واحدًا أو أكثر، التي تُمرَّر قيمهم من استدعاء الدالة إلى الدالة نفسها، في مثالنا هذا، الوسيط هو السلسلة النصية. يُفسّر محتوى السلسلة النصية من الدالة printf وتتحكم الدالة بطريقة عرض الخرج حسب الوسطاء الممرّرة له، يماثل عمل الدالة عمل تعليمة FORMAT في فورتران إلى حدٍّ ما. خُلاصة القول: تُستخدم التصريحات في التصريح عن اسم الدالة ونوع القيمة المُعادة ونوع قيم الوسطاء إن وُجدت. تعريف الدالة هي تصريح للدالة مع محتواها أيضًا. يُصرَّح عن الدالة التي لا تعيد أي قيمة باستخدام الكلمة void، على سبيل المثال: ;void func(/* list of arguments */) يجب أن يصرّح عن الدالة التي لا تأخذ أي وسيط باستخدام الكلمة void ضمن لائحة الوسطاء، على سبيل المثال: ;void func(void) السلاسل النصية تُعرَّف السلاسل النصية في لغة سي بأنها سلسلة من المحارف المحتواة داخل علامتي تنصيص على النحو التالي: "like this" من غير المسموح أن تشغر السلسلة النصية عدة أسطر، إذ تُعد عنصرًا واحدًا بصورةٍ مشابهة للمعرفات. إلا أنه من الممكن استخدام محرفَي المسافة ومسافة الجدولة داخل السلسلة النصية. يوضح المثال أدناه سلسلةً نصيّةً صالحةً وأخرى غير صالحة في السطرين الثاني والثالث: "This is a valid string" "This has a newline in it and is NOT a valid string" يمكنك الحصول على سلسلة نصية طويلة جدًا بالاستفادة من حقيقة أن المحرف "\" في نهاية السطر يختفي تمامًا ضمن برنامج سي عند التنفيذ: "This would not be valid but doesn't have \ a newline in it as far as the compiler is concerned" الحل الثاني هو باستخدام ميّزة ضم السلاسل النصية، التي تنظر لكل سلسلتين نصيتين متجاورتين على أنهما سلسلةٌ نصيةٌ واحدة: "All this " "comes out as " "just one string" بالعودة للمثال 1.1، تُعد السلسلة النصية "n\" مثالًا على ما يُدعى محرف الهروب escape character ويمثّل في حالتنا هذه حالة إنشاء سطر جديد، وستطبع الدالة printf محتوى السلسلة النصية على ملف برنامج الخرج، بحيث سيكون الخرج "Hello" متبوعًا بسطرٍ جديد. يسمح المعيار الجديد باستخدام المحارف ذات البايتات المتعدّدة multibyte characters لدعم الأشخاص العاملين ببيئة تستخدم مجموعة محارف أوسع من معيار آسكي ASCII الأميركي، مثل معيار Shift JIS المُستخدم في اليابان. يعرّف المعيار الجديد 96 محرفًا تمثِّل أبجدية لغة سي (المتطرّق لها في مقال أبجدية لغة C)، وفي حال كان نظامك يستخدم مجموعة محارف موسّعة extended، فسيكون المكان الوحيد الذي قد تستخدمها هو بداخل سلسلة نصية، أو متغيرات من نوع محرف، أو ضمن التعليقات وأسماء ملفات الترويسة Header files. ينبغي عليك تفقُّد ملفات توثيق نظامك إذا أردت استخدام ميزة دعم المحارف الموسّعة. دالة main يحتوي المثال 1.1 على دالتين، هما: دالة show_message ودالة main؛ فإذا صرفنا النظر عن طول دالة main موازنةً مع الدالة show_message، فسنلاحظ أن الدالتين مبنيتان بالشكل نفسه، إذ تحتوي كلا الدالتين على اسمٍ وقوسين () متبوعين بقوس معقوص، وتعليمةٍ مركبة محتواة داخل القوسين المعقوصين تتبٍّع تعريف الدالة. على الرغم من أن الدالة المركبة مختلفةٌ عن الدالة الأخرى، إلا أنك ستجد قوس الإغلاق المعقوص نفسه { الذي يتماشى مع القوس الأول }. يُعد هذا المثال دالةً حقيقيّةً يمكن استخدامها في التطبيقات الواقعية، إذ تحتوي على عدة تعليمات ضمن متن الدالة بدلًا من تعليمة واحدة في الدالة السابقة، ولربما لاحظت أيضًا أن الدالة غير مصرّح عنها باستخدام الكلمة void، لأن الدالة في الحقيقة تمرّر قيمة معينة، ولكننا سنتكلم عنها لاحقًا. الشيء المميز بخصوص دالة main هو كونها أول دالة تُستدعى عند تنفيذ البرنامج في بيئة مستضافة، إذ تستدعي لغة سي الدالة main أوّلًا عند تشغيل البرنامج، وهذا هو السبب في تسمية الدالة بهذا الاسم (main تعني رئيس)، وعلى هذا فهي دالة هامة، ولكن محتوى الدالة هام بقدر مساوٍ، وكما ذكرنا سابقًا يمكن أن تحتوي الدالة على عدّة تعليمات بداخل التعليمة المركبة، دعونا نأخذ نظرة على هذه التعليمات. التصريح التعليمة الأولى هي: int count; وهي ليست تعليمة لتنفيذ أمرٍ ما، بل تعلن عن متغيرٍ جديد ضمن البرنامج، واسمه count من نوع "عدد صحيح integer" والكلمة التي تحدد هذا النوع من المتغيرات ضمن برنامج سي مُختصرة إلى الكلمة int. لا تدل جميع أسماء أنواع المتغيرات على نوعها بوضوح في لغة سي، إذ يُستخدم اسم نوع المتغير في بعض الأحيان مثل كلمةٍ مفتاحية مختصرة وفي أحيان أخرى يُكتب كاملًا. لحسن الحظ يمكن تخمين نوع البيانات للكلمة int بقراءتها. بفضل هذه التعليمة، يعلم المصرّف الآن أن هناك متغيّرًا باسم count لتخزين قيم الأعداد الصحيحة. يجب التصريح عن جميع المتغيرات قبل استخدامها في لغة سي، على نقيض لغة FORTRAN، التي يجب أن يأتي التصريح قبل استخدام المتغير ضمن أي تعليمة. تعليمة الإسناد بالانتقال إلى السطور التالية، نلاحظ تعليمة الإسناد assignment statement، وهي التعليمة التي أسندت أول قيمة للمتغير count (القيمة هي صفر في حالتنا هذه). كانت قيمة المتغير count قبل تعليمة الإسناد غير معرّفة undefined وغير آمنة الاستخدام، وربما تتفاجئ بحقيقة أن رمز الإسناد -أي عامل الإسناد assignment operator- يُمثَّل بإشارة مساواة واحدة =، وهذا التمثيل مستخدمٌ في معظم لغات البرمجة الحديثة، ولكنه ليس بمشكلة كبيرة. إذًا، بالوصول لهذه النقطة في برنامجنا نكون قد صرّحنا عن متغير وأسندنا له قيمة الصفر، ماذا بعد؟ تعليمة الحلقة التكرارية While سنتكلم عن واحدة من تعليمات التحكم بالحلقات، ألا وهي تعليمة while لنلقي نظرةً على شكلها العام: while(expression) statement هل هذا كل ما هنالك؟ نعم، هذه بنية تعليمة while، الجزء التالي في مثالنا هو: count < 10 ويدعى باسم التعبير العلائقي relational expression، وهو مثال عن إحدى التعبيرات الصالحة الممكن استخدامها في جملة الحلقة التكرارية -مكان expression- ويُتبَع التعبير بتعليمة مركّبة، وهي مثال عن التعليمات الصالحة أيضًا الممكن استخدامها -مكان statement-. وهكذا، نستطيع تشكيل تعليمة while صحيحة. إذا برمجت برنامجًا في السابق، فستلاحظ أن متن الحلقة سينفَّذ بصورةٍ متكررة طالما أن التعبير count < 10 صحيح؛ وإذا أردنا برمجة حلقةٍ منتهية، فعلينا كتابة تعليمة ما تتسبّب بجعل التعبير السابق خاطئًا في مرحلة من المراحل، وهذا موجود في مثالنا فعلًا. هناك تعليمتان فقط داخل متن الحلقة، إذ تمثِّل الأولى استدعاءً لدالة show_message وتُكتب تعليمة استدعاء الدالة منتهيةً بقوسين () تحتويان ضمنهما لائحة الوسطاء؛ فإذا لم تحتوي الدالة على أي وسيط، نكتب قوسين فارغين؛ وإذا احتوت على وسيط أو عدة وسطاء نكتب ذلك ضمن القوسين على النحو التالي: /* call a function with several arguments */ function_name(first_arg, second_arg, third_arg); استدعاء الدالة printf هو مثال آخر، وسنشرح المزيد عن هذا الموضوع في جزئية لاحقة من هذه السلسلة. تمثّل التعليمة الأخيرة ضمن الحلقة تعليمة إسناد تضيف الرقم واحد إلى قيمة المتغير count، لكي نتوصل في نقطة ما إلى قيمة تجعل من التعبير الخاص بالحلقة خاطئًا. تعليمة الإعادة return التعليمة الأخيرة المتبقية في المثال هي تعليمة return، وتبدو للوهلة الأولى أنها استدعاءٌ لدالة ٍما، ولكن التعليمة تُكتب على النحو التالي: return expression; والتعبير expression اختياري، إذ يتبِّع مثالنا تنسيقًا شائعًا ألا وهو وضع التعبير ضمن قوسين، ولكن الأقواس غير ضرورية ولا تؤثر على عمل التعليمة. تعيد تعليمة return قيمةً من الدالة الحالية الواقعة ضمنها إلى مستدعي caller الدالة؛ فإذا لم تُزوَّد التعليمة بالتعبير expression فستعاد قيمةٌ غير معروفة unknown إلى المستدعي، وهو أمرٌ خاطئ، عدا حالة إعادة void. الدالة main غير مصرّح بنوع خاص بها على الإطلاق على عكس دالة show_message، فأيّ نوع من القيم تعيدها هذه الدالة؟ الإجابة هي int، إذ تفترض لغة سي نوع البيانات المُعاد int في حالة عدم تخصيص النوع بوضوح، لذا من الشائع أن تجد الدالة main مكتوبةً بهذه الطريقة: int main(){ وهو تعبير مماثل لما ورد في مثالنا، ويعطي النتائج نفسها، لكنك لا تستطيع استعمال هذه الميزة للحصول على نوع اعتيادي للمتغيرات بالطريقة نفسها، ويجب أن تصرِّح عن نوعها بوضوح. لكن ما الذي تعني القيمة المُعادة من الدالة main وإلى أين تُرسل؟ كانت القيمة تُرسل إلى نظام التشغيل أو الجهة التي شغّلت البرنامج في لغة سي القديمة، وفي البيئات المشابهة لنظام يونيكس UNIX، كانت القيمة "0" تعني "نجاح" العملية، بينما يدلّ على "فشل" العملية أي رقم آخر (غالبًا "1-"). حافظ المعيار عند قدومه على هذا التقليد، إذ يدل "0" على التنفيذ الناجح للبرنامج، ولكن هذا لا يعني أن القيمة "0" تُمرّر إلى البيئة المُضيفة، بل تُمرّر القيمة المناسبة للدلالة على نجاح البرنامج ضمن هذا النظام. يسبب هذا الكثير من الالتباس، لذا قد تحبذ استخدام القيمتين المعرّفتين "EXIT_SUCCESS" و"EXIT_FAILURE" ضمن ملف الترويسة <stdlib.h>. يماثل استخدام التعليمة return ضمن الدالة main استخدام الدالة exit مزوّدًا بالقيمة المُعادة وسيطًا، والفرق هنا أن الدالة exit قد تُستدعى من أي مكان ضمن البرنامج، وأن توقف البرنامج في النقطة التي استُدعيت فيها بعد إنجاز بعض العمليات النهائية. إذا أردت استخدام الدالة exit، يجب عليك تضمين ملف الترويسة <stdlib.h>، ومن هذه اللحظة فصاعدًا سنستخدم exit بدلًا من استخدام return ضمن الدالة main. الملخص تُعيد الدالة main قيمةً من نوع int. يُماثل استخدام التعليمة return ضمن الدالة main استدعاء الدالة exit، الفرق هنا أنه من الممكن استدعاء exit في أي نقطة ضمن البرنامج. إعادة القيمة 0 أو EXIT_SUCCESS يعني نجاح البرنامج، بينما تُعد أي قيمة أخرى فشلًا للبرنامج. مع أنّ المثال المُناقش قصير، إلا أنه سمح لنا بمناقشة العديد من مزايا اللغة المهمة، وهي: بنية البرنامج Program structure. التعليق Comment. تضمين الملفات File inclusion. تعريف الدوال Function definition. التعليمات المركبة Compound statements. استدعاء الدوال Function calling. التصريح عن المتغيرات Variable declaration. العمليات الحسابية Arithmetic. الحلقات التكرارية Looping. لكننا طبعًا لم نناقش هذه المواضيع بتعمّق بعد. ترجمة -وبتصرف- لقسم من الفصل Chapter 1 An Introduction to C من كتاب The C Book. اقرأ أيضًا المقال التالي: بعض البرامج البسيطة بلغة سي C: المصفوفات والعمليات الحسابية إدارة الذاكرة (Memory management) في لغة C المتغيرات الشرطية وحلها مشاكل التزامن بين العمليات في لغة C متغيرات تقييد الوصول (Semaphores) في لغة البرمجة سي C

تُعَد الحاويات Containers من التطبيقات الثورية المعاصرة، إذ أنك ستستخدمها بغضّ النظر عن البرنامج الذي تعمل عليه سواءً كان كوبيرنيتيس Kubernetes، أو دوكر Docker، أو نظام كور CoreOS، أو سيلفربلو Sliverblue، أو فلاتباك Flatpak؛ إذ تستخدم جميع البرامج المذكورة سابقًا الحاويات بصورةٍ أساسية بفضل سهولة التعامل معها وأمانها العالي وقابليّة توسعتها. قد تكون الحاويات صعبة الفهم للبعض، فما الذي نعنيه عندما نقول أنّ النظام يعمل بداخل حاوية؟ وكيفَ لعمليّة محتواة داخل حاوية ما أن تتفاعل مع بقيّة أجزاء الجهاز المضيف الذي تعمل عليه؟ لا أحد يحبّ الغموض، لذا سنشرح في هذه المقالة تقنية عمل الحاويات. مجالات الأسماء تُعَد مجالات الاسماء Namespaces من أكثر المصطلحات شيوعًا في عالم البرمجة؛ وإذا كنتَ مبرمجًا، فعلى الأغلب أنك رأيت سطرًا برمجيًّا مشابهًا لهذا: ;using namespace std أو لربّما رأيت هذا السطر ضمن ملف XML: <book xmlns="http://docbook.org/ns/docbook" xml:lang="en"> يوفر هذا النوع من الأسطر البرمجية توصيفًا لسياق الأوامر الموجودة في ملف الشيفرة المصدرية التي تليه؛ فعلى سبيل المثال، السبب الوحيد في كون الكلمة المفتاحية cout ذات معنى للغة ++C، هو وجود مجال اسم يصف عملها. إذا كان الشرح السابق يستخدم كثيرًا من المصطلحات التقنية ولم تفهمه، دعنا نسقط الأمر على الحياة الواقعية؛ فنحن نستخدم مجالات الاسم أيضًا في حياتنا اليومية، صحيح نحن لا ندعوها باسمها بالطبع، ولكننا نستخدم المفهوم طوال الوقت؛ فإذا قلت مثلًا، "أنا من أكبر معجبي هذه السلسلة"، فقد تقصد سلسلة شركات أو محال تجاريّة معيّنة في سياق مجال الأعمال، أو سلسلة أفلام شهيرة في سياق السينما؛ كما قد تعني الجملة "على أيّ محرك يعمل هذا الشيء؟" شيئًا ما بداخل ورشة الميكانيكي، وشيئًا آخر في مجال تطوير الويب. نحن بالطبع لا نحدّد السياق خلال محادثتنا مع بعضنا بعضًا، إذ إنّ أدمغتنا ذكيةً كفاية لمعرفة السياق لوحدها، بينما نحتاج لإعلان مجال الاسم وتحديده عندما نتعامل مع الحواسيب. بالنسبة للحاويات، يصف مجال الاسم الحدود التي تستطيع الحاوية "رؤية" العمليات التي تجري بداخلها. أمر lsns لا يعي البعض هذا الأمر، ولكن يعمل نظام لينكس على إدارة العديد من مجالات الاسم المخصصة لإنجاز مختلف العمليات. وتستطيع الاطلاع على مجالات الاسم الموجودة على نظامك باستخدام آخر إصدارات حزمة util-linux: lsns $ NS TYPE NPROCS PID USER COMMAND 4026531835 cgroup 85 1571 seth /usr/lib/systemd/systemd --user 4026531836 pid 85 1571 seth /usr/lib/systemd/systemd --user 4026531837 user 80 1571 seth /usr/lib/systemd/systemd --user 4026532601 user 1 6266 seth /usr/lib64/firefox/firefox [...] 4026532928 net 1 7164 seth /usr/lib64/firefox/firefox [...] [...] إذا لم يحتوي إصدار الحزمة util-linux على أمر lsns، فيمكنك رؤية سجل مجالات الاسم ضمن المسار proc/: ls /proc/*/ns $ 1571 6266 7164 [...] ls /proc/6266/ns $ [...] ipc net pid user uts يجري عدُّ كل عملية Process في نظام لينكس برقمٍ تسلسلي يُدعى معرّف العملية process ID -أو اختصارًا PID-، ويرتبط كل PID بمجال اسمٍ معيّن. ويمكن لمعرّفات PIDs التي تحمل مجال الاسم نفسه الوصول لبعضها بعضًا، نظرًا لأنها مبرمجة ضمن مجال الاسم نفسه؛ بينما لا تستطيع العمليات التي تنتمي لمجالات أسماء مختلفة التفاعل والتواصل مع بعضها بعضًا بصورةٍ اعتيادية، لأنها تعمل ضمن سياقات مختلفة، أي مجالات اسم مختلفة؛ وهذا هو السبب في كون عمليات التي تعمل ضمن حاوية ما غير قادرةٍ على الوصول للمعلومات الموجودة خارج الحاوية، أو المعلومات الموجودة ضمن حاويةٍ أخرى مختلفة. إنشاء مجال اسم جديد تقدّم أي برمجيةٍ تتعامل مع الحاويات إدارةً تلقائية لمجالات الاسم في الحالة الاعتيادية؛ فعندما ينشئ المستخدم تطبيقًا أو بيئةً محتواةً بداخل حاويةٍ ما، عندها لا يلزم عليه استخدام الأمر lsns لتفقّد مجالات الاسم الموجودة وإنشاء مجال جديد يدويًّا، إذ تتولّى هذه البرمجيات المهمّة المذكورة تلقائيًّا بالاعتماد على مجالات اسم كل عمليّة PID، وبمساعدة نواة لينكس؛ إلّا أنّه من الممكن محاكاة هذه المهمة يدويًّا للحصول على فهم أفضل لكيفية عملها، وما الذي يحصل خلف الكواليس. أولًا، عليك تعريف عملية لا تعمل حاليًّا على جهازك، وفي هذا المثال، سنستخدم صدفة Z -أو اختصارًا Zsh-، لأنّ الجهاز الحالي الذي نعمل عليه يستخدم Bash؛ فإذا كان جهازك يعمل على Zsh، فبإمكانك استخدام Bash، أو tcsh، أو أيّ صدفة Shell غير فعالة حاليًّا. يُعَد هدفنا هنا هو إثبات أنّ الصدفة المُختارة (العملية) غير فعالة، إذ يمكننا التحقق من ذلك عن طريق استخدام الأمر pidof، الذي يطلب من النظام العثور على PID لأي تطبيق تكتبه بعد الأمر: pidof zsh $ sudo pidof zsh $ إذا لم يُعِد هذا الأمر أيّ رقم PID بالنتيجة، فهذا يعني أن التطبيق المُدخل غير فعال. أمر unshare يشغّل الأمر unshare أي تطبيق ضمن مجال اسم غير مشترك مع عمليات الأصل، وهناك الكثير من أنواع مجالات الاسم المختلفة التي يتيحها هذا الأمر. وبإمكانك الاطلاع على صفحة الدليل man للتعرف على الخيارات المتاحة. لإنشاء مجال اسم جديد خاص بالأمر الذي ستجرّبه: sudo unshare --fork --pid --mount-proc zsh $ % ستعمل صدفة Zsh في مجال اسمها عند التشغيل تلقائيًا، وذلك بحكم أنها صدفةٌ تفاعلية. ولكن مع ذلك، لا ينطبق هذا الأمر على جميع العمليات؛ إذ تعمل بعضها في الخلفية تاركةً إياك في واجهة ضمن مجال اسمها الأصلي. يمكنك ملاحظة أنك تركت مجال الاسم المعتاد بالنظر إلى المعرّف PID الخاص بعمليتك الفرعية الجديدة، وذلك طالما بقيت في جلسة Zsh نفسها: pidof zsh % pid 1 إذا كنت تعرف ولو الشيء اليسير عن أرقام عمليات لينكس التعريفية، فأنت تعلم أن PID ذو القيمة 1 محجوزٌ دائمًا؛ وذلك بسبب طبيعة عملية بدء تشغيل النظام boot (تطبيق systemd على معظم التوزيعات عدا سلاك وير Slackware وديفوان Devuan وبعض الحزم المخصّصة من توزيعة آرش Arch)، إذ من المستحيل أن تكون قيمة PID الخاصة بـ Zsh أو أي تطبيق آخر لا ينتمي لمجموعة تطبيقات بدء تشغيل النظام مساويةً 1، فمن غير الممكن لحاسوبك أن يعمل ويشغل النظام دون وجود عمليّة إقلاع تبدأه، وعلى الرغم من ذلك، تعرض لك الصدفة Zsh أن قيمة العملية بها تشغل القيمة 1. بغض النظر عن المعلومة التي تخبرك بها الصدفة، فالقيمة 1 لم تُستبدل، وتستطيع التأكد من ذلك عن طريق فتح نافذة طرفية جديدة والبحث عن العملية ذات القيمة 1، على النحو التالي: $ ps 1 init تستطيع البحث عن قيمة PID الخاصة بالصدفة Zsh عن طريق: pidof zsh $ 7723 كما تلاحظ من الأوامر السابقة، يعي نظامك المضيف ما الذي يجري، ويعرف أن قيمة PID للصدفة Zsh ليست 1 (لن تكون نتيجة الأمر 7723 إن جرّبتها، وإذا ساوتها فسيكون ذلك وليد الصُدفة). تعتقد الصدفة Zsh أن رقم عمليّتها PID هو 1 بسبب نطاقها Scope المغلق أو المحتوى بداخل مجال الاسم، وبمجرّد إنشاء عملياتٍ فرعية في مجال الاسم هذا، فستبدأ أرقام عمليّاتها بدءًا من الواحد، ولكن في سياق مجال الاسم وحده. تُعَد مجالات الاسم بالإضافة لتقنيات أخرى مثل cgroups وغيرها، أساسًا لمفهوم الحاويات. يساعد فهم فكرة أن مجالات الاسم الفرعية موجودةً داخل سياق مجالات الاسم العامة ضمن بيئة المضيف (يُمثَّل المضيف بالحاسوب في أمثلتنا السابقة، ولكن في التطبيقات الواقعية قد يكون خادمًا أو سحابة هجينة Hybird cloud)، في فهم كيف ولماذا تعمل برامج الحاويات على النحو الذي تعمل به، إذ لا "تعلم" حاوية تشغِّل مدونة ووردبريس Wordpress مثلًا، أنها تعمل ضمن حاوية، بل تعلم أن لها وصولًا لنواة النظام Kernel وقِسمًا من الذاكرة العشوائيّة RAM، بالإضافة لأيٍّ من ملفات الإعدادات Configuration التي زوّدتها؛ لكنها لا تستطيع الوصول إلى المسار الرئيسي Home أو أي مسارات لم تعطها الإذن للوصول إليها. إضافةًً لذلك، لا يمكن للعمليات التي تعمل داخل سياق المدوّنة التأثير على أيٍّ من العمليات الأخرى الموجودة بداخل النظام، وذلك لعدم شمول مجموعة أرقام العمليات -على حدّ علمها- أي عملية قبل 1؛ و1 هي الحاوية التي تعمل بداخلها. تُعَد الحاويات ميزةً قويةً في نظام لينكس، وتتزايد شهرةً يومًا بعد يوم. والآن بما أنك تعلمت كيف تعمل هذه التقنية، جرّب التعامل معها باستخدام بعض الأنظمة المخصصة، مثل كوبيرنيتيس Kubernetes، أو سيلفربلو Silverblue، أو فلاتباك Flatpak، واكتشف بعضًا من إمكانياتها. تعمل الحاويات في نهاية المطاف مثل نظام لينكس، لذا طبّق ما تعرفه عن لينكس وكيفية تثبيته باستخدامها. ترجمة -وبتصرف- للمقال Demystifying namespaces and containers in Linux لصاحبه Seth Kenlon. اقرأ أيضًا كيفية تأمين الحاويات عن طريق سي لينكس SELinux دليل لفهم حاويات لينكس وكيفية التعامل معها بدء تشغيل واستعمال حاويات لينكس (LXC) إجراء مهام معينة عند مختلف مراحل دورة حياة حاويات لينكس (LXC)

يعطّل معظم الأشخاص التأمين المُعزَّز في لينكس Security-Enhanced Linux -أو اختصارًا سي لينوكس SELinux- إذا واجهتهم أي مشكلة خلال عملهم على بيئة لينكس، إذ يبدو أن تعطيلها يحل المشاكل بصورةٍ مفاجئة، لكن هذا يتسبب بخسارتهم لأداة حماية فائقة القوّة والأهميّة. تتزايد التهديدات الأمنية مع تزايد استخدام الحاويات Containers والخدمات المصغرة Microservices ومعمارية الحوسبة الموزّعة Distributed Architecture، وذلك بسبب مشكلة قديمة ومعروفة جيّدًا، ألا وهي: التسارع velocity؛ إذ تتميز الحاويات بمنحك القدرة على التحرك بسرعة وإنجاز المزيد والتغير بسرعة أيضًا. وهذا يعني أن تطبيق الحاويات انتشر بصورةٍ كبيرة، ولكن سرعة تطبيقها محدودة. وستواجهك الكثير من المشاكل ونقاط الضعف خلال استخدامها؛ فهذا أمرٌ طبيعي عندما تسعى لإنجاز الأمور على نحوٍ أسرع. كيف تخفف من التهديدات؟ يقول سن تزو: "المحارب الحكيم يتفادى المعركة". ينطبق هذا الاقتباس على عملية حماية الحاويات بصورةٍ مثالية؛ إذ لتفادي المشكلات (المعارك)، عليك التأكد أن مضيف الحاوية آمن ويستخدَم سي لينكس مثل خط دفاعٍ أوّل. أُطلِق سي لينكس على أنه مشروعٌ مفتوح المصدر في عام 2000، ودُمج مع نواة لينكس في عام 2003. ووفقًا لموقع Red Hat's explainer، فإن سي لينكس هو معماريّة أمان لأنظمة لينكس، تسمح لمسؤولي النظام بالتحكم بمن لديه صلاحية الولوج للنظام، وقد طوِّرت البرمجية من قبل وكالة الأمن القومي United States National Security Agency -أو اختصارًا NSA-، بكونها سلسلةً ضمن مجموعةٍ من الرُقع Patches لـ نواة لينكس باستخدام وحدات أمن لينكس Linux Security Modules -أو اختصارًا LSM". البداية عندما تسمع كلمة حاويات، سيتبادر لذهنك أولًا دوكر Docker، فقد بدأ دوكر بثورةٍ ساهمت بتبنٍ واسعٍ لتقنية الحاويات بعد ظهوره في عام 2013؛ فهو من أبرز الأسباب التي ساهمت بانتشار شعبية الحاويات. وكما ذكرنا سابقًا، ساهم تزايد معدل تبنّي هذه التقنية بتزايد معدل الثغرات الأمنية. قبل البدء بعملية تأمين حاويات دوكر باستخدام سي لينكس، عليك تجهيز بعض الأشياء. المتطلبات نظام تشغيل سينت أو إس CentOS إصدار 8/RHEL مُثبت ومهيّأ. دوكر Docker CE مُثبَّت ومهيّأ. حسابين مستخدم، إحداها بصلاحيات الجذر root والآخر بدون؛ وهو موجود باسم mcalizo في الأمثلة ضمن هذه المقالة. يمكنك اتباع التعليمات، إذا أردت تثبيت دوكر على خادم CentOS RHEL/8؛ وإذا كنت تعمل على RHEL 8، فعليك إزالة الحزمتين المثبّتتين تلقائيًّا Podman وrunc قبل البدء. دعنا نتأكد أوّلًا من أن سي لينكس يعمل: mcalizo@Rhel82 ~]$ sestatus] SELinux status: enabled SELinuxfs mount: /sys/fs/selinux SELinux root directory: /etc/selinux Loaded policy name: targeted Current mode: enforcing Mode from config file: enforcing Policy MLS status: enabled Policy deny_unknown status: allowed (Memory protection checking: actual (secure Max kernel policy version: 31 $ [ ~ mcalizo@Rhel82] من ثم، تأكد أن إصدار نظام التشغيل الخاص بك ودوكر يعملان. سجّل الدخول مثل مستخدمٍ بصلاحيات الجذر، ونفّذ التعليمات التالية: root@rhel82 ~]# cat /etc/redhat-release] (Red Hat Enterprise Linux release 8.2 (Ootpa [root@rhel82 ~]# root@rhel82 ~]# systemctl status docker] docker.service - Docker Application Container Engine ● (Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled Active: active (running) since Wed 2020-10-28 19:10:14 EDT; 15s ago Docs: https://docs.docker.com (Main PID: 30768 (dockerd Tasks: 8 Memory: 39.0M CGroup: /system.slice/docker.service └─ 30768 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock Oct 28 19:10:13 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:13.889602941-04:00" level=error msg="> Oct 28 19:10:13 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:13.903413613-04:00" level=warning msg> Oct 28 19:10:13 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:13.903427451-04:00" level=warning msg> Oct 28 19:10:13 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:13.903538271-04:00" level=info msg="L> Oct 28 19:10:14 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:14.132060506-04:00" level=info msg="D> Oct 28 19:10:14 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:14.308943088-04:00" level=info msg="L> Oct 28 19:10:14 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:14.319438549-04:00" level=info msg="D> Oct 28 19:10:14 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:14.319570298-04:00" level=info msg="D> Oct 28 19:10:14 rhel82.home.labs.com dockerd[30768]: time="2020-10-28T19:10:14.333419209-04:00" level=info msg="A> Oct 28 19:10:14 rhel82.home.labs.com systemd[1]: Started Docker Application Container Engine تحقق من إصدار دوكر لديك: root@rhel82 ~]# docker --version] Docker version 19.03.13, build 4484c46d9d اخترق المضيف أفضل الطرق للتعلم هي خوض التجربة، لذلك سنبيّن في هذه الفقرة سهولة اختراق مضيف دوكر باستخدام شيفرة حقن Injection خبيثة، إذا لم يكن أمن الحاوية مُعدًّا على النحو الصحيح. لكي تكون قادرًا على إجراء هجومٍ ما على المضيف، يجب أن يكون المستخدم الخبيث الذي لا يملك صلاحيات الجذر (باسم mcalizo في أمثلتنا) منتميًا للمجموعة التي أنشأت حاويات دوكر. وللتأكد من ذلك، نتفقّد المجموعة التي ينتمي إليها الحساب mcalizo عن طريق: root@Rhel82 ~]# groups mcalizo] mcalizo : mcalizo تُظهِر رسالة الخَرج أن الحساب mcalizo ينتمي لمجموعته الخاصة، وهذا يعني أنه لا يمكنه إنشاء حاوية دوكر. وإذا حاولت إنشاء حاوية دوكر باستخدام الحساب سيظهر الخطأ التالي: mcalizo@Rhel82 ~]$ docker run -it --rm centos:latest /bin/sh] docker: Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Post http://%2Fvar%2Frun%2Fdocker.sock/v1.40/containers/create: dial unix /var/run/docker.sock: connect: permission denied. See 'docker run --help'. للسماح لحساب mcalizo بإنشاء الحاوية، أضِف المستخدم لمجموعة docker: root@Rhel82 ~]# usermod -G docker -a mcalizo] root@Rhel82 ~]# groups mcalizo] mcalizo : mcalizo docker ثم أنشئ حاويةً من نوع fedora:latest وادخل إليها لتكتشفها: mcalizo@Rhel82 ~]$ docker run -it --rm fedora:latest /bin/sh] Unable to find image 'fedora:latest' locally latest: Pulling from library/fedora ee7e89337106: Pull complete Digest: sha256:b9ec86d36fca7b1d3de39cd7c258e8d90c377d312c21a7748071ce49069b8db4 Status: Downloaded newer image for fedora:latest sh-5.0# cat /etc/redhat-release (Fedora release 33 (Thirty Three ستُسجَّل مثل مستخدم بصلاحيات الجذر تلقائيًّا، عندما تسجل الدخول لحاوية منشأة جديدًا: sh-5.0# whoami root sh-5.0# تستطيع فعل أي شيء بداخل الحاوية بصفتك مستخدمًا بصلاحيات الجذر؛ وهذا يعني أنك تستطيع إساءة استخدام مضيف الحاوية وتتسبّب بكثيرٍ من الضرر. تعني قدرتك على إنشاء الحاويات أنّك تستطيع فعل أي شيء للمضيف، حتى إن لم تكن جزءًا من المستخدمين بصلاحيات الجذر على الجهاز المضيف. لتوضيح الثغرة الأمنية هذه، أُخرج من الحاوية التي أنشأتها وأنشئ حاويةً جديدة: mcalizo@Rhel82 ~]$ docker run -it --rm -v /:/exploit fedora:latest /bin/bash] #[root@131043f2e306 /] ينقل الخيار ‎-v مسار المضيف الرئيس الخاص بدوكر / إلى مسار الحاوية المدعوّ exploit/: /root@131043f2e306 /]#ls exploit] bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var بسبب عملية النقل هذه، تستطيع فعل أي شيء على جهاز دوكر المضيف؛ إذ يمكنك مثلًا حذف الملفات، أو تعديل ملفات الضبط بهدف إلحاق الضرر بالنظام، أو تثبيت تطبيق حصان طروادة أو برمجيات خبيثة مشابهة لسرقة البيانات المهمة. سبب هذه الثغرة لعلك تتسائل عن سبب حدوث ذلك بالرغم من أن سي لينكس مفعّل، إذ نستطيع فهم ما السبب بالتحديد، من خلال النظر الدقيق لكيفية عمل سي لينكس. تأكد من أن سي لينكس يحتوي على سياق دوكر Docker Context: mcalizo@Rhel82 ~]$ ps -eZ | grep docker] system_u:system_r:container_runtime_t:s0 30768 ? 00:00:04 dockerd $[~ mcalizo@Rhel82] يحتوي سي لينكس على السياق كما توقعنا؛ وهذا يعني أن سي لينكس مسؤولٌ عن إدارة عفريت دوكر Docker daemon. افحص عفريت دوكر للتحقُّق مما إذا كان سي لينكس مفعّلًا تلقائيًا: mcalizo@Rhel82 ~]$ docker info | grep Security -A3] :Security Options seccomp Profile: default Kernel Version: 4.18.0-193.el8.x86_64 كما نلاحظ، سي لينكس غير مفعَّل تلقائيًا، بالتالي لقد وجدنا المشكلة، وكل ما علينا فعله هو تفعيل سي لينكس لسد الثغرة؛ بحيث يتحكّم ويدير دوكر. ولتفعيل سي لينكس، أنشئ ملفًّا في المسار etc/docker/daemon.json كما هو موضح هنا، ولكن يجب أن تمتلك صلاحيات الجذر لتفعيله: root@Rhel82 ~]# cat /etc/docker/daemon.json] { "selinux-enabled": true } #[~ root@Rhel82] root@Rhel82 ~]# systemctl restart docker] بعد إنشائك للملف أو تحديثه، وإعادة تشغيل دوكر؛ يجب أن ترى أن سي لينكس مفعّل في عفريت دوكر: root@Rhel82 ~]# systemctl restart docker] mcalizo@Rhel82 root]$ docker info | grep Security -A3] :Security Options seccomp Profile: default selinux [mcalizo@Rhel82 root]$ على الرغم من أنّ وصل مسارات ملفات filesystem معيّنة لمضيف دوكر داخل حاوية دوكر ما زال ممكنًا، إلّا أنّ تحديث الملفات أو الوصول إليها أصبح غير متاحًا الآن: mcalizo@Rhel82 root]$ docker run -it --rm -v /:/exploit fedora:latest /bin/bash] root@ecb5836da1f6 /]# touch /exploit/etc/shadow.sh] touch: cannot touch '/exploit/etc/shadow.sh': Permission denied #[/ root@ecb5836da1f6] تعتمد درجة أمان حاويتك على قوة أمان نظام تشغيل مضيف الحاوية. وهناك كثيرٌ من الوسائل لتأمين نظام لينكس، والعديد منها متاحٌ بهدف زيادة أمان نظامك. يتواجد سي لينكس افتراضيًا مع توزيعات لينكس ليضيف طبقةً إضافية من الحماية؛ فتأكد من تفعيله وعمله صحيحًا للاستفادة منه ومن الحماية التي يقدمها لنظامك. ترجمة -وبتصرف- للمقال Secure your containers with SELinux لصاحبه Mike Calizo. اقرأ أيضًا بدء تشغيل واستعمال حاويات لينكس (LXC) التعامل مع حاويات Docker إجراء مهام معينة عند مختلف مراحل دورة حياة حاويات لينكس (LXC) مدخل إلى حاويات لينكس LXC

هل يمكنك الحصول على حاويات لينكس Linux Containers دون استخدام Docker أو OpebShift أو Kubernetes؟ نعم، يمكنك، فقد طوّر مشروع LXC مفهوم تشغيل نظام تشغيل افتراضي يعمل على نواة النظام، ومُحتوًى ضمن مجموعةٍ من التعليمات المعرفة مسبقًا، وذلك قبل سنوات عدّة من ظهور Docker وانتشار مصطلح الحاويات. في الحقيقة، بُنيَ Docker على مشروع LXC، وتتوافر اليوم كثيرٌ من المنصات التي تُبرِز مزايا LXC بصورةٍ مباشرة أو غير مباشرة، كما تبسّط معظم هذه المنصات عملية إنشاء وإدارة الحاويات بصورةٍ ملحوظة، ومن المنطقي أن تُستخدم هذه الأدوات المتخصصة في مشروعات كبيرة، لكن لا تنطبق هذه الحالة على الجميع، إذ من المحتمل ألا تدير مشروعًا كبيرًا، وألا تكون لديك الرغبة بالوصول إلى خدمات كبيرة وتعلّم أدوات مخصّصة لإنشاء الحاويات. لحسن الحظ، تستطيع إنشاء واستخدام وتعلّم الحاويات باستخدام حاسوبٍ يعمل على نظام لينكس ضمن هذا الدليل؛ إذ سنساعدك في فهم الحاويات باستخدام LXC، وكيفية عملها، ولماذا تعمل، وكيف تصحّح الأخطاء إذا واجهت أي مشكلات. تثبيت LXC إذا كنتَ تبحث عن مصدر سريع لفهم مشروع LXC، فزُر موقع المشروع الرسمي. إذا لم يكن LXC مثبتًا بعد على جهازك، فثبّته باستخدام مدير الحزم على لينكس. وبالنسبة لتوزيعة فيدورا Fedora والتوزيعات المشابهة، اكتب: sudo dnf install lxc lxc-templates lxc-doc $ أما بالنسبة لتوزيعتي ديبيان Debian وأوبنتو Ubuntu والتوزيعات المشابهة، فاكتب: sudo apt install lxc $ إنشاء جسر للشبكة تفترض معظم الحاويات توافر اتّصال بالشبكة، كما تفترض معظم أدوات إدارة الحاويات أن المستخدم سينشئ شبكات افتراضية. يُعد جسر الشبكة network bridge من المكونات الأساسية في أيّ حاوية، وهو يكافئ إلى حدٍ ما مبدّل switch شبكة، إذ يعمل بمثابة مأخذ ذكي ذي مخرجين Y-Adapter، مثل مأخذ سماعات الرأس الذي يسمح لك ولصديقك بالاستماع للصوت في الوقت ذاته باستخدام سماعتين منفصلتين، والفرق هنا هو أنّ الإشارة التي تُنقل هي حزم البيانات وليس إشارة الصوت. يمكنك إنشاء جسر للشبكة برمجيًّا، لتمكين كلٍّ من حاسوبك المضيف والنظام المحتوى من إرسال واستقبال البيانات عبر الشبكة باستخدام جهاز اتصالٍ واحد، مثل منفذ الإيثرنت Ethernet، أو شريحة الاتصال اللاسلكية. يُهمل هذا الجانب الأساسي غالبًا عند استخدامك لبرنامج يولّد حاويات النظام تلقائيًا، وذلك رغم أهميته؛ إذ من المستبعد أن تخصّص جهاز اتصال فيزيائي لكل حاوية تشغّلها. وبالتالي يجب أن تستوعب أنّ الحاويات تتعامل مع أجهزة اتصال افتراضية، وفهمك لهذا سيساهم في نجاح عملية تصحيح الأخطاء، إذا فقدت الحاوية اتّصالها بالشبكة. لإنشاء جسرٍ للشبكة على جهازك، عليك الحصول على الأذونات المطلوبة. ومن خلال تنفيذك للتعليمات في هذا الدليل، استخدم الأمر sudo الذي سيعطيك صلاحيات الجذر؛ بينما يقدم توثيق LXC طريقةً لتهيئة صلاحيات المستخدمين دون استخدام الأمر sudo. sudo ip link add br0 type bridge $ يمكن التحقق من عملية إنشاء واجهة الشبكة الافتراضية بنجاح عن طريق: sudo ip addr show br0 $ 7: br0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default qlen 1000 link/ether 26:fa:21:5f:cf:99 brd ff:ff:ff:ff:ff:ff بما أنّ br0 واجهة شبكة افتراضية Virtual Network Interface، فهو يتطلب عنوان بروتوكول الإنترنت الخاص به. لذلك، اختر عنوانًا محليًا صالحًا لا يتعارض مع أي عنوانٍ آخر موجود على شبكتك، واربطه مع جهاز الشبكة الافتراضية br0 على النحو التالي: sudo ip addr add 192.168.168.168 dev br0 $ تأكّد في النهاية أن br0 يعمل بنجاح من خلال الأمر التالي: sudo ip link set br0 up $ تهيئة تكوين الحاوية قد يكون ملف ضبط Config حاوية LXC معقدًا بحسب الحاجة لتهيئة الحاوية على شبكتك ونظام المضيف، ولكن سيكون ملف الضبط في مثالنا التالي بسيطًا. أنشئ ملفًا باستخدام أي محرر نصوص تفضّله، وعرّف اسمًا للحاوية واكتب إعدادات الشبكة: lxc.utsname = opensourcedotcom lxc.network.type = veth lxc.network.flags = up lxc.network.link = br0 lxc.network.hwaddr = 4a:49:43:49:79:bd lxc.network.ipv4 = 192.168.168.1/24 lxc.network.ipv6 = 2003:db8:1:0:214:1234:fe0b:3596 احفظ هذا الملف في المسار الرئيسي Home باسم mycontainer.conf، وتكون تسمية lxc.utsname اختياريّة، إذ يمكنك تسمية الحاوية كما شئت، وستستخدم هذا الاسم لتشغيل وإيقاف الحاوية. يُضبط نوع الشبكة إلى veth، وهو نوع من كابلات الإيثرنت Ethernet الافتراضية؛ إذ يتمحور مبدأ عملها في إرسال الاتصال من نوع veth من الحاوية إلى جهاز جسر الشبكة، المُعرّف بخاصية lxc.network.link، وبقيمة br0. يقع عنوان بروتوكول الإنترنت الخاص بالحاوية في شبكة جهاز التجسير نفسها، ولكنّه مختلف لتفادي أي تعارض. جميع القيم متغيّرة ويمكن تعديلها حسب الحاجة، باستثناء نوع الشبكة veth وراية الشبكة up. ويمكن استعراض لائحة الخصائص عن طريق الأمر man lxc.container.conf؛ وإذا كان الأمر مفقودًا من نظامك، تفقّد مدير الحزم للحصول على حزم توثيق LXC منفصلة. هناك كثيرٌ من الأمثلة التي يمكنك مطالعتها لاحقًا على هيئة ملفات ضبط ضمن المسار usr/share/doc/lxc/examples. تشغيل صدفة الحاوية أنجزنا أكثر من نصف العمل اللازم لإنشاء حاوية؛ فقد أنشأنا بنية الشبكة التحتية، وثبتنا شريحة الاتصال الافتراضية على حاسوبنا الافتراضي؛ وبقي الآن تثبيت نظام التشغيل الخاص بالحاوية. ولكن يمكنك رؤية حاوية LXC تعمل بتشغيل الصدفة Shell ضمن مساحة الحاوية دون تثبيت نظام التشغيل، من خلال الأمر التالي: \ sudo lxc-execute --name basic $ \ rcfile ~/mycontainer.conf /bin/bash-- logfile mycontainer.log-- # في هذه المرحلة من بناء الحاوية، ألقِ نظرةً على إعدادات الشبكة، إذ ستكون مشابهةً لتلك الموجودة في الأسفل ولكن بقيم فريدة: /usr/sbin/ip addr show # 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state [...] link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo [...] 22: eth0@if23: <BROADCAST,MULTICAST,UP,LOWER_UP> [...] qlen 1000 link/ether 4a:49:43:49:79:bd brd ff:ff:ff:ff:ff:ff link-netnsid 0 inet 192.168.168.167/24 brd 192.168.168.255 scope global eth0 valid_lft forever preferred_lft forever inet6 2003:db8:1:0:214:1234:fe0b:3596/64 scope global valid_lft forever preferred_lft forever [...] تميِّز الحاوية بنية الشبكة المزيفة، ونواة النظام المستخدمة: uname -av # Linux opensourcedotcom 4.18.13-100.fc27.x86_64 #1 SMP Wed Oct 10 18:34:01 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux استخدم الأمر exit لمغادرة الحاوية: exit # تثبيت نظام تشغيل الحاوية تُعَد عملية بناء بيئة مُحتواة كاملة من البداية معقدةً أكثر موازنةً بمرحلة تهيئة الشبكة الافتراضية وضبطها، لذا يمكننا استخدام قوالب حاويات جاهزة من LXC. وإذا لم يحتو جهازك على أيّ قالب، فألقِ نظرةً على حزمة قوالب LXC الموجودة ضمن مستودع برمجيّتك. ويكون المسار الافتراضي لقوالب LXC هو usr/share/lxc/templates. ls -m /usr/share/lxc/templates/ $ lxc-alpine, lxc-altlinux, lxc-archlinux, lxc-busybox, lxc-centos, lxc-cirros, lxc-debian, lxc-download, lxc-fedora, lxc-gentoo, lxc-openmandriva, lxc-opensuse, lxc-oracle, lxc-plamo, lxc-slackware, lxc-sparclinux, lxc-sshd, lxc-ubuntu, lxc-ubuntu-cloud اختر قالبك المفضل، وأنشئ الحاوية. استخدمنا في مثالنا هذا قالب Slackware. sudo lxc-create --name slackware --template slackware $ ستعلّمك مشاهدة عملية تنفيذ القالب عن كثب الكثير عن كيفية عمل القوالب، وكأنّك تبني قالبًا من الصفر بيديك؛ إذ تُوصَف عملية التنفيذ بأنها واضحة ومسهبة، وتستطيع ملاحظة أن lxc-createيضبط جذر Root الحاوية للمسار var/lib/lxc/slackware/rootfs، كما يمكن تحميل وتثبيت كثيرٍ من الحزم في هذا المسار أيضًا. تمنحك قراءة ملفات القالب فهمًا أكبر لكيفية عمل شجرة الأجهزة الدنيا minimal device tree وملفات تخزين البيانات المؤقتة Spool الشائعة وملف جدول الأنظمة fstab وملفات init وغيرها، كما تمنع القوالب بعض الخدمات التي لا تحتوي على فائدة مرجوّة في الحاويات من العمل، مثل udev للتعرُّف على العتاد الصلب. ونظرًا لاحتواء القوالب على عددٍ كبيرٍ من إعدادات لينكس التقليدية، فمن الأفضل بناء القالب مع التقيُّد بقالبٍ مشابه للقالب الذي تبنيه (إذا أردت بناء قالبٍ من الصفر)، وذلك تجنّبًا للأخطاء والعثرات التي قد تحدث، مثل بعض الأخطاء التي كُشف عنها وعولجت من قِبل مشروع LXC. بعد تهيئة بيئة نظام التشغيل الأساسيّة، تستطيع بدء الحاوية من خلال الأمر التالي: \ sudo lxc-start --name slackware $ rcfile ~/mycontainer.conf-- بكتابتك للأمر السابق، تكون قد بدأت تشغيل الحاوية، ولكنك لم تربطها بعد؛ فبعكس المثال السابق، أنت لا تتعامل مع الحاوية في سطر الأوامر Shell، وإنما تتعامل مع نظام تشغيل محتوى، لهذا اربط الحاوية بالاسم، عن طريق الأمر: sudo lxc-attach --name slackware $ # تأكد أن عنوان بروتوكول الإنترنت التابع للحاوية وعنوان بروتوكول الإنترنت في ملف الضبط Config متماثلان، عن طريق: usr/sbin/ip addr SHOW | grep eth/ # 34: eth0@if35: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 [...] 1000 link/ether 4a:49:43:49:79:bd brd ff:ff:ff:ff:ff:ff link-netnsid 0 inet 192.168.168.167/24 brd 192.168.168.255 scope global eth0 اُخرُج من الحاوية، وأغلقها عن طريق: exit # sudo lxc-stop slackware $ استخدام حاويات LXC في التطبيقات الواقعية يسهّل لنا مشروع LXC عملية إنشاء وتشغيل حاوية آمنة. تطورت الحاويات كثيرًا منذ ظهورها أول مرة بواسطة LXC في عام 2008، وننصحك بالاستفادة من خبرات مطوّريها لمصلحتك. على الرغم من وضوح توجيهات دليل LXC، إلّا أن هدفنا في هذا الدليل هو توفير فهمٍ أعمق لما يحصل خلال تنفيذ هذه الأوامر خلف الكواليس. ترجمة -وبتصرف- للمقال Behind the scenes with Linux containers لصاحبه Seth Kenlon اقرأ أيضًا إجراء مهام معينة عند مختلف مراحل دورة حياة حاويات لينكس (LXC) ألف باء أساسيات التعامل مع لينكس

يُعَد فهم الشبكات جزءًا أساسيًّا من تهيئة كيانات معقدة على الإنترنت، ويؤثر ذلك كثيرًا على كفاءة تواصل الخوادم بين بعضها بعضًا، وتطوير ضوابط أمان للشبكات، وإبقاء عقد الاتّصال منظمة. شرحنا في الدليل السابق بعض المصطلحات المهمة في عالم الشبكات. اطّلع على الدليل إذا أردت فهم المفاهيم، التي سنستعرضها هنا. سنناقش في هذا المقال بعضًا من المفاهيم المرتبطة بتصميم شبكات الحاسوب والتفاعل معها، كما سنغطّي على وجه التحديد أصناف الشبكات Network Classes، والشبكات الفرعية Subnets، والتوجيه غير الصنفي بين النطاقات CIDR لتجميع عناوين بروتوكول الإنترنت. فهم عناوين بروتوكول الإنترنت IP Addresses يجب أن يحتوي كلّ موقعٍ أو جهاز على الشبكة عنوانًا يدل عليه، وهذا يعني أنه يمكن الوصول إلى أي موقع أو جهاز عن طريق معرفة العنوان الخاص به، بحيث ينتمي هذا العنوان لنظام عناوينٍ ما مُعرَّف بواسطته؛ ففي حالة شبكة من نمط بروتوكول الإنترنت TCP/IP الاعتياديّة، يُعالَج الأمر باستخدام عدة طبقات، لكن عندما نذكر "عنوانًا على الشبكة" فنحن نقصد غالبًا عنوان بروتوكول الإنترنت. تمكننا عناوين بروتوكول الإنترنت من الوصول لموارد شبكةٍ ما باستخدام واجهتها Interface؛ فإذا أردنا إجراء اتّصال بين حاسوبٍ وحاسوب آخر مثلًا، فنحن بحاجة لإرسال المعلومات باستخدام بروتوكول الإنترنت الخاص بالحاسوب المتلقّي. يمكننا نظريًا فعل ذلك، وهذا بفرض أنّ الجهازين على الشبكة نفسها، أو أن هناك بعض الأجهزة الوسيطة التي تفسّر الطلب عبر عدّة شبكات. لا ينبغي تكرار عنوان بروتوكول الإنترنت ذاته على الشبكة نفسها، فكلّ عنوان فريدٌ عن غيره؛ ويمكن للشبكات أن تُعزل أو تُربط ببعضها بعضًا بعد تهيئتها لتضمن الوصول بين شبكتين منفصلتين. يسمح نظام ترجمة عنوان الشبكة Network Address Translation -أو اختصارًا NAT-، بإعادة كتابة العناوين عندَ إرسال حزمٍ من البيانات بين شبكتين، وذلك بهدف وصول الحزم لوجهتها النهائية. وبالتالي يمكننا بفضل هذا النظام استعمال عناوين متشابهة ضمن عدّة شبكاتٍ معزولة دون أيّ مشكلات. الفرق بين معياري IPv4 وIPv6 هناك معياران لبروتوكول الإنترنت، ومُستخدمان بكثرة ضمن أنظمة الاتّصالات، هما: معيار IPv4 ومعيار IPv6. نظرًا للتحسينات التي طرأت على معيار IPv6، فهو يستبدل ببطء معيار IPv4 المحدود؛ والسبب في ذلك ببساطة هو احتواء العالم على كثيرٍ من الأجهزة المتصلة بالإنترنت ولا يكفي معيار IPv4 لسدّ الحاجة. يكون عنوان معيار IPv4 بطول 32 بِت، ويُقسَّم إلى 4 أقسام، إذ يكون كل واحدٍ منها بطول بايت أو 8 بِت، ويفصل بين كل بايتٍ وآخر نقطة ويُمثَّل كل بايت برقم من 0 إلى 255. بالرغم من أنّ العنوان يتألّف من أرقام في النظام العشري ليسهل التعامل بها بواسطتنا نحن البشر، إلّا أنّها في الحقيقة قيمٌ مُمثّلة بثمان خانات (واحدات وأصفار)، وتدعى كل 8 خانات بثُمانيّة Octet. يبدو عنوان IPv4 الاعتيادي على النحو التالي: 192.168.0.5 إذ أن أعلى قيمة ممكنة هي 255، وأصغر قيمة هي 0. يمكننا التعبير عن العنوان السابق باستخدام النظام الثنائي، بحيث نفصل بين كل ثمانيّة وأخرى بشَرطة بدل نقطة، ونفصل بمسافةٍ بين كل 4 خانات بهدف تسهيل قراءة العنوان: 1010 0000 - 0000 0000 - 1000 1010 - 0000 1100 لا بُد أن نفهم جيّدًا أن التمثيلين السابقين متكافئين، فهذا مهمّ لاستيعاب المفاهيم التي سترِد لاحقًا. على الرغم من وجود بعض الاختلافات الأخرى بين المعيارين بخصوص البروتوكول وكيف يعمل كلّ منهما، إلّا أن الفرق الأبرز هو اختلاف سعة كلّ منهما؛ إذ يُمثَّل معيار IPv6 عنوان بروتوكول الإنترنت باستخدام رقم مؤلف من 128 بِت؛ وبالتالي يحوي IPv6 ما يساوي: 7.9 x 10²⁸ ضعف ما يستطيع معيار IPv4 تمثيله. يُكتب عنوان بروتوكول الإنترنت بمعيار IPv6 متمثّلًا بثمانية أقسام؛ ويتكوّن كل قسم من 4 خانات في النظام السداسي عشري. يحتوي النظام السداسي عشري على 16 رقم من 0 إلى 15، ويُمثَّل بالأرقام من 0 إلى 9 بالإضافة للأحرف من A إلى F. هذا ما قد يبدو عليه عنوان بروتوكول إنترنت بمعيار IPv6: 1203:8fe0:fe80:b897:8990:8a7c:99bf:323d قد ترى أن بعض العناوين مكتوبةً أقصر من السابق، إذ يمكن اختصار الخانات الصفرية اليسرى لأي ثمانيّة دون أن تؤثر على قيمة العنوان، كما يمكن اختصار ثمانيّة صفرية باستخدام "::". على سبيل المثال إن كان لدينا ثمانيّة ما في عنوان IPv6 على النحو التالي: ...:00bc:... فيمكننا اختصاره إلى: ...:bc:... لتوضيح الحالة الثانية المذكورة، سنفترض أنه لدينا العنوان التالي الذي يحتوي على ثمانيّات صفريّة: ...:18bc:0000:0000:0000:00ff:... يمكن كتابته بصيغةٍ مختصرة، وذلك عن طريق إزالة الأصفار اليسرى واستبدال الثمانيّات الصفرية بالرمز "::"، وفق: ...:18bc::ff... ولكن يمكن اختصار الثمانيّات الصفرية مرّةً واحدةً في العنوان؛ وإلّا فلن تكون قادرًا على إعادته للعنوان الكامل مرةً أخرى. رغم أنّ المعيار IPv6 أكثر شيوعًا وانتشارًا هذه الأيام، إلّا أننا سنبني شرحنا وأمثلتنا على معيار IPv4، نظرًا لسهولة التعامل معه واحتوائه على خاناتٍ أقلّ. أصناف عنوان IPv4 والنطاقات المحجوزة تحتوي عناوين بروتوكول الإنترنت عادةً على مكوّنين يدلّان على معلومتين؛ إذ يدلّ المكون الأول على الشبكة network التي ينتمي العنوان إليها؛ بينما يدلّ المكون الثاني على جهاز معيّن (مضيف host) على الشبكة. ويعتمد موضع بدء المكون وانتهائه على الطريقة التي هُيئت بها الشبكة، وسنتكلّم عن ذلك في الفقرات التالية. تتوزع عناوين IPv4 على أربعة أقسام تدعى بالأصناف Classes، من A إلى E، هدفها الفصل بين نطاقات عناوين الإنترنت المتاحة وتجزئتها. يمكننا معرفة صنف كل عنوان عن طريق ملاحظة أول أربعة بِتات، إذ يُعرَّف صنف العنوان بواسطتها. نستطيع التعرف على صنف العنوان على النحو التالي: الصنف A ‎0---‎: يبدأ أول بِت من عنوان IPv4 ذو الصنف A بالصفر، وأي عنوان يقع بين المجال 0.0.0.0 و127.255.255.255 ينتمي للصنف A. الصنف B ‎10--‎: يحتوي الصنف B على جميع العناوين بين المجال 128.0.0.0 و 191.255.255.255. أو بمعنى آخر، أي عنوانٍ يحتوي على 1 في البِت الأول، و 0 في البِت الثاني. الصنف C ‎110‎-‎: يحتوي الصنف C على جميع العناوين بين المجال 192.0.0.0 و223.255.255.255. أو بمعنى آخر، أي عنوانٍ يحتوي على 1 في البِت الأول والثاني، و0 في الثالث. الصنف D ‎1110‎: يحتوي الصنف D على جميع العناوين بين المجال 244.0.0.0 و329.255.255.255. بمعنى آخر، أي عنوانٍ يحتوي على 1 في البِت الأول والثاني والثالث، و0 في الرابع. الصنف E 1111: يحتوي الصنف E على جميع العناوين بين المجال 240.0.0.0 و255.255.255.255. بمعنى آخر، أي عنوان يحتوي على 1 في البِت الأول والثاني والثالث والرابع. الصنف D مخصّص لبروتوكولات التحويل المتعدد Multi-casting، التي تسمح بإرسال حزم البيانات لمجموعةٍ من المضيفين دفعةً واحدةً. عناوين الصنف E محجوزة للاستخدام المستقبلي والتجريبي، وهي غير مُستخدمة غالبًا. تقسِّم كل من الأصناف A و B و C الشبكات والأجهزة المضيفة على نحوٍ مختلف وفقًا لحجم الشبكة؛ إذ يستخدم الصنف A الخانات المتبقية من الثُمانيّة الأولى في تمثيل الشبكة، ويُمثّل المضيف بباقي العنوان. يُعد هذا الصنف جيدًا لتعريف شبكاتٍ قليلة تضمّ كثيرًا من الأجهزة المضيفة. يستخدم الصنف B أوّل ثمانيّتان (المتبقي من الثمانية الأولى، وكامل الثمانية الثانية) في تمثيل الشبكة والمتبقي من العنوان لتمثيل الأجهزة المضيفة؛ بينما يستخدم الصنف C أوّل ثلاث ثمانيّات لتمثيل الشبكة، والثمانية الأخيرة لتمثيل الجهاز المضيف داخل الشبكة. تقسيم عنوان بروتوكول الإنترنت لأصناف عدّة طريقةٌ قديمةٌ بعض الشيء، إذ قُدِّمَت هذه الطريقة مثل حلٍ لمشكلة نفاذ عناوين IPv4، وذلك نظرًا لإمكانية وجود عدة حواسيب للمضيف ذاته وتابعة لشبكاتٍ مختلفة، واستُبدلت هذه الطريقة بطرقٍ أخرى سنناقشها. النطاقات الخاصة المحجوزة هناك بعض الأجزاء من عنوان IPv4 المحجوزة لأغراضٍ معينة. ويُعد نطاق الاسترجاع Loopback Range واحدًا من أكثر النطاقات المحجوزة إفادةً، وهو مُحددٌ بالنطاقات ما بين 127.0.0.0 و 127.255.255.255؛ إذ يُستخدم هذا النطاق من قبل المضيف لفحص سلامة الشبكة، ويُستخدم أوّل عنوان في النطاق غالبًا وهو 127.0.0.1. يمتلك كل صنف من أصناف عنوان الإنترنت نطاقًا محجوزًا للشبكات الخاصة؛ إذ أن نطاق العناوين من 10.0.0.0 إلى 10.255.255.255 محجوزٌ للشبكات الخاصة للعناوين من الصنف A؛ بينما يوجد للصنف B النطاق المحجوز من 172.16.0.0 إلى 172.31.255.255، وأخيرًا للصنف C النطاق من 192.168.0.0 إلى 192.168.255.255. يمكن لأي حاسوب غير متّصل بالإنترنت مباشرةً، بمعنى غير متصل عبر جهاز توجيه Router، أو نظامٍ لترجمة عناوين الشبكات NAT، استخدام العناوين المذكورة في أي وقت. هناك بعض نطاقات العناوين الإضافية المحجوزة لأغراض معيّنة، يمكنك مراجعة ملخص ويكيبيديا لمزيدٍ من المعلومات عنها. أقنعة الشبكة والشبكات الفرعية تُدعى عملية تقسيم الشبكة إلى شبكات فرعية أصغر منها بتفريع الشبكة Subnetting، إذ تُعد هذه العملية مفيدةً في كثيرٍ من الحالات، وتساعد بعزل مجموعات من المضيفين عن بعضها بعضًا للتعامل معها بسهولة. كما ناقشنا سابقًا، يمكن تجزئة كل نطاق من عناوين بروتوكول الإنترنت إلى جزء يدل على الشبكة، وآخر يدل على المضيف؛ إذ يعود طول الجزء الذي يدلّ على كلٍّ منهما للصنف الذي ينتمي إليه هذا العنوان؛ فبالنسبة لعنوانٍ من الصنف C مثلًا، تُستخدم أوّل ثلاث ثمانيّات للدلالة على الشبكة. إذًا، يدل الجزء 192.168.0 بالنسبة للعنوان 192.168.0.15 على الشبكة، ويدلّ 15 على المضيف. تحتوي كل شبكة افتراضيًا على شبكةٍ فرعية واحدة، وتضمّ هذه الشبكة الفرعية على جميع عناوين المضيفين المعرّفة بداخلها. ويُعَد قناع الشبكة بمثابة توصيفٍ لعدد بِتّات العنوان المستخدم في الشبكة الفرعية هذه؛ وقناع الشبكة الفرعية هو قناع شبكة آخر يُستخدم لتقسيم الشبكة لأقسامٍ أكثر. كلّ بِت في العنوان هامٌ في التمثيل والدلالة على الشبكة يجب أن يُمثّل بـ 1 في قناع الشبكة، إذ يمكننا مثلًا تمثيل العنوان 192.168.0.15، الذي ناقشناه في مثالنا السابق بالترميز الثنائي على النحو التالي: 1100 0000 - 1010 1000 - 0000 0000 - 0000 1111 كما شرحنا في السابق، تمثّل الثمانيّات الثلاثة الأولى الجزء الذي يدل على الشبكة في عنوان من التصنيف C، أو بكلماتٍ أخرى، الأربع وعشرين بتًا الأوّليات. ونظرًا لأن هذه هي البتات المهمة التي نريد الاحتفاظ بها، فسيكون قناع الشبكة على النحو التالي: 0000 0000 - 1111 1111 - 1111 1111 - 1111 1111 يمكننا كتابة قناع الشبكة السابق بترميز IPv4 اعتيادي، أي 255.255.255.0؛ إذ أن كل بِت يتخذ القيمة 0 بالتمثيل الثنائي لقناع الشبكة يدلّ على أنّه جزءٌ من العنوان الذي يمثل المضيف، ويمكن عدّه متغيرًا. تُعَد البِتّات التي تتخذ القيمة 1 ثابتة القيمة ضمن الشبكة أو الشبكة الفرعية. يمكننا الحصول على الجزء الدالّ على الشبكة بإجراء عمليّة ثنائية من نوع AND بين عنوان بروتوكول الإنترنت وقناع الشبكة. وبإجراء هذه العملية، نحافظ على القسم الذي يدل على الشبكة في العنوان ونهمل القسم الذي يدل على المضيف. ستكون نتيجة العملية وفقًا لمثالنا السابق على النحو التالي: 0000 0000 - 0000 0000 - 0000 1010 - 0000 1100 يمكننا تمثيل العنوان السابق على النحو التالي: 192.168.0.0. النطاق الذي يدل على المضيف هو الفرق بين القيم الأصلية وقسم المضيف. وفي هذه الحالة، قيمة نطاق المضيف، هي: 1111 0000 أو 15. الهدف من تفريع الشبكة هو استخدام قسمٍ من نطاق المضيف في العنوان، واستخدامه لتقسيم العنوان من جديد. إذ يزودنا قناع الشبكة للعنوان 255.255.255.0 مثلًا، بـ 254 مضيف على الشبكة (الرقمان 0 و255 محجوزان). إذا أردنا تقسيم الشبكة لشبكتين فرعيتين، يمكننا استخدام بِت واحد من قسم العنوان الذي يدل على المضيف قناعًا للشبكة. بعودتنا للمثال السابق، القسم الذي يعود للشبكة هو: 0000 0000 - 1000 1010- 0000 1100 والقسم الذي يعود للمضيف هو: 1111 0000 يمكننا استخدام أول بِت من القسم الذي يدلّ على المضيف وتغييره لإنشاء شبكة فرعية، وذلك بتعديل قناع الشبكة من هذا القناع: 0000 0000 - 1111 1111 - 1111 1111 - 1111 1111 لهذا القناع: 0000 1000 - 1111 1111 - 1111 1111 - 1111 1111 في ترميز IPv4 الاعتيادي، يُمثّل العنوان السابق على النحو التالي: 192.168.0.128. خصّصنا بهذه العملية أوّل بِت في الثمانيّة الأخيرة على أنها خانة ذات أهمية تدل على الشبكة، إذ تعطينا هذه العملية شبكتين فرعيتين؛ ويغطي قناع الشبكة الأول النطاق من 192.168.0.1 إلى 192.168.0.127؛ بينما يغطي قناع الشبكة الثاني النطاق 192.168.0.129 إلى 192.168.0.255. بطبيعة الحال، يجب ألاّ تُستخدم الشبكة الفرعية بنفسها عنوانًا. إذا استخدمنا بِتّات أكثر من قسم العنوان العائد للشبكة، عندها يمكننا الحصول على شبكاتٍ فرعية أكثر وأكثر. ألقِ نظرةً على بناء مخطط لعناوين IP عبر الشبكات الفرعية لمزيدٍ من المعلومات. ترميز التوجيه غير الصنفي بين النطاقات CIDR طُوِّر نظام التوجيه غير الصنفي بين النطاقات Classless Inter-Domain Routing -أو اختصارًا CIDR- بديلًا لطريقة تفريع الشبكة التقليدي، إذ يعتمد مبدأ هذا النظام على إضافة خانةٍ جديدة لعنوان بروتوكول الإنترنت بنفسه للدلالة على عدد البِتّات التي تمثل القسم الخاص بتوجيه الشبكة. على سبيل المثال، عنوان بروتوكول الإنترنت 192.168.0.15 مرتبطٌ بقناع الشبكة 255.255.255.0، ويمكننا التعبير عن ذلك بترميز CIDR عن طريق كتابة 192.168.0.15/24؛ إذ يمثل العدد 24 عدد البِتّات الموجودة في عنوان بروتوكول الإنترنت، والتي تدل على القسم الخاص بتوجيه الشبكة. يفتح هذا النظام المجال لفرصٍ مثيرةٍ للاهتمام، إذ يمكن استخدامه للدلالة على الشبكات الفوقية Supernets، ونقصد هنا نطاقات عناوين كبيرة من غير الممكن تمثيلها بطريقة قناع الشبكة الاعتياديّة. على سبيل المثال، في شبكةٍ من الصنف C، مثل الشبكة في أمثلتنا السابقة، لا يمكننا جمع العنوانين 192.168.0.0 و192.168.1.0، وذلك نظرًا لأن عنوان قناع الشبكة للصنف C هو 255.255.255.0، ولكن مع استخدام ترميز CIDR، يمكننا جمع العنوانين بالدلالة على النطاق الذي ينتميان إليه على النحو التالي 192.168.0.0/23؛ وهذا يدلّ على أن هناك 23 بِت مُستخدمٌ للدلالة على الشبكة التي نقصدها. يمكننا تمثيل الشبكة الأولى 192.168.0.0 بالترميز الثنائي على النحو التالي: 0000 0000 - 0000 0000 - 1000 1010 - 0000 1100 ونمثل الشبكة الثانية 192.168.1.0 على النحو التالي: 0000 0000 - 0001 0000 - 1000 1010 - 0000 1100 وبالتالي، يدلنا عنوان CIDR الذي كتبناه سابقًا، على أوّل 24 بِت مستخدَم لتمثيل القسم الذي يعود للشبكة، ويساوي هذا التمثيل قناع الشبكة 255.255.254.0، أو بالتمثيل الثنائي على النحو التالي: 0000 0000 - 1110 1111 - 1111 1111 - 1111 1111 كما نلاحظ، يمكن أن يكون البِت ذو الترتيب 24 بقيمة 1 أو 0، لأن الجزء الذي يدل على الشبكة يشمل فقط أوّل 23 بِت. يمنح نظام CIDR مزيدًا من التحكم للدلالة على نطاقاتٍ مستمرّة من عنوان بروتوكول الإنترنت، وهو أفضل من طريقة قناع الشبكة التي استعرضناها سابقًا. الخاتمة نأمل أنك استطعت فهم بعض تطبيقات الشبكات على عناوين بروتوكول الإنترنت. مع أنّ صعوبة التعامل مع هذا النوع من الشبكات كبيرة وغير بديهية، إلا أنها هامة لفهم طريقة تهيئة مكونات شبكتك وبرمجياتها. هناك الكثير من الأدوات والآلات الحاسبة على الإنترنت التي ستساعدك في فهم بعض من هذه المبادئ، والحصول على نطاقات عناوين صحيحة من خلال إدخال بعض المعلومات. توفر بعض الأدوات تحويلًا لعنوان بروتوكول الإنترنت من التمثيل العشري الاعتيادي إلى التمثيل الثنائي (الثمانيّات)، وتعرض لك تمثيلًا بصريًّا لأقنعة شبكة نظام CIDR. ترجمة -وبتصرف- للمقال Understanding IP Addresses, Subnets, and CIDR Notation for Networking لصاحبه Justing Ellingwood. اقرأ أيضًا الشبكات الفرعية والعناوين والأخطاء في بروتوكول IP بناء مخطط لعناوين IP عبر الشبكات الفرعية عند بناء الشبكات التوجيه بين الشبكات المحلية الافتراضية VLANs استكشاف وظائف الموجهات في الشبكات معمارية الشبكة الحاسوبية وشبكة الإنترنت (Network Architecture)

يميل الكثير من الناس لإهمال جانبٍ معيّن من عملية تطوير البرمجيات، ألا وهو كيفية ترخيص البرنامج، حيث تُملي رخصة البرنامج كيفية استعمال وتوزيع الشيفرة المصدرية بواسطة المُرخّص لهم -أي المستخدمين-، وهذا من شأنه أن يؤثر بشدة على حجم تبنّي الحلّ التقني. تُباع معظم البرامج باستخدام رخصة احتكارية تسمح للناشر أو المطوّر بالاحتفاظ بكامل الحقوق الفكرية للبرنامج. هناك بعض وجهات النظر التي تنظر لهذه الرخصة بأنها تضيف قدرة تحكم إضافية للناشر يمكن الاستغناء عنها، إذ يساهم منع الأشخاص المُرخّص لهم بنسخ وتغيير الشيفرة المصدرية للبرنامج بكبح ناشري البرامج الاحتكاريّة من الابتكار والتطوير المحتمل لتقنيات جديدة. ألهم هذا الموقف في إيجاد رخَص تعطي الحقّ للمستخدمين برؤية الشيفرة المصدرية وتعديلها ومشاركتها حسب رغبتهم، وعُرفت البرمجيات المرخّصة وفقًا لتلك الطريقة بأحد الإسمين: البرمجيات الحرّة؛ أو بالبرمجيات مفتوحة المصدر. يرمز كلا المصطلحين للمعنى ذاته عمومًا، وهو: برمجيات تحتوي على القليل من القيود المتعلّقة بكيفية استعمالها، ويرى مناصروها أن البرمجيات الحرّة والبرمجيات مفتوحة المصدر أكثر أمانًا وفاعليّةً، وأنها تعمل بموثوقية أكبر من البرمجيات الاحتكارية. لمَ نستخدم إذًا تسميتين مختلفتين للدلالة على الشيء ذاته؟ يتضمّن التفسير فهمًا لتاريخ كلا المصطلحين، وفهمًا أعمق للتفاصيل الدقيقة التي تفصل المصطلحين المختلفين. لمحة تاريخية لا تُعد إمكانية السماح للفرد برؤية وتعديل ومشاركة الشيفرة المصدرية لبرمجيّة معيّنة دون أي ملاحقة قانونيّة فكرةً جديدة؛ فقد كانت توزّع البرمجيات قبل سبعينيات القرن الماضي مصحوبةً بشيفرتها المصدرية، والسبب في ذلك هو أنّ هذه البرمجيات كانت مخصّصةً لمتطلبات العتاد الصلب، وعلى المستخدم أن يعدلها قبل أن تعمل بنجاح على حاسوبه، أو لإضافة وظائف جديدة. كان التعامل مع الحواسيب في هذه الفترة لمعظم الأشخاص مقتصرًا على أهدافٍ أكاديميّة أو بحثيّة. ومعنى هذا، أن موارد الحوسبة كانت تُشارَك أغلب الأحيان، وكان تغيير البرمجيات لخلق طرق أكثر فاعليّةً ووثوقيّةً لسير العمل مرحّبًا به للغاية. طوّر مشروع المارد Genie في جامعة كاليفورنيا بيركلي مثلًا، نظام تشغيل بيركلي لمشاركة الوقت؛ وهو نظام تشغيل بُنيَ من الصفر عن طريق التعديل على الشيفرة المصدرية لحاسوب SDS 930. مع ارتفاع تكلفة تطوير البرمجيّات وزيادة تعقيدها، توصلت الشركات لطرق أوقفت المشاركة لشيفرتها المصدرية دون أيّ رقيب، وذلك لحماية مصدر ربحهم ومنع المنافسين من الاطّلاع على حلولهم التقنية. عندها، بدأت عملية وضع القيود القانونيّة، متضمّنةً حقوق التأليف والنشر وعقود الشراء، وباعت هذه الشركات منتجاتها تحت مظلّة الرُخَص الاحتكاريّة. ومع نهايات سبعينيّات القرن الماضي، توقفت معظم الشركات المنتجة للبرمجيات عن تضمين الشيفرة المصدرية لمنتجاتها، وأدّت هذه الحركة لاستياء العديد من مستخدمي الحواسيب القدامى، وكانت نتيجتها إيجاد حركة البرمجيات الحرّة. بدايات البرمجيات الحرة كانت حركة البرمجيات الحرة Free Software Movement بالمعظم وليدة أفكار شخصٍ واحد هو ريتشارد ستالمان؛ حيث بدأ ستالمان دراساته في علوم الحاسوب بدايات السبعينيّات، وذلك قبل ولادة البرامج الاحتكاريّة بفترة قصيرة، وعملَ باحثًا في مختبرات جامعة ماساتشوستس للذكاء الاصطناعي في بدايات الثمانينيّات. كان ستالمان يُكِنّ كثيرًا من الإحباط اتجاه انتشار البرمجيات الاحتكارية بصفته عضوًا في مجتمع القرصنة الأكاديمي لما يقارب القرن، ورأى أن انتشارها ينتهك حق الناس في ابتكار وتحسين برمجياتٍ موجودة. أطلق ستالمان في عام 1983 مشروعًا سمّاه باسم مشروع جنو GNU في سبيل إنشاء نظام تشغيل متكامل يسمح لمستخدميه برؤية وتعديل ومشاركة الشيفرة المصدريّة. حدّد ستالمان أهدافه من هذا المشروع في بيان جنو، والذي ذكر فيه بأنّ الرخص الاحتكارية تعيق تطوير البرمجيّات التي يقودها المجتمع، وهذا يؤدي بدوره إلى ركود الابتكار ويعيق تقدُّم التقنية. يضيف هذا الأمر وفقًا لستالمان، عبئًا غير عادل على المستخدمين والمطوّرين الذين أمكنهم عوضًا عن ذلك تعديل الشيفرة البرمجيّة لتلائم حاجاتهم، أو تغييرها لتُستخدَم في غرضٍ جديد. لقد نُظِرَ إلى مشروع جنو على أنه استجابةً للبرمجيات الاحتكارية وتذكيرًا للناس بالعصر الذي سبقها، وذلك عندما كانت الشيفرة المصدريّة للبرمجيات تُشارَك بحريّة بهدف تطوير البرمجيات التعاوني. بنى ستالمان في عام 1985 مؤسسة البرمجيات الحرّة، أو كما تُعرف باسم Free Softwar ،Foundation -أو اختصارًا FSS-، معتمدًا على مشروع جنو حجرًا للأساس، وهي مؤسسةٌ غير ربحية هدفها نشر ثقافة البرمجيات الحرة للعامّة. كما طور ستالمان فيما بعد رخصة جنو العموميّة GPL؛ وهي رخصة برمجيات تمنح الحق للمستخدم بتشغيل الشيفرة المصدرية ورؤيتها ومشاركتها بحرية مطلقة. اعتمادًا على تعريف مؤسسة البرمجيات الحرة، يجب أن تتضمَن أي برمجيّة الحريات الأربع التالية لمستخدميها لتُصنّف برمجيّةً حرة: حرية تشغيل البرنامج متى أراد المستخدم، ولأي غرض. حرية معرفة طريقة عمل البرنامج، وتغييرها بناءً على رغبة المستخدم، فالوصول للشيفرة المصدرية هو شرطٌ مسبق لهذه الحرية. حرية توزيع نسخةٍ من الشيفرة المصدريّة لمعارفك. حرية توزيع نسخ من برنامجك المعدّل للآخرين؛ إذ يمكنك بفعل هذا إتاحة الفرصة لكامل المجتمع بالاستفادة من تعديلاتك. ويُعَد الوصول للشيفرة المصدرية شرطًا مسبقًا لهذه الحرية أيضًا. تعد مؤسسة البرمجيات الحرّة أي برمجيةٍ تخفق بتحقيق هذه الحريات الأربع برمجيّةً غير حرّة، وبذلك غير أخلاقيّة. ولادة البرمجيات مفتوحة المصدر اختار ستالمان مصطلح "البرمجيات الحرّة" للدلالة على المبدأ الذي ينصّ على حرية تعديل الشيفرة المصدرية، ومشاركتها لأي برنامجٍ من مستخدميه وفق رغبتهم. خلقت هذه التسمية كثيرًا من الخلط لدى الناس على مرور السنوات، لاعتقادهم بأنّ البرمجيات الحرة هي البرامج التي يمكنهم الحصول عليها مجانًا دون دفع أي مقابل مادّي؛ وذلك نظرًا لازدواجية معنى كلمة Free، فهي تعني حرّ ومجاني في الوقت ذاته حسب السياق. توضّح مؤسسة البرمجيات الحرة هذا الخلط بالمعاني بواسطة مقولتها "فكّر بالكلمة بسياق حرية الرأي، وليس بسياق مشروبٍ مجاني". تنامى القلق بين مناصري مشروع جنو ونظام لينكس في نهايات تسعينيات القرن الماضي، فقد كان من الممكن أن يتسبب هذا الخلط في المعنى بسوء فهم الناس لمصطلح البرمجيات الحرة، وإيجابياتها موازنةً مع البرمجيات الاحتكارية. كما كانت مؤسسة البرمجيات الحرّة شديدة اللهجة ولاذعة الانتقاد ضدّ جميع أشكال البرمجيات الاحتكارية، وهذا سبّب قلقًا من طرف مناصري البرمجيات الحرّة بكونه سلوكًا عدائيًّا تجاه المصالح التجارية، الذي سيتسبّب في النهاية بعرقلة انتشار حركة البرمجيات الحرة. الكاتدرائية والبازار كتب إريك ريموند في عام 1997 -وهو مطوّرٌ ومناصرٌ للبرمجيات الحرة-، مقالًا بعنوان الكاتدرائية والبازار The Cathedral and the Bazaar؛ وهي مقالةٌ شهيرة توازن بين نمطين من أنماط تطوير البرمجيات المُستخدمة في تطوير مختلف مشاريع البرمجيات الحرّة. ترمز الكاتدرائية هنا للنمط الهرمي في تطوير البرمجيات، إذ تطور مجموعةٌ معينةٌ من المطورين البرمجيات، مثل عملية تطوير محرّر النصوص إيماكس Emacs على نظام جنو؛ بينما يرمز البازار لنمط التطوير المتمثّل بنشر الشيفرة المصدرية للعموم وتطويرها علنيًا، مثل عملية تطوير نواة لينكس. تتمحور فكرة المقال حول كفاءة نمط البازار في إيجاد الأخطاء البرمجية وحلّها موازنةً مع النمط الآخر، وذلك بحكم أن هناك عددٌ أكبر من الأشخاص القادرين على مراجعة وتجربة الشيفرة المصدرية للبرنامج. لذا، يزعم ريموند أن تبني هذا النمط المعتمد على الجهد المجتمعي ينتج بالحصول على برمجياتٍ أكثر أمانًا وموثوقيّة. عُقب الأفكار التي طرحها ريموند في مقالته الكاتدرائية والبازار، أطلقت شركة نتسكيب Netscape الشيفرة المصدريّة لمتصفح الويب الخاص بها المسمى بالمتواصل Communicator مجانًا ومفتوح المصدر للعموم في عام 1998؛ وسيشكّل هذا المتصفح أساس متصفح موزيلا فيرفكس 1.0 لاحقًا. فكّرت مجموعةٌ من مناصري البرمجيات الحرّة، متضمنةً ريموند ولينوس تورفالدس وفيل زيمرمان وآخرون، بإعادة تسويق حركة البرمجيات الحرة، وصرف تركيزها بعيدًا عن الدوافع الفلسفيّة والأخلاقية، مستلهمين ذلك من تجرِبة Netscape والإمكانية التجارية التي أتيحت لها بعد هذه العملية. اختارت هذه المجموعة تسمية "مفتوح المصدر" للدلالة على البرمجيات المشاركة مجانًا، آملين أن تظهر هذه التسمية الفائدة المضافة من نمط تطوير البرمجيات الاجتماعي والتعاوني. بعد ذلك بوقت وجيز، أوجد كلٌّ من ريموند وبروس بيرنز مبادرة المصدر المفتوح Open Source Initiative -أو اختصارًا OSI-، لتشجيع استخدام التسمية الجديدة ونشر مبادئ البرمجيات مفتوحة المصدر، إذ طوّرت هذه المبادرة تعريف المصدر المفتوح؛ وهي لائحةٌ من عشرة مبادئ تصف معايير رخصة أي برمجية لتعدّ مفتوحة المصدر، وهي: حرية إعادة التوزيع: يجب ألّا تمنع الرخصة أي طرفٍ من بيع أو منح البرمجيّة، مثل إضافةٍ لبرمجية أكبر منها تحتوي برمجياتٍ من مصادرٍ متعددة. الشيفرة المصدرية: يجب أن يحتوي البرنامج على الشيفرة المصدرية، وأن يسمح بتوزيع البرنامج مثل شيفرة مصدريّة أو إصدار مُجمّع. الأعمال المشتقة: يجب أن تسمح الرخصة بالتعديل وإنشاء برمجيات مشتقة، وأن تسمح بتوزيعها تحت شروط رخصة البرنامج الأصلي ذاتها. الحفاظ على الشيفرة المصدرية للمؤلّف: يجوز للرخصة أن تمنع توزيع البرامج المعدّلة المبنية على الشيفرة المصدرية الأصل، وذلك في حالة سماح الرخصة بتوزيع ملفات الترقيع patch files مع الشيفرة المصدرية الأصل بهدف تعديل البرنامج بعد تجميعه Compiling. يُمنَع التمييز ضدّ شخص ما أو مجموعة من الأشخاص: على الرخصة ألّا تميّز بين الأشخاص أو مجموعة من الأشخاص. يُمنَع التمييز ضد مجال أو مهنة معيّنة: يجب ألا تمنع الرخصة أي أحدٍ من استخدام البرنامج بحرية بهدف توظيفه في أي مجال أو غرض. توزيع الرخصة: يجب أن تُطبّق الحقوق الموجودة على رخصة البرنامج الأصلية على جميع البرامج المشتقة دون الحاجة لتضمين رخصة إضافية من الموزّعين. لا ينبغي للرخصة أن تكون مخصصة لمنتج معين: لا يشترط على الحقوق المُضمّنة في برنامجٍ ما أن تكون فعالةً بحالة كان جزءًا من برنامج معين فقط. لا ينبغي على الرخصة أن تضع قيودًا على برمجياتٍ أخرى: يجب ألّا تضع الرخصة قيودًا على برنامج معيّن مُوزعٍ مع البرنامج المرخّص. على الرخصة أن تكون محايدة: لا يجوز أن تستند الرخصة على أي تقنيةٍ فردية أو نمط واجهة مستخدم. الاختلافات بين البرمجيات الحرة ومفتوحة المصدر يُعد الفرق بين مصطلح "البرمجيات الحرة" و"البرمجيات مفتوحة المصدر" ضئيلًا في العموم، ويأتي الاختلاف بالتسمية من فروقات فلسفيّة. تقول مبادرة المصدر المفتوح، أن كلا المصطلحين يعنيان الأمر ذاته، ويمكن استخدامهما بالتبادل في أي سياق كان. يفضّل مصطلح "مفتوح المصدر" ببساطة، لأنّه يُعتقد أنه المصطلح الأفضل الذي يظهر طبيعة البرمجيات ونوايا مؤلّفيها في كيفية استخدامها. أما بالنسبة لمناصري فلسفة "البرمجيات الحرة"، فلا يصف المصطلح "مفتوح المصدر" بالضبط أهميّة الحركة، والمشاكل الاجتماعية التي قد تحصل بسبب البرامج الاحتكارية. ترى مؤسسة البرمجيات الحرة أنّ مبادرة المصدر المفتوح تولي كثيرًا من الاهتمام لتسويق ونشر الفوائد العملية من البرامج غير الاحتكارية، متضمّنًة ربحية العملية وكفاءة نمط التطوير التعاوني، وذلك على حساب الاهتمام للمشاكل الأخلاقية الناتجة عن تقييد حقوق المستخدمين في تغيير وتحسين الشيفرة المصدرية طبقًا لرغبتهم. يعتمد تصنيف البرمجية بكونها حرةً أو مفتوحة المصدر، على شروط رخصتها وتحقيقها لشروط كلٍّ من مبادرة المصدر المفتوح، ومؤسسة البرمجيات الحرة، أو كلاهما. هناك نقاط كثيرة مشتركة بين الاثنين، ولكن هناك بعض الاستثناءات في بعض الأحيان؛ إذ تتوافق مثلًا رخصة ناسا مفتوحة المصدر مع معايير مبادرة المصدر المفتوح؛ بينما تعدّها مؤسسة البرمجيات الحرّة رخصة تقييديّة. لكن عمومًا، هناك فرصة كبيرة بكون رخصة ما مفتوحة المصدر إذا عُدّت حرّة. أسماء بديلة ظهرت على مرّ السنوات كثيرٌ من التسميات الأخرى في سعيٍ منها لحسم الخلاف؛ منها "برمجية حرة ومفتوحة المصدر Free and Open-source Software" -أو اختصارًا FOSS-، وهي واحدةٌ من أكثر التسميات استخدامًا، وتُعد تسميةً وسيطةً بين الطرفين. اكتسبت التسمية "برمجية حرة Libre Software" (إذ تأتي كلمة Libre من كلمة حرية Liberty)، أنصارًا هي الأخرى وأصبحت الكلمة FLOSS رائجةً أيضًا. تجدر الإشارة هنا إلى أنّ البرمجيات الحرة ومفتوحة المصدر مختلفةٌ كليًّا عن البرمجيات التي تنتمي للملكية العامة Public Domain؛ إذ تستمد البرمجيات الحرة ومفتوحة المصدر حرياتها من ترخيصها؛ بينما تستمد برمجيات الملكية العامة بعضًا من هذه الحريات من خلال الوقوع خارج نظام الترخيص. الفارق الواضح هنا هو أنه من الواجب توزيع كلٍّ من البرمجيات الحرة ومفتوحة المصدر تحت رخصة FOSS؛ بينما لا تخضع برمجيات الملكية العامة للشرط ذاته. المشكلة المتعلقة ببرمجيات الملكية العامة، هي عدم اعتراف جميع الدول في العالم بمحتواها غير الخاضع لحقوق الطبع والنشر. يجعل هذا الأمر الاعتراف بوجود برمجيّة تحت الملكية العامة عالميًّا أمرًا مستحيلًا. ولهذا السبب، لا تشجّع أيّ من مبادرة المصدر المفتوح OSI ومؤسسة البرمجيات الحرة FSF، بإطلاق المطورين برمجياتهم تحت الملكية العامة. الخاتمة يُستخدم كلا المصطلحين "برمجيات حرة" و"برمجيات مفتوحة المصدر" في معظم السياقات للدلالة على الشيء ذاته. وينبع تفضيل استخدام مصطلحٍ دونًا عن الآخر من اختلافٍ فلسفي بسيط؛ ولكن قد يصبح الفرق مهمًا بالنسبة للمطورين الذين يطوّرون برامجًا ويطلقونها للعالم، أو للنشطاء الذين يسعون لتغيير طريقة تفاعل الناس مع التقنية. بالتالي من المهم جدًا النظر للسلبيات والإيجابيات لمختلف الرُخَص والمتضمّنة الرُخَص الاحتكاريّة قبل نشر أيّ برنامج، واختيار الرُخصة المُثلى التي تناسب احتياجات الناشر. إن كنتَ مهتمًّا بقراءة مزيدٍ من التفاصيل عن مختلف الرخص المناسبة لمشروعك القادم، تقدّم مؤسسة البرمجيات الحرة لائحةً من الرُخَص تبيّن تفاصيل كلّ من الرخص الحرّة وغير الحرّة. كما قد تكون صفحة الرخص والمعايير على موقع مبادرة المصدر المفتوح مفيدةً لك. ترجمة -وبتصرف- للمقال The Difference Between Free and Open-Source Software لصاحبه Mark Drake. اقرأ أيضًا ما المقصود بمصطلح مفتوح المصدر (open source)؟ تعلم البرمجة تعرف على أنواع التراخيص الحرة التي تسمح لك ببيع المواد بشكل تجاري