الدرس الرابع الهياكل Structures

من طرف **Admin** الثلاثاء يوليو 02, 2019 8:41 pm

الدرس الرابع
الهياكل Structures
لقد رأينا متغيرات من أنواع البيانات البسيطة ، مثل float و char و int. تمثل المتغيرات من هذه الأنواع عنصرًا واحدًا من المعلومات : الارتفاع ، والكمية ، والعد، وما إلى ذلك. ولكن كما يتم تنظيم سلع البقالة في حقائب ، والموظفين في الإدارات ، والكلمات في جمل ، فمن المريح في كثير من الأحيان تنظيم المتغيرات البسيطة في كيانات أكثر تعقيدًا. بناء C++ المسمى "البنية" أو الهيكل structure هوالطريقة للقيام بذلك.

الهيكل structure عبارة عن مجموعة من المتغيرات البسيطة. يمكن أن تكون المتغيرات في الهيكل من أنواع مختلفة : بعضها يمكن أن يكون int ، والبعض يمكن أن يكون float ، وهكذا. (هذا على عكس المصفوفة ، التي سنلتقى بها لاحقًا ، والتي يجب أن تكون فيها جميع المتغيرات من نفس النوع .) تسمى عناصر البيانات data items في الهيكل أعضاء members الهيكل.

في الكتب التي تتناول البرمجة بلغة C ، غالبًا ما تُعتبر الهياكل ميزة متقدمة ويتم تقديمها في نهاية الكتاب. ومع ذلك ، بالنسبة للمبرمجين بلغة C++ ، تعتبر الهياكل واحدة من لبنات البناء المهمة في فهم الكائنات objects والفئات classes . في الواقع ، يكون بناء جملة الهيكلstructure مطابقًا تقريبًا لهيكل الفئة class . الهيكل structure (كما هو مستخدم عادة) عبارة عن مجموعة من البيانات ، في حين أن الفئة class عبارة عن مجموعة من البيانات data والدوال functions. لذلك من خلال تعلم الهياكل structures ، سنعمل على تمهيد الطريق لفهم الفئات والكائنات. تخدم الهياكل في C++ (و C) غرضًا مماثلًا للسجلات records في بعض اللغات الأخرى مثل Pascal.

الهيكل البسيط A Simple Structure
دعنا نبدأ بهيكل يحتوي على ثلاثة متغيرات : عددان صحيحان integers وعدد الفاصلة العائمة floating-point . يمثل هذا الهيكل عنصرًا item في مخزون شركة لقطع widget من أجزاء parts (حاجيات). الهيكل عبارة عن نوع من المخطط blueprint (النسخة الأصلية التى يتم منها الاستنساخ ) الذى يحدد المعلومات الضرورية لجزء واحد single part . تقوم الشركة بعمل عدة أنواع من القطع ، وبالتالي فإن رقم طراز القطعة modelnumber هو العضو الأول first member في الهيكل. ورقم الجزء نفسه partnumber هو العضو التالي next member ، والعضو النهائي final member هو تكلفة cost الجزء.

البرنامج PARTS
• يعرف الهيكل structure part ،
• ويعرف متغير الهيكل structure variable من هذا النوع يسمى part1 ،
• ويعين (يخصص) القيم لأعضائه ،
• ثم يعرض هذه القيم.

الكود:
// parts.cpp // uses parts inventory to demonstrate structures #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct part    //1- declare a structure { int modelnumber; //ID number of widget int partnumber; //ID number of widget part float cost;    //cost of part }; //////////////////////////////////////////////////////////////// int main() { part part1; //2- define a structure variable part1.modelnumber = 6244;    //3- give values to structure members part1.partnumber = 373; part1.cost = 217.55F; //4- display structure members cout << “Model “ << part1.modelnumber; cout << “, part “ << part1.partnumber; cout << “, costs $” << part1.cost << endl; return 0; }

خرج البرنامج يبدو كما يلي:

الكود:
Model 6244, part 373, costs $217.55

يحتوي برنامج PARTS على ثلاثة جوانب رئيسية : تعريف defining الهيكل وتعريف متغير الهيكل والوصول إلى أعضاء الهيكل. دعونا ننظر إلى كل من هذه الجوانب .

1- تعريف الهيكل Defining the Structure
يوضح تعريف الهيكل structure كيفية تنظيم الهيكل structure : فهو يعرف الأعضاء members الذين سيكونون لدى الهيكل . ها هو التعريف :

الكود:
struct part { int modelnumber; int partnumber; float cost; };

