>> વક્તા: અત્યાર સુધી, તે સંભવિત છે તમારા કાર્યક્રમો મોટા ભાગના
થોડી ક્ષણજીવી રહી છે.
તમે મારિયો અથવા લોભી જેવા કાર્યક્રમ ચાલે છે.
તે કદાચ પૂછે છે, કંઈક કરે છે કેટલીક માહિતી માટે વપરાશકર્તા,
સ્ક્રીન પર અમુક આઉટપુટ છાપો, પરંતુ તે પછી તમારા કાર્યક્રમ પર જ્યારે
ત્યાં કોઈ પુરાવા ખરેખર છે તે ક્યારેય પ્રથમ સ્થાને ચલાવી હતી.
મને ખાતરી છે કે, તમે છોડી ગયા છે શકે છે, અર્થ તે ટર્મિનલ વિન્ડોમાં ખોલો
તમે તમારી સ્ક્રીન સાફ પરંતુ જો ત્યાં છે તે અસ્તિત્વમાં છે કે જે ખરેખર કોઈ પુરાવા.
અમે સ્ટોર એક સાધન નથી નિરંતર માહિતી, માહિતી
કે અમારા પછી અસ્તિત્વમાં કાર્યક્રમ ચાલી બંધ થઈ ગયું છે,
અથવા આપણે આ બિંદુ સુધી નથી.
સદનસીબે છતાં, સી કરે ક્ષમતા સાથે અમને પૂરી પાડે છે
અમલીકરણ દ્વારા આ કરવા માટે કહેવાય કંઈક
ફાઈલ એક માળખું છે કે જે મૂળભૂત તમે ડબલ કરશે કે જે ફાઈલ રજૂ
તમે છો, તો તમારા કમ્પ્યુટર પર ક્લિક કરો ગ્રાફિકલ વપરાશકર્તા પર્યાવરણ માટે વપરાય છે.
સામાન્ય રીતે કામ જ્યારે C સાથે, અમે ખરેખર છો
સાથે કામ કરી રહ્યું પોઇન્ટર ફાઇલ ફાઈલો છે માટે stars--
થોડો સિવાય અમે થોડા વિશે વાત ત્યારે
કાર્યો કે ફાઇલ પોઇન્ટર સાથે કામ કરે છે.
તમે ખરેખર ખોદવામાં આવ્યા છે કરવાની જરૂર નથી સમજ પોઇન્ટર માં ખૂબ ઊંડા
પોતાને.
થોડી નાનકડું બીટ છે અમે તેમને વિશે વાત કરશે, જ્યાં
પરંતુ સામાન્ય રીતે પોઇંટરો ફાઇલ અને પોઇન્ટર, જંગ, જ્યારે
બરાબર આ જ વાત નથી.
>> હવે હું ત્યારે શું અર્થ નથી હું સતત માહિતી કહે છે?
નિરંતર માહિતી શું છે?
અમે તે વિશે શા માટે કાળજી નથી?
કે, ઉદાહરણ તરીકે, કહે છે તમે એક કાર્યક્રમ ચલાવી રહ્યા છો
અથવા તમે ફરીથી લખાઈ કર્યું એક રમત છે કે કાર્યક્રમ,
અને તમે ટ્રેક રાખવા માંગો છો વપરાશકર્તા ચાલ બધી
જેથી કંઈક ખોટું છે કે કદાચ જો, તમે આ રમત પછી ફાઈલ સમીક્ષા કરી શકો છો.
કે જ્યારે અમે શું અર્થ છે નિરંતર માહિતી વિશે વાત કરો.
>> ચાલી દરમિયાન તમારા કાર્યક્રમ, ફાઇલ બનાવવામાં આવેલ છે.
અને જ્યારે તમારા કાર્યક્રમ ચાલી બંધ થઈ ગયું છે,
તે ફાઈલ હજુ પણ તમારી સિસ્ટમ પર અસ્તિત્વ ધરાવે છે.
અને અમે તેને જોવા અને તે પરીક્ષણ કરી શકે છે.
અને જેથી કાર્યક્રમ સુયોજિત કરવામાં આવશે કેટલાક સતત માહિતી બનાવવામાં આવી છે,
માહિતી કાર્યક્રમ પછી અસ્તિત્વમાં ચાલી સમાપ્ત થઈ ગઈ છે.
>> હવે કામ કરે છે આ તમામ કાર્યોને ફાઈલો બનાવવા અને હેરફેર સાથે
વિવિધ રીતે તેમને ધોરણ io.h માં રહે છે,
જે એક હેડર ફાઈલ છે કે તમે કદાચ પાઉન્ડ કરવામાં આવી છે
ખૂબ ટોચ પર સમાવેશ થાય છે તમારા કાર્યક્રમો ખૂબ બધા
તે એક છે કારણ કે અમારા માટે સૌથી વધુ ઉપયોગી કાર્યો,
પણ દે છે કે printf, ધોરણ io.h. રહે
તેથી જો તમે સમાવેશ પાઉન્ડ કરવાની જરૂર નથી કોઈપણ વધારાના ફાઈલો કદાચ
ક્રમમાં ફાઇલ પોઇન્ટર સાથે કામ કરવા માટે.
>> હવે દરેક એક ફાઈલ નિર્દેશક કાર્ય, અથવા દરેક એક ફાઈલ I / O, ઇનપુટ આઉટપુટ
કાર્ય, એક તરીકે સ્વીકારે છે તેના પરિમાણો અથવા ઇનપુટ્સ
સિવાય ફાઇલ નિર્દેશક એક, fopen, જે
તમે ફાઈલ વિચાર ઉપયોગ શું છે પ્રથમ સ્થાને નિર્દેશક.
પરંતુ તમે ખોલી છે પછી ફાઇલ અને તમે ફાઈલ પોઇન્ટર વિચાર,
પછી તમે તેમને પસાર કરી શકો છો વિવિધ કાર્યો માટે દલીલો
અમે વિશે વાત કરવા જઈ રહ્યાં છો આજે, તેમજ અન્ય ઘણા લોકો
કે જેથી તમે ફાઈલો સાથે કામ કરી શકે છે.
>> તેથી છ ખૂબ હોય છે સામાન્ય મૂળભૂત મુદ્દાઓ
આજે આપણે વિશે વાત કરવા જઈ રહ્યાં છે.
fopen અને તેના સાથી કાર્ય fclose, fgetc
અને તેના સાથી કાર્ય fputc, અને fread અને તેના સાથી કાર્ય,
fwrite.
તેથી આપણે તેને અધિકાર વિચાર કરીએ.
>> fopen-- તે શું કરે છે?
વેલ, તે ફાઇલ ખોલે છે અને તે તે તમે ફાઈલ નિર્દેશક આપે છે,
તેથી પછી તમે ઉપયોગ કરી શકો છો કે એક દલીલ તરીકે નિર્દેશક ફાઇલ
અન્ય ફાઈલ I / O કાર્યો કોઇ પણ.
સૌથી મહત્વની બાબત fopen સાથે યાદ
તમે ખોલી છે છે કે પછી ફાઇલ અથવા અહીં એક જેવી કોલ કર્યો હતો,
તમે તેની ખાતરી કરવા માટે તપાસ કરવાની જરૂર છે કે તમે પાછા મળી કે નિર્દેશક
નલ માટે સમાન નથી.
તમે વિડિઓ પર જોવાયેલા ન હોય તો પોઇન્ટર, આ અર્થમાં બનાવવા શકે છે.
પરંતુ તમે પ્રયાસ કરો અને ખોટો સંદર્ભ તો એક નલ નિર્દેશક યાદ છે,
તમારા કાર્યક્રમ કદાચ જોખમાશે સેગ્મેન્ટેશન [અશ્રાવ્ય].
અમે ખાતરી કરો કે કરવા માંગો છો અમે કાયદેસર નિર્દેશક પાછા મળી.
સમય મોટા ભાગના અમે પાછા કાયદેસર નિર્દેશક મેળવેલ છે
અને તે એક સમસ્યા રહેશે નહીં.
>> તેથી અમે કેવી રીતે કોલ fopen માટે કરી શકું?
તે આ જેમ ખૂબ ખૂબ લાગે છે.
સામાન્ય હોવા ptr ptr-- ફાઇલ સ્ટાર નિર્દેશક fopen ફાઇલ નામ
અને અમે બે વસ્તુઓ ફાઈલ નામ પસાર અને કામગીરી અમે હાથ કરવા માંગો છો.
તેથી અમે જેવી લાગે છે કે કોલ હોય શકે છે આ ફાઇલ સ્ટાર ptr 1 fopen બરાબર
file1.txt.
અને હું પસંદ કરેલા કામગીરી આર છે.
>> તેથી શું તમે આર અહીં લાગે છે નથી?
વસ્તુઓ આ પ્રકારના શું છે અમે ફાઇલો માટે કરવા માટે સમર્થ હોઈ શકે છે?
તેથી આર કામગીરી છે કે અમે અમે એક ફાઈલ વાંચી કરવા માંગો છો જ્યારે પસંદ કરો.
તેથી અમે મૂળભૂત ત્યારે કરશે અમે આ જેવી કૉલ કરો
જાતને એક ફાઈલ નિર્દેશક મેળવવામાં આવશે અમે પછી માહિતી વાંચી શકે છે, જેમ કે
file1.txt છે.
>> એ જ રીતે, અમે ફાઈલ 2.txt ખોલી શકે ptr2 લખવા માટે અને તેથી અમે પસાર કરી શકો છો,
હું અહીં બનાવેલ ફાઇલ નિર્દેશક, કોઈપણ કાર્ય કરવા માટે એક દલીલ તરીકે
ફાઈલ માહિતી લખે છે.
અને લેખન માટે સમાન, ત્યાં પણ વિકલ્પ છે, કંઈક ઉમેરવા માટે.
વચ્ચે તફાવત લેખન અને ઉમેરવાની
હોવા તમે ફાઈલ લખી ત્યારે, તમે લખવા માટે fopen કૉલ કરવા માટે કરો છો, તો
અને તે ફાઇલ પહેલેથી તે અસ્તિત્વમાં સમગ્ર ફાઈલ પર ફરીથી લખી જઈ રહી છે.
તે શરૂ કરવા જઈ રહ્યું છે ખૂબ શરૂઆતમાં,
બધી માહિતી કાઢી નાંખવા કે ત્યાં પહેલેથી જ છે.
>> તમે ઉમેરવાની માટે તેને ખોલવા માટે જ્યારે જો, તે ફાઈલ ઓવરને પર જશે
પહેલેથી જ લખાણ હોય તો તે અથવા તે માહિતી
અને તે પછી શરૂ થશે ત્યાંથી લખી.
તેથી તમે કોઇ ગુમાવી નહીં જો તમે પહેલાં કર્યું છે માહિતી.
તમે લખી અથવા ઉમેરવા માંગો છો કે કેમ સૉર્ટ ની પરિસ્થિતિ પર આધાર રાખે છે.
પરંતુ તમે કદાચ શું ખબર પડશે સમય આવે ત્યારે યોગ્ય કામગીરી છે.
જેથી fopen છે.
>> શું fclose વિશે શું?
વેલ, તે સારુ સરળ, fclose ફક્ત ફાઇલ નિર્દેશક સ્વીકારે છે.
અને તમે અપેક્ષા શકે છે, તે ફાઇલ બંધ.
અમે ફાઈલ બંધ કરી અને એકવાર, અમે નથી કરી શકો છો કોઈ વધુ ફાઇલ I / O કાર્યો કરે છે
વાંચન અથવા ફાઇલ પર લખી.
અમે ફરીથી ખોલવા માટે છે ક્રમમાં બીજા સમય ફાઈલ
સાથે કામ ચાલુ રાખવા માટે તે I / O કાર્યો ઉપયોગ કરે છે.
અમે પૂર્ણ કરી લીધું તેથી fclose અર્થ આ ફાઇલ સાથે કામ કરે છે.
અને અમે પસાર કરવા માટે જરૂર છે ફાઇલ નિર્દેશક ના નામ પર.
એક દંપતિ પહેલા સ્લાઇડ્સ પર તેથી, અમે વાંચન માટે fopened ફાઇલ 1 ટપકું લખાણ
અને અમે તે સોંપાયેલ ptr1 માટે નિર્દેશક ફાઇલ.
હવે અમે છો નક્કી કર્યું છે તે ફાઈલ માંથી વાંચવા થાય છે.
અમે તેની સાથે કોઈ વધુ કરવાની જરૂર નથી.
અમે માત્ર fclose ptr1 કરી શકો છો.
અને એ જ રીતે, અમે કરી શકે અન્ય મુદ્દાઓ fclose.
બધા અધિકાર.
તેથી તે ખોલવાનું અને બંધ છે.
તે બે મૂળભૂત છે કામગીરી શરૂ થાય છે.
>> હવે અમે ખરેખર કરવા માંગો છો કેટલીક રસપ્રદ સામગ્રી નથી,
અને પ્રથમ કાર્ય છે કે અમે પડશે કે fgetc-- છે કે શું કરશે જોવા
એક અક્ષર વિચાર ફાઇલ.
તે સામાન્ય fgetc શું છે અનુવાદ થશે.
જીવન તેના ધ્યેય છે આગલા અક્ષર વાંચી,
અથવા આ તમારા ખૂબ જ છે, તો fgetc પ્રથમ કોલ
ચોક્કસ ફાઈલ માટે, પ્રથમ અક્ષર.
પરંતુ તે પછી, તમે આગામી એક વિચાર
તે ફાઈલ ખૂબ જ આગામી પાત્ર, એક અક્ષર ચલ અને સ્ટોર્સ તે.
અમે અહીં કર્યું છે, ઘરનાં પરચૂરણ કામો સીએચ, fgetc બરાબર
ફાઇલ નિર્દેશક નામે પસાર કરે છે.
ફરીથી, તે ખૂબ જ છે યાદ રાખો અહીં મહત્વનું
ક્રમમાં હોય કે આ ઓપરેશન સફળ,
ફાઇલ નિર્દેશક પોતે must've વાંચન માટે ખોલવામાં આવી છે.
અમે ફાઈલ માંથી એક અક્ષર વાંચી શકતા નથી અમે લખવા માટે ખોલી કે નિર્દેશક.
જેથી એક છે fopen મર્યાદાઓ, અધિકાર?
અમે પ્રતિબંધિત છે જાતને માત્ર અભિનય
એક ફાઈલ નિર્દેશક સાથે એક કામગીરી.
અમે વાંચી કરવા ઈચ્છતો હોય તો અને એ જ ફાઈલ લખી,
અમે ઓપન બે અલગ હશે એ જ ફાઈલ કરવા માટે ફાઇલ પોઇન્ટર
વાંચન માટે એક, લેખન માટે.
>> તેથી ફરીથી, આ માત્ર કારણ હું હવે લાવવા
અમે કૉલ કરવા માટે જઈ રહ્યાં છો કારણ કે જો fgetc માટે, તે ફાઇલ નિર્દેશક must've
વાંચન માટે ખોલવામાં આવી છે.
અને પછી ખૂબ સરળ, બધા અમે શું કરવાની જરૂર છે
ફાઇલ નિર્દેશક નામે પાસ છે.
તેથી ઘરનાં પરચૂરણ કામો સીએચ fgetc ptr1 સમકક્ષ હોય છે.
>> તે અમને બનશે આગામી character--
અથવા ફરી આ પ્રથમ છે, તો અમે આ ફોન કર્યા સમય,
પ્રથમ character-- ગમે ફાઇલ ptr1 દ્વારા નિર્દેશ કરવામાં આવે છે.
તે ફાઈલ 1 ટપકું લખાણ હતું કે યાદ અપાવે છે.
તે છે કે પ્રથમ અક્ષર મળશે અને અમે ચલ સીએચ માં સંગ્રહે પડશે.
ખૂબ સરળ.
તેથી અમે માત્ર ત્રણ પર જોવામાં કર્યું છે કાર્યો અને અમે પહેલાથી જ
ખૂબ સુઘડ કંઈક કરી શકો છો.
>> અમે આ ક્ષમતા લેવા તેથી જો એક અક્ષર મેળવવાની
અને અમે લૂપ જેથી તેને અમે અક્ષરો વિચાર ચાલુ
ફાઇલ પર અને ઉપર અને over-- હવે અમે
દરેક એક વાંચી શકે છે ફાઇલ પાત્ર.
અને અમે દરેક અક્ષર છાપો તો અમે તેને વાંચી પછી તરત જ,
અમે હવે એક ફાઈલ વાંચી છે અને સ્ક્રીન પર તેના સમાવિષ્ટો મુદ્રિત.
અમે અસરકારક રીતે શ્રેણીબદ્ધ કર્યું સ્ક્રીન પર તે ફાઇલ.
અને તે છે શું Linux આદેશ બિલાડી કરે છે.
>> તમે ફાઇલ નામ બિલાડી લખો, તો તે સમગ્ર સમાવિષ્ટો છાપશે
તમારા ટર્મિનલ વિન્ડોમાં ફાઈલની.
અને તેથી અહીં આ થોડું લૂપ, કોડ માત્ર ત્રણ રેખાઓ,
પરંતુ તે અસરકારક રીતે ડુપ્લિકેટ્સ Linux આદેશ કેટ.
તેથી આ વાક્યરચના શકે , થોડો વિચિત્ર લાગે
પરંતુ અહીં શું થઈ રહ્યું છે.
સીએચ fgetc બરાબર, જ્યારે ptr નથી તે સમગ્ર કોળિયો છે EOF-- સમાન,
પરંતુ તે માત્ર તોડી દો તેથી તે બંધારણ પર સ્પષ્ટ છે.
હું તેને મજબૂત કર્યું જગ્યા ખાતર,
તે થોડી છે, તેમ છતાં વાક્યરચના અનુસાર મુશ્કેલ.
>> જેથી લીલા અધિકાર આ ભાગ હવે, તે શું કરી રહ્યો છે?
ઠીક છે, કે અમારા fgetc કૉલ, બરાબર ને?
અમે તે પહેલાં જોઇ છે.
તે એક મેળવવા છે ફાઇલ પાત્ર.
પછી અમે તે તુલના EOF સામે પાત્ર.
EOF છે કે ખાસ કિંમત છે ધોરણ io.h, માં વ્યાખ્યાયિત થયેલ છે
ફાઇલ પાત્ર અંત છે.
જેથી મૂળભૂત શું ચાલી રહ્યું છે તે આ લૂપ એક અક્ષર વાંચી હશે છે,
, આ EOF સાથે સરખામણી ફાઇલ પાત્ર અંત થાય છે.
તેઓ સરખા નહિં હોય, તેથી અમે છે , ફાઈલ ઓવરને પહોંચી
અમે તે અક્ષર છાપો પડશે.
પછી અમે પાછા જવા પડશે ફરીથી લૂપ પ્રારંભ.
અમે એક અક્ષર મળશે, ચેક EOF સામે, તેથી તેને છાપી બહાર, અને
અને તેથી પર અને તેથી પર, જે રીતે દ્વારા રહ્યાં
અમે ફાઈલ ઓવરને પહોંચી ગયા છો ત્યાં સુધી.
અને પછી તે બિંદુએ, અમે મુદ્રિત હશે
ફાઈલ સમગ્ર સમાવિષ્ટો બહાર.
તેથી ફરી, અમે માત્ર જોઇ fopen, fclose અને fgetc
અને પહેલેથી જ અમે ડુપ્લિકેટ કરી શકો છો એ Linux ટર્મિનલ આદેશ.
>> હું શરૂઆતમાં જણાવ્યું હતું કે, અમે fgetc અને fputc હતી,
અને fputc સાથી હતી fgetc કાર્ય.
અને તેથી, જેમ કે તમે કલ્પના કરી શકે છે તે લેખન સમકક્ષ છે.
તે અમને લખવા માટે પરવાનગી આપે છે ફાઈલ એક પાત્ર.
>> ફરીથી, આ ચેતવણી છે, માત્ર તે fgetc સાથે હતી, જેમ કે ફાઈલ
અમે must've માટે લખી રહ્યાં છે કે આવી લેખન માટે અથવા ઉમેરવાની માટે ખૂલ્લું હતું.
અમે પ્રયાસ અને એક ફાઇલ પર fputc વાપરો તો અમે વાંચન માટે ખોલી છે કે,
અમે સહન કરવા જઈ રહ્યાં છો એક ભૂલ એક બીટ છે.
પરંતુ કોલ ખૂબ સરળ છે.
fputc મૂડી ptr2, બધા કે શું થઈ રહ્યું છે તે છે
પત્ર લખવા જઈ ફાઇલમાં 2 ટપકું માં
આ નામ પણ હતું, જે લખાણ, અમે ખોલી અને સોંપેલ તે ફાઇલ
નિર્દેશક ptr2 છે.
તેથી અમે એક લખી રહ્યા છીએ કેપિટલ 2 ટપકું લખાણ ફાઈલ.
અને અમે એક આશ્ચર્યચિહ્ન લખીશ 3 ટપકું ફાઈલમાં નિર્દેશ
ptr3 દ્વારા નિર્દેશ કરવામાં આવ્યો હતો જે લખાણ.
તેથી ફરી, અહીં ખૂબ સરળ.
>> પરંતુ હવે અમે અન્ય વસ્તુ કરી શકો છો.
અમે આ ઉદાહરણ છે અમે માત્ર જતા હતા
બિલાડી નકલ કરવા માટે સમર્થ હોવા અંગે Linux આદેશ, છાપે છે કે એક
સ્ક્રીન પર.
ઠીક છે, હવે અમે ક્ષમતા હોય છે કે ફાઇલો માંથી અક્ષરો વાંચવા માટે
અને, ફાઇલો અક્ષરો લખવા શા માટે આપણે માત્ર કે અલગ નથી
fputc માટે કૉલ સાથે printf માટે ફોન કરો.
>> અને હવે અમે સીપી ડુપ્લિકેટ કર્યું છે, એક ખૂબ જ મૂળભૂત Linux આદેશ
અમે માર્ગ લાંબા વિશે વાત કરી પહેલા Linux માં વિડિઓ આદેશો.
અમે અસરકારક રીતે કર્યું અહીં કે ડુપ્લિકેટ.
અમે એક અક્ષર વાંચી રહ્યા છો અને પછી અમે છો બીજી ફાઇલ કે પાત્ર લખવાનું.
એક ફાઈલ વાંચન, લેખન ઉપર અને ઉપર અન્ય માટે
અને ઉપર ફરીથી અમે EOF હિટ સુધી.
અમે ઓવરને મળી છે ફાઇલ અમે માંથી નકલ કરવાનો પ્રયાસ કરી રહ્યાં છો.
અને તે દ્વારા આપણે બધા તેવા પરચૂરણ ખર્ચ પડશે અક્ષરો અમે ફાઇલ કરવાની જરૂર
અમે લખી રહ્યાં છે.
તેથી આ સી.પી., Linux નકલ આદેશ છે.
>> ખૂબ જ પ્રારંભમાં આ વિડિઓ, હું ચેતવણી હતી
અમે એક ચર્ચા છે કે જે પોઇન્ટર વિશે થોડુંક.
અમે છો જ્યાં અહીં ખાસ છે પોઇન્ટર વિશે વાત કરવા જઈ
વધુમાં પોઇન્ટર ફાઈલ કરવા માટે.
તેથી આ કાર્ય પ્રકારની ડરામણી લાગે છે.
તે ઘણા પરિમાણો મળ્યું છે.
અહીં પર જવા ઘણો છે.
વિવિધ ઘણો છે રંગો અને લખાણો.
પરંતુ ખરેખર, તે માત્ર છે fgetc ના જિનેરિક વર્ઝન
કે અમને કોઇ વિચાર પરવાનગી આપે છે માહિતી જથ્થો.
તે અમે હો તો થોડી બિનકાર્યક્ષમ હોઈ શકે છે એક સમયે અક્ષરો એક મેળવવામાં,
ફાઇલ વારો એક સમયે એક પાત્ર.
તે વિચાર NICER હોઈ નથી એક સમયે એક સમય અથવા 500 100?
>> વેલ, fread અને તેના સાથી કાર્ય fwrite, અમે વિશે વાત કરીશું
બીજા, અમને માત્ર તે કરવા માટે પરવાનગી આપે છે.
અમે એક મનસ્વી રકમ વાંચી શકે છે એક ફાઇલ માંથી માહિતી
અને અમે ક્યાંક કામચલાઉ સ્ટોર કરે છે.
તેના બદલે માત્ર માટે સક્ષમ છે એક ચલ તે ફિટ
અમે એક એરે માં સંગ્રહે કરવાની જરૂર પડી શકે.
અને તેથી, અમે ચાર પસાર દલીલો નિર્દેશક fread-- માટે
અમે છો જ્યાં પાંચ આંકડાના US સ્થાન માહિતી અત્યારે સંગ્રહ કરવા જઈ,
કેવી રીતે જાણકારી દરેક એકમ મોટા હશે, માહિતી કેટલા એકમો
અમે હસ્તગત કરવા માંગો છો, અને જે ફાઈલ અમે તેમને વિચાર કરવા માંગો છો.
કદાચ શ્રેષ્ઠ સચિત્ર અહીં એક ઉદાહરણ છે.
તેથી ચાલો આપણે જાહેર કહે છે કે દો 10 પૂર્ણાંકો ઝાકઝમાળ.
અમે હમણાં જ જાહેર કર્યું છે આપખુદ સ્ટેક આગમન 10 INT.
તેથી તે ખૂબ સરળ છે.
હવે અમે શું છતાં કરી રહ્યા છીએ છે frecall અમે પૂર્ણાંક કદ વાંચી રહ્યા છો છે
વખત માહિતી 10 બાઇટ્સ.
પૂર્ણાંક અસ્તિત્વ માપ કે four-- સી પૂર્ણાંક માપ.
>> તેથી શું અમે કરી રહ્યા છીએ અમે વાંચી રહ્યા છો છે માહિતી વર્થ 40 બાઇટ્સ
ફાઇલ ptr દ્વારા પર ધ્યાન.
અને અમે તે સ્ટોર કરી રહ્યાં 40 બાઇટ્સ ક્યાંક
અમે કોરે સુયોજિત છે જ્યાં મેમરી વર્થ 40 બાઇટ્સ.
સદનસીબે, અમે પહેલેથી જ દ્વારા તે કર્યું છે કે એરે જમણી ત્યાં, આગમન જાહેર.
હોલ્ડિંગ કે સક્ષમ છે 10 ચાર બાઇટ એકમો.
કુલ તેથી, તે 40 પકડી શકે છે બાઇટ્સ માહિતી વર્થ.
અને અમે હવે 40 બાઇટ્સ વાંચી રહ્યા ફાઇલ માહિતી,
અને અમે આગમન માં સ્ટોર કરી રહ્યાં છો.
>> પોઇન્ટર પર વિડિઓ થી યાદ છે કે આવા આગમન તરીકે એરે ના નામ,
ખરેખર માત્ર એક નિર્દેશક છે તેના પ્રથમ તત્વ છે.
તેથી અમે ત્યાં આગમન પસાર, ત્યારે અમે એક નિર્દેશક પસાર, હકીકતમાં, છે.
>> એ જ રીતે અમે આ કરવા કરી શકો છો અમે જરૂરી નથી
સ્ટેક પર અમારી બફર સેવ જરૂર છે.
અમે પણ ગતિશીલ ફાળવણી કરી શકે છે એક malloc ઉપયોગ કરીને, આ જેવા બફર.
ત્યારે અમે યાદ રાખો ગતિશીલ મેમરી ફાળવણી,
અમે પર બચત કરી રહ્યાં છો ઢગલો નથી, સ્ટેક.
પરંતુ તે હજુ પણ બફર છે.
>> તે હજુ પણ, આ કિસ્સામાં છે, માહિતી 640 બાઇટ્સ હોલ્ડિંગ
ડબલ આઠ બાઇટ્સ લે છે.
અને અમે તેમને 80 માટે પૂછી રહ્યાં છો.
અમે જગ્યા છે કરવા માંગો છો 80 ડબલ્સ ધરાવે છે.
તેથી 80 ગુણ્યા 8 640 બાઇટ્સ માહિતી છે.
અને fread કે કોલ છે માહિતી 640 બાઇટ્સ એકત્ર
ફાઇલ દ્વારા નિર્દેશ થી ptr અને arr2 હવે સ્ટોર.
>> હવે અમે પણ fread સારવાર કરી શકે છે માત્ર fgetc કૉલ ગમે છે.
આ કિસ્સામાં, અમે માત્ર પ્રયાસ કરી રહ્યા છો ફાઇલ એક અક્ષર મળે છે.
અને અમે એક જરૂર નથી એરે એક અક્ષર ધરાવે છે.
અમે હમણાં જ તે સ્ટોર કરી શકો છો એક અક્ષર ચલ.
>> કેચ છતાં છે, કે જે અમે માત્ર એક ચલ હોય ત્યારે,
અમે માં પસાર કરવાની જરૂર છે કે ચલ સરનામું
યાદ છે કે કારણ fread પ્રથમ દલીલ
સ્થાન અને મેમરી માટે નિર્દેશક છે અમે આ માહિતી અત્યારે સંગ્રહ કરવા માંગો છો જ્યાં.
ફરીથી, એક નામ એરે એક નિર્દેશક છે.
તેથી અમે 'ચિન્હ એરે શું કરવાની જરૂર નથી.
પરંતુ સી, અક્ષર સી અહીં, એક એરે નથી.
તે માત્ર એક ચલ છે.
અને તેથી અમે એક પસાર કરવાની જરૂર છે નું ચિહ્ન સી દર્શાવવા માટે
કે અમે માંગો છો જ્યાં સરનામું છે કે માહિતી આ એક બાઈટ સંગ્રહવા માટે,
આ એક પાત્ર કે અમે ptr માંથી એકત્ર કરી રહ્યાં છો.
હું મારફતે જાઓ પડશે Fwrite-- આ થોડો વધુ
quickly-- ખૂબ ખૂબ છે fread ચોક્કસ સમકક્ષ
તે લખવા માટે સિવાય તેના બદલે વાંચન, માત્ર
આ other-- જેમ આપણે ખુલ્લા પડ્યું અને બંધ, એક અક્ષર મેળવવા માટે,
એક અક્ષર લખો.
હવે તે મનસ્વી વિચાર છે માહિતી જથ્થો,
માહિતી અધિકાર મનસ્વી રકમ.
તેથી પહેલા જેવી, અમે કરી શકો છો 10 પૂર્ણાંકો ઝાકઝમાળ છે
જ્યાં અમે પહેલેથી જ હોય ​​છે માહિતી કદાચ, સંગ્રહિત.
>> તે કદાચ કોડ કેટલાક લાઇન્સ હતી કે આ બે વચ્ચે જવું જોઈએ
હું સાથે આગમન ભરો જ્યાં અર્થપૂર્ણ કંઈક.
હું 10 અલગ અલગ પૂર્ણાંકો સાથે ભરો.
અને તેની જગ્યાએ, હું શું છું કરી આગમન લખવાનું છે
અને આગમન ના જાણકારી એકઠા કરે છે.
અને હું કે માહિતી લઈ રહ્યો છું અને ફાઈલ માં મૂકી.
>> તેથી તેના બદલે તે હોવાની બફર કરવાનો ફાઇલ,
અમે હવે જઈ રહ્યાં છો ફાઇલ બફર.
તેથી તે માત્ર વિપરીત છે.
માત્ર પહેલાં જેવી તેથી ફરી, અમે કરી શકો છો પણ મેમરી નો ઢગલો Chunk છે
અમે ગતિશીલ કર્યું કે ફાળવવામાં અને તે વાંચવામાં
અને ફાઈલ કે લખી.
>> અને અમે પણ એક ચલ છે એક બાઈટ હોલ્ડિંગ સક્ષમ
જેમ કે એક પાત્ર તરીકે જાણકારી.
પરંતુ ફરીથી, અમે પસાર કરવાની જરૂર છે કે ચલ સરનામું
અમે તેને વાંચવામાં કરવા માંગો છો.
તેથી અમે આ માહિતી લખી શકો છો અમે તે સરનામા પર શોધી
ફાઇલ નિર્દેશક, ptr.
>> અન્ય ઘણાં બધાં છે મહાન ફાઈલ I / O કાર્યો
આ ઉપરાંત વિવિધ બાબતો રાશિઓ આજે આપણે વિશે વાત કરી છે.
આ મુદ્દાઓ એક દંપતી તમને ઉપયોગી લાગે તેવા
fgets અને fputs છે, જે સમકક્ષ છે
fgetc અને fputc પરંતુ વાંચવા માટે એક ફાઈલ એક શબ્દમાળા.
તેના બદલે એક પાત્ર, તે સમગ્ર શબ્દમાળા વાંચી હશે.
મૂળભૂત પરવાનગી આપે છે fprintf, તમે ફાઈલ લખવા માટે printf ઉપયોગ કરે છે.
તમે શું કરી શકો છો તેથી જેમ ઉપયોગ ચલ બદલી વાક્યો
આ જગ્યામાં ટકા અને હું printf સાથે ટકા ડી, અને તેથી પર,
તમે એ જ રીતે લઇ શકે છે printf શબ્દમાળા અને કંઈક છાપવા
એક ફાઈલ કે ગમે છે.
>> fseek-- તમે ડીવીડી પ્લેયર હોય તો હું સામાન્ય રીતે અહીં ઉપયોગ અનુરૂપતા છે
પ્રકારની મદદથી જેમ તમારા રીવાઇન્ડ અને ફાસ્ટ ફોરવર્ડ
બટનો ફિલ્મ આસપાસ ખસેડવા.
એ જ રીતે, તમે ફાઈલ આસપાસ ખસેડી શકો છો.
અંદર વસ્તુઓ એક કે ફાઈલ બંધારણ
તમે એક સૂચક છે કે સી બનાવે છે જ્યાં તમે ફાઈલ છે.
તમે ખૂબ જ હોય ​​છે બાઇટ શૂન્ય પર, શરૂઆત?
તમે બાઇટ 100 હોય છે, બાઇટ 1000, અને તેથી પર?
તમે આપખુદ ખસેડવા fseek ઉપયોગ કરી શકો છો આગળ ધપાવવા અને પાછળ કે સૂચક.
>> અને ફરી, ftell એક ડીવીડી પ્લેયર માટે સમાન છે,
કહે છે કે થોડી ઘડિયાળ જેવી છે તમે કેટલા મિનિટ અને સેકન્ડ તમે
ચોક્કસ ફિલ્મ માં છે.
એ જ રીતે, ftell તમે કેવી રીતે કહે છે ઘણા બાઇટ્સ તમે ફાઈલ માં છે.
feof એક અલગ આવૃત્તિ છે તમે કરેલા કે શું શોધવા
આ ફાઈલ ઓવરને સુધી પહોંચી હતી.
અને ferror એક કાર્ય છે તમે ઉપયોગ કરી શકો છો
કંઈક છે કે શું શોધવા માટે ફાઇલ સાથે ખોટું કામ ગયો.
ફરીથી, આ માત્ર છે સપાટી ખંજવાળ.
પુષ્કળ વધુ ફાઇલ I / O હજુ પણ છે પ્રમાણભૂત io.h. કાર્યો
પરંતુ આ કદાચ તમે મળશે ફાઇલ પોઇન્ટર સાથે કામ કરવાનું શરૂ કર્યું.
હું ડો લોયડ છું.
આ CS50 છે.