לימוד למתחילים C++

מדריכי תכנות

: הבסיס של1שיעור ++C

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

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

++C שלכל היא שפת תכנות. היא שפת תכנות של הרבה ניבים שונים, בדיוק כמו ,הם אינם כיוון שה"דוברים" גרים בצפון C שפה מדוברת יש ניבים רבים. אולם, ב

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

,Watcom C/386 ,Microsoft Visual C++ ,Borland C++ ו DJGPP. ניתן להוריד את DJGPP מ http://www.delorie.com/djgpp/ ייתכן שכבר יש לך מהדר אחר או .

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

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

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

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

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

#include <iostream.h>

int main(){ cout<<"HEY, you, I'm alive! Oh, and Hello World!"; return 0; }

#include זה לא נראה כל כך קשה, נכון? בואו נפרק את התוכנית ואז נתבונן בה. ה שאומרת למהדר לשים את הקוד שבקובץ הכותרת preprocessor הוא הנחייה ל

iostream.h בתוך התוכנית שלנו! באמצעות הכללת קבצי כותרת, ניתן להשיג גישה פונקציות שונות. לדוגמא, הפונקציה להרבה cout מצריכה את הכללת הקובץ

iostream.h.

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

http://www.delorie.com/djgpp/

לסמן את ההתחלה והסוף של פונקציות, ושל גושי קוד אחרים. אם תכנתת בפסקל,כ תכיר אותם BEGIN ו END.

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

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

כל קריאה לפונקציה ב האותיות כפי שהיא. ה ; נוסף בסוף ++C.

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

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

מומלץ, כיוון שזה לא מתאים לסטנדרט של מכון התקנים האמריקאי אבל זה כבר לא (ANCI).

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

אותו בקובץ עם סיומת שמור cpp, והשתמש במהדר של שורת פקודה כדי להדר .ולקשר אותו

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

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

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

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

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

ו int ,char טיפוסים שונים של משתנים, עליהם יש להצהיר. הטיפוסים הבסיסיים הםfloat.

