1
00:00:00,000 --> 00:00:01,110
>> [సంగీతాన్ని]

2
00:00:01,110 --> 00:00:10,567

3
00:00:10,567 --> 00:00:11,650
డేవిడ్ J. మలన్: అన్ని కుడి.

4
00:00:11,650 --> 00:00:15,610
ఈ CS50, మరియు ఈ
వీక్ నాలుగు ముగింపు.

5
00:00:15,610 --> 00:00:19,420
మరియు విషయాలు ఒకటి నేడు
డిజిటల్ ఫోరెన్సిక్స్, ఉంది

6
00:00:19,420 --> 00:00:20,989
సమాచారం కోలుకుంటున్నారు కళ.

7
00:00:20,989 --> 00:00:22,780
నిజానికి, అయినప్పటికీ
మీరు మధ్యలో ఉన్నాము

8
00:00:22,780 --> 00:00:25,070
ప్రస్తుతం శాంతి మూడు వద్ద
మరియు బ్రేక్అవుట్, వచ్చే వారం,

9
00:00:25,070 --> 00:00:27,880
దృష్టి ఉంటుంది
ఖచ్చితంగా ఈ డొమైన్.

10
00:00:27,880 --> 00:00:30,686
>> చక్కని ఉద్యోగాలు సో నేను ఎప్పుడూ చేసిన ఒక
వచ్చింది, తిరిగి గ్రాడ్యుయేట్ పాఠశాలలో

11
00:00:30,686 --> 00:00:33,560
నేను స్థానిక పనిచేస్తున్నారు ఉన్నప్పుడు
మిడిల్సెక్స్ కౌంటీ జిల్లా అటార్నీ

12
00:00:33,560 --> 00:00:34,950
ఆఫీసు, చేస్తున్న ఫోరెన్సిక్స్ పని.

13
00:00:34,950 --> 00:00:37,450
కాబట్టి ముఖ్యంగా, మసాచుసెట్స్
రాష్ట్ర పోలీసులు, సందర్భంగా,

14
00:00:37,450 --> 00:00:40,100
కేసులపై పనిచేసేటప్పుడు చేస్తాను
హార్డ్ డ్రైవ్లు వంటి విషయాల తీసుకుని

15
00:00:40,100 --> 00:00:42,185
మరియు ఫ్లాపీ డిస్క్
మెమరీ కార్డులు మరియు ఇష్టపడుతున్నారు.

16
00:00:42,185 --> 00:00:44,060
మరియు వారు వాటిని అప్పగిస్తాం అని
నాకు మరియు నా గురువు,

17
00:00:44,060 --> 00:00:48,070
మరియు మా లక్ష్యం సాక్ష్యం కనుగొనేందుకు ఉంది
ఈ మీడియా మీద ఏ, ఉంది ఉంటే.

18
00:00:48,070 --> 00:00:50,700
ఇప్పుడు, మీరు చూసిన ఉండవచ్చు గ్లింప్సెస్
ఫోరెన్సిక్స్ ఈ ప్రపంచంలోని

19
00:00:50,700 --> 00:00:53,000
మీడియా, TV మరియు సినిమాలు.

20
00:00:53,000 --> 00:00:55,730
కానీ ఉద్యోగం నేను కలిగి, మరియు
విశ్వసించుటకు సిద్ధంగానుండు ప్రపంచానికి

21
00:00:55,730 --> 00:00:57,550
మీరు చూడగలం వంటి చాలా కాదు.

22
00:00:57,550 --> 00:01:00,794
యొక్క పరిశీలించి లెట్ ఏమి
మీరు బహుశా చూసిన చేసిన.

23
00:01:00,794 --> 00:01:01,460
[వీడియో ప్లేబ్యాక్]

24
00:01:01,460 --> 00:01:02,930
-OK.

25
00:01:02,930 --> 00:01:05,380
ఇప్పుడు, మీరు ఒక మంచి లుక్ పొందుటకు వీలు.

26
00:01:05,380 --> 00:01:06,850
>> [సంగీతాన్ని]

27
00:01:06,850 --> 00:01:12,260

28
00:01:12,260 --> 00:01:12,932
>> ఇది -Hold.

29
00:01:12,932 --> 00:01:13,657
ఆ వెనుక అమలు.

30
00:01:13,657 --> 00:01:14,733
>> ఒక నిమిషం -Wait.

31
00:01:14,733 --> 00:01:15,233
కుడి వెళ్ళండి.

32
00:01:15,233 --> 00:01:16,371

33
00:01:16,371 --> 00:01:16,870
-There.

34
00:01:16,870 --> 00:01:17,369
ఆ ఫ్రీజ్.

35
00:01:17,369 --> 00:01:17,930
BREAK -సంపూర్ణ స్క్రీన్.

36
00:01:17,930 --> 00:01:18,376
>> -OK.

37
00:01:18,376 --> 00:01:18,875
ఆ ఫ్రీజ్.

38
00:01:18,875 --> 00:01:20,160
మీరు, ఆ పై అప్ -Tighten?

39
00:01:20,160 --> 00:01:22,126
>> ఆ లో -Vector
తిరిగి వీల్ ద్వారా గై.

40
00:01:22,126 --> 00:01:24,435
>> ఇక్కడే ఈ స్పాట్ లో -Zoom.

41
00:01:24,435 --> 00:01:28,580
>> కుడి పరికరాలు ఉంటుది-,
చిత్రం విస్తరించి పదును చేయవచ్చు.

42
00:01:28,580 --> 00:01:29,330
>> ఆ -What వార్తలు?

43
00:01:29,330 --> 00:01:30,780
>> -ఇది ఒక వృద్ది కార్యక్రమం.

44
00:01:30,780 --> 00:01:32,170
>> ఆ అప్ ఏ స్పష్టమైన మీరు -Can?

45
00:01:32,170 --> 00:01:33,070
>> -I తెలియదు.

46
00:01:33,070 --> 00:01:34,150
యొక్క పెంచడానికి లెట్.

47
00:01:34,150 --> 00:01:35,440
>> -Enhance విభాగం A6.

48
00:01:35,440 --> 00:01:36,570

49
00:01:36,570 --> 00:01:38,562
నేను వివరాలు మెరుగైన, మీరే

50
00:01:38,562 --> 00:01:40,020
-I విస్తరించేందుకు తగినంత ఉందని నేను అనుకుంటున్నాను.

51
00:01:40,020 --> 00:01:40,976
నా స్క్రీన్ దానిని విడుదల.

52
00:01:40,976 --> 00:01:42,559
>> -I ఆమె కంటిలో ప్రతిబింబం విస్తరించింది.

53
00:01:42,559 --> 00:01:44,322
-Let ద్వారా ఈ అమలు
వీడియో మెరుగుదల.

54
00:01:44,322 --> 00:01:45,210
>> -ఎడ్గార్, మీరు ఈ విస్తరించేందుకు చేయవచ్చు?

55
00:01:45,210 --> 00:01:45,710
>> న -Hang.

56
00:01:45,710 --> 00:01:47,570

57
00:01:47,570 --> 00:01:49,458
>> ఈ తెలివితో పని -I've.

58
00:01:49,458 --> 00:01:50,402
>> -ఉంది ఒకరి ప్రతిబింబం.

59
00:01:50,402 --> 00:01:50,902
>> -Reflection.

60
00:01:50,902 --> 00:01:52,870
మనిషి ముఖం యొక్క ప్రతిబింబం-ఉంది.

61
00:01:52,870 --> 00:01:53,694
>> -ఫిల్టర్లు ప్రతిబింబం!

62
00:01:53,694 --> 00:01:54,610
ప్రతిబింబం-ఉంది.

63
00:01:54,610 --> 00:01:55,880
అద్దం లో -Zoom.

64
00:01:55,880 --> 00:01:57,860
మీరు ఒక పరావర్తనం చూడగలరు.

65
00:01:57,860 --> 00:01:59,630
>> మీరు ఇక్కడ నుండి చిత్రం విస్తరించేందుకు -Can?

66
00:01:59,630 --> 00:02:00,377

67
00:02:00,377 --> 00:02:01,210
మీరు విస్తరించేందుకు -Can?

68
00:02:01,210 --> 00:02:02,190
మీరు విస్తరించేందుకు -Can?

69
00:02:02,190 --> 00:02:03,066
మేము ఈ విస్తరించేందుకు -Can?

70
00:02:03,066 --> 00:02:03,898
మీరు విస్తరించేందుకు -Can?

71
00:02:03,898 --> 00:02:04,740
రెండవ -Hold.

72
00:02:04,740 --> 00:02:05,281
నేను విస్తరించేందుకు చేస్తాము.

73
00:02:05,281 --> 00:02:06,470
తలుపు లో -Zoom.

74
00:02:06,470 --> 00:02:06,970
10 -Times.

75
00:02:06,970 --> 00:02:08,009
-Zoom.

76
00:02:08,009 --> 00:02:08,509
లో -Move.

77
00:02:08,509 --> 00:02:09,340
యంత్రాలు ఎక్కువగా.

78
00:02:09,340 --> 00:02:10,094
-Wait, ఆపడానికి.

79
00:02:10,094 --> 00:02:10,750
-Stop.

80
00:02:10,750 --> 00:02:11,250
ఇది -Pause.

81
00:02:11,250 --> 00:02:13,542
మాకు 75 డిగ్రీల -Rotate
నిలువు చుట్టూ దయచేసి.

82
00:02:13,542 --> 00:02:14,750

83
00:02:14,750 --> 00:02:16,127
>> -Stop.

84
00:02:16,127 --> 00:02:19,330
భాగం తిరిగి వెళ్ళు
తలుపు గురించి మళ్ళీ.

85
00:02:19,330 --> 00:02:21,420
>> బిట్మ్యాప్ ఒక చిత్రం పెంచే -Got?

86
00:02:21,420 --> 00:02:24,420
>> మేము ప్రదీప్ సింగ్ ఉపయోగించవచ్చు -Maybe
పద్ధతి Windows లోకి చూడటానికి.

87
00:02:24,420 --> 00:02:25,902
>> -ఫిల్టర్లు సాఫ్ట్వేర్ కళ యొక్క రాష్ట్రం.

88
00:02:25,902 --> 00:02:26,866
>> -ఫిల్టర్లు Eigenvalue ఆఫ్ ఉంది.

89
00:02:26,866 --> 00:02:29,758
>> కుడి ఉంటుది-
అల్గోరిథంలు యొక్క కలయిక

90
00:02:29,758 --> 00:02:32,168
>> -He యొక్క తీసుకున్న ప్రకాశం
తదుపరి స్థాయికి క్రమసూత్ర

91
00:02:32,168 --> 00:02:34,110
మరియు నేను వాటిని ఉపయోగించవచ్చు
ఈ ఛాయాచిత్రం మెరుగుపరచండి.

92
00:02:34,110 --> 00:02:36,840
>> న -Lock మరియు z అక్షం వచ్చేలా.

93
00:02:36,840 --> 00:02:37,351
>> -Enhance.

94
00:02:37,351 --> 00:02:37,850
పెంచు.

95
00:02:37,850 --> 00:02:38,720
-Enhance.

96
00:02:38,720 --> 00:02:40,070
-Freeze మరియు మెరుగుపరచడానికి.

97
00:02:40,070 --> 00:02:43,420
[END వీడియో ప్లేబ్యాక్]

98
00:02:43,420 --> 00:02:45,830
డేవిడ్ J. మలన్: సో ఉంటాయి
అన్ని పదాలు, కానీ వారు కాదు

99
00:02:45,830 --> 00:02:47,870
సరిగ్గా వాక్యాలను ఉపయోగించారు.

100
00:02:47,870 --> 00:02:52,370
నిజానికి భవిష్యత్తులో, ఏ సమయంలో,
మీరు ఎవరైనా పదం చెప్పే వినడానికి దయచేసి,

101
00:02:52,370 --> 00:02:54,250
కేవలం కొద్దిగా లోలోపల నవ్వుకొను ", విస్తరించేందుకు".

102
00:02:54,250 --> 00:02:57,190
మీరు విస్తరించేందుకు ప్రయత్నించండి చేసినప్పుడు,
ఉదాహరణకు, ఈ ఏమి జరుగుతుందో ఉంది.

103
00:02:57,190 --> 00:02:58,580
>> కాబట్టి ఇక్కడ ఒక అందమైన ఫోటో.

104
00:02:58,580 --> 00:02:59,720
ఈ CS50 యొక్క సొంత Daven ఉంది.

105
00:02:59,720 --> 00:03:03,740
మరియు మేము కోరుకున్నాడు అనుకుందాం
తన కంటి లో ట్వింకిల్ కేంద్రీకరించండి,

106
00:03:03,740 --> 00:03:05,870
లేదా ప్రతిబింబం
స్పష్టంగా అని చెడ్డ వ్యక్తి

107
00:03:05,870 --> 00:03:07,820
భద్రతా కెమెరా ద్వారా స్వాధీనం.

108
00:03:07,820 --> 00:03:10,330
ఈ ఏమవుతుందో ఉంది
మీరు ఒక చిత్రం లో జూమ్

109
00:03:10,330 --> 00:03:14,060
కేవలం పరిమిత సంఖ్యలో ఉన్నాయి
ఇది సంబంధం బిట్స్.

110
00:03:14,060 --> 00:03:15,420
>> మీరు పొందుతారు ఏమిటి.

111
00:03:15,420 --> 00:03:19,190
నిజానికి, Daven యొక్క కన్ను
బహుశా, ఆరు పిక్సెళ్ళు కానీ నాలుగు

112
00:03:19,190 --> 00:03:22,110
ఆ వేటి కంపోజ్
అక్కడ మిణుకు జరిగినది.

113
00:03:22,110 --> 00:03:25,890
కాబట్టి సమస్య సెట్ నాలుగు చివరికి ఉంటుంది
మీరు ముఖ్యంగా, ఈ ప్రపంచాన్ని అన్వేషించండి

114
00:03:25,890 --> 00:03:28,090
ఏదో స్వభావం ద్వారా
మేము ఫైలు I / O, ఇక్కడ కాల్

115
00:03:28,090 --> 00:03:31,000
I / O ఒక ఫాన్సీ మార్గం
ఇన్పుట్ మరియు అవుట్పుట్ మాట్లాడుతూ.

116
00:03:31,000 --> 00:03:34,280
>> కాబట్టి ఇప్పటివరకు, పరస్పర అన్ని
మనం కంప్యూటర్ కలిగింది

117
00:03:34,280 --> 00:03:36,770
ఎక్కువగా ఉన్నాయి మీ
కీబోర్డు మరియు స్క్రీన్,

118
00:03:36,770 --> 00:03:40,770
కానీ హార్డ్ డిస్క్ తో ఎక్కువ,
లేదా వాటిని దాటి ఫైళ్ళను సేవ్ మీరు

119
00:03:40,770 --> 00:03:41,620
మీరే వ్రాయండి.

120
00:03:41,620 --> 00:03:44,570
మీ కార్యక్రమాలు ఇప్పటివరకు కలిగి
కాదు, సృష్టించడంలో, మరియు సేవ్ చేయబడింది

121
00:03:44,570 --> 00:03:46,270
మరియు వారి స్వంత ఫైళ్ళను నవీకరించుటకు.

122
00:03:46,270 --> 00:03:47,150
>> Well, ఒక ఫైల్ ఏది?

123
00:03:47,150 --> 00:03:48,105
వెల్, ఒక JPEG వంటి ఏదో.

124
00:03:48,105 --> 00:03:50,520
ఈ మీరు వాటిని ఒక చిత్రం ఉంది
లేదా Facebook కు అప్లోడ్

125
00:03:50,520 --> 00:03:51,690
లేదా ఎక్కడైనా వెబ్లో చూడండి.

126
00:03:51,690 --> 00:03:54,460
నిజానికి, ఆ ఫోటో కేవలం
Daven చూసిన ఒక JPEG ఉంది.

127
00:03:54,460 --> 00:03:57,570
మరియు ఏ ఆసక్తికరమైన వార్తలు
JPEGs ఇలా ఫైళ్ళ గురించి

128
00:03:57,570 --> 00:04:02,170
వారు గుర్తించారు సాధ్యం చేసే ఉంది,
సాధారణంగా, బిట్స్ నిర్దిష్ట నమూనాలు ద్వారా.

129
00:04:02,170 --> 00:04:05,200
>> ఇతర మాటలలో, అది ఏమిటి
ఒక GIF నుండి ఒక JPEG వేరుచేస్తుంది

130
00:04:05,200 --> 00:04:08,109
ఒక పదం నుండి పింగ్ నుండి
Excel ఫైల్ నుండి పత్ర?

131
00:04:08,109 --> 00:04:09,900
సరే, కేవలం విభిన్నమైనది
బిట్స్ క్రమాలు.

132
00:04:09,900 --> 00:04:12,820
మరియు ఆ వివిధ నమూనాలు ఉన్నాయి
సాధారణంగా ఆ ఫైళ్ళను ప్రారంభంలో.

133
00:04:12,820 --> 00:04:18,200
>> మీ కంప్యూటర్లో ఒక పద తెరిచినప్పుడు కాబట్టి
డిఓసి, లేదా ఒక కంప్యూటర్ ఒక JPEG తెరిచినప్పుడు,

134
00:04:18,200 --> 00:04:20,940
ఇది సాధారణంగా కనిపిస్తుంది
ఫైలు లో మొదటి అనేక బిట్స్.

135
00:04:20,940 --> 00:04:24,059
మరియు అది ఒక నమూనా గుర్తిస్తుంది ఉంటే,
ఇది ఓహ్, ఈ ఒక చిత్రం, చెప్పారు.

136
00:04:24,059 --> 00:04:25,850
నాకు అది ప్రదర్శించడానికి లెట్
ఒక గ్రాఫిక్ యూజర్.

137
00:04:25,850 --> 00:04:27,870
లేదా, OH, ఈ ఒక పద డిఓసి కనిపిస్తోంది.

138
00:04:27,870 --> 00:04:30,480
నాకు ఒక వ్యాసంలో యూజర్ దానిని చూపించడానికి లెట్.

139
00:04:30,480 --> 00:04:33,020
>> కాబట్టి ఉదాహరణకు, JPEGs,
అది ఉంటాయి మారుతుంది

140
00:04:33,020 --> 00:04:35,460
చాలా క్లిష్టమైన
హుడ్ కింద.

141
00:04:35,460 --> 00:04:40,140
కానీ చాలా ప్రతి ముగ్గురిలో బైట్లు
JPEG ఈ మూడు సంఖ్యలు ప్రారంభం.

142
00:04:40,140 --> 00:04:44,680
కాబట్టి బైట్ సున్నా, ఒకటి, మరియు రెండు ఉన్నాయి
అత్యంత ప్రతి JPEG, 255, అప్పుడు సంఖ్య

143
00:04:44,680 --> 00:04:46,675
216, అప్పుడు సంఖ్య 255.

144
00:04:46,675 --> 00:04:48,990
>> మరియు మీరు చేయగలరు దానికి
వచ్చే వారం చేయడం మొదలు

145
00:04:48,990 --> 00:04:52,920
నిజానికి కింద poking ఉంది
JPEGs ఇలా ఫైళ్లు హుడ్

146
00:04:52,920 --> 00:04:57,210
మరియు బిట్మ్యాప్ ఫైళ్లు వంటి, మరియు చూసిన
ఏ ఎల్లప్పుడూ కాలం కోసం ఉన్నాయి

147
00:04:57,210 --> 00:04:58,650
మీరు ఒక కంప్యూటర్ ను ఉపయోగించి పరిష్కరించగలుగుతున్నాము.

148
00:04:58,650 --> 00:05:01,860
>> కానీ సాధారణంగా లేదు ఏమిటి
ఈ వంటి దశాంశ సంఖ్యలు వంటి వ్రాసిన.

149
00:05:01,860 --> 00:05:04,620
కంప్యూటర్ శాస్త్రవేత్తలు లేదు
దశాంశ లో మాట్లాడటం ఉంటాయి.

150
00:05:04,620 --> 00:05:06,139
వారు నిజంగా బైనరీ లో మాట్లాడడం లేదు.

151
00:05:06,139 --> 00:05:07,930
సాధారణంగా, మేము కావలసిన
సంఖ్యలు వ్యక్తీకరించడానికి,

152
00:05:07,930 --> 00:05:10,710
మేము నిజంగా హెక్సాడెసిమల్ ఉపయోగించడానికి,
ఇది మీరు రీకాల్ చేయవచ్చు

153
00:05:10,710 --> 00:05:13,027
సమస్య సెట్, సే, నుండి
ఎయిమ్స్ ఒకటి,

154
00:05:13,027 --> 00:05:14,610
మీరు వేరే వ్యవస్థ గురించి ఆలోచించాలి.

155
00:05:14,610 --> 00:05:17,170
>> మేము, కోర్సు యొక్క, తెలిసిన
తొమ్మిది ద్వారా దశాంశ, సున్నా.

156
00:05:17,170 --> 00:05:18,215
మేము బైనరీ గురించి మాట్లాడారు.

157
00:05:18,215 --> 00:05:20,710
మరియు మేము నిజంగా లేని
ఇక్కడ చాలా ఉపయోగించడానికి

158
00:05:20,710 --> 00:05:22,470
అవుట్, కంప్యూటర్లు ఆ ఉపయోగిస్తుంది ఎందుకంటే.

159
00:05:22,470 --> 00:05:24,900
కానీ ప్రోగ్రామర్లు చాలా రెడీ
తరచుగా, కానీ ఎల్లప్పుడూ,

160
00:05:24,900 --> 00:05:29,360
కేవలం అంటే, హెక్సాడెసిమల్ ఉపయోగించడానికి
మీరు మీ వర్ణమాలలో 16 అక్షరాలు కలిగి

161
00:05:29,360 --> 00:05:31,330
రెండు లేదా 10 వ్యతిరేకించారు.

162
00:05:31,330 --> 00:05:34,530
>> సో ఎలా మీరు అధిక లెక్కింపు లేదు
హెక్సాడెసిమల్ లో తొమ్మిది కంటే?

163
00:05:34,530 --> 00:05:41,120
మీరు వెళ్ళి 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
ఒక కేవలం కన్వెన్షన్ ద్వారా C, D, E, F, బి.

