1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS?] હાય,
હું [છું? ડેન Armadaras?].

3
00:00:02,350 --> 00:00:04,410
આજે, અમે જઈ રહ્યાં છો
ડિબગીંગ જોઈ શકાય છે.

4
00:00:04,410 --> 00:00:06,697
માત્ર અમે જતા હોય છે
કેટલીક ટેકનિક વિશે વાત છે,

5
00:00:06,697 --> 00:00:09,280
પણ અમે જોવા માટે જઈ રહ્યાં છો
કેટલાક લક્ષણો સમાયેલ

6
00:00:09,280 --> 00:00:14,170
પરવાનગી આપે છે કે CS50 IDE અંદર
તમે સરળતાથી એક કાર્યક્રમ ડિબગ.

7
00:00:14,170 --> 00:00:16,272
>> માત્ર એક ઉદાહરણ
ખોટું ન જઇ શકો છો કે જે કંઈક

8
00:00:16,272 --> 00:00:18,730
અને તે ખરેખર કંઈક છે
અમે પહેલાથી જ જોઇ છે.

9
00:00:18,730 --> 00:00:23,200
આ કિસ્સામાં, આ એક સી પ્રોગ્રામ છે
કે, વપરાશકર્તા માંથી પૂર્ણાંક સ્વીકારે

10
00:00:23,200 --> 00:00:27,580
બે દ્વારા તેને વિભાજિત કરે છે અને પૂરી પાડે છે
વપરાશકર્તા પાછા આઉટપુટ.

11
00:00:27,580 --> 00:00:30,610
હવે અમે શું જોઇ કર્યું
અગાઉ પ્રવચનો,

12
00:00:30,610 --> 00:00:34,370
અમે આ ખરેખર થાય છે કે ખબર
વિભાગ સમસ્યાઓ ચોક્કસ પ્રકારના

13
00:00:34,370 --> 00:00:35,860
અમે એકી સંખ્યા હોય છે.

14
00:00:35,860 --> 00:00:40,330
>> ખાસ કરીને, અમે ફક્ત ફેંકી દેવું પડશે
આ બાદ ચિહ્ન પછી કંઈપણ.

15
00:00:40,330 --> 00:00:43,170
હવે, આપણે આ જાણીએ છીએ કે
કેસ બને છે.

16
00:00:43,170 --> 00:00:47,430
અને અમે તેને ચલાવવા, તો અમે ખાતરી કરી શકો છો
સંકલન દ્વારા પ્રથમ અમારી શંકાને,.

17
00:00:47,430 --> 00:00:50,460
અને પછી, ચલાવીને અને
એક વિચિત્ર નંબર દાખલ.

18
00:00:50,460 --> 00:00:51,720
>> આ નવું કંઈ નથી.

19
00:00:51,720 --> 00:00:54,490
પરંતુ આ ખરેખર એક છે
ભૂલ ઉદાહરણ કે

20
00:00:54,490 --> 00:00:58,810
મોટા કાર્યક્રમ અંદર અસ્તિત્વ ધરાવે છે
કે ટ્રૅક કરવા માટે મુશ્કેલ બની જાય છે.

21
00:00:58,810 --> 00:01:02,640
અમે શું આ મુદ્દો ખબર હોવા છતાં
આ બાબત સાચી મર્મ છે

22
00:01:02,640 --> 00:01:06,250
ઓળખવા પ્રયાસ કરી શકે છે
ખાસ જ્યાં ભૂલ થાય છે,

23
00:01:06,250 --> 00:01:09,750
શું છે કે જે સમસ્યા ઓળખવા
છે, અને પછી તે કરવું.

24
00:01:09,750 --> 00:01:14,400
તેથી ઉદાહરણ તરીકે આ પૂરી પાડે છે
કંઈક હોઈ શકે છે શું

25
00:01:14,400 --> 00:01:19,030
અમે પહેલાથી જ ખબર છે, પરંતુ દફનાવવામાં કરી શકાય છે કે
કોડ અન્ય તત્વો અંદર.

26
00:01:19,030 --> 00:01:23,090
>> તેથી આ અન્ય સ્રોત ખોલીને
ઉદાહરણ તરીકે કોડ ફાઇલ,

27
00:01:23,090 --> 00:01:27,165
આ વિભાગ સમસ્યા હવે છે
મોટા કાર્યક્રમ ભાગ છે.

28
00:01:27,165 --> 00:01:29,040
હજુ થોડું હોઈ શકે છે
થોડી રચી, અને અમે

29
00:01:29,040 --> 00:01:31,076
સરળતાથી કરવા માટે સક્ષમ હોઈ શકે છે
ખાસ કરીને, તેને ઓળખવા

30
00:01:31,076 --> 00:01:32,450
અમે ફક્ત આ ચર્ચા કરી રહ્યાં છો કારણ કે.

31
00:01:32,450 --> 00:01:38,250
પરંતુ અમે આ છે કે જે બહાર આકૃતિ કરી શકો છો
સમસ્યા મોટા પાયે અસ્તિત્વ ધરાવે છે.

32
00:01:38,250 --> 00:01:45,450
>> હવે હું આ કમ્પાઇલ અને જો
તે એક વિચિત્ર નંબર દાખલ ચલાવો,

33
00:01:45,450 --> 00:01:49,816
અમે ચોક્કસપણે મળી નથી જોઈ શકો છો
અમે અપેક્ષા હોય શકે છે આઉટપુટ.

34
00:01:49,816 --> 00:01:51,690
આ ચોક્કસ કિસ્સામાં,
અમે કહી શકે કે અમે

35
00:01:51,690 --> 00:01:56,060
નંબરો તમામ ગણતરી કરવા માંગો છો
એક અમુક ચોક્કસ નંબર છે.

36
00:01:56,060 --> 00:01:58,130
અને અમે તે અમે જોઈ શકો છો
મુદ્દાઓ વિવિધ હોય છે

37
00:01:58,130 --> 00:02:03,880
અમે outputting રહ્યાં છો અહીં તો, ફક્ત 0
અને 1 અમે 5 ઇનપુટ પૂરી પાડે છે.

38
00:02:03,880 --> 00:02:07,380
>> તેથી અમે પહેલાથી જ ખબર છે કે
અહીં એક સમસ્યા છે.

39
00:02:07,380 --> 00:02:11,662
પરંતુ અમે ચોક્કસપણે ખબર નથી શકે છે
જ્યાં આ મુદ્દો ખરેખર અસ્તિત્વ ધરાવે છે.

40
00:02:11,662 --> 00:02:13,620
જે રીતે હવે એક કે
અમે આ ઠીક કરવાનો પ્રયાસ કરી શકો છો

41
00:02:13,620 --> 00:02:15,745
અમે છે કે કંઈક છે
પહેલેથી જ રજૂ કરવામાં આવ્યું.

42
00:02:15,745 --> 00:02:18,880
અમે હમણાં જ એક મોટા પાયા પર ઉપયોગ કરી શકો છો.

43
00:02:18,880 --> 00:02:21,680
>> 14 લીટી પર, અમે છે
આ printf કાર્ય,

44
00:02:21,680 --> 00:02:25,620
જે અમને રાજ્ય બહાર છાપવા માટે પરવાનગી આપે
માહિતી વિવિધ ટુકડાઓ.

45
00:02:25,620 --> 00:02:28,880
અને આ કંઈક છે કે તમે
તમારા કાર્યક્રમ અંદર લાભ જોઈએ

46
00:02:28,880 --> 00:02:33,100
બરાબર શું બહાર આકૃતિ કરવાનો પ્રયાસ કરો
કોડ વિવિધ રેખાઓ રહ્યું.

47
00:02:33,100 --> 00:02:36,350
તેથી આ ન હોય તો પણ
અંતિમ આઉટપુટ કે અમે ખરેખર

48
00:02:36,350 --> 00:02:39,830
બહાર પેદા કરવા માંગો છો
આ કાર્યક્રમ, અમે હજુ પણ

49
00:02:39,830 --> 00:02:42,300
કેટલાક ડિબગ હોય શકે છે
નિવેદનો જ્યાં અમે

50
00:02:42,300 --> 00:02:46,970
બહાર આકૃતિ કરવાનો પ્રયાસ કરી શકો છો ચોક્કસપણે શું
અમારા કોડ અંદર થઈ રહ્યું છે.

51
00:02:46,970 --> 00:02:51,210
>> તેથી આ કિસ્સામાં, ચાલશે
ડિબગ ટેગ સાથે printf.

52
00:02:51,210 --> 00:02:53,540
આ કિસ્સામાં, આ છે
માત્ર એક ડિબગ શબ્દમાળા

