Giáo trình Lập trình ứng dụng (Phần 1)

 BỘ CÔNG THƯƠNG 
TRƯỜNG CAO ĐẲNG KỸ THUẬT CAO THẮNG 
BỘ MÔN ĐIỆN TỬ VIỄN THÔNG 
LƯU VĂN ĐẠI 
NGUYỄN THIỆN THÔNG 
GIÁO TRÌNH 
LẬP TRÌNH ỨNG DỤNG 
THÀNH PHỐ HỒ CHÍ MINH – 2018 
 2 
MỤC LỤC 
MỤC LỤC ..................................................................................................................... 2 
CHƯƠNG 1. GIỚI THIỆU .......................................................................................... 5 
1.1 NGÔN NGỮ LẬP TRÌNH (PROGRAMMING LANGUAGE) .................... 5 
1.1.1 Thuật giải (Algorithm) .................................................................................. 5 
1.1.2 Chương trình (Program) ................................................................................ 5 
1.1.3 Ngôn ngữ lập trình (Programming language) ............................................... 5 
1.2 CÁC BƯỚC LẬP TRÌNH.................................................................................. 5 
1.3 KỸ THUẬT LẬP TRÌNH .................................................................................. 6 
1.3.1 I-P-O Cycle (Input-Pprocess-Output Cycle) (Quy trình nhập-xử lý-xuất) ... 6 
1.3.2 Sử dụng lưu đồ (Flowchart) ........................................................................... 6 
1.4 BÀI TẬP .............................................................................................................. 8 
CHƯƠNG 2. NGÔN NGỮ LẬP TRÌNH C ................................................................ 9 
2.1 GIỚI THIỆU ....................................................................................................... 9 
2.2 MỘT SỐ KHÁI NIỆM CƠ BẢN .................................................................... 10 
2.2.1 Bộ ký tự ....................................................................................................... 10 
2.2.2 Từ khóa ........................................................................................................ 10 
2.2.3 Kiểu dữ liệu ................................................................................................. 10 
2.2.4 Tên, Biến, hằng ............................................................................................ 12 
2.2.5. Biểu thức ..................................................................................................... 16 
2.3. CẤU TRÚC MỘT CHƯƠNG TRÌNH ĐƠN GIẢN ..................................... 21 
2.3.1 Cấu trúc chung ............................................................................................. 21 
2.3.2 Khai báo sử dụng thư viện ........................................................................... 23 
2.3.3 Khai báo hằng, biến, kiểu ............................................................................ 23 
2.3.4 Một số lệnh đơn ........................................................................................... 23 
2.3.5 Chú thích...................................................................................................... 24 
2.3.6 Chương trình chính ...................................................................................... 24 
2.4. NHẬP/XUẤT DỮ LIỆU.................................................................................. 24 
2.4.1 Nhập dữ liệu từ bàn phím – Hàm scanf() .................................................... 24 
2.4.2 Xuất dữ liệu ra màn hình - Hàm printf() ..................................................... 26 
2.4.3 Ví dụ ............................................................................................................ 29 
2.5 BÀI TẬP ............................................................................................................ 31 
2.5.1 Bài tập làm theo yêu cầu ............................................................................. 31 
2.5.2 Bài tập tự làm .............................................................................................. 33 
CHƯƠNG 3. CẤU TRÚC ĐIỀU KIỆN .................................................................... 35 
3.1 TUẦN TỰ .......................................................................................................... 35 
3.2 ĐIỀU KHIỂN CHỌN ....................................................................................... 36 
 3 