char משמש ליצירת משתנים שמאחסנים תווים, int משמש ליצירת משתנים ), ו44,-3,44,-1,2,0שמאחסנים מספרים שלמים (כמו float משמש להצהרה על

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

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

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

:להלן מספר דוגמאות של הצהרה על משתנים

int x;int a, b, c, d;char letter;float the_float;

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


int main(){ int thisisanumber; cout<<"Please enter a number:"; cin>>thisisanumber; cout<<"You entered: "<<thisisanumber; return 0;}

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

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

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

אין בכלל מירכאות. אם היו מירכאות, הפלט היה משתנה "You Entered: thisisanumber". אל תתבלבל מההכללה של שני אופרטורים שונים של הכנסה

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

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

. *, -, +, /, =,עכשיו שאתה יודע קצת על משתנים, הנה מספר דרכים לתפעל אותם הפשוטים. ה * הם כולם אופרטורים בהם משתמשים על מספרים, אלה הם==, <, <;

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

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

:להלן מספר דוגמאות

a=4*6; // a is 24 (שים לב לשימוש בהערות ובנקודה פסיק) a=a+5; // עם חמש יחידות נוספות a שווה לערך המקורי של aa==5 // 5שווה a במקום זאת בודק אם aלא מכניס חמש ל

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

.ולולאות if פקודות

וקטן מ. לדוגמא הם בדיקות של גדול מ <. וה < אתה יכול בוודאי לנחש בשביל מה ה :

a<5 // קטן מחמש a בודק אם a>5 בודק אם a גדול מחמש // a==5 // שווה לחמש, בשביל קנה מידה טוב a בודק אם


: פקודות2שיעור If

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

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

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

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

יותר, אבל הסמלים ב מאוחר ++C אינם NOT ,OR ו AND. משמעותם היא פשוט .זהה

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

.באותו אופן שמחשבים מבינים זאת false ו true הרעיון של

הוא 8.3 ו TRUE הוא1מסומלים במספר שונה מאפס, ואפס. לכן, C++ אמת ושקר ב TRUE הוא0אבל FALSE. אף מספר אחר לא מתפרש כשקר.

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

.שווים

.כדי לעשות זאת, משתמשים במספר אופרטורים

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

גדול מ > זה אמת 5>4קטן מ < זה אמת 4<5

גדול מ או שווה ל >= זה אמת 4>=4קטן מ או שווה ל <= זה אמת 3<=4

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

. עבור שקר, ומספר שונה מאפס עבור אמת0הבוליאנים. הם מחזירים

NOT: פירושו רק שהתכנית צריכה להפוך את הערך. לדוגמא, NOT(1) 0יהיה . NOT(0) 1יהיה .

( פרט לאפס כל מספר )NOT ב0יהיה . C ו NOT ,C++ נכתב כ !.

AND: זוהי פקודה חשובה נוספת, היא מחזירה אחד אם 'זה' AND (וגם) ' .זה' הם אמת )1( AND (0) 1. (הוא אמת 1 כיוון שלא שניהם אמת, רק 0יהיה( AND (1) כל1יהיה) .

)0) (מספר ממשי פרט לאפס AND כל מספר ממשי פרט לאפס0יהיה) .( AND (כל לאפס מספר ממשי פרט . ה1יהיה ( AND ב && נכתב כ ++C. אל תתבלבל ותחשוב

בין מספרים. זה לא. זכור ש שזה בודק שוויון AND יקבל ערך לפני OR.

OR: הפקודה OR בודקת הם היא שימושית מאוד! אם אחד מ (או) שני הערכים שהיא )1, (אמת, היא תחזיר אמת. לדוגמא OR (0) 0! (1יהיה( OR (0) כל מספר0יהיה) .

)ממשי OR ( לאפס כל מספר ממשי פרט ! ה1יהיה ( OR נכתב כ || ב ++C. אלו הם עשויים להראות כמו נקודתיים מתוחות. על על המקלדת שלך הם .pipe התווים של ה

.AND יקבל ערך לאחר OR המחשב שלי הם חולקים מקש עם \. זכור ש

). זה1זה יהיה אמת (, כמובן)! ? 1 && 0הדבר הבא הוא ללמוד לצרף אותם... מה זה ( 1! שווה ל 0 ו 0מקבל ערך 1 && 0כיוון ש .

לי נסה כמה מאלה... הם לא קשים. אם יש לך שאלות לגביהם, אתה יכול לשלוח email.

!(1 || 0) .A :0תשובה!(1 || 1 && 0) .B :0תשובה (AND מקבל ערך לפני OR)

!((1 || 0 ) && 0) .C :סוגריים הן שימושיות1תשובה) (

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

עם תנאים פקודות .

:הוא באופן בסיסי if המבנה של פקודת

if (TRUE)עשה את מה שנמצא בשורה הבאה

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

,לדוגמא

if (TRUE){

עשה את כל מה שבין הסוגריים המסולסלות}

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

:היא יכולה להראות כך

if (FALSE){

לא מתבצע אם זה שקר}else{

עשה את כל זה}

אותו ערך הוא אם יש שתי פקודות תנאי ששתיהן יהיו אמת עם else שימוש אחד של (30פחות מ הוא x יחזירו שניהם אמת אם x>50 ו x>30 ,אבל רק לפעמים. לדוגמא

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

במספר פקודות להשתמש else שאחריהן פקודות if.

...בואו נסתכל על תוכנית פשוטה בשביל שתנסה בעצמך


int main() //Most important part of the program!{ int age; //Need a variable... cout<<"Please input your age: "; //Asks for age cin>>age; //The input is put in age if(age<100) //If the age is less than 100 { cout<<"You are pretty young!"; //Just to show it works } else if(age==100) //I use else just to show an example { cout<<"You are old"; //Just to show you it works... } else if(age>100) { cout<<"You are really old"; //Proof that it works for any condition } return 0;}

הייתה צריכה לעשות או ! בתוכה. זה בגלל שהיא לא && || תכנית זו לא השתמשה ב .if זאת. מטרתה הייתה להדגים פקודות


: לולאות3שיעור

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

לכל אחד מהם יש שימוש ספציפי משלו. הם מתוארים .do while ו while ,for :לולאות :בקווים כלליים להלן

FOR - לולאות for הן הסוג השימושי ביותר. המבנה הוא

for(שינוי משתנה ;משפט תנאי ;אתחול משתנה)

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

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

x++, x=x+10, או אפילו x=random(5);, ואם אתה באמת רוצה, אתה יכול לקרוא אחרות שלא עושות כלום למשתנה. זה יהיה קרוב לודאי משהו מגוחך לפונקציות .

:דוגמא

#include <iostream.h> //We only need one header fileint main() //We always need this{

//The loop goes while x<100, and x increases by one every loop for(int x=0;x<100;x++) //Keep in mind that the loop condition checks { //the conditional statement before it loops again.

//consequently, when x equals 100 the loop breaks cout<<x<<endl; //Outputting x }

return 0;

}

100קטן מ x נקבע לאפס, כל עוד for. x תוכנית זו היא דוגמא פשוטה מאוד ללולאת עד שהלולאה מסתיימת. זכור גם x ל1ומוסיף ;cout>>x>>endl הוא קורא ל

.שהמשתנה מוגדל לאחר שהקוד בלולאה מורץ בפעם הראשונה

WHILE - לולאות while הן מאוד פשוטות. המבנה הבסיסי הוא...

While(true) אז בצע את כל הקוד בתוך הלולאה

שונה מ x שמשמעותו) while(x!=7) או x==1 מייצג ביטוי בוליאני שיכול להיות true המשפטים בוליאנים תקפים. אפילו זה יכול להיות כל צירוף של .(7 while(x==5||v==7)

את הקוד כל עוד שמשמעותו בצע x שווה חמש או כל עוד v 7שווה .

:דוגמא

#include <iostream.h> //We only need this header file

int main() //Of course... { int x=0; //Don't forget to declare variables while(x<100) //While x is less than 100 do { cout<<x<<endl; //Same output as the above loop x++; //Adds 1 to x every time it repeats, in for loops the //loop structure allows this to be done in the structure } return 0;}

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

שבודק את הביטוי ,while לסוגריים המסולסלות בסוף הוא חוזר בחזרה למעלה ל .הבוליאני

DO WHILE - לולאות DO WHILE הן שימושיות רק לדברים שרוצים שיתבצעו ;DO }THIS{ WHILE (TRUE) בלולאה לפחות פעם אחת. המבנה הוא

:דוגמא


int main(){ int x; x=0; do { cout<<"Hello world!"; }while(x!=0); //Loop while x is not zero, ut first execute the

//code in the section. (It outputs "Hello..." once

return 0;

}

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

|

המועדפי שלי ם

|

מחברתאישית

| תגובות

הקוראים|

השתתףבסקר

|

|

אודות

| תפריטאיתן


: פונקציות4שיעור

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

.פרודוקטיבי

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

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

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

:לדוגמא

int a;a=random(5); //random is sometimes defined by the compiler//Yes, it returns between 0 and the argument minus 1

הפונקציה הוא ייקבע לערך המוחזר כאשר ,random ישתנה ב 'a' אל תחשוב ש .נקראת, אבל לא ישתנה שוב

:המבנה הכללי של אב טיפוס הוא פשוט

שם_הפונקציה טיפוס_החזרה(שם_משתנה טיפוס_משתנה);

http://toolbar.eitan.ac.il/


http://eitan.ac.il/

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

int mult(int x, int y);

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

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

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

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

דובדבן מסולסלות. טוב, אולי לא .

:בואו נתבונן בתכנית לדוגמא


int mult(int x, int y);

int main(){ int x, y; cout<<"Please input two numbers to be multiplied: "; cin>>x>>y; cout<<"The product of your two numbers is "<<mult(x, y); return 0;

}

int mult(int x, int y){ return x*y;}

של תוכנית זו פותחת בקובץ המוכלל היחיד ההכרחי. לאחר מכן יש אב טיפוס היא יחידה שצריכה main הפונקציה. שים לב שיש לו נקודה פסיק בסוף! פונקצית ה

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

.עושה

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

cout יכולה להוציא כפלט את הערך המוחזר.

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

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

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

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

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

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

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


5שיעור : switch case

לשימוש ב ארוכות יותר. המבנה הבסיסי if הן תחליף לפקודות switch case פקודות switch case מתואר להלן בקווים כלליים:

Switch (expression or variable){ case variable equals this: do this; break; case variable equals this: do this; break; case variable equals this: do this; break; ... default: do this

}

שאחריו אז אומר שאם יש לו את הערך של מה case לביטוי או למשתנה יש ערך. ה break. case משמש לצאת מפקודות ה break עשה את מה שאחרי הנקודתיים. ה

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

case הבאה גם כן.

Switch case משמש פשוט כאמצעי לכתוב פקודות if קרובות ניתן ארוכות. לעיתים .להשתמש בו לעיבוד קלט ממשתמש

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

#include <iostream.h>#include <conio.h>

int main(){ char input; cout<<"1. Play game"; cout<<"2. Load game"; cout<<"3. Play multiplayer"; cout<<"4. Exit"; cin>>input; switch (input) { case 1: playgame();

break; case 2:

loadgame(); break; case 3: //Note use of : not ; playmultiplayer();

break; case 4: return 0; default: cout<<"Error, bad input, quitting"; }

return 0;

}

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

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

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

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

||


: הקדמה למצביעים6שיעור

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

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

תכנות מסוימות, כמו רשימות מקושרות גם מאפשרים טכניקות .

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

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

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

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

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

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

.התייחסות

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

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

:לדוגמא


int main(){ int x; //A normal integer int *pointer; //A pointer to an integer pointer=&x; //Read it, "pointer equals the address of x" cin>>x; //Reads in x cout<<*pointer;

//Note the use of the * to output the actual number stored in x

return 0;

}

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

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

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

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

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

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

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

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

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

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

:דוגמא

int *ptr = new int;

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

לתוכניות אחרות. דבר זה אומר שהמתכנת הזהיר ישחרר את הזיכרון הזה בסוף .השימוש בו

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

:דוגמא

delete ptr;

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

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

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

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

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: מבנים7שיעור

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

.הופך דברים ליותר מרוכזים. זה שימושי גם למסדי נתונים

:הוא (C זה שונה ב ,C++ ב) התבנית להצהרה על מבנה

struct NAME{ VARIABLES;};

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

NAME שם_המבנה_הבודד;



http://eitan.ac.il/

גישה למשתנה מהמבנה נעשית כך

;שם_המשתנה.שם_המבנה_הבודד

:לדוגמא

struct example{ int x;};

example an_example; //Treating it like a normal variable typean_example.x=33; //How to access it

:הנה תוכנית לדוגמא

struct database{ int id_number; int age; float salary;};

int main(){ database employee; //There is now an employee variable that has

//modifiable variables inside it. employee.age=22; employee.id_number=1; employee.salary=12000.21; return 0;

}

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

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

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

strucut database fn();

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

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

.זמן

.אופרטור ה '.' משמש לגישה למשתנים שונים בתוך האיחוד גם כן

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

אופרטור ה במקום<- .

:דוגמא מהירה

#include <iostream.h>struct xampl{ int x;};

int main()

{ xampl structure; xampl *ptr; structure.x=12; ptr=&structure; //Yes, you need the & when dealing with structures

//and using pointers to them cout<<ptr->x; //The -> acts somewhat like the * when used with pointers

//It says, get whatever is at that memory address

//Not "get what that memory address is" return 0;}

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: יסודות במערכים8שיעור

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

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

:חשוב על מערכים כך

[][][][][][]

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



http://eitan.ac.il/

:בואו נסתכל על המבנה של הגדרה של מערך

int examplearray[100]; //זה מגדיר מערך

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

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

. אלמנטים, לדוגמא100 במערך של 0-99פחות אחד. והאחרון הוא מספר האלמנטים

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

.של תווים

:לדוגמא

chat astring[100];

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

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

.לדון בזה כאן

.ההיבט השימושי ביותר של מערכים הוא מערכים רבי ממדים

.הדרך בה אני חושב על מערכים רבי ממדים

[][][][][][][][][][][][][][][][][][][][][][][][][]

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

:לדוגמא

int twodimensionalarray[8][8];

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

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

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

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

;משהו=[מספר_אינדקס_במערך]שם_המערך

:או, למערך דו-ממדי

]שם_המערך1][מספר_אינדקס_במערך2משהו=[מספר_אינדקס_במערך ;

למשל, אולם, אל תנסה אף פעם לכתוב נתונים מעבר לאלמנט האחרון של המערך . הזיכרון11 אלמנטים, ואתה מנסה לכתוב לאלמנט ה 10כאשר יש לך מערך של

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

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

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


int main(){ int x, y, anarray[8][8];//declares an array like a chessboard for(x=0; x<8; x++) { for(y=0; y<8; y++) { anarray[x][y]=0;

//sets the element to zero; after the loop all elements == 0 } } for(x=0; x<8;x++) { for(y=0; y<8; y++) {cout<<"anarray["<<x<<"]["<<y<<"]="<<anarray[x][y]<<" ";//you'll see } } return 0;}

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

.לכל המערך

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

char *ptr;char str[40];ptr=str; //gives the memory address without a reference operator(&)

בניגוד ל

int *ptr;int num;ptr=&num;//Requires & to give the memory address to the ptr

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: מחרוזות9שיעור

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

אם מחרוזות שקולות בדיקה .



http://eitan.ac.il/

קשורים) ההגדרה של מחרוזת תהיה כל דבר שמכיל מספר תווים (יותר מתו אחד למרות, היא מחרוזת. אולם, תווים בודדים לא יהיו מחרוזות "this" ,ביחד. לדוגמא

.שניתן להשתמש בהם כמחרוזות

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

"זוהי מחרוזת"

: אותיות, תרצה לומר50כדי להצהיר על מחרוזת של

char string[50];

ולא, תווים. אל תשכח שמערכים מתחילים באפס50זה יגדיר מחרוזת באורך של /'.0באופן מילולי תו ' ,null באחד למספר האינדקס. בנוסף, מחרוזת מסתיימת בתו

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

אותיות ותו 49להחזיק רק null אחד בסוף כדי לסיים את המחרוזת.

:הערה

;char *arry ניתן, גם יכול לשמש כמחרוזת. אם קראת את השיעור על מצביעים :לעשות משהו כמו

arry = new char[256];

עליך delete כאילו זה היה מערך. זכור שכדי להשתמש ב arry שמאפשר לך לגשת לשהוקצה בתים של זיכרון256כדי לומר לו לשחרר arry ו delete לשים [] בין .

,לדוגמא

delete []arry;

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

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

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

:אב הטיפוס לפונקציה הוא

cin.getline(char *buffer, int length, char terminal_char);

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

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

.למחרוזת terminal_char את ה

,בלי האורך, או להפך ;cin.getline(arry, '\n') ניתן ליצור קריאה לפונקציה שלcin.getline(arry, 50); בלי תו הסיום. שים לב ש n\ הוא הדרך לומר למעשה למהדר

כלומר שמישהו הקיש על מקש ה, שאתה מתכוון לשורה חדשה return.

:לדוגמא


int main(){ char string[256]; //A nice long string cout<<"Please enter a long string: "; cin.getline(string, 256, '\n'); //The user input goes into string cout<<"Your long string was:"<<endl<<string; return 0;}

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

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

getline באותו תו תסתיים .

string.h מהן היא הוא קובץ כותרת שמכיל הרבה פונקציות לטיפול במחרוזות. אחת .פונקצית השוואת המחרוזות

int strcmp(const char *s1, const char *s2);

strcmp יהיה תקבל שתי מחרוזות. היא תחזיר מספר שלם. המספר השלם :.s2 קטנה מ s1 שלילי אם

.שוות s2 ו s1 אפס אם.s2 גדולה מ s1 חיובי אם

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

int strcmpi(const char *s1, const char *s2);

strcmpi יהיה תקבל שתי מחרוזות. היא תחזיר מספר שלם. המספר השלם :.s2 קטנה מ s1 שלילי אם

.שוות s2 ו s1 אפס אם.s2 גדולה מ s1 חיובי אם

strcmpi באותיות אינה רגישה להבדל בין אותיות גדולות וקטנות, אם המילים הן .++ANSI C גדולות לא אכפת לה. זה לא

char *strcat(char *desc, chat *src);

strcat זה קיצור ל string concatenate (שרשור מחרוזות), לחבר לסוף, או שמשמעותו לשרשר. הפונקציה מחברת את המחרוזת השניה לראשונה. היא מחזירה מצביע

.למחרוזת המשורשרת

char *strupr(char *s);

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

.++ANSI C באותיות גדולות. זה לא

char *strlwr(char *s);

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

size_t strlen(const char *s);

strlen ה). 0 (/תחזיר את האורך של מחרוזת, פחות התו המסיים size_t לא צריך שזה מה שהוא, להדאיג אותך. פשוט תתייחס אליו כמספר שלם .

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

#include <iostream.h> //For cout#include <string.h> //For many of the string functions

int main(){

char name[50]; //Declare variables char lastname[50]; //This could have been declared on the last line... cout<<"Please enter your name: "; //Tell the user what to do cin.getline(name, 50, '\n'); //Use gets to input strings with spaces or

//just to get strings after the user presses enter

if(!strcmpi("Alexander", name)) //The ! means not, strcmpi returns 0 for { //equal strings cout<<"That's my name too."<<endl;

//Tell the user if its my name

} else //else is used to keep it from always { //outputting this line cout<<"That's not my name." }

cout<<"What is your name in uppercase..."<<endl; strupr(name); //strupr converts the string to uppercase cout<<name<<endl; cout<<"And, your name in lowercase..."<<endl; strlwr(name); //strlwr converts the string to lowercase cout<<name<<endl; cout<<"Your name is "<<strlen(name)<<" letters long"<<endl;

//strlen returns the length of the string cout<<"Enter your last name:";

gets(lastname); //lastname is also a string strcat(name, " "); //We want to space the two names apart strcat(name, lastname); //Now we put them together, we a space in

//the middle cout<<"Your full name is "<<name; //Outputting it all... return 0;

}

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: קלט/פלט של קובץ ב10שיעור ++C



http://eitan.ac.il/

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

.ASCII טקסט, כלומר, קבצים שמורכבים רק מטקסט

כדי .ofstream ו ifstream ,יש שתי מחלקות בסיסיות שמטפלות בקבצים C++ ב מטפלת בקלט של קובץ ifstream .fstream.h להשתמש בהן, הכלל את קובץ הכותרת

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

ifstream a_file;

או

ifstream a_file("filename");

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

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

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

לפני המופע של המחלקה כאילו שזה היה << ו << ניתן להשתמש ב cout או cin.

:לדוגמא

#include <fstream.h>#include <iostream.h>

int main(){ char str[10]; //Used later ofstream a_file("example.txt");

//Creates an instance of ofstream, and opens example.txt a_file<<"This text will now be inside of example.txt";

//Outputs to example.txt through a_file a_file.close();

//Closes up the file ifstream b_file("example.txt");

//Opens for reading the file b_file>>str; //Reads one string from the file cout<<str; //Should output 'this' b_file.close(); //Do not forget this! }

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

:ארגומנט שני שמציין איך צריך לטפל בקובץ. הארגומנטים מפורטים להלן

ios::app -- פותח את הקובץ, ומאפשר הוספה בסופו.ios::ate -- פותח את הקובץ, אבל מאפשר הוספה בכל מקום.

ios::trunc -- שבקובץ מוחק את כל מה .ios::nocreate -- לא פותח את הקובץ אם יש ליצור אותו.

ios::noreplace -- לא פותח את הקובץ אם הוא כבר קיים.

:לדוגמא

ifstream a_file("test.txt", ios::nocreate);

.רק אם הקובץ הזה לא קיים test.txt הקוד לעיל יפתח את הקובץ

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות




http://eitan.ac.il/


: הסבת טיפוסים11שיעור

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

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

.תו

:לדוגמא


int main() { cout<<(char)65; //The (char) is a typecast, telling the computer to interpret the 65 as a //character, not as a number. It is going to give the ASCII output of //the equivalent of the number 65(It should be the letter A). return 0;}

.ASCII שימוש אחד להסבת טיפוסים הוא כאשר אתה רוצה להשתמש בתווי ה כדי .ASCII תווי ה256לדוגמא, מה קורה אם אתה רוצה ליצור טבלה משלך של כל

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


int main(){ for(int x=0; x<256; x++) { //The ASCII character set is from 0 to 255 cout<<x<<". "<<(char)x<<" ";

//Note the use of the int version of x to //output a number and the use of (char) to

// typecast the x into a character //which outputs the ASCII character that

//corresponds to the current number } return 0;}

|

המועדפי|

מחברת| תגובות הקוראים

|

השתתף|

|

אוד|

תפריטאיתן


http://eitan.ac.il/

אישית שלי ם בסקר

ות


: הקדמה למחלקות12שיעור

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

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

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

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

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

למשתנים במבנה זה כלל הדרך היחידה לגשת .

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

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

יותר בקלות קוד .

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

'class' לאחר מכן שם המחלקה. הדוגמא שלנו תשתמש בשם computer. לאחר מכן מסולסלות. לפני שמניחים את המשתנים השונים, יש לשים דרגה אתה פותח סוגריים

שלושה שלבים של הגבלה. הראשון הוא של הגבלה על המשתנה. יש public, השני protected, והשלישי private. עתה, כל מה שאתה צריך לדעת זה שהגבלה של לעת

public כזה שאינו חלק מהמחלקה, לגשת מאפשרת לכל חלק של התוכנית, כולל מפונקציות מחוץ מונעת protected הגבלת ה .public למשתנים שמתוארים כ

למחלקה מלגשת למשתנה. התחביר לזה הוא רק מילת המפתח להגבלה(protected ,private ,public) ואז נקודתיים. לבסוף, שמים את המשתנים השונים

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

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


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

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

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

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

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

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

:לדוגמא

void Aclass::aFunction(){ cout<<"Whatever code";}


class Computer //Standard way of defining the class{ public:

//This means that all of the functions below this //(and any variables) are accessible to the rest of the program. //NOTE: That is a colon, NOT a semicolon...

Computer();//Constructor

~Computer();//Destructor

void setspeed(int p); int readspeed();

//These functions will be defined outside of the classprotected: //This means that all the variables under this, until a new type of //restriction is placed, will only be accessible to other functions //in the class. NOTE: That is a colon, NOT a semicolon...int processorspeed;};

//Do Not forget the trailing semi-colon

Computer::Computer()

{ //Constructors can accept arguments, but this one does not processorspeed = 0;

//Initializes it to zero}

Computer::~Computer(){ //Destructors do not accept arguments}

//The destructor does not need to do anything.

void Computer::setspeed(int p) { //To define a function outside put the name of the function

//after the return type and then two colons, and then the name

//of the function. processorspeed = p;}

int Computer::readspeed() { //The two colons simply tell the compiler that the function is part

//of the clas return processorspeed;}

int main(){ Computer compute;

//To create an 'instance' of the class, simply treat it like you //would a structure. (An instance is simply when you create an

//actual object from the class, as opposed to having the definition

//of the class) compute.setspeed(100);

//To call functions in the class, you put the name of the instance, //a period, and then the function name. cout<<compute.readspeed();

//See above note. return 0;}void Aclass::aFunction(){ cout<<"Whatever code";}


class Computer //Standard way of defining the class{ public:

//This means that all of the functions below this(and any //variables) are accessible to the rest of the program.

//NOTE: That is a colon, NOT a semicolon...

Computer();//Constructor

~Computer();//Destructor

void setspeed(int p); int readspeed();

//These functions will be defined outside of the classprotected: //This means that all the variables under this, until a new type of //restriction is placed, will only be accessible to other functions //in the class. NOTE: That is a colon, NOT a semicolon...int processorspeed;};

//Do Not forget the trailing semi-colon

Computer::Computer() { //Constructors can accept arguments, but this one does not processorspeed = 0;

//Initializes it to zero}

Computer::~Computer(){ //Destructors do not accept arguments}

//The destructor does not need to do anything.

void Computer::setspeed(int p) { //To define a function outside put the name of the function

//after the return type and then two colons, and then the name

//of the function. processorspeed = p;}

int Computer::readspeed() { //The two colons simply tell the compiler that the function is part

//of the clas return processorspeed;}

int main(){ Computer compute;

//To create an 'instance' of the class, simply treat it like you //would a structure. (An instance is simply when you create an

//actual object from the class, as opposed to having the //definition of the class)

compute.setspeed(100);

//To call functions in the class, you put the name of the //instance, a period, and then the function name. cout<<compute.readspeed();

//See above note. return 0;}

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

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


: עוד על פונקציות13שיעור

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

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

:לדוגמא


void function(void) { //Normally this would be the prototype. Do not include a semicolon

//Only prototypes have semicolons cout<<"HA! NO PROTOTYPE!";}

int main()

{ function(); //It works like a normal function now. return 0;}

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

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

'inline', בכל מקום בו אתה קורא לפונקציה זו המהדר יחליף את הקריאה לפונקציה .בקוד הממשי של הפונקציה

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

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

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

:לדוגמא


inline void hello(void){ //Just use the inline keyword before the function cout<<"hello";}

int main(){ hello(); //Call it like a normal function... return 0;}

תוחלף בקוד שמרכיב ;()hello בכל אופן, לאחר שהתוכנית עוברת הידור, הקריאה ל .את הפונקציה

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

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

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

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: קבלת ארגומנטים משורת הפקודה14שיעור

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

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

:זה נראה כך

int main(int argc, char* argv[])

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

הוא המסלול argv[0] .המערך של המצביעים לתווים הוא הרישום של כל הארגומניםשקטן מ המלא לתוכנית כולל שמה. לאחר מכן, כל מספר אלמנט argc הוא ארגומנט

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

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

ומוציאה כפלט את כל הטקסט שלו על המסך הקובץ .

#include <fstream.h> //Needed to manipulate files#include <iostream.h>#include <io.h> //Used to check file existence

int main(int argc, char * argv[]){ if(argc!=2) { cout<<"Correct input is: filename";



http://eitan.ac.il/

return 0; } if(access(argv[1], 00)) //access returns 0 if the file can be accessed { //under the specified method (00) cout<<"File does not exist"; //because it checks file existence return 0; } ifstream the_file; //ifstream is used for file input the_file.open(argv[1]); //argv[1] is the second argument passed in

//presumably the file name char x; the_file.get(x); while(x!=EOF) //EOF is defined as the end of the file { cout<<x; the_file.get(x);//Notice we always let the loop check x for the end of } //file to avoid bad output when it is reached the_file.close(); //Always clean up return 0;}

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

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

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

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

.לוודא שהפלט הבא טוב

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות




http://eitan.ac.il/


: רשימות מקושרות15שיעור

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

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

.(node) ברשימה ידוע כקשר

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

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

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

---------- ----------- Data - >- Data - ---------- - ---------- - Pointer- - - - Pointer- ---------- ----------

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

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

:לפי שעה אנחנו יודעים איך יראה מבנה הקשר

struct node{ int x; node *next;};

int main(){ node *root; //This will be the unchanging first node root=new node; //Now root points to a node struct root->next=NULL; //The node root points to has its next pointer

//set equal to NULL root->x=5; //By using the -> operator, you can modify the node return 0; //a struct (root in this case) points to.}

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

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

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

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

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

:כך זה נראה

struct node{ int x; node *next;};

int main(){ node *root; //This won't change, or we would lose the list in memory node *conductor; //This will point to each node as it traverses

//the list root=new node; //Sets it to actually point to something root->next=NULL; //Otherwise it would not work well root->x=12; conductor=root; //The conductor points to the first node if(conductor!=NULL) { while(conductor->next!=NULL) { conductor=conductor->next; } } conductor->next=new node; //Creates a node at the end of the list conductor=conductor->next; //Points to that node conductor->next=NULL; //Prevents it from going any further conductor->x=42;}

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

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

מה שאליו הוא מצביע על ידי קבלת הכתובת של משנה את conductor->next.

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

,לכן .(while הרכבת ינוע עד שאין לאן להמשיך? הוא עובד באותו אופן בלולאת הconductor->next נקבע ל null, כך שזה בסדר להקצות שטח זיכרון חדש שאליו הוא עובר אלמנט אחד (כמו כרטיסן רכבת שעובר לקרון conductor יצביע. לאחר מכן ה

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

לקבוע אותו על ידי קלט של המשתמש. אני פשוט כתבתי שלו קבוע. (ניתן x הערך של .)=' בתור דוגמא42'

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

:לדוגמא

conductor=root;if(conductor!=NULL) //Makes sure there is a place to start{ while(conductor->next!=NULL) { cout<<conductor->x; conductor=conductor->next; } cout<<conductor->x;}

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

איפוא, מטפל בזה, האחרון .

|


|


| תגובות

הקוראים|

השתתףבסקר

|

|

אודות



: רקורסיה16שיעור

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

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

:דוגמא פשוטה לרקורסיה תהיה

void recurse(){ recurse(); //Function calls itself



http://eitan.ac.il/

}

int main(){ recurse(); //Sets off the recursion return 0; //Rather pitiful, it will never be reached}

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

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

#include <iostream.h>void recurse(int count) //The count variable is initalized by each

//function call{ cout<<count; recurse(count+1); //It is not necessary to increment count//each function's variables} //are separate (so each count will be initialized one greater)

int main(){ recurse(1); //First function call, so it starts at one return 0; }

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

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

.חדשה

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

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

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

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

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

:דוגמא מהירה

void doll(int size){ if(size==0) //No doll can be smaller than 1 atom (10^0==1) so doesn't

//call itself return; //Return does not have to return something, it can be used

//to exit a function doll(size-1); //Decrements the size variable so the next doll will be

//smaller.}

int main(){ doll(10); //Starts off with a large doll (its a logarithmic scale) return 0; //Finally, it will be used}

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

)כל כך גרוע .

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

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

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

void printnum(int begin){ cout<<begin; if(begin<9) //The end condition is when begin is greater than 9 printnum(begin+1); //for it will not recurse after the if-statement cout<<begin; //Outputs the second begin, after the program has

//gone through and output} //the numbers from begin to 9.

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

.begin עד9מ

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

)1המספר)...* -2) * (המספר .

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

.אם הבנת [email protected] ל email שלו...תהנה, ותשלח לי

|

המועדפי|

מחברת| תגובות הקוראים

|

השתתף|

|

אוד|

תפריטאיתן


http://eitan.ac.il/

אישית שלי ם בסקר

ות


: פונקציות עם רשימות ארגומנטים באורך משתנה17שיעור

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

הפונקציה תהיה לקבל מצביע למערך. דרך אחרת תהיה לכתוב פונקציה שיכולהשל ארגומנטים. כך שתוכל לכתוב לקבל כל מספר avg (4, 12.2, 23.3, 33.3, 12.1);

פונקציות ספריה שיכולות לקבל רשימה יש .;avg(2, 2.3, 34.4) או שתוכל לכתוב .(printf כמו) משתנה של ארגומנטים

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

נחוצים חלקים : va_list, שמאחסן את הרשימה של הארגומנטים, va_start, שמאתחל שמנקה את ,va_end שמחזיר את הארגומנט הבא ברשימה, ו ,va_arg ,את הרשימה

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

יאמר למהדר שהפונקציה צריכה ;int a_function(int x, …) (שנראות כך '…'), כך שארגומנטים בהם המתכנת משתמש, כל עוד המספר הוא לפחות לקבל כל מספר של

.x ,אחד, שהוא הראשון

va_list הוא כמו כל משתנה אחר. לדוגמא va_list a_list;.

va_start היא מאקרו שמקבל שני ארגומנטים, va_list שבא לפני אחד, ושם המשתנה באמצעות a_list כדי לאתחל את ,a_function השלוש נקודות. כך שבפונקציה

va_start, תכתוב va_start(a_list, x);.

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

לדוגמא. הבא , va_arg(a_list, double) שהוא תחזיר את הארגומנט הבא, בהנחה בפעם הבאה שהיא נקראת היא תחזיר את הארגומנט שבא .double קיים, בצורה של

המספר המוחזר האחרון, אם קיים אחד כזה אחרי .

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

#include <stdarg.h>#include <iostream.h>double average(int num, ...){


va_list arguments; //A place to store the list of arguments va_start(arguments, num); //Initializing arguments to store all values int sum=0; // passed in after num for(int x=0; x<num; x++) //Loop until all numbers are added sum+=va_arg(arguments, double); //Adds the next value in argument

//list to sum. va_end(arguments); //Cleans up the list return sum/(double)num; //Returns some number (typecast prevents

//trunctation)}

int main(){ cout<<average(3, 12.2, 22.3, 4.5)<<endl; cout<<saverage(5, 3.3, 2.2, 1.1, 5.5, 3.3)<<endl; return 0;}

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

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

Documents

לימוד למתחילים C++