Tải bản đầy đủ (.pdf) (32 trang)

Bài giảng tin học đại cương C++ (chương 3)

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (474.67 KB, 32 trang )

CHNG3:NHPVÀXUTDLIU

§1.KHÁINIMCHUNG
1.Kháinim: Trcđâychúngtađãxétvicnhpdliutbànphím.
Trongnhiutrnghpthct,đthunli,chúngtaphinhpdliu
t
cáctptintrênđĩa.CáchàmthvincaCchophéptruycptptinvà
chialà2cpkhácnhau:
cáchàmcp1làcáchàmcpthpnht,truycptrc
tipđncác
tptintrênđĩa.Ckhôngcungcpvùngnhđmchocáchàmnày
cáchàmcp2làcáchàmtruyxuttptincaohn,dochúngđcC
cungcpvùngnhđm.
Đi
vicáchàmcp1,tptinđcxemlàkhicácbyteliêntcdođó
khimuntruycpmutincththìphitínhtoánđachcamutinvà
nhvycôngvi
cvtvhn.Ngoàiraphicungcpvùngnhđmcho
kiuđcghinày.Đivicáchàmcphaicôngvicnhnhànghndo:
trìnhbiêndchtđngcungcpvùngkíc
đmchochúng
cóth truy xut các mutinmàkhônggpkhókhănnhvicác
hàmcp1
TrongC,cácthôngtincnthitchocáchàmxutnhpcp2đcđt
trongt
ptinstdio.hcòncácthôngtinvhàmnhpxutcp1thìtrong
tptinio.h

2.Streamvàcáctptin:Taphiphânbithaithutnglàstreamvàfile.
H thng xut nh
p ca C cung cp mt không gian tng tng gia


ngilptrìnhvàcácthitbđcdùng.Cptrunggiantngtngnày
gilàstreamvàthitbcthlàtp
tin.
a.Cácstreams:Trongmáytínhtadùng2loistream:vănbnvành
phân.Mtstreamvănbnlàmtlotkít đctchcthànhdòngmà
midòngđcktthúcbngkítxungdòngnewline(“\n”).Khighi,mt
kítchuyndòngLF(mã10)đcchuynthành2kítCR(mã13)vàLF.
Khiđc2kítliêntipCRvàLFtrêntptinchchotamtkí
tLF.Mt
streamnhphânlàmtlotcácbyte.
b. Các tp tin: Trong C, mt tp tin là mt khái nim logic mà h
thng có th áp dng cho mi th t các tp
tin trênđĩa chođn các
terminal. Khibtđuthchinchngtrình,máytínhm3streamvăn
bnđãđcđnhnghĩatrclàstdin,stdoutvàstderr.Đivihuhtcác
hthng,các
thitbnàylàconsole.
§2.NHPXUTCHUN

27
1.Nhpxutkít,chuikít,đnhdngvàbnghi: Nhp xutcp2
(nhpxutchun)cungcp4cáchđcvàghidliukhácnhau(ngcli
nhpxutcâp1chdùng1trong4cáchnày).
 Trchtdliucóthđcghimilnmtkít,tngtnhcách
làmviccaputchar()vàgetche()đđcdliut
bànphímvàhinthlên
mànhình.
 Thhai,dliucóthnhpxuttheochuibngcácdùngcáchàm
gets()vàputs()
 Thba,dliucóthđcnhpvàxuttheokhuôndngb

ngcác
hàmfprintf()vàfscanf()
 Tht,dliuđcđcvàghitheokhicóchiudàicđnhthng
dùnglutrmnghaycutrúcbngcáchàmfread()vàfwrite().Tómli:
Cáchàmdùng
chungchohaikiunhphânvàvănbn
fopen:dùngmtptin
fclose:đóngtptin
fclose:đóngttccáctptin
fflush:dùnglàmschvùngđmcatptin
flushall:
dùnglàmschvùngđmcattctptin
ferror:chobitcóli(kháckhông)haykhôngcóli(bng0)
 perror:thongbáolitrênmànhình
 foef:chobitcuitptinhaycha
 unlinkvàremove:dùngđloitptintrênđĩa
 fseek:dichuyncontrđnvtríbtkìtrêntptin
 ftell:chobitvtríhinticacontr

