תחילתה של שפת C++ התרחשה עוד בשנת 1983, זמן קצר לאחר מכן 'Bjare Stroustrup' עבד עם שיעורים בשפת C כולל כמה תכונות נוספות כמו עומס יתר של המפעיל. סיומות הקבצים בהן נעשה שימוש הן '.c' ו-'.cpp'. C++ ניתן להרחבה ואינו תלוי בפלטפורמה וכולל STL שהוא הקיצור של Standard Template Library. אז בעצם, שפת C++ הידועה למעשה ידועה כשפת קומפילציה שבה קובץ המקור מורכב יחד ליצירת קבצי אובייקט, שבשילוב עם מקשר מייצרים תוכנית הניתנת להרצה.

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

רכיבים של שפת C++:

#include

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

int main()

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

הַצהָרָה:

משתנים מוכרזים ומוקצים להם שמות.

הצהרת בעיה:

זה חיוני בתוכנית ויכול להיות לולאת 'בזמן', לולאה 'עבור' או כל תנאי אחר שהופעל.

מפעילים:

משתמשים באופרטורים בתוכניות C++ וחלקם חיוניים מכיוון שהם מיושמים בתנאים. כמה אופרטורים חשובים הם &&, ||, !, &, !=, |, &=, |=, ^, ^=.

פלט קלט C++:

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

זרם קלט:

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

זרם פלט:

אם הבתים מוזרמים בכיוון ההפוך, זה זרם הפלט.

קובץ כותרת משמש כדי להקל על קלט ופלט ב-C++. זה כתוב כ המספק שיטות למשל תבשיל ודיוק סט. פקודות הקלט והפלט הן cin, cout, cerr ו-clog. כאן, 'cin' מציין את הקלט הסטנדרטי ו-'cout' מסמל את התקן הפלט הסטנדרטי המשמש עם אופרטורי הכנסת הזרם (<<) להצגת הצהרות על המסך.

דוגמא:

אנו נציג הודעת מחרוזת באמצעות מחרוזת מסוג תווים.

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

הפלט שנוצר מוצג להלן:

דוגמא:

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

בשלב הראשון אנו כוללים את הספרייה. לאחר מכן, אנו משתמשים במרחב שמות שיספק את היקף המזהים. בשלב הבא, אנו קוראים ל- רָאשִׁי() פוּנקצִיָה. לאחר מכן, אנו מאתחלים את הגיל כמשתנה 'int'. אנו משתמשים בפקודה 'cin' לקלט ובפקודה 'cout' לפלט של הודעת המחרוזת הפשוטה. ה-'cin' מזין את ערך הגיל מהמשתמש וה-'cout' מציג אותו בהודעה הסטטית האחרת.

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

דוגמא:

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

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

סוגי נתונים C++:

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

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

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

C++ מקל על השימוש בסוגי הנתונים המפורטים להלן:

1. סוגי נתונים המוגדרים על ידי המשתמש
2. סוגי נתונים נגזרים
3. סוגי נתונים מובנים

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

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

• Char: בגודל של בת אחד, הוא יאחסן תו, אות, מספר או ערכי ASCII בודדים.
• בוליאנית: בגודל של 1 בת, הוא יאחסן ויחזיר ערכים כ-true או false.
• Int: בגודל של 2 או 4 בתים, הוא יאחסן מספרים שלמים ללא עשרוניות.
• נקודה צפה: בגודל של 4 בתים, הוא יאחסן מספרים שברים בעלי נקודה עשרונית אחת או יותר. זה מתאים לאחסון עד 7 ספרות עשרוניות.
• נקודה צפה כפולה: בגודל של 8 בתים, הוא יאחסן גם את המספרים השבריים בעלי נקודה עשרונית אחת או יותר. זה מתאים לאחסון עד 15 ספרות עשרוניות.
• ריק: ללא גודל מוגדר חלל מכיל משהו חסר ערך. לכן, הוא משמש עבור הפונקציות שמחזירות ערך null.
• תו רחב: עם גודל גדול מ-8 סיביות שאורכו בדרך כלל 2 או 4 בתים מיוצג על ידי wchar_t שדומה ל-char ובכך גם מאחסן ערך תו.

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

דוגמא:

בואו פשוט נכתוב קוד פשוט ב-C++ שיניב את הגדלים המדויקים של כמה סוגי נתונים שתוארו לעיל:

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

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

דוגמא:

כאן נוסיף את הגודל של שני סוגי נתונים שונים.

ראשית, אנו משלבים קובץ כותרת המשתמש ב'מרחב שמות סטנדרטי' עבור מזהים. לאחר מכן, ה רָאשִׁי() נקראת פונקציה שבה אנו מאתחלים את המשתנה 'int' בהתחלה ולאחר מכן משתנה 'כפול' כדי לבדוק את ההבדל בין הגדלים של שני אלה. לאחר מכן, הגדלים שלהם משולבים על ידי השימוש ב- מידה של() פוּנקצִיָה. הפלט מוצג על ידי הצהרת 'cout'.

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

להלן משנה הנתונים הנגישים ב-C++:

1. חתם
2. לא חתום
3. ארוך
4. קצר

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

• קצר int: בגודל של 2 בתים, יש מגוון של שינויים מ-32,768 ל-32,767
• int קצר לא חתום: בגודל של 2 בתים, יש מגוון של שינויים מ-0 ל-65,535
• אינט לא חתום: בגודל של 4 בתים, יש מגוון של שינויים מ-0 ל-4,294,967,295
• Int: בגודל של 4 בתים, יש טווח שינויים מ-2,147,483,648 ל-2,147,483,647
• Long int: בגודל של 4 בתים, יש טווח שינויים מ-2,147,483,648 ל-2,147,483,647
• Int long unsigned: בגודל של 4 בתים, יש מגוון של שינויים מ-0 ל-4,294,967.295
• Long long int: בגודל של 8 בתים, יש מגוון של שינויים מ-(2^63) ל-(2^63)-1
• Int long long unsigned: בגודל של 8 בתים, יש מגוון של שינויים מ-0 ל-18,446,744,073,709,551,615
• char חתום: בגודל של 1 בייט, יש מגוון של שינויים מ-128 עד 127
• char Unsigned: בגודל של 1 בייט, יש מגוון של שינויים מ-0 עד 255.

ספירת C++:

בשפת התכנות C++ 'Enumeration' הוא סוג נתונים המוגדר על ידי המשתמש. הספירה מוכרזת כ' מנה' ב-C++. הוא משמש להקצאת שמות ספציפיים לכל קבוע המשמש בתוכנית. זה משפר את הקריאות והשימושיות של התוכנית.

תחביר:

אנו מצהירים על ספירה ב-C++ באופן הבא:

יתרונות הספירה ב-C++:

ניתן להשתמש ב-Enum בדרכים הבאות:

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

החסרונות של ספירה ב-C++:

לאנום יש גם כמה חסרונות:

אם לאחר ששם נמנה לא ניתן להשתמש בו שוב באותו היקף.

לדוגמה:

לא ניתן להצהיר על Enum.

לדוגמה:

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

לדוגמה:

דוגמא:

בדוגמה זו, אנו רואים את השימוש בספירת C++:

בביצוע הקוד הזה, קודם כל, אנחנו מתחילים עם #include . היא אחת מהספריות העשירות ב-C++. זוהי ספרייה מובנית. זה כולל זרמי נתונים של קלט ופלט . לאחר מכן, אנו משתמשים במרחב השמות הסטנדרטי. לאחר מכן, הכרזנו על 'enum' על שם ספציפי כנושא והקצנו שלושה מקצועות שהם מתמטיקה, אנגלית ואורדו. למתמטיקה מוקצה ערך 1. המטרה שלנו היא להדפיס ערכים של נושא המוצהר ב-enum. לאחר מכן, אנו מפעילים את רָאשִׁי() פוּנקצִיָה. ב רָאשִׁי() יש לנו cout<<, כאשר 'c' פירושו 'תו' ו-out פירושו 'פלט'. 'Cout' משמש להצגת פלט . << מציין את אופרטור ההכנסה. באמצעות 'cout<<', אנו מדפיסים ערכי enum. לאחר מכן, נשתמש בפקודה 'החזר 0'. פקודה זו מחזירה את התוצאה שהיא בצורה של ערכים.

הנה התוצאה שלנו מהתוכנית שבוצעה:

אז, כפי שאתה יכול לראות שיש לנו ערכים של נושא: מתמטיקה, אורדו, אנגלית; כלומר 1,2,3.

דוגמא:

הנה דוגמה נוספת שבאמצעותה אנו מנקים את המושגים שלנו לגבי enum:

בתוכנית זו, אנו מתחילים בשילוב קובץ הכותרת . זוהי ספרייה מובנית. זה כולל זרמי נתונים של קלט ופלט. לאחר מכן, עלינו להשתמש במרחב השמות הסטנדרטי. לאחר מכן, הקצינו ערכי enum לקבועים שהם שחקנים. המטרה שלנו היא להציג של מי זה. לאחר מכן, אנו קוראים שלנו רָאשִׁי() פוּנקצִיָה. בתוך ה רָאשִׁי() פונקציה הקצינו שני קבועים: Shadab, שערכו הוא 20 למשתנה ה- 'bowler1'; ואפרידי, שערכו הוא 25 למשתנה ה-enum 'בולר2'.

עלינו להשתמש בהצהרת if-else . השתמשנו גם באופרטור ההשוואה בתוך הצהרת 'אם', כלומר אנו משווים אם 'באולר2' גדול מ'באולר1'. לאחר מכן, בלוק ה'אם' מבוצע מה שאומר שזה הסוף של אפרידי. לאחר מכן, הכנסנו 'cout<<' כדי להציג את הפלט. ראשית, אנו מדפיסים את ההצהרה 'זה נגמר'. לאחר מכן, הערך של 'באולר2'. אם לא, בלוק אחר מופעל, מה שאומר שזהו הסיום של Shadab. לאחר מכן, על ידי יישום הפקודה 'cout<<' אנו מציגים את המשפט 'זה נגמר'. לאחר מכן, הערך של 'באולר1'.

לפי הצהרת If-else, יש לנו מעל 25 שזה הערך של אפרידי. זה אומר שהערך של משתנה ה-enum 'bowler2' גדול יותר מ-'bowler1' וזו הסיבה שהמשפט 'if' מבוצע.

C++ אם אחרת, החלף:

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

הצהרת 'אם':

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

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

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

הצהרת 'אם-אחר':

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

ראשית, נכריז על משתנה מסוג data 'int' בשם 'x' שהערך שלו נלקח מהמשתמש. כעת, נעשה שימוש בהצהרת 'if' כאשר החלנו תנאי שאם הערך השלם שהזין המשתמש הוא 2. הפלט יהיה הרצוי והודעת 'NICE TRY' פשוטה תוצג. אחרת, אם המספר שהוזן אינו 2, הפלט יהיה שונה.

כאשר המשתמש כותב את המספר 2, הפלט הבא מוצג.

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

הצהרת אם-אחר-אם:

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

כאן, לאחר שילוב קובץ הכותרת ומרחב השמות, אתחלנו ערך של המשתנה 'm' כ-200. הערך של 'm' נלקח לאחר מכן מהמשתמש ולאחר מכן מוצלב עם התנאים המרובים שצוינו בתוכנית.

כאן, המשתמש בחר בערך 195. זו הסיבה שהפלט מראה שזהו הערך האמיתי של 'm'.

הצהרת החלף:

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

מילת מפתח 'הפסקה':

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

בשורה הראשונה של הקוד המשותף, אנו כוללים את הספרייה. לאחר מכן, אנו מוסיפים 'מרחב שמות'. אנו מפעילים את רָאשִׁי() פוּנקצִיָה. לאחר מכן, אנו מכריזים על ציון נתוני תו כ-'F'. ציון זה יכול להיות רצונך והתוצאה תוצג בהתאמה עבור המקרים שנבחרו. יישמנו את הצהרת המתג כדי לקבל את התוצאה.

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

בוא נשנה את הציון ל-X ונראה מה קורה. כתבתי 'X' בתור הציון והפלט שהתקבל מוצג להלן:

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

להצהרות if-else ו-switch יש כמה תכונות נפוצות:

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

הצהרות If-else ו-switch נבדלות באופנים מסוימים:

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

לולאות C++:

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

סוגי לולאות:

ישנן שלוש קטגוריות של לולאות:

• עבור לולאה
• תוך כדי לולאה
• עשה תוך כדי לולאה

עבור לולאה:

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

התחביר של ביצוע לולאה 'עבור':

דוגמא:

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

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

דוגמאות לתוכניות C++ לאימות לולאת 'For':

דוגמא:

