SP_21_Lecture_8-_Pointers_part1
السلام عليكم، ازيكو يا سنة أولى. المحاضرة النهاردة إن شاء الله عن الـ Pointers، الـ Pointers مهمة جدًا جدًا، لازم تتأسسوا فيها كويس حتى وإن ما استخدمناهاش بشكل كبير في الترم ده في مادة الـ SP، لكن هتحتاجوها إن شاء الله في السنين اللي جاية، بالذات في مواد زي الـ Data Structure، زي الـ Object-Oriented.
فنحاولوا تتمرنوا كويس على الـ Knowledge اللي هناخدها النهاردة لأنكم هتستخدموها كتير مستقبلاً إن شاء الله نبتدي المحاضرة بكود بسيطة كده بتقول إن أي حد يقدر يكتب كود يكتب program يـrun على الـcomputer ده ما فيهوش مشكلة لكن مش أي حد يقدر يكتب كود زمايله يفهموه الناس اللي حواليه تفهمه
فحاولوا دايماً تلتزموا بقواعد الـ Clean Code زي مثلاً إيه زي أنكم تعملوا Indentation تلتزموا إيه بشكل منظم كده للبرنامج تعملوا Variables اسمها واضح تعملوا White Spaces ما يبقاش كل حاجة مزنقة ببعضها كل الحاجات دي كنا منزلينلكم Presentation صغيرة عليها كده self study تقروها في أول الترم على الـ Drive وانتو مش واخدين بالكم
طيب نبتدي بقى الكلام عن الـ Pointers، يعني إيه Pointer؟ الـ Pointer عبارة عن سهم بيشاور على حاجة جوه الـ Memory، بيشاور على Variable تاني موجود جوه الـ RAM. طيب أي Variable في الـ Memory بيبقى متميز بإيه؟ متميز بالـ Address بتاعه، مكانه في الـ Memory. إذًا الـ Pointer عبارة عن الـ Memory Address بتاع Variable تاني موجود جوه الـ Memory
طيب عندنا حاجة اسمها Pointer Variable ده Variable زي أي Variable تاني بس القيمة اللي جواه هي الـ Pointer Value اللي احنا اتكلمنا عليها دي. يعني الـ Pointer Variable هيبقى شايل جواه الـ Memory Address بتاع أي Variable تاني موجود جوه الـ Memory. إيه فايدة إن احنا نعمل Pointers وإيه Pointer Variable هنعرف أهميتها بعدين، بس الفكرة إن احنا نقدر نعمل Access لـ Variable تاني من خلال الـ Pointer، نقدر نوصل للقيمة اللي جواه من خلال الـ Pointer مش من خلال اسم الـ Variable.
طيب هل الـ Pointer Variables دي ليها أنواع زي أي Variables تانية؟ آه، ممكن أعمل Pointer بيشاور على Integer، ممكن أعمل Pointer بيشاور على Character، على Float، على أي حاجة أنا عايزها.

طيب إزاي بقى نعمل Declaration للـ Pointer Variables؟ نحط في دماغنا الأول حاجتين مهمين جداً.

أول حاجة إن نوع الـ Pointer Variable مرتبط بنوع أو مرتبط بالـ Type بتاع الحاجة اللي هيشاور عليها، بتاع الـ Variable اللي هيشاور عليه.
لو أنا هشاور على variable من نوع integer يبقى الـ pointer بيبقى integer pointer النوع character بيبقى character pointer وهكذا وتاني حاجة إنه لازم نحط asterisk قبل variable name بتاعي طيب شكل الـ declaration ممكن يبقى عامل إزاي؟ نقول مثلاً
 int asterisk p
 يبقى أنا كده عرفت pointer هيشاور لسة بعد كده على حاجة من نوع integer
Okay أنا بقول لسه بعد كدة لأن أنا مديتوش الـ Address اللي هيشاور عليه، مديتوش القيمة اللي هي الـ Address بتاعه إيه اللي المفروض هيشاور عليه بعد كدة.

يبقى أنا كدة عملت إيه Pointer to that type. نخلي بالنا إن معظم أسامي الـ Pointers في المحاضرة النهاردة هنلاقيها أسامي معبرة عن الـ Pointer، P، PTR، Pointer، P1، P2، حاجات كلها إيه عشان نقدر نفرق ما بينها وبين الـ Variables العادية.
طيب دايما قبل ما نستخدم الـ pointer في الـ program بعد كده لازم نحط قبليه الـ asterisk دي هنـ لسه هناخد أمثلة كتير عليها تعالوا نشوف الأول مثال عالـ declaration أنا لو قلت مثلا int count equal 7 يبقى أنا هنا معرفة إيه variable عادي طب إيه قيمته سبعة من نوع integer قلت تحت هنا int asterisk p1 و asterisk p2 يبقى أنا عملت إيه
Two Pointers هيشاوروا على Variables بعد كدة من نوع Integer. أنا لسه مجهزاهم معملتلهومش Initialization. عندي هنا V1 و V2 دول Two Integers أو Variables عادية جداً؛ يبقى إذاً هنا ممكن أعمل Declaration في نفس السطر لأي عدد من الـ Pointers، أي عدد من الـ Variables، مفيش أي Restrictions. طيب إحنا اتفقنا إن الـ Pointers بتبقى Typed، يعني ليها أنواع، فممكن بردو بعد كدة في الـ Program أقول double *p؛ يبقى أنا عملت Pointer اسمه P هيشاور على Variable بعد كدة من نوع Double.
Okay، واضح الـ Declaration؟ طيب إحنا عموماً بنعبر عن الـ Pointers بـ Diagrams لطيفة أوي بتبقى Represented as an arrow، عبارة عن سهم. السهم ده طالع منين ورايح فين؟ بيبقى طالع من الـ Pointer Variable، تمام، اللي جواه الـ Address اللي المفروض هيشاور عليه، ورايح على الـ Variable اللي هو شايل الـ Address بتاعه جوه الـ Memory.
الـ var ده variable طبيعي جداً integer مثلاً قمته 5 والـ ptr بيشاور عليه شايل الـ address بتاعه طيب نخلي بالنا بقى من الجملتين دول مهمين جداً تعالوا نقراهم كده بالتفصيل بنقول a variable name directly references a value and a pointer indirectly references a value يعني إيه؟
أنا لو عندي Variable طبيعي زي Var ده، اسمه Var، أنا عايزة أ Access الـ Value اللي جواه فبقول مثلاً cout var؛ يبقى أنا كدة خلاص من خلال اسم الـ Identifier، اسم الـ Variable نفسه اللي هو Var ده، وصلت للقيمة اللي جواه على مرة واحدة، على خطوة واحدة بس، فكدة وصلتلها إيه Directly. لكن لو أنا استخدمت اسم الـ Pointer بتاعي في الـ cout مثلاً؛ يبقى أنا بوصل للخمسة دي، بوصل للـ Value دي على خطوتين، بطريقة غير مباشرة. إزاي؟ أول حاجة بشوف الـ Address اللي جوه الـ Pointer ده إيه.
وتاني خطوة بشوف الـ Address ده بيشاور على إيه وأروح جايبة إيه الـ Value اللي بيشاور عليها اللي هي الخمسة. يبقى خطوتين، الخطوة الأولى بـ Access الـ Address وبعد كدة الخطوة التانية من خلال الـ Address بـ Access الـ Value.

طيب نعرف كدة دايماً بعد أي حاجة بنشرحها هنشوف الـ Terminology أو الـ English statement اللي بتعبر عنها. حاولوا تربطوا دايماً الـ Code بالوصف بتاعه عشان في الامتحان ما تتلخبطوش ده بيعمل إيه.
يبقى احنا كده عندنا ايه؟ عندنا Pointer variable points to ordinary variable بيشاور على variable طبيعي من الvariable زي احنا ايه خدناها قبل كده. طيب احنا اتفقنا ان الpointer variable ده بيشيل جواه ايه؟ بيبقى ايه القيمة اللي جواها؟ address. 
address بتاعت variable تاني. طيب تعالوا شوف ازاي هنعمله intialization.
هل إحنا هنجيب الـ Address ده بنفسنا نقعد نحسبه بقى الـ Hexadecimal value بتاعته إيه؟ لا، هما عملولنا Operator لطيف جداً اللي هو الـ And، الـ And Operator أو الـ Ampersand، اسمه بالإنجليزي الـ Ampersand Operator.
 تعالوا نشوف بنستخدمه إزاي؛ هنا مثلاً بنقول int num = 4 معرقه Variable طبيعي من نوع Integer.