53
00:02:53,540 --> 00:02:56,840
હું મૂકવા કે જેથી તે બની જાય છે કે છું કે
મારી કોડ આઉટપુટ ખૂબ જ સ્પષ્ટ

54
00:02:56,840 --> 00:02:59,200
શું તે હું બતાવવા માંગો છો છે.

55
00:02:59,200 --> 00:03:04,410
સંખ્યા અહીં અને આઉટપુટ
અમે ગણતરી કરી છે કે.

56
00:03:04,410 --> 00:03:06,800
>> આ કિસ્સામાં, હું કદાચ
ચોક્કસપણે ખબર કરવા માંગો છો

57
00:03:06,800 --> 00:03:11,380
શું પહેલા શું થઈ રહ્યું છે અને
અમુક ચોક્કસ ગણતરી પછી.

58
00:03:11,380 --> 00:03:16,224
તેથી હું પહેલાં printf ઉપયોગ કરી શકે છે
અને કોડ કે વાક્ય પછી.

59
00:03:16,224 --> 00:03:18,640
આ કિસ્સામાં, હું પણ કરી શકે છે
તે થોડો વધુ સ્પષ્ટ બનાવવા

60
00:03:18,640 --> 00:03:21,960
પહેલાં ડિબગ કહેતા
અને ડિબગ જેથી પછી

61
00:03:21,960 --> 00:03:26,540
હું સાથે મારી દિગ્મૂઢ નથી કે
સમાન જુઓ કે ઘણી રેખાઓ.

62
00:03:26,540 --> 00:03:32,290
>> હવે અમે આ અને રન પુનઃકમ્પાઈલ તો
તે ફરીથી પાંચ જેવા નંબર દાખલ

63
00:03:32,290 --> 00:03:35,090
અમે હોય છે કે જોઈ શકો છો
હવે પહેલા અને પછી આઉટપુટ

64
00:03:35,090 --> 00:03:40,670
અને અમે સ્પષ્ટ કર્યું નથી કે શોધવા
વિભાગ અથવા સ્પષ્ટ સંખ્યા કર્યા

65
00:03:40,670 --> 00:03:43,680
અમે ખરેખર કરવા માંગો છો છે.

66
00:03:43,680 --> 00:03:48,660
હવે આ કિસ્સામાં, આ છે
ખરેખર સ્પષ્ટ આઉટપુટ.

67
00:03:48,660 --> 00:03:52,440
તે ખરેખર એક સ્પષ્ટ પરિણામ નથી કે
અમે આ ચોક્કસ કાર્યક્રમ બહાર માંગો છો.

68
00:03:52,440 --> 00:03:54,427
>> અને આ એક, ફરી, છે
થોડો રચી.

69
00:03:54,427 --> 00:03:57,510
પરંતુ, કદાચ, એક વસ્તુઓ છે કે જે
સ્પષ્ટીકરણ જણાવ્યું હતું કે જો અમે કરી શકે છે

70
00:03:57,510 --> 00:04:01,900
અમે આ વિભાજીત કરવા માંગો છો કે
2 અને તેથી અન્ય શબ્દોમાં 1-- ઉમેરો

71
00:04:01,900 --> 00:04:04,550
અમે પછી up-- ધરપકડ કરવા માંગો છો
અમે કરી શકે છે ખબર શકે

72
00:04:04,550 --> 00:04:08,060
આ કિસ્સામાં, કે જે ચોક્કસ વસ્તુ નથી.

73
00:04:08,060 --> 00:04:14,010
હવે અહીં અમે હશે ખબર
અમારા અર્ધા નંબર 1 ઉમેરવા માટે સક્ષમ છે.

74
00:04:14,010 --> 00:04:16,490
>> ચાલો આ પુનઃકમ્પાઈલ દો
અને આ ખાતરી

75
00:04:16,490 --> 00:04:18,860
અમે માંગો છો કે જે રીતે વર્તન કરવામાં આવે છે.

76
00:04:18,860 --> 00:04:21,980
હવે અમે પહેલાં જોઈ શકો છો કે
આવી રહી છે, અમે 5 નંબર છે.

77
00:04:21,980 --> 00:04:26,620
કર્યા પછી, અમે નંબર 3 છે
અમારા સ્પષ્ટીકરણ અનુસાર, જે

78
00:04:26,620 --> 00:04:29,292
અમે શું કરવા માગતો હોય છે.

79
00:04:29,292 --> 00:04:31,000
પરંતુ અમે જોવા હોય તો
અહીં આઉટપુટ, અમે કરી શકો છો

80
00:04:31,000 --> 00:04:33,760
અમે અન્ય હોય શકે છે કે નહીં તે જોવા
છે, જે એકસાથે ભૂલ,

81
00:04:33,760 --> 00:04:36,940
અમે 0 અમારા ગણક શરૂ થાય છે.

82
00:04:36,940 --> 00:04:39,390
>> હવે ફરીથી, આ કંઈક છે
અમે ભૂતકાળમાં જોવા મળે છે કે

83
00:04:39,390 --> 00:04:42,500
અને અમે ખૂબ સરળતાથી ઠીક કરી શકે છે.

84
00:04:42,500 --> 00:04:44,790
પરંતુ આ કિસ્સામાં, અમે
પણ લાભ હતી

85
00:04:44,790 --> 00:04:48,940
આ printf સ્ટેટમેન્ટ ઉપયોગ
સીધા લૂપ માટે અંદર

86
00:04:48,940 --> 00:04:52,930
ચોક્કસપણે જ્યાં ખબર
કે જે ભૂલ બનતું હતું.

87
00:04:52,930 --> 00:04:55,150
તેથી printf નિવેદનો છે
મદદ ખૂબ જ ઉપયોગી

88
00:04:55,150 --> 00:04:57,940
તમે જ્યાં નક્કી કરવા માટે,
ચોક્કસપણે તમારા સ્રોત કોડ,

89
00:04:57,940 --> 00:05:00,620
ચોક્કસ ભૂલ થતું હોય છે.

90
00:05:00,620 --> 00:05:03,650
>> અને તે ખ્યાલ પણ મહત્વનું છે
કે, અમે કોડ લખી રહ્યાં છો,

91
00:05:03,650 --> 00:05:06,052
અમે ધારણા હોય શકે
એક કાર્યક્રમ રાજ્યના વિશે.

92
00:05:06,052 --> 00:05:08,510
અથવા આપણે ધારણા હોય શકે
આ કાર્યક્રમ ભાગ શું વિશે

93
00:05:08,510 --> 00:05:13,020
ખરેખર સાચું અથવા જ્યારે ખોટો છે
પાછળથી અમે તે કાર્યક્રમ પર બિલ્ડ તરીકે

94
00:05:13,020 --> 00:05:15,950
અને તે ભાગ બનાવવા
જટિલ અને મોટા કાર્યક્રમ

95
00:05:15,950 --> 00:05:19,700
અમે કેટલાક પાસા કે ખ્યાલ
કે ખરેખર બગડેલ છે.

96
00:05:19,700 --> 00:05:22,680
>> Printf મદદથી ખરેખર મદદ કરી શકે
સંકીર્ણ અને ઓળખવા

97
00:05:22,680 --> 00:05:26,430
એક કાર્યક્રમ વિસ્તારો કે નથી કરી શકે છે
બરાબર રીતે વર્તન કરવામાં કે અમે

98
00:05:26,430 --> 00:05:29,500
અમારી ધારણા પર આધારિત છે, અપેક્ષા.

99
00:05:29,500 --> 00:05:31,460
પરંતુ અન્ય સાધનો છે
ઉપલબ્ધ છે, સાથે સાથે,

100
00:05:31,460 --> 00:05:34,860
કે અમને આકૃતિ કરવાનો પ્રયાસ કરવા માટે પરવાનગી આપે
જ્યાં એક ભૂલ થતું હોય છે બહાર

101
00:05:34,860 --> 00:05:39,930
અને એ પણ ખાસ કરીને, શું વસ્તુઓ
આ કાર્યક્રમ ની અંદર શું થઈ રહ્યું છે.

102
00:05:39,930 --> 00:05:41,990
>> તેથી ઉપયોગ printf ખૂબ જ છે
ઉપયોગી જ્યારે અમે માંગો છો

103
00:05:41,990 --> 00:05:45,900
ચોક્કસ વિસ્તારોમાં ઓળખવા માટે
કેટલાક ભૂલ હોય છે કે કાર્યક્રમ.

