C - Cheatsheet

Tổng hợp Cheatsheet C - Tóm tắt C với các cú pháp và phương thức quan trọng.

🔖 Gợi ý từ Admin

📝 Tài liệu phỏng vấn kiến thức lập trình: Xem tại đây!!!

📌 Tìm hiểu về thuật toán: Xem tại đây!!!

📌 Roadmaps - Lộ trình trở thành một lập trình viên: Xem tại đây!!!

⚡️ Cheatsheet các ngôn ngữ lập trình: Xem tại đây!!!

⚡️ Handbook lập trình: Xem tại đây!!!

Mẹo

Bạn có thể tìm tất cả thông tin (tài liệu, công cụ...) thông qua núttìm kiếm 🔍ở góc trên bên phải màn hình.

I. Tổng hợp Cheatsheet C

1. Cơ bản

⚡️ Chương trình cơ bản

hello.c

#include <stdio.h>

int main(void) {
  printf("Hello World!\n");

  return 0;
}

// Biên dịch file hello.c file với gcc
$ gcc hello.c -o hello

// Chạy chương trình sau khi biên dịch
$ ./hello
// Output => Hello World!

⚡️ Biến (Variables)

Variables

int myNum = 15;

int myNum2; // chưa gán giá trị
myNum2 = 15; // gán giá trị

int myNum3 = 15; // myNum3 là 15
myNum3 = 10;     // myNum3 bây giờ là 10

float myFloat = 5.99; // số chấm động
char myLetter = 'D';  // kiểu ký tự

int x = 5;
int y = 6;
int sum = x + y; // cộng các biến

// khai báo nhiều biến trên cùng 1 dòng
int x = 5, y = 6, z = 50;

⚡️ Hằng (Constants)

Constants

const int minutesPerHour = 60;
const float PI = 3.14;

// Best Practices
const int BIRTHYEAR = 1980;

⚡️ Bình luận (Comment)

Comment

// đây là comment 1 dòng
printf("Hello World!"); // Có thể comment bất kỳ đâu trong file

/*
  Đây là comment
  nhiều dòng
*/

⚡️ In văn bản (Print text)

Print text

printf("I am learning C.");
int testInteger = 5;
printf("Number = %d", testInteger);

float f = 5.99; // số chấm động
printf("Value = %f", f);

short a = 0b1010110; // số hệ 2 (nhị phân)
int b = 02713; // số hệ 8 (bát phân)
long c = 0X1DAB83; // số hệ 16 (thập lục phân)

// output in octal form
printf("a=%ho, b=%o, c=%lo\n", a, b, c);
// output => a=126, b=2713, c=7325603

// Output in decimal form
printf("a=%hd, b=%d, c=%ld\n", a, b, c);
// output => a=86, b=1483, c=1944451

// output in hexadecimal form (letter lowercase)
printf("a=%hx, b=%x, c=%lx\n", a, b, c);
// output => a=56, b=5cb, c=1dab83

// Output in hexadecimal (capital letters)
printf("a=%hX, b=%X, c=%lX\n", a, b, c);
// output => a=56, b=5CB, c=1DAB83

⚡️ Kiểm soát các khoảng trắng (Control the number of spaces)

Control the number of spaces

int a1 = 20, a2 = 345, a3 = 700;
int b1 = 56720, b2 = 9999, b3 = 20098;
int c1 = 233, c2 = 205, c3 = 1;
int d1 = 34, d2 = 0, d3 = 23;

printf("%-9d %-9d %-9d\n", a1, a2, a3);
printf("%-9d %-9d %-9d\n", b1, b2, b3);
printf("%-9d %-9d %-9d\n", c1, c2, c3);
printf("%-9d %-9d %-9d\n", d1, d2, d3);

// Kết quả
20        345       700
56720     9999      20098
233       205       1
34        0         23
// Trong %-9d, d có nghĩa là xuất ra ở dạng 10, 9 có nghĩa là chiếm ít nhất 9 ký tự và chiều rộng không đủ để lấp đầy khoảng trắng, - có nghĩa là căn lề trái

⚡️ Chuỗi (Strings)

Strings

char greetings[] = "Hello World!";
printf("%s", greetings);

