Kwa urahisi wa upatikanaji, habari katika vifaa vya kuhifadhi huhifadhiwa kwa namna ya faili.

Faili ni eneo lenye jina la kumbukumbu ya nje iliyotengwa kwa ajili ya kuhifadhi safu ya data. Data iliyo katika faili ni ya asili tofauti sana: mipango katika lugha ya algorithmic au mashine; data ya awali ya uendeshaji wa programu au matokeo ya utekelezaji wa programu; maandishi ya bure; picha za picha, nk.

Saraka (folda, saraka) - mkusanyiko unaoitwa wa ka kwenye njia ya uhifadhi iliyo na majina ya subdirectories na faili, zinazotumiwa katika mfumo wa faili ili kurahisisha shirika la faili.

Mfumo wa faili inayoitwa sehemu ya kazi ya mfumo wa uendeshaji ambayo hufanya shughuli kwenye faili. Mifano ya mifumo ya faili ni FAT (FAT - Jedwali la Ugawaji wa Faili), NTFS, UDF (hutumika kwenye CD).

Kuna matoleo matatu kuu ya FAT: FAT12, FAT16 na FAT32. Wanatofautiana katika kina kidogo cha rekodi katika muundo wa disk, i.e. idadi ya biti zilizotengwa kuhifadhi nambari ya nguzo. FAT12 hutumiwa hasa kwa diski za floppy (hadi 4 KB), FAT16 - kwa disks ndogo za uwezo, FAT32 - kwa anatoa za juu za FLASH (hadi 32 GB).

Wacha tuangalie muundo wa mfumo wa faili kwa kutumia FAT32 kama mfano.

muundo wa faili FAT32

Vifaa vya kumbukumbu ya nje katika mfumo wa FAT32 vina anwani ya kuzuia badala ya kushughulikia kwa kawaida. Taarifa imeandikwa kwa kifaa cha kumbukumbu ya nje katika vitalu au sekta.

Sekta ni sehemu ya chini kabisa inayoweza kushughulikiwa ya uhifadhi wa taarifa kwenye vifaa vya hifadhi ya nje. Kwa kawaida, ukubwa wa sekta ni fasta kwa 512 bytes. Ili kuongeza nafasi ya anwani ya vifaa vya kumbukumbu ya nje, sekta zinajumuishwa katika vikundi vinavyoitwa makundi.

Nguzo ni muungano wa sekta kadhaa, ambayo inaweza kuchukuliwa kama kitengo huru na mali fulani. Mali kuu ya nguzo ni saizi yake, iliyopimwa kwa idadi ya sekta au idadi ya ka.

Mfumo wa faili wa FAT32 una muundo ufuatao.

Vikundi vinavyotumiwa kuandika faili vimehesabiwa kuanzia 2. Kama sheria, kikundi cha 2 kinatumiwa na saraka ya mizizi, na kuanzia kikundi cha 3 safu ya data huhifadhiwa. Sekta zinazotumiwa kuhifadhi habari juu ya saraka ya mizizi hazijaunganishwa.
Saizi ya chini ya faili inayohitajika kwenye diski inalingana na nguzo 1.

Sekta ya boot huanza na habari ifuatayo:

• EB 58 90 - kuruka bila masharti na saini;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 - idadi ya ka katika sekta (kawaida 512);
• 1 byte - idadi ya sekta katika nguzo;
• 2 byte - idadi ya sekta za hifadhi.

Kwa kuongeza, sekta ya boot ina taarifa muhimu zifuatazo:

• 0x10 (1 byte) - idadi ya meza za FAT (kawaida 2);
• 0x20 (4 byte) - idadi ya sekta kwenye diski;
• 0x2С (4 byte) - nambari ya nguzo ya saraka ya mizizi;
• 0x47 (bytes 11) - lebo ya kiasi;
• 0x1FE (2 byte) - saini ya sekta ya boot (55 AA).

Sekta ya habari ya mfumo wa faili ina:

• 0x00 (4 byte) - saini (52 52 61 41);
• 0x1E4 (4 byte) - saini (72 72 41 61);
• 0x1E8 (4 byte) - idadi ya makundi ya bure, -1 ikiwa haijulikani;
• 0x1EC (4 byte) - idadi ya nguzo ya mwisho iliyorekodiwa;
• 0x1FE (2 byte) - saini (55 AA).

Jedwali la FAT lina habari kuhusu hali ya kila nguzo kwenye diski. Biti 2 za chini za duka la meza la FAT F8 FF FF 0F FF FF FF FF (ambayo inalingana na hali ya makundi 0 na 1, ambayo haipo kimwili). Ifuatayo, hali ya kila nguzo ina nambari ya nguzo ambayo faili ya sasa inaendelea au habari ifuatayo:

• 00 00 00 00 - nguzo ni bure;
• FF FF FF 0F - mwisho wa faili ya sasa.

• 8 byte - jina la faili;
• 3 byte - ugani wa faili;

Saraka ya mizizi ina seti ya rekodi za habari 32-bit kuhusu kila faili, iliyo na habari ifuatayo:

Wakati wa kufanya kazi na majina ya faili ndefu (ikiwa ni pamoja na majina ya Kirusi), jina la faili limewekwa kwa kutumia mfumo wa encoding UTF-16. Katika kesi hii, byte 2 zimetengwa kwa kusimba kila herufi. Katika kesi hii, jina la faili limeandikwa katika muundo ufuatao:

• 1 mlolongo baiti;
• Biti 10 zina herufi 5 za chini za jina la faili;
• 1 byte sifa;
• 1 byte imehifadhiwa;
• 1 byte - hundi ya jina la DOS;
• Biti 12 zina herufi 3 za chini za jina la faili;
• 2 byte - idadi ya nguzo ya kwanza;
• herufi zilizobaki za jina refu.

Kufanya kazi na faili katika lugha ya C

Kwa mtayarishaji programu, faili iliyofunguliwa inawakilishwa kama mlolongo wa data inayosomwa au kuandikwa. Wakati faili inafunguliwa, inahusishwa na I/O mkondo. Taarifa ya pato imeandikwa kwa mkondo, taarifa ya pembejeo inasomwa kutoka kwa mkondo.

