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
మేము ఔట్పుట్ చేస్తున్నారు ఇక్కడ ఉంటే, కేవలం, 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
మేము అప్పుడు మీరే చుట్టూ అనుకుంటున్నారా
మేము అనుకొనుట తెలుసు ఉండవచ్చు

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
కానీ కేవలం కొన్ని చేతి చేశాడు
ఊపుతూ [వినబడని], అందులో

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
GDP నుండి కేవలం చెప్పి
ఈ కార్యక్రమం పూర్తి.

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
మరియు అది రకం Int ఉంటుంది.

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
>> నేను కొన్ని ఎంటర్ ఇప్పుడు తదుపరి సమయం
ఇన్పుట్గా కాబట్టి నేను ఆ సంఖ్య 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
కానీ ఒక వంటి, ఇప్పుడు గమనించవచ్చు
మన విలువ ఇవ్వడం ఫలితంగా,

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
Resume కొట్టడమే.

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
మేము నిజానికి Resume కొట్టాడు జరుగుతుంది.

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 కలిగి num.

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
లేదా ఆ వేరియబుల్
నిజానికి initialized.

344
00:18:45,530 --> 00:18:49,040
మేము ఖచ్చితంగా చూడగలరు
ఇక్కడ ఈ వేరియబుల్

345
00:18:49,040 --> 00:18:51,345
లేదు ఇది, నేను అనే
ఇంకా initialized

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
నేను వరకు ఆ సంఖ్యను initialized
ఈ రేఖ విలువ అతిక్రమించి

351
00:19:04,970 --> 00:19:08,560
నేను విలువ 1 to initialized ఉంది.

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
>> మరియు మేము ఇప్పుడు ఎలా మా విలువలు చూడగలరు
I మరియు 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
ఎక్కువ సార్లు iterate ఉంటుంది.

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
ఈ కార్యక్రమం నిజానికి నాకు ఉంది
చూడండి వేరియబుల్స్ మిడ్ స్ట్రీం మార్చడానికి

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
లూప్ ముందు అమలు చేశాయి
పరిస్థితి రివాల్యువేటెడ్ జరిగినది.

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
కూడా అమలు చేసుకోగలుగుతారు, skip
కోడ్ యొక్క పెద్ద భాగాలు పైగా,

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
మరియు మంచి అదృష్టం డీబగ్గింగ్.