1 Foreword

Cánh cửa từ từ kẽo kẹt mở ra, để lộ một hành lang dài với những chồng sách truyền thuyết phủ bụi…

Thôi, có lẽ không phải vậy đâu.

Nhưng bạn đã tìm ra phần Tham chiếu Thư viện (Library Reference) của Beej’s Guide to C!

Đây không phải một tutorial, mà là một bộ manual page đầy đủ (hay man page theo kiểu gọi của mấy dân Unix), định nghĩa mọi hàm trong Thư viện chuẩn C, kèm ví dụ.

“Thưa ngài, cuốn này chứa mọi chữ của thứ tiếng mà chúng ta yêu quý.”
“Từng chữ một, thưa ngài?”
“Từng chữ một, thưa ngài!”
“Ồ, vậy thì, thưa ngài, tôi mong ngài không phiền nếu tôi cũng gửi đến vị bác sĩ lời chúc phản-miếng-bánh-ngụm (contrafribularities) nồng nhiệt nhất của mình.”

—Blackadder trêu Tiến sĩ Samuel Johnson

Thực ra có một số hàm bị bỏ ngoài guide này, đáng chú ý nhất là mấy hàm “safe” tuỳ chọn (có hậu tố _s).

Nhưng mọi thứ bạn có thể muốn thì chắc chắn đều có ở đây. Kèm ví dụ.

Chắc vậy.

1.1 Đối tượng

Guide này dành cho người đã thạo C ở mức kha khá.

Nếu bạn chưa thuộc nhóm đó mà muốn trở thành, tôi xin hết lòng, hoàn toàn không thiên vị, giới thiệu cuốn Beej’s Guide to C Programming¹, có sẵn miễn phí ở bất cứ đâu Internet được bán.

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

Dùng mục lục hoặc index để tìm hàm hoặc chủ đề bạn cần.

Rồi lấy một tô ngũ cốc yêu thích ra, và chén thoải mái đống chữ nghĩa ngon lành trong đây.

1.3 Nền tảng và Compiler

Tôi sẽ cố bám vào ISO-standard C² cổ điển. Ừ, phần lớn là vậy. Thi thoảng tôi có thể nổi hứng nói về POSIX³ hay gì đó, để xem đã.

Unix (Linux, BSD, v.v.) thử gõ cc hoặc gcc ngoài command line, có thể bạn đã có sẵn compiler rồi. Nếu chưa, tìm cách cài gcc hoặc clang trên distro của bạn.

Windows thử Visual Studio Community⁴. Hoặc, nếu bạn muốn trải nghiệm kiểu Unix (khuyến khích!), cài WSL⁵ rồi cài gcc.

Mac thì cài XCode⁶, nhớ bật command line tools.

Có rất nhiều compiler, và hầu như cái nào cũng dùng được cho cuốn này. Và compiler C++ sẽ compile được khá nhiều code C (nhưng không phải tất cả!). Tốt nhất là dùng compiler C thực thụ nếu có.

1.4 Trang chủ chính thức

Địa chỉ chính thức của tài liệu này là https://beej.us/guide/bgclr/⁷. Trước đây ở đây có một ghi chú về việc di chuyển khỏi máy chủ ở Chico State (trường cũ của tôi), nhưng đó là chuyện tỷ năm trước rồi và câu chữ vẫn còn đây chỉ vì nó được copy từ Network Guide sang, [hít thở] mà tôi đã khá lâu rồi không đọc lại toàn bộ.

Hết chuyện.

1.5 Chính sách Email

Nói chung tôi luôn sẵn lòng giúp trả lời câu hỏi qua email, cứ viết thoải mái, nhưng tôi không đảm bảo sẽ trả lời. Tôi sống khá bận, có những lúc đơn giản là không trả lời nổi. Những lúc đó tôi thường xoá luôn tin nhắn. Không phải chuyện cá nhân gì đâu; chỉ là tôi không bao giờ đủ thời gian để đưa ra câu trả lời chi tiết mà bạn cần.

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

Nếu bạn không được trả lời, cứ cày thêm, thử tự tìm ra đáp án, và nếu nó vẫn lẩn trốn, hãy viết lại cho tôi với thông tin bạn đã thu thập được, và hy vọng chừng đó là đủ để tôi giúp được.

Giờ khi đã cằn nhằn bạn về cách nên và không nên viết thư cho tôi, tôi cũng muốn nói là tôi hết sức trân trọng mọi lời khen mà cuốn guide nhận được qua nhiều năm nay. Đó là một liều tinh thần thực sự, và tôi mừng khi biết nó đang được dùng cho mục đích tốt! :-) Cảm ơn nhé!

1.6 Mirror

Bạn hoàn toàn được hoan nghênh mirror trang này, dù công khai hay riêng tư. Nếu bạn mirror công khai và muốn tôi link tới từ trang chính, 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 guide sang ngôn ngữ khác, viết cho tôi ở beej@beej.us và tôi sẽ link tới bản dịch của bạn từ trang chính. Bạn có thể thêm tên và thông tin liên hệ của mình vào bản dịch.

Lưu ý các ràng buộc 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 Programming, Library Reference là Copyright © 2021 Brian “Beej Jorgensen” Hall.

Với một số ngoại lệ cụ thể cho source code và bản dịch (xem bên dưới), tác phẩm này được cấp phép theo Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 License. Để xem bản sao của giấy phép, vào 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ể đối với phần “No Derivative Works” của giấy phép là: guide này có thể được dịch tự do sang bất cứ ngôn ngữ nào, miễn là bản dịch chính xác và guide được in lại trọn vẹn. Các ràng buộc giấy phép áp dụng cho bản dịch giống như với bản gốc. Bản dịch cũng có thể kèm tên và thông tin liên hệ của người dịch.

Source code C xuất hiện trong tài liệu này được tuyên bố đưa vào public domain, hoàn toàn không bị ràng buộc giấy phép.

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

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

1.9 Lời đề tặng

Những chuyện khó nhất khi viết mấy cuốn guide này là:

• Học đủ sâu để có thể giải thích được
• Tìm ra cách giải thích sao cho rõ, một quá trình lặp đi lặp lại tưởng chừng vô tận
• Đặt mình ra đó như một cái gọi là chuyên gia, trong khi thực ra tôi chỉ là một con người bình thường đang cố hiểu mọi thứ, giống mọi người khác
• Giữ lửa với nó khi nhiều thứ khác cứ đòi sự chú ý của tôi

Rất nhiều người đã giúp tôi qua quá trình này, và tôi muốn ghi công những ai đã góp phần làm nên cuốn sách này.

• Mọi người trên Internet đã quyết định chia sẻ kiến thức của mình theo cách này hay cách khác. Việc chia sẻ kiến thức hướng dẫn một cách tự do chính là thứ làm nên một Internet tuyệt vời như ta thấy.
• Các tình nguyện viên ở cppreference.com⁸, những người xây cây cầu nối từ spec sang thực tế.
• Những người tốt bụng và hiểu biết ở comp.lang.c⁹ và r/C_Programming¹⁰, những người đã kéo tôi qua các phần khó của ngôn ngữ.
• Tất cả những ai đã gửi corrections và pull-request cho đủ thứ từ hướng dẫn gây hiểu lầm đến lỗi chính tả.

Cảm ơn! ♥

2 The C Language

Đây là bản tổng quan nhanh các điểm nhấn thời thượng và vui vẻ của cú pháp, keyword, và những “con thú” khác trong sở thú C.

2.1 Bối cảnh

Một vài thứ bạn cần để hiểu các ví dụ bên dưới.

2.1.1 Comment

Comment trong C bắt đầu bằng // và kéo đến cuối dòng.

Comment nhiều dòng bắt đầu bằng /* và kéo đến khi gặp */ đóng.

2.1.2 Dấu phân cách

Biểu thức trong C được phân cách bằng dấu chấm phẩy (;). Chúng thường xuất hiện ở cuối dòng.

2.1.3 Biểu thức

Nếu nó không phải keyword hay ký tự đặc biệt, khả năng nó là một biểu thức. Cứ nghĩ “toán học cộng thêm lời gọi hàm”.

2.1.4 Câu lệnh

Cứ nghĩ if, while, v.v. Các keyword thực thi.

2.1.5 Boolean

Bỏ qua kiểu bool, số không là false và khác không là true.

2.1.6 Block

Nhiều biểu thức và keyword điều khiển luồng có thể được gói trong một block, gồm { theo sau là một hay nhiều biểu thức hoặc câu lệnh, rồi }.

2.1.7 Ví dụ code

Chúng nhằm cho bạn hình dung cách dùng các câu lệnh khác nhau, chứ không phải liệt kê ví dụ toàn diện.

