יסודות התכנות

בנושא יסודות התכנות אנו נתעסק בהכרת הכלים הבסיסיים שיאפשרו לנו להבין כיצד הדברים עובדים ובניית תוכניות בסיסיות ביותר.

קודם כל יסודות התכנות הכרת המשתנים פיתוח אלגוריתם, התניות, לולאות, ונושאים מתקדמים כגון object oriented אלו נושאים משותפים לכל שפה.

c# php objective c java אתם לא מוגבלים בפלטפורמה אחת תוכלו תמיד להרחיב אופקים ולהיכנס לחקור סביבה חדשה.

אופרטור -אופרטור זהו סוג של פעולה שאנו מפעילים על משתנים מסוימים כמו מספרים מילים, נהוג לקרוא להם אופרנדים.      

דוגמה לאופרטור :  6 + 3 . הפעולה שנעשית פה היא  חיבור (+) זהו אופרטור שעובד על שני אופרנדים הכוונה ל 3 ו- 6 .

כל אופרטור שונה מהשני על פי 6 תכונות שמאפיינות אותו:

1. לכל אופרטור יש את הסימן שלו.

2. כמה אופרנדים האופרטור צריך.

    א. אופרטור אונארי – אופרטור שצורך רק אופרנד אחד.

      לדוגמא :  ! (סימן קריאה) זהו אופרטור שבודק ערך שונה ממה שהאופרנד מייצג.

    ב. אופרטור בינארי – אופרטור שצורך שני אופרנדים.

      לדוגמא : אופרטור + , – , / , * , % , ^ אלו אופרטורים שצריכים שני משתנים בשביל לבצע את הפעולה המאפיינת אותם.

    ג. אופרטור טרינרי – אופרטור שצורך שלושה אופרנדים ולפעמים גם ארבעה.

      לדוגמא : אמת: שקר? תנאי . במידה וההתניה תתקיים התניה יכולה להיות שני אופרנדים שאני עושה עליהם פעולה מתמטית כלשהי ורוצה לבדוק את התוצאה או שגם ההתניה יכולה להכיל אופרנד שמחזיק ערך בוליאני (זהו משתנה שיכול להכיל שני ערכים בלבד אמת, שקר),במידה וההתניה נכונה אני אקבל את הערך שנמצא ב"אמת" במידה וההתניה לא התקיימה אני אקבל את הערך שנמצא ב"שקר".

3. איזה סוג אופרנד או צריך האופרטור. לדוגמא אופרטור + צריך אופרנד מסוג מספר.

4. כל האופרטורים מטרתם לצמצם את האופרנדים לאופרנד אחד.

5. לכל האופרטורים יש תכונה אסוציאטיבית לקרוא את הכתוב. למשל בינארי ( אופרטור שצריך 2 אופרנדים) קורא את הכתוב מימין לשמאל. טרינרי ואונארי קוראים את הכתוב משמאל לימין.

6. לכל אופרטור יש את הקדימות שלו כמו במתמטיקה כפל וחילוק קודם לחיבור וחיסור.

אופרנדים

ישנם מספר סוגים שונים של אופרנדים בסיסיים ביותר שמשותפים לכל שפה.

– אופרנדים מספרים 4,3,8,9,13,41 כל ערך מספרי.

– אופרנד מסוג מחרוזת ( טקסט) –   "hello" , "click On me' כל ערך מחרוזתי יהיה עטוף בתוך גרשיים.

– אופרנד מסוג בולינאני (אמת,שקר) – מחזיק התניה למשל 4<3 התוצאה תחזיר רק שני מצבים נכון ולא נכון, משתנה בוליאני יחזיק את התוצאה של השאילתא.

הצהרה על משתנים נעשית על ידי קביעת סוג המשתנה, שם למשתנה והשמת ערך למשתנה.

דוגמא משתנה מסוג מספר נצהיר עליו בצורה כזאת :

int number = 3

int מאפיין משתנה מסוג מספר, number זה השם שנתתי למשתנה ו 3 זה הערך שהזנתי למשתנה,