דוגמה זו מציגה את ההדפסה של ערכי מספרים שלמים מ-0 עד 10.

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

מספר איטרציות עם תנאי i<10:

דוגמא:

המופע הבא מציג את הערך של המספר השלם:

במקרה שלעיל, משתנה בשם 'a' מאותחל עם ערך שניתן 50. מוחל תנאי שבו המשתנה 'a' קטן מ-70. לאחר מכן, הערך של 'a' מתעדכן כך שהוא יתווסף עם 2. לאחר מכן מתחילים את הערך של 'a' מערך התחלתי שהיה 50 ו-2 מתווסף במקביל לאורך הלולאה עד שהתנאי מחזיר false והערך של 'a' מוגדל מ-70 והלולאה מסתיימת.

מספר איטרציות:

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

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

בשורה הראשונה, אנו משלבים את קובץ הכותרת ואת מרחב השמות הסטנדרטי. אנחנו קוראים ל רָאשִׁי() פוּנקצִיָה. כאן אנו מאתחלים משתנה 'a'. בשורה הבאה, אנו מיישמים את תנאי ה-while. בתוך התנאי while, אנו משתמשים במשפט 'cout' כדי להציג את הערך שנכתב. לאחר מכן, אנו משתמשים באופרטור ההגדלה כדי להגדיל את הספירה. בשורה האחרונה, אנו משתמשים במשפט 'החזר 0' כדי לסיים את התוכנית.

לולאת עשה תוך כדי:

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

כאן, אנו משלבים את קובץ הכותרת . אנו מנצלים את רָאשִׁי() פונקציה בתוכנית. לאחר מכן, אנו מאתחלים ארבעה מספרים שלמים ומשתמשים במשפט 'cin', כדי שהמשתמש יוכל להזין את הערך. בשורה הבאה, אנו מאתחלים שני מספרים שלמים שונים. אנו מיישמים את הצהרת 'עשה'. בתוך ההצהרה, אנו משתמשים בשתי פונקציות אריתמטיות. ראשית, אנו משתמשים באופרטור הכפל ושנית, אנו משתמשים באופרטור החיבור. לאחר מכן, אנו מיישמים את התנאי 'בזמן' בתוכנית מחוץ להצהרת 'עשה'. יתר על כן, אנו מוסיפים את הצהרת 'cout' כדי להדפיס את התוצאה דרך המספר השלם 'התוצאה'. בשורה האחרונה, כדי לסיים את התוכנית, אנו משתמשים בפקודות return 0.

C++ המשך/הפסק:

C++ הצהרת המשך:

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

עם עבור לולאה:

במקרה זה, אנו משתמשים ב-'for loop' עם הצהרת continue מ-C++ כדי לקבל את התוצאה הנדרשת תוך עמידה בדרישות מסוימות.

אנו מתחילים בהכללת ספריית ושימוש ב-'namespace std'. אז אנחנו מתקשרים ל- רָאשִׁי() פוּנקצִיָה. אנו משתמשים עבור לולאה. Inside for loop, אנו מכריזים על משתנה 'k' שנחשב לשכב בין 3 ל-8. אנו עושים שימוש בתנאי כדי להמשיך את האיטרציה גם אם (k = = 5). לאחר מכן השתמש בהצהרה 'המשך' לאחר ציון התנאי. בסופו של דבר. כדי להציג פלט, אנו עושים שימוש בפקודה 'cout' יחד עם הפקודה 'return 0'.

עם לולאת זמן:

במהלך ההדגמה הזו, השתמשנו גם ב-'while loop' וגם בהצהרת 'continue' של C++ כולל כמה תנאים כדי לראות איזה סוג פלט עשוי להיווצר.

בדוגמה זו, הגדרנו תנאי להוסיף מספרים ל-40 בלבד. אם המספר השלם שהוזן הוא מספר שלילי, אזי לולאת 'בזמן' תסתיים. מצד שני, אם המספר גדול מ-40, המספר הספציפי הזה ידלג מהאיטרציה.

נכלול את ספריית , תוך שימוש ב-'namespace std' ולאחר מכן נקרא ל- רָאשִׁי() פוּנקצִיָה. אנו מאתחלים משתנה 's'. משתנה נוסף 'מספר' מוצהר בשלב הבא. אנו משתמשים בלולאת 'בזמן'. כעת, אנו מציינים את התנאי שהערך הנדרש יהיה מעל או שווה לאפס. כדי להוסיף את כל המספרים החיוביים, אנו משתמשים במשפט 's += number'. הפקודה 'cout' תופעל כדי להציג את ההודעה במסוף 'הזן כל מספר'. אנו מקבלים את המספר השלם מהמשתמש על ידי שימוש במשפט 'cin'. אנו משתמשים גם בהצהרת 'אם'. בכל פעם שהמספר המוגדר גדול מ-40, ההודעה תוצג. לאחר מכן, השתמשנו בפקודה 'המשך'. לאחר כל השלבים הללו, הצהרת 'המשך' תתבצע. כדי להראות את הסכום של כל המספרים, אנו משתמשים במשפט 'cout'.

C++ הצהרת הפסקה:

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

עם עבור לולאה:

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

ראשית, אנו משלבים קובץ כותרת . לאחר מכן, אנו משתמשים ב-'namespace std'. לאחר קריאה לפונקציה main() השתמשנו עבור הלולאה. כאן, אנו מאתחלים את המשתנה 'm'. נחיל את התנאי שהערך של 'm' נע בין 10 ל-20. תנאי 'הפסק' יתבצע כאילו (m == 17). כדי להדפיס את התוצאה, השתמשנו ב'cout'. לאחר מכן, תופעל הפקודה 'החזר 0'.

עם לולאת זמן:

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

אנו מתחילים בייבוא ​​ספריית . ה-'Namespace std' ייכלל. בתוך שיטת main(), שני משתנים 'nbr' ו-'x' יאותחלו. השתמשנו בלולאת 'בזמן' והעברת 'נכון' כטיעון. כדי לקבל ערך מהמשתמש, אנו משתמשים בפקודה 'cin'. לאחר מכן, השתמשנו בהצהרת 'אם'. יחד עם זה, התנאי 'הפסק' מוחל כדי לציין את התנאי אם (nbr < 0). כדי להוסיף את כל הערכים החיוביים, השתמשנו בנוסחאות 'x += nbr'. כדי להציג את הסכום הזה, הוספנו את הצהרת 'cout'.

פונקציות C++:

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

יצירת פונקציה:

