DỮ LIỆU KIỂU FILE
1. CÁC KIỂU NHẬP XUẤT ĐĨA
a. Nhập/xuất chuẩn với nhập/xuất hệ thống
Có thể phân chia nhập/xuất tập tin của C/C++ thành 2 loại: nhập/xuất chuẩn (hay còn gọi là
nhập/xuất dòng) và nhập/xuất hệ thống (hay nhập/xuất mức thấp). Mỗi loại là 1 hệ thống hoàn chỉnh
để truy xuất đĩa.
 Nhập/xuất hệ thống: thực hiện việc đọc/ghi như DOS. Không có dịch vụ nhập xuất riêng cho
từng kiểu dữ liệu mà chỉ có dịch vụ đọc ghi một dãy các byte. Như vậy để ghi 1 số thực lên đĩa ta
phải dùng dịch vụ ghi 4 byte, để ghi 4 số nguyên ta dùng dịch vụ ghi 8 byte. Mỗi tệp có 1 số hiệu
(handle), làm việc với tệp thông qua số hiệu tệp.
 Nhập/xuất chuẩn: thường được sử dụng hơn vì có nhiều lệnh và sử dụng dễ dàng
- Có dịch vụ truy xuất cho từng kiểu dữ liệu, có hàm nhập xuất ký tự, chuỗi, số nguyên, số
thực, cấu trúc....
- C/C++ tự động cung cấp một vùng đệm, mỗi lần đọc ghi thì thường tiến hành trên vùng đệm
chứ không trên tệp (tức là ghi nào đầy vùng đệm mới được đẩy lên đĩa, đọc thông tin lấy trên
vùng đệm khi nào vùng đệm trống mới lấy dữ liệu từ tệp lên vùng đệm). Việc sử dụng vùng
đệm giảm số lần nhập xuất trên đĩa và nâng cao tốc độ làm việc.
 Đối tệp của hàm là biến con trỏ tệp
b. Nhập/xuất nhị phân và văn bản
Lý do tồn tại 2 kiểu này là do trước đây hệ điều hành UNIX (giai đoạn đầu tiên của ngôn ngữ C) làm
theo 1 cách còn hệ điều hành MS-DOS lại làm theo cách khác.
 Kiểu nhị phân:
- Bảo toàn dữ liệu: trong quá trình nhập xuất dữ liệu không bị biến đổi, dữ liệu ghi trên tệp theo
các byte nhị phân như trong bộ nhớ.
- Mã kết kết thúc tệp: trong khi đọc nếu gặp cuối tệp thì ta nhận được mã kết thúc tệp EOF (định
nghĩa trong stdio.h là -1) và hàm feof cho giá trị khác không. Ta chọn số -1 làm mã kết htúc tệp
bởi vì nếu chưa gặp cuối tệp thì sẽ đọc 1 byte có giá trị từ 0 đến 255. Như vậy giá trị -1 sẽ không
trùng với bất kỳ byte nào đọc được từ tệp.
 Kiểu văn bản:
- kiểu nhập/xuất văn bản chỉ khác kiểu nhị phân khi xử lý ký tự chuyển dòng LF (Line Feed - mã
10) và ký tự mã 26.

