1
00:00:00,000 --> 00:00:05,640

2
00:00:05,640 --> 00:00:06,830
>> ડો LLOYD: બધા અધિકાર GDB.

3
00:00:06,830 --> 00:00:08,480
તે બરાબર શું છે?

4
00:00:08,480 --> 00:00:11,310
રહે છે, જે તેથી GDB,
GNU ડિબગર માટે,

5
00:00:11,310 --> 00:00:15,040
ખરેખર અદ્ભુત સાધન છે કે અમે કરી શકે છે
અમારા કાર્યક્રમો ડિબગ અમને મદદ કરવા માટે ઉપયોગ,

6
00:00:15,040 --> 00:00:18,210
અથવા વસ્તુઓ છે જ્યાં શોધવા
અમારા કાર્યક્ર ખોટું જઈ રહી છે.

7
00:00:18,210 --> 00:00:22,590
GDB, આશ્ચર્યજનક શક્તિશાળી છે, પરંતુ
તે સાથે આઉટપુટ અને ક્રિયાપ્રતિક્રિયા

8
00:00:22,590 --> 00:00:23,830
થોડો ભેદી હોઈ શકે છે.

9
00:00:23,830 --> 00:00:28,210
તે સામાન્ય રીતે એક આદેશ વાક્ય સાધન છે, અને
તે તમને સંદેશાઓ ઘણો ફેંકવું કરી શકો છો.

10
00:00:28,210 --> 00:00:31,144
અને તે પ્રકારની હાર્ડ કરી શકો છો
પર રહ્યું છે બરાબર શું પાર્સ.

11
00:00:31,144 --> 00:00:33,560
સદનસીબે, અમે ભર્યું પગલાંઓ
તમારા માટે આ સમસ્યા સુધારવા માટે

12
00:00:33,560 --> 00:00:36,281
તમે CS50 મારફતે કાર્ય કરે છે.

13
00:00:36,281 --> 00:00:39,030
તમે ગ્રાફિકલ વાપરી રહ્યા નહિં હોય, તો
ડીબગર, જે મારા સાથીદાર ડેન

14
00:00:39,030 --> 00:00:41,570
Armandarse તદ્દન બોલાય છે
વિડિઓ વિશે થોડી કે

15
00:00:41,570 --> 00:00:44,740
અહીં પ્રયત્ન કરીશું
હમણાં, તમે જરૂર પડી શકે

16
00:00:44,740 --> 00:00:48,270
આ આદેશ વાક્ય વાપરવા માટે
સાધનો GDB સાથે કામ કરવા માટે.

17
00:00:48,270 --> 00:00:51,250
તમે CS50 માં કામ કરી રહ્યાં છો
IDE, તમે આ કરવા માટે જરૂર નથી.

18
00:00:51,250 --> 00:00:53,550
પરંતુ તમે ન હો તો
આ CS50 IDE કામ,

19
00:00:53,550 --> 00:00:55,750
કદાચ આવૃત્તિ વાપરી
CS50 સાધન છે,

20
00:00:55,750 --> 00:00:58,860
અથવા અન્ય Linux ઓપરેટિંગ
GDB સાથે સિસ્ટમ પર સ્થાપિત

21
00:00:58,860 --> 00:01:00,980
તમે ઉપયોગ કરવાની જરૂર પડી શકે
આ આદેશ વાક્ય સાધનો.

22
00:01:00,980 --> 00:01:02,860
>> અને ત્યારથી તમે કદાચ
તે છે, તે કરવા માટે હોય

23
00:01:02,860 --> 00:01:06,280
માત્ર કેવી રીતે સમજવા માટે ઉપયોગી
GDB આદેશ વાક્યમાંથી કામ કરે છે.

24
00:01:06,280 --> 00:01:09,650
પરંતુ ફરીથી, તમે છો, તો
આ CS50 IDE ઉપયોગ કરીને, તમે

25
00:01:09,650 --> 00:01:15,400
ગ્રાફિકવાળા ડીબગર ઉપયોગ કરી શકો છો
કે IDE માં સમાયેલ છે.

26
00:01:15,400 --> 00:01:18,750
તેથી વસ્તુઓ સાથે જઈને વિચાર
GDB, ડિબગીંગ શરૂ કરવા માટે

27
00:01:18,750 --> 00:01:21,220
ચોક્કસ પ્રક્રિયા
કાર્યક્રમ, બધા તમે શું જરૂર

28
00:01:21,220 --> 00:01:23,810
GDB અનુસરવામાં પ્રકાર છે
કાર્યક્રમ નામ દ્વારા.

29
00:01:23,810 --> 00:01:28,620
તેથી ઉદાહરણ તરીકે, તમારા કાર્યક્રમ છે, તો
હેલો, તમે GDB હેલો લખો છો.

30
00:01:28,620 --> 00:01:31,210
>> તમે તે કરી, ત્યારે તમે જઈ રહ્યાં છો
આ GDB પર્યાવરણ ખેંચી.

31
00:01:31,210 --> 00:01:33,800
સત્વરે બદલવા માટે, અને કરશે
તેના બદલે હોવાની સામાન્ય રીતે તે શું

32
00:01:33,800 --> 00:01:35,841
તમે વસ્તુઓ લખો ત્યારે છે
આદેશ વાક્ય LS પર,

33
00:01:35,841 --> 00:01:38,115
તમારી લાક્ષણિક તમામ cd--
Linux, તમારા પ્રોમ્પ્ટ આદેશો

34
00:01:38,115 --> 00:01:42,200
કદાચ કંઈક માટે બદલાશે
કૌંસ જેવા GDB કૌંસ.