• بناء جملة تعريف الهيكل Syntax of the Structure Definition
فى البداية تتقدم الكلمة المفتاحية struct تعريف الهيكل structure . بعدها يأتي اسم الهيكل أو الوسم tag ، وهو هنا part . ثم يتم تضمين الإعلانات الخاصة بأعضاء الهيكل - modelnumber رقم الطراز و partnumber رقم الجزء و cost التكلفة - في أقواس {} . يتبع قوس الإغلاق فاصلة منقوطة ; ، كعلامة على إنهاء الهيكل بأكمله. لاحظ أن هذا الاستخدام للفاصلة المنقوطة للهيكل لا يشبه الاستخدام لكتلة من الكود . كما رأينا ، يتم أيضًا تعيين كتل الكود ، والتي يتم استخدامها في الحلقات والقرارات والدوال ، بواسطة الأقواس {} . ومع ذلك ، لا يستخدمون فاصلة منقوطة بعد قوس النهائية. يوضح الشكل 4-1 بناء جملة إعلان الهيكل.

الشكل 4-1 بناء جملة تعريف الهيكل Syntax of the structure definition.
.
• استخدام تعريف الهيكل Use of the Structure Definition
يساعد تعريف الهيكل فقط كمخطط blueprint (النسخة الأصلية) لإنشاء متغيرات نوع part (نسخ من الهيكل) . لا يقوم التعريف بنفسه بإنشاء أي متغيرات هيكل ؛ أي أنه لا يقوم بتخصيص أي مساحة في الذاكرة أو حتى تسمية أي متغيرات. هذا على خلاف تعريف المتغير البسيط ، الذي بخصص ذاكرة (يحجزها). تعريف الهيكل هو مجرد مواصفات specification لكيفية ظهور متغيرات الهيكل عندما يتم تعريفها. هذا مبين في الشكل 4-2 .

الشكل 4-2 الهياكل والمتغيرات الهيكلية Structures and structure variables

2- تعريف متغير الهيكل Defining a Structure Variable

العبارة الأولى في الدالة main()

الكود:
part part1;

تعرّف متغير ، يسمى part1 ، من نوع الهيكل part . هذا التعريف يحجز مساحة في الذاكرة من أجل part1. كم المساحة؟ مساحة تكفي أن تحفظ جميع أعضاء part1 - أي رقم الطراز modelnumber ، ورقم الجزء partnumber ، والتكلفة cost . في هذه الحالة ، سيكون هناك 4 بايت لكل من العدد الصحيح int (بافتراض نظام 32 بت) ، و 4 بايت من أجل float . يوضح الشكل 4-3 كيف يبدو part1 في الذاكرة. (يوضح الشكل أعداد صحيحة 2 بايت.)

الشكل 4-3 أعضاء الهيكل في الذاكرة Structure members in memory

يمكننا التفكير في الهيكل part كمواصفات specification لنوع بيانات جديد. سيصبح هذا أكثر وضوحًا مع تقدمنا ، لكن لاحظ أن التنسيق الخاص بتعريف متغير الهيكل هو نفسه بالنسبة لتعريف نوع بيانات مضمن أساسي مثل int:

الكود:
part part1; int var1;

هذا التشابه ليس عرضي . أحد أهداف C++ هو جعل بناء الجملة وتشغيل أنواع البيانات المعرفة من قبل المستخدم مماثلة قدر الإمكان لتلك الخاصة بأنواع البيانات المضمنة. (في C ، تحتاج إلى تضمين الكلمة المفتاحية struct في تعريفات الهيكل ، كما هو الحال في struct part part1; . في C++ ، الكلمة المفتاحية ليست ضرورية.)

3- الوصول إلى أعضاء الهيكل Accessing Structure Members
بمجرد تعريف متغير الهيكل ، يمكن الوصول إلى أعضائه باستخدام شيء يسمى عامل النقطة dot operator . إليك كيفية إعطاء العضو الأول قيمة :

الكود:
part1.modelnumber = 6244;

تتم كتابة عضو الهيكل في ثلاثة أجزاء : اسم متغير الهيكل (part1) ؛ وعامل النقطة dot operator ، الذي يتكون من period (.) ؛ واسم العضو (modelnumber). هذا يعني "العضو modelnumber في part1 ." الاسم الحقيقي لعامل النقطة هو عامل الوصول للعضو member access operator ، ولكن بالطبع لا أحد يريد استخدام مثل هذا المصطلح الطويل.

