1
00:00:00,000 --> 00:00:00,180

2
00:00:00,180 --> 00:00:02,920
>> 1 વક્તા: માતાનો એક કાર્યક્રમ લખીએ કે
વગર વપરાશકર્તા માંથી શબ્દમાળા મળે

3
00:00:02,920 --> 00:00:05,700
cs50 પુસ્તકાલય છે મદદથી
GetString કાર્ય.

4
00:00:05,700 --> 00:00:08,720
આ કરવા માટે, અમે આગળ વધીશું અને ઉપયોગ કરશો
scanf, કાર્ય કે GetString

5
00:00:08,720 --> 00:00:10,950
કાર્ય ખરેખર વાપરે
હૂડ નીચે.

6
00:00:10,950 --> 00:00:13,780
પરંતુ હું ઇરાદાપૂર્વક આ કરવા જાઉં છું
બગડેલ રીતે.

7
00:00:13,780 --> 00:00:17,230
હું મને લાગે છે કે જે રીતે કરવા જાઉં છું
અધિકાર હોય છે, પરંતુ તે તારણ છે કે જે

8
00:00:17,230 --> 00:00:19,380
મારા ધારણા બનશે
ખૂબ, ખૂબ અપૂર્ણ છે.

9
00:00:19,380 --> 00:00:20,800
અને હકીકતમાં, તદ્દન જોખમી છે.

10
00:00:20,800 --> 00:00:24,750
કારણ કે હું વિશે છું એક જેવી ભૂલો
પ્રતિસ્પર્ધકો દ્વારા શોષણ કરી શકાય કરો

11
00:00:24,750 --> 00:00:28,870
જેમ કે તમારા મશીન અથવા તમારા કાર્યક્રમ
સંભવિત પર પગલા લેવા જરૂરી છે.

12
00:00:28,870 --> 00:00:30,200
>> નીચે પ્રમાણે છે શરૂ થાય છે.

13
00:00:30,200 --> 00:00:33,540
પ્રથમ આપણે આપણા શબ્દમાળા જાહેર દો,
અન્યથા, ચાર રચે છે સ્ટાર તરીકે હવે ઓળખાય

14
00:00:33,540 --> 00:00:34,750
અને તે ઓ ફોન કરો.

15
00:00:34,750 --> 00:00:39,400
આગામી શબ્દમાળા માટે વપરાશકર્તા પૂછવા દે,
"કૃપા કરીને શબ્દમાળા." સાથે અને

16
00:00:39,400 --> 00:00:44,250
હવે વપરાશકર્તા માંથી શબ્દમાળા મેળવવા દો
અવતરણ ચિહ્નો પૂરાં કરવાં ભાવ, "% એ." scanf મદદથી માં

17
00:00:44,250 --> 00:00:47,760
અન્ય શબ્દોમાં, ચાલો કે અમે scanf જાણ કરો
હકીકતમાં શબ્દમાળા મેળવવા અપેક્ષા છે

18
00:00:47,760 --> 00:00:48,630
વપરાશકર્તા માંથી.

19
00:00:48,630 --> 00:00:50,810
>> પરંતુ હવે અમે scanf કહેવાની જરૂર
એક અન્ય વસ્તુ -

20
00:00:50,810 --> 00:00:53,350
શબ્દમાળા મૂકી છે કે
વપરાશકર્તા પૂરી પાડે છે.

21
00:00:53,350 --> 00:00:57,840
ઠીક છે, હું તદ્દન સરળ શરૂ જાઉં છું
અલ્પવિરામ એ, હું માંગો છો કે સ્પષ્ટ સાથે

22
00:00:57,840 --> 00:00:59,320
scanf ત્યાં શબ્દમાળા મૂકો.

23
00:00:59,320 --> 00:01:04,818
હું આગામી કંઈક છાપે જાઉં છું
આ% s માટે printf "આભાર જેવા

24
00:01:04,818 --> 00:01:10,670
બેકસ્લેશ n એ અલ્પવિરામ. "અને હંમેશની જેમ, હું છું
તે સ્ટ્રિંગ એ પાસ જઈ રહી છે.

25
00:01:10,670 --> 00:01:14,920
હવે, સંગ્રહ કરો કમ્પાઇલ, અને આ સ્કોર
અમે પ્રેરિત કરી શકો છો કાર્યક્રમ, અને જુઓ

26
00:01:14,920 --> 00:01:16,590
સમસ્યા હું આગાહી કરી હતી.

27
00:01:16,590 --> 00:01:18,650
>> Scanf -1 કરો.

28
00:01:18,650 --> 00:01:20,960
./scanf-1.

29
00:01:20,960 --> 00:01:21,830
શબ્દમાળા કરો.

30
00:01:21,830 --> 00:01:25,540
માતાનો, કંઈક આપવા દો "હેલો."
"નલ માટે આભાર." હમ્મ, તે નથી

31
00:01:25,540 --> 00:01:26,750
હું શું અપેક્ષા હતી.

32
00:01:26,750 --> 00:01:28,240
તેથી શું અહીં ચાલી રહ્યું છે?

33
00:01:28,240 --> 00:01:32,040
>> અમે જાહેર છે, કારણ કે ઠીક છે, તે તારણ
ઓ ચાર રચે સ્ટાર પરંતુ અમે કર્યું

34
00:01:32,040 --> 00:01:36,120
ખરેખર એક ની સરનામા s માં સંગ્રહિત
મેમરી વાસ્તવિક ભાગ, scanf ન હતી

35
00:01:36,120 --> 00:01:38,940
શબ્દમાળા મૂકી ગમે ત્યાં હોય
કે વપરાશકર્તા સાઇન ટાઇપ

36
00:01:38,940 --> 00:01:42,510
ખરેખર, વપરાશકર્તા તો હવે લખો
"હેલો" કરતાં ખૂબ લાંબા સમય સુધી શબ્દમાળા

37
00:01:42,510 --> 00:01:46,780
દાખલા તરીકે કેટલાક લખાણ લીટીઓ અથવા
લખાણ કેટલાક ફકરા, તે ખૂબ છે

38
00:01:46,780 --> 00:01:50,280
અમે પ્રેરિત શકે એ શક્ય એક
સેગ્મેન્ટેશન ક્ષતિમાં કહેવાતા.

39
00:01:50,280 --> 00:01:53,570
>> Scanf ખબર નથી જઈ રહ્યા છે કારણ કે
હું ખરેખર એક સરનામું મૂકી છે

40
00:01:53,570 --> 00:01:54,610
એ ની અંદર.

41
00:01:54,610 --> 00:01:58,000
તેના બદલે, તે અમુક મૂલ્ય જોવા માટે ચાલી રહ્યું છે
એ માં, કેટલાક પેટર્ન બીટ્સ કે કરી શકે છે

42
00:01:58,000 --> 00:02:00,910
ખૂબ જ સારી રીતે એક કચરો કિંમત હોઈ શકે છે,
ત્યાં માત્ર તક દ્વારા.

43
00:02:00,910 --> 00:02:04,600
અને હજુ પણ છે scanf લખવા પ્રયત્ન રહ્યું છે
તે સરનામા માટે વપરાશકર્તા શબ્દમાળા,

44
00:02:04,600 --> 00:02:08,789
તે કચરો કિંમત, હોય તો પણ જે
ખરેખર ભંગાણ પ્રેરિત કરી શકે છે.

45
00:02:08,789 --> 00:02:10,130
>> કેવી રીતે અમે આ ઠીક જવું છે?

46
00:02:10,130 --> 00:02:12,523