├── 04. Biến, nhập xuất dữ liệu.md
├── 05. Các kiểu dữ liệu.md
├── 06. Biến cục bộ, biến toàn cục.md
└── 09. Toán tử quan hệ, toán tử logic.md


/04. Biến, nhập xuất dữ liệu.md:
--------------------------------------------------------------------------------
 1 | ## Biến (variable) là gì?
 2 | - Biến là thứ được dùng để lưu trữ dữ liệu của chương trình và nó mang ý nghĩa có thể thay đổi được.
 3 | - Cách sử dụng biến:
 4 |     - Trước khi sử dụng phải khai báo biến
 5 |     - Cú pháp khai báo: `<Kiểu dữ liệu> <Tên biến>;` hoặc `<Kiểu dữ liệu> <Tên biến 1>, <Tên biến 2>,...;`
 6 | 
 7 |     ```c
 8 |     #include <iostream>
 9 | 
10 |     int main()
11 |     {
12 |         int i; // Khai báo biến i có kiểu dữ liệu số nguyên (integer)
13 |         float f; // Khai báo biến f có kiểu dữ liệu số thực (float)
14 |         char c; // Khai báo biến c có kiểu dữ liệu ký tự (character)
15 | 
16 |         int a, b; // Khai báo 2 biến a, b có kiểu dữ liệu số nguyên (integer)
17 | 
18 |         int d = 1; // Khai báo biến d và gán (assign) cho biến d giá trị 1
19 | 
20 |         std::cout << d;
21 | 
22 |         return 0;
23 |     }
24 |     ```
25 |     Kết quả:
26 |     ```
27 |     1
28 |     ```
29 | 
30 | ## Cách đặt tên biến
31 | - Không đặt tên biến trùng với từ khóa (void, for, while, do, delete,...)
32 | - Tên biến không chứa khoảng trắng hoặc ký tự đặc biệt
33 | - Ký tự đầu tiên của tên biến phải là chữ cái
34 | 
35 | ## Nhập xuất dữ liệu
36 | - Để nhập xuất dữ liệu trong C++, chúng ta sử dụng thư viện `iostream`. Thư viện này cung cấp cho chúng ta những thứ được định nghĩa sẵn để sử dụng.
37 |     - `std::cout`: In dữ liệu ra console
38 |     ```c
39 |     #include <iostream>
40 | 
41 |     int main()
42 |     {
43 |         std::cout << "Hello World!"; // In ra console chuỗi "Hello World!"
44 | 
45 |         return 0;
46 |     }
47 |     ```
48 |     Kết quả:
49 |     ```
50 |     Hello World!
51 |     ```
52 |     - `std::cin`: Đọc dữ liệu từ bàn phím và gán dữ liệu cho biến được chỉ định. Dùng cho thao tác nhập dữ liệu.
53 |     ```c
54 |     #include <iostream>
55 | 
56 |     int main()
57 |     {
58 |         int x;
59 |         std::cout << "x = ";
60 |         std::cin >> x; // Nhập vào giá trị của x
61 | 
62 |         std::cout << "Value of x: " << x; // In ra console giá trị của x
63 | 
64 |         return 0;
65 |     }
66 |     ```
67 |     Kết quả:
68 |     ```
69 |     x = 10
70 |     Value of x: 10
71 |     ```
72 |     - `std::endl`: Ngắt dòng khi hiển thị dữ liệu trên console, có thể dùng ký tự `\n` để thay thế.
73 |     ```c
74 |     #include <iostream>
75 | 
76 |     int main()
77 |     {
78 |         std::cout << "Hello World!" << std::endl;
79 |         std::cout << "CPP" << std::endl << "Learing!" << std::endl;
80 |         std::cout << "Full\nStack";
81 | 
82 |         return 0;
83 |     }
84 |     ```
85 |     Kết quả:
86 |     ```
87 |     Hello World!
88 |     CPP 
89 |     Learning!
90 |     Full 
91 |     Stack
92 |     ```
93 | 


--------------------------------------------------------------------------------
/05. Các kiểu dữ liệu.md:
--------------------------------------------------------------------------------
 1 | ## Các kiểu dữ liệu thường gặp
 2 | - Các kiểu dữ liệu thường gặp trong C++: 
 3 |     - Integer (int): Kiểu số nguyên (`1`, `2`, `3`)
 4 |     - Float (float): Kiểu số thực (`1.2`, `1.3`, `3.14`,...)
 5 |     - Double (double): Kiểu số thực (có giới hạn lưu trữ lớn hơn so với float)
 6 |     - Boolean (bool): 1/0 (True/False)
 7 |     - Character (char): Kiểu ký tự (`'a'`, `'b'`, `'c'`,...)
 8 | - Ngoài ra còn có các kiểu dữ liệu khác: `long`, `long long`, `unsigned long`, `short`, `unsigned short`,...
 9 | 
