1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID మలన్: అన్ని కుడి, తిరిగి స్వాగతం.

3
00:00:12,580 --> 00:00:13,290
ఈ CS50 ఉంది.

4
00:00:13,290 --> 00:00:15,130
ఈ వారం ఏడు ప్రారంభంలో ఉంది.

5
00:00:15,130 --> 00:00:18,890
కనుక ఇది ఒక సమయంలో కూడా, నేను మేము ఆలపించాలని అనుకున్నాము లో
అక్కడ ఒక సుడిగాలి పర్యటన

6
00:00:18,890 --> 00:00:20,760
వదిలి మరియు అక్కడ ప్రస్తుతం చేయబోతున్నామని.

7
00:00:20,760 --> 00:00:23,310
>> ఈ విషయం ఇక్కడ ఉండవచ్చు కాబట్టి
మొదటి కొన్ని బెంగ కారణంగా.

8
00:00:23,310 --> 00:00:27,680
కానీ ఆశాజనక, మీరు ప్రారంభిస్తున్నాం
ఇక్కడ సూచిస్తుంది ఏమి పరిసర స్థితిగతులకు అలవాటుపరచు -

9
00:00:27,680 --> 00:00:32,670
ఇది ఒక పాయింటర్, ప్రాతినిధ్యం స్టార్
మరింత లేమాన్ పరంగా కేవలం ఏమి?

10
00:00:32,670 --> 00:00:33,400
కనుక ఇది ఒక చిరునామా యొక్క.

11
00:00:33,400 --> 00:00:35,490
>> సో అది చిరునామా వార్తలు
మెమరీ ఏదో.

12
00:00:35,490 --> 00:00:38,260
మరియు మేము తిరిగి చర్మము పొరలు ప్రారంభించారు
వారాల క్రితం, విషయాలు ఇష్టం

13
00:00:38,260 --> 00:00:41,800
GetString మరియు ఇతర విధులు
అన్ని ఈ సమయంలో తిరిగి చేశారు

14
00:00:41,800 --> 00:00:46,010
వంటి మెమరీలో విషయాలను చిరునామాలు,
లో మొదటి అక్షరం యొక్క చిరునామా

15
00:00:46,010 --> 00:00:46,990
కొన్ని క్రమం.

16
00:00:46,990 --> 00:00:50,360
>> కాబట్టి మేము కూడా, valgrind పరిచయం చేసిన
మీరు ఈ సమస్య కోసం ఉపయోగించడానికి మొదలు పెడతారేమో

17
00:00:50,360 --> 00:00:53,380
ఆ తర్వాతి కోసం, సెట్
సమస్య అలాగే సెట్.

18
00:00:53,380 --> 00:00:54,980
మరియు valgrind మాకు ఏమి చేస్తుంది?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
ఇది మెమరీ లీకేజ్ కోసం వెతుకుతుంది, మరియు అది
కూడా మెమరీ దుర్వినియోగం కోసం వెతుకుతుంది.

21
00:01:01,020 --> 00:01:05,890
>> ఇది, కొన్ని సంభావ్యత తో, గుర్తించగలదు ఉంటే
మీ కోడ్ మెమరీ తాకే వెళ్తున్నారు

22
00:01:05,890 --> 00:01:07,100
అది కేవలం ఉండకూడదు.

23
00:01:07,100 --> 00:01:10,410
సో ఒక లీక్ అవసరం, కానీ మీరు కాదు
కొన్ని సరిహద్దులను దాటి వెళ్ళి

24
00:01:10,410 --> 00:01:14,730
అర్రే, మరియు మీరు నిజంగానే valgrind అమలు
మరియు ప్రవర్తన ప్రేరేపించడానికి అయితే

25
00:01:14,730 --> 00:01:17,870
valgrind మీ ప్రోగ్రామ్ రన్
అది లోపల నడుస్తున్న, మీరు పొందుతారు

26
00:01:17,870 --> 00:01:21,460
ఈ వంటి సందేశాలను - "చెల్లని యొక్క వ్రాయండి
, ఒక జంట గుర్తుకు ఇది పరిమాణం 4, "

27
00:01:21,460 --> 00:01:25,880
వారాల క్రితం నేను అనుకోకుండా వచ్చేది
చాలా దూరం ఒక Int నచ్చిన

28
00:01:25,880 --> 00:01:27,250
ఒక అర్రే యొక్క సరిహద్దులు దాటి.

29
00:01:27,250 --> 00:01:30,790
అందువలన పరిమాణం 4 ఇక్కడ పరిమాణం అర్థం
నిర్దిష్ట Int యొక్క.

30
00:01:30,790 --> 00:01:35,260
>> సో నిజానికి అభయమిచ్చిన తీసుకోవాలని
valgrind యొక్క అవుట్పుట్, అది ఫార్మాట్,

31
00:01:35,260 --> 00:01:36,170
కేవలం ఘోరమైన ఉంది.

32
00:01:36,170 --> 00:01:40,180
ఇది గజిబిజి ద్వారా చూడటానికి నిజంగా కష్టం
ఆసక్తికరమైన సమాచారం కోసం.

33
00:01:40,180 --> 00:01:42,910
సో వాట్ మేము ఇక్కడ చేశాను సారాంశంలో
ఎక్కువ జంట కొన్ని

34
00:01:42,910 --> 00:01:43,850
ఆసక్తికరమైన పంక్తులు.

35
00:01:43,850 --> 00:01:46,760
కాని వసూలు చేసే valgrind యొక్క 80%
అవుట్పుట్ యొక్క ఒక బిట్ అవతరిస్తుంది

36
00:01:46,760 --> 00:01:47,650
పరధ్యానంగా.

37
00:01:47,650 --> 00:01:52,820
>> కేవలం ఇలాంటి నమూనాలు చూడండి -
కుడి చెల్లని, చెల్లని, 40 బైట్లు చదవండి

38
00:01:52,820 --> 00:01:56,690
మరియు బ్లాక్లను కొన్ని సంఖ్య ఖచ్చితంగా ఉన్నాయి
ఆ వంటి కీలక పదాలు కోల్పోయింది.

39
00:01:56,690 --> 00:02:01,920
మరియు మీరు ఆశాజనక చూస్తారు కొన్ని ఉంది
పని ఏమి ఆధారములు రకం

40
00:02:01,920 --> 00:02:03,340
తప్పు సైన్ నిజానికి

41
00:02:03,340 --> 00:02:07,195
ఇక్కడ ఈ సందర్భంలో, ఏ లైన్ లో
నా కోడ్ స్పష్టంగా లోపం?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> ఇది memory.c పిలువబడే ఒక ఫైల్, 26
మేము ప్లే చేశారు ఉదాహరణకు

44
00:02:14,130 --> 00:02:14,890
సమయంలో.

45
00:02:14,890 --> 00:02:16,460
కనుక ఇది malloc బహుశా కాదు.

46
00:02:16,460 --> 00:02:18,630
ఇది బదులుగా నా కోడ్ బహుశా.

47
00:02:18,630 --> 00:02:20,910
కాబట్టి మేము మళ్ళీ ఈ చూస్తారు
మళ్ళీ దీర్ఘ ముందు.

48
00:02:20,910 --> 00:02:24,080
>> Scanf సో, ఈ ఒక వచ్చింది
ఇప్పటివరకు రకాల జంట.

49
00:02:24,080 --> 00:02:26,410
మేము క్లుప్తంగా sscanf చూసింది.

50
00:02:26,410 --> 00:02:28,330
ఇది ఏదో ఒక సంఖ్య
మీరు మీ లోకి dived

51
00:02:28,330 --> 00:02:29,535
క్విజ్ సన్నాహాలు.

52
00:02:29,535 --> 00:02:33,130
మరియు scanf అసలు CS50
లైబ్రరీ కింద ఉపయోగించి చేయబడింది

53
00:02:33,130 --> 00:02:36,560
క్రమంలో కొంతకాలంగా కోసం హుడ్
యూజర్ నుండి ఇన్పుట్ పొందుటకు.

54
00:02:36,560 --> 00:02:40,420
>> ఉదాహరణకు, నేను CS50 కు వచ్చినప్పుడు
ఉపకరణం ఇక్కడ, ఒక నన్ను తెరుచుకుంటుంది వీలు

55
00:02:40,420 --> 00:02:45,315
scanf-0.c అని ఉదాహరణగా నేడు
మరియు అది సూపర్ సులభం.

56
00:02:45,315 --> 00:02:46,590
ఇది కేవలం కోడ్ యొక్క కొన్ని పంక్తులు వార్తలు.

57
00:02:46,590 --> 00:02:50,880
కానీ అది ప్రదర్శించాడు నిజంగా ఎలా getInt
ఈ సమయంలో అన్ని పని చేస్తుంది.

58
00:02:50,880 --> 00:02:54,710
>> లైన్ 16 లో ఇక్కడ ఈ కార్యక్రమం
, నేను ఒక Int డిక్లేర్ ప్రకటన.

59
00:02:54,710 --> 00:02:57,270
అందువలన గమనికలు, మాయా ఏమీ
అక్కడ, కేవలం ఒక Int.

60
00:02:57,270 --> 00:03:00,330
అప్పుడు లైన్ 17 లో, నేను ప్రాంప్ట్
అనేక యూజర్, దయచేసి.

61
00:03:00,330 --> 00:03:02,930
అప్పుడు చివరి 18 లో, నేను ఇక్కడ scanf ఉపయోగించడానికి.

62
00:03:02,930 --> 00:03:06,910
మరియు నేను పేర్కొన్న, రకమైన వంటి printf యొక్క,
నేను కోట్ ఎదురుచూచే చేస్తున్నాను అని

63
00:03:06,910 --> 00:03:08,110
శాతం i unquote.

64
00:03:08,110 --> 00:03:10,920
>> శాతం నేను, కోర్సు యొక్క,
ఒక Int సూచిస్తుంది.

65
00:03:10,920 --> 00:03:14,580
కానీ గమనించవచ్చు ఏమి రెండవ
scanf కు వాదన.

66
00:03:14,580 --> 00:03:17,350
ఎలా మీరు రెండవ వివరిస్తారు
కామా తర్వాత వాదన?

67
00:03:17,350 --> 00:03:19,450
ఆ అంటే ఏమిటి?

68
00:03:19,450 --> 00:03:20,670
>> ఇది x యొక్క చిరునామా యొక్క.

69
00:03:20,670 --> 00:03:25,490
సో ఈ ఎందుకంటే అందించడం ద్వారా ఉపయోగకరంగా ఉంటుంది
x యొక్క చిరునామాతో scanf, దేనిని

70
00:03:25,490 --> 00:03:29,560
అలా ఆ ఫంక్షన్ గలదా?

71
00:03:29,560 --> 00:03:33,010
కాదు అక్కడికి వెళ్ళడానికి, కానీ కూడా ఏమి?

72
00:03:33,010 --> 00:03:34,060
>> ఇది మార్పు.

73
00:03:34,060 --> 00:03:38,080
మీరు అక్కడికి వెళ్లేందుకు ఎందుకంటే, అది విధమైన వార్తలు
మెమరీ లో ఒక స్థానాన్ని ఒక చిహ్నం వంటి.

74
00:03:38,080 --> 00:03:41,900
మరియు చాలా కాలం మీరు అందిస్తాయి scanf, లేదా
ఒక చిహ్నం, ఆ ఏ ఫంక్షన్

75
00:03:41,900 --> 00:03:45,840
ఫంక్షన్ అక్కడ వెళ్ళి, మరియు చేయవచ్చు మాత్రమే
విలువ చూడండి, కానీ కూడా చెయ్యవచ్చు

76
00:03:45,840 --> 00:03:49,670
ఉపయోగకరంగా ఉండే ఆ విలువ, మార్చడానికి
scanf జీవితంలో ప్రయోజనం ఉంది

77
00:03:49,670 --> 00:03:53,060
ప్రత్యేకంగా, వినియోగదారు నుండి ఇన్పుట్ స్కాన్
కీబోర్డ్ నుండి.

78
00:03:53,060 --> 00:03:57,830
మరియు f వలె, ఆకృతీకరణ సూచిస్తుంది
printf, f ఒక ఆకృతీకరణ సూచిస్తుంది

79
00:03:57,830 --> 00:03:58,930
మీరు ముద్రించడానికి కావలసిన స్ట్రింగ్.

80
00:03:58,930 --> 00:04:04,430
>> కాబట్టి చిన్న, ఈ లైన్ 18 కేవలం చెప్పారు,
యూజర్ యొక్క నుండి ఒక Int చదవడానికి ప్రయత్నించండి

81
00:04:04,430 --> 00:04:10,420
కీబోర్డ్ మరియు, x యొక్క లోపల నిల్వ
x వద్ద నివసించడానికి ఏది చిరునామా.

82
00:04:10,420 --> 00:04:14,860
ఆపై చివరగా, లైన్ 19 కేవలం చెప్పారు,
ఈ సందర్భంలో Int ధన్యవాదాలు.

83
00:04:14,860 --> 00:04:15,940
>> సో నాకు ముందుకు వెళ్లి ఈ తయారు చేద్దాము.

84
00:04:15,940 --> 00:04:18,570
సో scanf 0 తయారు.

85
00:04:18,570 --> 00:04:20,130
నాకు ముందుకు సాగి సైన్ జూమ్ లెట్

86
00:04:20,130 --> 00:04:22,960
నేను వెళ్ళి ఈ అమలు చేస్తాము
చుక్కలు scanf 0 స్లాష్.

87
00:04:22,960 --> 00:04:24,020
సంఖ్య, దయచేసి?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
50 ధన్యవాదాలు.

90
00:04:25,730 --> 00:04:27,270
కనుక ఇది చాలా సులభం.

91
00:04:27,270 --> 00:04:28,160
>> ఇప్పుడు ఏమి లేదు?

92
00:04:28,160 --> 00:04:29,940
ఇది ఒక మొత్తం బంచ్ చేయడం లేదు
దోష పరిశీలన యొక్క.

93
00:04:29,940 --> 00:04:33,000
ఉదాహరణకు, నేను సహకారం లేకపోతే,
మరియు నేను అనేక టైప్ కానీ లేదు

94
00:04:33,000 --> 00:04:37,860
బదులుగా నేను "హలో," వంటి ఏదో వ్రాయడానికి
ఆ వింత చూస్తూ ఉంటాము.

95
00:04:37,860 --> 00:04:41,130
విషయాలు CS50 యొక్క కావున
లైబ్రరీ కొన్ని మాకు చేస్తున్న

96
00:04:41,130 --> 00:04:43,440
సమయం ఆ reprompting ఉంది
మరియు reprompting.

97
00:04:43,440 --> 00:04:49,320
>> మళ్ళీ పదబంధం ఉపసంహరణలు, cs50.c లో ఉంది
మరియు ఆ getInt లో కారణం వార్తలు

98
00:04:49,320 --> 00:04:51,670
CS50 లైబ్రరీ నిజానికి మొత్తం ఉంది
దీర్ఘ లైన్లు బంచ్, మేము ఎందుకంటే

99
00:04:51,670 --> 00:04:53,190
ఈ వంటి స్టుపిడ్ స్టఫ్ కోసం తనిఖీ.

100
00:04:53,190 --> 00:04:55,730
యూజర్ ఇవ్వాలని లేదు
మాకు, నిజానికి, ఒక Int?

101
00:04:55,730 --> 00:04:57,910
అతను లేదా ఆమె మాకు ఏదో కల్పించింది
ఒక అక్షర లేఖ వంటి?

102
00:04:57,910 --> 00:05:01,410
అలా అయితే, మేము గుర్తించడానికి కావలసిన
మరియు వాటిని మీద అరుస్తుంటారు.

103
00:05:01,410 --> 00:05:03,915
>> కానీ విషయాలు మరింత ఆసక్తికరంగా పొందుటకు
ఈ తదుపరి ఉదాహరణలో.

104
00:05:03,915 --> 00:05:09,840
నేను scanf-1.c వెళ్ళండి ఉంటే, ఏమి ఒకటి
ప్రాథమికంగా మారింది అని విషయం

105
00:05:09,840 --> 00:05:11,135
ఈ తదుపరి ఉదాహరణకు?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
నేను, కోర్సు యొక్క, చార్ * ఉపయోగించి వెబ్
బదులుగా Int యొక్క.

108
00:05:16,010 --> 00:05:19,210
>> ఎందుకంటే చార్ * సో ఈ, ఆసక్తికరంగా ఉంటుంది
గుర్తు, కేవలం నిజంగా ఉంది

109
00:05:19,210 --> 00:05:20,190
స్ట్రింగ్ అదే విషయం.

110
00:05:20,190 --> 00:05:23,840
కనుక ఇది ఉండవచ్చు వంటి ఈ ఒక సూపర్ భావిస్తాడు
GetString సాధారణ అమలు.

111
00:05:23,840 --> 00:05:26,010
కానీ నేను పొర తిరిగి ఒలిచిన చేసిన
CS50 లైబ్రరీ, నేను కాబట్టి

112
00:05:26,010 --> 00:05:27,550
ఇప్పుడు ఈ చార్ * కాల్.

113
00:05:27,550 --> 00:05:30,070
సో యొక్క చూద్దాము పేరు, ఎక్కడైనా ఉంటే,
మేము తప్పు.

114
00:05:30,070 --> 00:05:30,840
>> లైన్ 17 -

115
00:05:30,840 --> 00:05:33,950
నేను మళ్ళీ, నాకు ఏదో ఇవ్వాలని దయచేసి, చెప్పటానికి
ఈ సందర్భంలో, ఒక స్ట్రింగ్.

116
00:05:33,950 --> 00:05:37,940
తరువాత లైన్ లో, నేను, scanf కాల్
మళ్ళీ, అది ఒక ఫార్మాట్ కోడ్ ఇవ్వడం,

117
00:05:37,940 --> 00:05:39,310
కానీ ఈ సమయంలో శాతం లు.

118
00:05:39,310 --> 00:05:41,900
ఆపై ఈ సమయంలో, నేను రెడీ!
ఇది బఫర్ ఇవ్వడం.

119
00:05:41,900 --> 00:05:43,550
>> ఇప్పుడు నేను ఉపయోగించి కాదు, గమనించండి
ఆంపర్సండ్ చిహ్నం.

120
00:05:43,550 --> 00:05:47,120
కానీ ఎందుకు ఇక్కడ బహుశా సరే?

121
00:05:47,120 --> 00:05:49,760
ఇప్పటికే బఫర్ ఏమిటి ఎందుకంటే?

122
00:05:49,760 --> 00:05:50,770
ఇది ఇప్పటికే ఒక పాయింటర్ వార్తలు.

123
00:05:50,770 --> 00:05:51,650
ఇది ఇప్పటికే ఒక చిరునామా యొక్క.

124
00:05:51,650 --> 00:05:54,510
>> మరియు లెట్ ఈ పదం నాకు వీలు ", కంగారు" వార్తలు
కేవలం ఉదాహరణకు, అది లు కాల్

125
00:05:54,510 --> 00:05:55,050
సరళత.

