C# vs C++: bộ nhớ, hiệu năng, làm game và độ khó khi học

C# và C++ có chung một chữ cái và cú pháp dấu ngoặc nhọn, nhưng chúng nằm ở hai tầng khác nhau. C++ (1985) biên dịch thẳng ra mã máy và cho bạn kiểm soát chính xác mỗi đối tượng nằm ở đâu và bị hủy lúc nào. C# (2002) biên dịch ra một ngôn ngữ trung gian, được runtime .NET chuyển thành mã máy lúc chạy, và bộ thu gom rác (garbage collector) thu hồi bộ nhớ thay bạn. Gần như mọi khác biệt bên dưới đều bắt nguồn từ lựa chọn đó.

Tóm tắt nhanh

Bộ nhớ: bộ thu gom rác và RAII

Trong C++, đối tượng có vùng lưu trữ tự động bị hủy khi ra khỏi phạm vi (scope), và hàm hủy (destructor) của nó chạy đúng vào thời điểm đó. Đối tượng trên heap được smart pointer (std::unique_ptr, std::shared_ptr) sở hữu, hoặc được quản lý thủ công bằng new và delete. Mẫu này, Resource Acquisition Is Initialization (RAII), giúp dọn dẹp bộ nhớ và mọi tài nguyên khác một cách xác định.

// 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

Trong C#, mọi instance của lớp nằm trên managed heap và bộ thu gom rác giải phóng nó vào một lúc nào đó sau này, khi không còn gì tham chiếu đến nó. Bạn không bao giờ viết delete và không bao giờ giải phóng nhầm thứ vẫn đang được dùng. Bộ nhớ thì đã được lo; thứ GC không xử lý kịp thời là các tài nguyên khác: tệp, socket, kết nối cơ sở dữ liệu. Với chúng, C# có IDisposable và câu lệnh using, gọi Dispose ở cuối khối lệnh, thứ gần nhất với hàm hủy:

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");
    }
}

Đầu ra:

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

Khác biệt là trong C++, việc dọn dẹp gắn với phạm vi cho mọi đối tượng cục bộ và mọi đối tượng do smart pointer sở hữu, còn trong C# nó tự động với bộ nhớ và phải chủ động bật (qua using) với mọi thứ khác. Xem thêm ở trang câu lệnh using.

An toàn: ngoại lệ thay cho hành vi không xác định

Đọc quá cuối mảng trong C++ là hành vi không xác định: chương trình có thể in ra dữ liệu rác, bị crash, hoặc tiếp tục chạy với bộ nhớ đã hỏng, và kết quả có thể khác nhau giữa các lần build. Cùng lỗi đó trong C# sẽ ném ra một ngoại lệ (exception) ngay tại dòng gây lỗi.

// 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");
        }
    }
}

Đầu ra:

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

Cả một nhóm lỗi hỏng bộ nhớ (tràn bộ đệm, dùng vùng nhớ đã giải phóng, giải phóng hai lần, con trỏ treo) không tồn tại trong C# an toàn. Đó là một phần lớn lý do khiến code C# viết và review nhanh hơn.

Con trỏ và code unsafe

C# có con trỏ, nhưng chỉ bên trong khối unsafe, và dự án phải bật bằng <AllowUnsafeBlocks>true</AllowUnsafeBlocks>. Đối tượng trên managed heap có thể bị di chuyển trong lúc thu gom rác, nên bạn phải ghim chúng bằng fixed trước khi lấy địa chỉ:

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

Code unsafe được dùng để giao tiếp với thư viện native và cho một vài vòng lặp nóng. Phần lớn code C# cấp thấp ngày nay dùng Span<T>, biến cục bộ ref và stackalloc thay thế, cho hiệu năng gần như con trỏ mà vẫn giữ kiểm tra giới hạn.

Hiệu năng

C++ đưa toàn bộ chương trình cho trình biên dịch từ trước và không thêm gì lúc chạy: không bộ thu gom rác, không JIT, không kiểm tra giới hạn trừ khi bạn yêu cầu. Vì vậy nó là lựa chọn khi từng micro giây hay từng byte đều quan trọng, và khi không thể chấp nhận việc chương trình bị khựng.

