1
00:00:00,000 --> 00:00:02,480
>> [સંગીત વગાડવાનો]

2
00:00:02,480 --> 00:00:06,460

3
00:00:06,460 --> 00:00:09,350
>> ડો LLOYD: બધા હક છે, તેથી દો
આદેશ વાક્ય દલીલો વિશે વાત કરો.

4
00:00:09,350 --> 00:00:11,800
તેથી, અત્યાર સુધી આ કોર્સ ખૂબ
તમારા કાર્યક્રમો ખૂબ બધા

5
00:00:11,800 --> 00:00:16,360
કદાચ શરૂ કર્યું છે
છે આ પૂર્ણાંક મુખ્ય રદબાતલ જેવા હોય છે.

6
00:00:16,360 --> 00:00:18,310
અમે એકત્ર કરવામાં આવ્યા છે
વપરાશકર્તા ઈનપુટ જો અમે તેને જરૂર

7
00:00:18,310 --> 00:00:21,080
જેમ કે અમારા કાર્યક્રમો માં
મારિયો કાર્યક્રમ, ઉદાહરણ તરીકે,

8
00:00:21,080 --> 00:00:22,990
માં કાર્યક્રમ પૂછે છે.

9
00:00:22,990 --> 00:00:25,190
અમે સુધારવા માટે જરૂરી નથી
મુખ્ય ઘોષણા,

10
00:00:25,190 --> 00:00:30,684
કારણ કે તેના બદલે મુખ્ય અમે અંદર
માત્ર તમે પૂર્ણાંક વિચાર તે કહી શકે છે, કહે છે.

11
00:00:30,684 --> 00:00:32,350
કેવી રીતે મોટા તમે પિરામિડ પ્રયત્ન કરવા માંગો છો?

12
00:00:32,350 --> 00:00:34,455
અથવા તમે વિચાર તે કહી શકે છે
કેટલી ફેરફાર float--

13
00:00:34,455 --> 00:00:36,400
આ વપરાશકર્તા માટે હું આઉટપુટ જોઈએ?

14
00:00:36,400 --> 00:00:38,630
>> બીજી રીતે, છતાં છે
અને અમે અમારા વપરાશકર્તાઓને માંગો છો

15
00:00:38,630 --> 00:00:40,580
પૂરી પાડવા માટે સક્ષમ હોઈ
અમારા કાર્યક્રમ માહિતી

16
00:00:40,580 --> 00:00:43,320
તેના બદલે જ્યારે રનટાઈમે
આ કાર્યક્રમ ચાલી રહ્યો છે

17
00:00:43,320 --> 00:00:45,910
એક ગૂઢ ભેદ પરંતુ
ક્યારેક ખૂબ જ ઉપયોગી છે,

18
00:00:45,910 --> 00:00:48,120
અમે મુખ્ય જાહેર એક નવું સ્વરૂપ જરૂર છે.

19
00:00:48,120 --> 00:00:53,320
અમે કરવા માંગો છો, તો પૂર્ણાંક મુખ્ય રદબાતલ ઉપયોગ કરી શકતા નથી
આદેશ વાક્ય પર અન્ય માહિતી એકત્રિત

20
00:00:53,320 --> 00:00:57,540
વપરાશકર્તા કાર્યક્રમ ચાલે છે ત્યારે,
તેથી આદેશ વાક્ય દલીલો.

21
00:00:57,540 --> 00:00:59,810
>> આ આદેશ વાક્ય એકત્રિત કરવા માટે
વપરાશકર્તા માંથી દલીલો,

22
00:00:59,810 --> 00:01:03,140
તમારા ઘોષણા બદલી
છે આ પૂર્ણાંક જેમ દેખાય છે માટે મુખ્ય

23
00:01:03,140 --> 00:01:10,450
મુખ્ય, ઓપન કૌંસ, પૂર્ણાંક argc, અલ્પવિરામ,
શબ્દમાળા argv, ચોરસ કૌંસ,

