ઋતુઓ

ઘર

શિક્ષકને

ઍક્સેસની સરળતા માટે, સ્ટોરેજ ઉપકરણોમાં માહિતી ફાઇલોના સ્વરૂપમાં સંગ્રહિત થાય છે.

ફાઇલ એ ડેટાની એરે સ્ટોર કરવા માટે ફાળવેલ બાહ્ય મેમરીનો નામાંકિત વિસ્તાર છે. ફાઇલોમાં સમાવિષ્ટ ડેટા ખૂબ જ વૈવિધ્યસભર છે: અલ્ગોરિધમિક અથવા મશીન ભાષામાં પ્રોગ્રામ્સ; પ્રોગ્રામ ઓપરેશન અથવા પ્રોગ્રામ એક્ઝેક્યુશન પરિણામો માટે પ્રારંભિક ડેટા; મફત પાઠો; ગ્રાફિક છબીઓ, વગેરે.ડિરેક્ટરી (ફોલ્ડર, ડિરેક્ટરી) - સબડિરેક્ટરીઝ અને ફાઇલોના નામો ધરાવતા સ્ટોરેજ માધ્યમ પર બાઇટનો નામાંકિત સંગ્રહ, ફાઇલોના સંગઠનને સરળ બનાવવા માટે ફાઇલ સિસ્ટમમાં ઉપયોગમાં લેવાય છે.

ફાઇલ સિસ્ટમ

ઓપરેટિંગ સિસ્ટમનો કાર્યાત્મક ભાગ કહેવાય છે જે ફાઇલો પર કામગીરી કરે છે. ફાઇલ સિસ્ટમના ઉદાહરણો છે FAT (FAT - ફાઇલ ફાળવણી કોષ્ટક), NTFS, UDF (CDs પર વપરાયેલ).

FAT ના ત્રણ મુખ્ય સંસ્કરણો છે: FAT12, FAT16 અને FAT32. તેઓ ડિસ્ક સ્ટ્રક્ચરમાં રેકોર્ડ્સની બીટ ઊંડાઈમાં અલગ પડે છે, એટલે કે. ક્લસ્ટર નંબર સ્ટોર કરવા માટે ફાળવેલ બિટ્સની સંખ્યા. FAT12 નો ઉપયોગ મુખ્યત્વે ફ્લોપી ડિસ્ક (4 KB સુધી), FAT16 - નાની-ક્ષમતાવાળી ડિસ્ક માટે, FAT32 - ઉચ્ચ-ક્ષમતાવાળી FLASH ડ્રાઇવ્સ (32 GB સુધી) માટે થાય છે.

ચાલો ઉદાહરણ તરીકે FAT32 નો ઉપયોગ કરીને ફાઇલ સિસ્ટમની રચના જોઈએ.

FAT32 ફાઇલ માળખું

FAT32 સિસ્ટમમાં બાહ્ય મેમરી ઉપકરણોમાં બાઈટ એડ્રેસિંગને બદલે બ્લોક એડ્રેસિંગ હોય છે. માહિતી બ્લોક અથવા સેક્ટરમાં બાહ્ય મેમરી ઉપકરણ પર લખવામાં આવે છે. સેક્ટર એ બાહ્ય સ્ટોરેજ ઉપકરણો પર માહિતી સંગ્રહનું ન્યૂનતમ એડ્રેસેબલ એકમ છે. સામાન્ય રીતે, સેક્ટરનું કદ 512 બાઇટ્સ પર નિશ્ચિત છે. બાહ્ય મેમરી ઉપકરણોની સરનામાંની જગ્યા વધારવા માટે, સેક્ટરોને ક્લસ્ટર તરીકે ઓળખાતા જૂથોમાં જોડવામાં આવે છે.ક્લસ્ટર એ ઘણા ક્ષેત્રોનું એક સંઘ છે, જેને સ્વતંત્ર એકમ તરીકે ગણી શકાય

ચોક્કસ ગુણધર્મો

ફાઇલો લખવા માટે વપરાતા ક્લસ્ટરોને 2 થી શરૂ કરીને નંબર આપવામાં આવે છે. નિયમ પ્રમાણે, ક્લસ્ટર નંબર 2 નો ઉપયોગ રૂટ ડિરેક્ટરી દ્વારા કરવામાં આવે છે, અને ક્લસ્ટર નંબર 3 થી શરૂ કરીને ડેટા એરે સંગ્રહિત થાય છે. રૂટ ડાયરેક્ટરી ઉપર માહિતી સંગ્રહિત કરવા માટે વપરાતા ક્ષેત્રો ક્લસ્ટર થયેલ નથી.
ડિસ્ક પર જરૂરી ન્યૂનતમ ફાઇલ કદ 1 ક્લસ્ટરને અનુરૂપ છે.

બૂટ સેક્ટર નીચેની માહિતી સાથે શરૂ થાય છે:

• EB 58 90 - બિનશરતી કૂદકો અને સહી;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 - સેક્ટરમાં બાઈટની સંખ્યા (સામાન્ય રીતે 512);
• 1 બાઇટ - ક્લસ્ટરમાં સેક્ટરની સંખ્યા;
• 2 બાઇટ્સ - અનામત ક્ષેત્રોની સંખ્યા.

વધુમાં, બૂટ સેક્ટરમાં નીચેની મહત્વપૂર્ણ માહિતી શામેલ છે:

• 0x10 (1 બાઇટ) - FAT કોષ્ટકોની સંખ્યા (સામાન્ય રીતે 2);
• 0x20 (4 બાઇટ્સ) - ડિસ્ક પર સેક્ટરની સંખ્યા;
• 0x2С (4 બાઇટ્સ) - રૂટ ડાયરેક્ટરીનો ક્લસ્ટર નંબર;
• 0x47 (11 બાઇટ્સ) - વોલ્યુમ લેબલ;
• 0x1FE (2 બાઇટ્સ) - બૂટ સેક્ટર સિગ્નેચર (55 AA).

ફાઇલ સિસ્ટમ માહિતી ક્ષેત્રમાં શામેલ છે:

• 0x00 (4 બાઇટ્સ) - હસ્તાક્ષર (52 52 61 41);
• 0x1E4 (4 બાઇટ્સ) – સહી (72 72 41 61);
• 0x1E8 (4 બાઇટ્સ) - મફત ક્લસ્ટરોની સંખ્યા, -1 જો અજાણ્યા હોય;
• 0x1EC (4 બાઇટ્સ) - છેલ્લા રેકોર્ડ કરેલ ક્લસ્ટરની સંખ્યા;
• 0x1FE (2 બાઇટ્સ) - હસ્તાક્ષર (55 AA).

FAT કોષ્ટક ડિસ્ક પરના દરેક ક્લસ્ટરની સ્થિતિ વિશેની માહિતી ધરાવે છે. FAT ટેબલ સ્ટોરના નીચલા 2 બાઇટ્સ F8 FF FF 0F FF FF FF FF (જે ક્લસ્ટર 0 અને 1 ની સ્થિતિને અનુરૂપ છે, જે શારીરિક રીતે ગેરહાજર છે). આગળ, દરેક ક્લસ્ટરની સ્થિતિમાં વર્તમાન ફાઇલ ચાલુ રહે છે તે ક્લસ્ટરની સંખ્યા અથવા નીચેની માહિતી શામેલ છે:

• 00 00 00 00 - ક્લસ્ટર મફત છે;
• FF FF FF 0F - વર્તમાન ફાઇલનો અંત.

• 8 બાઇટ્સ - ફાઇલનું નામ;
• 3 બાઇટ્સ - ફાઇલ એક્સ્ટેંશન;

રૂટ ડાયરેક્ટરી દરેક ફાઇલ વિશે 32-બીટ માહિતી રેકોર્ડનો સમૂહ ધરાવે છે, જેમાં નીચેની માહિતી શામેલ છે:

સાથે કામ કરવાના કિસ્સામાં લાંબા નામોફાઇલો (રશિયન નામો સહિત), ફાઇલનું નામ UTF-16 એન્કોડિંગ સિસ્ટમમાં એન્કોડ થયેલ છે. આ કિસ્સામાં, દરેક અક્ષરને એન્કોડ કરવા માટે 2 બાઇટ્સ ફાળવવામાં આવે છે. આ કિસ્સામાં, ફાઇલનું નામ નીચેના બંધારણમાં લખાયેલું છે:

• 1 સિક્વન્સ બાઈટ;
• 10 બાઇટ્સ ફાઇલના નામના નીચેના 5 અક્ષરો ધરાવે છે;
• 1 બાઇટ વિશેષતા;
• 1 બાઈટ આરક્ષિત;
• 1 બાઇટ - ડોસ નામ ચેકસમ;
• 12 બાઇટ્સ ફાઇલના નામના નીચેના 3 અક્ષરો ધરાવે છે;
• 2 બાઇટ્સ - પ્રથમ ક્લસ્ટરની સંખ્યા;
• લાંબા નામના બાકીના અક્ષરો.

સી ભાષામાં ફાઇલો સાથે કામ કરવું

પ્રોગ્રામર માટે, ખુલ્લી ફાઇલને વાંચવા અથવા લખવામાં આવતા ડેટાના ક્રમ તરીકે રજૂ કરવામાં આવે છે. જ્યારે ફાઇલ ખોલવામાં આવે છે, તે સાથે સંકળાયેલ છે I/O સ્ટ્રીમ. આઉટપુટ માહિતી સ્ટ્રીમ પર લખવામાં આવે છે, ઇનપુટ માહિતી સ્ટ્રીમમાંથી વાંચવામાં આવે છે.

