[Powered by Google Translate] [સમીક્ષા] [ક્વિઝ 0]
>> [Lexi રોસ, ટોમી MacWilliam, લુકાસ Freitas, જોસેફ ઓન્ગ] [હાર્વર્ડ યુનિવર્સિટી]
>> [આ CS50 છે.] [CS50.TV]
>> અરે, દરેકને.
0 ક્વિઝ છે, કે જે જગ્યાએ આ બુધવારે રહી છે માટે સમીક્ષા સત્ર માટે આપનું સ્વાગત છે.
માટે અમે શું કરી રાત્રે જઈ રહ્યાં છો, હું 3 અન્ય TFs સાથે છું,
અને સાથે સાથે અમે અમે શું કોર્સમાં કર્યું છે અત્યાર સુધી એક સમીક્ષા મારફતે જાઓ જતાં રહ્યાં છો.
તે 100% વ્યાપક બનશે નહીં, પણ તે તમને વધુ સારી રીતે વિચાર આપવી જોઇએ
તમે શું પહેલાથી નીચે હોય અને તમે હજી પણ બુધવાર પહેલાં અભ્યાસ કરવાની જરૂર છે કે શું.
અને પ્રશ્નો સાથે તમારા હાથમાં એકત્ર નિઃસંકોચ આપણે સાથે જઈ રહ્યાં છો,
પરંતુ ધ્યાનમાં રાખો કે અમે પણ અંતે સમય થોડો પડશે અંત
જો આપણે થોડી મિનિટો સાથે મારફતે વિચાર ફાજલ-કરવા માટે સામાન્ય પ્રશ્નો કરવા માટે,
જેથી ધ્યાનમાં રાખો કે, અને તેથી અમે 0 અઠવાડિયું સાથે શરૂઆતમાં શરૂ રહ્યા છીએ.
>> [0 સમીક્ષા કિવઝઃ!] [0 ભાગ] [Lexi રોસ] પરંતુ તે પહેલાં અમે કે ચાલો વિશે વાત
ક્વિઝ ઓફ લોજિસ્ટિક્સ.
>> [લોજિસ્ટિક્સ] [ક્વિઝ / 10 10 બુધવારે વ્યાખ્યાન બદલે થાય છે]
>> [(વિગતો માટે http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf જુઓ)] તે બુધવાર, 10 મી ઓક્ટોબરના રોજ છે.
>> કે આ બુધવાર, અને જો તમે આ URL માટે અહીં જાઓ,
જે પણ છે CS50.net-ત્યાં 'ઓ સુલભ કરવા માટે લિંકને-
તમે જ્યાં પર આધારિત જવા વિશે જાણકારી જોઈ શકો છો
તમારા છેલ્લા નામ અથવા શાળાના જોડાણ તેમજ
તે વિશે બરાબર ક્વિઝ શું આવરે છે અને પ્રશ્નો પ્રકારો કે જે તમે વિચાર જઈ રહ્યાં છો કરશે કહે છે.
ધ્યાનમાં રાખો કે તમે પણ એક વિભાગમાં ક્વિઝ માટે સમીક્ષા તક હશે,
તેથી તમારા TFs કેટલાક અભ્યાસ સમસ્યાઓ ઉપર જઈને જોઈએ,
અને તે અન્ય સારું જોવા માટે તમે જ્યાં પણ આ ક્વિઝ માટે અભ્યાસ કરવાની જરૂર છે તક છે.
ચાલો બિટ્સ 'એન' બાઇટ્સ સાથે શરૂઆતમાં શરૂ કરો.
યાદ રાખો થોડી ખાલી 0 અથવા 1 છે,
અને એક બાઈટ 8 તે બિટ્સની એક સંગ્રહ છે.
ચાલો બિટ્સ આ સંગ્રહ પર અહીં જુઓ.
અમે બહાર આકૃતિ કેટલી બિટ્સ ત્યાં છે કરવાનો પ્રયત્ન કરીશું.
જ્યાં અમે ગણતરી ત્યાં ફક્ત તેમને, 8 આઠ 0 અથવા 1 એકમો.
અને કારણ કે 8 બિટ કે, 1 બાઈટ છે છે,
દો અને તેને હેક્સાડેસિમલ રૂપાંતરિત કરો.
હેક્સાડેસિમલ 16 આધાર છે, અને તે સારુ સરળ કન્વર્ટ
દ્વિસંગી એક નંબર છે, કે જે એ છે કે શું છે હેક્સાડેસિમલ એક નંબર છે.
બધા અમે નથી અમે 4 જૂથો પર નજર,
અને અમે તેમને યોગ્ય હેક્સાડેસિમલ આંકડાના રૂપાંતરિત કરો.
અમે 4 ના જૂથ જમણી સાથે સૌથી શરૂ કરવા માટે, 0011 જેથી.
કે જે એક 1 અને 2 એક છે, કે જેથી એક સાથે કે 3 બનાવે બનશે.
અને પછી ચાલો 4 બીજી બ્લોક જુઓ.
1101. કે જે એક 1, 4, અને તે એક 8 એક જ હશે.
એકસાથે કે 13 છે, જે ડી બનાવે રહ્યું છે
અને અમે યાદ કરીશું કે હેક્સાડેસિમલ આપણે માત્ર 9 મારફતે 0 થતી નથી.
અમે એફ મારફત 0 જાઓ, 9 પછી, જેથી એ 10 અનુલક્ષે,
11 બી વગેરે, એટ જ્યાં એફ 15 છે.
13 અહીં ડી છે,
તેથી તે અક્ષાંશ કન્વર્ટ કરવા માટે બધા અમે અમે ખરેખર છે
2 ની શક્તિ તરીકે દરેક સ્થિતિમાં સારવાર.
કે એક 1, 2 એક, શૂન્ય 4s, 8 શૂન્ય, 16 એક, વગેરે એટ છે,
અને તે થોડું મુશ્કેલ તમારા માથા માં ગણતરી છે, પરંતુ જો આપણે આગામી સ્લાઇડ પર જાઓ
અમે કે જે જવાબ જોઈ શકો છો.
>> અનિવાર્યપણે અમે જમણેથી સમગ્ર જઈ રહ્યાં છો પાછા ડાબી,
અને અમે 2 લગતીવળગતી શક્તિ દ્વારા દરેક આંકડાના ગુણાકાર કરી રહ્યાં છો.
અને યાદ રાખો, હેક્સાડેસિમલ માટે અમે 0x સાથે શરૂઆતમાં આ આંકડાઓ નોંધવા
તેથી અમે તેને અક્ષાંશ નંબર સાથે ગૂંચવવામાં ન નથી.
પર સતત આ એક ASCII ટેબલ છે,
અને અમે શું ASCII અક્ષરો વાપરવા માટે ના સંખ્યાકીય મૂલ્યો સાથે ગોઠવણ છે.
આ ક્રિપ્ટોગ્રાફી pset યાદ રાખો કે અમે તે ASCII કોષ્ટક વ્યાપક ઉપયોગ કરવામાં
ક્રમમાં ક્રિપ્ટોગ્રાફી વિવિધ પદ્ધતિઓનો ઉપયોગ કરવા માટે,
સીઝર અને Vigenère સાઇફર, અલગ અલગ પત્રો કન્વર્ટ
આ વપરાશકર્તા દ્વારા આપવામાં કી અનુસાર શબ્દમાળા છે.
ચાલો તે ASCII ગણિત એક થોડો જુઓ.
અંતે 'પી' અક્ષર સ્વરૂપ કે જે પ્ર હશે માં + 1 છીએ,
યાદ અને '5 '5 ≠ છે.
અને બરાબર અમે કેવી રીતે તે 2 સ્વરૂપો વચ્ચે રૂપાંતરિત કરશે?
તે વાસ્તવમાં ખૂબ હાર્ડ નથી.
ક્રમમાં 5 વિચાર અમે '0 સબ્ટ્રેક્ટ '
કારણ કે ત્યાં '0 વચ્ચે 5 જગ્યાઓ હોય છે, 'અને '5.'
ક્રમમાં અન્ય રીતે આપણે માત્ર 0 ઉમેરવા જાઓ,
તેથી તે નિયમિત અંકગણિત જેવા પ્રકારની છે.
જસ્ટ યાદ રાખો કે જ્યારે કંઈક તેની આસપાસ અવતરણ છે તે પાત્ર છે
અને આમ તે ASCII કોષ્ટકમાં કિંમત અનુલક્ષે છે.
વધુ સામાન્ય કોમ્પ્યુટર વિજ્ઞાન વિષય માં ખસેડી રહ્યા છીએ.
અમે શીખ્યા એક એલ્ગોરિધમ છે શું અને કેવી રીતે અમે પ્રોગ્રામિંગ ઉપયોગ
અલગોરિથમનો અમલ.
એલ્ગોરિધમ્સ કેટલાક ઉદાહરણો ખરેખર જેવા સરળ કંઈક છે
ચકાસણી શું નંબર એકી કે બેકી છે.
કે યાદ અમે 2 દ્વારા નંબર MoD અને તપાસ જો પરિણામ 0 છે.
જો આમ હોય, તો તે પણ છે. જો નહિં, તો તે વિચિત્ર છે.
અને તે ખરેખર એક મૂળભૂત અલ્ગોરિધમનો એક ઉદાહરણ છે.
>> વધુ સામેલ એક એક થોડો દ્વિસંગી શોધ છે,
અમે ઉપર સમીક્ષા સત્ર પછી જઈશ છે.
અને પ્રોગ્રામિંગ શબ્દ અમે અલ્ગોરિધમનો લેવા માટે ઉપયોગ થાય છે
અને તે કોમ્પ્યુટર કોડ રૂપાંતરિત વાંચી શકે છે.
પ્રોગ્રામિંગ અને 2 ઉદાહરણો સ્ક્રેચ છે,
જે અમે શું 0 અઠવાડિયું કર્યું હતું.
તેમ છતાં અમે ખરેખર અણનમ કોડ ટાઇપ તેને અમલમાં એક રીત છે
આ ગણતરીઓ, કે જે નંબરો 1-10 છાપવા છે,
અને અહીં આપણે સી પ્રોગ્રામિંગ ભાષામાં જ નથી.
આ વિધેયાત્મક રીતે સમકક્ષ, માત્ર વિવિધ ભાષાઓ અથવા સિન્ટેક્ષ માં લખાયેલ છે.
પછી અમે બુલિયન સમીકરણો વિશે શીખી,
અને બુલિયન કિંમત છે કે જે ક્યાં તો સાચી કે ખોટી છે છે,
અને અહીં ઘણી વખત નજર બુલિયન સમીકરણો
શરતો ની અંદર જાય છે, તેથી જો (x ≤ 5),
સાથે સાથે, અમે પહેલાથી જ સેટ એક્સ = 5, આથી તે શરત સાચી માટે મૂલ્યાંકન રહ્યું છે.
અને જો તે સાચું છે, કોડ ગમે તે સ્થિતિ નીચે છે
છે કોમ્પ્યુટર દ્વારા મૂલ્યાંકન કરવામાં જવાનું, જેથી શબ્દમાળા પર છપાશે રહ્યું છે
પ્રમાણભૂત આઉટપુટ, અને આ શબ્દ શરત
ગમે તે નિવેદન જો ના કૌંસ અંદર છે ઉલ્લેખ કરે છે.
તમામ ઓપરેટરો યાદ રાખો.
| ભેગા જ્યારે અમે પ્રયાસ કરી રહ્યા છો માટે 2 અથવા વધુ શરતો, | તે && અને યાદ રાખો
== નથી = કે કેમ તેની તપાસ 2 વસ્તુઓ સમાન છે.
યાદ રાખો કે = સોંપણી માટે છે જ્યારે == એક બુલિયન ઓપરેટર છે.
≤, ≥ અને પછી અંતિમ 2 સ્વયંસ્પષ્ટ છે.
બૂલીન લોજિક એ સામાન્ય અહીં સમીક્ષા.
અને બુલિયન અભિવ્યક્તિઓ પણ આંટીઓ મહત્વપૂર્ણ છે,
જે અમે ઉપર હવે જવા પડશે.
અમે આંટીઓ લગભગ 3 પ્રકારના અત્યાર સુધી CS50 માં, વિદ્વાન માટે, જ્યારે, અને આમ કરતી વખતે.
અને તે અગત્યનું છે તે જાણવા માટે કે મોટાભાગના હેતુઓ માટે જ્યારે
અમે ખરેખર લૂપ કોઈપણ પ્રકારની સામાન્ય રીતે ઉપયોગ કરી શકો છો
ત્યાં હેતુઓ અથવા સામાન્ય દાખલાની ચોક્કસ પ્રકારના હોય છે
પ્રોગ્રામિંગ કે જે ખાસ કરીને એક આ લૂપ્સના માટે કૉલ માં
કે તે બનાવવા સૌથી કાર્યક્ષમ અથવા તે રીતે કોડ મનોહર.
ચાલો પર જાઓ આ લૂપ્સના દરેક શું માટે વાપરી શકાય મોટે ભાગે થાય છે.
>> માં લૂપ માટે અમે સામાન્ય રીતે પહેલેથી જ ખબર કેટલી વખત અમે ભારપૂર્વક કહેવું કરવા માંગો છો.
કે અમે શું શરત મૂકી.
માટે, આઇ = 0, આઇ 10 <, ઉદાહરણ તરીકે.
અમે પહેલાથી જ જાણો છો કે અમે 10 વખત કંઈક કરવા માંગો છો.
હવે, જ્યારે લૂપ માટે, સામાન્ય રીતે આપણે જરૂરી નથી
ખબર કેટલી વખત અમે લૂપ ચલાવવા માટે કરવા માંગો છો.
પરંતુ અમે શરત અમુક પ્રકારની ખબર છે કે અમે તે કરવા માંગો છો કરવું
હંમેશા સાચી હોઈ શકે છે અથવા હંમેશા ખોટા હોય છે.
ઉદાહરણ તરીકે, જ્યારે સુયોજિત થયેલ છે.
હવે કહો કે જે બુલિયન ચલ છે.
જ્યારે સાચું આપણે કોડ મૂલ્યાંકન કરવા માંગો છો,
જેથી થોડો વધુ વિસ્તારવા લાયક, લૂપ માટે થોડો વધુ એક કરતાં સામાન્ય બીટ,
પરંતુ લૂપ માટે કોઇ પણ જ્યારે લૂપ રૂપાંતરિત કરી શકાય છે.
છેલ્લે નથી, જ્યારે આંટીઓ, કે જે trickiest પ્રયત્ન અધિકાર દૂર સમજાવવાનો શકે છે,
ઘણીવાર ઉપયોગ થાય છે જ્યારે અમે કોડ પ્રથમ મૂલ્યાંકન કરવા માંગો છો
પ્રથમ વખત પહેલાં અમે શરત તપાસો.
માટે સામાન્ય ઉપયોગ કેસ કરતા હો ત્યારે લૂપ
જ્યારે તમે વપરાશકર્તા ઈનપુટ વિચાર કરવા માંગો છો, અને તમે જાણો છો કે તમે વપરાશકર્તા પૂછવા માગો છો
ઈનપુટ માટે ઓછામાં ઓછી એકવાર, પરંતુ જો તેઓ તમને સારું ઇનપુટ આપતા નથી અધિકાર દૂર
તમે તેમને પૂછ્યા સુધી તેઓ તમને સારા ઇનપુટ આપી રાખવા માંગો છો.
કે જે સૌથી સામાન્ય ઉપયોગ જ્યારે લૂપ છે નથી,
દો અને આ લૂપ્સના વાસ્તવિક માળખું જુઓ.
સામાન્ય રીતે તેઓ હંમેશા આ પદ્ધતિઓને અનુસરે વલણ ધરાવે છે.
>> અંદર માટે લૂપ પર તમે 3 ઘટકો હોય છે:
આરંભ, જેમ કે ખાસ કરીને કંઈક પૂર્ણાંક હું = 0 જ્યાં i ગણક છે,
શરત છે, જ્યાં અમે કહી લૂપ માટે આ સ્કોર અને આ સ્થિતિ હજી પણ ધરાવે સુધી માંગો છો,
હું 10 <, અને પછી છેવટે સુધારા, કે જે અમે કેવી રીતે વધારો જેવી
લૂપમાં દરેક સમયે કાઉન્ટર ચલ.
સામાન્ય ત્યાં જોવા વસ્તુ માત્ર હું + + છે,
જે હું 1 દ્વારા દર વખતે વધારો થાય છે.
તમે પણ મને + + = 2 કંઈક કરી શકે,
જેનો અર્થ છે કે હું 2 દરેક વખતે જ્યારે તમે લૂપ દ્વારા જાઓ ઉમેરો.
અને પછી આવું તો કોઈપણ કોડ કે જે વાસ્તવમાં લૂપ ભાગ તરીકે ચલાવે ઉલ્લેખ કરે છે.
અને જ્યારે લૂપ માટે, આ સમય અમે ખરેખર લૂપની બહાર પ્રારંભ છે,
તેથી, ઉદાહરણ તરીકે, ચાલો કહેવું અમે લૂપ જ પ્રકાર તરીકે હું માત્ર વર્ણવેલ કરવા પ્રયાસ કરી રહ્યા છો.
અમે કહ્યું પૂર્ણાંક હું = 0 પહેલાં લૂપ શરૂ થાય છે.
પછી અમે જ્યારે હું 10 <આવું કહેવું શકે છે,
તેથી પહેલાં તરીકે કોડ જ બ્લોક,
અને આ સમય કોડ સુધારો ઉદાહરણ તરીકે, ભાગ, આઇ + +,
વાસ્તવમાં લૂપની અંદર જાય છે.
અને છેલ્લે, માટે એક કરતા હો ત્યારે, તે જ્યારે લૂપ માટે સમાન છે,
પરંતુ અમે યાદ રાખો કે આ કોડ એકવાર મૂલ્યાંકન કરશે
પહેલાં શરત ચકાસાયેલ છે, તેથી તે ઘણો વધારે અર્થપૂર્ણ બને છે
જો તમે નીચે ટોચના ક્રમમાં તે જુઓ.
એક કરતા હો ત્યારે લૂપ કોડ મૂલ્યાંકન પહેલાં તમે પણ જ્યારે સ્થિતિ પર નજર,
જ્યારે લૂપ જ્યારે, તે પ્રથમ ચકાસે છે.
નિવેદનો અને ચલો.
જ્યારે અમે નવા ચલ બનાવવા માંગો છો તો અમે પ્રથમ તે પ્રારંભ કરવા માંગો છો.
>> ઉદાહરણ તરીકે, પૂર્ણાંક પટ્ટી ચલ બાર પ્રારંભ,
પરંતુ તેને એક મૂલ્ય આપતી નથી, તેથી શું માતાનો બાર કિંમત હવે છે?
અમે નથી જાણતા.
કેટલાક કચરો કિંમત છે કે જે પહેલાં મેમરી હતું ત્યાં સંગ્રહિત હોઈ શકે છે,
અને અમે તે ચલ વાપરવા માંગો નહિં
ત્યાં સુધી અમે ખરેખર તે કિંમત આપે છે,
કે જેથી અમે તેને અહીં જાહેર.
પછી અમે તેને 42 નીચે હોઈ પ્રારંભ.
હવે, અલબત્ત, આપણે જાણીએ છીએ કે આ એક લીટી પર, પૂર્ણાંક 42 = બાધ કરી શકાય છે.
પરંતુ ફક્ત બહુવિધ પગલાંઓ કે જે રહ્યું હોય સાફ કરવા માટે,
જાહેરાત અને પ્રારંભ અલગ અહીં થાય છે.
તે એક પગલું પર થાય છે, અને આગામી એક પૂર્ણાંક baz બાધ = 1 +
આ નીચે નિવેદન, આ કોડ બ્લોક ઓવરને અંતે જેથી ઇન્ક્રીમેન્ટ baz,
જો અમે baz મૂલ્ય છાપો હતા તે 44 થશે
કારણ કે અમે જાહેર અને તે પ્રારંભ માટે 1> બાર હોય છે,
અને પછી અમે તેની સાથે વધુ એક વખત વધારો એ + +.
અમે આ ખૂબ થોડા સમય પર ગયા, પરંતુ તે સારી છે એક સામાન્ય હોય છે
સૂત્રો અને ઘટનાઓ શું છે તે સમજવામાં.
અમે મુખ્યત્વે સ્ક્રેચ આવું કર્યું,
જેથી તમે થ્રેડ્સના કોડ બહુવિધ સિક્વન્સ તરીકે વિચાર કરી શકો છો
તે જ સમયે ચાલી રહ્યું છે.
વાસ્તવિકતા, તે કદાચ આ જ સમયે ચાલી રહ્યુ છે,
પરંતુ પ્રકારના અમૂર્ત અમે તે છે કે તે રીતે વિચાર કરી શકો છો.
>> સ્ક્રેચ, ઉદાહરણ તરીકે, અમે બહુવિધ sprites હતી.
તે જ સમયે વિવિધ કોડ શકાય ચલાવવા શકે છે.
એક, જ્યારે અન્ય કંઈક કહી રહ્યાં છે વૉકિંગ શકાય છે
સ્ક્રીન વિવિધ ભાગ છે.
ઘટનાઓ બહાર તર્ક અલગ અન્ય રીત છે
તમારો કોડ વિવિધ ઘટકો વચ્ચે,
અને સ્ક્રેચ માં અમે ઘટનાઓ અનુકરણ બ્રોડકાસ્ટ મદદથી સમર્થ હતા,
અને તે ખરેખર છે જ્યારે હું પ્રાપ્ત હું સાંભળો જ્યારે,
પરંતુ તે એક આવશ્યક માહિતી ટ્રાન્સમિટ કરવાનો માર્ગ છે
એક સ્પ્રાઈટ બીજા.
ઉદાહરણ માટે, તમે રમત વહન પર કરી શકો છો,
અને જ્યારે અન્ય સ્પ્રાઈટ રમત પર મેળવે છે,
તે ચોક્કસ રીતે પ્રતિક્રિયા આપે છે.
તે મહત્વનું છે પ્રોગ્રામિંગ માટે સમજી મોડલ છે.
માત્ર આધારભૂત 0 અઠવાડિયું પર જવા માટે, અમે શું બન્યું છે જેથી કરીને અત્યાર સુધી,
ચાલો આ સરળ સી કાર્યક્રમ જુઓ.
લખાણ અહીં થોડું નાના બીટ હોઇ શકે, પણ હું તેની પર જાઓ ખરેખર ઝડપી પડશે.
અમે 2 ટોચ cs50.h, અને stdio.h અંતે હેડર ફાઈલો સહિત રહ્યા છો.
પછી અમે સતત કહેવાય મર્યાદા વ્યાખ્યાયિત કરી રહ્યા છીએ 100 છે.
પછી અમે અમારી મુખ્ય કાર્ય અમલ કરી રહ્યા છીએ.
કારણ કે આપણે આદેશ વાક્ય દલીલો ઉપયોગ કરતા નથી અમે રદબાતલ મુકવાની જરૂર છે
મુખ્ય માટે દલીલો તરીકે.
અમે મુખ્ય ઉપર પૂર્ણાંક જુઓ. કે વળતર પ્રકાર છે, તેથી તળિયે 0 આવો.
અને અમે CS50 પુસ્તકાલય કાર્ય ઉપયોગ કરી રહ્યાં છો પૂર્ણાંક વિચાર
ઇનપુટ માટે વપરાશકર્તા પૂછો, અને અમે તેને આ ચલ x માં સંગ્રહે,
તેથી અમે એક્સ ઉપર જાહેર કરો, અને અમે તેને એક્સ = GetInt સાથે પ્રારંભ.
>> પછી અમે જોવા માટે જો વપરાશકર્તા આપણને સારા ઇનપુટ આપ્યો તપાસો.
જો તે ≥ LIMIT અમે માટે 1 ભૂલ કોડ આવો અને એક ભૂલ સંદેશો છાપો કરવા માંગો છો.
અને છેલ્લે, જો વપરાશકર્તા અમને આપવામાં આવી છે સારું ઇનપુટ
અમે નંબર સ્ક્વેર અને તે પરિણામે છાપી રહ્યા છીએ.
જસ્ટ ખાતરી કરો કે તે તમામ હિટ ઘર
તમે અહીં કોડ વિવિધ ભાગો લેબલો જોઈ શકો છો.
હું સતત, હેડર ફાઈલો ઉલ્લેખ કર્યો છે.
ઓહ, પૂર્ણાંક એક્સ. માટે યાદ રાખો કે એક સ્થાનિક ચલ છે તેની ખાતરી કરો.
કે તે એક વૈશ્વિક ચલ ના વિરોધાભાસ, જે અમે વિશે વાત કરીશું
પાછળથી થોડો સમીક્ષા સત્ર માં,
અને અમે પુસ્તકાલય કાર્ય printf ફોન આવે છે,
તેથી જો આપણે stdio.h હેડર ફાઈલ સમાવેશ થતો નથી કર્યું હતું
અમે printf કહી શકશે નહીં.
અને હું માનું છું કે તીર કે કાપી મળ્યો અહીં% d માટે પોઇન્ટ છે,
જે printf માં ફોર્મેટિંગ શબ્દમાળા છે.
તે કહે છે એક નંબર, ડી% તરીકે આ ચલ છાપો.
અને તે 0 અઠવાડિયું માટે છે.
હવે લુકાસ ચાલુ રાખવા માટે જઈ રહ્યો છે.
અરે, ગાય્સ. મારું નામ લુકાસ છે.
હું કેમ્પસ, માથેર પર શ્રેષ્ઠ ઘર માં અભ્યાસ કરે છું,
અને હું 1 અઠવાડિયું અને 2.1 વિશે થોડુંક વાત જાઉં છું.
[1 અઠવાડિયું અને 2.1!] [લુકાસ Freitas]
તરીકે Lexi જણાવ્યું હતું કે, આવી હતી જ્યારે અમે સ્ક્રેચ માંથી સી તમારી કોડ અનુવાદ શરૂ
એક વસ્તુઓ છે કે જે અમે નોંધ્યું છે કે તમે આ કરી શકો છો ફક્ત નથી કે
તમારો કોડ લખવા અને તેને ચલાવવા માટે એક લીલો ધ્વજ હવે મદદથી.
ખરેખર, તમે અમુક પગલાંઓ ઉપયોગ તમારા સી કાર્યક્રમ બનાવવા હોય
એક્ઝિક્યુટેબલ ફાઇલ બને છે.
મૂળભૂત રીતે તમે જ્યારે તમે કાર્યક્રમ લખી રહ્યાં છે કે શું
તમે એક ભાષા કે જે કમ્પાઇલર સમજી શકે તમારા વિચાર અનુવાદ કરો,
તેથી જ્યારે તમે સી એક કાર્યક્રમ લખી રહ્યાં
તમે શું કરી રહ્યા ખરેખર કંઈક લખવાનું છે કે તમારા કમ્પાઇલર સમજવા રહ્યું છે,
અને પછી કમ્પાઇલર કે કોડ અનુવાદ રહ્યું છે
કંઈક કે જે તમારા કમ્પ્યુટરને સમજશે માં.
>> અને આ વસ્તુ, તમારા કમ્પ્યુટર છે તે ખરેખર ખૂબ મૂક.
તમારા કમ્પ્યુટર માત્ર 0s અને 1 સે સમજી શકે,
તેથી વાસ્તવમાં પ્રથમ કમ્પ્યુટર્સ લોકો સામાન્ય રીતે પ્રોગ્રામ
0s અને 1 સે, પરંતુ હવે વાપરી રહ્યા હોય, ભગવાન આભાર.
અમે 0s અને 1 સે માટે સિક્વન્સ યાદ ન હોય
લૂપ માટે અથવા જ્યારે લૂપ અને તેથી એક છે.
તેથી જ અમે કમ્પાઇલર છે.
કમ્પાઇલર કરે છે શું છે તે મારાથી સી કોડ અનુવાદ કરે છે,
અમારા કિસ્સામાં, એક ભાષા કે જે તમારા કમ્પ્યુટરને સમજી કરશે,
જે પદાર્થ કોડ છે, અને ત્યારે કમ્પાઇલર છે કે અમે ઉપયોગ કરી રહ્યાં છો છે
છે રણકાર કહેવાય છે, તેથી આ ખરેખર રણકાર માટે પ્રતીક છે.
જ્યારે તમે તમારા કાર્યક્રમ છે, તો તમે 2 વસ્તુઓ હોય છે.
પ્રથમ, તમે તમારા કાર્યક્રમ કમ્પાઇલ હોય છે, અને તે પછી તમે તમારા કાર્યક્રમ ચલાવવા જઈ રહ્યાં છો.
તમારા કાર્યક્રમ કમ્પાઇલ તમે વિકલ્પો ઘણાં આવું હોય છે.
પ્રથમ એક રણકાર program.c નથી
જેમાં કાર્યક્રમ તમારા કાર્યક્રમ નામ છે.
આ કિસ્સામાં તમે તેઓ માત્ર કહી રહ્યાં છે જોઈ શકે છે "હેય, મારા કાર્યક્રમ કમ્પાઇલ."
તમે નથી કહેતા કે કંઈપણ "હું મારા કાર્યક્રમ માટે આ નામ માંગો છો" રહ્યા છો.
>> બીજા વિકલ્પ તમારા કાર્યક્રમ માટે એક નામ આપી રહી છે.
તમે રણકાર-o અને પછી એ નામ છે જે તમે કરવા માંગો છો કહી શકીએ
એક્ઝેક્યુટેબલ ફાઈલ તરીકે અને પછી program.c શકાય નામ આપવામાં આવ્યું છે.
અને તમે પણ કાર્યક્રમ બનાવવા શું કરી શકો છો, અને જુઓ પ્રથમ 2 કિસ્સાઓમાં કેવી રીતે
હું મૂકો. કેચ અને ત્રીજી એક હું માત્ર કાર્યક્રમો છે?
અરે વાહ, તમે ખરેખર નથી. કેચ મૂકી જ્યારે તમે બનાવવા ઉપયોગ કરવો જોઈએ.
તો કમ્પાઇલર ખરેખર તમે કિકિયારી રહ્યું છે.
અને પણ, હું જો તમે ગાય્સ યાદ ખબર નહિં હોય,
પરંતુ વખત અમે પણ અથવા એલએમ ઉપયોગ-lcs50 ઘણો.
કે લિંક કહેવામાં આવે છે.
તે માત્ર ત્યારે કમ્પાઇલર કહે છે કે તમે તે લાઈબ્રેરીઓ અધિકાર ત્યાં ઉપયોગ કરશે,
તેથી જો તમે cs50.h ઉપયોગ કરવા માંગો છો તમે ખરેખર લખો હોય
program.c-lcs50 રણકાર.
જો તમે તે નથી, પણ કમ્પાઇલર જાણવા નથી જઈ રહ્યા
કે તમે cs50.h. તે કાર્યો ઉપયોગ કરી રહ્યાં છો
અને જ્યારે તમે તમારા કાર્યક્રમ ચલાવવા માટે તમારે 2 વિકલ્પો છે કરવા માંગો છો.
જો તમે રણકાર program.c કર્યું તમે તમારા કાર્યક્રમ માટે એક નામ આપી ન હતી.
તમે તેને ચલાવવા માટે a.out. / મદદથી હોય છે.
A.out પ્રમાણભૂત નામ કે રણકાર તમારા કાર્યક્રમ આપે છે જો તમે તેને એક નામ આપી નથી.
અન્યથા તમે /. કાર્યક્રમ કરવા જઈ રહ્યાં છો જો તમે તમારી કાર્યક્રમ નામ આપ્યું,
અને પણ જો તમે કાર્યક્રમ નામ ઉપસ્થિત કર્યો હતો કે એક કાર્યક્રમ મેળવવા રહ્યું છે
પહેલાંથી જ આ કેચ ફાઈલ જેવી જ નામ પ્રોગ્રામ હશે.
તો પછી અમે ડેટા પ્રકારો અને માહિતી વિશે વાત કરી.
>> મૂળભૂત માહિતી પ્રકારો થોડું બોક્સ તેઓ વાપરો એ જ વસ્તુ છે
માટે કિંમતો સંગ્રહ, જેથી ડેટા પ્રકારો Pokémons જેમ જ ખરેખર છે.
તેઓ બધા માપો અને પ્રકારો આવે છે.
હું જો કે સાદ્રશ્ય અર્થમાં બનાવે છે ખબર નથી.
આ માહિતી કદ ખરેખર મશીન આર્કીટેક્ચર પર આધાર રાખે છે.
બધા માહિતી માપો કે હું અહીં બતાવવા માટે જાઉં છું
મશીન 32-bit છે, કે જે અમારા સાધન કિસ્સામાં છે ખરેખર છે,
પરંતુ જો તમે ખરેખર તમારા Mac અથવા Windows માં પણ કોડિંગ છે
કદાચ તમે મશીન 64-bit છે જઈ રહ્યાં છો,
જેથી યાદ રાખો કે આ માહિતી માપો કે હું જાઉં છું અહીં બતાવવા માટે
મશીન 32-bit માટે છે.
પ્રથમ એક કે અમે જોયું પૂર્ણાંક હતી,
જે ખૂબ જ સીધું છે.
તમારે એક પૂર્ણાંક સ્ટોર પૂર્ણાંક વાપરો.
અમે પણ અક્ષર છે, ઘરનાં પરચૂરણ કામો થયો છે.
જો તમે અક્ષર અથવા નાની પ્રતીક ઉપયોગ કરવા માંગો છો તો તમે કદાચ એક કોલસો બનાવો ઉપયોગ જઈ રહ્યાં છો.
એ ઘરનાં પરચૂરણ કામો 1 બાઇટ, કે જે Lexi જણાવ્યું હતું કે જેમ 8 બીટ્સ, એનો અર્થ એ થાય છે.
મૂળભૂત રીતે અમે તે ASCII કોષ્ટક કે જે 256 છે પાસે
0s અને 1 સે શક્ય સંયોજનો,
અને પછી જ્યારે તમે ઘરનાં પરચૂરણ કામો લખો તેને અનુવાદિત રહ્યું છે
અક્ષર કે તમે નંબર છે કે જે તમે ASCII કોષ્ટકમાં Lexi જેવા હોય છે ઇનપુટ્સ જણાવ્યું હતું.
અમે પણ ફ્લોટ છે, કે જે અમે અક્ષાંશ નંબરો સ્ટોર કરવા ઉપયોગ કરે છે.
જો તમે 3.14 પસંદ કરો માંગો છો, ઉદાહરણ તરીકે, તમે ફ્લોટ ઉપયોગ જઈ રહ્યાં છો
અથવા ડબલ વધુ ચોકસાઇ ધરાવે છે.
એક ફ્લોટ 4 બાઇટ્સ છે.
એક ડબલ 8 બાઇટ્સ હોય છે, તેથી માત્ર તફાવત એ ચોકસાઇ છે.
અમે પણ લાંબા કે પૂર્ણાંકો માટે વપરાય છે,
અને તમે એક મશીન 32-bit માટે જુઓ પૂર્ણાંક અને લાંબી જ માપ છે,
તેથી તે ખરેખર અર્થમાં નથી એક મશીન 32-bit લાંબા વાપરો.
>> પરંતુ જો તમે મેક અને 64-bit મશીન ઉપયોગ કરી રહ્યાં છો, ખરેખર લાંબા 8 કદ ધરાવે છે,
તેથી તે ખરેખર આર્કીટેક્ચર પર આધાર રાખે છે.
મશીન 32-bit માટે સૂઝ ન બનાવવા માટે લાંબા ખરેખર ઉપયોગ કરતું નથી.
અને પછી લાંબા લાંબા, બીજી બાજુ, 8 બાઇટ્સ હોય છે,
તેથી તે ખૂબ સારી છે જો તમે લાંબા સમય સુધી પૂર્ણાંક માંગો છો.
અને છેલ્લે, અમે શબ્દમાળા હોય છે, જે વાસ્તવમાં એક કોલસો બનાવો * છે,
જે ઘરનાં પરચૂરણ કામો માટે નિર્દેશક છે.
તે ખૂબ જ સરળ છે લાગે છે કે શબ્દમાળા માપ જેવા રહ્યું છે
અક્ષરો નંબર કે તમે ત્યાં છે,
પરંતુ હકીકતમાં ઘરનાં પરચૂરણ કામો * પોતે
ચાર રચે છે, જે 4 બાઇટ્સ છે નિર્દેશક કદ ધરાવે છે.
ચાર રચે છે * કદ 4 બાઇટ્સ છે.
જો તમે નાની શબ્દ અથવા અક્ષર અથવા કંઈપણ હોય તો કોઈ વાંધો નથી.
તે 4 બાઇટ્સ જ હશે.
અમે પણ કાસ્ટિંગ વિશે થોડુંક વિદ્વાન,
જેથી તમે જોઈ શકો છો, જો તમારી પાસે છે, ઉદાહરણ તરીકે, એક કાર્યક્રમ છે કે જે કહે છે
પૂર્ણાંક x 3 = અને પછી printf ("% d", એક્સ / 2)
શું તમે જાણીએ છીએ કે તે શું સ્ક્રીન પર છાપી રહ્યું છે?
>> કોઇકે >> [વિદ્યાર્થીઓ] 2.
1. 1 >>, હા.
જ્યારે તમે / 3 2 કરવું તે 1.5 વિચાર ચાલી રહ્યું છે,
પરંતુ ત્યાર બાદ અમે એક પૂર્ણાંક ઉપયોગ કરી રહ્યા છો તે અક્ષાંશ ભાગ અવગણો ચાલી રહ્યું છે,
અને તમે માટે 1 હોય રહ્યા છીએ.
જો તમે તે થાય, તમે શું કરી શકો છો, દાખલા તરીકે, નથી માંગતા,
છે ફ્લોટ જાહેર વાય = x.
પછી x કે 3 પ્રયત્ન ઉપયોગ હવે વાય માં 3,000 પ્રયત્ન રહ્યું છે.
અને તે પછી તમને વાય / 2 છાપી શકો છો.
ખરેખર, હું એક 2 હોવો જોઈએ. ત્યાં ઉપર.
તે 3.00/2.00 કરી રહ્યું છે,
અને તમે 1.5 વિચાર જઈ રહ્યાં છો.
અને અમે આ .2 f હોય માત્ર અક્ષાંશ ભાગ 2 માં રેખાંશ એકમો માટે કહો.
જો તમે .3 એફ હોય તે ખરેખર 1,500 હોય બનશે.
જો તે 2 તે 1.50 જ હશે.
અમે પણ આ કેસ અહીં છે.
જો તમે ફ્લોટ કરવા એક્સ 3.14 = અને પછી તમે printf એક્સ
તમે 3.14 વિચાર જઈ રહ્યાં છો.
અને જો તમે એક્સ = x ની પૂર્ણાંક,
જે પૂર્ણાંક તરીકે એક્સ સારવાર અર્થ થાય છે અને તમે હવે એક્સ છાપો
તમે 3.00 પાસે જઈ રહ્યાં છો.
એ નથી કે સૂઝ છે?
કારણ કે તમે પ્રથમ પૂર્ણાંક તરીકે રહ્યાં છો એક્સ સારવાર, તેથી તમે રેખાંશ ભાગ અવગણી રહ્યાં છો,
અને પછી તમે એક્સ છાપવા કરી રહ્યાં છો.
અને આખરે, તમે પણ કરી શકો છો,
પૂર્ણાંક એક્સ = 65, અને પછી તમે એક કોલસો બનાવો કેચ = x જાહેર,
અને પછી જો તમે કો છાપી તમે ખરેખર મેળવવા જઈ રહ્યાં છો
એ, જેથી મૂળભૂત શું તમે અહીં કરી રહ્યા છીએ
છે અક્ષર માં પૂર્ણાંક અનુવાદ,
જેમ કે તે ASCII કોષ્ટક કરે છે.
અમે પણ ગણિત ઓપરેટરો વિશે વાત કરી.
તેમાંના મોટા ભાગના ખૂબ સરળ છે, તેથી + +, -, *, /,
અને અમે પણ મોડ, જે 2 નંબરો એક વિભાગ બાકીની છે તે વિશે વાત કરી હતી.
જો તમે 10 3 ઉદાહરણ તરીકે%, છે,
તો એનો અર્થ એ 3 દ્વારા 10 વહેંચી અને બાકીની શું છે?
તે માટે 1 જ હશે, તેથી તે ખરેખર કાર્યક્રમો ઘણો માટે ખૂબ જ ઉપયોગી છે.
Vigenère અને સીઝર માટે હું ખૂબ ખાતરી કરો કે તમે ગાય્સ તમામ મોડ ઉપયોગ છું.
ગણિત ઓપરેટરો વિશે, ખૂબ કાળજી રાખો જ્યારે * અને / સંયોજન.
>> ઉદાહરણ તરીકે, જો તમે (2/3) * 2 તમે શું મેળવવા જવું છે?
[2 વિદ્યાર્થીઓ].
અરે વાહ, 2/2 3 કારણ 1.5 પ્રયત્ન રહ્યું છે,
પરંતુ કારણ કે તમે 2 પૂર્ણાંકો વચ્ચે કામગીરી કરી રહ્યા છીએ
તમે ખરેખર માત્ર રહ્યાં છો માટે 1 ધ્યાનમાં જવાનું,
અને પછી 1 2 * 2 માટે પ્રયત્ન રહ્યું છે, તેથી ખૂબ, ખૂબ કાળજી રાખો
જ્યારે પૂર્ણાંકો સાથે અંકગણિત કરી કારણ કે
તમે 2 કે = 3 કે કિસ્સામાં, વિચાર કરી શકે છે.
અને પણ ખૂબ જ પ્રાધાન્ય વિશે કાળજી રાખો.
તમે સામાન્ય રીતે કૌંસ વાપરવા માટે ખાતરી કરો કે તમે જાણો છો કે તમે શું કરી રહ્યાં છો પ્રયત્ન કરીશું.
કેટલાક ઉપયોગી શોર્ટકટ્સ, અલબત્ત, એક હું + + + + અથવા i = 1 છે
અથવા મદદથી + + =.
કે હું = 1 + કરવાથી તરીકે જ ચીજ છે.
તમે પણ મને કરી શકે છે - અથવા i - 1 =,
જે હું = -1 તરીકે આ જ વાત છે,
કંઈક તમે ગાય્સ આંટીઓ માટે ઘણો ઉપયોગ કરે છે, ઓછામાં ઓછું.
પણ * માટે, જો તમે વાપરવા * = અને જો તમે કરો, ઉદાહરણ તરીકે,
હું * 2 = હું = 2 * જણાવ્યું હતું તે જ વસ્તુ છે,
અને વિભાગ માટે આ જ બાબત.
જો તમે / i = 2 કરવું તે મને = / i 2 તરીકે જ વાત છે.
>> હવે કાર્યો વિશે.
તમે ગાય્સ જોયું કે વિધેયો એ ખૂબ સારો કોડ સેવ વ્યૂહરચના છે
જ્યારે તમે પ્રોગ્રામિંગ કરી રહ્યાં છો, તેથી જો તમે એ જ કાર્ય કરવા માંગો
કોડ ફરીથી અને ફરીથી, કદાચ તમે કાર્ય ઉપયોગ કરવા માંગો છો
માત્ર જેથી તમે નકલ અને અને ફરીથી કોડ પેસ્ટ નથી.
ખરેખર, મુખ્ય કામગીરી છે, અને જ્યારે હું તમને કાર્ય બંધારણ દર્શાવે છે
તમે એ જોવા માટે કે જે ખૂબ સ્પષ્ટ છે જઈ રહ્યાં છો.
અમે પણ કેટલાક પુસ્તકાલયો માંથી વિધેયો વાપરવા માટે,
ઉદાહરણ તરીકે, printf, GetIn છે, કે જે CS50 પુસ્તકાલય છે,
અને toupper જેવા અન્ય કાર્ય કરે છે.
તે બધા વિધેયોને ખરેખર અન્ય લાઈબ્રેરીઓમાં લાગુ પાડવામાં આવે છે,
અને જ્યારે તમે તમારા કાર્યક્રમ ની શરૂઆતમાં તે દામણ ફાઈલોને મૂકવામાં
તમે કહેતા કે તમે મને તે કાર્યો માટે કોડ આપવા કૃપા કરીને કરી શકો છો
તેથી હું તેમને મારી જાતને દ્વારા અમલ નથી?
અને તમે પણ તમારા પોતાના કાર્યો લખી શકો છો, જેથી જ્યારે તમે પ્રોગ્રામિંગ શરૂ
તમે સમજો કે લાઈબ્રેરીઓ બધા વિધેયો કે જે તમને જરૂર નથી.
છેલ્લા pset માટે, ઉદાહરણ તરીકે, અમે ડ્રો, ચઢાઇને, અને લુકઅપ લખ્યું હતું,
અને તે ખૂબ જ ખૂબ જ મહત્વપૂર્ણ છે માટે વિધેયો લખી કરવાનો પ્રયત્ન
કારણ કે તેઓ ઉપયોગી છે, અને અમે તેમને પ્રોગ્રામિંગ તમામ સમય વાપરે છે,
અને તે કોડ ઘણો સાચવે છે.
એક કાર્ય બંધારણ આ છે.
અમે શરૂઆતમાં વળતર પ્રકાર હોય છે. પરત પ્રકાર શું છે?
તે ફક્ત ત્યારે તમારા કાર્ય પર પાછા જઈ રહ્યું છે.
જો તમે ઉદાહરણ માટે એક કાર્ય, કારણદર્શી હોય છે,
કે પૂર્ણાંક એક કારણદર્શી ગણતરી રહ્યું છે,
કદાચ તે એક પૂર્ણાંક પણ પરત ચાલી રહ્યું છે.
પછી પરત પ્રકાર માટે પૂર્ણાંક હોવો રહ્યું છે.
Printf ખરેખર વળતર પ્રકાર રદબાતલ છે
કારણ કે તમે કંઈપણ પરત કરી રહ્યાં છો.
તમે હમણાં જ સ્ક્રીન પર કરી રહ્યાં છો વસ્તુઓ છાપવા
અને કાર્ય પછીથી છોડી.
પછી તમારે કાર્ય કે જે તમે પસંદ કરી શકો છો નું નામ છે.
તમે થોડું વાજબી હોઈ શકે છે, જેમ કે xyz જેવા એક નામ પસંદ કરો નહિં જોઈએ
અથવા x2f જેવા હોય છે.
એક નામ છે જે અર્થમાં બનાવે બનાવવા પ્રયાસ કરો.
>> ઉદાહરણ તરીકે, જો તે કારણદર્શી છે, કારણદર્શી કહો.
જો તે કાર્ય છે કે જે કંઈક દોરવા રહ્યું છે છે નામ, તે દોરે છે.
અને પછી અમે પરિમાણો, જે પણ દલીલો કહેવામાં આવે છે છે,
જે સ્રોતો છે કે જે તમારા કાર્ય જરૂર જેવા છે
તમારો કોડ તેના કાર્ય કરવા માટે.
જો તમે નંબર કારણદર્શી ગણતરી કરવા માંગો છો
કદાચ તમે નંબર હોય ફેક્ટોરિયલ ગણતરી કરવાની જરૂર છે.
એક દલીલો કે તમે જઈ રહ્યાં છો સંખ્યા પોતે છે.
અને પછી તેને કંઈક અને અંતે કિંમત પાછી ચાલી રહ્યું છે
જ્યાં સુધી તે રદબાતલ કાર્ય છે.
ચાલો એક ઉદાહરણ જુઓ.
જો હું કોઇ કાર્ય કે પૂર્ણાંકો ઝાકઝમાળ બધી સંખ્યાઓ જણાવે લખવા માંગો છો,
સૌ પ્રથમ, પરત પ્રકાર માટે પૂર્ણાંક હોવો રહ્યું છે
કારણ કે હું પૂર્ણાંકો ઝાકઝમાળ છે.
અને પછી હું sumArray જેમ કાર્ય નામ પણ જાઉં છું,
અને પછી તે એરે પોતે લઇ રહ્યું છે તે પૂર્ણાંક nums માટે,
અને પછી એરે તેથી મને ખબર છે કેટલા નંબરો હું સંક્ષેપમાં હોય લંબાઈ.
પછી હું ઉદાહરણ માટે એક ચલ કહેવાય સરવાળો, 0 થી, પ્રારંભ છે,
અને દર વખતે હું એરે એક તત્વ જુઓ હું તે રકમ ઉમેરવા, જેથી કરીશું હું લૂપ માટે એક હતી.
જેમ Lexi જણાવ્યું હતું કે, તમે આમ પૂર્ણાંક હું = 0, i <લંબાઈ i અને + +.
અને એરે દરેક તત્વ માટે હું રકમ + + = nums [i] હતી,
અને પછી હું રકમ પરત છે, તેથી તે ખૂબ જ સરળ છે, અને તે કોડ ઘણો બચાવે છે
જો તમે આ કાર્ય સમય ઘણો ઉપયોગ કરી રહ્યાં છો.
તો પછી અમે શરતો પર એક નજર લીધો હતો.
અમે જો કે, એ હોય છે, અને બીજું જો.
ચાલો શું તે વચ્ચેનો તફાવત છે.
આ 2 કોડ પર એક નજર. તેમની વચ્ચે શું તફાવત છે?
પ્રથમ એક મૂળભૂત છે કોડ્સ કે જે તમે કહો કરવા માંગો છો
, અથવા 0 - જો નંબર + છે.
પ્રથમ એક કહે છે, જો તે 0> છે પછી તે હકારાત્મક છે.
જો તે 0 થી = છે પછી તેને 0 છે, અને જો તે 0 <છે પછી તે નકારાત્મક છે.
>> અને અન્ય એક જો કે, એ જો, બીજું કરવાનું છે.
બંને વચ્ચે આ તફાવત એ છે કે આ એક ખરેખર રહ્યું છે
તપાસો જો> 0, <= 0 0 અથવા ત્રણ વખત,
તેથી જો તમે 2 નંબર હોય છે, ઉદાહરણ તરીકે, તે માટે અહીં આવે છે અને કહે છે ચાલી રહ્યું છે
(x 0>) જો, અને તે માટે હા કહી રહ્યું છે, જેથી હું સકારાત્મક છાપો.
પરંતુ છતાં પણ મને ખબર છે કે તે 0> છે અને તે માટે 0 0 અથવા <ન ચાલી રહ્યું છે
હું હજુ પણ કરવા જઈ રહ્યો છું તે 0 છે, તે છે <0,
તેથી હું ખરેખર IFS ની અંદર જઈ રહ્યો છું કે હું ન હતી
કારણ કે હું પહેલેથી જ ખબર છે કે તે આ શરતો કોઇ પણ સંતુષ્ટ નથી ચાલી રહ્યું છે.
હું જો વાપરવા માટે, બીજું તો, બીજું નિવેદન.
તે વાસ્તવમાં કહે જો એક્સ = 0 હું સકારાત્મક છાપો.
જો તે નથી, હું પણ આ પરીક્ષણ જાઉં છું.
જો તે 2 છે આ નથી છું હું જાઉં.
મૂળભૂત રીતે જો હું x = 2 હતી તમે કહ્યું
જો (x 0>), હા, તેથી આ છાપો.
હવે મને ખબર છે કે તે 0> છે અને તે જો પ્રથમ સંતુષ્ટ
હું પણ આ કોડ ચાલી નથી જવું છું.
આ કોડ વધુ ઝડપથી ચાલે છે, વાસ્તવમાં, 3 ગણો ઝડપી જો તમે આ વાપરો.
અમે પણ અને અને અથવા શીખ્યા.
હું આ મારફતે જાઓ કારણ કે Lexi પહેલેથી જ તેમને વિશે વાત કરી નથી માંગવાનો.
તે ફક્ત જે && અને | | ઓપરેટર.
>> આ જ વસ્તુ હું કહી શકશો છે સાવચેત રહો જ્યારે તમે 3 શરતો હોય છે.
કૌંસ વાપરો કારણ કે તે ખૂબ જ ગૂંચવણમાં છે જ્યારે તમે શરત છે
અને અન્ય એક કે એક અન્ય.
કૌંસ વાપરો ફક્ત ખાતરી કરો કે તમારી શરતો અર્થમાં બનાવવા પ્રયત્ન કરવા માટે
કારણ કે તે કિસ્સામાં, ઉદાહરણ તરીકે, તમે કલ્પના કરી શકો છો કે
તે પ્રથમ શરત અને એક અથવા બીજા હોઈ શકે છે
અથવા 2 એક સંયુક્ત શરતો અને
અથવા ત્રીજા એક છે, તેથી માત્ર ખૂબ કાળજી રાખો.
અને છેલ્લે, અમે સ્વીચો વિશે વાત કરી.
એક સ્વીચ ખૂબ ઉપયોગી છે જ્યારે તમે એક ચલ હોય છે.
હવે કહો કે તમે n જેમ એક ચલ છે
કે 0, 1, અથવા 2 હોઈ શકે છે, અને તે કેસ દરેક
તમે કાર્ય કરવા જઈ રહ્યાં છો.
તમે ચલ સ્વિચ કહેવું શકે છે, અને તે સૂચવે છે કે
મૂલ્ય પછી મૂલ્ય 1 જેમ હું આ કરવા જઈ રહ્યો છું,
અને પછી હું ભાંગી નાંખે છે, જેનો અર્થ થાય છે હું અન્ય કિસ્સાઓમાં કોઇ પણ જોવા નથી માંગવાનો
કારણ કે અમે પહેલાથી જ તે કેસ સંતુષ્ટ
અને પછી VALUE2 અને તેથી, હું અને પણ મૂળભૂત સ્વીચ કરી શકે છે.
તેનો અર્થ એ કે જો તે કિસ્સાઓમાં કે હું હતો કોઇ સંતોષ નથી
કે હું કંઈક બીજું કરવા જાઉં છું, પરંતુ તે વૈકલ્પિક છે.
તે મારા માટે બધા છે. હવે આપણે ટોમી છે.
તમામ હક, આ 3-ઇશ અઠવાડિયું પ્રયત્ન રહ્યું છે.
આ વિષયો અમે આવરી લેતી આવશે ક્રિપ્ટો, અવકાશ, એરે વગેરે એટ, અમુક છે.
જસ્ટ ક્રિપ્ટો પર ઝડપી શબ્દ. અમે આ ઘર ખૂબ મહેનત નથી જઈ રહ્યાં છો.
>> અમે 2 pset આવું કર્યું, પરંતુ ક્વિઝ માટે ખાતરી કરો કે તમે તફાવત ખબર બનાવવા
સીઝર સાઇફર અને Vigenère સાઇફર વચ્ચે,
કેવી રીતે તે ciphers વર્ક બંને અને તે શું એનક્રિપ્ટ જેવું છે
અને ડિક્રિપ્ટ તે 2 ciphers ઉપયોગ કરીને ટેક્સ્ટ.
યાદ રાખો, સીઝર સાઇફર માત્ર સમાન રકમ દ્વારા દરેક અક્ષર ફરે છે,
ખાતરી કરો કે તમે મોડ મૂળાક્ષરમાંથી અક્ષરોને સંખ્યા દ્વારા બનાવે છે.
અને Vigenère સાઇફર, તો બીજી બાજુ, દરેક અક્ષર ફરે છે
વિવિધ જથ્થો દ્વારા, તેથી તેના બદલે કહેતા કરતાં
3 Vigenère દ્વારા દરેક અક્ષર ફેરવાય દરેક અક્ષર ફેરવવા કરશે
વિવિધ કેટલીક કીવર્ડ પર આધાર રાખીને જથ્થો દ્વારા
જ્યાં મુખ્ય શબ્દ દરેક અક્ષર કેટલાક વિવિધ જથ્થો પ્રતિનિધિત્વ
દ્વારા સ્પષ્ટ લખાણ ફેરવવા.
માતાનો ચલ અવકાશ વિશે પ્રથમ ચર્ચા દો.
ત્યાં વેરિયેબલ્સ 2 અલગ અલગ પ્રકારના હોય છે.
અમે સ્થાનિક ચલો હોય છે, અને આ માટે વ્યાખ્યાયિત કરી રહ્યા છે
બહાર મુખ્ય છે, અથવા કોઇ કાર્ય અથવા બ્લોક બહાર,
અને આ સુલભ તમારા કાર્યક્રમ ગમે ત્યાં હશે.
જો તમે એક કાર્ય છે અને કાર્ય એક જ્યારે લૂપ છે
મોટા વૈશ્વિક ચલ સુલભ દરેક જગ્યાએ છે.
એક સ્થાનિક ચલ, તો બીજી બાજુ, એવી જગ્યા છે જ્યાં તેને વ્યાખ્યાયિત કરવામાં આવે છે માટે scoped છે.
>> જો તમે એક કાર્ય અહીં હોય છે, ઉદાહરણ તરીકે, અમે આ કાર્ય ત હોય છે,
અને જી ની અંદર ત્યાં અહીં એક ચલ વાય કહેવાય છે,
અને તે અર્થ એ થાય કે આ એક સ્થાનિક ચલ છે.
આમ છતાં આ ચલ વાય કહેવાય છે
અને આ ચલ આ 2 વિધેયો વાય કહેવાય છે
આ બોલ પર કોઈ વિચાર દરેક અન્ય સ્થાનિક ચલો શું હોય છે.
બીજી તરફ, અહીં આપણે પૂર્ણાંક એક્સ 5 = કહે,
અને આ કોઇ કાર્ય દાયરાની બહાર છે.
તે મુખ્ય દાયરાની બહાર છે, તેથી આ એક વૈશ્વિક ચલ છે.
કે આ 2 વિધેયો કે અંદર અર્થ થાય છે જ્યારે હું એક્સ કહે છે - અથવા એક્સ + +
હું જ એક્સ જેમાં આ વાય અને આ પિ અલગ ચલો છે ઍક્સેસ છું.
કે વૈશ્વિક ચલ અને સ્થાનિક ચલ વચ્ચે તફાવત છે.
જ્યાં સુધી ડિઝાઈન ચિંતા છે, ક્યારેક તે કદાચ વધુ સારી રીતે વિચાર છે
માટે ચલો સ્થાનિક રાખવા જ્યારે તમે કદાચ કરી શકો છો
કર્યા ત્યારથી વૈશ્વિક ચલો સમૂહ ખરેખર ગૂંચવણમાં મેળવી શકો છો.
જો તમે વિધેયો સમૂહ છે જે ત્રણેય એક જ વસ્તુ ફેરફાર
તમે શું જો આ કાર્ય આકસ્મિક આ વૈશ્વિક સુધારે ભૂલી જાઓ છો,
અને આ અન્ય કાર્ય તે વિશે ખબર નથી,
અને તે સારુ ગૂંચવણમાં વિચાર કરતો નથી, કારણ તમે વધુ કોડ મેળવો.
ચલો સ્થાનિક રાખવા જ્યારે તમે કદાચ કરી શકો છો
માત્ર સારી ડિઝાઇન છે.
એરે, યાદ રાખો, માત્ર છે તે જ પ્રકારની તત્વો યાદીઓ છે.
સી ની અંદર 2.0 1, જેમ યાદી નથી, હેલ્લો કરી શકો છો.
અમે હમણાં જ ન કરી શકે છે.
>> જ્યારે અમે સી એક એરે જાહેર રીતે બધા તત્વો જ પ્રકારની હોય છે.
અહીં હું 3 પૂર્ણાંકો ઝાકઝમાળ છે.
અહીં હું એરે લંબાઈ ધરાવે છે, પરંતુ જો હું ફક્ત આ વાક્યરચના માં છું તે જાહેર
જ્યાં હું સ્પષ્ટ રીતે બધા તત્વો કયા છે હું ટેકનિકલી આ 3 કરવાની જરૂર નથી.
આ કમ્પાઈલર પૂરતી સ્માર્ટ બહાર આકૃતિ મોટું કેવી રીતે અરે હોવો જોઇએ.
હવે જ્યારે હું વિચાર અથવા એરે ની કિંમત સુયોજિત કરવા માંગો છો
આ તે શું વાક્યરચના છે.
આ વાસ્તવમાં એરે બીજા તત્વ સુધારવા કારણ કે યાદ કરશે,
નંબર 0 પર શરૂ થાય છે, નહિં કે 1 ખાતે.
જો હું તે કિંમત વાંચી માંગો છો હું કંઈક કહી શકો પૂર્ણાંક એક્સ એરે = [1].
અથવા જો હું તે કિંમત સુયોજિત કરવા માંગો છો, જેમ કે હું અહીં કરી રહ્યો છું,
હું એરે [1] કહી શકો = 4.
કે તેમના ઇન્ડેક્સ દ્વારા તત્વો ઍક્સેસ સમય
અથવા તેમની સ્થિતિ અથવા તેઓ એરે છે જ્યાં,
અને તે યાદી 0 અંતે શરૂ થાય છે.
અમે પણ એરે હારમાળાઓનો હોઇ શકે છે,
અને આ એરે બહુ આયામી કહેવામાં આવે છે.
જ્યારે અમે એરે બહુ આયામી છે
તેનો અર્થ એ કે અમે પંક્તિઓ અને કૉલમ્સ કંઈક હોઇ શકે છે,
અને આ ફક્ત આ દ્રશ્યાત્મક અથવા તેના વિશે વિચારવાનો એક રીત છે.
જ્યારે હું એક એરે બહુ આયામી હોય તેનો અર્થ એ કે હું જરૂર શરૂ જાઉં છું
1 કરતાં વધુ અનુક્રમણિકા કારણ કે જો હું ગ્રિડ છે
કહેતા પંક્તિ શું તમે છો અમને ફક્ત એક નંબર આપતું નથી.
કે ખરેખર માત્ર છે અમને નંબરોની યાદી આપવા જઈ રહી છે.
હવે કહો કે હું આ એરે અહીં છે.
હું ગ્રિડ કહેવામાં આવે એરે હોય છે, અને હું તે 2 પંક્તિઓ અને 3 કૉલમ કહી રહ્યો છું,
અને તેથી આ તે દ્રશ્યાત્મક કરવાની એક રીત છે.
જ્યારે હું કહું છું હું [1] ખાતે તત્વ મેળવવા માંગો છો [2]
કે અર્થ એ છે કે કારણ કે આ પંક્તિઓ પ્રથમ અને પછી કૉલમ છે
હું 1 પંક્તિ થી હું 1 જણાવ્યું હતું કે કૂદી જાઉં છું.
>> પછી હું ઉપર 2 સ્તંભ અહીં આવવા જાઉં છું, અને હું કિંમત 6 વિચાર જાઉં છું.
અર્થમાં બનાવીએ?
મલ્ટી પરિમાણીય એરે, યાદ રાખો, જે ટેકનિકલી માત્ર એરે ઝાકઝમાળ છે.
અમે એરે હારમાળાઓનો હારમાળાઓનો હોઈ શકે છે.
અમે ચાલુ રાખવામાં શકે છે, પરંતુ વિશે ખરેખર એક રસ્તો લાગે છે
આ કેવી રીતે બહાર આવી રહી નાખ્યો છે અને શું થઈ રહ્યું છે તે માટે તેને નિહાળવાની છે
આ જેવી ગ્રીડ છે.
જ્યારે અમે કાર્યો એરે પસાર કરવા માટે, તેઓ વર્તે જઈ રહ્યાં છો
જ્યારે અમે વિધેયો માટે નિયમિત ચલો પસાર કરતાં થોડી અલગ બીટ
પૂર્ણાંક અથવા ફ્લોટ પસાર જેવા હોય છે.
જ્યારે અમે પૂર્ણાંક અથવા ઘરનાં પરચૂરણ કામો અથવા આ અન્ય માહિતી કોઈપણ પ્રકારના પાસ
અમે ફક્ત જો કાર્ય સુધારે જોતા હતા
કે ચલની કિંમત કે ફેરફાર કરવા માટે પ્રસરણ નથી જઈ રહ્યા
આ ફોન કામ કરવું.
ઝાકઝમાળ સાથે, બીજી બાજુ, કે શું થશે.
જો હું એક એરે કેટલાક કાર્ય પસાર અને તે કાર્ય તત્વો કેટલાક બદલે,
જ્યારે હું પાછળ કાર્ય કરે છે કે તે કહેવાય આવવા
મારા એરે હવે અલગ હોઈ રહ્યું છે, અને તે માટે શબ્દભંડોળ
છે એરે સંદર્ભ દ્વારા પસાર કરવામાં આવે છે, કારણ કે અમે પાછળથી જોશો.
આ પોઇન્ટર, કેવી રીતે કામ કરે છે આ મૂળભૂત જ્યાં ડેટા પ્રકારો સાથે સંબંધિત છે,
બીજી બાજુ, કિંમત દ્વારા પસાર થાય છે.
>> અમે કે કેટલાક ચલ નકલ બનાવે છે અને પછી નકલ માં પસાર વિચાર કરી શકો છો.
તે તો કોઈ વાંધો નથી કે આપણે શું ચલ સાથે કામ કરે છે.
આ ફોન કાર્ય ધ્યાન રાખો કે તેમાં ફેરફાર કરવામાં આવ્યો હતો રહેશે નહીં.
એરે થોડી કે સંદર્ભે અલગ અલગ બીટ છે.
ઉદાહરણ તરીકે, આપણે માત્ર જોયું, મુખ્ય ફક્ત એક કાર્ય છે
કે 2 દલીલો લઇ શકે છે.
મુખ્ય કામ કરવા માટે પ્રથમ દલીલ argc, અથવા દલીલોની સંખ્યા છે,
અને બીજી દલીલ argv કહે છે,
અને તે તે દલીલોને વાસ્તવિક કિંમતો છે.
હવે કહો કે હું this.c નામના પ્રોગ્રામ હોય,
અને હું કહું છું આ કરવા માટે, અને હું આદેશ વાક્ય પર આ સ્કોર જાઉં છું.
હવે કેટલીક દલીલો મારી કાર્યક્રમ પસાર આ કહે છે,
હું કંઈક જેમ કહેવું / હોઇ શકે છે. આ 50 cs છે.
આ આપણે શું ડેવિડ કરવું દરેક દિવસ કલ્પના ટર્મિનલ પર.
પરંતુ હવે તે કાર્યક્રમની મુખ્ય કાર્ય અંદર
આ કિંમતો છે, તેથી argc 4 છે.
તે થોડો ગૂંચવણમાં મૂકે એવો છે કારણ કે ખરેખર અમે માત્ર 50 cs છે પસાર કરી રહ્યાં છો શકે છે.
કે માત્ર 3.
યાદ પરંતુ argv પ્રથમ તત્વ અથવા પ્રથમ દલીલ
આ કાર્ય પોતાના નામ છે.
જેથી અર્થ એ છે કે અમે 4 વસ્તુઓ અહીં હોય છે,
અને પ્રથમ તત્વ માટે /. આ પ્રયત્ન રહ્યું છે.
અને આ શબ્દમાળા તરીકે રજૂ કરવામાં આવશે.
પછી બાકીના તત્વો હોય છે, આપણે શું કાર્યક્રમના નામ પછી લખ્યો.
તેથી જ કોરે એક, કારણ કે અમે કદાચ 2 pset માં થયો હતો,
યાદ રાખો કે જે 50 શબ્દમાળા પૂર્ણાંક 50 ≠ છે.
તેથી અમે કંઈક કહી શકો છો 'પૂર્ણાંક = x 3 argv.'
>> કે જે હમણાં જ ચાલી રહ્યું છે, નથી અર્થમાં બનાવવા કારણ કે આ એક સ્ટ્રિંગ છે, અને આ એક પૂર્ણાંક છે.
તેથી જો તમે 2 વચ્ચે રૂપાંતરિત કરવા માંગો છો, યાદ રાખો, અમે જઈ રહ્યાં છો
આ જાદુ atoi કહેવાય કાર્ય છે.
કે જે શબ્દમાળા લે છે અને કે જેઓ શબ્દમાળા ની અંદર રજૂ પૂર્ણાંક આપે છે.
જેથી એક સરળ ભૂલ છે એ ક્વિઝ પર બનાવે છે,
માત્ર વિચારીને કે આ આપોઆપ યોગ્ય પ્રકાર હશે.
પરંતુ માત્ર ખબર છે કે આ હંમેશા શબ્દમાળાઓ હશે
પણ જો શબ્દમાળા માત્ર એક પૂર્ણાંક અથવા એક અક્ષર અથવા ફ્લોટ સમાવે છે.
તેથી હવે આપણે સમય ચાલી વિશે વાત કરો.
, જ્યારે અમે આ બધા ગાણિતીક નિયમો છે કે આ બધા ઉન્મત્ત વસ્તુઓ હોય છે
તે ખરેખર ઉપયોગી બની જાય છે પ્રશ્ન પૂછો, "કેટલા તેઓ લે છે?"
અમે અનંત સ્પર્શી નોટેશનમાં કહેવાય કંઈક સાથે પ્રતિનિધિત્વ કરે છે.
તેથી આ અર્થ એ છે કે છે - દો, કહો કે અમે અમારા અલગોરિધમ આપી
કેટલાક ખરેખર, ખરેખર, ખરેખર મોટી ઇનપુટ.
અમે પ્રશ્ન પૂછવા માગો છો, "લાંબા તે કેવી રીતે લાગી રહ્યું છે?
કેટલી પગલાંઓ તે અમારી અલ્ગોરિધમનો લેવા માટે રન કરશે
ઇનપુટ કદ એક કાર્ય તરીકે? "
જેથી પ્રથમ આપણી સ્કોર સમય વર્ણન કરી શકે મોટું ઓ સાથે છે
અને આ અમારી ચાલતા સૌથી ખરાબ કેસ સમય છે.
તેથી જો આપણે એક એરે સૉર્ટ કરવા માંગો છો, અને અમે અમારી અલ્ગોરિધમનો ઝાકઝમાળ આપી
કે ઉતરતા ક્રમમાં છે જ્યારે તે ચડતા ક્રમમાં હોવી જોઈએ,
કે ખરાબ કેસ જ હશે.
આ અમારી સમય અમારા અલગોરિધમ લેશે મહત્તમ લંબાઈ બંધાયેલ ઉપર છે.
બીજી તરફ, આ Ω માટે શ્રેષ્ઠ કેસ ચાલી સમય વર્ણન રહ્યું છે.
તેથી જો અમે સૉર્ટ અલ્ગોરિધમનો માટે પહેલાથી જ છટણી એરે આપે છે,
લાંબા તે કેવી રીતે તેને સૉર્ટ લઇ જશે?
અને આ, તો પછી, ઓછા સમય ચાલી પર બાઉન્ડ વર્ણવે છે.
અહીં માત્ર કેટલાક શબ્દો અમુક સામાન્ય ચાલી વખત વર્ણન છે.
આ ક્રમમાં હોય છે.
સૌથી ઝડપી સમય ચાલી અમે સતત કહેવાય છે.
>> કે કોઈ બાબત કેટલી તત્વો અમારી અલ્ગોરિધમનો આપી અર્થ થાય છે,
કોઈ બાબત મોટી કેવી રીતે અમારી વ્યૂહરચના છે, તે સૉર્ટ
અથવા કરવાનું ગમે અમે એરે માટે કરી રહ્યા હંમેશા સમય જ જથ્થો લેશે.
તેથી અમે 1 એક છે, જે સતત હોય છે, સાથે જ કે પ્રતિનિધિત્વ કરી શકે છે.
અમે પણ લઘુગુણકીય રન સમયે હતા.
તેથી દ્વિસંગી શોધ કંઈક લઘુગુણકીય છે,
જ્યાં અમે દરેક અડધા સમયમાં સમસ્યા કાપી
અને પછી વસ્તુઓ માત્ર ત્યાંથી ઊંચી છે.
અને જો તમે ક્યારેય કોઈ કારણદર્શી ગાણિતીક અમને એક ઓ લખી,
તમે કદાચ આ તમારા દિવસ કામ નથી આપવું જોઈએ.
જ્યારે આપણે ચાલી વખત તુલના તે મહત્વપૂર્ણ છે ધ્યાનમાં આ વસ્તુઓ રાખો.
તેથી જો હું અલ્ગોરિધમનો કે ઓ (એન), અને બીજા કોઈને હોય છે
છે ઓ એક એલ્ગોરિધમ (2n) આ ખરેખર છે asymptotically સમકક્ષ.
તેથી જો આપણે અબજ eleventy જેવી મોટી સંખ્યા હોવી n કલ્પના:
તેથી જ્યારે અમે અબજ eleventy અબજ eleventy કંઈક + + 3 સાથે સરખામણી કરી રહ્યા છો,
અચાનક કે +3 ખરેખર એક મોટા તફાવત હવે નથી.
તેથી જ અમે આ બધી વસ્તુઓ સમકક્ષ આવે શરૂ રહ્યા છીએ.
આ સ્થિરાંકો જેમ અહીં વસ્તુઓ તેથી, ત્યાં 2 આ એક્સ છે, અથવા 3 એક ઉમેરીને,
આ ફક્ત સ્થિરાંકો, અને આ કરવા માટે ડ્રોપ જતાં હોય છે.
તેથી કે કેમ આ રન વખત તમામ 3 કહે છે કે તેઓ ઓ (એન) છો તરીકે જ છે.
તેવી જ રીતે, જો આપણે 2 અન્ય રન જોવાયા છે, ચાલો કહેવું ઓ (n + ચોરસ 2n ³), અમે ઉમેરી શકો છો
+ N એ, 7 +, અને પછી અમે અન્ય રન સમય કે જે હમણાં જ ઓ છે (n ³) હોય છે.
ફરીથી, આ જ વસ્તુ છે કારણ કે આ - આ જ નથી.
આ જ વસ્તુઓ છે, માફ કરશો. તેથી આ જ છે કારણ કે
આ n ³ આ 2n ચોરસ પર પ્રભુત્વ રહ્યું છે.
>> છે તો શું આપણે (n ³ O) અને O જેવા વખત ચાલે છે તે જ વસ્તુ નથી (ચોરસ એન)
કારણ કે આ n ³ ખૂબ આ n ચોરસ કરતાં પણ મોટો છે.
તેથી જો આપણે પ્રતિનિધિઓ હોય છે, અચાનક આ બાબતના શરૂ કરે છે,
પરંતુ જ્યારે અમે પરિબળો સાથે કામ કરી રહ્યાં છે કારણ કે અમે અહીં છે,
પછી તેને વાંધો નથી કારણ કે તેઓ માત્ર છોડી જતા નથી ચાલી રહ્યું છે.
ચાલો એવા ગાણિતીક નિયમો કેટલાક અમે અત્યાર સુધીમાં જોયેલા પર એક નજર
અને તેમના રન સમય વિશે વાત કરો.
યાદીમાં નંબર શોધી પ્રથમ માર્ગ, કે જે આપણે જોયું, રેખીય શોધ હતી.
અને લીનીયર શોધ અમલીકરણ સુપર સીધું છે.
અમે હમણાં જ એક યાદી હોય છે, અને અમે યાદીમાં દરેક એક તત્વ જોવા જઈ રહ્યાં છો
ત્યાં સુધી અમે નંબર શોધવા અમે શોધી રહ્યાં છે.
જેથી અર્થ એ છે કે સૌથી ખરાબ કિસ્સામાં, આ ઓ (n).
અને સૌથી ખરાબ અહીં કેસ જો તત્વ છે હોઈ શકે છે
છેલ્લું તત્વ હતું, તે પછી લાઇનર શોધ મદદથી અમે દરેક એક તત્વ જોવા હોય
ત્યાં સુધી અમે છેલ્લા એક મેળવવા માટે ક્રમમાં ખબર છે કે તે યાદીમાં વાસ્તવમાં હતી.
, અમે હમણાં હાફવે આપી શકે છે અને કહે છે "તે કદાચ ત્યાં નથી."
રેખીય શોધ સાથે અમે સમગ્ર બાબત જોવા મળે છે.
આ ચાલી રહેલ શ્રેષ્ઠ કેસ વખતે, બીજી બાજુ, સતત હોય છે,
કારણ કે શ્રેષ્ઠ કિસ્સામાં તત્વ અમે શોધી રહ્યાં છો તે ફક્ત યાદીમાં પ્રથમ છે.
તેથી તે અમને ચોક્કસ પગલાં 1, કોઈ બાબત મોટી કેવી રીતે યાદી છે લાગી રહ્યું છે
જો અમે પ્રથમ તત્વ માટે દર વખતે જોઈ રહ્યા છો.
>> તેથી જ્યારે તમે શોધવા માટે, યાદ રાખો, તે જરૂરી નથી કે અમારા યાદી અલગ કરવામાં આવે છે.
કારણ કે અમે ફક્ત દરેક એક તત્વ જોશે જઈ રહ્યાં છો, અને તે ખરેખર તો કોઈ વાંધો નથી
હુકમ શું છે તે તત્વો સાઇન છે
વધુ બુદ્ધિશાળી શોધ અલ્ગોરિધમનો દ્વિસંગી શોધ કંઈક છે.
યાદ રાખો, દ્વિસંગી શોધ અમલીકરણ છે જ્યારે તમે જઈ રહ્યાં છો
યાદીમાં મધ્યમ જોઈ રાખો.
અને કારણ કે અમે મધ્યમ અંતે શોધી રહ્યાં છો, તો અમે જરૂર છે કે જે યાદી સૉર્ટ થાય છે
બીજું કે અમે જ્યાં મધ્યમ નથી જાણતા હોય, તો અને અમે જોશે છે
સમગ્ર તેને શોધવા માટે યાદી અને પછી તે સમયે અમે ફક્ત સમય બરબાદ કરી રહ્યા છીએ.
તેથી જો અમે છટણી યાદી હોય છે અને અમે મધ્યમ શોધવા માટે, અમે મધ્યમ સરખાવવા જઈ રહ્યાં છો
તત્વ માટે અમે શોધી રહ્યાં છે.
જો કે તે ખૂબ ઊંચા છે, તે પછી અમે અધિકાર અડધા ભૂલી શકે
કારણ કે આપણે જાણીએ છીએ કે જો અમારી તત્વ પહેલેથી જ છે પણ ઊંચા
અને આ તત્વ જમણી બધું પણ ઊંચા છે,
પછી અમે ત્યાં હવે જોવા જરૂર નથી.
જ્યાં બીજી બાજુ, જો અમારા તત્વ ખૂબ ઓછી છે,
આપણે જાણીએ છીએ કે તત્વ ડાબી બધું પણ ખૂબ ઓછી,
તેથી તે ખરેખર ત્યાં જોવા અર્થમાં નથી ક્યાં,.
આ રીતે, દરેક અને યાદીના અંતે મિડપોઇન્ટ દર વખતે આપણે જોવા પગલાં સાથે,
અમે અડધા અમારી સમસ્યા કાપી જઈ રહ્યાં છો કારણ કે અચાનક આપણે જાણીએ છીએ
નંબરો કે એક અમે શોધી રહ્યાં છો તે ન હોઈ શકે સંપૂર્ણ જથ્થો.
>> સ્યુડોકોડનો આ કંઈક આના જેવી હો,
અને કારણ કે અમે દરેક અડધા જ સમય માં યાદી કાપવા કરી રહ્યાં છો,
અમારા ખરાબ કેસ રન રેખીય માંથી લઘુગુણકીય સમય જમ્પ.
તેથી અચાનક અમારી પાસે લોગ ઈન પગલાંઓ ક્રમમાં યાદીમાં એક તત્વ શોધવા માટે બનાવવા માટે.
આ ચાલી રહેલ શ્રેષ્ઠ કેસ સમય, જોકે, હજુ પણ છે સતત
કારણ કે હવે, ચાલો માત્ર કહે છે કે તત્વ અમે શોધી રહ્યાં છો છે
હંમેશા મૂળ યાદી ચોક્કસ મધ્યમ.
તેથી અમે મોટું કારણ કે અમે માંગો છો તરીકે અમારી યાદી વધવા શકે છે, પરંતુ જો તત્વ અમે શોધી રહ્યાં છો તે મધ્યમાં છે,
પછી તેને માત્ર અમને 1 પગલાં ચાલી રહ્યું છે.
તેથી કે શા માટે આપણે (લોગ એન) ઓ અને (1) Ω અથવા સતત છો.
ચાલો ખરેખર આ સૂચિ પર દ્વિસંગી શોધ ચલાવો.
તેથી આપણે કહેવું કે અમને 164 તત્વ શોધી રહ્યાં છે.
પ્રથમ વસ્તુ અમે કરવા જઇ રહ્યા છે અને આ યાદીમાં મિડપોઇન્ટ શોધો.
તે જ થાય છે કે મિડપોઇન્ટ આ 2 નંબરો વચ્ચે પડવું રહ્યું છે,
તેથી આપણે માત્ર આપખુદ કહેતા, દરેક સમયે મિડપોઇન્ટ 2 નંબરો વચ્ચે પડે છે,
ચાલો માત્ર ગિરફતારી.
અમે હમણાં જ ખાતરી કરવા માટે અમે આ રીતે દરેક પગલું શું કરવાની જરૂર છે.
તેથી અમે ગિરફતારી જઈ રહ્યાં છો, અને અમે કહે છે કે 161 અમારા યાદી મધ્યમાં છે જઈ રહ્યાં છો.
161 તેથી <164, અને 161 ડાબી દરેક તત્વ
પણ 164 <છે, તેથી આપણે જાણીએ છીએ કે તે અમને તમામ અંતે મદદ નથી ચાલી રહ્યું છે
પર અહીં જોઈ પ્રારંભ તત્વ કારણ કે અમે પ્રયત્ન નથી કરી શકો છો શોધી રહ્યાં છે.
તેથી અમે શું કરી શકો છો છે અમે ફક્ત યાદી છે કે સમગ્ર ડાબી અડધા ભૂલી શકો,
અને હવે માત્ર 161 આગળ જમણી ના વિચારો.
>> તેથી ફરીથી, આ મિડપોઇન્ટ છે; ચાલો માત્ર ગિરફતારી.
હવે 175 ખૂબ મોટી છે.
તેથી આપણે જાણીએ છીએ તે અમને અહીં અથવા અહીં જોઈ મદદ નથી ચાલી રહ્યું છે,
તેથી અમે માત્ર કે દૂર ફેંકવા શકે છે, અને છેવટે અમે 164 તો ફટકો પડશે.
દ્વિસંગી શોધ પર કોઈપણ પ્રશ્ન છે?
ચાલો એક પહેલેથી જ છટણી યાદી મારફતે શોધ માંથી પર ખસેડો
ખરેખર કોઈપણ ક્રમમાં નંબરોની યાદી લેતી
અને ચડતા ક્રમમાં છે કે જે યાદીમાં બનાવે છે.
પ્રથમ અલ્ગોરિધમનો અમે અંતે જોવામાં બબલ સૉર્ટ તરીકે ઓળખાતું હતું.
અને આ એલ્ગોરિધમ્સ આપણે જોયું સરળ હશે.
બબલ સૉર્ટ કહે છે કે જ્યારે યાદી અંદર કોઇ 2 તત્વો સ્થળ બહાર છે,
જેનો અર્થ થાય છે ત્યાં નીચા નંબર ડાબી ઊંચી સંખ્યા છે,
તો પછી અમે તેમને સ્વેપ જઈ રહ્યાં છો, કારણ કે તે અર્થ એ થાય કે યાદી હશે
"સોર્ટ વધુ" કરતાં પહેલાં હતી.
અને અમે હમણાં જ આ પ્રક્રિયા ફરીથી ચાલુ રાખવા જઈ રહ્યાં છો અને ફરી ફરી
ત્યાં સુધી છેવટે તેમના યોગ્ય સ્થાન માટે બબલ ના તત્વો પ્રકારની છે અને આપણે છટણી યાદી હોય છે.
>> આ સમય રન O એ પ્રયત્ન રહ્યું છે (n ²) હતું. શા માટે?
વેલ, સૌથી ખરાબ કિસ્સામાં કારણ કે, અમે દરેક તત્વ લઈ જઈ રહ્યાં છો, અને
અમે અંત તે યાદી દરેક અન્ય તત્વ સાથે સરખામણી રહ્યા છીએ.
પરંતુ શ્રેષ્ઠ કિસ્સામાં, અમે પહેલાથી જ છટણી યાદી હોય છે, પરપોટો સૉર્ટ હિસ્સો
માત્ર જઈને એક મારફતે જાઓ, કહેવું "ના હું કોઈપણ અદલબદલ શકતા નથી., તેથી હું પૂર્ણ છું."
તેથી અમે એક શ્રેષ્ઠ કેસ Ω (એન) ના ચાલી સમય હોય છે.
ચાલો એક યાદી પર બબલ સૉર્ટ ચલાવો.
અથવા પ્રથમ, ચાલો માત્ર કેટલાક સ્યુડોકોડનો અંતે ખરેખર ઝડપથી જુઓ.
અમે કહી અમે ટ્રેક ના લૂપ દરેક ઇટરેશન રાખવા માંગો છો માંગો છો,
કે શું નથી અથવા અમે કોઈ તત્વો બદલાઈ ટ્રૅક રાખો.
છે કે કારણ તેથી, અમે રોકવા જ્યારે અમે કોઈપણ ઘટકો નથી સ્વૅપ છે જઈ રહ્યાં છો.
તેથી અમારા લૂપ શરૂઆતમાં અમે કંઈપણ સ્વૅપ છે, તેથી અમે કહીએ છીએ પડશે કે ખોટા છે.
હવે, અમે યાદી મારફતે જાઓ અને તત્વ તુલના હું તત્વ હું + 1 માટે જઈ રહ્યાં છો
અને જો તે કેસ એ છે કે ત્યાં એક નાના નંબર ડાબી મોટા સંખ્યા છે,
તો પછી અમે માત્ર તેમને સ્વેપ રહ્યા છીએ.
>> અને પછી અમે યાદ રાખો કે અમે એક તત્વ સ્વૅપ રહ્યા છીએ.
એટલે કે અમે આ યાદી મારફતે ઓછામાં ઓછા વધુ 1 વખત જવાની જરૂર
કારણ કે આ પરિસ્થિતિ કે જેમાં આપણે અટકાવી છે જ્યારે સમગ્ર યાદી પહેલાથી જ છટણી કરવામાં આવે છે,
જેનો અર્થ અમે કોઈ અદલબદલ નથી કર્યા છે.
જેથી શા માટે અમારી સ્થિતિ નીચે અહીં છે છે 'જ્યારે કેટલાક તત્વો સ્વૅપ કરવામાં આવી છે.'
તેથી હવે આપણે ફક્ત આ યાદી પર ચાલી જુઓ.
હું 5,0,1,6,4 યાદી હોય છે.
બબલ સૉર્ટ ડાબી પર તમામ માર્ગ શરૂ થઈ રહ્યું છે, અને તે તુલના રહ્યું છે
આઇ તત્વો છે, તેથી 0 થી મને + 1, કે જે 1 તત્વ છે.
તે કહે છે, 5 સારી> 0 ચાલી રહ્યું છે, પરંતુ હમણાં 5 ડાબી તરફ હોય છે,
તેથી હું 5 અને 0 સ્વેપ કરવાની જરૂર છે.
જ્યારે હું તેમને સ્વેપ અચાનક હું આ અલગ યાદી મળે છે.
5 હવે 1> છે, તેથી અમે તેમને સ્વેપ રહ્યા છીએ.
5 6> નથી, તેથી અમે કંઈપણ અહીં જરૂર નથી.
પરંતુ 6 4> છે, તેથી અમે સ્વેપ કરવાની જરૂર છે.
ફરીથી, અમે સમગ્ર આખરે શોધવામાં યાદી મારફતે રન કરવા પડે છે
કે આ હુકમ બહાર છે; અમે તેમને સ્વેપ
અને આ બિંદુએ અમે યાદી મારફતે 1 વધુ સમય ચાલે જરૂર
ખાતરી કરવા માટે કે બધું તેના ક્રમમાં છે, અને આ બિંદુ બબલ સૉર્ટ અંતે સમાપ્ત થઈ ગઈ છે તેની ખાતરી કરો.
કેટલાક ઘટકોને લઈને તેમને સોર્ટિંગ કરવા માટે એક અલગ અલ્ગોરિધમનો પસંદગી જેવું છે.
પસંદગી સૉર્ટ પાછળ વિચાર છે કે અમે આ યાદી એક છટણી ભાગ બિલ્ડ જઈ રહ્યાં છો
એક સમયે 1 તત્વ.
>> અને જે રીતે અમે તે કરવા જઈ રહ્યાં છો અપ યાદી ડાબી સેગમેન્ટમાં મકાન છે.
અને મૂળભૂત, દરેક - દરેક પગલાં પર, અમે નાના તત્વ અમે બાકી લેવા જઈ રહ્યાં છો
કે હજુ સુધી કરવામાં આવી નથી છટણી છે, અને અમે તે છટણી સેગમેન્ટમાં ખસેડો રહ્યા છીએ.
તેનો અર્થ એ કે અમે સતત લઘુત્તમ ક્રમમાંગોઠવાયેલનથી તત્વ શોધવાની જરૂર
અને પછી તે ન્યૂનતમ તત્વ ભરે છે અને તેને ગમે સાથે સ્વેપ
બાકી સૌથી તત્વ કે છૂટાં પાડવામાં આવે છે.
આ સ્કોર સમય O એ પ્રયત્ન રહ્યું છે (ચોરસ એન) કારણ કે ખરાબ કિસ્સામાં
અમે દરેક અન્ય તત્વ માટે દરેક એક તત્વ તુલના કરવાની જરૂર છે.
કારણ કે અમે કહી રહ્યાં છે કે જો આપણે આ યાદીમાં ડાબી અડધા શરૂ થાય છે, આપણે જરૂર
સમગ્ર અધિકાર સેગમેન્ટમાં મારફતે પસાર થવા માટે નાના તત્વ શોધો.
અને પછી ફરી, અમે પર સમગ્ર અધિકાર સેગમેન્ટમાં જાઓ અને જરૂર
ઉપર અને ઉપર અને ઉપર ઉપર કે જઈને ફરીથી રાખો.
કે એન ચોરસ જ હશે. અમે બીજી લૂપ માટે લૂપ અંદર માટે જરૂર જઈ રહ્યાં છો
જે n ચોરસ સૂચવે છે.
શ્રેષ્ઠ કેસ વિચારોમાં દો, કહો કે અમે તેને પહેલાથી જ છટણી યાદી આપે છે;
અમે ખરેખર n ચોરસ કરતાં કોઇ વધુ સારી રીતે નથી કરતી.
કારણ કે પસંદગી સૉર્ટ જાણીને કે કોઇ માર્ગ હોય છે
લઘુત્તમ તત્વ માત્ર એક હું જોઈ શકાય થાય છે.
તે હજુ પણ ખાતરી કરો કે આ ખરેખર લઘુત્તમ છે જરૂર છે.
>> અને માત્ર તેની ખાતરી કરવા માટે કે જે તે ન્યૂનતમ જ, આ અલ્ગોરિધમનો ઉપયોગ કરીને રસ્તો,
માટે દરેક એક તત્વ અંતે ફરીથી જુઓ.
ખરેખર તેથી, જો તમે તેને આપી - જો તમે પસંદગી સૉર્ટ પહેલાથી છટણી યાદી આપવા માટે,
તે તેને યાદી છે કે જે હજુ સુધી નથી સૉર્ટ થાય છે આપવા કરતા કોઇ પણ સારી રીતે નથી ચાલી રહ્યું છે.
જો કે, જો તે કેસ બને છે કે કંઈક ઓ (કંઈક હોય)
અને કંઈક આ ઓમેગા, અમે માત્ર વધારે સંક્ષિપ્તમાં કે તે વસ્તુની θ છે કહી શકીએ.
તેથી જો તમે જુઓ છો કે જે ક્યાંય પણ આવે છે, કે છે કે શું માત્ર થાય છે.
>> જો કંઈક n ના થીટા છે ચોરસ છે, તે બન્ને મોટા (ચોરસ n O) અને Ω (ચોરસ એન) છે.
શ્રેષ્ઠ કેસ અને ખરાબમાં ખરાબ કિસ્સામાં, જેથી તે તફાવત નથી,
અલગોરિધમ એ જ વસ્તુ દર વખતે આવું રહ્યું છે.
તેથી આ છે પસંદગી સૉર્ટ માટે સ્યુડોકોડનો શું દેખાશે શકે છે.
અમે મૂળભૂત રીતે કહેવું કે હું ઉપર યાદી પર ફરી વળવું માંગો છો જઈ રહ્યાં છો
જમણી અને લૂપ દરેક ઇટરેશન પર ડાબેથી, હું ખસેડવા જાઉં છું
આ યાદીમાં આ છટણી ભાગ માં લઘુત્તમ તત્વ.
અને એકવાર હું કંઈક ત્યાં, હું ક્યારેય તે તત્વ અંતે ફરીથી જુઓ.
કારણ કે વહેલી તકે હું માં યાદી ડાબી સેગમેન્ટમાં એક તત્વ સ્વેપ, તે છટણી છે
કારણ કે અમે ન્યૂનતમ ઉપયોગ કરીને ચડતા ક્રમમાં બધું કરી રહ્યા છીએ.
તેથી અમે જણાવ્યું હતું કે, ઠીક, અમે હું પદ પર છો, અને અમે આગળ બધા તત્વો જોવાની જરૂર
i ની જમણી કરવા માટે ન્યૂનતમ શોધો.
તેથી તેનો અર્થ એ કે અમે હું + 1 ના યાદી ઓવરને નજર કરવા માંગો છો.
અને હવે, જો તત્વ કે અમે હાલમાં અંતે શોધી રહ્યાં છો તે અમારા લઘુત્તમ કરતા ઓછી અત્યાર સુધી છે,
જે, યાદ રાખો, અમે લઘુત્તમ બોલ શરૂ કરી રહ્યા છીએ જ હોઇ
ગમે તત્વ અમે હાલમાં છો; હું ધારે કરીશું કે લઘુત્તમ છે.
જો હું એક તત્વ છે કે જે કરતા નાની છે શોધવા માટે, તે પછી હું કહેવા જાઉં છું ઠીક,
તેમજ, હું એક નવા લઘુત્તમ મળ્યા છે.
હું યાદ જ્યાં કે લઘુત્તમ હતી જાઉં છું.
>> તેથી હવે, એક વખત હું કે અધિકાર ક્રમમાંગોઠવાયેલનથી સેગમેન્ટમાં પસાર કર્યો છે,
હું કહી શકીએ હું તત્વ કે હું સ્થિતિમાં છે સાથે લઘુત્તમ તત્વ સ્વેપ જાઉં છું.
કે મારી સૂચિ બનાવી રહ્યું છે, મારા ડાબેથી જમણે યાદીમાં છટણી ભાગ,
અને અમે ક્યારેય તત્વ અંતે ફરીથી જોવા એકવાર તે ભાગમાં છે જરૂર નથી.
એકવાર અમે તેને સ્વૅપ કરી છે.
તેથી આપણે આ સૂચિ પર પસંદગી સૉર્ટ ચલાવો.
વાદળી અહીં તત્વ માટે હું પ્રયત્ન રહ્યું છે, અને લાલ તત્વ માટે લઘુત્તમ તત્વ રહ્યું છે.
તેથી હું યાદી ડાબી બાજુએ બધી રીતે શરૂ કરે છે, જેથી 5 છે.
હવે અમે લઘુત્તમ ક્રમમાંગોઠવાયેલનથી તત્વ શોધવા જરૂર છે.
તેથી, અમે કહીએ 0 <5, તેથી 0 મારું નવું લઘુત્તમ છે.
>> પરંતુ હું ત્યાં ન અટકાવવા માટે, કારણ કે તેમ છતાં અમે ઓળખી શકે છે કે 0 સૌથી નાનું છે શકે છે,
અમે એ ખાતરી કરો કે યાદી દરેક અન્ય તત્વ દ્વારા ચલાવવામાં જરૂર છે.
1 તેથી મોટી છે, 6 મોટા, 4 મોટું છે.
તેનો અર્થ એ છે કે આ તમામ ઘટકો જોયા બાદ, હું નક્કી કર્યું 0 સૌથી નાનું છે.
તેથી હું 5 અને 0 સ્વેપ જાઉં છું.
એકવાર હું કે સ્વેપ, હું એક નવી યાદી મેળવવા જઈ રહ્યો છું, અને હું જાણું છું કે હું જરૂર 0 કે ફરીથી જોવા ક્યારેય
કારણ કે એક વખત હું તેને સ્વૅપ કરી છે, હું તેને છટણી કરી છે અને અમે પૂર્ણ કરી લીધું.
હવે તે જ બને છે કે વાદળી તત્વ ફરીથી 5 એ,
અને અમે 1 છે જુઓ જરૂર છે, 6 અને 4 માટે 1 જે તે નક્કી
નાના લઘુત્તમ તત્વ છે, તેથી અમે 1 અને 5 એ સ્વેપ કરશો.
ફરીથી, અમે જોવા જરૂર - 6 અને 4 માટે 5 સરખાવવા માટે,
અને અમે 4 અને 5 એ સ્વેપ જઈ રહ્યાં છો, અને છેલ્લે સરખાવવા માટે,
તે 2 નંબરો અને તેમને સ્વેપ સુધી અમે અમારા છટણી યાદી મળે છે.
પસંદગી સૉર્ટ પર કોઈપણ પ્રશ્ન છે?
ઠીક છે. ચાલો છેલ્લા વિષય અહીં ખસેડવા માટે, અને તે કે પુનરાવર્તનના છે.
>> રિકર્ઝન, યાદ રાખો, આ ખરેખર મેટા બાબત એ છે કે જ્યાં કાર્ય
વારંવાર પોતે કહે છે.
તેથી અમુક સમયે, જ્યારે અમારા fuction વારંવાર પોતાને કૉલ કરે છે,
ત્યાં અમુક બિંદુ કે અમે જાતને કૉલ રોકવા જરૂરી છે.
કારણ કે જો અમે તે નથી, તો પછી અમે માત્ર આ કાયમ કરવું ચાલુ રાખવા જઈ રહ્યાં છો,
અને અમારો કાર્યક્રમ માત્ર રહ્યું છે માટે સમાપ્ત.
અમે આ શરત આધાર કેસ કૉલ કરો.
અને આધાર કેસ વિધેય ફરીથી ફોન કરતાં કહે છે,
હું માત્ર કેટલાક કિંમત પાછી જાઉં છું.
તેથી એક વખત અમે કિંમત પરત કર્યું છે, અમે જાતને કૉલ બંધ કર્યુ છે,
અને કોલ્સ અમે અત્યાર સુધી કરેલા બાકીના પણ પાછા આવી શકો છો.
આધાર કેસ ઓફ વિરુદ્ધ ફરી યાદ આવવું કેસ છે.
અને આ છે જ્યારે અમે એ વિધેય કે અમે હાલમાં સાઇન છો બીજા કૉલ કરવા માંગો છો
અને અમે કદાચ, જોકે હંમેશાં નથી, વિવિધ દલીલો ઉપયોગ કરવા માંગો છો.
>> તેથી જો અમે એફ કહેવાય કાર્ય હોય છે, અને એફ ફક્ત 1 દલીલ લઇ કહે છે,
અને અમે હમણાં જ (1) f, એફ (1), એફ (1) ને કૉલ રાખવા, અને તે માત્ર જેથી બને છે
આ 1 દલીલ ફરી યાદ આવવું કેસ પડે છે, અમે હજી પણ જઈ રહ્યાં છો ક્યારેય અટકાવો.
પણ જો આપણે એક આધાર કેસ છે, તો અમે ખાતરી કરવા માટે કે આખરે અમે તે આધાર કેસ હિટ જઈ રહ્યાં છો કરવાની જરૂર છે.
અમે ફક્ત આ યાદ આવવું કેસ રહેતા નથી રાખી નથી.
સામાન્ય રીતે, જ્યારે અમે જાતને કહી, અમે કદાચ એક અલગ દલીલ દરેક સમય હોય રહ્યા છીએ.
અહીં ખરેખર સરળ ફરી યાદ આવવું કાર્ય છે.
તેથી આ એક નંબર કારણદર્શી ગણતરી કરશે.
અહીં ટોચ અમે અમારી આધાર કેસ હોય છે.
કે જે n ≤ 1, અમે કારણદર્શી ફરી કૉલ ન જઈ રહ્યાં છો છે.
અમે રોકવા જઈ રહ્યાં છો; આપણે માત્ર અમુક કિંમત પાછી જઈ રહ્યાં છો.
જો આ સાચું નથી, તો પછી અમે અમારી યાદ આવવું કેસ હિટ રહ્યા છીએ.
અહીં નોંધ કરો કે અમે માત્ર કારણદર્શી (n) ન કૉલ કરી રહ્યાં છો, કારણ કે તે ખૂબ જ ઉપયોગી નહિં હોય.
અમે કંઈક બીજું ઓફ કારણદર્શી કહી રહ્યા છીએ.
>> અને તેથી તમે જુઓ, આખરે તો અમે (5) કારણદર્શી અથવા કંઈક પસાર કરી શકો છો,
અમે (4) કારણદર્શી અને તેથી પર કૉલ જઈ રહ્યાં છો, અને છેવટે અમે આ આધાર કેસ હિટ રહ્યા છીએ.
તેથી આ સારી દેખાય છે. માતાનો જુઓ શું થાય છે જ્યારે અમે ખરેખર આ સ્કોર દો.
આ સ્ટેક છે, અને ચાલો કહે છે કે મુખ્ય એક દલીલ (4) સાથે આ કાર્ય કહી રહ્યું છે.
તેથી એક વખત કારણદર્શી જુએ છે અને 4 =, કારણદર્શી પોતે કૉલ કરશે.
હવે, અચાનક, અમે કારણદર્શી (3) હોય છે.
તેથી આ કાર્ય વધતી રાખવા સુધી છેવટે અમે અમારી આધાર કેસ હિટ જતાં હોય છે.
આ બિંદુએ, આ વળતર કિંમત પરત (nx આ વળતર કિંમત) છે,
આ વળતર કિંમત nx આ વળતર કિંમત છે.
આખરે અમે કેટલાક નંબર ફટકો જરૂર છે.
અહીં ટોચ પર, અમે 1 વળતર કહો.
તેનો અર્થ એ છે કે એકવાર અમે કે જે નંબર પાછા, અમે સ્ટેક આ પૉપ કરી શકો છો.
તેથી આ કારણદર્શી (1) કરવામાં આવે છે.
જ્યારે 1 વળતર, આ કારણદર્શી (1) વળતર, 1 થી આ વળતર.
આ વળતર કિંમત, યાદ રાખો, nx આ વળતર કિંમત હતી.
તેથી અચાનક, આ વ્યક્તિ જાણે છે કે હું 2 પરત કરવા માંગો છો.
>> તેથી યાદ રાખો કે, પરત આ કિંમત માત્ર nx પરત કિંમત છે અહીં.
તેથી હવે અમે 3 2 એક્સ કહેવું કરી શકો છો, અને છેલ્લે, અહીં આપણે કહી શકીએ
આ માત્ર 4 3 x x 2 પ્રયત્ન રહ્યું છે.
અને આ વળતર એકવાર, અમે મુખ્ય એક પૂર્ણાંક અંદર ઘટીને મેળવો.
રિકર્ઝન પર કોઈપણ પ્રશ્ન છે?
અધિકાર છે. તેથી ત્યાં ઓવરને અંતે પ્રશ્નો માટે વધુ સમય છે,
પરંતુ હવે જોસેફ બાકીના વિષયો આવરી લઈશું.
>> બધા હક [જોસેફ ઓન્ગ]. તેથી હવે અમે recursions વિશે વાત કરી છે,
ચાલો શું મર્જ સૉર્ટ કરો છે તે વિશે થોડુંક વાત કરો.
મર્જ કરો સૉર્ટ મૂળભૂત નંબરોની યાદી સૉર્ટ બીજી રીતે હોય છે.
અને તે કેવી રીતે કામ કરે છે મર્જ સૉર્ટ સાથે છે, તો તમે એક યાદી હોય છે, અને અમે શું છે
અમે કહીએ છીએ, આપણે 2 છિદ્ર આ વિભાજિત.
અમે પ્રથમ સૉર્ટ ડાબી અડધા ભાગ પર ફરીથી મર્જ સ્કોર પડશે,
પછી અમે અધિકાર અડધા ભાગ પર સૉર્ટ મર્જ સ્કોર પડશે,
અને તે અમને હવે આપે 2 છિદ્ર કે છટણી કરવામાં આવે છે, અને હવે અમે તે છિદ્ર એકસાથે રહ્યા છીએ.
તે થોડી મુશ્કેલ ઉદાહરણ વિના જુઓ, તેથી અમે ગતિનું મારફતે જાઓ અને જુઓ શું થાય છે પડશે.
તેથી તમે શરૂ કરો આ યાદી સાથે, અમે તેને 2 અર્ધભાગ વિભાજિત.
અમે ડાબી અડધા ભાગ પર સૉર્ટ પ્રથમ મર્જ ચલાવો.
જેથી ડાબી અડધા છે, અને હવે અમે આ યાદી મારફતે તેમને ફરીથી ચલાવો
જે મર્જ સૉર્ટ પસાર કરવામાં નહીં, અને તે પછી અમે જુઓ, ફરીથી,
આ યાદી ડાબી બાજુ અને અમે તેના પર સૉર્ટ મર્જ ચલાવો.
હવે, અમે 2 સંખ્યાની યાદી નીચે વિચાર,
અને હવે ડાબી અડધા માત્ર 1 તત્વ લાંબી છે, અને અમે શકતો નથી
યાદી છે કે જે અડધા માં માત્ર 1 તત્વ છે વિભાજિત છે, તેથી અમે માત્ર કહી, એક વખત અમે 50 હોય છે,
જે ફક્ત 1 તત્વ છે, તે પહેલેથી જ છટણી છે.
>> એકવાર અમે સાથે પૂર્ણ કરી, અમે જોઈ શકો છો કે અમે આ કરી શકો છો
આ યાદી જમણી અડધા પર ખસેડો,
અને 3 પણ, છૂટાં પાડવામાં આવે છે અને તેથી હવે આ યાદીમાં બંને અર્ધભાગ સૉર્ટ કરી છે
અમે આ નંબર ફરી પાછા સાથે જોડાઇ શકે છે.
તેથી અમે 50 અને 3 જોવા; 3 50 કરતાં નાની હોય છે, તેથી તે પ્રથમ જાય અને પછી 50 સાઇન આવે છે
હવે, તે થઈ છે; અમે પાછા જાઓ કે યાદી અને સૉર્ટ તે અડધા કરવા માટે છે.
42 તે પોતાના નંબર છે, જેથી તે પહેલેથી જ છટણી છે.
તેથી હવે અમે આ તુલના 2 અને 3 42 કરતાં નાની હોય છે, કે જેથી પ્રથમ મૂકવા નહીં,
હવે 42 માં મૂકી નહીં, અને 50 સાઇન મૂકવા નહીં
હવે, કે છટણી છે, અમે બધા માર્ગ પર પાછા જાઓ ટોચ પર, 1337 અને 15.
વેલ, અમે હવે આ યાદી ડાબી અડધા જોવા; 1337 પોતે છે જેથી તે છટણી અને 15 છે સાથે જ.
તેથી હવે અમે આ 2 નંબરો ભેગા કે મૂળ યાદી, 15 <1337, સૉર્ટ
તેથી તે પ્રથમ જાય, પછી 1337 સાઇન જાય
અને હવે અમે ઉપર મૂળ યાદી બંને અર્ધભાગ સોર્ટ થાય છે.
અને તમામ અમે હોય તો આ ભેગા છે.
અમે આ યાદીમાં પ્રથમ 2 નંબરો, 3 <15 જોવા છે, તેથી તે પ્રકારની એરે પર પ્રથમ વખત જાય છે.
15 <42, તેથી તેને સાઇન હવે જાય છે, 42 <1337, કે જે સાઇન જાય
50 <1337, તેથી તેને સાઇન જાય અને નોંધ્યું છે કે અમે માત્ર 2 નંબરો આ યાદી ઉપડ્યો.
તેથી અમે ફક્ત 2 યાદીઓ વચ્ચે વારાફરતી રહ્યા છો.
અમે હમણાં જ શરૂઆતમાં શોધી રહ્યાં છો, અને અમે તત્વ વાત કરી રહ્યાં છે
કે પછી અને નાના તે અમારી એરે માં મૂકી છે.
હવે અમે તમામ છિદ્ર મર્જ કરી છે અને અમે પૂર્ણ કરી લીધું.
>> વિશે કોઇ પ્રશ્નો સૉર્ટ મર્જ? હા?
[વિદ્યાર્થી] જો તે અલગ અલગ જૂથોમાં વિભાજન છે, તેઓ માત્ર શા માટે નથી તે નથી એકવાર વિભાજિત
અને તમે એક જૂથમાં 3 અને 2 છે? [પ્રશ્ન દુર્બોધ રેસ્ટ ઓફ]
કારણ - જેથી પ્રશ્ન છે, અમે માત્ર કે પ્રથમ પગલું ન શા માટે તેમને મર્જ કરી પછી અમે તેમને છે?
કારણ કે અમે આ કરી શકો છો, બન્ને પક્ષો ડાબી સૌથી તત્વો શરૂ થાય છે,
અને પછી નાના એક ભરે છે અને તેને મૂકી છે કે અમે કે આ ખબર
વ્યક્તિગત યાદીઓ છટણી ઓર્ડર છે.
તેથી જો હું બંને અર્ધભાગ ડાબી સૌથી તત્વો જોઈ રહ્યો છું,
મને ખબર છે તેઓ તે યાદીઓ નાના તત્વો પ્રયત્ન રહ્યા છીએ.
તેથી હું તેમને નાનું આ વિશાળ યાદી તત્વ સ્પોટ મુકી શકે છે.
બીજી બાજુ, જો હું ત્યાં ઉપર બીજા સ્તર તે 2 યાદીઓ જોવા,
50, 3, 42 1337, અને 15, નહિં કે જે અલગ પાડવામાં આવે છે.
તેથી જો હું 50 અને 1337 માટે જુઓ, હું મારું યાદી માં 50 પ્રથમ મૂકવા જાઉં છું.
પરંતુ ખરેખર અર્થમાં નથી, કારણ કે તે 3 બધા બહાર નાનું તત્વ છે.
જેથી માત્ર કારણ અમે આ સંયુક્ત પગલું કરી શકો છો છે કારણ કે અમારા યાદીઓ પહેલાથી જ અલગ પાડવામાં આવે છે.
જે શા માટે અમે નીચે નીચે બધી રીતે વિચાર છે
કારણ કે જ્યારે અમે માત્ર એક જ નંબર હોય, તમે કે જે એક નંબર ખબર
અને પોતાના પહેલેથી જ છટણી યાદી છે.
>> કોઈપણ પ્રશ્ન છે? નહીં?
જટિલતા? સારું, તમે જોઈ શકો છો કે જે દરેક પગલે ત્યાં ઓવરને નંબરો છે,
અને અમે અડધા લોગ n એ સમયમાં યાદી વિભાજિત કરી શકો છો,
જે છે જ્યાં અમે આ n એક્સ લોગ n જટિલતા છે.
અને તમે મર્જ સૉર્ટ માટે શ્રેષ્ઠ કેસ n લોગ n છે જુઓ, અને પડશે તે જ થાય છે
કે ખરાબ કિસ્સામાં, અથવા ત્યાં ઉપર Ω પણ n n પ્રવેશો.
ધ્યાનમાં રાખો કંઈક.
પર ખસેડવું, ચાલો કેટલાક સુપર મૂળભૂત ફાઈલ હું ઓ / પર જાઓ
જો તમે ભાંખોડિયાંભર થઈને તપાસ્યા હતા, તમે નોટિસ પડશે અમે સિસ્ટમ અમુક પ્રકારની હતી
તમે જ્યાં લૉગ ફાઇલ લખી જો તમે કોડ દ્વારા વાંચી શકે છે.
ચાલો કેવી રીતે તમે આ કરી શકે છે.
વેલ અમે fprintf છે, કે જે તમે હમણાં જ તરીકે printf વિચાર કરી શકો છો,
પણ માત્ર ફાઈલ બદલે છાપવા અને તેથી શરૂઆતમાં એફ.
કોડ આ અહીં સૉર્ટ કરો, તેને શું છે, તમે ભાંખોડિયાંભર થઈને જોવા હોઈ શકે છે,
તે પંક્તિ નંબરો કયા છે દ્વારા પંક્તિ તમારા એરે 2-પરિમાણીય પ્રિન્ટીંગ જાય છે.
આ કિસ્સામાં, તમારા printf ટર્મિનલ માટે છાપે છે અથવા આપણે શું વિભાગ પ્રમાણભૂત આઉટપુટ પર ફોન કરો.
>> અને હવે, આ કિસ્સામાં, બધા અમે શું હોય છે fprintf સાથે printf બદલો,
તે કહેવું ફાઈલ શું તમે છાપવાનો કરવા માંગો છો, અને આ કિસ્સામાં તે માત્ર તેને છાપે છે કે ફાઈલ માટે
ને બદલે તેને છાપી તમારા ટર્મિનલ માટે.
વેલ, પછી કે પ્રશ્ન begs: અમે ક્યાથી નથી ફાઈલ આ પ્રકારની વિચાર, અધિકાર?
અમે આ fprintf fuction લૉગ ઇન પસાર પણ અમે કોઈ વિચાર જ્યાં તે તરફથી આવ્યા હતા.
વેલ, કોડ શરૂઆતમાં, અમે હતી શું અહીં ઉપર કોડ આ ભાગ હતો,
જે મૂળભૂત રીતે કહે છે કે ખુલ્લી ફાઇલ log.txt કહે છે.
અમે શું પછી એ જ છે કે અમે ખાતરી કરો કે ફાઈલ ખરેખર સફળતાપૂર્વક ખોલવામાં આવે છે બનાવવા હોય છે.
જેથી તે બહુવિધ કારણો માટે નિષ્ફળ રહેશે; તમે તમારા કમ્પ્યુટર પર પૂરતી જગ્યા ન હોય તો, ઉદાહરણ તરીકે.
તેથી તે હંમેશા મહત્વપૂર્ણ પહેલાં તમે ફાઇલ સાથે કોઇ કામગીરી કરી
કે અમે તપાસ કે શું ફાઈલ સફળતાપૂર્વક ખોલવામાં આવી હતી.
તેથી શું છે કે, તે fopen એક દલીલ છે, સાથે સાથે, અમે ઘણી રીતે ફાઇલ ખોલી શકે છે.
અમે શું છે કરી શકો છો, તો અમે તેને વાઇડ પસાર કરી શકો છો, કે જે ફાઈલ પર ફરીથી લખી અર્થ છે જો તે બહાર નીકળે છે પહેલાથી જ,
અમે એક પસાર કરવા માટે, જે તેમને ફાઈલ ઓવરને તેને ઓવરરાઈડીંગ બદલે ઉમેરી શકો છો,
અથવા આપણે r સ્પષ્ટ કરવા માટે, કે જેનો અર્થ કરી શકો છો, ચાલો તરીકે ફક્ત વાંચવા માટે ફાઇલ ખોલો.
તેથી જો કાર્યક્રમ ફાઈલ સાથે કોઈપણ ફેરફારો કરવા પ્રયાસ કરે છે,
તેમને અંતે કિકિયારી નથી અને તેમને તે નથી.
છેલ્લે, એક વાર અમે ફાઇલ સાથે પૂર્ણ કરી પૂરી તેના પર કામગીરી કરી,
અમે ખાતરી કરવા માટે અમે ફાઈલ બંધ કરવાની જરૂર છે.
અને તેથી તમારા કાર્યક્રમ ઓવરને અંતે, તમે તેમને ફરીથી પસાર જવું છે
આ ફાઇલ છે કે જે તમે ખોલી, અને માત્ર બંધ કરો.
તેથી આ મહત્વપૂર્ણ કંઈક કે જે તમે ખાતરી કરો કે તમે શું કરી હોય છે.
તેથી યાદ તમે ફાઈલ ખોલી શકે છે, તો પછી તમે ફાઇલ લખી શકે છે,
ફાઇલ માં કામગીરી કરી છે, પણ પછી તમે અંતે ફાઈલ બંધ હોય છે.
>> મૂળભૂત ફાઈલ પર કોઈપણ પ્રશ્નો I / O? હા?
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]
અહીં અધિકાર. આ પ્રશ્ન છે, જ્યાં આ log.txt ફાઈલ નથી દેખાય છે?
વેલ, જો તમે તેને log.txt આપી, તેને એક્ઝેક્યુટેબલ તરીકે એજ ડિરેક્ટરીમાં બનાવે છે.
તેથી જો you're - >> [વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]
હા. એ જ ફોલ્ડર માં, અથવા સમાન ડિરેક્ટરીમાં તરીકે તમે તેને ફોન કરો.
હવે મેમરી, સ્ટેક ઢગલો, અને.
આમ કેવી રીતે કમ્પ્યૂટર બહાર નાખ્યો મેમરી છે?
સારું, તમે આ અહીં બ્લોક જેવું તરીકે મેમરી કલ્પના કરી શકો છો.
અને અમે મેમરી હોય શું ત્યાં પર અટકી ઢગલો, અને સ્ટેક કે નીચે ત્યાં કહેવાય છે.
અને ઢગલો નીચેની તરફ વધે છે અને સ્ટેક ઉપરનું વધે છે.
જેથી ટોમી ઉલ્લેખ કર્યો છે - ઓહ જ છે, અને અમે આ અન્ય 4 સેગમેન્ટો મને બીજા મળશે હોય -
તરીકે ટોમી અગાઉ કહ્યું હતું કે, તમે જાણો છો કે કેવી રીતે તેના કાર્યો પોતાને કૉલ અને દરેક અન્ય કૉલ?
તેઓ સ્ટેક ફ્રેમ આ પ્રકારની બિલ્ડ.
વેલ, જો મુખ્ય foo કોલ્સ, foo સ્ટેક પર મૂકી નહીં.
Foo કહે બાર બાર, વિચાર માતાનો સ્ટેક પર મૂકવામાં આવે છે, અને તે સ્ટેક પર પછી મૂકવા નહીં.
અને તેઓ પાછા ફરવા માટે, તેઓ દરેક બોલ સ્ટેક લેવામાં છે.
આ સ્થાનો દરેક અને મેમરી પકડી શકું?
વેલ, ટોચની છે, કે જે લખાણ સેગમેન્ટ છે કાર્યક્રમ પોતે સમાવે છે.
મશીન કોડ તેથી, કે ત્યાં છે, એક વાર તમે તમારા કાર્યક્રમ કમ્પાઇલ.
આગળ, કોઇપણ વૈશ્વિક ચલો આરંભ.
>> જેથી તમે તમારા કાર્યક્રમ વૈશ્વિક ચલો હોય છે, અને તમે જેમ = 5 કહેવું,
કે જે સેગમેન્ટમાં મૂકવા નહીં, અને જમણી કે હેઠળ,
તમે કોઈપણ uninitialized વૈશ્વિક દશાંશ માહિતી, કે જે માત્ર એક ઈન્ છે,
પરંતુ તમે કહેશો નહીં, તે કંઇ માટે સમાન છે.
સમજો આ વૈશ્વિક ચલો છે, તેથી તેઓ મુખ્ય બહાર છો.
તેથી આ કોઇ વૈશ્વિક ચલો કે જાહેર છે પરંતુ આરંભ નથી થાય છે.
તેથી શું ઢગલો છે? મેમરી malloc છે, કે જે અમે થોડો માં મળશે મદદથી ફાળવવામાં આવે છે.
અને છેલ્લે, સ્ટેક સાથે તમે કોઈપણ સ્થાનિક ચલો છે
અને કોઈ ફંક્શન્સ તમને તેમના પરિમાણો કોઇ પણ કહી શકે છે.
છેલ્લા વસ્તુ, તમે ખરેખર જાણવા પર્યાવરણ ચલો શું નથી,
પરંતુ જ્યારે તમે કાર્યક્રમ ચલાવો, ત્યાં સંકળાયેલ કંઈક છે, જેમ કે
આ વ્યક્તિ જે કાર્યક્રમ ચાલી હતી વપરાશકર્તાનામ છે.
અને તે માટે નીચે પ્રકારના જ હશે.
મેમરી સરનામાંઓ, જે હેક્સાડેસિમલ કિંમતો છે દ્રષ્ટિએ,
0 અંતે ટોચની શરૂઆતમાં કિંમતો, અને તેઓ બધી રીતે જવું નીચે.
આ કિસ્સામાં, જો તમે સિસ્ટમને 32-bit કરશો,
તળિયે સરનામા માટે 0x પ્રયત્ન રહ્યું છે, એએફ અનુસરતા, કારણ કે તે 32 બીટ છે,
જે 8 બાઇટ્સ છે, અને આ કિસ્સામાં 8 બાઇટ્સ 8 હેક્સાડેસિમલ અંકો અનુલક્ષે છે.
જેથી નીચે અહીં તમે, પસંદ, 0xffffff જઈ રહ્યાં છો, અને ત્યાં તમને 0 હોય રહ્યા છીએ.
તેથી પોઇંટરો શું છે? તમે કેટલાક આ વિભાગમાં નહિં આવે તે પહેલા આવરી શકે છે.
પરંતુ અમે તે ઉપર વ્યાખ્યાન જવા નહોતો તેથી, એક નિર્દેશક માત્ર એક માહિતી પ્રકાર છે
ભંડાર છે, જે તેના બદલે 50 જેવી કિંમત અમુક પ્રકારના છે, તે મેમરીમાં કેટલાક સ્થાન સરનામા ના સંગ્રહ કરે છે.
કે મેમરી જેમ [દુર્બોધ].
તેથી આ કિસ્સામાં, અમે શું છે, તો અમને પૂર્ણાંક અથવા પૂર્ણાંક * એક નિર્દેશક હોય છે,
અને તે 0xDEADBEEF આ હેક્સાડેસિમલ સરનામા સમાવે છે.
>> તેથી અમે શું છે, હવે, મેમરી કેટલાક સ્થાન પર આ નિર્દેશક પોઇન્ટ
અને તે માત્ર એક, 50 કિંમત આ મેમરી સ્થાન પર છે.
કેટલાક 32-bit સિસ્ટમો પર, બધા 32-bit સિસ્ટમો પર, પોઇંટરો અપ 32 બિટ્સ અથવા 4 બાઇટ્સ લો.
પરંતુ, ઉદાહરણ તરીકે, સિસ્ટમ 64-bit પર પોઇન્ટર 64 બિટ્સ છે.
જેથી કંઈક તમે ધ્યાનમાં રાખવા માંગો છો શકે છે.
તેથી એક સિસ્ટમ ઓવરને-bit, એક નિર્દેશક ઓવરને બિટ્સ છે બનાવ્યો.
પોઇન્ટર પ્રકારના વધારાના વસ્તુઓ વગર હાર્ડ પાચન છે,
તેથી આપણે ગતિશીલ મેમરી ફાળવણી એક ઉદાહરણ દ્વારા જાઓ.
શું ગતિશીલ મેમરી ફાળવણી તમારા માટે કરે છે, અથવા આપણે શું malloc કહી,
તે તમને સેટ બહાર દશાંશ માહિતી અમુક પ્રકારની ફાળવો.
તેથી આ માહિતી પ્રકારના વધુ કાર્યક્રમના સમયગાળા માટે કાયમી.
જેમ તમે જાણો છો, કારણ કે, જો તમે એક કાર્ય ની અંદર x છે, અને તે કાર્ય વળતર જાહેર,
તમે લાંબા સમય સુધી માહિતી કે એક્સ માં સંગ્રહ કરવામાં વપરાશ હોય છે.
પોઇન્ટર અમને શું છે તે અમને મેમરી અથવા સ્ટોર કિંમતો સ્ટોર
મેમરી અલગ સેગમેન્ટ છે, નામ અનુસાર ઢગલો છે.
હવે એક વાર અમે કાર્ય બહાર પાછો સુધી અમે એક નિર્દેશક હોય છે
મેમરી કે સ્થાન, પછી અમે શું કરી શકો છો છે અમે માત્ર ત્યાં કિંમતો જોવા કરી શકો છો.
ચાલો એક ઉદાહરણ જોવા: આ અમારી મેમરી લેઆઉટ ફરી છે.
અને અમે આ કાર્ય હોય છે, મુખ્ય.
તે શું છે - ઠીક છે, તેથી સરળ, જમણી - પૂર્ણાંક એક્સ = 5, કે જે હમણાં જ મુખ્ય માં સ્ટેક પર એક ચલ છે.
>> બીજી બાજુ, હવે આપણે એક નિર્દેશક જે કાર્ય giveMeThreeInts કહે જાહેર.
અને તેથી હવે અમે આ કાર્ય જાય છે અને અમે તે માટે એક નવો સ્ટેક ફ્રેમ બનાવો.
જો કે, આ સ્ટેક ફ્રેમમાં, અમે પૂર્ણાંક temp * જાહેર,
જે mallocs અમારા માટે 3 પૂર્ણાંકો છે.
તેથી પૂર્ણાંક કદ અમને આપો કેટલા બાઇટ્સ આ પૂર્ણાંક છે,
અને malloc અમને આપે છે કે ઢગલો પર જગ્યા ઘણા બાઇટ્સ.
તેથી આ કિસ્સામાં, અમે 3 પૂર્ણાંકો માટે પૂરતી જગ્યા બનાવી છે,
અને ઢગલો માર્ગ ઉપર ત્યાં છે, કે જે શા માટે હું આ દોરવામાં કર્યું છે ઊંચી છે.
એકવાર અમે પૂર્ણ કરી લો, અમે પાછા અહીં આવે છે, તમે માત્ર જરૂર 3 ints પાછો ફર્યો,
અને તે સરનામું આપે છે, જ્યાં છે કે મેમરી છે ઉપર આ કેસ છે.
અને અમે નિર્દેશક સ્વીચ = સુયોજિત કરો, અને ત્યાં અમે અન્ય નિર્દેશક હોય છે.
પરંતુ શું કે કાર્ય વળતર અહીં મુક્યા છે અને અદૃશ્ય થઈ જાય છે.
તેથી temp અદૃશ્ય થઈ જાય છે, પરંતુ અમે હજુ પણ જ્યાં ની સરનામા જાળવવા
તે 3 પૂર્ણાંકો મુખ્ય ની અંદર હોય છે.
તેથી આ સમૂહ માં, પોઇંટરો scoped સ્થાનિક છે સ્ટૅક્ડ ફ્રેમ માટે,
પરંતુ મેમરી કે જે તેમને સંદર્ભ લો તો ઢગલો છે.
>> એ નથી કે સૂઝ છે?
[વિદ્યાર્થી] કે જે તમને પુનરાવર્તન કરશો? >> [જોસેફ] હા.
તેથી જો હું પાછા માત્ર થોડો જાઓ, તમે જુઓ છો કે કામચલાઉ નોકર ફાળવવામાં
ત્યાં સુધી હીપ પર અમુક મેમરી.
તેથી જ્યારે આ કાર્ય, વળતર giveMeThreeInts, આ અહીં સ્ટેકમાંથી અદૃશ્ય થઈ જાય છે.
અને તે ચલો કોઇપણ પણ, આ કિસ્સામાં, આ નિર્દેશક કે સ્ટૅક્ડ ફ્રેમમાં ફાળવવામાં હતું.
કે અદૃશ્ય થઈ રહ્યું છે, પણ ત્યારથી અમે કામચલાઉ નોકર પરત
અને અમે નિર્દેશક સેટ = કામચલાઉ નોકર, નિર્દેશક હવે સ્થાન સમાન મેમરી કામચલાઉ નોકર હતો નિર્દેશ બનશે.
તેથી હવે, તેમ છતાં અમે કામચલાઉ નોકર છે, કે જે સ્થાનિક નિર્દેશક ગુમાવો છો,
અમે હજુ તે શું છે કે ચલ નિર્દેશક ની અંદર તરફ ઇશારો કરવામાં આવ્યો હતો મેમરી સરનામા જાળવી રાખી છે.
પ્રશ્નો? કે જે ગૂંચવણમાં વિષય પ્રકારની હોઈ શકે જો તમને તે ઉપર વિભાગમાં નહિં ચાલ્યા ગયા છે શકે છે.
અમે, તમારા ટીએફ ચોક્કસપણે હશે તેની પર જાઓ અને અલબત્ત અમે પ્રશ્નોના જવાબ કરી શકો છો
આ માટે સમીક્ષા સત્ર ઓવરને અંતે.
પરંતુ આ જટિલ વિષય જેવું છે, અને હું વધુ ઉદાહરણો છે કે જે બતાવે જતાં હોય છે
કે મદદ કરશે સ્પષ્ટ પોઇંટરો ખરેખર શું છે.
>> આ કિસ્સામાં, પોઇંટરો એરે માટે સમકક્ષ હોય છે,
તેથી હું ફક્ત પૂર્ણાંક એરે તરીકે જ બાબત તરીકે આ નિર્દેશક વાપરી શકો છો.
તેથી હું 0 માં ક્રમાંકિત છું, અને 1 થી પ્રથમ પૂર્ણાંક બદલી રહ્યા હોય,
2 એ બીજા પૂર્ણાંક બદલવા, અને 3 પૂર્ણાંક માટે 3.
તેથી પોઇન્ટર પર વધુ. વેલ, Binky યાદ અપાવે છે.
આ કિસ્સામાં અમે નિર્દેશક ફાળવવામાં કર્યું છે, અથવા અમે નિર્દેશક જાહેર
પરંતુ શરૂઆતમાં જ્યારે હું માત્ર એક નિર્દેશક જાહેર, પછી તે મેમરીમાં ક્યાંય નથી પોઇન્ટ છે.
તે માત્ર તે અંદર કચરો કિંમતો છે.
તેથી હું કોઈ વિચાર જ્યાં આ નિર્દેશક માટે પોઇન્ટ છે.
તે સરનામું કે જેને માત્ર 0 અને 1 ની જ્યાં તે શરૂઆતમાં જાહેર કરવામાં આવી ભરવામાં આવે છે.
મેં કંઈપણ આ સાથે નથી ત્યાં સુધી હું તેના પર malloc કહી શકો છો
અને પછી તે મને ઢગલો જ્યાં હું કિંમતો અંદર મૂકી શકો છો પર થોડો અવકાશ આપે છે.
પછી ફરીથી, મને ખબર નથી શું આ મેમરી ની અંદર છે.
જેથી પ્રથમ વસ્તુ મને શું હોય છે કે કેમ તેની તપાસ સિસ્ટમ પૂરતી મેમરી હતી
મને આપી પાછા પ્રથમ સ્થાને છે, કેમ કે હું જે કરી રહ્યો છું અને આ તપાસ માં 1 પૂર્ણાંક.
જો નિર્દેશક નલ છે, કે જે અર્થ એ થાય કે તે પૂરતી જગ્યા અથવા અમુક અન્ય ભૂલ આવી ન હતી,
જેથી હું મારા કાર્યક્રમની બહાર નીકળવા માટે કરવો જોઈએ.
પરંતુ જો તે સફળ કર્યું છે, હવે હું કે નિર્દેશક ઉપયોગ કરી શકો છો
અને * નિર્દેશક કરે છે શું છે તે અનુસરે છે જ્યાં સરનામું છે
તે કિંમત છે, જ્યાં છે અને તેને 1 થી સમાન સુયોજિત કરે છે.
અહીં પર, અમે જો કે મેમરી અસ્તિત્વમાં ચકાસણી કરી રહ્યા છીએ.
>> એકવાર તમે જાણો છો તે હાજર હોય, તો તમે તેને મુકી શકે છે
આ 1 કિસ્સામાં; શું કિંમત તમે તેને મૂકવામાં માંગો છો.
એકવાર અમે તેને પૂર્ણ કરી લીધું છે, શું તમે તે નિર્દેશક મુક્ત કરવાની જરૂર છે
કારણ કે અમે સિસ્ટમ છે કે જે મેમરી કે તમે પ્રથમ સ્થાને માટે પૂછવામાં પાછા જરૂર છે.
કારણ કે કમ્પ્યૂટર ખબર નથી ત્યારે અમે તેને પૂર્ણ કરી લીધું છે.
આ કિસ્સામાં અમે તેને બાહ્ય રીતે કહેવાની કરી રહ્યાં છો, ઠીક, અમે તે મેમરી સાથે પૂર્ણ કરી લીધું.
જો અમુક અન્ય પ્રક્રિયા તેને જરૂર છે, કેટલાક અન્ય કાર્યક્રમ તેને જરૂર છે, માટે આગળ વધીશું અને તે લઈ શકો છો.
અમે પણ શું કરી શકો છો છે અમે સેટ પર સ્થાનિક ચલો ના સરનામા મેળવી શકો છો.
તેથી પૂર્ણાંક એક્સ મુખ્ય ના સ્ટૅક્ડ ફ્રેમ અંદર છે.
અને જ્યારે અમે આ & "અને" નું ચિહ્ન વાપરવા માટે, આ અને ઓપરેટર, તેને શું છે
તે x લે છે, અને એક્સ માત્ર મેમરી કેટલીક માહિતી છે, પરંતુ તે એક સરનામું છે.
તે ક્યાંક સ્થિત થયેલ છે. જેથી દ્વારા કૉલિંગ અને એક્સ, આ શું કરે છે તે અમને x ની સરનામું આપે છે.
આમ, અમે જ્યાં એક્સ મેમરીમાં છે નિર્દેશક બિંદુ બનાવી રહ્યા છો.
હવે અમે ફક્ત * કંઈક એક્સ નથી, અમે કરી રહ્યા છીએ 5 પાછી મેળવવા જઈ રહી છે.
આ તારો તે dereferencing કહેવામાં આવે છે.
તમે સરનામા અનુસરવા અને તમે તેને કિંમત ત્યાં સંગ્રહિત છે.
>> કોઈપણ પ્રશ્ન છે? હા?
[વિદ્યાર્થી] જો તમે આ વસ્તુ 3-પોઇન્ટેડ ન કરવું હોય, તો તે હજી પણ નથી કમ્પાઇલ?
હા. જો તમે વસ્તુ 3-નિર્દેશક ન કરવું હોય, તો તે હજી પણ કમ્પાઇલ ચાલી રહ્યું છે,
પરંતુ હું તમને બતાવે છે, શું કરશો બીજી બને છે અને તે કે આમ કર્યા વિના,
કે અમે શું મેમરી છિદ્ર કૉલ કરો. તમે સિસ્ટમ આપતા નથી કરી રહ્યાં છો
તેની મેમરી બેક, તેથી પછી જ્યારે કાર્યક્રમ માટે એકઠા રહ્યું છે
મેમરી કે તેનો ઉપયોગ નથી, અને તે જ બીજું કંઇ તેનો ઉપયોગ કરી શકો છો.
જો તમે ક્યારેય તમારા કમ્પ્યુટર પર 1.5 મિલિયન કિલોબાઈટોમાં સાથે કર્યું છે ફાયરફોક્સ જોવા મળે છે,
કાર્ય વ્યવસ્થાપક, તે શું થઈ રહ્યું છે.
તમારે કાર્યક્રમ છે કે તેઓ સંભાળાતા ન કરી રહ્યાં છો મેમરી છિદ્ર હોય છે.
આમ કેવી રીતે નિર્દેશક અંકગણિત કામ કરે છે?
વેલ, નિર્દેશક અંકગણિત ઝાકઝમાળ માં જેમ ઈન્ડેક્સીંગ જેવું છે.
આ કિસ્સામાં, હું એક નિર્દેશક હોય છે, અને હું શું છે હું પ્રથમ તત્વ માટે નિર્દેશક મુદ્દો
3 પૂર્ણાંકો કે હું ફાળવવામાં કર્યું છે આ ઍરેની.
તેથી હવે મારે શું કરવું, સ્ટાર નિર્દેશક માત્ર યાદીમાં પ્રથમ તત્વ બદલે છે.
સ્ટાર નિર્દેશક અહીં પર +1 નિર્દેશ કરે છે.
+1 નિર્દેશક, તેથી નિર્દેશક અહીં વધારે છે ઉપર અહીં છે, +2 નિર્દેશક પર અહીં છે.
>> તેથી ફક્ત 1 ઉમેરીને આ એરે સાથે થતાં જ વસ્તુ છે.
અમે શું છે, જ્યારે અમે +1 નિર્દેશક તમે અહીં ઉપર સરનામા વિચાર,
અને અહીં આ કિંમત વિચાર ક્રમમાં, તમે સમગ્ર અભિવ્યક્તિ માંથી એક તારો મૂકી
તેને ડિરેફરન્સ.
તેથી, આ કિસ્સામાં, હું 1 થી આ એરે માં પ્રથમ સ્થાન સુયોજિત છું,
2 બીજા સ્થાન, અને સ્થાન માટે 3 ત્રીજા સ્થાન.
પછી હું ઉપર કરી રહ્યો છું અહીં શું છે હું અમારા +1 નિર્દેશક છાપવા છું,
જે ફક્ત મને 2 આપે છે.
હવે હું નિર્દેશક incrementing છું, જેથી નિર્દેશક +1 નિર્દેશક સમકક્ષ,
જે તેને આગળ ખસે છે.
અને તેથી હવે જો હું +1 નિર્દેશક છાપો, નિર્દેશક +1 હવે 3,
આ કિસ્સામાં જે 3 છાપે છે.
અને ક્રમમાં મફત કંઈક તો, નિર્દેશક કે હું તેને આપી
એરે જે હું malloc માંથી પાછા મળી શરૂઆતમાં પોઇન્ટ હોવું જ જોઈએ.
તેથી, આ કિસ્સામાં, જો હું 3 અહીં કહી હતી, આ અધિકાર નહીં હોય,
કારણ કે તે એરે મધ્યમાં છે.
હું મૂળ સ્થાન મેળવવા સબ્ટ્રેક્ટ છે
પ્રારંભિક પ્રથમ સ્પોટ પહેલા હું તેને મુક્ત કરી શકો છો.
તેથી, અહીં વધુ સંકળાયેલી ઉદાહરણ છે.
આ કિસ્સામાં, અમે એક અક્ષર એરે માં 7 અક્ષરો allocating કરી રહ્યાં છો.
>> અને આ કિસ્સામાં અમે શું કરી રહ્યા છે અમે તેમને પ્રથમ 6 પર રહ્યાં રહ્યાં છો,
અને અમે તેમને ઝેડ માટે સુયોજિત કરી રહ્યાં છો
તેથી, પૂર્ણાંક માટે હું = 0, આઇ 6>, હું + +,
તેથી, નિર્દેશક + + હું અમને ફક્ત આ કિસ્સામાં આપવાની રહેશે,
નિર્દેશક, +1 નિર્દેશક, +2 નિર્દેશક, +3 નિર્દેશક, અને તેથી અને જેથી લુપમાં આગળ.
તે શું થઈ રહ્યું છે તે શું છે તે સરનામા નોંધાયો નહીં, dereferences તે કિંમત મેળવવા માટે,
અને ફેરફારો કે જે ઝેડ માટે કિંમત
પછી ઓવરને અંતે યાદ આ શબ્દમાળા છે અધિકાર?
બધા શબ્દમાળાઓ માટે નલ બંધ પાત્ર સાથે અંત હોય છે.
તેથી, હું શું છે 6 પોઇન્ટર હું સાઇન તેનો નલ ટર્મીનેટર પાત્ર મૂકી
અને હવે હું શું મૂળભૂત પર છું અહીં કરી printf શબ્દમાળા માટે યોગ્ય અમલીકરણ છે?
>> તેથી, printf હવે જ્યારે નથી જ્યારે તે છે એક શબ્દમાળાને અંતે પહોંચી?
જ્યારે તેને નલ બંધ અક્ષર બનાવ્યા.
તેથી, આ કિસ્સામાં, મારા આ એરે શરૂઆતમાં મૂળ નિર્દેશક નિર્દેશ કરે છે.
હું પ્રથમ અક્ષર છાપો આઉટ. હું તેને એક ખસેડો.
હું કે અક્ષર છાપો આઉટ. હું તેને ખસેડવા પર.
અને હું આ કરી ત્યાં સુધી હું ઓવરને સુધી પહોંચવા રાખો.
અને હવે ઓવરને * નિર્દેશક ડિરેફરન્સ આ અને નલ બંધ અક્ષર પાછા મળી જશે.
અને તેથી મારું જ્યારે લૂપ સ્કોર ત્યારે જ કે કિંમત નલ બંધ અક્ષર નથી.
તેથી, હવે હું આ લૂપની બહાર બહાર નીકળો.
અને તેથી જો હું આ નિર્દેશક થી 6 સબ્ટ્રેક્ટ,
હું પાછા શરૂઆતમાં તમામ માર્ગ પર જાઓ.
યાદ રાખો, હું આ કરી રહ્યો છું કારણ કે હું આ શરૂઆત પર જાઓ કરવા માટે તેને મુક્ત હોય છે.
>> તેથી, હું જાણું છું કે ઘણી મજા આવી. ત્યાં કોઇ પ્રશ્નો છે?
કૃપા કરીને, હા!
[વિદ્યાર્થી પ્રશ્ન દુર્બોધ]
કે જે તમને કહી શકું મોટેથી? માફ કરશો.
[વિદ્યાર્થી] છેલ્લી સ્લાઇડ અધિકાર પહેલાં તમે નિર્દેશક મુક્ત પર,
તમે ખરેખર જ્યાં હતા નિર્દેશક કિંમત બદલવા?
[જોસેફ] તેથી, અહીં. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.
[જોસેફ] તેથી, હું એક નિર્દેશક બાદ બાદ હોય, અધિકાર,
જે વસ્તુ એક પાછા ફરે છે અને પછી હું તેને મુક્ત,
કારણ કે આ નિર્દેશક માટે એરે શરૂઆત પર ધ્યાન હોય છે.
[વિદ્યાર્થી] પરંતુ તે હતી કે જે તમને લીટી પછી અટકાવાયેલ હોવો જરૂરી નથી કરશે.
તેથી [જોસેફ], જો હું આ બાદ બંધ થઇ ગયા હતા, આ મેમરી છિદ્ર લેવામાં આવે છે,
કારણ કે હું મુક્ત ન સ્કોર નહોતો.
[વિદ્યાર્થી] હું [દુર્બોધ] પ્રથમ ત્રણ લીટીઓ જ્યાં તમે +1 નિર્દેશક [દુર્બોધ] પડી ગયો.
[જોસેફ] ઉહ-ઓહ. તેથી ત્યાં પ્રશ્ન શું છે?
માફ કરશો. ના, કોઈ. જાઓ, જાઓ, કૃપા કરીને.
તેથી [વિદ્યાર્થી], તમે પોઇંટરો કિંમત નથી બદલી રહ્યાં છીએ.
તમે નિર્દેશક બાદ બાદ કરી ન હતી.
[જોસેફ] હા, બરાબર.
તેથી, જ્યારે હું +1 નિર્દેશક અને +2 નિર્દેશક કરવું
હું નિર્દેશક નથી કરી રહ્યો છું +1 નિર્દેશક સમકક્ષ હોય છે.
તેથી, નિર્દેશક માત્ર એરે શરૂઆતમાં પોઇન્ટ રહે.
તે માત્ર ત્યારે હું વત્તા કરવું વત્તા કે તે નિર્દેશક અંદર કિંમત પાછા સુયોજિત કરે છે,
કે તે ખરેખર સાથે આ ખસે છે.
અધિકાર છે.
વધુ પ્રશ્નો છે?
>> ફરીથી, જો આ જબરજસ્ત જેવું છે, આ સત્રમાં આવરી લેવામાં આવશે.
તે વિશે તમારા સાથી શિક્ષણ કહો, અને અમે ઓવરને અંતે પ્રશ્નોના જવાબ આપી શકે છે.
અને સામાન્ય રીતે અમે આ બાદ વસ્તુ નથી ગમતું નથી.
આ મને ખૂબ હું કેવી રીતે એરે માં સરભર કર્યું છે રાખવામાં આવેલ જરૂર છે.
તેથી, સામાન્ય રીતે, આ માત્ર છે કેવી રીતે નિર્દેશક અંકગણિત કામો સમજાવે છે.
પરંતુ અમે સામાન્ય રીતે કરવા માંગો શું અમે નિર્દેશક એક નકલ બનાવવા માંગતા હોય છે,
અને પછી અમે એ નકલ વાપરો જ્યારે અમે આસપાસ શબ્દમાળા માં ખસેડીએ છીએ પડશે.
તેથી, આ કિસ્સામાં તમે નકલ સમગ્ર શબ્દમાળા છાપો વાપરવા માટે,
પરંતુ અમે નિર્દેશક બાદ 6 જેવા કરવું નહિં હોય અથવા કેટલી અમે આ ખસેડવામાં ટ્રેક રાખવા માટે,
માત્ર કારણ કે અમે જાણીએ છીએ કે અમારા મૂળ બિંદુ હજુ યાદી શરૂઆત પર ધ્યાન છે
અને બધા કે અમે બદલાઈ આ નકલ હતી.
તેથી, સામાન્ય રીતે, તમારા મૂળ નિર્દેશક નકલો બદલે છે.
પ્રયત્ન કરશો નહિં જેવા સૉર્ટ - મૂળ નકલો બદલવા don't.
તમારા મૂળ માત્ર નકલો બદલવા પ્રયાસ કરે છે.
તેથી, તમે નોટિસ જ્યારે અમે printf માં શબ્દમાળા પસાર
તમે તેને આગળ એક તારો મૂકવા જેવા અમે તમામ અન્ય dereferences સાથે ન હોય તો, યોગ્ય છે?
તેથી, જો તમે છાપે સમગ્ર શબ્દમાળા:% s અપેક્ષા એક સરનામું છે,
અને આ કિસ્સામાં એક નિર્દેશક અથવા અક્ષરો ઝાકઝમાળ જેમ આ કિસ્સામાં.
>> અક્ષરો, ઘરનાં પરચૂરણ કામો * s છે, અને એરે જ વસ્તુ છે.
પોઇન્ટર અક્ષરો છે, અને પાત્ર એરે જ વસ્તુ છે.
અને તેથી, બધા અમે હોય તો નિર્દેશક પાસ છે.
અમે * નિર્દેશક અથવા તે જેવો કંઈ જેવી પાસ નથી.
તેથી, એરે અને પોઇંટરો એ જ વસ્તુ છે.
જ્યારે તમે એક્સ કંઈક કરી રહ્યા છીએ એક એરે માટે અહીં પર [y],
તે હૂડ હેઠળ કરવાનું છે શું છે તે કહેતા છે, ઠીક છે, તે એક અક્ષર એરે છે,
જેથી તે એક નિર્દેશક છે.
અને તેથી એક્સ એ જ વસ્તુ છે,
અને તેથી તે શું કરે છે તે એક્સ માટે વાય ઉમેરે છે,
જે મેમરી આગળ કે ખૂબ થતાં જ વસ્તુ છે.
અને હવે એક્સ + + વાય અમને સરનામા અમુક પ્રકારની આપે છે,
અને અમે સરનામા ડિરેફરન્સ અથવા તીર અનુસરો
મેમરીમાં તે સ્થાન છે કે જ્યાં અને અમે મેમરી કે સ્થાન મૂલ્ય મેળવવા.
તેથી, તેથી આ બે બરાબર એ જ વસ્તુ છે.
તે માત્ર એક વાકયરચનામાં ખાંડ છે.
તેઓ આ જ વાત કરે છે. તેઓ દરેક અન્ય માટે માત્ર વિવિધ syntactics છો.
>> તેથી, શું પોઇન્ટર સાથે ખોટું જઇ શકો છો? જેમ, લોટ. ઠીક છે. તેથી, ખરાબ વસ્તુઓ.
કેટલાક ખરાબ વસ્તુઓ તમે કરી શકો છો, જો તમારી malloc કોલ નલ અધિકાર આપે છે તપાસી રહ્યા નથી કરી રહ્યાં છો?
આ કિસ્સામાં, હું સિસ્ટમ પૂછવા છું મને આપી - કે જે નંબર શું છે?
2 અબજ 4 વખત જેમ, કારણ કે એક પૂર્ણાંક કદ 4 બાઇટ્સ છે.
હું તેના માટે 8 અબજ બાઇટ્સ જેવી પૂછવા છું.
અલબત્ત મારા કમ્પ્યુટરને માટે મને તે બહુ મેમરી પાછા આપી શકશે નહિં રહ્યું છે.
અને અમે જો આ નલ નથી તપાસ કરી ન હતી, તેથી જ્યારે અમે તેને ત્યાં પર ડિરેફરન્સ પ્રયત્ન -
જ્યાં તે ચાલી રહ્યું છે તેને તીર અનુસરો - અમે કે મેમરી નથી.
આ છે જેને આપણે નલ નિર્દેશક dereferencing કૉલ કરો.
અને આ અનિવાર્યપણે તમે segfault માટે કારણ બને છે.
આ એક રીતે તમે segfault શકે છે.
અન્ય ખરાબ વસ્તુઓ તમે કરી શકો છો - ઓહ છે.
કે જે નલ નિર્દેશક dereferencing હતી. ઠીક છે.
અન્ય ખરાબ વસ્તુઓ છે - ઠીક છે, કે જે તમે હમણાં જ ત્યાં એક ચેક મૂકી
કે ચકાસે છે કે શું નિર્દેશક નલ છે
અને કાર્યક્રમ બહાર બહાર નીકળવા જો તે બને છે કે malloc એક નલ નિર્દેશક આપે છે.
કે xkcd કોમિક છે. લોકો હવે તેને સમજો. ના સૉર્ટ કરો.
>> તેથી મેમરી. અને હું આ પર ગયા હતા.
અમે લુપ માં malloc કૉલ કરી રહ્યાં છો, પરંતુ દર વખતે આપણે malloc કૉલ
અમે જ્યાં આ નિર્દેશક તરફ ઇશારો છે ટ્રેક ગુમાવી રહ્યાં છો,
કારણ કે અમે તેનો clobbering કરી રહ્યાં છો.
તેથી, malloc પ્રારંભિક કૉલ મને આપે મેમરી અહીં બનાવ્યા.
મારા માટે આ નિર્દેશક પોઇન્ટર.
હવે, હું તો તેને મુક્ત નથી, તેથી હવે હું malloc ફરી કૉલ કરો.
હવે તે ઉપર અહીં નિર્દેશ કરે છે. હવે મારી મેમરી ઉપર અહીં પોઇન્ટ છે.
ઉપર અહીં પોઇન્ટિંગ. ઉપર અહીં પોઇન્ટિંગ.
પરંતુ હું અહીં કે હું ફાળવવામાં પર તમામ મેમરી સરનામાંઓ ટ્રેક ગુમાવ્યું છે.
અને તેથી હવે હું તેમને કોઇ સંદર્ભ હવે નથી.
તેથી, હું તેમને આ લૂપની બહાર નથી મુક્ત કરી શકો છો.
અને તેથી ક્રમમાં આ કંઈક ઠીક કરવા માટે,
જો તમે મુક્ત મેમરી માટે ભૂલી જાઓ અને તમે આ મેમરી છિદ્ર વિચાર,
તમે આ લૂપની અંદર મેમરી મુક્ત એકવાર તમે તેને પૂર્ણ કરી લીધું છે.
વેલ, આ છે શું થાય છે. મને ખબર છે કે ઘણાં બધાં આ અપ્રિય.
પરંતુ હવે - યે! You 44.000 કિલોબાઈટોમાં જેવા મળે છે.
તેથી, તો તમે તેને લૂપ ઓવરને અંતે મુક્ત,
અને તે માત્ર મેમરી દર વખતે મુક્ત બનશે.
આવશ્યકપણે, તમારા કાર્યક્રમ મેમરી છિદ્ર હવે નથી.
>> અને હવે બીજું કંઈક તમે કરી શકો છો અમુક મેમરી કે તમે બે વાર માટે પૂછ્યું છે મુક્ત.
આ કિસ્સામાં, તમે malloc કંઈક, તમે તેની કિંમત બદલો.
તમે તેને મુક્ત છે કારણ કે તમે એક વખત જણાવ્યું હતું કે તેની સાથે કરવામાં આવી હતી.
પરંતુ તે પછી અમે તેને ફરીથી મુક્ત કર્યા હતા.
આ એવું કંઈક છે જે ખૂબ ખરાબ આપી છે.
તે શરૂઆતમાં segfault નથી ચાલી રહ્યું છે,
પરંતુ પછી શું ડબલ છે, આ બગડેલ તમારા ઢગલો માળખું મુક્ત કરીને જ્યારે,
અને તમે થોડો વધુ આ વિશે જાણવા માટે જો તમે CS61 જેવા વર્ગ લેવા પસંદ કરશો.
પરંતુ અનિવાર્યપણે એક પછી જ્યારે તમારી કમ્પ્યુટર ગુંચવણ ના થવી રહ્યું છે
મેમરી સ્થાનો શું છે જ્યાં જ્યાં અને તે સંગ્રહિત વિશે -
માહિતી મેમરીમાં જ્યાં સંગ્રહાયેલ છે.
અને તેથી નિર્દેશક મુક્ત કરીને બે વખત ખરાબ ચીજ છે કે તમે કરવા માંગતા નહિં હોય છે.
>> અન્ય વસ્તુઓ છે કે જે ખોટી જઈ શકે છે sizeof ઉપયોગ કરતા નથી.
તેથી, આ કિસ્સામાં તમે 8 બાઇટ્સ malloc,
અને તે બે પૂર્ણાંકો તરીકે જ વસ્તુ અધિકાર છે?
તેથી, કે સંપૂર્ણપણે સલામત છે, પરંતુ તે છે?
વેલ, તરીકે લુકાસ વિવિધ આર્કિટેક્ચરો પર વિશે વાત કરી,
પૂર્ણાંકો વિવિધ લંબાઈનો છે.
તેથી ઉપકરણ કે જે તમે ઉપયોગ કરી રહ્યાં છો પર, પૂર્ણાંકો લગભગ 4 બાઇટ્સ હોય છે,
પરંતુ અમુક અન્ય સિસ્ટમ પર તેઓ 8 બાઇટ્સ હોઈ શકે છે અથવા તેઓ 16 બાઇટ્સ હોઈ શકે.
તેથી, જો હું હમણાં જ અહીં ઉપર આ નંબરનો ઉપયોગ,
આ કાર્યક્રમ ઉપકરણ પર કામ કરી શકે છે,
પરંતુ તે કેટલાક અન્ય સિસ્ટમ પર પૂરતી મેમરી ફાળવી નથી ચાલી રહ્યું છે.
આ કિસ્સામાં, આ છે શું sizeof ઓપરેટર માટે વપરાય છે.
જ્યારે આપણે કહી (પૂર્ણાંક) sizeof, કરે શું છે
અમને સિસ્ટમ છે કે જે કાર્યક્રમ ચાલી રહ્યો છે તેના પર એક પૂર્ણાંક માપ આપે છે.
તેથી, આ કિસ્સામાં, sizeof (પૂર્ણાંક) એ સાધન કંઈક પર 4 આપશે,
અને હવે આ ઇચ્છા 4 2 *, કે જે 8 છે,
જે ફક્ત બે પૂર્ણાંકો માટે જરૂરી જગ્યા જથ્થો છે.
અલગ સિસ્ટમ પર, જો પૂર્ણાંક 16 બાઇટ્સ કે 8 બાઇટ્સ જેવી છે,
તે માત્ર એટલા બાઇટ્સ પરત કે જથ્થો સ્ટોર ચાલી રહ્યું છે.
>> અને છેલ્લે, સ્ટ્ર્ક્ટ્સ.
તેથી, જો તમે મેમરીમાં સુડોકુ બોર્ડ સંગ્રહવા માંગો, તો અમે કેવી રીતે આવું કરી શકે છે?
તમે પ્રથમ વસ્તુ માટે એક ચલ જેવા લાગે શકે છે,
બીજી વસ્તુ માટે એક ચલ, ત્રીજા વસ્તુ માટે એક ચલ,
ખરાબ, જમણી - ચોથા વસ્તુ માટે એક ચલ?
તેથી, એક સુધારણા તમે આ શીર્ષ પર કરી શકો છો એક 9 x 9 એરે માટે છે.
કે દંડ છે, પરંતુ જો તમે સુડોકુ બોર્ડ સાથે અન્ય વસ્તુઓ સાંકળવા માગે છે
ગમે બોર્ડના મુશ્કેલી શું છે,
અથવા, ઉદાહરણ તરીકે, તમારી સ્કોર શું છે, અથવા કેટલી સમયે તે તમે આ બોર્ડને હલ કરવા માટે લઈ જાય છે?
સારું, તમે શું કરી શકો છો છે તમે સ્ટ્રક્ટ બનાવી શકો છો.
હું મૂળભૂત કહી રહ્યો છું શું છે હું અહીં પર આ માળખું વ્યાખ્યાયિત છું,
અને હું એક સુડોકુ બોર્ડ જે બોર્ડ જે 9 છે 9 એક્સ સમાવે વ્યાખ્યાયિત છું.
>> અને તે શું છે તે સ્તર ના નામ પોઇન્ટર છે.
તે પણ એક્સ અને વાય છે, જે જ્યાં હું હમણાં છું એ કોઓર્ડિનેટ્સ છે.
તે પણ સમય [દુર્બોધ] ખર્ચ્યા છે, અને તે ચાલ હું અત્યાર સુધી ઇનપુટ કર્યું છે કુલ સંખ્યા ધરાવે છે.
અને તેથી આ કિસ્સામાં, હું હમણાં જ એક માળખામાં માહિતી સંપૂર્ણ જથ્થો જૂથ કરી શકો છો
તેના બદલે તે વિવિધ આસપાસ variables જેવી ઉડાન જેવી રહી ઓફ
કે હું ખરેખર ટ્રેક ન રાખે શકો છો.
અને આ દે અમને ફક્ત આ સ્ટ્રક્ટ ની અંદર અલગ વસ્તુઓ સંદર્ભ જેવું માટે સરસ વાક્યરચના છે.
હું board.board ફક્ત કરવા માટે, અને હું સુડોકુ બોર્ડ પાછા મેળવી શકો છો.
Board.level, હું વિચાર ખડતલ તે કેવી રીતે છે.
Board.x અને board.y મને જ્યાં હું બોર્ડ હોઇ શકે એ કોઓર્ડિનેટ્સ આપે છે.
અને તેથી હું ઍક્સેસ છું અમે શું સ્ટ્રક્ટ ક્ષેત્રો કૉલ કરો.
આ sudokuBoard છે, કે જે પ્રકારની છે કે હું હોય છે વ્યાખ્યાયિત કરે છે.
અને હવે અમે અહીં છીએ. હું એક પ્રકાર sudokuBoard "ની બોર્ડ" કહેવાય ચલ હોય છે.
અને તેથી હવે હું તમામ ક્ષેત્રો કે અહીં ઉપર આ માળખું બનાવે છે ઍક્સેસ કરી શકો છો.
>> સ્ટ્ર્ક્ટ્સ વિશે કોઈ પ્રશ્ન? હા?
પૂર્ણાંક એક્સ, વાય માટે [વિદ્યાર્થી], તમે એક વાક્ય પર બંને જાહેર? >> [જોસેફ] ઉહ-ઓહ.
[વિદ્યાર્થી] તેથી, તો તમે ફક્ત તેને તમામ સાથે કરી શકે?
એક્સ જેમ, વાય અલ્પવિરામ વખત કુલ છે કે?
[જોસેફ] હા, તમે ચોક્કસપણે કે શું કરી શકે છે, પરંતુ કારણ હું એ જ લાઇન પર એક્સ અને વાય મૂકે છે -
અને એક પ્રશ્ન છે કે શા માટે આપણે માત્ર એક જ વાક્ય પર આ શું કરી શકું?
અમે ફક્ત આ જ વાક્ય પર શા માટે નથી આ બધી મૂકી છે
એક્સ અને વાય દરેક અન્ય સાથે સંબંધિત છે,
અને આ માત્ર stylistically વધુ યોગ્ય એક અર્થમાં છે,
કારણ કે તે જ લાઇન પર બે વસ્તુઓ જૂથબદ્ધ છે
જેમ સૉર્ટ જ વસ્તુ સાથે રહેલો છે.
અને મેં હમણાં જ આ સિવાય વિભાજિત. તે માત્ર એક શૈલી વાત છે.
તે વિધેયાત્મક રીતે કોઈ પ્રકારની તફાવત બનાવે છે.
સ્ટ્ર્ક્ટ્સ પર કોઈપણ અન્ય પ્રશ્નો છે?
તમે સ્ટ્રક્ટ સાથે Pokédex વ્યાખ્યાયિત કરી શકો છો.
એક Pokémon ધરાવે છે અને તેને એક પત્ર, એક માલિક, એક પ્રકાર છે.
અને પછી જો તમે Pokémon ઝાકઝમાળ હોય, તો તમારે એક Pokédex બનાવવા માટે, યોગ્ય શકે?
ઠીક છે કૂલ. તેથી, સ્ટ્ર્ક્ટ્સ પર પ્રશ્નો. તે સ્ટ્ર્ક્ટ્સ સંબંધિત છે.
>> છેલ્લે, GDB. GDB શું તમને છે? તે તમને તમારા કાર્યક્રમ ડિબગ.
અને જો તમે GDB ઉપયોગ કર્યો નથી, હું ટૂંકા જોવાનું ભલામણ કરશે
અને માત્ર GDB શું છે ઉપર જઈને, તો તમે તેને કેવી રીતે સાથે કામ કરે છે, તમે કેવી રીતે તેનો ઉપયોગ થઇ શકે છે,
અને તે એક કાર્યક્રમ પર પરીક્ષણ.
અને તેથી GDB શું તમને નથી તે [દુર્બોધ] તમારા કાર્યક્રમ વિરામ દે
અને વ્યવહારુ રેખા.
ઉદાહરણ તરીકે, હું મારા કાર્યક્રમ 3 લીટી જેવા અટકશે અમલ કરવા માંગો છો,
અને જ્યારે હું 3 વાક્ય પર છું હું તમામ કિંમતો કે ત્યાં છાપી શકે છે.
અને તેથી આપણે શું કહી જેવી લીટી માં pausing
છે અમે આ તે લીટી પર બ્રેકપોઇન્ટ મૂકવા કહી
અને પછી અમે તે સમયે કાર્યક્રમ રાજ્યના ખાતે ચલો છાપી શકો છો.
>> અમે પછી ત્યાં કાર્યક્રમ વાક્ય દ્વારા વાક્ય મારફતે પગલું કરી શકો છો.
અને પછી અમે સ્ટેક રાજ્ય સમયે દેખાય છે.
અને તેથી ક્રમમાં GDB, અમે શું છે અમે સી ફાઇલ પર રણકાર કૉલ કરવા,
પણ અમે તેને-ggdb ધ્વજ પસાર હોય છે.
અને એકવાર અમે પૂર્ણ કરી લો કે અમે ફક્ત પરિણામી આઉટપુટ ફાઇલ પર gdb ચલાવો.
અને તેથી તમે આ જેવા કેટલાક લખાણને જેવા સામૂહિક વિચાર,
પરંતુ ખરેખર તમામ તમારે કરવા આદેશો માં શરૂઆતમાં લખો છે.
ભંગ મુખ્ય મુખ્ય ખાતે બ્રેકપોઇન્ટ મૂકે છે.
400 યાદી લાઇન 400 આસપાસ કોડ લીટીઓ યાદી આપે છે.
અને તેથી આ કિસ્સામાં તમે હમણાં આસપાસ નજર કરી શકો છો અને કહે છે, ઓહ,
હું 397 વાક્ય પર એક બ્રેકપોઇન્ટ, કે જે આ વાક્ય છે સેટ કરવા માંગો છો,
અને પછી તમારા કાર્યક્રમ છે કે જે પગલું માં ચાલે છે અને તે તોડી રહ્યું છે.
તે ત્યાં વિરામ માટે ચાલી રહ્યું છે, અને તમે છાપે છે, ઉદાહરણ તરીકે કરી શકો છો, અથવા ઓછા ઊંચા મૂલ્ય.
અને તેથી આદેશો તમે જાણવા જરૂર સમૂહ છે,
અને આ સ્લાઇડશો અપ વેબસાઈટ પર જશે,
તેથી જો તમે માત્ર આ સંદર્ભ કરવા માંગો છો અથવા માંગતા તેમને તમારા ખાણિયાઓને છેતરે શીટ્સ પર મૂકવા મફત લાગે.
>> સરસ. કે ક્વિઝ 0 સમીક્ષા હતી, અને અમે આસપાસ વળગી જો તમને કોઈ પ્રશ્નો હશે.
અધિકાર છે.
>> [વધાવી]
>> [CS50.TV]