قلت هنا int *pointer؛ يبقى أنا مجهزة Pointer اسمه PTR هيشاور على حاجة من نوع Integer بعد كدة. طيب، إديته هنا بقى الـ Value بتاعته إيه؟ &num. 
&num الـ And operator بيجيب لي الـ Address بتاع أي Variable بعديه. يبقى أنا كدة جبت الـ Address بتاع num حطيته جوه الـ Pointer 
PTR. طيب ده معناه إيه؟ معناه خلاص إن PTR بقى Pointer بيشاور على الـ Variable num، هقدر أوصل للـ Value بتاعة num من خلال ايه؟.
الـ pointer هنعمل جملة cout بعد كدة بنقول cout num،
 cout PTR. الـ cout دي هتعمل إيه؟ num دي سهلة بتعرض الأربعة العادية جداً بتاعتي. 
cout PTR، إيه ده هو أنا ينفع أعرض القيمة بتاعة الـ Pointer Variable؟ آه عادي جداً، هو Variable زي أي Variable تاني بتعامل معاه عادي، بس هيعرض لي إيه بقى؟ الـ Address بتاع مين؟
الـ Address ده بتاع مين؟ بتاع num اللي هو إيه بيشاور عليه. يبقى زي ما اتفقنا تاني، 
قيمة الـ Pointer هي الـ Address بتاع الـ Variable التاني. نقرأ الكلام ده إزاي بالـ English؟ الـ Terminologies بتاعتنا: 
Pointer PTR equals Address of num، 
أو PTR points to num. طيب تعالوا نشوف إيه Animated example لطيف أوي.
عندنا هنا دي الـ Memory بتاعتنا متقسمة Locations، كل Location ليه الـ Address بتاعه. طبعاً الـ Addresses بتبقى Hexadecimal value معقدة، إحنا عاملنها هنا إيه 1000، 1001 كدة للتبسيط. الجملة دي، لو قلنا هنا int num = 4؛ المفروض أول ما ننفذها، الـ num ده هيحجز كام Location في الـ Memory؟
أربعة، إحنا اتفقنا الـ Integer العادي اللي بنتعامل معاه 4 bytes. تعالوا نشوف كدة، أهو؛ يبقى أنا عندي هنا الـ num variable حجز أربع أماكن ورا بعض جوه الـ Memory من الف لحد الف وتلاتة. طيب بصوا بقى السطر اللي بعده بنقول إيه
int * ptr يبقى هنا بعرف Pointer هيشاور على حاجة Integer وإديته الـ Address بتاع num، إديته الـ Value &num.
طيب احنا اتفقنا الـPointer variable هو variable عادي إذًا ليه مكان جوه الـmemory هو نفسه عبارة عن variable تعالوا نشوف هيتنفذ ازاي
 الـPtr Pointerبقى موجود في مكان تاني من الـmemory أنا ما يهمنيش هو فين في مكان ما القيمة اللي جوه هي الالف اللي هي الـbeginning address بتاعت ايه الـVariable number
تمام، فكدة كأنه إيه بيشاور عليه. طيب أنا هنا لو قلت cout num و cout PTR هيعرضلي إيه؟ الـ num هنا هيعرض إيه؟ هيعرض أربعة، القيمة بتاعته. طيب cout PTR؟ هيعرض الف، اللي هو الـ Address بتاع num. طيب في هنا سؤال مش عليكم أوي في المنهج بس أنا أحب أعرفكم عشان تبقوا فاهمين اللي بيحصل.
What is the size of a pointer variable؟
 إحنا هنا pointer variable حطيناه كأنه في بايت واحد لأ هو مش في بايت واحد، هو ليه size بس إحنا ما هيمناش أنتوا تعرفوه دلوقتي إحنا مجازًا حطيناه إيه في مكان واحد 
اومال الـ size إيه بتاع الـ pointer variable؟ الـ pointer variable عموماً هي عبارة عن address الـ address الحجم بتاعه متوقف على الـ system أو الـ platform اللي إنت شغال عليه
أنت شغال 32-bit يبقى الـ Address هيبقى 32-bit أو 4 bytes، شغال 64-bit يبقى الـ Address بتاعك هيبقى 64-bit أو 8 bytes وهكذا. Okay وكل الـ Pointers
 the same، هي آه بتشاور على حاجات مختلفة الـ Size بتاعها مختلف بس الـ Pointers كلها عبارة عن Addresses. تمام؟ فالموضوع ده هتاخدوه بالتفصيل في المواد اللي بتهتم بالـ Hardware أكتر بعد كدة، معرفش هتاخدوا Assembly ولا لأ، الـ Architecture الكلام ده.
عايزين تعرفوا معلومات أكتر دلوقتي Google it، بس مش داخلة في الامتحان إن شاء الله. طيب إحنا كل ده بنكلم عن الـ Pointer إنه هيشاور على Variable، يعني إيه بقى يشاور على Variable؟ إن إحنا Access الـ Value بتاعت الحاجة اللي بيشاور عليها دي، هنا هنعرف إزاي. عندنا هنا Program بنقول إيه int *p1, *p2 عرفنا Two Pointers.
وبعد كدة إيه v1 و v2، دول two integer variables عاديين جداً. قلنا p1 بيساوي v1&، بيساوي الـ address بتاع v1. تعالوا نرسمها، دايماً نرسم الـ diagram بتاع الـ arrow اللي اتفقنا عليه. أنا عندي هنا إيه p1 وعندي هنا p2 وعندي هنا v1.
و v2. قلنا p1 بيساوي &v1، يبقى p1 هيبقى جواه Address بيشاور على إيه؟ v1 بالشكل ده بقى بيشاور عليه. طيب قلنا بعد كدة v1 بيساوي سبعة. يبقى أنا كدة غيرت قيمة الـ v1 بس من خلال اسمه هو نفسه، من خلال الـ Variable الطبيعي بتاعه، يبقى هيبقى هنا جواه إيه؟ سبعة.
Okay، يبقى دلوقتي أنا أقدر أوصل للسبعة دي من خلال الـ v1 نفسه أو من خلال الـ Pointer اللي بيشاور عليه. طيب تعالوا نشوف إزاي. هنا أول واحدة بنقول إيه cout v1، 
اعرض لي الـ v1 خلاص وصلنا للسبعة من خلال الـ Identifier بتاعها. بصوا التانية بقى دي المهمة بالنسبة لنا cout * p1.
يبقى هنا كدة وصلت لإيه، وصلت للـ Value بتاعة الـ Variable اللي بيشاور عليه p1.
 نخلي بالنا في فرق هنا Note، 
this is not a declaration، في هنا تشابه في الشكل ما بين *p1 دي وما بين *p1 دي؛ الأولانية دي كانت إيه؟ Declaration، أنا هنا بعرف الـ Pointer،
 زي كدة الـ Array علامته المميزة الـ Square brackets، 
الـ Pointer علامته المميزة الـ Asterisk.
فهنا في الـ declaration هبقى عندي ال asterisk دي متعبر لأن انا بعرف pointer من نوع integer لكن هنا معناها ايه الـ asterisk هنا هتبقى dereference operator يعني ايه dereference operator بيخلي بدل ما يـ access القيمة اللي جواها اللي هي  الـ address لأ يروح بالـ address ده بيغير اتجاهه ويروح ايه على ال variable بيشاور عليه يجيب قيمته.
يبقى احنا هنقولكم كدة جملة اسطمبة هنكررها كتير جداً النهاردة،
* مثلا p1 يعني هات الـ Value بتاعة الـ Variable اللي بيشاور عليه p1.
okay، هنقولها كتير النهاردة فإيه هتحفظوها، هزهقكم بيها. طيب، يبقى يعني إيه
 De-reference مكتوبة تحت أهي بالـ English؛ يعني Get data that pointer points to. نشوف Animated example.
الحاجات دي بتفهمنا أكتر، عندنا هنا int *p1, *p2 و v1 و v2 نفس إيه القصة بتاعت المرة اللي فاتت. إحنا هنا عرفناهم لسه معملنلهومش Initialization مفيش جواهم حاجة؛ فـ p1 و p2 لسه مش عارفين بيشاوروا على إيه، والـ v1 والـ v2 بردو إيه لسه Uninitialized. طيب، هنيجي بعد كدة نقول v1 بتساوي zero.
اهو يبقى غيرنا قيمة الـ V1 من خلال اسمه عادي بالطريقة العادية بتاعتنا طيب بصوا بقى في الخطوة اللي بعدها اللي هي P1 بيساوي &v1 اللي هيحصل؟ اهو P1 غير اتجاهه بقى بيشاور فين على الـ V1 بتاعي يبقى نقدر اغير القيمة دي من خلال ايه؟
الـ V1 نفسه أو الـ P1 الـ pointer اللي بيشاور عليه طيب بصوا بقى السطر الجاي بنقول * P1 بيساوي 42 هنا استخدمت الـ dereference operator عملت dereference لـ P1 يعني كأني بقول له ايه خليلي value بتاعت ال variable اللي بيشاور عليه P1 بتساوي 42 يبقى أنا غيرت قيمة مين؟
الـ V1 لأنه هو ييشاور على V1 طيب تتخيلوا بعد كده لو قلنا Cout V1 و Cout *  P1 هيعرض لي إيه في الجملتين دول الاتنين هيعرضوا 42 لأن الاتنين بيشاوروا على نفس الحاجة بيشاوروا على نفس الـ value تمام أهي يبقى الـ output هنا هيبقى 42 للـ Vو  42 * P1 خلاص اتفقنا ان الاتنين V1 هنا والP1 بيشاور برضو على هنا على نفس المكان
يبقى p1 و v1 refer to the same variable now.
طيب مين يقولي الفرق ما بين الجملتين دول أو بمعنى أدق الفرق ما بين الـ * هنا والـ *هنا؟ ده هنا Declaration تمام بعرف الـ Pointer، اللي تحت هنا De-referencing
 أنا إيه بجيب الـ Value بتاعة الـ Variable اللي بيشاور عليه الـ Pointer 