104
00:05:45,900 --> 00:05:47,730
પરંતુ તે પણ બને છે
જ્યારે પછી કંટાળાજનક.

105
00:05:47,730 --> 00:05:50,500
આ કિસ્સામાં, આ એક છે
પ્રમાણમાં સરળ કાર્યક્રમ

106
00:05:50,500 --> 00:05:52,750
માત્ર એક કે બે ચલો સાથે.

107
00:05:52,750 --> 00:05:57,260
અને તે માટે અમારા માટે ખૂબ જ સરળ બની જાય છે
તે ચલો ની કિંમત છાપે

108
00:05:57,260 --> 00:05:59,670
મોટા કાર્યક્રમ સંદર્ભમાં.

109
00:05:59,670 --> 00:06:02,670
>> પરંતુ અમે એક અલગ પડી શકે છે
ઘણા પરિબળો છે કે કાર્યક્રમ.

110
00:06:02,670 --> 00:06:06,530
અને તે તદ્દન ન હોઈ શકે
printf જેથી વાપરવા માટે સરળ

111
00:06:06,530 --> 00:06:10,120
શું થઈ રહ્યું છે મૂલ્યાંકન કરવાનો પ્રયાસ કરો
તે ચલો દરેક એક માટે

112
00:06:10,120 --> 00:06:13,590
આ કાર્યક્રમ તરીકે ચલાવવા છે.

113
00:06:13,590 --> 00:06:16,960
અસ્તિત્વમાં છે કે જે કાર્યક્રમ છે
ડિબગર કાર્યક્રમ તરીકે ઓળખાય છે.

114
00:06:16,960 --> 00:06:20,320
આ કિસ્સામાં, એક કે અમે
ઉપયોગ, GDB GNU ડિબગર છે, અથવા

115
00:06:20,320 --> 00:06:24,260
કે અમને આંતરિક તપાસ કરવા માટે પરવાનગી આપે
વધુ એક કાર્યક્રમ કામગીરી

116
00:06:24,260 --> 00:06:25,700
વિગતવાર માર્ગ.

117
00:06:25,700 --> 00:06:28,810
>> અમે ખરેખર અમલ કરી શકો છો
આદેશ વાક્ય માંથી GDB

118
00:06:28,810 --> 00:06:35,370
અહીં ફક્ત GDB અને ટાઇપિંગ દ્વારા
અમે ડિબગ કરવા માંગો છો કે આદેશ.

119
00:06:35,370 --> 00:06:37,550
આ કિસ્સામાં, ગણતરી.

120
00:06:37,550 --> 00:06:41,650
હવે આ કિસ્સામાં, અમે તેને જોઈ શકો છો કે
GDB કહે છે કે પ્રોમ્પ્ટ પર લાવે છે.

121
00:06:41,650 --> 00:06:44,020
અને અમે ખરેખર કરી શકો છો
GDB માટે આદેશો ચલાવો

122
00:06:44,020 --> 00:06:48,260
વાસ્તવમાં અમલ શરૂ કરવા માટે
કાર્યક્રમ ચોક્કસ પોઈન્ટ તેને રોકવા,

123
00:06:48,260 --> 00:06:51,060
ચલો મૂલ્યાંકન અને
ચલો નિરીક્ષણ કે

124
00:06:51,060 --> 00:06:54,152
આ કાર્યક્રમ રાજ્ય અસ્તિત્વમાં
તે ચોક્કસ ક્ષણે,

125
00:06:54,152 --> 00:06:55,110
અને તેથી પર અને તેથી આગળ.

126
00:06:55,110 --> 00:06:57,240
તે અમને પાવર ઘણો પૂરી પાડે છે.

127
00:06:57,240 --> 00:06:59,960
>> પરંતુ તે માત્ર જેથી બને
તે પણ આ CS50 IDE

128
00:06:59,960 --> 00:07:05,870
એ GUI અથવા વપરાશકર્તા પૂરી પાડે છે
GDB માટે ઈન્ટરફેસ કે

129
00:07:05,870 --> 00:07:11,120
અમને જરૂર વિના આ કરવા માટે પરવાનગી આપે છે
બિલકુલ આદેશ વાક્ય ઈન્ટરફેસ

130
00:07:11,120 --> 00:07:13,560
અથવા બધા પણ.

131
00:07:13,560 --> 00:07:16,930
મને લાગે છે કે ઍક્સેસ કરી શકો છો કે જે રીતે
ડિબગ બટન નો ઉપયોગ કરીને છે

132
00:07:16,930 --> 00:07:20,120
આ CS50 IDE ખૂબ જ ટોચ પર.

133
00:07:20,120 --> 00:07:24,280
હવે ભૂતકાળમાં, અમે શું છે
જોઈ અમે આદેશને વાપરો કે જે છે

134
00:07:24,280 --> 00:07:27,660
લીટી કમ્પાઇલ અને પછી કાર્યક્રમ ચલાવવા માટે.

135
00:07:27,660 --> 00:07:29,790
>> આ ડિબગ બટન કરે
તે પગલાં બંને.

136
00:07:29,790 --> 00:07:34,380
પરંતુ તે પણ લાવશે
દૂર અધિકાર પર ડીબગર ટેબ

137
00:07:34,380 --> 00:07:38,280
કે અમને વિવિધ નિરીક્ષણ કરવા માટે પરવાનગી આપે છે
કાર્યક્રમ ગુણધર્મો

138
00:07:38,280 --> 00:07:40,500
, કે અમલ કરવામાં આવે છે.

139
00:07:40,500 --> 00:07:44,280
હું આ ડિબગ ક્લિક કરો, તો
કેસ, તે લાવશે

140
00:07:44,280 --> 00:07:48,230
કન્સોલ નવી ટેબ
ખૂબ તળિયે વિન્ડો.

141
00:07:48,230 --> 00:07:51,160
>> અને તમે આ ટેબ ધરાવે છે કે નહીં તે જોવા કરી શકો છો
ખૂબ જ ટોચ પર કેટલીક માહિતી.

142
00:07:51,160 --> 00:07:52,670
અને અમે મોટા પાયે આ અવગણી શકો છો.

143
00:07:52,670 --> 00:07:54,800
પરંતુ એક વસ્તુઓ
અમે નોટિસ છો કે

144
00:07:54,800 --> 00:07:57,170
તે આઉટપુટ છે
આ જ વસ્તુ છે કે અમે

145
00:07:57,170 --> 00:08:03,000
અમે બનાવવા ચલાવવા માટે પ્રયત્ન કર્યો તો મળી જશે
ટર્મિનલ વિન્ડોમાં સી કાર્યક્રમ.

146
00:08:03,000 --> 00:08:06,230
>> અહીં, અમે તે રણકાર ચાલી રહ્યું છે જોઈ શકે છે,
અને તે ફ્લેગ્સ વિવિધ હોય છે,

147
00:08:06,230 --> 00:08:12,660
અને તે બનાવે છે અમારા count.c ફાઈલ કમ્પાઈલ છે
જે તે સમયે પસંદ કરેલ ટેબ હતી

148
00:08:12,660 --> 00:08:15,100
કે હું ડિબગ હિટ.

149
00:08:15,100 --> 00:08:18,010
તેથી આ કારણ ખૂબ જ ઉપયોગી છે
હવે આ ડિબગ બટન નો ઉપયોગ કરીને,

150
00:08:18,010 --> 00:08:23,280
અમે વારાફરતી પછી કમ્પાઇલ અને કરી શકો છો
આ કાર્યક્રમ ચલાવવા છે કે અમે ખરેખર

151
00:08:23,280 --> 00:08:24,460
ચલાવવા માંગો છો.

152
00:08:24,460 --> 00:08:27,880
>> છે કે ફ્લેગ્સ એક
મહત્વપૂર્ણ, આ કિસ્સામાં,

153
00:08:27,880 --> 00:08:30,190
અમે ખરેખર ઉપયોગ કરી રહ્યો છું
સૌથી લાંબો સમય માટે

154
00:08:30,190 --> 00:08:32,450
પણ માત્ર કેટલાક હાથ કર્યું
waving [અશ્રાવ્ય] છે, કે જે

155
00:08:32,450 --> 00:08:33,820
અહીં આ એક છે.

156
00:08:33,820 --> 00:08:35,790
રણકાર, તે -ggdb3 કહે છે.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
આ કિસ્સામાં, અમે શું છે
રણકાર કહેવાની અમારા કમ્પાઇલર,

159
00:08:41,250 --> 00:08:43,820
અમે અમારા કાર્યક્રમ કમ્પાઇલ કરવા માંગો છો શકે છે.

