પ્રિઝમમાં કિરણોનો માર્ગ બનાવો. ભૌમિતિક ઓપ્ટિક્સના તત્વો સ્ટેપનોવા V.A

fopen() ફંક્શન ઉપયોગ માટે એક સ્ટ્રીમ ખોલે છે, તે સ્ટ્રીમ સાથે ફાઇલને સાંકળે છે અને પછી તે સ્ટ્રીમમાં FILE પોઇન્ટર પરત કરે છે. મોટાભાગે ફાઇલને ડિસ્ક ફાઇલ તરીકે ગણવામાં આવે છે. fopen() ફંક્શનમાં નીચેના પ્રોટોટાઇપ છે:

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

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

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

કોષ્ટક બતાવે છે તેમ, ફાઇલને ટેક્સ્ટ અથવા બાઈનરી મોડમાં ખોલી શકાય છે. ટેક્સ્ટ મોડમાં, જેમ તમે ટાઇપ કરો છો, કેરેજ રિટર્ન અને લાઇન ફીડ્સનો ક્રમ નવી લાઇન અક્ષરમાં અનુવાદિત થાય છે. આઉટપુટમાં, વિપરીત સાચું છે: નવી લાઇન કેરેક્ટરને કેરેજ રીટર્ન અને લાઇન ફીડમાં અનુવાદિત કરવામાં આવે છે. આ અનુવાદ બાઈનરી ફાઈલોમાં થતો નથી. જ્યારે મોડ આર્ગ્યુમેન્ટમાં t કે b નો ઉલ્લેખ કરવામાં આવ્યો નથી, ત્યારે ફાઈલની ટેક્સ્ટ/બાઈનરી સ્થિતિ બોર્લેન્ડ C++ માં વ્યાખ્યાયિત વૈશ્વિક ચલ _fmode ની કિંમત દ્વારા નક્કી કરવામાં આવે છે. મૂળભૂત રીતે, fmode O_TEXT પર સેટ છે, એટલે કે, ટેક્સ્ટ મોડ સેટ છે. જો તમે _fmode ને O_BINARY પર સેટ કરો છો, તો ફાઇલો બાઈનરી મોડમાં ખોલવામાં આવશે. (આ મેક્રો fcntl.h માં વ્યાખ્યાયિત થયેલ છે.) સ્વાભાવિક રીતે, સ્પષ્ટ t અથવા b નો ઉપયોગ _fmode ચલ સાથે સંકળાયેલ અસરોને દૂર કરે છે. વધુમાં, _fmode માત્ર બોરલેન્ડ ઉત્પાદનો માટે વિશિષ્ટ છે. તે ANSI C I/O સિસ્ટમમાં વ્યાખ્યાયિત નથી.

જો તમારે લખવા માટે ટેસ્ટ નામની ફાઇલ ખોલવાની જરૂર હોય, તો તમારે લખવું જોઈએ:

Fp = fopen("ટેસ્ટ", "w");

જ્યાં fp છે પ્રકાર ચલફાઇલ *. જો કે, નીચેના જોવા માટે તે સામાન્ય છે:

જો((fp = fopen("ટેસ્ટ", "w"))==NULL) (
puts("ફાઇલ ખોલી શકાતી નથી.");
બહાર નીકળો(1);
}

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

જો fopen() નો ઉપયોગ લખવા માટે ફાઇલ ખોલવા માટે કરવામાં આવે છે, તો સ્પષ્ટ નામ સાથેની કોઈપણ પહેલાથી અસ્તિત્વમાં રહેલી ફાઇલ કાઢી નાખવામાં આવશે. જો ઉલ્લેખિત નામવાળી ફાઇલ અસ્તિત્વમાં નથી, તો તે બનાવવામાં આવશે.

જો તમારે ફાઇલના અંતમાં માહિતી ઉમેરવાની જરૂર હોય, તો તમારે મોડ a (એપેન્ડ) નો ઉપયોગ કરવો જોઈએ. જો ફાઇલ અસ્તિત્વમાં નથી, તો તે બનાવવામાં આવશે.

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

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

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

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

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