P. طيب هل لو حطيتهم كدة في وضعهم زي ما هما بترتيبهم ده ونفذتهم هتتنفذ؟
 هيطلعلي حاجة ولا هيطلع Error؟"
بالظبط برافو عليكي 
يبقى هنا هيطلع لي Error. ليه بقى؟ لأن دلوقتي أنا بقوله * P
هات لي الـ Value بتاعة الـ Variable اللي أنت بتشاور عليه، طب هو مش بيشاور على حاجة، أنا لسه معملتوش Initialization، مديتوش Address، مقلتش بيساوي مثلاً & أي حاجة. وبالتالي هو بيقولي هنا بصوا الـ Error مكتوب بخط صغير أوي:
 The variable P is being used without being initialized.
 أنت عايز تخليني أعرض حاجة وأنا أصلاً معنديش حاجة إيه أعرضها.
تمام؟ طيب نلخص بقى كل الـ slides اللي فاتت في مثال بسيط كده هنا مثلا عرفنا 
variable i بيساوي 17 بنقول هنا ايه؟ هنعمل pointer اسمه ptr بالنوع integer هيشاور بعد كده لسه على حاجة من نوع integer قلنا هنا ptr الـ pointer بتاعنا بيساوي الـ address بتاع الـ variable i يبقى بيشاور عليه
جيت أعمل cout *ptr،
 عملت de-reference لـ ptr فعرضت الـ value بتاعة الـ variable اللي ptr بيشاور عليه يبقى هيعرض إيه؟ قيمة الـ i اللي بيشاور عليها اللي هي ايه 17.
تمام؟ 
طيب نتمرن بقى شوية مع بعض؛ هنا عرفت إيه variable v طبيعي جداً، variable w بردو طبيعي جداً من نوع integer.
عملت * P يبقى عرفت Pointer هيشاور على حاجة من نوع Integer. تعالوا نرسمهم عشان إيه نتابع مع بعض، نعمل Tracing. الرسم هيسهل عليكم جداً في الامتحان يا جماعة. ممكن تمسحوه بأستيكة وتغيروا فيه كل شوية أو تعملوا كذا إيه رسمة ورا بعض. يبقى عندي كدة إيه Pointer و Two Variables.
قلت هنا P بيساوي &v يبقى هنا عملت إيه؟ خليت P يشاور على V خليت هنا حطيت
 الـ address بتاع V جوا P هنا فبقى إيه؟ هيشاور عليه بالشكل ده طيب قلت V بيساوي 3 يبقى الـ V هنا تقييم عادية جداً كانت جملة assignment عادية جداً مفيهاش مشكلة
P* بتساوي 7. هنـ overwrite على مين؟ على الـ 3. دلوقتي الـ P عايز يحط value في
 الـ variable اللي بيشاور عليه، اللي هو مين؟ الـ v. فخلاص كدة هنشيل الـ 3، sorry، ونحط مكانها الـ 7.
طيب P بيساوي &w جديدة دي. هينفع الـpointer ان انا ادي له address جديد كل شوية خليه يشاور على حتة تانية اه مفيش مشكلة. هو كده هيسيب الـV لحاله. طالما الـV ده variable يبالطبيعي له اسم ممكن انا اتعامل معه بطريقة تانية خلاص. ممكن اسيبه واروح ايه اشاور على الـw.
مش عارفة الأستيكة بتختفي، أيوه، أهي؛ هيروح إيه مشاور هنا على إيه؟ على الـ w. طيب بنقول *p بيساوي 12، هيغير في مين بقى المرة دي؟ في الـ w، هيبقى عندي هنا جواها 12. فلو قالك في الآخر مثلاً cout الـ v و cout الـ w هيعرضلك إيه؟ 7 و 12.
Okay، فخلوا بالكم حاجة زي دي ممكن تيجي في الامتحان نخدعكم شوية نقعد نعمل إيه نغير من حتة لحتة، فلو عملت Tracing بعينيك ممكن الواحد يتلخبط فزي ما قلنا الرسم أضمن. (سؤال طالب: لو عملت *cout p؟) هيعرضلك 12، خلاص السبعة دلوقتي بقت مع الـ v بس أنا أقدر accessـها من اسمها بس.
Okay
الـ P Pointer بيشاور أو بيعرض الحاجة اللي إحنا بنخليه يشاور عليها بس؛ كان بيشاور على الـ v قبل كدة كان هيعرضها. دلوقتي خليناه يسيب الـ v وراح للـ w خلاص هيعرض الـ w بس. طيب في أي حد مش فاهم أي حاجة في الجزئيات اللي فاتت؟ أيوه؟
اخر خطوة بتاعت الاتناشر رقم هتتغير عادي بالرقم الجديد مش هتفرق انا ممكن اغير القيمة اللي جوا الـ W دي من خلال اسم الـ W نفسه واسم الـ variable الحقيقي او من خلال كلمة P* اعمل De-reference لـ P و اخليه يتغير
تمام، ونخلي بالنا ما بين التعامل مع P في حد ذاتها وما بين *P.
 P، لو قلت P يبقى أنا بغير Address، بديها Address. 
*P يبقى أنا بغير الـ Value اللي بتشاور عليها. تمام؟
 لو عملت بعد دي قلت مثلاً w بتساوي 15؛ يبقى الـ 12 هتتمسح هتبقى 15 عادي، ممكن من هنا وممكن من هنا مفيش مشكلة.
طيب إحنا اتفقنا دلوقتي إن الـ Pointer ده بيبقى شايل جواه Address، والـ Address ده عبارة عن رقم. إذاً هل ينفع بقى أقعد أجمعه وأطرحه وأحطه في Mathematical expression أساويه بأي حاجة Integer مثلاً؟ لا مش هينفع. هو آه Variable طبيعي وآه شايل رقم اللي هو الـ Address، ولكن بيبقى ليه معاملة خاصة لأنه Hexadecimal address.
تمام؟ فما ينفعش احطه كده ما ينفعش اعمله في expression ولكن انا ممكن اعمله increment و decrement ممكن نزوده و نقصه ولكن نخلي بالنا بقى ايه من المعنى بتاعنا لو قلنا ptr++ احنا هنا مش بنزود قيمة الادرس بواحد مش بنعمله increment فعلا لا احنا بنزودله location عشان يشاور على الـ variable اللي بعده
يعني بيزيد عدد bytes على قد عدد الـ bytes اللي بيحجزها الـ variable اللي هو بيشاور عليه حسب نوعه. يعني مثلاً، فلنفترض إحنا دلوقتي pointer بيشاور على integer يبقى لما أعمله ++ هيزيد كام بقى؟ 4 bytes
 عشان يشاور على الـ next integer location. 
لو أنا من نوع character قلتله ++ هيزيد 1 byte، من نوع float هيزيد كام byte؟
قلناها دي قبل كدة أربعة برضو. يبقى الـ Increment بأربعة، الـ Decrement 
minus أربعة. تمام؟ 
زودنا باتنين يبقى 2 في 4 فاهمين بقى الفكرة؟ 
طيب نخلي بالنا هنا فاكرين علامات الـ Increment لما تبقى بعد وقبل بيبقى
 إيه الفرق ما بينهم؟ لو قلنا مثلاً هنا cout
 ptr++ بيعمل إيه؟ هيعرض الـ Address الأول اللي جوه الـ PTR وبعد كدة يعمل له Increment يروح على الـ Next location.
هنا plus plus 
ptr يبقى هيزود الأول الـ Address بقيمة اللي هي 4 bytes وبعد كدة يروح يعرض
 الـ Address الجديد. نخلي بالنا بقى ما بين الاتنين دول وما بين السطر اللي هنا ده. 
لو قلنا plus plus
*ptr ده معناه إننا بنزود ايه؟ الـ Value بتاعة الـ Variable اللي الـ PTR بيشاور عليه.
يبقى هنزود الـ Value دي بكام؟ بواحد عادي، ما هي الـ Value دي هتبقى رقم. تمام؟ يبقى هنا إيه بيعمل plus plus لكل ده على بعضه، اللي هو إيه الـ PTR بس De-referenced.
 تمام؟ هنشوف دلوقتي أمثلة هنأكد على الموضوع ده. أه ده هنا بس
 شكل الـ Pointer arithmetic لو أنا مثلاً معرفه Character.
