מספר פרמטרים משתנה - C#) params)

params

כמו בהרבה שפות, ב-#C קיימת אפשרות שפונקציה תקבל מספר משתנה של פרמטרים.

בשפת C ראינו את זה הרבה בפונקציות ()printf וְ ()scanf שמדפיסות או מקבלות מספר משתנים ככל העולה על רוחנו.

תחביר:

 שם_הפונקציה   ערך_מוחזר(params טייפ_הפרמטרים[] name){.....}

כל הפרמטרים נכנסים לפונקציה במערך. ה"Length" של המערך שווה למספר הפרמטרים שהוזנו.




דוגמה 1:

    class Program
    {
        public static int Sum(params int[] numbers)
        {
            int sum = 0;
            for (int i = 0; i < numbers.Length; i++)
            {
                sum += numbers[i];
            }
            return sum;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Sum());  // ידפיס 0
            Console.WriteLine(Sum(3, 5));  // ידפיס 8
            Console.WriteLine(Sum(3, 5, 10));  // ידפיס 18
        } 
    }

מבחן תקשורת נתונים 03/12/2017

מבחן בתקשורת נתונים:

צבעים בחלון הפקודה #C

צבעים #C

נוכל לשנות את צבע הטקסט בחלון הפקודה.


1.
צריך להוסיף בראש התוכנית: using System.
לרוב, ה-System כבר כתובה אוטומטית בראש הקוד ע"י הוויזואל סטודיו.

שימו לב: ב-#C על ידי ה-using אנחנו לא מייבאים "ספריות", אלא "ניימספייסים" (namespace). מעתה נקרא להם בשמם.





2.
כדי לשנות את צבע הטקסט:
; צבע = Console.ForegroundColor

אחרי הפקודה כל הטקסט יהיה בצבע שבחרתם.
(כדי לציין את הצבע משתמשים ב enum הצבעים: "ConsoleColor".)

        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Hello");
        }

חיבור ה-NetBeans ל-GitHub

חיבור ה-NetBeans ל-GitHub של Bitbucket

1. צרו משתמש, קבוצה ופרויקט ב: Bitbucket.

2. חברו את ה-Git שלכם ל-NetBeans. השתמשו במדריך.





בהצלחה.

ה-ref וה-C#) out)

בדומה ל"משתנה המיוחס" ב ++C, גם ב-#C פונקציה יכולה להשפיע על הארגומנטים שהיא מקבלת.

כדי להשפיע על ארגומנט נוסיף לו את המילה השמורה "ref" או "out" בראש הפונקציה ובשליחה לפונקציה.

ref

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

דוגמה:
החלפת ערכים בין שני משתנים

    class Program
    {
        static void Swap(ref int x, ref int y)
        {
            int tmp = x;
            x = y;
            y = tmp;
        }
        static void Main(string[] args)
        {
            int a = 5, b = 10;
            Swap(ref a, ref b);
 
            // :הדפסה
            Console.WriteLine("a: " + a); // a: 10
            Console.WriteLine("b: " + b); // b: 5
        }
    }

פרויקט דמו בג'אווה - קליטה ושינוי מה SQL Server

תקשורת בטוחה עם בסיס הנתונים - קריאה ועדכון

הפרויקט של עמית:
-להורדה-


לימדו אותו היטב.





משימה:
- לקבל את כל השורות של הטבלה "Categories" מבסיס הנתונים "NORTHWND" לתוך רשימה (מסוג ArrayList) של אובייקטים שמכילים את כל העמודות של הטבלה.
- לשנות את אחד מאיברי הרשימה, בלי לשנות את ה-id.
- לכתוב פונקציה שמקבלת את הרשימה ששינינו ומעדכנת את הטבלה ב-NORTHWND על פי אותה רשימה.
- לבדוק ב SQL Server שאכן הטבלה Categories עברה שינוי.

שימושים של המחלקה Math ב-#C

פונקציות שימושיות במחלקה Math:

1

Math.Abs(מספר)

מחזיר את הערך המוחלט של המספר

            double n = Math.Abs(-8.9);
            Console.WriteLine(n);  // ידפיס: 8.9

2

Math.Pow(מספר1, מספר2)

מחזיר את מספר2 בחזקת מספר1

            double n = Math.Pow(10, 2);
            Console.WriteLine(n);  // ידפיס: 100

3

Math.Sqrt(מספר)

מחזיר את השורש הריבועי של המספר

            double n = Math.Sqrt(25);
            Console.WriteLine(n);  // ידפיס: 5

פונקציה נחמדה שכתבתי לקליטה בטוחה של מספר שלם מהמשתמש

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

קליטה בטוחה של מספר int מהמשתמש:

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

הערה: הפונקציה Get_Save_int_Number_From_User נכתבה במקור עבור שפת C, כנראה תמצאו בה דברים שאפשר לקצר באמצעות #C.
בניגוד אליה, הפונקציה Get_Save_int_Numbers_From_User נכתבה ישירות עבור #C.

מספרים ומערכים רנדומלים (#C)

למדנו על מספרים רנדומליים בשפת C וב ++C. היום נלמד עליהם ב-#C תוך הרחבה של הנושא.

מספרים אקראיים:

כדי ליצור מספר אקראי ניצור אובייקט מהמחלקה Random:

Random r = new Random();

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

r.Next();

נוכל לשלוח לפונקציה Next טווח מספרים.
כך למשל על-מנת להגריל מספר שלם בין 1 ל- 7 (כולל 1 אך לא כולל 7):

r.Next(1,7);

לדוגמה:

            Random r = new Random();
            Console.WriteLine(r.Next(1,9)); // ידפיס מספר רנדומלי בין 1 ל-8 כולל 

קלט מהמשתמש ב Java (בדומה ל-scanf)

קלט בג'אווה:

1.

מוסיפים את המחלקה:  "java.util.Scanner"

כך:

import java.util.Scanner;

או את כל המחלקה:

import java.util.*;

2.

כותבים פעם אחת בראש הפונקציה את הקוד:

Scanner s = new Scanner(System.in);

(את המשתנה "s" אפשר להחליף בכל שם שנרצה)

שפת #C - מחרוזות

אנחנו כבר יודעים איך לעבוד עם מחרוזות בשפת C ובשפת ++C.
היום נלמד על מחרוזות ב-#C:

String

עד היום השתמשנו במערך של משתנים מטייפ char לעבודה עם מחרוזות.
ב#C, (בדומה לJava), קיים טייפ מיוחד בשם "String" שנועד במיוחד לאחסון מחרוזות.

הגדרה:

String str;

אתחול בהגדרה:

String str = "Hello!";

הדפסה:

Console.WriteLine(str);

קליטה:
כאן אין צורך בפונקציית ההמרה "()Parse", משום שהפונקציה ()ReadLine כבר מחזירה String.

str = Console.ReadLine();

NULL מסיים:
ל-String אין NULL מסיים. במקומו נוכל להשתמש במאפיין Length שמייצג את אורך המחרוזת.

str.Length

מאמר של מוטי על תזמון תהליכים

מאמר ארוך בנושאים שלמדנו עם מוטי על תזמון תהליכים ב- CPU

להורדת הקובץ המלא:  כאן. או כאן. או כאן. (דרושה סיסמת חברים).

קטעים חלקיים:

מבוא

מערכת מחשב

מערכת מחשב מתחלקת לארבעה חלקים :

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

מבחן מבוא לאלקטרוניקה

מבחן מבוא לאלקטרוניקה

מערכים והלולאה C#) foreach)

Arrays

בשפת #C מערכים מתנהגים קצת שונה מבשפת C.

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


הגדרת מערך של int:

int[] Array;

מערך זה עדיין לא מאותחל. כרגע Array הוא רק "שם של מערך". בדומה לשפת C - שם של מערך הוא מצביע.
(בשפת #C לא משתמשים במצביעים, לכן לא נקפיד לקרוא לו בשם "מצביע". זכרו שהוא מתנהג כמו מצביע.)


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

Array = new int[5];

כעת Array הוא מערך מאותחל בגודל 5 איברים.
כשמערך מאותחל כל איבריו מקבלים את הערך 0.



ניתן לבצע את כל זה בשורה אחת:

int[] Array = new int[5];

תחילת עבודה עם #C

מה שונה ב #C ?

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

כדי לפתוח בוויזואל סטודיו פרויקט ב #C צריך לבחור במיוחד:

Visual C#  ->  Console Application

אחרי זה יופיע לנו הקוד הבא:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

כל מה שנחוץ לפרויקט - מדריכי ווידאו של עמית פרדיס

כל מה שנחוץ לתחילת הפרויקט

הקמת טבלאות במסד מידע SQL (למי ששכח איך עושים את זה)

הבנה טובה של מצביעיםVSמערכים דו מימדיים - ריבוע קסם (שפת C)

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

הגדרה:
ריבוע של מספרים בו:
- הסכום של כל שורה שווה.
- הסכום של כל עמודה שווה.
- הסכום של שני האלכסונים הגדולים שווה.
- כולם שווים אחד לשני (כלומר סכום האלכסון שווה לסכום השורה ושווה לסכום העמודה)

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




לדוגמה:

ריבוע חוקי:
1  8  3
6  4  2
5  0  7

תוכנית רצינית - חיפוש מילים בטקסט

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

על התוכנית להשיב כמה פעמים מופיעה כל מילה.

פרטים:

- התוכנית מקבלת מהמשתמש (באמצעות קובץ טקסט או הקלדה ישירה למסך) טקסט ארוך ושומרת אותו במערך long_text.

[באמצעות הקצאה דינאמית משתמשת בזיכרון המינימלי שנחוץ]

- התוכנית מקבלת מהמשתמש מספר n. מספר זה מייצג את מספר המילים שהמשתמש רוצה לחפש.

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

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

  כמובן שמילה לא יכולה להכיל רווחים, tab, או אנטר.

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

[באמצעות הקצאה דינאמית כל מילה תשתמש בזיכרון המינימלי שנחוץ לה]

- התוכנית מדפיסה כמה פעמים מופיעה כל מילה במערך long_text.

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

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

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

נסו לכתוב את הקוד בעצמכם!

צבעים בסיסיים בחלון הפקודה ++C

שיטה לצבעי טקסט שונים

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



א. מוסיפים את הספרייה windows.h. (לכן השיטה לא תעבוד במערכת הפעלה שאינה ווינדוס)

ב. כותבים את הפונקציה הזאת בראש הקוד:

void setcolor(unsigned short color){
 HANDLE hcon = GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleTextAttribute(hcon, color);
}

ג. לפני טקסט צבעוני מוסיפים את הפקודה:    ;(setcolor(NUM
ה-NUM קובע באיזה צבע יהיה הטקסט בתוכנית מעתה והלאה (עד לפקודת setcolor הבאה אשר תשנה שוב את הצבע).

אתגר למתכנת - בית בלי להרים את העט

צייר לי בית

מכירים את המשחק בו צריכים לצייר בית ובתוכו איקס בלי להרים את העט ובלי לחזור על אף קו?
לדוגמה:

כמה דרכים אפשריות יש לדעתכם לפתור את החידה?
נסו לכתוב תוכנה שמוצאת את כולן!

עבודה במערכות הפעלה

עבודה הגשה במערכות הפעלה

מבחן שליש ג' – בסיסי נתונים Sql Server

מבחן שליש ג' – בסיסי נתונים Sql Server

שאלות ב java

שאלות:

להורדה כאן או כאן

חבר (friend) של המחלקה

Friend

ראינו שאין לשום דבר מחוץ למחלקה גישה למשתנים ולפונקציות שבחלק ה private של המחלקה.
יש יוצא דופן:
אם נגדיר פונקציה/מחלקה כלשהי כ friend של מחלקה, היא תוכל לגשת לכל התוכן ה private של אותה מחלקה.

מבנה של מחלקה חברה:

class First{

         .

         .

         .

public:

friend class Second; // זה שם מחלקה האחרת Second 

         .

         .

         .

};

-כך מצהירים על המחלקה Second כ friend של המחלקה First.

אילו סוגי זכרונות יש

מאמר מאת: www.4project.co.il


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

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

ROM - Read Only Memory
זכרון לקריאה בלבד. תחשבו עליו כאוסף של חוטים שחלק חתוכים שלא מוליכים וחלק שלמים שכן מוליכים. כלומר חלק יחזירו 0 לוגי וחלק 1 לוגי כשקווי הכתובת יצביעו עליהם. מצב החוטים/הביטים בדרך כלל נקבע במהלך היצור של הרכיב.

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

פונקציה הורסת במחלקה

פונקציה הורסת Destructor

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

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

זיכרון דינאמי

הקצאת זיכרון דינאמי

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

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

#include <iostream>
using namespace std;
 
void main(){
 int *ptr = new int;
 *ptr = 5;
 cout<<*ptr<<"\n"; // ידפיס 5
}

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

#include <iostream>
using namespace std;
 
void main(){
 int *ptr = new int;
 *ptr = 5;
 cout<<*ptr<<"\n";
 delete ptr;
}

מספר רנדומלי, ודיליי (השהייה) ב ++C

מספרים רנדומליים

בשפת C למדנו על מספרים רנדומליים.
נראה בקצרה איך זה עובד ב ++C.

א. נוסיף את הספרייה:
                          < ctime>
ב. נכתוב פעם אחת בפונקצייה main את השורה:

                                                                                                                                        srand( time(0));

ג. נקבל מספר רנדומלי ע"י:
                      rand() % 2


כדי להגביל את טווח המספרים משתמשים ב %
כך:

                                                                                                                                        int x = rand() % 10;

כעת x יהיה מספר בין 0-9

או:

                                                                                                                                        int x = rand() % 10+1;

כעת x יהיה מספר בין 1-10

שאלות חזרה ב sql

שאלות:

משתנה מיוחס

משתנה מיוחס

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


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

#include <iostream>
using namespace std;
void swap(int &a,int &b){
 int temp;
 temp=a;
 a=b;
 b=temp;
}
void main(){
 int num1=5,num2=10;
 swap(num1,num2);
 cout << num1 << "  " << num2 << "\n";
}

חפיפת פונקציות וברירת מחדל

חפיפת פונקציות

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

היום נראה שזה מותר. באחד מהתנאים:

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

דוגמה:

#include <iostream>
using namespace std;
 
int f1(){  //1
 return 5*3;
}
int f1(int x, int y){ //2
 return x*y;
}
 
double f1(double x, double y){  //3
 return x*y;
}
double f1(int x, double y, int z){  //4
 return x*y*z;
}
void main(){
 cout<<f1()<<"\n";         // 15
 cout<<f1(7,8)<<"\n";      // 56
 cout<<f1(7.5,8.5)<<"\n";  // 63.75
 cout<<f1(2,0.5,5)<<"\n";  // 5
 cout<<f1(2,5,6)<<"\n";    // 60
}

פונקציה בונה

פונקציה בונה ב class שלנו

לרוב נרצה שתהיה "פונקציה בונה" (Constructor) בכל class.
תפקידה להכניס ערכים ראשוניים לחלק/לכל המשתנים של האובייקט.

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


לדוגמה:

מרכיבים עיקריים של מערכת מבוססת מיקרו מחשב

מרכיבים עיקריים של מערכת מבוססת מיקרו מחשב

מצגת הסבר מקיפה.
להורדה: כאן או כאן

מאמר מבוא למערכות הפעלה

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

להורדה: כאן או כאן

דוגמית:

מבני נתונים - מבוא

מבני נתונים - מצגת מבוא:

קישור להורדה

מקור: מכללת אורט כפר-סבא

מהו CLASS

class  -  מחלקה

ה class מתנהג כמו ה struct של שפת C. אבל עם תחביר מעט שונה והרבה תכונות נוספות.


הדוגמה הפשוטה:

class Item{
public:        // נסביר בהמשך מה משמעות השורה הזאת, כרגע פשוט נכתוב אותה
 int a;
 int b;
 char c;
};
 
void main(){
 Item q1;
 q1.a = 5;
 q1.b = 10;
 q1.c = 'A';
 cout <<q1.a<<"\n"<<q1.b<<"\n"<<q1.c<<"\n";
}

כפי שרואים, בניגוד ל struct כאן אין צורך לכתוב את המילה "class" כל פעם שמכריזים על משתנה.

מ C אל ++C

ההבדלים בין C ל ++C

אחרי שלמדנו שפת C, נתחיל ללמוד ++C.

ישנם מספר הבדלים בין C ל ++C. חלקם רק בשמות הפונקציות והספריות, וחלקם בכך ששפת ++C
היא שפה מונחת עצמים (Object Oriented).

הבדלים חשובים:

C
על מנת ליצור ב Visual Studio תוכנית היה עלינו להשמיט את ה "pp" מסיומת הקובץ ("Source.c" במקום "Source.cpp").

++C
ב ++C לא נשמיט.

שפת C - מצביע לפונקציה, qsort , bsearch ומשתנה const

מצביע לפונקציה

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

מבנה כללי:

     ; (הארגומנטים שהפונקציה מקבלת)   (שם_המצביע *)   סוג הערך שהפונקציה מחזירה


לדוגמה אם יש פונקציה בשם "F":

double F(int a, int b, char c) { ...... }

אז כדי שמצביע "p" יוכל להצביע עליה, צריך להגדיר אותו כך:

double (*p) (int a, int b, char c);

ואז נוכל להכניס אליו את הכתובת של הפונקציה:

p = F ;

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

שפת C - עוד חזרות פשוטות

משולש שווה שוקיים

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

לדוגמה:

שפת C - משחק בול פגיעה

עוד תרגילים וחזרות על חומר ישן

ננסה ליצור את המשחק "בול פגיעה" (Bulls and Cows)

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

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

~משחק חשיבה נחמד ומומלץ לכולם~
ראו גם: וויקיפדיה

שפת C - עוד על define ו enum

define מתקדם

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

-השם הרשמי להגדרות כאלו הוא "מאקרו" (macro).
-נראה היום שאפשר לעשות פעולות מתקדמות יותר עם define. בדומה לפונקציות:

#include <stdio.h>
#define p(a) printf("%d\n",a)
void main(){
 int x=3,y=8;
 p(x);
 p(y);
}

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

printf("%d\n",מספר)

גם תווים:

#include <stdio.h>
#define p(a) printf("%c\n",a+1)
void main(){
 p('e');
 p('E');
}

שפת C - הגדרת טיפוס typedef

הגדרת טיפוס - typedef

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

מבנה כללי:

typedef     שם_חדש     שם ישן ;   

לדוגמה:
p1 ו p2 הם מסוג int בשתי התוכניות הבאות:

#include <stdio.h>
void main(){
 int p1 , p2;
.
.
.
}

//// 
 
#include <stdio.h>
typedef int phone;
void main(){
 phone p1 , p2;
.
.
.
}

שפת C - חזרה עם גידי

שאלות חזרה על מערכים:

1. קלוט מהמשתמש 6 תווים למערך והדפס אותם בסדר הפוך, תו תחת תו.

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

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

לדוגמה:
8 1 6
3 5 7
4 9 2
הוא ריבוע קסם.

שיעורים Solaris - סיכום מבחן על יוניקס

מבחן יוניקס

שפת C - קבצים בינארים וקריאה לא סדרתית

קבצים בינארים

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

void main( ) {

FILE fp ;

fp = fopen ("name_of_file","mode") ;

.

.

.

fclose(fp);

}

למדנו בקצרה שעבור קבצים בינארים יש ב mode את האות b.

פעולות בסיסיות על קובץ בינארי:

fwrite( מצביע קובץ , מספר המשתנים , גודל המשתנה בבתים , כתובת המשתנה ממנו מעתיקים )

fwrite( void *p , int size , int num , FILE *fp )                          :ניסוח באנגלית

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

שפת C - טיפול בקבצים

טיפול בקבצים

- תוכנית יכולה לגשת לקבצים אחרים במחשב. לקרוא, ליצור או לשנות אותם.

- כל הפונקציות והקבועים הנוגעים לטיפול בקבצים כלולים בספריית הקלט פלט, הלא היא ספריית stdio.h .

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

כדי לטפל או ליצור קובץ נצטרך קודם להצביע על הכתובת שלו בזיכרון. כמו כל המצביעים גם המצביע הזה
צריך להיות מאותו הסוג של הקובץ עליו הוא אמור להצביע, היינו מסוג FILE.
(ולא מסוג  "struct FILE", משום ש"FILE" הוא טיפוס שהוגדר כבר  כ "struct FILE" ע"י typedef בספריה stdio.h. -נלמד בהמשך.)


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

fopen ( __ שם או נתיב__ , __mode__ );

באופן הבא:

#include <stdio.h>

void main( ) {

FILE *fp ;

fp = fopen ( __שם או נתיב__ , __mode__ );
if (fp == NULL) {  // NULL אם פתיחת הקובץ נכשלה המצביע יקבל 

       printf ("Can't open file");

       exit (0);    // stdlib.h בחלק מהמקרים על מנת להשתמש בפקודה הזאת יש להוסיף את הספרייה 

     }
.

.

.

}

SQL - מבחן פנימי

מבחן (31/1/2017)

המבחן:

שפת C - רקורסיה - תרגילים וכללים

רקורסיה - שיטה לבנייה נכונה

פתרונות מהשיעור הקודם:

תשובה 1: (לא רשמי)

#include <stdio.h>
 
int  f1(int x,int y) {
 if (x<y||(x==y&&x%2==1))   // הפונקציה מחזירה את סכום המספרים הזוגיים בין שני מספרים כשהשמאלי גדול או שווה לימיני
  return 0;
 if (y%2==1) 
  y++;
 return 1 + f1(x, y+2);
 }
 
 void main() {
  int x,y;
  printf("Enter 2 numbers: ");
  scanf("%d %d",&x,&y);
  printf("Zugi: %d \n",f1(x,y));
 }

שיעורים Solaris - בעיות אופטימיזציה עם מספר נעלמים - השיטה הקצרה

בעיות אופטימיזציה עם מספר נעלמים - טבלה

משימות:

מבחנים חיצוניים משנים קודמות באלגברה לינארית

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

2016

2015

2014

2013

2012

סמל 714003

המבחנים הם מאתר משרד החינוך.

שפת C - רקורסיה

רקורסיה - recursion

רקורסיה הוא תהליך בו הפונקציה קוראת לעצמה.

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

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

לדוגמה נתבונן בפונקציה רקורסיבית שמחזירה סכום המספרים מ0 ועד למספר שהיא מקבלת.
עבור 5 הפונקציה תחזיר סכום: 1+2+3+4+5

#include<stdio.h>
 
int f(int n){
 if(n==0)
  return 0;
 return n+f(n-1);
}
 
void main(){
 int n;
 printf("Enter number: ");
 scanf("%d",&n);
 printf("%d\n",f(n));
 
}

שפת C - עבודה עם רשימות מקושרת שמכילות גם מצביעים לרשימות אחרות (יום ראשון)

עבודה מורכבת עם רשימות מקושרות

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

התרגיל היום זה ליצור פונקציה שיוצרת רשימה מקושרת של סטודנטים    ( ) CreateStudentList
ופונקציה שיוצרת רשימה מקושרת של קורסים    ( ) CreateCourseList

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

כל קורס מכיל את השדות הבאים:
שם הקורס
ממוצע ציונים (של כל הסטודנטים שלומדים בקורס)
מצביע לראש (= head) רשימה מקושרת של כל הסטודנטים שלומדים בקורס   (sh)
next לקורס הבא

תכנות מערכות בשפת C ושפת סף - במחנים אמיתיים (משרד החינוך)

תכנות מערכות בשפת C ושפת סף - מבחני משרד החינוך בשנים האחרונות

2016

2015

2014

2013

2012

סמל 714001

המבחנים הם מאתר משרד החינוך.

שפת C - רשימה מקושרת דו סטרית (יום רביעי)

רשימה דו סטרית

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

כפי שה next של האיבר האחרון מכיל NULL, גם ה back של האיבר הראשון מכיל NULL.

struct Item{

int info;       

      stuct Item *next, *back;    

};

משימות

1. לבנות פונקציה CreatList של רשימה דו סטרית.
2. לבנות פונקציה PrintList שמדפיסה הרשימה מהסוף להתחלה וגם מההתחלה לסוף (באותה הפונקציה).
3. לבנות פונקציה DelItem של רשימה דו סטרית.
4. לבנות פונקציה המקבלת שתי רשימות מקושרות דו סטריות ומספר שלם x.
     הפונקציה מכניסה הרשימה השניה לרשימה הראשונה אחרי ההופעה הראשונה
     של  x  ברשימה.
     אם אין איבר כזה , אז לא יבוצע כלום.
5. כתוב הפונקציה:

                                                                           struct Item* head  Del_Even (struct Item* head);

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

בעיות אופטימיזציה (תכנון לינארי)

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

תרגילים:

מבחן חוזר באסמבלי

מבחן חוזר באסמבלי (5.1.17)

1.

שפת C - עוד על רשימות מקושרות (יום רביעי)

עוד על רשימות מקושרות

נתחיל מהתכנית מהשיעור הקודם (+תוספות מהשיעור הזה):

#include <stdio.h>
#include <conio.h> // לפעמים יש צורך בספרייה הזאת, לא קשור לנושא השיעור
#include <stdlib.h>
struct Item {     // מגדירים את סוג איברי הרשימה
 int info;
 struct Item* next;
};
struct Item* CreateList() {     // יוצרים פונקציה שיוצרת רשימה ע"פ קלט מהמשתנה
 struct Item *head = NULL, *tail, *p;
 while( 1 ) {
  printf("Enter Esc to finish, any other key to continue\n");
  flushall();
  if(getch() == 27)       // (הפקודה חוקית מפני שזו פונקציה שמחזירה ערך)
   break;
 
  p = (struct Item*) malloc( sizeof(struct Item) );
  printf("Enter number: ");
  scanf("%d",&p->info);
  p->next = NULL;
 
  if(head == NULL)         // זה המקרה שקיבלו את האיבר הראשון
   head = tail = p;
  else {
   tail->next = p;   // האיבר שקודם היה האיבר האחרון מצביע עכשיו על האיבר החדש
   tail = p;
  }
 }
 return head;
}

שיעור SQL - שאלות (יום שלישי)

שאלות ב SQL

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

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

     2. הצג מטבלת הזמנות ועובדים שם עובד, מספר עובד ומספר הזמנות שהעובד עשה.

(GROUP BY)

שפת C - רשימות מקושרות (יום ראשון)

רשימות מקושרות Linked List

- הרשימה המקושרת היא מבנה (struct) לשמירת הרבה נתונים מאותו הסוג.
- איברי הרשימה לא שמורים ברצף בזיכרון.
- כל איבר מכיל 2 דברים:
                          1. שדה/שדות מידע
                          2. שדה קישור (מצביע) לכתובת של האיבר הבא


סוגי רשימות:
רשימה חד סטרית
רשימה דו סטרית
רשימה מעגלית

התחלה [head] >   [ מידע   |next] >   [ מידע   |next] >   [ מידע   |next] >   [ מידע   |NULL] סוף

head הוא מצביע לתחילת הרשימה.
הרשימה מסתיימת באיבר בו שדה המצביע הוא NULL.

שפת C - מבנים struct (יום ראשון)

מבנים - struct

- המבנה מיועד לשמירת הרבה נתונים מסוגים שונים.
- איברי המבנה (השדות) נשמרים ברצף בזכרון.

הגדרה כללית:

        struct Name{

        type1  n1;

        type2  n2;

              .

              .

              .

        };

מחרוזות בשפת אסמבלי (יום חמישי)

מחרוזות בשפת אסמבלי - UnderWarrior PDF

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

כאן

Show/Hide me

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.

Name:

שפת C - מצביע למצביע (יום רביעי)

מצביע למצביע

מצביע יכול להצביע למצביע אחר עם כוכבית אחת פחות משלו (וכן הלאה "מצביע למצביע למצביע" עוד כוכביות)

הגדרה:

type  **PName; 

שימוש:

int x = 13,*p,**q;  

p = &x;                    

q = &p;                    

הפקודה q = &x לא חוקית!

אם הכתובת של x היא 600 , של p היא 850 ושל q היא 900
אז נתבונן במצב אחרי הפקודות:

x = 13         &x = 600      *x

p = 600      &p = 850      *p = 13        **p

q = 850      &q = 900      *q = 600      **q = 13

הקצאת מטריצה דינאמית:

int n = 5(שורות), m = 4(עמודות), **A;

נעבור לתוכנית:

שפת C - פקודת realloc (יום ראשון)

פקודת realloc

מאמר מאת ויקיספר:

פונקציית שינוי-ההקצאה realloc

שינויי הקצאות אפשר לעשות בעזרת הפונקציה realloc, על ידי קריאות מהצורה הבאה:

realloc(<old_ptr>, <total_size>)

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

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

שפת C - הקצאת זיכרון דינאמי (יום רביעי)

הקצאת זיכרון דינאמי

נדגים מה הצורך בזיכרון דינאמי:

void main(){   

int n;               

scanf(%d,&n);

int A[n];         

הפקודה האחרונה לא חוקית!

למה?

* אסור שגודל מערך יהיה משתנה.

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

לכן יש שימוש בהקצאת זיכרון דינאמית!

- הקצאת זיכרון דינאמית היא האפשרות לייצר זיכרון (להקצות) במהלך ביצוע התוכנית.
- יש לעשות שימוש בספרייה  <stdlib.h>

אנחנו נשתמש בפקודות הבאות:

malloc - לבצע הקצאה חדשה
calloc  - לבצע הקצאה חדשה + לאפס אותה
realloc - להגדיל/להקטין זיכרון דינאמי
free     -  לשחרר זיכרון דינאמי

תירגול מצביע למערך

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

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







פתרון אפשרי:

שפת C - עוד על מצביעים (יום רביעי וראשון)

עוד על מצביעים:

- שם מערך הוא למעשה גם מצביע, שמצביע על הבית הראשון של האיבר הראשון במערך.

- כדי להצביע על מערך אפשר לעשות בפשטות (כש p הוא מצביע):

p = &A[0];  

  אבל אפשר לעשות גם:

.שכן שניהם מצביעים, ואפשר להשוות שני מצביעים-         p = A;  

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

  לדוגמה:

  אם p הוא מצביע מסוג int שמצביע על האיבר הראשון של המערך A

*p = 13;          =>      A[0] = 13

p++;               =>      p = 1004

*p = 27;          =>      A[1] = 27

p+=2;             =>      p = 1012

*p = 20;          =>      A[3] = 20