>> 1 વક્તા: ઠીક હવે કે છેલ્લા કાર્યક્રમ.
અને આ જ સમયે, ચાલો સ્પષ્ટ ફાળવવા દો અમુક મેમરી કે જેમાં
વપરાશકર્તાની ઇનપુટ સંગ્રહિત કરવામાં આવશે.
આમ કરવા માટે, ચાલો તેને પ્રથમ પર હજી મેળ બેસાડી દો અમે એ જાહેર કોડ જ્યાં વાક્ય
અગાઉ ચાર રચે સ્ટાર છે.
આ જ સમયે, ચાલો ફરી જાહેર તે નીચે પ્રમાણે -
ચાર રચે છે એ કૌંસ 16, દાખલા તરીકે, બંધ કૌંસ.
>> અન્ય શબ્દોમાં, કોઈ માટે એ જાહેર દો લાંબા સમય સુધી એક અક્ષર એક સરનામું છે,
પરંતુ 16 અક્ષરો બદલે પણ દર્શાવે છે.
આ રીતે, વપરાશકર્તા સુધી 15 માં ટાઈપ કરી શકો છો અક્ષરો અને હજુ પણ માટે જગ્યા છોડો
નલ ટર્મીનેટર.
સાચવો માતાનો આગળ વધવા દો, સંકલન, અને આ કાર્યક્રમ ચલાવો.
Scanf2 કોઈ સ્લેશ scanf2 કરો.
હવે હેલ્લો જેવી શબ્દમાળા લખો, અને અમે હેલ્લો માટે આભાર માન્યો કરી રહ્યા છીએ.
>> હવે, સમસ્યા હજુ પણ છે.
હું માત્ર જ છે, કે જે હેલો માં લખ્યો નલ માટે પાંચ અક્ષરો, વત્તા 1
ટર્મિનેટર.
તે માત્ર ત્યારે જ આપણને નહીં છ બાઇટ્સ માટે જરૂર.
>> પરંતુ દુર્ભાગ્યે, અમે માત્ર કુલ 16 ફાળવવામાં.
તેથી જો 16 માં વપરાશકર્તા ખરેખર પ્રકારના અક્ષરો, કે 17, અથવા કેટલાક સો
અક્ષરો, અમે હજુ પણ નથી જઈ રહ્યાં છો આ માટે મેમરી પૂરતી જગ્યા છે
વપરાશકર્તાની ઇનપુટ.
અને હકીકતમાં, આ કરે છે વપરાશકર્તા ઈનપુટ કરવા ખૂબ જ
સામાન્ય રીતે મુશ્કેલ.
અમે અમલ શા માટે અને ખરેખર, આ છે પ્રથમ માં વિચાર શબ્દમાળા કાર્ય
CS50 પુસ્તકાલય માં સ્થાન -
તે નિયંત્રિત કરવા માટે બહાર આકૃતિ કેવી રીતે પરિસ્થિતિ જ્યાં વપરાશકર્તા પ્રકારો માં
અમે કરતાં વધુ અક્ષરો શરૂઆતમાં કલ્પના કરી હતી.
>> પ્રમાણિકપણે, વગર સંપૂર્ણપણે આ કાર્યક્રમ પુનર્લેખન,
આ બોલ પર કોઈ સ્વચ્છ ઉકેલ છે.
તેના બદલે, અમે શું હશે વિચાર છે એક પર વપરાશકર્તા પાસેથી એક અક્ષર
સમય, ફરીથી અને ફરીથી.
અને દરેક સમયે અમે અમે છો ખ્યાલ તો મેમરી બહાર, અમે પર પડે
તે બિંદુ પર પાછા જાઓ અને ફરી ફાળવવા કેટલાક વધુ મેમરી, વપરાશકર્તાની નકલ
અમારી પ્રથમ ભાગ જુના ઇનપુટ નવા માં મેમરી,
મેમરી મોટા ભાગ.
અને પછી ફરીથી તે પ્રક્રિયા પુનરાવર્તન અને વપરાશકર્તા પૂરી કરવામાં આવે છે ફરીથી ત્યાં સુધી
તેના અથવા તેણીના ઇનપુટ.