160
00:08:43,820 --> 00:08:46,810
પણ શું છે પૂરી પાડે છે
કહેવાય પ્રતીક માહિતી

161
00:08:46,810 --> 00:08:50,940
કમ્પાઇલર ખરેખર વપરાશ હોય છે કે જેથી
અંતર્ગત માહિતી ઘણો

162
00:08:50,940 --> 00:08:52,610
આ કાર્યક્રમ અંદર સમાયેલ છે.

163
00:08:52,610 --> 00:08:55,260
>> વધુ ખાસ રીતે, આ નંબર
મારી પાસે જે કાર્યો,

164
00:08:55,260 --> 00:08:58,000
તે કાર્યો નામો
ચલો પ્રકારો

165
00:08:58,000 --> 00:09:01,730
તે ચલો, અને વિવિધ છે કે
ડીબગર મદદ કે અન્ય વસ્તુઓ

166
00:09:01,730 --> 00:09:04,350
તેની કામગીરી કરે છે.

167
00:09:04,350 --> 00:09:06,600
હવે બીજું કંઈક છે
ઉલ્લેખ કર્યો છે કે મહત્વપૂર્ણ છે

168
00:09:06,600 --> 00:09:10,280
જ્યારે અમે ચાલી ચર્ચા કરી રહ્યાં છો
આ રીતે એક કાર્યક્રમ.

169
00:09:10,280 --> 00:09:13,660
>> તે ખરેખર છે કે નોટિસ
અમારા કન્સોલમાં નવી ટેબ લાવવામાં

170
00:09:13,660 --> 00:09:14,780
તળિયે સાથે.

171
00:09:14,780 --> 00:09:18,600
અમે લાંબા સમય સુધી વાતચીત કરવા માટે હોય છે
સીધા ટર્મિનલ વિન્ડો સાથે.

172
00:09:18,600 --> 00:09:21,420
પરંતુ આ નવા ટેબ છે
ખરેખર ટર્મિનલ વિન્ડોમાં.

173
00:09:21,420 --> 00:09:26,710
તે માત્ર ચાલી ચોક્કસ છે
અમે બનાવેલ હોય કે કાર્યક્રમ.

174
00:09:26,710 --> 00:09:29,270
>> માં, નોંધ કરો કે તળિયે
કેટલાક આઉટપુટ સાથે મિશ્રણ

175
00:09:29,270 --> 00:09:33,500
કમ્પાઇલર અને GDB રણકાર દ્વારા,
અમે મોટે ભાગે અવગણી શકો છો, કે જે

176
00:09:33,500 --> 00:09:37,570
તે ખરેખર નું આઉટપુટ બતાવે
ખૂબ તળિયે અમારા કાર્યક્રમ.

177
00:09:37,570 --> 00:09:41,240
હવે તે સમજવુ અગત્યનુ છે
કે ખરેખર આ એક વિન્ડો

178
00:09:41,240 --> 00:09:43,360
તમે બતાવશે
તમારા કાર્યક્રમ આઉટપુટ

179
00:09:43,360 --> 00:09:47,190
પણ ઇનપુટ સ્વીકારી શકો છો
કે કાર્યક્રમ માટે, તેમજ.

180
00:09:47,190 --> 00:09:49,260
>> તેથી કહે છે કે નોટિસ
એક નંબર દાખલ કરો,

181
00:09:49,260 --> 00:09:53,050
જે અમે હતી તે જ આઉટપુટ છે
પહેલાં ટર્મિનલ વિન્ડોમાં હતી.

182
00:09:53,050 --> 00:09:55,510
પરંતુ તે હવે આ નવી ટેબ માં બતાવ્યા પ્રમાણે છે.

183
00:09:55,510 --> 00:09:56,550
હું ઇનપુટ એક નંબર કરી શકો છો.

184
00:09:56,550 --> 00:10:00,900
અને તે ખરેખર કરશે
કાર્ય અમે અપેક્ષા તરીકે

185
00:10:00,900 --> 00:10:05,890
અમને અમારા ડિબગ દર્શાવે છે, આઉટપુટ
બગડેલ હોઇ શકે છે આઉટપુટ

186
00:10:05,890 --> 00:10:07,010
અમે પહેલાં જોઇ છે.

187
00:10:07,010 --> 00:10:10,460
અને ખૂબ જ તળિયે, તો તે
વાસ્તવમાં કેટલાક વધારાના આઉટપુટ છે

188
00:10:10,460 --> 00:10:14,550
જીડીપી માત્ર કહે છે કે
આ કાર્યક્રમ પૂર્ણ કરી હતી.

189
00:10:14,550 --> 00:10:16,655
>> હવે તમે આ જોયું
દ્વારા ખાસ રન

190
00:10:16,655 --> 00:10:19,370
તે ખાસ કરીને ન હતી
ઉપયોગી પણ છે, કારણ

191
00:10:19,370 --> 00:10:23,740
અમે હતી છતાં ડીબગર મેનુ આવે છે
ઉપર, આ હજુ ચાલતી કાર્યક્રમ હતો.

192
00:10:23,740 --> 00:10:26,790
કોઈ સમયે ખરેખર તે કર્યું
અમારા માટે અમલ વિરામ

193
00:10:26,790 --> 00:10:30,767
બધી તપાસ કરવાનો પ્રયત્ન કરવા માટે
ચલો અંદર સમાયેલ છે.

194
00:10:30,767 --> 00:10:32,850
ત્યાં કંઈક બીજું છે
અમે ક્રમમાં શું કરવું છે કે

195
00:10:32,850 --> 00:10:36,910
અમે માંગો છો તે ઓળખી GDB વિચાર
આ કાર્યક્રમ અમલ વિરામ

196
00:10:36,910 --> 00:10:42,820
અને તે આગળ વધવા માટે પરવાનગી નથી
સામાન્ય રીતે આપણે અન્ય કોઇ કિસ્સામાં જેમ.

197
00:10:42,820 --> 00:10:45,530
>> અમલ અટકાવવા માટે,
અમુક ચોક્કસ વાક્ય પર,

198
00:10:45,530 --> 00:10:47,830
અમે શું છે બનાવવાની જરૂર છે
વિરામ બિંદુ કહેવાય છે.

199
00:10:47,830 --> 00:10:52,670
અને એક વિરામ બિંદુ ખૂબ સરળતાથી બનાવી છે
આ તમારા માઉસની લઈને IDE CS50

200
00:10:52,670 --> 00:10:57,090
અને ડાબી સીધા ક્લિક
અમુક ચોક્કસ લાઇન નંબર છે.

201
00:10:57,090 --> 00:10:59,920
હું આ કરી જાય છે, એક લાલ ટપકું
જે સૂચવે છે દેખાય છે,

202
00:10:59,920 --> 00:11:02,300
કે લીટી હવે વિરામ બિંદુ છે.

203
00:11:02,300 --> 00:11:07,540
>> અને હું GDB ચલાવવા કે આગામી સમય, તે
કે વિરામ સમયે અમલ કરવાનું બંધ કરશે

204
00:11:07,540 --> 00:11:10,280
તે કોડ કે વાક્ય પહોંચે છે.

205
00:11:10,280 --> 00:11:12,230
હવે આ એક મહત્વપૂર્ણ છે
વસ્તુ ખ્યાલ

206
00:11:12,230 --> 00:11:16,140
તે નથી કે જરૂરી
કેસ કે કોડ ઓફ દરેક લીટી

207
00:11:16,140 --> 00:11:17,880
ખરેખર સુલભ છે.

208
00:11:17,880 --> 00:11:23,780
હું એક કાર્ય બનાવવા માટે જ હોય
અહીં, ઉદાહરણ રદબાતલ f-- માટે

209
00:11:23,780 --> 00:11:31,230
અને માત્ર હેલો અહીં પ્રિન્ટ લીટી કરી
world-- હું આ કાર્ય કૉલ ક્યારેય નહિં, તો

210
00:11:31,230 --> 00:11:34,770
તે કિસ્સામાં હશે કે,
હું અહીં વિરામ બિંદુ સુયોજિત હોય તો,

211
00:11:34,770 --> 00:11:36,220
કાર્ય કહી શકાય નહીં.

212
00:11:36,220 --> 00:11:38,310
અને તેથી, આ
ચોક્કસ બ્રેક બિંદુ

213
00:11:38,310 --> 00:11:43,040
ખરેખર વિરામ નહીં
આ કાર્યક્રમ અમલ.

214
00:11:43,040 --> 00:11:48,020
>> તેથી હું યોગ્ય રીતે બનાવવા કહે છે કે દો
કોડ કેટલાક વાક્ય પર બ્રેક બિંદુ

