1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[సంగీతాన్ని]

3
00:00:11,261 --> 00:00:12,640
>> డేవిడ్ J. మలన్: అన్ని కుడి.

4
00:00:12,640 --> 00:00:14,525
ఈ CS50 ఉంది.

5
00:00:14,525 --> 00:00:16,009
మరియు ఈ వారం 5 ప్రారంభంలో ఉంది.

6
00:00:16,009 --> 00:00:18,050
మరియు మీరు గమనించి ఉండవచ్చు గా,
కొన్ని విషయాలు

7
00:00:18,050 --> 00:00:21,050
కొంచెం పెరిగిపోతుంది
క్లిష్టమైన, తక్కువ దట్టమైన.

8
00:00:21,050 --> 00:00:24,560
>> మరియు అది ముఖ్యంగా, చాలా సులభం
మీరు కొంత సమయం కోసం అలవాటు ఉన్నాను

9
00:00:24,560 --> 00:00:28,600
అత్యంత డౌన్ ని ప్రయత్నిస్తున్న
మేము ఏదైనా, మేము తరగతి లో మాట్లాడుతూ చేస్తున్నారు.

10
00:00:28,600 --> 00:00:31,626
కానీ ఆ బహుశా కాదు, గుర్తించలేరు
ఆదర్శ బోధనకు విధానం

11
00:00:31,626 --> 00:00:34,250
పదార్థం యొక్క ఈ రకమైన జ్ఞానార్జన,
మరియు పదార్థం మరింత సాధారణంగా.

12
00:00:34,250 --> 00:00:37,250
కాబట్టి మనం సంతోషిస్తున్నారు
ఆ CS50 యొక్క సొంత Gheng ప్రకటించిన

13
00:00:37,250 --> 00:00:39,780
గాంగ్ సిద్ధం ప్రారంభించింది
గమనికలు యొక్క సాధారణ సెట్

14
00:00:39,780 --> 00:00:42,100
కోర్సు కోసం, ఆశ
ఇది ఈ, ఒకటి

15
00:00:42,100 --> 00:00:44,030
మాత్రమే అందజేయడం
సూచన మరియు ఒక వనరు

16
00:00:44,030 --> 00:00:47,410
పదార్థం సమీక్షించిన మరియు వెళుతున్న కోసం
తిరిగి పదార్థం ద్వారా కలిగి ఉండవచ్చని

17
00:00:47,410 --> 00:00:51,230
మీరు చుట్టూ మొదటిసారి తప్పించుకుంటాడు కానీ
కూడా తద్వారా మీ తలలు ఉంటుంది మరింత

18
00:00:51,230 --> 00:00:53,740
డౌన్, అది కంటే అప్
ఉపన్యాసాలిచ్చేందుకు సమయం వస్తుంది,

19
00:00:53,740 --> 00:00:56,960
మీరు నిమగ్నం కావచ్చు కనుక
మరింత thoughtfully, వంటి

20
00:00:56,960 --> 00:00:59,170
మరింత scribbly వ్యతిరేకంగా.

21
00:00:59,170 --> 00:01:02,510
>> అన్నారు తో, మీరు పొందుతారు ఏమి
వెబ్సైట్ ఈ వంటి పత్రాలు ఉంది.

22
00:01:02,510 --> 00:01:04,660
మరియు ప్రకటన, ఎడమ ఎగువన ఉంది
మాత్రమే విషయాల పట్టిక,

23
00:01:04,660 --> 00:01:06,920
కానీ సమయం సంకేతాలు అని
వెంటనే మీరు జంప్

24
00:01:06,920 --> 00:01:09,077
తగిన భాగం
వీడియో ఆన్లైన్.

25
00:01:09,077 --> 00:01:11,410
మరియు ఇక్కడ ఏమి చాంగ్ చేశారు
, తప్పనిసరిగా, పత్ర

26
00:01:11,410 --> 00:01:13,340
ఏమి ఈ జరిగిన
ప్రత్యేక ఉపన్యాసం.

27
00:01:13,340 --> 00:01:16,370
మరియు ఉపన్యాసాలు అనేక
ఇప్పటికే ఇప్పుడు ఆన్లైన్ ఈ URL తో.

28
00:01:16,370 --> 00:01:20,110
మరియు మేము మిగిలిన పోస్ట్ చేస్తాము
ఈ వారం చివరికి ఆ,

29
00:01:20,110 --> 00:01:22,380
కాబట్టి ఆ రిసోర్స్ ప్రయోజనాన్ని లేదు.

30
00:01:22,380 --> 00:01:25,740
>> కనుక తదుపరి శ్రమ లేకుండా,
మేము తిరిగి రాలిపోవడం ప్రారంభించారు

31
00:01:25,740 --> 00:01:28,180
ఉంది ఆ పొర
కొంత సమయం కోసం స్ట్రింగ్.

32
00:01:28,180 --> 00:01:30,670
మరియు మేము ఒక స్ట్రింగ్ ఏమి లేదు
నిజానికి గత వారం?

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
కాబట్టి చార్ స్టార్.

35
00:01:32,900 --> 00:01:34,900
మరియు చార్ స్టార్, బాగా, ఏమి
నిజంగా అర్థం లేదు?

36
00:01:34,900 --> 00:01:37,150
Well, ఈ సమయంలో, మేము చేసిన ఉంటే
ఒక ఫంక్షన్ కాల్,

37
00:01:37,150 --> 00:01:40,450
GetString, మరియు నిల్వ వంటి
అని పిలవబడే తిరిగి

38
00:01:40,450 --> 00:01:42,910
ఒక లో GetString విలువ
వేరియబుల్ అది అని

39
00:01:42,910 --> 00:01:47,721
మేము రాయడం చేసిన స్ట్రింగ్ s రకం
అక్కడికి ఎగువ కోడ్ లైన్.

40
00:01:47,721 --> 00:01:49,970
నేను చూసినప్పుడు ఇది మాత్రమే నా
చేతిరాత ఇక్కడ వృద్ధి

41
00:01:49,970 --> 00:01:51,930
నేను ఈ కేవలం ఎంత దారుణమైన రియలైజ్.

42
00:01:51,930 --> 00:01:54,180
>> అయితే, ఆ యొక్క ఊహించుకోవటం తెలియజేయండి,
కుడి వైపు

43
00:01:54,180 --> 00:01:57,070
, అయితే, ఒక సహేతుకమైన ఉంది
ఏది చిత్రణ

44
00:01:57,070 --> 00:01:58,880
ఈ జరుగుతున్నాయి
GetString తో సమయం.

45
00:01:58,880 --> 00:02:00,380
GetString, కోర్సు యొక్క, ఒక స్ట్రింగ్ పొందుతాడు.

46
00:02:00,380 --> 00:02:01,691
కానీ నిజంగా అర్థం ఏమిటి?

47
00:02:01,691 --> 00:02:04,190
ఇది ఒక భాగం అవుతుందని అర్ధం
ఆపరేటింగ్ సిస్టమ్ నుండి మెమరీ

48
00:02:04,190 --> 00:02:06,040
ఒక చర్యను కాల్ చేస్తున్నప్పుడు, malloc అని.

49
00:02:06,040 --> 00:02:07,390
కానీ ఆ తర్వాత.

50
00:02:07,390 --> 00:02:09,139
ఆపై దానిని populates
మెమరీ ఆ భాగం

51
00:02:09,139 --> 00:02:11,764
అక్షరాలతో వినియోగదారు ఉంది
, లో టైప్ తరువాత, కోర్సు యొక్క,

52
00:02:11,764 --> 00:02:14,800
ఒక శూన్య పాత్ర, లేదా బాక్ స్లాష్
చాలా చివరిలో సున్నా.

53
00:02:14,800 --> 00:02:18,280
>> ఇంతలో, ఎడమ చేతి వైపు
ఈ కథ, ఈ సమయంలో,

54
00:02:18,280 --> 00:02:20,850
మేము, వంటి ఒక వేరియబుల్ ప్రకటించారు చేసిన.

55
00:02:20,850 --> 00:02:24,770
మరియు ఆ వేరియబుల్ ఇప్పుడు ఏమిటి
ఒక పాయింటర్ కాల్ ప్రారంభించడానికి ఉంటుంది.

56
00:02:24,770 --> 00:02:29,190
ఇది లోపల ఇది బాక్స్ కాదు
మేము స్ట్రింగ్ చాలు, Daven, ప్రతి SE,

57
00:02:29,190 --> 00:02:32,550
కానీ మేము ఆ చదరపు చాలు
ఎడమ వేటి బాక్స్?

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
అవును?

60
00:02:35,390 --> 00:02:37,118
>> ప్రేక్షకులు: పాఠశాల చిరునామా
మెమరీ లో ఉన్న యొక్క.

61
00:02:37,118 --> 00:02:38,118
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

62
00:02:38,118 --> 00:02:40,690
Daven పేరు యొక్క చిరునామా
మెమరీలో ఉన్న.

63
00:02:40,690 --> 00:02:44,650
మరియు Daven అన్ని ఉన్న పేరు
కేవలంగా, కానీ ప్రత్యేకంగా చిరునామా

64
00:02:44,650 --> 00:02:45,150
ఏమి?

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
అవును?

67
00:02:46,810 --> 00:02:47,460
>> ప్రేక్షకులు: మొదటి పాత్ర.

68
00:02:47,460 --> 00:02:50,209
>> డేవిడ్ J. మలన్: మొదటి పాత్ర
ఈ సందర్భంలో Daven, దీనిలో,

69
00:02:50,209 --> 00:02:53,820
నేను ఏకపక్ష ఉంది ప్రతిపాదించారు
అవాస్తవ రీతిలో 1, Ox1,

70
00:02:53,820 --> 00:02:55,910
ఇది కేవలం అర్థం
1 హెక్సాడెసిమల్ సంఖ్య.

71
00:02:55,910 --> 00:02:57,993
కానీ అది బహుశా జరగబోతోంది
ఒక పెద్ద సంఖ్య అని

72
00:02:57,993 --> 00:03:01,260
మేము డ్రా ఉండవచ్చు
ఉపసర్గ ఒక 0x తో,

73
00:03:01,260 --> 00:03:02,806
ఒక హెక్సాడెసిమల్ పాత్ర సూచిస్తున్న.

74
00:03:02,806 --> 00:03:05,930
మరియు మేము తెలుసుకోవాలి లేదు ఎందుకంటే
Daven అక్షరాలు మిగిలిన

75
00:03:05,930 --> 00:03:09,860
ఎందుకంటే, ఏమిటో సాధారణ డిజైన్
నిర్ణయం అనేక సంవత్సరాల క్రితం జరిగింది?

76
00:03:09,860 --> 00:03:10,548
అవును?

77
00:03:10,548 --> 00:03:11,651
>> ప్రేక్షకులు బ్యాక్స్లాష్ 0.

78
00:03:11,651 --> 00:03:12,900
డేవిడ్ J. మలన్: అవును, సరిగ్గా.

79
00:03:12,900 --> 00:03:18,100
బాక్ స్లాష్ 0 లో అయితే, మీరు అనుమతిస్తుంది
సరళ సమయం, స్ట్రింగ్ ప్రయాణించేందుకు,

80
00:03:18,100 --> 00:03:20,400
ఎడమ నుండి కుడికి నడిచి,
ఒక లూప్ లేదా కొంత తో

81
00:03:20,400 --> 00:03:22,608
లూప్, లేదా ఏదో వంటి
ఆ, మరియు ఇక్కడ, OH, గుర్తించడానికి

82
00:03:22,608 --> 00:03:24,751
ఈ ప్రత్యేక స్ట్రింగ్ ముగింపు.

83
00:03:24,751 --> 00:03:27,000
కేవలం చిరునామాతో కాబట్టి
ఒక స్ట్రింగ్ ప్రారంభంలో,

84
00:03:27,000 --> 00:03:30,290
మేము సంపూర్ణంగా యాక్సెస్ చేయవచ్చు
అది అన్ని ఈ ఎందుకంటే,

85
00:03:30,290 --> 00:03:32,030
ఒక స్ట్రింగ్ కేవలం ఒక చార్ స్టార్ ఉన్నారు.

86
00:03:32,030 --> 00:03:36,370
>> కనుక ఇది ఉపయోగించడం కొనసాగించాలని ఖచ్చితంగా మంచిది
CS50 లైబ్రరీ మరియు ఈ నైరూప్యత,

87
00:03:36,370 --> 00:03:38,440
కాబట్టి మాట్లాడటం, కానీ మేము చేస్తాము
సరిగ్గా చూడటానికి ప్రారంభం

88
00:03:38,440 --> 00:03:41,230
ఏమి జరుగుతున్నాయి
ఈ మొత్తం సమయం కింద.

89
00:03:41,230 --> 00:03:45,260
కాబట్టి మీరు ఈ ఉదాహరణ గుర్తుకు,
చాలా, చివరిసారి నుండి, 0 పోల్చడం

90
00:03:45,260 --> 00:03:47,300
నిజానికి సరిపోల్చండి లేదు.

91
00:03:47,300 --> 00:03:49,070
కానీ మేము ఈ పరిష్కరించడానికి ప్రారంభమైంది.

92
00:03:49,070 --> 00:03:52,020
>> కానీ బహుశా ఒక రిఫ్రెషర్,
నేను ఎవరైనా ఆసక్తి ఉండవచ్చు

93
00:03:52,020 --> 00:03:54,261
ఒక పింక్ ఏనుగు నేడు,
కూడా చాంగ్ చేసిన?

94
00:03:54,261 --> 00:03:55,760
ఎలా ముందు మీరు? [వినబడని].

95
00:03:55,760 --> 00:03:56,660
అప్ న వస్తాయి.

96
00:03:56,660 --> 00:03:58,740
>> మరియు ఈ మధ్యకాలంలో,
మీరు వచ్చేటప్పుడు, లెట్స్

97
00:03:58,740 --> 00:04:01,670
కేవలం ఒక క్షణం భావిస్తారు ఏమి
ఈ కోడ్ వాస్తవానికి చేయడం జరిగినది.

98
00:04:01,670 --> 00:04:04,917
ఇది రెండు చరరాశుల ప్రకటించారు లో
టాప్, s మరియు t, మరియు GetString కాల్.

99
00:04:04,917 --> 00:04:08,250
ఈ ఒక చాలా యూజర్ ఫ్రెండ్లీ కార్యక్రమం కాదు
మీరు చెప్పండి లేదు ఎందుకంటే మీరు ఏమి.

100
00:04:08,250 --> 00:04:10,541
కానీ మేము ఉన్నాము భావిస్తాయి తెలియజేయండి
జ్యుసి భాగం చిత్రీకరించింది.

101
00:04:10,541 --> 00:04:14,470
లు సమానం ఉంటే అప్పుడు మేము, చేయండి
అది printf చెప్పాలి T సమానం,

102
00:04:14,470 --> 00:04:16,170
మీరు అదే పని టైప్.

103
00:04:16,170 --> 00:04:16,670
హలో.

104
00:04:16,670 --> 00:04:17,050
మీ పేరు ఏమిటి?

105
00:04:17,050 --> 00:04:17,779
>> Janelle: Janelle.

106
00:04:17,779 --> 00:04:19,529
డేవిడ్ J. మలన్: Janelle,
మీరు ఎవరిని బాగుంది.

107
00:04:19,529 --> 00:04:21,800
మీ సవాలు సో
ఈ ఏనుగు వైపు

108
00:04:21,800 --> 00:04:25,230
మొదటి మాకు ఏది చిత్రాన్ని డ్రా ఉంది
ఆ మొదటి రెండు ప్రాతినిధ్యం చేస్తున్నారు

109
00:04:25,230 --> 00:04:25,970
పంక్తులు.

110
00:04:25,970 --> 00:04:28,139
కాబట్టి s మరియు t కావచ్చు
ఎలా తెరపై ప్రాతినిధ్యం?

111
00:04:28,139 --> 00:04:30,680
మరియు మీరు కేవలం అది డ్రా చేయవచ్చు
ఈ పెద్ద తెరపై మీ వేలు.

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> కాబట్టి రెండు భాగాలుగా ఉంది
సమీకరణం ప్రతి వైపు.

114
00:04:34,510 --> 00:04:37,760
సో అక్కడ ఎడమ లు, మరియు
అప్పుడు కుడివైపు GetString.

115
00:04:37,760 --> 00:04:40,540
ఆపై టి, ఎడమ ఉంది
మరియు సరైన GetString.

116
00:04:40,540 --> 00:04:42,630
కాబట్టి మేము ఎలా ప్రారంభం కావచ్చు
ఒక చిత్రాన్ని గీయడం ఆ

117
00:04:42,630 --> 00:04:46,340
జరగబోతోంది ఏమి సూచిస్తుంది
ఇక్కడ మెమరీ, మీరు చెబుతా?

118
00:04:46,340 --> 00:04:49,150
నాకు మీరు వివరించడానికి వీలు తెలియజేయండి
మీరు వంటి మీరు చేస్తున్న ఏమి.

119
00:04:49,150 --> 00:04:49,820
>> Janelle: సరే.

120
00:04:49,820 --> 00:04:58,890
బాగా, మొదటి, ఇది కోరుతూ
మీరు ఇన్పుట్ స్ట్రింగ్ పొందడానికి.

121
00:04:58,890 --> 00:05:00,439
మరియు అది క్షమించాలి, OH store-- ఉంటుంది.

122
00:05:00,439 --> 00:05:01,230
డేవిడ్ J. మలన్: సరే.

123
00:05:01,230 --> 00:05:01,730
గుడ్.

124
00:05:01,730 --> 00:05:03,330
మరియు ఈ ఏమి అంటారు?

125
00:05:03,330 --> 00:05:03,950
సరే, అవును.

126
00:05:03,950 --> 00:05:04,450
కొనసాగించడాన్ని.

127
00:05:04,450 --> 00:05:05,575
నేను అంతరాయం ఉద్దేశ్యం కాదు.

128
00:05:05,575 --> 00:05:07,060
Janelle: క్షమించండి.

129
00:05:07,060 --> 00:05:14,237
కనుక ఇది ఇన్పుట్ లోకి చేస్తాను
చిరునామా ఖచ్చితంగా కాదు of--.

130
00:05:14,237 --> 00:05:17,320
నేను ఖచ్చితంగా సంఖ్య గుర్తులేకపోతే,
కానీ నేను అది 0 తో మొదలు నమ్ముతారు.

131
00:05:17,320 --> 00:05:18,420
>> డేవిడ్ J. మలన్: ఆ, అన్ని కుడి వార్తలు
నేను సంఖ్యలు అప్ యుంటారు

132
00:05:18,420 --> 00:05:19,650
కాబట్టి ఎటువంటి హక్కు సమాధానం ఉంది.

133
00:05:19,650 --> 00:05:22,105
>> Janelle: 0 ఆర్క్ ప్రారంభిస్తోంది.

134
00:05:22,105 --> 00:05:24,000
>> డేవిడ్ J. మలన్: సరే, అందువలన మూలకం 0.

135
00:05:24,000 --> 00:05:24,765
షూర్.

136
00:05:24,765 --> 00:05:28,295
>> Janelle: ఆపై ఉంటే
కేవలం రెండు letter-- వంటి

137
00:05:28,295 --> 00:05:30,496
>> డేవిడ్ J. మలన్: సరే, మీరు తిరిగి.

138
00:05:30,496 --> 00:05:33,629
>> Janelle: సో మూలకం 0, మరియు
అప్పుడు మూలకం 1 లేదా మూలకం 2.

139
00:05:33,629 --> 00:05:36,670
ఇది భాగం యొక్క మరియు: డేవిడ్ J. మలన్
చిత్రాన్ని మీరు ప్రస్తుతం గీస్తున్నారు?

140
00:05:36,670 --> 00:05:37,690
getString పిలుపు?

141
00:05:37,690 --> 00:05:38,830
లేదా S యొక్క ప్రకటన?

142
00:05:38,830 --> 00:05:42,890
>> Janelle నిర్దారణ
s యొక్క, నేను నమ్మకం.

143
00:05:42,890 --> 00:05:45,980
ఓహ్, GetString, అది ఎందుకంటే
ప్రతి [లోకి ఇన్పుట్ అవుతుంది? ప్రాంతం. ?]

144
00:05:45,980 --> 00:05:46,510
>> డేవిడ్ J. మలన్: గుడ్.

145
00:05:46,510 --> 00:05:47,051
సరిగ్గా.