כשנרצה להשתמש במשתנה שיצרנו פשוט נקרא לו בשם שלו.

number – 4

הביטוי אומר 3-4, עכשיו ניתן אופרטור – מחזיר לנו תוצאה של מספר במקרה הזה יחזור לנו המספר 1- שגם אותו נוכל לשמור בתוך משתנה, int result = number – 4.

אין לנו הגבלה על משתנים שאנו יוצרים, רק חשוב מאוד לשים לב שברגע שיצרנו משתנה ונתנו לו שם מסוים, אותו שם לא יכול לחזור על עצמו יותר מפעם אחת, לא יכול להיות מצב שקיימים מספר משתנים עם אותו שם בתוכנית.

סוגי הערכים שניתן ליצור מהם משתנים:

String – מייצג משתנה מסוג מחרוזת.  

String name = " avi " משתנה מסוג String מרמז על מחרוזת טקסט שם המשתנה name והערך avi נמצא בתוך גרשיים.

int – מייצג מספר.

char – מייצג  ערך של תו אחד.     

char digit = '3' ערכו של תו בודד להבדיל מ String יהיה בתוך גרש אחד.

אין עם זה בעיה שנתתי לc ערך מסוג מספר מכיוון שהוא יתייחס למספר כאל תו ולא כאל מספר אותו דבר אני יכול לעשות עם .String

לתת ל – name ערך "8" אני אתייחס לזה כאל מחרוזת, אני לא אוכל לעשות עם אותו ערך פעולות מתמטיות.    

boolean – מייצג ערך אמת/שקר, לדוגמא boolean test = 4<5.

יש לי התניה בדיקה של שני אופרנדים התוצאה תחזיר לי נכון או לא נכון, היא לא מחזירה לי ערך מספרי אז את התוצאה אני מחזיק בתוך test שהוא מסוג  boolean.

short – מייצג ערך מספרי כמו int רק שמבחינת זיכרון התוכנית short תופס פחות זיכרון אבל הינו מוגבל מבחינת ערך מספר שהוא מחזיק, המספר המקסימאלי ש- short יכול להחזיק הינו 32,767 והערך המינימאלי ביותר הינו 32,767- , משתנה מסוג short תופס רק 2 בתים בזיכרון להבדיל מ- int שתופס 4 בתים. לכן בשביל לחסוך מקום בזיכרון ושהתוכנית תרוץ יותר מהר כדאי להצהיר על משתנים מסוג short אבל כשאין ברירה אז אין ברירה.

     . 

long – מייצג ערך מספרי גבוה יותר מזה של int. כמו שאמרתי מקודם על short שהוא תופס פחות מקום בזיכרון, long תופס הכי הרבה מקום, 8 בתים. הערך המקסימאלי של int זה 2147483647 ו- 2147483647-, הערך להבדיל מ long יכול להחזיק מספר בעל 19 ספרות.

doube- מייצג ערך מספרי אבל להבדיל מ-int , short ו- longששלושתם מחזיקים מספר שלם double מחזיק מספר עשרוני כמו 2.5 , 3.9, 8.0.

למה אנו צריכים להשתמש בזה ? במידה ונרצה להצהיר על משתנה מסוג כסף שיתאר לנו את המצב שלנו בחשבון הבנק, אנו נצהיר על משתנה מסוג double מכיוון שנרצה לחשב גם את האגורות.     double money = 145999.99.

במידה וננסה להצהיר על משתנה מסוג מסוים וניתן לו ערך מסוג אחר נקבל שגיאת קומפילציה.

שגיאה כזאת לא תיתן לנו להריץ את התוכנית ולא תקמפל את הקוד שלנו לשפה שהמחשב מבין.

