>> 1 વક્તા: માતાનો એક નજર આ CS50 પુસ્તકાલય પર,
ખાસ તેના GetInt કાર્ય કરે છે.
અહીં અમે વાસ્તવિક સ્ત્રોત છે GetInt માટે કોડ.
અને તે ખૂબ લાંબુ નથી કે નોટિસ, અને તે મોટા ભાગના જ્યારે લૂપ રચના -
તે એક અનંત લૂપ - કે જે માત્ર અમે ખરેખર એક વાર એક કિંમત આપે છે
અમે અપેક્ષા શું મેળવેલ.
આપણે તેના લઈ જવામાં.
>> પ્રથમ અહીં નોંધ કરો કે આ લૂપ શરૂ થાય છે.
અમે કોડ એક વાક્ય છે કે આગામી નોંધ કરો કે ખરેખર GetString કહે
અને એક માં પરત કિંમત સંગ્રહ કરે છે ચલ, પ્રકાર શબ્દમાળા, લાઇન છે.
અમે પછી એક સેનીટી ચેક એક બીટ છે.
રેખા == નલ હોય, તો પછી અમે જિજ્ઞાસાપૂર્વક INT_MAX આવો.
>> હવે તે INT_MAX તારણ આપે છે કે એક ખાસ સતત તેના સિવાય જાહેર
કે સૌથી શક્ય સ્પષ્ટ કરે તમે માં પ્રતિનિધિત્વ કરી શકે છે કે પૂર્ણાંક
આ જેવા કાર્યક્રમ.
હવે અમે આપખુદ પરત ફરવાનું નક્કી કર્યું છે એક સંત્રી કિંમત તરીકે INT_MAX
પ્રકારના અમે અનામત કર્યું છે એક જેનો અર્થ થાય છે એક ભૂલ આવી.
તેથી અમે ચૂકવણી કિંમત, અલબત્ત, છે કે GetInt દેખીતી રીતે નથી કરી શકો છો
ખરેખર મોટા સંખ્યાબંધ પરત INT_MAX, તે ઇચ્છે છે પણ જો કારણ કે,
કે વળતર કિંમત ખરેખર જોઈએ કોલર દ્વારા અર્થઘટન કરી -
જેનો GetInt મદદથી છે -
અમુક પ્રકારની ભૂલ તરીકે.
>> આગળ, હું જાહેર કર્યું છે કે નોટિસ પૂર્ણાંક n એ અને ચાર રચે સી.
કોડ આ આગળના વાક્ય માં, હું કહી sscanf કહેવાય કાર્ય, માં પસાર
ચાર દલીલો.
શબ્દમાળા છે જે લાઇન, વપરાશકર્તાની બંધારણમાં જે લખ્યો, "% હું% C"
હું વપરાશકર્તા શકે અપેક્ષા છું કે જેઓ શબ્દમાળા ની સરનામા અનુસરતા પ્રકાર,
n એ, અને સી ની સરનામું.
જીવનમાં હવે આપણે sscanf હેતુ ખરેખર છે પાંચ શોધી શબ્દમાળા સ્કેન
ચોક્કસ બંધારણ છે કે જે પ્રોગ્રામર કે બીજી દલીલ તરીકે સ્પષ્ટ છે.
આ કિસ્સામાં,% હું છે ,% C છે કારણ કે ત્યાં.
Sscanf માં પૂર્ણાંક સામનો તેથી જો વપરાશકર્તાની ઇનપુટ, કે પૂર્ણાંક સંગ્રહિત કરવામાં આવશે
n એ કહેવાય ચલ ની અંદર કારણ કે અમે ત્રીજા તરીકે આપવામાં આવી છે
n ના સરનામા sscanf માટે દલીલ.
જે sscanf ખરેખર જાઓ શકે છે ત્યાં, અને તેમાં કિંમત સુધારો.
>> હવે, કિસ્સામાં વપરાશકર્તા પ્રકારો વધુ કંઈક માં
એક અથવા વધુ અંકો કરતાં -
અન્ય શબ્દોમાં, અમુક પ્રકારની એક કોલસો બનાવો -
જેની આંકડાના કે બીજા ચલ સી, અમે તેના ચોથા તરીકે sscanf પસાર
દલીલ પણ રચાયેલ કરવામાં આવશે.
હવે એક માટે તપાસ ના ઊંધો વપરાશકર્તા માંથી વધારાના પાત્ર છે
કે તે અથવા તેણી સહકાર ન થાય તો, અને માત્ર પૂર્ણાંક કરતાં વધુ પ્રકારો,
અમે આ માં તે શોધવા માટે સક્ષમ હશો રીતે, તે કિસ્સામાં, sscanf કારણ
દર્શાવે છે, 2 પરત ચાલી રહ્યું છે કે આ જગ્યામાં બંને ભરવામાં આવ્યા હતા
કિંમતો સાથે.
પરંતુ અમે તેના બદલે છે કે sscanf આશા કરી રહ્યા છીએ માત્ર વપરાશકર્તા એટલે કે, 1 આપે છે
પૂર્ણાંક છે.
>> અમે શું કરી શકું જો sscanf ખરેખર 1 આપે છે?
વેલ, અમે તરત જ લીટી મુક્ત કે તે પછી વપરાશકર્તા માં ટાઇપ, અને અમે
તરત જ કર્યા, એન પાછા પૂર્ણાંક મેળવેલ.
બાકી, sscanf 1 પરત, અને ન થાય તો વપરાશકર્તા તેથી સહકાર ન હતી,
અમે હજુ પણ રેખા મુક્ત છે, પરંતુ અમે હવે ફરીથી પ્રયત્ન કરવા માટે વપરાશકર્તાને પૂછે છે.
અને અમે તે અંદર હજી પણ કારણ અન્યથા અનંત લૂપ, પ્રક્રિયા
ફરી શરૂ કરવા માટે, અને કદાચ ફરી, અને કરશે કદાચ ફરી, ત્યાં સુધી વપરાશકર્તા ખરેખર
અમને એક પૂર્ણાંક છે.