146
00:05:47,051 --> 00:05:49,300
కూడా ఈ సమర్థవంతంగా అయితే
వ్యూహం, రీకాల్ తిరిగి,

147
00:05:49,300 --> 00:05:53,300
మేము ఒక స్ట్రింగ్ తిరిగి వచ్చినప్పుడు, మేము చెయ్యవచ్చు
01 మరియు 2 ఉపయోగించి ఆ స్ట్రింగ్ లోకి సూచిక.

148
00:05:53,300 --> 00:05:56,180
సాంకేతికంగా, ఈ బహుశా ఉంటాయి
వ్యక్తిగత చిరునామాలు ప్రాతినిధ్యం,

149
00:05:56,180 --> 00:05:57,100
కానీ ఆ మంచిది.

150
00:05:57,100 --> 00:06:00,170
>> కాబట్టి, ఊహించు ఉంటే నేను కేవలం ఫాస్ట్
మేము వదిలి పేరు ముందుకు

151
00:06:00,170 --> 00:06:04,320
చివరిసారి, ఒకటి ఉంటే
తీగలను, ఒక బి ఇ గ్రా ఉంది

152
00:06:04,320 --> 00:06:10,337
బాక్ స్లాష్ 0, తద్వారా ప్రాతినిధ్యం గాబే యొక్క
ఇన్పుట్, ఎలా మేము ఇప్పుడు ప్రతిఫలించే?

153
00:06:10,337 --> 00:06:12,670
అన్నారు ఆ మెమరీ ఉంటే
getString ద్వారా తిరిగి?

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> Janelle: ఇది ఉంటుందా
ఒక ఆర్క్ ద్వారా ప్రాతినిధ్యం?

156
00:06:17,610 --> 00:06:18,750
>> డేవిడ్ J. మలన్: ఒక ఆర్క్ ద్వారా?

157
00:06:18,750 --> 00:06:19,130
Well, ఏ.

158
00:06:19,130 --> 00:06:21,171
, యొక్క కేవలం చిత్రాల చెబుతారు
నాకు ముందుకు వెళ్లి తెలియజేయండి

159
00:06:21,171 --> 00:06:25,710
ఈ లు ఉంటే, ఈ ప్రతిపాదించారు
GetString తిరిగి విలువ.

160
00:06:25,710 --> 00:06:29,482
మరియు మీరు 0, 1, 2, ఈ డ్రా చేసిన
, ఖచ్చితంగా మంచిది మేము ఎందుకంటే

161
00:06:29,482 --> 00:06:30,940
వంటి స్ట్రింగ్ లోకి ఇండెక్స్, చెయ్యవచ్చు.

162
00:06:30,940 --> 00:06:33,340
కానీ కేవలం స్థిరంగా ఉండాలి
చివరిసారి, నాకు ముందుకు తెలియజేయండి

163
00:06:33,340 --> 00:06:37,310
మరియు ఏకపక్ష ఈ ప్రతిపాదించారు
చిరునామా 1, ఈ చిరునామా, 2

164
00:06:37,310 --> 00:06:39,597
ఈ మొదలైనవి చిరునామా 3, మరియు.

165
00:06:39,597 --> 00:06:41,430
కాబట్టి, కేవలం సూపర్ ఉండాలి
స్పష్టమైన, ఏమి జరగబోతోంది

166
00:06:41,430 --> 00:06:44,580
ఆ ఫలితంగా లు వెళ్లాల్సి
కోడ్ మొదటి లైన్, మీరు చెబుతా?

167
00:06:44,580 --> 00:06:45,420
>> Janelle: చిరునామా 1?

168
00:06:45,420 --> 00:06:46,420
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

169
00:06:46,420 --> 00:06:47,190
కాబట్టి 0x1 పరిష్కరించారని.

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
మరియు అదే సమయంలో, నాకు ముందుకు తెలియజేయండి మరియు
మీరు చేసిన ఏ చాలా నకిలీ

172
00:06:51,230 --> 00:06:52,740
మరియు ఇక్కడ నా సొంత T జోడించండి.

173
00:06:52,740 --> 00:06:56,340
నేను గాబే లో టైప్ ఉంటే
మళ్ళీ రెండవసారి,

174
00:06:56,340 --> 00:07:01,530
GetString తో ప్రాంప్ట్ ఎప్పుడు, ఎక్కడ,
కోర్సు యొక్క, గాబే గో అన్నారు?

175
00:07:01,530 --> 00:07:02,280
వెల్, presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> Janelle: ఇక్కడ ఇలా?

178
00:07:05,975 --> 00:07:06,850
డేవిడ్ J. మలన్: అవును.

179
00:07:06,850 --> 00:07:08,516
Janelle: లేదా ఒకే బాక్సులను లో కూడా?

180
00:07:08,516 --> 00:07:11,940
డేవిడ్ J. మలన్: నాకు అవును, ప్రపోజ్ లెట్
సరిగ్గా ఈ అదనపు బాక్సులను కాబట్టి.

181
00:07:11,940 --> 00:07:15,230
కానీ ఇప్పుడు కీ కూడా, అని
నేను ఈ అందంగా దగ్గరగా డ్రా చేసిన అయితే

182
00:07:15,230 --> 00:07:18,650
together-- 0x1, ఈ
వాస్తవానికి 0x2-- ఉంది,

183
00:07:18,650 --> 00:07:25,750
ఈ ఇప్పుడు, చిరునామా 0x10 కావచ్చు
ఉదాహరణకు, మరియు 0x11, మరియు 0x12,

184
00:07:25,750 --> 00:07:26,870
మొదలగునవి.

185
00:07:26,870 --> 00:07:29,955
కాబట్టి, ఒకవేళ,
ఎంచు లో ఇక్కడ ముగుస్తుంది జరగబోతోంది?

186
00:07:29,955 --> 00:07:30,830
>> Janelle: 0x10?

187
00:07:30,830 --> 00:07:31,830
డేవిడ్ J. మలన్: ఖచ్చితంగా.

188
00:07:31,830 --> 00:07:33,180
కాబట్టి 0x10.

189
00:07:33,180 --> 00:07:34,570
కాబట్టి ఇప్పుడు, చివరి ప్రశ్న.

190
00:07:34,570 --> 00:07:37,510
మీరు చాలా ద్వారా, పని కలిగి
ఇప్పటివరకు ఒక ఏనుగు కోసం కష్టతరమైన.

191
00:07:37,510 --> 00:07:42,650
ఇప్పుడు ద్వారా, నేను కోడ్ పుల్ అప్ ఉంటే
మళ్ళీ, నేను చేస్తే, లైన్ మూడుసార్లు,

192
00:07:42,650 --> 00:07:47,630
లు సమానం T సమానం ఉంటే, నేను నిజానికి ఏమి am
మేము ఇక్కడ డ్రా చేసిన పోల్చడం ఆ?

193
00:07:47,630 --> 00:07:49,271
>> Janelle: రెండు చిరునామాలు?

194
00:07:49,271 --> 00:07:50,270
డేవిడ్ J. మలన్: ఖచ్చితంగా.

195
00:07:50,270 --> 00:07:53,350
కాబట్టి నేను t సమానంగా సమానం చెప్పడం?

196
00:07:53,350 --> 00:07:56,210
ఇతర మాటలలో, 10 సమానం సమానం 1?

197
00:07:56,210 --> 00:07:59,710
మరియు కోర్సు యొక్క,
స్పష్టమైన సమాధానం ఇప్పుడు ఏ ఉంది.

198
00:07:59,710 --> 00:08:02,920
కాబట్టి ఈ ప్రోగ్రామ్ అంతిమంగా
మీరు చెప్పే, ఏమి ప్రింట్ అన్నారు?

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> Janelle: ఇది ఉంటుందా
మీరు అదే పని టైప్?

201
00:08:08,405 --> 00:08:11,446
>> డేవిడ్ J. మలన్: చేస్తే
లు 1 మరియు T 10?

202
00:08:11,446 --> 00:08:13,320
>> Janelle: మీరు వివిధ విషయాలను టైప్.

203
00:08:13,320 --> 00:08:13,570
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

204
00:08:13,570 --> 00:08:14,480
మీరు వివిధ విషయాలను టైప్.

205
00:08:14,480 --> 00:08:14,850
అన్ని కుడి.

206
00:08:14,850 --> 00:08:16,714
కాబట్టి చప్పట్లు ఒక రౌండ్,
ఇక్కడ, మేము అనుకొనుట ఉంటే.

207
00:08:16,714 --> 00:08:17,214
[చప్పట్లు]

208
00:08:17,214 --> 00:08:17,708
ఆ బాధాకరమైన ఉంది.

209
00:08:17,708 --> 00:08:18,208
నేను తెలుసు.

210
00:08:18,208 --> 00:08:19,684
చక్కగా పూర్తి.

211
00:08:19,684 --> 00:08:24,690
కాబట్టి ఇప్పుడు యొక్క చూసేలా ఉంటే మేము కాదు
పరిష్కారము ఏమి వేరుగా బాధించటం.

212
00:08:24,690 --> 00:08:28,040
మరియు కోర్సు యొక్క, మేము ఉండాలి ఈ స్థిర
ఇది నేను ఇప్పుడు green-- లో ప్రాతినిధ్యం చేస్తాము

213
00:08:28,040 --> 00:08:29,690
మేము ఇక్కడ విస్తరింపులను జంట చేశాడు.

214
00:08:29,690 --> 00:08:32,409
మొదటి, కేవలం ఒక తెలివి గా
నేను మొదటి తనిఖీ చేస్తున్నాను, తనిఖీ

215
00:08:32,409 --> 00:08:35,110
లు శూన్య సమానం మరియు t శూన్య సమానం.

216
00:08:35,110 --> 00:08:39,440
మరియు కేవలం స్పష్టతను, ఉన్నప్పుడు కలిగింది
s లేదా t ఈ వంటి కోడ్ శూన్య ఉంటుంది?

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
చేసినప్పుడు లేదా t శూన్య కావచ్చు.

219
00:08:44,490 --> 00:08:44,990
అవును?

220
00:08:44,990 --> 00:08:45,990
>> ప్రేక్షకులు: [వినబడని].

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

223
00:08:50,510 --> 00:08:52,840
స్ట్రింగ్ వినియోగదారు ఉంటే
లో టైప్ మార్గం చాలా పొడవుగా ఉంది

224
00:08:52,840 --> 00:08:56,140
మెమరీ లోకి సరిపోయే, లేదా కొన్ని
ఆ వంటి అసహజ మూలలో కేసు

225
00:08:56,140 --> 00:08:59,010
మేము చూస్తారు వంటి వాచ్యంగా, GetString
నేడు, దాని డాక్యుమెంటేషన్,

226
00:08:59,010 --> 00:09:02,330
అది శూన్య తిరిగి చెబుతాడు
ఒక ప్రత్యేక కాపలాదారుడు విలువ,

227
00:09:02,330 --> 00:09:05,417
లేదా కేవలం విధమైన ప్రత్యేక చిహ్నం
ఏదో తప్పు జరిగింది అర్థం.

228
00:09:05,417 --> 00:09:07,500
అందుకని మనం చెక్ అనుకుంటున్నారా
అది అవుతుంది ఎందుకంటే, ఆ

229
00:09:07,500 --> 00:09:09,720
ఆ శూన్య చాలా ప్రమాదకరమైన విలువ ఉంది.

230
00:09:09,720 --> 00:09:14,250
>> తరచుగా, మీరు ఏదో ఒకటి చేయాలని ప్రయత్నిస్తే
శూన్య ప్రయాణిస్తున్న ఒక ఫంక్షన్ పాల్గొన్న

231
00:09:14,250 --> 00:09:17,470
ఇన్పుట్ వంటి, ఆ ఫంక్షన్ instance-- కోసం
చాలా దానితో, క్రాష్ మరియు ఉండవచ్చు,

232
00:09:17,470 --> 00:09:19,090
మీ మొత్తం కార్యక్రమాన్ని డౌన్ పడుతుంది.

233
00:09:19,090 --> 00:09:22,570
కాబట్టి ఈ మూడవ లైన్ ఇప్పుడు తెలివి ఉంది
మీరు రెడీ ఉంటే, దోష పరిశీలన తనిఖీ.

234
00:09:22,570 --> 00:09:25,450
ఆ కోసం ఇప్పుడు ఒక మంచి అలవాటు ఉంది
మాకు ఏ సమయంలో పొందడానికి మేము

235
00:09:25,450 --> 00:09:28,050
ఒక విలువ ఉపయోగించడానికి ప్రయత్నించండి
, సమర్థవంతంగా, శూన్య కావచ్చు.

236
00:09:28,050 --> 00:09:32,000
>> ఇప్పుడు, ఇక్కడ నాలుగవ లైన్ లో,
"ఉంటే strcmp (s, t)" అలాగే,

237
00:09:32,000 --> 00:09:33,180
వాటిని సూచించే ఆ?

238
00:09:33,180 --> 00:09:36,750
Well, మేము ఈ చాలా క్లుప్తమైన ఒక చెప్పాడు
స్ట్రింగ్ పోలిక కోసం అనే ఫంక్షన్.

239
00:09:36,750 --> 00:09:40,370
మరియు జీవితం లో ప్రయోజనం పోల్చడం
రెండవ అది వ్యతిరేకంగా మొదటి వాదన,

240
00:09:40,370 --> 00:09:44,640
కానీ వారి చిరునామాలు పరంగా,
మేము ఒక క్షణం అనుకోకుండా వలె

241
00:09:44,640 --> 00:09:48,270
క్రితం ఎరుపు కోడ్ తో, కానీ
కాకుండా ఆ రెండు పోల్చడానికి

242
00:09:48,270 --> 00:09:53,210
మనిషిలా సహజమైన తీగలను
దీనితోపాటుగా ఈ పోల్చడం ద్వారా మార్గం,

243
00:09:53,210 --> 00:09:56,690
ఈ, వ్యతిరేకంగా, మరియు వ్యతిరేకంగా
అప్పుడు ఆపటం ఉన్నప్పుడు ఒక ఉంటే

244
00:09:56,690 --> 00:09:59,590
లేదా నా వేళ్ళు రెండు
ఒక బాక్ స్లాష్ 0 హిట్స్.

245
00:09:59,590 --> 00:10:04,530
కాబట్టి ఎవరైనా సంవత్సరాల క్రితం అమలు strcmp
కార్యాచరణ మాకు అమలు

246
00:10:04,530 --> 00:10:08,890
మేము ఉండాల్సిందని ఆశించాను
కేవలం రెండు సాధారణ విలువలు పోల్చడం ద్వారా.

247
00:10:08,890 --> 00:10:14,929
>> ఇప్పుడు స్పష్టముగా, నేను డ్రాయింగ్ ఉంచడానికి
ఈ వివిధ సంఖ్యల అన్ని.

248
00:10:14,929 --> 00:10:17,470
కానీ వాస్తవంలో నేను ఉన్నాను, ఉంది
మొత్తం సమయం ఈ ముందుకెళ్లి.

249
00:10:17,470 --> 00:10:19,580
కాబట్టి నాకు ముందుకు వెళ్లి తెలియజేయండి
మరియు ఈ అవ్ట్ ని

250
00:10:19,580 --> 00:10:23,100
ఒక పాయింట్ చేయడానికి, చివర
రోజు మరియు ముందుకు వెళ్లడానికి,

251
00:10:23,100 --> 00:10:30,160
మేము నిజంగా శ్రద్ధ వెళ్ళడం లేదు చేస్తున్నాం
ఏమి విషయాలు నిజానికి ఉన్నాయి చిరునామాలు

252
00:10:30,160 --> 00:10:30,790
మెమరీలో.

253
00:10:30,790 --> 00:10:34,320
కాబట్టి నేను ఈ డ్రా వెళుతున్న కాదు
చాలా ఇకపై సంఖ్యలు రకాల

254
00:10:34,320 --> 00:10:38,970
నేను దూరంగా ఈ కేవలం ఒక నైరూప్య ఉన్నాను
కేవలం బాణాలు తో మరింత స్నేహపూర్వక కొద్దిగా.

255
00:10:38,970 --> 00:10:42,060
>> ఇతర మాటలలో, ఒక పాయింటర్ ఉంటే,
బాగా, యొక్క కేవలం సాహిత్యపరంగా, అది డ్రా తెలియజేయండి

256
00:10:42,060 --> 00:10:45,430
ఒక పాయింటర్ గా, ఒక బాణంతో
, ఏదో నుండే

257
00:10:45,430 --> 00:10:48,280
మరియు గురించి చాలా ఎక్కువ చింతించకండి
ఈ అడ్రస్ల minutia

258
00:10:48,280 --> 00:10:49,910
ఇది మళ్ళీ, నేను ఏమైనప్పటికీ తయారు.

259
00:10:49,910 --> 00:10:52,680
కానీ మేము ఆ చిరునామాలను చూస్తారు,
కొన్నిసార్లు కోడ్ డీబగ్గింగ్ చేసేటప్పుడు అధికం.

260
00:10:52,680 --> 00:10:56,450
>> ఇప్పుడు అదే సమయంలో, ఈ కార్యక్రమం
ఇక్కడ పరిష్కారాలను, కోర్సు యొక్క,

261
00:10:56,450 --> 00:10:58,720
పోల్చడం ద్వారా ఆ సమస్య
ఆ రెండు తీగలను.

262
00:10:58,720 --> 00:11:00,260
కానీ మేము మరొక సమస్య పడింది.

263
00:11:00,260 --> 00:11:03,180
ఈ కాపీ నుండి ఉంది
గత టైం ప్రోగ్రాం

264
00:11:03,180 --> 00:11:06,880
అనగా, నేను పెట్టుబడిగా ప్రయత్నిస్తున్నప్పుడు
ఒక స్ట్రింగ్ కేవలం మొదటి పాత్ర.

265
00:11:06,880 --> 00:11:09,620
కానీ లక్షణం ఏమిటి
మేము చివరిసారి చూసిన

266
00:11:09,620 --> 00:11:14,150
ఒక వినియోగదారు వంటి, ఒక విలువ లో టైప్
చిన్న లో గాబే, s కోసం,

267
00:11:14,150 --> 00:11:19,310
అప్పుడు మేము, T లోకి లు కేటాయించిన
అక్కడ మూడో వరుసలో ఉండటం,

268
00:11:19,310 --> 00:11:22,900
ఆపై నేను ప్రయత్నించారు
T బ్రాకెట్ 0 చూపడంలో?

269
00:11:22,900 --> 00:11:25,950
ప్రభావం ఏమిటి
T బ్రాకెట్ 0 ఇక్కడ మారుతున్న?

270
00:11:25,950 --> 00:11:27,150
>> ప్రేక్షకులు: ఇది s కు మార్చబడింది.

271
00:11:27,150 --> 00:11:29,360
>> డేవిడ్ J. మలన్: అవును,
నేను అలాగే, s కు మార్చబడింది.

272
00:11:29,360 --> 00:11:31,050
నిజంగా జరుగుతుందో ఏమి ఎందుకంటే?

273
00:11:31,050 --> 00:11:34,130
Well, నేను శుభ్రం చేయవచ్చు ఉంటే నాకు చూద్దాము
ఈ చిత్రాన్ని అప్, వంటి అనుసరిస్తుంది.

274
00:11:34,130 --> 00:11:41,390
>> లు ఉంటే, మళ్ళీ, పదం గ్రా,
ఒక, B, E, బాక్ స్లాష్, 0, మరియు లు

275
00:11:41,390 --> 00:11:44,084
మేము ఒక బాక్స్ డ్రాయింగ్ చేస్తాము
ఇక్కడ, అయితే మరింత చిరునామాలు.

276
00:11:44,084 --> 00:11:45,250
యొక్క విషయాలు అప్ స్టాప్ మేకింగ్ లెట్.

277
00:11:45,250 --> 00:11:47,510
యొక్క కేవలం ఒక చిత్రాన్ని డ్రా లెట్
ప్రపంచంలో సులభతరం.

278
00:11:47,510 --> 00:11:52,640
>> నేను స్ట్రింగ్ t తో t డిక్లేర్ చేసినప్పుడు,
మెమరీ ఆ భాగం సృష్టిస్తుంది.

279
00:11:52,640 --> 00:11:55,850
స్క్వేర్ 32 నిర్మాణము
చాలా కంప్యూటర్లు బిట్స్.

280
00:11:55,850 --> 00:11:59,530
నిజానికి, మీరు ఎప్పుడైనా ఒక విన్న చేసిన
కంప్యూటర్, ఒక 32-bit నిర్మాణం కలిగి

