C++‎

מתוך ויקיפדיה, האנציקלופדיה החופשית

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

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

[עריכה] היסטוריה ומקור השם

המדריך הראשון לשפת ++C

השפה פותחה החל משנת 1979 ובתחילת שנות ה־80 על ידי ביארן סטרוסטרופ ממעבדות בל, כאשר הגרסה הראשונה נקראה C with classes (דהיינו "C עם מחלקות"). גרסה זו זכתה לשימוש ב־1983 במעבדות בל. בשנה זו קיבלה השפה את שמה החדש "++C". הגרסה המסחרית הראשונה הופצה בשנת 1985 יחד עם פרסום המדריך הראשון לשפה על ידי סטרוסטרופ, כאשר תמיכה בתבניות הוספה רק מאוחר יותר בגרסה השנייה של מדריך זה. השפה תוקננה על ידי ארגון התקינה הבינלאומי בשנת 1997.

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

[עריכה] עקרונות השפה

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

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

[עריכה] מושגים בשפה

[עריכה] מחלקה (class)

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

[עריכה] הגבלת גישה

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

• private - פרטי: רק שיטות המחלקה יכולות להשתמש בהם
• protected - שמור: למחלקה ולמחלקות שנורשות ממנה
• public - ציבורי: לכולם יש גישה אליהם

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

[עריכה] הורשה

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

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

מנגנון ה־Run-Time Type Information (‏RTTI) מאפשר לקבל מידע, תוך כדי ריצת התוכנית, לגבי עצם אם הינו ממחלקה בסיסית או ממחלקה הנורשת ממנה. מנגנון זה מאפשר המרת טיפוסים בטוחה.

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

• הורשה פרטית (private) - מגבילה את הרשאת הגישה של המשתנים והשיטות ל-private
• הורשה ציבורית (public) - יורשת את כל המשתנים והשיטות באותה רמת גישה
• הורשה שמורה (protected) - מגבילה את הרשאת הגישה של המשתנים והשיטות ל-protected (כלומר public הופך ל-protected)

[עריכה] תבניות

שפת C++‎ תומכת ב־templates – תבניות. התבניות מהוות רמת הפשטה נוספת מעל רמת ההפשטה של המחלקה. הן מאפשרות יצירת מחלקות או פונקציות על ידי תבנית, כאשר בכל פעם הפונקציה או מחלקה נוצרת עבור טיפוס או טיפוסים אחרים. ה"טיפוס" הוא טיפוס פשוט או מחלקה בעצמו. הטיפוסים "מועברים" בכמעין פרמטר על ידי שימוש בסוגריים מיוחדים: "<...>" במקום השימוש ב "(...)" הרגילים. המהדר (קומפיילר) מזהה אילו פרמטרים הועברו לתבנית ומשכפל את התבנית בהתאם.

[עריכה] טיפוסיות חזקה (Strong Typing)

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

[עריכה] הגדרת הקבוע

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

[עריכה] משתנה ייחוס (reference variable)

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

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

[עריכה] העמסת פונקציות

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

[עריכה] פרמטרים אופציונאלים

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

[עריכה] העמסת אופרטורים

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

[עריכה] ספרית התבניות הסטנדרטית (STL)

ספרית התבניות הסטנדרטית (STL - Standard Template Library‎) מכילה מימושים של מבני נתונים רבים ויעילים (מחסנית, רשימה מקושרת, עץ חיפוש מאוזן ועוד), וכן טיפוסי נתונים סטנדרטיים חשובים כמו וקטור (מערך משוכלל) ומחרוזת. הספרייה גם מכילה אלגוריתמים גנריים שניתן להפעיל על מבני הנתונים כמו גם מחלקות לטיפול במספרים ובקלט־פלט.

תוספות אלו, תורשה מרובה (1989), העמסת אופרטורים (1989), תבניות (1991), ספרית התבניות הסטנדרטית ו־RTTI ‏(1995) הוכנסו לשפה בהדרגה.

[עריכה] תחביר

ביארן סטרוסטרופ, יוצר השפה

[עריכה] טיפוסים

• int
• float
• double
• long double
• char
• unsigned long int
• signed long int
• long int
• unsigned short int
• signed short int
• short int
• signed int
• unsigned int
• signed char
• unsigned char

[עריכה] קלט פלט