בסופו של דבר המחשב לא יודע מזה name, result ושאר המשתנים שאנו מצהירים עליהם לכן המערכת מקמפלת (מהדרת) את הקוד שלנו לשפת ביניים, שפה שלא ברורה למתכנת ולא למחשב איפשהו באמצע, מכיוון שעד לפני עשרות שנים היו לומדים פיתוח תוכנה על שפת אסמבלי זוהי השפה הכי קרובה לשפת מכונה. המתכנת היה כותב קטע קוד ומתאים את התוכנית שלו לאותו מחשב ספציפי שהיה עובד עליו בהתאם למעבד, ולזיכרון וכדומה, היו צריכים לפתח לכל דגם של מחשב את אותה התוכנה, עם השנים פיתחו שפות מתקדמות ומערכות שמהדרות את הקוד לשפה משותפת בין כל המחשבים ובהתאם לאותו מחשב הקוד מתקמפל בהתאם לשפת מכונה.

שפת הביניים זוהי גם שפה שבאה להגן על הקוד שלנו, בין היתר במקום להחזיק בקוד המקור ולהעביר אותו בין מחשב למחשב שהאנשים יוכלו לראות אותו ולהעתיק אותו, כמו- כן זוהי שפה שלא ניתן להבין אותה, ישנם תוכנות שיכולות להמיר בחזרה משפת מכונה לקוד מקור.

שפת מכונה בסופו של דבר זהו קוד בינארי המבוסס על שני מספרים 1,0.

הזיכרון שלנו מחולק לבתים כל בית אחד מחולק ל 8 סיביות מ 0 עד ל 128 חיובי ו 127 שלילי

            1     2     4     8     16    32    64    -127

במידה ונצהיר על משתנה מסוג int number = 6 אז המערכת תקמפל את הקוד ותסמן באמצעות הספרה 1 את הסיביות שהיא צריכה בשביל אותו משתנה.

בשביל ליצור את הספרה 6 בסיבית 2 תופיע הספרה 1 וכנ"ל גם ב 4 ושאר הסיביות יקבלו את הספרה 0 שמסמנת חוסר שימוש באותו תא.

דוגמא לשגיאת קומפילציה :

String age = 4

המערכת מתייחסת ל- 4 כאל מספר ולא ניתן להכניס ערך מספרי לתוך משתנה מסוג מחרוזת.

אבל כן אפשר להתייחס ל- 4 גם כאל מחרוזת טקסט על ידי הוספת גרשיים –  "String age = "4 .

*בחירה שלכם איזה שם לתת למשתנה.

*כל סוף פקודה חייבת להסתיים בסימן פסיק נקודה. למשל:  "String name = "avi ;

כמו לכל שפה רגילה גם לשפת תכנות יש את התחביר שלה שמאפיין אותה.

קיימים מספר סוגי תחבירים בסיסיים המשותפים לכל השפות :

if – התניה מובנית שמקבלת איזשהו ערך בוליאני, ובמידה והערך הבוליאני מחזיר ערך חיובי (אמת) אז נוכל להגדיר איזשהו קטע קוד שיתבצע בהתאם, ובמידה ולא אז זה לא יתבצע.

      לדוגמא :

boolean test = 4<3;

if(test==true)  //checking if the condition is true

                                                            }

code//

                                                            {

כל מה שנמצא בתוך הסוגריים המסולסלים יתבצע רק במידה וההתניה תחזיר ערך חיובי.

switch –  מאפשר לנו לבחון את המשתנה ולבצע בהתאם לערך שלו את פעולה מסויימת.

      לדוגמא :

int number = 4

switch(number)// check the vakue of number

                                          }

case 3:

here i write the code //

break;     

case 8:    

here i write the code //

break;

default

