יסודות התכנות בשפת C#‎

3.1 מבוא

בתכנות בשפת סי שארפ, הנחשבת לשפה מונחית עצמים, אנו כותבים את התוכנית שלנו בעורך ויז'ואל סטודיו. לפני שמתחילים לתכנת, עלינו להבחין בין כמה מונחים, והם:

(א) הוראה (Instruction)

(ב) המתכנת (Programmer)

(ג) תוכנה (Program)

(ד) המשתמש (User)

(ה) פלט מחלקת קונסול (Console output)

3.2 התוכנית הראשונה

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main()
        {




        }
    }
}

כדי להתאמן בכתיבת התוכנית הראשונה שלנו, נלמד את פקודת ההדפסה למסך הבאה:

והפקודה:

static void Main(string[] args)
{
    Console.WriteLine("Hello Class 10 .");
}

Console.ReadLine();

Hello Class 10 .

static void Main(string[] args)
{
    Console.Write("My name is Hammam.");
    Console.Write("I am from Jatt.");
    Console.Write("My age is: 39.");
}

My name is Hammam.I am from Jatt.My age is: 39.

My name is Hammam.
I am from Jatt.
My age is: 39.

3.3 משתנים

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

לכל משתנה יש:

(a) טיפוס

(b) שם. (מקומו בזיכרון מזוהה לפי השם שאנו נותנים לו).

(c) ערך. (הנתונים או המידע השמורים במשתנה (הערך שבתוך הזיכרון)).

(a) טיפוס:

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

(b) שם המשתנה:

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

עדיף לתת למשתנים שאנו משתמשים בהם שמות הגיוניים ובעלי משמעות. למשל, אם נרצה לשמור את ציון התלמיד במבחן, עדיף ששם המשתנה יהיה mark, וכן הלאה ...

כללים לבחירת שם המשתנה:

1) שם המשתנה חייב להתחיל באות או בקו תחתון _

2) אסור ששם המשתנה יכלול תווים (%, *, !, # ...) או רווחים. (מותר רק הקו התחתון)

3) אסור שיכיל מילה שמורה של שפת סי שארפ (למשל אסורה המילה int ואסורה המילה if, וכן הלאה..)

(c) ערך המשתנה:

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

הגדרת המשתנה (הכרזה על המשתנה):

עלינו להגדיר את המשתנים לפני שמשתמשים בהם בתכנות, ועדיף שהגדרת המשתנים תהיה בשורות הראשונות בתוך הפעולה Main שבה אנו משתמשים.

הגדרת המשתנה נעשית כך:

int n1;

double t ;

יש לתת למשתנה ערך התחלתי או ערך שנקלט מן המשתמש, והדבר נעשה באמצעות הפעולה =

אופרטור = : זו פעולת ההשמה של הערכים הנמצאים מימין לסימן אל תוך (ב) המשתנה הנמצא משמאל לסימן.

אם נותנים למשתנה ערך התחלתי, הדבר נקרא "אתחול" ואפשר לעשות זאת כך:

(1) הגדרת המשתנה.

(2) נותנים לו ערך התחלתי.

int x;
x = 4;

אפשר גם להגדיר את המשתנה ולאתחל אותו יחד.

int x=-4;

כל משתנה שלא ניתן לו ערך התחלתי, או שלא הוזן לתוכו ערך מן המשתמש, מכיל נתונים חסרי משמעות (זבל).

int x = 4, y;

int x,y;

int x;
int y;

int n;
double a;

int x;
int y;
x = 4;
y = -5;

int x, y;
x = 4;
y = -5;

int x = 4, y = -5;

int x = 4;
int y = -5;

קלט, פלט ומשתנים:

קלט <— תוכנית <— פלט

3.4 פלט

כרגע, פעולת הפלט היא פעולת ההדפסה על מסך Console, כלומר התוכנית מדפיסה מידע על המסך השחור.

פקודת ההדפסה על מסך Console (פלט) היא Write או הפקודה WriteLine, באופן הבא:

א. Console.Write: הדפסה בלי שהסמן יורד שורה.

ב. Console.WriteLine: הדפסה שבה הסמן יורד בסוף פעולת Write לשורה חדשה.

בקיצור:

WriteLine פועלת כמו Write, אך מורידה את הסמן לשורה חדשה בסוף פעולת הפונקציה.

צורות ההדפסה על המסך:

1> Console.Write("המחרוזת");

2> Console.Write("מחרוזת1" + "מחרוזת2");

3> Console.Write("מחרוזת {0} המשך המחרוזת {1} המשך המחרוזת", משתנה שנדפיס את ערכו במקום {0}, משתנה שנדפיס את ערכו במקום {1});

4> Console.Write("מחרוזת1" + שם המשתנה שנדפיס את ערכו + "מחרוזת2" + שם המשתנה שנדפיס את ערכו);

5> Console.Write(שם המשתנה);

3.5 קלט

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

פעולת הקלט היא ReadLine()‎ , והיא פעולה לקליטת נתונים ומידע מן המשתמש דרך מסך Console

Console.ReadLine();

והיא פקודה לקליטת מחרוזת (string) מן המשתמש דרך מסך Console.

כדי לקלוט כל טיפוס אחר, יש להמיר את המחרוזת לטיפוס הנדרש באמצעות הפעולה Parse בצורה הבאה:

double.Parse(Console.ReadLine());

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

1. קליטת מחרוזת:

(המשתנה חייב להיות מוגדר מראש לפני שמשתמשים בו)

2. כל טיפוס אחר: (int, double, char,byte….):

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

x = int.Parse(Console.ReadLine());

משפט בקשה הוא משפט שבו אנו מבקשים מן המשתמש להזין נתונים לפי הנדרש. למשל, נדפיס לו על המסך: "הכנס שנת לידה: " אם נרצה לקלוט את השנה שבה המשתמש נולד.

משפט הסבר מדפיסים כאשר מדפיסים תוצאה מסוימת או פלט בתוכנית. למשל, אם הדפסנו למשתמש את גילו, נכתוב על המסך: " גילך הוא : "

3.6 תיעוד

אפשר להוסיף לתוכנית הערות או תגובות (בין הפקודות) בלי להשפיע על התכנות. ההערות האלה מסבירות את דרך הפתרון שלנו או מפרשות חלק מן הפקודות, והמחשב אינו מתייחס אליהן.

הוספת ההערות נעשית באמצעות // : שמים את שני הקווים הנטויים האלה, וכל מה שנכתב אחריהם באותה שורה נחשב הערה, והמחשב אינו מתייחס אליו ואינו לוקח אותו בחשבון. אפשר לכתוב את ההערות שלנו אחרי שני הקווים האלה בכל שורה, בכל שפה שנרצה.

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

כמו כן, אפשר לבטל שורות תכנות אם מוסיפים אותם לפני השורות האלה.

static void Main(string[] args)
{
    // This Program by: המאם ותד
    int d = 31; // my birth day.
    int m = 5; // my birth month.
    //d = 300;
    //m = int.Parse(Console.ReadLine());
    Console.WriteLine("Hammam"); // remark - הערה// still...
    Console.WriteLine(d);
    Console.WriteLine("m");
}

Hammam
31
m

אך אם נרצה לבטל פסקה שלמה, או להוסיף הערות המשתרעות על יותר משורה אחת ולא רק על שורה אחת, נשתמש בסימנים /* */ : כל מה שנמצא בין הסימן /* לבין הסימן */ שסוגר אותו נחשב הערה, המחשב אינו מחשיב אותו כקוד והוא אינו נחשב חלק מן התוכנית.

static void Main(string[] args)
{
    // This Program by: המאם ותד
    int d = 31; // my birth day.
    int m = 5; // my birth month.
    /*d = 300;
    m = int.Parse(Console.ReadLine());*/
    Console.WriteLine("Hammam"); // remark - הערה// still...
    Console.WriteLine(d);
    Console.WriteLine("m");/* אפשר להשתמש בזה גם באותה שורה */
    Console.WriteLine("End");
}

3.7 מחרוזות

המחרוזות שנשמרות במשתנה מטיפוס string הן קבוצה של תווים מן המקלדת המסודרים זה לצד זה, והן קיימות בכל הטקסטים של המחשבים (UNICODE).

הגדרת משתנה מטיפוס string:

כמובן, זו הכרזה על המשתנה, אך הוא אינו מכיל ערך בעל משמעות (יש בו זבל). לכן כדאי לתת לו ערך התחלתי או לקלוט ערך מן המשתמש ולשמור אותו בו.

• מתן ערך התחלתי נעשה כך:

string name = "Hammam";

