Mọi chương trình C đều bắt đầu tại main. #include <stdio.h> đưa vào một header để bạn có thể sử dụng printf để in. Một hàm là một khối có tên mà bạn có thể gọi; \n bắt đầu một dòng mới. main trả về 0 để biểu thị "thành công".
#include <stdio.h>
void greet(void) {
printf("Hello, world!\n");
}
int main(void) {
greet();
printf("I am learning C.\n");
return 0;
}
Mọi chương trình C đều chạy từ main sau khi bao gồm headers
1.2
Biến, kiểu & toán học
C yêu cầu một kiểu cho mỗi biến: int (số nguyên), double (số thực), char (một ký tự). printf sử dụng một định dạng specifier — %d, %f, %c — cho mỗi giá trị. Phép chia / giữa hai int là phép chia nguyên; phép chia % là phần dư.
#include <stdio.h>
int main(void) {
int n = 17;
double pi = 3.14;
char grade = 'A';
printf("%d %.2f %c\n", n, pi, grade); // 17 3.14 A
printf("%d %d\n", 7 / 2, 7 % 2); // 3 1
return 0;
}
Chuỗi định dạng điều khiển cả việc in và đọc:
Specifier
Type
Ví dụ output
%d
int
17
%f
double (%.2f = 2 chữ số thập phân)
3.14
%c
char
A
%s
một chuỗi
Mei
%zu
một kích thước (từ sizeof / strlen)
3
%x
unsigned int, in theo cơ số 16
ff
scanf("%d", &n) đọc một int qua địa chỉ của nó (lưu ý dấu &). Định dạng đầu vào và đầu ra không giống nhau: printf("%f", x) in một double, nhưng scanf("%lf", &x) đọc một double; đầu vào %f cần một float *. Kiểm tra số lượng phần tử được gán thành công trả về. Anh em của nó sscanf phân tích các giá trị ra khỏi một chuỗi:
#include <stdio.h>
int main(void) {
char line[] = "Mei 88";
char name[20];
int score;
if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
printf("%s scored %d\n", name, score); // Mei scored 88
return 0;
}
1.3
Bình luận & phong cách
Một bình luận là ghi chú dành cho con người; trình biên dịch bỏ qua nó. Sử dụng // cho một dòng và /* ... */ cho một khối. Indentation tốt và tên rõ ràng giúp code dễ đọc.
#include <stdio.h>
int main(void) {
// a single-line comment
/* a block
comment */
int total = 3 + 4; // clear names help
printf("%d\n", total); // 7
return 0;
}
Lỗi thường gặp
Các khai báo và biểu thức lệnh kết thúc bằng ;; một khối hợp thành { ... } không cần dấu chấm câu thêm. main nên trả về int (return 0;).
printf cần một chuỗi định dạng: %d cho int, %f cho double, và \n cho một dòng mới.
Một định dạng sai như %d cho một double sẽ gây hành vi không xác định; nó không đảm bảo chỉ in ra dữ liệu rác. Hãy khớp đúng kiểu đối số.
Một if chạy một khối khi điều kiện là true. C không có kiểu boolean thực sự mặc định: 0 là false và bất kỳ giá trị nào khác 0 đều là true. Xếp chồng lựa chọn với else if và else. So sánh với ==, !=, <, >, <=, >=.
#include <stdio.h>
int main(void) {
int score = 72;
if (score >= 90) {
printf("A\n");
} else if (score >= 60) {
printf("Pass\n");
} else {
printf("Fail\n");
}
return 0;
}
if chọn nhánh true; else chọn nhánh false
2.2
công tắc
Một switch chọn một case dựa trên một giá trị số nguyên. Mỗi case cần một break để thoát ra — nếu không, C sẽ "rơi xuống" case tiếp theo. default chạy khi không có gì khớp.
#include <stdio.h>
int main(void) {
int day = 3;
switch (day) {
case 1: printf("Mon\n"); break;
case 2: printf("Tue\n"); break;
case 3: printf("Wed\n"); break;
default: printf("Other\n");
}
return 0;
}
Lỗi thường gặp
if (x = 5) gán và luôn là true; hãy dùng == để so sánh.
Mỗi trường hợp switch cần một break;, nếu không sẽ rơi vào case tiếp theo.
0 là false và bất kỳ giá trị nào khác 0 đều là true trong một điều kiện.
Vòng lặp lặp lại một khối lệnh. Một vòng lặp while chạy chừng nào điều kiện còn đúng. Một vòng lặp for gộp phần khởi tạo, kiểm tra và tăng (i++) thành một dòng — tốt nhất khi bạn biết số lần lặp.
#include <stdio.h>
int main(void) {
int i = 1;
while (i <= 3) {
printf("%d ", i);
i++;
}
printf("\n"); // 1 2 3
for (int j = 0; j < 5; j++) {
printf("%d ", j);
}
printf("\n"); // 0 1 2 3 4
return 0;
}
while kiểm tra điều kiện; for đếm với bước nhảy
3.2
Tích lũy
Một mẫu phổ biến: bắt đầu bộ tích lũy ở 0, sau đó cộng thêm vào bên trong vòng lặp. Ý tưởng tương tự dùng để đếm số lượng hoặc tìm tổng tích lũy.
#include <stdio.h>
int main(void) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i; // 1 + 2 + 3 + 4 + 5
}
printf("%d\n", total); // 15
return 0;
}
3.3
Vòng lặp lồng nhau & mô hình
Vòng lặp nằm trong một vòng lặp khác là vòng lặp lồng nhau. Vòng lặp trong chạy hoàn toàn cho mỗi bước của vòng lặp ngoài — lý tưởng cho lưới và mô hình.
#include <stdio.h>
int main(void) {
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
printf("*");
}
printf("\n");
}
return 0;
}
Lỗi thường gặp
for (i = 0; i < n; i++) chạy n lần; dấu chấm phẩy ngay sau for (...) tạo ra một vòng lặp rỗng.
Một while mà điều kiện chưa bao giờ trở thành false sẽ lặp vô hạn.
Khai báo biến đếm (int i) trước hoặc trong header for.
Hàm nhận tham số (đầu vào) và trả về một giá trị. Kiểu trả về xuất hiện đầu tiên (int, double, …); void có nghĩa là hàm không trả về gì.
#include <stdio.h>
int square(int x) { // x is a parameter
return x * x; // hand back a value
}
int main(void) {
int r = square(5);
printf("%d\n", r); // 25
return 0;
}
Tham số vào; giá trị trả về ra
4.2
Mẫu khai báo & phạm vi
C đọc từ trên xuống dưới, nên một hàm phải được biết đến trước khi nó được gọi. Một mẫu khai báo — gồm dòng header plus ; — khai báo sớm để bạn có thể đặt main lên đầu. Phạm vi của một biến là khối lệnh chứa nó: nó chỉ tồn tại cục bộ và biến mất khi khối kết thúc.
#include <stdio.h>
int add(int a, int b); // prototype: declared before use
int main(void) {
printf("%d\n", add(3, 4)); // 7
return 0;
}
int add(int a, int b) { // definition comes later
int sum = a + b; // sum is local to add
return sum;
}
Lỗi thường gặp
Một hàm được sử dụng trước khi định nghĩa cần có bản mẫu ở trên main.
Đối số được truyền THEO GIÁ TRỊ — thay đổi bên trong hàm không ảnh hưởng đến nơi gọi trừ khi bạn truyền con trỏ.
Biến được khai báo bên trong hàm thì thuộc tính cục bộ của hàm đó.
Mảng chứa nhiều giá trị cùng một kiểu. Chỉ mục bắt đầu từ 0. C không lưu độ dài mảng, vì vậy một mẹo phổ biến là tính số phần tử: sizeof(a) / sizeof(a[0]).
#include <stdio.h>
int main(void) {
int scores[3] = {88, 71, 95};
printf("%d\n", scores[0]); // 88
scores[1] = 100;
printf("%d\n", scores[1]); // 100
int n = sizeof(scores) / sizeof(scores[0]);
printf("%d\n", n); // 3
return 0;
}
Các ô trong mảng được chỉ mục từ 0
5.2
Thuật toán mảng
Duyệt qua mảng bằng vòng lặp for để tìm giá trị lớn nhất, tổng, hoặc số lượng. Luôn lặp từ 0 đến n - 1.
#include <stdio.h>
int main(void) {
int a[] = {3, 9, 2, 7};
int n = sizeof(a) / sizeof(a[0]);
int max = a[0], total = 0;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
total += a[i];
}
printf("%d %d\n", max, total); // 9 21
return 0;
}
5.3
Mảng 2 chiều
Mảng 2 chiều là lưới các hàng và cột: grid[row][col]. Sử dụng hai vòng lặp lồng nhau để truy cập mọi ô.
#include <stdio.h>
int main(void) {
int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", grid[1][2]); // 6
for (int r = 0; r < 2; r++) {
for (int c = 0; c < 3; c++) {
printf("%d ", grid[r][c]);
}
}
printf("\n"); // 1 2 3 4 5 6
return 0;
}
Lỗi thường gặp
C KHÔNG kiểm tra giới hạn mảng: ghi đè vào vị trí a[n] trong mảng có kích thước n là hành vi xác định không rõ ràng.
Các chỉ mục hợp lệ chạy từ 0 đến n - 1.
Trong hầu hết các biểu thức, mảng chuyển đổi thành con trỏ đến phần tử đầu tiên, nhưng bản thân mảng không phải là con trỏ. sizeof(a) cho biết tổng kích thước byte của một mảng thực tế; tham số mảng được điều chỉnh thành con trỏ, do đó hàm cần nhận độ dài cung cấp riêng biệt.
Con trỏ lưu địa chỉ của một biến. &x trả về địa chỉ của x; *p giải tham chiếu con trỏ — nó đọc hoặc ghi giá trị được lưu tại đó. Truyền con trỏ cho phép hàm thay đổi biến của nơi gọi (truyền theo con trỏ).
Con trỏ lưu một địa chỉ; giải tham chiếu đi theo mũi tên đến giá trị
#include <stdio.h>
void addOne(int *p) { // p holds an address
*p = *p + 1; // change the value at that address
}
int main(void) {
int x = 10;
int *ptr = &x; // & takes the address of x
printf("%d\n", *ptr); // * reads the value: 10
addOne(&x);
printf("%d\n", x); // 11 — changed through the pointer
return 0;
}
Ứng dụng kinh điển là hàm hoán đổi. Truyền chỉ giá trị thì chỉ sao chép chúng — sự hoán đổi bị mất. Truyền con trỏ cho phép hàm truy cập biến của nơi gọi:
#include <stdio.h>
void swap_values(int a, int b) { // copies: the caller sees nothing
int t = a; a = b; b = t;
}
void swap_pointers(int *a, int *b) { // addresses: the swap is real
int t = *a; *a = *b; *b = t;
}
int main(void) {
int x = 1, y = 2;
swap_values(x, y);
printf("%d %d\n", x, y); // 1 2 (unchanged!)
swap_pointers(&x, &y);
printf("%d %d\n", x, y); // 2 1 (swapped)
return 0;
}
Tên mảng hoạt động như con trỏ tới phần tử đầu tiên, và toán học con trỏ bước nhảy theo từng phần tử nguyên vẹn:
#include <stdio.h>
int main(void) {
int a[] = {10, 20, 30};
int *p = a; // same as &a[0]
printf("%d\n", *p); // 10
printf("%d\n", *(p + 2)); // 30 — same as a[2]
return 0;
}
NULL là con trỏ không trỏ vào đâu — hãy kiểm tra nó trước khi giải tham chiếu.
Lỗi thường gặp
&x là địa chỉ của x; *p là giá trị được lưu tại p.
Tuyệt đối không sử dụng *p trên con trỏ chưa khởi tạo hoặc NULL — nó gây crash hoặc làm hỏng bộ nhớ.
Để thay đổi biến của nơi gọi, truyền địa chỉ của nó và ghi thông qua con trỏ.
Chuỗi C là mảng char. Mọi chuỗi đều kết thúc bằng ký kết thúc null ẩn '\0', đánh dấu nơi nó dừng lại. strlen (từ <string.h>) đếm số ký tự cho đến '\0' đó. In cả chuỗi với %s và một ký tự với %c.
#include <stdio.h>
#include <string.h>
int main(void) {
char name[] = "Mei"; // 'M', 'e', 'i', '\0'
printf("%s\n", name); // Mei
printf("%zu\n", strlen(name)); // 3 (stops at '\0')
printf("%c\n", name[0]); // M
return 0;
}
Chuỗi C là mảng char kết thúc bằng ký kết thúc null ẩn
Bạn có thể duyệt chuỗi bằng cách lặp cho đến khi gặp '\0'.
#include <stdio.h>
int main(void) {
char word[] = "banana";
int count = 0;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == 'a') count++;
}
printf("%d\n", count); // 3
return 0;
}
7.2
Thư viện string.h
#include <string.h> cung cấp cho bạn các công cụ xử lý chuỗi cơ bản:
Hàm
Tác dụng
strlen(s)
độ dài, không tính ký kết thúc
strcpy(dst, src)
sao chép — dst phải đủ rộng
strcat(dst, src)
nối src vào cuối dst
strcmp(a, b)
so sánh: 0 khi bằng nhau, ngược lại âm / dương
#include <stdio.h>
#include <string.h>
int main(void) {
char full[40];
strcpy(full, "Mei"); // full is now "Mei"
strcat(full, " Chen"); // append -> "Mei Chen"
printf("%s (%zu)\n", full, strlen(full)); // Mei Chen (8)
printf("%d\n", strcmp("apple", "apple") == 0); // 1 (equal)
return 0;
}
strcmp trả về 0 khi bằng nhau, vì thế phép kiểm tra là strcmp(a, b) == 0 — tuyệt đối không dùng a == b.
Mảng đích phải có chỗ cho kết quả cùng với ký kết thúc.
Lỗi thường gặp
Một chuỗi C cần một byte dư cho ký kết thúc \0: một từ 5 chữ cái cần char[6].
sao chép và so sánh chuỗi với strcpy / strcmp, không phải = / ==.
Quên \0 khiến printf("%s", ...) vượt quá cuối văn bản.
struct nhóm các giá trị liên quan thành một kiểu. Mỗi giá trị là một thành viên. typedef đặt tên ngắn cho struct để bạn có thể viết Dog thay vì struct Dog. Dùng . trên giá trị struct, nhưng -> trên con trỏ tới struct.
#include <stdio.h>
typedef struct {
char name[20];
int age;
} Dog;
int main(void) {
Dog d = {"Rex", 3};
printf("%s is %d\n", d.name, d.age); // Rex is 3 (. on a value)
Dog *p = &d;
p->age = 4; // -> on a pointer
printf("%s is %d\n", d.name, d.age); // Rex is 4
return 0;
}
Lỗi thường gặp
Sử dụng . trên giá trị struct và -> trên con trỏ struct.
typedef cho phép bạn bỏ qua từ struct khi khai báo; nếu không có nó, bạn phải viết struct Point p;.
Gán một struct cho cấu trúc khác sẽ sao chép tất cả các trường của nó.
malloc cấp phát bộ nhớ trên heap tại thời điểm chạy và trả về con trỏ trỏ đến đó. realloc thay đổi kích thước khối bộ nhớ đó; free giải phóng nó lại. Mỗi lần gọi malloc đều cần một call tương ứng của free, nếu không sẽ gây rò rỉ bộ nhớ. Những hàm này nằm trong <stdlib.h>.
Các biến cục bộ sống trên ngăn xếp; bộ nhớ malloc sống trên vùng nhúng cho đến khi bạn giải phóng nó
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int *a = malloc(n * sizeof(int)); // room for 3 ints
if (a == NULL) return EXIT_FAILURE;
for (int i = 0; i < n; i++) a[i] = i * 10;
int *grown = realloc(a, 4 * sizeof *a); // positive size
if (grown == NULL) {
free(a);
return EXIT_FAILURE;
}
a = grown;
a[3] = 30;
for (int i = 0; i < 4; i++) printf("%d ", a[i]);
printf("\n"); // 0 10 20 30
free(a); // hand the memory back
return 0;
}
calloc(n, size) cấp phát một mảng giống như malloc VÀ điền đầy bằng số không.
Lỗi thường gặp
Mỗi malloc đều cần một free tương ứng; quên giải phóng sẽ gây rò rỉ bộ nhớ.
Sử dụng bộ nhớ sau khi đã free ("use-after-free") là một lỗi nghiêm trọng.
Kiểm tra xem malloc có trả về NULL hay không trước khi sử dụng bộ nhớ.
Đối với kích thước dương, một phép gọi realloc thất bại sẽ trả về NULL và giữ nguyên vùng cấp phát cũ: hãy kiểm tra kết quả tạm thời trước khi thay thế con trỏ duy nhất của bạn. Thành công sẽ giữ lại số byte nhỏ hơn giữa cũ/mới; các ô được thêm vào sẽ chưa được khởi tạo. Ví dụ này tránh yêu cầu kích thước bằng không và tràn số. Các biến cục thông thường không tĩnh có thời gian lưu trữ tự động và thường được triển khai trên ngăn xếp; C không bắt buộc bố trí đó.
Danh sách liên kết là một chuỗi các nút. Mỗi nút chứa một giá trị và con trỏ đến nút next; nút cuối cùng trỏ đến NULL. Khác với mảng, nó mở rộng thêm một nút mỗi lần với malloc. Luôn free mọi nút khi hoàn tất.
Danh sách liên kết: mỗi nút chứa một giá trị và con trỏ đến nút tiếp theo, kết thúc bằng NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
int main(void) {
Node *head = NULL;
for (int v = 10; v <= 30; v += 10) { // prepend 10, 20, 30
Node *n = malloc(sizeof(Node));
n->value = v;
n->next = head;
head = n;
}
for (Node *p = head; p != NULL; p = p->next) {
printf("%d ", p->value); // 30 20 10
}
printf("\n");
while (head != NULL) { // free the whole list
Node *t = head;
head = head->next;
free(t);
}
return 0;
}
10.2
Ngăn xếp & hàng đợi
Ngăn xếp là LIFO (vào sau, ra trước): push và pop ở cùng một đầu. Hàng đợi là FIFO (vào trước, ra trước): thêm vào cuối, lấy ra từ đầu. Cả hai đều dễ xây dựng trên mảng bằng các biến chỉ mục.
#include <stdio.h>
int main(void) {
int stack[10];
int top = 0; // next free slot
stack[top++] = 1; // push
stack[top++] = 2;
stack[top++] = 3;
while (top > 0) {
printf("%d ", stack[--top]); // pop: 3 2 1
}
printf("\n");
return 0;
}
#include <stdio.h>
int main(void) {
int queue[10];
int front = 0, back = 0;
queue[back++] = 1; // enqueue
queue[back++] = 2;
queue[back++] = 3;
while (front < back) {
printf("%d ", queue[front++]); // dequeue: 1 2 3
}
printf("\n");
return 0;
}
Lỗi thường gặp
Trong danh sách liên kết, tuyệt đối không mất con trỏ head, nếu không toàn bộ danh sách sẽ không thể truy cập được.
Free từng nút khi xong, duyệt qua danh sách trước khi unlink.
Kiểm tra xem danh sách có trống hay không (một head NULL) trước khi pop.
Tìm kiếm tuyến tính (linear search) kiểm tra từng phần tử một — nó hoạt động trên mọi loại mảng. Tìm kiếm nhị phân (binary search) nhanh hơn nhiều nhưng cần mảng đã sắp xếp: nó kiểm tra phần tử ở giữa và loại bỏ một nửa mỗi bước. Cả hai đều trả về chỉ số, hoặc -1 nếu không tìm thấy.
#include <stdio.h>
int linear(int a[], int n, int target) {
for (int i = 0; i < n; i++)
if (a[i] == target) return i;
return -1;
}
int binary(int a[], int n, int target) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {2, 5, 8, 12, 16, 23};
int n = sizeof(a) / sizeof(a[0]);
printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
return 0; // 3 3 -1
}
Linear scans all; binary halves a sorted range
11.2
Sắp xếp
Sắp xếp bong bóng (bubble sort) liên tục so sánh các phần tử kề nhau và hoán đổi bất kỳ cặp nào không đúng thứ tự. Sau mỗi lượt duyệt, giá trị lớn nhất sẽ "nổi" lên cuối mảng.
#include <stdio.h>
int main(void) {
int a[] = {5, 2, 9, 1, 7};
int n = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n"); // 1 2 5 7 9
return 0;
}
11.3
Đệ quy
Đệ quy (recursion) là một hàm gọi chính nó. Nó cần một trường hợp cơ sở (base case) để dừng lại, và một lời gọi đệ quy tiến gần về phía trường hợp đó. Không có base case thì nó sẽ không bao giờ kết thúc.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call
}
int main(void) {
printf("%d\n", factorial(5)); // 120
return 0;
}
Lỗi thường gặp
Tìm kiếm nhị phân cần một mảng đã sắp xếp; đệ quy cần một base case.
Mỗi lần gọi đệ quy phải tiến gần hơn đến trường hợp cơ sở, nếu không thì stack sẽ bị tràn.
Sắp xếp nổi và sắp xếp chèn có độ phức tạp O(n²) — dễ học nhưng chậm khi xử lý dữ liệu lớn.
fopen returns a file pointer; the mode string says what to do — "w" write, "r" read, "a" append. Write with fprintf, read with fscanf, and always fclose when done.
#include <stdio.h>
int main(void) {
FILE *out = fopen("scores.txt", "w"); // open for writing
if (out == NULL) {
perror("scores.txt");
return 1;
}
fprintf(out, "Alice 80\nBob 95\n");
fclose(out);
FILE *in = fopen("scores.txt", "r"); // open for reading
if (in == NULL) {
perror("scores.txt");
return 1;
}
char name[20];
int score;
while (fscanf(in, "%19s %d", name, &score) == 2) { // %19s leaves room for '\0'
printf("%s -> %d\n", name, score);
}
fclose(in);
return 0;
}
fopen → read/write → fclose
12.2
Xử lý lỗi với mã trả về
Ngôn ngữ C không có ngoại lệ nội tại. Một hàm có thể báo cáo kết quả thông qua mã trả về; hãy kiểm tra quy tắc của hàm đó trước khi sử dụng kết quả. Ví dụ dưới đây sử dụng 0 cho thành công và -1 cho thất bại. Thay vào đó, fopen trả về con trỏ dòng, hoặc NULL khi gặp lỗi.
#include <stdio.h>
// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
if (b == 0) return -1; // error code
*result = a / b;
return 0; // success
}
int main(void) {
int r;
if (safe_divide(10, 2, &r) == 0)
printf("10 / 2 = %d\n", r); // 10 / 2 = 5
if (safe_divide(10, 0, &r) != 0)
printf("cannot divide by zero\n"); // error reported
return 0;
}
Lỗi thường gặp
Kiểm tra xem fopen có trả về NULL hay không trước khi đọc hoặc ghi.
Always fclose a file when you are done.
Return a non-zero code from main to signal an error to the caller.
Một bit là một giá trị 0 hoặc 1; số được lưu trữ dưới dạng nhị phân. Các toán tử bit hoạt động trực tiếp trên các bit: & AND, | OR, ^ XOR, << dịch trái (×2 mỗi bước), >> dịch phải (÷2).
#include <stdio.h>
int main(void) {
int a = 12; // 1100
int b = 10; // 1010
printf("%d\n", a & b); // 8 AND -> 1000
printf("%d\n", a | b); // 14 OR -> 1110
printf("%d\n", a ^ b); // 6 XOR -> 0110
printf("%d\n", a << 1); // 24 left shift
printf("%d\n", a >> 1); // 6 right shift
return 0;
}
Thập phân phân (cơ số 16) viết gọn nhị phân: một chữ số thập phân phân chính xác là bốn bit. Viết hằng số thập phân phân với 0x; in ra với %x:
#include <stdio.h>
int main(void) {
printf("%d\n", 0xFF); // 255 (0x marks a hex literal)
printf("%x\n", 255); // ff
printf("%x\n", 12); // c
return 0;
}
Bitwise operators work on the bits of integers
13.2
Mã hóa độ dài chuỗi (Run-length encoding)
Mã hóa độ dài chuỗi lặp lại (RLE) là một phương pháp nén đơn giản: thay thế mỗi chuỗi ký tự lặp lại bằng số lượng và ký tự đó. Nó không mất dữ liệu — có thể khôi phục hoàn toàn bản gốc.
#include <stdio.h>
#include <string.h>
int main(void) {
char *s = "aaabbc";
int n = strlen(s);
for (int i = 0; i < n; ) {
char c = s[i];
int run = 0;
while (i < n && s[i] == c) { run++; i++; }
printf("%d%c", run, c); // 3a2b1c
}
printf("\n");
return 0;
}
Lỗi thường gặp
& là AND bit và && là AND logic — đừng nhầm lẫn.
Dịch trái << 1 làm đôi một giá trị; dịch phải >> 1 chia đôi nó.
Bit n có giá trị 1 << n (C không có toán tử lũy thừa **); kiểm tra một bit bằng (x >> n) & 1.
Tiền trình viên chạy trước khi biên dịch. #define tạo macro — văn bản thường được thay thế ở mọi nơi. const tạo hằng số không thể thay đổi. static bên trong hàm giữ nguyên giá trị biến giữa các lần gọi. Một ENUM (enum) đặt tên cho một tập hợp các số nguyên bắt đầu từ 0.
#include <stdio.h>
#define MAX 100 // macro: text replaced before compiling
enum Color { RED, GREEN, BLUE }; // named integers 0, 1, 2
int next_id(void) {
static int count = 0; // keeps its value between calls
count++;
return count;
}
int main(void) {
const double PI = 3.14; // cannot be changed
printf("%d %.2f\n", MAX, PI); // 100 3.14
printf("%d %d %d\n", RED, GREEN, BLUE); // 0 1 2
int a = next_id();
int b = next_id();
printf("%d %d\n", a, b); // 1 2
return 0;
}
Các chương trình lớn hơn chia sẻ nhiều file: phần khai báo nằm trong file header (mine.h), được bao gồm bằng #include "mine.h" — dấu ngoặc kép có nghĩa là file của bạn, < > có nghĩa là thư viện tiêu chuẩn. Một include guard (#ifndef MINE_H / #define MINE_H / #endif) ngăn file header được bao gồm hai lần.
Lỗi thường gặp
#define thực hiện thay thế văn bản thường mà không có kiểm tra kiểu; hãy bọc thân macro và đối số trong dấu ngoặc.
Giá trị const không thể thay đổi sau khi đã được gán.
Biến cục bộ static giữ nguyên giá trị giữa các lần gọi đến hàm.