126
00:05:55,050 --> 00:05:58,250
కానీ నేను స్వీకరించేందుకు అని చేసిన ఎందుకంటే
సాధారణ, ప్రోగ్రామింగ్ లో, మీరు ఒక కలిగి ఉంటే

127
00:05:58,250 --> 00:06:02,130
మెమరీ భాగం, ఇది ఒక స్ట్రింగ్ నిజంగా
కేవలం, మీరు ఒక బఫర్ కాల్ ఉండవచ్చు ఉంది.

128
00:06:02,130 --> 00:06:04,460
ఇది సమాచారాన్ని నిల్వచేసే ప్రదేశం.

129
00:06:04,460 --> 00:06:07,400
>> ఉన్నప్పుడు YouTube, వంటి విషయాలను పోలి
వారు, మాట్లాడటానికి, బఫరింగ్ చేస్తున్న

130
00:06:07,400 --> 00:06:10,270
దాని నుండి బిట్స్ డౌన్లోడ్ యొక్క అర్థం
ఇంటర్నెట్ మరియు ఒక వాటిని నిల్వ

131
00:06:10,270 --> 00:06:14,160
స్థానిక అర్రే, కాబట్టి మెమరీ స్థానిక భాగం
మీరు లేకుండా తరువాత చూడవచ్చు

132
00:06:14,160 --> 00:06:16,830
ఇది ముళ్లు లేదా వ్రేలాడుతూ
మీరు తిరిగి ఆడుతున్నప్పుడు.

133
00:06:16,830 --> 00:06:20,930
>> సో ఒక సమస్య, అయితే ఇక్కడ ఉంది
నేను scanf చెప్పడం నేను ఎందుకంటే, ఒక అంచనా

134
00:06:20,930 --> 00:06:22,320
యూజర్ నుండి స్ట్రింగ్.

135
00:06:22,320 --> 00:06:24,410
ఇక్కడ యొక్క చిరునామా వార్తలు
మెమరీ భాగం.

136
00:06:24,410 --> 00:06:26,180
అక్కడ ఆ స్ట్రింగ్ ఉంచండి.

137
00:06:26,180 --> 00:06:31,230
ఎందుకు ఆ బౌండ్ ఇవ్వండి
అయితే మాకు ఇబ్బంది,?

138
00:06:31,230 --> 00:06:33,490
>> ఆ ఏమిటి?

139
00:06:33,490 --> 00:06:35,510
నేను ఆక్సెస్ చెయ్యడానికి అనుమతి
మెమరీ భాగం?

140
00:06:35,510 --> 00:06:36,250
మీకు తెలిసిన, నేను తెలియదు.

141
00:06:36,250 --> 00:06:39,210
బఫర్ initialized ఎందుకంటే
దేని?

142
00:06:39,210 --> 00:06:39,820
కాదు నిజంగా.

143
00:06:39,820 --> 00:06:43,090
కావున మేము కాల్ చేసిన ఏమిటి
ఒక చెత్త విలువ, ఇది

144
00:06:43,090 --> 00:06:44,040
ఒక అధికారిక పదం కాదు.

145
00:06:44,040 --> 00:06:49,200
ఇది కేవలం మేము ఏమి బిట్స్ సంఖ్య ఆలోచన ఉంది అంటే
నాలుగు బైట్లు లోపలి ఉన్నాయి

146
00:06:49,200 --> 00:06:51,240
నేను బఫర్ వంటి కేటాయించిన చేశారు.

147
00:06:51,240 --> 00:06:52,450
>> నేను malloc అని లేదు.

148
00:06:52,450 --> 00:06:53,940
నేను ఖచ్చితంగా GetString అని చేసిన.

149
00:06:53,940 --> 00:06:56,380
సో ఎవరు అసలు తెలుసు
బఫర్ లోపల?

150
00:06:56,380 --> 00:07:00,550
మరియు ఇంకా scanf చెప్పడం నిర్లక్ష్యంగా, అక్కడ వెళ్ళి
మరియు వినియోగదారు టైప్ సంసార చాలు.

151
00:07:00,550 --> 00:07:04,460
>> సో కారణమవుతుంది ఏమిటి
మా కోడ్ మేము అది అమలు చేస్తే?

152
00:07:04,460 --> 00:07:05,700
బహుశా ఒక segfault.

153
00:07:05,700 --> 00:07:07,970
బహుశా కాకపోవచ్చు, కానీ బహుశా ఒక segfault.

154
00:07:07,970 --> 00:07:10,620
మరియు నేను ఉండవచ్చు కాదు ఎందుకంటే కొన్నిసార్లు
మీరు కొన్నిసార్లు, చేయండి

155
00:07:10,620 --> 00:07:11,380
మీరు ఒక segfault పొందలేము.

156
00:07:11,380 --> 00:07:14,280
కొన్ని సమయాల్లో మీరు అదృష్ట పొందుటకు, కానీ
ఏది ఏమి అయినప్పటికీ అది చేస్తాడు

157
00:07:14,280 --> 00:07:15,340
మా ప్రోగ్రామ్ ఒక బగ్.

158
00:07:15,340 --> 00:07:17,060
>> సో నాకు ముందుకు వెళ్లి ఈ కంపైల్ వీలు.

159
00:07:17,060 --> 00:07:18,280
నేను పాత పాఠశాల విధంగా చేయ బోతున్నాను.

160
00:07:18,280 --> 00:07:23,825
సో గణగణమని ద్వని చేయు డాష్ 0, scanf-1,
scanf-1.c, ఎంటర్ చెయ్యండి.

161
00:07:23,825 --> 00:07:24,720
అయ్యో, పాత పాఠశాల.

162
00:07:24,720 --> 00:07:26,550
యొక్క చూసేలా.

163
00:07:26,550 --> 00:07:28,440
నేను ఏమి అయ్యాయి?

164
00:07:28,440 --> 00:07:29,700
ఓహ్, చార్ * బఫర్.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
ఓహ్, ధన్యవాదాలు -

167
00:07:35,130 --> 00:07:36,930
OK, సేవ్ -

168
00:07:36,930 --> 00:07:37,690
చాలా పాత పాఠశాల.

169
00:07:37,690 --> 00:07:38,900
అన్ని కుడి, అది చాలా సేపు అయ్యింది.

170
00:07:38,900 --> 00:07:41,720
>> సో నేను ఫైలు తర్వాత సేవ్ చేసిన
ఆ తాత్కాలిక మేకింగ్

171
00:07:41,720 --> 00:07:42,700
ఒక క్షణం క్రితం మార్చడానికి.

172
00:07:42,700 --> 00:07:46,090
మరియు ఇప్పుడు నేను సంగ్రహం
మానవీయంగా గణగణమని ద్వని చేయు తో.

173
00:07:46,090 --> 00:07:49,500
మరియు ఇప్పుడు నేను ముందుకు వెళ్ళి వెళుతున్నాను
మరియు Enter, scanf-1 అమలు.

174
00:07:49,500 --> 00:07:50,290
స్ట్రింగ్ దయచేసి.

175
00:07:50,290 --> 00:07:51,600
నేను టైప్ చేస్తాము "హలో."

176
00:07:51,600 --> 00:07:54,070
>> మరియు ఇప్పుడు, ఇక్కడ printf, స్పష్టముగా, పేరు వార్తలు
కొద్దిగా బాధించే ఉంటుంది.

177
00:07:54,070 --> 00:07:56,020
ఇది నిజానికి మాత్రం కాదు
ఈ సందర్భంలో segfault.

178
00:07:56,020 --> 00:07:59,860
Printf కొద్దిగా ప్రత్యేక ఎందుకంటే
ఇది సాధారణంగా ఉపయోగిస్తారు కాబట్టి సూపర్ అని

179
00:07:59,860 --> 00:08:03,570
ముఖ్యంగా printf చేస్తున్న
మాకు ఒక అనుకూలంగా మరియు తెలుసుకొని,

180
00:08:03,570 --> 00:08:04,830
ఒక చెల్లుబాటు అయ్యే పాయింటర్ కాదు.

181
00:08:04,830 --> 00:08:09,080
నాకు కేవలం ప్రింట్ మీద నన్ను తీసుకుందాం
వక్ర శూన్య లో, కూడా

182
00:08:09,080 --> 00:08:13,340
అది తప్పనిసరిగా కాదు అయితే ఏమి
మనం అంచనా.

183
00:08:13,340 --> 00:08:16,940
>> కనుక మనం నిజంగా సులభంగా ఒక ప్రేరేపించడానికి కాదు
ఈ స్పష్టంగా ఈ segfault, కానీ

184
00:08:16,940 --> 00:08:18,600
నేను కోరుకున్న ప్రవర్తనను కాదు.

185
00:08:18,600 --> 00:08:19,800
సో సాధారణ పరిష్కారం ఏమిటి?

186
00:08:19,800 --> 00:08:25,650
బాగా, scanf-2 లో, నాకు ప్రతిపాదించారు అనుమతించే
బదులుగా నిజానికి ఒక కేటాయించడం

187
00:08:25,650 --> 00:08:30,100
చార్ *, నాకు కొద్దిగా తెలివిగా గురించి తెలపండి
ఈ, మరియు నాకు బఫర్ కేటాయించుటకు వీలు

188
00:08:30,100 --> 00:08:32,940
16 అక్షరాలు యొక్క ఒక క్రమంలో.

189
00:08:32,940 --> 00:08:34,200
>> నేను మార్గాలు ఈ చేయవచ్చు.

190
00:08:34,200 --> 00:08:35,610
నేను ఖచ్చితంగా malloc ఉపయోగించవచ్చు.

191
00:08:35,610 --> 00:08:38,980
కానీ నేను వారం రెండు వెళ్లవచ్చు ఉన్నప్పుడు
నేను ఒక మొత్తం బంచ్ అవసరం

192
00:08:38,980 --> 00:08:39,620
అక్షరాలు.

193
00:08:39,620 --> 00:08:40,860
అది ఒక అర్రే యొక్క.

194
00:08:40,860 --> 00:08:44,870
సో నాకు బదులుగా బఫర్ పునర్నిర్వచించటానికి వీలు
16 అక్షరాల యొక్క శ్రేణి ఉండాలి.

195
00:08:44,870 --> 00:08:47,340
>> మరియు ఇప్పుడు, నేను లో బఫర్ పాస్ -

196
00:08:47,340 --> 00:08:49,940
మరియు ఈ మేము ఏదో ఉంది
వారం రెండు గురించి మాట్లాడటానికి -

197
00:08:49,940 --> 00:08:53,730
కానీ మీరు ఒక వ్యూహం చికిత్స చేయవచ్చు
అది ఒక చిరునామా యొక్క అయితే.

198
00:08:53,730 --> 00:08:56,390
మేము చూసిన సాంకేతికంగా, వారు ఉన్నాము
కొంత భిన్నమైనది.

199
00:08:56,390 --> 00:09:01,290
మీరు పాస్ అయితే scanf చూసుకొని లేదు
ఒక అర్రే యొక్క పేరు, ఎందుకంటే ఏమి

200
00:09:01,290 --> 00:09:05,030
మాకు ఖచ్చితంగా ఉంది గణగణమని ద్వని చేయు చేస్తాను
ఆ శ్రేణి పేరు చికిత్స

201
00:09:05,030 --> 00:09:08,280
16 బైట్లు భాగం యొక్క చిరునామా.

202
00:09:08,280 --> 00:09:09,550
>> సో ఈ ఉత్తమం.

203
00:09:09,550 --> 00:09:12,110
ఈ ఇప్పుడు నేను ఆశాజనక అంటే
క్రింది వాటిని.

204
00:09:12,110 --> 00:09:16,800
నాకు ఒక క్షణం దూరంగా లెట్ మరియు
OK సంకలనం scanf-2, ఉందని.

205
00:09:16,800 --> 00:09:19,390
ఇప్పుడు నాకు స్లాష్ scanf-2 వచ్చింది మనం.

206
00:09:19,390 --> 00:09:22,430
స్ట్రింగ్ దయచేసి. "హలో." మరియు అది
ఈ సమయం పని కనిపించింది.

207
00:09:22,430 --> 00:09:26,020
>> కానీ ఎవరైనా ఒక సందర్భంలో ప్రతిపాదించారు చేయవచ్చు
దీనిలో అది ఇప్పటికీ పనిచేయదు?

208
00:09:26,020 --> 00:09:28,550
అవును?

209
00:09:28,550 --> 00:09:30,640
16 అక్షరాల కంటే ఎక్కువ ఏదో.

210
00:09:30,640 --> 00:09:32,020
మరియు వాస్తవానికి, మేము చేయవచ్చు
కొద్దిగా ఎక్కువ ఖచ్చితమైన.

211
00:09:32,020 --> 00:09:36,540
ఇక అప్పుడు 15 అక్షరాలు ఏదో,
మేము గుర్తుంచుకోండి అవసరం ఎందుకంటే

212
00:09:36,540 --> 00:09:39,920
మేము ఆ బాక్ స్లాష్ సున్నా అవసరమైన
పరిపూర్ణంగా స్ట్రింగ్ ముగింపులో,

213
00:09:39,920 --> 00:09:42,950
ఇది ఒక ప్రక్కన scanf సాధారణంగా ఉంటుంది
మాకు యొక్క జాగ్రత్తగా ఉండు.

214
00:09:42,950 --> 00:09:46,210
>> సో నాకు ఏదో తెలియజేసేలా -

215
00:09:46,210 --> 00:09:48,040
కొన్నిసార్లు మేము కేవలం చెయ్యవచ్చు
ఆ వంటి వదిలి.

216
00:09:48,040 --> 00:09:50,630
OK, కాబట్టి మేము ఇప్పుడు ప్రేరిత చేసిన
మా విభజన లోపంగా.

217
00:09:50,630 --> 00:09:51,000
ఎందుకు?

218
00:09:51,000 --> 00:09:54,940
నేను కంటే ఎక్కువ 15 కు టైప్ ఎందుకంటే
అక్షరాలు, అందువలన మేము నిజానికి చేసిన

219
00:09:54,940 --> 00:09:58,280
తాకిన జ్ఞప్తి నేను నిజానికి
లేదు.

220
00:09:58,280 --> 00:10:00,180
>> సో వాట్ నిజంగా ఇక్కడ పరిష్కారం ఏమిటి?

221
00:10:00,180 --> 00:10:02,210
బాగా, మేము ఒక పొడవైన స్ట్రింగ్ ఏమి అవసరం ఉంటే?

222
00:10:02,210 --> 00:10:03,960
బాగా, మేము దీనికి 32 బైట్లు తయారు.

223
00:10:03,960 --> 00:10:05,160
బాగా, ఏమి దీర్ఘ చాలదు ఉంటే?

224
00:10:05,160 --> 00:10:06,040
ఎలా 64 బైట్లు?

225
00:10:06,040 --> 00:10:07,080
ఏమి కాలం తగినంత కాదు ఉంటే?

226
00:10:07,080 --> 00:10:09,640
ఎలా 128 గురించి లేదా 200 బైట్లు?

227
00:10:09,640 --> 00:10:12,660
ఏమి నిజంగా ఇక్కడ పరిష్కారం
సాధారణ సందర్భంలో, మేము మాకు లేకపోతే

228
00:10:12,660 --> 00:10:14,460
యూజర్ టైప్ జరగబోతోంది ఏమి ముందుకు?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> ఇది గాడిద ఒక పెద్ద నొప్పి చూస్తూ ఉంటాము
నిజాయితీ ఉండాలి, ఇది ఎందుకు

231
00:10:23,050 --> 00:10:29,050
CS50 లైబ్రరీ యొక్క కొన్ని డజన్ల పంక్తులు ఉంది
సమిష్టిగా అమలు చేసే కోడ్

232
00:10:29,050 --> 00:10:32,390
మేము చేయలేని విధంగా స్ట్రింగ్ GetString
ముందుగానే తెలుసు ఏమి

233
00:10:32,390 --> 00:10:33,430
యూజర్ టైపు కానుంది.

234
00:10:33,430 --> 00:10:37,370
ముఖ్యంగా, మీరు తిరిగి చూడండి
cs50.c రెండు వారాల క్రితం నుండి, మీరు చూస్తారు

235
00:10:37,370 --> 00:10:40,480
ఆ GetString నిజానికి చేస్తుంది
ఈ విధంగా scanf ఉపయోగించదు.

236
00:10:40,480 --> 00:10:43,720
అయితే, ఇది ఒక పాత్ర చదువుతుంది
ఒక సమయంలో.

237
00:10:43,720 --> 00:10:46,010
>> ఎందుకంటే గురించి ఒక nice విషయం
ఒక పాత్ర చదివే మేము ఉంది

238
00:10:46,010 --> 00:10:48,490
ఎల్లప్పుడూ కు మేమే హామీ
కనీసం ఒక చార్ కలిగి.

239
00:10:48,490 --> 00:10:51,740
నేను పడుతుంది అప్పుడు ఒక చార్ డిక్లేర్, మరియు చేయవచ్చు
కేవలం ఈ నిజంగా శిశువు దశలు

240
00:10:51,740 --> 00:10:54,380
ఒక వద్ద ఒక పాత్ర చదవండి
కీబోర్డ్ నుండి సమయం.

241
00:10:54,380 --> 00:10:58,240
ఆపై, మీరు GetString చూస్తారు
చేస్తుంది, ఇది సహకరించదు ప్రతి సమయం

242
00:10:58,240 --> 00:11:02,280
మెమరీ 16 బైట్లు చెప్పటానికి, అది ఉపయోగిస్తుంది
malloc, లేదా ఒక బంధువు వాటి కు

243
00:11:02,280 --> 00:11:06,810
పాత కాపీ, మరింత మెమరీని కేటాయించాల్సిన
అప్పుడు కొత్త, మరియు క్రాల్ లోకి మెమరీ

244
00:11:06,810 --> 00:11:09,900
పాటు, ఒక సమయంలో ఒక పాత్ర పొందడానికి
ఆ సహకరించదు ఉన్నప్పుడు

245
00:11:09,900 --> 00:11:13,370
మెమరీ భాగం,, ఆక్రమణలకు స్వస్తి దూరంగా విసురుతాడు
మెమరీ పెద్ద భాగం, పాత కాపీ

246
00:11:13,370 --> 00:11:14,750
కొత్త, మరియు రిపీట్స్ లోకి.

247
00:11:14,750 --> 00:11:18,480
మరియు అది నిజానికి నిజమైన నొప్పి వార్తలు
సాధారణ ఏదో అమలు

248
00:11:18,480 --> 00:11:19,710
ఒక వినియోగదారు నుండి ఇన్పుట్ పొందడానికి.

249
00:11:19,710 --> 00:11:21,090
>> సో మీరు scanf ఉపయోగించవచ్చు.

250
00:11:21,090 --> 00:11:22,430
మీరు ఇతర ఇదేవిధమైన విధులను ఉపయోగించవచ్చు.

251
00:11:22,430 --> 00:11:25,420
మరియు ఒక పాఠ్య పుస్తకాలు చాలా మరియు ఆన్లైన్
ఉదాహరణలు, కానీ వారు ఉన్నాము

252
00:11:25,420 --> 00:11:27,210
ఈ వంటి సమస్యలు దెబ్బతింది.