3.2.1 Lệnh if.......................................................................................................... 36 
3.2.2 Lệnh switch.................................................................................................. 40 
3.3 ĐIỀU KHIỂN LẶP ........................................................................................... 45 
3.3.1. Lệnh for ...................................................................................................... 45 
3.3.2 Lệnh while ................................................................................................... 49 
3.3.3 Lệnh do .. while ........................................................................................... 51 
3.3.4. Một số nhận xét về for, while và do while ................................................. 53 
3.3.5 Lệnh break và continue ............................................................................... 54 
3.4 BÀI TẬP ............................................................................................................ 56 
CHƯƠNG 4. MẢNG VÀ CON TRỎ ........................................................................ 58 
4.1 MẢNG ................................................................................................................ 58 
4.1.1 Mảng trong C ............................................................................................... 58 
4.1.2 Mảng một chiều ........................................................................................... 58 
4.1.3 Mảng nhiều chiều ........................................................................................ 63 
4.2 XÂU KÝ TỰ ...................................................................................................... 67 
4.2.1 Khai báo và nhập xuất dữ liệu ..................................................................... 67 
4.2.2 Các hàm xử lý dữ liệu xâu ........................................................................... 69 
4.2.3 Một số ví dụ ................................................................................................. 75 
4.3 CON TRỎ .......................................................................................................... 79 
4.3.1 Khai báo và sử dụng biến con trỏ ................................................................ 80 
4.3.2 Con trỏ và mảng .......................................................................................... 84 
4.3.3 Con trỏ và tham số hình thức của hàm ........................................................ 89 
4.4 BÀI TẬP LÀM THEO YÊU CẦU .................................................................. 90 
4.4.1 Tìm phần tử lớn nhất của mảng ................................................................... 90 
4.4.2 Tính ma trận tích ......................................................................................... 90 
4.5 BÀI TẬP TỰ LÀM ........................................................................................... 91 
CHƯƠNG 5. HÀM VÀ CON TRỎ HÀM ................................................................ 93 
5.1 HÀM .................................................................................................................. 93 
5.1.1 Khai báo và định nghĩa hàm ........................................................................ 93 
5.1.2 Lời gọi và sử dụng hàm ............................................................................... 96 
5.1.3 Hàm với đối mặc định ................................................................................. 97 
5.1.4 Khai báo hàm trùng tên ............................................................................... 98 
5.1.5 Biến, đối tham chiếu .................................................................................... 99 
5.1.6 Cách truyền tham số .................................................................................. 100 
5.1.7 Hàm và mảng ............................................................................................. 105 
5.2 CON TRỎ HÀM ............................................................................................. 116 
5.2.1 Khai báo ..................................................................................................... 116 
5.2.2 Sử dụng con trỏ hàm .................................................................................. 116 
5.2.3 Mảng con trỏ hàm ...................................................................................... 118 
5.3 BÀI TẬP LÀM THEO YÊU CẦU ................................................................ 119 
5.3.1 Xác định vị trí tương đối của 1 điểm với tam giác ABC ........................... 119 
 4 
5.3.2 Viết hàm đếm số từ của một xâu ký tự ...................................................... 120 
5.4 BÀI TẬP TỰ LÀM ......................................................................................... 120 
CHƯƠNG 6. XÂY DỰNG GIAO DIỆN ỨNG DỤNG BẰNG VISUAL C SHARP
 .................................................................................................................................... 122 
6.1 WINDOW FORM........................................................................................... 122 
6.1.1 Sự quan trọng của Window Form ............................................................. 122 
6.1.2 Những điểm căn bản của Window Form ................................................... 122 
6.1.3 Tạo một form mới ...................................................................................... 122 
6.1.4 Các sự kiện của form ................................................................................. 125 
6.2 CÁC CONTROL CĂN BẢN ......................................................................... 127 
6.2.1 Nút nhấn (Button) ...................................................................................... 127 
6.2.2 Nhãn (Label) ............................................................................................. 133 
6.2.3 Ô nhập (Textbox) ...................................................................................... 137 
6.3 MỘT SỐ VÍ DỤ .............................................................................................. 141 
6.3.1 Làm việc với Listbox ................................................................................. 141 
6.3.2 Làm việc với RadioButton ........................................................................ 143 
6.3.3 Làm việc với Timer ................................................................................... 144 
6.3.4 Viết chương trình thực hiện các phép tính ................................................. 145 
6.4 ĐIỀU KHIỂN LED VỚI ARDUINO VÀ C# ............................................... 150 
6.5 BÀI TẬP .......................................................................................................... 155 
TÀI LIỆU THAM KHẢO ........................................................................................ 157 
PHỤ LỤC .................................................................................................................. 158 
 5 
CHƯƠNG 1. GIỚI THIỆU 
1.1 NGÔN NGỮ LẬP TRÌNH (PROGRAMMING LANGUAGE) 
 Phần này chúng ta sẽ tìm hiểu một số khái niệm căn bản về thuật toán, chương trình, 