જ્યારે I/O માટે સ્ટ્રીમ ખોલવામાં આવે છે, ત્યારે તે પ્રમાણભૂત FILE માળખું સાથે સંકળાયેલું છે, જે stdio.h માં વ્યાખ્યાયિત થયેલ છે. FILE માળખું ફાઇલ વિશે જરૂરી માહિતી ધરાવે છે.

ફાઇલ ખોલવી એ fopen() ફંક્શનનો ઉપયોગ કરીને કરવામાં આવે છે, જે FILE સ્ટ્રક્ચરમાં પોઇન્ટર પરત કરે છે જેનો ઉપયોગ ફાઇલ પર અનુગામી કામગીરી માટે થઈ શકે છે.

FILE *fopen(નામ, પ્રકાર);

• "r" - વાંચવા માટે ફાઇલ ખોલો (ફાઇલ અસ્તિત્વમાં હોવી જોઈએ);
• "w" - લખવા માટે ખાલી ફાઇલ ખોલો; જો ફાઇલ અસ્તિત્વમાં છે, તો તેના સમાવિષ્ટો ખોવાઈ જશે;
• "a" - અંત સુધી લખવા માટે ફાઇલ ખોલો (જોડવા માટે); જો તે અસ્તિત્વમાં ન હોય તો ફાઇલ બનાવવામાં આવે છે;
• "r+" - વાંચવા અને લખવા માટે ફાઇલ ખોલો (ફાઇલ અસ્તિત્વમાં હોવી જોઈએ);
• "w+" - વાંચવા અને લખવા માટે ખાલી ફાઇલ ખોલો; જો ફાઇલ અસ્તિત્વમાં છે, તો તેના સમાવિષ્ટો ખોવાઈ જશે;
• "a+" - વાંચવા અને જોડવા માટે ફાઇલ ખોલો, જો ફાઇલ અસ્તિત્વમાં નથી, તો તે બનાવવામાં આવે છે.

વળતર મૂલ્ય ઓપન સ્ટ્રીમ માટે એક નિર્દેશક છે. જો કોઈ ભૂલ આવી હોય, તો NULL પરત કરવામાં આવે છે.

fclose() ફંક્શન fopen() ફંક્શનનો ઉપયોગ કરીને ખોલવામાં આવેલી ફાઇલો સાથે સંકળાયેલ સ્ટ્રીમ અથવા સ્ટ્રીમ્સને બંધ કરે છે. બંધ કરવાનો સ્ટ્રીમ fclose() ફંક્શનની દલીલ દ્વારા નક્કી થાય છે.

વળતર મૂલ્ય: મૂલ્ય 0 જો સ્ટ્રીમ સફળતાપૂર્વક બંધ થઈ ગઈ હોય; જો કોઈ ભૂલ આવી હોય તો સતત EOF.

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

# સમાવેશ થાય છે
int main() (
ફાઇલ *fp;
char name = "my.txt" ;
જો ((fp = fopen(નામ, "r")) == NULL )
{
printf( "ફાઇલ ખોલવામાં નિષ્ફળ");
getchar();
પરત 0;
}
// ફાઇલ ખોલવામાં સફળ
... // ડેટા પર જરૂરી ક્રિયાઓ
fclose(fp);
getchar();
પરત 0;
}

ફાઇલમાંથી અક્ષર વાંચવું:

char fgetc(સ્ટ્રીમ);

ફાઇલમાં પ્રતીક લખવું:

fputc(char, સ્ટ્રીમ);

ફંક્શનની દલીલો એક અક્ષર છે અને FILE પ્રકારના પ્રવાહ માટે નિર્દેશક છે. ફંક્શન રીડ કેરેક્ટરનો કોડ પરત કરે છે.

fscanf() અને fprintf() ફંક્શન્સ scanf() અને printf() ફંક્શન્સ જેવા જ છે, પરંતુ ડેટા ફાઈલો સાથે કામ કરે છે, અને તેમની પ્રથમ દલીલ તરીકે ફાઈલ માટે પોઈન્ટર હોય છે.

fscanf(સ્ટ્રીમ, "ઇનપુટફોર્મેટ", દલીલો);

પહેલાં, ડેટા ઇનપુટ અને આઉટપુટ કરતી વખતે, અમે માનક સ્ટ્રીમ્સ - કીબોર્ડ અને મોનિટર સાથે કામ કર્યું હતું. હવે ચાલો જોઈએ કે સી લેંગ્વેજ કેવી રીતે ફાઈલોમાંથી ડેટા મેળવવા અને તેને ત્યાં લખવાનું અમલીકરણ કરે છે. તમે આ ક્રિયાઓ કરી શકો તે પહેલાં, તમારે ફાઇલ ખોલવી અને તેને ઍક્સેસ કરવી આવશ્યક છે.

સી પ્રોગ્રામિંગ લેંગ્વેજમાં, ફાઈલનું પોઈન્ટર FILE પ્રકારનું હોય છે અને તેની ઘોષણા આના જેવી દેખાય છે:
FILE *myfile;

બીજી બાજુ, fopen() ફંક્શન રીડ મોડ ("r"), રાઇટ મોડ ("w"), અથવા એપેન્ડ મોડ ("a")માં પ્રથમ દલીલ તરીકે ઉલ્લેખિત સરનામા પર ફાઇલ ખોલે છે અને એક પોઇન્ટર પરત કરે છે. તે માટે કાર્યક્રમ માટે. તેથી, ફાઇલ ખોલવાની અને તેને પ્રોગ્રામ સાથે કનેક્ટ કરવાની પ્રક્રિયા કંઈક આના જેવી લાગે છે:
myfile = fopen("hello.txt", "r");

ફાઇલમાં ડેટા વાંચતી વખતે અથવા લખતી વખતે, તેને ફાઇલ પોઇન્ટર દ્વારા એક્સેસ કરવામાં આવે છે (આ કિસ્સામાં, માયફાઇલ).

જો એક અથવા બીજા કારણસર (ઉલ્લેખિત સરનામાં પર કોઈ ફાઇલ નથી, તેની ઍક્સેસ નકારી છે) fopen() ફંક્શન ફાઇલ ખોલી શકતું નથી, તો તે NULL પરત કરે છે. વાસ્તવિક કાર્યક્રમોમાં, તેઓ લગભગ હંમેશા if શાખામાં ફાઇલ ખોલવાની ભૂલને હેન્ડલ કરે છે, પરંતુ અમે તેને આગળ છોડી દઈશું.

fopen() ફંક્શન ડિક્લેરેશન stdio.h હેડર ફાઈલમાં સમાયેલ છે, તેથી તેનો સમાવેશ થવો જોઈએ. stdio.h માં પણ બંધારણ પ્રકાર FILE જાહેર કરવામાં આવે છે.

ફાઇલ સાથે કામ પૂર્ણ થયા પછી, બફરને ડેટામાંથી મુક્ત કરવા અને અન્ય કારણોસર તેને બંધ કરવાનો રિવાજ છે. આ ખાસ કરીને મહત્વનું છે જો પ્રોગ્રામ ફાઇલ સાથે કામ કર્યા પછી ચાલુ રહે. એક્સટર્નલ ફાઈલ અને પ્રોગ્રામમાંથી તેને પોઈન્ટર વચ્ચેનું કનેક્શન તોડવું fclose() ફંક્શનનો ઉપયોગ કરીને કરવામાં આવે છે. ફાઇલ માટે એક નિર્દેશક તેને પરિમાણ તરીકે પસાર કરવામાં આવે છે:
fclose(myfile);

પ્રોગ્રામમાં એક કરતાં વધુ ફાઇલો ખોલી શકાય છે. આ કિસ્સામાં, દરેક ફાઇલ તેના પોતાના ફાઇલ પોઇન્ટર સાથે સંકળાયેલ હોવી આવશ્યક છે. જો કે, જો પ્રોગ્રામ પહેલા એક ફાઇલ સાથે કામ કરે છે અને પછી તેને બંધ કરે છે, તો પછી બીજી ફાઇલ ખોલવા માટે પોઇન્ટરનો ઉપયોગ કરી શકાય છે.

ટેક્સ્ટ ફાઇલમાંથી વાંચવું અને લખવું

fscanf()

fscanf() ફંક્શન એ scanf() ફંક્શનના અર્થમાં સમાન છે, પરંતુ તેનાથી વિપરીત, તે પ્રમાણભૂત ઇનપુટ સ્ટ્રીમને બદલે ફાઇલમાંથી ફોર્મેટ કરેલ ઇનપુટ પ્રદાન કરે છે. fscanf() ફંક્શન પરિમાણો લે છે: ફાઇલ પોઇન્ટર, ફોર્મેટ સ્ટ્રિંગ, ડેટા લખવા માટે મેમરી વિસ્તારોના સરનામાં:
fscanf(myfile, "%s%d", str, &a);

સફળતાપૂર્વક વાંચેલા ડેટા અથવા EOFની સંખ્યા પરત કરે છે. સ્પેસ અને ન્યુલાઇન અક્ષરોની ગણતરી ડેટા સીમાંકક તરીકે કરવામાં આવે છે.

ચાલો કહીએ કે અમારી પાસે એક ફાઇલ છે જેમાં ઑબ્જેક્ટનું નીચેનું વર્ણન છે:

સફરજન 10 23.4 કેળા 5 25.0 બ્રેડ 1 10.3

# સમાવેશ થાય છે મુખ્ય () ( ફાઇલ * ફાઇલ; સ્ટ્રક્ટ ફૂડ ( ચાર નામ[ 20 ] ; સહી ન કરેલ જથ્થો; ફ્લોટ કિંમત ); "%s %u %.2f \n", દુકાન[ i].નામ, દુકાન[ i].qty, દુકાન[ i]. કિંમત);

i++;

))

