1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [સંગીત વગાડવાનો]

3
00:00:11,210 --> 00:00:12,100
>> રોબ Boden: અધિકાર છે.

4
00:00:12,100 --> 00:00:15,620
ટ્યુબ પ્રથમ તેથી, પ્રથમ વસ્તુ,
એક પરિચિત ચહેરો છે.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [વિડિઓ પ્લેબેક]

7
00:00:22,560 --> 00:00:23,370
>> -અધિકાર છે.

8
00:00:23,370 --> 00:00:27,150
આ CS50 છે, અને આ છે
અઠવાડિયું ત્રણ શરૂઆત.

9
00:00:27,150 --> 00:00:29,980
હું તમારી સાથે હોઈ શકે છે દિલગીર છું
આજે, પણ જેણે મને દાખલ કરવા માટે પરવાનગી આપે

10
00:00:29,980 --> 00:00:32,880
CS50 પોતાના રોબ Boden માં.

11
00:00:32,880 --> 00:00:33,872
>> [સમાપ્ત વિડિઓ પ્લેબેક]

12
00:00:33,872 --> 00:00:39,340
>> [વધાવી અને ટીમે]

13
00:00:39,340 --> 00:00:41,277
>> રોબ Boden: માં ફિલ્મોગ્રાફી
તે વિડિઓ વિચિત્ર છે.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
અધિકાર છે.

16
00:00:47,770 --> 00:00:50,960
તેથી પ્રથમ, બીજા પાત્ર છે.

17
00:00:50,960 --> 00:00:52,330
તે 1:15 ખાતે આવતી કાલે છે.

18
00:00:52,330 --> 00:00:54,480
આ શુક્રવાર કોઈ પાત્ર છે.

19
00:00:54,480 --> 00:00:55,810
તે Quora સાથે છે.

20
00:00:55,810 --> 00:01:00,190
અને ટોમી એક પરંતુ, હજુ સુધી અહીં નથી
ભૂતપૂર્વ વડા સીએફ છે લોકો,

21
00:01:00,190 --> 00:01:01,530
ટોમી McWilliam.

22
00:01:01,530 --> 00:01:02,730
તેથી તેમણે એક મજા વ્યક્તિ છે.

23
00:01:02,730 --> 00:01:04,819
તમને આવે છે.

24
00:01:04,819 --> 00:01:05,900
>> અધિકાર છે.

25
00:01:05,900 --> 00:01:11,360
તેથી છેલ્લા અઠવાડિયે, અમે સિવાય તોડી શરૂ
એક શબ્દમાળા ખરેખર શું છે તે અંગે.

26
00:01:11,360 --> 00:01:14,830
અમે શરૂઆતમાં થી ઓળખાય છે કે
તે અક્ષરો ક્રમ છે.

27
00:01:14,830 --> 00:01:18,130
પરંતુ છેલ્લા અઠવાડિયે, અમે એ હકીકત ઉતર્યા
શું ખરેખર એક ક્રમ છે કે

28
00:01:18,130 --> 00:01:22,110
અક્ષરો, સાથે સાથે, અમે હવે છે
અક્ષરો એરે.

29
00:01:22,110 --> 00:01:26,450
અને અમે શબ્દમાળા, તે એક એરે છે ખબર છે કે
અક્ષરો, ખૂબ જ ઓવરને અંતે,

30
00:01:26,450 --> 00:01:30,920
અમે આ ખાસ નલ બાઇટ છે, આ
બેકસ્લેશ 0, કે અંતના સૂચવે

31
00:01:30,920 --> 00:01:32,230
શબ્દમાળા.

32
00:01:32,230 --> 00:01:36,970
>> અને તેથી શબ્દમાળા ઝાકઝમાળ છે
અક્ષરો, પરંતુ અમે કરી શકે છે કરતાં વધુ

33
00:01:36,970 --> 00:01:39,530
માત્ર અક્ષરો ઝાકઝમાળ,
અમે કોઈ પણ દર્શાવે છે હોઈ શકે છે

34
00:01:39,530 --> 00:01:40,890
અમે માંગો છો વસ્તુ પ્રકાર.

35
00:01:40,890 --> 00:01:51,570
તેથી, જો તમે છેલ્લા સપ્તાહના યાદ તો,
ડેવિડ રજૂ કરવામાં કે યુગ કાર્યક્રમ

36
00:01:51,570 --> 00:01:53,560
ખરેખર ઝડપથી.

37
00:01:53,560 --> 00:01:57,010
અમે કરી રહ્યા છીએ તેથી પ્રથમ વસ્તુ છે
, પૂર્ણાંક માટે વપરાશકર્તા પૂછવા પાંચ

38
00:01:57,010 --> 00:01:58,800
રૂમમાં લોકોની સંખ્યા.

39
00:01:58,800 --> 00:02:01,260
અમે તે પૂર્ણાંક છે એકવાર,
અમે એક એરે જાહેર કરી રહ્યાં છો.

40
00:02:01,260 --> 00:02:02,890
આ કૌંસ વાક્યરચના જુઓ.

41
00:02:02,890 --> 00:02:04,540
આપને કોઈ ઉપયોગ કરો રહ્યા છીએ.

42
00:02:04,540 --> 00:02:09,430
>> તેથી અમે પૂર્ણાંકો ઝાકઝમાળ જાહેર કરી રહ્યાં છો
ઉંમરના કહેવાય છે, અને ત્યાં n છે

43
00:02:09,430 --> 00:02:12,080
આ એરે પૂર્ણાંકો.

44
00:02:12,080 --> 00:02:16,480
અહીં તેથી આ પેટર્ન, આ 4 પૂર્ણાંક
હું વત્તા, હું કરતાં ઓછી n છે, 0 સમકક્ષ હોય છે

45
00:02:16,480 --> 00:02:20,580
પ્લસ, એ પણ એક પેટર્ન કરી રહ્યું છે
તમે ખૂબ જ ઉપયોગ કરો કે.

46
00:02:20,580 --> 00:02:24,000
કે ખૂબ ખૂબ તમે કેવી રીતે કારણ કે
હંમેશા એરે પર ફરી વળવું રહ્યા.

47
00:02:24,000 --> 00:02:26,330
તેથી n એ યાદ રાખો કે આ
અમારા એરે લંબાઈ.

48
00:02:26,330 --> 00:02:32,120
અને તેથી અહીં, અમે વારંવાર પૂછે છે કે
રૂમમાં વ્યક્તિ i ની ઉંમર.

49
00:02:32,120 --> 00:02:36,640
>> આ પછી, અમે નીચે જાય છે, અને ગમે માટે
મનસ્વી કારણ, અમે તો પછી

50
00:02:36,640 --> 00:02:40,220
તેઓ રહ્યા છીએ કેવી રીતે જૂના છાપે
હવે એક વર્ષ છે.

51
00:02:40,220 --> 00:02:49,980
અને તે કાર્યક્રમ ચાલી રહ્યો છે, ચાલો
, વય કરો સ્લેશ ઉંમરના DOT.

52
00:02:49,980 --> 00:02:53,010
તેથી રૂમમાં લોકો નંબર છે,
ત્રણ છે કહો.

53
00:02:53,010 --> 00:02:59,880
અને, પ્રથમ વ્યક્તિ 13 છે, કહે છે
આગામી 26 છે, અને છેલ્લા 30 છે.

54
00:02:59,880 --> 00:03:05,080
તેથી પછી તે તે ત્રણ ફરી વળવું પડશે
લોકો, 14 બહાર 27, અને 31 છાપો.

55
00:03:05,080 --> 00:03:16,060
>> તેથી યાદ રાખો કે આપણે એક જાહેર ત્યારે
માપ n ના એરે નથી, તે સૂચકાંકો

56
00:03:16,060 --> 00:03:19,950
અરે, એરે કિંમતો છે અને
સૂચકાંક 0, 1, 2, બધી રીતે

57
00:03:19,950 --> 00:03:21,680
અપ n એ માટે ઓછા 1.

58
00:03:21,680 --> 00:03:26,255
તેથી અમે કહ્યું ત્રણ લોકો હતા
રૂમમાં, અને અમે અહીં મૂકવામાં

59
00:03:26,255 --> 00:03:29,850
આ દ્વારા પ્રથમ પુનરાવૃત્તિ
લૂપ, હું 0 પ્રયત્ન રહ્યું છે.

60
00:03:29,850 --> 00:03:31,650
તેથી 0 અનુક્રમણિકા છે.

61
00:03:31,650 --> 00:03:34,540
અમે પ્રથમ સોંપણી છે
વપરાશકર્તા પ્રવેશ કરે ઉંમર.

62
00:03:34,540 --> 00:03:38,870
પછી આગામી એક, અમે દાખલ કરી રહ્યા છીએ એ
બીજા n એ વપરાશકર્તા પ્રવેશ કરે, અને માં

63
00:03:38,870 --> 00:03:40,580
બે, છેલ્લા ન આગામી.

64
00:03:40,580 --> 00:03:44,200
>> તેથી નોંધ્યું છે કે કદ ઝાકઝમાળ
ત્રણ કંઈપણ નથી

65
00:03:44,200 --> 00:03:46,040
ઇન્ડેક્સ ત્રણ.

66
00:03:46,040 --> 00:03:49,036
આ યોગ્ય નથી રહ્યો.

67
00:03:49,036 --> 00:03:50,250
અધિકાર છે.

68
00:03:50,250 --> 00:03:55,136
તેથી, અહીં પાછા જવાનું.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
તેથી હવે અમે એરે સાથે કામ કર્યું છે,
અમે કેટલાક પારિવારિકતા છે.

71
00:04:01,590 --> 00:04:03,780
હવે અમે આદેશ પર ખસેડો રહ્યા છીએ
હશે આવે છે જે વાક્ય દલીલો,

72
00:04:03,780 --> 00:04:05,890
આ સમસ્યા સેટ ખૂબ સંબંધિત.

73
00:04:05,890 --> 00:04:09,670
>> તેથી હવે ત્યાં સુધી, જ્યારે તમે કરેલા
તમારા મુખ્ય કાર્ય જાહેર, અમે કર્યું

74
00:04:09,670 --> 00:04:11,230
પૂર્ણાંક મુખ્ય રદબાતલ જણાવ્યું હતું.

75
00:04:11,230 --> 00:04:14,070
તેથી રદબાતલ ફક્ત અર્થ એ થાય કે
અમે કોઈ પસાર નથી

76
00:04:14,070 --> 00:04:16,440
આ કાર્ય માટે દલીલો.

77
00:04:16,440 --> 00:04:19,190
હવે અમે તે મુખ્ય જોવા જઈ રહ્યાં છો
કેટલીક દલીલો કરી શકો છો.

78
00:04:19,190 --> 00:04:22,470
અહીં અમે argc પૂર્ણાંક તેમને કૉલ
અને શબ્દમાળા argv કૌંસ.

79
00:04:22,470 --> 00:04:26,930
આ કૌંસ, ફરી એક વાર, સૂચવે છે
અમે એરે સાથે કામ કરીએ છીએ કે.

80
00:04:26,930 --> 00:04:31,850
અહીં, શબ્દમાળા argv કૌંસ, અમે છો
શબ્દમાળાઓ ઝાકઝમાળ સાથે કામ કરીએ.

81
00:04:31,850 --> 00:04:35,360
તેથી argc, કે જે સૂચવે બનશે
અમે કર્યું છે કે કેવી રીતે બધી દલીલો

82
00:04:35,360 --> 00:04:37,580
આ કાર્યક્રમને પસાર.

83
00:04:37,580 --> 00:04:46,050
અને, તે શું છે તે જોવા માટે
ચાલો આ બંધ કરીએ.

84
00:04:46,050 --> 00:04:46,490
>> બરાબર.

85
00:04:46,490 --> 00:04:50,790
તેથી હવે ત્યાં સુધી, આપણે દરેક સ્કોર કર્યો
કોઈ સ્લેશ ઉંમરના જેવા કાર્યક્રમ.

86
00:04:50,790 --> 00:04:55,250
અમે પણ કરી શકો છો, તો આદેશ વાક્ય પર, છેલ્લા
દલીલો પસાર કરવા માટે, આમ શબ્દ, આદેશ

87
00:04:55,250 --> 00:04:56,550
વાક્ય દલીલો.

88
00:04:56,550 --> 00:04:59,760
જેથી પ્રથમ દલીલ, હેલો વર્લ્ડ.

89
00:04:59,760 --> 00:05:03,350
અહીં, argc ત્રણ છે.

90
00:05:03,350 --> 00:05:07,720
તે દલીલો ગણના છે
આદેશ વાક્ય પર.

91
00:05:07,720 --> 00:05:12,840
Argc, હંમેશા ઓછામાં ઓછા 1 છે કારણ ડોટ
પોતે ઉંમરના સ્લેશ, એક તરીકે ગણે છે

92
00:05:12,840 --> 00:05:14,490
આદેશ વાક્ય દલીલો.

93
00:05:14,490 --> 00:05:17,010
>> પછી હેલો પ્રથમ છે.

94
00:05:17,010 --> 00:05:20,460
કોઈ સ્લેશ ઉંમરના પછી, આ zeroth છે
હેલો પ્રથમ છે, અને વિશ્વ છે

95
00:05:20,460 --> 00:05:22,830
બીજા આદેશ વાક્ય દલીલ.

96
00:05:22,830 --> 00:05:29,490
તેથી શબ્દમાળા argv, અમે જોવા માટે જઈ રહ્યાં છો,
શબ્દમાળાઓ, કોઈ સ્લેશ સમાવે

97
00:05:29,490 --> 00:05:33,830
ઉંમરના, હેલો, અને વિશ્વ.

98
00:05:33,830 --> 00:05:38,945
અને, ડેવિડ વિનંતી કરીને આપણે રહ્યા છીએ
કે રજૂઆત વિડિઓ રમવા માટે.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [વિડિઓ પ્લેબેક]

101
00:05:43,890 --> 00:05:46,240
>> અપ અમે કર્યું કાર્યક્ર હમણાં સુધી
લેખિત, અમે જાહેર કર્યું

102
00:05:46,240 --> 00:05:48,500
મુખ્ય તરીકે પૂર્ણાંક મુખ્ય રદબાતલ.

103
00:05:48,500 --> 00:05:51,170
અને આ બધા સમય, કે રદબાતલ છે
ફક્ત સ્પષ્ટ કરવામાં આવી છે કે જે