// truy cập chuỗi
char greetings[] = "Hello World!";
printf("%c", greetings[0]);

// chỉnh sửa chuỗi
char greetings[] = "Hello World!";
greetings[0] = 'J';

printf("%s", greetings); // in ra "Jello World!"

// 1 cách khác để tạo chuỗi
char greetings[] = {'H','e','l','l','\0'};

printf("%s", greetings); // in ra "Hell!"

// Tạo chuỗi bằng con trỏ ký tự (String Literals)
char *greetings = "Hello";
printf("%s", greetings); // in ra "Hello!"

// LƯU Ý: Chuỗi ký tự có thể được lưu trữ trong phần bộ nhớ chỉ đọc. Việc sửa đổi một chuỗi ký tự sẽ kích hoạt hành vi không xác định. Bạn không thể sửa đổi nó.
// C không có kiểu String, dùng kiểu char và tạo mảng ký tự

⚡️ Câu lệnh điều kiện (Condition)

Condition

int time = 20;
if (time < 18) {
  printf("Goodbye!");
} else {
  printf("Good evening!");
}
// Output -> "Good evening!"
int time = 22;
if (time < 10) {
  printf("Good morning!");
} else if (time < 20) {
  printf("Goodbye!");
} else {
  printf("Good evening!");
}
// Output -> "Good evening!"

⚡️ Toán tử 3 ngôi (Ternary operator)

Ternary operator

         ┌── Đúng ──┐
K.quả = Đ.kiện ? B.thức1 : B.thức2;
           └───── Sai ───────┘

int age = 20;
(age > 19) ? printf("Adult") : printf("Teenager");

⚡️ Switch

Switch

int day = 4;

switch (day) {
  case 3: printf("Wednesday"); break;
  case 4: printf("Thursday"); break;
  default:
    printf("Weekend!");
}
// output -> "Thursday" (day 4)

⚡️ Vòng lặp while (While Loop)

While Loop

int i = 0;

while (i < 5) {
  printf("%d\n", i);
  i++;
}
// LƯU Ý: Đừng quên tăng giá trị của biến được sử dụng trong điều kiện, nếu không vòng lặp sẽ không bao giờ kết thúc và trở thành "vòng lặp vô hạn"!

⚡️ Vòng lặp do...while (do...while Loop)

do...while Loop

int i = 0;

do {
  printf("%d\n", i);
  i++;
} while (i < 5);

⚡️ Vòng lặp for (For Loop)

For Loop

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

⚡️ Ví dụ về vòng lặp while kết hợp với break

While Break Example

int i = 0;

while (i < 10) {
  if (i == 4) {
    break;
  }
  printf("%d\n", i);

  i++;
}

⚡️ Ví dụ về vòng lặp while kết hợp với continue

While continue example

int i = 0;

while (i < 10) {
  i++;

  if (i == 4) {
    continue;
  }
  printf("%d\n", i);
}

⚡️ Thoát khỏi vòng lặp sử dụng break

Break out of the loop Break/Continue

for (int i = 0; i < 10; i++) {
  // thoát khỏi vòng lặp khi i == 4
  if (i == 4) {
    break;
  }
  printf("%d\n", i);
}

for (int i = 0; i < 10; i++) {
  // bỏ qua giá trị i == 4
  if (i == 4) {
    continue;
  }
  printf("%d\n", i);
}

⚡️ Mảng (Arrays)

Arrays

int myNumbers[] = {25, 50, 75, 100};

printf("%d", myNumbers[0]); // output 25

// thay đổi các phần tử trong mảng
int myNumbers[] = {25, 50, 75, 100};
myNumbers[0] = 33;
printf("%d", myNumbers[0]);

// Vòng lặp với mảng
int myNumbers[] = {25, 50, 75, 100};
int i;

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

// Khai báo 1 mảng gồm 4 số nguyên
int myNumbers[4];

// thêm phần tử
myNumbers[0] = 25;
myNumbers[1] = 50;
myNumbers[2] = 75;
myNumbers[3] = 100;

⚡️ Kiểu dữ liệu enum (Enumeration Enum)

Enumeration Enum

enum week { Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };

// định nghĩa các biến enum
enum week a, b, c;
enum week { Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a, b, c;

// Với biến enum, bạn có thể gán giá trị trong danh sách cho nó
enum week { Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };
enum week a = Mon, b = Wed, c = Sat;
// hoặc
enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } a = Mon, b = Wed, c = Sat;

⚡️ Ví dụ cho ứng dụng enum

Enumerate sample applications

enum week {Mon = 1, Tues, Wed, Thurs} day;

scanf("%d", &day);

switch(day) {
  case Mon: puts("Monday"); break;
  case Tues: puts("Tuesday"); break;
  case Wed: puts("Wednesday"); break;
  case Thursday: puts("Thursday"); break;
  default: puts("Error!");
}

⚡️ Dữ liệu đầu vào do người dùng nhập (User input)

User input

// Tạo một biến số nguyên để lưu trữ giá trị nhận được từ người dùng
int myNum;

// Hỏi người dùng nhập số
printf("Please enter a number: \n");

// Nhận và lưu giá trị từ người dùng nhập vào
scanf("%d", &myNum);

// Xuất giá trị
printf("The number you entered: %d", myNum);

⚡️ Dữ liệu đầu vào kiểu chuỗi (User input string)

User input string

// tạo 1 chuỗi
char firstName[30];

// Hỏi người dùng nhập chuỗi
printf("Enter your name: \n");

// Nhận và lưu giá trị
scanf("%s", &firstName);

// Hiển thị chuỗi
printf("Hello %s.", firstName);

⚡️ Địa chỉ bộ nhớ (memory address)

memory address

// Khi một biến được tạo, nó được gán một địa chỉ bộ nhớ
int myAge = 43;

// Để truy cập nó, hãy sử dụng toán tử tham chiếu (&)
printf("%p", &myAge); // Output: 0x7ffe5367e044

⚡️ Tạo con trỏ (create pointer)

create pointer

int myAge = 43; // Gán giá trị cho biến
printf("%d", myAge); // Hiển thị giá trị

// Địa chỉ bộ nhớ của biến myAge (0x7ffe5367e044)
printf("%p", &myAge);

⚡️ Biến con trỏ (pointer variable)

pointer variable

int myAge = 43; // Gán giá trị cho biến
int*ptr = &myAge; // Biến con trỏ có tên ptr, dùng để lưu trữ địa chỉ của myAge

printf("%d\n", myAge); // Hiển thị giá trị

printf("%p\n", \&myAge); // hiển thị địa chỉ bộ nhớ của biến myAge (0x7ffe5367e044)
printf("%p\n", ptr); // sử dụng con trỏ (0x7ffe5367e044) để hiển thị địa chỉ bộ nhớ của biến myAge

⚡️ Dereference

Dereference

int myAge = 43; // khởi tạo biến
int*ptr = &myAge; // khởi tạo con trỏ

// Reference: xuất myAge bằng một con trỏ
// địa chỉ bộ nhớ (0x7ffe5367e044)
printf("%p\n", ptr);
// dereference: xuất giá trị của myAge bằng một con trỏ
printf("%d\n", *ptr);

2. Operators (toán tử)

⚡️ Toán tử số học (Arithmetic Operators)

Arithmetic Operators

int example1 = 100 + 50;   // Cộng
int example2 = 300 - 250;  // Trừ
int example3 = 2*2; // Nhân
int example4 = 6/2; // Chia
int example5 = 10%2; // Chia lấy dư
int example6 = example1++, int example7 = ++example1; // Tăng 1 đơn vị
int example8 = example1--, int example9 = --example1; // Giảm 1 đơn vị

⚡️ Toán tử gán (Assignment operator)

Assignment operator

x = 5	  // x = 5
x += 3	  // x = x + 3
x -= 3	  // x = x - 3
x *= 3	  // x = x * 3
x /= 3	  // x = x / 3
x %= 3	  // x = x % 3
x &= 3	  // x = x & 3
x |= 3	  // x = x | 3
x ^= 3	  // x = x ^ 3
x >>= 3	  // x = x >> 3
x <<= 3	  // x = x << 3

⚡️ Toán tử so sánh (Comparison Operators)

Comparison Operators

int x = 5;
int y = 3;

printf("%d", x > y); // trả về 1 (true) bởi vì 5 lớn hơn 3