Trong các ví dụ dưới đây, nếu chỗ đó có thể là biểu thức hoặc câu lệnh, từ code được chèn vào.

2.2 Toán tử

2.2.1 Toán tử số học

Các toán tử số học: +, -, *, /, % (phần dư).

Phép chia là chia số nguyên nếu mọi toán hạng đều là số nguyên. Nếu không, kết quả là số thực.

Bạn cũng có thể đổi dấu một biểu thức bằng cách đặt - trước nó. (Bạn cũng có thể đặt + trước, việc này không làm gì về mặt toán học, nhưng nó khiến Usual Arithmetic Conversions được thực hiện trên biểu thức đó.)

2.2.2 Pre- và Post-Increment, Pre- và Post-Decrement

Toán tử post-increment (++) và post-decrement (--) (đặt sau biến) làm việc của chúng sau khi phần còn lại của biểu thức đã được tính.

int x = 10;
int y = 20;
int z = 30;

int w = (x++) + (y--) + (z++);

print("%d %d %d %d\n", x, y, z, w);  // 11 19 31 60

Toán tử pre-increment (++) và pre-decrement (--) (đặt trước biến) làm việc của chúng trước khi phần còn lại của biểu thức được tính.

int x = 10;
int y = 20;
int z = 30;

int w = (++x) + (--y) + (++z);

print("%d %d %d %d\n", x, y, z, w);  // 11 19 31 61

2.2.3 Toán tử so sánh

Tất cả đều trả về một giá trị true hoặc false kiểu Boolean.

Nhỏ hơn, lớn hơn, và bằng lần lượt là: <, >, ==.

Nhỏ hơn hoặc bằng và lớn hơn hoặc bằng là <= và >=.

Không bằng là !=.

2.2.4 Toán tử con trỏ

* đặt trước biến con trỏ dereference biến đó.

& đặt trước biến lấy địa chỉ của biến đó.

Các toán tử số học + và - cũng chạy trên con trỏ để làm số học con trỏ.

2.2.5 Toán tử cho Struct và Union

Toán tử dấu chấm (.) lấy giá trị một field từ struct hoặc union.

Toán tử mũi tên (->) lấy giá trị một field từ con trỏ tới struct hay union. Hai cách dưới đây tương đương nhau, giả sử p chính là loại con trỏ đó:

(*p).bar;
p->bar;

2.2.6 Toán tử mảng

Toán tử ngoặc vuông có thể tham chiếu một giá trị trong mảng:

a[10] = 99;

Đây là “syntactic sugar” bọc ngoài số học con trỏ và dereference. Dòng trên tương đương với:

*(a + 10) = 99;

2.2.7 Toán tử bit

Dịch bit phải: >>, dịch bit trái: <<.

int i = x << 3;  // dịch trái 3 bit

Việc dịch phải trên một giá trị có dấu có được mở rộng dấu hay không là implementation-defined.

Bitwise AND, OR, NOT, và XOR lần lượt là &, |, ~, và ^.

2.2.8 Toán tử gán

= đứng một mình là phép gán cơ bản.

Nhưng còn có các phép gán kết hợp, kiểu viết tắt. Ví dụ, hai dòng sau về cơ bản là tương đương:

x = x + 1;
x += 1;

Có các toán tử gán kết hợp cho phần lớn các toán tử khác.

Số học: +=, -=, *=, /=, và %=.

Bit: |=, &=, ~=, và ^=.

2.2.9 Toán tử sizeof

Đây là toán tử lúc compile, cho bạn kích thước tính bằng byte của kiểu của đối số. Kiểu của biểu thức được dùng; biểu thức không được đánh giá. sizeof làm việc với bất kỳ kiểu nào, kể cả kiểu hợp do người dùng định nghĩa.

Kiểu trả về là kiểu integer size_t.

float f;
size_t x = sizeof f;

printf("f is %zu bytes\n", x);

Bạn cũng có thể chỉ định trực tiếp tên kiểu bằng cách bọc nó trong ngoặc:

size_t x = sizeof(int);

printf("int is %zu bytes\n", x);

2.2.10 Type Cast

Bạn có thể ép một biểu thức sang kiểu khác (trong giới hạn hợp lý) bằng cách cast sang kiểu đó.

Bạn đặt tên kiểu mới trong ngoặc.

Ở đây ta đang ép biểu thức con x thành kiểu float ngay trước phép chia¹¹. Cái này làm cho phép chia, nếu không sẽ là chia số nguyên, trở thành chia số thực.

int x = 17;
int y = 2;

float f = (float)x / y;

2.2.11 Toán tử _Alignof

Bạn có thể lấy byte alignment của bất kỳ kiểu nào với toán tử compile-time _Alignof. Nếu bạn include <stdalign.h>, bạn có thể dùng alignof thay thế.

Bất kỳ kiểu nào cũng có thể là đối số của toán tử, và phải đặt trong ngoặc. Khác với sizeof, đối số không thể là biểu thức.

printf("Alignment of int is %zu\n", alignof(int));

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

Bạn có thể phân tách các biểu thức con bằng dấu phẩy, mỗi biểu thức sẽ được tính từ trái sang phải, và giá trị của toàn biểu thức sẽ là giá trị của biểu thức con đứng sau dấu phẩy cuối cùng.

int x = (1, 2, 3);  // Cách ngốc để gán `x = 3`

Thường thì cái này được dùng trong các mệnh đề của vòng lặp. Ví dụ, ta có thể gán nhiều lần trong vòng for, và có nhiều biểu thức post như thế này:

for (i = 2, j = 10; i < 100; i++, j += 4) { ... }

2.3 Type Specifier

Các kiểu integer từ nhỏ nhất đến lớn nhất: char, short, int, long, long long.

Bất kỳ kiểu integer nào cũng có thể có tiền tố signed (mặc định, trừ char) hoặc unsigned.

Việc char có dấu hay không là implementation-defined.

Các kiểu floating từ ít chính xác nhất đến nhiều nhất: float, double, long double.

void là kiểu biểu diễn “không có kiểu”.

_Bool là kiểu Boolean. Kiểu này thành bool trong C23. Các phiên bản C trước đó phải include <stdbool.h> để có bool.

_Complex chỉ một kiểu số phức floating, khi kết hợp với một kiểu đó. Include <complex.h> để dùng complex thay thế.

complex float x = 1.2 + 2.3*I;
complex double y = 1.2 + 2.3*I;

_Imaginary là keyword tuỳ chọn, dùng để chỉ một kiểu tưởng tượng (phần imaginary của một số phức) khi kết hợp với kiểu floating. Include <complex.h> để dùng imaginary thay thế. Cả GCC và clang đều không hỗ trợ cái này.

imaginary float f = 2.3*I;

_Generic là “cái chuyển kiểu”, cho phép bạn sinh ra code khác nhau lúc compile tuỳ vào kiểu của dữ liệu.

2.4 Kiểu hằng

Bạn có thể khai báo hằng với kiểu cụ thể (dù đôi khi nó là kiểu lớn hơn). Trong ví dụ dưới, với các kiểu không qualifier, hoa thường không quan trọng, và U có thể đứng trước hoặc sau L hoặc LL.

123              int hoặc lớn hơn
123L             long int hoặc lớn hơn
123LL            long long int

123U             unsigned int hoặc lớn hơn
123UL            unsigned long int hoặc lớn hơn
123ULL           unsigned long long int

123.4F           float
123.4            double
123.4L           long double

'a'              char
"hello, world"   char* (string)

Bạn cũng có thể chỉ định hằng ở cơ số khác:

123              thập phân
0x123            hexa
0123             bát phân

Bạn cũng có thể chỉ định hằng floating theo ký hiệu luỹ thừa cơ số 10:

1.2e3            1.2 x 10^3

Và bạn có thể chỉ định float ở hex! Chỉ có điều trong trường hợp này số mũ vẫn ở thập phân, còn cơ số là 2 thay vì 10:

0x1.2p3          0x1.2 x 2^3

2.5 Kiểu hợp

2.5.1 Kiểu struct

Bạn có thể dựng một kiểu hợp từ các kiểu khác bằng struct rồi khai báo biến có kiểu đó.

struct animal {
    char *name;
    int leg_count;
};

struct animal a;
struct animal b = {"goat", 4};
struct animal c = {.name="goat", .leg_count=4};

Truy cập bằng toán tử dấu chấm (.), hoặc nếu biến là con trỏ tới struct, bằng toán tử mũi tên (->).

struct animal *p = &b;  // b ở trên

printf("%d\n", b.leg_count);
printf("%d\n", p->leg_count);

