ماذا تفعل هذه البرامج؟
وتبين أن التنفيذ الثاني يعمل أسرع مرتين من الأول. هل كنت تتوقع مثل هذه النتيجة؟ كيف تفسرون ذلك؟

التمرين 3.15

هل يمكنك تحسين أو إضافة أي شيء إلى مجموعة عمليات فئة السلسلة الواردة في القسم الأخير؟ اشرح مقترحاتك

3.5. محدد ثابت

لنأخذ مثال الكود التالي:

من أجل (مؤشر int = 0؛ مؤشر< 512; ++index) ... ;

هناك مشكلتان في استخدام 512 حرفيًا. الأول هو سهولة إدراك نص البرنامج. لماذا يجب أن يكون الحد الأعلى لمتغير الحلقة 512 بالضبط؟ ما هو مخفي وراء هذه القيمة؟ يبدو أنها عشوائية...
المشكلة الثانية تتعلق بسهولة التعديل وصيانة الكود. لنفترض أن البرنامج يحتوي على 10000 سطر وأن العدد الحرفي 512 يحدث في 4% منها. لنفترض أنه في 80٪ من الحالات يجب تغيير الرقم 512 إلى 1024. هل يمكنك تخيل مدى تعقيد هذا العمل وعدد الأخطاء التي يمكن ارتكابها عن طريق تصحيح القيمة الخاطئة؟
نحن نحل هاتين المشكلتين في نفس الوقت: نحتاج إلى إنشاء كائن بالقيمة 512. ومن خلال إعطائه اسمًا ذا معنى، مثل bufSize، نجعل البرنامج أكثر قابلية للفهم: يصبح من الواضح ما هي مقارنة متغير الحلقة بالضبط ل.

فِهرِس< bufSize

في هذه الحالة، تغيير حجم bufSize لا يتطلب المرور عبر 400 سطر من التعليمات البرمجية لتعديل 320 منها. ما مدى تقليل احتمال حدوث الأخطاء عن طريق إضافة كائن واحد فقط! الآن القيمة هي 512 موضعية.

حجم كثافة العمليات = 512; // حجم المخزن المؤقت للإدخال // ... for (int Index = 0; Index< bufSize; ++index)
// ...

تبقى مشكلة واحدة صغيرة: المتغير bufSize هنا هو قيمة l يمكن تغييرها عن طريق الخطأ في البرنامج، مما يؤدي إلى خطأ يصعب اكتشافه. إليك خطأ شائع: استخدام عامل التعيين (=) بدلاً من عامل المقارنة (==):

// تغيير عشوائي في قيمة bufSize إذا (bufSize = 1) // ...

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

Const int bufSize = 512; // حجم المخزن المؤقت للإدخال

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

// خطأ: حاول تعيين قيمة لثابت if (bufSize = 0) ...

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

كونست بي مزدوج؛ // خطأ: ثابت غير مهيأ

الحد الأدنى للأجور المزدوج = 9.60؛ // يمين؟ خطأ؟
مزدوج *بتر =

هل يجب على المترجم السماح بمثل هذه المهمة؟ نظرًا لأن الحد الأدنى للأجور ثابت، فلا يمكن تعيين قيمة له. ومن ناحية أخرى، لا شيء يمنعنا من أن نكتب:

*ptr += 1.40; // تغيير كائن minWage!

كقاعدة عامة، المترجم غير قادر على الحماية من استخدام المؤشرات ولن يتمكن من الإشارة إلى خطأ إذا تم استخدامها بهذه الطريقة. وهذا يتطلب تحليلا عميقا جدا لمنطق البرنامج. لذلك، يحظر المترجم ببساطة تعيين عناوين ثابتة للمؤشرات العادية.
فهل نحن محرومون من القدرة على استخدام المؤشرات للثوابت؟ لا. لهذا الغرض، هناك مؤشرات معلنة باستخدام محدد const:

كونست مزدوج *cptr;

حيث cptr هو مؤشر لكائن من النوع const double. الدقة هي أن المؤشر نفسه ليس ثابتًا، مما يعني أنه يمكننا تغيير قيمته. على سبيل المثال:

Const double *pc = 0; الحد الأدنى للأجور المزدوجة الثابت = 9.60؛ // صحيح: لا يمكننا تغيير minWage باستخدام جهاز الكمبيوتر
الكمبيوتر = مزدوج dval = 3.14؛ // صحيح: لا يمكننا تغيير minWage باستخدام جهاز الكمبيوتر
// على الرغم من أن dval ليس ثابتًا
الكمبيوتر = // صحيح dval = 3.14159؛ //يمين
* الكمبيوتر = 3.14159؛ // خطأ

يتم تعيين عنوان الكائن الثابت فقط لمؤشر ثابت. في الوقت نفسه، يمكن أيضًا تعيين عنوان لمتغير عادي لمثل هذا المؤشر:

جهاز الكمبيوتر =

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

// في البرامج الحقيقية، غالبًا ما تُستخدم مؤشرات الثوابت // كمعلمات رسمية للوظائف int strcmp(const char *str1, const char *str2);

(سنتحدث أكثر عن المؤشرات الثابتة في الفصل السابع، عندما نتحدث عن الوظائف.)
هناك أيضًا مؤشرات ثابتة. (لاحظ الفرق بين مؤشر const ومؤشر ثابت!). يمكن لمؤشر const أن يعالج إما ثابتًا أو متغيرًا. على سبيل المثال:

int errNumb = 0; int *const currErr =

هنا curErr هو مؤشر ثابت لكائن غير ثابت. هذا يعني أنه لا يمكننا تعيين عنوان كائن آخر له، على الرغم من أنه يمكن تعديل الكائن نفسه. إليك كيفية استخدام مؤشر curErr:

قم بعمل ما()؛ إذا (*curErr) (
معالج الأخطاء()؛
*curErr = 0; // صحيح: إعادة تعيين قيمة errNumb
}

ستؤدي محاولة تعيين قيمة لمؤشر const إلى حدوث خطأ في الترجمة:

CurErr = // خطأ

المؤشر الثابت إلى الثابت هو اتحاد بين الحالتين اللتين تم النظر فيهما.

كونست بي مزدوج = 3.14159؛ const مزدوج *const pi_ptr = π

لا يمكن تغيير قيمة الكائن المشار إليه بواسطة pi_ptr ولا قيمة المؤشر نفسه في البرنامج.

التمرين 3.16

اشرح معنى التعاريف الخمسة التالية. هل أي منهم على خطأ؟

(أ) كثافة العمليات ط؛ (د) int *const cpi؛ (ب) ثابت int جيم؛ (هـ) const int *const cpic; (ج) ثابت int *pic;

التمرين 3.17

أي من التعريفات التالية صحيحة؟ لماذا؟

(أ) إنت ط = -1؛ (ب) const int ic = i; (ج) const int *pic = (d) int *const cpi = (e) const int *const cpic =

التمرين 3.18

باستخدام التعريفات من التمرين السابق، حدد عوامل التعيين الصحيحة. يشرح.

(أ) أنا = جيم؛ (د) الموافقة المسبقة عن علم = الصورة؛ (ب) الموافقة المسبقة عن علم = (i) Cpic = (ج) CPI = الموافقة المسبقة عن علم؛ (و) ic = *cpic;

3.6. نوع مرجع

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

إنت إيفال = 1024؛ // صحيح: refVal - إشارة إلى ival int &refVal = ival; // خطأ: يجب تهيئة المرجع إلى int

إنت إيفال = 1024؛ // خطأ: refVal من النوع int، وليس int* int &refVal = int *pi = // صحيح: ptrVal هو مرجع إلى مؤشر int *&ptrVal2 = pi;

بمجرد تعريف المرجع، لا يمكنك تغييره للعمل مع كائن آخر (ولهذا السبب يجب تهيئة المرجع عند النقطة التي تم تعريفه فيها). في المثال التالي، لا يغير عامل التعيين قيمة refVal؛ حيث يتم تعيين القيمة الجديدة للمتغير ival - الذي يعالجه refVal.

إنت مين_فال = 0؛ // ival يتلقى قيمة min_val، // بدلاً من refVal يغير القيمة إلى min_val refVal = min_val;