a == b	// a bằng b
a != b	// a khác b
a < b	// a bé hơn b
a > b	// a lớn hơn b
a <= b	// a bé hơn hoặc bằng b
a >= b	// a lớn hơn hoặc bằng b

// Toán tử so sánh dùng để so sánh 2 giá trị

⚡️ Toán tử logic (Logical Operators)

Ký tự	Toán tử	Mô tả	Ví dụ
&&	and (và)	trả về true nếu cả 2 đều đúng	x < 5 && x < 10
||	or (hoặc)	trả về true nếu 1 trong 2 đúng	x < 5 || x < 4
!	not (phủ định)	phủ định kết quả	!(x < 5 && x < 10)

⚡️ Toán tử trên bit (Bitwise operators)

Ký tự	Mô tả	Ví dụ
&	Phép AND bitwise, thực hiện phép "AND" trên các chữ số nhị phân	(A & B) sẽ nhận được 12, tức là 0000 1100
|	Toán tử OR bitwise, thực hiện phép "OR" trên các chữ số nhị phân	(A | B) sẽ nhận được 61, tức là 0011 1101
^	Toán tử XOR, thực hiện phép "XOR" trên các chữ số nhị phân	(A ^ B) sẽ nhận được 49, tức là 0011 0001
~	Toán tử đảo bit, thực hiện phép "đảo bit" trên các bit nhị phân	(~A) sẽ nhận được -61, tức là 1100 0011
<<	Toán tử dịch bit sang trái	A << 2 sẽ nhận được 240, tức là 1111 0000
>>	Toán tử dịch bit sang phải	A >> 2 sẽ nhận được 15, tức là 0000 1111

⚡️ Ví dụ

Operator Examples

unsigned int a = 60; /*60 = 0011 1100 */
unsigned int b = 13; /*13 = 0000 1101 */
int c = 0;

c = a & b; /*12 = 0000 1100 */
printf("Line 1 -the value of c is %d\n", c);

c = a | b; /*61 = 0011 1101 */
printf("Line 2 -the value of c is %d\n", c);
c = a ^ b; /*49 = 0011 0001 */
printf("Line 3 -the value of c is %d\n", c);
c = ~a; /*-61 = 1100 0011 */
printf("Line 4 -The value of c is %d\n", c);
c = a << 2; /*240 = 1111 0000 */
printf("Line 5 -the value of c is %d\n", c);
c = a >> 2; /*15 = 0000 1111 */
printf("Line 6 -The value of c is %d\n", c);

3. Data Types (kiểu dữ liệu)

⚡️ Các kiểu dữ liệu cơ bản (Basic data types)

Kiểu dữ liệu	Kích thước	Phạm vi
char	1 byte	−128 ~ 127
signed char	1 byte	−128 ~ 127
unsigned char	1 byte	0 ~ 255
int	2 đến 4 bytes	−32,768 ~ 32,767
signed int	2 bytes	−32,768 ~ 32,767
unsigned int	2 bytes	0 ~ 65,535
short int	2 bytes	−32,768 ~ 32,767
signed short int	2 bytes	−32,768 ~ 32,767
unsigned short int	2 bytes	0 ~ 65,535
long int	4 bytes	-2,147,483,648 ~ 2,147,483,647
signed long int	4 bytes	-2,147,483,648 ~ 2,147,483,647
unsigned long int	4 bytes	0 ~ 4,294,967,295
float	4 bytes	3.4E-38 ~ 3.4E+38
double	8 bytes	1.7E-308 ~ 1.7E+308
long double	10 bytes	3.4E-4932 ~ 1.1E+4932

⚡️ Ví dụ kiểu dữ liệu (Data types)

Data types

// tạo biến
int myNum = 5; // kiểu integer
float myFloatNum = 5.99; // số chấm động (floating)
char myLetter = 'D'; // chuỗi (string)

// in kết quả
printf("%d\n", myNum);
printf("%f\n", myFloatNum);
printf("%c\n", myLetter);
printf("%lf\n", myDouble);

⚡️ Định dạng (Basic format specifiers)

Basic format specifiers

%d hoặc %i	// dành cho kiểu int
%f	        // dành cho kiểu float
%lf	        // dành cho kiểu double
%c	        // dành cho kiểu char
%s	        // dành cho chuỗi

