1. ‫מודולארי‬ ‫בתכנות‬ ‫הקורס‬ ‫של‬ (‫)קצר‬ ‫סיכום‬
‫ביברמן‬ ‫יורם‬ ‫ד"ר‬ :‫הקורס‬ ‫מרצה‬
‫הדסה‬ ‫מכללת‬ ‫־‬ ‫תשע"ג‬ ‫־‬ '‫ב‬ ‫סמסטר‬
!‫בהצלחה‬
.‫י‬ ‫נתאי‬ :‫ע"י‬ ‫נכתב‬ ‫הסיכום‬
1

2. (int argc, char *argv[ ]) :‫שמתחילים‬ ‫לפני‬ ‫קטן‬ ‫משהו‬ 0.1
:‫אחד‬ ‫כל‬ ‫משמעות‬
.argv[] ‫־‬ (‫הארגומנטים‬ ‫)וקטור‬ ‫הארגומנטים‬ ‫מערך‬ ,argc ‫־‬ ‫הארגומנטים‬ ‫מספר‬
‫ו־‬ argc=3 ‫אזי‬ ./ex1a in.txt out.txt :Shell‫ב־‬ ‫הפקודה‬ ‫בשורת‬ ‫כתבנו‬ ‫נניח‬ ‫אם‬
...‫הלאה‬ ‫וכך‬ argv[1]=in.txt ,argv[0]=ex1a
I ‫חלק‬
‫בקבצים‬ ‫טיפול‬
cin ‫של‬ ‫בסיסיות‬ ‫פקודות‬ 1
‫הפקודה‬ ‫מחזירה‬/‫עושה‬ ‫היא‬ ‫מה‬ ‫הפקודה‬ ‫עם‬ ‫קוד‬ ‫לקטע‬ ‫דוגמא‬
cin.peek(); ‫מחוצץ‬ ‫הבא‬ ‫התו‬ ‫את‬ ‫לוקחת‬
"‫"אוכלת‬ ‫לא‬ ‫אבל‬ ‫הקלט‬
....‫אותו‬
ab :‫לנו‬ ‫יש‬ ‫הקלט‬ ‫בחוצץ‬ ‫למשל‬ ‫אם‬
:‫הפקודות‬ ‫אזי‬
c=cin.peek();
cout<cendl;
c=cin.peek();
coutcendl;
aa ‫הקלט‬ ‫את‬ ‫ידפיסו‬
cin.get(); ‫הקלט‬ ‫מחוצץ‬ ‫התו‬ ‫את‬ ‫לוקחת‬
.‫הבא‬ ‫התו‬ ‫אל‬ ‫ועוברת‬
‫הקודם‬ ‫במקרה‬ ‫כמו‬ ‫קוד‬ ‫אותו‬ ‫עם‬
ab :‫יהיה‬ ‫הפלט‬
cin.putback(c); ‫המכיל‬ ‫משתנה‬ ‫הוא‬ c‫ו־‬ ‫במידה‬
‫את‬ ‫מחזירה‬ ‫הפקודה‬ ‫אזי‬ ,‫תו‬
‫חייב‬ c .‫הקלט‬ ‫לחוצץ‬ ‫התו‬
‫את‬ ‫שקיבלנו‬ ‫משתנה‬ ‫להיות‬
cin.get(); ‫דרך‬ ‫ערכו‬
2