253
00:11:27,210 --> 00:11:29,550
చివరకు, ఒక segfault విధానం
రకం బాధించే ఉంది.

254
00:11:29,550 --> 00:11:30,680
ఇది వినియోగదారు కోసం మంచి కాదు.

255
00:11:30,680 --> 00:11:33,560
>> కానీ చెత్త సందర్భంలో, దేనిని
ఇది ప్రాథమికంగా మీ చాలు

256
00:11:33,560 --> 00:11:37,160
ప్రమాదం వద్ద కోడ్?

257
00:11:37,160 --> 00:11:39,250
దాడి రకమైన, సమర్థవంతంగా.

258
00:11:39,250 --> 00:11:41,680
మేము అటువంటి దాడి గురించి మాట్లాడారు -
స్టాక్ నిండిన.

259
00:11:41,680 --> 00:11:44,660
కానీ సాధారణంగా, మీరు అనుమతి చేస్తుంటే
ఓవర్ఫ్లో ఒక బఫర్, వంటి మేము ఒక చేసాడు

260
00:11:44,660 --> 00:11:48,070
కేవలం రాసే క్రితం వారాల జంట,
మరింత స్టాక్ న "హలో" కంటే, మీరు

261
00:11:48,070 --> 00:11:52,330
నిజానికి ఒక, సమర్థవంతమైన, ఆక్రమిస్తాయి
కంప్యూటర్, లేదా కనీసం డేటా వద్ద పొందుటకు

262
00:11:52,330 --> 00:11:53,510
మీకు సంబంధించినది కాదు.

263
00:11:53,510 --> 00:11:55,970
>> మేము ఎందుకు అలా చిన్న లో, ఈ ఉంది
ఆ శిక్షణ చక్రాలు.

264
00:11:55,970 --> 00:11:59,090
కానీ ఇప్పుడు, మేము, వాటిని ఆఫ్ మొదలయ్యాయి
మా కార్యక్రమాలు ఇకపై అవసరం,

265
00:11:59,090 --> 00:12:00,610
యూజర్ నుండి తప్పనిసరిగా, ఇన్పుట్.

266
00:12:00,610 --> 00:12:03,960
కానీ సమస్య విషయంలో, ఆరు సెట్
మీ ఇన్పుట్ భారీ నుండి వస్తాయి

267
00:12:03,960 --> 00:12:07,520
150 తో నిఘంటువు ఫైలు కొన్ని
బేసి వేల పదాలు.

268
00:12:07,520 --> 00:12:10,330
>> సో మీరు గురించి ఆందోళన చెందనవసరం లేదు
యూజర్ యొక్క అనియత ఇన్పుట్.

269
00:12:10,330 --> 00:12:13,720
మేము మీరు కొన్ని ఊహలు ఇస్తుంది
ఫైల్ గురించి.

270
00:12:13,720 --> 00:12:20,340
గమనికలు లేదా scanf ఏ ప్రశ్నలు
లేదా సాధారణంగా వినియోగదారు ఇన్పుట్?

271
00:12:20,340 --> 00:12:24,450
>> అన్ని కుడి, కాబట్టి ఒక వద్ద అప్పుడు ఒక త్వరిత వీక్షణ
రెండు వారాల క్రితం నుండి అంశం వెనుకంజలో.

272
00:12:24,450 --> 00:12:28,590
మరియు ఒక struct ఈ భావన.

273
00:12:28,590 --> 00:12:34,180
కాదు - ఒక ఈ భావన
ఏమి ఇది, struct?

274
00:12:34,180 --> 00:12:35,430
Struct మాకు ఏమి లేదు?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> నిర్వచించండి -

277
00:12:39,860 --> 00:12:41,710
క్షమించండి?

278
00:12:41,710 --> 00:12:42,820
ఒక వేరియబుల్ రకం నిర్వచించండి.

279
00:12:42,820 --> 00:12:44,410
సో క్రమం యొక్క.

280
00:12:44,410 --> 00:12:46,180
మేము నిజానికి రెండు విషయాలు కలపడం చేస్తున్నారు.

281
00:12:46,180 --> 00:12:49,510
Typedef కలిగిన, ఆ మేము గుర్తు
ఒక వంటి, మా సొంత రకం డిక్లేర్

282
00:12:49,510 --> 00:12:51,500
చార్ * కోసం స్ట్రింగ్ వంటి పర్యాయపదంగా.

283
00:12:51,500 --> 00:12:56,200
కానీ typedef మరియు struct ఉపయోగించి, మేము
నిజంగా మా సొంత డేటా నిర్మాణాలు సృష్టించడానికి.

284
00:12:56,200 --> 00:12:59,600
>> ఉదాహరణకు, నేను తిరిగి వెళ్ళి ఉంటే gedit లోకి
ఇక్కడ కేవలం ఒక క్షణం, నేను ముందుకు వెళ్ళి

285
00:12:59,600 --> 00:13:08,230
మరియు ఏదో ఇష్టం, నాకు సేవ్ చేసేలా
ఈ, structs.c, యొక్క చెప్పటానికి వీలు

286
00:13:08,230 --> 00:13:10,840
తాత్కాలికంగా, నేను వెళుతున్నాను
ముందుకు వెళ్ళి చేర్చడానికి

287
00:13:10,840 --> 00:13:14,360
standardio.h, Int ప్రధాన శూన్యమైన.

288
00:13:14,360 --> 00:13:18,960
ఆపై ఇక్కడ, నేను మీరు అనుకుంటే
నిల్వ ఒక ప్రోగ్రామ్ను రాయడం

289
00:13:18,960 --> 00:13:21,840
బహుళ నుండి బహుళ విద్యార్థులు
ఇళ్ళు, ఉదాహరణకు.

290
00:13:21,840 --> 00:13:24,430
కనుక ఇది ఒక registrarial వంటిది
కొంత డేటాబేస్.

291
00:13:24,430 --> 00:13:29,550
>> నేను పేరు ఒక విద్యార్థి అవసరం కనుక, నేను
, చార్ * పేరు వంటి ఏదో ఉండవచ్చు

292
00:13:29,550 --> 00:13:31,570
మరియు నేను ఏదో చేస్తాను -

293
00:13:31,570 --> 00:13:34,410
నిజానికి, యొక్క CS50 లైబ్రరీ ఉపయోగించడానికి అనుమతిస్తున్నట్లు
కేవలం ఒక క్షణం ఈ ఒక చేయడానికి

294
00:13:34,410 --> 00:13:38,380
కొద్దిగా సులభం, కాబట్టి మేము తీసుకోగలగడంతో
లైన్స్ ఆఫ్ కోడ్ ఆ డజన్ల కొద్దీ.

295
00:13:38,380 --> 00:13:39,340
మరియు లెట్ అది సాధారణ ఉంచండి లో.

296
00:13:39,340 --> 00:13:42,610
మేము అది స్ట్రింగ్ ఉంటాం
మరియు ఇప్పుడు GetString.

297
00:13:42,610 --> 00:13:47,420
>> సో నేను పేరు నిల్వ చేసిన ఇప్పుడు క్లెయిమ్
కొన్ని విద్యార్ధి, మరియు హౌస్ ఆఫ్

298
00:13:47,420 --> 00:13:50,240
కేవలం వేరియబుల్ ఉపయోగించి కొన్ని విద్యార్ధి,
మేము వారంలో ఒక. వంటి

299
00:13:50,240 --> 00:13:52,370
కానీ ఇప్పుడు మద్దతు అనుకుంటున్నారా ఊహించు
బహుళ విద్యార్థులు.

300
00:13:52,370 --> 00:13:58,460
అన్ని కుడి, నా ప్రవృత్తులు చేయాలని ఉన్నాయి
స్ట్రింగ్ NAME2, GetString, స్ట్రింగ్ గెట్స్

301
00:13:58,460 --> 00:14:01,370
house2 GetString గెట్స్.

302
00:14:01,370 --> 00:14:05,850
ఆపై మా మూడవ విద్యార్థి,
NAME3 GetString చేయండి చేసుకుందాం.

303
00:14:05,850 --> 00:14:09,170
>> అన్ని కుడి, కాబట్టి ఈ ఆశాజనక అద్భుతమైన ఉంది
తెలివితక్కువదని ఇలాంటి మీరు,

304
00:14:09,170 --> 00:14:11,580
ఈ ప్రక్రియ నిజంగా ఎప్పుడూ ఎందుకంటే
ముగించాలి వెళ్తున్నారు, మరియు అది కేవలం వెళుతున్న

305
00:14:11,580 --> 00:14:13,130
నా కోడ్ అధ్వాన్నంగా కనిపించేలా
మరియు అధ్వాన్నంగా మరియు అధ్వాన్నంగా.

306
00:14:13,130 --> 00:14:14,810
కానీ మేము వారం రెండు చాలా ఇది అధిగమించింది.

307
00:14:14,810 --> 00:14:19,450
మా చాలా శుభ్రంగా పరిష్కారం ఏమిటి
మేము బహుళ వేరియబుల్ ఉన్నప్పుడు

308
00:14:19,450 --> 00:14:23,580
అదే డేటా అన్ని సంబంధించిన రకం, కానీ
మేము ఈ దారుణమైన గజిబిజి కోరుకోలేదు

309
00:14:23,580 --> 00:14:26,870
అదే విధమైన పేరున్న చరరాశుల?

310
00:14:26,870 --> 00:14:30,060
మేము బదులుగా ఏమి లేదు?

311
00:14:30,060 --> 00:14:31,260
>> సో నేను కొన్ని ప్రదేశాలలో విన్న అనుకుంటున్నాను.

312
00:14:31,260 --> 00:14:32,590
మేము ఒక అర్రే కలిగి.

313
00:14:32,590 --> 00:14:37,110
మీరు అనేక చోట్ల కావాలా
ఏదో, ఎందుకు మేము ఈ అన్ని శుభ్రం లేదు

314
00:14:37,110 --> 00:14:39,540
అప్ మరియు నాకు ఇవ్వాలని, చెప్పటానికి
అర్రే పేర్లు అని?

315
00:14:39,540 --> 00:14:41,640
>> మరియు ఇప్పుడు కోసం, హార్డ్ కోడ్ 3 వీలు.

316
00:14:41,640 --> 00:14:44,450
ఆపై నాకు మరొక వ్యూహం ఇవ్వాలని
ఇళ్ళు అని, మరియు నాకు వీలు

317
00:14:44,450 --> 00:14:45,800
ప్రస్తుతం హార్డ్ కోడ్ 3.

318
00:14:45,800 --> 00:14:49,220
మరియు నేను గురుతర శుభ్రం చేసిన
నేను సృష్టించిన విసిగిపోకండి.

319
00:14:49,220 --> 00:14:52,400
ఇప్పుడు, నేను ఇప్పటికీ హార్డ్ 3 కోడ్, కానీ చేసిన కూడా
3 డైనమిక్ నుండి వస్తానని

320
00:14:52,400 --> 00:14:54,350
యూజర్, లేదా argv, లేదా ఇష్టపడుతున్నారు.

321
00:14:54,350 --> 00:14:55,720
సో ఈ ఇప్పటికే క్లీనర్ ఉంది.

322
00:14:55,720 --> 00:15:00,100
>> కానీ ఈ గురించి బాధించే వార్తలు ఉంది
ఇప్పుడు, అయినప్పటికీ ఒక పేరు ఏదో ఉంది

323
00:15:00,100 --> 00:15:02,280
ప్రాథమికంగా లింక్
ఒక విద్యార్థి యొక్క house -

324
00:15:02,280 --> 00:15:04,720
ఆ నేను నిజంగా ఒక విద్యార్థి
సూచించడానికి కావలసిన -

325
00:15:04,720 --> 00:15:08,080
నేను ఇప్పుడు సమాంతర రెండు శ్రేణుల కలిగి
వారు ఉన్నట్లు అర్థంలో

326
00:15:08,080 --> 00:15:13,930
అదే పరిమాణం, మరియు పేర్లు బ్రాకెట్ 0
ఇళ్ళు బ్రాకెట్ 0 బహుశా మాన,

327
00:15:13,930 --> 00:15:16,600
మరియు పేర్లు బ్రాకెట్ 1 మాన
గృహాల బ్రాకెట్ 1.

328
00:15:16,600 --> 00:15:19,280
ఇతర మాటలలో, ఆ విద్యార్థి జీవితాలను
ఇల్లు, మరియు ఇతర విద్యార్థి

329
00:15:19,280 --> 00:15:20,530
ఇతర ఇంట్లో జీవితాలను.

330
00:15:20,530 --> 00:15:23,720
కానీ తప్పనిసరిగా ఈ కావచ్చు
మరింత సజావుగా పూర్తి.

331
00:15:23,720 --> 00:15:24,990
>> బాగా, అది, నిజానికి.

332
00:15:24,990 --> 00:15:28,730
మరియు నాకు ముందుకు వెళ్లి తెరవడానికి వీలు
structs.h అప్, మరియు మీరు చేస్తాము

333
00:15:28,730 --> 00:15:31,130
ఇక్కడ ఈ ఆలోచన చూడండి.

334
00:15:31,130 --> 00:15:34,905
మీరు, నేను typedef ఉపయోగించి గమనించవచ్చు
క్రితం డిక్లేర్ ఒక క్షణం పేర్కొన్నట్లు మా

335
00:15:34,905 --> 00:15:35,570
సొంత డేటా రకం.

336
00:15:35,570 --> 00:15:39,660
కానీ నేను కూడా ఈ ఇతర కీవర్డ్ ఉపయోగించి వెబ్
struct అని నాకు ఒక కొత్త ఇస్తుంది

337
00:15:39,660 --> 00:15:40,790
డేటా నిర్మాణం.

338
00:15:40,790 --> 00:15:43,980
>> మరియు నేను క్లెయిమ్ ఈ డేటాను నిర్మాణం కానుంది
లోపలి రెండు విషయాల్లో

339
00:15:43,980 --> 00:15:47,060
అది - పేరు అనే స్ట్రింగ్, మరియు
ఇల్లు అనే స్ట్రింగ్.

340
00:15:47,060 --> 00:15:49,820
మరియు నేను వెళుతున్నాను పేరు ఇవ్వాలని
ఈ డేటాను నిర్మాణం కానుంది

341
00:15:49,820 --> 00:15:51,005
విద్యార్థి అని పిలుస్తారు.

342
00:15:51,005 --> 00:15:54,030
నేను, నేను మీరు ఏదైనా అని పిలుస్తాము
కానీ ఈ పదానికి అర్థ విచారానికి తయారు

343
00:15:54,030 --> 00:15:55,810
నా మనసు నాకు అంటుంది.

344
00:15:55,810 --> 00:15:59,160
>> కాబట్టి ఇప్పుడు, నేను ఒక మంచి వెర్షన్ తెరుచుకుంటుంది ఉంటే
కార్యక్రమం నేను రాయడం మొదలుపెట్టారు

345
00:15:59,160 --> 00:16:00,390
అక్కడ, నాకు టాప్ స్క్రోల్ వీలు.

346
00:16:00,390 --> 00:16:03,190
మరియు కోడ్ కొన్ని పంక్తులు వార్తలు
ఇక్కడ, కానీ నాకు దృష్టి వీలు

347
00:16:03,190 --> 00:16:04,160
ఒక క్షణం.

348
00:16:04,160 --> 00:16:07,790
నేను ఒక స్థిరమైన పిలవబడే విద్యార్థులు డిక్లేర్డ్ చేసిన
మరియు హార్డ్ ఇప్పుడు కోసం 3 కోడ్.

349
00:16:07,790 --> 00:16:11,110
కానీ ఇప్పుడు, గమనించవచ్చు ఎలా శుభ్రంగా
నా కోడ్ పొందడం ప్రారంభిస్తాడు.

350
00:16:11,110 --> 00:16:15,030
>> లైన్ 22 లో, నేను డిక్లేర్
విద్యార్థులు శ్రేణి.

351
00:16:15,030 --> 00:16:18,760
మరియు విద్యార్థి స్పష్టంగా ఉంది అని గుర్తించలేకపోతే
ఇప్పుడు ఒక డేటా రకాన్ని.

352
00:16:18,760 --> 00:16:23,360
ఈ ఫైలు యొక్క పైభాగంలో, గమనించవచ్చు ఎందుకంటే
నేను ఆ శీర్షికా ఫైలును చేర్చాను

353
00:16:23,360 --> 00:16:24,820
నేను ఒక క్షణం క్రితం ఆగింది ఆ.

354
00:16:24,820 --> 00:16:28,820
మరియు ఆ శీర్షికా ఫైలును చాలా కేవలం కలిగి
ఒక విద్యార్థి యొక్క ఈ నిర్వచనం.

355
00:16:28,820 --> 00:16:32,470
>> కాబట్టి ఇప్పుడు, నేను నా స్వంత కస్టమ్ డేటా సృష్టించాను
రకం ఆ C సంవత్సరాల రచయితలు

356
00:16:32,470 --> 00:16:33,890
క్రితం ముందుగానే యొక్క నేను భావించలేదు.

357
00:16:33,890 --> 00:16:34,570
కానీ సమస్య.

358
00:16:34,570 --> 00:16:35,870
నన్ను నేను సమాధానపరుచుకుంటాను చేయవచ్చు.

359
00:16:35,870 --> 00:16:39,050
సో ఈ, విద్యార్థులు అనే శ్రేణి
దీని సభ్యులు ప్రతి

360
00:16:39,050 --> 00:16:41,100
ఒక విద్యార్థి నిర్మాణం.

361
00:16:41,100 --> 00:16:44,270
మరియు నేను ఆ మూడు అనుకుంటున్నారా
అర్రే లో.

362
00:16:44,270 --> 00:16:46,030
>> మరియు ఇప్పుడు, మిగిలిన దేనిని
ఈ కార్యక్రమం యొక్క ఏమి?

363
00:16:46,030 --> 00:16:47,550
నేను కొద్దిగా అనియత ఏదో అవసరం.

364
00:16:47,550 --> 00:16:51,450
సో ఆన్లైన్ 24 నుండి,
నేను 0 నుండి 3 iterate.

365
00:16:51,450 --> 00:16:54,000
నేను వినియోగదారుని అభ్యర్థించడం
విద్యార్థి యొక్క పేరు.

366
00:16:54,000 --> 00:16:56,110
ఆపై నేను ముందు గా GetString ఉపయోగిస్తారు.

367
00:16:56,110 --> 00:16:59,410
అప్పుడు నేను, విద్యార్థి యొక్క హౌస్ గోవా
మరియు నేను ముందు గా GetString ఉపయోగించడానికి.

368
00:16:59,410 --> 00:17:01,780
>> కానీ నోటీసు - కొద్దిగా కొత్త
సింటెక్స్ ముక్క -

369
00:17:01,780 --> 00:17:07,010
నేను, i-వ విద్యార్థి ఇప్పటికీ సూచిక చెయ్యవచ్చు
కానీ నేను నిర్దిష్ట సమాచార ఎలా పొందుటకు లేదు

370
00:17:07,010 --> 00:17:08,354
struct రంగంలో లోపల?