pointer عملت له هنا increment يبقى هنا إيه كان مثلا بيشاور على ألف حيث بيشاور على ألف و واحد. لو أنا عاملة short integer وعملت له A++ ده بيبقى الحجم بتاعه 2 bytes. بدل ما كان بيشاور على ألفين هيشاور على ألفين واتنين وهكذا. 
زي ما قلنا بيروح على next variable of the same type.
طيب تعالوا نشوف أمثلة، أنا عندي هنا إيه variable num بيساوي 4.
 عندي هنا pointer عرفت pointer PTR بيساوي &num حطيت جواه الـ address بتاع num يعني دلوقتي أنا عندي الـ PTR بيشاور على الـ variable اللي اسمه num تمام؟ جيت أعمل cout num،
 cout PTR تفتكروا هيعرضوا إيه؟
Num هتعرض 4 عادي، PTR هيعرض إيه؟ الـ Address بتاع num أهو.
 يبقى أنا عندي الأربعة عادي أهي وده الـ Address بتاع num.
 جينا بقى نعمل Pointer arithmetic نزود حاجات عليه، لو قلنا PTR = PTR + 1 
يبقى الـ Address اللي جواه هيزيد إيه؟ 4 bytes، تمام؟ والمفروض ده الـ Address الجديد اللي جواه أهو بنقول cout هنا PTR هيعرض لي الـ Address ده.
إحنا ملناش دعوة بالـ Hexadecimal addition دلوقتي، 
هي مش قصتنا مش هقولكم زودولي الـ Address بأربعة، Okay؟ 
بس الرقم ده هو الـ Address زايد بأربعة. طيب جينا ننقص منه واحد تاني يبقى هيعمل minus أربعة، هيرجع يعرض إيه؟ الـ Address القديم اللي كان جواه أصلاً في الأول. تمام؟ الـ Int...
الـ Address اللي ما هو Hexadecimal address هي مش حروف هي أرقام بس Hexadecimal. مش أنتم أخذتوا الـ Hexadecimal في الـ Introduction؟ اللي هنا دي؟ لا هنا مش هينفع يطلعلك Error. ليه بقى؟ لأن كدة PTR هيبقى Integer variable عادي.
والـ Integer variable ماينفعش يشيل Hexadecimal number، هيشيل Address
 الـ Integer variables مش مجهزة إنها تشيل Address، 
Okay؟ فمش هينفع. طيب تعالوا ناخد نفس المثال بس إيه بطريقة تعامل مختلفة، أنا عندي هنا نفس الـ Variable num وإيه وشايل الـ Address الـ PTR شايل الـ Address بتاع num.
هنيجي نعمل هنا cout PTR و *cout PTR 
يبقى هنا بيعرض إيه؟ الـ Address بتاع num اللي شايله جواه، *ptr هيعمل De-reference اعرض لي الـ Value بتاعت الـ Variable اللي أنت بتشاور عليه، اللي هو إيه 4، هو بيشاور على الـ 4. طيب نشوف بقى بعد كدة عملنا Increment للـ Pointer
 يبقى زودناه One integer location بيشاور على الرقم اللي بعده.
تعالوا بقى نشوف دي، cout PTR و *PTR تاني. 
الـ Pointer نفسه الـ Address زاد بـ 4 bytes، بدل ما كان آخره 4 بقى آخره 8 أهو دي واضحة. نيجي بقى نعمله De-reference *PTR، اعرض لي الـ Value بتاعة الـ Variable اللي أنت بتشاور عليه؛ هو أصلاً المكان الجديد اللي بيشاور عليه ده Uninitialized، صح؟ إحنا معرفناش حاجة بعد الـ Num.
وبالتالي هيعرض لي هنا إيه؟ أي Garbage جوه الـ Memory بالشكل ده. تمام؟ لو أنا كنت معرفة كذا حاجة كان هيعرض لي الحاجة اللي بعدها. لكن هنا مفيش حاجة خلاص هيعرض لي أي حاجة Random. لو عملت Decrement هرجع تاني أعرض مين؟ الأربعة بتاعة الـ Num يبقى رجعت مكاني تاني. حد مش فاهم؟
طيب ده بقى شرح الكلام اللي احنا قولناه نظري عشان وانتو بتذكروا لوحدكم. 
الـ pointer variable ممكن نخليه يشاور على حاجة من اي نوع. integral float double struct array مفيش مشكلة خالص. ممكن ال pointer variable نعمله assigning لـ pointer variable تاني of the same type. هنشوف ده لسة دلوقتي الـ slide اللي جاية.
نخلي بالنا increment و decrement pointer بتخلينا ايه نروح للnext variable of the same type قبليا او بعديا ولكن نخلي بالنا يا جماعة ان ده بيختلف من compiler ل compiler تاني يعني ممكن مثلا عندي انا default الـ integer يبقى 4 bytes ممكن عند حد تاني long integer يبقى 4 bytes يعني فيه اختلافات ما بين الـ platforms المختلفة
فلو لقيتوا اختلاف ما تقلقوش، لكن الـ Default اللي هنشتغل عليه في الامتحان إن الـ Integer أربعة bytes. أي تغيير هنبلغكم. أهو هنا بقى لما نيجي نعمل Assignment للـ Pointers 
دول Two pointers أنا معرفاهم مثلاً من نوع Integer، جيت هنا قلت P2 بيساوي P1. نخلي بالنا هنا بنتعامل بإيه؟ بالـ Addresses اللي جواهم، الـ Values بتاعتهم اللي جواهم إيه؟ اللي هي الـ Address.
كأني بعمل إيه؟ بقول هات الـ Address اللي جوه p1 حطهولي جوه p2 هو كمان. طب ده معناه إيه؟ معناه إن دلوقتي الـ p1 والـ p2 الاتنين بيشاوروا على نفس الحاجة، على نفس المكان. والمكان ده ممكن أغيره سواء من p1 أو من p2؛ الاتنين بقوا Two pointers identical
 أهو Make p2 point to where p1 points.
Do not confuse with محدش يتلخبط ما بين هنا إيه *p1 بيساوي *p2 هنا بنعمل إيه؟ بنساوي الـ Value بتاعة الـ Variable اللي بيشاور عليها p1 بالـ Value بتاعة الـ Variable اللي بيشاور عليه الـ p2. فخلاص مش هتنسوها الجملة دي. ناخد مثال عشان إيه نستوعب الجملتين دول.
لو قلنا هنا P1 بيساوي P2 قبل ما نيجي ننفذ الجملة دي هنلاقي مثلا P1 بيشاور على variable قيمته 8 والـ P2 بيشاور على variable قيمته 9 طيب بعد ما تتنفذ احنا عايزين نعمل ايه عايزين نخلي الـ address اللي جوا P2 جوا P1 يبقى هناخد القيمة اللي هنا هنحطها فين جوا P1 هنا هنلاقي P1 فعلا غير الـ direction بتاعه بقى بيشاور على ايه؟ على الـ 9 زي P2
وساب الـ Variable اللي هنا لحاله، نـ accessـه من اسمه عادي. طيب عايزين نشوف الجملة التانية *P1 بيساوي*P2 . قبل كان إيه اللي هيحصل؟
 برضو ده بيشاور على الـ 8 وده بيشاور على الـ 9. طب إحنا عايزين نعمل إيه؟ عايزين ناخد القيمة اللي بيشاور عليها P2 اللي هي الـ 9 دي، نحطها فين؟ جوه الـ P1؛ أهو إحنا فعلاً أهي غيرنا قيمتها.