RefVal += 2; يضيف 2 إلى ival، المتغير المشار إليه بواسطة refVal. وبالمثل int ii = refVal; يعين ii القيمة الحالية لـ ival، int *pi = تهيئة pi بعنوان ival.

// تم تعريف كائنين من النوع int int ival = 1024, ival2 = 2048; // مرجع واحد وكائن واحد محددان int &rval = ival, rval2 = ival2; // تم تعريف كائن واحد ومؤشر واحد ومرجع واحد
int inal3 = 1024, *pi = ival3, &ri = ival3; // تم تعريف رابطين int &rval3 = ival3, &rval4 = ival2;

يمكن تهيئة المرجع const بواسطة كائن من نوع آخر (بافتراض، بالطبع، أنه من الممكن تحويل نوع إلى آخر)، بالإضافة إلى قيمة بدون عنوان مثل الثابت الحرفي. على سبيل المثال:

مزدوج دفال = 3.14159؛ // صحيح فقط للمراجع الثابتة
كونست إنت &ir = 1024؛
const int &ir2 = dval;
const double &dr = dval + 1.0;

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

مزدوج دفال = 1024؛ const int &ri = dval;

ثم يقوم المترجم بتحويله إلى شيء مثل هذا:

درجة الحرارة المؤقتة = دفال؛ const int &ri = temp;

إذا تمكنا من تعيين قيمة جديدة لمرجع ri، فلن نغير في الواقع dval، بل درجة الحرارة. ستبقى قيمة dval كما هي، وهو أمر غير واضح تمامًا للمبرمج. لذلك، يحظر المترجم مثل هذه الإجراءات، والطريقة الوحيدة لتهيئة مرجع بكائن من نوع آخر هي الإعلان عنه كـ const.
إليك مثال آخر على رابط يصعب فهمه في المرة الأولى. نريد تحديد مرجع لعنوان كائن ثابت، لكن خيارنا الأول يسبب خطأ في الترجمة:

كونست إنت إيفال = 1024؛ // خطأ: هناك حاجة إلى مرجع ثابت
int *&pi_ref =

فشلت أيضًا محاولة تصحيح الأمر عن طريق إضافة محدد const:

كونست إنت إيفال = 1024؛ // لا يزال هناك خطأ const int *&pi_ref =

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

كونست إنت إيفال = 1024؛ // يمين
int *const &piref =

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

إنت * بي = 0؛

نقوم بتهيئة المؤشر pi إلى الصفر، مما يعني أن pi لا يشير إلى أي كائن. في نفس الوقت التسجيل

كونست إنت &ري = 0؛
يعني شيئا مثل هذا:
درجة الحرارة المؤقتة = 0؛
const int &ri = temp;

أما بالنسبة لعملية الإسناد ففي المثال التالي:

إنت ival = 1024، ival2 = 2048؛ int *pi = &ival, *pi2 = pi = pi2;

يبقى المتغير ival الذي يشير إليه pi بدون تغيير، ويستقبل pi قيمة عنوان المتغير ival2. يشير كل من pi وpi2 الآن إلى نفس الكائن، ival2.
إذا عملنا مع الروابط:

Int &ri = ival, &ri2 = ival2; ري = ري2؛

// مثال لاستخدام الروابط // يتم إرجاع القيمة في معلمة القيمة التالية
bool get_next_value(int &next_value); // مشغل Matrix ذو التحميل الزائد عامل التشغيل+(const Matrix&, const Matrix&);

إنت إيفال؛ بينما (get_next_value(ival)) ...

Int &next_value = ival;

(تتم مناقشة استخدام المراجع كمعلمات رسمية للوظائف بمزيد من التفصيل في الفصل السابع.)

التمرين 3.19

هل هناك أي أخطاء في هذه التعريفات؟ يشرح. كيف يمكنك اصلاحها؟

(أ) إنت إيفال = 1.01؛ (ب) كثافة العمليات &rval1 = 1.01؛ (ج) int &rval2 = ival; (د) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (ز) int &rval5 = pi*; (ح) int &*prval1 = pi; (ط) const int &ival2 = 1; (ي) const int &*prval2 =

التمرين 3.20

هل أي من عوامل التعيين التالية خاطئة (باستخدام التعريفات من التمرين السابق)؟

(أ) rval1 = 3.14159؛ (ب) prval1 = prval2؛ (ج) prval2 = rval1؛ (د) * prval2 = ival2؛

التمرين 3.21

ابحث عن الأخطاء في التعليمات المقدمة:

(أ) إنت إيفال = 0؛ const int *pi = 0; كونست إنت &ري = 0؛ (ب) بي =
ري =
بي =

3.7. اكتب منطقي

يمكن لكائن من النوع bool أن يأخذ إحدى القيمتين: صحيح وخطأ. على سبيل المثال:

// تهيئة السلسلة string search_word = get_word(); // تهيئة المتغير الموجود
تم العثور على منطقية = خطأ؛ سلسلة next_word؛ بينما (سين >> next_word)
إذا (next_word == search_word)
وجدت = صحيح؛
// ... // الاختصار: إذا (وجد == صحيح)
ان وجد)
cout<< "ok, мы нашли слово\n";
آخر قطع<< "нет, наше слово не встретилось.\n";

على الرغم من أن bool هو أحد أنواع الأعداد الصحيحة، إلا أنه لا يمكن الإعلان عنه على أنه موقع أو غير موقع أو قصير أو طويل، لذا فإن التعريف أعلاه خاطئ:

// تم العثور على خطأ منطقي قصير = خطأ؛

يتم تحويل الكائنات من النوع bool ضمنيًا إلى النوع int. صحيح يصبح 1 وخطأ يصبح 0. على سبيل المثال:

تم العثور على المنطق = خطأ؛ كثافة العمليات_عدد = 0; بينما (/* غمغم */)
{
وجدت = look_for(/* شيء */); // يتم تحويل القيمة الموجودة إلى 0 أو 1
عدد الأحداث += موجود؛ )

وبنفس الطريقة يمكن تحويل قيم الأنواع الصحيحة والمؤشرات إلى قيم من النوع bool. في هذه الحالة، يتم تفسير 0 على أنه خطأ، وكل شيء آخر على أنه صحيح:

// يُرجع عدد التكرارات الخارجية int find(const string&); تم العثور على منطقية = خطأ؛ if (found = find("rosebud")) // صحيح: Found == true // يُرجع مؤشرًا إلى العنصر
int الخارجي * find(قيمة int); إذا (وجدت = وجدت (1024)) // صحيح: وجدت == صحيح

3.8. التحويلات

غالبًا ما يتعين عليك تحديد متغير يأخذ قيمًا من مجموعة معينة. لنفترض أن الملف مفتوح في أي من الأوضاع الثلاثة: للقراءة والكتابة والإلحاق.
وبالطبع يمكن تعريف ثلاثة ثوابت للدلالة على هذه الأوضاع:

إدخال ثابت = 1؛ إخراج ثابت = 2 ؛ إلحاق const int = 3؛

واستخدم هذه الثوابت:

Bool open_file(string file_name, int open_mode); // ...
open_file("Phoenix_and_the_Crane"، إلحاق)؛

هذا الحل ممكن، ولكنه غير مقبول تمامًا، حيث لا يمكننا ضمان أن الوسيط الذي تم تمريره إلى الدالة open_file() هو 1 أو 2 أو 3 فقط.
استخدام نوع التعداد يحل هذه المشكلة. عندما نكتب:

التعداد open_modes( الإدخال = 1, الإخراج, إلحاق );

نحدد نوعًا جديدًا open_modes. تقتصر القيم الصالحة لكائن من هذا النوع على مجموعة 1 و2 و3، مع وجود اسم تذكيري لكل من القيم المحددة. يمكننا استخدام اسم هذا النوع الجديد لتحديد كائن من هذا النوع ونوع المعلمات الرسمية للوظيفة:

Void open_file(string file_name, open_modes om);

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

Open_file("فينيكس والرافعة"، إلحاق)؛

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

// خطأ: 1 ليس عنصرًا في التعداد open_modes open_file("Jonah"، 1);

هناك طريقة لتعريف متغير من النوع open_modes، وتعيين قيمة أحد عناصر التعداد له وتمريره كمعلمة إلى الدالة:

Open_modes om = input; // ... أوم = إلحاق؛ open_file("TailTell", om);

ومع ذلك، ليس من الممكن الحصول على أسماء هذه العناصر. إذا كتبنا بيان الإخراج:

كوت<< input << " " << om << endl;

ثم ما زلنا نحصل على:

تم حل هذه المشكلة عن طريق تحديد مصفوفة سلسلة يحتوي فيها العنصر الذي يحتوي على فهرس يساوي قيمة عنصر التعداد على اسمه. بالنظر إلى مثل هذه المصفوفة، يمكننا أن نكتب:

كوت<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

بالإضافة إلى ذلك، لا يمكنك التكرار على كافة قيم التعداد:

// غير مدعوم لـ (open_modes iter = input; iter != append; ++inter) // ...

لتعريف التعداد، استخدم الكلمة الأساسية التعداد، ويتم تحديد أسماء العناصر بين قوسين متعرجين، مفصولة بفواصل. بشكل افتراضي، الأول هو 0، التالي هو 1، وهكذا. يمكنك تغيير هذه القاعدة باستخدام عامل التعيين. في هذه الحالة، كل عنصر لاحق بدون قيمة محددة بشكل صريح سيكون 1 أكثر من العنصر الذي يسبقه في القائمة. في مثالنا، حددنا بشكل صريح القيمة 1 للإدخال، وسيكون الإخراج والإلحاق مساويين لـ 2 و3. وإليك مثال آخر:

// الشكل == 0، المجال == 1، الأسطوانة == 2، المضلع == 3 التعداد Forms( share, spere, Cylinder, Polygon );

لا يجب أن تكون القيم الصحيحة المقابلة لعناصر مختلفة من نفس التعداد مختلفة. على سبيل المثال:

// point2d == 2, point2w == 3, point3d == 3, point3w == 4 نقاط التعداد ( point2d=2, point2w, point3d=3, point3w=4 );

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

Void mumble() ( Points pt3d = point3d; // صحيح: pt2d == 3 // خطأ: تمت تهيئة pt3w بالنوع int Points pt3w = 3; // خطأ: لم يتم تضمين المضلع في تعداد النقاط pt3w = polygon; / / صحيح: كلا الكائنين من النوع Points pt3w = pt3d )

ومع ذلك، في التعبيرات الحسابية، يمكن تحويل التعداد تلقائيًا إلى النوع int. على سبيل المثال:

Const int array_size = 1024؛ // صحيح: يتم تحويل pt2w إلى int
int Chunk_size = array_size * pt2w;

3.9. اكتب "مصفوفة"

لقد تطرقنا بالفعل إلى المصفوفات في القسم 2.1. المصفوفة عبارة عن مجموعة من العناصر من نفس النوع، يتم الوصول إليها عن طريق فهرس - الرقم التسلسلي للعنصر في المصفوفة. على سبيل المثال:

إنت إيفال؛

يعرف ival كمتغير int، والتعليمات

إنت إيا[10]؛

يحدد مصفوفة من عشرة كائنات من النوع int. لكل من هذه الكائنات، أو عناصر المصفوفة، يمكن الوصول إليها باستخدام عملية الفهرس:

Ival = ia[2];

يعين المتغير ival قيمة عنصر الصفيف ia مع الفهرس 2. وبالمثل

Ia[ 7 ] = ival;

يعين العنصر في الفهرس 7 القيمة ival.

يتكون تعريف المصفوفة من محدد النوع واسم المصفوفة وحجمها. يحدد الحجم عدد عناصر الصفيف (1 على الأقل) وهو محاط بين قوسين مربعين. يجب أن يكون حجم المصفوفة معروفًا بالفعل في مرحلة الترجمة، وبالتالي يجب أن يكون تعبيرًا ثابتًا، على الرغم من أنه لا يتم تحديده بالضرورة كتعبير حرفي. فيما يلي أمثلة لتعريفات المصفوفة الصحيحة وغير الصحيحة:

الخارجية int get_size(); // ثوابت buf_size وmax_files
const int buf_size = 512, max_files = 20;
كثافة الموظفين_حجم = 27؛ // صحيح: ثابت char input_buffer[ buf_size ]؛ // صحيح: التعبير الثابت: 20 - 3 char *fileTable[ max_files-3 ]; // خطأ: لا يوجد راتب مزدوج ثابت[staff_size]; // خطأ: ليس تعبيرًا ثابتًا int test_scores[ get_size() ];

تعد الكائنات buf_size وmax_files ثوابت، لذا فإن تعريفات مصفوفة input_buffer وfileTable صحيحة. لكن حجم الموظفين متغير (على الرغم من أنه تمت تهيئته بالرقم الثابت 27)، مما يعني أن الرواتب غير مقبولة. (المترجم غير قادر على العثور على قيمة المتغير Staff_size عند تحديد مصفوفة الرواتب.)
يمكن تقييم التعبير max_files-3 في وقت الترجمة، لذا فإن تعريف صفيف fileTable صحيح من الناحية النحوية.
يبدأ ترقيم العناصر عند 0، لذا بالنسبة لمصفوفة مكونة من 10 عناصر، فإن نطاق الفهرس الصحيح ليس 1 - 10، بل 0 - 9. فيما يلي مثال على التكرار عبر جميع عناصر المصفوفة:

int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 0; ix< array_size; ++ ix)
ia[التاسع] = التاسع;
}

عند تعريف مصفوفة، يمكنك تهيئتها بشكل صريح عن طريق إدراج قيم عناصرها بين قوسين متعرجين، مفصولة بفواصل:

Const int array_size = 3؛ int ia[ray_size] = ( 0, 1, 2);

إذا قمنا بتحديد قائمة من القيم بشكل صريح، فلن نحتاج إلى تحديد حجم المصفوفة: المترجم نفسه سوف يحسب عدد العناصر:

// مصفوفة بالحجم 3 int ia = ( 0, 1, 2 );

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

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; int ia[ray_size] = ( 0, 1, 2);

يمكن تهيئة مصفوفة الأحرف ليس فقط باستخدام قائمة قيم الأحرف داخل الأقواس المتعرجة، ولكن أيضًا باستخدام سلسلة حرفية. ومع ذلك، هناك بعض الاختلافات بين هذه الأساليب. دعنا نقول

Const char cal = ("C"، "+"، "+" ); const char cal2 = "C++";

أبعاد مصفوفة ca1 هي 3، ومصفوفة ca2 هي 4 (في السلسلة الحرفية، يتم أخذ الحرف الفارغ النهائي في الاعتبار). التعريف التالي سوف يسبب خطأ في الترجمة:

// خطأ: السلسلة "Daniel" تتكون من 7 عناصر const char ch3[ 6 ] = "Daniel";

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

Const int array_size = 3؛ إنت التاسع، جكس، ككس؛ // صحيح: مجموعة من المؤشرات من النوع int* int *iar = ( &ix, &jx, &kx ); // خطأ: المصفوفات المرجعية غير مسموح بها int &iar = ( ix, jx, kx ); انت مين()
{
int ia3(ray_size]; // صحيح
// خطأ: لا يمكن نسخ المصفوفات المضمنة
ia3 = ia;
العودة 0؛
}

لنسخ مصفوفة إلى أخرى، عليك القيام بذلك لكل عنصر على حدة:

Const int array_size = 7؛ كثافة العمليات ia1 = (0, 1, 2, 3, 4, 5, 6); انت مين() (
int ia3[ray_size]; ل(int التاسع = 0؛ التاسع< array_size; ++ix)
ia2[التاسع] = ia1[التاسع]; العودة 0؛
}

يمكن أن يكون فهرس المصفوفة أي تعبير ينتج نتيجة لنوع عدد صحيح. على سبيل المثال:

Int someVal, get_index(); ia2[get_index()] = someVal;

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

التمرين 3.22

أي من تعريفات المصفوفة التالية غير صحيحة؟ يشرح.

(أ) int ia[buf_size]; (د) int ia[ 2 * 7 - 14 ] (ب) int ia[ get_size() ]; (هـ) شار st[ 11 ] = "أساسي"; (ج) كثافة العمليات [ 4 * 7 - 14 ];

التمرين 3.23