ngôn ngữ lập trình. Thuật ngữ "thuật giải" và "thuật toán" dĩ nhiên có sự khác nhau song trong 
nhiều trường hợp chúng có cùng nghĩa. 
1.1.1 Thuật giải (Algorithm) 
Là một dãy các thao tác xác định trên một đối tượng, sao cho sau khi thực hiện một số 
hữu hạn các bước thì đạt được mục tiêu. Theo R.A.Kowalski thì bản chất của thuật giải: 
Thuật giải = Logic + Điều khiển 
* Logic: Đây là phần khá quan trọng, nó trả lời câu hỏi "Thuật giải làm gì, giải quyết vấn 
đề gì?", những yếu tố trong bài toán có quan hệ với nhau như thế nào v.v Ở đây bao gồm 
những kiến thức chuyên môn mà bạn phải biết để có thể tiến hành giải bài toán. 
 Ví dụ 1: Để giải một bài toán tính diện tích hình cầu, mà bạn không còn nhớ công thức 
tính hình cầu thì bạn không thể viết chương trình cho máy để giải bài toán này được. 
* Điều khiển: Thành phần này trả lời câu hỏi: giải thuật phải làm như thế nào?. Chính là 
cách thức tiến hành áp dụng thành phần logic để giải quyết vấn đề. 
1.1.2 Chương trình (Program) 
Là một tập hợp các mô tả, các phát biểu, nằm trong một hệ thống qui ước về ý nghĩa và 
thứ tự thực hiện, nhằm điều khiển máy tính làm việc. Theo Niklaus Wirth thì: 
Chương trình = Thuật toán + Cấu trúc dữ liệu 
Các thuật toán và chương trình đều có cấu trúc dựa trên 3 cấu trúc điều khiển cơ bản: 
* Tuần tự (Sequential): Các bước thực hiện tuần tự một cách chính xác từ trên xuống, 
mỗi bước chỉ thực hiện đúng một lần. 
* Chọn lọc (Selection): Chọn 1 trong 2 hay nhiều thao tác để thực hiện. 
* Lặp lại (Repetition): Một hay nhiều bước được thực hiện lặp lại một số lần. 
Muốn trở thành lập trình viên chuyên nghiệp bạn hãy làm đúng trình tự để có thói 
quen tốt và thuận lợi sau này trên nhiều mặt của một người làm máy tính. Bạn hãy làm theo 
các bước sau: 
Tìm, xây dựng thuật giải (trên giấy) → viết chương trình trên máy 
→ dịch chương trình → chạy và thử chương trình 
1.1.3 Ngôn ngữ lập trình (Programming language) 
Ngôn ngữ lập trình là hệ thống các ký hiệu tuân theo các qui ước về ngữ pháp và ngữ 
nghĩa, dùng để xây dựng thành các chương trình cho máy tính. 
Một chương trình được viết bằng một ngôn ngữ lập trình cụ thể (ví dụ Pascal, C) gọi 
là chương trình nguồn, chương trình dịch làm nhiệm vụ dịch chương trình nguồn thành chương 
trình thực thi được trên máy tính. 
1.2 CÁC BƯỚC LẬP TRÌNH 
Bước 1: Phân tích vấn đề và xác định các đặc điểm. (xác định I-P-O) 
Bước 2: Lập ra giải pháp. (đưa ra thuật giải) 
 6 
Bước 3: Cài đặt. (viết chương trình) 
Bước 4: Chạy thử chương trình. (dịch chương trình) 
Bước 5: Kiểm chứng và hoàn thiện chương trình. (thử nghiệm bằng nhiều số liệu và đánh 
giá) 
1.3 KỸ THUẬT LẬP TRÌNH 
1.3.1 I-P-O Cycle (Input-Pprocess-Output Cycle) (Quy trình nhập-xử lý-xuất) 
Quy trình xử lý cơ bản của máy tính gồm I-P-O. 
Ví dụ 2: Xác định Input, Process, Output của việc làm 1 ly nước chanh nóng 
 Input : ly, đường, chanh, nước nóng, muỗng. 
 Process : - cho hỗn hợp đường, chanh, nước nóng vào ly. 
 - dùng muỗng khuấy đều. 
 Output : ly chanh nóng đã sẵn sàng để dùng. 
Ví dụ 3: Xác định Input, Process, Output của chương trình tính tiền lương công nhân 
tháng 10/2002 biết rằng lương = lương căn bản * ngày công 
 Input : lương căn bản, ngày công 
 Process : nhân lương căn bản với ngày công 
 Output : lương 
Ví dụ 4: Xác định Input, Process, Output của chương trình giải phương trình bậc nhất ax 
+ b = 0 
 Input : hệ số a, b 
 Process : chia – b cho a 
 Output : nghiệm x 
