1 Lời nói đầu

C không phải là một ngôn ngữ lớn, và nó không hợp với một cuốn sách lớn.

–Brian W. Kernighan, Dennis M. Ritchie

Không có lý do gì để phí lời ở đây nữa, các bạn, ta nhảy thẳng vào code C luôn:

E((ck?main((z?(stat(M,&t)?P+=a+'{'?0:3:
execv(M,k),a=G,i=P,y=G&255,
sprintf(Q,y/'@'-3?A(*L(V(%d+%d)+%d,0)

Và họ sống hạnh phúc mãi mãi về sau. Hết.

Hử? Bạn bảo vẫn còn điều gì đó chưa rõ về cái ngôn ngữ lập trình C này?

Ừ thì, nói thật, chính tôi cũng không biết đoạn code trên làm gì. Nó là một mẩu trích từ một bài dự thi năm 2001 của International Obfuscated C Code Contest¹, một cuộc thi tuyệt vời mà người dự thi cố viết code C khó đọc nhất có thể, thường cho ra kết quả gây ngạc nhiên.

Tin xấu là nếu bạn mới bắt đầu với thứ này, mọi đoạn code C bạn thấy trông có lẽ đều giống như bị làm rối tung lên! Tin tốt là, cảm giác đó sẽ không kéo dài lâu đâu.

Điều tôi sẽ cố làm trong suốt hướng dẫn này là dẫn bạn từ trạng thái hoang mang toàn tập đến kiểu hạnh phúc tỉnh ngộ chỉ có thể đạt được qua lập trình C thuần túy. Cứ thế nhé.

Ngày xưa, C là một ngôn ngữ đơn giản hơn. Rất nhiều tính năng trong cuốn sách này cùng một đống tính năng trong tập Library Reference còn chưa tồn tại khi K&R viết ấn bản thứ hai nổi tiếng vào năm 1988. Dù vậy, phần lõi của ngôn ngữ vẫn nhỏ, và tôi hy vọng mình đã trình bày ở đây theo cách bắt đầu từ cái lõi đơn giản đó rồi mở rộng dần ra.

Và đó là lý do tôi bào chữa cho việc viết một cuốn sách to đến buồn cười về một ngôn ngữ nhỏ gọn và cô đọng như vậy.

1.1 Đối tượng đọc

Hướng dẫn này giả định rằng bạn đã có sẵn một chút kiến thức lập trình từ một ngôn ngữ khác, kiểu như Python², JavaScript³, Java⁴, Rust⁵, Go⁶, Swift⁷, v.v. (Dân Objective-C⁸ sẽ cực kỳ dễ thở!)

Chúng ta sẽ giả định là bạn biết biến là gì, vòng lặp làm gì, hàm hoạt động ra sao, và đại loại thế.

Nếu điều đó không đúng với bạn vì lý do nào đi nữa, thì điều tốt nhất tôi có thể hy vọng cung cấp là một chút giải trí chân thành cho niềm vui đọc sách của bạn. Điều duy nhất tôi có thể hứa một cách hợp lý là hướng dẫn này sẽ không kết thúc ở một nút thắt hồi hộp… hay là sẽ kết thúc như thế?

1.2 Cách đọc cuốn sách này

Hướng dẫn chia làm hai tập, và đây là tập đầu: tập hướng dẫn!

Tập thứ hai là library reference⁹, và nó mang tính tham khảo hơn là hướng dẫn nhiều.

Nếu bạn là người mới, hãy đi qua phần hướng dẫn theo thứ tự, nói chung là vậy. Càng lên cao trong các chương thì thứ tự càng bớt quan trọng.

Và dù trình độ của bạn đến đâu, phần tham khảo luôn sẵn ở đó với các ví dụ đầy đủ về những hàm trong thư viện chuẩn, giúp bạn làm mới trí nhớ bất cứ khi nào cần. Hợp để đọc khi đang ăn một tô ngũ cốc hoặc trong những lúc rảnh khác.

Cuối cùng, liếc qua phần mục lục (nếu bạn đang đọc bản in), các mục thuộc phần tham khảo được in nghiêng.

1.3 Nền tảng và trình biên dịch

Tôi sẽ cố bám vào C chuẩn ISO kiểu cũ¹⁰. Ờ, phần lớn thôi. Đôi khi tôi có thể nổi hứng mà nói về POSIX¹¹ hay gì đó, nhưng để xem đã.

Người dùng Unix (ví dụ Linux, BSD, v.v.) thử chạy cc hoặc gcc từ dòng lệnh, biết đâu bạn đã có sẵn một trình biên dịch cài rồi. Nếu chưa, tìm trong bản phân phối của bạn cách cài gcc hoặc clang.

Người dùng Windows nên xem qua Visual Studio Community¹². Hoặc, nếu bạn muốn trải nghiệm kiểu Unix hơn (rất khuyến khích!), cài WSL¹³ và gcc.

Người dùng Mac sẽ muốn cài XCode¹⁴, và đặc biệt là bộ command line tools.

Có cả tá trình biên dịch ngoài kia, và hầu như tất cả đều dùng được cho cuốn sách này. Một trình biên dịch C++ cũng sẽ biên dịch được phần lớn (nhưng không phải tất cả!) code C. Tốt nhất là dùng một trình biên dịch C đúng nghĩa nếu được.

1.4 Trang chủ chính thức

Vị trí chính thức của tài liệu này là https://beej.us/guide/bgc/¹⁵. Có thể điều này sẽ thay đổi trong tương lai, nhưng khả năng cao hơn là mọi hướng dẫn khác sẽ được dời khỏi máy tính ở Chico State.

1.5 Chính sách email

Tôi thường có mặt để giúp trả lời các câu hỏi qua email, nên cứ viết cho tôi, nhưng tôi không thể bảo đảm sẽ trả lời. Tôi có một cuộc sống khá bận rộn và có những lúc đơn giản là không thể trả lời câu hỏi của bạn. Khi đó, thường là tôi xóa tin nhắn đi luôn. Không có gì cá nhân cả; chỉ là tôi sẽ không bao giờ có đủ thời gian để đưa ra câu trả lời chi tiết mà bạn cần.

Theo nguyên tắc chung, câu hỏi càng phức tạp thì khả năng tôi trả lời càng thấp. Nếu bạn thu hẹp được câu hỏi trước khi gửi và nhớ đính kèm mọi thông tin liên quan (như nền tảng, trình biên dịch, thông báo lỗi bạn đang nhận được, và bất cứ thứ gì bạn nghĩ có thể giúp tôi tìm ra vấn đề), khả năng có hồi âm sẽ cao hơn nhiều.

Nếu bạn không nhận được hồi âm, cứ tiếp tục mò mẫm, cố tự tìm ra câu trả lời, và nếu vẫn không ra, viết lại cho tôi với thông tin đã tìm được, hy vọng khi đó sẽ đủ để tôi giúp đỡ.

Giờ mà tôi đã cằn nhằn xong về chuyện viết hay không viết email cho tôi, chỉ xin nói thêm rằng tôi thực sự trân trọng mọi lời khen mà cuốn hướng dẫn này đã nhận được suốt những năm qua. Nó là một liều tinh thần thật sự, và tôi vui khi biết nó đang được dùng vào việc tốt! :-) Cảm ơn bạn!

1.6 Sao lưu (mirror)

Bạn hoàn toàn được hoan nghênh sao lưu trang này, dù là công khai hay riêng tư. Nếu bạn mirror công khai và muốn tôi liên kết tới bản của bạn từ trang chính, cứ gửi cho tôi một dòng ở beej@beej.us.

1.7 Ghi chú cho người dịch

Nếu bạn muốn dịch hướng dẫn này sang một ngôn ngữ khác, hãy viết cho tôi tại beej@beej.us và tôi sẽ liên kết tới bản dịch của bạn từ trang chính. Cứ thoải mái thêm tên và thông tin liên hệ của bạn vào bản dịch.

Xin lưu ý các điều khoản giấy phép ở mục Bản quyền và Phân phối bên dưới.

1.8 Bản quyền và Phân phối

Beej’s Guide to C có Bản quyền © 2021 Brian “Beej Jorgensen” Hall.

Ngoại trừ một vài trường hợp cụ thể dành cho mã nguồn và bản dịch, nêu ở dưới, tác phẩm này được cấp phép theo giấy phép Creative Commons Attribution-Noncommercial-No Derivative Works 3.0. Để xem một bản của giấy phép này, ghé https://creativecommons.org/licenses/by-nc-nd/3.0/ hoặc gửi thư tới Creative Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.

Một ngoại lệ cụ thể cho phần “No Derivative Works” của giấy phép như sau: hướng dẫn này có thể được tự do dịch sang bất kỳ ngôn ngữ nào, miễn là bản dịch chính xác, và hướng dẫn được in lại đầy đủ. Các giới hạn giấy phép áp dụng cho bản dịch cũng giống như áp dụng cho bản gốc. Bản dịch cũng có thể kèm theo tên và thông tin liên hệ của người dịch.

Mã nguồn C trình bày trong tài liệu này được trao cho miền công cộng, hoàn toàn không có bất kỳ giới hạn giấy phép nào.

Các nhà giáo dục được khuyến khích giới thiệu hoặc cung cấp các bản của hướng dẫn này cho học viên của mình.

Liên hệ beej@beej.us để biết thêm thông tin.

1.9 Lời tri ân

Những điều khó nhất khi viết các hướng dẫn này là:

• Học tài liệu đủ kỹ để có thể giảng lại
• Tìm ra cách giải thích rõ ràng nhất, một quá trình lặp đi lặp lại tưởng như không có hồi kết
• Tự đặt mình vào vai kẻ được gọi là người có thẩm quyền, trong khi thật ra tôi chỉ là một người bình thường đang cố hiểu mọi thứ, giống như mọi người khác thôi
• Kiên trì khi có biết bao thứ khác kéo sự chú ý của tôi đi chỗ khác

Rất nhiều người đã giúp tôi đi qua quá trình này, và tôi muốn ghi nhận những người đã khiến cuốn sách này thành sự thật.

• Mọi người trên Internet đã quyết định chia sẻ kiến thức của mình dưới hình thức này hay hình thức khác. Chính việc tự do chia sẻ các thông tin mang tính hướng dẫn đã khiến Internet trở thành nơi tuyệt vời như hiện nay.
• Những tình nguyện viên ở cppreference.com¹⁶, những người bắc chiếc cầu nối từ bản spec sang thế giới thực.
• Các cao nhân thân thiện trên comp.lang.c¹⁷ và r/C_Programming¹⁸, những người đã kéo tôi qua những phần khó nhằn của ngôn ngữ.
• Tất cả những ai đã gửi sửa lỗi và pull request cho mọi thứ, từ hướng dẫn gây hiểu lầm cho đến lỗi chính tả.

Cảm ơn bạn! ♥

2 Hello, World!

2.1 Kỳ vọng gì từ C

“Mấy cái cầu thang này dẫn đi đâu?”
“Nó dẫn đi lên.”

—Ray Stantz và Peter Venkman, Ghostbusters

C là một ngôn ngữ cấp thấp.

Nó đâu từng như vậy. Thời xa xưa khi người ta còn đục thẻ bìa đục lỗ từ đá hoa cương, C là một cách tuyệt vời để thoát khỏi cực hình của các ngôn ngữ cấp thấp hơn như assembly¹⁹.

Nhưng ở thời hiện đại này, các ngôn ngữ thế hệ mới cung cấp đủ thứ tính năng không tồn tại vào năm 1972 khi C được phát minh. Điều đó có nghĩa là C là một ngôn ngữ khá cơ bản với không nhiều tính năng. Nó có thể làm mọi thứ, nhưng sẽ bắt bạn đổ mồ hôi cho chúng.

Vậy tại sao ta vẫn còn dùng C đến bây giờ?

• Như một công cụ học tập: C không chỉ là một mảnh lịch sử đáng kính của ngành máy tính, mà còn kết nối với phần cứng thô²⁰ (bare metal) theo cách mà các ngôn ngữ hiện thời không có. Khi học C, bạn học về việc phần mềm tương tác với bộ nhớ máy tính ở cấp độ thấp như thế nào. Không có dây an toàn. Bạn sẽ viết ra các phần mềm bị crash, tôi bảo đảm với bạn. Và đó là một phần của cuộc vui!

• Như một công cụ hữu ích: C vẫn còn được dùng cho một số ứng dụng nhất định, chẳng hạn như xây dựng hệ điều hành²¹ hay trong hệ thống nhúng²². (Mặc dù ngôn ngữ Rust²³ đang dòm ngó cả hai lĩnh vực đó!)

Nếu bạn đã quen với một ngôn ngữ khác, nhiều thứ trong C sẽ dễ. C đã truyền cảm hứng cho rất nhiều ngôn ngữ khác, và bạn sẽ thấy mảng mảng của nó trong Go, Rust, Swift, Python, JavaScript, Java, và đủ loại ngôn ngữ khác. Những phần đó sẽ quen thuộc.

Thứ duy nhất trong C làm người ta khựng lại là con trỏ (pointers). Gần như mọi thứ khác đều quen thuộc, nhưng con trỏ là đứa con lạ. Khái niệm đằng sau con trỏ có lẽ bạn đã biết rồi, nhưng C buộc bạn phải tường minh về nó, bằng các toán tử mà có thể bạn chưa từng thấy bao giờ.

Điều đặc biệt khó chịu là một khi bạn đã nắm được²⁴ con trỏ, nó bỗng nhiên trở nên dễ. Còn trước thời điểm đó, chúng cứ trơn tuột như lươn.

Mọi thứ khác trong C chỉ đơn giản là ghi nhớ một cách khác (đôi khi chính là cùng một cách!) để làm một việc bạn đã làm rồi. Con trỏ là phần lạ lẫm. Và, nếu xét kỹ, ngay cả con trỏ cũng chỉ là biến tấu trên một chủ đề có lẽ bạn đã quen.

Vậy chuẩn bị tinh thần cho một chuyến phiêu lưu náo nhiệt gần nhất với lõi của máy tính mà bạn có thể đến được mà không cần đụng đến assembly, bằng ngôn ngữ có ảnh hưởng nhất mọi thời đại²⁵. Giữ chặt!

2.2 Hello, World!

Đây là ví dụ chuẩn mực của một chương trình C. Ai cũng dùng nó. (Lưu ý là các con số ở bên trái chỉ để người đọc tham khảo, chúng không phải là một phần của mã nguồn.)

/* Hello world program */

#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");  // Actually do the work here
}

Chúng ta sẽ đeo găng tay cao su loại dày tay áo dài, vớ lấy con dao mổ, và rạch thẳng vào thứ này để xem cái gì làm nó hoạt động. Nào, rửa tay đi, vì ta bắt đầu. Cắt nhẹ thôi…

Ta giải quyết cái dễ trước: mọi thứ nằm giữa hai cặp ký hiệu /* và */ là chú thích (comment) và sẽ bị trình biên dịch bỏ qua hoàn toàn. Mọi thứ nằm trên một dòng sau // cũng vậy. Nó cho phép bạn để lại thông điệp cho chính mình và cho người khác, để khi bạn quay lại đọc code của mình ở tương lai xa, bạn biết cái quái gì mình đang định làm. Tin tôi đi, bạn sẽ quên; chuyện đó xảy ra.

Giờ, cái #include này là gì? KINH QUÁ! Được rồi, nó báo cho C Preprocessor kéo nội dung của một file khác và chèn vào code ngay chỗ đó.

Khoan, C Preprocessor là cái gì? Câu hỏi hay. Việc biên dịch có hai giai đoạn²⁶: preprocessor và compiler. Bất cứ thứ gì bắt đầu bằng dấu pound, dấu thăng, hay “octothorpe”, (#) là thứ mà preprocessor xử lý trước khi compiler thậm chí còn bắt đầu. Các chỉ thị preprocessor (preprocessor directives) thường gặp, như người ta hay gọi, là #include và #define. Bàn thêm về mấy cái đó sau.

Trước khi đi tiếp, tại sao tôi lại dày công chỉ ra rằng dấu pound được gọi là octothorpe? Câu trả lời đơn giản: tôi thấy từ octothorpe nó buồn cười xuất sắc, nên phải rải bừa cái tên đó ra mọi khi có dịp. Octothorpe. Octothorpe, octothorpe, octothorpe.

Nên dù sao đi nữa. Sau khi C preprocessor xử lý xong mọi thứ, kết quả được trao cho compiler để nó sản xuất ra mã assembly²⁷, mã máy²⁸, hay bất cứ cái gì nó định làm. Mã máy là “ngôn ngữ” mà CPU hiểu, và nó có thể hiểu rất nhanh. Đây là một trong những lý do chương trình C thường chạy nhanh.

Đừng lo về các chi tiết kỹ thuật của quá trình biên dịch lúc này; cứ biết rằng code của bạn chạy qua preprocessor, rồi output của nó chạy qua compiler, rồi cái đó tạo ra một file thực thi để bạn chạy.

Còn phần còn lại của dòng thì sao? Cái <stdio.h> là gì? Đó là thứ người ta gọi là header file. Chính cái chấm-h ở cuối đã tiết lộ điều đó. Thực ra nó là header file “Standard I/O” (stdio) mà bạn sẽ dần dần quen và yêu mến. Nó cho ta quyền truy cập vào một loạt chức năng I/O²⁹. Với chương trình demo của ta, ta đang xuất chuỗi “Hello, World!”, nên cụ thể là ta cần truy cập đến hàm printf() để làm việc đó. File <stdio.h> cho ta quyền truy cập đó. Nói cơ bản, nếu ta cố dùng printf() mà không có #include <stdio.h>, compiler sẽ rền rĩ phàn nàn với ta về chuyện đó.

Sao tôi biết phải #include <stdio.h> cho printf()? Câu trả lời: nó nằm trong tài liệu. Nếu bạn đang trên hệ Unix, gõ man 3 printf và nó sẽ cho bạn biết ngay ở đầu trang man cần những file header nào. Hoặc xem phần tham khảo trong cuốn sách này. :-)

Trời đất ơi. Ngần ấy chỉ để cover dòng đầu tiên! Nhưng, nói thẳng ra, nó đã bị mổ xẻ hoàn toàn. Không còn bí ẩn nào sót lại!

Vậy thở một hơi đi… nhìn lại mã mẫu. Chỉ còn vài dòng dễ nữa thôi.

Chào mừng quay lại sau kỳ nghỉ! Tôi biết bạn chẳng nghỉ thực sự đâu; tôi chỉ chiều lòng bạn thôi.

Dòng tiếp theo là main(). Đây là định nghĩa của hàm main(); mọi thứ giữa cặp dấu ngoặc nhọn ngoằn ngoèo ({ và }) là một phần của định nghĩa hàm.

(Vậy thì gọi một hàm khác như thế nào nhỉ? Câu trả lời nằm ở dòng printf(), ta sẽ đến đó trong một phút nữa.)

Giờ, hàm main là đặc biệt theo nhiều nghĩa, nhưng có một nghĩa nổi bật hơn cả: nó là hàm sẽ được gọi tự động khi chương trình của bạn bắt đầu chạy. Không có gì của bạn được gọi trước main(). Trong ví dụ của ta, điều này ổn vì tất cả những gì ta muốn làm là in một dòng rồi thoát.

À, còn chuyện này: một khi chương trình chạy qua khỏi cuối main(), chỗ dấu ngoặc nhọn đóng ở dưới đó, chương trình sẽ thoát, và bạn sẽ trở lại với dấu nhắc dòng lệnh.

Vậy giờ ta biết rằng chương trình đó đã kéo vào một header file, stdio.h, và khai báo một hàm main() sẽ chạy khi chương trình được khởi động. Bên trong main() có những món ngon gì?

Tôi rất vui là bạn đã hỏi. Thật đấy! Ta chỉ có đúng một món ngon thôi: lời gọi đến hàm printf(). Bạn có thể nhận ra đây là một lời gọi hàm chứ không phải định nghĩa hàm qua nhiều cách, nhưng một dấu hiệu là không có cặp dấu ngoặc nhọn ngoằn ngoèo đi sau nó. Và bạn kết thúc lời gọi hàm bằng một dấu chấm phẩy để compiler biết đây là điểm kết của biểu thức. Bạn sẽ đặt dấu chấm phẩy sau gần như mọi thứ, bạn sẽ thấy.

Bạn đang truyền một đối số (argument) cho hàm printf(): một chuỗi sẽ được in ra khi bạn gọi nó. À đúng rồi, ta đang gọi một hàm! Ta giỏi thế! Khoan, khoan, đừng vội tự mãn. Cái \n khùng khùng ở cuối chuỗi là gì? Ờ, phần lớn các ký tự trong chuỗi sẽ được in ra đúng như cách chúng được lưu. Nhưng có một số ký tự không thể in trên màn hình một cách đẹp đẽ nên được nhúng dưới dạng mã hai ký tự bắt đầu bằng dấu chéo ngược. Một trong những cái phổ biến nhất là \n (đọc là “backslash-N” hoặc đơn giản “newline”) tương ứng với ký tự xuống dòng. Đây là ký tự làm cho việc in tiếp theo bắt đầu ở đầu dòng tiếp chứ không ở dòng hiện tại. Giống như bạn nhấn return ở cuối dòng.

Vậy chép đoạn code đó vào một file tên là hello.c và build nó. Trên nền tảng kiểu Unix (ví dụ Linux, BSD, Mac, hay WSL), từ dòng lệnh bạn sẽ build bằng lệnh kiểu thế này:

gcc -o hello hello.c

(Có nghĩa là “biên dịch hello.c, và xuất ra file thực thi tên là hello”.)

Sau khi xong, bạn sẽ có một file tên là hello mà bạn có thể chạy bằng lệnh này:

./hello

(Phần ./ ở đầu bảo shell “chạy file từ thư mục hiện tại”.)

Và xem thử nó ra cái gì:

Hello, World! 

Xong và đã test! Ship it!

2.3 Chi tiết về biên dịch

Nói thêm một chút về cách build chương trình C, và chuyện gì xảy ra hậu trường.

Giống các ngôn ngữ khác, C có mã nguồn (source code). Nhưng, tùy vào ngôn ngữ bạn đến từ đâu, có thể bạn chưa bao giờ phải biên dịch mã nguồn của mình thành một file thực thi (executable).

Biên dịch là quá trình lấy mã nguồn C của bạn và biến nó thành một chương trình mà hệ điều hành có thể thực thi.

Dân JavaScript và Python không hề quen với một bước biên dịch tách biệt, dù rằng hậu trường nó vẫn đang diễn ra! Python biên dịch mã nguồn của bạn thành thứ gọi là bytecode mà máy ảo Python có thể chạy. Dân Java thì quen với việc biên dịch, nhưng cái đó sinh ra bytecode cho Java Virtual Machine.

Khi biên dịch C, mã máy được sinh ra. Đây là các số 1 và 0 mà CPU có thể chạy trực tiếp và nhanh chóng.

Các ngôn ngữ thường không biên dịch được gọi là ngôn ngữ thông dịch (interpreted). Nhưng như ta đã nói với Java và Python, chúng cũng có một bước biên dịch. Và không có luật nào nói C không thể được thông dịch. (Ngoài kia có cả interpreter cho C đấy!) Nói ngắn gọn, nó là một mớ ranh giới mờ. Biên dịch nói chung chỉ là việc lấy mã nguồn và biến nó thành một dạng khác, dễ thực thi hơn.

Trình biên dịch C (C compiler) là chương trình làm việc biên dịch đó.

Như đã nói, gcc là một trình biên dịch được cài sẵn trên rất nhiều hệ điều hành kiểu Unix³⁰. Và thường được chạy từ dòng lệnh trong terminal, nhưng không phải luôn luôn. Bạn cũng có thể chạy nó từ IDE.

Vậy ta build từ dòng lệnh kiểu gì?

2.4 Build với gcc

Nếu bạn có một file nguồn tên là hello.c trong thư mục hiện tại, bạn có thể build nó thành một chương trình tên là hello bằng lệnh gõ trong terminal sau:

gcc -o hello hello.c

Cờ -o có nghĩa là “xuất ra file này”³¹. Và ở cuối là hello.c, tên của file ta muốn biên dịch.

Nếu mã nguồn được tách làm nhiều file, bạn có thể biên dịch tất cả cùng nhau (gần như thể chúng là một file, dù các quy tắc thực sự có phần phức tạp hơn) bằng cách đưa tất cả các file .c lên dòng lệnh:

gcc -o awesomegame ui.c characters.c npc.c items.c

và tất cả chúng sẽ được build cùng nhau thành một file thực thi to.

Thế là đủ để bắt đầu, sau này ta sẽ bàn chi tiết về nhiều file nguồn, object files, và đủ thứ vui khác.

2.5 Build với clang

Trên máy Mac, trình biên dịch mặc định không phải gcc, mà là clang. Nhưng cũng có một wrapper được cài sẵn để bạn vẫn chạy gcc được.

Bạn cũng có thể cài đúng trình gcc qua Homebrew³² hay cách khác.

2.6 Build từ IDE

Nếu bạn đang dùng Môi trường phát triển tích hợp (Integrated Development Environment, IDE), có lẽ bạn không phải build từ dòng lệnh.

Với Visual Studio, CTRL-F7 sẽ build, và CTRL-F5 sẽ chạy.

Với VS Code, bạn có thể nhấn F5 để chạy qua debugger. (Bạn sẽ phải cài C/C++ Extension.)

Với XCode, bạn có thể build bằng COMMAND-B và chạy bằng COMMAND-R. Để có bộ command line tools, Google “XCode command line tools” và bạn sẽ tìm được hướng dẫn cài đặt.

Để bắt đầu, tôi khuyến khích bạn cũng thử build từ dòng lệnh, nó là lịch sử mà!

2.7 Các phiên bản C

C đã đi một chặng đường dài qua nhiều năm, và nó có nhiều số hiệu phiên bản được đặt tên để chỉ ra phương ngữ của ngôn ngữ mà bạn đang dùng.

Chúng thường tham chiếu đến năm của bản đặc tả.

Nổi tiếng nhất là C89, C99, C11, và C23. Ta sẽ tập trung vào cái cuối cùng trong cuốn sách này.

Nhưng đây là một bảng đầy đủ hơn:

Bạn có thể ép GCC dùng một trong các chuẩn này bằng tham số dòng lệnh -std=. Nếu muốn nó soi kỹ chuẩn, thêm -pedantic.

Ví dụ:

gcc -std=c11 -pedantic foo.c

Với cuốn sách này, tôi biên dịch chương trình cho C23 với toàn bộ cảnh báo bật lên:

gcc -Wall -Wextra -std=c23 -pedantic foo.c

3 Biến và câu lệnh

“It takes all kinds to make a world, does it not, Padre?”
“So it does, my son, so it does.”

—Pirate Captain Thomas Bartholomew Red to the Padre, Pirates

Một chương trình C có thể chứa đủ thứ trên đời.

Ừ đấy.

Và vì nhiều lý do, sẽ dễ cho tất cả chúng ta nếu phân loại một vài thứ hay gặp trong chương trình, để ai nấy đều rõ chúng ta đang nói về cái gì.

3.1 Biến

Người ta hay nói “biến giữ giá trị”. Nhưng một cách nghĩ khác là: biến là một cái tên dễ đọc đối với con người, dùng để tham chiếu tới một mẩu dữ liệu nào đó trong bộ nhớ.

Chúng ta sẽ dừng lại một nhịp để he hé nhìn xuống cái hang thỏ mang tên pointer (con trỏ). Đừng lo lắng gì cả.

Bạn có thể hình dung bộ nhớ như một mảng khổng lồ gồm các byte³³. Dữ liệu được lưu trong “mảng” này³⁴. Nếu một số lớn hơn một byte, nó được lưu trong nhiều byte. Vì bộ nhớ giống như một mảng, mỗi byte có thể được tham chiếu qua chỉ số của nó. Chỉ số này vào bộ nhớ còn được gọi là address (địa chỉ), location (vị trí), hay pointer (con trỏ).

Khi bạn có một biến trong C, giá trị của biến đó nằm trong bộ nhớ ở đâu đó, tại một địa chỉ nào đó. Dĩ nhiên. Chứ nó còn ở chỗ nào được nữa? Nhưng nhắc tới một giá trị bằng địa chỉ số thì thật khổ sở, nên ta đặt cho nó cái tên, và cái tên đó chính là biến.

Lý do tôi nói hết đống này có hai:

1. Nó sẽ giúp bạn dễ hiểu biến con trỏ sau này, chúng là biến chứa địa chỉ của các biến khác!
2. Và nó cũng giúp bạn dễ hiểu con trỏ sau này.

Tóm lại, biến là một cái tên cho mẩu dữ liệu được lưu trong bộ nhớ ở một địa chỉ nào đó.

3.1.1 Tên biến

Bạn có thể dùng các ký tự trong khoảng 0-9, A-Z, a-z, và dấu gạch dưới cho tên biến, với các luật sau:

• Không được bắt đầu tên biến bằng chữ số 0-9.
• Không được bắt đầu tên biến bằng hai dấu gạch dưới.
• Không được bắt đầu tên biến bằng một dấu gạch dưới rồi tới chữ hoa A-Z.

Với Unicode thì cứ thử xem. Trong spec §D.2 có vài luật nói về dải codepoint Unicode nào được phép ở phần nào của định danh, nhưng viết hết ra thì dài quá, và có lẽ đời bạn cũng chẳng cần nghĩ tới.

3.1.2 Kiểu biến

Tuỳ vào ngôn ngữ bạn đã biết, có thể bạn đã quen với khái niệm type (kiểu), có thể chưa. Nhưng C hơi khó tính ở chỗ này, nên ta nên ôn lại một chút.

Vài kiểu ví dụ, thuộc loại cơ bản nhất:

C cố gắng tự động chuyển đổi giữa hầu hết các kiểu số khi bạn yêu cầu. Ngoài chuyện đó, mọi phép chuyển đổi đều phải làm bằng tay, đặc biệt là giữa chuỗi và số.

Gần như mọi kiểu trong C đều là biến thể của những kiểu trên.

Trước khi dùng một biến, bạn phải khai báo (declare) biến đó và cho C biết biến chứa kiểu gì. Một khi đã khai báo, kiểu của biến không thể đổi sau này lúc chạy chương trình. Đặt là gì thì nó là thế cho đến khi rơi ra khỏi scope (phạm vi) và bị vũ trụ hấp thụ lại.

Hãy lấy code “Hello, world” trước đó và thêm vài biến vào:

#include <stdio.h>

int main(void)
{
    int i;    // Holds signed integers, e.g. -3, -2, 0, 1, 10
    float f;  // Holds signed floating point numbers, e.g. -3.1416

    printf("Hello, World!\n");  // Ah, blessed familiarity
}

Đó! Ta đã khai báo vài biến. Chưa dùng đến, và cả hai đều chưa được khởi tạo. Một biến giữ số nguyên, biến kia giữ số dấu phẩy động (về cơ bản là số thực, nếu bạn có nền toán).

Biến chưa được khởi tạo có giá trị không xác định³⁷. Chúng phải được khởi tạo, nếu không bạn phải giả định chúng chứa một số nhảm nào đó.

Đây là một trong những chỗ C có thể “cắn” bạn. Theo kinh nghiệm của tôi, phần lớn trường hợp cái giá trị không xác định đó là số không… nhưng nó có thể khác nhau giữa các lần chạy! Đừng bao giờ giả định giá trị sẽ là 0, kể cả khi bạn thấy đúng là 0. Luôn luôn khởi tạo biến một cách rõ ràng trước khi dùng³⁸.

Khoan, bạn muốn lưu số vào mấy biến đó à? Điên rồ!

Thì cứ làm đi:

int main(void)
{
    int i;

    i = 2; // Assign the value 2 into the variable i

    printf("Hello, World!\n");
}

Đỉnh. Ta vừa lưu một giá trị. Giờ in nó ra nào.

Ta sẽ in bằng cách truyền hai đối số tuyệt vời cho hàm printf(). Đối số thứ nhất là một chuỗi mô tả cần in gì và in như thế nào (gọi là format string), và đối số thứ hai là giá trị cần in, cụ thể là thứ đang nằm trong biến i.

printf() quét chuỗi format tìm các chuỗi đặc biệt bắt đầu bằng dấu phần trăm (%) để biết phải in gì. Ví dụ, khi gặp %d, nó nhìn vào tham số kế tiếp và in ra dưới dạng số nguyên. Gặp %f thì in dưới dạng float. Gặp %s thì in chuỗi.

Nhờ vậy, ta có thể in ra giá trị của nhiều kiểu khác nhau như này:

#include <stdio.h>

int main(void)
{
    int i = 2;
    float f = 3.14;
    char *s = "Hello, world!";  // char * ("char pointer") is the string type

    printf("%s  i = %d and f = %f!\n", s, i, f);
}

Và output sẽ là:

Hello, world!  i = 2 and f = 3.14!

Kiểu này, printf() có thể giống với các loại chuỗi format hay chuỗi tham số hoá trong những ngôn ngữ khác mà bạn đã quen.

LƯU Ý: Trong các mục tiếp theo, tôi mặc định bạn đã khai báo các biến từ trước. Nếu ví dụ dùng số nguyên i và j, cứ giả định đâu đó phía trên ví dụ tôi đã có:

int i, j;

3.1.3 Kiểu Boolean

C có kiểu Boolean, true hay false?

1!

Về lịch sử, C không có kiểu Boolean, và vài người có thể tranh cãi là bây giờ vẫn chưa có.

Trong C, 0 nghĩa là “false”, và khác không nghĩa là “true”.

Nên 1 là true. -37 cũng true. Và 0 là false.

Bạn có thể khai báo Boolean như int:

int x = 1;

if (x) {
    printf("x is true!\n");
}

Trong C23, bạn có bool, true, và false thực sự. Trước đó, nếu bạn có phiên bản C đủ mới, có thể #include <stdbool.h> để có thứ tương tự.

#include <stdio.h>
#include <stdbool.h>  // not needed in C23

int main(void) {
    bool x = true;

    if (x) {
        printf("x is true!\n");
    }
}

Về lý thuyết bạn nên gán biến bool là true, false, hoặc kết quả của biểu thức trả ra true/false, nhưng thật ra bạn có thể ép đủ thứ thành bool. Có vài luật cụ thể, nhưng đại khái thứ nào giống-số-không thường thành false, còn thứ khác-không thì thành true.

Nhưng cẩn thận nếu bạn trộn lẫn, vì giá trị số của true là 1, gần như chắc chắn³⁹, và nếu bạn trông cậy vào một giá trị dương khác mang nghĩa true, bạn có thể bị lệch. Ví dụ:

printf("%d\n", true == 12);  // Prints "0", false!

3.2 Toán tử và biểu thức

Các toán tử trong C chắc đã quen thuộc với bạn từ ngôn ngữ khác. Ta lướt nhanh qua một số ở đây.

(Có cả đống chi tiết hơn thế này, nhưng trong mục này ta sẽ làm đủ để bắt đầu thôi.)

3.2.1 Số học

Hy vọng mấy cái này quen thuộc:

i = i + 3;  // Addition (+) and assignment (=) operators, add 3 to i
i = i - 8;  // Subtraction, subtract 8 from i
i = i * 9;  // Multiplication
i = i / 2;  // Division
i = i % 5;  // Modulo (division remainder)

Có các biến thể viết tắt cho tất cả mấy dòng trên. Mỗi dòng có thể viết ngắn gọn hơn như sau:

i += 3;  // Same as "i = i + 3", add 3 to i
i -= 8;  // Same as "i = i - 8"
i *= 9;  // Same as "i = i * 9"
i /= 2;  // Same as "i = i / 2"
i %= 5;  // Same as "i = i % 5"

Không có toán tử luỹ thừa. Bạn sẽ phải dùng một trong các biến thể của hàm pow() trong math.h.

Giờ thì nhảy vào mấy thứ lạ hơn mà có thể ngôn ngữ khác của bạn không có!

3.2.2 Toán tử ba ngôi

C cũng có toán tử ba ngôi (ternary operator). Đây là một biểu thức mà giá trị của nó phụ thuộc vào kết quả của một điều kiện được nhúng trong biểu thức.

// If x > 10, add 17 to y. Otherwise add 37 to y.

y += x > 10? 17: 37;

Rối thật! Đọc nhiều sẽ quen. Để giúp một chút, tôi viết lại biểu thức trên bằng câu lệnh if:

// This expression:

y += x > 10? 17: 37;

// is equivalent to this non-expression:

if (x > 10)
    y += 17;
else
    y += 37;

So sánh hai đoạn cho tới khi bạn nhận ra từng thành phần của toán tử ba ngôi.

Hoặc một ví dụ khác, in ra xem số trong x là chẵn hay lẻ:

printf("The number %d is %s.\n", x, x % 2 == 0? "even": "odd");

Format specifier %s trong printf() nghĩa là in một chuỗi. Nếu biểu thức x % 2 cho ra 0, giá trị của toàn bộ biểu thức ba ngôi là chuỗi "even". Ngược lại là chuỗi "odd". Khá ngầu!

Cần lưu ý rằng toán tử ba ngôi không phải flow control (điều khiển luồng) như câu lệnh if. Nó chỉ là một biểu thức cho ra một giá trị.

3.2.3 Tăng giảm tiền tố và hậu tố

Giờ nghịch tiếp một thứ mà có lẽ bạn chưa thấy.

Đây là cặp toán tử huyền thoại post-increment và post-decrement:

i++;        // Add one to i (post-increment)
i--;        // Subtract one from i (post-decrement)

Thường thì chúng được dùng như phiên bản ngắn của:

i += 1;        // Add one to i
i -= 1;        // Subtract one from i

nhưng tinh ý hơn thì chúng khác một chút, mấy anh bạn ranh mãnh này.

Xem luôn biến thể pre-increment và pre-decrement:

++i;        // Add one to i (pre-increment)
--i;        // Subtract one from i (pre-decrement)

Với pre-increment và pre-decrement, giá trị của biến được tăng hoặc giảm trước khi biểu thức được tính. Sau đó biểu thức được tính với giá trị mới.

Với post-increment và post-decrement, giá trị của biểu thức được tính trước bằng giá trị hiện tại, rồi sau đó giá trị mới được tăng hay giảm sau khi giá trị của biểu thức đã được xác định.

Bạn có thể nhúng chúng vào biểu thức như sau:

i = 10;
j = 5 + i++;  // Compute 5 + i, _then_ increment i

printf("%d, %d\n", i, j);  // Prints 11, 15

So sánh với toán tử pre-increment:

i = 10;
j = 5 + ++i;  // Increment i, _then_ compute 5 + i

printf("%d, %d\n", i, j);  // Prints 11, 16

Kỹ thuật này được dùng rất thường xuyên khi truy cập và thao tác mảng và con trỏ. Nó cho bạn cách dùng giá trị trong một biến, đồng thời tăng hoặc giảm giá trị đó trước hoặc sau khi dùng.

Nhưng chỗ bạn hay thấy nhất là trong vòng lặp for:

for (i = 0; i < 10; i++)
    printf("i is %d\n", i);

Để sau nói tiếp.

3.2.4 Toán tử dấu phẩy

Đây là một cách ít dùng để ngăn các biểu thức sẽ được chạy từ trái sang phải:

x = 10, y = 20;  // First assign 10 to x, then 20 to y

Nghe hơi vô nghĩa, vì bạn có thể thay dấu phẩy bằng dấu chấm phẩy đúng không?

x = 10; y = 20;  // First assign 10 to x, then 20 to y

Nhưng hai cái hơi khác nhau đấy. Cái sau là hai biểu thức riêng biệt, còn cái trước là một biểu thức duy nhất!

Với toán tử dấu phẩy, giá trị của biểu thức dấu phẩy là giá trị của biểu thức ngoài cùng bên phải:

x = (1, 2, 3);

printf("x is %d\n", x);  // Prints 3, because 3 is rightmost in the comma list

Nhưng ngay cả thế cũng khá gượng gạo. Một chỗ phổ biến hay dùng toán tử dấu phẩy là trong vòng lặp for để làm nhiều việc trong từng phần của câu lệnh:

for (i = 0, j = 10; i < 100; i++, j++)
    printf("%d, %d\n", i, j);

Ta sẽ quay lại phần này sau.

3.2.5 Toán tử điều kiện

Với giá trị Boolean, ta có cả loạt toán tử chuẩn:

a == b;  // True if a is equivalent to b
a != b;  // True if a is not equivalent to b
a < b;   // True if a is less than b
a > b;   // True if a is greater than b
a <= b;  // True if a is less than or equal to b
a >= b;  // True if a is greater than or equal to b

Đừng lẫn phép gán (=) với phép so sánh (==)! Hai dấu bằng là so sánh, một dấu bằng là gán.

Ta có thể dùng biểu thức so sánh với câu lệnh if:

if (a <= 10)
    printf("Success!\n");

3.2.6 Toán tử Boolean

Ta có thể nối hoặc biến đổi các biểu thức điều kiện bằng toán tử Boolean cho and, or, và not.

Ví dụ Boolean “and”:

// Do something if x less than 10 and y greater than 20:

if (x < 10 && y > 20)
    printf("Doing something!\n");

Ví dụ Boolean “not”:

if (!(x < 12))
    printf("x is not less than 12\n");

! có độ ưu tiên cao hơn các toán tử Boolean khác, nên trong trường hợp này ta phải dùng dấu ngoặc.

Dĩ nhiên, thế thì cũng chỉ tương đương:

if (x >= 12)
    printf("x is not less than 12\n");

nhưng tôi cần ví dụ mà!

3.2.7 Toán tử sizeof

Toán tử này cho bạn biết kích thước (tính bằng byte) mà một biến hoặc một kiểu dữ liệu cụ thể chiếm trong bộ nhớ.

Chính xác hơn, nó cho biết kích thước (tính bằng byte) mà kiểu của một biểu thức cụ thể (có thể chỉ là một biến đơn) chiếm trong bộ nhớ.

Con số này có thể khác nhau trên các hệ thống khác nhau, trừ char và các biến thể của nó (luôn là 1 byte).

Và có thể hiện tại trông nó chưa hữu ích lắm, nhưng ta sẽ nhắc tới đây đó, nên đáng nói qua.

Vì nó tính số byte cần để lưu một kiểu, bạn có thể nghĩ nó sẽ trả về một int. Hoặc… vì kích thước không thể âm, có lẽ trả về unsigned?

Hoá ra C có một kiểu đặc biệt cho giá trị trả về từ sizeof. Đó là size_t, đọc là “size tee”⁴⁰. Tất cả những gì ta biết là nó là kiểu số nguyên unsigned có thể chứa kích thước tính bằng byte của bất cứ thứ gì bạn đưa vào sizeof.

size_t xuất hiện ở rất nhiều nơi khi ta truyền hoặc trả về đếm số lượng. Cứ coi nó như một giá trị đại diện cho một phép đếm.

Bạn có thể lấy sizeof của một biến hoặc biểu thức:

int a = 999;

// %zu is the format specifier for type size_t
// If your compiler balks at the "z" part, leave it off

printf("%zu\n", sizeof a);      // Prints 4 on my system
printf("%zu\n", sizeof(2 + 7)); // Prints 4 on my system
printf("%zu\n", sizeof 3.14);   // Prints 8 on my system

// If you need to print out negative size_t values, use %zd

Nhớ nhé: đó là kích thước tính bằng byte của kiểu của biểu thức, chứ không phải kích thước của chính biểu thức. Đó là lý do kích thước của 2+7 bằng với kích thước của a, cả hai đều kiểu int. Ta sẽ gặp lại con số 4 ở khối code kế tiếp…

…Ở đó bạn sẽ thấy có thể lấy sizeof của một kiểu (lưu ý cần dấu ngoặc quanh tên kiểu, khác với biểu thức):

printf("%zu\n", sizeof(int));   // Prints 4 on my system
printf("%zu\n", sizeof(char));  // Prints 1 on all systems

Một điều quan trọng cần nhớ: sizeof là phép toán thời điểm biên dịch (compile-time)⁴¹. Kết quả của biểu thức được xác định toàn bộ lúc biên dịch, chứ không phải lúc chạy.

Ta sẽ tận dụng điều này sau.

3.3 Điều khiển luồng

Boolean thì tốt, nhưng chẳng đi tới đâu nếu ta không điều khiển được luồng chương trình. Hãy nhìn qua một số cấu trúc: if, for, while, và do-while.

Trước hết, một ghi chú chung hướng về phía trước, về câu lệnh và khối câu lệnh, gửi tới bạn bởi lập trình viên C thân thiện ở khu phố của bạn:

Sau một thứ như if hay while, bạn có thể đặt một câu lệnh duy nhất để thực thi, hoặc một khối các câu lệnh thực thi lần lượt theo thứ tự.

Bắt đầu với một câu lệnh đơn:

if (x == 10) printf("x is 10\n");

Cái này cũng đôi khi được viết trên một dòng riêng. (Whitespace trong C phần lớn không có ý nghĩa, không như Python.)

if (x == 10)
    printf("x is 10\n");

Nhưng nếu bạn muốn nhiều thứ xảy ra do điều kiện thì sao? Bạn có thể dùng dấu ngoặc nhọn ngoằn ngoèo để đánh dấu một block hay compound statement (khối hay câu lệnh ghép).

if (x == 10) {
    printf("x is 10\n");
    printf("And also this happens when x is 10\n");
}

Có một phong cách khá phổ biến là luôn luôn dùng ngoặc nhọn ngay cả khi không cần thiết:

if (x == 10) {
    printf("x is 10\n");
}

Một số dev thấy code dễ đọc hơn và tránh được lỗi kiểu như ví dụ sau, nhìn qua thì có vẻ cả hai dòng đều nằm trong khối if, nhưng thực ra không phải:

// BAD ERROR EXAMPLE

if (x == 10)
    printf("This happens if x is 10\n");
    printf("This happens ALWAYS\n");  // Surprise!! Unconditional!

while và for và các cấu trúc lặp khác hoạt động giống như các ví dụ trên. Nếu bạn muốn làm nhiều việc trong vòng lặp hoặc sau if, cứ bọc chúng trong ngoặc nhọn.

Nói cách khác, if sẽ chạy đúng một thứ ngay sau nó. Và “một thứ” đó có thể là một câu lệnh đơn hoặc một khối các câu lệnh.

3.3.1 Câu lệnh if-else

Ta đã dùng if trong nhiều ví dụ rồi, vì có lẽ bạn đã thấy nó trong ngôn ngữ nào đó, nhưng đây là thêm một ví dụ nữa:

int i = 10;

if (i > 10) {
    printf("Yes, i is greater than 10.\n");
    printf("And this will also print if i is greater than 10.\n");
}

if (i <= 10) printf("i is less than or equal to 10.\n");

Trong code ví dụ, thông báo sẽ được in nếu i lớn hơn 10, còn không thì chạy tiếp xuống dòng kế. Để ý các dấu ngoặc nhọn sau câu lệnh if. Nếu điều kiện đúng, hoặc là câu lệnh/biểu thức đầu tiên ngay sau if sẽ chạy, hoặc là khối code trong dấu ngoặc nhọn sau if sẽ chạy. Hành vi khối code (code block) này đúng với mọi câu lệnh.

Dĩ nhiên, vì C cũng vui theo kiểu này, bạn có thể làm gì đó khi điều kiện sai bằng mệnh đề else:

int i = 99;

if (i == 10)
    printf("i is 10!\n");
else {
    printf("i is decidedly not 10.\n");
    printf("Which irritates me a little, frankly.\n");
}

Và bạn thậm chí có thể xâu chuỗi để kiểm tra nhiều điều kiện khác nhau, như này:

int i = 99;

if (i == 10)
    printf("i is 10!\n");

else if (i == 20)
    printf("i is 20!\n");

else if (i == 99) {
    printf("i is 99! My favorite\n");
    printf("I can't tell you how happy I am.\n");
    printf("Really.\n");
}
    
else
    printf("i is some crazy number I've never heard of.\n");

Dù nếu đi hướng đó, nhớ xem câu lệnh switch để có giải pháp có khả năng tốt hơn. Cái gượng là switch chỉ làm việc với so sánh bằng với hằng số. Cascade if-else ở trên có thể so sánh bất đẳng, khoảng, biến, hay bất cứ thứ gì bạn dựng được trong biểu thức điều kiện.

3.3.2 Câu lệnh while

while là cấu trúc lặp bình dân. Làm một việc trong khi biểu thức điều kiện còn đúng.

Làm một cái nào!

// Print the following output:
//
//   i is now 0!
//   i is now 1!
//   [ more of the same between 2 and 7 ]
//   i is now 8!
//   i is now 9!

int i = 0;

while (i < 10) {
    printf("i is now %d!\n", i);
    i++;
}

printf("All done!\n");

Thế là bạn có một vòng lặp cơ bản. C cũng có for có lẽ sẽ gọn hơn cho ví dụ đó.

Một kiểu không hiếm gặp khi dùng while là lặp vô hạn, lặp khi điều kiện luôn đúng:

while (1) {
    printf("1 is always true, so this repeats forever.\n");
}

3.3.3 Câu lệnh do-while

Giờ đã thuần được while, hãy ngó qua ông anh họ gần của nó, do-while.

Về cơ bản hai thằng giống nhau, chỉ khác là nếu điều kiện sai ngay lần đầu, do-while vẫn chạy một lần, còn while không chạy lần nào. Nói cách khác, phép kiểm tra xem có thực thi khối hay không xảy ra ở cuối khối với do-while. Còn với while là ở đầu khối.

Xem ví dụ:

// Using a while statement:

i = 10;

// this is not executed because i is not less than 10:
while(i < 10) {
    printf("while: i is %d\n", i);
    i++;
}

// Using a do-while statement:

i = 10;

// this is executed once, because the loop condition is not checked until
// after the body of the loop runs:

do {
    printf("do-while: i is %d\n", i);
    i++;
} while (i < 10);

printf("All done!\n");

Để ý rằng trong cả hai trường hợp, điều kiện lặp là sai ngay từ đầu. Thế nên với while, vòng lặp thất bại và khối code sau đó không bao giờ chạy. Còn với do-while, điều kiện được kiểm tra sau khi khối code chạy, nên nó luôn chạy ít nhất một lần. Ở đây, nó in thông báo, tăng i, rồi kiểm tra thấy điều kiện sai, và chạy tiếp tới dòng “All done!”.

Bài học rút ra là: nếu bạn muốn vòng lặp chạy ít nhất một lần, bất kể điều kiện lặp thế nào, hãy dùng do-while.

Tất cả ví dụ trên có lẽ đã tốt hơn nếu dùng for. Làm một cái đỡ tiền định hơn: lặp cho đến khi một số ngẫu nhiên nhất định xuất hiện!

#include <stdio.h>   // For printf
#include <stdlib.h>  // For rand

int main(void)
{
    int r;

    do {
        r = rand() % 100; // Get a random number between 0 and 99
        printf("%d\n", r);
    } while (r != 37);    // Repeat until 37 comes up
}

Ghi chú bên lề: bạn có chạy cái đó nhiều lần không? Nếu có, bạn có để ý chính dãy số đó lại xuất hiện. Lại. Và lại? Đó là vì rand() là một bộ sinh số giả ngẫu nhiên, nó cần được seed (gieo mầm) bằng một số khác nhau để sinh dãy khác nhau. Xem hàm srand()⁴² để biết chi tiết.

3.3.4 Câu lệnh for

Chào mừng đến với một trong những vòng lặp phổ biến nhất thế giới! Vòng lặp for!

Đây là vòng lặp tuyệt vời nếu bạn biết trước số lần cần lặp.

Bạn có thể làm việc tương tự chỉ với while, nhưng for giúp code sạch hơn.

Đây là hai đoạn code tương đương, để ý for chỉ là cách biểu diễn gọn hơn:

// Print numbers between 0 and 9, inclusive...

// Using a while statement:

i = 0;
while (i < 10) {
    printf("i is %d\n", i);
    i++;
}

// Do the exact same thing with a for-loop:

for (i = 0; i < 10; i++) {
    printf("i is %d\n", i);
}

Đúng vậy, thưa các bạn, hai đoạn làm chính xác cùng một việc. Nhưng bạn có thể thấy for gọn hơn và dễ nhìn hơn. (Dân JavaScript lúc này sẽ thấy rõ nguồn gốc C của nó.)

Nó được chia thành ba phần, ngăn bởi dấu chấm phẩy. Phần đầu là khởi tạo, phần hai là điều kiện lặp, và phần ba là thứ xảy ra ở cuối khối nếu điều kiện lặp còn đúng. Cả ba phần đều tuỳ chọn.

for (initialize things; loop if this is true; do this after each loop)

Lưu ý rằng vòng lặp sẽ không chạy dù chỉ một lần nếu điều kiện lặp sai ngay từ đầu.

for-loop fun fact!

Bạn có thể dùng toán tử dấu phẩy để làm nhiều việc trong từng vế của for!

for (i = 0, j = 999; i < 10; i++, j--) {
    printf("%d, %d\n", i, j);
}

Một for rỗng sẽ chạy mãi mãi:

for(;;) {  // "forever"
    printf("I will print this again and again and again\n" );
    printf("for all eternity until the heat-death of the universe.\n");

    printf("Or until you hit CTRL-C.\n");
}

3.3.5 Câu lệnh switch

Tuỳ ngôn ngữ bạn đang dùng, có thể bạn quen hoặc chưa quen với switch, hoặc phiên bản C của nó có thể chặt chẽ hơn bạn tưởng. Đây là câu lệnh cho phép bạn thực hiện nhiều hành động khác nhau tuỳ thuộc vào giá trị của một biểu thức số nguyên.

Cơ bản là nó tính biểu thức ra một giá trị số nguyên, rồi nhảy đến case tương ứng với giá trị đó. Thực thi tiếp tục từ điểm ấy. Nếu gặp câu lệnh break, thực thi nhảy ra khỏi switch.

Đây là ví dụ, với một số dê cho trước, ta in ra cảm nhận về số dê đó.

#include <stdio.h>

int main(void)
{
    int goat_count = 2;

    switch (goat_count) {
        case 0:
            printf("You have no goats.\n");
            break;

        case 1:
            printf("You have a singular goat.\n");
            break;

        case 2:
            printf("You have a brace of goats.\n");
            break;

        default:
            printf("You have a bona fide plethora of goats!\n");
            break;
    }
}

Trong ví dụ đó, switch nhảy tới case 2 và chạy từ đó. Khi (nếu) gặp break, nó nhảy ra khỏi switch.

Bạn cũng có thể thấy nhãn default ở dưới cùng. Cái này chạy khi không case nào khớp.

Mọi case, kể cả default, đều tuỳ chọn. Và chúng có thể xuất hiện theo bất kỳ thứ tự nào, nhưng thông thường default, nếu có, được đặt cuối cùng.

Cho nên toàn bộ hoạt động như một cascade if-else:

if (goat_count == 0)
    printf("You have no goats.\n");
else if (goat_count == 1)
    printf("You have a singular goat.\n");
else if (goat_count == 2)
    printf("You have a brace of goats.\n");
else
    printf("You have a bona fide plethora of goats!\n");

Với vài điểm khác biệt chủ chốt:

• switch thường nhảy tới đoạn code đúng nhanh hơn (dù spec không bảo đảm điều đó).
• if-else có thể làm các so sánh quan hệ như < và >=, cộng số dấu phẩy động và các kiểu khác, còn switch thì không.

Còn một thứ khá thú vị về switch đôi khi bạn sẽ thấy: fall through (rơi xuyên qua).

Nhớ break làm ta nhảy ra khỏi switch chứ?

Thế, chuyện gì xảy ra nếu ta không break?

Hoá ra ta cứ tiếp tục chạy xuống case kế tiếp! Demo!

switch (x) {
    case 1:
        printf("1\n");
        // Fall through!
    case 2:
        printf("2\n");
        break;
    case 3:
        printf("3\n");
        break;
}

Nếu x == 1, switch này trước hết trúng case 1, nó in 1, nhưng rồi cứ chạy tiếp xuống dòng code kế… in ra 2!

Rồi, cuối cùng, ta gặp break nên nhảy ra khỏi switch.

nếu x == 2, thì ta chỉ trúng case 2, in 2, và break như thường.

Không có break được gọi là fall through.

ProTip: LUÔN LUÔN đặt comment trong code chỗ bạn chủ ý fall through, như tôi đã làm phía trên. Nó sẽ cứu lập trình viên khác khỏi thắc mắc bạn có cố ý làm thế không.

Thực tế, đây là một trong những chỗ phổ biến phát sinh bug trong chương trình C: quên đặt break trong case. Bạn phải đặt nó nếu không muốn rơi tiếp xuống case kế⁴³.

Ở trên tôi đã nói switch làm việc với kiểu số nguyên, cứ giữ như thế. Đừng dùng số dấu phẩy động hay kiểu chuỗi trong đó. Một kẽ hở ở đây là bạn có thể dùng kiểu ký tự vì ký tự bí mật là số nguyên. Nên đoạn này hoàn toàn chấp nhận được:

char c = 'b';

switch (c) {
    case 'a':
        printf("It's 'a'!\n");
        break;

    case 'b':
        printf("It's 'b'!\n");
        break;

    case 'c':
        printf("It's 'c'!\n");
        break;
}

Cuối cùng, bạn có thể dùng enum trong switch vì chúng cũng là kiểu số nguyên. Nhưng để sau, ở chương enum.

4 Hàm

“Sir, not in an environment such as this. That’s why I’ve also been programmed for over thirty secondary functions that—”

—C3PO, before being rudely interrupted, reporting a now-unimpressive number of additional functions, Star Wars script

Rất giống với các ngôn ngữ khác bạn đã quen, C có khái niệm function (hàm).

Hàm có thể nhận nhiều loại argument (đối số) và trả về một giá trị. Có một điều quan trọng: kiểu của đối số và giá trị trả về phải được khai báo trước, vì C thích thế!

Hãy nhìn một hàm. Đây là hàm nhận một int làm đối số, và trả về một int.

#include <stdio.h>

int plus_one(int n)  // The "definition"
{
    return n + 1;
}
 

Chữ int trước plus_one chỉ kiểu trả về.

int n chỉ rằng hàm nhận một đối số int, được lưu trong parameter (tham số) n. Parameter là một loại biến cục bộ đặc biệt mà đối số được sao chép vào.

Tôi sẽ nhấn mạnh rằng đối số được sao chép vào parameter. Nhiều thứ trong C dễ hiểu hơn nếu bạn biết parameter là một bản sao của đối số, chứ không phải bản thân đối số. Nói thêm sau một chút.

Đi tiếp xuống main(), ta có thể thấy lời gọi hàm, nơi ta gán giá trị trả về vào biến cục bộ j:

int main(void)
{
    int i = 10, j;
    
    j = plus_one(i);  // The "call"

    printf("i + 1 is %d\n", j);
}

Trước khi quên, để ý rằng tôi đã định nghĩa hàm trước khi dùng nó. Nếu không làm vậy, trình biên dịch sẽ chưa biết gì về hàm khi biên dịch main() và sẽ văng lỗi gọi hàm không xác định. Có cách chuẩn chỉnh hơn để viết đoạn code trên bằng function prototype (nguyên mẫu hàm), nhưng sẽ nói sau.

Để ý luôn rằng main() cũng là một hàm!

Nó trả về int.

Nhưng cái void này là gì? Đây là một keyword dùng để nói rằng hàm không nhận đối số nào.

Bạn cũng có thể trả về void để nói rằng bạn không trả về giá trị nào:

#include <stdio.h>

// This function takes no arguments and returns no value:

void hello(void)
{
    printf("Hello, world!\n");
}

int main(void)
{
    hello();  // Prints "Hello, world!"
}

4.1 Truyền theo giá trị

Tôi đã nói trước đó rằng khi bạn truyền một đối số cho hàm, một bản sao của đối số đó được tạo ra và lưu vào parameter tương ứng.

Nếu đối số là một biến, một bản sao của giá trị biến đó được tạo ra và lưu vào parameter.

Tổng quát hơn, toàn bộ biểu thức đối số được tính ra giá trị. Giá trị đó được sao chép vào parameter.

Trong mọi trường hợp, giá trị trong parameter là của riêng nó. Nó độc lập với bất kỳ giá trị hay biến nào bạn dùng làm đối số khi gọi hàm.

Hãy xem một ví dụ. Nghiên cứu và thử đoán output trước khi chạy:

#include <stdio.h>

void increment(int a)
{
    a++;
}

int main(void)
{
    int i = 10;

    increment(i);

    printf("i == %d\n", i);  // What does this print?
}

Thoạt nhìn, có vẻ i là 10, và ta truyền nó vào hàm increment(). Ở đó giá trị được tăng, nên khi in ra phải là 11 đúng không?

“Get used to disappointment.”

—Dread Pirate Roberts, The Princess Bride

Nhưng không phải 11, nó in ra 10! Sao thế?

Mọi chuyện nằm ở việc biểu thức bạn truyền vào hàm được sao chép vào parameter tương ứng. Parameter là bản sao, không phải bản gốc.

Vậy i là 10 ngoài main(). Và ta truyền nó vào increment(). Parameter tương ứng có tên là a trong hàm đó.

Và phép sao chép xảy ra, như thể là một phép gán. Đại khái, a = i. Nên tại thời điểm đó, a là 10. Và ngoài main(), i cũng là 10.

Rồi ta tăng a lên 11. Nhưng ta không chạm vào i chút nào! Nó vẫn là 10.

Cuối cùng, hàm kết thúc. Tất cả biến cục bộ bị bỏ đi (chào nhé, a!) và ta quay lại main(), nơi i vẫn là 10.

Rồi ta in ra, được 10, và xong.

Đây là lý do trong ví dụ trước với hàm plus_one(), ta đã return giá trị đã bị sửa cục bộ để có thể thấy nó lại trong main().

Nghe hạn chế nhỉ? Kiểu như bạn chỉ lấy về được một mẩu dữ liệu từ hàm, bạn đang nghĩ vậy đấy. Tuy nhiên, còn một cách khác để lấy dữ liệu về; dân C gọi cách đó là passing by reference (truyền theo tham chiếu) và đó là câu chuyện để dành dịp khác.

Nhưng đừng để cái tên hoa lá cành đó đánh lừa bạn khỏi sự thật rằng MỌI THỨ bạn truyền vào hàm, KHÔNG NGOẠI LỆ, đều được sao chép vào parameter tương ứng, và hàm thao tác trên bản sao cục bộ đó, BẤT KỂ THẾ NÀO. Nhớ lấy, ngay cả khi ta đang nói về cái gọi là truyền theo tham chiếu.

4.2 Function Prototype

Nếu bạn còn nhớ từ thời kỳ băng hà vài mục trước, tôi có nói rằng bạn phải định nghĩa hàm trước khi dùng nó, không thì trình biên dịch sẽ chưa biết gì về hàm, và sẽ văng lỗi.

Điều này không hoàn toàn nghiêm ngặt đúng. Bạn có thể báo trước cho trình biên dịch rằng bạn sẽ dùng một hàm có kiểu nhất định với danh sách parameter nhất định. Như thế, hàm có thể được định nghĩa ở đâu cũng được (kể cả ở file khác), miễn là function prototype đã được khai báo trước khi bạn gọi hàm đó.

May thay, function prototype thực ra khá dễ. Nó chỉ là bản sao của dòng đầu tiên trong định nghĩa hàm, kèm thêm dấu chấm phẩy ở cuối cho chắc ăn. Ví dụ, đoạn code này gọi một hàm được định nghĩa ở phía sau, vì prototype đã được khai báo trước:

#include <stdio.h>

int foo(void);  // This is the prototype!

int main(void)
{
    int i;
    
    // We can call foo() here before it's definition because the
    // prototype has already been declared, above!

    i = foo();
    
    printf("%d\n", i);  // 3490
}

int foo(void)  // This is the definition, just like the prototype!
{
    return 3490;
}

Nếu bạn không khai báo hàm trước khi dùng (bằng prototype hoặc bằng định nghĩa), bạn đang làm một thứ gọi là implicit declaration (khai báo ngầm). Chuyện này được cho phép trong chuẩn C đầu tiên (C89), và chuẩn đó có quy định cho nó, nhưng ngày nay không còn được phép nữa. Và không có lý do chính đáng nào để trông cậy vào nó trong code mới.

Bạn có thể để ý một điều về các đoạn code mẫu ta đã dùng… Đó là ta đã dùng hàm printf() cũ kỹ mà tốt lành mà không định nghĩa cũng không khai báo prototype! Làm sao ta thoát được sự vô luật pháp này? Thật ra ta không thoát đâu. Có prototype; nó nằm trong file header stdio.h mà ta đã kèm vào bằng #include, nhớ không? Nên ta vẫn hợp pháp đó, thưa ông cảnh sát!

4.3 Danh sách parameter rỗng

Bạn có thể thấy cái này đây đó trong code cũ, nhưng không bao giờ nên viết nó trong code mới. Luôn dùng void để chỉ rằng hàm không nhận parameter nào. Không bao giờ⁴⁴ có lý do để bỏ qua chuyện này trong code hiện đại.

Nếu bạn giỏi nhớ việc bỏ void vào cho danh sách parameter rỗng trong hàm và prototype, bạn có thể bỏ qua phần còn lại của mục này.

Có hai bối cảnh cho chuyện này:

• Bỏ hết parameter khi định nghĩa hàm
• Bỏ hết parameter trong prototype

Trước tiên xem định nghĩa hàm tiềm tàng:

void foo()  // Should really have a `void` in there
{
    printf("Hello, world!\n");
}

Dù spec có nói hành vi trong trường hợp này như thể bạn đã ghi void (C11 §6.7.6.3¶14), kiểu void ở đó có lý do. Hãy dùng nó.

Nhưng trong trường hợp function prototype, có một khác biệt đáng kể giữa dùng void và không:

void foo();
void foo(void);  // Not the same!

Bỏ void khỏi prototype báo cho trình biên dịch rằng không có thông tin thêm về các parameter của hàm. Nó hiệu quả tắt hết mọi kiểm tra kiểu.

Với prototype, chắc chắn dùng void khi bạn có danh sách parameter rỗng.

5 Con trỏ, khép nép mà run!

“How do you get to Carnegie Hall?”
“Practice!”

—20th-century joke of unknown origin

Pointer (con trỏ) là một trong những thứ bị sợ nhất trong ngôn ngữ C. Thật ra, đó chính là thứ khiến ngôn ngữ này có chút thử thách. Nhưng vì sao?

Vì nó, nói thật, có thể tạo ra dòng điện chạy ngược từ bàn phím lên rồi hàn tay bạn dính vĩnh viễn tại chỗ, đày bạn cả đời trước bàn phím với ngôn ngữ từ những năm 70!

Thật à? Ừ, không thật đâu. Tôi chỉ đang dựng sẵn bối cảnh để bạn thành công.

Tuỳ ngôn ngữ bạn đến từ đâu, có thể bạn đã hiểu khái niệm reference (tham chiếu), nơi một biến tham chiếu tới một đối tượng nào đó.

Chuyện trong C cũng rất giống, chỉ là ta phải nói rõ ràng với C hơn về việc đang nói tới tham chiếu hay nói tới thứ được tham chiếu.

5.1 Bộ nhớ và biến

Bộ nhớ máy tính chứa đủ loại dữ liệu, đúng không? Nó chứa float, int, và đủ thứ khác. Để bộ nhớ dễ xử lý, mỗi byte trong bộ nhớ được gán một số nguyên để nhận dạng. Các số này tăng dần khi bạn đi lên trong bộ nhớ⁴⁵. Bạn có thể hình dung như một đống hộp được đánh số, mỗi hộp chứa một byte⁴⁶ dữ liệu. Hoặc như một mảng lớn mà mỗi phần tử chứa một byte, nếu bạn đến từ ngôn ngữ có mảng. Con số đại diện cho mỗi hộp được gọi là address (địa chỉ).

Và không phải kiểu dữ liệu nào cũng chỉ dùng một byte. Ví dụ, int thường bốn byte, float cũng vậy, nhưng thật ra tuỳ hệ thống. Bạn có thể dùng toán tử sizeof để xem một kiểu dùng bao nhiêu byte bộ nhớ.

// %zu is the format specifier for type size_t

printf("an int uses %zu bytes of memory\n", sizeof(int));

// That prints "4" for me, but can vary by system.

Sự thật vui về bộ nhớ: Khi bạn có một kiểu dữ liệu (như int điển hình) dùng nhiều hơn một byte, các byte tạo nên dữ liệu luôn nằm liền kề nhau trong bộ nhớ. Đôi khi chúng theo thứ tự bạn nghĩ, đôi khi không⁴⁷. Dù C không bảo đảm thứ tự bộ nhớ cụ thể (tuỳ nền tảng), vẫn hoàn toàn có thể viết code theo hướng không phụ thuộc nền tảng, nơi bạn thậm chí không phải nghĩ tới cái trật tự byte phiền phức đó.

Vậy dù sao thì, nếu ta có thể đi tiếp và làm một hồi trống cùng chút nhạc dồn dập cho định nghĩa của con trỏ, con trỏ là một biến chứa địa chỉ. Hãy tưởng tượng bản nhạc kinh điển của 2001: A Space Odyssey ngay lúc này. Ba bum ba bum ba bum BAAAAH!

Được rồi, có lẽ hơi lên gân nhỉ? Con trỏ không có nhiều bí hiểm lắm đâu. Nó là địa chỉ của dữ liệu. Cũng như biến int có thể chứa giá trị 12, biến con trỏ có thể chứa địa chỉ của dữ liệu.

Nghĩa là các thứ sau đây cùng mang một nghĩa, tức là một con số biểu diễn một điểm trong bộ nhớ:

• Chỉ số vào bộ nhớ (nếu bạn nghĩ bộ nhớ như một mảng lớn)
• Địa chỉ (Address)
• Vị trí (Location)

Tôi sẽ dùng lẫn lộn. Và đúng, tôi đã quăng location vào đó, vì không bao giờ là đủ từ đồng nghĩa cả.

Và biến con trỏ giữ con số địa chỉ đó. Cũng như biến float có thể chứa 3.14159.

Hãy tưởng tượng bạn có một xấp giấy nhớ Post-it® được đánh số thứ tự theo địa chỉ. (Cái đầu tiên ở chỉ số 0, cái kế ở chỉ số 1, và cứ thế.)

Ngoài con số biểu diễn vị trí, bạn cũng có thể viết lên mỗi tờ một số khác tuỳ thích. Có thể là số chó bạn có. Hoặc số mặt trăng quanh sao Hoả…

…Hoặc, đó có thể là chỉ số của một tờ Post-it khác!

Nếu bạn đã viết số chó bạn có, đó chỉ là một biến bình thường. Nhưng nếu bạn viết chỉ số của một tờ Post-it khác, đó là một con trỏ. Nó trỏ tới tờ giấy kia!

Một phép tương tự khác có thể là với địa chỉ nhà. Bạn có thể có một căn nhà với những đặc tính nhất định, sân vườn, mái kim loại, tấm pin mặt trời, v.v. Hoặc bạn có thể có địa chỉ của căn nhà đó. Địa chỉ không phải là căn nhà. Một bên là nguyên căn nhà, bên kia chỉ là vài dòng chữ. Nhưng địa chỉ của căn nhà là một con trỏ tới căn nhà đó. Nó không phải căn nhà, nhưng nó nói cho bạn biết tìm căn nhà ở đâu.

Và ta có thể làm điều tương tự trong máy tính với dữ liệu. Bạn có thể có một biến dữ liệu chứa giá trị nào đó. Và giá trị đó nằm trong bộ nhớ ở một địa chỉ nào đó. Và bạn có thể có một biến con trỏ khác chứa địa chỉ của biến dữ liệu đó.

Nó không phải chính biến dữ liệu, nhưng, giống như địa chỉ nhà, nó nói cho ta biết tìm biến đó ở đâu.

Khi có được điều đó, ta nói ta có một “con trỏ tới” mẩu dữ liệu đó. Và ta có thể đi theo con trỏ để truy cập đến bản thân dữ liệu.

(Tuy đến giờ trông chưa có vẻ đặc biệt hữu ích, tất cả sẽ trở nên không thể thiếu khi dùng với lời gọi hàm. Chịu khó với tôi đến khi tới chỗ đó.)

Giờ nếu ta có một int, và ta muốn một con trỏ tới nó, thứ ta muốn là cách nào đó để lấy địa chỉ của int đó, đúng không? Xét cho cùng, con trỏ chỉ giữ địa chỉ của dữ liệu. Bạn đoán xem ta dùng toán tử nào để tìm địa chỉ của int?

Ồ, với một bất ngờ kinh hoàng mà chắc hẳn gây sốc tới bạn, người đọc dịu dàng, ta dùng toán tử address-of (hoá ra là dấu và: “&”) để tìm địa chỉ của dữ liệu. Ampersand (dấu và).

Ví dụ nhanh, ta sẽ giới thiệu một format specifier mới cho printf() để bạn có thể in một con trỏ. Bạn đã biết %d in số nguyên thập phân đúng không? Thì %p in một con trỏ. Giờ, con trỏ này sẽ trông như một con số rác (và có thể được in ở dạng hexadecimal⁴⁸ thay vì thập phân), nhưng nó chỉ là chỉ số vào bộ nhớ nơi dữ liệu được lưu. (Hoặc chỉ số vào bộ nhớ nơi byte đầu tiên của dữ liệu được lưu, nếu dữ liệu gồm nhiều byte.) Trong hầu như mọi tình huống, kể cả trường hợp này, giá trị thực tế của con số được in là không quan trọng với bạn, và tôi đưa ra đây chỉ để minh hoạ toán tử address-of.

#include <stdio.h>

int main(void)
{
    int i = 10;

    printf("The value of i is %d\n", i);
    printf("And its address is %p\n", (void *)&i);
}

Đoạn code trên có một cast (ép kiểu) nơi ta cưỡng ép kiểu của biểu thức &i thành kiểu void*. Đây là để ngăn trình biên dịch văng ra cảnh báo. Tất cả thứ này đều là chuyện ta chưa nói tới, nên cứ kệ (void*) trong đoạn code trên và giả vờ nó không có ở đó.

Trên máy tính của tôi, đoạn này in ra:

The value of i is 10
And its address is 0x7ffddf7072a4

Nếu bạn tò mò, con số hexadecimal đó là 140.727.326.896.068 trong thập phân (cơ số 10 y như bà của bạn từng dùng). Đó là chỉ số vào bộ nhớ nơi dữ liệu của biến i được lưu. Đó là địa chỉ của i. Đó là vị trí của i. Đó là con trỏ tới i.

Khoan, bạn có 140 terabyte RAM à? Có! Bạn không có à? Nhưng tôi đang bốc phét thôi; dĩ nhiên tôi không có (khoảng 2024). Máy tính hiện đại dùng một công nghệ kỳ diệu gọi là virtual memory⁴⁹ (bộ nhớ ảo) khiến các process nghĩ rằng nó có toàn bộ không gian bộ nhớ của máy tính cho riêng nó, bất kể bao nhiêu RAM vật lý thực sự hậu thuẫn. Nên dù địa chỉ là con số khổng lồ đó, nó được hệ thống bộ nhớ ảo của CPU ánh xạ về một địa chỉ bộ nhớ vật lý thấp hơn. Máy tính cụ thể này có 16 GB RAM (lại nữa, khoảng 2024, nhưng tôi đang chạy Linux, nên vậy là dư dả). Terabyte RAM à? Tôi là giáo viên, không phải tỷ phú dot-com. Chẳng có gì trong mấy chuyện này mà ai trong chúng ta cần lo cả, trừ phần tôi không phải giàu đến khủng khiếp.

Nó là con trỏ vì nó cho bạn biết i ở đâu trong bộ nhớ. Như địa chỉ nhà viết trên mẩu giấy cho bạn biết có thể tìm căn nhà nào đó ở đâu, con số này chỉ cho ta biết chỗ nào trong bộ nhớ ta có thể tìm thấy giá trị của i. Nó trỏ tới i.

Lại nữa, thường thì ta không thực sự quan tâm con số địa chỉ chính xác là gì. Ta chỉ quan tâm nó là con trỏ tới i.

5.2 Kiểu con trỏ

Được rồi… tất cả thế này ổn thôi. Giờ bạn có thể thành công lấy địa chỉ của biến và in ra màn hình. Có một chút gì đó cho bản CV đấy nhỉ? Đây là lúc bạn tóm cổ tôi và lịch sự hỏi con trỏ rốt cuộc có ích cái quái gì.

Câu hỏi tuyệt vời, và ta sẽ đến đó ngay sau các thông điệp từ nhà tài trợ.

ACME ROBOTIC HOUSING UNIT CLEANING SERVICES. YOUR HOMESTEAD WILL BE
DRAMATICALLY IMPROVED OR YOU WILL BE TERMINATED. MESSAGE ENDS.

Chào mừng trở lại với một kỳ nữa của Beej’s Guide. Lần gặp trước ta đang nói về cách tận dụng con trỏ. Tốt, thứ ta sẽ làm là lưu một con trỏ vào biến để có thể dùng sau. Bạn có thể nhận ra kiểu con trỏ vì có dấu sao (*) đứng trước tên biến và sau kiểu của nó:

int main(void)
{
    int i;  // i's type is "int"
    int *p; // p's type is "pointer to an int", or "int-pointer"
}

Này, vậy ta có một biến kiểu con trỏ, và nó có thể trỏ tới các int khác. Tức là, nó có thể chứa địa chỉ của các int khác. Ta biết nó trỏ tới int, vì kiểu của nó là int* (đọc là “int-pointer”).

Khi bạn gán vào một biến con trỏ, kiểu của vế phải phép gán phải trùng với kiểu biến con trỏ. May thay, khi bạn lấy address-of một biến, kiểu kết quả là con trỏ tới kiểu biến đó, nên các phép gán kiểu sau đây là hoàn hảo:

int i;
int *p;  // p is a pointer, but is uninitialized and points to garbage

p = &i;  // p is assigned the address of i--p now "points to" i

Bên trái phép gán, ta có một biến kiểu pointer-to-int (int*), và bên phải là biểu thức kiểu pointer-to-int vì i là int (bởi address-of một int cho bạn một con trỏ tới int). Địa chỉ của một thứ có thể được lưu trong một con trỏ tới thứ đó.

Hiểu chứ? Tôi biết vẫn chưa hợp lý lắm vì bạn chưa thấy công dụng thực tế của biến con trỏ, nhưng ta đang đi từng bước nhỏ để không ai lạc. Giờ ta sẽ giới thiệu toán tử nghịch-address-of. Nó hơi giống address-of trong Thế giới Bizarro vậy.

5.3 Dereference

Biến con trỏ có thể được xem là refer (nhắc tới) một biến khác bằng cách trỏ tới nó. Hiếm khi bạn nghe dân C nói về “refer” hay “references” đâu, nhưng tôi nhắc tới để cái tên của toán tử này có chút ý nghĩa hơn.

Khi bạn có con trỏ tới một biến (đại khái “một reference tới một biến”), bạn có thể dùng biến gốc thông qua con trỏ bằng cách dereference con trỏ. (Có thể nghĩ như “de-pointering” con trỏ, nhưng không ai từng nói “de-pointering” cả.)

Trở lại phép so sánh, việc này hơi giống nhìn địa chỉ nhà rồi đi đến căn nhà đó.

Giờ, “truy cập đến biến gốc” nghĩa là gì? Nếu bạn có biến tên i, và có con trỏ tới i tên p, bạn có thể dùng con trỏ p đã được dereference y hệt như chính biến i gốc!

Bạn gần như có đủ kiến thức để xem ví dụ. Mẩu cuối cùng bạn cần biết thật ra là: toán tử dereference là gì? Nó thật ra được gọi là indirection operator (toán tử gián tiếp), vì bạn đang truy cập giá trị gián tiếp qua con trỏ. Và nó là dấu sao, lần nữa: *. Giờ, đừng nhầm lẫn nó với dấu sao bạn đã dùng lúc khai báo con trỏ, ở trước. Cùng là một ký tự, nhưng có nghĩa khác nhau ở các bối cảnh khác nhau⁵⁰.

Đây là một ví dụ đầy đủ:

#include <stdio.h>

int main(void)
{
    int i;
    int *p;  // this is NOT a dereference--this is a type "int*"

    p = &i;  // p now points to i, p holds address of i

    i = 10;  // i is now 10
    *p = 20; // the thing p points to (namely i!) is now 20!!

    printf("i is %d\n", i);   // prints "20"
    printf("i is %d\n", *p);  // "20"! dereference-p is the same as i!
}

Nhớ rằng p giữ địa chỉ của i, như bạn thấy ở chỗ ta gán cho p ở dòng 8. Cái toán tử indirection làm là bảo máy tính dùng đối tượng mà con trỏ trỏ tới thay vì dùng chính con trỏ. Bằng cách này, ta đã biến *p thành một dạng bí danh cho i.

Tuyệt, nhưng sao chứ? Làm tất cả thứ này để làm gì?

5.4 Truyền con trỏ làm đối số

Đến giờ, bạn đang nghĩ là mình có khá nhiều kiến thức về con trỏ nhưng không một chút ứng dụng, đúng chứ? Kiểu, *p có ích gì nếu bạn cứ việc viết i?

Bạn của tôi ơi, sức mạnh thực sự của con trỏ xuất hiện khi bạn bắt đầu truyền chúng cho hàm. Sao lại quan trọng? Bạn có thể nhớ từ trước rằng có thể truyền đủ loại đối số cho hàm, chúng sẽ được ngoan ngoãn sao chép vào parameter, và rồi bạn có thể thao tác các bản sao cục bộ của biến bên trong hàm, và rồi có thể trả về một giá trị duy nhất.

Lỡ bạn muốn đem về nhiều hơn một mẩu dữ liệu từ hàm thì sao? Ý là bạn chỉ có thể trả về một thứ duy nhất, đúng không? Lỡ tôi trả lời câu hỏi đó bằng một câu hỏi khác? …Ờ, hai câu hỏi?

Chuyện gì xảy ra khi bạn truyền một con trỏ làm đối số cho hàm? Một bản sao của con trỏ có được đặt vào parameter tương ứng không? Tất nhiên có luôn. Nhớ hồi trước tôi huyên thuyên về chuyện MỌI ĐỐI SỐ được sao chép vào parameter và hàm dùng một bản sao của đối số không? Cũng như vậy ở đây. Hàm sẽ nhận một bản sao của con trỏ.

Nhưng, và đây là phần thông minh: ta đã dựng sẵn con trỏ để trỏ tới một biến… và rồi hàm có thể dereference bản sao con trỏ của nó để quay lại biến gốc! Hàm không thấy được chính biến đó, nhưng chắc chắn nó có thể dereference một con trỏ tới biến đó!

Việc này tương tự như viết một địa chỉ nhà lên mảnh giấy, rồi chép nó sang một mảnh giấy khác. Giờ bạn có hai con trỏ tới căn nhà đó, và cả hai đều dẫn tốt như nhau tới chính căn nhà.

Trong trường hợp lời gọi hàm, một trong các bản sao được lưu trong một biến con trỏ ở scope gọi hàm, bản kia được lưu trong một biến con trỏ là parameter của hàm.

Ví dụ nào! Hãy quay lại hàm increment() cũ của ta, nhưng lần này làm sao cho nó thực sự tăng giá trị ở phía người gọi.

#include <stdio.h>

void increment(int *p)  // note that it accepts a pointer to an int
{
    *p = *p + 1;        // add one to the thing p points to
}

int main(void)
{
    int i = 10;
    int *j = &i;  // note the address-of; turns it into a pointer to i

    printf("i is %d\n", i);        // prints "10"
    printf("i is also %d\n", *j);  // prints "10"

    increment(j);                  // j is an int*--to i

    printf("i is %d\n", i);        // prints "11"!
}

Được rồi! Có vài thứ cần để ý ở đây… không kém phần quan trọng là hàm increment() nhận int* làm đối số. Ta truyền cho nó một int* trong lời gọi bằng cách đổi biến int i thành int* qua toán tử address-of. (Nhớ nhé, con trỏ giữ địa chỉ, nên ta tạo con trỏ tới biến bằng cách cho chúng chạy qua toán tử address-of.)

Hàm increment() nhận một bản sao của con trỏ. Cả con trỏ gốc j (trong main()) lẫn bản sao của nó p (parameter trong increment()) đều trỏ tới cùng một địa chỉ, cụ thể là địa chỉ chứa giá trị i. (Lại nữa, theo phép so sánh, như hai mảnh giấy cùng ghi một địa chỉ nhà.) Dereference bất kỳ cái nào cũng cho phép bạn sửa biến gốc i! Hàm có thể sửa một biến ở scope khác! Tuyệt vời!

Ví dụ trên thường được viết gọn hơn trong lời gọi bằng cách dùng address-of ngay trong danh sách đối số:

printf("i is %d\n", i);  // prints "10"
increment(&i);
printf("i is %d\n", i);  // prints "11"!

Quy tắc chung, nếu bạn muốn hàm sửa thứ bạn đang truyền vào sao cho bạn thấy kết quả, bạn sẽ phải truyền một con trỏ tới thứ đó.

5.5 Con trỏ NULL

Bất kỳ biến con trỏ kiểu nào cũng có thể được gán một giá trị đặc biệt là NULL. Điều này cho biết con trỏ không trỏ tới thứ gì.

int *p;

p = NULL;

Vì nó không trỏ tới giá trị nào, dereference nó là hành vi không xác định, và có lẽ sẽ dẫn đến crash:

int *p = NULL;

*p = 12;  // CRASH or SOMETHING PROBABLY BAD. BEST AVOIDED.

Dù bị gọi là lỗi lầm tỷ đô, bởi chính người tạo ra nó⁵¹, con trỏ NULL là một sentinel value⁵² tốt và là chỉ dấu chung cho thấy một con trỏ chưa được khởi tạo.

(Dĩ nhiên, cũng giống các biến khác, con trỏ trỏ tới rác trừ khi bạn gán rõ ràng cho nó trỏ tới một địa chỉ hoặc NULL.)

5.6 Một ghi chú về khai báo con trỏ

Cú pháp khai báo con trỏ có thể hơi kỳ quặc. Hãy xem ví dụ này:

int a;
int b;

Ta có thể gộp thành một dòng chứ?

int a, b;  // Same thing

Nên a và b đều là int. Không vấn đề.

Nhưng còn cái này?

int a;
int *p;

Có gộp được thành một dòng không? Được. Nhưng * đặt ở đâu?

Quy tắc là * đứng trước bất kỳ biến nào là kiểu con trỏ. Tức là, * không phải là một phần của int trong ví dụ này, nó là một phần của biến p.

Với điều đó trong đầu, ta có thể viết:

int a, *p;  // Same thing

Quan trọng cần lưu ý rằng dòng sau đây không khai báo hai con trỏ:

int *p, q;  // p is a pointer to an int; q is just an int.

Trông càng gian trá hơn nếu lập trình viên viết dòng (hợp lệ) sau, có chức năng giống hệt dòng trên.

int* p, q;  // p is a pointer to an int; q is just an int.

Giờ xem cái này và xác định biến nào là con trỏ, biến nào không:

int *a, b, c, *d, e, *f, g, h, *i;

Tôi sẽ để đáp án ở footnote⁵³.

5.7 sizeof và con trỏ

Chỉ một chút cú pháp ở đây có thể gây bối rối, đôi khi bạn sẽ gặp.

Nhớ rằng sizeof hoạt động trên kiểu của biểu thức.

int *p;

// Prints size of an 'int'
printf("%zu\n", sizeof(int));

// p is type 'int *', so prints size of 'int*'
printf("%zu\n", sizeof p);

// *p is type 'int', so prints size of 'int'
printf("%zu\n", sizeof *p);

Bạn có thể gặp code ngoài đời với sizeof cuối cùng đó. Chỉ cần nhớ sizeof nói về kiểu của biểu thức, chứ không phải về bản thân các biến trong biểu thức.

6 Mảng

“Should array indices start at 0 or 1? My compromise of 0.5 was rejected without, I thought, proper consideration.”

—Stan Kelly-Bootle, computer scientist

May thay, C có mảng. Ý tôi là, tôi biết nó được xem là ngôn ngữ cấp thấp⁵⁴ nhưng ít nhất nó có khái niệm mảng được tích hợp sẵn. Và vì khá nhiều ngôn ngữ lấy cảm hứng cú pháp từ C, có lẽ bạn đã quen với việc dùng [ và ] để khai báo và dùng mảng.

Nhưng C chỉ vừa đủ có mảng thôi! Như ta sẽ thấy sau, mảng chỉ là đường cú pháp (syntactic sugar) trong C, sâu thẳm bên trong chúng là con trỏ và đủ thứ. Hoảng lên đi! Nhưng bây giờ, cứ dùng chúng như mảng đã. Phù.

6.1 Ví dụ dễ

Xắn tay làm ví dụ luôn:

#include <stdio.h>

int main(void)
{
    int i;
    float f[4];  // Declare an array of 4 floats

    f[0] = 3.14159;  // Indexing starts at 0, of course.
    f[1] = 1.41421;
    f[2] = 1.61803;
    f[3] = 2.71828;

    // Print them all out:

    for (i = 0; i < 4; i++) {
        printf("%f\n", f[i]);
    }
}

Khi khai báo một mảng, bạn phải cho nó kích thước. Và kích thước phải cố định⁵⁵.

Trong ví dụ trên, ta tạo một mảng 4 float. Giá trị trong dấu ngoặc vuông ở khai báo cho ta biết điều đó.

Ở các dòng sau, ta truy cập các giá trị trong mảng, gán hoặc đọc, lại bằng dấu ngoặc vuông.

Hy vọng cái này quen thuộc từ các ngôn ngữ bạn đã biết!

6.2 Lấy chiều dài của mảng

Bạn không thể… ở mức độ nào đó. C không ghi lại thông tin này⁵⁶. Bạn phải quản lý riêng trong một biến khác.

Khi tôi nói “không thể”, thật ra có một số hoàn cảnh bạn có thể. Có một mẹo để lấy số phần tử của mảng trong scope mà mảng được khai báo. Nhưng, nói chung, nó sẽ không hoạt động như bạn mong muốn nếu bạn truyền mảng cho hàm⁵⁷.

Xem cái mẹo này. Ý tưởng cơ bản là bạn lấy sizeof mảng, rồi chia cho kích thước của mỗi phần tử để ra chiều dài. Ví dụ, nếu một int là 4 byte, và mảng dài 32 byte, vậy chắc chắn có chỗ cho \(\frac{32}{4}\) hay \(8\) int trong đó.

int x[12];  // 12 ints

printf("%zu\n", sizeof x);     // 48 total bytes
printf("%zu\n", sizeof(int));  // 4 bytes per int

printf("%zu\n", sizeof x / sizeof(int));  // 48/4 = 12 ints!

Nếu là mảng char, thì sizeof mảng chính là số phần tử, vì sizeof(char) được định nghĩa là 1. Với bất cứ thứ gì khác, bạn phải chia cho kích thước của mỗi phần tử.

Nhưng mẹo này chỉ hoạt động trong scope mà mảng được định nghĩa. Nếu bạn truyền mảng cho hàm, nó không hoạt động. Ngay cả khi bạn làm cho nó “to” trong signature của hàm:

void foo(int x[12])
{
    printf("%zu\n", sizeof x);     // 8?! What happened to 48?
    printf("%zu\n", sizeof(int));  // 4 bytes per int

    printf("%zu\n", sizeof x / sizeof(int));  // 8/4 = 2 ints?? WRONG.
}

Đó là vì khi bạn “truyền” mảng cho hàm, bạn chỉ truyền một con trỏ tới phần tử đầu tiên, và đó là thứ sizeof đo. Sẽ nói thêm ở mục Passing Single Dimensional Arrays to Functions phía dưới.

Một thứ nữa bạn có thể làm với sizeof và mảng là lấy kích thước của một mảng có số phần tử cố định mà không cần khai báo mảng. Giống như cách bạn lấy kích thước của int bằng sizeof(int).

Ví dụ, để xem cần bao nhiêu byte cho một mảng 48 double, bạn có thể làm:

sizeof(double [48]);

6.3 Khởi tạo mảng

Bạn có thể khởi tạo mảng bằng hằng số từ trước:

#include <stdio.h>

int main(void)
{
    int i;
    int a[5] = {22, 37, 3490, 18, 95};  // Initialize with these values

    for (i = 0; i < 5; i++) {
        printf("%d\n", a[i]);
    }
}

Đừng bao giờ để nhiều phần tử trong initializer hơn mức mảng chứa được, không thì trình biên dịch sẽ khó chịu:

foo.c: In function ‘main’:
foo.c:6:39: warning: excess elements in array initializer
    6 |     int a[5] = {22, 37, 3490, 18, 95, 999};
      |                                       ^~~
foo.c:6:39: note: (near initialization for ‘a’)

Nhưng (vui đây!) bạn có thể để ít phần tử trong initializer hơn mức mảng có. Các phần tử còn lại trong mảng sẽ được tự động khởi tạo bằng zero. Điều này đúng với tất cả các dạng khởi tạo mảng: nếu bạn có initializer, bất cứ thứ gì không được gán giá trị rõ ràng sẽ được đặt thành zero.

int a[5] = {22, 37, 3490};

// is the same as:

int a[5] = {22, 37, 3490, 0, 0};

Có một mẹo tắt phổ biến bạn hay thấy trong initializer khi muốn đặt toàn bộ mảng về zero:

int a[100] = {0};

Nghĩa là, “Đặt phần tử đầu tiên thành zero, rồi tự động đặt phần còn lại cũng thành zero.”

Bạn cũng có thể đặt phần tử cụ thể của mảng trong initializer, bằng cách chỉ định chỉ số cho giá trị! Khi làm thế, C sẽ vui vẻ tiếp tục khởi tạo các giá trị kế sau cho bạn đến khi initializer cạn, lấp phần còn lại bằng 0.

Để làm vậy, đặt chỉ số trong ngoặc vuông với = theo sau, rồi đặt giá trị.

Đây là ví dụ ta dựng một mảng:

int a[10] = {0, 11, 22, [5]=55, 66, 77};

Vì ta liệt kê chỉ số 5 là điểm bắt đầu cho 55, dữ liệu kết quả trong mảng là:

0 11 22 0 0 55 66 77 0 0

Bạn cũng có thể đặt biểu thức hằng số đơn giản vào đó.

#define COUNT 5

int a[COUNT] = {[COUNT-3]=3, 2, 1};

cho ra:

0 0 3 2 1

Cuối cùng, bạn cũng có thể để C tự tính kích thước mảng từ initializer, bằng cách bỏ trống kích thước:

int a[3] = {22, 37, 3490};

// is the same as:

int a[] = {22, 37, 3490};  // Left the size off!

6.4 Vượt biên!

C không ngăn bạn truy cập mảng vượt biên. Có khi còn không cảnh báo luôn.

Chôm ví dụ phía trên và cứ thế in vượt qua cuối mảng. Nó chỉ có 5 phần tử, nhưng cứ thử in 10 xem chuyện gì xảy ra:

#include <stdio.h>

int main(void)
{
    int i;
    int a[5] = {22, 37, 3490, 18, 95};

    for (i = 0; i < 10; i++) {  // BAD NEWS: printing too many elements!
        printf("%d\n", a[i]);
    }
}

Chạy trên máy tính của tôi, nó in:

22
37
3490
18
95
32765
1847052032
1780534144
-56487472
21890

Hú hồn! Cái gì thế? Hoá ra in vượt qua cuối mảng dẫn đến thứ mà dân C gọi là undefined behavior (hành vi không xác định). Ta sẽ nói thêm về con quái này sau, nhưng hiện giờ nó nghĩa là, “Bạn đã làm điều gì đó xấu, và bất cứ điều gì cũng có thể xảy ra trong lúc chương trình chạy.”

Và “bất cứ điều gì”, thường là như tìm thấy zero, tìm thấy số rác, hay crash. Nhưng thật ra spec C nói trong trường hợp này trình biên dịch được phép sinh code làm bất cứ thứ gì⁵⁸.

Phiên bản ngắn: đừng làm bất cứ thứ gì gây ra undefined behavior. Bao giờ⁵⁹.

6.5 Mảng nhiều chiều

Bạn có thể thêm bao nhiêu chiều tuỳ thích cho mảng.

int a[10];
int b[2][7];
int c[4][5][6];

Chúng được lưu trong bộ nhớ theo thứ tự row-major order⁶⁰. Nghĩa là với mảng 2D, chỉ số đầu tiên được liệt kê chỉ hàng, chỉ số thứ hai chỉ cột.

Bạn cũng có thể dùng initializer trên mảng nhiều chiều bằng cách lồng chúng:

#include <stdio.h>

int main(void)
{
    int row, col;

    int a[2][5] = {      // Initialize a 2D array
        {0, 1, 2, 3, 4},
        {5, 6, 7, 8, 9}
    };

    for (row = 0; row < 2; row++) {
        for (col = 0; col < 5; col++) {
            printf("(%d,%d) = %d\n", row, col, a[row][col]);
        }
    }
}

Cho output:

(0,0) = 0
(0,1) = 1
(0,2) = 2
(0,3) = 3
(0,4) = 4
(1,0) = 5
(1,1) = 6
(1,2) = 7
(1,3) = 8
(1,4) = 9

Và bạn có thể khởi tạo với chỉ số rõ ràng:

// Make a 3x3 identity matrix

int a[3][3] = {[0][0]=1, [1][1]=1, [2][2]=1};

sẽ dựng một mảng 2D như này:

1 0 0
0 1 0
0 0 1

6.6 Mảng và con trỏ

[Thản nhiên] Thì… tôi có lẽ đã đề cập phía trên rằng sâu thẳm bên trong mảng là con trỏ nhỉ? Giờ ta nên làm một cú lặn cạn vào chuyện đó, để mọi thứ không bị hoàn toàn rối rắm. Sau này, ta sẽ nhìn kỹ mối quan hệ thực sự giữa mảng và con trỏ, nhưng bây giờ tôi chỉ muốn xem chuyện truyền mảng cho hàm.

6.6.1 Lấy con trỏ tới một mảng

Tôi muốn kể bạn nghe một bí mật. Nói chung, khi một lập trình viên C nói về con trỏ tới một mảng, họ đang nói về con trỏ tới phần tử đầu tiên của mảng⁶¹.

Nào, lấy một con trỏ tới phần tử đầu tiên của mảng.

#include <stdio.h>

int main(void)
{
    int a[5] = {11, 22, 33, 44, 55};
    int *p;

    p = &a[0];  // p points to the array
                // Well, to the first element, actually

    printf("%d\n", *p);  // Prints "11"
}

Chuyện này quá phổ biến trong C, đến nỗi ngôn ngữ cho phép ta một cách viết tắt:

p = &a[0];  // p points to the array

// is the same as:

p = a;      // p points to the array, but much nicer-looking!

Chỉ cần nhắc đến tên mảng đứng một mình là tương đương với lấy một con trỏ tới phần tử đầu tiên của mảng! Ta sẽ dùng điều này rộng rãi trong các ví dụ sắp tới.

Nhưng khoan đã, p chẳng phải là int* sao? Và *p cho ta 11, cùng giống a[0]? Đúúúúng. Bạn đang bắt đầu thấy thoáng qua mối quan hệ giữa mảng và con trỏ trong C. (Ta sẽ nói nhiều hơn về chuyện này trong chương Pointers II, ở mục Array/Pointer Equivalence.)

6.6.2 Truyền mảng một chiều cho hàm

Làm một ví dụ với mảng một chiều. Tôi sẽ viết vài hàm mà ta có thể truyền mảng vào để làm việc khác nhau.

Chuẩn bị cho vài signature hàm làm đầu óc bùng nổ!

#include <stdio.h>

// Passing as a pointer to the first element
void times2(int *a, int len)
{
    for (int i = 0; i < len; i++)
        printf("%d\n", a[i] * 2);
}

// Same thing, but using array notation
void times3(int a[], int len)
{
    for (int i = 0; i < len; i++)
        printf("%d\n", a[i] * 3);
}

// Same thing, but using array notation with size
void times4(int a[5], int len)
{
    for (int i = 0; i < len; i++)
        printf("%d\n", a[i] * 4);
}

int main(void)
{
    int x[5] = {11, 22, 33, 44, 55};

    times2(x, 5);
    times3(x, 5);
    times4(x, 5);
}

Tất cả các cách liệt kê mảng làm parameter trong hàm đó đều giống hệt nhau.

void times2(int *a, int len)
void times3(int a[], int len)
void times4(int a[5], int len)

Trong cách dùng của dân C quen tay, cách đầu tiên phổ biến nhất, bỏ xa các cách còn lại.

Và, thật ra, ở tình huống cuối, trình biên dịch thậm chí không quan tâm bạn truyền số nào (miễn lớn hơn không⁶²). Nó không ép buộc gì cả.

Giờ sau khi đã nói vậy, kích thước mảng trong khai báo hàm thật ra có ý nghĩa khi bạn truyền mảng nhiều chiều vào hàm, nhưng hãy quay lại chuyện đó sau.

6.6.3 Thay đổi mảng trong hàm

Ta đã nói mảng chỉ là con trỏ trá hình. Nghĩa là nếu bạn truyền mảng cho hàm, nhiều khả năng bạn đang truyền con trỏ tới phần tử đầu tiên của mảng.

Nhưng nếu hàm có con trỏ tới dữ liệu, nó có thể thao tác trên dữ liệu đó! Vậy nên những thay đổi mà hàm làm với mảng sẽ thấy được ở phía người gọi.

Đây là ví dụ ta truyền một con trỏ tới mảng cho hàm, hàm thao tác trên các giá trị trong mảng đó, và các thay đổi đó thấy được ở phía người gọi.

#include <stdio.h>

void double_array(int *a, int len)
{
    // Multiply each element by 2
    //
    // This doubles the values in x in main() since x and a both point
    // to the same array in memory!

    for (int i = 0; i < len; i++)
        a[i] *= 2;
}

int main(void)
{
    int x[5] = {1, 2, 3, 4, 5};

    double_array(x, 5);

    for (int i = 0; i < 5; i++)
        printf("%d\n", x[i]);  // 2, 4, 6, 8, 10!
}

Mặc dù ta truyền mảng vào parameter a kiểu int*, nhìn cách ta truy cập nó bằng ký pháp mảng a[i]! Cááááái gì. Chuyện này hoàn toàn được cho phép.

Sau này khi nói về sự tương đương giữa mảng và con trỏ, ta sẽ thấy chuyện này hợp lý hơn nhiều. Giờ, đủ để biết rằng hàm có thể thay đổi mảng mà thấy được ở phía người gọi.

6.6.4 Truyền mảng nhiều chiều cho hàm

Câu chuyện thay đổi một chút khi ta nói về mảng nhiều chiều. C cần biết tất cả các chiều (trừ chiều đầu tiên) để có đủ thông tin biết tìm giá trị ở đâu trong bộ nhớ.

Đây là ví dụ ta nói rõ tất cả các chiều:

#include <stdio.h>

void print_2D_array(int a[2][3])
{
    for (int row = 0; row < 2; row++) {
        for (int col = 0; col < 3; col++)
            printf("%d ", a[row][col]);
        printf("\n");
    }
}

int main(void)
{
    int x[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    print_2D_array(x);
}

Nhưng trong trường hợp này, hai cách này⁶³ là tương đương:

void print_2D_array(int a[2][3])
void print_2D_array(int a[][3])

Trình biên dịch thật ra chỉ cần chiều thứ hai để biết cần nhảy bao xa trong bộ nhớ cho mỗi lần tăng chiều đầu tiên. Nói chung, nó cần biết tất cả các chiều trừ chiều đầu tiên.

Ngoài ra, nhớ rằng trình biên dịch chỉ làm kiểm tra biên tối thiểu lúc biên dịch (nếu bạn may mắn), và C không kiểm tra biên gì hết lúc chạy. Không dây an toàn! Đừng crash bằng cách truy cập phần tử mảng vượt biên!

7 Chuỗi

Cuối cùng! Chuỗi! Có gì đơn giản hơn được nữa?

Nhưng hoá ra chuỗi thật ra không phải chuỗi trong C. Đúng vậy đấy! Chúng là con trỏ! Dĩ nhiên rồi!

Giống như mảng, chuỗi trong C vừa đủ để tồn tại.

Nhưng cứ xem nào, không phải chuyện ghê gớm lắm đâu.

7.1 String Literal

Trước khi bắt đầu, hãy nói về string literal trong C. Đây là các chuỗi ký tự nằm trong dấu nháy kép ("). (Nháy đơn bọc quanh ký tự, và đó là con thú hoàn toàn khác.)

Ví dụ:

"Hello, world!\n"
"This is a test."
"When asked if this string had quotes in it, she replied, \"It does.\""

Cái đầu tiên có newline ở cuối, khá phổ biến.

Cái cuối có dấu nháy kép nhúng bên trong, nhưng bạn thấy mỗi cái được đặt trước (ta nói “được escape bởi”) một dấu gạch chéo ngược (\) báo cho biết một dấu nháy kép chữ thuộc về chuỗi tại điểm đó. Đây là cách trình biên dịch C phân biệt giữa in dấu nháy kép và dấu nháy kép ở cuối chuỗi.

7.2 Biến chuỗi

Giờ ta đã biết cách làm một string literal, hãy gán nó vào biến để làm gì đó với nó.

char *s = "Hello, world!";

Để ý kiểu: pointer tới char. Biến chuỗi s thật ra là con trỏ tới ký tự đầu tiên trong chuỗi đó, chính là H.

Và ta có thể in nó bằng format specifier %s (viết tắt cho “string”):

char *s = "Hello, world!";

printf("%s\n", s);  // "Hello, world!"

7.3 Biến chuỗi dưới dạng mảng

Một lựa chọn khác, gần như tương đương với cách dùng char* phía trên:

char s[14] = "Hello, world!";

// or, if we were properly lazy and have the compiler
// figure the length for us:

char s[] = "Hello, world!";

Nghĩa là bạn có thể dùng ký pháp mảng để truy cập các ký tự trong chuỗi. Làm đúng thế để in tất cả ký tự trong chuỗi trên cùng một dòng:

#include <stdio.h>

int main(void)
{
    char s[] = "Hello, world!";

    for (int i = 0; i < 13; i++)
        printf("%c", s[i]);
    printf("\n");
}

Để ý ta dùng format specifier %c để in một ký tự đơn.

Và, xem cái này. Chương trình vẫn chạy tốt nếu ta đổi định nghĩa s thành kiểu char*:

#include <stdio.h>

int main(void)
{
    char *s = "Hello, world!";   // char* here

    for (int i = 0; i < 13; i++)
        printf("%c", s[i]);    // But still use arrays here...?
    printf("\n");
}

Và ta vẫn có thể dùng ký pháp mảng để in ra! Bất ngờ nhỉ, nhưng chỉ vì ta chưa nói về sự tương đương giữa mảng và con trỏ. Nhưng đây là thêm một gợi ý nữa rằng sâu thẳm bên trong, mảng và con trỏ là cùng một thứ.

7.4 Khởi tạo chuỗi

Ta đã thấy vài ví dụ khởi tạo biến chuỗi bằng string literal:

char *s = "Hello, world!";
char t[] = "Hello, again!";

Nhưng hai cách khởi tạo này khác nhau một chút tinh tế. Một string literal, tương tự một integer literal, có bộ nhớ được trình biên dịch tự động quản lý giúp bạn! Với số nguyên, tức là một mẩu dữ liệu kích thước cố định, trình biên dịch khá dễ quản lý. Nhưng chuỗi là con thú số byte thay đổi, được trình biên dịch thuần hoá bằng cách quăng vào một mẩu bộ nhớ và đưa cho bạn một con trỏ tới đó.

Cách viết này trỏ tới bất cứ nơi đâu chuỗi được đặt. Thường thì nơi đó nằm trong vùng đất xa xôi so với phần còn lại của bộ nhớ chương trình, bộ nhớ chỉ đọc, vì lý do liên quan đến hiệu năng và an toàn.

char *s = "Hello, world!";

Nên nếu bạn thử đột biến chuỗi bằng:

char *s = "Hello, world!";

s[0] = 'z';  // BAD NEWS: tried to mutate a string literal!

Hành vi là không xác định. Có lẽ, tuỳ hệ thống, sẽ dẫn đến crash.

Nhưng khai báo nó dưới dạng mảng thì khác. Trình biên dịch không cất các byte đó ở phần khác của thành phố, chúng ở ngay cuối đường. Cái này là một bản sao có thể đột biến của chuỗi, cái ta có thể đổi tuỳ thích:

char t[] = "Hello, again!";  // t is an array copy of the string 
t[0] = 'z'; //  No problem

printf("%s\n", t);  // "zello, again!"

Nên nhớ nhé: nếu bạn có con trỏ tới một string literal, đừng cố đổi nó! Và nếu bạn dùng chuỗi trong dấu nháy kép để khởi tạo mảng, đó thật ra không phải là string literal.

7.5 Lấy chiều dài chuỗi

Bạn không thể, vì C không theo dõi hộ bạn. Và khi tôi nói “không thể”, tôi thật ra muốn nói “có thể”⁶⁴. Có một hàm trong <string.h> tên là strlen() có thể được dùng để tính chiều dài của bất kỳ chuỗi nào tính bằng byte⁶⁵.

#include <stdio.h>
#include <string.h>

int main(void)
{
    char *s = "Hello, world!";

    printf("The string is %zu bytes long.\n", strlen(s));
}

Hàm strlen() trả về kiểu size_t, là một kiểu số nguyên nên bạn có thể dùng nó cho phép toán số nguyên. Ta in size_t bằng %zu.

Chương trình trên in:

The string is 13 bytes long.

Tuyệt! Vậy là có thể lấy chiều dài chuỗi!

Nhưng… nếu C không theo dõi chiều dài chuỗi ở đâu, làm sao nó biết chuỗi dài bao nhiêu?

7.6 Kết thúc chuỗi

C xử lý chuỗi hơi khác nhiều ngôn ngữ lập trình, và thật ra khác với gần như mọi ngôn ngữ lập trình hiện đại.

Khi bạn làm một ngôn ngữ mới, về cơ bản bạn có hai lựa chọn để lưu chuỗi trong bộ nhớ:

1. Lưu các byte của chuỗi cùng với một con số chỉ chiều dài chuỗi.

2. Lưu các byte của chuỗi, và đánh dấu điểm kết thúc chuỗi bằng một byte đặc biệt gọi là terminator (kết thúc).

Nếu bạn muốn chuỗi dài hơn 255 ký tự, phương án 1 cần ít nhất hai byte để lưu chiều dài. Còn phương án 2 chỉ cần một byte để kết thúc chuỗi. Vậy là tiết kiệm được chút ít.

Dĩ nhiên, ngày nay nghe có vẻ lố bịch khi lo tiết kiệm một byte (hay 3, nhiều ngôn ngữ vui vẻ cho phép bạn có chuỗi dài 4 gigabyte). Nhưng ngày xưa, đó là chuyện lớn hơn.

Nên C chọn phương án #2. Trong C, một “chuỗi” được định nghĩa bởi hai đặc tính cơ bản:

• Một con trỏ tới ký tự đầu tiên trong chuỗi.
• Một byte có giá trị bằng không (hay ký tự NUL⁶⁶) nằm đâu đó trong bộ nhớ sau con trỏ, báo hiệu kết thúc chuỗi.

Ký tự NUL có thể được viết trong code C là \0, dù bạn không hay phải làm thế.

Khi bạn đặt chuỗi trong dấu nháy kép trong code, ký tự NUL được tự động, ngầm định, đưa vào.

char *s = "Hello!";  // Actually "Hello!\0" behind the scenes

Với chuyện này trong đầu, hãy viết hàm strlen() của riêng ta, đếm các char trong chuỗi cho tới khi gặp NUL.

Quy trình là quét dọc chuỗi tìm một ký tự NUL duy nhất, đếm khi đi qua⁶⁷:

int my_strlen(char *s)
{
    int count = 0;

    while (s[count] != '\0')  // Single quotes for single char
        count++;

    return count;
}

Và đó về cơ bản là cách strlen() có sẵn làm chuyện này.

7.7 Sao chép một chuỗi

Bạn không thể sao chép chuỗi qua toán tử gán (=). Tất cả những gì nó làm là tạo một bản sao của con trỏ tới ký tự đầu tiên… nên bạn kết thúc với hai con trỏ cùng trỏ tới một chuỗi:

#include <stdio.h>

int main(void)
{
    char s[] = "Hello, world!";
    char *t;

    // This makes a copy of the pointer, not a copy of the string!
    t = s;

    // We modify t
    t[0] = 'z';

    // But printing s shows the modification!
    // Because t and s point to the same string!

    printf("%s\n", s);  // "zello, world!"
}

Nếu bạn muốn tạo một bản sao của chuỗi, bạn phải chép từng byte, nghĩa là bạn sẽ lấy từng byte của chuỗi từ một chỗ trong bộ nhớ và nhân đôi chúng ở chỗ khác trong bộ nhớ. Chuyện này được làm dễ hơn nhờ hàm strcpy().⁶⁸

Trước khi sao chép chuỗi, đảm bảo bạn có chỗ để chép vào, tức mảng đích sẽ chứa các ký tự phải dài ít nhất bằng chuỗi bạn đang chép.

#include <stdio.h>
#include <string.h>

int main(void)
{
    char s[] = "Hello, world!";
    char t[100];  // Each char is one byte, so plenty of room

    // This makes a copy of the string!
    strcpy(t, s);

    // We modify t
    t[0] = 'z';

    // And s remains unaffected because it's a different string
    printf("%s\n", s);  // "Hello, world!"

    // But t has been changed
    printf("%s\n", t);  // "zello, world!"
}

Để ý với strcpy(), con trỏ đích là đối số đầu tiên, con trỏ nguồn là đối số thứ hai. Một mẹo nhớ tôi dùng là đó là thứ tự mà bạn sẽ đặt t và s nếu phép gán = chạy được cho chuỗi, với nguồn ở bên phải và đích ở bên trái.

8 Struct

Trong C, có một thứ gọi là struct, một kiểu do người dùng định nghĩa được, giữ nhiều mẩu dữ liệu, có thể thuộc các kiểu khác nhau.

Đây là cách tiện lợi để gói nhiều biến vào làm một. Việc này có ích khi truyền biến cho hàm (chỉ cần truyền một thay vì nhiều), và hữu dụng để tổ chức dữ liệu và làm code dễ đọc hơn.

Nếu bạn đến từ ngôn ngữ khác, có thể bạn đã quen với khái niệm class và object. Những thứ này không tồn tại sẵn trong C⁶⁹. Bạn có thể nghĩ về struct như class chỉ có các trường dữ liệu, không có method.

8.1 Khai báo một struct

Bạn có thể khai báo một struct trong code của mình như này:

struct car {
    char *name;
    float price;
    int speed;
};

Chuyện này thường được làm ở scope toàn cục bên ngoài các hàm để struct khả dụng toàn cục.

Khi làm vậy, bạn đang tạo một kiểu (type) mới. Tên kiểu đầy đủ là struct car. (Không phải chỉ car, viết thế không hoạt động.)

Chưa có biến nào kiểu đó, nhưng ta có thể khai báo vài biến:

struct car saturn;  // Variable "saturn" of type "struct car"

Giờ ta có biến chưa khởi tạo saturn⁷⁰ kiểu struct car.

Ta nên khởi tạo nó! Nhưng làm sao đặt giá trị cho từng trường riêng lẻ?

Giống như nhiều ngôn ngữ khác lấy lại từ C, ta sẽ dùng toán tử chấm (.) để truy cập từng trường.

saturn.name = "Saturn SL/2";
saturn.price = 15999.99;
saturn.speed = 175;

printf("Name:           %s\n", saturn.name);
printf("Price (USD):    %f\n", saturn.price);
printf("Top Speed (km): %d\n", saturn.speed);

Ở các dòng đầu, ta đặt giá trị vào struct car, rồi ở đoạn sau, in các giá trị đó ra.

8.2 Khởi tạo Struct

Ví dụ ở mục trước hơi cồng kềnh. Chắc phải có cách tốt hơn để khởi tạo biến struct!

Bạn có thể làm với initializer bằng cách đặt giá trị cho các trường theo thứ tự chúng xuất hiện trong struct khi bạn định nghĩa biến. (Cách này không chạy sau khi biến đã được định nghĩa, phải xảy ra ngay lúc định nghĩa).

struct car {
    char *name;
    float price;
    int speed;
};

// Now with an initializer! Same field order as in the struct declaration:
struct car saturn = {"Saturn SL/2", 16000.99, 175};

printf("Name:      %s\n", saturn.name);
printf("Price:     %f\n", saturn.price);
printf("Top Speed: %d km\n", saturn.speed);

Việc các trường trong initializer phải cùng thứ tự nghe hơi rùng mình. Nếu ai đó đổi thứ tự trong struct car, có thể làm hỏng hết code khác!

Ta có thể cụ thể hơn với initializer:

struct car saturn = {.speed=175, .name="Saturn SL/2"};

Giờ nó độc lập với thứ tự trong khai báo struct. Code an toàn hơn hẳn.

Tương tự như initializer của mảng, bất kỳ field designator nào bị bỏ sót đều được khởi tạo về không (trong trường hợp này, đó là .price, tôi đã bỏ qua).

8.3 Truyền Struct cho hàm

Bạn có vài cách để truyền struct cho hàm.

1. Truyền bản thân struct.
2. Truyền con trỏ tới struct.

Nhớ rằng khi bạn truyền thứ gì đó cho hàm, một bản sao của thứ đó được tạo ra cho hàm thao tác, bất kể đó là bản sao của con trỏ, của int, của struct, hay bất cứ thứ gì.

Về cơ bản có hai trường hợp bạn muốn truyền con trỏ tới struct:

1. Bạn cần hàm có thể thay đổi struct được truyền vào, và để những thay đổi đó hiện ra ở phía người gọi.
2. struct hơi lớn và chép nó lên stack tốn hơn là chép một con trỏ⁷¹.

Vì hai lý do đó, truyền con trỏ tới struct cho hàm phổ biến hơn nhiều, dù truyền cả struct thì không hề phạm luật.

Thử truyền con trỏ, làm một hàm cho phép bạn đặt trường .price của struct car:

#include <stdio.h>

struct car {
    char *name;
    float price;
    int speed;
};

int main(void)
{
    struct car saturn = {.speed=175, .name="Saturn SL/2"};

    // Pass a pointer to this struct car, along with a new,
    // more realistic, price:
    set_price(&saturn, 799.99);

    printf("Price: %f\n", saturn.price);
}

Bạn nên có thể nghĩ ra signature của hàm set_price() chỉ bằng cách nhìn kiểu của các đối số ta có ở đó.

saturn là struct car, nên &saturn phải là địa chỉ của struct car, tức là con trỏ tới struct car, cụ thể là struct car*.

Và 799.99 là float.

Nên khai báo hàm phải như này:

void set_price(struct car *c, float new_price)

Ta chỉ cần viết phần thân. Lần thử đầu tiên có thể là:

void set_price(struct car *c, float new_price) {
    c.price = new_price;  // ERROR!!
}

Cách đó không chạy vì toán tử chấm chỉ chạy trên struct… nó không chạy trên con trỏ tới struct.

Được rồi, ta có thể dereference biến c để “de-pointer” nó để tới bản thân struct. Dereference một struct car* cho ra struct car mà con trỏ trỏ tới, ta nên có thể dùng toán tử chấm lên đó:

void set_price(struct car *c, float new_price) {
    (*c).price = new_price;  // Works, but is ugly and non-idiomatic :(
}

Và chạy! Nhưng hơi lôi thôi khi gõ hết đám dấu ngoặc với dấu sao. C có một thứ đường cú pháp gọi là toán tử mũi tên (arrow operator) giúp chuyện đó.

8.4 Toán tử mũi tên

Toán tử mũi tên giúp tham chiếu tới các trường trong con trỏ tới struct.

void set_price(struct car *c, float new_price) {
    // (*c).price = new_price;  // Works, but non-idiomatic :(
    //
    // The line above is 100% equivalent to the one below:

    c->price = new_price;  // That's the one!
}

Vậy khi truy cập các trường, khi nào dùng chấm và khi nào dùng mũi tên?

• Nếu bạn có struct, dùng chấm (.).
• Nếu bạn có con trỏ tới struct, dùng mũi tên (->).

8.5 Sao chép và trả về struct

Đây là phần dễ cho bạn!

Chỉ cần gán từ cái này sang cái kia!

struct car a, b;

b = a;  // Copy the struct

Và trả về một struct (thay vì trả về một con trỏ tới nó) từ hàm cũng tạo một bản sao tương tự vào biến nhận.

Đây không phải “deep copy”⁷². Tất cả các trường được chép y nguyên, kể cả con trỏ tới các thứ.

8.6 So sánh struct

Chỉ có một cách an toàn duy nhất: so sánh từng trường một.

Bạn có thể nghĩ có thể dùng memcmp()⁷³, nhưng nó không xử lý được trường hợp có thể có padding bytes nằm lẫn trong đó.

Nếu bạn xoá struct về không trước bằng memset()⁷⁴, thì nó có thể chạy, dù vẫn có thể có những phần tử lạ không so sánh như bạn mong⁷⁵.

9 File Input/Output

Ta đã thấy vài ví dụ về I/O với printf() để làm I/O ở console.

Nhưng ở chương này ta sẽ đẩy các khái niệm đó đi xa hơn một chút.

9.1 Kiểu dữ liệu FILE*

Khi làm bất kỳ dạng I/O nào trong C, ta làm thông qua một mẩu dữ liệu dưới dạng kiểu FILE*. FILE* này giữ mọi thông tin cần để giao tiếp với hệ thống I/O về file bạn đang mở, vị trí hiện tại trong file, v.v.

Đặc tả gọi những thứ này là stream, tức một dòng dữ liệu chảy ra từ file hoặc từ bất kỳ nguồn nào. Tôi sẽ dùng lẫn “file” với “stream”, nhưng thực sự bạn nên coi “file” là một trường hợp đặc biệt của “stream”. Có những cách khác để đẩy dữ liệu vào chương trình ngoài chuyện đọc từ file.

Chút nữa ta sẽ xem cách đi từ một tên file tới một FILE* đã mở, nhưng trước hết tôi muốn nhắc đến ba stream đã được mở sẵn và có thể dùng ngay.

Hoá ra ta đã dùng chúng ngầm suốt rồi. Chẳng hạn, hai lời gọi này là một:

printf("Hello, world!\n");
fprintf(stdout, "Hello, world!\n");  // printf to a file

Nhưng chuyện đó để sau.

Bạn cũng sẽ nhận ra rằng cả stdout và stderr đều ra màn hình. Nhìn qua tưởng như sơ suất hay trùng lặp, nhưng thực ra không phải. Các hệ điều hành điển hình cho phép bạn redirect (chuyển hướng) đầu ra của bất kỳ cái nào trong hai vào các file khác nhau, và việc tách thông báo lỗi khỏi đầu ra thường có thể rất tiện.

Ví dụ, trong shell POSIX (như sh, ksh, bash, zsh, v.v.) trên hệ thống kiểu Unix, ta có thể chạy chương trình và đẩy đầu ra không-lỗi (stdout) vào một file, còn đầu ra lỗi (stderr) vào file khác.

./foo > output.txt 2> errors.txt   # This command is Unix-specific

Vì lý do đó, bạn nên gửi các thông báo lỗi nghiêm trọng ra stderr chứ đừng ra stdout.

Cách làm sẽ nói sau.

9.2 Đọc file văn bản

Stream được phân loại đại khái theo hai cách: text (văn bản) và binary (nhị phân).

Stream văn bản được phép dịch dữ liệu khá nhiều, đáng chú ý nhất là dịch các newline sang các biểu diễn khác nhau⁷⁶. File văn bản về mặt logic là một chuỗi dòng được ngăn bởi newline. Để portable, dữ liệu đầu vào nên luôn kết thúc bằng một newline.

Nhưng quy tắc chung là nếu bạn có thể chỉnh sửa file đó trong một trình soạn thảo văn bản thông thường thì đó là file văn bản. Ngược lại là nhị phân. Nhị phân thì để sau.

Vậy, vào việc, làm sao mở một file để đọc và kéo dữ liệu ra?

Tạo một file hello.txt chỉ chứa mỗi:

Hello, world!

Rồi viết một chương trình mở file, đọc một ký tự ra, rồi đóng file khi xong. Kế hoạch thế!

#include <stdio.h>

int main(void)
{
    FILE *fp;                      // Variable to represent open file

    fp = fopen("hello.txt", "r");  // Open file for reading

    int c = fgetc(fp);             // Read a single character
    printf("%c\n", c);             // Print char to stdout

    fclose(fp);                    // Close the file when done
}

Thấy đấy, khi mở file với fopen(), nó trả FILE* về cho ta để dùng sau.

(Tôi bỏ qua để gọn, nhưng fopen() sẽ trả về NULL nếu có gì trục trặc, như không tìm thấy file, nên bạn thật sự phải check lỗi cho nó!)

Cũng chú ý chuỗi "r" ta truyền vào, nghĩa là “mở một stream văn bản để đọc”. (Có nhiều chuỗi khác nhau có thể truyền cho fopen() với ý nghĩa khác, như ghi, append, v.v.)

Sau đó ta dùng hàm fgetc() để lấy một ký tự từ stream. Có thể bạn thắc mắc sao tôi khai báo c là int chứ không phải char, giữ câu hỏi đó lại nhé!

Cuối cùng ta đóng stream khi xong. Mọi stream đều được đóng tự động khi chương trình thoát, nhưng đóng file thủ công khi không còn dùng nữa là phong cách tốt và cẩn thận.

FILE* theo dõi vị trí của ta trong file. Nên các lời gọi fgetc() tiếp theo sẽ lấy ký tự kế, rồi ký tự kế nữa, cho tới hết.

Nhưng nghe khổ sở quá. Xem có cách nào dễ hơn không.

9.3 Hết file: EOF

Có một ký tự đặc biệt được định nghĩa dạng macro: EOF. Đây là thứ fgetc() sẽ trả về khi đã tới cuối file và bạn cố đọc thêm một ký tự nữa.

Giờ kể một Fun Fact™. Hoá ra EOF là lý do fgetc() và các hàm kiểu nó trả về int thay vì char. EOF không phải ký tự đúng nghĩa, và giá trị của nó nhiều khả năng nằm ngoài miền của char. Vì fgetc() phải có khả năng trả về bất kỳ byte nào và EOF, nó cần một kiểu rộng hơn để chứa nhiều giá trị hơn. Nên là int. Nhưng trừ khi bạn đang so sánh giá trị trả về với EOF, trong thâm tâm bạn có thể yên tâm rằng đó là một char.

Ổn! Quay lại thực tế! Ta có thể dùng cái này để đọc cả file trong một vòng lặp.

#include <stdio.h>

int main(void)
{
    FILE *fp;
    int c;

    fp = fopen("hello.txt", "r");

    while ((c = fgetc(fp)) != EOF)
        printf("%c", c);

    fclose(fp);
}

(Nếu dòng 10 lạ quá, cứ mổ nó ra bắt đầu từ ngoặc lồng trong cùng. Việc đầu tiên là gán kết quả của fgetc() vào c, rồi mới so sánh cái đó với EOF. Ta vừa nhét tất cả vào một dòng. Đọc có vẻ khó, nhưng nghiền ngẫm đi, đây là C idiomatic đấy.)

Chạy thử, ta thấy:

Hello, world!

Nhưng vẫn đang xử lý từng ký tự một, mà nhiều file văn bản hợp lý hơn khi nhìn theo dòng. Chuyển sang cái đó.

9.3.1 Đọc từng dòng một

Vậy làm sao lấy nguyên một dòng cùng lúc? fgets() giải cứu! Tham số gồm một con trỏ tới buffer char để chứa byte, số byte tối đa được đọc, và một FILE* để đọc từ đó. Nó trả về NULL khi hết file hoặc lỗi. fgets() còn tử tế đến mức NUL-terminate chuỗi khi xong⁷⁷.

Làm một vòng lặp tương tự trước, nhưng lần này với file nhiều dòng và đọc từng dòng một.

Đây là file quote.txt:

A wise man can learn more from
a foolish question than a fool
can learn from a wise answer.
                  --Bruce Lee

Và đây là đoạn code đọc file đó từng dòng một và in số dòng trước mỗi dòng:

#include <stdio.h>

int main(void)
{
    FILE *fp;
    char s[1024];  // Big enough for any line this program will encounter
    int linecount = 0;

    fp = fopen("quote.txt", "r");

    while (fgets(s, sizeof s, fp) != NULL) 
        printf("%d: %s", ++linecount, s);

    fclose(fp);
}

Cho ra:

1: A wise man can learn more from
2: a foolish question than a fool
3: can learn from a wise answer.
4:                   --Bruce Lee

9.4 Đầu vào có định dạng

Bạn biết cách lấy đầu ra có định dạng bằng printf() chứ (và cũng vậy với fprintf() ta sẽ thấy ở dưới)?

Bạn có thể làm y như thế với fscanf().

Trước khi bắt đầu, xin lưu ý rằng dùng các hàm kiểu scanf() có thể nguy hiểm với đầu vào không đáng tin. Nếu không chỉ định độ rộng trường cho %s, bạn có thể tràn buffer. Tệ hơn, chuyển đổi số không hợp lệ sẽ dẫn tới undefined behavior. Cách an toàn với đầu vào không đáng tin là dùng %s kèm độ rộng trường, rồi dùng các hàm như strtol() hay strtod() để chuyển đổi.

Ta có một file với một dãy bản ghi dữ liệu. Trường hợp này là cá voi, với tên, chiều dài tính bằng mét, và cân nặng tính bằng tấn. whales.txt:

blue 29.9 173
right 20.7 135
gray 14.9 41
humpback 16.0 30

Phải, ta có thể đọc bằng fgets() rồi parse chuỗi bằng sscanf() (và cách đó chống đỡ tốt hơn với file hỏng), nhưng lần này cứ dùng fscanf() kéo thẳng vào.

Hàm fscanf() bỏ qua whitespace ở đầu khi đọc, và trả về EOF khi hết file hoặc lỗi.

#include <stdio.h>

int main(void)
{
    FILE *fp;
    char name[1024];  // Big enough for any line this program will encounter
    float length;
    int mass;

    fp = fopen("whales.txt", "r");

    while (fscanf(fp, "%s %f %d", name, &length, &mass) != EOF)
        printf("%s whale, %d tonnes, %.1f meters\n", name, mass, length);

    fclose(fp);
}

Cho ra:

blue whale, 173 tonnes, 29.9 meters
right whale, 135 tonnes, 20.7 meters
gray whale, 41 tonnes, 14.9 meters
humpback whale, 30 tonnes, 16.0 meters

9.5 Ghi file văn bản

Giống hệt như cách ta dùng fgetc(), fgets(), và fscanf() để đọc stream văn bản, ta có thể dùng fputc(), fputs(), và fprintf() để ghi stream văn bản.

Để làm vậy, ta phải fopen() file ở chế độ ghi bằng cách truyền "w" làm đối số thứ hai. Mở một file đang tồn tại ở chế độ "w" sẽ lập tức cắt file đó về 0 byte để ghi đè hoàn toàn.

Ta sẽ ghép một chương trình đơn giản xuất ra file output.txt dùng vài hàm xuất khác nhau.

#include <stdio.h>

int main(void)
{
    FILE *fp;
    int x = 32;

    fp = fopen("output.txt", "w");

    fputc('B', fp);
    fputc('\n', fp);   // newline
    fprintf(fp, "x = %d\n", x);
    fputs("Hello, world!\n", fp);

    fclose(fp);
}

Chương trình này tạo ra file output.txt với nội dung:

B
x = 32
Hello, world!

Fun fact: vì stdout là một file, bạn có thể thay dòng 8 bằng:

fp = stdout;

và chương trình sẽ xuất ra console thay vì ra file. Thử xem!

9.6 I/O file nhị phân

Tới giờ ta mới nói file văn bản. Nhưng còn con thú còn lại nhắc hồi đầu gọi là file nhị phân (binary), hay binary stream.

Chúng hoạt động khá giống file văn bản, chỉ khác ở chỗ hệ thống I/O không dịch dữ liệu như có thể sẽ làm với file văn bản. Với file nhị phân, bạn có một dòng byte thô, thế thôi.

Khác biệt lớn khi mở file là phải thêm "b" vào mode. Tức là, để đọc file nhị phân, mở ở mode "rb". Để ghi file, mở ở mode "wb".

Vì là dòng byte, và dòng byte có thể chứa ký tự NUL, mà ký tự NUL là dấu kết chuỗi trong C, hiếm khi người ta dùng fprintf() và đồng bọn để thao tác file nhị phân.

Thay vào đó hai hàm phổ biến nhất là fread() và fwrite(). Các hàm này đọc và ghi một số byte chỉ định vào stream.

Demo cho biết, ta sẽ viết mấy chương trình. Một chương trình sẽ ghi một dãy giá trị byte ra đĩa cùng lúc. Chương trình thứ hai sẽ đọc từng byte một và in ra⁷⁸.

#include <stdio.h>

int main(void)
{
    FILE *fp;
    unsigned char bytes[6] = {5, 37, 0, 88, 255, 12};

    fp = fopen("output.bin", "wb");  // wb mode for "write binary"!

    // In the call to fwrite, the arguments are:
    //
    // * Pointer to data to write
    // * Size of each "piece" of data
    // * Count of each "piece" of data
    // * FILE*

    fwrite(bytes, sizeof(char), 6, fp);

    fclose(fp);
}

Hai đối số giữa của fwrite() trông hơi kỳ. Nhưng đại khái ý ta muốn nói với hàm là: “Ta có các mục lớn ngần này, và muốn ghi bấy nhiêu mục.” Tiện lợi nếu bạn có bản ghi có độ dài cố định, và có một mảng chúng. Bạn chỉ cần bảo kích cỡ một bản ghi và bao nhiêu bản ghi cần ghi.

Trong ví dụ trên, ta bảo kích cỡ mỗi bản ghi là char, và có 6 mục.

Chạy chương trình xong ta có file output.bin, nhưng mở nó trong trình soạn thảo văn bản thì chẳng thấy gì thân thiện! Đó là dữ liệu nhị phân, không phải văn bản. Và là dữ liệu nhị phân ngẫu nhiên tôi vừa chế ra ấy chứ!

Nếu đẩy qua chương trình hex dump⁷⁹, ta có thể thấy đầu ra dưới dạng các byte:

05 25 00 58 ff 0c

Nhiều hệ Unix có sẵn chương trình tên hexdump để làm việc này. Bạn có thể dùng như này với cờ -C (“canonical”) để có đầu ra đẹp:

$ hexdump -C output.bin
00000000  05 25 00 58 ff 0c                              |.%.X..|

00000000 là offset trong file mà dòng đầu ra này bắt đầu. 05 25 00 58 ff 0c là các giá trị byte (và sẽ dài hơn, tới 16 byte mỗi dòng, nếu có nhiều byte hơn trong file). Và bên phải giữa hai ký hiệu pipe (|) là nỗ lực hết mình của hexdump để in ra các ký tự ứng với những byte đó. Nó in dấu chấm nếu ký tự không in được. Trường hợp này, vì ta chỉ in dữ liệu nhị phân ngẫu nhiên, phần đầu ra đó chỉ là rác. Nhưng nếu ta in một chuỗi ASCII ra file, sẽ thấy nó ở trong đó.

Và các giá trị hex đó khớp với các giá trị (thập phân) ta đã ghi ra.

Giờ thử đọc lại bằng một chương trình khác. Chương trình này sẽ mở file để đọc nhị phân (mode "rb") và đọc từng byte một trong vòng lặp.

fread() có đặc điểm hay ở chỗ trả về số byte đã đọc, hoặc 0 khi EOF. Nên ta có thể lặp đến khi thấy thế, in số ra trong lúc chạy.

#include <stdio.h>

int main(void)
{
    FILE *fp;
    unsigned char c;

    fp = fopen("output.bin", "rb"); // rb for "read binary"!

    while (fread(&c, sizeof(char), 1, fp) > 0)
        printf("%d\n", c);

    fclose(fp);
}

Và, chạy nó, ta thấy lại các con số gốc!

5
37
0
88
255
12

Woo hoo!

9.6.1 Lưu ý về struct và số

Như đã thấy ở phần struct, compiler được tự do thêm padding vào struct theo cách nó thấy hợp. Và các compiler khác nhau có thể làm khác nhau. Cùng một compiler trên kiến trúc khác nhau có thể làm khác. Cùng một compiler trên cùng kiến trúc cũng có thể làm khác.

Ý tôi là: không portable nếu bạn chỉ fwrite() nguyên một struct ra file khi không biết padding sẽ nằm đâu.

Fix sao đây? Giữ ý đó lại, ta sẽ xem vài cách làm chuyện này sau khi ngó qua một vấn đề liên quan khác.

Số!

Hoá ra không phải mọi kiến trúc đều biểu diễn số trong bộ nhớ theo cùng một cách.

Xem một fwrite() đơn giản của một số 2 byte. Ta sẽ viết nó dạng hex để mỗi byte hiện rõ. Byte có giá trị cao nhất sẽ có giá trị 0x12, byte thấp nhất sẽ có giá trị 0x34.

unsigned short v = 0x1234;  // Two bytes, 0x12 and 0x34

fwrite(&v, sizeof v, 1, fp);

Stream sẽ chứa gì?

Tưởng như phải là 0x12 rồi tới 0x34, đúng không?

Nhưng nếu tôi chạy cái này trên máy mình và hex dump kết quả, tôi thấy:

34 12

Đảo ngược rồi! Chuyện gì thế?

Chuyện này liên quan tới cái gọi là endianess⁸⁰ của kiến trúc. Có nơi ghi byte có giá trị cao trước, có nơi ghi byte có giá trị thấp trước.

Điều này nghĩa là nếu bạn ghi thẳng một số nhiều byte ra từ bộ nhớ, bạn không thể làm portable được⁸¹.

Một vấn đề tương tự tồn tại với số dấu phẩy động. Hầu hết hệ thống dùng cùng format cho số floating point, nhưng vài hệ thì không. Không đảm bảo gì hết!

Vậy… làm sao fix hết đống vấn đề này với số và struct để ghi dữ liệu ra một cách portable?

Tóm gọn là serialize (tuần tự hoá) dữ liệu, thuật ngữ chung mang nghĩa lấy hết dữ liệu và ghi ra theo một định dạng bạn kiểm soát, rõ ràng, và lập trình được để hoạt động giống nhau trên mọi nền tảng.

Như bạn đoán, đây là bài toán đã giải. Có một loạt thư viện serialization sẵn sàng để dùng, chẳng hạn protocol buffers⁸² của Google. Chúng lo mọi chi tiết vặt cho bạn, và thậm chí cho phép dữ liệu từ chương trình C của bạn tương tác với các ngôn ngữ khác hỗ trợ cùng phương thức serialization.

Làm ơn một điều cho bản thân và mọi người! Serialize dữ liệu nhị phân khi ghi ra stream! Sẽ giữ mọi thứ gọn và portable, kể cả khi bạn chuyển file dữ liệu từ kiến trúc này sang kiến trúc khác.

10 typedef: Tạo kiểu mới

Thực ra không hẳn là tạo kiểu mới, mà là đặt tên mới cho kiểu đã có. Thoạt nghe hơi vô nghĩa, nhưng ta có thể dùng nó để làm code gọn gàng hơn hẳn.

10.1 typedef về lý thuyết

Đại khái, bạn lấy một kiểu đã có rồi tạo alias (bí danh) cho nó bằng typedef.

Như này:

typedef int antelope;  // Make "antelope" an alias for "int"

antelope x = 10;       // Type "antelope" is the same as type "int"

Bạn có thể làm thế với bất kỳ kiểu có sẵn nào. Còn có thể tạo nhiều kiểu bằng list ngăn bởi dấu phẩy:

typedef int antelope, bagel, mushroom;  // These are all "int"

Tiện ghê, nhỉ? Đánh máy được mushroom thay cho int? Chắc bạn đang phấn khích lắm với tính năng này!

Được rồi Giáo sư Chế Giễu, chút nữa sẽ tới những cách dùng phổ biến hơn.

10.1.1 Scoping

typedef tuân theo quy tắc scope thông thường.

Vì vậy, rất hay gặp typedef ở file scope (“global”) để mọi hàm đều dùng được kiểu mới thoải mái.

10.2 typedef trong thực tế

Đổi tên int thành cái khác thì cũng không thú vị lắm. Xem typedef thường xuất hiện ở đâu.

10.2.1 typedef và struct

Đôi khi một struct sẽ được typedef ra tên mới để khỏi phải gõ từ struct đi struct lại.

struct animal {
    char *name;
    int leg_count, speed;
};

//  original name      new name
//            |         |
//            v         v
//      |-----------| |----|
typedef struct animal animal;

struct animal y;  // This works
animal z;         // This also works because "animal" is an alias

Cá nhân tôi không thích kiểu này lắm. Tôi thích sự rõ ràng mà code có được khi thêm chữ struct vào trước kiểu, lập trình viên biết ngay mình đang xử lý cái gì. Nhưng vì nó phổ biến nên tôi đưa vào đây.

Giờ tôi muốn chạy lại đúng ví dụ đó theo cách bạn hay thấy. Ta sẽ đặt struct animal vào bên trong typedef. Có thể gộp hết vào như này:

//  original name
//            |
//            v
//      |-----------|
typedef struct animal {
    char *name;
    int leg_count, speed;
} animal;                         // <-- new name

struct animal y;  // This works
animal z;         // This also works because "animal" is an alias

Y chang ví dụ trước, chỉ ngắn gọn hơn.

Nhưng chưa hết! Còn một kiểu rút gọn phổ biến nữa bạn có thể thấy trong code, dùng cái gọi là anonymous structure (cấu trúc vô danh)⁸³. Hoá ra ở nhiều chỗ bạn không cần đặt tên cho structure, và dùng với typedef là một trong những chỗ đó.

Làm lại ví dụ với anonymous structure:

//  Anonymous struct! It has no name!
//         |
//         v
//      |----|
typedef struct {
    char *name;
    int leg_count, speed;
} animal;                         // <-- new name

//struct animal y;  // ERROR: this no longer works--no such struct!
animal z;           // This works because "animal" is an alias

Một ví dụ khác, có thể gặp thứ kiểu như:

typedef struct {
    int x, y;
} point;

point p = {.x=20, .y=40};

printf("%d, %d\n", p.x, p.y);  // 20, 40

10.2.2 typedef và các kiểu khác

Không phải dùng typedef với một kiểu đơn giản như int là hoàn toàn vô ích, nó giúp bạn trừu tượng hoá các kiểu để dễ đổi sau này.

Ví dụ, nếu float rải khắp code của bạn ở 100 tỉ chỗ, sẽ rất đau đầu nếu đổi hết sang double khi sau này vì lý do nào đó bạn phải làm thế.

Nhưng nếu bạn chuẩn bị một chút:

typedef float app_float;

// and

app_float f1, f2, f3;

Thì sau này muốn đổi sang kiểu khác, chẳng hạn long double, bạn chỉ cần đổi typedef:

//        voila!
//      |---------|
typedef long double app_float;

// and no need to change this line:

app_float f1, f2, f3;  // Now these are all long doubles

10.2.3 typedef và con trỏ

Bạn có thể tạo một kiểu là con trỏ.

typedef int *intptr;

int a = 10;
intptr x = &a;  // "intptr" is type "int*"

Tôi rất không thích kiểu này. Nó giấu đi chuyện x là kiểu con trỏ vì bạn không thấy dấu * nào trong khai báo.

IMHO, tốt hơn là thể hiện rõ bạn đang khai báo kiểu con trỏ để các dev khác nhìn thấy rõ và không nhầm x là kiểu không phải con trỏ.

Nhưng lần đếm gần nhất thì có chừng 832.007 người không đồng ý với tôi.

10.2.4 typedef và cách viết hoa

Tôi đã thấy đủ loại cách viết hoa cho typedef.

typedef struct {
    int x, y;
} my_point;          // lower snake case

typedef struct {
    int x, y;
} MyPoint;          // CamelCase

typedef struct {
    int x, y;
} Mypoint;          // Leading uppercase

typedef struct {
    int x, y;
} MY_POINT;          // UPPER SNAKE CASE