35
00:01:42,200 --> 00:01:46,630
કારણ કે તે, તમારા નવા GDB પ્રોમ્પ્ટ છે
તમે GDB પર્યાવરણ અંદર છો.

36
00:01:46,630 --> 00:01:49,830
એકવાર પર્યાવરણ અંદર,
બે મુખ્ય આદેશો છે

37
00:01:49,830 --> 00:01:52,290
તમે કદાચ ઉપયોગ કરશો
નીચેના ક્રમમાં.

38
00:01:52,290 --> 00:01:55,200
>> પ્રથમ બી, જે
વિરામ માટે ટૂંકા હોય છે.

39
00:01:55,200 --> 00:01:58,690
અને તમે બી, તમે સામાન્ય રીતે લખો પછી
એક કાર્ય નું નામ લખો

40
00:01:58,690 --> 00:02:01,040
અથવા તમે જાણતા થાય તો
શું લાઇન નંબર આસપાસ

41
00:02:01,040 --> 00:02:04,100
તમારા કાર્યક્રમ શરૂ થાય છે
થોડો વિચિત્ર વર્તે,

42
00:02:04,100 --> 00:02:06,370
તમે એક લીટી લખી શકો છો
નંબર તેમજ.

43
00:02:06,370 --> 00:02:09,660
શું બી, અથવા વિરામ કરે
તે તમારા કાર્યક્રમ માટે પરવાનગી આપે છે

44
00:02:09,660 --> 00:02:13,270
અમુક ચોક્કસ બિંદુ સુધી ચલાવવા માટે,
કાર્ય એટલે કે, નામ

45
00:02:13,270 --> 00:02:15,880
તમે ઉલ્લેખ કરો અથવા લીટી કે
તમે સ્પષ્ટ છે કે સંખ્યા.

46
00:02:15,880 --> 00:02:18,590
>> અને તે સમયે, તે
અમલ જામી જશે નહીં.

47
00:02:18,590 --> 00:02:21,670
આ કારણ કે, ખરેખર સારી બાબત છે
અમલ સ્થિર થઈ જાય,

48
00:02:21,670 --> 00:02:25,214
તમે ખૂબ જ ધીમે ધીમે શરૂ કરી શકો છો
તમારા કાર્યક્રમ દ્વારા પગલું.

49
00:02:25,214 --> 00:02:28,130
તમે આવી છે, તો ખાસ કરીને, ચાલી
તમારા કાર્યક્રમો, તેઓ ખૂબ ટૂંકા છો.

50
00:02:28,130 --> 00:02:31,250
સામાન્ય રીતે, તમે કોઈ સ્લેશ લખો ગમે
તમારા કાર્યક્રમ નામ દાખલ કરો, નહીં

51
00:02:31,250 --> 00:02:33,470
અને તમે આંખ મારવી કરી શકો છો તે પહેલાં, તમારી
કાર્યક્રમ પહેલેથી જ સમાપ્ત થાય છે.

52
00:02:33,470 --> 00:02:36,620
તે ખરેખર પ્રયાસ કરવા માટે સમય ઘણો નથી
અને ખોટું થઈ રહ્યું છે તે બહાર આકૃતિ.

53
00:02:36,620 --> 00:02:40,920
તે ખરેખર વસ્તુઓ ધીમી રજુ કરવાનો પ્રયત્ન જેથી
નીચે બી સાથે વિરામ બિંદુ સુયોજિત કરીને,

54
00:02:40,920 --> 00:02:43,040
અને પછી આધાર.

55
00:02:43,040 --> 00:02:46,169
>> તમે તમારા વિરામ સેટ કર્યું પછી એક વખત
બિંદુ, તમે કાર્યક્રમ ચલાવી શકો છો.

56
00:02:46,169 --> 00:02:47,960
અને તમે કોઇ હોય તો
આદેશ વાક્ય દલીલો,

57
00:02:47,960 --> 00:02:51,610
તમે અહીં તેમને સ્પષ્ટ નથી ત્યારે
તમે તમારા કાર્યક્રમ નામ GDB લખો.

58
00:02:51,610 --> 00:02:55,980
તમે બધા આદેશ વાક્ય સ્પષ્ટ
આર, અથવા રન લઈને દલીલો,

59
00:02:55,980 --> 00:03:00,270
અને પછી ગમે આદેશ વાક્ય દલીલો
તમે તમારા કાર્યક્રમ ની અંદર જરૂર છે.

60
00:03:00,270 --> 00:03:03,510
અન્ય એક નંબર ખરેખર છે
મહત્વપૂર્ણ અને ઉપયોગી આદેશો

61
00:03:03,510 --> 00:03:04,970
જીડીપી પર્યાવરણ પર આધારિત છે.

62
00:03:04,970 --> 00:03:07,540
તેથી માત્ર ઝડપથી મને દો
તેમને કેટલાક પર જાઓ.

63
00:03:07,540 --> 00:03:11,320
>> પ્રથમ, આગામી માટે ટૂંકા હોય છે, જે n એ, છે
અને તમે આગામી બદલે n ના ટાઈપ કરી શકો છો

64
00:03:11,320 --> 00:03:12,304
બંને કામ કરશે.

65
00:03:12,304 --> 00:03:13,470
અને તે માત્ર લઘુલિપિ છે.

66
00:03:13,470 --> 00:03:17,540
અને તમે કદાચ પહેલાથી જ મેળવેલ છે તેમ
વસ્તુઓ લખવા માટે સમર્થ હોવા માટે ઉપયોગ