يجب أن يقوم مقتطف التعليمات البرمجية التالي بتهيئة كل عنصر من عناصر المصفوفة بقيمة فهرس. ابحث عن الأخطاء المرتكبة:

int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 1; ix<= array_size; ++ix)
ia[ia] = ix; // ...
}

3.9.1. مصفوفات متعددة الأبعاد

في لغة C++، من الممكن استخدام المصفوفات متعددة الأبعاد، عند الإعلان عنها يجب عليك الإشارة إلى الحد الأيمن لكل بعد بين قوسين مربعين منفصلين. فيما يلي تعريف المصفوفة ثنائية الأبعاد:

إنت إيا[ 4 ] [ 3 ];

تحدد القيمة الأولى (4) عدد الصفوف، والثانية (3) - عدد الأعمدة. يتم تعريف كائن ia على أنه مصفوفة من أربع سلاسل مكونة من ثلاثة عناصر لكل منها. يمكن أيضًا تهيئة المصفوفات متعددة الأبعاد:

Int ia[ 4 ][ 3 ] = ( ( 0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

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

كثافة العمليات = (0,1,2,3,4,5,6,7,8,9,10,11);

يقوم التعريف التالي بتهيئة العناصر الأولى فقط من كل سطر. العناصر المتبقية ستكون صفراً:

كثافة العمليات[ 4 ][ 3 ] = ( (0), (3), (6), (9) );

إذا قمت بحذف الأقواس الداخلية المتعرجة، فإن النتيجة ستكون مختلفة تماما. ستتلقى جميع العناصر الثلاثة في الصف الأول والعنصر الأول من الثاني القيمة المحددة، وسيتم تهيئة الباقي ضمنيًا إلى 0.

Int ia[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

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

Int main() ( const introwSize = 4; const int colSize = 3; int ia[rowSize][colSize]; for (int = 0; i< rowSize; ++i)
ل(int j = 0; j< colSize; ++j)
ia[i][j] = i + j j;
}

تصميم

يا[ 1, 2 ]

صحيح من وجهة نظر بناء جملة C++، لكنه لا يعني على الإطلاق ما يتوقعه مبرمج عديم الخبرة. هذا ليس إعلانًا عن مصفوفة ثنائية الأبعاد 1 × 2. التجميع بين قوسين مربعين هو قائمة من التعبيرات مفصولة بفواصل والتي ستؤدي إلى القيمة النهائية 2 (انظر عامل الفاصلة في القسم 4.2). لذلك فإن الإعلان ia يعادل ia. هذه فرصة أخرى لارتكاب خطأ.

3.9.2. العلاقة بين المصفوفات والمؤشرات

إذا كان لدينا تعريف صفيف:

إنت أ = ( 0, 1, 1, 2, 3, 5, 8, 13, 21);

إذن ماذا يعني مجرد الإشارة إلى اسمه في البرنامج؟

إن استخدام معرف المصفوفة في البرنامج يعادل تحديد عنوان العنصر الأول الخاص به:

وبالمثل، يمكنك الوصول إلى قيمة العنصر الأول في المصفوفة بطريقتين:

// يعيد كلا التعبيرين العنصر الأول *ia; I ل؛

للحصول على عنوان العنصر الثاني من المصفوفة يجب أن نكتب:

وكما ذكرنا سابقاً فإن التعبير

كما يعطي عنوان العنصر الثاني من المصفوفة. وعليه يأتي معناها على الوجهين التاليين:

*(ia+1); I ل؛

لاحظ الفرق في التعبيرات:

*ia+1 و *(ia+1);

عملية إلغاء الإشارة لديها أعلى أولويةمن عملية الإضافة (تتم مناقشة أولويات المشغل في القسم 4.13). لذلك، يقوم التعبير الأول أولاً بإلغاء تحديد المتغير ia ويحصل على العنصر الأول من المصفوفة، ثم يضيف 1 إليه. ويقدم التعبير الثاني قيمة العنصر الثاني.

يمكنك اجتياز مصفوفة باستخدام فهرس، كما فعلنا في القسم السابق، أو باستخدام المؤشرات. على سبيل المثال:

#يشمل int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); int *pbegin = ia; int *pend = ia + 9; while (pbegin != pend) ( cout<< *pbegin <<; ++pbegin; } }

تتم تهيئة مؤشر pbegin إلى عنوان العنصر الأول في المصفوفة. يؤدي كل مرور خلال الحلقة إلى زيادة هذا المؤشر بمقدار 1، مما يعني أنه يتم إزاحته إلى العنصر التالي. كيف تعرف مكان الإقامة؟ في مثالنا، قمنا بتعريف مؤشر تعليق ثانٍ وقمنا بتهيئته بالعنوان الذي يلي العنصر الأخير في المصفوفة ia. بمجرد أن تصبح قيمة pbegin مساوية لـ pend، نعلم أن المصفوفة قد انتهت. دعونا نعيد كتابة هذا البرنامج بحيث يتم تمرير بداية ونهاية المصفوفة كمعلمات إلى دالة معممة معينة يمكنها طباعة مصفوفة بأي حجم:

#يشمل باطلة ia_print(int *pbegin, int *pend) (
بينما (pbegin != pend) (
cout<< *pbegin << " ";
++pbegin;
}
) انت مين()
{
كثافة العمليات = (0, 1, 1, 2, 3, 5, 8, 13, 21);
ia_print(ia, ia + 9);
}

أصبحت وظيفتنا أكثر عالمية، ومع ذلك، لا يمكنها العمل إلا مع صفائف من النوع int. هناك طريقة لإزالة هذا القيد: تحويل هذه الوظيفة إلى قالب (تم تقديم القوالب لفترة وجيزة في القسم 2.5):

#يشمل نموذج طباعة باطلة (elemType *pbegin، elemType *pend) ( while (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

يمكننا الآن استدعاء الدالة print()‎ لطباعة المصفوفات من أي نوع:

Int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); double da = ( 3.14, 6.28, 12.56, 25.12 ); سلسلة sa = ( "خنزير صغير"، " eeyore"، "pooh" ); print(ia, ia+9);
طباعة (دا، دا + 4)؛
طباعة (سا، سا+3)؛
}

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

#يشمل int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( "piglet", "eeyore", "pooh" );sort(ia, ia+6);
فرز(سا,سا+3);
};

(سنتناول المزيد من التفاصيل حول الخوارزميات المعممة في الفصل 12، وسيقدم الملحق أمثلة على استخدامها.)
تحتوي مكتبة C++ القياسية على مجموعة من الفئات التي تتضمن استخدام الحاويات والمؤشرات. (تمت مناقشة هذا في القسم 2.8.) في القسم التالي، سنلقي نظرة على ناقل نوع الحاوية القياسي، وهو تطبيق موجه للكائنات لمصفوفة.

3.10. فئة المتجهات

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

#يشمل

هناك طريقتان مختلفتان تمامًا لاستخدام المتجه، دعنا نسميهما مصطلح المصفوفة ومصطلح STL. في الحالة الأولى، يتم استخدام كائن متجه بنفس الطريقة تمامًا مثل مصفوفة من النوع المضمن. يتم تحديد متجه لبعد معين:

المتجه< int >إيفيك (10) ؛

وهو مشابه لتعريف مصفوفة من النوع المدمج:

إنت إيا[10]؛

للوصول إلى العناصر الفردية للمتجه، يتم استخدام عملية الفهرس:

باطلة simp1e_examp1e() ( const int e1em_size = 10; المتجه< int >ivec(e1em_size); int ia[e1em_size]; ل(int التاسع = 0؛ التاسع< e1em_size; ++ix)
ia[ix] = ivec[ix]; // ...
}

يمكننا معرفة أبعاد المتجه باستخدام الدالة size() والتحقق مما إذا كان المتجه فارغًا باستخدام الدالة الفارغة(). على سبيل المثال:

طباعة باطلة_vector(vector ivec) ( if (ivec.empty()) return; for (int ix=0; ix< ivec.size(); ++ix)
cout<< ivec[ ix ] << " ";
}