لكن بيشاوروا على نفس الأماكن عادي. ما هو بص هو p1 و p2 دول Pointer variables القيمة اللي جواهم Addresses، ده جواه Address فبيشاور بيه على حتة معينة وده جواه Address بيشاور بيه على حتة معينة. ساويتهم ببعض، معناها إيه الـ Assignment ده؟ يعني أنا هاخد الـ Address اللي جوه p2 أحطه جوه p1 هو كمان.
هـ overwrite على الـ Address اللي كان جوا الـ P1. خلاص بقى الاتنين دلوقتي جواهم Address واحد اللي كان جوا الـ P2 فالاتنين بيشاوروا على نفس المكان اللي عنده الـ Address ده في الـ Memory، خلاص اللي هو هنا إيه مكان التسعة دي. فأنا أقدر أغير التسعة دي من خلال دلوقتي الـ P2 أو الـ P1 عادي. Okay الـ P1 إيه تطفل على P2 وإيه ودخل Access معاه.
طيب في أي حاجة مش مفهومة في الجزء اللي فات؟ نبتدي بقى في الحاجات المهمة اللي بتوضح لنا أهمية الـ pointers هناخد دلوقتي dynamic variables اللي هتمهد لنا بعد كده ناخد الـ dynamic arrays اللي إحنا إيه؟ منتظرينها بفارغ الصبر الـ dynamic variables يعني إيه؟ لحد دلوقتي كنا نتعامل مع الـ variables الطبيعية العادية جداً بيبقى لها identifier اللي هي الاسم بتاعها بنتعامل معها بتخلص مع الـ function الـ function خلصت..
هنا بقى هنعمل حاجة اسمها dynamic variable.
الـ dynamic variable ده nameless ملوش اسم. اومال بعملو ازاي؟ انا بعرفه من خلال الpointer اللي هيشاور عليه. وبعملو access بس من خلال الpointer اللي انا ايه معرفاه بيه. طيب بنعرفو ازاي من خلال كده operator لطيف جدا اسمه الـ new.
الـ New Operator ده يروح مخلق لي عمل لي variable جديد و بيخلي الـ P1 بس هو إيه اللي يشاور عليه يعني خلاص هنا بقى ده ليه طريقة واحدة للـ Accessing مالوش اسم خلاص طيب وبعد كده بعد ما بنعرفه بنستخدمه عادي زي أي variable طبيعي جدا فإحنا بنعرفه زي نقول P1 اللي هو اسم Pointer مثلاً بيساوي New Integer 
P1 بيسوي New Double بيسوي New أي حاجة حسب نوعه إيه
طيب، Since pointers can refer to variables، 
خلاص طالما الـ Pointers ممكن نـ refer بيها للـ Variables دي إحنا مش محتاجين أي Standard identifier خلاص، هو الكلام كله متكرر بنستخدمه عن طريق الـ New operator وبس إيه الـ Pointer. إحنا كاتبين الكلام بس اللي بنقوله في الشرح عشان وأنتم بتذاكروا إيه لوحدكم بعد كدة. مثال، الأمثلة الـ Animated اللطيفة دي.
إحنا هنا بنقول إيه
int *p1,*p2 عرفنا two pointers من نوع integer هيشاوروا على حاجات integer بعد كدة، أهوم p1 و p2 ومش عارفين لسه هيشاوروا على إيه. نيجي بعد كدة نقول p1 بيساوي new int يبقى هنا عملنا الـ p1 
dynamic variable وهو لوحده اللي هيشاور عليه يبقى p1 فعلاً بقى بيشاور على مكان جديد خاص بيه هو بس، بتاعه هو بس.
لسه المكان ده نفسه uninitialized، هو variable عادي زي أي variable لسه مادينالوش قيمة جواه. بصوا بقى هنا بنقول*p1 بيساوي 42. خليلي الـ value بتاعة الـ variable اللي بيشاور عليه الـ p1 بـ 42. طب هو بيشاور على إيه؟ على الـ dynamic variable الجديد بتاعه. مابقاش بقى variable عادي طبيعي يبقى هنا إيه هيخلي القيمة فعلاً بـ 42.
طيب، هنيجي بعد كدة نقول p2 بيساوي p1 تفتكروا إيه اللي هيحصل؟ هيطلع سهم من p2 للـ 42 أهو. يبقى هنا لما ساويناهم ببعض في السطر ده، الـ Address اللي جةل p1 اتعمله copy جوا الـ p2؛ فـ p2 فعلاً بقى بيشاور على الـ 42 مع الـ p1.
طيب، قبل ما نشوف الـ output لما نيجي نعمل cout بعد كدة لـ *p1 و *p2 تفتكروا إيه اللي هيحصل؟ هيعرضوا إيه هنا وهنا؟ الاتنين هيعرضوا 42 لأن الاتنين بيشاوروا على نفس المكان دلوقتي. يبقى المكان الـ dynamic variable اللي اتعمل ده ممكن أشاور عليه من خلال الـ p1 أو من خلال الـ p2.
ال dynamic variable مش مرتبط بـ pointer معين هو لو pointer بيشاور عليه خلاص ما فيش غيره okay لكن لو فيه 2 pointers عشرة pointers عادي كلهم يعملوا ايه accessing P2 تطفل على P1 بعد كده هيخلي قيمته ب53 *p2 بيساوي 53 هنغير قيمة الـ value بتاعت الـ variable بيشاور عليه فغير في قيمة الـ dynamic variable المشترك بتاعهم
نيجي نعمل cout بعد كدة إيه اللي هيحصل؟ الاتنين هيعرضوا 53.
 p1 زهق خلاص، يعني هو عمل لنفسه dynamic variable راح p2 داخل معاه ومغير فيه فخلاص هيسيبهوله لوحده، يسيبه في حاله ويعمل لنفسه إيه dynamic variable خاص بيه هو تاني، هنقول هنا p1 بيساوي new integer راح عامل لنفسه هنا dynamic variable جديد وبيشاور عليه هو بس.
خلاص ساب بقى الـ dynamic variable التاني لـ p2. طيب *p1 بيساوي 88 يبقى هنغير في الـ dynamic variable الجديد اللي هو عمله. نيجي نعمل cout في الآخر هتعرض إيه؟
 *p1 هيعرض 88، *p2 هيعرض 53
كل واحد هيشاور على الـ value بتاعة الـ variable اللي هو إيه بيشاور عليه.
نخلي بالنا من حاجة، لو مكناش هنا ضامنين إن ده فيه pointer بيشاور عليه اللي هو الـ p2
ماينفعش نسيبه. ماينفعش نسيب dynamic variable كدة إيه لوحده جوه الـ memory ومالوش address، مالوش pointer بيشاور عليه ده كدة يبقى allocated space جوه الـ memory محدش قادر يـ accessـه، لا البرنامج ولا الـ operating system. 
طول ما البرنامج شغال هيبقى محجوز للبرنامج وخلاص ومش عارفين نـ accessـه.
الـ dynamic variables بيبقى ليها طريقة تانية للـ initialization، إحنا أخدنا إن إحنا نغيرها من خلال asterisk الـ pointer بنعمل dereference للـ pointer. ممكن وإحنا بنعرفها نقول مثلاً *int iPtr 
integer pointer بيساوي new int قبل كدة كنا بنقف هنا ونحط semicolon.
لا هنا هنحط قوسين مدورين وما بينهم إيه الـ value اللي عايزين نديها لهم بالشكل ده، فهنا بيعمل initialize للـ dynamic variable بتاع الـ pointer ده بـ 33. هنا مثلاً عملنا double dPointer، ده pointer اسمه dPointer، قلنا ده بيساوي new dynamic variable وادينا له إيه القيمة 11.2.
هنا بس ملحوظة جانبية على جنب إن ممكن نعملها على سطرين عادي. مش لازم التعريف بتاع الـDynamic Variable يكون على سطر واحد. ونخلي بالنا لما السطر الثاني بدايته إيه؟ اسم الـPointer نفسه مش asterisk. إن إحنا إيه؟ بنحط جواه Address. الـNew Operator بيرجع لي الـAddress بتاع الـDynamic Variable اللي هو إيه حاجة حجزهولي. تمام؟
بتاع الـ new double، 
Okay؟ لو كنا نقلناه فوق كنا هناخد من أول equals دي نحطها إيه هنا يبقى كنا بنعرف dynamic variable عادي و initialize بـ 11.2. إحنا هنا بس فصلناهم على سطرين، تمام؟ فإحنا الفكرة كلها إن الـ new operator بيرجعلي الـ address بتاع الـ dynamic variable اللي هو حجزهولي.
okay احنا بقول الـ Pointer بيساوي New مثلاً Double فالـ New رجعت لي Address حطتهولي جوا الـ Pointer عشان الـ Pointer دا يعرف يشاور عليه ويتعامل معاه بعد كده تمام؟ فهنا بنحط الـ Pointer نفسه أقصد مش الـ Asterisk لأن احنا خلاص بنتعامل الوقت مع Address طيب كان زمان بقى وإحنا بنتعامل مع الـ Variables العادية كنا بدل ما بنقول إيه int num equals 5 اللي هو الطريقة العادية بتاعتنا كان ممكن نقول int num of 5 بالشكل ده نفس القوسين المدورين جربوها هتلاقوها بتنفع
عادي، دي طريقة تانية بس ممكن نعملها. ما تتلخبطوش بقى ما بينها وما بين الـ Functions. ممكن في الامتحان يجي واحد يقول لي num دي function بترجع Integer والـ Parameter بتاعها 5 لا، خلوا بالكم بقى إيه كويس أوي من الفرق ده والفرق ده هيبان من صياغة الكود بتاعنا إحنا عايزين إيه.