Ví dụ 5: Xác định Input, Pro ...  2: Khai báo biến f kiểu float và biến pf là con trỏ float 
float f, *pf; 
Lưu ý: Nếu chưa muốn khai báo kiểu dữ liệu mà con trỏ ptr đang chỉ đến, ta sử dụng: 
void *ptr; 
sau đó, nếu ta muốn con trỏ ptr chỉ đến kiểu dữ liệu gì cũng được. Tác dụng của khai báo này là 
chỉ dành ra 2 bytes trong bộ nhớ để cấp phát cho biến con trỏ ptr. 
Các thao tác trên con trỏ 
Gán địa chỉ của biến cho biến con trỏ 
Toán tử & dùng để định vị con trỏ đến địa chỉ của một biến đang làm việc. 
Cú pháp: 
=&; 
Giải thích: Ta gán địa chỉ của biến Tên biến cho con trỏ Tên biến con trỏ. 
Ví dụ: Gán địa chỉ của biến a cho con trỏ pa, gán địa chỉ của biến b cho con trỏ pb. 
 81 
pa=&a; pb=&b; 
Lưu ý: Khi gán địa chỉ của biến tĩnh cho con trỏ cần phải lưu ý kiểu dữ liệu của chúng. Ví dụ sau 
đây không đúng do không tương thích kiểu: 
int Bien_Nguyen; 
float *Con_Tro_Thuc; 
... 
Con_Tro_Thuc=&Bien_Nguyen; 
Phép gán ở đây là sai vì Con_Tro_Thuc là một con trỏ kiểu float (nó chỉ có thể chứa được địa chỉ 
của biến kiểu float); trong khi đó, Bien_Nguyen có kiểu int. 
Nội dung của ô nhớ con trỏ chỉ tới 
Để truy cập đến nội dung của ô nhớ mà con trỏ chỉ tới, ta sử dụng cú pháp: 
* 
Ví dụ 3: Ví dụ sau đây cho phép khai báo, gán địa chỉ cũng như lấy nội dung vùng nhớ của biến 
con trỏ: 
int x=100; 
int *ptr; 
ptr=&x; 
int y= *ptr; 
Lưu ý: Khi gán địa chỉ của một biến cho một biến con trỏ, mọi sự thay đổi trên nội dung ô nhớ 
con trỏ chỉ tới sẽ làm giá trị của biến thay đổi theo (thực chất nội dung ô nhớ và biến chỉ là một). 
Ví dụ 4: Đoạn chương trình sau thấy rõ sự thay đổi này : 
#include 
#include 
int main() 
{ 
 int a,b,*pa,*pb; 
 a=2; 
 b=3; 
 printf("\nGia tri cua bien a=%d \nGia tri cua bien b=%d ",a,b); 
 pa=&a; 
 pb=&b; 
 printf("\nNoi dung cua o nho con tro pa tro toi=%d",*pa); 
 printf("\nNoi dung cua o nho con tro pb tro toi=%d ",*pb); 
 *pa=20; /* Thay doi gia tri cua *pa*/ 
 82 
 *pb=20; /* Thay doi gia tri cua *pb*/ 
 printf("\nGia tri moi cua bien a=%d \n Gia tri moi cua bien b=%d ",a,b); 
 getch(); 
 return 0; 
} 
Cấp phát vùng nhớ cho biến con trỏ 
Trước khi sử dụng biến con trỏ, ta nên cấp phát vùng nhớ cho biến con trỏ này quản lý địa chỉ. 
Việc cấp phát được thực hiện nhờ các hàm malloc(), calloc() trong thư viện alloc.h. 
Cú pháp: 
void *malloc(size_t size): 
Cấp phát vùng nhớ có kích thước là size. 
void *calloc(size_t nitems, size_t size): 
Cấp phát vùng nhớ có kích thước là nitems*size. 
Ví dụ: Giả sử ta có khai báo: 
int a, *pa, *pb; 
pa = (int*)malloc(sizeof(int)); 
/* Cấp phát vùng nhớ có kích thước bằng với kích thước của một số nguyên */ 
pb= (int*)calloc(10, sizeof(int)); 
/* Cấp phát vùng nhớ có thể chứa được 10 số nguyên*/ 
Lúc này hình ảnh trong bộ nhớ như sau: 
0 0 1 2 3 4 5 6 7 8 9 
pa (2 byte) pb (2 byte) 
Lưu ý: Khi sử dụng hàm malloc() hay calloc(), ta phải ép kiểu vì nguyên mẫu các hàm này trả về 
con trỏ kiểu void. 
Cấp phát lại vùng nhớ cho biến con trỏ 
Trong quá trình thao tác trên biến con trỏ, nếu ta cần cấp phát thêm vùng nhớ có kích thước lớn 
hơn vùng nhớ đã cấp phát, ta sử dụng hàm realloc(). 
Cú pháp: 
void *realloc(void *block, size_t size) 
Ý nghĩa: 
- Cấp phát lại 1 vùng nhớ cho con trỏ block quản lý, vùng nhớ này có kích thước mới là size; 
khi cấp phát lại thì nội dung vùng nhớ trước đó vẫn tồn tại; 
 83 