למרות ש-C++ מספק הרבה פונקציות מוגדרות מראש כמו רָאשִׁי(), מה שמקל על ביצוע הקוד. באותו אופן, אתה יכול ליצור ולהגדיר את הפונקציות שלך בהתאם לדרישתך. בדיוק כמו כל הפונקציות הרגילות, כאן, אתה צריך שם לפונקציה שלך להצהרה שמתווספת בסוגריים לאחר מכן '()'.

תחביר:

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

קריאה לפונקציה:

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

דוגמא:

הבה נצהיר ונבנה פונקציה מוגדרת על ידי משתמש במצב זה.

בתחילה, כפי שמתואר בכל תוכנית, מוקצים לנו ספרייה ומרחב שמות לתמיכה בביצוע התוכנית. הפונקציה המוגדרת על ידי המשתמש עבודה() נקרא תמיד לפני שכותבים את רָאשִׁי() פוּנקצִיָה. פונקציה בשם עבודה() מוצהר במקום שבו מוצגת ההודעה 'עבודה ראויה לכבוד!'. בתוך ה רָאשִׁי() פונקציה עם סוג החזרה של מספר שלם, אנו קוראים ל- עבודה() פוּנקצִיָה.

זוהי ההודעה הפשוטה שהוגדרה בפונקציה המוגדרת על ידי המשתמש המוצגת כאן בעזרת ה- רָאשִׁי() פוּנקצִיָה.

בָּטֵל:

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

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

הפרמטרים בפועל:

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

דוגמא:

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

בהתחלה, אנחנו לוקחים את קובץ הכותרת. הפונקציה המוגדרת על ידי המשתמש היא השם המוצהר והמוגדר תַת(). פונקציה זו משמשת להחלפה של שני ערכי המספרים השלמים שהם i ו-n. לאחר מכן, האופרטורים האריתמטיים משמשים להחלפה של שני המספרים השלמים הללו. הערך של המספר השלם הראשון 'i' מאוחסן במקום הערך 'n' והערך של n נשמר במקום הערך של 'i'. לאחר מכן, התוצאה לאחר החלפת הערכים מודפסת. אם נדבר על ה רָאשִׁי() פונקציה, אנו לוקחים את הערכים של שני המספרים השלמים מהמשתמש ומוצגים. בשלב האחרון, הפונקציה המוגדרת על ידי המשתמש תַת() נקרא ושני הערכים מתחלפים.

במקרה זה של החלפת שני המספרים, אנו יכולים לראות בבירור שבזמן השימוש ב- תַת() פונקציה, הערך של 'i' ו-'n' בתוך רשימת הפרמטרים הם הפרמטרים הפורמליים. הפרמטרים בפועל הם הפרמטר שעובר בסוף ה- רָאשִׁי() פונקציה שבה נקראת פונקציית ההחלפה.

מצביעי C++:

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

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

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

מצביעים וסוגיהם:

לפוינטר יש כמה סוגים:

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

דוגמא:

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

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

הפלט שקיבלנו מוצג להלן:

תוצאה זו מציגה את הכתובת של שני המשתנים.

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

הצהרת מצביע:

המצביע מוצהר באופן זה:

סוג הבסיס של המצביע מסומן על ידי 'סוג', בעוד שמו של המצביע מבוטא על ידי 'var-name'. וכדי לזכות משתנה למצביע נעשה שימוש בכוכבית(*).

דרכים להקצות מצביעים למשתנים:

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

דוגמא:

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

אנחנו הולכים לשלב את התמיכה בספריות ובספריות. לאחר מכן, היינו מפעילים את רָאשִׁי() פונקציה שבה אנו מכריזים ומאתחלים לראשונה משתנה 'n' מסוג 'int' עם הערך 55. בשורה הבאה, אנו מאתחלים משתנה מצביע בשם 'p1'. לאחר מכן, אנו מקצים את הכתובת של המשתנה 'n' למצביע 'p1' ולאחר מכן אנו מראים את הערך של המשתנה 'n'. הכתובת של 'n' המאוחסנת במצביע 'p1' מוצגת. לאחר מכן, הערך של '*p1' מודפס על המסך על ידי שימוש בפקודה 'cout'. הפלט הוא כדלקמן:

כאן, אנו רואים שהערך של 'n' הוא 55 והכתובת של 'n' שנשמרה במצביע 'p1' מוצגת כ-0x6ffe14. נמצא הערך של משתנה המצביע והוא 55 שזהה לערך של המשתנה השלם. לכן, מצביע מאחסן את הכתובת של המשתנה, וגם למצביע *, יש את הערך של המספר השלם המאוחסן שכתוצאה מכך יחזיר את הערך של המשתנה שנשמר בתחילה.

דוגמא:

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

בקוד זה, אנו מוסיפים תחילה ספריות ומרחב שמות. בתוך ה רָאשִׁי() פונקציה שעלינו להכריז על מחרוזת בשם 'איפור' שיש בה את הערך 'מסקרה'. מצביע מסוג מחרוזת '*p2' משמש לאחסון הכתובת של משתנה האיפור. הערך של המשתנה 'איפור' מוצג לאחר מכן על המסך תוך שימוש בהצהרת 'cout'. לאחר מכן, הכתובת של המשתנה 'איפור' מודפסת, ובסופו של דבר, מוצג משתנה המצביע 'p2' המציג את כתובת הזיכרון של המשתנה 'איפור' עם המצביע.

הפלט שהתקבל מהקוד לעיל הוא כדלקמן:

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

ניהול זיכרון C++:

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

להקצאה דינמית והקצאה דינמית של הזיכרון ב-C++, אנו עושים את ' חָדָשׁ' ו 'לִמְחוֹק' פעולות. זה קריטי לנהל את הזיכרון כך שזיכרון לא יתבזבז. הקצאת הזיכרון הופכת לקלה ואפקטיבית. בכל תוכנית C++, הזיכרון מופעל באחד משני היבטים: או כערימה או כמחסנית.

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

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

מפעיל חדש C++:

המפעיל החדש אחראי להקצאת הזיכרון והוא משמש כדלקמן:

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

זיכרון הוקצה למשתנה 'int' בהצלחה עם שימוש במצביע.

אופרטור מחיקת C++:

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

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

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

שימוש במערך להקצאת זיכרון:

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

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

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