આ કિસ્સામાં, એક માળખું અને માળખાઓની શ્રેણી જાહેર કરવામાં આવે છે. ફાઇલમાંથી દરેક લાઇન એરેના એક ઘટકને અનુલક્ષે છે; એરે એલિમેન્ટ એ એક માળખું છે જેમાં એક સ્ટ્રિંગ અને બે આંકડાકીય ક્ષેત્રો છે. લૂપ પુનરાવર્તન દીઠ એક પંક્તિ વાંચે છે. જ્યારે ફાઇલનો અંત આવે છે, ત્યારે fscanf() EOF પરત કરે છે અને લૂપ સમાપ્ત થાય છે.
fgets()

fgets() ફંક્શન gets() ફંક્શન જેવું જ છે અને ફાઇલમાંથી લાઇન-બાય-લાઇન ઇનપુટ કરે છે. fgets() ને એક કોલ એક લાઇન વાંચશે. આ કિસ્સામાં, તમે આખી લીટી વાંચી શકતા નથી, પરંતુ શરૂઆતથી તેનો માત્ર એક ભાગ. fgets() પરિમાણો આના જેવા દેખાય છે:
fgets (અક્ષર_એરે, નંબર_ઓફ_કેરેક્ટર્સ_રીડ, પોઇન્ટર_ટુ_ફાઇલ)

ઉદાહરણ તરીકે:

# સમાવેશ થાય છે fgets(str, 50, myfile) \n"આ ફંક્શન કૉલ myfile પોઇન્ટર સાથે સંકળાયેલ ફાઇલમાંથી ટેક્સ્ટની એક સંપૂર્ણ લાઇન વાંચશે જો તેની લંબાઈ 50 અક્ષરો કરતાં ઓછી હોય, જેમાં "\n" અક્ષરનો સમાવેશ થાય છે, જેને ફંક્શન એરેમાં પણ સંગ્રહિત કરશે. str એરેનું છેલ્લું (50મું) ઘટક fgets() દ્વારા ઉમેરવામાં આવેલ "\0" અક્ષર હશે. જો શબ્દમાળા લાંબી હોય, તો ફંક્શન 49 અક્ષરો વાંચશે અને અંતે "\0" લખશે. આ કિસ્સામાં, "\n" રીડ લાઇનમાં સમાવિષ્ટ થશે નહીં.

# વ્યાખ્યાયિત કરો N 80 મુખ્ય () ( FILE * ફાઇલ; char arr[ N] ; file = fopen ("fscanf.txt" , "r" ) ; જ્યારે (fgets (arr, N, ફાઇલ) != NULL) printf (" %s" , arr) ; printf ("

);

fclose(ફાઇલ);

) \n"આ પ્રોગ્રામમાં, અગાઉના પ્રોગ્રામથી વિપરીત, એરે એરેમાં ડેટાને વાક્ય દ્વારા વાંચવામાં આવે છે. જ્યારે આગલી લાઇન વાંચવામાં આવે છે, ત્યારે પાછલી એક ખોવાઈ જાય છે. fgets() ફંક્શન NULL પરત કરે છે જો તે આગલી લાઇન વાંચી શકતું નથી. \0 " getc() અથવા fgetc() \n" getc() અથવા fgetc() ફંક્શન (બંને કાર્ય) તમને ફાઇલમાંથી આગલું એક અક્ષર મેળવવા માટે પરવાનગી આપે છે. \0 " getc() અથવા fgetc() \n"જ્યારે ((arr[ i] = fgetc (ફાઇલ)) != EOF) ( જો (arr[ i] == "

) (arr[i] = "

;

printf("%s

• , arr) ;
• પોસ્ટ-બાય-લાઇન આઉટપુટ. ફંક્શન fputs(સ્ટ્રિંગ, ફાઇલ_પોઇન્ટર).
• અક્ષર-દર-પાત્ર આઉટપુટ. ફંક્શન fputc() અથવા putc(symbol, file_pointer) .

નીચે કોડ ઉદાહરણો છે જે ફાઇલમાં ડેટા આઉટપુટ કરવાની ત્રણ પદ્ધતિઓનો ઉપયોગ કરે છે.

ફાઇલની દરેક લાઇન પર એક સ્ટ્રક્ચરના ક્ષેત્રો લખવા:

file = fopen ("fprintf.txt" , "w" ); \n"જ્યારે (scanf ("%s%u%f" , દુકાન[ i]. નામ , & (દુકાન[ i].qty ) , & (દુકાન[ i]. કિંમત ) != EOF) ( fprintf (ફાઇલ, " %s %u %.2f

, દુકાન[ i].નામ, દુકાન[ i].qty, દુકાન[ i]. કિંમત);

i++; \n")

ફાઇલમાં લાઇન-બાય-લાઇન આઉટપુટ (fputs(), puts()થી વિપરીત, લાઇનના અંતે “\n” મૂકતું નથી):

જ્યારે (ગેટ્સ (અરર) != NULL) ( fputs (arr, file); fputs ("

, ફાઇલ);

)

અક્ષર-દર-પાત્ર આઉટપુટનું ઉદાહરણ:

જ્યારે ((i = getchar () ) != EOF) putc (i, ફાઇલ);

દ્વિસંગી ફાઇલમાંથી વાંચવું અને લખવું

1. તમે ફાઇલ સાથે અક્ષરોના ક્રમ તરીકે નહીં, પરંતુ બાઇટ્સના ક્રમ તરીકે કામ કરી શકો છો. સૈદ્ધાંતિક રીતે, બિન-ટેક્સ્ટ ફાઇલો સાથે અન્ય કોઈપણ રીતે કામ કરવું શક્ય નથી. જો કે, તમે આ રીતે ટેક્સ્ટ ફાઇલો વાંચી અને લખી શકો છો. ફાઇલને ઍક્સેસ કરવાની આ પદ્ધતિનો ફાયદો એ વાંચવાની-લખવાની ઝડપ છે: માહિતીનો નોંધપાત્ર બ્લોક એક ઍક્સેસમાં વાંચી/લખી શકાય છે.
2. બાઈનરી એક્સેસ માટે ફાઈલ ખોલતી વખતે, fopen() માટેનું બીજું પેરામીટર "rb" અથવા "wb" છે.
3. દ્વિસંગી ફાઇલો સાથે કામ કરવાનો વિષય ખૂબ જટિલ છે અને અભ્યાસ કરવા માટે એક અલગ પાઠની જરૂર છે. અહીં ફક્ત બાઈટ સ્ટ્રીમ તરીકે ગણવામાં આવતી ફાઈલને વાંચવા અને લખવાના કાર્યોની વિશેષતાઓ નોંધવામાં આવશે.
4. fread() અને fwrite() ફંક્શન પરિમાણો તરીકે લે છે:

મેમરી વિસ્તારનું સરનામું જ્યાંથી ડેટા લખવામાં આવે છે અથવા વાંચવામાં આવે છે,

આપેલ એક પ્રકારનું કદ,

# સમાવેશ થાય છે ઉલ્લેખિત કદના વાંચેલા ડેટાની માત્રા, ફાઇલ ઇન્ડેક્સ. \0 " આ કાર્યો સફળતાપૂર્વક વાંચેલા અથવા લખેલા ડેટાની સંખ્યા પરત કરે છે. તે. તમે 50 ડેટા ઘટકોના વાંચનને "ઓર્ડર" કરી શકો છો, પરંતુ ફક્ત 10 પ્રાપ્ત કરો. કોઈ ભૂલ હશે નહીં. \n" fread() અને fwrite() ફંક્શનનો ઉપયોગ કરવાનું ઉદાહરણ: \0 " # સમાવેશ થાય છે

અહીં પ્રથમ ફાઇલમાંથી 50 અક્ષરો વાંચવાનો પ્રયાસ કરવામાં આવ્યો છે. n વાસ્તવમાં વાંચેલા અક્ષરોની સંખ્યાને સંગ્રહિત કરે છે. n ની કિંમત 50 કે તેથી ઓછી હોઈ શકે છે. ડેટા એક પંક્તિમાં મૂકવામાં આવે છે. આ જ વસ્તુ બીજી ફાઇલ સાથે થાય છે. આગળ, પ્રથમ લાઇન બીજી સાથે જોડવામાં આવે છે, અને ડેટાને ત્રીજી ફાઇલમાં ડમ્પ કરવામાં આવે છે.

સમસ્યાનું નિરાકરણ

1. એક પ્રોગ્રામ લખો જે વપરાશકર્તાને ટેક્સ્ટ ફાઇલનું નામ (સરનામું) પૂછે છે, પછી તેને ખોલે છે અને તેમાં અક્ષરો અને રેખાઓની સંખ્યા ગણે છે.
2. એક પ્રોગ્રામ લખો જે બીજી ફાઇલમાંથી મેળવેલી ફાઇલ ડેટા પર લખે છે અને લખતા પહેલા અમુક રીતે ફેરફાર કરે છે. ફાઇલમાંથી મેળવેલા ડેટાની દરેક લાઇન માળખામાં ફિટ હોવી જોઈએ.

ટૅગ્સ: ટેક્સ્ટ ફાઇલો, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, બફર કરેલ સ્ટ્રીમ, અનબફર્ડ સ્ટ્રીમ.

ટેક્સ્ટ ફાઇલો સાથે કામ કરો

ટેક્સ્ટ ફાઇલ સાથે કામ કરવું એ કન્સોલ સાથે કામ કરવા જેવું જ છે: ફોર્મેટ કરેલા ઇનપુટ ફંક્શનનો ઉપયોગ કરીને અમે ફાઇલમાં ડેટા સાચવીએ છીએ, ફોર્મેટ કરેલા આઉટપુટ ફંક્શનનો ઉપયોગ કરીને અમે ફાઇલમાંથી ડેટા વાંચીએ છીએ. ત્યાં ઘણી ઘોંઘાટ છે જે આપણે પછીથી જોઈશું. મુખ્ય કામગીરી જે કરવાની જરૂર છે તે છે

