Hello World ב-C++: התוכנית הראשונה שלכם, שורה אחר שורה

התוכנית

זוהי תוכנית Hello World המלאה ב-C++. לחצו על Run כדי לקמפל ולהריץ אותה בדפדפן:

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

היא מדפיסה שורה אחת:

Hello, World!

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

שורה אחר שורה

#include <iostream>

שורות שמתחילות ב-# הן הוראות לקדם המעבד (preprocessor), שרץ לפני הקומפיילר עצמו. #include <iostream> מדביק את ההצהרות מקובץ הכותרת הסטנדרטי <iostream> (זרמי קלט ופלט). בקובץ הכותרת הזה מוצהרים std::cout ו-std::endl. ל-C++ אין פקודת הדפסה מובנית: ההדפסה היא חלק מהספרייה הסטנדרטית, ואתם מצרפים אותה עם השורה הזו.

int main() {

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

std::cout << "Hello, World!" << std::endl;

השורה הזו היא שמבצעת את ההדפסה בפועל.

• std::cout הוא זרם הפלט הסטנדרטי, בדרך כלל הטרמינל. הקידומת std:: אומרת ש-cout נמצא במרחב השמות (namespace) std, שבו נמצאת כל הספרייה הסטנדרטית.
• << הוא אופרטור ההכנסה. הוא שולח את הערך שאחריו לתוך ה-stream שלפניו. אפשר לשרשר אותו, וכל << מוסיף את החלק הבא לאותו פלט.
• "Hello, World!" הוא ליטרל מחרוזת: טקסט בתוך מירכאות כפולות.
• std::endl מסיים את השורה.
• הנקודה-פסיק מסיימת את הפקודה. כל פקודה ב-C++ צריכה אחת.

return 0;

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

הסוגר המסולסל הסוגר

הסוגר המסולסל הסוגר מסיים את גוף main, ואיתו את התוכנית.

std::endl מול '\n'

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

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    std::cout << "Hello again!" << '\n';
    std::cout << "Line one\nLine two\n";
    return 0;
}

פלט:

Hello, World!
Hello again!
Line one
Line two

התוצאה הנראית זהה. ההבדל הוא ש-std::endl כותב תו שורה חדשה ואז מרוקן את ה-stream, כך שכל טקסט שממתין בחוצץ נשלח לטרמינל מיד. '\n' כותב רק את תו השורה החדשה, וה-stream מתרוקן בקצב שלו (לכל המאוחר כשהתוכנית מסתיימת). בלולאה שמדפיסה אלפי שורות, הריקונים הנוספים של std::endl יוצרים הבדל מדיד, ולכן הרבה מתכנתי C++ משתמשים כברירת מחדל ב-'\n' ושומרים את std::endl למקרים שבהם הטקסט חייב להופיע מיד. רצף הבריחה \n עובד גם בתוך מחרוזת, כמו שהשורה השלישית מראה. עמוד הקלט והפלט מסביר את cout ו-cin לעומק.

הגרסה עם using namespace std;

הרבה מדריכים כותבים Hello World כך:

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl;
    return 0;
}

using namespace std; אומר לקומפיילר לחפש במרחב השמות std שמות שהוא לא מוצא במקום אחר, כך ש-cout ו-endl עובדים בלי הקידומת. זה בסדר לתוכניות קטנות ולתרגילים. בקוד גדול יותר ובקובצי כותרת בדרך כלל נמנעים מזה, כי זה מכניס לטווח מאות שמות סטנדרטיים שעלולים להתנגש בשמות שלכם (למשל פונקציה שלכם בשם count או distance). כתיבת std::cout עולה חמישה תווים ומבטלת את הסיכון.

קימפול והרצה של Hello World במחשב שלכם

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

שמרו את התוכנית בשם hello.cpp, פתחו טרמינל באותה תיקייה וקמפלו אותה:

g++ hello.cpp -o hello

אם שום דבר לא הודפס, זה עבד, ועכשיו יש קובץ הרצה בשם hello (hello.exe ב-Windows) לצד קובץ המקור. הריצו אותו:

./hello

ב-Windows הריצו במקום זאת hello.exe או פשוט hello. ב-macOS הפקודה clang++ hello.cpp -o hello עובדת באותו אופן, ו-g++ שם הוא בדרך כלל Clang בשם אחר.

כדאי להוסיף שני דגלים כבר מההתחלה: -std=c++17 (או -std=c++20) בוחר את תקן השפה, ו--Wall -Wextra מפעיל אזהרות שתופסות טעויות אמיתיות:

g++ -std=c++17 -Wall -Wextra hello.cpp -o hello

עמוד הקימפול של C++ מסביר מה הדגלים האלה עושים, מה המשמעות של -o ולמה בלעדיו מקבלים קובץ בשם a.out.

שגיאות ראשונות נפוצות

טקסט השגיאות שבהמשך הוא של GCC (g++). Clang מנסח את ההודעות שלו אחרת, אבל מצביע על אותה שורה.

חסרה נקודה-פסיק.

hello.cpp:5:5: error: expected ';' before 'return'

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

חסר #include <iostream>.

error: 'cout' is not a member of 'std'

std::cout מוצהר ב-<iostream>. הוסיפו את ה-include בראש הקובץ.

חסר std::.

error: 'cout' was not declared in this scope; did you mean 'std::cout'?

או שתכתבו std::cout ו-std::endl, או שתוסיפו using namespace std; אחרי ה-include.

Main במקום main. C++ רגישה לאותיות גדולות וקטנות. תוכנית עם int Main() מתקמפלת, ואז נכשלת בשלב הקישור (linking) עם undefined reference to 'main', כי המקשר לא מוצא את הפונקציה שממנה התוכנית אמורה להתחיל.

קימפול עם gcc במקום g++. gcc hello.cpp מקמפל את קוד ה-C++ אבל לא מקשר את הספרייה הסטנדרטית של C++, ולכן מקבלים רשימה ארוכה של שגיאות undefined reference to std::.... השתמשו ב-g++ (או clang++) לקובצי C++.

מירכאות מסולסלות. קוד שהועתק ממעבד תמלילים או מדף אינטרנט עלול להכיל מירכאות טיפוגרפיות (“Hello”) במקום ישרות ("Hello"). GCC מדווח stray '\342' in program. הקלידו מחדש את המירכאות בעורך שלכם.

קובצי כותרת ישנים ו-void main. כמה מדריכים ישנים מאוד משתמשים ב-#include <iostream.h> או ב-void main(). אף אחד מהם אינו C++ תקני: קובץ הכותרת הוא <iostream> בלי .h, ו-main חייבת להחזיר int. קומפיילרים מודרניים דוחים את שניהם.

הדפסה עם std::println ב-C++23

C++23 הוסיפה דרך קצרה יותר להדפיס שורה, std::println מקובץ הכותרת <print>:

#include <print>

int main() {
    std::println("Hello, World!");
}

היא מוסיפה את תו השורה החדשה בשבילכם ותומכת בממלאי מקום {} לערכים. התמיכה הגיעה ב-GCC 14, ב-Clang 18 עם libc++ ובגרסאות האחרונות של Visual Studio, והיא דורשת -std=c++23. רוב הקוד והמדריכים הקיימים עדיין משתמשים ב-std::cout, ולכן כדאי לשלוט היטב בשתיהן.