Cáchàmnhpxutkít
putcvàfputc:nhpkítvàotptin
getcvàfgetc:đckítttptin
 fprintf:dùngghidliuđnhdnglêntptin
 fscanf:dùngđc
dliuđnhdngttptin
 fputs:dùngghichuilêntptin
 fgets:dùngđcchuittptin
Cáchàmdùngchokiuxutnhpnhphân
 putw:dùngghimts
nguyênhaibytelêntptin

 gets:dùngđcmtsnguyênhaibytettptin
 fwrite:dùngghimtmutinlêntptin
 fread:dùngđcmtmutinttptin

2.D
ngvănbnvàdngnhphân: Cáchkhácđphânloicác thao tác
nhpxuttptinlànóđcmtheokiuvănbnhaynhphân.Đimkhác

28
bitgiahailoinàylàkítnewlinevàendofline.Đimthhaiđphân
bithaikiutptinlàlàcáchlutrcácsvàođĩa.Đividngvănbn
thìcács
đclutrthànhchuicáckítcòndngnhphânthìcács
đclunhtrongbnh,nghĩalàdùnghaibytechomtsnguyênvà4
bytechomtsfloat.

3.Nhpxut
chun:Chngtrìnhdùngcáchàmnhpxutcp2thng
dhiuhnnênchúngtasnghiêncutrc.
a.Nhpxutkít:Đnhpkítvàotptintadùnghàm
putc()hay
fputc().Đđckítttptintadùnghàmgetc()hayfgetc().Chngtrình
vídnàylàtolpcáckítbngcáchgõvàobànphímmilnmtkít
vàghivàomt
tptintrênđĩa.Chngtrìnhdùnghàmfopen()đmmt
tp tin, dùng hàm putc()đghi lên tp tin,dùng kít enterđkt thúc
chngtrình.

Chngtrình31
#include<stdio.h>

#include<conio.h>
voidmain()
{
FILE*fp;

charch;
printf(“Nhapcackitu:“);
fp=fopen(textfile,w);
while((ch=getche())!=\r)
putc(ch,fp);
fclose(fp);
}
b.Mmttptin:Trckhighimttptinlênđĩataphimtptin
đó
đã.Đmtptin,trchttaphikhaibáomtcontrchtiFILE.
FILElàmtstructurechađngcácthôngtinvcutrúccatptinvíd
nhkíchthc,v
trícabđmdliuhinhành.CutrúcFILEđc
khaibáotrongstdio.hnêntacnincludetptinnày.Ngoàirastdio.hcòn
xácđnhcáctênvàcácbinkhácđcdùngtrongchngtrìnhhngđn

cáctptin.Dovytrongchngtrìnhtacócâulnh:
FILE*fp;
Sauđótamtptinbnglnh:
 fopen(“textfile”,”w”);
Khi vit nh vy s làm cho h điu hành bit là m m
t tp tin tên là
textfiletrongthmchinhànhđvitlêntptinđó(nh“w”).Tacóth

29

chotênđng dnđyđnumunm tptinthmcbt kì. Hàm
fopen()trvmtcontrchđncutrúcFILEchotptinvàcontrnày
đcctgitrongbinfp.
Chui“w”đcgilàkiu,nócónghĩalàghi
lêntptin.Cáckiumtptinlà:
 “r”,”rt”mđđc,tptinphicótrênđĩa
 “w”,”wt”mđghi,nutrênđĩađãcótptinthìnidungbghi
đè,nuchacóthìtptinđctolp
 “a”,”at”mđnithêm,thôngtinđcghivàocuitptincũnu
đãcótptinhaytomitptin
 “r+”,’’r+t”mđvađcvàghi,tptinphicótrênđĩa
 “rb”mmttptinđđctheokiunhphân.Tptinphicósn
trênđĩa
 “r+b”mmttptinđđctheokiunhphân.Tptinphicósn
trênđĩa
 “w+”,”w+t”mđvađcvàghi,nidungtptinđãcótrênđĩas