67
00:03:17,540 --> 00:03:20,520
ટૂંકા સામાન્ય રીતે વધુ સારી છે.

68
00:03:20,520 --> 00:03:24,100
અને તે શું કરશે તે પડશે
કોડ આગળ એક બ્લોક પગલું.

69
00:03:24,100 --> 00:03:26,170
તેથી તે આગળ ખસેડવા પડશે
એક કાર્ય કૉલ સુધી.

70
00:03:26,170 --> 00:03:28,350
અને પછી બદલે
તે કાર્ય માં ડાઇવિંગ

71
00:03:28,350 --> 00:03:33,130
અને તે તમામ કાર્યોને પસાર થઇ
કોડ છે, તે માત્ર કાર્ય હશે.

72
00:03:33,130 --> 00:03:34,400
>> આ કાર્ય કહેવામાં આવશે.

73
00:03:34,400 --> 00:03:35,733
તે તેના કામ છે ગમે કરશે.

74
00:03:35,733 --> 00:03:38,870
તે કિંમત આપશે
તે કહે છે કે કાર્ય.

75
00:03:38,870 --> 00:03:42,490
અને પછી તમે પર ખસેડો પડશે
કે કૉલિંગ કાર્ય આગામી લાઇન.

76
00:03:42,490 --> 00:03:44,555
તમે પગલું કરવા માંગો છો
આ કાર્ય ની અંદર,

77
00:03:44,555 --> 00:03:46,430
તેના બદલે માત્ર કર્યા
તે ખાસ કરીને, ચલાવો

78
00:03:46,430 --> 00:03:50,004
તમે આ સમસ્યા લાગે છે કે જો
કે કાર્ય ની અંદર આવેલા શકે છે,

79
00:03:50,004 --> 00:03:52,670
તમે, અલબત્ત, એક વિરામ સેટ કરી શકે છે
અંદર કે કાર્ય છે નિર્દેશ કરે છે.

80
00:03:52,670 --> 00:03:57,820
જો તમે પહેલાથી જ ચલાવી રહ્યા છો, તો તમે કરી શકો છો
કોડ આગળ એક વાક્ય પગલું ઓ ઉપયોગ કરે છે.

81
00:03:57,820 --> 00:04:01,170
>> તેથી આ પગલું કરશે
અને કાર્યો માં ડાઇવ

82
00:04:01,170 --> 00:04:04,750
બદલે માત્ર ચલાવવા છે
અને કાર્ય પર ચાલુ

83
00:04:04,750 --> 00:04:07,380
તમે ડિબગીંગ માટે કરી શકે છે.

84
00:04:07,380 --> 00:04:09,870
તમે ક્યારેય ખબર કરવા માંગો છો
એક ચલ ની કિંમત,

85
00:04:09,870 --> 00:04:12,507
તમે પી, અથવા પ્રિન્ટ લખી શકો છો,
અને પછી ચલ નામ.

86
00:04:12,507 --> 00:04:15,090
અને તે તમને છાપશે
આ GDB પર્યાવરણ અંદર,

87
00:04:15,090 --> 00:04:19,110
ચલ નામ કે તમારી પાસે
me-- ચલ ની કિંમત માફ

88
00:04:19,110 --> 00:04:20,064
તમે નામ આપવામાં આવ્યું કર્યું છે.

89
00:04:20,064 --> 00:04:23,230
તમે દરેક કિંમતો જાણવા માંગો છો
જ્યાં સ્થાનિક ચલ સુલભ

90
00:04:23,230 --> 00:04:25,970
તમે હાલમાં તમારા
કાર્યક્રમ, તમે માહિતી સ્થાનિકો લખી શકો છો.

91
00:04:25,970 --> 00:04:28,332
તે કરતાં ઘણો ઝડપી છે
પછી પી લખીને અને ગમે,

92
00:04:28,332 --> 00:04:30,540
આ બધા બહાર યાદી
તમે અસ્તિત્વમાં ખબર છે કે ચલો.

93
00:04:30,540 --> 00:04:34,370
તમે માહિતી સ્થાનિકો લખો, અને તે કરી શકો છો
તમારા માટે બધું છાપશે.

94
00:04:34,370 --> 00:04:37,770
આગામી અપ છે, કે જે બીટી છે
પાછા ટ્રેસ માટે નહીં.

95
00:04:37,770 --> 00:04:41,680
હવે, સામાન્ય રીતે,
ખાસ કરીને વહેલી CS50 માં,

96
00:04:41,680 --> 00:04:44,450
તમે ખરેખર પ્રસંગે હોય નહીં
બીટી, અથવા પાછા ટ્રેસ વાપરવા માટે,

97
00:04:44,450 --> 00:04:47,860
તમે કાર્યો કર્યા નથી કારણ કે
કે અન્ય કાર્યો કૉલ કરો.

98
00:04:47,860 --> 00:04:50,450
>> તમે મુખ્ય કૉલ હોય શકે છે
કાર્ય છે, પરંતુ તે કદાચ તે છે.

99
00:04:50,450 --> 00:04:53,199
તમે કે અન્ય કાર્ય નથી
અન્ય કાર્ય, ફોન, જે

100
00:04:53,199 --> 00:04:54,880
અન્ય કાર્ય કહે છે, અને તેથી પર.

101
00:04:54,880 --> 00:04:57,550
પરંતુ તમારા કાર્યક્રમો વધુ વિચાર
જટિલ, અને ખાસ કરીને

102
00:04:57,550 --> 00:05:00,290
તમે કામ શરૂ કરો ત્યારે
રિકર્ઝન સાથે પાછા ટ્રેસ

