1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [విభాగం 5 - అత్యంత సౌకర్యవంతమైన]

2
00:00:02,500 --> 00:00:04,690
[రాబ్ బౌడెన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:04,690 --> 00:00:07,250
[ఈ CS50 ఉంది. - CS50.TV]

4
00:00:08,990 --> 00:00:14,250
>> నా ఇమెయిల్ లో చెప్పినట్టూ, మీరు ఉపయోగించవచ్చు విషయాలు చాలా ఉన్నాయి

5
00:00:14,250 --> 00:00:17,060
వాస్తవానికి సమస్య సెట్లు చేయడానికి ఉపకరణం కంటే ఇతర.

6
00:00:17,060 --> 00:00:19,910
మేము అప్పుడు మేము సులభంగా మీరు సహాయం చెయ్యవచ్చు కనుక మీరు పరికరంలోని దీనిని సిఫార్సు

7
00:00:19,910 --> 00:00:22,070
మరియు మేము ప్రతిదీ వెళ్లాలని ఎలా తెలుసు.

8
00:00:22,070 --> 00:00:26,950
కానీ చెప్పడానికి, మీరు చేయవచ్చు పేరు ఒక ఉదాహరణ, మీరు ప్రాప్యత లేదు

9
00:00:26,950 --> 00:00:31,570
ఒక ఉపకరణం లేదా మీరు సైన్స్ సెంటర్ నేలమాళిగలో పని -

10
00:00:31,570 --> 00:00:33,090
ఇది వాస్తవానికి వారు చాలా ఉపకరణం కలిగి -

11
00:00:33,090 --> 00:00:35,150
మీరు ఎక్కడైనా పని చేయండి.

12
00:00:35,150 --> 00:00:42,370
ఒక ఉదాహరణ మీరు చూసిన / SSH యొక్క విన్న ఉంది?

13
00:00:44,380 --> 00:00:47,780
SSH కేవలం ఏదో కనెక్ట్ వంటి రప్పించింది.

14
00:00:47,780 --> 00:00:51,340
అసలైన, ప్రస్తుతం నేను ఉపకరణం లోకి SSHed చేస్తున్నాను.

15
00:00:51,340 --> 00:00:54,290
నేను పరికరంలోని పని ఎప్పుడూ.

16
00:00:55,930 --> 00:01:01,060
ఇక్కడ ఉపకరణం, మరియు మీరు ఇక్కడ క్రిందికి చూడండి మీరు ఈ IP చిరునామా చూడండి.

17
00:01:01,060 --> 00:01:03,650
నేను ఉపకరణం కూడా పని లేదు;

18
00:01:03,650 --> 00:01:08,840
నేను ఎల్లప్పుడూ ఒక iTerm2 విండో / టెర్మినల్ విండో కి వచ్చారు.

19
00:01:08,840 --> 00:01:15,910
ఆ IP చిరునామా, ssh jharvard@192.168.129.128 కు SSH చెయ్యవచ్చు.

20
00:01:15,910 --> 00:01:20,390
అది ఒక nice నమూనా ఎందుకంటే నేను చాలా సులభంగా ఆ సంఖ్యను గుర్తుంచుకోండి.

21
00:01:20,390 --> 00:01:24,920
కానీ నా పాస్వర్డ్ను కోసం అడుగుతుంది, మరియు ఇప్పుడు నేను ఉపకరణం ఉన్నాను.

22
00:01:24,920 --> 00:01:33,060
సాధారణంగా, ఈ సమయంలో, మీరు, ఉపకరణం యొక్క లోపల టెర్మినల్ ప్రారంభించబడ్డాయి

23
00:01:33,060 --> 00:01:36,350
ఈ ఇంటర్ఫేస్, అయితే మీరు దానిని ఉపయోగించే, అదే ఉంది

24
00:01:36,350 --> 00:01:40,010
ఇంటర్ఫేస్ను నేను ఇక్కడ ఉపయోగించి నేను ఇప్పుడు మీరు SSHed చేస్తున్నారు.

25
00:01:42,240 --> 00:01:44,920
మీరు ఉపకరణం కు SSH లేదు.

26
00:01:44,920 --> 00:01:52,360
మీరు చేయగల SSH మరొక స్థలం యొక్క ఒక ఉదాహరణ నేను సిద్ధంగా ఉన్నాయి అందంగా ఖచ్చితంగా ఉన్నాను ఉంది -

27
00:01:52,360 --> 00:01:55,020
ఓహ్. పెద్దది.

28
00:01:55,020 --> 00:02:01,130
మీరు అన్ని FAS సర్వర్లపై డిఫాల్ట్ FAS ఖాతాల ద్వారా ఉండాలి.

29
00:02:01,130 --> 00:02:06,840
నా కోసం నేను SSH rbowden@nice.fas.harvard.edu నియమిస్తున్నట్లు.

30
00:02:06,840 --> 00:02:11,610
మీరు మొదటిసారి అడగండి అవకాశముంది, మరియు మీరు అవును అంటున్నారు.

31
00:02:11,610 --> 00:02:15,840
నా పాస్వర్డ్ను నా FAS పాస్వర్డ్ను అని అన్నారు.

32
00:02:15,840 --> 00:02:22,650
కాబట్టి ఇప్పుడు, నేను మంచి సర్వర్లకు SSHed చేస్తున్నాను, నేను ఇక్కడ న మీరు ఏదైనా సాధ్యమే.

33
00:02:22,650 --> 00:02:28,560
మీరు 124 వంటి పడుతుంది తరగతులు చాలా, మీరు ఇక్కడ అంశాన్ని అప్లోడ్ పొందబోతున్నారు

34
00:02:28,560 --> 00:02:30,950
నిజానికి మీ సమస్య సెట్లు సమర్పించడానికి.

35
00:02:30,950 --> 00:02:34,100
కానీ మీరు మీ ఉపకరణం యాక్సెస్ లేదు చెప్పారు.

36
00:02:34,100 --> 00:02:37,910
అప్పుడు మీరు, చేయవచ్చు ఇక్కడ లాంటి స్టేట్మెంట్లు చదివితే, అది -

37
00:02:37,910 --> 00:02:42,160
ఇది ప్రశ్నలు మా విభాగం ఉంది.

38
00:02:42,160 --> 00:02:45,070
ఇది పరికరంలోని దీన్ని మీరు అడుగుతాము.

39
00:02:45,070 --> 00:02:47,790
బదులుగా నేను సర్వర్లో చేయును.

40
00:02:47,790 --> 00:02:50,560
నేను ఆ అన్జిప్ వెళుతున్న.

41
00:02:50,560 --> 00:02:55,670
సమస్య మీరు gedit లాగ ఉపయోగించి ఉపయోగిస్తారు చేస్తున్న అవతరిస్తుంది

42
00:02:55,670 --> 00:02:58,160
ఉపకరణం లేదా ఏ లోపల.

43
00:02:58,160 --> 00:03:01,830
మీరు FAS సర్వర్లో ఆ కొనసాగుతుందని లేదు.

44
00:03:01,830 --> 00:03:04,110
ఇది అన్ని కేవలం ఈ పాఠ్య అంతర్ముఖాన్ని చేస్తాడు.

45
00:03:04,110 --> 00:03:09,180
కాబట్టి మీరు, వారు లేదని టెక్స్ట్ ఎడిటర్ తెలుసుకోవడానికి గాని ఒక ప్రయత్నించండి.

46
00:03:09,180 --> 00:03:12,130
వారు నానో ఉన్నాయి.

47
00:03:12,130 --> 00:03:14,990
నానో సాధారణంగా ఉపయోగించడానికి చాలా సులభం.

48
00:03:14,990 --> 00:03:19,470
మీరు మీ బాణాలు ఉపయోగించండి మరియు సాధారణంగా టైప్ చెయ్యవచ్చు.

49
00:03:19,470 --> 00:03:21,250
కాబట్టి ఆ హార్డు కాదు.

50
00:03:21,250 --> 00:03:24,720
మీరు నిజంగా ఫాన్సీ పొందడానికి అనుకుంటే మీరు, Emacs ఉపయోగించవచ్చు

51
00:03:24,720 --> 00:03:29,850
నేను కూడా Emacs దగ్గరగా ఎలా తెలియదు ఎందుకంటే ఇది నేను బహుశా తెరిచారు లేదు.

52
00:03:29,850 --> 00:03:32,760
కంట్రోల్ X, కంట్రోల్ సి? అవును.

53
00:03:32,760 --> 00:03:35,310
లేదా మీరు నేను ఉపయోగం ఉంది Vim, ఉపయోగించవచ్చు.

54
00:03:35,310 --> 00:03:37,800
కాబట్టి ఆ మీ ఎంపికలు ఉన్నాయి.

55
00:03:37,800 --> 00:03:43,830
మీరు అలా చేయకూడదని, మీరు కూడా, మీరు చూడండి ఉంటే manual.cs50.net -

56
00:03:43,830 --> 00:03:45,410
ఓహ్.

57
00:03:45,410 --> 00:03:49,920
ఒక PC లో, మీరు SSH, పుట్టీ ఉపయోగించి

58
00:03:49,920 --> 00:03:51,940
ప్రత్యేకంగా మీరు డౌన్లోడ్ చూడాలని ఇది.

59
00:03:51,940 --> 00:03:55,460
ఒక Mac, మీరు కేవలం డిఫాల్ట్ ఉపయోగించు టెర్మినల్ ద్వారా లేదా మీరు, iTerm2 డౌన్లోడ్ చేసుకోగలరు

60
00:03:55,460 --> 00:03:58,490
ఒక nice, ఫాన్సీ టెర్మినల్ ఉంటుంది.

61
00:03:58,490 --> 00:04:03,780
మీరు manual.cs50.net వెళ్ళండి ఉంటే మీరు నోట్ప్యాడ్లో ఒక లింక్ను చూస్తారు + +,

62
00:04:03,780 --> 00:04:07,120
మీరు ఒక PC లో ఉపయోగించే ఏమిటి.

63
00:04:07,120 --> 00:04:13,340
ఇది నోట్ప్యాడ్లో మీరు SFTP అనుమతిస్తుంది + +, ఇది ప్రాథమికంగా SSH ఉంది.

64
00:04:13,340 --> 00:04:17,750
ఈ మీరు అనుమతిస్తుంది, స్థానికంగా మీ ఫైళ్ళను ఎడిట్ ఉంది

65
00:04:17,750 --> 00:04:20,670
మరియు మీరు వాటిని సేవ్ చేయాలనుకుంటున్నారా చేసినా, అది, nice.fas సేవ్ చేస్తుంది

66
00:04:20,670 --> 00:04:23,670
మీరు వాటిని అమలు చేయగల.

67
00:04:23,670 --> 00:04:26,880
మరియు ఒక Mac న సమానమైన TextWrangler అని అన్నారు.

68
00:04:26,880 --> 00:04:28,760
కాబట్టి మీరు కూడా ఇదే అనుమతిస్తుంది.

69
00:04:28,760 --> 00:04:32,800
ఇది మీరు స్థానికంగా ఫైళ్ళను ఎడిట్ మరియు nice.fas వాటిని సేవ్ అనుమతిస్తుంది

70
00:04:32,800 --> 00:04:35,730
మీరు వాటిని అమలు చేయగల.

71
00:04:35,730 --> 00:04:40,400
మీరు ఒక ఉపకరణం లేకుండా ఇరుక్కుపోయి ఉన్నాం చేస్తే, మీరు ఈ ఎంపికలు ఉన్నాయి

72
00:04:40,400 --> 00:04:44,230
మీ సమస్య సెట్లు చేయండి ఇప్పటికీ కు.

73
00:04:44,230 --> 00:04:48,250
ఒక సమస్య మీరు CS50 లైబ్రరీ ఏమీ ఉండదని చేస్తున్న అవతరిస్తుంది

74
00:04:48,250 --> 00:04:51,580
nice.fas సిద్ధంగా ఆ లేవు.

75
00:04:51,580 --> 00:04:55,970
మీరు CS50 లైబ్రరీ డౌన్లోడ్ చేసుకోవచ్చు -

76
00:04:55,970 --> 00:04:58,470
నేను ఈ సమయంలో ఆ అవసరం భావించడం లేదు.

77
00:04:58,470 --> 00:05:03,270
మీరు, CS50 లైబ్రరీ డౌన్లోడ్ మరియు nice.fas దానిని పైగా కాపీ చేసుకోవచ్చు

78
00:05:03,270 --> 00:05:07,450
లేదా నేను ఈ సమయంలో మేము ఏ విధంగా అయినా ఇకపై దీన్ని ఉపయోగించకండి భావిస్తున్నాను.

79
00:05:07,450 --> 00:05:12,720
మేము ఉంటే లేదా, మీరు సారి భర్తీ చేస్తున్న చేయవచ్చు

80
00:05:12,720 --> 00:05:18,480
ఏమైనప్పటికీ CS50 లైబ్రరీలో విధులు అమలు.

81
00:05:18,480 --> 00:05:21,370
కాబట్టి ఒక పరిమితి యొక్క ఎక్కువ ఉండకూడదు.

82
00:05:21,370 --> 00:05:23,710
మరియు ఆ ఆ.

83
00:05:26,460 --> 00:05:29,820
>> నేను ఇప్పుడు ఉపకరణం తిరిగి వెళ్తారో; మేము పరికరంలోని ప్రతిదీ చేస్తాను.

84
00:05:29,820 --> 00:05:37,510
నా ఇమెయిల్ మాట్లాడుతూ వంటి ప్రారంభంలో, ప్రశ్నలు మా విభాగం వద్ద గురించి,

85
00:05:37,510 --> 00:05:43,620
మీరు చూడటానికి నిర్ణయించుకున్నాయి చిన్న గురించి మాట్లాడటానికి ఉన్నాయి.

86
00:05:43,620 --> 00:05:51,980
మేము మళ్లిస్తోంది & పైప్స్ మరియు ఈ మూడు ప్రశ్నలు.

87
00:05:51,980 --> 00:05:56,070
>> ఏ స్ట్రీమ్ వంటి విధులను printf సిద్ధంగా వ్రాస్తారా?

88
00:05:56,070 --> 00:05:59,130
స్ట్రీమ్ కాబట్టి. ప్రవాహం ఏమిటి?

89
00:06:06,520 --> 00:06:15,100
అది కేవలం కొన్ని మాదిరిగా ప్రవాహం రప్పించింది -

90
00:06:15,100 --> 00:06:21,450
ఇది కూడా 1s మరియు 0 సె ఒక మూల కాదు.

91
00:06:21,450 --> 00:06:24,920
అది ఇక్కడ కోరుతూ యొక్క స్ట్రీమ్లో ప్రామాణిక ముగిసింది.

92
00:06:24,920 --> 00:06:27,250
కాబట్టి ప్రామాణిక అవుట్ ఒక ప్రవాహం మీరు, అది వ్రాసే సమయంలో

93
00:06:27,250 --> 00:06:30,940
అది తెరపై కనిపిస్తుంది.

94
00:06:30,940 --> 00:06:36,860
ప్రామాణిక అవ్ట్, ప్రవాహం ద్వారా, అది మీకు 1s మరియు దానికి వ్రాసి 0 సె అర్థం

95
00:06:36,860 --> 00:06:40,220
మరియు ప్రామాణిక అవుట్ ఇతర ముగింపు ఆ ప్రవాహం నుంచి చదువుతుంది.

96
00:06:40,220 --> 00:06:43,540
ఇది కేవలం 1s మరియు 0 సె ఒక స్ట్రింగ్ ఉంది.

97
00:06:43,540 --> 00:06:45,570
మీరు ప్రవాహాలు వ్రాయగలరు లేదా మీరు కాలువల నుండి చదువుకోవచ్చు

98
00:06:45,570 --> 00:06:47,950
స్ట్రీమ్ అసలు ఆధారపడి.

99
00:06:47,950 --> 00:06:52,800
ఇతర రెండు డిఫాల్ట్ ప్రవాహాలు మరియు ప్రామాణిక తప్పు ప్రామాణికమైన.

100
00:06:52,800 --> 00:06:57,540
మీరు GetString లేదు చేసినప్పుడు లో ప్రామాణిక ఉంటే, మీరు కోసం ఇన్పుట్ అంశం వేచి యొక్క.

101
00:06:57,540 --> 00:07:01,570
కాబట్టి మీరు వేచి, ఇది నిజానికి, ప్రామాణిక న వేచి యొక్క

102
00:07:01,570 --> 00:07:04,880
మీరు కీబోర్డ్ వద్ద టైప్ మీరు పొందుతారు నిజంగా ఉంది.

103
00:07:04,880 --> 00:07:07,530
మీరు ప్రామాణిక టైప్ చేస్తున్నారు

104
00:07:07,530 --> 00:07:10,050
ప్రామాణిక లోపం, ప్రామాణిక అవుట్ ప్రధానంగా సమానం

105
00:07:10,050 --> 00:07:13,280
మీరు ప్రామాణిక లోపం ప్రింట్ చేసినప్పుడు కానీ, ఆ ప్రత్యేక ఉంది

106
00:07:13,280 --> 00:07:16,770
మీరు మాత్రమే ఆ లోపం సందేశాలు ప్రింట్ కోరుకుంటున్నాము చేస్తున్నారు

107
00:07:16,770 --> 00:07:20,200
కాబట్టి మీరు స్క్రీన్ ముద్రించబడుతుంది సాధారణ సందేశాలను మధ్య తేడా చేయవచ్చు

108
00:07:20,200 --> 00:07:24,560
వారు ప్రామాణిక అవుట్ లేదా ప్రామాణిక లోపం జరిగింది అనే దానిపై ఆధారపడి దోష సందేశాలు వర్సెస్.

109
00:07:24,560 --> 00:07:28,660
చాలా ఫైళ్ళను.

110
00:07:28,660 --> 00:07:32,440
ప్రామాణిక అవ్ట్, ప్రామాణిక, మరియు ప్రామాణిక తప్పు, కేవలం ప్రత్యేక ప్రసారాలు ఉంటాయి

111
00:07:32,440 --> 00:07:36,810
కానీ నిజంగా ఏ ఫైలు, మీరు ఒక ఫైల్ను తెరవడం, అది బైట్లు ప్రవాహం అవుతుంది

112
00:07:36,810 --> 00:07:40,740
మీరు ఆ స్ట్రీమ్ నుండి చదువుకోవచ్చు.

113
00:07:40,740 --> 00:07:47,770
మీరు చాలా భాగం కేవలం బైట్లు ప్రవాహం వంటి ఫైల్ యొక్క ఆలోచించవచ్చు.

114
00:07:47,770 --> 00:07:51,190
సో వాట్ ప్రవాహాలు వారు సిద్ధంగా కు వ్రాస్తారా? ప్రామాణిక అవుట్.

115
00:07:51,190 --> 00:07:56,980
>> > మరియు >> మధ్య తేడా ఏమిటి?

116
00:07:58,140 --> 00:08:03,710
ఎవరైనా ముందుగానే వీడియోను తెలుసా? సరే.

117
00:08:03,710 --> 00:08:10,960
> మీరు ఫైల్ గా దారిమార్పు ఎలా ఉండబోతుంది

118
00:08:10,960 --> 00:08:15,240
మరియు >> కూడా, ఫైల్ గా అవుట్పుట్ మళ్ళింపు అన్నారు

119
00:08:15,240 --> 00:08:17,820
కానీ బదులుగా ఫైలుకు జోడించే జరగబోతోంది.

120
00:08:17,820 --> 00:08:23,430
ఉదాహరణకు, లెట్స్ నేను ఇక్కడే నిఘం కలిగి జరిగే సే

121
00:08:23,430 --> 00:08:27,020
మరియు నిఘం లోపలి మాత్రమే stuff పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క ఉంది.

122
00:08:27,020 --> 00:08:31,530
మీరు కమాండ్ లైన్ వద్ద కలిగి ఒక ఆదేశం, పిల్లి

123
00:08:31,530 --> 00:08:34,539
ఇది ఫైల్ లో ఏమి ప్రింట్ అన్నారు.

124
00:08:34,539 --> 00:08:40,679
నేను పిల్లి నిఘం సే, అది పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క ముద్రించడానికి జరగబోతోంది. అన్ని పిల్లి చేస్తుంది ఉంది.

125
00:08:40,679 --> 00:08:46,280
అది పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క అవుట్ ప్రామాణిక ముద్రించబడుతుంది అర్థం.

126
00:08:46,280 --> 00:08:53,240
నేను బదులుగా ఒక ఫైల్ను మళ్ళిస్తుంది చేయాలనుకుంటే, నేను ఉపయోగించే> మరియు ఫైలు ఏ దానిని దారిమార్పు చేయవచ్చు.

127
00:08:53,240 --> 00:08:56,460
నేను ఫైలు పిలుస్తాను.

128
00:08:56,460 --> 00:09:00,320
నేను ls చేస్తే ఇప్పుడు, నేను ఫైలు అనే కొత్త ఫైలుని కలిగి చూస్తారు.

129
00:09:00,320 --> 00:09:05,700
నేను దానిని తెరిచి ఉంటే, అది పిల్లి కమాండ్ లైన్ వద్ద ఉంచారు సరిగ్గా అదే కలిగి జరగబోతోంది.

130
00:09:05,700 --> 00:09:11,040
నేను మళ్ళీ అలా చేస్తే ఇప్పుడు, అది, ఫైల్లోకి అవుట్పుట్ మళ్ళించడం జరగబోతోంది

131
00:09:11,040 --> 00:09:13,930
మరియు నేను అదే ఖచ్చితమైన విషయం కలిగి వెళుతున్న.

132
00:09:13,930 --> 00:09:17,910
కాబట్టి సాంకేతికంగా ఇది పూర్తిగా మేము ఏ overrode.

133
00:09:17,910 --> 00:09:22,970
నేను నిఘం మార్చడానికి మేము చూస్తారు, నేను కుక్క తీసుకున్నారు.

134
00:09:22,970 --> 00:09:29,980
ఇప్పుడు మళ్ళీ ఫైల్లోకి మేము పిల్లి నిఘం ఉంటే, మేము కుక్క తొలగించబడుతుంది కొత్త వెర్షన్ చూడాలని.

135
00:09:29,980 --> 00:09:32,400
కనుక ఇది పూర్తిగా భర్తీ చేయబడుతుంది.

136
00:09:32,400 --> 00:09:36,640
మేము >> ఉపయోగిస్తే బదులుగా, ఫైలు జోడించే జరగబోతోంది.

137
00:09:36,640 --> 00:09:40,860
ఇప్పుడు, తెరుస్తోంది, మేము రెండుసార్లు ముద్రించబడిన ఇదే చూడండి

138
00:09:40,860 --> 00:09:44,920
ఒకప్పుడు ఉంది ఎందుకంటే, అప్పుడు మేము అసలు చేర్చబడుతుంది.

139
00:09:44,920 --> 00:09:48,130
కాబట్టి యొక్క ఏ> మరియు >> లేదు.

140
00:09:48,130 --> 00:09:50,580
తదుపరి అడుగుతుంది - ఇది దాని గురించి అడగండి లేదు.

141
00:09:50,580 --> 00:09:59,050
>> మనం ఇతర ఒక ప్రామాణిక అవుట్ దారిమార్పులను <ఉంటే ఇది,> ఉంది

142
00:09:59,050 --> 00:10:01,970
<ప్రామాణిక సైన్ మళ్ళింపు అవతరిస్తుంది

143
00:10:01,970 --> 00:10:12,050
మేము ఒక ఉదాహరణ ఉంటే యొక్క చూసేలా.

144
00:10:14,750 --> 00:10:16,930
నేను ఒక నిజమైన త్వరగా రాయడం.

145
00:10:17,870 --> 00:10:25,700
యొక్క ఏ ఫైలు, hello.c తీసుకుందాం.

146
00:10:56,060 --> 00:10:59,070
సాపేక్షంగా సూటిగా ఫైలు.

147
00:10:59,070 --> 00:11:03,570
నేను కేవలం ఎంటర్ స్ట్రింగ్ అది ఏమైనప్పటికీ "హలో" ప్రింటింగ్ అప్పుడు స్ట్రింగ్ పొందడానికి మరియు వెబ్.

148
00:11:03,570 --> 00:11:07,990
కాబట్టి హలో హలో మరియు తరువాత చేయండి. /.

149
00:11:07,990 --> 00:11:10,720
ఇప్పుడు అది, ఏదైనా ఎంటర్ నాకు ప్రాంప్ట్ యొక్క

150
00:11:10,720 --> 00:11:15,070
అది సైన్ ప్రామాణిక నమోదు వస్తువుల మీద వేచి యొక్క అర్థం

151
00:11:15,070 --> 00:11:20,450
కాబట్టి మేము రాబ్, హలో చెప్పండి చూడాలని సైన్ నేను ప్రామాణిక లోకి కావలసిన ఎంటర్!

152
00:11:20,450 --> 00:11:23,310
అప్పుడు, హలో అవుట్ ప్రామాణిక రాబ్ ప్రింటింగ్ కాదు!

153
00:11:23,310 --> 00:11:28,860
నేను. / హలో మరియు తరువాత మళ్ళింపు, ఇలా చేస్తే

154
00:11:30,740 --> 00:11:34,310
ఇప్పుడు కోసం మీరు ఒక ఫైల్ నుండి దారిమార్పు చేయవచ్చు.

155
00:11:34,310 --> 00:11:41,720
నేను కొన్ని ఫైలు, టిఎక్స్ టి ఉంచారు, మరియు నేను, రాబ్ ఉంచండి అయితే

156
00:11:41,720 --> 00:11:52,300
నేను హలో అమలు మరియు తరువాత ఫైలు టిఎక్స్ టి మళ్ళింపు ఉంటే. / హలో, అది రాబ్, హలో చెప్పండి వెళుతున్న! వెంటనే.

157
00:11:52,300 --> 00:11:57,160
అది మొదటి GetString చేసుకుంటాడు మరియు ఇది ప్రామాణిక న వేచి ఉన్నప్పుడు

158
00:11:57,160 --> 00:12:01,730
ప్రామాణిక ఎంటర్ చెయ్యండి డేటా కోసం కీబోర్డు మీద వేచి లేదు.

159
00:12:01,730 --> 00:12:05,980
బదులుగా, ఫైలు టిఎక్స్ నుండి చదవడానికి ప్రామాణిక మళ్ళించబడింది చేశారు.

160
00:12:05,980 --> 00:12:10,290
మరియు అందువలన, కేవలం లైన్ రాబ్ ఇది ఫైల్ టిఎక్స్ టి, నుండి చదవడానికి జరగబోతోంది

161
00:12:10,290 --> 00:12:13,380
మరియు తర్వాత ఇది హలో, రాబ్ ముద్రించడానికి జరగబోతోంది!

162
00:12:13,380 --> 00:12:18,180
నేను కోరుకుంటే, నేను కూడా పని చేయడు. / హలో <టిఎక్స్

163
00:12:18,180 --> 00:12:21,500
తరువాత ప్రామాణిక ఆ హలో ఇది దాని ముద్రణ, రాబ్!

164
00:12:21,500 --> 00:12:24,700
నేను దాని స్వంత ఫైల్ లోకి మళ్ళిస్తుంది చేయవచ్చు.

165
00:12:24,700 --> 00:12:29,790
నేను హలో ఫైలు పిలుస్తాను - లేదు, నేను కాదు, ఆ executable ఎందుకంటే - txt2.

166
00:12:29,790 --> 00:12:40,150
ఇప్పుడు, txt2 హలో మాత్రం ఇది. / హలో <టిఎక్స్ టి, రాబ్ యొక్క అవుట్పుట్ కలిగి అన్నారు!

167
00:12:41,370 --> 00:12:43,520
>> ప్రశ్నలు?

168
00:12:45,900 --> 00:12:49,090
>> సరే. కాబట్టి ఇక్కడ మేము పైప్లైన్ ఉన్నాయి.

169
00:12:49,090 --> 00:12:53,510
పైప్స్ దారి మళ్లింపును చివరి యూనిట్ ఉన్నాయి.

170
00:12:53,510 --> 00:12:58,750
>> ఓహ్. నేను దారి మళ్లింపును యొక్క మరొక యూనిట్ ఉంటే బదులుగా ఉంటుంది ఊహించడం> మీరు 2 చేయండి>

171
00:12:58,750 --> 00:13:01,070
ప్రామాణిక దోషం రీడైరెక్ట్ యొక్క.

172
00:13:01,070 --> 00:13:06,280
ఏదో ప్రామాణిక లోపం జరిగింది కాబట్టి, అది txt2 ఉంచి get కాదు.

173
00:13:06,280 --> 00:13:12,480
కానీ నేను 2> లేకపోతే గమనించి, అది ఇప్పటికీ రాబ్, హలో ప్రింటింగ్ కాదు! కమాండ్ లైన్ కు

174
00:13:12,480 --> 00:13:18,600
నేను మాత్రమే ప్రామాణిక తప్పు దారి మళ్ళించడం నేను ఎందుకంటే, నేను ప్రామాణిక అవుట్ రీడైరెక్ట్ లేదు.

175
00:13:18,600 --> 00:13:22,210
ప్రామాణిక దోషం మరియు ప్రామాణిక అవుట్ భిన్నంగా ఉంటాయి.

176
00:13:24,210 --> 00:13:27,080
మీరు నిజంగా ప్రామాణిక లోపం రాయడానికి కోరుకున్నాడు ఉంటే

177
00:13:27,080 --> 00:13:35,080
అప్పుడు నేను stderr కు fprintf అని ఈ మారిపోవచ్చు.

178
00:13:35,080 --> 00:13:37,850
కాబట్టి printf, డిఫాల్ట్గా, ప్రామాణిక అవుట్ ముద్రిస్తుంది.

179
00:13:37,850 --> 00:13:41,720
నేను మానవీయంగా ప్రామాణిక లోపం ప్రింట్ చెయ్యడానికి, అప్పుడు నేను fprintf ఉపయోగించాలి

180
00:13:41,720 --> 00:13:45,010
మరియు నేను ముద్రించడానికి ఏమి తెలుపుము.

181
00:13:45,010 --> 00:13:49,720
బదులుగా నేను fprintf stdout చేశాడు, అప్పుడు ఆ printf ప్రాథమికంగా సమానమైన ఉంది.

182
00:13:49,720 --> 00:13:55,530
కానీ fprintf ప్రామాణిక లోపం.

183
00:13:57,790 --> 00:14:03,650
కాబట్టి ఇప్పుడు, నేను txt2 ఈ మళ్ళింపు ఉంటే, హలో, రాబ్! ఇప్పటికీ ఆదేశ పంక్తి వద్ద ముద్రించిన సంతరించుకుంటున్నది

184
00:14:03,650 --> 00:14:08,270
ఇది ప్రామాణిక లోపం ముద్రించిన సంతరించుకోనుంది మరియు నేను మాత్రమే ప్రామాణిక అవుట్ రీడైరెక్ట్ చేస్తున్నాను నుండి.

185
00:14:08,270 --> 00:14:16,420
నేను ఇప్పుడు ప్రామాణిక మళ్ళింపు లోపం ఉంటే, ఇప్పుడు అది ముద్రించబడిన కాలేదు, మరియు txt2, హలో రాబ్ ఉండబోతుంది?

186
00:14:16,420 --> 00:14:21,910
కాబట్టి ఇప్పుడు, మీరు ప్రామాణిక లోపం మీ వాస్తవ దోషాలు ముద్రించవచ్చు

187
00:14:21,910 --> 00:14:24,720
మరియు ప్రామాణిక అవుట్ మీ సాధారణ సందేశాలను ప్రింట్.

188
00:14:24,720 --> 00:14:31,420
మరియు మీరు మీ ప్రోగ్రామ్ రన్, అప్పుడు మీరు 2 హలో ఈ రకం గా అమలు. / చేయవచ్చు>

189
00:14:31,420 --> 00:14:33,800
మీ ప్రోగ్రామ్, సాధారణంగా అమలు అన్నారు కాబట్టి

190
00:14:33,800 --> 00:14:38,400
కానీ మీరు పొందుతారు ఏ దోష సందేశాలు, మీ లోపం లాగ్ తరువాత తనిఖీ చేయవచ్చు

191
00:14:38,400 --> 00:14:44,500
లోపాలను కాబట్టి, తర్వాత చూసి మీ లోపాలు ఫైలు జరిగిన ఏ లోపాలు ఉంటుంది.

192
00:14:45,200 --> 00:14:47,540
>> ప్రశ్నలు?

193
00:14:47,540 --> 00:14:58,070
>> చివరి మీరు ఒక ఆదేశం నుండి ప్రామాణిక తీసుకున్న భావిస్తున్నది ఇది PIPE ఉంది

194
00:14:58,070 --> 00:15:01,210
మరియు తదుపరి ఆదేశాన్ని యొక్క ప్రామాణిక అయింది.

195
00:15:01,210 --> 00:15:05,570
ఒక ఉదాహరణ ఇక్కడ echo ఒక కమాండ్ లైన్ విషయం ఉంది

196
00:15:05,570 --> 00:15:11,840
కేవలం నేను దాని వాదన వంటి ఉంచారు ఏ ప్రతిధ్వని అన్నారు. నేను కోట్లు పెట్టి లేదు.

197
00:15:11,840 --> 00:15:16,150
ఎకో బ్లా, బ్లా, బ్లా బ్లా కేవలం, బ్లా, బ్లా ప్రింట్ అన్నారు.

198
00:15:16,150 --> 00:15:20,600
ముందు, నేను అన్నాడు నేను ఒక టిఎక్స్ టి ఫైల్లోకి రాబ్ ఉంచారు వచ్చింది

199
00:15:20,600 --> 00:15:28,830
నేను మాత్రమే టిఎక్స్ టి ఫైళ్లను మళ్ళింపు, బదులుగా ఎందుకంటే, / నేను రాబ్ ప్రతిధ్వని ఉంటే

200
00:15:28,830 --> 00:15:35,520
తరువాత పైపు దీనిని. / హలో, ఆ విషయం కూడా అదే రకం చేస్తుంది.

201
00:15:35,520 --> 00:15:39,160
ఈ ఆదేశం యొక్క అవుట్పుట్, echo రాబ్, తీసుకుంటోంది

202
00:15:39,160 --> 00:15:43,610
మరియు ఇన్పుట్ గా ఉపయోగించి. / హలో.

203
00:15:44,790 --> 00:15:49,560
మీరు మొదటి ఫైలు లోకి echo రాబ్ మళ్ళింపు ఆలోచించి చేయవచ్చు

204
00:15:49,560 --> 00:15:54,160
మరియు తర్వాత. / హలో ఫైల్ లోకి ఇన్పుట్ కేవలం outputted అని.

205
00:15:54,160 --> 00:15:57,850
కానీ చిత్రం తాత్కాలిక ఫైల్ తీస్తాడు.

206
00:16:01,890 --> 00:16:04,460
>> ఆ ప్రశ్నలకు?

207
00:16:04,460 --> 00:16:07,150
>> తదుపరి ప్రశ్నకు ఈ కలిగి అన్నారు.

208
00:16:07,150 --> 00:16:15,310
ఏ పైప్లైన్ మీరు names.txt గా పిలువబడే ఒక ఫైల్ లో ఏకైక పేర్లు సంఖ్య కనుగొనేందుకు వాడేవారు?

209
00:16:15,310 --> 00:16:24,160
మేము ఇక్కడ ఉపయోగించాలనుకుంటున్నాను చూడాలని ఆదేశాలు ఏకైక, కాబట్టి uniq, ఆపై WC ఉంటాయి.

210
00:16:24,160 --> 00:16:28,840
మీరు నిజంగా ఆ ఏమి కు వ్యక్తి uniq చేయవచ్చు

211
00:16:28,840 --> 00:16:34,840
అది ఇన్పుట్ నుండి ప్రక్కన సరిపోలే పంక్తులు ఫిల్టర్ చెప్పారు.

212
00:16:34,840 --> 00:16:40,690
మరియు మనిషి WC NEWLINE, పదం, మరియు ప్రతి ఫైల్ కోసం బైట్ గణనలు ప్రింట్ అన్నారు.

213
00:16:40,690 --> 00:16:43,760
మరియు మేము ఉపయోగించాలనుకుంటున్నాను చూడాలని చివరి, క్రమీకరించు ఉంది

214
00:16:43,760 --> 00:16:47,410
ఇది కేవలం టిఎక్స్ టి ఫైలు రేఖలు క్రమం అన్నారు.

215
00:16:47,410 --> 00:16:58,080
నేను కొన్ని టిఎక్స్ టి ఫైలు, names.txt, తయారుచేస్తాయి మరియు దాన్ని రాబ్, టామీ, జోసెఫ్, టామీ, జోసెఫ్, RJ, రాబ్, అయితే

216
00:16:58,080 --> 00:17:03,910
నేను ఇక్కడ చేయాలనుకుంటున్నారా ఈ ఫైలులో ఏకైక పేర్లు సంఖ్య కనుగొనేందుకు ఉంది.

217
00:17:03,910 --> 00:17:08,750
కాబట్టి సమాధానం ఉండాలి? >> [విద్యార్థి] 4. >> అవును.

218
00:17:08,750 --> 00:17:13,780
ఇది రోబ్, టామీ, జోసెఫ్ నుండి 4 ఉండాలి, RJ ఈ ఫైలులో మాత్రమే ఏకైక పేర్లు.

219
00:17:13,780 --> 00:17:20,180
మొదటి దశ, నేను names.txt న పద గణన ఉన్నట్లయితే,

220
00:17:20,180 --> 00:17:24,290
ఈ నిజానికి నాకు ప్రతిదీ చెప్తుంటాడు.

221
00:17:24,290 --> 00:17:32,560
ఈ నిజానికి ముద్రణ ఉంది - న్యూ లైన్, పదాలు, మరియు బైట్ COUNT - మనిషి WC, చూద్దాం.

222
00:17:32,560 --> 00:17:38,270
నేను మాత్రమే పంక్తులు శ్రద్ధ, అప్పుడు నేను WC-l names.txt చేయవచ్చు.

223
00:17:41,730 --> 00:17:44,300
కాబట్టి ఆ దశ 1 ఉంది.

224
00:17:44,300 --> 00:17:50,510
Names.txt అన్ని పేర్లు ఉన్నందున కానీ, WC-l names.txt చేయకూడదని

225
00:17:50,510 --> 00:17:54,170
మరియు నేను ఏదైనా ఏకైక వాటిని ఫిల్టర్ చెయ్యడానికి మీరు.

226
00:17:54,170 --> 00:18:01,200
నేను uniq names.txt లేకపోతే కనుక, నేను ఏమి నాకు ఇవ్వండి లేదు

227
00:18:01,200 --> 00:18:03,760
నకిలీ పేర్లు ఇప్పటికీ ఎందుకంటే.

228
00:18:03,760 --> 00:18:07,690
ఎందుకు అని? ఎందుకు uniq నేను ఏమి చేయడం లేదు?

229
00:18:07,690 --> 00:18:10,500
[విద్యార్థి] నకిలీలను కాదు [వినబడని] >> అవును.

230
00:18:10,500 --> 00:18:16,370
Uniq కోసం మనిషి పేజీ గుర్తుంచుకో ఫిల్టర్ ప్రక్కన మ్యాచింగ్ పంక్తులు చెప్పారు.

231
00:18:16,370 --> 00:18:19,680
వారు ప్రక్కన లేదు, కనుక ఫిల్టర్ చేస్తుంది.

232
00:18:19,680 --> 00:18:31,100
నేను మొదటి క్రమం ఉంటే, క్రమీకరించు names.txt కలిసి అన్ని నకిలీ పంక్తులు ఉంచారు అన్నారు.

233
00:18:31,100 --> 00:18:34,450
కాబట్టి ఇప్పుడు విధమైన names.txt ఉంది.

234
00:18:34,450 --> 00:18:40,550
Uniq | నేను ఇది uniq, ఇన్పుట్ ఆ ఉపయోగించాలనుకుంటున్నాను వెళుతున్న.

235
00:18:40,550 --> 00:18:43,390
అది నాకు జోసెఫ్, RJ, రాబ్, టామీ, ఇస్తుంది

236
00:18:43,390 --> 00:18:49,260
మరియు నేను, WC-l ఇన్పుట్ ఆ ఉపయోగించాలనుకుంటున్నాను

237
00:18:49,260 --> 00:18:52,740
ఇది నాకు 4 ఇవ్వాలని అన్నారు.

238
00:18:52,740 --> 00:18:56,930
అది ఇక్కడ చెప్పారు వలె, మీరు ఏమి పైప్లైన్ ఉపయోగించవచ్చు?

239
00:18:56,930 --> 00:19:01,390
మీరు ఆదేశాలను సీరీస్ ను వంటి వాటిని చాలా చేయవచ్చు

240
00:19:01,390 --> 00:19:05,130
మీరు తదుపరి ఆదేశానికి ఇన్పుట్ ఒక ఆదేశం నుండి అవుట్పుట్ ఉపయోగిస్తారు.

241
00:19:05,130 --> 00:19:08,780
మీరు విషయాలు చాలా, తెలివైన విషయాలు చాలా చేయవచ్చు.

242
00:19:08,780 --> 00:19:11,440
>> ప్రశ్నలు?

243
00:19:12,910 --> 00:19:14,600
సరే.

244
00:19:14,600 --> 00:19:17,880
గొట్టాలు మరియు దారిమళ్ళింపు అది పేర్కొంది.

245
00:19:18,370 --> 00:19:24,090
>> ఇప్పుడు మేము అసలు విషయం, కోడింగ్ స్టఫ్ సాగుతుంది.

246
00:19:24,090 --> 00:19:29,100
ఈ PDF లోపలి మీరు, ఈ ఆదేశం చూస్తారు

247
00:19:29,100 --> 00:19:32,950
మరియు మీరు మీ ఉపకరణం ఈ ఆదేశాన్ని చెయ్యవచ్చును.

248
00:19:36,240 --> 00:19:42,250
wget, ప్రధానంగా, కేవలం ఇంటర్నెట్ నుండి ఏదో పొందడానికి ఆదేశాలు

249
00:19:42,250 --> 00:19:45,180
కాబట్టి wget మరియు ఈ URL.

250
00:19:45,180 --> 00:19:49,110
మీరు మీ బ్రౌజర్ లో ఈ URL వెళ్ళాడు, అది ఆ ఫైల్ డౌన్లోడ్ అవుతుంది.

251
00:19:49,110 --> 00:19:52,510
నేను దాని మీద క్లిక్, కాబట్టి ఇది నాకు ఫైల్ డౌన్లోడ్.

252
00:19:52,510 --> 00:19:55,650
కానీ టెర్మినల్ యొక్క లోపల విషయం యొక్క wget రాయడం

253
00:19:55,650 --> 00:19:58,620
మీ టెర్మినల్ లో డౌన్లోడ్ అన్నారు.

254
00:19:58,620 --> 00:20:02,750
నేను section5.zip కలిగి, మరియు మీరు section5.zip అన్జిప్ చెయ్యవచ్చును

255
00:20:02,750 --> 00:20:06,520
ఇది మీరు section5 అనే ఫోల్డర్ ఇవ్వాలని అన్నారు

256
00:20:06,520 --> 00:20:11,550
మనం లోపల నేడు ఉపయోగిస్తున్న చూడాలని ఫైళ్లు అన్ని అన్నారు ఇది.

257
00:20:33,380 --> 00:20:37,710
ఈ కార్యక్రమాలు 'ఫైలు పేర్లను సూచిస్తుంది, అవి ఒక బిట్ బగ్గీ ఉన్నాము,

258
00:20:37,710 --> 00:20:40,990
మీ మిషన్ GDB ఉపయోగించి ఎందుకు గుర్తించడానికి ఉంది.

259
00:20:40,990 --> 00:20:44,560
వాటిని ప్రతి ఒక్కరూ డౌన్లోడ్ / వాటిని డౌన్లోడ్ ఎలా పొందాలో మాకు కలిగి

260
00:20:44,560 --> 00:20:47,480
వారి ఉపకరణం వలె? సరే.

261
00:20:47,480 --> 00:20:56,400
>> ./buggy1 రన్నింగ్, ఇది విభజన లోపంగా (ముడి వేసారు) యున్నది

262
00:20:56,400 --> 00:21:00,500
మీరు ఒక segfault పొందండి ఏ సమయంలో, అది మంచిది.

263
00:21:00,500 --> 00:21:03,810
ఏ పరిస్థితులలో మీరు ఒక segfault వస్తుందా?

264
00:21:03,810 --> 00:21:08,210
[విద్యార్థి] ఒక నల్ పాయింటర్ Dereferencing. >> అవును. కాబట్టి ఒక ఉదాహరణ.

265
00:21:08,210 --> 00:21:11,580
మీరు ఒక segfault పొందడానికి వెళుతున్న ఒక నల్ పాయింటర్ Dereferencing.

266
00:21:11,580 --> 00:21:16,720
మీరు మెమరీ తాకిన ఏమి సాధనంగా segfault మీరు తాకడం లేదు.

267
00:21:16,720 --> 00:21:21,350
కాబట్టి ఒక నల్ పాయింటర్ dereferencing, చిరునామా 0 తాకినప్పటికీ అది లోపలే

268
00:21:21,350 --> 00:21:28,060
మరియు ప్రధానంగా, అన్ని కంప్యూటర్లలో రోజుల్లో చిరునామా 0 మీరు తాకడం లేదు మెమరీ చెపుతారు.

269
00:21:28,060 --> 00:21:31,920
ఒక segfault ఒక నల్ పాయింటర్ ఫలితాలు dereferencing వై సో ఆ.

270
00:21:31,920 --> 00:21:37,210
మీరు ఒక పాయింటర్ ప్రారంభించడం సాధ్యం సంభవించినప్పుడు పూర్తి, అది, ఒక చెత్త విలువ

271
00:21:37,210 --> 00:21:41,520
మరియు మీరు dereference ప్రయత్నించినప్పుడు అది, అన్ని సంభావ్యత లో మీరు మెమరీ తాకిన చేస్తున్నారు

272
00:21:41,520 --> 00:21:43,540
ఆ ఎక్కడా మధ్యలో ఉంది.

273
00:21:43,540 --> 00:21:45,650
మీరు లక్కీ మరియు చెత్త విలువ పొందడానికి జరిగితే

274
00:21:45,650 --> 00:21:48,440
స్టాక్ లేదా ఏదైనా ఎక్కడో సూచించడానికి జరిగిన,

275
00:21:48,440 --> 00:21:50,820
అప్పుడు మీరు పాయింటర్ initialized కాని మీరు dereference,

276
00:21:50,820 --> 00:21:52,730
ఏమీ తప్పు వెళ్తుంది.

277
00:21:52,730 --> 00:21:55,480
అది సూచించే యొక్క అయితే, ఎక్కడో స్టాక్ మరియు కుప్ప మధ్య, సే

278
00:21:55,480 --> 00:21:59,850
లేదా అది కేవలం ఎక్కడో ఇంకా మీ ప్రోగ్రామ్ ద్వారా ఉపయోగంలో లేని ఆ పై యొక్క

279
00:21:59,850 --> 00:22:02,240
మీరు తాకడం లేదు మెమరీ తాకిన చేసిన మరియు మీరు segfault.

280
00:22:02,240 --> 00:22:06,370
మీరు ఒక పునరావృత ఫంక్షన్ వ్రాసి చాలా సార్లు recurses చేసినప్పుడు

281
00:22:06,370 --> 00:22:08,720
మరియు మీ స్టాక్ విషయాలు లోకి చాలా పెద్ద మరియు స్టాక్ గుద్దు పెరుగుతుంది

282
00:22:08,720 --> 00:22:12,270
మీరు తాకడం లేదు అది గుద్దుకునే కూడదు, మీరు మెమరీ తాకిన చేస్తున్నారు,

283
00:22:12,270 --> 00:22:14,810
కాబట్టి మీరు segfault.

284
00:22:14,810 --> 00:22:17,010
ఏ ఒక segfault ఉంది.

285
00:22:17,010 --> 00:22:21,810
>> ఇది కూడా అదే కారణం అని మీరు వంటి స్ట్రింగ్ కలిగి ఉంటే -

286
00:22:21,810 --> 00:22:23,930
గత కార్యక్రమం తిరిగి వదలి వేస్తారు.

287
00:22:23,930 --> 00:22:28,530
లో hello.c--I'm కేవలం ఏదో సిధ్ధంగా.

288
00:22:28,530 --> 00:22:33,770
చార్ * s = "హలో వరల్డ్!";

289
00:22:33,770 --> 00:22:42,310
నేను ఉపయోగిస్తే * s = ఏదో లేదా s [0] = 'X';

290
00:22:42,310 --> 00:22:47,290
కాబట్టి హలో తయారు. / హలో, ఎందుకు ఆ segfault చేశారు?

291
00:22:48,410 --> 00:22:51,250
ఎందుకు ఈ segfault చేశారు?

292
00:22:55,660 --> 00:22:57,890
మీరు ఏమి ఊహించిన దాని?

293
00:22:57,890 --> 00:23:06,640
నేను printf పొతే ("% s \ n", s); మీకు ముద్రించబడిన ఊహించిన దాని?

294
00:23:06,640 --> 00:23:09,930
[విద్యార్థి] X హలో. >> అవును.

295
00:23:09,930 --> 00:23:15,140
సమస్య, మీరు ఈ స్ట్రింగ్ ఉన్నప్పుడు డిక్లేర్ ఉంది

296
00:23:15,140 --> 00:23:18,190
s, స్టాక్ మీద బయటకు వెళ్లి ఒక పాయింటర్ గా

297
00:23:18,190 --> 00:23:25,880
ఏ s కు సూచిస్తుంది రీడ్ ఓన్లీ మెమరీ పొందుపర్చి ఉన్న ఈ స్ట్రింగ్.

298
00:23:25,880 --> 00:23:30,560
కేవలం పేరు, రీడ్ ఓన్లీ మెమరీ, అందువల్ల మీరు ఆలోచన కావాలి

299
00:23:30,560 --> 00:23:33,010
మీరు రీడ్ ఓన్లీ మెమరీ లో ఏమి మార్చడానికి ప్రయత్నించండి ఉంటే,

300
00:23:33,010 --> 00:23:36,670
మీరు మెమరీ తో చేయడం లేదు ఏదో చేస్తున్నా మరియు మీరు segfault.

301
00:23:36,670 --> 00:23:45,360
ఈ నిజానికి చార్ * s మరియు చార్ లు [] మధ్య ఒక పెద్ద తేడా ఉంది.

302
00:23:45,360 --> 00:23:48,790
కాబట్టి చార్ లు [], ఇప్పుడు ఈ స్ట్రింగ్ స్టాక్ లో పెట్టడానికి అన్నారు,

303
00:23:48,790 --> 00:23:53,960
మరియు స్టాక్ ఈ ఖచ్చితంగా బాగా పని చేయాలి అంటే, చదవడానికి మాత్రమే కాదు.

304
00:23:55,500 --> 00:23:57,370
మరియు అది.

305
00:23:57,370 --> 00:24:06,250
గుర్తుంచుకో నేను చార్ చేసినప్పుడు * s = "హలో వరల్డ్!", S కూడా స్టాక్ ఉంది

306
00:24:06,250 --> 00:24:10,390
కానీ s ఎక్కడైనా కు పాయింట్లు, మరియు ఆ ఎక్కడైనా చదవడానికి మాత్రమే నిర్మాణము.

307
00:24:10,390 --> 00:24:15,640
కానీ చార్ లు [] కేవలం స్టాక్ మీద ఏదో ఉంది.

308
00:24:17,560 --> 00:24:21,760
కాబట్టి ఒక segfault జరుగుతున్న మరొక ఉదాహరణ ఉంది.

309
00:24:21,760 --> 00:24:27,820
>> మేము ./buggy1 ఒక segfault ఫలితంగా చూసింది.

310
00:24:27,820 --> 00:24:31,810
సిద్ధాంతంలో, మీరు వెంటనే buggy1.c వద్ద చూడరాదని.

311
00:24:31,810 --> 00:24:35,170
బదులుగా, GDB ద్వారా వద్ద పరిశీలిస్తాము.

312
00:24:35,170 --> 00:24:37,750
మీరు విభజన లోపంగా (ముడి వేసారు) వచ్చిన ప్రకటనలో,

313
00:24:37,750 --> 00:24:40,850
మీరు ఇక్కడ అని కోర్ ఈ ఫైల్.

314
00:24:40,850 --> 00:24:45,200
మేము ls-l, ఆ కోర్ సాధారణంగా చాలా పెద్ద ఫైలు చూస్తారు.

315
00:24:45,200 --> 00:24:51,580
ఈ ఫైలు యొక్క బైట్లు యొక్క సంఖ్య, కాబట్టి ఇది 250 ఏదో లు ఉన్నట్లు కనిపిస్తోంది.

316
00:24:51,580 --> 00:24:56,120
ఈ కారణం కోర్ డంప్ వాస్తవానికి ఏ ఉంటుంది

317
00:24:56,120 --> 00:25:01,410
ఉన్నప్పుడు మీ ప్రోగ్రామ్ క్రాష్, మీ ప్రోగ్రామ్ యొక్క మెమరీ రాష్ట్ర

318
00:25:01,410 --> 00:25:05,230
కేవలం కాపీ మరియు ఈ ఫైలు లోకి అతికించబడింది తీర్చుకుంటాడు.

319
00:25:05,230 --> 00:25:07,270
ఇది ఫైల్ లోకి తిరస్కరించబడుతుంది.

320
00:25:07,270 --> 00:25:13,060
ఈ కార్యక్రమం అమలు అవుతున్నప్పుడు, అది,, దాదాపు 250 ల మెమొరీ వాడుక కలిగి జరిగిన

321
00:25:13,060 --> 00:25:17,040
అందువలన, ఈ ఫైల్ పోస్తారు ఏం జరిగింది ఉంది.

322
00:25:17,040 --> 00:25:23,630
మేము GDB buggy1 కోర్ లేకపోతే ఇప్పుడు మీరు ఆ ఫైల్ చూడవచ్చు.

323
00:25:23,630 --> 00:25:30,130
మేము GDB buggy1 చేయవచ్చు, మరియు కేవలం, క్రమం తప్పకుండా GDB అప్ మొదలవుతుంది

324
00:25:30,130 --> 00:25:33,800
దాని ఇన్పుట్ ఫైల్గా buggy1 ఉపయోగించి.

325
00:25:33,800 --> 00:25:38,260
మీరు GDB buggy1 కోర్ చేయండి అయితే, అది ప్రత్యేకంగా GDB అప్ ఆరంభమవుతుంది

326
00:25:38,260 --> 00:25:40,330
ప్రధాన ఫైలు చూడటం ద్వారా.

327
00:25:40,330 --> 00:25:45,560
మరియు మీరు buggy1 అంటే GDB చెప్పడం ప్రధాన ఫైలు buggy1 కార్యక్రమం నుంచి వచ్చింది తెలుసు.

328
00:25:45,560 --> 00:25:49,580
కాబట్టి GDB buggy1 కోర్ వెంటనే మాకు చేసేందుకు ప్రయత్నిస్తుంది

329
00:25:49,580 --> 00:25:52,060
కార్యక్రమం రద్దు జరిగింది ఎక్కడ.

330
00:25:57,720 --> 00:26:02,340
మేము ప్రోగ్రామ్ సిగ్నల్ 11, విభజన లోపంగా తో రద్దు ఇక్కడ చూడండి.

331
00:26:02,340 --> 00:26:10,110
మేము బహుశా చాలా సహాయకారిగా కాదు అసెంబ్లీ, ఒక లైన్ చూడటానికి పొందుతున్నారు.

332
00:26:10,110 --> 00:26:15,360
మీరు BT లేదా వెనుకకు టైప్ అయితే, ఆ ఫంక్షన్ చేస్తాడు

333
00:26:15,360 --> 00:26:19,430
మాకు మా ప్రస్తుత స్టాక్ ఫ్రేములు జాబితా ఇస్తుంది.

334
00:26:19,430 --> 00:26:23,150
కాబట్టి వెనుకకు. మేము కేవలం రెండు స్టాక్ ఫ్రేమ్లను కలిగి ఉన్నట్లు తెలుస్తుంది.

335
00:26:23,150 --> 00:26:26,310
మొదటి, మా ప్రధాన స్టాక్ ఫ్రేమ్

336
00:26:26,310 --> 00:26:29,810
మరియు రెండవ, మేము ఉండాలి జరిగే ఈ వేడుకలో స్టాక్ ఫ్రేమ్

337
00:26:29,810 --> 00:26:34,440
మేము మాత్రమే అసెంబ్లీ కోడ్ ఉన్నట్లు ఇది కనిపిస్తోంది.

338
00:26:34,440 --> 00:26:38,050
కాబట్టి యొక్క మా ప్రధాన విధి తిరిగి వీడలేదు,

339
00:26:38,050 --> 00:26:42,300
మరియు మేము ఫ్రేమ్ 1 చేయవచ్చు అలా, మరియు మనం కూడా డౌన్ చేయవచ్చు ఆలోచించడం,

340
00:26:42,300 --> 00:26:45,160
అప్ లేదా - కాని నేను దాదాపు అధిగమించుట ఎప్పుడూ. అవును.

341
00:26:45,160 --> 00:26:50,710
పైకి క్రిందికి. అప్ మీరు ఒక స్టాక్ ఫ్రేమ్ మీరు డౌన్ తెస్తుంది డౌన్, ఒక స్టాక్ ఫ్రేమ్ వస్తుంది.

342
00:26:50,710 --> 00:26:53,240
నేను ఆ ఉపయోగించడానికి ఎప్పుడూ ఉంటాయి.

343
00:26:53,240 --> 00:26:59,120
నేను ప్రత్యేకంగా 1 లేబుల్ ఫ్రేమ్ వెళ్ళండి ఇది ఫ్రేమ్ 1 చెబుతారు.

344
00:26:59,120 --> 00:27:01,750
Frame 1, ప్రధాన స్టాక్ ఫ్రేమ్ లోకి మాకు చేసేందుకు ప్రయత్నిస్తుంది

345
00:27:01,750 --> 00:27:05,570
మరియు అది ఇక్కడే మేము వద్ద కావడం కోడ్ వాక్యాన్ని చెబుతుంది.

346
00:27:05,570 --> 00:27:07,950
మేము కోడ్ యొక్క ఒక జంట మరిన్ని పంక్తులు అనుకుంటే, మేము, జాబితా చెప్పగలదు

347
00:27:07,950 --> 00:27:11,280
మరియు మాకు ఇది చుట్టూ కోడ్ అన్ని లైన్లు ఇవ్వడానికి జరగబోతోంది.

348
00:27:11,280 --> 00:27:13,360
మేము వద్ద segfaulted లైన్ 6 ఉంది:

349
00:27:13,360 --> 00:27:17,360
ఉంటే (strcmp ("CS50 రాళ్ళు", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
అది ఇంకా స్పష్టంగా ఉంటే, మీరు దాన్ని segfaulted ఎందుకు ఆలోచించడం ద్వారా ఇక్కడ నుండి దానిని నేరుగా పొందవచ్చు.

351
00:27:24,130 --> 00:27:28,800
కానీ మేము ఒక అడుగు ముందుకు తీసుకెళ్ళవచ్చు మరియు చెప్పడానికి, "ఎందుకు argv [1] segfault అనుకుంటున్నారు?" చేయవచ్చు

352
00:27:28,800 --> 00:27:38,830
లెట్స్ print argv [1], మరియు అది నల్ పాయింటర్ ఇది దాని 0x0, కనిపిస్తోంది.

353
00:27:38,830 --> 00:27:44,750
మేము segfault వెళుతున్న తద్వారా CS50 రాళ్ళు మరియు శూన్య strcmping, మరియు చేస్తున్నారు.

354
00:27:44,750 --> 00:27:48,280
మరియు ఎందుకు argv [1] శూన్య?

355
00:27:48,640 --> 00:27:51,280
[విద్యార్థి] మేము ఏ ఆదేశ పంక్తి వాదనలు ఇవ్వని కారణంగా.

356
00:27:51,280 --> 00:27:53,390
అవును. మేము ఏ ఆదేశ పంక్తి వాదనలు ఇవ్వలేదని.

357
00:27:53,390 --> 00:27:58,460
కాబట్టి ./buggy1 మాత్రమే argv [0] ./buggy1 అయి ఉంటాయి అన్నారు.

358
00:27:58,460 --> 00:28:02,100
ఇది ఒక argv [1] కలిగి మాత్రం కాదు, segfault వెళుతున్న తద్వారా.

359
00:28:02,100 --> 00:28:07,450
బదులుగా, నేను CS50 చేయండి, అయితే, మీరు D పొందండి చెప్పడానికి జరగబోతోంది

360
00:28:07,450 --> 00:28:09,950
ఆ అది ఏమి చేయాలో ఏమి ఎందుకంటే.

361
00:28:09,950 --> 00:28:15,240
Buggy1.c వద్ద గురించి, ప్రింట్ కోరుకుంటున్నాము యొక్క "మీరు ఒక D పొందండి" -

362
00:28:15,240 --> 00:28:20,820
Argv [1] "CS50 రాళ్ళు", లేకపోతే, "మీరు ఒక D పొందండి" చెయ్యకపోతే "మీరు ఒక ఒక పొందండి!"

363
00:28:20,820 --> 00:28:25,660
మేము ఒక ఒక అనుకుంటే, మేము, నిజం పోల్చడానికి ఈ అవసరం

364
00:28:25,660 --> 00:28:28,710
అది 0 పోలిస్తే అర్థం.

365
00:28:28,710 --> 00:28:31,100
కాబట్టి argv [1] "CS50 రాళ్ళు" ఉండాలి.

366
00:28:31,100 --> 00:28:35,660
మీరు ఆదేశ ఆ విధంగా చేయడానికి, మీరు ఖాళీ తప్పించుకోవడానికి \ ఉపయోగించాలి.

367
00:28:35,660 --> 00:28:41,690
కాబట్టి CS50 \ రాళ్ళు మరియు మీరు ఒక ఒక పొందండి!

368
00:28:41,690 --> 00:28:44,060
మీరు బాక్ స్లాష్ చేయకపోతే, ఎందుకు ఈ పని లేదు?

369
00:28:44,060 --> 00:28:47,190
[విద్యార్థి] ఇది రెండు వేర్వేరు వాదనలు ఉంది. >> అవును.

370
00:28:47,190 --> 00:28:52,540
Argv [1] CS50 ఉండబోతుంది, మరియు argv [2] రాళ్ళు అని అన్నారు. సరే.

371
00:28:52,540 --> 00:28:56,470
>> ఇప్పుడు మళ్ళీ ./buggy2 segfault అన్నారు.

372
00:28:56,470 --> 00:29:01,880
దాని కోర్ ఫైల్ తో ప్రారంభమైన, మేము నేరుగా buggy2 ప్రారంభం చేస్తాము

373
00:29:01,880 --> 00:29:05,000
GDB buggy2 కాబట్టి.

374
00:29:05,000 --> 00:29:09,590
మేము మా కార్యక్రమం అమలు చేస్తే ఇప్పుడు, అది, ప్రోగ్రామ్ సిగ్నల్ SIGSEGV పొందింది చెప్పడానికి జరగబోతోంది

375
00:29:09,590 --> 00:29:15,530
ఇది సిగ్నల్ segfault, మరియు జరిగి జరిగిన పేరు ఉంటుంది.

376
00:29:15,530 --> 00:29:21,250
మా వెనుకకు వద్ద గురించి, మేము, మేము ఫంక్షన్ oh_no ఉన్నాయి చూడండి

377
00:29:21,250 --> 00:29:23,900
ఇది ఫంక్షన్ binky ఏర్పాటు చేశారు ఫంక్షన్ పరిశుభ్రంగా, అనే

378
00:29:23,900 --> 00:29:26,460
ప్రధాన ద్వారా పిలుస్తారు.

379
00:29:26,460 --> 00:29:31,680
మేము కూడా ఈ విధులకు వాదనలు చూడగలరు.

380
00:29:31,680 --> 00:29:34,680
పరిశుభ్రంగా మరియు binky కు వాదన 1 ఉంది.

381
00:29:34,680 --> 00:29:44,390
మేము ఫంక్షన్ oh_no జాబితా ఉంటే, మేము oh_no కేవలం చార్ ** s = NULL చేస్తున్న ఆ చూడండి;

382
00:29:44,390 --> 00:29:47,410
* S = "బూమ్";

383
00:29:47,410 --> 00:29:50,330
ఎందుకు ఆ వైఫల్యం?

384
00:29:54,330 --> 00:29:58,380
[విద్యార్థి] మీరు dereference నల్ పాయింటర్ కాదు? >> అవును.

385
00:29:58,380 --> 00:30:06,090
ఒక చార్ ** నిర్మాణము ఈ కేవలం, సంబంధం లేకుండా, s NULL ఉంది అని

386
00:30:06,090 --> 00:30:12,070
మీరు దానిని వ్యాఖ్యానిస్తారు ఆధారపడి, అది స్త్రింగ్ కి ఒక పాయింటర్ ఒక పాయింటర్ చేసే ఆ,

387
00:30:12,070 --> 00:30:15,550
లేదా తీగలను యొక్క వ్యూహం.

388
00:30:15,550 --> 00:30:21,430
ఇది s NULL ఉంది, కనుక * s, ఒక నల్ పాయింటర్ dereferencing ఉంది

389
00:30:21,430 --> 00:30:24,800
మరియు ఈ క్రాష్ అన్నారు.

390
00:30:24,800 --> 00:30:27,540
మీరు బహుశా segfault చేయవచ్చు శీఘ్రమైన ఒకటి.

391
00:30:27,540 --> 00:30:31,300
ఇది కేవలం నల్ పాయింటర్ ప్రకటించారు మరియు తక్షణమే segfaulting యొక్క.

392
00:30:31,300 --> 00:30:34,570
ఆ oh_no ఏమి ఉంది.

393
00:30:34,570 --> 00:30:43,400
మేము ఒక ఫ్రేమ్ పెరుగుతుంది, అప్పుడు మేము oh_no అని ఆ ఫంక్షన్ పొందడానికి వెళుతున్న.

394
00:30:43,400 --> 00:30:44,830
నేను క్రింద ఆ చేయాలి.

395
00:30:44,830 --> 00:30:48,610
మీరు ఒక ఆదేశమును ప్రవేశపెట్టుము మరియు మీరు కేవలం, మళ్ళీ ఎంటర్ నొక్కండి

396
00:30:48,610 --> 00:30:52,350
ఇది మీరు సాగిన మునుపటి ఆదేశం పునరావృతం.

397
00:30:52,350 --> 00:30:56,610
మేము ఫ్రేమ్ 1 ఉన్నాయి.

398
00:30:56,610 --> 00:31:04,650
ఈ ఫ్రేమ్ లిస్టింగ్, మేము ఇక్కడ మా విధి చూడండి.

399
00:31:04,650 --> 00:31:08,520
మీరు మళ్ళీ జాబితా నొక్కండి, లేదా మీరు జాబితా 20 చేయవచ్చు మరియు మరింత జాబితా చేస్తుంది.

400
00:31:08,520 --> 00:31:13,640
ఫంక్షన్ పరిశుభ్రంగా నేను 1 ఉంటే, అప్పుడు, oh_no ఫంక్షన్ కి వెళ్ళండి అన్నారు

401
00:31:13,640 --> 00:31:15,960
ఇంకా slinky కు వెళ్ళండి.

402
00:31:15,960 --> 00:31:18,700
మరియు మేము ఇక్కడ చూడటానికి ఏమి ఎందుకంటే నేను 1 తెలుసు

403
00:31:18,700 --> 00:31:22,560
ఆ పరిశుభ్రంగా వాదన 1 తో పిలుస్తారు.

404
00:31:22,560 --> 00:31:27,560
లేదా మీరు నేను ప్రింట్ చెయ్యాలి మరియు ఇది నేను 1 యున్నది.

405
00:31:27,560 --> 00:31:33,770
మేము పరిశుభ్రంగా ఉంది, మరియు మేము మరొక ఫ్రేమ్ పెరుగుతుంది ఉంటే, మేము binky లో ముగుస్తుంది చేస్తాము తెలుసు.

406
00:31:33,770 --> 00:31:36,600
అప్. ఇప్పుడు మేము binky లో ఉన్నాము.

407
00:31:36,600 --> 00:31:41,340
సగం నాకు నరికి ముందు నుండి జాబితా - - ఈ ఫంక్షన్ లిస్టింగ్

408
00:31:41,340 --> 00:31:52,670
నేను 0 ఉంటే అది ప్రారంభమైనది, అప్పుడు మేము దాన్ని oh_no కాల్ చూడాలని, లేకపోతే పరిశుభ్రంగా కాల్.

409
00:31:52,670 --> 00:31:57,000
మేము నాకు 1 విషయం, కాబట్టి ఇది పరిశుభ్రంగా అని.

410
00:31:57,000 --> 00:32:05,030
ఇప్పుడు మేము ప్రధాన తిరిగి వచ్చాక, మరియు ప్రధాన కేవలం Int i = RAND ()% 3 అన్నారు;

411
00:32:05,030 --> 00:32:08,790
అది మీరు 0, 1, లేదా 2 ఒక యాదృచ్చిక సంఖ్య ఇవ్వాలని అన్నారు.

412
00:32:08,790 --> 00:32:12,780
ఇది ఆ సంఖ్య binky కాల్ అవకాశముంది, మరియు అది 0 చూపిస్తుంది.

413
00:32:12,780 --> 00:32:16,700
ఈ చూడటం,

414
00:32:16,700 --> 00:32:19,880
కేవలం, తక్షణమే అమలు లేకుండా మానవీయంగా కార్యక్రమం ద్వారా వాకింగ్

415
00:32:19,880 --> 00:32:25,400
మీరు ప్రధాన వద్ద ఒక బ్రేక్ పాయింట్ సెట్ చేస్తుంది, ఇది మేము అమలు చేసేటప్పుడు అర్థం

416
00:32:25,400 --> 00:32:31,020
అది ఒక బ్రేక్ పాయింట్ హిట్స్ వరకు మీ ప్రోగ్రామ్ అప్ నడుస్తుంది.

417
00:32:31,020 --> 00:32:35,450
ప్రోగ్రామ్ను అమలు కాబట్టి, అమలు చేస్తుంది మరియు అప్పుడు ప్రధాన విధి హిట్ మరియు అమలు చేయవు.

418
00:32:35,450 --> 00:32:44,700
ఇప్పుడు మేము ప్రధాన లోపలి ఉన్నాము, మరియు దశ లేదా తదుపరి కోడ్ తదుపరి లైన్ మాకు చేసేందుకు ప్రయత్నిస్తుంది.

419
00:32:44,700 --> 00:32:47,050
మీరు దశ లేదా తదుపరి చేయవచ్చు.

420
00:32:47,050 --> 00:32:51,800
తదుపరి, హిట్టింగ్ ఇప్పుడు నేను RAND ()% 3, కాబట్టి మేము i యొక్క విలువ ముద్రించవచ్చు, సెట్ చెయ్యబడింది

421
00:32:51,800 --> 00:32:55,280
మరియు నేను 1 యున్నది.

422
00:32:55,280 --> 00:32:58,110
ఇప్పుడు అది రాబోయే లేదా దశను ఉపయోగిస్తున్నాయి లేదో అవసరం.

423
00:32:58,110 --> 00:33:01,000
నేను ముందు లో ముఖ్యమని అంచనా, కానీ రాబోయే ఉపయోగించడానికి కావాలో.

424
00:33:01,000 --> 00:33:06,000
మేము అడుగు ఉపయోగిస్తే, మేము ఫంక్షన్ లో అడుగు, వాస్తవ విషయం చూడు అర్థం

425
00:33:06,000 --> 00:33:07,940
ఆ binky లోపలి జరుగుతున్నది.

426
00:33:07,940 --> 00:33:10,510
రాబోయే ఉపయోగిస్తే, అప్పుడు అది ఫంక్షన్ వెళ్ళి అర్థం

427
00:33:10,510 --> 00:33:14,070
మరియు మా ప్రధాన ఫంక్షన్ కోడ్ తదుపరి లైన్ వెళ్ళండి.

428
00:33:14,070 --> 00:33:17,900
ఇక్కడే పై, నేను RAND ()% 3 చెప్పబడిన వద్ద ఉంది;

429
00:33:17,900 --> 00:33:21,320
నేను అడుగు, ఇది RAND అమలు కానుందని

430
00:33:21,320 --> 00:33:25,110
మరియు అక్కడ ఏం చూడండి, మరియు నేను RAND చర్య ద్వారా అడుగు కాలేదు.

431
00:33:25,110 --> 00:33:26,920
కానీ నేను RAND ఫంక్షన్ గురించి పట్టించుకోను.

432
00:33:26,920 --> 00:33:30,190
నేను ప్రధాన కోడ్ తదుపరి లైన్ కు వెళ్లాలని మీరు అనుకుంటున్నారా, నేను తరువాత ఉపయోగించండి.

433
00:33:30,190 --> 00:33:35,800
కానీ ఇప్పుడు నేను binky ఫంక్షన్ గురించి జాగ్రత్త, అందుచే నేను చేయడానికి కావలసిన.

434
00:33:35,800 --> 00:33:37,730
ఇప్పుడు నేను binky ఉన్నాను.

435
00:33:37,730 --> 00:33:42,040
కోడ్ యొక్క మొదటి లైన్ (i == 0), నేను ఒక దశకు ఉంటే చెప్పండి అన్నారు,

436
00:33:42,040 --> 00:33:44,930
మేము పరిశుభ్రంగా వద్ద ముగుస్తుంది చూడండి.

437
00:33:44,930 --> 00:33:51,620
మేము జాబితా విషయాలు, మేము అది తనిఖీ ఉందని నేను = 0.

438
00:33:51,620 --> 00:33:55,470
నేను 0 సమానం కాదు, కాబట్టి ఇది ఇంకా పరిస్థితి వెళ్ళాడు

439
00:33:55,470 --> 00:33:59,540
ఇది పరిశుభ్రంగా (i) కాల్ అన్నారు.

440
00:33:59,540 --> 00:34:04,030
మీరు అయోమయం get ఉండవచ్చు.

441
00:34:04,030 --> 00:34:07,380
మీరు నేరుగా ఈ పంక్తులు చూడండి, మీరు భావిస్తే ఉండవచ్చు, (i == 0) ఉంటే

442
00:34:07,380 --> 00:34:10,800
సరే,, అప్పుడు నేను ఒక అడుగు తీసుకుంది మరియు ఇప్పుడు నేను పరిశుభ్రంగా (i) వద్ద ఉన్నాను

443
00:34:10,800 --> 00:34:14,120
మీరు ఆ i = 0 లేదా ఏదో ఒకటి ఉండాలి అనుకుంటున్నాను ఉండవచ్చు.

444
00:34:14,120 --> 00:34:18,980
నం ఇది కేవలం అది లైన్ పరిశుభ్రంగా (i) నేరుగా అతుక్కుపోగలవు తెలుసని అర్థం.

445
00:34:18,980 --> 00:34:23,300
నేను 0 కాబట్టి, తదుపరి దశలో మిగిలిన వద్ద ముగిసింది వెళ్ళడం లేదు.

446
00:34:23,300 --> 00:34:26,239
ఎల్స్ ఇది వద్ద ఆపడానికి జరగబోతోంది ఒక లైన్ కాదు.

447
00:34:26,239 --> 00:34:31,570
ఇది కేవలం నిజానికి ఇది (i) పరిశుభ్రంగా ఉంది, అమలు చెయ్యవచ్చు తదుపరి లైన్ వెళ్ళడానికి జరగబోతోంది.

448
00:34:31,570 --> 00:34:36,090
పరిశుభ్రంగా (i) లోకి అడుగు పెట్టటం, మేము చూడండి (i == 1) ఉంటే.

449
00:34:36,090 --> 00:34:42,670
దీనితో మేము అడుగు, మాకు oh_no వదులుకోవడానికి వెళుతున్న తెలుసు, నేను = 1 తెలుసు

450
00:34:42,670 --> 00:34:46,489
i = 1 మీరు అడుగు ఇది ఫంక్షన్ oh_no, కాల్స్ ఎందుకంటే

451
00:34:46,489 --> 00:34:52,969
సెట్ అన్నారు ఇది చార్ ** s = శూన్య వెంటనే "బూమ్" కు.

452
00:34:54,270 --> 00:34:59,690
మరియు తర్వాత వాస్తవానికి, buggy2 అమలు చూడటం

453
00:34:59,690 --> 00:35:04,590
0, 1, లేదా 2 - - కాలింగ్ binky, ఈ, నేను యాదృచ్ఛిక సంఖ్య పెరిగిపోతుంది

454
00:35:04,590 --> 00:35:10,610
నేను 0 ఉంటే అది oh_no పిలిచే, లేకపోతే అది పరిశుభ్రంగా కాల్స్, ఇది ఇక్కడ వస్తుంది.

455
00:35:10,610 --> 00:35:18,100
నేను, కాల్ oh_no 1 ఉంటే, వేరే ఇక్కడ వస్తున్న ఇది slinky కాల్

456
00:35:18,100 --> 00:35:20,460
నేను 2 ఉంటే, oh_no కాల్.

457
00:35:20,460 --> 00:35:24,720
నేను కూడా ఒక మార్గం ఉంది భావించడం లేదు -

458
00:35:24,720 --> 00:35:30,030
ఎవరైనా ఈ segfault లేదు ప్రోగ్రామ్ మేకింగ్ ఒక మార్గం చూడండి లేదు?

459
00:35:30,030 --> 00:35:37,530
నేను ఏదో మిస్ నేను తప్ప 0 ఉంటే, మీరు వెంటనే segfault చేస్తాము కాబట్టి,

460
00:35:37,530 --> 00:35:41,250
ఇంకా మీరు, నేను మీరు segfault 1 ఉంటే ఒక ఫంక్షన్ కు వెళ్ళండి

461
00:35:41,250 --> 00:35:44,540
ఇంకా మీరు నేను ఉంటే 2 మీరు segfault పేరు ఒక ఫంక్షన్ కు వెళ్ళండి.

462
00:35:44,540 --> 00:35:46,810
ఏ మీరు ఏమి చేసినా కాబట్టి, మీరు segfault.

463
00:35:46,810 --> 00:35:52,380
>> నేను, అది బదులుగా చార్ ** s = NULL చేయడం ఉంటుందని ఫిక్సింగ్ యొక్క ఒక మార్గం అంచనా

464
00:35:52,380 --> 00:35:55,610
మీరు ఆ స్ట్రింగ్ స్థలాన్ని malloc కాలేదు.

465
00:35:55,610 --> 00:36:04,230
Sizeof ఏ - మేము malloc (sizeof) చేయగల?

466
00:36:09,910 --> 00:36:15,190
[విద్యార్థి] (చార్) * 5? >> ఈ కుడి అనిపించడం లేదు?

467
00:36:15,190 --> 00:36:21,060
నేను నిజానికి ఇది నడిచింది, ఇది పనిచేస్తుంది ఊహించి నేను, కానీ నేను చూస్తున్నాను ఏమి కాదు.

468
00:36:24,400 --> 00:36:32,940
S రకం వద్ద చూడండి. యొక్క Int * జోడించడానికి అనుమతిస్తుంది, అందువలన Int * x.

469
00:36:32,940 --> 00:36:35,600
నేను (sizeof (Int)) malloc చేయరు.

470
00:36:35,600 --> 00:36:40,490
లేదా నేను 5 యొక్క వ్యూహం కోరుకుంటే, I (sizeof (Int) * 5) అని;

471
00:36:40,490 --> 00:36:44,210
నేను ఒక పూర్ణాంకానికి ** ఉంటే?

472
00:36:46,260 --> 00:36:49,140
నేను malloc ఏమైంది?

473
00:36:49,140 --> 00:36:53,510
పాయింటర్ యొక్క [విద్యార్థి] సైజు. >> అవును. (Sizeof (Int *));

474
00:36:53,510 --> 00:36:56,960
డౌన్ ఇక్కడ ఇదే.

475
00:36:56,960 --> 00:37:01,280
నేను (sizeof (చార్ *)) కావలసిన;

476
00:37:06,170 --> 00:37:12,840
ఈ "బూమ్" పాయింతు ఆ పాయింటర్ స్థలాన్ని కేటాయించాలని అన్నారు.

477
00:37:12,840 --> 00:37:15,330
నేను "బూమ్" దాని కొరకు ఖాళీ కేటాయించాల్సిన అవసరం లేదు

478
00:37:15,330 --> 00:37:17,210
ఈ నేను ముందు మాట్లాడుతూ ప్రాథమికంగా సమానమైన ఎందుకంటే

479
00:37:17,210 --> 00:37:20,870
చార్ యొక్క * x = "బూమ్".

480
00:37:20,870 --> 00:37:27,950
"బూమ్" ఇప్పటికే ఉనికిలో ఉంది. ఇది మెమరీ యొక్క చదవడానికి మాత్రమే ఈ ప్రాంతంలో ఉన్నాయి నిర్మాణము.

481
00:37:27,950 --> 00:37:35,200
S ఒక చార్ ** ఉంటే కానీ ఇప్పటికే, కోడ్ యొక్క ఈ లైన్ అంటే, ఉంది

482
00:37:35,200 --> 00:37:43,900
అప్పుడు * s ఒక చార్ * మరియు మీరు "బూమ్" సూచించడానికి ఈ చార్ * సెట్ చేస్తున్నాము.

483
00:37:43,900 --> 00:37:50,040
నేను s లోకి "బూమ్" కాపీ అనుకుంటే, అప్పుడు నేను s స్థలాన్ని కేటాయించే అవసరం.

484
00:37:55,170 --> 00:38:03,900
నేను చేస్తాను * s = malloc (sizeof (చార్) * 5);

485
00:38:03,900 --> 00:38:06,210
ఎందుకు 5?

486
00:38:06,210 --> 00:38:10,860
ఎందుకు లేదు 4? "బూమ్" 4 అక్షరాలు ఉన్నట్లు తెలుస్తుంది. >> [విద్యార్థి] శూన్య పాత్ర.

487
00:38:10,860 --> 00:38:14,580
అవును. మీ తీగల యొక్క అన్ని శూన్య పాత్ర అవసరం వెళ్తున్నారు.

488
00:38:14,580 --> 00:38:23,590
ఇప్పుడు నేను strcat వంటి ఏదో ఒకటి చెయ్యాలి - స్ట్రింగ్ కాపీ కోసం కర్తవ్యం ఏమిటి?

489
00:38:23,590 --> 00:38:28,520
[విద్యార్థి] cpy? >> Strcpy.

490
00:38:28,520 --> 00:38:32,700
మనిషి strcpy.

491
00:38:36,120 --> 00:38:39,590
కాబట్టి strcpy లేదా strncpy.

492
00:38:39,590 --> 00:38:43,410
మీరు పేర్కొనవచ్చు నుండి strncpy ఒక బిట్ సురక్షితమైన ఎలా అనేక అక్షరాలు,

493
00:38:43,410 --> 00:38:46,190
మేము తెలిసిన కారణంగా ఇక్కడ అది పెద్ద విషయం కాదు.

494
00:38:46,190 --> 00:38:50,340
కాబట్టి strcpy మరియు వాదనలు చూడండి.

495
00:38:50,340 --> 00:38:53,100
మొదటి వాదన మా గమ్యం.

496
00:38:53,100 --> 00:38:56,770
రెండవ వాదన మా ఆధారం.

497
00:38:56,770 --> 00:39:10,310
మేము మా గమ్యం * లోకి కాపీ చూడాలని పాయింటర్ "బూమ్" s.

498
00:39:10,310 --> 00:39:19,820
ఎందుకు మీరు ముందు బదులుగా మేము కలిగి ఇప్పుడే ఏమి ఒక strcpy తో దీన్ని చేయాలనుకుంటున్నారా ఉండవచ్చు

499
00:39:19,820 --> 00:39:22,800
* s యొక్క = "బూమ్"?

500
00:39:22,800 --> 00:39:28,630
అక్కడ మీరు దీన్ని చేయాలనుకుంటున్నారా ఉండవచ్చు ఒక కారణం, కానీ ఆ కారణం ఏమిటి?

501
00:39:28,630 --> 00:39:31,940
[విద్యార్థి] మీరు "బూమ్" కొంత మార్పు చేయండి. >> అవును.

502
00:39:31,940 --> 00:39:37,950
ఇప్పుడు నేను s వంటి ఏదో ఒకటి చెయ్యాలి [0] = 'X';

503
00:39:37,950 --> 00:39:48,190
s పాయింట్లు కుప్ప మీద నిండుగా మరియు space కి s కు సూచిస్తుంది ఎందుకంటే

504
00:39:48,190 --> 00:39:52,320
"బూమ్" నిల్వ ఉన్న కుప్ప, మరింత స్థలం ఒక పాయింటర్ ఉంది.

505
00:39:52,320 --> 00:39:55,150
కాబట్టి "బూమ్" ఈ కాపీని కుప్ప నిల్వ ఉంది.

506
00:39:55,150 --> 00:39:58,780
మా కార్యక్రమంలో "బూమ్" యొక్క రెండు కాపీలు సాంకేతికంగా ఉన్నాయి.

507
00:39:58,780 --> 00:40:03,500
ఈ "బూమ్" స్ట్రింగ్ స్థిరంగా ఇచ్చిన చేసే మొదటి ఒకటి, ఉంది

508
00:40:03,500 --> 00:40:09,250
మరియు "బూమ్" యొక్క రెండవ కాపీ, strcpy "బూమ్" యొక్క కాపీని సృష్టించింది.

509
00:40:09,250 --> 00:40:13,100
కానీ "బూమ్" యొక్క కాపీని కుప్ప నిల్వ, మరియు కుప్ప మీరు మార్చడానికి ఉచిత ఉన్నారు ఉంది.

510
00:40:13,100 --> 00:40:17,250
కుప్ప చదవడానికి మాత్రమే కాదు, కాబట్టి అని s [0]

511
00:40:17,250 --> 00:40:20,500
మీరు "బూమ్" యొక్క విలువను మార్చడానికి అనుమతిస్తుంది అన్నారు.

512
00:40:20,500 --> 00:40:23,130
ఇది ఆ అక్షరాలు మార్చుకోవడానికి అనుమతించే జరగబోతోంది.

513
00:40:23,130 --> 00:40:26,640
>> ప్రశ్నలు?

514
00:40:27,740 --> 00:40:29,290
సరే.

515
00:40:29,290 --> 00:40:35,500
>> , Buggy3 కు లెట్స్ GDB buggy3 వెళ్లడానికి.

516
00:40:35,500 --> 00:40:39,840
మేము దానిని అమలు మరియు మేము ఒక segfault పొందండి చూడండి.

517
00:40:39,840 --> 00:40:46,550
మేము వెనుకకు ఉంటే, కేవలం రెండు విధులు ఉన్నాయి.

518
00:40:46,550 --> 00:40:52,970
మేము మా ప్రధాన విధి విభజించవచ్చు వెళ్ళి ఉంటే, మేము ఈ లైన్ వద్ద segfaulted ఆ చూడండి.

519
00:40:52,970 --> 00:41:00,180
కాబట్టి కేవలం (కోసం, ఈ లైన్ చూడటం Int లైన్ = 0; fgets ఈ విషయాన్ని సమానం కాదు NULL చేస్తుంది;

520
00:41:00,180 --> 00:41:03,770
లైన్ + +).

521
00:41:03,770 --> 00:41:08,010
మా గత ఫ్రేమ్ _IO_fgets అని పిలిచేవారు.

522
00:41:08,010 --> 00:41:10,720
ఆ అంతర్నిర్మిత సి విధులు చాలా, చూస్తారు

523
00:41:10,720 --> 00:41:15,350
మీరు segfault వచ్చిన, నిజంగా గుప్తమైన ఫంక్షన్ పేర్లు ఉంటుందని

524
00:41:15,350 --> 00:41:18,090
ఈ _IO_fgets ఇష్టపడుతున్నారు.

525
00:41:18,090 --> 00:41:21,770
కానీ ఈ fgets కాల్ సంబంధం జరగబోతోంది.

526
00:41:21,770 --> 00:41:25,850
ఎక్కడో ఇక్కడ లోపల, మేము segfaulting ఉంటాయి.

527
00:41:25,850 --> 00:41:30,340
మేము fgets వాదనలు చేయడానికి విషయంలో చూస్తే, మేము బఫర్ ముద్రించవచ్చు.

528
00:41:30,340 --> 00:41:41,180
యొక్క ప్రింట్ లెట్ ఒక - అరెరె.

529
00:41:48,980 --> 00:41:51,900
ప్రింట్ నేను అది మీరు వెళ్లాలని లేదు.

530
00:41:55,460 --> 00:41:58,000
యొక్క నిజమైన కార్యక్రమం చూద్దాం.

531
00:42:02,200 --> 00:42:09,640
బఫర్ ఒక పాత్ర శ్రేణి. ఇది 128 అక్షరాలు ఒక పాత్ర శ్రేణి ఉంది.

532
00:42:09,640 --> 00:42:14,980
నేను ప్రింట్ బఫర్ సే, అది, ఆ 128 అక్షరాలు ముద్రించడానికి జరగబోతోంది

533
00:42:14,980 --> 00:42:18,300
ఇది నేను ఊహిస్తున్నాను అంచనా ఏమిటి.

534
00:42:18,300 --> 00:42:21,390
నేను వెతుకుతున్న, బఫర్ యొక్క చిరునామా ప్రింట్ ఉంది

535
00:42:21,390 --> 00:42:23,680
కానీ ఆ నన్ను చాలా చెప్పడు.

536
00:42:23,680 --> 00:42:30,770
నేను ఇక్కడ x బఫర్ అప్ చెప్పడానికి జరిగే సమయంలో ఇది నన్ను 0xbffff090 చూపిస్తుంది

537
00:42:30,770 --> 00:42:38,690
మీరు ముందు లేదా కొన్ని పాయింట్ నుండి గుర్తుంచుకుంటే, Oxbffff ఒక స్టాక్-ish ప్రాంతం ఉంటుంది, ఇది.

538
00:42:38,690 --> 00:42:46,020
స్టాక్ కేవలం 0xc000 కింద ఎక్కడో మొదలు ఉంటుంది.

539
00:42:46,020 --> 00:42:51,890
ఈ చిరునామా చూడటం ద్వారా, నేను బఫర్ స్టాక్ లో సంభవించే మనకు తెలుసు.

540
00:42:51,890 --> 00:43:04,500
స్వీకరించేందుకు, అప్, అమలు, నా ప్రోగ్రామ్ పునఃప్రారంభం మేము ఉండేది అక్షరాలు ఈ క్రమంలో చూసిన

541
00:43:04,500 --> 00:43:06,530
ఇది చాలా అర్థరహితమని.

542
00:43:06,530 --> 00:43:12,270
అప్పుడు ఫైలు ప్రింటింగ్, ఏ ఫైలు ఎలా చేస్తుంది?

543
00:43:15,120 --> 00:43:17,310
[విద్యార్థి] నల్. >> అవును.

544
00:43:17,310 --> 00:43:22,610
, ఫైలు రకమైన ఫైల్ * యొక్క ఒక ఉంటుంది, అందువలన ఇది పాయింటర్ గా

545
00:43:22,610 --> 00:43:26,610
మరియు ఆ పాయింటర్ విలువ NULL.

546
00:43:26,610 --> 00:43:33,240
కాబట్టి fgets, ఒక పరోక్ష విధంగా ఆ పాయింటర్ నుండి చదవడానికి ప్రయత్నించండి అన్నారు

547
00:43:33,240 --> 00:43:37,320
కానీ ఆ పాయింటర్ ప్రాప్యత చేయడానికి, అది dereference ఇది ఉంటుంది.

548
00:43:37,320 --> 00:43:40,550
లేదా, అది dereferences ఇది సూచించే ఏ ప్రాప్యత చేయడానికి.

549
00:43:40,550 --> 00:43:43,810
కాబట్టి దీనిని నల్ పాయింటర్ మరియు segfaults dereferencing యొక్క.

550
00:43:46,600 --> 00:43:48,730
నేను అక్కడ అది పునఃప్రారంభం ఉండవచ్చు.

551
00:43:48,730 --> 00:43:52,170
మేము మా ప్రధాన పాయింట్ వద్ద బ్రేక్ మరియు అమలు చేస్తే,

552
00:43:52,170 --> 00:43:57,320
కోడ్ యొక్క మొదటి లైన్ చార్ * ఫైల్ = "nonexistent.txt" ఉంది;

553
00:43:57,320 --> 00:44:00,870
ఈ కార్యక్రమం విఫలమైతే ఎందుకు ఒక అందమైన పెద్ద సూచనను ఇస్తుంది.

554
00:44:00,870 --> 00:44:06,080
నేను ఈ ఫైల్ను తెరవడం పేరు తదుపరి టైప్, తర్వాత లైన్ నాకు తెస్తుంది

555
00:44:06,080 --> 00:44:11,140
మరియు నేను వెంటనే ఒకసారి నేను తరువాత నొక్కండి పేరు మా లైన్, పొందడానికి, అది segfault చెప్పారు.

556
00:44:11,140 --> 00:44:16,880
ఎవరైనా మేము segfaulting ఉండవచ్చు కారణాన్ని అవుట్ త్రో అనుకుంటుంది?

557
00:44:16,880 --> 00:44:19,130
[విద్యార్థి] ఫైల్ ఉనికిలో లేదు. >> అవును.

558
00:44:19,130 --> 00:44:22,250
ఈ సూచనను భావించబడేది

559
00:44:22,250 --> 00:44:29,570
మీరు ఒక తెరుస్తోంది చేసినపుడు ఫైల్ వాస్తవానికి ఉందని అవసరమైన.

560
00:44:29,570 --> 00:44:31,510
ఇక్కడ, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
మేము చదవడానికి fopen FILENAME, మేము అప్పుడు చెప్పడానికి అవసరమైనప్పుడు

562
00:44:34,700 --> 00:44:45,870
ఉంటే (ఫైలు == NULL) మరియు printf ("ఫైల్ ఉనికిలో లేదు!" అని

563
00:44:45,870 --> 00:44:56,340
లేదా - ఇంకా బాగా - ఫైల్ పేరు); తిరిగి 1;

564
00:44:56,340 --> 00:45:00,300
కాబట్టి ఇప్పుడు మేము ఇది NULL అని తెలుసుకోవడానికి కు చెక్

565
00:45:00,300 --> 00:45:03,930
ముందు వాస్తవానికి నిరంతర మరియు ఫైల్ నుండి చదవడానికి ప్రయత్నించడంలో.

566
00:45:03,930 --> 00:45:08,800
మేము ఆ పనులు చూడడానికి అది రీమేక్ చేయవచ్చు.

567
00:45:11,020 --> 00:45:14,970
నేను ఒక కొత్త లైన్ ఉన్నాయి ఉద్దేశించబడింది.

568
00:45:21,090 --> 00:45:25,290
కాబట్టి ఇప్పుడు nonexistent.txt లేదు.

569
00:45:26,890 --> 00:45:30,040
మీరు ఎల్లప్పుడూ విషయం ఈ విధమైన కోసం తనిఖీ చేయాలి.

570
00:45:30,040 --> 00:45:33,870
మీరు ఎల్లప్పుడూ fopen NULL తిరిగి ఉంటే చూడటానికి తనిఖీ చేయాలి.

571
00:45:33,870 --> 00:45:38,170
మీరు ఎల్లప్పుడూ malloc NULL తిరిగి లేదు నిర్ధారించుకోండి ఉండాలి

572
00:45:38,170 --> 00:45:41,410
లేదంటే segfault.

573
00:45:42,200 --> 00:45:45,930
>> ఇప్పుడు buggy4.c.

574
00:45:49,190 --> 00:45:58,440
రన్నింగ్. నేను ఇన్పుట్ లేదా బహుశా అనంతం మళ్ళీ వెతికినా కోసం వేచి ఉంది ఈ ఊహించడం చేస్తున్నాను.

575
00:45:58,440 --> 00:46:01,870
అవును, ఇది అనంతమైన మళ్ళీ వెతికినా ఉంది.

576
00:46:01,870 --> 00:46:05,560
Buggy4 కాబట్టి. మేము అనంతం మళ్ళీ వెతికినా కనిపిస్తుంది.

577
00:46:05,560 --> 00:46:12,590
మేము ప్రధాన వద్ద విరిగిపోతాయి, మా ప్రోగ్రామ్ రన్.

578
00:46:12,590 --> 00:46:20,180
GDB లో, కాలం మీరు ఉపయోగించే సంక్షిప్త నిర్ద్వంద్వంగా ఉంది

579
00:46:20,180 --> 00:46:23,420
లేదా వారు మీ కోసం అందించే ప్రత్యేక నిర్వచనాలలో

580
00:46:23,420 --> 00:46:29,020
అప్పుడు మీరు బదులుగా తర్వాత అన్ని వే అవుట్ టైప్ చేయడానికి తదుపరి ఉపయోగించడానికి n ఉపయోగించవచ్చు.

581
00:46:29,020 --> 00:46:33,730
ఇప్పుడు నేను ఒకసారి నొక్కండి n చేసిన, నేను తర్వాతి కొనసాగించడాన్ని ఎంటర్ నొక్కండి

582
00:46:33,730 --> 00:46:36,640
బదులుగా హిట్ n ఎంటర్ n ఎంటర్ n నమోదు చేయండి కలిగి.

583
00:46:36,640 --> 00:46:44,630
నేను [i] 0 to శ్రేణి సెట్ చేసే లూప్ ఒకరకమైన ఉన్నాను కనిపిస్తుంది.

584
00:46:44,630 --> 00:46:50,510
నేను లూప్ ఈ యొక్క బద్దలు ఎప్పుడూ am కనిపిస్తోంది.

585
00:46:50,510 --> 00:46:54,780
నేను ప్రింట్ నేను 2 ఉంటే, అప్పుడు నేను తరువాత వెళ్తారో.

586
00:46:54,780 --> 00:46:59,250
నేను తరువాత వెళ్తారో తర్వాత, నేను 3, నేను ప్రింట్ చేస్తాము.

587
00:46:59,250 --> 00:47:05,360
నేను ప్రింట్ చేస్తాము మరియు నేను 3. తరువాత, నేను ప్రింట్ నేను 4 ఉంటుంది.

588
00:47:05,360 --> 00:47:14,520
అసలైన, ముద్రణ sizeof (శ్రేణి), కాబట్టి శ్రేణి యొక్క పరిమాణం 20.

589
00:47:16,310 --> 00:47:32,870
కొన్ని ప్రత్యేక GDB ఆదేశం ఏదో జరుగుతుంది వరకు వెళ్లి కోసం ఉన్నట్లు కానీ కనిపిస్తోంది.

590
00:47:32,870 --> 00:47:37,620
ఇది వేరియబుల్ విలువ పరిస్థితిని సెట్ వంటిది. కానీ నేను అది గుర్తు లేదు.

591
00:47:37,620 --> 00:47:44,100
- మేము కొనసాగించడాన్ని అయితే

592
00:47:44,100 --> 00:47:47,120
మీరు ఏమి అంటున్నారు చేశారు? మీరు ఏ తీసుకురావటానికి చేశారు?

593
00:47:47,120 --> 00:47:50,500
[విద్యార్థి] ప్రదర్శించు జత చేస్తుంది - >> అవును. నేను సహాయపడుతుంది ప్రదర్శిస్తాయి.

594
00:47:50,500 --> 00:47:54,530
మేము కేవలం నేను ప్రదర్శించడానికి, అది నేను విలువ ఏమిటి ఇక్కడ ప్రదర్శించాలి

595
00:47:54,530 --> 00:47:56,470
నేను ప్రతిసారీ దాన్ని ముద్రించడానికి లేదు.

596
00:47:56,470 --> 00:48:02,930
మేము తర్వాతి వెళ్ళి ఉంటే, మేము 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 చూడండి.

597
00:48:02,930 --> 00:48:08,530
ఏదో భయంకరమైన తప్పు అంటే, నేను 0 రీసెట్ చేయబడుతుంది.

598
00:48:13,330 --> 00:48:22,220
Buggy4.c వద్ద గురించి, మేము జరిగినప్పుడు అన్ని Int శ్రేణి [5] చూడండి;

599
00:48:22,220 --> 00:48:26,200
(; i <= sizeof (శ్రేణి); i + + i = 0) కోసం

600
00:48:26,200 --> 00:48:28,550
అర్రే [i] = 0;

601
00:48:28,550 --> 00:48:31,390
మేము ఇక్కడ తప్పు ఏమి చూస్తారు?

602
00:48:31,390 --> 00:48:39,480
ఒక సూచన, నేను GDB buggy4 చేస్తున్న సమయంలో - ప్రధాన, రన్ బ్రేక్ యొక్క Let -

603
00:48:39,480 --> 00:48:45,980
నేను ప్రింట్ sizeof (శ్రేణి) కేవలం చివరికి నేను బయటకు ఎక్కడ పరిస్థితి చూడటానికి లేదు.

604
00:48:47,690 --> 00:48:51,100
నేను ఎక్కడ వున్నాను? నేను అయిపోయాయా?

605
00:48:51,100 --> 00:48:54,280
నేను ఇంకా డిక్లేర్ లేదు.

606
00:48:54,280 --> 00:48:58,680
కాబట్టి, sizeof (శ్రేణి) ముద్రించడానికి మరియు 20 ల

607
00:48:58,680 --> 00:49:06,690
ఇది నా అర్రే పరిమాణం 5 యొక్క ఎందుకంటే అంచనా మరియు ఇది 5 పూర్ణాంకాల అని

608
00:49:06,690 --> 00:49:12,410
కాబట్టి మొత్తం విషయం sizeof (Int) 4 ఉంటుంది పేరు 5 * sizeof (Int) బైట్లు ఉండాలి.

609
00:49:12,410 --> 00:49:14,780
కాబట్టి sizeof (శ్రేణి) 20.

610
00:49:14,780 --> 00:49:17,420
ఈ ఉండాలి?

611
00:49:17,420 --> 00:49:21,720
[విద్యార్థి] sizeof (Int) ద్వారా విభజించబడింది. >> అవును, / sizeof (Int).

612
00:49:21,720 --> 00:49:30,630
ఒక సమస్య ఇక్కడ ఇప్పటికీ ఉన్నట్లు కనిపిస్తోంది. నేను ఈ కేవలం ఉండాలి అనుకుంటున్నాను <

613
00:49:30,630 --> 00:49:36,960
ఇది ఎల్లప్పుడూ ల నాటినుండి <మరియు ఎప్పుడూ <=.

614
00:49:36,960 --> 00:49:44,860
ఇప్పుడు ఈ వాస్తవానికి ఉల్లంఘించబడింది ఎందుకు భావిస్తున్నాను తెలియజేయండి.

615
00:49:44,860 --> 00:49:53,370
ఎవరైనా నేను లూప్ యొక్క ప్రతి పునరావృతం ద్వారా 0 to అంచనాలు రీసెట్ జరిగినది ఉంటాయా?

616
00:50:01,300 --> 00:50:09,350
ఇక్కడ జరుగుతున్నది ఆ లోపలి మాత్రమే విషయం [i] 0 సెట్ చేయబడుతుంది శ్రేణి.

617
00:50:09,350 --> 00:50:15,350
కాబట్టి ఏదో, కోడ్ యొక్క ఈ లైన్ నేను 0 కు సెట్ మా Int చేస్తుంది.

618
00:50:16,730 --> 00:50:23,130
నేను ఈ భాగాన్ని మెమరీ భర్తీ ఎందుకంటే [విద్యార్థి] ఎంత

619
00:50:23,130 --> 00:50:27,970
అది యెరే యొక్క తదుపరి ఎలిమెంట్? ఆలోచించినప్పుడు >> [బౌడెన్] అవును.

620
00:50:27,970 --> 00:50:33,880
మేము మా శ్రేణి ముగింపు దాటుకొని చేసిన తర్వాత,

621
00:50:33,880 --> 00:50:39,870
మేము భర్తీ చేస్తున్న ఎలానో ఆ స్థలం నేను విలువ భర్తీ చేయబడుతుంది.

622
00:50:39,870 --> 00:50:48,030
మేము buggy4 పరిశీలిస్తాము ఉంటే కనుక, ప్రధాన, రన్ బ్రేక్

623
00:50:48,030 --> 00:50:53,120
యొక్క నేను యొక్క చిరునామా ప్రింట్ తెలియజేయండి.

624
00:50:53,120 --> 00:50:57,280
అది bffff124 యొక్క కనిపిస్తుంది.

625
00:50:57,280 --> 00:51:03,930
ఇప్పుడు యొక్క శ్రేణి యొక్క చిరునామా ప్రింట్ వీలు [0]. 110.

626
00:51:03,930 --> 00:51:06,290
ఏమి [1] గురించి? 114.

627
00:51:06,290 --> 00:51:07,920
[2], 118.

628
00:51:07,920 --> 00:51:14,530
11C సంఖ్య కలవి, 120. అర్రే [5] bfff124 ఉంది.

629
00:51:14,530 --> 00:51:26,990
అర్రే కాబట్టి [5] నేను, ఆ శ్రేణి [5] ఐ అంటే అదే చిరునామాను కలిగి ఉంటుంది.

630
00:51:26,990 --> 00:51:30,720
వారు అదే చిరునామా ఉంటే, వారు ఇదే ఉంటాయి.

631
00:51:30,720 --> 00:51:38,410
కాబట్టి మేము శ్రేణి [5] పెట్టినప్పుడు 0, మేము 0 నేను సెట్ చేస్తారు.

632
00:51:38,410 --> 00:51:46,070
మరియు మీరు స్టాక్ పరంగా ఈ గురించి అనుకుంటే,

633
00:51:46,070 --> 00:51:55,590
Int నేను స్టాక్ కొన్ని అంతరిక్ష అవుతుందని అర్ధం, ఇది మొదటి ప్రకటిస్తారు.

634
00:51:55,590 --> 00:52:04,730
అప్పుడు శ్రేణి [5] అందువలన 20 బైట్లు స్టాక్ న కేటాయించబడతాయి, కేటాయించబడుతుంది.

635
00:52:04,730 --> 00:52:08,400
నేను అప్పుడు ఈ 20 బైట్లు కేటాయించింది get, మొదటి కేటాయించింది తీర్చుకుంటాడు.

636
00:52:08,400 --> 00:52:11,400
నేను, కుడి అమరిక ముందు జరుగుతుంది

637
00:52:11,400 --> 00:52:19,230
మరియు పద్ధతి కారణంగా, నేను, సాంకేతికంగా స్టాక్ డౌన్ పెరుగుతుంది, గత వారం చెప్పారు

638
00:52:19,230 --> 00:52:28,520
వ్యూహం లోకి మీరు ఇండెక్స్, మేము హామీ పరిధిలో 0th స్థానం

639
00:52:28,520 --> 00:52:31,970
ఎల్లప్పుడూ యెరే నందలి మొదటి స్థానం ముందు జరుగుతుంది.

640
00:52:31,970 --> 00:52:35,900
ఈ నేను గత వారం ఇది ఆకర్షించింది ఎలా రకం.

641
00:52:35,900 --> 00:52:42,210
దిగువన మేము చిరునామా 0 కలిగి మరియు ఎగువన మేము చిరునామా మాక్స్ మేము గుర్తించాము.

642
00:52:42,210 --> 00:52:44,880
స్టాక్ ఎల్లప్పుడూ డౌన్ పెరుగుతోంది.

643
00:52:48,100 --> 00:52:53,500
లెట్ యొక్క మేము నేను కేటాయించాలని చెప్పారు.

644
00:52:53,500 --> 00:52:59,680
మేము పూర్ణాంక కేటాయించాలని నేను, లెట్స్ కేవలం ఇక్కడ పూర్ణాంకం నేను కేటాయించింది అవుతుంది అప్ సే అంటే.

645
00:52:59,680 --> 00:53:06,420
అప్పుడు ఆ కింద అంటే 5 పూర్ణాంకాల మా అర్రే,, కేటాయించాలని

646
00:53:06,420 --> 00:53:11,230
స్టాక్ డౌన్ పెరుగుతోంది నుండి, ఆ 5 పూర్ణాంకాల కేటాయించింది కలుగుతుంది.

647
00:53:11,230 --> 00:53:15,900
కానీ శ్రేణుల పని ఎలా ఎందుకంటే, మేము హామీ చేస్తున్న యెరే నందలి మొదటి స్థానం

648
00:53:15,900 --> 00:53:22,260
ఎల్లప్పుడూ శ్రేణి రెండవ విషయం కంటే తక్కువ ఒక చిరునామాను కలిగి ఉంటుంది.

649
00:53:22,260 --> 00:53:28,270
కాబట్టి శ్రేణి స్థానం 0 ఎప్పుడూ మెమరీలో మొదటి జరిగే ఉంది

650
00:53:28,270 --> 00:53:30,700
అర్రే స్థానం 1 ఆ తర్వాత జరిగే ఉంది అయితే

651
00:53:30,700 --> 00:53:33,310
యెరే స్థానం 2, ఆ తర్వాత జరిగే ఉంది

652
00:53:33,310 --> 00:53:37,900
ఇది ఆ శ్రేణి స్థానం 0, డౌన్ ఇక్కడ ఎక్కడో జరుగుతుంది అంటే

653
00:53:37,900 --> 00:53:40,690
అర్రే స్థానం 1 ఆ పైన జరుగుతుంది

654
00:53:40,690 --> 00:53:45,530
పైకి కదలడం గరిష్ట చిరునామా ఇక్కడ నుంచి అధిక చిరునామాలను అర్థం. ఎందుకంటే

655
00:53:45,530 --> 00:53:50,490
డౌన్ ఇక్కడ శ్రేణి [0] కాబట్టి, అర్రే [1] ఇక్కడ, అర్రే [2] ఇక్కడ, అర్రే [3] వరకు ఇక్కడ.

656
00:53:50,490 --> 00:53:55,620
మేము ఇక్కడ నేను అన్ని మార్గం అప్, పూర్ణాంక కేటాయించింది ఎలా ముందు గమనించండి

657
00:53:55,620 --> 00:54:01,040
మేము మా శ్రేణి మరింత మరియు మరింత ప్రయాణంలో, మేము దగ్గరగా మరియు దగ్గరగా మా పూర్ణాంక నేను అందుకుంటున్నారు.

658
00:54:01,040 --> 00:54:07,640
ఇది కేవలం కాబట్టి, ఇది మా శ్రేణి మించి ఒక స్థానం, ఆ శ్రేణి [5] జరిగినప్పుడు

659
00:54:07,640 --> 00:54:13,010
నేను కేటాయించింది సంభవించింది పేరు పూర్ణ సంఖ్య.

660
00:54:13,010 --> 00:54:16,920
కాబట్టి మేము స్టాక్ న స్పేస్ కొట్టడం కావడం పేరు పాయింట్

661
00:54:16,920 --> 00:54:21,680
ఆ పూర్ణాంక నేను కోసం కేటాయించారు, మరియు మేము ఆ 0 to సెట్ చేస్తున్నాము.

662
00:54:21,680 --> 00:54:26,160
>> ఆ పని ఎలా. ప్రశ్నలు? అవును.

663
00:54:26,160 --> 00:54:30,710
[విద్యార్థి] ఫరవాలేదు. సరే.

664
00:54:30,710 --> 00:54:33,090
[విద్యార్థి] ఎలా మీరు లోపాలు ఈ రకమైన తప్పించాలి?

665
00:54:33,090 --> 00:54:41,190
లోపాలు ఈ రకమైన? మీ ప్రోగ్రామింగ్ భాష వంటి C ఉపయోగించకండి.

666
00:54:41,190 --> 00:54:45,840
తనిఖీ శ్రేణి హద్దులు లేని ఒక భాష ఉపయోగించండి.

667
00:54:45,840 --> 00:54:55,900
కాలం మీరు జాగ్రత్తగా చేస్తున్నపుడు, మీరు మీ శ్రేణి యొక్క సరిహద్దులు గత వెళ్లి దూరంగా ఉండాలి.

668
00:54:55,900 --> 00:54:58,300
[విద్యార్థి] ఇక్కడ మేము మీ శ్రేణి యొక్క సరిహద్దులు గత వెళ్లిన -

669
00:54:58,300 --> 00:55:01,840
[బౌడెన్] విషయాలను తప్పు వెళ్ళి మొదలు పేర్కొంది. >> [విద్యార్థి] ఓహ్, ఓకే.

670
00:55:01,840 --> 00:55:05,730
కాలం మీరు మీ శ్రేణి కోసం కేటాయించిన మెమొరీ లో ఉండడానికి, మీరు జరిమానా ఉన్నారు.

671
00:55:05,730 --> 00:55:12,400
కానీ సి ఏ దోష పరిశీలన చేస్తుంది. నేను శ్రేణి చేస్తే [1000], ఇది కేవలం సంతోషముగా ఏది సవరించడానికి కనిపిస్తుంది -

672
00:55:12,400 --> 00:55:16,500
ఇది అర్రే ప్రారంభంలో వెళుతుంది, అప్పుడు అది తర్వాత 1000 స్థానాలు వెళుతుంది మరియు 0 కు అమర్చుతుంది.

673
00:55:16,500 --> 00:55:20,000
ఇది OH ఇది నిజానికి అది 1000 విషయాలు లేదు ఏ తనిఖీని విధంగా లేదు.

674
00:55:20,000 --> 00:55:22,750
1000, వే ఐ మార్పులు ఏ మించిన

675
00:55:22,750 --> 00:55:26,940
జావా లేదా ఏదో మీరు హద్దులు ఇండెక్స్ యొక్క శ్రేణి అవుట్ పొందుతారు అయితే

676
00:55:26,940 --> 00:55:29,820
లేదా హద్దులు మినహాయింపు యొక్క సూచిక.

677
00:55:29,820 --> 00:55:33,950
ఉన్నత స్థాయి భాషల చాలా విషయాలు ఈ ఎందుకు ఆ

678
00:55:33,950 --> 00:55:37,340
మీరు శ్రేణి యొక్క సరిహద్దులు దాటి వెళ్ళండి ఉంటే, అక్కడ మీరు విఫలం

679
00:55:37,340 --> 00:55:40,070
మీరు క్రింద నుండి అంశాలను మార్చలేరు కాబట్టి

680
00:55:40,070 --> 00:55:42,590
మరియు తర్వాత విషయాలు కేవలం ఒక మినహాయింపు పొందడానికి కంటే చెత్తగా వెళ్ళి

681
00:55:42,590 --> 00:55:44,940
మీరు శ్రేణి ముగింపు మించి జరిగింది చెప్పాడు.

682
00:55:44,940 --> 00:55:50,970
[విద్యార్థి] అందువలన మేము మార్చబడింది ఉండాలి <= కేవలం <? >> [బౌడెన్] అవును.

683
00:55:50,970 --> 00:55:54,800
ఇది <sizeof (శ్రేణి) / sizeof (Int) ఉండాలి;

684
00:55:54,800 --> 00:55:59,560
sizeof (శ్రేణి) 20, కానీ మేము కేవలం 5 కావలసిన నుండి. >> [విద్యార్థి] రైట్.

685
00:55:59,560 --> 00:56:04,060
మరిన్ని ప్రశ్నలు? సరే.

686
00:56:04,060 --> 00:56:07,380
>> [విద్యార్థి] నేను ఒక ప్రశ్న కలిగి ఉంటాయి. >> అవును.

687
00:56:07,380 --> 00:56:16,440
[విద్యార్థి] వాస్తవ శ్రేణి వేరియబుల్ ఏమిటి?

688
00:56:16,440 --> 00:56:20,000
[బౌడెన్] ఇలా శ్రేణి ఏమిటి?

689
00:56:20,000 --> 00:56:24,930
అర్రే కూడా గుర్తు.

690
00:56:24,930 --> 00:56:31,490
ఇది కేవలం మేము సూచిస్తూ ఉంటాయి 20 బైట్లు ప్రారంభంలో యొక్క చిరునామా.

691
00:56:31,490 --> 00:56:38,070
మీరు ఒక పాయింటర్ గా భావిస్తారు, కానీ అది స్థిరమైన పాయింటర్ ఉంది.

692
00:56:38,070 --> 00:56:44,140
వెంటనే విషయాలు సంకలనం కొద్ది వేరియబుల్ శ్రేణి ఇకపై ఉనికిలో లేదు.

693
00:56:44,140 --> 00:56:48,210
[విద్యార్థి] కాబట్టి ఎలా శ్రేణి యొక్క పరిమాణం కనుగొనేందుకు లేదు?

694
00:56:48,210 --> 00:56:54,130
అర్రే పరిమాణం ఆ గుర్తు సూచిస్తుంది ఆ బ్లాక్ యొక్క పరిమాణం సూచిస్తుంది.

695
00:56:54,130 --> 00:57:01,240
నేను printf లాగ ("% p \ n", అర్రే) చేసినప్పుడు;

696
00:57:01,240 --> 00:57:05,140
యొక్క అమలు అనుమతిస్తాయి.

697
00:57:12,960 --> 00:57:15,530
నేను ఏం తప్పు చేసావ్?

698
00:57:15,530 --> 00:57:19,220
అర్రే 'శ్రేణి' ఇక్కడ ప్రకటించింది.

699
00:57:20,820 --> 00:57:23,200
ఓహ్, ఇక్కడ.

700
00:57:23,200 --> 00:57:31,250
గణగణమని ద్వని చేయు తెలివైన, మరియు ఇది నేను 5 అంశాలు వంటి శ్రేణి ప్రకటించింది అని గుర్తించలేకపోతే జరుగుతుంది

701
00:57:31,250 --> 00:57:34,540
కానీ నేను స్థానం 1000 లో సూచి నేను.

702
00:57:34,540 --> 00:57:38,450
ఈ కేవలం స్థిరాంకాలు ఉంటాయి ఎందుకంటే ఇది ఆ చేయవచ్చు.

703
00:57:38,450 --> 00:57:43,370
ఇది మాత్రమే నేను శ్రేణి యొక్క సరిహద్దులు దాటి వెళుతున్న ఆ గమనిస్తున్నారు ఇప్పటివరకు వెళ్ళవచ్చు.

704
00:57:43,370 --> 00:57:46,880
కానీ, మేము నేను సరైనది ఉన్నప్పుడు ముందు గమనించి

705
00:57:46,880 --> 00:57:51,040
అది, నేను పడుతుంది ఎన్ని విలువలు కనుగొనలేదు

706
00:57:51,040 --> 00:57:55,540
కాబట్టి నేను శ్రేణి ముగింపు దాటుకొని ఆ కనుగొనలేదు.

707
00:57:55,540 --> 00:57:59,430
అది తెలివైన ఉండటం గణగణమని ద్వని చేయు ఉంది.

708
00:57:59,430 --> 00:58:03,340
>> కానీ ఇప్పుడు buggy4 చేయండి. నేను తప్పు ఏమి చేస్తున్న?

709
00:58:03,340 --> 00:58:05,970
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ 'printf' ప్రకటించారు.

710
00:58:05,970 --> 00:58:14,960
నేను # <stdio.h> చేర్చాలనుకుంటే వెళుతున్న.

711
00:58:14,960 --> 00:58:18,710
సరే. ఇప్పుడు buggy4 అమలు.

712
00:58:18,710 --> 00:58:24,840
వంటి శ్రేణి యొక్క విలువ ముద్రణ నేను పాయింటర్ గా ప్రింటింగ్, ఇక్కడ చేసింది

713
00:58:24,840 --> 00:58:30,060
ఈ కనిపించే ప్రింట్లు ఏదో - bfb8805c - కొన్ని చిరునామా ఇది

714
00:58:30,060 --> 00:58:33,450
ఆ స్టాక్-ish ప్రాంతంలో ఉంది.

715
00:58:33,450 --> 00:58:41,820
, అర్రే కూడా ఒక పాయింటర్ వలె ఉంటుంది, కాని అది అసలైన పాయింటర్ కాదు

716
00:58:41,820 --> 00:58:45,410
ఒక సాధారణ పాయింటర్ నుండి మేము మార్చవచ్చు.

717
00:58:45,410 --> 00:58:54,700
అర్రే కొన్ని స్థిరాంకం. మెమరీ యొక్క 20 బ్లాక్లను చిరునామా 0xbfb8805c వద్ద ప్రారంభించండి.

718
00:58:54,700 --> 00:59:09,020
ఈ చిరునామా ద్వారా కాబట్టి bfb8805c +20- లేదా నేను -20 అంచనా -

719
00:59:09,020 --> 00:59:17,400
ఈ శ్రేణి కోసం కేటాయించిన మెమొరీ యొక్క అన్ని ఉంటుంది.

720
00:59:17,400 --> 00:59:20,350
అర్రే, వేరియబుల్ కూడా ఎక్కడైనా నిల్వ చెయ్యబడదు.

721
00:59:20,350 --> 00:59:27,660
మీరు కంపైల్ చేసినప్పుడు, కంపైలర్ - ఇది వద్ద చేతి అల -

722
00:59:27,660 --> 00:59:33,060
అది యెరే అని తెలుసు కానీ పేరు కంపైలర్ కేవలం ఉపయోగిస్తారు.

723
00:59:33,060 --> 00:59:36,090
ఆ శ్రేణి ప్రారంభిస్తారు ఇది తెలుసు

724
00:59:36,090 --> 00:59:40,910
మరియు కనుక ఇది ఎల్లప్పుడూ ఆ ప్రారంభం నుండి ఆఫ్సెట్లు పరంగా చేయవచ్చు.

725
00:59:40,910 --> 00:59:43,960
ఇది అర్రే ప్రాతినిధ్యం ఒక వేరియబుల్ కూడా అవసరం లేదు.

726
00:59:43,960 --> 00:59:53,730
కానీ నేను Int * p = శ్రేణి వంటి ఏదో చేసినప్పుడు; ఇప్పుడు p, ఆ శ్రేణి చూపాడు ఒక పాయింటర్ గా

727
00:59:53,730 --> 00:59:57,830
మరియు ఇప్పుడు p నిజానికి స్టాక్ మీద ఉందా.

728
00:59:57,830 --> 01:00:01,950
నేను p మార్చడానికి ఉచిత ఉన్నాను. నేను p = malloc చేయవచ్చు.

729
01:00:01,950 --> 01:00:06,500
కాబట్టి ఇది శ్రేణి సూచించాడు; ఇప్పుడు కుప్ప మీద కొన్ని అంతరిక్ష సూచిస్తుంది.

730
01:00:06,500 --> 01:00:09,620
నేను శ్రేణి = malloc చెయ్యలేరు.

731
01:00:09,620 --> 01:00:13,710
గణగణమని ద్వని చేయు తెలివైన ఉంటే, అది కుడి బ్యాట్ ఆఫ్ నాకు అరుస్తుంటారు కనిపిస్తుంది.

732
01:00:17,000 --> 01:00:21,430
అసలైన, నేను gcc చాలా ఈ చేయరు అందంగా ఖచ్చితంగా అనుకుంటున్నాను.

733
01:00:21,430 --> 01:00:25,010
కాబట్టి శ్రేణి రకం 'Int [5]' కేటాయించలేని కాదు.

734
01:00:25,010 --> 01:00:28,040
మీరు ఒక అర్రే రకం ఏదైనా కేటాయించి కాదు

735
01:00:28,040 --> 01:00:30,500
అర్రే ఒక స్థిరమైన ఎందుకంటే.

736
01:00:30,500 --> 01:00:34,760
ఇది సూచనలు ఆ 20 బైట్లు గుర్తు. నేను మార్చలేరు.

737
01:00:34,760 --> 01:00:37,690
>> [విద్యార్థి] యెరే యొక్క పరిమాణం పేరు నిల్వ చేయబడుతుంది?

738
01:00:37,690 --> 01:00:40,670
[బౌడెన్] ఇది ఎక్కడైనా నిల్వ లేదు. ఇది కంపైల్ ఎప్పుడు ఇది.

739
01:00:40,670 --> 01:00:46,310
కాబట్టి శ్రేణి యొక్క పరిమాణం పేరు నిల్వ చేయబడుతుంది?

740
01:00:46,310 --> 01:00:51,870
మీరు శ్రేణి కూడా ప్రకటిస్తారు ఆ ఫంక్షన్ యొక్క లోపల sizeof (శ్రేణి) ఉపయోగించవచ్చు.

741
01:00:51,870 --> 01:01:03,150
నేను కొన్ని ఫంక్షన్, foo, ఏమి మరియు నేను అలా అయితే (Int శ్రేణి [])

742
01:01:03,150 --> 01:01:10,450
printf ("% d \ n", sizeof (శ్రేణి));

743
01:01:10,450 --> 01:01:21,330
ఆపై డౌన్ ఇక్కడ నేను foo (శ్రేణి) కాల్;

744
01:01:21,330 --> 01:01:24,840
ఈ చర్యను లోపల - యొక్క అమలు అనుమతిస్తాయి.

745
01:01:34,200 --> 01:01:36,840
మళ్ళీ తెలివైన ఉండటం గణగణమని ద్వని చేయు ఉంది.

746
01:01:36,840 --> 01:01:43,890
ఇది నాకు చెప్పుచున్నారు ఆ శ్రేణి ఫంక్షన్ పారామీటర్ sizeof

747
01:01:43,890 --> 01:01:46,690
'Int *' యొక్క పరిమాణం తిరిగి కనిపిస్తుంది.

748
01:01:46,690 --> 01:01:55,150
అది ఏమి అనుకున్నవే కాదు ఈ లోపం ఉంటుంది.

749
01:01:55,150 --> 01:01:58,960
యొక్క వాస్తవానికి Werror ఆఫ్ లెట్.

750
01:02:14,950 --> 01:02:17,590
హెచ్చరిక. హెచ్చరికలు జరిమానా ఉంటాయి.

751
01:02:17,590 --> 01:02:19,960
అది ఒక హెచ్చరిక ఉంది ఇది ఇప్పటికీ కాలం కంపైల్ కనిపిస్తుంది.

752
01:02:19,960 --> 01:02:22,910
. / A.out 4 ప్రింట్ అన్నారు.

753
01:02:22,910 --> 01:02:28,650
ఉత్పత్తి చేసే హెచ్చరిక వాట్ వెంట్ రాంగ్ యొక్క స్పష్టమైన సూచనగా చెప్పవచ్చు.

754
01:02:28,650 --> 01:02:34,120
ఈ Int శ్రేణి కేవలం sizeof (Int *) ముద్రించడానికి అన్నారు.

755
01:02:34,120 --> 01:02:39,790
నేను ఇక్కడ శ్రేణి [5] ఉంచండి ఒకవేళ, ఇది కేవలం sizeof (Int *) ముద్రించడానికి జరగబోతోంది.

756
01:02:39,790 --> 01:02:47,440
కాబట్టి వెంటనే మీరు ఒక ఫంక్షన్ లో పాస్ వంటి శ్రేణుల మరియు గమనికలు మధ్య వ్యత్యాసం

757
01:02:47,440 --> 01:02:49,670
లేని ఉంది.

758
01:02:49,670 --> 01:02:52,640
ఇది స్టాక్ న ప్రకటించబడింది ఒక అర్రే నిర్మాణము

759
01:02:52,640 --> 01:02:58,300
కానీ త్వరలో ఆ విలువలను పాటిస్తూ ఆ 0xbf బ్లా, బ్లా, ఈ ఫంక్షన్ కు బ్లా,

760
01:02:58,300 --> 01:03:03,350
ఈ పాయింటర్ స్టాక్ ఆ శ్రేణి చూపాడు.

761
01:03:03,350 --> 01:03:08,310
Sizeof మాత్రమే శ్రేణి ప్రకటించబడింది ఆ ఫంక్షన్ లో వర్తిస్తుంది అంటే, అందువలన

762
01:03:08,310 --> 01:03:11,230
అంటే మీరు, ఈ ఫంక్షన్ కంపైల్ చేసినప్పుడు

763
01:03:11,230 --> 01:03:17,330
గణగణమని ద్వని చేయు ఈ చర్య ద్వారా వెళుతుంది, ఇది అర్రే పరిమాణం 5 యొక్క ఒక పూర్ణాంకానికి శ్రేణి చూస్తాడు.

764
01:03:17,330 --> 01:03:20,640
కాబట్టి అప్పుడు sizeof (శ్రేణి) చూస్తాడు. అయితే, అది 20 ల.

765
01:03:20,640 --> 01:03:26,440
ఆ sizeof ప్రధానంగా దాదాపు అన్ని సందర్భాలలో ఎలా పనిచేస్తుంది నిజానికి ఉంది.

766
01:03:26,440 --> 01:03:31,150
Sizeof ఒక క్రియ కాదు; ఇది ఒక ఆపరేటర్లు ఉంది.

767
01:03:31,150 --> 01:03:33,570
మీరు sizeof ఫంక్షన్ కాల్ లేదు.

768
01:03:33,570 --> 01:03:38,280
Sizeof (Int), కంపైలర్ ఆ 4 అనువదిస్తుంది.

769
01:03:41,480 --> 01:03:43,700
అర్థమైంది? సరే.

770
01:03:43,700 --> 01:03:47,520
>> [విద్యార్థి] కాబట్టి ప్రధాన మరియు foo లో sizeof (శ్రేణి) మధ్య తేడా ఏమిటి?

771
01:03:47,520 --> 01:03:52,840
మేము రకం Int * చెప్పవచ్చు sizeof (శ్రేణి), ఈ విధంగా చేసిన ఎందుకంటే

772
01:03:52,840 --> 01:03:57,120
అర్రే డౌన్ ఇక్కడ కాదు రకం Int * యొక్క అయితే, అది ఒక పూర్ణాంకానికి శ్రేణి ఉంది.

773
01:03:57,120 --> 01:04:04,540
>> [విద్యార్థి] కాబట్టి మీరు శ్రేణి [] బదులుగా Int * శ్రేణి లో పారామితి కలిగి ఉంటే,

774
01:04:04,540 --> 01:04:09,230
ఇప్పుడు అది ఒక పాయింటర్ ఎందుకంటే మీరు ఇప్పటికీ శ్రేణి మార్చుకునేది అర్థం?

775
01:04:09,230 --> 01:04:14,250
[బౌడెన్] ఈ నచ్చిందా? >> [విద్యార్థి] అవును. మీరు ఇప్పుడు ఫంక్షన్ లో అర్రే మార్చవచ్చు?

776
01:04:14,250 --> 01:04:18,420
[బౌడెన్] మీరు రెండు సందర్భాలలో శ్రేణి మారిపోవచ్చు.

777
01:04:18,420 --> 01:04:23,130
ఈ కేసుల్లో రెండు మీరు శ్రేణి [4] = 0 చెప్పడానికి ఉచితం.

778
01:04:23,130 --> 01:04:26,590
[విద్యార్థి] కానీ మీరు ఏదో కు శ్రేణి పాయింట్ చేయవచ్చు?

779
01:04:26,590 --> 01:04:30,230
[బౌడెన్] ఓహ్. అవును. ఏ సందర్భంలో - >> [విద్యార్థి] అవును.

780
01:04:30,230 --> 01:04:38,410
[బౌడెన్] శ్రేణి [] మరియు ఒక పూర్ణాంకానికి * శ్రేణి మధ్య వ్యత్యాసం, ఏదీ.

781
01:04:38,410 --> 01:04:42,570
మీరు ఇక్కడ కొన్ని బహుమితీయ శ్రేణి పొందవచ్చు

782
01:04:42,570 --> 01:04:47,050
కొన్ని అనుకూలమైన సింటాక్స్ కోసం, కాని ఇప్పటికీ ఒక పాయింటర్ ఉంది.

783
01:04:47,050 --> 01:04:56,400
ఈ నేను శ్రేణి చేయడానికి ఉచిత am అంటే = malloc (sizeof (Int)); మరియు ఇప్పుడు ఎక్కడైనా అభిప్రాయపడుతున్నారు.

784
01:04:56,400 --> 01:04:59,610
కానీ, ఈ ఎప్పటికీ మరియు ఎల్లప్పుడూ ఎలా పనిచేస్తుంది ఇష్టం

785
01:04:59,610 --> 01:05:03,210
అది ద్వారా ఈ శ్రేణి మారుతున్న ఏదో సూచించడానికి

786
01:05:03,210 --> 01:05:07,570
అది, వాదన యొక్క ఒక కాపీని ఎందుకంటే ఇక్కడ ఈ శ్రేణి డౌన్ మారదు

787
01:05:07,570 --> 01:05:10,780
ఆ వాదన ఒక పాయింటర్ కాదు.

788
01:05:10,780 --> 01:05:16,070
మరియు వాస్తవానికి, దీనిని అదే అని మరింత సూచన వంటి -

789
01:05:16,070 --> 01:05:21,100
మేము ఇప్పటికే ముద్రణ అమరిక ప్రింట్లు చూసిన -

790
01:05:21,100 --> 01:05:31,410
మనం శ్రేణి యొక్క చిరునామా లేదా శ్రేణి యొక్క చిరునామా చిరునామా ప్రింట్ ఉంటే

791
01:05:31,410 --> 01:05:36,290
వారిలో ను?

792
01:05:41,770 --> 01:05:45,220
యొక్క ఈ ఒక విస్మరించండి లెట్.

793
01:05:48,140 --> 01:05:51,660
సరే. ఈ ఉత్తమంగా ఉంటుంది. ఇది ఇప్పుడు. / A.out నడుస్తున్న యొక్క.

794
01:05:51,660 --> 01:06:00,220
ప్రింటింగ్ అర్రే, అప్పుడు శ్రేణి యొక్క చిరునామా ప్రింటింగ్, ఇదే ఉంటాయి.

795
01:06:00,220 --> 01:06:02,870
అర్రే కేవలం లేదు.

796
01:06:02,870 --> 01:06:08,190
మీరు శ్రేణి ప్రింటింగ్ చేసినప్పుడు, మీరు ఆ 20 బైట్లు సూచిస్తుంది గుర్తు ప్రింటింగ్ చేసిన తెలుసు.

797
01:06:08,190 --> 01:06:11,940
యెరే యొక్క చిరునామా ముద్రణ, అలాగే, అర్రే లేదు.

798
01:06:11,940 --> 01:06:17,200
ఇది ఒక చిరునామా లేదు, కాబట్టి అది కేవలం ఆ 20 బైట్లు యొక్క చిరునామా ముద్రిస్తుంది.

799
01:06:20,820 --> 01:06:28,150
వెంటనే మీకు డౌన్ కంపైల్ వంటి, మీ సంకలనం buggy4 లాగే. / A.out

800
01:06:28,150 --> 01:06:30,340
అర్రే లేని ఉంది.

801
01:06:30,340 --> 01:06:33,640
గమనికలు ఉన్నాయి. వ్యూహాలను లేదు.

802
01:06:34,300 --> 01:06:38,060
అర్రే ప్రాతినిధ్యం మెమరీ బ్లాక్లు ఇప్పటికీ ఉనికిలో

803
01:06:38,060 --> 01:06:43,270
కానీ వేరియబుల్ శ్రేణి మరియు ఆ రకమైన వేరియబుల్స్ లేవు.

804
01:06:46,260 --> 01:06:50,270
ఆ శ్రేణుల మరియు గమనికలు మధ్య ప్రధాన తేడాలు లాగా ఉంటాయి

805
01:06:50,270 --> 01:06:55,590
వెంటనే మీకు ఫంక్షన్ కాల్స్ వంటి, ఏ తేడా ఉంటాయి.

806
01:06:55,590 --> 01:07:00,460
కానీ లోపల శ్రేణి కూడా ప్రకటిస్తారు ఆ ఫంక్షన్ యొక్క, sizeof విభిన్నంగా పని చేస్తుంది

807
01:07:00,460 --> 01:07:05,190
మీరు బదులుగా రకం పరిమాణం బ్లాక్లు పరిమాణం ప్రింటింగ్ ఉన్నందున,

808
01:07:05,190 --> 01:07:08,950
అది ఒక గుర్తు ఎందుకంటే మరియు మీరు మార్చలేరు.

809
01:07:08,950 --> 01:07:14,370
విషయం యొక్క విషయం మరియు చిరునామా ముద్రణ ఇదే ముద్రిస్తుంది.

810
01:07:14,370 --> 01:07:18,480
అంతే అందంగా ఎక్కువ.

811
01:07:18,480 --> 01:07:20,820
[విద్యార్థి] మీరు ఆ మరొకసారి చెప్పండి కాలేదు?

812
01:07:21,170 --> 01:07:24,170
నేను ఏదో తాకలేదని.

813
01:07:24,170 --> 01:07:29,260
యెరే యొక్క ప్రింటింగ్ శ్రేణి మరియు చిరునామా, ఇదే ముద్రిస్తుంది

814
01:07:29,260 --> 01:07:33,180
మీరు పాయింటర్ యొక్క చిరునామా వర్సెస్ ఒక పాయింటర్ ప్రింట్ ఉంటే అయితే,

815
01:07:33,180 --> 01:07:36,010
ఒక విషయం మీరు సూచించే ఏమి యొక్క చిరునామా ముద్రిస్తుంది,

816
01:07:36,010 --> 01:07:40,360
ఇతర స్టాక్ పాయింటర్కు యొక్క చిరునామా ముద్రిస్తుంది.

817
01:07:40,360 --> 01:07:47,040
మీరు ఒక పాయింటర్ మార్చవచ్చు; మీరు వ్యూహం గుర్తు మార్చలేరు.

818
01:07:47,740 --> 01:07:53,270
మరియు sizeof పాయింటర్ ఆ పాయింటర్ రకం పరిమాణం ప్రింట్ అన్నారు.

819
01:07:53,270 --> 01:07:57,470
కాబట్టి Int * p sizeof (p), 4 ప్రింట్ అన్నారు

820
01:07:57,470 --> 01:08:04,110
కానీ Int శ్రేణి [5] ముద్రణ sizeof (శ్రేణి) 20 ప్రింట్ అన్నారు.

821
01:08:04,110 --> 01:08:07,480
[విద్యార్థి] కాబట్టి Int శ్రేణి [5] 20 ముద్రిస్తుంది? >> అవును.

822
01:08:07,480 --> 01:08:13,300
ఎందుకు లోపల buggy4 ఇది sizeof (శ్రేణి) గా వాడినప్పుడు ఆ

823
01:08:13,300 --> 01:08:16,660
ఈ i <20 చేస్తున్న, ఇది మేము అనుకున్నవే కాదు.

824
01:08:16,660 --> 01:08:20,880
మేము i <5 కావలసిన. >> [విద్యార్థి] సరే.

825
01:08:20,880 --> 01:08:25,569
[బౌడెన్] మరియు తరువాత వెంటనే మీకు విధులు అక్కడ మొదలు వంటి,

826
01:08:25,569 --> 01:08:34,340
మేము ఉంటే Int * p = శ్రేణి;

827
01:08:34,340 --> 01:08:39,779
ఈ చర్యను లోపల, మేము సాధారణంగా, అదే విధాలుగా p మరియు యెరే ఉపయోగించవచ్చు

828
01:08:39,779 --> 01:08:43,710
sizeof సమస్య మరియు మారుతున్న సమస్య తప్ప.

829
01:08:43,710 --> 01:08:49,810
కానీ పే [0] = 1; శ్రేణి [0] = 1 మాట్లాడుతూ ఒకటే;

830
01:08:49,810 --> 01:08:55,600
మరియు సాధ్యమైనంత త్వరలో foo (శ్రేణి) చెప్పగలను; లేదా foo (p);

831
01:08:55,600 --> 01:08:59,760
foo ఫంక్షన్ లోపలి ఈ రెండుసార్లు అదే పిలుపు.

832
01:08:59,760 --> 01:09:03,350
ఈ రెండు కాల్స్ మధ్య తేడా ఉంది.

833
01:09:07,029 --> 01:09:11,080
>> ఆ మంచి అందరూ? సరే.

834
01:09:14,620 --> 01:09:17,950
మేము 10 నిమిషాలు.

835
01:09:17,950 --> 01:09:28,319
>> మేము, ఈ హ్యాకర్ Typer కార్యక్రమం ద్వారా పొందండి ప్రయత్నిస్తాము

836
01:09:28,319 --> 01:09:32,350
గత ఏడాది లేదా ఏదో బయటకు వచ్చిన ఈ వెబ్సైట్.

837
01:09:34,149 --> 01:09:41,100
మీరు యాదృచ్ఛికంగా టైప్ మరియు దీనిని ముద్రిస్తుంది వంటి అది రావలసిన ఉంటాడు -

838
01:09:41,100 --> 01:09:46,729
ఏమైనప్పటికీ ఫైలు అది లోడ్ చేసిన జరిగినప్పుడు మీరు టైప్ కనిపిస్తుంది ఏమిటి.

839
01:09:46,729 --> 01:09:52,069
ఇది ఆపరేటింగ్ సిస్టమ్ కోడ్ రకమైన కనిపిస్తోంది.

840
01:09:53,760 --> 01:09:56,890
అంటే అమలు చేయడానికి ఏమి ఉంది.

841
01:10:08,560 --> 01:10:11,690
మీరు hacker_typer అనే బైనరీ ఎక్సిక్యూటబుల్ ఉండాలి

842
01:10:11,690 --> 01:10:14,350
ఆ ఫైల్, ఒక వాదన లో పడుతుంది "హ్యాకర్ రకం."

843
01:10:14,350 --> 01:10:16,480
Executable రన్నింగ్ స్క్రీన్ క్లియర్ చేయాలి

844
01:10:16,480 --> 01:10:20,850
మరియు తరువాత వినియోగదారు ఒత్తిడి పరికరాలు కీ ప్రతి కాలం లో ఫైల్ నుండి ఒక పాత్రను ప్రింట్.

845
01:10:20,850 --> 01:10:24,990
మీరు నొక్కండి ఏ కీ కాబట్టి, త్రో ఇట్ అవే మరియు బదులుగా ఫైల్ నుండి ఒక పాత్ర ప్రింట్ ఉండాలి

846
01:10:24,990 --> 01:10:27,810
ఆ వాదన ఉంది.

847
01:10:29,880 --> 01:10:34,350
నేను చాలా చక్కని మేము తెలుసుకోవాలి చూడాలని విషయాలు మీకు చెబుతాడని.

848
01:10:34,350 --> 01:10:36,440
కానీ మేము termios లైబ్రరీ తనిఖీ మీరు.

849
01:10:36,440 --> 01:10:44,840
నా జీవితకాలంలో ఈ లైబ్రరీ వాడలేదు, కాబట్టి అది చాలా తక్కువ ఉద్దేశాలు.

850
01:10:44,840 --> 01:10:48,610
కానీ ఈ మీరు హిట్ పాత్ర తీసివేసినట్లు ఉపయోగించవచ్చు లైబ్రరీ అని అన్నారు

851
01:10:48,610 --> 01:10:52,390
మీరు ప్రామాణిక టైప్ చేసినప్పుడు

852
01:10:56,970 --> 01:11:05,840
కాబట్టి hacker_typer.c, మరియు మేము # <stdio.h> చేర్చాలనుకుంటే చూడాలని.

853
01:11:05,840 --> 01:11:12,870
Termios కోసం మనిషి పేజీ వద్ద గురించి - I'm అది యొక్క టెర్మినల్ OS లేదా ఏదో ఊహించడం -

854
01:11:12,870 --> 01:11:16,240
నేను చదవడానికి నాకు తెలియదు.

855
01:11:16,240 --> 01:11:21,040
ఈ వద్ద గురించి, ఈ 2 ఫైల్స్ కు చెప్పారు, కాబట్టి మేము ఆ పని చేస్తాము.

856
01:11:37,620 --> 01:11:46,820
>> మొదటి విషయం మొదటి, మేము తెరిచి ఉండాలి ఫైలు ఇది ఒక వాదన, లో తీసుకొవాలనుకోవటము.

857
01:11:46,820 --> 01:11:52,420
నేను ఏమి అనుకుంటున్నారు? నేను ఒక వాదన కలిగి చూడటానికి తనిఖీ చెయ్యాలి?

858
01:11:52,420 --> 01:11:56,480
[విద్యార్థి] argc అది సమానం ఉంటే. >> [బౌడెన్] అవును.

859
01:11:56,480 --> 01:12:21,250
అయితే (argc = 2!) Printf ("ఉపయోగం:% s [ఫైలు తెరవడానికి]").

860
01:12:21,250 --> 01:12:32,750
నేను రెండవ వాదన అందించకుండా ఈ అమలు చేస్తే ఇప్పుడు - ఓహ్, నేను కొత్త లైన్ అవసరం -

861
01:12:32,750 --> 01:12:36,240
మీరు చెప్పింది వాడుక చూస్తారు:. / hacker_typer,

862
01:12:36,240 --> 01:12:39,770
తరువాత రెండవ వాదన నేను తెరిచి మీరు ఫైల్ ఉండాలి.

863
01:12:58,430 --> 01:13:01,260
ఇప్పుడు నేను ఏమి చేస్తారు?

864
01:13:01,260 --> 01:13:08,490
నేను ఈ ఫైలు నుండి చదవాలనుకుంటున్న. నేను ఒక ఫైల్ నుండి చదివే?

865
01:13:08,490 --> 01:13:11,920
[విద్యార్థి] దాన్ని తెరవండి. >> అవును.

866
01:13:11,920 --> 01:13:15,010
కాబట్టి fopen. Fopen ఏమిటి ఎలా చేస్తుంది?

867
01:13:15,010 --> 01:13:22,980
[విద్యార్థి] పేరు. >> [బౌడెన్] పేరు argv [1] అని అన్నారు.

868
01:13:22,980 --> 01:13:26,110
[విద్యార్థి] మరియు తరువాత మీరు దానిని చేయాలనుకుంటున్నారా, కాబట్టి - >> [బౌడెన్] అవును.

869
01:13:26,110 --> 01:13:28,740
మీరు గుర్తు లేదు కనుక, మీరు, మనిషి fopen లాగే కాలేదు

870
01:13:28,740 --> 01:13:32,960
ఇది మార్గం ఫైల్ ఉన్న ఒక కాన్స్ట్ చార్ * మార్గం చేస్తాడు పేరు,

871
01:13:32,960 --> 01:13:34,970
కాన్స్ట్ చార్ * మోడ్.

872
01:13:34,970 --> 01:13:38,660
మీరు రీతి గుర్తు లేదు జరిగితే, అప్పుడు మీరు మోడ్ కోసం చూడవచ్చు.

873
01:13:38,660 --> 01:13:44,660
మనిషి పేజీల ఇన్సైడ్, స్లాష్ పాత్ర మీరు విషయాలు శోది ఉపయోగించవచ్చు ఏమిటి.

874
01:13:44,660 --> 01:13:49,790
నేను మోడ్ శోది / మోడ్ టైప్ చేయండి.

875
01:13:49,790 --> 01:13:57,130
n మరియు N మీరు శోధన మ్యాచ్ ద్వారా చక్రం ఉపయోగించే ఉపయోగించలేరు.

876
01:13:57,130 --> 01:13:59,800
ఇక్కడ ఇది ఒక స్ట్రింగ్ కు వాదన మోడ్ పాయింట్లు చెప్పారు

877
01:13:59,800 --> 01:14:01,930
క్రింది వరుస క్రమాల యొక్క ఒక పరిగణిస్తారు.

878
01:14:01,930 --> 01:14:06,480
పఠనం కోసం r కాబట్టి, ఓపెన్ టెక్స్ట్ ఫైల్. అంటే మీరు ఏమి ఉంది.

879
01:14:08,930 --> 01:14:13,210
చదవడం, మరియు ఆ నిల్వ మీరు కోసం.

880
01:14:13,210 --> 01:14:18,720
విషయం ఫైలు * అని అన్నారు. ఇప్పుడు నేను చెయ్యాలనుకుంటున్నారు ఏమి?

881
01:14:18,720 --> 01:14:21,200
నాకు రెండవ ఇవ్వండి.

882
01:14:28,140 --> 01:14:30,430
సరే. ఇప్పుడు నేను చెయ్యాలనుకుంటున్నారు ఏమి?

883
01:14:30,430 --> 01:14:32,940
[విద్యార్థి] ఇది NULL అయితే తనిఖీ. >> [బౌడెన్] అవును.

884
01:14:32,940 --> 01:14:38,690
మీరు ఒక ఫైల్ను తెరవడం ఏ సమయంలో, మీరు విజయవంతంగా దీన్ని తెరిచేందుకు చూడగలరని నిర్ధారించుకోండి.

885
01:14:58,930 --> 01:15:10,460
>> నేను మొదటి నా ప్రస్తుత అమరికలను చదవడానికి ఎక్కడ ఇప్పుడు నేను ఆ termios stuff చేయాలనుకుంటున్నారా

886
01:15:10,460 --> 01:15:14,050
మరియు దానిని ఆ సేవ్, అప్పుడు నా సెట్టింగులను మార్చడానికి కావలసిన

887
01:15:14,050 --> 01:15:19,420
నేను టైప్ ఏ పాత్ర తీసివేసినట్లు

888
01:15:19,420 --> 01:15:22,520
మరియు నేను ఆ సెట్టింగులను నవీకరించాలనుకున్న.

889
01:15:22,520 --> 01:15:27,250
ఆపై ప్రోగ్రామ్ యొక్క ముగింపులో, నా అసలు అమర్పులను మార్చవచ్చు మీరు.

890
01:15:27,250 --> 01:15:32,080
కాబట్టి struct రకం termios అని అన్నారు, మరియు నేను ఆ రెండు కావలసిన వెళుతున్న.

891
01:15:32,080 --> 01:15:35,600
మొదటి ఒకటి, నా current_settings అవతరిస్తుంది

892
01:15:35,600 --> 01:15:42,010
మరియు తర్వాత వారు నా hacker_settings మాత్రం చేస్తున్నారు.

893
01:15:42,010 --> 01:15:48,070
మొదటి, నేను, నా ప్రస్తుత సెట్టింగులను సేవ్ చేయాలనుకుంటున్నారా వెళుతున్న

894
01:15:48,070 --> 01:15:53,790
అప్పుడు నేను, hacker_settings నవీకరించాలనుకున్న వెళుతున్న

895
01:15:53,790 --> 01:16:01,570
అప్పుడు నా ప్రోగ్రామ్ చివరిలో మార్గం, I ప్రస్తుత అమరికలను తిరిగి వెళ్లాలని.

896
01:16:01,570 --> 01:16:08,660
అందుకే, ఈ మనిషి termios పనిచేసే విధంగా, ప్రస్తుత సెట్టింగ్లను సేవ్.

897
01:16:08,660 --> 01:16:15,810
మేము ఈ Int tcsetattr, Int tcgetattr కలిగి చూడండి.

898
01:16:15,810 --> 01:16:22,960
నేను దాని పాయింటర్ ఒక termios struct లో పాస్.

899
01:16:22,960 --> 01:16:30,640
ఈ కనిపిస్తుంది మార్గం - I've ఇప్పటికే ఫంక్షన్ అని పిలిచారు మర్చిపోయి.

900
01:16:30,640 --> 01:16:34,930
దాన్ని కాపీ చేసి.

901
01:16:39,150 --> 01:16:45,500
Tcgetattr కాబట్టి, నేను, నేను సమాచారాన్ని సేవ్ కాబట్టి struct లో పాస్ కావలసిన

902
01:16:45,500 --> 01:16:49,650
ఇది current_settings అవతరిస్తుంది

903
01:16:49,650 --> 01:16:59,120
మరియు మొదటి వాదన నేను యొక్క లక్షణాలను సేవ్ చేయాలనుకుంటున్నారా విషయం కోసం ఫైల్ వర్ణన.

904
01:16:59,120 --> 01:17:04,360
ఏ ఫైల్ వర్ణన మీరు ఒక ఫైల్ను తెరవడం ఏ సమయంలో ఉంటుంది, ఇది ఒక ఫైలు వివరణ పొందుతాడు.

905
01:17:04,360 --> 01:17:14,560
నేను fopen argv [1], ఇది మీరు సూచిస్తూ ఉంటాయి ఫైలు వివరణ గెట్స్

906
01:17:14,560 --> 01:17:16,730
మీరు చదివి లేదా వ్రాయడానికి కావలసినప్పుడు.

907
01:17:16,730 --> 01:17:19,220
నేను ఇక్కడ ఉపయోగించాలనుకుంటున్నాను ఫైలు వివరణ కాదు.

908
01:17:19,220 --> 01:17:21,940
మీరు సిద్ధంగా కలిగి మూడు ఫైలు సూచికలు ఉన్నాయి

909
01:17:21,940 --> 01:17:24,310
ఇది ప్రామాణిక అవ్ట్, మరియు ప్రామాణిక తప్పు ప్రామాణిక ఉంటాయి.

910
01:17:24,310 --> 01:17:29,960
అప్రమేయంగా, నేను 0, ప్రామాణిక అవుట్ 1, మరియు ప్రామాణిక తప్పు 2 ఉంది ప్రామాణిక అని.

911
01:17:29,960 --> 01:17:33,980
కాబట్టి నేను ఏ యొక్క సెట్టింగులను మార్చు అనుకుంటున్నారు?

912
01:17:33,980 --> 01:17:37,370
నేను ఒక పాత్ర హిట్ చేసినప్పుడు యొక్క సెట్టింగులు మార్చడానికి మీరు

913
01:17:37,370 --> 01:17:41,590
నేను బదులుగా స్క్రీన్ కు ప్రింటింగ్ యొక్క దూరంగా పాత్ర త్రో అనుకుంటున్నారా.

914
01:17:41,590 --> 01:17:45,960
ఏ స్ట్రీమ్ - - ప్రామాణిక అవ్ట్, లేదా ప్రామాణిక తప్పు, ప్రామాణిక

915
01:17:45,960 --> 01:17:52,050
నేను కీబోర్డ్ వద్ద టైప్ చేసినప్పుడు విషయాలు స్పందిస్తుంది? >> >> అవును సైన్ [విద్యార్థి] ప్రామాణిక.

916
01:17:52,050 --> 01:17:56,450
నేను గాని 0 చేయవచ్చు లేదా నేను stdin చేయవచ్చు.

917
01:17:56,450 --> 01:17:59,380
నేను సైన్ ప్రామాణిక యొక్క current_settings పొందుతున్నాను

918
01:17:59,380 --> 01:18:01,720
>> ఇప్పుడు నేను, ఆ సెట్టింగులను నవీకరించాలనుకున్న

919
01:18:01,720 --> 01:18:07,200
కాబట్టి మొదటి నా current_settings ఏమిటో hacker_settings లోకి కాపీ చేస్తాము.

920
01:18:07,200 --> 01:18:10,430
మరియు structs పని ఎంత ఇది కాపీ చేస్తుంది.

921
01:18:10,430 --> 01:18:14,510
మీరు ఊహించిన దాని ఇది అన్ని రంగాల్లో ప్రతులు.

922
01:18:14,510 --> 01:18:17,410
>> ఇప్పుడు నేను రంగాలలో కొన్ని నవీకరించాలనుకున్న.

923
01:18:17,410 --> 01:18:21,670
Termios వద్ద గురించి, మీరు ఈ చాలా ద్వారా రీడ్ వుంటుంది

924
01:18:21,670 --> 01:18:24,110
మీ కోసం చూడవచ్చు ఏ చూడటానికి,

925
01:18:24,110 --> 01:18:28,210
మీరు చూడవచ్చు, చూడాలని జెండాలు, echo ఉంటాయి

926
01:18:28,210 --> 01:18:33,110
కాబట్టి ఎకో అక్షరాలను ఇన్పుట్ ఎకో.

927
01:18:33,110 --> 01:18:37,710
మొదటి నేను సెట్ చేయాలనుకుంటున్నారా - క్షేత్రాలు ఏ ఇప్పటికే మర్చిపోయి I've.

928
01:18:45,040 --> 01:18:47,900
ఈ struct ఎలా ఉంది.

929
01:18:47,900 --> 01:18:51,060
ఇన్పుట్ విధానాలను నేను మేము మార్చడానికి కావలసిన భావిస్తున్నాను.

930
01:18:51,060 --> 01:18:54,210
మేము ఆ మనము చేయడానికి ఏమి ఉందో లేదో నిర్ధారించడానికి పరిష్కారం వద్ద పరిశీలిస్తాము.

931
01:19:04,060 --> 01:19:12,610
మేము ఈ ద్వారా చూడండి అవసరం నిరోధించడానికి lflag మార్చడానికి కావలసిన.

932
01:19:12,610 --> 01:19:14,670
మేము స్థానిక మోడ్లు మార్చడానికి కావలసిన.

933
01:19:14,670 --> 01:19:17,710
మీరు ప్రతి చెందిన పేరు అర్థం ఈ మొత్తం విషయం ద్వారా రీడ్ వుంటుంది

934
01:19:17,710 --> 01:19:19,320
మేము మార్చడానికి కావలసిన.

935
01:19:19,320 --> 01:19:24,120
కానీ మేము ఆ మార్పు చేయండి వెళుతున్న స్థానిక రీతుల్లో లోపల.

936
01:19:27,080 --> 01:19:33,110
కాబట్టి hacker_settings.cc_lmode దీనిని ఏమి ఉంది.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
మేము bitwise ఆపరేటర్లు పొందడానికి ఇది ఉంది.

939
01:19:52,280 --> 01:19:54,860
మేము సమయాల్లో రకం, కానీ మాకు అది నిజమైన శీఘ్ర ద్వారా వెళ్తారో.

940
01:19:54,860 --> 01:19:56,600
మేము bitwise ఆపరేటర్లు పొందడానికి ఇది ఉంది

941
01:19:56,600 --> 01:19:59,950
నేను అనుకుంటున్నాను నేను ఎక్కడ ఒకసారి కాలం క్రితం చెప్పారు మీరు జెండాలు వ్యవహరించే ప్రారంభించిన ప్రతిసారీ,

942
01:19:59,950 --> 01:20:03,370
మీరు bitwise ఆపరేటర్లు చాలా ఉపయోగించి చూడాలని.

943
01:20:03,370 --> 01:20:08,240
జెండా ప్రతి బిట్ ప్రవర్తన విధమైన సూచించదు.

944
01:20:08,240 --> 01:20:14,090
ఇక్కడ, ఈ జెండా వారి అన్ని విరుద్ధంగా అర్థాన్ని వేర్వేరు విషయాలు, కొంత ఉంది.

945
01:20:14,090 --> 01:20:18,690
కానీ నేను మీరు ఏమి కేవలం ఎకో అనుగుణంగా ఉండే బిట్ ఆఫ్ ఉంది.

946
01:20:18,690 --> 01:20:25,440
కాబట్టి చెయ్యడానికి ఆ నేను ఆఫ్ & = ¬ ECHO.

947
01:20:25,440 --> 01:20:30,110
అసలైన, నేను tECHO లేదా ఏదో వంటి అని. నేను మళ్ళీ తనిఖీ వెళుతున్న.

948
01:20:30,110 --> 01:20:34,050
నేను termios చేయవచ్చు. ఇది కేవలం ఎకో యొక్క.

949
01:20:34,050 --> 01:20:38,440
ECHO ఒక బిట్ ఉంటుంది అన్నారు.

950
01:20:38,440 --> 01:20:44,230
¬ ECHO అన్ని జెండాలు ఒప్పుకు సెట్ అంటే, అన్ని బిట్స్ 1 కు సెట్ అర్థం అన్నారు

951
01:20:44,230 --> 01:20:47,140
ECHO బిట్ మినహా.

952
01:20:47,140 --> 01:20:53,830
ఈ నా స్థానిక జెండాలు ముగింపు నాటికి, ప్రస్తుతం ఒప్పుకు సెట్ అన్ని జెండాలు అర్థం

953
01:20:53,830 --> 01:20:56,520
ఇప్పటికీ నిజమైన అమర్చబడుతుంది.

954
01:20:56,520 --> 01:21:03,240
నా ECHO జెండా నిజమైన సెట్ చేయబడి ఉంటే, అప్పుడు ఈ తప్పనిసరిగా ECHO జెండా పై తప్పుడు కు సెట్.

955
01:21:03,240 --> 01:21:07,170
కాబట్టి కోడ్ ఈ రేఖను కేవలం ECHO జెండా ఆఫ్ అవుతుంది.

956
01:21:07,170 --> 01:21:16,270
కోడ్ ఇతర పంక్తులు నేను వాటిని సమయం ఆసక్తి కాపీ మరియు తరువాత వాటిని వివరించటానికి ఉంటాం.

957
01:21:27,810 --> 01:21:30,180
పరిష్కారం లో, అతను 0 చెప్పారు.

958
01:21:30,180 --> 01:21:33,880
ఇది స్పష్టంగా stdin చెప్పడానికి బహుశా ఉత్తమం.

959
01:21:33,880 --> 01:21:42,100
>> ఇక్కడ ICANON | నేను కూడా ECHO చేస్తున్నదాన్ని గమనించాలి.

960
01:21:42,100 --> 01:21:46,650
ICANON కానానికల్ మోడ్ అంటే ప్రత్యేక ఏదో, సూచిస్తుంది.

961
01:21:46,650 --> 01:21:50,280
మీరు కమాండ్ లైన్ అవ్ట్ టైప్ చేస్తున్నప్పుడు ఏమి కానానికల్ మోడ్ అంటే, సాధారణంగా

962
01:21:50,280 --> 01:21:54,670
మీరు NEWLINE హిట్ వరకు ప్రామాణిక ఏదైనా ప్రాసెస్ లేదు.

963
01:21:54,670 --> 01:21:58,230
కాబట్టి మీరు GetString చేసినప్పుడు, మీరు NEWLINE హిట్ తర్వాత, విషయాలు కొంత టైప్ చేయండి.

964
01:21:58,230 --> 01:22:00,590
ఇది సైన్ ప్రామాణిక కు పంపిన ఉన్నప్పుడు ఆ

965
01:22:00,590 --> 01:22:02,680
డిఫాల్ట్ ఉంది.

966
01:22:02,680 --> 01:22:05,830
నేను, మీరు నొక్కండి ఇప్పుడు ప్రతి పాత్ర కానానికల్ మోడ్ ఆఫ్ చేసినప్పుడు

967
01:22:05,830 --> 01:22:10,910
ఏ, ఈ విషయాలు ప్రాసెస్ నెమ్మదిగా ఎందుకంటే సాధారణంగా చెడు రకం, ఇది ప్రాసెస్ అవుతుంది ఉంది

968
01:22:10,910 --> 01:22:14,330
ఇది మొత్తం పంక్తులు లో స్వీకరించేందుకు మంచి వై ఇది.

969
01:22:14,330 --> 01:22:16,810
కానీ నేను ప్రతి పాత్ర ప్రాసెస్ చెయ్యడానికి మీరు

970
01:22:16,810 --> 01:22:18,810
నా NEWLINE నొక్కండి కోసం వేచి అనుకుంటున్న నుండి

971
01:22:18,810 --> 01:22:21,280
అన్ని అక్షరాలు ప్రాసెస్ ముందు నేను టైప్ చేసిన.

972
01:22:21,280 --> 01:22:24,760
ఈ కానానికల్ మోడ్ ఆఫ్ అవుతుంది.

973
01:22:24,760 --> 01:22:31,320
నిజానికి అక్షరాలు ప్రాసెస్ ఈ అంశాలు అర్థం.

974
01:22:31,320 --> 01:22:35,830
, వెంటనే నేను టైప్ ఆమ్ వాటిని ప్రాసెస్; ఈ వెంటనే వాటిని ప్రాసెస్ అర్థం.

975
01:22:35,830 --> 01:22:42,510
మరియు ఈ, ప్రామాణిక నా సెట్టింగ్లను నవీకరించడంలో ఇది విధి

976
01:22:42,510 --> 01:22:45,480
మరియు TCSA అంటే ప్రస్తుతం చేస్తున్నాయి.

977
01:22:45,480 --> 01:22:50,310
స్ట్రీమ్లో ప్రస్తుతం ప్రతిదీ ప్రాసెస్ వరకు ఇతర ఎంపికలు వేచి ఉన్నాయి.

978
01:22:50,310 --> 01:22:52,030
ఇది నిజంగా పట్టింపు లేదు.

979
01:22:52,030 --> 01:22:56,920
ప్రస్తుతం నా సెట్టింగులు hacker_typer_settings ప్రస్తుతం ఏ గా మార్చండి.

980
01:22:56,920 --> 01:23:02,210
నేను hacker_settings అని అంచనా, కాబట్టి యొక్క మార్చే వీలు.

981
01:23:09,610 --> 01:23:13,500
Hacker_settings ప్రతిదీ మార్చండి.

982
01:23:13,500 --> 01:23:16,870
>> ఇప్పుడు మా కార్యక్రమం చివరిలో మేము తిరిగి మీరు చూడాలని

983
01:23:16,870 --> 01:23:20,210
normal_settings లోపలి ప్రస్తుతం ఏమి,

984
01:23:20,210 --> 01:23:26,560
ఇది కేవలం & normal_settings ఎలా అన్నారు.

985
01:23:26,560 --> 01:23:30,650
నేను మొదట దాన్ని పొందడం నుండి నా normal_settings ఏ మారలేదు గమనించండి.

986
01:23:30,650 --> 01:23:34,520
వాటిని తిరిగి మార్చడానికి, నేను ముగింపు వాటిని మళ్ళీ పాస్.

987
01:23:34,520 --> 01:23:38,390
ఈ నవీకరణ ఉంది. సరే.

988
01:23:38,390 --> 01:23:43,900
>> లోపల ఇక్కడ ఇప్పుడు నేను సమయం ఆసక్తి కోడ్ వివరించడానికి చేస్తాము.

989
01:23:43,900 --> 01:23:46,350
ఇది చాలా కోడ్ కాదు.

990
01:23:50,770 --> 01:24:03,750
మేము ఫైల్ నుండి ఒక పాత్ర చదవండి చూడండి. మేము F అని.

991
01:24:03,750 --> 01:24:07,850
ఇప్పుడు మీరు మనిషి fgetc చేయగలరు, కానీ ఎలా fgetc పని అన్నారు

992
01:24:07,850 --> 01:24:11,910
దీనిని మీరు చదివి లేదా EOF పాత్ర తిరిగి వెళుతున్న ఉంది,

993
01:24:11,910 --> 01:24:15,680
ఏ ఫైల్ లేదా కొన్ని లోపం జరిగిందని చివర ఉంటుంది.

994
01:24:15,680 --> 01:24:19,900
మేము, ఫైలు నుండి ఒక పాత్ర చదవడానికి నిరంతర, మళ్ళీ వెతికినా ఉంటాయి

995
01:24:19,900 --> 01:24:22,420
మేము చదవడానికి అక్షరాలు యొక్క రన్నవుట్ చేసిన వరకు.

996
01:24:22,420 --> 01:24:26,650
మేము ఆ చేస్తున్నా సమయంలో, మేము సైన్ ప్రామాణిక నుండి ఒక పాత్ర వేచి

997
01:24:26,650 --> 01:24:29,090
ప్రతి మీరు, కమాండ్ లైన్ వద్ద ఏదో టైప్

998
01:24:29,090 --> 01:24:32,820
సైన్ ప్రామాణిక నుండి ఒక పాత్ర లో చదివిన చేసే

999
01:24:32,820 --> 01:24:38,330
అప్పుడు putchar కేవలం మేము ఫైల్ నుండి ప్రామాణిక అవుట్ ఇక్కడ చదవండి చార్ ఉంచారు అన్నారు.

1000
01:24:38,330 --> 01:24:42,890
మీరు మనిషి putchar, కాని, ఇది కేవలం ప్రమాణ ఉంచడం, అది ఆ పాత్ర ప్రింటింగ్ అన్నారు.

1001
01:24:42,890 --> 01:24:51,600
ఇదే ఆలోచన; మీరు కేవలం printf ("% సి", సి) పని చేయడు.

1002
01:24:53,330 --> 01:24:56,670
మా పని అత్యధిక చేయడానికి జరగబోతోంది.

1003
01:24:56,670 --> 01:25:00,300
>> మేము చేయాలనుకుంటున్నారా చూడాలని లాస్ట్ థింగ్ మా ఫైలు fclose ఉంది.

1004
01:25:00,300 --> 01:25:03,310
మీరు fclose లేకపోతే, ఆ మెమొరీ లీక్ ఉంది.

1005
01:25:03,310 --> 01:25:06,680
మేము నిజానికి తెరుచుకున్న ఫైల్ fclose మీరు, నేను దాన్ని ఉంటుంది.

1006
01:25:06,680 --> 01:25:13,810
మేము ఆ చేస్తే, నేను ఇప్పటికే సమస్యలు వచ్చింది.

1007
01:25:13,810 --> 01:25:17,260
యొక్క చూసేలా.

1008
01:25:17,260 --> 01:25:19,960
అంటే ఫిర్యాదు చేశారు?

1009
01:25:19,960 --> 01:25:30,220
ఊహించినది 'Int' కానీ వాదన రకం 'struct _IO_FILE *' ఉంటుంది.

1010
01:25:36,850 --> 01:25:39,370
ఆ పని మేము చూస్తారు.

1011
01:25:45,210 --> 01:25:53,540
మాత్రమే C99 లో అనుమతించింది. Augh. సరే, hacker_typer చేయండి.

1012
01:25:53,540 --> 01:25:57,760
ఇప్పుడు మేము మరింత ఉపయోగకరమైన వివరణలను పొందండి.

1013
01:25:57,760 --> 01:25:59,900
కాబట్టి ప్రకటించనివారు ఐడెంటిఫైయర్ 'normal_settings' యొక్క ఉపయోగించండి.

1014
01:25:59,900 --> 01:26:04,170
నేను normal_settings కాల్ లేదు. నేను current_settings అని.

1015
01:26:04,170 --> 01:26:12,090
కాబట్టి యొక్క ఆ అన్ని మార్చుకోవడానికి అనుమతించే.

1016
01:26:17,920 --> 01:26:21,710
ఇప్పుడు వాదన వెళుతుంది.

1017
01:26:26,290 --> 01:26:29,500
నేను ఇప్పుడు ఈ 0 చేస్తాము.

1018
01:26:29,500 --> 01:26:36,720
సరే. . / Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
నేను కూడా ప్రారంభంలో స్క్రీన్ క్లియర్ లేదు.

1020
01:26:39,590 --> 01:26:42,960
కానీ మీరు స్క్రీన్ క్లియర్ ఎలా చివరి సమస్య సెట్ తిరిగి చూడవచ్చు.

1021
01:26:42,960 --> 01:26:45,160
ఇది కేవలం కొన్ని అక్షరాలు ప్రింటింగ్ యొక్క

1022
01:26:45,160 --> 01:26:47,210
ఈ నేను మీరు ఏమి చేయడం ఉంది.

1023
01:26:47,210 --> 01:26:48,900
సరే.

1024
01:26:48,900 --> 01:26:55,280
మరియు ఈ బదులుగా stdin 0 ఉండాలి ఎందుకు ఆలోచించకుండా,

1025
01:26:55,280 --> 01:27:00,560
ఇది # 0 నిర్వచించే చేయాలి

1026
01:27:00,560 --> 01:27:03,890
ఈ ఫిర్యాదు ఉంది -

1027
01:27:13,150 --> 01:27:19,360
నేను ఫైలు సూచికలు లేదు, అయితే మీరు కూడా మీ ఫైల్ * ఉన్నప్పుడు ముందు,

1028
01:27:19,360 --> 01:27:23,210
ఫైలు వివరణ, కేవలం ఒకే పూర్ణ సంఖ్య

1029
01:27:23,210 --> 01:27:26,970
ఫైలు * ఇది సంబంధం stuff యొక్క మొత్తం బంచ్ అదే.

1030
01:27:26,970 --> 01:27:30,380
మేము బదులుగా stdin 0 చెప్పడానికి అవసరం కారణం

1031
01:27:30,380 --> 01:27:37,480
ఆ stdin ఫైలు వివరణ 0 సూచిస్తూ ఆ విషయం సూచిస్తుంది ఉన్న ఒక ఫైల్ * ఉంది.

1032
01:27:37,480 --> 01:27:45,070
కాబట్టి కూడా ఇక్కడ నేను fopen చేసినప్పుడు (argv [1], నేను తిరిగి ఫైల్ * పొందుతున్నాను.

1033
01:27:45,070 --> 01:27:51,180
కానీ ఎక్కడో ఆ ఫైల్ * లో ఫైల్ కోసం ఫైలు వివరణ సంబంధించి ఒక విషయం.

1034
01:27:51,180 --> 01:27:57,430
మీరు ఓపెన్ కోసం మనిషి పేజీ చూడండి ఉంటే, నేను మీరు మనిషి 3 ఓపెన్ లేదు భావిస్తున్నాము - వద్దు -

1035
01:27:57,430 --> 01:27:59,380
మనిషి 2 ఓపెన్ - అవును.

1036
01:27:59,380 --> 01:28:06,250
మీరు ఓపెన్ కోసం పేజీ చూడండి ఉంటే, ఓపెన్, తక్కువ స్థాయి fopen వంటిది

1037
01:28:06,250 --> 01:28:09,350
మరియు అది వాస్తవ ఫైలు వివరణ తిరిగి ఉంది.

1038
01:28:09,350 --> 01:28:12,050
fopen ఓపెన్ పైన stuff ఒక సమూహం చేస్తుంది,

1039
01:28:12,050 --> 01:28:17,640
బదులుగా ఫైల్ వివరణ మొత్తం FILE * పాయింటర్ తిరిగి ఆ తిరిగి ఏ

1040
01:28:17,640 --> 01:28:20,590
లోపల ఇది మా చిన్న ఫైల్ వర్ణన.

1041
01:28:20,590 --> 01:28:25,020
FILE * విషయం సూచిస్తుంది అలా ప్రామాణిక,

1042
01:28:25,020 --> 01:28:29,120
0 కూడా కేవలం ఫైల్ వివరణ ప్రామాణిక సూచిస్తుంది అయితే.

1043
01:28:29,120 --> 01:28:32,160
>> ప్రశ్నలు?

1044
01:28:32,160 --> 01:28:35,930
[నవ్విన] ఆ ద్వారా బ్ల్యూ.

1045
01:28:35,930 --> 01:28:39,140
అన్ని కుడి. మేము పూర్తి చేసిన. [నవ్విన]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]