371
00:17:08,354 --> 00:17:11,770
బాగా, స్పష్టంగా ఏమిటి
కొత్త సింటెక్స్ ముక్క?

372
00:17:11,770 --> 00:17:13,339
ఇది కేవలం డాట్ ఆపరేటర్లు వార్తలు.

373
00:17:13,339 --> 00:17:14,510
>> మేము నిజంగా ఈ ముందు చూడని చేసిన.

374
00:17:14,510 --> 00:17:17,819
మీరు మీరు pset ఐదు లో చూసిన
బిట్మ్యాప్ ఫైళ్లు ఇప్పటికే లో dived.

375
00:17:17,819 --> 00:17:22,372
కానీ డాట్ ఈ లోపలి అర్థం
struct లేదా బహుళ ఖాళీలను, డాట్ ఇవ్వాలని

376
00:17:22,372 --> 00:17:24,510
పేరు, లేదా నాకు డాట్ హౌస్ ఇవ్వాలని.

377
00:17:24,510 --> 00:17:28,690
Struct లోపలి వెళ్లి అర్థం
మరియు ఆ నిర్దిష్ట ఖాళీలను పొందుటకు.

378
00:17:28,690 --> 00:17:30,200
>> ఈ కార్యక్రమం యొక్క మిగిలిన ఏమి చేస్తుంది?

379
00:17:30,200 --> 00:17:31,190
ఇది అన్ని ఆ సెక్సీ కాదు.

380
00:17:31,190 --> 00:17:34,640
నేను మళ్ళీ 0 నుండి 3 iterate గమనించవచ్చు,
మరియు నేను కేవలం ఒక ఆంగ్ల సృష్టించడానికి

381
00:17:34,640 --> 00:17:40,500
అదే విధంగా వంటి పదబంధం ఇటువంటి మరియు ఉంది
నుండి డాట్ పేరు లో ప్రయాణిస్తున్న ఒక ఇల్లు,

382
00:17:40,500 --> 00:17:43,320
i-వ విద్యార్థి మరియు వారి
ఇల్లు అలాగే.

383
00:17:43,320 --> 00:17:47,560
>> ఆపై చివరగా, ఇప్పుడు మేము పొందుటకు మొదలు పెడతారేమో
మేము ఇప్పుడు ఈ గురించి అంగ,

384
00:17:47,560 --> 00:17:49,580
ఏ malloc మరియు తెలిసిన
ఇతర విధులు ఉన్నాయి

385
00:17:49,580 --> 00:17:50,570
అన్ని ఈ సమయంలో చేయడం.

386
00:17:50,570 --> 00:17:54,220
ఎందుకు నేను పేరు విముక్తికై కలిగి లేదు
మరియు హౌస్, అయినప్పటికీ నేను

387
00:17:54,220 --> 00:17:56,960
malloc కాల్ లేదు?

388
00:17:56,960 --> 00:17:58,020
>> GetString చేసింది.

389
00:17:58,020 --> 00:18:00,930
మరియు ఆ కోసం మురికి కొద్దిగా రహస్య ఉంది
అనేక వారాల, కానీ GetString ఉంది

390
00:18:00,930 --> 00:18:03,530
అన్ని పైగా మెమరీ రావడం జరిగింది
ఇప్పటివరకు అన్ని సెమిస్టర్ ఉంచండి.

391
00:18:03,530 --> 00:18:05,990
మరియు valgrand చివరకు అవుతుంది
మాకు ఈ బహిర్గతం.

392
00:18:05,990 --> 00:18:10,730
>> నాకు తెలుసు ఎందుకంటే కానీ అది ఒక పెద్ద ఒప్పందం కాదు
నేను కేవలం పేరు విడిపించేందుకు చేసే

393
00:18:10,730 --> 00:18:15,750
మరియు హౌస్, అయితే సాంకేతికంగా, కు
సూపర్, సూపర్ సురక్షితంగా, నేను ఉండాలి

394
00:18:15,750 --> 00:18:17,890
కొన్ని లోపం చేయడం ఇక్కడ తనిఖీ.

395
00:18:17,890 --> 00:18:19,040
మీ కోరికలు నిన్ను ఏమి చెప్పడం ఉంటాయి?

396
00:18:19,040 --> 00:18:22,480
నేను ఏమి తనిఖీ చేయాలి
నేను ఒక ఏమిటి విడిపించేందుకు ముందు

397
00:18:22,480 --> 00:18:25,470
స్ట్రింగ్, ఆక ఇది ఒక చార్ *?

398
00:18:25,470 --> 00:18:33,460
>> నేను నిజంగా తనిఖీ చేయాలి విద్యార్థులు ఉంటే
బ్రాకెట్ i డాట్ పేరు లేదు

399
00:18:33,460 --> 00:18:34,840
సమాన శూన్య.

400
00:18:34,840 --> 00:18:40,400
అప్పుడు ముందుకు మరియు ఉచిత వెళ్ళడానికి OK ఉంటాం
ఆ పాయింటర్, మరియు ఒకేరకమైన లేదా ఇతర

401
00:18:40,400 --> 00:18:41,160
ఒక అదే.

402
00:18:41,160 --> 00:18:46,860
విద్యార్థులు బ్రాకెట్ i డాట్ హౌస్ లేకపోతే
శూన్య సమానంగా, ఈ ఇప్పుడు రక్షించడానికి చేస్తుంది

403
00:18:46,860 --> 00:18:52,520
మూలలో సందర్భంలో వ్యతిరేకంగా దీనిలో
GetString శూన్య వంటి ఏదో తిరిగి.

404
00:18:52,520 --> 00:18:57,310
మరియు మేము printf అవుతుంది, ఒక క్షణం క్రితం చూసింది
కేవలం విధంగా ఇక్కడ మాకు అప్ రక్షించడానికి

405
00:18:57,310 --> 00:18:58,990
నల్, ఇది అసహజ చూడండి కానుంది.

406
00:18:58,990 --> 00:19:02,340
కానీ కనీసం అది segfault కాదు
మేము చూసిన వంటి.

407
00:19:02,340 --> 00:19:05,990
>> బాగా, నాకు ఇక్కడ ఒక ఇతర పనిని తెలపండి.
structs-0 ఒక పెద్ద కార్యక్రమం రకం

408
00:19:05,990 --> 00:19:09,700
నేను అన్ని ఈ డేటాను నమోదు, మరియు ఎందుకంటే
కార్యక్రమం ముగుస్తుంది ఒకసారి కోల్పోయాడు.

409
00:19:09,700 --> 00:19:10,940
కానీ నాకు ముందుకు వెళ్లి ఈ తెలియజేసేలా.

410
00:19:10,940 --> 00:19:12,830
నాకు టెర్మినల్ తయారు చేద్దాము
ఒక బిట్ పెద్ద విండో.

411
00:19:12,830 --> 00:19:17,000
, నాకు structs-1 తయారు చేద్దాము ఇది
ఈ కొత్త వెర్షన్.

412
00:19:17,000 --> 00:19:18,520
>> నేను కొద్దిగా జూమ్ చేస్తాను.

413
00:19:18,520 --> 00:19:21,620
మరియు ఇప్పుడు నాకు డాట్ అమలు తెలపండి
structs-1 స్లాష్.

414
00:19:21,620 --> 00:19:22,590
విద్యార్థి యొక్క పేరు -

415
00:19:22,590 --> 00:19:31,500
డేవిడ్ మాథుర్, రాబ్ కిర్క్ల్యాండ్ చేయండి చేసుకుందాం
లారెన్ Leverett చేయండి చేసుకుందాం.

416
00:19:31,500 --> 00:19:33,650
ఏ ఆసక్తికరంగా ఇప్పుడు ప్రకటన -

417
00:19:33,650 --> 00:19:35,540
మరియు నేను మాత్రమే ఈ ఎందుకంటే తెలుసు
నేను కార్యక్రమం రాశారు -

418
00:19:35,540 --> 00:19:38,930
ఒక ఫైలు నా ప్రస్తుత ఇప్పుడు ఉంది
డైరెక్టరీ students.csv అని.

419
00:19:38,930 --> 00:19:40,420
మీరు కొన్ని చూసిన ఉండవచ్చు
వాస్తవ ప్రపంచంలో ఈ.

420
00:19:40,420 --> 00:19:42,980
>> ఒక CSV ఫైల్ ఏమిటి?

421
00:19:42,980 --> 00:19:44,170
విలువలు కామాతో వేరు.

422
00:19:44,170 --> 00:19:46,670
ఇది ఒక పేదవాని వంటి విధమైన వార్తలు
Excel ఫైల్ యొక్క వెర్షన్.

423
00:19:46,670 --> 00:19:50,580
ఇది వరుసలు మరియు కాలమ్లను ఒక పట్టిక వార్తలు
మీరు, Excel వంటి ప్రోగ్రామ్ తెరుస్తుంది

424
00:19:50,580 --> 00:19:51,800
ఒక Mac లేదా సంఖ్యలు.

425
00:19:51,800 --> 00:19:55,180
>> మరియు నేను gedit ఇక్కడ ఈ ఫైల్ను తెరవడం ఉంటే,
నోటీసు - మరియు సంఖ్యలు లేవు.

426
00:19:55,180 --> 00:19:57,360
అది చెప్పడం gedit యొక్క
నాకు లైన్ సంఖ్యలు.

427
00:19:57,360 --> 00:19:59,740
ఈ మొదటి పంక్తిలో గమనించండి
ఫైలు డేవిడ్ మరియు మాథుర్ ఉంది.

428
00:19:59,740 --> 00:20:01,450
తదుపరి లైన్ రాబ్ కామా కిర్క్ల్యాండ్ ఉంది.

429
00:20:01,450 --> 00:20:04,170
మరియు మూడవ లైన్ లారెన్ ఉంది
కామా Leverett.

430
00:20:04,170 --> 00:20:05,480
>> సో నేను సృష్టించిన?

431
00:20:05,480 --> 00:20:09,580
నేను ఇప్పుడు ఒక సి కార్యక్రమం వ్రాసిన చేసిన
సమర్థవంతంగా స్ప్రెడ్షీట్లు రూపొందించవచ్చు

432
00:20:09,580 --> 00:20:11,840
ఒక లో తెరవవచ్చు
Excel వంటి కార్యక్రమ.

433
00:20:11,840 --> 00:20:15,520
అన్ని ఉందనేందుకు ఒక డేటా సెట్, కానీ
మీరు చాలా పెద్ద రాళ్లను కలిగి ఉంటే

434
00:20:15,520 --> 00:20:18,440
మీరు నిజంగానే మీరు డేటా
రెట్టింపు మరియు గ్రాఫ్లు మరియు తయారు

435
00:20:18,440 --> 00:20:21,260
ఇష్టం, ఈ బహుశా ఒకటి
ఆ డేటా మార్గం.

436
00:20:21,260 --> 00:20:25,370
అంతేకాక, CSVs సాధారణ నిజానికి సూపర్ ఉన్నాయి
కేవలం సాధారణ డేటా నిల్వ కోసం -

437
00:20:25,370 --> 00:20:28,940
యాహూ ఫైనాన్స్, ఉదాహరణకు, మీరు పొందుటకు ఉంటే
వారి అని పిలవబడే ద్వారా స్టాక్ కోట్స్

438
00:20:28,940 --> 00:20:33,180
API, మీరు అనుమతించే ఉచిత సేవ
ప్రస్తుత అప్ టు డేట్ స్టాక్ పొందుటకు

439
00:20:33,180 --> 00:20:35,650
కంపెనీలకు కోట్స్, వారు
తిరిగి లో డేటా ఇవ్వాలని

440
00:20:35,650 --> 00:20:37,800
సూపర్ సాధారణ CSV ఫార్మాట్.

441
00:20:37,800 --> 00:20:39,380
>> కనుక మనం ఎలా చేస్తారు?

442
00:20:39,380 --> 00:20:42,530
బాగా, ఈ కార్యక్రమం యొక్క అత్యంత గమనించవచ్చు
దాదాపు అదే.

443
00:20:42,530 --> 00:20:46,870
కానీ ఇక్కడ డౌన్ గమనించవచ్చు కాకుండా ముద్రణ
లైన్ 35 న విద్యార్థులు అవ్ట్,

444
00:20:46,870 --> 00:20:51,040
తరువాత, నేను సేవ్ వెబ్ వాదించారు
డిస్కునకు విద్యార్థులు, కాబట్టి ఒక ఫైల్ సేవ్.

445
00:20:51,040 --> 00:20:53,630
>> నేను ఒక ఫైల్ * ప్రకటించారు వెబ్ గమనించవచ్చు -

446
00:20:53,630 --> 00:20:57,260
ఇప్పుడు, ఈ C. ఒక అసాధారణ విధమైన
ఏ కారణం చేతనైనా సరే, FILE, అన్ని పరిమితులను ఉంది

447
00:20:57,260 --> 00:21:00,690
ఇది అనేక ఇతర డేటా రకాలుగా కాదు
సి లో అయితే ఇది ఒక అంతర్నిర్మిత

448
00:21:00,690 --> 00:21:02,320
డేటా రకం, FILE *.

449
00:21:02,320 --> 00:21:05,900
మరియు నేను ఒక ఫైల్ కు ఒక పాయింటర్ ప్రకటించారు వెబ్
మీరు భావించి ఎలా ఉంది.

450
00:21:05,900 --> 00:21:08,070
>> fopen ఓపెన్ ఫైలు అర్థం.

451
00:21:08,070 --> 00:21:09,470
మీరు ఏమి ఫైలు తెరవడానికి అనుకుంటున్నారు?

452
00:21:09,470 --> 00:21:12,620
నేను ఒక ఫైల్ తెరవాలనుకుంటున్నారా రెడీ అని
ఏకపక్ష students.csv కాల్.

453
00:21:12,620 --> 00:21:14,480
నేను కావలసిన ఏదైనా అని పిలుస్తాము.

454
00:21:14,480 --> 00:21:15,200
>> ఆపై ఒక అంచనా పడుతుంది.

455
00:21:15,200 --> 00:21:18,960
రెండవ వాదన వేటికి
fopen బహుశా అర్థం?

456
00:21:18,960 --> 00:21:21,480
కుడి, write కోసం w, అనుకొనుట
రీడ్ కోసం r ఉంటుంది.

457
00:21:21,480 --> 00:21:24,120
ఒక append కోసం ఉంది మీరు
వరుసలు మరియు జోడించాలనుకుంటే

458
00:21:24,120 --> 00:21:25,200
మొత్తం విషయం తిరిగి రాస్తుంది.

459
00:21:25,200 --> 00:21:28,005
>> కానీ నేను ఈ ఫైలు సృష్టించాలనుకునే
ఒకసారి, నేను కోట్ unquote w ఉపయోగిస్తాము.

460
00:21:28,005 --> 00:21:31,880
మరియు నేను కలిగి నుండి మాత్రమే తెలుసు
డాక్యుమెంటేషన్, లేదా వ్యక్తి పేజీ.

461
00:21:31,880 --> 00:21:35,100
ఫైలు శూన్య లేకపోతే - ఇతర పదాలు లో,
ఏమీ తప్పు ఉంటే -

462
00:21:35,100 --> 00:21:37,820
నేను iterate వీలు
0 నుండి 3 విద్యార్థులు.

463
00:21:37,820 --> 00:21:40,410
>> మరియు ఇప్పుడు ఏదో గమనించవచ్చు
ఇంత కొద్దిగా వివిధ

464
00:21:40,410 --> 00:21:42,110
ఇక్కడ గురించి లైన్ 41.

465
00:21:42,110 --> 00:21:42,960
ఇది printf కాదు.

466
00:21:42,960 --> 00:21:46,530
ఇది printf ఫైలు కోసం fprintf వార్తలు.

467
00:21:46,530 --> 00:21:47,790
కనుక ఇది ఫైల్కు వ్రాయడం అవకాశముంది.

468
00:21:47,790 --> 00:21:48,860
ఏ ఫైల్?

469
00:21:48,860 --> 00:21:53,630
దీని పాయింటర్ మీరు పేర్కొన్న ఒక
మొదటి వాదన వంటి.

470
00:21:53,630 --> 00:21:55,940
>> అప్పుడు మేము ఒక ఫార్మాట్ స్ట్రింగ్ పేర్కొనండి.

471
00:21:55,940 --> 00:21:59,660
అప్పుడు మేము ఏమి పదాన్ని సూచించండి
మొదటి శాతం s కోసం ప్లగ్, మరియు

472
00:21:59,660 --> 00:22:04,320
అప్పుడు మరొక వేరియబుల్ లేదా
రెండవ శాతం లు.

473
00:22:04,320 --> 00:22:06,760
అప్పుడు మేము fclose ఫైల్ ముగించలేదు.

474
00:22:06,760 --> 00:22:09,380
నేను అయితే, ముందు మెమరీ విడిపించేందుకు కంటే
నేను తిరిగి వెళ్లి జోడించండి ఉండాలి

475
00:22:09,380 --> 00:22:10,540
శూన్య కోసం కొన్ని తనిఖీలను.

476
00:22:10,540 --> 00:22:12,090
>> అంతే.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf, fclose నాకు ఇస్తుంది
టెక్స్ట్ ఫైళ్లు సృష్టించడానికి సామర్ధ్యం.

478
00:22:16,960 --> 00:22:19,640
ఇప్పుడు, మీరు, ప్రాబ్లం సెట్ ఐదు చూస్తారు
చిత్రాలు ఉండే, మీరు ఉపయోగిస్తున్న అవుతారు

479
00:22:19,640 --> 00:22:20,990
బైనరీ ఫైళ్ళను బదులుగా.

480
00:22:20,990 --> 00:22:24,200
కానీ ప్రాథమికంగా, ఆలోచన, అదే ఉంది
అయినప్పటికీ మీరు చేస్తాము విధులు

481
00:22:24,200 --> 00:22:28,710
కొద్దిగా భిన్నంగా ఉంటాయి చూడండి.

482
00:22:28,710 --> 00:22:32,580
>> సుడిగాలి పర్యటన సో, కానీ మీరు పొందుతారు
ఫైలు అన్ని చాలా తెలిసిన I/O--

483
00:22:32,580 --> 00:22:34,960
ఇన్పుట్ మరియు అవుట్పుట్ - pset ఐదు తో.

484
00:22:34,960 --> 00:22:38,607
మరియు గురించి ఏవైనా ప్రశ్నలు
ఇక్కడ ప్రారంభ బేసిక్స్?

485
00:22:38,607 --> 00:22:39,857
అవును?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> మీరు ఒక శూన్య విలువను విముక్తికై ప్రయత్నించండి ఉంటే?

488
00:22:43,710 --> 00:22:48,880
ఉచిత ఒక సంపాదించిన చేసింది తప్ప, నమ్మకం
కొంచం user-friendly, మీరు చేయవచ్చు

489
00:22:48,880 --> 00:22:49,890
శక్తివంతమైన segfault.

490
00:22:49,890 --> 00:22:54,160
నాదగ్గర ఎందుకంటే శూన్యం ప్రయాణిస్తున్న చెడు
ఉచిత నమ్మకం, మీరు కోసం తనిఖీ bothers