103
00:05:00,290 --> 00:05:05,150
તમે દેવા માટે ખરેખર ઉપયોગી રસ્તો હોઈ શકે છે
પ્રકારની છે માટે અમુક સંદર્ભમાં વિચાર

104
00:05:05,150 --> 00:05:06,460
હું મારા કાર્યક્રમ છું.

105
00:05:06,460 --> 00:05:10,590
તેથી જો તમે તમારી કોડ તેવા પરચૂરણ ખર્ચ કર્યો કહે છે, અને
તમે મુખ્ય કાર્ય કહે છે કે ખબર

106
00:05:10,590 --> 00:05:14,720
એક કાર્ય કહે છે, જે એફ,
એક કાર્ય એચ કહે છે કે જે ત.

107
00:05:14,720 --> 00:05:17,650
તેથી અમે વિવિધ સ્તરો છે
માળો અહીં પર જઈ રહી છે.

108
00:05:17,650 --> 00:05:19,440
>> તમે અંદર છો, તો
તમારા GDB પર્યાવરણ,

109
00:05:19,440 --> 00:05:21,640
અને તમે તમારા અંદર ખબર
H, પરંતુ તમને ભૂલી

110
00:05:21,640 --> 00:05:27,210
તમે જ્યાં તમે મળી છે તે વિશે
તમે બીટી, અથવા પાછા ટ્રેસ લખી શકો છો are--,

111
00:05:27,210 --> 00:05:32,370
અને તે, એચ, જી બહાર મુખ્ય એફ છાપશે
કેટલાક અન્ય માહિતી, સાથે જે

112
00:05:32,370 --> 00:05:35,984
તમે એક ચાવી આપે છે કે, ઠીક મુખ્ય
કહેવાય એફ કહેવાય છે, જી એફ, જી, એચ કહેવાય

113
00:05:35,984 --> 00:05:37,900
અને તે જ્યાં હું
હાલમાં મારા કાર્યક્રમ છું.

114
00:05:37,900 --> 00:05:41,380
તેથી તે ખરેખર ઉપયોગી હોઈ શકે
ખાસ કરીને GDB ની ભેદી નેસ તરીકે

115
00:05:41,380 --> 00:05:45,667
માટે, થોડી જબરજસ્ત બની જાય છે
વસ્તુઓ છે બરાબર જ્યાં શોધવા.

116
00:05:45,667 --> 00:05:48,500
છેલ્લે, તમારી કાર્યક્રમ કરવામાં આવે છે ત્યારે,
તમે પૂર્ણ કરી રહ્યાં છો અથવા જ્યારે તે ડિબગીંગ

117
00:05:48,500 --> 00:05:50,125
અને તમે દૂર પગલું કરવા માંગો છો
આ GDB વાતાવરણ,

118
00:05:50,125 --> 00:05:51,940
તે તેને બહાર વિચાર કેવી રીતે ખબર મદદ કરે છે.

119
00:05:51,940 --> 00:05:55,500
જો તમે તેને ક્યૂ લખો, અથવા બહાર વિચાર, છોડો શકો છો.

120
00:05:55,500 --> 00:05:59,220
હવે, આજે વિડિઓ પહેલાં
હું બગડેલ કાર્યક્રમ તૈયાર

121
00:05:59,220 --> 00:06:03,900
હું સંકલિત, જે કહેવાય buggy1,
buggy1.c તરીકે ઓળખાય ફાઇલમાંથી.

122
00:06:03,900 --> 00:06:06,500
જો તમે આ આશા રાખી શકે છે
કાર્યક્રમ હકીકત બગડેલ છે.

123
00:06:06,500 --> 00:06:08,990
કંઈક ખોટું થાય
જ્યારે હું પ્રયત્ન કરો અને તે ચલાવો.

124
00:06:08,990 --> 00:06:13,014
હવે, કમનસીબે, હું અજાણતા
મારા buggy1.c ફાઇલ કાઢી

125
00:06:13,014 --> 00:06:15,930
તેથી ક્રમમાં મને બહાર આકૃતિ માટે
શું આ કાર્યક્રમ સાથે ખોટું થઈ રહ્યું છે

126
00:06:15,930 --> 00:06:18,770
હું ઉપયોગ કરવા હોય જાઉં છું
GDB પ્રકારની અકારણ, પ્રયાસ

127
00:06:18,770 --> 00:06:22,372
આ કાર્યક્રમ મારફતે શોધખોળ કરવા માટે
ખોટું થઈ રહ્યું છે બરાબર શું બહાર આકૃતિ.

128
00:06:22,372 --> 00:06:24,580
પરંતુ માત્ર સાધનોની મદદથી
અમે પહેલાથી જ વિશે શીખી કર્યું

129
00:06:24,580 --> 00:06:27,700
અમે ખૂબ ખૂબ આકૃતિ કરી શકો છો
તે છે બરાબર શું બહાર.

130
00:06:27,700 --> 00:06:30,740
તેથી આપણે પર વડા દો
CS50 IDE અને એક નજર છે.

131
00:06:30,740 --> 00:06:33,155
ઠીક છે, તેથી અમે અહીં છો મારા
CS50 IDE પર્યાવરણ,

132
00:06:33,155 --> 00:06:35,697
અને હું થોડી ઝૂમ પડશે
જેથી તમે થોડી વધુ જોઈ શકે છે.

133
00:06:35,697 --> 00:06:38,530
મારા ટર્મિનલ વિન્ડોમાં, હું યાદી તો
મારા વર્તમાન ડિરેક્ટર સમાવિષ્ટો