- Kết quả trả về của hàm là địa chỉ đầu tiên của vùng nhớ mới. Địa chỉ này có thể khác với 
địa chỉ được chỉ ra khi cấp phát ban đầu. 
Ví dụ: Trong ví dụ trên ta có thể cấp phát lại vùng nhớ do con trỏ pa quản lý như sau: 
int a, *pa; 
pa= (int*)malloc(sizeof(int)); /*Cấp phát vùng nhớ có kích thước 2 byte*/ 
pa = realloc(pa, 6); /* Cấp phát lại vùng nhớ có kích thước 6 byte*/ 
Giải phóng vùng nhớ cho biến con trỏ : Một vùng nhớ đã cấp phát cho biến con trỏ, khi không 
còn sử dụng nữa, ta sẽ thu hồi lại vùng nhớ này nhờ hàm free(). 
Cú pháp: 
void free(void *block) 
Ý nghĩa: Giải phóng vùng nhớ được quản lý bởi con trỏ block. 
Ví dụ: Ở ví dụ trên, sau khi thực hiện xong, ta giải phóng vùng nhớ cho 2 biến con trỏ pa & pb: 
free(pa); 
free(pb); 
Một số phép toán trên con trỏ 
a. Phép gán con trỏ: Hai con trỏ cùng kiểu có thể gán cho nhau. 
Ví dụ 
int a, *p, *q ; float *f; 
a = 5 ; p = &a ; q = p ; /* đúng */ 
f = p ; /* sai do khác kiểu */ 
Ta cũng có thể ép kiểu con trỏ theo cú pháp: 
(*) 
Chẳng hạn, ví dụ trên được viết lại: 
int a, *p, *q ; float *f; 
a = 5 ; p = &a ; q = p ; /* đúng */ 
f = (float*)p; /* Đúng nhờ ép kiểu*/ 
b. Cộng, trừ con trỏ với một số nguyên 
Ta có thể cộng (+), trừ (-) 1 con trỏ với 1 số nguyên N nào đó; kết quả trả về là 1 con trỏ. Con trỏ 
này chỉ đến vùng nhớ cách vùng nhớ của con trỏ hiện tại N phần tử. 
Ví dụ: Cho đoạn chương trình sau: 
int *pa; 
pa = (int*) malloc(20); /* Cấp phát vùng nhớ 20 byte=10 số nguyên*/ 
int *pb, *pc; 
 84 
pb = pa + 7; 
pc = pb - 3; 
Lúc này hình ảnh của pa, pb, pc như sau: 
0 1 2 3 4 5 6 7 8 9 
pa pc pb 
c. Con trỏ NULL: là con trỏ không chứa địa chỉ nào cả. Ta có thể gán giá trị NULL cho 1 con trỏ 
có kiểu bất kỳ. 
d. Lưu ý: 
- Ta không thể cộng 2 con trỏ với nhau; 
- Phép trừ 2 con trỏ cùng kiểu sẽ trả về 1 giá trị nguyên (int). Đây chính là khoảng cách (số 
phần tử) giữa 2 con trỏ đó. Chẳng hạn, trong ví dụ trên pc-pa=4. 
4.3.2 Con trỏ và mảng 
Con trỏ và mảng 1 chiều 
Giữa mảng và con trỏ có một sự liên hệ rất chặt chẽ. Những phần tử của mảng có thể được xác 
định bằng chỉ số trong mảng, bên cạnh đó chúng cũng có thể được xác lập qua biến con trỏ. 
Truy cập các phần tử mảng theo dạng con trỏ 
Ta có các quy tắc sau: 
- &[0] tương đương với 
- & [] tương đương với + 
- [] tương đương với *( + ) 
Ví dụ 4.18: Cho 1 mảng 1 chiều các số nguyên a có 5 phần tử, truy cập các phần tử theo kiểu 
mảng và theo kiểu con trỏ. 
#include 
#include 
/* Nhap mang binh thuong */ 
void NhapMang(int a[], int N) 
{ 
 int i; 
 for(i=0;i<N;i++) 
 { 
 printf("Phan tu thu %d: ",i);scanf("%d",&a[i]); 
 } 
} 
 85 