طيب آخر سطر، بنقول هنا *int pointer بيساوي new int of الـnum
يبقى هنا ممكن الـ Initialization بتاعت الـ Dynamic variable تبقى قيمة Variable تاني، مش لازم تبقى Constant أو رقم ثابت، عادي جداً.
الـ Variable ده طبعا يكون Initialized قبل كده ولوه قيمة. Okay. طيب الـ Dynamic Variable دي هنعرف أهميتها بعد شوية. زي هنستخدم حاجة زي هي هنعمل بيها Dynamic Array. تعالوا لأول نشوف جزء كده بسيط عن Memory Management. يعني إيه؟ يعني الـ memory الـ allocated للـ program لما بيتعمل له Run بيبقى شكلها إيه؟ أو متقسمة إزاي؟
الكلام ده مش مهم أو مش ضروري أوي في الـSP، إحنا بس فيه جزئين عايزين نركز عليهم النهاردة ضروري الشكل العام ده عموماً هتاخدوه أكتر برضو في المواد اللي بتهتم بالـ hardware أكتر بعد كده عموماً عندنا الـMemory بتبقى متقسمة جزء text، جزء Initialized Data، Uninitialized Data heap و stack و environment، اللي يهمنا اوي النهاردة الـheap و stack
تعالوا نشوف شرح بسيط على كل جزئية أول جزء اللي هو الـ text segment
 الـ text segment دي أو جزء ده من الـ memory بيشيل جواه executable instructions أي instructions أي code أنا كتبه جوا البرنامج بتاعي بيشيل جواه الـ object code بتاعهم أو او الـ machine code اللي هو zeros والـ ones اللي بتعبر عن instruction ده تمام؟
جزء الـ initialized data ده segment جوا الـ memory بتشيل الـ global variables والـ static variables اللي اتعمل لها initialization في الـ program بتاعنا. الـ static variables دي مش قصتنا بس هتتعاملوا معاها بكثرة إن شاء الله في الـ OOP بعد كدة. 
الـ uninitialized data بتشيل برضه الـ global والـ static variables.
اللي ما اتعملهاش initialization في الـ source code بتاعنا.
 أومال فين بقى الـ variables العادية بتاعتنا بتتشال فين؟ تعالوا نشوف دلوقتي. 
جوا الـ Stack Segment. الـ Stack Segment في الـ memory بيتشال جواها كل 
الـ variables اللي هي كل الـ local variables اللي كنا بنتعامل معاها قبل كدة حتى including الـ Main، 
Okay؟ يبقى بتشيل الـ variables بتاعة أي functions حتى لو كنا إيه بنتعامل مع الـ Main.
أول ما بيحصل function call أو أول ما الـ function بتبتدي، كل الـ variables اللي متعرفة جوه الـ function دي بيتعمل لها allocation جوه الـ Stack Segment في الـ memory، تحجز مكان جوه الـ Stack Segment. وأول ما الـ function call is over، 
أول ما الـ function بتنتهي عايزة تعمل return بقى وترجع إيه الـ control للـ function اللي ندهتها، الـ variables بتاعتها دي بتبقى deallocated.
أو بتتمسح من جوا الـ Stack Segment. طب هل إحنا هنمسحها بنفسنا؟ 
لا، الـ Compiler بيبقى جواه some pre-defined routines في جواه حاجات مخصوصة بتمسح هنا الـ variables دي بتعمل لها deallocation. 
فاكرين في المحاضرة بتاعة Functions 2 لو حد ذاكرها أو حضرها كان فيه 
animated example كدة كبير جداً كنا أول ما بننده function نلاقي الـ variables ظهرت جوا الـ memory.
أول ما إيه الـ function خلصت، الـ call بتاعها خلص، الـ variables اختفت لوحدها من
 الـ memory؛ هو ده اللي بيحصل لما إيه بنتعامل مع أي function في الـ Stack Segment. نيجي بقى للي يهمنا النهاردة، الـ related للـ topic بتاعنا النهاردة، اللي هو الـ Heap 
أو الـ Free Store. نخلي بالنا إن دول مسميين مختلفين لنفس الحاجة، الـ Heap أو الـ Free Store؛ عشان لو جالنا في الامتحان ده أو ده.
ده محجوز لإيه؟ محجوز للـ dynamically allocated variables،
 أي variable عرفناه عن طريق الـ new operator بيتحط جوا الـ Heap أو إيه الـ Free Store. تمام؟ 
يبقى الـ Pointers عادي بتتحط في الـ memory عادي بتاعت الـ Stack، لكن الـ Heap
 والـ Free Store بيتحط جواها الـ dynamic variables.
all new dynamic variables consume memory in free store 
تستهلك منها مساحة خصوصا بعد كده لو عملنا dynamic arrays لما نبتدي نشرحها الـ arrays بقى تاخد ايه مساحة كبيرة جدا if too many لو dynamic variables دي احنا عملناها كتير جدا كل شوية نعمل pointer بيساوي new كذا pointer بيساوي new كذا حجزنا اماكن كتيرة جدا خلاص الـ memory هتتملي هي مش unlimited هي ليها limit معين ساعتها اللي هيحصل؟
Future new operations will fail if free store is full. 
يبقى ساعتها كل ما نيجي نعمل new تاني الـ operation دي هتفشل، بدل ما الـ new كانت بترجعلي address تحطه جوا الـ pointer لمكان الـ variable اللي هي حجزته
 هترجع إيه null. طيب هنتصرف إزاي؟ الـ older compilers، في الـcompilers القديمة مكنتش بتعرف تـ handle الـ case دي كان البرنامج إيه ممكن يروح إيه مفرقع في وشك، راميلك إيه exception أو يهنج بطريقة مش كويسة.
فكان لازم نعمل الـ null check ده. بصوا كدة معايا 
أول حاجة بنعرف int *pointer بيساوي new int عرفنا dynamic variable. إحنا متوقعين الـ new دي ترجعلي إيه؟ يا address يا null. طيب،
 if pointer بيساوي null، لو كانت قيمته null هنقول إيه؟
 cout Failed to allocate memory
أنا آسف، أنا مش قادر أحجزلك memory فرجعتلك null خلاص.
وهعمل exit بـ 1 
دي حاجة بتطلعني برة البرنامج إيه بهدوء وسلاسة بدل ما يفرقع في وشي،
 exit بـ 1  يعني أنا خارج بمشكلة، خلي بالك أنا خارج بمشكلة.
 Else، 
cout << Successful new allocation
يبقى خلاص أنا جبتلك address فعلاً وحطيناه جوا الـ pointer. فاكرين لما كنتوا تقعدوا تسألونا إيه الفرق ما بين void main و int main؟ هي عشان الـ case دي بالذات
 void main بنستخدمها لو متوقعين البرنامج يخلص لحد آخره بالـ sequence الطبيعي بتاعه، int main بنستخدمها عادة لو هنعمل exit...
برقم معين،
 Okay؟exit بـ0 يعني كان successful
exit بـ 1 كان فيه مشكلة أو أي رقم تاني يبقى فيه مشكلة فغالباً هتبقى int main 
عشان الـ cases دي. طيب الـ newer compilers بقى، الحاجات الأجدد بقت بتقدر إنها إيه terminate automatically من غير مشاكل من غير ما يهنج، أو تطلعلي error message. بس it's still a good practice نستخدم إيه الـ null check عشان حتى أعرض لليوزر إيه message كدة إيه لطيفة تفهمه اللي حصل.
إحنا اتفقنا دلوقتي إن الـ dynamic variables بتحجز مكان جوا إيه؟ الحتة في الـ memory اللي اسمها إيه؟ الـ Heap أو الـ Free Store، تمام؟ وقلنا إنه ممكن يتملي على آخره.
 فطبعاً يبقى logic لو أنا إيه بستخدم pointer معين وخلصت استخدامه، خلصت الـ dynamic variable اللي هو بيشاور عليه خلاص مش هستخدمه تاني، إن أنا أمسحه، هعمله delete.
هو هنا وفرلي operator اسمه delete operator
ده بيعمل إيه؟ بيعمل deallocation للـ dynamic memory pointed to by pointer variable، 
يعني بيخليها إيه تتمسح لما نبقى إيه مش محتاجينها تاني،
 وهترجع بعد كدة الـ memory للـ Free Store أو الـ Heap بتاعي.
 هنا مثلاً بنقول *int ptr بيساوي new int of 5
يبقى هنا عرفت dynamic variable قيمته 5 وبيشاور عليه أو بـ accessـه من خلال الـ ptr.
أي بقى سطور code عادية جداً هنستخدمه، خلصنا استخدامه نعمل إيه؟ delete ptr
 هنمسح الـpointer
 ptr، بس نخلي بالنا إحنا مش بنمسح الـpointer نفسه، أومال delete دي بتعمل إيه؟ 