تذكر أن المكون الأول من تعبير يتضمن عامل النقطة هو اسم متغير الهيكل المحدد (part1 في هذه الحالة) ، وليس اسم تعريف البنية (part). يجب استخدام اسم المتغير لتمييز أحد المتغيرات عن الآخر ، مثل part1 و part2 وما إلى ذلك ، كما هو موضح في الشكل 4.4.

الشكل 4-4 عامل النقطة The dot operator

يتم التعامل مع أعضاء الهيكل تمامًا مثل المتغيرات الأخرى. في العبارة part1.modelnumber = 6244; ، يتم إعطاء العضو القيمة 6244 باستخدام عامل التعيين العادي . يعرض البرنامج أيضًا الأعضاء المستخدمة في عبارات cout مثل

الكود:
cout << “\nModel “ << part1.modelnumber;

هذه العبارات تخرج قيم أعضاء الهيكل.

ميزات Structure الأخرى Other Structure Features
الهياكل متعددة الاستخدامات بشكل مدهش . دعنا نلقي نظرة على بعض الميزات الإضافية لبناء الجملة والاستخدام.

تهيئة أعضاء الهيكل Initializing Structure Members
يوضح المثال التالي كيف يمكن تهيئة أعضاء الهيكل عندما يتم تعريف متغير الهيكل. إنه يوضح أيضًا أنه يمكن أن يكون لديك أكثر من متغير من نوع هيكل معين.
إليك قائمة PARTINIT:

الكود:
// partinit.cpp // shows initialization of structure variables #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct part    //specify a structure { int modelnumber; //ID number of widget int partnumber; //ID number of widget part float cost;    //cost of part }; //////////////////////////////////////////////////////////////// int main() { //initialize variable part part1 = { 6244, 373, 217.55F }; part part2; //define variable //display first variable cout << “Model “ << part1.modelnumber; cout << “, part “ << part1.partnumber; cout << “, costs $” << part1.cost << endl; part2 = part1; //assign first variable to second //display second variable cout << “Model “ << part2.modelnumber; cout << “, part “ << part2.partnumber; cout << “, costs $” << part2.cost << endl; return 0; }

يعرف هذا البرنامج متغيرين من نوع part : part1 و part2. يقوم بتهيئة part1 ، ويطبع قيم أعضائه ، ويعين part1 إلى part2 ، ويطبع أعضاءه.
فيما يلى الخرج :

الكود:
Model 6244, part 373, costs $217.55 Model 6244, part 373, costs $217.55

ليس من المستغرب أن تتكرر نفس الناتج لأن متغيرًا يساوي الآخر.
تتم تهيئة أعضاء المتغير part1 من الهيكل عندما يتم تعريف المتغير:

الكود:
part part1 = { 6244, 373, 217.55 };

القيم التي يتم تعيينها لأعضاء الهيكل محاطة بأقواس {}ومفصولة بفواصل ( , ) . يتم تعيين القيمة الأولى في القائمة للعضو الأول ، والثانية للعضو الثاني ، وهكذا.

متغيرات الهيكل في عبارات التعيين Structure Variables in Assignment Statements

كما يمكن رؤيته في PARTINIT ، يمكن تعيين متغير هيكل إلى آخر:

الكود:
part2 = part1;

يتم تعيين قيمة كل عضو في part1 للعضو المقابل في part2 . نظرًا لأن الهيكل الكبير يمكن أن يضم العشرات من الأعضاء ، فإن عبارة التعيين هذه قد يتطلب من الكمبيوتر القيام بقدر كبير من العمل.
لاحظ أنه يمكن تعيين متغير بهيكل إلى آخر فقط عندما يكونون من نفس نوع الهيكل. إذا حاولت تعيين متغير من نوع هيكل إلى متغير من نوع هيكل آخر ، فسوف يشتكي المترجم.

مثال القياس A Measurement Example
دعونا نرى كيف يمكن استخدام هيكل structure لتجميع نوع مختلف من المعلومات. إذا نظرت إلى أي رسم معماري ، فأنت تعلم أنه (على الأقل في الولايات المتحدة) تقاس المسافات بالأقدام والبوصات. (كما تعلمون ، هناك 12 بوصة في القدم). قد يتم تحديد طول غرفة المعيشة ، على سبيل المثال ، 15’–8” ، وهذا يعني 15 قدمًا و 8 بوصات. الواصلة ليست علامة السالب ؛ إنها تفصل الأقدام عن البوصات. هذا جزء من نظام القياس الإنجليزى . يوضح الشكل 4.5 قياسات الطول المعتادة في النظام الإنجليزى .