تتم تهيئة عناصر المتجه بالقيم الافتراضية. بالنسبة للأنواع والمؤشرات الرقمية، هذه القيمة هي 0. إذا كانت العناصر عبارة عن كائنات فئة، فسيتم تحديد البادئ لها بواسطة المنشئ الافتراضي (انظر القسم 2.3). ومع ذلك، يمكن أيضًا تحديد البادئ بشكل صريح باستخدام النموذج:

المتجه< int >ivec(10, -1);

جميع العناصر العشرة للمتجه ستكون مساوية لـ -1.
يمكن تهيئة مصفوفة من النوع المدمج بشكل صريح باستخدام قائمة:

Int ia[ 6 ] = ( -2, -1, O, 1, 2, 1024);

لا يمكن تنفيذ إجراء مماثل لكائن من فئة المتجه. ومع ذلك، يمكن تهيئة مثل هذا الكائن باستخدام نوع مصفوفة مضمن:

// يتم نسخ 6 عناصر ia إلى ناقل ivec< int >ivec(ia, ia+6);

يتم تمرير منشئ المتجه ivec مؤشرين - مؤشر إلى بداية المصفوفة ia وإلى العنصر الذي يلي العنصر الأخير. كقائمة من القيم الأولية، لا يجوز تحديد المصفوفة بأكملها، بل نطاق معين منها:

// يتم نسخ 3 عناصر: ia، ia، ia Vector< int >ivec(&ia[ 2 ], &ia[ 5 ]);

هناك اختلاف آخر بين المتجه والمصفوفة المضمنة وهو القدرة على تهيئة كائن متجه مع آخر واستخدام عامل التعيين لنسخ الكائنات. على سبيل المثال:

المتجه< string >سفيك؛ void init_and_sign() ( // تتم تهيئة أحد المتجهات بواسطة ناقل آخر< string >user_names(svec); // ... // يتم نسخ متجه إلى آخر
svec = user_names;
}

عندما نتحدث عن لغة STL، فإننا نعني نهجًا مختلفًا تمامًا لاستخدام المتجه. بدلاً من تحديد الحجم المطلوب على الفور، نحدد متجهًا فارغًا:

المتجه< string >نص؛

ثم نضيف عناصر إليها باستخدام وظائف مختلفة. على سبيل المثال، تقوم الدالة Push_back() بإدراج عنصر في نهاية المتجه. إليك جزء من التعليمات البرمجية يقرأ سلسلة من الأسطر من الإدخال القياسي ويضيفها إلى المتجه:

كلمة سلسلة؛ بينما (سين >> كلمة) ( text.push_back(word); // ... )

على الرغم من أنه يمكننا استخدام عملية الفهرس للتكرار على عناصر المتجه:

كوت<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

الاستخدام الأكثر شيوعًا للمكررات ضمن هذا المصطلح هو:

كوت<< "считаны слова: \n"; for (vector::iterator it = text.begin(); ذلك != text.end(); ++it) cout<< *it << " "; cout << endl;

المكرر عبارة عن فئة مكتبة قياسية تعد في الأساس مؤشرًا لعنصر الصفيف.
تعبير

يقوم بإلغاء الإشارة إلى المكرر ويعطي العنصر المتجه نفسه. تعليمات

ينقل المؤشر إلى العنصر التالي. ليست هناك حاجة للخلط بين هذين النهجين. إذا اتبعت لغة STL عند تحديد متجه فارغ:

المتجه ivec;

سيكون من الخطأ أن أكتب:

ليس لدينا عنصر واحد من ناقل ivec حتى الآن؛ يتم تحديد عدد العناصر باستخدام الدالة size().

ويمكن أيضًا ارتكاب الخطأ المعاكس. إذا قمنا بتعريف متجه بحجم معين، على سبيل المثال:

المتجه أنا(10);

ثم يؤدي إدراج العناصر إلى زيادة حجمه، وإضافة عناصر جديدة إلى العناصر الموجودة. على الرغم من أن هذا يبدو واضحًا، إلا أن المبرمج المبتدئ قد يكتب:

حجم ثابت = 7؛ int ia[الحجم] = (0, 1, 1, 2, 3, 5, 8); المتجه< int >ivec(حجم); ل(int التاسع = 0؛ التاسع< size; ++ix) ivec.push_back(ia[ ix ]);

وهذا يعني تهيئة متجه ivec بقيم عناصر ia، مما أدى إلى ظهور متجه ivec بحجم 14.
باتباع لغة STL، لا يمكنك إضافة عناصر من المتجه فحسب، بل يمكنك أيضًا إزالتها. (سنتناول كل هذا بالتفصيل وبالأمثلة في الفصل السادس).

التمرين 3.24

هل هناك أي أخطاء في التعريفات التالية؟
int ia[ 7 ] = ( 0, 1, 1, 2, 3, 5, 8 );

(أ) ناقلات< vector< int >>ivec;
(ب) ناقلات< int >إيفيك = (0, 1, 1, 2, 3, 5, 8);
(ج) ناقلات< int >ivec(ia, ia+7);
(د) ناقلات< string >svec = ivec;
(ه) ناقلات< string >svec(10, string("null"));

التمرين 3.25

تنفيذ الوظيفة التالية:
منطقي is_equal(const int*ia, int ia_size,
ناقل ثابت &ivec);
تقارن الدالة is_equal() بين حاويتين عنصرًا بعنصر. وفي حالة الحاويات ذات الأحجام المختلفة، لا يؤخذ "ذيل" الحاوية الأطول بعين الاعتبار. من الواضح أنه إذا كانت جميع العناصر المقارنة متساوية، فسترجع الدالة صحيحًا، وإذا كان عنصر واحد مختلفًا على الأقل، فسترجع خطأ. استخدم مكررًا للتكرار على العناصر. اكتب دالة main() تستدعي is_equal().

3.11. مجمع الطبقة

فئة الأعداد المركبة المعقدة هي فئة أخرى من المكتبة القياسية. كالعادة، لاستخدامه، يجب عليك تضمين ملف الرأس:

#يشمل

يتكون العدد المركب من جزأين - حقيقي وتخيلي. الجزء التخيلي هو الجذر التربيعي لعدد سالب. عادةً ما يُكتب العدد المركب على الصورة

حيث 2 هو الجزء الحقيقي، و3i هو الجزء التخيلي. فيما يلي أمثلة لتعريفات الكائنات من النوع المعقد:

// رقم وهمي بحت: 0 + 7-i مركب< double >بوري (0، 7)؛ // الجزء التخيلي هو 0: 3 + مجمع Oi< float >rea1_num(3); // كل من الأجزاء الحقيقية والتخيلية تساوي 0: 0 + 0-i complex< long double >صفر؛ // تهيئة رقم مركب مع مركب آخر< double >purei2(بوري);

نظرًا لأن المعقد، مثل المتجه، عبارة عن قالب، فيمكننا إنشاء مثيل له باستخدام الأنواع float وdouble وlong double، كما في الأمثلة المذكورة. يمكنك أيضًا تحديد مصفوفة من العناصر من النوع المعقد:

معقد< double >مرافقة[ 2 ] = (معقدة< double >(2، 3)، مجمع< double >(2, -3) };

معقد< double >*ptr = معقد< double >&ref = *ptr;

3.12. توجيه typedef

يسمح لك توجيه typedef بتحديد مرادف لنوع بيانات مضمن أو مخصص. على سبيل المثال:

Typedef الأجور المزدوجة؛ ناقل typedef vec_int; typedef vec_int test_scores; typedef bool in_attendance; typedef int *Pint;

يمكن استخدام الأسماء المعرفة باستخدام توجيه typedef بنفس طريقة محددات النوع:

// مضاعفة كل ساعة، أسبوعيا؛ الأجور بالساعة والأسبوعية؛ //المتجه فيكل(10);
vec_int vecl(10); //المتجه test0(c1ass_size); const int c1ass_size = 34; test_scores test0(c1ass_size); //المتجه< bool >حضور؛ المتجه< in_attendance >الحضور(c1ass_size); // int *table[ 10 ]; طاولة نصف لتر [10]؛

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

Typedef char *cstring;

ما هو نوع المتغير cstr في الإعلان التالي:

extern const cstring cstr؛

الجواب الذي يبدو واضحا هو:

كونست شار *cstr

مهما يكن ... هذه ليست الحقيقة. يشير محدد const إلى cstr، وبالتالي فإن الإجابة الصحيحة هي مؤشر const إلى char:

شار *const cstr;

3.13. محدد متقلب

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

متطاير كثافة العمليات disp1ay_register؛ مهمة متقلبة *curr_task; متقلبة int ixa[max_size]; bitmap_buf للشاشة المتقلبة؛

Display_register هو كائن متطاير من النوع int. curr_task هو مؤشر لكائن متطاير من فئة المهمة. ixa عبارة عن مصفوفة غير مستقرة من الأعداد الصحيحة، وكل عنصر في هذه المصفوفة يعتبر غير مستقر. bitmap_buf هو كائن متطاير من فئة الشاشة، ويعتبر كل عضو من بياناته متطايرًا أيضًا.
الغرض الوحيد من استخدام المحدد المتطاير هو إخبار المترجم أنه لا يمكنه تحديد من يمكنه تغيير قيمة كائن معين وكيف. ولذلك، يجب ألا يقوم المحول البرمجي بإجراء تحسينات على التعليمات البرمجية التي تستخدم هذا الكائن.

3.14. زوج الطبقة

تتيح لنا فئة الزوج في مكتبة C++ القياسية تحديد زوج من القيم بكائن واحد إذا كان هناك أي اتصال دلالي بينهما. يمكن أن تكون هذه القيم هي نفسها أو أنواع مختلفة. لاستخدام هذه الفئة يجب عليك تضمين ملف الرأس:

#يشمل

على سبيل المثال، التعليمات

زوج< string, string >المؤلف ("جيمس"، "جويس")؛

ينشئ كائن مؤلف من النوع زوج، يتكون من قيمتين من السلسلة.
يمكن الحصول على الأجزاء الفردية للزوج باستخدام العضوين الأول والثاني:

سلسلة أول كتاب؛ إذا (جويس.فيرست == "جيمس" &&
جويس.ثانية == "جويس")
firstBook = "ستيفن هيرو";

إذا كنت بحاجة إلى تعريف عدة كائنات من نفس النوع من هذه الفئة، فمن الملائم استخدام توجيه typedef:

زوج Typedef< string, string >المؤلفون؛ المؤلفون بروست("مارسيل", "بروست"); المؤلفون جويس ("جيمس"، "جويس")؛ المؤلفون موسيل("روبرت", "musi1");

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

فتحة دخول الفئة؛ فتحة الإدخال الخارجية* 1ook_up(string); زوج typedef< string, EntrySlot* >إدخال الرمز; رمز الإدخال current_entry("author", 1ook_up("author"));
// ... إذا (EntrySlot *it = 1ook_up("editor")) (
current_entry.first = "editor";
current_entry. Second = it;
}