Octal (Bát phân)

• %o: Sử dụng để hiển thị giá trị ở dạng bát phân (base 8).
• %ho: Tương tự như %o, nhưng là cho giá trị số nguyên ngắn (short).

Ví dụ:

Octal

int value = 64;
printf("%o\n", value);  // In ra: 100

Decimal (Thập phân)

• %d: Sử dụng để hiển thị giá trị ở dạng thập phân (base 10).
• %ld: Tương tự như %d, nhưng là cho giá trị số nguyên dài (long).
• %hd: Tương tự như %d, nhưng là cho giá trị số nguyên ngắn (short).

Ví dụ:

Decimal

int value = 42;
printf("%d\n", value);  // In ra: 42

Hexadecimal (Thập lục phân)

• %x hoặc %X: Sử dụng để hiển thị giá trị ở dạng thập lục phân (base 16).
• %lx hoặc %lX: Tương tự như %x/%X, nhưng là cho giá trị số nguyên dài (long).
• %hx hoặc %hX: Tương tự như %x/%X, nhưng là cho giá trị số nguyên ngắn (short).

Ví dụ:

Hexadecimal

int value = 255;
printf("%x\n", value); // In ra: ff

4. Preprocessor

Trong ngôn ngữ lập trình C, preprocessor là một phần của quá trình biên dịch (compilation process). Preprocessor thực hiện các xử lý trước khi mã nguồn C được chuyển đổi thành mã máy.

⚡️ Preprocessor Directives

Từ khoá	Mô tả
#define	Định nghĩa một macro
#include	Chèn một file mã nguồn vào chương trình
#undef	Hủy định nghĩa của một macro đã được định nghĩa trước đó
#ifdef	Trả về true nếu macro đã được định nghĩa
#ifndef	Trả về true nếu macro chưa được định nghĩa
#if	Biên dịch mã nguồn sau nếu điều kiện cho trước là true
#else	Lựa chọn thay thế cho #if
#elif	Nếu điều kiện của #if là false, kiểm tra điều kiện mới này là true
#endif	Kết thúc khối biên dịch có điều kiện #if...#else
#error	In ra một thông báo lỗi khi gặp lỗi chuẩn
#pragma	Gửi các lệnh đặc biệt tới trình biên dịch sử dụng phương pháp chuẩn

Preprocessor Directives

#define MAX_ARRAY_LENGTH 20 // Định nghĩa một macro có tên là MAX_ARRAY_LENGTH và gán giá trị 20 cho nó.
#include <stdio.h> // Chèn nội dung của file stdio.h từ thư viện hệ thống vào mã nguồn.
#include "myheader.h" // Chèn nội dung của file myheader.h từ thư mục local vào mã nguồn.
#undef FILE_SIZE // Hủy định nghĩa của macro FILE_SIZE.

⚡️ Predefined macros

Tên Macro	Mô tả
__DATE__	Ngày hiện tại, một hằng ký tự trong định dạng "MMM DD YYYY" (Tháng Ngày Năm)
__TIME__	Giờ hiện tại, một hằng ký tự trong định dạng "HH:MM:SS" (Giờ:Phút:Giây)
__FILE__	Chứa tên file mã nguồn hiện tại, một hằng ký tự
__LINE__	Chứa số dòng hiện tại trong mã nguồn, một hằng số thập phân
__STDC__	Được định nghĩa là 1 khi trình biên dịch biên dịch theo tiêu chuẩn ANSI

Predefined macros

#include <stdio.h>

int main() {
  printf("File :%s\n", __FILE__);
  printf("Date :%s\n", __DATE__);
  printf("Time :%s\n", __TIME__);
  printf("Line :%d\n", __LINE__);
  printf("ANSI :%d\n", __STDC__);
}

⚡️ Toán tử tiếp tục Macro (Macro continuation operator ())

Macro continuation operator ()