104
00:05:51,170 --> 00:05:54,430
કાર્યક્રમ કોઈપણ નથી
આદેશ વાક્ય દલીલો.

105
00:05:54,430 --> 00:05:57,750
જ્યારે વપરાશકર્તા ચાલે, તો બીજા શબ્દોમાં,
કાર્યક્રમ, તે અથવા તેણી આદેશ આપી શકે છે

106
00:05:57,750 --> 00:06:01,710
વધારાના લખીને વાક્ય દલીલો
શબ્દો અથવા શબ્દસમૂહની પછી આ કાર્યક્રમ

107
00:06:01,710 --> 00:06:03,000
પ્રોમ્પ્ટ પર નામ.

108
00:06:03,000 --> 00:06:06,550
>> સારું, તમે તમારા કાર્યક્રમ કરવા માંગો છો જો તમે કરો
આદેશ વાક્ય દલીલો, માત્ર એક અથવા લો

109
00:06:06,550 --> 00:06:10,540
વધુ જેમ કે શબ્દો, અમે બદલવાની જરૂર
દલીલો એક દંપતી સાથે ગેરમાન્ય.

110
00:06:10,540 --> 00:06:12,200
તેથી આપણે તે કરીએ.

111
00:06:12,200 --> 00:06:15,750
Cs50.h. સમાવેશ કરો

112
00:06:15,750 --> 00:06:19,360
ધોરણ io.h. સમાવેશ કરો

113
00:06:19,360 --> 00:06:20,760
મુખ્ય ઈન્.

114
00:06:20,760 --> 00:06:26,330
અને હવે, તેના બદલે રદબાતલ ના, હું જાઉં છું
એક argc કહેવાય પૂર્ણાંક, અને સ્પષ્ટ

115
00:06:26,330 --> 00:06:28,780
argv કહે શબ્દમાળાઓ પણ દર્શાવે છે.

116
00:06:28,780 --> 00:06:31,820
હવે, argc અને argv છે
ફક્ત સંમેલનો.

117
00:06:31,820 --> 00:06:34,000
>> અમે આ દલીલો કહે છે શકે છે
અમે માંગો છો સૌથી વધુ કાંઇ.

118
00:06:34,000 --> 00:06:37,630
પરંતુ મહત્વનું છે argc છે
પૂર્ણાંક વ્યાખ્યા દ્વારા, તે છે, કારણ કે

119
00:06:37,630 --> 00:06:41,360
આ દલીલ ગણતરી સમાવી રહ્યું છે,
કુલ શબ્દો નંબર કે

120
00:06:41,360 --> 00:06:43,380
વપરાશકર્તા તેના અથવા તેણીના પ્રોમ્પ્ટ પર લખ્યો છે.

121
00:06:43,380 --> 00:06:47,910
argv દરમિયાન, દલીલ વેક્ટર છે,
ખરેખર સ્ટોર ઝાકઝમાળ જ હશે

122
00:06:47,910 --> 00:06:52,020
વપરાશકર્તા છે કે બધા જ શબ્દો
તેના અથવા તેણીના પ્રોમ્પ્ટ પર લખ્યો.

123
00:06:52,020 --> 00:06:54,500
>> હવે કંઈક કરવા આગળ વધવા દો
આ એક અથવા વધુ સાથે

124
00:06:54,500 --> 00:06:55,660
આદેશ વાક્ય દલીલો.

125
00:06:55,660 --> 00:07:00,070
ખાસ કરીને, આપણે આગળ અને પ્રિન્ટ જાઓ
શબ્દ ગમે વપરાશકર્તા પ્રકારો

126
00:07:00,070 --> 00:07:03,960
આ કાર્યક્રમના નામ પછી
પ્રોમ્પ્ટ પર.

127
00:07:03,960 --> 00:07:04,730
ઓપન કૌંસ.

128
00:07:04,730 --> 00:07:06,240
બંધ કૌંસ.

129
00:07:06,240 --> 00:07:10,510
Printf ટકા એ બેકસ્લેશ અને અલ્પવિરામ.

130
00:07:10,510 --> 00:07:14,550
અને હવે હું printf શું કિંમત જણાવવાની રહેશે
કે પ્લેસહોલ્ડર માં પ્લગ.

131
00:07:14,550 --> 00:07:18,600
હું વપરાશકર્તા છે કે પ્રથમ શબ્દ માંગો છો
આ કાર્યક્રમના નામ પછી લખ્યો,

132
00:07:18,600 --> 00:07:23,130
અને તેથી હું સ્પષ્ટ કરવા માટે જઈ રહ્યો છું
argv કૌંસ 1, બંધ કરો

133
00:07:23,130 --> 00:07:24,830
કે વાક્ય, અર્ધવિરામ.

134
00:07:24,830 --> 00:07:27,290
>> હવે, શા માટે કૌંસ 1 અને ન કૌંસ 0?

135
00:07:27,290 --> 00:07:30,990
વેલ, તે આપમેળે સંગ્રહિત તારણ
argv 0 પ્રયત્ન રહ્યું છે આ

136
00:07:30,990 --> 00:07:32,620
કાર્યક્રમ વાસ્તવિક નામ.

137
00:07:32,620 --> 00:07:36,180
જેથી પ્રથમ શબ્દ કે વપરાશકર્તા પ્રકારો
આ કાર્યક્રમના નામ દ્વારા, પછી

138
00:07:36,180 --> 00:07:38,990
સંમેલન, જ હશે
argv 1 માં સંગ્રહ થાય છે.

139
00:07:38,990 --> 00:07:42,380
હવે સંકલન કરીએ અને
આ કાર્યક્રમ ચલાવો.

140
00:07:42,380 --> 00:07:47,780
>> Argv 0, કોઈ સ્લેશ argv 0 બનાવો.

141
00:07:47,780 --> 00:07:50,520
અને હવે તે એક શબ્દ હેલો જેમ.

142
00:07:50,520 --> 00:07:51,670
દાખલ કરો.

143
00:07:51,670 --> 00:07:53,520
અને આ રહ્યું હેલો, તે છે.

144
00:07:53,520 --> 00:07:55,750
>> [સમાપ્ત વિડિઓ પ્લેબેક]

145
00:07:55,750 --> 00:07:57,000
>> રોબ Boden: અધિકાર છે.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
કે બંધ કરો.

148
00:08:01,230 --> 00:08:16,730
જેથી કાર્યક્રમ આગળ લઈ કે
અમે માત્ર, પણ અમારા માટે પરિચય

149
00:08:16,730 --> 00:08:24,710
અમે 0 પ્રિન્ટ argv હવે, જો કરો, બતાવવા માટે
તે argv 0, કોઈ સ્લેશ argv 0 છે.

150
00:08:24,710 --> 00:08:30,440
અપેક્ષા તેથી, તે પ્રિન્ટ કરે છે
argv 0 છે, કારણ કે કાર્યક્રમ નામ

151
00:08:30,440 --> 00:08:32,970
હંમેશા જ હશે એ
કાર્યક્રમ નામ.

152
00:08:32,970 --> 00:08:35,640
પરંતુ કંઈક કરવા દો
વધુ રસપ્રદ બીટ.

153
00:08:35,640 --> 00:08:42,080
>> જેથી સમસ્યા સમૂહ, તમે હશો
આ કાર્ય, atoi માટે રજૂઆત કરી હતી.

154
00:08:42,080 --> 00:08:44,440
તેથી શું અમે માટે atoi ઉપયોગ કરી શકું?

155
00:08:44,440 --> 00:08:48,550
કે રૂપાંતરિત બનશે એક
પૂર્ણાંક માટે શબ્દમાળા.

156
00:08:48,550 --> 00:08:53,280
તેથી હું શબ્દમાળા પસાર છે, એક બે ત્રણ,
atoi માટે, કે રૂપાંતરિત પડશે

157
00:08:53,280 --> 00:08:56,910
પૂર્ણાંક માટે, એક બે ત્રણ.

158
00:08:56,910 --> 00:09:01,480
તેથી અમે પ્રથમ કન્વર્ટ રહ્યા છીએ
પૂર્ણાંક માટે આદેશ વાક્ય દલીલ,

159
00:09:01,480 --> 00:09:05,690
અને પછી માત્ર કે પૂર્ણાંક છાપો.

160
00:09:05,690 --> 00:09:09,680
>> તેથી સામાન્ય રીતે, અમે પ્રકારની છો
માત્ર, GetInt reimplementing

161
00:09:09,680 --> 00:09:12,350
પૂર્ણાંક આદેશ પર દાખલ થાય છે
વાક્ય બદલે કાર્યક્રમ

162
00:09:12,350 --> 00:09:14,560
સીધુ જ.

163
00:09:14,560 --> 00:09:23,170
તેથી તો, argv 0 બનાવે કરવા દો
અહીં તે છે, અને તે બંધ કરો.

164
00:09:23,170 --> 00:09:27,670
તેથી argv 0 ચાલી રહ્યું છે, અને માતાનો દાખલ દો
પૂર્ણાંક, એક બે ત્રણ ચાર એક બે.

165
00:09:27,670 --> 00:09:30,840
તેથી તે, માત્ર એક પૂર્ણાંક છાપો પડશે
બે ત્રણ ચાર એક બે.

166
00:09:30,840 --> 00:09:35,500
કે atoi કેટલાક subtleties છે
તે બાબત અંગે સંભાળ લેવાનું બંધ કરશો

167
00:09:35,500 --> 00:09:39,040
માન્ય આંકડાકીય પાત્ર બહાર,
પરંતુ તે તો કોઈ વાંધો નથી.

168
00:09:39,040 --> 00:09:42,870
>> તેથી તમે શું થાય છે વિચારો છો
જો હું આવું?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
વિભાગીય ખામી.

171
00:09:47,050 --> 00:09:50,410
તેથી શા માટે છે?

172
00:09:50,410 --> 00:09:56,060
તમે અમારી કાર્યક્રમ પર એક નજર, અમે છો
argv 1, પ્રથમ દલીલ રૂપાંતર

173
00:09:56,060 --> 00:09:59,610
કાર્યક્રમ નામ પછી, પૂર્ણાંક છે.

174
00:09:59,610 --> 00:10:03,350
પરંતુ પસાર કોઈ દલીલ છે
કાર્યક્રમ નામ છે.

175
00:10:03,350 --> 00:10:08,060
અહીં, અમે આ એક બગડેલ છે કે નહીં તે જોવા
કાર્યક્રમ, કારણ કે, અમે ચલાવવા માટે પ્રયાસ કરો

176
00:10:08,060 --> 00:10:10,530
કોઇ પણ દલીલો કર્યા વગર
તે માત્ર ભાંગી જશે.

177
00:10:10,530 --> 00:10:16,950
>> તમે જોશો તો અન્ય સામાન્ય પેટર્ન
કંઈક જેમ, argc ઓછી હોય છે, જો

178
00:10:16,950 --> 00:10:21,100
ત્યાં ન હતો જે દર્શાવે છે કે બે કરતાં
ઓછામાં ઓછા કાર્યક્રમ નામ અને

179
00:10:21,100 --> 00:10:29,100
પ્રથમ દલીલ, તો પછી અમે કંઈક કરીશ
જેમ કે, printf પૂરતી નથી

180
00:10:29,100 --> 00:10:31,190
આદેશ વાક્ય દલીલો.

181
00:10:31,190 --> 00:10:33,170
કે કદાચ પ્રિન્ટ સારી નથી,
તે, જેમ કે કદાચ કંઈક છે

182
00:10:33,170 --> 00:10:35,440
તમે પૂર્ણાંક દાખલ કરીશું
આદેશ વાક્ય પર.

183
00:10:35,440 --> 00:10:37,450
હું માત્ર ત્યાં તે સમાપ્ત કરીશું.

184
00:10:37,450 --> 00:10:39,600
અને પછી 1 આવો.

185
00:10:39,600 --> 00:10:44,740
તેથી અમારા ઓવરને અંતે યાદ રાખો કે
કાર્યક્રમ, અમે 0 આવો, કે જે પ્રકારના

186
00:10:44,740 --> 00:10:47,060
સફળતા દર્શાવે છે.

187
00:10:47,060 --> 00:10:50,940
અને મુખ્ય પણ આપોઆપ
જો તમે ન કરો તો 0 આપે છે.

188
00:10:50,940 --> 00:10:55,800
>> અહીં, અમે દર્શાવવા માટે 1 retuning રહ્યા છો
કે સફળતા નથી કે.

189
00:10:55,800 --> 00:11:01,000
અને તમે ગમે તમે ઇચ્છો પાછા આવી શકો છો,
માત્ર 0 સફળતા સૂચવે છે, અને

190
00:11:01,000 --> 00:11:03,390
જે કંઈપણ નિષ્ફળતા સૂચવે છે.

191
00:11:03,390 --> 00:11:04,855
તેથી આપણે વસ્તુઓ ની આ આવૃત્તિ ચલાવો.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
તેથી હવે, અમે આદેશ વાક્ય દાખલ કરો, જો
દલીલ છે, તે યોગ્ય રીતે કહી શકશો

194
00:11:16,600 --> 00:11:18,290
અમને પૂરતી આદેશ વાક્ય નથી.

195
00:11:18,290 --> 00:11:20,610
સજા પૂરી કરી હતી.

196
00:11:20,610 --> 00:11:24,950
બાકી, અમે ખરેખર તે એક પસાર હોય,
તે કાર્યક્રમ પૂર્ણ કરી શકો છો.

197
00:11:24,950 --> 00:11:27,920
તેથી આ તમે argc ઉપયોગ કરશે કેવી રીતે
સંખ્યા માન્ય કરવા માટે

198
00:11:27,920 --> 00:11:30,630
આદેશ વાક્ય દલીલો કે
ખરેખર પસાર થાય છે.

199
00:11:30,630 --> 00:11:39,360
>> તેથી આપણે થોડી વધુ આ કાર્યક્રમ કરી દો
જટિલ, અને બીજા જોવા

200
00:11:39,360 --> 00:11:42,180
વસ્તુઓ પુનરાવૃત્તિ.

201
00:11:42,180 --> 00:11:46,310
તેથી હવે, અમે માત્ર છાપવા કરી રહ્યાં છો એ
પ્રથમ આદેશ વાક્ય દલીલ.

202
00:11:46,310 --> 00:11:51,210
અહીં, અમે પૂર્ણાંક હું સમકક્ષ થી વારો કરી રહ્યાં છો
0, હું, હું argc કરતાં ઓછી છે વત્તા