164
00:05:41,120 --> 00:05:43,540
కానీ ఏ కీ ఉంది అని ప్రతి
ఈ ఒకే గుర్తు.

165
00:05:43,540 --> 00:05:44,340
ఏ 10 ఉంది.

166
00:05:44,340 --> 00:05:48,400
ప్రతి ఎందుకంటే, ఏ 11, కేవలంగా ఉంది
మీ అంకెలు యొక్క, దశాంశ లో ఇష్టం

167
00:05:48,400 --> 00:05:51,940
కేవలం బైనరీ లో మరియు, కేవలం తప్పక
సాంప్రదాయకంగా ఒకే ఒక పాత్ర ఉంటుంది.

168
00:05:51,940 --> 00:05:55,280
>> తర్వాత మేము వర్ణమాల కాబట్టి ఆ
హెక్సాడెసిమల్ కోసం మా పారవేయడం వద్ద.

169
00:05:55,280 --> 00:05:58,600
కాబట్టి ఒక JPEG మీరు ఉంటే వంటి లుక్ వాట్ లేదు
ఆ మొదటి మూడు రాయడానికి ఉన్నాయి

170
00:05:58,600 --> 00:06:01,980
దశాంశ కాదు బైట్లు కానీ
ఉదాహరణకు, హెక్సాడెసిమల్ వంటి?

171
00:06:01,980 --> 00:06:03,640
ఎందుకు హెక్స్ ఉపయోగకరమైన కూడా ఇంతేనా?

172
00:06:03,640 --> 00:06:05,290
>> Well, ఒక ఉదాహరణ శీఘ్ర లుక్.

173
00:06:05,290 --> 00:06:09,030
నేను బిట్స్ వ్రాయండి చేస్తే
ఈ దశాంశ numbers-- ప్రాతినిధ్యం

174
00:06:09,030 --> 00:06:12,450
ఈ కొద్దిగా రస్టీ కావచ్చు
ఇప్పుడు తిరిగి కొన్ని వారాల నుండి,

175
00:06:12,450 --> 00:06:14,820
ఒక్క మరియు కానీ
కుడి ఒకటి అందంగా సులభం.

176
00:06:14,820 --> 00:06:17,990
255 అత్యధిక సంఖ్యలో మేము ఉన్నది
ఎనిమిది బిట్స్ తో ప్రాతినిధ్యం వహిస్తుంది.

177
00:06:17,990 --> 00:06:18,820
ఇది అన్ని వాటిని ఉంది.

178
00:06:18,820 --> 00:06:21,320
కాబట్టి స్వల్పంగా అని మాత్రమే ఒకటి
ఆసక్తికరమైన మధ్యలో ఒకటి.

179
00:06:21,320 --> 00:06:24,700
మరియు మీరు రకమైన అవుట్ లేకపోతే
గణిత, మీరు, నిజానికి, నిరూపించు చేస్తుంది

180
00:06:24,700 --> 00:06:27,949
ఒక నమూనా మరియు
సున్నాలు 216 సూచిస్తుంది.

181
00:06:27,949 --> 00:06:30,240
కాబట్టి యొక్క కేవలం నిబంధనలు తెలియజేయండి
ఇప్పుడు ఈ సరైనవని.

182
00:06:30,240 --> 00:06:31,730
కానీ ఎందుకు ఈ ఆసక్తికరమైన ఉంది?

183
00:06:31,730 --> 00:06:33,970
>> Well, ఒక బైట్, కోర్సు యొక్క, ఎనిమిది బిట్స్ ఉంది.

184
00:06:33,970 --> 00:06:38,980
మరియు మీరు అనుకుంటే ఆ అవుతుంది
నాలుగు బిట్స్ రెండు భాగాలుగా ఒక బైట్ యొక్క,

185
00:06:38,980 --> 00:06:39,500
దీనిని ఇష్టపడుతున్నారు.

186
00:06:39,500 --> 00:06:41,000
నాకు కొన్ని ఖాళీ జోడించడానికి లెట్.

187
00:06:41,000 --> 00:06:42,550
కాబట్టి ముందు, తర్వాత.

188
00:06:42,550 --> 00:06:46,520
నేను కేవలం కొన్ని వైట్ స్పేస్ జోడించిన
ఇక్కడ విజువలైజేషన్ కోసమని.

189
00:06:46,520 --> 00:06:51,840
ఎలా మేము ఇప్పుడే ప్రతిఫలించే,
సే, హెక్సాడెసిమల్ బిట్స్ ప్రతి క్వాడ్,

190
00:06:51,840 --> 00:06:52,880
నాలుగు బిట్స్ ప్రతి సమితి?

191
00:06:52,880 --> 00:06:56,420
>> ఉదాహరణకు, ఎడమ కాబట్టి
ఇప్పుడు మేము బైనరీ లో 1111 చేశారు.

192
00:06:56,420 --> 00:07:00,420
దశాంశ లో ఆ సంఖ్యను ఏమిటి,
మీరు గణిత అవుట్ లేకపోతే?

193
00:07:00,420 --> 00:07:03,780
మీరు వాటిని స్థలం కలిగి, పరుగులు తీయడం స్థానంలో,
ఫోర్లు స్థానంలో, మరియు ఎయిట్స్కి స్థానంలో.

194
00:07:03,780 --> 00:07:04,341
>> ప్రేక్షకులు: 15.

195
00:07:04,341 --> 00:07:05,340
డేవిడ్ J. మలన్: ఇది 15 ఉంది.

196
00:07:05,340 --> 00:07:08,340
కాబట్టి మేము ఎనిమిది ప్లస్ నాలుగు లేకపోతే
ప్లస్ రెండు ప్లస్ ఒకటి, మేము 15 పొందండి.

197
00:07:08,340 --> 00:07:11,790
నేను క్రింద 15 వ్రాసి కాలేదు
1111, కానీ ఇక్కడ మొత్తం పాయింట్

198
00:07:11,790 --> 00:07:13,190
హెక్సాడెసిమల్ దశాంశ కాదు.

199
00:07:13,190 --> 00:07:17,310
కాబట్టి బదులుగా లిఖించడానికి 15, 1-5,
నేను, హెక్స్ లో రాయడానికి వెళుతున్న

200
00:07:17,310 --> 00:07:22,311
మీరు కలిగి ఉంటే మీరు తిరిగి అనుకుంటే ఇది
F ద్వారా సున్నా, ఏమి 15 అవతరిస్తుంది?

201
00:07:22,311 --> 00:07:22,810
ప్రేక్షకులు: ఎఫ్.

202
00:07:22,810 --> 00:07:24,434
డేవిడ్ J. మలన్: సో అది యొక్క F అవుతుంది.

203
00:07:24,434 --> 00:07:29,140
మరియు మీరు చెప్పి పని చేయవచ్చు,
ఒక 10 ఉంటే బాగా, అప్పుడు సరే, F 15.

204
00:07:29,140 --> 00:07:33,250
కాబట్టి నిజంగా, మేము తిరిగి అని
F F వంటి సంఖ్యల ఈ అదే సెట్.

205
00:07:33,250 --> 00:07:35,750
మరియు తర్వాత మేము గణిత ఒక బిట్ లేకపోతే,
మేము ఆ d యొక్క నిరూపించు చేస్తాము.

206
00:07:35,750 --> 00:07:38,650
ఎనిమిది, అందంగా సులభం మేము ఎందుకంటే
ఎయిట్స్కి స్థానంలో ఒక ఒకటి.

207
00:07:38,650 --> 00:07:40,620
ఆపై, మేము F F యొక్క ఒక జంట ఎక్కువ.

208
00:07:40,620 --> 00:07:44,669
>> సో వాట్ మానవులు కన్వెన్షన్ ద్వారా చేసుకొంటాయి
వారు ఉపయోగించడానికి ఉన్నప్పుడు హెక్సాడెసిమల్ వారు కేవలం ఉంది

209
00:07:44,669 --> 00:07:47,710
మరింత క్లుప్తమైన ఈ కొద్దిగా వ్రాయండి,
ఆ తెల్లని స్థలం అత్యంత వదిలించుకోవటం.

210
00:07:47,710 --> 00:07:50,890
మరియు కేవలం సూపర్ స్పష్టమైన ఉండాలి
ఈ హెక్సాడెసిమల్ పాఠకులకు,

211
00:07:50,890 --> 00:07:54,670
మధ్య సాధారణ సమావేశం
మానవులలో సున్నా వ్రాయడానికి ఉంది

212
00:07:54,670 --> 00:07:58,000
ఇతర ఏ అర్థాన్ని కలిగి X,
ఒక దృశ్య నిర్ధారిణి కంటే,

213
00:07:58,000 --> 00:07:59,590
ఇక్కడ ఒక hex సంఖ్య వస్తుంది.

214
00:07:59,590 --> 00:08:04,210
>> ఆపై, మీరు F రెండు అంకెలు చాలు
ఈ సందర్భంలో F, అప్పుడు D ఒక, f ఎఫ్.

215
00:08:04,210 --> 00:08:06,700
సో లాంగ్ కథ చిన్న,
హెక్సాడెసిమల్ కేవలం ఉంటుంది

216
00:08:06,700 --> 00:08:11,990
ఉపయోగకరంగా ప్రతి ఎందుకంటే దాని
అంకెలు, F ద్వారా సున్నా, సంపూర్ణ పంక్తులు

217
00:08:11,990 --> 00:08:13,880
నాలుగు బిట్స్ నమూనా.

218
00:08:13,880 --> 00:08:18,080
>> మీరు రెండు హెక్సాడెసిమల్ సంఖ్యలను కలిగి ఉంటే కాబట్టి,
సున్నా మళ్లీ మళ్లీ F ద్వారా,

219
00:08:18,080 --> 00:08:20,256
ఆ సంపూర్ణ మీరు ఇస్తుంది
ఎనిమిది బిట్స్ లేదా ఒక బైట్.

220
00:08:20,256 --> 00:08:22,380
ఇది ఉంటుంది ఎందుకు అలా ఆ
సంప్రదాయకంగా ఉపయోగకరంగా ఉంటుంది.

221
00:08:22,380 --> 00:08:24,990
ఏ మేధో ఉంది
నిజంగా ఆ మించి కంటెంట్,

222
00:08:24,990 --> 00:08:27,010
దాని అసలు వినియోగ కంటే ఇతర.

223
00:08:27,010 --> 00:08:29,310
>> ఇప్పుడు JPEGs మాత్రమే కాదు
గ్రాఫిక్స్ ఫార్మాట్లలో దాఖలు.

224
00:08:29,310 --> 00:08:33,230
మీరు ఉన్నాయి గుర్తుచేసుకున్నారు ఉండవచ్చు
ప్రపంచంలో ఈ వంటి ఫైళ్ళ,

225
00:08:33,230 --> 00:08:34,830
కనీసం తిరిగి కొన్ని సంవత్సరాల నుండి.

226
00:08:34,830 --> 00:08:37,580
>> కాబట్టి ఈ వాస్తవానికి ఉంది
విండోస్ XP లో ఇన్స్టాల్

227
00:08:37,580 --> 00:08:39,960
ప్రపంచవ్యాప్తంగా PC లు మిలియన్ల.

228
00:08:39,960 --> 00:08:43,000
మరియు ఈ ఒక బిట్మ్యాప్ BMP, ఉంది.

229
00:08:43,000 --> 00:08:47,690
మరియు ఒక బిట్మ్యాప్ ఫైలు, మీరు తదుపరి చూస్తారు
వారం, కేవలం చుక్కలు నమూనా అంటే,

230
00:08:47,690 --> 00:08:51,710
వారు అని పిక్సెళ్ళు,
ఒక నిజంగా, బిట్స్ మ్యాప్.

231
00:08:51,710 --> 00:08:55,160
>> సో వాట్ అయితే, ఆసక్తికరమైన వార్తలు,
ఈ ఫైల్ ఫార్మాట్, BMP గురించి ఉంది

232
00:08:55,160 --> 00:08:58,590
హుడ్ కింద, అది
కేవలం మూడు బైట్ల కంటే ఎక్కువ ఉంది

233
00:08:58,590 --> 00:09:01,020
కాబట్టి, దాని శీర్షిక కంపోజ్
మొదటి కొన్ని గాట్లు మాట్లాడటం.

234
00:09:01,020 --> 00:09:03,330
ఇది నిజానికి ఒక చిన్న కనిపిస్తోంది
మొదటి చూపులో సంక్లిష్టంగా.

235
00:09:03,330 --> 00:09:04,704
మరియు మీరు పి సెట్ లో ఈ చూస్తారు.

236
00:09:04,704 --> 00:09:06,810
మరియు ఏదో పొందడానికి
ఈ ప్రత్యేక ముగిసింది

237
00:09:06,810 --> 00:09:10,720
కేవలం నిజానికి, కాబట్టి ముఖ్యమైనది కాదు
ప్రతి బిట్మ్యాప్ ప్రారంభంలో

238
00:09:10,720 --> 00:09:13,823
ఫైల్, ఒక గ్రాఫికల్ ఫార్మాట్,
సంఖ్యల మొత్తం బంచ్ ఉంది.

239
00:09:13,823 --> 00:09:14,980

240
00:09:14,980 --> 00:09:16,720
>> ఇప్పుడు మైక్రోసాఫ్ట్,
ఈ ఫార్మాట్ రచయిత,

241
00:09:16,720 --> 00:09:18,820
ఆ కాల్ ఉంటుంది
విషయాలు కాదు ints మరియు అక్షరాలు

242
00:09:18,820 --> 00:09:22,259
మరియు తేలియాడుతున్న కానీ పదాలు మరియు D
పదాలు మరియు longs మరియు బైట్లు.

243
00:09:22,259 --> 00:09:23,800
కాబట్టి అవి వివిధ రకాల డేటా ఉన్నాము.

244
00:09:23,800 --> 00:09:25,170
వారు వివిధ పేర్లు ఉన్నాము
ఇదే కోసం.

245
00:09:25,170 --> 00:09:26,740
కానీ మీరు p సెట్ ఫోర్ లో చూస్తారు.

246
00:09:26,740 --> 00:09:31,450
>> కానీ ఈ చెప్పడానికి మాత్రమే అని ఒక మానవ ఉంటే
కొన్ని .BMP ఫైలు డబుల్ క్లిక్ తన

247
00:09:31,450 --> 00:09:35,015
లేదా ఆమె హార్డ్ డ్రైవ్, మరియు ఒక విండో తెరుచుకుంటుంది
అతనికి లేదా ఆమె ఆ చిత్రం చూపిస్తున్న అప్,

248
00:09:35,015 --> 00:09:38,500
ఆపరేటింగ్ ఎందుకంటే జరిగింది
వ్యవస్థ బహుశా మాత్రమే గమనించి

249
00:09:38,500 --> 00:09:41,460
.BMP ఫైల్ పొడిగింపు
ఫైలు పేరు లో,

250
00:09:41,460 --> 00:09:45,010
కానీ నిజానికి ఉందని కొంత
బిట్స్ నమూనా కన్వెన్షన్

251
00:09:45,010 --> 00:09:47,490
చాలా ప్రారంభంలో
ఆ బిట్మ్యాప్ ఫైలు యొక్క.

252
00:09:47,490 --> 00:09:50,270
>> కానీ ఇప్పుడు దృష్టి తెలియజేయండి
ఒక క్లిష్టమైన ఫైలు,

253
00:09:50,270 --> 00:09:52,120
కానీ బదులుగా ఈ వంటి ఏదో.

254
00:09:52,120 --> 00:09:55,190
నేను, gedit ఇక్కడ అనుకుందాం
కేవలం ప్రారంభం ఉన్నాయి

255
00:09:55,190 --> 00:09:57,070
అందంగా సులభం ఒక కార్యక్రమం.

256
00:09:57,070 --> 00:09:58,860
నేను కొన్ని టాప్ అప్ ఇచ్చింది పొందారు.

257
00:09:58,860 --> 00:10:02,120
ఇప్పుడు నేను పొందారు # ఉన్నాయి "structs.h" కానీ
నేను ఒక క్షణం లో ఆ వచ్చి చేస్తాము.

258
00:10:02,120 --> 00:10:03,974
కానీ ఈ ఇప్పుడు ఉపయోగకరంగా ఉంది.

259
00:10:03,974 --> 00:10:05,890
కాబట్టి ఈ ప్రోగ్రామ్
ఆ అమలు జరగబోతోంది

260
00:10:05,890 --> 00:10:07,335
రిజిస్ట్రార్ యొక్క డేటాబేస్ వంటి.

261
00:10:07,335 --> 00:10:09,710
కనుక విద్యార్థులు డేటాబేస్,
మరియు ప్రపంచంలో ప్రతి విద్యార్థి

262
00:10:09,710 --> 00:10:13,190
బహుశా కొన్ని ఒక పేరు మరియు ఒక ఇల్లు ఉంది
ఇతర stuff, కానీ మేము సాధారణ ఉంటాం.

263
00:10:13,190 --> 00:10:15,140
ప్రతి విద్యార్థి ఒక పేరు మరియు ఒక ఇల్లు ఉంది.

264
00:10:15,140 --> 00:10:17,700
>> నేను ఒక రాయడానికి కోరుకున్నారు కనుక
దీని ప్రయోజనం జీవితంలో కార్యక్రమం

265
00:10:17,700 --> 00:10:19,860
కేవలం నుంచి iterate జరిగినది
మూడు మీద సున్నా,

266
00:10:19,860 --> 00:10:22,070
ముగ్గురు విద్యార్థులు అక్కడ ఉంటే
హార్వర్డ్ విశ్వవిద్యాలయంలో.

267
00:10:22,070 --> 00:10:25,350
నేను కేవలం GetString ఉపయోగించి పొందడానికి కావలసిన,
ప్రతి విద్యార్థి యొక్క పేరు మరియు ఇంటి,

268
00:10:25,350 --> 00:10:26,600
ఆపై కేవలం ఆ ప్రింట్.

269
00:10:26,600 --> 00:10:28,630
>> ఈ విధమైన వీక్ వంటిది
వన్ వీక్ రెండు విషయాన్ని ఇప్పుడు,

270
00:10:28,630 --> 00:10:30,810
నేను కేవలం ఒక చోట
లూప్ లేదా అలాంటిదే.

271
00:10:30,810 --> 00:10:34,500
మరియు నేను GetString కొన్ని కాల్ అనుకుంటున్నారా
సార్లు, మరియు అప్పుడు కొన్ని సార్లు F ​​ప్రింట్.

272
00:10:34,500 --> 00:10:37,340
కాబట్టి నేను అయితే, దీన్ని ఎలా,
ఒక పేరు మరియు ఒక ఇల్లు రెండు

273
00:10:37,340 --> 00:10:39,070
ప్రతి విద్యార్థి కోసం పాల్గొంటున్నారు?

274
00:10:39,070 --> 00:10:42,830
>> కాబట్టి నా మొట్టమొదటి ప్రవృత్తి వాటిని
ఈ వంటి ఏదో చేయాలని ఉంటుంది.

275
00:10:42,830 --> 00:10:49,620
నేను మొదటి చక్కగా, నాకు ఇవ్వండి అని అనవచ్చు,
, పేర్లు తీగలను యొక్క వ్యూహం అంటున్నారు.

276
00:10:49,620 --> 00:10:51,530
నేను ఒక hardcode మూడు ఇక్కడ వద్దు.

277
00:10:51,530 --> 00:10:53,064
నేను అక్కడ ఉంచారు అనుకుంటున్నారు?

278
00:10:53,064 --> 00:10:55,730
కేవలం ఎందుకంటే, విద్యార్థులు సో
ఎగువన ప్రకటించింది స్థిరమైన,

279
00:10:55,730 --> 00:10:57,860
నేను hardcode లేదు కేవలం
అనేక స్థానాల్లో మూడు.

280
00:10:57,860 --> 00:11:00,859
ఈ విధంగా, నేను, అది ఒకే చోట మార్చవచ్చు
మరియు ప్రతిచోటా మార్పు ప్రభావితం చేస్తుంది.

281
00:11:00,859 --> 00:11:04,470
ఆపై, నేను ఏమి ఉండవచ్చు
స్ట్రింగ్ STUDENTS హౌసెస్.