24
00:01:10,450 --> 00:01:12,670
અને પછી સર્પાકાર તાણવું ખોલો.

25
00:01:12,670 --> 00:01:14,415
તેથી તે પહેલાથી જ શું અર્થ છે?

26
00:01:14,415 --> 00:01:19,410
વેલ, અમે બે પરિમાણો પસાર કરવામાં આવે છે,
મુખ્ય અથવા દલીલો, અથવા ઇનપુટ્સ.

27
00:01:19,410 --> 00:01:23,800
એક પૂર્ણાંક કહેવાય
argc, અને અન્ય શું છે?

28
00:01:23,800 --> 00:01:26,430

29
00:01:26,430 --> 00:01:29,640
તે હક, શબ્દમાળાઓ ઝાકઝમાળ છે?

30
00:01:29,640 --> 00:01:31,140
અમે તે ચોરસ કૌંસ નોટેશનમાં જુઓ.

31
00:01:31,140 --> 00:01:32,181
તે શબ્દમાળાઓ ઝાકઝમાળ છે.

32
00:01:32,181 --> 00:01:35,110
તે વ્યક્તિગત શબ્દમાળા નથી,
તે શબ્દમાળાઓ ઝાકઝમાળ છે.

33
00:01:35,110 --> 00:01:39,640
અને આ બે દલીલો, argc અને argv,
શું માહિતી વપરાશકર્તા ખબર કરવા માટે સક્રિય

34
00:01:39,640 --> 00:01:42,912
આદેશ વાક્ય પર પૂરી પાડવામાં આવી છે
અને કેવી રીતે ઘણી વસ્તુઓ તેઓ

35
00:01:42,912 --> 00:01:44,120
આદેશ વાક્ય પર પૂરી પાડવામાં આવેલ.

36
00:01:44,120 --> 00:01:46,570
સાથે કામ કરવા માટે ખૂબ ઉપયોગી વસ્તુઓ.

37
00:01:46,570 --> 00:01:50,310
>> Argc, દલીલ ગણતરી માટે વપરાય છે
અને તમે જે રીતે દ્વારા, ખબર હોવી જોઇએ,

38
00:01:50,310 --> 00:01:52,600
તમે argc કૉલ કરી શકે છે કે
તમે તેને કરવા માંગો છો ગમે.

39
00:01:52,600 --> 00:01:54,710
તમે ઇચ્છતા ગમે argv કૉલ કરી શકો છો.

40
00:01:54,710 --> 00:01:58,740
આ માત્ર પરંપરાગત નામો છે
અમે them-- દલીલ ગણતરી માટે ઉપયોગ કરે છે,

41
00:01:58,740 --> 00:02:00,907
અને અમે એક બીજા જોશો,
દલીલ વેક્ટર, argv.

42
00:02:00,907 --> 00:02:03,698
પરંતુ તમે તેમને કૉલ કરવા માટે નથી
તમે કરવા માંગો છો નથી, તો argc અને argv,

43
00:02:03,698 --> 00:02:05,570
પરંતુ પરંપરાગત, કે અમે શું છે.

44
00:02:05,570 --> 00:02:07,500
>> તેથી કોઈપણ રીતે, argc, દલીલ ગણક.

45
00:02:07,500 --> 00:02:11,569
તે પૂર્ણાંક પ્રકાર ચલ છે અને તેથી,
અમે બે વસ્તુઓ હોય છે, જો તમે અપેક્ષા રાખી શકો છો

46
00:02:11,569 --> 00:02:13,860
અમે શોધવા કરી રહ્યા છીએ કે
આ ટાઇપ કરી રહ્યા છે તે બહાર

47
00:02:13,860 --> 00:02:16,070
અને કેટલી સામગ્રી
વપરાશકર્તા ટાઇપ, argc છે

48
00:02:16,070 --> 00:02:18,559
કેટલી અમને કહી જતા
ટાઇપ વપરાશકર્તા સામગ્રી.