string name;
name = "Hammam";

• קליטה מן המשתמש:

נשים לב שקליטת נתונים מטיפוס string נעשית באמצעות Console.ReadLine()‎ ואין צורך להשתמש בפעולה Parse

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

string name;
Console.Write("Insert your name: "); // משפט בקשה
name = Console.ReadLine();

הדפסת מחרוזות נעשית באמצעות Console.Write( )‎ כפי שלמדנו קודם, וכך גם הדפסת הערך של משתנים מטיפוס string

1> Console.Write("המחרוזת");

2> Console.Write("מחרוזת1" + "מחרוזת2");

3> Console.Write("מחרוזת {0} המשך המחרוזת {1} המשך המחרוזת", משתנה שנדפיס את ערכו במקום {0}, משתנה שנדפיס את ערכו במקום {1});

4> Console.Write("מחרוזת1" + שם המשתנה שנדפיס את ערכו + "מחרוזת2" + שם המשתנה שנדפיס את ערכו);

5> Console.Write(שם המשתנה);

static void Main(string[] args)
{
    string first_name, last_name;
    Console.WriteLine("Please enter your first name: ");
    first_name = Console.ReadLine();
    Console.WriteLine("Please enter your last name: ");
    last_name = Console.ReadLine();
    Console.WriteLine("{0} {1}", first_name, last_name);
}

Please enter your first name:
Hammam
Please enter your last name:
Hamad
Hammam Hamad

תווים מיוחדים להדפסה בתוך מחרוזת באמצעות הקו הנטוי backslash:

static void Main(string[] args)
{
    string name="Hammam";
    string town = "Jatt";
    Console.Write("My name is {0}.\nI live in {1}.\n",name,town);
    Console.Write("My father saied: \"Hello\"");
    Console.WriteLine("\nnoting to fear\\nothing to fear!");
}

My name is Hammam.
I live in Jatt.
My father saied: "Hello"
noting to fear\nothing to fear!

שרשור במשתנים מטיפוס מחרוזת:

הפעולה + במשתנים מטיפוס מחרוזת משמשת לחיבור מחרוזות זו לזו (להדבקתן זו לזו), וגם להדבקת ערך של משתנה למחרוזת.

string+string ➔ string

string+משתנה ➔ string

משתנה+string ➔ string

static void Main(string[] args)
{
  string str1 = "Hammam";
  string str2 = "Wattad";
  string str3 = " ";
  int age = 39;
  string s1, s2, s3, s4,s5;
  s1 = str1 + str2;              // "Hammam"+"Wattad" => "HammamWattad"
  s2 = str1 + str3 + str2;       //"Hammam"+" "+"Wattad"=>"Hammam Wattad"
  s3 = "my age is" + age;        //"my age is39
  s4 = "my age is " + age;       //"my age is 39"
  s5 = "my age is" + str3 + age; //"my age is 39"
  Console.WriteLine("s1={0}",s1);
  Console.WriteLine("s2="+s2);
  Console.WriteLine("s3=" + s3);
  Console.WriteLine("s4={0}",s4);
  Console.WriteLine("s5=" + s5);
  Console.WriteLine(str1+" "+str2+"\nMy age is "+age); //Hammam Wattad
                                                       //My age is 39
}

static void Main(string[] args)
{
    Console.Write("C:\users\windows:");//שגיאה כי הוא מבין \כתו מיוחד
    Console.Write(@"C:\users\windows:"); // מחרוזת תקינה
    Console.Write("C:\new\timer:"); // \הוא תו מיוחד
    Console.WriteLine(@"C:\new\timer:");
}

3.8 מספרים שלמים

הנתונים והמידע מטיפוס int הם מספרים שלמים (בלי שברים או נקודה עשרונית) בתחום: -2,147,483,648 עד 2,147,483,647 . כדי לשמור מספרים אלה בזיכרון נדרשים 4 byte, כלומר 32 bit, והם 32 סיביות שבהן המספר נשמר בבסיס הבינארי (בסיס הספירה של המחשב).

הגדרת משתנה מטיפוס int:

כמובן, זו הכרזה על המשתנה, אך הוא אינו מכיל ערך בעל משמעות. (יש בו זבל) לכן כדאי לתת לו ערך התחלתי או לקלוט ערך מן המשתמש ולשמור אותו בו.

• מתן ערך התחלתי נעשה כך:

int x = 6;

int birth_year;
birth_year = 1984;

• קליטה מן המשתמש:

נשים לב שקליטת נתונים מן המשתמש היא מטיפוס string, והיא נעשית באמצעות Console.ReadLine()‎. לכן אנו משתמשים בפעולה Parse כדי להמיר את הנתונים ממחרוזת למספרים שלמים שאפשר לעבוד איתם בחישובים ובמתמטיקה (הכפופים לכללי החשבון).

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

int mark;
Console.Write("Insert your mark: "); // משפט בקשה
mark = int.Parse(Console.ReadLine());

הדפסת ערכי המשתנים נעשית באמצעות Console.Write( )‎ כפי שלמדנו קודם, וזאת כך:

Console.Write("מחרוזת {0} המשך המחרוזת {1} המשך המחרוזת", משתנה שנדפיס את ערכו במקום {0}, משתנה שנדפיס את ערכו במקום {1});

Console.Write("מחרוזת1" + שם המשתנה שנדפיס את ערכו + "מחרוזת2" + שם המשתנה שנדפיס את ערכו);

Console.Write(שם המשתנה);

static void Main(string[] args)
{
    int positive, negative , id=398201;
    Console.Write("Insert a positive number: "); // משפט בקשה
    positive = int.Parse(Console.ReadLine());

    Console.Write("Insert a negative number: "); // משפט בקשה
    negative = int.Parse(Console.ReadLine());

    Console.WriteLine("Positive number is:{0} and negative number is:{1}",positive,negative);
    Console.WriteLine("Positive number is:" + positive + " and negative number is:" + negative);
    Console.Write("Your id number is: ");
    Console.WriteLine(id);
}

Insert a positive number: 5
Insert a negative number: -2
Positive number is:5 and negative number is:-2
Positive number is:5 and negative number is:-2
Your id number is: 398201

3.9 מספרים ממשיים

הנתונים והמידע מטיפוס double הם מספרים ממשיים (הכוללים גם מספרים שלמים), ודיוק התצוגה של הספרות העשרוניות מגיע עד 15 ספרות אחרי הנקודה העשרונית. כדי לשמור מספרים אלה בזיכרון נדרשים 8 byte, כלומר 64 bit, והם 64 סיביות שבהן המספר נשמר בבסיס הבינארי (בסיס הספירה של המחשב).

הגדרת משתנה מטיפוס double:

כמובן, זו הכרזה על המשתנה, אך הוא אינו מכיל ערך בעל משמעות (יש בו זבל). לכן כדאי לתת לו ערך התחלתי או לקלוט ערך מן המשתמש ולשמור אותו בו.

• מתן ערך התחלתי נעשה כך:

double a, b = -5, c = 2.5;
a = -14.678;

• קליטה מן המשתמש:

נשים לב שקליטת נתונים מן המשתמש היא מטיפוס string, והיא נעשית באמצעות Console.ReadLine()‎. לכן אנו משתמשים בפעולה Parse כדי להמיר את הנתונים ממחרוזת למספרים ממשיים double שאפשר לעבוד איתם בחישובים ובמתמטיקה (הכפופים לכללי החשבון).

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

double tall;
Console.Write("Insert your tall in [m] units: "); // משפט בקשה
tall = double.Parse(Console.ReadLine());

הדפסת ערכי המשתנים נעשית באמצעות Console.Write( )‎ כפי שלמדנו קודם, וזאת כך:

Console.Write("מחרוזת {0} המשך המחרוזת {1} המשך המחרוזת", משתנה שנדפיס את ערכו במקום {0}, משתנה שנדפיס את ערכו במקום {1});

Console.Write("מחרוזת1" + שם המשתנה שנדפיס את ערכו + "מחרוזת2" + שם המשתנה שנדפיס את ערכו);

Console.Write(שם המשתנה);

static void Main(string[] args)
{
    double num;
    Console.Write("Please insert a number: ");
    num = double.Parse(Console.ReadLine());
    Console.WriteLine("You inserted the number: ");
    Console.WriteLine(num);
}

Please insert a number: 5
You inserted the number:
5

הדפסת מספר מוגדר של ספרות אחרי הנקודה העשרונית (דיוק תצוגת המספר על המסך):

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