بصوا السطر اللي فوق ده delete بتمسح الـ dynamic variable اللي هو بيشاور عليه، القيمة اللي حجزتها مثلاً إيه الخمسة دي تعالوا نرسمها.
أدي عندي إيه الـ ptr، وأدي إيه الـ dynamic variable اللي هو إيه بيشاور عليه
Okay؟ يبقى إيه اللي هيتمسح؟ الجزء ده، جوا الـ Heap أو الـ Free Store. 
أومال طب الـ pointer لسه معمول إزاي أو قيمته إيه؟ لسه موجود زي ما هو، جواه الـ Address اللي جواه عادي جداً زي ما هو. طيب تعالوا نشوف ده هنتصرف معاه إزاي بعد كدة.
الـ delete بيمسح الـ dynamic memory بس الـ pointer لسه موجود هناك.
 طيب ده بنسميه إيه؟ بنسميه dangling pointer،
 pointer معلق كدة مالوش صاحب، جواه address بيشاور على حاجة مافيهاش قيمة خلاص، Okay؟ طيب تعالوا نشوف مثال نتعامل إزاي مع الحكاية دي  دلوقتي لو عملنا له asterisk ptr، هنيجي نعمله dereference والحاجة اللي بيشاور عليها مش موجودة بقت مثلاً random memory أو garbage هيبقى أي رقم عادي.
هنا هنقول إيه integer*  pointer بيساوي new int of 5 عادي جداً،
 هنا هنعمل cout ptr و * ptr هيعرض إيه؟ 
الـ address بتاع الـ dynamic variable وهيعرض 5. 
أهو تعالوا نشوف، أهو بيعرض الـ address وبيعرض إيه الـ 5 دي. delete pointer
هيمسح إيه؟ هيمسح المكان اللي حاجزاه إيه الـ 5، الـ dynamic variable ده.
طب لو جينا قلنا بعد كدة cout ptr و *ptr تعالوا نشوف.
 ptr عرضلي نفس الـ address اللي كان موجود فوق، هو مختفاش منه. 
جينا بقى نعمل dereference ونعرض القيمة اللي بيشاور عليها، الـ value بتاعة الـ variable اللي ptr بيشاور عليه، هنلاقيها إيه garbage موجودة في الـ memory. خلاص طبعاً دي لو استخدمناها بعد كدة يعني هي هترجع، بس يعني نيجي بقى نستخدمها بعد كدة هتطلعلي قيم إيه unpredictable وهتبوظلي البرنامج بتاعي.
"طيب إيه الحل بقى؟ إحنا ممكن
 نـ avoid dangling pointers by assigning the pointer to null. 
بعد ما نعمل delete للـ pointer هيمسح الـ value اللي بيشاور عليه، نروح إيه حاطين جواه null؛ يبقى كدة شيلنا الـ address اللي جواه. دايماً الجملتين دول هييجوا مع بعض بعد كدة أهو مثلاً هنا عرفنا الـ pointer، هنا هنعرض، هيعرض الـ address وهيعرض الـ 5 اللي جواه.
هنيجي بعد كدة نعمل إيه؟ delete pointer هنمسحه، يبقى مسح المكان اللي واخداه الخمسة. بعد كدة نقول إيه؟ pointer بيساوي null أو pointer بيساوي nullptr; دي صيغة تانية برضو للـ null pointer. فسواء قلنا ده أو ده خلاص كدة إحنا في الـ safe side
 واتجنبنا الـ dangling pointer. 
طب لو جينا نقول بعد كدة cout ptr و cout asterisk ptr هينفع؟
وإيه بقى؟ asterisk ptr هيعرض إيه؟ مش فاكرين الـ error اللي كان مكتوب بخط صغير ده اللي طلعناه من شوية؟ إحنا دلوقتي بنحاول دي نعمل dereference للـ pointer
 وهو جواه null. مفيش جواه address أصلاً، مفيش حاجة بيشاور عليها، تمام؟ يبقى ده إيه illegal خلاص ده هيطلعلي error. أنا بحاول أعمل إيه؟ اعرضلي الـ value بتاعة الـ variable أنت بتشاور عليه وأنت مش بتشاور على حاجة أنت جواك null.
تمام؟ فهنا هيطلع error. فدايما نخلي delete. اخر حاجة ايه؟ بعد ما نخلص استخدام الpointer. منستخدموش تاني بعدها خلص. اوكي؟ يبقى خدوها قاعدة يا شباب. اي حاجة. اي dynamic variable يتعامل عن طريق new لازم يتمسح. اوكي؟ عشان نـdeallocate المكان نفضيه ما يبقاش ايه محجوز من خلال الـ pointer ده كده وخلاص. نفضيه لأي استخدامات تانية بعد كده.
طيب ايه بقى الفرق ما بين الـDynamic Variables والـLocal Variables؟ 
كلام نظري معظمه قلناه قبل كده الـDynamic بيتعمل من خلال الـNew Operator مالوش اسم بنتعامل معه من خلال Pointer بس
 Created and Destroyed While the Program Runs الـLocal Variable بيبقى Declared Within the Function Definition اول ما function بتخلص بيختفي لوحده احنا مبنعملش الـProcess دي الـCompiler بيعلمها لنا بنـaccessـه من خلال الـIdentifier بتاعه او من خلال اسمه عنده اسم عادي..
اهمية الـ Pointers ايه؟ بقى ليه بناخد المحاضرة دي وندوش نفسنا النهاردة؟
 زي ما قولنا مش هنلمسها قوي في الـcourse بتاعنا في الـ SP بس احنا لازم نجهزكوا عشان ما تطلعوا بعد كده على الـ DS و على الـ OP تقدروا ايه تتعاملوا مع الحاجات دي كويس استخداماتها زي ايه؟ بنعمل بيها Accessing لل-Array Elements دي لسة هنشوفها النهاردة ان شاء الله
Passing arguments to functions إحنا زي ما عندنا pass by value 
و pass by reference، في عندنا برضه pass by pointer نوع تالت بيبقى إيه pass 
لـ pointer بالشكل ده. مش هنركز عليها أوي بس هنعرفها. ممكن بيها نعمل
 passing لـ arrays و strings للـ functions زي الـ pass by reference كدة. بنـ obtain memory من الـ system عن طريق الـ delete، بنـ free memory...
Create بقى Data Structures دي أهم حاجة فيها.
 Create data structures whose size can grow and shrink dynamically جوا البرنامج؛ طول ما البرنامج شغال تلاقي حاجة كدة مشابهة للـ Array بس عمالة تكبر وتصغر زي ما أنا عايزة، حسب اليوزر بيدخلي إيه زي الـ Linked List. دي برضه لسه مش السنة دي بقى إن شاء الله. طيب ناخد تمرين بسيط كدة.
نرسم المثال ده أنا عندي هنا إيه variable اسمه first value، و variable اسمه second value، و 2 pointers
 p1 و p2. تعالوا نرسمهم.. ده first val..
وده الـ second val.
 الـ first جواه كام؟ 5، والـ second جواه 15. طيب، هنيجي هنا نقول 
p1 هيشاور على الـ first، هيشيل الـ address بتاعه، و p2 هيشاور على الـ second. يبقى الـ p1 هيشاور على الـ first كدة، والـ p2 جواه الـ address بتاع الـ second val هيشاور إيه عليه.
طيب، asterisk p1 = 10
 هنعمل إيه؟ هنغير الخمسة
 خليلي الـ value بتاعة الـ variable اللي أنت بتشاور عليه بـ 10. يبقى هنا هتبقى إيه 10.
asterisk p2 = asterisk p1 يبقى هنا هناخد الـ value بتاعة الـ variable اللي بيشاور عليه p1، هنخليها بقيمة الـ value بتاعة الـ variable اللي بيشاور عليه p2 يبقى هنا هيبقى جواه إيه برضه 10.
طيب هنا هنقول إيه؟ ركزوا في دي
 p1 بيساوي p2 يبقى الـ p1 السهم بتاعه هيتغير، بدل ما كان بيشاور على الـ first value هيشاور على الـ second value. ليه؟ أنا أخدت الـ address اللي بيشاور عليه الـ p2 حطيته جوا الـ p1. يبقى هاخد القيمة دي، هحطها هنا؛ هييجي بقى الـ p1 هيغير اتجاهه.
يبقى إيه هيشاور هنا على إيه الـ second val مع الـ p2. تمام؟ طيب،
asterisk p1 بيساوي 20 يبقى الـ second val هيبقى بتساوي 20 أنا بغير الـ value بتاعى
 الـ variable اللي بيشاور عليه الـ p1 هتبقى إيه بـ 20 قلتلكم هزهقكم بالجملة دي النهاردة. طيب في الآخر هنيجي نقول بقى cout first value, second value هتبقى سهلة خلاص إحنا عملنا tracing بالرسمة؛ يبقى هيعرض 10 و 20.
تمام؟ لو كنتوا عملتوها بعينيكوكان برضو يبقى ممكن يبقى فيه لخبطة فارسموها أحسن.
 p1 هيبقى جواه الـ address اللي جوا p2، يبقى هيشاور على نفس المكان اللي كان بيشاور عليه p2. 
