פרמטרים של פונקציות ב-C++: לפי ערך, לפי הפניה, const

פרמטרים מול ארגומנטים

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

ברירת המחדל ב-C++ היא העברה לפי ערך (pass by value): הפונקציה מקבלת עותק.

#include <iostream>
using namespace std;

void addTen(int n) {   // n הוא עותק של מה שמעבירים
    n = n + 10;
    cout << "inside: " << n << endl;
}

int main() {
    int score = 5;
    addTen(score);
    cout << "outside: " << score << endl;   // עדיין 5
    return 0;
}

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

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

לפעמים רוצים שהפונקציה תשנה את המשתנה של הקורא. הוסיפו & לטיפוס הפרמטר והוא הופך להפניה (reference): שם נוסף למקור, לא עותק:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n מתייחס למשתנה של הקורא
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15: המקור השתנה
    return 0;
}

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

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << endl;   // 2 1
    return 0;
}

בלי ה-&, swapValues הייתה מערבבת שני עותקים ו-main לא הייתה רואה שום שינוי: באג נפוץ מאוד אצל מתחילים.

הפניות const: גישה זולה לקריאה בלבד

העברה לפי ערך מעתיקה את הארגומנט. עבור int זה לא עולה כלום, אבל העתקה של string או vector גדולים בכל קריאה היא עבודה אמיתית ומבוזבזת. הפתרון הוא הפניית const (const T&): מקבלים את המהירות של הפניה (בלי העתקה) וגם הבטחה שהמהדר אוכף, שהארגומנט לא ישתנה.

#include <iostream>
#include <string>
using namespace std;

// לא נוצר עותק של המחרוזת, ואי אפשר לשנות אותה בטעות
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // זו הייתה שגיאת הידור: name הוא const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& יכול להיקשר גם לערך זמני
    return 0;
}

כלל אצבע שימושי: העבירו טיפוסים מובנים קטנים (int, double, char, bool, מצביעים) לפי ערך, והעבירו אובייקטים גדולים שצריך רק לקרוא לפי הפניית const. שמרו T& רגיל שאינו const למקרים שבהם אתם באמת מתכוונים לשנות את האובייקט של הקורא.

מלכודת עדינה: int& n רגיל לא יכול להיקשר לערך זמני או לליטרל. addTen(5) מהדוגמה הראשונה לא היה מתהדר אם הפרמטר היה int&, כי 5 אינו משתנה שאפשר לתת לו שם נוסף. const int& כן יכול להיקשר ל-5, וזו עוד סיבה לכך שהפניות const נפוצות כל כך.

ארגומנטים ברירת מחדל

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

#include <iostream>
#include <string>
using namespace std;

void connect(const string& host, int port = 8080, bool secure = false) {
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port << endl;
}

int main() {
    connect("example.com");              // port=8080, secure=false
    connect("example.com", 443);         // secure=false
    connect("example.com", 443, true);   // שלושתם ניתנו
    return 0;
}

שני כללים מכשילים אנשים. ראשית, ברירות המחדל חייבות להיות בסוף: ברגע שלפרמטר יש ברירת מחדל, גם לכל הפרמטרים שאחריו חייבת להיות. אי אפשר לכתוב void f(int a = 1, int b), כי לא הייתה דרך לספק את b תוך דילוג על a. שנית, כשפונקציה מוצהרת ב-header ומוגדרת במקום אחר, שימו את ברירת המחדל רק בהצהרה, ולעולם אל תחזרו עליה בהגדרה: חזרה עליה היא שגיאת הידור.

העברת מערכים ו-vectors

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

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // כאן arr הוא בעצם int*
    int total = 0;
    for (int i = 0; i < size; i++) total += arr[i];
    return total;
}

int main() {
    int nums[] = {4, 8, 15, 16};
    cout << sum(nums, 4) << endl;   // 43
    return 0;
}

מכיוון שהמערך הפך למצביע, sizeof(arr) בתוך sum היה נותן את הגודל של מצביע ולא של המערך: באג ידוע לשמצה. ב-C++ מודרנית העדיפו std::vector (או std::span ב-C++20) שמועבר לפי הפניית const, ונושא את הגודל שלו בעצמו:

#include <iostream>
#include <vector>
using namespace std;

int sum(const vector<int>& v) {   // בלי עותק, יודע את הגודל של עצמו
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> nums = {4, 8, 15, 16};
    cout << sum(nums) << endl;   // 43
    return 0;
}

שימו לב ל-const&: השמיטו אותו וכל קריאה תעתיק את כל ה-vector. עבור vector של ארבעה איברים זה לא מזיק, אבל עבור מיליון איברים זה חור ביצועים שקט.

פרמטרים מסוג מצביע

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

#include <iostream>
using namespace std;

// מחזירה false כשאין לאן לכתוב את התוצאה
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // הגנה מפני null
    *out = 0.0;
    for (const char* p = text; *p >= '0' && *p <= '9'; ++p) {
        *out = *out * 10 + (*p - '0');
    }
    return true;
}

int main() {
    double value;
    if (tryParseDouble("123", &value)) {
        cout << "parsed: " << value << endl;
    }
    return 0;
}

הקורא מעביר &value כדי לשתף את הכתובת שלו, והפונקציה כותבת דרך *out. ההבדל המרכזי מהפניות: מצביע יכול להיות nullptr, ולכן פונקציה שמקבלת מצביע צריכה לבדוק לפני dereference. דילוג על הבדיקה הזו ו-dereference של מצביע null הם undefined behavior, בדרך כלל קריסה. אם "אין ערך" אף פעם לא הגיוני, הפניה נקייה יותר, כי היא בכלל לא יכולה להיות null.

הבא בתור: הפניות

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