I.

Ôn tập:
Bài 1:
a. Tạo 1 biến pointer p trỏ về kiểu int:

int* p;

b. Tạo 1 biến tĩnh a=10 và trỏ p vào biến này:

int a = 10;
p = &a;

c. Thay đổi giá trị của a bằng cách sử dụng con trỏ p (a=20):

*p = 20;

d. Tạo 1 biến tĩnh b=30 và trỏ p vào biến này:

int b = 30;
p = &b;

Chương trình hoàn thiện:

Kết quả khi chạy chương trình:

Bài 2:
a.Khi in ra giá trị của con trỏ p, kết quả in ra sẽ là địa chỉ mà nó đang trỏ đến bằng câu lệnh:
cout<<p;
kết quả sẽ là:
vì biến p là một con trỏ trỏ đến biến a. Tại dòng lệnh:
int *p = &a;
biến p được khởi tạo để trỏ đến địa chỉ của biến a.
b. long(p+1) - long(p) sẽ trả về kích thước của kiểu int, vì p được khai báo trỏ đến kiểu int và khi cộng 1 với p thì
nó sẽ trỏ đến ô nhớ tiếp theo kế tiếp của kiểu int đó.
c. *(p+1) sẽ truy xuất đến giá trị của biến b, vì p đang trỏ đến biến b và p+1 trỏ đến phần tử tiếp theo của mảng
chứa biến b. Kết quả sẽ là giá trị của biến b, tức là 30.
d. CCó lỗi là do con trỏ p1 được khai báo là void, vì thế nó không biết đến kích thước của kiểu dữ liệu mà nó
trỏ đến. Khi cộng 1 vào p1 thì nó không biết cần dùng bao nhiêu byte để nhảy tới ô nhớ tiếp theo.

Bài 3:
a.
Kết quả của 2 lần in sẽ giống nhau vì khi gọi hàm swap(), tham số truyền vào là giá trị của a và b. Khi thực
hiện việc hoán đổi giá trị thì hai biến a và b trong hàm main() vẫn không thay đổi, nên giá trị của biến a và b
sẽ vẫn là 10 và 20. Sau khi thực hiện xong hàm swap(), chương trình trở lại hàm main() và kết quả khi in ra
giá trị của biến a và b sẽ không thay đổi.
b.

Để in 2 lần 2 kết quả khác nhau, chúng ta cần sửa hàm swap. Hiện tại, hàm swap đang hoạt động trên các
giá trị a và b được truyền vào bằng giá trị, được gọi là "truyền tham trị".

Để hoạt động đúng, chúng ta cần truyền các con trỏ tới biến a và b vào hàm swap, để thao tác swap được
thực hiện trên chính các biến a và b này. Đây được gọi là "truyền tham chiếu".

Sau khi sửa đổi hàm swap như sau:

void swap(int* a, int* b){

int temp;
temp = *a;
*a = *b;
*b = temp;
}

Chúng ta cần cập nhật cả hàm main để truyền con trỏ tới biến a và b vào hàm swap.

Sau khi chỉnh sửa:

#include <stdio.h>

void swap(int* a, int* b){

int temp;
temp = *a;
*a = *b;
*b = temp;
}

int main() {
int a = 10, b = 20;
 printf("a,b: %d,%d\n", a, b);
swap(&a, &b);
printf("a,b: %d,%d\n", a, b);
return 0;
}

Khi thực thi, chương trình sẽ in ra 2 lần kết quả khác nhau:

a,b: 10,20
a,b: 20,10

II.

Bài 1:
a) int *p = a;

b)
- Để truy xuất đến phần tử thứ 0 của mảng a thông qua con trỏ p, ta sử dụng cú pháp: *p
- Kết quả trả về sẽ là giá trị của phần tử đầu tiên của mảng a, tức là 1.
Vậy, để truy xuất đến phần tử thứ 0 của mảng a thông qua con trỏ p, ta sử dụng lệnh: *p

c)
cout<<*a<<endl; // in ra giá trị của phần tử thứ 0
cout<<*(a+2)<<endl; // in ra giá trị của phần tử thứ 2

Giải thích: Vì mảng a và biến pointer p đều trỏ tới địa chỉ của phần tử đầu tiên trong mảng a, nên chúng có
thể được sử dụng để truy xuất đến các phần tử trong mảng. Sử dụng *p có nghĩa là lấy giá trị tại địa chỉ mà
pointer p trỏ tới. Tương tự, sử dụng *a có nghĩa là lấy giá trị tại địa chỉ đầu tiên trong mảng a.

Bài 2:
Tạo biến con trỏ `sv1` trỏ về kiểu `SV`:

SV* sv1 = new SV;

Gán giá trị của `id` vào trường `id` của `sv1` bằng hàm `strcpy`:

strcpy(sv1->id, id);

Chương trình:
#include <iostream>
#include <cstring>

using namespace std;

struct SV {
 char id[15];
};

int main() {
char id[15] = "sinhvienSIU";

// Tạo biến con trỏ sv1 trỏ về kiểu struct SV

SV* sv1 = new SV;

// Gán giá trị của id vào trường id của sv1

strcpy(sv1->id, id);

// In ra giá trị của trường id của sv1

cout << "id cua sv1 la: " << sv1->id << endl;
return 0;
}

Bài 3:
a) SV2 *sv2 = new SV2;
b) string id2 = "sinhvienSIU";
sv2 -> id= id2;

Bài 4:

struct Node {
int val;
Node* next = nullptr; // con trỏ chỉ đến node tiếp theo

// Hàm không có tham số

Node() {}

// Hàm có 1 tham số
Node(int x) {
val = x;
}

// Hàm có 2 tham số
Node(int x, Node* nxt) {
val = x;
next = nxt;
}
};