/* Nhap mang theo dang con tro */ 
void NhapContro(int a[], int N) 
{ 
 int i; 
 for(i=0;i<N;i++) 
 { 
 printf("Phan tu thu %d: ",i);scanf("%d",a+i); 
 } 
} 
int main() 
{ 
 int a[20],N,i; 
 printf("So phan tu N= ");scanf("%d",&N); 
 NhapMang(a,N); 
 // NhapContro(a,N); 
 printf("Truy cap theo kieu mang: "); 
 for(i=0;i<N;i++) 
 printf("%d ",a[i]); 
 printf("\nTruy cap theo kieu con tro: "); 
 for(i=0;i<N;i++) 
 printf("%d ",*(a+i)); 
 getch(); 
 return 0; 
} 
Truy xuất từng phần tử đang được quản lý bởi con trỏ theo dạng mảng 
- [] tương đương với *( + ) 
- &[] tương đương với ( + ) 
Trong đó là biến con trỏ, là 1 biểu thức số nguyên. 
Ví dụ 4.19: Giả sử có khai báo: 
#include 
#include 
#include 
#include /* Them vao so voi phien ban tren DOS*/ 
 86 
int main() 
{ 
 int *a; 
 int i; 
 a=(int*)malloc(sizeof(int)*10); 
 for(i=0;i<10;i++) 
 a[i] = 2*i; 
 printf("Truy cap theo kieu mang: "); 
 for(i=0;i<10;i++) 
 printf("%d ",a[i]); 
 printf("\nTruy cap theo kieu con tro: "); 
 for(i=0;i<10;i++) 
 printf("%d ",*(a+i)); 
 getch(); 
 return 0; 
} 
Con trỏ chỉ đến phần tử mảng 
Giả sử con trỏ ptr chỉ đến phần tử a[i] nào đó của mảng a thì: 
ptr + j chỉ đến phần tử thứ j sau a[i], tức a[i+j] 
ptr - j chỉ đến phần tử đứng trước a[i], tức a[i-j] 
Ví dụ 4.20: Giả sử có 1 mảng mang_int, cho con trỏ contro_int chỉ đến phần tử thứ 5 trong mảng. 
In ra các phần tử của contro_int & mang_int. 
#include 
#include 
#include 
#include /* Them vao so voi phien ban tren DOS*/ 
int main() 
{ 
 int i,mang_int[10]; 
 int *contro_int; 
 for(i=0;i<=9;i++) 
 mang_int[i]=i*2; 
 contro_int=&mang_int[5]; 
 87 
 printf("\nNoi dung cua mang_int ban dau="); 
 for (i=0;i<=9;i++) 
 printf("%d ",mang_int[i]); 
 printf("\nNoi dung cua contro_int ban dau ="); 
 for (i=0;i<5;i++) 
 printf("%d ",contro_int[i]); 
 for(i=0;i<5;i++) 
 contro_int[i]++; 
 printf("\n--------------------"); 
 printf("\nNoi dung cua mang_int sau khi tang 1="); 
 for (i=0;i<=9;i++) 
 printf("%d ",mang_int[i]); 
 printf("\nNoi dung cua contro_int sau khi tang 1="); 
 for (i=0;i<5;i++) 
 printf("%d ",contro_int[i]); 
 if (contro_int!=NULL) 
 free(contro_int); 
 getch(); 
 return 0; 
} 
Con trỏ và mảng nhiều chiều 
Ta có thể sử dụng con trỏ thay cho mảng nhiều chiều như sau: Giả sử ta có mảng 2 chiều và biến 
con trỏ như sau: 
int a[n][m]; 
int *contro_int; 
Thực hiện phép gán 
contro_int=a; 
khi đó phần tử a[0][0] được quản lý bởi contro_int; 
a[0][1] được quản lý bởi contro_int+1; 
a[0][2] được quản lý bởi contro_int+2; 
... 
a[1][0] được quản lý bởi contro_int+m; 
a[1][1] được quản lý bởi contro_int+m+1; 
 88 