49
00:02:18,559 --> 00:02:20,850
તે તમને એક નંબર આપે છે તેથી
આદેશ વાક્ય દલીલો વપરાશકર્તા

50
00:02:20,850 --> 00:02:22,470
કાર્યક્રમ ચલાવવામાં આવી હતી જ્યારે લખ્યો.

51
00:02:22,470 --> 00:02:25,780
તમારા કાર્યક્રમ છે તેથી જો
કોઈ લોભી સ્લેશ ચલાવો,

52
00:02:25,780 --> 00:02:28,670
અને તમારા લોભી અંદર
તમારી મુખ્ય કાર્ય કાર્યક્રમ

53
00:02:28,670 --> 00:02:34,800
જાહેરાત પૂર્ણાંક મુખ્ય પૂર્ણાંક argc છે,
શબ્દમાળા પછી, ચોરસ કૌંસ argv

54
00:02:34,800 --> 00:02:37,950
તે કિસ્સામાં argc છે.

55
00:02:37,950 --> 00:02:40,200
હવે અમે નથી નોટિસ
કેવી રીતે ઘણી વસ્તુઓ ગણતરી

56
00:02:40,200 --> 00:02:42,590
વપરાશકર્તા કાર્યક્રમ નામ પછી લખ્યો.

57
00:02:42,590 --> 00:02:46,710
કાર્યક્રમ નામ પોતે ગણે
આદેશ વાક્ય દલીલ તરીકે.

58
00:02:46,710 --> 00:02:51,770
>> તેથી, લોભી સ્લેશ
તે કિસ્સામાં, argc છે.

59
00:02:51,770 --> 00:02:57,910
વપરાશકર્તા સ્લેશ લોભી 1024 CS50 ટાઇપ તો
તે કિસ્સામાં argc આદેશ-વાક્ય ખાતે

60
00:02:57,910 --> 00:02:59,520
ત્રણ હશે.

61
00:02:59,520 --> 00:03:03,720
અને અમે જે રીતે, કારણ કે આ ખબર
કે શબ્દમાળાઓ વચ્ચે વિભાજન

62
00:03:03,720 --> 00:03:06,030
કે શું છે શોધાયેલ છે
એક જગ્યા, અથવા એક ટેબ છે,

63
00:03:06,030 --> 00:03:08,230
અથવા તેમની વચ્ચે કંઈક હોય છે.

64
00:03:08,230 --> 00:03:13,860
જેથી સફેદ જગ્યા કોઇપણ રકમ, કહેવાતા,
કિંમતો વચ્ચે આદેશ-વાક્ય ટાઇપ

65
00:03:13,860 --> 00:03:15,720
કેટલા સૂચવે છે.

66
00:03:15,720 --> 00:03:24,040
તેથી લોભી જગ્યા 1024 જગ્યા સ્લેશ
CS50, argc, કે જે કિસ્સામાં, ત્રણ છે.

67
00:03:24,040 --> 00:03:26,600
>> Argv દલીલ વેક્ટર છે.

68
00:03:26,600 --> 00:03:29,240
વેક્ટર, જે રીતે દ્વારા, માત્ર છે
એક એરે માટે અન્ય શબ્દ,

69
00:03:29,240 --> 00:03:31,510
અને આ એક એરે છે
કે શબ્દમાળાઓ સંગ્રહ કરે છે.

70
00:03:31,510 --> 00:03:35,540
છે, કે જે તત્વ દીઠ એક શબ્દમાળા,
શબ્દમાળાઓ કે જે વપરાશકર્તા ખરેખર

71
00:03:35,540 --> 00:03:39,230
આદેશ વાક્ય પર લખ્યો
કાર્યક્રમ ચલાવવામાં આવી હતી.

72
00:03:39,230 --> 00:03:40,990
હવે, તરીકે કેસ છે
કોઈપણ એરે સાથે, તમે તો

73
00:03:40,990 --> 00:03:44,380
અમારી ચર્ચા યાદ
એરે, argv પ્રથમ તત્વ

