[Powered by Google Translate] [6 વિભાગ] [વધુ સાનુકૂળ]
[રોબ બોડેન] [હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે.] [CS50.TV]
>> અમે પ્રશ્નો અમારા વિભાગમાં વડા કરી શકે છે.
હું પહેલા જગ્યા માટે URL મોકલ્યો.
પ્રશ્નો ના વિભાગની શરૂઆતમાં કહે-
દેખીતી રીતે હું સંપૂર્ણપણે અત્યંત સરળ પ્રશ્ન unsick-નથી છું
માત્ર શું valgrind છે?
Valgrind શું થાય છે?
કોઈને કહેવું valgrind શું કરે છે કરવા માંગો છો?
[વિદ્યાર્થી] ચકાસે મેમરી લીક્સ.
અરે વાહ, valgrind સામાન્ય મેમરી ચેકર છે.
તે, અંતે, તમને કહે છે જો તમે કોઈપણ મેમરી લીક્સ હોય છે,
જે મોટે ભાગે આપણે શું કારણ માટે ઉપયોગ કરી રહ્યા છો તો તમે કરવા માંગો છો
સમસ્યા સમૂહ અથવા તમે કરવા માંગો છો જો સારો દેખાવ
મોટા બોર્ડ પર મેળવવા માટે, તમારે કોઈ મેમરી લીક્સ બિલકુલ જરૂર પડે છે,
અને કદાચ તમને મેમરી છિદ્ર કે જે તમે શોધી શકો છો,
પણ ધ્યાન રાખો કે તમે જ્યારે ફાઈલ ખોલવા
અને જો તમે તેને બંધ કરો નહિં, કે જે મેમરી છિદ્ર છે.
>> ઘણા લોકો અમુક નોડ માટે જોઈ રહ્યા હોય કે જે તેઓ મુક્ત કરી રહ્યાં છો
ખરેખર, જ્યારે તેઓ ખૂબ પ્રથમ પગલું માં શબ્દકોશ બંધ ન હતી.
તે તમને કહે છે જો તમે કોઈપણ અમાન્ય છે વાંચે અથવા લખે છે,
જેનો અર્થ છે કે જો તમે પ્રયાસ કરો અને કિંમત સેટ
કે ઢગલો ઓવરને બહાર છે અને તે seg દોષ ન થાય
પરંતુ valgrind તે કેચ, કારણ કે તમે ખરેખર નથી ત્યાં લેખિત જોઈએ,
અને જેથી તમે ચોક્કસપણે તે ક્યાં તો કોઇ નથી કરીશું.
તમે કેવી રીતે ઉપયોગ કરી શકું valgrind?
>> તે એક સામાન્ય પ્રશ્ન છે
પ્રકારની તેને ચલાવવા અને આઉટપુટ જુઓ.
આઉટપુટ વખત ઘણો જબરજસ્ત છે.
ત્યાં પણ મજા ભૂલો જ્યાં જો તમને કેટલાક ભયંકર ખોટું વસ્તુ છે
લુપ માં બની રહ્યું છે, પછી તે આખરે કહે, "કરશે વે ઘણા ભૂલો.
હું હવે ગણતરી રોકવા જાઉં છું. "
તે વાસ્તવમાં શાબ્દિક આઉટપુટ કે જે તમે પાર્સ હોય છે.
અંતે, તે તમને કોઈપણ મેમરી લીક્સ કે તમારી પાસે કહેશે,
કેટલા બ્લોક્સ, કે જે ઉપયોગી થઈ શકે છે કારણ કે
જો તે એક બ્લોક unfreed છે, પછી તે સામાન્ય રીતે સરળતાથી શોધી
1,000 કરતાં બ્લોક્સ unfreed.
1,000 unfreed બ્લોકો કદાચ અર્થ છે કે તમે નથી ખાલી કરી રહ્યાં છો
તમારી સાથે લિંક યોગ્ય અથવા કંઈક યાદીઓ છે.
કે valgrind છે.
>> હવે અમે પ્રશ્નો અમારી કલમ છે,
જે તમે ડાઉનલોડ કરવા માટે જરૂર નથી.
તમે મારા નામ પર ક્લિક કરો અને તેમને જગ્યા માં લઈ શકો છો.
હવે મને પર ક્લિક કરો.
1 પુનરાવર્તન સ્ટેક છે, કે જે અમે પ્રથમ કરી રહ્યા હશે.
2 પુનરાવર્તન કતાર પ્રયત્ન કરશે, અને 3 પુનરાવર્તન આ singly યાદીની લિંક થશે.
અમારા સ્ટેક સાથે બંધ શરૂ કરી રહ્યા છીએ.
કારણ કે તે અહીં કહે છે, સ્ટેક સૌથી આધારભૂત છે,
કમ્પ્યુટર વિજ્ઞાનના મૂળભૂત માહિતી માળખાં.
ખૂબ અજમાયશી ઉદાહરણ છે
ડાઇનિંગ હોલ માં ટ્રે ને સ્ટેક.
તે વાસ્તવમાં છે જ્યારે તમે એક સ્ટેક રહી રજૂ કરવામાં આવ્યા છે,
કોઈને કહેવું, રહ્યું છે "ઓહ ટ્રે એક સ્ટેક જેમ."
તમે ટ્રે ગંજી છે.
પછી તમે ટ્રે ખેંચી જવા જ્યારે,
પ્રથમ ટ્રે કે જેને ખેંચવામાં રહ્યું છે કે છેલ્લા એક કે સ્ટેક પર મૂકવામાં આવ્યું હતું.
તે પણ જેવા સ્ટેક અહીં કહે છે
અમે મેમરીનો સેગમેન્ટમાં સ્ટેક કહેવાય છે.
અને તે સ્ટેક શા માટે કહેવાય છે?
>> કારણ કે સ્ટેક માહિતી બંધારણ જેમ,
તે કોઈ રન નોંધાયો નહીં અને પૉપ સ્ટેક પર સ્ટેક ફ્રેમ્સ,
જ્યાં સ્ટેક ફ્રેમ્સ કાર્ય ચોક્કસ કોલ જેવા છે.
અને સ્ટેક જેમ, તમે હંમેશા પાછા પડશે
એક કાર્ય કૉલ પહેલાં તમે નીચા સ્ટેક ફ્રેમ્સ માં ફરીથી મેળવી શકો છો.
તમે મુખ્ય કૉલ foo કોલ બાર અને બાર મુખ્ય સીધું વળતર ન હોઈ શકે છે.
તે હંમેશા માટે યોગ્ય દબાણ અને ધાણી સ્ટેક અનુસરો મળ્યું છે.
બે ઓપરેશન જેમ હું જણાવ્યું હતું કે, દબાણ અને પોપ છે.
તે સાર્વત્રિક શરતો હોય છે.
તમે અને કોઈ બાબત શું રન ટાઇમ સ્ટેકનું દ્રષ્ટિએ પુશ પૉપ ખબર હોવી જોઇએ.
અમે જોશો ક્યુને અલગ પ્રકારની હોય છે.
તે ખરેખર એક સાર્વત્રિક શબ્દ નથી, પરંતુ દબાણ અને પોપ રન ટાઇમ સ્ટેકનું માટે સાર્વત્રિક હોય છે.
Push ને માત્ર સ્ટેક પર મૂકવામાં આવે છે.
પૉપ છે બંધ સ્ટેક લો.
અને અમે અહીં જોવા અમારા typedef સ્ટ્રક્ટ સ્ટેક હોય છે,
તેથી અમે ઘરનાં પરચૂરણ કામો ** શબ્દમાળાઓ ધરાવે છે.
શું વિચાર કોઈપણ ** દ્વારા ભયભીત.
આ અંત શબ્દમાળાઓ ઝાકઝમાળ છે રહ્યું છે
અથવા પોઇંટરો એક અક્ષરો એરે, જ્યાં
અક્ષરો પોઇંટરો માટે શબ્દમાળાઓ હોય છે.
તે શબ્દમાળાઓ પ્રયત્ન નથી, પરંતુ અહીં, તેઓ શબ્દમાળાઓ પ્રયત્ન રહ્યા છીએ.
>> અમે શબ્દમાળાઓ ઝાકઝમાળ છે.
અમે એક માપ છે, જે દર્શાવે છે કે કેટલી તત્વો સ્ટેક પર હાલમાં છે,
અને પછી અમે ક્ષમતા, કે જે કેટલા તત્વો સ્ટેક પર હોઇ શકે છે.
આ ક્ષમતા બોલ 1 કરતા વધુ કંઈક તરીકે શરૂ થવું જોઈએ,
પરંતુ માપ 0 તરીકે બોલ શરૂ થઈ રહ્યું છે.
હવે, ત્યાં મૂળભૂત રીતે ત્રણ અલગ અલગ રીતે તમે એક સ્ટેક વિચાર કરી શકો છો.
સારું, કદાચ વધુ, પરંતુ બે મુખ્ય માર્ગો છે
તમે તેને અમલમાં ઝાકઝમાળ મદદથી કરી શકો છો, અથવા તમે તેને અમલમાં એક કડી થયેલ યાદી વાપરી રહ્યા હોય.
લિંક કરેલા યાદીઓ પ્રકારની છે માંથી રન ટાઇમ સ્ટેકનું બનાવવા તુચ્છ.
તે ખૂબ જ સરળ છે સંલગ્ન યાદીમાં સ્ટેક કરો,
અહીં, અમે સ્ટેક કરો એરે મદદથી જઈ રહ્યાં છો,
અને પછી એરે વાપરી રહ્યા હોય, ત્યાં પણ બે રીતે તમે એના વિશે વિચારો શકે છે.
પહેલાં, જ્યારે હું જણાવ્યું હતું કે, અમે સ્ટેક માટે ક્ષમતા હોય છે,
તેથી અમે સ્ટેક પર એક તત્વ ફિટ થઈ શકે છે.
>> એક રીતે બની શકે છે તેમ તેમ તમે 10 તત્વો દબાવો, તો પછી તમે પૂર્ણ કરી લો ટૂંક છે.
તમને ખબર છે કે ત્યાં એક વિશ્વમાં 10 વસ્તુઓ બંધાયેલ ઉપલા છે
કે તમે 10 કરતાં વધુ વસ્તુઓ તમારી સ્ટેક પર ક્યારેય પડશે,
જે કિસ્સામાં તમે તમારા સ્ટેક માપ પર બંધાયેલ ઉપર કરી શકે છે.
અથવા તમે કરી શકે છે તમારા સ્ટેક અનબાઉન્ડેડ શકાય છે,
પરંતુ જો તમે એક એરે કરી રહ્યા છીએ, કે અર્થ એ થાય કે દરેક એક સમયે તમે 10 તત્વો દબાવો,
પછી તમે 20 તત્વો વધવા છે જઈ રહ્યાં છો, અને જ્યારે તમે 20 તત્વો દબાવો,
તમે 30 તત્વો અથવા 40 તત્વો તમારા એરે વધવા હોય રહ્યા છીએ.
તમે ક્ષમતા, કે જે અમે શું કરીએ અહીં જઈ રહ્યાં છો વધારો કરવાની જરૂર જઈ રહ્યાં છો.
દરેક એક સમય આપણે સ્ટેક મહત્તમ કદ સુધી પહોંચે છે,
જ્યારે આપણે કંઈક બીજું દબાણ, અમે કરવા માટે ક્ષમતા વધારવા જરૂર જઈ રહ્યાં છો.
અહીં, અમે દબાણ bool પુશ (કોલસો * str) તરીકે જાહેર કર્યું હતું.
ચાર * str શબ્દમાળા કે અમે સ્ટેક પર દબાણ કરવામાં આવે છે,
અને bool માત્ર કહે છે કે શું આપણે સફળ અથવા નિષ્ફળ ગયું.
>> અમે કેવી રીતે નિષ્ફળ કરી શકે છે?
માત્ર એક જ સંજોગોમાં કે તમે વિચાર કરી શકો છો શું છે
જ્યાં અમે ખોટા પરત કરવાની જરૂર છે?
યાહ.
[વિદ્યાર્થી] જો તે સંપૂર્ણ છે અને અમે બંધાયેલી અમલીકરણ ઉપયોગ કરી રહ્યાં છો.
અરે વાહ, તેથી અમે કેવી રીતે વ્યાખ્યાયિત-તેમણે જવાબ આપ્યો નથી
જો તે સંપૂર્ણ છે અને અમે બાઉન્ડેડ અમલીકરણ ઉપયોગ કરી રહ્યાં છો.
ત્યાર બાદ અમે ચોક્કસપણે ખોટી આપશે.
જલદી અમે એરે માં 10 વસ્તુઓ દબાવો, અમે 11 બેસી શકતા નથી, તેથી અમે ખોટા આવો.
જો તે અનબાઉન્ડેડ છે? યાહ.
જો તમે કોઈ કારણસર એરે નથી વધારી શકે છે.
અરે વાહ, જેથી મેમરી મર્યાદિત સ્ત્રોત છે,
અને છેવટે, જો અમે સ્ટેક પર ઉપર અને ઉપર ફરી દબાણ વસ્તુઓ રાખવા માટે,
અમે પ્રયાસ અને એક મોટી એરે ફાળવવા માટે ફિટ જઈ રહ્યાં છો
મોટા ક્ષમતા, અને malloc અથવા જે અમે ઉપયોગ કરી રહ્યાં છો ખોટા પાછા જઈ રહ્યું છે.
વેલ, malloc નલ આપશે.
>> યાદ રાખો, દરેક એક સમય તમે ક્યારેય malloc કૉલ, તમે એ જોવા માટે ચકાસણી થવી જોઈએ જો તે
નલ આપે છે અથવા અન્ય કે જે ચોકસાઈ કપાત છે.
કારણ કે આપણે એક અમાપ સ્ટેક માંગો છો,
માત્ર એક જ કેસ અમે ખોટા પાછો જઈ રહ્યાં છો છે જો અમે પ્રયાસ
ક્ષમતા અને malloc વધારો અથવા જે ખોટા આપે છે.
પછી પોપ કોઈ દલીલો લે છે,
અને તે શબ્દમાળા કે સ્ટેક ટોચ પર છે આપે છે.
ગમે તાજેતરમાં સ્ટેક પર દબાણ આવ્યું હતું પોપ શું પરત આવે છે,
અને તે પણ તે સ્ટેક દૂર કરે છે.
નોટિસ અને તે નલ આપે છે જો ત્યાં સ્ટેક પર કંઈ નથી.
તે હંમેશા શક્ય છે કે સ્ટેક ખાલી છે.
જાવા, જો કે તમે, અથવા અન્ય ભાષાઓ માટે ઉપયોગ કરી રહ્યાં છો,
એક ખાલી સ્ટેક માંથી પૉપ પ્રયાસ કરી અપવાદ અથવા કંઈક થઇ શકે છે.
>> પરંતુ સી, નલ કિસ્સાઓ કેવી રીતે અમે આ સમસ્યા હેન્ડલ ઘણાં પ્રકારની છે.
નલ પરત કેવી રીતે અમે મહત્વપૂર્ણ રીતે સ્ટેક ખાલી હતી રહ્યા છીએ.
અમે કોડ કે જે તમારા સ્ટેક કાર્યક્ષમતા ચકાસવા કરશે પ્રદાન કરેલો,
દબાણ અને પૉપ અમલ.
આ કોડ ઘણો હશે નહિં.
હું ખરેખર કરશે, પહેલા અમે તે કરવા માટે, હિંટ, સંકેતની-
જો તમે તેને જોઇ ન હોય, malloc માત્ર એક જ કાર્ય નથી
કે તમારા માટે ઢગલો પર મેમરી ફાળવે છે.
ત્યાં alloc વિધેયો એક કુટુંબ છે.
પ્રથમ malloc છે, જે તમે ઉપયોગ કરી રહ્યાં છો છે.
તો પછી ત્યાં calloc છે, કે જે malloc તરીકે જ વાત કરે છે,
પરંતુ તે બધું તમારા માટે બહાર શૂન્ય કરશે.
જો તમે ક્યારેય કંઈક mallocing પછી કર્યું બધું સેટ કરવા માગે છે null
તમે હમણાં જ લખવા ના બદલે પ્રથમ સ્થાને હોવા જોઈએ calloc ઉપયોગ
બહાર મેમરી સમગ્ર બ્લોક શૂન્ય લૂપ માટે.
>> Realloc malloc જેવું છે અને ખાસ કિસ્સાઓમાં ઘણો છે,
પરંતુ મૂળભૂત રીતે realloc શું કરે છે
તે નિર્દેશક જે પહેલેથી ફાળવણી કરવામાં આવી હતી લઈ જાય છે.
Realloc કાર્ય તમે ધ્યાન અહીં ભરવા શકાય માંગો છો.
તે એક નિર્દેશક જે પહેલેથી malloc કરી હતી પરત કરવામાં લે છે.
હવે કહો કે તમે malloc થી 10 બાઇટ્સ એક નિર્દેશક વિનંતી છે.
ત્યાર બાદ તમે સમજો છો કે તમને 20 બાઇટ્સ માગતા હતા,
જેથી તમે 20 બાઇટ્સ સાથે નિર્દેશક પર realloc કહી,
અને realloc તમારા માટે આપોઆપ બધું પર નકલ થશે.
જો તમે હમણાં malloc ફરીથી કહેવાય છે, જેમ હું 10 બાઇટ્સ એક બ્લોક છે.
હવે હું 20 બાઇટ્સ એક બ્લોક જરૂર છે,
જેથી હું 20 બાઇટ્સ malloc જો, પછી હું જાતે પર પ્રથમ વસ્તુ ના 10 બાઇટ્સ નકલ હોય છે
બીજી વસ્તુ માં અને તે પછી પ્રથમ વસ્તુ મફત.
Realloc તમારા માટે કે હેન્ડલ કરશે.
>> નોટિસ સહી કરવા માટે રદબાતલ * પ્રયત્ન રહ્યું છે,
જે ફક્ત મેમરી બ્લોક માટે છે નિર્દેશક પરત,
પછી રદબાતલ * ptr.
તમે રદબાતલ * એક સામાન્ય નિર્દેશક તરીકે વિચાર કરી શકો છો.
સામાન્ય રીતે, ખાલીપણુ * સાથે તમે ક્યારેય ડીલ
પરંતુ malloc એક રદબાતલ * પરત આવે છે, અને પછી તેને જેમ ઉપયોગ
આ ખરેખર એક કોલસો બનાવો * પ્રયત્ન રહ્યું છે.
અગાઉના રદબાતલ * કે malloc દ્વારા કરવામાં ફર્યા હતા
હવે realloc પસાર કરી જવાનું, અને પછી કદ
બાઇટ્સ તમે ફાળવણી કરવા માંગો છો નવા નંબર છે, તેથી તમારા નવા ક્ષમતા છે.
હું તમને એક દંપતી મિનિટ આપો પડશે અને તે અમારી જગ્યા કામ કરે છે.
1 પૂનરાવર્તન સાથે શરૂ કરો.
હું તમને માટે પૂરતી દબાણ અમલ સમય વિશે પછી આસ્થાપૂર્વક બંધ થશે,
અને પછી હું તમને બીજા પોપ કરવું વિરામ આપવા પડશે.
પરંતુ તે ખરેખર છે કે ખૂબ કોડ તમામ નથી.
સૌથી કોડ કદાચ વિસ્તરતા સામગ્રી છે, ક્ષમતા વિસ્તરણ કર્યું હતું.
ઠીક છે, કોઈ સંપૂર્ણપણે થઈ દબાણ,
પરંતુ જ્યાં સુધી તમને લાગે છે કે તમે સાચો માર્ગ પર કરશો, તે સારી છે.
>> શું કોઇને કોઇ કોડ તેઓ મને અપ ખેંચીને સાથે આરામદાયક લાગે છે?
અરે વાહ, હું, પરંતુ તે કોઈપણ કોઈપણ કોડ મેં ખેંચી શકે છે થશે?
ઠીક છે, તમે શરૂ કરવા માટે, તેને સાચવી શકો છો, ગમે છે?
હું હંમેશા તે પગલું ભૂલી જાવ.
ઠીક છે, પુશ અંતે looking,
તમે તમારા કોડ સમજાવવા માંગો છો?
[વિદ્યાર્થી] ફર્સ્ટ બધી, હું કદ વધારો થયો છે.
હું માનું મારે જે રીતે હોવું જોઈએ, હું કદ વધારો થયો હતો,
અને હું એ જોવા કે તે ક્ષમતા કરતાં ઓછી છે.
અને જો તે ક્ષમતા કરતાં ઓછી છે, હું એરે કે અમે પહેલાથી જ હોય ​​ઉમેરો.
અને જો તેમાં તે નથી, હું 2 દ્વારા ક્ષમતા મલ્ટીપ્લાય,
અને હું કંઇક કરવા માટે શબ્દમાળાઓ એરે હવે reallocate મોટી ક્ષમતા માપ સાથે.
અને પછી જો કે નિષ્ફળ જાય, તો હું વપરાશકર્તા કહેવું અને ખોટા પાછા ફરવા માટે,
અને જો તે દંડ છે, પછી હું નવી જગ્યા શબ્દમાળા મૂકે છે.
>> [રોબ બી] આ પણ નોંધ્યું છે કે અમે એક સરસ bitwise ઓપરેટર અંહિ વપરાય
માટે 2 દ્વારા વધવું.
યાદ રાખો, ડાબી પાળી હંમેશા 2 દ્વારા ગુણાકાર કરી રહ્યું છે.
અધિકાર પાળી 2 દ્વારા લાંબા તરીકે વહેંચવામાં આવે છે કારણ કે તમે યાદ રાખો કે એનો અર્થ
એક 2 દ્વારા વિભાજી પૂર્ણાંક તરીકે 2 દ્વારા વહેંચાય છે.
તે અહીં અથવા ત્યાં 1 ટૂંકાવીને શકે છે.
પરંતુ 1 દ્વારા છોડી પાળી હંમેશા 2 દ્વારા ગુણાકાર કરી રહ્યું છે,
તમે પૂર્ણાંક સીમાડાં ઓવરફ્લો સિવાય, અને પછી તેને રહેશે નહીં.
એક બાજુ ટિપ્પણી.
હું શું-માટે આ કોઈપણ રીતે બિલકુલ કોડિંગ બદલી ન રહ્યું છે ગમે,
પરંતુ હું આ કંઈક કરવું ગમશે.
તે વાસ્તવમાં તેને સહેજ લાંબા સમય સુધી કરી રહ્યા છે.
કદાચ આ સંપૂર્ણ આ બતાવવા કેસ નથી,
પરંતુ હું સેગમેન્ટમાં કરવા માંગો તેનો આ બ્લોકમાં
ઠીક, જો આ જો આવું થાય, તો પછી હું કંઈક કરવા જાઉં છું,
અને પછી કાર્ય કરવામાં આવે છે.
હું પછી મારી આંખોમાં કામગીરી નીચે બધી રીતે સ્ક્રોલ જરૂર નથી
શું બીજું બાદ આવું થાય છે.
તે જો આ જો આવું થાય, તો પછી હું ફક્ત આવો.
તે પણ આ બધું બહાર ના સરસ વધારાના લાભ ધરાવે છે
હવે એક વાર છોડી ખસેડાયેલો.
હું લાંબા સમય સુધી-જો તમે ક્યારેય હાસ્યજનક રીતે લાંબા લીટીઓ નજીક જરૂર છે,
પછી તે 4 બાઇટ્સ મદદ, અને વધુ ડાબેરી કંઈક છે,
ઓછા ભરાઈ ગયાં તમને લાગે જો ગમે-ઠીક, હું યાદ છે
હું લૂપ માટે એક બીજું અંદર અંદર એક જ્યારે લૂપ હાલમાં છું.
તમે ગમે ત્યાં આ વળતર તુરંત જ કરી શકે છે, હું પ્રકારની જેમ.
તે તદ્દન વૈકલ્પિક છે અને કોઈપણ રીતે થવાની ધારણા છે.
>> [વિદ્યાર્થી] ત્યાં કદ હોવું જોઇએ - આ નિષ્ફળ શરત છે?
આ નિષ્ફળ અહીં શરત અમે realloc નિષ્ફળ છે, તેથી હા.
આ નિષ્ફળ સ્થિતિ કેવી રીતે કદાચ નોટિસ,
પછી અમે મફત સામગ્રી સિવાય, અમે હંમેશા નિષ્ફળ જઈ રહ્યાં છો
કોઈ બાબત કેટલી વખત અમે કંઈક દબાણ કરવાનો પ્રયાસ કરો.
જો અમે દબાણ રાખવા, અમે incrementing માપ રાખવું,
તેમ છતાં અમે કોઇ સ્ટેક પર ન મૂકવા આવે છે.
સામાન્ય રીતે આપણે ત્યાં સુધી કદ નથી વધારતી નથી
પછી અમે સફળતાપૂર્વક સ્ટેક પર છે તે મૂકે છે.
અમે તે કરવા માટે, કહેવું હો, ક્યાં અહીં અને અહીં.
અને પછી તેની જગ્યાએ કહેતા ≤ ક્ષમતા s.size છે, આ ક્ષમતા કરતાં ઓછી છે,
માત્ર કારણ કે અમે આવ્યા, જ્યાં બધું હતું.
>> અને યાદ રાખો, માત્ર જગ્યા કે અમે કદાચ ખોટા પરત કરી શકે છે
અહીં છે, જ્યાં realloc નલ પાછો ફર્યો,
અને જો તમે પ્રમાણભૂત ભૂલ યાદ થાય છે,
કદાચ તમને આ કેસ વિચારણા જ્યાં તમે પ્રમાણભૂત ભૂલ છાપી શકો છો,
માત્ર ધોરણ બહાર સીધી છાપવા બદલે જેથી fprintf stderr.
ફરીથી, કે અપેક્ષા નથી, પરંતુ જો તે એક ભૂલ છે,
printf લખો, પછી તમે તેને પ્રમાણભૂત બહાર બદલે પ્રમાણભૂત ભૂલ છાપવાનો શકો છો.
>> કોઈપણ જે કંઈપણ નોંધ છે? હા.
[વિદ્યાર્થી] એ તમને [અશ્રાવ્ય] પર જાઓ શકું?
[રોબ બી] હા, તેનો વાસ્તવિક binariness અથવા માત્ર તે શું?
[વિદ્યાર્થી] તેથી તમે તેને 2 દ્વારા મલ્ટીપ્લાય?
[રોબ બી] અરે વાહ, મૂળભૂત રીતે.
દ્વિસંગી જમીન, અમે હંમેશા અંકો અમારી સમૂહ છે.
1 દ્વારા આ ડાબી સ્થળાંતર મૂળભૂત તેને જમણી બાજુ પર અહીં દાખલ.
પાછા આ, માત્ર દ્વિસંગી કે બધું યાદ
2 ની શક્તિ છે, તેથી આ 0 થી 2 રજૂ કરે છે,
1 આ 2, આ 2 માટે 2.
જમણી બાજુએ એક 0 હવે દાખલ કરીને, અમે હમણાં જ બધું પાળી પર.
શું 0 ને 2 હવે 1 હોય છે માટે 2, 2 2 માટે છે.
જમણી બાજુ કે અમે શામેલ
છે જરૂરી માટે 0 હશે,
જે અર્થમાં બનાવે છે.
જો તમે ક્યારેય 2 દ્વારા એક સંખ્યાના ગુણાંકમાં હોય, તો તે અપ વિચિત્ર અંત નથી ચાલી રહ્યું છે,
તેથી 0 સ્થળ માટે 2 0 હોવો જોઈએ,
અને આ છે જે હું અડધી પહેલા અંગે ચેતવણી આપી હતી કે જો તમે પાળી થાય નથી
પૂર્ણાંક માં બિટ્સ સંખ્યા ઉપરાંત,
તો પછી આ 1 થી અંત બોલ જઈને રહ્યું છે.
કે માત્ર એ જ ચિંતા છે જો તમે ખરેખર મોટી ક્ષમતા સાથે વ્યવહાર કરવામાં થાય છે.
પરંતુ તે સમયે, પછી તમે વસ્તુઓ અબજો ઝાકઝમાળ સાથે કામ કરીએ છીએ,
જે મેમરીમાં રીતે ફિટ ન શકે.
>> હવે અમે પોપ, કે જે વધુ સરળ છે મેળવી શકો છો.
તમે તેને નથી જો તમે આખું ટોળું પૉપ થાય માંગો શકે છે,
અને હવે તમે અડધા ક્ષમતા પર ફરીથી છો.
તમે મેમરીનો જથ્થો તમારી પાસે સંકોચો realloc શકે છે,
પરંતુ તમે તે અંગે ચિંતા કરવાની જરૂર નથી, તેથી માત્ર realloc કેસ પ્રયત્ન રહ્યું છે
મેમરી વધતી ઘટાડાથી મેમરી ક્યારેય,
જે પોપ સુપર સરળ બનાવવા જઈ રહ્યું છે.
હવે ક્યુને, કે જે રન ટાઇમ સ્ટેકનું જેવો હોવો જવું છે,
પરંતુ ક્રમમાં છે કે જે તમને વસ્તુઓ બહાર લઇ જવા માટે વિપરીત છે.
એક કતાર ઓફ અજમાયશી ઉદાહરણ એક વાક્ય છે,
તેથી હું માનું જો તમે ઇંગલિશ હતા, મેં કહ્યું હોત
એક કતાર એક અજમાયશી ઉદાહરણ એક કતાર છે.
તેથી લીટી જેમ, જો તમે લીટી માં પ્રથમ વ્યક્તિ છો,
તમે વાક્ય બહાર પ્રથમ વ્યક્તિ પ્રયત્ન અપેક્ષા.
જો તમે વાક્ય છેલ્લા વ્યક્તિ છો, તો તમે છેલ્લા સેવા વ્યક્તિ હશે આવે છે.
અમે તે FIFO પેટર્ન કૉલ, જ્યારે સ્ટેક LIFO પેટર્ન હતી.
તે શબ્દો ખૂબ સાર્વત્રિક હોય છે.
>> રન ટાઇમ સ્ટેકનું જેમ અને એરે વિપરીત, ક્યુને ખાસ મધ્યમાં તત્વો ઍક્સેસ મંજૂરી આપતા નથી.
અહીં, સ્ટેક, અમે દબાણ અને પોપ હોય છે.
અહીં, અમે તેમને કહેવાય એન્ક્યૂ અને dequeue છે થાય છે.
હું પણ સાંભળ્યું ન હોય તેમને પાળી અને unshift કહેવાય છે.
હું સાંભળી કર્યું છે લોકો કહે છે દબાણ અને પોપ પણ ક્યુને લાગુ પડે છે.
હું સાંભળ્યું દાખલ કરો, દૂર કરવા,
તેથી દબાણ અને પૉપ, જો તમે રન ટાઇમ સ્ટેકનું વિશે વાત કરે છે, તો તમે દબાણ છે અને ધાણી.
જો તમે ક્યુને વિશે વાત કરી રહ્યાં છો, તમે જે શબ્દોના તમે ઉપયોગ કરવા માંગો છો લઇ શકે
નિવેશ અને દૂર કરવા માટે, અને ત્યાં તે કહેવાય કરીશું પર કોઈ સર્વસંમતિ છે.
પરંતુ અહીં, અમે એન્ક્યૂ અને dequeue છે.
હવે, સ્ટ્રક્ટ લગભગ સ્ટેક સ્ટ્રક્ટ સમાન દેખાય છે.
પરંતુ અમે વડા સાચવી રાખે છે.
હું માનું તે અહીં કહે છે, પરંતુ અમે માથામાં શા માટે જરૂરી છે?
આ પ્રોટોટાઇપ મૂળભૂત પર દબાણ અને પૉપ સમાન છે.
તમે તેના દબાણ અને પોપ તરીકે વિચાર કરી શકો છો.
માત્ર એટલો જ તફાવત છે પોપ નિર્વાચન બદલે છેલ્લા ના હોય, તો તે છે પ્રથમ ફર્યા હતા.
2, 1, 3, 4, અથવા કંઈક.
અને અહીં શરૂઆત છે.
અમારા કતાર સંપૂર્ણપણે પૂર્ણ છે, તેથી તેમાં ચાર તત્વો છે.
અમારા કતાર ઓવરને હાલમાં 2,
અને હવે અમે કંઈક બીજું દાખલ જાઓ.
>> જ્યારે અમે સ્ટેક આવૃત્તિ માટે કે કંઈક બીજું, અમે શું કર્યું સામેલ કરવા માંગો છો
તો અમે મેમરી અમારા બ્લોક વિસ્તારી.
આ સાથે સમસ્યા શું છે?
[વિદ્યાર્થી] તમે 2 ખસેડો.
હું શું કતાર ઓવરને વિશે પહેલાં જણાવ્યું હતું કે,
આ 1 અંતે અર્થમાં કે અમે શરૂ નથી,
તો પછી અમે 1 dequeue કરવા માંગો છો, dequeue પછી 3, પછી 4 dequeue,
dequeue પછી 2, પછી આ એક dequeue.
અમે realloc હવે ઉપયોગ કરી શકતા નથી,
અથવા ખૂબ જ ઓછામાં ઓછા કરવા માટે, તમને અલગ રીતે realloc ઉપયોગ કરે છે.
પરંતુ તમે કદાચ માત્ર realloc ઉપયોગ કરવો ન જોઈએ.
તમે જાતે તમારી મેમરી નકલ હોય જતાં હોય છે.
>> ત્યાં બે મેમરી નકલ વિધેયો છે.
ત્યાં memcopy અને memmove છે.
હું હાલમાં મદદ પાનાંઓ વાંચી રહ્યો છું તે જોવા માટે એક કે જે તમે ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો.
ઠીક છે, memcopy, આ તફાવત એ છે
કે memcopy અને memmove, એક કેસ યોગ્ય રીતે સંભાળે છે
તમે જ્યાં પ્રદેશ કે પ્રદેશ ઓવરલેપ થાય છે માં નકલ કરી રહ્યા છીએ
તમે નકલ કરી રહ્યા છો.
Memcopy તે હેન્ડલ નથી. Memmove કરે છે.
તમે જેમ સમસ્યા વિચાર કરી શકો છો
ચાલો કહે હું આ વ્યક્તિ નકલ કરવા માંગો છો,
આ બોલ વ્યક્તિ માટે આ ચાર.
અંતે, એરે શું જેવો હવો જોઈએ
પછી નકલ 2, 1, 2, 1, 3, 4, અને પછી ઓવરને અંતે કેટલાક સામગ્રી છે.
પરંતુ આ ક્રમ કે જેમાં આપણે ખરેખર નકલ પર આધારિત છે,
જો આપણે એ હકીકત છે કે આ વિસ્તારમાં અમે માં નકલ કરી રહ્યા છો તેવું વિચારતા નથી કારણ કે
ઓવરલેપ એક અમે માંથી નકલ કરી રહ્યા છો,
તો પછી અમે પ્રારંભ જેવા અહીં, કદાચ સ્થળ અમે જવા માગતા માં 2 નકલ,
પછી અમારી પોઇંટરો આગળ વધો.
>> હવે અમે અહીં અને અહીં જઈ રહ્યાં છો, અને હવે અમે સાથે નકલ કરવા માંગો છો
આ વ્યક્તિ પર આ વ્યક્તિ અને અમારા પોઇંટરો આગળ વધો.
અમે અંત મેળવવાની જઈ રહ્યાં છો શું 2 છે, 1, 2, 1, 2, 1
તેના બદલે યોગ્ય 2 ના, 1, 2, 1, 3, 4 કારણ કે
1 2, મૂળ 3, 4 overrode.
Memmove કે યોગ્ય રીતે સંભાળે છે.
આ કિસ્સામાં, મૂળભૂત રીતે માત્ર હંમેશા memmove ઉપયોગ
કારણ કે તે યોગ્ય રીતે સંભાળે છે.
તે સામાન્ય રીતે કોઈ પણ ખરાબ નથી કરવા નથી.
આ વિચાર શરૂઆતથી શરૂ અને આ રીતે નકલ બદલે છે
જેમ અમે અહીં આપી હતી, તે અંતથી શરૂ થાય છે અને નકલ કરે છે,
અને તે કિસ્સામાં, તમે એક સમસ્યા ક્યારેય હોઈ શકે છે.
ત્યાં કોઈ પ્રભાવ ગુમાવી છે.
હંમેશા memmove વાપરો. ચિંતા ક્યારેય memcopy વિશે.
અને તે છે જ્યાં તમે અલગ memmove હોય રહ્યા છીએ
આવરિત-આસપાસ તમારી કતાર ના ભાગ.
કોઈ ચિંતાઓ જો નહિં સંપૂર્ણપણે થાય છે.
આ વધુ સ્ટેક, પુશ પૉપ, અને કરતાં મુશ્કેલ છે.
>> કોઈપણ કોઈપણ કોડ આપણે સાથે કામ કરી શકે છે છે?
પણ સંપૂર્ણપણે અપૂર્ણ જો?
[વિદ્યાર્થી] અરે વાહ, તેને સંપૂર્ણપણે અપૂર્ણ છે, જોકે.
સંપૂર્ણપણે અપૂર્ણ સુધી દંડ છે કારણકે આપણે-કરી શકો છો પુનરાવર્તન સાચવવા માંગો છો?
હું કે દરેક એક સમય ભૂલી જાવ.
ઠીક છે, શું રાખવાની થાય છે જ્યારે અમે વસ્તુઓ માપ બદલવા જરૂર છે.
સંપૂર્ણપણે પુન: માપ અવગણો.
આ કોડ સમજાવો.
હું સૌ પ્રથમ ચકાસણી છું જો કદ તમામ પ્રથમ નકલ કરતાં ઓછી હોય
અને પછી તે પછી, હું દાખલ હું + + વડા માપ લે છે,
અને મને ખાતરી છે કે તે એરે ક્ષમતા આસપાસ આવરણમાં બનાવવા માટે,
અને મને તે સ્થાને નવા શબ્દમાળા દાખલ કરો.
પછી હું કદ વધારો અને સાચું આવો.
>> [રોબ બી] આ ચોક્કસપણે એક તે કિસ્સાઓ છે કે જ્યાં તમે મોડ ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો છે.
કેસ કોઈપણ પ્રકારનું જ્યાં તમે આસપાસ રેપિંગ છે, જો તમે આસપાસ રેપિંગ વિચારો,
તાત્કાલિક વિચાર મોડ પ્રયત્ન કરીશું.
એક ઝડપી ઓપ્ટિમાઇઝેશન તરીકે / તમારો કોડ એક વાક્ય ટૂંકા બનાવે છે,
તમે નોંધ્યું છે કે લીટી તરત જ એક આ બાદ
માત્ર માપ છે + +, જેથી તમે મર્જ કરો કે આ લીટી માં, કદ + +.
હવે નીચે અહીં, અમે કેસ હોય છે
અમે પૂરતી મેમરી જ્યાં નથી,
તેથી અમે 2 કરીને અમારી ક્ષમતા વધી રહી છે.
હું માનું તમે જ સમસ્યા અહીં હોઇ શકે છે, પરંતુ અમે તે હવે અવગણી શકો છો,
જ્યાં જો તમે તમારી ક્ષમતા વધારવા નિષ્ફળ થયેલ છે,
તો પછી તમારે માટે 2 દ્વારા તમારી ક્ષમતા ફરીથી ઘટાડો કરવા માંગો છો જઈ રહ્યાં છો.
અન્ય ટૂંકી નોંધ છે જેમ તમે શું કરી શકો છો + + =,
તમે પણ << = કરી શકો છો.
લગભગ કંઈપણ પહેલા સમકક્ષ જઈ શકે છે, + = | =, અને = << =.
ચાર * નવી અમારા મેમરી નવા બ્લોક છે.
ઓહ, અહીં બનાવ્યા.
>> લોકો શું અમારી મેમરી નવા બ્લોક પ્રકાર વિશે શું વિચારો છો?
[વિદ્યાર્થી] તે ચાર રચે છે ** પ્રયત્ન કરીશું.
અમારા સ્ટ્રક્ટ પાછા અહીં વિચારી,
શબ્દમાળાઓ છે, આપણે શું reallocating છે.
અમે કતાર માં તત્વો માટે એક આખી નવી ગતિશીલ બનાવવા સંગ્રહ કરવામાં આવે છે.
અમે તમારી શબ્દમાળાઓ માટે સોંપણી કરી રહ્યા છીએ શું છે, આપણે શું હમણાં mallocing કરી રહ્યાં છો,
અને તેથી નવા ચાર રચે છે ** પ્રયત્ન રહ્યું છે.
તે શબ્દમાળાઓ ઝાકઝમાળ જ હશે.
પછી કેસ કે જે હેઠળ અમે ખોટા પાછા જઈ રહ્યાં છો શું છે?
[વિદ્યાર્થી] અમે ઘરનાં પરચૂરણ કામો * કરી જોઈએ?
[રોબ બી] હા, સારી કોલ.
[વિદ્યાર્થી] શું હતી?
[રોબ બી] અમે ઘરનાં પરચૂરણ કામો * કદ નથી કારણ કે અમે કોઈ ઇચ્છતા લાંબા
આ ખરેખર ખૂબ મોટી સમસ્યા છે કારણકે sizeof (કોલસો) 1 કરશે.
Sizeof ઘરનાં પરચૂરણ કામો * માટે 4 હોઇ રહ્યું છે,
તેથી જ્યારે તમે ints સાથે કામ કરીએ છીએ ઘણો,
તમે તેને દૂર વિચાર કરતા હોય છે કારણ કે અને પૂર્ણાંક * ના પૂર્ણાંક કદ માપ
સિસ્ટમ 32-bit એ જ વસ્તુ હોઈ જવું છે.
પરંતુ અહીં, (કોલસો) sizeof અને sizeof (કોલસો *) હવે આ જ વાત હશે આવે છે.
>> આ સંજોગોમાં જ્યાં અમે ખોટા પરત શું છે?
[વિદ્યાર્થી] નવી નલ છે.
અરે વાહ, જો નવું નલ છે, અમે ખોટા પાછા ફરવા માટે,
અને હું નીચે ફેંકવું જાઉં છું અહીં-
[વિદ્યાર્થી] [અશ્રાવ્ય]
[રોબ બી] અરે વાહ, આ દંડ છે.
તમે ક્યાં તો 2 વખત ક્ષમતા અથવા ક્ષમતા 1 પાળી છે અને પછી માત્ર તે સેટ નીચે અહીં અથવા જે કરી શકે.
અમે તે કરી કારણ કે અમે તેને હતી પડશે.
>> = 1 ક્ષમતા.
અને તમે જે 1 સ્થળને ગુમાવ્યા ચિંતા ક્યારેય જઈ રહ્યાં છો
કારણ કે તમે છોડી 1 દ્વારા કર્યું, જેથી તે 1 સ્થળ જરૂરી 0 છે,
તેથી યોગ્ય 1 દ્વારા સ્થળાંતર, તો તમે હજુ પણ દંડ પ્રયત્ન રહ્યા છીએ.
[વિદ્યાર્થી] શું તમે વળતર તે પહેલાં શું જરૂર છે?
[રોબ બી] હા, આ સંપૂર્ણપણે કોઈ અર્થ બનાવે છે.
>> હવે ધારે અમે અંત ઓવરને સાચી પરત જઈ રહ્યાં છો.
જે રીતે અમે આ memmoves કરવા જઈ રહ્યાં છો,
અમે કેવી રીતે અમે તેમને આમ સાથે ખૂબ કાળજી રાખો જરૂર છે.
શું કોઇને કેવી રીતે અમે તેમને આમ કરવા માટે કોઈ સૂચનો છે?
અહીં અમારા પ્રારંભ છે.
ખચીત, અમે શરૂઆતમાં ફરીથી શરૂ કરવા માંગો છો
અને ત્યાંથી માં નકલ વસ્તુઓ, 1, 3, 4, 2.
કે જે તમને કેવી રીતે કરવું?
પ્રથમ, હું memmove માટે મદદ પાનું અંતે ફરી જોવા મળે છે.
Memmove, દલીલો ક્રમ હંમેશા મહત્વનો છે.
અમે અમારા ગંતવ્ય પ્રથમ કરવા માંગો છો, સ્રોત બીજું, કદ ત્રીજા સ્થાને છે.
ત્યાં કયા વિધેયો સ્રોત અને અંતિમ મુકામ વિપરીત ઘણો છે.
ગંતવ્ય સ્ત્રોત માટે સુસંગત અંશે હોઇ શકે છે.
ચાલ, તે શું પરત આવે છે?
તે ગંતવ્ય માટે કારણ ગમે છે કે જે તમને શકો છો માટે એક નિર્દેશક, આપે છે.
હું ચિત્ર તે વાંચી શકો છો, પરંતુ અમે અમારી ગંતવ્ય માં ખસેડવા માંગો છો.
>> અમારા ગંતવ્ય શું જવાનું છે આવશે?
[વિદ્યાર્થી] ન્યુ.
[રોબ બી] હા, અને જ્યાં અમે માંથી નકલ કરવામાં આવે છે?
પ્રથમ વસ્તુ અમે નકલ કરવામાં આવે છે 1 આ, 3, 4 છે.
શું એ આ 1, 3, 4.
1 આ સરનામું શું છે?
1 કે સરનામું શું છે?
[વિદ્યાર્થી] [અશ્રાવ્ય]
[રોબ બી] હેડ + + પ્રથમ તત્વ ની સરનામું.
અમે એરે પ્રથમ તત્વ કેવી રીતે મેળવી શકું?
[વિદ્યાર્થી] કતારમાં.
[રોબ બી] હા q.strings.
યાદ રાખો, અહીં, અમારા વડા 1 છે.
તે રફૂ કરવું. મેં હમણાં જ લાગે તે જાદુઇ-
અહીં, અમારા વડા 1 છે. હું મારી રંગ પણ બદલી જાઉં છું.
અને અહીં શબ્દમાળાઓ છે.
આ, અમે તો લખી અમે ઉપર અહીં કર્યું શકો છો
સાથે + + હેડ q.strings.
ઘણા લોકો પણ તે લખી અને q.strings [વડા].
આ ખરેખર કોઈ પણ ઓછા કાર્યક્ષમ નથી.
તમે તેને લાગે કારણકે તમે તેને dereferencing છે અને પછી એ સરનામું મેળવવામાં શકે છે,
પરંતુ કમ્પાઇલર તેને આપણે શું પહેલાં અનુવાદ રહ્યું છે રીતે, q.strings વડા +.
ક્યાં માર્ગ તમે તેને લાગે કરવા માંગો છો.
>> અને કેટલા બાઇટ્સ અમે નકલ કરવા માંગો છો?
[વિદ્યાર્થી] ક્ષમતા - વડા.
ક્ષમતા - વડા.
અને પછી તમે હંમેશા એક ઉદાહરણ લખી શકે છે
બહાર આકૃતિ જો કે અધિકાર છે.
[વિદ્યાર્થી] તે પછી 2 દ્વારા વિભાજી કરવાની જરૂર છે.
અરે વાહ, જેથી હું ધારી અમે કદ ઉપયોગ કરી શકે છે.
અમે હજુ પણ માપ છે સુખાકારી
માપ ઉપયોગ કરીને, અમે 4 થી સમાન કદ ધરાવે છે.
અમારા કદ 4 છે. અમારા વડા 1 છે.
અમે આ 3 તત્વો નકલ કરવા માંગો છો.
કે જે સેનીટી કે કદ તપાસો - વડા યોગ્ય રીતે 3 હોય છે.
અને અહીં પાછા આવતા, જેમ કે અમારી પહેલાં જણાવ્યું હતું કે,
જો અમે ક્ષમતા ઉપયોગ થાય છે, તે પછી અમે 2 દ્વારા વિભાજીત હોય છો
કારણ કે અમે પહેલાથી જ અમારી ક્ષમતા ઉગાડવામાં છે, જેથી તેના બદલે, અમે કદ ઉપયોગ જઈ રહ્યાં છો.
કે જે તે ભાગ નકલો.
હવે, અમે અન્ય ભાગ, ભાગ છે, જે પ્રારંભના બાકી છે નકલ કરવાની જરૂર છે.
>> કે સ્થિતિ શું માં memmove ચાલી રહ્યું છે?
[વિદ્યાર્થી] પ્લસ કદ - વડા.
હા, તેથી અમે પહેલાથી જ કદ નકલ કરેલ છે - વડા બાઇટ્સ,
અને તેથી જ્યાં અમે બાકીના બાઇટ્સ નકલ કરવા માંગો છો, નવું છે
અને પછી કદ બાદ-ઉપરાંત બાઇટ્સ સંખ્યા અમે પહેલાંથી સાઇન નકલ કરી છે
અને પછી જ્યાં અમે માંથી નકલ કરવામાં આવે છે?
[વિદ્યાર્થી] Q.strings [0].
[રોબ બી] હા q.strings.
અમે ક્યાં તો અને q.strings. [0] શકે
આ નોંધપાત્ર રીતે ઓછું આ કરતાં સામાન્ય છે.
જો તે માત્ર 0 જ હશે, તો પછી તમારે q.strings જુઓ વલણ ધરાવે પડશે.
કે જ્યાં અમે માંથી નકલ કરી રહ્યા છો.
કેટલી બાઇટ્સ અમે નકલ કરશો બાકી છે? >> [10 વિદ્યાર્થી].
અધિકાર.
[વિદ્યાર્થી] અમે 5 વધવું હોય નહિં - 10 ગણો બાઇટ્સ અથવા કંઈક કદ?
અરે વાહ, તેથી આ જ્યાં-શું બરાબર અમે નકલ કરવામાં આવે છે?
[વિદ્યાર્થી] [અશ્રાવ્ય]
આ વસ્તુ અમે નકલ કરી રહ્યા છીએ પ્રકાર શું છે?
[વિદ્યાર્થી] [અશ્રાવ્ય]
અરે વાહ, આ ઘરનાં પરચૂરણ કામો * ઓ કે અમે નકલ કરી રહ્યાં છીએ તેથી, અમે જ્યાં તે આવતા નથી જાણતા નથી.
વેલ, જ્યાં તેઓ પોઇન્ટ કરી રહ્યાં છો, તો શબ્દમાળાઓ જેમ, અમે અંત તે કતાર પર દબાણ
અથવા કતાર પર enqueuing.
જ્યાં તે આવતા હોય છે, અમે કોઇ વિચાર છે.
અમે માત્ર કોલસો બનાવો * પોતાને ઓ ટ્રૅક રાખવા જરૂર છે.
વડા બાઇટ્સ - અમે કદ નકલ કરવા નથી માંગતા.
વડા ઘરનાં પરચૂરણ કામો * s, - અમે કદ નકલ કરવા માંગો છો
તેથી અમે sizeof (કોલસો *) દ્વારા આ મલ્ટીપ્લાય રહ્યા છીએ.
જ નીચે અહીં, હેડ * sizeof (કોલસો *).
>> [વિદ્યાર્થી] શું આશરે [અશ્રાવ્ય]
આ અહીં અધિકાર?
[વિદ્યાર્થી] ના, કે નીચે, કદ - વડા.
આ અહીં અધિકાર [રોબ બી]
પોઇન્ટર અંકગણિત.
કેવી રીતે નિર્દેશક અંકગણિત કામ જઈને છે
તે આપોઆપ પ્રકાર કે અમે સાથે કામ કરીએ છીએ માપ દ્વારા multiplies.
માત્ર અહીં માંગો, નવી + (કદ - વડા)
બરાબર અને નવા [- વડા કદ] સમકક્ષ છે
ત્યાં સુધી અમે તે યોગ્ય રીતે કામ કરવા માટે અપેક્ષા,
જો ત્યારથી અમે પૂર્ણાંક એરે સાથે વ્યવહાર કરી રહ્યાં છો, તો પછી અમે પૂર્ણાંક દ્વારા ઇન્ડેક્સ નથી
અથવા જો તે 5 કદ અને તમે 4 થી તત્વ કરવા માંગો છો, તો પછી અમે માં અનુક્રમણિકા
પૂર્ણાંક એરે. [4]
તમે don't [4] પૂર્ણાંક ઓફ * માપ.
કે તે આપોઆપ સંભાળે છે, અને આ કિસ્સામાં
શાબ્દિક સમકક્ષ છે, જેથી કૌંસ વાક્યરચના
છે માત્ર આ કન્વર્ટ કરી જલદી તમે કમ્પાઇલ જઈ રહી છે.
કે કંઈક તમે કે કાળજી રાખો જરૂર છે
જ્યારે તમે કદ ઉમેરીને છે - વડા
તમે નથી એક બાઈટ ઉમેરી રહ્યા છે.
તમે એક કોલસો બનાવો * ઉમેરી રહ્યાં છીએ, જે એક બાઇટ્સ અથવા જે પ્રયત્ન કરી શકો છો.
>> અન્ય પ્રશ્નો છે?
ઠીક છે, dequeue સરળ હોઈ રહ્યું છે.
હું તમને અમલ મિનિટ આપવા પડશે.
ઓહ, અને મને લાગ્યું કે આ તે જ પરિસ્થિતિ છે જ્યાં
શું એન્ક્યૂ કિસ્સામાં, જો આપણે નલ enqueuing કરી રહ્યાં છો,
કદાચ અમે તેને હેન્ડલ કરવા માંગો છો, તો કદાચ અમે નથી.
અમે તેને ફરીથી નથી અહીં, પણ અમારી સ્ટેક કેસ તરીકે જ.
જો અમે નલ એન્ક્યૂ, તો અમે તેને અવગણી શકો છો.
કોઈપણ અમુક કોડ મેં ખેંચી શકે છે?
[વિદ્યાર્થી] હું માત્ર dequeue છે.
સંસ્કરણ 2 જે ઠીક છે.
તમે તે સમજાવવા માટે કરવા માંગો છો?
[વિદ્યાર્થી] પ્રથમ, તમે ખાતરી કરો કે ત્યાં કતાર માં કશુંક
અને તે માપ નીચે 1 દ્વારા રહ્યું છે.
તમે તે જરૂર છે, અને તે પછી તમે વડા પાછા
અને પછી 1 અપ વડા ખસેડો.
ઠીક છે, તેથી એક ખૂણામાં કેસ અમે ધ્યાનમાં હોય છે. યાહ.
[વિદ્યાર્થી] જો તમારા માથા છેલ્લા તત્વ છે,
પછી તમે વડા ઍરેની બહાર નિર્દેશ કરવા નથી માંગતા.
>> અરે વાહ, જેથી વડા તરીકે ટૂંક સમયમાં અમારા એરે ઓવરને બનાવ્યા,
જ્યારે અમે dequeue, અમારા વડા 0 થી લઈ modded કરીશું.
કમનસીબે, અમે તે એક પગલું ન કરી શકો છો.
હું જે રીતે હું કદાચ ઠીક છે હો અનુમાન
આ ચાર રચે છે * પ્રયત્ન રહ્યું છે, આપણે શું પરત કરી રહ્યાં છો,
ગમે તમારા ચલ નામ થવા માંગે છે.
પછી અમે અમારી ક્ષમતા દ્વારા વડા mod માંગો છો
અને પછી Ret આવો.
લોકો અહીં ઘણો તેઓ શું કરી શકે છે
આ you'll કિસ્સામાં જુઓ લોકો આમ જો વડા
ક્ષમતા કરતાં વધારે હોય છે, હેડ કરવું - ક્ષમતા.
અને તે માત્ર મોડ શું છે આસપાસ કામ કરી રહ્યા છે.
વડા મોડ = ક્ષમતા ખૂબ ક્લીનર છે
ક્ષમતા -. જો વડા ક્ષમતા વડા કરતાં વધુ આસપાસ વીંટવાનું ઓફ
>> પ્રશ્નો?
ઠીક છે, છેલ્લા વસ્તુ અમે બાકી અમારી સંલગ્ન યાદી છે.
તમે લિંક કરેલા યાદી વર્તન કેટલાક કરવા માટે વપરાઈ શકે જો તમે કર્યું
તમારા હેશ કોષ્ટકોમાં યાદીઓ સાથે કડી થયેલ છે, જો તમે હેશ ટેબલ હતી.
હું ભારપૂર્વક હેશ ટેબલ કરી ભલામણ કરીએ છીએ.
તમે પહેલેથી જ એક trie કરી શકો છો,
પરંતુ પ્રયત્નોમાં વધુ મુશ્કેલ હોય છે.
સિદ્ધાંત, તેઓ asymptotically છો વધુ સારા.
પરંતુ માત્ર મોટા બોર્ડ પર નજર,
કરવાનો પ્રયાસ કરે છે અને આમ વધુ સારી રીતે ક્યારેય, અને તેઓ વધુ મેમરી લે છે.
બધું વિશે વધુ કામ માટે વધુ ખરાબ હોવા અંત થાય છે પ્રયાસ કરે છે.
તે ડેવિડ Malan ઉકેલ શું હંમેશા
છે તે હંમેશા તેના trie ઉકેલ પોસ્ટ્સ, અને ચાલો જોવા જ્યાં તેઓ હાલમાં છે.
તેઓ શું હેઠળ હતી, ડેવિડ જ?
તેમણે 18 # જેથી, તે ઘણું જ ખરાબ નથી,
અને તે માટે એક શ્રેષ્ઠ જ હશે કરવાનો પ્રયાસ કરે છે તમે વિચાર કરી શકો છો
અથવા એક શ્રેષ્ઠ એક trie ઓફ પ્રયાસ કરે છે.
તે તેના મૂળ ઉકેલ છે પણ નથી?
મને લાગે છે કે trie ઉકેલો માટે રેમ વપરાશ આ શ્રેણીમાં વધુ હોય છે.
>> એકદમ ટોચ પર નીચે જાઓ, અને રેમ વપરાશ એક અંકો છે.
નીચે તરફ નીચે જાઓ, અને પછી તમે જોયા કરવાનો પ્રયાસ કરે છે શરૂ
, કે જ્યાં તમે સંપૂર્ણપણે વ્યાપક રેમ વપરાશ વિચાર
અને પ્રયત્નોમાં વધુ મુશ્કેલ હોય છે.
પરંતુ એક શૈક્ષણિક અનુભવ વર્થ સંપૂર્ણપણે જો તમે એક ન.
છેલ્લા વસ્તુ અમારા સંલગ્ન યાદી છે,
અને આ ત્રણ વસ્તુઓ, રન ટાઇમ સ્ટેકનું, ક્યુને, અને સંલગ્ન યાદીઓ,
ભવિષ્યના કોઈપણ વસ્તુ તમે ક્યારેય કમ્પ્યૂટર સાયન્સ કરવું
ધારે તમે આ બાબતો સાથે પારિવારિકતા હશે.
તેઓ એ જ બધું માટે મૂળભૂત છે.
>> યાદીઓ લિંક કરેલા છે, અને અહીં આપણે એક singly કડી થયેલ યાદી અમારી અમલીકરણ પ્રયત્ન છે રહ્યું છે.
શું singly કડી થયેલ નથી અર્થ તરીકે સમયમાં બમણું કડી થયેલ વિરોધ? હા.
[વિદ્યાર્થી] તે માત્ર આગામી નિર્દેશક તેના બદલે પોઇંટરો નિર્દેશ,
તેને અને તે પછી એક પૂર્વવર્તી એક જેવા હોય છે.
અરે વાહ, તેથી ચિત્ર બંધારણમાં માં, હું શું માત્ર કરી?
હું બે વસ્તુઓ હોય છે. હું ચિત્ર અને ચિત્ર હોય છે.
ચિત્ર બંધારણ, અમારા singly કડી થયેલ યાદીઓ,
ખચીત, અમે અમારી યાદી વડા માટે નિર્દેશક અમુક પ્રકારના હોય છે,
અને પછી અમારી યાદી અંદર, અમે માત્ર પોઇન્ટર હોય છે,
અને કદાચ આ પોઇન્ટ null છે.
તે તમારી singly યાદીની લિંક લાક્ષણિક ચિત્ર બની રહ્યું છે.
એક સમયમાં બમણું કડી થયેલ યાદી છે, તમે પાછળની જઈ શકે છે.
જો હું તમને યાદીમાં કોઇ નોડ આપો, પછી તમે જરૂરી મેળવી શકો છો
અન્ય કોઇ નોડ યાદીમાં જો તે સમયમાં બમણું કડી થયેલ યાદી છે.
પરંતુ જો હું તમને યાદીમાં ત્રીજા નોડ વિચાર અને તે singly કડી થયેલ યાદી છે,
કોઈ રીતે તમે ક્યારેય પ્રથમ અને બીજા ગાંઠો મેળવવા જઈ રહ્યાં છો.
અને ત્યાં લાભો અને detriments, અને એક સ્પષ્ટ એક છે
છે તમે વધુ કદ લે છે, અને તમે જ્યાં આ વસ્તુઓ હવે પોઇન્ટ છે ટ્રેક રાખવો પડે છે.
પરંતુ અમે માત્ર singly કડી થયેલ કાળજી.
>> થોડા વસ્તુઓ અમે અમલ કરવા માટે હોય રહ્યા છીએ.
તમારા typedef સ્ટ્રક્ટ નોડ, પૂર્ણાંક હું: સ્ટ્રક્ટ નોડ * આગામી; નોડ.
કે typedef તમારા મનમાં માં સળગાવી જોઇએ.
1 ક્વિઝ એક કડી થયેલ યાદી નોડ એક typedef આપવા માંગો જોઈએ,
અને તમે તરત જ કે નીચે બેદરકારીપૂર્વક કરવાનો પ્રયત્ન કરીશું
વિના પણ તે વિશે વિચારવાનો.
હું થોડા પ્રશ્નો ધારી, અમે અહીં સ્ટ્રક્ટ શા માટે જરૂરી છે?
અમે નોડ * કહી ન શકે કેમ?
[વિદ્યાર્થી] [અશ્રાવ્ય]
યાહ.
આ જ વસ્તુ છે કે એક વસ્તુ તરીકે નોડ વ્યાખ્યાયિત
પોતે typedef છે.
પરંતુ આ મુદ્દે, જ્યારે અમે આ સ્ટ્રક્ટ નોડ વ્યાખ્યા દ્વારા પદચ્છેદન પ્રકારની છો
અમે અમારા typedef હજી સમાપ્ત નથી છે, કે જેથી કારણ કે typedef નથી સમાપ્ત થઈ ગઈ છે,
નોડ અસ્તિત્વમાં નથી.
પરંતુ સ્ટ્રક્ટ નોડ કરે છે, અને અહીં, આ નોડ
આ પણ બીજું કશું કહેવાય કરી શકાય છે.
આ n એ કહી શકાય.
તે સંલગ્ન યાદી નોડ કહી શકાય.
તે કશું કહી શકાય.
પરંતુ આ સ્ટ્રક્ટ નોડ માટે આ સ્ટ્રક્ટ નોડ તરીકે આ જ વાત કહી શકાય જરૂર છે.
, તમે શું કહી આ પણ અહીં છે
અને જેથી પણ પ્રશ્ન બીજા બિંદુ જવાબ
જે શા માટે એક વખત જ્યારે તમે સ્ટ્ર્ક્ટ્સ અને સ્ટ્ર્ક્ટ્સ ઓફ typedefs જુએ લોટ,
તમે અનામી સ્ટ્ર્ક્ટ્સ જોવા જ્યાં તમે હમણાં typedef સ્ટ્રક્ટ જોશો પડશે,
સ્ટ્રક્ટ, શબ્દકોશ, અથવા ગમે અમલીકરણ.
>> અહીં અમે શા માટે નોડ કહેવું જરૂરી છે?
તે એક અનામી સ્ટ્રક્ટ કેમ ન હોઈ શકે?
તે લગભગ એ જ જવાબ છે.
[વિદ્યાર્થી] તમે સ્ટ્રક્ટ અંદર તે સંદર્ભ લો કરવાની જરૂર છે.
અરે વાહ, આ સ્ટ્રક્ટ અંદર, તો તમે સ્ટ્રક્ટ પોતે નો સંદર્ભ લો કરવાની જરૂર છે.
જો તમે સ્ટ્રક્ટ એક નામ આપતા નથી, જો તે એક અનામી સ્ટ્રક્ટ છે, તો તમે તેને ઉલ્લેખ કરી શકે છે.
અને છેલ્લા પરંતુ ઓછામાં ઓછા-આ તમામ પ્રયત્ન કરીશું નથી અંશે સરળ,
અને તેઓ તમને ખ્યાલ મદદ જો તમે આ લખી રહ્યાં નીચે કરીશું
કે તમે કંઇક ખોટું કરી રહ્યા છીએ જો વસ્તુઓ આ પ્રકારના અર્થમાં બનાવતા નથી.
છેલ્લું નથી, પરંતુ ઓછામાં ઓછા, આ શા માટે સ્ટ્રક્ટ નોડ * પ્રયત્ન નથી?
તે માત્ર શા માટે નોડ નથી સ્ટ્રક્ટ શકાય આગામી?
[વિદ્યાર્થી] પછીના સ્ટ્રક્ટ માટે પોઇન્ટર.
કે સ્વાભાવિકપણે અમે શું કરવા માંગો છો.
શા સ્ટ્રક્ટ આગામી નોડ પ્રયત્ન ક્યારેય શકે છે?
તે સ્ટ્રક્ટ * આગામી નોડ પ્રયત્ન શા માટે છે? યાહ.
[વિદ્યાર્થી] તે અનંત લૂપ જેવું છે.
યાહ.
[વિદ્યાર્થી] તે બધા એક જ હશે.
અરે વાહ, માત્ર અમે કેવી રીતે આકાર અથવા કંઈક થશે લાગે છે.
એક સ્ટ્રક્ટ કદ મૂળભૂત + અથવા - કેટલાક અહીં અથવા ત્યાં પેટર્ન.
તે વાસ્તવમાં માટે સ્ટ્રક્ટ માં વસ્તુઓ માપ સરવાળા જ હશે.
આ અહીં અધિકાર કંઈપણ ફેરફાર કર્યા વિના, માપ સરળ હોઈ રહ્યું છે.
સ્ટ્રક્ટ નોડ કદ માટે હું આગામી ઓફ + + કદ માપ પ્રયત્ન રહ્યું છે.
I ની માપ 4 હોઇ રહ્યું છે. આગામી કદ માટે 4 હોઇ રહ્યું છે.
સ્ટ્રક્ટ નોડ કદ થી 8 પ્રયત્ન રહ્યું છે.
જો અમે * નથી, sizeof વિચારી,
પછી sizeof (i) માટે 4 હોઇ રહ્યું છે.
સ્ટ્રક્ટ નોડ કદ આગામી માટે i ની કદ સ્ટ્રક્ટ આગામી ગાંઠની + + કદ પ્રયત્ન રહ્યું છે
હું સ્ટ્રક્ટ આગામી ગાંઠની + + + + કદ માપ.
તે ગાંઠો એક અનંત રિકર્ઝન હશે.
આ શા માટે આ કેવી રીતે વસ્તુઓ માટે હોય છે.
>> ફરીથી, ચોક્કસપણે કે યાદ,
અથવા ઓછામાં ઓછું તેને પર્યાપ્ત સમજો કે તમે કરવાનો પ્રયત્ન કરી શકો છો
તે શું જેવો હવો જોઈએ મારફતે કારણ છે.
આ વસ્તુઓ અમે અમલ કરવા માંગો છો જઈ રહ્યાં છો.
જો લંબાઈ યાદી-
તમે ઠગ અને આસપાસ ચાલુ રાખી શકે
વૈશ્વિક લંબાઈ અથવા કંઈક છે, પરંતુ અમે તે નથી જઈ રહ્યાં છો.
અમે યાદી લંબાઈ ગણતરી રહ્યા છીએ.
અમે સમાવે છે તેથી, જે શોધ જેવી મૂળભૂત છે,
તેથી અમે પૂર્ણાંકો એક કડી થયેલ યાદી જોવા માટે જો આ પૂર્ણાંક સંકળાયેલા યાદીમાં છે.
અંત થાય યાદીમાં શરૂઆતમાં દાખલ રહ્યું છે.
ઉમેરો કરવા માટે ઓવરને અંતે દાખલ રહ્યું છે.
Insert_sorted યાદીમાં માં સોર્ટ સ્થિતિ દાખલ રહ્યું છે.
ના Insert_sorted પ્રકારની ધારે છે કે તમે ઉપયોગમાં અથવા ક્યારેય અંત ખરાબ રીતે જોડો.
>> Insert_sorted જ્યારે તમે insert_sorted-અમલ કરી રહ્યા છીએ
ચાલો આપણે કહેવું કડી થયેલ યાદી છે.
આ તે શું હાલમાં જેમ, 2, 4, 5 જુએ છે.
હું 3 દાખલ કરો, જેથી લાંબા તરીકે યાદી પોતે પહેલેથી સૉર્ટ થાય છે માંગો છો,
તે સરળ છે શોધવા જ્યાં 3 અનુસરે છે.
હું 2 શરુ થાય છે.
ઠીક, 3 2 કરતા વધારે હોય છે, જેથી હું જવા રાખવા માંગો છો.
ઓહ, 4 ખૂબ મોટી છે, તેથી મને ખબર 3 થી 2 અને 4 વચ્ચે જઈ રહ્યું છે,
અને હું પોઇંટરો અને તે તમામ સામગ્રી ઠીક છે.
પરંતુ જો આપણે સખત insert_sorted ઉપયોગ નથી કર્યો,
ગમે ચાલો માત્ર કહે હું 6 ઉમેરવું,
પછી મારા સંલગ્ન યાદી આ બની રહ્યું છે.
તે હવે કોઈ અર્થ બનાવે છે, જેથી insert_sorted માટે, તમે માત્ર ધારણ કરી શકે છે
કે યાદી છટણી કરવામાં આવે છે, તેમ છતાં કામગીરી અસ્તિત્વમાં
જે તેને અલગ કરવામાં આવે નથી કારણ શકે છે, અને એ છે કે તે છે.
મદદરૂપ insert-જેથી શોધો તે મુખ્ય બાબતો માટે અમલમાં છે જઈ રહ્યાં છો છે.
>> હવે, એક મિનિટ લાગી લંબાઈ કરવું અને સમાવે છે,
અને તે પ્રમાણમાં ઝડપી પ્રયત્ન કરીશું.
બંધ કરવાનો સમય નજીક છે, તેથી લંબાઈ કોઈને માટે કશું હોય અથવા સમાવે છે?
તેઓ લગભગ સમાન હોવું રહ્યા છીએ.
[વિદ્યાર્થી] લંબાઈ.
ચાલો જોવા માટે, પુનરાવર્તન.
ઠીક છે.
તમે તે સમજાવવા માટે કરવા માંગો છો?
[વિદ્યાર્થી] હું માત્ર એક નિર્દેશક નોડ બનાવવા અને તેને પ્રથમ, જે આપણા વૈશ્વિક ચલ છે આરંભ કરવા માટે,
અને પછી હું જોવા માટે જો તે નલ જેથી હું seg દોષ ન મળી શકે અને 0 આપશે જો કે કેસ છે તપાસો.
નહિંતર, મારફતે લૂપ હું, પૂર્ણાંક અંદર રાખવામાં આવેલ
કેટલી વખત હું યાદી આગળના તત્વ ઍક્સેસ કરી છે
અને તે જ પગાર - વધારો કામગીરી પણ છે કે જે વાસ્તવિક તત્વ ઍક્સેસ કરવા માટે,
અને પછી હું સતત ચેક જો તે નલ છે તે જોવા માટે બનાવવા માટે,
અને જો તે નલ, તે પછી aborts અને માત્ર તત્વો હું ઍક્સેસ કરી છે સંખ્યા આપે છે.
>> [રોબ બી] કોઈને પણ બાબતની કોઈ પણ ટિપ્પણી છે?
આ દેખાય છે દંડ ચોકસાઈ જાગરૂક.
[વિદ્યાર્થી] મને નથી લાગતું કે તમે == નોડ નલ જરૂર છે.
અરે વાહ, તેથી જો નોડ == નલ વળતર 0.
પરંતુ જો નોડ == નલ પછી આ ઓહ, ત્યાં ચોકસાઈ મુદ્દો છે.
તે ફક્ત તમે મને પરત કરી રહ્યાં છો, પરંતુ તેને અવકાશ માં હમણાં નથી.
તમે હમણાં જ પૂર્ણાંક હું જરૂર છે, તેથી હું = 0.
પરંતુ જો નોડ નલ હોય, તો પછી હું હજુ પણ 0 પ્રયત્ન રહ્યું છે,
અને અમે 0 પાછા જઈ રહ્યાં છો, જેથી આ કેસ સરખા છે.
અન્ય સામાન્ય વસ્તુ જાહેરાત રાખે છે
લૂપ માટે ની ગાંઠની અંદર છે.
તમે કહેવું તદ્દન શકે છે, નં.
ચાલો તેને આ તરીકે રાખો.
હું કદાચ પૂર્ણાંક હું = 0 અહીં મૂકો છો,
પછી નોડ * નોડ = અહીં પ્રથમ છે.
અને આ સંભવિત છે કદાચ આ છૂટકારો હવે કેવી રીતે મેળવી શકો છો.
આ સંભવિત છે હું કેવી રીતે તે હોય શકે છે.
તમે આ જેવા તેના પર પણ જોઈ શકે છે.
લૂપ માળખું માટે અહીં આ
લગભગ પૂર્ણાંક હું = 0 માટે તમે કુદરતી પ્રયત્ન કરીશું
મને એરેને લંબાઈ કરતા ઓછી છે મને + +.
જો કે આવી જ રીતે તમે એક એરે પર ફરી વળવું, આ કેવી રીતે તમે એક કડી થયેલ યાદી પર ફરી વળવું.
>> આ અમુક બિંદુએ બીજા પ્રકૃતિ પ્રયત્ન કરીશું.
મન કે સાથે, આ માટે લગભગ સમાન વસ્તુ હોઈ રહ્યું છે.
તમે ઉપર સંકળાયેલી યાદી પર ફરી વળવું માંગો છો જઈ રહ્યાં છો.
આ નોડ હું કોઈ વિચાર શું કિંમત કહેવાય છે. જો
હું નોડ.
જો કે ગાંઠ પર મૂલ્ય = હું સાચું પરત, અને તે છે.
નોંધ કરો કે માત્ર એક જ રસ્તો અમે ક્યારેય ખોટા પાછા
જો અમે સમગ્ર યાદીની લિંક પર ફરી વળવું અને પરત સાચું નથી,
જેથી આ શું કરે છે.
તરીકે બાજુ નોંધ-અમે કદાચ ઉમેરો અથવા ઉમેરવું મળશે નહીં.
>> ઝડપી છેલ્લા નોંધ.
જો તમે સ્ટેટિક કીવર્ડ જુઓ, તેથી આપણે સ્થિર પૂર્ણાંક ગણતરી = 0 કહેવું,
તો પછી અમે ગણતરી કરી + +, તમે મૂળભૂત વૈશ્વિક ચલ કારણ કે તે વિચાર કરી શકો છો,
ભલે હું હમણાં જ કહ્યું હતું કે આ કેવી રીતે અમે લંબાઈ અમલ જઈ રહ્યાં છો નથી.
હું આ કરી રહ્યો છું અહીં, અને પછી + + ગણતરી.
કોઈપણ રીતે આપણે સંલગ્ન યાદી અમે અમારી ગણતરી incrementing આવે નોડ દાખલ કરી શકો છો.
આ બિંદુ છે સ્ટેટિક કીવર્ડ શું અર્થ થાય છે.
જો હું માત્ર પૂર્ણાંક ગણતરી હતી = 0 છે કે જે નિયમિત જૂના વૈશ્વિક ચલ હશે.
સ્થિર પૂર્ણાંક ગણતરી અર્થ એ છે કે તે આ ફાઈલ માટે વૈશ્વિક ચલ છે.
તેને કેટલીક અન્ય ફાઇલ માટે અશક્ય છે,
5 pset લાગે માંગો, જો તમે શરૂ કર્યું છે.
તમે બંને speller.c હોય છે, અને તમે dictionary.c હોય છે,
અને જો તમે માત્ર એક વૈશ્વિક વસ્તુ જાહેર, પછી speller.c પણ
dictionary.c અને ઊલટું માં વાપરી શકાય છે.
વૈશ્વિક ચલો કોઇપણ સી. ફાઈલ દ્વારા સુલભ છે,
પરંતુ સ્થિર ચલો માત્ર ફાઈલ પોતે અંદર સુલભ છે,
જેથી અંદર સ્પેલચેકરરૂપરેખાંંકિતકરો અથવા dictionary.c ની અંદર છે,
આ કેવી રીતે હું મારા એરે માપ માટે મારી ચલ જાહેર કરશે પ્રકારની છે
અથવા શબ્દકોશ શબ્દો મારા નંબર માપ.
ત્યારથી હું એક વૈશ્વિક ચલ જાહેર કે જે કોઇ પણ ઍક્સેસ નથી માંગતા,
હું ખરેખર માત્ર મારા પોતાના હેતુ માટે તે વિશે કાળજી.
>> આ વિશે સારી વસ્તુ પણ સમગ્ર નામ ટક્કર સામગ્રી છે.
જો કોઇ અન્ય ફાઇલ માટે એક વૈશ્વિક ગણતરી કહેવાય ચલ ઉપયોગ કરવાનો પ્રયાસ કરે છે, વસ્તુઓ ખૂબ, ખૂબ ખોટું જાય છે,
તેથી આ સરસ રીતે વસ્તુઓ સલામત રાખે છે, અને માત્ર તમે તેને ઍક્સેસ કરી શકો છો,
અને કોઈ એક, અને જો કોઈએ વૈશ્વિક ગણતરી કહેવાય ચલ ઘોષણા કરી શકાય છે
પછી તેને તમારા સ્થિર ગણતરી કહેવાય ચલ સાથે દખલ કરશે.
કે સ્થિર શું છે. એ એક ફાઈલ વૈશ્વિક ચલ છે.
>> બાબતની પ્રશ્નો?
બધા સમૂહ. બાય.
[CS50.TV]