નામ - ખોલવા માટેની ફાઇલનું નામ (પાથ સહિત),
ટાઇપ - ફાઇલને કેવી રીતે એક્સેસ કરવામાં આવે છે તે વ્યાખ્યાયિત કરતી અક્ષરોની સ્ટ્રિંગ માટે નિર્દેશક:

· "r" - વાંચવા માટે ફાઇલ ખોલો (ફાઇલ અસ્તિત્વમાં હોવી જોઈએ);

· "w" - લખવા માટે ખાલી ફાઇલ ખોલો; જો ફાઇલ અસ્તિત્વમાં છે, તો તેના સમાવિષ્ટો ખોવાઈ જશે;

· "a" - અંત સુધી લખવા માટે ફાઇલ ખોલો (જોડવા માટે); જો તે અસ્તિત્વમાં ન હોય તો ફાઇલ બનાવવામાં આવે છે;

· "r+" - વાંચવા અને લખવા માટે ફાઇલ ખોલો (ફાઇલ અસ્તિત્વમાં હોવી જોઈએ);

· "w+" - વાંચવા અને લખવા માટે ખાલી ફાઇલ ખોલો; જો ફાઇલ અસ્તિત્વમાં છે, તો તેના સમાવિષ્ટો ખોવાઈ જશે;

· "a+" - ફાઇલને વાંચવા અને જોડવા માટે ખોલો; જો ફાઇલ અસ્તિત્વમાં નથી, તો તે બનાવવામાં આવે છે.

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

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

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

# સમાવેશ થાય છે
પૂર્ણાંક મુખ્ય()

char name="my.txt";

if(fp = fopen(નામ, "r")!=NULL)

// શું ફાઇલ ખોલવાનું શક્ય હતું?
... // ડેટા પર જરૂરી ક્રિયાઓ

else printf("ફાઈલ ખોલવામાં નિષ્ફળ");

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

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

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

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

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

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

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

fgets() અને fputs() ફંક્શન્સ સ્ટ્રીંગ ઇનપુટ/આઉટપુટ માટે ડિઝાઇન કરવામાં આવ્યા છે તેઓ ફાઇલો સાથે કામ કરવા માટે gets() અને puts() ફંક્શનના સમાન છે.

fgets(પોઇન્ટર ટુ લાઇન, અક્ષરોની સંખ્યા, સ્ટ્રીમ);

સ્ટ્રીમમાંથી અક્ષરો વાંચવામાં આવે છે જ્યાં સુધી નવી લાઇન અક્ષર "\n" વાંચવામાં ન આવે, જે સ્ટ્રિંગમાં શામેલ હોય, અથવા જ્યાં સુધી સ્ટ્રીમ EOF સમાપ્ત ન થાય અથવા અક્ષરોની મહત્તમ સંખ્યા વાંચવામાં ન આવે ત્યાં સુધી. પરિણામ સ્ટ્રિંગ પોઇન્ટરમાં મૂકવામાં આવે છે અને નલ અક્ષર "\0" સાથે સમાપ્ત થાય છે. ફંક્શન સ્ટ્રિંગનું સરનામું પરત કરે છે.

fputs(પૉઇન્ટર ટુ સ્ટ્રીંગ, સ્ટ્રીમ);

વર્તમાન સ્થિતિમાંથી સ્ટ્રીમમાં સ્ટ્રિંગની નકલ કરે છે. સમાપ્ત થતા નલ અક્ષરની નકલ કરવામાં આવી નથી.
ઉદાહરણ નંબર દાખલ કરો અને તેને s1.txt ફાઇલમાં સાચવો. s1.txt ફાઇલમાંથી નંબર વાંચો, તેને 3 વધારવો અને તેને s2.txt ફાઇલમાં સાચવો.

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

ચાલો ઉદાહરણનો ઉપયોગ કરીને 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);

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