134
00:06:38,530 --> 00:06:41,250
LS સાથે, અમે કે હું જોશો
સ્ત્રોત ફાઇલો એક દંપતિ છે

135
00:06:41,250 --> 00:06:44,982
અહીં, સહિત
અગાઉ buggy1 ચર્ચા કરી છે.

136
00:06:44,982 --> 00:06:46,940
બરાબર શું જ્યારે પર જાય છે
હું પ્રયત્ન કરો અને buggy1 ચલાવો.

137
00:06:46,940 --> 00:06:47,773
વેલ ચાલો શોધવા દો.

138
00:06:47,773 --> 00:06:52,510
હું કોઈ સ્લેશ લખો
બગડેલ, અને હું Enter દબાવો.

139
00:06:52,510 --> 00:06:53,670
>> વિભાગીય ખામી.

140
00:06:53,670 --> 00:06:55,000
તે સારી નથી.

141
00:06:55,000 --> 00:06:57,180
તમે યાદ તો, એક
સેગ્મેન્ટેશન ક્ષતિમાં સામાન્ય

142
00:06:57,180 --> 00:07:01,540
અમે મેમરી ઍક્સેસ ત્યારે થાય છે જ્યારે
અમે સ્પર્શ કરવાની પરવાનગી નથી રહ્યાં છે.

143
00:07:01,540 --> 00:07:03,820
અમે અચાનક પહોંચી ગયા છો
આ સીમાથી બહાર

144
00:07:03,820 --> 00:07:05,995
શું આ કાર્યક્રમ
કમ્પાઇલર, અમને આપવામાં આવી છે.

145
00:07:05,995 --> 00:07:08,310
અને તેથી પહેલેથી જ એક
ચાવી શોધો રાખવા

146
00:07:08,310 --> 00:07:10,660
અમે ડિબગીંગ પ્રક્રિયા શરૂ થાય છે.

147
00:07:10,660 --> 00:07:13,620
કંઈક અહીં થોડી ખોટું થયું છે.

148
00:07:13,620 --> 00:07:15,935
>> બધા હક છે, તેથી દો પ્રારંભ
આ GDB પર્યાવરણ

149
00:07:15,935 --> 00:07:19,030
અમે બહાર આકૃતિ કરી શકો છો જો અને જુઓ
બરાબર શું સમસ્યા છે.

150
00:07:19,030 --> 00:07:21,674
હું મારા સ્ક્રીન સાફ કરવા માટે જઇ રહ્યો છું
અને હું GDB લખો જાઉં છું

151
00:07:21,674 --> 00:07:24,340
ફરીથી, આ GDB પર્યાવરણમાં દાખલ કરવા માટે,
અને કાર્યક્રમ નામ

152
00:07:24,340 --> 00:07:27,450
હું buggy1 ડિબગ કરવા માંગો છો છે.

153
00:07:27,450 --> 00:07:30,182
અમે વાંચન, થોડી સંદેશ વિચાર
buggy1 થી સંજ્ઞાઓ વાપરીને, થાય છે.

154
00:07:30,182 --> 00:07:32,390
અર્થ એ થાય કે બધા તે ખેંચાય છે
એકસાથે કોડ તમામ,

155
00:07:32,390 --> 00:07:35,570
અને હવે તે લોડ કરવામાં આવી રહ્યું છે
GDB, અને તે જવા માટે તૈયાર છે.

156
00:07:35,570 --> 00:07:37,140
>> હવે, હું શું કરવા માંગો છો?

157
00:07:37,140 --> 00:07:39,130
તમે શું યાદ કરો
પ્રથમ પગલું સામાન્ય રીતે છે

158
00:07:39,130 --> 00:07:42,540
હું આ પર્યાવરણ અંદર છું પછી?

159
00:07:42,540 --> 00:07:44,540
આસ્થાપૂર્વક, તમે સેટ જણાવ્યું હતું
વિરામ બિંદુ છે, કારણ કે

160
00:07:44,540 --> 00:07:46,240
હકીકત છે કે હું શું કરવા માંગો છો તે છે.

161
00:07:46,240 --> 00:07:47,990
હવે, હું નથી
આ માટે સ્રોત કોડ

162
00:07:47,990 --> 00:07:50,948
મને સામે છે, જે કદાચ છે
નથી લાક્ષણિક ઉપયોગ કેસ, માર્ગ દ્વારા.

163
00:07:50,948 --> 00:07:52,055
તમે કદાચ ચાલશે.

164
00:07:52,055 --> 00:07:52,680
તેથી તે સારી છે.

165
00:07:52,680 --> 00:07:55,790
પરંતુ એમ ધારી રહ્યા છીએ તમે નથી, શું કરવું
તમે જાણો છો કે એક કાર્ય

166
00:07:55,790 --> 00:07:58,880
દરેક એક સી કાર્યક્રમ અસ્તિત્વમાં છે?

167
00:07:58,880 --> 00:08:04,420
કોઈ બાબત કેવી રીતે મોટા અથવા જટિલ કેવી રીતે
તે છે, આ કાર્ય ચોક્કસપણે અસ્તિત્વમાં છે.

168
00:08:04,420 --> 00:08:05,440
મુખ્ય, અધિકાર?

169
00:08:05,440 --> 00:08:08,870
>> તેથી બીજું તમામ, અમે કરી શકો છો નિષ્ફળ
મુખ્ય અંતે વિરામ બિંદુ સુયોજિત કરો.

170
00:08:08,870 --> 00:08:12,200
અને ફરી, હું માત્ર ટાઇપ કરી શકે છે
તેના બદલે બી, મુખ્ય તૂટી જાય છે.

