# C++ Tutorial For Newbie
Course: C++ for newbie
Price: Free
## Phần 1: Hiểu về code
### Khái niệm
>- Ngôn ngữ máy là ngôn ngữ mà máy có thể hiểu. Ngôn ngữ máy thường chỉ là các đoạn mã nhị phân gồm 2 ký tự là 1 và 0
>- Do việc lập trình trên đoạn mã chỉ có 2 chỉ số 1 và 0 là vô cùng khó nên các ngôn ngữ lập trình sinh ra để giúp mọi thứ dễ dàng hơn
### Cách để máy hiểu ngôn ngữ lập trình
>- Khi ta viết code ta sẽ sử dụng 1 trình dịch để chuyển từ ngôn ngữ lập trình sang ngôn ngữ máy để máy có thể hiểu và thực hiện
>- Mô hình chuyển: Code $\rightarrow$ Compiler $\rightarrow$ Program.
## Phần 2: Xây dựng môi trường cho việc code:
### Điều kiện cần của một môi trường code
**Để xây dựng một môi trường để code ta cần 2 thứ**
>1. Code Editor: Phần mềm để viết các đoạn code
>2. Compiler: Trình dịch code theo ngôn ngữ (ở đây là C++)
> [!Note]
> Và có nhiều phần mềm có thể đảm nhận được cả 2 vai trò trên ta gọi là IDE.
### Xây dựng môi trường
> Các bước xây dựng như sau:
> - Tải phần mềm Visual Studio Code
> - Tải bộ compiler trên các nguồn (ở đây là [github](https://github.com/longnhat2k9/gnu-compiler) với bộ GNU)
> - Tải extension C++ trên Visual Studio Code (bộ plugin để VSCode tìm ra bộ compiler đã được tải)
## Phần 3: Làm quen với cấu trúc của một chương trình C++:
### 1. Chương trình "Hello, World!"
> **Đề bài**: Viết 1 chương trình in ra dòng chữ "Hello, World!"
Chương trình mẫu:
Mẫu 1:
```cpp=
#include<iostream>
int main()
{
std::cout << "Hello, World!";
return 0;
}
```
Mẫu 2:
```cpp=
#include<iostream>
using namespace std;
int main()
{
cout << "Hello, World!";
return 0;
}
```
Đây là 2 mẫu chương trình mà người mới học sẽ thường thấy và đây là giải thích các phần của chương trình
**Ta sẽ chia chương trình thành 2 phần mà một chương trình bắt buộc phải có**
#### **Phần 1:** Khai báo thư viện
> Các chương trình đều cần khai báo thư viện câu lệnh để trình dịch có thể hiểu được.
```cpp
#include<iostream>
```
Nếu như xem ở mẫu 2 ta sẽ thấy thêm 1 dòng ``` using namespace std;``` đó chính là cách để đến phần 2 ta sẽ đơn giản hóa chương trình
```cpp
#include<iostream>
using namespace std;
```
Ở đây ta thấy được phần khai báo sẽ có dấu ```#``` với từ khóa là ```include``` với tên thư viện nằm trong cặp dấu ```<>```
Tên thư viện là ```iostream``` không phải là "ios tream" mà là "io stream" hay ta hiểu là "input output stream"
#### **Phần 2:** Viết lệnh cho chương trình
>[!Important]
>Điều bắt buộc trong chương trình C++ tại phần 2 đó là ```int main()```
Bên trong hai dấu ngoặc kép của phần main chính là các câu lệnh sẽ dùng để điều khiển máy tính
Trước hết ta sẽ xem mẫu 1:
```cpp=
int main()
{
std::cout << "Hello, World!";
return 0;
}
```
Ta thấy được yêu cầu là in ra dòng ```Hello, World!``` và tại câu lệnh đầu tiên trong phần main là ```std::cout << "Hello, World!";``` như vậy thì câu lệnh ```std::cout``` là câu lệnh để in dòng chữ ra màn hình
Tiếp theo ta thấy sau mỗi dòng lệnh là dấu ```;``` đó chính là dấu ngắt giữa các lệnh
Và ta thấy thêm 1 câu lệnh ```return 0``` ở cuối, đó là câu lệnh báo hiệu chương trình đã kết thúc
Vậy **tại sao lại có câu lệnh ```using namespace std;``` trong phần khai báo thư viện ở mẫu 2**
Trước hết ta sẽ so sánh giữa 2 đoạn code trong phần 2 thì phần khác duy nhất chính là dòng để in ra dòng chữ ```Hello, World!```
```cpp
std::cout << "Hello, World!";
```
```cpp
cout << "Hello, World!"
```
Do các câu lệnh đều xuất phát từ bộ thư viện cơ bản nên ta chỉ cần báo với chương trình sử dụng các câu lệnh của bộ ```std``` là được
>[!NOTE]
>Đa số các thư viện đi kèm với trình dịch khi tải xuống đều nằm trong bộ std nên chỉ cần đúng namespace std là đủ
### 2. Biến và đầu vào (Variable and input):
#### **Các khái niệm:**
>-**Biến (Variable):** Là vùng nhớ của một chương trình để lưu trữ các giá trị để tính toán
>-**Đầu vào (Input):** Là cách đưa dữ liệu vào
#### **1. Biến**
Trước hết vì nó là bộ nhớ nên nó có thể lưu trữ chữ, số,... Và để phân biệt thì ta có 1 thứ là kiểu dữ liệu
##### Kiểu dữ liệu
> Có 4 dạng phổ biến về kiểu dữ liệu
**Kiểu số nguyên**:
|Tên|Tên khai báo|Độ lớn dữ liệu có thể nhớ|
|---------------|---------------------------|---------------------|
|int|int|-2,147,483,648 $\rightarrow$ 2,147,483,647|
|long long int|long long|-9223372036854775808 $\rightarrow$ 9223372036854775807|
**Kiểu số thực (chủ yếu là lưu số thập phân)**
|Tên|Tên khai báo|Độ lớn dữ liệu có thể nhớ|
|---------------|---------------------------|---------------------|
|float|float|6 - 9 chữ số thập phân|
|double|double|15 - 18 chữ số thập phân |
|long double|long double|33 - 36 chữ số thập phân|
**Kiểu ký tự và chuỗi**
|Tên|Tên khai báo|Độ lớn dữ liệu có thể nhớ|
|---------------|---------------------------|---------------------|
|char|char|1 ký tự|
|string|string|không giới hạn|
**Kiểu đúng sai**
Tên: ```boolean```
Tên khai báo:```bool```
Giá trị có thể lưu: ```true``` ```false``` hay ```1``` ```0```
>[!NOTE]
>- Nếu ta lưu số nguyên bằng kiểu số thực có thể tạo ra sai số
>- Nếu ta lưu số nguyên hoặc số thực bằng ký tự hoặc chuỗi thì nó mất đi khả >năng tính toán
>- Không thể lưu kiểu khác vào kiểu boolean và kiểu boolean không nên lưu dạng số thực hoặc ký tự mà có thể sử dụng ```0``` ```1``` lưu vào kiểu số nguyên
##### Khai báo biến
**Để tạo ra vùng nhớ ta cần khai báo vùng nhớ**
Lệnh khai báo vùng nhớ như sau:
```kiểu dữ liệu``` ```tên biến``` ```;```
>[!Note]
>- Giữa tên dữ liệu và tên biến khai báo cần phải có dấu cách
>- Kiểu dữ liệu sử dụng tên khai báo ở các bảng trên
>- Tên biến chỉ bắt đầu bằng chữ, không trùng với các từ khóa, các từ mang lệnh. Tên biến chỉ chứa duy nhất chữ, số hoặc 2 kí tự ```-``` ```_``` và viết liền không dấu
##### Nhập dữ liệu vào biến
**Cách đưa dữ liệu vào biến (đã khai báo)**
Lệnh đưa dữ liệu vào biến như sau:
```kiểu dữ liệu``` ```tên biến``` ```=``` ```giá trị``` ```;```
>[!NOTE]
>- Nếu biến kiểu char thì giá trị cần đặt trong cặp nháy đơn ```''```, kiểu string thì nháy kép ```""```
**Cách đưa dữ liệu vào biến (chưa khai báo)**
Lệnh đưa dữ liệu vào biến như sau:
```tên biến``` ```=``` ```giá trị``` ```;```
>[!NOTE]
>- Giữa tên dữ liệu và tên biến khai báo cần phải có dấu cách
>- Kiểu dữ liệu sử dụng tên khai báo ở các bảng trên
>- Tên biến chỉ bắt đầu bằng chữ, không trùng với các từ khóa, các từ mang lệnh. Tên biến chỉ chứa duy nhất chữ, số hoặc 2 kí tự ```-``` ```_``` và viết liền không dấu
>- Nếu biến kiểu char thì giá trị cần đặt trong cặp nháy đơn ```''```, kiểu string thì nháy kép ```""```
Ví dụ:
```cpp=
int a;
a = 1;
long long coder-2k9 = 1;
char hello = '1';
string word = "Newbie hoc code";
```
##### Xuất dữ liệu từ bộ nhớ
**Cách in dữ liệu ra màn hình:**
```cout << ``` ```tên biến``` ```;```
>[!Tip]
>Ta có thể kết hợp in ra nhiều biến bằng cách thêm biến vào lệnh cout:
```cout``` ```<< ``` ```tên biến 1``` ```<< ``` ```tên biến 2``` ```<< ``` ```tên biến 3``` ```;```
Ví dụ:
```cpp=
int a;
a = 1;
cout << a;
long long coder-2k9 = 1;
char kitu = '1';
cout << coder-2k9 << kitu;
string day = "Newbie hoc code";
cout << coder-2k9 << kitu << day;
```
Output
```text
11111Newbie hoc code
```
>[!NOTE]
>Để xuống dòng ta chỉ cần chèn thêm ```endl``` vào cuối các lệnh, nếu in trên một dòng có thể thêm dấu cách trong nháy kép ```" "``` để dễ xem
```cpp=
int a;
a = 1;
cout << a << endl;
long long coder-2k9 = 1;
char kitu = '1';
cout << coder-2k9 << kitu << endl;
string chuoi = "Newbie hoc code";
cout << coder-2k9 << " " << kitu << " " << chuoi << endl;
```
```text
1
1 1
1 1 Newbie hoc code
```
##### Nhập dữ liệu
Và việc đưa dữ liệu vào bộ nhớ không chỉ dừng lại ở việc gán thông thường mà nó có thể thay đổi dựa trên người dùng nhập. **Câu lệnh sử dụng là:**
```cin``` ```>>``` ```tên biến``` ```;```
>[!Tip]
>Tương tự lệnh cout ta có thể sử dụng cin nhập hàng loạt bằng việc thêm các biến vào
```cin``` ```>>``` ```tên biến 1``` ```>>``` ```tên biến 2``` ```>>``` ```tên biến 3``` ```;```
>[!NOTE]
>Đảm bảo các biến đã được khai báo và dữ liệu nhập vào đảm bảo phải đúng với kiểu dữ liệu khi khai báo. Các biến nhập cùng lúc thì cách nhau tối thiểu 1 dấu cách khi nhập vào để phân biệt
Ví dụ:
```cpp=
int a;
cin >> a;
cout << a << endl;
long long coder-2k9;
char haiyaa = '1';
cin >> coder-2k9 >> haiyaa;
cout << haiyaa << coder-2k9 << endl;
string quanquai;
cin >> quanquai;
cout << coder-2k9 << " " << haiyaa << " " << quanquai << endl;
```
Input:
```text
1
20 90
blabla
```
Output:
```text
1
90 20
blabla
```
### 3. Ghi chú (Comment)
>[!TIP]
>Khi được cho 1 đoạn code nó quá dài dòng và đọc khó hiểu thì đó là lúc comment cần đến
> Comment có 2 dạng
**Dạng 1**: Comment theo dòng
> Dạng này thì cứ trên 1 dòng (cho dù ở giữa dòng và dòng đang chứa câu lệnh) thì ta chỉ cần thêm ```//``` và tất cả mọi thứ sau dấu đó là comment để bạn có thể đọc hiểu chứ chương trình sẽ không đụng đến nó
**Dạng 2**: Comment theo đoạn
> Dạng này thì có thể comment trên nhiều dòng liên tục và bắt đầu từ sau dấu ```/*``` và kết thúc với dấu ```*/```
Ví dụ
```cpp=
// Comment dạng 1
/*
Comment dạng 2
và kết thúc
*/
long long demo; //Comment ngay sau lệnh.
int a; /*comment dang 2*/
```
### 4. Toán tử
> Có 5 dạng toán tử hay gặp
>
**Dạng 1: Toán tử toán học**
|Toán tử| Ý nghĩa| Ví dụ|
|---|---|---|
|+ |Phép cộng |```int n = 100 + 200; // n = 300```
|- |Phép trừ |```int n = 200 - 100; // n = 100```
|* |Phép nhân |```int n = 28 * 2; // n = 56```
|/ |Phép chia |```int n = 50 / 2; // n = 25```
|% |Phép chia chỉ lấy số dư |```int n = 20 % 3; // n = 2```
**Dạng 2: Toán tử gán toán học**
>[!Note]
Nó là kết hợp giữa gán và tính
Ví dụ: a = a + b thì ta gán a bằng a + b thì phép toán tử gán toán học sẽ giúp viết dạng này rút gọn hơn
|Toán tử |Ví dụ |Ý nghĩa|
|---|---|---|
|+= |```a += b``` |```a = a + b```|
|-= |```a -= b``` |```a = a - b```|
|/= |```a /= b``` |```a = a / b```|
|*= |```a *= b``` |```a = a * b```|
|%= |```a %= b``` |```a = a % b```|
**Dạng 3: Toán tử so sánh**
|Toán tử |Ý nghĩa |Ví dụ|
|---|---|---|
|> |So sánh lớn hơn| ```a > b```|
|>= |Lớn hơn hoặc bằng| ```a >= b```|
|< |So sánh nhỏ hơn |```a < b```|
|<= |Nhỏ hơn hoặc bằng| ```a <= b```|
|!= |So sánh khác |```a != b```|
|== |So sánh bằng |```a == b```|
>[!Important]
Ở dạng này nó chỉ trả về ```true``` hoặc ```false``` nhưng nếu in ra thì nó chỉ hiện ```1``` hoặc ```0```
**Dạng 4: Toán tử tăng giảm**
Khi chỉ cần tăng giảm 1 ta dùng các lệnh này để tăng tốc độ viết
|Toán tử | Ý nghĩa
|---|---|
|```++a``` | Tăng trước|
|```a++``` | Tăng sau|
|```--a``` | Giảm trước|
|```a--``` | Giảm sau |
**Dạng 5: Toán tử logic**
|Toán tử| Ý nghĩa| Cách hoạt động| Ví dụ|Kết quả|
|---|---|---|---|---|
|&& |Toán tử AND (Và)| Cho giá trị đúng khi mọi toán hạng có giá trị đúng, sai trong các trường hợp còn lại |```(10 < 20) && (20 == 20)``` |Đúng
| \|\| | Toán tử OR (Hoặc) |Cho giá trị sai khi mọi toán hạng có giá trị sai, đúng trong các trường hợp còn lại |```(10 > 30) && (30 == 30) ```| Đúng
| ! |Toán tử NOT (Phủ định) |Phủ định của đúng là sai, phủ định của sai là đúng |```!(20 == 20)``` |Sai
## Phần 4: Cấu trúc rẽ nhánh (Câu điều kiện)
**Tại sao câu điều kiện lại là cấu trúc rẽ nhánh?**
>- Câu điều kiện về cơ bản là lệnh if...else... như bình thường
>- Mỗi lệnh if...else... có thể đưa chương trình theo hướng khác tùy theo dữ liệu đưa vào
### 1. Lệnh cơ bản
#### **1. Câu điều kiện dạng thiếu**
Cú pháp
```cpp=
if(/*condition*/)
{
/*Code*/
}
```
> [!NOTE]
> Với
> - phần condition là điều kiện sử dụng các toán tử so sánh và toán tử logic
> - phần code chính là code sẽ chạy nếu điều kiện đúng
**Cách chương trình chạy:** Lệnh trước khi đến if -> Xác nhận condition trong if -> Nếu đúng: Thực hiện code. Nếu sai: Bỏ qua code -> Chạy tiếp phần còn lại của chương trình
Ví dụ
```cpp=
int n;
cin >> n;
if(n % 2 == 0)
{
cout << n << " la so chan";
}
```
Case #1:
Input
```
5
```
Output
```
```
Case #2:
Input
```
6
```
Output
```
6 la so chan
```
#### **2. Câu điều kiện dạng đủ**
Cú pháp
```cpp=
if(/*condition*/)
{
/*Code 1*/
}
else
{
/*Code 2*/
}
```
>[!Note]
>- phần condition là điều kiện sử dụng các toán tử so sánh và toán tử logic
>- phần code 1 chính là code sẽ chạy nếu điều kiện đúng
>- phần code 2 chính là code sẽ chạy nếu điều kiện sai
```cpp=
int n;
cin >> n;
if(n % 2 == 0)
{
cout << n << " la so chan";
}
else
{
cout << n << " la so le";
}
```
Case #1:
Input
```
5
```
Output
```
5 la so le
```
Case #2:
Input
```
6
```
Output
```
6 la so chan
```
**Cách chương trình chạy:** Lệnh trước khi đến if $\rightarrow$ Xác nhận condition trong if $\rightarrow$ Nếu đúng: Thực hiện code 1. Nếu sai: Thực hiện code 2 $\rightarrow$ Chạy tiếp phần còn lại của chương trình
### 2. Nhiều điều kiện (Rẽ nhiều nhánh)
#### **1. Câu điều kiện lồng nhau**
Cú pháp
```cpp=
if(/*condition 1*/)
{
/*Code 1*/
}
else if(/*condition 2*/)
{
/*Code 2*/
}
```
>[!Note]
>- phần condition là điều kiện sử dụng các toán tử so sánh và toán tử logic
>- phần code 1 chính là code sẽ chạy nếu điều kiện condition 1 đúng
>- phần code 2 chính là code sẽ chạy nếu điều kiện condition 2 đúng
Ví dụ
```cpp=
int n;
cin >> n;
if(n % 3 == 0)
{
cout << n << " chia het cho 3";
}
else if(n % 3 == 1)
{
cout << n << " chia 3 du 1";
}
else if (n % 3 == 2)
{
cout << n << "chia 3 du 2";
}
```
Case #1:
Input
```
5
```
Output
```
5 chia 3 du 2
```
Case #2:
Input
```
6
```
Output
```
6 chia het cho 3
```
Case #3:
Input
```
7
```
Output
```
7 chia 3 du 1
```
**Cách chương trình chạy:** Lệnh trước khi đến if $\rightarrow$ Xác nhận condition trong if $\rightarrow$ Nếu đúng: Thực hiện code 1. Nếu sai: ```Xác nhận condition 2 -> Nếu đúng: Thực hiện code 2. Nếu sai: Bỏ qua ```$\rightarrow$ Chạy tiếp phần còn lại của chương trình
>[!Tip]
>Dạng trên có thể thêm
>```cpp=
>else
>{
> /* code 3*/
>}
>```
>[!Note]
>phần code 3 sẽ chạy khi tất cả condition đều sai
Ví dụ
```cpp=
int n;
cin >> n;
if(n % 3 == 0)
{
cout << n << " chia het cho 3";
}
else if(n % 3 == 1)
{
cout << n << " chia 3 du 1";
}
else
{
cout << n << "chia 3 du 2";
}
```
Case #1:
Input
```
5
```
Output
```
5 chia 3 du 2
```
Case #2:
Input
```
6
```
Output
```
6 chia het cho 3
```
Case #3:
Input
```
7
```
Output
```
7 chia 3 du 1
```
**Cách chương trình chạy:** Lệnh trước khi đến if $\rightarrow$ Xác nhận condition trong if $\rightarrow$ Nếu đúng: Thực hiện code 1. Nếu sai: ```Xác nhận condition 2 -> Nếu đúng: Thực hiện code 2. Nếu sai: Thực hiện code 3 ```$\rightarrow$ Chạy tiếp phần còn lại của chương trình
#### **2. Switch...case...**
Cú pháp
```cpp=
switch(/*variable*/)
{
case /*value*/:
/*code*/
break;
case /*value*/:
/*code*/
break;
case /*value*/:
/*code*/
break;
case /*value*/:
/*code*/
break;
default:
/*code*/
}
```
>[!Note]
>- Tại variable hãy chọn 1 biến và cho vào
>- Tại các vị trí value và code hãy chọn các giá trị khác nhau điền vào value và các đoạn code tương ứng vào các vị trí code
>- Nếu tất cả đều sai, chạy code trong phần default
Ví dụ
```cpp=
int a, b;
char op;
cin >> a >> op >> b;
switch(op){
case '+':
cout << a + b << endl;;
break;
case '-':
cout << a - b << endl;;
break;
case '*':
cout << a * b << endl;;
break;
case '/':
cout << a / b << endl;;
break;
default:
cout << "INVALID INPUT" << endl;
}
```
Input
```
5 + 2
```
Output
```
7
```
**Cách chương trình chạy:** Chương trình chạy code $\rightarrow$ Tại vị trí switch xác định giá trị của variable $\rightarrow$ Tìm case có value == variable $\rightarrow$ Nếu có: chạy code của case đó. Nếu không có: chạy code của default $\rightarrow$ break (dừng case không chạy tiếp) $\rightarrow$ Chạy phần còn lại của chương trình
## Phần 5: Cấu trúc vòng lặp
### 1. Vòng lặp với số lần biết trước
```cpp=
for(/*type*/ /*variable*/ = /*start*/; /*condition*/; /*countable*/)
{
/*code*/
}
```
>[!Note]
>- ```type``` là kiểu dữ liệu
>- ```variable``` là tên biến
>- ```start``` là giá trị xuất phát
>- ```condition``` là điều kiện thực hiện vòng lặp
>- ```countable``` là khoảng cách trong mỗi lần đếm (tăng thêm hoặc giảm đi)
Ví dụ
```cpp=
for(int i = 0; i < 5; i++)
{
cout << i << endl;
}
for(int i = 5; i > 0; i--)
{
cout << i << endl;
}
```
Output
```
0
1
2
3
4
5
4
3
2
1
```
> [!Tip]
> Trong ví dụ này ta biết rõ trong mỗi trường hợp chạy chỉ cần lặp 5 lần. Nếu như muốn số lần lặp thay đổi theo cách nhập qua bàn phím ta chỉ cần tạo biến và sử dụng biến đó trong phần ```condỉtion```
```cpp=
int n;
cin >> n;
for(int i = 0; i < n; i++)
{
cout << i << endl;
}
for(int i = n; i >= 0; i--)
{
cout << i << endl;
}
```
### 2. Vòng lặp với số lần chưa biết trước
>Khi ta không thể có cách nào biết được số lần lặp (có thể do biến đếm cần tăng hoặc giảm trong lúc lặp) thì ta sẽ dùng vòng lặp while
```cpp=
while(/*condition*/)
{
/*code*/
}
```
>[!Note]
>- ```condition``` là điều kiện để vòng lặp tiếp tục hoạt động
>- ```code``` là phần code cần lặp đi lặp lại
Ví dụ
```cpp=
int n;
cin >> n;
int i;
cin >> i;
while(i < n)
{
if(i % 3 == 0) i+= 3;
else i -= i % 3;
cout << i << endl;
}
```
Input
```
99 55
```
Output
```
54
57
60
63
66
69
72
75
78
81
84
87
90
93
96
99
```
## Phần 6: Mảng 1 chiều (array) và vector
> Mỗi lần ta cần lưu 1 giá trị ta sẽ khai báo 1 biến nhưng nếu như số lượng biến ta cần có thể chưa biết trước hay các giá trị nhập vào ta muốn lưu nó thành nhóm thì mảng chính là cách chúng ta tạo ra 1 **vùng nhớ** để chứa tất cả giá trị đó
### 1. Mảng (Array)
#### **1. Cách khai báo**
Code
- Khai báo mảng
```type``` ```name``` ```[``` ```size``` ```]``` ```;```
- Khai báo mảng và giá trị của mảng
```type``` ```name``` ```[``` ```size``` ```]``` ```=``` ```{``` ```value1``` ```,``` ```value2``` .... ```}``` ```;```
>[!Note]
>- ```type``` là kiểu dữ liệu của các phần tử trong mảng
>- ```name``` là tên mảng (lưu ý cách đặt tên mảng giống như cách đặt tên biến, đảm bảo các quy tắc đặt tên biến)
>- ```size``` là độ lớn của mảng
>- ```value1```, ```value2``` là các giá trị ta gán trực tiếp vào mảng
#### 2. Cách truy cập vào các phần tử
Để truy cập vào các giá trị trong mảng, ta sử dụng lệnh sau
```name``` ```[``` ```location``` ```]``` ```;```
>[!Note]
>- ```name``` là tên mảng
>- ```location``` là vị trí của phần tử trong mảng(theo cách đếm từ ```0``` đến ```size - 1```)
Ví dụ
```cpp=
int a[100]; //init array with 100 elements
int b[5] = {10, 50, 23, 45, 57} //init array with 5 elements: 10, 50, 23, 45, 57
cout << b[0] << endl; // print the element 0 in array b
```
Output
```
10
```
#### **3. Cách để nhập dữ liệu vào mảng từ bàn phím:**
>[!Important]
>Trước hết đảm bảo dữ liệu mỗi số cách nhau tối thiểu 1 dấu cách
>[!Tip]
>Cách để nhập là ta sử dụng vòng lặp for chạy từ 0 đến size - 1
Ví dụ:
```cpp=
int a[5];
for(int i = 0; i < 5; i++)
{
cin >> a[i];
}
for(int i = 0; i < 5; i++)
{
cout << a[i] << " ";
}
```
Input
```
1 2 3 4 5
```
Output
```
1 2 3 4 5
```
>[!Tip]
>Nếu muốn chọn số lượng phần tử từ bàn phím ta chỉ cần cho thêm biến để nhận số lượng phần tử
```cpp=
int n;
cin >> n;
int a[n];
for(int i = 0; i < n; i++)
{
cin >> a[i];
}
for(int i = 0; i < n; i++)
{
cout << a[i] << " ";
}
```
Input
```
5
1 2 3 4 5
```
Output
```
1 2 3 4 5
```
>[!Warning]
>Đây được gọi là mảng cố định do phần mảng chỉ sử dụng được với số phần tử khai báo trước, nếu như khai báo thiếu ta không thể thêm phần tử vào mảng
>Từ đó ta sinh ra 1 thứ chính là mảng động hay trong C++ là vector
### 2. Vector (Mảng động)
#### **1. Cách khai báo**
>[!Caution]
>Do vector không nằm trong thư viện ```iostream``` nên ta phải khai báo thư viện ```vector``` trước khi tiến hành code
```cpp
#include<vector>
```
Lệnh khai báo
```vector``` ```<``` ```type``` ```>``` ```name``` ```;```
>[!Note]
>- ```type``` là kiểu dữ liệu
>- ```name``` là tên vector
Nhưng nếu ta muốn báo trước với chương trình số lượng phần tử nhất định thì ta dùng lệnh
```vector``` ```<``` ```type``` ```>``` ```name``` ```(``` ```size``` ```)``` ```;```
>[!Note] ```size``` là kích thước vector
Nếu ta muốn báo cho chương trình tất cả phần tử được khai báo trước đều có cùng 1 giá trị giống nhau thì ta khai báo
```vector``` ```<``` ```type``` ```>``` ```name``` ```(``` ```size``` ```,``` ```num``` ```)``` ```;```
>[!Note] ```num``` là giá trị của tất cả các phần tử được khai báo trước
Nếu ta muốn báo cho chương trình giá trị của các phần tử khai báo thì ta làm
```vector``` ```<``` ```type``` ```>``` ```name``` ```(``` ```size``` ```)``` ```=``` ```{``` ```value1``` ```,``` ```value2``` .... ```}``` ```;```
>[!Note] ```value1```, ```value2``` là các giá trị ta gán trực tiếp vào mảng
#### 2. Cách nhập dữ liệu
**Đối với các phần tử đã khai báo**
> Ta làm tương tự như mảng
>[!Tip]
>Cách để nhập là ta sử dụng vòng lặp for chạy từ 0 đến size - 1
Ví dụ:
```cpp=
vectỏr<int>a(5);
for(int i = 0; i < 5; i++)
{
cin >> a[i];
}
for(int i = 0; i < 5; i++)
{
cout << a[i] << " ";
}
```
Input
```
1 2 3 4 5
```
Output
```
1 2 3 4 5
```
**Đối với các phần tử chưa khai báo trước**
Ta sẽ thêm các phần tử đó vào cuối vector bằng cách sử dụng
```name``` ```.``` ```push_back``` ```(``` ```variable/ value``` ```)``` ```;```
```cpp=
vectỏr<int>a;
for(int i = 0; i < 5; i++)
{
int x;
cin >> x;
a.push_back(x); // lenh them phan tu
}
for(int i = 0; i < 5; i++)
{
cout << a[i] << " ";
}
```
Input
```
1 2 3 4 5
```
Output
```
1 2 3 4 5
```
>[!Note]
>- ```name``` là tên vector
>- ```variable/ value``` là 1 biến hoặc 1 giá trị
#### 3. Cách truy cập vào các phần tử
Để truy cập vào các giá trị trong vector ta làm tương tự như mảng
```name``` ```[``` ```location``` ```]``` ```;```
>[!Note]
>- ```name``` là tên mảng
>- ```location``` là vị trí của phần tử trong mảng(theo cách đếm từ ```0``` đến ```size - 1```)
```cpp=
vector<int>a;
for(int i = 0; i < 5; i++)
{
int x;
cin >> x;
a.push_back(x); // lenh them phan tu
}
for(int i = 0; i < 5; i++)
{
cout << a[i] << " "; // truy cap va in ra cac phan tu
}
```
Input
```
1 2 3 4 5
```
Output
```
1 2 3 4 5
```
#### 4. Cách xác định độ dài (số lượng phần tử) của vector
Ta sử có cú pháp là ```name``` ```.``` ```size()``` ```;``` Với ```name``` là tên vector
Ví dụ:
```cpp=
vector<int>a;
for(int i = 0; i < 5; i++)
{
int x;
cin >> x;
a.push_back(x); // lenh them phan tu
}
cout << a.size() << endl;
```
Input
```
1 2 3 4 5
```
Output
```
5
```
## Phần 7: String
>Vì string là chuỗi ký tự nên cách hoạt động của string khá tương tự so với vector char
>- Cách truy cập vào từng ký tự trong chuỗi như truy cập các phần tử trong vector
>- Cách thêm kí tự, chuỗi có thể dùng ```push_back``` của vector hoặc dùng dấu ```+```
>- Độ dài string có thể tìm như vector: dùng hàm ```size()```
>[!Tip]
> Chuyển 1 số thành 1 chuỗi ta dùng ```to_string()```
> Chuyển 1 chuỗi thành 1 số
> - Chuyển thành int: ```stoi()```
> - Chuyển thành long long: ```stoll()```
> - Chuyển về double: ```stod()```
> - Chuyển về long double: ```stold()```
## Phần 8: Chương trình con - Hàm (Function)
### 1. Khái niệm, hiểu và cách dùng
>- Chương trình con là cách tách chương trình thành phần nhỏ để dễ kiểm soát hoặc phải gọi đi gọi lại 1 đoạn code nhiều lần
>- Vì chương trình con cũng có thể là hàm khi nó trả về 1 giá trị nào đó
>[!Caution]
>Trong cấu trúc của chương trình thì ```int main()``` cũng chính là chương trình nhưng đó là chương trình chính $\Rightarrow$ Chương trình con sẽ nằm ngoài ```main```
### 2. Triển khai
#### 1. Khai báo chương trình con chỉ thực hiện không trả về giá trị
```cpp
void name()
{
/*code*/
}
```
>[!Note]
>- ```name``` là tên function
>- ```code``` là đoạn code của function
#### 2. Khai báo chương trình con có trả về giá trị
```cpp
type name()
{
/*code*/
return /*variable, value*/;
}
```
>[!Note]
>- ```type``` kiểu dữ liệu trả về
>- ```name``` tên function
>- ```code``` code của function
>- ```variable```, ```value``` là giá trị trả về hoặc biến
#### 3. Gọi hàm
Tại hàm ```main``` ta chỉ cần gọi hàm bằng tên hàm
Ví dụ
```cpp=
#include<iostream>
using namespace std;
int func1()
{
return 10;
}
int main()
{
int x = func1();
cout << x << endl;
}
```
Output
```
10
```
Ví dụ 2
```cpp=
#include<iostream>
using namespace std;
void func1()
{
cout << "Hello World!" << endl;
}
int main()
{
func1();
}
```
Output
```
Hello, World!
```
#### 4. Truyền dữ liệu vào hàm
>Về cơ bản chương trình con cũng có thể nhận dữ liệu được chương trình chính truyền vào. Để chương trình con có thể nhận thì trong phần ngoặc sau tên của chương trình con ta sẽ khai báo các biến sẽ tiếp nhận dữ liệu được truyền vào
Ví dụ
```cpp
int func(int a, int b, char c) {}
```
>[!Important]
>Tại ```main``` khi ta gọi chương trình đồng thời ta sẽ cho các giá trị cần truyền vào ngoặc đơn khi gọi
Ví dụ
```cpp
void func(int a, int b, char c)
{
cout << a << " " << b << " " << c << endl;
}
int main()
{
func(1, 3, 'n');
}
```
Output
```
1 3 n
```
# END COURSE
>AUTHOR: @longnhat2k9
>GITHUB: github.com/longnhat2k9
Sign in with Wallet
Connect another wallet