C# trả giá cho sự an toàn bằng một runtime, thời gian khởi động JIT lúc chạy và đôi lúc dừng để GC. Về thông lượng, C# thường chỉ chậm hơn C++ một hệ số nhỏ, và khoảng cách thu hẹp qua mỗi phiên bản .NET: JIT phân tầng với tối ưu dựa trên profile, struct và Span<T> để tránh cấp phát, hardware intrinsic cho SIMD, và Native AOT để biên dịch trước thành một tệp thực thi native duy nhất. Với web API, công cụ và logic nghiệp vụ, cơ sở dữ liệu và mạng mới là phần chậm nhất, và khác biệt về ngôn ngữ hiếm khi lộ ra.

Làm game: Unity và Unreal

Đây là chỗ hầu hết mọi người gặp câu hỏi này. Unity được lập trình bằng C#: code gameplay, UI và công cụ là các lớp C# gắn vào game object, còn lõi engine là C++. Unreal Engine được viết bằng C++ và gameplay là C++ cùng hệ thống lập trình trực quan Blueprints. Godot hỗ trợ cả GDScript và C#.

C# với Unity dễ học và lặp nhanh hơn, đó là lý do nó rất phổ biến trong game indie và game di động. Unreal và C++ là tiêu chuẩn ở các studio AAA, và lập trình viên engine ở đâu cũng làm việc bằng C++. Một con đường phổ biến là bắt đầu với Unity, rồi học C++ nếu bạn chuyển sang Unreal hoặc làm engine.

Mô hình build

Một chương trình C++ được chia thành tệp header (.h, khai báo) và tệp nguồn (.cpp, định nghĩa). Bộ tiền xử lý chèn header vào từng tệp nguồn, mỗi tệp được biên dịch riêng, và trình liên kết ghép các kết quả lại. Template được sinh code trong mọi tệp dùng đến nó, một lý do khiến việc build dự án C++ lớn rất chậm.

C# không có những thứ đó. Một dự án là tập hợp các tệp .cs được biên dịch cùng nhau thành một assembly (.dll); thứ tự khai báo và thứ tự tệp không quan trọng, và một kiểu ở tệp này dùng được kiểu ở tệp khác mà không cần include. Thư viện được phân phối dưới dạng package NuGet. Chỉ thị using nhập một namespace, không phải một tệp.

Khác biệt cú pháp bạn sẽ nhận ra

• Đối tượng. auto p = std::make_unique<Player>(); và p->Jump(); trong C++; var p = new Player(); và p.Jump(); trong C#. C# dùng . cho mọi thứ.
• Chuỗi. std::string là giá trị có thể thay đổi; string của C# là kiểu tham chiếu bất biến.
• Đa kế thừa. C++ cho một lớp kế thừa từ nhiều lớp; C# cho một lớp cơ sở cùng số interface tùy ý.
• Template và generic. Template của C++ là sinh code lúc biên dịch và có thể làm metaprogramming; generic của C# được kiểm tra kiểu một lần với ràng buộc tường minh (where T : IComparable<T>).
• Thư viện chuẩn. Thư viện chuẩn của C# có HTTP, JSON, biểu thức chính quy, đọc ghi tệp, nén và mã hóa; trong C++, phần lớn những thứ đó đến từ thư viện bên thứ ba.

Nên học ngôn ngữ nào

Học C# nếu bạn muốn làm ứng dụng, backend web, công cụ hoặc game Unity và thấy kết quả nhanh. Học C++ nếu bạn nhắm tới game engine, đồ họa, hệ thống nhúng, hệ điều hành, trình duyệt hoặc bất cứ thứ gì mà kiểm soát ở cấp phần cứng và độ trễ ổn định là mục tiêu chính. C# là ngôn ngữ đầu tiên dễ tiếp cận hơn; C++ đáng học làm ngôn ngữ thứ hai, vì nó dạy bạn runtime của C# đang làm gì thay bạn.