491
00:22:54,160 --> 00:22:57,330
ఇది సమర్ధంగా ఒక వ్యర్థాలు ఉంటుంది ఎందుకంటే
అది కూడా చేయాలని సమయం

492
00:22:57,330 --> 00:22:59,022
ప్రపంచంలో ప్రతి ఒక్కరూ.

493
00:22:59,022 --> 00:23:00,590
మంచి ప్రశ్న, అయితే.

494
00:23:00,590 --> 00:23:04,300
>> అన్ని కుడి, ఈ రకమైన గెట్స్ కాబట్టి
మాకు ఒక ఆసక్తికరమైన అంశం.

495
00:23:04,300 --> 00:23:07,010
సమస్య సెట్ థీమ్
ఐదు ఫోరెన్సిక్స్ ఉంది.

496
00:23:07,010 --> 00:23:08,420
కనీసం ఒక భాగం యొక్క
సమస్య సెట్.

497
00:23:08,420 --> 00:23:12,030
ఫోరెన్సిక్స్ సాధారణంగా సూచిస్తుంది
మే లేదా సమాచారాన్ని రికవరీ

498
00:23:12,030 --> 00:23:14,110
తొలగించబడ్డాయి పోవచ్చు
ఉద్దేశపూర్వకంగా.

499
00:23:14,110 --> 00:23:18,680
అందువలన నేను మీరు త్వరగా ఇవ్వాలని ఇష్టం ఆలోచన
ఏమి రుచి నిజంగా అన్ని జరుగుతుందో

500
00:23:18,680 --> 00:23:21,230
క్రింద ఈ సమయం
మీ కంప్యూటర్ యొక్క హుడ్.

501
00:23:21,230 --> 00:23:23,960
>> ఉదాహరణకు, మీరు లోపల కలిగి ఉంటే మీ యొక్క
ల్యాప్టాప్ లేదా మీ డెస్క్టాప్ కంప్యూటర్

502
00:23:23,960 --> 00:23:28,040
హార్డు డ్రైవు, అది ఒక యాంత్రిక వార్తలు
నిజానికి తిప్పే పరికరం -

503
00:23:28,040 --> 00:23:31,650
platters అని వృత్తాకార విషయాలను
చాలా ఆ కనిపిస్తుంది నేను

504
00:23:31,650 --> 00:23:34,540
కేవలం అయితే, ఇక్కడ స్క్రీన్ మీద ఉంది
ఈ పెరుగుతున్న పాత పాఠశాల.

505
00:23:34,540 --> 00:23:37,370
ఈ మూడు మరియు-a-సగం అంగుళాల ఉంది
హార్డు డ్రైవు.

506
00:23:37,370 --> 00:23:40,070
మరియు మూడు మరియు ఒక అర్ధ అంగుళాలు యొక్క సూచిస్తుంది
మీరు ఇన్స్టాల్ చేసినప్పుడు విషయం తో

507
00:23:40,070 --> 00:23:40,890
ఒక కంప్యూటర్ లో.

508
00:23:40,890 --> 00:23:44,890
>> ఇప్పుడు మీ ల్యాప్టాప్లో మీరు అనేక అబ్బాయిలు
, సాలిడ్ స్టేట్ డ్రైవ్, లేదా SSDs కలిగి

509
00:23:44,890 --> 00:23:46,260
ఇది కదిలే భాగాలను లేవు.

510
00:23:46,260 --> 00:23:49,170
వారు RAM వంటి మరింత మరియు తక్కువ లాగ ఉన్నాము
ఈ యాంత్రిక పరికరాలు.

511
00:23:49,170 --> 00:23:51,450
కానీ ఆలోచనలు, ఇప్పటికీ ఒకటే
ఖచ్చితంగా వారు సంబంధించి

512
00:23:51,450 --> 00:23:52,790
సమస్య ఐదు సెట్.

513
00:23:52,790 --> 00:23:57,400
>> మరియు మీరు ఒక హార్డ్ డ్రైవ్ ప్రస్తుతం సుమారు అనుకుంటే
ఇది ఒక వృత్తం, ఉండటం ప్రాతినిధ్యం

514
00:23:57,400 --> 00:23:58,930
నేను ఇక్కడ ఇలా డ్రా చేస్తాము.

515
00:23:58,930 --> 00:24:02,290
మీరు, మీ కంప్యూటర్లో ఒక ఫైలు రూపొందించినప్పుడు
అది ఒక SSD, లేదా లో లేదో

516
00:24:02,290 --> 00:24:06,610
ఈ సందర్భంలో, పాత పాఠశాల హార్డు డ్రైవు,
ఫైల్ బహుళ బిట్స్ ఉన్నాయి.

517
00:24:06,610 --> 00:24:10,510
యొక్క ఈ 0 మరియు 1 అని చెప్పటానికి వీలు,
0 సె మరియు 1s యొక్క మొత్తం బంచ్.

518
00:24:10,510 --> 00:24:11,660
సో ఈ నా మొత్తం హార్డ్ డ్రైవ్.

519
00:24:11,660 --> 00:24:13,225
ఈ స్పష్టంగా ఒక అందమైన పెద్ద ఫైలు.

520
00:24:13,225 --> 00:24:18,080
మరియు ఆ వద్ద 0 సె మరియు 1s అప్ ఉపయోగిస్తోంది
భౌతిక పళ్ళెం యొక్క భాగం.

521
00:24:18,080 --> 00:24:19,750
>> బాగా, భౌతిక భాగం ఏమిటి?

522
00:24:19,750 --> 00:24:25,310
బాగా, అది ఒక హార్డ్ డ్రైవ్ ఆ హాజరవుతారు
ఈ రకం కనీసం, ఉంది

523
00:24:25,310 --> 00:24:27,340
ఈ చిన్న చిన్న అయస్కాంత అణువులు.

524
00:24:27,340 --> 00:24:32,630
మరియు అవి చాలా ఉత్తర మరియు
వారికి దక్షిణ ధ్రువాలు, తద్వారా మీరు

525
00:24:32,630 --> 00:24:35,710
ఆ అయస్కాంత అణువులు ఒకటి చెయ్యి
ఈ విధంగా, మీరు అది చెప్పుకునే

526
00:24:35,710 --> 00:24:36,720
ఒక 1 ప్రాతినిధ్యం.

527
00:24:36,720 --> 00:24:39,340
మరియు అది తలక్రిందులుగా దక్షిణాన ఉంటే
ఉత్తర, మీరు అది చెప్పుకునే

528
00:24:39,340 --> 00:24:40,390
ఒక 0 ప్రాతినిధ్యం.

529
00:24:40,390 --> 00:24:43,660
>> సో నిజమైన భౌతిక ప్రపంచం లో, ఆ
మీరు ఏదో ప్రాతినిధ్యం వహిస్తుంది ఎలా

530
00:24:43,660 --> 00:24:45,670
బైనరీ 0 రాష్ట్ర మరియు ఒక 1.

531
00:24:45,670 --> 00:24:46,720
తద్వారా అన్ని ఫైలు యొక్క.

532
00:24:46,720 --> 00:24:49,300
అయస్కాంత యొక్క మొత్తం బంచ్ ఉంది
వారి ఈ విధంగా లేదా అని కణాలు

533
00:24:49,300 --> 00:24:51,920
ఈ విధంగా, సృష్టించడం నమూనాలను
యొక్క 0s మరియు 1s.

534
00:24:51,920 --> 00:24:56,760
>> కానీ, మీరు ఒక ఫైల్ సేవ్ చేసినప్పుడు హాజరవుతారు
కొన్ని సమాచారం విడివిడిగా సేవ్ చేయబడుతుంది.

535
00:24:56,760 --> 00:25:00,000
సో ఈ, కొద్దిగా పట్టిక ఉంది
ఒక డైరెక్టరీ మాట్లాడటానికి.

536
00:25:00,000 --> 00:25:05,810
మరియు నేను ఈ కాలమ్ పేరు కాల్, మరియు ఉంటాం
నేను ఈ కాలమ్ నగర కాల్ చేస్తాము.

537
00:25:05,810 --> 00:25:08,850
>> మరియు నేను ఊహించు, చెప్పటానికి వెళుతున్నాను
ఈ నా పునఃప్రారంభం ఉంది.

538
00:25:08,850 --> 00:25:14,050
నా resume.doc వద్ద నిల్వ ఉంది
నగర, 123 చెప్పటానికి చేసుకుందాం.

539
00:25:14,050 --> 00:25:15,390
నేను ఎల్లప్పుడూ ఆ సంఖ్యను కోసం వెళ్ళి.

540
00:25:15,390 --> 00:25:18,810
కానీ కేవలం ఇష్టం అని అది తగినంత
RAM లో, మీరు హార్డు డ్రైవు పట్టవచ్చు

541
00:25:18,810 --> 00:25:22,350
ఒక గిగాబైట్ లేదా 200 గిగాబైట్ల వార్తలు
లేదా ఒక టెరాబైట్, మరియు మీరు చెయ్యగలరు

542
00:25:22,350 --> 00:25:23,750
సంఖ్య బైట్లు అన్ని.

543
00:25:23,750 --> 00:25:26,480
మీరు 8 బిట్స్ అన్ని భాగాలు సంఖ్య చేయవచ్చు.

544
00:25:26,480 --> 00:25:29,030
>> కాబట్టి మేము ఈ చెప్పటానికి చేస్తాము
నగర 123 ఉంది.

545
00:25:29,030 --> 00:25:32,070
నా ఆపరేటింగ్ ఈ డైరెక్టరీ లోపల
సిస్టమ్ గుర్తు నా

546
00:25:32,070 --> 00:25:34,250
పునఃప్రారంభం నగర 123 వద్ద ఉంది.

547
00:25:34,250 --> 00:25:36,850
కానీ ఎప్పుడు ఆసక్తికరమైన గెట్స్
మీరు ఒక ఫైల్ను మీరు తొలగించాలని.

548
00:25:36,850 --> 00:25:37,820
>> ఉదాహరణకు సో -

549
00:25:37,820 --> 00:25:40,790
మరియు అదృష్టవశాత్తూ, ప్రపంచంలో చాలా ఉంది
ఈ లో ఆకర్షించింది - ఏమి జరుగుతుంది

550
00:25:40,790 --> 00:25:45,040
మీరు మీ Mac OS ట్రాష్కు ఒక ఫైల్ డ్రాగ్
లేదా మీ Windows రీసైకిల్ బిన్?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
ఆ చేయడం వలన ప్రయోజనం ఏమిటి?

553
00:25:50,510 --> 00:25:53,860
ఇది, ఫైలు వదిలించుకోవటం ఖచ్చితంగా ఉంది
కానీ ఏమి డ్రాగ్ చర్య చేస్తుంది మరియు

554
00:25:53,860 --> 00:25:57,550
మీ ట్రాష్ లేదా లోకి పడిపోయింది మీ
రీసైకిల్ బిన్ ఒక కంప్యూటర్లో చేయాలని?

555
00:25:57,550 --> 00:25:59,230
>> నిజంగా ఖచ్చితంగా ఏమీ.

556
00:25:59,230 --> 00:26:00,320
ఇది కేవలం ఒక ఫోల్డర్ వంటిది.

557
00:26:00,320 --> 00:26:01,800
ఇది తప్పకుండా ఒక ప్రత్యేక ఫోల్డర్ యొక్క.

558
00:26:01,800 --> 00:26:04,460
అయితే ఫైల్ను తొలగించి లేదు?

559
00:26:04,460 --> 00:26:06,780
>> ఏ, బాగా, ఎందుకంటే మీరు బహుశా కొన్ని
వంటి ఉన్నాయి, తిట్టు OH, మీరు కాదు

560
00:26:06,780 --> 00:26:07,420
అలా అని అర్థం.

561
00:26:07,420 --> 00:26:09,130
సో మీరు డబుల్ క్లిక్
ట్రాష్ లేదా రీసైకిల్ బిన్.

562
00:26:09,130 --> 00:26:11,630
మీరు చుట్టూ ఎత్తిచూపారు మరియు మీరు కోలుకొని చేసిన
కేవలం డ్రాగ్ చేసి ఫైలు

563
00:26:11,630 --> 00:26:12,110
అక్కడ నుండి.

564
00:26:12,110 --> 00:26:14,420
నుంచే, అది తప్పనిసరిగా కాదు
తొలగించి.

565
00:26:14,420 --> 00:26:15,990
>> OK, మీరు తెలివిగా కంటే ఉన్నాము.

566
00:26:15,990 --> 00:26:18,860
మీకు తెలిసిన ఆ కేవలం డ్రాగ్
ట్రాష్ లేదా రీసైకిల్ బిన్ కాదు

567
00:26:18,860 --> 00:26:19,930
మీరు ఖాళీ చేస్తున్నారు.

568
00:26:19,930 --> 00:26:24,110
సో మీరు అప్ మెనూ కు వెళ్ళండి, మరియు మీరు చెప్పే
ట్రాష్ను ఖాళీ లేదా ఖాళీ రీసైకిల్ బిన్.

569
00:26:24,110 --> 00:26:25,360
అప్పుడు ఏమి జరుగుతుంది?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> అవును, కాబట్టి అది మరింత కాబట్టి తొలగించబడుతుంది.

572
00:26:32,530 --> 00:26:37,660
కానీ జరిగే అన్ని ఈ.

573
00:26:37,660 --> 00:26:45,350
కంప్యూటర్ పేరు మర్చిపోతోంది
resume.doc ఉంది.

574
00:26:45,350 --> 00:26:47,400
>> కానీ ఏమి స్పష్టంగా మార్చలేదు
చిత్రంలో?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
బిట్స్, నేను ప్రకటిస్తున్నారు 0 సె మరియు 1s ఉన్నాయి
కొన్ని భౌతిక అంశం సైట్ న

577
00:26:55,570 --> 00:26:56,280
హార్డ్వేర్.

578
00:26:56,280 --> 00:26:57,110
వారు ఇప్పటికీ ఉన్నారు.

579
00:26:57,110 --> 00:26:58,930
ఇది కేవలం కంప్యూటర్ ఉంది
మర్చిపోయారు ఏమి వారు.

580
00:26:58,930 --> 00:27:03,160
>> కనుక ఇది తప్పనిసరిగా విముక్తి యొక్క ఫైలు యొక్క
వారు తిరిగి ఉపయోగించ తగినవి బిట్స్ కనుక.

581
00:27:03,160 --> 00:27:06,940
కానీ మీరు, మరింత ఫైళ్లను రూపొందిస్తుంది వరకు
మరియు మరిన్ని ఫైళ్ళను, మరియు మరిన్ని ఫైళ్ళను అవుతుంది

582
00:27:06,940 --> 00:27:12,150
చాలా మటుకు, ఆ 0 సె మరియు 1s,
ఆ అయస్కాంత అణువులు, మళ్లీ ఉపయోగించబడదు చేసుకోగా,

583
00:27:12,150 --> 00:27:16,220
కోసం పైకి లేదా కుడి వైపున అప్,
ఇతర ఫైళ్లు, 0 సె మరియు 1s.

584
00:27:16,220 --> 00:27:17,980
>> సో మీరు సమయం ఈ విండో కలిగి.

585
00:27:17,980 --> 00:27:19,860
మరియు అది ఊహాజనిత యొక్క కాదు
పొడవు, నిజంగా.

586
00:27:19,860 --> 00:27:22,240
ఇది మీ హార్డ్ యొక్క పరిమాణం మీద ఆధారపడి ఉంటుంది
డ్రైవ్ మరియు ఎన్ని ఫైళ్లు మీరు మరియు

587
00:27:22,240 --> 00:27:23,490
ఎంత త్వరగా మీరు కొత్త వాటిని తయారు.

588
00:27:23,490 --> 00:27:27,050
కానీ సమయం ఈ విండో సమయములో ఉంది
ఫైల్ సంపూర్ణ ఇప్పటికీ ఇది

589
00:27:27,050 --> 00:27:27,770
వెలికి.

590
00:27:27,770 --> 00:27:31,050
>> మీరు ఎప్పుడైనా McAfee వంటి కార్యక్రమాలు ఉపయోగించడానికి కనుక
లేదా నార్టన్ తిరిగి ప్రయత్నించండి

591
00:27:31,050 --> 00:27:35,680
డేటా, వారు చేస్తున్న అన్ని ప్రయత్నిస్తున్నారు
ఈ అని పిలవబడే డైరెక్టరీకి తిరిగి

592
00:27:35,680 --> 00:27:37,340
మీ ఫైలు అక్కడ అవ్ట్ దొరుకుతుందని.

593
00:27:37,340 --> 00:27:40,605
మరియు కొన్నిసార్లు నార్టన్ మరియు, పలుకును
ఫైలు 93% దీనిని పునరుద్ధరించడం సాధ్యంకాదు.

594
00:27:40,605 --> 00:27:42,020
బాగా, ఆ అర్థం ఏమిటి?

595
00:27:42,020 --> 00:27:45,690
కేవలం అర్థం కొన్ని ఇతర ఫైలు
యాదృచ్చికంగా, చెప్పటానికి, ఉపయోగించి ఇచ్చాను

596
00:27:45,690 --> 00:27:48,920
మీ అసలు ఫైల్ నుండి ఆ బిట్స్.

597
00:27:48,920 --> 00:27:51,950
>> సో నిజానికి ఏమి చేరి ఉంది
డేటా కోలుకుంటూ?

598
00:27:51,950 --> 00:27:55,720
బాగా, మీరు ఏదో లేకపోతే
నార్టన్, మీ కంప్యూటర్లో ముందు ఇన్స్టాల్

599
00:27:55,720 --> 00:27:59,510
మీరు కొన్నిసార్లు చేయవచ్చు ఉత్తమ చూడండి ఉంది
మొత్తం హార్డ్ డ్రైవ్ కోసం చూస్తున్న వద్ద

600
00:27:59,510 --> 00:28:00,510
బిట్స్ క్రమాలు.

601
00:28:00,510 --> 00:28:05,350
మరియు సమస్య సెట్ మూలాల్లో ఒకటి
ఐదు మీరు శోధిస్తుంది ఉంది

602
00:28:05,350 --> 00:28:09,570
హార్డు డ్రైవు యొక్క సమానమైన, ఒక ఫోరెన్సిక్
ఒక నుండి ఒక కాంపాక్ట్ ఫ్లాష్ కార్డ్ చిత్రం

603
00:28:09,570 --> 00:28:13,660
0 సె శోధించడం డిజిటల్ కెమెరా,
అధిక ఆ సాధారణంగా మరియు 1s,

604
00:28:13,660 --> 00:28:16,720
సంభావ్యత, ప్రాతినిధ్యం
ఒక చిత్రం యొక్క మొదలు.

605
00:28:16,720 --> 00:28:21,120
>> మరియు మీరు అబ్బాయిలు ద్వారా చిత్రాలను పునరుద్ధరించవచ్చు
నేను ఈ నమూనా చూడండి ఉంటే, ఊహిస్తూ

606
00:28:21,120 --> 00:28:24,380
ఫోరెన్సిక్ చిత్రంపై బిట్స్ తో
మార్క్స్ అధిక సంభావ్యత,

607
00:28:24,380 --> 00:28:25,650
ఒక JPEG ప్రారంభంలో.