203
00:11:51,210 --> 00:11:55,280
પ્લસ, અને પ્રિન્ટીંગ argv, ઇન્ડેક્સ હું.

204
00:11:55,280 --> 00:11:59,300
તેથી આ પેટર્ન, ફરીથી, આ જ છે
તેના બદલે સિવાય પહેલાં પેટર્ન,

205
00:11:59,300 --> 00:12:02,600
ચલ કૉલ ની
n એ, અમે argc ઉપયોગ કરી રહ્યાં છો.

206
00:12:02,600 --> 00:12:09,520
>> તેથી આ દરેક ઇન્ડેક્સ પર વારો છે
એરે, અને દરેક છાપવા

207
00:12:09,520 --> 00:12:11,910
કે એરે તત્વ.

208
00:12:11,910 --> 00:12:20,300
અને તેથી અમે આ પ્રોગ્રામ રન છે, સાથે સાથે,
હું કોઇ પણ આદેશ વાક્ય દાખલ કર્યું નથી

209
00:12:20,300 --> 00:12:22,540
દલીલો, માત્ર છાપે છે તેથી તે
કાર્યક્રમ નામ.

210
00:12:22,540 --> 00:12:26,053
હું વસ્તુઓ સમૂહ દાખલ કરો, તો તે પડશે
એક, તેની પોતાની લીટી પર દરેક છાપો.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> બરાબર.

213
00:12:32,210 --> 00:12:34,770
તેથી આપણે આ એક પગલું આગળ લે છે.

214
00:12:34,770 --> 00:12:38,890
અને તેના બદલે દરેક દલીલ છાપવા
તેની પોતાની લીટી પર, દરેક છાપો

215
00:12:38,890 --> 00:12:42,590
દરેક દલીલ પાત્ર
તેની પોતાની લીટી પર.

216
00:12:42,590 --> 00:12:46,700
તેથી argv યાદ રાખો કે
શબ્દમાળાઓ પણ દર્શાવે છે.

217
00:12:46,700 --> 00:12:50,960
તેથી શું શબ્દમાળા છે, પરંતુ
અક્ષરો ઝાકઝમાળ?

218
00:12:50,960 --> 00:12:57,140
જેથી argv ખરેખર અર્થ એ થાય કે એક
અક્ષરો ઝાકઝમાળ દર્શાવે છે.

219
00:12:57,140 --> 00:13:04,920
તેથી તે લાભ લેવા,
હવે માટે આ અવગણો.

220
00:13:04,920 --> 00:13:08,190
આપણે માત્ર શબ્દમાળા argv 0 વિચાર કરીએ.

221
00:13:08,190 --> 00:13:14,170
>> અમે દરેક પાત્ર લાવવા માંગો છો તેથી જો
argv 0 તેની પોતાની લીટી પર, તો પછી હું માંગો છો

222
00:13:14,170 --> 00:13:19,500
અમે ઉપયોગ કરી રહ્યા છો પેટર્ન કરવા માટે, મને છે
એરે લંબાઈ કરતા ઓછી,

223
00:13:19,500 --> 00:13:23,990
અહીં, strlen કરે છે, જે તે છે
હું કરવા માંગો છો નથી શું, શબ્દમાળા

224
00:13:23,990 --> 00:13:26,450
એ argv 0 સમકક્ષ હોય છે.

225
00:13:26,450 --> 00:13:30,390
તેથી હું અમારા લંબાઈ કરતાં ઓછી છે
આ કિસ્સામાં એક વ્યૂહરચના છે કે જે એરે,

226
00:13:30,390 --> 00:13:34,410
અક્ષરો, હું વત્તા વત્તા.

227
00:13:34,410 --> 00:13:41,040
અમે ગયા સપ્તાહે જોયું અને તેથી, તે આદર્શ છે
અમે બહાર strlen કે ખસેડવા જો

228
00:13:41,040 --> 00:13:45,210
આ પરિસ્થિતિ છે, કારણ કે n એ ઉમેરીને આવશે
એ ના strlen અમે જાઓ દર વખતે

229
00:13:45,210 --> 00:13:47,720
લૂપ દ્વારા, અને તે છે
બદલવા માટે નથી જતા.

230
00:13:47,720 --> 00:13:50,230
તેથી અમે અહીં n એ બરાબર તે સેટ કરશો.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> બરાબર.

233
00:13:55,170 --> 00:14:01,320
તેથી હવે, અમે ઉપર વારો કરી રહ્યાં છો
એરે દરેક ઇન્ડેક્સ.

234
00:14:01,320 --> 00:14:05,630
અને તેથી, અમે દરેક પ્રિન્ટ માંગો છો
કે અરે, ટકા સી પાત્ર છે

235
00:14:05,630 --> 00:14:06,880
અમે ઉપયોગ કરવા માંગો છો ધ્વજ
અક્ષરો માટે.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
અને હવે એક કૌંસ હું પ્રયત્ન રહ્યું છે આ
શબ્દમાળા અનુક્રમણિકા પાત્ર હું, તેથી જો

238
00:14:19,770 --> 00:14:20,970
શબ્દમાળા હેલો હતા.

239
00:14:20,970 --> 00:14:27,530
પછી કૌંસ, 0 એચ પ્રયત્ન રહ્યું છે ઓ ઓ
1 તેથી ઈ, ને.

240
00:14:27,530 --> 00:14:30,800
>> તેથી હવે અમે ભેગા કરવા માંગો છો
આ બે વસ્તુઓ.

241
00:14:30,800 --> 00:14:35,440
અમે દરેક અક્ષર પ્રિન્ટ માંગો છો
દરેક આદેશ વાક્ય દલીલ.

242
00:14:35,440 --> 00:14:38,950
તેથી અમે હોય રહ્યા છીએ
લૂપ માટે નેસ્ટ.

243
00:14:38,950 --> 00:14:47,480
અને પરંપરાગત, પ્રથમ કાઉન્ટર
હું આગામી જ પ્રયત્ન રહ્યું છે, n એ છે છે

244
00:14:47,480 --> 00:14:54,450
argv i ની strlen થશે, હું
કરતાં ઓછી n એ, હું વત્તા વત્તા છે.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
અને હવે તેના બદલે પ્રિન્ટીંગ argv હું, તેથી
હું ઇન્ડેક્સ રહ્યું છે argv કૌંસ -

247
00:15:06,870 --> 00:15:14,280
કે-i મી આદેશ વાક્ય જ હશે
દલીલ, argv હું જે રહ્યું છે

248
00:15:14,280 --> 00:15:16,925
પાંચ jth પાત્ર હોઈ
-i મી દલીલ.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
હું હવે આ અહીં ઉપર છૂટકારો મેળવવા પડશે
અમે તે લૂપ માં મૂકી છે.

251
00:15:24,810 --> 00:15:33,900
તેથી શબ્દમાળા ઓ સમકક્ષ જેવું જ છે
argv હું, અને પછી એ જ કૌંસ.

252
00:15:33,900 --> 00:15:36,980
>> વેલ, અમે જાહેર કરવાની જરૂર નથી
આ ચલ ઓ.

253
00:15:36,980 --> 00:15:44,530
તેના બદલે, અમે માત્ર આ ભેગા પડશે
અમે હતી શું બે માં,, જે હું argv.

254
00:15:44,530 --> 00:15:45,780
>> 1 વક્તા: [અશ્રાવ્ય].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> રોબ Boden: ગુડ કોલ.

257
00:15:49,680 --> 00:15:52,936
તેથી આ તૂટી જાય છે.

258
00:15:52,936 --> 00:15:55,510
હું ખરેખર તે ચાલી હતી, અમે કરશે
આ સમજાયું છે.

259
00:15:55,510 --> 00:16:01,210
હું વિશે કાળજી તેથી કાઉન્ટર
માટે આ ખાસ કરીને

260
00:16:01,210 --> 00:16:05,410
લૂપ જે, આ iterator છે.

261
00:16:05,410 --> 00:16:08,560
તેથી જો તમે સમસ્યાઓ પણ હશે,
કદાચ એક અનંત લૂપ, તો

262
00:16:08,560 --> 00:16:09,540
કે નિશ્ચિત ન હતું.

263
00:16:09,540 --> 00:16:12,220
અમે વાત કરી રહ્યા છીએ કે શા માટે
આજે ડિબગીંગ.

264
00:16:12,220 --> 00:16:13,120
>> બરાબર.

265
00:16:13,120 --> 00:16:15,240
તેથી આપણે આ કાર્યક્રમ ચલાવો.

266
00:16:15,240 --> 00:16:21,200
અને આપણે ખરેખર અલગ છે printf ઉમેરો
અહીં માત્ર છાપશે કે

267
00:16:21,200 --> 00:16:27,480
આ અર્થ એ છે કારણ કે બીજા લાઇન, જ્યારે અમે
કાર્યક્રમ ચલાવો, ખાલી હોઈ પડશે

268
00:16:27,480 --> 00:16:31,830
દરેક પાત્ર વચ્ચે લીટી
દરેક આદેશ વાક્ય દલીલ.

269
00:16:31,830 --> 00:16:33,448
વેલ, અમને અર્થ એ થાય કે તે દેખાશે.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
OOP.

272
00:16:37,790 --> 00:16:39,870
કેટલાક ભૂલ મળ્યો.

273
00:16:39,870 --> 00:16:42,860
ભૂલ સર્વથા જાહેર
પુસ્તકાલય કાર્ય strlen.

274
00:16:42,860 --> 00:16:51,630
>> તેથી અમારા કાર્યક્રમમાં પાછા જવાનું, હું
string.h સમાવેશ હેશ ભૂલી ગયા છો.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
તેથી string.h કરી રહ્યું છે
જાહેર છે કે હેડર ફાઈલ

277
00:16:57,730 --> 00:16:58,980
કાર્ય strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
ઠીક છે, તે કમ્પાઇલ.

280
00:17:06,060 --> 00:17:09,109
હવે, આપણે તેના ચલાવો.

281
00:17:09,109 --> 00:17:10,930
તેથી માત્ર કે.

282
00:17:10,930 --> 00:17:17,790
તેને છાપે ચાલી રહ્યું છે અમારા
કાર્યક્રમ નામ, હેલો વર્લ્ડ.

283
00:17:17,790 --> 00:17:23,510
તે દરેક, દરેક વસ્તુ છાપી રહ્યું છે
તેની પોતાની લીટી પર પાત્ર,.

284
00:17:23,510 --> 00:17:24,540
બરાબર.

285
00:17:24,540 --> 00:17:30,625
>> તેથી આપણે ખરેખર આ લો
વધુ એક પગલું.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
અને તેની જગ્યાએ string.h ઉપયોગ, ચાલો
અમે અમારી પોતાની અમલ છો કેવી રીતે વિશે વિચારો

288
00:17:39,700 --> 00:17:41,420
strlen કાર્ય કરે છે.

289
00:17:41,420 --> 00:17:45,600
તેથી હું તરત જ આપી શકશો
એક કાર્ય સહી.

290
00:17:45,600 --> 00:17:52,900
તેથી આપણે my_strlen માં કૉલ કરો, અને તે છે
એક દલીલ તરીકે શબ્દમાળા લાગી રહ્યું,

291
00:17:52,900 --> 00:17:57,220
અને અમે પાછા અપેક્ષા
કે જેઓ શબ્દમાળા લંબાઈ.

292
00:17:57,220 --> 00:18:03,430
તેથી, જ્યાં કે વ્યક્તિ છે?

293
00:18:03,430 --> 00:18:04,990
હા.

294
00:18:04,990 --> 00:18:06,740
બરાબર.

295
00:18:06,740 --> 00:18:12,900
તેથી અગાઉના સ્લાઇડ થી યાદ કે
ગયા સપ્તાહે પણ હતી કે એક

296
00:18:12,900 --> 00:18:18,890
અક્ષરો એરે, સાથે સાથે, એક શબ્દમાળા,
તેથી આપણે આ અમારી શબ્દમાળા ઓ છે કહો.

297
00:18:18,890 --> 00:18:29,870
તેથી એ શબ્દમાળા છે, હેલો, તો પછી,
એચ ઇ એલ એલ ઓ, મેમરી, તે બનશે

298
00:18:29,870 --> 00:18:35,610
પછી આ બેકસ્લેશ હોય છે, અને
0 પાત્ર.

299
00:18:35,610 --> 00:18:39,170
>> તેથી અમે કેવી રીતે ઓ લંબાઈ વિચાર છે?

300
00:18:39,170 --> 00:18:43,190
વેલ, આ યુક્તિ આ માટે જોઈ છે
0 પાત્ર, આ નલ તીવ્ર નકારાત્મક પ્રતિક્રિયા છે

301
00:18:43,190 --> 00:18:44,380
ટર્મિનેટર.

302
00:18:44,380 --> 00:18:50,270
તેથી અલ્ગોરિધમનો રહ્યું છે
થોડા કંઈક હોય

303
00:18:50,270 --> 00:18:51,510
પૂરતી અક્ષરો કે -

304
00:18:51,510 --> 00:18:56,180
ચાલો આ તરફ કેટલાક પ્રતિનિધિત્વ હોય છે
પ્રતિ, ચાલો આ પૂર્ણાંક લંબાઈ કૉલ કરો.

305
00:18:56,180 --> 00:19:00,060
તેથી, અહીં થી શરૂ, અમે છો
અમારા શબ્દમાળા ફરી વળવું રહ્યા.

306
00:19:00,060 --> 00:19:04,100
>> તેથી, તે એચ પ્રથમ અક્ષર છે,
અને તે પાછા તેથી, 0 સ્લેશ નથી

307
00:19:04,100 --> 00:19:05,170
લંબાઈ 1 છે.

308
00:19:05,170 --> 00:19:08,050
આગલા અક્ષર પર ફરી વળવું,
ઇ, અને તે 0 બેકસ્લેશ નથી.

309
00:19:08,050 --> 00:19:09,630
લંબાઈ 2 છે.

310
00:19:09,630 --> 00:19:10,960
એલ, 3.

311
00:19:10,960 --> 00:19:11,850
એલ, 4.

312
00:19:11,850 --> 00:19:13,050
ઓ, 5.

313
00:19:13,050 --> 00:19:16,690
અને છેલ્લે, અમે બેકસ્લેશ પહોંચી
0, અને તેથી તે અર્થ, સાથે સાથે,

