5.5.4.2. Truy nhập tệp dữ liệu nhị phân
a. Hàm putw(n; tên_biến): Là hàm để ghi số n (kiểu int) lên tệp dưới dạng 2 bytes. Giá trị của hàm trả về là số kiểu int đã được ghi vào tệp hoặc EOF nếu có lỗi ghi.
b. Hàm getw(biến_tệp): Là hàm đọc một số nguyên ghi ở 2 bytes từ tệp. Giá trị của hàm trả về là số kiểu int đã đọc được hoặc EOF nếu có lỗi hay gặp cuối tệp.
Ví dụ: Chương trình nhập một dãy n số nguyên từ bàn phím và ghi vào tệp có tên do người sử dụng nhập từ bàn phím rồi hiển thị dãy số nguyên đọc lại từ tệp đó ra màn hình.
#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fp ; char ten_tep[21];
int i, n, x;
printf(“
Vào tên tệp để ghi dãy số:”); scanf(“%s”, ten_tep)
fp = fopen(ten_tep, “wb”);
printf(“
Số phần tử của dãy n = “); scanf(“%d”, &n);
for (i=1; i<=n; i++)
{printf(“
Vào số nguyên thứ %d =”, i);
scanf(“%d %*c”, &x);
putw(x, fp);
}
fflush(fp);
fclose(fp);
fp = fopen(ten_tep, “rb”);
clrscr();
printf(“
Dãy số ghi trong tệp là :”);
while ( ! feof(fp) )
{ x = getw(fp); printf(“
%d “, x);}
fclose(fp);
getch();
}
c. Hàm fwrite(con_trỏ, kích_thước, n, biến_tệp): Hàm ghi vào tệp biến_tệp n khối dữ liệu có địa chỉ xác định bởi con_trỏ và độ dài trường nhớ xác định bởi kích_thước. Mỗi khối dữ liệu khi ghi vào tệp tạo thành một bản ghi. Giá trị trả về của hàm là số kiểu int chỉ số bản ghi ghi được.
d. Hàm fread(con_trỏ, kích_thước, n, biến_tệp): Hàm đọc n bản ghi có số lượng byte bằng kích_thước từ tệp biến_tệp chứa vào vùng nhớ có địa chỉ chỉ bởi con_trỏ.
Ví dụ: Chương trình nhập một dãy n số thực từ bàn phím và ghi vào tệp có tên là DULIEU.IN rồi hiển thị dãy số thực đọc lại từ tệp đó ra màn hình.
#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fp ; int i, n;
float x;
fp = fopen(“Dulieu.in”, “wb”);
printf(“
Số phần tử của dãy n = “); scanf(“%d”, &n);
for (i=1; i<=n; i++)
{printf(“
Vào số thực thứ %d =”, i);
scanf(“%f %*c”, &x);
fwrite(&x, sizeof(float), 1, fp);
}
fflush(fp);
fclose(fp);
printf(“
Đã ghi xong !!!”); getch();
fp = fopen(“Dulieu.in”, “rb”);
clrscr();
printf(“
Dãy số thực ghi trong tệp là :”);
while ( ! feof(fp) )
{ fread(&x, sizeof(x), 1, fp);
printf(“
%f “, x);}
fclose(fp);
getch();
}
5.5.4.3. Truy nhập tệp dữ liệu struct
Muốn truy nhập đến các dữ liệu kiểu truct, nhất thiết phải sử dụng đến hai hàm fwite() và fread() để ghi hoặc đọc từng khối (bản ghi) đối với tệp nhị phân. Khi lấy ra các thành phần của struc, vẫn tham chiếu bình thường như đã giới thiệu ở phần 5.2.2 (tên_biến.phần_tử hoặc con_trỏ->phần tử).
Ví dụ: Chương trình quản lí số điện thoại của các nhân viên trong cơ quan được thiết kế thành các hàm:
- Hàm nhap(): Để nhập bản ghi mới gồm hai thành phần họ tên và số điện thoại; Nếu tệp chưa có thì tạo mới, nếu đã có thì bổ sung bản ghi vào phía cuối tệp. Để kết thúc nhập, bấm Enter khi nhập họ tên.
- Hàm duyet(): Để đọc lần lượt từng bản ghi rồi hiển thị chúng lên màn hình thành từng cột;
- Hàm xem(): Để xem một bản ghi khi biết số thứ tự; Kết thúc xem bấm một số âm. Hàm này minh hoạ cho việc truy nhập ngẫu nhiên một bản ghi trong tệp.
- Hàm main(): Là hàm chính điều hành các công việc thông qua việc gọi các hàm liên kết với một thực đơn luôn được hiển thị trên màn hình.
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct ban_ghi
{ char hoten[30];
long int phone;};
typedef struct ban_ghi nhanvien;
FILE *fp;
long size = sizeoff(nhanvien);
/* ********************* */
void nhap()
{ nhanvien x;
fp = fopen(“Sophone.dat”, “ab”);
while (1)
{ printf(“
Nhap ho ten : ”); gets(x.hoten);
if (strlen(x.hoten) = = 0) break;
printf(“
Nhap so dien thoai : ”
scanf(“%ld%*c”, &x.phone);
fwrite(&x, size, 1, fp);
}
fclose(fp);
}
/* ********************* */
int duyet()
{ nhanvien x;
fp = fopen(“Sophone.dat”, “rb”);
if (fp = = NULL)
{ clrscr();
printf(
Tep chua ton tai, bam ENTER de tiep tuc ...”);
getch();
return 1;
}
while ( fread(&x, size, 1, fp) >0 )
printf(“
%-30s %ld”, x.hoten, x.phone);
fclose(fp);
printf(“
Nhan ENTER de quay ve ...”);
getch();
retunr 0;
}
/* ********************* */
void xem()
{ nhanvien x;
int so_bg , kqua;
fp = fopen(“Sophone.dat”, “r+b”);
so_bg = 0;
while (so_bg >=0)
{ clrscr();
printf(“
Nhap so ban ghi muon xem : ”);
scanf(“%d%*c”, &so_bg);
fseek(fp, so_bg*size, SEEK_SET);
kqua = fread(&x, size, 1, fp);
if (kqua = = 1)
printf(“
%-30s %ld”, x.hoten, x.phone);
else
printf(“
Khong co ban ghi so %d”,so_bg);
printf(“
Nhan ENTER de tiep tuc ...”);
getch();
}
fclose(fp);
}
/* ********************* */
void main()
{ int ch, thoat = 1;
while (thoat)
{ clrscr();
printf(“
1. Nhap so dien thoai tung nguoi”);
printf(“
2. Hien bang tra cuu so dien thoai ”);
printf(“
3. Xem so dien thoai tung nguoi”);
printf(“
4. Thoat khoi chuong trinh”);
printf(“
Hay bam 1 / 2/ 3/ 4 de chon cong viec ”);
ch = getchar();
fflush(stdin);
switch (ch)
{ case ‘1’ : nhap(); break;
case ‘2’ : duyet(); break;
case ‘3’ : xem(); break;
case ‘4’ : thoat = 0; break;
}
}
}
5.5.5. Tệp văn bản
5.5.5.1. Một số hàm xử lí tệp văn bản
a. Hàm fprintf(biến_tệp, xâu_điều_khiển, danh_sách_đối): Là hàm tổng quát để đưa thông tin ra các thiết bị ngoại vi thông qua các luồng dữ liệu khác nhau. Cách sử dụng hàm này giống như hàm printf() nhưng không đưa ra màn hình mà đưa ra tệp văn bản được trỏ bởi biến_tệp. Nếu ghi thành công, hàm sẽ cho giá trị là một số nguyên kiểu int bằng số byte ghi được ra tệp, ngược lại cho giá trị EOF.
b.Hàm fscanf(biến_tệp, xâu_điều_khiển, danh_sách_đối): Tương tự như hàm scanf() nhưng không đọc dữ liệu từ bàn phím mà đọc từ tệp văn bản được trỏ bởi biến_tệp. Nếu đọc được, hàm trả về giá trị là một số kiểu int bằng số trường đọc được. Cách thức đọc giống như scanf() đọc dữ liệu từ buffer.
Với mã %s, hàm fscanf() sẽ đọc một xâu từ tệp văn bản cho đến khi gặp kí tự khoảng trống hoặc kí tự xuống dòng (
).
Ví dụ 1: Chương trình nhập dữ liệu là một ma trận vuông cấp n từ bàn phím (với n≤100), ghi vào tệp văn bản MATRAN.TXT, theo quy cách:
a11 a12 a13 .... a1n
a21 a22 a23 .... a2n
...........................
an1 an2 an3 ... ann
- Dòng đầu ghi số nguyên n là kích thước ma trận.
- n dòng tiếp theo trong tệp, mỗi dòng ghi một hàng của ma trận, mỗi phần tử cách nhau ít nhất một kí tự khoảng trống.
Phần việc tiếp theo là:
- Đọc lại dữ liệu từ tệp vừa nhập vào một mảng;
- Hiển thị lại mảng vừa đọc ra màn hình dưới dạng một ma trận.
#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fp;
int i , j , n; float temp, x[100][100];
fp = fopen(“MATRAN.TXT”, “w”);
/* Ghi vào tệp */
printf(“
Nhap n = ”); scanf(“%d”, &n);
fprintf(fp, “%d%c”, n, ‘
’);
for (i=1; i <= n; i++)
{ clrscr(); printf(“
Nhap dong %d cua ma tran
”, i);
for (j=1; j <= n; j++)
{ printf(“ a[%d,%d] = “, i, j);
scanf(“%f”, &temp);
fprintf(fp, “%f “, temp); /* - khoảng trống */
}
fprintf(fp, “%c”, ‘
’);
}
fclose(fp);
/* Đọc từ tệp */
fp = fopen(“MATRAN.TXT”, “r”);
fscanf(fp, “%d”, &n);
for (i=0; i < n; i++)
for (j=0; j < n; j++)
{ fscanf(fp, “%f ” , &temp);
x[i][j] = temp;
}
fclose(fp);
/* Hiển thị ma trận */
clrscr();
for (i=0; i < n; i++)
{ for (j=0; j < n; j++)
printf(“%10.1f ” , x[i][j]);
printf(“%c” , ‘
’);
}
getch();
}
c. Hàm puts(s, biến_tệp): Hàm ghi xâu s vào tệp được trỏ bởi biến_tệp. Hàm sẽ: Không ghi kí tự ‘\0’ vào tệp; Cho giá trị là một số kiểu int bằng mã ASCII của kí tự cuối cùng vừa được ghi vào tệp, nếu không ghi được hàm cho giá trị EOF.
d. Hàm fgets(s, n, biến_tệp): Hàm đọc một xâu có độ dài cực đại là n (n là số kiểu int) từ tệp được trỏ bởi biến tệp rồi chứa vào vùng nhớ s. Việc đọc xâu sẽ dừng khi: hoặc đã đọc được n-1 kí tự, hoặc gặp cặp mã 13 10, hoặc dấu hiệu kết thúc tệp. Khi gặp cặp mã 13 10, kí tự có mã 10 sẽ được bổ sung vào xâu đọc được.
Kết thúc quá trình đọc xâu, kí tự ‘\0’ sẽ được bổ sung vào cuối xâu kết quả. Hàm trả về địa chỉ vùng ghi kết quả, nếu đọc lỗi hoặc con trỏ chỉ vị đã ở dấu hiệu kết thúc tệp, hàm cho giá trị NULL.
Ví dụ 2: Chương trình thực hiện các công việc sau với tệp SAMPLE.TXT:
- Ghi 5 dòng văn bản vào tệp bằng hàm fprintf();
- Bổ sung 3 dòng văn bản vào cuối tệp bằng cách ghi từng kí tự nhờ hàm putc();
- Nhập bổ sung một văn bản nhờ hàm fputs();
- Đọc từng kí tự từ tệp nhờ hàm getc();
- Đọc từng từ nhờ hàm fscanf();
- Đọc từng dòng.
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
FILE *fp ;
int i, j ;
char kitu, xau[50], tu[10], dong[100];
clrscr();
printf(“
1. Tao tep moi và ghi 5 dong van ban vao tep
”);
fp = fopen(“SAMPLE.TXT” , “w”);
strcpy(xau, “Dong van ban thu”);
for (i = 1 ; i<=5 ; i++)
fprintf(fp, “%s %d
”, xau , i);
fclose(fp);
printf(“
Xong 1. Bam ENTER de tiep tuc ...”);
getch(); clrscr();
/*******************************/
printf(“
2. Ghi bo sung 3 dong van ban vao tep
”);
fp = fopen(“SAMPLE.TXT” , “a”);
strcpy(xau, “Dong van ban bo sung thu”);
for (i = 1 ; i<=3 ; i++)
{ for (j =0; xau[j]; j++) putc(xau[j], fp);
fprintf(fp, “ %d”, i);
putc(‘
’, fp);
}
fclose(fp);
printf(“
Xong 2. Bam ENTER de tiep tuc ...”);
getch(); clrscr();
/*******************************/
printf(“
3. Bo sung mot so dong tu ban phim vao tep
”);
fp = fopen(“SAMPLE.TXT” , “a”);
for ( ; ; )
{ printf(“Go mot dong van ban / Enter de ket thuc
”); gets(dong);
if (dong[0] = = ‘\0’) break;
fputs(dong, fp);
putc(‘
’, fp);
}
fclose(fp);
printf(“
Xong 3. Bam ENTER de tiep tuc ...”);
getch(); clrscr();
/*******************************/
printf(“
4. Doc tung ki tu cua tep van ban
”);
fp = fopen(“SAMPLE.TXT” , “r”);
if (fp = = NULL)
printf(“Tep khong ton tai !!!”);
else
{ do
{ kitu = getc(fp);
putchar(c);
}
while (kitu ! = EOF);
}
fclose(fp);
printf(“
Xong 4. Bam ENTER de tiep tuc ...”);
getch(); clrscr();
/*******************************/
printf(“
5. Doc tung tu cua tep van ban
”);
fp = fopen(“SAMPLE.TXT” , “r”);
if (fp = = NULL)
printf(“Tep khong ton tai !!!”);
else
{ do
{ kitu = fscanf(fp, “%s”, tu );
if (kitu != EOF) printf(“%s ”, tu);
}
while (kitu != EOF);
}
fclose(fp);
printf(“
Xong 5. Bam ENTER de tiep tuc ...”);
getch(); clrscr();
/*******************************/
printf(“
6. Doc tung dong tep van ban
”);
fp = fopen(“SAMPLE.TXT” , “r”);
do
{ kitu = fgets(dong, 100, fp);
if ( kitu!= NULL ) printf(“%s”, dong);
}
while (kitu != NULL);
}
fclose(fp);
printf(“
Hoan tat cong viec. Bam ENTER de quay ve”);
getch(); clrscr();
}
Bạn đang đọc truyện trên: Truyen2U.Pro