10 |     ```c
11 |     #include <iostream>
12 | 
13 |     int main()
14 |     {
15 |         int a = 1;
16 |         
17 |         float b = 1.4;
18 |         
19 |         double c = 3.14;
20 |         
21 |         char d = 'a';
22 |         
23 |         bool e = true;
24 |         bool f = 1;
25 | 
26 |         return 0;
27 |     }
28 |     ```
29 | 
30 | ## Giới hạn lưu trữ
31 | - Ngoài việc lưu trữ các loại dữ liệu khác nhau, mỗi kiểu dữ liệu lại có các giới hạn lưu trữ khác nhau
32 | 
33 |     Ví dụ:
34 |     - Kiểu `int` có thể lưu trữ 4 byte (-2,147,483,648 tới 2,147,483,647)
35 |     - Kiểu `short` có thể lưu trữ 2 byte (-32,768 tới 32,767)
36 | - Sử dụng các macro sau đây để kiểm tra giá trị lớn nhất hoặc nhỏ nhất mà 1 kiểu dữ liệu có thể lưu trữ
37 |     - `INT_MAX`: Giá trị lớn nhất mà kiểu `int` có thể lưu trữ.
38 |     - `INT_MIN`: Giá trị nhỏ nhất mà kiểu `int` có thể lưu trữ.
39 |     - `SHRT_MAX`: Giá trị nhất mà kiểu `short` có thể lưu trữ.
40 |     - `SHRT_MIN`: Giá trị nhỏ nh mà kiểu `short` có thể lưu trữ.
41 |     - `LONG_MAX`: Giá trị nhất mà kiểu `long` có thể lưu trữ.
42 |     - `LONG_MIN`: Giá trị nhỏ nh mà kiểu `long` có thể lưu trữ.
43 |     - `FLT_MAX`: Giá trị nhất mà kiểu `float` có thể lưu trữ.
44 |     - `FLT_MIN`: Giá trị nhỏ nh mà kiểu `float` có thể lưu trữ.
45 |     - `DBL_MAX`: Giá trị nhất mà kiểu `double` có thể lưu trữ.
46 |     - `DBL_MIN`: Giá trị nhỏ nh mà kiểu `double` có thể lưu trữ.
47 | 
48 |     Ví dụ:
49 |     ```c
50 |     #include <iostream>
51 | 
52 |     int main()
53 |     {
54 |         std::cout << "Min int: " << INT_MIN << std::endl;
55 |         std::cout << "Max int: " << INT_MAX << std::endl;
56 |         std::cout << "Min short: " << SHRT_MIN << std::endl;
57 |         std::cout << "Max short: " << SHRT_MAX << std::endl;
58 | 
59 |         return 0;
60 |     }
61 |     ```
62 | - Sử dụng `sizeof` để xác định số lượng byte mà một kiểu dữ liệu có thể lưu trữ
63 | 
64 |     Ví dụ:
65 |     ```c
66 |     #include <iostream>
67 | 
68 |     int main()
69 |     {
70 |         std::cout << "Int: " << sizeof(int) << std::endl; // 4
71 |         std::cout << "Float: " << sizeof(float) << std::endl; // 4
72 |         std::cout << "Double: " << sizeof(double) << std::endl; // 8
73 |         std::cout << "Bool: " << sizeof(bool) << std::endl; // 1
74 |         std::cout << "Char: " << sizeof(char) << std::endl; // 1
75 |         std::cout << "Long: " << sizeof(long) << std::endl; // 4
76 | 
77 |         return 0;
78 |     }
79 |     ```
80 | 