74
00:03:44,380 --> 00:03:49,150
હંમેશા જોવા મળે કરી રહ્યું છે
argv ચોરસ કૌંસ શૂન્ય છે.

75
00:03:49,150 --> 00:03:51,800
તે પ્રથમ ઇન્ડેક્સ છે
આ argv એરે છે.

76
00:03:51,800 --> 00:03:55,720
કે જેથી will-- અને હકીકતમાં, કે ચાલશે
હંમેશા કાર્યક્રમના નામ હોઈ શકે છે,

77
00:03:55,720 --> 00:03:59,730
હંમેશા પર સ્થિત આવશે
argv ચોરસ કૌંસ શૂન્ય.

78
00:03:59,730 --> 00:04:08,590
>> Argv ના છેલ્લા તત્વ હંમેશા જોવા મળે છે
argv ચોરસ કૌંસ argc ઓછા એક છે.

79
00:04:08,590 --> 00:04:10,300
તમે શા માટે જુઓ છો?

80
00:04:10,300 --> 00:04:14,180
કેટલા તત્વો યાદ રાખો
આ એરે અસ્તિત્વ ધરાવે છે.

81
00:04:14,180 --> 00:04:16,660
વેલ, અમે તે that-- ખબર
તત્વો argc સંખ્યા.

82
00:04:16,660 --> 00:04:21,279
વપરાશકર્તા અંતે ત્રણ વસ્તુઓ લખ્યો તો
આદેશ વાક્ય, argc ત્રણ છે.

83
00:04:21,279 --> 00:04:27,070
પરંતુ કારણ કે સી, ત્યારે અમે કામ કરી રહ્યા છીએ
એરે સાથે, એરે દરેક તત્વ,

84
00:04:27,070 --> 00:04:30,190
અથવા બદલે સૂચકાંક
એરે શૂન્ય શરુ થાય છે.

85
00:04:30,190 --> 00:04:34,000
અમે ત્રણ ઘટકો હોય તો અમારા
અરે, અમે argv શૂન્ય પર એક તત્વ છે

86
00:04:34,000 --> 00:04:37,930
argv એક એક તત્વ,
argv બે અને એક તત્વ.

87
00:04:37,930 --> 00:04:41,700
Argv કોઈ તત્વ છે
ત્રણ, અને કદ ત્રણ ઝાકઝમાળ.

88
00:04:41,700 --> 00:04:43,990
તેથી કે શા માટે છેલ્લા છે
argv તત્વ હંમેશા કરી શકો છો

89
00:04:43,990 --> 00:04:49,510
argv સ્ક્વેર ખાતે શોધી શકાય
કૌંસ argc ઓછા છે.

90
00:04:49,510 --> 00:04:52,420
>> તેથી આ વપરાશકર્તા ચલાવે ધારે દો
નીચે પ્રમાણે લોભી કાર્યક્રમ

91
00:04:52,420 --> 00:04:57,970
તેઓ આદેશ-વાક્ય ટપકું લખો તો
લોભી જગ્યા 1024 જગ્યા CS50 સ્લેશ

92
00:04:57,970 --> 00:05:00,720
અને કારણ ગમે તે માટે અમે કર્યું
પહેલેથી જ અમારી લોભી કાર્યક્રમ તૈયાર

93
00:05:00,720 --> 00:05:04,050
ખબર છે અને આ સાથે કામ કરવા માટે
આદેશ વાક્ય દલીલો.

94
00:05:04,050 --> 00:05:07,030
અમે કામ કર્યું ત્યારે અમે અગાઉ ન હતી
લોભી સમસ્યા માટે તે પર,

95
00:05:07,030 --> 00:05:09,660
પરંતુ અમે હવે ફેરફાર કર્યું છે કહે દો
તે છે કે જેથી અમે પ્રક્રિયા

96
00:05:09,660 --> 00:05:11,480
અમુક રીતે આદેશ વાક્ય દલીલો.

