1
00:00:07,170 --> 00:00:12,630
[Powered by Google Translate] GDB, GNU ప్రాజెక్ట్ డీబగ్గర్, సి ఒక శక్తివంతమైన డీబగ్గింగ్ సాధనం

2
00:00:12,630 --> 00:00:14,300
అనేక ఇతర భాషలు పాటు.

3
00:00:14,300 --> 00:00:17,440
వారు అమలు ఉన్నప్పుడు, మీ సి కార్యక్రమాలలో చుట్టూ దూర్చు అనుమతిస్తుంది

4
00:00:17,440 --> 00:00:20,880
మరియు అది కూడా మీరు జరిగినప్పుడు సరిగ్గా చూడటానికి అవకాశం ఇస్తుంది

5
00:00:20,880 --> 00:00:22,490
మీ ప్రోగ్రామ్ దూసుకుపోయింది.

6
00:00:22,490 --> 00:00:24,690
ఇది కుడి, అందంగా నిఫ్టీ ఏమిటి?

7
00:00:24,690 --> 00:00:27,980
GDB ఉచిత సాఫ్ట్వేర్, మరియు అనేక ప్రసిద్ధ UNIX అమలు మరియు

8
00:00:27,980 --> 00:00:31,840
Windows-ఆధారిత ఆపరేటింగ్ వ్యవస్థలు, అందువలన ఇది చాలా విస్తృతమైన సాధనం.

9
00:00:31,840 --> 00:00:33,560
>> మీరు ప్రేమించే గురించి తెలుసుకోవాలి.

10
00:00:33,560 --> 00:00:36,800
GDB ప్రోస్ దోషాలు జాడ ఒక సులభంగా

11
00:00:36,800 --> 00:00:39,150
అంచనాలు ఉపయోగించి ద్వారా గజిబిజి వారికంటే

12
00:00:39,150 --> 00:00:41,420
మరియు ప్రింటవుట్ ప్రకటనలు అనంతమైన పరిమాణంలో.

13
00:00:41,420 --> 00:00:45,810
GDB మీరు టెర్మినల్ లో వ్యవహరించవచ్చు, అనగా ఒక ఆదేశ పంక్తి సాధనం

14
00:00:45,810 --> 00:00:49,720
మీ మౌస్ తో కీబోర్డు ద్వారా ఆదేశాలు బదులుగా క్లిక్ బటన్లు జారీ.

15
00:00:49,720 --> 00:00:54,960
>> GDB అప్ ప్రారంభించడానికి, మీరు వాచ్యంగా ప్రాంప్ట్ మరియు హిట్ కేవలం రకం GDB ఎంటర్.

16
00:00:54,960 --> 00:00:58,230
మీరు తెరకు ముద్రించిన కొన్ని పంక్తులు చూస్తారు

17
00:00:58,230 --> 00:01:00,810
, మీరు రన్ చేస్తున్న మీరు GDB యొక్క చూపిస్తున్న

18
00:01:00,810 --> 00:01:07,890
దాని కాపీరైట్ సమాచారం, మరియు చివరిలో మీరు GDB ప్రాంప్ట్ చూస్తారు: (GDB).

19
00:01:07,890 --> 00:01:10,770
ఈ మీరు GDB ఆదేశాలను సిద్దంగా తెలియచేస్తుంది.

20
00:01:10,770 --> 00:01:15,400
ఈ సమయంలో, ఎలా చెయ్యాలో తెలుసుకోవడం చాలా ముఖ్యమైన విషయం విడిచి ఉంది.

21
00:01:15,400 --> 00:01:17,790
అదృష్టవశాత్తూ, ఈ అందంగా సులభం.

22
00:01:17,790 --> 00:01:19,840
విడిచి ఆదేశం ఆ చేస్తుంది.

23
00:01:19,840 --> 00:01:23,090
ఒక షార్ట్కట్, మీరు కేవలం q చాలా ఉపయోగించవచ్చు.

24
00:01:23,090 --> 00:01:27,410
వినోదం GDB అప్ బూటింగ్ తరువాత వెంటనే త్యజించడం వంటి ఉంది,