2.5.2 Kiểu union

Chúng giống kiểu struct về cách dùng, chỉ khác là bạn chỉ dùng được một field tại một thời điểm. (Các field chia sẻ cùng vùng bộ nhớ.)

union dt {
    float distance;
    int time;
};

union dt a;
union dt b = {6};            // Khởi tạo "distance", field đầu
union dt c = {.distance=6};  // Khởi tạo "distance"
union dt d = {.time=6};      // Khởi tạo "time"

Truy cập bằng toán tử dấu chấm (.), hoặc nếu biến là con trỏ tới union, bằng toán tử mũi tên (->).

union dt *p = &b;

printf("%d\n", b.time);
printf("%d\n", p->time);

2.5.3 Kiểu enum

Cho bạn cách có kiểu để đặt tên cho các giá trị hằng integer. Chúng dùng được với switch(), hay làm kích thước mảng, hay ở bất cứ chỗ nào cần giá trị hằng.

Theo thông lệ, tên viết hoa.

enum animal {
    ANTELOPE,
    BADGER,
    CAT,
    DOG,
    ELEPHANT,
    FISH
};

enum animal a = CAT;

if (a == CAT)
    printf("The animal is a cat.\n");

Các tên có giá trị số bắt đầu từ 0 và đếm lên. (Trong ví dụ trên, DOG sẽ là 3.)

Có thể ghi đè giá trị số bằng cách chỉ định một số nguyên chính xác. Các giá trị sau tăng từ giá trị đã chỉ định đó.

enum animal {
    ANTELOPE = 4,
    BADGER,         // Sẽ là 5
    CAT,            // Sẽ là 6
    DOG = 3,
    ELEPHANT,       // Sẽ là 4
    FISH            // Sẽ là 5
};

Như trên, giá trị trùng không phải là bất hợp pháp, nhưng hữu dụng thì cũng chẳng bao.

2.6 Initializer

Bạn có thể làm vầy khi biến được định nghĩa, nhưng không được làm ở chỗ khác.

Khởi tạo các kiểu cơ bản:

int x = 12;
float y = 1.2;
char c = 'a';
char *s = "Hello, world!";

Khởi tạo các kiểu mảng:

int a[3] = {1,2,3};
int a[] = {1,2,3};   // Giống a[3]

int a[3] = {1, 2};   // Giống {1, 2, 0}
int a[3] = {1};      // Giống {1, 0, 0}
int a[3] = {0};      // Giống {0, 0, 0}

Khởi tạo các kiểu con trỏ:

int q;
int *p = &q;

Khởi tạo struct:

struct s {
    int a;
    float b;
};

struct s x0 = {1, 2.2}; // Khởi tạo các field theo thứ tự

struct s x0 = {.a=1, .b=2.2}; // Khởi tạo các field theo tên
struct s x0 = {.b=2.2, .a=1}; // Cùng ý nghĩa

struct s x0 = {.b=2.2}; // Các field còn lại được khởi tạo về 0
struct s x0 = {.b=2.2, .a-=0};  // Cùng ý nghĩa

Khởi tạo union:

union u {
    int a;
    float b;
};

union u x0 = {1};  // Khởi tạo field đầu tiên (a)

union u x0 = {.a=1};  // Khởi tạo field theo tên
union u x0 = {.b=2.2};

//union u x0 = {1, 2};       // BẤT HỢP PHÁP
//union u x0 = {.a=1, .b=2};  // BẤT HỢP PHÁP

2.7 Compound Literal

Bạn có thể khai báo object “không tên” trong C. Cái này thường hữu dụng khi truyền một struct cho hàm mà không cần đặt tên nó.

Bạn dùng tên kiểu trong ngoặc, theo sau là một initializer để tạo object.

Đây là ví dụ truyền một compound literal cho hàm. Chú ý không có biến struct s nào trong main():

#include <stdio.h>

struct s {
    int a, b;
};

int add(struct s x)
{
    return x.a + x.b;
}

int main(void)
{
    int t = add((struct s){.a=2, .b=4});  // <-- Đây

    printf("%d\n", t);
}

Compound literal có thời gian sống đúng bằng scope của chúng.

Bạn cũng có thể truyền con trỏ tới một compound literal bằng cách lấy địa chỉ của nó:

foo(&(struct s){1, 2});

2.8 Type Alias

Bạn có thể dựng type alias cho tiện hoặc để trừu tượng hoá.

Ở đây ta sẽ tạo kiểu mới tên time_counter, thực ra chỉ là int. Nó chỉ dùng được hệt như int. Nó chỉ là alias của int.

typedef int time_counter;

time_counter t = 3490;

Cũng chạy với struct hay union:

struct foo {
    int bar;
    float baz;
};

typedef struct foo funtype;

funtype f = {1, 2}; // "funtype" là alias của "struct foo";

Nó cũng chạy inline, với struct hay union có tên hoặc không tên:

typedef struct {
    int bar;
    float baz;
} funtype;

funtype f = {1, 2}; // "funtype" là alias cho struct không tên

2.9 Specifier khác liên quan đến kiểu

Bạn có thể cho compiler nhiều gợi ý hơn về tính chất mà một kiểu nên có thông qua các specifier và qualifier này.

2.9.1 Storage Class Specifier

Chúng có thể đặt trước một kiểu để chỉ dẫn thêm về cách dùng kiểu đó.

auto int a
register int a
static int a
extern int a
thread_local int a

auto là mặc định, nên về cơ bản chẳng ai dùng. Nó chỉ ra storage duration tự động (những thứ như biến local được tự động giải phóng khi hết scope). Trong C23 keyword này đổi nghĩa thành “suy luận kiểu” kiểu C++.

register chỉ ra rằng việc truy cập biến này nên càng nhanh càng tốt. Nó hạn chế một số cách dùng biến để compiler có cơ hội tối ưu. Ít gặp trong công việc hàng ngày.

static ở function scope chỉ ra giá trị biến này nên tồn tại qua các lần gọi. Ở file scope nó chỉ ra biến này không nên visible ngoài file nguồn này.

extern chỉ ra biến này tham chiếu tới một biến được khai báo ở file nguồn khác.

_Thread_local nghĩa là mỗi thread có bản copy riêng của biến này. Bạn có thể dùng thread_local nếu include <threads.h>.

2.9.2 Type Qualifier

Chúng có thể đặt trước một kiểu để chỉ dẫn thêm về cách dùng kiểu đó.

const int a
const int *p
int * const p
const int * const p
int * restrict p
volatile int a
atomic int a

const nghĩa là giá trị không được sửa. Bạn cũng có thể dùng với con trỏ:

const int a = 10;        // Không sửa được "a"

const int *p = &b        // Không sửa được thứ "p" trỏ tới ("b")
int *const p = &b        // Không sửa được "p"
const int *const p = &b  // Không sửa được cả "p" lẫn thứ nó trỏ tới

restrict trên con trỏ nghĩa là sẽ chỉ có một con trỏ trỏ tới item đó, cho compiler tự do hơn để tối ưu.

volatile chỉ ra giá trị trong biến có thể thay đổi bất cứ lúc nào, và nên được load từ bộ nhớ thay vì giữ trong register. Thường dùng với phần cứng memory-mapped.

_Atomic (hoặc atomic nếu bạn include <stdatomic.h>) bảo compiler rằng việc đọc hoặc ghi kiểu này phải xảy ra atomic. (Việc này có thể được thực hiện bằng lock, tuỳ platform và kiểu.)

2.9.2.1 Pseudo-Type có qualifier của C23: QVoid*, QChar*, v.v.

Trong C23 có một số hàm generic sẽ trả về kiểu đã được const-qualify nếu một trong các tham số là const, và không như vậy trong các trường hợp khác.

Spec tự chế một kiểu giả cho mục đích này, với chữ Q đằng trước (cho “qualified”). Đây không phải kiểu thật và sẽ không compile được, chỉ để làm tài liệu.

Các pseudo-type này là:

• QVoid *
• QChar *
• QWchar_t *

Ví dụ, hàm strchr(), tìm một ký tự trong chuỗi, có prototype thế này trong spec:

QChar *strchr(QChar *s, int c);

Nó là gì? Nó có nghĩa là nếu s có kiểu const char *, thì kiểu trả về của hàm cũng sẽ là const char *.

Nếu s chỉ là char *, thì kiểu trả về của hàm cũng chỉ là char *.

Nói cách khác, tính const của s được giữ nguyên ở giá trị trả về.

Nhìn kiểu khác, thì dòng này:

QChar *strchr(QChar *s, int c);

tương đương với:

char *strchr(char *s, int c);
const char *strchr(const char *s, int c);