314
00:19:16,690 --> 00:19:17,780
આ શબ્દમાળા વધારે છે.

315
00:19:17,780 --> 00:19:20,130
તેથી આપણે 5 પરત દો.

316
00:19:20,130 --> 00:19:33,630
>> તેથી વાસ્તવમાં, પ્રથમ, કે અમલીકરણ
મારા n એ લંબાઈ મારા જમણા હાથમાં, 0 સમકક્ષ હોય છે.

317
00:19:33,630 --> 00:19:36,088
અને અમે ફરી વળવું રહ્યા છીએ -

318
00:19:36,088 --> 00:19:38,000
>> 1 વક્તા: [અશ્રાવ્ય]

319
00:19:38,000 --> 00:19:38,640
>> રોબ Boden: ઓહ, શૂટ.

320
00:19:38,640 --> 00:19:39,870
ગુડ કોલ.

321
00:19:39,870 --> 00:19:42,680
બૂમ.

322
00:19:42,680 --> 00:19:44,140
તેથી n એ લંબાઈ 0 સમકક્ષ હોય છે.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
તેથી હવે, જ્યારે એ લંબાઈ નથી
પછી સમાન અને, બેકસ્લેશ 0.

325
00:19:58,310 --> 00:20:04,660
તેથી, આ બેકસ્લેશ 0 યાદ રાખો કે, તે એક છે
વાસ્તવિક પાત્ર છે, અને તે સૂચવે છે

326
00:20:04,660 --> 00:20:05,820
શબ્દમાળા ઓવરને.

327
00:20:05,820 --> 00:20:09,850
જેમ પણ, બેકસ્લેશ
એ કોઇ વાસ્તવિક પાત્ર છે.

328
00:20:09,850 --> 00:20:14,040
બેકસ્લેશ 0 સૂચવે રહ્યું છે
અમારા શબ્દમાળા ઓવરને.

329
00:20:14,040 --> 00:20:15,414
હું ત્યાં કે મૂકેલ નથી.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
અને લંબાઈ દ્વારા અનુક્રમિત એ નથી જ્યારે
નલ ટર્મીનેટર સમાન, તો પછી

332
00:20:25,620 --> 00:20:27,130
અમે માત્ર લંબાઈ વધારતી રહ્યા છીએ.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
તેથી પછી અમારા કાર્યક્રમ ઓવરને અંતે,
લંબાઈ છેવટે રહ્યું છે

335
00:20:34,880 --> 00:20:37,610
આ કિસ્સામાં 5 છે.

336
00:20:37,610 --> 00:20:39,210
અને અમે માત્ર લંબાઈ પરત મળશે.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> બરાબર.

339
00:20:43,530 --> 00:20:48,290
તેથી હવે અહીં નીચે, હું નથી
my_strlen નથી.

340
00:20:48,290 --> 00:20:50,700
માટે ખાતરી કરો કે તે સંકલન કરીએ
બધું સરળતાથી ચાલે છે.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
હું 2 માં કરી હતી?

343
00:20:58,210 --> 00:21:00,565
અથવા 1 એ હતો?

344
00:21:00,565 --> 00:21:01,940
તે કરવું જોઈએ.

345
00:21:01,940 --> 00:21:02,690
અધિકાર છે.

346
00:21:02,690 --> 00:21:08,490
તેથી આ argv 2 છે.

347
00:21:08,490 --> 00:21:11,585
અપેક્ષિત તરીકે, કામ કરે છે, તેમ છતાં
એક હું તે કર્યું હતું કે હતો?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
હા.

350
00:21:15,550 --> 00:21:16,760
બરાબર.

351
00:21:16,760 --> 00:21:21,820
વસ્તુઓ આ સંસ્કરણ ન હતી
આ printf નવા પછી વાક્ય છે, પરંતુ તે

352
00:21:21,820 --> 00:21:22,910
કોઇ તફાવત નથી.

353
00:21:22,910 --> 00:21:23,300
બરાબર.

354
00:21:23,300 --> 00:21:25,780
અપેક્ષા જેથી કામ કર્યું હતું.

355
00:21:25,780 --> 00:21:34,750
>> હવે અમે પણ આ એક પગલું ભેગા કરી શકો છો
વળી, અહીં જ્યાં નોંધ લો, સાથે સાથે,

356
00:21:34,750 --> 00:21:38,920
પ્રથમ, અમે argv ના strlen પડતો કરી રહ્યાં છો
હું, અને પછી અમે પર વારો કરી રહ્યાં છો

357
00:21:38,920 --> 00:21:41,450
કે જેઓ શબ્દમાળા દરેક અક્ષર છે.

358
00:21:41,450 --> 00:21:47,480
તેથી તેના બદલે કે કરી ના, તો શું આપણે
માત્ર રાહ આ તર્ક ભેગા

359
00:21:47,480 --> 00:21:50,740
અમે બેકસ્લેશ 0 અધિકાર નહીં ત્યાં સુધી
લૂપ માટે આ માં?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Argv હું જે કરે છે, જ્યારે તેથી ફરી વળવું
સમાન નથી બેકસ્લેશ 0.

362
00:22:07,490 --> 00:22:10,680
તેથી આપણે તેને પ્રથમ વખત ચલાવો.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> અધિકાર છે.

365
00:22:21,180 --> 00:22:27,655
અહીં, આ શરત કહે છે -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
માતાનો એ સ્પષ્ટ કરો.

368
00:22:40,060 --> 00:22:49,140
તેથી હવે, આ અમારી argv બનાવી દો.

369
00:22:49,140 --> 00:22:55,290
તેથી હું ફક્ત પહેલા તે કાર્યક્રમ ચાલી હતી,
argv શબ્દમાળાઓ ઝાકઝમાળ છે.

370
00:22:55,290 --> 00:23:03,100
અને તેથી, હું કોઈ સ્લેશ argv સાથે ચલાવવા જો
2, હેલો વર્લ્ડ, પછી argv

371
00:23:03,100 --> 00:23:07,650
પોતે argv માટે, લંબાઈ 3 છે
શૂન્ય, હેલો, અને વિશ્વ.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> અને આ સૂચકાંક દરેક ની અંદર છે,
પોતે આ હશો જ્યાં ઝાકઝમાળ,

374
00:23:19,660 --> 00:23:23,780
કોઈ, આ સ્લેશ હશે, મને ખબર નથી
કે યોગ્ય દિશામાં હોય તો, હું

375
00:23:23,780 --> 00:23:25,680
તે લાગતું નથી.

376
00:23:25,680 --> 00:23:30,110
એ આર-V એ આડંબર, વધુ જગ્યાની જરૂર.

377
00:23:30,110 --> 00:23:32,570
ચાલો આ એરે માં કાઢે છે.

378
00:23:32,570 --> 00:23:38,230
એ આર-V એ આડંબર 0 અને પછી બેકસ્લેશ 0.

379
00:23:38,230 --> 00:23:43,160
અને પછી ગૂંચવાડો હેલો હશે.

380
00:23:43,160 --> 00:23:45,910
માતાનો, એચ ઇ બેકસ્લેશ 0 કહો.

381
00:23:45,910 --> 00:23:51,130
અને છેલ્લે, W-કંઈપણ બેકસ્લેશ 0.

382
00:23:51,130 --> 00:23:59,730
>> તેથી અમે માત્ર લખ્યું હતું કે અલ્ગોરિધમનો,
આ તેઓ શું લૂપ, માટે નેસ્ટ

383
00:23:59,730 --> 00:24:07,321
નોંધ કરી, અમે પ્રથમ છે
હું અને પછી જ કાઉન્ટર છે.

384
00:24:07,321 --> 00:24:15,206
આ પર કોડ સાથે સરળ છે
સ્ક્રીન, ચાલો આ માટે પાછા જઈએ.

385
00:24:15,206 --> 00:24:17,476
બરાબર.

386
00:24:17,476 --> 00:24:24,600
તેથી હું કે iterator નોંધ્યું છે કે
દરેક આદેશ પર વારો

387
00:24:24,600 --> 00:24:25,610
વાક્ય દલીલ.

388
00:24:25,610 --> 00:24:28,870
અને જે પાંચ iterator વારો છે
કે દરેક અક્ષર પર

389
00:24:28,870 --> 00:24:30,410
આદેશ વાક્ય દલીલ.

390
00:24:30,410 --> 00:24:46,755
તેથી આ અંદરની printf શું કરી રહ્યા છે
, અમે argv 0 0, printf printf છે છે

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf argv 0 2 0 3, 4 0, 0
5, 6 0, પરંતુ હવે, argv 0 7 રહ્યું છે

392
00:24:58,680 --> 00:25:00,670
સમાન બેકસ્લેશ 0.

393
00:25:00,670 --> 00:25:05,730
>> તેથી તો અમે લૂપ કે બહાર નીકળો,
અને હવે હું 1 માટે iterates.

394
00:25:05,730 --> 00:25:10,910
અને હવે અમે છાપી રહ્યા છીએ
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
ઠીક છે, હવે, હું ટૂંકા હેલો કાપી છે, કારણ કે
argv 1 2 ફરીથી પ્રયત્ન રહ્યું છે

396
00:25:17,040 --> 00:25:18,170
બેકસ્લેશ 0.

397
00:25:18,170 --> 00:25:25,050
અને તેથી, હું વધારતી અને ચાલુ રાખવા માટે, અને
તેથી, ત્યાં સુધી અમે તમામ છાપે

398
00:25:25,050 --> 00:25:28,580
દુનિયા અને તે ત્રણ આદેશ વાક્ય છે
દલીલો, અને અમે બહાર બહાર નીકળવા પડશે

399
00:25:28,580 --> 00:25:31,670
બાહ્ય સત્ર મારી લૂપ, અને
અમારા કાર્યક્રમ સમાપ્ત કરો.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
બરાબર.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> તેથી આપણે અહીં પાછા આવીએ.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
તેથી તમારી સાથે કેટલાક પારિવારિકતા મેળવવા પડશે
આ આદેશ વાક્ય દલીલો

406
00:25:52,370 --> 00:25:54,460
ખાસ સમસ્યા સુયોજિત કરો.

407
00:25:54,460 --> 00:25:56,630
>> હવે, ડિબગીંગ.

408
00:25:56,630 --> 00:26:01,680
તેથી તમે કદાચ પહેલાથી જ કરી રહ્યો છે
તમારા પહેલાંના સાથે કેટલાક ડિબગીંગ

409
00:26:01,680 --> 00:26:03,120
સમસ્યા સુયોજિત કરો.

410
00:26:03,120 --> 00:26:08,420
અને ડિબગીંગ એક ખૂબ જ સરળ રીતે,
પ્રથમ, એક બગડેલ કાર્યક્રમ જુઓ.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
વેલ, આ કાર્યક્રમ દ્વારા વૉકિંગ
અમે એક માટે વપરાશકર્તા પૂછવા રહ્યા છીએ

413
00:26:23,830 --> 00:26:29,350
પૂર્ણાંક, કે પૂર્ણાંક ગ્રેબ અને પછી,
આપખુદ, અમે જ્યારે લૂપ છે કે

414
00:26:29,350 --> 00:26:32,280
માત્ર હ્રાસ રહ્યું છે
તે 10 માટે સમાન છે હું ત્યાં સુધી.

415
00:26:32,280 --> 00:26:35,820
ચાલો માત્ર હું દાખલ છું ધારે
10 થી વધુ પૂર્ણાંક.

416
00:26:35,820 --> 00:26:38,700
તે 10 માટે સમાન છે ત્યાં સુધી તેથી હું હ્રાસ.

417
00:26:38,700 --> 00:26:42,630
>> અને પછી અમે બીજા જ્યારે લૂપ છે
હું 0 સમાન નથી, અમે છીએ, કે

418
00:26:42,630 --> 00:26:44,540
3 હું ઘટાડવા માટે જઈ રહી છે.

419
00:26:44,540 --> 00:26:49,790
તેથી તમે ક્ષતિના ઉદ્દેશ જુઓ તો
અહીં, આ હું હ્રાસ પડશે કે છે

420
00:26:49,790 --> 00:26:57,010
10 અને પછી આ વખતે લૂપ પણ આવી
1 થી 4 થી 7 10,,, ના હ્રાસ હું,

421
00:26:57,010 --> 00:27:02,880
નકારાત્મક 2 માટે, તેથી પર 5 નકારાત્મક છે, અને
નકારાત્મક અનંત માટે, ચાલશે થી

422
00:27:02,880 --> 00:27:05,920
ખરેખર 0 જેટલી નથી.

423
00:27:05,920 --> 00:27:08,610
અને પછી આ કાર્યક્રમ ઓવરને અંતે,
અમે કે જે foo કાર્ય છે

424
00:27:08,610 --> 00:27:12,130
પ્રિન્ટ પર બહાર હું કે જે.

425
00:27:12,130 --> 00:27:16,520
>> તેથી આ એક ટૂંકા અને તુચ્છ કાર્યક્રમ છે
અને ભૂલ સ્પષ્ટ છે,

426
00:27:16,520 --> 00:27:18,790
ખાસ કરીને પછી હું માત્ર
ભૂલ શું જણાવ્યું હતું.

427
00:27:18,790 --> 00:27:24,840
પરંતુ અહીં હેતુ સાથે સાથે, આ કદાચ છે,
ખરેખર કેટલાક જેમ દેખાય તમારા

428
00:27:24,840 --> 00:27:30,040
છેલ્લા થી લોભી થી ઉકેલો
સમસ્યા સુયોજિત કરો, અને કદાચ તમે છે

429
00:27:30,040 --> 00:27:32,800
તમારા કાર્યક્રમ કેટલાક અનંત લૂપ,
અને તમે કોઈ વિચાર છે

430
00:27:32,800 --> 00:27:34,100
તે શું કારણ છે.

431
00:27:34,100 --> 00:27:38,690
તેથી ખૂબ જ ઉપયોગી ડિબગીંગ ટેકનિક
માત્ર printfs ઉમેરો છે

432
00:27:38,690 --> 00:27:40,180
તમારા બધા કોડ પર.

433
00:27:40,180 --> 00:27:49,200
>> તેથી અહીં હું બહાર printf કરવા માંગો છો
પ્રથમ જ્યારે લૂપ.

434
00:27:49,200 --> 00:27:53,155
અને અહીં હું printf કરવા માંગો છો,
અને હું માત્ર મને છાપો પડશે.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
લૂપ જ્યારે હું પણ હું પ્રથમ પ્રયાસો કરીશું.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
બહાર, બીજા લૂપ છે.