25
00:01:27,410 --> 00:01:30,800
ఒక ప్రోగ్రామ్ డీబగ్ సహాయం GDB ఉపయోగించడం గురించి మాట్లాడటానికి ఇప్పుడు చూద్దాం.

26
00:01:30,800 --> 00:01:34,630
>> ప్రారంభించడానికి, నేను ఇక్కడ factorial.c లో ఒక ప్రోగ్రామ్ పొందారు

27
00:01:34,630 --> 00:01:37,380
ఒక Int వచ్చి దాని కారకమైన గణించడం ప్రయత్నిస్తుంది.

28
00:01:37,380 --> 00:01:41,270
ఒకవేళ మీరు, ముందు factorials చూడని లేదా వాటిని గుర్తు లేదు

29
00:01:41,270 --> 00:01:47,840
సంఖ్య యొక్క కారకమైన n n యొక్క ఉత్పత్తి సమానంగా ఉంటుంది - (n - 1), (n - 2) మరియు ఆ విధంగా -

30
00:01:47,840 --> 00:01:49,230
మీరు 1 హిట్ వరకు.

31
00:01:49,230 --> 00:01:54,550
అందువలన, 3 యొక్క కారకమైన 3 * 2 * 1, లేదా 6,

32
00:01:54,550 --> 00:02:00,180
మరియు 4 యొక్క కారకమైన 4 ఉంటుంది * 3 * 2 * 1, లేదా 24.

33
00:02:00,180 --> 00:02:03,970
సున్నా కారకమైన బేసి సందర్భంలో, అది, 1 యొక్క

34
00:02:03,970 --> 00:02:06,970
మరియు ప్రతికూల పూర్ణాంకాల factorials నిర్వచింపబడలేదు.

35
00:02:06,970 --> 00:02:10,280
ఏమైనా, నా కారకమైన కార్యక్రమం గురించి అల్లరిగా ఉంది.

36
00:02:10,280 --> 00:02:15,410
నేను దీన్ని అమలు, అది factorials తో లేదు ఆ విచిత్రమైన సంఖ్యలను ముద్రిస్తుంది.

37
00:02:15,410 --> 00:02:19,030
>> కాబట్టి, మేము ఏమి గుర్తించడానికి సహాయంగా GDB ఉపయోగించవచ్చు.

38
00:02:19,030 --> 00:02:21,720
GDB, ఎగ్జిక్యూటబుల్ ఫైళ్లు పనిచేస్తుంది

39
00:02:21,720 --> 00:02:24,910
ఇది సంగ్రహంలో ద్వారా ఉత్పత్తి బైనరీ ఫైళ్లు.

40
00:02:24,910 --> 00:02:30,940
అంటే, మేము మా. సి న GDB అమలు లేదా కాదు. Factorial.c వంటి h సోర్స్ కోడ్ ఫైళ్లు.

41
00:02:30,940 --> 00:02:34,650
మేము బదులుగా కేవలం కారకమైన మీద అమలు చేయండి.

42
00:02:34,650 --> 00:02:38,340
కార్యక్రమం ఏ ఆదేశ పంక్తి వాదనలు అవసరం ఉంటే,

43
00:02:38,340 --> 00:02:40,230
మేము వాటిని పేర్కొనవచ్చు చోట ఈ ఉంది.

44
00:02:40,230 --> 00:02:44,050
ఈ సందర్భంలో, కారకమైన, ఏ ఆదేశ పంక్తి వాదనలు అవసరం లేదు

45
00:02:44,050 --> 00:02:46,410
కాబట్టి మేము కేవలం చిన్న పోటీ లేదా r టైప్ చేయండి.

46
00:02:46,410 --> 00:02:50,440
>> ఈ కారకమైన ప్రోగ్రామ్ను అమలు ప్రారంభమౌతుంది.

47
00:02:50,440 --> 00:02:53,940
ప్రోగ్రామ్ను అమలు ఆపి, నేను, నా GDB తిరిగి ప్రాంప్ట్ పొందుతారు.

48
00:02:53,940 --> 00:02:58,130
సరే, యొక్క 4 యొక్క కారకమైన, మళ్ళీ ఇదే ప్రయత్నించండి తెలియజేయండి.

49
00:02:58,130 --> 00:03:02,910
All right, మేము GDB ఇక్కడ వ్యర్థ రకమైన పొందడానికి మేము చూసాము.