الشكل 4-5 القياسات فى النظام الإنجليزى Measurements in the English system

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

الكود:
// englstrc.cpp // demonstrates structures using English measurements #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct Distance //English distance { int feet; float inches; }; //////////////////////////////////////////////////////////////// int main() { Distance d1, d3;          //define two lengths Distance d2 = { 11, 6.25 };       //define & initialize one length //get length d1 from user cout << “\nEnter feet: “; cin >> d1.feet; cout << “Enter inches: “; cin >> d1.inches; //add lengths d1 and d2 to get d3 d3.inches = d1.inches + d2.inches;    //add the inches d3.feet = 0;             //(for possible carry) if(d3.inches >= 12.0)          //if total exceeds 12.0, { //then decrease inches by 12.0 d3.inches -= 12.0; //and d3.feet++; //increase feet by 1 } d3.feet += d1.feet + d2.feet; //add the feet //display all lengths cout << d1.feet << “\’-” << d1.inches << “\” + “; cout << d2.feet << “\’-” << d2.inches << “\” = “; cout << d3.feet << “\’-” << d3.inches << “\”\n”; return 0; }

هنا الهيكل Distance لديه عضوين : feet و inches . قد يكون للمتغير inches جزءًا كسريًا ، لذلك سنستخدم النوع float له. المتغير feet هو دائمًا أعداد صحيحة ، لذلك سنستخدم النوع int له.

نعرف بعدين من هذه المسافات ، d1 و d3 ، دون تهيئتهما ، بينما نهيئ مسافة أخرى ، d2 ، إلى 11'–6.25'' . يطلب البرنامج من المستخدم إدخال مسافة بالقدم والبوصة ، ويقوم بتعيين هذه المسافة إلى d1. (يجب أن تكون قيمة البوصات أصغر من 12.0.) ثم تضيف المسافة d1 إلى d2 ، للحصول على المسافة الإجمالية d3. أخيرًا ، يعرض البرنامج المسافات الأولية والمسافة الإجمالية المحسوبة حديثًا. إليك بعض الإخراج:

الكود:
Enter feet: 10 Enter inches: 6.75 10’-6.75” + 11’-6.25” = 22’-1”

لاحظ أنه لا يمكننا إضافة مسافتين بعبارة برنامج مثل

الكود:
d3 = d1 + d2; // can’t do this in ENGLSTRC

لما لا ؟ لأنه لا يوجد روتين مضمّن في C++ يعرف كيفية إضافة متغيرات من نوع Distance . يعمل العامل + مع أنواع مدمجة مثل float ، ولكن ليس مع أنواع نعرّفها بأنفسنا ، مثل Distance.

الهياكل داخل الهياكل Structures Within Structures
يمكنك تداخل الهياكل داخل الهياكل الأخرى. إليك صيغة مختلفة في برنامج ENGLSTRC توضح كيف يبدو ذلك. في هذا البرنامج ، نريد إنشاء هيكل بيانات تخزن أبعاد غرفة نموذجية : طولها وعرضها. نظرًا لأننا نعمل مع مسافات إنجليزية ، فسوف نستخدم متغيرين من نوع Distance وهما المتغيرين length و width .

الكود:
struct Room { Distance length; Distance width; };

إليك برنامج ، ENGLAREA ، يستخدم الهيكل Room لتمثيل الغرفة.

الكود:
// englarea.cpp // demonstrates nested structures #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct Distance //English distance { int feet; float inches; }; //////////////////////////////////////////////////////////////// struct Room //rectangular area { Distance length; //length of rectangle Distance width; //width of rectangle }; //////////////////////////////////////////////////////////////// int main() { Room dining;             //define a room dining.length.feet = 13;       //assign values to room dining.length.inches = 6.5; dining.width.feet = 10; dining.width.inches = 0.0; //convert length & width float l = dining.length.feet + dining.length.inches/12; float w = dining.width.feet + dining.width.inches/12; //find area and display it cout << “Dining room area is “ << l * w << “ square feet\n” ; return 0; }

يعرف هذا البرنامج متغير واحد - dining - من النوع Room ، في السطر

الكود:
Room dining; // variable dining of type Room

ثم يعين القيم لمختلف أعضاء هذا الهيكل.

الوصول إلى أعضاء هيكل متداخل Accessing Nested Structure Members
نظرًا لأن هناك هيكل متداخل داخل آخر ، يجب علينا تطبيق عامل النقطة مرتين للوصول إلى أعضاء الهيكل.

