[Powered by Google Translate] [ફાઇલ I / O]
[જેસન Hirschhorn, હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે, CS50.TV]
જ્યારે અમે ફાઈલ લાગે છે, શું વાંધો આવે માઇક્રોસોફ્ટ વર્ડ દસ્તાવેજ છે,
એક JPEG છબી, અથવા MP3 ગીત,
અને અમે અલગ અલગ રીતે ફાઈલો આ પ્રકારના દરેક સાથે ક્રિયાપ્રતિક્રિયા કરે છે.
ઉદાહરણ તરીકે, વર્ડ દસ્તાવેજ આપણે લખાણ ઉમેરો
જ્યારે JPEG છબી સાથે અમે ધાર કાપવા અથવા કદાચ રંગો નવી છટાઓ આપીને સુધારવું.
હજુ સુધી હૂડ હેઠળ અમારી કોમ્પ્યુટર માં બધી ફાઈલોને વધુ કશું છે
zeros અને શૈલીઓનો લાંબા ક્રમ કરતાં.
તે ચોક્કસ કાર્યક્રમ છે કે જે આ ફાઇલ સાથે સંપર્ક કરે છે અપ કરવા માટે છે
નક્કી આ કેવી રીતે લાંબા ક્રમ પર પ્રક્રિયા કરવા માટે અને તેને વપરાશકર્તા માટે રજૂ કરે છે.
એક તરફ, એક દસ્તાવેજ માત્ર એક બાઈટ જોવા શકે છે,
કે 8 zeros અને પ્રવર્તે છે અને સ્ક્રીન પર એક ASCII અક્ષર દર્શાવે છે.
બીજી બાજુ, એક બીટમેપ છબી 3 બાઇટ્સ જોવા શકે છે,
અથવા 24 zeros અને પ્રવર્તે
અને તેમને 3 હેક્સાડેસિમલ નંબર તરીકે અર્થઘટન
કે લાલ, લીલો અને વાદળી માટે મૂલ્યો પ્રતિનિધિત્વ
એક છબી એક પિક્સેલ છે.
તેઓ જે જેવી તમારી સ્ક્રીન પર તેમના કોર પર, જુઓ શકે છે,
ફાઈલો કશું છે zeros અને શૈલીઓનો હાર કરતાં વધુ.
તેથી ચાલો માં ડાઇવ અને અમે કેવી રીતે વાસ્તવમાં આ zeros અને મુદ્દાઓ ચાલાકી જોવા
જ્યારે તે લખવાનું અને ફાઈલ માંથી વાંચવા માટે આવે છે.
>> હું તેને સરળ પ્રક્રિયા 3-ભાગ ફેરવાઇ ભંગ દ્વારા શરૂ કરી શકશો.
આગલું, હું બે કોડ ઉદાહરણો છે કે આ ત્રણ ભાગો દર્શાવે છે માં ડાઇવ પડશે.
છેલ્લે, હું પ્રક્રિયા સમીક્ષા અને તેના સૌથી મહત્વપૂર્ણ વિગતો કેટલાક પડશે.
કોઇ પણ ફાઇલ તમારા ડેસ્કટોપ પર બેસે છે,
પ્રથમ બાબત તેને ખોલવા છે.
સી અમે પૂર્વનિર્ધારિત સ્ટ્રક્ટ માટે નિર્દેશક જાહેર કરીને આ કરવા માટે
કે ડિસ્ક પર ફાઇલ પ્રતિનિધિત્વ કરે છે.
આ ફંક્શન કોલ, અમે પણ નક્કી કરો કે શું અમે લખી અથવા ફાઇલને વાંચવામાં કરવા માંગો છો.
પછી, આપણે વાસ્તવિક વાંચન અને લેખન કરવું.
ત્યાં ખાસ કાર્યો સંખ્યાબંધ અમે આ ભાગ માં ઉપયોગ કરી શકે છે,
અને તેમને લગભગ તમામ પત્ર એફ, જે ફાઈલ માટે વપરાય સાથે શરૂ કરો.
છેલ્લા ફાઈલો ટોચ ખૂણામાં નાના લાલ X સમાન તમારા કમ્પ્યુટર પર ખોલવા માટે,
અમે અંતિમ વિધેય કોલ સાથે ફાઈલ બંધ કરો.
હવે અમે અમે શું જઈ રહ્યાં છો એક સામાન્ય વિચાર છે,
માતાનો કોડ માં ડાઈવ દો.
>> આ ડિરેક્ટરીમાં, અમે બે સી ફાઇલો અને તેમના લગતાવળગતા એક્ઝેક્યુટેબલ ફાઈલો હોય.
આ ટાઇપરાઇટર કાર્યક્રમ એક આદેશ વાક્ય દલીલ લે છે,
દસ્તાવેજનું નામ અમે બનાવવા માંગો છો.
આ કિસ્સામાં, અમે તેને doc.txt કહી શકશો.
ચાલો કાર્યક્રમ ચલાવો અને લીટીઓ એક દંપતી દાખલ કરો.
હાય. મારું નામ જેસન છે.
છેલ્લે, અમે લખો "છોડી દીધું." પડશે
જો આપણે હવે આ ડિરેક્ટરીમાં ફાઈલોની યાદી,
અમે જુઓ કે એક નવો દસ્તાવેજ doc.txt કહેવાય અસ્તિત્વમાં છે.
કે ફાઈલ આ માત્ર બનાવનાર કાર્યક્રમ છે.
અલબત્ત, તે ખૂબ zeros અને શૈલીઓનો લાંબા ક્રમ કરતાં વધુ કંઈ નથી.
જો અમે આ નવી ફાઈલ ખોલવા માટે,
અમે કોડ ઓફ 3 રેખાઓ અમે અમારા કાર્યક્રમ દાખલ જુઓ -
હાય. મે નામ જેસન છે.
પરંતુ શું ખરેખર જ્યારે typewriter.c સ્કોર પર ચાલી રહ્યું છે?
અમારા માટે આ રસ પ્રથમ વાક્ય 24 રેખા છે.
આ રેખા, અમે અમારી ફાઈલ નિર્દેશક જાહેર.
કાર્ય કે આ નિર્દેશક, fopen આપે છે, બે દલીલો લે છે.
પ્રથમ ફાઈલ ફાઈલ જો યોગ્ય વિસ્તરણ સહિત નામ છે.
યાદ છે કે જે ફાઈલ એક્સટેન્સન તેના સૌથી નીચા સ્તરે ફાઈલ પર અસર કરતું નથી.
અમે હંમેશા zeros અને શૈલીઓનો લાંબા ક્રમ સાથે વ્યવહાર કરી રહ્યા છો.
પરંતુ તે પ્રભાવ કરે છે કે કેવી રીતે ફાઈલો અર્થઘટન કરવામાં આવે છે અને શું કાર્યક્રમોને તેમને ખોલવા માટે ઉપયોગ થાય છે.
Fopen બીજી દલીલ એ એક પત્ર છે
કે અમે શું પછી અમે ફાઇલ ખોલવા કરવાની યોજના માટે વપરાય છે.
ડબલ્યુ, આર, અને એ - આ દલીલ માટે ત્રણ વિકલ્પો છે
અમે આ કિસ્સામાં વાઇડ કરવાનું પસંદ કર્યું છે કારણ કે અમે ફાઈલમાં લખો કરવા માંગો છો.
આર, તરીકે તમે કદાચ ધારી શકો છો, ફાઈલ વાંચવા માટે છે.
અને એક ફાઈલમાં ઉમેરીને માટે છે.
જ્યારે બંને વાઇડ અને એક ફાઈલો લખવા માટે ઉપયોગ થઇ શકે છે,
વાઇડ ફાઈલની શરૂઆતથી લખવાનું શરૂ કરશે
અને સંભવિત કોઈપણ માહિતી કે જે પહેલાં સંગ્રહિત કરવામાં આવી પર ફરીથી લખી.
મૂળભૂત રીતે, ફાઈલ અમે ખોલવા માટે, જો તે પહેલાથી જ હાજર નહિં હોય,
તે અમારા હાજર કામ કરતી ડિરેક્ટરીમાં બનાવેલ છે.
જો કે, અમે ઍક્સેસ અથવા એક અલગ સ્થાન એક ફાઈલ બનાવવા માંગો છો,
fopen પ્રથમ દલીલ છે,
અમે ફાઇલ નામ ઉપરાંત એક ફાઈલ પાથ સ્પષ્ટ કરી શકો છો.
જ્યારે આ પ્રક્રિયાના પ્રથમ ભાગ માત્ર લાંબા કોડ એક વાક્ય છે,
તે હંમેશા સારો વ્યવહાર કરવા માટે રેખાઓ અન્ય સમૂહ સમાવેશ થાય છે
કે તેની ખાતરી કરવા માટે કે જે ફાઈલ સફળતાપૂર્વક અથવા ખોલવામાં આવી હતી બનાવનાર તપાસો.
જો fopen નલ આપે છે, અમે અમારા કાર્યક્રમ સાથે આગળ સ્થાપશે માગતા નથી,
અને આ જો ઓપરેટિંગ સિસ્ટમ મેમરી બહાર છે થઈ શકે છે
અથવા જો અમે એ ડિરેક્ટરી છે કે જે માટે અમે યોગ્ય પરવાનગીઓ ન હતી એક ફાઇલ ખોલવા પ્રયાસ કરો.
>> આ પ્રક્રિયા બે ભાગ ની ટાઇપરાઇટર જ્યારે લૂપ માં ઉજવાય છે.
અમે એક પુસ્તકાલય CS50 કાર્ય વાપરવા માટે વપરાશકર્તા તરફથી ઇનપુટ વિચાર,
એમ ધારી રહ્યા છીએ અને તેઓ કાર્યક્રમ બહાર નીકળવા માંગો નહિં,
અમે કાર્ય fputs વાપરવા માટે શબ્દમાળા લાગી અને તે ફાઈલમાં લખો.
fputs માત્ર ઘણા કાર્યો એક અમે ફાઈલમાં લખો ઉપયોગ કરી શકો છે.
અન્ય fwrite, fputc, અને તે પણ fprintf સમાવેશ થાય છે.
અનુલક્ષીને ચોક્કસ કાર્યમાં આપણે મદદથી જોકે અંત,
તેમને બધી ખબર તેમની દલીલો મારફતે, જરૂર છે,
ઓછામાં ઓછા બે વસ્તુઓ -
શું હોય તેવા પરચૂરણ ખર્ચ અને જ્યાં તે માટે તેવા પરચૂરણ ખર્ચ કરવાની જરૂર જરૂર છે.
અમારા કિસ્સામાં, ઇનપુટ શબ્દમાળા કે જે તેવા પરચૂરણ ખર્ચ કરવાની જરૂર છે
અને fp પોઇન્ટર છે કે અમને જ્યાં અમે લખી રહ્યાં માટે દિશામાન છે.
આ કાર્યક્રમ માં, પ્રક્રિયા બે ભાગ બદલે સીધું છે.
અમે ફક્ત વપરાશકર્તાના છો શબ્દમાળા લેતી
અને તે સીધી રીતે ઉમેરીને સાથે અમારી ફાઈલ થોડું થી કોઈ ઇનપુટ માન્યતા અથવા સુરક્ષા તપાસોને.
જોકે, ઘણી વાર બે ભાગ તમારી કોડ બલ્ક લેશે.
છેલ્લે, ત્રણ ભાગ 58 ​​લીટી પર છે, જ્યાં અમે ફાઇલ બંધ કરો.
અહીં અમે fclose અને તેને પસાર અમારા મૂળ ફાઈલ નિર્દેશક કૉલ કરો.
અનુગામી રેખા, અમે શૂન્ય પરત, અમારા કાર્યક્રમ ઓવરને સંકેત આપે છે.
અને, હા, ત્રણ ભાગ તરીકે કે સરળ છે.
>> ચાલો ફાઈલો વાંચવા પર ખસેડો.
અમારી ડિરેક્ટરીમાં પાછા અમે printer.c તરીકે ઓળખાતી ફાઈલ હોય છે.
ચાલો તે ફાઈલ અમે ફક્ત બનાવનાર સાથે ચાલે -
doc.txt.
આ કાર્યક્રમ તરીકે નામ સૂચવે છે, માત્ર છાપે ફાઈલના સમાવિષ્ટો પસાર કરશે.
અને ત્યાં અમે તેને હોય છે.
કોડ ઓફ રેખાઓ આપણે પહેલાં લખ્યો હતો અને doc.txt માં સાચવી.
હાય. મારું નામ જેસન છે.
જો અમે printer.c માં ડાઇવ
અમે જુઓ કે કોડ ઘણાં આપણે શું માત્ર typewriter.c માં મારફતે ચાલ્યો જેવું જ દેખાય છે.
ખરેખર રેખા 22, જ્યાં અમે ફાઇલ ખોલી,
અને 39 લાઇન છે, જ્યાં અમે ફાઈલ બંધ
બંને છે લગભગ typewriter.c માટે સમાન, fopen બીજી દલીલ માટે સાચવો.
આ સમય અમે ફાઈલ માંથી વાંચવા રહ્યાં છો,
તેથી અમે r પસંદ કરેલ છે તેના બદલે વાઇડ છે.
આમ, ચાલો પ્રક્રિયા બીજા ભાગ પર ભાર મૂકે છે.
35 લીટી, અમારા 4 લૂપ બીજી શરત તરીકે,
અમે fgets કૉલ કરવા માટે,
સાથી પહેલાં fputs માટે કાર્ય કરે છે.
આ સમય અમે ત્રણ દલીલો છે.
પ્રથમ અક્ષરો જ્યાં શબ્દમાળા સંગ્રહિત કરવામાં આવશે એરે માટે નિર્દેશક છે.
બીજા અક્ષરોની મહત્તમ સંખ્યા પર વાંચી શકાય છે.
અને ત્રીજા ફાઇલ જેની સાથે અમે કામ કરી રહ્યા છીએ માટે નિર્દેશક છે.
તમે નોટિસ કરીશું કે લૂપ માટે અંત થાય છે જ્યારે fgets નલ આપે છે.
બે કારણ કે આ રીતે થઇ શકે છે.
પ્રથમ, એક ભૂલ આવી શકે છે.
બીજું, અને વધુ તો ફાઈલના અંતે પહોંચી હતી અને કોઇ વધુ અક્ષરો વાંચી હતી.
કિસ્સામાં તમે આશ્ચર્ય પામી રહ્યા છીએ, બે કાર્યો અસ્તિત્વમાં નથી કે અમને જણાવો માટે પરવાનગી આપે છે
કારણ કે જે આ ચોક્કસ નલ નિર્દેશક માટે કારણ છે.
અને, આશ્ચર્યજનક નથી, કારણ કે તેઓ ફાઇલો સાથે કામ સાથે કરી છે,
બંને ferror કાર્ય અને અક્ષર એફ સાથે feof કાર્ય શરુ થાય છે.
>> છેલ્લે, પહેલાં આપણે એવા તારણ પર, એક ફાઈલ કાર્ય ઓવરને વિશે ઝડપી નોંધ,
, જેમાં માત્ર ઉલ્લેખ કર્યો છે, feof તરીકે લખાયેલ છે.
ઘણી વખત તમે તમારી જાતને શોધી જ્યારે અને આંટીઓ ઉપયોગ માટે ક્રમશઃ ફાઇલો દ્વારા તમારી રીતે વાંચી શકશો.
આમ, તમે એક આ આંટીઓ અંત રસ્તો જરૂર પછી તમે આ ફાઇલો ઓવરને સુધી પહોંચી શકશો.
તમારી ફાઈલ નિર્દેશક પર feof કૉલિંગ અને જોવા માટે જો તે સાચું છે ચકાસીને
કે જે હમણાં જ આવું કરશે.
આમ, શરત (feof! (Fp)) સાથે જ્યારે લૂપ સંપૂર્ણ યોગ્ય ઉકેલ જેવી લાગે.
જોકે કહેવું, અમે અમારા લખાણ ફાઈલ બાકી રેખા હોય છે.
અમે અમારા જ્યારે લૂપ દાખલ કરો અને બધું બહાર કામ આયોજન કરીશું નહીં.
આગામી દ્વારા રાઉન્ડ પર, અમારા કાર્યક્રમ જોવા માટે જો fp ઓફ feof સાચું છે તે ચકાસવા કરશે,
પરંતુ - અને આ નિર્ણાયક અહીં સમજવા બિંદુ છે -
તે સાચું હજી સુધી રહેશે.
કે કારણ કે feof હેતુ માટે તપાસ નથી
જો વાંચી કામ કરવા માટે આગામી કોલ ફાઇલ ઓવરને ફટકો પડશે,
પરંતુ તપાસો કે નહીં ફાઈલ ઓવરને પહેલાથી જ પહોંચી ગઈ છે.
આ ઉદાહરણ કિસ્સામાં,
અમારી ફાઈલ ના છેલ્લા વાક્ય વાંચવા સંપૂર્ણપણે સરળતાથી જાય છે,
પરંતુ હજુ સુધી કાર્યક્રમ છે કે અમે અમારી ફાઈલ ઓવરને ફટકો કર્યું છે ખબર નથી.
તે જ્યાં સુધી તે એક વધારાની વાંચી નથી કે તે ફાઈલ ઓવરને ગણકો.
આમ, યોગ્ય સ્થિતિ નીચેના હશે:
fgets અને તેના ત્રણ દલીલો - ઉત્પાદન, ઉત્પાદન કદ, અને fp -
અને સમાન નથી કે તમામ null છે.
આ અભિગમ અમે printer.c માં લીધો છે,
અને આ કિસ્સામાં, લૂપ બહાર નીકળે છે પછી,
તમે feof અથવા ferror આ લૂપ બહાર નીકળતા માટે ચોક્કસ તર્ક એ વપરાશકર્તા જાણ માટે કહી શકે છે.
>> માટે લેખન અને ફાઈલ માંથી વાંચવા તેના મોટા ભાગના આધારભૂત છે,
એક સરળ પ્રક્રિયા 3-ભાગ છે.
પ્રથમ, અમે ફાઈલ ખોલો.
બીજું, અમે અમારા ફાઇલમાં કેટલીક વસ્તુઓ મૂકી છે અથવા તેને બહાર કેટલીક વસ્તુઓ લે છે.
ત્રીજું, અમે ફાઈલ બંધ કરો.
પ્રથમ અને છેલ્લા ભાગો સરળ હોય છે.
મધ્યમ ભાગ છે જ્યાં કાવતરાબાજ સામગ્રી આવેલું છે.
અને છતાં હૂડ નીચે આપણે હંમેશા zeros અને શૈલીઓનો લાંબા ક્રમ સાથે કામ કરીએ છીએ,
તે વખતે બેધ્યાનપણું એક સ્તર ઉમેરવા કોડિંગ મદદ કરતું નથી,
કે કંઈક કે જે વધુ નજીકથી મળતી આવે છે કે અમે શું જોવાનું ઉપયોગ કરી રહ્યા છો માં ક્રમ કરે છે.
ઉદાહરણ તરીકે, જો આપણે એક બીટમેપ 24-bit ફાઇલ સાથે કામ કરી રહ્યા છીએ,
અમે સંભવિત અથવા વાંચી આવશે એક સમયે ત્રણ બાઇટ્સ લખ્યું.
, કે જે કિસ્સામાં તે અર્થમાં બનાવવા માટે નક્કી કરે છે અને યોગ્ય નામ આપશે
એક સ્ટ્રક્ટ કે 3 બાઇટ્સ મોટી છે.
>> જોકે ફાઇલો સાથે કામ જટિલ લાગે,
તેમને ઉપયોગ અમને સાચી નોંધપાત્ર કંઈક પરવાનગી આપે છે.
અમે અમારા કાર્યક્રમ બહાર વિશ્વની સ્થિતિ બદલી શકો છો,
અમે કંઈક કે જે અમારા કાર્યક્રમ જીવન બહાર રહે બનાવી શકો છો,
અથવા આપણે પણ કંઈક કે જે પહેલાં અમારી કાર્યક્રમ ચાલી શરૂ બનાવવામાં આવી હતી બદલી શકો છો.
ફાઈલો સાથે સંપર્ક સી માં પ્રોગ્રામીંગ ખરેખર શક્તિશાળી હિસ્સો છે
અને હું એ જોવા માટે કે તમે શું કરવા માટે આવે કોડ માં તેની સાથે બનાવવા જઈ રહ્યાં છો ઉત્સાહિત છું.
મારું નામ જેસન Hirschhorn છે. આ CS50 છે.
[CS50.TV]
>> [હાસ્ય]
ઠીક છે. એક લો. અહીં અમે જાઓ.
જ્યારે અમે ફાઈલ લાગે છે - ઓહ >> રાહ જુઓ,. માફ કરશો.
[હાસ્ય] ઠીક.
ત્યાં હે.
જ્યારે અમે ફાઈલ લાગે છે -
જ્યારે તમે ફાઈલ લાગે છે - ઠીક છે. મને કહો જ્યારે તમે તૈયાર છો.
ઓહ, મહાન.
એક teleprompter માંથી વાંચવા છતાં લાગે - નં. મારા ખરાબ.