281
00:11:59,530 --> 00:12:03,000
నిజంగా ఫాన్సీ-మాట్లాడటం, కేవలం
ఇది 32 బిట్ అడ్రస్లను ఉపయోగిస్తుంది అర్థం.

282
00:12:03,000 --> 00:12:05,370
పక్కన సాంకేతిక,
మీరు ఆలోచిస్తున్నారా చేసిన ఉంటే

283
00:12:05,370 --> 00:12:09,630
ఎందుకు పాత కంప్యూటర్లు, నిజానికి మీరు ఉంటే
RAM యొక్క మా తో సూప్ వాటిని అప్ ప్రయత్నించారు,

284
00:12:09,630 --> 00:12:12,360
మాత్రమే గరిష్టంగా కలిగి ఉంటుంది
RAM నాలుగు గిగాబైట్ల,

285
00:12:12,360 --> 00:12:14,860
అలాగే ఆ వాచ్యంగా, ఎందుకంటే,
మీ పాత కంప్యూటర్లో అనుకొనుట మాత్రమే

286
00:12:14,860 --> 00:12:17,250
4 వంటి అధిక లెక్కింపు
బిలియన్, 4 బిలియన్ బైట్లు,

287
00:12:17,250 --> 00:12:20,590
ఇది ఎందుకంటే 32-bit ఉపయోగించి జరిగినది
చిరునామాలకు సంఖ్యలు.

288
00:12:20,590 --> 00:12:23,260
>> కానీ ఏ సందర్భంలో, ఈ
ఉదాహరణకు, కథ యొక్క అతి సాధారణ చేస్తుంది.

289
00:12:23,260 --> 00:12:27,250
t కేవలం మరొక పాయింటర్ ఉంది, లేదా
నిజంగా ఒక చార్ స్టార్, ఆక స్ట్రింగ్.

290
00:12:27,250 --> 00:12:30,860
మరియు ఎలా నేను ఈ చిత్రాన్ని అప్డేట్ అనుకుంటున్నారు
ఇప్పుడు కోడ్ రెండవ లైన్ తో,

291
00:12:30,860 --> 00:12:31,950
డాట్ తర్వాత, డాట్, డాట్?

292
00:12:31,950 --> 00:12:35,845
నేను చేసినప్పుడు స్ట్రింగ్ t, లు సెమికోలన్ సమానం
ఈ చిత్రాన్ని ఎలా మార్చదు?

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
అవును?

295
00:12:38,000 --> 00:12:38,916
>> ప్రేక్షకులు: [వినబడని].

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> డేవిడ్ J. మలన్: అవును.

298
00:12:42,020 --> 00:12:42,600
సరిగ్గా.

299
00:12:42,600 --> 00:12:45,620
నేను నుండి ఒక బాణం పెట్టి
అదే చిరునామాకు T బాక్స్,

300
00:12:45,620 --> 00:12:47,570
లో అదే మొదటి లేఖ ఇచ్చారు.

301
00:12:47,570 --> 00:12:50,850
లేదా సాంకేతికంగా, ఈ
గై, 0x1 లోనే ఉన్నారు

302
00:12:50,850 --> 00:12:53,052
నేను కలిగి అయితే ఉంది
ఇక్కడ 0x1 మరియు ఇక్కడ 0x1.

303
00:12:53,052 --> 00:12:54,760
కానీ మళ్ళీ, ఎవరు పట్టించుకుంటారు
చిరునామాలు గురించి?

304
00:12:54,760 --> 00:12:56,345
ఇది ఇప్పుడు ఆ విషయాలను కేవలం ఆలోచన.

305
00:12:56,345 --> 00:12:57,720
కాబట్టి ఈ ఇక్కడ జరుగుతున్నది ఏమిటి.

306
00:12:57,720 --> 00:13:02,690
కోర్సు యొక్క, మీరు t ఉంటే బ్రాకెట్ కాబట్టి
శ్రేణి సంజ్ఞామానం ఇది 0,

307
00:13:02,690 --> 00:13:05,650
యొక్క కోర్సులో మరియు స్పష్టముగా, అది కనిపిస్తుంది
ఇక్కడ పైగా వ్యూహం ఉన్నట్లు,

308
00:13:05,650 --> 00:13:07,340
కానీ ఇప్పుడు ఈ విచిత్రమైన విషయం ఉంది.

309
00:13:07,340 --> 00:13:11,160
ప్రోగ్రామింగ్ భాష తెలిసిన,
సి, మీరు ఈ లక్షణం అందిస్తుంది

310
00:13:11,160 --> 00:13:14,650
అనగా, t ఒక పోయినప్పటికీ
పాయింటర్, లేదా ఒక పాయింటర్ ఉంది,

311
00:13:14,650 --> 00:13:18,050
మీరు ఇప్పటికీ, తెలిసిన ఉపయోగించవచ్చు
సౌకర్యవంతమైన చదరపు బ్రాకెట్

312
00:13:18,050 --> 00:13:22,520
సంజ్ఞామానం మొదటి మూలకం వెళ్ళడానికి,
రెండవ మూలకం, లేదా ఏ మూలకం లేదా

313
00:13:22,520 --> 00:13:26,130
ఆ పాయింటర్ సూచించబడిన ఆ
బహుశా, ఎందుకంటే, అది

314
00:13:26,130 --> 00:13:29,410
ఈ సందర్భంలో, ఉంది
కొన్ని శ్రేణి వద్ద గురిపెట్టి.

315
00:13:29,410 --> 00:13:30,340
>> సో ఎలా మేము ఈ పరిష్కరించాలి?

316
00:13:30,340 --> 00:13:33,660
అది ఒక వచ్చింది పేరు స్పష్టముగా, ఈ ఉంది
మొదటి చూపులో కొద్దిగా అధిక.

317
00:13:33,660 --> 00:13:35,340
కానీ ఇక్కడ ఒక కొత్త మరియు మెరుగైన వెర్షన్.

318
00:13:35,340 --> 00:13:37,460
>> కాబట్టి మొదటి, నేను పొందుతున్నాను
CS50 లైబ్రరీ యొక్క వదులుకొను,

319
00:13:37,460 --> 00:13:41,170
కేవలం నిజానికి ఆ s ఉంది బహిర్గతం
ఒక చార్ స్టార్, కేవలం ఒక పర్యాయపదంగా.

320
00:13:41,170 --> 00:13:43,540
మరియు t కూడా ఒక చార్ నక్షత్రం.

321
00:13:43,540 --> 00:13:48,290
కానీ మీద ఏమి జరుగుతుందో ఏమి
ఆ మార్గం యొక్క కుడి చేతి వైపు

322
00:13:48,290 --> 00:13:49,970
t ఒక విలువ కేటాయించిన ఎక్కడ?

323
00:13:49,970 --> 00:13:50,790
>> Malloc అంటే ఏమిటి?

324
00:13:50,790 --> 00:13:51,630
ఇది ఏమిటి strlen యొక్క?

325
00:13:51,630 --> 00:13:52,547
Sizeof (చార్) అంటే ఏమిటి?

326
00:13:52,547 --> 00:13:54,380
ఎందుకు హెక్ చేస్తుంది
లైన్ లుక్ కాబట్టి క్లిష్టమైన?

327
00:13:54,380 --> 00:13:55,713
ఏం ఒక అధిక స్థాయిలో చేస్తోంది?

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
ఏం అది T లో నిల్వ?

330
00:13:57,440 --> 00:13:58,646
అవును?

331
00:13:58,646 --> 00:14:01,104
ప్రేక్షకులు: ఇది కేటాయించడం యొక్క ఒక
మెమరీని యొక్క నిర్దిష్ట మొత్తం.

332
00:14:01,104 --> 00:14:03,032
ఇది నిల్వ వార్తలు, నేను ఊహిస్తున్నాను
అక్షరాలు [వినబడని].

333
00:14:03,032 --> 00:14:04,032
>> డేవిడ్ J. మలన్: పర్ఫెక్ట్.

334
00:14:04,032 --> 00:14:04,540
పర్ఫెక్ట్.

335
00:14:04,540 --> 00:14:06,650
ఇది ఒక నిర్దిష్ట కేటాయించడం యొక్క
మెమరీని యొక్క మొత్తం

336
00:14:06,650 --> 00:14:08,940
బహుశా, భవిష్యత్ అక్షరాలు నిల్వ.

337
00:14:08,940 --> 00:14:11,310
మరియు ముఖ్యంగా, malloc
అందువలన ఏమి తిరిగి?

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> ప్రేక్షకులు: [వినబడని] తిరిగి?

340
00:14:14,851 --> 00:14:15,850
డేవిడ్ J. మలన్: ఖచ్చితంగా.

341
00:14:15,850 --> 00:14:18,850
మెమరీ చిరునామా సాధించాక,
ఇది చెప్పడం ఒక ఫాన్సీ మార్గం

342
00:14:18,850 --> 00:14:21,640
యొక్క చిరునామా తిరిగి
ఆ మెమరీ మొదటి బైట్.

343
00:14:21,640 --> 00:14:25,460
నన్ను గుర్తుంచుకోవడానికి న జవాబుదారి ఉంది
ఎంత మెమరీ నేను నిజానికి

344
00:14:25,460 --> 00:14:27,140
కేటాయించింది లేదా కొరకు malloc కోరారు.

345
00:14:27,140 --> 00:14:28,384
>> ఇప్పుడు ఎంత ఉంది?

346
00:14:28,384 --> 00:14:30,550
Well, అక్కడ అయినప్పటికీ
ఇక్కడ కుండలీకరణాలు చాలా,

347
00:14:30,550 --> 00:14:32,970
malloc కేవలం ఒక వాదన పడుతుంది.

348
00:14:32,970 --> 00:14:37,250
మరియు నేను యొక్క strlen పేర్కొనడం, కాబట్టి ఇవ్వాలని చేస్తున్నాను
నాకు అనేక బైట్లు లు ఉన్నాయి గా,

349
00:14:37,250 --> 00:14:37,800
కానీ ఒక జోడించండి.

350
00:14:37,800 --> 00:14:38,300
ఎందుకు?

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
అవును?

353
00:14:39,530 --> 00:14:40,840
>> ప్రేక్షకులు బ్యాక్స్లాష్ 0.

354
00:14:40,840 --> 00:14:41,840
డేవిడ్ J. మలన్: ఖచ్చితంగా.

355
00:14:41,840 --> 00:14:43,423
మేము ఒక చిన్న హౌస్ కీపింగ్ చేయడానికి పొందారు.

356
00:14:43,423 --> 00:14:45,970
ఒక బాక్ స్లాష్ ఉంది కనుక అలా
0, మేము మంచి గుర్తుంచుకోవాలి ఇష్టం.

357
00:14:45,970 --> 00:14:47,310
లేకపోతే, మేము చేయబోతున్నామని
ఒక స్ట్రింగ్ రూపొందించడానికి ఆ

358
00:14:47,310 --> 00:14:49,170
ప్రత్యేక టెర్మినేటర్ లేదు.

359
00:14:49,170 --> 00:14:52,640
>> ఇంతలో, కేవలం సూపర్ ఉండాలి
అంగ, నేను, sizeof (చార్) కలిగి

360
00:14:52,640 --> 00:14:55,730
కేవలం సందర్భంలో ఎవరైనా నా నడుస్తుంది
కాదు CS50 ఉపకరణం కోడ్,

361
00:14:55,730 --> 00:14:58,220
కానీ బహుశా వేరే కంప్యూటర్
మొత్తంగా పేరు అక్షరాలు

362
00:14:58,220 --> 00:15:01,470
సాంప్రదాయకంగా, ఒక బైట్ ఉంటాయి, కాని రెండు
బైట్లు, లేదా కంటే పెద్ద ఏదో.

363
00:15:01,470 --> 00:15:04,490
ఇది కేవలం సూపర్ వెయ్యబడింది,
లోపాలు సూపర్ విముఖత.

364
00:15:04,490 --> 00:15:06,940
అయినప్పటికీ, నిజానికి ఇది వార్తలు
ఎక్కువగా ఒక 1 చేస్తాడు.

365
00:15:06,940 --> 00:15:11,490
>> ఇప్పుడు, మరోవైపు, నేను ముందుకు వెళ్లి కాపీ
స్ట్రింగ్, T బ్రాకెట్ నేను T బ్రాకెట్ లు సమానం.

366
00:15:11,490 --> 00:15:14,962
నేను గత వారం యొక్క వాయిదా
సోర్స్ కోడ్ జరగబోతోంది ఏమి చూడటానికి.

367
00:15:14,962 --> 00:15:17,670
కీ takeaway, మరియు కాని
కారణం నేను, గ్రీన్ ఇప్పుడు కోడ్ను ఉంచాలి

368
00:15:17,670 --> 00:15:22,520
, చాలా చివరి లైన్ ఎందుకంటే
T బ్రాకెట్ 0, toupper సమానం

369
00:15:22,520 --> 00:15:25,230
ప్రభావం
కోరుతాయి స్ట్రింగ్?

370
00:15:25,230 --> 00:15:26,960
t మరియు / లేదా s?

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
కోడ్ యొక్క చివరి పంక్తి.

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> ఏమి ఎందుకంటే జస్ట్, T
ఈ సమయంలో జరిగింది

375
00:15:35,560 --> 00:15:41,500
నేను కొద్దిగా ఆ చివరి దశలో దిద్దుబాటు రద్దుచెయ్యి ఉంటే,
నేను malloc కాల్ చేసినప్పుడు, ఏమి హాపెండ్ లో

376
00:15:41,500 --> 00:15:45,380
నేను తప్పనిసరిగా మెమరీ భాగం పొందండి
అసలు అదే పరిమాణం,

377
00:15:45,380 --> 00:15:47,020
అంకగణితం ఎందుకంటే నేను చేసింది.

378
00:15:47,020 --> 00:15:50,920
నేను చిరునామా T లో నిల్వ చేస్తున్నాను
మెమరీ ఆ భాగం యొక్క.

379
00:15:50,920 --> 00:15:53,370
కూడా ఈ nice కనిపిస్తోంది అయితే
మరియు, అందంగా nice మరియు ఖాళీ,

380
00:15:53,370 --> 00:15:56,882
ఈ సంఘంలో ఏమి మేము చేస్తాము ఉంది ఉంది
ఇక్కడ, కాల్ చెత్త విలువలు ఉంచండి.

381
00:15:56,882 --> 00:15:59,340
మెమరీ ఆ భాగం వాటిని చాలా
అలాగే ముందు ఉపయోగిస్తున్నారు,

382
00:15:59,340 --> 00:16:00,940
కొన్ని సెకన్ల కొన్ని నిమిషాలు క్రితం.

383
00:16:00,940 --> 00:16:04,410
సో ఖచ్చితంగా సంఖ్యలు ఉండవచ్చు
కేవలం ప్రమాదంలో అక్కడ లేక అక్షరాలు.

384
00:16:04,410 --> 00:16:08,580
కానీ వారు నేను వరకు, చెల్లుబాటు కావు
నాకు మెమొరీ ఈ భాగం జనసాంద్రత

385
00:16:08,580 --> 00:16:12,510
అసలు అక్షరాలు, నేను
అక్కడ లూప్ అని చేయండి.

386
00:16:12,510 --> 00:16:13,180
అన్ని కుడి?

387
00:16:13,180 --> 00:16:16,180
>> కాబట్టి ఇప్పుడు, క్లైమాక్స్
ఈ మూడు ఉదాహరణలు

388
00:16:16,180 --> 00:16:20,730
అకారణంగా, చివరిసారి అధిగమించే
ఈ swap ఉదాహరణకు, ఈ ఫంక్షన్

389
00:16:20,730 --> 00:16:23,670
భావంలో పని
అది ఒక అండ్ బి మార్చుకున్నారు ఆ.

390
00:16:23,670 --> 00:16:25,620
కానీ ఏమిటి ఇతర అర్ధంలో లో పని చేయలేదు?

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
అవును?

393
00:16:28,614 --> 00:16:29,612
>> ప్రేక్షకులు: [వినబడని].

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

396
00:16:36,700 --> 00:16:39,530
నేను ఈ ఫంక్షన్ కాల్ చేస్తే
ఉదాహరణకు another-- నుండి,

397
00:16:39,530 --> 00:16:42,870
, పేరు ప్రధాన వంటి ఫంక్షన్ నుండి
నేను, ఒక వేరియబుల్, x మరియు y కలిగి

398
00:16:42,870 --> 00:16:46,160
గత వారం చేశాడు, అదే కోడ్,
నేను x మరియు y లో పాస్

399
00:16:46,160 --> 00:16:49,860
swap, ఆపై Swap-- ఈ కాల్,
కోర్సు యొక్క, సరైన వెర్షన్

400
00:16:49,860 --> 00:16:52,220
మేము చేయబోతున్నారు ఏమిటి
see-- అది పని చేయలేదు.

401
00:16:52,220 --> 00:16:53,770
కాబట్టి పరిష్కారము ఏమి ఉంది?

402
00:16:53,770 --> 00:16:56,850
>> Well, కాబట్టి కేవలం ఉండాలి
స్పష్టమైన, నాకు ముందుకు తెలియజేయండి

403
00:16:56,850 --> 00:17:05,450
మీరే ఇక్కడ రెండవ నాకే ఇవ్వాలని, మరియు చూడండి
నేను మీరు చివరి చూపవచ్చు ఉంటే

404
00:17:05,450 --> 00:17:12,464
నేను వెదుక్కోవచ్చు ఉంటే యొక్క చూసేలా in-- ఉంటుంది
ఈ నిజమైన fast-- సరే, [వినబడని].

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
సరే, అక్కడ అది.

407
00:17:19,240 --> 00:17:21,000
సో నేను టైప్ చేస్తున్నానని ఆదేశాలను పట్టించుకోకుండా.

408
00:17:21,000 --> 00:17:23,780
నేను వద్ద తిరిగి కావలసిన
చివరి నిమిషంలో ఒక ఉదాహరణ

409
00:17:23,780 --> 00:17:27,960
చివరిసారి నుండి ఇది
ఇప్పుడు ఏ స్వాప్ అంటారు.

410
00:17:27,960 --> 00:17:30,200
>> సో సంఖ్య మార్పిడి పేరు ఉంది
మేము చివరిసారి వదిలి

411
00:17:30,200 --> 00:17:32,930
అనగా, నేను initialized
1 x మరియు 2 కు y.

412
00:17:32,930 --> 00:17:35,840
నేను అప్పుడు 1 మరియు 2 లో ప్రయాణిస్తున్న, స్వాప్ కాల్.

413
00:17:35,840 --> 00:17:37,930
ఆపై ఈ ఫంక్షన్
కొన్ని భావంలో పని,

414
00:17:37,930 --> 00:17:40,750
కానీ అది ఎటువంటి శాశ్వత వచ్చింది
x మరియు y న ప్రభావితం.

415
00:17:40,750 --> 00:17:45,430
కాబట్టి చేతిలో ప్రశ్న ఎలా ఇప్పుడు,
మేము నిజానికి ఈ సమస్య పరిష్కరించాలి?

416
00:17:45,430 --> 00:17:47,820
చేతిలో పరిష్కారం ఏమిటి?

417
00:17:47,820 --> 00:17:53,150
>> Well, నేడు కొత్త ఉంది దీనిలో swap.c లో,
తేడాలు యొక్క ఒక జంట గమనించి.

418
00:17:53,150 --> 00:17:54,700
x మరియు y ఒకటే.

419
00:17:54,700 --> 00:17:57,250
కానీ ఏమి స్పష్టంగా ఉంది
లైన్ 25 గురించి వివిధ?

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
మీరు గుర్తు ఉంటే ఏమి, అక్కడ కొత్త వార్తలు
ఇది రెండవ క్రితం వంటి చూసారు ఏమి?

422
00:18:01,715 --> 00:18:02,565
>> ప్రేక్షకులు: [వినబడని].

423
00:18:02,565 --> 00:18:03,440
>> డేవిడ్ J. మలన్: అవును.

424
00:18:03,440 --> 00:18:06,680
కాబట్టి ampersands ఒక కొత్త ముక్క ఉన్నాయి
వాక్యనిర్మాణం యొక్క మాత్రమే ఈ కార్యక్రమం లో,

425
00:18:06,680 --> 00:18:08,560
కానీ కూడా మరింత సాధారణంగా CS50 లో.