bghiđèlên
 “wb”mđghitheokiunhphân,nutrênđĩađãcótptinthì
nidungbghiđè,nuchacóthìtptinđctolp
 “a+”,”a+t” m đ đc và ni thêm, nu tp tin cha có thì nó s
đctora
 “ab”mđđcvànithêmtheokiunhphân,nutptinchacó
thìnósđctora
 c.Ghilêntptin:Khitptinđãđcm,tacóthghilêntptin
t
ngkítmtbngcáchdùnghàm:
putc(ch,fp)
Hàmputc()tngtcáchàmputch()vàputchar().Hàmputc()ghilêntp
tincócutrúcFILEđcnđnhbibinfpnhnđckhimtptin.
Tin

trìnhghiđctinhànhchođnkhinhnenter.
 d.Đóngtptin:Khikhôngđcghinatacnđóngtptin.Câulnh
đóngtptinlà:
 fclose(fp);
Tabáochohthngbit
làcnđóngtptinchbifp.
 e.Đctptin:Nutacóthghilêntptinthìtacũngcóthđct
tptin.Tacóvídsau:
Chngtrình32
#include<stdio.h>
#include<conio.h>
main()
{
FILE*fp;

30
intch;
clrscr();
fp=fopen(textfile,r);
while((ch=getc(fp))!=EOF)
printf(%c,ch);
fclose(fp);
getch();
}

 f.Ktthúctptin:Skhácnhâuchyugiachngtrìnhđcvà
ghilàchngtrìnhđcphiphânbi
tđcđâulàkítEOF.Nókhông
philàmtkítàmlàmtsnguyêndohđiuhànhgiti.Khihttp
tintagpmãktthúctptinEOF(đnh

nghĩatrongstdio.hbng1)và
hàmfoef()chotrkháckhông.Ngitachn1làmmãktthúcvìnucha
gpcuitptinthìsđcđcmtbytemàmãsnmtrong
khong0255
.Nhvygiátr1khôngtrùngvibtkìkítnàonàođcđcttptin.
Trongkhichngtrìnhđangđcvàhinthcáckítthìnótìmkimm
giá
tr1hayEOF.Khithygiátrnày,chngtrìnhsktthúc.Chúngta
dùngmtbinnguyênctgimtkítđcđc,dođótacóthhiudu
EOFnhlàmttrnguyêncó
trlà1.Nudùngmtbinkiuchar,chúg
tacóthdùngttccáckítt0 255đólàthp8.Dođónudùng
binnguyên,tabođmrngchcó
mtgiátr16bitlà1,đólàduEOF.
 g.Sphinphckhimtptin:Haichngtrìnhtatrìnhbàytrêncó
mtlitimn.Nutptinđãđcchđnhkhông
mđcthìchng
trình không chy. Li này có th là do tp tin cha có (khiđc) hayđĩa
khôngcònđch(khighi).Dođóvnđlàphikimtraxemtptincóm
đchaykhông,
nutptinkhôngmđcthìhàmfopen()trvtr0(0là
NULLtrongstdio.h).KhinàyCcoiđâykhôngphilàđachhpl.Nh
vytavitlichngtrìnhtrênnhsau:

Chng
trình33
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
voidmain()

