קורס מבוא לתכנות של הבסמ"ח

קורס מבוא לתכנות של Basmach!

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

צייר לי בית

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

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

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

Friend

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

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

class First{

         .

         .

         .

public:

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

         .

         .

         .

};

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

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

פונקציה הורסת 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

משתנה מיוחס

משתנה מיוחס

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


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

#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 לא נשמיט.