3. ‫קבצים‬ ‫עם‬ ‫עבודה‬ 2
:‫בהתחלה‬ ‫לשים‬ ‫צריכים‬ ‫אנחנו‬ ‫קבצים‬ ‫עם‬ ‫לעבוד‬ ‫רוצים‬ ‫אנחנו‬ ‫כאשר‬ ‫־‬ ‫הכל‬ ‫לפני‬
#include fstream
‫את‬ ‫תקרא‬ ‫התוכנית‬ ‫)שמהם‬ .‫קלט‬ ‫לקבצי‬ ‫־‬ using std::ifstream :‫בשורה‬ ‫נשתמש‬ ‫זה‬ ‫אחרי‬
.(‫הנתונים‬
.(‫הקלט‬ ‫את‬ ‫תדפיס‬ ‫התוכנית‬ ‫)שאליהם‬ .‫פלט‬ ‫לקבצי‬ ‫־‬ using std::ofstream; :‫ובשורה‬
‫נעבוד‬ ‫שאיתם‬ ‫הקבצים‬ ‫הגדרת‬ 2.1
:‫אותם‬ ‫להגדיר‬ ‫צריך‬ ‫לקבצים‬ ‫ניגשים‬ ‫שאחנו‬ ‫לפני‬
.‫הקלט‬ ‫קובץ‬ ‫יהיה‬ le1 ‫כאשר‬ ‫־‬ ifstream le1; :‫קלט‬ ‫קבצי‬
.‫הפלט‬ ‫קובץ‬ ‫יהיה‬ le2 ‫כאשר‬ ‫־‬ ofstream le2; :‫פלט‬ ‫קבצי‬
‫קבצים‬ ‫של‬ ‫וסגירה‬ ‫פתיחה‬ 2.2
:‫עי‬ ‫עושים‬ ‫אנחנו‬ ‫זה‬ ‫את‬ .‫אותו‬ ‫לפתוח‬ ‫צריכים‬ ‫אנחנו‬ ‫הקובץ‬ ‫עם‬ ‫לעבוד‬ ‫ניגשים‬ ‫שאנחנו‬ ‫לפני‬
le1.open(lename);
‫ניתן‬ ‫אינו‬ ‫והקובץ‬ ‫במידה‬ ‫־‬ le1.is_open(); :‫עי‬ ‫נפתח‬ ‫הקובץ‬ ‫שאכן‬ ‫לוודא‬ ‫כדי‬ ‫מכן‬ ‫ולאחר‬
‫הקובץ‬ ‫אם‬ ,‫שקר‬ ‫תחזיר‬ ‫הפונקציה‬ ‫אזי‬ (‫בסיסמא‬ ‫מוגן‬ ‫הוא‬ ‫נניח‬ ‫כי‬ ,‫קריאה‬ ‫)עבור‬ ‫לפתיחה‬
.‫אמת‬ ‫תחזיר‬ ‫הפונקציה‬ ‫אזי‬ ,‫בעיה‬ ‫בלי‬ ‫נפתח‬
:‫עי‬ ‫עושים‬ ‫אנחנו‬ ‫זה‬ ‫את‬ ,‫אותו‬ ‫לסגור‬ ‫מאוד‬ ‫חשוב‬ ‫הקובץ‬ ‫עם‬ ‫לעבוד‬ ‫שסיימנו‬ ‫אחרי‬ ,‫לבסוף‬
.le1.close();
.‫לכתיבה‬ ‫שנפתח‬ ‫קובץ‬ ‫לגבי‬ ‫בדיוק‬ ‫הדבר‬ ‫אותו‬
‫וכתיבה‬ ‫קריאה‬ ‫בקבצי‬ ‫שימוש‬ 2.3
‫עכשיו‬ ‫אזי‬ (int ‫מסוג‬ ‫משתנה‬ ‫)עבור‬ cinnum ‫כתבנו‬ ‫נתון‬ ‫לקרוא‬ ‫בשביל‬ ‫עכשיו‬ ‫עד‬ ‫אם‬
,‫הקלט‬ ‫מחוצץ‬ ‫הנתון‬ ‫את‬ ‫לקרוא‬ ‫שמקום‬ ‫זה‬ ‫שקורה‬ ‫מה‬ ,‫)בפועל‬ .le1 ‫נרשום‬ cin‫ה־‬ ‫במקום‬
.(‫מהקובץ‬ ,‫הנתון‬ ‫מהסטרים‬ ‫אותו‬ ‫קוראים‬ ‫אנחנו‬
.cout‫ה־‬ ‫לגבי‬ ‫דבר‬ ‫אותו‬
.le2num ‫שנרשום‬ ‫הוא‬ ‫שנעשה‬ ‫מה‬ ,‫כלשהו‬ ‫לקובץ‬ ‫לכתוב‬ ‫נרצה‬ ‫אם‬
,‫הפנייה‬ ‫בפרמטר‬ ‫להשתמש‬ ‫חובה‬ ‫־‬ ‫לפונקציות‬ ‫הקבצים‬ ‫את‬ ‫שולחים‬ ‫כאשר‬ :‫לזכור‬ ‫חשוב‬
. :‫כלומר‬
.‫לכתיבה‬ f‫ב־‬ ‫שנמצא‬ ‫הקובץ‬ ‫עם‬ ‫שעובדת‬ ‫פונקציה‬ ‫זוהי‬ ‫־‬ double g(ofstream f) :‫למשל‬
‫עושה‬/‫מחזירה‬ ‫היא‬ ‫מה‬ ‫הפקודה‬
,‫)כלומר‬ ‫הכותב‬ ‫הראש‬ ‫את‬ ‫מזיזה‬
‫לכתוב‬ ‫נתחיל‬ ‫לקובץ‬ ‫נכתוב‬ ‫כאשר‬
.(pos‫מ־‬
seekp(int pos)
‫הכותב‬ ‫הראש‬ ‫מיקום‬ ‫את‬ ‫לנו‬ ‫מחזירה‬
‫את‬ ‫מזיזה‬ ‫איננה‬ ‫הפונקציה‬ ,‫)כלומר‬
‫את‬ ‫מחזירה‬ ‫אלא‬ ‫הכותב‬ ‫הראש‬
.(‫מיקומו‬
tellp()
‫הראש‬ ‫לגבי‬ ‫רק‬ ‫בדיוק‬ ‫הדבר‬ ‫אותו‬
.‫הקורא‬
seekg(int pos)
‫הראש‬ ‫לגבי‬ ‫רק‬ ‫בדיוק‬ ‫הדבר‬ ‫אותו‬
.‫הקורא‬
tellg()
int n = file1.tellg(); :‫למשל‬ ,‫לפני‬ ‫המשתנה‬ ‫שם‬ ‫את‬ ‫לשים‬ ‫צריכים‬ ‫שאנחנו‬ ‫לזכור‬ ‫חשוב‬
.(‫עליו‬ ‫עובד‬ le1‫ש־‬ ‫הקובץ‬ ‫לאותו‬ ‫יתייחס‬ ‫זה‬ ‫)ואז‬ .file1.seekg(12); ‫או‬
3

4. II ‫חלק‬
(Pointers) ‫מצביעים‬
‫בסיס‬ 3
.int ‫מסוג‬ ‫משתנה‬ ‫של‬ ‫כתובת‬ ‫מחזיק‬ int *p :‫למשל‬ .‫בזיכרון‬ ‫כתובת‬ ‫שמכיל‬ ‫משנה‬ ‫הוא‬ ‫מצביע‬
:‫למשל‬
int n=10,m=12;
int *p=n;
cout *p; //will print 10
‫או‬ :(‫ערך‬ ‫אליו‬ ‫להעביר‬ ‫)או‬ ‫למצביע‬ ‫להתייחס‬ ‫אפשרויות‬ ‫שתי‬ ‫יש‬ ‫עצמה‬ ‫התוכנית‬ ‫כדי‬ ‫תוך‬
.n‫ל־‬ ‫מצביע‬ p ‫־‬ ‫תוצאה‬ ‫אותה‬ ‫את‬ ‫נקבל‬ ‫המקרים‬ ‫בשני‬ *p=n; ‫או‬ p=n;
‫של‬ ‫הכתובת‬ ‫את‬ p ‫למצביע‬ ‫להכניס‬ ‫אומר‬ p=n ‫ולכן‬ ,n ‫של‬ ‫הכתובת‬ ‫פירושו‬ ‫־‬ n :‫הסבר‬
(...‫כתובת‬ ‫מכיל‬ p :‫)תזכורת‬ .n ‫המשתנה‬
:‫מורכב‬ ‫יותר‬ ‫טיפה‬ ‫קוד‬ ‫על‬ ‫נסתכל‬ ‫כעת‬
int n=10,m=12;
int *p=n;
cout *p; //Will print 10.
n=28;
cout *p; //Will print 28.
p=m;
cout *p; //Will print 12.
‫מה‬ ‫את‬ ‫לשנות‬ ‫ניתן‬ .‫כתובת‬ ‫שמכיל‬ ‫משתנה‬ ‫הוא‬ ‫מצביע‬ :‫הוא‬ ‫לזכור‬ ‫שחשוב‬ ‫מה‬ ,‫כלומר‬
‫שהמצביע‬ ‫מה‬ ‫את‬ ‫לשנות‬ ‫ניתן‬ ‫)כלומר‬ ‫מצביע‬ ‫המצביע‬ ‫שאליו‬ ‫מה‬ ‫ואת‬ ‫עליו‬ ‫מצביע‬ ‫שהמצביע‬
.(‫אחר‬ ‫למשהו‬ ‫יצביע‬ p‫ש־‬ ‫זה‬ ‫ואת‬ ‫עליו‬ ‫מצביע‬ p
:‫הנושא‬ ‫את‬ ‫טוב‬ ‫יותר‬ ‫שתבהיר‬ ‫דיאגרמה‬ ‫הנה‬
:int x = 12 ‫רגיל‬ ‫משתנה‬
.‫לשנותו‬ ‫שניתן‬ ‫וכמובן‬ 12 ‫הערך‬ ‫את‬ ‫מכיל‬ x , x // 12
.x :‫הינה‬ x ‫של‬ ‫כתובתו‬
4

5. 1
:int ∗ p = x ‫מצביע‬
p // x // The value of x
y // The value of y
‫כמו‬ ‫משהו‬ ‫נרשום‬ ‫אם‬ ‫ולכן‬ x ‫של‬ ‫כתובתו‬ ‫על‬ ‫מצביע‬ p ,‫כלומר‬ ,x‫ל־‬ ‫מצביע‬ p
.(x ‫של‬ ‫ערכו‬ ‫את‬ ‫נשנה‬ ‫אם‬ ‫)גם‬ x ‫של‬ ‫ערכו‬ ‫את‬ ‫נקבל‬ cout ∗p
:‫הוא‬ ‫שנקבל‬ ‫מה‬ ‫אזי‬ p = y ‫או‬ :‫הבאות‬ ‫מהפקודות‬ ‫האחת‬ ‫את‬ ‫נרשום‬ ‫אם‬ ,‫כעת‬
p
x // The value of x
y // The value of y
.y ‫של‬ ‫המשתנה‬ ‫כתובת‬ ‫על‬ ‫מצביע‬ p ‫כעת‬ ,‫כלומר‬
∗p = ∗q ‫לרשום‬ ‫היה‬ ‫ניתן‬ ‫אזי‬ int ∗ q ‫נניח‬ ,‫מצביע‬ ‫עוד‬ ‫לנו‬ ‫היה‬ ‫אם‬ ,‫או‬
‫ניתן‬ ‫ולא‬ ‫קבוע‬ ‫באופן‬ ‫למשהו‬ ‫מצביע‬ ‫הוא‬ p ‫)כי‬ ‫תתקמפל‬ ‫לא‬ p = y ‫כמו‬ ‫פקודה‬ ,‫כלומר‬
‫מכיוון‬ ‫בעיה‬ ‫שום‬ ‫ללא‬ x ‫של‬ ‫ערכו‬ ‫את‬ ‫לשנות‬ ‫ניתן‬ ‫לעומת‬ ,(‫עליו‬ ‫מצביע‬ ‫שהוא‬ ‫מה‬ ‫את‬ ‫להזיז‬
.‫עליו‬ ‫מצביע‬ p‫ש־‬ ‫מה‬ ‫את‬ ‫משנה‬ ‫לא‬ ‫שזה‬
:‫הערה‬
:‫הבא‬ ‫בקוד‬ ‫האחרונה‬ ‫השורה‬ ‫על‬ ‫נסתכל‬
int n=12;
int *p=n;
int m=6;
*p=m; // Change the value of n.
.n ‫של‬ ‫ערכו‬ ‫את‬ ‫משנה‬ ‫שהיא‬ ‫זה‬ ‫עושה‬ ‫שהיא‬ ‫מה‬
‫דינמית‬ ‫והקצאה‬ ‫מצביעים‬ 4
.‫למערך‬ ‫פוטנציאל‬ ‫הוא‬ ‫מצביע‬ ‫כל‬ ‫שבעצם‬ ‫לומר‬ ‫ניתן‬
:‫דינמית‬ ‫להקצות‬ ‫הוא‬ ‫שצריך‬ ‫מה‬ ,‫לכן‬
.‫המתאים‬ ‫בחלק‬ using std::nothrow ‫־‬ ‫נשים‬ ‫תחילה‬
:‫הבא‬ ‫בקוד‬ ‫נביט‬ ‫מכן‬ ‫לאחר‬
// ----Part 1----
int *p=NULL;
p=new (nothrow) int [size];
// ----Part 2----
if (p==NULL)
.‫בהגדרה‬ ‫אותו‬ ‫מאתחל‬ ‫אני‬ ‫הקומפקטיות‬ ‫בשביל‬ ‫אבל‬ ,‫יותר‬ ‫מאוחר‬ ‫בשלב‬ ‫לבצע‬ ‫ניתן‬ ‫האיתחול‬ ‫את‬1
5

6. {
cerr ...;
...
}
// ----Part 3----
for (int i=0; isize; i++)
cin p[i];
//Same as - cin *(p+i)
p-=size; //Came back to the first cell.
// ----Part 4----
delete []p;
:‫ראשון‬ ‫חלק‬
‫לא‬ ‫התוכנית‬ ‫אזי‬ ‫כהלכה‬ ‫מתבעת‬ ‫איננה‬ ‫ההקצאה‬ ‫שאם‬ ‫בשביל‬ ‫הוא‬ nothrow‫ה־‬ .‫ההקצאה‬
.‫תעוף‬
:‫שני‬ ‫חלק‬
.‫מצליחה‬ ‫איננה‬ ‫ההקצאה‬ ‫כאשר‬ ‫קורה‬ ‫מה‬
:‫שלישי‬ ‫חלק‬
.‫המערך‬ ‫עם‬ ‫עבודה‬
:‫ביותר‬ ‫וחשוב‬ ‫רביעי‬ ‫חלק‬
!‫זומבי‬ ‫לנו‬ ‫יווצר‬ ‫אחרת‬ ‫־‬ ‫זה‬ ‫את‬ ‫לעשות‬ ‫לשכוח‬ ‫ולא‬ ‫זה‬ ‫את‬ ‫לבצע‬ ‫מאוד‬ ‫חשוב‬ .‫המערך‬ ‫מחיקת‬
(**p) ‫למצביע‬ ‫מצביע‬ 4.1
‫מצביע‬ ‫השני‬ ,‫דו־מימדי‬ ‫מערך‬ ‫של‬ ‫דינמית‬ ‫הקצאה‬ ‫הוא‬ ‫הראשון‬ ,‫לזה‬ ‫שימושים‬ ‫שני‬ ‫יש‬ ‫בעיקרון‬
.‫למצביע‬
.‫השניה‬ ‫האפשרות‬ ‫על‬ ‫אלא‬ ,‫כאן‬ ‫אדון‬ ‫לא‬ ‫הראשונה‬ ‫האפשרות‬ ‫על‬
:int ‫מסוג‬ ‫משתנה‬ ‫לנו‬ ‫ויש‬ ‫נניח‬
int n;
:‫מצביע‬ ‫אליו‬ ‫יוצרים‬ ‫ואנחנו‬
int *p1=n;
p1 // n :‫הבא‬ ‫הדבר‬ ‫את‬ ‫הוא‬ ‫שנקבל‬ ‫מה‬ ‫אזי‬
6

7. :‫למצביע‬ ‫מצביע‬ ‫נוסיף‬ ‫אם‬ ‫כעת‬
int **p2=p1;
:‫שלנו‬ ‫במקרה‬ ,‫כלומר‬ ,‫מצביע‬ ‫של‬ ‫כתובת‬ ‫שמחזיק‬ ‫מצביע‬ ‫הוא‬ ‫שנקבל‬ ‫מה‬
p2
p1 // n
.**p2=n‫ו־‬ *p2=p1 ‫לכן‬
‫מצביעים‬ ‫של‬ ‫מחיקה‬ 5
:‫הבא‬ ‫הדבר‬ ‫את‬ ‫ועשינו‬ ‫נניח‬
int *a=new (nothrow) int [10];
int *b=a;
delete []b;
‫למחוק‬ ‫שגיאה‬ ‫תהיה‬ ‫זאת‬ ‫לכן‬ ,‫שניהם‬ ‫את‬ ‫בעצם‬ ‫מחקנו‬ ‫המשתנים‬ ‫אחת‬ ‫את‬ ‫שמחקנו‬ ‫ברגע‬ ‫אזי‬
.‫שניהם‬ ‫את‬
(‫הפונקציה‬ ‫של‬ prototype‫ה־‬ ‫אומר‬ ‫)מה‬ ‫ופונקציות‬ ‫מצביעים‬ 6
‫פונקציה‬ ‫באמצעות‬ (4 ‫בחלק‬ ‫שמופיעה‬ ‫)מה‬ ‫מקושרת‬ ‫רשימה‬ ‫על‬ ‫לעבוד‬ ‫רוצים‬ ‫ואנחנו‬ ‫נניח‬
,‫כמו־כן‬ .‫רשימות‬ ‫אינם‬ ‫שהם‬ ‫דברים‬ ‫עבור‬ ‫גם‬ ‫תקף‬ ‫שזה‬ ‫וכמובן‬ ,‫נוח‬ ‫יותר‬ ‫זה‬ ‫כי‬ ‫]פשוט‬
:‫אפשרויות‬ ‫מספר‬ ‫ישנן‬ ‫אזי‬ ,[‫לסבך‬ ‫לא‬ ‫כדי‬ next‫ה־‬ ‫מרכיה‬ ‫את‬ ‫שמתי‬ ‫לא‬ ‫כאן‬ ‫ברימשות‬
int f(int *p) ‫־‬ 6.1
:‫כלומר‬ ,head ‫של‬ ‫עותק‬ ‫יוצרת‬ ‫הפונקציה‬
f (int *p) // head
∗head // 3 // 4
‫פקודה‬ ‫נרשום‬ ‫אם‬ ,‫לכן‬ ,‫המקורי‬ head‫ה־‬ ‫של‬ ‫העתק‬ ‫רק‬ ‫הוא‬ ‫רואים‬ ‫שאנחנו‬ ‫המקוקוו‬ head‫ה־‬
‫את‬ ‫ונשאיר‬ ‫ההעתק‬ ‫את‬ ‫נמחק‬ ‫שבעצם‬ ‫הוא‬ ‫שנעשה‬ ‫מה‬ ‫אזי‬ (‫הפונקציה‬ ‫)בתוך‬ p=NULL; ‫כמו‬
.‫שהיא‬ ‫כמו‬ ‫המקורית‬ ‫הרשימה‬
:‫תעשה‬ ‫שהיא‬ ‫מה‬ ‫זה‬
7

8. f (int *p) //
H
HH
H
head
∗head // 3 // 4
...‫כלום‬ ‫שינינו‬ ‫לא‬ ,‫כלומר‬
int f(int *p) ‫־‬ 6.2
:‫ולכן‬ ‫המקורי‬ ‫למצביע‬ ‫מצביעה‬ ‫הפוקציה‬ ‫כזה‬ ‫במקרה‬
f (int *p)
uu
∗head // 3 // 4
!‫זומבי‬ ‫ניצור‬ ‫כך‬ ‫ועי‬ ‫ברשימה‬ ‫הראשון‬ ‫האיבר‬ ‫את‬ ‫נמחק‬ p=NULL; ‫נכתוב‬ ‫אם‬ ‫כזה‬ ‫במקרה‬
f (int *p)
uu
∗head
3 4
int f(const int *p) ‫־‬ 6.3
‫כמו־‬ ‫משהו‬ ‫לכתוב‬ ‫אסור‬ :‫למשל‬ ,‫עליו‬ ‫מצביע‬ p ‫ש־‬ ‫מה‬ ‫את‬ ‫לשנות‬ ‫לנו‬ ‫אסור‬ ‫כזה‬ ‫במקרה‬
.p=NULL;
int f(int *const p) ‫־‬ 6.4
*p=12; :‫למשל‬ ,‫עליו‬ ‫מצביע‬ p‫ש־‬ ‫מה‬ ‫של‬ ‫הערך‬ ‫את‬ ‫לשנות‬ ‫לנו‬ ‫מאפשר‬ ‫אינו‬
8

9. III ‫חלק‬
‫מבנים‬
‫כללי‬ ‫מבנה‬ 7
:‫הבאה‬ ‫בצורה‬ ‫מוגדר‬ ‫מבנה‬
struct Point{
int _x;
int _y;
};
.y‫ו־‬ x :‫משתנים‬ ‫שני‬ ‫עם‬ ‫קופסה‬ ‫זאת‬ ‫כאן‬ ‫שנוצרה‬ ‫מה‬
:‫מבנה‬ ‫שמגדירים‬ ‫לעשות‬ ‫שצריך‬ ‫דברים‬ ‫שני‬ ‫יש‬ ,‫בעיקרון‬
.‫גדולה‬ ‫באות‬ ‫המבנה‬ ‫שם‬ ‫את‬ ‫להתחיל‬ .1
. ‫עם‬ ‫במבנה‬ ‫משתנה‬ ‫כל‬ ‫להתחיל‬ .2
:‫למשל‬ ,. ‫עי‬ ‫היא‬ ‫במבנה‬ ‫לערך‬ ‫הגישה‬
struct Point p1;
p1._x=12;
p1._x=17;
‫ומצביעים‬ ‫מבנים‬ 8
:‫למבנה‬ ‫מצביע‬ ‫לנו‬ ‫ויש‬ ‫נניח‬
struct Point *p
:‫הבא‬ ‫הדבר‬ ‫את‬ ‫לכתוב‬ ‫יותר‬ ‫מקובל‬ ‫אבל‬ (*p)._x=12; ‫עי‬ ‫היא‬ ‫אליו‬ ‫לגשת‬ ‫הדרך‬ ‫אזי‬
p-_x=12;
!‫במצביעים‬ ‫מדובר‬ ‫כאשר‬ ‫רק‬ ‫זה‬
9

10. IV ‫חלק‬
‫מקושרות‬ ‫רשימות‬
:‫מקושרת‬ ‫ברשימה‬ ‫איבר‬ ‫נראה‬ ‫ככה‬
data ∗next
‫ואחת‬ (‫שלנו‬ ‫)במקרה‬ ‫מספר‬ ‫עם‬ ‫אחת‬ ‫־‬ ‫יותר‬ ‫קטנות‬ ‫קופסאות‬ ‫שתי‬ ‫שמכילה‬ ‫קופסא‬ ‫הוא‬
:‫אחרת‬ ‫אבל‬ ‫כזאת‬ ‫לקופסא‬ ‫מצביעה‬
data ∗next
KK
data ∗next
(‫הקופסא‬ ‫לכל‬ ‫מצביע‬ ‫בעצם‬ ‫הוא‬ ‫הבא‬ data ‫ל‬ ‫מצביע‬ *next ‫ש‬ ‫נראה‬ ‫בשירטוט‬ ‫שכאן‬ ‫)אפילו‬
:‫לרשום‬ ‫נצטרך‬ ‫הבאה‬ ‫הקופסא‬ ‫של‬ data‫ל־‬ ‫לגשת‬ ‫נרצה‬ ‫אם‬
next -_data
‫למצביע‬ ‫ומצביע‬ ‫מקושרת‬ ‫רשימה‬ 9
:‫למצביע‬ ‫מצביע‬ ‫באמצעות‬ ‫לרשימה‬ ‫איבר‬ ‫להכניס‬ ‫ניתן‬ ,‫בעיקרון‬
.‫למצביע‬ ‫מצביע‬ ‫באמצעות‬ ‫לרשימה‬ ‫איבר‬ ‫מכניסה‬ insert ‫שהפונקציה‬ ‫נניח‬
insert 8 ∗next
∗head // 3 ∗next // 5 ∗next
‫שני‬ ‫הנה‬ ,‫הרשימה‬ ‫לסוף‬ ‫או‬ ‫הרשימה‬ ‫לראש‬ ‫מכניסה‬ ‫שהיא‬ ‫או‬ :‫אפשרויות‬ ‫שתי‬ ‫ישנן‬ ‫אזי‬
:‫מהמקרים‬ ‫אחד‬ ‫לכל‬ ‫הפונקציות‬
‫למצביע‬ ‫מצביע‬ ‫באמצעות‬ ‫הרשימה‬ ‫לראש‬ ‫איבר‬ ‫הכנסת‬ 9.1
void insert(int num , struct Node **head)
{
struct Node *temp=new (nothrow) struct Node; 1
(if...)
temp -_data=num; 1
temp -_next=head; 2
*head=temp;
}
‫המספר‬ ‫עם‬ ‫חדש‬ ‫אוביקט‬ ‫ויוצרת‬ head ‫של‬ ‫הכתובת‬ ‫את‬ ‫מקבלת‬ ‫הפוקנציה‬ ?‫כאן‬ ‫נעשה‬ ‫מה‬
:‫הרצוי‬
10

11. insert
8 ∗next
∗head // 3 ∗next // 5 ∗next
‫למציע‬ ‫שהמצביע‬ ‫לאן‬ ‫להצביע‬ ‫החדש‬ ‫האיבר‬ ‫של‬ *next‫ה־‬ ‫את‬ ‫הופכת‬ ‫הפונקציה‬ ‫השני‬ ‫בשלב‬
: *head‫ל־‬ ‫מצביע‬
insert
8 ∗next
∗head // 3 ∗next // 5 ∗next
:temp‫ל־‬ ‫להצביע‬ ‫עובר‬ **head ‫למצביע‬ ‫המצביע‬ ‫הרשימה‬ ‫בראש‬ ‫יהיה‬ ‫אכן‬ 8‫ש־‬ ‫בשביל‬ ,‫כעת‬
insert
8 ∗next
∗head
77
3 ∗next // 5 ∗next
!‫לרשימה‬ ‫המבוקש‬ ‫האיבר‬ ‫את‬ ‫הוספנו‬ ‫וכך‬
‫למצביע‬ ‫מצביע‬ ‫באמצעות‬ ‫הרשימה‬ ‫לסוף‬ ‫איבר‬ ‫הכנסת‬ 9.2
:‫קטנה‬ ‫תוספת‬ ‫ישנה‬ ‫שהפעם‬ ‫רק‬ ‫מקודם‬ ‫כמו‬ ‫רעיון‬ ‫אותו‬
void insert(int num , struct Node **head)
{
struct Node *temp=new (nothrow) struct Node; 1
(if...)
temp -_data=num; 1
while (*head!=NULL)
head =((* head)-_next );
temp -_next=head; 2
*head=temp;
}
‫לאיבר‬ ‫מגיע‬ ‫שהוא‬ ‫עד‬ ‫הבא‬ ‫לאיבר‬ ‫פעם‬ ‫כל‬ ‫מתקדם‬ ‫למצביע‬ ‫שהמצביע‬ ‫זה‬ ‫כאן‬ ‫שקורה‬ ‫מה‬
.‫הרשימה‬ ‫לסוף‬ ‫הגיע‬ ‫שהוא‬ ‫הוא‬ ‫הדבר‬ ‫ופירוש‬ NULL ‫הוא‬ ‫שלו‬ ‫שהבא‬
:‫זה‬ ‫את‬ ‫שממחישה‬ ‫דיאגרמה‬ ‫הנה‬
insert
8 ∗next
∗head // 3 ∗next // 5 ∗next // 6 ∗next // 7 ∗next
:‫הבא‬ ‫למצביע‬ ‫ממשיך‬ ‫הוא‬ ‫לכן‬ ,NULL ‫אינו‬ ‫עליו‬ ‫מצביע‬ *head‫ש־‬ ‫מה‬
insert
8 ∗next
∗head // 3 ∗next // 5 ∗next // 6 ∗next // 7 ∗next
11

12. :‫הלאה‬ ‫וכך‬
insert
8 ∗next
∗head // 3 ∗next // 5 ∗next // 6 ∗next // 7 ∗next
:‫על‬ ‫להצביע‬ ‫מגיע‬ ‫שהוא‬ ‫עד‬
insert
8 ∗next
∗head // 3 ∗next // 5 ∗next // 6 ∗next // 7 ∗next
...‫מקודם‬ ‫כמו‬ ‫האיבר‬ ‫את‬ ‫מכניס‬ ‫הוא‬ ‫ואז‬ *head=NULL :‫אכן‬ ‫הזה‬ ‫במקרה‬
:‫למשל‬ .‫המתאים‬ ‫במקום‬ ‫האביר‬ ‫את‬ ‫להכנסי‬ ‫וכך‬ ‫אחרת‬ ‫הלולאה‬ ‫תנאי‬ ‫את‬ ‫לנסח‬ ‫שניתן‬ ‫כמובן‬
.‫ממוינת‬ ‫רשימה‬ ‫לנו‬ ‫יצור‬ ‫־‬ while (*head!=NULL (*head)_datanum)
:‫לזכור‬ ‫חשוב‬
‫להיות‬ ‫שיכול‬ ‫בחשבון‬ ‫לקחת‬ ‫צריך‬ ‫תמיד‬ ,‫ברשימה‬ ‫שמטפלת‬ ‫פונקציה‬ ‫בונים‬ ‫שאנחנו‬ ‫תמיד‬
!‫בכך‬ ‫לטפל‬ ‫צריך‬ (‫הפונקציה‬ ‫)בתחילת‬ ‫ההתחלה‬ ‫על‬ ‫ולכן‬ ,‫ריקה‬ ‫שהרשימה‬
12

13. V ‫חלק‬
‫בינאריים‬ ‫חיפוש‬ ‫עצי‬
‫מה‬ (‫)צומת‬ ‫קודקוד‬ ‫לכל‬ ‫עלים‬/‫צמתים‬ ‫לשים‬ ‫היכן‬ ‫יהיה‬ ‫תמיד‬ ‫בינארי‬ ‫חיפוש‬ ‫בעץ‬ :‫הגדרה‬
:‫למשל‬ ,‫ממנו‬ ‫גדול‬ ‫שמימינו‬ ‫ומה‬ ‫לו‬ ‫שווה‬ ‫או‬ ‫קטן‬ ‫שמשמאלו‬
50
}} !!
30
}} !!
70
!!
25
}}
32
♠
}}
74
!!
}}
10 30 79 83
}}
83
:‫דברים‬ ‫כמה‬ ‫לזכור‬ ‫חשוב‬
‫להיות‬ ‫יכול‬ ‫אחרת‬ ‫הנתונים‬ ‫את‬ ‫מכניסים‬ ‫היינו‬ ‫אם‬ .‫הנתונים‬ ‫הכנסת‬ ‫לסדר‬ ‫קשר‬ ‫שישנו‬ ‫כמובן‬
‫כמובן‬ ‫הוא‬ ♠‫ב־‬ ‫שמסומן‬ 30 ‫עם‬ ‫הקודקוד‬ ‫שנמצא‬ ‫היכן‬ ‫למשל‬ .‫אחרת‬ ‫קצת‬ ‫נראה‬ ‫היה‬ ‫שהעץ‬
.32‫ל־‬ ‫מתחת‬ ‫הוא‬ ‫אליו‬ ‫אותו‬ ‫להכניס‬ ‫צריך‬ ‫שהיה‬ ‫המקום‬ ‫ולכן‬ 25‫ו־‬ 32‫ה־‬ ‫אחרי‬ ‫נכנס‬
:‫העץ‬ ‫נראה‬ ‫היה‬ ‫ככה‬ ,‫השני‬ 30‫ה־‬ ‫אחרי‬ 32‫ה־‬ ‫את‬ ‫את‬ ‫מכניסים‬ ‫היינו‬ ‫נניח‬ ‫אם‬ ,‫זאת‬ ‫לעומת‬
50
}} !!
30
}} !!
70
!!
25
}}
♠
!!
32 74
!!
}}
10 30 79 83
}}
83
‫עצים‬ ‫של‬ ‫פונקציות‬ 10
.‫לזכור‬ ‫חשוב‬ ‫שמאוד‬ ‫דברים‬ ‫כמה‬ ‫יש‬ ‫לכן‬ ,‫רקורסיביות‬ ‫פונקציות‬ ‫ברובן‬ ‫הן‬ ‫עצים‬ ‫של‬ ‫פונקציות‬
:‫כך‬ ‫בנויה‬ ‫פונקציה‬ ‫כל‬ ‫בעיקרון‬
‫אזי‬ ‫ריק‬ ‫העץ‬ ‫שאם‬ ‫לוודא‬ ‫הוא‬ !!!‫ואופן‬ ‫פנים‬ ‫בשום‬ ‫אותו‬ ‫לשכוח‬ ‫שאסור‬ ‫־‬ ‫הראשון‬ ‫השלב‬
.‫להתחיל‬ ‫הפונקציה‬ ‫חייבת‬ ‫ככה‬ ‫אבל‬ ‫ערך‬ ‫בלי‬ ‫או‬ ‫ערך‬ ‫עם‬ ‫להיות‬ ‫יכול‬ return ‫עושים‬ ‫אנחנו‬
.(‫שלה‬ ‫הייעוד‬ ,‫)כלומר‬ ‫הפונקציה‬ ‫עיקר‬ ‫שזה‬ ‫־‬ ‫תנאי‬ ‫כלל‬ ‫בדרך‬ ‫יהיה‬ ‫הוא‬ ‫־‬ ‫השני‬ ‫השלב‬
.‫עצמה‬ ‫הרקורסיה‬ ‫זאת‬ ‫־‬ ‫השלישי‬ ‫השלב‬
.(‫הבא‬ ‫בחלק‬ ‫פונקציות‬ ‫על‬ ‫פירוט‬ ‫)יותר‬
13

