C# vs C++: זיכרון, ביצועים, פיתוח משחקים ועקומת למידה

ל-C# ול-C++ יש אות משותפת ותחביר של סוגריים מסולסלים, אבל הן יושבות ברמות שונות. C++ (1985) מתקמפלת ישירות לקוד מכונה ומאפשרת לשלוט בדיוק איפה כל אובייקט חי ומתי הוא מת. C# (2002) מתקמפלת לשפת ביניים שסביבת הריצה של .NET הופכת לקוד מכונה בזמן ריצה, ו-garbage collector מחזיר עבורכם זיכרון. כמעט כל הבדל שבהמשך נובע מהבחירה האחת הזו.

במבט מהיר

זיכרון: garbage collector מול RAII

ב-C++, אובייקט עם אחסון אוטומטי מושמד כשהוא יוצא מה-scope, וה-destructor שלו רץ בדיוק ברגע הזה. אובייקטים ב-heap שייכים ל-smart pointers (std::unique_ptr, std::shared_ptr) או מנוהלים ביד עם new ו-delete. התבנית הזו, Resource Acquisition Is Initialization (RAII), נותנת ניקוי דטרמיניסטי של זיכרון ושל כל משאב אחר.

// C++
#include <memory>
#include <fstream>

void save() {
    std::ofstream file("log.txt");          // opened here
    auto buffer = std::make_unique<char[]>(4096);
    file << "saved\n";
}   // file closed and buffer freed here, in reverse order

ב-C#, כל מופע של מחלקה חי ב-heap המנוהל, וה-garbage collector משחרר אותו בנקודה מאוחרת יותר, ברגע ששום דבר לא מפנה אליו. אף פעם לא כותבים delete ואף פעם לא אפשר לשחרר משהו שעדיין בשימוש. הזיכרון מטופל; מה שה-GC לא מטפל בו מיד הוא משאבים אחרים: קבצים, sockets, חיבורים למסד נתונים. בשבילם יש ב-C# את IDisposable ואת פקודת ה-using, שקוראת ל-Dispose בסוף בלוק, הדבר הקרוב ביותר ל-destructor:

using System;

class Connection : IDisposable
{
    private readonly string name;
    public Connection(string name) { this.name = name; Console.WriteLine($"open {name}"); }
    public void Send(string msg) { Console.WriteLine($"{name} <- {msg}"); }
    public void Dispose() { Console.WriteLine($"close {name}"); }
}

class Program
{
    static void Main()
    {
        using (var db = new Connection("db"))
        using (var cache = new Connection("cache"))
        {
            db.Send("SELECT 1");
            cache.Send("PING");
        }   // Dispose runs here, in reverse order, even if an exception is thrown
        Console.WriteLine("done");
    }
}

פלט:

open db
open cache
db <- SELECT 1
cache <- PING
close cache
close db
done

ההבדל הוא שב-C++ הניקוי קשור ל-scope עבור כל אובייקט מקומי ועבור כל אובייקט ששייך ל-smart pointer, ואילו ב-C# הוא אוטומטי לזיכרון ומופעל לפי בחירה (דרך using) לכל השאר. עוד על זה בדף על פקודת using.

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

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

// C++: compiles, and the behavior is undefined
int scores[3] = {90, 85, 77};
int x = scores[5];   // reads whatever is in memory there

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 90, 85, 77 };
        try
        {
            int x = scores[5];
            Console.WriteLine(x);
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("Index 5 is outside an array of length " + scores.Length);
        }

        string name = null;
        try
        {
            Console.WriteLine(name.Length);
        }
        catch (NullReferenceException)
        {
            Console.WriteLine("name was null");
        }
    }
}

פלט:

Index 5 is outside an array of length 3
name was null

כל המשפחה של באגי השחתת זיכרון (buffer overflows, use after free, double free, מצביעים תלויים) לא קיימת ב-C# בטוחה. זה חלק גדול מהסיבה שקוד C# מהיר יותר לכתיבה ולסקירה.

מצביעים וקוד unsafe