50
00:03:02,910 --> 00:03:04,850
కార్యక్రమం పూర్తి ఇప్పుడు ఆ,

51
00:03:04,850 --> 00:03:06,870
మేము, లో వెళ్ళి దాని రాష్ట్ర ఏ యాక్సెస్ చేయలేరు

52
00:03:06,870 --> 00:03:09,870
కనుక మేము ఏం చూడటానికి ముందు మళ్లీ అమలు ప్రారంభం చేయాలి.

53
00:03:09,870 --> 00:03:13,570
అయితే, మేము దాని రన్ మధ్యలో ఉన్నప్పుడు అది ఆపే మార్గం అవసరం.

54
00:03:13,570 --> 00:03:16,970
>> అలా చెయ్యడానికి, బ్రేక్పాయింట్ని అని ఏమి ఉపయోగించండి.

55
00:03:16,970 --> 00:03:21,880
బ్రేక్ పాయింట్స్ ఒక నిర్దిష్ట విధిని లేదా సోర్సు కోడ్ లైన్ వద్ద విరామం కార్యక్రమానికి GDB చెప్పండి

56
00:03:21,880 --> 00:03:24,070
కాబట్టి మేము, ప్రోగ్రామ్ యొక్క స్థితి పరిశీలించడానికి చేయవచ్చు

57
00:03:24,070 --> 00:03:27,380
చరరాశులు యొక్క విలువలలో, మెమరీ రాష్ట్ర మరియు ఆ సమయంలో.

58
00:03:27,380 --> 00:03:30,750
నేను నిజంగా విషయాలు తప్పు వెళ్తున్నారు పేరు తెలియదు కాబట్టి,

59
00:03:30,750 --> 00:03:33,510
>> నేను, కుడి చాలా ప్రారంభంలో డీబగ్గింగ్ ప్రారంభం కావాలి

60
00:03:33,510 --> 00:03:36,510
ప్రధాన ప్రారంభమవుతుంది కుడి ఉన్నప్పుడు.

61
00:03:36,510 --> 00:03:39,260
మేము విరామం ఆదేశాన్ని ఉపయోగించి ప్రధాన ప్రారంభంలో ఒక బ్రేక్ పాయింట్ సెట్ చేస్తాము.

62
00:03:39,260 --> 00:03:42,640
మేము కూడా బ్రేక్ నిర్వచించడం బి ఉపయోగించవచ్చు.

63
00:03:42,640 --> 00:03:45,000
ఇప్పుడు ప్రోగ్రామ్ మళ్లీ అమలు ప్రారంభిద్దాం.

64
00:03:45,000 --> 00:03:48,140
ఇక్కడ మేము GDB మాకు చెబుతుంది వలె, ప్రధాన ప్రారంభంలో ఉంటాయి.

65
00:03:48,140 --> 00:03:51,970
అమలు గురించి కానీ ఇంకా ఆ కోడ్ యొక్క లైన్

66
00:03:51,970 --> 00:03:53,480
printf లైన్.

67
00:03:53,480 --> 00:03:57,200
మేము కోడ్ యొక్క ఈ లైన్ అమలు మరియు తరువాత లైన్ వెళ్ళడానికి GDB తెలియజేయవచ్చు

68
00:03:57,200 --> 00:03:59,840
తదుపరి లేదా n ఆదేశంతో.

69
00:03:59,840 --> 00:04:04,120
>> All right, ఇప్పుడు GDB మేము GetInt లైన్ లో మాకు చెబుతుంది.

70
00:04:04,120 --> 00:04:06,630
నేను printf లైన్ అమలు చేయలేదు ఉన్నట్లు కనిపిస్తోంది తెలుసు

71
00:04:06,630 --> 00:04:10,070
మేము చూడండి కాబట్టి, తెరపై print అవుట్ "ఒక సానుకూల పూర్ణాంక నమోదు చేయండి"

72
00:04:10,070 --> 00:04:12,040
అయితే అమలు చేయలేదు.

73
00:04:12,040 --> 00:04:16,029
మనం చూస్తూ ఆపరేటింగ్ సిస్టమ్ కు రచన ఏదైనా అణచివేయడానికి ఉంది