break;

                                          {

בסוגריים העגולים של הswitch הכנסתי את הערך שאותו אני רוצה לבחון במקרה הזה זהו number שערכו שווה ל 4. לאחר מכן אני הצהרתי על case שזאת מילה שמורה במערכת שפירושה פתיחת "תיק" לבדיקה הכוונה שיש פה ערך מסויים לבדוק ואחרי המילה case הכנסתי את הערך שעליו אני רוצה לעשות את הבדיקה . במקרה הראשון אני בודק אם number שווה ל ערך 3 במידה ולא התוכנית תמשיך לcase הבא במידה וכן אז היא תבצע את הקטע קוד שאני אכתוב לה, המילה break יוצאת מהבדיקה ולא ממשיכה ל case הבא רק אם אותו case יתבצע. יש לנו אפשרות לבצע גם קטע קוד מסויים במידה ושום תנאי לא התקיים קטע קוד default יתקיים כברירת מחדל.

for – לולאה. לולאה זה קטע קוד שנרצה להריץ אותו מספר פעמים.

אם ארצה להדפיס את המחרוזת "hello" ארבע פעמים אז במקום לכתוב ארבע פעמים את אותו קטע קוד אני אצור לולאה שתרוץ ארבע פעמים וכל איטרציה (סבב) תדפיס פעם אחת את המחרוזת. זה נועד כדי לחסוך לנו כתיבת קוד שחוזר על עצמו.

      לדוגמא :

for(int i = 0; i<4 ; i++)//example for

                                                }

the code will be here

                                                {          

אז ככה הצהרתי על לולאה מסוג for (קיימות עוד כמה סוגי לולאות ), ומיד אחר כך פתחתי סוגריים והצהרתי על משתנה בשם  i סוג int ואתחלתי אותו בערך 0, שישמש לנו כאינדקס ויסמן לנו את מספר האיטרציה, לאחר מכן אחרי פסיק נקודה הצהרתי על תנאי שכל עוד התנאי מתקיים הלולאה תתקיים. אנחנו חייבים תנאי עצירה בשביל לשבור באיזשהו שלב את הלולאה שהתכנית תמשיך הלאה אחרת תהיה לנו כאן לולאה אין סופית שתמשיך להתקיים עד שהזיכרון של התוכנית תתמלא ותקרוס (overloading ), בסוף האיטרציה המשתנה i יקודם בערך 1 i++ זהו כתיב מקוצר ל :

i =i +1

ההצהרה על המשתנה תתקיים רק פעם אחת, ובאיטרציה השנייה המערכת תדלג ישר אל התנאי.

ככה הלולאה תרוץ עד שערכו של i יהיה שווה ל 4 והתנאי יהיה 4<4 כמובן שהתנאי יחזיר ערך בוליאני שערכו false והמערכת לא תיכנס לתוך גוף הלולאה.                    

while – לולאה נוספת די דומה ל- for, ההבדל ביניהם הוא שב- for מספר האיטרציות ידוע לי מראש, וב- while מספר האיטרציות אינו ידוע לי. בדוגמא הקודמת ראינו שהלולאה רצה לי כל עוד התנאי מתקיים ש i קטן מ 4, זאת אומרת שידענו כמה איטרציות יהיו ב- while התנאי יהיה בדרך כלל בקלט מהמשתמש או באיזשהו גורם חיצוני שישפיע על התוכנית שלנו.

      דוגמת קוד :

String line = "in";

while( in !="bye bye")//example while

                                          }

                        כאן אני אכתוב את הקוד

                                          {

הצהרתי על המילה while וסוגריים עגולים שבתוכם אני הכנסתי את התנאי שלי, הלולאה תרוץ כל עוד התנאי מחזיר את הערך true, במקרה הזה הצהרתי על משתנה מסוג String ונתתי לו את הערך in ובתנאי אני שואל אם המשתנה אינו שווה למחרוזת bye bye. כל עוד התנאי מתקיים אז גוף הלולאה תתבצע רק שיש פה בעיה אחת שנוצרה לי פה לולאה אין סופית מכיוון שהערך של המשתנה נשאר קבוע, לכן אני אדאג לשנות את הערך בתוך גוף הלולאה, אתן למשתמש להכניס ערך ואשמור אותו בתוך המשתנה שהצהרתי ככה שכל איטרציה התנאי יבדוק ערך, ככה אנו לא יודעים בדיוק כמה איטרציות הלולאה תבצע אנחנו יודעים רק שכל עוד המשתמש לא הזין את המחרוזת bye bye הלולאה תרוץ. המחרוזת bye bye אינה שונה מהמחרוזת bye bye לכן התנאי לא התקיים והמערכת תמשיך בתוכנית כרגיל.