ב-C# כן יש מצביעים, אבל רק בתוך בלוקים של unsafe, והפרויקט חייב להפעיל את זה עם <AllowUnsafeBlocks>true</AllowUnsafeBlocks>. אובייקטים ב-heap המנוהל יכולים לזוז במהלך garbage collection, ולכן מקבעים אותם עם fixed לפני שלוקחים את הכתובת שלהם:

// C#, requires AllowUnsafeBlocks
unsafe
{
    int[] data = { 1, 2, 3 };
    fixed (int* p = data)
    {
        *(p + 1) = 20;   // data is now { 1, 20, 3 }
    }
}

קוד unsafe משמש ל-interop עם ספריות נייטיב ולכמה לולאות חמות. רוב קוד ה-C# ברמה נמוכה כיום משתמש במקום זאת ב-Span<T>, במשתנים מקומיים מסוג ref וב-stackalloc, שנותנים ביצועים דומים למצביעים ועדיין שומרים על בדיקות גבולות.

ביצועים

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

C# משלמת על הבטיחות שלה בסביבת ריצה, בחימום של ה-JIT בהפעלה, ובהשהיות GC מזדמנות. בתפוקה היא בדרך כלל במרחק פקטור קטן מ-C++, והפער הצטמצם בכל גרסת .NET: JIT מדורג עם אופטימיזציה מונחית פרופיל, structs ו-Span<T> כדי להימנע מהקצאות, hardware intrinsics ל-SIMD, ו-Native AOT לקומפילציה מראש לקובץ הרצה נייטיב יחיד. ב-web APIs, בכלים ובלוגיקה עסקית, מסד הנתונים והרשת שולטים, וההבדל בין השפות כמעט לא מורגש.

פיתוח משחקים: Unity מול Unreal

כאן רוב האנשים פוגשים את השאלה. Unity נכתב בסקריפטים של C#: קוד המשחק, הממשק והכלים הם מחלקות C# שמחוברות לאובייקטים במשחק, בעוד שליבת המנוע היא C++. Unreal Engine כתוב ב-C++, וקוד המשחק הוא C++ ובנוסף מערכת הסקריפטים הוויזואלית Blueprints. Godot תומך גם ב-GDScript וגם ב-C#.

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

מודל הבנייה

תוכנית C++ מפוצלת לקובצי header (.h, הצהרות) ולקובצי מקור (.cpp, הגדרות). ה-preprocessor מדביק headers לתוך כל קובץ מקור, כל קובץ מתקמפל בנפרד, וה-linker מחבר את התוצאות. Templates נוצרים בכל קובץ שמשתמש בהם, וזו אחת הסיבות ש-builds גדולים של C++ איטיים.

ב-C# אין שום דבר מזה. פרויקט הוא אוסף של קובצי .cs שמתקמפלים יחד ל-assembly (.dll); סדר ההצהרות וסדר הקבצים לא משנים, וטיפוס בקובץ אחד יכול להשתמש בטיפוס בקובץ אחר בלי include. ספריות מגיעות כחבילות NuGet. ההנחיה using מייבאת namespace, לא קובץ.

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

• אובייקטים. auto p = std::make_unique<Player>(); ו-p->Jump(); ב-C++; var p = new Player(); ו-p.Jump(); ב-C#. C# משתמשת ב-. לכל דבר.
• מחרוזות. std::string הוא ערך שניתן לשינוי; string של C# הוא טיפוס הפניה בלתי ניתן לשינוי.
• ירושה מרובה. C++ מאפשרת למחלקה לרשת מכמה מחלקות; C# מאפשרת מחלקת בסיס אחת ובנוסף כל מספר של interfaces.
• Templates מול generics. templates של C++ הם יצירת קוד בזמן קומפילציה ויכולים לעשות metaprogramming; generics של C# נבדקים פעם אחת עם אילוצים מפורשים (where T : IComparable<T>).
• ספרייה סטנדרטית. הספרייה של C# כוללת HTTP, JSON, ביטויים רגולריים, קלט ופלט של קבצים, דחיסה והצפנה; ב-C++ הרבה מזה מגיע מספריות צד שלישי.

מה ללמוד

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