439
00:28:09,040 --> 00:28:12,170
ફરી એક વાર, અંદર છાપો
ના અહીં, મૂલ્યો.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
અને આપણે આ ચલાવો.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> તેથી કોઈ સ્લેશ ડિબગ.

444
00:28:24,800 --> 00:28:25,610
પૂર્ણાંક દાખલ કરો.

445
00:28:25,610 --> 00:28:28,150
13 દો.

446
00:28:28,150 --> 00:28:28,760
અને તેજી.

447
00:28:28,760 --> 00:28:33,300
અમે અનંત રહ્યાં છે કે નહીં તે જોવા
બીજા જ્યારે લૂપની અંદર.

448
00:28:33,300 --> 00:28:36,305
તેથી હવે આપણે ભૂલ છે તે જાણવા.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
પરંતુ printf ડિબગીંગ, સંપૂર્ણ મહાન છે
પરંતુ તમારા કાર્યક્રમો વિચાર એક વખત

451
00:28:45,610 --> 00:28:50,560
લાંબા સમય સુધી અને વધુ જટિલ છે,
વધુ આધુનિક ઉકેલો

452
00:28:50,560 --> 00:28:51,705
વસ્તુઓ કામ કરી રહેલી.

453
00:28:51,705 --> 00:28:52,955
તેથી આપણે આ બધા printfs દૂર કરો.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
અને માતાનો ખાતરી છે કે હું નથી કર્યું બનાવી દો
કંઈપણ તૂટી જાય છે.

456
00:29:08,896 --> 00:29:09,850
બરાબર.

457
00:29:09,850 --> 00:29:14,180
>> તેથી અમે રહ્યા છીએ કાર્યક્રમ
દાખલ તરીકે ઓળખાય છે

458
00:29:14,180 --> 00:29:16,715
GNU ડિબગર માટે GDB,.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
ઠીક છે, ખરેખર, ચાલો માટે ડિબગ દૂર કરો
એક સેકન્ડ, અને ફરીથી ડિબગ કરો.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
ઠીક છે, ખરેખર પ્રથમ, એક સારો પાઠ
આદેશ વાક્ય દલીલો છે.

463
00:29:34,440 --> 00:29:37,780
આ રણકાર આદેશ છે નોંધ કરો કે
બધું પસાર થઈ રહી છે સંકલન

464
00:29:37,780 --> 00:29:41,300
આદેશ વાક્ય પર, આ
આદેશ વાક્ય દલીલો.

465
00:29:41,300 --> 00:29:46,250
તમે ઉપયોગ કરી રહ્યા છે તેથી ખરેખર કેવી રીતે
આદેશ વાક્ય દલીલો, અમે

466
00:29:46,250 --> 00:29:51,500
પહેલાં હતી, અને તમે pset માં કરશે
2, કે રણકાર તેમને ઉપયોગ કરી રહ્યા છે કેવી રીતે.

467
00:29:51,500 --> 00:30:00,070
>> તેથી નોંધ્યું છે કે આ પ્રથમ ધ્વજ, આડંબર
ggdb3, એ કહે છે તે, રણકાર,

468
00:30:00,070 --> 00:30:03,790
તમે સાથે આ ફાઈલ કમ્પાઈલ જોઈએ
ઉદ્દેશ કે અમે આખરે કરશે

469
00:30:03,790 --> 00:30:05,380
તે ડિબગ કરવાની જરૂર છે.

470
00:30:05,380 --> 00:30:13,840
તેથી જ્યાં સુધી તમે કે ધ્વજ હોય ​​છે,
પછી અમે GDB ડિબગ કરી શકો છો.

471
00:30:13,840 --> 00:30:17,380
અને તે એ GNU ડિબગર ખોલો પડશે.

472
00:30:17,380 --> 00:30:22,920
>> તેથી આદેશો ઘણો છે
તમે ઉપયોગ કરવા માટે જરૂર છે.

473
00:30:22,920 --> 00:30:27,100
પ્રથમ એક કે તમે કદાચ પડશે
તરત જ જરૂર છે ચલાવવામાં આવે છે.

474
00:30:27,100 --> 00:30:28,200
તેથી શું કરવા જઈ રન?

475
00:30:28,200 --> 00:30:30,910
તે બનાવે છે અમારા કાર્યક્રમ શરૂ થઈ રહ્યું છે.

476
00:30:30,910 --> 00:30:36,180
તેથી, શરૂ કાર્યક્રમ, કાર્યક્રમ ચલાવો
પૂર્ણાંક, 13 માટે અમને પૂછે છે.

477
00:30:36,180 --> 00:30:39,170
અને પછી તે અનંત રહ્યાં તરીકે છે
હું દૂર સિવાય અપેક્ષિત

478
00:30:39,170 --> 00:30:40,500
printfs, તેથી અમે પણ છે કે જે દેખાય નહિં.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
સામાન્ય રીતે બહાર.

481
00:30:44,600 --> 00:30:45,850
ઓહ.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
તે આવરિત છે કે શક્ય છે બધા
રીતે આસપાસ છે, પાછળ - કે અવગણીને.

484
00:30:53,640 --> 00:30:55,170
તે સામાન્ય રીતે બહાર નીકળી ન હતી ધારે.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
તે માટે એક જટિલ જવાબ છે.

487
00:31:03,370 --> 00:31:07,890
>> તેથી હવે, તે ખૂબ જ ઉપયોગી નથી.

488
00:31:07,890 --> 00:31:11,480
તેથી માત્ર ની અંદર અમારા કાર્યક્રમ ચાલી
આ ડીબગર કોઈપણ બનાવવામાં મદદ કરતું નથી,

489
00:31:11,480 --> 00:31:15,610
અમે માત્ર આ કરી શકે છે કારણ કે જે રીતે,
કોઈ GDB બહારથી ડિબગ સ્લેશ.

490
00:31:15,610 --> 00:31:21,250
તેથી એક આદેશ કે
તમે કદાચ કરીશું -

491
00:31:21,250 --> 00:31:22,970
અને હું આ બહાર નીકળવા પડશે.

492
00:31:22,970 --> 00:31:25,850
નિયંત્રણ-D અથવા, કામ બંને છોડી દીધું.

493
00:31:25,850 --> 00:31:29,550
તેથી આપણે તેને ફરીથી ખોલો.

494
00:31:29,550 --> 00:31:31,130
>> અન્ય આદેશ કે તમે કદાચ પડશે
તરત જ કરવા માંગો છો

495
00:31:31,130 --> 00:31:33,600
માટે ઉપયોગ કરો બ્રેક છે.

496
00:31:33,600 --> 00:31:37,120
તેથી અમે હવે મુખ્ય પર તૂટી પડશે
અને પછી હું સમજાવવું પડશે.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
વેલ, અહીં આપણે બ્રેકપોઇન્ટ સેટ જુઓ
debug.c આ વાક્ય પર.

499
00:31:46,370 --> 00:31:50,160
તેથી શું વિરામ અર્થ છે કે જ્યારે હું
રન લખો, કાર્યક્રમ રહ્યું છે

500
00:31:50,160 --> 00:31:53,560
ત્યાં સુધી ચાલુ રહે
હું એક બ્રેકપોઇન્ટ હિટ.

501
00:31:53,560 --> 00:31:59,390
હું રન હિટ તેથી, જ્યારે આ કાર્યક્રમ, શરૂ થાય છે
અને પછી તે તરત તે તોડે

502
00:31:59,390 --> 00:32:01,940
મુખ્ય કાર્ય પ્રવેશે છે.

503
00:32:01,940 --> 00:32:06,930
મુખ્ય તૂટી જાય છે કંઈક પ્રયત્ન રહ્યું છે
તમે ખૂબ સામાન્ય હોય છે.

504
00:32:06,930 --> 00:32:11,340
>> અને હવે, તમે દાખલ
કેટલાક વધુ આદેશો માટે.

505
00:32:11,340 --> 00:32:14,330
તે અમે કહેતા છે કે, અહીં નોંધ કરો
જે 11 લીટી, ઓછામાં તોડી

506
00:32:14,330 --> 00:32:16,230
printf, પૂર્ણાંક દાખલ કરો.

507
00:32:16,230 --> 00:32:21,260
તેથી આદેશ આગળ કેવી રીતે કરી રહ્યું છે
અમે કોડ આગળના વાક્ય પર જાઓ.

508
00:32:21,260 --> 00:32:24,810
આ અમને પગલું માટે પરવાનગી આપે છે રહ્યું છે
વાક્ય દ્વારા અમારા કાર્યક્રમ વાક્ય મારફતે.

509
00:32:24,810 --> 00:32:26,260
તેથી આગામી.

510
00:32:26,260 --> 00:32:29,820
>> હવે 12 લીટી, અમે રહ્યા છીએ
પૂર્ણાંક વિચાર.

511
00:32:29,820 --> 00:32:30,450
આગળ.

512
00:32:30,450 --> 00:32:34,290
તમે માત્ર લિમિટેડ ફરીથી દબાવો, તે પડશે
તમે હતી છેલ્લા વસ્તુ ફરી.

513
00:32:34,290 --> 00:32:36,480
તેથી હું લખો જરૂર નથી
આગામી દર વખતે.

514
00:32:36,480 --> 00:32:40,100
તેથી પૂર્ણાંક, 13 દાખલ કરો.

515
00:32:40,100 --> 00:32:46,940
તેથી હવે, લાઇન 14, હું વધારે હોય છે, જ્યારે
10 કરતાં, અને હું આગળ શું કરશો.

516
00:32:46,940 --> 00:32:48,685
અને અમે અમે હું હ્રાસ રહ્યા છીએ જુઓ.

517
00:32:48,685 --> 00:32:50,210
તેથી અમે ફરીથી હું હ્રાસ રહ્યા છીએ.

518
00:32:50,210 --> 00:32:53,620
>> તેથી હવે, અન્ય ઉપયોગી
આદેશ છાપો છે.

519
00:32:53,620 --> 00:32:55,750
તેથી પ્રિન્ટ છાપી રહ્યું છે
ચલ ની કિંમત.

520
00:32:55,750 --> 00:32:57,825
માતાનો કિંમત લાવવા દો
ચલ આવી છે.

521
00:32:57,825 --> 00:32:58,705
માતાનો મને છાપો દો.

522
00:32:58,705 --> 00:33:00,910
તે હું 11 કહેવું બનશે.

523
00:33:00,910 --> 00:33:03,330
હવે અમે આગળ ફરી જ્યારે
હું 10 કરતાં વધારે હોય છે.

524
00:33:03,330 --> 00:33:05,590
તેથી હું હજુ પણ કરતા વધારે છે
તે 11 કારણ કે 10,.

525
00:33:05,590 --> 00:33:06,920
હું બાદ બાદ.

526
00:33:06,920 --> 00:33:08,250
માતાનો ફરીથી મને છાપો દો.

527
00:33:08,250 --> 00:33:10,950
ઈચ્છિત તરીકે, તે 10 છે.

528
00:33:10,950 --> 00:33:12,510
>> તેથી હવે, આગામી.

529
00:33:12,510 --> 00:33:16,250
તે પાછા સ્થિતિ ચાલી રહ્યું છે, હું
10 થી વધુ, પરંતુ હું તેથી, હવે 10 છે

530
00:33:16,250 --> 00:33:20,040
તે 10 થી વધુ નથી, તેથી અમે અપેક્ષા
તે જ્યારે લૂપ બહાર પડે છે.

531
00:33:20,040 --> 00:33:22,220
અને હવે અમે કોડ કે વાક્ય નીચે છો.

532
00:33:22,220 --> 00:33:28,750
પછી બીજો એક આદેશ, સૂચિ, માત્ર રહ્યું છે
અગાઉના અને આગામી પ્રદર્શિત કરવા માટે

533
00:33:28,750 --> 00:33:31,240
કોડ ઓફ લાઇન, માં દંપતિ
કેસ તમે તમારી જાતને ગુમાવી હતી.

534
00:33:31,240 --> 00:33:35,420
તેથી અમે માત્ર, આ વખતે લૂપ બહાર
અને હવે અમે આ દાખલ કર્યો છે

535
00:33:35,420 --> 00:33:37,080
જ્યારે લૂપ, 18 લીટી.

536
00:33:37,080 --> 00:33:39,860
હું 0 સમાન નથી જ્યારે છે.

537
00:33:39,860 --> 00:33:46,570
અને, આગળ, અમે પડશે હું ઓછા 3 જેટલી જ થાય છે, અને
નોટિસ, આ માત્ર ચાલુ રાખવા પડશે.

538
00:33:46,570 --> 00:33:48,270
અને અમે હું પ્રિન્ટ કરી શકો છો.

539
00:33:48,270 --> 00:33:49,990
>> દરેક આદેશ સૉર્ટ શૉર્ટકટ્સ છે.

540
00:33:49,990 --> 00:33:51,720
તેથી પૃષ્ઠ છાપો માટે ટૂંકા હોય છે.

541
00:33:51,720 --> 00:33:53,400
તેથી અમે પી હું આ કરી શકો છો.

542
00:33:53,400 --> 00:33:57,550
માત્ર n હોલ્ડિંગ રાખો,
અથવા આગામી કરી રાખે છે.

543
00:33:57,550 --> 00:33:58,340
ફરીથી મને છાપો.

544
00:33:58,340 --> 00:34:00,380
તમે તેને 167 નકારાત્મક છે હવે જુઓ.

545
00:34:00,380 --> 00:34:06,030
તેથી આ કાયમ પર જાય છે, પરંતુ નહીં
ખરેખર કાયમ, તમે માત્ર જોવા મળી હતી, કારણ કે તે

546
00:34:06,030 --> 00:34:09,330
ખરેખર કોઇ સમયે સમાપ્ત થશે.

547
00:34:09,330 --> 00:34:15,699
>> જેથી GDB શરૂઆત છે.

548
00:34:15,699 --> 00:34:19,504
પરંતુ GDB માં વધુ એક વસ્તુ નથી.

549
00:34:19,504 --> 00:34:20,754
ઉહ, ડિબગ.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
તેથી, આ ચોક્કસ કિસ્સામાં,
અનંત લૂપની અંદર પ્રયત્ન થયું

552
00:34:28,534 --> 00:34:30,050
મુખ્ય કાર્ય.

