הנדסת תוכנה

תחום הנדסת תוכנה מורכב מ2 נושאים עיקריים

1. חישוביות ואלגוריתמים – שייך לתחום מדעי המחשב > מתמטיקה שימושית
2. עיצוב פרדיגמה תכנותיות – software design  - עיצוב הקוד  - ילמד בקורס הקרוב

עקרונות בעיצוב תוכנה – מתוך ויקיפדיה

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

ארגון קוד

תכנות מובנה – בשימוש בשפות C \ basic  - יחידת הארגון זה פונקציה – פונקציה מקבלת ערכים > מעבדת > מחזירה ערך 

Object oriented – תכנות מונחה עצמים - גישת עיצוב קוד שמבוססת על מחלקות של אובייקטים שלכל אחד מאפיינים ופעולות משלה ומשמשת כיחידה סגורה ועצמאית 

Class - מחלקה היא תבנית לאובייקט - חבילה של פונקציות \ משתנים – data member / member factions   יצירת מחלקה נקראת כימוס 

Abstraction הפשטה - תהליך קוגניטיבי שבו אנו מסירים מאובייקט במציאות מרכיבים
שאינם רלוונטיים להגדרתו כמושג

Data hiding – מטרת העבודה בקלאסים היא למנוע מהמשתמש גישה למשתנים 

Public - ACCESS MODIFIERS \ private   - הגדרת משתנה מסוג Public   אומרת שניתן לגשת למשתמש בכל התוכנית לעומת זאת למשתנה מסוג  privateניתן לגשת רק בתוך אותו הבלוק לכן נגדיר את המשתנים בקלאס כ private

בעבודה עם מחלקות נגדיר את המשתנים כ private    ע"מ למנוע מהמשתמש

 במהלך כתיבת הקוד קוראים ל  Object ע"י יצירת אובייקט עם שם יחודי – ניתן ליצור את האובייקט שוב ושוב עם שמות שונים

            Person p = new Person();

New – אופרטור המקצה זיכרון לאובייקט המבוקש () בנאי המאתחל את המשתנים של האובייקט

גישה לחברים (משתנים\פונקציות) של האובייקט באמצעות  שם המשתנה. שם האובייקט

Constructor – בנאי

פונקציה לבנייה התחלתית של האובייקט. הוא מופעל אוטומטית בעת יצירת מופע מהמחלקה (אובייקט) באמצעות הפקודה new:

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

Constructor default – מאתחל את המשתנים לערך ברירת מחדל int = 0  string = null  - 

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

כך נוכל להגדיר שלא אפשרי ליצור משתמש ללא ת.ז

        public Person(int PersonId)

        {

            Id = PersonId ;

        }

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

הפעלת בנאי שמקבל פרמטרים        Person p = new Person(123456);

ברגע שהוגדר בנאי אחד למחלקה לא ניתן יותר להשתמש בבנאי ברירת מחדל  - ניתן להגדיר יותר מבנאי אחד

לא ניתן ליצור 2 בנאים שמקבלים אותם סוגי ערכים לדוג' לא ניתן ליצור 2 בנאים שמקבלים string  אחד למרות שמדובר על 2 משתנים שונים

ניתן ליצור אחד שמקבל string ואחד שמקבל string  ו- int או 2 string  

שרשור Constructor – במידה ויש בנאי ברירת מחדל שמגדיר  AB ונדרש בנאי נוסף שיאתחל גם את  Cניתן לשרשר בניהם במקום לכתוב כפול – נקרא לפונקציה אחת שקוראת לשנייה

        public cat(string owner):this()

אתחול משתנה מתוך קובץ – ניתן להגדיר ערך של משתנה מתוך קובץ טקסט – כרגע אנחנו לא משתמשים בבסיס נתונים לשמור את המידע ובכל פעם שסוגרים את הconsole  הנתונים נמחקים אז אם רוצים לשמור על רצף \ לעקוב אחרי שינויים ניתן לרשום את המידע בקובץ ובכל הרצה המערכת תמשוך את המידע מהקובץ

יכול לשמש גם בעתיד ביצירת תוכנה שנדרש שהמשתמש יעדכן מידע לדוג' מחיר של מוצר וכמובן שלא ניתן לו גישה לקוד  אלא לקובץ והתוכנה תמשוך משם את המידע

דוג' לקוד – אם הקובץ קיים תאתחל את המשתנה מתוך הקובץ אחרת תאתחל בערך ברירת מחדל > תיצור קובץ ותכתוב בו את הערך

if (File.Exists(PathFileTemperature))

                this.temperature = Convert.ToInt32(File.ReadAllText(PathFileTemperature));

            else

            {

                this.temperature = 16;

                File.WriteAllText(PathFileTemperature, temperature.ToString());

            }

מיון מערך - int

Complexity - סיבוכיות

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

מיון

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

סידור ערכים במערך