426
00:18:08,560 --> 00:18:10,680
నేటికి, నేను భావించడం లేదు
మేము ఏ ఉదాహరణలు చూసిన

427
00:18:10,680 --> 00:18:14,070
లేదా నిజంగా ఏ వాటిని గురించి మాట్లాడారు
బహుశా, preemptively కంటే ఇతర వివరాలు,

428
00:18:14,070 --> 00:18:16,467
విభాగంలో, ఈ వంటి ఒక ఆంపర్సండ్ చిహ్నం.

429
00:18:16,467 --> 00:18:19,300
సరే, ఆంపర్సండ్ చిహ్నం ఒకటి అవుతుంది
కొత్త వాక్యనిర్మాణం యొక్క గత ముక్కలు

430
00:18:19,300 --> 00:18:20,174
మేము తెలుసుకోవడానికి చూడాలని.

431
00:18:20,174 --> 00:18:23,500
ఇది అర్థం అన్ని ఉంది
కొన్ని వేరియబుల్ చిరునామా.

432
00:18:23,500 --> 00:18:25,070
ఏమి చిరునామా వద్ద X నివసిస్తున్నారు లేదు?

433
00:18:25,070 --> 00:18:26,510
కానీ Y చిరునామా ఏమిటి లేదు?

434
00:18:26,510 --> 00:18:28,700
ఎందుకంటే
ముందు ప్రాథమిక సమస్య

435
00:18:28,700 --> 00:18:32,970
ఆ x మరియు y జారీ చేస్తున్నారు చేసింది
మేము నిజంగా చేయాలనుకుంటున్నారా ఏమి కాపీలు, వంటి

436
00:18:32,970 --> 00:18:38,780
ఒక నిధి వంటి తో Swap అందించడానికి ఉంది
ఇక్కడ x మరియు నిజానికి Y దారితీస్తుంది చిహ్నం

437
00:18:38,780 --> 00:18:41,910
కాబట్టి, RAM లో ఉన్నాయి
స్వాప్ మ్యాప్ అనుసరించండి

438
00:18:41,910 --> 00:18:47,760
X లేదా Y గుర్తులతో ఎక్కడికి మరియు వెళ్ళండి
మరియు వాస్తవ విలువలను మార్చడం 1 మరియు 2

439
00:18:47,760 --> 00:18:48,270
అక్కడ.

440
00:18:48,270 --> 00:18:50,710
>> కాబట్టి swap చాలా కొద్దిగా మార్చడానికి అవసరం.

441
00:18:50,710 --> 00:18:53,760
మరియు మొదటి చూపులో, ఈ మైట్
చార్ స్టార్ కొద్దిగా సమానంగా ఉన్నాయి.

442
00:18:53,760 --> 00:18:54,850
నిజానికి ఇది.

443
00:18:54,850 --> 00:18:59,635
కాబట్టి ఒక డేటా రకం ఒక పాయింటర్ ఉంది,
ఈ హైలైట్ భాగం ఆధారంగా?

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
కనుక ఇది ఒక పూర్ణాంకానికి ఉంది.

446
00:19:01,620 --> 00:19:04,880
>> కాబట్టి ఒక ఇకపై ఒక Int,
అది ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంది.

447
00:19:04,880 --> 00:19:07,910
మరియు అలాగే, బి ఇప్పుడు అన్నారు
ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంటుంది.

448
00:19:07,910 --> 00:19:12,470
నేను ఇప్పుడు ప్రధాన నుండి స్వాప్ కాల్ చేసినప్పుడు,
నేను swap 1 మరియు 2 ఇస్తాయి వెళుతున్న కాదు.

449
00:19:12,470 --> 00:19:15,540
నేను వంటి ఇవ్వాలని వెళుతున్న
దున్నేందుకు ఏదో మరియు ఆక్స్-ఏదో,

450
00:19:15,540 --> 00:19:19,820
దారి తీస్తుంది రెండు చిరునామాలు
వారి అసలు స్థానాలకు swap

451
00:19:19,820 --> 00:19:21,310
నా కంప్యూటర్ యొక్క మెమరీ లో.

452
00:19:21,310 --> 00:19:25,580
>> కాబట్టి ఇప్పుడు, నా మిగిలిన అమలు
ఒక టాడ్ మార్చడానికి అవసరం.

453
00:19:25,580 --> 00:19:28,650
ఇప్పుడు ఏం స్పష్టంగా విభిన్నమైనది
కోడ్ యొక్క ఈ మూడు పంక్తులు?

454
00:19:28,650 --> 00:19:31,350
ఈ తిట్టు నక్షత్రాలు ఉంది
చోట్ల, అన్ని కుడి?

455
00:19:31,350 --> 00:19:33,014
సో వాట్ ఇక్కడ జరగబోతోంది?

456
00:19:33,014 --> 00:19:33,514
అవును?

457
00:19:33,514 --> 00:19:35,055
>> ప్రేక్షకులు: [వినబడని] స్పష్టంగా ఉంది.

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

460
00:19:37,990 --> 00:19:41,560
ఈ సందర్భం లో సో ఈ లేదు
ఉత్తమ నిర్ణయానికి ఆమోదం

461
00:19:41,560 --> 00:19:42,530
క్రితం సంవత్సరాల.

462
00:19:42,530 --> 00:19:45,110
ఈ సందర్భంలో, పేరు
మీరు కేవలం ఒక స్టార్,

463
00:19:45,110 --> 00:19:48,240
మరియు మీరు ఒక డేటా రకాన్ని కలిగి లేదు,
Int వంటి, వెంటనే ఎడమ,

464
00:19:48,240 --> 00:19:53,146
బదులుగా మీరు స్పష్టంగా, సమాన సైన్ కలిగి,
ఈ సందర్భంలో, మీరు చెప్పినప్పుడు ఒక స్టార్,

465
00:19:53,146 --> 00:19:56,980
ఆ వెళ్ళడానికి అంటే
ఒక ఉందని చిరునామా.

466
00:19:56,980 --> 00:19:58,870
కాబట్టి మాట్లాడటం, నిధి పటం అనుసరించండి.

467
00:19:58,870 --> 00:20:01,720
>> మరియు అదే సమయంలో, లైన్ 37 లో,
అదే విషయం అర్థం.

468
00:20:01,720 --> 00:20:05,460
చిరునామా ఒక వెళ్ళండి, మరియు అక్కడ ఉంచారు?

469
00:20:05,460 --> 00:20:09,520
ఏది వద్ద ఉంది
బి పేర్కొనే నగర.

470
00:20:09,520 --> 00:20:10,980
ఇతర మాటలలో, బి వెళ్ళండి.

471
00:20:10,980 --> 00:20:12,130
ఆ విలువ పొందండి.

472
00:20:12,130 --> 00:20:15,620
సమాన శాతం, ఒక వెళ్ళండి మరియు
సైన్ అప్పగించిన ఆపరేటర్లు,

473
00:20:15,620 --> 00:20:17,010
అక్కడ ఆ విలువను ఉంచారు.

474
00:20:17,010 --> 00:20:19,272
>> అదేవిధంగా, Int టెంప్ కేవలం ఒక పూర్ణాంకానికి ఉంది.

475
00:20:19,272 --> 00:20:20,730
నథింగ్ తాత్కాలిక గురించి మార్చడానికి అవసరం.

476
00:20:20,730 --> 00:20:24,810
ఇది Annenberg నుండి కేవలం ఒక విడి గాజు వార్తలు
కొన్ని పాలు లేదా నారింజ రసం కోసం.

477
00:20:24,810 --> 00:20:27,630
కానీ నేను చెప్పేది, బి వెళ్లాలి లేదు.

478
00:20:27,630 --> 00:20:31,449
ఆ గమ్యానికి వెళ్లి
అక్కడ తాత్కాలిక విలువ ఉంచారు.

479
00:20:31,449 --> 00:20:32,490
కాబట్టి అప్పుడు ఏం?

480
00:20:32,490 --> 00:20:36,540
నేను నిజానికి, ఈ సమయంలో మార్చు కాల్ చేసినప్పుడు
ఈ మొదటి ట్రే ఇక్కడ, ప్రధాన సూచిస్తుంది

481
00:20:36,540 --> 00:20:42,270
ఈ రెండవ ట్రే స్వాప్ సూచిస్తుంది, ఎప్పుడు
నేను ఆంపర్సండ్ చిహ్నం x మరియు ఆంపర్సండ్ చిహ్నం Y పాస్

482
00:20:42,270 --> 00:20:47,150
ప్రధాన swap కు నుండి, కేవలం స్పష్టతను
ఈ స్టాక్ ఫ్రేమ్ అందుకునే ఏమి ఉంది?

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
అవును?

485
00:20:49,200 --> 00:20:50,180
>> ప్రేక్షకులు: [వినబడని].

486
00:20:50,180 --> 00:20:51,180
డేవిడ్ J. మలన్: ఖచ్చితంగా.

487
00:20:51,180 --> 00:20:53,129
x యొక్క చిరునామా మరియు y యొక్క చిరునామా.

488
00:20:53,129 --> 00:20:55,170
మరియు మీరు ఈ యొక్క ఆలోచించవచ్చు
పోస్టల్ చిరునామా వంటి.

489
00:20:55,170 --> 00:20:58,772
33 ఆక్స్ఫోర్డ్ స్ట్రీట్ మరియు 35
ఆక్స్ఫోర్డ్ స్ట్రీట్, మరియు మీరు

490
00:20:58,772 --> 00:21:01,230
రెండు భవనాలు తరలించాలనుకుంటున్న
ఆ స్థానాల్లో ఉన్నవి అని.

491
00:21:01,230 --> 00:21:04,680
>> ఇది ఒక పరిహాసాస్పదం ఆలోచన యొక్క విధమైన ఉంది,
కానీ ఆ మేము చిరునామా అర్ధం అంతే.

492
00:21:04,680 --> 00:21:07,000
ఎక్కడ ప్రపంచంలో చెయ్యవచ్చు
మీరు ఆ రెండు ints కనుగొనేందుకు?

493
00:21:07,000 --> 00:21:09,470
ప్రపంచంలో మీరు చెయ్యవచ్చు
ఆ రెండు భవనాలు కనుగొనేందుకు?

494
00:21:09,470 --> 00:21:15,170
సో చివరకు ఉంటే, ఈ సమయంలో నేను తర్వాత
నేటి సోర్స్ కోడ్ లోకి వెళ్ళి కంపైల్

495
00:21:15,170 --> 00:21:22,110
Swap మరియు రన్ ./swap, చివరకు, కోసం
మొదటిసారి మేము నిజంగా ఆ చూడండి లేదు

496
00:21:22,110 --> 00:21:25,330
నా విలువలు నిజానికి కలిగి
విజయవంతంగా మార్చుకున్నారు.

497
00:21:25,330 --> 00:21:30,860
ఇప్పుడు, మేము కూడా పట్టవచ్చు
ఈ లో, సే, GDB నోటు.

498
00:21:30,860 --> 00:21:32,740
>> నాలో ఒకే ఫైల్ లోకి వీడలేదు.

499
00:21:32,740 --> 00:21:35,010
నాకు ముందుకు వెళ్లి ./swap యొక్క GDB అమలు లెట్.

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
మరియు ఇప్పుడు, స్వాప్ లో, నేను వెళ్ళడానికి వెళుతున్న
ముందుకు మరియు మెయిన్ ఒక బ్రేక్ పాయింట్ సెట్.

502
00:21:40,547 --> 00:21:42,630
ఇప్పుడు నేను వెళ్ళడానికి వెళుతున్న
ముందుకు మరియు అమలు.

503
00:21:42,630 --> 00:21:45,810
ఇప్పుడు మేము నా కోడ్ చూడండి
ఆ లైన్ వద్ద నిలిపివేయబడింది.

504
00:21:45,810 --> 00:21:48,330
>> నేను ముందుకు ముద్రణ వెళ్ళి ఉంటే
X, నేను ఇక్కడ ఏమి చూస్తారు?

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
ఇది ఒక ప్రశ్న.

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
మళ్ళీ సే?

509
00:21:51,530 --> 00:21:52,295
>> ప్రేక్షకులు: [వినబడని].

510
00:21:52,295 --> 00:21:53,910
>> డేవిడ్ J. మలన్: సో
యాదృచ్ఛిక సంఖ్యలు, బహుశా.

511
00:21:53,910 --> 00:21:56,010
నేను లక్కీ పొందండి, మరియు అది వార్తలు
0 వంటి, nice మరియు సాధారణ.

512
00:21:56,010 --> 00:21:57,230
కానీ దీనికి కొన్ని యాదృచ్ఛిక నెంబర్.

513
00:21:57,230 --> 00:21:58,090
ఈ సందర్భంలో, నేను లక్కీ వచ్చింది.

514
00:21:58,090 --> 00:21:59,030
ఇది కేవలం 0 నిర్మాణము.

515
00:21:59,030 --> 00:22:00,780
కానీ అది నిజానికి అదృష్టం ఉంది
వరకు ఎందుకంటే నేను

516
00:22:00,780 --> 00:22:06,280
తరువాత టైప్ ఆపై ముద్రణ x ఉందని ఉంది
కోడ్ లైన్, లైన్ 19 అమలు చేశారు.

517
00:22:06,280 --> 00:22:10,942
>> ఇంతలో, నేను టైప్ ఉంటే తదుపరి మళ్ళీ, మరియు
ఇప్పుడు నేను 2 చూడండి వెళుతున్న, Y ముద్రించాలా.

518
00:22:10,942 --> 00:22:13,900
నేను తదుపరి టైప్ ఉంటే ఇప్పుడు, దానికి జరగబోతోంది
కొద్దిగా గందరగోళంగా పొందవచ్చు, ఇప్పుడు ఎందుకంటే,

519
00:22:13,900 --> 00:22:17,250
printf కనిపించడం అన్నారు
స్క్రీన్ చేసియున్నారు, వంటి. x 1.

520
00:22:17,250 --> 00:22:18,606
>> మళ్ళీ మనం.

521
00:22:18,606 --> 00:22:20,480
మరియు ఇప్పుడు, ఇక్కడ, ఇక్కడ వార్తలు
విషయాలు ఆసక్తికరమైన పొందండి.

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
నేను swap లేదా కూడా అడుగు కాల్ ముందు
అది లోకి, యొక్క ఒక చిన్న పీక్ తీసుకుందాం.

524
00:22:26,580 --> 00:22:28,980
X, మళ్ళీ, 1.

525
00:22:28,980 --> 00:22:33,240
Y, కోర్సు యొక్క, శీఘ్ర తెలివి ఉంది
కాబట్టి హార్డ్ కాదు, అక్కడ 2 తనిఖీ.

526
00:22:33,240 --> 00:22:35,740
కానీ ఆంపర్సండ్ చిహ్నం x ఏమి ఉంది?

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
సమాధానం ఇది అల్లరిగా రకం ఆరాటపడుతుంది.

529
00:22:39,350 --> 00:22:43,500
కానీ కుండలీకరణాలు లో Int నక్షత్రం కేవలం ఉంది
ఈ యొక్క GDP యొక్క మార్గం చిరునామా.

530
00:22:43,500 --> 00:22:48,290
ఇది ఒక ఒక పాయింటర్ ఒక పూర్ణాంకానికి యొక్క కాదు
Int, లేదా ఏదో ఒక చిరునామా అని పిలిచే.

531
00:22:48,290 --> 00:22:49,742
>> ఈ వెర్రి విషయం ఏమిటి?

532
00:22:49,742 --> 00:22:51,825
మేము ఏదో ఎప్పుడూ చూడలేదు
చాలా ముందు వంటి.

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
కాబట్టి ఈ నా కంప్యూటర్ యొక్క చిరునామా
X నివసిస్తున్నారు నిర్మాణము యొక్క మెమరీ.

535
00:22:58,120 --> 00:22:59,040
ఇది దున్నేందుకు ఏదో ఉంది.

536
00:22:59,040 --> 00:23:01,290
మరియు ఈ స్పష్టముగా, ఎందుకు ఉంది
నేను బాణాలు గీయడం ప్రారంభించారు చేసిన,

537
00:23:01,290 --> 00:23:03,340
బదులుగా సంఖ్యల,
ఎవరు నిజంగా అడిగే ఎందుకంటే

538
00:23:03,340 --> 00:23:06,890
మీ పూర్ణాంకానికి ఒక నిర్దిష్ట వద్ద అని
పెద్ద అని చిరునామా.

539
00:23:06,890 --> 00:23:12,160
కానీ bffff0c4, ఇవన్నీ ఉంటాయి
నిజానికి హెక్సాడెసిమల్ అంకెలు,

540
00:23:12,160 --> 00:23:13,720
F ద్వారా 0 ఇవి.

541
00:23:13,720 --> 00:23:16,590
>> కాబట్టి మేము ఆ చాలా నివసించు వెళ్ళడం లేదు చేస్తున్నాం
ఆ విషయాలు ఏమి దీర్ఘ.

542
00:23:16,590 --> 00:23:19,400
కానీ నేను y ముద్రించాలా ఉంటే,
కోర్సు యొక్క, నేను 2 చూడండి.

543
00:23:19,400 --> 00:23:22,440
కానీ ఆంపర్సండ్ చిహ్నం Y, నేను ఈ చిరునామా చూడండి.

544
00:23:22,440 --> 00:23:26,527
మరియు ప్రకటన, ఆసక్తికరమైన,
వేరుగా x మరియు y ఎంత దూరం?

545
00:23:26,527 --> 00:23:27,985
మీరు చిరునామా అత్యంత విస్మరించవచ్చు.

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
నాలుగు బైట్లు.

548
00:23:29,920 --> 00:23:33,510
ఆ స్థిరంగా మా
గతంలో ఒక పూర్ణాంకానికి ఎంత పెద్ద దావా?

549
00:23:33,510 --> 00:23:34,130
నాలుగు బైట్లు.

550
00:23:34,130 --> 00:23:37,420
కనుక ఇది ప్రతిదీ లైనింగ్ అప్ కనిపిస్తోంది
చక్కగా, మీరు మెమరీలో, ఆశించవచ్చు.

551
00:23:37,420 --> 00:23:40,010
>> కాబట్టి ఇప్పుడు, కేవలం ఫాస్ట్ ఫార్వర్డ్ తెలియజేయండి
ఈ కథ ముగింపు.

552
00:23:40,010 --> 00:23:43,290
, యొక్క ముందుకు వెళ్లి అడుగు టైప్ లెట్
swap ఫంక్షన్ ప్రవేశిస్తాడు.

553
00:23:43,290 --> 00:23:46,880
ఇప్పుడు నేను ఒక టైప్ ఉంటే, అది గమనించని
x యొక్క చిరునామా సమానంగా.

554
00:23:46,880 --> 00:23:52,130
నేను బి టైప్ ఉంటే, ఇది ఏకరూప
y యొక్క చిరునామాకు.

555
00:23:52,130 --> 00:23:57,020
సో నేను ఉంటే ఏమి చూస్తారు
ఒక చిరునామా వెళ్ళండి సే?

556
00:23:57,020 --> 00:23:58,120
కాబట్టి ఒక నక్షత్రం ప్రింట్.

557
00:23:58,120 --> 00:24:00,130
కాబట్టి నటి ఈ సందర్భంలో, అంటే అక్కడ వెళ్ళండి.

558
00:24:00,130 --> 00:24:02,730
ఆంపర్సండ్ చిహ్నం చిరునామా ఏమిటి అర్థం.

559
00:24:02,730 --> 00:24:05,000
కాబట్టి ఒక సాధనంగా 1 స్టార్.

560
00:24:05,000 --> 00:24:09,590
మరియు ముద్రణ స్టార్ బి నాకు 2 ఇస్తుంది.

561
00:24:09,590 --> 00:24:15,750
>> నాకు క్షణం ఊహించుకుంటే తెలియజేయండి
కనీసం కోడ్ ఆ

562
00:24:15,750 --> 00:24:18,950
అని ఇప్పుడు అమలు ఉపక్రమించాడు
ఆ విధంగా ద్వారా కారణం.

563
00:24:18,950 --> 00:24:21,150
కానీ మేము దీర్ఘ ముందు ఈ ఆలోచన సందర్శించండి చేస్తాము.

564
00:24:21,150 --> 00:24:23,850
స్వాప్ కాబట్టి ఈ వెర్షన్
ఇప్పుడు సరైన అనుమతించే

565
00:24:23,850 --> 00:24:26,650
మాకు ఈ ప్రత్యేక డేటా రకం మార్చుకోవడానికి.

