[Powered by Google Translate] [5 વિભાગ - વધુ અનુકૂળ]
[રોબ બોડેન - હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે. - CS50.TV]
>> જેમ હું મારા ઇમેઇલમાં જણાવ્યું હતું કે, ત્યાં વસ્તુઓ તમે ઉપયોગ કરી શકો છો ઘણો છે
જે વાસ્તવમાં સમસ્યા સેટ કરવા સાધન કરતાં અન્ય.
અમે ભલામણ કરીએ છીએ તમે તે સાધન શું માત્ર કારણ કે તે પછી અમે વધુ સરળતાથી તમે મદદ કરી શકો છો
અને અમે જાણીએ છીએ કે કેવી રીતે બધું કામ થઈ રહ્યું છે.
પરંતુ જ્યાં તમે વસ્તુઓ, જો કહી શકીએ એક ઉદાહરણ તરીકે, તમે ઍક્સેસ નથી
ઓજાર અથવા તમે સાયન્સ સેન્ટર ભોંયરામાં કામ કરવા માંગો છો -
જે વાસ્તવમાં તેઓ સાધન પણ છે -
જો તમે ગમે ત્યાં કામ કરવા માંગો છો.
એક ઉદાહરણ તમારી પાસે જોવા મળે છે / SSH સાંભળ્યું?
SSH કંઈક સાથે જોડાવા માટે જેમ જ મૂળભૂત છે.
ખરેખર, હમણાં હું ઉપકરણ માં SSHed છું.
આ ઉપકરણ માં હું સીધી ક્યારેય કામ કરે છે.
અહીં સાધન છે, અને જો તમે અહીં જુઓ તમે આ IP સરનામું જુઓ.
આ સાધન એ પોતે હું ક્યારેય કામ;
હું હંમેશા iTerm2 વિન્ડો / વિન્ડો ટર્મિનલ પર આવે છે.
કે જે તમને IP સરનામું, jharvard@192.168.129.128 ssh માટે SSH કરી શકો છો.
હું કે જે નંબર ખૂબ સરળતાથી યાદ નથી કારણ કે તે આવા સરસ પેટર્ન છે.
પરંતુ મને મારા પાસવર્ડ માટે પૂછો, અને હવે હું સાધન છું.
મૂળભૂત રીતે, આ બિંદુએ, જો તમે ઉપકરણ પોતાની અંદર ટર્મિનલ ખોલવામાં,
આ ઈન્ટરફેસ જોકે તમે તેનો ઉપયોગ કરશે, બરાબર એ જ
ઈન્ટરફેસ તરીકે હું ઉપર ઉપયોગ કરું છું, અહીં પરંતુ હવે તમે SSHed કરી રહ્યાં છો.
તમે ઉપકરણ માટે SSH માટે નથી.
બીજા સ્થાને તમે કરી શકે SSH એક ઉદાહરણ છે હું ખૂબ ખાતરી કરો કે તમે મૂળભૂત રીતે હોય છે છું -
ઓહ. ઘણી મોટી છે.
તમે બધા મૂળભૂત FAS સર્વર્સ પર FAS એકાઉન્ટ્સ દ્વારા હોવી જોઈએ.
મારા માટે, હું SSH છો rbowden@nice.fas.harvard.edu છે.
તે છે કે જે તમને પ્રથમ વખત પૂછી રહ્યું છે, અને તમે હા કહી.
મારા પાસવર્ડ માત્ર મારા FAS પાસવર્ડ પ્રયત્ન રહ્યું છે.
અને તેથી હવે, હું સરસ સર્વરો માટે SSHed છું, અને મેં કંઈપણ હું અહીં પર માંગો છો કરી શકો છો.
વર્ગો તમે, 124 જેવી લાગી શકે છે ઘણાં, હોય તમે અહીં સામગ્રી અપલોડ જવું છે
ખરેખર તમારી સમસ્યા સેટ સબમિટ કરો.
પરંતુ કહે છે કે તમે તમારા ઉપકરણ માટે ઍક્સેસ નથી.
પછી તમે વસ્તુઓ નથી, તો તે અંહિ પર જેમ કહેવું હશે -
આ માત્ર પ્રશ્નો અમારા વિભાગ છે.
તે તમને ઉપકરણ માં આવું કરશે.
તેના બદલે હું હમણાં જ તે સર્વર પર કરી શકશો.
હું અનઝિપ કરી જાઉં છું.
આ સમસ્યા માટે પ્રયત્ન કરે છે કે તમે gedit કંઈક મદદથી ઉપયોગ કરી રહ્યા છો રહ્યું છે
અથવા સાધન ની અંદર ગમે.
તમે FAS સર્વર પર નથી જઈ રહ્યાં છો.
તે બધા માત્ર છે આ શાબ્દિક ઈન્ટરફેસ હશે.
તેથી તમે એક ક્યાં, એક લખાણ સંપાદક છે કે તેઓ પાસે જાણવા પ્રયાસ કરી શકે છે.
તેઓ નેનો છે.
નેનો સામાન્ય રીતે ખૂબ વાપરવા માટે સરળ.
તમે તમારા તીરો વાપરો અને સામાન્ય રીતે લખી શકો છો.
તેથી તે હાર્ડ નથી.
જો તમે ખરેખર ફેન્સી મેળવવા માંગો છો તો તમે Emacs ઉપયોગ કરી શકો છો,
જે હું કદાચ કારણ કે હું પણ કેવી રીતે Emacs બંધ ખબર નથી ન ખોલી કરીશું.
નિયંત્રણ એક્સ, નિયંત્રણ સી? યાહ.
અથવા તમે આવેશ, કે જે હું શું ઉપયોગ કરવા માટે કરી શકો છો.
અને તેથી તે તમારા વિકલ્પો છે.
જો તમે તે નથી માંગતા, તો તમે પણ કરી શકાય છે જો તમે જોવા manual.cs50.net -
ઓહ.
એક પીસી પર, તમે SSH PuTTY મદદથી કરી શકો છો,
જે તમે અલગ અલગ ડાઉનલોડ કરી રહ્યા છીએ.
મેક પર, તમે મૂળભૂત ઉપયોગ ટર્મિનલ દ્વારા માત્ર અથવા તમે iTerm2 કરી શકો છો ડાઉનલોડ કરી શકો છો,
જે સરસ, ફેન્સી ટર્મિનલ જેવી છે.
જો તમે manual.cs50.net જાઓ તમે નોટપેડ પર એક લિંક જોશો + +,
જે તમે શું PC પર ઉપયોગ કરી શકો છો.
તે તમને નોટપેડ થી SFTP દે + +, કે જે મૂળભૂત રીતે SSH છે.
આ તમને માહિતી આપશે શું છે તમારી ફાઇલોને સ્થાનિક રીતે ફેરફાર કરવા માટે,
અને પછી જ્યારે પણ તમે તેમને સાચવવા માંગો છો, તે nice.fas સાચવવા માટે કરશે,
જ્યાં તમે પછી તેમને ચલાવી શકો છો.
અને મેક પર સમકક્ષ TextWrangler પ્રયત્ન રહ્યું છે.
તેથી તે તમને આ જ બાબત નથી.
તે તમને ફાઈલો સ્થાનિક રીતે ફેરફાર કરવા અને તેમને nice.fas સાચવવા માટે,
જ્યાં તમે પછી તેમને ચલાવી શકો છો.
તેથી જો તમે ક્યારેય ઓજાર વગર અટકી કરી રહ્યાં છો, તમે આ વિકલ્પો છે
તમારી સમસ્યા સેટ હજી પણ.
આ એક સમસ્યા કે તમે CS50 પુસ્તકાલય નથી જઈ રહ્યાં છો રહ્યું છે
કારણ કે nice.fas મૂળભૂત દ્વારા કે નથી.
તમે ક્યાં તો CS50 પુસ્તકાલય ડાઉનલોડ કરી શકો છો -
મને નથી લાગતું કે હું આ બિંદુએ કે જરૂર છે.
તમે ક્યાં તો CS50 પુસ્તકાલય ડાઉનલોડ કરી શકો છો અને તે nice.fas પર નકલ કરો,
અથવા મને લાગે છે કે આ સમયે અમે તેને હવે ઉપયોગ નથી કરતા તો પણ.
અથવા જો અમે હોય, તો તમે સમય સાથે તે કરી શકો છો બદલો કરવામાં આવી રહી છે
આ CS50 પુસ્તકાલય માં વિધેયોને રીતે અમલીકરણ.
જેથી પ્રતિબંધ છે કે બહુ પ્રયત્ન કરીશું.
અને તે કે.
>> હું પાછા સાધન હવે જઈશ; અમે સાધન બધું કરવું પડશે.
પ્રશ્નો અમારા વિભાગમાં છીએ, તો શરૂઆતમાં, જેમ કે હું મારા ઇમેઇલમાં જણાવ્યું હતું કે,
અમે ટૂંકા એક તમે જોવાનું માનવામાં આવ્યા હતા વિશે વાત છે.
અમે પુનઃદિશામાન કરી અને પાઇપ્સ અને આ ત્રણ પ્રશ્નો હોય છે.
>> માટે જે સ્ટ્રીમ જેવા કાર્યો printf નથી મૂળભૂત રીતે લખી?
સ્ટ્રીમ તેથી. સ્ટ્રીમ શું છે?
એક સ્ટ્રીમ મૂળભૂત જેમ તે માત્ર કેટલાક -
તે પણ નથી અને 1 સે 0s એક સ્ત્રોત છે.
સ્ટ્રીમ તેને અહીં પૂછી છે પ્રમાણભૂત બહાર છે.
અને તેથી પ્રમાણભૂત એક પ્રવાહ કે છે જ્યારે તમે તેને લખી,
તે સ્ક્રીન પર દેખાય છે.
સ્ટાન્ડર્ડ આઉટ, સ્ટ્રીમ દ્વારા, તો એનો અર્થ તમે માત્ર 1 સે અને તે 0s લખો,
અને પ્રમાણભૂત બહાર બીજા છેડે માત્ર તે સ્ટ્રીમ માંથી વાંચે છે.
તે માત્ર 1 સે અને 0s એક શબ્દમાળા છે.
તમે સ્ટ્રીમ્સ લખવા માટે અથવા તમે સ્ટ્રીમ્સ માંથી વાંચી શકે છે
સ્ટ્રીમ ખરેખર શું છે તેના પર આધાર રાખીને.
અન્ય બે મૂળભૂત સ્ટ્રીમ્સ અને પ્રમાણભૂત ભૂલ પ્રમાણભૂત છે.
માં ધોરણ જ્યારે તમે GetString હો, તો તે તમારા માટે ઇનપુટ સામગ્રી માટે રાહ જોઈ રહ્યું છે.
તેથી તે તમારા માટે રાહ જોઈ રહ્યું છે, તે ખરેખર પ્રમાણભૂત પર રાહ જોઈ છે,
જે ખરેખર છે તમે શું વિચાર છે જ્યારે તમે કીબોર્ડ લખો.
આપ લોગઇન ધોરણ માં ટાઇપ કરી રહ્યા
સ્ટાન્ડર્ડ ભૂલ મૂળભૂત પ્રમાણભૂત બહાર જેવું જ છે,
પરંતુ તે છે કે જે વિશિષ્ટ છે જ્યારે તમે પ્રમાણભૂત ભૂલ માટે છાપો,
તમે માત્ર તે ભૂલ સંદેશાઓ છાપી માનવામાં કરી રહ્યાં છો
જેથી તમે નિયમિત સ્ક્રીન પર છપાતા સંદેશાઓ વચ્ચે તફાવત કરી શકો છો
ભૂલ કે શું તેઓ પ્રમાણભૂત બહાર અથવા પ્રમાણભૂત ભૂલ ગયા પર આધાર રાખીને સંદેશાઓ વિરુદ્ધ.
પણ ફાઇલ્સ.
સ્ટાન્ડર્ડ બહાર માં ધોરણ, અને પ્રમાણભૂત ભૂલ માત્ર ખાસ સ્ટ્રીમ્સ હોય છે,
પરંતુ ખરેખર કોઈપણ ફાઈલ, જ્યારે તમે એક ફાઈલ ખોલવા માટે, તેને બાઇટ્સ એક પ્રવાહ બને છે
તમે હમણાં જ્યાં તે સ્ટ્રીમ માંથી વાંચી શકે છે.
તમે, સૌથી ભાગ માટે, ફક્ત બાઇટ્સ એક પ્રવાહ તરીકે ફાઇલ વિચાર કરી શકો છો.
તેથી શું સ્ટ્રીમ્સ તેઓ મૂળભૂત રીતે નથી લખી? સ્ટાન્ડર્ડ આઉટ.
>> > અને >> વચ્ચે શું તફાવત છે?
શું કોઈને પણ વિડિઓ પહેલાંથી જોઈ? ઠીક છે.
> હોય કે તમે કેવી રીતે ફાઇલોમાં પુનઃદિશામાન થઈ રહ્યું છે,
અને >> પણ ફાઇલોમાં આઉટપુટ પુનઃદિશામાન થઈ રહ્યું છે,
પરંતુ તેના બદલે ફાઈલ સાથે ઉમેરી રહ્યું છે.
ઉદાહરણ તરીકે, આપણે કહેવું કે હું dict અહીં હોય થાય છે,
અને dict ની અંદર એક માત્ર સામગ્રી બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો છે.
એક આદેશ કે તમે આદેશ વાક્ય પર હોય બિલાડી છે,
જે માત્ર છાપો શું ફાઈલમાં છે રહ્યું છે.
તેથી જ્યારે હું બિલાડી dict કહે, તે બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો, પ્રિન્ટ બનશે. કે તમામ બિલાડી કરે છે.
તેનો અર્થ એ છે કે તે બિલાડી, બિલાડી, કૂતરો, માછલી કૂતરો, બહાર પ્રમાણભૂત પર છપાતા.
જો હું તેના બદલે એક ફાઈલ કે પુનઃદિશામાન કરવા માંગો છો, હું> વાપરો અને તેને ગમે તે ફાઈલ છે પુનઃદિશામાન કરી શકો છો.
હું ફાઈલ ફાઈલ કહી શકશો.
તેથી હવે હું ls જો, હું જોશો હું એક નવી ફાઇલ તરીકે ઓળખાતી ફાઈલ હોય છે.
અને જો હું તેને ખોલવા ઉપર, તે છે બરાબર શું બિલાડી આદેશ વાક્ય પર મૂકી રહ્યું છે.
તેથી હવે જો હું કે ફરીથી કરવા માટે, પછી તે ફાઈલમાં આઉટપુટ પુનઃદિશામાન ચાલી રહ્યું છે,
અને હું જ ચોક્કસ વસ્તુ હોય જાઉં છું.
તેથી ટેકનિકલી, તે સંપૂર્ણપણે overrode આપણે શું હતા.
અને અમે જો હું dict બદલી જોશો, હું બહાર કૂતરો લીધો હતો.
હવે જો ફાઇલમાં અમે બિલાડી ફરીથી dict, અમે કૂતરો દૂર સાથે નવા આવૃત્તિ હોય રહ્યા છીએ.
તેથી તે સંપૂર્ણપણે તેને ફરીથી લખે છે.
તેની જગ્યાએ, જો આપણે >> વાપરવા માટે, તે ફાઈલ ઉમેરી રહ્યું છે.
હવે, ફાઈલ ખોલવા માટે, અમે જુઓ અમે માત્ર એ જ બે વાર મુદ્રણ વસ્તુ છે
કારણ કે તે ત્યાં એક વખત આવી હતી, તે પછી અમે મૂળ ઉમેરાવું જોઈએ.
તેથી કે શું> >> અને નથી.
શું આગામી એક પૂછો તે - તે વિશે પૂછશે નહિં.
>> અન્ય એક કે અમે હોય <છે, કે જે જો> ધોરણ બહાર અન્યત્ર છે,
<પ્રમાણભૂત પુનઃદિશામાન કરી સાઇન રહ્યું છે
ચાલો જોવા જો આપણે એક ઉદાહરણ છે.
હું એક વાસ્તવિક ઝડપી લખી શકો છો.
ચાલો કોઈપણ ફાઈલ, hello.c લો.
પ્રમાણમાં સરળ ફાઇલ.
હું માત્ર એક શબ્દમાળા મેળવવામાં છું અને પછી "હેલો" ગમે તે શબ્દમાળા હું હમણાં જ દાખલ કરેલ હતી છાપવા.
તેથી હેલ્લો અને પછી બનાવવા / હેલો..
હવે તે મને પૂછવાની છે કંઈક દાખલ કરો,
જેનો અર્થ છે કે તે વસ્તુઓ પર રાહ જોઈ છે સાઇન ધોરણ દાખલ કરવામાં
તેથી દાખલ ગમે હું ધોરણ કરવા માંગો છો સાઇન અમે માત્ર હેલો, રોબ કહે જઈ રહ્યાં છો!
પછી તેને હેલો બહાર પ્રમાણભૂત પર છાપવા છે, રોબ!
જો હું /. હેલ્લો અને પછી પુનઃદિશામાન કરવા માટે,
હવે તમે માત્ર એક ફાઇલ માંથી પુનઃદિશામાન કરી શકો છો.
તેથી જો હું અમુક ફાઈલ, txt મૂકવા, અને હું રોબ મૂકી,
જો હું હેલ્લો ચલાવો અને પછી માં ફાઈલ txt પુનઃદિશામાન કરે છે. / હેલ્લો, તે હેલો કહો, રોબ ચાલી રહ્યું છે! તરત જ.
જ્યારે તે પ્રથમ GetString મળે છે અને તે પ્રમાણભૂત પર રાહ જોઈ છે,
પ્રમાણભૂત લાંબા સમય સુધી દાખલ કરેલ મળશે માહિતી માટે કિબોર્ડ પર પ્રતીક્ષામાં છે.
તેના બદલે, અમે ધોરણ માટે ફાઈલ txt માંથી વાંચી માં પુનઃદિશામાન છે.
અને તેથી તે ફાઈલ txt, કે જે માત્ર રેખા રોબ છે વાંચી રહ્યું છે,
અને પછી તેને હેલો, રોબ છાપી રહ્યું છે!
અને જો હું ઇચ્છતો હતો, હું પણ નથી. / હેલ્લો txt <શકે
અને પછી તે પ્રમાણભૂત તે છાપકામ, કે જે હેલો છે રોબ!
હું તેની પોતાની ફાઇલમાં કે પુનઃદિશામાન કરી શકો છો.
હું માત્ર ફાઈલ કૉલ હેલ્લો કરીશું - ના, હું નથી, કારણ કે એ એક્ઝેક્યુટેબલ છે - txt2.
હવે, txt2 માટે /. હેલ્લો <txt, જે હેલો પ્રયત્ન રહ્યું છે રોબ નું આઉટપુટ હોય રહ્યું છે!
>> પ્રશ્નો?
>> ઠીક છે. તેથી તે પછી અહીં અમે પાઇપલાઇન છે.
પાઇપ્સ પુનર્નિર્દેશન ના છેલ્લા એકમ છે.
>> ઓહ. હું માનું એક પુનર્નિર્દેશન વધુ એકમ બદલે જો> તમે 2 કરવું>
કે પ્રમાણભૂત ભૂલ પુનઃદિશામાન છે.
તેથી જો કશુંક પ્રમાણભૂત ભૂલ ગયા, તે txt2 માં મળશે મૂકી શકે છે.
પરંતુ નોટિસ જો હું 2> નહિં, તો તે હજી પણ હેલો છાપવા છે, રોબ! આદેશ વાક્ય
કારણ કે હું માત્ર ધોરણ ભૂલ પુનઃદિશામાન છું, હું માનક નથી પુનઃદિશામાન બહાર છું.
સ્ટાન્ડર્ડ ભૂલ અને પ્રમાણભૂત બહાર અલગ અલગ છે.
જો તમે ખરેખર પ્રમાણભૂત ભૂલ લખવા માગતા હતા,
પછી હું આ બદલવા માટે stderr માટે fprintf હોઈ શકે છે.
તેથી printf, મૂળભૂત રીતે, પ્રમાણભૂત આઉટ છાપે છે.
જો હું પ્રમાણભૂત ભૂલ જાતે છાપો કરવા માંગો છો, તો પછી હું fprintf ઉપયોગ કરે છે
સ્પષ્ટ અને હું શું છાપવાનો કરવા માંગો છો.
જો બદલે હું fprintf stdout પર હતી, પછી તે મૂળભૂત રીતે printf માટે સમકક્ષ છે.
પરંતુ fprintf પ્રમાણભૂત ભૂલ છે.
તેથી હવે જો હું txt2 આ પુનઃદિશામાન થયેલ છે, હેલો, રોબ! હજુ પણ આદેશ વાક્ય પર મુદ્રિત રહ્યું
કારણ કે તે પ્રમાણભૂત ભૂલ રહ્યું મુદ્રિત છે અને હું માત્ર ધોરણ પુનઃદિશામાન છું બહાર.
જો હું હવે પ્રમાણભૂત ભૂલ પુનઃદિશામાન થયેલ છે, હવે તે મળશે છપાતા નહોતી અને txt2 માટે હેલો પ્રયત્ન, રોબ રહ્યું છે!
તેથી હવે તમે તમારી વાસ્તવિક ભૂલો પ્રમાણભૂત ભૂલ છાપી શકો છો
અને પ્રમાણભૂત બહાર તમારી નિયમિત સંદેશાઓ છાપો.
અને તેથી જ્યારે તમે તમારા કાર્યક્રમ ચલાવો, તો તમે તેને તરીકે ચલાવવા / શકે છે. હેલ્લો 2 સાથે આ પ્રકારની>
જેથી તમારા કાર્યક્રમ સામાન્ય રીતે ચલાવવા રહ્યું છે,
પરંતુ કોઈ પણ ભૂલ સંદેશાઓ કે જે તમને વિચાર પછીથી તમારી ભૂલ લોગ ચેક કરી શકો છો,
ભૂલો છે, અને તેથી તે પછી પાછળથી દેખાય અને તમારી ભૂલો ફાઈલ કોઈપણ ભૂલો થયું હશે.
>> પ્રશ્નો?
>> છેલ્લા એક પાઇપ, કે જે તમે પ્રમાણભૂત એક આદેશ બહાર લઈ તરીકે લાગે શકે છે
અને તે આગામી આદેશ માં પ્રમાણભૂત બનાવે છે.
અહીં એક ઉદાહરણ પડઘો આદેશ વાક્ય વસ્તુ છે
કે માત્ર પડઘો ગમે હું તેની દલીલ તરીકે મૂકવામાં રહ્યું છે. હું અવતરણ મૂકી નથી શકતા.
ઇકો મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત માત્ર, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત છાપી રહ્યું છે.
પહેલાં, જ્યારે હું જણાવ્યું હતું કે હું એક txt ફાઇલમાં રોબ મૂકી હતી
કારણ કે હું માત્ર txt ફાઈલો પુનઃદિશામાન કરી શકો છો, તેના બદલે, I / રોબ પડઘો જો
અને પછી પાઇપ તેને ધ્યાનમાં / હેલ્લો, કે જે પણ વસ્તુ એક જ પ્રકારનો કરશે..
આ આદેશનું આઉટપુટ, ઇકો રોબ લઈ રહ્યું છે,
અને તે માટે ઇનપુટ તરીકે ઉપયોગ કરીને /. હેલો.
તમે તેને લાગે તરીકે પ્રથમ ફાઇલમાં પડઘો રોબ પુનઃદિશામાન કરી શકો છો
અને પછી /. હેલ્લો કે ફાઇલમાં ઇનપુટ કે જે હમણાં જ outputted હતી.
પરંતુ તે ચિત્ર ના કામચલાઉ ફાઈલ બહાર લઈ જશે.
>> પર પ્રશ્નો?
>> આગામી પ્રશ્ન આ સમાવેશ થાય રહ્યું છે.
પાઇપલાઇન શું તમે names.txt કહેવાય ફાઈલમાં અનન્ય નામો સંખ્યા શોધવા ઉપયોગ કરી શકે છે?
આદેશો અમે અહીં ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો અનન્ય છે, તેથી uniq અને પછી WC છે.
તમે માણસ uniq કરવું ખરેખર છે કે શું કરે જોવા કરી શકો છો,
અને તે માત્ર ઈનપુટમાંથી અડીને બંધબેસતા લીટીઓ ફિલ્ટર બનશે.
અને માણસ WC માટે NEWLINE, શબ્દ, અને દરેક ફાઈલ માટે બાઈટ ગણતરી છાપી રહ્યું છે.
અને છેલ્લા એક અમે ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો જેવું છે,
જે માત્ર txt ફાઈલ રેખાઓ સૉર્ટ રહ્યું છે.
જો હું કેટલાક txt ફાઇલ, names.txt બનાવવા અને તેને રોબ, ટોમી, જોસેફ, ટોમી, જોસેફ, આરજે, રોબ છે,
હું અહીં શું કરવા માંગો છો છે અને આ ફાઈલમાં અનન્ય નામો સંખ્યા શોધો.
તેથી જવાબ શું હોવું જોઈએ? >> [વિદ્યાર્થી] 4. >> યાહ.
તે 4, રોબ ટોમી, જોસેફ થી હોવુ જોઇએ, આરજે આ ફાઇલ એક માત્ર અનન્ય નામો છે.
પ્રથમ પગલું, જો હું માત્ર names.txt પર શબ્દ ગણતરી કરવા માટે,
આ ખરેખર મને બધું કહેવાની છે.
આ વાસ્તવમાં છે પ્રિન્ટીંગ - દો છે, જુઓ માણસ WC - newlines, શબ્દો, અને બાઈટ ગણતરી.
જો હું માત્ર લીટીઓ વિશે ચિંતિત હોય, તો પછી હું ફક્ત WC-l names.txt કરી શકો છો.
જેથી પગલાં 1 છે.
પરંતુ હું WC-l names.txt ન માંગતા કારણ કે names.txt ફક્ત તમામ નામો સમાવે નહિં,
અને હું બહાર કોઈપણ બિન અનન્ય મુદ્દાઓ ફિલ્ટર કરવા માંગો છો.
તેથી જો હું uniq names.txt કરવા માટે, કે તે તદ્દન મને આપતું નથી હું શું કરવા માંગો છો
કારણ કે ડુપ્લિકેટ નામો હજુ પણ ત્યાં હોય છે.
કે શા માટે છે? Uniq શા માટે કરી રહ્યા છે હું શું કરવા માંગો છો?
[વિદ્યાર્થી] છે આ ડુપ્લિકેટ્સ [અશ્રાવ્ય] >> યાહ.
Uniq માટે મદદ પાનું યાદ રાખો ફિલ્ટર અડીને મેચિંગ રેખાઓ કહે છે.
તેઓ અડીને નથી તેથી તે તેમને ફિલ્ટર કરશે.
જો હું તેમને પ્રથમ, સૉર્ટ સૉર્ટ names.txt બધી નકલી રેખાઓ સાથે મળીને રાખવામાં રહ્યું છે.
તેથી હવે સૉર્ટ names.txt હોય છે.
Uniq | હું uniq છે, જે છે ઇનપુટ તરીકે ઉપયોગ કરવા માંગો છો કે જાઉં છું.
કે મને જોસેફ, આરજે, રોબ, ટોમી આપે છે,
અને હું WC-l માટે ઇનપુટ તરીકે ઉપયોગ કરવા માંગો છો કે,
જેના માટે માટે મારે 4 આપી રહ્યું છે.
જેમ તે અહીં કહે છે, પાઇપલાઇન શું તમે ઉપયોગ કરી શકો?
તમને આદેશો શ્રેણીબદ્ધ મદદથી જેવી વસ્તુઓ ઘણો કરી શકો છો
જ્યાં તમે એક આદેશ ના આગામી આદેશ ઇનપુટ તરીકે આઉટપુટ વાપરો.
તમે વસ્તુઓ, હોંશિયાર વસ્તુઓ કરી શકે છે.
>> પ્રશ્નો?
ઠીક છે.
કે તે પાઇપ અને રીડાયરેક્શન નથી માટે છે.
>> હવે અમે વાસ્તવિક સામગ્રી છે, કોડિંગ સામગ્રી પર જાઓ.
આ PDF ની અંદર, તમે આ આદેશ જોશો,
અને તમે તમારા ઉપકરણ માં આ આદેશ ચલાવવા માંગો પડશે.
માત્ર ઇન્ટરનેટ માંથી કંઈક મેળવવા માટે wget આદેશ છે મૂળભૂત રીતે,
જેથી wget અને આ URL.
જો તમે તમારા બ્રાઉઝરમાં આ URL માટે ગયા, તે ફાઇલ ડાઉનલોડ થશે.
હું માત્ર તેના પર ક્લિક કર્યું છે, તેથી તેને મને માટે ફાઈલ ડાઉનલોડ કરી છે.
પરંતુ ટર્મિનલ ની અંદર કે વસ્તુને wget લેખન
છે ફક્ત તેને તમારા ટર્મિનલ માં ડાઉનલોડ થઈ રહ્યું છે.
હું section5.zip હોય, અને તમે section5.zip ઝિપસાંકળ છોડવી માંગો છો પડશે,
જે તમને section5 કહેવાય ફોલ્ડર આપી રહ્યું છે,
જે ફાઇલો અમે આજે ની અંદર ઉપયોગ કરી રહ્યા છીએ બધી રહ્યું છે.
જેમ આ કાર્યક્રમો ફાઈલ નામોનું સૂચન, તેઓ થોડી બગડેલ કરશો,
તેથી તમારા મિશન માટે બહાર આકૃતિ શા માટે gdb ઉપયોગ કરે છે.
નથી દરેકને તેમને / ડાઉનલોડ કરેલ હોય તો ખબર કેવી રીતે તેમને ડાઉનલોડ
તેમના સાધન માં? ઠીક છે.
>> ./buggy1 ચલાવી રહ્યા હોય, તે વિભાગીય દોષ (કોર ડમ્પ) કહેવું પડશે,
જે કોઇ પણ સમયે segfault વિચાર, તે ખરાબ બાબત છે.
સંજોગો શું હેઠળ તમે segfault વિચાર છે?
[વિદ્યાર્થી] એક નલ નિર્દેશક Dereferencing. >> યાહ. જેથી એક ઉદાહરણ છે.
એક નલ નિર્દેશક તમે segfault વિચાર જઈ રહ્યાં છો Dereferencing.
એક શું અર્થ segfault છે તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ નથી.
તેથી નલ નિર્દેશક dereferencing 0 સરનામા સ્પર્શ છે,
અને મૂળભૂત, બધા કમ્પ્યુટર્સ હવે કહે છે કે સરનામા 0 મેમરી તમે સ્પર્શ જોઇએ નહિં છે.
તેથી કે કેમ segfault માં નલ નિર્દેશક પરિણામો dereferencing.
જ્યારે તમે એક નિર્દેશક પ્રારંભ ન થાય, તો પછી તે કચરો કિંમત ધરાવે છે,
અને તેથી જ્યારે તમે ડિરેફરન્સ પ્રયત્ન તે તમામ શક્યતા તમે મેમરી સ્પર્શ કરી રહ્યાં છો
કે ક્યાંય મધ્યમાં છે.
જો તમે નસીબદાર અને કચરો કિંમત વિચાર થાય છે
માટે સ્ટેક અથવા કંઈક પર બીજે નિર્દેશ થયો,
પછી તમે ડિરેફરન્સ કે નિર્દેશક જે તમે નથી આરંભ કરે છે,
કશું ખોટું જશે.
પરંતુ જો તે પોઇન્ટ છે, કહે છે, સ્ટેક અને ઢગલો વચ્ચે ક્યાંક,
અથવા તે માત્ર ક્યાંક છે કે જે તમારા કાર્યક્રમ દ્વારા આવી નથી ઉપયોગ કરવામાં હજુ સુધી પોઇન્ટ છે,
પછી તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ જોઇએ નહિં અને તમે segfault.
જ્યારે તમે ફરી યાદ આવવું કાર્ય લખી અને તેને ઘણી વાર recurses
અને તમારા સ્ટેક વસ્તુઓ માં ખૂબ મોટી અને સ્ટેક અથડામણ ઊગે
કે તે સાથે અથડાઈ જોઈએ, તમે મેમરી સ્પર્શ કરી રહ્યાં છો તમે સ્પર્શ જોઇએ નહિં,
જેથી તમે segfault.
એટલે કે segfault એક શું છે.
>> તે પણ આ જ કારણ છે કે તમે જેવા શબ્દમાળા હોય તો -
ચાલો અગાઉના કાર્યક્રમ પર પાછા જાઓ.
માં hello.c-I'm માત્ર કંઈક બીજું બનાવવા જઈ રહી છે.
ઘરનાં પરચૂરણ કામો * ઓ = "વિશ્વ હેલો!";
; જો હું * ઓ = કંઈક અથવા ઓ [0] = 'એક્સ' 'નો ઉપયોગ
જેથી બનાવવા હેલ્લો /. હેલ્લો, કેમ કે segfault હતી?
આ કેમ segfault હતી?
તમે શું અપેક્શા શું થશે?
જો હું printf હતી ("% s \ n" ઓ); તમે શું છપાશે અપેક્ષા છે?
[વિદ્યાર્થી] અને એક્સ હેલો. >> યાહ.
સમસ્યા એ છે કે જ્યારે તમે આ જેવી શબ્દમાળા જાહેર,
ઓ એક નિર્દેશક કે જે સ્ટેક પર જાઓ રહ્યું છે છે,
અને ઓ માટે પોઇન્ટ છે શું આ શબ્દમાળાને જે રીડ ઓન્લી મેમરી માં સમાયેલ છે.
તેથી જ, નામ, મેમરી માત્ર વાંચી દ્વારા, તમે વિચાર વિચાર કરીશું
કે જો તમે બદલવા શું રીડ ઓન્લી મેમરી માં છે પ્રયાસ કરો,
તમે કંઈક તમે મેમરી સાથે ન કરી કરીશું કરી રહ્યા છીએ અને તમે segfault.
આ વાસ્તવમાં ઘરનાં પરચૂરણ કામો * ઓ અને કોલસો બનાવો] [ઓ વચ્ચે મોટો તફાવત છે.
તેથી ઓ ઘરનાં પરચૂરણ કામો] [, હવે આ શબ્દમાળાને સ્ટેક પર મૂકી શકાય રહ્યું છે,
અને સ્ટેક ફક્ત વાંચવા માટે નથી, કે જેનો અર્થ એ છે કે આ સંપૂર્ણપણે દંડ કામ કરીશું.
અને તે કરે છે.
યાદ રાખો કે જ્યારે હું ઘરનાં પરચૂરણ કામો કરવા * ઓ = "હેલ્લો! વર્લ્ડ", પોતાને ઓ સ્ટેક પર છે
પરંતુ બીજે ક્યાંક ને પોઇન્ટ, અને તે બીજે ક્યાંય માટે ફક્ત વાંચવા માટે બને છે.
પરંતુ ઘરનાં પરચૂરણ કામો] [ઓ માત્ર સ્ટેક પર કંઈક છે.
જેથી segfault થઈ રહ્યું અન્ય ઉદાહરણ છે.
>> અમે જોયું છે કે ./buggy1 એક segfault માં પરિણમેલ છે.
સિદ્ધાંત, તમે buggy1.c અંતે તુરંત જ નથી હવો જોઈએ.
તેના બદલે, અમે તેના પર gdb મારફતે જોવા મળશે.
કે નોટિસ જ્યારે તમે સેગ્મેન્ટેશન ક્ષતિમાં (કોર ડમ્પ) વિચાર,
તમે અહીં કહેવાય કોર પર આ ફાઈલ મેળવો.
અમે ls-l જો, અમે જોશો કે કોર સામાન્ય રીતે ખૂબ મોટી ફાઈલ છે.
આ ફાઇલ બાઇટ્સ સંખ્યા છે, તેથી તેને લાગે છે કે તે 250 કંઈક કિલોબાઈટોમાં છે.
આ માટેનું કારણ એ છે કે કોર ડમ્પ ખરેખર શું છે
છે જ્યારે તમારું કાર્યક્રમ અકસ્માત, તમારા કાર્યક્રમ મેમરી સ્થિતિ
માત્ર નકલ અને નહીં આ ફાઇલમાં પેસ્ટ કર્યું.
તે ફાઈલમાં ડમ્પ નહીં.
આ કાર્યક્રમ, જ્યારે તે ચાલી રહ્યું હતું, માટે 250 આસપાસ રહેલ એક મેમરી વપરાશ હોય થયું,
અને જેથી શું આ ફાઈલમાં ડમ્પ મળ્યો છે.
હવે તમે તે ફાઈલ પર નજર જો આપણે gdb buggy1 કોર કરી શકો છો.
અમે હમણાં જ buggy1 gdb કરી શકે છે, અને કે જે હમણાં જ અપ gdb શરૂ કરશે નિયમિત,
તેની ઇનપુટ ફાઇલ તરીકે buggy1 મદદથી.
પરંતુ જો તમે gdb buggy1 કોર કરવું, પછી તે ખાસ કરીને અપ gdb શરૂ થઈ રહ્યું છે તે
કે કોર ફાઈલ જોઈ છે.
અને તમે buggy1 અર્થ gdb કહેતા જાણે કે જે કોર ફાઈલ buggy1 કાર્યક્રમ આવે છે.
તેથી gdb buggy1 કોર તરત જ આપણને લાવી રહ્યું છે
જ્યાં કાર્યક્રમ સમાપ્ત થયું છે.
અમે અહીં જોવા કાર્યક્રમ 11 સિગ્નલ, વિભાગીય ખામી સાથે સમાપ્ત.
અમે એસેમ્બલી, જે સંભવતઃ ખૂબ જ ઉપયોગી નથી એક વાક્ય જુઓ થાય છે.
પરંતુ જો તમે BT અથવા બેકસ્ટ્રેસ લખો કે જે કાર્ય જ હશે
કે અમારા વર્તમાન સ્ટેક ફ્રેમ્સ યાદી આપે છે.
તેથી બેકસ્ટ્રેસ. એવું લાગે છે કે અમે માત્ર બે સ્ટેક ફ્રેમ્સ છે.
પ્રથમ અમારી મુખ્ય સ્ટેક ફ્રેમ હોય છે,
અને બીજા આ કાર્ય કે અમે હોવા થાય માટેના સ્ટેક ફ્રેમ હોય છે,
જે લાગે છે કે અમે માત્ર માટે વિધાનસભા કોડ છે.
તેથી આપણે આપણા મુખ્ય કાર્ય માં પાછા જાઓ,
અને કરવા કે અમે 1 ફ્રેમ કરી શકો છો, અને મને લાગે છે કે અમે પણ નીચે કરી શકો છો,
પરંતુ હું લગભગ આવું ક્યારેય નીચે - અપ અથવા. યાહ.
ઉપર અને નીચે. તમને લાવે એક સ્ટેક ફ્રેમ, નીચે તમે લાવે નીચે સ્ટેક ફ્રેમ.
હું ક્યારેય ઉપયોગ કરે છે.
મેં હમણાં જ ખાસ 1 ફ્રેમ, કે જે 1 લેબલ થયેલ ફ્રેમ પર જવા માટે છે કહો.
1 ફ્રેમ અમને લાવવા મુખ્ય સ્ટેક ફ્રેમ માં રહ્યું છે,
અને તે અહીં કોડ લીટી અમે હોવા થાય છે.
જો આપણે કોડ થોડા વધુ લીટીઓ માગતા હતા, અમે યાદી કહેવું કરી શકો છો,
અને તે અમને તેની આસપાસ તમામ કોડ લીટીઓ આપી રહ્યું છે.
આ વાક્ય આપણે અંતે segfaulted 6 હતું:
જો (strcmp ("CS50 ખડકો", argv [1]) == 0).
જો તે સ્પષ્ટ નથી, તો તમે તેને કોઈ રન નોંધાયો નહીં વિચારી તે શા માટે segfaulted દ્વારા માત્ર કરી શકો છો અહીં છે.
પરંતુ અમે તે એક પગલું આગળ લે છે અને કહે છે શકો છો, "શા માટે argv [1] segfault છો?"
લેટ્સ પ્રિન્ટ argv [1], અને તે તેના 0x0 છે, કે જે નલ નિર્દેશક છે જેવો દેખાય છે.
અમે CS50 ખડકો અને નલ strcmping છીએ, અને તેથી કે જે segfault બનશે.
અને શા માટે છે argv [1] નલ?
[વિદ્યાર્થી] કારણ કે અમે તેને કોઈપણ આદેશ વાક્ય દલીલો આપી ન હતી.
યાહ. અમે તેને કોઈપણ આદેશ વાક્ય દલીલો આપી ન હતી.
તેથી ./buggy1 માત્ર હોય argv [0] ./buggy1 પ્રયત્ન રહ્યું છે.
તે એક argv [1] નથી ચાલી રહ્યું છે, આથી તે માટે segfault બનશે.
પરંતુ જો, તેની બદલે, મેં હમણાં જ CS50 કરવા માટે, તે કહે તમે ડી બનશે
કારણ કે તે શું છે તે કરવા માટે માનવામાં આવે છે.
Buggy1.c અંતે છીએ, તે છાપી તેવું માનવામાં આવે છે "તમે ડી વિચાર" -
જો argv [1] "CS50 ખડકો" નહિં હોય, "તમે ડી વિચાર", બીજું "તમે એક વિચાર!"
તેથી જો અમે એ માંગો છો, અમે આ કરવાની જરૂર સાચું તરીકે સરખાવવા માટે,
જેનો અર્થ છે કે 0 થી તેને સરખાવે છે.
તેથી argv [1] "CS50 ખડકો" જરૂરી છે.
જો તમે આદેશ વાક્ય પર કરવા માંગો છો, તો તમે \ વાપરવા માટે જગ્યા છટકી જરૂર છે.
તેથી CS50 \ ખડકો અને તમે એક એક વિચાર!
જો તમે બેકસ્લેશ નથી, આ શા માટે કામ નથી?
[વિદ્યાર્થી] આ બે અલગ અલગ દલીલો છે. >> યાહ.
Argv [1] CS50 પ્રયત્ન રહ્યું છે, અને argv [2] ખડકો પ્રયત્ન રહ્યું છે. ઠીક છે.
>> હવે ./buggy2 ફરીથી segfault રહ્યું છે.
તેના બદલે તે તેના કોર ફાઈલ સાથે ખોલ્યા છે, અમે હમણાં buggy2 સીધી ખોલવા પડશે,
buggy2 gdb જેથી.
હવે જો આપણે માત્ર અમારા કાર્યક્રમ ચલાવો, તો પછી તે કહેવું કાર્યક્રમ સંકેત SIGSEGV પ્રાપ્ત ચાલી રહ્યું છે,
કે જે સંકેત segfault, અને આ છે જ્યાં તે થાય થયું.
અમારા બેકસ્ટ્રેસ અંતે છીએ, અમે જુઓ કે અમે કાર્ય oh_no હતા,
જે કાર્ય નમણું, કે જે કાર્ય binky દ્વારા બોલાવવામાં આવ્યો દ્વારા બોલાવવામાં આવ્યા,
જે મુખ્ય દ્વારા કહેવામાં આવતું હતું.
અમે પણ આ વિધેયોને માટે દલીલો જોઈ શકો છો.
સુઘડ અને binky માટે દલીલ 1 હતી.
જો અમે કાર્ય oh_no યાદી, અમે જુઓ કે oh_no માત્ર કોલસો બનાવો ** ઓ = NULL કરી છે;
* ઓ = "તેજી";
કે શા માટે નિષ્ફળ જશે?
[વિદ્યાર્થી] તમે NULL નિર્દેશક ખોટો સંદર્ભ નથી કરી શકતાં? >> યાહ.
આ માત્ર કહી રહ્યાં છે ઓ NULL છે, અનુલક્ષીને જો કે ચાર રચે છે ** બને છે,
, જે તમે કેવી રીતે તે અર્થઘટન પર આધાર રાખીને, તે શબ્દમાળા માટે નિર્દેશક માટે નિર્દેશક હોઈ શકે છે
અથવા શબ્દમાળાઓ પણ દર્શાવે છે.
તે ઓ NULL છે, તેથી * ઓ એક નલ નિર્દેશક dereferencing છે,
અને તેથી આ માટે તૂટી રહ્યું છે.
આ એક ઝડપી માર્ગ તમે કદાચ segfault શકે છે.
તે માત્ર એક નલ નિર્દેશક જાહેર કરવામાં આવ્યું છે અને તરત જ segfaulting.
કે oh_no શું કરી છે.
જો આપણે એક ફ્રેમ જાઓ, અને પછી અમે એ વિધેય કે oh_no કહેવાય પ્રવેશ મેળવવા જઈ રહ્યાં છો.
હું નીચે કરવાની જરૂર છે.
જો તમે આદેશ દાખલ કરો અને તમે માત્ર લિમિટેડ ફરીથી દબાવો,
તે માત્ર અગાઉના આદેશ કે જે તમે ચાલી હતી પુનરાવર્તન થશે.
અમે 1 ફ્રેમ હોય છે.
આ ફ્રેમ યાદી, અમે જોવા માટે અહીં અમારી કાર્ય છે.
તમે યાદી ફરીથી ફટકો કરી શકો છો, અથવા તમે 20 યાદી કરી શકો છો અને તેને વધુ યાદી આપશે.
કાર્ય સુઘડ કહે છે જો હું 1 હોય, તો પછી oh_no કાર્ય પર જાઓ,
બીજું એ slinky કાર્ય પર જાઓ.
અને અમે જાણીએ છીએ કે હું 1 છે કારણ કે અમે અહીં જુઓ થવું
કે સુરેખ એ 1 દલીલ સાથે કહેવામાં આવતું હતું.
અથવા તમે માત્ર હું છાપી શકો છો અને તે કહે છે કે હું 1 છે.
અમે સોહામણું વર્તમાનમાં છે, અને જો આપણે બીજા ફ્રેમ જાઓ, અમે જાણીએ છીએ કે અમે અપ binky માં સમાપ્ત કરીશું.
ઉપર. હવે અમે binky છો.
પહેલા અડધા મને કટ ના યાદી - આ કાર્ય યાદી -
આ બોલ પર શરૂ જો હું 0 છે, તો પછી અમે તેને oh_no કૉલ જઈ રહ્યાં છો, તે અન્ય આકર્ષક ફોન કરો.
અમે જાણીએ છીએ હું 1 હતી, તેથી તેને સોહામણું કહેવાય છે.
અને હવે અમે મુખ્ય માં પાછા આવ્યા, અને મુખ્ય માત્ર પૂર્ણાંક હું = રેન્ડ (3)% પ્રયત્ન રહ્યું છે;
કે જે હમણાં જ તમને રેન્ડમ નંબર છે કે જે 0 ક્યાં, 1, અથવા 2 છે આપી રહ્યું છે.
તે જે નંબર સાથે binky કહી રહ્યું છે, અને તે 0 આપશે.
આ અંતે છીએ,
ફક્ત કાર્યક્રમ દ્વારા જાતે વૉકિંગ તે તુરંત જ ચાલુ કર્યા વગર,
તમે મુખ્ય અંતે વિરામ બિંદુ સુયોજિત હો, જેનો અર્થ છે કે જ્યારે અમે કાર્યક્રમ ચલાવો
તમારા કાર્યક્રમ અપ સ્કોર સુધી તે બ્રેક પોઇન્ટ બનાવ્યા.
આ કાર્યક્રમ ચાલી રહ્યો છે, કે જેથી તેને ચલાવવા માટે અને પછી તે મુખ્ય કાર્ય ફટકો અને ચાલી અટકાવવા કરશે.
હવે અમે મુખ્ય અંદર કરશો, અને પગલું અથવા આગામી અમને કોડ આગળના વાક્ય લાવી રહ્યું છે.
તમે પગલું અથવા આગામી કરી શકો છો.
આગામી હિટિંગ, હવે હું રેન્ડ (3)% છે, તેથી અમે i ની કિંમત છાપી શકો છો પર સેટ છે,
અને તે કહે છે કે હું 1 છે.
હવે તે બાબત શું આપણે આગામી અથવા પગલું ઉપયોગ કરે છે.
હું માનું તેને પહેલાંના એક mattered, પણ અમે આગામી ઉપયોગ કરવા માંગો છો કરશે.
જો અમે પગલું વાપરવા માટે, અમે કાર્ય સ્ટેપ ઇનટુ છે, કે જે વાસ્તવિક વસ્તુ અંતે દેખાવ અર્થ થાય છે
કે binky ની અંદર ચાલી રહ્યું છે.
જો અમે આગામી વાપરવા માટે, પછી એનો અર્થ પર કાર્ય જાઓ
અને અમારા મુખ્ય કામગીરીમાં કોડ આગળના વાક્ય પર જાઓ.
અહીં આ વાક્ય પર, હું જ્યાં તે (રેન્ડ) 3% એ જણાવ્યું હતું;
જો હું પગલું હતું ત્યારે તે રેન્ડ અમલીકરણ માં જશે
અને શું ત્યાં ચાલી રહ્યું છે તે જોવા માટે, અને હું રેન્ડ કાર્ય મારફતે પગલું શકે છે.
પરંતુ હું રેન્ડ કાર્ય વિશે કાળજી નથી.
હું માત્ર મુખ્ય માં કોડ આગળના વાક્ય પર જાઓ કરવા માંગો છો, જેથી હું આગામી વાપરો.
પરંતુ હવે હું binky કાર્ય વિશે કાળજી કરવા માટે, જેથી હું સ્ટેપ ઇનટુ કરવા માંગો છો.
હવે હું binky છું.
કોડ પ્રથમ વાક્ય કહી જો (i 0 ==), હું એક પગલું લઈ રહ્યું છે,
અમે જુઓ અમે સોહામણું અંતે અંત.
જો અમે યાદી વસ્તુઓ, અમે જુઓ કે તે ચકાસાયેલ મને છે = 0.
મને 0 સમાન નથી, તેથી તે બીજા શરત ગયા,
જે સુરેખ (i) કૉલ રહ્યું છે.
તમે ગુંચવણ ના થવી શકે છે.
જો તમે માત્ર આ રેખાઓ સીધી જુઓ, તમને લાગે શકે છે જો (i 0 ==),
ઠીક, પછી હું પગલું ભર્યું હતું અને હવે હું સુરેખ (i) ખાતે છું,
તમને લાગે છે કે તેનો અર્થ જ જોઈએ હું = 0 અથવા કંઈક.
નંબર તે માત્ર અર્થ એ થાય કે તે જાણે છે કે તે સીધેસીધું લીટી સુરેખ (i) વળગી શકે છે.
કારણ કે હું 0 નહિં હોય, તો આગળનું પગલું એ બીજું અંતે અંત નથી જઈ રહ્યા છે.
બાકી એક વાક્ય તેને અંતે રોકવા રહ્યું છે નથી.
તે માત્ર આગલા લીટી તે વાસ્તવમાં ચલાવો, કે જે સુઘડ છે (i) કરી શકો છો પર જાઓ બનશે.
સુરેખ (i) માં વેગ, અમે જોવા (i 1 ==).
અમે હું = 1 જાણતા નથી, તેથી અમે જ્યારે પગલું, અમે જાણીએ છીએ કે અમે માટે oh_no માં અંત જઈ રહ્યાં છો
કારણ કે હું = 1 કામગીરી oh_no, કે જે તમને સ્ટેપ ઇનટુ કરી શકો છો કહે છે,
જે સેટ થઈ રહ્યું છે ઘરનાં પરચૂરણ કામો ** ઓ = માટે NULL છે અને તરત જ "બૂમ".
અને પછી ખરેખર buggy2 અમલીકરણ પર looking,
0, 1, અથવા 2 - - કૉલિંગ binky, આ, હું માત્ર એક રેન્ડમ નંબર રહ્યો છે
જે જો હું 0 છે તે oh_no કહે છે, બીજું તે સુઘડ કહે છે, જે અહીં આવે છે.
જો હું એ 1, કોલ oh_no, બીજું slinky કહી છે, કે જે અહીં આવતા,
જો હું 2 છે, oh_no કૉલ કરો.
હું પણ ત્યાં એક માર્ગ છે લાગતું નથી -
શું કોઇને એક કાર્યક્રમ છે કે જે નથી segfault કરશે આ બનાવવા એક માર્ગ જુઓ છો?
કારણ કે જ્યાં સુધી હું કંઈક ખૂટે છું, જો હું 0 છે, તમને તુરંત જ segfault પડશે,
બીજું તમે એક કાર્ય છે, જે જો હું એ 1 તમે segfault પર જાઓ,
બીજું તમે એક કાર્ય જ્યાં જો હું છે 2 તમે segfault પર જાઓ.
તેથી કોઇ વાંધો નથી કે તમે શું કરો છો, તમે segfault.
>> હું સુધારવા તે ચાર રચે છે ** ઓ = NULL કરી બદલે હોય એક માર્ગ, અનુમાન
તમે કે જેઓ શબ્દમાળા માટે જગ્યા malloc શકે છે.
Sizeof શું - અમે (sizeof) malloc કરી શકે?
[વિદ્યાર્થી] (કોલસો) 5 *? >> આ અધિકાર લાગતું નથી?
હું એમ ધારી રહ્યા છીએ છું આ તો હું ખરેખર તે ચાલી હતી કામ કરશે, પરંતુ તે હું શું શોધી રહ્યો છું નથી.
ઓ ના પ્રકાર જુઓ. ચાલો પૂર્ણાંક * ઉમેરો, જેથી પૂર્ણાંક * એક્સ.
હું malloc કરવું (sizeof (પૂર્ણાંક)) કરશે.
અથવા જો હું 5 ઝાકઝમાળ માગતા હતા, હું ((પૂર્ણાંક) sizeof 5 *) કરી શકે છે;
જો હું પૂર્ણાંક ** છે?
હું શું થશે malloc?
[વિદ્યાર્થી] પોઇન્ટર કદ. >> યાહ. (Sizeof (પૂર્ણાંક *));
નીચે અહીં જ વાત.
હું માંગો છો (sizeof (કોલસો) *);
આ નિર્દેશક કે "તેજી" નિર્દેશ માટે જગ્યા ફાળવી રહ્યું છે.
હું "બૂમ" પોતાના માટે જગ્યા ફાળવી જરૂર નથી
કારણ કે આ મૂળભૂત હું શું પહેલાં જણાવ્યું હતું કે સમકક્ષ છે
ઘરનાં પરચૂરણ કામો ઓફ * x = "તેજી".
"બૂમ" પહેલાથી જ અસ્તિત્વમાં છે. તે મેમરી વિસ્તારમાં માત્ર વાંચી અસ્તિત્વ બને છે.
પરંતુ તે પહેલેથી જ અસ્તિત્વમાં છે, કે જે કોડ આ વાક્ય અર્થ થાય છે, જો ઓ ચાર રચે છે ** છે,
પછી * ઓ ચાર રચે છે * છે અને તમે આ ઘરનાં પરચૂરણ કામો * સુયોજિત કરી રહ્યા છીએ "બૂમ" નિર્દેશિત કરવા માટે.
જો હું ઓ માં "બૂમ" નકલ કરવા માગે છે, તો પછી હું ઓ માટે જગ્યા ફાળવી જરૂર છે.
હું કરીશ * ઓ malloc = (sizeof (કોલસો) 5 *);
શા 5?
શા માટે 4 નથી? એવું લાગે છે કે "બૂમ" 4 અક્ષરો છે. >> [વિદ્યાર્થી] આ નલ પાત્ર.
યાહ. તમારા શબ્દમાળાઓ માટે તમામ નલ અક્ષર જરૂર જવું છે.
હવે હું strcat કંઈક કરી શકો છો - એક શબ્દમાળા નકલ માટે કાર્ય શું છે?
[વિદ્યાર્થી] cpy? >> Strcpy.
માણસ strcpy.
તેથી strcpy અથવા strncpy.
strncpy થોડી સુરક્ષિત છે કારણ કે તમે સ્પષ્ટ કરી શકો છો ચોક્કસ કેટલી અક્ષરો,
પરંતુ અહીં તેને કારણે આપણે જાણીએ છીએ તો કોઈ વાંધો નથી.
તેથી strcpy અને દલીલો માં જુઓ.
પ્રથમ દલીલ અમારા સ્થળ છે.
બીજી દલીલ અમારા સ્ત્રોત છે.
અમે અમારી ગંતવ્ય * કૉપિ જઈ રહ્યાં છો તે નિર્દેશક "બૂમ" ઓ.
તમે માત્ર શું આપણે બદલે strcpy સાથે આ પહેલા શા શકો છો
* s ની = "તેજી?"
ત્યાં એક કારણ તમે આ કરવા માંગો છો શકે છે, પરંતુ તે કારણ શું છે?
[વિદ્યાર્થી] જો તમે "તેજી" માં કંઈક ફેરફાર કરવા માંગો છો. >> યાહ.
હવે હું ઓ કંઈક કરી શકે છે [0] = 'એક્સ' ';
કારણ કે ઓ પોઇન્ટ અને ઢગલો પર જગ્યા ઢગલો કે ઓ તરફ ઇશારો છે
આ ઢગલો છે, કે જે "બૂમ" સ્ટોર કરે છે તેના પર વધુ જગ્યા માટે એક નિર્દેશક છે.
તેથી "બૂમ" આ નકલ ઢગલો કરવામાં સંગ્રહાયેલ છે.
ત્યાં તકનિકી છે અમારી પ્રોગ્રામ માં "તેજી" બે નકલો.
ત્યાં પ્રથમ એક કે જે હમણાં જ આ "તેજી" શબ્દમાળા સતત દ્વારા આપવામાં આવ્યું છે તે છે,
અને "તેજી" બીજા નકલ, strcpy "બૂમ" ની નકલ બનાવી.
પરંતુ "તેજી" ના નકલ ઢગલો પર આવી રહી સંગ્રહિત થાય છે, અને ઢગલો તમે બદલવા મુક્ત છો.
આ ઢગલો ફક્ત વાંચવા માટે નથી, કે જેથી અર્થ એ થાય કે ઓ [0]
છે જેનાથી તમે "તેજી" ની કિંમત બદલવા જઈ રહી છે.
તે તમને તે અક્ષરો બદલી રહ્યું છે.
>> પ્રશ્નો?
ઠીક છે.
>> Buggy3 પર ખસેડવું, લેટ્સ gdb buggy3.
અમે હમણાં જ તેને ચલાવવા અને અમે જોઈ અમે segfault મેળવો.
બેકસ્ટ્રેસ અમે જો, ત્યાં માત્ર બે કાર્યો છે.
જો અમે અમારી મુખ્ય કાર્ય માં અપ જાઓ, અમે જુઓ કે જે આપણે આ વાક્ય પર segfaulted.
તેથી ફક્ત આ વાક્ય પર looking, (માટે પૂર્ણાંક રેખા = 0; fgets આ સામગ્રીને સમાન NULL કરે છે;
રેખા + +).
અમારા અગાઉના ફ્રેમ _IO_fgets તરીકે ઓળખાતું હતું.
તમે જોશો કે આંતરિક સી વિધેયો સાથે ઘણો,
કે જ્યારે તમે segfault વિચાર, ત્યાં ખરેખર ભેદી કાર્ય નામો હશે
આ _IO_fgets જેવા હોય છે.
પરંતુ આ fgets કોલ સંબંધિત બનશે.
અહીં અંદર ક્યાંક, અમે segfaulting છે.
જો અમે દલીલો અંતે fgets નજર, અમે બફર છાપી શકો છો.
ચાલો છાપો એક તરીકે - ઓહ, નો.
પ્રિન્ટ માટે બરાબર તરીકે હું તેને કરવા માંગો છો કામ નથી જઈ રહ્યા છે.
ચાલો વાસ્તવિક કાર્યક્રમ જુઓ.
બફર એક અક્ષર એરે છે. તે 128 અક્ષરો, એક અક્ષર એરે છે.
તેથી જ્યારે હું પ્રિન્ટ બફર કહે છે, તે માટે તે 128 અક્ષરો છાપો ચાલી રહ્યું છે,
હું માનું છે કે જે શું અપેક્ષા છે.
હું શોધી હતી શું છે બફર ની સરનામા છાપો,
પરંતુ ખરેખર મને કહી ખૂબ નથી.
તેથી જ્યારે હું અપ એક્સ બફર અહીં કહેવું થાય છે, તે મને 0xbffff090 બતાવે છે,
જે, જો તમે પહેલાં અથવા અમુક બિંદુ પરથી યાદ રાખો કે, Oxbffff એક પ્રદેશ સ્ટેક-જેવું હોય છે.
આ સ્ટેકમાંથી 0xc000 હેઠળ માત્ર ક્યાંક શરૂ કરે છે.
આ સરનામા જોયા દ્વારા જસ્ટ, હું જાણું છું કે બફર સ્ટેક પર ચાલી રહ્યું છે.
મારા કાર્યક્રમ પુનઃશરૂ કરી રહ્યા છીએ, ચલાવો, અપ બફર અમે જોયો હતો અક્ષરો આ ક્રમ
કે ખૂબ ખૂબ અર્થહીન છે.
પછી ફાઈલ છાપવા, ફાઇલ શું લાગતું નથી?
[વિદ્યાર્થી] નલ. >> યાહ.
ફાઇલ પ્રકાર છે FILE * એક છે, તેથી તે નિર્દેશક છે,
અને તે નિર્દેશક મૂલ્ય નલ છે.
તેથી fgets માટે એક પરોક્ષ રીતે કે નિર્દેશક માંથી વાંચી પ્રયાસ રહ્યું છે,
પરંતુ ક્રમમાં કે નિર્દેશક ઍક્સેસ કરવા માટે, તેને ડિરેફરન્સ માટે છે.
અથવા, ક્રમમાં વાપરવા માટે તે શું છે, તે dereferences પોઇન્ટ જોઇએ.
તો તેને એક નલ નિર્દેશક અને તે segfaults dereferencing છે.
હું તે છે ત્યાં પુનઃશરૂ કરી શકે છે.
જો અમે અમારી મુખ્ય બિંદુ પર તોડી અને ચલાવવા માટે,
કોડ પ્રથમ વાક્ય ઘરનાં પરચૂરણ કામો * ફાઈલનામ = "nonexistent.txt" છે;
કે શા માટે આ કાર્યક્રમ નિષ્ફળ જાય તરીકે એક સુંદર મોટી સંકેતની આપવી જોઇએ.
આગામી લખીને મને આગામી રેખા પર લઈ આવે છે, જ્યાં હું આ ફાઈલ ખોલવા માટે,
અને પછી હું તરત જ અમારી વાક્ય છે, જ્યાં એક વાર હું આગામી ફટકો પ્રવેશ મેળવવા, તે segfault બનશે.
શું કોઇને માટે એક કારણ અમે segfaulting હોઈ શકે કાઢી નાખવા માંગો છો?
[વિદ્યાર્થી] ફાઈલ અસ્તિત્વમાં નથી. >> યાહ.
આ સંકેત હશે તેવું માનવામાં આવે છે
કે તમે જ્યારે ફાઈલ ખોલવા કરી રહ્યા છો તમે તપાસો કે ફાઇલ ખરેખર અસ્તિત્વમાં જરૂર છે.
અહીં, "nonexistent.txt";
જ્યારે અમે વાંચન માટે fopen ફાઇલનામ, અમે પછી કહેવું જરૂર
જો અને ફાઇલ (NULL ==) કહે છે printf ("ફાઈલ અસ્તિત્વમાં નથી!"
અથવા - હજુ સુધી સારી રીતે - ફાઈલનામ); 1 વળતર;
તેથી હવે અમે જોવા માટે જો તે NULL છે તપાસ
પહેલાં ખરેખર ચાલુ રાખવા માટે અને તે ફાઇલ વાંચવામાં પ્રયાસ કરે છે.
અમે તેને રિમેક માત્ર કે જે કામો જોવા માટે કરી શકો છો.
હું એક નવી લાઇન સમાવેશ કરવાનો હતો.
તેથી હવે nonexistent.txt અસ્તિત્વમાં નથી.
તમે હંમેશા વસ્તુ આ પ્રકારની તપાસ માટે કરીશું.
તમે હંમેશા જોવા માટે જો fopen NULL આપે તપાસ કરીશું.
તમે હંમેશા ખાતરી કરો કે malloc NULL નહિં આપે તેની ખાતરી કરવા તપાસો જોઈએ,
અથવા તો તમે segfault.
>> હવે buggy4.c.
ચાલી રહ્યું છે. હું આ અનુમાન લગાવવા છું છે ઇનપુટ અથવા કદાચ અનંત રહ્યાં પ્રતીક્ષામાં છે.
હા, તેને અનંત રહ્યાં છે.
Buggy4 તેથી. એવું લાગે છે કે અમે અનંત રહ્યાં છો.
અમે મુખ્ય અંતે તોડી શકે છે, અમારા કાર્યક્રમ ચલાવો.
Gdb માં, લાંબા તરીકે સંક્ષેપ તમે ઉપયોગ અસંદિગ્ધ છે
અથવા ખાસ સંક્ષેપ કે તેઓ તમારા માટે પૂરી પાડે છે,
પછી તમે n નો ઉપયોગ કરવા માટે આગામી બધી રીતે ટાઇપ કર્યા બદલે આગામી વાપરી શકો છો.
અને હવે હું ફટકો n એ કર્યું છે એકવાર, હું હમણાં જ દાખલ હિટ આગામી જઈને રાખી શકો છો
તેના બદલે ફટકો n દાખલ કરો, n દાખલ કરો, n દાખલ કર્યા છે.
એવું લાગે છે કે હું લૂપ કે એરે [i] 0 માટે સુયોજિત છે માટે કેટલાક પ્રકારની છું.
એવું લાગે છે કે હું લૂપ માટે ક્યારેય ભંગ કરું છું આ.
જો હું મને છાપો, જેથી હું 2 છે, પછી હું આગામી જવા પડશે.
હું મને છાપો મને 3 છે, પછી મળશે હું આગામી જવા પડશે.
હું મને છાપી અને હું 3 કરીશું. આગળ, હું છાપો, હું 4 છે.
ખરેખર, પ્રિન્ટ (એરે) sizeof, તેથી એરે કદ 20 છે.
પરંતુ લાગે છે કે ત્યાં જઈને ત્યાં સુધી કંઈક થાય છે માટે અમુક ખાસ gdb આદેશ છે.
તે ચલની કિંમત પર શરત સુયોજિત જેવું છે. પરંતુ હું યાદ નથી કે તે શું છે.
તેથી જો આપણે જઈને રાખો -
તમે શું કહી હતી? તમે શું લાવ્યો?
>> યાહ - [વિદ્યાર્થી] પ્રદર્શિત હું શું ઉમેરો. તેથી પ્રદર્શિત મને મદદ કરી શકો છો.
જો અમે માત્ર હું દર્શાવવા માટે, તે અહીં મૂકો i ની કિંમત શું છે
તેથી હું તેને છાપી બહાર દરેક સમય નથી.
જો અમે માત્ર આગામી ચાલુ રાખવામાં, અમે 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 જુઓ.
કંઈક ખોટું ભયંકર રહ્યું છે, અને મને 0 રહી ફરીથી સેટ છે.
Buggy4.c અંતે છીએ, અમે જોવા તમામ આવું થાય પૂર્ણાંક એરે [5] છે;
(; i <= (એરે) sizeof; i + + હું = 0) માટે
એરે [i] = 0;
અમે શું નથી કે ખોટું અહીં છે?
સંકેત તરીકે, જ્યારે હું buggy4 gdb કરી હતી - ચાલો મુખ્ય રન, ભંગ -
હું પ્રિન્ટ sizeof (એરે) માત્ર જોવા માટે તેણે શરત શું છે જ્યાં હું આખરે ભંગ કરીશું.
હું ક્યાં છું? શું હું સ્કોર?
હું હજુ સુધી જાહેર ન હતી.
તેથી sizeof (એરે) છાપો અને તે 20 છે,
જે ત્યારથી મારા એરે 5 કદ છે તેવી અપેક્ષા છે અને તે 5 પૂર્ણાંકોના છે,
જેથી સમગ્ર વસ્તુ 5 * sizeof (પૂર્ણાંક) બાઇટ્સ, જ્યાં sizeof (પૂર્ણાંક) માટે 4 હોઇ શકે છે પ્રયત્ન કરીશું.
તેથી sizeof (એરે) 20 છે.
આ શું હોવું જોઈએ?
[વિદ્યાર્થી] sizeof (પૂર્ણાંક) દ્વારા વિભાજિત. >> અરે વાહ, / sizeof (પૂર્ણાંક).
એવું લાગે છે કે હજી પણ એક સમસ્યા છે અહીં. મને લાગે છે કે આ માત્ર પ્રયત્ન કરીશું <
કારણ કે તે ખૂબ સુંદર હંમેશા <અને = <નથી.
હવે આપણે શા માટે આ ખરેખર ભાંગી હતી વિશે વિચારો.
શું કોઇને ધારી શા માટે કરવામાં આવી હતી છે મને લૂપ દરેક ઇટરેશન મારફતે 0 પુનઃસુયોજિત કરવા માટે?
અહીં કે ચાલી રહ્યું છે તે અંદર જ વસ્તુ છે કે જે એરે [i] 0 રહી સેટ છે.
જેથી કોઈક, કોડના આ વાક્ય અમારા પૂર્ણાંક રહી છે મને 0 થી સુયોજિત કરવા માટે.
[વિદ્યાર્થી] તે કારણ કે તે મને આ ભાગ મેમરી ઓવરરાઈડીંગ છે પ્રયત્ન કરી શકાયું નથી
જ્યારે તે વિચારે છે તે એરે આગળના તત્વ છે? >> [બોડેન] હા.
, જ્યારે અમે અમારા એરે ઓવરને બહાર જઈ રહ્યાં છો
કોઈક કે જે જગ્યા છે કે અમે ઓવરરાઈડીંગ કરી રહ્યાં છો i ની કિંમત ઓવરરાઈડીંગ છે.
અને તેથી જો આપણે buggy4 તપાસ, મુખ્ય રન, ભંગ
ચાલો i ની સરનામા છાપો.
એવું લાગે છે કે તે bffff124 છે.
હવે આપણે ઍરેના સરનામા છાપો. [0] 110.
શું [1] શું? 114.
[2], 118.
11c, 120. [5] એરે bfff124 છે.
અરે તેથી [5] આઇ, જેનો અર્થ છે કે એરે [5] હું છે તે જ સરનામાં હોય છે.
જો તેઓ તે જ સરનામાં હોય છે, તેઓ તે જ વસ્તુ છે.
તેથી જ્યારે અમે [5] એરે સુયોજિત 0 થી, અમે આઈ 0 થી સુયોજિત કરી રહ્યા હોય.
અને જો તમે સ્ટેક દ્રષ્ટિએ આ વિશે વિચારો,
પૂર્ણાંક હું પ્રથમ જાહેર કરવામાં આવે છે, જેનો અર્થ છે મને સ્ટેક પર અમુક જગ્યા નોંધાયો નહીં.
પછી [5] એરે ફાળવવામાં આવે છે, જેથી તે પછી 20 બાઇટ્સ સ્ટેક પર ફાળવવામાં આવે છે.
તેથી હું પ્રથમ ફાળવવામાં નહીં, તો પછી આ 20 બાઇટ્સ ફાળવવામાં છે.
તેથી હું એરે પહેલાં અધિકાર થાય છે,
અને એ છે કે, છેલ્લા અઠવાડિયે જેમ હું જણાવ્યું હતું કે, જ્યાં ટેકનિકલી સ્ટેક નીચે ઊગે છે,
જ્યારે તમે એરે માં અનુક્રમણિકા, અમે ખાતરી આપી છે કે જે એરે માં 0th સ્થિતિ
હંમેશા એરે માં પ્રથમ સ્થાન પહેલાં થાય છે.
આ કેવી રીતે હું છેલ્લા અઠવાડિયામાં તે દોર્યું પ્રકારની છે.
નોંધ કરો કે તળિયે અમે 0 સરનામા હોય છે અને ટોચ પર અમે સરનામા મેક્સ છે.
સ્ટેક હંમેશાં નીચે વધી રહી છે.
હવે કહો કે અમે હું ફાળવો.
અમે પૂર્ણાંક ફાળવવા આઇ, જેનો અર્થ થાય છે ચાલો હમણાં પૂર્ણાંક અહીં હું ફાળવવામાં નહીં કહો.
તો પછી અમે 5 પૂર્ણાંકો અમારી એરે, કે જે નીચે તેનો અર્થ એ કે ફાળવણી,
કારણ કે સ્ટેક નીચે વધતી જાય છે, તે 5 પૂર્ણાંકો ફાળવવામાં છે.
પરંતુ કેવી રીતે એરે કામ કારણ કે, અમે ખાતરી આપી રહ્યાં છો કે જે એરે માં પ્રથમ સ્થાન
હંમેશા એરે બીજી વસ્તુ કરતાં ઓછી સરનામા ધરાવે છે.
તેથી એરે સ્થિતિ 0 હંમેશા મેમરી પ્રથમ થાય છે,
જ્યારે એરે 1 સ્થિતિ કે પછી થાય છે
અને એરે 2 પદ કે પછી થાય છે,
જેનો અર્થ છે કે એરે સ્થિતિ 0 ક્યાંક નીચે અહીં શું થશે,
એરે 1 પોઝિશન કે ઉપર શું થશે
કારણ કે અપ ખસેડવાની ઉચ્ચ સરનામાં અર્થ થાય છે કારણ કે મહત્તમ સરનામા અહીં છે.
[0] નીચે અહીં એરે તેથી, અરે [1] અહીં, અરે [2] અહીં, [3] એરે અહીં છે.
નોટિસ પહેલાં અમે કેવી રીતે પૂર્ણાંક મને બધા અહીં માર્ગ ફાળવવામાં,
અમે અમારા એરે આગળ અને આગળ ખસેડવા માટે, અમે નજીક અને અમારા પૂર્ણાંક હું નજીક મેળવવામાં આવે છે.
તે માત્ર જેથી એરે થાય છે [5], જે આપણા એરે બહાર એક પદ છે,
બરાબર પૂર્ણાંક જ્યાં i માટે ફાળવણી કરવામાં થયું છે.
જેથી બિંદુ જ્યાં અમે સ્ટેક પર જગ્યા હિટ શકાય થાય છે
કે પૂર્ણાંક i માટે ફાળવવામાં આવ્યો હતો, અને અમે તે 0 થી સુયોજિત કરી રહ્યાં છો.
>> કે કેવી રીતે કામ કરે છે. પ્રશ્નો? યાહ.
[વિદ્યાર્થી] કશો વાંધો નહીં. ઠીક છે.
[વિદ્યાર્થી] તમે ભૂલો આ પ્રકારના કેવી રીતે બચું?
ભૂલો આ પ્રકારની? તમારા પ્રોગ્રામિંગ ભાષા તરીકે ઉપયોગ કરશો નહીં. C
એક ભાષા કે એરે ચકાસણી બાઉન્ડ્સ છે વાપરો.
સુધી તમે કાળજી કરશો, તમે ફક્ત તમારા એરે સીમાડાં ભૂતકાળમાં જઈને ટાળવા જરૂર છે.
[વિદ્યાર્થી] તેથી અહીં જ્યારે અમે તમારા એરે સીમાડાં ભૂતકાળમાં થયું હતું -
[બોડેન] કે જ્યાં વસ્તુઓ ખોટી જઈને શરૂ કરો. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.
સુધી તમે તમારા એરે માટે ફાળવવામાં મેમરી અંદર રહેવાની, તમે દંડ છો.
પરંતુ સી કોઈ ભૂલ ચકાસણી કરે છે. જો હું એરે કરવું [1000], તે રાજીખુશીથી માત્ર સુધારવા ગમે થાય છે કરશે -
તે એરે શરૂઆત જાય, પછી તે પછી 1000 સ્થિતિ જાય છે અને તે સુયોજિત કરે છે 0 થી.
તેને કોઈપણ ચકાસણી કે ઓહ, આ ખરેખર તેને 1000 વસ્તુઓ નથી કરતું નથી.
1000 હું શું બદલવા જોઇએ આગળ રસ્તો છે,
જ્યારે જાવા અથવા કંઈક તમે એરે સીમાથી અનુક્રમણિકા બહાર મળશે
અથવા કિનારીઓ અપવાદ બહાર ઇન્ડેક્સ.
કે શા માટે ઉચ્ચ કક્ષાની ભાષાઓ ઘણો આ બધી વસ્તુઓ છે
જ્યાં જો તમે એરે ફરી વસ્તીની સીમાથી દૂર જાય છે, તમે નિષ્ફળ
જેથી તમે વસ્તુઓ તમે નીચે માંથી બદલી શકો છો
અને પછી વસ્તુઓ માત્ર અપવાદ મેળવવામાં કરતાં ઘણા ખરાબ જાઓ
કહે છે કે તમે એરે ઓવરને બહાર ગયા હતા.
[વિદ્યાર્થી] અને તેથી અમે ફક્ત બદલવા જોઈએ છે <= માત્ર <? >> [બોડેન] યાહ.
તે <(એરે) sizeof / sizeof (પૂર્ણાંક) હોવી જોઇએ;
ત્યારથી sizeof (એરે) 20 છે, પરંતુ અમે ફક્ત 5 માંગો છો. >> [વિદ્યાર્થી] અધિકાર.
વધુ પ્રશ્નો છે? ઠીક છે.
>> [વિદ્યાર્થી] હું એક પ્રશ્ન છે. >> યાહ.
[વિદ્યાર્થી] વાસ્તવિક એરે ચલ શું છે?
[બોડેન] જેમ શું એરે છે?
પોતે અરે પ્રતીક છે.
તે ફક્ત 20 બાઇટ્સ કે અમે સંદર્ભ છે શરૂઆત સરનામું છે.
તમે તેને એક નિર્દેશક તરીકે લાગે શકે છે, પરંતુ તે સતત નિર્દેશક છે.
જલદી વસ્તુઓ એકત્ર માટે, ચલ એરે હવે અસ્તિત્વમાં નથી.
[વિદ્યાર્થી] તેથી તે કેવી રીતે એરે માપ શોધી નથી?
અરે કદ કે બ્લોક માપ કે જે પ્રતીક સંદર્ભ લે ઉલ્લેખ કરે છે.
જ્યારે હું printf કંઈક ("% પૃષ્ઠ \ n" એરે) ન કરો;
ચાલો તે ચલાવો.
હું શું માત્ર નહોતી ખોટું છે?
અરે 'અરે' અહીં જાહેર કર્યું.
ઓહ, અહીં.
રણકાર હોંશિયાર છે, અને તે માટે નોટિસ કે હું 5 તત્વો તરીકે એરે જાહેર થાય છે
પરંતુ હું 1000 સ્થિતિ માં ક્રમાંકિત છું.
તે શું કારણ કે આ માત્ર સ્થિરાંકો છે કરી શકો છો.
તે માત્ર ત્યારે જ ધ્યાનમાં લીધા કે હું એરે ફરી વસ્તીની સીમાથી દૂર જઈ રહ્યો છું માં અત્યાર સુધી જઈ શકે છે.
પરંતુ જ્યારે આપણે હું ખોટો હોઈ પહેલાં નોટિસ,
તે સંભવતઃ કેટલા કિંમતો મને લઇ શકે છે કે નહિં તે નક્કી કરી શકે છે,
તેથી તે નક્કી કરી શકતા નથી કે હું એરે ઓવરને બહારના હતી.
કે જે હમણાં જ હોંશિયાર હોવાથી રણકાર છે.
>> પરંતુ હવે buggy4 બનાવે છે. તેથી બીજું શું હું ખોટું કરી રહ્યો છું?
સર્વથા પુસ્તકાલય કાર્ય 'printf' જાહેર કર્યુ.
હું # સમાવેશ કરવા માંગો છો જાઉં છું.
ઠીક છે. હવે buggy4 ચાલી રહ્યું છે.
જેમ એરે ની કિંમત છાપવા હું અહીં આપી હતી, તે એક નિર્દેશક તરીકે છાપવા
પ્રિન્ટ કંઈક કે આ જેવી લાગે છે - bfb8805c - જે કેટલાક સરનામું છે
કે પ્રદેશ સ્ટેક-જેવું માં છે.
પોતે અરે એક નિર્દેશક જેવા હોય છે, પરંતુ તે વાસ્તવિક નિર્દેશક નથી,
અમે નિયમિત નિર્દેશક થી બદલી શકો છો.
અરે માત્ર કેટલાક સતત છે. મેમરીનો 20 બ્લોક્સ સરનામા 0xbfb8805c શરુ થાય છે.
તેથી આ સરનામા મારફતે bfb8805c +20- અથવા હું -20 ધારી -
આ એરે માટે ફાળવવામાં મેમરી બધું છે.
અરે, આ ચલ પોતે ગમે ત્યાં નથી સંગ્રહાયેલ છે.
જ્યારે તમે સંકલન કરી રહ્યાં છો, પણ કમ્પાઇલર - તે અંતે હાથ મોજું -
પરંતુ કમ્પાઇલર માત્ર જ્યાં તે એરે કરવા જાણે ઉપયોગ કરશે.
તે જાણે છે કે જ્યાં એરે શરૂ કરે છે,
અને તેથી તેને હંમેશાં માત્ર ઓફસેટો દ્રષ્ટિએ વસ્તુઓ કરી શકો છો કે શરૂઆતથી નથી.
તે એક ચલ પોતે એરે પ્રતિનિધિત્વ જરૂર નથી.
પરંતુ જ્યારે હું પૂર્ણાંક * પૃષ્ઠ એરે = કંઈક કરવું; હવે પૃષ્ઠ એક નિર્દેશક જે એરે નિર્દેશ છે,
અને હવે પૃષ્ઠ ખરેખર સ્ટેક પર અસ્તિત્વમાં નથી.
હું પૃષ્ઠ બદલવા મુક્ત છું. હું પૃષ્ઠ = malloc કરી શકો છો.
તેથી તે મૂળભૂત એરે પર ધ્યાન; હવે તેને ઢગલો પર કેટલાક જગ્યા નિર્દેશ કરે છે.
હું એરે = malloc ન કરી શકો.
જો રણકાર હોંશિયાર છે, તે મને પર બેટ બોલ અધિકાર કિકિયારી આવશે.
ખરેખર, હું ખૂબ ખાતરી કરો કે gcc આ પણ આવું કરશે છું.
તેથી 'પૂર્ણાંક [5]' અરે પ્રકાર અસાઇનેબલ નથી.
તમે કંઈક ઝાકઝમાળ પ્રકાર નથી સોંપી શકો છો
કારણ કે એરે માત્ર એક સતત છે.
તે એક પ્રતીક સંદર્ભો જે 20 બાઇટ્સ છે. હું તેને બદલી શકતા નથી.
>> [વિદ્યાર્થી] અને જ્યાં એરે માપ સંગ્રહાયેલ છે?
[બોડેન] તે ગમે ત્યાં નથી સ્ટોર છે. તે જ્યારે તે સંકલન છે.
તેથી જ્યાં એરે માપ સંગ્રહાયેલ છે?
તમે માત્ર કાર્ય કે એરે પોતે જાહેર કરવામાં આવે છે ની અંદર sizeof (એરે) નો ઉપયોગ કરી શકો છો.
તેથી જો હું અમુક કાર્ય, foo, આમ અને હું (પૂર્ણાંક એરે [])
printf ("% d \ n", sizeof (એરે));
અને પછી નીચે અહીં હું foo (એરે) કહે છે;
અંદર આ કાર્યનો એક - આપણે તેના ચલાવો.
આ ચપળ ફરીથી હોવા રણકાર છે.
તે મારા કહેવાની છે કે એરે કાર્ય પરિમાણ પર sizeof
'પૂર્ણાંક *' નું માપ આપશે.
આ ભૂલ હોય તો તે હું શું કરવા માગે છે માંગતા નથી.
ચાલો ખરેખર બોલ Werror કરો.
ચેતવણી. ચેતવણી દંડ છે.
તે હજુ સુધી કમ્પાઇલ તે એક ચેતવણી હશે.
/. A.out માટે 4 છાપી રહ્યું છે.
ચેતવણી કે જે પેદા કરવામાં આવ્યો હતો કે શું ખોટું થયું સ્પષ્ટ સૂચક છે.
આ પૂર્ણાંક એરે માત્ર sizeof (* પૂર્ણાંક) છાપી રહ્યું છે.
જો હું અહીં [5] એરે મૂકી, તે હજુ પણ માત્ર છે માટે sizeof (* પૂર્ણાંક) છાપો જઈ રહી છે.
તેથી જલદી તમે તે કાર્ય પસાર, એરે અને પોઇંટરો વચ્ચે તફાવત
આવા કોઈ વલણને સ્થાન છે.
આ ઝાકઝમાળ કે સ્ટેક પર જાહેર કરવામાં આવી બને છે,
પરંતુ જલદી અમે તે કિંમત પસાર કરવા માટે, કે 0xbf મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત છે, આ કાર્ય માં મૂર્ખામી ભરેલી વાહિયાત વાત,
તો પછી આ નિર્દેશક સ્ટેક પર કે એરે નિર્દેશ કરે છે.
, કે જેથી અર્થ એ થાય કે sizeof માત્ર કાર્ય કરે છે જે એરે જાહેર કરવામાં આવી હતી તે લાગુ પડે છે
જેનો અર્થ છે કે જ્યારે તમે આ કાર્ય કમ્પાઇલ કરવામાં આવે છે,
જ્યારે રણકાર આ કાર્ય જાય છે, જુએ છે તે એરે 5 સાઈઝ પૂર્ણાંક એરે છે.
તેથી પછી તે sizeof (એરે) જુએ છે. વેલ, અને તે 20 છે.
કે ખરેખર કેવી રીતે sizeof મૂળભૂત લગભગ તમામ કિસ્સાઓમાં કામ કરે છે.
Sizeof કાર્ય નથી; તેને એક ઓપરેટર છે.
તમે sizeof કાર્ય નથી કહેતો.
Sizeof (પૂર્ણાંક), પણ કમ્પાઇલર માત્ર જે 4 થી અનુવાદ થશે.
તે મળ્યું? ઠીક છે.
>> [વિદ્યાર્થી] તેથી મુખ્ય અને foo માં sizeof (એરે) વચ્ચે તફાવત શું છે?
આ કારણ છે કે અમે (એરે) sizeof છે, જે પ્રકાર પૂર્ણાંક * છે કહી રહ્યાં છે,
જ્યારે એરે નીચે અહીં પ્રકાર પૂર્ણાંક * નથી, તે પૂર્ણાંક એરે છે.
>> [વિદ્યાર્થી] તેથી, જો તમે [] બદલે પૂર્ણાંક * અરે, અરે આ પરિમાણ હતી
તેનો અર્થ છે કે તમે હજી પણ એરે ફેરફાર કારણ કે હવે તે એક નિર્દેશક છે કરી શકે છે?
[બોડેન] આ ગમે છે? >> [વિદ્યાર્થી] યાહ. તમે કાર્ય કરી શકો છો અંદર એરે હવે બદલ્યો?
[બોડેન] તમે બંને કિસ્સામાં એરે બદલી શકે છે.
આ કિસ્સાઓમાં આ બંને તમને કહું છું [4] એરે = 0 મફત છે.
[વિદ્યાર્થી] પરંતુ તમે કંઈક બીજું માટે એરે બિંદુ કરી શકો છો?
[બોડેન] ઓહ. યાહ. ક્યાં કિસ્સામાં - >> [વિદ્યાર્થી] યાહ.
[બોડેન] [] અને પૂર્ણાંક * અરે, અરે વચ્ચે આ તફાવત, ત્યાં કંઈ છે.
તમે પણ અહીં કેટલાક બહુપરીમાણીય એરે મેળવી શકો છો
કેટલાક અનુકૂળ સિન્ટેક્ષ માટે છે, પરંતુ તે હજુ પણ માત્ર એક નિર્દેશક છે.
આનો અર્થ એ થાય કે હું એરે કરવા મુક્ત છું = (sizeof (પૂર્ણાંક)) malloc; અને હવે બીજે ક્યાંય નિર્દેશ કરે છે.
પરંતુ ફક્ત માંગો કે કેવી રીતે આ કાયમ અને હંમેશા કામ કરે છે,
તે કરીને આ એરે બદલવા કંઈક બીજું માટે નિર્દેશ
નથી બદલી નીચે આ એરે અહીં કારણ કે તે દલીલ નકલ છે,
તે દલીલ માટે નિર્દેશક નથી.
અને ખરેખર, માત્ર વધારે સંકેત કરે છે કે તે બરાબર છે જ તરીકે -
અમે પહેલાથી જ શું પ્રિન્ટીંગ એરે પ્રિન્ટ જોવા મળ્યો હતો -
જો અમે ઍરેના સરનામું અથવા ઍરેના સરનામું સરનામા છાપો
માટે તે ક્યાંતો?
ચાલો આ એક અવગણો.
ઠીક છે. આ દંડ છે. તે હવે a.out. / ચાલી રહી છે.
પ્રિન્ટિંગ એરે, પછી ઍરેના સરનામા છાપવા માટે, આ જ વસ્તુ છે.
અરે માત્ર અસ્તિત્વમાં નથી.
તે જાણે છે કે જ્યારે તમે એરે છાપવા કરી રહ્યાં છો, તો તમે પ્રતીક કે તે 20 બાઇટ્સ સંદર્ભ લે છે છાપવા કરી રહ્યાં છો.
એરે ની સરનામા છાપવા, તેમજ, અરે અસ્તિત્વમાં નથી.
તે એક સરનામું નથી, તેથી તે માત્ર તે 20 બાઇટ્સ ની સરનામા છાપે છે.
જલદી તમે કમ્પાઇલ, તમારા સંકલિત buggy4 માં ગમે /. A.out,
એરે અસ્તિત્વ ધરાવતી હોય છે.
પોઇન્ટર અસ્તિત્વ ધરાવે છે. નથી એરે.
મેમરી ઓફ બ્લોકો એરે રજૂ હજુ પણ અસ્તિત્વ ધરાવે છે,
પરંતુ ચલ એરે અને તે પ્રકારના ચલો અસ્તિત્વમાં નથી.
તે એરે અને પોઇંટરો વચ્ચે મુખ્ય તફાવત જેવા છે
છે જલદી તમે વિધેય કોલ કરવા માટે, ત્યાં કોઈ તફાવત નથી.
પરંતુ કાર્ય કે એરે પોતે જાહેર કરવામાં આવે છે અંદર, sizeof અલગ રીતે કામ કરે છે
કારણ કે તમે આ પ્રકારના માપ બદલે બ્લોકની કદ છાપવા કરી રહ્યાં છો,
અને તમે તેને બદલવા કારણ કે તે પ્રતીક છે કરી શકો છો.
અને આ વસ્તુ ની સરનામા વસ્તુ છાપવા જ વસ્તુ છાપે છે.
અને તે ખૂબ ખૂબ તે છે.
[વિદ્યાર્થી] કે જે તમને એક અથવા વધુ વખત કહેવું કરશો?
હું કંઈક ચૂકી હોઈ શકે છે.
પ્રિન્ટિંગ અને ઍરેની એરે સરનામું પણ એ જ વસ્તુ છાપે છે,
જો તમે નિર્દેશક ની સરનામા વિરુદ્ધ એક નિર્દેશક છાપો જ્યારે,
એક વસ્તુ તમે શું કરી રહ્યાં છો પોઇન્ટ ઓફ સરનામા છાપે છે,
અન્ય સ્ટેક પર પોઇન્ટર ની સરનામા છાપે છે.
તમે એક નિર્દેશક બદલી શકો છો; તમે ઝાકઝમાળ પ્રતીક બદલી શકતા નથી.
અને sizeof નિર્દેશક કે નિર્દેશક પ્રકારના કદ છાપી રહ્યું છે.
તેથી પૂર્ણાંક * પૃષ્ઠ sizeof (પી), 4 છાપી રહ્યું છે,
પરંતુ પૂર્ણાંક [5] એરે પ્રિન્ટ sizeof (એરે) થી 20 છાપી રહ્યું છે.
[વિદ્યાર્થી] તેથી પૂર્ણાંક [5] એરે 20 છાપશે? હા. >>
કે buggy4 ની અંદર શા માટે છે જ્યારે તે sizeof (એરે) હોવો ઉપયોગ
આ હું 20 <કરી હતી, જે નથી, આપણે શું ઇચ્છે છે.
અમે i <5 માંગો છો. >> [વિદ્યાર્થી] ઠીક.
[બોડેન] અને તે પછી તરત જ તમે વિધેયો માં પસાર શરૂ કરવા માટે,
જો અમે પૂર્ણાંક * પૃષ્ઠ એરે =;
આ કાર્ય ની અંદર, અમે મૂળભૂત રીતે બરાબર એ જ રીતે p અને એરે ઉપયોગ કરી શકો છો,
સિવાય sizeof સમસ્યા અને બદલાતી સમસ્યા છે.
પરંતુ પાનું 1 = [0]; [0] એરે = 1 જણાવ્યું હતું એ જ છે;
અને જલદી અમે (એરે) foo કહે; અથવા foo (પી);
આ foo કાર્ય ની અંદર, આ જ કોલ બમણું છે.
ત્યાં આ બે કોલ્સ વચ્ચે કોઈ તફાવત નથી.
>> કે સારા દરેક વ્યક્તિને? ઠીક છે.
અમે 10 મિનિટ હોય છે.
>> અમે આ હેકર Typer કાર્યક્રમ મારફતે પ્રયાસ કરીશું,
આ વેબસાઇટ છે, જે ગયા વર્ષે અથવા કંઈક બહાર આવ્યા હતા.
તે માત્ર હશે તેવું માનવામાં આવે છે કે તમે રેન્ડમ લખો અને તેને છાપે છે -
ફાઈલ ગમે તે લાવી દીધા થાય છે તે શું લાગે છે કે તમે ટાઇપ કરી રહ્યા છો.
તે ઓપરેટિંગ સિસ્ટમ કોડ કેટલાક પ્રકારની જેવો દેખાય છે.
કે અમે શું અમલ કરવા માંગો છો.
તમે એક દ્વિસંગી hacker_typer નામવાળી એક્ઝેક્યુટેબલ હોવા જોઈએ
કે જે એક દલીલ લે છે, જે ફાઈલ "હેકર પ્રકાર."
એક્ઝેક્યુટેબલ ચાલી રહેલ સ્ક્રીન સાફ કરીશું
અને પછી ફાઈલ પસાર થતા-દરેક સમયે વપરાશકર્તા કી દબાવીને એક અક્ષર છાપો.
કી ગમે તમે દબાવો, જેથી તે ફેંકી દેવું છે અને તેની જગ્યાએ ફાઈલ માંથી એક અક્ષર છાપો જોઈએ
કે દલીલ છે.
હું ખૂબ ખૂબ તમે કહો વસ્તુઓ અમે જાણવાની જરૂર જઈ રહ્યાં છો શું છે પડશે.
પરંતુ અમે બહાર termios પુસ્તકાલય તપાસ કરવા માંગો છો.
હું મારી સમગ્ર જીવન માં આ લાઇબ્રેરી ઉપયોગ ક્યારેય થતો નથી, તેથી તે ખૂબ જ ન્યૂનતમ હેતુઓ ધરાવે છે.
પરંતુ આ માટે લાઈબ્રેરી અમે દૂર અક્ષર તમે ફટકો ફેંકવું ઉપયોગ કરી શકે રહ્યું છે
જ્યારે તમે સાઇન ધોરણ માં ટાઇપ કરી રહ્યા છે
તેથી hacker_typer.c, અને અમે તે માટે # સમાવેશ કરવા માંગો છો જઈ રહ્યાં છો.
Termios માટે મદદ પાનું અંતે છીએ - I'm તે ટર્મિનલ ઓએસ અથવા કંઈક અનુમાન લગાવવા -
મને ખબર નથી કે તે કેવી રીતે વાંચી શકાય છે.
આ અંતે છીએ, તે આ 2 ફાઈલો સમાવેશ કહે છે, તેથી અમે તે કરીશ.
>> પ્રથમ વસ્તુ પ્રથમ, અમે એક દલીલ છે, કે જે ફાઈલ અમે ખોલવા જોઈએ છે માં લઈ જવા માંગો છો.
તેથી હું શું કરવા માંગો છો? હું જોવા માટે હું એક દલીલ છે કે કેવી રીતે તપાસ કરી શકું?
[વિદ્યાર્થી] જો argc તેને સમકક્ષ હોય છે. >> [બોડેન] યાહ.
તેથી જો (argc = 2!) Printf ("વપરાશ:% [ફાઈલ ખોલવા માટે] ઓ").
તેથી હવે જો હું બીજી દલીલ પૂરી વગર આ સ્કોર - ઓહ, હું નવી લાઇન કરવાની જરૂર પડશે -
તમે તેને વપરાશ કહે જોશો:. / hacker_typer,
અને પછી બીજા દલીલ ફાઈલ હું ખોલવા માંગો છો પ્રયત્ન કરીશું.
હવે હું શું કરું?
હું આ ફાઇલ વાંચવામાં કરવા માંગો છો. હું એક ફાઈલ કેવી રીતે વાંચી શકું?
[વિદ્યાર્થી] તમે તે પ્રથમ ખોલો. >> યાહ.
તેથી fopen. Fopen શું લાગતું નથી?
[વિદ્યાર્થી] ફાઇલનામ. >> [બોડેન] ફાઇલનામ માટે argv [1] પ્રયત્ન રહ્યું છે.
[વિદ્યાર્થી] અને તે પછી શું તમે તેની સાથે કરવા માંગો છો, તેથી - >> [બોડેન] યાહ.
તેથી જો તમે યાદ નથી નહોતી, તો તમે માણસ fopen માત્ર કરી શકે,
, જ્યાં તે એક const ઘરનાં પરચૂરણ કામો * પાથ છે કે જ્યાં પાથ અને ફાઈલનામ છે જ હશે
const ઘરનાં પરચૂરણ કામો * મોડ.
જો તમે યાદ સ્થિતિ શું છે ન થાય, તો પછી તમે સ્થિતિમાં જોવા માટે કરી શકો છો.
મદદ પાનાંઓ અંદર છે, સ્લેશ અક્ષર છે તમે શું વસ્તુઓ શોધવા માટે ઉપયોગ કરી શકો છો.
તેથી હું / માટે સ્થિતિ માટે શોધ સ્થિતિ લખો.
n અને એન છે તમે શું શોધ મેચ મારફતે ખસેડવા માટે ઉપયોગ કરી શકો છો.
અહીં તે શબ્દમાળા માટે દલીલ સ્થિતિમાં પોઇન્ટ કહે છે
એક નીચેના ક્રમાંકો સાથે શરૂઆત કરી હતી.
R તેથી, વાંચન માટે ઓપન ટેક્સ્ટ ફાઇલ. કે અમે શું કરવા માંગો છો.
માટે વાંચવા, અને હું સંગ્રહવા માંગો છો.
આ વસ્તુ એક છે FILE * પ્રયત્ન રહ્યું છે. હવે હું શું કરવા માંગો છો?
મને બીજા આપો.
ઠીક છે. હવે હું શું કરવા માંગો છો?
[વિદ્યાર્થી] તપાસો જો તે NULL છે. >> [બોડેન] યાહ.
કોઈપણ સમયે તમે ફાઈલ ખોલવા માટે, ખાતરી કરો કે તમે સફળતાપૂર્વક તેને ખોલવા સક્ષમ બનાવે છે.
>> હવે હું termios સામગ્રી કરવા માંગો છો જ્યાં હું પ્રથમ મારા વર્તમાન સુયોજનો વાંચવા માંગો છો
અને કંઈક માં તે સંગ્રહો, તો પછી હું મારી સેટિંગ્સ બદલવા માંગો છો
દૂર કોઇ અક્ષર કે હું લખો ફેંકવું,
અને પછી હું તે સેટિંગ્સને અપડેટ કરવા માંગો છો.
અને પછી કાર્યક્રમ ઓવરને અંતે, હું મારા મૂળ સેટિંગ્સ પર પાછા બદલવા માંગો છો.
તેથી સ્ટ્રક્ટ માટે પ્રકાર termios હોવા રહ્યું છે, અને હું બે લોકો કરવા માંગો છો જાઉં છું.
પ્રથમ એક મારા current_settings પ્રયત્ન રહ્યું છે,
અને પછી તેઓ મારા hacker_settings પ્રયત્ન રહ્યા છીએ.
પ્રથમ, હું મારા વર્તમાન સુયોજનો સાચવવા માંગો છો જાઉં છું,
પછી હું hacker_settings અપડેટ કરવા માંગો છો જાઉં છું,
અને પછી મારી કાર્યક્રમ ઓવરને અંતે માર્ગ, હું વર્તમાન સુયોજનો ઉલટાવવાની કરવા માંગો છો.
તેથી વર્તમાન સેટિંગ્સ સાચવતી, કે જે રીતે કામ કરે છે, અમે માણસ termios.
અમે જુઓ કે જે આપણે આ પૂર્ણાંક tcsetattr, tcgetattr પૂર્ણાંક હોય છે.
હું તેના નિર્દેશક દ્વારા termios સ્ટ્રક્ટ માં પસાર કરે છે.
જે રીતે આ જોઈશું છે - I've પહેલાથી જ ભૂલી શું કાર્ય તરીકે ઓળખાતું હતું.
કૉપિ કરો અને તેને પેસ્ટ કરો.
Tcgetattr તેથી, પછી હું સ્ટ્રક્ટ પાસ કે હું આ માહિતી સાચવવામાં છું માંગો છો,
જે current_settings પ્રયત્ન રહ્યું છે,
અને પ્રથમ દલીલ વસ્તુ હું લક્ષણો સાચવવા માંગો છો માટે ફાઇલ વર્ણનકર્તા છે.
ફાઇલ વર્ણનકર્તા છે શું કોઇ પણ સમયે ફાઇલ ખોલવા જેવા છે, તે ફાઇલ વર્ણનકર્તા નોંધાયો નહીં.
Fopen હું જ્યારે argv [1], તે ફાઇલ વર્ણનકર્તા કે જે તમને સંદર્ભ કરવામાં આવે છે નોંધાયો નહીં
જ્યારે પણ તમે વાંચી અથવા તે લખવા માટે કરવા માંગો છો.
કે ફાઇલ વર્ણનકર્તા હું અહીં ઉપયોગ કરવા માંગો છો નથી.
ત્યાં ત્રણ ફાઈલ વર્ણનકાર તમે મૂળભૂત રીતે હોય છે,
જે પ્રમાણભૂત છે, પ્રમાણભૂત આઉટ અને પ્રમાણભૂત ભૂલ.
મૂળભૂત રીતે, મને લાગે છે કે તે પ્રમાણભૂત છે 0, પ્રમાણભૂત બહાર 1, અને પ્રમાણભૂત ભૂલ 2 છે.
તેથી હું શું માટે સુયોજનો બદલવા માંગો છો?
હું જ્યારે પણ હું એક અક્ષર ફટકો ના સેટિંગ્સ બદલવા માંગો છો,
હું તે પાત્ર ફેંકવું તેને સ્ક્રીન પર છાપવા બદલે દૂર કરવા માંગો છો.
માં ધોરણ આઉટ, અથવા પ્રમાણભૂત ભૂલ ધોરણ - સ્ટ્રીમ શું -
વસ્તુઓ પ્રતિભાવ જ્યારે હું કીબોર્ડ પર લખ્યું છે? >> [વિદ્યાર્થી] >> યાહ સાઇન સ્ટાન્ડર્ડ.
તેથી હું ક્યાં તો 0 કરવા કરી શકો છો અથવા હું stdin ની કરી શકો છો.
હું સ્ટાન્ડર્ડ current_settings સાઇન મેળવવામાં છું
>> હવે હું તે સેટિંગ્સને અપડેટ કરવા માંગો છો,
તેથી પ્રથમ હું hacker_settings મારા current_settings શું છે કૉપિ પડશે.
અને કેવી રીતે સ્ટ્ર્ક્ટ્સ કાર્ય છે તે માત્ર નકલ થશે.
આ બધા ક્ષેત્રોમાં નકલ કરે છે, કારણ કે તમે અપેક્ષા રાખી શકે છે.
>> હવે હું ક્ષેત્રોમાં કેટલાક અપડેટ કરવા માંગો છો.
Termios અંતે છીએ, તમે આ ઘણો દ્વારા વાંચી હશે
માત્ર જોવા માટે તમે શું જોવા માટે કરવા માંગો છો કરશે,
પરંતુ ફ્લેગ કરવા માટે તમે જોવા માટે કરવા માંગો છો જઈ રહ્યાં છો પડઘો છે,
જેથી ઇકો અક્ષરો ઇનપુટ ઇકો.
પ્રથમ હું સેટ કરવા માંગો છો - I've પહેલાથી જ ભૂલી ક્ષેત્રો શું છે.
આ છે સ્ટ્રક્ટ શું જુએ છે.
ઇનપુટ સ્થિતિઓ મને લાગે છે અમે બદલવા માંગો છો.
અમે ઉકેલ જોવા ખાતરી કરો કે અમે શું બદલવા માંગો છો બનાવવા પડશે.
અમે lflag ફેરફાર કરવા માટે ક્રમમાં આ તમામ દ્વારા જોવા જરૂર રોકવા માંગો છો.
અમે સ્થાનિક સ્થિતિઓ બદલવા માંગો છો.
તમે આ સમગ્ર વસ્તુ મારફતે વાંચી છે તે સમજવા માટે જ્યાં બધું અનુલક્ષે કરશે
કે અમે બદલવા માંગો છો.
પરંતુ તે સ્થાનિક સ્થિતિઓ જ્યાં અમે કરવા માટે કે બદલવા માંગો છો જઈ રહ્યાં છો ની અંદર છે.
તેથી hacker_settings.cc_lmode છે શુ કહેવાય છે.
c_lflag.
આ તે છે જ્યાં અમે bitwise ઓપરેટરો માં મેળવો.
અમે સમય બહાર પ્રકારની છીએ, પરંતુ અમે તેને વાસ્તવિક ઝડપી પસાર કરશો.
આ તે છે જ્યાં અમે bitwise ઓપરેટરો પ્રવેશ મેળવવા,
જ્યાં મને લાગે છે કે હું એક લાંબા સમયથી પહેલા કહ્યું હતું કે, જ્યારે તમે ફ્લેગ સાથે કામ શરૂ
તમે bitwise ઓપરેટર ઘણો ઉપયોગ કરી રહ્યા છીએ.
ધ્વજ દરેક બીટ વર્તન અમુક પ્રકારની અનુલક્ષે છે.
અહીં, આ ધ્વજ અલગ વસ્તુઓ છે, જ્યાં તેમને બધા કંઇક અલગ અર્થ સમૂહ છે.
પરંતુ હું શું કરવા માંગો છો કે માત્ર બોલ છે બીટ જે ECHO અનુલક્ષે કરો.
તેથી ચાલુ કરવા માટે કે બોલ હું અને = ¬ ECHO.
ખરેખર, મને લાગે છે કે તે tECHO અથવા કંઈક જેવું છે. મેં હમણાં ફરીથી તપાસ જાઉં છું.
હું તેને termios કરી શકો છો. તે માત્ર ECHO છે.
ECHO એક બીટ પ્રયત્ન રહ્યું છે.
¬ ECHO અર્થ બધા બિટ્સ 1 સુયોજિત છે, કે જેનો અર્થ તમામ ધ્વજો સાચું સુયોજિત હોય છે રહ્યું છે
આ ECHO બીટ સિવાય.
આ સાથે મારા સ્થાનિક ફ્લેગો અંત સુધીમાં, આ તમામ ધ્વજો કે જે વર્તમાનમાં સાચું સુયોજિત હોય છે, એટલે
હજુ પણ સાચું સુયોજિત કરવામાં આવશે.
જો મારું ECHO ધ્વજ સાચું સુયોજિત થયેલ હોય, તો પછી આ માટે જરૂરી ECHO ધ્વજ પર ખોટા સુયોજિત થયેલ છે.
તેથી કોડ આ વાક્ય માત્ર બોલ ECHO ધ્વજ કરે છે.
કોડ અન્ય રેખાઓ, હું હમણાં જ તેમને સમય રસ નકલ અને પડશે પછી તેમને સમજાવવું.
ઉકેલ માં, તેમણે 0 જણાવ્યું હતું.
તે કદાચ વધુ સારી રીતે સ્પષ્ટ રીતે stdin ની કહે છે.
>> નોંધ કરો કે હું પણ ECHO છું કરવાનું | ICANON અહીં.
ICANON અલગ કંઈક છે, કે જે પ્રમાણભૂત સ્થિતિમાં અર્થ ઉલ્લેખ કરે છે.
પ્રમાણભૂત સ્થિતિમાં અર્થ શું સામાન્ય રીતે જ્યારે તમે આદેશ વાક્ય લખી રહ્યા છો,
પ્રમાણભૂત કંઈપણ પ્રક્રિયા સુધી તમે NEWLINE ફટકો નથી.
તેથી જ્યારે તમે GetString નથી, તો તમે વસ્તુઓ સમૂહ લખો, પછી તમે NEWLINE નહીં.
કે જ્યારે તે સાઇન પ્રમાણભૂત માટે મોકલવામાં આવે છે
કે મૂળભૂત છે.
જ્યારે હું બોલ પ્રમાણભૂત સ્થિતિમાં ચાલુ છે, હવે દરેક એક અક્ષર તમે દબાવો
છે શું પ્રક્રિયા, નહીં કે જે સામાન્ય રીતે ખરાબ પ્રકારની કારણ કે તે આ બધી વસ્તુઓ પર પ્રક્રિયા ધીમી છે,
કેમ કે તે સારી છે તે સમગ્ર લીટીઓમાં બફર.
પરંતુ હું દરેક અક્ષર પ્રક્રિયા કરવા માંગો છો
કારણ કે હું તેને મારા માટે NEWLINE હિટ રાહ નથી માંગતા
તે પહેલા તમામ અક્ષરો પ્રક્રિયા હું લખીને થઈ.
આ બોલ પ્રમાણભૂત સ્થિતિમાં કરે છે.
આ સામગ્રી ફક્ત અર્થ થાય છે જ્યારે તે વાસ્તવમાં અક્ષરો પ્રક્રિયા.
આનો અર્થ એ થાય તેમને તુરંત જ પ્રક્રિયા; જલદી હું તેમને લખીને છું, તેમને પ્રક્રિયા કરે છે.
અને આ કાર્ય જે પ્રમાણભૂત માટે મારી સેટિંગ્સ અપડેટ થાય છે,
અને TCSA અર્થ તે હમણાં નથી.
અન્ય વિકલ્પો સુધી બધું છે કે સ્ટ્રીમ પર હાલમાં પ્રક્રિયા રાહ છે.
કે ખરેખર તો કોઈ વાંધો નથી.
જસ્ટ હમણાં મારી સેટિંગ્સ પ્રયત્ન ગમે hacker_typer_settings હાલમાં છે બદલો.
હું માનું હું તે hacker_settings કહેવાય છે, તેથી આપણે કે બદલો.
Hacker_settings માટે બધું બદલો.
>> હવે અમારી કાર્યક્રમ ઓવરને અંતે અમે પાછા ફરવા માટે કરવા માંગો છો જઈ રહ્યાં છો
શું હાલમાં normal_settings ની અંદર છે,
જે માત્ર normal_settings અને જેમ દેખાય રહ્યું છે.
હું મારા normal_settings કોઇપણ મૂળભૂત રીતે તે મેળવવામાં થી બદલાઈ નથી નોટિસ.
પછી ફક્ત તેને પાછા બદલી શકે છે, હું તેમને ઓવરને અંતે પાછળ પસાર કરે છે.
આ સુધારો હતો. ઠીક છે.
>> હવે અંદર અહીં મેં હમણાં જ સમય રસ કોડ સમજાવવું પડશે.
તે ખૂબ કોડ નથી.
અમે જુઓ ફાઇલ પર અમે એક અક્ષર વાંચી શકાય છે. અમે તેને એફ કહેવાય છે.
હવે તમે માણસ fgetc કરી શકો છો, પરંતુ fgetc કેવી રીતે કામ રહ્યું છે
છે માત્ર તે અક્ષર કે જે તમે હમણાં જ વાંચી અથવા EOF પરત ચાલી રહ્યું છે,
જે ફાઈલ અથવા કેટલીક ભૂલ થાય અંતે અનુલક્ષે છે.
અમે રહ્યાં છે, જે ફાઈલ એક અક્ષર વાંચી નિરંતર,
ત્યાં સુધી અમે અક્ષરો સ્કોર કર્યું વાંચો.
અને જ્યારે અમે તે કરી રહ્યા છીએ, અમે સાઇન પ્રમાણભૂત એક પાત્ર પર રાહ જોવી
દરેક એક સમય તમે આદેશ વાક્ય પર કંઈક લખો
કે, એક અક્ષર પ્રમાણભૂત માંથી સાઇન reading છે
પછી putchar માત્ર કોલસો બનાવો અમે વાંચો ફાઇલ માંથી ધોરણ આઉટ કરવા માટે અહીં મૂકવામાં રહ્યું છે.
તમે માણસ putchar કરી શકો છો, પરંતુ તે માત્ર ધોરણ માટે મૂકી છે આઉટ તે અક્ષર છાપવા છે.
તમે પણ માત્ર printf કરી શકે ("% C", C); સેમ વિચાર.
કે અમારી કામ બલ્ક કરવા જઇ રહી છે.
>> છેલ્લા વસ્તુ અમે કરવા માંગો છો જઈ રહ્યાં છો છે અમારા ફાઈલ fclose.
જો તમે ન fclose નથી, કે જે મેમરી છિદ્ર છે.
અમે ફાઈલ અમે મૂળ ખોલી fclose કરવા માંગો છો, અને મને લાગે છે કે તે છે.
જો આપણે એ બનાવવા માટે, હું પહેલેથી જ સમસ્યાઓ મળી.
ચાલો જુઓ.
તે શેના વિશે ફરિયાદ કરી?
અપેક્ષિત 'પૂર્ણાંક' પરંતુ દલીલ પ્રકાર 'સ્ટ્રક્ટ _IO_FILE *' છે.
અમે જો કે કામ કરે છે જોશો.
માત્ર C99 માં મંજૂરી આપી હતી. Augh. ઠીક છે, hacker_typer બનાવે છે.
હવે અમે વધુ ઉપયોગી વર્ણનો મળે છે.
તેથી બિનજાહેર ઓળખકર્તા 'normal_settings' ના વાપરો.
હું તેને normal_settings નથી કહી ન હતી. હું તેને current_settings કહેવાય છે.
તેથી આપણે તે બધા બદલો.
હવે દલીલ પસાર.
હવે હું માટે આ 0 બનાવવા પડશે.
ઠીક છે. /. Hacker_typer cp.c.
હું પણ શરૂઆતમાં સ્ક્રીન સાફ ન હતી.
પરંતુ તમે પાછા છેલ્લા સમસ્યા સેટ નજર જોવા માટે તમે કેવી રીતે સ્ક્રીન સાફ કરી શકો છો.
તે માત્ર કેટલાક અક્ષરો છાપવા છે
જ્યારે આવું થાય છે હું શું કરવા માંગો છો.
ઠીક છે.
અને શા માટે આ 0 stdin ની જગ્યાએ જરૂર વિશે વિચારવું,
જે 0 # વ્યાખ્યાયિત કરવા જોઇએ,
આ કે ફરિયાદ છે -
જ્યારે હું જણાવ્યું હતું કે ત્યાં ફાઈલ ડિસ્ક્રીપ્ટર્સ છે પછી પણ તમે પણ તમારા છે FILE * પહેલાં,
ફાઇલ વર્ણનકર્તા માત્ર એક પૂર્ણાંક છે,
જ્યારે એક છે FILE * સામગ્રી સંપૂર્ણ સમૂહ તેની સાથે સંકળાયેલ છે.
કારણ અમે stdin ની બદલે 0 કહેવું જરૂર
છે કે stdin ની એક છે FILE * જે વસ્તુ કે ફાઈલ 0 વર્ણનકર્તા સંદર્ભ આપે છે નિર્દેશ છે.
તેથી પણ અહીં જ્યારે હું fopen કરવું (argv [1], હું એક છે FILE * મળતો રહ્યો છું નહીં.
પરંતુ તે ફાઇલ * ક્યાંક તે ફાઈલ માટે ફાઇલ વર્ણનકર્તા સંબંધિત વસ્તુ છે.
જો તમે ઓપન માટે મદદ પાનું જોવા માટે છે, તેથી મને લાગે છે કે તમે 3 માણસ ઓપન કરવા પડશે - ના -
2 માણસ ઓપન - હા.
જો તમે ઓપન માટે પાનું જોવા માટે, ઓપન એક fopen નીચા સ્તર જેવા છે,
અને તે વાસ્તવિક ફાઇલ વર્ણનકર્તા પરત છે.
fopen ઓપન ટોચ પર સામગ્રી સમૂહ કરે છે,
પરત માત્ર તે ફાઇલ વર્ણનકર્તા સંપૂર્ણ છે FILE * નિર્દેશક આપે બદલે જે
અંદર જે અમારી થોડી ફાઇલ વર્ણનકર્તા છે.
તેથી છે FILE * વસ્તુ સંદર્ભ લે માં ધોરણ,
જ્યારે 0 માત્ર પોતે ફાઇલ વર્ણનકર્તા પ્રમાણભૂત સંદર્ભ આપે છે.
>> પ્રશ્નો?
[Laughs] કે મારફતે ઉડાવી.
અધિકાર છે. અમે પૂર્ણ કરી લીધું. [Laughs]
>> [CS50.TV]