static void Main(string[] args)
{
    double a,b=10,c=3;
    double d,e;

    a = Math.Sqrt(2); //a פעולה ששמה את השורש של המספר 2 במשתנה
    d = b / c;
    e = c / b;
    Console.WriteLine("a={0},b={1},c={2},d={3},e={4}",a,b,c,d,e);
    Console.WriteLine("This code written by: Hammam Wattad.");
}

a=1.4142135623730951,b=10,c=3,d=3.3333333333333335,e=0.3
This code written by: Hammam Wattad.

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

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

מספר הספרות העשרוניות:F

למשל: {0:F1} המשתנה יוצג בדיוק של ספרה אחת בלבד אחרי הנקודה העשרונית.

{0:F2} המשתנה יוצג בדיוק של שתי ספרות אחרי הנקודה העשרונית. וכן הלאה...

static void Main(string[] args)
{
    double a,b=10,c=3;
    double d,e;

    a = Math.Sqrt(2); //a פעולה ששמה את השורש של המספר 2 במשתנה
    d = b / c;
    e = 3.0 / 10;
    Console.WriteLine("a={0:F3},b={1},c={2:F1},d={3:F0},e={4:F2}",a,b,c,d,e);
    Console.WriteLine("This code written by: Hammam Wattad.");
}

a=1.414,b=10,c=3.0,d=3,e=0.30
This code written by: Hammam Wattad.

3.10 בית

בית בזיכרון הוא מקום שיש בו 8 סיביות (8 bit). לכן כל משתנה שמוגדר מטיפוס בית (byte) יכול להכיל מספרים שלמים בתחום (0 עד 255).

המספר הקטן ביותר:

המספר הגדול ביותר:

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

למשל, נרצה להגדיר משתנה בשם num מהטיפוס byte:

byte num;

קליטת מספר מן המשתמש לתוך משתנה מטיפוס בית נעשית באמצעות הפקודה הבאה:

המספר חייב להיות שלם וחיובי בתחום 0 עד 255.

הדפסת הערך של משתנה בשם num מטיפוס בית נעשית באמצעות Console.Write כמקובל. למשל:

Console.WriteLine("the value of num is: {0}",num);

או באמצעות פעולת חיבור הטקסטים + (שרשור):

Console.WriteLine("the value of num is: "+num);

static void Main(string[] args)
{
    byte n1 = 0, n2 = 100, mark;
    Console.Write("insert your final bagrot physics mark: "); // משפט בקשה
    mark = byte.Parse(Console.ReadLine());

    Console.WriteLine("Minimum mark:{0} ,maximum mark:"+n2,n1);
    Console.WriteLine("You got: {0}",mark);
}

insert your final bagrot physics mark: 97
Minimum mark:0 ,maximum mark:100
You got: 97

3.11 פעולות חשבון וטבלת מעקב

3.11.1 פעולות החשבון ב-C#‎

אסטרטגיה לפתרון בעיות בתכנות:

1) עלינו להבין נכון את השאלה ואת הנדרש מאיתנו.

2) עלינו לקבוע באילו משתנים נשתמש.

3) עלינו לדעת את החישובים שמובילים לפתרון או את האלגוריתם.

area= width*length ;
perimeter = 2 * (width + length) ;

static void Main(string[] args)
{
    double width, length, area, perimeter;

    Console.WriteLine("Please insert width:");
    width = double.Parse(Console.ReadLine());
    Console.WriteLine("Please insert length:");
    length = double.Parse(Console.ReadLine());

    perimeter = 2 * (width + length);
    Console.WriteLine("the perimeter is : {0}", perimeter);
    area = (width * length);

    Console.WriteLine("the area is:{0}", area);
}

3.11.2 טבלת מעקב

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

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

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

בסיום הביצוע של כל פקודה (הנמצאת בשורה) רושמים בשורה זו, בכל עמודה, מה ערכי המשתנים ומה הודפס על המסך, וזאת בסיום ביצוע הפקודה, וכן הלאה

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

3.12 חילוק שלמים, המרה ושארית

3.12.1 חילוק מספרים שלמים והמרה casting

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

פעולות החשבון שמתבצעות בין מספרים שלמים (int) תוצאתן int, ומכאן שחילוק מספרים שלמים הוא בהכרח מספר שלם בשפת סי שארפ.

דוגמה:

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

9 / 2 = 4
9.0 / 2 = 4.5
9 / 2.0 = 4.5