282
00:11:04,470 --> 00:11:10,250
>> మరియు ఇప్పుడు, నేను వంటి ఏదో ఉండవచ్చు
నేను విద్యార్థులు <;; కోసం (నేను = 0 Int నేను ++.

283
00:11:10,250 --> 00:11:14,390
కాబట్టి నేను వేగంగా టైప్ చేస్తున్నానని, కానీ ఈ ఉంది
ఇప్పుడు బహుశా తెలిసిన సింటాక్స్.

284
00:11:14,390 --> 00:11:17,030
>> మరియు ఇప్పుడు, ఈ మరింత ఇటీవలి జరిగినది.

285
00:11:17,030 --> 00:11:22,890
నేను i-th లో చాలు అనుకొంటే
విద్యార్థి యొక్క పేరు, నేను దీన్ని భావిస్తున్నాను.

286
00:11:22,890 --> 00:11:26,480
ఆపై, పేర్లు
కానీ ఇళ్ళు నేను బ్రాకెట్.

287
00:11:26,480 --> 00:11:29,930
నేను ఈ GetString లేదు, మరియు తెలపండి
నాకు తిరిగి వెళ్లి ఈ లైన్ పరిష్కరించడానికి.

288
00:11:29,930 --> 00:11:30,430
అంగీకరిస్తున్నారు?

289
00:11:30,430 --> 00:11:31,200
విభేదిస్తున్నారు?

290
00:11:31,200 --> 00:11:32,366
ఇది చాలా యూజర్ ఫ్రెండ్లీ కాదు.

291
00:11:32,366 --> 00:11:33,890
నేను ఏమి యూజర్ చెప్పారు లేదు.

292
00:11:33,890 --> 00:11:36,520
>> కానీ ఇప్పుడు, నేను కూడా ఉంటే
తరువాత, లెట్స్ కావలెను

293
00:11:36,520 --> 00:11:40,060
సే, ఈ విషయాలను ప్రింట్
out-- కాబట్టి TODO తరువాత.

294
00:11:40,060 --> 00:11:42,330
నేను మరింత తో చేయ బోతున్నాను
నిస్సందేహంగా ఈ దీన్ని

295
00:11:42,330 --> 00:11:45,970
ఒక సరైన అమలు
పేర్లు మరియు ఇళ్ళు, మూడు పొందడానికి

296
00:11:45,970 --> 00:11:48,870
ఒక యూజర్ నుండి ప్రతి యొక్క వాటిలో మొత్తం.

297
00:11:48,870 --> 00:11:51,280
>> కానీ ఈ చాలా మంచి డిజైన్ కుడి కాదు?

298
00:11:51,280 --> 00:11:55,220
ఏం ఒక విద్యార్ధి కాదు కేవలం ఒక పేరు ఉంది ఉంటే
మరియు ఒక ఇల్లు, కానీ కూడా ఒక ID సంఖ్య,

299
00:11:55,220 --> 00:11:57,770
మరియు ఒక టెలిఫోన్ సంఖ్య,
మరియు ఒక ఇమెయిల్ చిరునామా,

300
00:11:57,770 --> 00:12:00,280
మరియు ఉండవచ్చు ఒక హోమ్ పేజీ మరియు
బహుశా ఒక ట్విట్టర్ హ్యాండిల్,

301
00:12:00,280 --> 00:12:03,730
మరియు ఇతర వివరాలు ఏ సంఖ్య
ఒక విద్యార్థి లేదా ఒక వ్యక్తి తో సంబంధం,

302
00:12:03,730 --> 00:12:04,610
సాధారణంగా.

303
00:12:04,610 --> 00:12:07,720
మేము చేర్చండి ప్రారంభమవుతుంది ఎలా
ఈ కార్యక్రమానికి కార్యాచరణను?

304
00:12:07,720 --> 00:12:14,080
>> Well, నేను వాటిని సరళమైన మార్గం భావిస్తాను
, వంటి ఏదో ఒకటి చెప్పాలి వీలు,

305
00:12:14,080 --> 00:12:16,490
ఐడిలు STUDENTS Int.

306
00:12:16,490 --> 00:12:18,380
కాబట్టి నేను అక్కడ వారి ఐడిలను ఉంచవచ్చు.

307
00:12:18,380 --> 00:12:22,240
ఆపై, ఏదో కోసం
ఫోన్ నంబర్లు వంటి,

308
00:12:22,240 --> 00:12:24,400
నేను ఎలా ఖచ్చితంగా తెలియదు
ఇంకా ఆ సూచిస్తాయి.

309
00:12:24,400 --> 00:12:30,280
కాబట్టి యొక్క ముందుకు మరియు కేవలం కాల్ వీడలేదు
ఈ విద్యార్థులు, ట్విట్టర్లతో ఇది

310
00:12:30,280 --> 00:12:33,550
ఒక చిన్న వింత, but-- ఉంది
మరియు ఖాళీలను కొంత ఎక్కువ.

311
00:12:33,550 --> 00:12:36,360
>> నేను సమర్థవంతంగా ప్రారంభించారు చేసిన
కాపీ మరియు ఇక్కడ అతికించండి.

312
00:12:36,360 --> 00:12:39,416
మరియు ఈ అందంగా పెరుగుతాయి అన్నారు
అందంగా త్వరగా అతిపెద్దదైన, కుడి?

313
00:12:39,416 --> 00:12:42,290
ఉన్నాయి ఉంటే అది nice కాదు
ప్రపంచంలో ఒక డేటా నిర్మాణం తెలిసిన

314
00:12:42,290 --> 00:12:45,600
ఒక పూర్ణాంకానికి లేదా ఒక స్ట్రింగ్, కానీ ఏదో
అధిక స్థాయి, ఒక సంగ్రహణం కాబట్టి

315
00:12:45,600 --> 00:12:47,570
ఒక విద్యార్థి వలె పిలుస్తారు, మాట్లాడటం ఎలా |?

316
00:12:47,570 --> 00:12:50,220
సి అంతర్నిర్మిత తో రాలేదు
విద్యార్థులకు కార్యాచరణ,

317
00:12:50,220 --> 00:12:52,260
కాని దాన్ని ఇవ్వాలని కోరారు ఉంటే ఏమి?

318
00:12:52,260 --> 00:12:55,640
>> సరే, నేను వెళుతున్న టర్న్స్
, structs.h ఇక్కడ పిలువబడే ఒక ఫైల్ తెరిచి

319
00:12:55,640 --> 00:12:57,090
మరియు మీరు ఖచ్చితంగా ఆ చేయవచ్చు.

320
00:12:57,090 --> 00:12:58,290
మరియు మేము ఇప్పుడు ఇలా మొదలు చూడాలని.

321
00:12:58,290 --> 00:13:01,490
మరియు P సెట్ మూడు హుడ్ కింద,
మీరు ఇప్పటికే ఇప్పుడు ఈ చేయడం చేసిన.

322
00:13:01,490 --> 00:13:05,920
ఒక గ్రా RECT అనేందుకు ఉంది లేదా
ప్రోగ్రామింగ్ భాష C. లో ఒక గ్రా ఓవల్

323
00:13:05,920 --> 00:13:10,570
>> స్టాన్ఫోర్డ్ వద్ద చేసారో ఆ అమలు
ఇక్కడ ఈ విధానాన్ని ఉపయోగించి డేటా రకాల

324
00:13:10,570 --> 00:13:13,900
వారి స్వంత కొత్త డేటా ప్రకటించారు
ఒక కొత్త కీవర్డ్ ఉపయోగించి రకాల

325
00:13:13,900 --> 00:13:16,744
అని struct మరియు మరొక
ఒకటి అని typedef.

326
00:13:16,744 --> 00:13:19,660
నిజానికి, అయినప్పటికీ వాక్యనిర్మాణం
stuff నుండి కొద్దిగా భిన్నంగా కనిపిస్తోంది

327
00:13:19,660 --> 00:13:23,550
మేము ముందు చూసిన
సూత్రం, సూపర్ సులభం.

328
00:13:23,550 --> 00:13:25,297
>> ఈ కేవలం "ఒక రకం నిర్వచించే." అంటే

329
00:13:25,297 --> 00:13:27,255
ఒక చేస్తాడు
నిర్మాణం, మరియు ఒక నిర్మాణం

330
00:13:27,255 --> 00:13:29,400
కేవలం ఒక కంటైనర్ వంటి ఉంది
బహుళ విషయాల కోసం.

331
00:13:29,400 --> 00:13:31,780
ఆ నిర్మాణం అన్నారు
నేమ్ అనే స్ట్రింగ్ కలిగి,

332
00:13:31,780 --> 00:13:33,210
మరియు ఒక స్ట్రింగ్ హౌస్ అని.

333
00:13:33,210 --> 00:13:37,520
మరియు లెట్స్ కేవలం సౌలభ్యం కోసం, కాల్ తెలియజేయండి
ఈ మొత్తం డేటా నిర్మాణం విద్యార్థి.

334
00:13:37,520 --> 00:13:40,320
>> కాబట్టి క్షణం మీరు ను
సెమికోలన్, మీరు ఇప్పుడు కలిగి

335
00:13:40,320 --> 00:13:43,280
మీ స్వంత డేటా రూపొందించినవారు
రకం అని విద్యార్థి

336
00:13:43,280 --> 00:13:46,420
ఇప్పుడు, Int పాటు ఉంటుంది
మరియు ఫ్లోట్, మరియు చార్ మరియు స్ట్రింగ్,

337
00:13:46,420 --> 00:13:50,270
మరియు g RECT, మరియు g Oval, మరియు ఏ సంఖ్య
ఇతర విషయాలను ప్రజలను తున్నారు.

338
00:13:50,270 --> 00:13:53,340
>> కాబట్టి దీని గురించి ఉపయోగకరమైన ఏమిటి
ఇప్పుడు నేను తిరిగి వెళ్లి ఉంటే ఉంటుంది

339
00:13:53,340 --> 00:13:57,430
0 struct మరియు ఈ పూర్తి
నేను రాసింది అమలు,

340
00:13:57,430 --> 00:14:02,080
ఇక్కడ ముందుగానే, అన్ని గమనించవచ్చు
అనివార్య అవకతవకలు ఆ

341
00:14:02,080 --> 00:14:05,490
నేను జోడించిన సంభవించే ఆరంభమవుతుందని
ఫోన్ నంబర్లు మరియు ట్విట్టర్లతో మరియు అన్ని

342
00:14:05,490 --> 00:14:07,370
ఈ ఇతర విషయాలు
ఒక విద్యార్థి యొక్క నిర్వచనం,

343
00:14:07,370 --> 00:14:11,810
ఇప్పుడు అది క్లుప్తమైన ముగిస్తుంది లో
విద్యార్థులు కేవలం ఒక శ్రేణి వంటి.

344
00:14:11,810 --> 00:14:15,500
>> మరియు ఆ విద్యార్థులు ప్రతి ఇప్పుడు
అది లోపలి బహుళ విషయాలు ఉన్నాయి.

345
00:14:15,500 --> 00:14:16,930
కాబట్టి కేవలం ఒక ప్రశ్న వెళ్లిపోతాడు.

346
00:14:16,930 --> 00:14:19,700
ఎలా మీరు పేరు వస్తుందా,
మరియు హౌస్, మరియు ID,

347
00:14:19,700 --> 00:14:21,640
మిగిలిన సంసార ఉంది
విద్యార్థి యొక్క లోపల?

348
00:14:21,640 --> 00:14:22,930
సూపర్ సాధారణ, అలాగే.

349
00:14:22,930 --> 00:14:25,730
కొత్త సింటాక్సు, కానీ ఒక సాధారణ ఆలోచన.

350
00:14:25,730 --> 00:14:29,239
>> శ్రేణి లోకి మీరు కేవలం ఇండెక్స్,
మేము గత వారం మరియు ఈ ఆదరించాడు.

351
00:14:29,239 --> 00:14:31,030
మరియు ఏమి స్పష్టంగా వార్తలు
వాక్యనిర్మాణం యొక్క కొత్త భాగాన్ని?

352
00:14:31,030 --> 00:14:32,590

353
00:14:32,590 --> 00:14:35,880
జస్ట్., అంటే "లోపల వెళ్ళి
నిర్మాణం మరియు ఫీల్డ్ అని పెట్టడానికి

354
00:14:35,880 --> 00:14:39,030
పేరు, ఇల్లు అనే field పొందండి
విద్యార్థి అని రంగంలో పొందండి. "

355
00:14:39,030 --> 00:14:41,940
>> కాబట్టి P సెట్ మూడు, మీరు అయితే
ఇప్పటికీ ఆ పని,

356
00:14:41,940 --> 00:14:44,020
ఇప్పటికీ మరియు అత్యంత ఫొల్క్స్
, మీరు ఆ తెలుసుకుంటారు ఉంటాయి

357
00:14:44,020 --> 00:14:46,130
వంటి విషయాలను ఉపయోగించి ప్రారంభం
గ్రా rects మరియు g ovals

358
00:14:46,130 --> 00:14:50,201
మరియు ఇతర విషయాలు కనిపించడం లేదు
వీక్ సున్నా, ఒకటి, లేదా రెండు నుండి వచ్చి,

359
00:14:50,201 --> 00:14:52,950
ఆ స్టాన్ఫోర్డ్ ఎందుకంటే ఉందని గుర్తించండి
కొన్ని కొత్త డేటా రకాల ప్రకటించింది.

360
00:14:52,950 --> 00:14:56,160
>> నిజానికి, ఖచ్చితంగా ఏమి మేము చేస్తాము
p సెట్ ఫోర్ లో, అలాగే, చేయండి ఉన్నప్పుడు

361
00:14:56,160 --> 00:14:59,880
మేము విషయాలు వ్యవహరించే ప్రారంభం
చిత్రాలు, బిట్ మ్యాప్ చిత్రాలన్నీ, మరియు మరిన్ని.

362
00:14:59,880 --> 00:15:02,882
కాబట్టి ఆ టీజర్ మరియు ఒక వార్తలు
వచ్చి ఏమి మానసిక మోడల్.

363
00:15:02,882 --> 00:15:04,590
ఇప్పుడు, నేను procrastinated
ఒక బిట్ ఈ ఉదయం.

364
00:15:04,590 --> 00:15:09,560
నేను ఏమి చూడటానికి రకమైన ఆసక్తికరమైన ఉంది
మైక్రోసాఫ్ట్ వాల్ నిజానికి

365
00:15:09,560 --> 00:15:10,310
నేడు కనిపిస్తుంది.

366
00:15:10,310 --> 00:15:15,200
మరియు అది 2006 లో ఎవరైనా అవుతుంది
నిజానికి దాదాపు ఖచ్చితంగా వెళ్ళింది

367
00:15:15,200 --> 00:15:19,210
అదే స్పాట్ వాస్తవానికి చిత్రీకరించే
ఏమి ఈ రోజుల్లో ఆ కనిపిస్తుంది.

368
00:15:19,210 --> 00:15:21,380
రంగంలో ఇప్పుడు ఒక చిన్న కట్టడాలు ఉంది.

369
00:15:21,380 --> 00:15:24,850
>> కాబట్టి చిత్రాల ఇప్పుడు మాట్లాడుతున్న,
యొక్క ఇక్కడ Daven బాగు తెలియజేయండి

370
00:15:24,850 --> 00:15:26,890
స్క్రీన్ మరియు నికోలస్ న,
మరియు కేవలం మీరు గుర్తు

371
00:15:26,890 --> 00:15:30,540
మీరు భోజనం కోసం మాకు చేరడానికి చెయ్యాలనుకుంటే
మన మామూలు URL కు ఈ శుక్రవారం, తల

372
00:15:30,540 --> 00:15:31,440
ఇక్కడ.

373
00:15:31,440 --> 00:15:33,530
>> కాబట్టి అక్కడ సోమవారం ఆఫ్ చెబుతావా?

374
00:15:33,530 --> 00:15:35,140
మేము కుడి, ఈ సమస్య పరిచయం?

375
00:15:35,140 --> 00:15:37,610
ఈ అంతమయినట్లుగా చూపబడతాడు ఒక సరైనదే
స్వాప్ అమలు

376
00:15:37,610 --> 00:15:40,460
అనగా మీరు, రెండు ints తీసుకొని
ఒకటి, బి అని ఒకటి, ఒక అని

377
00:15:40,460 --> 00:15:44,130
లారా ఇక్కడ చేసినట్టుగానే, వాటిని మార్పిడి
పాలు మరియు నీటితో వేదికపై,

378
00:15:44,130 --> 00:15:46,820
ఒక తాత్కాలిక ఉపయోగించి
వేరియబుల్, లేదా ఒక ఖాళీ కప్పు,

379
00:15:46,820 --> 00:15:50,540
మేము ఒక మరియు ఒక లో బి ఉంచారు కాలేదు
విషయాలు గజిబిజి లేకుండా బి.

380
00:15:50,540 --> 00:15:51,560
మేము ఒక వేరియబుల్ ఉపయోగించారు.

381
00:15:51,560 --> 00:15:52,870
ఇది తాత్కాలిక అని.

382
00:15:52,870 --> 00:15:55,520
>> కానీ ప్రాథమిక ఏమిటి
సోమవారం ఈ కోడ్ తో సమస్య?

383
00:15:55,520 --> 00:15:57,700

384
00:15:57,700 --> 00:15:58,870
ఇక్కడ సమస్య ఏమిటి?

385
00:15:58,870 --> 00:16:00,106

386
00:16:00,106 --> 00:16:00,605
అవును.

387
00:16:00,605 --> 00:16:01,970
>> ప్రేక్షకులు: ఇది మరింత స్థలాన్ని పడుతుంది.

388
00:16:01,970 --> 00:16:04,719
>> డేవిడ్ J. మలన్: మరింత అప్ టేక్స్
స్పేస్, నేను ఒక వేరియబుల్ ఉపయోగించి నేను ఎందుకంటే,

389
00:16:04,719 --> 00:16:05,400
మరియు ఆ సరే.

390
00:16:05,400 --> 00:16:07,300
ఆ నిజం, కానీ నేను ఉన్నాను
ఆ సరే చెప్పాలి.

391
00:16:07,300 --> 00:16:10,030
ఇది గ్రాండ్ లో మాత్రమే 32 బిట్స్
విషయాలు పథకం, కాబట్టి ఒక పెద్ద ఒప్పందం.

392
00:16:10,030 --> 00:16:10,655
ఇతర ఆలోచనలు?

393
00:16:10,655 --> 00:16:12,572
ప్రేక్షకులు: ఇది మాత్రమే మార్పిడులు
స్థానికంగా వేరియబుల్స్.

394
00:16:12,572 --> 00:16:13,571
డేవిడ్ J. మలన్: ఖచ్చితంగా.

395
00:16:13,571 --> 00:16:15,090
ఇది కేవలం స్థానికంగా వేరియబుల్స్ మార్పిడులు.

396
00:16:15,090 --> 00:16:18,173
ఏ సమయంలో మీరు ఒక ఫంక్షన్ కాల్ ఎందుకంటే
నేను Annenberg నుండి ట్రేలు ఉన్నప్పుడు

397
00:16:18,173 --> 00:16:19,840
చివరిసారి, మీరు అడుగున ప్రధాన చేశారు.

398
00:16:19,840 --> 00:16:23,560
వెంటనే మీరు అని ఒక ఫంక్షన్ కాల్ వంటి
స్వాప్, స్వాప్ x మరియు y లభించక

399
00:16:23,560 --> 00:16:24,400
అసలు విలువలు.

400
00:16:24,400 --> 00:16:26,392
మనం దావా లేదు, స్వాప్ చేయదా?

401
00:16:26,392 --> 00:16:27,100
ప్రేక్షకులు: ప్రతులు.

402
00:16:27,100 --> 00:16:28,090
డేవిడ్ J. మలన్: వాటిలో కాపీలు కాబట్టి.

403
00:16:28,090 --> 00:16:31,120
కాబట్టి మీరు ఉంటే, ఒక మరియు రెండు గెట్స్
చివరిసారి నుండి, ఉదాహరణకు, రీకాల్

404
00:16:31,120 --> 00:16:34,730
కానీ ఒక మరియు రెండు ప్రతిని
విజయవంతంగా మార్చుకున్నారు ఉంటాయి.

405
00:16:34,730 --> 00:16:38,550
కానీ దురదృష్టవశాత్తు చివరికి,
ఆ విలువలు ఇప్పటికీ ఒకటే.

406
00:16:38,550 --> 00:16:41,880
కాబట్టి మేము ఈ చూడగలరు మా
కొత్త స్నేహితుడు, ఆశాజనక, GDB,

407
00:16:41,880 --> 00:16:45,180
మీరు లేదా TFS మరియు Ca యొక్క కలిగి
ఈ క్రింది విధంగా వైపు మీరు మార్గదర్శక చేశారు.

408
00:16:45,180 --> 00:16:51,210
>> సో సంఖ్య స్వాప్ రీకాల్ లెట్ యొక్క వంటి కనిపిస్తుంది
ఈ వంటి ఉండాలి ఈ లుక్స్ అప్ తెరవండి.

409
00:16:51,210 --> 00:16:54,160
మేము రెండు, ఒకటి y, x initialized.

410
00:16:54,160 --> 00:16:55,620
ముద్రణ F యొక్క బంచ్ కలిగి.

411
00:16:55,620 --> 00:16:58,080
కానీ, కీ కాల్
ఇక్కడ, స్వాప్ ఇది

412
00:16:58,080 --> 00:17:00,260
సరిగ్గా కోడ్ మేము
కేవలం ఒక క్షణం క్రితం చూసింది.

413
00:17:00,260 --> 00:17:03,180
ఇది మొదటి వద్ద సరైన ఉంది
చూపులో క్రియాశీలంగా

414
00:17:03,180 --> 00:17:06,800
ఈ కార్యక్రమం ఎందుకంటే, పని లేదు
అది శాశ్వతంగా x మరియు y రెండు స్వాప్ లేదు.

415
00:17:06,800 --> 00:17:10,190
>> కాబట్టి, ఒక శీఘ్ర వెచ్చని యొక్క చూసేలా ఈ
ఇక్కడ GDB, ఒక ./noswap తో.

416
00:17:10,190 --> 00:17:11,867

417
00:17:11,867 --> 00:17:15,200
అధిక సమాచారము సమూహం ఆ
నేను ఇప్పుడు కోసం కంట్రోల్ L తో విమోచనం పొందుతారు.

418
00:17:15,200 --> 00:17:17,516
మరియు ఇప్పుడు, నేను వెళుతున్న
ముందుకు వెళ్ళడానికి మరియు అమలు.

419
00:17:17,516 --> 00:17:19,349
మరియు దురదృష్టవశాత్తు, ఆ
ఆ ఉపయోగకరం కాదు.

420
00:17:19,349 --> 00:17:22,355
ఇది ఈ లోపల కార్యక్రమం నడిచింది
కార్యక్రమం, GDB ఒక డీబగ్గర్ అని

421
00:17:22,355 --> 00:17:23,730
కానీ అది నాకు చుట్టూ దూర్చు వీలు లేదు.

422
00:17:23,730 --> 00:17:26,229
>> నేను నిజానికి విరామం చేయవచ్చు ఎలా
ఈ కార్యక్రమం లోపల అమలు?

423
00:17:26,229 --> 00:17:27,410

424
00:17:27,410 --> 00:17:28,329
కాబట్టి విడిపోయారు.

425
00:17:28,329 --> 00:17:32,340
నేను ఏ విచ్ఛిన్నం కాలేదు
లైన్ నెంబర్, ఒక, 10, 15.

426
00:17:32,340 --> 00:17:35,530
కానీ నేను కూడా ప్రతీకాత్మకంగా విరిగిపోతాయి
విరామం ప్రధాన విధంగా.

427
00:17:35,530 --> 00:17:38,980
మరియు ఒక విరామం సెట్ చేస్తాడు
పాయింట్, స్పష్టంగా ప్రధాన లైన్ 16 వద్ద.

428
00:17:38,980 --> 00:17:40,050
మరియు ఎక్కడ లైన్ 16?

429
00:17:40,050 --> 00:17:42,960
యొక్క కోడ్ వరకు వెళ్ళి తెలపండి
మరియు noswap వరకు వెళ్ళండి.

430
00:17:42,960 --> 00:17:46,930
నిజానికి, లైన్ 16
మొదటి కార్యక్రమం లో.

431
00:17:46,930 --> 00:17:52,130
>> కాబట్టి ఇప్పుడు, నేను ముందుకు వెళ్లి టైప్
ఈ సమయాన్ని అమలు ఎంటర్, ఇది పాజ్.

432
00:17:52,130 --> 00:17:53,080
కాబట్టి యొక్క చుట్టూ దూర్చు తెలియజేయండి.

433
00:17:53,080 --> 00:17:55,716
ఎందుకు X సున్నా x-- ముద్రించు?

434
00:17:55,716 --> 00:17:56,705

435
00:17:56,705 --> 00:17:57,830
మరియు డాలర్ సైన్ పట్టించుకోకండి.

436
00:17:57,830 --> 00:17:59,725
ఆ ఫ్యాన్సియెర్స్ కేవలం వార్తలు
కార్యక్రమం వాడుక.

437
00:17:59,725 --> 00:18:00,780

438
00:18:00,780 --> 00:18:03,140
ఎందుకు సమయంలో x సున్నా?

439
00:18:03,140 --> 00:18:03,640
అవును.

440
00:18:03,640 --> 00:18:07,061
>> ప్రేక్షకులు: ఇది కుడి ముందు పాజ్
లైన్ 16, నిజానికి లైన్ 16 న.

441
00:18:07,061 --> 00:18:08,060
డేవిడ్ J. మలన్: ఖచ్చితంగా.

442
00:18:08,060 --> 00:18:11,630
GDB, అప్రమేయంగా, నిలిపివేయబడింది
కేవలం లైన్ 16 ముందు మరణశిక్ష.

443
00:18:11,630 --> 00:18:14,820
కాబట్టి అది అమలు చేయలేదు ఇది
కొన్ని తెలియని విలువ ఉంది x అంటే.

444
00:18:14,820 --> 00:18:17,150
మరియు మేము అది అదృష్ట వచ్చింది
సున్నా వంటి శుభ్రంగా ఏదో.

445
00:18:17,150 --> 00:18:20,310
కాబట్టి ఇప్పుడు నేను తదుపరి టైప్ ఉంటే,
ఇప్పుడు అది 16 అమలు.

446
00:18:20,310 --> 00:18:22,000
నాకు 17 అమలు కోసం ఇది వేచి యొక్క.

447
00:18:22,000 --> 00:18:23,400
నాకు ముందుకు ముద్రణ x వెళ్ళి తెలపండి.

448
00:18:23,400 --> 00:18:24,094
ఇది ఒకటి.

449
00:18:24,094 --> 00:18:25,260
నాకు ముందుకు మరియు y ముద్రణ వెళ్ళి తెలపండి.

450
00:18:25,260 --> 00:18:26,176
నేను ఇప్పుడు ఏమి చూస్తారు?

451
00:18:26,176 --> 00:18:27,660

452
00:18:27,660 --> 00:18:28,560
>> ప్రేక్షకులు: [వినబడని]

453
00:18:28,560 --> 00:18:29,165
>> డేవిడ్ J. మలన్: బిగ్గరగా కొద్దిగా.

454
00:18:29,165 --> 00:18:30,040
>> ప్రేక్షకులు: [వినబడని]

455
00:18:30,040 --> 00:18:30,537

456
00:18:30,537 --> 00:18:32,120
డేవిడ్ J. మలన్: కాదు చాలా ఏకాభిప్రాయం.

457
00:18:32,120 --> 00:18:34,760
కాబట్టి అవును, మేము కొన్ని చెత్త విలువ చూడండి.

458
00:18:34,760 --> 00:18:37,862
ఇప్పుడు, Y అక్కడ 134514064 ఉంది.

459
00:18:37,862 --> 00:18:39,320
సరే, కేవలం కొన్ని చెత్త విలువ ఏమిటి.

460
00:18:39,320 --> 00:18:41,350
నా కార్యక్రమం RAM ఉపయోగించే
వివిధ ప్రయోజనాల కోసం.

461
00:18:41,350 --> 00:18:42,350
ఇతర విధులు ఉన్నాయి.

462
00:18:42,350 --> 00:18:44,040
ఇతర ప్రజలు నా కంప్యూటర్ లోపల రాశారు.

463
00:18:44,040 --> 00:18:46,789
కాబట్టి ఆ బిట్స్ కోసం ఉపయోగిస్తున్నారు
ఇతర విలువలు, నేను ఏమి చూసిన వెబ్

464
00:18:46,789 --> 00:18:49,470
కొన్ని అవశేషాలు ఉంది
మెమరీ ముందు ఉపయోగం.

465
00:18:49,470 --> 00:18:53,350
>> అలా ఏ పెద్ద ఒప్పందం, ఎందుకంటే త్వరలో
నేను తరువాత టైప్ ఆపై ముద్రణ y వంటి,

466
00:18:53,350 --> 00:18:55,640
అది initialized ఉంది
నేను కావలసిన విలువ.

467
00:18:55,640 --> 00:18:57,400
కాబట్టి ఇప్పుడు, యొక్క కొద్దిగా వేగంగా ముందుకు వెళ్ళి తెలపండి.

468
00:18:57,400 --> 00:18:58,540
తరువాతి కోసం ఉ.

469
00:18:58,540 --> 00:18:59,570
మళ్ళీ దాన్ని లెట్.

470
00:18:59,570 --> 00:19:00,530
మళ్ళీ దాన్ని లెట్.

471
00:19:00,530 --> 00:19:02,404
కానీ నేను హిట్ వద్దు
ఇక్కడ అది, ఎందుకంటే నేను ఉంటే

472
00:19:02,404 --> 00:19:05,110
లోపల ఏం జరగబోతోంది చూడాలనుకుంటే
స్వాప్, ఆదేశం ఏమిటి?

473
00:19:05,110 --> 00:19:05,520
>> ప్రేక్షకులు: దశలను.

474
00:19:05,520 --> 00:19:06,436
>> డేవిడ్ J. మలన్: దశలను.

475
00:19:06,436 --> 00:19:09,800
కాబట్టి ఈ లోకి నన్ను వేసింది
అంతేకానీ పైగా కంటే ఫంక్షన్.

476
00:19:09,800 --> 00:19:12,270
మరియు ఇప్పుడు, ఒక చిన్న గుప్తమైన వార్తలు
నిజాయితీగా, కానీ ఈ కేవలం ఉంది

477
00:19:12,270 --> 00:19:14,581
నేను ఇప్పుడు లైన్ 33 లో ఉన్నాను నాకు చెప్పటం.

478
00:19:14,581 --> 00:19:15,580
మరియు మళ్ళీ తెలియజేసేలా.

479
00:19:15,580 --> 00:19:16,080
ప్రింట్ తాత్కాలిక.

480
00:19:16,080 --> 00:19:17,129

481
00:19:17,129 --> 00:19:20,170
చెత్త విలువ, ప్రతికూల ఈ సమయంలో,
కానీ కేవలం ఇప్పటికీ ఒక చెత్త విలువ ఏమిటి.

482
00:19:20,170 --> 00:19:22,810
కాబట్టి యొక్క తదుపరి, ముద్రణ టెంప్ తెలియజేసేలా.

483
00:19:22,810 --> 00:19:27,130
ఇది, 1 to initialized ఇందులో
ఒక ఆక x యొక్క విలువ ఉంది.

484
00:19:27,130 --> 00:19:29,110
>> ఇప్పుడు, అక్కడ మా ఒక మరియు నుండి వస్తున్న x?

485
00:19:29,110 --> 00:19:32,510
Well, మేము ప్రధాన గమనించవచ్చు
ఈ విలువలు x మరియు y అనే.

486
00:19:32,510 --> 00:19:34,740
మేము అప్పుడు వాటిలో స్వాప్ వశమైంది.

487
00:19:34,740 --> 00:19:37,010
ఎక్స్ కామా Y, మొదటి వచ్చింది.

488
00:19:37,010 --> 00:19:40,020
ఆపై, స్వాప్ వాటిని x మరియు y కాల్ కాలేదు.

489
00:19:40,020 --> 00:19:42,630
సరళత కోసం, అది వార్తలు
a మరియు b వాటిని కాల్.

490
00:19:42,630 --> 00:19:45,970
కానీ అండ్ బి ఇప్పుడు వెళ్తున్నారు
వరుసగా x మరియు y యొక్క కాపీలు.

491
00:19:45,970 --> 00:19:50,660
>> నేను, టెంప్ తిరిగి GDB వెళ్ళండి చేస్తే
ఇప్పుడు ఒకటి మరియు ఇప్పుడు ఒకటి.

492
00:19:50,660 --> 00:19:56,130
నేను ఇప్పుడు తదుపరి చేయండి మరియు అయితే ముద్రణ చేయండి
ఒక, ఒక గడిచినా తరలించబడింది.

493
00:19:56,130 --> 00:20:00,030
పాలు మాజీ లోకి కురిపించింది చేయబడింది
నారింజ రసం యొక్క గాజు, లేదా ఇదే విధంగా విరుద్ధంగా.

494
00:20:00,030 --> 00:20:04,750
>> మరియు నేను ఇప్పుడు మళ్ళీ తరువాతి ఏమి, మరియు ఉంటే
నేను ఒక పవిత్రత చెక్ వలె ముద్రించవచ్చు ఉంటే,

495
00:20:04,750 --> 00:20:07,687
ఇప్పటికీ రెండు, కానీ బి ఇప్పుడు ఒకటి.

496
00:20:07,687 --> 00:20:08,770
స్పష్టముగా, అది ఇప్పటికీ ఉంది.

497
00:20:08,770 --> 00:20:10,670
నేను ఏమి తాత్కాలిక పట్టించుకోను.

498
00:20:10,670 --> 00:20:16,850
కానీ వెంటనే నేను ఇప్పుడు టైప్ వంటి, యొక్క అని పిలవబడు
ఇప్పుడు నేను చివరిలో ఉన్నాను, తిరిగి వెళ్ళడానికి కొనసాగుతుంది

499
00:20:16,850 --> 00:20:17,480
కార్యక్రమం.

500
00:20:17,480 --> 00:20:20,730
మరియు దురదృష్టవశాత్తు, X ఉంది
ఒక మరియు Y ఇప్పటికీ రెండు ఉంది.

501
00:20:20,730 --> 00:20:22,272
>> సో అక్కడ GDB యొక్క వినియోగ ఏమి ఉంది?

502
00:20:22,272 --> 00:20:23,980
ఇది నాకు పరిష్కరించడానికి సహాయం లేదు
పర్ సే సమస్య,

503
00:20:23,980 --> 00:20:26,265
కానీ ఆశాజనక నాకు సహాయం
తెలుసుకొని ద్వారా అది అర్థం

504
00:20:26,265 --> 00:20:30,000
అవును, నా తర్కం కుడి, కానీ
నా కోడ్ చివరికి కలిగి లేదు

505
00:20:30,000 --> 00:20:31,450
శాశ్వత ప్రభావం.

506
00:20:31,450 --> 00:20:34,570
కాబట్టి మేము ఉన్నాము సమస్య
ఇప్పుడు నేడు పరిష్కరించడానికి వెళ్తున్నారు.

507
00:20:34,570 --> 00:20:37,870
>> కానీ యొక్క ఈ మార్గం ద్వారా అక్కడ పొందుటకు వీలు.

508
00:20:37,870 --> 00:20:39,230
స్ట్రింగ్ ఒక అబద్ధం ఉంది.

509
00:20:39,230 --> 00:20:41,860
ఇది, చాలా, ఒక డేటా రకం
అంతే C. లో ఉంది

510
00:20:41,860 --> 00:20:44,750
కొన్ని పర్యాయపదంగా ఉన్నారు
ఏదో కోసం సమయం

511
00:20:44,750 --> 00:20:47,300
మరియు మేము ఈ క్రింది తెలుస్తుంది.

512
00:20:47,300 --> 00:20:53,282
>> నాకు ముందుకు వెళ్లి తెరుచుకుంటుంది లెట్
ఒక కార్యక్రమం పోల్చి-0 అని.

513
00:20:53,282 --> 00:20:56,240
మరియు ఈ ఒక రకం అవుట్ కాకుండా,
మేము కోడ్ నడవడానికి మొదలు పెడతారేమో

514
00:20:56,240 --> 00:20:58,040
నేను ఇప్పటికే రాశారు, కానీ
ఇది కేవలం కొన్ని పంక్తులు ఉంది.

515
00:20:58,040 --> 00:20:59,570
కాబట్టి ఈ సరిపోల్చండి-0.

516
00:20:59,570 --> 00:21:02,380
మరియు మొదటి విషయం నేను ఏమి చేస్తున్నానో
టెక్స్ట్ లోని ఒక లైన్ పెరిగిపోతుంది.

517
00:21:02,380 --> 00:21:05,610
>> కానీ నేను ఉన్నాను గమనిస్తారు
మొదటిసారి చేయడం.

518
00:21:05,610 --> 00:21:07,910
ఏం స్పష్టంగా లైన్ 21 గురించి భిన్నంగా ఉంటుంది?

519
00:21:07,910 --> 00:21:10,020

520
00:21:10,020 --> 00:21:11,402
అసలైన, ఒక నిమిషం వేచి.

521
00:21:11,402 --> 00:21:12,110
ఈ కాపీ రెండు ఉంది.

522
00:21:12,110 --> 00:21:13,568
కూడా కుడి కార్యక్రమం కాదు.

523
00:21:13,568 --> 00:21:14,780
అన్ని కుడి, స్పాయిలర్ హెచ్చరిక.

524
00:21:14,780 --> 00:21:16,890
All right, కాబట్టి పర్వాలేదు.

525
00:21:16,890 --> 00:21:18,520
ఒక భవిష్యత్తు ప్రశ్నకు సమాధానం ఉంది.

526
00:21:18,520 --> 00:21:21,450
>> ఇక్కడ-0 పోల్చి, మరియు నేను ఉన్నాను ఉంది
టెక్స్ట్ యొక్క ఒక లైన్ పొందడానికి గురించి.

527
00:21:21,450 --> 00:21:22,435
ప్రోగ్రామ్ యొక్క అతి సాధారణ చేస్తుంది.

528
00:21:22,435 --> 00:21:23,560
కాబట్టి ఈ ముక్కుసూటి ఉంది.

529
00:21:23,560 --> 00:21:28,070
ఈ వారం ఒకటి, వీక్ రెండు stuff వంటి ఉంది
సమయంలో. స్ట్రింగ్ s = GetString.

530
00:21:28,070 --> 00:21:29,700
ఇప్పుడు, నేను ఇక్కడ డౌన్ మళ్ళీ చెప్పాను.

531
00:21:29,700 --> 00:21:31,830
స్ట్రింగ్ t = GetString.

532
00:21:31,830 --> 00:21:35,300
ఈ ఆపై, చివరి విషయం
కార్యక్రమం, దాని పేరు సూచించిన విధంగా,

533
00:21:35,300 --> 00:21:37,090
నేను వాటిని పోల్చడానికి ప్రయత్నించండి వెళుతున్న ఉంది.

534
00:21:37,090 --> 00:21:40,709
>> కాబట్టి s ఉంటే, మొదటి స్ట్రింగ్,
= T, అప్పుడు నేను ఉన్నాను సమానం

535
00:21:40,709 --> 00:21:42,250
మీరు అదే విషయం టైప్ చెప్పండి వెళుతున్న.

536
00:21:42,250 --> 00:21:44,291
ఎల్స్, నేను చెప్పడానికి వెళుతున్న
మీరు వివిధ విషయాలను టైప్.

537
00:21:44,291 --> 00:21:45,880
కాబట్టి యొక్క ఈ కార్యక్రమం కంపైల్ మరియు అమలు అనుమతిస్తాయి.

538
00:21:45,880 --> 00:21:48,481
కాబట్టి సున్నా పోల్చి తయారు.

539
00:21:48,481 --> 00:21:48,980
బాగుంది.

540
00:21:48,980 --> 00:21:50,490
ఏ సంగ్రహం లోపాలు.

541
00:21:50,490 --> 00:21:52,386
>> నాకు ఇప్పుడు ముందుకు వెళ్ళి తెలపండి
మరియు ./compare-0 టైప్ చేయండి.

542
00:21:52,386 --> 00:21:55,230

543
00:21:55,230 --> 00:21:59,220
నాకు ముందుకు వెళ్లి ఏదో చెప్పటానికి లెట్
: Daven మరియు ఏదో: రాబ్.

544
00:21:59,220 --> 00:22:00,450
మరియు నేను వివిధ విషయాలను టైప్.

545
00:22:00,450 --> 00:22:01,250
సో ఫార్, సో గుడ్.

546
00:22:01,250 --> 00:22:02,680
ప్రోగ్రామ్ సరైన ఉంది.

547
00:22:02,680 --> 00:22:03,880
>> కానీ మళ్ళీ దాన్ని అమలు అనుమతిస్తాయి.

548
00:22:03,880 --> 00:22:05,800
ఏదో సే: గాబే.

549
00:22:05,800 --> 00:22:07,140
ఏదో సే: గాబే.

550
00:22:07,140 --> 00:22:08,520

551
00:22:08,520 --> 00:22:09,020
అన్ని కుడి.

552
00:22:09,020 --> 00:22:10,851
బహుశా నేను స్పేస్ బార్ నొక్కండి
లేదా అల్లరిగా ఏదో.

553
00:22:10,851 --> 00:22:11,600
మళ్ళీ దాన్ని లెట్.

554
00:22:11,600 --> 00:22:13,020
Zamyla కాబట్టి.

555
00:22:13,020 --> 00:22:13,970

556
00:22:13,970 --> 00:22:14,470
Zamyla.

557
00:22:14,470 --> 00:22:15,740

558
00:22:15,740 --> 00:22:17,330
వివిధ విషయాలు.

559
00:22:17,330 --> 00:22:19,430
కాబట్టి ఏం జరుగుతుందో?

560
00:22:19,430 --> 00:22:23,200
>> కాబట్టి మేము ఈ రెండు పంక్తులు కలిగి
కోడ్ GetString, రెండుసార్లు అని పిలిచారు.

561
00:22:23,200 --> 00:22:25,760
ఆపై, నేను కేవలం ఉన్నాను
s మరియు t పోల్చడానికి ప్రయత్నిస్తున్న.

562
00:22:25,760 --> 00:22:28,370
కానీ జరుగుతుందో అప్పుడు నిజంగా ఏమి?

563
00:22:28,370 --> 00:22:31,180
బాగా, నా చేతిరాత గురించి
కొంతవరకు ఈ ఉదాహరణ బుట్చేర్.

564
00:22:31,180 --> 00:22:34,630
మరియు వాస్తవానికి త్రో అనుమతిస్తాయి
ఈ అప్ ఇక్కడ పైగా, అలాగే.

565
00:22:34,630 --> 00:22:37,390

566
00:22:37,390 --> 00:22:45,712
>> కాబట్టి మేము ఒక లైన్ వలె కలిగి
స్ట్రింగ్ s = GetString.

567
00:22:45,712 --> 00:22:48,295
కాబట్టి ఆ కేవలం మొదటి వార్తలు
ఆ కార్యక్రమం నుంచి ఆసక్తికరమైన లైన్.

568
00:22:48,295 --> 00:22:49,920

569
00:22:49,920 --> 00:22:52,974
కానీ ఈ సమయంలో ఉంది ఏమి
హుడ్ కింద జరగబోతోంది?

570
00:22:52,974 --> 00:22:55,890
వెల్, ఎడమ వైపు వైపు తీగ ఉంది
ఇది వేరియబుల్ కొన్ని రకం,

571
00:22:55,890 --> 00:22:56,785
మరియు అది యొక్క అని.

572
00:22:56,785 --> 00:23:00,019
కాబట్టి నేను ఈ మెమరీ ఉపయోగించి తెలుసు,
లేదా RAM, ఏదో నా కంప్యూటర్ లో.

573
00:23:00,019 --> 00:23:02,060
నేను బొత్తిగా వెళుతున్న
ఒక చదరపు వంటి డ్రా.

574
00:23:02,060 --> 00:23:04,820
32 బిట్స్, ఇది అవుతుంది, కానీ
భవిష్యత్తులో ఆ మరింత.

575
00:23:04,820 --> 00:23:06,410
ఆపై, ఏమి ఇక్కడ పైగా జరగబోతోంది?

576
00:23:06,410 --> 00:23:08,700
>> సరే, స్పష్టంగా GetString
వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందుతాడు.

577
00:23:08,700 --> 00:23:11,360
మరియు GetString వచ్చింది
Zamyla లేదా గాబే లేదా Daven.

578
00:23:11,360 --> 00:23:14,640
కాబట్టి యొక్క మొదటి ఎంపిక తెలియజేయండి
వారిలో, Daven ఇది.

579
00:23:14,640 --> 00:23:19,174
అది ప్రభావవంతంగా, ఏమి GetString వచ్చింది
నాకు ఆ మొదటి సందర్భంలో D-a-V-E-N జరిగినది.

580
00:23:19,174 --> 00:23:22,690

581
00:23:22,690 --> 00:23:25,045
ఆపై, ఏమి చేసాడు
అది నాకు రహస్యంగా ఇవ్వాలని?

582
00:23:25,045 --> 00:23:25,920
ప్రేక్షకులు: [వినబడని]

583
00:23:25,920 --> 00:23:28,720
డేవిడ్ J. మలన్: అవును,
/ 0 లేదా శూన్య పాత్ర.

584
00:23:28,720 --> 00:23:30,550
కనుక ఇది సమర్థవంతంగా నాకు ఒక స్ట్రింగ్ ఇచ్చారు.

585
00:23:30,550 --> 00:23:34,550
కానీ మేము ఇప్పటికే మునుపటి నుండి తెలుసు
ఒక స్ట్రింగ్ కేవలం ఒక శ్రేణి కనిపిస్తోంది

586
00:23:34,550 --> 00:23:37,895
అక్షరాలు, మరియు అది ద్వారా రద్దు యొక్క
ఈ ప్రత్యేక కాపలాదారుడు పాత్ర, / 0.

587
00:23:37,895 --> 00:23:39,220

588
00:23:39,220 --> 00:23:42,310
>> కానీ ఈ నిజమైన ఉంటే
మరియు ఈ ఒక కూడలి,

589
00:23:42,310 --> 00:23:44,160
ఈ స్పష్టంగా చాలా పెద్ద దీర్ఘచతురస్రం ఉంది.

590
00:23:44,160 --> 00:23:46,830
నిజానికి, ఈ,
నేను మాత్రమే 32 బిట్స్ పేర్కొంటున్నాయి.

591
00:23:46,830 --> 00:23:49,500
మరియు ఈ స్పష్టంగా కంటే ఎక్కువ 32
బిట్స్, ఈ బహుశా ఎందుకంటే

592
00:23:49,500 --> 00:23:51,583
ఎనిమిది ప్లస్ ఎనిమిది ప్లస్ ఎనిమిది
ప్లస్ ఎనిమిది ప్లస్ ఎనిమిది,

593
00:23:51,583 --> 00:23:53,320
కేవలం ASCII లో బైట్లు ఎందుకంటే.

594
00:23:53,320 --> 00:23:57,030
ఎలా హెక్ మేము సరిపోయే వెళ్తున్నారు
ఇక్కడ ఈ చిన్న పెట్టెలో Daven?

595
00:23:57,030 --> 00:23:59,880
>> Well, వాస్తవానికి చేయడం GetString ఉంది?

596
00:23:59,880 --> 00:24:03,680
Well, ఈ గ్రిడ్ ఇక్కడ సూచిస్తుంది
నా కంప్యూటర్ యొక్క మెమరీ లేదా RAM.

597
00:24:03,680 --> 00:24:07,564
కాబట్టి యొక్క ఏకపక్ష ఉంటే అని పిలవబడు
ఈ యొక్క ప్రతి ఒక బైట్ సూచిస్తుంది

598
00:24:07,564 --> 00:24:09,730
అప్పుడు మేము ప్రతి ఆలోచించవచ్చు
బైట్ ఒక చిరునామా కలిగి,

599
00:24:09,730 --> 00:24:13,830
33 ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా 34 వలె
ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా 35 ఆక్స్ఫోర్డ్ స్ట్రీట్.

600
00:24:13,830 --> 00:24:16,700
>> కాబట్టి గృహాలు చిరునామాలను కలిగి వలె
మరియు భవనాలు చిరునామాలను కలిగి,

601
00:24:16,700 --> 00:24:19,810
కాబట్టి వ్యక్తిగత బైట్లు చేయండి
మెమరీ చిరునామాలు లేదా సంఖ్యలు కలిగి

602
00:24:19,810 --> 00:24:21,042
ఆ ప్రత్యేకంగా వాటిని గుర్తిస్తాయి.

603
00:24:21,042 --> 00:24:22,000
ఇప్పుడు, ఈ ఏకపక్ష ఉంది.

604
00:24:22,000 --> 00:24:25,370
కానీ నేను వెళుతున్న, అది సాధారణ ఉంచడానికి
కేవలం కన్వెన్షన్ ద్వారా హెక్సాడెసిమల్ ఉపయోగించడానికి,

605
00:24:25,370 --> 00:24:28,200
కానీ 0x ఇతర ఏమీ అర్థం
కంటే "ఈ హెక్సాడెసిమల్."

606
00:24:28,200 --> 00:24:31,030
మరియు నేను ఆ దావా వెళుతున్న
"D" మెమరీలో బైట్ వన్ వద్ద ముగుస్తుంది.

607
00:24:31,030 --> 00:24:34,210
>> నేను వేరే ఏమీ లో జరగబోతోంది వచ్చింది
జ్ఞాపకాలు, Daven మొదటి స్పాట్ వచ్చింది

608
00:24:34,210 --> 00:24:35,509
బైట్ ఒక.

609
00:24:35,509 --> 00:24:36,800
ఈ అప్పుడు 0x2 అవతరిస్తుంది.

610
00:24:36,800 --> 00:24:37,831

611
00:24:37,831 --> 00:24:38,705
ఈ 0x3 అన్నారు.

612
00:24:38,705 --> 00:24:39,840

613
00:24:39,840 --> 00:24:41,800
ఈ 0x4 అవతరిస్తుంది.

614
00:24:41,800 --> 00:24:43,025
ఈ 0x5 అన్నారు.

615
00:24:43,025 --> 00:24:44,025
ఈ 0x6 అవతరిస్తుంది.

616
00:24:44,025 --> 00:24:45,560

617
00:24:45,560 --> 00:24:48,290
>> కానీ ఒకసారి మీరు ఆలోచిస్తూ ప్రారంభించండి
ఏమి కంప్యూటర్ చేయుచున్నాడు గురించి

618
00:24:48,290 --> 00:24:50,710
హుడ్ కింద,
మీరు ప్రతిపాదించే ప్రారంభించవచ్చు

619
00:24:50,710 --> 00:24:54,960
ఎలా మీరు, కొన్ని సంవత్సరాల క్రితం, భవిష్యత్తును
కూడా సి అమలు చేశారు.

620
00:24:54,960 --> 00:24:58,360
బహుశా GetString ఏమిటి
returning-- అది ఎందుకంటే

621
00:24:58,360 --> 00:25:00,946
అది కాదు అనుకుని
తిరిగి Daven, ప్రతి SE,

622
00:25:00,946 --> 00:25:03,320
అతను తప్పనిసరిగా వెళ్ళడం లేదు ఎందుకంటే
ఈ చిన్న box-- లో సరిపోయే

623
00:25:03,320 --> 00:25:05,090
కాబట్టి ఏమి GetString బహుశా తిరిగి?

624
00:25:05,090 --> 00:25:07,958

625
00:25:07,958 --> 00:25:08,920
>> ప్రేక్షకులు: [వినబడని]

626
00:25:08,920 --> 00:25:10,540
>> డేవిడ్ J. మలన్: Daven నగర.

627
00:25:10,540 --> 00:25:12,770
మరియు అది ఈ చేస్తోంది
ఎప్పుడూ వీక్ వన్ నుండి.

628
00:25:12,770 --> 00:25:16,150
ఏం GetString నిజంగా ఉంది
తిరిగి ఒక స్ట్రింగ్, కేవలంగా కాదు.

629
00:25:16,150 --> 00:25:17,780
ఆ చిన్న తెల్ల అసత్యాలు ఒకటి.

630
00:25:17,780 --> 00:25:22,520
ఇది యొక్క చిరునామా తిరిగి
మెమరీ స్ట్రింగ్, ఏకైక చిరునామా.

631
00:25:22,520 --> 00:25:24,820
Daven 33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వద్ద నివసిస్తున్నారు.

632
00:25:24,820 --> 00:25:29,310
కానీ మరింత క్లుప్తమైన, గావిన్ నివసిస్తున్నారు
0x1 వద్ద, సంఖ్య ఒక చిరునామా.

633
00:25:29,310 --> 00:25:32,280
>> సో వాట్ ఈ ఉంచే
చిన్న బాక్స్ అప్పుడు, స్పష్టంగా ఉండాలి

634
00:25:32,280 --> 00:25:35,930
ఆ స్ట్రింగ్ యొక్క చిరునామా.

635
00:25:35,930 --> 00:25:38,110
కాబట్టి ఈ అన్ని సమయం, ఈ
ఉంది జరుగుతున్నాయి.

636
00:25:38,110 --> 00:25:41,650
కానీ ఈ సూచనలను
ఇప్పుడు అన్ని ఉంటే కలిగి ఉంది

637
00:25:41,650 --> 00:25:44,710
అది లోపల అనేక, ఎవరు ఉంది
మీరు ఆపడానికి, ప్రోగ్రామర్,

638
00:25:44,710 --> 00:25:47,970
లో ఎన్ని ఉంచడం నుండి
ఏ వేరియబుల్ మరియు కేవలం జంపింగ్

639
00:25:47,970 --> 00:25:49,080
మెమరీ ఆ భాగం?

640
00:25:49,080 --> 00:25:51,320
నిజానికి, మేము చూస్తారు
ఒక బెదిరింపు తదుపరి సమయం.

641
00:25:51,320 --> 00:25:53,500
>> కానీ ఇప్పుడు కోసం, ఈ చాలని అనిపిస్తుంది.

642
00:25:53,500 --> 00:25:55,630
నేను చెప్పేది ఉంటే, నాకు ఒక పొందండి
స్ట్రింగ్, మీరు నాకు Daven ఇస్తాయి.

643
00:25:55,630 --> 00:25:57,230
కానీ మీరు నిజంగా నాకు Daven ఇవ్వాలని లేదు.

644
00:25:57,230 --> 00:25:59,310
మీరు నాకు ఇవ్వాలని అన్ని Daven యొక్క చిరునామా.

645
00:25:59,310 --> 00:26:04,310
నేను అప్పుడు ఖచ్చితంగా తెలుసు ఎలా
తోబుట్టువుల Daven ప్రారంభమవుతుంది మరియు ends--

646
00:26:04,310 --> 00:26:07,140
కథ యొక్క అసహజ పొందడానికి
Daven ప్రారంభమవుతుంది మరియు ముగుస్తుంది,

647
00:26:07,140 --> 00:26:10,435
మరియు, తదుపరి తర్వాత
మెమరీ స్ట్రింగ్ మొదలవుతుంది?

648
00:26:10,435 --> 00:26:11,520

649
00:26:11,520 --> 00:26:13,620
>> సరే, మీరు ఇవ్వడానికి చేస్తుంటే
నాకు Daven ప్రారంభంలో,

650
00:26:13,620 --> 00:26:17,230
ముఖ్యంగా, ఎలా నేను తెలుసు
తన పేరు చివర ఎక్కడ ఉంది?

651
00:26:17,230 --> 00:26:20,550
ప్రత్యేక శూన్య పాత్ర ఇది
అన్ని మరింత ముఖ్యమైన ఇప్పుడు

652
00:26:20,550 --> 00:26:23,040
కింద తీగలను ఉంటే
హుడ్ కేవలం గుర్తించబడతాయి

653
00:26:23,040 --> 00:26:25,820
ప్రత్యేకం స్మృతిలో వారి నగర ద్వారా.

654
00:26:25,820 --> 00:26:28,130
కాబట్టి అన్ని ఈ సమయంలో, ఆ వార్తలు
ఏమి జరుగుతున్నాయి.

655
00:26:28,130 --> 00:26:32,470
>> కాబట్టి మేము ఇప్పుడు చూడండి
ఇక్కడ కోడ్ వివరించడానికి

656
00:26:32,470 --> 00:26:35,790
మీరు లైన్ 26 లో బగ్ అని.

657
00:26:35,790 --> 00:26:39,560
ఎందుకు Zamyla మరియు Zamyla భిన్నంగా ఉంటుంది?

658
00:26:39,560 --> 00:26:41,330
ఎందుకు గాబే మరియు గాబే భిన్నంగా ఉంటుంది?

659
00:26:41,330 --> 00:26:42,154
అవును, తిరిగి లో.

660
00:26:42,154 --> 00:26:43,390
>> ప్రేక్షకులు: వారు వివిధ చిరునామాలను కలిగి.

661
00:26:43,390 --> 00:26:45,931
>> డేవిడ్ J. మలన్: కేవలం ఎందుకంటే
వారు వివిధ చిరునామాలను కలిగి.

662
00:26:45,931 --> 00:26:48,820
మీరు GetString కాల్ చేసినప్పుడు
మళ్ళీ, నేను ఇక్కడ త్వరగా చేస్తాను ఇది,

663
00:26:48,820 --> 00:26:52,870
ఈ రెండవ పంక్తి, స్ట్రింగ్ ఉంటే
టి, నేను ఆ ప్రోగ్రాం వచ్చింది,

664
00:26:52,870 --> 00:26:55,030
GetString మరొక కాల్ సమానం.

665
00:26:55,030 --> 00:26:56,370

666
00:26:56,370 --> 00:26:58,670
నేను కాల్ తదుపరి సమయం
GetString, నేను వెళుతున్నాను

667
00:26:58,670 --> 00:27:00,190
మెమరీ వేరొక భాగం పొందడానికి.

668
00:27:00,190 --> 00:27:02,220
>> GetString అనుమతి
ఆపరేటింగ్ గోవా

669
00:27:02,220 --> 00:27:03,800
మరింత మెమరీ వ్యవస్థ.

670
00:27:03,800 --> 00:27:07,894
ఇది అదే తిరిగి మాత్రం కాదు
ఆరు బైట్లు ప్రతి ఒక్క సారి.

671
00:27:07,894 --> 00:27:09,810
ఇది ఒక కొత్త పొందడానికి జరగబోతోంది
మెమరీ భాగం, ఇది

672
00:27:09,810 --> 00:27:12,780
T వస్తుందా మాత్రం అర్థం
ఇక్కడ పైగా కొన్ని ఇతర విలువ.

673
00:27:12,780 --> 00:27:15,380
>> నేను అలా చేసినప్పుడు లు = సమానం
T, మీరు పోల్చడం లేదు

674
00:27:15,380 --> 00:27:17,880
ఈ మరియు ఒక వ్యతిరేకంగా డి
ఈ మరియు ఈ వ్యతిరేకంగా వి.

675
00:27:17,880 --> 00:27:19,588
మీరు ఈ పోల్చడం చేస్తున్నారు
, ఇది ఈ వ్యతిరేకంగా

676
00:27:19,588 --> 00:27:24,020
స్పష్టముగా అందంగా useful-- useless-- ఉంది
అందంగా నిరుపయోగం నిజంగా ఎందుకంటే

677
00:27:24,020 --> 00:27:25,830
తీగలను మెమరీ ఎక్కడ పట్టించుకుంటారు?

678
00:27:25,830 --> 00:27:26,850
>> నిజానికి, మేము కలిగి.

679
00:27:26,850 --> 00:27:28,980
మరియు మేము వెళ్ళడం లేదు చేస్తున్నాం
ముఖ్యంగా caring ప్రారంభించండి.

680
00:27:28,980 --> 00:27:34,180
మాత్రమే దోషాలు తలెత్తుతాయి ఆ మేరకు
మరియు భద్రతా బెదిరింపులతో సంకల్పం పెరగవచ్చు

681
00:27:34,180 --> 00:27:36,100
మేము నిజానికి ఈ పట్టించుకోనట్లు మొదలు.

682
00:27:36,100 --> 00:27:37,230
కాబట్టి ఈ సమస్య పరిష్కరించడానికి అనుమతిస్తాయి.

683
00:27:37,230 --> 00:27:39,650
మీరు సూపర్ కేవలం దాన్ని పరిష్కరించడానికి, అవుతుంది.

684
00:27:39,650 --> 00:27:42,600
>> మరియు నేను ముందు, నిజానికి లెట్స్
మళ్ళీ వెల్లడించలేదు ఏమైంది

685
00:27:42,600 --> 00:27:47,170
ఒక CS50 తరగతి లో ఉంటే మీరు,
మరియు మీరు అమలు వచ్చింది

686
00:27:47,170 --> 00:27:48,600
రెండు రెమ్మలు వ్యతిరేకంగా ఒక పోలిక.

687
00:27:48,600 --> 00:27:51,440
మీరు స్పష్టంగా, s = T సమానం ఉపయోగించలేరు.

688
00:27:51,440 --> 00:27:54,090
కానీ కేవలం తార్కికంగా, ఎలా
మీరు ఈ స్ట్రింగ్ పోల్చి చేస్తుంది

689
00:27:54,090 --> 00:27:56,370
సి కోడ్ ఉపయోగించి ఈ స్ట్రింగ్ వ్యతిరేకంగా?

690
00:27:56,370 --> 00:27:56,880
అవును.

691
00:27:56,880 --> 00:27:58,780
>> ప్రేక్షకులు: జస్ట్
లూప్ [వినబడని]

692
00:27:58,780 --> 00:28:00,670

693
00:28:00,670 --> 00:28:01,670
డేవిడ్ J. మలన్: పర్ఫెక్ట్.

694
00:28:01,670 --> 00:28:02,900
ప్రేక్షకులు: [వినబడని]

695
00:28:02,900 --> 00:28:03,310
డేవిడ్ J. మలన్: అవును.

696
00:28:03,310 --> 00:28:05,390
కేవలం లూప్ లేదా ఒక ఉపయోగించడానికి
లూప్ లేదా సంసార అయితే.

697
00:28:05,390 --> 00:28:08,710
కానీ కేవలం ప్రాథమిక ఆలోచన దరఖాస్తు ఉంటే
ఈ మెమోరీ లేదా వ్యూహం యొక్క ఒక భాగం ఉంది

698
00:28:08,710 --> 00:28:11,590
మరియు ఈ పైగా iterate
రెండూ ఒకే సమయంలో.

699
00:28:11,590 --> 00:28:12,960
మరియు కేవలం అక్షరాలు సరిపోల్చండి.

700
00:28:12,960 --> 00:28:14,260
>> మరియు మీరు ఒక కలిగి పొందారు
చిన్న జాగ్రత్తగా, మీరు ఎందుకంటే

701
00:28:14,260 --> 00:28:16,247
ఒక వేలు వద్దు
ఇతర గతంలో వెళ్ళడానికి

702
00:28:16,247 --> 00:28:18,080
ఒక స్ట్రింగ్ ఎందుకంటే
ఇతర కంటే ఎక్కువ.

703
00:28:18,080 --> 00:28:21,380
కాబట్టి మీరు చెక్ అనుకుంటున్నారా చూడాలని
చివరిలో ఈ ప్రత్యేక విలువ, శూన్య.

704
00:28:21,380 --> 00:28:24,017
కానీ అది నిజంగా ఉంది
ముగింపు, వంటి సాధారణము.

705
00:28:24,017 --> 00:28:26,100
మరియు స్పష్టముగా, మేము అవసరం లేదు
ఆ చక్రం ఆవిష్కరించుకునే.

706
00:28:26,100 --> 00:28:27,960
ఇక్కడ వెర్షన్ రెండు ఉంది.

707
00:28:27,960 --> 00:28:32,910
మరియు నేను ఏ ఇక్కడ చెప్పడానికి వెళుతున్న ఉంది
బదులుగా లు పోల్చుట, = t సమానం

708
00:28:32,910 --> 00:28:38,964
ఒకవేళ స్ట్రింగ్ నేను బదులుగా, చెప్పడానికి వెళుతున్నాను
లు కామా T పోలిక = 0 సమానం.

709
00:28:38,964 --> 00:28:40,130
ఇప్పుడు, స్ట్రింగ్ ఏమి పోల్చడానికి ఉంది?

710
00:28:40,130 --> 00:28:43,046
>> ఇది ఒక ఫంక్షన్ ఉంది, ఆ బయటకు వస్తాడు
దీని ప్రయోజనం జీవితంలో సి తో వస్తుంది

711
00:28:43,046 --> 00:28:44,650
రెండు రెమ్మలు పోల్చడం.

712
00:28:44,650 --> 00:28:48,300
మేము చదివితే మరియు పోల్చడానికి కదిలించు దాని
మనిషి పేజీ లేదా డాక్యుమెంటేషన్ లేదా CS50

713
00:28:48,300 --> 00:28:50,630
సూచన, అది రెడీ
కేవలం మీరు స్టైర్ చెప్పండి

714
00:28:50,630 --> 00:28:55,730
ప్రతికూల స్థితికి వస్తుంది సరిపోల్చండి
సంఖ్య లేదా ఒక ధనాత్మక సంఖ్యకు లేదా సున్నా

715
00:28:55,730 --> 00:28:57,660
సున్నా అంటే అక్కడ వారు సమాన ఉన్నారు.

716
00:28:57,660 --> 00:28:58,570
>> కాబట్టి కేవలం ప్రతిపాదనను.

717
00:28:58,570 --> 00:29:00,390
ఇది ఏం కావచ్చు
సరిపోల్చండి రాబడి కదిలించు

718
00:29:00,390 --> 00:29:02,110
ప్రతికూల విలువ లేదా సానుకూల విలువ?

719
00:29:02,110 --> 00:29:02,785

720
00:29:02,785 --> 00:29:04,285
ప్రేక్షకులు: కంటే ఎక్కువ లేదా కంటే తక్కువ.

721
00:29:04,285 --> 00:29:05,570
డేవిడ్ J. మలన్: అవును,
కంటే ఎక్కువ లేదా కంటే తక్కువ.

722
00:29:05,570 --> 00:29:08,640
కాబట్టి మీరు ఒక మొత్తం క్రమం కోరుకుంటే
ఒక dictionary-- లో తీగల యొక్క బంచ్

723
00:29:08,640 --> 00:29:12,975
మేము చివరికి road-- డౌన్ రెడీ
పరిపూర్ణ ఫంక్షన్ సమర్థవంతంగా ఉపయోగించడానికి,

724
00:29:12,975 --> 00:29:15,850
అలా వెళుతున్న ఎందుకంటే
మీరు తీగలను పోల్చడం, మరియు చెప్పండి

725
00:29:15,850 --> 00:29:20,060
మీరు ఒక బి ముందు వస్తుంది లేదు, లేదా చేస్తుంది
బి అక్షర ముందు పేర్కొనబడతాయి.

726
00:29:20,060 --> 00:29:21,490
మేము ఖచ్చితంగా ఆ చేయవచ్చు.

727
00:29:21,490 --> 00:29:23,620
>> నేను ఇతర ఒకటి లేదు గమనించండి
ఈ ఉదాహరణలో విషయం.

728
00:29:23,620 --> 00:29:26,870
ఇంకా ఏమి ఎక్కువ మార్చబడింది
ఈ ప్రధాన ఫంక్షన్ లో?

729
00:29:26,870 --> 00:29:28,500

730
00:29:28,500 --> 00:29:29,350
చార్ *.

731
00:29:29,350 --> 00:29:31,150
మరియు ఈ ఇతర తెలుపు అబద్ధం ఉంది.

732
00:29:31,150 --> 00:29:33,750
అన్ని ఈ సమయంలో, మీరు చేసిన
స్ట్రింగ్ వ్రాయడం జరిగింది,

733
00:29:33,750 --> 00:29:38,350
మేము రహస్యంగా మళ్లీ చేశారు
చార్ వంటి స్ట్రింగ్ * కనుక వాస్తవానికి గణగణమని ద్వని చేయు

734
00:29:38,350 --> 00:29:39,270
మీరు అర్థం.

735
00:29:39,270 --> 00:29:42,450
>> ఇతర మాటలలో, CS50.h లో
మరియు మేము చివరికి చూస్తారు,

736
00:29:42,450 --> 00:29:45,950
మేము ఒక పర్యాయపదంగా అని స్ట్రింగ్ చేసింది
ఆ చార్ * అదే విషయం.

737
00:29:45,950 --> 00:29:49,910
ఇప్పుడు కోసం, కేవలం తెలుసు
* ఈ సందర్భంలో, కనీసం,

738
00:29:49,910 --> 00:29:51,286
చిరునామా అర్థం.

739
00:29:51,286 --> 00:29:52,210
>> ఏమి చిరునామా?

740
00:29:52,210 --> 00:29:56,390
వెల్, నేను అన్నాడు ఆ
చార్ *, మరియు * Int లేదా * తేలుతూ కాదు

741
00:29:56,390 --> 00:30:00,820
చార్ * ఉంది అంటే
ఒక చార్ యొక్క చిరునామా.

742
00:30:00,820 --> 00:30:06,770
కాబట్టి ఇక్కడ ఈ చిన్న పెట్టెలో, ఆక
స్ట్రింగ్, నిజంగా రకం చార్ * ఉంది,

743
00:30:06,770 --> 00:30:10,490
ఇది చెప్పడం కేవలం ఒక ఫాన్సీ మార్గం
ఈ బాక్స్ లో ఒక చిరునామా వెళ్తుంది.

744
00:30:10,490 --> 00:30:12,430
మరియు ఆ చిరునామాకు చూడండి లేదు?

745
00:30:12,430 --> 00:30:13,780
స్పష్టంగా, ఒక చార్.

746
00:30:13,780 --> 00:30:16,410
>> కానీ మేము ఖచ్చితంగా జరిగింది
Int * మరియు ఇతర విషయాలు ఉన్నాయి.

747
00:30:16,410 --> 00:30:20,790
కానీ ఇప్పుడు కోసం, చార్ * నిజంగా చాలా ఉంది
ముక్కుసూటి మరియు ఆసక్తి ఒకటి.

748
00:30:20,790 --> 00:30:23,310
కాబట్టి ఈ సమస్య అన్నారు
మళ్ళీ, అయితే, పెరుగుతుంది.

749
00:30:23,310 --> 00:30:24,830
>> నేను ఈ కార్యక్రమం తెరుచుకుంటుంది అనుకుందాం.

750
00:30:24,830 --> 00:30:27,670
ఇప్పుడు మేము అంచనా లేదో యొక్క చూసేలా
ఏమి ఈ కోడ్ తప్పు.

751
00:30:27,670 --> 00:30:31,140
కాబట్టి ఈ ప్రోగ్రామ్ లో, కాపీ 0, నేను రెడీ
ముందుకు వెళ్లి మళ్లీ కాల్ వెళుతున్న

752
00:30:31,140 --> 00:30:34,190
GetString మరియు s విలువ నిల్వ.

753
00:30:34,190 --> 00:30:38,800
>> ఆపై, ఎందుకు నేను ఇలా చేస్తున్నాను
కేవలం వారాల గతం నుండి ఒక రిమైండర్ గా?

754
00:30:38,800 --> 00:30:40,960
మేము ఆ GetString అని పేర్కొన్నారు
కొన్నిసార్లు శూన్య తిరిగి.

755
00:30:40,960 --> 00:30:42,793
ఇది ఏం చేయమంటారు
GetString శూన్య తిరిగి?

756
00:30:42,793 --> 00:30:45,040

757
00:30:45,040 --> 00:30:46,034
ఏదో తప్పు జరిగింది.

758
00:30:46,034 --> 00:30:48,950
ఇది బహుశా స్ట్రింగ్ చాలా ఉంది అంటే
పెద్ద, మెమరీ కంప్యూటర్ యొక్క అవుట్.

759
00:30:48,950 --> 00:30:51,724
ఇది సూపర్, సూపర్, సూపర్ జరుగుతుంది
అరుదుగా, కానీ అది జరిగి.

760
00:30:51,724 --> 00:30:53,890
దాని కోసం మేము చెక్ అనుకుంటున్నారా,
మరియు మేము చేస్తున్న అంతే.

761
00:30:53,890 --> 00:30:57,910
>> మీరు లేకపోతే మేము ఇప్పుడు చూస్తారు ఎందుకంటే
విషయాల కోసం అలవాటుగా తనిఖీ ప్రారంభం

762
00:30:57,910 --> 00:31:00,870
శూన్య వంటి, మీరు వాటిని
వాస్తవానికి వెళ్ళి మొదలు

763
00:31:00,870 --> 00:31:03,106
మెమరీ చిరునామాలను చెల్లుబాటు అని ఉంటాయి.

764
00:31:03,106 --> 00:31:05,980
మరియు మీరు ప్రేరేపించే ఆరంభమవుతుంది చేస్తున్నారు
మరింత సెగ్మెంటేషన్ లోపాలుగా.

765
00:31:05,980 --> 00:31:08,360
లేదా ఒక Mac లేదా PC లో కేవలం
ఒక కంప్యూటర్ దీనివల్ల హేంగ్

766
00:31:08,360 --> 00:31:10,340
లేదా ప్రోగ్రామ్ సమర్థవంతంగా, స్తంభింప చేయడానికి.

767
00:31:10,340 --> 00:31:14,930
>> కాబట్టి ఇప్పుడు, నేను కాపీ 0.c లో క్లెయిమ్ నేను
మార్గం ద్వారా ఈ తీగల కాపీ వెళ్ళిపోతున్నాను

768
00:31:14,930 --> 00:31:15,685
28 తీరతారు.

769
00:31:15,685 --> 00:31:16,850

770
00:31:16,850 --> 00:31:18,750
ఆపై, నేను వెళుతున్నాను
దిగువన దావా

771
00:31:18,750 --> 00:31:21,430
ఇక్కడ నేను వెళుతున్న ఆ
వాటిలో ఒకటి మార్చడానికి.

772
00:31:21,430 --> 00:31:22,330
>> కాబట్టి ఈ గమనిస్తారు.

773
00:31:22,330 --> 00:31:24,370
నేను మా పాత స్నేహితుడు strlen కాల్ చేస్తున్నాను.

774
00:31:24,370 --> 00:31:28,960
మరియు కేవలం ఇంగ్లీష్ లో వివరించేందుకు
ఈ లైన్ 34 ఏమి ఉంది?

775
00:31:28,960 --> 00:31:32,480
ఏం T బ్రాకెట్ 0 చేస్తుంది
ఎడమవైపు సూచిస్తాయి.

776
00:31:32,480 --> 00:31:32,980
అవును.

777
00:31:32,980 --> 00:31:34,339
>> ప్రేక్షకులు: t యొక్క మొదటి పాత్ర?

778
00:31:34,339 --> 00:31:35,880
డేవిడ్ J. మలన్: t యొక్క మొదటి పాత్ర.

779
00:31:35,880 --> 00:31:36,379
అంతే.

780
00:31:36,379 --> 00:31:40,024
T యొక్క మొదటి పాత్ర, నేను కావలసిన
పెద్ద వెర్షన్ పెట్టేందుకు

781
00:31:40,024 --> 00:31:41,190
T లో మొదటి అక్షరం యొక్క.

782
00:31:41,190 --> 00:31:43,200
కాబట్టి ఈ కేంద్రీకరణ ఉంటుంది
మొదటి లేఖ.

783
00:31:43,200 --> 00:31:46,340
ఆపై, ఆఖరి మాట చేయండి
ఈ కార్యక్రమం లో నేను ఇక్కడ క్లైమ్

784
00:31:46,340 --> 00:31:50,340
అసలు, s, మరియు ఇక్కడ కాపీ, t యొక్క.

785
00:31:50,340 --> 00:31:54,610
>> కానీ కథ ఆధారంగా మేము కేవలం
తీగలను నిజంగా ఏమిటో గురించి చెప్పారు

786
00:31:54,610 --> 00:31:57,520
నిజంగా లైన్ 28 ఏమి ఉంది
కలిగెను ఏమిటి

787
00:31:57,520 --> 00:31:59,405
అన్నారు ఫలితంగా బగ్
తెరపై ఉండాలి?

788
00:31:59,405 --> 00:32:01,300

789
00:32:01,300 --> 00:32:03,500
>> కాబట్టి మొదటి, మొదటి ప్రశ్న, 28.

790
00:32:03,500 --> 00:32:09,040
స్ట్రింగ్ t = s నిజంగా ఏం చేస్తోంది?

791
00:32:09,040 --> 00:32:16,430
మేము ఎడమ వైపు ఉంటే
ఇక్కడ వైపున స్ట్రింగ్ t = ఏమిటి;

792
00:32:16,430 --> 00:32:19,400
నాకు ఒక బాక్స్ ఇస్తుంది
ఇక్కడ మరియు ఒక బాక్స్ ఇక్కడ.

793
00:32:19,400 --> 00:32:25,530
మరియు, ఈ చిరునామా 0x అనుకుందాం
యొక్క కక్ష్య, ఈ సమయంలో, చెప్పడానికి 50 తెలియజేయండి.

794
00:32:25,530 --> 00:32:28,847
ఏం స్ట్రింగ్ t = s చేస్తుంది
హుడ్ కింద ఏమి?

795
00:32:28,847 --> 00:32:30,340
>> ప్రేక్షకులు: [వినబడని]

796
00:32:30,340 --> 00:32:34,100
>> డేవిడ్ J. మలన్: ఇది మెమరీ నిల్వ
అక్కడ పరిష్కరించేందుకు, కాబట్టి 0x50 అక్కడ వెళ్తాడు.

797
00:32:34,100 --> 00:32:37,980
ఇప్పుడు చేస్తే, నేను మొదటి వెళ్ళండి
T లో పాత్ర మరియు అప్పర్కేస్,

798
00:32:37,980 --> 00:32:39,535
నేను సమర్థవంతంగా s కు ఏమి చేస్తున్నాను?

799
00:32:39,535 --> 00:32:41,300

800
00:32:41,300 --> 00:32:43,450
నేను నిజంగా కుడి, అదే పనిని చేస్తున్నాను?

801
00:32:43,450 --> 00:32:47,680
ఎందుకంటే, చిరునామా 0x50-- మరియు కేవలం నేను
బోర్డు మీద ఇక్కడ తావు లేదు,

802
00:32:47,680 --> 00:32:51,750
కానీ, ఈ ఇక్కడ డౌన్ 0x50 భావిస్తాయి
నా కంప్యూటర్ యొక్క మెమరీ లో ఎక్కడో.

803
00:32:51,750 --> 00:32:55,825
>> నేను, ఉదాహరణకు, గాబే చేశారు
ఈ వంటి, ఇక్కడ చిన్న లో.

804
00:32:55,825 --> 00:32:57,120

805
00:32:57,120 --> 00:33:01,980
మరియు నేను చెప్పారు T బ్రాకెట్
0 పెట్టుబడిగా కావాలి.

806
00:33:01,980 --> 00:33:04,860
వెల్, T బ్రాకెట్ 0
T లో మొదటి అక్షరం.

807
00:33:04,860 --> 00:33:07,840
కాబట్టి చిన్న g అన్నారు
మారింది పెద్ద జి కానీ సమస్య

808
00:33:07,840 --> 00:33:09,410
ఏమి కూడా పాయింట్ ఉంది?

809
00:33:09,410 --> 00:33:10,300
>> ప్రేక్షకులు: అదే.

810
00:33:10,300 --> 00:33:11,841
>> డేవిడ్ J. మలన్: అదే ఖచ్చితమైన విషయం.

811
00:33:11,841 --> 00:33:16,342
కాబట్టి బహుశా ఒక సాధారణ వివరణ,
సింటాక్స్ ఒక చిన్న అసహజ పోయినప్పటికీ.

812
00:33:16,342 --> 00:33:17,050
కాబట్టి దీన్ని చూద్దాం.

813
00:33:17,050 --> 00:33:20,210
./copy-0 అప్పుడు కాపీని-0 చేయండి మరియు.

814
00:33:20,210 --> 00:33:21,820

815
00:33:21,820 --> 00:33:24,110
ఏదో సే: గాబే.

816
00:33:24,110 --> 00:33:26,760
మరియు దురదృష్టవశాత్తు, రెండు
వాటిని ఇప్పుడు పెట్టుబడిగా చేశారు

817
00:33:26,760 --> 00:33:29,500
కానీ ఆ కోసం అంతర్లీన
మేము కేవలం అని కారణం

818
00:33:29,500 --> 00:33:32,350
ఇప్పుడు చిరునామాలను వ్యవహరించే.

819
00:33:32,350 --> 00:33:36,470
>> కాబట్టి మేము ఎలా ప్రారంభం చెయ్యాలి
చిరునామాతో ఏ పన్ intended--

820
00:33:36,470 --> 00:33:39,270
మేము చిరునామా ప్రారంభించారు ఎలా
ఈ ప్రత్యేక సమస్య?

821
00:33:39,270 --> 00:33:44,400
వెల్, copy1.c, విషయాలు వెళ్తున్నారు
కొద్దిగా మరింత క్లిష్టంగా పొందుటకు.

822
00:33:44,400 --> 00:33:49,310
కానీ నేను ఒక దావా
సంభావితంగా సాధారణ పరిష్కారం.

823
00:33:49,310 --> 00:33:50,852
>> మొదటి చూపులో పొందుటకు కాబట్టి హార్డ్.

824
00:33:50,852 --> 00:33:53,560
మొదటి కోసం సులభం మాత్రం కాదు
సమయం మీరు, బహుశా, దాన్ని టైప్

825
00:33:53,560 --> 00:33:57,440
కానీ సమస్య ఉంటే
కేవలం T = లు కేవలం చేయడం

826
00:33:57,440 --> 00:33:59,694
కాపీలు చిరునామా, ఏమిటి,
మళ్ళీ నేను మీరు ఎంచుకోవచ్చు ఉంటే,

827
00:33:59,694 --> 00:34:02,110
పరిష్కారం అవతరిస్తుంది
నిజానికి ఒక స్ట్రింగ్ కాపీ కోసం?

828
00:34:02,110 --> 00:34:04,906

829
00:34:04,906 --> 00:34:06,770
>> ప్రేక్షకులు: మేము బహుశా చేస్తాము
మళ్ళీ ఒక లూప్ ఉపయోగించడానికి.

830
00:34:06,770 --> 00:34:06,890
>> డేవిడ్ J. మలన్: అవును.

831
00:34:06,890 --> 00:34:08,390
కాబట్టి మేము మళ్ళీ ఒక లూప్ అవసరం చూడాలని.

832
00:34:08,390 --> 00:34:11,800
మరియు మేము కాపీ అనుకుంటే ఎందుకంటే
మరొక స్ట్రింగ్ ఒక స్ట్రింగ్ s,

833
00:34:11,800 --> 00:34:14,120
మేము బహుశా దీన్ని చేయాలనుకుంటున్నారా
పాత్ర పాత్ర.

834
00:34:14,120 --> 00:34:17,199
కానీ సమస్య ఉంటే,
ఈ నిజానికి s ఉంది

835
00:34:17,199 --> 00:34:22,159
ఇప్పుడు మనం స్పష్టంగా ప్రారంభించడానికి అవసరం
T మెమరీ పెడుతోంది.

836
00:34:22,159 --> 00:34:24,320
>> ఇతర మాటలలో, లెట్స్
ఈ చివరిసారిగా పునర్.

837
00:34:24,320 --> 00:34:28,659
ఈ స్ట్రింగ్ s = GetString ఉంటే.

838
00:34:28,659 --> 00:34:30,956

839
00:34:30,956 --> 00:34:32,455
మరియు అలాగే, ఇక్కడ ఈ అప్ చాలు తెలపండి.

840
00:34:32,455 --> 00:34:36,639

841
00:34:36,639 --> 00:34:37,420
ఈ GetString ఉంది.

842
00:34:37,420 --> 00:34:39,070

843
00:34:39,070 --> 00:34:43,860
ఏదో ఆపై, చిత్రాన్ని
ఆ వంటి అని ముందు అన్నారు,

844
00:34:43,860 --> 00:34:44,360
G-a-b-ఇ / 0.

845
00:34:44,360 --> 00:34:47,294

846
00:34:47,294 --> 00:34:48,960
ఈ వంటి కొంత కనిపిస్తోంది.

847
00:34:48,960 --> 00:34:53,650
మరియు s అందువలన, మేము ఈ 0x50 కాల్
మరియు ఆ 51, 52 చేస్తాడు.

848
00:34:53,650 --> 00:34:54,409
>> కాబట్టి ఈ 0x50 ఉంది.

849
00:34:54,409 --> 00:34:55,679

850
00:34:55,679 --> 00:34:59,690
ఆపై, నేను స్ట్రింగ్ t చేయండి.

851
00:34:59,690 --> 00:35:02,450
మెమరీ, కేవలం జరగబోతోంది
నాకు ఈ వంటి చిన్న చదరపు ఇస్తాయి.

852
00:35:02,450 --> 00:35:04,080
కాబట్టి కీలక దశ ఇప్పుడు ఏమిటి?

853
00:35:04,080 --> 00:35:09,870
నేను t లోకి లు కాపీ అనుకుంటే, ఏమి
ఖాళీ మేము ఇక్కడ పూరించడానికి అవసరం?

854
00:35:09,870 --> 00:35:12,050
లేదా మేము ఏమి చేయాలి
అధిక స్థాయిలో లేదు?

855
00:35:12,050 --> 00:35:14,101

856
00:35:14,101 --> 00:35:14,600
అవును?

857
00:35:14,600 --> 00:35:16,200

858
00:35:16,200 --> 00:35:17,020
ఎవరో?

859
00:35:17,020 --> 00:35:17,690
అవును.

860
00:35:17,690 --> 00:35:19,214
>> ప్రేక్షకులు: మేము [వినబడని] అవసరం.

861
00:35:19,214 --> 00:35:21,380
డేవిడ్ J. మలన్: అవును, మేము
ఈ ఖాళీ పూరించడానికి అవసరం.

862
00:35:21,380 --> 00:35:24,340
నేను కాపీ మరియు కాదు
గాబే యొక్క పేరు చూపడంలో

863
00:35:24,340 --> 00:35:28,120
నేను ఆపరేటింగ్ సిస్టమ్ అడగండి వరకు
మెమరీ మరొక భాగం కోసం

864
00:35:28,120 --> 00:35:30,640
అసలు కనీసం పెద్దది.

865
00:35:30,640 --> 00:35:32,130
కాబట్టి ఒక ప్రశ్న తో వెళ్లిపోతాడు.

866
00:35:32,130 --> 00:35:36,080
>> నేను ఆపరేటింగ్ సిస్టమ్ కాదు అడుగుతారు చెయ్యాలి ఎలా
కేవలం ఒక సాధారణ చిన్న పాయింటర్ కోసం

867
00:35:36,080 --> 00:35:38,530
ఈ పిలవబడే ఒక
చిరునామా, ఒక పాయింటర్ కాదు

868
00:35:38,530 --> 00:35:40,980
ఒక సాధారణ చిన్న బాక్స్
ఈ వంటి ఒక స్ట్రింగ్ అనే?

869
00:35:40,980 --> 00:35:44,200
ఎలా నేను ఆపరేటింగ్ అడగండి లేదు
మెమరీ యొక్క ఒక పెద్ద భాగం కోసం సిస్టమ్?

870
00:35:44,200 --> 00:35:48,430
ఇంతవరకు, నేను మాత్రమే తిరిగి సంపాదించిన చేసిన
పరోక్షంగా GetString కాల్.

871
00:35:48,430 --> 00:35:50,740
సో ఎలా GetString ఉంది
దాని మెమరీ పొందడం కూడా?

872
00:35:50,740 --> 00:35:53,430
>> సరే, అక్కడ ఉండే అవుతుంది
ఇక్కడ ఈ ఇతర ఫంక్షన్

873
00:35:53,430 --> 00:35:55,160
మేము ఇప్పుడు ఉపయోగించడానికి మొదలు పెడతారేమో.

874
00:35:55,160 --> 00:35:59,780
ఇప్పుడు, ఈ విధంగా మరింత గుప్తమైన than-- కనిపిస్తోంది
మరియు నేను దాన్ని చూడగలరు ఒక్కడినే

875
00:35:59,780 --> 00:36:03,150
ఈ లైన్ మార్గం మరింత గుప్తమైన కనిపిస్తోంది
అప్పుడు మొదటి చూపులో తప్పక.

876
00:36:03,150 --> 00:36:04,650
కానీ అది వేరుగా బాధించటం తెలియజేయండి.

877
00:36:04,650 --> 00:36:07,950
>> ఎడమ చేతి వైపు, నేను చార్ * t చేశారు.

878
00:36:07,950 --> 00:36:13,280
ఇంగ్లీష్ లో కాబట్టి, యొక్క సూత్రీకరించి ప్రారంభిద్దాం
సాంకేతిక పరిభాషలో సరైన వాక్యాలు.

879
00:36:13,280 --> 00:36:19,757
కాబట్టి ఈ పెడుతోంది ఒక
రకం చార్ వేరియబుల్ T అనే *.

880
00:36:19,757 --> 00:36:21,090
ఇప్పుడు, ఆ నిజంగా అర్థం ఏమిటి?

881
00:36:21,090 --> 00:36:23,881
>> సరే, అర్థం, నేను ఏమి వెళ్తున్నాను
T అనే ఈ వేరియబుల్ ఉంచాలి?

882
00:36:23,881 --> 00:36:24,780

883
00:36:24,780 --> 00:36:26,402
ఒక చార్ యొక్క ఒక చిరునామా.

884
00:36:26,402 --> 00:36:28,360
కాబట్టి ఆ, కేవలం సరళంగా వార్తలు
మరింత సహేతుకమైన మార్గం

885
00:36:28,360 --> 00:36:29,930
ఎడమచేతి వైపు అభివర్ణించాడు.

886
00:36:29,930 --> 00:36:32,890
కాబట్టి ఇక్కడ మాత్రమే ఈ బాక్స్ సృష్టిస్తుంది.

887
00:36:32,890 --> 00:36:34,760
సో కుడి చేతి వైపు,
బహుశా, వెళ్ళి

888
00:36:34,760 --> 00:36:37,170
పెద్ద అని కేటాయించే
మెమరీ ఎలా భాగం?

889
00:36:37,170 --> 00:36:38,340
కాబట్టి యొక్క ఈ వేరుగా బాధించటం తెలియజేయండి.

890
00:36:38,340 --> 00:36:41,131
>> ఇది మొదటి చూపులో అఖండమైన ఉంది
కానీ ఇక్కడ లోపల ఏం జరగబోతోంది?

891
00:36:41,131 --> 00:36:43,740
మొదటి, malloc, ఉంది దీనిలో
మా కొత్త స్నేహితుడు, స్పష్టంగా ఉంది

892
00:36:43,740 --> 00:36:45,450
"మెమరీని కేటాయించాల్సిన."

893
00:36:45,450 --> 00:36:49,560
కాబట్టి ఈ జారీ చేస్తున్నారు వాదన ఉంది
అది లోకి, కాబట్టి అది ఒక అందమైన పెద్ద వాదన.

894
00:36:49,560 --> 00:36:50,970
కాబట్టి యొక్క ఈ వేరుగా బాధించటం తెలియజేయండి.

895
00:36:50,970 --> 00:36:53,410
>> S యొక్క strlen, వాస్తవానికి, సూచిస్తుంది వాట్

896
00:36:53,410 --> 00:36:54,142

897
00:36:54,142 --> 00:36:55,600
ప్రేక్షకులు: అక్షరాలు సంఖ్య.

898
00:36:55,600 --> 00:36:56,710
డేవిడ్ J. మలన్: జస్ట్
లు పాత్రలు సంఖ్య.

899
00:36:56,710 --> 00:36:59,040
కాబట్టి s యొక్క పొడవు, అసలు స్ట్రింగ్.

900
00:36:59,040 --> 00:37:00,350
కాబట్టి G-a-b-ఇ.

901
00:37:00,350 --> 00:37:02,320
కనుక ఇది బహుశా నాలుగు ఈ సందర్భంలో వార్తలు.

902
00:37:02,320 --> 00:37:05,485
ఎందుకు నేను తరువాత +1 చేస్తున్న
S యొక్క strlen కాల్?

903
00:37:05,485 --> 00:37:06,360
ప్రేక్షకులు: [వినబడని]

904
00:37:06,360 --> 00:37:07,590
డేవిడ్ J. మలన్: ఆ కోసం
ప్రత్యేక శూన్య పాత్ర.

905
00:37:07,590 --> 00:37:11,260
మీరు నాకు చెప్పండి ఉంటే పొడవు ఉంది ఏమి
గాబే యొక్క పేరు, నేను నాలుగు చెప్పటానికి వెళ్ళిపోతున్నాను.

906
00:37:11,260 --> 00:37:14,480
హుడ్ కింద, అయితే, నేను అవసరం
శూన్య పాత్ర కోసం ఐదో బైట్.

907
00:37:14,480 --> 00:37:16,100
I +1 చేయడం నేను ఎందుకు కాబట్టి ఆ.

908
00:37:16,100 --> 00:37:21,730
>> ఇప్పుడు కేవలం సందర్భంలో మీరు ఈ నడుస్తున్నాయి
కాకుండా వేరే కంప్యూటర్లో ప్రోగ్రాం సే,

909
00:37:21,730 --> 00:37:24,610
CS50 ఉపకరణం,
ఇక్కడ ఒక చార్ యొక్క పరిమాణం

910
00:37:24,610 --> 00:37:26,350
వివిధ కావచ్చు
నా సొంత కంప్యూటర్ నుండి

911
00:37:26,350 --> 00:37:30,590
నేను ఈ కాల్ చేసుకోవచ్చు అవుతుంది
ఆపరేటర్లు sizeof, కేవలం కంప్యూటర్ అడగండి

912
00:37:30,590 --> 00:37:32,870
ఒక యొక్క పరిమాణం ఏమిటి
ఈ కంప్యూటర్లో చార్?

913
00:37:32,870 --> 00:37:37,400
>> మరియు ఈ ఐదుగురు గుణించడం ద్వారా
ఒక చార్ యొక్క పరిమాణం, ఉదాహరణకి ఇది

914
00:37:37,400 --> 00:37:40,440
చాలా కంప్యూటర్లలో రెడీ
కేవలం ఒకటి, malloc ఉంటుంది

915
00:37:40,440 --> 00:37:44,830
నాకు ఈ పెద్ద కోసం కేటాయించాలని అన్నారు
ఇక్కడ కుడివైపు పైగా మెమరీ భాగం.

916
00:37:44,830 --> 00:37:47,140
మరియు అది తిరిగి జరగబోతోంది
కాబట్టి ఇది అది ఒక ఫంక్షన్ ఉంది

917
00:37:47,140 --> 00:37:48,265
ఏమిటో నాకు తిరిగి వెళుతున్న?

918
00:37:48,265 --> 00:37:50,914

919
00:37:50,914 --> 00:37:51,830
ప్రేక్షకులు: చిరునామాను?

920
00:37:51,830 --> 00:37:53,709
డేవిడ్ J. మలన్: ఏమి చిరునామా?

921
00:37:53,709 --> 00:37:55,250
ప్రేక్షకులు: మెమరీ ఇది కేటాయించింది?

922
00:37:55,250 --> 00:37:56,450
డేవిడ్ J. మలన్: ది
మెమరీ అది కేటాయించింది.

923
00:37:56,450 --> 00:37:59,189
కాబట్టి నేను, స్పష్టముగా, ఏ ఆలోచన కలిగి
ఇక్కడ ఈ అప్ ముగుస్తుంది అన్నారు.

924
00:37:59,189 --> 00:38:01,480
నేను ప్రతిపాదించారు వెళుతున్న
ఇది 0x88 వద్ద ముగుస్తుంది జరగబోతోంది.

925
00:38:01,480 --> 00:38:02,770

926
00:38:02,770 --> 00:38:06,009
పూర్తిగా ఏకపక్షంగా, కానీ
0x50 కంటే ఇతర ఎక్కడో,

927
00:38:06,009 --> 00:38:08,800
ఆపరేటింగ్ సిస్టమ్ ఎందుకంటే, ఏమి
Windows మరియు Mac OS నన్ను ఇలా, ఉంది

928
00:38:08,800 --> 00:38:11,230
ఇది ఇచ్చి చేసే నిర్ధారించుకోండి
నాకు RAM వివిధ భాగాలుగా.

929
00:38:11,230 --> 00:38:14,210
>> కాబట్టి ఈ విలువ ఎక్కడ ఈ
మెమరీ భాగం ముగుస్తుంది ఉండవచ్చు.

930
00:38:14,210 --> 00:38:16,060
కాబట్టి ఈ 0x88, ఇక్కడ ముగుస్తుంది ఏమిటి.

931
00:38:16,060 --> 00:38:17,480

932
00:38:17,480 --> 00:38:21,570
కాబట్టి ఇప్పుడు స్పష్టంగా, నేను అర్థం చేసుకోవచ్చు
ఈ అదే కాదు,

933
00:38:21,570 --> 00:38:23,960
వారు సూచించే ఉన్నందున
మెమరీ వివిధ భాగాలుగా.

934
00:38:23,960 --> 00:38:29,980
నేను ఇప్పుడు వాస్తవానికి ఈ కాపీ అనుకుంటే కాబట్టి
, యొక్క మీ ప్రతిపాదిత పరిష్కారం తెలియజేసేలా.

935
00:38:29,980 --> 00:38:36,870
>> , యొక్క కేవలం వెళ్ళి లూప్ ఒక సృష్టించడానికి లెట్
మరియు t బ్రాకెట్ చేయండి నేను s బ్రాకెట్ నేను పొందుతాడు.

936
00:38:36,870 --> 00:38:39,760
ఇప్పుడు నేను ఉపయోగించవచ్చు ఎందుకంటే
ఈ శ్రేణి వంటి సంజ్ఞామానం

937
00:38:39,760 --> 00:38:43,390
ఎందుకంటే అయినప్పటికీ, malloc చాలా
సామాన్యముగా నాకు మెమరీ కేటాయించుకునే,

938
00:38:43,390 --> 00:38:45,290
మెమరీ కేవలం ఆనుకొని బైట్లు.

939
00:38:45,290 --> 00:38:47,240
బైట్, బైట్, బైట్, తిరిగి తిరిగి వెనుకకు.

940
00:38:47,240 --> 00:38:50,030
>> నేను ఒక ప్రోగ్రామర్ గా తప్పనిసరిగా చెయ్యవచ్చు
వ్యూహం గా చికిత్స ఇది

941
00:38:50,030 --> 00:38:55,090
నేను ఈ చివరకు తెలిసిన ఉపయోగించవచ్చు అర్థం
కొన్ని చదరపు బ్రాకెట్లలో నొటేషన్.

942
00:38:55,090 --> 00:38:56,462

943
00:38:56,462 --> 00:39:00,020
>> నాలో, ఎందుకంటే అక్కడ విరామం తెలియజేయండి
ఈ కూడా, ఒకేసారి చాలా ఉంది

944
00:39:00,020 --> 00:39:03,530
ప్రాథమిక ఆలోచన రీక్యాప్ అయితే
తీగ ఉంది, ఈ సమయంలో,

945
00:39:03,530 --> 00:39:05,550
ఒక కొత్త డేటా రకం కేవలంగా కాదు.

946
00:39:05,550 --> 00:39:10,150
ఇది కేవలం ఒక అని పిలవబడే పాయింటర్
ఒక పాత్ర యొక్క చిరునామా,

947
00:39:10,150 --> 00:39:12,650
ఇది కేవలం అనగా ఒక సంఖ్య
మానవ కన్వెన్షన్ ద్వారా

948
00:39:12,650 --> 00:39:15,350
మేము 0x ఏదో రాయడానికి ఉంటాయి.

949
00:39:15,350 --> 00:39:18,590
>> కానీ అది కేవలం ఒక సంఖ్య
33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వంటి,

950
00:39:18,590 --> 00:39:20,530
ఇది నిర్మాణము
CS భవనం యొక్క చిరునామా.

951
00:39:20,530 --> 00:39:22,000

952
00:39:22,000 --> 00:39:23,545
ఈ వివరాలను ఏదైనా ప్రశ్నలు?

953
00:39:23,545 --> 00:39:24,790

954
00:39:24,790 --> 00:39:25,289
అవును?

955
00:39:25,289 --> 00:39:28,530
>> ప్రేక్షకులు: ఎందుకు మేము తనిఖీ చేయండి
సమాన T కోసం శూన్యం?

956
00:39:28,530 --> 00:39:30,740
>> డేవిడ్ J. మలన్: మేము ఎందుకు చేయండి
శూన్యం సమానంగా T తనిఖీ?

957
00:39:30,740 --> 00:39:33,250
మేము documentation-- చదివితే
malloc కోసం గొప్ప question--,

958
00:39:33,250 --> 00:39:37,020
ఇది ఫైన్ ప్రింట్ లో చెప్పడానికి జరగబోతోంది
కొన్నిసార్లు, malloc శూన్య తిరిగి ఉండవచ్చు

959
00:39:37,020 --> 00:39:38,080
కేవలం GetString వంటి.

960
00:39:38,080 --> 00:39:41,820
నిజానికి, GetString శూన్య తిరిగి
, క్రమంగా, malloc శూన్య తిరిగి ఉంటే,

961
00:39:41,820 --> 00:39:43,130
GetString malloc ఉపయోగించే ఎందుకంటే.

962
00:39:43,130 --> 00:39:46,400
>> OS ఉంటే ఆ జరిగే ఉండవచ్చు
Mac OS, Windows, సంసార, కేవలం ఉంది

963
00:39:46,400 --> 00:39:48,130
మీరు మెమరీని ఔట్.

964
00:39:48,130 --> 00:39:49,820
కాబట్టి ఆ అక్కడ జరిగిన ఏమిటి.

965
00:39:49,820 --> 00:39:52,910
>> నాకు ఒక విషయం ఇతర బహిర్గతం వీలు
కేవలం మీ మనసును రగిలించు ఉండవచ్చు

966
00:39:52,910 --> 00:39:55,100
లేదా పూర్తిగా చాలా దూరం లైన్పై ఉంటుంది.

967
00:39:55,100 --> 00:39:59,770
కానీ నాకు పుల్ అప్ తెలియజేయండి
కాపీ లూప్ అదే,

968
00:39:59,770 --> 00:40:05,480
ఇది ఒక క్షణం క్రితం, రీకాల్ ఉంది
ఈ. T బ్రాకెట్ నేను s బ్రాకెట్ నేను పొందుతాడు.

969
00:40:05,480 --> 00:40:06,740
>> నైస్ మరియు యూజర్ ఫ్రెండ్లీ.

970
00:40:06,740 --> 00:40:09,330
మళ్ళీ వీక్ రెండు అనుకుని.

971
00:40:09,330 --> 00:40:14,920
కానీ ఈ వెర్షన్ నిజానికి ఉంటుంది
గుప్తమైన కనిపిస్తోంది ఈ, రాసి.

972
00:40:14,920 --> 00:40:18,280
ఇది ఒక టెక్నిక్ అని పాయింటర్
అంక, చిరునామా అంకగణితం.

973
00:40:18,280 --> 00:40:19,600
కానీ ఎందుకు ఈ పని చేస్తుంది?

974
00:40:19,600 --> 00:40:22,220
>> ఇప్పుడు annoyingly,
సి రచయితలు ఉపయోగించడానికి నిర్ణయించుకుంది

975
00:40:22,220 --> 00:40:25,070
వివిధ ప్రయోజనాల కోసం * సంకేతం.

976
00:40:25,070 --> 00:40:29,020
మేము, అది ఇప్పటికే ఒకసారి ఉపయోగించిన చూసిన
అంటే చార్ *, "నాకు ఒక వేరియబుల్ ఇవ్వాలని

977
00:40:29,020 --> 00:40:31,210
ఆ కలిగి జరగబోతోంది
ఒక చార్ యొక్క చిరునామా. "

978
00:40:31,210 --> 00:40:33,990
ఆ సందర్భంలో కాబట్టి చార్ *
"నాకు ఒక వేరియబుల్ ఇస్తాయి." అంటే

979
00:40:33,990 --> 00:40:40,050
>> దురదృష్టవశాత్తు, మీరు * లేకుండా ఉపయోగిస్తే
అది ముందు ఒక పదం, చార్ వంటి,

980
00:40:40,050 --> 00:40:41,905
అది ఇప్పుడు అని
dereference ఆపరేటర్లు.

981
00:40:41,905 --> 00:40:43,530
మరియు మేము దీర్ఘ ముందు ఈ మరింత చూస్తారు.

982
00:40:43,530 --> 00:40:44,930
కానీ అది కేవలం "అక్కడ వెళ్ళండి." అంటే

983
00:40:44,930 --> 00:40:49,070
ఎవరైనా నాకు అప్పగించారు ఇది చెప్పడం వంటిది
కాగితం ముక్క మీద "33 ఆక్స్ఫోర్డ్ స్ట్రీట్,"

984
00:40:49,070 --> 00:40:53,830
నేను "* 33 ఆక్స్ఫోర్డ్ స్ట్రీట్," అలా చేస్తే అర్థం
"CS భవనం వీధిలోనే వెళ్ళండి."

985
00:40:53,830 --> 00:40:57,220
>> కాబట్టి * అక్కడే ఉంటే వెళ్ళడానికి అంటే
అది ముందు ఏ పదం ఉంది.

986
00:40:57,220 --> 00:40:59,100
కాబట్టి ప్రశాంతంగా ఉంటుంది, t ఏమిటి?

987
00:40:59,100 --> 00:41:03,250
t యొక్క భాగం యొక్క చిరునామా
నాకు తిరిగి ఇవ్వబడింది మెమరీ.

988
00:41:03,250 --> 00:41:06,650
లు స్పష్టతను ఏమి యొక్క చిరునామా
ఉదాహరణకు మనం చర్చిస్తున్న చేసిన,

989
00:41:06,650 --> 00:41:07,500
చిన్న గాబే యొక్క?

990
00:41:07,500 --> 00:41:08,990

991
00:41:08,990 --> 00:41:10,005
యొక్క చిరునామా of--

992
00:41:10,005 --> 00:41:11,585

993
00:41:11,585 --> 00:41:12,460
ప్రేక్షకులు: స్ట్రింగ్.

994
00:41:12,460 --> 00:41:14,126
డేవిడ్ J. మలన్: గాబే యొక్క అసలు పేరు.

995
00:41:14,126 --> 00:41:16,660
కనుక ఇది యొక్క చిరునామా వార్తలు
మెమొరీ ఈ భాగం.

996
00:41:16,660 --> 00:41:22,220
కాబట్టి నేను చెప్పుకోవాలంటే టి + ఐ కెన్ ఐ, నోటీసు,
కేవలం మా పాత స్నేహితుడు.

997
00:41:22,220 --> 00:41:24,770
ఇది కేవలం ఒక ఇండెక్స్ వేరియబుల్ వార్తలు
ఆ మీద సున్నా నుండి iterating

998
00:41:24,770 --> 00:41:26,960
స్ట్రింగ్ s యొక్క పొడవు.

999
00:41:26,960 --> 00:41:30,367
కాబట్టి అది అప్పుడు సున్నా, ఒకటి చేస్తాడు
రెండు, మూడు, నాలుగు.

1000
00:41:30,367 --> 00:41:33,200
కాబట్టి యొక్క ఈ కొత్త సిద్ధం తెలియజేయండి
స్క్రాచ్ వంటి పజిల్ ముక్కలు, మీరు రెడీ ఉంటే,

1001
00:41:33,200 --> 00:41:36,140
అయినప్పటికీ, మళ్లీ, వాక్యనిర్మాణం
స్క్రాచ్ కంటే మరింత రహస్య ఉంది.

1002
00:41:36,140 --> 00:41:39,522
కాబట్టి T ఒక చిరునామా ఉంది +
నేను నాకు ఇవ్వాలని అన్నారు

1003
00:41:39,522 --> 00:41:42,480
ఒక సంఖ్య, ఈ ఎందుకంటే అన్ని ఉన్నాయి
మేము హెక్స్ గీయడం చేసిన సంఖ్యలు.

1004
00:41:42,480 --> 00:41:43,560
కానీ వారు కేవలం సంఖ్యలు ఉన్నారు.

1005
00:41:43,560 --> 00:41:49,960
>> T యొక్క చిరునామా మేము చెప్పారు చేస్తే
ఉంది 0x88, 0x88 ప్లస్ సున్నా ఏమిటి.

1006
00:41:49,960 --> 00:41:51,564

1007
00:41:51,564 --> 00:41:53,980
మీరు సౌకర్యవంతమైన లేదు కూడా ఉంటే
ఇంకా హెక్స్ తో, ఒక అంచనా పడుతుంది.

1008
00:41:53,980 --> 00:41:54,410
>> ప్రేక్షకులు: అసలు.

1009
00:41:54,410 --> 00:41:55,850
>> డేవిడ్ J. మలన్: 0x88 స్టిల్.

1010
00:41:55,850 --> 00:41:58,910
కాబట్టి * ఏమి అర్థం 0x88 లేదు?

1011
00:41:58,910 --> 00:42:02,670
ఇది అంటే "అక్కడ వెళ్ళి" అంటే
సమర్థవంతంగా, "ఇక్కడ మీ వేలు ఉంచండి."

1012
00:42:02,670 --> 00:42:06,930
ఇప్పుడు కుడి వైపు
ఈ వ్యక్తీకరణ * ఆపై parens లో,

1013
00:42:06,930 --> 00:42:11,586
నేను చేస్తున్న, ఇది అర్థం +
ఇక్కడ చిన్న g అప్ పరిష్కరించడానికి.

1014
00:42:11,586 --> 00:42:16,220
s +0, కోర్సు యొక్క, ఉంది ఏ s, s.

1015
00:42:16,220 --> 00:42:21,230
>> కాబట్టి ఇప్పుడు, అది * లు, ఇందులో కేవలం * 33 వంటి
ఆక్స్ఫోర్డ్ స్ట్రీట్ చిరునామా వెళ్ళండి అర్థం

1016
00:42:21,230 --> 00:42:22,010
లు.

1017
00:42:22,010 --> 00:42:24,170
కాబట్టి ఇక్కడ ఈ వేలు, కుడి చేతి.

1018
00:42:24,170 --> 00:42:26,050
సో నేను ఏమి లోకి కాపీ వెళ్తున్నాను?

1019
00:42:26,050 --> 00:42:30,260
ఇది కుడి విషయం,
గాబే, ఇక్కడ లోకి ఇక్కడ చిన్న g.

1020
00:42:30,260 --> 00:42:32,750
>> ఆ కాబట్టి ప్రభావం
లూప్ యొక్క మొదటి మళ్ళా,

1021
00:42:32,750 --> 00:42:36,200
మీరు కనిపిస్తోంది అయినప్పటికీ, ప్రతిపాదించిన
అన్నింటికన్నా క్రేజీ మరింత క్లిష్టంగా

1022
00:42:36,200 --> 00:42:42,110
మేము ముందు చూసిన కేవలం చెబుతున్నారు
ఇక్కడ వెళ్లి ఇక్కడ ఆ పాత్ర కాపీ.

1023
00:42:42,110 --> 00:42:44,700
ఇది మీరు రెండు స్థానాలను ఒక మ్యాప్ ఇవ్వడం.

1024
00:42:44,700 --> 00:42:46,130
>> మేము ఈ చాలా చూస్తారు.

1025
00:42:46,130 --> 00:42:50,600
కానీ ఇప్పుడు కోసం, ఆశ కేవలం ఉంది
ఈ ప్రాథమిక ఆలోచనలు కొన్ని పరిచయం.

1026
00:42:50,600 --> 00:42:53,550
నిజానికి, చూద్దాం
ఇక్కడ ఒక చివరి కార్యక్రమం,

1027
00:42:53,550 --> 00:42:57,480
ఆపై వాగ్దానం క్లేమాషన్గా,
ఇది ప్రతిదీ అన్ని కుడి చేస్తుంది.

1028
00:42:57,480 --> 00:42:57,980
అన్ని కుడి.

1029
00:42:57,980 --> 00:43:01,680
కాబట్టి నాకు అక్కడ మేము వెళ్ళి up-- తెరిచి తెలియజేయండి.

1030
00:43:01,680 --> 00:43:02,850

1031
00:43:02,850 --> 00:43:05,440
మేము తిరిగి వచ్చి చేస్తాము నాకు సో తెలియజేయండి
దీర్ఘ ముందు ఈ చిత్రానికి.

1032
00:43:05,440 --> 00:43:08,360
నాకు ఇక్కడ ఈ చివరి ఉదాహరణ ప్రారంభం లెట్.

1033
00:43:08,360 --> 00:43:09,440

1034
00:43:09,440 --> 00:43:12,710
>> కాబట్టి ఇక్కడ ఒక సూపర్, సూపర్ ఉంది
నెరవేరుస్తుంది కార్యక్రమం

1035
00:43:12,710 --> 00:43:15,050
కింది చేసే జీవితంలో ఏదీ.

1036
00:43:15,050 --> 00:43:18,740
ఇది మొదటి రెండు వేరియబుల్స్ x ప్రకటించాడు
మరియు ఈ సమయంలో సంఖ్యలు లేని Y,

1037
00:43:18,740 --> 00:43:19,240
కేవలంగా.

1038
00:43:19,240 --> 00:43:20,448
వారు కేవలంగా, పూర్ణ లేదు.

1039
00:43:20,448 --> 00:43:22,899
వారు * స్పష్టంగా Int.

1040
00:43:22,899 --> 00:43:25,690
కాబట్టి కేవలం ఎవరైనా, అది అర్థం ఏమిటి
మీ డేటా రకం ఉంటే, మీ వేరియబుల్,

1041
00:43:25,690 --> 00:43:26,860
రకం Int * తార ఉంది?

1042
00:43:26,860 --> 00:43:30,240
ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంది.

1043
00:43:30,240 --> 00:43:31,990
>> కాబట్టి నేను ఇంకా ఎలాంటి ఆలోచన చేశారు.

1044
00:43:31,990 --> 00:43:35,150
ఇది కేవలం "చివరికి, ఉంచారు అనగా
ఇక్కడ ఒక పూర్ణాంకానికి యొక్క చిరునామా. "

1045
00:43:35,150 --> 00:43:38,340
అది ఎంతవరకూ 0x50, 0x88,
జ్ఞాపకశక్తి, ఒక చిరునామా ఉన్నట్లు అన్నారు.

1046
00:43:38,340 --> 00:43:40,200
ఆ Y ఏమిటి
అలాగే చేస్తాడు.

1047
00:43:40,200 --> 00:43:44,920
>> నేను ఇప్పుడు చెప్పండి చేస్తే x = malloc (sizeof (Int)),
ఈ చెప్పడం ఒక ఫాన్సీ మార్గం,

1048
00:43:44,920 --> 00:43:49,000
హే ఆపరేటింగ్ సిస్టమ్, malloc ద్వారా,
పరిమాణం నాకు తగినంత మెమరీ ఇవ్వాలని

1049
00:43:49,000 --> 00:43:52,370
బహుశా ఇది ఒక పూర్ణాంకానికి యొక్క
32 బిట్స్ లేదా నాలుగు బైట్లు చేస్తాడు.

1050
00:43:52,370 --> 00:43:53,680
>> కాబట్టి malloc ఏ తిరిగి లేదు?

1051
00:43:53,680 --> 00:43:55,250
Malloc ఒక చిరునామా తిరిగి.

1052
00:43:55,250 --> 00:43:57,020
సో వాట్ x నిల్వ పరుచుట?

1053
00:43:57,020 --> 00:44:00,600
భాగం యొక్క చిరునామా
జ్ఞాపకశక్తి, నాలుగు బైట్లు, ఆ malloc

1054
00:44:00,600 --> 00:44:03,360
కేవలం అడుగుతూ నాకు దొరకలేదు
ఆపరేటింగ్ సిస్టమ్.

1055
00:44:03,360 --> 00:44:08,240
>> ఇప్పుడు అదే సమయంలో, లైన్
ఇక్కడ నాలుగు, * x = 42.

1056
00:44:08,240 --> 00:44:09,990
జస్ట్ స్పష్టతను
అక్కడ డౌన్ ఏమి జరగబోతోంది?

1057
00:44:09,990 --> 00:44:11,530
ఎడమ చేతి వైపు, * x.

1058
00:44:11,530 --> 00:44:13,610
ఆ * 33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వంటిది.

1059
00:44:13,610 --> 00:44:15,523
కాబట్టి * x అంటే?

1060
00:44:15,523 --> 00:44:16,450
>> ప్రేక్షకులు: వెళ్ళండి.

1061
00:44:16,450 --> 00:44:17,908
>> డేవిడ్ J. మలన్: ఆ చిరునామా వెళ్ళండి.

1062
00:44:17,908 --> 00:44:20,466
ఎక్కడైతే ఆ భాగం
మెమరీ దానికి వెళ్ళండి.

1063
00:44:20,466 --> 00:44:21,979
మరియు స్పష్టంగా, అంటే చాలు?

1064
00:44:21,979 --> 00:44:22,520
ప్రేక్షకులు: 42.

1065
00:44:22,520 --> 00:44:23,580
డేవిడ్ J. మలన్: 42.

1066
00:44:23,580 --> 00:44:25,650
అన్ని కుడి, * వై, అదే ఆలోచన.

1067
00:44:25,650 --> 00:44:26,860
Y చిరునామా వెళ్ళండి.

1068
00:44:26,860 --> 00:44:31,740
అక్కడ 13 ఉంచండి
కానీ క్షణం వద్ద Y ఏమిటి?

1069
00:44:31,740 --> 00:44:33,172

1070
00:44:33,172 --> 00:44:34,630
ప్రేక్షకులు: జ్ఞాపకాలు Y కోసం ఉంది.

1071
00:44:34,630 --> 00:44:35,710
డేవిడ్ J. మలన్: అక్కడ
Y కోసం ఏ మెమరీ ఉంది.

1072
00:44:35,710 --> 00:44:38,215
సో వాట్ బహుశా Y చేస్తుంది
మేము చెప్పడం చేసిన, కలిగి?

1073
00:44:38,215 --> 00:44:38,520
>> ప్రేక్షకులు: గార్బేజ్.

1074
00:44:38,520 --> 00:44:39,480
>> డేవిడ్ J. మలన్: కొన్ని చెత్త విలువ.

1075
00:44:39,480 --> 00:44:41,320
ఇప్పుడు, చెత్త విలువ ఇప్పటికీ ఒక సంఖ్య.

1076
00:44:41,320 --> 00:44:43,160
ఇది ఇప్పటికీ ఒక చిరునామా పొరబడుతుంటారు.

1077
00:44:43,160 --> 00:44:45,160
ఇది ఎవరైనా అయితే వార్తలు
డౌన్ ఏదో రాతలు

1078
00:44:45,160 --> 00:44:48,002
మరియు నేను అర్థం గా తప్పుగా
వీధిలో కొన్ని భవనం.

1079
00:44:48,002 --> 00:44:50,460
మరియు మీరు కేవలం లోకి వెళ్ళడానికి ప్రయత్నించండి ఉంటే
మీరు స్వంతం లేదు కొన్ని భవనం,

1080
00:44:50,460 --> 00:44:53,710
లేదా మెమరీ కొన్ని భాగం మీరు కాదు
ఇవ్వబడిన చెడు పనులు జరిగే.

1081
00:44:53,710 --> 00:44:57,740
కంప్యూటర్ కొన్ని ఇతర క్రాష్, లేదా ఉండవచ్చు
వివరించలేని ప్రాంతంనుండి ప్రవర్తన జరిగే.

1082
00:44:57,740 --> 00:45:01,310
>> కాబట్టి, అప్పుడు Binky, ఈ పరిచయ ఉంది.

1083
00:45:01,310 --> 00:45:04,290
నేను ఇప్పటికీ 20, గుర్తు
కొన్ని బేసి సంవత్సరాల తరువాత,

1084
00:45:04,290 --> 00:45:07,200
నేను చివరికి నేను అక్కడ
గమనికలు అర్థం.

1085
00:45:07,200 --> 00:45:09,520
>> మీకు, చెప్పటానికి ఇది
మూడు నిమిషాల ఇక్కడ వదిలి

1086
00:45:09,520 --> 00:45:12,170
మరియు నేను లేదు అనుకుంటున్నాను
గమనికలు అర్థం, తెలుసుకోవటం

1087
00:45:12,170 --> 00:45:14,410
నేను 20 గుర్తుకువచ్చి
కొన్ని క్రేజీ కారణం సంవత్సరాల

1088
00:45:14,410 --> 00:45:17,140
ఎప్పుడు ఎందుకు అది చివరకు మునిగిపోయాయి
, నా శిక్షణతో కూర్చొని

1089
00:45:17,140 --> 00:45:19,501
తోటి, నిషాత్ మెహతా లో
ఎలియట్ డైనింగ్ హాల్ వెనుక.

1090
00:45:19,501 --> 00:45:21,250
ఇప్పుడు, నేను జ్ఞాపకం చేసిన
ఈ ఎందుకంటే

1091
00:45:21,250 --> 00:45:23,920
విషయాలు నేను కూడా ఒకటి
ప్రత్యేక పోరాడింది.

1092
00:45:23,920 --> 00:45:26,470
ఆపై, చివరకు క్లిక్,
వంటి నేను విషయాలు చాలా చెప్పటానికి ధైర్యం

1093
00:45:26,470 --> 00:45:27,460
చివరికి రెడీ.

1094
00:45:27,460 --> 00:45:32,590
మరియు ఇప్పుడు, అన్ని అనిపించవచ్చు
సంతోషముగా మరియు అన్ని మరింత ఆమోదయోగ్యమైన

1095
00:45:32,590 --> 00:45:35,360
యొక్క ఒక చివరి లుక్ తీసుకుందాం మా
ఇక్కడ Binky గత మూడు నిమిషాలు,

1096
00:45:35,360 --> 00:45:37,675
మా స్నేహితుడు, నిక్ నుండి
స్టాన్ఫోర్డ్ నుండి Parlante.

1097
00:45:37,675 --> 00:45:38,910

1098
00:45:38,910 --> 00:45:41,580
>> [వీడియో ప్లేబ్యాక్]

1099
00:45:41,580 --> 00:45:42,750
>> -Hey, Binky ఆన్లైన్.

1100
00:45:42,750 --> 00:45:43,500
నిద్రలేపే!

1101
00:45:43,500 --> 00:45:45,960
ఇది పాయింటర్ వినోదం కోసం సమయం.

1102
00:45:45,960 --> 00:45:47,012
>> ఆ -What వార్తలు?

1103
00:45:47,012 --> 00:45:48,723
గమనికలు గురించి తెలుసుకోండి?

1104
00:45:48,723 --> 00:45:50,580
ఓహ్, అమ్మ!

1105
00:45:50,580 --> 00:45:53,563
>> -సరే, ప్రారంభించడానికి, మనం ఉన్నాము అంచనా
ఒక జంట గమనికలు అవసరం అన్నారు.

1106
00:45:53,563 --> 00:45:54,390
>> -OK.

1107
00:45:54,390 --> 00:45:57,930
ఈ కోడ్, రెండు పాయింటర్లు కేటాయించుకునే
ఇది పూర్ణ సూచిస్తుంది.

1108
00:45:57,930 --> 00:45:58,430
-OK.

1109
00:45:58,430 --> 00:46:02,140
Well, నేను రెండు పాయింటర్లు చూడండి, కానీ వారు
ఏదైనా సూచించే అనిపించడం లేదు.

1110
00:46:02,140 --> 00:46:02,980
>> -ఆ సరియే.

1111
00:46:02,980 --> 00:46:05,100
మొదట్లో, గమనికలు
ఏదైనా సూచించడానికి లేదు.

1112
00:46:05,100 --> 00:46:08,030
వారు అని సూచించడానికి విషయాలు
pointees, మరియు వాటిని ఏర్పాటు

1113
00:46:08,030 --> 00:46:09,370
ప్రత్యేక అడుగు.

1114
00:46:09,370 --> 00:46:10,220
>> కుడి, కుడి, -OH.

1115
00:46:10,220 --> 00:46:10,950
నేను తెలుసు.

1116
00:46:10,950 --> 00:46:12,385
pointees విడిగా ఉంటాయి.

1117
00:46:12,385 --> 00:46:14,315
Er, కాబట్టి మీరు ఒక pointee కేటాయించాలని చెయ్యాలి?

1118
00:46:14,315 --> 00:46:15,340

1119
00:46:15,340 --> 00:46:15,960
>> -OK.

1120
00:46:15,960 --> 00:46:18,970
Well, ఈ కోడ్ కేటాయించుకునే
ఒక కొత్త పూర్ణాంక pointee,

1121
00:46:18,970 --> 00:46:20,950
మరియు ఈ భాగం సెట్లు x అది సూచించడానికి.

1122
00:46:20,950 --> 00:46:22,050

1123
00:46:22,050 --> 00:46:23,230
>> -Hey, మంచి కనిపిస్తోంది.

1124
00:46:23,230 --> 00:46:25,060
కాబట్టి అది ఏదో ఒకటి చేయండి.

1125
00:46:25,060 --> 00:46:25,990
>> -OK.

1126
00:46:25,990 --> 00:46:30,455
నేను dereference పాయింటర్ x చేస్తాము
దాని pointee లోకి సంఖ్య 42 నిల్వ.

1127
00:46:30,455 --> 00:46:32,830
ఈ ట్రిక్ కోసం, నేను అవసరం ఉంటుంది నా
Dereferencing యొక్క మ్యాజిక్ వాండ్.

1128
00:46:32,830 --> 00:46:34,130

1129
00:46:34,130 --> 00:46:36,080
>> Dereferencing యొక్క -మీ మేజిక్ వాండ్?

1130
00:46:36,080 --> 00:46:37,357

1131
00:46:37,357 --> 00:46:38,190
ఆ గొప్ప పని.

1132
00:46:38,190 --> 00:46:39,340

1133
00:46:39,340 --> 00:46:41,080
>> -ఈ కోడ్ కనిపిస్తోంది ఏమిటి.

1134
00:46:41,080 --> 00:46:44,110
నేను కేవలం సంఖ్య, మరియు [పాప్] ఏర్పాటు చేస్తాము

1135
00:46:44,110 --> 00:46:44,700
>> -Hey, చూడండి.

1136
00:46:44,700 --> 00:46:46,140
అక్కడ అది వెళుతుంది.

1137
00:46:46,140 --> 00:46:50,980
>> X అనుసరిస్తుంది ఒక dereference చేయడం -కాబట్టి
బాణం దాని pointee ప్రాప్తి చేయడానికి.

1138
00:46:50,980 --> 00:46:53,160
ఈ సందర్భంలో, అక్కడ ఒక స్టోర్ 42.

1139
00:46:53,160 --> 00:46:57,710
హే సంఖ్య నిల్వ దానిని ఉపయోగించి ప్రయత్నించండి
ఇతర పాయింటర్ ద్వారా 13, Y.

1140
00:46:57,710 --> 00:46:58,760
>> -OK.

1141
00:46:58,760 --> 00:47:03,270
నేను y ఇక్కడ పైగా వెళ్తారో
సంఖ్య 13 సెట్ అప్ పొందండి.

1142
00:47:03,270 --> 00:47:07,930
ఆపై, మంత్రదండం టేక్
Dereferencing మరియు కేవలం [Buzz]

1143
00:47:07,930 --> 00:47:08,960
>> -OH!

1144
00:47:08,960 --> 00:47:09,500
>> హే, -OH!

1145
00:47:09,500 --> 00:47:11,090
ఆ పని చేయలేదు.

1146
00:47:11,090 --> 00:47:15,630
Binky, నేను dereferencing భావించడం లేదు, సే
మీరు తెలుసు ఎందుకంటే Y, ఒక మంచి ఆలోచన

1147
00:47:15,630 --> 00:47:17,850
pointee ఏర్పాటు
ప్రత్యేక అడుగు.

1148
00:47:17,850 --> 00:47:20,450
మరియు మనం ఎప్పుడూ చేసియున్నారు భావించడం లేదు.

1149
00:47:20,450 --> 00:47:21,480
>> -గుడ్ పాయింట్.

1150
00:47:21,480 --> 00:47:21,980
-Yeah.

1151
00:47:21,980 --> 00:47:25,680
మేము పాయింటర్ Y కేటాయించింది, కాని మేము
ఎప్పుడూ ఒక pointee సూచించడానికి సెట్.

1152
00:47:25,680 --> 00:47:27,190

1153
00:47:27,190 --> 00:47:28,616
>> -Very గమనించే.

1154
00:47:28,616 --> 00:47:30,240
-Hey, మీరు అక్కడ Binky మంచి చూస్తున్న.

1155
00:47:30,240 --> 00:47:33,400
కాబట్టి మీరు దాన్ని పరిష్కరించడానికి చేయవచ్చు y పాయింట్లు
x అదే pointee కు?

1156
00:47:33,400 --> 00:47:34,000
>> -Sure.

1157
00:47:34,000 --> 00:47:36,780
నేను నా మాజిక్ మంత్ర ఉపయోగిస్తాము
పాయింటర్ అప్పగించిన.

1158
00:47:36,780 --> 00:47:38,740
>> అవతరిస్తుంది చూడబడ్డాడు
ముందు వంటి సమస్య?

1159
00:47:38,740 --> 00:47:39,240
-సంఖ్య.

1160
00:47:39,240 --> 00:47:40,660
ఈ pointees టచ్ లేదు.

1161
00:47:40,660 --> 00:47:44,450
ఇది కేవలం ఒక పాయింటర్ మార్పులు
మరొక అదే విషయం సూచించడానికి.

1162
00:47:44,450 --> 00:47:45,450
>> -OH, నేను చూడండి.

1163
00:47:45,450 --> 00:47:48,200
X అదే స్థానంలో ఇప్పుడు Y పాయింట్లు.

1164
00:47:48,200 --> 00:47:48,910
కాబట్టి వేచి.

1165
00:47:48,910 --> 00:47:49,950
ఇప్పుడు, Y పరిష్కరించబడింది.

1166
00:47:49,950 --> 00:47:51,120
ఇది ఒక pointee ఉంది.

1167
00:47:51,120 --> 00:47:54,510
కాబట్టి మీరు వాండ్ ప్రయత్నించవచ్చు
13 కి పైగా పంపడానికి మళ్ళీ dereferencing.

1168
00:47:54,510 --> 00:47:56,510
>> సరే, -Uh.

1169
00:47:56,510 --> 00:47:58,160
ఇక్కడ చేజారిపోతుంది. [పాప్]

1170
00:47:58,160 --> 00:47:59,340
>> -Hey, ఆ దృష్టి.

1171
00:47:59,340 --> 00:48:00,750
ఇప్పుడు Y పనులు dereferencing.

1172
00:48:00,750 --> 00:48:04,991
గమనికలు భాగస్వామ్యం ఎందుకంటే
ఒక pointee అని, వారు రెండు 13 చూడండి.

1173
00:48:04,991 --> 00:48:05,490
-Yeah.

1174
00:48:05,490 --> 00:48:06,870
పంచుకుంటున్న సంసార.

1175
00:48:06,870 --> 00:48:08,820
కాబట్టి మేము ఇప్పుడు ప్రదేశాలు మారడానికి వెళ్తున్నారు?

1176
00:48:08,820 --> 00:48:09,440
>> ఓహ్, చూడండి.

1177
00:48:09,440 --> 00:48:10,830
మేము సమయం లేదు.

1178
00:48:10,830 --> 00:48:11,570
>> -But--

1179
00:48:11,570 --> 00:48:13,530
>> మూడు పాయింటర్ నియమాలు గుర్తుంచుకోవాలి-కేవలం.

1180
00:48:13,530 --> 00:48:16,560
నెంబర్ వన్, ప్రాథమిక నిర్మాణం
మీరు ఒక పాయింటర్ కలిగి ఉంది,

1181
00:48:16,560 --> 00:48:18,680
మరియు ఇది ఒక pointee కు చూపాడు.

1182
00:48:18,680 --> 00:48:20,640
కానీ పాయింటర్ మరియు
pointee, ప్రత్యేక ఉన్నాయి

1183
00:48:20,640 --> 00:48:22,610
మరియు సాధారణ లోపాన్ని
ఒక పాయింటర్ ఏర్పాటు చేయడం,

1184
00:48:22,610 --> 00:48:25,000
కానీ ఒక pointee ఇవ్వాలని మర్చిపోవటానికి.

1185
00:48:25,000 --> 00:48:28,170
>> సంఖ్య రెండు, పాయింటర్ dereferencing
పాయింటర్ మొదలవుతుంది

1186
00:48:28,170 --> 00:48:31,050
మరియు దాని బాణం క్రింది
దాని pointee ప్రాప్తి చేయడానికి.

1187
00:48:31,050 --> 00:48:33,400
మేము అన్ని తెలిసిన, ఈ
ఉందనుకోండి మాత్రమే పనిచేస్తుంది

1188
00:48:33,400 --> 00:48:36,270
ఒక pointee ఏ రకమైన
నెంబర్ వన్ రూల్ వచ్చేస్తుంది.

1189
00:48:36,270 --> 00:48:39,000
>> సంఖ్య మూడు, పాయింటర్
అప్పగించిన ఒక పాయింటర్ పడుతుంది

1190
00:48:39,000 --> 00:48:42,320
మరియు మార్చాలి
మరొక పాయింటర్ అదే pointee.

1191
00:48:42,320 --> 00:48:44,160
అప్పగించిన తర్వాత కాబట్టి,
రెండు పాయింటర్లు

1192
00:48:44,160 --> 00:48:45,910
అదే pointee కు ఆకర్షిస్తాయి.

1193
00:48:45,910 --> 00:48:47,990
కొన్నిసార్లు, భాగస్వామ్య అని.

1194
00:48:47,990 --> 00:48:49,740
మరియు ఆ నిజంగా, ఇది ఉంది అంతే.

1195
00:48:49,740 --> 00:48:50,277
బై బై-ఇప్పుడు.

1196
00:48:50,277 --> 00:48:51,110
[END వీడియో ప్లేబ్యాక్]

1197
00:48:51,110 --> 00:48:52,568
డేవిడ్ J. మలన్: ఆ CS50 కోసం అంతే.

1198
00:48:52,568 --> 00:48:55,110
వచ్చే వారం మీరు చూస్తారు.

1199
00:48:55,110 --> 00:48:56,064