608
00:28:25,650 --> 00:28:29,520
మరియు నేను మళ్ళీ అదే నమూనా చూడండి ఉంటే,
ఆ బహుశా ప్రారంభంలో మార్క్స్

609
00:28:29,520 --> 00:28:32,440
మరొక JPEG, మరియు మరొక
JPEG, మరియు మరొక JPEG.

610
00:28:32,440 --> 00:28:34,970
మరియు ఇది సాధారణంగా ఎలా
డేటా రికవరీ పని చేస్తుంది.

611
00:28:34,970 --> 00:28:37,870
ఏ JPEGs గురించి nice వార్తలు అయినప్పటికీ ఉంది
ఫైల్ ఫార్మాట్ కూడా కొంతవరకు ఉంది

612
00:28:37,870 --> 00:28:44,400
ప్రతి యొక్క క్లిష్టమైన, ప్రారంభంలో
ఫైలు నిజానికి చాలా గుర్తించదగిన

613
00:28:44,400 --> 00:28:47,370
, మీరు చూస్తారు గా, మరియు సాధారణ
మీరు ఇప్పటికే ఉంటే.

614
00:28:47,370 --> 00:28:50,270
>> సో యొక్క కింద దగ్గరగా పరిశీలించి లెట్
కూడా సరిగ్గా ఏమి హుడ్

615
00:28:50,270 --> 00:28:53,360
జరగబోతోంది, మరియు ఈ 0s మరియు 1s ఏమి
మీరు ఒక ఒక బిట్ మరింత ఇవ్వాలని, ఉన్నాయి

616
00:28:53,360 --> 00:28:55,330
ఈ ప్రత్యేక సవాలు సందర్భం.

617
00:28:55,330 --> 00:28:55,510
>> [వీడియో ప్లేబ్యాక్]

618
00:28:55,510 --> 00:28:58,700
>> మీ PC అత్యంత నిల్వ-ఎక్కడ
దాని శాశ్వత డేటా.

619
00:28:58,700 --> 00:29:03,390
ఇలా చేయాలంటే, డేటా RAM నుండి ప్రయాణిస్తుంది
చెప్పే సాఫ్ట్వేర్ సంకేతాలు పాటు

620
00:29:03,390 --> 00:29:06,110
ఆ సమాచారాన్ని నిల్వచేయటానికి హార్డ్ డ్రైవ్.

621
00:29:06,110 --> 00:29:09,410
హార్డు డ్రైవు సర్క్యూట్లు అనువాదం
వోల్టేజ్ లోకి ఆ సంకేతాలను

622
00:29:09,410 --> 00:29:10,870
ఒడిదుడుకులు.

623
00:29:10,870 --> 00:29:14,970
ఈ, అందుకు ప్రతిగా, హార్డ్ డ్రైవ్ యొక్క నియంత్రణ
కదిలే భాగాలు, కొన్ని కొన్ని

624
00:29:14,970 --> 00:29:17,910
మిగిలి కదిలే భాగాలు
ఆధునిక కంప్యూటర్.

625
00:29:17,910 --> 00:29:22,130
>> సిగ్నల్స్ కొన్ని వాహనాల నియంత్రణ
ఇది మెటల్ పూత platters తిప్పుతుంది.

626
00:29:22,130 --> 00:29:25,470
మీ డేటా నిజానికి నిల్వ ఉంది
ఈ platters న.

627
00:29:25,470 --> 00:29:28,610
ఇతర సంకేతాలను చదవండి / వ్రాయండి తరలించడానికి
చదవడానికి లేదా తలలు

628
00:29:28,610 --> 00:29:30,710
platters డేటా వ్రాయండి.

629
00:29:30,710 --> 00:29:35,450
ఈ యంత్రాలు కాబట్టి ఖచ్చితమైన ఒక మానవ అని
జుట్టు కూడా మధ్య పాస్ కాలేదు

630
00:29:35,450 --> 00:29:37,280
తలలు మరియు స్పిన్నింగ్ platters.

631
00:29:37,280 --> 00:29:40,316
ఇంకా, ఇది అన్ని అద్భుతమైన వేగంతో పనిచేస్తుంది.

632
00:29:40,316 --> 00:29:40,660
>> [END వీడియో ప్లేబ్యాక్]

633
00:29:40,660 --> 00:29:42,190
>> DAVID మలన్: కొద్దిగా జూమ్
లోతుగా ఇప్పుడు ఏమి వద్ద

634
00:29:42,190 --> 00:29:44,360
నిజానికి ఆ platters న.

635
00:29:44,360 --> 00:29:44,720
>> [వీడియో ప్లేబ్యాక్]

636
00:29:44,720 --> 00:29:47,660
>> యొక్క చూడండి-లెట్ మేము కేవలం వద్ద
స్లో మోషన్ లో చూసింది.

637
00:29:47,660 --> 00:29:51,710
విద్యుత్ సంక్షిప్త పల్స్ ఉన్నప్పుడు
ఎగరవేసిన ప్రతిసారి ఉంటే, / వ్రాసే తల పంపిన

638
00:29:51,710 --> 00:29:54,650
ఒక చిన్న విద్యుదయస్కాంత న
రెండవ యొక్క ఒక భిన్నం.

639
00:29:54,650 --> 00:29:58,970
అయస్కాంతం ఇది ఒక రంగంలో, సృష్టిస్తుంది
మార్పులు చిన్న, చిన్న యొక్క ధ్రువణత

640
00:29:58,970 --> 00:30:02,850
మెటల్ కణాల భాగం ఇది
కోటు ప్రతి పళ్ళెం ఉపరితల.

641
00:30:02,850 --> 00:30:05,940
>> ఈ చిన్న నమూనా సిరీస్,
డిస్క్ వసూలు అప్ ప్రాంతాల్లో

642
00:30:05,940 --> 00:30:08,470
ఒకే బిట్ ప్రాతినిధ్యం
బైనరీ సంఖ్య డేటా

643
00:30:08,470 --> 00:30:10,530
కంప్యూటర్లు ఉపయోగించబడుతుంది.

644
00:30:10,530 --> 00:30:13,775
ఇప్పుడు, ప్రస్తుత పంపినా ఒక మార్గం
రీడ్ ద్వారా / ప్రాంతం తల వ్రాయండి

645
00:30:13,775 --> 00:30:15,970
ఒక దిశలో ధృవీకరణం ఉంది.

646
00:30:15,970 --> 00:30:17,950
ప్రస్తుత లో పంపినా
వ్యతిరేక దిశలో,

647
00:30:17,950 --> 00:30:19,930
ధ్రువిత తిరగబడుతుంది.

648
00:30:19,930 --> 00:30:22,370
>> మీరు హార్డు డిస్కు ఆఫ్ డేటా ఎంత?

649
00:30:22,370 --> 00:30:24,090
కేవలం ప్రక్రియ రివర్స్.

650
00:30:24,090 --> 00:30:26,550
కనుక ఇది డిస్క్ కణాలు వార్తలు
ఎందుకంటే ప్రస్తుతం పొందుటకు

651
00:30:26,550 --> 00:30:27,960
తల కదిలే / వ్రాసే.

652
00:30:27,960 --> 00:30:30,700
ఈ మిలియన్ల కూర్చు
అయస్కాంతము భాగాలు, మరియు

653
00:30:30,700 --> 00:30:32,160
మీరు ఒక ఫైల్ వచ్చింది చేసిన.

654
00:30:32,160 --> 00:30:36,060
>> ఇప్పుడు, ఒక ఫైలు యొక్క ముక్కలు చేయవచ్చు
అన్ని డ్రైవ్ యొక్క మైదానాల్లో అవుతుంది

655
00:30:36,060 --> 00:30:39,970
గజిబిజి వంటి రకమైన platters,
మీ డెస్క్ మీద పత్రాలు.

656
00:30:39,970 --> 00:30:43,500
సో ఒక ప్రత్యేక అదనపు ఫైల్ ట్రాక్
ప్రతిదీ ఇక్కడ.

657
00:30:43,500 --> 00:30:45,985
మీరు కలిగి అనుకుంటున్నారా లేదు
అలాంటిదే?

658
00:30:45,985 --> 00:30:46,470
>> [END వీడియో ప్లేబ్యాక్]

659
00:30:46,470 --> 00:30:47,820
>> DAVID మలన్: OK, బహుశా.

660
00:30:47,820 --> 00:30:52,070
సో ఎలా మీరు అనేక అబ్బాయిలు
ఈ తో కలిసి పెరిగాను?

661
00:30:52,070 --> 00:30:53,970
OK, కాబట్టి అది తక్కువ వార్తలు
చేతులు ప్రతి సంవత్సరం.

662
00:30:53,970 --> 00:30:56,550
కానీ, నేను మీరు కనీసం తెలిసి సంతోషించిన రెడీ!
వారితో, ఈ ఎందుకంటే మరియు మా సొంత

663
00:30:56,550 --> 00:31:00,520
పుస్తకం డెమో, పాపం, చాలా చస్తున్నామని
పరిచయాన్ని ఇక్కడ మరణం తగ్గించి.

664
00:31:00,520 --> 00:31:04,010
>> కానీ ఈ కనీసం తిరిగి, నేను ఉంది
ఉన్నత పాఠశాల, బ్యాకప్ కోసం ఉపయోగిస్తారు ఉపయోగం.

665
00:31:04,010 --> 00:31:08,110
మరియు అది అద్భుతమైన ఉంది, ఎందుకంటే మీరు
న 1.4 మెగాబైట్ల నిల్వ చేసుకోవచ్చు

666
00:31:08,110 --> 00:31:08,930
ఈ ప్రత్యేక డిస్కు.

667
00:31:08,930 --> 00:31:12,260
మరియు ఈ, అధిక సాంద్రత వెర్షన్
గా ఇది HD, సూచించిన

668
00:31:12,260 --> 00:31:14,240
నేటి HD వీడియోలను ముందు అర్థం.

669
00:31:14,240 --> 00:31:16,400
>> ప్రామాణిక సాంద్రత 800 కిలోబైట్ల ఉంది.

670
00:31:16,400 --> 00:31:18,640
మరియు ఆ ముందు, ఉన్నాయి
400 కిలోబైట్ డిస్కులను.

671
00:31:18,640 --> 00:31:23,120
మరియు ఆ ముందు, 5 మరియు 1/4 ఉన్నాయి
నిజంగా ఫ్లాపీ ఉన్నాయి ఇది అంగుళాల డిస్కులు,,

672
00:31:23,120 --> 00:31:25,680
మరియు కొద్దిగా విస్తృత మరియు పొడవుగా
ఇక్కడ ఈ విషయాల కంటే.

673
00:31:25,680 --> 00:31:29,150
కానీ మీరు నిజంగా పిలవబడే చూడగలరు
ఈ డిస్కుల ఫ్లాపీ కారక.

674
00:31:29,150 --> 00:31:32,630
>> మరియు పనితీరు వారు నిజానికి ఉన్నాము
వద్ద హార్డ్ డ్రైవ్లకు అందంగా ఇదే

675
00:31:32,630 --> 00:31:33,570
కనీసం ఈ రకం.

676
00:31:33,570 --> 00:31:37,270
కొత్త కంప్యూటర్లు మళ్లీ SSDs
విభిన్నంగా కొద్దిగా పని.

677
00:31:37,270 --> 00:31:41,530
కానీ మీరు చిన్న మెటల్ ను తరలించు ఉంటే,
మీరు నిజంగానే, కొద్దిగా కుకీ చూడగలరు

678
00:31:41,530 --> 00:31:42,560
లేదా పళ్ళెం.

679
00:31:42,560 --> 00:31:43,830
>> ఈ ఒక వంటి మెటల్ కాదు.

680
00:31:43,830 --> 00:31:46,000
ఈ ఒక నిజంగా కొన్ని తక్కువ వార్తలు
పదార్థం ప్లాస్టిక్.

681
00:31:46,000 --> 00:31:46,750
మరియు మీరు విగ్లే ఇది రకం చేయవచ్చు.

682
00:31:46,750 --> 00:31:50,310
మరియు మీరు trully కొన్ని ఆఫ్ కనుమరుగవుతుంది చేసిన
బిట్స్ లేదా అయస్కాంత కణాల సంఖ్య

683
00:31:50,310 --> 00:31:51,220
ఈ డిస్కు నుండి.

684
00:31:51,220 --> 00:31:52,710
>> సో అదృష్టవశాత్తూ, అది ఏమీ లేదు.

685
00:31:52,710 --> 00:31:55,790
ఆ విషయం విధంగా ఉంటే - మరియు కవర్
మీ కళ్ళు మరియు మీ పొరుగు యొక్క ఆ -

686
00:31:55,790 --> 00:31:58,865
కేవలం రకమైన ఈ లాగండి మీరు చేయవచ్చు
ఆ వంటి మొత్తం కోశం ఆఫ్.

687
00:31:58,865 --> 00:32:01,900
కానీ కొద్దిగా వసంత, దాంతో ఉంటుంది
మీ కళ్ళు ఆ తెలుసు.

688
00:32:01,900 --> 00:32:03,620
కాబట్టి ఇప్పుడు మీరు నిజంగా ఒక ఫ్లాపీ డిస్కు.

689
00:32:03,620 --> 00:32:07,090
>> మరియు ఈ గురించి గొప్ప వార్తలు
ఈ ఉంది అని చాలా ఉంది ఒక

690
00:32:07,090 --> 00:32:10,830
ఒక పెద్ద చిన్న తరహా ప్రాతినిధ్యం
హార్డు డ్రైవు, ఈ విషయాలు, సూపర్ ఉన్నాయి

691
00:32:10,830 --> 00:32:11,590
సూపర్ సాధారణ.

692
00:32:11,590 --> 00:32:15,170
మీరు ఇప్పుడు, అది దిగువన చిటికెడు, ఆ
ఆ మెటల్ విషయం ఆఫ్ వార్తలు, మరియు తొక్క

693
00:32:15,170 --> 00:32:20,990
వాటిని తెరవడానికి, ఉంది అన్ని రెండు ముక్కలు ఉంది
భావించాడు మరియు అని పిలవబడే ఫ్లాపీ డిస్క్

694
00:32:20,990 --> 00:32:22,930
లోపల మెటల్ ఒక ముక్క తో.

695
00:32:22,930 --> 00:32:25,990
>> మరియు సగం అక్కడ వెళ్తాడు
నా డిస్క్ యొక్క విషయాలను.

696
00:32:25,990 --> 00:32:27,540
వాటిని మరొక సగం ఉన్నాయి వెళ్తాడు.

697
00:32:27,540 --> 00:32:31,375
కానీ ఆ లోపల తిరుగుతూ ఆ అన్ని వార్తలు
ఒకప్పటి మీ కంప్యూటర్ యొక్క.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> మళ్ళీ, దృష్టికోణం ఈ ఉంచాలి
ఎలా పెద్దది మీ అత్యంత

700
00:32:38,310 --> 00:32:39,560
హార్డ్ ఈ రోజుల్లో వెళ్ళే?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 గిగాబైట్ల, ఒక టెరాబైట్, ఉండవచ్చు లో
ఒక డెస్క్టాప్ కంప్యూటర్, 2 టెరాబైట్ల, 3

703
00:32:46,230 --> 00:32:47,630
టెరాబైట్ల, 4 టెరాబైట్ల, కుడి?

704
00:32:47,630 --> 00:32:52,480
ఈ ఒక మెగాబైట్ ఉంది, ఇవ్వాలని లేదా పడుతుంది
కూడా ఒక సాధారణ MP3 సరిపోవు ఇది

705
00:32:52,480 --> 00:32:55,310
ఇకపై ఈ రోజుల్లో, లేదా కొన్ని
ఇలాంటి సంగీతం ఫైలు.

706
00:32:55,310 --> 00:32:59,500
>> సో కొద్దిగా మీరు కోసం స్మారక నేడు, మరియు
కూడా ఏమి contextualize సహాయం

707
00:32:59,500 --> 00:33:03,570
మేము మంజూరు కోసం తీసుకొని వస్తారు
ఇప్పుడు సమస్య ఐదు సెట్.

708
00:33:03,570 --> 00:33:04,820
సో ఆ ఉంచాలని మీదే ఉన్నాయి.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
సో ఉంటుంది పేరు నాకు బదిలీ వీలు
తదుపరి pset ఖర్చు అలాగే.

711
00:33:13,370 --> 00:33:18,470
కనుక మనం ఇప్పుడు ఈ పేజీ సెట్ చేసిన - ఓహ్,
త్వరగా ప్రకటనలు జంట.

712
00:33:18,470 --> 00:33:21,730
>> ఈ శుక్రవారం, మీరు అని CS50 చేరడానికి
అర్హత కోసం, సాధారణ స్థానంలో వెళ్ళండి

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
తుది ప్రణాళిక -

715
00:33:25,100 --> 00:33:28,520
కాబట్టి సిలబస్ ప్రకారం, పోస్ట్ చేసిన
ఇప్పటికే ఫైనల్ ప్రాజెక్ట్ వివరణ.

716
00:33:28,520 --> 00:33:31,410
అర్థం అని తెలుసుకోవటం
ఇది ముఖ్యంగా వెంటనే వలన.

717
00:33:31,410 --> 00:33:33,990
ఇది కేవలం పొందుటకు, నిజంగా, పోస్ట్ చేసిన
మీరు అబ్బాయిలు దాని గురించి ఆలోచిస్తూ.

718
00:33:33,990 --> 00:33:37,620
నిజానికి, ఒక సూపర్ ముఖ్యమైన
మీరు శాతం పరిష్కారంలో ఉంటుంది

719
00:33:37,620 --> 00:33:40,780
అంశంపై తుది ప్రాజెక్టులు మేము
కూడా తరగతి లో సంపాదించిన లేదు,

720
00:33:40,780 --> 00:33:42,730
కానీ తరువాత వారం అవుతుంది.

721
00:33:42,730 --> 00:33:45,530
>> నోటీసు, అయితే, వివరాలను పిలుపు ఆ
కొన్ని వివిధ భాగాలు

722
00:33:45,530 --> 00:33:46,190
చివరి ప్రాజెక్ట్.

723
00:33:46,190 --> 00:33:49,590
మొదటి, కొన్ని వారాల లో, ఒక
ముందు ప్రతిపాదన, ఒక అందమైన సాధారణం ఇమెయిల్

724
00:33:49,590 --> 00:33:52,760
మీ అతనికి చెప్పాల్సి TF లేదా ఏమి మీరు
తో, మీ ప్రాజెక్ట్ కోసం గురించి ఆలోచిస్తూ

725
00:33:52,760 --> 00:33:53,650
ఏ నిబద్ధత.

726
00:33:53,650 --> 00:33:56,710
ప్రతిపాదన మీ ఉంటుంది
నిబద్ధత, మాట్లాడుతూ, ఇక్కడ, ఈ ఏమిటి

727
00:33:56,710 --> 00:33:57,770
నేను నా ప్రాజెక్ట్ కోసం చేయాలని భావిస్తున్న.

728
00:33:57,770 --> 00:33:58,250
మీరు ఏమి ఆలోచిస్తాడు?