(سنعود إلى فئة الزوج عندما نتحدث عن أنواع الحاويات في الفصل السادس وعن الخوارزميات العامة في الفصل الثاني عشر.)

3.15. أنواع الفصول

تسمح لك آلية الفصل بإنشاء أنواع بيانات جديدة؛ بمساعدتها، تم تقديم أنواع السلسلة والمتجهات والمعقدة والزوجية التي تمت مناقشتها أعلاه. في الفصل الثاني، قدمنا ​​المفاهيم والآليات التي تدعم النهج الكائني والموجه للكائنات، باستخدام فئة Array كمثال. هنا، بناءً على نهج الكائن، سنقوم بإنشاء فئة سلسلة بسيطة، والتي سيساعدنا تنفيذها على فهم التحميل الزائد للمشغل، على وجه الخصوص - تحدثنا عنه في القسم 2.3. (يتم تناول الفصول بالتفصيل في الفصول 13 و14 و15.) لقد قدمنا ​​​​وصفًا موجزًا ​​للفصل من أجل تقديم أمثلة أكثر إثارة للاهتمام. قد يرغب القارئ الجديد في لغة C++ في تخطي هذا القسم وانتظار وصف أكثر منهجية للفئات في الفصول اللاحقة.)
يجب أن تدعم فئة السلسلة الخاصة بنا التهيئة بواسطة كائن من فئة السلسلة، وسلسلة حرفية، ونوع السلسلة المضمنة، بالإضافة إلى عملية تعيين القيم لهذه الأنواع. نحن نستخدم منشئي الفئة ومشغل المهمة المثقلة لهذا الغرض. سيتم تنفيذ الوصول إلى أحرف السلسلة الفردية كعملية فهرس مثقلة. بالإضافة إلى ذلك، سنحتاج إلى: الدالة size() للحصول على معلومات حول طول السلسلة؛ عملية مقارنة كائنات من النوع String وكائنات String بسلسلة من النوع المدمج؛ وكذلك عمليات الإدخال/الإخراج لكائننا. أخيرًا، قمنا بتنفيذ القدرة على الوصول إلى التمثيل الداخلي لسلسلتنا كنوع سلسلة مدمج.
يبدأ تعريف الفئة بالكلمة الأساسية، متبوعة بمعرف - اسم الفئة أو النوع. بشكل عام، يتكون الفصل من أقسام تسبقها الكلمات العامة (مفتوحة) والخاصة (مغلقة). يحتوي القسم العام عادةً على مجموعة من العمليات التي يدعمها الفصل، تسمى الأساليب أو وظائف الأعضاء في الفصل. تحدد وظائف الأعضاء هذه الواجهة العامة للفئة، وبعبارة أخرى، مجموعة الإجراءات التي يمكن تنفيذها على كائنات تلك الفئة. يتضمن القسم الخاص عادةً أعضاء البيانات الذين يوفرون التنفيذ الداخلي. في حالتنا، تتضمن الأعضاء الداخلية _string - مؤشر إلى char، بالإضافة إلى _size من النوع int. سوف يقوم _size بتخزين معلومات حول طول السلسلة، وسيكون _string عبارة عن مجموعة من الأحرف المخصصة ديناميكيًا. هذا ما يبدو عليه تعريف الفئة:

#يشمل سلسلة الطبقة؛ istream& المشغل >>(istream&, String&);
ostream& المشغل<<(ostream&, const String&); class String {
عام:
// مجموعة من المنشئين
// للتهيئة التلقائية
// سلسلة strl؛ // خيط()
// سلسلة str2("literal"); // سلسلة(const char*);
// سلسلة str3(str2); // سلسلة (سلسلة كونست &)؛ خيط()؛
سلسلة (كونست شار *)؛
سلسلة(سلسلة ثابتة&); // المدمرة
~سلسلة(); // عوامل التعيين
// strl = str2
// str3 = "سلسلة حرفية" String&operator=(const String&);
String&operator=(const char*); // عوامل اختبار المساواة
// strl == str2;
// str3 == "سلسلة حرفية"; عامل منطقي ==(const String&);
عامل منطقي ==(const char*); // التحميل الزائد على مشغل الوصول حسب الفهرس
// strl[ 0 ] = str2[ 0 ]; شار&المشغل(int); // الوصول إلى أعضاء الفصل
حجم صحيح () (إرجاع _ الحجم؛)
char* c_str() ( return _string; ) خاص:
int_size;
شار *_string;
}

تحتوي فئة String على ثلاثة مُنشئات. كما تمت مناقشته في القسم 2.3، تتيح لك آلية التحميل الزائد تحديد تطبيقات متعددة للوظائف التي تحمل الاسم نفسه، طالما أنها تختلف جميعًا في عدد و/أو أنواع معلماتها. المنشئ الأول

إنه المُنشئ الافتراضي لأنه لا يتطلب قيمة أولية صريحة. عندما نكتب:

بالنسبة إلى str1، يتم استدعاء هذا المنشئ.
لكل من المنشئين المتبقيين معلمة واحدة. نعم لاجل

سلسلة str2("سلسلة الأحرف");

يسمى المنشئ

سلسلة (كونست شار *)؛

سلسلة str3(str2);

البناء

سلسلة(سلسلة ثابتة&);

يتم تحديد نوع المنشئ الذي يتم استدعاؤه حسب نوع الوسيطة الفعلية. يُطلق على آخر المُنشئات، String(const String&)، مُنشئ النسخ لأنه يقوم بتهيئة كائن بنسخة من كائن آخر.
إذا كتبت:

سلسلة str4(1024);

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