p2 كان بيشاور على الـ second val يبقى p1 كمان هيشاور على الـ second val معاه.
هو بيشاور مطرح ما الـ address اللي جواه هيقوله، خلاص حطينا جواه الـ address اللي كان جوا p2 فيروح إيه بيشاور معاه على نفس الحتة. طيب فاكرين أنتم الـ increment
 والـ decrement لما تبقى قبله وبعده وبـ asterisk أو من غير؟ تعالوا نشوف عليها تطبيق عشان ما نتلخبطش.
هنا لو قلنا ptr 
plus plus جوا الـ cout مثلاً، هنا هيعرض إيه الأول؟ هنا الأول هيستخدم أو يعني هيعرض قيمة الـ address اللي جواه وبعد كدة يعمل له increment عشان يشاور على الـ next position. لو قلنا plus plus
ptr هزود الـ address بواحد الأول وبعد كدة إيه استخدم الـ address الجديد على بعضه أو أعرض الـ address اللي جواه.
طب لو قلنا plus plus asterisk ptr
  خلوا بالكم بقى إيه، هزود على الـ value، Okay؟ يبقى هزود الـ value الأول وبعد كدة هنستخدمه ، اللي هو إيه بيشاور عليه asterisk plus plus ptr 
خلوا بالكم دي بقى هنبتدي بقى في اللخبطة، هنا إيه هيعمل إيه؟
هيتنقل الأول على الـ next position وبعد كدة هنعمل dereference لإيه للـ address الجديد ليه؟ هو جه يعمل dereference جه يشوف الـ address اللي هيعمله 
dereferencing لقى ++ الأول، فيروح مزود الـ address يروح على المكان اللي بعده وبعد كدة يعرض الـ value اللي عنده. 
asterisk pointer plus plus..
هنا هيستخدم الـ value الأول وبعد كدة هيـ move على الـ next position
لأن الـ plus plus هنا إيه لازقة في الـ pointer فبتديله أولوية. يعني هيستخدم الـ value ككل وبعد كدة يزود، يروح إيه على الـ next integer position. خلي بالكم آخر واحدة دي بتلخبط، أ
نا نفسي اتلخبطت فيها إيه وأنا بأحضر، Okay؟ دي بقى أنتم اعملوها في البيت، دي استحالة أعملها tracing معاكم النهاردة. أنتم عشان تقتنعوا بالحاجات دي، أنتم في البيت اعملوا practice بنفسكم جهزوا كدة pointer وحطوله قيمة، وافضلوا إيه زودوا ونقصوا وحطوا asterisk و plus plus وشوفوا القيمة اللي هتطلعلكو إيه
تمام ايوا؟
انهي؟ اخر واحدة؟ طيب، 
asterisk ptr plus plus هو لقى هنا إيه de-reference operator، 
Okay؟ عايز يجيب value، فهيعمل إيه؟ هيروح إيه جايب الـ value اللي عند الـ address ptr على طول. طيب، بعد كدة لقى الـ ++، بس الـ ++ مش هتبقى لازقة في الـ value ككل، لا، هي
 الـ ++ لازقة في كلمة ptr نفسها، فبيديها الأولوية عن إيه؟ عن الـ value.
يعني هيستخدم الـ value بتاعت الـ address اللي بيشاور عليه الـ ptr 
وبعد كده يـ increment الـ PTR يروح على الـ next integer position. 
هنشوف ليها استخدام بعد شوية. الـ Slide اللي قبليه؟ هتطلع 10 و 20. خلي بالك 
أنا بعرض الـ variables من أساميها
 First value و second value.
يبقى بنعرض استنى.. إحنا بنعرض إيه الـ 10 دي وبعد كدة الـ 20 دي.
 لو كنت قلتلك cout asterisk p1 و asterisk p2 كان الاتنين هيعرضوا 20، لأن الاتنين بيشاوروا على نفس الـ variable وهو الـ second val. لكن أنا طالما استخدمت أساميهم الأصلية خلاص يبقى هعرض ده بقيمته وهعرض ده بقيمته.
"ناخد practice لطيف على الـ increment operators.
 هنا عملنا إيه؟ عرفنا إيه array عادي جداً، الـ size بتاعه 5، static array زي ما أخدنا زمان، جواه قيم إيه 0, 1, 2, 3, 4
 من 0 لـ 4. بصوا بقى السطر ده جديد علينا، هنقول هنا int * pointer بيساوي الـ arr.
هو أنا ينفع أساوي الـ pointer بـ arr؟ فاكرين قبل كدة لما قلنا إن اسم الـ array ده عبارة عن pointer بيشاور على أول element في الـ array؟ جواه الـ address بتاع أول element في الـ array، تمام؟ إذًا هو عبارة عن address طبيعي، فأقدر أحطه جوا الـ pointer. يبقى نعرف معلومة النهاردة إن اسم الـ array هو sort of pointer.
نوع من أنواع الـ pointers كل اسم array pointer لكن مش كل pointer array، 
في اختلافات هنعرفها دلوقتي. يبقى هنا إيه بقى عندي الـ asterisk ptr هو كمان بيشاور على أول element في الـ array، شايل الـ address بتاعه. فأنا من خلال الـ ptr دلوقتي هقدر أعمل accessing للـ array elements كلها ما خلاص بقى ماسك أول element فيهم، فيقدر يلف عليهم عادي لو عملنا له increment.
تعالوا نشوف بقى الجملة دي، نشوف هل هي صح ولا لأ. 
أهو هنلف على الـ array elements نقول كل مرة asterisk plus plus ptr. دي كانت بتعمل إيه؟ أنا أخدت لكم copy أهو تحت عشان عارفة إن إحنا هنتلخبط
دي pointer moves to the next integer position الأول، وبعد كدة هتستخدم إيه الـ value اللي عندي. طيب يبقى هنا هنعمل إيه؟ دلوقتي الـ array أهو..
أهو معلش الرسمة أي كلام.. 0, 1, 2, 3, 4. كان الـ ptr أول مرة بيشاور هنا
أنا هعمل له increment الأول فهيشاور إيه على هنا، وبعد كدة آخد الـ value اللي جواه. يعني أنا في أول iteration بقيت بشاور على تاني variable أو تاني element في الـ array، فهيعرض لي إيه الـ 1. أهي أول مرة عرض الـ 1 فعلاً ما عرضش الـ 0، عمل skip للـ 0.
تاني iteration هيـ increment الـ address اللي جوه الـ pointer الأول وبعد كدة أعرض الـ value اللي جواه؛ يبقى بيشاور على تالت element هيعرضلي إيه؟ الاتنين. بعد كدة اللي بعدها التالت، اللي بعدها الرابع، نيجي بقى عند آخر iteration عند الـ i بـ 4 هيعرض إيه؟ هو كدة خرج بره حدود الـ array، خرج بره الـ boundaries بتاعت الـ array فعرضلي أي garbage كانت موجودة في الـ memory. إذًا الجملة دي اللي جوه الـ for loop مش مناسبة للـ case بتاعتنا.
إذًا، تعالوا نشوف المثال ده نفس المثال بالظبط لكن خلينا الجملة asterisk ptr plus plus ، اللي هي الأخيرة اللي كانت ملخبطانا دي. دي بتعمل إيه؟ uses value first ، 
وبعد كدة الـ pointer هيروح على الـ next integer position. يبقى هنا إيه؟ أول iteration عند الـzero، هنعرض الأول القيمة اللي بيشاور عليها الـ pointer اللي هي الـzero نفسها، وبعد كدة هيـ increment على الـ location اللي بعده.
اللي بعدها عرض الواحد وأنقل على الـlocation اللي بعدها وهكذا. هاجي عند آخر واحد خلاص أنا عرضت آخر واحد وما فيش مشكلة يبقى هنا أنا التزمت بالـ array boundaries. يبقى الجملة دي مناسبة إيه إن أنا أعرض وألف على الـ array elements. في حد مش فاهم المثال ده؟ طيب مين يحل لي دي؟ دي سهلة جداً، ياخد bonus سريع كدة...
لا قولي لي الـ final value على طول، ما تحسبيهاش.. كام؟ برافو. طيب تعالوا نشوف المثال هنا أنا عندي دلوقتي الـ i variable
 طبيعي قيمته بـ 3، وعندي pointer j،
 الـ pointer j هيشاور على الـ i، Okay؟ فالاتنين بيـ access الـ value 3. طيب cout.. تعالوا نشوف، أول واحدة i ده variable عادي طبيعي، هنكتب قيمته زي ما هي 3.
"الـ asterisk اللي بعديها دي ما ينفعش تبقى بتاعة pointer، لأن هي مش لازقة في pointer فهتبقى إيه times عادية. هناخد دي بقى تبقى بتاعة الـ j، ده pointer على بعضه؛ هو.. يبقى بنقوله إيه هاتلي الـ value بتاعة الـ variable اللي j بيشاور عليه اللي هي كام؟ 3. اللي بعديها times، وبعد كدة i نفسها بـ 3، plus asterisk j دي بـ 3.
يبقى 27 + 3 يساوي 30 في الاخر واضحة كده؟