729
00:33:58,250 --> 00:33:58,650
చాలా పెద్దది?

730
00:33:58,650 --> 00:33:59,145
చాలా చిన్న?

731
00:33:59,145 --> 00:34:00,330
ఇది నిర్వహించటానికి ఉంది?

732
00:34:00,330 --> 00:34:02,230
మరియు మీరు మరిన్ని వివరాలకు చూడండి.

733
00:34:02,230 --> 00:34:05,060
>> వారాల జంట ఆ తర్వాత స్థితి
ఇదే ఇది నివేదిక,

734
00:34:05,060 --> 00:34:08,260
ఎంత చెప్పటానికి మీ TF కు సాధారణం ఇమెయిల్
మీరు మీ చివరి ఉన్నాయి కంటే

735
00:34:08,260 --> 00:34:12,360
తరువాత ప్రాజెక్ట్ యొక్క అమలు,
CS50 Hackathon ఏ ఒక్కరూ

736
00:34:12,360 --> 00:34:17,520
ఆహ్వానించారు ఉంది, ఒక సంఘటన ఉంటుంది
7:00 వరకు ఒక సాయంత్రం 8:00 PM

737
00:34:17,520 --> 00:34:19,150
మరుసటి రోజు పోస్ట్.

738
00:34:19,150 --> 00:34:22,560
నేను వారంలో చెప్పిన విధంగా పిజ్జా,
సున్నా, విల్, 9:00 గంటలకు వడ్డిస్తారు

739
00:34:22,560 --> 00:34:24,120
1:00 వద్ద చైనీస్ ఆహార పోస్ట్.

740
00:34:24,120 --> 00:34:27,929
మరియు మీరు 5:00 వద్ద ఇప్పటికీ మేలుకొని అయితే పోస్ట్,
మేము అల్పాహారం కోసం IHOP కి తీసుకొని వెళ్తాము.

741
00:34:27,929 --> 00:34:31,310
>> సో Hackathon మరింత ఒకటి
తరగతి లో గుర్తుండిపోయే అనుభవాలు.

742
00:34:31,310 --> 00:34:35,290
అప్పుడు అమలు కారణంగా, మరియు
అప్పుడు పతాక CS50 ఫెయిర్.

743
00:34:35,290 --> 00:34:38,070
ఈ అన్ని మరిన్ని వివరాలకు
వారాల వచ్చిన.

744
00:34:38,070 --> 00:34:40,739
>> కానీ కొంత తిరిగి వెళ్ళి తెలపండి
పాత పాఠశాల -

745
00:34:40,739 --> 00:34:41,920
మళ్ళీ, వ్యూహం.

746
00:34:41,920 --> 00:34:45,040
ఇది పరిష్కరిస్తుంది ఎందుకంటే సో వ్యూహం, nice ఉంది
మేము వంటి సమస్యలు కేవలం ఒక చూసింది

747
00:34:45,040 --> 00:34:49,290
విద్యార్థి నిర్మాణాలు క్రితం క్షణం
నియంత్రణ కొద్దిగా అవుట్ ఉంటే మేము

748
00:34:49,290 --> 00:34:52,405
విద్యార్థి ఒక విద్యార్ధి రెండు, కలిగి అనుకుంటున్నారా
విద్యార్థి మూడు, విద్యార్థి డాట్ డాట్ డాట్,

749
00:34:52,405 --> 00:34:54,400
కొంతమంది విద్యార్ధులు అనియత సంఖ్య.

750
00:34:54,400 --> 00:34:58,850
>> శ్రేణుల సో, కొన్ని వారాల క్రితం, లో swooped
మరియు పరిష్కరించాడు మా సమస్యలు కాదు అన్ని

751
00:34:58,850 --> 00:35:03,340
ముందుగానే తెలుసుకోవడం ఎన్ని విషయాలు
కొన్ని రకం మేము కావలసిన ఉండవచ్చు.

752
00:35:03,340 --> 00:35:07,390
మరియు మేము structs మాకు సహాయపడే చూసిన
మరింత మా కోడ్ నిర్వహించడానికి మరియు ఉంచడానికి

753
00:35:07,390 --> 00:35:11,660
ఒక వంటి సందర్భానుసారంగా పోలి వేరియబుల్స్
పేరు మరియు ఒక ఇల్లు, కలిసి, తద్వారా మేము

754
00:35:11,660 --> 00:35:15,570
లోపల ఒక పరిధి, వాటిని చికిత్స చేయవచ్చు
ఇది చిన్న ముక్కలు ఉన్నాయి.

755
00:35:15,570 --> 00:35:17,810
>> కానీ శ్రేణుల కొన్ని లోపాలు ఉన్నాయి.

756
00:35:17,810 --> 00:35:19,780
లోపాలు ఏమిటి
మేము ఎదుర్కొన్న

757
00:35:19,780 --> 00:35:22,320
శ్రేణితో ఇప్పటివరకు?

758
00:35:22,320 --> 00:35:23,450
ఆ ఏమిటి?

759
00:35:23,450 --> 00:35:28,130
స్థిర పరిమాణం - కాబట్టి మీరు వాటిని అయితే
ఒక కోసం మెమరీని కేటాయించాల్సిన చెయ్యగలరు

760
00:35:28,130 --> 00:35:32,310
అర్రే, మీకు ఎన్ని విద్యార్థులు
మీరు ఎన్ని అక్షరాలు కలిగి

761
00:35:32,310 --> 00:35:35,460
యూజర్ నుండి, మీరు కేటాయించిన చేసిన
అర్రే, మీరు రకమైన పెయింట్ చేసిన

762
00:35:35,460 --> 00:35:36,740
ఒక మూలలో మీ.

763
00:35:36,740 --> 00:35:40,600
>> మీరు కొత్త అంశాలు ఇన్సర్ట్ ఎందుకంటే
వ్యూహం మధ్యలో.

764
00:35:40,600 --> 00:35:43,660
మీరు మరిన్ని అంశములు చేర్చలేరు
ఒక అర్రే యొక్క ముగింపు వద్ద.

765
00:35:43,660 --> 00:35:47,750
నిజంగా, మీరు ఒక సృష్టించడం ఆశ్రయించాల్సిన ఉంటుంది
మేము చర్చించిన చేసిన వంటి సరికొత్త వ్యూహం,

766
00:35:47,750 --> 00:35:49,320
నూతన పాత కాపీ.

767
00:35:49,320 --> 00:35:52,610
మళ్ళీ, ఆ తలనొప్పి అని
మీరు కోసం వ్యవహరించే GetString.

768
00:35:52,610 --> 00:35:56,170
>> కానీ మళ్ళీ, మీరు కూడా చేర్చలేరు
అర్రే యొక్క మధ్యలో ఏదో

769
00:35:56,170 --> 00:35:58,200
రేటు పూర్తిగా నిండి లేదు ఉంటే.

770
00:35:58,200 --> 00:36:03,010
ఉదాహరణకు, ఈ శ్రేణి ఇక్కడ పరిమాణం
ఆరు మాత్రమే, అది ఐదు అంశాలు ఉన్నాయి

771
00:36:03,010 --> 00:36:06,080
బాగా, మీరు కేవలం అమరిక అనుకొనుట
ముగింపు లో ఏదో.

772
00:36:06,080 --> 00:36:08,200
కానీ మీరు ఏదో ఇన్సర్ట్ ఏమి కావాలా
మధ్యలో

773
00:36:08,200 --> 00:36:11,280
అర్రే, అది కలిగి ఉండవచ్చు అయినప్పటికీ
ఇది ఆరు విషయాలు ఐదు అవ్ట్?

774
00:36:11,280 --> 00:36:14,250
>> బాగా, మేము అన్ని ఉన్నప్పుడు ఏమి లేదు
మా మానవ వాలంటీర్లను వేదికపై లో

775
00:36:14,250 --> 00:36:15,110
వారాలు?

776
00:36:15,110 --> 00:36:18,710
మేము ఇక్కడ ఎవరైనా చాలు అనుకుంటే, గాని
ఈ తరలించడానికి ఎలా ఈ ప్రజలు

777
00:36:18,710 --> 00:36:22,540
మార్గం, లేదా ఈ తరలించడానికి ఎలా ఈ ప్రజలు
మార్గం, మరియు ఆ ఖరీదైన మారింది.

778
00:36:22,540 --> 00:36:26,950
ఒక లోపలి ప్రజల బదిలీ
అర్రే అప్ జోడించడం మరియు ఖర్చు ముగిసింది

779
00:36:26,950 --> 00:36:31,240
మాకు సమయం, అందుకే చాలా మా n స్క్వేర్డ్ యొక్క
కోసం, చొప్పించడం విధమైన వంటి సార్లు అమలు

780
00:36:31,240 --> 00:36:32,550
ఉదాహరణకు, చెత్త సందర్భంలో.

781
00:36:32,550 --> 00:36:36,520
సో శ్రేణుల గొప్ప ఉంటాయి, కానీ మీరు కలిగి
మీరు వాటిని ఎలా పెద్ద ముందుగానే తెలుసు.

782
00:36:36,520 --> 00:36:38,030
>> సో OK, ఇక్కడ ఒక పరిష్కారం యొక్క.

783
00:36:38,030 --> 00:36:43,860
నేను ముందుగానే తెలియకపోతే ఎన్ని
విద్యార్థులు నేను ఉండవచ్చు, మరియు నేను ఒకసారి తెలుసు

784
00:36:43,860 --> 00:36:47,870
నేను నిర్ణయించుకుంటారు, అయితే, నేను ఆ కష్టం నేను
, ఎందుకు నేను ఎల్లప్పుడూ చాలా విద్యార్థులు లేదు

785
00:36:47,870 --> 00:36:51,740
రెట్టింపు స్థలం కేటాయించాలని
నేను అనుకుంటున్నాను ఉండవచ్చు నేను అవసరం?

786
00:36:51,740 --> 00:36:54,450
ఒక సహేతుకమైన పరిష్కారం కాదు?

787
00:36:54,450 --> 00:36:58,240
>> వాస్తవికంగా, నేను మేము ఆ భావించడం లేదు
కంటే ఎక్కువ 50 విభాగాలు అవసరం వెళుతున్న

788
00:36:58,240 --> 00:37:02,190
మధ్యస్థ పరిమాణ తరగతి కోసం వ్యూహంలో,
కాబట్టి మనం చుట్టుముట్టటమే వీలు.

789
00:37:02,190 --> 00:37:07,040
నేను, నా పరిధిలో 100 విభాగాలు చేస్తాము
తద్వారా మేము ఖచ్చితంగా పొందవచ్చు

790
00:37:07,040 --> 00:37:10,330
నేను అంచనా విద్యార్థులు సంఖ్య
కొన్ని మధ్యస్థ పరిమాణ తరగతి లో.

791
00:37:10,330 --> 00:37:14,320
సో ఎందుకు కేవలం అప్ అందుబాటులోనున్న మరియు కేటాయించుటకు కాదు
వ్యూహం కోసం మరింత మెమరీ, సాధారణంగా,

792
00:37:14,320 --> 00:37:16,290
మీరు కూడా కావాలనుకుంటే కంటే?

793
00:37:16,290 --> 00:37:20,190
ఈ సాధారణ pushback ఏమిటి
ఆలోచనను?

794
00:37:20,190 --> 00:37:21,440
>> మీరు కేవలం మెమరీ వృధా చేస్తున్నాం.

795
00:37:21,440 --> 00:37:25,350
మీరు వ్రాయడానికి వాచ్యంగా ప్రతి కార్యక్రమం
బహుశా రెండు రెట్లు మెమరీని వాడుకుంటున్నారని

796
00:37:25,350 --> 00:37:26,680
మీరు నిజంగానే అవసరం.

797
00:37:26,680 --> 00:37:28,990
మరియు కేవలం ఒక భావిస్తాను లేదు
ముఖ్యంగా చక్కని పరిష్కారం.

798
00:37:28,990 --> 00:37:31,990
అంతేకాక, ఇది కేవలం తగ్గుతుంది
ఒక సమస్య సంభావ్యత.

799
00:37:31,990 --> 00:37:35,300
మీరు ఒక ప్రముఖ కోర్సు కలిగి జరిగే ఉంటే
ఒక సెమిస్టర్ మరియు మీరు 101 కలిగి

800
00:37:35,300 --> 00:37:39,610
విద్యార్థులు, మీ ప్రోగ్రామ్ ఇంకా
ప్రాథమికంగా అదే సమస్య ఎదుర్కొంటున్న.

801
00:37:39,610 --> 00:37:44,280
>> సో అదృష్టవశాత్తూ, ఒక పరిష్కారం ఉంది
రూపంలో ఈ ప్రకటన మా సమస్యలు

802
00:37:44,280 --> 00:37:46,790
అని డేటా నిర్మాణాలు
వాటి కంటే మరింత క్లిష్టమైన

803
00:37:46,790 --> 00:37:47,970
మేము ఇప్పటివరకు చూసిన.

804
00:37:47,970 --> 00:37:50,530
ఈ, నేను క్లెయిమ్, అనుబంధ జాబితా ఉంది.

805
00:37:50,530 --> 00:37:51,920
ఈ సంఖ్యల జాబితా -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, మరియు 34 -

807
00:37:54,970 --> 00:38:00,120
మార్గం ద్వారా కలిసి లింక్ చేయబడ్డాయి
ఏమి నేను బాణాలు డ్రా గా చేసిన.

808
00:38:00,120 --> 00:38:03,580
>> ఇతర మాటలలో, ఉంటే నేను కోరుకున్నాడు
ఒక అర్రే, నేను అలా

809
00:38:03,580 --> 00:38:04,910
ఈ వంటి ఏదో.

810
00:38:04,910 --> 00:38:07,310
మరియు నేను భారాన్ని ఈ పెడతామో
కేవలం ఒక క్షణం లో.

811
00:38:07,310 --> 00:38:09,970
నేను అలా -

812
00:38:09,970 --> 00:38:12,520
హలో, అన్ని కుడి.

813
00:38:12,520 --> 00:38:14,470
ఉండండి.

814
00:38:14,470 --> 00:38:17,360
ఇక్కడ కొత్త కంప్యూటర్, స్పష్టమైన -

815
00:38:17,360 --> 00:38:18,090
అన్ని కుడి.

816
00:38:18,090 --> 00:38:21,730
>> నేను అర్రే ఈ సంఖ్యలు కలిగి ఉంటే -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
కొలమానము అవసరం లేదు.

819
00:38:30,530 --> 00:38:33,730
అన్ని కుడి, ఇక్కడ నా శ్రేణి -

820
00:38:33,730 --> 00:38:34,980
ఓహ్ మై గాడ్.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
అన్ని కుడి, ఇక్కడ నా శ్రేణి.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
ఓహ్ మై గాడ్.

825
00:38:45,050 --> 00:38:48,820
>> [నవ్వు]

826
00:38:48,820 --> 00:38:49,440
>> DAVID మలన్: నటిస్తారు.

827
00:38:49,440 --> 00:38:52,330
తిరిగి వెళ్ళడానికి చాలా కృషి వార్తలు
మరియు అందువల్ల, ఆ పరిష్కరించడానికి -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
కాబట్టి మేము ఈ శ్రేణి యొక్క కలిగి
9, 17, 22, 26, మరియు 34.

830
00:38:57,650 --> 00:39:00,260
మీరు ఆ చూడగలరు కోసం
ఇబ్బందికరమైన తప్పు నేను చేసిన,

831
00:39:00,260 --> 00:39:00,830
అక్కడ ఇది.

832
00:39:00,830 --> 00:39:04,490
>> నేను ఈ చెప్పడము ఒక
చాలా సమర్థవంతమైన పరిష్కారంగా.

833
00:39:04,490 --> 00:39:07,310
నేను అనేక ints వంటి కేటాయించిన చేసిన
నేను అవసరం - ఒక, రెండు, మూడు,

834
00:39:07,310 --> 00:39:09,100
నాలుగు, ఐదు, ఆరు -

835
00:39:09,100 --> 00:39:11,660
అప్పుడు నేను సంఖ్యలు నిల్వ చేసిన
ఈ శ్రేణి యొక్క లోపల.

836
00:39:11,660 --> 00:39:15,220
కానీ ఊహించు, అప్పుడు, నేను ఇన్సర్ట్ అనుకుంటున్నారా
సంఖ్య 8 వంటి విలువ?

837
00:39:15,220 --> 00:39:16,100
బాగా, అది గడిచిపోయింది?

838
00:39:16,100 --> 00:39:18,530
నేను ఇన్సర్ట్ మీరు ఊహించు
20 వంటి అనేక.

839
00:39:18,530 --> 00:39:19,790
బాగా, అది గడిచిపోయింది?

840
00:39:19,790 --> 00:39:23,160
ఎక్కడా కూడా మధ్యలో,
లేదా సంఖ్య 35 వెళ్ళడానికి ఉంది

841
00:39:23,160 --> 00:39:24,010
ఎక్కడా చివరిలో.

842
00:39:24,010 --> 00:39:25,320
కానీ నేను స్థలం అల్ అవ్ట్ రెడీ.

843
00:39:25,320 --> 00:39:29,120
>> అందువలన ఈ ఒక ప్రాథమిక సవాలు
పరిష్కారం లేని శ్రేణుల.

844
00:39:29,120 --> 00:39:32,280
నేను GetString, ఒక క్షణం క్రితం పేర్కొన్నారు
ఈ సమస్యను పరిష్కరించే.

845
00:39:32,280 --> 00:39:37,380
మీరు ఒక ఆరవ సంఖ్య ఇన్సర్ట్ అనుకొంటే
ఈ శ్రేణి లోకి, కనీసం ఒక ఏమిటి

846
00:39:37,380 --> 00:39:40,090
పరిష్కారం మీరు ఖచ్చితంగా తిరిగి రావొచ్చు
మేము GetString సంబంధం వంటి?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
ఆ ఏమిటి?

849
00:39:46,030 --> 00:39:48,190
>> బాగా, అది పెద్ద నిర్ధారించుకోండి
సులభంగా పూర్తి కంటే చెప్పారు.

850
00:39:48,190 --> 00:39:52,810
మేము తప్పనిసరిగా అర్రే చేయలేరు
పెద్ద, కానీ మేము ఏమి చేయవచ్చు?

851
00:39:52,810 --> 00:39:56,570
పరిమాణం యొక్క పెద్ద యొక్క ఒక కొత్త శ్రేణి, చేయండి
6, లేదా ఉండవచ్చు పరిమాణం 10, మేము కావాలా

852
00:39:56,570 --> 00:40:00,490
ముందుకు విషయాలు పొందుటకు, ఆపై కాపీ
పాత నూతన శ్రేణి, ఆపై

853
00:40:00,490 --> 00:40:01,680
పాత శ్రేణి విడిపించేందుకు.

854
00:40:01,680 --> 00:40:05,770
>> కానీ నడుస్తున్న సమయం ఏమిటి
ఇప్పుడు ఆ ప్రక్రియలో?

855
00:40:05,770 --> 00:40:09,870
ఇది n యొక్క పెద్ద O ఎందుకంటే కాపీ
మీరు కొన్ని యూనిట్లు ఖర్చు కానుంది

