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
>> మొదటి b, ఇది
విరామం సంక్షిప్తరూపం.

39
00:01:55,200 --> 00:01:58,690
మరియు మీరు b, మీరు సాధారణంగా టైప్ తర్వాత
ఒక చర్య యొక్క పేరును టైప్

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
మీరు అన్ని కమాండ్ లైన్ పేర్కొనండి
r, లేదా రన్ తీసుకొని వాదనలు,

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
GDP వాతావరణంలో లోపల.

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
మీరు ఇప్పటికే అమలు చేస్తున్నారు ఉంటే లేదా, మీరు చెయ్యవచ్చు
కోడ్ యొక్క ముందుకు ఒక లైన్ దశను S ఉపయోగించండి.

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
మీరు p ప్రచురించాలి టైపు చెయ్యవచ్చు
ఆపై వేరియబుల్ పేరు.

86
00:04:12,507 --> 00:04:15,090
మరియు ఆ, మీరు ముద్రిస్తుంది
GDB పర్యావరణం లోపల,

87
00:04:15,090 --> 00:04:19,110
వేరియబుల్ పేరు, ఆ మీరు చేసిన
నాకు వేరియబుల్ విలువ క్షమించు

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
ఇది చాలా వేగంగా కంటే వార్తలు
అప్పుడు p టైప్ మరియు సంసార,

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
మీరు నిజంగా సందర్భంగా ఉండదు
bT, లేదా తిరిగి ట్రేస్ ఉపయోగించడానికి,

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
నా కార్యక్రమంలో am.

105
00:05:06,460 --> 00:05:10,590
కాబట్టి మీరు మీ కోడ్ వ్రాయలేదు అని, మరియు
మీరు ప్రధాన ఒక ఫంక్షన్ కాల్స్ తెలుసు

106
00:05:10,590 --> 00:05:14,720
ఒక ఫంక్షన్ కాల్స్ f,
ఒక ఫంక్షన్ H పిలుస్తుంది గ్రా.

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
మీరు ఎక్కడ మీరు వచ్చింది ఏమి గురించి
మీరు BT లేదా వీపు ట్రేస్ టైప్ చేయవచ్చు are--,

111
00:05:27,210 --> 00:05:32,370
మరియు అది, h, గ్రా బయటకు ప్రధాన f ముద్రిస్తుంది
కొన్ని ఇతర సమాచారం, కలిసి ఇది

112
00:05:32,370 --> 00:05:35,984
మీరు ఒక ఆధారాన్ని ఇస్తుంది ఆ, సరే ప్రధాన
అని f, అని గ్రా f, g, h అని

113
00:05:35,984 --> 00:05:37,900
మరియు ఆ పేరు నేను
ప్రస్తుతం నా కార్యక్రమంలో am.

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
మీరు q టైప్ లేదా పొందడానికి, క్విట్ చేయవచ్చు.

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
OK, కాబట్టి మేము ఇక్కడ ఉన్నాము నా
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
Well యొక్క అవ్ట్ కనుగొనండి.

138
00:06:47,773 --> 00:06:52,510
నేను, డాట్ స్లాష్ టైప్
బగ్గీ, మరియు నేను ఎంటర్ కొట్టాడు.

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
>> All right, కాబట్టి లెట్స్ ప్రారంభం
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
మీరు ఇది రెడీ, కంట్రోల్ U పట్టవచ్చు
ప్రతిదీ తొలగించండి మరియు మీరు బాగు

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
ఆపై, నేను కేవలం దీనికై
మరియు R, కార్యక్రమం అమలు.

184
00:08:44,510 --> 00:08:45,360
కార్యక్రమం మొదలు.

185
00:08:45,360 --> 00:08:48,160
All right, కాబట్టి ఈ సందేశం
ఒక చిన్న గుప్తమైన ఉంది.

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
>> OK, కాబట్టి యొక్క చూసేలా, ఏమి
నేను ఇక్కడ ఏమి అనుకుంటున్నారు?

197
00:09:17,330 --> 00:09:21,770
Well, నేను స్థానిక ఏమి కోరుకుంటున్నారో
వేరియబుల్స్ బహుశా నాకు అందుబాటులో ఉన్నాయి.

198
00:09:21,770 --> 00:09:23,570
నా కార్యక్రమాన్ని ప్రారంభించారు చేసిన.

199
00:09:23,570 --> 00:09:28,515
యొక్క కావచ్చు ఏమి చూద్దాం
అప్పటికే మాకు initialized.

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
నేను n ఉపయోగించడానికి వెళుతున్న.

207
00:09:49,630 --> 00:09:51,180
నేను n టైప్ చేయండి.

208
00:09:51,180 --> 00:09:53,060
అబ్బా నా ఓహ్, ఏమి ఇక్కడ జరుగుతోంది.

209
00:09:53,060 --> 00:09:56,260
ప్రోగ్రామ్ సిగ్నల్స్ పొందింది,
SIGSEGV, విభజన లోపంగా

210
00:09:56,260 --> 00:09:57,880
ఆపై stuff యొక్క మొత్తం బంచ్.

211
00:09:57,880 --> 00:09:58,880
నేను ఇప్పటికే నిష్ఫలంగా ఉన్నాను.

212
00:09:58,880 --> 00:10:00,980
Well, వాస్తవానికి అక్కడ ఒక
చాలా ఇక్కడ నేర్చుకొన్న.

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
సి ప్రామాణిక లో ఉంది లైబ్రరీ
కానీ వారు మీరు అన్ని అందుబాటులో ఉన్నారు

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
, నేను n హిట్, మరియు నిజానికి నేను సందేశాన్ని పొందుటకు
కార్యక్రమం సిగ్నల్ SIGSEGV తో రద్దు

227
00:10:58,530 --> 00:11:01,370
విభజన లోపంగా. కాబట్టి ఇప్పుడు
నేను నిజానికి seg విమర్శలకు గురయ్యారు చేశారు,

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
Well, నా ప్రోగ్రామ్ కూలిపోతుంది
వెంటనే అందంగా చాలా.

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
ఇది కేవలం నేను కనుగొన్నారు అని నాకు చెప్పారు.

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
కాబట్టి ఈ ఉదాహరణ, మళ్ళీ నేను, అన్నాడు వంటి
కుడి, కొద్దిగా కంట్రైవ్డ్ ఉంది?

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