171
00:08:12,200 --> 00:08:14,650
અને તમે વિચિત્ર છો, તો તમે તો
ક્યારેય લાંબા આદેશ લખો

172
00:08:14,650 --> 00:08:16,800
અને પછી તમે ખ્યાલ છે કે
ખોટી વસ્તુ લખ્યો,

173
00:08:16,800 --> 00:08:18,770
અને તમે છૂટકારો મેળવવા માંગો છો
બધા હું માત્ર હતી,

174
00:08:18,770 --> 00:08:22,029
તમે જે કરશે, નિયંત્રણ યુ લઇ શકે છે
બધું કાઢી અને તમે પાછા લાવવા

175
00:08:22,029 --> 00:08:23,570
કર્સર રેખાઓ શરૂઆતમાં.

176
00:08:23,570 --> 00:08:26,569
માત્ર પકડી રાખો કરતાં ઘણો ઝડપી
કાઢી નાખો, અથવા તે એક ટોળું વખત હિટ

177
00:08:26,569 --> 00:08:27,080
નહીં.

178
00:08:27,080 --> 00:08:28,740
>> તેથી અમે મુખ્ય અંતે વિરામ બિંદુ સુયોજિત પડશે.

179
00:08:28,740 --> 00:08:32,970
અને તમે જોઈ શકો છો, તે અમે કર્યું છે
ફાઇલ Buggy1.c અંતે વિરામ બિંદુ સુયોજિત કરે છે,

180
00:08:32,970 --> 00:08:36,330
અને દેખીતી રીતે પ્રથમ વાક્ય
મુખ્ય કોડ વાક્ય સાત છે.

181
00:08:36,330 --> 00:08:38,080
ફરીથી, અમે નથી
અહીં સ્રોત ફાઈલ,

182
00:08:38,080 --> 00:08:40,429
પરંતુ હું તે છે કે ધારે પડશે
મને સત્ય કહેવાની.

183
00:08:40,429 --> 00:08:44,510
અને પછી, હું ફક્ત પ્રયાસ કરી રહ્યો છું
અને આર, કાર્યક્રમ ચલાવો.

184
00:08:44,510 --> 00:08:45,360
કાર્યક્રમ શરૂ થાય છે.

185
00:08:45,360 --> 00:08:48,160
બધા હક છે, તેથી આ સંદેશ
થોડી છુપાયેલું છે.

186
00:08:48,160 --> 00:08:50,160
પરંતુ મૂળભૂત રીતે શું છે
અહીં શું થઈ રહ્યું તે માત્ર છે

187
00:08:50,160 --> 00:08:53,350
હું મારા વિરામ હિટ થઈ છે મને કહેતાં
બિંદુ વિરામ બિંદુ નંબર 1.

188
00:08:53,350 --> 00:08:55,877
>> અને પછી, કોડ કે વાક્ય છે,
આવી કોઈ ફાઈલ અથવા ડિરેક્ટરી.

189
00:08:55,877 --> 00:08:57,710
આ જ કારણ છે કે
હું જે તે સંદેશ જોઈ રહ્યો છું

190
00:08:57,710 --> 00:09:00,800
હું અજાણતા કારણ કે
મારા buggy.c ફાઇલ કાઢી.

191
00:09:00,800 --> 00:09:04,050
મારા buggy1.c ફાઇલ અસ્તિત્વમાં હોય તો
વર્તમાન ડિરેક્ટરીમાં,

192
00:09:04,050 --> 00:09:06,920
ત્યાં ખરેખર તે લીટી અધિકાર
મને કહો શું કોડ વાક્ય

193
00:09:06,920 --> 00:09:08,214
શાબ્દિક વાંચે છે.

194
00:09:08,214 --> 00:09:09,380
કમનસીબે, હું તે કાઢી નાખ્યું છે.

195
00:09:09,380 --> 00:09:14,790
અમે પ્રકારની શોધખોળ કરવા માટે છે જવું કરી રહ્યાં છો
વધુ અકારણ આ થોડી મારફતે.

196
00:09:14,790 --> 00:09:17,330
>> ઠીક છે, તેથી માતાનો જોવા દો, શું
હું અહીં શું કરવા માંગો છો?

197
00:09:17,330 --> 00:09:21,770
ઠીક છે, હું સ્થાનિક શું ખબર કરવા માંગો છો
ચલો કદાચ મને માટે ઉપલબ્ધ છે.

198
00:09:21,770 --> 00:09:23,570
હું મારા કાર્યક્રમ શરૂ કર્યું છે.

199
00:09:23,570 --> 00:09:28,515
માતાનો હોઈ શકે છે તે જોવા દો
પહેલાથી જ આપણા માટે આરંભ.

200
00:09:28,515 --> 00:09:31,430
હું માહિતી સ્થાનિકો કોઈ સ્થાનિક લખો.

201
00:09:31,430 --> 00:09:33,960
બધા હક છે, કે નથી તેથી
મને માહિતી એક ટન આપે છે.

202
00:09:33,960 --> 00:09:37,600
હું પ્રયત્ન કરો અને એક ચલ છાપી શકે છે,
પરંતુ હું કોઇ પણ ચલ નામો ખબર નથી.

203
00:09:37,600 --> 00:09:39,930
હું પાછા ટ્રેસ પ્રયાસ કરી શકે છે,
પરંતુ હું મુખ્ય અંદર છું,

204
00:09:39,930 --> 00:09:43,710
તેથી હું ન કરી હોય ખબર
હમણાં બીજા કાર્ય કૉલ.