566
00:24:26,650 --> 00:24:29,120
>> కాబట్టి అప్పుడు ఏదైనా ప్రశ్నలు స్వాప్?

567
00:24:29,120 --> 00:24:29,890
స్టార్?

568
00:24:29,890 --> 00:24:30,690
యొక్క చిరునామా న?

569
00:24:30,690 --> 00:24:33,270
మరియు మీరు తో, చూస్తారు
సమస్య విధమైన సెట్ 4

570
00:24:33,270 --> 00:24:37,310
కానీ సమస్య 5, ఖచ్చితంగా, ఎలా ఈ సెట్
విషయాలు ఉపయోగకరం మరియు పొందుటకు మరింత

571
00:24:37,310 --> 00:24:39,584
ఫలితంగా, వాటిని సౌకర్యవంతమైన.

572
00:24:39,584 --> 00:24:40,430
అన్ని వద్ద ఏదైనా?

573
00:24:40,430 --> 00:24:40,930
అన్ని కుడి.

574
00:24:40,930 --> 00:24:44,350
కాబట్టి malloc, ఈ ఫంక్షన్ మళ్ళీ,
కేవలం మెమరీ, మెమరీ కేటాయించుకునే

575
00:24:44,350 --> 00:24:45,330
కేటాయింపు.

576
00:24:45,330 --> 00:24:47,024
ఎందుకు ఈ ఉపయోగపడుతుంది?

577
00:24:47,024 --> 00:24:48,940
Well, ఈ సమయంలో,
మీరు malloc ఉపయోగించి పరిష్కరించగలుగుతున్నాము.

578
00:24:48,940 --> 00:24:52,230
ఎలా మీరు ఇప్పుడు పరిగణలోకి ఉంటే
రచనలు GetString, బహుశా, ఇది వార్తలు

579
00:24:52,230 --> 00:24:56,140
ఒక భాగం కోసం ఎవరైనా అడగడం జరిగింది
జ్ఞాపకశక్తి, ఎప్పుడైనా వినియోగదారు రకాల స్ట్రింగ్

580
00:24:56,140 --> 00:24:59,040
, ఖచ్చితంగా మేము ఎందుకంటే
తెలియదు, CS50 సిబ్బంది వంటి,

581
00:24:59,040 --> 00:25:02,710
ఎంత పెద్ద ఆ తీగలను మానవులు
కావచ్చు టైప్ వెళ్తున్నారు.

582
00:25:02,710 --> 00:25:07,910
>> కాబట్టి, మొదటి సారి, ప్రారంభిద్దాం
చర్మము తిరిగి ఎలా CS50 లైబ్రరీ రచనలు,

583
00:25:07,910 --> 00:25:10,990
ఉదాహరణలలో ఒక జంట ద్వారా
అక్కడ మాకు దారి తీస్తుంది.

584
00:25:10,990 --> 00:25:15,300
నేను gedit అప్ తెరిచి చేస్తే
మరియు, scanf 0 తెరవటానికి

585
00:25:15,300 --> 00:25:17,055
మేము ఈ క్రింది కోడ్ చూడండి చూడాలని.

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
వెబ్సైట్లో అందుబాటులో scanf 0,
నేడు కోడ్ సాపేక్షంగా కొన్ని పంక్తులు ఉంది

588
00:25:23,530 --> 00:25:25,351
ఇక్కడ, 20 ద్వారా 14.

589
00:25:25,351 --> 00:25:26,600
మరియు ఇది ఏమి చూద్దాం.

590
00:25:26,600 --> 00:25:28,920
ఇది ఒక పూర్ణాంకానికి అని x ప్రకటించాడు.

591
00:25:28,920 --> 00:25:30,850
ఏదో, సంఖ్య దయచేసి చెప్పారు.

592
00:25:30,850 --> 00:25:33,940
ఇప్పుడు అది scanf% i, & X అన్నారు.

593
00:25:33,940 --> 00:25:35,620
కాబట్టి అక్కడ కొత్త stuff ఒక సమూహం ఉంది.

594
00:25:35,620 --> 00:25:38,420
>> కానీ scanf, మీరు రకమైన ఆలోచించవచ్చు
యొక్క printf వ్యతిరేకం గా.

595
00:25:38,420 --> 00:25:40,090
printf, కోర్సు యొక్క, స్క్రీన్ ప్రింట్లు.

596
00:25:40,090 --> 00:25:44,410
యూజర్ యొక్క నుండి స్కాన్లు scanf విధమైన
కీబోర్డ్ ఏదో అతను లేదా ఆమె టైప్.

597
00:25:44,410 --> 00:25:46,550
>> % I కేవలం printf వంటిది.

598
00:25:46,550 --> 00:25:49,410
ఇది అంచనా అర్థం
వినియోగదారు ఒక Int టైప్.

599
00:25:49,410 --> 00:25:52,820
మరియు ఇప్పుడు, ఎందుకు మీరు నేను భావిస్తున్నాను లేదు
scanf & x ప్రయాణిస్తున్న ఉండవచ్చు?

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
ఉంటే scanf జీవితం లో ప్రయోజనం
వినియోగదారు నుండి ఏదో పొందుటకు ఉంది,

602
00:25:57,770 --> 00:26:02,480
యొక్క అర్థం ఏమిటి
ఇప్పుడు, అది దాటారు & x?

603
00:26:02,480 --> 00:26:02,980
అవును?

604
00:26:02,980 --> 00:26:03,896
>> ప్రేక్షకులు: [వినబడని].

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
డేవిడ్ J. మలన్: ఖచ్చితంగా.

607
00:26:06,540 --> 00:26:12,900
ఏమైనప్పటికీ నేను, మానవ, నా ఇన్పుట్ టైప్
ఆ స్థానాన్ని సేవ్ అన్నారు.

608
00:26:12,900 --> 00:26:17,660
ఇది కేవలం, గుర్తు, సరిపోతాయి కాదు
మేము ఇప్పటికే చూసిన ఎందుకంటే, x లో పాస్,

609
00:26:17,660 --> 00:26:21,630
ఏ సమయంలో మీరు, కేవలం ఒక ముడి వేరియబుల్ పాస్
ఒక పూర్ణాంకానికి వంటి కొన్ని ఇతర ఫంక్షన్,

610
00:26:21,630 --> 00:26:25,640
ఖచ్చితంగా, అది మార్చవచ్చు
వేరియబుల్, కానీ శాశ్వతంగా.

611
00:26:25,640 --> 00:26:27,360
ఇది ప్రధాన ప్రభావం ఉండకూడదు.

612
00:26:27,360 --> 00:26:29,420
ఇది మాత్రమే దాని స్వంత స్థానిక కాపీ మార్చవచ్చు.

613
00:26:29,420 --> 00:26:32,560
అయితే, బదులుగా, మీరు లేదు
నాకు అసలు పూర్ణాంకానికి ఇవ్వాలని,

614
00:26:32,560 --> 00:26:36,640
కానీ మీరు నాకు ఆదేశాలు ఇవ్వాలని
ఆ Int, నేను ఇప్పుడు, scanf ఉండటం

615
00:26:36,640 --> 00:26:41,050
ఖచ్చితంగా, నేను ఆ అనుసరించండి
పరిష్కరించడానికి మరియు అక్కడ అనేక చాలు

616
00:26:41,050 --> 00:26:43,280
కాబట్టి మీరు అలాగే అది యాక్సెస్.

617
00:26:43,280 --> 00:26:45,120
>> నేను ఈ ప్రోగ్రామ్ రన్ కనుక, యొక్క చూసేలా.

618
00:26:45,120 --> 00:26:49,660
Scanf 0 డాట్ స్లాష్ చేయండి, 0 scanf.

619
00:26:49,660 --> 00:26:54,030
మరియు నేను ఇప్పుడు ఒక సంఖ్య టైప్ ఉంటే
50 వంటి, 50 ధన్యవాదాలు.

620
00:26:54,030 --> 00:26:58,150
నేను ఇప్పుడు వంటి అనేక టైప్ ఉంటే
ప్రతికూల 1, మొత్తం 1 ప్రతికూల.

621
00:26:58,150 --> 00:27:04,200
నేను ఇప్పుడు HM 1.5 వంటి సంఖ్యను టైప్ చేయండి.

622
00:27:04,200 --> 00:27:06,030
ఎందుకు నా ప్రోగ్రామ్ నాకు పట్టించుకోకుండా లేదు?

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
వెల్, ఎందుకంటే కేవలం, నేను చెప్పారు
అది ఒక పూర్ణాంకానికి మాత్రమే ఆశించే.

625
00:27:09,880 --> 00:27:10,380
అన్ని కుడి.

626
00:27:10,380 --> 00:27:11,630
కాబట్టి ఈ ఒకటి సంస్కరణ.

627
00:27:11,630 --> 00:27:16,600
యొక్క ఒక గీత అప్ విషయాలు తీసుకుందాం
ఈ మంచి కాదు అని ప్రతిపాదించారు.

628
00:27:16,600 --> 00:27:20,530
మరియు ఇక్కడ ఒక చాలా చిన్న ఉదాహరణ ఉంది
మేము రచనలలో కోడ్ ప్రారంభించవచ్చు ఎలా

629
00:27:20,530 --> 00:27:24,450
ఇతర ప్రజలు దోపిడీ చేసే లేదా
చెడు పనులు చేయడం ద్వారా రాజీ.

630
00:27:24,450 --> 00:27:28,336
కాబట్టి లైన్ 16, అలా పోలి
ఆత్మ ముందు,

631
00:27:28,336 --> 00:27:29,960
కానీ నేను ఈ సమయంలో, Int ప్రకటించారు లేదు చేస్తున్నాను.

632
00:27:29,960 --> 00:27:32,970
నేను స్ట్రింగ్ ఆక, ఇది చార్ స్టార్ ప్రకటించారు చేస్తున్నాను.

633
00:27:32,970 --> 00:27:35,190
>> కానీ నిజంగా అర్థం ఏమిటి?

634
00:27:35,190 --> 00:27:38,790
కాబట్టి నేను ఒక చిరునామాతో ఇవ్వకండి ఉంటే
నేను కక్ష్య కాల్ చేస్తున్నాను, బఫర్,

635
00:27:38,790 --> 00:27:43,370
కానీ నేను simple-- ఉండటానికి, అది వార్తలు కాల్ కాలేదు
ఆపై నేను దీన్ని నాకు వివరించేందుకు

636
00:27:43,370 --> 00:27:48,630
మీరు మునుపటి ఆధారంగా, అనుకొనుట ఉంటే
తర్కం, scanf లైన్ 18 లో, ఏమి

637
00:27:48,630 --> 00:27:55,000
పాస్% s మరియు బఫర్ ఉంటే,
ఒక చిరునామా ఉంటుంది?

638
00:27:55,000 --> 00:27:58,210
మీరు దరఖాస్తు ఉంటే scanf, ఏమిటి
వెర్షన్ 0 గా ఖచ్చితమైన అదే తర్కం,

639
00:27:58,210 --> 00:28:00,640
ఇక్కడ అలా ప్రయత్నించండి అన్నారు ఉన్నప్పుడు
వినియోగదారు రకాల ఏదో?

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
అవును?

642
00:28:03,409 --> 00:28:04,407
>> ప్రేక్షకులు: [వినబడని].

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.

645
00:28:08,890 --> 00:28:11,577
Scanf, తర్కం ముందువి ద్వారా,
స్ట్రింగ్ పడుతుంది అన్నారు

646
00:28:11,577 --> 00:28:13,410
మానవ టైప్
అది ఇప్పుడు ఒక స్ట్రింగ్ in--

647
00:28:13,410 --> 00:28:15,790
అది, బహుశా, ఒక సంఖ్య కాదు
అతను లేదా ఆమె cooperates-- ఉంటే

648
00:28:15,790 --> 00:28:19,310
మరియు అది ఉంచారు ప్రయత్నించండి జరగబోతోంది
ఏమైనా చిరునామా మెమరీ స్ట్రింగ్

649
00:28:19,310 --> 00:28:20,340
బఫర్ నిర్దేశిస్తుంది.

650
00:28:20,340 --> 00:28:23,870
మరియు ఈ గొప్ప ఉంది బఫర్ ఎందుకంటే
నిజంగానే చిరునామా అని అర్థం.

651
00:28:23,870 --> 00:28:30,470
>> కానీ నేను ఈ కార్యక్రమం లో బగ్గీ ఉంది దావా
చాలా తీవ్రమైన విధంగా, విలువ ఏమిటి ఎందుకంటే

652
00:28:30,470 --> 00:28:31,330
అప్రమేయంగా స్వీకరించేందుకు?

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
నేను లోకి ఏం initialized చేశారు?

655
00:28:34,790 --> 00:28:35,770
మెమరీ ఏమిటి భాగం?

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
నేను లేదు, కుడి?

658
00:28:38,620 --> 00:28:42,265
>> కాబట్టి నేను కేటాయించింది చేసిన అయినప్పటికీ ఒక
ఇకపై లు అని చార్ స్టార్,

659
00:28:42,265 --> 00:28:48,030
ఇది బదులుగా అని, కాబట్టి buffer--
వేరియబుల్ యొక్క పేరు డ్రా తెలియజేయండి

660
00:28:48,030 --> 00:28:53,380
నేను కలిగి ఉంటే ఇప్పుడు buffer--
ఇక్కడ GetString లేదా malloc అని,

661
00:28:53,380 --> 00:28:56,030
ఆ సమర్థవంతంగా అర్థం
బఫర్ కేవలం కొన్ని చెత్త విలువ.

662
00:28:56,030 --> 00:28:57,030
>> ఇప్పుడు ఆ అర్థం ఏమిటి?

663
00:28:57,030 --> 00:29:00,220
ఇది నేను scanf చెప్పారు అర్థం
వినియోగదారు నుండి ఒక స్ట్రింగ్ ఆశించడం.

664
00:29:00,220 --> 00:29:01,300
మరియు మీరు ఏమి?

665
00:29:01,300 --> 00:29:03,883
ఏది ఈ విషయం సూచించబడిన
ఆలోచన మరియు నేను ప్రశ్న మార్క్ డ్రా,

666
00:29:03,883 --> 00:29:07,060
కానీ వాస్తవంలో, ఇది చేస్తాడు
Ox1, 2, 3, వంటి ఏదో కుడి?

667
00:29:07,060 --> 00:29:10,730
ఇది కొన్ని బోగస్ విలువ కేవలం
ముందు నుండి ఉన్నాయి నిర్మాణము.

668
00:29:10,730 --> 00:29:13,440
కాబట్టి మరో విధంగా చెప్పాలంటే, ఇది వార్తలు
బఫర్ కేవలం అయినప్పటికీ గా

669
00:29:13,440 --> 00:29:16,180
మెమరీ లో ఏదో చెబుతోంది.

670
00:29:16,180 --> 00:29:17,610
నేను ఏమి సంఖ్య ఆలోచన ఉంది.

671
00:29:17,610 --> 00:29:24,130
>> నేను ఇప్పుడు గాబే లో టైప్ చేస్తే, అది జరగబోతోంది
అక్కడ G-a-b-ఇ / 0 ఉంచాలి ప్రయత్నించండి.

672
00:29:24,130 --> 00:29:25,530
కానీ ఎవరు అని తెలుసు?

673
00:29:25,530 --> 00:29:27,480
మరియు గతంలో ఏ
మేము తాకే ప్రయత్నించారు చేసిన సమయం

674
00:29:27,480 --> 00:29:29,770
చెందినది కాదు మెమరీ
మాకు, ఏమి జరిగింది?

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
లేదా దాదాపు ప్రతిసారీ.

677
00:29:32,870 --> 00:29:34,310
విభజన లోపంగా, కుడి?

678
00:29:34,310 --> 00:29:37,829
>> ఇది ఎక్కడ ఈ బాణం, నేను సంఖ్య ఆలోచన ఉంది
పాయింటింగ్. ఇది కేవలం కొన్ని యాదృచ్ఛిక విలువ ఏమిటి.

679
00:29:37,829 --> 00:29:40,370
మరియు కోర్సు యొక్క, మీరు అనుకుంటున్నట్లు ఉంటే
ఒక చిరునామా ఒక యాదృచ్ఛిక విలువ,

680
00:29:40,370 --> 00:29:42,610
మీరు వెళ్ళండి చూడాలని
కొన్ని యాదృచ్ఛిక గమ్యం.

681
00:29:42,610 --> 00:29:46,810
కాబట్టి గాబే క్రాష్ నిజానికి వాటిని
ఇక్కడ ఈ సందర్భంలో నా ప్రోగ్రామ్.

682
00:29:46,810 --> 00:29:50,600
>> కాబట్టి మేము దాదాపు చెడు ఏమి చేయవచ్చు?

683
00:29:50,600 --> 00:29:52,660
ఈ మూడవ పరిగణించండి మరియు
scanf ఆఖరి ఉదాహరణ.

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
ఈ సంస్కరణ ఏ కోణంలో ఉత్తమం?

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
మీరు సౌకర్యవంతంగా ఉంటాయి ఉంటే
మునుపటి సమస్య, ఈ మంచి ఉంది.

688
00:30:01,400 --> 00:30:02,250
ఎందుకు?

689
00:30:02,250 --> 00:30:03,250
>> ప్రేక్షకులు: [వినబడని].

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
డేవిడ్ J. మలన్: గుడ్.

692
00:30:07,110 --> 00:30:09,970
లైన్ 16 కాబట్టి ఈ కేసు
భావంలో, ఉత్తమం

693
00:30:09,970 --> 00:30:12,030
మేము స్పష్టంగా ఉన్నట్లు
కొన్ని మెమరీ పెడుతోంది.

694
00:30:12,030 --> 00:30:14,190
మేము, malloc ఉపయోగించి లేదు
మేము వారం 2 ఉపయోగించి చేస్తున్నారు

695
00:30:14,190 --> 00:30:16,060
కేవలం వ్యూహం ప్రకటించే విధానం.

696
00:30:16,060 --> 00:30:18,130
మరియు మేము ఒక స్ట్రింగ్ ముందు చెప్పారు చేసిన
కేవలం అక్షరాల యొక్క శ్రేణి,

697
00:30:18,130 --> 00:30:19,690
కాబట్టి ఈ పూర్తిగా అవసరమని.

698
00:30:19,690 --> 00:30:22,910
కానీ అది, కోర్సు యొక్క, ఉంది
మీరు 16, స్థిర పరిమాణం గమనించండి.

699
00:30:22,910 --> 00:30:25,440
>> కాబట్టి ఈ ప్రోగ్రామ్ ఉంది
పూర్తిగా సురక్షితంగా, నేను టైప్ ఉంటే

700
00:30:25,440 --> 00:30:29,760
ఒక పాత్ర తీగలను లో, రెండు మూర్తులు
తీగలను, 15 పాత్ర తీగలను.

701
00:30:29,760 --> 00:30:34,970
కానీ వెంటనే నేను 16 టైప్ మొదలు,
17, 18, 1,000 పాత్ర తీగలను,

702
00:30:34,970 --> 00:30:37,390
అక్కడ ఆ స్ట్రింగ్ ముగుస్తుంది అన్నారు?

703
00:30:37,390 --> 00:30:39,570
ఇది పాక్షికంగా ఇక్కడ వదులుకోవడానికి జరగబోతోంది.

704
00:30:39,570 --> 00:30:42,820
కానీ అప్పుడు ఎవరు ఏం else తెలుసు
సరిహద్దులు దాటి ఉంది

705
00:30:42,820 --> 00:30:44,270
ఈ ప్రత్యేక శ్రేణి యొక్క?

706
00:30:44,270 --> 00:30:48,015
>> నేను చేసిన అయితే ఇది
ఇక్కడ 16 బాక్సులను ప్రకటించింది.

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
కాబట్టి అన్ని 16 అవ్ట్ డ్రా కాకుండా, మేము చేస్తాము
కేవలం నేను 16 డ్రా చేసిన నటిస్తారు.

709
00:30:52,690 --> 00:30:56,540
కానీ నేను ఒక స్ట్రింగ్ చదవడానికి ప్రయత్నించండి ఉంటే
50 అక్షరాలు వంటి, చాలా పొడవుగా ఉంది,

710
00:30:56,540 --> 00:31:01,270
నేను పెట్టటం మొదలు వెళుతున్న
ఒక, B, C, D, X, Y, Z.

711
00:31:01,270 --> 00:31:04,916
మరియు ఈ బహుశా ఉంది
కొన్ని ఇతర మెమరీ విభాగంలో