553
00:34:30,050 --> 00:34:35,779
અને હવે માટે, માત્ર હું છું કે સ્વીકારે છે કે
માં અનંત લૂપ ખસેડવા જાઉં

554
00:34:35,779 --> 00:34:37,029
ફૂ કાર્ય કરે છે.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
માત્ર આ ઓવરને અંતે, યાદ રાખો કે
કાર્યક્રમ, સાથે સાથે, આ મૂળ હતી

557
00:34:43,730 --> 00:34:46,210
માત્ર હતી જે foo ને ફોન
હું છાપી રહ્યું.

558
00:34:46,210 --> 00:34:51,880
પરંતુ હવે અમે, કે જે foo કૉલ કરી રહ્યાં છો
તે 0 છે ત્યાં સુધી હું હ્રાસ, અને રહ્યું

559
00:34:51,880 --> 00:34:54,548
પછી તે ચલ છાપો.

560
00:34:54,548 --> 00:34:55,469
બરાબર.

561
00:34:55,469 --> 00:34:57,970
કે સાચવો.

562
00:34:57,970 --> 00:35:00,175
ડિબગ કરો.

563
00:35:00,175 --> 00:35:03,310
અને હવે, GDB ડિબગ.

564
00:35:03,310 --> 00:35:04,090
બરાબર.

565
00:35:04,090 --> 00:35:10,580
>> હું માત્ર ચલાવો તો તેથી પછી હું જઈ રહ્યો છું
ખરેખર મારફતે પગલું કરવાનો પ્રયત્ન મારા

566
00:35:10,580 --> 00:35:11,730
કાર્યક્રમ વાક્ય દ્વારા વાક્ય.

567
00:35:11,730 --> 00:35:19,820
તેથી આપણે મુખ્ય અંતે તોડી દો,
અને પછી રન લખો.

568
00:35:19,820 --> 00:35:28,160
તેથી આ મારફતે જાઓ, printf માટે, દાખલ
પૂર્ણાંક, પૂર્ણાંક, 13 વિશે.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
તેથી અમે decrementing રાખવા રહ્યા છીએ
હું 10 કરતાં વધારે હોય છે ત્યાં સુધી.

571
00:35:37,490 --> 00:35:42,840
પછી અમે મારફતે આવતા રહ્યા છીએ
જ્યારે લૂપ, અને લાઇન પર વિચાર -

572
00:35:42,840 --> 00:35:44,364
માતાનો અલગ વિન્ડોમાં તે ખોલો.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
હું લાંબા સમય સુધી ન કરે ત્યાં સુધી તો આપણે decremented
પછી 10 થી વધુ છે, અને અમે

575
00:35:53,300 --> 00:35:55,700
foo, કાર્ય કરે છે.

576
00:35:55,700 --> 00:36:01,340
>> તેથી શું જલદી હું નહીં થયું
કાર્ય foo, સાથે સાથે, હું foo કહેવાય છે, અને

577
00:36:01,340 --> 00:36:04,030
પછી હું લાંબા સમય સુધી GDB પર નિયંત્રણ ધરાવતા હતા.

578
00:36:04,030 --> 00:36:10,230
તેથી જલદી હું આ વાક્ય પર આગળ નહીં,
આ થયું ત્યાં સુધી વસ્તુઓ ચાલુ રાખ્યું,

579
00:36:10,230 --> 00:36:12,400
જ્યારે કાર્યક્રમ જ્યાં બહાર -

580
00:36:12,400 --> 00:36:14,450
તે આખરે અસ્તિત્વમાં હતી ધારે.

581
00:36:14,450 --> 00:36:16,390
તમે તે છતાં ઘડીભર વિરામ જોવા મળી હતી.

582
00:36:16,390 --> 00:36:22,040
તેથી શા માટે હું પર નિયંત્રણ ગુમાવી હતી
તે સમયે કાર્યક્રમ?

583
00:36:22,040 --> 00:36:27,540
હું આગામી લખો જ્યારે ઠીક છે,, કે જાય
કોડ શાબ્દિક આગામી લીટી

584
00:36:27,540 --> 00:36:28,850
ચલાવવા કરશે.

585
00:36:28,850 --> 00:36:35,950
તેથી પછી 21 લીટી, કોડ આગળના વાક્ય
કે, 22 લીટી છે ચલાવવા કરશે

586
00:36:35,950 --> 00:36:38,520
મુખ્ય માંથી બહાર નીકળતા, છે.

587
00:36:38,520 --> 00:36:43,810
તેથી હું ફક્ત જાઓ નહિં માંગો
કોડ આગળના વાક્ય.

588
00:36:43,810 --> 00:36:48,170
હું કાર્ય, foo જાય માંગો છો,
અને પછી પણ મારફતે પગલું

589
00:36:48,170 --> 00:36:49,830
કોડ ઓફ તે રેખાઓ.

590
00:36:49,830 --> 00:36:53,726
>> તેથી આ માટે, અમે એક વૈકલ્પિક હોય છે.

591
00:36:53,726 --> 00:36:56,770
માતાનો ફરીથી છોડી દીધું.

592
00:36:56,770 --> 00:36:58,020
મુખ્ય તૂટી જાય છે.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
ઉહ, 1, આગળ, આગળ, 13, આગળ,
આગળ, આગળ, કાળજીપૂર્વક

595
00:37:06,370 --> 00:37:09,820
અમે વાક્ય foo દબાવો તે પહેલા જ.

596
00:37:09,820 --> 00:37:10,520
બરાબર.

597
00:37:10,520 --> 00:37:13,700
>> તેથી હવે, અમે 21 લીટી પર છો
અમે foo કહી છે.

598
00:37:13,700 --> 00:37:17,100
અમે આગામી લખો નથી માંગતા કે કારણ
માત્ર કાર્ય foo કહી, અને કરશે

599
00:37:17,100 --> 00:37:18,710
કોડ આગળના વાક્ય પર જાઓ.

600
00:37:18,710 --> 00:37:20,840
શું અમે ઉપયોગ કરવા માંગો છો પગલું છે.

601
00:37:20,840 --> 00:37:25,690
તેથી પગલું વચ્ચે તફાવત છે
અને પગલું પાંચ માં જાય છે આગળ,

602
00:37:25,690 --> 00:37:28,190
કામ કરે છે અને આગળ જાય છે
કાર્ય પર.

603
00:37:28,190 --> 00:37:32,830
તે માત્ર સમગ્ર ચલાવે છે
કાર્ય અને રાખે છે જઈ રહી છે.

604
00:37:32,830 --> 00:37:37,210
>> તેથી પગલું બનાવવામાં લાવી રહ્યું છે
આ કાર્ય માં, foo,.

605
00:37:37,210 --> 00:37:41,160
અને અમે હવે, અમે પાછા છો, અહીં જુઓ
સિદ્ધાંત મુજબ, કે આ વખતે લૂપ,

606
00:37:41,160 --> 00:37:44,190
કાયમ ચાલુ રહ્યું.

607
00:37:44,190 --> 00:37:50,420
અને જો તમે તે ન હોય ત્યારે પગલું, નહીં જો
ફોન કાર્ય, પછી તે છે

608
00:37:50,420 --> 00:37:51,720
આગળ સમાન.

609
00:37:51,720 --> 00:37:55,320
તમે એક લીટી પર છો તેથી જ્યારે તે માત્ર છે કે
પગલું કે કાર્ય ફોન છે

610
00:37:55,320 --> 00:37:56,970
આગળ અલગ રહ્યું છે.

611
00:37:56,970 --> 00:37:57,930
તેથી પગલું અહીં અમારો લાવશે.

612
00:37:57,930 --> 00:38:02,100
પગલું, પગલું, પગલું, પગલું, પગલું, પગલું, અને
અમે કાયમ માત્ર અનંત લૂપ પડશે.

613
00:38:02,100 --> 00:38:06,810
>> તેથી તમે તે માટે વાપરવામાં શકે તમારા
અનંત આંટીઓ ઓળખવા રીતે, છે

614
00:38:06,810 --> 00:38:08,960
ફક્ત આ Enter કી માટે હોલ્ડિંગ
જો તમારી સામે સમસ્યાઓ જ્યાં જુઓ.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
ત્યાં તે કરવા માટે વધુ સારી રીતે હોય છે, પરંતુ
હવે માટે, કે જે સંપૂર્ણપણે પૂરતી છે.

617
00:38:14,780 --> 00:38:17,967
અને stylistically, પ્રકાર ખાતરી કરવા માટે
50, હું આ કરી જોઈએ.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
બરાબર.

620
00:38:24,030 --> 00:38:28,400
>> તેથી એક છેલ્લા આદેશ દાખલ.

621
00:38:28,400 --> 00:38:30,810
વેલ, જે સાઇન ડિબગ gdb દો

622
00:38:30,810 --> 00:38:35,580
તેથી તેના બદલે મુખ્ય અંતે તોડવા, તો હું
ફૂ કાર્ય ખબર પણ છે

623
00:38:35,580 --> 00:38:39,230
સમસ્યા છે, તો પછી હું કરી શકે છે માત્ર
, તેના બદલે, foo પર ભંગ.

624
00:38:39,230 --> 00:38:42,310
માતાનો હું તોડી કહો
મુખ્ય અને foo બંને.

625
00:38:42,310 --> 00:38:45,390
તેથી તમે ઘણા બ્રેકપોઇન્ટ્સ સેટ કરી શકો છો
તમે ઇચ્છો તરીકે.

626
00:38:45,390 --> 00:38:49,230
હું રન લખો, ત્યારે તે ચાલી રહ્યું છે
આ પર બંધ કરવા માટે -

627
00:38:49,230 --> 00:38:52,180
ooh, કારણ કે, માતાનો પુનઃકમ્પાઈલ દો
હું વસ્તુઓ બદલ્યો છે.

628
00:38:52,180 --> 00:38:55,950
તમે આ રેખા, ચેતવણી સોર્સ જોશો
ફાઇલ ચલાવી શકાય તેવી કરતાં વધુ થયેલા છે.

629
00:38:55,950 --> 00:38:59,680
જેથી હું હમણાં જ અહીં ગયા અર્થ એ થાય કે
અને પ્રકાર ખાતરી કરવા માટે આ ફેરફાર

630
00:38:59,680 --> 00:39:03,100
50, પરંતુ હું પુનઃકમ્પાઈલ ન હતી
કાર્યક્રમ.

631
00:39:03,100 --> 00:39:04,870
તેથી GDB કે મને જાણે છે.

632
00:39:04,870 --> 00:39:10,130
હું ફરીથી ડિબગ કરો, બહાર નીકળવા પડશે
GDB ડિબગ નહીં.

633
00:39:10,130 --> 00:39:10,700
બરાબર.

634
00:39:10,700 --> 00:39:12,800
>> તેથી હવે, પાછા હું શું કરી હતી છે.

635
00:39:12,800 --> 00:39:15,720
મુખ્ય, વિરામ foo તૂટી જાય છે.

636
00:39:15,720 --> 00:39:20,680
હવે હું આ કાર્યક્રમ ચલાવવા છે, એટલે જો
હિટ ન થાય ત્યાં સુધી જઈ એક

637
00:39:20,680 --> 00:39:21,320
બ્રેકપોઇન્ટ.

638
00:39:21,320 --> 00:39:24,680
તે બ્રેકપોઇન્ટ થાય છે
મુખ્ય અંતે પ્રથમ એક છે.

639
00:39:24,680 --> 00:39:28,630
હવે, તેના બદલે આગામી કરવાની, આગળ, આગળ,
આગળ, આગળ, હું foo હિટ, ત્યાં સુધી હું

640
00:39:28,630 --> 00:39:35,230
ચાલુ રહેશે, જે ચાલુ ટાઈપ કરી શકો છો
તમે આગામી બ્રેકપોઇન્ટ હિટ સુધી.

641
00:39:35,230 --> 00:39:37,200
હું પ્રથમ પૂર્ણાંક દાખલ કરવાનો રહે છે.

642
00:39:37,200 --> 00:39:40,570
હું હિટ સુધી ચાલુ રહેશે ચાલુ રાખો
છે જે આગામી બ્રેકપોઇન્ટ,

643
00:39:40,570 --> 00:39:43,320
foo કાર્ય.

644
00:39:43,320 --> 00:39:50,130
>> તમે હિટ સુધી તેથી રન ચાલશે
જ્યારે બ્રેકપોઇન્ટ, પરંતુ તમે માત્ર રન લખો

645
00:39:50,130 --> 00:39:54,060
તમે, પછી કાર્યક્રમ શરૂ, અને કરી રહ્યાં છો
પછી થી, તે તમને ચાલુ છે.

646
00:39:54,060 --> 00:40:01,950
હું માત્ર મુખ્ય તોડી હતી અને જો
પછી ચાલી હતી, તેના પર તૂટી પડશે

647
00:40:01,950 --> 00:40:03,670
પછી મુખ્ય, અને ચાલુ રાખો.

648
00:40:03,670 --> 00:40:10,050
હું foo અંતે વિરામ બિંદુ છે, ન હોવાથી
પૂર્ણાંક દાખલ કરો, પછી હવે હું છું

649
00:40:10,050 --> 00:40:11,380
foo પર જતું નથી ચાલી રહ્યું.

650
00:40:11,380 --> 00:40:16,318
તે માત્ર અનંત બનશે
કે ત્યાં સુધી લૂપ.

651
00:40:16,318 --> 00:40:17,568
બરાબર.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> જેથી GDB માટે પ્રસ્તાવના છે.

654
00:40:24,420 --> 00:40:27,790
તમે તેનો ઉપયોગ શરૂ કરીશું
તમારી સમસ્યા સેટમાં.

655
00:40:27,790 --> 00:40:30,550
તે ખૂબ જ ઉપયોગી સાબિત થઈ શકે છે
ભૂલો ઓળખવા માટે.

656
00:40:30,550 --> 00:40:35,280
તમે ખરેખર માત્ર વાક્ય દ્વારા વાક્ય, જાઓ
તમારો કોડ છે, અને શું કરો

657
00:40:35,280 --> 00:40:39,740
ખરેખર તમે શું અપેક્ષા સાથે થઈ રહ્યું
થાય છે, પછી તે ખૂબ છે

658
00:40:39,740 --> 00:40:41,060
તમારી ભૂલો સહેલાઈથી સમજાવી શકીશું.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
બરાબર.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> તેથી છેલ્લા અઠવાડિયે ડેવિડ આ લાવવામાં
આ માટે ગુપ્ત કી ક્રિપ્ટોગ્રાફી સામગ્રી