“w+b”
“a + b”
Mở file đã tồn tại để đọc theo kiểu văn bản (read only), nếu không tồn tại có lỗi
Mở file mới để ghi theo kiểu văn bản. Nếu file đã tồn tại, nội dung của nó sẽ bị loại
bỏ để thay vào đó nội dung mới
Mở 1 tệp để ghi bổ sung theo kiểu văn bản, nếu tệp chưa tồn tại thì tạo tệp mới
Mở 1 tệp để đọc/ghi theo kiểu văn bản, nếu không tồn tại sẽ báo lỗi
Mở file mới để đọc/ghi theo kiểu văn bản. Nếu file đang tồn tại nội dung của nó sẽ bị
huỷ để thay vào nội dung mới
Mở file để đọc/ghi bổ xung theo kiểu văn bản, nếu tệp chưa tồn tại thì tạo mới
Mở file để đọc theo kiểu nhị phân, nếu tệp không tồn tại sẽ có lỗi
Mở file mới để ghi theo kiểu nhị phân. Nếu file đang tồn tại, nội dung của file bị xoá
bỏ để ghi vào thông tin mới
Mở file nhị phân đang tồn tại để ghi thêm dữ liệu vào cuối file. Nếu file chưa tồn tại,
một file mới sẽ được tạo ra
Mở file nhị phân mới cho đọc/ghi. Nếu file không tồn tại thì báo lỗi
mở 1 tệp mới để đọc/ghi theo kiểu nhị phân, nếu tệp đã tồn tại thì bị xoá
Mở file nhị phân đang tồn tại và ghi thêm dữ liệu vào cuối file. Nếu file chưa tồn tại
thì một file mới sẽ được tạo ra
Chú ý: Trong các kiểu đọc/ghi, cần làm sạch vùng đệm trước khi chuyển từ đọc sang ghi hoặc từ ghi
sang đọc. Có thể tên tệp có định đường dẫn, “w” chuỗi chứ không phải là ký tự.
Ví dụ:
FILE *fp;
fp=fopen(“tep_mo.txt”,”w”);
Hàm fclose: đóng tệp
int fclose(FILE *fp);
Hàm dùng để đóng tệp,fd là con trỏ tương ứng với tệp cần đóng.
Nội dung đóng tệp:Đẩy dữ liệu còn trong vùng đệm lên đĩa (khi đang ghi),xoá vùng đệm (khi đang
đọc)
Giải phóng biến fp để dùng cho tệp khác. Nếu thành công hàm cho giá trị 0, ngược lại hàm cho EOF.

fprintf(fp,”%s”,name);
if(ferror(fp))
{ perror(“loi ghi tep:”);
fclose(fp);
exit(); }
} while (strlen(name)>1);
fclose(fp);
}
Kết quả in ra dòng thông báo: Loi ghi tep: Bad data
 Hàm feof: Kiểm tra cuối tệp
int feof(FILE *fp);
Dùng để kiểm tra cuối tệp, hàm cho giá trị khác không gặp cuối tệp khi đọc, ngược lại cho giá trị 0
 Hàm unlink: xoá tệp
int unlink(const char *ten_tep);
Hàm dùng để xoá tệp tin trên đĩa, nếu thành công hàm cho giá trị = 0, ngược lại cho EOF
b. Nhập/xuất ký tự
Các hàm putc và fputc
int putc(int ch,FILE *fp);
int fputc(int ch,FILE *fp);
Ghi ký tự lên tệp, thành công cho mã ký tự được ghi, ngược lại cho EOF.Hai hàm có ý nghĩa như
nhau.
Ví dụ: ghi từng ký tự vào tập tin
#include “stdio.h”
void main(void)
{
FILE *fp; char ch;
fp=fopen(“tep.txt”,”w”);
while ((ch=getche()) != ‘\r’)
putc(ch,fp);
fclose(fp);

printf(“\n tep %s chua co”,tep1);
getch();
return;
}
f2=fopen(tep2,”wb”);
while ((ch=fgetc(f1)) != EOF)
fputc(ch,f2);
fclose(f1);
fclose(f2);
}
c. Các hàm nhập/xuất theo kiểu văn bản
Hàm fprintf: ghi dữ liệu theo khuôn dạng
int fprintf(FILE *fp, const char *dk,....);
Giá trị các đối được ghi lên tệp fp theo khuôn dạng xác định trong chuỗi điều khiển dk. Nếu thành
công hàm trả về giá trị nguyên bằng số byte ghi lên tệp, khi có lỗi trả về EOF. Hàm làm việc giống
như printf.
Ví dụ: đưa dữ liệu và tệp
#include <stdio.h>
int main(void)
{
FILE *fp;
Trịnh Vân Anh 89
int i = 100; char c = 'C'; float f = 1.234;
/* open a file for update */
fp = fopen("dl.dat", "w+");
/* write some data to the file */
fprintf(fp, "%d %c %f", i, c, f);
/* close the file */
fclose(fp);
return 0;

fclose(fp);
getch();
}
Cách 2:
#include “stdio.h”
void main(void)
{
FILE *fp; int c;
fp=fopen(“slieu.dat”,”r”);
while(1)
Trịnh Vân Anh 90
{
fscanf(fp,”%d”,&c);
if(feof(fp)) break;
printf(“\n %d”,c);
}
fclose(fp);
getch();
}
Ví dụ: ma trận nghịch đảo
Cho tệp : mtndao.dat có dạng:
- Dòng đầu tiên là số tự nhiên n (cấp của ma trận vuông A)
- n dòng tiếp theo mỗi dòng ghi n số thực phân biệt nhau bởi dấu cách là A[i][j]
Hãy viết chương trình tính ma trận nghịch đảo của ma trận A và viết tiếp vào file trên.
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
FILE *f;
int Chuyen(float **, int ,int);
void Mtdao(float **,int );