712
00:31:04,916 --> 00:31:06,790
మళ్ళీ, కారణం కావచ్చు
నా ప్రోగ్రామ్ క్రాష్

713
00:31:06,790 --> 00:31:10,600
నేను అడిగారు చేసిన ఎందుకంటే
కేవలం 16 బైట్ల కంటే ఎక్కువ ఏదైనా.

714
00:31:10,600 --> 00:31:12,260
>> కాబట్టి ఎవరు పట్టించుకుంటారు?

715
00:31:12,260 --> 00:31:13,880
సరే, ఇక్కడ CS50 లైబ్రరీ.

716
00:31:13,880 --> 00:31:17,220
మరియు ఈ అత్యంత కేవలం ఉంది
టాప్ వంటి సూచనలను.

717
00:31:17,220 --> 00:31:21,670
CS50 లైబ్రరీ, ఈ సమయంలో,
లైన్ 52 లో ఈ లైన్ కలిగి ఉంది.

718
00:31:21,670 --> 00:31:23,680
మేము typedef చూసిన, లేదా చేసిన
మీరు typedef చూస్తారు

719
00:31:23,680 --> 00:31:27,930
కేవలం సృష్టిస్తుంది ఇది pset 4 లో
పర్యాయపదంగా చార్ స్టార్ మలిచారు

720
00:31:27,930 --> 00:31:29,290
కేవలం స్ట్రింగ్ వలె సూచిస్తారు.

721
00:31:29,290 --> 00:31:31,540
కాబట్టి ఈ ఒకటి
కొన్ని శిక్షణ చక్రాలు

722
00:31:31,540 --> 00:31:34,120
మేము హుడ్ కింద రహస్యంగా ఉపయోగించారు చేసిన.

723
00:31:34,120 --> 00:31:36,490
>> ఇంతలో, ఇక్కడ GetChar, ఫంక్షన్ ఉంది.

724
00:31:36,490 --> 00:31:38,190
ఇప్పుడు స్పష్టంగా, అది ఎటువంటి శరీరం ఉంది.

725
00:31:38,190 --> 00:31:40,273
నిజానికి, నేను ఉంచుకుంటే
స్క్రోలింగ్, నేను నిజానికి లేదు

726
00:31:40,273 --> 00:31:42,080
ఏ ఆచరణలు చూడండి
ఈ విధులను.

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
ఒక పవిత్రత చెక్, ఆ ఎందుకు?

729
00:31:45,516 --> 00:31:46,795
>> ప్రేక్షకులు: [వినబడని].

730
00:31:46,795 --> 00:31:47,670
డేవిడ్ J. మలన్: అవును.

731
00:31:47,670 --> 00:31:48,950
కాబట్టి ఈ శీర్షిక ఫైలు.

732
00:31:48,950 --> 00:31:52,520
మరియు శీర్షిక ఫైళ్లు నమూనాలను కలిగి,
ప్లస్ కొన్ని ఇతర అంశాలు, అది కనిపిస్తుంది,

733
00:31:52,520 --> 00:31:53,780
typedefs వంటి.

734
00:31:53,780 --> 00:31:56,910
కానీ cs50.c, మేము చేసిన
బొత్తిగా మీరు ఇచ్చిన ఎప్పుడూ,

735
00:31:56,910 --> 00:32:02,100
కానీ CS50 పరికరంలోని సంతరించుకున్నాయి అన్ని
ఈ సమయంలో, లోతైన దాని ఫోల్డర్లను లోపల,

736
00:32:02,100 --> 00:32:04,990
మొత్తం అక్కడ గమనిస్తారు
ఇక్కడ విధులు సమూహం.

737
00:32:04,990 --> 00:32:06,720
>> నిజానికి, యొక్క స్క్రోల్ డౌన్ తెలపండి.

738
00:32:06,720 --> 00:32:08,810
ఇప్పుడు కోసం, వాటిలో చాలా విస్మరించండి లెట్.

739
00:32:08,810 --> 00:32:12,670
కానీ GetInt క్రిందికి స్క్రోల్
మరియు GetInt పనిచేస్తుంది ఎలా చూడండి.

740
00:32:12,670 --> 00:32:13,890
కాబట్టి ఇక్కడ GetInt ఉంది.

741
00:32:13,890 --> 00:32:17,727
మీరు నిజంగా ఆలోచించలేదు ఉంటే చేయాలో పొందండి
పూర్ణాంకానికి ఇక్కడ పనిచేస్తుంది దాని డాక్యుమెంటేషన్ ఉంది.

742
00:32:17,727 --> 00:32:19,560
మరియు విషయాలతోపాటు
అది మీరు చెబుతుంది చెప్పారు

743
00:32:19,560 --> 00:32:21,340
విలువలు శ్రేణులు తిరిగి చేయవచ్చు ఏమి.

744
00:32:21,340 --> 00:32:24,400
ఇది ముఖ్యంగా ప్రతికూల వార్తలు 2 బిలియన్
అనుకూల 2 బిలియన్ ఇవ్వడం లేదా తీసుకోవడం.

745
00:32:24,400 --> 00:32:26,420
>> మరియు అది అన్ని ఈ టర్న్స్
సమయం, మేము ఎప్పుడూ చేసిన అయినప్పటికీ

746
00:32:26,420 --> 00:32:28,570
మీరు దాని కోసం తనిఖీ చేసింది,
ఏదో తప్పు పోతే,

747
00:32:28,570 --> 00:32:30,680
ఇది అన్ని ఆ అవుతుంది
ఈ సమయంలో, GetInt ఉంది

748
00:32:30,680 --> 00:32:33,600
ఒక ప్రత్యేక తిరిగి చేశారు
, శూన్య, స్థిరమైనది కాదు

749
00:32:33,600 --> 00:32:36,760
కానీ ఇది int_max
కేవలం ఒక ప్రోగ్రామర్ కన్వెన్షన్.

750
00:32:36,760 --> 00:32:38,846
ఇది ఇక్కడ అర్థం ఒక ప్రత్యేక విలువ ఉంది.

751
00:32:38,846 --> 00:32:41,470
కేవలం ఈ తనిఖీ నిర్ధారించుకోండి
విషయంలో ఏదో తప్పు జరిగితే.

752
00:32:41,470 --> 00:32:43,261
కానీ మేము పొందలేదన్న ఎప్పుడూ చేసిన
తేదీ ఆ,

753
00:32:43,261 --> 00:32:45,200
మళ్ళీ, ఈ ఎందుకంటే
సరళీకృతం చేయడానికి ఉద్దేశించబడింది.

754
00:32:45,200 --> 00:32:46,950
>> కానీ ఎలా GetInt అమలు చేసుకోగా లేదు?

755
00:32:46,950 --> 00:32:48,450
సరే,, అది ఎటువంటి వాదనలూ లేవు పడుతుంది.

756
00:32:48,450 --> 00:32:49,390
మేము తెలుసు.

757
00:32:49,390 --> 00:32:50,820
ఇది ఒక పూర్ణాంకానికి తిరిగి.

758
00:32:50,820 --> 00:32:51,950
మేము తెలుసు.

759
00:32:51,950 --> 00:32:54,460
కాబట్టి ఎలా హుడ్ కింద పని చేస్తుంది?

760
00:32:54,460 --> 00:32:58,290
>> కాబట్టి స్పష్టంగా అనంత ఉంది
లూప్ ఒక కనీసం ప్రదర్శన.

761
00:32:58,290 --> 00:33:00,290
మేము GetString ఉపయోగించి గమనించాలి.

762
00:33:00,290 --> 00:33:04,000
కాబట్టి ఆసక్తికరంగా ఉందని. GetInt
మా సొంత ఫంక్షన్ GetString, పిలుస్తుంది.

763
00:33:04,000 --> 00:33:05,645
ఇప్పుడు ఎందుకు ఈ సందర్భంలో కావచ్చు?

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
ఎందుకు నేను రక్షక ఉండటం am
ఇక్కడ లైన్ 165 లో?

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
ఏం లైన్ లో జరిగి
164, కేవలం స్పష్టతను?

768
00:33:15,639 --> 00:33:16,930
ఇది ముందు అదే సమాధానం ఉంది.

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
కేవలం మెమరీ బయటకు కావచ్చు.

771
00:33:20,089 --> 00:33:23,130
ఏదో, GetString తో తప్పు జరిగితే
మేము ఆ నిర్వహించడానికి చెయ్యగలరు పొందారు.

772
00:33:23,130 --> 00:33:27,070
మరియు కారణం నేను శూన్య తిరిగి లేదు
ఆ సాంకేతికంగా శూన్య ఒక పాయింటర్ ఉంది.

773
00:33:27,070 --> 00:33:29,120
GetInt ఒక పూర్ణాంకానికి తిరిగి ఉంది.

774
00:33:29,120 --> 00:33:31,060
కాబట్టి నేను ఏకపక్ష చేసిన
ముఖ్యంగా నిర్ణయించుకుంది

775
00:33:31,060 --> 00:33:34,600
2 బిలియన్ అని, వెళ్ళి ఇవ్వాలని లేదా పడుతుంది
ఒక ప్రత్యేక విలువ అని నేను చెయ్యవచ్చు ఎప్పుడూ

776
00:33:34,600 --> 00:33:35,970
వాస్తవానికి వినియోగదారు నుండి పొందండి.

777
00:33:35,970 --> 00:33:39,930
ఇది నేను వెళుతున్నాను కేవలం ఒక విలువ వార్తలు
ఒక లోపం కోడ్ ప్రాతినిథ్యం వృధా.

778
00:33:39,930 --> 00:33:41,540
>> కాబట్టి ఇప్పుడు, విషయాలు కొద్దిగా ఫాన్సీ పొందండి.

779
00:33:41,540 --> 00:33:44,670
మరియు అది చాలా అదే ఫంక్షన్ కాదు
ముందు గా, కానీ అది చాలా పోలి ఉంది.

780
00:33:44,670 --> 00:33:50,120
కాబట్టి నేను లైన్ లో ఇక్కడ డిక్లేర్ గమనించవచ్చు
172, ఒక పూర్ణాంకానికి n మరియు ఒక చార్ సి రెండూ.

781
00:33:50,120 --> 00:33:53,600
ఆపై నేను, ఈ అల్లరిగా పంక్తిని ఉపయోగించండి
దాన్ని మారుతుంది ఇది sscanf,

782
00:33:53,600 --> 00:33:55,990
కీబోర్డ్ నుండి ఒక స్ట్రింగ్ స్కాన్ లేదు.

783
00:33:55,990 --> 00:33:59,226
ఇది ఇప్పటికే ఉన్న స్ట్రింగ్ నిలిచే
యూజర్ ఇప్పటికే సైన్ టైప్.

784
00:33:59,226 --> 00:34:02,100
కాబట్టి నేను ఇప్పటికే GetString, అని ఇది
నేను మెమరీ లో ఒక స్ట్రింగ్ కలిగి అర్థం.

785
00:34:02,100 --> 00:34:05,020
sscanf ఏమి మీరు కావలసిన
ఒక పదనిరూపణ ఫంక్షన్ కాల్.

786
00:34:05,020 --> 00:34:07,760
ఇది నేను చేసిన స్ట్రింగ్ చూసి
, పాత్ర, పాత్ర లో టైప్

787
00:34:07,760 --> 00:34:09,250
మరియు ఉపయోగకరమైన ఏదో చేస్తుంది.

788
00:34:09,250 --> 00:34:10,969
ఆ స్ట్రింగ్ లైన్ లో నిల్వ చేయబడుతుంది.

789
00:34:10,969 --> 00:34:13,560
మరియు నేను మాత్రమే వెళ్తుంటే తెలుసు
సరే, OH, ఇక్కడ మరియు మాట్లాడుతూ బ్యాకప్,

790
00:34:13,560 --> 00:34:15,143
నేను ఈ సమయం, కానీ లైన్ అని.

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> ఇప్పుడు ఈ చిన్న భిన్నంగా ఉంటుంది.

793
00:34:18,080 --> 00:34:22,480
కానీ ఈ సమర్థవంతంగా కారణాల కోసం, అర్థం
మేము కొంతవరకు నేడు, మా చేతులు దుర్చాల్సిన చేస్తాము

794
00:34:22,480 --> 00:34:26,070
మేము తనిఖీ చేస్తున్నాము అని
యూజర్ టైప్ చూడండి

795
00:34:26,070 --> 00:34:29,909
మరియు Int మరియు బహుశా మరొక పాత్ర.

796
00:34:29,909 --> 00:34:33,610
వినియోగదారు ఒక Int లో టైప్ ఉంటే, అది వార్తలు
నేను ఉన్నాను ఎందుకంటే అన్నారు, N భద్రపర్చడానికి

797
00:34:33,610 --> 00:34:36,739
చిరునామా ద్వారా ఈ దాటారు
మేము నేడు చూసిన కొత్త ట్రిక్.

798
00:34:36,739 --> 00:34:41,570
వినియోగదారు టైప్ ఉంటే
వంటి 123x లో, ఆ x

799
00:34:41,570 --> 00:34:45,060
ఒక ముగుస్తుంది అన్నారు
పాత్ర సి లో లేఖ.

800
00:34:45,060 --> 00:34:48,739
>> ఇప్పుడు ఆ sscanf అవుతుంది
తెలివిగా, చెప్పు,

801
00:34:48,739 --> 00:34:54,750
ఎన్ని వేరియబుల్స్ sscanf చేశారు
పూరించడానికి విజయవంతంగా చేయగలరు.

802
00:34:54,750 --> 00:34:58,770
ఈ తర్కం ద్వారా, చేస్తే ఫంక్షన్
నేను, GetInt అమలు చేస్తున్నాను

803
00:34:58,770 --> 00:35:00,900
కానీ నేను తనిఖీ చేస్తున్నాను,
సమర్థవంతంగా, యూజర్ కోసం

804
00:35:00,900 --> 00:35:04,190
ఒక Int లో టైప్ చేసిన తర్వాత
ఏదో తరువాత,

805
00:35:04,190 --> 00:35:08,580
ఏమి నేను sscanf యొక్క అనుకుంటున్నారు
తిరిగి విలువ నిజంగా ఉండాలి?

806
00:35:08,580 --> 00:35:10,950
ప్రయోజనం పొందడానికి ఉంటే
కేవలం యూజర్ నుండి ఒక పూర్ణాంకానికి?

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> కాబట్టి sscanf తిరిగి ఉంటే
2, ఆ అర్థం ఏమిటి?

809
00:35:19,300 --> 00:35:21,660
యూజర్ టైప్
ఏదో వంటి, వాచ్యంగా,

810
00:35:21,660 --> 00:35:24,770
కేవలం అర్ధంలేని ఇది 123x.

811
00:35:24,770 --> 00:35:27,490
ఇది ఒక లోపం పరిస్థితి, మరియు
నేను ఆ కోసం తనిఖీ చెయ్యవచ్చును.

812
00:35:27,490 --> 00:35:32,960
>> కాబట్టి ఈ వినియోగదారు రకాల ఉంటే, ద్వారా
ఈ తర్కం, తిరిగి sscanf ఏమి,

813
00:35:32,960 --> 00:35:33,740
మీరు చెబుతా?

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
కాబట్టి ఇది ఎందుకంటే, 2 తిరిగి వెళుతున్న
123, ఇక్కడ వెళ్ళండి అన్నారు

816
00:35:39,130 --> 00:35:41,580
మరియు x ఇక్కడ ముగుస్తుంది అన్నారు.

817
00:35:41,580 --> 00:35:43,970
కానీ నేను x నిండి పెట్టడానికి వద్దు.

818
00:35:43,970 --> 00:35:48,580
నేను మాత్రమే విజయవంతం sscanf కావలసిన
దాని వేరియబుల్స్ మొదటి నింపి.

819
00:35:48,580 --> 00:35:52,490
కాబట్టి ఎందుకు నేను
sscanf 1 తిరిగి అనుకుంటున్నారా.

820
00:35:52,490 --> 00:35:55,750
>> మరియు ఈ తలపై ఒక బిట్ ఉంటే
క్షణం కోసం, ఆ పూర్తిగా మంచిది.

821
00:35:55,750 --> 00:36:00,030
అయితే ఆ ఒకటి రియలైజ్
GetInt మరియు GetString విలువలు

822
00:36:00,030 --> 00:36:03,630
మేము ఒక హెక్ చేస్తున్న ఉంది
ఈ విధంగా వంటి తనిఖీ లోపం చాలా

823
00:36:03,630 --> 00:36:07,130
ఆ తేదీ వరకు, మీరు చాలా చక్కని చెయ్యవచ్చు
మీ కీబోర్డ్ వద్ద ఏదైనా టైప్

824
00:36:07,130 --> 00:36:08,490
మరియు మేము అది క్యాచ్ ఉంటుంది.

825
00:36:08,490 --> 00:36:10,592
మరియు మేము ఖచ్చితంగా,
సిబ్బంది, కాదు ఖచ్చితంగా రెడీ

826
00:36:10,592 --> 00:36:13,300
ఒక బగ్ మూలం ఉంటుంది మీ
కార్యక్రమం, మేము రక్షణాత్మకంగా ఉన్నాము ఎందుకంటే

827
00:36:13,300 --> 00:36:16,270
స్టుపిడ్ అన్ని కోసం తనిఖీ
ఒక వినియోగదారు విషయముల,

828
00:36:16,270 --> 00:36:18,900
, ఒక స్ట్రింగ్ టైపింగ్ వంటి
మీరు నిజంగా పూర్ణాంకానికి కోరుకున్నారు.

829
00:36:18,900 --> 00:36:21,350
కాబట్టి మేము వచ్చి చేస్తాము ఇప్పుడు కోసం
తిరిగి ఈ లాంగ్ ముందు

830
00:36:21,350 --> 00:36:23,710
కానీ ఈ సమయంలో,
GetString మరియు GetInt కలిగి

831
00:36:23,710 --> 00:36:29,950
ఈ ఉపయోగించి హుడ్ కింద ఉన్నారు
మెమరీ అడ్రసులను ప్రాథమిక ఆలోచన.

832
00:36:29,950 --> 00:36:32,580
>> కాబట్టి ఇప్పుడు, ఒక యొక్క విషయాలు తయారు చేద్దాము
యూజర్ ఫ్రెండ్లీ కొంచెం ఎక్కువ ఉంటుంది.

833
00:36:32,580 --> 00:36:38,740
మీరు Binky చివరి నుండి, గుర్తుకు విధంగా
time-- నా మౌస్ కాబట్టి cooperate-- ఉంటే

834
00:36:38,740 --> 00:36:42,560
మేము ఈ కోడ్ కలిగి లేని
స్పష్టముగా, బొత్తిగా పనికిమాలిన.

835
00:36:42,560 --> 00:36:45,330
ఈ కోడ్ ఏమీ సాధిస్తుంది
ఉపయోగకరమైన, కాని ఉదాహరణ

836
00:36:45,330 --> 00:36:48,330
ఆ ప్రొఫెసర్ Parlante
య క్రమంలో ఉపయోగిస్తారు

837
00:36:48,330 --> 00:36:51,840
ఏమి ఒక లో జరగబోతోంది
మెమరీ పాల్గొన్న కార్యక్రమం.

838
00:36:51,840 --> 00:36:54,850
>> కాబట్టి యొక్క ఈ కధా శ్రేణిలో తెలియజేయండి
కథ సూపర్ క్లుప్తంగా.

839
00:36:54,850 --> 00:36:58,720
ఈ మొదటి రెండు పంక్తులు లో
ఇంగ్లీష్, మీరు ఏమి చెబుతారు లేదు?

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
జస్ట్ సహేతుక మానవ, కానీ
కొద్దిగా సాంకేతిక నిబంధనలు, ఒక ఉదంతం పడుతుంది.

842
00:37:05,430 --> 00:37:06,346
ప్రేక్షకులు: [వినబడని].

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> డేవిడ్ J. మలన్: సరే, మీరు స్థాపించటం చేస్తున్నారు
మీ x మరియు y వేరియబుల్స్ చిరునామాలు.

845
00:37:11,080 --> 00:37:15,520
కాదు, x మరియు y కాదు ఎందుకంటే
సంప్రదాయ అర్థంలో వేరియబుల్స్.

846
00:37:15,520 --> 00:37:18,054
x మరియు y చిరునామాలు
లేదా చిరునామా నిల్వ చేస్తుంది.