... 
a[n-1][m-1] được quản lý bởi contro_int+(n-1)*m + (m-1); 
Tương tự như thế đối với mảng nhiều hơn 2 chiều. 
Ví dụ 4.21: Sự tương đương giữa mảng 2 chiều và con trỏ. 
#include 
#include 
#include 
#include 
int main() 
{ 
 int i,j; 
 int mang_int[4][5]={1,2,3,4,5,6,7,8,9,10,11,12,13,14, 
 15,16,17,18,19,20}; 
 int *contro_int; 
 contro_int=(int*)mang_int; 
 printf("\nNoi dung cua mang_int ban dau="); 
 for (i=0;i<4;i++) 
 { 
 printf("\n"); 
 for (j=0;j<5;j++) 
 printf("%d\t",mang_int[i][j]); 
 } 
 printf("\n-----------------------------"); 
 printf("\nNoi dung cua contro_int ban dau \n"); 
 for (i=0;i<20;i++) 
 printf("%d ",contro_int[i]); 
 for(i=0;i<20;i++) 
 contro_int[i]++ ; 
 printf("\n-----------------------------"); 
 printf("\nNoi dung cua mang_int sau khi tang 1="); 
 for (i=0;i<4;i++) 
 { 
 printf("\n"); 
 89 
 for (j=0;j<5;j++) 
 printf("%d\t",mang_int[i][j]); 
 } 
 printf("\nNoi dung cua contro_int sau khi tang 1=\n"); 
 for (i=0;i<20;i++) 
 printf("%d ",contro_int[i]); 
 if (contro_int!=NULL) 
 free(contro_int); 
 getch(); 
 return 0; 
} 
4.3.3 Con trỏ và tham số hình thức của hàm 
Khi tham số hình thức của hàm là một con trỏ thì theo nguyên tắc gọi hàm ta dùng tham số thực 
tế là 1 con trỏ có kiểu giống với kiểu của tham số hình thức. Nếu lúc thực thi hàm ta có sự thay 
đổi trên nội dung vùng nhớ được chỉ bởi con trỏ tham số hình thức thì lúc đó nội dung vùng nhớ 
được chỉ bởi tham số thực tế cũng sẽ bị thay đổi theo. 
Ví dụ 4.22: Xét hàm hoán vị được viết như sau : 
#include 
#include 
void HoanVi(int *a, int *b) 
{ 
 int c=*a; 
 *a=*b; 
 *b=c; 
} 
int main() 
{ 
 int m=20,n=30; 
 printf("Truoc khi goi ham m= %d, n= %d\n",m,n); 
 HoanVi(&m,&n); 
 printf("Sau khi goi ham m= %d, n= %d",m,n); 
 getch(); 
 return 0; 
 90 
} 
4.4 BÀI TẬP LÀM THEO YÊU CẦU 
4.4.1 Tìm phần tử lớn nhất của mảng 
Yêu cầu: Viết chương trình cho phép nhập vào một mảng, tìm phần tử lớn nhất và in ra màn hình 
Thử nghiệm 1: 
1. Nhận F9 để chạy chương trình, khi đó giao diện xuất hiện như sau: 
2. Nhập các giá trị cho N (số phần tử của mảng) và các giá trị tương ứng cho mỗi phần tử 
của mảng như sau: 4  8  5  9  1 , khi đó kết quả nhận được như sau: 
3. Nhận xét về kết quả đạt được. 
Thử nghiệm 2: Đổi việc tìm phần tử lớn nhất thành phần tử nhỏ nhất. 
Thử nghiệm 3: Thêm vào yêu cầu là tìm phần tử lớn nhất và vị trí của phần tử đó trong mảng. 
4.4.2 Tính ma trận tích 
Vấn đề: Viết chương trình cho phép nhập vào mảng dữ liệu liệu hai chiều, tính tích hai ma trận 
và đưa ma trận kết quả ra màn hình. 
Thử nghiệm 1: 
Nhấn F9, nhập hai ma trận sau: 
 91 
a b 
1 2 3 
3 2 1 
- Hãy nhận xét về kết quả nhận được 
Thử nghiệm 2: 
Thay dòng 49 thành 
 //printf("\n"); 