74
00:04:16,029 --> 00:04:19,649
అది ఖచ్చితంగా ఎందుకు printouts తో డీబగ్గింగ్ ఇది ఉంటుంది వరకు

75
00:04:19,649 --> 00:04:21,730
కొన్నిసార్లు నమ్మలేని వస్తున్నాయి.

76
00:04:21,730 --> 00:04:26,240
ఏమైనా, కోడ్ యొక్క తదుపరి లైన్ కు వెళ్లండి మరియు Int లో ఎంటర్ మళ్ళీ చూద్దాం.

77
00:04:26,240 --> 00:04:30,070
మళ్లీ, రకం 4 చూద్దాం.

78
00:04:30,070 --> 00:04:34,540
కాబట్టి ఈ అసహజ కనిపిస్తోంది. మేము, GDB ప్రకారం లైన్ 12 లో ఉన్నారు

79
00:04:34,540 --> 00:04:37,660
కానీ అమలు గురించి ఆ తర్వాత పంక్తి ఒక వంకర జంట కలుపు.

80
00:04:37,660 --> 00:04:42,110
>> కేవలం మేము ఒక లూప్ యొక్క ముగింపు వద్ద ఉన్నారని అర్ధం మా విధంగా నిజానికి లూప్,

81
00:04:42,110 --> 00:04:46,710
మరియు GDB మాకు చెప్పడం అని రద్దు పరిస్థితి, సున్నా కంటే అవి ఏవీ తక్కువ,

82
00:04:46,710 --> 00:04:48,010
తదుపరి అమలు అవుతుంది.

83
00:04:48,010 --> 00:04:50,230
ఇది ఒక చిన్న గందరగోళంగా గెట్స్ ఉంటే,

84
00:04:50,230 --> 00:04:54,860
మేము జాబితా లేదా l ఆదేశంతో GDB లో సోర్స్ కోడ్ పుల్ అప్ చేయవచ్చు.

85
00:04:54,860 --> 00:04:56,880
ఈ సోర్స్ కోడ్ అవుట్ ముద్రిస్తుంది

86
00:04:56,880 --> 00:04:59,010
మేము ప్రస్తుతం ఉన్నట్లు లైన్ చుట్టూ ఉంది.

87
00:04:59,010 --> 00:05:03,590
మేము మళ్ళీ జాబితా లేదా l టైప్ చేస్తే, మేము రేఖల తదుపరి సెట్లో ముద్రించాలా చూస్తారు.

88
00:05:03,590 --> 00:05:06,070
మేము ఫైల్ ముగింపు హిట్ వరకు మేము చేయవచ్చు.

89
00:05:06,070 --> 00:05:11,210
>> మేము ఉన్న తిరిగి పొందడానికి, మేము, ఒక లైన్ సంఖ్యలో జాబితా సరఫరా చేయవచ్చు

90
00:05:11,210 --> 00:05:14,120
ఈ సందర్భంలో, లైన్ 12.

91
00:05:14,120 --> 00:05:16,040
ఏమైనా, యొక్క ముందుకు తెలియజేయండి.

92
00:05:16,040 --> 00:05:18,240
ఇప్పుడు మేము 4 లూప్ లో ఉన్నారు.

93
00:05:18,240 --> 00:05:21,490
లెట్ యొక్క మా num వేరియబుల్ 4 కలిగి నిర్ధారించుకోండి.

94
00:05:21,490 --> 00:05:26,170
మేము ప్రింట్, లేదా, p ఆదేశంతో దీన్ని.

95
00:05:26,170 --> 00:05:31,140
కాబట్టి, GDB మేము అనుకున్న num నిజానికి 4 నిల్వ మాకు చెబుతుంది.

96
00:05:31,140 --> 00:05:35,180
ఆ GDB ముద్రిస్తుంది $ 1 ప్రత్యేక GDB చరరాశి

97
00:05:35,180 --> 00:05:37,720
ఇప్పుడు అదే సంఖ్య 4 నిల్వ కు సెట్.

98
00:05:37,720 --> 00:05:42,240
మీరు ఇప్పుడు ఈ విస్మరించవచ్చు, కానీ ఈ GDB వేరియబుల్స్ సులభ సూపర్ వస్తాయి

