Bài giảng Cơ sở lập trình - Trần Tấn Từ

ách rời nhau. Trong trường hợp này, bắt buộc phải khai báo tên struct. - Ví dụ 8.5: Khai báo cấu trúc để quản lý họ tên và điểm trung bình của học sinh như sau: struct hocsinh { char hodem[25]; char ten[10]; float dtb; } hs1, hs2; Hoặc khai báo struct với tên họcsinh, sau đó khai báo 2 biến hs1, hs2 theo cú pháp: struct hocsinh hs1, hs2; - Ví dụ 8.6: Khai báo structure lồng nhau: struct nhansu { char hoten[30]; struct date ngaysinh; unsigned gioitinh; struct diachi; float luong; } nguoiA, nguoiB; struct date { int namsinh; int thang; int ngay; } .. Bài giảng Cơ sở lập trình -122- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. 8.3.2 Truy cập vào phần tử kiểu struct Để truy cập vào từng phần tử của struct ta viết theo cú pháp: .; Với khai báo trong ví dụ 8.5, bạn có thể truy cập và gán dữ liệu vào từng trường của struct qua các biến hs1, hs2 như sau : hs1.hodem = “Nguyễn Thị” hs1.ten = “Lan” hs1.dtb = 5.5; Hoặc nhập liệu thông qua các lệnh: printf(“Hãy cho họ đệm học sinh 1 “); gets(hs1.hodem); Sau đó, bạn có thể can thiệp vào từng phần tử của họ đệm vì họ đệm là một mảng với n là số nguyên nói lên độ dài chuỗi ký tự cần in: for (i=0; i < n; i++) putchar(hs1.hodem[i]); 8.3.3 Khai báo mảng struct Có thể phối hợp khai báo cấu trúc với mảng để dễ dàng quản lý các dữ liệu do yêu cầu thực tiễn đặt ra. Với khai báo struct hocsinh như trên ta có thể khai báo tiếp : struct hocsinh hs[100]; - Ví dụ 8.7: Viết chương trình tạo ra bảng chọn có 4 chức năng: 1. Nhập 2. Xem 3. Sắp xếp 4. Thoát Trong đó: + Chức năng nhập cho phép nhập thông tin các học sinh, với mỗi học sinh cần quản lý: họ đệm, tên, tuổi. + Chức năng xem cho phép xem các thông tin của tất cả các học sinh. + Chức năng sắp xếp cho phép sắp xếp danh sách học sinh theo tên. + Chức năng thoát cho phép trở về chương trình chính. Giải: #include #include #include Bài giảng Cơ sở lập trình -123- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. #define MAX 20 struct hocsinh { char hodem[20]; char ten[10]; int tuoi; } hs[MAX],tam; int n,i,chon; int menu(void); void nhap(void); void xem(void); void sapxep(void); main() { for (;;) { clrscr(); chon = menu(); switch (chon) { case 1 : nhap(); break; case 2 : xem(); break; case 3 : sapxep(); break; case 4 : exit(0); } } } int menu(void) { int c; char s[10]; clrscr(); printf("1. Nhap danh sach \n"); printf("2. Xem danh sach \n"); printf("3. Sap xep danh sach\n"); Bài giảng Cơ sở lập trình -124- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. printf("4. Thoat \n"); do { printf("Bam so de chon (1/2/3/4)"); gets(s); c = atoi(s); } while (c 4); return c; } void nhap(void) { char c; clrscr(); printf("Nhap so hoc sinh :"); scanf("%d",&n); while (getchar() !='\n'); i = 1; while (i<=n) { clrscr(); printf("\n Nguoi thu %d",i); printf("\n Ho dem :");gets(hs[i].hodem); printf("\n Ten :");gets(hs[i].ten); printf("\n Tuoi :");scanf("%d",&hs[i].tuoi); while (getchar() !='\n'); i = i + 1; } } void xem(void) { char c; clrscr(); i = 1; printf("STT Ho va ten Tuoi\n"); while (i<=n) { printf("%3d ",i); printf("%-20s",hs[i].hodem); printf("%-10s",hs[i].ten); Bài giảng Cơ sở lập trình -125- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. printf("%5d",hs[i].tuoi); printf("\n"); i++; } getch(); } void sapxep(void) { int j; clrscr(); for (i=0;i<=n-1;i++) for (j = i+1;j<=n;j++) if (strcmp(hs[i].ten, hs[j].ten)>0) { tam = hs[i]; hs[i] = hs[j]; hs[j] = tam; } printf("Da sap xong"); getch(); } 8.3.4 Truyền tham số struct cho hàm - Truyền tham số là từng phần tử của struct: Khi truyền tham số kiểu struct cho hàm, ta có thể chuyển từng phần tử của struct cho hàm. - Ví dụ 8.8: Giả sử đã có struct với khai báo như sau: struct vidu { char x; int y; char st[10]; } bien; Từng phần tử của struct có thể được truyền cho hàm như sau: HamVidu1(bien.x); HamVidu1(bien.y); HamVidu1(bien.z); HamVidu1(bien.st); /* Chuyển địa chỉ chuỗi ký tự st */ Bài giảng Cơ sở lập trình -126- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. HamVidu1(bien.st[2]); /* Chuyển giá trị ký tự */ Bạn cũng có thể truyền địa chỉ của các thành phần này cho hàm như sau: HamVidu1(&bien.x); HamVidu1(&bien.y); HamVidu1(bien.st); /* Chuyển địa chỉ chuỗi ký tự st */ HamVidu1(&bien.st[2]); /* Chuyển địa chỉ của ký tự */ - Truyền tham số là một struct: Việc truyền cả struct cho hàm tuân theo nguyên tắc truyền theo tham số giá trị; Nghĩa là mọi thay đổi của struct bên trong hàm sẽ không được lưu giữ khi ra khỏi hàm. Cần lưu ý sự tương hợp giữa tham số hình thức và tham số thực sự. - Ví dụ 8.9: Xem đoạn chương trình sau: Giải: #include struct Vidu { int a; char kt; }; void HamVD(struct Vidu VD); main() { struct Vidu doiso; clrscr(); doiso.a = 500; printf(“\n Truoc khi goi ham doiso.a = %d”,doiso.a); HamVD(doiso); printf(“\n Sau khi goi ham doiso.a = %d”,doiso.a); getch(); } void HamVD(struct Vidu VD) { VD.a++; printf("\n Trong ham doiso.a = %d",VD.a); } Kết quả khi thực hiện chương trình Truoc khi goi ham doiso.a = 500 Trong ham doiso.a = 501 Bài giảng Cơ sở lập trình -127- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. Sau khi goi ham doiso.a = 500 8.3.5 Con trỏ struct C cũng cho phép con trỏ trỏ tới struct tương tự như con trỏ trỏ tới các kiểu dữ liệu khác. Dùng con trỏ truy xuất đến từng trường trong struct theo cú pháp: -> ; - Ví dụ 8.10: Giả sử ta đã có khai báo : struct hocsinh { char hodem[20]; char ten[10]; int tuoi; }; struct hocsinh *p; Để nhập liệu cho trường họ đệm ta dùng lệnh : printf("\n Ho dem :");gets(p -> hodem); Hoặc để xem dữ liệu trường họ đệm ta dùng lệnh : printf("%s",p -> hodem); - Ví dụ 8.11: Viết chương trình mô phỏng đồng hồ điện tử. Khi chương trình chạy hiện lên dạng 00:00:00 rồi tăng dần theo giây, phút, giờ. Chương trình có sử dụng biến con trỏ để trỏ đến struct chứa 3 trường: giờ, phút, giây. Giải: #include #define DELAY 1000000 struct thoigian { int gio; int phut; int giay; }; void hienthi(struct thoigian *t); /* Hàm hiển thị thời gian */ void capnhat(struct thoigian *t); /* Hàm cập nhật giờ phút giây */ void tre(void); /* Thời gian trễ giữa 2 lần hiển thị */ main() { struct thoigian tg; tg.gio = 0; tg.phut = 0; Bài giảng Cơ sở lập trình -128- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. tg.giay = 0; for (;;) { capnhat(&tg); hienthi(&tg); while (kbhit()) exit(0); /* Bấm phím bất kỳ thì dừng */ } } void capnhat(struct thoigian *t) { t -> giay++; if (t -> giay ==60) { t -> giay = 0; t -> phut++; } if (t -> phut == 60) { t -> phut = 0; t -> gio++; } if (t -> gio == 24) t -> gio =0; tre(); } void hienthi(struct thoigian *t) { clrscr(); printf("%02d:",t-> gio); printf("%02d:",t-> phut); printf("%02d",t-> giay); } void tre(void) { long int t; for (t=1;t <DELAY;++t); } 8.3.6 Hàm đọc và xác lập thời gian, ngày tháng Các hàm này chứa trong thư viện dos.h Tổ chức struct về ngày tháng như sau: Bài giảng Cơ sở lập trình -129- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. struct date { int da_year; /* Năm hiện tại */ char da_day; /* Ngày trong tháng */ char da_mon; /* Tháng trong năm */ } void getdate (struct date *datep); Đọc ngày tháng năm trong máy void setdate(struct date *datep); : Xác lập ngày tháng năm Tổ chức struct về thời gian như sau: struct time { unsigned char ti_min ; /* Phút hiện tại */ unsigned char ti_hour; /* Giờ hiện tại */ unsigned char ti_hund ; /* Sao hiện tại */ unsigned char ti_sec ; /* Giây hiện tại */ } void gettime (struct time *timep); Đọc thời gian trong máy void settime(struct time *timep); Xác lập thời gian cho máy - Ví dụ 8.12: Chương trình đọc và xác lập ngày tháng năm của máy #include #include main(void) { struct date d; struct date reset; clrscr(); getdate(&d); printf("Hom nay la ngay %d/%d/%d\n",d.da_day,d.da_mon,d.da_year); getdate(&reset); printf("Ban nhap ngay thang muon doi \n"); printf("Nhap ngay ");scanf("%d",&reset.da_day); printf("Nhap thang ");scanf("%d",&reset.da_mon); printf("Nhap nam ");scanf("%d",&reset.da_year); setdate(&reset); getch(); } Bài giảng Cơ sở lập trình -130- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. - Ví dụ 8.13: Chương trình đọc và xác lập thời gian của máy. #include #include main(void) { struct time t; struct time reset; clrscr(); gettime(&t); printf("Bay gio la : %2d gio %2d phut %2d giay %2d sao\n “, t.ti_hour,t.ti_min,t.ti_sec,t.ti_hund); t.ti_hour = t.ti_hour + 1; settime(&t); printf("Gio vua thay doi\n"); gettime(&t); printf("Bay gio la : %2d gio %2d phut %2d giay %2d sao\n", t.ti_hour,t.ti_min,t.ti_sec,t.ti_hund); getch(); } 8.4 Bài tập thực hành 1. Để quản lý nhân sự, mỗi nhân viên trong cơ quan cần có các thông tin sau - Họ tên - Ngày sinh - Quê quán - Chỉ số lương Viết chương trình cho phép nhập và xem danh sách nhân viên. Yêu cầu kỹ thuật: Trong chương trình gồm hai hàm: Nhập danh sách và xem danh sách. Sau đó, chương trình chính gọi 2 hàm vào thực hiện yêu cầu bài toán. 2. Một tờ hóa đơn thông thường có các mục sau : - Số thứ tự - Tên loại hàng - Số lượng hàng - Đơn giá - Thành tiền từng loại hàng Bài giảng Cơ sở lập trình -131- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. - Tổng tiền của tờ hóa đơn Viết chương trình thực hiện nhập các thông tin bán hàng gồm: Tên hàng, số lượng, đơn giá. Sau đó chương trình tính toán và in ra màn hình các thông tin theo mẫu sau: STT Loại hàng Số lượng Đơn giá Thành tiền 1 Xe máy 2 10.000.000 20.000.000 ... . . Tổng số tiền: .. 3. Viết chương trình nhập vào danh sách nhân viên trong một cơ quan. Thông tin của một nhân viên gồm: Họ tên, chức vụ, hệ số lương. Sau đó chương trình in ra màn hình bảng lương theo mẫu: STT Họ tên Chức vụ Chỉ số Lương Ký nhận 1 Nguyen Van Binh GD 4.98 6227000 .. . Biết rằng: Nếu chức vụ là GD (giám đốc) được phụ cấp 500.000 đ, PG (phó giám đốc) được phụ cấp 300.000 đ Lương = Chỉ số * 1.150.000 + phụ cấp. 4. Viết chương trình sử dụng phối hợp mảng, struct, hàm để quản lý một danh sách các hộ gia đình trong một khu phố, thông tin của mỗi hộ gồm : Tên chủ hộ, đường phố, phường, thành phố. Chương trình được tổ chức thành menu có các chức năng: a. Nhập (Nhập danh sách) b. Xem danh sách (Xem danh sách đã nhập) c. Sắp xếp danh sách (Sắp xếp danh sách theo tên chủ hộ) d. Kết thúc. (Kết thúc chương trình) 5. Để quản lý điểm của học sinh, mỗi học sinh cần có các thông tin sau: Holot, ten, ngày sinh, DTB. Viết chương trình tổ chức thành menu có các chức năng: a. Nhập. (Nhập thông tin của các học sinh) b. Xem danh sách (Xem danh sách học sinh) c. Bổ sung danh sách (Bổ sung danh sách học sinh) d. Sắp xếp danh sách (Sắp xếp danh sách theo tên) e. Xem danh sách thi lại (Danh sách học sinh có DTB < 5) f. Xem danh sách lên lớp (Danh sách học sinh có DTB ≥ 5) g. Kết thúc (Kết thúc chương trình) Bài giảng Cơ sở lập trình -132- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. CHƯƠNG 9: KIỂU DỮ LIỆU TẬP TIN (FILE) Mục tiêu Kết thúc chương, sinh viên có thể:
Phân biệt được các dạng tập tin.
Nắm vững các bước và thao tác trên tập tin: dạng văn bản, dạng nhị phân. 9.1 Khái niệm về kiểu dữ liệu tập tin và các dạng tập tin - Dữ liệu của các biến thuộc các kiểu dữ liệu đã trình bày ở các chương trước chỉ lưu trữ ở bộ nhớ RAM, vì vậy việc lưu trữ đó chỉ mang tính tạm thời, phục vụ cho quá trình xử lý thông tin trong phiên làm việc đó. Để dữ liệu được lưu trữ có tính chất vĩnh viễn (giả sử thiết bị lưu trữ không bị hư hỏng) phục vụ cho cả quá trình làm việc, C cung cấp cho chúng ta kiểu dữ liệu tập tin. - Với kiểu dữ liệu tập tin, bạn có thể lưu các dữ liệu lên các bị trữ tin như đĩa mềm, đĩa cứng, USB,Từ đó ta có thể sao chép dữ liệu từ máy này sang máy khác. - Tùy theo cách tổ chức của từng dạng tập tin mà người ta phân loại chúng thành các dạng khác nhau. Theo ANSI C thì có 2 phương thức để truy cập tập tin: nhị phân (binary) và văn bản (text), nghĩa là có 2 dạng tập tin: + Tập tin kiểu văn bản (text file): Các phần tử của tập tin văn bản là các ký tự, được tổ chức thành từng dòng với độ dài mỗi dòng khác nhau và có thêm dấu hết dòng hay dấu chấm xuống dòng. Các tập tin văn bản do các chương trình soạn thảo văn bản như Notepad của Window, các hệ soạn thảo chương trình nguồn của các ngôn ngữ lập trình và thường có phần mở rộng: *.txt, *.c, *.cpp, *.pas, + Tập tin kiểu nhị phân (binary file): Là các tập tin không có dạng văn bản. Mỗi tập tin nhị phân có cấu trúc do phần mềm tạo ra nó quy định. Các tập tin này thường có phần mở rộng: *.doc, *.exe, *.com, *.bmp, *.gif, 9.2 Khai báo biến tập tin – Một số hàm thường dùng khi thao tác trên tập tin 9.2.1 Khai báo biến tập tin - Khi thao tác với tập tin, thường bạn thực hiện tuần tự các bước sau: + Khai báo biến tập tin. + Mở tập tin để đọc hoặc ghi. + Xử lý dữ liệu (ghi dữ liệu vào tập tin hoặc đọc nội dung tập tin). + Đóng tập tin. - Cú pháp: FILE *; Trong đó: + FILE là từ khóa khai báo và luôn luôn có ở dạng chữ hoa. Bài giảng Cơ sở lập trình -133- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. + *: Biến con trỏ tập tin. Nếu khai báo nhiều biến con trỏ tập tin thì các biến con trỏ được viết cách nhau bởi dấu phẩy. - Ví dụ 9.1: FILE *f1, *f2, *f3; 9.2.2 Mở tập tin để đọc hoặc ghi - Cú pháp: FILE *open(const char *, const char *); Trong đó: + : Là tên của tập tin bạn muốn mở. + : Kiểu truy nhập. - Tác dụng: Hàm dùng để mở tập tin. Nếu mở thành công, hàm trả về con trỏ kiểu FILE tương ứng với tập tin vừa mở. Nếu mở không thành công hàm trả về giá trị NULL. - Ví dụ 9.2: f = fopen(“C:\\TC\\VD.TXT”,”w”); /* Mở để ghi */ f = fopen(“C:\\TC\\VD.TXT”,”r”); /* Mở để đọc */ - Các tham số của kiểu xử lý được cho trong bảng sau: Kiểu xử lý cho tập tin dạng văn bản Kiểu xử lý Ý nghĩa “r” Mở tập tin văn bản đã có để đọc “w” Mở tập tin văn bản mới để ghi, nếu đã có thì tập tin cũ bị xóa “a” Mở tập tin văn bản đã có và ghi thêm dữ liệu nối tiếp vào cuối tập tin “r+” Mở tập tin văn bản đã có và cho phép cả ghi lẫn đọc “w+” Mở tập tin văn bản mới và cho phép cả ghi lẫn đọc. Nếu đã có thì tập tin cũ bị xóa thay vào đó tập tin mới “a+” Mở tập tin văn bản đã có hoặc tạo tập tin mới để đọc và ghi thêm dữ liệu tiếp nối vào cuối tập tin này hoặc đọc Kiểu xử lý cho tập tin dạng nhị phân Kiểu xử lý Ý nghĩa “rb” Mở tập tin nhị phân đã có để đọc “wb” Mở tập tin nhị phân mới để ghi, nếu đã có thì tập tin cũ bị xóa “ab” Mở tập tin nhị phân đã có và ghi thêm dữ liệu nối tiếp vào cuối tập tin “r+b” Mở tập tin nhị phân đã có và cho phép cả ghi lẫn đọc Bài giảng Cơ sở lập trình -134- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. “w+b” Mở tập tin nhị phân mới và cho phép cả ghi lẫn đọc. Nếu đã có thì tập tin cũ bị xóa thay vào đó tập tin mới “a+b” Mở tập tin nhị phân đã có và ghi thêm dữ liệu nối vào cuối tập tin này. Nếu tập tin này chưa có thì một tập tin mới sẽ được tạo ra 9.2.3 Ghi các mẫu tin lên tập tin - Cú pháp: int fwrite(void *, int size, int n, FILE *); Trong đó: + : Là con trỏ trỏ tới vùng nhớ chứa dữ liệu cần ghi. + size: Kích thước của mẫu tin (tính bằng byte). + n là số mẫu tin cần ghi. + : Tên biến con trỏ tập tin. - Tác dụng: Hàm ghi n mẫu tin có kích thước size từ vùng nhớ lên tập tin có tên được trỏ bởi . - Ví dụ 9.3: Đoạn chương trình sau ghi các số nguyên từ 1 đến 100 xuống tập tin trỏ bởi biến tập tin f. for (i=1;i<=100;i++) fwrite(&i,sizeof(int),1,f); Đoạn chương trình trên, với mỗi lần lặp sẽ thực hiện ghi dữ liệu tại địa chỉ biến i có kích thước là số nguyên 2 byte xuống tập tin được trỏ bởi biến tập tin f. 9.2.4 Đọc các mẫu tin từ tập tin - Cú pháp: int fread(void *, int size, int n, FILE *); Trong đó: + : Là con trỏ trỏ tới vùng nhớ sẽ đọc dữ liệu vào. + size: Kích thước của mẫu tin (tính bằng byte). + n là số mẫu tin cần đọc. + : Tên biến con trỏ tập tin. - Tác dụng: Hàm đọc n mẫu tin có kích thước size từ tập tin có tên được trỏ bởi lên vùng nhớ do đang trỏ. - Ví dụ 9.4: Đoạn chương trình sau đọc nội dung tập tin được trỏ bởi biến tập tin f và viết lên màn hình. do { fread(&i,sizeof(int),1,f); Bài giảng Cơ sở lập trình -135- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. if (!feof(f)) /* Kiểm tra phần tử vừa đọc có phải cuối tập tin */ printf(“%d”,i); } while (!feof(f)); 9.2.5 Đóng tập tin Khi kết thúc làm việc với tập tin bạn phải đóng tập tin. - Cú pháp: int fclose(FILE *); - Tác dụng: Hàm đóng tập tin khi kết thúc thao tác với tập tin. Lúc này, máy sẽ thực hiện: + Nếu đang ghi dữ liệu, máy sẽ đẩy dữ liệu còn trong vùng đệm lên đĩa. + Nếu đang đọc dữ liệu, máy sẽ xóa vùng đệm. + Giải phóng biến con trỏ tập tin. - Ví dụ 9.5: fclose(f); /* Đóng tập tin đang làm việc được trỏ bởi biến *f / 9.2.6 Hàm kiểm tra cuối tập tin - Cú pháp: int feofe(FILE *); - Tác dụng: Hàm trả về giá trị 0 nếu cửa số file chưa ở cuối tập tin. Hàm trả về giá trị khác 0 nếu cửa sổ file đang ở cuối tập tin. - Ví dụ 9.6: Ví dụ tổng quát về cách mở một tập tin để thực hiện một công việc nào đó. Chương trình thông báo ra màn hình nếu việc mở không thành công. Giải: #include main() { FILE *f; f = fopen(“Tên_tập_tin”,”Kiểu_xử_lý”); if (f == NULL) printf(“\n Loi mo tap tin”); else ; fclose(f); } 9.2.7 Hàm kiểm tra lỗi - Cú pháp: int ferror(FILE *); - Tác dụng: Hàm kiểm tra lỗi khi thao tác trên tập tin có tên được quản lý bới . Hàm trả về giá trị 0 nếu không có lỗi, giá trị khác 0 nếu có lỗi. Bài giảng Cơ sở lập trình -136- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. 9.2.8 Hàm chuyển con trỏ về đầu tập tin - Cú pháp: void rewind(FILE *); - Tác dụng: Hàm chuyển cửa sổ tập tin về đầu tập tin. Lúc này, việc nhập xuất được thực hiện từ đầu tập tin. 9.2.9 Hàm chuyển con trỏ đến vị trí bất kỳ trên tập tin - Cú pháp: void fseek(FILE *, long n, int vt); - Tác dụng: Hàm chuyển cửa sổ tập tin về vị trí bất kỳ được xác định bởi vt. Với n là số byte cần di chuyển, nếu n dương, chiều di chuyển về cuối tập tin, nếu n âm chiều di chuyển về đầu tập tin. Vt có thể nhận những giá trị sau: + 0 hay SEEK_SET: xuất phát từ đầu tập tin. + 1 hay SEEK_CUR: xuất phát tại vị trí hiện thời của con trỏ tập tin. + 2 hay SEEK_END: xuất phát tại vị trí cuối tập tin. 9.2.10 Hàm làm sạch vùng đệm của tập tin - Cú pháp: void fflush(FILE *, long n, int vt); - Tác dụng: Hàm dùng làm sạch vùng đệm của tập tin (đỗ hết nội dung trong bộ nhớ đệm của tập tin) ra tập tin được quản lý bởi . Hàm trả về giá trị 0 nếu lệnh thành công, ngược lại hàm trả về EOF. 9.2.11 Hàm đổi tên tập tin - Cú pháp: int rename(const char *, char *); - Tác dụng: Hàm cho phép đổi tên tập tin. Hàm trả về giá trị 0 nếu việc đổi tên thành công, không có lỗi. 9.2.12 Hàm xóa tập tin - Cú pháp: int unlink(const char *); - Tác dụng: Hàm được dùng để xóa một tập tin trên đĩa. Hàm tra về giá trị 0 nếu việc xóa thành công. 9.2.13 Hàm ghi một ký tự lên tập tin văn bản - Cú pháp: int putc(int ch, FILE *); - Tác dụng: Hàm ghi một ký tự có mã bằng ch % 256 lên tập tin văn bản có tên trỏ bởi . 9.2.14 Hàm đọc một ký tự từ tập tin văn bản - Cú pháp: int getc(FILE *); - Tác dụng: Hàm đọc một ký tự từ tập tin văn bản được trỏ bởi 9.2.15 . Hàm đọc một chuỗi ký tự từ tập tin văn bản - Cú pháp: int fgetc(int st[MAX], int n, FILE *); Bài giảng Cơ sở lập trình -137- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. - Tác dụng: Hàm cho phép đọc một chuỗi ký tự từ tập tin văn bản được trỏ bởi vào cho biến st. Các hàm xử lý tập tin nêu trên chứa trong tập tin tiền xử lý stdio.h 9.3 Các ví dụ minh họa - Để tạo tập tin mới, bạn mở tập tin bằng hàm fopen với chế độ xử lý là “w” hoặc “wb”. Lúc này tập tin rỗng vì chưa có phần tử nào. Cửa sổ file lúc này chưa có giá trị xác định vì nó đang trỏ vào cuối tập tin. Sau đó, bạn tiến hành dùng các lệnh để xử lý dữ liệu và ghi vào tập tin. Kết thúc việc ghi phải đóng tập tin. - Để đọc file dữ liệu, bạn phải tập tin bằng hàm fopen với chế độ xử lý là “r” hoặc “rb”. Sau đó kiểm tra xem tập tin có còn phần tử nào không (cửa sổ tập tin đã trỏ đến cuối tập tin chưa). Hàm feof() sẽ cho giá trị true nếu cửa sổ tập file trỏ vào cuối tập tin, ngược lại hàm cho giá trị false. Kết thúc quá trình làm việc với tập tin phải đóng tập tin. Lưu ý: Cần phải đọc phần tử của tập tin trước rồi mới thử xem nó có phải là cuối tập tin chưa? 9.3.1 Ví dụ về nhập xuất cho tập tin văn bản - Ví dụ 9.7: Viết chương trình thực hiện các công việc: + Đọc một dòng ký tự thường từ bàn phím, đổi các ký tự vừa đọc sang ký tự hoa và ghi vào tập tin VIDU.TXT. + Đọc nội dung có trong tập tin VIDU.TXT và viết lên màn hình. Giải: #include main() { FILE *f; char c; f = fopen(“D:\\VIDU.TXT”, “w”); do putc(toupper(c = getchar()),f) while (c != ‘\n’); fclose(f); if ((f = fopen(“D:\\VIDU.TXT”, “r”))==NULL) printf(“Khong mo duoc tap tin”); else do putchar(c = getc(f)); while (c != ‘\n’); Bài giảng Cơ sở lập trình -138- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. getch(); fclose(f); } Với ví dụ trên, chương trình thực hiện đọc và ghi từng ký tự. Để thuận lợi bạn có thể vận dụng các hàm đọc và ghi từng dòng văn bản như ví dụ 9.8 sau. - Ví dụ 9.8: Viết chương trình thực hiện các công việc: + Nhập tên tập tin văn bản từ bàn phím (có thể có đường dẫn chứa tập tin) + Hiển thị nội dung của tập tin lên màn hình. + Thông báo số dòng văn bản của tập tin vừa đọc. Giải: #include main() { FILE *f; int i,dong = 0; char ten[30]; char st[255]; clrscr(); printf("Nhap ten tap tin "); gets(ten); if ((f = fopen(ten,"r")) == NULL) printf("\a\n Co loi, khong mo duoc tap tin de doc."); else do { fgets(st,255,fp); printf("%s",st); dong++; } while (!feof(f)); printf("\nTong so dong co trong tap tin %d\n",dong); getch(); fclose(f); } 9.3.2 Ví dụ về nhập xuất cho tập tin nhị phân - Ví dụ 9.9: Viết chương trình thực hiện các công việc: Bài giảng Cơ sở lập trình -139- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. + Tạo mới tập tin có tên nhập tên tập tin nhập từ bàn phím (có thể có đường dẫn chứa tập tin) + Ghi vào tập tin vừa tạo các số nguyên từ 1 đến 100. + Đọc nội dung tập tin vừa tạo và viết lên màn hình. Giải: #include main() { char ten[20], ch; int i; long num; FILE *f; clrscr(); printf("Ten tap tin can tao "); scanf("%20s",ten); f = fopen(ten,"wb"); for (i=1;i<=100;i++) fwrite(&i,sizeof(int),1,f); fclose(f); printf("\n Da tao xong\n"); printf("\n Bam phim bat ky de xem noi dung tap tin vua tao\n"); getch(); i = 0; f = fopen(ten,"rb"); do { fread(&i,sizeof(int),1,f); if (!feof(f)) printf("%d ",i); } while (!feof(f)); fclose(f); getch(); } Đối với tập tin chứa các phần tử có kiểu struct cũng thuộc tập tin kiểu nhị phân - Ví dụ 9.10: Viết chương trình tạo bảng chọn có 4 chức năng: Bài giảng Cơ sở lập trình -140- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. 1. Nhập danh sách: Cho phép nhập danh sách học sinh từ bàn phím, thông tin mỗi học sinh gồm: hodem, ten, tuoi. Chương trình lặp đi lặp lại việc nhập cho đến chừng nào ký tự đầu của hodem là rỗng thì kết thúc nhập. Dữ liệu nhập vào được lưu lên tập tin DULIEU.DAT. 2. Xem danh sách: Cho phép đọc dữ liệu từ tập tin DULIEU.DAT và viết lên màn hình thành bảng danh sách học sinh theo mẫu sau: STT Ho va ten Tuoi .. . 3. Sắp xếp danh sách: Sắp xếp danh sách học sinh có trong tập tin vừa nhập tăng dần theo tên. 4. Thoát: Nếu người dùng chọn chức năng này thì kết thúc chương trình. Giải: Việc ghi tập tin dữ liệu struct không cần phải ghi từng phần tử một mà ghi cả một struct ra tập tin, song khi đọc dữ liệu từ bàn phím vào cho biến struct thì phải đọc lần lượt cho từng phần tử của struct. #include #include #include struct hocsinh { char hodem[20]; char ten[10]; int tuoi; } hs,tam; FILE *f; int i; int menu(void); void nhap(void); void xem(void); void sapxep(void); main() { int chon; for (;;) Bài giảng Cơ sở lập trình -141- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. { clrscr(); chon = menu(); switch (chon) { case 1 : nhap(); break; case 2 : xem(); break; case 3 : sapxep(); break; case 4 : exit(0); } } } int menu(void) { int c; char s[10]; clrscr(); printf("1. Nhap danh sach \n"); printf("2. Xem danh sach \n"); printf("3. Sap xep danh sach \n"); printf("4. Thoat \n"); do { printf("Bam so de chon (1/2/3/4)"); gets(s); c = atoi(s); } while (c 4); return c; } int n; void nhap(void) { int T =1; Bài giảng Cơ sở lập trình -142- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. char c; clrscr(); f = fopen("D:\\DULIEU.DAT","wb"); i = 1; while (T) { clrscr(); printf("\n Nguoi thu %d",i); printf("\n Ho dem :");gets(hs.hodem); if (hs.hodem[0] =='\0') break; printf("\n Ten :");gets(hs.ten); printf("\n Tuoi :");scanf("%d",&hs.tuoi); fwrite(&hs,sizeof(hs),1,fp); while (getchar() != '\n'); i++; } fclose(f); } void xem(void) { int j; char c; clrscr(); j = 0; printf("STT Ho va ten Tuoi\n"); f = fopen("D:\\DULIEU.DAT","rb"); while (fread(&hs,sizeof(hs),1,f),!feof(f)) { printf("%3d ",j+1); printf("%-20s",hs.hodem); printf("%-10s",hs.ten); printf("%5d",hs.tuoi); printf("\n"); j++; } Bài giảng Cơ sở lập trình -143- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. fclose(f); getch(); } void sapxep(void) { struct hocsinh ds[10]; int j,sl=0; clrscr(); f = fopen("D:\\DULIEU.DAT","r+b"); while (fread(&hs,sizeof(hs),1,f),!feof(f)) { sl++; ds[sl] = hs; } for (i=1;i<=sl-1;i++) for (j=i+1;j<=sl;j++) if (strcmp(ds[i].ten,ds[j].ten)>0) { tam = ds[i]; ds[i] = ds[j]; ds[j] = tam; } fseek(fp,0,SEEK_SET); for (i=1;i<= sl;i++) fwrite(&ds[i],sizeof(hs),1,f); printf("Da sap xep xong "); getch(); fclose(f); } 9.3.3 Ví dụ về chuyển tham số là tên tập tin cho hàm Giả sử bạn viết chương trình đếm số ký tự có trong một tập tin văn bản đã có trên đĩa. Yêu cầu kỹ thuật: Khi gõ lệnh thực hiện chương trình gõ tên tập tin chương trình, sau đó gõ tiếp tham số là tên tập tin muốn đếm. Giải: #include #include Bài giảng Cơ sở lập trình -144- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. main(int ds1, char *ds2[]) { int ch; FILE *f; long dem = 0; if (ds1 !=2) { printf("Khong nhap ten tap tin can dem"); exit(1); } if ((f = fopen(ds2[1],"r")) == NULL) { printf("Khong the mo tap tin %s\n",ds2[1]); exit(1); } while ((ch=getc(f)) != EOF) { putc(ch,stdout); dem++; } fclose(f); printf("Tap tin %s co %ld ky tu\n",ds2[1],dem); getch(); } 9.4 Bài tập thực hành 1. Viết chương trình thực hiện các công việc: a. Tạo tập tin STN1.DAT chứa 50 số tự nhiên đầu tiên. b. Tạo tập tin STN2.DAT chứa các số tự nhiên từ 51 đến 100. c. Ghép tập tin STN1.DAT với tập tin STN2.DAT thành tập tin STN3.DAT. In ra màn hình nội dung của tập tin STN3.DAT. 2. Dùng trình soạn thảo Notepad củaWindow tạo trên thư mục gốc ổ đĩa D: tập tin văn bản có tên VIDU.TXT trong đó có chứa vài dòng văn bản với nội dung tuỳ ý. Bài giảng Cơ sở lập trình -145- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. Khởi động C, viết chương trình thực hiện các công việc: a. Đọc tập tin VIDU.TXT và viết nội dung của tập tin lên màn hình. b. Đếm tổng số dòng của văn bản. c. Tính tổng số từ có trong văn bản. d. Tính số lượng của từng loại ký tự có trong văn bản. 3. Gỉa sử có một tập tin văn bản lưu dãy các số nguyên dương trên nhiều dòng, mỗi dòng lưu đúng 10 số, giữa 2 số cách nhau ít nhất một ký tự trắng. Viết chương trình đọc dãy số từ tập tin, sau đó viết các số chẳn lên màn hình và thông báo số lượng số chẳn có trong tập tin. 4. Viết chương trình đếm số lượng ký tự là nguyên âm có trong một tập tin văn bản (tên tập tin văn bản nhập từ bàn phím). Biết rằng: Các nguyên âm bao gồm: A, E, I, O, U. 5. Viết chương trình tạo tập tin văn bản chứa tên, tuổi, địa chỉ của bạn (mỗi thứ chiếm một dòng). Sau đó chương trình sẽ đọc nội dung tập tin và in ra màn hình với quy định: thông tin của một người nằm trên một dòng. 6. Để quản lý điểm thi vào lớp 10 của thí sinh, mỗi thí sinh cần lưu giữ các thông tin: số báo danh, họ đệm, tên, điểm toán, điểm văn. Viết chương trình thực hiện các công việc sau: a. Mở tập tin mới có tên DULIEU.DAT để nhập họ đệm, tên, điểm toán, điểm văn. Việc nhập được tiến hành cho đến chừng nào nhập họ đệm là xâu rỗng thì kết thúc. b. Sắp xếp danh sách theo tăng dần theo tên có trong tập tin DULIEU.DAT. c. In ra màn hình danh sách trúng tuyển (Thí sinh có tổng điểm 2 môn ≥ 12). STT Ho va ten Diem toan Diem van Tong diem .. . . . d. In ra màn hình danh sách hỏng (Thí sinh có tổng điểm 2 môn < 12). STT Ho va ten Diem toan Diem van Tong diem .. . . . Yêu cầu kỹ thuật: Tổ chức chương trình thành bảng chọn có 5 chức năng. Mỗi chức năng giải quyết một công việc nêu trên trong một chương trình con. Chức năng 5 dùng để chấm dứt chương trình. Bài giảng Cơ sở lập trình -146- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. PHỤ LỤC 1: MÔI TRƯỜNG IDE CỦA TURBO C Môi trường IDE (Integrated Development Environment) của Turbo C cung cấp cho bạn mọi thứ như: soạn thảo, dịch, liên kết, chạy, quản lý và gỡ rối một chương trình. Nếu máy của bạn chạy hệ điều hành từ Windows XP trở về trước thì có thể cài đặt bộ Turbo C 2.0 hoặc Turbo C 3.0 để sử dụng. Nếu máy của bạn cài hệ điều hành Windows 7 thì cài bộ TurboC_BOSBox_setup. Bắt đầu từ Turbo C 3.0 trở đi là C++, các tập tin được tạo ra có phần mở rộng mặc định là CPP, vì vậy khi soạn thảo tập tin mã nguồn trong môi trường này, bạn phải lưu tập tin với tên có cả phần mở rộng là .C. Sau khi cài đặt xong Turbo C, thường có một thư mục có tên TC, trong đó có chứa các thư mục con và các tập tin làm việc như sau: TC\INCLUDE: Chứa các tập tin header TC\LIB: Chứa các tập tin thư viện TC\BGI: Chứa các tập tin có phần mở rộng BGI, CHR phục vụ cho đồ hoạ TC\EXAMPLE: Chứa các tập tin ví dụ. TC\BIN: Chứa các tập tin thực hiện chương trình như TC.EXE, Môi trường phát triển tích hợp (DOS IDE) của trình biên dịch Turbo C được khởi động từ tập tin TC.EXE (Bạn có thể tạo icon của chương trình lên desktop và khởi động từ icon này trong chế độ Windows) 1. Khởi động và thoát khỏi - Khởi động: + Từ dấu nhắc hệ điều hành, chuyển vào làm việc với thư mục có chứa tập tin thực thi Turbo C (C:\TC\BIN) và gõ TC + Nhắp đúp chuột lên icon của chương trình trên desktop. Bài giảng Cơ sở lập trình -147- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. - Thoát khỏi: Kết thúc làm việc với Turbo C: Bấm F10
File
Quit hoặc bấm tổ hợp phím Alt+X. 2. Một số chức năng cơ bản trong bộ soạn thảo Turbo C - Tạo tập tin chương trình mới: bấm F10
File
New. - Mở tập tin mã nguồn có sẵn: bấm F10
File
Open hoặc bấm F3. Một hộp thoại được mở ra để bạn tìm và mở tập tin mã nguồn cần thiết. - Lưu tập tin mã nguồn: F10
File
Save hoặc bấm F2, sau đó chỉ rõ đường dẫn và đặt tên cho tập tin cần lưu. - Lưu tập tin chương trình với tên khác: Bấm F10
File
Save as - Tạo tập tin thực thi: Bấm F10
Compile
Make hoặc bấm F9 để tạo tập tin thực thi. Việc tạo tập tin thực thi trải qua 2 giai đoạn: Biên dịch (compile) và liên kết (link). Đầu tiên tập tin nguồn được chuyển thành tập tin đối tượng (object file), sau đó liên kết với các chương trình chứa trong các thư viện để tạo thành tập tin thực thi. Quá trình make thành công, sẽ có màn hình thông báo. Trường hợp quá trình make có lỗi ở khâu biên dịch hoặc liên kết, bạn phải tiến hành sửa các lỗi theo thông báo. - Thực hiện chương trình: Bấm F10
Run
Run hoặc bấm tổ hợp phím Ctrl+F9 để chạy chương trình. Trường hợp chạy chương trình có tham số thực hiện lệnh Bấm F10
Run
Arguments
hộp thoại Programs Arguments xuất hiện, bạn nhập các tham số. - Xem màn hình kết quả: Khi thực hiện chương trình xong, điều khiển sẽ trả về màn hình soạn thảo, muốn xem màn hình kết quả bấm tổ hợp phím Alt+F5. - Turbo C 3.0 cho phép mở nhiều cửa số soạn thảo cùng một lúc, bạn có thể di chuyển qua lại giữa các cửa sổ bằng phím F6. Để đóng một cửa sổ, đứng tại cửa số đó và bấm Alt+F3. - Một số phím tắt thường dùng khi soạn thảo chương trình nguồn: + Đánh dấu khối: Bấm Shift đồng thời bấm phím mũi tên để di chuyển con trỏ đến cuối khối. Bài giảng Cơ sở lập trình -148- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. + Sao chép khối vào clipboard: Ctrl+Insert + Dán khối từ clipboard ra màn hình soạn thảo: Shift+Insert + Xóa dòng: Bấm Ctrl+Y tại dòng con trỏ đang đứng. + Hủy bó lệnh vừa thực hiện: Bấm Alt+BackSpace. - Huỷ phiên Debug hiện thời và xoá vùng nhớ mà chương trình đã cấp phát: Bấm F10
Run
Program reset hoặc bấm tổ hợp phím Ctrl+F2. - Gỡ rối chương trình: Bạn muốn chương trình chỉ chạy đến một dòng lệnh nhất định, hãy đưa con trỏ tới dòng đó và bấm F4 hoặc chọn lệnh F10
Run
Go to cursor. - Chạy từng bước: Bấm F7 hoặc chọn F10
Run
Trace into. Khi chạy từng bước đến dòng lệnh có gọi hàm mà bạn nghi vấn có lỗi, bấm F7 để nhảy đến hàm đó và chạy từng bước các dòng lệnh của hàm nhằm tìm lỗi có trong hàm. - Chạy bước qua: Bấm F8 hoặc F10
Run
chọn Step over. Khi chạy từng bước đến dòng lệnh có gọi hàm mà bạn chắc rằng hàm đó không chưa lỗi, bấm F8 để không nhảy đến xem xét hàm đó làm gì. - Cửa sổ Watch và điểm ngắt (breakpoint): Khi chạy từng bước, bạn có thể dùng cửa sổ Watch để xem vị trí các biến trong chương trình. Bấm Ctrl+F7 để mở cửa số Watch, trong cửa sổ này, bấm Insert để đưa từng biến cần theo dõi vào cửa sổ Watch. Để tạo điểm ngắt, bạn đưa con trỏ đến dòng cần đặt điểm ngắt, bấm Ctrl+F8. Dựa vào điểm ngắt, chương trình được phân thành từng đoạn để dò lỗi - Quan sát các lời gọi hàm: Bấm F10
Debug
Call satck hoặc bấm tổ hợp phím Ctrl+F3. Lúc này, quá trình dò lỗi bạn sẽ quan sát được các chuỗi kể cả đối số của hàm được gọi. Bài giảng Cơ sở lập trình -149- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. PHỤ LỤC 2: MÔI TRƯỜNG IDE CỦA Bloodshed Dev-C++ Dev-C++ là ngôn ngữ được viết bằng ngôn ngữ Delphi, chạy được trên môi trường Windows (có cả phiên bản cho Linux) Bạn có thể download bộ devcpp- 4.9.9.2_setup và cài đặt vào máy. Dev-C++ là bộ chương trình mã nguồn mở, miễn phí, chạy ổn định và nhẹ. Môi trường IDE của Dev-C++ có nhiều chức năng, thư viện được mở rộng, template, tiện ích, Với IDE này, bạn có thể soạn thảo chương trình nguồn của C và cho thực thi các chương trình đó. Sau khi cài đặt thành công, khởi động chương trình Dev-C++, màn hình làm việc có dạng: - Bạn chọn File
New
Source File hoặc bấm tổ hợp phím Ctrl+N, sẽ xuất hiện cửa sổ cho bạn soạn thảo chương trình nguồn Bài giảng Cơ sở lập trình -150- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. - Chọn File
Save (Ctrl+S) để ghi tập tin. Khi ghi bạn cần lưu ý ngoài việc gõ tên vào hộp File name, bạn cần chỉ rõ C Source file (*.C) trong hộp Save as type. - Chọn File
Save as (Ctrl+F12) để đặt tên khác cho tập tin đã có tên. - Chọn Execute
Compile hoặc bấm tổ hợp phím Ctrl+F9 để biên dịch chương trình. - Chọn Execute
Run hoặc bấm tổ hợp phím Ctrl+F10 để chạy chương trình. - Chọn Execute
Conpile & Run hoặc bấm phím F9 để biên dịch và chạy chương trình. Bạn tìm hiểu thêm các chức năng thông qua hệ thống menu của chương trình. Bài giảng Cơ sở lập trình -151- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. TÀI LIỆU THAM KHẢO Tiếng Việt [1] Phạm Văn Ất (1995), Kỹ thuật lập trình C, Nhà xuất bản Khoa học và kỹ thuật. [2] Nguyễn Đình Tê, Hoàng Đức Hải (1996), Ngôn ngữ lập trình C. Nhà xuất bản Giáo dục. [3] Nguyễn Cấn (1996), Tự học ngôn ngữ lập trình C++, Nhà xuất bản Đồng Nai. [4] Lê Văn Doanh, Trần Khắc Tuấn (1996), 101 thuật toán và chương trình viết bằng ngôn ngữ C, Nhà xuất bản Khoa học và kỹ thuật – Hà Nội. [5] Quách Tuấn Ngọc (1998), Ngôn ngữ lập trình C, Nhà xuất bản Giáo dục. [6] Dương Thiên Tử (2006), Kỹ thuật lập trình C, Nhà xuất bản Thanh niên. Địa chỉ trên Internet [1] [2] Bài giảng Cơ sở lập trình -152- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. MỤC LỤC CHƯƠNG, MỤC Trang Chương 1: Các thành phần cơ bản .................................................................. 1 1.1 Bộ ký hiệu và từ khóa .................................................................................. 1 1.2 Cấu trúc chung của một chương trình C ........................................................ 2 1.3 Kiểu dữ liệu cơ sở ......................................................................................... 6 1.3.1 Kiểu dữ liệu .............................................................................................. 6 1.3.2 Kiểu số nguyên ......................................................................................... 6 1.3.3 Kiểu số thực .............................................................................................. 8 1.3.4 Kiểu ký tự ................................................................................................ 10 1.3.5 Kiểu Boolean ........................................................................................... 12 1.4 Câu hỏi và bài tập chương 1 ........................................................................ 12 Chương 2: Tiền xử lý – Hằng – Biến – Toán tử - Biểu thức – Câu lệnh ....... 13 2.1 Tiền xử lý ................................................................................................... 13 2.2 Hằng ........................................................................................................... 15 2.3 Biến ............................................................................................................ 16 2.4 Biểu thức và toán tử .................................................................................... 17 2.5 Câu lệnh ...................................................................................................... 24 2.6 Câu hỏi và bài tập chương 2 ........................................................................ 25 Chương 3: Nhập và xuất dữ liệu ..................................................................... 28 3.1 Câu lệnh nhập dữ liệu ................................................................................. 28 3.1.1 Nhập dữ liệu bằng hàm scanf ................................................................... 28 3.1.2 Nhập dữ liệu với hàm getchar() và getch() ............................................... 31 3.2 Câu lệnh xuất dữ liệu .................................................................................. 32 3.2.1 Xuất dữ liệu bằng hàm printf .................................................................... 32 3.2.2 Xuất dữ liệu bằng hàm putch .................................................................... 34 3.2.3 Các lệnh trình bày màn hình ..................................................................... 35 3.3 Bài tập thực hành ........................................................................................ 36 Chương 4: Cấu trúc điều khiển ...................................................................... 39 4.1 Câu lệnh điều kiện ...................................................................................... 39 4.1.1 Câu lệnh if ............................................................................................... 39 4.1.2 Câu lệnh switch ........................................................................................ 41 4.2 Câu lệnh lặp ................................................................................................ 45 Bài giảng Cơ sở lập trình -153- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. 4.2.1 Câu lệnh while ......................................................................................... 45 4.2.2 Câu lệnh do while ............................................................................... 47 4.2.3 Câu lệnh for ............................................................................................. 49 4.3 Các câu lệnh rẽ nhánh vô điều kiện ............................................................. 53 4.3.1 Câu lệnh break ......................................................................................... 53 4.3.2 Câu lệnh continue .................................................................................... 54 4.3.3 Câu lệnh goto ........................................................................................... 55 4.4 Câu hỏi và bài tập thực hành ....................................................................... 56 Chương 5: Kiểu dữ liệu mảng – Kiểu dữ liệu con trỏ ................................... 60 5.1 Kiểu dữ liệu mảng ....................................................................................... 60 5.1.1 Khái niệm mảng ....................................................................................... 60 5.1.2 Mảng một chiều ....................................................................................... 60 5.1.3 Mảng hai chiều ........................................................................................ 70 5.1.4 Điạ chỉ mảng ............................................................................................ 75 5.2 Kiểu dữ liệu con trỏ .................................................................................... 76 5.2.1 Khái niệm về con trỏ và biến động ........................................................... 76 5.2.2 Khai báo biến con trỏ ............................................................................... 77 5.2.3 Sử dụng con trỏ ........................................................................................ 77 5.2.4 Các phép toán trên con trỏ ........................................................................ 77 5.2.5 Mảng con trỏ ............................................................................................ 79 5.2.6 Các hàm cấp phát bộ nhớ động ................................................................ 80 5.3 Mối quan hệ giữa con trỏ với mảng ............................................................. 81 5.3.1 Con trỏ và mảng một chiều ...................................................................... 81 5.3.2 Con trỏ và mảng hai chiều ........................................................................ 82 5.4 Bài tập thực hành ........................................................................................ 82 Chương 6: Chuỗi ký tự ................................................................................... 85 6.1 Khái niệm ................................................................................................... 85 6.2 Khai báo chuỗi ký tự ................................................................................... 85 6.3 Các hàm nhập / xuất dữ liệu dùng cho chuỗi ký tự ...................................... 86 6.4 Các hàm thư viện xử lý chuỗi ký tự ............................................................. 87 6.5 Mối quan hệ giữa con trỏ với chuỗi ký tự .................................................... 93 6.6 Một số ví dụ tổng hợp về xử lý chuỗi ký tự ................................................. 94 6.7 Bài tập thực hành ........................................................................................ 96 Bài giảng Cơ sở lập trình -154- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. Chương 7: Chương trình con - Hàm .............................................................. 99 7.1 Khái niệm về chương trình con .................................................................... 99 7.2 Định nghĩa hàm .......................................................................................... 99 7.3 Lời gọi hàm, truyền tham số cho hàm ....................................................... 102 7.4 Biến toàn cục và biến địa phương ............................................................. 104 7.4.1 Biến toàn cục ......................................................................................... 104 7.4.2 Biến địa phương ..................................................................................... 105 7.4.3 Chương trình minh họa .......................................................................... 105 7.4.4 Các lớp lưu trữ biến ............................................................................... 106 7.5 Đệ quy ...................................................................................................... 107 7.5.1 Khái niệm .............................................................................................. 107 7.5.2 Các thành phần của giải thuật đệ quy ..................................................... 108 7.5.3 Phân loại giải thuật đệ quy ..................................................................... 109 7.5.4 Cơ chế hoạt động của giải thuật đệ quy .................................................. 109 7.5.5 Ưu nhược điểm của giải thuật đệ quy ..................................................... 111 7.6 Con trỏ hàm .............................................................................................. 111 7.7 Một số hàm thông dụng ............................................................................ 112 7.8 Bài tập thực hành ...................................................................................... 115 Chương 8: Khai báo kiểu – Kiểu liệt kê – Kiểu cấu trúc ............................ 118 8.1 Khai báo kiểu ............................................................................................ 118 8.2 Kiểu liệt kê ............................................................................................... 119 8.3 Kiểu cấu trúc ............................................................................................. 120 8.3.1 Khái niệm và định nghĩa ........................................................................ 120 8.3.2 Truy cập vào phần tử kiểu struct ............................................................ 122 8.3.3 Khai báo mảng struct ............................................................................. 122 8.3.4 Truyền tham số struct cho hàm .............................................................. 125 8.3.5 Con trỏ struct ......................................................................................... 127 8.3.6 Hàm đọc và xác lập thời gian, ngày tháng .............................................. 128 8.4 Bài tập thực hành ...................................................................................... 130 Chương 9: Kiểu dữ liệu tập tin .................................................................... 132 9.1 Khái niệm về kiểu dữ liệu tập tin và các dạng tập tin ................................ 132 9.2 Khai báo biến tập tin - Một số hàm thường dùng khi thao tác trên tập tin ... 132 9.3 Các ví dụ minh họa ................................................................................... 137 Bài giảng Cơ sở lập trình -155- Giảng viên: Th.S Trần Tấn Từ - Khoa CNTT – Đại học Phạm Văn Đồng. 9.3.1 Ví dụ về nhập, xuất cho tập tin văn bản .................................................. 137 9.3.2 Ví dụ về nhập, xuất cho tập tin nhị phân ................................................ 138 9.3.3 Ví dụ về chuyển tham số là tên tập tin cho hàm ...................................... 143 9.4 Bài tập thực hành ...................................................................................... 144 Phụ lục 1: Môi trường IDE của Turbo C .................................................... 146 Phụ lục 2: Môi trường IDE của Bloodshed Dev-C++ ................................. 149 Tài liệu tham khảo ........................................................................................ 151 Mục lục .......................................................................................................... 152