בעת חיפוש בתוך מערך \ רשימה ע"מ ליעל את העבודה ולחסוך משאבים של המחשב והתוכנה מחלקת את הרשימה ל2 ומבצעת בדיקה מול ערך שמאמצע במידה והערך שמחפשים גדול ממנו החיפוש יתבצע בצד אחד של המערך אחרת בצד השני

במערך של string  הבדיקה היא לפי הABC במידה והמילה שמחפשים גדולה מהערך האמצעי התשובה שמתקבלת היא 1 והחיפוש יהיה בצד הגדול אחרת התשובה היא 1- והחיפוש בצד הקטן

לכן צריך לסדר את המערך בסדר עולה 

החלפת ערכים במערך

דוג' להחלפה פשוטה שבה יצרנו מערך עם 5 מספרים ומבקשים מהמשתמש לבחור איזה מספר להחליף עם איזה

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

static void Main(string[] args)

        {

            int[] data = new int[5] {0 , 1, 2, 3, 4};

            int m = 0, n = 0;

            {

                show(data);

                Console.WriteLine("enter first");

                m = Convert.ToInt32 (Console.ReadLine());

                Console.WriteLine("enter second");

                n = Convert.ToInt32(Console.ReadLine());

                swap(data, m, n);

                show(data);

            }

        }

        public static void  show (int[] data)

        {

            for (int i = 0; i < data.Length; i++)

            {

                Console.WriteLine(data[i] + ",");

            }

            Console.WriteLine();

        }

        public static void swap(int[] data , int m , int n)

        {

            int temporary;

            temporary = data[m];

            data[m] = data[n];

            data[n] = temporary;

        }

Bubble Sort

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

int[] data = new int[5] {9 , 1, 4, 8, 3};

            int i, j;

            int N = data.Length;

            for (j = N - 1; j > 0; j--)

            {

                for (i = 0; i < j; i++)

                {

                    if (data[i] > data[i + 1])

                        swap(data, i, i + 1);

                }

             }

1. הגדרנו מערך עם חמישה מספרים
2. משתנה N מוגדר לערך של האורך של המערך = 5
3. לולאה ראשונה רצה 4 פעמים -  J = לN מינוס 1 (על המספר האחרון במערך לא צריך לרוץ ולבדוק אם יש גדול ממנו אחריו כי הוא האחרון)
4. לולאה פנימית שרצה 4 (מ-ס ועד J) פעמים ובודקת האם המספר במערך גדול מהמספר שלידו במידה וכן מתבצעת קריאה לפונקציה שמחליפה בניהם  (אותה הפונקציה מהדוג' הקודמת)

סדר המספרים במערך בתחילת ההרצה  -  9, 1, 4, 8, 3

בסיבוב הראשון של הלולאה החיצונית – הלולאה הפנימית רצה בדקה את מיקום אחד מול 2 והחליפה בניהם בסיבוב השני בדקה את מיקום 2 מול 3 והחליפה בניהם כך שבסיום הסיבוב הראשון הסדר של המערך היה  1, 4, 8, 3, 9

בסיבוב השני – מיקום ראשון ושני לא הוחלפו כי אחד לא גדול מ4 וכן השני עם השלישי אבל 8 התחלף עם 3 1, 4, 3, 8, 9

בסיום הסיבוב השלישי   - 1, 3, 4, 8, 9 

סיבוב רביעי כבר רץ ללא שינויים

Selection Sortמיון בחירה

• נמצא את האיבר בעל הערך הנמוך ביותר במערך.
• נחליף אותו עם האיבר הראשון במערך.
• ונמשיך באותה שיטה על שאר המערך (ללא האיבר הראשון).

 היתרון שבכל הרצה מבצעים פחות פעולות אך בכ"א במונחי זמן רציה המיון נחשב כלא יעיל

            int[] data = new int[5] {9 , 1, 4, 8, 3};

            for (int i = 0; i < data.Length; i++)

            {

                int min = i;

                for (int  j= i+1 ; j < data.Length; j++)

                {

                    if(data[j] < data[min])

                    {

                        min = j;

                    }

                }

                if (data[i] > min)

                {

                    swap( data , i, min );

                }

            }

פונקציות רקורסיביות

פונקציה שקוראת לעצמה לדוג' פונקציה לחישוב חזקה -  2 בחזקת 4    התרגיל הנדרש הוא

16  = 2•2•2•2

לביצוע החישוב נעשה פונקציה שמכפילה מספר בעצמו וקוראת לעצמה לחישוב חוזר 

לא לשכוח! לתת לפונקציה תנאי יציאה אחרת היא תחזור על עצמה שוב ושוב

static void Main(string[] args)

        {

            int b , a , result;

            Console.WriteLine("enter number base");

            b = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("enter number exponent");

            a = Convert.ToInt32(Console.ReadLine());

            result = Exponentiation(b , a);

            Console.WriteLine(result);

{

     public static int Exponentiation(int m , int n)

            {  if (n > 1)

            {

                return m * Exponentiation(m, n - 1);

            }

           return m;

        }