847
00:37:18,054 --> 00:37:19,220
కాబట్టి యొక్క ఈ సారి మరిన్ని ప్రయత్నించండి తెలియజేయండి.

848
00:37:19,220 --> 00:37:21,010
Not a చెడు ప్రారంభం, అయితే.

849
00:37:21,010 --> 00:37:21,510
అవును?

850
00:37:21,510 --> 00:37:22,426
>> ప్రేక్షకులు: [వినబడని].

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
డేవిడ్ J. మలన్: గుడ్.

853
00:37:24,840 --> 00:37:26,173
నేను ఒక చిన్న క్లీనర్ అని.

854
00:37:26,173 --> 00:37:28,630
రెండు పాయింటర్లు, రెండు పూర్ణాంకాల ప్రకటన.

855
00:37:28,630 --> 00:37:30,150
మరియు మేము వాటిని x మరియు y కాల్ చేస్తున్నారు.

856
00:37:30,150 --> 00:37:32,790
లేదా మేము ఉన్నట్లయితే డ్రా
ఈ చిత్రాన్ని మళ్ళీ,

857
00:37:32,790 --> 00:37:36,410
చాలా సరళంగా అన్ని గుర్తుకు
మేము, మొదటి లైన్ తో చేస్తున్నా

858
00:37:36,410 --> 00:37:39,690
ఈ వంటి ఒక బాక్స్ గీయడం,
అది కొన్ని చెత్త విలువతో

859
00:37:39,690 --> 00:37:41,920
ఆపై ఇది x పిలుపు
ఈ వంటి మరొక బాక్స్,

860
00:37:41,920 --> 00:37:43,880
కొన్ని చెత్త విలువతో
అది, Y పిలుస్తూ.

861
00:37:43,880 --> 00:37:45,810
మేము రెండు డిక్లేర్డ్ చేసిన
గమనికలు చివరికి

862
00:37:45,810 --> 00:37:47,860
ఒక పూర్ణాంకానికి యొక్క చిరునామా నిల్వ చేస్తుంది.

863
00:37:47,860 --> 00:37:49,170
కాబట్టి అన్ని ఉంది.

864
00:37:49,170 --> 00:37:53,290
>> Binky ఈ చేశాడు కాబట్టి,
మట్టి కేవలం ఈ వంటి చూసారు.

865
00:37:53,290 --> 00:37:55,350
మరియు నిక్ కేవలం రకమైన
బాణాలు ముగిస్తుంది,

866
00:37:55,350 --> 00:37:57,590
అయితే వారు ఎక్కడైనా పై లేదు
ముఖ్యంగా, ఎందుకంటే వారు మాత్రమే ఉన్నారు

867
00:37:57,590 --> 00:37:58,250
చెత్త విలువలు.

868
00:37:58,250 --> 00:38:01,670
వారు స్పష్టంగా initialized లేదు
ఎక్కడైనా పెడుతోంది.

869
00:38:01,670 --> 00:38:03,980
>> ఇప్పుడు తదుపరి లైన్
కోడ్, రీకాల్, ఈ ఉంది.

870
00:38:03,980 --> 00:38:07,510
సహేతుక యూజర్ ఫ్రెండ్లీ కాబట్టి
కానీ కొంతవరకు సాంకేతిక ఇంగ్లీష్,

871
00:38:07,510 --> 00:38:09,790
కోడ్ చేస్తోంది ఈ లైన్ ఏమిటి?

872
00:38:09,790 --> 00:38:10,391
అవును?

873
00:38:10,391 --> 00:38:11,333
>> ప్రేక్షకులు: [వినబడని].

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> డేవిడ్ J. మలన్: పర్ఫెక్ట్.

876
00:38:13,950 --> 00:38:17,016
ఇది భాగం కేటాయించడం యొక్క
ఒక పూర్ణాంకానికి యొక్క పరిమాణం మెమరీ.

877
00:38:17,016 --> 00:38:18,140
మరియు ఆ సగం సమాధానం ఉంది.

878
00:38:18,140 --> 00:38:20,056
మీరు కుడి సమాధానం
వ్యక్తీకరణ సగం.

879
00:38:20,056 --> 00:38:22,473
ఏం జరుగుతుందో
సమాన సైన్ ఎడమ వైపు?

880
00:38:22,473 --> 00:38:22,972
అవును?

881
00:38:22,972 --> 00:38:24,814
ప్రేక్షకులు: గలవారు
ఇది వేరియబుల్ x కు?

882
00:38:24,814 --> 00:38:27,690
>> డేవిడ్ J. మలన్: మరియు గలవారు
ఇది వేరియబుల్ x కు.

883
00:38:27,690 --> 00:38:31,650
పునశ్చరణ, కుడి చేతి వైపు కేటాయించుకునే సో
తగినంత మెమరీ ఒక పూర్ణాంకానికి నిల్వ.

884
00:38:31,650 --> 00:38:34,150
కానీ malloc ప్రత్యేకంగా
చిరునామా తిరిగి

885
00:38:34,150 --> 00:38:37,270
మీరు చేసిన మెమరీ ఆ భాగం యొక్క
కేవలం x లో నిల్వ కావాలి ప్రతిపాదించారు.

886
00:38:37,270 --> 00:38:42,560
>> సో వాట్ నిక్ Binky తో చివరిసారిగా చేసింది ఉంది
అతను ఆ పాయింటర్ బయటకు లాగారు, మట్టి,

887
00:38:42,560 --> 00:38:46,820
మెమరీ తెలుపు భాగం వద్ద ఇప్పుడు మార్చాలి
ఒక పూర్ణాంకానికి యొక్క పరిమాణం సమానంగా ఉంది.

888
00:38:46,820 --> 00:38:49,360
నిజానికి, ఆ అర్థం ఉంది
నాలుగు బైట్లు సూచించడానికి.

889
00:38:49,360 --> 00:38:55,310
>> కోడ్ యొక్క ఇప్పుడు వచ్చే లైన్
ఈ చేశాడు, స్టార్ X 42 గెట్స్.

890
00:38:55,310 --> 00:38:58,530
కాబట్టి 42 సూటిగా ఉంటుంది
కుడి వైపు, జీవితం యొక్క అర్థం.

891
00:38:58,530 --> 00:39:00,500
ఎడమ చేతి వైపు, స్టార్ X అంటే అర్థం?

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
ఆ సరే gone-- ఆ చాలా కలిగి ఉండవచ్చు.

894
00:39:03,280 --> 00:39:04,220
సరే.

895
00:39:04,220 --> 00:39:06,875
>> ప్రేక్షకులు: సాధారణంగా,
[వినబడని] కు వెళ్ళండి

896
00:39:06,875 --> 00:39:07,750
డేవిడ్ J. మలన్: గుడ్.

897
00:39:07,750 --> 00:39:08,760
ప్రేక్షకులు: [వినబడని].

898
00:39:08,760 --> 00:39:09,760
డేవిడ్ J. మలన్: ఖచ్చితంగా.

899
00:39:09,760 --> 00:39:11,979
ఎడమ చేతి వైపు x కు వెళ్ళి అర్థం.

900
00:39:11,979 --> 00:39:12,520
X చిరునామా.

901
00:39:12,520 --> 00:39:15,520
ఇది 33 ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా Ox1 వంటిది.

902
00:39:15,520 --> 00:39:18,690
ఆ నక్షత్రం అని X వెళ్ళండి అర్థం
అడ్రసు మరియు అక్కడ ఉంచారు?

903
00:39:18,690 --> 00:39:19,520
42.

904
00:39:19,520 --> 00:39:21,290
>> కాబట్టి నిజంగా, ఆ నిక్ చేసాడు ఖచ్చితంగా ఏమిటి.

905
00:39:21,290 --> 00:39:23,740
అతను ద్వారా ప్రారంభించండి
ముఖ్యంగా, మానసికంగా

906
00:39:23,740 --> 00:39:26,270
ఒక వేలు వద్ద గురిపెట్టి
X, బాణం తర్వాత

907
00:39:26,270 --> 00:39:30,670
కుడి వైపు వైట్ బాక్స్
వైపు, మరియు అనేక 42 నిలిపివేసింది.

908
00:39:30,670 --> 00:39:34,120
కానీ విషయాలు వచ్చింది
చిన్న ప్రమాదకరమైన, కుడి?

909
00:39:34,120 --> 00:39:35,860
Binky తన తల కోల్పోతారు గురించి.

910
00:39:35,860 --> 00:39:39,465
>> స్టార్ Y అర్థం, 13, చెడు అదృష్టం సమానం?

911
00:39:39,465 --> 00:39:43,620
కాబట్టి స్టార్ Y అంటే Y చిరునామా వెళ్ళండి.

912
00:39:43,620 --> 00:39:45,630
కానీ Y చిరునామా ఏమిటి?

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
అన్ని కుడి, అది చెత్త విలువ, కుడి?

915
00:39:49,440 --> 00:39:50,800
నేను ఒక ప్రశ్న గుర్తు వంటి ఇది ఆకర్షించింది.

916
00:39:50,800 --> 00:39:54,850
నిక్ ఒక అప్ వంకరగా బాణం వంటి ఇది ఆకర్షించింది.

917
00:39:54,850 --> 00:39:59,600
మరియు వెంటనే మీకు ప్రయత్నించండి గా
అక్కడ వెళ్ళి చెప్పడం, స్టార్ Y చేయండి,

918
00:39:59,600 --> 00:40:03,872
కానీ ఒక చట్టబద్ధమైన లేదు
చిరునామా, అది కొన్ని బోగస్ బట్టి,

919
00:40:03,872 --> 00:40:05,080
క్రాష్ ప్రోగ్రామ్ జరగబోతోంది.

920
00:40:05,080 --> 00:40:08,580
మరియు Binky తల అన్నారు
ఇది ముందులా ఆఫ్ ఫ్లై.

921
00:40:08,580 --> 00:40:12,130
>> చివరికి, ఈ కార్యక్రమం కాబట్టి
కేవలం flat అవుట్ దోషం ఉంది.

922
00:40:12,130 --> 00:40:13,540
ఇది ఒక బగ్గీ కార్యక్రమం.

923
00:40:13,540 --> 00:40:14,760
మరియు అది నిర్ధారించడానికి అవసరమైన.

924
00:40:14,760 --> 00:40:18,260
మరియు మాత్రమే మార్గం, నిజంగా, దాన్ని పరిష్కరించడానికి
ఉంటుంది, ఉదాహరణకు, ఈ రేఖ

925
00:40:18,260 --> 00:40:21,010
మేము కూడా రాలేదు ఇది ఎందుకంటే
కార్యక్రమం చాలా త్వరగా కుప్పకూలింది.

926
00:40:21,010 --> 00:40:26,170
కానీ మేము ఈ పరిష్కరించడానికి ఒకవేళ, ఏ
ప్రభావం Y సమానంగా x చేస్తున్నానో చేస్తుంది?

927
00:40:26,170 --> 00:40:30,010
సరే, తప్పనిసరిగా వద్ద y పాయింట్లు
సంసార విలువ x వద్ద గురిపెట్టి ఉంటుంది.

928
00:40:30,010 --> 00:40:32,430
>> నిక్ యొక్క కథ లో,
లేదా Binky యొక్క కథ, రెండు

929
00:40:32,430 --> 00:40:34,640
x మరియు y వద్ద గురిపెట్టి చేయబడ్డాయి
మెమరీ తెలుపు భాగం,

930
00:40:34,640 --> 00:40:38,300
కాబట్టి, చివరకు, మీరు
y మళ్లీ 13 సమానం నటించనున్నాడు లేదు,

931
00:40:38,300 --> 00:40:43,080
మీరు 13 పెట్టటం ముగుస్తుంది
సరైన స్థానాన్ని.

932
00:40:43,080 --> 00:40:47,640
కాబట్టి ఈ పంక్తులు అన్ని ఖచ్చితంగా ఉంటాయి
చట్టబద్ధమైన, ఈ ఒక తప్ప,

933
00:40:47,640 --> 00:40:51,730
ఇది మీరు ముందు జరిగినప్పుడు
నిజానికి వై కొన్ని విలువ కేటాయించిన.

934
00:40:51,730 --> 00:40:54,290
>> ఇప్పుడు కృతజ్ఞతగా, మీరు లేదు
అన్ని ద్వారా కారణం కలిగి

935
00:40:54,290 --> 00:40:56,560
మీ స్వంత సమస్యలు ఈ రకాల.

936
00:40:56,560 --> 00:40:59,310
నాకు ముందుకు వెళ్లి తెరిచి లెట్
ఇక్కడ ఒక టెర్మినల్ విండో

937
00:40:59,310 --> 00:41:03,050
మరియు కేవలం ఒక క్షణం, తెరవడం,
ఒక చిన్న సూపర్ కార్యక్రమం

938
00:41:03,050 --> 00:41:04,360
కూడా అర్ధం యొక్క విధమైన ఉంది.

939
00:41:04,360 --> 00:41:05,152
ఇది అగ్లీ యొక్క.

940
00:41:05,152 --> 00:41:06,610
ఇది ఉపయోగకరమైన ఏదైనా సాధించడానికి లేదు.

941
00:41:06,610 --> 00:41:10,180
కానీ అది సమస్యలను ప్రదర్శించేందుకు లేదు
memory, కాబట్టి యొక్క పరిశీలించి తెలియజేయండి.

942
00:41:10,180 --> 00:41:11,830
>> మెయిన్, సూపర్ సాధారణ.

943
00:41:11,830 --> 00:41:14,830
ఇది స్పష్టంగా ఒక ఫంక్షన్ కాల్స్,
f, మరియు అప్పుడు 0 తిరిగి.

944
00:41:14,830 --> 00:41:16,310
ఇది మెస్ ఈ అప్ రకమైన కష్టం.

945
00:41:16,310 --> 00:41:18,540
కాబట్టి ప్రధాన ఇప్పటివరకు ప్రెట్టి గుడ్ ఉంది.

946
00:41:18,540 --> 00:41:20,100
>> కాబట్టి f సమస్యాత్మకంగా ఉంది.

947
00:41:20,100 --> 00:41:22,120
మరియు కేవలం చాలా పెట్టలేదు
నామకరణ లోకి ప్రయత్నం

948
00:41:22,120 --> 00:41:23,990
ఇక్కడ కోడ్ దృష్టి ఉంచాలని.

949
00:41:23,990 --> 00:41:25,740
F రెండు పంక్తులు కలిగి ఉంది.

950
00:41:25,740 --> 00:41:27,610
మరియు ఇప్పుడు జరగబోతోంది ఏమి చూడటానికి.

951
00:41:27,610 --> 00:41:29,840
కాబట్టి ఒక వైపు
ఇక్కడ నాకు తెలియజేయండి

952
00:41:29,840 --> 00:41:32,680
మునుపటి ఈ స్థిరమైన
ఒకవైపు ఉదాహరణకు,

953
00:41:32,680 --> 00:41:35,830
ఎడమ చేతి వైపు
ఇంగ్లీష్ లో, ఏమి చేస్తున్న?

954
00:41:35,830 --> 00:41:36,493
ఇది is--

955
00:41:36,493 --> 00:41:37,701
ప్రేక్షకులు: ఒక పాయింటర్ సృష్టిస్తోంది.

956
00:41:37,701 --> 00:41:40,830
డేవిడ్ J. మలన్: ఒక పాయింటర్ సృష్టిస్తోంది
ఒక పూర్ణాంకానికి అని పిలవడం ఇది x.

957
00:41:40,830 --> 00:41:43,789
కాబట్టి అది ఆ బాక్సులను ఒకటి సృష్టించడం
నేను టచ్ స్క్రీన్ తీసుకుంటూ వస్తున్నాను.

958
00:41:43,789 --> 00:41:45,913
మరియు ఇప్పుడు, కుడి చేతి మీద
వైపు, malloc, కోర్సు యొక్క,

959
00:41:45,913 --> 00:41:47,420
మెమరీ భాగం కేటాయించడం ఉంది.

960
00:41:47,420 --> 00:41:49,989
మరియు కేవలం స్పష్టతను, ఎలా
మెమరీని స్పష్టంగా అది ఉంది

961
00:41:49,989 --> 00:41:52,030
పెడుతోంది, మీరు కేవలం
రకమైన ఇక్కడ గణిత చేయండి?

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> కాబట్టి అది 40 బైట్లు ఉంది.

964
00:41:54,040 --> 00:41:57,400
మరియు నాకు తెలుసు అని నేను తెలుసు మాత్రమే ఎందుకంటే
Int, CS50 ఉపకరణం, కనీసం,

965
00:41:57,400 --> 00:41:58,060
నాలుగు బైట్లు.

966
00:41:58,060 --> 00:41:59,610
కాబట్టి 10 సార్లు 4 40 ఉంది.

967
00:41:59,610 --> 00:42:04,924
కాబట్టి ఈ ఒక x నిల్వ, చిరునామా
40 ints యొక్క మొదటి ఆ

968
00:42:04,924 --> 00:42:07,340
తిరిగి కేటాయించింది చేశారు
తిరిగి, తిరిగి, తిరిగి.

969
00:42:07,340 --> 00:42:08,470
>> ఆ malloc గురించి కీ ఏమిటి.

970
00:42:08,470 --> 00:42:11,261
ఇది ఒక చిన్న మెమరీ తీసుకోదు
ఇక్కడ, ఇక్కడ కొద్దిగా, కొద్దిగా ఇక్కడ.

971
00:42:11,261 --> 00:42:14,220
ఇది, మీరు మెమరీ ఒకటి భాగం ఇస్తుంది
పక్కపక్కన, ఆపరేటింగ్ నుండి

972
00:42:14,220 --> 00:42:15,240
వ్యవస్థ.

973
00:42:15,240 --> 00:42:18,500
>> ఇప్పుడు ఈ గురించి ఏమి,
X బ్రాకెట్ 10 0 సమానం?

974
00:42:18,500 --> 00:42:19,470
కోడ్ అనియత లైన్.

975
00:42:19,470 --> 00:42:21,100
ఇది ఉపయోగకరమైన ఏదైనా సాధించడానికి లేదు.

976
00:42:21,100 --> 00:42:26,128
కానీ అది ఆసక్తికరంగా ఉంటుంది,
X బ్రాకెట్ 10-- ఎందుకంటే?

977
00:42:26,128 --> 00:42:26,628
అవును?

978
00:42:26,628 --> 00:42:27,912
>> ప్రేక్షకులు: [వినబడని]?

979
00:42:27,912 --> 00:42:30,500
>> డేవిడ్ J. మలన్: X బ్రాకెట్
10 శూన్య ఉండాలి లేదు.

980
00:42:30,500 --> 00:42:35,070
శూన్య వివరాలు మాత్రమే ఆటలోకి వస్తుంది
తీగలను తో, ఒక స్ట్రింగ్ చివరిలో.

981
00:42:35,070 --> 00:42:36,700
కానీ ఒక మంచి ఆలోచన.

982
00:42:36,700 --> 00:42:39,615
>> ఎంత పెద్ద కూడా, ఈ శ్రేణి
నేను 40 బైట్లు కేటాయించింది చేసిన అయితే?

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
ఇది కుడి, తొమ్మిది ద్వారా 0?

985
00:42:43,690 --> 00:42:45,120
ఇది మొత్తం 10 ints యొక్క.

986
00:42:45,120 --> 00:42:48,790
40 బైట్లు, కానీ 10 ints,
0 ద్వారా ఇండెక్స్ 0.

987
00:42:48,790 --> 00:42:50,930
>> కాబట్టి ఆ x బ్రాకెట్ 10 ఏమి ఉంది?

988
00:42:50,930 --> 00:42:53,090
ఇది నిజానికి కొన్ని
తెలియని చెత్త విలువ.

989
00:42:53,090 --> 00:42:54,780
ఇది నాకు చెందినవి లేని మెమరీ ఉంది.

990
00:42:54,780 --> 00:42:59,650
నేను ఆ తాకడం చేయరాదు
బైట్ సంఖ్య 41, 42, 43, 44.

991
00:42:59,650 --> 00:43:01,420
నేను చాలా దూరం కొద్దిగా వెళుతున్న.

992
00:43:01,420 --> 00:43:04,490
>> నిజానికి, నేను అమలు చేస్తే ఈ
కార్యక్రమం, ఇది చాలా బాగా క్రాష్ కావచ్చు.

993
00:43:04,490 --> 00:43:05,790
కానీ కొన్నిసార్లు, మేము లక్కీ పొందుతారు.