--------------------------------------------------------------------------------
/06. Biến cục bộ, biến toàn cục.md:
--------------------------------------------------------------------------------
 1 | ## Biến cục bộ và biến toàn cục
 2 | 
 3 | 1. Phạm vi cục bộ
 4 | - Trong 1 chương trình sẽ có các phạm vi (scope), mỗi 1 phạm vi sẽ được thể hiện bằng dấu `{}`.
 5 | - Biến khai báo ở phạm vi nào thì chỉ được sử dụng ở trong phạm vi đó (đó được gọi là các biến cục bộ).
 6 | 
 7 |     Ví dụ:
 8 |     ```cpp
 9 |     #include <iostream> 
10 | 
11 |     int main()
12 |     {
13 |         int main_var = 0;
14 |         std::cout << main_var << std::endl;
15 | 
16 |         { // Phạm vi 1
17 |             int scope_var_1 = 1;
18 |             std::cout << scope_var_1 << std::endl;
19 | 
20 |             {
21 |                 std::cout << scope_var_1 << std::endl;
22 |             }
23 |         }
24 | 
25 |         { // Phạm vi 2
26 |             int scope_var_2 = 2;
27 |             std::cout << scope_var_2 << std::endl;
28 |             std::cout << scope_var_1 << std::endl; // Lỗi: scope_var_1 was not declared in this scope
29 |         }
30 | 
31 |         return 0;
32 |     }
33 |     ```
34 | - Khi có 1 biến ở phạm vi bên trong trùng tên với 1 biến ở phạm vi bên ngoài, chương trình sẽ ưu tiên lấy giá trị của biến ở phạm vi gần nhất tính từ trong ra ngoài.
35 | 
36 |     Ví dụ:
37 |     ```cpp
38 |     #include <iostream>
39 | 
40 |     int main()
41 |     {
42 |         int main_var = 0;
43 | 
44 |         {
45 |             int main_var = 1;
46 |             std::cout << main_var; // 1
47 |         }
48 | 
49 |         std::cout << main_var; // 0
50 | 
51 |         return 0;
52 |     }
53 |     ```
54 | 2. Phạm vi toàn cục
55 | - Các biến được khai báo ở bên ngoài chương trình được gọi là biến toàn cục có thể được sử dụng ở bất cứ nơi nào trong chương trình.
56 | 
57 |     Ví dụ:
58 |     ```cpp
59 |     #include <iostream>
60 | 
61 |     int global_var = 1;
62 | 
63 |     int main()
64 |     {
65 |         std::cout << "Main scope: " << global_var << std::endl;
66 | 
67 |         { // Phạm vi 1
68 |             std::cout << "Scope 1: " << global_var << std::endl;
69 |         }
70 | 
71 |         { // Phạm vi 2
72 |             std::cout << "Scope 2: " << global_var << std::endl;
73 |         }
74 | 
75 |         return 0;
76 |     }
77 |     ```
78 | 


--------------------------------------------------------------------------------
/09. Toán tử quan hệ, toán tử logic.md:
--------------------------------------------------------------------------------
 1 | ##  Toán tử quan hệ
 2 | - Là các phép toán để thực hiện việc so sánh: `>`, `<`, `>=`, `<=`, `==`, `!=`.
 3 | - Các phép toán này trả về giá trị boolean.
 4 | 
 5 |     Ví dụ:
 6 |     ```c
 7 |     #include <iostream>
 8 | 
 9 |     int main()
10 |     {
11 |         std::cout << (3 > 2) << std::endl; // 1 - true
12 |         std::cout << (1 > 2) << std::endl; // 0 - false
13 | 
14 |         int a = 3;
15 |         int b = 3;
16 |         std::cout << (a == b) << std::endl; // 1 - true
17 |         std::cout << (a != b) << std::endl; // 0 - false
18 | 
19 |         bool c = a < b;
20 |         std::cout << c << std::endl; // 0 - false
21 | 
22 |         return 0;
23 |     }
24 |     ```
25 |     Kết quả:
26 |     ```
27 |     1
28 |     0
29 |     1
30 |     0
31 |     0
32 |     ```
33 | - Lưu ý: 2 giá trị tham gia vào phép so sánh phải có cùng kiểu dữ liệu.
34 | 
35 | ##  Toán tử logic
36 | -  Các toán tử logic trong C++: `AND (&&)`, `OR (||)`, `NOT (!)`
37 |     - AND: Nếu 2 vế đều là `true` thì kết quả trả về là `true`, các trường hợp còn lại thì trả về `false`.
38 |     - OR: Nếu 2 vế đều là `false` thì kết quả trả về là `false`, các trường hợp còn lại thì trả về `true`.
39 |     - NOT: Trả về giá trị phủ định.
40 | 
41 |     Ví dụ:
42 |     ```c
43 |     #include <iostream>
44 | 
45 |     int main()
46 |     {
47 |         // AND
48 |         std::cout << (true && true) << std::endl; // 1 - true
49 |         std::cout << (true && false) << std::endl; // 0 - false
50 |         std::cout << (false && true) << std::endl; // 0 - false
51 |         std::cout << (false && false) << std::endl; // 0 - false
52 | 
53 |         // OR
54 |         std::cout << (true || true) << std::endl; // 1 - true
55 |         std::cout << (true || false) << std::endl; // 1 - true
56 |         std::cout << (false || true) << std::endl; // 1 - true
57 |         std::cout << (false || false) << std::endl; // 0 - false
58 | 
59 |         // NOT
60 |         std::cout << !true << std::endl; // 0 - false
61 |         std::cout << !false << std::endl; // 1 - true
62 | 
63 |         return 0;
64 |     }
65 |     ```
66 | - Sử dụng kết hợp với toán tử quan hệ.
67 | 
68 |     Ví dụ:
69 |     ```c
70 |     #include <iotream>
71 | 
72 |     int main()
73 |     {
74 |         int a = 1, b = 2, c = 3;
75 | 
76 |         bool d = (a < b) && (b > c); // true && false
77 |         bool e = (a < b) || (b > c); // true || false
78 | 
79 |         std::cout << d << std::endl; // 0 - false
80 |         std::cout << e << std::endl; // 1 - true
81 | 
82 |         return 0;
83 |     }
84 |     ```
85 | 


--------------------------------------------------------------------------------