Tóm lại khi bạn thấy cái này, bỏ Q đầu đi rồi đổi chữ tiếp theo thành chữ thường là xong.

2.9.3 Function Specifier

Được dùng trên hàm để chỉ dẫn thêm cho compiler.

_Noreturn chỉ ra rằng một hàm sẽ không bao giờ return. Nó chỉ có thể chạy mãi hoặc thoát hẳn chương trình. Nếu bạn include <stdnoreturn.h>, bạn có thể dùng noreturn thay thế.

inline chỉ ra rằng các lời gọi hàm này nên càng nhanh càng tốt. Ý định là code của hàm được dời inline để bỏ overhead của lời gọi và return. Compiler coi inline là gợi ý, không phải yêu cầu.

2.9.4 Alignment Specifier

Bạn có thể ép alignment của một biến trong bộ nhớ bằng _Alignas. Nếu bạn include <stdalign.h> bạn có thể dùng alignas thay thế.

alignas(0) không có tác dụng gì.

alignas(16) int a = 12;    // alignment 16-byte
alignas(long) int b = 34;  // cùng alignment với "long"

2.10 Câu lệnh if

if (boolean_expression) code;

if (boolean_expression) {
    code;
    code;
    code;
}

if (boolean_expression) {
    code;
    code;
} else
    code;

if (boolean_expression) {
    code;
    code;
} else if {
    code;
    code;
    code;
} else {
    code;
}

2.11 Câu lệnh for

Vòng for cổ điển.

Phần trong ngoặc gồm ba phần phân cách bằng dấu chấm phẩy:

• Khởi tạo, chạy một lần.
• Điều kiện vào block, được đánh giá trước mỗi lần vào thân vòng lặp.
• Biểu thức post, đánh giá sau mỗi lần chạy thân vòng lặp.

Ví dụ, khởi tạo i về 0, vào thân vòng lặp khi i < 10, và tăng i sau mỗi vòng lặp:

for (i = 0; i < 10; i++) {
    code;
    code;
    code;
}

Bạn có thể khai báo biến cục bộ trong vòng lặp bằng cách chỉ định kiểu:

for (int i = 0; i < 10; i++) {
    code;
    code;
}

Bạn có thể phân tách các phần của biểu thức bằng toán tử dấu phẩy:

for (i = 0, j = 5; i < 10; i++, j *= 3) {
    code;
    code;
}

2.12 Câu lệnh while

Vòng lặp này sẽ không vào nếu biểu thức Boolean là false. Kiểm tra điều kiện tiếp tục xảy ra trước thân vòng lặp.

while (boolean_expression) code;

while (boolean_expression) {
    code;
    code;
}

2.13 Câu lệnh do-while

Vòng lặp này sẽ chạy ít nhất một lần ngay cả khi biểu thức Boolean là false. Kiểm tra điều kiện tiếp tục không xảy ra cho đến sau thân vòng lặp.

do code while (boolean_expression);

do {
    code;
    code;
} while (boolean_expression);

2.14 Câu lệnh switch

Thực hiện hành động dựa trên giá trị của một biểu thức. Các case so khớp phải là giá trị hằng.

Nếu có default tuỳ chọn, code đó được chạy khi không case nào khớp. Không bắt buộc có ngoặc nhọn quanh các case.

switch (expression) {
    case constant:
        code;
        code;
        break;

    case constant:
        code;
        code;
        break;

    default:
        code;
        break;
}

break cuối trong switch là không cần thiết nếu không còn case nào sau nó.

Nếu break không có, case rơi qua case kế tiếp. Nên ghi comment cho chuyện đó để các dev khác không ghét bạn.

switch (expression) {
    case constant:
        code;
        code;
        // fall through!

    case constant:
        code;
        break;
}

2.15 Câu lệnh break

Lệnh này thoát khỏi một case trong switch, nhưng cũng có thể thoát khỏi bất kỳ vòng lặp nào.

while (boolean_expression) {
    code;

    if (boolean_expression)
        break;

    code;
}

2.16 Câu lệnh continue

Có thể dùng để short-circuit một vòng lặp và đi tới kiểm tra điều kiện tiếp theo mà không hoàn tất thân vòng lặp.

while (boolean_expression) {
    code;
    code;

    if (boolean_expression_2)
        continue;

    // Nếu boolean_expression_2, code dưới đây sẽ bị bỏ qua:

    code;
    code;
}

2.17 Câu lệnh goto

Bạn có thể nhảy đến bất kỳ đâu trong một hàm bằng goto. (Bạn không thể goto giữa các hàm, chỉ trong cùng hàm với goto.)

Đích của goto là một label, là một identifier theo sau là dấu hai chấm (:). Label thường được canh sát lề trái để dễ nhìn.

{
    // Code minh hoạ kiểu lạm dụng mà đáng lẽ phải là vòng while

    int i = 0;

loop:

    printf("%d\n", i++);

    if (i < 10)
        goto loop;
}

2.18 Câu lệnh return

Đây là cách bạn về từ một hàm. Bạn có thể return nhiều lần hoặc chỉ một lần.

Nếu một hàm kiểu trả về void chạy hết, return là ngầm định.

Nếu kiểu trả về không phải void, câu lệnh return phải chỉ định giá trị trả về cùng kiểu.

Không cần ngoặc quanh giá trị return (vì đây là câu lệnh, không phải hàm).

int increment(int a)
{
    return a + 1;
}

2.19 Câu lệnh _Static_assert

Đây là cách ngăn compilation một chương trình nếu một điều kiện hằng nào đó không thoả.

_Static_assert(__STDC_VERSION__ >= 201112L, "You need at least C11!")

2.20 Hàm

Bạn cần chỉ định kiểu trả về và kiểu tham số cho hàm, thân hàm đặt trong block sau đó.

Biến trong hàm là local với hàm đó.

// Hàm cộng hai số

int add(int x, int y)
{
    int sum = x + y;

    return sum;
}

Hàm không return gì nên có kiểu trả về void. Hàm không nhận tham số nên có void làm danh sách tham số.

// Toàn tác dụng phụ, mọi lúc!

void foo(void)
{
    some_global = 12;
    printf("Here we go!\n");
}

2.20.1 Hàm main()

Đây là hàm chạy khi bạn bắt đầu chương trình. Nó sẽ ở một trong các dạng sau:

int main(void)
int main(int argc, char *argv[])

Dạng đầu bỏ qua mọi tham số command line.

Dạng thứ hai lưu số lượng tham số command line vào argc, và lưu chính các tham số đó thành mảng chuỗi trong argv. Cái đầu tiên, argv[0], thường là tên của file thực thi. Con trỏ argv cuối cùng có giá trị NULL.

Giá trị trả về thường xuất hiện thành exit status code trong OS. Nếu không có return, chạy hết main() được ngầm coi là return 0¹².

2.20.2 Hàm Variadic

Một số hàm có thể nhận số lượng tham số biến đổi. Mọi hàm đều phải có ít nhất một tham số. Các tham số còn lại được chỉ định bằng ... và có thể đọc qua các macro va_start(), va_arg(), và va_end().

Đây là ví dụ cộng số lượng biến đổi các giá trị integer.

int add(int count, ...)
{
    int total = 0;
    va_list va;

    va_start(va, count);   // Bắt đầu với tham số sau "count"

    for (int i = 0; i < count; i++) {
        int n = va_arg(va, int);   // Lấy int kế tiếp

        total += n;
    }

    va_end(va);  // Xong

    return total;
}

3 <assert.h> Runtime and Compile-time Diagnostics

Chức năng này liên quan tới những thứ Không-Bao-Giờ-Nên-Xảy-Ra™. Nếu có điều gì đó lẽ ra không bao giờ đúng và bạn muốn chương trình nổ tung khi nó xảy ra, đây là header dành cho bạn.

Có hai loại assertion: assertion lúc compile (gọi là “static assertion”) và assertion lúc chạy (runtime). Nếu assertion thất bại (nghĩa là thứ bạn cần đúng thì hoá ra không đúng), chương trình sẽ nổ tung ở compile-time hoặc runtime.

3.1 Macro

Nếu bạn define macro NDEBUG trước khi include <assert.h>, macro assert() sẽ không còn tác dụng. Bạn có thể define NDEBUG thành bất cứ thứ gì, nhưng 1 có vẻ là giá trị hợp lý.

Vì assert() làm chương trình nổ tung lúc chạy, chắc là bạn không muốn hành vi đó khi lên production. Define NDEBUG sẽ khiến assert() bị bỏ qua.

NDEBUG không ảnh hưởng tới static_assert().

3.2 assert()

Nổ tung lúc chạy nếu một điều kiện thất bại