Mtiririko unapofunguliwa kwa I/O, unahusishwa na muundo wa kawaida wa FILE, ambao umefafanuliwa katika stdio.h. Muundo wa FILE una habari muhimu kuhusu faili.

Kufungua faili hufanywa kwa kutumia fopen() kazi, ambayo inarudisha pointer kwa muundo wa FILE ambao unaweza kutumika kwa shughuli zinazofuata kwenye faili.

FILE *fopen(jina, aina);

jina - jina la faili ya kufungua (pamoja na njia),
type ni kielekezi kwa safu ya wahusika ambayo inafafanua jinsi faili inavyopatikana:

• "r" - fungua faili kwa kusoma (faili lazima iwepo);
• "w" - fungua faili tupu kwa kuandika; ikiwa faili iko, yaliyomo yake yanapotea;
• "a" - fungua faili kwa kuandika hadi mwisho (kwa kuongezea); faili imeundwa ikiwa haipo;
• "r +" - fungua faili kwa kusoma na kuandika (faili lazima iwepo);
• "w+" - fungua faili tupu kwa kusoma na kuandika; ikiwa faili iko, yaliyomo yake yanapotea;
• "a+" - fungua faili kwa kusoma na kuongezea; ikiwa faili haipo, basi imeundwa.

Thamani ya kurudi ni kiashirio kwa mkondo wazi. Ikiwa hitilafu itapatikana, NULL itarejeshwa.

Fclose() chaguo za kukokotoa hufunga mtiririko au mitiririko inayohusishwa na faili zilizofunguliwa kwa kutumia fopen() chaguo la kukokotoa. Mtiririko utakaofungwa unaamuliwa na hoja ya fclose() chaguo la kukokotoa.

Thamani ya kurejesha: thamani 0 ikiwa mtiririko ulifungwa kwa mafanikio; EOF mara kwa mara ikiwa hitilafu ilitokea.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#pamoja na
int kuu() (
FILE *fp;
char name = "my.txt" ;
ikiwa ((fp = fopen(jina, "r")) == NULL )
{
printf( "Imeshindwa kufungua faili");
getchar();
kurudi 0;
}
// alifanikiwa kufungua faili
... // vitendo vinavyohitajika kwenye data
fclose (fp);
getchar();
kurudi 0;
}

Kusoma herufi kutoka kwa faili:

char fgetc(mkondo);

Hoja ya kukokotoa ni kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa. Ikiwa mwisho wa faili umefikiwa au hitilafu hutokea, EOF ya mara kwa mara inarudi.

Kuandika ishara kwa faili:

fputc(char, mkondo);

Hoja za chaguo za kukokotoa ni herufi na kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa.

Vipengele vya fscanf() na fprintf() vinafanana na vitendaji vya scanf() na printf(), lakini hufanya kazi na faili za data, na kuwa na kielekezi cha faili kama hoja yao ya kwanza.

fscanf(mkondo, "InputFormat", hoja);

Faili za maandishi

Wacha tuangalie kufanya kazi na faili ya maandishi katika C kwa kutumia mfano. Unda faili ya maandishi kwenye hifadhi C inayoitwa TextFile.txt. Andika mistari ifuatayo kwenye faili hii:

Mfuatano_1 123 Mfuatano_11, 456
Kamba_2
Kamba_3

Hifadhi faili.

Na hii ndio nambari ya programu ya C inayofungua faili yetu na kusoma mistari kutoka kwayo:

/* *Mwandishi: @author Subbotin B.P..h> #pamoja na #fafanua LEN 50 int main(batili) ( inaweka("Shughuli za faili za maandishi"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( huweka("Matatizo"); rudisha EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); rudisha EXIT_SUCCESS; )

Ili kufungua faili ya maandishi katika C, tumia fopen kazi:

FILE *pTextFile = fopen("C:\\TextFile.txt", "r");

Hoja ya kwanza kwa kazi ya fopen inaelekeza kwenye faili, na ya pili inasema kwamba faili imefunguliwa kwa kusoma kutoka kwake.

Tunasoma mistari kwa kutumia fgets kazi:

fgets(cArray, LEN, pTextFile);

Hoja ya kwanza ya kazi ya fgets inaelekeza kwa safu ya herufi ambayo mifuatano iliyopokelewa itahifadhiwa, hoja ya pili ni idadi ya juu ya herufi za kusoma, na ya tatu ni faili yetu.

Baada ya kumaliza kufanya kazi na faili, unahitaji kuifunga:

fclose(pTextFile);

Tunapata:

Barua za Kirusi pia zinaonekana kwenye mistari.

Kwa njia, nilifanya programu hii katika Eclipse. Unaweza kuona jinsi ya kufanya kazi na C/C++ kwenye Eclipse.

Kwa hiyo, tulifungua na kusoma data kutoka kwa faili ya maandishi.

Sasa tutajifunza jinsi ya kuunda faili ya maandishi na kuandika data kwake.

/* Mwandishi: @author Subbotin B.P..h> #include int main(batili) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Hii ni kamba"; char cNewLine = "\n"; int nVal = 123 ; ikiwa(pTextFile == NULL) ( inaweka("Matatizo"); rudisha EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine); fprintf(pTextFile, "%d", nVal); rudisha EXIT_SUCCESS ;)

Unda faili ya maandishi ili kuandika data kwa:

FILE *pTextFile = fopen("C:\\TextFileW.txt", "w");

ikiwa faili tayari iko, itafunguliwa na data yote kutoka kwake itafutwa.

C-string cString na nambari nVal zimeandikwa na programu kwenye faili ya maandishi. cNewLine ni laini mpya.

Tunaandika data kwa faili ya maandishi kwa kutumia kazi ya fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

hoja ya kwanza hapa ni faili yetu, ya pili ni kamba ya umbizo, ya tatu au zaidi ni idadi ya hoja zinazohitajika kwa umbizo hili.

Hapo awali, wakati wa kuingiza na kutoa data, tulifanya kazi na mitiririko ya kawaida - kibodi na ufuatiliaji. Sasa hebu tuangalie jinsi lugha C inavyotumia kupokea data kutoka kwa faili na kuziandika hapo. Kabla ya kufanya shughuli hizi, lazima ufungue faili na uifikie.

Katika lugha ya programu ya C, kielekezi kwa faili ni cha aina ya FILE na tamko lake linaonekana kama hii:
FILE *myfile;

Kwa upande mwingine, fopen() chaguo la kukokotoa hufungua faili kwenye anwani iliyotajwa kama hoja yake ya kwanza katika hali ya kusoma ("r"), modi ya kuandika ("w"), au modi ya kuongeza ("a") na kurudisha pointer. kwake kwa programu. Kwa hivyo, mchakato wa kufungua faili na kuiunganisha kwenye programu inaonekana kama hii:
myfile = fopen("hello.txt", "r");

Wakati wa kusoma au kuandika data kwa faili, hupatikana kwa njia ya pointer ya faili (katika kesi hii, myfile).

Ikiwa kwa sababu moja au nyingine (hakuna faili kwenye anwani maalum, ufikiaji wake umekataliwa) kazi ya fopen () haiwezi kufungua faili, basi inarudi NULL. Katika programu halisi, karibu kila mara hushughulikia kosa la kufungua faili kwenye tawi la if, lakini tutaacha hili zaidi.

Tamko la chaguo la kukokotoa la fopen() lipo katika faili ya kichwa cha stdio.h, kwa hivyo ni lazima ijumuishwe. Pia katika stdio.h aina ya muundo FILE imetangazwa.

Baada ya kufanya kazi na faili kukamilika, ni desturi ya kuifunga ili kufungua buffer kutoka kwa data na kwa sababu nyingine. Hii ni muhimu hasa ikiwa programu inaendelea kufanya kazi baada ya kufanya kazi na faili. Kuvunja uunganisho kati ya faili ya nje na pointer kutoka kwa programu inafanywa kwa kutumia fclose() kazi. Pointer kwa faili hupitishwa kwake kama parameta:
fclose(myfile);

Zaidi ya faili moja inaweza kufunguliwa katika programu. Katika kesi hii, kila faili lazima ihusishwe na pointer yake ya faili. Hata hivyo, ikiwa programu inafanya kazi kwanza na faili moja na kisha kuifunga, basi pointer inaweza kutumika kufungua faili ya pili.

Kusoma na kuandika kwa faili ya maandishi

fscanf()

fscanf() chaguo za kukokotoa ni sawa kimaana na kitendakazi cha scanf(), lakini tofauti na hicho, hutoa ingizo lililoumbizwa kutoka kwa faili badala ya ingizo la kawaida. Kazi ya fscanf() inachukua vigezo: pointer ya faili, kamba ya fomati, anwani za maeneo ya kumbukumbu ya kuandika data:
fscanf(myfile, "%s%d", str, &a);

Hurejesha nambari ya data iliyosomwa kwa ufanisi au EOF. Nafasi na herufi mpya huhesabiwa kama vikomo vya data.

Wacha tuseme tunayo faili iliyo na maelezo yafuatayo ya vitu:

Tufaha 10 23.4 ndizi 5 25.0 mkate 1 10.3

#pamoja na kuu () ( FILE * faili; struct food ( char name[ 20 ] ; unsigned qty; float price; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt" , "r" ) ; wakati (fscanf (faili, "%s%u%f" , duka[ i].name , & (duka[ i].qty ) , & (duka[ i].price ) ) != EOF) ( printf ("%s %u %.2f \n", duka[ i].jina, duka[ i].qty, duka[ i].bei); i++; ))

Katika kesi hii, muundo na safu ya miundo hutangazwa. Kila mstari kutoka kwa faili unafanana na kipengele kimoja cha safu; kipengele cha safu ni muundo ulio na kamba na sehemu mbili za nambari. Kitanzi kinasoma safu mlalo moja kwa kila marudio. Wakati mwisho wa faili unakabiliwa, fscanf() inarudisha EOF na kitanzi kinaisha.

fgets()

Kitendakazi cha fgets() ni sawa na gets() kitendakazi na hufanya uingizaji wa mstari kwa mstari kutoka kwa faili. Simu moja kwa fgets() itasoma mstari mmoja. Katika kesi hii, huwezi kusoma mstari mzima, lakini sehemu yake tu tangu mwanzo. fgets() vigezo vinaonekana kama hii:
fgets (safu_ya_wahusika, nambari_ya_wahusika_kusomwa, kielekezi_kwa_faili)

Kwa mfano:
fgets(str, 50, myfile)

Simu hii ya kukokotoa itasoma kutoka kwa faili inayohusishwa na kielekezi cha myfile mstari mmoja kamili wa maandishi ikiwa urefu wake ni chini ya vibambo 50, ikijumuisha herufi "\n", ambayo fomula ya kukokotoa pia itahifadhi katika safu. Kipengele cha mwisho (cha 50) cha safu ya safu kitakuwa herufi "\0" iliyoongezwa na fgets() . Ikiwa kamba ni ndefu, chaguo la kukokotoa litasoma herufi 49 na kuandika "\0" mwishoni. Katika kesi hii, "\n" haitakuwa kwenye mstari wa kusoma.

#pamoja na #define N 80 kuu () ( FILE * file; char arr[ N] ; file = fopen ( "fscanf.txt" , "r" ) ; while (fgets (arr, N, file) != NULL) printf (" %s" , arr); printf (" \n"); fclose (faili); )

Katika mpango huu, tofauti na uliopita, data inasomwa mstari kwa mstari kwenye safu ya safu. Wakati mstari unaofuata unasomwa, uliopita unapotea. Kazi ya fgets() inarudisha NULL ikiwa haiwezi kusoma mstari unaofuata.

getc() au fgetc()

Getc() au fgetc() kazi (zote mbili zinafanya kazi) hukuruhusu kupata herufi moja inayofuata kutoka kwa faili.

wakati ((arr[ i] = fgetc (faili) ) != EOF) ( ikiwa (arr[ i] == " \n") (arr[i] = " \0 " ; printf("%s \n", sivyo); i = 0; ) mwingine i++; ) arr[i] = " \0 " ; printf("%s \n", sivyo);

Nambari ya mfano inaonyesha data kutoka kwa faili kwenye skrini.

Kuandika kwa faili ya maandishi

Kama vile ingizo, pato kwa faili linaweza kuwa tofauti.

• Toleo lililoumbizwa. Kazi fprintf (faili_index, format_string, vigezo) .
• Pato la baada kwa mstari. Kazi fputs(kamba, file_pointer) .
• Matokeo ya herufi kwa herufi. Kazi fputc() au putc(ishara, file_pointer) .

Ifuatayo ni mifano ya msimbo inayotumia mbinu tatu za kutoa data kwa faili.

Sehemu za uandishi za muundo mmoja kwa kila mstari wa faili:

file = fopen ("fprintf.txt" , "w" ) ; wakati (scanf ("%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (duka[ i].price ) ) != EOF) ( fprintf (faili, " %s %u %.2f \n", duka[ i].jina, duka[ i].qty, duka[ i].bei); i++; )

Pato la mstari kwa mstari kwa faili (fputs(), tofauti na puts() yenyewe, haiweki "\n" mwishoni mwa mstari):

while (anapata (arr) != NULL) ( fputs (arr, file); fputs (" \n", faili); )

Mfano wa matokeo ya herufi kwa herufi:

wakati ((i = getchar () ) != EOF) putc (i, faili);

Kusoma kutoka na kuandika kwa faili ya binary

Unaweza kufanya kazi na faili sio kama mlolongo wa wahusika, lakini kama mlolongo wa ka. Kimsingi, haiwezekani kufanya kazi na faili zisizo za maandishi kwa njia nyingine yoyote. Walakini, unaweza kusoma na kuandika kwa faili za maandishi kwa njia hii. Faida ya njia hii ya kupata faili ni kasi ya kusoma-kuandika: kizuizi kikubwa cha habari kinaweza kusoma / kuandikwa kwa ufikiaji mmoja.

Wakati wa kufungua faili kwa ufikiaji wa binary, parameta ya pili ya fopen() ni kamba "rb" au "wb".

Mada ya kufanya kazi na faili za binary ni ngumu sana na inahitaji somo tofauti ili kuisoma. Hapa tu sifa za kazi za kusoma na kuandika kwa faili, ambayo inachukuliwa kama mkondo wa kawaida, itazingatiwa.

Kazi za fread() na fwrite() huchukua kama vigezo:

1. anwani ya eneo la kumbukumbu ambapo data imeandikwa au kusomwa kutoka,
2. saizi ya aina yoyote,
3. kiasi cha data iliyosomwa ya saizi maalum,
4. faharisi ya faili.

Vitendaji hivi hurejesha idadi ya data iliyosomwa au kuandikwa kwa mafanikio. Wale. unaweza "kuagiza" usomaji wa vipengele 50 vya data, lakini upokea 10 tu. Hakutakuwa na kosa.

Mfano wa kutumia fread() na fwrite() kazi:

#pamoja na #pamoja na kuu () ( FILE * file; char shelf1[ 50 ], shelf2[ 100 ] ; int n, m; file = fopen ("shelf1.txt" , "rb" ) ; n= fread (rafu1, sizeof (char ) , 50 , faili); fclose (faili) ; file = fopen ("shelf2.txt" , "rb" ) ; m= fread (rafu2, sizeof (char ) , 50 , faili) ; fclose (faili) ; shelf1[ n] = " \0 " ; rafu2[m] = " \n"; rafu2[ m+ 1 ] = " \0 " ; file = fopen ("shop.txt" , "wb" ) ; fwrite (strcat (rafu2, rafu1) , sizeof (char ) , n+ m, faili); fclose (faili); )

Hapa jaribio linafanywa kusoma herufi 50 kutoka kwa faili ya kwanza. n huhifadhi idadi ya herufi zilizosomwa. Thamani ya n inaweza kuwa 50 au chini. Data imewekwa kwa safu. Kitu kimoja kinatokea na faili ya pili. Ifuatayo, mstari wa kwanza umeongezwa kwa pili, na data inatupwa kwenye faili ya tatu.

Kutatua tatizo

1. Andika programu inayouliza mtumiaji jina (anwani) ya faili ya maandishi, kisha uifungue na uhesabu idadi ya wahusika na mistari ndani yake.
2. Andika programu ambayo huandika kwa data ya faili iliyopokelewa kutoka kwa faili nyingine na kurekebishwa kwa njia fulani kabla ya kuandika. Kila safu ya data iliyopatikana kutoka kwa faili lazima ilingane na muundo.

Kwa mtayarishaji programu, faili iliyofunguliwa inawakilishwa kama mlolongo wa data inayosomwa au kuandikwa. Wakati faili inafunguliwa, inahusishwa na I/O mkondo . Taarifa ya pato imeandikwa kwa mkondo, taarifa ya pembejeo inasomwa kutoka kwa mkondo.

Mtiririko unapofunguliwa kwa I/O, unahusishwa na muundo wa kawaida wa FILE, ambao umefafanuliwa katika stdio.h. Muundo wa FILE una habari muhimu kuhusu faili.

Kufungua faili hufanywa kwa kutumia fopen() kazi, ambayo inarudisha pointer kwa muundo wa aina FILE ambayo inaweza kutumika kwa shughuli zinazofuata kwenye faili.

FILE *fopen(jina, aina);

jina - jina la faili ya kufungua (pamoja na njia),
type - pointer kwa safu ya wahusika kufafanua jinsi faili inapatikana:

· "r" - kufungua faili kwa kusoma (faili lazima iwepo);

· "w" - fungua faili tupu kwa kuandika; ikiwa faili iko, yaliyomo yake yanapotea;

· "a" - kufungua faili kwa ajili ya kuandika hadi mwisho (kwa appending); faili imeundwa ikiwa haipo;

· "r +" - kufungua faili kwa kusoma na kuandika (faili lazima iwepo);

· "w+" - fungua faili tupu kwa kusoma na kuandika; ikiwa faili iko, yaliyomo yake yanapotea;

· "a+" - fungua faili kwa kusoma na kuongezea; ikiwa faili haipo, imeundwa.

Thamani ya kurudi ni kiashirio kwa mkondo wazi. Ikiwa hitilafu itagunduliwa, NULL itarejeshwa.

Fclose() chaguo za kukokotoa hufunga mtiririko au mitiririko inayohusishwa na faili zilizofunguliwa kwa kutumia fopen() chaguo la kukokotoa. Mtiririko utakaofungwa unaamuliwa na hoja ya fclose() chaguo la kukokotoa.

Thamani ya kurejesha: thamani 0 ikiwa mtiririko ulifungwa kwa mafanikio; EOF mara kwa mara ikiwa hitilafu ilitokea.

#pamoja na
int kuu()

char name="my.txt";

if(fp = fopen(jina, "r")!=NULL)

// iliwezekana kufungua faili?
... // vitendo vinavyohitajika kwenye data

else printf("Imeshindwa kufungua faili");

Kusoma herufi kutoka kwa faili:

char fgetc(mkondo);

Hoja ya kukokotoa ni kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa. Ikiwa mwisho wa faili umefikiwa au hitilafu hutokea, EOF ya mara kwa mara inarudi.
Kuandika ishara kwa faili:

fputc(char, mkondo);

Hoja za chaguo za kukokotoa ni herufi na kielekezi kwa mtiririko wa aina FILE. Chaguo la kukokotoa linarudisha msimbo wa herufi iliyosomwa.

Vipengele vya fscanf() na fprintf() vinafanana na vitendaji vya scanf() na printf(), lakini hufanya kazi na faili za data, na kuwa na kielekezi kwa faili kama hoja yao ya kwanza.

fscanf(mkondo, "Muundo wa Kuingiza", hoja);
fprintf(mkondo, "Muundo wa Pato", hoja);

Kazi za fgets() na fputs() zimeundwa kwa ajili ya pembejeo/pato la kamba; ni sawa na gets() na puts() kazi za kufanya kazi na faili.

fgets(Kielekezi Kwa Mstari, Idadi ya Wahusika, mkondo);

Herufi husomwa kutoka kwa mtiririko hadi herufi mpya "\n" isomwe, ambayo imejumuishwa kwenye mfuatano, au hadi mtiririko umalizike EOF au idadi ya juu zaidi ya herufi isomwe. Matokeo yake huwekwa kwenye kielekezi cha kamba na kuishia na herufi isiyofaa "\0". Kazi inarudisha anwani ya kamba.

fputs(Pointer Kwa Kamba, mkondo);

Hunakili mfuatano hadi kwenye mkondo kutoka kwa nafasi ya sasa. Kibambo batili cha kukomesha hakijanakiliwa.
Mfano Ingiza nambari na uihifadhi kwenye faili ya s1.txt. Soma nambari kutoka kwa faili s1.txt, iongeze kwa 3 na uihifadhi kwenye faili s2.txt.

Sehemu hii itajadili njia mbili za kufanya kazi na faili na darasa la kawaida la MFC CFileDialog.

1. Kufanya kazi na faili katika C (inafanya kazi katika C++ pia).

#pamoja na
#pamoja na

Utupu kuu (utupu)
{
FILE *faili;
char* file_name = "file.txt";
char load_string = "hakuna";

Faili = fopen(file_name, "w");

Fputs("kamba", faili);

Faili = fopen(file_name, "r");
ikiwa (faili != 0)
{
fgets(load_string, 50, faili);
koti)
mwingine
{
koti)
fclose (faili);
) Maelezo ya kazi za kufanya kazi na faili ziko kwenye maktaba stdio.h
Kwanza unahitaji kuunda pointer kwa utofauti wa aina FILE ( FILE* faili;).
Kufungua faili hufanywa kwa kupiga kazi ya fopen ( faili = fopen(file_name, "w");)
Parameta ya kwanza ya kazi hii ni jina la faili, ya pili inataja katika hali gani faili inapaswa kufunguliwa. "w"- wazi kwa kurekodi, "r"- wazi kwa kusoma, "a"- nyongeza ya faili (hizi ndio njia zinazotumiwa zaidi, ingawa kuna zingine). Kuandika na kusoma data kutoka kwa faili hufanywa na kazi zifuatazo: fputc, fputs, fgetc, fgets, fprintf, fscanf(kwa maelezo ya kazi hizi, ona stdio.h).
Kufunga faili kunafanywa kwa kupiga kazi ya fclose ( fclose (faili);).

Kufanya kazi na faili kwa kutumia MFC (madarasa CFile, CStdioFile, ...) na darasa la kawaida la MFC CFileDialog.

Maktaba ya MFC inajumuisha madarasa kadhaa ya kufanya kazi na faili. Madarasa yaliyojadiliwa hapa chini yanarithi kutoka kwa darasa la msingi

CFile.

Darasa la CF ile

CFileiliyoundwa kufanya kazi na faili. Inafanya faili kuwa rahisi kutumia kwa kuwakilisha faili kama kitu ambacho kinaweza kuunda, kusoma, kuandikwa, nk.

Ili kufikia faili, kwanza unahitaji kuunda kitu cha darasa la CFile. Mjenzi wa darasa hukuruhusu kufungua faili mara baada ya kuunda kitu kama hicho. Lakini unaweza kufungua faili baadaye kwa kutumia njia

Fungua.

Kufungua na kuunda faili

Baada ya kuunda kitu cha darasa CFileunaweza kufungua faili kwa kupiga njiaFungua. Njia lazima ielezee njia ya kufungua faili na hali ya matumizi yake. Mfano wa mbinuFunguaina fomu ifuatayo:

Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

Kama kigezo cha lpszFileName, lazima ubainishe jina la faili ili kufungua. Unaweza kutaja tu jina la faili au jina kamili la faili ambalo linajumuisha njia kamili ya hiyo.

Parameta ya pili, nOpenFlags, inabainisha hatua ambayo njia ya Fungua hufanya kwenye faili, pamoja na sifa za faili. Hapo chini kuna maadili yanayowezekana ya parameta ya nOpenFlags:

• CFile::modeCreate - Inaunda faili mpya. Ikiwa faili iliyobainishwa iko, yaliyomo yake yanafutwa na urefu wa faili umewekwa kuwa sifuri.
• CFile::modeNoTruncate - Faili hii inakusudiwa kutumika pamoja na CFile::modeCreate file. Ikiwa faili iliyopo imeundwa, yaliyomo yake hayatafutwa.

CFile::modeRea d - Faili inafunguliwa kwa kusoma tu.

CFile::modeReadWrite - Faili inafunguliwa kwa kuandika na kusoma.

CFile::modeWrite - Faili inafunguliwa kwa maandishi pekee.

CFile::typeText - Inatumiwa na madarasa yanayotokana na darasa la CFile, kama vile CStdioFile, kufanya kazi na faili katika hali ya maandishi. Hali ya maandishi hubadilisha mchanganyiko wa herufi ya kurejesha gari na herufi ya mlisho wa mstari.

CFile::Binary - Inatumiwa na madarasa yanayotokana na darasa la CFile, kama vile CStdioFile, kufanya kazi na faili katika hali ya jozi.

Hitilafu ya kigezo cha hiari, ambayo ni kielekezi kwa kitu cha darasa CFileException, inatumika tu ikiwa kufanya operesheni kwenye faili kunaweza kusababisha hitilafu. Katika kesi hii, maelezo ya ziada yataandikwa kwa kitu kilichoelekezwa na pError.

Njia Funguainarudisha zisizo sifuri ikiwa faili imefunguliwa na sifuri kwenye makosa. Hitilafu wakati wa kufungua faili inaweza kutokea, kwa mfano, ikiwa njia ya Fungua imeelezwa kusoma faili isiyopo.

Fungua kitambulisho cha faili

Darasa la CFile linajumuisha kipengele cha data m_hFile cha aina ya UINT. Huhifadhi kitambulisho cha faili wazi. Ikiwa kitu cha darasa la CFile tayari kimeundwa, lakini faili bado haijafunguliwa, basi hFileNull mara kwa mara imeandikwa katika m_hFile variable.

Kwa kawaida kitambulisho cha faili wazi hakitumiki moja kwa moja. Mbinu za Darasa CFilehukuruhusu kufanya karibu operesheni yoyote na faili na hauitaji kutaja kitambulisho cha faili. Kwa kuwa m_hFile ni kipengele cha darasa, utekelezaji wa mbinu zake daima una upatikanaji wa bure kwake.

Kufunga faili

Baada ya kumaliza kufanya kazi na faili, lazima iwe imefungwa. Darasa CFileina njia maalum ya Funga kwa hili. Ikumbukwe kwamba ikiwa kitu cha darasa la CFile kiliundwa na faili ilifunguliwa, na kisha kitu kinafutwa, faili inayohusishwa imefungwa moja kwa moja kwa kutumia uharibifu.

Kusoma na kuandika faili

Kuna njia kadhaa za darasa za kupata faili. CFile: Read, ReadHuge, Andika, WriteHuge, Flush. Mbinu Soma na UsomeHuge zimeundwa kusoma data kutoka kwa faili iliyofunguliwa hapo awali. Kwenye mifumo ya uendeshaji ya 32-bit, njia zote mbili zinaweza kusoma kwa wakati mmoja zaidi ya ka 65535 kutoka kwa faili. Vipimo vya ReadHuge huchukuliwa kuwa vya kizamani na hutunzwa tu kwa uoanifu na mifumo ya uendeshaji ya 16-bit.

Data iliyosomwa kutoka kwa faili imeandikwa kwa lpBuf bafa. Kigezo cha nCount kinabainisha idadi ya baiti za kusomwa kutoka kwa faili. Kwa kweli, baiti chache zinaweza kusomwa kutoka kwa faili kuliko ilivyoombwa na parameta ya nCount. Hii hutokea ikiwa mwisho wa faili unafikiwa wakati wa kusoma. Njia zinarudisha idadi ya ka zilizosomwa kutoka kwa faili.

Njia za Andika na AndikaHuge zimekusudiwa kuandikia faili. Kwenye mifumo ya uendeshaji 32-bit, njia zote mbili zinaweza kuandika kwa wakati mmoja zaidi ya ka 65535 kwa faili. Mbinu huandika baiti kutoka kwa bafa ya lpBuf hadi faili wazi nCount. Ikiwa hitilafu ya kuandika itatokea, kama vile diski iliyojaa, mbinu zinahitaji utunzaji wa ubaguzi.

Mbinu ya kuvuta

Wakati njia ya Andika au AndikaHuge inatumiwa kuandika data kwenye diski, inaweza kubaki kwenye bafa ya muda kwa muda fulani. Ili kuhakikisha kuwa mabadiliko muhimu yanafanywa kwa faili kwenye diski, unahitaji kutumia njia ya Flush.

Uendeshaji wa faili

Darasa linajumuisha njia zinazokuwezesha kufanya shughuli mbalimbali kwenye faili, kama vile kunakili, kubadilisha jina, kufuta, kubadilisha sifa.

Ili kubadilisha jina la faili, darasa la CFile linajumuisha njia tuli Badilisha jina, ambayo hufanya kazi za amri hii. Mbinu haiwezi kutumika kubadilisha saraka. Ikiwa kosa linatokea, njia hiyo inaleta ubaguzi.

Mbinu tuli imejumuishwa katika darasa la CFile ili kufuta faili Ondoa, ambayo hukuruhusu kufuta faili maalum. Njia hii haikuruhusu kufuta saraka. Ikiwa faili haiwezi kufutwa, njia hutupa ubaguzi.

Kuamua tarehe na wakati wa kuunda faili, urefu na sifa zake, njia ya tuli hutumiwa GetStatus. Kuna aina mbili za mbinu - ya kwanza inafafanuliwa kama njia ya kawaida na ya pili inafafanuliwa kama mbinu tuli.

Toleo la kweli la mbinu GetStatushuamua hali ya wazi ya faili inayohusishwa na kitu hiki cha darasa la CFile. Njia hii inaitwa tu wakati kitu cha darasa la CFile kimeundwa na faili inafunguliwa.

Toleo tuli la mbinu GetStatushukuruhusu kuamua sifa za faili ambayo haihusiani na kitu cha darasa la CFile. Ili kutumia njia hii, si lazima kwanza kufungua faili.

Funga

darasa ni pamoja na mbinu LockRange Na UnlockRange, ambayo huruhusu kipande kimoja au zaidi cha data ya faili kufungwa kwa ufikiaji wa michakato mingine. Ikiwa programu itajaribu kufunga tena data ambayo ilikuwa imefungwa hapo awali na programu hii au nyingine, ubaguzi hutupwa. Kufunga ni mojawapo ya taratibu zinazoruhusu programu au michakato kadhaa kufanya kazi kwa wakati mmoja kwenye faili moja bila kuingilia kati.

Unaweza kuweka kufuli kwa kutumia njia LockRange. Ili kuondoa kufuli zilizowekwa, unahitaji kutumia njiaUnlockRange. Ikiwa kufuli kadhaa zimewekwa kwenye faili moja, basi kila mmoja wao lazima aachiliwe kwa njia tofauti ya simuUnlockRange.

Kuweka

Ili kusogeza kiashirio cha sasa cha nafasi ya faili kwenye nafasi mpya, unaweza kutumia mojawapo ya mbinu za darasa zifuatazo CFile - Tafuta, TafutaKuanza, TafutaMwisho. Kwa darasa CFilepia inajumuisha njia zinazokuruhusu kuweka na kubadilisha urefu wa faili, -Urefu, Urefu wa Kuweka.

Wakati wa kufungua faili, kiashiria cha nafasi ya faili ya sasa iko mwanzoni mwa faili. Kipande cha data kinaposomwa au kuandikwa, kielekezi cha sasa cha nafasi husogea hadi mwisho wa faili na kuelekeza kwenye data ambayo itasomwa au kuandikwa na operesheni inayofuata ya kusoma au kuandika kwenye faili.

Ili kusogeza kiashirio cha sasa cha nafasi ya faili hadi eneo lolote, unaweza kutumia mbinu ya ulimwengu wote

Tafuta. Inakuruhusu kusogeza pointer idadi fulani ya baiti zinazohusiana na mwanzo, mwisho, au nafasi ya sasa ya pointer.

Ili kusonga pointer mwanzoni au mwisho wa faili, ni rahisi zaidi kutumia njia maalum. Njia

TafutaKuanzahuhamisha pointer hadi mwanzo wa faili, na njiaSeekToEnd- hadi mwisho wake.

Lakini ili kuamua urefu wa faili wazi, si lazima kusonga pointer yake. Unaweza kutumia mbinu

KupataUrefu. Njia hii pia inarudisha urefu wa faili wazi kwa ka. NjiaSetLengthhukuruhusu kubadilisha urefu wa faili wazi. Ikiwa njia hii inaongeza saizi ya faili, basi thamani ya byte za mwisho haijafafanuliwa.

Nafasi ya pointer ya faili ya sasa inaweza kuamua kwa kutumia njia

GetPosition. Imerejeshwa kwa mbinuGetPositionThamani ya 32-bit inabainisha kukabiliana na pointer tangu mwanzo wa faili.

Fungua Sifa za Faili

Kuamua eneo la faili wazi kwenye diski, unahitaji kupiga njia GetFilePath. Njia hii inarudisha kitu cha darasaCString, ambayo ina njia kamili ya faili, ikijumuisha jina la kiendeshi, saraka, jina la faili na kiendelezi cha faili.

Ikiwa unahitaji tu kuamua jina na ugani wa faili wazi, unaweza kutumia njia GetFileName. Inarudisha kitu cha CSring kilicho na jina la faili. Katika kesi wakati unahitaji kujua tu jina la faili wazi bila ugani, tumia njiaGetFileTitle.

Njia ifuatayo ya darasa la CFile hukuruhusu kuweka njia ya faili. Njia hii haiundi, inakili, au kubadilisha jina la faili; inajaza tu kipengele cha data sambamba katika kitu cha darasa la CFile.

Darasa C

MemFile

Maktaba ya MFC inajumuisha darasa

CMMFile, iliyorithiwa kutoka kwa darasa la msingiCFile. Darasa CMMFileinawakilisha faili iliyoko kwenye RAM. Na vitu vya darasaCMMFilesawa na vitu vya darasaCFile. Tofauti ni kwamba faili inayohusishwa na kituCMMFile, haipo kwenye diski, lakini kwenye RAM ya kompyuta. Kwa sababu ya hii, shughuli na faili kama hiyo ni haraka sana kuliko faili za kawaida.

Kufanya kazi na vitu vya darasa

CMMFile, unaweza kutumia karibu njia zote za darasaCFileambazo zimeelezwa hapo juu. Unaweza kuandika data kwa faili kama hiyo au kuisoma. Mbali na njia hizi, darasa linaCMMFilembinu za ziada pamoja.

Kuna wajenzi wawili tofauti wa kuunda vitu vya darasa la CMemFile. Mjenzi wa kwanza wa CMemFile ana kigezo kimoja tu cha hiari nGrowBytes:

CMemFile(UINT nGrowBytes=1024);

Mjenzi huyu huunda faili tupu kwenye RAM. Mara tu imeundwa, faili hufunguliwa kiatomati (hakuna haja ya kupiga njia ya Ope

n).

Wakati wa kuandika kwa faili kama hiyo huanza, kizuizi cha kumbukumbu kinatengwa kiatomati. Ili kupata njia za darasa la kumbukumbu

CMMFilepiga kazi za kawaidamalloc, realloc Na bure. Ikiwa kizuizi cha kumbukumbu kilichotengwa haitoshi, ukubwa wake umeongezeka. Kizuizi cha kumbukumbu cha faili kinaongezwa katika sehemu za baiti za nGrowBytes. Baada ya kufuta kitu cha darasaCMMFilekumbukumbu iliyotumika inarejeshwa kiotomatiki kwenye mfumo.

Mjenzi wa pili wa darasa la CMemFile ana mfano ngumu zaidi. Mjenzi huyu hutumiwa katika hali ambapo programu mwenyewe hutenga kumbukumbu kwa faili:

CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);

Kigezo cha lpBuffer kinabainisha bafa itakayotumika kwa faili. Ukubwa wa bafa hubainishwa na kigezo cha nBufferSize.

Kigezo cha hiari cha nGrowBytes kinatumika kwa undani zaidi kuliko kijenzi cha darasa la kwanza. Ikiwa nGrowBytes ina sifuri, basi faili iliyotengenezwa itakuwa na data kutoka kwa lpBuffer. Urefu wa faili kama hiyo utakuwa sawa na nBufferSize.

Ikiwa nGrowBytes ni kubwa kuliko sifuri, basi yaliyomo kwenye lpBuffer yanapuuzwa. Kwa kuongeza, ikiwa data zaidi imeandikwa kwa faili kama hiyo kuliko inaweza kutoshea kwenye bafa iliyotengwa, saizi yake huongezeka kiatomati. Kizuizi cha kumbukumbu cha faili kinaongezwa katika sehemu za baiti za nGrowBytes.

CMMFilehukuruhusu kupata pointer kwa eneo la kumbukumbu linalotumiwa na faili. Kupitia pointer hii unaweza kufanya kazi moja kwa moja na yaliyomo kwenye faili, bila kujizuia na njia za darasaCFile. Ili kupata kielekezi kwa bafa ya faili, unaweza kutumia mbinu ya Detach. Kabla ya kufanya hivi, ni muhimu kuamua urefu wa faili (na kwa hivyo saizi ya buffer ya kumbukumbu) kwa kupiga njia.KupataUrefu. Tenganishahufunga faili uliyopewa na kurudisha pointer kwenye kizuizi cha kumbukumbu kinachotumia. Ikiwa unahitaji tena kufungua faili na kuhusisha kizuizi cha RAM nayo, unahitaji kupiga njiaAmbatisha.

Ikumbukwe kwamba kusimamia buffer ya faili, darasa

CMMFilehuita vitendaji vya kawaidamalloc, realloc Na bure. Kwa hivyo, ili usivunje utaratibu wa usimamizi wa kumbukumbu, bafa ya lpBuffer lazima iundwe na vitendakazimalloc au calloc.

CstdioFile darasa

Wale ambao wamezoea kutumia utendakazi wa mkondo wa I/O kutoka kwa maktaba ya kawaida ya C na C++ wanapaswa kuzingatia darasa.

CstdioFile, iliyorithiwa kutoka kwa darasa la msingiCFile. Darasa hili hukuruhusu kutekeleza I/O iliyoakibishwa katika hali ya maandishi na ya jozi. Kwa vitu vya darasaCstdioFileUnaweza kupiga simu karibu njia zote za darasa la CFile.CstdioFileinajumuisha kipengee cha data cha m_pStream, ambacho kina kielekezi kwa faili iliyofunguliwa. Ikiwa kitu cha darasaCstdioFileimeundwa, lakini faili bado haijafunguliwa au kufungwa, basi m_pStream ina NULL mara kwa mara.CstdioFileina wajenzi watatu tofauti. Mjenzi wa kwanza wa darasa la CStdioFile hana vigezo. Mjenzi huyu huunda tu kitu cha darasa, lakini hafungui faili zozote. Ili kufungua faili, unahitaji kupiga simu njiaFunguadarasa la msingiCFile.

Mjenzi wa daraja la pili

CstdioFileinaweza kuitwa ikiwa faili tayari imefunguliwa na unahitaji kuunda kitu kipya cha darasa la CStdioFile na kuhusisha faili iliyo wazi nayo. Mjenzi huyu anaweza kutumika ikiwa faili ilifunguliwa na kazi ya kawaidafopen. Parameta ya njia lazima iwe na pointer kwa faili iliyopatikana kwa kupiga kazi ya kawaidafopen.

Mjenzi wa tatu anaweza kutumika ikiwa unahitaji kuunda kitu cha darasa

CstdioFile, fungua faili mpya na uihusishe na kitu kipya kilichoundwa.

Kwa kusoma na kuandika kwa faili ya maandishi, darasa la CStdioFile linajumuisha njia mbili mpya:

ReadString Na WriteString. Njia ya kwanza inakuwezesha kusoma safu ya wahusika kutoka kwa faili, na njia ya pili inakuwezesha kuiandika.

Mifano ya kuandika na kusoma kutoka kwa faili

Hapa kuna vipande vya msimbo vinavyoonyesha matumizi ya vidirisha vya kawaida vya uteuzi wa faili na utaratibu wa kusoma na kuandika kwa faili.

Kufungua faili na kusoma kutoka kwayo

CSring m_Nakala; …… // kuunda paneli ya kawaida ya uteuzi wa faili Fungua CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREAADONLY,(LPCSTR)" Faili za Maandishi (*.txt) |*.txt||"); // onyesha paneli ya kawaida ya uteuzi wa faili Fungua if(DlgOpen.DoModal()==IDOK) ( // kuunda kitu na kufungua faili kwa ajili ya kusoma Faili ya CStdioFile(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary); // kusoma kamba kutoka kwa faili CString& ref=m_Text; Faili.ReadString(rejelea ); // rejeleo la mfuatano limepitishwa m_Nakala)

Kufungua na kuandika kutoka kwa faili

CSring m_Nakala; …… // kuunda paneli ya kawaida ya kuchagua faili ya SaveAs CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Faili za Maandishi (*.txt) |*.txt||"); // onyesha paneli ya kawaida ya kuchagua faili ya SaveAs if(DlgSaveAs.DoModal()==IDOK) ( // kuunda kitu na kufungua faili kwa kuandika Faili ya CStdioFile(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary); // andika kwa faili ya kamba File.WriteString((LPCTSTR)m_Text); )

ina msimbo wa kufanya kazi wa programu, iliyoundwa kwa urahisi kama programu ya kiweko chini ya MFC. Ili programu ifanye kazi, usisahau kufanya yafuatayo:

Endesha programu - Jenga / Unda upya wote (kutakuwa na makosa), chagua Jenga / Weka usanidi unaofanya kazi - Shinda 32 Tambua, chagua kipengee cha menyu ya "Mradi", kisha "Mipangilio ...", kichupo cha "C/C ++", Kitengo - Uzalishaji wa Msimbo na Katika kipengee cha "Tumia maktaba ya wakati wa kukimbia", chagua "Nyingi". Baada ya hayo, fanya Jenga / Unda tena yote na programu itafanya kazi.