99
00:05:42,240 --> 00:05:46,380
మరింత ఆధునిక విషయాలలో మీరు గతంలో చేసిన ఏ గుర్తు ఉంటుంది.

100
00:05:46,380 --> 00:05:50,970
ఏమైనా, తదుపరి తో కదిలే, మేము లూప్ ద్వారా తిరగటం మొదలు ఆ చూడండి.

101
00:05:50,970 --> 00:05:54,790
బిట్ n బిట్ ఇక్కడ ద్వారా కొనసాగించడాన్ని యొక్క లెట్.

102
00:05:54,790 --> 00:05:58,280
అయితే టైపింగ్ n ప్రతి సమయం కంటే, మీరు కూడా ఎంటర్ నొక్కండి కేవలం.

103
00:05:58,280 --> 00:06:03,710
మీరు ఏదైనా టైప్ లేకుండా ఎంటర్ నొక్కండి చేసినప్పుడు, GDB కేవలం మునుపటి ఆదేశం పునరావృతమవుతుంది.

104
00:06:03,710 --> 00:06:05,910
కాబట్టి ఇప్పుడు మేము printf కాల్ హిట్ చేసిన.

105
00:06:05,910 --> 00:06:09,520
మేము నిజంగా లూప్ 4 సార్లు మా ద్వారా మారారు వంటి ఇది కనిపిస్తుంది

106
00:06:09,520 --> 00:06:13,750
ఇది మేము 1, 2, 3, మరియు 4 ద్వారా హెచ్చించాము చేయడానికి మీరు ఏమి ఉంది.

107
00:06:13,750 --> 00:06:15,870
>> ప్రతిదీ అది పనిచేస్తోందని వంటి ఉంది,

108
00:06:15,870 --> 00:06:19,680
రాబోయే మళ్లీ హిట్ తప్ప మేము బదులుగా 24 ఈ భారీ సంఖ్యలో పొందండి.

109
00:06:19,680 --> 00:06:23,100
మేము కారకమైన ఉపయోగించి p విలువ ముద్రించాలా ఉంటే,

110
00:06:23,100 --> 00:06:26,120
మేము కారకమైన అది ఈ భారీ సంఖ్యలో లేని చూడండి.

111
00:06:26,120 --> 00:06:28,740
ఏదో ఖచ్చితంగా తప్పు జరగబోతోంది.

112
00:06:28,740 --> 00:06:31,960
ఈ సమయంలో, అయితే, మేము దాదాపు కార్యక్రమం చివరిలో ఉంటాయి

113
00:06:31,960 --> 00:06:34,610
మరియు అది ఏదైనా పరిష్కరించడానికి ఆలస్యం.

114
00:06:34,610 --> 00:06:39,750
>> అయితే, మేము నిర్ధారించడానికి మళ్ళీ తరువాత Y r టైప్ చేయడం ద్వారా కార్యక్రమం పునఃప్రారంభించుము చేయవచ్చు.

115
00:06:39,750 --> 00:06:43,460
ఇప్పుడు మేము ప్రధాన ప్రారంభంలో మా బ్రేక్పాయింట్ని వద్ద వెనక్కి వచ్చారు.

116
00:06:43,460 --> 00:06:46,600
మేము ప్రతిదీ n లో చదివిన చిన్నగా ఉంది తెలుసు.

117
00:06:46,600 --> 00:06:48,630
కాబట్టి మేము n ముందుకు కెన్ జంప్.

118
00:06:48,630 --> 00:06:52,280
ఏమి తరువాత ప్రత్యామ్నాయంగా, మేము ఒక కొత్త బ్రేక్పాయింట్ని సెట్ చేయవచ్చు, అయితే లూప్

119
00:06:52,280 --> 00:06:54,910
మరియు అక్కడ దూకుతారు. యొక్క అలా లెట్.

120
00:06:54,910 --> 00:06:59,080
లైన్ 14 కేవలం లూప్ తర్వాత వస్తుంది కనిపిస్తోంది.

121
00:06:59,080 --> 00:07:01,070
యొక్క అక్కడ బ్రేక్పాయింట్ని సెట్ లెట్.