الكود:
dining.length.feet = 13;

في هذه العبارة ، dining هو اسم متغير الهيكل ، كما كان من قبل ؛ و length هو اسم العضو في الهيكل الخارجي (Room) ؛ و feet هو اسم عضو في الهيكل الداخلي (Distance). تعني العبارة "خذ العضو feet من العضو length للمتغير dining وخصص له القيمة 13." يوضح الشكل 4.6 كيف يعمل هذا.

الشكل 4-6 عامل النقطة والهياكل المتداخلة Dot operator and nested structures

بمجرد تخصيص القيم لأعضاء dining ، يقوم البرنامج بحساب مساحة أرضية الغرفة ، كما هو موضح في الشكل 4-7 .
لإيجاد المساحة ، يقوم البرنامج بتحويل الطول والعرض من متغيرات من نوع Distance إلى متغيرات من نوع float و l و w ، تمثل المسافات بالأقدام. يتم إيجاد قيم l و w عن طريق جمع العضو feet في Distance إلى العضو inches مقسومًا على 12. يتم تحويل العضو feet إلى نوع float تلقائيًا قبل تنفيذ الجمع ، وتكون النتيجة نوع float . ثم يتم ضرب المتغيرات l و w معًا للحصول على المساحة area .

الشكل 4-7 المساحة بالأقدام والبوصات Area in feet and inches

تحويلات نوع المعرف من قبل المستخدم User-Defined Type Conversions
لاحظ أن البرنامج يحول مسافتين من النوع Distanceإلى مسافتين من النوع float : المتغيرات l و w. في الواقع ، تقوم أيضًا بتحويل مساحة الغرفة ، التي يتم تخزينها على أنها هيكل من النوع Room (والتي يتم تعريفها على أنها هيكلين من نوع Distance ) ، إلى عدد floating-point واحد يمثل المساحة بالأقدام المربعة. إليك الإخراج:

الكود:
Dining room area is 135.416672 square feet

يعد تحويل قيمة نوع ما إلى قيمة نوع آخر جانبًا مهمًا في البرامج التي تستخدم أنواع البيانات المعرفة من قبل المستخدم .

تهيئة الهياكل المتداخلة Initializing Nested Structures
كيف يمكنك تهيئة متغير هيكل يحتوي في حد ذاته على هياكل ؟ العبارة التالية تهىء المتغير dining إلى نفس القيم المعطاة في برنامج ENGLAREA :

الكود:
Room dining = { {13, 6.5}, {10, 0.0} };

يتم تهيئة كل هيكل من نوع Distance ، المضمن في Room ، بشكل منفصل.
تذكر أن هذا ينطوي على تطويق القيم بالأقواس وفصلها بفواصل. تتم تهيئة Distance الأولى إلى :

الكود:
{13, 6.5}

والثانية إلى :

الكود:
{10, 0.0}

ثم يتم استخدام قيمتي المسافة هذه لتهيئة المتغير Room ؛ مرة أخرى ، فهي محاطة بالأقواس ومفصولة بفواصل.

عمق التداخل Depth of Nesting
من الناحية النظرية ، يمكن تداخل الهياكل إلى أي عمق. في برنامج يصمم المباني السكنية ، قد تجد نفسك مع عبارات مثل هذا:

الكود:
apartment1.laundry_room.washing_machine.width.feet

أسئلة :
س1 : الهيكل structure يجمع مجموعة من
ا. عناصر من نفس نوع البيانات.
ب. عناصر البيانات ذات الصلة.
ج. أعداد صحيحة مع أسماء المعرفة من قبل المستخدم.
د. المتغيرات.

ج1 : ب و د

س2 : صواب أو خطأ : الهيكل structure والفئة class تسنخدم بناء جملة مماثل.

ج2 : صواب

س3 : يتبع قوس إغلاق الهيكل ....