215
00:11:48,020 --> 00:11:50,340
કે ખરેખર ચલાવવામાં આવશે.

216
00:11:50,340 --> 00:11:53,470
હવે આ કિસ્સામાં, આ છે
મુખ્ય કાર્ય પ્રથમ વાક્ય.

217
00:11:53,470 --> 00:11:56,630
તેથી તે ચોક્કસપણે કેસ હશે
કે, હું અમલ શરૂ જલદી,

218
00:11:56,630 --> 00:11:58,580
ખૂબ પ્રથમ વાક્ય પહોંચી કરવામાં આવશે.

219
00:11:58,580 --> 00:12:00,230
GDB અમલ અટકશે.

220
00:12:00,230 --> 00:12:04,100
અને પછી, હું કરવાનો પ્રયત્ન કરશે
ડીબગર સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

221
00:12:04,100 --> 00:12:08,480
>> તમે બહુવિધ રેખાઓ સુયોજિત કરી શકો છો
તમે ઈચ્છો, તો બ્રેકપોઇન્ટ્સ.

222
00:12:08,480 --> 00:12:11,365
અમે પણ એક વાક્ય બનાવી શકો છો
અહીં કોડ આ સેગમેન્ટમાં

223
00:12:11,365 --> 00:12:12,490
પહોંચી શકાય નહીં.

224
00:12:12,490 --> 00:12:14,744
અને અમે પણ વધુ નીચે એક સેટ કરી શકો છો.

225
00:12:14,744 --> 00:12:16,660
કારણ કે અમે કરશે
અમે પડશે આ કરવા માંગો છો

226
00:12:16,660 --> 00:12:19,119
થોડો વધુ જાય
માત્ર એક ક્ષણ વિગતવાર.

227
00:12:19,119 --> 00:12:21,660
તેથી હવે, મને માત્ર નિષ્ક્રિય દો
આ વધારાની બ્રેક પોઇન્ટ

228
00:12:21,660 --> 00:12:24,940
અમે શું થાય છે તે જોવા કરી શકો છો કે જેથી
હું એક વિરામ હોય છે ત્યારે

229
00:12:24,940 --> 00:12:27,650
મારા કાર્યક્રમ બિંદુ.

230
00:12:27,650 --> 00:12:29,410
હું કર્યા છે કેટલાક
આ કાર્યક્રમ માટે બદલે છે.

231
00:12:29,410 --> 00:12:30,750
તેથી હું તેને સેવ જરૂર છે.

232
00:12:30,750 --> 00:12:34,490
હું ડિબગ ક્લિક કરો હું કરી શકો છો કે જેથી
સંકલન શરૂ કરો અને પછી

233
00:12:34,490 --> 00:12:36,880
ડીબગર અમલ.

234
00:12:36,880 --> 00:12:40,632
>> અમે જોશો, કે ક્ષણો, પછી
અમે વિરામ તરીકે પસંદ તે લીટી

235
00:12:40,632 --> 00:12:43,360
બિંદુ પીળો પ્રકાશિત થયેલ છે.

236
00:12:43,360 --> 00:12:47,440
અમે પણ છે કે નોટિસ કરી શકો છો
ડિબગ પેનલ ઉપર જમણા

237
00:12:47,440 --> 00:12:50,940
વિરામ ચિહ્ન ચાલુ છે કે
થોડી નાટક ચિહ્ન માં.

238
00:12:50,940 --> 00:12:54,710
આ અમે વિરામ હોય છે
અમલ, આ ચોક્કસ કિસ્સામાં.

239
00:12:54,710 --> 00:12:57,840
અને આ નાટક બટન કરશે હિટ
અમને અમલ ફરી શરૂ કરવા માટે પરવાનગી આપે છે

240
00:12:57,840 --> 00:13:00,000
કે જે ચોક્કસ બિંદુએ.

241
00:13:00,000 --> 00:13:03,240
>> અન્ય એક દંપતિ છે કે નોટિસ
આ ડિબગ પેનલ માં ઉપલબ્ધ બટનો,

242
00:13:03,240 --> 00:13:04,220
તેમજ.

243
00:13:04,220 --> 00:13:09,470
મને પરવાનગી આપે છે, ઉપર પગલું
કોડ કે એક વાક્ય ચલાવો

244
00:13:09,470 --> 00:13:14,030
અને માટે તે લીટી પર પગલું
આ કિસ્સામાં આગામી એક છે, કે જે,

245
00:13:14,030 --> 00:13:17,060
આ printf કે તેનો અર્થ એ થાય
નિવેદનમાં ચલાવવામાં આવે છે.

246
00:13:17,060 --> 00:13:22,310
અને તે પછી વિરામ કરશે
આની જેમ વાક્ય પર 13 અમલ.

247
00:13:22,310 --> 00:13:25,090
>> અને પણ એક પગલું છે
કાર્ય માં જે

248
00:13:25,090 --> 00:13:28,950
હું અન્ય બનાવેલ હોય તો ઉપયોગી છે
અન્યત્ર સ્રોત કોડ કાર્ય કરે છે.

249
00:13:28,950 --> 00:13:31,420
અને હું સ્ટેપ ઇનટુ કરવા માંગો છો
તે કાર્યો બદલે

250
00:13:31,420 --> 00:13:33,050
સમગ્ર કે કાર્ય ચલાવો.

251
00:13:33,050 --> 00:13:37,279
પરંતુ અમે આ પગલું પર વધુ જોવા મળશે
માત્ર એક ક્ષણ કાર્ય માં.

252
00:13:37,279 --> 00:13:40,320
હવે કેટલાક અન્ય વસ્તુઓ નોંધ્યું છે કે
ખરેખર આ ડિબગ પેનલ અંદર અસ્તિત્વ ધરાવે છે.

253
00:13:40,320 --> 00:13:44,110
>> અમે આ પેનલ કહેવાય છે
જે અમને બતાવે છે, સ્ટેક કૉલ

254
00:13:44,110 --> 00:13:45,300
બરાબર જ્યાં અમે છે.

255
00:13:45,300 --> 00:13:48,550
આ કિસ્સામાં, અમે અંદર છે
મુખ્ય કાર્ય.

256
00:13:48,550 --> 00:13:50,880
અમારા સ્ક્રિપ્ટ count.c કહેવામાં આવે છે.

257
00:13:50,880 --> 00:13:53,820
અને અમે પર પ્રયત્ન થાય છે
રેખા 13, કૉલમ એક, જે

258
00:13:53,820 --> 00:13:58,950
શું પ્રકાશિત પ્રદેશ ચોક્કસપણે છે
સ્ત્રોત કોડ, તેમજ દર્શાવે છે.

259
00:13:58,950 --> 00:14:02,435
>> હવે આ પણ બતાવે છે કે નોટિસ
સ્થાનિક ચલ વિભાગ હેઠળ

260
00:14:02,435 --> 00:14:06,710
ચલો તમામ
આ કાર્ય અંદર અસ્તિત્વ ધરાવે છે.

261
00:14:06,710 --> 00:14:08,930
તે મહત્વપૂર્ણ છે નોંધ કરો
ચલો તમામ

262
00:14:08,930 --> 00:14:12,580
આ સ્થાનિક ચલ દેખાશે
એક કાર્ય અંદર વિભાગ

263
00:14:12,580 --> 00:14:14,380
પણ તેઓ વ્યાખ્યાયિત કરવામાં આવે છે તે પહેલાં.

264
00:14:14,380 --> 00:14:19,160
અમે એક ચલ છે કે અહીં જોઈ શકો છો
NUM કહેવાય છે, 0 ની મૂળભૂત કિંમત ધરાવે છે,

265
00:14:19,160 --> 00:14:21,280
અને તે પ્રકાર પૂર્ણાંક છે.

266
00:14:21,280 --> 00:14:24,110
>> હવે અમે ખરેખર પ્રારંભ પહેલાં
આ ચલો બધા

267
00:14:24,110 --> 00:14:26,685
અમે જરૂરી નથી
0 ની કિંમત જોવા માટે ખાતરી આપી.

268
00:14:26,685 --> 00:14:29,200
અને અન્ય ફાંસીની સજા પર આધાર રાખીને
તમે કરવામાં આવી છે કે

269
00:14:29,200 --> 00:14:32,020
અને તમારી મેમરી જ્યારે રાજ્ય
તમે ખરેખર આ કાર્યક્રમ ચલાવવા માટે,

270
00:14:32,020 --> 00:14:34,605
તમે જે શોધી શકે છે
0 કિંમતો જોવા નથી