באותו אופן, אם משתמשים במשתנים, חילוק של משתנים מטיפוס int ייתן בהכרח מספר שלם (int), גם אם נשמור אותו בתוך משתנה מטיפוס double.

static void Main(string[] args)
{
    int a = 7;
    int b = 2;
    double result;
    result = a/ b;
    Console.WriteLine("result = {0}",result);
    Console.WriteLine("Written By:Hammam");
}

result = 3
Written By:Hammam

לכן עלינו להמיר ( casting ) את הטיפוס של אחד הנתונים כך שיהיה מספר ממשי double, כי כולם מטיפוס מספר שלם int, וכך נבטיח שהתוצאה תהיה מטיפוס מספרים ממשיים double. אך יש לשים לב שאיננו יכולים לשמור אותה במשתנים מטיפוס int (Error), כי אי אפשר לשמור מספר ממשי double במשתנה מטיפוס שלם int. לכן עלינו לשמור אותה במשתנה מטיפוס ממשי double.

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

static void Main(string[] args)
{
    Console.WriteLine("Example By:Hammam");
    int a = 7;
    int b = 2;
    int result1;
    double result2;
    // result1 = (double) a / b;  Error ---> שגיאת תכנות
    result2 = (double)a / b;  // we can write: result2 = a/(double) b;
    Console.WriteLine("result = {0}",result2);
}

Example By:Hammam
result = 3.5

static void Main(string[] args)
{
    int num1,num2;
    double res;
    Console.Write("Insert the first number: ");
    num1 = int.Parse(Console.ReadLine());

    Console.Write("Insert the second number: ");
    num2 = int.Parse(Console.ReadLine());

    res = (double) num1 / num2;
    Console.WriteLine("{0}/{1} = {2}",num1,num2,res);
    Console.WriteLine("Written By: Hammam.");
}

Insert the first number: 12
Insert the second number: 8
12/8 = 1.5
Written By: Hammam.

חילוק של כל מספר שלם ב-10 נותן מספר שיש בו ספרה אחת פחות: ספרת האחדות של המספר המקורי נקטעת, והתוצאה היא מספר חדש קצר בספרה אחת (בלי ספרת האחדות שלו שנקטעה).

חילוק של כל מספר שלם ב-100 נותן מספר שיש בו שתי ספרות פחות: ספרת האחדות וספרת העשרות של המספר המקורי נקטעות, והתוצאה היא מספר חדש קצר בשתי ספרות (בלי ספרת האחדות וספרת העשרות שלו שנקטעו).

360123 / 100 = 3601
 -67 / 100 = 0
-100/100 = -1
 104 / 100 = 1
-8731/100=-87

912/10 = 91
3401/10 =340
-3560/10 =-356
 7/10 = 0

3.12.2 שארית

בשפת התכנות C#‎ יש פעולה שנותנת את השארית של חילוק מספר שלם במספר שלם אחר, והיא: %

הפעולה % נקראת פעולת השארית (מודולו), והיא נותנת לנו את השארית של חילוק המספר השלם הראשון במספר השלם השני.

כללים:

• אם a מתחלק ב-b בלי שארית, התוצאה של הפעולה a מודולו b היא אפס, כלומר: a % b = 0
• כל מספר זוגי מתחלק ב-2 בלי שארית, ולכן מספר זוגי מודולו 2 התוצאה אפס (אין שארית).
• אם התוצאה של החישוב הבא: מספר מסוים מודולו 2 היא אפס, אז המספר הזה זוגי (כי הוא מתחלק ב-2).
• מספר אי-זוגי מודולו 2 נותן תוצאה 1 (השארית 1).
• כל מספר % n = {0,1,2,3,…..,n-2,n-1}
• 9 % 4 = {0 or 1 or 2 or 3}

static void Main(string[] args)
{
    int num, res;
    Console.WriteLine("Insert a number: ");
    num = int.Parse(Console.ReadLine());
    res = num % 7;
    Console.WriteLine("{0} % 7 is {1}",num,res);
    Console.WriteLine("Written by Hammam");
}

Insert a number:
23
23 % 7 is 2
Written by Hammam

static void Main(string[] args)
{
    int seashells, remainders, bags;
    Console.Write("Insert number of seashells: ");
    seashells = int.Parse(Console.ReadLine());
    bags = seashells / 15;
    remainders = seashells % 15;
    Console.WriteLine("Number of bags:{0}", bags);
    Console.WriteLine("Number of seashells without bags:{0}",remainders);
    Console.WriteLine("Written By Hammam!");
}