• 1. ફાઇલ ખોલો જેથી કરીને તેને એક્સેસ કરી શકાય. તદનુસાર, તમે તેને વાંચવા, લખવા, વાંચવા અને લખવા, ફરીથી લખવા અથવા ફાઇલના અંત સુધી લખવા વગેરે માટે ખોલી શકો છો. જ્યારે તમે ફાઇલ ખોલો છો, ત્યારે ઘણી બધી ભૂલો પણ થઈ શકે છે - ફાઇલ અસ્તિત્વમાં ન હોઈ શકે, તે ખોટી ફાઇલ પ્રકાર હોઈ શકે, તમને ફાઇલ સાથે કામ કરવાની પરવાનગી ન હોય, વગેરે. આ બધું ધ્યાનમાં લેવું આવશ્યક છે.
• 2. ફાઇલ સાથે સીધી રીતે કામ કરવું - લખવું અને વાંચવું. અહીં આપણે એ પણ યાદ રાખવાની જરૂર છે કે આપણે રેન્ડમ એક્સેસ મેમરી સાથે કામ નથી કરી રહ્યા, પરંતુ બફર કરેલ સ્ટ્રીમ સાથે, જે તેની પોતાની વિશિષ્ટતાઓ ઉમેરે છે.
• 3. ફાઇલ બંધ કરો. ફાઈલ એ પ્રોગ્રામનો બાહ્ય સંસાધન હોવાથી, જો તે બંધ ન હોય, તો તે મેમરીમાં અટકવાનું ચાલુ રાખશે, સંભવતઃ પ્રોગ્રામ બંધ થઈ ગયા પછી પણ (ઉદાહરણ તરીકે, ખુલ્લી ફાઇલને કાઢી નાખવી અથવા ફેરફારો કરવા શક્ય નહીં હોય, વગેરે). વધુમાં, કેટલીકવાર તે બંધ ન કરવું જરૂરી છે, પરંતુ ક્રમમાં ફાઇલને "ફરીથી ખોલવા" માટે, ઉદાહરણ તરીકે, ઍક્સેસ મોડ બદલવા માટે.

આ ઉપરાંત, જ્યારે અમને ફાઇલની સામગ્રીને ઍક્સેસ કરવાની જરૂર હોતી નથી ત્યારે સંખ્યાબંધ કાર્યો છે: નામ બદલવું, ખસેડવું, કૉપિ કરવું વગેરે. કમનસીબે, C ધોરણમાં આ જરૂરિયાતો માટેના કાર્યોનું વર્ણન નથી. તેઓ, અલબત્ત, દરેક કમ્પાઇલર અમલીકરણ માટે ઉપલબ્ધ છે. ડિરેક્ટરી (ફોલ્ડર, ડિરેક્ટરી) ની સામગ્રીઓ વાંચવી એ પણ ફાઇલને ઍક્સેસ કરે છે, કારણ કે ફોલ્ડર પોતે મેટેનફોર્મેશન સાથેની ફાઇલ છે.

કેટલીકવાર કેટલીક સહાયક કામગીરી કરવી જરૂરી છે: ફાઇલમાં ઇચ્છિત સ્થાન પર ખસેડો, યાદ રાખો વર્તમાન પરિસ્થિતિ, ફાઇલની લંબાઈ નક્કી કરો, વગેરે.

ફાઇલ સાથે કામ કરવા માટે, તમારે FILE ઑબ્જેક્ટની જરૂર છે. આ ઑબ્જેક્ટ ફાઇલ સ્ટ્રીમના ઓળખકર્તા અને તેને સંચાલિત કરવા માટે જરૂરી માહિતીને સંગ્રહિત કરે છે, જેમાં તેના બફર માટે નિર્દેશક, ફાઇલ સ્થિતિ સૂચક અને સ્થિતિ સૂચકનો સમાવેશ થાય છે.

FILE ઑબ્જેક્ટ પોતે જ એક માળખું છે, પરંતુ તેના ફીલ્ડ્સને ઍક્સેસ કરવું જોઈએ નહીં. પોર્ટેબલ પ્રોગ્રામે ફાઇલને અમૂર્ત ઑબ્જેક્ટ તરીકે ગણવી જોઈએ જે ફાઇલ સ્ટ્રીમને ઍક્સેસ કરવાની મંજૂરી આપે છે.

FILE પ્રકારના ઑબ્જેક્ટ માટે મેમરીનું નિર્માણ અને ફાળવણી fopen અથવા tmpfile ફંક્શનનો ઉપયોગ કરીને હાથ ધરવામાં આવે છે (અન્ય પણ છે, પરંતુ અમે ફક્ત તેના પર ધ્યાન કેન્દ્રિત કરીશું).

ફોપેન ફંક્શન ફાઇલ ખોલે છે. તે બે દલીલો મેળવે છે - ફાઇલ સરનામા સાથેની સ્ટ્રિંગ અને ફાઇલ એક્સેસ મોડ સાથેની સ્ટ્રિંગ. ફાઇલનું નામ સંપૂર્ણ અથવા સંબંધિત હોઈ શકે છે. fopen એ FILE ઑબ્જેક્ટ પર પોઇન્ટર પરત કરે છે જેનો ઉપયોગ ફાઇલને વધુ ઍક્સેસ કરવા માટે થઈ શકે છે.

FILE* fopen(const char* ફાઇલનામ, const char* મોડ);

ઉદાહરણ તરીકે, ચાલો એક ફાઈલ ખોલીએ અને તેમાં Hello World લખીએ

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( //ફાઈલ વેરીએબલનો ઉપયોગ કરીને આપણે ફાઈલ FILE *ફાઈલને એક્સેસ કરીશું; // લખવાની પરવાનગી સાથે ટેક્સ્ટ ફાઈલ ખોલો ફાઈલ = fopen("C:/c/test.txt", "w+t") ;//ફાઈલ fprintf પર લખો (ફાઈલ, "હેલો, વર્લ્ડ!" //ફાઈલ બંધ કરો);

ફોપેન ફંક્શન પોતે જ ઑબ્જેક્ટ માટે મેમરી ફાળવે છે; સફાઈ fclose ફંક્શન દ્વારા કરવામાં આવે છે. ફાઇલને બંધ કરવી જરૂરી છે તે તેના પોતાના પર બંધ થશે નહીં.

ફોપેન ફંક્શન ફાઇલને ટેક્સ્ટ અથવા બાઈનરી મોડમાં ખોલી શકે છે. મૂળભૂત ટેક્સ્ટ છે. ઍક્સેસ મોડ નીચે મુજબ હોઈ શકે છે

જો ફાઇલને બાઈનરી મોડમાં ખોલવી જરૂરી હોય, તો પછી લીટીના અંતમાં અક્ષર b ઉમેરવામાં આવે છે, ઉદાહરણ તરીકે "rb", "wb", "ab", અથવા, મિશ્ર મોડ માટે, "ab+", " wb+”, “ab+”. b ને બદલે, તમે અક્ષર t ઉમેરી શકો છો, પછી ફાઇલ ટેક્સ્ટ મોડમાં ખુલશે. તે અમલીકરણ પર આધાર રાખે છે. નવા સી સ્ટાન્ડર્ડ (2011) માં, અક્ષર x નો અર્થ છે કે જો ફાઇલ પહેલેથી અસ્તિત્વમાં હોય તો ફોપેન નિષ્ફળ થવો જોઈએ. ચાલો આપણું પૂરક કરીએ જૂનો કાર્યક્રમ: ચાલો ફાઈલ ફરીથી ખોલીએ અને આપણે ત્યાં શું લખ્યું તે ધ્યાનમાં લઈએ.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(ફાઇલ, "હેલો, વર્લ્ડ!"); fclose(ફાઇલ); ફાઇલ = fopen("C:/c/test.txt", "r"); printf("%s", buffer(file);

fgets ફંક્શનને બદલે, તમે fscanf નો ઉપયોગ કરી શકો છો, પરંતુ તમારે યાદ રાખવાની જરૂર છે કે તે ફક્ત પ્રથમ જગ્યા સુધીની લાઇન વાંચી શકે છે.
fscanf(ફાઇલ, "%127s", બફર);

ઉપરાંત, ફાઇલ ખોલવા અને બંધ કરવાને બદલે, તમે ફ્રીઓપન ફંક્શનનો ઉપયોગ કરી શકો છો, જે નવા ઍક્સેસ અધિકારો સાથે ફાઇલને "ફરીથી ખોલે છે".

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(ફાઇલ, "હેલો, વર્લ્ડ!"); ફ્રીઓપન("C:/ c/test.txt", "r", file); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch();)