{
FILE*fp;
intch;
clrscr();
if((fp=fopen(file,r))==NULL)

31
{
 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
while((ch=getc(fp))!=EOF)
printf(%c,ch);
fclose(fp);
}

 h.Đmskít:Khnăngđcvàghitptintrêncscáckítcho
phéptrinkhaimt
sngdng.Chúngtaxemxétchngtrìnhđmskí
tsau:

Chngtrình34
#include<stdio.h>
#include<conio.h>
main(intargc,char*argv)
{
FILE*fp;
charstring[8];
intcount=0;

clrscr();
if(argc!=2)
{
 printf(Formatc:\<tenchuongtrinh>
<tentaptin>);
 getch();
 exit(1);
}
if((fp=fopen(argv[1],r))==NULL)
{
 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
while(getc(fp)!=EOF)
count++;
fclose(fp);
printf(Taptin%sco%dkitu,argv[1],count);
getch();

32
}

i.Đmst:Tacóthsachngtrìnhtrênthànhchngtrìnhđm
st.

Chngtrình35
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

main(intargc,char*argv[])
{
FILE*fp;
charch,string[81];
intcount=0;
int
white=1;
clrscr();
if(argc!=2)
{
 printf(Formatc:\<Tenchuongtrinh><tentaptin>\n);
 getch();
 exit(1);
}
if((fp=fopen(argv[1],r))==NULL)
{
 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
while((ch=getc(fp))!=EOF)
switch(ch)
 {
case:/*nucódutr
ng,dòngmihaytab*/
case\t:
case\n:white++;
  break;
default:if(white)
  {

  white=0;
  count++;
  }

33
}
fclose(fp);
printf(Taptin%sco%dtu,argv[1],count);
getch();
return0;
}

k.Vàorachui:Đchayghichuitrêntptincũngtngtnhđc
hayghitngkítriêngl.Taxétm
tchngtrìnhghichui

Chngtrình36
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<conio.h>
voidmain()
{
FILE*fp;
charstring[8];
clrscr();
if((fp=fopen(a.txt,w))==NULL)
{
 printf(Khongmoduoctaptin\n);
 getch();

 exit(1);

}
while(strlen(gets(string))>0)
{
 fputs(string,fp);
 fputs(\n,fp);
}
fclose(fp);
}
Trongchngtrìnhmichuiktthúcbngcáchgõentervàktthúc
chngtrìnhbngcáchgõenterđudòngmi.Dofputs()khôngtđ
ng
thêmvàomãktthúcđchuyndòngminêntaphithêmvàotptinmã
này.Chngtrìnhđcmtchuittptin:

Chngtrình37:
#include<stdio.h>

34
#include<string.h>
#include<stdlib.h>
#include<conio.h>
voidmain()
{
FILE*fp;
charstring[81];
clrscr();
if((fp=fopen(a.txt,r))==NULL)
{

 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
while(fgets(string,81,fp)!=NULL)
printf(%s,string);
fclose(fp);
getch();
}

 Hàmfgets()nhn
3đis:đachniđtchui,chiudàitiđaca
chui,vàcontrchtitptin.
l.Vnđsangdòngmi:Trongchngtrìnhđmkíttathyskít

đmđc bao gi cũng nh hns byte cótrong tp tinnàynhnđc
bnglnhdircaDOS.Khitaghimttptinvănbnvàođĩa,Ctđng
ghivàođĩachai
mãCRvàLFkhigpmãsangdòngmi“\n”.Ngcli
khiđctptintđĩa,cácmãCRvàLFđcthpthànhmãsangdòng
mi.Chngtrìnhsauminhhoathêmvkĩthut
vàorachui,nidung
tngtlnhtypecaDOS

Chngtrình38
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main(intargc,char*argv[])
{

FILE*fp;
charstring[81];
clrscr();
if(argc!=2)

35
{
 printf(Formatc:\<tenchuongtrinh><tentaptin>);
 getch();
 exit(1);
}
if((fp=fopen(argv[1],r))==NULL)
{
 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
while(fgets(string,81,fp)!=NULL)
printf(%s,string);
fclose(fp);
getch();
return0;
}

m.Cáctp
tinchunvàmáyin:Trênđâytađãnóiđncáchthctip
nhnmtcontrthamchiudnmttptintrênđĩacahàmfopen(),C
đnhnghĩalitêchunc
a5tptinchunnhsau:


Tên Thitb
in Thitbvàochun(bànphím)
out Thitbrachun(mànhình)
err Thitblichun(mànhình)
aux Thitbphtrchun(cngnitip)
prn Thitbinchun(máyin)

Tacóthdùngcáctênnàyđtruycpđncácthitb.Chngtrìnhsau
dùnghàmfgets(0vàfputs()đinnidungmttptinramáyin

Chngtrình39
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main(intargc,char
*argv[])
{
FILE*fp1,*fp2;

36
charstring[81];
clrscr();
if(argc!=2)
{
 printf(Formatc:\<tenchuongtrinh><tentaptin>);
 getch();
 exit(1);
}
if((fp1=fopen(argv[1],r))==NULL)
{

 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}
if((fp2=fopen(prn,w))==NULL)
{
 printf(Khong
moduocmayin\n);
 getch();
 exit(1);
}
while(fgets(string,81,fp1)!=NULL)
fputs(string,fp2);
fclose(fp1);
fclose(fp2);
getch();
return0;
}
Trongchngtrìnhtrênmáyinđccoilàtptincótênlàprn
n.Nhpxutđnhdng:Trcđây
tađãđcpđnnhpxutkít.
Nhngscóđnhdngcũngcóthghilênđĩanhcáckít.Taxétchng
trìnhsau:

Chngtrình310:
#include<stdio.h>
#include<conio.h>
main()
{


FILE*p;
inti,n;
floatx[4],y[4];

37
clrscr();
p=fopen(test.txt,w);
printf(Chosocapsocannhapn=);
scanf(%d,&n);
fprintf(p,%d\n,n);
printf(Chocacgiatrixvay\n);
for(i=0;i<n;i++)
{
 scanf(%f%f,&x[i],&y[i]);
 fprintf(p,%f%f\n,x[i],y[i]);
}
fclose(p);
}

#include<stdio.h>
#include<conio.h>
#include<string.h>
voidmain()
{
FILE*fp;
charname[40];
intcode;
floatheight;
intn,i;
clrscr();

fp=fopen(b.txt,w);
printf(Chosonguoicannhap:);
scanf(%d,&n);
for(i=0;i<n;i++)
{
 printf(Nhapten,maso
vachieucao:);
 scanf(%s%d%f,name,&code,&height);
 fprintf(fp,%s%d%f,name,code,height);
}
fclose(fp);
}

Chngtrình311
#include<stdio.h>
#include<conio.h>

38
voidmain()
{
FILE*p;
inti,n;
floatx[4],y[4];
clrscr();
p=fopen(test.txt,r);
fscanf(p,%d,&n);
for(i=0;i<n;i++)
{
 fscanf(p,%f%f,&x[i],&y[i]);
 printf(\n%.3f%8.3f,x[i],y[i]);

}
fclose(p);
getch();
}


#include<stdio.h>
#include<conio.h>
#include<string.h>
voidmain()
{
FILE*fp;
char
name[2];
intcode,n,i;
floatheight;
clrscr();
fp=fopen(b.txt,r);
fscanf(fp,%d,&n);
for(i=0;i<n;i++)
{
 fscanf(fp,%s%d%f\n,name,&code,&height);
 printf(%s%3d%8.3f\n,name,code,height);
}
fclose(fp);
getch();
}

§3.KIUNHPHÂNVÀKIUVĂNBN


39
1.Mãsangdòngtheohaikiu:Trongdngvănbn,mtkítchuyndòng
tngngvi2mãCRvàLFkhighivàotptintrênđĩa.Ngclikhiđc,
thpCR/LF
trênđĩatngngvikítsangdòngmi.Tuynhiênnu
mtptintheokiunhphânthì2mãCRvàLFlàphânbitnhau.Tđós
kítmàchngtrìnhđmđckhácvi
trnghpmtptinbngkiu
vănbn.
Chngtrình312:Chngtrìnhđmskítbngcáchmtptintheo
kiunhphân
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
voidmain(intargc,char*argv[])

{
FILE*fp;
charstring[81];
intcount=0;
clrscr();
if(argc!=2)
{
 printf(Formatc:\<tenchuongtrinh><tentaptin>);
 getch();
 exit(1);
}
if((fp=fopen(argv[1],rb))==NULL)
{
 printf(Khongmoduoctaptin\n);

 getch();
 exit(1);
}
while(getc(fp)!=EOF)
count++;

fclose(fp);
printf(Taptin%sco%dkitu,argv[1],count);
getch();
}

2.Mãktthúctptintheo2kiu:Skhácbitthhaikhimtptintheo
kiunhphânhaykiukítcònlàch
nhìnnhnkítktthúctptin.
Nóichungcáctptinđuđcqunlítheokíchthccanóvàkhiđc
ht s byteđã ch ra trong kích thc tp tin thì du hi
u EOF s đc

40
thôngbáo,duhiuđóngvimã1Ah(hay26h10).Khiđóngtptin
vănbn,mã1Asđctđngchènvàocuitptinđlàmduhiukt
thúctptin(tngđng
mãCtrlZ).Dovynubngcáhnàođótachèn
mã1Avàomtvtrígiatptin,thìkhimtptintheokiuvănbnvà
đcđnmãnàychngtrìnhđcs
ngnghnvìchínhlúcđóhàmđc
phátsinhgiátr1đbáochochngtrìnhlàđãktthúctptin.Nuđã
lusvàotptintheodngnhphânthìkhimtptinc
nphimtheo
dngnhphân.Nukhôngscómtsnàođólà1Avàvicđctptin

theokiuvănbnsktthúcngoàiýđnh.Tngt,vitptin
mtheo
kiunhphânmã10khôngđcnhìnnhnlàmãsangdòngmivìkhông
đcxemlàtngngvithpCR/LFna.
3.Chngtrìnhminhho:Chúngtaxétmtchngtrình
dùngkiunh
phânđkhosáttptin

Chngtrình313
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#definelength 10
#definetrue 0
#definefalse1
voidmain(intagrc,char*argv[])
{
FILE*fp;
intch;
intj,noteof;
unsignedcharstring[length+1];
clrscr();
if(agrc!=2)
{
 printf(Dangc:\<tenchuongtrinh><tentaptin>);
 getch();
 exit(1);
}
if((fp=fopen(argv[1],rb))==NULL)
{

 printf(Khongmoduoctaptin\n);
 getch();
 exit(1);
}

41
noteof=true;
do
{
 for(j=0;j<length;j++)
{
 if((ch=getc(fp))==EOF)
 noteof=false;
 printf(%3x,ch);
 if(ch>31)
 *(string+j)=ch;/*kituinduoc*/
 else
 *(string+j)=.;/*kitukhonginduoc*/
}
 *(string+j)=\0;
 printf(%s\n,string);
}
while(noteof==true);
fclose(fp);
getch();
}


4.Cáchàmfreadvàfwrite:
a.Ghicutrúcbngfwrite:Taxétmtchngtrìnhghicutrúclên

đĩa.Trongchngtrìnhtadùnghàmfread().Hàmnàycó4đis:đach
đghicu
trúc,kíchthccacutrúc,scutrúcsghivàcontrchti
tptin.

Chngtrình314
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
voidmain()
{
charchso[10];
FILE*fp;
structnguoi{
  charten[30];
  intso;
  floatcao;
}nv;

42
clrscr();
if((fp=fopen(nhanvien.rec,wb))==NULL)
{
 printf(Khongmoduocfile\n);
 getch();
 exit(1);
}
do
{
 printf(\nChoten:);

 gets(nv.ten);
 printf(Chomaso:);
 gets(chso);
 nv.so=atoi(chso);
 printf(Chochieucao:);
 gets(chso);
 nv.cao=atof(chso);
 fwrite(&nv,sizeof(nv),1,fp);

printf(Tieptuckhongy/n?);
}
while(getch()==y);
fclose(fp);
}
b.Đccutrúcbngfread:Tadùnghàmfread()đđccutrúcghi
trênmttptin.Cácđiscafread()cũnggingnhfwrite().Hàm
fread()
trvscanhngmcđãđcđcti.Nutptinđãktthúcnóchotr
âm.Taxétvídsau:

Chngtrình315
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
voidmain()
{
FILE*fp;
structnguoi{
  charten[30];
  intso;

  floatcao;
}nv;

43
clrscr();
if((fp=fopen(nhanvien.rec,rb))==NULL)
{
 printf(Khongmoduocfile\n);
 getch();
 exit(1);
}
do
{
 printf(\nTen:%s\n,nv.ten);
 printf(Maso:%03d\n,nv.so);
 printf(Chieucao:%.2f\n,nv.cao);

}
while(fread(&nv,sizeof(nv),1,fp)==1);
fclose(fp);
getch();
}

c.Ghimng
bngfwrite(:Hàmfwrite()cũngdùngghimnglênđĩa.
Taxétvídsau:

Chngtrình316
#include<stdio.h>
#include<conio.h>

#include<stdlib.h>
inttable[10]={1,2,3,4,5,6,7,8,9,10};
voidmain()
{

FILE*fp;
clrscr();
if((fp=fopen(table.rec,wb))==NULL)
{
 printf(Khongmo
duocfile\n);
 getch();
 exit(1);
}
fwrite(table,sizeof(table),1,fp);
fclose(fp);

44
}

d.Đcmngbngfread():Saukhighimnglênđĩatacóthđccác
phntcamngtđĩabnghàmfread().

Chngtrình317
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

voidmain()
{


FILE
*fp;
inta[10];
inti;
clrscr();
if((fp=fopen(table.rec,rb))==NULL)
{
 printf(Khongmoduocfile\n);
 getch();
 exit(1);
}
for(i=0;i<10;i++)
{
 fread(a,sizeof(a),10,fp);
 printf(\%3d,a[i]);
}
fclose(fp);
getch();
}

e.Vídvcsdliu:
Taxétchngtrìnhqunlínhânviênvicác
tptintrênđĩanhsau

Chngtrình318
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#definetrue1


45
structnguoi{
 charten[30];
 intso;
 floatcao;
 };
structnguoinv[10];
intn=0;
charnumstr[10];

voidmain()
{
charch;
voidnewname(void);
voidlistall(void);
voidwfile(void);
voidrfile(void);
clrscr();
while(true)
{
 printf(\nGoedenhapnhanvienmoi\n);

printf(Goldelietkenhanvien\n);
 printf(Gowdeghilendia\n);
 printf(Gordedocfiletudia\n);
 printf(Goqdeketthucchuongtrinh\n\n);
 ch=getch();
 switch(ch)
{

 casee:newname();
  break;
 casel:listall();
  break;
 casew:wfile();
  break;
 caser:rfile();
  break;
 caseq:exit(1);
 default:printf(Nhapsaikitu,chonlai!);
}
}
}

46

voidnewname()
{
charnumstr[81];
printf(\nBanghiso%d\nChoten:,n+1);
gets(nv[n].ten);
printf(Chomasoco3chuso:);
gets(numstr);
nv[n].so=atoi(numstr);
printf(Chochieucao:);
gets(numstr);
nv[n++].cao=atof(numstr);
}
voidlistall()
{

intj;
if(n<1)
printf(
Danhsachrong\n);
for(j=0;j<n;j++)
{
 printf(\nBanghiso%d\n,j+1);
 printf(Ten:%s\n,nv[j].ten);
 printf(Manhanvien:%3d\n,nv[j].so);
 printf(Chieucao:%4.2f\n,nv[j].cao);
}
}

voidwfile()
{
FILE*fp;
if(n<1)
{
 printf(Danhsachrong,
khongghi\n);
 getch();
 exit(1);
}
if((fp=fopen(nv.rec,wb))==NULL)
{
 printf(Khongmoduocfile\n);
 getch();

47
 exit(1);

}
else
{
 fwrite(nv,sizeof(nv[0]),n,fp);
 fclose(fp);
 printf(Daghi%3dbanghilendia\n,n);
}
}

voidrfile()
{
FILE*fp;
if((fp=fopen(nv.rec,rb))==NULL)
{
 printf(Khongmoduocfile\n);
 getch();
 exit(1);
}
else
{
 while(fread(&nv[n],sizeof(nv[n]),1,fp)==1)

{
 clrscr();
 printf(Banghiso%3d\n,n+1);
 printf(Tennhanvien:%s\n,nv[n].ten);
 printf(Manhanvien:%3d\n,nv[n].so);
 printf(Chieucaocuanhanvien:%.2f\n,nv[n].cao);
 getch();
 n++;

}
 fclose(fp);
 printf(Xong!Tongsobanghidadoc%3d\n,n);
}
}

§4.CÁCFILENGUNHIÊN
 Cáctptinđcptrcđâylàcáctptintunt,nghĩalàtptinmà
khiđchayghiđtheochđtunttđuđncuitptin.Đ
ivitp
tintunttakhôngthđchayghimtcáchtrctiptimtvtríbtkì

48
trêntptin.Tptinngunhiênchophéptatruycpngunhiênvàonhng
vtrícnthittrêntptin.Cáchàmdùngkhitruycptptinngunhiênlà:
 rewind():dichuyn
contrtptinvđutptin
Cúpháp:voidrewind(FILE*fp);
 fseek():dichuyncontrtptinvvtrímongmun
Cúpháp:intfseek(FILE*fp,longsb,intxp)
 fpcontrtptin
 sb
sbytecndichuyn
xpvtríxutphátmàvicdchchuynđcbtđutđó.xpcóth
cócácgiátrsau:
xp=SEEK_SEThay0:xutpáhttđutptin
xp=SEEK_CUR
hay1:xutpháttvtrícontrhinti
xp=SEEK_ENDhay2:xutpáhttcuitptin
 ftell():chobitvtríhinticacontrtptin

Taxétchngtrình
vídsau:

Chngtrình319
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
voidmain()
{
structnguoi{
  charten[30];
  intso;
  floatcao;
}nv;
intrecno;
FILE*fp;
longintoffset;
clrscr();
if((fp=fopen(nhanvien.rec,r))==NULL)
{
 printf(Khong
moduocfile\n);
 getch();
 exit(1);
}
printf(Banmuondocbanghithumay:);
scanf(%d,&recno);
recno;

49

offset=recno*sizeof(nv);
if(fseek(fp,offset,0)!=0)
{
 printf(Khongdichuyenduoccontrofiletoido\n);
 getch();
 exit(1);
}
fread(&nv,sizeof(nv),1,fp);
printf(Ten:%s\n,nv.ten);
printf(Manhanvien:%3d\n,nv.so);
printf(Chieucao:%4.2f\n,nv.cao);
getch();
}

§5.LIVÀORA
 Nói
chung,khimtptinthànhcôngtacóthghilênnó.Tuynhiên,
nhiutrnghpkhôngmđctptinnhngtakhôngbitlidođâu.
Đxácđnhlõitadùnghàmferror().Hàmnàycóđis
làcontrtptin.
Hàmscógiátrkhôngnukhôngcóligì.Ngclihàmchogiátrkhác
không.Tacũngcóthdùnghàmperror()đchnidungli.

Chngtrình320
#include<stdio.h>
#include<conio.h>

#include<string.h>
#include<stdlib.h>
voidmain()

{
FILE*fp;
charname[40],numstr[10];
intcode;
floatheight;
intn,i;
clrscr();
fp=fopen(a:\newfile.txt,w);
printf(Chosonguoicannhap:);
gets(numstr);
n=atoi(numstr);
for(i=0;i<n;i++)
{

50
 printf(Nhapten:);
 gets(name);
 printf(Nhapmaso:);
 gets(numstr);
 code=atoi(numstr);
 printf(Nhapchieucao:);
 gets(numstr);
 height=atof(numstr);
 fprintf(fp,%s%d%f,name,code,height);
 if(ferror(fp))
{
 perror(Loighifile);
 getch();
 exit(1);
}

}
fclose(fp);
}

Saulidotaghi,trìnhbiêndchsthôngbáolicthtrongcâu“
Loighifile:nosuchfiledirectory”

§6.VÀORAMCHTHNG
1.Cáctptintiêuđvàbinchun:Trongcáchvào
ramchthng,ta
phikhitobđmriđtdliuvàođótrcghihayđc.Vàoramc
hthngcólichlngmãíthnvàorachunvà
tcđsnhanhhn.
Đdùngcáchàmcp1taphicncáctptintiêuđsau:
 io.hchacácprototypecacáchàmcp1
 fcntl.hchacácđnhnghĩaquyntruycp
 sys/stat.hchá
cácđnhnghĩathuctính
 dó.hchacácthuctínhtheoDOS

2.Tómttcáchàm: 
creattotptinmi
 _creattotptinmitheokiunhphân
 openmtptin
 _openmtptinđãtnti
 closevà_closeđóngtptin
 chmodthayđithuctínhcatptin 
 _chmodethayđithuctínhcatptintheokiuDOS

51

×