Insert number of seashells: 50
Number of bags:3
Number of seashells without bags:5
Written By Hammam!

static void Main(string[] args)
{
    int num, ones, tens, hundreds, sum, rev_num, square;
    Console.WriteLine("Insert a number:");
    num = int.Parse(Console.ReadLine());
    ones = num % 10;
    num = num / 10;
    tens = num % 10;
    num = num / 10;
    hundreds = num % 10; // hundreds = num;
    sum = ones + tens + hundreds;
    rev_num = ones * 100 + tens * 10 + hundreds;
    square = rev_num * rev_num; // Math.Pow(rev_num,2)
    Console.WriteLine("Sum of the digits: {0}",sum);
    Console.WriteLine("Reverse number: {0}",rev_num);
    Console.WriteLine("Square of reverse number:{0}",square);
}

Insert a number:
496
Sum of the digits: 19
Reverse number: 694
Square of reverse number:481636

3.13 פעולות מקוצרות

++ ו -- חלים רק על המספר 1 (כלומר מותר להוסיף 1 ומותר להחסיר 1, אך מעבר לכך לא)

כלומר אסור i++++; ואסור i----;

מותר גם להשתמש ב-++i; וב---i;, כלומר לשים את הסימן + + או הסימן - - לפני שם המשתנה, וכאן ההבדל יהיה בערך של הביטוי כולו, וזה יובהר בדוגמה הבאה:

int a,b,i = 3, j = 3;
a = i++;
b = ++j;
Console.WriteLine("i={0}",i);
Console.WriteLine("j={0}",j);
Console.WriteLine("a={0}",a);
Console.WriteLine("b={0}",b);

i=4
j=4
a=3
b=4

כפי שנראה מן הדוגמה, כאשר שמים את סימן הקידום מימין למשתנה (כמו ++i), ערך הביטוי יהיה ערך המשתנה לפני פעולת הקידום ב-1 (כמובן שהמשתנה יתקדם ב-1 בכל מקרה).

ואילו כאשר שמים את סימן הקידום משמאל למשתנה (כמו i++ ), ערך הביטוי יהיה ערך המשתנה אחרי פעולת הקידום ב-1 (כמובן שהמשתנה יתקדם ב-1 בכל מקרה).

(3) יש גם פעולות חשבון שבהן מתבצעת פעולת החשבון עם ערך המשתנה (הערך הנוכחי), ואחרי ביצוע הפעולה ערך המשתנה מתעדכן ומשתנה לערך חדש. והן:

3.14 המחלקה Math

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

דוגמה:

• פעולת הערך המוחלט   |X|
• פעולת השורש   X
• פעולת החזקה   X^y
• פעולת הגדול MAX   Max(X,Y)

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

דרך השימוש בה:

static void Main(string[] args)
{
    double a,b;
    Console.Write("Insert a number: ");
    a = double.Parse(Console.ReadLine());
    Console.Write("Insert another number: ");
    b = double.Parse(Console.ReadLine());
    Console.WriteLine("The maximum is: {0}",Math.Max(a,b));
    Console.WriteLine("Written By Hammam!");
}

Insert a number: -3
Insert another number: -1.9
The maximum is: -1.9
Written By Hammam!

3.15 תווים

3.15.1 עבודה עם תווים

התווים והאותיות הם טיפוס נתונים שאנו מקבלים מן המקלדת, והם מוגדרים בשם char.

הגדרת משתנה מטיפוס char:

char x ;

אתחול המשתנה:

1. שימוש בגרש ' '   דוגמה:

char tav = '$';

2. שימוש בקוד המספרי של התו (לפי טבלת ASCII)

char tav = (char) 36;

אי אפשר לשמור מספר שלם (int) בתוך משתנה מטיפוס char, ולכן יש להמיר את המספר לטיפוס תו (char) באמצעות casting כפי שלמדנו קודם.

קליטת ערך למשתנה מטיפוס char:

ch = char.Parse(Console.ReadLine());

נקלט תו אחד בלבד.

הדפסת נתונים מטיפוס תו (char):

Console.WriteLine(x); // x מוגדר כטיפוס char

מודפס הערך של x, והוא התו השמור בתוך x .