663
00:40:54,040 --> 00:40:59,350
અમે ઈચ્છા જ્યાં નહિ પ્રથમ વખત,
પાસવર્ડ માત્ર પર સંગ્રહ કરી અમારા

664
00:40:59,350 --> 00:41:03,210
કેટલાક સાદા લખાણ ફાઈલમાં કમ્પ્યુટર, જ્યાં
કોઈને પર અને માત્ર આવી શકે

665
00:41:03,210 --> 00:41:04,660
તે ખોલો અને તેમને વાંચો.

666
00:41:04,660 --> 00:41:07,530
આદર્શ રીતે, તેઓ એનક્રિપ્ટ થયેલ આવશે
અમુક રીતે.

667
00:41:07,530 --> 00:41:13,340
અને સમસ્યા સેટ 2, તમારી વ્યવહાર કરવામાં આવશે
એનક્રિપ્શન એક પદ્ધતિ સાથે,

668
00:41:13,340 --> 00:41:16,520
અથવા, સાથે સાથે, બે પદ્ધતિઓ છે, પરંતુ
તેઓ મહાન નથી.

669
00:41:16,520 --> 00:41:20,050
તમે હેકર આવૃત્તિ હોય, તો તમે છો
પણ સાથે કામ કરી રહ્યા

670
00:41:20,050 --> 00:41:22,150
કેટલીક વસ્તુઓ ડિક્રિપ્ટ.

671
00:41:22,150 --> 00:41:29,770
>> તેથી આ મુદ્દો હવે સાથે સાથે, પણ જો છે
અમે મજબૂત એનક્રિપ્શન છે

672
00:41:29,770 --> 00:41:34,830
વિશ્વમાં અલ્ગોરિધમનો, જો તમે પસંદ કરો
ખાસ કરીને ગરીબ પાસવર્ડ, પછી તે

673
00:41:34,830 --> 00:41:37,720
, તમે ખૂબ ખૂબ મદદ કરશે કારણ કે લોકો
હજુ પણ તે બહાર આકૃતિ કરવાનો પ્રયત્ન કરશે.

674
00:41:37,720 --> 00:41:41,530
એનક્રિપ્ટ થયેલ શબ્દમાળા જોઈ અને તો પણ
તે કચરો એક વાસણ જેવો દેખાય છે

675
00:41:41,530 --> 00:41:44,760
જો કે, તેમને માટે કંઈ થાય છે તેઓ
હજુ હમણાં જ થોડા પાસવર્ડ પ્રયાસ કરવાની જરૂર છે

676
00:41:44,760 --> 00:41:50,560
તમે પછી, તે બહાર આકૃતિ
ખૂબ જ સુરક્ષિત નથી.

677
00:41:50,560 --> 00:41:55,890
તેથી એક વિડિઓ જોઈ કે
તે બિંદુ છે.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [વિડિઓ પ્લેબેક]

680
00:42:00,970 --> 00:42:02,100
>> -હેલ્મેટ, તમે અતિ ઘાતકી.

681
00:42:02,100 --> 00:42:03,370
શું થઈ રહ્યું છે તે?

682
00:42:03,370 --> 00:42:05,170
તમે મારા પુત્રી માટે કરી રહ્યા છે?

683
00:42:05,170 --> 00:42:09,910
>> તેજસ્વી દાખલ મને પરમિટ
યુવાન પ્લાસ્ટિક સર્જન ડો ફિલિપ

684
00:42:09,910 --> 00:42:13,730
Schlotkin, મહાન નાક
સમગ્ર નોકરીના માણસ

685
00:42:13,730 --> 00:42:16,080
બ્રહ્માંડ અને બેવર્લી હિલ્સ.

686
00:42:16,080 --> 00:42:17,210
>> યોર મહત્તા.

687
00:42:17,210 --> 00:42:18,070
>> -નાક કામ?

688
00:42:18,070 --> 00:42:18,670
હું સમજી શક્યા નથી.

689
00:42:18,670 --> 00:42:20,090
તેમણે પહેલેથી જ નાક કામ હતું છે.

690
00:42:20,090 --> 00:42:21,910
તે એક મીઠી સોળ હાજર હતા.

691
00:42:21,910 --> 00:42:22,140
>> કોઈ.

692
00:42:22,140 --> 00:42:23,690
તે તમને શું લાગે છે નથી.

693
00:42:23,690 --> 00:42:25,420
તે ખૂબ, ખૂબ ખરાબ છે.

694
00:42:25,420 --> 00:42:30,300
તમે મને મિશ્રણ આપતા ન હોય તો
હવામાં ઢાલ, ડો Schlotkin કરશે

695
00:42:30,300 --> 00:42:34,226
તેમના જૂના નાક તમારી દીકરી પાછા આપે છે.

696
00:42:34,226 --> 00:42:35,476
>> કોઈ.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
જ્યાં તમે તે મેળવી હતી?

699
00:42:40,516 --> 00:42:41,440
>> -અધિકાર છે.

700
00:42:41,440 --> 00:42:42,180
હું કહી શકશો.

701
00:42:42,180 --> 00:42:43,381
હું કહી શકશો.

702
00:42:43,381 --> 00:42:44,263
ના, ડેડી.

703
00:42:44,263 --> 00:42:45,590
ના, તમે ન કરવી જોઈએ.

704
00:42:45,590 --> 00:42:46,860
>> -રહ્યાં છો અધિકાર, મારી પ્રિય.

705
00:42:46,860 --> 00:42:48,450
હું તમારા નવા નાક ચૂકી પડશે.

706
00:42:48,450 --> 00:42:52,090
પરંતુ હું તેમને મિશ્રણ કહી શકતા નથી,
કોઈ બાબત શું.

707
00:42:52,090 --> 00:42:53,680
>> સારી રીતે ખૂબ.

708
00:42:53,680 --> 00:42:55,685
ડો Schlotkin, તમારા સૌથી ખરાબ હોય છે.

709
00:42:55,685 --> 00:42:56,914
>> -મારો આનંદ.

710
00:42:56,914 --> 00:43:00,690
>> [સાધનો sharpened હોવા પર]

711
00:43:00,690 --> 00:43:01,910
>> કોઈ.

712
00:43:01,910 --> 00:43:02,520
રાહ જુઓ.

713
00:43:02,520 --> 00:43:03,836
રાહ જુઓ.

714
00:43:03,836 --> 00:43:05,300
હું કહી શકશો.

715
00:43:05,300 --> 00:43:06,880
હું કહી શકશો.

716
00:43:06,880 --> 00:43:09,130
>> હું તે કામ કરશે હતા.

717
00:43:09,130 --> 00:43:09,900
અધિકાર છે.

718
00:43:09,900 --> 00:43:12,850
તે મને આપો.

719
00:43:12,850 --> 00:43:16,918
>> -મિશ્રણ છે.

720
00:43:16,918 --> 00:43:17,406
>> વન.

721
00:43:17,406 --> 00:43:18,382
>> વન.

722
00:43:18,382 --> 00:43:19,358
>> બે.

723
00:43:19,358 --> 00:43:19,846
>> બે.

724
00:43:19,846 --> 00:43:20,822
>> બે.

725
00:43:20,822 --> 00:43:21,310
>> થ્રી.

726
00:43:21,310 --> 00:43:21,798
>> થ્રી.

727
00:43:21,798 --> 00:43:22,774
>> થ્રી.

728
00:43:22,774 --> 00:43:23,262
>> ચાર.

729
00:43:23,262 --> 00:43:23,750
>> ચાર.

730
00:43:23,750 --> 00:43:26,150
>> ચાર.

731
00:43:26,150 --> 00:43:27,010
>> -પાંચ.

732
00:43:27,010 --> 00:43:27,670
>> -પાંચ.

733
00:43:27,670 --> 00:43:29,010
>> -પાંચ.

734
00:43:29,010 --> 00:43:34,770
>> -તેથી મિશ્રણ, એક છે
બે, ત્રણ, ચાર, પાંચ.

735
00:43:34,770 --> 00:43:37,460
કે stupidest મિશ્રણ છે
હું ક્યારેય મારા જીવનમાં સાંભળ્યું.

736
00:43:37,460 --> 00:43:39,710
કે વસ્તુ પ્રકાર એક મૂર્ખ માણસ છે
પોતાના સામાન પર હશે.

737
00:43:39,710 --> 00:43:42,000
>> તમારી મહત્તા, તમે આભાર.

738
00:43:42,000 --> 00:43:43,530
>> શું તમે કરો છો?

739
00:43:43,530 --> 00:43:44,490
>> હું બોલ દીવાલ નહીં.

740
00:43:44,490 --> 00:43:45,420
>> કોઈ તમે નથી.

741
00:43:45,420 --> 00:43:45,840
તમે સમગ્ર ફિલ્મ નહીં.

742
00:43:45,840 --> 00:43:46,930
>> -I ખોટું બટન દબાવવામાં જ જોઈએ.

743
00:43:46,930 --> 00:43:48,265
>> વેલ, તે પાછી ફેરવી છે.

744
00:43:48,265 --> 00:43:49,110
પાછળ ફિલ્મ મૂકો.

745
00:43:49,110 --> 00:43:49,510
>> હા, સર.

746
00:43:49,510 --> 00:43:49,917
હા, સર.

747
00:43:49,917 --> 00:43:50,324
>> માતાનો, આર્નોલ્ડ ગો દો.

748
00:43:50,324 --> 00:43:51,140
, Gretchen આવો.

749
00:43:51,140 --> 00:43:53,060
અલબત્ત, તમે હું હજુ પણ પડશે ખબર
આ માટે તમે બિલ છે.

750
00:43:53,060 --> 00:43:53,440
>> [સમાપ્ત વિડિઓ પ્લેબેક]

751
00:43:53,440 --> 00:43:54,690
>> રોબ Boden: અધિકાર છે.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
અમે પહેલાથી જ વિશે વાત કરી રહ્યા છીએ તેથી હવે
કેટલીક રીતે સુરક્ષા, સરસ

754
00:44:08,430 --> 00:44:16,050
થોડી ફિલ્મ પોસ્ટર છે, તેથી હાલ માં
જો NSA સાથે દિવસ, આ મુદ્દાઓ

755
00:44:16,050 --> 00:44:17,300
બધું નિરીક્ષણ.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
તે તમને લાગે છે કે મુશ્કેલ હોઈ શકે છે
આ ગોપનીયતા અમુક પ્રકારની છે

758
00:44:26,930 --> 00:44:34,540
ઓનલાઇન વિશ્વમાં, હું કહી શકે છે, તેમ છતાં
તમે પ્રિઝમ વિગતો મોટા ભાગના.

759
00:44:34,540 --> 00:44:42,130
તેથી પ્રિઝમ બહાર ખસેડવા, અમે જઈ રહ્યાં છો
હવે, તે વિશે વાત કરી

760
00:44:42,130 --> 00:44:44,030
તમારા લેપટોપ વિશે વિચારો.

761
00:44:44,030 --> 00:44:48,360
તેથી અહીં, હું સ્વિચ કરવા માંગો છો
મારા વાસ્તવિક એકાઉન્ટ માટે,

762
00:44:48,360 --> 00:44:50,370
મારા ઓછી પેંગ્વિન સાથે.

763
00:44:50,370 --> 00:44:57,310
તેથી હું પાસવર્ડ સુયોજિત કરો છે, અને તે
પાસવર્ડ હું તે કરવા માંગો છો ગમે છે.

764
00:44:57,310 --> 00:45:02,430
>> પરંતુ યાદ રાખો કે શું હું લૉગિન છું
, તેથી આ પ્રવેશ સાથે

765
00:45:02,430 --> 00:45:04,850
પ્રોમ્પ્ટ પર, કેટલાક પ્રોગ્રામ છે.

766
00:45:04,850 --> 00:45:07,910
તે કે જે અમુક કાર્યક્રમ છે
કેટલાક વ્યક્તિ દ્વારા લખવામાં.

767
00:45:07,910 --> 00:45:13,250
અને તેથી, તે વ્યક્તિ, જો તેઓ છે
ખાસ કરીને ખરાબ છે, તેઓ કરી શકે છે

768
00:45:13,250 --> 00:45:17,780
કહ્યું છે, બધા હક છે, તેથી જો પાસવર્ડ
હું દાખલ કે સમાન છે મારા

769
00:45:17,780 --> 00:45:22,800
વાસ્તવિક પાસવર્ડ, અથવા તે સમાન છે
કેટલાક ખાસ પાસવર્ડ માટે -

770
00:45:22,800 --> 00:45:25,550
ડેવિડ ભયાનક અથવા કંઈક છે -

771
00:45:25,550 --> 00:45:27,190
પછી તેમને સાઇન દો

772
00:45:27,190 --> 00:45:33,760
તેથી દૂષિત પ્રોગ્રામર કરી શકે છે
તમારા મેક્સ તમામ, અથવા વપરાશ

773
00:45:33,760 --> 00:45:36,150
વિન્ડોઝ, અથવા કંઈપણ.

774
00:45:36,150 --> 00:45:41,980
>> જેથી, કારણ કે, એક ચિંતા મોટા નથી
હું તેનો અર્થ, આ પ્રવેશ એ કાર્યક્રમ છે

775
00:45:41,980 --> 00:45:48,720
કે ઓએસ એક્સ, સેંકડો સાથે આવે છે
અથવા હજારો લોકોની છે

776
00:45:48,720 --> 00:45:50,020
આ કોડ સમીક્ષા કરી હતી.

777
00:45:50,020 --> 00:45:55,330
અને તેથી, જો તમે ક્યાંક તમારા કોડમાં, જો
આ શબ્દમાળા સમકક્ષ સમકક્ષ હોય તો કહી

778
00:45:55,330 --> 00:45:58,860
ડેવિડ અદ્ભુત છે, પ્રવેશ, પછી કોઈને છે
જ હશે, જેમ કે, રાહ જુઓ.

779
00:45:58,860 --> 00:45:59,800
આ યોગ્ય નથી.

780
00:45:59,800 --> 00:46:01,790
આ અહીં ન હોવી જોઈએ.

781
00:46:01,790 --> 00:46:06,650
જેથી અમે વસ્તુઓ માત્ર એક રીત છે
પ્રકારની સુરક્ષિત છે.

782
00:46:06,650 --> 00:46:10,300
>> પણ કાર્યક્રમો વિશે વિચારો
તમે લખી છે.