271
00:14:34,605 --> 00:14:36,550
અને, તેના બદલે કેટલાક અન્ય ક્રેઝી નંબરો.

272
00:14:36,550 --> 00:14:38,390
>> પરંતુ તે વિશે ચિંતા નથી.

273
00:14:38,390 --> 00:14:44,610
તે ત્યાં સુધી સુસંગત હોઈ જવા નથી
તમે ખરેખર કિંમત પ્રારંભ.

274
00:14:44,610 --> 00:14:49,630
હવે આ કિસ્સામાં, અમે જોઈ શકો છો કે
હું કેટલાક આઉટપુટ રજૂઆત કરી છે.

275
00:14:49,630 --> 00:14:52,131
અને હું, હમણાં, અમલ થોભાવવામાં છું.

276
00:14:52,131 --> 00:14:53,880
પરંતુ આ કિસ્સામાં, શું
હું ખરેખર કરવા માંગો છો

277
00:14:53,880 --> 00:14:58,060
હવે આ લીટી પર પગલું છે
કોડ તેથી હું ખરેખર આ કરી શકો છો કે

278
00:14:58,060 --> 00:15:04,390
કે પૂર્ણાંક માટે વપરાશકર્તા પૂછપરછ કરે છે તે
અમે અમારા કાર્યક્રમ વાપરવા માંગો છો.

279
00:15:04,390 --> 00:15:07,060
>> હવે આ કિસ્સામાં, જ્યારે
હું નોટિસ પર પગલું હિટ

280
00:15:07,060 --> 00:15:11,940
કે બદલે અટકાવવા અથવા ફરી શરૂ કરો
બટન આ થોભો બટન માટે બદલાઈ ગયેલ છે

281
00:15:11,940 --> 00:15:14,022
આ કોડ વાસ્તવમાં ચલાવવા છે કારણ કે.

282
00:15:14,022 --> 00:15:15,730
શું થઇ રહ્યું છે
હમણાં તે છે

283
00:15:15,730 --> 00:15:21,630
ઇનપુટ અમારા માટે કેટલીક માહિતી રાહ જોઈ
અમે અમારા આઉટપુટ લખાણ દ્વારા જોઈ શકો છો

284
00:15:21,630 --> 00:15:23,600
ખૂબ તળિયે.

285
00:15:23,600 --> 00:15:25,787
>> તેથી હમણાં, આ છે
ખરેખર થોભાવવામાં નથી,

286
00:15:25,787 --> 00:15:28,620
પણ તે છતાં, પ્રકારની દેખાય છે,
કંઈ થઈ રહ્યું છે, કારણ કે હોય છે.

287
00:15:28,620 --> 00:15:32,360
પરંતુ તે માત્ર જેથી બને છે કે
વાક્ય પર 13 મારા ચોક્કસ કેસ,

288
00:15:32,360 --> 00:15:34,210
હું વપરાશકર્તા ઈનપુટ માટે રાહ જોઈ રહ્યો છું.

289
00:15:34,210 --> 00:15:39,130
અને તેથી GDB નિરીક્ષણ કરવા માટે સમર્થ નથી
તે એક કાર્યક્રમ ચાલી રહ્યો છે.

290
00:15:39,130 --> 00:15:43,370
>> હું કેટલાક દાખલ હવે આગામી સમય
input-- તેથી હું કે જે નંબર 5 દાખલ કરશો

291
00:15:43,370 --> 00:15:46,140
અમે જોઇ છે તરીકે
હિટ રીટર્ન past--, અને અમે

292
00:15:46,140 --> 00:15:51,430
કે તરત જ, GDB વિરામનો નોટિસ
અને, ફરી, આગળના વાક્ય પ્રકાશિત કરે છે.

293
00:15:51,430 --> 00:15:55,320
પરંતુ, હવે નોંધ્યું છે કે
અમારા નીચેની inputting પરિણામ,

294
00:15:55,320 --> 00:15:58,930
અમે અંદર તે કિંમત સુધારાશે છે
અમારા સ્થાનિક ચલો, જે

295
00:15:58,930 --> 00:16:05,560
ચોક્કસપણે ખબર ખૂબ જ ઉપયોગી છે
શું છે કે જે નંબર મેમરી હતી.

296
00:16:05,560 --> 00:16:10,650
>> હવે હું આ કાર્યક્રમ ચાલુ રાખવા માટે પરવાનગી આપી શકે છે
તેના અમલ ના અંત સુધી રમી

297
00:16:10,650 --> 00:16:12,570
ફરી શરૂ કરો મથાળે સ્પર્શી દ્વારા.

298
00:16:12,570 --> 00:16:16,410
અમે ખૂબ જ ઝડપથી જોઈ શકો છો કે
કાર્યક્રમ સમાપ્ત ચલાવવા કરે

299
00:16:16,410 --> 00:16:19,790
એ જ આઉટપુટ સાથે અમે
પહેલાં હતી, ડીબગર બંધ થાય છે,

300
00:16:19,790 --> 00:16:23,170
અને હવે આ કાર્યક્રમ
સંપૂર્ણપણે બંધ કરી દીધું છે.

301
00:16:23,170 --> 00:16:25,320
>> હું બતાવવા માટે જ છે કે
જોઈ હેતુ શું

302
00:16:25,320 --> 00:16:27,280
અમે ખરેખર રેઝ્યૂમે હિટ જ્યારે થાય છે.

303
00:16:27,280 --> 00:16:30,640
પરંતુ અમે ખરેખર કરવા જઇ રહ્યા છે
આ કાર્યક્રમ માં પાછા જવા માંગો છો

304
00:16:30,640 --> 00:16:33,820
અમે ડિબગ પ્રયત્ન કરી શકો છો કે જેથી
ચોક્કસપણે શું બની રહ્યું છે.

305
00:16:33,820 --> 00:16:37,980
હું ડીબગર ઉપયોગ કરું છું કે હવે, હું કરી શકે છે
આ ડિબગ printf નિવેદનો જરૂર નથી.

306
00:16:37,980 --> 00:16:43,860
>> હું કરીશ, જેથી હું તેમને દૂર કરી શકે છે
હવે અમારા સરળ કોડ પર પાછા જાઓ

307
00:16:43,860 --> 00:16:45,950
અમે એક ક્ષણ પહેલા હતી.

308
00:16:45,950 --> 00:16:48,790
હવે હું સેવ જ્યારે
કાર્યક્રમ અને તે ચલાવવા,

309
00:16:48,790 --> 00:16:53,700
એટલે કે, ફરી છે કે પ્રારંભિક પર જશે
હું 11 લીટી પર હતું કે બિંદુ તૂટી જાય છે.

310
00:16:53,700 --> 00:16:57,700
અને હું નિરીક્ષણ કરવા માટે સમર્થ હશો
મારા ચલો હું શું કરવા માંગો છો.

311
00:16:57,700 --> 00:17:00,695
>> તે માત્ર જેથી આ છે કે જે થાય છે
ભાગ ખૂબ જ રસપ્રદ નથી

312
00:17:00,695 --> 00:17:04,364
અને હું જાઉં છું ખબર છે કે
આ નિવેદન છાપે.

313
00:17:04,364 --> 00:17:05,280
એક નંબર દાખલ કરો.

314
00:17:05,280 --> 00:17:08,099
અને પછી, હું જાઉં છું ખબર છે કે
કે પૂર્ણાંક માટે વપરાશકર્તા પૂછો.

315
00:17:08,099 --> 00:17:13,329
તેથી કદાચ, હું ખરેખર ખસેડવા માંગો છો મારા
નીચે થોડો વધુ બિંદુ તૂટી જાય છે.

316
00:17:13,329 --> 00:17:16,710
>> તમે બ્રેક પોઇન્ટ દૂર કરી શકો છો
સીધા, ફરી, પર ક્લિક કરીને

317
00:17:16,710 --> 00:17:18,460
તે લીટી નંબર ડાબી છે.

318
00:17:18,460 --> 00:17:22,200
કે લાલ ટપકું દર્શાવે છે અદૃશ્ય થઈ જશે
કે વિરામ બિંદુ હવે ગયો છે.

319
00:17:22,200 --> 00:17:24,780
હવે આ કિસ્સામાં,
અમલ થોભાવવામાં આવી છે.

320
00:17:24,780 --> 00:17:27,770
અને તેથી તે ખરેખર નથી ચાલી રહ્યું છે
કે જે ચોક્કસ ઉદાહરણ ફરીથી શરૂ કરો.