// Thông thường, một macro được viết trên một dòng duy nhất.
#define message_for(a, b) \
    printf(#a " và " #b ": Chúng tôi yêu bạn!\n")
// Nếu macro quá dài và không thể trên một dòng, sử dụng toán tử tiếp tục Macro `\`

⚡️ Toán tử Hằng ký chuỗi (String Constantization Operator (#))

String Constantization Operator (#)

#include <stdio.h>
#define message_for(a, b) \
  printf(#a " và " #b ": Chúng tôi yêu bạn!\n")

int main(void) {
  message_for(Carole, Debra);

  return 0;
}
// Khi mã trên được biên dịch và thực thi, nó sẽ tạo ra kết quả như sau:
// Output: Carole và Debra: Chúng tôi yêu bạn!
// Khi bạn cần chuyển đổi một tham số macro thành một hằng ký chuỗi, sử dụng toán tử hằng ký chuỗi #

⚡️ Toán tử nối tag (tag paste operator (##))

tag paste operator (##)

#include <stdio.h>

#define tokenpaster(n) printf ("token" #n " = %d", token##n)

int main(void) {
  int token34 = 40;
  tokenpaster(34);

  return 0;
}

⚡️ Toán tử defined() (defined() operator)

defined() operator

#include <stdio.h>

#if !defined (MESSAGE)
   #define MESSAGE "You wish!"
#endif

int main(void) {
  printf("Here is the message: %s\n", MESSAGE);

  return 0;
}

⚡️ Macros có tham số (Parameterized macros)

Parameterized macros

int square(int x) {
  return x * x;
}

// Macro viết lại mã trên như sau:
#define square(x) ( (x) * (x) )

// Không cho phép có khoảng trắng giữa tên macro và dấu ngoặc mở
#include <stdio.h>
#define MAX(x,y) ( (x) > (y) ? (x) : (y) )

int main(void) {
  printf("Giá trị lớn nhất giữa 20 và 10 là %d\n", MAX(10, 20));

  return 0;
}

5. Function (hàm)

⚡️ Khai báo và định nghĩa hàm (Function declaration and definition)

Function declaration and definition

int main(void) {
  printf("Hello World!");

  return 0;
}

// Hàm bao gồm hai phần
void myFunction() { // phần khai báo (declaration)
  // thân hàm (mã để thực thi)
}

// Khai báo chỉ định tên hàm, kiểu trả về và các tham số (nếu có)
// Định nghĩa thân hàm (mã để thực thi)
// khai báo hàm
void myFunction();

int main() {
  myFunction(); // --> gọi hàm

  return 0;
}

void myFunction() {// Định nghĩa hàm
  printf("Good evening!");
}

⚡️ Gọi hàm (Call function)

Call function

// tạo hàm
void myFunction() {
  printf("Good evening!");
}

int main() {
 myFunction(); // gọi hàm
  myFunction(); // có thể gọi nhiều lần

  return 0;
}
// Output -> "Good evening!"
// Output -> "Good evening!"

⚡️ Nhiều tham số (Multiple parameters)

Multiple parameters

void myFunction(char name[], int age) {
  printf("Hi %s, you are %d years old.\n",name,age);
}
int main() {
  myFunction("Liam", 3);
  myFunction("Jenny", 14);

  return 0;
}
// Hi Liam you are 3 years old.
// Hi Jenny you are 14 years old.

⚡️ Tham số hàm (Function parameters)

Function parameters

void myFunction(char name[]) {
  printf("Hello %s\n", name);
}

int main() {
  myFunction("Liam");
  myFunction("Jenny");

  return 0;
}
// Hello Liam
// Hello Jenny

⚡️ Trả về giá trị (Return value)

Return value

int myFunction(int x) {
  return 5 + x;
}

int main() {
  printf("Result: %d", myFunction(3));
  return 0;
}
// output 8 (5 + 3)

// 2 tham số
int myFunction(int x, int y) {
  return x + y;
}

int main() {
  printf("Result: %d", myFunction(5, 3));
  // lưu kết quả vào biến
  int result = myFunction(5, 3);
  printf("Result = %d", result);

  return 0;
}
// result: 8 (5 + 3)
// result = 8 (5 + 3)

⚡️ Ví dụ về đệ quy (Recursive example)

Recursive example

int sum(int k);

int main() {
  int result = sum(10);
  printf("%d", result);

  return 0;
}

int sum(int k) {
  if (k > 0) {
    return k + sum(k -1);
  } else {
    return 0;
  }
}

⚡️ Các hàm toán học (Mathematical functions)

Mathematical functions

#include <math.h>

void main(void) {
  printf("%f", sqrt(16)); // căn bậc hai
  printf("%f", ceil(1.4)); // làm tròn lên
  printf("%f", floor(1.4)); // làm tròn xuống
  printf("%f", pow(4, 3)); // x(4) mũ y(3)
}
// abs(x) giá trị tuyệt đối
// acos(x) giá trị cung của x
// asin(x) giá trị sine của x
// atan(x) giá trị tangent của x
// cbrt(x) căn bậc ba
// cos(x) cosin của x
// giá trị của exp(x) Ex
// sin(x) giá trị sine của x
// giá trị của tan(x) tangent của x

6. Structures

⚡️ Tạo struct (Create structure)

Create structure

struct MyStructure { // khai báo cấu trúc
  int myNum; // thành viên (biến int)
  char myLetter; // thành viên (biến char)
}; // kết thúc cấu trúc bằng dấu chấm phẩy
// Tạo một biến cấu trúc có tên là s1

struct myStructure {
  int myNum;
  char myLetter;
};

int main() {
  struct myStructure s1;

  return 0;
}

⚡️ Chuỗi trong stuct (Strings in the structure)

Strings in the structure

struct myStructure {
  int myNum;
  char myLetter;
  char myString[30]; // Chuỗi
};

int main() {
  struct myStructure s1;
  strcpy(s1. myString, "Một số văn bản");
  // in giá trị
  printf("Chuỗi của tôi: %s", s1.myString);

  return 0;
}
// Gán giá trị cho chuỗi bằng hàm strcpy

⚡️ Truy cập thành viên (Accessing structure members)

Accessing structure members

// tạo một cấu trúc có tên là myStructure
struct myStructure {
  int myNum;
  char myLetter;
};

int main() {
  // Tạo biến cấu trúc có tên myStructure được gọi là s1
  struct myStructure s1;
  // Gán giá trị cho các thành viên của s1
  s1.myNum = 13;
  s1.myLetter = 'B';

  // Tạo biến cấu trúc của myStructure được gọi là s2 và gán giá trị cho nó
  struct myStructure s2 = {13, 'B'};
  // in giá trị
  printf("Số của tôi: %d\n", s1.myNum);
  printf("Chữ của tôi: %c\n", s1.myLetter);

  return 0;
}

// Tạo các biến cấu trúc khác nhau
struct myStructure s1;
struct myStructure s2;
// Gán giá trị cho các biến cấu trúc khác nhau
s1.myNum = 13;
s1.myLetter = 'B';

s2.myNum = 20;
s2.myLetter = 'C';

⚡️ Sao chép cấu trúc (Copy structure)

Copy structure

struct myStructure s1 = {
  13, 'B', "Some text"
};

struct myStructure s2;
s2 = s1;
// Trong ví dụ, giá trị của s1 được sao chép vào s2

⚡️ Sửa đổi giá trị (Modify value)

Modify value

// Tạo một biến cấu trúc và gán giá trị cho nó
struct myStructure s1 = {
  13, 'B'
};
// sửa đổi giá trị
s1.myNum = 30;
s1.myLetter = 'C';
// in giá trị
printf("%d %c %s", s1.myNum, s1.myLetter);

7. file processing (xử lý file)

⚡️ Hàm xử lý file (File processing function)

File processing function

fopen()	// mở một tệp mới hoặc tệp hiện tại
fprintf() // ghi dữ liệu vào tệp
fscanf() // đọc dữ liệu từ tệp
fputc()	// ghi một ký tự vào tệp
fgetc()	// đọc một ký tự từ tệp
fclose() // đóng tệp
fseek()	// đặt con trỏ tệp ở vị trí đã cho
fputw()	// ghi một số nguyên vào tệp
fgetw()	// đọc một số nguyên từ tệp
ftell()	// trả về vị trí hiện tại
rewind() // đặt con trỏ tệp ở đầu tệp
// Có nhiều hàm trong thư viện C để mở/đọc/ghi/tìm kiếm và đóng tệp

⚡️ Tham số trong open mode (Open mode parameter)

Tham số	Mô tả
r	Mở tệp văn bản ở chế độ đọc, cho phép đọc tệp
w	Mở tệp văn bản ở chế độ ghi, cho phép ghi vào tệp
a	Mở tệp văn bản ở chế độ nối thêm. Nếu tệp không tồn tại, một tệp mới sẽ được tạo
r+	Mở tệp văn bản ở chế độ đọc - viết, cho phép đọc và viết vào tệp
w+	Mở tệp văn bản ở chế độ đọc - viết, cho phép đọc và viết vào tệp
a+	Mở tệp văn bản ở chế độ đọc - viết, cho phép đọc và viết vào tệp
rb	Mở tệp nhị phân ở chế độ đọc
wb	Mở tệp nhị phân ở chế độ ghi
ab	Mở tệp nhị phân ở chế độ nối thêm
rb+	mở tệp nhị phân ở chế độ đọc - viết
wb+	mở tệp nhị phân ở chế độ đọc - viết
ab+	mở tệp nhị phân ở chế độ đọc - viết

⚡️ Đọc file: fopen()

Open the file: fopen()

#include <stdio.h>

void main() {
  FILE *fp;
  char ch;

  fp = fopen("file_handle.c", "r");

  while (1) {
    ch = fgetc(fp);
    if (ch == EOF)
      break;
    printf("%c", ch);
  }
  fclose(fp);
}
// Sau khi thực hiện tất cả các hoạt động trên tệp, tệp phải được đóng bằng fclose()

⚡️ Ghi vào file: fprintf()

Write to file: fprintf()

#include <stdio.h>

void main() {
  FILE *fp;
  fp = fopen("file.txt", "w"); // mở tệp

  // ghi dữ liệu vào tệp
  fprintf(fp, "Hello fprintf..\n");
  fclose(fp); // đóng tệp
}

⚡️ Đọc vào file: fscanf()

Read the file: fscanf()

#include <stdio.h>

void main() {
  FILE *fp;

  char buff[255]; // Tạo một mảng char để lưu trữ dữ liệu tệp
  fp = fopen("file.txt", "r");

  while(fscanf(fp, "%s", buff) != EOF) {
    printf("%s ", buff);
  }
  fclose(fp);
}

⚡️ Ghi vào file: fputc()

Write to file: fputc()

#include <stdio.h>

void main() {
  FILE *fp;
  fp = fopen("file1.txt", "w"); // mở tệp
  fputc('a',fp); // ghi một ký tự vào tệp
  fclose(fp); // đóng tệp
}

⚡️ Đọc vào file: fgetc()

Read the file: fgetc()

#include <stdio.h>
#include <conio.h>

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

  clrscr();

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

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

  getch();
}

⚡️ Ghi vào file: fputs()

Write to file: fputs()

#include<stdio.h>
#include<conio.h>

void main() {
  FILE *fp;

  clrscr();

  fp = fopen("myfile2.txt","w");
  fputs("hello c programming",fp);
  fclose(fp);

  getch();
}

⚡️ Đọc files: fgets()

Read files: fgets()

#include<stdio.h>
#include<conio.h>

void main() {
  FILE *fp;
  char text[300];

  clrscr();

  fp = fopen("myfile2.txt", "r");
  printf("%s", fgets(text, 200, fp));
  fclose(fp);

  getch();
}

⚡️ fseek()

fseek()

#include <stdio.h>

void main(void) {
  FILE *fp;

  fp = fopen("myfile.txt","w+");
  fputs("this is book", fp);

  // Đặt con trỏ tệp ở vị trí đã cho
  fseek(fp, 7, SEEK_SET);

  fputs("Kenny Wong", fp);
  fclose(fp);
}
// Đặt con trỏ tệp ở vị trí đã cho

⚡️ rewind()

rewind()

#include <stdio.h>
#include <conio.h>

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

  clrscr();

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

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

  rewind(fp); // di chuyển con trỏ tệp về đầu tệp

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

  getch();
}
// output
// Hello World! Hello World!

⚡️ ftell()

ftell()

#include <stdio.h>
#include <conio.h>

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

   clrscr();

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

   fseek(fp, 0, SEEK_END);
   length = ftell(fp); // trả về vị trí hiện tại
   fclose(fp);

   printf("File size: %d bytes", length);

   getch();
}
// output
// file size: 18 bytes

II. Tài liệu tham khảo

• quickref