205
00:09:43,710 --> 00:09:47,710
>> મારી માત્ર વિકલ્પો હોય છે, જેમ તેથી લાગે છે
n અથવા તેથી ઉપયોગ કરે છે અને ડાઇવ શરૂ કરવા માટે.

206
00:09:47,710 --> 00:09:49,630
હું એ નો ઉપયોગ કરવા જઇ રહ્યો છું.

207
00:09:49,630 --> 00:09:51,180
તેથી હું n લખો.

208
00:09:51,180 --> 00:09:53,060
ઓહ gosh, અહીં શું ચાલી રહ્યું છે.

209
00:09:53,060 --> 00:09:56,260
કાર્યક્રમ સંકેતો પ્રાપ્ત થાય છે,
SIGSEGV સેગ્મેન્ટેશન ક્ષતિમાં,

210
00:09:56,260 --> 00:09:57,880
અને પછી સામગ્રી સંપૂર્ણ જથ્થો.

211
00:09:57,880 --> 00:09:58,880
હું પહેલેથી જ ભરાઈ ગયાં છું.

212
00:09:58,880 --> 00:10:00,980
વેલ, ત્યાં ખરેખર એક
ઘણો અહીં શીખી શકાય.

213
00:10:00,980 --> 00:10:02,520
તેથી શું આ અમને જણાવો નથી?

214
00:10:02,520 --> 00:10:09,180
શું તે અમને કહે છે આ કાર્યક્રમ છે,
વિશે છે, પરંતુ હજુ સુધી, seg દોષ.

215
00:10:09,180 --> 00:10:12,550
અને ખાસ કરીને, હું જાઉં છું
પણ વધુ અહીં ઝૂમ કરવા માટે,

216
00:10:12,550 --> 00:10:18,980
તે વિશે seg ખામી વિશે છે
કંઈક strcmp કહેવાય છે.

217
00:10:18,980 --> 00:10:22,705
>> હવે, આપણે ચર્ચા કરી શકે નહિં
વ્યાપક આ કાર્ય કરે છે.

218
00:10:22,705 --> 00:10:25,580
અમે જઈ રહ્યાં છો કારણ કે, પરંતુ તે is--
દરેક કાર્ય વિશે વાત કરવા માટે કે

219
00:10:25,580 --> 00:10:28,610
C સ્ટાન્ડર્ડ અસ્તિત્વમાં પુસ્તકાલય
પરંતુ તેઓ તમને બધા ઉપલબ્ધ છો

220
00:10:28,610 --> 00:10:32,110
તમે લેવા, ખાસ કરીને જો
reference.cs50.net જુઓ.

221
00:10:32,110 --> 00:10:35,000
અને strcmp ખરેખર શક્તિશાળી છે
અંદર અસ્તિત્વમાં છે કે કાર્ય

222
00:10:35,000 --> 00:10:38,070
આ string.h હેડર
હેડર છે, જે ફાઇલ,

223
00:10:38,070 --> 00:10:41,970
કાર્યો માટે સમર્પિત છે કે ફાઈલ
સાથે કામ કરે છે અને શબ્દમાળાઓ ચાલાકી.

224
00:10:41,970 --> 00:10:49,830
>> અને ખાસ કરીને, શું strcmp કરે છે
તે બે શબ્દમાળાઓ કિંમતો સરખામણી કરે છે.

225
00:10:49,830 --> 00:10:54,160
તેથી હું દોષ વિભાગીય વિશે છું
કૉલ પર તે લાગે છે strcmp છે.

226
00:10:54,160 --> 00:10:58,530
, હું એ દબાવો, અને હકીકતમાં હું મેસેજ મળે છે
કાર્યક્રમ સંકેત SIGSEGV સાથે સમાપ્ત

227
00:10:58,530 --> 00:11:01,370
સેગ્મેન્ટેશન ક્ષતિમાં. તેથી હવે
હું ખરેખર seg faulted છે,

228
00:11:01,370 --> 00:11:06,479
અને મારા કાર્યક્રમ ખૂબ છે
ખૂબ અસરકારક રીતે આપવામાં આવે છે.

229
00:11:06,479 --> 00:11:07,770
આ કાર્યક્રમ ઓવરને છે.

230
00:11:07,770 --> 00:11:10,370
તે તૂટી પડી હતી, તે ક્રેશ થયું.

231
00:11:10,370 --> 00:11:14,740
તેથી ઘણો ન હતી, પરંતુ હું
ખરેખર ખૂબ થોડી જાણવા હતી

232
00:11:14,740 --> 00:11:16,747
આ થોડો અનુભવ છે.

233
00:11:16,747 --> 00:11:17,580
હું શું શીખ્યા?

234
00:11:17,580 --> 00:11:22,020
ઠીક છે, મારા કાર્યક્રમ ક્રેશ
તરત જ ખૂબ ખૂબ.

235
00:11:22,020 --> 00:11:26,300
મારા કાર્યક્રમ પર ક્રેશ
એક strcmp માટે કૉલ, પરંતુ હું

236
00:11:26,300 --> 00:11:30,560
કોઈપણ સ્થાનિક ચલો નથી મારા
તે ક્રેશ તે સમયે કાર્યક્રમ.

237
00:11:30,560 --> 00:11:37,320
તેથી શું શબ્દમાળા, અથવા શબ્દમાળાઓ,
હું કદાચ સરખામણી હોઈ શકે છે.

238
00:11:37,320 --> 00:11:42,140
હું કોઇ પણ સ્થાનિક ન હોય તો
ચલો, તમે કદાચ

239
00:11:42,140 --> 00:11:45,520
કદાચ હું ત્યાં અહી કે અટકળ
સાચું હોઈ શકે કે જે વૈશ્વિક ચલ.