321
00:17:27,770 --> 00:17:30,210
પરંતુ હું એક વિરામ સેટ કરી શકો છો
થોડુંક પછીથી નિર્દેશ કરે છે.

322
00:17:30,210 --> 00:17:33,880
>> અને હવે હું ફરી શરૂ ત્યારે મારા
કોડ છે, તે શરૂ કરો અને કહેશે

323
00:17:33,880 --> 00:17:36,190
કે વિરામ ચિહ્ન બિંદુ.

324
00:17:36,190 --> 00:17:37,374
ફરીથી, હું ફરી શરૂ નહીં.

325
00:17:37,374 --> 00:17:39,040
કંઈપણ થઈ રહ્યું છે જેમ તેમ લાગતું નથી.

326
00:17:39,040 --> 00:17:41,450
પરંતુ તે મારા કારણ
કોડ ઈનપુટ માટે રાહ જોઈ રહ્યું છે.

327
00:17:41,450 --> 00:17:47,900
હું એક નંબર 5 દાખલ કરો દબાવો, અને કરશે
હવે આગામી વિરામ બિંદુ હિટ કરવામાં આવશે.

328
00:17:47,900 --> 00:17:50,570
>> હવે આ કિસ્સામાં, આ
કોડ વાક્ય છે

329
00:17:50,570 --> 00:17:53,820
કે, તે પહેલાં, અમે જાણતા હતા
બગડેલ હોઇ થયું.

330
00:17:53,820 --> 00:17:57,590
તેથી શું થાય છે મૂલ્યાંકન દો
આ સમય ચોક્કસ બિંદુએ.

331
00:17:57,590 --> 00:18:02,620
એક વાક્ય પ્રકાશિત થયેલ છે ત્યારે, આ
લીટી હજુ સુધી ચલાવવામાં આવી નથી.

332
00:18:02,620 --> 00:18:06,490
તેથી આ કિસ્સામાં, અમે જોઈ શકો છો
હું એક નંબર છે, કે જે જે

333
00:18:06,490 --> 00:18:11,610
મને કહેવામાં આવે પૂર્ણાંક છે
નીચેની 5 છે કે ગણ.

334
00:18:11,610 --> 00:18:15,090
અને હું ચલાવી કરી જાઉં છું
કે જે નંબર પર કેટલાક ગણિત.

335
00:18:15,090 --> 00:18:20,130
>> મને લાગે છે કે પર પગલું, તો અમે કરી શકો છો
NUM માટે કિંમત છે કે જે નોટિસ

336
00:18:20,130 --> 00:18:23,780
આ અનુસાર બદલાઈ ગયેલ છે
અમે ખરેખર કર્યું છે કે અંકગણિત.

337
00:18:23,780 --> 00:18:26,810
અને હવે અમે છે કે
અંદર લૂપ માટે આ

338
00:18:26,810 --> 00:18:29,090
અથવા હવે કે લૂપ માટે
પોતે પ્રકાશિત થયેલ છે,

339
00:18:29,090 --> 00:18:32,450
અમે એક નવી હોય કે નહીં તે જોવા
ચલ કે હું કહેવાય

340
00:18:32,450 --> 00:18:35,370
લૂપ માટે કે ઉપયોગ કરી રહ્યું છે.

341
00:18:35,370 --> 00:18:38,230
>> હવે હું પહેલાં યાદ
ક્યારેક તમે છો કે ઉલ્લેખ કર્યો છે

342
00:18:38,230 --> 00:18:43,470
ક્રેઝી અમુક પ્રકારના જોવા જઈ
કે જે નંબર પહેલાં મૂળભૂત તરીકે નંબરો

343
00:18:43,470 --> 00:18:45,530
અથવા તે ચલ છે
ખરેખર આરંભ.

344
00:18:45,530 --> 00:18:49,040
અમે ચોક્કસપણે કે જોઈ શકો છો
અહીં આ ચલ માં

345
00:18:49,040 --> 00:18:51,345
નથી જે, હું કહેવાય
હજુ સુધી આરંભ કરવામાં

346
00:18:51,345 --> 00:18:53,560
પ્રકાશ સમયે.

347
00:18:53,560 --> 00:18:57,070
પરંતુ અમે તે કેટલાક નંબર છે કે જોઈ શકો છો
અમે ખરેખર નથી અપેક્ષા કરશે.

348
00:18:57,070 --> 00:18:57,620
>> એ બરાબર છે.

349
00:18:57,620 --> 00:18:59,661
તે વિશે ચિંતા કરશો નહીં
અમે ખરેખર છે, કારણ કે

350
00:18:59,661 --> 00:19:04,970
હું ત્યાં સુધી કે જે નંબર આરંભ
આ વાક્ય અને કિંમત પર પગલું

351
00:19:04,970 --> 00:19:08,560
હું કિંમત 1 થી આરંભ કરવામાં આવ્યો છે.

352
00:19:08,560 --> 00:19:11,400
તેથી તે ખરેખર છે કે નહીં તે જોવા માટે
આ કિસ્સામાં, માતાનો પર પગલું દો.

353
00:19:11,400 --> 00:19:14,420
હવે અમે તે જોઈ શકે છે કે
લીટી ચલાવવામાં આવી છે.

354
00:19:14,420 --> 00:19:17,000
અને અમે હવે પ્રકાશ છે
આ printf રેખા.

355
00:19:17,000 --> 00:19:22,230
>> અને અમે હવે કેવી રીતે અમારા કિંમતો જોઈ શકો છો
હું અને 3 સમય પર બદલાઈ ગયેલ છે.

356
00:19:22,230 --> 00:19:26,450
આ હકીકત માં, કરવા માટે ખૂબ જ ઉપયોગી છે,
વારંવાર લીટીઓ પર પગલું છે.

357
00:19:26,450 --> 00:19:30,480
અને તમે શું ખરેખર શોધી શકો છો
તમારા માટે લૂપ અંદર થાય છે

358
00:19:30,480 --> 00:19:33,660
અને શું થાય છે
અંદર લૂપ માટે કે ચલો

359
00:19:33,660 --> 00:19:39,200
કે કાર્યક્રમ અમલ તરીકે
એક સમયે એક પગલું જોવા મળે છે.

360
00:19:39,200 --> 00:19:41,110
>> હવે આ બિંદુએ, હું
પૂરતું પર ઊતર્યા

361
00:19:41,110 --> 00:19:44,210
હવે હું મારા કાર્યક્રમ ઓવરને અંતે છું.

362
00:19:44,210 --> 00:19:46,980
મને લાગે છે કે પર પગલું છે, તો તે ચાલશે
ખરેખર અમલ બંધ

363
00:19:46,980 --> 00:19:48,860
અમે ભૂતકાળમાં જોઈ છે.

364
00:19:48,860 --> 00:19:52,110
તેથી, મને હજુ સુધી ફરીથી, આ પુનઃશરૂ કરો
હું કંઈક બીજું નિર્દેશ કરી શકો છો કે,

365
00:19:52,110 --> 00:19:53,320
તેમજ.

366
00:19:53,320 --> 00:19:55,350
>> આ કિસ્સામાં, તે છે
હવે ફરી, મને પૂછ્યા

367
00:19:55,350 --> 00:19:57,100
એક નંબર માટે જે
હું, ફરી, દાખલ કરવામાં આવશે.

368
00:19:57,100 --> 00:20:00,300
પરંતુ આ સમય, હું જાઉં છું દાખલ કરો
મોટી સંખ્યામાં છે, કે જેથી લૂપ માટે

369
00:20:00,300 --> 00:20:02,540
વધુ વખત ફરી વળવું પડશે.

370
00:20:02,540 --> 00:20:06,090
આ કિસ્સામાં, હું જાઉં છું
11 ની કિંમત દાખલ કરો.

371
00:20:06,090 --> 00:20:08,390
>> હવે ફરીથી હું સુયોજિત કરશો કારણ કે
15 લીટી પર એક વિરામ બિંદુ,

372
00:20:08,390 --> 00:20:10,490
તે લીટી પ્રકાશિત કરવા જઈ રહ્યું છે.

373
00:20:10,490 --> 00:20:12,980
અમે જોઈ શકો છો કે અમારા
નંબર 11 યોગ્ય રીતે છે

374
00:20:12,980 --> 00:20:15,560
અમારા સ્થાનિક ચલો રજૂ કરે છે.

375
00:20:15,560 --> 00:20:22,460
અમે હવે, કે ઉપર કરી શકો છો વેગ
હું અમારા કિંમત થાય છે તે જુઓ

