[Powered by Google Translate] [5 SECTION ઓછુ: આરામદાયક]
[Nate Hardison, હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે.] [CS50.TV]
તેથી સ્વાગત ગાય્સ.
5 વિભાગ માટે આપનું સ્વાગત છે.
આ બિંદુએ, જેમણે 0 ક્વિઝ પૂર્ણ અને એવું જોવામાં તમે કેવી રીતે કર્યું છે,
આસ્થાપૂર્વક તમે ખરેખર સારું લાગે છે, કારણ કે હું ખૂબ આ વિભાગમાં સ્કોર્સ દ્વારા પ્રભાવિત થયા હતા.
અમારા ઑનલાઇન દર્શકો માટે, અમે પ્રશ્નો દંપતી પડ્યું
સમસ્યા સેટ પર છેલ્લા બે સમસ્યાઓ વિશે - અથવા ક્વિઝ પર બદલે.
તેથી અમે તે ઉપર ખરેખર ઝડપથી જાઓ કે જેથી દરેકને જુએ શું થયું જઈ રહ્યાં છો
અને કેવી રીતે માત્ર ઉકેલ પોતે જોઈ બદલે વાસ્તવિક ઉકેલ મારફતે પસાર થવા માટે.
અમે સમસ્યાઓ ના છેલ્લા દંપતી પર ખરેખર ઝડપથી જાઓ જઈ રહ્યાં છો, 32 અને 33.
જસ્ટ ફરી, તેથી ઑનલાઇન દર્શકો કે આ જોઈ શકે છે.
>> જો તમે તમારા 32 સમસ્યા છે, જે 13 પાનાં પર છે ચાલુ કરો,
16 બહાર 13, 32 સમસ્યા અદલબદલ વિશે બધું છે.
તે બે પૂર્ણાંકો જેઓ લગભગ તમામ હતી.
તે સમસ્યા છે કે અમે વ્યાખ્યાન માં વખત દંપતી પર ગયા છો છે.
અને અહીં, અમે તમને શું કહીને હતા કયા ઝડપી મેમરી ટ્રેસ છે.
માટે ચલો એ કિંમતો ભરો તરીકે તેઓ સ્ટેક પર છે
તરીકે કોડ આ સ્વેપ કાર્ય મારફતે જાય છે.
ખાસ કરીને, અમે શું અંતે શોધી રહ્યાં છો - I'm આ આઇપેડ મૂકી નીચે રહ્યું -
ખાસ કરીને, અમે જોઈ રહ્યાં છો શું છે આ રેખા 6 અહીં નંબર.
અને તેને પહેલાંના સમસ્યા માત્ર સંલગ્નતા માટે 6 નંબર છે.
અમે કરવા માંગો છો શું પ્રદર્શિત અથવા મેમરી રાજ્ય લેબલ
કારણ કે તે સમયે છે જ્યારે અમે આ વાક્ય 6 નંબર ચલાવો,
જે અસરકારક રીતે અમારી સ્વેપ કાર્ય પરથી અહીં વળતર છે.
જો અમે નીચે સ્ક્રોલ અહીં, અમે જોયું છે કે મેમરી બધું ના સરનામાં અમારા માટે આપવામાં આવી હતી.
આ ખૂબ જ મહત્વની છે; અમે પાછા માત્ર એક ક્ષણ તે આવવા પડશે.
અને પછી નીચે અહીં નીચે, અમે થોડી મેમરી રેખાકૃતિ હતી કે અમે સંદર્ભ લો રહ્યા છીએ.
હું ખરેખર આ કર્યું છે મારું iPad પર આઉટ.
તેથી હું અને સંદર્ભ માટે ફક્ત આ કોડ આઇપેડ વચ્ચે આગળ અને આગળ એકના જાઉં છું.
>> ચાલો શરૂ કરીએ. પ્રથમ, ચાલો મુખ્ય રેખાઓ પ્રથમ દંપતી પર અહીં ભાર મૂકે છે.
શરૂ કરવા માટે, અમે 1 અને વાય માટે એક્સ માટે 2 પ્રારંભ રહ્યા છીએ.
તેથી અમે બે પૂર્ણાંક ચલો હોય છે, તેઓ બન્ને સ્ટેક પર મૂકી શકાય જઈ રહ્યાં છો.
અમે તેમને માં 1 અને 2 એક મૂકી રહ્યા છીએ.
તેથી જો હું મારા આઇપેડ પર ફ્લિપ કરો, આસ્થાપૂર્વક, ચાલો જોવા -
એપલ ટીવી મીરરીંગ, અને ત્યાં અમે જાઓ. ઠીક છે.
તેથી જો હું મારા આઇપેડ પર ફ્લિપ કરો,
હું 1 અને વાય માટે એક્સ 2 માટે પ્રારંભ કરવા માંગો છો.
અમે કે એક્સ ચિહ્નિત બોક્સમાં 1 એક લખીને તદ્દન ખાલી કરવું
અને એક બૉક્સમાં 2 વાય ચિહ્નિત. એકદમ સરળ.
તેથી હવે આપણે લેપટોપ પર પાછા જાઓ, જુઓ આગળ શું થશે.
તેથી આ આગામી વાક્ય છે જ્યાં વસ્તુઓ મુશ્કેલ છે.
અમે પરિમાણો તરીકે x ની સરનામું અને વાય ના સરનામા પસાર અને સ્વેપ કાર્ય માટે બોલ્ડ.
એક્સ અને વાય ના સરનામા ઓફ સરનામા વસ્તુઓ છે કે જે આપણે ન ગણતરી કરી શકે છે
આ બુલેટ ઉલ્લેખ વિના અધિકાર નીચે અહીં નિર્દેશ કરે છે.
અને સદભાગ્યે, પ્રથમ બે બુલેટ પોઈન્ટ અમને જણાવો ચોકકસ શું જવાબો છે.
મેમરીમાં એક્સ ઓફ સરનામા 10 છે, અને મેમરીમાં વાય ના સરનામા 14 છે.
તેથી તે કિંમતો છે કે જે પસાર કરો છો અને અમારી સ્વેપ કાર્ય ટોચની બી.
તેથી ફરીથી, અમારા રેખાકૃતિ પર પાછા સ્વિચ, હું એક માં 10 લખી શકો છો
અને બોલ્ડ માં 14.
હવે, આ બિંદુ છે જ્યાં અમે સ્વેપ સાથે પ્રક્રિયા કરો.
જેથી લેપટોપ ફરી ફ્લિપિંગ,
અમે જુઓ કે જે રીતે કામ કરે છે સ્વેપ હું પ્રથમ ડિરેફરન્સ અને સ્ટોર tmp માં પરિણામ છે.
તેથી ડિરેફરન્સ ઓપરેટર કહે છે, "હે એક સરનામું તરીકે ચલ એક સમાવિષ્ટો વર્તો..
ગમે તે સરનામા પર સંગ્રહિત છે જાઓ, અને તે લોડ. "
તમે ચલ બહાર લાવવા શું અમારી tmp ચલ માં સંગ્રહિત કરવામાં રહ્યું છે.
આઇપેડ પર પાછા ફ્લિપિંગ.
જો અમે 10 સંબોધવા જાય છે, આપણે જાણીએ છીએ કે 10 સરનામું varible એક્સ છે
કારણ કે અમે અમારા બુલેટ બિંદુ કે જે મેમરીમાં x ની સરનામું 10 છે તેની જાણ કરવામાં આવી હતી.
તેથી અમે ત્યાં જાઓ, તે મૂલ્ય છે, કે જે 1 છે મેળવી શકો છો, કારણ કે અમે અમારા iPad પર જુઓ,
અને tmp માં કે લોડ.
ફરીથી, આ અંતિમ વિષયવસ્તુ નથી.
અમે લઈ જવામાં જઈ રહ્યાં છો અને અમે ઓવરને અંતે અમારી કાર્યક્રમ અંતિમ સ્થિતિમાં મળશે.
પરંતુ હમણાં, અમે 1 કિંમત tmp માં સંગ્રહિત હોય છે.
>> અને ત્યાં અહીં ઉપર ઝડપી પ્રશ્ન છે.
[એલેક્ઝાન્ડર] આ ડિરેફરન્સ ઓપરેટર છે - કે જે ફક્ત ચલ સામે તારો અધિકાર છે?
હા. >> આ ડિરેફરન્સ ઓપરેટર તેથી, કારણ કે અમે અમારા લેપટોપ માટે ફરી એકવાર ફ્લિપ કરો,
સામે અધિકાર આ તારો છે.
તે અર્થમાં, તે છે - તો તમે તેને ગુણાકાર ઓપરેટર સાથે વિરોધાભાસ છે
જે બે વસ્તુઓ જરૂરી છે; આ ડિરેફરન્સ ઓપરેટર એક unary ઓપરેટર છે.
માત્ર એક મૂલ્ય પર લાગુ તરીકે દ્વિસંગી ઓપરેટર વિરોધ કરે છે,
જ્યાં તમે બે અલગ અલગ કિંમતો લાગુ પડે છે.
જેથી શું છે આ રેખા બને.
અમે 1 કિંમત લોડ અને તે અમારી કામચલાઉ પૂર્ણાંક ચલ માં સંગ્રહ થાય છે.
આગામી રેખા, અમે માં બો સમાવિષ્ટો સ્ટોર -
અથવા, તેના બદલે, અમે વિષયવસ્તુ કે બો માટે જગ્યા છે જ્યાં એક તરફ પ્રવેશ પોઇન્ટ છે સંગ્રહે છે.
જો અમે ડાબી અધિકાર આ વિશ્લેષણ, અમે ડિરેફરન્સ બો જોઈ રહ્યા છે,
અમે 14 સંબોધવા જઇ રહ્યા, અમે પૂર્ણાંક છે કે જે ત્યાં છે ગ્રેબ જવું છે,
અને પછી અમે 10 સરનામાં પર જવું છે,
અને અમે તે અવકાશમાં બો અમારી ડિરેફરન્સ પરિણામ ફેંકવા જતા હોય છે.
અમારા આઇપેડ, જ્યાં અમે આ થોડો વધુ નક્કર બનાવી શકે પાછા ફ્લિપિંગ,
જો તે મને સરનામાં બધી પર નંબરો અહીં લખી મદદ કરી શકે છે.
તેથી આપણે જાણીએ છીએ કે વાય અંતે, અમે 14 સરનામા હોય છે, એક્સ 10 સરનામા પર છે.
જ્યારે અમે બો શરૂ થાય છે, અમે ડિરેફરન્સ બો, અમે કિંમત 2 ગ્રેબ રહ્યા છીએ.
અમે આ કિંમત ગ્રેબ કારણ કે મૂલ્ય કે 14 સરનામાં પર જીવે છે જવું છે.
અને અમે તે ચલ છે કે જે 10 સરનામાં પર રહે મૂકવામાં જઈ રહ્યાં છો,
જે યોગ્ય પણ છે, અમારા ચલ x અનુરૂપ છે.
તેથી અમે અહીં ફરીથી લખી એક થોડો કરી શકો છો
જ્યાં અમે અમારા 1 છૂટકારો મેળવવા અને તેના બદલે આપણે એ 2 લખો.
તેથી તમામ સારી અને વિશ્વમાં સારી છે, તેમ છતાં અમે ફરીથી લખાઈ એક્સ હવે કરેલા.
અમે એક્સ અમારા tmp ચલ જૂના કિંમત સંગ્રહિત છે.
તેથી અમે આગામી વાક્ય સાથે પૂર્ણ સ્વેપ કરી શકો છો.
અમારા લેપટોપ પર પાછા ફ્લિપિંગ.
હવે તમામ અવશેષો માટે સમાવિષ્ટો કામચલાઉ અમારા પૂર્ણાંક ચલ બહાર લઇ આવે છે
અને તેમને ચલ છે કે સરનામું કે બો હોલ્ડિંગ છે રહેતી માં સંગ્રહે છે.
તેથી અમે અસરકારક રીતે ડિરેફરન્સ બોલ્ડ માટે જઈ રહ્યાં છો તે ચલ ઍક્સેસ મેળવવા
કે સરનામું કે બો તેને ધરાવે છે,
અને અમે કિંમત છે કે જે tmp તે માં હિસ્સો છે સામગ્રી રહ્યા છીએ.
આઇપેડ પર પાછા વધુ એક વખત ફ્લિપિંગ.
હું આ કિંમત અંહિ ભૂંસવું કરી શકો છો, 2,
અને તેના બદલે અમે તેને માં 1 અધિકાર નકલ કરશો.
પછી આગળની અલબત્ત કે ચલાવે વાક્ય -
જો અમે લેપટોપ પર પાછા ફ્લિપ કરો - આ બિંદુ 6 છે,
જે મુદ્દો છે જેમાં અમે અમારી પાસે રેખાકૃતિ સંપૂર્ણપણે ભરેલ ઇચ્છતા હોય છે.
તેથી આઇપેડ પર પાછા ફ્લિપિંગ વધુ વખત, ફક્ત જેથી તમે પૂર્ણ જુઓ ડાયાગ્રામ કરી શકો છો,
તમે જોઈ શકો છો કે અમે માં 10, બી માં 14, એક tmp માં 1, 2 એ એક્સ, અને વાય 1 માં હોય છે.
ત્યાં આ વિશે કોઈ પ્રશ્ન?
શું આ વધુ અર્થમાં બનાવે છે, એવું તે મારફતે ચાલ્યો?
ઓછી સમજ છે? આસ્થાપૂર્વક નથી. ઠીક છે.
>> પોઇન્ટર ખૂબ જટિલ વિષય છે.
એક ગાય્સ અમે સાથે કામ ખૂબ સામાન્ય કહેવત છે:
"કરવા માટે પોઇંટરો સમજવા માટે, તમારે પ્રથમ પોઇંટરો સમજવું જ જોઈએ."
જે મને લાગે છે કે ખૂબ જ સાચી છે. તે માટે તેને ઉપયોગ કરો જ્યારે લાગી છે.
ચિત્રો ખૂબ ડ્રોઇંગ, એક આ જેવા મેમરી આકૃતિઓ ઘણાં ચિત્રકામ ખૂબ મદદરૂપ થાય છે,
અને પછી તમે ઉદાહરણ પછી ઉદાહરણ દ્વારા ઉદાહરણ પછી ચાલી,
તે થોડું વધુ સૂઝ અને થોડી વધુ સૂઝ અને થોડી વધુ અર્થમાં બનાવવા શરૂ કરી શકશો.
છેલ્લે, એક દિવસ, તમે પડશે તે બધા સંપૂર્ણપણે mastered.
કોઈપણ પ્રશ્નો પહેલાં અમે આગામી સમસ્યા પર ખસેડો? અધિકાર છે.
જેથી લેપટોપ પર પાછા ફ્લિપ કરો.
હવે પછીની સમસ્યા અમે સમસ્યા 33 નંબર ફાઇલ પર છે I / ઓ
આ થોડો પર ઝૂમ ઘટાડો.
33 સમસ્યા - હા?
>> [ડીએલ] હું માત્ર એક ઝડપી પ્રશ્ન હતો. આ તારો, અથવા ફૂદડી,
તે dereferencing જ્યારે તમે ફૂદડી પહેલાં વાપરવા માટે કહેવાય છે.
તે શું છે જ્યારે તમે પહેલા & "અને" નું ચિહ્ન ઉપયોગ કહેવાય છે?
>> ધ & "અને" નું ચિહ્ન પહેલાં ઓપરેટર ની-સરનામું છે.
તેથી આપણે પાછા ઉપર સ્ક્રોલ કરો.
અરે. હું ઝૂમ જેથી હું ખરેખર સ્ક્રોલ કરી શકો છો નથી સ્થિતિમાં છું.
જો અમે આ કોડ અંતે ખરેખર ઝડપથી જોવા અહીં,
ફરીથી, આ જ વસ્તુ બની રહ્યું.
જો અમે આ કોડ અંતે અહીં જુઓ, આ લીટી પર જ્યાં અમે કોલ સ્વેપ કરો,
આ & "અને" નું ચિહ્ન માત્ર કહી રહ્યાં છે કે "સરનામા કે ચલ x જીવન મળે છે."
જ્યારે તમારા કમ્પાઇલર તમારો કોડ કમ્પાઇલ,
તે ખરેખર શારીરિક તમારા રહેવા માટે ચલો બધા માટે એ મેમરીમાં સ્થાન માર્ક છે.
અને તેથી કમ્પાઇલર શું પછી એકવાર તે બધું સંકલિત છે કરી શકો છો,
તે જાણે છે, "ઓહ, હું 10 સરનામાં પર એક્સ મૂકી હું 14 સરનામાં પર વાય મૂકે છે.".
પછી તે તમને આ કિંમતો ભરી શકો છો.
તેથી તો પછી તમે કરી શકો છો - પછી તે કરી શકો છો અને સાથે સાથે માં પાસ વાય આ પસાર.
આ ગાય્સ સરનામું વિચાર છે, પરંતુ તેઓ પણ, જ્યારે તમે તેમને સ્વેપ કાર્ય માં પસાર કરવા માટે,
આ પ્રકારની માહિતી, આ પૂર્ણાંક અહીં *, પણ કમ્પાઇલર કહે છે,
"ઠીક છે, અમે પૂર્ણાંક ચલ એક સરનામા તરીકે આ સરનામું ઈન્ટરપ્રીટ કરી રહ્યા છીએ."
પૂર્ણાંક એક સરનામા તરીકે, કે જે અક્ષર ચલની સરનામા અલગ છે
કારણ કે પૂર્ણાંક એક મશીન 32-bit, લે છે, અપ જગ્યા 4 બાઇટ્સ લે છે,
જ્યારે એક પાત્ર માત્ર અપ જગ્યા 1 બાઇટ લે છે.
તેથી તે પણ ખબર શું છે મહત્વપૂર્ણ છે - શું રહે છે, મૂલ્ય શું પ્રકાર
છે સરનામું સાઇન પસાર થયો ખાતે રહેતા
અથવા સરનામું કે જે તમે સાથે કામ કરી રહ્યાં છે.
આ રીતે, તમે અનેક માહિતી બાઇટ્સ કેવી રીતે ખરેખર તમારી RAM ની બહાર લાવવા છો.
અને પછી, હા, તમે જેમ આ ડિરેફરન્સ ઓપરેટર, કહેતી હતી,
જાય છે અને એક ખાસ સરનામાં પર માહિતી ઍક્સેસ કરે છે.
તેથી તે આ ચલ સાથે કહે, અહીં, એક સરનામું તરીકે સમાવિષ્ટો, સારવાર,
તે સરનામા પર જાઓ, અને બહાર ખેંચી, રજીસ્ટર માં પ્રોસેસર, ભાર માં લોડ
વાસ્તવિક મૂલ્યો અથવા સમાવિષ્ટો કે જે સરનામાં પર રહે છે.
વધુ કોઈપણ પ્રશ્ન છે? આ સારા પ્રશ્નો હોય છે.
તે નવું પરિભાષા ઘણો પણ છે.
તે પણ ફંકી પ્રકારની છે, વિવિધ સ્થળોએ અને અને * દેખાઈ રહ્યું છે.
>> અધિકાર છે.
તેથી 33 સમસ્યા પર પાછા ફાઇલ I / ઓ
આ એક તે સમસ્યાઓ કે મને લાગે છે કે વસ્તુઓ એક દંપતી થયું હતું.
એક તો, તે એકદમ નવો વિષય છે.
તે ખૂબ જલદી ક્વિઝ સમક્ષ રજૂ કરવામાં આવી હતી,
અને પછી મને લાગે છે કે તે એક ગણિતના તે શબ્દ સમસ્યાઓ જેવી પ્રકારની હતી
તેઓ તમને જ્યાં ઘણી માહિતી આપે છે, પણ તમે ખરેખર ન અંત તેને એક ટન ઉપયોગ કર્યા નથી.
આ સમસ્યા પ્રથમ ભાગ વર્ણન છે CSV ફાઈલ શું છે.
હવે, એક CSV ફાઈલ, વર્ણન અનુસાર, એક અલ્પવિરામથી અલગ પડેલ કિંમતો ફાઇલ છે.
કારણ આ બધા રસપ્રદ છે, અને કારણ તમે ક્યારેય તેમને વાપરવા માટે,
છે, કારણ કે, તમે કેટલી ક્યારેય એક્સેલ જેવા સામગ્રી વપરાય છે?
તમે મોટા ભાગના આકૃતિ છે, કદાચ, અથવા તમારા જીવન માં કોઇ સમયે ઉપયોગ કરશે.
તમે એક્સેલ કંઈક ઉપયોગ કરશો.
, ક્રમમાં માહિતી મેળવવા માટે એક એક્સેલ સ્પ્રેડશીટ અથવા તેની સાથે પ્રક્રિયા કોઇ પણ પ્રકારની કરવું
જો તમે એક સી કાર્યક્રમ અથવા Python કાર્યક્રમ, જાવા પ્રોગ્રામ લખવા માગતા હતા,
જે માહિતી તમે ત્યાં સંગ્રહિત થયેલ છે સાથે વ્યવહાર,
એક સૌથી સામાન્ય તેને વિચાર બહાર રીતે એક CSV ફાઈલ છે.
અને તમે એક્સેલ ખોલી શકો છો અને જ્યારે તમે સંવાદ 'સાચવો' પર જાઓ,
તમે એક વાસ્તવિક CSV ફાઈલ મેળવી શકો છો.
>> કેવી રીતે આ બધી વસ્તુઓ સાથે વહેવાર માટે હેન્ડી.
આ રીતે કામ કરે છે તે છે કે તે સમાન છે - હું તેનો અર્થ, તે મૂળભૂત એક સ્પ્રેડશીટ એપોપ્લેક્સી છે,
, આપણે અહીં જોવા ખૂબ જ બાકી સૌથી ટુકડો, જ્યાં,
અમે તમામ છેલ્લા નામો હોય છે.
તેથી અમે Malan, પછી Hardison અને પછી બોડેન, MacWilliam અને પછી ચાન હોય છે.
બધા છેલ્લા નામો. અને પછી અલ્પવિરામ પ્રથમ નામો ના છેલ્લા નામો અલગ પાડે છે.
ડેવિડ, Nate, રોબ, ટોમી, અને Zamyla.
હું હંમેશા Robby અને ટોમ મિશ્રણ.
અને પછી, છેવટે, ત્રીજા સ્તંભ ઇમેઇલ સરનામાંઓ છે.
એકવાર તમે સમજો કે, આ કાર્યક્રમ બાકીના એકદમ અમલ કરવા માટે સરળ હોય છે.
અમે શું કરવા માટે અમારી સી કાર્યક્રમ આ જ માળખું નકલ કર્યું છે
તો અમે એક માળખું ઉપયોગ કર્યો છે.
અમે આ થોડું તેમજ વધુ સાથે રમી શરૂ કરી શકશો.
અમે તેમને સમસ્યા 3 સેટ, જ્યારે અમે આ શબ્દકોશો સાથે વ્યવહાર કરવામાં આવી હતી પ્રથમ થોડો માટે થયો છે.
પરંતુ આ સ્ટાફ સ્ટ્રક્ટ એક છેલ્લું નામ, પ્રથમ નામ, અને એક ઇમેઇલ સંગ્રહ કરે છે.
અમારા CSV ફાઈલ જેમ જ સ્ટોર કરવામાં આવી હતી.
તેથી આ માત્ર એક બંધારણમાં બીજા રૂપાંતરિત કરી રહી છે.
અમે આ કેસ માં કન્વર્ટ, એક લીટી માં સ્ટાફ સ્ટ્રક્ટ હોય છે,
જેમ માત્ર એક લીટી અલ્પવિરામથી અલગ પડેલ.
એ નથી કે સૂઝ છે? તમે ગાય્સ તમામ ક્વિઝ લેવામાં આવે છે,
તેથી હું કલ્પના તમે ઓછામાં ઓછા કેટલાક આ વિશે વિચારો સમય રહ્યો છે.
>> આ ભાડે કાર્ય માં, સમસ્યા અમને માં લેવા માટે પૂછે છે - આ થોડો પર we'll ઝૂમ -
એક સ્ટાફ માળખું, એક સ્ટાફ સ્ટ્રક્ટ નામ ઓ સાથે લઇ,
અને અમારા staff.csv ફાઈલ તેના સમાવિષ્ટો જોડો.
તે તારણ છે કે આ એકદમ વાપરવા માટે સરળ હોય છે.
અમે પ્રકારની આ થોડો વધુ કાર્યો આજે આસપાસ રમી શકશો.
પરંતુ આ કિસ્સામાં, fprintf કાર્ય ખરેખર કી છે.
તેથી fprintf સાથે, અમે છાપી, જેમ તમે ગાય્સ printf આ સમગ્ર શબ્દ નો ઉપયોગ કરી શકશે નહીં.
તમે printf ફાઇલ માટે એક લીટી કરી શકો છો.
તેથી તેના બદલે માત્ર સામાન્ય printf કોલ બનાવવા જ્યાં તમે તેને ફોર્મેટ સ્ટ્રિંગ આપી
અને પછી તમે નીચેની દલીલો સાથે તમામ ચલો બદલો,
fprintf સાથે, તમારા પ્રથમ દલીલ જગ્યાએ ફાઈલ કરવા માટે તમે લખવાની ઇચ્છા છે.
જો અમે આ સાધન પર જુઓ, ઉદાહરણ માટે fprintf માણસ હતા,
અમે printf અને fprintf વચ્ચે તફાવત જોઇ શકો છો.
હું અહીં થોડો ઝૂમ પડશે.
તેથી printf સાથે, અમે તેને ફોર્મેટ સ્ટ્રિંગ આપે છે, અને તે પછી તેના પછીના દલીલો
અથવા અમારી ફોર્મેટ સ્ટ્રિંગ માં સ્થાને અવેજી માટે તમામ ચલો છે.
Fprintf સાથે, જ્યારે પ્રથમ દલીલ ખરેખર આ ફાઇલ સ્ટ્રીમ કહેવાય * છે.
>> અહીં પર પાછા અમારા ભાડે ખસેડી,
અમે પહેલાથી જ મળી છે અમારી ફાઈલ * સ્ટ્રીમ અમારા માટે ખોલવામાં આવી હતી.
કે આ પ્રથમ વાક્ય શું કરે છે; તે staff.csv ફાઈલ ખોલે છે,
તેને ઉમેરો સ્થિતિમાં ખોલે છે, અને તે અમારા માટે શું કરવું બાકી છે છે
સ્ટાફ માટે ફાઈલ બંધારણ લખી.
અને, ચાલો જોવા માટે, હું શું માટે આઇપેડ વાપરવા માંગો છો?
હું આઇપેડ ઉપયોગ કરશો. અમે રદબાતલ છે - લેટ્સ ટેબલ પર મૂકી આ તેથી હું થોડો સારો લખી શકો છો -
ભાડે ગેરમાન્ય ગણાય છે અને તે એક દલીલ લે છે, સ્ટાફ ઓ કહેવાય માળખું.
અમારા કૌંસ ગોટ, અમે અમારી ફાઈલ ફાઈલ કહેવાય * મળ્યો છે,
અમે અમારા fopen અમને આપવામાં રેખા હોય છે,
અને હું માત્ર બિંદુઓ તરીકે લખવા પડશે કારણ કે તે pedia પહેલેથી જ છે.
અને પછી અમારી આગામી વાક્ય પર, અમે fprintf કૉલ કરવા જઈ રહ્યાં છો
અને અમે ફાઈલ પાસ જઈ રહ્યાં છો કે અમે છાપવાનો માંગો છો,
અને પછી અમારી ફોર્મેટ સ્ટ્રિંગ, જે -
હું જઈશ તમે ગાય્સ મને કહો તે શું જેવો દેખાય છે.
તમે કેવી રીતે વિશે સ્ટેલા? શું તમે જાણો છો કે ફોર્મેટ સ્ટ્રિંગ પ્રથમ ભાગ શું લાગે છે?
[સ્ટેલા] મને ખાતરી છે કે નથી. >> માટે જીમી પૂછો સંકોચ ન અનુભવો.
શું તમે જાણો છો, જીમી?
[જિમી] તે માત્ર છેલ્લા પ્રયત્ન માંગો છો? મને ખબર નથી. હું સંપૂર્ણપણે ખાતરી નથી.
ઠીક છે. >> વિશે કેવી રીતે, કોઈની પરીક્ષા પર નહોતો તે આ સાચું શું?
બધા હક નં.
તે તારણ આપે છે કે અહીં બધા અમે શું હોય છે અમે અમારા સ્ટાફ માળખું દરેક ભાગ કરવા માંગો છો
અમારા ફાઇલમાં શબ્દમાળા તરીકે છપાશે.
અમે હમણાં જ શબ્દમાળા અવેજી અક્ષર ત્રણ અલગ અલગ સમય ઉપયોગ કારણ કે અમે છેલ્લા નામ છે
અલ્પવિરામ અનુસરતા, પછી પ્રથમ નામ અલ્પવિરામ અનુસરતા,
અને પછી છેલ્લે ઇમેઇલ સરનામું કે જેને અનુસરીને છે - નથી જે
મારી સ્ક્રીન પર ફિટિંગ - પરંતુ તે NEWLINE અક્ષર દ્વારા અનુસરવામાં છે.
તેથી હું તેને માત્ર નીચે ત્યાં લખવા જઈ રહ્યો છું.
અને પછી અમારી ફોર્મેટ સ્ટ્રિંગ બાદ,
અમે ફક્ત ખેલાડીઓની ફેરબદલ હોય છે, જેને આપણે કોઈ નોટેશનમાં ઉપયોગ કરીને ઍક્સેસ
કે અમે સમસ્યા 3 સેટ થયો છે.
અમે s.last, s.first, અને s.email ઉપયોગ કરી શકો છો
અમારા ફોર્મેટ સ્ટ્રિંગ માં તે ત્રણ કિંમતો અવેજી.
આમ કેવી રીતે કરે છે કે ક્યાં ગયા હતા? અર્થમાં બનાવીએ?
હા? નહીં? કદાચ? ઠીક છે.
>> અંતિમ વસ્તુ કે અમે શું પછી અમે મુદ્રિત અને કર્યા છે પછી અમે અમારી ફાઇલ ખોલી છે:
જ્યારે પણ આપણે એક ફાઇલ ખોલ્યું, અમે હંમેશા માટે તેને બંધ યાદ છે.
કારણ કે અન્યથા અમે અંત મેમરી લીક પડશે,
અપ ફાઇલ વર્ણનકાર મદદથી.
તેથી તેને બંધ કરવા માટે, કાર્ય જે અમે ઉપયોગ કરી શકું? ડેનિયલ?
[ડીએલ] fclose? >> બરાબર fclose.
જેથી આ સમસ્યા ના છેલ્લા ભાગ માટે યોગ્ય રીતે ફાઈલ બંધ હતી, fclose ફંક્શનનો ઉપયોગ કરીને,
જે ફક્ત કે જેવો દેખાય છે.
ઉન્મત્ત નથી પણ.
સરસ.
જેથી ક્વિઝ પર 33 સમસ્યા છે.
અમે ચોક્કસપણે વધુ ફાઇલ હોય I / O આવી પડશે.
અમે થોડો વધુ આજે વ્યાખ્યાન કરતા, પડશે અથવા વિભાગ માં આજે,
કારણ કે તે શું છે આ આગામી pset ની બલ્ક રચના બનશે.
ચાલો આ તબક્કે ક્વિઝ માંથી પર ખસેડો. હા?
>> [ચાર્લોટ]] શા માટે fclose બદલે () ફાઇલ fclose (staff.csv)?
આહ. >> કારણ કે તે તારણ આપે છે કે - જેથી પ્રશ્ન છે, કે જે એક મહાન છે,
છે, જ્યારે અમે fclose લખી શા માટે, અમે fclose () ફાઇલ સ્ટાર ચલ લખે છે
તરીકે ફાઇલ નામ, staff.csv વિરોધ? કે સાચું છે? યાહ.
તેથી આપણે એક નજર નાખો. જો હું મારા લૅપટૉપ પર સ્વિચ કરો
દો અને આ fclose કાર્ય જુઓ.
તેથી fclose કાર્ય પ્રવાહ બંધ અને તે પોઇન્ટર સ્ટ્રીમ કે અમે બંધ કરવા માંગો છો લઈ જશે,
તરીકે વાસ્તવિક ફાઈલ નામ કે અમે બંધ કરવા માંગો છો વિરોધ કર્યો હતો.
અને આ કારણ કે પડદા પાછળ, જ્યારે તમે fopen કૉલ કરવા માટે છે
જ્યારે તમે એક ફાઈલ ખોલવા માટે, તમે ખરેખર મેમરી allocating કરી રહ્યા છીએ ફાઈલ વિશે જાણકારી સંગ્રહે છે.
તેથી તમે ફાઈલ નિર્દેશક કે ફાઈલ વિશે જાણકારી ધરાવે છે છે,
જેમ કે તે ખુલ્લા, તેના કદ, કે જ્યાં તમે ફાઈલ વર્તમાનમાં છે,
જેથી તમે વાંચન અને ચોક્કસ જગ્યાએ ફાઈલ અંદર કોલ્સ લખી શકો છો.
તમે અંત ફાઇલ નામ બંધ બદલે નિર્દેશક બંધ.
>> હા? [ડીએલ] તેથી ક્રમમાં ભાડે વાપરવા માટે, તમારે કહેવું કરશે - તે વપરાશકર્તા ઈનપુટ કેવી રીતે થાય છે?
નથી fprintf અર્થમાં GetString જેમ કાર્ય કરે છે કે તે માત્ર વપરાશકર્તા ઈનપુટ માટે રાહ જોવી પડશે
અને તમે આ ટાઇપ કરવા માટે કહી છે - અથવા રાહ માટે તમે આ ત્રણ વસ્તુઓ લખો માટે?
અથવા તમે કંઈક વાપરવા માટે ભાડે અમલીકરણની જરૂર છે?
>> યાહ. પ્રશ્ન કેવી રીતે કરી શકું હતી અમે વપરાશકર્તા ઈનપુટ વિચાર - જેથી અમે નથી
ક્રમમાં ભાડે અમલ માટે? અને અમે અહીં છે શું ભાડે ના મુલાકાતી આવે છે,
આ સ્ટ્રક્ટ પહેલેથી જ સ્ટોર કરેલો ડેટા બધી સાથે આ સ્ટાફ સ્ટ્રક્ટ પસાર થયો.
તેથી fprintf માત્ર કે માહિતી ફાઇલમાં સીધુ લખી શકે છે.
ત્યાં કોઈ વપરાશકર્તા ઈનપુટ માટે રાહ જોઈ છે.
વપરાશકર્તા પહેલાથી જ યોગ્ય રીતે તેને આ સ્ટાફ સ્ટ્રક્ટ માં મૂકીને છે ઇનપુટ આપવામાં આવે છે.
અને વસ્તુઓ, અલબત્ત, જો તે પોઇંટરો કોઈપણ નલ હતા તૂટી શકે,
તેથી અમે પાછા અહીં સ્ક્રોલ અને અમે અમારા સ્ટ્રક્ટ જુઓ.
અમે શબ્દમાળા છેલ્લા શબ્દમાળા પ્રથમ, શબ્દમાળા ઇમેઇલ હોય છે.
હવે અમે જાણીએ છીએ કે તે ખરેખર બધા, હૂડ હેઠળ, ચાર * ચલો છે.
કે null પોઇન્ટ શકે છે કે નહિં કરી શકાય છે.
તેઓ ઢગલો પર મેમરી પોઇન્ટ થઈ શકે છે,
સ્ટેક પર કદાચ મેમરી.
અમે ખરેખર, ખબર નથી, પરંતુ જો આ પોઇંટરો કોઈપણ નલ, અથવા અમાન્ય છે,
કે જે ચોક્કસપણે અમારા ભાડે કાર્ય ભાંગી પડશે.
કે જે કશુંક પરીક્ષા તક બહાર પ્રકારની હતી.
અમે તે વિષે બાબત ચિંતાજનક કરી રહ્યાં છો.
સરસ. ઠીક છે. તેથી ક્વિઝ થી ખસેડીને.
>> ચાલો આ વ્યક્તિ બંધ, અને અમે 4 pset જોવા જઈ રહ્યાં છો.
તેથી જો તમે ગાય્સ આ pset સ્પેક જોવા, એકવાર તમે તેને ઍક્સેસ કરી શકો છો, cs50.net/quizzes,
અમે વિભાગ આજની સમસ્યાઓ થોડા પસાર થશે.
હું સ્ક્રોલ છું - પ્રશ્નો વિભાગ pset સ્પેક ત્રીજા પાનાં પર શરૂ થાય છે.
અને પ્રથમ ભાગ તમે પૂછે પર જાઓ અને પુનઃદિશામાન અને પાઈપો પર ટૂંકા જુઓ.
જે ઠંડી ટૂંકી પ્રકારની હતી, તો તમે અમુક નવા, ઠંડી આદેશ વાક્ય યુક્તિઓ કે જે તમે ઉપયોગ કરી શકો છો બતાવે છે.
અને પછી તો અમે તમારા માટે અમુક પ્રશ્નોનો મળી છે તેમજ.
સ્ટ્રીમ્સ વિશે આ પ્રથમ પ્રશ્ન છે કે જે printf મૂળભૂત રીતે લખે છે,
અમે પ્રકારની માત્ર થોડો પર ક્ષણ પહેલા સપાટીએ બંધ રહ્યો હતો.
આ fprintf કે અમે હમણાં જ ચર્ચા કરવામાં આવી હતી તેના દલીલ તરીકે ફાઈલ * સ્ટ્રીમમાં લે છે.
fclose ફાઈલ * સ્ટ્રીમમાં તેમજ લે છે,
અને fopen પરત કિંમત તમે ફાઈલ * સ્ટ્રીમ આપે છે.
કારણ કે અમે પહેલાં તે જોઇ ન હોય ત્યારે અમે printf સાથે કામ કર્યું છે છે
છે કારણ કે printf મૂળભૂત સ્ટ્રીમ ધરાવે છે.
અને મૂળભૂત સ્ટ્રીમ માટે જે તે લખે છે
તમે બહાર વિશે ટૂંકી મળશે.
તેથી ચોક્કસપણે તે પર એક નજર.
>> આજના વિભાગમાં, અમે GDB વિશે થોડુંક વાત જઈ રહ્યાં છો,
થી વધુ પરિચિત તમે તેની સાથે છે, જેમાં વધુ અભ્યાસ તમે તેની સાથે વિચાર,
વધુ સારી કરવાનો તમે ખરેખર તમારા પોતાના કોડ માં ભૂલો શિકાર હશો.
આ જબરદસ્ત ડિબગીંગ પ્રક્રિયા વધારે છે.
તેથી printf ઉપયોગ કરીને, દર વખતે તમે કે તમે તમારા કોડ પુનઃકમ્પાઈલ હોય છે,
તમે તે ફરીથી ચલાવવા હોય, ક્યારેક તમે printf કોલ ફરતે ખસેડવા માટે હોય છે,
બહાર કોડ ટિપ્પણી, તે માત્ર એક જ્યારે લે છે.
અમારો ધ્યેય પ્રયાસ કરો અને તમે મનાવવા કે GDB સાથે, તમે આ કરી શકો છો અનિવાર્યપણે છે
તમારો કોડ કોઈપણ બિંદુએ printf કંઈપણ તમે અને ક્યારેય તેને પુનઃકમ્પાઈલ.
તમે ક્યારેય શરૂ કરો અને printf આગામી માટે જ્યાં અનુમાન લગાવવા રાખો.
પ્રથમ બાબત આ રેખા નકલ અને કલમ કોડ વેબ બંધ વિચાર છે.
હું કોડ આ લીટી કે કહે છે, "wget ​​http://cdn.cs50.net" નકલ છું.
હું તેને નકલ જાઉં છું.
હું મારી ઉપકરણ પર જાઓ જાઉં છું, બહાર ઝૂમ જેથી તમે જોઈ શકો છો કે હું શું કરી રહ્યો છું,
તેને ત્યાં પેસ્ટ કરવું, અને જ્યારે હું લિમિટેડ ફટકો, આ wget આદેશ શાબ્દિક અર્થ છે, એક વેબ મેળવો.
તે નીચે ઇન્ટરનેટ આ ફાઈલ ખેંચવાનો બોલ ચાલી રહ્યું છે,
અને તે માટે તે વર્તમાન ડિરેક્ટરીમાં સંગ્રહી રહ્યું છે.
હવે જો હું મારી વર્તમાન ડિરેક્ટરી યાદી તમે જોઈ શકો છો કે હું ત્યાં જ આ section5.zip ફાઈલ મળી છે.
તે વ્યક્તિ સાથે કામ રસ્તો તેને અનઝિપ કરી છે,
જે તમે આદેશ વાક્ય આ જેમ, કરી શકો છો.
Section5.zip.
કે તે ઝિપસાંકળ છોડવી પડશે, મને માટે ફોલ્ડર બનાવવા માટે,
આ બધા સમાવિષ્ટો ચડાવવું, તેમને ત્યાં મૂકી.
તેથી હવે હું મારા કલમ 5 cd આદેશ ની મદદથી ડિરેક્ટરીમાં જઈ શકે છે.
સ્પષ્ટ મદદથી સ્ક્રીન સાફ કરો. જેથી સ્ક્રીન સાફ કરો.
હવે હું એક સુંદર સ્વચ્છ સાથે વ્યવહાર ટર્મિનલ મેળવ્યા છે.
>> હવે જો હું બધી ફાઈલો છે કે હું આ ડિરેક્ટરીમાં જુઓ યાદી,
તમે જુઓ છો કે હું ચાર ફાઇલો મળી છે: buggy1, buggy2, buggy3, અને buggy4.
હું પણ તેમના લગતાવળગતા. કેચ ફાઈલો મેળવ્યા છે.
અમે હવે માટે કેચ. ફાઈલો જોવા ન જઈ રહ્યાં છો.
તેના બદલે, અમે તેનો ઉપયોગ ત્યારે અમે GDB ખોલવા જઈ રહ્યાં છો.
અમે તેમને રાખવામાં કર્યું છે આસપાસ કે જેથી અમે વાસ્તવિક સ્ત્રોત કોડ પણ વપરાશ હોય છે જ્યારે અમે GDB ઉપયોગ કરી રહ્યા છો,
પરંતુ કલમ આ ભાગ ધ્યેય GDB સાથે આસપાસ જિપ્સી છે
જુઓ અને અમે કેવી રીતે તેનો ઉપયોગ બહાર આકૃતિ શું આ ચાર બગડેલ કાર્યક્રમો દરેક સાથે ખોટું થઈ રહ્યું છે તે કરી શકો છો.
તેથી અમે ફક્ત રુમની આસપાસ રહ્યા છો ખરેખર ઝડપથી જવાનું,
અને હું કોઈકને કહી એક ઘોડાગાડી કાર્યક્રમો ચલાવો જાઉં છું,
અને પછી અમે GDB મારફતે એક જૂથ તરીકે જાય છે, અને પડશે અમે જોશો તો અમે શું આ કાર્યક્રમો સુધારવા કરી શકો છો,
અથવા ઓછામાં ઓછું ઓળખવા માટે શું તેમને દરેક ખોટું બનશે.
ચાલો પર ડેનિયલ સાથે અહીં શરૂ કરો. તમે buggy1 ચાલશે? માતાનો જુઓ શું થાય દો.
[ડીએલ] તે કહે ત્યાં અરજી દોષ છે. >> યાહ. બરાબર.
તેથી જો હું buggy1 ચલાવવા માટે, હું એક seg દોષ છે.
આ બિંદુએ, હું જાઓ અને buggy1.c ખોલવા શકે છે,
પ્રયત્ન કરો અને બહાર આકૃતિ શું ખોટું ચાલી રહ્યું છે,
પરંતુ આ એક seg દોષ ભૂલ વિશે સૌથી ખરાબ વસ્તુઓ
એ છે કે તે તમને કાર્યક્રમ વસ્તુઓ વાક્ય શું ખરેખર ખોટું થયું અને તોડ્યો પર કહેવું નથી.
તમે પ્રકારની માટે કોડ જોવા હોય
અને અનુમાન મદદથી બહાર આકૃતિ અને તપાસો અથવા printf જોવા માટે શું ખોટું થઈ રહ્યું છે તે.
એક GDB વિશે શાનદાર વસ્તુઓ છે કે તે ખરેખર, ખરેખર સરળ છે
બહાર લીટી આકૃતિ તમારા કાર્યક્રમ ભંગાણો કે.
તે સંપૂર્ણપણે તેને વાપરવા માટે કિંમત છે, પણ જો માત્ર કે.
અપ કરવા માટે GDB બુટ તેથી, હું GDB લખો અને પછી હું તેને એક્ઝેક્યુટેબલ કે હું ચલાવવા માંગો છો પાથ આપે છે.
અહીં હું ./buggy1 gdb લખીને છું.
લિમિટેડ નહીં. મને આ તમામ કૉપિરાઇટ માહિતી આપે છે,
અને નીચે અહીં તમે આ લીટી કે કહે છે, "/ home / થી વાંચન પ્રતીકો જોશો
jharvard/section5/buggy1. "
અને જો તમામ સારી રીતે જાય, તો તમે જોશો તેને એક સંદેશ છે કે આ જેવી લાગે છાપો.
તે પ્રતીકો વાંચી શકશો, તે કહેવું પડશે, "હું તમારી એક્ઝિક્યુટેબલ ફાઇલ માંથી ચિહ્નો વાંચી રહ્યો છું,"
અને પછી તે અહીં પર આ "પૂર્ણ" સંદેશ હશે.
જો તમે આ કેટલાક અન્ય વિવિધતા જોવા માટે, અથવા તમે જુઓ તે પ્રતીકો શોધી શક્યા નથી
અથવા તે કંઈક, તેનો અર્થ એ કે શું છે કે તમે ફક્ત તમારા એક્ઝેક્યુટેબલ યોગ્ય રીતે કમ્પાઇલ કરેલ છે.
જ્યારે અમે GDB સાથે વાપરવા માટે કાર્યક્રમો કમ્પાઈલ, અમે તે ધ્વજ ખાસ જી ઉપયોગ કરે છે,
અને તે મૂળભૂત દ્વારા કરવામાં આવ્યું છે તે જો તમે તમારા કાર્યક્રમો કમ્પાઈલ લખીને બનાવવા દ્વારા જ
અથવા બગડેલ બનાવવા અથવા પુનઃપ્રાપ્ત કરવા માટે, તે કોઇ પણ.
પરંતુ જો તમે જાતે ખણખણાટ સાથે સંકલન કરી રહ્યાં છો, તો પછી તમે જાઓ અને જે જી ધ્વજ સમાવેશ હશે.
>> આ બિંદુએ, હવે અમે અમારા GDB પ્રોમ્પ્ટ છે,
તે સારુ સરળ છે આ કાર્યક્રમ ચલાવો.
અમે ક્યાં રન ટાઇપ કરી શકો છો અથવા અમારી માત્ર r ટાઈપ કરી શકો છો.
સૌથી GDB આદેશો સંક્ષિપ્ત હોઈ શકે છે.
સામાન્ય રીતે એક કે બે અક્ષરો છે, જે ખૂબ સરસ છે.
તેથી સાદ, જો તમે r લખો અને Enter, શું થાય છે ફટકો?
[સાદ] હું SIGSEGV, સેગ્મેન્ટેશન ક્ષતિમાં, અને પછી આ તમામ gobbledygook મળ્યો હતો.
>> યાહ.
જેમ અમે સ્ક્રીન પર જોઈ રહ્યાં છો હમણાં, અને જેવા સાદ જણાવ્યું હતું કે,
જ્યારે અમે રન અથવા r લખો અને Enter દબાવો, અમે હજુ પણ એ જ seg દોષ છે.
તેથી GDB મદદથી અમારી સમસ્યા હલ નથી.
પરંતુ તે અમને કેટલાક gobbledygook આપે છે, અને તે તારણ છે કે જે આ gobbledygook
વાસ્તવમાં આપણને કહે છે જ્યાં તે ચાલી રહ્યું છે.
આ થોડો પાર્સ, આ પ્રથમ બીટ એ વિધેય જે બધું ખોટું થઈ રહ્યું છે તે છે.
આ strcmp_sse4_2 __ છે, અને તે અમને કહે છે કે તે આ ફાઇલ થઇ રહ્યું છે તે
કહેવાય sysdeps/i386, આ તમામ, ફરી એક વાસણ પ્રકારની છે - પરંતુ 254 રેખા.
કે પ્રકારની છે હાર્ડ પાર્સ. સામાન્ય રીતે જ્યારે તમે આ જેવી સામગ્રી જુઓ,
કે અર્થ એ થાય કે તે એક સિસ્ટમ લાઈબ્રેરીઓ માં faulting seg છે.
તેથી strcmp સાથે કંઇક. તમે ગાય્સ strcmp જોઈ હોય તો.
ઉન્મત્ત નથી, પણ, પરંતુ આ સરેરાશ કે strcmp ભાંગી અથવા આવે છે કે ત્યાં strcmp સાથે સમસ્યા છે?
તમે શું એલેક્ઝાન્ડર વિચારો છો?
[એલેક્ઝાન્ડર] શું કે - 254 લીટી છે? અને - બાઈનરી નથી, પરંતુ તેમના છત નથી,
અને પછી ત્યાં દરેક કાર્ય માટે બીજી ભાષા છે. કે છે કે વિધેય માં, 254 અથવા -?
>> તે 254 રેખા છે. આ ઓ. ફાઈલમાં જેવી લાગે છે, તેને વિધાનસભા ની કદાચ કોડ જેથી.
>> પરંતુ, હું માનું વધુ જરૂરી વસ્તુ છે, કારણ કે અમે એક seg દોષ મેળવેલ કરી લીધી છે,
અને લાગે છે કે તે strcmp વિધેય માંથી આવે છે,
નથી આ સૂચિત કરો, પછી કે, strcmp ભાંગી છે?
તે, આસ્થાપૂર્વક નથી. તેથી માત્ર કારણ કે તમે સેગ્મેન્ટેશન ક્ષતિમાં છે
એક સિસ્ટમ કાર્યો હતા, ખાસ કરીને કે અર્થ એ છે કે તમે માત્ર તે બરાબર કહેવાય છે.
આ દોડ માટે બહાર આકૃતિ ખરેખર શું ચાલી રહ્યું છે તે બાબત
, જ્યારે તમે આ જેવા ઉન્મત્ત કંઈક, જુઓ તમે જ્યારે seg દોષ જુઓ
ખાસ કરીને જો તમે એક કાર્યક્રમ છે કે જે કરતાં વધુ માત્ર મુખ્ય મદદથી છે છે,
એક બેકસ્ટ્રેસ ઉપયોગ છે.
હું BT લેખન તરીકે સંપૂર્ણ બેકસ્ટ્રેસ શબ્દ વિરોધ દ્વારા બેકસ્ટ્રેસ ટૂંકાવવું.
પરંતુ ચાર્લોટ, શું થાય છે જ્યારે તમે BT લખો અને Enter દબાવો?
[ચાર્લોટ] તે મને બે લીટીઓ, લાઇન 0 અને 1 લીટી બતાવે છે.
>> યાહ. તેથી રેખા 0 અને 1 લીટી.
આ વાસ્તવિક સ્ટેક ફ્રેમ નાટક હાલમાં હતા જ્યારે તમારા કાર્યક્રમ ભાંગી છે.
આ સર્વોચ્ચ ફ્રેમ, 0 ફ્રેમ થી શરૂ કરીને, અને નીચે સૌથી છે, કે જે 1 ફ્રેમ છે જવાની.
અમારા સર્વોચ્ચ ફ્રેમ strcmp ફ્રેમ હોય છે.
તમે આ લાગે છે કે સમસ્યા અમે ફક્ત પોઇન્ટર સાથે ક્વિઝ કરી હતી સમાન કરી શકો છો,
અમે મુખ્ય સ્ટેક ફ્રેમ ઉપર જ્યાં સ્ટેક ફ્રેમ સ્વેપ હતી,
અને અમે ચલો કે સ્વેપ ચલો કે મુખ્ય ઉપયોગ કરીને કરવામાં આવી હતી ટોચ પર ઉપયોગ કરીને કરવામાં આવી.
અહીં અમારા ક્રેશ અમારા strcmp કાર્ય છે, કે જે અમારા મુખ્ય કાર્ય દ્વારા બોલાવવામાં આવ્યો બન્યું,
અને બેકસ્ટ્રેસ અમને માત્ર કયા વિધેયો વસ્તુઓ નિષ્ફળ આપે છે,
પરંતુ તે પણ અમને જણાવ્યાં છે જ્યાં બધું થી તરીકે ઓળખાતું હતું.
તેથી જો હું થોડો વધારે યોગ્ય સરકાવવા,
અમે જોઈ શકે છે કે હા, અમે આ ફાઇલ strcmp-sse4.s ઓફ 254 લાઇન પર હતા.
પરંતુ કોલ buggy1.c, 6 રેખા પર કરવામાં આવી હતી.
તેથી તેનો અર્થ એ કે અમે શું કરી શકો છો - અમે માત્ર જાઓ તપાસો અને જુઓ શું થવાનું હતું શકો છો
buggy1.c, 6 વાક્ય પર.
ફરીથી, ત્યાં થોડા આ કરવા માટે માર્ગો છે. એક GDB બહાર બહાર નીકળવા છે
અથવા તમારો કોડ બીજી વિંડોમાં અને ક્રોસ સંદર્ભ માં ખોલો.
કે, અને પોતાના, ખૂબ સરળ છે કારણ કે હવે જો તમે ઓફિસ કલાકો પર છો
અને તમે seg ખામી મળી છે અને તમારા ટીએફ જ્યાં બધું તોડી હતી આશ્ચર્ય છે,
તમે હમણાં જ કહે, "ઓહ, 6 લીટી શકે મને ખબર નથી શું થઈ રહ્યું છે તે.
પરંતુ 6 રેખા વિશે કંઈક મારા કાર્યક્રમ તોડવા રહી છે. "
અન્ય કરવું રીત છે કે તમે આ GDB માં યાદી કહેવાય આદેશ વાપરી શકો છો.
તમને પણ તે l સાથે ટૂંકાવવું કરી શકો છો.
તેથી જો આપણે l ફટકો, અમે શું અહીં વિચાર છે?
અમે વિચિત્ર સામગ્રી સંપૂર્ણ સમૂહ છે.
આ વાસ્તવિક વિધાનસભા કોડ છે
કે strcmp_sse4_2 છે.
આ ફંકી પ્રકારની લાગે છે,
અને કારણ અમે આ રહ્યાં છો કારણ કે હમણાં છે,
GDB અમને 0 ચોકઠામાં છે.
>> જેથી ગમે ત્યારે અમે જોવા ચલો પર, કોઈપણ સમયે અમે સ્રોત કોડ જોવા,
અમે સ્રોત કોડ અંતે શોધી રહ્યાં છો કે જે સ્ટેક ફ્રેમ અનુલક્ષે અમે વર્તમાનમાં સાઇન છો
તેથી ક્રમમાં અર્થપૂર્ણ કંઈપણ વિચાર, અમે છે
સ્ટેક ફ્રેમ કે વધુ અર્થપૂર્ણ બને ખસેડવા.
આ કિસ્સામાં, મુખ્ય સ્ટેક ફ્રેમ થોડી વધુ અર્થમાં બનાવશે,
કારણ કે વાસ્તવમાં કોડ કે અમે લખ્યું હતું.
Strcmp નથી કોડ.
જે રીતે તમે ફ્રેમ્સ વચ્ચે ખસેડવા માટે, આ કિસ્સામાં કરી શકે છે, કારણ કે અમે બે હોય છે,
અમે 0 અને 1 હોય,
તમે ઉપર અને નીચે આદેશો સાથે કામ કરે છે.
જો હું એક ફ્રેમ ખસેડવા માટે,
હવે હું મુખ્ય સ્ટેક ફ્રેમ છું.
હું નીચે ખસેડો જ્યાં હું હતો પાછળ જવા માટે કરી શકો છો,
ફરી જાય છે, નીચે ફરી જાય છે, અને ફરી જાય છે.
જો તમે ક્યારેય GDB માં તમારા કાર્યક્રમ કરવા માટે, તમારે ક્રેશ વિચાર, તો તમે બેકસ્ટ્રેસ વિચાર,
અને તમે જુઓ કે તે અમુક ફાઈલ કે જે તમે જાણતા નથી કે શું થઈ રહ્યું છે તે કરે છે.
તમે યાદી પ્રયાસ કરો, કોડ તમે પરિચિત લાગતો નથી,
તમારી ફ્રેમ પર એક નજર અને બહાર આકૃતિ તમે જ્યાં છો.
તમે ખોટું સ્ટેક ફ્રેમ કદાચ છો.
અથવા ઓછામાં ઓછું તમે સ્ટેક ફ્રેમ કે એક કે જે તમે ખરેખર ડિબગ શકે છે છો.
હવે અમે યોગ્ય સ્ટેક ફ્રેમ છો, અમે મુખ્ય છો,
હવે અમે યાદી આદેશ વાપરો બહાર આકૃતિ વાક્ય શું થઇ હતી.
અને તમે તેને જોઈ શકે છે; તે અમારા માટે અહીં મુદ્રિત.
પરંતુ અમે બધા જ યાદી હિટ શકો છો, અને યાદી અમને આ સરસ પ્રિંટઆઉટ આપે છે
વાસ્તવિક સ્ત્રોત કોડ કે અહીં ચાલી રહ્યું છે એક છે.
>> ખાસ કરીને, અમે 6 વાક્ય પર જ દેખાય છે.
અમે જોઈ શકો છો શું થઈ રહ્યું છે તે અહીં.
અને લાગે છે કે અમે એક શબ્દમાળા સરખામણી કરી રહ્યા છીએ
શબ્દમાળા "CS50 ખડકો" અને argv વચ્ચે. [1]
આ વિશે કંઈક તૂટી હતી.
Missy તેથી, તમે શું રહ્યું હોઈ શકે છે અહીં પર કોઈપણ વિચારો છે?
[Missy] હું શા માટે ભાંગી છે ખબર નથી. >> તમે શા માટે તે ભાંગી છે ખબર નથી?
જીમી, કોઈપણ વિચારો?
[જિમી] હું સંપૂર્ણપણે ખાતરી, નથી પરંતુ છેલ્લા સમય અમે શબ્દમાળા ઉપયોગ સરખાવવા માટે,
અથવા strcmp, અમે તે હેઠળ ત્રણ અલગ અલગ કિસ્સાઓમાં જેમ હતી.
અમે == એક ન હતા, હું કે પ્રથમ લીટી માં અધિકાર નથી લાગતું નથી,.
તેના બદલે ત્રણ અલગ હતી, અને એક 0 == હતી,
એક હતી <0, મને લાગે છે, અને એક હતી> 0.
જેથી જેમ કદાચ કંઈક? >> યાહ. તેથી આ મુદ્દાને છે
આપણે સરખામણી યોગ્ય રીતે કરી?
સ્ટેલા? કોઈપણ વિચારો?
[સ્ટેલા] મને ખાતરી છે કે નથી. તેની ચોક્કસ ખાતરી નથી. >> ડેનિયલ? વિચારો? ઠીક છે.
તે તારણ આવ્યું છે તે અહીં થઈ રહ્યું શું છે જ્યારે અમે આ કાર્યક્રમ ચાલી હતી
અને અમે seg દોષ મળ્યું, જ્યારે તમે પ્રથમ વખત કાર્યક્રમ, ડેનિયલ ચાલી હતી,
નહોતી તમે તેને કોઈપણ આદેશ વાક્ય દલીલો આપી?
[ડીએલ] નં >> નંબર તે કિસ્સામાં, શું argv મૂલ્ય છે [1]
>> કોઇ મૂલ્ય નથી. >> અધિકાર.
વેલ, કોઈ યોગ્ય શબ્દમાળા કિંમત છે.
પરંતુ અમુક કિંમત છે. કિંમત છે કે જે ત્યાં સંગ્રહાયેલ નહીં શું છે?
>> એ કચરો કિંમત? >> તે ક્યાં તો એક કચરો કિંમત છે કે આ કિસ્સામાં,
આ argv એરે ઓવરને હંમેશા નલ સાથે સમાપ્ત થાય છે.
તેથી વાસ્તવમાં માં સ્ટોર મળ્યો શું ત્યાં નલ છે.
અન્ય માર્ગ આ ઉકેલવા માટે તે વિચારવાનો મારફતે બદલે,
તેને છાપી આઉટ કરવાનો પ્રયાસ છે.
આ તે છે જ્યાં હું હતા કે GDB મદદથી મહાન છે,
કારણ કે તમે બધા ચલો છાપી શકો છો, બધા કિંમતો કે જે તમે કરવા માંગો છો
આ હાથમાં-છેલબટાઉ પૃષ્ઠ આદેશની મદદથી.
તેથી જો હું પૃષ્ઠ લખો અને પછી હું ચલ અથવા ચલની નામ મૂલ્ય લખો
કહે, argc, હું જુઓ કે argc 1 છે.
જો હું બહાર argv પ્રિન્ટ માંગો છો [0], હું જેથી જેમ જ કરી શકો છો.
અને જેમ આપણે જોયું, argv [0] હંમેશા તમારા કાર્યક્રમ નામ છે,
હંમેશા એક્ઝેક્યુટેબલ ના નામ પર.
અહીં તમે જુઓ તે સંપૂર્ણ પાથ નામ મળ્યું છે.
હું પણ છાપે argv [1] અને જુઓ શું થાય છે શકે છે.
>> અહીં અમે રહસ્યમય કિંમત આ પ્રકારની મળી.
અમે આ 0x0 મળ્યો હતો.
શબ્દ શરૂઆતમાં જ્યારે અમે હેક્સાડેસિમલ નંબરો વિશે વાત પર યાદ રાખો?
અથવા એ કેવી રીતે તે hex માં 50 પ્રતિનિધિત્વ કરવા વિશે છે કે 0 pset ઓવરને અંતે થોડી પ્રશ્ન?
જે રીતે આપણે સીએસ માં તે hex નંબરો લખવા માટે, ફક્ત જાતને ગૂંચવવામાં ન કરવા માટે
અક્ષાંશ સંખ્યામાં છે, અમે હંમેશા તેમને 0x સાથે ઉપસર્ગ.
તેથી આ 0x ઉપસર્ગ હંમેશા માત્ર અર્થ થાય છે હેક્સાડેસિમલ નંબર તરીકે નીચેનો નંબર અર્થઘટન,
નથી શબ્દમાળા તરીકે નથી અક્ષાંશ નંબર તરીકે નથી, દ્વિસંગી નંબર તરીકે.
કારણ કે 5-0 નંબર હેક્સાડેસિમલ એક માન્ય નંબર છે.
અને તે અક્ષાંશ, 50 માં નંબર છે.
તેથી આ માત્ર અમે કેવી રીતે disambiguate.
તેથી 0x0 0 હેક્સાડેસિમલ અર્થ, કે જે પણ 0 અક્ષાંશ 0 દ્વિસંગી.
તે માત્ર મૂલ્ય 0 છે.
તે તારણ છે કે જે આ છે નલ શું છે, વાસ્તવમાં મેમરી છે.
નલ માત્ર 0 હોય છે.
અહીં, તત્વ argv અંતે સંગ્રહિત [1] નલ છે.
તેથી અમે એક નલ શબ્દમાળાને અમારી "CS50 ખડકો" શબ્દમાળા તુલના કરવાનો પ્રયાસ કરી રહ્યાં છો.
તેથી નલ dereferencing માટે નલ અંતે વસ્તુઓ ઍક્સેસ કરવાનો પ્રયાસ કરી,
તે સામાન્ય રીતે સેગ્મેન્ટેશન ક્ષતિમાં અથવા અન્ય ખરાબ થાય વસ્તુઓ અમુક પ્રકારની કારણ બની રહી છે.
અને તે તારણ છે કે strcmp જોવા માટે ચકાસણી કરતું નથી
કે શું નથી અથવા તમારી પાસે કિંમત છે કે જે નલ છે માં પસાર કર્યો છે.
તેના બદલે, તે માત્ર આગળ જાય છે, તેની વસ્તુ કરવા પ્રયાસ કરે છે,
અને જો તે ખામી seg, તે ખામી seg, અને તે તમારી સમસ્યા છે. તમે જવા માટે તેને ઠીક છે.
ખરેખર ઝડપથી કેવી રીતે અમે આ સમસ્યા ઠીક થઈ શકે છે? ચાર્લોટ?
[ચાર્લોટ] તમે જો મદદથી તપાસ કરી શકે છે.
તેથી જો argv [1] નલ છે, 0 ==, પછી 1 પરત, અથવા કંઈક [દુર્બોધ].
>> યાહ. જેથી એક મહાન તે કરવા રીત નથી, કારણ કે અમે એ જોવા માટે ચકાસણી કરી શકો છો,
મૂલ્ય અમે છો strcmp પસાર, argv [1], તે null છે?
તે નલ જો, તો પછી અમે ઠીક કહે, અડધેથી બંધ કરી શકો છો.
>> વધુ સામાન્ય આ કરવા માટે માર્ગ માટે argc કિંમત ઉપયોગ છે.
તમે અહીં મુખ્ય શરૂઆતમાં જોઈ શકો,
અમે તે પ્રથમ પરીક્ષણ અવગણવામાં કે અમે સામાન્ય રીતે કરવું જ્યારે અમે આદેશ વાક્ય દલીલો વાપરવા માટે,
જે ચકાસો કે શું નથી અથવા અમારી argc કિંમત છે, આપણે શું અપેક્ષા છે.
આ કિસ્સામાં, અમે ઓછામાં ઓછા બે દલીલો અપેક્ષા કરી રહ્યાં છો,
કાર્યક્રમના નામ વત્તા એક અન્ય.
કારણ કે અમે બીજી દલીલ અહીં ઉપયોગ કરી રહ્યાં છો.
તેથી પરીક્ષણ અમુક પ્રકારની અગાઉથી અમારા strcmp કોલ પહેલાં, કર્યા
કે પરીક્ષણો છે કે શું નથી અથવા argv 2 ઓછામાં ઓછા છે, પણ વસ્તુ એક જ પ્રકારની કરી શકે છે.
અમે જો કે કાર્યક્રમ ફરી ચલાવીને કામ કરે છે જોઈ શકે છે.
તમે હંમેશા GDB, જે ખરેખર સરસ છે અંદર તમારા કાર્યક્રમ શરૂ થઇ શકે.
તમે ચલાવો, અને જ્યારે તમે દલીલો તમારા કાર્યક્રમ પસાર કરી શકો છો,
તમે તેમને જ્યારે તમે રન કૉલ પાસ, નહિં કે જ્યારે તમે GDB બુટ કરો.
તે રીતે તમે વિવિધ દલીલો સાથે તમારા દરેક પ્રોગ્રામ invoking રાખી શકો છો.
તેથી ચલાવો, અથવા ફરી, હું r ટાઈપ કરી શકો છો, અને ચાલો શું જો અમે લખો થાય છે "હેલો".
તે હંમેશા તમને જો તમે શરૂઆતથી તેને ફરીથી શરૂ કરવા માંગો છો કરશે.
સામાન્ય રીતે, તમે શરૂઆતથી તેને ફરીથી શરૂ કરવા માંગો છો.
અને આ બિંદુએ, તે પુનઃશરૂ થાય છે તે ફરી, તે બહાર છાપે છે
કાર્યક્રમ કે અમે ચાલી છીએ, આ દલીલ હેલ્લો સાથે buggy1,
અને તે આ પ્રમાણભૂત બહાર છાપે છે, તે કહે છે, "તમે ડી મેળવવા માટે," દુખી ચહેરો.
પરંતુ અમે દોષ નથી seg નહોતો. એવું કહેવાય છે કે પ્રક્રિયા સામાન્ય રીતે બહાર.
જેથી ખૂબ સારું લાગે છે.
કોઈ વધુ seg દોષ, અમે તેને ભૂતકાળમાં બનેલ હોય છે,
જેથી તે લાગે છે કે ખરેખર seg દોષ ભૂલ કે અમે મળતું હતી.
કમનસીબે, અમને કહે છે કે અમે ડી રહ્યાં છો
>> અમે પાછા જાઓ અને કોડ જોવા કરી શકો છો અને શું ત્યાં પર થવાનું હતું
બહાર આકૃતિ શું હતું - તે શા માટે અમને જણાવ્યાં આવ્યું હતું કે અમે ડી મળ્યું
ચાલો જોવા માટે, અહીં આવ્યો હતો અને આ printf કહે છે કે તમે એક ડી મળ્યું
જો અમે યાદી લખો તરીકે તમે લખીને યાદી રાખો, તો તે તમારી કાર્યક્રમ દ્વારા નીચે વારો રાખે છે,
તેથી તે તમને તમારા કાર્યક્રમ પ્રથમ થોડા લીટીઓ બતાવીશું.
પછી તે તમને આગામી થોડા લીટીઓ, અને પછીના ભાગ અને આગળના ભાગ બતાવીશું.
અને તે નીચે જાઓ રાખવાનો પ્રયાસ કરીશું.
અને હવે અમે "લીટી નંબર 16 શ્રેણી બહાર છે." મળશે
કારણ કે તે માત્ર 15 રેખાઓ હોય છે.
જો તમે આ બિંદુએ મેળવવા અને તમારા આશ્ચર્ય, "હું શું કરી શકું?" તમે મદદ આદેશ વાપરી શકો છો.
મદદ અને પછી તેને આદેશ નું નામ આપવા વાપરો.
અને તમે જુઓ GDB અમને સામગ્રી તમામ આ પ્રકારની આપે છે.
તે કહે છે, "કોઈ દલીલ સાથે, પછી અથવા આસપાસ અગાઉના યાદી વધુ દસ રેખાઓ યાદી આપે છે.
યાદી - પહેલા દસ રેખાઓ યાદી આપે છે - "
તેથી આપણે યાદી બાદ વાપરવાનો પ્રયત્ન કરો.
અને તે 10 રેખાઓ અગાઉના યાદી આપે છે; તમે આસપાસ યાદી સાથે થોડો પ્લે કરી શકે છે.
તમે યાદી, યાદી કરી શકો છો - તમે પણ યાદી નંબર આપી શકે 8 યાદી જેમ,
અને તે 8 લીટી આસપાસ 10 રેખાઓ યાદી મળશે.
અને તમે શું થઈ રહ્યું છે તે અહીં જોવા છે કે તમે જો બીજા સરળ મળ્યો છે કરી શકો છો.
જો તમે CS50 ખડકો લખો, તે બહાર છાપે છે "તમે એ વિચાર"
અન્યથા તેને છાપે છે "તમે ડી વિચાર"
સમય વ્યર્થ થયો નગર. અધિકાર છે. હા?
>> [ડીએલ] તેથી, જ્યારે હું અવતરણ વિના CS50 ખડકો કરવાનું પ્રયાસ કર્યો
તે કહે છે કે "તમે ડી વિચાર"
હું અવતરણ તેને જરૂર કામ મેળવવા; કે શા માટે છે?
>> યાહ. તે તારણ છે કે જ્યારે - આ અન્ય મજા થોડી tidbit છે -
, જ્યારે તમે કાર્યક્રમ ચલાવો, જો આપણે તેને ચલાવવા અને અમે CS50 ખડકો લખો
જેમ ડીએલ હતા તેમણે અને તમે દાખલ દબાવો,
તે હજુ પણ કહે છે અમે ડી વિચાર
અને પ્રશ્ન છે, આ શા માટે છે?
અને તે તારણ છે કે જે બંને આપણા ટર્મિનલ અને GDB બે અલગ દલીલો તરીકે આ પદચ્છેદ.
જ્યારે ત્યાં એક જગ્યા, કે ગર્ભિત છે એટલા માટે છે કે
પ્રથમ દલીલ અંત; આગામી દલીલ શરૂ કરવા માટે છે.
આ માટે બે ભાગમાં તે ભેગા માર્ગ, અથવા માફ કરશો, એક દલીલ માં,
માટે અવતરણ ઉપયોગ છે.
તેથી હવે, જો આપણે તેને અવતરણ મૂકવા અને તે ફરીથી ચલાવવા માટે, અમે એક એ વિચાર
તેથી માત્ર રીકેપ માટે આ બોલ પર કોઈ ક્વોટ્સ, CS50 અને ખડકો બે અલગ દલીલો તરીકે પદચ્છેદન કરવામાં આવે છે.
અવતરણ સાથે, તે એક સંપૂર્ણપણે દલીલ તરીકે પદચ્છેદન છે.
>> અમે બ્રેકપોઇન્ટ સાથે આ જોઈ શકે છે.
અત્યાર સુધીમાં અમે અમારા કાર્યક્રમ કરવામાં ચાલી છે અને તે ચાલી રહ્યું કરવામાં આવ્યું
તો ખામી અથવા હિટ ભૂલ seg સુધી
અથવા જ્યાં સુધી તે બહાર નીકાળી છે અને તમામ તદ્દન દંડ કરવામાં આવ્યો છે.
આ જરુરી સૌથી ઉપયોગી વસ્તુ નથી, કારણ કે કેટલીક વખત
તમે તમારા કાર્યક્રમ ભૂલ છે, પરંતુ તે સેગ્મેન્ટેશન ક્ષતિમાં પરિણમે છે નથી છે.
તે તમારા રોકવા કાર્યક્રમ અથવા કે કંઈપણ કારણ બની છે.
આ માટે એક ખાસ સમયે વિરામ માટે GDB તમારી કાર્યક્રમ વિચાર માર્ગ
એક બ્રેકપોઇન્ટ સેટ છે.
તમે ક્યાં તો એક વિધેય નામ પર બ્રેકપોઇન્ટ સેટ કરીને આ કરી શકો છો
અથવા તમે કોડ ચોક્કસ રેખા પર બ્રેકપોઇન્ટ સેટ કરી શકો છો.
હું કાર્ય નામો પર બ્રેકપોઇન્ટ્સ સેટ કરવા માંગો, કારણ કે - સરળ યાદ રાખવું,
અને જો તમે ખરેખર જાય અને થોડો તમારા સ્રોત કોડ બદલવા માટે,
પછી તમારા બ્રેકપોઇન્ટ ખરેખર તમારો કોડ અંદર જ જગ્યાએ રહેશે.
જ્યારે જો તમે લીટી નંબરો ઉપયોગ કરી રહ્યાં છો, અને લીટી નંબરો બદલવા
કારણ કે તમે ઉમેરવા અથવા અમુક કોડ કાઢી નાખવા, પછી તમારા બ્રેકપોઇન્ટ્સ તમામ તદ્દન આવે ખરાબ કર્યું.
એક સૌથી સામાન્ય બાબતો હું મુખ્ય કાર્ય પર બ્રેકપોઇન્ટ સેટ કરવામાં આવે છે.
ઘણી વાર હું GDB બુટ પડશે, હું બોલ્ડ મુખ્ય લખો લિમિટેડ ફટકો પડશે, અને તે એક બ્રેકપોઇન્ટ સેટ કરશો
મુખ્ય કાર્ય જે ફક્ત કહે પર, "કાર્યક્રમ જલદી તમને ચાલી રહેલ શરૂ થોભો,"
અને તે રીતે, જ્યારે હું કહું છું, સાથે CS50 ખડકો તરીકે મારા કાર્યક્રમ ચલાવો બે દલીલો
અને Enter દબાવો, તે મુખ્ય કાર્ય માટે નહીં અને તે ખૂબ જ પ્રથમ વાક્ય પર અધિકાર સ્ટોપ્સ,
અધિકાર તે પહેલા strcmp કાર્ય મૂલ્યાંકન.
>> ત્યારથી હું થોભાવવામાં છું, હવે હું આસપાસ mucking અને જોયા શું થઈ રહ્યું છે તે શરૂ કરી શકો છો
વિવિધ ચલો કે મારા કાર્યક્રમમાં પસાર થાય છે બધા સાથે.
અહીં હું argc છાપી શકો છો અને શું થઈ રહ્યું છે.
જુઓ કે argc 3 છે, કારણ કે તે તેમાં 3 અલગ અલગ કિંમતો મળ્યું હતું.
તે કાર્યક્રમની નામ મળ્યું છે, અને તે પ્રથમ દલીલ અને બીજી દલીલ મળ્યું છે.
અમે તે argv જોઈ દ્વારા બહાર છાપી શકો છો [0] argv [1], અને argv [2].
તેથી હવે તમે પણ શા માટે આ strcmp કૉલ નિષ્ફળ રહ્યું છે જોઈ શકે છે,
કારણ કે તમે જુઓ કે તે અને બે અલગ દલીલો માં CS50 ખડકો વિભાજિત નહોતો.
આ બિંદુએ, તમે એકવાર એક બ્રેકપોઇન્ટ હિટ છો, તો તમારે તમારા કાર્યક્રમ દ્વારા પગલું ચાલુ રાખી શકો છો
રેખા દ્વારા રેખા, તમારા કાર્યક્રમ ફરી શરૂ કરવા માટે વિરોધ કર્યો હતો.
તેથી જો તમે તમારી કાર્યક્રમ ફરી શરૂ કરો અને ખાલી કરવા નથી માંગતા અહીંથી પર ચાલુ રાખવા માટે,
તમે ચાલુ રાખો આદેશ વાપરો અને કાર્યક્રમ ઓવરને માટે ચાલુ રહેશે કરી શકો છો.
બસ અહીં ગમતો.
જો કે, જો હું કાર્યક્રમ, CS50 ખડકો પુનઃશરૂ કરો, તો તે મારા બ્રેકપોઇન્ટ ફરીથી બનાવ્યા,
અને આ જ સમયે, જો હું કાર્યક્રમ બાકીના મારફતે માત્ર તમામ માર્ગ પર જાઓ નથી માંગતા,
હું આગામી આદેશ, કે જે હું પણ એન સાથે ટૂંકાવવું વાપરી શકો છો.
અને આ કાર્યક્રમ વાક્ય મારફતે વાક્ય દ્વારા કૂદી જશે.
તેથી તમે વસ્તુઓ ચલાવવા જુઓ, તરીકે ચલો ફેરફાર કરી શકો છો, જેમ વસ્તુઓ સુધારાશે છે.
જે ખૂબ સરસ છે.
અન્ય ઠંડી વસ્તુ અને અને ઉપર જ આદેશ ફરીથી પુનરાવર્તન બદલે છે,
જો તમે હમણાં દાખલ ફટકો - અહીં તમે જુઓ હું કાંઇ ન લખ્યો છે -
જો હું હમણાં જ દાખલ દબાવો, તેને પહેલાંના આદેશ પુનરાવર્તન કરશો,
અથવા અગાઉના GDB આદેશ કે હું હમણાં જ સાઇન મૂકી
હું લખો હિટ રાખવા અને તેને મારા લાઇન દ્વારા કોડ વાક્ય મારફતે વેગ રાખવા પડશે કરી શકો છો.
હું તમને ગાય્ઝ આઉટ અન્ય બગડેલ કાર્યક્રમો તપાસ તેમજ જવા માટે પ્રોત્સાહિત કરશે.
અમે તેમને આજે વિભાગમાં તમામ મારફતે વિચાર સમય નથી.
સ્ત્રોત કોડ પણ છે, જેથી તમે શું થઈ રહ્યું છે તે પ્રકારની કરી શકો છો
પડદા જો તમે ખરેખર સ્થિર પાછળ,
પરંતુ ઓછામાં ઓછા, માત્ર ઉપર GDB બુટ કરવા ઉપયોગ કરે છે,
આ કાર્યક્રમ ચાલી ત્યાં સુધી તે તમને તોડે,
આ બેકસ્ટ્રેસ મેળવીને, બહાર figuring શું કામ કરે છે તે ક્રેશ હતો,
શું લીટી તેના પર હતી, કેટલાક ચલ કિંમતો છાપવા,
એ જ તમે તેને માટે એક લાગણી વિચાર છે કારણ કે તે ખરેખર તમે આગળ જતાં મદદ કરશે.
આ બિંદુએ, અમે GDB બહાર છોડી દીધું છે, કે જે તમે બહાર નીકળવા મદદથી આવું અથવા ફક્ત q રહ્યા છીએ.
જો તમારા કાર્યક્રમ હજુ ચાલતી મધ્યમાં છે, અને તે ન બહાર નીકાળી છે,
તે હંમેશા તમે પૂછશે, "શું તમે ખરેખર તમે ખરેખર બહાર નીકળવા માંગો છો?"
તમે માત્ર હા હિટ કરી શકે છે.
>> હવે અમે આગામી સમસ્યા અમે હોય છે, જે બિલાડી કાર્યક્રમ છે જોવા જઈ રહ્યાં છો.
જો તમે પુનઃદિશામાન અને પાઈપો પર ટૂંકા જુઓ, તમે જોશો કે ટોમી આ કાર્યક્રમ વાપરે છે
જે સામાન્ય સ્ક્રીન પર એક ફાઇલ તમામ આઉટપુટ છાપે છે.
તેથી જો હું બિલાડી ચલાવવા માટે, આ ખરેખર એક કાર્યક્રમ આંતરિક છે સાધન છે,
અને જો તમે મેક્સ હોય તો તમે તમારા Mac પર આ ખૂબ કરી શકો છો, જો તમે ટર્મિનલ ખોલો.
અને અમે - બિલાડી દો, કહો કે, cp.c, અને Enter દબાવો.
આ શું કર્યું, અમે થોડો સ્ક્રોલ અને જુઓ જ્યાં અમે લીટી ચાલી હતી જો,
અથવા જ્યાં અમે cat આદેશ ચાલી હતી, તે શાબ્દિક માત્ર છપાયેલ અમારા સ્ક્રીન પર cp.c સમાવિષ્ટો.
અમે તે ફરીથી ચલાવવા કરી શકો છો અને તમે બહુવિધ ફાઇલો સાથે મૂકી શકો છો.
તેથી તમે બિલાડી cp.c કરી શકે છે, અને પછી અમે પણ cat.c ફાઈલ એકસાથે જોડવું કરી શકો છો,
જે કાર્યક્રમ અમે લખી રહ્યાં છો છે,
અને તે બંને ફાઈલો પાછા છાપો અમારા સ્ક્રીન પાછળ પડશે.
તેથી જો આપણે થોડો સ્ક્રોલ, અમે જુઓ કે જ્યારે અમે આ બિલાડી cp.c, cat.c ચાલી હતી,
પ્રથમ તેને cp ફાઈલ મુદ્રિત, અને તેને નીચે હોય, તો પછી તેને cat.c ફાઈલ મુદ્રિત અધિકાર નીચે અહીં.
અમે આ ઉપયોગ કરવા માટે માત્ર અમારા પગ ભીના વિચાર જઈ રહ્યાં છો.
ટર્મિનલ પર સરળ પ્રિન્ટીંગ સાથે આસપાસ રમો જુઓ, કેવી રીતે કામ કરે છે.
જો તમે ગાય્સ gedit cat.c સાથે ખોલવા માટે, દાખલ દબાવો,
તમે કાર્યક્રમ છે કે અમે લખી રહ્યાં છો જોઈ શકો છો.
અમે આ સરસ બોઈલર પ્લેટ સમાવેશ કર્યા છે, જેથી અમે સમય ગાળવા કે બધા બહાર લખીને નથી.
અમે પણ દલીલોને નંબર તપાસો સાઇન પસાર
અમે એક સરસ વપરાશ સંદેશો છાપો.
>> આ બાબત છે કે, ફરી, જેમ કે અમારી વિશે વાત કરી એ પ્રકારની છે,
તે સ્નાયુ મેમરી જેવા લગભગ છે.
માત્ર સામગ્રી સમાન પ્રકારની કરવાનું ચાલુ રાખી યાદ
અને હંમેશા બહાર મદદરૂપ સંદેશો અમુક પ્રકારની છાપવા
કે જેથી લોકોને ખબર કેવી રીતે તમારા કાર્યક્રમ ચલાવવા માટે.
બિલાડી સાથે, તે સારુ સરળ છે; અમે હમણાં જ વિવિધ દલીલો તમામ મારફતે જાઓ જઈ રહ્યાં છો
કે અમારા કાર્યક્રમને પસાર કરવામાં આવી હતી, અને અમે છાપી રહ્યા છીએ
એક સમયે એક સ્ક્રીન પર તેમના બહાર સમાવિષ્ટો.
ક્રમમાં ફાઈલો પ્રિન્ટ સ્ક્રીન પર બહાર, અમે ખૂબ જ સમાન કંઈક જઈ રહ્યાં છો
અમે શું ક્વિઝ ઓવરને અંતે હતી.
ક્વિઝ છે, કે જે કાર્યક્રમ ભાડે ઓવરને અંતે, અમે એક ફાઇલ ખોલવા હતી,
અને પછી તો અમે તેને છાપી હતી.
આ કિસ્સામાં, અમે એક ફાઇલ ખોલવા જઈ રહ્યાં છો, અને અમે તે જગ્યાએ વાંચી રહ્યા છીએ.
પછી અમે ફાઈલમાં બદલે છાપો, જઈ રહ્યાં છો, તો અમે સ્ક્રીન પર છાપી રહ્યા છીએ.
જેથી સ્ક્રીન તમને બધા printf સાથે કર્યું છે તે પહેલા કરવામાં પર છાપવા.
તેથી તે ખૂબ અસ્થિર નથી.
પરંતુ ફાઇલ વાંચવામાં વિચિત્ર પ્રકારની છે.
અમે તે થોડો દ્વારા એક સમયે જવા પડશે.
જો તમે ગાય્સ કે છેલ્લા સમસ્યા પર પાછા તમારા ક્વિઝ, 33 સમસ્યા પર જાઓ,
પ્રથમ વાક્ય કે અમે અહીં જઈ રહ્યાં છો, તો ફાઇલ ખોલીને, ખૂબ આપણે શું ત્યાં હતી જેવી જ છે.
સ્ટેલા તેથી શું, જ્યારે અમે ફાઇલ ખોલવા તે લીટી દેખાવ કરે છે?
[સ્ટેલા] કેપિટલ છે FILE *, ફાઈલ - >> ઠીક. >> - Fopen સમાન છે. >> Yup.
જે આ કિસ્સામાં છે? તે ટિપ્પણીમાં છે.
>> તે ટિપ્પણીમાં છે? argv [i] અને r?
ચોક્કસ. >> અધિકાર છે. તેથી સ્ટેલા તદ્દન યોગ્ય છે.
આ લીટી શું જુએ છે.
અમે ફાઇલ સ્ટ્રીમ ચલ વિચાર, તે છે FILE * માં સંગ્રહે જઈ રહ્યાં છો, તેથી તમામ કેપ્સ,
FILE, *, અને આ ચલ નું નામ ફાઇલ હશે.
અમે તેને કૉલ ગમે અમે ગમે શકે છે. અમે તેને first_file, અથવા file_i, ગમે અમે માંગતા હો કહી શકે છે.
અને પછી ફાઈલ નામ આદેશ આ કાર્યક્રમ માટે લીટી પર પસાર થયો હતો.
તેથી તે argv માં સંગ્રહિત છે [i,] અને પછી અમે વાંચી મોડમાં આ ફાઈલ ખોલવા જઈ રહ્યાં છો.
હવે અમે ફાઈલ ખોલ્યું, શું ચીજ છે કે આપણે હંમેશા કરવા માટે યાદ હોય છે
જ્યારે પણ અમે ફાઇલ ખોલી હોય તો શું? તે બંધ કરો.
તેથી Missy, અમે કેવી રીતે ફાઇલ બંધ છે?
[Missy] fclose () ફાઇલ >> fclose (ફાઇલ). બરાબર.
સરસ. ઠીક છે. જો અમે આ જોવા ટિપ્પણી અહીં કરવા માટે,
તે કહે છે, "ઓપન argv [i] અને stdout પર તેના સમાવિષ્ટો છાપો."
>> સ્ટાન્ડર્ડ એક વિચિત્ર નામ છે. Stdout માત્ર કહેતા અમારા રસ્તો છે
અમે તેને ટર્મિનલ પર છાપી માંગો છો; અમે તેને પ્રમાણભૂત આઉટપુટ સ્ટ્રીમ છાપવાનો કરવા માંગો છો.
અમે ખરેખર આ ટિપ્પણી છૂટકારો અહીં મેળવી શકો છો.
હું તેને તેની નકલ કરો અને પેસ્ટ કરો કારણ કે અમે શું કર્યું જાઉં છું.
આ બિંદુએ, હવે અમે બીટ દ્વારા ફાઇલ બીટ વાંચી છે.
અમે વાંચી ફાઈલો માર્ગો એક દંપતી ચર્ચા કરી છે.
જે મુદ્દાઓ પર તમારી મનપસંદ અત્યાર સુધી હોય છે?
માર્ગો કે જે તમને અથવા જોઈ હોય તો તમે યાદ રાખો કે, ફાઇલો વાંચી?
[ડીએલ] fread? Fread >>? Fread તેથી એક છે. જીમી, તમે કોઈપણ અન્ય જાણો છો?
[જિમી] નં >> ઠીક. ના. ચાર્લોટ? એલેક્ઝાન્ડર? કોઈપણ અન્ય? ઠીક છે.
તેથી અન્ય મુદ્દાઓ fgetc છે, એક કે અમે જરુર પડશે છે.
ત્યાં પણ fscanf; તમે ગાય્સ એક પેટર્ન અહીં જુઓ છો?
તેઓ બધા એફ સાથે શરૂ થાય છે. એક ફાઇલ સાથે જે કાંઈ કરવાનું હોય.
ત્યાં fread છે, fgetc, fscanf. આ વાંચીને તમામ કાર્યોને છે.
લેખન અમે fwrite હોય, તો અમે fgetc બદલે fputc છે.
અમે પણ fprintf ગમે છે અમે ક્વિઝ પર જોવા મળી હતી.
ત્યારથી આ સમસ્યા કે જે ફાઈલ માંથી વાંચવા સમાવેશ થાય છે,
અમે એક આ ત્રણ વિધેયો ઉપયોગ જઈ રહ્યાં છો.
અમે આ વિધેયોને વાપરવાનું નીચે અહીં જઈ રહ્યાં છો.
આ વિધેયો બધા પ્રમાણભૂત I / O લાઇબ્રેરી જોવા મળે છે.
તેથી જો તમે આ કાર્યક્રમ ટોચ પર જુઓ,
તમે જોઈ શકો છો કે અમે પહેલાથી જ પ્રમાણભૂત I / O લાઇબ્રેરી માટે હેડર ફાઈલ સમાવેશ કર્યો છે.
જો અમે બહાર આકૃતિ કરવા માંગો છો કે જે એક અમે ઉપયોગ કરવા માંગો છો,
અમે હંમેશા મદદ પાનાંઓ ખોલી શકે છે.
તેથી અમે માણસ stdio ટાઈપ કરી શકો છો
અને stdio અને સી માં ઇનપુટ આઉટપુટ કાર્યો વિશે તમામ વાંચો
અને અમે પહેલાથી જ જોવા ઓહ જુઓ, કરી શકો છો. તે fgetc ઉલ્લેખ છે, જે તેને fputc ઉલ્લેખ છે.
તેથી તમે થોડો વ્યાયામ કરી શકે છે અને અંતે જુઓ, જેમ કે, fgetc
અને તેનું મદદ પાનું જુઓ.
તમે જોઈ શકો છો કે તે અન્ય કાર્યો સંપૂર્ણ સમૂહ સાથે જાય છે:
fgetc, fgets, getc, getchar નહીં, ungetc, અને અક્ષરો અને શબ્દમાળાઓ તેના ઇનપુટ.
તેથી આ રીતે આપણે મૂળભૂત ઇનપુટ માંથી ફાઇલોને માંથી અક્ષરો અને શબ્દમાળાઓ માં વાંચો,
જે વપરાશકર્તા તરફથી અનિવાર્યપણે છે.
અને આ રીતે અમે તેને વાસ્તવિક સી માં કરવું
તેથી આ GetString અને GetChar વિધેયો નથી વાપરી રહ્યા છે
કે અમે CS50 પુસ્તકાલય માંથી વપરાય છે.
અમે ઘણી રીતે દંપતી આ સમસ્યા કરવા જઇ રહ્યાં છો
જેથી તમે આમ બે અલગ અલગ રીતે જોઈ શકે છે.
બંને fread કાર્ય કે ડીએલ ઉલ્લેખ કર્યો છે અને fgetc સારું કરવું માર્ગો છે.
મને લાગે છે કે fgetc થોડું સરળ છે, કારણ કે તે માત્ર છે, તમે જુઓ છો,
એક દલીલ, ફાઈલ * કે અમે અક્ષર વાંચી માંથી પ્રયાસ કરી રહ્યા છો,
અને તેના વળતર કિંમત પૂર્ણાંક છે.
અને આ થોડો ગૂંચવણમાં મૂકે, અધિકાર છે?
>> કારણ કે અમે એક અક્ષર રહ્યાં છો, તેથી આ શા માટે વળતર એક કોલસો બનાવો નથી?
તમે ગાય્સ શા માટે આ ઘરનાં પરચૂરણ કામો ન શકે પર કોઈપણ વિચારો છે?
[Missy જવાબો, દુર્બોધ] >> યાહ. તેથી Missy તદ્દન યોગ્ય છે.
જો તે ASCII છે, તો પછી આ પૂર્ણાંક એક વાસ્તવિક ઘરનાં પરચૂરણ કામો સાથે જોડાયેલ હોઇ શકે છે.
એક ASCII અક્ષર હોઇ શકે છે, અને તે યોગ્ય છે.
કે ચોકકસ શું ચાલી રહ્યું છે તે છે.
અમે પૂર્ણાંક ઉપયોગ કરી રહ્યાં છો કારણ કે તે માત્ર વધુ બિટ્સ ધરાવે છે.
તે ચાર રચે કરતાં મોટી છે; અમારા ઘરનાં પરચૂરણ કામો માત્ર 8 બીટ્સ છે, કે જે અમારા 32-bit મશીનો પર 1 બાઇટ.
અને પૂર્ણાંક જગ્યા 4 'બાઇટ્સ વર્થ છે.
અને તે તારણ છે કે જે રીતે fgetc કામ કરે છે,
, જો અમે અમારી સારાંશ નીચે આ માણસ પાનું થોડો માં સ્ક્રોલ
બધી રીતે સ્ક્રોલ ડાઉન. તે તારણ આપે છે કે તેઓ આ ખાસ EOF કહેવાય કિંમત વાપરો.
તે fgetc કાર્ય પરત કિંમત તરીકે એક ખાસ સતત છે
જ્યારે તમે ફાઇલ ઓવરને ફટકો અથવા જો તમને ભૂલ મળી.
અને તે તારણ છે કે EOF સાથે આ તુલના કરવા માટે યોગ્ય રીતે,
તમે પૂર્ણાંક માં જાણકારી કે જે વધારાના જથ્થો કે તમારી પાસે માંગો છો
તરીકે ઘરનાં પરચૂરણ કામો ચલ મદદથી વિરોધ કર્યો હતો.
ભલે fgetc અસરકારક રીતે ફાઇલ માંથી એક પાત્ર મેળવીને,
તમે યાદ રાખો કે તે કંઈક છે જે પ્રકાર પૂર્ણાંક તમે કરવા પરત છે કરવા માંગો છો.
તેણે કહ્યું, તે એકદમ વાપરવા માટે સરળ છે.
તે અમને એક અક્ષર આપી રહ્યું છે; જેથી તમામ અમે શું હોય છે ફાઈલ પૂછવા રાખવા માટે,
"મને આગલા અક્ષર આપો, મને આગલા અક્ષર આપી છે, મને આગલા અક્ષર આપવા માટે,"
ત્યાં સુધી અમે ફાઈલ ઓવરને મેળવો.
અને તે એક અક્ષર અમારી ફાઇલ માંથી એક સમયે ખેંચી જશે,
અને પછી અમે શું કરી શકો છો ગમે અમે તેની સાથે ગમે છે.
અમે તે સ્ટોર કરી શકે છે, અમે તેને શબ્દમાળા ઉમેરવા, અમે તેને છાપી આઉટ કરી શકે છે.
કે કોઇ પણ કામ કરે છે.
>> પાછા ઝૂમ આઉટ અને અમારા cat.c કાર્યક્રમ પર પાછા જવાનું,
જો અમે fgetc ઉપયોગ જઈ રહ્યાં છો,
અમે કોડ આગામી રેખા કેવી રીતે સંપર્ક કરી શકે છે?
અમે ઉપયોગ કરવા માટે જઈ રહ્યાં છો - fread સહેજ કંઇક અલગ કરશે.
અને આ જ સમયે, અમે હમણાં જ fgetc વાપરવા માટે એક સમયે એક પાત્ર મળી રહ્યા છીએ.
એક આખી ફાઇલ પર પ્રક્રિયા, અમે શું હોય શકે?
કેટલા અક્ષરો ફાઈલ છે?
ત્યાં ઘણા બધા છે. તેથી તમે કદાચ એક વિચાર કરવા માંગો છો
અને પછી બીજા વિચાર અને અન્ય વિચાર અને અન્ય મેળવો.
અલ્ગોરિધમનો તમે કેવા પ્રકારની વિચારો છો અમે અહીં ઉપયોગ હોય?
કયા પ્રકારની ની -? [એલેક્ઝાન્ડર] લૂપ માટે? ચોક્કસ. >>
લૂપ કેટલાક પ્રકાર.
લૂપ માટે ખરેખર મહાન આ કિસ્સામાં છે.
અને તમે કહેતા હતા, જેમ લાગે છે કે તમે તે સમગ્ર ફાઈલ પર લૂપ માંગો છો,
એક સમયે, એક અક્ષર રહ્યો.
શું કોઈ સૂચનો છે કે આના જેવો શકે છે?
[એલેક્ઝાન્ડર દુર્બોધ]
>> ઠીક છે, ફક્ત મને ઇંગલિશ માં જણાવો કે તમે શું કરી રહ્યાં છો? [એલેક્ઝાન્ડર દુર્બોધ]
તેથી આ કિસ્સામાં, તેને લાગે જેમ અમે સમગ્ર ફાઈલ પર લૂપ માટે પ્રયાસ કરી રહ્યા છો.
[એલેક્ઝાન્ડર] તેથી i <પૂર્ણાંક કદ? >> કદ -?
હું ફાઈલ માપ અધિકાર અનુમાન? માપ - we'll ફક્ત તે આ જેમ લખો.
ફાઈલ સમય માટે માપ છે, આઇ + +.
તેથી તે તારણ આપે છે કે જે રીતે તમે આ fgetc મદદથી નથી, અને આ નવા છે,
છે કે ત્યાં કોઈ સરળ ફક્ત એક ફાઇલ કદ વિચાર રીત છે
રચવા કે જે તમે પહેલા જોયેલા આ "sizeof" પ્રકાર સાથે.
જ્યારે અમે તે fgetc કાર્ય વાપરવા માટે, અમે કેટલીક પ્રકારની રજૂઆત કરી રહ્યાં છો
નવું, લૂપ માટે આ ફંકી વાક્યરચના, જ્યાં તેને બદલે માત્ર એક મૂળભૂત કાઉન્ટર ઉપયોગ
માટે પાત્ર દ્વારા અક્ષર જાઓ, અમે એક સમયે એક અક્ષર ખેંચી જઈ રહ્યાં છો,
એક સમયે એક પાત્ર, અને જે રીતે અમે જાણીએ છીએ કે અમે ઓવરને અંતે છો
તો અમે અક્ષરો ચોક્કસ નંબર ત્યારે ગણાશે કરી લીધી છે,
પરંતુ જ્યારે અક્ષર અમે ખેંચવાનો ફાઈલ પાત્ર છે કે ખાસ અંત છે.
તેથી અમે આ દ્વારા કરી શકે છે - હું આ સીએચ કહી છે, અને અમે તેને પ્રારંભ જઈ રહ્યાં છો
અમારી પ્રથમ ફાઈલ બહાર પ્રથમ અક્ષર વિચાર કૉલ સાથે.
આ અહીં ભાગ તેથી, આ ફાઈલ એક પાત્ર મેળવવા રહ્યું છે
અને તે ચલ ચ માં સંગ્રહે છે.
અમે આ કરવાનું ચાલુ રાખી રહ્યા છીએ ત્યાં સુધી અમે ફાઈલ અંતે વિચાર,
જેને આપણે હોય છે કે, ખાસ EOF પાત્ર ન પાત્ર માટે પરીક્ષણ દ્વારા કામ કરે છે.
અને પછી તેની જગ્યાએ ચ કરવાની + +, જે ફક્ત કિંમત વધારો કરશે,
તેથી જો આપણે ફાઈલ એક બહાર A, મૂડી એ કહેવું, વાંચી,
ચ + + અમને બો આપશે, અને તે પછી અમે કેચ અને પછી ડી મેળવી લેતો.
કે જે સ્પષ્ટપણે આપણે શું કરવા માંગો છો નથી. અમે અહીં શું કરવા માંગો છો
આ છેલ્લા બીટ માં અમે ફાઈલ ના આગલા અક્ષર મેળવવા માંગો છો છે.
>> તેથી અમે કેવી રીતે ફાઇલ ના આગલા અક્ષર વિચાર કરી શકે છે?
ફાઇલ પર અમે કેવી રીતે તે પ્રથમ અક્ષર વિચાર?
[વિદ્યાર્થી] fgetfile? >> Fgetc, અથવા, માફ કરશો, તમે સંપૂર્ણપણે અધિકાર હતા.
હું તે ત્યાં ખોટીજોડણીવાળું. હા તેથી.
અહીં બદલે સીએચ કરવાની + +,
અમે હમણાં જ (ફાઇલ) ફરી fgetc કહી રહ્યા છીએ
અને અમારી જ સીએચ ચલ માં પરિણામ સ્ટોર કરે છે.
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]
>> આ તે છે જ્યાં આ છે FILE * ગાય્સ ખાસ હોય છે.
જે રીતે તેઓ કામ તેઓ છે - જ્યારે તમે પ્રથમ ખોલવા - જ્યારે તમે પ્રથમ કે fopen કૉલ કરવા માટે,
ફાઇલ * અસરકારક રીતે ફાઈલ શરૂઆતમાં એક નિર્દેશક તરીકે કામ કરે છે.
અને પછી દરેક વખતે તમે fgetc કહી, તે ફાઈલ મારફતે એક અક્ષર ખસે છે.
તેથી જ્યારે પણ તમે આ કૉલ, તમે એક અક્ષર દ્વારા ફાઈલ નિર્દેશક incrementing કરી રહ્યાં છો.
અને જ્યારે તમે ફરીથી fgetc, તો તમે તેને અન્ય અક્ષર ખસેડીએ છીએ
અને અન્ય પાત્ર અને અન્ય પાત્ર અને અન્ય પાત્ર.
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ] >> અને that's - હા.
તે હૂડ હેઠળ આ જાદુ પ્રકારની છે.
તમે હમણાં મારફતે incrementing રાખો.
આ બિંદુએ, તમે ખરેખર એક અક્ષર સાથે કામ કરવાનો છો.
તેથી અમે કેવી રીતે સ્ક્રીન પર આ છાપે શકે છે હવે?
અમે એ જ printf વસ્તુ કે અમે પહેલાં વપરાય વાપરી શકો છો.
કે અમે બધા સત્ર નો ઉપયોગ કર્યો છે.
અમે printf કહી શકો છો,
અને અમે પાત્ર છે કે જેમ જ પસાર કરી શકે છે.
અન્ય કરવું માર્ગ printf ઉપયોગ કરીને અને આ ફોર્મેટ સ્ટ્રિંગ કરવું કરવાને બદલે છે,
અમે પણ એક અન્ય કાર્યો પણ ઉપયોગ કરી શકો છો.
અમે fputc, જે સ્ક્રીન પર એક અક્ષર છાપે ઉપયોગ કરી શકો છો,
જો સિવાય અમે fputc જોવા - દો મને બહાર થોડો ઝૂમ.
અમે જુઓ સરસ શું છે તે અક્ષર લે છે કે અમે વાંચી fgetc વાપરી રહ્યા હોય,
પરંતુ તે પછી અમે તેને છાપી સ્ટ્રીમ આપી છે.
અમે પણ putchar કાર્ય છે, કે જે સીધી પ્રમાણભૂત બહાર મૂકવામાં આવશે વાપરી શકો છો.
તેથી ત્યાં વિવિધ વિકલ્પો છે કે અમે છાપકામ માટે ઉપયોગ કરી શકો છો સંપૂર્ણ ઝુમખું પણ છે.
તેઓ પ્રમાણભૂત I / O લાઇબ્રેરી તમામ છો.
જ્યારે પણ તમે છાપવાનો માંગો છો - તેથી printf મૂળભૂત રીતે, સ્ટ્રીમ બહાર ખાસ પ્રમાણભૂત છાપવાનો કરશે,
જે stdout પર છે.
તેથી અમે ફક્ત આ જાદુ કિંમત, અહીં stdout પર પ્રકારની તરીકે તે ઉલ્લેખ કરી શકે છે.
અરે. બહારની અર્ધવિરામ મૂકો.
>> આ નવું, અહીં ફંકી ઘણી માહિતી છે.
આ એક ઘણો ખૂબ રૂઢિપ્રાયોગિક અર્થમાં કે આ કોડ છે, છે
કે આ રીતે લખવામાં આવે છે કે માત્ર કારણ કે તે સ્વચ્છ કરવા માટે વાંચો, વાંચવા સરળ.
ઘણી અલગ કરવું રીતે, ઘણા વિવિધ કાર્યો તમે ઉપયોગ કરી શકો છો,
પરંતુ અમે માત્ર પર અને આ જ પદ્ધતિને અનુસરતા હોય છે.
તેથી જો તમે ફરીથી અને ફરીથી આવતા આ જેવી કોડ જોઈ શકાતી નથી આશ્ચર્ય નથી.
અધિકાર છે. આ બિંદુએ, અમે દિવસ માટે તોડી જરૂર છે.
આગામી માટે આભાર. જોવાનું જો તમે ઑનલાઇન માટે આભાર. અને અમે આગામી સપ્તાહે તમે જોશો.
[CS50.TV]