[Powered by Google Translate] [CS50 લાયબ્રેરી]
[Nate Hardison] [હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે. CS50.TV]
આ CS50 પુસ્તકાલય મદદરૂપ સાધન છે કે અમે ઉપકરણ પર સ્થાપિત કરેલ છે
તેને સરળ માટે તમે કાર્યક્રમો લખવા માટે બનાવવા કે ઈનપુટ માટે પ્રોમ્પ્ટ વપરાશકર્તાઓ.
આ વિડિઓ, અમે પાછા પડદો ખેંચી અને પડશે બરાબર શું CS50 પુસ્તકાલય છે જુઓ.
>> સી લાઇબ્રેરીઓ પર વિડિઓ, અમે તમને કેવી રીતે # હેડરો ફાઇલો સમાવેશ અંગે વાત
તમારી સ્રોત કોડ માં પુસ્તકાલય છે,
અને તે પછી તમને લિંક તબક્કા દરમ્યાન દ્વિસંગી પુસ્તકાલય ફાઇલ સાથે લિંક
સંકલન પ્રક્રિયા છે.
હેડર ફાઈલો ગ્રંથાલયનો ઇન્ટરફેસ સ્પષ્ટ કરો.
એટલે કે, તેઓ સ્ત્રોતોના તમામ કે પુસ્તકાલય ઉપલબ્ધ છે માટે તમે ઉપયોગ કરવા વિગત,
કાર્ય ઘોષણાઓ, સ્થિરાંકો, અને ડેટા પ્રકારો જેમ.
બાઈનરી ફાઈલ પુસ્તકાલય પુસ્તકાલય અમલીકરણ સમાવે છે,
જે પુસ્તકાલય હેડર ફાઈલો અને લાઈબ્રેરી સી. સ્રોત કોડ ફાઈલો ના સંકલિત છે.
>> બાઈનરી ફાઈલ પુસ્તકાલય ખૂબ જ જોવા કારણ કે તે છે, એ જ પ્રમાણે બાઈનરી માં, રસપ્રદ નથી.
તેથી, ચાલો લાઈબ્રેરી માટે હેડર ફાઈલો બદલે પર એક નજર.
આ કિસ્સામાં, ત્યાં માત્ર એક જ હેડર cs50.h. તરીકે ઓળખાતી ફાઈલ છે
અમે તે વપરાશકર્તા માટે સ્થાપિત કર્યા છે ડિરેક્ટરીમાં સમાવેશ થાય છે
સાથે અન્ય સિસ્ટમ 'લાઈબ્રેરીઓ હેડર ફાઈલો સાથે.
>> એક પ્રથમ વસ્તુઓ તમે નોટિસ કરશો છે કે cs50.h # અન્ય લાઈબ્રેરીઓ માંથી હેડર ફાઈલો સમાવે છે -
ફ્લોટ, મર્યાદા, પ્રમાણભૂત bool, અને પ્રમાણભૂત lib.
ફરીથી, રિઈન્વાઈટિંગ ધ વ્હીલ ન સિદ્ધાંતનું પાલન,
અમે CS0 સાધનો કે જે આપણા માટે અન્ય પૂરી પાડવામાં મદદથી પુસ્તકાલય નિર્માણ કર્યું છે.
>> આગામી વસ્તુ તમે પુસ્તકાલયમાં જોશો છે કે અમે એક નવું કહેવાય પ્રકાર define "શબ્દમાળા."
આ રેખા ખરેખર માત્ર કોલસો બનાવો * પ્રકાર માટે ઉપનામ બનાવે છે,
તેથી તે જાદુઇ લક્ષણો સાથે નવા શબ્દમાળા પ્રકાર નથી ભીંજવવું નથી
સામાન્ય રીતે અન્ય ભાષાઓમાં શબ્દમાળા વસ્તુઓ સાથે સંકળાયેલ,
જેમ કે લંબાઈ છે.
કારણ અમે આ કર્યું છે તે લોહીલુહાણ વિગતો નવી પ્રોગ્રામરો રક્ષણ છે
પોઇન્ટર ઓફ ત્યાં સુધી તેઓ તૈયાર છો.
>> હેડર ફાઈલ આગળના ભાગ વિધેયોને જાહેરાત છે
કે CS50 પુસ્તકાલય દસ્તાવેજીકરણ સાથે પૂરી પાડે છે.
અહીં ટિપ્પણીઓ વિગતવાર સ્તર નોટિસ.
આ અગત્યનું સુપર થાય છે જેથી લોકોને ખબર કેવી રીતે આ વિધેયોને વાપરવાનું.
અમે બદલામાં જાહેર, વપરાશકર્તા અને વળતર અક્ષરો, ડબલ્સમાં, ફ્લોટ્સ, ints પૂછવા કાર્ય કરે છે,
લાંબા લોન્ગ્સ, અને શબ્દમાળાઓ, આપણા પોતાના શબ્દમાળા પ્રકાર મદદથી.
માહિતી છુપાવવામાં સિદ્ધાંત બાદ,
. અમે અલગ કેચ અમલીકરણ ફાઈલ અમારા વ્યાખ્યા મૂકી છે - cs50.c -
વપરાશકર્તા સ્રોત ડિરેક્ટરીમાં સ્થિત થયેલ છે.
અમે તે ફાઇલ પ્રદાન કરેલો છે કે જેથી તમે તેને પર એક નજર કરી શકો છો,
તે જાણવા માટે, અને તે વિવિધ મશીનો પર પુનઃકમ્પાઈલ જો તમે ઈચ્છો,
ભલે અમે લાગે છે કે તે સારું આ વર્ગ માટે સાધન પર કામ કરે છે.
કોઈપણ રીતે, ચાલો તે પર એક નજર હવે લો.
>> આ GetChar, GetDouble, GetFloat, GetInt, કાર્યો અને GetLongLong
છે બધા GetString કાર્ય ટોચ પર બાંધવામાં આવે છે.
તે તારણ આપે છે કે તેઓ તમામ આવશ્યક સમાન પેટર્ન અનુસરો.
તેઓ જ્યારે લૂપ વાપરવા માટે ઇનપુટ એક વાક્ય માટે વપરાશકર્તા પૂછવા.
તેઓ વપરાશકર્તા એ ખાલી લીટી ઇનપુટ્સ જો એક ખાસ મૂલ્ય આવો.
તેઓ યોગ્ય પ્રકાર તરીકે વપરાશકર્તાની ઇનપુટ પાર્સ પ્રયત્ન કરે છે,
તે ચાર રચે છે, ડબલ, એક ફ્લોટ, વગેરે હોવું
અને પછી તેઓ ક્યાં તો પરિણામ આપશે જો ઇનપુટ સફળતાપૂર્વક પદચ્છેદન કરવામાં આવી હતી
અથવા તેઓ વપરાશકર્તા reprompt.
>> ઊંચા સ્તરે, ત્યાં ખરેખર મુશ્કેલ કશું અહીં છે.
તમે જેમ જ સંગઠિત કોડ હોય શકે જાતને ભૂતકાળમાં.
કદાચ વિસ્મૃત દેખાવ સૌથી ભાગ sscanf કોલ કે જે વપરાશકર્તા ઈનપુટ parses છે.
Sscanf ઇનપુટ ફોર્મેટ કન્વર્ઝન કુટુંબ ભાગ છે.
તે પ્રમાણભૂત io.h માં રહે છે, અને તેના કામ માટે એક સી શબ્દમાળા પાર્સ છે,
ચોક્કસ બંધારણ અનુસાર, ચલ માં વિશ્લેષણ પરિણામો સ્ટોર
આ કોલર દ્વારા પૂરી પાડવામાં આવેલ.
કારણ કે ઇનપુટ ફોર્મેટ કન્વર્ઝન કાર્યો ખૂબ ઉપયોગી છે, બહોળી રીતે ઉપયોગમાં લેવાતી વિધેયો છે
કે સાહજિક સુપર પ્રથમ નથી,
અમે ઉપર જવા કેવી રીતે કામ કરે છે sscanf પડશે.
>> Sscanf પ્રથમ દલીલ ચાર રચે છે * છે - એક અક્ષર માટે એક નિર્દેશક.
માટે કાર્ય યોગ્ય રીતે કામ કરવા માટે,
કે અક્ષર એક સી શબ્દમાળા પ્રથમ અક્ષર હોવો જોઈએ,
આ નલ \ 0 પાત્ર સાથે સમાપ્ત.
આ પદચ્છેદ શબ્દમાળા છે
Sscanf બીજી દલીલ બંધારણમાં શબ્દમાળા છે,
સામાન્ય રીતે એક શબ્દમાળા સતત તરીકે પસાર થયો,
અને તમે જ્યારે printf ઉપયોગ કરતા પહેલા આ જેવી શબ્દમાળા જોઈ હોય શકે છે.
બંધારણ શબ્દમાળા માં ટકા સાઇન રૂપાંતરણ specifier સૂચવે છે.
આ પાત્ર તાત્કાલિક ટકા સાઇન બાદ,
C ની પ્રકાર કે અમે રૂપાંતરિત કરવા માંગો છો sscanf સૂચવે છે.
GetInt, તમે જુઓ કે ત્યાં% d અને% C છે.
આનો અર્થ એ થાય કે sscanf એક અક્ષાંશ int પર પ્રયાસ કરશે - આ% d - અને ચાર રચે છે -% c.
બંધારણ શબ્દમાળા દરેક રૂપાંતર specifier માટે,
sscanf તેની દલીલ યાદીમાં અનુરૂપ દલીલ પછી અપેક્ષા રાખી છે.
કે દલીલ યોગ્ય લખેલા સ્થાન માટે નિર્દેશ જ જોઈએ
જેમાં રૂપાંતર પરિણામ સંગ્રહવા માટે.
>> આમ લાક્ષણિક રીતે sscanf કોલ પહેલાં સ્ટેક પર એક ચલ બનાવો
દરેક વસ્તુ કે જે તમે શબ્દમાળા માંથી પદચ્છેદ કરવા માંગો છો માટે
આ & "અને" નું ચિહ્ન - - અને પછી સરનામા ઓપરેટર વાપરવા માટે પોઇંટરો પસાર
આ sscanf કૉલ કરવા માટે તે ચલો છે.
તમે જોઈ શકો છો કે GetInt આપણે બરાબર આવું.
આ sscanf કોલ પહેલાં અધિકાર, અમે એક n એ પૂર્ણાંક તરીકે ઓળખાય છે અને સ્ટેક પર ચાર રચે કૉલ કો ઘોષિત કર્યા,
અને અમે sscanf કોલ માં તેમને પોઇંટરો પસાર કરે છે.
સ્ટેક પર આ ચલો પુટિંગ જગ્યાને મદદથી ઉપર પ્રાધાન્ય આપવામાં આવે છે
malloc સાથે ઢગલો છે, કારણ કે તમે malloc કોલ ઓવરહેડ ટાળવા પર,
અને તમે મેમરી લીક અંગે ચિંતા કરવાની જરૂર નથી.
એક ટકા સાઇન દ્વારા નથી પ્રિફિક્સ અક્ષરો રૂપાંતર ન પૂછવા નથી.
ઊલટાનું તેઓ માત્ર ફોર્મેટ સ્પષ્ટતા ઉમેરો.
>> ઉદાહરણ તરીકે, જો GetInt બંધારણમાં સ્ટ્રિંગ% d ને બદલે હતા
sscanf અક્ષર એક પૂર્ણાંક દ્વારા અનુસરવામાં જોવા માટે કરશે,
અને જ્યારે તે પૂર્ણાંક રૂપાંતરિત કરવાનો પ્રયાસ કરશે, તો તે સાથે જે કંઈપણ નથી કરશે.
આ માત્ર અપવાદ સફેદજગ્યાના છે.
બંધારણ શબ્દમાળા સફેદ જગ્યા અક્ષરો સફેદજગ્યાના કોઈપણ રકમ સાથે મેળ -
બધા પણ નથી.
તેથી, કે શા માટે ટિપ્પણી અગ્રણી અને / અથવા સફેદજગ્યાના પાછળનો સાથે કદાચ ઉલ્લેખ કર્યો છે.
તેથી, આ બિંદુએ તે અમારી sscanf કોલ જેવું દેખાય પર વપરાશકર્તાની ઇનપુટ શબ્દમાળા પાર્સ પ્રયત્ન કરશે
શક્ય અગ્રણી સફેદજગ્યાના ચકાસીને,
એક પૂર્ણાંક છે કે જે રૂપાંતરિત કરવામાં આવશે પૂર્ણાંક ચલ n માં સ્ટોર દ્વારા અનુસરવામાં
સફેદજગ્યાના કેટલાક જથ્થો અનુસરતા, અને એક અક્ષર દ્વારા અનુસરવામાં
આ ઘરનાં પરચૂરણ કામો ચલ કેચ સંગ્રહ થાય છે.
>> પરત કિંમત વિશે શું?
Sscanf શરૂ ના ઈનપુટ લીટી પદચ્છેદ સમાપ્ત કરવા માટે કરશે,
જ્યારે તે અંત સુધી પહોંચે અટકાવવા અથવા જ્યારે ઇનપુટ એક પાત્ર
નથી મેળ ખાતા નથી અથવા બંધારણમાં અક્ષર જ્યારે તે રૂપાંતર કરી શકતા નથી.
તે વળતર કિંમત એક જ્યારે તે રોકી માટે વપરાય છે.
જો તે બંધ કરી દીધું, કારણ કે તે ઇનપુટ શબ્દમાળાને અંતે પહોંચી
કોઈપણ રૂપાંતરણો કરવા પહેલાં અને ફોર્મેટ સ્ટ્રિંગ ભાગ સાથે મેળ નિષ્ફળ પહેલાં,
પછી ખાસ સતત EOF ફર્યા છે.
નહિંતર, તે સફળ રૂપાંતરણો આપે,
જે 0, 1, અથવા 2 હોઇ શકે, કારણ કે અમે બે રૂપાંતરણ માટે પૂછ્યું છે શકે છે.
અમારા કિસ્સામાં, અમે ખાતરી કરો કે વપરાશકર્તા પૂર્ણાંક અને માત્ર પૂર્ણાંક માં ટાઇપ બનાવવા માંગો છો.
>> તેથી, અમે sscanf 1 પરત કરવા માંગો છો. શા માટે જુઓ છો?
જો sscanf 0 પરત ફર્યા, પછી કોઈ રૂપાંતરણ કરવામાં આવ્યા હતા,
જેથી વપરાશકર્તા ઈનપુટ શરૂઆતમાં પૂર્ણાંક સિવાયના અન્ય લખ્યો.
જો sscanf 2 આપે છે, પછી વપરાશકર્તા યોગ્ય રીતે તેને ટાઇપ નહોતી ઇનપુટ શરૂઆતમાં માં,
પરંતુ તેઓ પછી કેટલાક પાત્ર બિન સફેદજગ્યાના માં પછીથી લખ્યો
આ% થી કેચ રૂપાંતર સફળ રહ્યા હતા.
વાહ, કે તે તદ્દન એક ફંક્શન કોલ માટે એક લાંબી સમજૂતી છે.
કોઈપણ રીતે, જો તમે sscanf અને તેના અન્ય ભાઇ બહેન પર વધુ જાણકારી માંગો છો,
બહાર મદદ પાનાંઓ, ગૂગલ, અથવા બંને તપાસો.
ત્યાં ફોર્મેટ સ્ટ્રિંગ વિકલ્પો ઘણાં હોય છે,
અને આ તમે મજૂર ઘણો સેવ જ્યારે સી માં શબ્દમાળાઓ પાર્સ કરવાનો પ્રયાસ કરી શકો છો
>> ગ્રંથાલયનો આ અંતિમ કાર્ય માટે જોવા GetString છે.
તે તારણ આપે છે કે GetString એક કપટી યોગ્ય રીતે લખી કાર્ય છે,
ભલે તે આવા સરળ, સામાન્ય કાર્ય જેવા લાગે છે.
આ કેમ બને છે?
વેલ, ચાલો અમે રેખા સ્ટોર કેવી રીતે જઈ રહ્યાં છો તે વિશે વિચારે છે કે લોગ વપરાશકર્તા પ્રકારો
કારણ કે શબ્દમાળા અક્ષરો ક્રમ છે,
અમે સ્ટેક પર ઝાકઝમાળ તેને સંગ્રહવા માંગો છો શકે છે,
પરંતુ અમે જાણતા કેટલા એરે માટે પ્રયત્ન રહ્યું છે ત્યારે અમે તેને જાહેર જરૂર છે.
તેવી જ રીતે, જો આપણે તેને ઢગલો પર મૂકવા માંગો છો,
અમે malloc માટે બાઇટ્સ સંખ્યા અમે અનામત કરવા માંગો છો પસાર કરવાની જરૂર છે,
પરંતુ આ અશક્ય છે.
અમે કોઇ વિચાર કેટલા અક્ષરો વપરાશકર્તા લખો કરશે
પહેલાં વપરાશકર્તા ખરેખર તેમને લખો નથી.
>> આ સમસ્યા માટે સરળ ઉકેલ માત્ર જગ્યા એક મોટા ભાગ અનામત, કહે છે,
આ વપરાશકર્તા ઈનપુટ માટે 1000 અક્ષરો એક બ્લોક,
એમ ધારી રહ્યા છીએ કે જે વપરાશકર્તા શબ્દમાળા કે લાંબા ક્યારેય લખો કરશે.
આ બે કારણોસર ખરાબ વિચાર છે.
પ્રથમ એમ ધારી રહ્યા છીએ, કે જે વપરાશકર્તાઓને ખાસ શબ્દમાળાઓ કે લાંબા સમય સુધી ન લખો નથી,
તમે મેમરીની જરુર કચરો શકે છે.
આધુનિક મશીનો પર, આ એક મુદ્દો ન હોઇ શકે જો તમે આ કરો છો શકે છે
એક અથવા બે અલગ કિસ્સાઓમાં,
પરંતુ જો તમારી પાસે લુપમાં વપરાશકર્તાની ઇનપુટ લઇ રહ્યા છીએ અને પછી ઉપયોગ માટે સ્ટોર,
તમે ઝડપથી ઉપર મેમરી એક ટન suck કરી શકો છો.
વધુમાં, જો કાર્યક્રમ તમે લખી રહ્યાં નાના કમ્પ્યુટર માટે છે -
એક અથવા મર્યાદિત મેમરી સાથે કંઈક બીજું સ્માર્ટફોન જેવા ઉપકરણ -
આ ઉકેલ સમસ્યાઓ ખૂબ ઝડપથી થાય છે.
બીજો, વધુ ગંભીર માટે આ નથી કારણ એ છે કે તે તમારા કાર્યક્રમ નહીં નિર્બળ
શું બફર ઓવરફ્લો હુમલો કહેવાય છે માટે.
પ્રોગ્રામિંગ, એક બફર કામચલાઉ ઇનપુટ કે આઉટપુટ માહિતી સંગ્રહવા માટે વાપરવામાં મેમરી છે,
જે આ કિસ્સામાં અમારા બ્લોક 1000 કોલસો બનાવો છે.
એક બફર ઓવરફ્લો ત્યારે થાય છે જ્યારે માહિતી બ્લોક ઓવરને ભૂતકાળ લખાયેલ છે.
>> ઉદાહરણ તરીકે, જો વપરાશકર્તા ખરેખર 1000 કરતાં વધુ અક્ષરો ટાઇપ કરે છે.
તમે આ અનુભવ હોઈ શકે છે આકસ્મિક જ્યારે સંગ્રહ સાથે પ્રોગ્રામિંગ.
જો તમે 10 ints ઝાકઝમાળ છે, કંઇ તમે વાંચી અથવા લખવાનો પ્રયાસ માંથી સ્ટોપ્સ
15 ઈન્.
ત્યાં કોઈ કમ્પાઇલર ચેતવણીઓ અથવા ભૂલો છે.
આ કાર્યક્રમ માત્ર સીધા આગળ ભૂલો અને મેમરી ઍક્સેસ
જ્યાં તે એમ વિચારે છે કે 15 પૂર્ણાંક હોવી જોઈએ, અને આ તમારા અન્ય ચલો પર ફરીથી લખી શકો છો.
સૌથી ખરાબ કિસ્સામાં, તમે તમારા કાર્યક્રમ આંતરિક કેટલાક પર ફરીથી લખી શકો છો
નિયંત્રણ પદ્ધતિઓ, તમારા કાર્યક્રમ પરિણમે છે વાસ્તવમાં વિવિધ સૂચનો ચલાવવા માટે
કરતાં તમે ઈરાદો હતો.
>> હવે, તે આ આકસ્મિક કરવું સામાન્ય નથી,
પરંતુ આ રીતે સામાન્ય તરકીબ કે ખરાબ ગાય્ઝ માટે કાર્યક્રમો તોડી ઉપયોગ
અને અન્ય લોકોના કમ્પ્યુટર્સ પર મલીન કોડ મૂકો.
તેથી, અમે અમારા નિષ્કપટ ઉકેલ ન વાપરી શકો છો.
અમને સંવેદનશીલ હોવા અમારા કાર્યક્રમોનું અટકાવવા માર્ગ જરૂર
બફર ઓવરફ્લો હુમલો છે.
આ કરવા માટે, અમે ખાતરી કરવા માટે કે જે અમારા બફર તરીકે અમે વાંચી પ્રગતિ કરી શકે છે કરવાની જરૂર છે
વપરાશકર્તા પાસેથી વધુ ઇનપુટ.
ઉકેલ? અમે ઢગલો ફાળવવામાં બફર વાપરો.
કારણ કે આપણે માપ બદલે તે પુન: માપ એ realloc ફંક્શનનો ઉપયોગ કરીને,
અને અમે બે નંબર સાચવી રાખે છે - બફર આગામી ખાલી સ્લોટ ની અનુક્રમણિકા
અને લંબાઈ અથવા બફર ક્ષમતા.
અમે એક fgetc ફંક્શનનો ઉપયોગ કરીને સમયે એક વપરાશકર્તા પાસેથી અક્ષરો માં વાંચો.
આ દલીલ fgetc કાર્ય લે - stdin ની - પ્રમાણભૂત ઈનપુટ શબ્દમાળા સંદર્ભ છે,
જે preconnected ઇનપુટ ચેનલ છે કે જે વપરાશકર્તાની ઇનપુટ પરિવહન કરવા માટે વપરાય છે
ટર્મિનલ ના કાર્યક્રમ છે.
>> જ્યારે પણ નવા પાત્રની માં વપરાશકર્તા પ્રકારો, અમે જોવા માટે ચકાસો જો અનુક્રમણિકા
આગામી મફત સ્લોટ ઓફ વત્તા 1 છે બફર ક્ષમતા કરતાં વધારે હોય છે.
+1 ને કારણ કે જો આગામી મફત ઇન્ડેક્સ 5 છે આવે છે,
પછી અમારી બફર લંબાઈ 6 0 ઈન્ડેક્સીંગ માટે આભાર હોવા જ જોઈએ.
જો અમે જગ્યા બફર ચલાવવા કર્યો છે, તો અમે તેનો આકાર બદલવા માટે પ્રયત્ન કરે છે,
તે બમણો કે જેથી અમે વખત સંખ્યા પર કાપવામાં કે અમે માપ બદલો
જો વપરાશકર્તા એ ખરેખર લાંબા શબ્દમાળા માં લખી રહ્યા છે.
જો શબ્દમાળા ખૂબ લાંબુ મેળવેલ છે અથવા જો અમે ઢગલો મેમરી રન આઉટ,
અમે અમારા બફર અને વળતર નલ મુક્ત.
>> છેલ્લે, અમે બફર કરવા માટે ઘરનાં પરચૂરણ કામો જોડો.
એકવાર વપરાશકર્તા હિટ દાખલ કરો અથવા પાછા ફરવા માટે, નવી લાઇન સંકેત,
અથવા ખાસ ઘરનાં પરચૂરણ કામો - નિયંત્રણ ડી - જે ઇનપુટ એક ઓવરને નહીં,
અમે જોવા માટે જો વપરાશકર્તા ખરેખર કંઈપણ બધી અંતે લખ્યો ચેક કરવું.
જો નહિં, તો અમે નલ આવો.
નહિંતર, કારણ કે અમારા બફર કદાચ મોટી કરતાં અમે જરૂર છે,
સૌથી ખરાબ કિસ્સામાં તે લગભગ બમણી મોટી આપણે જરૂર છે
કારણ કે અમે દર વખતે અમે ફરીથી કદમાં બે વાર,
અમે ફક્ત જગ્યાનો જથ્થો છે કે અમે જરૂર મદદથી શબ્દમાળા એક નવી કૉપિ બનાવો.
અમે malloc કોલ વધારાનો 1 ઉમેરવા માટે,
0 ની \ - કે તેથી ખાસ નલ ટર્મીનેટર પાત્ર માટે જગ્યા છે
અમે શબ્દમાળાને ઉમેરી એકવાર અમે અક્ષરો બાકીના નકલ કે જે,
strcpy બદલે strncpy મદદથી
તેથી અમે સ્પષ્ટ કરી શકો છો ચોક્કસ કેટલી અક્ષરો આપણે નકલ કરવા માંગો છો.
Strcpy નકલ કરે છે જ્યાં સુધી તે \ 0 બનાવ્યા.
તો પછી અમે અમારી બફર મુક્ત અને કોલર માટે નકલ આવો.
>> કોણ જાણતા આવા કાર્ય સરળ ઉપલક જેથી જટિલ થઈ શકે છે?
હવે તમને ખબર શું CS50 પુસ્તકાલય જાય.
>> મારું નામ Nate Hardison છે, અને આ CS50 છે.
[CS50.TV]