122
00:07:01,070 --> 00:07:05,220
ఈ బ్రేక్పాయింట్ని ఆదేశం లో ఫైల్ పేరు తెలుపుటకు మంచి పద్ధతి యొక్క

123
00:07:05,220 --> 00:07:08,480
మీరు బహుళ ఫైళ్లను పని మీరు GDB అయోమయం పొందవచ్చు నుండి.

124
00:07:08,480 --> 00:07:13,230
ముందుకు ఈ బ్రేక్పాయింట్ని యొక్క తరలించడానికి, మేము కొనసాగింపును లేదా సి ఆదేశం ఉపయోగించండి.

125
00:07:13,230 --> 00:07:16,570
>> సరే, ఇక్కడ మేము లూప్ ఉన్నాయి.

126
00:07:16,570 --> 00:07:19,060
యొక్క లూప్ లోకి 1 మరింత లైన్ వెళ్ళి తెలపండి,

127
00:07:19,060 --> 00:07:21,630
మరియు తర్వాత మేము ఏమి చూడటానికి ముద్రణ వేరియబుల్స్ ప్రారంభించగలరు.

128
00:07:21,630 --> 00:07:26,410
లెట్ యొక్క అంచనా నేను నిజానికి 1 నిర్ధారించుకోండి.

129
00:07:26,410 --> 00:07:28,300
అన్ని మంచి అయ్యో,.

130
00:07:28,300 --> 00:07:30,270
గురించి కారకమైన ఏమి అయినప్పటికీ?

131
00:07:30,270 --> 00:07:33,760
ఏ మంచి అయ్యో,.

132
00:07:33,760 --> 00:07:35,800
మేము ఇక్కడ ఒక పెద్ద రుణ సంఖ్య పొందారు.

133
00:07:35,800 --> 00:07:38,190
ఆ జరిగే How'd?

134
00:07:38,190 --> 00:07:40,040
Well, మేము కోడ్ వద్ద తిరిగి చూస్తే,

135
00:07:40,040 --> 00:07:44,800
మేము అది initialized ఎప్పుడూ చూడండి, కాబట్టి మేము అక్కడే ట్రాష్ పొందారు.

136
00:07:44,800 --> 00:07:46,820
ఆ ఖచ్చితంగా మా లెక్కింపు పడగొట్టటానికి కనిపిస్తుంది.

137
00:07:46,820 --> 00:07:49,930
>> అదృష్టవశాత్తూ, ఈ పరిష్కరించడానికి GDB వదిలి లేదు.

138
00:07:49,930 --> 00:07:54,590
మేము ఇక్కడే అది ప్రారంభించడం మరియు తరువాత print ఆదేశాన్ని ఉపయోగించి కోడ్ పరిష్కరిస్తాము.

139
00:07:54,590 --> 00:07:59,500
సున్నా మరియు 1 యొక్క factorials 1 రెండూ నుండి మేము, 1 కి ప్రారంభించడం చేస్తాము

140
00:07:59,500 --> 00:08:03,940
మేము సున్నా దానిని ప్రారంభించటానికి ఉంటే, అప్పుడు మేము ఎల్లప్పుడూ మా ఫలితంగా సున్నా ముగిసేవి భావిస్తున్న.

141
00:08:03,940 --> 00:08:08,370
మీరు సూపర్ సులభ ఉన్న ఏదైనా వేరియబుల్ ఈ విధంగా, సెట్ చేయవచ్చు.

142
00:08:08,370 --> 00:08:10,920
ఇప్పుడు, యొక్క మా కార్యక్రమం చెయ్యనివ్వండి.

143
00:08:10,920 --> 00:08:14,040
లెట్ యొక్క ఇది రావలసిన చోట ప్రతిదీ ను నిర్థారించండి.

144
00:08:14,040 --> 00:08:19,090
Num 4 ఉండాలి, నేను 1 ఉండాలి, మరియు కారకమైన చాలా 1 అయి ఉండాలి.

145
00:08:19,090 --> 00:08:23,990
మేము ఈ ప్రక్రియ సత్వరమార్గం మరియు మా స్థానిక వేరియబుల్స్ యొక్క అన్ని ముద్రించవచ్చు

146
00:08:23,990 --> 00:08:26,440
సూపర్ ఉపయోగపడిందా ఆదేశం సమాచారం స్థానికులు,