عامل تشغيل Return_type op(parameter_list);

حيث أن عامل التشغيل هو كلمة أساسية، وop هو أحد عوامل التشغيل المحددة مسبقًا: +، =، ==، وما إلى ذلك. (راجع الفصل 15 للحصول على تعريف دقيق للتركيب.) فيما يلي إعلان عامل الفهرس المحمل بشكل زائد:

شار&المشغل(int);

يحتوي هذا العامل على معلمة واحدة من النوع int ويقوم بإرجاع مرجع إلى char. قد يتم تحميل عامل التشغيل المثقل بشكل زائد إذا اختلفت قوائم المعلمات الخاصة بعمليات إنشاء مثيلات فردية. بالنسبة لفئة السلسلة الخاصة بنا، سنقوم بإنشاء عاملي إسناد ومساواة مختلفين.
لاستدعاء وظيفة عضو، استخدم عوامل وصول العضو النقطة (.) أو السهم (->). دعونا نحصل على إعلانات لكائنات من النوع String:

كائن سلسلة ("داني")؛
String *ptr = new String("آنا");
مصفوفة السلسلة؛
إليك ما يبدو عليه استدعاء size() على هذه الكائنات:
المتجه الأحجام (3)؛

// عضو الوصول للكائنات (.); // حجم الكائنات هو 5 أحجام[ 0 ] = object.size(); // وصول الأعضاء للمؤشرات (->)
// ptr بحجم 4
الأحجام[ 1 ] = ptr->size(); // الوصول إلى العضو (.)
// حجم المصفوفة 0
الأحجام[2] = array.size();

تقوم بإرجاع 5 و 4 و 0 على التوالي.
يتم تطبيق العوامل المحملة بشكل زائد على الكائن بنفس الطريقة التي يتم بها تطبيق العوامل العادية:

اسم السلسلة ("يادي")؛ اسم السلسلة 2("يودي"); // عامل التشغيل المنطقي ==(سلسلة const&)
إذا (الاسم == الاسم 2)
يعود؛
آخر
// سلسلة & عامل = (سلسلة ثابتة &)
الاسم = الاسم2؛

يجب أن يكون إعلان وظيفة العضو داخل تعريف الفئة، ويمكن أن يكون تعريف الوظيفة داخل تعريف الفئة أو خارجه. (يتم تعريف كل من الدالتين size() وc_str() داخل فئة ما.) إذا تم تعريف دالة خارج فئة ما، فيجب علينا تحديد الفئة التي تنتمي إليها، من بين أمور أخرى. في هذه الحالة، يتم وضع تعريف الوظيفة في الملف المصدر، مثلاً String.C، ويتم وضع تعريف الفئة نفسها في ملف الرأس (String.h في مثالنا)، والذي يجب تضمينه في المصدر :

// محتويات الملف المصدر: String.C // تمكين تعريف فئة السلسلة
#include "String.h" // يتضمن تعريف الدالة strcmp()
#يشمل
منطقي // نوع الإرجاع
السلسلة:: // الفئة التي تنتمي إليها الوظيفة
عامل == // اسم الوظيفة: عامل المساواة
(سلسلة const &rhs) // قائمة المعلمات
{
إذا (_size!= rhs._size)
عودة كاذبة؛
إرجاع strcmp(_strinq, rhs._string) ؟
خطأ: صحيح؛
}

تذكر أن strcmp() هي دالة مكتبة قياسية في لغة C، فهي تقارن سلسلتين مضمنتين، وتعيد 0 إذا كانت السلاسل متساوية وغير صفرية إذا لم تكن متساوية. يقوم العامل الشرطي (؟:) باختبار القيمة قبل علامة الاستفهام. إذا كان صحيحًا، فسيتم إرجاع قيمة التعبير الموجود على يسار النقطتين؛ وإلا، فسيتم إرجاع القيمة الموجودة على اليمين. في مثالنا، تكون قيمة التعبير خاطئة إذا أعادت الدالة strcmp() قيمة غير صفرية، وتكون صحيحة إذا أعادت قيمة صفر. (تمت مناقشة العامل الشرطي في القسم 4.7.)
يتم استخدام عملية المقارنة في كثير من الأحيان، وتبين أن الوظيفة التي تنفذها صغيرة، لذلك من المفيد إعلان هذه الوظيفة مدمجة (مضمنة). يقوم المترجم باستبدال نص الوظيفة بدلاً من استدعائها، لذلك لا يضيع أي وقت في مثل هذا الاستدعاء. (تتم مناقشة الوظائف المضمنة في القسم 7.6.) تكون وظيفة العضو المحددة داخل الفصل مدمجة بشكل افتراضي. إذا تم تعريفها خارج الفصل، فمن أجل إعلانها مدمجة، تحتاج إلى استخدام الكلمة الأساسية المضمنة:

سلسلة منطقية مضمّنة::operator==(const String &rhs) (// نفس الشيء)

يجب أن يكون تعريف الوظيفة المضمنة في ملف الرأس الذي يحتوي على تعريف الفئة. من خلال إعادة تعريف عامل التشغيل == كعامل سطري، يجب علينا نقل نص الوظيفة نفسه من ملف String.C إلى ملف String.h.
فيما يلي تنفيذ عملية مقارنة كائن سلسلة بنوع سلسلة مضمن:

سلسلة منطقية مضمنة::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

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

#يشمل // المنشئ الافتراضي المضمّن String::String()
{
_الحجم = 0;
_سلسلة = 0;
) inline String::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) else ( _size = str1en(str); strcpy(_string, str); ) // نسخ المُنشئ
سلسلة مضمنة::سلسلة(سلسلة const &rhs)
{
size = rhs._size;
إذا (! rhs._string)
_سلسلة = 0;
آخر(
_string = new char[ _size + 1];
} }

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

سلسلة مضمنة: :~String() (حذف _string;)

يستخدم كلا عاملي التعيين المحملين بشكل زائد الكلمة الأساسية الخاصة this.
عندما نكتب:

سلسلة namel("أورفيل"), name2("ويلبر");
الاسم = "أورفيل رايت"؛
هذا هو المؤشر الذي يعالج كائن name1 داخل النص الأساسي لعملية التعيين.
يشير هذا دائمًا إلى كائن الفئة الذي يتم من خلاله استدعاء الوظيفة. لو
ptr->size();
كائن[1024];

ثم داخل size() ستكون قيمة هذا هي العنوان المخزن في ptr. داخل عملية الفهرس، يحتوي هذا على عنوان obj. من خلال إلغاء الإشارة إلى this (باستخدام *this)، نحصل على الكائن نفسه. (تم وصف هذا المؤشر بالتفصيل في القسم 13.4.)