Console.WriteLine((char)36);

מודפס התו המתאים למספר 36, והוא $ . (לפי טבלת המספרים של התווים, הנקראת ASCII)

בהדפסה אפשר להשתמש ב-{0} וב-{1} כפי שלמדנו עם שאר טיפוסי הנתונים.

static void Main(string[] args)
{
  char rmz;
  Console.Write("Insert a character: ");
  rmz = char.Parse(Console.ReadLine());
  Console.WriteLine("Your char is: {0}",rmz);
}

Insert a character: E
Your char is: E

המשתמש יכול להזין תו אחד ואז ללחוץ על Enter . דוגמה: * ואז Enter, או כפי שהזנו את התו E ואז Enter, אך אם המשתמש יזין יותר מתו אחד לפני שילחץ על Enter, תהיה לנו שגיאת תכנות (Error), כי המחשב אינו יכול להמיר מחרוזת (שיש בה יותר מתו אחד) לטיפוס char

מכאן אנו מסיקים שהפעולה char.Parse(Console.ReadLine()); קולטת תו אחד בלבד ואז Enter .

אם נרצה לקלוט כמה תווים רצופים שהמשתמש מזין בלי ללחוץ ביניהם על Enter, עלינו להימנע משימוש ב-Console.ReadLine ( )‎ כי היא קוראת את כל התווים כמחרוזת אחת. לכן עלינו להשתמש בפקודה הבאה:

Console.Read();

זו פקודה שקולטת תו אחד בלבד ולא שורה, אך עלינו להמיר את מה שנקלט ל-char, כי הפעולה הזאת קולטת את התו כמספר שלם ( int ) של תו אחד. כלומר הפקודה היא:

tav1 = (char)Console.Read();
tav2 = (char)Console.Read();
tav3 = (char)Console.Read();

זו הדרך לקלוט כמה תווים יחד בלי ללחוץ ביניהם על Enter.

3.15.2 טבלת הקודים ASCII

זו טבלה שיש בה קוד (מספר שלם) לכל תו מן המקלדת, והיא מורכבת מ-128 תווים שונים, שמספריהם (הקודים שלהם) הם מ-0 עד 127, מסודרים ברצף לוגי מסודר. כלומר הספרות 0 – 9 רציפות ברצף לוגי, וכן האותיות הקטנות מסודרות זו מיד אחרי זו, וכן האותיות הגדולות.

דוגמאות למספרים של כמה תווים:

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

הטבלה המלאה נמצאת בנספחים. (נספח 2 בסוף הספר)

3.15.3 פעולות חשבון בתווים (char)

אפשר לחבר, לחסר ולכפול את המספרים (הקודים) של התווים, שהם מטיפוס int (הקוד של התו הוא int, כלומר מספר שלם). כדאי לדעת שביטוי שיש בו מספר שלם (int) ותו (char) הוא מטיפוס int (התוצאה היא int), ואז יש לשים לב שעלינו לבצע המרה (casting) ל-char .

static void Main(string[] args)
{
 char tav,next_tav;
 Console.Write("Insert a character:");
 tav = char.Parse(Console.ReadLine());
 //next_tav = tav + 1 ; שגיאה כי הוא ינסה לשמור מספר שלם
 next_tav = (char)(tav + 1);
 Console.WriteLine("your char:{0} \nnext char:{1}",tav,next_tav);
}

Insert a character:G
your char:G
next char:H

פעולות החשבון בין תווים מתבצעות באמצעות הקוד שלהם (המספר השלם שלהם), וכך גם ההשוואה ביניהם (ההשוואה !=,==,>=,<=,<,> ) למשל:

'a' + 'b'

כאן מחברים את הקוד של התו ’a‘ עם הקוד של התו ’b‘, והתשובה תהיה מספר שלם, כלומר מטיפוס int

דוגמאות לעבודה עם תווים (char) ועם המספרים שלהם לפי טבלת ASCII:

static void Main(string[] args)
{
  char ch;
  Console.Write("insert a character: ");
  ch = char.Parse(Console.ReadLine());
  if ((ch >= 'a' && ch <= 'z') || (ch>='A' && ch<='Z'))
      Console.WriteLine("It is a letter");
  else
      Console.WriteLine("It isn`t a letter");
}

insert a character: t
It is a letter

insert a character: D
It is a letter

insert a character: #
It isn`t a letter