147
00:08:26,440 --> 00:08:29,190
ఇది మా లో-స్కోప్ స్థానిక వేరియబుల్స్ యొక్క అల్ అవ్ట్ ముద్రిస్తుంది.

148
00:08:29,190 --> 00:08:31,980
ప్రతిదీ వెళ్ళడానికి మంచి వంటి ఏమైనా, కనిపిస్తోంది.

149
00:08:31,980 --> 00:08:34,700
>> కేవలం నిర్ధారించడానికి మరొక Go-చుట్టూ ఉచ్చు యొక్క తెలియజేసేలా యొక్క.

150
00:08:34,700 --> 00:08:38,789
సరే, ప్రతిదీ చాలా బాగుంది.

151
00:08:38,789 --> 00:08:41,659
ఇప్పుడు మేము ముగింపు వెళ్లడాన్ని కొనసాగించాల్సిన ఆదేశం ఉపయోగించవచ్చు.

152
00:08:41,659 --> 00:08:46,170
Sweet! 4 కారకమైన అనుకున్న 24 ముద్రించిన.

153
00:08:46,170 --> 00:08:48,690
ఇప్పుడు మేము మా కోడ్ లో పరిష్కరిస్తాము వెళ్ళవచ్చు.

154
00:08:48,690 --> 00:08:53,710
అయితే GDB నుండి నిష్క్రమించినప్పుడు కంటే, మేము దీన్ని మరొక టెర్మినల్ టాబ్ ఉపయోగిస్తాము.

155
00:08:53,710 --> 00:08:58,080
మా GDB టాబ్ కు వెళుతున్నారు, మేము ఇప్పుడు మా executable మళ్ళీ కంపైల్ చెయ్యండి అవసరం.

156
00:08:58,080 --> 00:09:03,180
GDB గురించి ఉత్తమ విషయాలు ఒకటి మీరు చేసే అమలు చేయడానికి GDB వదిలి లేదు అని.

157
00:09:03,180 --> 00:09:06,570
కాబట్టి మేము పాత బ్రేక్ పాయింట్స్ కొట్టిన ఉంచేందుకు లేదు ఆ

158
00:09:06,570 --> 00:09:10,440
లెట్స్ వాటిని డిసేబుల్, మీరు ఊహించిన, ఆదేశం అచేతనము చేయుము.

159
00:09:10,440 --> 00:09:13,320
ఈ మా బ్రేక్ పాయింట్స్ అన్ని ఆపివేస్తుంది.

160
00:09:13,320 --> 00:09:18,180
ఇప్పుడు మేము r తో కార్యక్రమం పునఃప్రారంభించుము మరియు ప్రతిదీ సరైందే ఖచ్చితంగా చేయవచ్చు.

161
00:09:18,180 --> 00:09:21,300
ప్రతిదీ అన్నిటికి ఉన్నట్లు కనిపిస్తుంది.

162
00:09:21,300 --> 00:09:24,410
24 4 అచ్చుల కారకమైన, కేవలం వంటి మేము ఆలోచన.

163
00:09:24,410 --> 00:09:28,830
GDB మీ పేజీలు లో పొందారు అత్యంత సహాయపడే ఉపకరణాలు ఒకటి.

164
00:09:28,830 --> 00:09:31,970
>> మీరు GDB చేయగలిగే ఒక టన్ను వస్తువుల ఉన్నాయి

165
00:09:31,970 --> 00:09:34,030
మీరు సాధారణ printouts చేయగలిగే కంటే చాలా.

166
00:09:34,030 --> 00:09:36,730
తరువాత మీ ప్రోగ్రామ్, మీకు కావలసిన ఏమి లేదు

167
00:09:36,730 --> 00:09:39,740
లోపల ఏమి గుర్తించడానికి GDB నడుస్తున్న ప్రయత్నించండి.

168
00:09:39,740 --> 00:09:44,380
సాధన కొంత, మీరు ఏ సమయంలో మీ బగ్ న డౌన్ రంధ్రములు చేసే పరికరము చేయగలరు.

169
00:09:44,380 --> 00:09:48,180
నా పేరు నేట్ Hardison ఉంది. ఈ CS50 ఉంది.