240
00:11:45,520 --> 00:11:47,670
>> પરંતુ સામાન્ય રીતે, તે લાગે છે
જેમ હું સરખામણી છું

241
00:11:47,670 --> 00:11:52,070
અસ્તિત્વમાં નથી કે કંઈક.

242
00:11:52,070 --> 00:11:54,130
તેથી આપણે તપાસ કરીએ
થોડી વધુ છે.

243
00:11:54,130 --> 00:11:55,120
તેથી હું મારા સ્ક્રીન સાફ કરવા માટે જઇ રહ્યો છું.

244
00:11:55,120 --> 00:11:57,536
હું બહાર નીકળી જાઉં છું
એક બીજા માટે GDB એન્વાર્યમેન્ટ.

245
00:11:57,536 --> 00:12:01,300
અને હું બરાબર, વિચારી રહ્યો છું, તેથી ત્યાં છે
મારા કાર્યક્રમ કોઈ સ્થાનિક ચલો.

246
00:12:01,300 --> 00:12:06,444
હું પસાર માનવામાં છું તો કદાચ હું આશ્ચર્ય
આદેશ વાક્ય દલીલ તરીકે શબ્દમાળા છે.

247
00:12:06,444 --> 00:12:07,610
તેથી આપણે માત્ર આ ચકાસીએ.

248
00:12:07,610 --> 00:12:09,020
હું પહેલાં આ કર્યું નથી.

249
00:12:09,020 --> 00:12:14,244
>> હું આ કાર્યક્રમ ચલાવવા કદાચ જો માતાનો જોવા દો
આદેશ વાક્ય દલીલ સાથે કામ કરે છે.

250
00:12:14,244 --> 00:12:16,140
ઓહ, ત્યાં કોઈ સેગ્મેન્ટેશન ક્ષતિમાં.

251
00:12:16,140 --> 00:12:17,870
તે માત્ર હું તેને બહાર figured છે કે મને કહ્યું હતું.

252
00:12:17,870 --> 00:12:19,170
તેથી કદાચ કે સુધારો અહીં છે.

253
00:12:19,170 --> 00:12:27,560
હું પાછા જાઓ અને જો ખરેખર જોવા
buggy1.c માટે વાસ્તવિક સ્રોત કોડ,

254
00:12:27,560 --> 00:12:31,180
હું શું કરી રહ્યો છું છે છતાં તે લાગે છે
હું વિના strcmp માટે કૉલ બનાવવા છું

255
00:12:31,180 --> 00:12:34,010
હકીકતમાં argv [1] અસ્તિત્વમાં છે કે કેમ ચકાસણી.

256
00:12:34,010 --> 00:12:36,730
આ વાસ્તવમાં છે
buggy1.c માટે સ્ત્રોત કોડ.

257
00:12:36,730 --> 00:12:38,855
તેથી હું ખરેખર જરૂર શું
મારા કાર્યક્રમને સરખો કરવા માટે અહીં નથી,

258
00:12:38,855 --> 00:12:40,835
ધારી રહ્યા છીએ કે હું હોય
છે મને સામે દાખલ

259
00:12:40,835 --> 00:12:44,740
જસ્ટ ખાતરી કરો કે એક ચેક ઉમેરવા
ખાતરી કરો કે argc 2 સમાન છે.

260
00:12:44,740 --> 00:12:47,780
તેથી આ ઉદાહરણ તરીકે, ફરીથી હું જણાવ્યું હતું કે, જેમ
અધિકાર, થોડો contrived છે?

261
00:12:47,780 --> 00:12:49,840
તમે સામાન્ય રીતે નથી જઈ રહ્યાં છો
આકસ્મિક તમારા સ્રોત કોડ કાઢી

262
00:12:49,840 --> 00:12:51,820
અને પછી પ્રયાસ હોય છે
અને કાર્યક્રમ ડિબગ.

263
00:12:51,820 --> 00:12:53,120
પરંતુ આસ્થાપૂર્વક, તે આપ્યો
તમે એક ઉદાહરણ

264
00:12:53,120 --> 00:12:55,120
વસ્તુઓ આ પ્રકારના કે
તમારા વિશે વિચારી શકાય છે

265
00:12:55,120 --> 00:12:56,610
કારણ કે તમે તમારા કાર્યક્રમ ડિબગીંગ કરી રહ્યાં છો.

266
00:12:56,610 --> 00:12:58,760
>> અહીં બાબતોના રાજ્ય શું છે?

267
00:12:58,760 --> 00:13:00,510
શું ચલો હું શું
મને સુલભ છે?

268
00:13:00,510 --> 00:13:03,600
બરાબર જ્યાં મારા કાર્યક્રમ છે
શું વાક્ય પર, તૂટી,

269
00:13:03,600 --> 00:13:05,240
શું કાર્ય શું કૉલ પર?

270
00:13:05,240 --> 00:13:06,952
કડીઓ કેવા પ્રકારની છે કે જે મને આપે છે?

271
00:13:06,952 --> 00:13:08,910
અને તે બરાબર છે
વિચાર કાઇન્ડ કે તમે

272
00:13:08,910 --> 00:13:12,820
તમે છો જ્યારે પ્રવેશ મેળવવામાં જોઇએ
તમારા ડિબગીંગ કાર્યક્રમો વિશે વિચારવાનો.

273
00:13:12,820 --> 00:13:13,820
>> હું ડો લોયડ છું.

274
00:13:13,820 --> 00:13:16,140
આ CS50 છે.

275
00:13:16,140 --> 00:15:08,642