בפלט, יכולנו לראות סטים של ערכים מודפסים פעמיים. לולאת ה-'for' הראשונה שימשה לכתיבת הערכים עבור אלמנטים והלולאת 'for' השנייה משמשת להדפסת הערכים שכבר נכתבו, מה שמראה שהמשתמש כתב את הערכים הללו לצורך הבהירות.

יתרונות:

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

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

מערכי C++:

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

הצהרת מערכים:

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

לדוגמה:

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

לדוגמה:

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

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

כיצד לגשת לאלמנטים במערך?

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

דוגמא:

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

בשלב הראשון, אנו משלבים את קובץ הכותרת , שיוסיף אוטומטית את כל הספריות הדרושות בתוכנית. מרחב השמות 'std' יספק את היקף הספריות. בשורה השלישית, אנו קוראים את רָאשִׁי() פוּנקצִיָה. הסוגר המתולתל מסמל את התחלת הפונקציה. לאחר הכניסה לפונקציה, נכריז על מערך מסוג 'int' בשם 'ספרות'. הוא מכיל את הגודל של 4, מה שאומר שהוא יכול להכיל רק 4 ערכים שלמים בבת אחת. לכל אחד מהאלמנטים במערך הוקצו ספרה ייחודית ושונה בנפרד. לאחר מכן מוצג המערך כולו כאשר כל פריט נקרא בנפרד.

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

דוגמא:

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

במקרה שלעיל, אנו מוסיפים את הספרייה החיונית. מרחב השמות הסטנדרטי מתווסף. ה רָאשִׁי() function היא הפונקציה שבה אנו הולכים לבצע את כל הפונקציות לביצוע של תוכנית מסוימת. לאחר מכן, אנו מכריזים על מערך מסוג int בשם 'Num', שגודלו 10. הערך של עשרת המשתנים הללו נלקח מהמשתמש עם השימוש בלולאת 'for'. לתצוגה של מערך זה, נעשה שוב שימוש בלולאת 'עבור'. 10 המספרים השלמים המאוחסנים במערך מוצגים בעזרת הצהרת 'cout'.

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

דוגמא:

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

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

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

יתרונות השימוש במערכים:

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

חסרונות השימוש במערכים:

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

אובייקטים ומחלקות C++:

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

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

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

הגדרת כיתה:

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

הכרזת חפצים:

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

גישה לחברי נתונים:

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

דוגמא:

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

בשלב הראשון, אנו משלבים את הספרייה ולאחר מכן עלינו לכלול את המדריכים התומכים. המחלקה מוגדרת במפורש לפני הקריאה ל- רָאשִׁי() פוּנקצִיָה. מחלקה זו מכונה 'רכב'. חברי הנתונים היו 'שם הרכב וה'מזהה' של אותו רכב, שהוא מספר הלוח של אותו רכב בעל מחרוזת ו-int datatype בהתאמה. שתי הפונקציות מוצהרות עבור שני איברי הנתונים הללו. ה תְעוּדַת זֶהוּת() הפונקציה מציגה את מזהה הרכב. מכיוון שהנתונים חברי הכיתה הם ציבוריים, כך נוכל לגשת אליהם גם מחוץ לכיתה. לכן, אנו קוראים ל- שֵׁם() לתפקד מחוץ למחלקה ולאחר מכן לקחת את הערך עבור 'שם הרכב' מהמשתמש ולהדפיס אותו בשלב הבא. בתוך ה רָאשִׁי() function, אנו מכריזים על אובייקט של המחלקה הנדרשת אשר יסייע בגישה לחברי הנתונים והפונקציות מהמחלקה. בנוסף, אנו מאתחלים את הערכים של שם הרכב ומזהה שלו, רק אם המשתמש לא נותן את הערך עבור שם הרכב.

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

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

בונים והרסים של C++:

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

בונים:

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

תחביר:

סוגי בונים:

בנאי עם פרמטרים:

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

דוגמא:

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

אנחנו כוללים את קובץ הכותרת כבר בשלב הראשון. השלב הבא של שימוש במרחב שמות הוא תמיכה בספריות לתוכנית. מחלקה בשם 'ספרות' מוכרזת כאשר תחילה, המשתנים מאותחלים באופן פומבי כך שיוכלו להיות נגישים בכל התוכנית. משתנה בשם 'dig1' עם מספר שלם של סוג נתונים מוצהר. לאחר מכן, הכרזנו על בנאי ששמו דומה לשם המחלקה. לבנאי זה יש משתנה מספר שלם המועבר אליו בתור 'n' ומשתנה המחלקה 'dig1' מוגדר שווה ל-n. בתוך ה רָאשִׁי() פונקציה של התוכנית, שלושה אובייקטים עבור המחלקה 'ספרות' נוצרים ומוקצים כמה ערכים אקראיים. אובייקטים אלה משמשים לאחר מכן כדי לקרוא למשתני המחלקה המוקצים עם אותם ערכים באופן אוטומטי.

ערכי המספרים השלמים מוצגים על המסך כפלט.

עותק בנאי:

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

דוגמא:

במקרה זה, יוכרז בנאי ההעתקה.

ראשית, אנו משלבים את הספרייה והספרייה. מחלקה בשם 'חדש' מוצהרת שבה המספרים השלמים מאותחלים כ-'e' ו-'o'. הבנאי מפורסם כאשר לשני המשתנים מוקצים הערכים ומשתנים אלו מוצהרים במחלקה. לאחר מכן, ערכים אלה מוצגים בעזרת ה- רָאשִׁי() פונקציה עם 'int' כסוג ההחזרה. ה לְהַצִיג() הפונקציה נקראת ומוגדרת לאחר מכן כאשר המספרים מוצגים על המסך. בתוך ה רָאשִׁי() הפונקציה, האובייקטים נוצרים והאובייקטים המוקצים אלה מאותחלים עם ערכים אקראיים ולאחר מכן לְהַצִיג() נעשה שימוש בשיטה.

הפלט שהתקבל על ידי השימוש בבנאי ההעתקה מתגלה להלן.

משחתות:

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

תחביר:

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

דוגמא:

בתרחיש זה, אנו משתמשים ב-destructor למחיקת אובייקט.

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

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

ההבדל בין קונסטרוקטורים והורסים:

ירושה C++:

כעת, נלמד על ירושה של C++ והיקפו.

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

ירושה מתייחסת למערכת יחסים (היא). אנו קוראים לכל מערכת יחסים ירושה אם משתמשים ב-'is-a' בין שתי מחלקות.

לדוגמה:

• תוכי הוא ציפור.
• מחשב הוא מכונה.