856
00:40:09,870 --> 00:40:13,480
మేము సమయం, కాబట్టి ఆదర్శ లేకపోతే
వెళ్తున్నారు ఇది ఒక కొత్త శ్రేణి, కేటాయించుటకు

857
00:40:13,480 --> 00:40:15,610
రెట్టింపు వినియోగించాయి
తాత్కాలికంగా మెమరీ.

858
00:40:15,610 --> 00:40:16,660
నూతన పాత కాపీ -

859
00:40:16,660 --> 00:40:18,800
నా ఉద్దేశ్యం, అది కేవలం ఒక తలనొప్పి, వార్తలు ఇది
, మళ్ళీ, ఎందుకు మేము రాశాడు ఉంది

860
00:40:18,800 --> 00:40:19,920
మీరు కోసం GetString.

861
00:40:19,920 --> 00:40:21,380
>> మేము బదులుగా సో ఏమి ఉండవచ్చు?

862
00:40:21,380 --> 00:40:25,000
బాగా, ఏమి మా డేటా నిర్మాణం
నిజానికి ఇది లోపాలను కలిగి ఉంది?

863
00:40:25,000 --> 00:40:30,790
నేను కలిగి నా లక్ష్యం విశ్రాంతి అని ఊహించు
మెమరీ ఆనుకొని రాళ్లను, పేరు 9

864
00:40:30,790 --> 00:40:34,500
ఇది 17, హక్కు తదుపరి
కుడి 22 పక్కన, మరియు అందువలన న.

865
00:40:34,500 --> 00:40:39,570
>> మరియు 9 ఇక్కడ పైగా ఉండవచ్చు ఊహించు
RAM, మరియు 17, RAM లో ఇక్కడ చేయవచ్చు

866
00:40:39,570 --> 00:40:40,990
మరియు 22 RAM లో ఇక్కడ చేయవచ్చు.

867
00:40:40,990 --> 00:40:43,610
ఇతర మాటలలో, నేను అవసరం లేదు
కూడా ఇకపై వెనుకకు తిరిగి.

868
00:40:43,610 --> 00:40:47,850
నేను ఏదో ఒకవిధంగా ఒక సూది దారం కలిగి
ఈ సంఖ్యలు ప్రతి లేదా ప్రతి ద్వారా

869
00:40:47,850 --> 00:40:51,010
ఈ గ్రంథుల, మేము కాల్ చేస్తాము
నేను వాటిని డ్రా చేసిన వంటి దీర్ఘ చతురస్రాలు కు

870
00:40:51,010 --> 00:40:55,670
గత ఎలా పొందాలో గుర్తు
మొదటి నుంచి నోడ్.

871
00:40:55,670 --> 00:40:59,940
>> సో ప్రోగ్రామింగ్ నిర్మించేందుకు ఏమిటి
మేము చాలా ఇటీవల చూసిన ఇది నేను

872
00:40:59,940 --> 00:41:03,030
ఆ థ్రెడ్ అమలు, లేదా
, ఇక్కడ డ్రా నేను తో

873
00:41:03,030 --> 00:41:05,430
ఆ బాణాలు అమలు?

874
00:41:05,430 --> 00:41:06,500
సో గమనికలు, కుడి?

875
00:41:06,500 --> 00:41:09,560
నేను ఒక లేదు కేటాయించుటకు ఉంటే
Int, కానీ ఒక నోడ్ - మరియు ద్వారా

876
00:41:09,560 --> 00:41:10,810
నోడ్, నేను కంటైనర్ అర్థం.

877
00:41:10,810 --> 00:41:12,900
మరియు దృష్టి, నేను ఒక దీర్ఘ చతురస్రం అర్థం.

878
00:41:12,900 --> 00:41:16,420
ఒక నోడ్ స్పష్టంగా అవసరం కాబట్టి
రెండు విలువలు కలిగి -

879
00:41:16,420 --> 00:41:21,490
Int కూడా, ఆపై, వంటి సూచించినట్లు
దీర్ఘ చతురస్రం యొక్క దిగువ సగం,

880
00:41:21,490 --> 00:41:23,010
ఒక Int కోసం తగినంత స్థలం.

881
00:41:23,010 --> 00:41:26,130
>> సో కేవలం, ఇక్కడ ముందుకు ఆలోచిస్తూ
ఈ నోడ్ ఈ, ఎలా పెద్దది

882
00:41:26,130 --> 00:41:27,170
ప్రశ్న లో కంటైనర్?

883
00:41:27,170 --> 00:41:29,250
Int కోసం ఎన్ని బైట్లు?

884
00:41:29,250 --> 00:41:31,310
బహుశా 4, అది ఉంటే
సాధారణ అదే.

885
00:41:31,310 --> 00:41:33,270
ఆపై ఎన్ని బైట్లు
పాయింటర్ కోసం?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
సో ఈ కంటైనర్, లేదా ఈ నోడ్, ఉంది
ఒక 8-బైట్ నిర్మాణం కానుంది.

888
00:41:37,940 --> 00:41:41,760
ఓహ్, మరియు ఒక సంతోషంగా యాధృచ్చికంగా ఆ
మేము కేవలం ఈ భావన పరిచయం

889
00:41:41,760 --> 00:41:44,400
ఒక struct, లేదా ఒక సి నిర్మాణం.

890
00:41:44,400 --> 00:41:48,890
>> సో నేను ఒక అడుగు తీసుకోవాలని కావలసిన క్లెయిమ్
ఈ మరింత ఆధునిక వైపు

891
00:41:48,890 --> 00:41:52,560
సంఖ్యల జాబితా, ఒక అమలు
సంఖ్యల లింక్ జాబితా, నేను ఒక చెయ్యాల్సిన

892
00:41:52,560 --> 00:41:56,920
కొంచెం ముందు అప్ ఆలోచన మరియు
కేవలం ఒక Int, కానీ ఒక struct డిక్లేర్

893
00:41:56,920 --> 00:41:58,620
నేను కాల్ మేము సాంప్రదాయబద్ధంగా
ఇక్కడ, నోడ్.

894
00:41:58,620 --> 00:42:01,630
మేము అది మేము కావలసిన ఏదైనా కాల్, కానీ
నోడ్ చాలా నేపథ్య అవతరిస్తుంది

895
00:42:01,630 --> 00:42:03,560
విషయాలు మేము ఇప్పుడు చూడటం మొదలు.

896
00:42:03,560 --> 00:42:06,480
>> ఆ నోడ్ లోపల ఒక Int n.

897
00:42:06,480 --> 00:42:09,350
ఆపై ఈ సింటాక్స్, కొద్దిగా
మొదటి చూపులో అదృష్టము -

898
00:42:09,350 --> 00:42:12,960
struct నోడ్ * తదుపరి.

899
00:42:12,960 --> 00:42:16,900
బాగా చిత్రాల, ఆ ఏమిటి?

900
00:42:16,900 --> 00:42:21,000
ఆ దిగువన సగం ఉంటుంది
మేము చూసిన దీర్ఘచతురస్ర

901
00:42:21,000 --> 00:42:22,730
కేవలం ఒక క్షణం క్రితం.

902
00:42:22,730 --> 00:42:27,600
>> కానీ నేను * struct నోడ్ మాట్లాడుతూ చేస్తున్నాను
కేవలం నోడ్ * వ్యతిరేకంగా?

903
00:42:27,600 --> 00:42:31,370
ఆ పాయింటర్ సూచిస్తుంది ఉంటే ఎందుకంటే
మరొక నోడ్, అది కేవలం వార్తలు

904
00:42:31,370 --> 00:42:32,760
ఒక నోడ్ చిరునామా.

905
00:42:32,760 --> 00:42:35,630
మేము దాన్ని స్థిరంగా ఉండే
ఇప్పటివరకు గమనికలు గురించి చర్చించారు.

906
00:42:35,630 --> 00:42:39,690
నేను దావా అయితే ఎందుకు, ఈ నిర్మాణం
కణుపు అని పిలిచే, నేను struct చెప్పటానికి కలిగి లేదు

907
00:42:39,690 --> 00:42:42,660
ఇక్కడ లోపల నోడ్?

908
00:42:42,660 --> 00:42:43,190
>> సరిగ్గా.

909
00:42:43,190 --> 00:42:46,490
ఇది C. ఒక తెలివితక్కువదని రియాలిటీ విధమైన వార్తలు
typedef, మాట్లాడటానికి, కాదు ఉంది

910
00:42:46,490 --> 00:42:47,220
ఇంకా జరిగింది.

911
00:42:47,220 --> 00:42:48,510
సి సాహిత్య సూపర్ ఉంది.

912
00:42:48,510 --> 00:42:51,050
ఇది మీ కోడ్ పైకి చదివి
దిగువన, ఎడమ.

913
00:42:51,050 --> 00:42:54,930
మరియు వరకు ఆ సెమికోలన్ హిట్స్
బాటమ్ లైన్, వాటిని అంచనా

914
00:42:54,930 --> 00:42:57,590
ఒక దత్తాంశ ఉన్నాయి?

915
00:42:57,590 --> 00:42:59,060
నోడ్, కోట్ unquote నోడ్.

916
00:42:59,060 --> 00:43:03,050
>> కానీ మరింత మందమైన యొక్క
ప్రకటన నేను మొదటి పంక్తిలో చేసింది -

917
00:43:03,050 --> 00:43:05,340
typedef struct నోడ్ -

918
00:43:05,340 --> 00:43:08,790
ఆ ముందు వచ్చింది ఎందుకంటే
గిరజాల కలుపులు, వంటి విధమైన అని

919
00:43:08,790 --> 00:43:11,800
ముందు చదువు గణగణమని ద్వని చేయు, మీరు
ఏమి, నాకు ఒక struct ఇవ్వాలని

920
00:43:11,800 --> 00:43:13,570
struct కణుపు అని పిలిచే.

921
00:43:13,570 --> 00:43:16,270
స్పష్టముగా, నేను కాల్ విషయాలు నచ్చలేదు
struct నోడ్, struct నోడ్ అన్ని

922
00:43:16,270 --> 00:43:17,090
నా కోడ్ అంతటా.

923
00:43:17,090 --> 00:43:20,660
కానీ నేను మాత్రమే, కేవలం లోపల, ఒకసారి ఉపయోగించండి
కాబట్టి నేను సమర్థవంతంగా చేయవచ్చు

924
00:43:20,660 --> 00:43:25,010
, వృత్తాకార సూచన ఒక విధమైన కాదు సృష్టించడానికి
ఒక పర్ సే నాకు పాయింటర్, కానీ ఒక

925
00:43:25,010 --> 00:43:29,400
మరొక కు పాయింటర్
ఒక ఏకరూప రకం.

926
00:43:29,400 --> 00:43:32,330
>> కనుక దీనిని మారుతుంది ఒక డేటా నిర్మాణం
ఈ వంటి, కొన్ని ఉంది

927
00:43:32,330 --> 00:43:34,470
కావచ్చు క్రియలకు
మాకు ఆసక్తి.

928
00:43:34,470 --> 00:43:37,460
మేము ఇన్సర్ట్ అనుకొనుచున్న
ఈ వంటి ఒక జాబితాలో.

929
00:43:37,460 --> 00:43:39,850
మేము తొలగించాలనుకుంటున్నారా ఉండవచ్చు
ఈ వంటి ఒక జాబితా నుండి.

930
00:43:39,850 --> 00:43:43,490
మేము ఒక జాబితాలో అన్వేషణ అనుకొనుచున్న
విలువ, లేదా మరింత సాధారణంగా, యాత్ర.

931
00:43:43,490 --> 00:43:46,410
మరియు యాత్ర కేవలం ఒక ఫాన్సీ మార్గం
ఎడమ ప్రారంభం మాట్లాడుతూ మరియు అన్ని తరలించడానికి

932
00:43:46,410 --> 00:43:47,650
కుడి మార్గం.

933
00:43:47,650 --> 00:43:52,640
>> మరియు కూడా ఈ కొద్దిగా ఎక్కువ నోటీసు,
అధునాతన డేటా నిర్మాణం, వీలు

934
00:43:52,640 --> 00:43:56,510
నాకు మేము కొన్ని రుణాలు తీసుకునే ప్రతిపాదించారు
గత రెండు వారాల ఆలోచనలు మరియు

935
00:43:56,510 --> 00:43:58,410
అని ఒక ఫంక్షన్ అమలు
ఈ వంటి అన్వేషణ.

936
00:43:58,410 --> 00:44:01,360
ఇది లేదా నిజమైన తిరిగి జరగబోతోంది
, తప్పుడు సూచిస్తుంది అవును లేదా

937
00:44:01,360 --> 00:44:03,390
ఏ, n జాబితా ఉంది.

938
00:44:03,390 --> 00:44:05,960
దాని రెండవ వాదన పాయింటర్ గా
జాబితా కూడా, కాబట్టి ఒక

939
00:44:05,960 --> 00:44:07,920
ఒక నోడ్ కు పాయింటర్.

940
00:44:07,920 --> 00:44:10,350
>> నేను చేయ బోతున్నాను అన్ని డిక్లేర్ ఉంది
ఒక తాత్కాలిక వేరియబుల్.

941
00:44:10,350 --> 00:44:12,730
మేము సమావేశం ద్వారా PTR కాల్ చేస్తాము
పాయింటర్ కోసం.

942
00:44:12,730 --> 00:44:15,220
మరియు నేను దానిని సమానంగా కేటాయించి
జాబితా ప్రారంభం.

943
00:44:15,220 --> 00:44:16,680
>> మరియు ఇప్పుడు అయితే లూప్ గమనించవచ్చు.

944
00:44:16,680 --> 00:44:20,640
చాలా కాలం పాయింటర్ సమానం కాదు వంటి
శూన్యం, నేను తనిఖీ వెళుతున్న.

945
00:44:20,640 --> 00:44:24,520
ఉంది పాయింటర్ బాణం n సమానంగా
ఆమోదించబడింది ఆ n?

946
00:44:24,520 --> 00:44:26,410
కొత్త - మరియు ఒక నిమిషం వేచి
సింటెక్స్ ముక్క.

947
00:44:26,410 --> 00:44:29,324
బాణం ఆకస్మికంగా ఏమిటి?

948
00:44:29,324 --> 00:44:30,574
అవును?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> సరిగ్గా.

951
00:44:34,810 --> 00:44:38,860
సో అయితే కొన్ని నిమిషాల క్రితం, మేము ఉపయోగించే
ఏదో ఆక్సెస్ చెయ్యడానికి డాట్ సంజ్ఞామానం

952
00:44:38,860 --> 00:44:43,080
ఒక struct లోపలి వేరియబుల్ ఉంటే
మీరు struct కాదు చేశారు

953
00:44:43,080 --> 00:44:47,420
కూడా, కానీ ఒక struct ఒక పాయింటర్,
అదృష్టవశాత్తూ, సింటెక్స్ ఒక ముక్క ఆ

954
00:44:47,420 --> 00:44:48,620
చివరకు సహజమైన అర్ధమే.

955
00:44:48,620 --> 00:44:52,360
బాణం, పాయింటర్ అనుసరించండి అర్థం
మా బాణాలు సాధారణంగా అర్ధం వంటి

956
00:44:52,360 --> 00:44:56,570
చిత్రాల, మరియు వెళ్ళి
డేటా పొలాలలో.

957
00:44:56,570 --> 00:44:59,700
సో బాణం డాట్ అదే విషయం, కానీ
మీరు ఒక పాయింటర్ ఉన్నప్పుడు మీరు దాన్ని ఉపయోగించండి.

958
00:44:59,700 --> 00:45:05,270
>> సో కేవలం, అప్పుడు రీక్యాప్ ఉంటే n రంగంలో
struct లోపలి పాయింటర్ అని

959
00:45:05,270 --> 00:45:07,760
సమానం n సమానం, నిజమైన తిరిగి.

960
00:45:07,760 --> 00:45:11,970
లేకపోతే, ఈ లైన్ - పాయింటర్
తదుపరి పాయింటర్ సమానం.

961
00:45:11,970 --> 00:45:17,540
సో ఈ చేస్తున్నది, నోటీసు, ఉంటే నేను
ప్రస్తుతం struct వద్ద గురిపెట్టి చేస్తున్నాను

962
00:45:17,540 --> 00:45:21,430
9 మరియు 9 కలిగి సంఖ్య కాదు
నేను చూస్తున్నాను - నేను చూస్తున్నాను ఊహించు

963
00:45:21,430 --> 00:45:22,830
కోసం n 50 సమానం -

964
00:45:22,830 --> 00:45:25,930
నా తాత్కాలిక పాయింటర్ అప్డేట్ వెళుతున్న
ఈ నోడ్ సమయంలో లేదు

965
00:45:25,930 --> 00:45:31,190
ఇకపై, కానీ పాయింటర్ బాణం తదుపరి, ఇది
ఇక్కడ నాకు అప్ చాలు అన్నారు.

966
00:45:31,190 --> 00:45:34,270
>> ఇప్పుడు, నేను ఒక సుడిగాలి ఉంది గ్రహించారు
పరిచయం.

967
00:45:34,270 --> 00:45:37,380
బుధవారం, మేము నిజానికి చేస్తాను
కొన్ని మానవుల మరియు కొన్ని ఎక్కువ

968
00:45:37,380 --> 00:45:38,900
ఒక నెమ్మదిగా కోడ్.

969
00:45:38,900 --> 00:45:42,990
కానీ గుర్తించిన మేము ఇప్పుడు మా డేటా చేస్తున్న
నిర్మాణాలు క్లిష్టమైన కనుక మా

970
00:45:42,990 --> 00:45:45,780
అల్గోరిథంలు, మరింత సమర్థవంతమైన పొందవచ్చు ఇది
కోసం అవసరమైన అవతరిస్తుంది

971
00:45:45,780 --> 00:45:50,500
pset ఆరు, మేము మళ్ళీ, లో లోడ్ చేసినప్పుడు, ఆ
150,000 పదాలు, కానీ అలా చెయ్యాల్సి

972
00:45:50,500 --> 00:45:55,650
సమర్ధవంతంగా, మరియు ఆదర్శంగా ఒక సృష్టించడానికి
మా వినియోగదారులు లో నడుస్తుంది కార్యక్రమం

973
00:45:55,650 --> 00:46:00,460
సరళ, కాదు స్క్వేర్డ్ n లో, అయితే
ఆదర్శ నిరంతరం సమయం,.

974
00:46:00,460 --> 00:46:02,300
>> మేము బుధవారం మీరు చూస్తారు.

975
00:46:02,300 --> 00:46:07,240
>> SPEAKER: తదుపరి CS50, డేవిడ్ వద్ద
తన బేస్ కేసు మర్చిపోతోంది.

976
00:46:07,240 --> 00:46:12,770
>> DAVID మలన్: ఆ మీరు పంపే ఎలా
తో టెక్స్ట్ సందేశాలను C. ఏం -

977
00:46:12,770 --> 00:46:14,020
>> [వివిధ టెక్స్ట్ సందేశం
నోటిఫికేషన్ ధ్వనులు]

978
00:46:14,020 --> 00:46:19,734