376
00:20:22,460 --> 00:20:25,680
અમે લૂપ માટે આ અંદર આગળ વધી છે.

377
00:20:25,680 --> 00:20:31,960
તે દર વખતે આપણે વધે નહીં
લૂપ માટે કે ટોચ સુધી પહોંચે છે.

378
00:20:31,960 --> 00:20:35,110
>> એક વસ્તુઓ હવે કદાચ
અમલ દરમિયાન શું માટે ઉપયોગી હોઈ

379
00:20:35,110 --> 00:20:40,490
આ કાર્યક્રમ ખરેખર મારા માટે છે
જોવા માટે ચલો midstream બદલવા

380
00:20:40,490 --> 00:20:42,450
શું મારા કાર્યક્રમ થાય છે.

381
00:20:42,450 --> 00:20:46,540
આ કિસ્સામાં, હું ખરેખર આ કરી શકો છો
ડબલ કિંમત પર ક્લિક કરો.

382
00:20:46,540 --> 00:20:48,040
તે લખાણ ક્ષેત્રમાં બની જાય છે કે નોટિસ.

383
00:20:48,040 --> 00:20:50,280
>> હવે હું અલગ દાખલ કરી શકો છો
એકસાથે કદર

384
00:20:50,280 --> 00:20:55,700
મારા કાર્યક્રમ કેવી રીતે વર્તે છે જોવા માટે
મને લાગે છે કે ચલ બદલ્યું છે.

385
00:20:55,700 --> 00:20:59,560
હવે આ કિસ્સામાં, ચલ
હવે હું કિંમત 10 છે.

386
00:20:59,560 --> 00:21:02,810
પરંતુ આ કાર્યક્રમ હજુ પણ છે
અમલ માં રોક્યો છે.

387
00:21:02,810 --> 00:21:07,610
હું પગલું ત્યારે, હું જુઓ કે
હું 10 તરીકે દાખલ જે કિંમત હું,

388
00:21:07,610 --> 00:21:12,170
, NUM ની કિંમત કરતાં વધારે છે
જે તરત જ લૂપ માટે માટેનું કારણ બને છે

389
00:21:12,170 --> 00:21:14,240
ચલાવવા રોકવા માટે.

390
00:21:14,240 --> 00:21:16,210
>> હવે માત્ર નથી
કારણ શા માટે તમે છો

391
00:21:16,210 --> 00:21:19,450
જગ્યાએ ચલ સુધારવા માંગો છો.

392
00:21:19,450 --> 00:21:22,210
તમે ખરેખર માંગો છો શકે છે
તેથી તે સુધારવા માટે પ્રયાસ કરવા માટે

393
00:21:22,210 --> 00:21:24,590
તમે આ ચાલુ કરી શકો છો કે
લૂપ અમલ

394
00:21:24,590 --> 00:21:27,370
કે જેથી તમે સંશોધિત કરી શકો છો
તે પહેલાં કેટલાક કિંમત

395
00:21:27,370 --> 00:21:32,630
અંકગણિત કેટલાક ચોક્કસ સમૂહ સુધી પહોંચે છે
તમે કરવા માટે વિશે હોય છે.

396
00:21:32,630 --> 00:21:36,210
>> તેથી હવે અમે ખરેખર બદલવાની
આ કાર્યક્રમ તરીકે હું કિંમત તે અમલ કરતું હતું

397
00:21:36,210 --> 00:21:39,540
તે લૂપ માટે બહાર નીકળવા માટે કારણે
અકાળે હું અચાનક તમામ, કારણ કે

398
00:21:39,540 --> 00:21:42,770
આ કિંમત કરતાં વધારે હોઈ થયું
NUM ના, લૂપ માટે કે જેનો અર્થ થાય છે

399
00:21:42,770 --> 00:21:45,410
લાંબા સમય સુધી ચલાવવામાં આવશે જરૂર છે.

400
00:21:45,410 --> 00:21:48,780
વધુમાં, તે પ્રયત્ન થયું
અમે i ની કિંમત બદલી કે કેસ

401
00:21:48,780 --> 00:21:53,270
લીટી 17 પ્રકાશિત કરવામાં આવી હતી, ત્યારે
સમય માં બિંદુ હતી, જે

402
00:21:53,270 --> 00:21:56,280
તે લૂપ અમલ માટે
ખરેખર મૂલ્યાંકન કરવામાં આવી હતી.

403
00:21:56,280 --> 00:22:00,210
>> હું કિંમત બદલી હોત તો
હું એક અલગ લીટી પર, 19 કહે છે

404
00:22:00,210 --> 00:22:03,360
અમે વિવિધ જોઈ હશે
વર્તન રેખા 19 છે કારણ કે

405
00:22:03,360 --> 00:22:08,310
લૂપ ચલાવવા પહેલા છે
શરત reevaluated કરવામાં આવી હતી.

406
00:22:08,310 --> 00:22:11,900
હવે આ બિંદુએ, હું છું, ફરી,
આ કાર્યક્રમ ઓવરને અંતે.

407
00:22:11,900 --> 00:22:15,707
અને હું આ માટે આગળ વધવા માટે પરવાનગી આપી શકે છે
મારા કાર્યક્રમ કુદરતી બહાર નીકળવા માટે પરવાનગી આપે છે.

408
00:22:15,707 --> 00:22:18,290
પરંતુ બધી વસ્તુઓ એક દંપતિ છે
દૂર લઇ મહત્વપૂર્ણ છે કે

409
00:22:18,290 --> 00:22:19,960
આ ચોક્કસ ચર્ચા છે.

410
00:22:19,960 --> 00:22:22,490
તમે મૂલ્યાંકન કરવાની જરૂર છે
તમારા પોતાના ધારણા

411
00:22:22,490 --> 00:22:24,710
કેવી રીતે વિશે કોડ વર્તન જોઇએ.

412
00:22:24,710 --> 00:22:28,220
કોઈપણ સમયે તમે કેટલાક ભાગ લાગે છે કે
તમે જાણો છો કોડ કામ કરવા માટે થાય છે,

413
00:22:28,220 --> 00:22:30,940
તે જવા માટે એક લાલ ધ્વજ હોઈ શકે છે
અને પાછળ મૂલ્યાંકન, અને ખાતરી કરો

414
00:22:30,940 --> 00:22:33,470
તમારા ધારણા છે કે
કેવી રીતે કોડ સંચાલન કરવામાં આવે છે

415
00:22:33,470 --> 00:22:38,290
તે કેવી રીતે ખરેખર સાચું છે
તમારો સ્રોત કોડમાં વ્યક્ત કરી હતી.

416
00:22:38,290 --> 00:22:41,300
>> પરંતુ બિંદુ પણ વધુ હતી,
અમે ડીબગર વાપરી રહ્યા હોય ત્યારે,

417
00:22:41,300 --> 00:22:43,920
તમે ઓછામાં બ્રેકપોઇન્ટ્સ મૂકી શકો છો
કોડ વિવિધ રેખાઓ,

418
00:22:43,920 --> 00:22:48,110
માટે ડીબગર કારણ બનશે કે જે
તે રેખાઓ દરેક અટકશે અમલ

419
00:22:48,110 --> 00:22:52,210
જેથી તમે મૂલ્યાંકન કરી શકે છે કે
મેમરી અથવા પણ જગ્યાએ તેને બદલો.

420
00:22:52,210 --> 00:22:55,630
અને ફરી, તમે કરી શકો છો યાદ રાખો કે
બહુવિધ બ્રેકપોઇન્ટ્સ બનાવો કે જેથી તમે

421
00:22:55,630 --> 00:23:00,390
પણ અમલ ફરી શરૂ કરી શકો છો, અવગણો
કોડ મોટા ભાગ પર,

422
00:23:00,390 --> 00:23:04,790
અને તે આપોઆપ વિરામ પડશે
આગામી વિરામ સમયે.

423
00:23:04,790 --> 00:23:07,760
>> ખરેખર વધુ અદ્યતન છે
ડીબગર ના લક્ષણો, તેમજ.

424
00:23:07,760 --> 00:23:10,170
પરંતુ અમે તમને સંદર્ભ લો પડશે
કેટલીક અનુગામી વિડિઓઝ

425
00:23:10,170 --> 00:23:14,090
ખરેખર કેવી રીતે સિવાય પીંજવું માટે
તે ચોક્કસ કાર્યો વાપરવા માટે.

426
00:23:14,090 --> 00:23:15,990
હવે માટે, આભાર
જોવા માટે ખૂબ ખૂબ.

427
00:23:15,990 --> 00:23:18,080
અને સારા નસીબ ડિબગીંગ.