97
00:05:11,480 --> 00:05:15,720
આ કિસ્સામાં, શૂન્ય argv
કોઈ સ્લેશ લોભી છે.

98
00:05:15,720 --> 00:05:17,042
Argv એક શું છે?

99
00:05:17,042 --> 00:05:19,030
વેલ, તે યોગ્ય, 1024 છે?

100
00:05:19,030 --> 00:05:22,620
તે 1024 છે, પરંતુ અહીં એક છે
ખરેખર મહત્વનું distinction--

101
00:05:22,620 --> 00:05:26,410
તમે argv માહિતી પ્રકાર યાદ છે?

102
00:05:26,410 --> 00:05:31,020
>> તે હક, શબ્દમાળાઓ સંગ્રહ?

103
00:05:31,020 --> 00:05:34,140
પરંતુ તે 1024 જેવો દેખાય છે
પૂર્ણાંક કિંમત છે.

104
00:05:34,140 --> 00:05:36,530
આ એક ખરેખર મહત્વનું છે
ભેદ, અને ખરેખર છે

105
00:05:36,530 --> 00:05:40,200
કંઈક બની રહ્યું છે કે જે તમને
પાછળથી સમસ્યાઓ અનુભવી શકે છે.

106
00:05:40,200 --> 00:05:43,770
Argv બધું છે
શબ્દમાળા તરીકે સંગ્રહ.

107
00:05:43,770 --> 00:05:48,775
તેથી argv એક સમાવિષ્ટો છે
શબ્દમાળા એક, શૂન્ય, બે, ચાર,

108
00:05:48,775 --> 00:05:50,275
તે ચાર અક્ષરો સમાવેશ થાય છે.

109
00:05:50,275 --> 00:05:53,870
તે વપરાશકર્તા ટાઇપ, જો તરીકે છે
એક, શૂન્ય, બે, ચાર

110
00:05:53,870 --> 00:05:56,680
વ્યક્તિગત અક્ષરો અથવા અક્ષરો તરીકે.

111
00:05:56,680 --> 00:06:00,730
તે પૂર્ણાંક 1024 નથી
અને તેથી તમે સીધા નથી કરી શકો છો

112
00:06:00,730 --> 00:06:11,580
પૂર્ણાંક 1,000 કહેતા તેની સાથે કામ, અથવા
તેના બદલે પૂર્ણાંક એક્સ argv એક ઓછા 24 સમકક્ષ હોય છે.

113
00:06:11,580 --> 00:06:15,550
>> તર્ક, કે જે તમને લાગે શકે છે
ઠીક છે, સાથે સાથે તે 1,024 ઓછા 24 છે, કારણ કે

114
00:06:15,550 --> 00:06:17,920
તેથી એક્સ 1000 સમાન છે.

115
00:06:17,920 --> 00:06:22,020
પરંતુ હકીકતમાં, કે કેસ નથી
argv એક સ્ટ્રિંગ છે, કારણ કે.

116
00:06:22,020 --> 00:06:23,940
શબ્દમાળા 1024.

117
00:06:23,940 --> 00:06:28,739
હવે શકો છો કે જે કાર્ય છે
પૂર્ણાંકો માટે શબ્દમાળાઓ કન્વર્ટ કરવા માટે વપરાય.

118
00:06:28,739 --> 00:06:30,780
હું તમારા માટે તેને બગાડી નહીં
હવે, પરંતુ હું Zamyla ખાતરી છે કે છું

119
00:06:30,780 --> 00:06:34,380
તે વિશે તમને કહી ખુશ હશે
ભવિષ્યના સમસ્યા માટે walkthrough.

120
00:06:34,380 --> 00:06:36,390
પરંતુ તમે પણ શોધી શકો છો
સમસ્યાઓ જેવા બહાનું

121
00:06:36,390 --> 00:06:39,921
મને, કાર્યો કે કરશે
સંદર્ભ 50 આવું,

122
00:06:39,921 --> 00:06:42,462
તમે સંદર્ભ માર્ગદર્શન પર જાઓ, તો
તમે એક કાર્ય શોધી શકો છો કે