ફંક્શન fprintf અને fscanf માત્ર printf અને scanf થી અલગ પડે છે કે તેઓ તેમની પ્રથમ દલીલ તરીકે FILE માટે નિર્દેશક લે છે જેમાં તેઓ આઉટપુટ કરશે અથવા જેમાંથી તેઓ ડેટા વાંચશે. તે તરત જ ઉમેરવા યોગ્ય છે કે printf અને scanf ફંક્શનને સરળતાથી fprintf અને fscanf ફંક્શન દ્વારા બદલી શકાય છે. OS માં (અમે સૌથી સામાન્ય અને પર્યાપ્ત ગણીએ છીએ ઓપરેટિંગ સિસ્ટમ્સ) ત્યાં ત્રણ પ્રમાણભૂત પ્રવાહો છે: પ્રમાણભૂત આઉટપુટ stdout, પ્રમાણભૂત ઇનપુટ stdin અને પ્રમાણભૂત ભૂલ આઉટપુટ stderr. જ્યારે એપ્લિકેશન લોંચ કરવામાં આવે ત્યારે તે આપમેળે ખોલવામાં આવે છે અને કન્સોલ સાથે સંકળાયેલા હોય છે. ઉદાહરણ

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( int a, b; fprintf(stdout, "Enter two numbers\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); જો (b) == 0) ( fprintf(stderr, "ભૂલ: શૂન્ય દ્વારા ભાગાકાર"); ) અન્ય ( fprintf(stdout, "%.3f", (float) a / (float) b); ) getch();

ફાઇલ ખોલવામાં ભૂલ

જો fopen ફંક્શન કૉલ નિષ્ફળ જાય, તો તે NULL પરત કરશે. ફાઇલો સાથે કામ કરતી વખતે ભૂલો ઘણી વાર થાય છે, તેથી જ્યારે પણ આપણે ફાઇલ ખોલીએ છીએ, ત્યારે અમારે કાર્યનું પરિણામ તપાસવાની જરૂર છે.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # define ERROR_OPEN_FILE -3 void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); if (file == NULL) ( printf("ખોલવામાં ભૂલ ફાઇલ"); getch(); બહાર નીકળો(ERROR_OPEN_FILE); ) fprintf(ફાઇલ, "હેલો, વર્લ્ડ!"); ફ્રીઓપન("C:/c/test.txt", "r", ફાઇલ); જો (ફાઇલ = = NULL) ( printf("ફાઈલ ખોલવામાં ભૂલ"); getch(); exit(ERROR_OPEN_FILE); ) fgets(buffer, 127, file); printf("%s", buffer(file); )

સમસ્યા ત્યારે ઊભી થાય છે જ્યારે ઘણી ફાઇલો એકસાથે ખોલવામાં આવે છે: જો તેમાંથી એક ખોલી શકાતી નથી, તો બાકીની પણ બંધ કરવી આવશ્યક છે.

FILE *inputFile, *outputFile;

સહી વિનાનું m, n; સહી વિનાનું i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); જો (inputFile == NULL) ( printf("ફાઈલ %s ખોલવામાં ભૂલ", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY);જો (આઉટપુટફાઇલ == NULL) ( printf("ફાઇલ %s ખોલવામાં ભૂલ", OUTPUT_FILE); getch(); if (inputFile != NULL) ( fclose(inputFile); ) exit(4); ) ...

IN

સરળ કેસો

• કોડના પાછલા ભાગની જેમ તમે હેડ-ઓન કાર્ય કરી શકો છો. વધુ માં
• મુશ્કેલ કેસો
• પદ્ધતિઓનો ઉપયોગ કરવામાં આવે છે જે C++ થી RAII ને બદલે છે: રેપર્સ, અથવા કમ્પાઈલર સુવિધાઓ (GCC માં સફાઈ), વગેરે.
• ડેટા બફરિંગ

અગાઉ સૂચવ્યા મુજબ, જ્યારે આપણે ડેટા આઉટપુટ કરીએ છીએ, ત્યારે તે પ્રથમ બફરમાં મૂકવામાં આવે છે. બફર સાફ થાય છે

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે 1) જો તે ભરેલું હોય

2) જો પ્રવાહ બંધ હોય

3) જો આપણે સ્પષ્ટપણે સૂચવીએ કે બફરને સાફ કરવું જરૂરી છે (અહીં પણ અપવાદો છે :)).

4) જો પ્રોગ્રામ સફળતાપૂર્વક પૂર્ણ થયો હોય તો તે પણ સાફ. તે જ સમયે, બધી ફાઇલો બંધ છે. રનટાઇમ ભૂલના કિસ્સામાં, આ ન થઈ શકે.

જે પહેલાથી જ ખુલ્લી FILE અને નવા બફર માટે નિર્દેશક લે છે. નવા બફરનું કદ BUFSIZ કરતાં ઓછું ન હોવું જોઈએ (ઉદાહરણ તરીકે, વર્તમાન વર્કસ્ટેશન પર BUFSIZ 512 બાઇટ્સ છે). જો તમે NULL ને બફર તરીકે પાસ કરો છો, તો સ્ટ્રીમ અનબફર થઈ જશે. તમે ફંક્શનનો પણ ઉપયોગ કરી શકો છો

Int setvbuf(FILE * સ્ટ્રીમ, char * બફર, int મોડ, size_t કદ);

જે મનસ્વી કદના કદના બફરને સ્વીકારે છે. મોડ નીચેના મૂલ્યો લઈ શકે છે

• _IOFBF- સંપૂર્ણ બફરિંગ. જ્યારે ફાઇલ ભરાઈ જાય ત્યારે ડેટા લખવામાં આવે છે. વાંચવા પર, જ્યારે ઇનપુટ ઑપરેશનની વિનંતી કરવામાં આવે અને બફર ખાલી હોય ત્યારે બફરને ભરેલું ગણવામાં આવે છે.
• _IOLBF- રેખીય બફરિંગ. ડેટા ફાઇલમાં લખવામાં આવે છે જ્યારે તે ભરાઈ જાય છે અથવા જ્યારે નવી લાઇન અક્ષરનો સામનો કરવામાં આવે છે. વાંચવા પર, જ્યારે ઇનપુટ ઑપરેશનની વિનંતી કરવામાં આવે અને બફર ખાલી હોય ત્યારે બફર નવી લાઇન અક્ષરમાં ભરવામાં આવે છે.
• _IONBF- કોઈ બફરિંગ નથી. આ કિસ્સામાં, કદ અને બફર પરિમાણો અવગણવામાં આવે છે.

ઉદાહરણ: ચાલો આપણું પોતાનું બફર સેટ કરીએ અને જોઈએ કે ફાઇલમાંથી વાંચન કેવી રીતે થાય છે. ફાઇલને ટૂંકી થવા દો (હેલો, વર્લ્ડ જેવું કંઈક!), અને આપણે તેને અક્ષર પ્રમાણે વાંચીએ છીએ

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *input = NULL; char c; char buffer = (0); input = fopen("D:/c/text.txt", "rt"); setbuf(input, buffer); જ્યારે ( !feof(ઇનપુટ)) ( c = fgetc(ઇનપુટ); printf("%c\n", c); printf("%s\n", બફર); _getch(); ) fclose(ઇનપુટ )

તે જોઈ શકાય છે કે ડેટા પહેલેથી જ બફરમાં છે. અક્ષર દ્વારા અક્ષર વાંચન બફરમાંથી કરવામાં આવે છે.

feof