Nhập lại giá trị ở trên, ghi nhận sự thay đổi kết quả in ra màn hình 
Thử nghiệm 3: 
Để nguyên dòng printf("\n"); 
Thay dòng 47 thành 
printf("%d",c[i][j]); 
Nhập lại giá trị ở trên, ghi nhận sự thay đổi kết quả in ra màn hình 
Thử nghiệm 4: 
- Giữ nguyên các dòng như văn bản ban đầu 
- Thay đổi dòng 34 thành 
//c[i][j]=0; 
Thực hiện chương trình, nhập dữ liệu mảng ở trên, nhận xét kết quả in ra màn hình 
Thử nghiệm 5: 
- Giữ nguyên các dòng như văn bản ban đầu 
- Thay đổi dòng 4 thành 
#define M 2 
Thực hiện chương trình, và nhận xét về số lượng phần tử nhập vào, và kết quả in ra màn hình 
4.5 BÀI TẬP TỰ LÀM 
1. Viết chương trình nhập vào một dãy n số thực a[0], a[1],..., a[n-1], sắp xếp dãy số theo thứ tự 
giảm dần. In dãy số sau khi sắp xếp. 
2. Viết chương trình sắp xếp một mảng theo thứ tự tăng dần sau khi đã loại bỏ các phần tử trùng 
nhau. 
3. Viết chương trình nhập vào một mảng, hãy xuất ra màn hình: 
- Phần tử lớn nhất của mảng. 
- Phần tử nhỏ nhất của mảng. 
- Tính tổng của các phần tử trong mảng . 
3 3 
2 0 
1 -1 
 92 
4. Viết chương trình nhập vào một dãy các số theo thứ tự tăng, nếu nhập sai quy cách thì yêu cầu 
nhập lại. In dãy số sau khi đã nhập xong. Nhập thêm một số mới và chèn số đó vào dãy đã có 
sao cho dãy vẫn đảm bảo thứ tự tăng. In lại dãy số để kiểm tra. 
5. Viết chương trình nhập vào một ma trận (mảng hai chiều) các số nguyên, gồm m hàng, n cột. 
In ma trận đó lên màn hình. Nhập một số nguyên khác vào và xét xem có phần tử nào của ma 
trận trùng với số này không ? Ở vị trí nào ? Có bao nhiêu phần tử ? 
6. Viết chương trình để chuyển đổi vị trí từ dòng thành cột của một ma trận (ma trận chuyển vị) 
vuông 4 hàng 4 cột. Sau đó viết cho ma trận tổng quát cấp m*n. 
7. Viết chương trình nhập vào một mảng số tự nhiên. Hãy xuất ra màn hình: 
- Dòng 1 : gồm các số lẻ, tổng cộng có bao nhiêu số lẻ. 
- Dòng 2 : gồm các số chẵn, tổng cộng có bao nhiêu số chẵn. 
- Dòng 3 : gồm các số nguyên tố. 
- Dòng 4 : gồm các số không phải là số nguyên tố. 
8. Viết chương trình tính tổng bình phương của các số âm trong một mảng các số nguyên. 
9. Viết chương trình thực hiện việc đảo một mảng một chiều. 
Ví dụ : 1 2 3 4 5 7 9 10 đảo thành 10 9 7 5 4 3 2 1 . 
(Không dùng mảng phụ) 
10. Viết chương trình nhập vào hai ma trận A và B có cấp m, n. In hai ma trận lên màn hình. Tổng 
hai ma trận A và B là ma trận C được tính bởi công thức: 
c
ij
= a
ij 
+b
ij 
( i=0,1,2,...m-1; j=0,1,2...n-1) 
Tính ma trận tổng C và in kết quả lên màn hình. 
11. Viết chương trình nhập vào hai ma trận A có cấp m, k và B có cấp k, n. In hai ma trận lên màn 
hình. Tích hai ma trận A và B là ma trận C được tính bởi công thức: 
c
ij
= a
i1
*b
1j 
+ a
i2 
*b
2j 
+ a
i3 
*b
3j 
+ ... + a
ik 
*b
kj 
(i=0,1,2,...m-1;j=0,1,2...n-1) 
Tính ma trận tích C và in kết quả lên màn hình. 
12. Xét ma trận A vuông cấp n, các phần tử a[i, i] ( i= 1 ... n ) được gọi là đường chéo chính của 
ma trận vuông A. Ma trận vuông A được gọi là ma trận tam giác nếu tất cả các phần tử dưới 
đường chéo chính đều bằng 0. Định thức của ma trận tam giác bằng tích các phần tử trên đường 
chéo chính. Hãy biến đổi ma trân A về ma trận tam giác. In kết quả từng bước lên màn hình. 
13. Viết chương trình thực hiện việc trộn hai dãy có thứ tự thành một dãy có thứ tự. Yêu cầu không 
được trộn chung rồi mới sắp thứ tự. Khi trộn phải tận dụng được tính chất đã sắp của hai dãy 
con. 
14. Thực hiện các bài tập ở phần Mảng , bằng cách sử dụng con trỏ.