תחביר:

בתכנות C++, אנו משתמשים או כותבים בירושה באופן הבא:

מצבים של ירושה C++:

ירושה כוללת 3 מצבים להורשה של מחלקות:

• פּוּמְבֵּי: במצב זה, אם מוצהרת כיתת ילד, חברי כיתת אב עוברים בירושה על ידי כיתת ילד כמו זהים בכיתת אב.
• מוגן: אני במצב זה, החברים הציבוריים של כיתת ההורים הופכים לחברים מוגנים בכיתת הילד.
• פְּרָטִי : במצב זה, כל החברים בכיתת הורה הופכים לפרטיים בכיתת הילד.

סוגי ירושה C++:

להלן סוגי הירושה C++:

1. ירושה יחידה:

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

תחביר:

2. ירושה מרובה:

בסוג זה של ירושה, מחלקה עשויה לרדת ממחלקות בסיס שונות.

תחביר:

3. ירושה רב-שכבתית:

כיתת ילד היא צאצא מכיתת ילד אחרת בצורה זו של ירושה.

תחביר:

4. ירושה היררכית:

מספר תת-מחלקות נוצרות ממחלקת בסיס אחת בשיטה זו של ירושה.

תחביר:

5. ירושה היברידית:

בסוג זה של ירושה משולבים ירושות מרובות.

תחביר:

דוגמא:

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

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

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

דוגמא:

כאן נפעיל תוכנית שתראה כיצד להשתמש בירושה רב-שכבית.

התחלנו את התוכנית שלנו באמצעות זרמי קלט-פלט. לאחר מכן, הכרזנו כיתת הורה 'M' אשר מוגדרת להיות ציבורית. התקשרנו ל- לְהַצִיג() פונקציה ופקודת 'cout' כדי להציג את ההצהרה. לאחר מכן, יצרנו כיתת ילד 'N' שנגזרת מכיתת האב 'M'. יש לנו כיתת ילד חדשה 'O' הנגזרת מכיתה ילד 'N' והגוף של שתי הכיתות הנגזרות ריק. בסופו של דבר, אנו מפעילים את רָאשִׁי() פונקציה שבה עלינו לאתחל את האובייקט של המחלקה 'O'. ה לְהַצִיג() הפונקציה של האובייקט משמשת להדגמת התוצאה.

באיור זה, יש לנו את התוצאה של מחלקה 'M' שהיא כיתת האב כי היה לנו א לְהַצִיג() לתפקד בו. אז, מחלקה 'N' נגזרת ממחלקת האב 'M' ומחלקה 'O' ממחלקה אב 'N' המתייחסת בירושה רב-שכבתית.

C++ פולימורפיזם:

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

קטגוריות של פולימורפיזם:

פולימורפיזם מתרחש בעיקר בשתי שיטות:

1. הידור פולימורפיזם של זמן
2. ריצה פולימורפיזם

בואו נסביר.

6. קומפילו פולימורפיזם של זמן:

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

• עומס יתר של פונקציות
• עומס יתר על המפעיל

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

7. עומס יתר של פונקציות:

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

ראשית, אנו מעסיקים את הספרייה וכן את מרחב השמות הסטנדרטי. אז נכריז על המחלקה המוגדרת על ידי המשתמש 'הוסף'. בתוך המחלקה, אנו מגדירים פונקציה ADD() עם שני פרמטרים כציבור. שוב, הכריז על פונקציה חדשה בתוך גוף המחלקה עם אותו שם אבל לפונקציה הזו אין פרמטר. כאן אנו מאתחלים שלוש מחרוזות. לשתי המחרוזות הראשונות יש ערך כלשהו והמחרוזת האחרונה משמשת לשרשור שתי המחרוזות הראשונות. אנו משתמשים בפקודה 'cout' כדי להדפיס את התוצאה. לאחר מכן, אנו קוראים ל- רָאשִׁי() שיטה מחוץ לכיתה. אנו בונים אובייקט מהמחלקה הנדרשת 'הוסף'. כעת, אנו קוראים לפונקציה הראשונה עם שני פרמטרים ואז קוראים גם לפונקציה השנייה. בשלב האחרון, אנו כוללים את הצהרת 'החזר 0' כדי לסיים את התוכנית.

עומס יתר על המפעיל:

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

הדוגמה לעיל כוללת את קובץ הכותרת . לאחר מכן, השתמשנו במרחב שמות סטנדרטי. אנו מגדירים את המחלקה 'מספר שלם'. בתוך מחלקה זו, אנו מציינים מספר שלם כחבר פרטי של מחלקה. לאחר מכן, אנו מכריזים על בנאי פרמטריזציה כחבר ציבורי ומאתחלים את הערך של המספר השלם שבו. אנו מגדירים בנאי עם אופרטור קידומת עומס יתר. בתוך בנאי זה, אנו מבצעים פעולת קידומת. יתר על כן, אנו יוצרים פונקציה המציגה את ערך התוספת באמצעות הצהרת 'cout'. בינתיים, אנו מפעילים את רָאשִׁי() פוּנקצִיָה. כאן, אנו יוצרים שני אובייקטי מחלקה. האובייקט הראשון מעביר ערך של המספר השלם. לאחר מכן, השתמש בהצהרת 'cout' כדי להדפיס את השורה 'לפני ההגדלה הערך הוא'. לאחר מכן, אנו מתקשרים לְהַצִיג() פונקציה עבור האובייקט הראשון. האובייקט השני משתמש באופרטור ה-pre-increment. אנו משתמשים בפקודה 'cout' כדי להציג את השורה 'לאחר העלאה מוקדמת הערך הוא'. לאחר מכן, אנו משתמשים ב- לְהַצִיג() פונקציה עבור האובייקט השני.

8. פולימורפיזם בזמן ריצה:

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

עקיפה של פונקציות:

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

בשורה הראשונה, אנו משלבים את הספרייה כדי לבצע פעולות קלט ופלט. יתר על כן, אנו מוסיפים את מרחב השמות הסטנדרטי. בשורה הבאה, אנו מכריזים כיתת הורה 'גבר'. בתוך המחלקה, אנו מגדירים פונקציה עם שני פרמטרים כציבור. לאחר מכן, אנו משתמשים בהצהרת 'cout' כדי להציג את הטקסט 'הליכה'. מחוץ לכיתה, אנו יוצרים כיתת ילד 'חיה' שמקורה בכיתת ההורים. כאן, אנו יוצרים פונקציה בעלת שם דומה לזה שהוכרזה בעבר במחלקת האב. לאחר מכן, השתמש בהצהרת 'cout' כדי להציג את הטקסט 'אכילה'. אנו משתמשים ב- רָאשִׁי() פוּנקצִיָה. בינתיים, אנו יוצרים אובייקט מחלקה 'm'. לאחר מכן, אנו קוראים לפונקציה של כיתת האב וכן לפונקציה של כיתת הילד. השתמש בפקודה 'החזר 0'.