ج2 : فاصلة منقوطة semicolon (

س4 : اكتب مواصفات هيكل تتضمن ثلاثة متغيرات - جميعها من النوع int – تسمى hrs و mins و secs . وسمى هذا الهيكل time .

ج4 :

الكود:
struct time { int hrs; int mins; int secs; };

س5 : صواب أو خطأ: تعريف الهيكل يخلق مساحة في الذاكرة لمتغير.

ج5 : خطأ ، فقط تعريف متغير يخلق مساحة في الذاكرة .

س6 : عند الوصول إلى عضو هيكل ، يكون المعرف الموجود على يسار عامل النقطة هو اسم
ا. عضو الهيكل structure member .
ب. علامة هيكل structure tag .
ج. متغير هيكل structure variable .
د. الكلمة المفتاحية keyword struct .

ج6 : ج
س7 : اكتب عبارة تعيّن العضو hrs لمتغير الهيكل time2 ليساوي 11

ج7 :

الكود:
time2.hrs = 11;

س8 : إذا كان لديك ثلاثة متغيرات تم تعريفها على أنها من نوع الهيكل time ، وكان هذا الهيكل يحتوي على ثلاثة أعضاء int ، كم عدد بايتات الذاكرة التي تستخدمها المتغيرات معًا؟

ج8 : 18 بايت في أنظمة 16 بت (3 هياكل فى 3 أعداد صحيحة فى 2 بايت) أو 36 في أنظمة 32 بت .

س9 : اكتب تعريفًا يهيئ أعضاء time1 - وهو متغير من نوع struct time ، كما هو محدد في السؤال 4 – إلى hrs = 11 و mins = 10 و secs = 59 .

ج9 :

الكود:
time time1 = { 11, 10, 59 };

س10 : صواب أو خطأ: يمكنك تعيين متغير هيكل لآخر ، بشرط أن يكون من نفس النوع .

ج10 صواب .

تمارين :
التمرين رقم 1 :
يمكن اعتبار أن رقم الهاتف ، مثل (212) 767-8900 ، يحتوي على ثلاثة أجزاء : كود المنطقة (212) area code ، والسنترال (767) ، والرقم (8900). اكتب برنامجًا يستخدم هيكلًا لتخزين هذه الأجزاء الثلاثة من رقم الهاتف بشكل منفصل. سمى الهيكل phone . قم بإنشاء متغيرين هيكل اثنين من نوع phone . قم بتهيئة واحد ، واطلب من المستخدم إدخال رقم للآخر. ثم أعرض كلا الرقمين. قد يبدو التفاعل كما يلي:

الكود:
Enter your area code, exchange, and number: 415 555 1212 My number is (212) 767-8900 Your number is (415) 555-1212

الحل :

الكود:
// ex4_1.cpp // uses structure to store phone number #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct phone { int area;    //area code (3 digits) int exchange;    //exchange (3 digits) int number;    //number (4 digits) }; //////////////////////////////////////////////////////////////// int main() { phone ph1 = { 212, 767, 8900 }; //initialize phone number phone ph2;          //define phone number // get phone no from user cout << “\nEnter your area code, exchange, and number”; cout << “\n(Don’t use leading zeros): “; cin >> ph2.area >> ph2.exchange >> ph2.number; cout << “\nMy number is “    //display numbers << ‘(‘ << ph1.area << “) “ << ph1.exchange << ‘-’ << ph1.number; cout << “\nYour number is “ << ‘(‘ << ph2.area << “) “ << ph2.exchange << ‘-’ << ph2.number << endl; return 0; }

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

الكود:
Enter coordinates for p1: 3 4 Enter coordinates for p2: 5 7 Coordinates of p1+p2 are: 8, 11

الحل :

الكود:
// ex4_2.cpp // structure models point on the plane #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct point { int xCo; //X coordinate int yCo; //Y coordinate }; //////////////////////////////////////////////////////////////// int main() { point p1, p2, p3;          //define 3 points cout << “\nEnter coordinates for p1: “; //get 2 points cin >> p1.xCo >> p1.yCo;       //from user cout << “Enter coordinates for p2: “; cin >> p2.xCo >> p2.yCo; p3.xCo = p1.xCo + p2.xCo;       //find sum of p3.yCo = p1.yCo + p2.yCo;       //p1 and p2 cout << “Coordinates of p1+p2 are: “ //display the sum << p3.xCo << “, “ << p3.yCo << endl; return 0; }

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

الحل :

الكود:
// ex4_3.cpp // uses structure to model volume of room #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// struct Distance { int feet; float inches; }; //////////////////////////////////////////////////////////////// struct Volume { Distance length; Distance width; Distance height; }; //////////////////////////////////////////////////////////////// int main() { float l, w, h; Volume room1 = { { 16, 3.5 }, { 12, 6.25 }, { 8, 1.75 } }; l = room1.length.feet + room1.length.inches/12.0; w = room1.width.feet + room1.width.inches /12.0; h = room1.height.feet + room1.height.inches/12.0; cout << “Volume = “ << l*w*h << “ cubic feet\n”; return 0; }