ફંક્શન int feof(FILE * સ્ટ્રીમ); જો ફાઇલના અંત સુધી પહોંચી ગયા હોય તો સાચું પરત કરે છે. જ્યારે તમારે શરૂઆતથી અંત સુધી સમગ્ર ફાઇલમાંથી પસાર થવાની જરૂર હોય ત્યારે આ ફંક્શન વાપરવા માટે અનુકૂળ છે. ટેક્સ્ટ સામગ્રી text.txt સાથે એક ફાઇલ રહેવા દો. અમે અક્ષર દ્વારા ફાઇલ અક્ષર વાંચીએ છીએ અને તેને સ્ક્રીન પર પ્રદર્શિત કરીએ છીએ.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) ( printf("ફાઈલ ખોલવામાં ભૂલ") ; _getch(); જ્યારે (!feof(input)) ( c = fgetc(input); fprintf(stdout, "%c", c); ) fclose(input());

બધું બરાબર હશે, પરંતુ feof ફંક્શન યોગ્ય રીતે કામ કરતું નથી... આ એ હકીકતને કારણે છે કે "ફાઇલનો અંત" ની વિભાવના વ્યાખ્યાયિત નથી. feof નો ઉપયોગ કરતી વખતે એક ભૂલ જે વારંવાર થાય છે તે એ છે કે વાંચવામાં આવેલ છેલ્લો ડેટા બે વાર છાપવામાં આવે છે. આ એ હકીકતને કારણે છે કે ડેટા ઇનપુટ બફર પર લખવામાં આવે છે, છેલ્લું વાંચન ભૂલ સાથે થાય છે અને ફંક્શન જૂની કિંમત વાંચે છે.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) ( printf("ફાઈલ ખોલવામાં ભૂલ") ; _getch(0); જ્યારે (!feof(input)) ( fscanf(input, "%c", &c); fprintf(stdout, "%c", c); ();

આ ઉદાહરણ નિષ્ફળ જશે (મોટે ભાગે) અને ફાઇલના છેલ્લા અક્ષરને બે વાર છાપશે.

ઉકેલ એ છે કે ફીઓફનો ઉપયોગ ન કરવો. ઉદાહરણ તરીકે, સ્ટોર કરો કુલ જથ્થોરેકોર્ડ કરે છે અથવા એ હકીકતનો ઉપયોગ કરે છે કે fscanf વગેરે ફંક્શન સામાન્ય રીતે યોગ્ય રીતે વાંચેલા અને મેળ ખાતા મૂલ્યોની સંખ્યા પરત કરે છે.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) ( printf("ફાઈલ ખોલવામાં ભૂલ") ; _getch(0); જ્યારે (fscanf(input, "%c", &c) == 1) (fprintf(stdout, "%c", c); )

ઉદાહરણો

1. એક ફાઇલમાં બે સંખ્યાઓ છે - એરેના પરિમાણો. ચાલો બીજી ફાઇલને રેન્ડમ નંબરોની એરે સાથે ભરીએ.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે //ફાઈલ નામો અને પરવાનગીઓ #define INPUT_FILE "D:/c/input.txt" # define OUTPUT_FILE "D:/c/output.txt" # વ્યાખ્યાયિત કરો READ_ONLY "r" # વ્યાખ્યાયિત કરો WRITE_ONLY "w" // એરે માટે મહત્તમ મૂલ્ય માપ #define MAX_DIMENSION 100 //ફાઈલ ખોલતી વખતે ભૂલ #define ERROR_OPEN_FILE -3 void main() ( FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, જો); inputFile == NULL) ( printf("ફાઈલ %s ખોલવામાં ભૂલ", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY) જો (આઉટપુટફાઈલ == NULL) ( printf("ભૂલ); ફાઇલ ખોલી રહ્યું છે %s", OUTPUT_FILE); getch(); // જો ફાઇલ વાંચવા માટે ખોલી શકાતી હોય, તો તે બંધ કરવી જ જોઇએ જો (inputFile != NULL) ( fclose(inputFile); ) exit(ERROR_OPEN_FILE); ) fscanf (inputFile, "%ud %ud", &m, &n); જો (m > MAX_DIMENSION; ) જો (n > MAX_DIMENSION) ( n = MAX_DIMENSION; ) srand(time(NULL));< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. વપરાશકર્તા ફાઇલની નકલ કરે છે, અને પ્રથમ ઓપરેટિંગ મોડ પસંદ કરે છે: ફાઇલ કાં તો કન્સોલ પર આઉટપુટ કરી શકાય છે અથવા નવી ફાઇલમાં કૉપિ કરી શકાય છે.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # ERROR_FILE_OPEN -3 void main() વ્યાખ્યાયિત કરો ( FILE *origin = NULL; FILE *output = NULL; char filename; int mode; printf("Enter filename:"); scanf("%1023s", filename); origin = fopen (ફાઇલનામ, "r" જો (મૂળ == NULL) ( printf("ફાઇલ %s ખોલવામાં ભૂલ", ફાઇલનામ); getch(); exit(ERROR_FILE_OPEN); ) printf("enter mode: "%); d", &mode); if (mode == 1) ( printf("Enter filename: "); scanf("%1023s", filename); output = fopen(filename, "w"); if (output == NULL ) ( printf("ફાઇલ %s ખોલવામાં ભૂલ", ફાઇલનામ); getch(); fclose(origin); exit(ERROR_FILE_OPEN); ) ) બીજું (આઉટપુટ = stdout; ) જ્યારે (!feof(origin)) ( fprintf (આઉટપુટ) , "%c", fgetc(origin) fclose(origin);

3. વપરાશકર્તા કન્સોલમાંથી ડેટા દાખલ કરે છે અને જ્યાં સુધી esc કી દબાવવામાં ન આવે ત્યાં સુધી તે ફાઇલમાં લખવામાં આવે છે. પ્રોગ્રામ તપાસો અને જુઓ. જો તમે બેકસ્પેસ દાખલ કરો તો તે કેવી રીતે વર્તે છે: ફાઇલનું આઉટપુટ શું છે અને કન્સોલનું આઉટપુટ શું છે.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # ERROR_FILE_OPEN -3 void main() વ્યાખ્યાયિત કરો ( FILE *output = NULL; char c; આઉટપુટ = fopen("D:/c/test_output.txt", "w+t"); જો (આઉટપુટ == NULL) ( printf ("ફાઇલ ખોલવામાં ભૂલ"); બહાર નીકળો(ERROR_FILE_OPEN); (c = _getch(); જો (c == 27) ( બ્રેક; ) fputc(c, આઉટપુટ); , stdout);

4. ફાઇલમાં પૂર્ણાંકો છે. તેમાંથી મહત્તમ શોધો. ચાલો એ હકીકતનો લાભ લઈએ કે fscanf ફંક્શન યોગ્ય રીતે વાંચેલા અને મેળ ખાતી વસ્તુઓની સંખ્યા પરત કરે છે. દર વખતે નંબર 1 પરત કરવો જોઈએ.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # ERROR_FILE_OPEN -3 void main() વ્યાખ્યાયિત કરો ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); જો (ઇનપુટ == NULL) (printf("ફાઈલ ખોલવામાં ભૂલ"); _getch(); exit(ERROR_FILE_OPEN); maxn = INT_MIN; hasRead = 1; જ્યારે (hasRead == 1) ( hasRead = fscanf(ઇનપુટ, "%d", &num); if (hasRead != 1) ( ચાલુ રાખો; ) જો (સંખ્યા >

બીજો ઉકેલ એ છે કે જ્યાં સુધી આપણે ફાઇલના અંત સુધી પહોંચીએ ત્યાં સુધી નંબરો વાંચો.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # ERROR_FILE_OPEN -3 void main() વ્યાખ્યાયિત કરો ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); જો (ઇનપુટ == NULL) ( printf("ફાઈલ ખોલવામાં ભૂલ"); _getch(); બહાર નીકળો(ERROR_FILE_OPEN); ) maxn = INT_MIN; જ્યારે (!feof(input)) ( fscanf(input, "%d", &num); જો (num > maxn) ) ( maxn = num; ) ) printf("max number = %d", maxn);

5. ફાઇલમાં શબ્દો છે: રશિયન શબ્દ, ટેબ, અંગ્રેજી શબ્દ, ઘણી પંક્તિઓમાં. વપરાશકર્તા અંગ્રેજી શબ્દ દાખલ કરે છે, રશિયન શબ્દનું આઉટપુટ કરવું જરૂરી છે.

અનુવાદ ફાઇલ કંઈક આના જેવી દેખાય છે

સૂર્ય સૂર્ય
પેન્સિલ પેન
બોલપોઇન્ટ પેન પેન્સિલ
બારણું બારણું
વિન્ડો વિન્ડો
ખુરશી ખુરશી
ખુરશી

અને cp866 એન્કોડિંગ (OEM 866) માં સાચવેલ છે. તે મહત્વપૂર્ણ છે: શબ્દોની છેલ્લી જોડી પણ લાઇન ફીડ સાથે સમાપ્ત થાય છે.

અલ્ગોરિધમ નીચે મુજબ છે: આપણે ફાઇલમાંથી એક લાઇન વાંચીએ છીએ, લાઇનમાં ટેબ સાઇન શોધીએ છીએ, ટૅબ ચિહ્નને શૂન્યથી બદલીએ છીએ, બફરમાંથી રશિયન શબ્દની નકલ કરીએ છીએ, બફરમાંથી અંગ્રેજી શબ્દની નકલ કરીએ છીએ, સમાનતા તપાસો.

# સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # સમાવેશ થાય છે # ERROR_FILE_OPEN -3 void main() વ્યાખ્યાયિત કરો ( FILE *input = NULL; char buffer; char enWord; char ruWord; char usrWord; સહી ન કરેલ અનુક્રમણિકા; int લંબાઈ; int wasFound; input = fopen("D:/c/input.txt ", "r"); જો (ઇનપુટ == NULL) ( printf("ફાઇલ ખોલવામાં ભૂલ"); _getch(); બહાર નીકળો(ERROR_FILE_OPEN); ) printf("શબ્દ દાખલ કરો:"); fgets(usrWord, 127, stdin હતી.< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. ફાઇલમાં લીટીઓની સંખ્યા ગણો. અમે EOF અક્ષરનો સામનો ન કરીએ ત્યાં સુધી અમે "\n" અક્ષરોની સંખ્યા ગણીને, અક્ષર દ્વારા ફાઇલ અક્ષર વાંચીશું. EOF એ એક વિશિષ્ટ અક્ષર છે જે સૂચવે છે કે ઇનપુટ પૂર્ણ છે અને વાંચવા માટે વધુ ડેટા નથી. ફંક્શન ભૂલના કિસ્સામાં નકારાત્મક મૂલ્ય આપે છે.
નોંધ: EOF int પ્રકારનું છે, તેથી તમારે અક્ષરો વાંચવા માટે int નો ઉપયોગ કરવાની જરૂર છે. વધુમાં, EOF નું મૂલ્ય ધોરણ દ્વારા વ્યાખ્યાયિત કરવામાં આવતું નથી.

#CRT_SECURE_NO_WARNINGS #સમાવેશ કરો # સમાવેશ થાય છે # સમાવેશ થાય છે int cntLines(const char *filename) ( int લાઇન = 0; int any; //any int પ્રકારનું છે કારણ કે EOF int પ્રકારનું છે! FILE *f = fopen(ફાઇલનામ, "r"); જો (f == NULL ) ( પરત કરો -1; ) કરો ( any = fgetc(f); //printf("%c", કોઈપણ);//ડિબગ જો (any == "\n") ( રેખાઓ++; ) ) જ્યારે(કોઈપણ ! = ઇઓએફ (એફ) રીટર્ન લાઇન્સ;

Ru-Cyrl 18-ટ્યુટોરીયલ સિપાચેવ એસ.એસ. 1989-04-14[ઇમેઇલ સુરક્ષિત]સ્ટેપન સિપાચેવ

વિદ્યાર્થીઓ

હજુ સ્પષ્ટ નથી? - મેઈલબોક્સમાં પ્રશ્નો લખો

છેલ્લું અપડેટ: 10/31/2015 વર્ગફાઇલસ્ટ્રીમ

ફાઇલમાંથી વાંચવાની અને ફાઇલમાં લખવાની ક્ષમતાઓનું પ્રતિનિધિત્વ કરે છે. તે તમને ટેક્સ્ટ ફાઇલો અને બાઈનરી બંને સાથે કામ કરવાની મંજૂરી આપે છે.

ચાલો તેના સૌથી મહત્વપૂર્ણ ગુણધર્મો અને પદ્ધતિઓનો વિચાર કરીએ:

લંબાઈ ગુણધર્મ: બાઈટમાં સ્ટ્રીમની લંબાઈ પરત કરે છે

પોઝિશન પ્રોપર્ટી: સ્ટ્રીમમાં વર્તમાન સ્થિતિ પરત કરે છે

• એરે - બાઇટ્સની એરે જ્યાં ફાઇલમાંથી વાંચવામાં આવેલ ડેટા મૂકવામાં આવશે

  ઑફસેટ એરેમાં બાઈટ્સમાં ઑફસેટનું પ્રતિનિધિત્વ કરે છે જેમાં રીડ બાઇટ્સ મૂકવામાં આવશે

  ગણતરી - મહત્તમ સંખ્યાવાંચવા માટે બાઈટ. જો ફાઇલમાં ઓછા બાઇટ્સ હોય, તો તે બધા વાંચવામાં આવશે.

પદ્ધતિ લાંબી શોધ (લાંબી ઑફસેટ, સીકઓરિજિન મૂળ): ઑફસેટ પરિમાણમાં ઉલ્લેખિત બાઇટ્સની સંખ્યા દ્વારા ઑફસેટ સાથે સ્ટ્રીમમાં સ્થિતિ સેટ કરે છે.

લખવાની પદ્ધતિ: બાઈટ એરેમાંથી ફાઇલમાં ડેટા લખે છે. ત્રણ પરિમાણો લે છે: લખો (બાઇટ એરે, પૂર્ણાંક ઑફસેટ, પૂર્ણાંક સંખ્યા)

• એરે - બાઇટ્સની એરે જેમાંથી ડેટા ફાઇલમાં લખવામાં આવશે

  ઑફસેટ - એરેમાં બાઇટ્સમાં ઑફસેટ જ્યાંથી સ્ટ્રીમમાં બાઇટ લખવાનું શરૂ થાય છે

  ગણતરી - લખવા માટેની બાઈટ્સની મહત્તમ સંખ્યા

ફાઇલસ્ટ્રીમ બાઇટ સ્તરે ફાઇલ એક્સેસનું પ્રતિનિધિત્વ કરે છે, તેથી, ઉદાહરણ તરીકે, જો તમારે ટેક્સ્ટ ફાઇલમાં એક અથવા વધુ લાઇન વાંચવાની અથવા લખવાની જરૂર હોય, તો પછી બાઇટ એરેને વિશિષ્ટ પદ્ધતિઓનો ઉપયોગ કરીને સ્ટ્રિંગ્સમાં રૂપાંતરિત કરવું આવશ્યક છે. તેથી, અન્ય વર્ગોનો ઉપયોગ ટેક્સ્ટ ફાઇલો સાથે કામ કરવા માટે થાય છે.

તે જ સમયે, જ્યારે ચોક્કસ માળખું ધરાવતી વિવિધ દ્વિસંગી ફાઇલો સાથે કામ કરતી વખતે, FileStream માહિતીના ચોક્કસ ટુકડાઓ કાઢવા અને તેની પ્રક્રિયા કરવા માટે ખૂબ ઉપયોગી થઈ શકે છે.

ચાલો ટેક્સ્ટ ફાઇલ વાંચવા અને લખવાનું ઉદાહરણ જોઈએ:

Console.WriteLine("ફાઈલમાં લખવા માટે એક લીટી દાખલ કરો:"); શબ્દમાળા ટેક્સ્ટ = કન્સોલ.રીડલાઇન(); // (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) નો ઉપયોગ કરીને ફાઇલમાં લખવું ( // સ્ટ્રિંગને બાઇટ બાઇટ એરે = System.Text.Encoding માં કન્વર્ટ કરો. ડિફૉલ્ટ ગેટબાઇટ્સ (ટેક્સ્ટ); fstream = ફાઈલ (@"C:\SomeDir\noname\note.txt")) ( // સ્ટ્રિંગને બાઈટ બાઈટ એરે = નવા બાઈટમાં કન્વર્ટ કરો; // ડેટા વાંચો fstream.Read(array, 0, array). લંબાઇ);

ચાલો આ ઉદાહરણ જોઈએ. વાંચન અને લેખન બંને યુઝિંગ સ્ટેટમેન્ટનો ઉપયોગ કરે છે. આ વિધાનને યુઝિંગ ડાયરેક્ટિવ સાથે ભેળસેળ ન કરવી જોઈએ, જેમાં કોડ ફાઇલની શરૂઆતમાં નેમસ્પેસનો સમાવેશ થાય છે. યુઝિંગ સ્ટેટમેન્ટ તમને કોડના બ્લોકમાં ઑબ્જેક્ટ બનાવવા માટે પરવાનગી આપે છે, જે પૂર્ણ થવા પર ઑબ્જેક્ટની નિકાલ પદ્ધતિ કહેવામાં આવે છે, અને આમ ઑબ્જેક્ટનો નાશ થાય છે. આ કિસ્સામાં, fstream ચલ આવા ઑબ્જેક્ટ તરીકે સેવા આપે છે.

fstream ઑબ્જેક્ટ બે અલગ અલગ રીતે બનાવવામાં આવે છે: કન્સ્ટ્રક્ટર દ્વારા અને ફાઇલ ક્લાસની સ્થિર પદ્ધતિઓમાંથી એક દ્વારા.

અહીં બે પરિમાણો કન્સ્ટ્રક્ટરને પસાર કરવામાં આવે છે: ફાઇલ પાથ અને ફાઇલમોડ ગણતરી. આ ગણતરી ફાઇલ એક્સેસ મોડ સૂચવે છે અને નીચેના મૂલ્યો લઈ શકે છે:

ઉમેરો: જો ફાઇલ અસ્તિત્વમાં છે, તો ટેક્સ્ટ ફાઇલના અંતમાં ઉમેરવામાં આવે છે. જો ફાઇલ અસ્તિત્વમાં નથી, તો તે બનાવવામાં આવે છે. ફાઈલ ફક્ત લખવા માટે જ ખોલવામાં આવે છે.

બનાવો : એક નવી ફાઈલ બનાવવામાં આવી છે. જો આવી ફાઇલ પહેલેથી જ અસ્તિત્વમાં છે, તો તે ઓવરરાઇટ થઈ જશે

CreateNew: એક નવી ફાઈલ બનાવવામાં આવે છે. જો આવી ફાઇલ પહેલેથી અસ્તિત્વમાં છે, તો એપ્લિકેશન ભૂલ ફેંકે છે

ખોલો: ફાઇલ ખોલે છે. જો ફાઇલ અસ્તિત્વમાં નથી, તો અપવાદ ફેંકવામાં આવે છે

OpenOrCreate : જો ફાઇલ અસ્તિત્વમાં હોય, તો તે ખોલવામાં આવે છે, જો નહીં, તો નવી બનાવવામાં આવે છે

ટ્રંકેટ: જો ફાઇલ અસ્તિત્વમાં છે, તો તે ઓવરરાઇટ થઈ જશે. ફાઈલ ફક્ત લખવા માટે જ ખોલવામાં આવે છે.

ફાઇલ વર્ગની સ્થિર ઓપનરીડ પદ્ધતિ વાંચવા માટે ફાઇલ ખોલે છે અને ફાઇલસ્ટ્રીમ ઑબ્જેક્ટ પરત કરે છે.

ફાઇલસ્ટ્રીમ ક્લાસ કન્સ્ટ્રક્ટરમાં સંખ્યાબંધ ઓવરલોડ્સ પણ છે જે તમને ઑબ્જેક્ટ બનાવવામાં આવી રહેલા ઑબ્જેક્ટને વધુ ચોક્કસ રીતે કસ્ટમાઇઝ કરવાની મંજૂરી આપે છે. આ બધી આવૃત્તિઓ msdn પર જોઈ શકાય છે.

લખવું અને વાંચવું બંને સિસ્ટમ.ટેક્સ્ટ નેમસ્પેસમાંથી Encoding.Default એન્કોડિંગ ઑબ્જેક્ટનો ઉપયોગ કરે છે. આ કિસ્સામાં, અમે તેની બે પદ્ધતિઓનો ઉપયોગ કરીએ છીએ: સ્ટ્રિંગમાંથી બાઈટ એરે મેળવવા માટે GetBytes અને બાઈટ એરેમાંથી સ્ટ્રિંગ મેળવવા માટે GetString.

પરિણામે, અમે દાખલ કરેલી સ્ટ્રિંગ ફાઇલમાં લખાઈ છે note.txt. અનિવાર્યપણે, આ એક બાઈનરી ફાઇલ છે (ટેક્સ્ટ ફાઇલ નથી), જો કે જો આપણે તેમાં માત્ર એક લીટી લખીએ, તો અમે આ ફાઇલને ટેક્સ્ટ એડિટરમાં ખોલીને વાંચી શકાય તેવા સ્વરૂપમાં જોઈ શકીએ છીએ. જો કે, જો આપણે તેમાં રેન્ડમ બાઇટ્સ લખીએ, ઉદાહરણ તરીકે:

Fstream.WriteByte(13); fstream.WriteByte(103);

પછી આપણને તેને સમજવામાં તકલીફ પડી શકે છે. તેથી, ટેક્સ્ટ ફાઇલો - StreamReader અને StreamWriter સાથે સીધા કામ કરવા માટે અલગ વર્ગો ડિઝાઇન કરવામાં આવ્યા છે.

ફાઇલોની રેન્ડમ ઍક્સેસ

ઘણીવાર બાઈનરી ફાઈલો ચોક્કસ માળખું રજૂ કરે છે. અને, આ માળખું જાણીને, આપણે ફાઇલમાંથી જરૂરી માહિતીનો ટુકડો લઈ શકીએ છીએ અથવા તેનાથી વિપરિત, ફાઇલમાં ચોક્કસ જગ્યાએ બાઈટનો ચોક્કસ સેટ લખી શકીએ છીએ. ઉદાહરણ તરીકે, wav ફાઇલોમાં, ઑડિઓ ડેટા પોતે 44 બાઇટ્સથી શરૂ થાય છે, અને 44 બાઇટ્સ સુધી વિવિધ મેટાડેટા છે - ઑડિઓ ચેનલોની સંખ્યા, નમૂનાની આવર્તન, વગેરે.

Seek() પદ્ધતિનો ઉપયોગ કરીને, અમે સ્ટ્રીમ કર્સરની સ્થિતિને નિયંત્રિત કરી શકીએ છીએ, જ્યાંથી ફાઇલ વાંચવામાં અથવા લખવામાં આવે છે. આ પદ્ધતિ બે પરિમાણો લે છે: ઑફસેટ અને ફાઇલમાં સ્થાન. ફાઇલમાં સ્થાન ત્રણ મૂલ્યો દ્વારા વર્ણવવામાં આવે છે:

SeekOrigin.Begin : ફાઇલની શરૂઆત

SeekOrigin.End : ફાઇલનો અંત

SeekOrigin.Current : ફાઇલમાં વર્તમાન સ્થિતિ

સ્ટ્રીમનો કર્સર જેમાંથી વાંચન અથવા લેખન શરૂ થાય છે તે બીજા પરિમાણ તરીકે ઉલ્લેખિત સ્થિતિને સંબંધિત ઑફસેટ દ્વારા આગળ ખસેડવામાં આવે છે. ઓફસેટ નકારાત્મક હોઈ શકે છે, પછી કર્સર પાછળ ખસે છે, જો હકારાત્મક, તો આગળ.

ચાલો એક ઉદાહરણ જોઈએ:

System.IO નો ઉપયોગ કરીને; System.Text નો ઉપયોગ કરીને; ક્લાસ પ્રોગ્રામ ( સ્ટેટિક વોઈડ મેઈન(સ્ટ્રિંગ આર્ગ્સ) ( સ્ટ્રિંગ ટેક્સ્ટ = "હેલો વર્લ્ડ"; // (ફાઇલસ્ટ્રીમ fstream = નવી ફાઇલસ્ટ્રીમ (@"ડી:\note.dat", FileMode.OpenOrCreate)) નો ઉપયોગ કરીને ફાઇલમાં લખવું (/ / સ્ટ્રિંગને બાઇટ્સ ઇનપુટમાં કન્વર્ટ કરો = Encoding.Default.GetBytes(ટેક્સ્ટ); // ફાઇલમાં બાઇટ્સનો એરે લખો. લખો(ઇનપુટ, 0, ઇનપુટ. લંબાઈ ); વર્તમાન સ્થિતિ બાઇટ આઉટપુટ = નવી બાઇટ (આઉટપુટ, 0, આઉટપુટ. લંબાઈ); // બાઇટ્સને સ્ટ્રિંગ સ્ટ્રિંગમાં ડીકોડ કરો. , ટેક્સ્ટમાંથી ફાઇલ); GetBytes(ટેક્સ્ટ બદલો); 0, ઇનપુટ. લંબાઈ);

// આખી ફાઈલ વાંચો // ફાઈલ fstream.Seek(0, SeekOrigin.Begin)ની શરૂઆતમાં પોઈન્ટરને પરત કરો;

આઉટપુટ = નવી બાઈટ;

fstream.Seek(-5, SeekOrigin.End) કૉલ કરવાથી સ્ટ્રીમ કર્સરને ફાઇલના અંતમાં પાંચ અક્ષરો પાછળ ખસેડવામાં આવે છે:

એટલે કે, નવી ફાઇલમાં “hello world” લાઇન લખ્યા પછી, કર્સર “w” અક્ષરની સ્થિતિ પર હશે.

આ પછી, અમે અક્ષર "w" થી શરૂ થતા ચાર બાઇટ્સ વાંચીએ છીએ. આ એન્કોડિંગમાં, 1 અક્ષર 1 બાઈટનું પ્રતિનિધિત્વ કરશે. તેથી, 4 બાઇટ્સ વાંચવું એ ચાર અક્ષરો વાંચવા સમાન હશે: "worl".

પછી, ફરીથી, આપણે ફાઈલના અંત તરફ જઈએ છીએ, પાંચ અક્ષરોના અંત સુધી પહોંચ્યા નથી (એટલે ​​​​કે, ફરીથી "w" અક્ષરની સ્થિતિથી), અને શબ્દમાળા "હાઉસ" લખો. તેથી શબ્દમાળા "ઘર" શબ્દમાળા "વિશ્વ" ને બદલે છે.

એક થ્રેડ બંધ કરી રહ્યા છીએ

ઉપરના ઉદાહરણોમાં, સ્ટ્રીમને બંધ કરવા માટે યુઝિંગ કન્સ્ટ્રક્ટનો ઉપયોગ થાય છે. ઉપયોગના બ્લોકમાંના તમામ ઓપરેટરો અને અભિવ્યક્તિઓ પર પ્રક્રિયા કર્યા પછી, ફાઇલસ્ટ્રીમ ઑબ્જેક્ટ નાશ પામે છે. જો કે, અમે બીજી રીત પસંદ કરી શકીએ છીએ:

ફાઇલસ્ટ્રીમ fstream = નલ; પ્રયાસ કરો ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // સ્ટ્રીમ સાથેની કામગીરી) પકડો(અપવાદ ex) ( ) છેલ્લે ( if (fstream != null) fstream.Close() ;)

જો આપણે યુઝિંગ કન્સ્ટ્રક્ટનો ઉપયોગ કરતા નથી, તો આપણે સ્પષ્ટપણે ક્લોઝ() પદ્ધતિને કૉલ કરવાની જરૂર છે: fstream.Close()

ટેક્સ્ટ ફાઇલો

ચાલો ઉદાહરણનો ઉપયોગ કરીને C માં ટેક્સ્ટ ફાઇલ સાથે કામ કરીએ. ડ્રાઇવ C પર TextFile.txt નામની ટેક્સ્ટ ફાઇલ બનાવો. આ ફાઈલમાં નીચેની લીટીઓ ટાઈપ કરો:

સ્ટ્રિંગ_1 123 સ્ટ્રિંગ_11, 456
શબ્દમાળા_2
સ્ટ્રિંગ_3

ફાઇલ સાચવો.

અને આ સી પ્રોગ્રામનો કોડ છે જે આપણી ફાઇલ ખોલે છે અને તેમાંથી લીટીઓ વાંચે છે:

/* *લેખક: @author Subbotin B.P..h> #include # define LEN 50 int main(void) ( puts("Text file operations"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("સમસ્યાઓ"); પરત કરો EXIT_FAILURE; ) જ્યારે(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile) પરત કરો EXIT_SUCCESS;

સીમાં ટેક્સ્ટ ફાઇલ ખોલવા માટે, ફોપેન ફંક્શનનો ઉપયોગ કરો:

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

ફોપેન ફંક્શનની પ્રથમ દલીલ ફાઇલ તરફ નિર્દેશ કરે છે, અને બીજી કહે છે કે ફાઇલ તેમાંથી વાંચવા માટે ખુલ્લી છે.

અમે fgets ફંક્શનનો ઉપયોગ કરીને લીટીઓ વાંચીએ છીએ:

fgets(cArray, LEN, pTextFile);

fgets ફંક્શનની પ્રથમ દલીલ અક્ષર એરે તરફ નિર્દેશ કરે છે જેમાં પ્રાપ્ત સ્ટ્રિંગ્સ સંગ્રહિત કરવામાં આવશે, બીજી દલીલ વાંચવા માટે મહત્તમ અક્ષરોની સંખ્યા છે, અને ત્રીજી અમારી ફાઇલ છે.

ફાઇલ સાથે કામ પૂર્ણ કર્યા પછી, તમારે તેને બંધ કરવાની જરૂર છે:

fclose(pTextFile);

અમને મળે છે:

લીટીઓમાં રશિયન અક્ષરો પણ દેખાય છે.

બાય ધ વે, મેં આ પ્રોગ્રામ Eclipse માં બનાવ્યો હતો. તમે Eclipse માં C/C++ સાથે કેવી રીતે કામ કરવું તે જોઈ શકો છો.

તેથી, અમે ટેક્સ્ટ ફાઇલમાંથી ડેટા ખોલ્યો અને વાંચ્યો.

હવે ચાલો શીખીએ કે કેવી રીતે પ્રોગ્રામેટિકલી ટેક્સ્ટ ફાઈલ બનાવવી અને તેમાં ડેટા લખવો.

/* લેખક: @author Subbotin B.P..h> # સમાવેશ થાય છે int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "આ એક સ્ટ્રિંગ છે"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("problems"); EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

ડેટા લખવા માટે એક ટેક્સ્ટ ફાઇલ બનાવો:

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

જો ફાઇલ પહેલેથી જ અસ્તિત્વમાં છે, તો તે ખોલવામાં આવશે અને તેમાંથી તમામ ડેટા કાઢી નાખવામાં આવશે.

સી-સ્ટ્રિંગ cString અને નંબર nVal પ્રોગ્રામ દ્વારા ટેક્સ્ટ ફાઇલમાં લખવામાં આવે છે. cNewLine ખાલી એક નવી લાઇન છે.

અમે fprintf ફંક્શનનો ઉપયોગ કરીને ટેક્સ્ટ ફાઇલમાં ડેટા લખીએ છીએ:

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

અહીં પ્રથમ દલીલ અમારી ફાઇલ છે, બીજી ફોર્મેટ સ્ટ્રિંગ છે, ત્રીજી અથવા વધુ આ ફોર્મેટ માટે જરૂરી દલીલોની સંખ્યા છે.