123
00:06:42,462 --> 00:06:43,820
તમારા માટે આ રૂપાંતર કરશે.

124
00:06:43,820 --> 00:06:45,980
પરંતુ ફરીથી, આ walkthrough
ભવિષ્યના સમસ્યા માટે,

125
00:06:45,980 --> 00:06:48,290
Zamyla કરવા માટે ખુશ હશે
શું કાર્ય તમે કહો

126
00:06:48,290 --> 00:06:53,280
તે રૂપાંતર કરશે
પૂર્ણાંક 1024 માટે શબ્દમાળા 1024.

127
00:06:53,280 --> 00:06:54,560
>> બધા હક છે, તેથી પર ખસેડવાની.

128
00:06:54,560 --> 00:06:56,726
અમે અમારા argv શૂન્ય આવરી કર્યું
અમે એક argv આવરી લેવામાં આવ્યાં છે.

129
00:06:56,726 --> 00:06:58,000
શું argv બે છે?

130
00:06:58,000 --> 00:06:58,620
CS50.

131
00:06:58,620 --> 00:07:01,350
તે એક કદાચ છે
ખૂબ સ્વયંસ્પષ્ટ.

132
00:07:01,350 --> 00:07:02,950
શું argv ત્રણ છે?

133
00:07:02,950 --> 00:07:04,970
વેલ ફરી, અમે ખરેખર ખબર નથી, અધિકાર?

134
00:07:04,970 --> 00:07:08,060
અમે કદ ત્રણ ઝાકઝમાળ છે
કે કેટલા તત્વો વપરાશકર્તાની

135
00:07:08,060 --> 00:07:11,610
આદેશ વાક્ય પર લખ્યો,
તેથી અમે ત્રણ argv પર જાઓ, તો

136
00:07:11,610 --> 00:07:14,660
આપણે હવે વધુ પડતા પગલાં રહ્યા છો
અમારા એરે સીમાડાં.

137
00:07:14,660 --> 00:07:18,570
આ કમ્પાઈલર, અમને આ કરવા દો
કોઈ સાહજિક સમસ્યા તેની સાથે છે,

138
00:07:18,570 --> 00:07:22,890
પરંતુ વાસ્તવમાં શરતો શું ચાલી રહ્યું છે
થાય છે, અમે ખરેખર ખબર નથી.

139
00:07:22,890 --> 00:07:25,380
તે શું છે પર આધાર રાખે છે
મેમરી જ્યાં સ્થિત

140
00:07:25,380 --> 00:07:28,060
argv ત્રણ તેવી અપેક્ષા કરવામાં આવશે.

141
00:07:28,060 --> 00:07:30,716
અને તેથી અમે અંત કરી શકે છે
દૂર સ્કોટ મફત મેળવવામાં.

142
00:07:30,716 --> 00:07:33,840
શક્યતા વધુ કરતાં નથી, ખાસ કરીને જ્યારે
વિરોધ તરીકે તમે argv સાથે કામ કરી રહ્યા છીએ

143
00:07:33,840 --> 00:07:35,548
અન્ય કોઇ એરે માટે
કે અમારા કાર્યક્રમ છે

144
00:07:35,548 --> 00:07:38,660
અમે કદાચ સહન કરવા જઈ રહ્યાં છો
સેગ્મેન્ટેશન ક્ષતિમાં. તેથી ફરી,

145
00:07:38,660 --> 00:07:42,756
ભૂસકે overstep ખાતરી કરી
તમારા એરે, ખાસ કરીને argv,

146
00:07:42,756 --> 00:07:47,170
તેની ઊંચી ડિગ્રી આપવામાં
તમારા કાર્યક્રમો માં મહત્વ.

147
00:07:47,170 --> 00:07:48,100
>> હું ડો લોયડ છું.

148
00:07:48,100 --> 00:07:50,170
આ CS50 છે.

149
00:07:50,170 --> 00:07:51,457