מחרוזות C++:

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

קבל את המחרוזת באמצעות הפקודה 'cin':

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

בשלב הראשון, אנו משתמשים בספרייה . בינתיים, כללנו את מרחב השמות הסטנדרטי. לאחר מכן, אנו מכריזים על רָאשִׁי() פוּנקצִיָה. אנו מאתחלים מחרוזת סוג תווים בתוך גוף ה- רָאשִׁי() פוּנקצִיָה. לאחר מכן, אנו משתמשים בהצהרת 'cout' כדי להדפיס 'הזן את שמך'. אנו משתמשים בפקודה 'cin' כדי לשאול את המחרוזת מהמשתמש. הפקודה 'cout' מופעלת כדי להדפיס את השם שייכתב על ידי המשתמש. הצהרת return 0 מתווספת כדי לסיים את התוכנית.

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

קבל את המחרוזת באמצעות הפונקציה cin.get() :

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

הדוגמה לעיל כוללת את הספרייה לביצוע פעולות קלט ופלט. לאחר מכן, השתמשנו במרחב שמות סטנדרטי. ה רָאשִׁי() פונקציה נקראת. לאחר מכן, אנו מאתחלים מחרוזת בשם 's'. בשלב הבא, הפקודה 'cout' משמשת כדי להציג את ההצהרה 'הזן מחרוזת'. ה cin.get() מוחל כדי לקבל את המחרוזת מהמשתמש. על ידי שימוש ב cin.get() פונקציה אנו מעבירים ערך מחרוזת ומציינים את גודל המחרוזת כפרמטר. הפקודה 'cout' מנוצלת שוב כדי להציג את הפלט של התוכנית. בסופו של דבר, נוסיף את ההחזר 0.

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

שימוש במערך מחרוזות דו-ממדי (דו-מימדי):

במקרה זה, אנו מקבלים קלט (שם של שלוש ערים) מהמשתמש על ידי שימוש במערך דו-ממדי של מחרוזות.

ראשית, אנו משלבים את קובץ הכותרת ומרחב שמות סטנדרטי. אנו מפעילים את רָאשִׁי() פוּנקצִיָה. לאחר מכן, אנו מאתחלים מערך דו מימדי של תווים עם שלוש שורות וחמש עשרה עמודות. בשלב הבא, עבור לולאה משמשת לספירת המשתנה 'i' כדי לחזור על המחרוזת הנדרשת עד לזיהוי תו האפס. בתוך גוף לולאת ה'for', אנו משתמשים בפקודה 'cout' כדי להציג את השורה 'הזן שם עיר'. לאחר מכן השתמש בהצהרה 'cin' כדי לקבל את שם העיר. אנו משתמשים שוב בלולאת 'for' והצהרת 'cout' נוספת כדי להציג את שם הערים ברצף עד שהלולאה מסתיימת. לאחר מכן, נעשה שימוש בפקודה 'החזר 0'.

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

C++ ספרייה רגילה:

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

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

הספרייה הסטנדרטית C++ תומכת בשני הסוגים הבאים:

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

כמה מקבצי הכותרות זוכים לצער מאז שהגיעו 11 C++ האחרונים: אלה , ו-.

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

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

סוגים:

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

• חלקי Iostream
• חלקי C++ STL (ספרייה רגילה)

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

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

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

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

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