14. ‫העץ‬ ‫בתוך‬ ‫ביקורים‬ 10.1
‫הוא‬ ‫לזכור‬ ‫שחשוב‬ ‫מה‬ ,‫ביקורים‬ ‫סוגי‬ ‫שלושה‬ ‫ישנם‬ ,‫בעץ‬ ‫שתבקר‬ ‫פונקציה‬ ‫בונים‬ ‫אנחנו‬ ‫כאשר‬
.‫הימני‬ ‫בילד‬ ‫מכן‬ ‫לאחר‬ ‫ורק‬ ‫השמאלי‬ ‫בילד‬ ‫מבקרים‬ ‫כל‬ ‫קודם‬ ‫אנחנו‬ ‫שתמיד‬
Preorder ‫־‬ ‫תחילי‬ ‫ביקור‬ 10.1.1
‫זה‬ ‫את‬ ‫עושים‬ ‫אנחנו‬ .‫הימני‬ ‫בילד‬ ‫מכן‬ ‫ולאחר‬ ‫השמאלי‬ ‫בילד‬ ‫מכן‬ ‫ולאחר‬ ‫בשורש‬ ‫מבקרים‬
‫אז‬ ‫ורק‬ ‫נמצאים‬ ‫אנחנו‬ ‫שבה‬ ‫הצומת‬ ‫על‬ ‫הפעולה‬ ‫את‬ ‫לעשות‬ ‫כל‬ ‫קודם‬ ‫רוצים‬ ‫אנחנו‬ ‫כאשר‬
.‫הקודקודים‬ ‫לשאר‬ ‫להמשיך‬
Inorder ‫תוכי‬ ‫ביקור‬ 10.1.2
‫)בהנחה‬ ‫בעץ‬ ‫לבקר‬ ‫לנו‬ ‫שנותן‬ ‫ביקרו‬ ‫זה‬ .‫ימני‬ ‫בילד‬ ‫ואחכ‬ ‫בשורש‬ ‫אחכ‬ ,‫שמאלי‬ ‫בילד‬ ‫מבקרים‬
‫כזה‬ ‫ביקור‬ ‫עם‬ ‫לפונקציה‬ ‫דוגמא‬ ‫הנה‬ .‫גדול‬ ‫להכי‬ ‫קטן‬ ‫הכי‬ ‫מהשורש‬ (‫בינארי‬ ‫חיפוש‬ ‫עץ‬ ‫שהוא‬
:‫עץ‬ ‫של‬ ‫הדפסה‬ ‫פונקצית‬ ‫־‬
print (struct Node *root)
{
if (root==NULL)
return;
print(root -_left );
cout root -_data;
print(root -_right );
}
Postorder ‫סופי‬ ‫ביקור‬ 10.1.3
‫אנחנו‬ ‫כאשר‬ ‫טוב‬ ‫זה‬ ‫ביקור‬ .‫בשורש‬ ‫ולבסוף‬ ‫המני‬ ‫בילדי‬ ‫אחכ‬ ,‫השמאלי‬ ‫בילד‬ ‫קודם‬ ‫מבקרים‬
:‫העצץ‬ ‫מחיקת‬ ,‫למשל‬ ,‫הביקור‬ ‫בסוף‬ ‫רק‬ ‫הפעולה‬ ‫את‬ ‫לבצע‬ ‫ורצים‬
del (struct Node *root)
{
if (root!=NULL)
{
del(root -_left );
del(root -_right );
del(root);
}
// insted of the first condition we could write:
// if (root==NULL)
// return;
}
‫העץ‬ ‫בכל‬ ‫מבקרים‬ ‫כל‬ ‫קודם‬ ‫אנחנו‬ ‫כאן‬ ‫כי‬ ‫־‬ ‫כולו‬ ‫העץ‬ ‫את‬ ‫מוחק‬ ‫היה‬ ‫לא‬ ‫בעץ‬ ‫אחר‬ ‫ביקור‬ ‫כל‬
.(‫הרקורסיה‬ ‫)עפ‬
14

15. ‫ערך‬ ‫שמחזירה‬ ‫רקורסיה‬ 10.2
.(‫)למשל‬ ‫ערכו‬ ‫את‬ ‫תחזיר‬ ‫גם‬ ‫אלא‬ ,‫בעץ‬ ‫תבקר‬ ‫רק‬ ‫שלא‬ ‫רקורסיה‬ ‫רוצים‬ ‫ואנחנו‬ ‫נניח‬
:‫בעץ‬ ‫הצמתים‬ ‫כל‬ ‫סכום‬ ‫את‬ ‫שמחזירה‬ ‫פונקציה‬ ‫הנה‬
int sum (const struct Node *root)
{
while (root!=NULL)
{
return root -_data+sum(root -_left )+sum(root -_right );
}
return 0;
}
VI ‫חלק‬
‫גנריים‬ ‫ומצביעים‬ ‫לפונקציות‬ ‫מצביעים‬
‫לפונקציות‬ ‫מצביעים‬ 11
:‫כללית‬ ‫פונקציה‬ ‫לכתוב‬ ‫רוצים‬ ‫כאשר‬
double (*func_name) (int,char);
‫מחזירה‬ ‫הכללית‬ ‫הפונקציה‬ ‫מה‬ .(‫המצביע‬ ‫)של‬ ‫שלה‬ ‫השם‬ ‫מה‬ ‫מקבלת‬ ‫היא‬ ‫מה‬
‫־‬ ‫דוגמא‬ ‫והנה‬
‫תוכל‬ func_name‫ו־‬ ‫להתאים‬ ‫תוכל‬ ‫כזאת‬ ‫פונקציה‬ ‫־‬ double func1(int n ,char c); ‫־‬ ‫יעבוד‬
.‫עליה‬ ‫להצביע‬
.‫שונה‬ ‫שהיה‬ ‫אחר‬ ‫דבר‬ ‫כל‬ ‫או‬ ‫־‬ int func2(int a ,char c) :‫יעבוד‬ ‫לא‬
int func3 (*simple) (const :‫למשל‬ ,‫לפני‬ ‫או‬ const ‫ישנו‬ ‫לאם‬ ‫לב‬ ‫לשים‬ ‫גם‬ ‫חשוב‬ ‫כן‬ ‫כמו‬
‫רק‬ ‫לקבל‬ ‫יכולה‬ ‫הזאת‬ ‫הפונקציה‬ ‫אזי‬ struct Node *root, char a, const int num)
.‫דומה‬ ‫מסוג‬ ‫דברים‬
‫גנריים‬ ‫מצביעים‬ 12
‫אלא‬ ‫ישירות‬ ‫אליו‬ ‫לגשת‬ ‫ניתן‬ ‫לא‬ void *p :‫משתנה‬ ‫לכל‬ ‫לצביע‬ ‫שיכול‬ ‫מצביע‬ ‫הוא‬ ‫גנרי‬ ‫מצביע‬
:‫למשל‬ ,(‫המתאים‬ ‫לטיפוס‬ ‫)המרה‬ Casting ‫לו‬ ‫שעושים‬ ‫אחרי‬ ‫רק‬
int_p *(const void *p)
{
return (int*)p;
}
// ------------------------------
int_p2 (const void *p)
{
return *(( int *)p);
}
15

16. ‫מחזירה‬ ‫השניה‬ ‫הפונקציה‬ ‫ואילו‬ int (int *) ‫מסוג‬ ‫למשתנה‬ ‫מצביע‬ ‫מחזירה‬ ‫הראשונה‬ ‫הפוקנציה‬
‫הכתובת‬ ‫בתוך‬ ‫שנמצא‬ ‫מה‬ ‫של‬ ‫הערך‬ ‫בפועל‬ ‫שזה‬ ,‫הכוכבית‬ ‫היא‬ ‫לכך‬ ‫הסיבה‬ int ‫מסוג‬ ‫ערך‬
.(‫המבוקש‬ ‫לסוג‬ ‫)או‬ int‫ל־‬ ‫המרה‬ ‫לה‬ ‫שעשינו‬ ‫אחרי‬
‫לזכור‬ ‫צריך‬ ‫אזי‬ ,‫לפונקציה‬ ‫מצביע‬ ‫עם‬ ‫עליו‬ ‫לעבוד‬ ‫רוצים‬ ‫ואנחנו‬ ‫מערך‬ ‫וישנו‬ ‫נניח‬ ,‫כעת‬
:‫של‬ ‫בסגנון‬ ‫משהו‬ ‫לכתוב‬ ‫עלינו‬ ‫לכן‬ ,‫לזוז‬ ‫עליו‬ ‫תאים‬ ‫כמה‬ ‫יודע‬ ‫אינו‬ ‫הגנרי‬ ‫שהמצביע‬
void *p_to_int(const void *p,int i)
{
return ((int*)p)+i;
}
‫וההחלפה‬ ‫ההשוואה‬ ‫פעולות‬ ‫שאת‬ ‫לזכור‬ ‫צריך‬ ,‫מיון‬ ‫פונקצית‬ ‫לייצר‬ ‫רוצים‬ ‫ואנחנו‬ ‫נניח‬ ,‫כעת‬
:‫עבורם‬ ‫זה‬ ‫את‬ ‫לכתוב‬ ‫נצטרך‬ ‫ולכן‬ ‫לעשות‬ ‫יכולים‬ ‫לא‬ ‫גנריים‬ ‫מצבביעים‬
void sort (void *, void *(get_p)(void *,int),
bool (*cmp)(void *,void *), void swap (void *,void *)
{
...
}
‫ורשימות‬ ‫גנריים‬ ‫מצביעים‬ 12.1
‫עושים‬ ‫אנחנו‬ ‫כאשר‬ ‫דינמית‬ ‫הקצאה‬ ‫עי‬ ‫גנריים‬ ‫מצבעים‬ ‫של‬ ‫רשימה‬ ‫ליצור‬ ‫ניתן‬
16