Synopsis

#include <assert.h>

void assert(scalar expression);

Mô tả

Bạn truyền một biểu thức vào macro này. Nếu nó đánh giá ra false, chương trình sẽ crash với assertion failure (bằng cách gọi hàm abort()).

Về cơ bản, bạn đang nói, “Này, tôi đang giả định điều kiện này là true, và nếu không phải vậy, tôi không muốn chạy tiếp nữa.”

Cái này được dùng khi debug để đảm bảo không có điều kiện bất ngờ nào phát sinh. Và nếu trong quá trình phát triển bạn thấy điều kiện đó có phát sinh thật, có thể bạn nên sửa code để xử lý nó trước khi lên production.

Nếu bạn đã define macro NDEBUG thành bất kỳ giá trị nào trước khi <assert.h> được include, macro assert() sẽ bị bỏ qua. Đây là ý hay trước khi ra production.

Khác với static_assert(), macro này không cho bạn in một thông báo tuỳ ý. Nếu bạn muốn làm vậy, có thể tự viết một assert riêng dạng preprocessor macro:

#define ASSERT(c, m) \
do { \
    if (!(c)) { \
        fprintf(stderr, __FILE__ ":%d: assertion %s failed: %s\n", \
                        __LINE__, #c, m); \
        exit(1); \
    } \
} while(0)

Giá trị trả về

Macro này không return (vì nó gọi abort(), không bao giờ return).

Nếu NDEBUG được set, macro đánh giá ra ((void)0), không làm gì cả.

Ví dụ

Đây là hàm chia kích thước đàn dê của ta. Nhưng ta giả định sẽ không bao giờ bị truyền 0 vào.

Nên ta assert amount != 0… và nếu có, chương trình abort.

//#define NDEBUG 1   // bỏ comment để tắt assert

#include <stdio.h>
#include <assert.h>

int goat_count = 10;

void divide_goat_herd_by(int amount)
{
    assert(amount != 0);

    goat_count /= amount;
}  

int main(void)
{
    divide_goat_herd_by(2);  // OK

    divide_goat_herd_by(0);  // Kích hoạt assert
}

Khi tôi chạy và truyền 0 cho hàm, tôi nhận được output sau trên hệ của tôi (output cụ thể có thể khác):

assert: assert.c:10: divide_goat_herd_by: Assertion `amount != 0' failed.

Xem thêm

static_assert(), abort()

3.3 static_assert()

Nổ tung lúc compile nếu một điều kiện thất bại

Synopsis

#include <assert.h>

static_assert(constant-expression, string-literal);

Mô tả

Macro này ngăn chương trình của bạn được compile luôn nếu một điều kiện không đúng.

Và nó in ra string literal bạn đưa cho nó.

Cơ bản là nếu constant-expression là false, việc compile sẽ dừng và string-literal sẽ được in ra.

Constant expression phải thực sự là hằng, chỉ giá trị, không biến. String literal cũng vậy: không biến, chỉ là literal string đặt trong dấu ngoặc kép. (Phải như vậy vì chương trình chưa chạy ở thời điểm này.)

Giá trị trả về

Không áp dụng, vì đây là chức năng compile-time.

Ví dụ

Đây là một ví dụ phần, với một thuật toán mà hiệu năng hay bộ nhớ chắc là tệ nếu kích thước mảng local quá lớn. Ta phòng trường hợp đó ngay lúc compile bằng cách bắt nó với static_assert().

#include <stdio.h>
#include <assert.h>

#define ARRAY_SIZE 16

int main(void)
{
    static_assert(ARRAY_SIZE > 32, "ARRAY_SIZE too small");

    int a[ARRAY_SIZE];

    a[32] = 10;

    printf("%d\n", a[32]);
}

Trên hệ của tôi, khi tôi cố compile, nó in ra (output có thể khác trên hệ khác):

In file included from static_assert.c:2:
static_assert.c: In function ‘main’:
static_assert.c:8:5: error: static assertion failed: "ARRAY_SIZE too small"
    8 |     static_assert(ARRAY_SIZE > 32, "ARRAY_SIZE too small");
      |     ^~~~~~~~~~~~~

Xem thêm

assert()

4 <complex.h> Chức năng Số phức

Các hàm số phức trong phần tham chiếu này đều có ba phiên bản: double complex, float complex, và long double complex.

Biến thể float kết thúc bằng f còn biến thể long double kết thúc bằng l, ví dụ với cosine của số phức:

ccos()   double complex
ccosf()  float complex
ccosl()  long double complex

Bảng dưới chỉ liệt kê phiên bản double complex cho gọn.

Bạn có thể kiểm tra hỗ trợ số phức bằng cách xem macro __STDC_NO_COMPLEX__. Nếu nó được định nghĩa, tức là số phức không có sẵn.

Có thể có hai loại số được định nghĩa: complex và imaginary. Hiện tôi không biết hệ thống nào hiện thực kiểu imaginary cả.

Các kiểu complex, tức một giá trị thực cộng với bội của \(i\), là:

float complex
double complex
long double complex

Các kiểu imaginary, tức chỉ chứa bội của \(i\), là:

float imaginary
double imaginary
long double imaginary

Giá trị toán học \(i=\sqrt{-1}\) được biểu diễn bằng ký hiệu _Complex_I hoặc _Imaginary_I, nếu có.

Macro I sẽ được ưu tiên đặt thành _Imaginary_I (nếu có), hoặc là _Complex_I nếu không.

Bạn có thể viết literal ảo (nếu được hỗ trợ) theo cú pháp này:

double imaginary x = 3.4 * I;

Bạn có thể viết literal phức bằng ký pháp phức thông thường:

double complex x = 1.2 + 3.4 * I;

hoặc dựng chúng bằng macro CMPLX():

double complex x = CMPLX(1.2, 3.4);  // Giống 1.2 + 3.4 * I

Cách sau có lợi thế là xử lý đúng các trường hợp đặc biệt của số phức (như những trường hợp dính vô cùng hoặc số không có dấu) như thể _Imaginary_I đang có mặt, dù thực ra không có.

Mọi giá trị góc đều tính bằng radian.

Một số hàm có các điểm gián đoạn gọi là branch cut (nhát cắt nhánh). Thú thật tôi không phải dân toán nên không bàn nghiêm túc về chuyện này được, nhưng nếu bạn đang ở đây thì tôi tin bạn biết mình đang làm gì ở mảng này.

Nếu hệ của bạn có số không có dấu, bạn có thể biết mình đang ở phía nào của nhát cắt dựa vào dấu. Còn nếu không có thì chịu. Spec viết thêm:

Những hiện thực không hỗ trợ số không có dấu […] không thể phân biệt hai phía của nhát cắt nhánh. Các hiện thực này phải ánh xạ nhát cắt sao cho hàm liên tục khi tiếp cận nhát cắt đi quanh điểm đầu hữu hạn của nhát cắt theo chiều ngược kim đồng hồ. (Các nhát cắt nhánh cho những hàm ở đây đều chỉ có một điểm đầu hữu hạn.) Ví dụ, với hàm căn bậc hai, đi ngược kim đồng hồ quanh điểm đầu hữu hạn của nhát cắt dọc theo trục thực âm thì tiếp cận nhát cắt từ phía trên, vậy nên nhát cắt ánh xạ vào trục ảo dương.

Cuối cùng, có một pragma tên CX_LIMITED_RANGE có thể bật/tắt (mặc định là tắt). Bạn bật nó như thế này:

#pragma STDC CX_LIMITED_RANGE ON

Nó cho phép một số phép toán trung gian được tràn dưới, tràn trên, hoặc xử lý lỏng tay với vô cùng, đại khái là đánh đổi lấy tốc độ. Nếu bạn chắc chắn những lỗi kiểu đó không xảy ra với các số bạn đang dùng VÀ bạn đang cố vắt kiệt tốc độ, bạn có thể bật macro này lên.

Spec cũng viết thêm:

Mục đích của pragma là cho phép hiện thực dùng các công thức:

\((x+iy)\times(u+iv) = (xu-yv)+i(yu+xv)\)

\((x+iy)/(u+iv) = [(xu+yv)+i(yu-xv)]/(u^2+v^2)\)

\(|x+iy|=\sqrt{x^2+y^2}\)

khi lập trình viên xác định được là chúng an toàn.

4.1 cacos(), cacosf(), cacosl()

Tính arc-cosine phức

Synopsis

#include <complex.h>

double complex cacos(double complex z);

float complex cacosf(float complex z);

long double complex cacosl(long double complex z);

Mô tả

Tính arc-cosine phức của một số phức.

Số phức z sẽ có phần ảo trong khoảng \([0,\pi]\), còn phần thực không bị chặn.

Có các nhát cắt nhánh nằm ngoài khoảng \([-1,+1]\) trên trục thực.

Giá trị trả về

Trả về arc-cosine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = cacos(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 0.195321 + -2.788006i

Xem thêm

ccos(), casin(), catan()

4.2 casin(), casinf(), casinl()

Tính arc-sine phức

Synopsis

#include <complex.h>

double complex casin(double complex z);

float complex casinf(float complex z);

long double complex casinl(long double complex z);

Mô tả

Tính arc-sine phức của một số phức.

Số phức z sẽ có phần ảo trong khoảng \([-\pi/2,+\pi/2]\), còn phần thực không bị chặn.

Có các nhát cắt nhánh nằm ngoài khoảng \([-1,+1]\) trên trục thực.

Giá trị trả về

Trả về arc-sine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = casin(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.375476 + 2.788006i

Xem thêm

csin(), cacos(), catan()

4.3 catan(), catanf(), catanl()

Tính arc-tangent phức

Synopsis

#include <complex.h>

double complex catan(double complex z);

float complex catanf(float complex z);

long double complex catanl(long double complex z);

Mô tả

Tính arc-tangent phức của một số phức.

Số phức z sẽ có phần thực trong khoảng \([-\pi/2,+\pi/2]\), còn phần ảo không bị chặn.

Có các nhát cắt nhánh nằm ngoài khoảng \([-i,+i]\) trên trục ảo.

Giá trị trả về

Trả về arc-tangent phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double wheat = 8;
    double sheep = 1.5708;

    double complex x = wheat + sheep * I;

    double complex y = catan(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.450947 + 0.023299i

Xem thêm

ctan(), cacos(), casin()

4.4 ccos(), ccosf(), ccosl()

Tính cosine phức

Synopsis

#include <complex.h>

double complex ccos(double complex z);

float complex ccosf(float complex z);

long double complex ccosl(long double complex z);

Mô tả

Tính cosine phức của một số phức.

Giá trị trả về

Trả về cosine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = ccos(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: -0.365087 + -2.276818i

Xem thêm

csin(), ctan(), cacos()

4.5 csin(), csinf(), csinl()

Tính sine phức

Synopsis

#include <complex.h>

double complex csin(double complex z);

float complex csinf(float complex z);

long double complex csinl(long double complex z);

Mô tả

Tính sine phức của một số phức.

Giá trị trả về

Trả về sine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = csin(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 2.482485 + -0.334840i

Xem thêm

ccos(), ctan(), casin()

4.6 ctan(), ctanf(), ctanl()

Tính tangent phức

Synopsis

#include <complex.h>

double complex ctan(double complex z);

float complex ctanf(float complex z);

long double complex ctanl(long double complex z);

Mô tả

Tính tangent phức của một số phức.

Giá trị trả về

Trả về tangent phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = ctan(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: -0.027073 + 1.085990i

Xem thêm

ccos(), csin(), catan()

4.7 cacosh(), cacoshf(), cacoshl()

Tính arc hyperbolic cosine phức

Synopsis

#include <complex.h>

double complex cacosh(double complex z);

float complex cacoshf(float complex z);

long double complex cacoshl(long double complex z);

Mô tả

Tính arc hyperbolic cosine phức của một số phức.

Có một nhát cắt nhánh tại các giá trị nhỏ hơn \(1\) trên trục thực.

Giá trị trả về sẽ không âm trên trục số thực, và nằm trong khoảng \([-i\pi,+i\pi]\) trên trục ảo.

Giá trị trả về

Trả về arc hyperbolic cosine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = cacosh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 2.788006 + 0.195321i

Xem thêm

casinh(), catanh(), acosh()

4.8 casinh(), casinhf(), casinhl()

Tính arc hyperbolic sine phức

Synopsis

#include <complex.h>

double complex casinh(double complex z);

float complex casinhf(float complex z);

long double complex casinhl(long double complex z);

Mô tả

Tính arc hyperbolic sine phức của một số phức.

Có các nhát cắt nhánh nằm ngoài \([-i,+i]\) trên trục ảo.

Giá trị trả về không bị chặn trên trục số thực, và nằm trong khoảng \([-i\pi/2,+i\pi/2]\) trên trục ảo.

Giá trị trả về

Trả về arc hyperbolic sine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = casinh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 2.794970 + 0.192476i

Xem thêm

cacosh(), catanh(), asinh()

4.9 catanh(), catanhf(), catanhl()

Tính arc hyperbolic tangent phức

Synopsis

#include <complex.h>

double complex catanh(double complex z);

float complex catanhf(float complex z);

long double complex catanhl(long double complex z);

Mô tả

Tính arc hyperbolic tangent phức của một số phức.

Có các nhát cắt nhánh nằm ngoài \([-1,+1]\) trên trục thực.

Giá trị trả về không bị chặn trên trục số thực, và nằm trong khoảng \([-i\pi/2,+i\pi/2]\) trên trục ảo.

Giá trị trả về

Trả về arc hyperbolic tangent phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = catanh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 0.120877 + 1.546821i

Xem thêm

cacosh(), casinh(), atanh()

4.10 ccosh(), ccoshf(), ccoshl()

Tính hyperbolic cosine phức

Synopsis

#include <complex.h>

double complex ccosh(double complex z);

float complex ccoshf(float complex z);

long double complex ccoshl(long double complex z);

Mô tả

Tính hyperbolic cosine phức của một số phức.

Giá trị trả về

Trả về hyperbolic cosine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = ccosh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: -0.005475 + 1490.478826i

Xem thêm

csinh(), ctanh(), ccos()

4.11 csinh(), csinhf(), csinhl()

Tính hyperbolic sine phức

Synopsis

#include <complex.h>

double complex csinh(double complex z);

float complex csinhf(float complex z);

long double complex csinhl(long double complex z);

Mô tả

Tính hyperbolic sine phức của một số phức.

Giá trị trả về

Trả về hyperbolic sine phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = csinh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: -0.005475 + 1490.479161i

Xem thêm

ccosh(), ctanh(), csin()

4.12 ctanh(), ctanhf(), ctanhl()

Tính hyperbolic tangent phức

Synopsis

#include <complex.h>

double complex ctanh(double complex z);

float complex ctanhf(float complex z);

long double complex ctanhl(long double complex z);

Mô tả

Tính hyperbolic tangent phức của một số phức.

Giá trị trả về

Trả về hyperbolic tangent phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 8 + 1.5708 * I;

    double complex y = ctanh(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.000000 + -0.000000i

Xem thêm

ccosh(), csinh(), ctan()

4.13 cexp(), cexpf(), cexpl()

Tính hàm mũ cơ số \(e\) phức

Synopsis

#include <complex.h>

double complex cexp(double complex z);

float complex cexpf(float complex z);

long double complex cexpl(long double complex z);

Mô tả

Tính hàm mũ cơ số \(e\) phức của z.

Giá trị trả về

Trả về hàm mũ cơ số \(e\) phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = cexp(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: -1.131204 + 2.471727i

Xem thêm

cpow(), clog(), exp()

4.14 clog(), clogf(), clogl()

Tính logarithm phức

Synopsis

#include <complex.h>

double complex clog(double complex z);

float complex clogf(float complex z);

long double complex clogl(long double complex z);

Mô tả

Tính logarithm cơ số \(e\) phức của z. Có một nhát cắt nhánh trên trục thực âm.

Giá trị trả về không bị chặn trên trục thực và nằm trong khoảng \([-i\pi,+i\pi]\) trên trục ảo.

Giá trị trả về

Trả về logarithm cơ số \(e\) phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = clog(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 0.804719 + 1.107149i

Xem thêm

cexp(), log()

4.15 cabs(), cabsf(), cabsl()

Tính giá trị tuyệt đối phức

Synopsis

#include <complex.h>

double cabs(double complex z);

float cabsf(float complex z);

long double cabsl(long double complex z);

Mô tả

Tính giá trị tuyệt đối phức của z.

Giá trị trả về

Trả về giá trị tuyệt đối phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = cabs(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 2.236068 + 0.000000i

Xem thêm

fabs(), abs()

4.16 cpow(), cpowf(), cpowl()

Tính luỹ thừa phức

Synopsis

#include <complex.h>

double complex cpow(double complex x, double complex y);

float complex cpowf(float complex x, float complex y);

long double complex cpowl(long double complex x,
                          long double complex y);

Mô tả

Tính \(x^y\) phức.

Có một nhát cắt nhánh cho x dọc theo trục thực âm.

Giá trị trả về

Trả về \(x^y\) phức.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;
    double complex y = 3 + 4 * I;

    double r = cpow(x, y);

    printf("Result: %f + %fi\n", creal(r), cimag(r));
}

Result:

Result: 0.129010 + 0.000000i

Xem thêm

csqrt(), cexp()

4.17 csqrt(), csqrtf(), csqrtl()

Tính căn bậc hai phức

Synopsis

#include <complex.h>

double complex csqrt(double complex z);

float complex csqrtf(float complex z);

long double complex csqrtl(long double complex z);

Mô tả

Tính căn bậc hai phức của z.

Có một nhát cắt nhánh dọc theo trục thực âm.

Giá trị trả về nằm ở nửa phải của mặt phẳng phức và bao gồm cả trục ảo.

Giá trị trả về

Trả về căn bậc hai phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = csqrt(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.272020 + 0.786151i

Xem thêm

cpow(), sqrt()

4.18 carg(), cargf(), cargl()

Tính argument phức

Synopsis

#include <complex.h>

double carg(double complex z);

float cargf(float complex z);

long double cargl(long double complex z);

Mô tả

Tính argument phức (còn gọi là góc pha) của z.

Có một nhát cắt nhánh dọc theo trục thực âm.

Trả về giá trị trong khoảng \([-\pi,+\pi]\).

Giá trị trả về

Trả về argument phức của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double y = carg(x);

    printf("Result: %f\n", y);
}

Output:

Result: 1.107149

4.19 cimag(), cimagf(), cimagl()

Trả về phần ảo của một số phức

Synopsis

#include <complex.h>

double cimag(double complex z);

float cimagf(float complex z);

long double cimagl(long double complex z);

Mô tả

Trả về phần ảo của z.

Nói ngoài lề, spec chỉ ra rằng bất kỳ số phức x nào cũng tuân theo đẳng thức sau:

x == creal(x) + cimag(x) * I;

Giá trị trả về

Trả về phần ảo của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double y = cimag(x);

    printf("Result: %f\n", y);
}

Output—chỉ phần ảo:

Result: 2.000000

Xem thêm

creal()

4.20 CMPLX(), CMPLXF(), CMPLXL()

Dựng một giá trị phức từ kiểu thực và ảo

Synopsis

#include <complex.h>

double complex CMPLX(double x, double y);

float complex CMPLXF(float x, float y);

long double complex CMPLXL(long double x, long double y);

Mô tả

Các macro này dựng một giá trị phức từ các kiểu thực và ảo.

Chắc là bạn đang nghĩ, “Nhưng tôi đã có thể dựng giá trị phức từ kiểu thực và ảo bằng macro I rồi mà, như trong ví dụ sắp tới.”

double complex x = 1 + 2 * I;

Và điều đó đúng.

Nhưng thực tế vấn đề lạ và phức.

Có thể I đã bị undefine, hoặc có thể bạn đã redefine nó.

Hoặc có thể I được định nghĩa là _Complex_I, thứ không nhất thiết giữ được dấu của giá trị không.

Như spec chỉ ra, các macro này dựng số phức như thể _Imaginary_I đang có mặt (nhờ đó giữ được dấu không của bạn) ngay cả khi nó không có. Cụ thể, chúng được định nghĩa tương đương với:

#define CMPLX(x, y)  ((double complex)((double)(x) + \
                     _Imaginary_I * (double)(y)))

#define CMPLXF(x, y) ((float complex)((float)(x) + \
                     _Imaginary_I * (float)(y)))

#define CMPLXL(x, y) ((long double complex)((long double)(x) + \
                     _Imaginary_I * (long double)(y)))

Giá trị trả về

Trả về số phức cho các phần thực x và ảo y đã cho.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = CMPLX(1, 2);  // Giống 1 + 2 * I

    printf("Result: %f + %fi\n", creal(x), cimag(x));
}

Output:

Result: 1.000000 + 2.000000i

Xem thêm

creal(), cimag()

4.21 conj(), conjf(), conjl()

Tính liên hợp của một số phức

Synopsis

#include <complex.h>

double complex conj(double complex z);

float complex conjf(float complex z);

long double complex conjl(long double complex z);

Mô tả

Hàm này tính liên hợp phức¹³ của z. Hình như nó làm vậy bằng cách đảo dấu phần ảo, nhưng trời ạ, tôi là lập trình viên chứ không phải dân toán, Jim ơi!

Giá trị trả về

Trả về liên hợp phức của z

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = conj(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.000000 + -2.000000i

4.22 cproj(), cproj(), cproj()

Tính phép chiếu của một số phức

Synopsis

#include <complex.h>

double complex cproj(double complex z);

float complex cprojf(float complex z);

long double complex cprojl(long double complex z);

Mô tả

Tính phép chiếu của z lên một mặt cầu Riemann¹⁴.

Giờ thì thực sự ngoài vùng chuyên môn của tôi rồi. Spec viết thế này, tôi trích nguyên văn vì không đủ hiểu biết để viết lại cho gọn. Mong là nó hiểu được với ai cần dùng hàm này.

z chiếu thành z trừ khi mọi vô cùng phức (kể cả những vô cùng có một phần vô cùng và một phần NaN) đều chiếu thành vô cùng dương trên trục thực. Nếu z có phần vô cùng, thì cproj(z) tương đương với

INFINITY + I * copysign(0.0, cimag(z))

Đấy, có vậy thôi.

Giá trị trả về

Trả về phép chiếu của z lên một mặt cầu Riemann.

Ví dụ

Bắt chéo ngón tay cầu cho ví dụ này có tí hợp lý…

#include <stdio.h>
#include <complex.h>
#include <math.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double complex y = cproj(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));

    x = INFINITY + 2 * I;
    y = cproj(x);

    printf("Result: %f + %fi\n", creal(y), cimag(y));
}

Output:

Result: 1.000000 + 2.000000i
Result: inf + 0.000000i

4.23 creal(), crealf(), creall()

Trả về phần thực của một số phức

Synopsis

#include <complex.h>

double creal(double complex z);

float crealf(float complex z);

long double creall(long double complex z);

Mô tả

Trả về phần thực của z.

Nói ngoài lề, spec chỉ ra rằng bất kỳ số phức x nào cũng tuân theo đẳng thức sau:

x == creal(x) + cimag(x) * I;

Giá trị trả về

Trả về phần thực của z.

Ví dụ

#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex x = 1 + 2 * I;

    double y = creal(x);

    printf("Result: %f\n", y);
}

Output—chỉ phần thực:

Result: 1.000000

Xem thêm

cimag()

5 <ctype.h> Phân loại và Chuyển đổi Ký tự

Bộ macro này tiện để kiểm tra xem một ký tự có thuộc một nhóm nào đó không, chẳng hạn chữ cái, chữ số, ký tự điều khiển, v.v.

Đáng ngạc nhiên là chúng nhận tham số int thay vì kiểu char nào đó. Lý do là để bạn tiện nhét EOF vào nếu có biểu diễn int của nó. Nếu không phải EOF, giá trị truyền vào phải biểu diễn được bằng unsigned char. Ngược lại thì (tèn tèn TÈÈÈN) undefined behavior. Cho nên quên việc nhét ký tự UTF-8 nhiều byte vào đây đi.

Bạn có thể tránh undefined behavior này kiểu portable bằng cách ép kiểu các đối số của những hàm này thành (unsigned char). Công nhận nghe phiền và xấu. Các giá trị trong basic character set đều dùng được an toàn vì chúng là giá trị dương vừa vặn trong unsigned char.

Ngoài ra, hành vi của những hàm này cũng thay đổi theo locale.

Trong nhiều trang ở section này, tôi có kèm vài ví dụ. Chúng chạy ở locale “C”, và có thể khác đi nếu bạn đã đặt locale khác.

Chú ý là ký tự rộng (wide character) có bộ hàm phân loại riêng của nó, nên đừng có thử dùng mấy hàm này trên wchar_t. Nghe không thì biết tay!

5.1 isalnum()

Kiểm tra ký tự có là chữ cái hoặc chữ số

Synopsis

#include <ctype.h>

int isalnum(int c);

Mô tả

Kiểm tra xem ký tự có là chữ cái (A-Z hoặc a-z) hoặc chữ số (0-9).

Tương đương với:

isalpha(c) || isdigit(c)

Giá trị trả về

Trả về true nếu ký tự là chữ cái (A-Z hoặc a-z) hoặc chữ số (0-9).

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isalnum('a')? "yes": "no");  // yes
    printf("%s\n", isalnum('B')? "yes": "no");  // yes
    printf("%s\n", isalnum('5')? "yes": "no");  // yes
    printf("%s\n", isalnum('?')? "yes": "no");  // no
}

Xem thêm

isalpha(), isdigit()

5.2 isalpha()

Trả về true nếu ký tự là chữ cái

Synopsis

#include <ctype.h>

int isalpha(int c);

Mô tả

Trả về true cho các ký tự chữ cái (A-Z hoặc a-z).

Về mặt kỹ thuật (và ở locale “C”) tương đương với:

isupper(c) || islower(c)

Cực kỳ siêu kỹ thuật, vì tôi biết bạn đang khát khao đoạn này phức tạp một cách không cần thiết, nó còn có thể bao gồm một số ký tự đặc thù locale mà cái này đúng:

!iscntrl(c) && !isdigit(c) && !ispunct(c) && !isspace(c)

và cái này đúng:

isupper(c) || islower(c)

Giá trị trả về

Trả về true cho các ký tự chữ cái (A-Z hoặc a-z).

Hoặc bất kỳ thứ điên rồ nào khác trong phần mô tả ở trên.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isalpha('a')? "yes": "no");  // yes
    printf("%s\n", isalpha('B')? "yes": "no");  // yes
    printf("%s\n", isalpha('5')? "yes": "no");  // no
    printf("%s\n", isalpha('?')? "yes": "no");  // no
}

Xem thêm

isalnum()

5.3 isblank()

Kiểm tra ký tự có là whitespace ngăn từ

Synopsis

#include <ctype.h>

int isblank(int c);

Mô tả

True nếu ký tự là whitespace dùng để ngăn các từ trên cùng một dòng.

Ví dụ, space (' ') hoặc tab ngang ('\t'). Locale khác có thể định nghĩa các ký tự blank khác.

Giá trị trả về

Trả về true nếu ký tự là whitespace dùng để ngăn các từ trên cùng một dòng.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isblank(' ')? "yes": "no");   // yes
    printf("%s\n", isblank('\t')? "yes": "no");  // yes
    printf("%s\n", isblank('\n')? "yes": "no");  // no
    printf("%s\n", isblank('a')? "yes": "no");   // no
    printf("%s\n", isblank('?')? "yes": "no");   // no
}

Xem thêm

isspace()

5.4 iscntrl()

Kiểm tra ký tự có là ký tự điều khiển

Synopsis

#include <ctype.h>

int iscntrl(int c);

Mô tả

Ký tự điều khiển (control character) là ký tự không in được, tuỳ theo locale.

Với locale “C”, nghĩa là các ký tự điều khiển nằm trong khoảng 0x00 đến 0x1F (ký tự ngay trước SPACE) và 0x7F (ký tự DEL).

Nói chung nếu nó không phải ký tự ASCII (hoặc Unicode nhỏ hơn 128) in được, thì nó là ký tự điều khiển ở locale “C”.

Giá trị trả về

Trả về true nếu c là ký tự điều khiển.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", iscntrl('\t')? "yes": "no");  // yes (tab)
    printf("%s\n", iscntrl('\n')? "yes": "no");  // yes (newline)
    printf("%s\n", iscntrl('\r')? "yes": "no");  // yes (return)
    printf("%s\n", iscntrl('\a')? "yes": "no");  // yes (bell)
    printf("%s\n", iscntrl(' ')? "yes": "no");   // no
    printf("%s\n", iscntrl('a')? "yes": "no");   // no
    printf("%s\n", iscntrl('?')? "yes": "no");   // no
}

Xem thêm

isgraph(), isprint()

5.5 isdigit()

Kiểm tra ký tự có là chữ số

Synopsis

#include <ctype.h>

int isdigit(int c);

Mô tả

Kiểm tra xem c có là chữ số trong khoảng 0-9 không.

Giá trị trả về

Trả về true nếu ký tự là chữ số, không có gì bất ngờ.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isdigit('0')? "yes": "no");   // yes
    printf("%s\n", isdigit('5')? "yes": "no");   // yes
    printf("%s\n", isdigit('a')? "yes": "no");   // no
    printf("%s\n", isdigit('B')? "yes": "no");   // no
    printf("%s\n", isdigit('?')? "yes": "no");   // no
}

Xem thêm

isalnum(), isxdigit()

5.6 isgraph()

Kiểm tra ký tự có in được và không phải space

Synopsis

#include <ctype.h>

int isgraph(int c);

Mô tả

Kiểm tra xem c có là ký tự in được nào mà không phải space (' ') không.

Giá trị trả về

Trả về true nếu c là ký tự in được nào mà không phải space (' ').

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isgraph('0')? "yes": "no");   // yes
    printf("%s\n", isgraph('a')? "yes": "no");   // yes
    printf("%s\n", isgraph('B')? "yes": "no");   // yes
    printf("%s\n", isgraph('?')? "yes": "no");   // yes
    printf("%s\n", isgraph(' ')? "yes": "no");   // no
    printf("%s\n", isgraph('\n')? "yes": "no");  // no
}

Xem thêm

iscntrl(), isprint()

5.7 islower()

Kiểm tra ký tự có là chữ thường

Synopsis

#include <ctype.h>

int islower(int c);

Mô tả

Kiểm tra xem ký tự có là chữ thường trong khoảng a-z không.

Ở các locale khác, có thể có những ký tự chữ thường khác. Trong mọi trường hợp, để là chữ thường, điều sau đây phải đúng:

!iscntrl(c) && !isdigit(c) && !ispunct(c) && !isspace(c)

Giá trị trả về

Trả về true nếu ký tự là chữ thường.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", islower('c')? "yes": "no");   // yes
    printf("%s\n", islower('0')? "yes": "no");   // no
    printf("%s\n", islower('B')? "yes": "no");   // no
    printf("%s\n", islower('?')? "yes": "no");   // no
    printf("%s\n", islower(' ')? "yes": "no");   // no
}

Xem thêm

isupper(), isalpha(), toupper(), tolower()

5.8 isprint()

Kiểm tra ký tự có in được

Synopsis

#include <ctype.h>

int isprint(int c);

Mô tả

Kiểm tra xem ký tự có in được không, kể cả space (' '). Nên là giống isgraph(), nhưng lần này space không bị bỏ rơi ngoài trời lạnh.

Giá trị trả về

Trả về true nếu ký tự in được, kể cả space (' ').

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isprint('c')? "yes": "no");   // yes
    printf("%s\n", isprint('0')? "yes": "no");   // yes
    printf("%s\n", isprint(' ')? "yes": "no");   // yes
    printf("%s\n", isprint('\r')? "yes": "no");  // no
}

Xem thêm

isgraph(), iscntrl()

5.9 ispunct()

Kiểm tra ký tự có là dấu câu

Synopsis

#include <ctype.h>

int ispunct(int c);

Mô tả

Kiểm tra xem ký tự có là dấu câu.

Ở locale “C”, điều đó có nghĩa là:

!isspace(c) && !isalnum(c)

Ở các locale khác, có thể có các ký tự dấu câu khác (nhưng cũng không thể là space hoặc chữ-số).

Giá trị trả về

True nếu ký tự là dấu câu.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", ispunct(',')? "yes": "no");   // yes
    printf("%s\n", ispunct('!')? "yes": "no");   // yes
    printf("%s\n", ispunct('c')? "yes": "no");   // no
    printf("%s\n", ispunct('0')? "yes": "no");   // no
    printf("%s\n", ispunct(' ')? "yes": "no");   // no
    printf("%s\n", ispunct('\n')? "yes": "no");  // no
}

Xem thêm

isspace(), isalnum()

5.10 isspace()

Kiểm tra ký tự có là whitespace

Synopsis

#include <ctype.h>

int isspace(int c);

Mô tả

Kiểm tra xem c có là ký tự whitespace không. Bao gồm:

• Space (' ')
• Formfeed ('\f')
• Newline ('\n')
• Carriage Return ('\r')
• Horizontal Tab ('\t')
• Vertical Tab ('\v')

Các locale khác có thể xác định các ký tự whitespace khác. isalnum() là false với mọi ký tự whitespace.

Giá trị trả về

True nếu ký tự là whitespace.

Ví dụ

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    //             kiểm tra ký tự này
    //                      v
    printf("%s\n", isspace(' ')? "yes": "no");   // yes
    printf("%s\n", isspace('\n')? "yes": "no");  // yes
    printf("%s\n", isspace('\t')? "yes": "no");  // yes
    printf("%s\n", isspace(',')? "yes": "no");   // no
    printf("%s\n", isspace('!')? "yes": "no");   // no
    printf("%s\n", isspace('c')? "yes": "no");   // no
}

Xem thêm

isblank()

5.11 isupper()

Kiểm tra ký tự có là chữ hoa

Synopsis