סוגריים זוויתיים אלה '<>' מסמלים שחייבים לחפש את קובץ הכותרת המסוים הזה בספרייה המוגדרת ונכללת. אפשר גם להוסיף סיומת '.h' לספרייה זו, אשר מתבצעת במידת הצורך או הרצוי. אם לא נכלול את ספריית '.h', אנו זקוקים לתוספת 'c' ממש לפני תחילת שם הקובץ, רק כאינדיקציה לכך שקובץ הכותרת הזה שייך לספריית C. לדוגמה, אתה יכול לכתוב (#include או #include ).

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

וקטורים C++:

ישנן דרכים רבות לאחסון נתונים או ערכים ב-C++. אך לעת עתה, אנו מחפשים את הדרך הקלה והגמישה ביותר לאחסון הערכים תוך כתיבת התוכנות בשפת C++. לכן, וקטורים הם מיכלים שמרצפים כראוי בתבנית סדרה שגודלה משתנה בזמן הביצוע בהתאם להכנסה וההורדה של האלמנטים. המשמעות היא שהמתכנת יוכל לשנות את גודל הווקטור לפי רצונו במהלך ביצוע התוכנית. הם דומים למערכים בצורה כזו שיש להם גם עמדות אחסון ניתנות לחיבור עבור האלמנטים הכלולים שלהם. לבדיקת מספר הערכים או האלמנטים הקיימים בתוך הוקטורים, עלינו להשתמש ב-' std::count' פוּנקצִיָה. וקטורים כלולים בספריית התבניות הסטנדרטית של C++ כך שיש לה קובץ כותרת מוגדר שצריך לכלול קודם, כלומר:

הַצהָרָה:

ההכרזה על וקטור מוצגת להלן.

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

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

אתחול הוקטורים:

לאתחול הוקטורים, יש יותר מדרך אחת ב-C++.

טכניקה מספר 1:

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

טכניקה מספר 2:

בתהליך האתחול הזה, 3 מכתיב את גודל הווקטור ו-15 הוא הנתונים או הערך שנשמרו בו. נוצר וקטור מסוג נתונים 'int' בגודל נתון של 3 המאחסן את הערך 15, מה שאומר שהווקטור 'v3' מאחסן את הדברים הבאים:

פעולות עיקריות:

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

• הוספת ערך
• גישה לערך
• שינוי ערך
• מחיקת ערך

הוספה ומחיקה:

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

פונקציות בשימוש:

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

• Insert(): הוא משמש להוספת ערך בתוך מיכל וקטור במיקום מסוים.
• Erase(): הוא משמש להסרה או מחיקה של ערך בתוך מיכל וקטור במיקום מסוים.
• Swap(): הוא משמש להחלפה של הערכים בתוך מיכל וקטור ששייך לאותו סוג נתונים.
• Assign(): הוא משמש להקצאת ערך חדש לערך שנשמר קודם לכן בתוך מיכל הווקטור.
• Begin(): הוא משמש להחזרת איטרטור בתוך לולאה הפונה לערך הראשון של הווקטור בתוך האלמנט הראשון.
• Clear(): הוא משמש למחיקת כל הערכים המאוחסנים בתוך מיכל וקטור.
• Push_back(): הוא משמש להוספת ערך בסיום של מיכל הווקטור.
• Pop_back(): הוא משמש למחיקת ערך בסיום של מיכל הווקטור.

דוגמא:

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

ראשית, אנו כוללים את קובצי הכותרת ו-. לאחר מכן, מרחב השמות std משולב כדי להוסיף את המחלקות בבת אחת. עבור כתיבת הלוגיקה של התוכנית כולה, אנו קוראים לפונקציה main() שבה מאתחל וקטור בשם 'ספרות'. ההקצאה של וקטור זה מתבצעת בשלב הבא שבו 'ספרות' נתנו ערך של 6 ו-24, כלומר 6 אלמנטים מאוחסנים בתוך מיכל הווקטור, כל אחד עם הערך של 24. ערכים אלו מוצגים לאחר מכן באמצעות 'cout' ' פקודה. לולאת 'for' משמשת עבור פונקציית השינוי push_back() להוספת האלמנטים בתוך המיכל. כעת, ערך 3 מתווסף לספרות בסוף. את, אנו מאתחלים משתנה 'x' לשמירת התיעוד של גודל המיכל הווקטורי. כעת, הערך של האלמנט האחרון מוצג וה- pop_back() הפונקציה תמחק את המספר '3' המאוחסן בתוך המכולה. עבור התצוגה של כל האלמנטים, אנו משתמשים שוב בלולאת 'עבור' עם ה- לְהַכנִיס() משנה שיכניס את הערכים. כאן, 4 יוכנסו בתחילת מיכל הווקטור ויוצגו על המסך. ה ברור() לאחר מכן ימחק או ימחק את כל הערכים המאוחסנים בתוך המיכל. גודל הווקטור מוצג לאחר ביצוע הניקוי.

הפלט מוצג להלן.

פלט קלט קבצי C++:

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

הקלט והפלט בקבצים מאופיינים בשלושת המחלקות העיקריות:

• מחלקה 'istream' משמשת לקליטת קלט.
• המחלקה 'ostream' משמשת להצגת פלט.
• עבור קלט ופלט, השתמש במחלקה 'iostream'.

קבצים מטופלים כזרמים ב-C++. כאשר אנו לוקחים קלט ופלט בקובץ או מקובץ, המחלקות הבאות משמשות:

• Offstream: זוהי מחלקת זרם המשמשת לכתיבה על קובץ.
• Ifstream: זוהי מחלקת זרם המשמשת לקריאת תוכן מקובץ.
• זרם: זוהי מחלקת זרם המשמשת הן לקריאה והן לכתיבה בקובץ או מקובץ.

כיתות 'istream' ו-'ostream' הם האבות הקדמונים של כל המעמדות המוזכרים לעיל. זרמי הקבצים קלים לשימוש כמו הפקודות 'cin' ו-'cout', רק עם ההבדל של שיוך זרמי קבצים אלה לקבצים אחרים. הבה נראה דוגמה ללמוד בקצרה על כיתת 'fstream':

דוגמא:

במקרה זה, אנו כותבים נתונים בקובץ.

אנו משלבים את זרם הקלט והפלט בשלב הראשון. לאחר מכן מתווסף קובץ הכותרת כי אנחנו הולכים לכתוב ולקרוא נתונים מהקובץ. לאחר מכן, קוראים לשיעורים בעזרת מרחב השמות. ה רָאשִׁי() הפונקציה נקראת עבור גוף התוכנית שבו נעשה שימוש ב-'ofstream' שכותב את הנתונים לקובץ, הקובץ נוצר כ-New_File. בשלב הבא, אנו פותחים קובץ טקסט בשם 'דוגמה' על ידי שימוש ב- לִפְתוֹחַ( ) שיטה. אנו כותבים טקסט בעזרת סוגריים זוויתיים לתוך הקובץ. כל תיק מיועד להיסגר לאחר שיטופל. זו הסיבה שהקובץ נסגר בעזרת ה- סגור() פוּנקצִיָה.

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

פתיחת קובץ:

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

כאן, המצב אינו חובה.

סגירת קובץ:

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

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

קבצי טקסט:

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

דוגמא:

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

כאן, אנו כותבים נתונים בקובץ בשם 'דוגמה' באמצעות הפונקציה New_File() . אנו פותחים את הקובץ 'דוגמה' באמצעות ה- לִפְתוֹחַ() שיטה. ה-'ofstream' משמש להוספת הנתונים לקובץ. לאחר ביצוע כל העבודה בתוך הקובץ, הקובץ הנדרש נסגר על ידי שימוש ב- סגור() פוּנקצִיָה. אם הקובץ לא נפתח, מוצגת הודעת השגיאה 'הקובץ אינו נתמך, שגיאה בעת טעינת הקובץ'.

הקובץ נפתח והטקסט מוצג בקונסולה.

קריאת קובץ טקסט:

הקריאה של קובץ מוצגת בעזרת הדוגמה הבאה.

דוגמא:

ה-'ifstream' משמש לקריאת הנתונים המאוחסנים בתוך הקובץ.

הדוגמה כוללת את קבצי הכותרת הראשיים בהתחלה. לאחר מכן, השתמש ב'ifstream' בתוך רָאשִׁי() פוּנקצִיָה. בעזרת 'ifstream', נקרא את הנתונים כאשר הקובץ 'New_File' מציג את הטקסט המאוחסן בתוך קובץ הטקסט 'לדוגמה'. אנחנו מעסיקים את לִפְתוֹחַ() שיטה לפתיחת הקובץ. לאחר מכן, נשתמש בלולאת 'בזמן'. לאחר קריאת הנתונים מקובץ הטקסט 'לדוגמה', ה סגור() הפונקציה משמשת לסגירת הקובץ הדרוש. אם למערכת אין את הקובץ המסוים, אנו מקבלים את ההודעה 'לא ניתן לפתוח את הקובץ'.

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

סיכום

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