783
00:46:10,300 --> 00:46:13,000
માતાનો તમને પ્રવેશ કાર્યક્રમ લખ્યું કહો.

784
00:46:13,000 --> 00:46:20,440
તમે લખ્યું કે તેથી આ પ્રવેશ કાર્યક્રમ,
તેથી દેખીતી રીતે, તમે એક સારા છે

785
00:46:20,440 --> 00:46:21,210
પ્રોગ્રામર.

786
00:46:21,210 --> 00:46:25,610
તમે કોઇપણ દૂષિત મૂકવા જઈ રહ્યાં છો
X સમકક્ષ સમકક્ષ જો ડેવિડ ભયાનક છે

787
00:46:25,610 --> 00:46:27,860
તમારા કોડમાં.

788
00:46:27,860 --> 00:46:31,930
પરંતુ આ કાર્યક્રમ, તમે શું
આ કાર્યક્રમ કમ્પાઇલ ઉપયોગ?

789
00:46:31,930 --> 00:46:34,180
રણકાર કંઈક.

790
00:46:34,180 --> 00:46:38,460
તેથી શું થયું જો જે વ્યક્તિ
રણકાર માં cased રણકાર ખાસ લખી

791
00:46:38,460 --> 00:46:44,310
કંઈક, જેમ હું સંકલન છું જો
કાર્યક્રમ પ્રવેશ, તો પછી આ કોડ દાખલ કરો

792
00:46:44,310 --> 00:46:49,720
તો કહે છે કે પ્રવેશ પ્રોગ્રામમાં
X સમકક્ષ ડેવિડ અદ્ભુત છે જેટલી જ થાય છે?

793
00:46:49,720 --> 00:46:59,890
તેથી તદ્દન હજુ સુધી, પરંતુ અમે એ જ છે
અહીં જારી, જ્યાં રણકાર, સાથે સાથે,

794
00:46:59,890 --> 00:47:03,790
હજારો નહીં તો દસ હજારો
લોકો છે, રણકાર પર ધ્યાન આપવામાં આવે છે

795
00:47:03,790 --> 00:47:07,160
કોડ તેના લીટીઓ પર હતા અને કહ્યું હતું કે,
બધા હક છે, અહીં ખરાબ કશું જ નથી.

796
00:47:07,160 --> 00:47:10,680
દેખીતી રીતે, કોઈ એક કરી રહ્યા છે
આ દૂષિત કંઈપણ.

797
00:47:10,680 --> 00:47:15,780
>> પરંતુ, જેમ કે, પોતે રણકાર છે
શું હું રણકાર સંકલન તો શું?

798
00:47:15,780 --> 00:47:20,900
શું હું કેટલાક કમ્પાઇલર છે કે જો
રણકાર માં દાખલ કે રણકાર કમ્પાઇલ

799
00:47:20,900 --> 00:47:25,610
કહે છે કે આ ખાસ હેક, બધા હક છે,
હું રણકાર સંકલન છે, પછી

800
00:47:25,610 --> 00:47:31,290
ચલાવી શકાય તેવી હું ખાસ જોવું જોઈએ કરો
પ્રવેશ કાર્યક્રમ અને શામેલ ની અંદર

801
00:47:31,290 --> 00:47:34,230
આ પાસવર્ડ, સમકક્ષ સમકક્ષ હોય
ડેવ અદ્ભુત છે?

802
00:47:34,230 --> 00:47:37,990
તેથી યાદ રાખો કે તમારા કમ્પાઇલર પોતે
અમુક સમયે સંકલિત કરવાની જરૂર છે.

803
00:47:37,990 --> 00:47:42,810
તેથી તમે રણકાર કમ્પાઇલ પસંદ જો
પોતે પછી તમે દૂષિત છે સાથે

804
00:47:42,810 --> 00:47:45,580
સમગ્ર ઘણું ખરાબ કરી શકાય
માર્ગ નીચે લીટી.

805
00:47:45,580 --> 00:47:49,630
>> અહીં, અમે કેન થોમ્પસન છે
અને ડેનિસ રિચી.

806
00:47:49,630 --> 00:47:53,780
તેથી આ એક આઇકોનિક ફોટો છે.

807
00:47:53,780 --> 00:47:55,470
ડેનિસ રિચી જ અધિકાર છે.

808
00:47:55,470 --> 00:47:58,740
તેમણે એક મુખ્ય છે -

809
00:47:58,740 --> 00:48:03,640
ખૂબ ખૂબ સી લખ્યું તેથી તમે કરી શકો છો
આ વર્ગ માટે તેનો આભાર.

810
00:48:03,640 --> 00:48:04,840
કેન થોમસન ડાબી પર છે.

811
00:48:04,840 --> 00:48:07,780
તેમને બે મૂળભૂત રીતે એ UNIX લખ્યું હતું.

812
00:48:07,780 --> 00:48:10,140
ઠીક છે, તેઓ મુખ્ય યોગદાન હતા
UNIX માં.

813
00:48:10,140 --> 00:48:11,310
કેટલાક અન્ય લોકો હતા.

814
00:48:11,310 --> 00:48:16,240
અમુક સમયે તેથી કેન થોમ્પસન,
તેમણે ટ્યુરિંગ એવોર્ડ જીતી જાય છે.

815
00:48:16,240 --> 00:48:20,860
અને ટ્યુરિંગ એવોર્ડ, હું હંમેશા સાંભળ્યું કર્યું
તે આ રીતે સંદર્ભ છે, તે છે

816
00:48:20,860 --> 00:48:23,100
કોમ્પ્યુટર વિજ્ઞાન નોબેલ પારિતોષિક.

817
00:48:23,100 --> 00:48:27,500
>> તેથી ટ્યુરિંગ એવોર્ડ ખાતે તેઓ છે
પોતાના આભાર પ્રવચનમાં આપે છે.

818
00:48:27,500 --> 00:48:31,790
અને તે આ ખૂબ જ પ્રખ્યાત ભાષણ આપે છે
હવે, વિશ્વાસ પ્રતિબિંબ કહેવાય

819
00:48:31,790 --> 00:48:35,620
અમે કડી થયેલ છે, જે ટ્રસ્ટ,
કોર્સ વેબસાઇટ પર છે.

820
00:48:35,620 --> 00:48:41,670
અને આ વકતવ્યમાં, તેમણે, બધા હક છે, કહે છે
તેથી હું એ UNIX લખ્યું હતું, અને હવે સૌ

821
00:48:41,670 --> 00:48:43,320
તમે લોકો એ UNIX ઉપયોગ કરી રહ્યા છો.

822
00:48:43,320 --> 00:48:46,960
હવે, Linux ને કે આજે યાદ
યુનિક્સ એક સીધા વંશજ.

823
00:48:46,960 --> 00:48:50,140
ઓએસ એક્સ સીધા એ UNIX ઉપયોગ કરે છે.

824
00:48:50,140 --> 00:48:53,810
વિન્ડોઝ ખૂબ જ કરે છે, પરંતુ ઘણી
વિચારો UNIX માંથી લેવામાં આવ્યા હતા.

825
00:48:53,810 --> 00:48:59,220
>> તેથી તેમણે સ્ટેજ સુધી જાય છે અને કહે છે
બધા હક છે, હું એ UNIX લખ્યું હતું.

826
00:48:59,220 --> 00:49:03,940
અને એ જ તમે ગાય્સ જાણો છો, હું છું
દરેક પ્રવેશ કરવાનો

827
00:49:03,940 --> 00:49:05,590
તમારા કમ્પ્યુટર્સ એક એક.

828
00:49:05,590 --> 00:49:14,280
X જો હું આ ખાસ એક મૂકી થી
જેટલી જ થાય છે, કેન થોમસન અદ્ભુત છે જેટલી જ થાય છે

829
00:49:14,280 --> 00:49:16,350
પછી હું પ્રવેશ માટે માન્ય છું.

830
00:49:16,350 --> 00:49:18,370
તેથી લોકો, પણ જેવા છે
how'd તમે આ કરી?

831
00:49:18,370 --> 00:49:21,090
અમે લૉગિન કાર્યક્રમ જોવામાં
અને કશું જ નથી.

832
00:49:21,090 --> 00:49:24,700
તેમણે સાથે સાથે, હું પણ કમ્પાઇલર ફેરફાર, જેવું છે
પ્રવેશ કાર્યક્રમ પ્રવેશ કરવા માટે

833
00:49:24,700 --> 00:49:30,490
પ્રવેશ કાર્યક્રમ હવે છે કે જેથી
કે એક્સ કેન થોમ્પસન સમકક્ષ સમકક્ષ હોય છે

834
00:49:30,490 --> 00:49:31,700
અદ્ભુત છે.

835
00:49:31,700 --> 00:49:33,120
>> અને તેઓ સારી રીતે, તે સાચું નથી, કહે છે.

836
00:49:33,120 --> 00:49:35,740
અમે કમ્પાઇલર જોઈ, અને કરી રહ્યાં છો
કમ્પાઇલર કોઇ લાઇન નથી

837
00:49:35,740 --> 00:49:36,400
જેમ કોડ.

838
00:49:36,400 --> 00:49:40,540
તેમણે બરાબર, જેવું છે, પરંતુ તમે શું છે
કમ્પાઇલર સાથે સંકલન?

839
00:49:40,540 --> 00:49:44,810
અને, સાથે સાથે, જેમ તેઓ લાગે છે, અને તે છે
હું તમને કમ્પાઇલર આપ્યો જે એક છું

840
00:49:44,810 --> 00:49:50,580
તમે પણ કમ્પાઇલર કમ્પાઇલ ઉપયોગ કરીને, તેથી રહ્યા છો
તમે કમ્પાઇલર કમ્પાઇલ કરવામાં આવે છે

841
00:49:50,580 --> 00:49:56,390
પોતે દૂષિત છે, અને કરશે
પ્રવેશ કાર્યક્રમ તૂટી જાય છે.

842
00:49:56,390 --> 00:49:59,360
જેથી મૂળભૂત છે, તે સમયે, ત્યાં
તમે સ્ત્રોત પર નજર શકે કોઈ રીતે

843
00:49:59,360 --> 00:50:02,450
પ્રવેશ કાર્યક્રમની કોડ
ખોટું છે તે જોવા માટે.

844
00:50:02,450 --> 00:50:04,220
તમે પણ જુઓ શકે છે
કમ્પાઇલર સ્રોત કોડ

845
00:50:04,220 --> 00:50:06,790
ખોટું છે તે જોવા માટે.

846
00:50:06,790 --> 00:50:11,940
>> તમે મશીન જોવા જરૂર છે
કોડ છે, એ ના વાસ્તવિક દ્વિસંગી

847
00:50:11,940 --> 00:50:16,760
આ, રાહ જુઓ, તે જોવા માટે સંકલિત કમ્પાઇલર
કોડ ઓફ રેખાઓ અહીં ન હોવી જોઈએ.

848
00:50:16,760 --> 00:50:22,130
પરંતુ કેન થોમ્પસન તે એક પગલું ભર્યું
વધુ અને સાથે સાથે, ત્યાં જણાવ્યું હતું કે,

849
00:50:22,130 --> 00:50:25,980
આ ખાસ કાર્યક્રમો કે જે વાસ્તવમાં
તમે કાર્યક્રમો બાઈનરી વાંચી મદદ,

850
00:50:25,980 --> 00:50:29,340
અને તેથી કોઈને કે કાર્યક્રમ ઉપયોગ જો
બાઈનરી વાંચો, તેઓ આ જુઓ છો

851
00:50:29,340 --> 00:50:30,490
કોડ ઓફ રેખાઓ.

852
00:50:30,490 --> 00:50:34,020
તેમણે તમામ કહે છે, તે કાર્યક્રમો ફેરફાર
અધિકાર, તમે જોઈ રહ્યાં છો

853
00:50:34,020 --> 00:50:38,460
કમ્પાઇલર, આ ચોક્કસ બતાવતા નથી
દ્વિસંગીની સમૂહ.

854
00:50:38,460 --> 00:50:42,830
>> તેથી પછી તમે લેવાની જરૂર છે કે જે પગલું
વધુ અને સામાન્ય રીતે, કે કરી શકે છે

855
00:50:42,830 --> 00:50:46,210
પરોક્ષ રીત ના લેવામાં બહુવિધ સ્તરે,
અને અમુક સમયે, કોઈ એક ખરેખર છે

856
00:50:46,210 --> 00:50:47,990
ચકાસણી કરી રહ્યા.

857
00:50:47,990 --> 00:50:52,590
તેથી વાર્તા નૈતિક તમે, છે
લખી શકાય જઈ નથી

858
00:50:52,590 --> 00:50:54,340
આ વર્ગ માં રણકાર.

859
00:50:54,340 --> 00:50:57,020
તમે ચડતા ઉપયોગ કરી રહ્યા છીએ
આ વર્ગ ઘણો રણકાર.

860
00:50:57,020 --> 00:51:00,490
તમે જાણો છો બધા માટે, રણકાર દૂષિત છે
દરેક sabotaging છે કે કાર્યક્રમ

861
00:51:00,490 --> 00:51:03,520
એક કાર્યક્રમ તમે ક્યારેય તૈયાર કરી છે.

862
00:51:03,520 --> 00:51:08,206
અને તે ખૂબ જ અપશુકનિયાળ પર તમે છોડી
બુધવારે તમે જુઓ, નોંધ કરો.

863
00:51:08,206 --> 00:51:10,030
>> [વધાવી]

864
00:51:10,030 --> 00:51:12,935
>> 2 વક્તા: આગામી CS50 ખાતે.

865
00:51:12,935 --> 00:51:14,580
>> 3 વક્તા: તમે તે કબૂલ કરું છું નથી.

866
00:51:14,580 --> 00:51:15,930
તમે કરી શકો છો.

867
00:51:15,930 --> 00:51:19,440
તમે તે પહેલાં પણ કરેલું છે, તમે આ કરી શકો છો
આજે, તમે આવતી કાલે કરી શકો છો.

868
00:51:19,440 --> 00:51:20,930
તમે વર્ષ માટે આ કરી રહ્યો છું.

869
00:51:20,930 --> 00:51:22,790
માત્ર ત્યાં જાઓ અને આવું.

870
00:51:22,790 --> 00:51:24,310
તમે કરી શકો છો.

871
00:51:24,310 --> 00:51:26,102
>> [સંગીત વગાડવાનો]