Inline String& String::operator=(const char *s) ( if (! s) ( _size = 0; حذف _string; _string = 0; ) else ( _size = str1en(s); حذف _string; _string = new char[ _size + 1 ]; strcpy(_string, s);

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

Inline String& String::operator=(const String &rhs) ( // في التعبير // namel = *pointer_to_string // هذا يمثل name1، // rhs - *pointer_to_string.if (this != &rhs) (

فيما يلي النص الكامل لعملية تعيين كائن من نفس النوع لكائن سلسلة:

سلسلة مضمنة وسلسلة::operator=(const String &rhs) ( if (this != &rhs) (حذف _string; _size = rhs._size; if (! rhs._string)
_سلسلة = 0;
آخر(
_string = new char[ _size + 1];
strcpy(_string, rhs._string);
}
}
العودة * هذا؛
}

إن عملية أخذ الفهرس مطابقة تقريبًا لتطبيقها على مصفوفة Array التي أنشأناها في القسم 2.3:

#يشمل حرف مضمّن&
سلسلة :: المشغل (عنصر int)
{
تأكيد(elem >= 0 && elem< _size);
إرجاع _سلسلة [عنصر]؛
}

يتم تنفيذ عوامل الإدخال والإخراج كوظائف منفصلة بدلاً من كونها أعضاء في الفصل. (سنتحدث عن أسباب ذلك في القسم 15.2. ويتحدث القسمان 20.4 و20.5 عن التحميل الزائد لمشغلي الإدخال والإخراج في مكتبة iostream.) يمكن لمشغل الإدخال لدينا قراءة 4095 حرفًا كحد أقصى. setw() عبارة عن مناور محدد مسبقًا، فهو يقرأ عددًا معينًا من الأحرف ناقص 1 من تدفق الإدخال، وبالتالي يضمن عدم تجاوز سعة المخزن المؤقت الداخلي لدينا في inBuf. (يناقش الفصل 20 معالج setw() بالتفصيل.) لاستخدام المعالجات، يجب عليك تضمين ملف الرأس المقابل:

#يشمل مضمّن istream& عامل>>(istream &io, String &s) ( // الحد الاصطناعي: 4096 حرفًا const int 1imit_string_size = 4096; char inBuf[ Limit_string_size ]; // setw() مضمن في مكتبة iostream // فهو يحد من حجم الكتلة القابلة للقراءة إلى 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf s = mBuf // String::operator=(const char*);

يحتاج مشغل الإخراج إلى الوصول إلى التمثيل الداخلي للسلسلة. منذ المشغل<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

مضمنة ostream والمشغل<<(ostream& os, const String &s) { return os << s.c_str(); }

يوجد أدناه برنامج مثال يستخدم فئة السلسلة. يأخذ هذا البرنامج الكلمات من تدفق الإدخال ويحسب العدد الإجمالي لها، بالإضافة إلى عدد الكلمات "the" و"it"، ويسجل حروف العلة التي تمت مواجهتها.

#يشمل #include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / الكلمتين "ال" و"هو"
// سوف نتحقق باستخدام عامل التشغيل==(const char*)
سلسلة لكن، the("the"),it("it"); // عامل التشغيل>>(ostream&، String&)
بينما (سين >> بوف) (
++wdCnt; // المشغل أو العامل<<(ostream&, const String&)
cout<< buf << " "; if (wdCnt % 12 == 0)
cout<< endl; // String::operator==(const String&) and
// String::operator==(const char*);
إذا (buf == the | | buf == "The")
++theCnt;
آخر
إذا (buf == it || buf == "It")
++itCnt; // يستدعي السلسلة::s-ize()
ل (int التاسع = 0؛ التاسع< buf.sizeO; ++ix)
{
// يستدعي String::operator(int)
التبديل (بوف [التاسع])
{
الحالة "أ": الحالة "أ": ++aCnt; استراحة؛
الحالة "e": الحالة "E": ++eCnt; استراحة؛
الحالة "i": الحالة "I": ++iCnt; استراحة؛
الحالة "o": الحالة "0": ++oCnt; استراحة؛
الحالة "u": الحالة "U": ++uCnt; استراحة؛
الافتراضي: ++notVowe1; استراحة؛
}
}
) // المشغل أو العامل<<(ostream&, const String&)
cout<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

لنختبر البرنامج: سنعرض عليه فقرة من قصة أطفال كتبها أحد مؤلفي هذا الكتاب (سنلتقي بهذه القصة في الفصل السادس). وهنا نتيجة البرنامج:

أليس إيما لديها شعر أحمر طويل متدفق. يقول والدها إنه عندما تهب الريح على شعرها، فإنه يبدو حيًا تقريبًا، مثل طائر ناري أثناء طيرانه. أخبرها أنه طائر ناري جميل، سحري لكنه جامح. "أبي، اسكت، لا يوجد شيء من هذا القبيل،" قالت له، وفي نفس الوقت أرادت منه أن يخبرها بالمزيد. تسأل بخجل: "أعني يا أبي، هل هناك؟" الكلمات: 65
/ ال: 2
هو/هو: 1
الحروف الساكنة: 190
ج: 22
ه: 30
ط: 24
س: 10
ش: 7

التمرين 3.26

تحتوي تطبيقاتنا للمنشئين ومشغلي المهام على الكثير من التكرار. فكر في نقل التعليمات البرمجية المكررة إلى وظيفة عضو خاص منفصلة، ​​كما حدث في القسم 2.3. تأكد من أن الخيار الجديد يعمل.

التمرين 3.27

قم بتعديل برنامج الاختبار بحيث يقوم أيضًا بإحصاء الحروف الساكنة b، d، f، s، t.

التمرين 3.28

اكتب دالة عضو تحسب عدد مرات ظهور الحرف في سلسلة باستخدام التصريح التالي:

سلسلة الفئة ( عامة: // ... int count(char ch) const; // ... );

التمرين 3.29

قم بتنفيذ عامل تسلسل السلسلة (+) بحيث يقوم بتسلسل سلسلتين وإرجاع النتيجة في كائن سلسلة جديد. هنا هو إعلان الوظيفة:

سلسلة الفئة ( عامة: // ... مشغل السلسلة+(const String &rhs) const; // ... );

في هذا الدرس سوف تتعلم أبجدية لغة C++، وماذا أيضا أنواع البياناتيمكن للبرنامج معالجتها. قد لا تكون هذه هي اللحظة الأكثر إثارة، ولكن هذه المعرفة ضرورية بالإضافة إلى ذلك، عندما تبدأ في تعلم أي لغة برمجة أخرى، فسوف تمر بمرحلة مماثلة من التعلم بثقة أكبر! يمكن أن يحتوي برنامج C++ على الرموز التالية:

• الأحرف اللاتينية الكبيرة والصغيرة A، B، C...، x، y، z والشرطة السفلية؛
• الأرقام العربية من 0 إلى 9؛
• الأحرف الخاصة: ( ) ، | , () + - / % * . \' : ؟< > = ! & # ~ ; ^
• المسافة وعلامة التبويب وأحرف السطر الجديد.

في اختبار البرنامج يمكنك استخدامه تعليقات. إذا كان النص يحتوي على حرفين مائلين للأمام // وينتهي بحرف سطر جديد أو كان محاطًا بالحرفين /* و */، فإن المترجم يتجاهله.

البيانات في C++

لحل مشكلة ما، يقوم أي برنامج بمعالجة بعض البيانات. يمكن أن تكون من أنواع مختلفة: الأعداد الصحيحة والأرقام الحقيقية، والأحرف، والسلاسل، والمصفوفات. في لغة C++، يتم وصف البيانات عادة في بداية الوظيفة. ل أنواع البيانات الأساسيةاللغات تشمل:

لتوليد أنواع أخرى من البيانات الأساسية وما يسمى محددات.تحدد لغة C++ أربعة محددات لنوع البيانات:

• قصير قصير؛
• طويل طويل؛
• وقعت - وقعت؛
• غير موقعة - غير موقعة.

نوع عدد صحيح

نوع المتغير كثافة العملياتفي ذاكرة الكمبيوتر يمكن أن تشغل إما 2 أو 4 بايت. ذلك يعتمد على حجم بت المعالج. افتراضيًا، تعتبر كافة أنواع الأعداد الصحيحة موقعة، أي المحدد وقعتقد لا يتم تحديدها. محدد غير موقعةيسمح لك بتمثيل الأرقام الإيجابية فقط. فيما يلي بعض نطاقات قيم النوع الصحيح

النوع الحقيقي

يتم تمثيل رقم النقطة العائمة في النموذج mE +- p، حيث m هو الجزء العشري (عدد صحيح أو رقم كسري بنقطة عشرية)، p هو الأس (عدد صحيح). عادة القيم مثل يطفويستغرق 4 بايت، و مزدوج 8 بايت. جدول نطاق القيمة الحقيقية:

نوع منطقي

نوع المتغير منطقييمكن أن تأخذ قيمتين فقط حقيقي (حقيقي ) أو فاسل (كذب ). يتم تفسير أي قيمة لا تساوي الصفر على أنها حقيقي.معنى خطأ شنيعممثلة في الذاكرة كـ 0.

اكتب الفراغ

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

تحويل نوع البيانات

في لغة C++، هناك نوعان من تحويل نوع البيانات: صريح وضمني.

• التحويل الضمنييحدث تلقائيا. ويتم ذلك أثناء المقارنة أو التعيين أو تقييم التعبيرات بمختلف أنواعها. على سبيل المثال، سيقوم البرنامج التالي بطباعة قيمة مثل إلى وحدة التحكم يطفو

#تتضمن "stdafx.h" #تتضمن استخدام اسم للمحطة؛ int main() ( int i=5; float f=10.12; cout<>باطل"); إرجاع 0;)