for(k=0;k<2*n;k++)
A[j][k]=A[j][k]-A[i][k]*hs;
}
}
for(i=0;i<n;i++){
hs=A[i][i];
for(k=0;k<2*n;k++)
A[i][k]=A[i][k]/hs;
}
for(i=n-1;i>0;i--) {
for(j=i-1;j>=0;j--){
hs=A[j][i]/A[i][i];
for(k=0;k<2*n;k++)
A[j][k]=A[j][k]-A[i][k]*hs;
}
}
for(i=0;i<n;i++){
for(j=0;j<n;j++)
fprintf(f,"%6.1f",A[i][j+n]);
fprintf(f,"\n");
}
}
void main() {
float **A,**B,t;
int i,j,k,n;
clrscr();
f=fopen("mtndao.dat","r");
fscanf(f,"%d",&n);
A=(float **)malloc(n*sizeof(float));
for(i=0;i<n;i++)

lên tệp, có lỗi hàm trả về EOF.
Ví dụ: ghi các dòng lên tệp
#include “stdio.h”
#include “conio.h”
void main(void)
{
FILE *fp;
int i=0;
char d[256];
fp=fopen(“vanban.dat”,”w”);
clrscr();
while(1)
{
++i;
printf(“\n Dong thu %d(go Enter de thoat):”,i);
gets(d);
if(d[0]==’\0’) break;
if(i>1) fputc(10,fd);
fputs(d,fp);
}
fclose(fp);
getch();
}
Hàm fgets: đọc 1 dãy ký tự từ tệp
char fgets( char *s,int n,FILE *fp); (n là độ dài cực đại của xâu đọc)
Đọc 1 dãy ký tự từ tệp fp chứa các vùng nhớ s, thành công hàm trả lại địa chỉ vùng nhận kết quả, khi
có lỗi hoặc gặp cuối tệp hàm cho giá trị NULL (xâu kết quả sẽ được bổ sung thêm dấu hiệu kết thúc
xâu ‘\0’.
Ví dụ: đọc các dòng ký tự từ tệp và viết ra màn hình
#include “stdio.h”

/* seek to the start of the file */
fseek(stream, 0, SEEK_SET);
/* read a string from the file */
fgets(msg, strlen(string)+1, stream);
/* display the string */
printf("%s", msg);
fclose(stream);
return 0;
}
Tệp văn bản và các thiết bị chuẩn
Ngôn ngữ C định nghĩa các tệp và con trỏ tệp ứng với các thiết bị chuẩn:
Tệp con trỏ thiết bị
in
out
err
prn
stdin
stdout
stderr
stdprn
thiết bị vào chuẩn (bàn phím)
thiết bị ra chuẩn (màn hình)
thiết bị lỗi chuẩn (màn hình)
thiết bị in chuẩn (máy in)
Khi chương trình C bắt đầu làm việc thì các tệp này tự động mở, vì vậy có thể dùng các con trỏ trên
để nhập/xuất trên các thiết bị chuẩn.
Ví dụ:
#include “stdio.h”
#include “conio.h”
void main(void)

fclose(fp);
clrscr();
fp=fopen(“nguyen.dat”,”rb”);
while(i=getw(fp) !=EOF)
printf(“\n %d”,i);
fclose(fp);
getch();
}
Ví dụ:
#include <stdio.h>
#include <stdlib.h>
#define FNAME "vban.txt"
int main(void)
{
FILE *fp;
int word;
/* place the word in a file */
fp = fopen(FNAME, "wb");
if (fp == NULL)
{
printf("Error opening file %s\n", FNAME);
exit(1);
Trịnh Vân Anh 95
}
word = 94;
putw(word,fp);
if (ferror(fp))
printf("Error writing to file\n");
else
printf("Successful write\n");

{
int i;
char ch;
};
int main(void)
{
FILE *fp;
struct mystruct s;
if ((fp = fopen("thu.txt", "wb")) == NULL) /* open file thu.txt */
{
fprintf(stderr, "Cannot open output file.\n");
Trịnh Vân Anh 96