994
00:43:05,790 --> 00:43:07,706
కాబట్టి కేవలం ప్రదర్శించేందుకు
దీన్ని మరియు స్పష్టముగా,

995
00:43:07,706 --> 00:43:11,000
మీరు ముందు తెలుసు ఎప్పుడూ
దాన్ని యొక్క ఈ అమలు అనుమతిస్తాయి లేదు.

996
00:43:11,000 --> 00:43:12,480
ఇది వాస్తవానికి క్రాష్ లేదు.

997
00:43:12,480 --> 00:43:15,032
>> కానీ నేను ఈ మార్చుకుంటే
ఉదాహరణకు, 1,000 ఉండాలనే

998
00:43:15,032 --> 00:43:16,740
నిజంగా ఈ చేయడానికి
ఉద్దేశపూర్వక, యొక్క చూసేలా

999
00:43:16,740 --> 00:43:18,710
మేము లభిస్తే అది ఈ సమయంలో క్రాష్.

1000
00:43:18,710 --> 00:43:20,070
OK, అది క్రాష్ లేదు.

1001
00:43:20,070 --> 00:43:22,600
ఎలా 100,000 గురించి?

1002
00:43:22,600 --> 00:43:25,000
యొక్క ఇది రీమేక్ లెట్, మరియు ఇప్పుడు అది తిరిగి.

1003
00:43:25,000 --> 00:43:25,500
సరే.

1004
00:43:25,500 --> 00:43:25,960
అయ్యో.

1005
00:43:25,960 --> 00:43:26,460
అన్ని కుడి.

1006
00:43:26,460 --> 00:43:29,090
కాబట్టి స్పష్టంగా, మళ్ళీ, ఈ
మెమరీ విభాగాలు, కాబట్టి, మాట్లాడటం

1007
00:43:29,090 --> 00:43:32,660
కాబట్టి మేము, సహేతుక పెద్ద ఉంటాయి
మళ్లీ మళ్లీ అదృష్ట పొందుటకు.

1008
00:43:32,660 --> 00:43:36,510
కానీ చివరికి, ఒకసారి మీరు హాస్యాస్పదంగా పొందండి
మరియు నిజంగా, తెరపై చాలా అవ్ట్ వెళ్ళి

1009
00:43:36,510 --> 00:43:39,120
మీరు నిజంగా మెమరీ టచ్
నిజంగా మీకు చెందదు.

1010
00:43:39,120 --> 00:43:40,870
>> కానీ స్పష్టముగా, ఈ
దోషాలు రకాల వెళ్తున్నారు

1011
00:43:40,870 --> 00:43:43,020
కష్టం మరియు కష్టం అని
మీ స్వంత న గుర్తించడానికి.

1012
00:43:43,020 --> 00:43:47,880
కానీ కృతజ్ఞతగా, ప్రోగ్రామర్లు, మేము కలిగి
మా కోసం దీన్ని అనుమతించే ఉపకరణాలు.

1013
00:43:47,880 --> 00:43:50,140
కాబట్టి ఈ బహుశా, ఒకటి
ugliest కార్యక్రమాలు

1014
00:43:50,140 --> 00:43:52,060
GDB యొక్క అవుట్పుట్ కంటే కూడా uglier.

1015
00:43:52,060 --> 00:43:55,670
కానీ ఇది ఎల్లప్పుడూ ఒక లైన్ ఉంది లేదా
సూపర్ ఉపయోగకరంగా రెండు.

1016
00:43:55,670 --> 00:44:00,310
>> Valgrind సహాయపడుతుంది కార్యక్రమం
మీరు ఒక ప్రోగ్రామ్ డీబగ్ కాదు, ప్రతి SE,

1017
00:44:00,310 --> 00:44:03,500
కానీ మెమరీ సంబంధిత కనుగొనేందుకు
సమస్యలు, ప్రత్యేకంగా.

1018
00:44:03,500 --> 00:44:07,590
ఇది స్వయంచాలకంగా మీ కోడ్ అమలు చేస్తుంది
మీరు మరియు కనీసం రెండు విషయాలు కోసం చూడండి.

1019
00:44:07,590 --> 00:44:10,680
ఒకటి, మీరు ఏదో చేసావ్
టచ్ మెమరీ వంటి ప్రమాదవశాత్తు

1020
00:44:10,680 --> 00:44:11,980
మీరు ఉండలేదు?

1021
00:44:11,980 --> 00:44:13,590
ఇది మీరు ఆ సందర్భాలలో సహాయపడుతుంది.

1022
00:44:13,590 --> 00:44:15,710
>> రెండు, అది సహాయం చేస్తుంది
మీరు అని ఏదో కనుగొనేందుకు

1023
00:44:15,710 --> 00:44:19,270
మెమరీ లీకేజ్, మేము కలిగి
పూర్తిగా నిర్లక్ష్యం, naively,

1024
00:44:19,270 --> 00:44:21,380
కొంత సమయం కోసం మరియు పరమానందంగా.

1025
00:44:21,380 --> 00:44:23,140
కానీ ఇది అన్ని అవుతుంది
ఈ సమయంలో, చేసినప్పుడు

1026
00:44:23,140 --> 00:44:26,620
మీరు GetString లో అని చేసిన
మా కార్యక్రమాలు చాలా ఉన్నాయి,

1027
00:44:26,620 --> 00:44:28,930
మీరు ఆపరేటింగ్ అభ్యర్థిస్తున్నాము
మెమరీ సిస్టమ్,

1028
00:44:28,930 --> 00:44:32,070
కానీ మీరు ఏ జ్ఞప్తికి తెచ్చుకొను
ఎప్పుడూ ఇవ్వడం

1029
00:44:32,070 --> 00:44:36,169
తిరిగి చేస్తున్న unalloc, లేదా
ఉచిత, అది అని.

1030
00:44:36,169 --> 00:44:37,960
లేదు, ఎందుకంటే మేము ఎప్పుడూ చేసిన
అలా మీరు అడిగారు.

1031
00:44:37,960 --> 00:44:41,250
>> కానీ ఈ సమయంలో, కార్యక్రమాలు
మీరు C లో రాయడం చేసిన

1032
00:44:41,250 --> 00:44:43,800
మెమరీ లీకింగ్ చేశారు
ఆపరేటింగ్ అడుగుతూ

1033
00:44:43,800 --> 00:44:46,190
మరింత సిస్టమ్
తీగలను మరియు whatnot మెమరీ,

1034
00:44:46,190 --> 00:44:47,870
కానీ అది తిరిగి ఇవ్వడానికి ఎప్పుడూ.

1035
00:44:47,870 --> 00:44:50,080
ఇప్పుడు ఈ ఒక బిట్ ఉంది
ఒక అతిసూక్ష్మీకరణ,

1036
00:44:50,080 --> 00:44:53,550
కానీ మీరు ఎప్పుడూ మీరు మీరు మీ Mac అమలు లేదా
కొంతకాలంగా ప్రారంభ కోసం మీ PC

1037
00:44:53,550 --> 00:44:55,790
కార్యక్రమాలు మా,
బహుశా, కార్యక్రమాలు మూసివేయడం

1038
00:44:55,790 --> 00:44:57,795
అయినప్పటికీ మీ
కంప్యూటర్ క్రాష్ లేదు,

1039
00:44:57,795 --> 00:45:01,690
అది చాలా నెమ్మదిగా సంతరించుకోనుంది
ఇది నిజంగా అయితే వంటి

1040
00:45:01,690 --> 00:45:04,290
మెమరీ చాలా ఉపయోగించి లేదా
వనరులు, అయినప్పటికీ,

1041
00:45:04,290 --> 00:45:06,070
మీరు తెలియకపోతే కూడా
కీబోర్డును స్పృశించడం,

1042
00:45:06,070 --> 00:45:10,430
ఆ ఉండబోతుంది కానీ always-- గలిగారు
కార్యక్రమాలు మీరు రన్ చేస్తున్న ఉంటుంది

1043
00:45:10,430 --> 00:45:11,920
తాము మెమరీ లీకేజ్.

1044
00:45:11,920 --> 00:45:15,645
మరియు వారు మరింత మరియు OS అడగడం
మరింత మెమరీ ఉంది, కానీ దాని గురించి మర్చిపోకుండా,

1045
00:45:15,645 --> 00:45:18,470
నిజానికి, ఇది ఉపయోగించడం లేదు కానీ
అందువలన దూరంగా మెమరీ తీసుకొని

1046
00:45:18,470 --> 00:45:20,500
కావలసిన ఉండవచ్చు ఇతర కార్యక్రమాలు నుండి.

1047
00:45:20,500 --> 00:45:23,940
కాబట్టి ఒక సాధారణ వివరణ ఉంది.

1048
00:45:23,940 --> 00:45:25,940
ఇప్పుడు ఇక్కడ ఎక్కడ Valgrind యొక్క వార్తలు
అవుట్పుట్ పూర్తిగా ఉంది

1049
00:45:25,940 --> 00:45:29,290
ఆ తక్కువ దారుణమైన
మరియు అలైక్ మరింత సౌకర్యవంతమైన.

1050
00:45:29,290 --> 00:45:32,690
కానీ ఆసక్తికరమైన
అంశాలు ఇక్కడ కుడి అప్ ఉంది.

1051
00:45:32,690 --> 00:45:37,060
ఇది నాకు ఒక చెల్లని రాసే చెప్తుంటాడు
పరిమాణం నాలుగు, ఈ కార్యక్రమం జరుగుతుంది

1052
00:45:37,060 --> 00:45:40,640
ముఖ్యంగా, memory.c యొక్క లైన్ 21 వద్ద.

1053
00:45:40,640 --> 00:45:45,450
>> నేను HM, అక్కడ నిజానికి, 21 వరుసలో వెళ్ళి ఉంటే
పరిమాణం నాలుగు చెల్లని రాసే ఉంది.

1054
00:45:45,450 --> 00:45:46,250
ఎందుకు పరిమాణం నాలుగు?

1055
00:45:46,250 --> 00:45:49,500
Well, ఈ సంఖ్య మరియు అది
ఏదైనా కావచ్చు ఒక పూర్ణాంకానికి ఉంది.

1056
00:45:49,500 --> 00:45:50,450
అది నాలుగు బైట్లు ఉంది.

1057
00:45:50,450 --> 00:45:52,550
కాబట్టి నేను నాలుగు బైట్లు చూస్తూ నేను
అక్కడ వారు లభించవు.

1058
00:45:52,550 --> 00:45:55,080
ఆ ఏమి Valgrind వార్తలు
నిజానికి నాకు చెప్తుంటాడు.

1059
00:45:55,080 --> 00:45:57,600
అంతేకాక, అది కూడా రెడీ
మేము చూస్తారు వంటి, నాకు చెప్పండి,

1060
00:45:57,600 --> 00:46:01,490
మీరు ఈ భవిష్యత్ pset లో అమలు వంటి, మరియు
మీరు ఇది నిజానికి మెమరీ, వెల్లడైంది చేసినప్పుడు

1061
00:46:01,490 --> 00:46:05,300
నేను అని చేసిన ఎందుకంటే నేను కలిగి
malloc, కానీ నేను నిజానికి కాదు కలిగి

1062
00:46:05,300 --> 00:46:08,010
ఉచిత, ఈ సందర్భంలో, ఒక అని,
ఇది మేము చివరికి చూస్తారు

1063
00:46:08,010 --> 00:46:09,830
malloc యొక్క వ్యతిరేకం.

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> కాబట్టి ఇప్పుడు, నేను, ఒక చివరి ఉదాహరణకు అనుకుంటున్నాను.

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
కాబట్టి ఈ ఒక కొంచెం వార్తలు
రహస్యములు, కానీ అది బహుశా వార్తలు

1068
00:46:16,690 --> 00:46:19,180
అతిపెద్ద కారణం
స్మృతితో జాగ్రత్తగా ఉండాలి

1069
00:46:19,180 --> 00:46:24,490
మరియు కారణం అనేక కార్యక్రమాలు
మరియు కూడా ఈ రోజు / లేదా వెబ్ సర్వర్లు,

1070
00:46:24,490 --> 00:46:28,200
ఎక్కడో చెడు అబ్బాయిలు స్వాధీనం
ఇంటర్నెట్ లో ఏదో ఎవరు

1071
00:46:28,200 --> 00:46:33,390
మీ సర్వర్కు బోగస్ ప్యాకెట్లను పంపడం
మీ ఖాతాలను రాజీ ప్రయత్నిస్తున్న,

1072
00:46:33,390 --> 00:46:36,420
లేదా మీ డేటా పడుతుంది, లేదా కేవలం
సాధారణంగా ఒక యంత్రం పై పడుతుంది.

1073
00:46:36,420 --> 00:46:38,910
బఫర్ ఓవర్ఫ్లో, వంటి
పేరు, అంటే సూచిస్తుంది

1074
00:46:38,910 --> 00:46:40,740
ఒక Int, కానీ ఒక బఫర్ పొంగి.

1075
00:46:40,740 --> 00:46:43,490
మరియు ఒక బఫర్ కేవలం ఒక ఫాన్సీ మార్గం
చెప్పడం మెమరీ బంచ్ ఉంది.

1076
00:46:43,490 --> 00:46:46,710
>> నిజానికి, నేను ఒక స్ట్రింగ్ అనే
బదులుగా s యొక్క బఫర్, ముందు.

1077
00:46:46,710 --> 00:46:49,234
అది ఒక బఫర్ ఉంటే ఎందుకంటే,
YouTube అర్థంలో వంటి,

1078
00:46:49,234 --> 00:46:52,400
లేదా మీరు ఒక వీడియో చూడటం చేసినప్పుడు,
మీరు పదం బఫరింగ్ చూసిన ఉండవచ్చు,

1079
00:46:52,400 --> 00:46:53,040
డాట్, డాట్ డాట్.

1080
00:46:53,040 --> 00:46:54,240
ఇది చాలా బాధించే ఉంది.

1081
00:46:54,240 --> 00:46:55,990
మరియు కేవలం అర్థం
మీ వీడియో ఆటగాడు

1082
00:46:55,990 --> 00:46:58,710
మా డౌన్లోడ్ ప్రయత్నిస్తున్నారు
బైట్లు బైట్లు, బోలెడంత

1083
00:46:58,710 --> 00:47:00,170
ఇంటర్నెట్ నుండి ఒక వీడియో నుండి.

1084
00:47:00,170 --> 00:47:02,920
కానీ నెమ్మదిగా, కనుక అది ప్రయత్నిస్తున్నాడు
వాటిని కొంత డౌన్లోడ్

1085
00:47:02,920 --> 00:47:06,430
కాబట్టి ఒక బఫర్ ఒక కంటైనర్, పూరించడానికి
మీరు అది అప్పుడు తగినంత బైట్లు

1086
00:47:06,430 --> 00:47:09,174
, మీరు వీడియో చూపించు
నిరంతరం pausing లేకుండా.

1087
00:47:09,174 --> 00:47:11,340
కానీ మీకు టర్న్స్
ఈ పెద్ద ఒక బఫర్.

1088
00:47:11,340 --> 00:47:15,710
కానీ ఈ చాలా డేటా ఉంచాలి ప్రయత్నించండి
అది, చాలా చెడ్డ విషయాలు జరుగుతుంది.

1089
00:47:15,710 --> 00:47:22,780
కాబట్టి ఉదాహరణకు, యొక్క చూద్దాం
ఒక ఉదాహరణ ఈ ఫైనల్ టీజర్.

1090
00:47:22,780 --> 00:47:24,720
ఈ మరొక కార్యక్రమం
ఆ, మొదటి చూపులో,

1091
00:47:24,720 --> 00:47:26,540
సూపర్ ఉపయోగకరమైన ఏమీ లేదు.

1092
00:47:26,540 --> 00:47:29,590
ఇది ఒక ప్రధాన ఫంక్షన్ సంపాదించి
ఆ F, ఆ ఫంక్షన్ కాల్స్.

1093
00:47:29,590 --> 00:47:36,640
మరియు ఆ ఫంక్షన్ f, ఇక్కడ ఉంది
ఒక చార్ అర్రే పరిమాణం 12, c అనే.

1094
00:47:36,640 --> 00:47:39,340
ఆపై ఈ ఉపయోగించి
కొత్త ఫంక్షన్ strncpy అని.

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> ఇది, ఈ సాధారణ, ఆ బయటకు వస్తాడు
కోడ్ యొక్క సాధారణ లైన్, కేవలం రెండు పంక్తులు

1097
00:47:45,190 --> 00:47:49,130
మేము నా పూర్తి ప్రోగ్రామ్ చేసిన
అందువలన, నా పూర్తి కంప్యూటర్,

1098
00:47:49,130 --> 00:47:54,000
మరియు నా యూజర్ ఖాతా, మరియు నా హార్డ్
ఎవరికైనా సమర్థవంతంగా అవకాశం డ్రైవ్

1099
00:47:54,000 --> 00:47:58,170
ఎవరు తెలుసు మరియు అమలు చేయడానికి తగినంత మంచి ఉంది
ఒక నిర్దిష్ట కమాండ్ లైన్ తో ఈ కార్యక్రమం

1100
00:47:58,170 --> 00:47:58,900
వాదన.

1101
00:47:58,900 --> 00:48:03,400
ఇతర మాటలలో, ఈ చెడ్డ వ్యక్తి
టైప్ చేసి argvargv [1] లోపలి ఉంచుతుంది

1102
00:48:03,400 --> 00:48:08,750
కీబోర్డ్ చాలా ప్రత్యేకంగా రూపొందించుకున్న వద్ద
స్ట్రింగ్, ABC, 123, కానీ ముఖ్యంగా,

1103
00:48:08,750 --> 00:48:15,180
ఎక్జిక్యూటబుల్ సూచించే బైనరీ చిహ్నాలు
కోడ్, అతను లేదా ఆమె రాశారు ఒక కార్యక్రమం,

1104
00:48:15,180 --> 00:48:19,190
ఇది ఈ సులభమైన కార్యక్రమం తో
కార్యక్రమాలు వేల ప్రతినిధి

1105
00:48:19,190 --> 00:48:23,610
ఆ విశ్వసించుటకు సిద్ధంగానుండు, అదేవిధంగా గురవుతుంటాయి
అతను లేదా ఆమె చివరకు అన్ని తొలగించవచ్చు

1106
00:48:23,610 --> 00:48:26,680
నా హార్డు డ్రైవు ఫైళ్లను, ఒక పొందండి
అతను లేదా ఆమె తద్వారా ప్రాంప్ట్ మెరిసే

1107
00:48:26,680 --> 00:48:30,170
వారి సొంత ఆదేశాలను టైప్
నాకు అన్ని ఫైళ్ళను ఇమెయిల్.

1108
00:48:30,170 --> 00:48:34,660
నేను చేయవచ్చు ఏదైనా, అతను
లేదా ఆమె ఈ కోడ్ తో చేయవచ్చు.

1109
00:48:34,660 --> 00:48:36,575
>> మేము చాలా ఇంకా ఈ పరిష్కరించడానికి కాదు.

1110
00:48:36,575 --> 00:48:38,700
నిజానికి, ఇది జరగబోతోంది
ఒక చిన్న చిత్రాన్ని కలిగి

1111
00:48:38,700 --> 00:48:41,470
ఈ వంటి, మేము వెంటనే వచ్చి చేస్తాము దీనిలో
అన్ని మంచి అర్థం.

1112
00:48:41,470 --> 00:48:44,480
కానీ నేడు, యొక్క అంతం తెలియజేయండి
కొద్దిగా ఎక్కువ ఆశాజనక, ఏమిటి

1113
00:48:44,480 --> 00:48:48,360
అర్థమయ్యేలా xkcd జోక్,
మేము తదుపరి సమయం రెస్యూమ్ వరకు.

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
అన్ని కుడి.

1116
00:48:51,600 --> 00:48:53,446
బుధవారం మీరు చూడండి.

1117
00:48:53,446 --> 00:48:54,754
>> [సంగీతాన్ని]

1118
00:48:54,754 --> 00:48:57,790
>> స్పీకర్: ఇప్పుడు, లోతైన
Daven Farnham ఆలోచనలు,.

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
మెమరీ కుప్ప దూకి వంటిది
ఒక ఆదివారం మధ్యాహ్నం బంగారు ఆకులు.

1121
00:49:04,770 --> 00:49:09,000
గాలి వీచే, ఎగరవేసినప్పుడు మీ
ఓహ్ hair--, నేను రోజుల when-- మిస్

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [నవ్వు]

1124
00:49:12,650 --> 00:49:13,750