הקלט והפלט מתבצעים בשפה על ידי stream-ים מהם מבצעים קריאה באמצעות האופרטור << וכתיבה באמצעות האופרטור >>. טיפוסים אלו מוגדרים בעיקר באמצעות הספריות iostream (קלט/פלט סטנדרטי) ו-fstream (קלט/פלט באמצעות קבצים) ובמרבית המהדרים על ידי ספריות נוספות.

למשל תוך שימוש בהגדרת הקלט הסטנדרטי כ-cin והפלט הסטנדרטי כ-cout ניתן לכתוב:

int x;
cout<<"please enter a number: ";
cin>>x;

במקרה כאן הפלט יראה כך:

והמחשב ימתין לקבלת מספר שלם.

[עריכה] הכרזות

[עריכה] מילים שמורות

[עריכה] אופרטורים

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

1. אופרטורים אונריים, בהם יש רק אופרנד אחד. למשל: c++
2. אופרטורים בינאריים, בהם יש שני אופרנדים. למשל a * b
3. אופרנד טרנרי אחד ויחיד, בו יש 3 אופרנדים הוא: a ? b : c

(משמעותו של האופרטור הטרינארי היא: נבדוק את התנאי a, שיכול להיות ביטוי כלשהו, אם הוא מתקיים, נבצע את b, אחרת נבצע את c )

[עריכה] מבנה בקרה

[עריכה] פונקציות/שיטות

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

[עריכה] הצהרה

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

type_specifier function_name (parameter list);

כאשר:

• type_specifier - סוג הערך המוחזר על ידי הפונקציה (int ,long...)
• function_name - שם הפונקציה (חייב להיות מזהה חוקי)
• parameter list - פרמטרי הפונקציה הם רצף מופרד של הגדרות פרמטרים מהצורה הבאה:

type parameter = default_value

כאשר:

• type - טיפוס הפרמטר
• parameter - שם הפרמטר (חייב להיות ייחודי בתוך ההצהרה)
• default_value - ערך ברירת המחדל של הפרמטרים (פרמטרים בעלי ערכים כאלו חייבים להופיע בסוף ההצהרה)

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

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

[עריכה] הגדרות

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

inline type_specifier class::function_name (parameter list)
{
code
}

כאשר:

• inline - אם מופיע מציין כי זאת פונקציית inline (שיטות המופיעות בגוף ההצהרה על מחלקה מוגדרות אוטומטית כ-inline)
• type_specifier - זהה להצהרה
• class - נדרש אם השיטה מוגדרת מחוץ לבלוק של הצהרת המחלקה, במקרים האחרים ערך זה (וה-:: אחריו) מושמט
• function_name - זהה להצהרה
• parameter list - זהה להצהרה (למעט ערכי ברירת מחדל הניתנים להשמטה)
• code - הקוד של השיטה או הפונקציה (אם טיפוס ערך ההחזר איננו void חייב להופיע משפט return מתאים)

[עריכה] קריאה

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

object.name(parameter_list)

כאשר:

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

[עריכה] דוגמה

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

#include <iostream>
 
using namespace std;
 
int max(int x, int y);
 
int max(int x, int y)
{
    if (x > y)
        return x;
    else
        return y;
}
 
int main()
{
    int a, b;
    cout << "Please enter two numbers\n";
    cin >> a >> b;
    cout << max(a, b);
    return 0;
}

[עריכה] שלום עולם

תוכנית שלום עולם בשפת C++‎ תראה כך:

#include <iostream>
 
int main()
{
    std::cout << "Hello, world!"<<std::endl;
    return 0;
}

[עריכה] ראו גם

• ספריית התבניות התקנית
• מונחים בתוכנה
• Microsoft Foundation Classes - ספרייה העוטפת חלקי API של חלונות שנכתבו ב־C, במחלקות C++‎.

[עריכה] לקריאה נוספת

[עריכה] קישורים חיצוניים

מיזמי קרן ויקימדיה
ספר לימוד בוויקיספר: C++

• קורס C++‎ שניתן באוניברסיטת תל אביב הכולל את יסודות תכנות מוכוון עצמים בעברית (מניח ידע בשפת C)
• קורס C++‎ שניתן באוניברסיטה העברית (מניח ידע בשפת C)
• השלמות לקורס הנ"ל
• המדריך השלם לC++, אתר איתן
• תכניות פשוטות ב С++ (אנגלית)
• מדריכי ++C, באתר איתן
• מדריך לשפה, אנגלית

[עריכה] הערות שוליים

1. ^ ‏תוכניתן, תכנן נכון, אתר דהמרקר‏