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

2
00:00:10,970 --> 00:00:12,536
>> డేవిడ్ J. మలన్: అన్ని కుడి.

3
00:00:12,536 --> 00:00:13,392
>> [నవ్వు]

4
00:00:13,392 --> 00:00:14,240
>> స్వాగతము.

5
00:00:14,240 --> 00:00:14,990
ఈ CS50 ఉంది.

6
00:00:14,990 --> 00:00:16,890
మరియు ఈ వారం ఐదు ముగింపు.

7
00:00:16,890 --> 00:00:20,020
మరియు ఇప్పుడు వరకు, మేము చాలా చాలా చేసిన
మంజూరు కోసం తీసుకోవడం ఉండనే

8
00:00:20,020 --> 00:00:23,480
మీరు ఈ కంపైలర్, గణగణమని ద్వని చేయు, ఉంది
ఈ మార్గం ద్వారా ప్రారంభించడం జరిగింది

9
00:00:23,480 --> 00:00:27,100
ఇతర సాధనం అని ఏదో చేయండి అని
అద్భుతంగా సోర్స్ కోడ్ మారుస్తుంది

10
00:00:27,100 --> 00:00:31,350
వస్తువు కోడ్, సున్నాలు మరియు వాటిని లోకి
మీ కంప్యూటర్ల CPU, కేంద్ర

11
00:00:31,350 --> 00:00:33,410
ప్రాసెసింగ్ యూనిట్, నిజానికి అర్థం.

12
00:00:33,410 --> 00:00:36,770
ఈ సంఖ్య ఉంది బయటకు కానీ యదావశాత్తు
లో హుడ్ కింద జరగబోతోంది

13
00:00:36,770 --> 00:00:38,690
ఇన్పుట్ మరియు అవుట్పుట్ మధ్య.

14
00:00:38,690 --> 00:00:41,800
>> మరియు నేను మేము మాంసం ప్రతిపాదించారు అవ్వాలనుకుంటే
కొద్దిగా ఎక్కువ వివరాలను లో ఆ

15
00:00:41,800 --> 00:00:45,130
ఈ నాలుగు దశలు, అని ఏదో కలిగి
ముందు ప్రాసెసింగ్, ఏదో

16
00:00:45,130 --> 00:00:48,300
మేము చూసిన ఇది సేకరించి, అని
ఏదో ఏర్పాటు అని, మరియు

17
00:00:48,300 --> 00:00:49,420
ఏదో లింక్ అని.

18
00:00:49,420 --> 00:00:53,270
కాబట్టి ఇప్పుడు వరకు, మా యొక్క కొన్ని
కార్యక్రమాలు, మేము పదునైన కలిగి ఉంది.

19
00:00:53,270 --> 00:00:56,650
ఇటీవల మేము కొన్ని పదునైన చేశాము
స్థిరాంకాలు కోసం నిర్వచిస్తుంది.

20
00:00:56,650 --> 00:01:00,660
కనుక దీనిని మారుతుంది ఆ విషయాలు ఆ
హాష్ చిహ్నం లేదా కలిగి ఉంటాయి

21
00:01:00,660 --> 00:01:04,150
పౌండ్ గుర్తు ప్రి ప్రాసెసర్ ఉన్నాయి
మార్గదర్శకాలు.

22
00:01:04,150 --> 00:01:07,960
కేవలం అది తెలిపారు యొక్క ఫాన్సీ మార్గం
నిజానికి ఆ కోడ్ యొక్క ఒక లైన్

23
00:01:07,960 --> 00:01:12,280
ముందు ఏదో మార్చబడింది
కంప్యూటర్ కూడా మార్చేందుకు ప్రయత్నించవద్దని మీ

24
00:01:12,280 --> 00:01:13,800
సున్నాలు మరియు వాటిని ప్రోగ్రామ్.

25
00:01:13,800 --> 00:01:19,000
>> ఉదాహరణకు, పదునైన ప్రామాణిక కలిగి
I / O. H, అందంగా చాలా కేవలం వెళ్ళి అర్ధం

26
00:01:19,000 --> 00:01:24,010
ముందుకు, ఫైళ్లు విషయాలు పట్టుకోడానికి
stdio.h మరియు అక్కడే పెట్టండి.

27
00:01:24,010 --> 00:01:25,880
అందువలన సున్నాలు మరియు వాటిని
ఇంకా ఆ సమయంలో.

28
00:01:25,880 --> 00:01:27,470
ఇది నిజంగా కేవలం ఒక ప్రతిక్షేపణ వార్తలు.

29
00:01:27,470 --> 00:01:30,790
మరియు అని పిలవబడే సమయంలో ప్రదర్శనతో
ముందు ప్రాసెసింగ్ దశ, మీరు

30
00:01:30,790 --> 00:01:34,230
నిజానికి ప్రత్యేకంగా గణగణమని ద్వని చేయు అమలు లేదా
చాలా సందర్భాలలో చేయండి.

31
00:01:34,230 --> 00:01:36,950
సో ఈ జరుగుతున్న చెయ్యబడింది
మొదటి స్వయంచాలకంగా ఇప్పటివరకు.

32
00:01:36,950 --> 00:01:38,800
>> అప్పుడు సంకలనం దశల వస్తుంది.

33
00:01:38,800 --> 00:01:40,920
కానీ మేము అతిగా సులభతరం చేసిన
సంగ్రహం.

34
00:01:40,920 --> 00:01:45,060
ఒక ప్రోగ్రామ్ కంపైల్ నిజంగా అర్థం
, సి ఏదో నమ్ము

35
00:01:45,060 --> 00:01:48,430
సోర్స్ కోడ్ మేము డౌన్, వ్రాస్తున్నానని చేసిన
ఏదో అసెంబ్లీ అని కు.

36
00:01:48,430 --> 00:01:52,900
అసెంబ్లీ భాష తక్కువ స్థాయి
భాష, అదృష్టవశాత్తూ, మేము లేదు

37
00:01:52,900 --> 00:01:55,480
చాలా సందర్భాన్ని చేశారు
ఈ సెమిస్టర్ వ్రాయండి.

38
00:01:55,480 --> 00:01:59,100
కానీ అది తక్కువ స్థాయిలో ఉంది
మీరు వాచ్యంగా రాయటం మొదలుపెట్టాలని అర్థంలో

39
00:01:59,100 --> 00:02:04,270
జోడించడానికి మరియు వ్యవకలనం మరియు గుణిస్తారు మరియు లోడ్
మెమరీ నుండి మరియు సేవ్ జ్ఞాపకార్ధం

40
00:02:04,270 --> 00:02:08,259
చాలా ప్రాథమిక సూచనలను ఒక కంప్యూటర్,
హుడ్ కింద,

41
00:02:08,259 --> 00:02:09,639
నిజానికి అర్థం.

42
00:02:09,639 --> 00:02:14,930
>> చివరగా, నిర్మాణం ఆ భాష పడుతుంది
మేము కూడా చేసిన సున్నాలు మరియు వాటిని

43
00:02:14,930 --> 00:02:16,190
ఇప్పటివరకు వివరిస్తూ.

44
00:02:16,190 --> 00:02:19,270
నిజంగా చివరగా, అని పిలవబడే ఉంది
దశ లింక్, ఇది మేము చేస్తాము

45
00:02:19,270 --> 00:02:22,360
కలిపిన కేవలం ఒక క్షణం, లో చూడండి
మీ సున్నాలు మరియు సున్నాలు ఉన్నవారు మరియు

46
00:02:22,360 --> 00:02:24,870
ముందు వాటిని ఇతర వ్యక్తులు
మీరు సృష్టించారు.

47
00:02:24,870 --> 00:02:26,660
>> సో ఈ సూపర్ సాధారణ ప్రోగ్రామ్ పరిగణలోకి.

48
00:02:26,660 --> 00:02:27,560
ఇది వీక్ 1 నుండి.

49
00:02:27,560 --> 00:02:29,610
ఇది కేవలం, హలో, అన్నారు
తెరపై.

50
00:02:29,610 --> 00:02:30,920
మేము గణగణమని ద్వని చేయు ద్వారా ఈ నడిచింది.

51
00:02:30,920 --> 00:02:33,200
లేదా మేము అది ద్వారా మేక్ అమలు
ఇది గణగణమని ద్వని చేయు నడిచింది.

52
00:02:33,200 --> 00:02:36,170
మరియు సమయంలో outputted పేరు
కొన్ని సున్నాలు మరియు వాటిని.

53
00:02:36,170 --> 00:02:38,100
అక్కడ అవ్ట్ కానీ యదావశాత్తు
ఇంటర్మీడియట్ దశ.

54
00:02:38,100 --> 00:02:40,460
నేను ఇక్కడ వెళ్ళి ఉంటే - oops, కాదు
ఇంకా అతనికి చూడాలనుకుంటే.

55
00:02:40,460 --> 00:02:44,800
నా ఉపకరణం ఇక్కడ వెళ్ళి ఉంటే
మరియు నేను hello.c, ఇక్కడ ప్రారంభించిన

56
00:02:44,800 --> 00:02:46,160
అదే కార్యక్రమం.

57
00:02:46,160 --> 00:02:48,600
మరియు నేను నా టెర్మినల్ లో చేయ బోతున్నాను
ఇక్కడ విండో నేను వెళుతున్న ఉంది

58
00:02:48,600 --> 00:02:51,430
, గణగణమని ద్వని చేయు అమలు కాకుండా చేస్తుంది
అన్ని నాలుగు స్వయంచాలకం

59
00:02:51,430 --> 00:02:52,870
మాకు ఆ దశలను.

60
00:02:52,870 --> 00:02:58,620
మరియు నేను గణగణమని ద్వని చేయు-S చేయబోవడం మరియు వెబ్
ఎంటర్ తరువాత hello.c మరియు తరువాత.

61
00:02:58,620 --> 00:03:00,590
>> మరియు నేను ఒక మెరిసే ప్రాంప్ట్ పొందుటకు
మళ్ళీ, ఇది మంచి.

62
00:03:00,590 --> 00:03:05,280
మరియు ఇప్పుడు కొద్దిగా పెద్ద విండోలో,
నేను ఇక్కడ gedit తెరవటానికి వెళుతున్నాను.

63
00:03:05,280 --> 00:03:09,610
మరియు నేను, ఒక ఫైల్ తెరుచుకుంటుంది వెళుతున్నాను
హాజరవుతారు, hello.s పిలుస్తారు

64
00:03:09,610 --> 00:03:11,870
అసెంబ్లీ భాష కలిగి
నేను ముందు సూచిస్తారు.

65
00:03:11,870 --> 00:03:15,060
మరియు ఈ అసెంబ్లీ అని ఏమిటి
భాష, బొత్తిగా తక్కువ స్థాయి

66
00:03:15,060 --> 00:03:18,470
సూచనలు మీ ఇంటెల్ CPU
లేదా అది లోపల ఉంది

67
00:03:18,470 --> 00:03:19,350
అర్థం.

68
00:03:19,350 --> 00:03:24,480
మరియు MOV ఎత్తుగడకు ఉంది. కాల్ కోసం
, చాలా తక్కువ స్థాయిలో చర్యను కాల్.

69
00:03:24,480 --> 00:03:26,380
ఉప తీసివేయి కోసం.

70
00:03:26,380 --> 00:03:30,370
>> మీరు లోపల ఒక ప్రత్యేక CPU దానిమూలంగా ఉన్నప్పుడు
మీ కంప్యూటర్ యొక్క, అది చేస్తుంది

71
00:03:30,370 --> 00:03:34,300
న ప్రత్యేక ప్రతిగా ఇతర CPU లు
మార్కెట్, ఇది సూచనలను అది

72
00:03:34,300 --> 00:03:39,460
అర్థం మరియు తరచుగా ఎలా సమర్థవంతంగా ఇది
ఇది కొన్ని అమలు ఎంత వేగంగా ఉంది

73
00:03:39,460 --> 00:03:40,380
ఆ సూచనలను.

74
00:03:40,380 --> 00:03:45,150
ఇప్పుడు ఈ మరింత కోసం, మీరు పట్టవచ్చు
కళాశాల తర్వాత పతనం CS61.

75
00:03:45,150 --> 00:03:48,170
కానీ ఇక్కడ మేము కొన్ని, ఉదాహరణకు, కలిగి
తెలిసిన చూడండి ఉండవచ్చు గుర్తింపుదారులను.

76
00:03:48,170 --> 00:03:50,150
hello.c కార్యక్రమం పేరు.

77
00:03:50,150 --> 00:03:51,070
>> . టెక్స్ట్ -

78
00:03:51,070 --> 00:03:54,190
ఆసక్తి ఎక్కువ అక్కడ కాదు
ఇప్పుడు, గుర్తు టెక్స్ట్

79
00:03:54,190 --> 00:03:59,190
పేరు లో భాగం, సోమవారం నాటికి, ఉంది
మెమరీ మీ ప్రోగ్రామ్ నిజానికి ముగుస్తుంది.

80
00:03:59,190 --> 00:04:01,330
తద్వారా కనీసం అస్పష్టంగా వార్తలు
అక్కడ తెలిసిన.

81
00:04:01,330 --> 00:04:03,730
ఇక్కడ, కోర్సు యొక్క, ఒక ప్రస్తావన ఉంది
మా ప్రధాన విధి యొక్క.

82
00:04:03,730 --> 00:04:07,220
డౌన్ స్క్రోలింగ్, ఈ విషయాలను సూచిస్తాయి
పిలవబడే నమోదులను చిన్న రాళ్లను

83
00:04:07,220 --> 00:04:09,190
మీ వాస్తవ CPU యొక్క మెమరీ లోపల.

84
00:04:09,190 --> 00:04:12,930
మరియు నేను కూడా డౌన్ స్క్రోల్ చేయండి
మరింత నేను కొంత చూడండి

85
00:04:12,930 --> 00:04:14,240
ASCII యొక్క పరోక్ష ప్రస్తావన.

86
00:04:14,240 --> 00:04:17,120
మరియు, నిజానికి, ఆ స్ట్రింగ్ ఉంది
హలో, కామా, ప్రపంచ.

87
00:04:17,120 --> 00:04:20,079
>> చాలా కాలం కథ చిన్న, ఈ ఉంది
, స్వయంచాలకంగా మీరు కోసం జరుగుతున్న

88
00:04:20,079 --> 00:04:22,140
హుడ్ కింద ఈ సమయంలో అన్ని.

89
00:04:22,140 --> 00:04:26,450
ఏ జరుగుతున్న చేయబడింది నిజంగా ఒకసారి ఉంది
మీరు గణగణమని ద్వని చేయు అమలు, లేదా ద్వారా చేసిన

90
00:04:26,450 --> 00:04:29,150
, మీరు మొదటి పొందుతుంటే, చేయండి
సోర్స్ కోడ్ నుండి,

91
00:04:29,150 --> 00:04:30,700
అసెంబ్లీ భాష అని పిలుస్తారు.

92
00:04:30,700 --> 00:04:35,210
అప్పుడు గణగణమని ద్వని చేయు ఈ అసెంబ్లీ మార్పిడి ఉంది
డౌన్ సున్నాలు మరియు వాటిని భాష.

93
00:04:35,210 --> 00:04:38,340
మరియు ఈ మేము ప్రారంభించారు స్లయిడ్ ఉంది
వారం 0 లో మా చర్చ -

94
00:04:38,340 --> 00:04:39,840
మరియు ఆ తరువాత వారం 1.

95
00:04:39,840 --> 00:04:44,030
మరియు ఆఖరికి, ఆ సున్నాలు మరియు వాటిని
సున్నాలు మరియు వాటిని కలుపుతారు

96
00:04:44,030 --> 00:04:47,190
ఆ లైబ్రరీలు మేము తీసుకోవడం చేసిన
ప్రామాణిక I / O లేదా వంటి మంజూరు కోసం

97
00:04:47,190 --> 00:04:50,010
స్ట్రింగ్ లైబ్రరీ లేదా
CS50 లైబ్రరీ.

98
00:04:50,010 --> 00:04:54,200
>> సో మరింత ఈ చిత్రాన్ని చిత్రించడానికి
దృష్టి, మేము hello.c కలిగి.

99
00:04:54,200 --> 00:04:57,220
మరియు అది, కోర్సు యొక్క, printf ఉపయోగిస్తుంది
ప్రపంచ హలో, చెప్పటానికి పని.

100
00:04:57,220 --> 00:05:01,810
సంకలన అడుగు దానిని డౌన్ పడుతుంది
ఫైల్ మేము కేవలం కూడా, hello.s చూసింది

101
00:05:01,810 --> 00:05:04,290
సాధారణంగా తొలగించబడింది అని అయితే
స్వయంచాలకంగా మీరు కోసం.

102
00:05:04,290 --> 00:05:06,050
కానీ ఆ అసెంబ్లీ కోడ్ వార్తలు
మధ్య దశలో.

103
00:05:06,050 --> 00:05:09,750
ఆపై మేము అసెంబ్లీ సమీకరించటం ఉన్నప్పుడు
మీరు భాష, అలా మాట్లాడటం, ఆ

104
00:05:09,750 --> 00:05:10,830
ఆ సున్నాలు మరియు వాటిని పొందడానికి.

105
00:05:10,830 --> 00:05:13,920
కాబట్టి మేము నేటి సమర్థవంతంగా జూమ్ చేసిన
ఏ మంజూరు కోసం మేము తీసుకోవడం చేసిన,

106
00:05:13,920 --> 00:05:16,430
సోర్స్ కోడ్ వెళుతున్న అర్థం
కోడ్ వస్తువు.

107
00:05:16,430 --> 00:05:18,850
>> కానీ చివరకు ఇప్పుడు అదే చిత్రాన్ని -
దాని పై బలంగా త్రోయు లెట్స్

108
00:05:18,850 --> 00:05:20,020
ఎడమ వైపు.

109
00:05:20,020 --> 00:05:22,880
మరియు గమనించండి ఆ టాప్ లో ఉన్నాయి
నేను stdio.h పేర్కొన్నారు.

110
00:05:22,880 --> 00:05:25,030
మేము చేర్చాను ఒక ఫైల్ యొక్క
దాదాపు అన్ని లో

111
00:05:25,030 --> 00:05:26,250
మేము వ్రాయలేదు కార్యక్రమాలు.

112
00:05:26,250 --> 00:05:28,830
మరియు వీటి విషయాలు ఫైలు యొక్క
కాపీ అతికించారు చేసుకోగా,

113
00:05:28,830 --> 00:05:30,350
సమర్థవంతంగా మీ కోడ్ పైన.

114
00:05:30,350 --> 00:05:34,170
అయితే, కంప్యూటర్ నుండి మారుతుంది
సిస్టమ్ ఎక్కడో బహుశా ఒక ఉంది

115
00:05:34,170 --> 00:05:39,150
ఎవరైనా సంవత్సరాల వ్రాసాడు stdio.c ఫైలు
క్రితం ఆ అన్ని అమలు

116
00:05:39,150 --> 00:05:41,870
ప్రకటించారు క్రియలు
stdio.h లో.

117
00:05:41,870 --> 00:05:45,465
>> ఇప్పుడు వాస్తవానికి అది బహుశా కాదు
లేదా మీ Mac లేదా మీ PC

118
00:05:45,465 --> 00:05:47,660
CS50 ఉపకరణం ఒక ముడి సి కోడ్.

119
00:05:47,660 --> 00:05:52,710
మరొకరు ఇప్పటికే అది సంకలనం మరియు కూడా
. ఓ వస్తువు కోడ్ ఫైల్ లేదా. ఒక

120
00:05:52,710 --> 00:05:56,020
ఒక భాగస్వామ్యం లైబ్రరీ సూచిస్తుంది ఫైల్,
ముందు ఇన్స్టాల్ మరియు చేయబడింది

121
00:05:56,020 --> 00:05:57,240
మీరు ముందే సంకలనం.

122
00:05:57,240 --> 00:06:01,950
కానీ నిజానికి ఉందని అనుకుందాం
సమాంతరంగా మా కంప్యూటర్ stdio.c న

123
00:06:01,950 --> 00:06:02,650
గణగణమని ద్వని చేయు తో.

124
00:06:02,650 --> 00:06:04,960
మీ కోడ్ కంపైల్ చేయబడిన
మరియు సమావేశం.

125
00:06:04,960 --> 00:06:09,200
stdio.c 's కోడ్ కంపైల్ చేశారు
సమావేశమయ్యారు ఈ ఆఖరి ఆ

126
00:06:09,200 --> 00:06:13,730
ఇక్కడ డౌన్, దశను, మేము ఏదో ఉంటుంది
లింక్, మాట్లాడటానికి, మీ సున్నాలు మరియు వాటిని

127
00:06:13,730 --> 00:06:18,430
ఒక తన లేదా ఆమె సున్నాలు మరియు వాటిని తో
అంతిమంగా సాధారణ ప్రోగ్రామ్

128
00:06:18,430 --> 00:06:20,540
హలో కేవలం అని.

129
00:06:20,540 --> 00:06:23,340
>> తద్వారా ఆ మేజిక్ అన్ని వార్తలు
ఇప్పటివరకు జరుగుతున్న చేశారు.

130
00:06:23,340 --> 00:06:26,430
మరియు ఈ తీసుకోవాలని కొనసాగుతుంది
పద్ధతులు మంజూరు, కాని వసూలు

131
00:06:26,430 --> 00:06:28,750
జూసీ వివరాలు చాలా ఉంది
అక్కడ క్రింద జరగబోతోంది.

132
00:06:28,750 --> 00:06:31,920
మరియు ఈ విధంగా చేస్తుంది మీ
ఇంటెల్ ఇన్సైడ్ తో కంప్యూటర్

133
00:06:31,920 --> 00:06:33,940
ముఖ్యంగా ప్రత్యేక.

134
00:06:33,940 --> 00:06:37,020
>> సో గమనించండి న, మీరు అని కు
ఈ శుక్రవారం అర్హత కోసం మాకు చేరడానికి, గో

135
00:06:37,020 --> 00:06:41,570
సాధారణ స్థానంలో cs50.net/rsvp కు,
1:15 PM ఈ శుక్రవారం.

136
00:06:41,570 --> 00:06:43,400
మరియు ఇప్పుడు కొన్ని ప్రకటనలు.

137
00:06:43,400 --> 00:06:44,670
కనుక మనం కొన్ని మంచి వార్త ఉంది.

138
00:06:44,670 --> 00:06:45,970
మరియు మేము కొన్ని చెడ్డ వార్తలు కలిగి.

139
00:06:45,970 --> 00:06:47,260
ఇక్కడ కొన్ని మంచి వార్తలు ప్రారంభించండి.

140
00:06:47,260 --> 00:06:52,038

141
00:06:52,038 --> 00:06:54,510
>> [GROANING]

142
00:06:54,510 --> 00:06:54,710
>> అన్ని కుడి.

143
00:06:54,710 --> 00:06:56,670
బాగా, అది సాంకేతికంగా ఒక సెలవు వార్తలు
ఇది చాలా మాకు నుండి ఒక బహుమతి కాదు.

144
00:06:56,670 --> 00:06:58,030
కోర్సు యొక్క కానీ అప్పుడు చెడు వార్తలను.

145
00:06:58,030 --> 00:07:00,550

146
00:07:00,550 --> 00:07:01,880
>> [GROANING]

147
00:07:01,880 --> 00:07:03,530
>> నేను సమయం చాలా ఖర్చు
ఈ యానిమేషన్స్.

148
00:07:03,530 --> 00:07:04,690
>> [నవ్వు]

149
00:07:04,690 --> 00:07:07,000
>> ఒక సమీక్ష సెషన్ ఉంటుంది
ఈ సోమవారం వచ్చిన.

150
00:07:07,000 --> 00:07:08,340
ఇది 5:30 PM ఉండటానికి జరగబోతోంది.

151
00:07:08,340 --> 00:07:11,210
మేము అన్ని ఈ వివరాలను మీరు గుర్తు చేస్తుంది
కోర్సు యొక్క మీరు ఇమెయిల్ ద్వారా

152
00:07:11,210 --> 00:07:13,470
రోజుల సమయం కేవలం ఒక జంట లో వెబ్సైట్.

153
00:07:13,470 --> 00:07:16,610
ఇది చిత్రీకరించబడింది మరియు అందుబాటులో ఉంటుంది
కొంతకాలం తర్వాత.

154
00:07:16,610 --> 00:07:19,200
మీరు చేయలేరు కనుక ఆ సోమవారం
రాత్రి స్లాట్, ఆందోళన పడకండి.

155
00:07:19,200 --> 00:07:22,270
విభాగాలు ఈ వచ్చే వారం కూడా
క్విజ్ కోసం సమీక్ష దృష్టి.

156
00:07:22,270 --> 00:07:25,670
మీ విభాగం సోమవారం, న ఉంటే
నిజానికి విశ్వవిద్యాలయంలో సెలవు, మేము

157
00:07:25,670 --> 00:07:26,920
ఇప్పటికీ విభాగంలో కలిసే.

158
00:07:26,920 --> 00:07:28,890
మీరు మామూలుగా చేయలేరు ఉంటే
విభాగం మీరు వెళుతున్న ఎందుకంటే

159
00:07:28,890 --> 00:07:29,860
దూరంగా ఆ మంచిది.

160
00:07:29,860 --> 00:07:33,710
ఆదివారం లేదా మంగళవారం విభాగం లేదా హాజరు
జాసన్ యొక్క భాగం ట్యూన్ ఇన్ ఇది

161
00:07:33,710 --> 00:07:35,110
అందుబాటులో ఆన్లైన్.

162
00:07:35,110 --> 00:07:37,490
>> సో, మరింత చెడ్డ వార్తలు.

163
00:07:37,490 --> 00:07:41,960
సో సిలబస్ ప్రకారం,
మేము తదుపరి శుక్రవారం ఉపన్యాసం కలిగి.

164
00:07:41,960 --> 00:07:43,690
కానీ శుభవార్త -

165
00:07:43,690 --> 00:07:44,860
స్పష్టంగా, నేను ఈ చాలా ఎక్కువ సమయం గడిపేవాడు.

166
00:07:44,860 --> 00:07:45,280
>> [నవ్వు]

167
00:07:45,280 --> 00:07:47,140
>> మేము శుక్రవారం ఉపన్యాసాలు తదుపరి రద్దు చేస్తాము.

168
00:07:47,140 --> 00:07:50,590
సో మాకు ఒక బహుమతి ఉంటుంది, కాబట్టి మీరు
నిజంగా ఒక nice విరామం లో కలిగి ఉండవచ్చు

169
00:07:50,590 --> 00:07:52,990
ఈ వారం అందువలన రెండు వారాల మధ్య.

170
00:07:52,990 --> 00:07:57,460
ఏ ఉపన్యాసాలు తదుపరి వారం, కేవలం ఒక చిన్న కనుక
మీరు ఉండాలి ఇది కొద్దిగా క్విజ్,

171
00:07:57,460 --> 00:07:59,030
పెరుగుతున్న సంతోషిస్తున్నాము విధానం.

172
00:07:59,030 --> 00:08:03,870
>> సో యొక్క ఇప్పుడు మన దృష్టి చెయ్యి వీలు
వాస్తవానికి దృశ్య అని ఏదో

173
00:08:03,870 --> 00:08:06,990
మరియు మరింత ఉత్తేజకరమైన మరియు వేదికను ఏర్పాటు
క్షితిజ సమాంతర ఉండాలి జరగబోతోంది ఏమి కోసం

174
00:08:06,990 --> 00:08:08,420
వారాల సమయం కేవలం ఒక జంట లో.

175
00:08:08,420 --> 00:08:12,160
మొదటి క్విజ్ తరువాత, మేము తెరుద్దాము
మా సమస్య సెట్లు మరొక దృష్టి

176
00:08:12,160 --> 00:08:16,710
డొమైన్ నిర్దిష్ట సమస్య, ఆ
సాధారణంగా ఫోరెన్సిక్స్ లేదా భద్రతా.

177
00:08:16,710 --> 00:08:19,550
>> ఈ సమస్యను నిజానికి, సంప్రదాయం
సెట్ నాకు ఒకటి

178
00:08:19,550 --> 00:08:24,850
అంతటా నడవడానికి తోటి లేదా CA ల బోధన
కొన్ని ఛాయాచిత్రాలను తీసుకొని క్యాంపస్

179
00:08:24,850 --> 00:08:29,450
గుర్తించదగిన కానీ కాని స్పష్టమైన ప్రజలు,
అప్పుడు స్థలాలు, లేదా విషయాలు, ప్రతి సంవత్సరం నేను

180
00:08:29,450 --> 00:08:34,520
ఏదో అనుకోకుండా తొలగించడానికి నిర్వహించండి
లేదా డిజిటల్ మీడియా కార్డ్ చెడగొట్టి

181
00:08:34,520 --> 00:08:35,720
మా కెమెరా లోపల.

182
00:08:35,720 --> 00:08:36,860
కానీ పెద్ద ఒప్పందం.

183
00:08:36,860 --> 00:08:39,200
నేను ముందుకు వెళ్లి ప్రదర్శించాడు చేయవచ్చు
నా కంప్యూటర్ లోకి ఆ.

184
00:08:39,200 --> 00:08:43,010
నేను, అది ఒక ఫోరెన్సిక్ చిత్రం చేయవచ్చు
సున్నాలు కాపీ ద్వారా, మాట్లాడటం మరియు

185
00:08:43,010 --> 00:08:46,830
ఆ మెమరీ కార్డ్ వాటిని ఆఫ్, అని
దాని ఒక SD కార్డ్ లేదా కాంపాక్ట్ ఫ్లాష్ కార్డ్ లేదా

186
00:08:46,830 --> 00:08:48,100
మీకు తెలిసిన ఏ.

187
00:08:48,100 --> 00:08:49,300
ఆపై మేము ఆ అప్పగించండి చేయవచ్చు.

188
00:08:49,300 --> 00:08:53,190
>> అందువలన ఇతర మధ్య ముందుకు సవాలు,
మీరు కోసం విషయాలు, వ్రాయడానికి ఉంటుంది

189
00:08:53,190 --> 00:08:58,630
ఒక మొత్తం బంచ్ తిరిగి ఆ C కోడ్
నాకు JPEGs మరియు బహిర్గతం ఉంటుంది

190
00:08:58,630 --> 00:09:00,190
ఆ వ్యక్తులు, ప్రదేశాలు, లేదా విషయాలు.

191
00:09:00,190 --> 00:09:03,340
మరియు మేము కూడా ఈ సమస్య, మాట్లాడదాము
సెట్ మరియు రోజులలో గురించి, రాబోయే

192
00:09:03,340 --> 00:09:04,440
సాధారణంగా గ్రాఫిక్స్.

193
00:09:04,440 --> 00:09:06,140
మేము, ఒక కోర్సు వాటిని ఉపయోగించి
బయటకు కోసం.

194
00:09:06,140 --> 00:09:09,080
మంజూరు కోసం కానీ మీరు విధమైన తీసుకున్నారు
ఈ అధిక స్థాయి భావాలను ఉంది

195
00:09:09,080 --> 00:09:10,680
దీర్ఘ చతురస్రాలు మరియు ovals యొక్క.

196
00:09:10,680 --> 00:09:12,450
కానీ హుడ్ కింద
పిక్సెళ్ళు ఉన్నాయి.

197
00:09:12,450 --> 00:09:14,370
మరియు మీరు ప్రారంభించడానికి కలిగి
ఆ గురించి ఆలోచిస్తూ.

198
00:09:14,370 --> 00:09:18,800
లేదా మీరు p-సెట్ 4 అనుకుంటున్నాను ఉంటుంది కోసం
మీ ఇటుకలు మధ్య అంతరం గురించి, ఎలా

199
00:09:18,800 --> 00:09:21,990
త్వరగా మీరు బంతి అంతటా కదిలే చేస్తున్నారు
స్క్రీన్ బయటకు.

200
00:09:21,990 --> 00:09:24,830
కాబట్టి ఈ భావనను ఉంది
ఆ మీ స్క్రీన్ చుక్కలు

201
00:09:24,830 --> 00:09:26,290
ఇప్పటికే తెరపైకి వస్తాయి.

202
00:09:26,290 --> 00:09:29,430
>> ఇప్పుడు మీరు చూడండి ఏమి, అయితే, ఏ
మీరు ఒక కంప్యూటర్ తెరపై పొందుటకు.

203
00:09:29,430 --> 00:09:33,680
మీరు ఎప్పుడైనా కొన్ని మంచి లేదా చూసిన ఉంటే
చెడు TV, అసమానత వారు అందంగా ఉంటాయి

204
00:09:33,680 --> 00:09:36,280
technophobes వంటి ప్రేక్షకుల చికిత్స
ఎవరు కాదు నిజంగా చేయండి

205
00:09:36,280 --> 00:09:37,630
చాలా కంప్యూటింగ్ గురించి తెలుసు.

206
00:09:37,630 --> 00:09:40,840
అందువలన పోలీసులు చాలా సులభం
చెప్పటానికి డిటెక్టివ్, మీరు చేయవచ్చు

207
00:09:40,840 --> 00:09:41,710
నాకు ఆ శుభ్రం?

208
00:09:41,710 --> 00:09:42,710
లేదా కుడి, విస్తరించేందుకు?

209
00:09:42,710 --> 00:09:45,550
విస్తరించేందుకు లో buzz పదం వంటిది
అత్యంత ఏదైనా నేర సంబంధిత షో.

210
00:09:45,550 --> 00:09:49,240
మీరు చాలా తీసుకుంటే మరియు రియాలిటీ ఉంది
చేయడం ఒక అనుమానితుడు యొక్క అస్పష్టంగా చిత్రం

211
00:09:49,240 --> 00:09:51,620
చెడు ఏదో, మీరు కాదు
కేవలం దీన్ని మెరుగుపరచడానికి.

212
00:09:51,620 --> 00:09:53,080
మీరు అనంతమైన జూమ్ కాదు.

213
00:09:53,080 --> 00:09:56,350
మీరు ఎవరైనా యొక్క ప్రకాశం లో చూడండి కాదు
ఆ పాల్పడిన కంటి

214
00:09:56,350 --> 00:09:59,860
ఉన్నప్పటికీ ముఖ్యంగా నేరం
TV లో ఈ ప్రాబల్యం.

215
00:09:59,860 --> 00:10:04,110
>> అందువలన యొక్క చైతన్యపరచటంలో వీలు ఆ
రాబోయే సమస్య ఒక సంగ్రహావలోకనం తో సెట్

216
00:10:04,110 --> 00:10:05,765
కొన్ని ప్రదర్శనలలో ఇది మీకు
తెలిసిన కావచ్చు.

217
00:10:05,765 --> 00:10:06,500
>> [వీడియో ప్లేబ్యాక్]

218
00:10:06,500 --> 00:10:07,835
>> -OK.

219
00:10:07,835 --> 00:10:09,956
ఇప్పుడు, మీరు ఒక మంచి కనిపిస్తోంది చేసుకుందాం.

220
00:10:09,956 --> 00:10:17,060

221
00:10:17,060 --> 00:10:17,766
>> అది పట్టుకోండి.

222
00:10:17,766 --> 00:10:18,658
తిరిగి అమలు.

223
00:10:18,658 --> 00:10:19,550
>> ఒక నిమిషం వేచి ఉండండి.

224
00:10:19,550 --> 00:10:21,580
కుడివైపు వెళ్ళు.

225
00:10:21,580 --> 00:10:21,800
>> -ఉన్నాయి.

226
00:10:21,800 --> 00:10:22,690
ఆ స్తంభింప.

227
00:10:22,690 --> 00:10:23,692
>> స్క్రీన్ పూర్తి.

228
00:10:23,692 --> 00:10:23,846
>> -OK.

229
00:10:23,846 --> 00:10:24,154
ఆ స్తంభింప.

230
00:10:24,154 --> 00:10:25,140
>> య, ఆ ఉంటుంది అప్-బిగించి?

231
00:10:25,140 --> 00:10:27,090
>> ఆ వ్యక్తి లో-వెక్టర్
తిరిగి చక్రం ద్వారా.

232
00:10:27,090 --> 00:10:29,730
>> ఈ అక్కడికక్కడే ఇక్కడే లో జూమ్.

233
00:10:29,730 --> 00:10:33,700
>> -సరైన పరికరాలు, imaged
విస్తరించి పదును చేయవచ్చు.

234
00:10:33,700 --> 00:10:34,490
>> దాన్ని ఆ?

235
00:10:34,490 --> 00:10:35,870
>> అది ఒక వృద్ది కార్యక్రమం.

236
00:10:35,870 --> 00:10:36,793
>> -మీకు ఏ అప్ స్పష్టం?

237
00:10:36,793 --> 00:10:38,560
>> -నాకు తెలీదు.

238
00:10:38,560 --> 00:10:39,090
యొక్క దీన్ని మెరుగుపరచడానికి లెట్.

239
00:10:39,090 --> 00:10:41,690
>> విభాగం A-6-మెరుగుపరచండి.

240
00:10:41,690 --> 00:10:43,510
>> -I వివరాలు విస్తరించింది మరియు -

241
00:10:43,510 --> 00:10:44,456
>> -I విస్తరించేందుకు తగినంత ఉందని నేను అనుకుంటున్నాను.

242
00:10:44,456 --> 00:10:45,402
నా తెర విడుదల.

243
00:10:45,402 --> 00:10:47,300
>> ఆమె కంటి లో ప్రతిబింబం-మెరుగుపరచండి.

244
00:10:47,300 --> 00:10:49,330
>> యొక్క ఈ ద్వారా రన్ లెట్
వీడియో మెరుగుదల.

245
00:10:49,330 --> 00:10:50,340
>> -ఎడ్గార్, మీరు ఈ మెరుగుపరుస్తాయి?

246
00:10:50,340 --> 00:10:52,320
>> ఆన్ చేరండి.

247
00:10:52,320 --> 00:10:54,290
>> -I've ఈ తెలివితో పని.

248
00:10:54,290 --> 00:10:55,560
>> -ఎవరో ప్రతిబింబం.

249
00:10:55,560 --> 00:10:56,440
>> -ప్రతిబింబం.

250
00:10:56,440 --> 00:10:57,940
>> ప్రతిబింబం-ఉంది
మనిషి యొక్క.

251
00:10:57,940 --> 00:10:58,860
>> -ప్రతిబింబం.

252
00:10:58,860 --> 00:10:59,710
>> -ఉన్నాయి ప్రతిబింబం యొక్క.

253
00:10:59,710 --> 00:11:00,900
>> అద్దం లో-జూమ్.

254
00:11:00,900 --> 00:11:03,500
>> -మీరు ప్రతిబింబం చూడగలరు.

255
00:11:03,500 --> 00:11:04,700
>> -మీకు ఇక్కడ నుండి చిత్రం విస్తరించేందుకు?

256
00:11:04,700 --> 00:11:05,700
>> -మీకు ఇక్కడే అతనికి విస్తరించేందుకు?

257
00:11:05,700 --> 00:11:06,500
>> -మీకు దీన్ని మెరుగుపరచడానికి?

258
00:11:06,500 --> 00:11:07,380
>> -మీకు దీన్ని మెరుగుపరచడానికి?

259
00:11:07,380 --> 00:11:08,190
>> ఉండటం మేము ఈ విస్తరించేందుకు?

260
00:11:08,190 --> 00:11:08,940
>> -మీకు దీన్ని మెరుగుపరచడానికి?

261
00:11:08,940 --> 00:11:10,280
>> రెండవ ఆన్ హోల్డ్, నేను విస్తరించేందుకు చేస్తాము.

262
00:11:10,280 --> 00:11:11,570
>> తలుపు మీద లో జూమ్.

263
00:11:11,570 --> 00:11:12,180
>> -X10.

264
00:11:12,180 --> 00:11:13,052
>> -జూమ్.

265
00:11:13,052 --> 00:11:13,197
>> [నవ్వు]

266
00:11:13,197 --> 00:11:14,360
>> సైన్-తరలించు

267
00:11:14,360 --> 00:11:15,100
>> ఆపడానికి,-వేచి.

268
00:11:15,100 --> 00:11:15,740
>> -ఆపు.

269
00:11:15,740 --> 00:11:16,290
>> అది విరామం.

270
00:11:16,290 --> 00:11:19,390
>> చుట్టూ ఒక 75 డిగ్రీల-తిప్పండి
నిలువు దయచేసి.

271
00:11:19,390 --> 00:11:19,886
>> [నవ్వు]

272
00:11:19,886 --> 00:11:24,350
>> భాగం తిరిగి-ఆపు, మరియు
తలుపు గురించి మళ్ళీ.

273
00:11:24,350 --> 00:11:26,330
>> ఒక చిత్రం పెంచే-గాట్
ఆ బిట్మ్యాప్ చెయ్యవచ్చు?

274
00:11:26,330 --> 00:11:28,990
>> -బహుశా మేము ప్రదీప్ సేన్ ఉపయోగించవచ్చు
పద్ధతి విండోస్ లోకి చూడటానికి.

275
00:11:28,990 --> 00:11:30,680
>> -ఈ సాఫ్ట్వేర్ కళ యొక్క రాష్ట్రం.

276
00:11:30,680 --> 00:11:31,676
>> -చిహ్నం విలువ ఆఫ్.

277
00:11:31,676 --> 00:11:34,166
>> -సరైన కలయిక
అల్గోరిథంలు యొక్క.

278
00:11:34,166 --> 00:11:38,399
>> -ఆయన ప్రకాశం అల్గోరిథంలు తీసుకువెళ్లారు
తదుపరి స్థాయి మరియు నేను వాటిని ఉపయోగించవచ్చు

279
00:11:38,399 --> 00:11:38,648
ఈ ఛాయాచిత్రం విస్తరించేందుకు.

280
00:11:38,648 --> 00:11:42,050
>> ఆన్ లాక్ మరియు z-అక్షం వచ్చేలా.

281
00:11:42,050 --> 00:11:42,760
>> -మెరుగుపరచండి.

282
00:11:42,760 --> 00:11:43,060
>> -మెరుగుపరచండి.

283
00:11:43,060 --> 00:11:43,760
>> -మెరుగుపరచండి.

284
00:11:43,760 --> 00:11:45,010
>> -స్తంభింపచెయ్యి మరియు మెరుగుపరచండి.

285
00:11:45,010 --> 00:11:47,470

286
00:11:47,470 --> 00:11:47,910
>> [END వీడియో ప్లేబ్యాక్]

287
00:11:47,910 --> 00:11:51,470
>> డేవిడ్ J. మలన్: సో సమస్య సెట్
5 అక్కడ ముందుకు ఉంది ఏమిటి.

288
00:11:51,470 --> 00:11:55,260
కనుక మనం వెంటనే ఒక మంచి అవగాహన పొందుతారు
ఎప్పుడు ఎందుకు మీరు డబ్బా

289
00:11:55,260 --> 00:11:57,300
మరియు మా విధంగా మెరుగుపరచలేరు.

290
00:11:57,300 --> 00:12:00,090
కానీ మొదటి, యొక్క మా దృష్టిని తిరిగి వీలు
మేము చేస్తాము బిల్డింగ్ బ్లాక్స్ కొన్ని

291
00:12:00,090 --> 00:12:02,250
ఆ కథ చెప్పడానికి ఉండాలి.

292
00:12:02,250 --> 00:12:05,580
>> కాబట్టి మేము ఈ చిత్రం ఆకర్షించాడు గుర్తు
సోమవారం మరియు కొద్దిగా గత వారం.

293
00:12:05,580 --> 00:12:09,970
మరియు ఈ విషయాలు లేఅవుట్ వివరిస్తుంది
మీ కంప్యూటర్ యొక్క మెమరీ లో ఉన్నప్పుడు

294
00:12:09,970 --> 00:12:11,000
కొన్ని ప్రోగ్రామ్ను అమలు.

295
00:12:11,000 --> 00:12:14,310
టాప్ టెక్ విభాగంలో, రీకాల్, సూచిస్తుంది
అసలు సున్నాలు మరియు వాటిని

296
00:12:14,310 --> 00:12:16,000
మీ ప్రోగ్రామ్ ఉన్నారు.

297
00:12:16,000 --> 00:12:19,340
అక్కడ, ఆ క్రింద, కొన్ని initialized లేదా
అవినియోగిత డేటా, ఇది సాధారణంగా

298
00:12:19,340 --> 00:12:22,910
లేదా స్థిరాంకాలు వంటి విషయాలను సూచిస్తుంది
తీగలను లేదా ప్రపంచ వేరియబుల్స్

299
00:12:22,910 --> 00:12:24,200
ముందుగానే ప్రకటించారు.

300
00:12:24,200 --> 00:12:26,500
అక్కడ కుప్ప, కానీ మేము వచ్చి చేస్తాము
తిరిగి ఒక బిట్ లో ఆ.

301
00:12:26,500 --> 00:12:27,410
>> ఆపై స్టాక్ ఉంది.

302
00:12:27,410 --> 00:12:30,660
చాలా లో trays యొక్క స్టాక్ వంటి
మెమరీ గెట్స్ పేరు ఫలహారశాల ఈ ఉంది

303
00:12:30,660 --> 00:12:33,610
పొరలుగా మరియు చేసినప్పుడు పొరలుగా
మీరు ఒక కార్యక్రమంలో ఏమి?

304
00:12:33,610 --> 00:12:36,380

305
00:12:36,380 --> 00:12:37,730
కోసం స్టాక్ ఉపయోగం ఏమిటి?

306
00:12:37,730 --> 00:12:39,320
>> అవును?

307
00:12:39,320 --> 00:12:40,000
>> ఫంక్షన్ యొక్క కాల్.

308
00:12:40,000 --> 00:12:42,890
మీరు ఒక ఫంక్షన్ కాల్ ఎప్పుడైనా, అది
దాని కోసం మెమరీ అంశం గురించి ఆలోచించారు ఇచ్చిన

309
00:12:42,890 --> 00:12:45,020
స్థానిక వేరియబుల్స్ లేదా దాని పారామితులు.

310
00:12:45,020 --> 00:12:48,810
మరియు చిత్రాల, మేము చూడండి ప్రతి తో
ఒక వరుస ఫంక్షన్, అని

311
00:12:48,810 --> 00:12:52,520
కాల్స్ B కాల్స్ సి కాల్స్ D, వారు
స్టాక్ లో పొరలుగా చేసుకోగా.

312
00:12:52,520 --> 00:12:55,630
మరియు ఆ ముక్కలు ప్రతి లోపల
మెమరీ తప్పనిసరిగా ఒక ఏకైక పరిధిని ఉంది

313
00:12:55,630 --> 00:12:58,590
ఆ ఫంక్షన్ కోసం, ఇది, కోర్సు యొక్క,
మీరు అప్పగించండి అనుకుంటే సమస్యాత్మకం

314
00:12:58,590 --> 00:13:01,850
ఫంక్షన్ నుంచి మరొక ఒక పావు
మీరు కావలసిన డేటా యొక్క

315
00:13:01,850 --> 00:13:03,500
పరివర్తనం చెందడానికి లేదా మార్చడానికి.

316
00:13:03,500 --> 00:13:08,060
>> సో ఎనేబుల్ మా పరిష్కారం ఏమిటి
ఒక స్టాక్ ప్రాతినిధ్యం ఒక ఫంక్షన్

317
00:13:08,060 --> 00:13:11,390
లోపల మెమరీ మార్చడానికి ప్రణాళిక
మరొక స్టాక్ ఫ్రేమ్ యొక్క?

318
00:13:11,390 --> 00:13:14,590
ఎలా మరొక ఆ రెండు చర్చ లేదు?

319
00:13:14,590 --> 00:13:18,510
సో గమనికలు లేదా చిరునామాలను ద్వారా,
పేరు లో ఇది, మళ్ళీ, కేవలం వివరించడానికి

320
00:13:18,510 --> 00:13:22,280
ఒక నిర్దిష్ట యొక్క మెమరీ, ద్వారా మార్గం
కాటు సంఖ్య, ముఖ్యంగా

321
00:13:22,280 --> 00:13:23,830
విలువ చూడవచ్చు.

322
00:13:23,830 --> 00:13:26,860
కాబట్టి మేము కొనసాగింది చివరిసారి గుర్తుకు
ఒక వద్ద కథ మరియు చూసారు

323
00:13:26,860 --> 00:13:28,280
బొత్తిగా బగ్గీ కార్యక్రమం.

324
00:13:28,280 --> 00:13:32,900
మరియు ఈ ప్రోగ్రామ్ కొన్ని కోసం బగ్గీ ఉంది
కారణాలు, కానీ వలన చింతించవలసిన ముఖ్య ఒకటి

325
00:13:32,900 --> 00:13:34,620
అది ఏమి తనిఖీ విఫలమైతే ఎందుకంటే?

326
00:13:34,620 --> 00:13:39,111

327
00:13:39,111 --> 00:13:40,450
>> అవును, అది తనిఖీ విఫలమైంది.

328
00:13:40,450 --> 00:13:41,870
క్షమించాలి?

329
00:13:41,870 --> 00:13:43,880
>> 12 అక్షరాలు కంటే ఎక్కువ ఉంటే.

330
00:13:43,880 --> 00:13:47,260
సో చాలా తెలివిగా నడిపిన, memcopy కాల్ చేస్తున్నప్పుడు,
ఇది, పేరు సూచించినట్లు, కేవలం

331
00:13:47,260 --> 00:13:50,630
దాని రెండవ వాదనను కాపీలు మెమరీ
దాని మొదటి వాదన లోకి.

332
00:13:50,630 --> 00:13:54,730
మూడవ వాదన, చాలా తెలివిగా నడిపిన, ఉంది
మీరు లేదు నిర్ధారించుకోండి తనిఖీ

333
00:13:54,730 --> 00:13:59,400
ఈ సందర్భంలో, పొడవు కంటే ఎక్కువ కాపీ
బార్, పాత్రల సంఖ్య,

334
00:13:59,400 --> 00:14:03,810
గమ్యం లోకి, ఈ ఉంది
అర్రే C. కానీ సమస్య ఏమి

335
00:14:03,810 --> 00:14:07,230
సి కూడా తగినంత పెద్ద కాదు ఉంటే
ఆ నిర్వహించడానికి?

336
00:14:07,230 --> 00:14:09,900
మీరు సంఖ్య కాపీ చేయబోతున్నామని
మీరు ఇచ్చిన చేసిన బైట్లు.

337
00:14:09,900 --> 00:14:13,040
కానీ మీరు వాస్తవానికి ఏమి ఉన్నాయి
మీరు కోసం గది కంటే బైట్లు?

338
00:14:13,040 --> 00:14:16,770
>> బాగా, ఈ కార్యక్రమం చాలా తెలివిలేక కేవలం
నిర్లక్ష్యంగా ఇది సంసార తీసుకోవాలని కొనసాగింది

339
00:14:16,770 --> 00:14:20,650
ఇచ్చిన, హలో బాక్ స్లాష్ 0
స్ట్రింగ్ తక్కువ గొప్ప ఉంటే

340
00:14:20,650 --> 00:14:22,040
తగినంత, ఐదు అక్షరాలు ఇష్టపడుతున్నారు.

341
00:14:22,040 --> 00:14:26,470
అయితే 12 అక్షరాలు లేదా ఉంటే
1,200 అక్షరాలు, మేము చివరిసారి చూసింది

342
00:14:26,470 --> 00:14:29,380
మీరు కేవలం పూర్తిగా చూడాలని ఉద్దేశ్యంతో
మెమరీ తిరిగి రాస్తుంది ఆ

343
00:14:29,380 --> 00:14:30,470
మీకు సంబంధించినది కాదు.

344
00:14:30,470 --> 00:14:34,390
మరియు చెత్త సందర్భంలో, మీరు తిరిగి రాస్తుంది ఉంటే
మేము అని అక్కడ ఎరుపు భాగం

345
00:14:34,390 --> 00:14:35,380
చిరునామా తిరిగి -

346
00:14:35,380 --> 00:14:38,370
ఈ కేవలం కంప్యూటర్
స్వయంచాలకంగా మీరు కోసం, వెనుక

347
00:14:38,370 --> 00:14:43,130
దూరంగా దృశ్యాలు, tucks ఒక 32-bit విలువ
అది ఏమి చిరునామా దానిని గుర్తు

348
00:14:43,130 --> 00:14:47,080
తిరిగి ఉన్నప్పుడు foo, ఈ ఇతర ఫంక్షన్,
అమలు చేయబడుతుంది.

349
00:14:47,080 --> 00:14:49,320
ఇది రకాల ఒక రొట్టె చిన్న ముక్క వార్తలు
అది తిరిగి.

350
00:14:49,320 --> 00:14:52,490
మీరు, సమర్థవంతంగా, ఆ తిరిగి రాస్తుంది ఉంటే
మీరు చెడు వ్యక్తి అయితే, చెయ్యవచ్చు అనుకొనుట

351
00:14:52,490 --> 00:14:54,750
శక్తివంతమైన స్వాధీనం
ఒకరి కంప్యూటర్.

352
00:14:54,750 --> 00:14:58,020
మరియు మీరు చాలా ఖచ్చితంగా చేస్తాము
చాలా సందర్భాలలో అది క్రాష్.

353
00:14:58,020 --> 00:15:01,690
>> ఇప్పుడు ఈ సమస్య మాత్రమే అధికమైనది
మేము మెమరీ గురించి మాట్లాడటం ప్రారంభించారు

354
00:15:01,690 --> 00:15:03,010
సాధారణంగా నిర్వహణ.

355
00:15:03,010 --> 00:15:07,150
మరియు malloc, మెమరీ కేటాయింపు కోసం, ఒక
మేము కేటాయించుటకు ఉపయోగించే ఫంక్షన్

356
00:15:07,150 --> 00:15:11,260
మేము ముందుగానే తెలియదు మెమరీలోకి
మేము కొన్ని అవసరం ఉండవచ్చు.

357
00:15:11,260 --> 00:15:13,960
సో, ఉదాహరణకు, నేను తిరిగి వెళ్ళి ఉంటే
ఇక్కడ పరికరానికి.

358
00:15:13,960 --> 00:15:21,010
మరియు నేను, గత సమయం hello2.c నుండి తెరుచుకుంటుంది
చూసారు ఇది ఇక్కడ ఈ కార్యక్రమం, గుర్తు

359
00:15:21,010 --> 00:15:23,500
ఈ వంటి ఒక చిన్న ఏదో,
కేవలం మూడు పంక్తులు -

360
00:15:23,500 --> 00:15:27,940
మీ పేరు, అప్పుడు స్ట్రింగ్ పేరు, రాష్ట్రం
ఎడమవైపు, getstring సమానం.

361
00:15:27,940 --> 00:15:29,690
మరియు అప్పుడు మేము దాన్ని ప్రింట్
యూజర్ యొక్క పేరు.

362
00:15:29,690 --> 00:15:31,170
>> సో ఈ ఒక సూపర్ సాధారణ కార్యక్రమం.

363
00:15:31,170 --> 00:15:34,870
స్పష్టమైన ఉండాలి, నాకు ముందుకు వెళ్ళి తెలపండి
హలో-2 తయారు.

364
00:15:34,870 --> 00:15:36,680
నేను డాట్ స్లాష్ హలో-2 చేయ బోతున్నాను.

365
00:15:36,680 --> 00:15:37,750
మీ పేరు రాష్ట్రం -

366
00:15:37,750 --> 00:15:38,140
డేవిడ్.

367
00:15:38,140 --> 00:15:38,840
ఎంటర్ చెయ్యండి.

368
00:15:38,840 --> 00:15:39,540
డేవిడ్ హలో.

369
00:15:39,540 --> 00:15:41,060
అది సరే పని ఉంది.

370
00:15:41,060 --> 00:15:43,140
కానీ నిజంగా జరగబోతోంది
ఇక్కడ హుడ్ కింద?

371
00:15:43,140 --> 00:15:44,670
మొదటి లెట్ యొక్క కొన్ని పొరల తిరిగి తొక్క.

372
00:15:44,670 --> 00:15:48,380
స్ట్రింగ్ మేము చేసిన ఒక పర్యాయపదం
ఏమి కోసం గ్రహించారు?

373
00:15:48,380 --> 00:15:49,110
చార్ స్టార్.

374
00:15:49,110 --> 00:15:52,740
సో యొక్క ఇది కొద్దిగా ఎక్కువ మర్మమైన తయారు చేద్దాము
కానీ సాంకేతికంగా సరైన ఇది

375
00:15:52,740 --> 00:15:55,570
అంటే ఒక చార్ స్టార్, ఉంది
పేరు, అవును, ఒక వేరియబుల్ ఉంది.

376
00:15:55,570 --> 00:15:59,920
కానీ ఏది దుకాణాలు చిరునామా
కొద్దిగా వింత అనిపిస్తుంది ఇది ఒక చార్

377
00:15:59,920 --> 00:16:01,050
నేను ఒక స్ట్రింగ్ తిరిగి పొందుతున్నాను ఎందుకంటే.

378
00:16:01,050 --> 00:16:03,580
నేను తిరిగి బహుళ పొందుతున్నాను
అక్షరాలు ఒక చార్ కాదు.

379
00:16:03,580 --> 00:16:07,400
>> కానీ కోర్సు యొక్క, మీరు మొదటి అవసరం
గుర్తుంచుకోవాలని చార్ యొక్క చిరునామా పేరు

380
00:16:07,400 --> 00:16:08,870
ఎందుకంటే ఎందుకు మొత్తం స్ట్రింగ్?

381
00:16:08,870 --> 00:16:12,700
మీరు ఎలా దొరుకుతుందని ఎక్కడ ముగింపు
స్ట్రింగ్ ప్రారంభంలో తెలుసుకోవడం?

382
00:16:12,700 --> 00:16:13,630
బాక్ స్లాష్ సున్నా.

383
00:16:13,630 --> 00:16:17,260
సో ఆ రెండు ఆధారాలు మీకు దొరుకుతుందని
ప్రారంభంలో మరియు ముగింపులో ముందు

384
00:16:17,260 --> 00:16:20,280
ఏ స్ట్రింగ్ వారు ఉన్నారు కాబట్టి కాలం, ఉన్నాయి
సరిగ్గా ఆ శూన్య ఏర్పాటుచేయబడింది

385
00:16:20,280 --> 00:16:22,110
టెర్మినేటర్, ఆ బాక్ స్లాష్ సున్నా.

386
00:16:22,110 --> 00:16:24,520
>> కానీ ఈ getstring కాల్.

387
00:16:24,520 --> 00:16:28,020
ఆ getstring హాజరవుతారు
అన్ని ఈ సమయంలో రకమైన ఉంది

388
00:16:28,020 --> 00:16:28,820
మాకు మోసం.

389
00:16:28,820 --> 00:16:32,460
ఇది తప్పకుండా, ఈ కార్మిక చేస్తోంది
యూజర్ నుండి ఒక స్ట్రింగ్ పొందడానికి.

390
00:16:32,460 --> 00:16:34,580
కానీ ఆ స్మృతి పేరు వార్తలు
నుండి వస్తున్నాడు?

391
00:16:34,580 --> 00:16:38,440
మేము ఇక్కడ చిత్రాన్ని తిరిగి వెళ్ళి ఉంటే
కేవలం ఒక నుండి నిర్వచనం దరఖాస్తు

392
00:16:38,440 --> 00:16:42,610
క్షణం క్రితం, ఆ స్టాక్ పేరు ఉంది
ధర్మాలని పిలుస్తారు మెమరీలోకి చేరుతుంది

393
00:16:42,610 --> 00:16:45,370
తర్కానికి ద్వారా, మీరు getstring కాల్ చేసినప్పుడు,
ఆపై నేను టైప్

394
00:16:45,370 --> 00:16:50,900
D-A-V-I-D, ఎంటర్ పేరు ఉంది D-A-V-I-D
బాక్ స్లాష్ సున్నా ఆధారంగా, నిల్వ

395
00:16:50,900 --> 00:16:53,480
కథ మేము చాలా మాకు చెప్పారు చేసిన?

396
00:16:53,480 --> 00:16:55,190
>> అది అగుపిస్తుంది
స్టాక్, కుడి?

397
00:16:55,190 --> 00:16:58,120
మీరు స్ట్రింగ్ పొందండి కాల్ చేసినప్పుడు మీరు ఒక పొందుటకు
స్టాక్ మెమరీ తక్కువ స్లైస్.

398
00:16:58,120 --> 00:17:01,630
సో ఆ D-A-V-I-D కారణం ఉంది
బాక్ స్లాష్ సున్నా నిల్వ ఉంది

399
00:17:01,630 --> 00:17:02,770
అక్కడ స్టాక్ లో.

400
00:17:02,770 --> 00:17:07,680
కానీ తిరిగి getstring, ఒక నిమిషం వేచి ఉండండి
ఆ స్ట్రింగ్, మాట్లాడటానికి, అంటే

401
00:17:07,680 --> 00:17:11,700
ఇది ఫలహారశాల నుండి ట్రే వార్తలు
స్టాక్ ఆఫ్ తీసుకోవాలి.

402
00:17:11,700 --> 00:17:14,560
మరియు మేము ఆ వెంటనే ఒక చివరిసారి అన్నారు
ఫంక్షన్ తిరిగి, మరియు మీరు తీసుకోవాలని

403
00:17:14,560 --> 00:17:20,109
స్టాక్ ఆఫ్ ట్రే, మాట్లాడటానికి, ఏ
మీరు అవశేషాలు గురించి ఊహించుకుని

404
00:17:20,109 --> 00:17:21,819
మెమరీ?

405
00:17:21,819 --> 00:17:25,160
నేను విధమైన ప్రశ్నార్థకాలుగా వాటిని redrew
వారు సమర్థవంతంగా మారింది ఎందుకంటే

406
00:17:25,160 --> 00:17:26,250
తెలియని విలువలు.

407
00:17:26,250 --> 00:17:29,500
కొన్ని వారు తిరిగి ఉపయోగించ తగినవి
తదుపరి చర్య అంటారు.

408
00:17:29,500 --> 00:17:31,870
>> ఇతర మాటల్లో చెప్పాలంటే, జరిగితే
నిల్వ చేయడానికి -

409
00:17:31,870 --> 00:17:34,350
నేను త్వరగా చిత్రాన్ని డ్రా చేస్తాము
ఇక్కడ స్టాక్.

410
00:17:34,350 --> 00:17:38,690
మేము దిగువన గీయడం సాధ్యం జరిగే ఉంటే
నా మెమరీ సెగ్మెంట్, మరియు మేము చెప్పటానికి చేస్తాము

411
00:17:38,690 --> 00:17:42,230
ఈ మెమరీ ప్రాంతంగా
ప్రధాన మరియు ఉండవచ్చు ARG సి మరియు ఆక్రమించిన

412
00:17:42,230 --> 00:17:46,790
ARG v కార్యక్రమంలో ఏదైనా,
getstring అంటారు,

413
00:17:46,790 --> 00:17:51,120
బహుశా getstring గెట్స్
ఇక్కడ మెమరీ భాగం.

414
00:17:51,120 --> 00:17:53,940
ఆపై D-A-V-I-D ఏదో
ఈ ఫంక్షన్ లో ముగుస్తుంది.

415
00:17:53,940 --> 00:17:55,320
మరియు నేను సరళంగా వెళుతున్న.

416
00:17:55,320 --> 00:18:00,050
కానీ యొక్క చేపట్టడానికి వీలు దాని D-A-V-I-D అని
బాక్ స్లాష్ సున్నా.

417
00:18:00,050 --> 00:18:03,500
సో ఈ అనేక బైట్లు ఉపయోగిస్తారు
getstring కోసం ఫ్రేమ్.

418
00:18:03,500 --> 00:18:08,270
>> కానీ వెంటనే getstring తిరిగి వంటి, మేము
చివరిసారి మాట్లాడుతూ ఈ మెమరీ

419
00:18:08,270 --> 00:18:11,340
ఇక్కడ అన్ని అవుతుంది - woops! -

420
00:18:11,340 --> 00:18:14,270
అన్ని సమర్థవంతంగా మాసిపోయిన అవుతుంది.

421
00:18:14,270 --> 00:18:17,220
మరియు మేము ప్రశ్న ఇప్పుడు ఈ ఆలోచించవచ్చు
మార్కులు తెలిసిన ఎందుకంటే

422
00:18:17,220 --> 00:18:18,720
దాన్ని మెమరీ మారింది జరగబోతోంది.

423
00:18:18,720 --> 00:18:22,130
నిజానికి, నేను చాలా తరచుగా విధులు కాల్
getstring కంటే ఇతర.

424
00:18:22,130 --> 00:18:24,750
మరియు వెంటనే నేను కొన్ని ఇతర పిలుస్తున్నారు
getstring కంటే ఫంక్షన్, బహుశా లేదు

425
00:18:24,750 --> 00:18:28,860
మేము కేవలం చూసారు ఈ ప్రత్యేక కార్యక్రమం
కానీ కొన్ని ఇతర, తప్పనిసరిగా కొన్ని ఇతర వద్ద

426
00:18:28,860 --> 00:18:34,180
ఫంక్షన్ ఇచ్చిన ముగింపు ఉండవచ్చు
స్టాక్ లో ఈ తదుపరి స్పాట్.

427
00:18:34,180 --> 00:18:39,410
>> సో ఆ getstring దుకాణాలు ఉండకూడదు
స్టాక్ న D-A-V-I-D నేను ఎందుకంటే

428
00:18:39,410 --> 00:18:41,040
వెంటనే ప్రాప్తిని కోల్పోతే.

429
00:18:41,040 --> 00:18:43,720
కానీ అవి getstring తెలుసు
మాత్రమే ఏమి తిరిగి?

430
00:18:43,720 --> 00:18:47,220
ఇది తిరిగి లేదు
నాకు ఆరు అక్షరాలు.

431
00:18:47,220 --> 00:18:51,090
ఇది నిజంగా ఏమి లేదు తిరిగి
మేము చివరిసారి నిర్ధారించారు?

432
00:18:51,090 --> 00:18:52,480
మొదటి చిరునామా.

433
00:18:52,480 --> 00:18:56,650
సో ఏదో, మీరు getstring పిలిచాడు,
అది మెమొరీ ఒక భాగం కేటాయించడం లో

434
00:18:56,650 --> 00:18:59,620
స్ట్రింగ్ వినియోగదారులు రకం మరియు
ఇది అప్పటి తిరిగి చిరునామా.

435
00:18:59,620 --> 00:19:02,930
మరియు మీరు ఎప్పుడు కావలసిన హాజరవుతారు
ఈ లో మెమరీని కేటాయించాల్సిన పని

436
00:19:02,930 --> 00:19:08,390
మార్గం అని పిలుస్తారు వ్యక్తి తిరిగి
ఆ ఫంక్షన్ యొక్క చిరునామా

437
00:19:08,390 --> 00:19:11,870
మెమరీ యొక్క భాగం, మీరు ఖచ్చితంగా
వద్ద స్టాక్ లో అది చాలు కాదు

438
00:19:11,870 --> 00:19:14,750
దిగువన, ఎందుకంటే క్రియాశీలంగా కేవలం వార్తలు
చాలా మీదే మారింది వెళుతున్న

439
00:19:14,750 --> 00:19:17,800
త్వరగా, కాబట్టి మీరు బహుశా అంచనా పేరు
మేము బహుశా దీన్ని టాసు చేయబోతున్నామని

440
00:19:17,800 --> 00:19:20,130
బదులుగా, అని పిలవబడే కుప్ప.

441
00:19:20,130 --> 00:19:25,290
>> సో మీ మెమరీ యొక్క దిగువన మధ్య
లేఅవుట్ మరియు మీ మెమరీ యొక్క టాప్

442
00:19:25,290 --> 00:19:26,820
లేఅవుట్ సెగ్మెంట్ల మొత్తం బంచ్ ఉంటాయి.

443
00:19:26,820 --> 00:19:29,270
ఒక కుప్ప ఉంది, మరియు కుడి
ఇది పైన కుప్ప ఉంది.

444
00:19:29,270 --> 00:19:33,680
మరియు కుప్ప కేవలం ఒక విభిన్న భాగం ఉంది
విధులు కోసం ఉపయోగిస్తారు లేదు మెమరీ

445
00:19:33,680 --> 00:19:34,770
వారు అని చేసినప్పుడు.

446
00:19:34,770 --> 00:19:38,100
ఇది ఉన్నప్పుడు, దీర్ఘకాల మెమరీ కోసం ఉపయోగిస్తారు
మీరు ఒక పని కొన్ని పట్టుకోడానికి అనుకుంటున్నారా

447
00:19:38,100 --> 00:19:42,700
మెమరీ మరియు అది న హేంగ్ చెయ్యగలరు
ఇది నియంత్రణ కోల్పోకుండా.

448
00:19:42,700 --> 00:19:45,550
>> ఇప్పుడు మీరు బహుశా వెంటనే అనుకొనుట
ఈ కాదని చూడండి

449
00:19:45,550 --> 00:19:48,060
ఒక పరిపూర్ణ డిజైన్ అవసరం.

450
00:19:48,060 --> 00:19:51,350
మీ ప్రోగ్రామ్ మెమరీ కేటాయించిన వంటి
స్టాక్, లేదా మీరు కాల్ మరింత మరియు

451
00:19:51,350 --> 00:19:55,540
మరింత విధులు, లేదా మీరు కేటాయించుటకు వంటి
గా malloc తో కుప్ప మెమరీ

452
00:19:55,540 --> 00:20:00,690
getstring చేయడం, ఏమి స్పష్టంగా ఉంది
అనివార్యమైన సమస్య ఉంది?

453
00:20:00,690 --> 00:20:00,860
>> రైట్.

454
00:20:00,860 --> 00:20:03,150
నిజానికి ఇలా ఈ బాణాలు
ప్రతి ఇతర వద్ద గురిపెట్టి ఉంటాయి

455
00:20:03,150 --> 00:20:04,380
బాగా భవిష్యత్తును చెప్పు లేదు.

456
00:20:04,380 --> 00:20:08,630
నిజానికి, మేము చాలా త్వరగా క్రాష్ కాలేదు
మార్గాల్లో సంఖ్య కార్యక్రమం.

457
00:20:08,630 --> 00:20:12,050
నిజానికి, నేను మేము కలిగి ఆలోచిస్తున్న
ఈ అనుకోకుండా ఒకసారి.

458
00:20:12,050 --> 00:20:14,020
లేదా లేకపోతే, అది యొక్క తెలపండి
ఉద్దేశపూర్వకంగా ఇప్పుడు.

459
00:20:14,020 --> 00:20:21,330
నాకు ముందుకు వెళ్లి త్వరగా సూపర్ వ్రాయడానికి వీలు
ఒక ప్రోగ్రామ్ dontdothis.c అని.

460
00:20:21,330 --> 00:20:26,730
మరియు ఇప్పుడు నేను ఇక్కడ వెళ్ళి వస్తుంది
పదునైన stdio.h ఉంటాయి.

461
00:20:26,730 --> 00:20:32,620
ఫంక్షన్ foo పడుతుంది డిక్లేర్ లెట్ యొక్క
ఏ వాదనలు, ఇది

462
00:20:32,620 --> 00:20:34,040
శూన్యమైన ద్వారా బాగా సూచిస్తారు.

463
00:20:34,040 --> 00:20:37,830
>> మరియు foo చేయబోవడం మాత్రమే విషయం
బహుశా ఇది కాల్ foo,

464
00:20:37,830 --> 00:20:39,100
తెలివైన ఆలోచన, కానీ అది.

465
00:20:39,100 --> 00:20:40,490
ENT ప్రధాన శూన్యమైన.

466
00:20:40,490 --> 00:20:45,270
ఇప్పుడు ప్రధాన వెళుతున్న మాత్రమే విషయం
చేయాలని అలాగే foo పిలుస్తారు.

467
00:20:45,270 --> 00:20:51,050
మరియు కేవలం కిక్స్ కోసం, నేను వెళ్ళి వెళుతున్న
ముందుకు ఇక్కడ మరియు హలో "printf చెప్పటానికి

468
00:20:51,050 --> 00:20:52,340
foo. "

469
00:20:52,340 --> 00:20:52,890
>> OK.

470
00:20:52,890 --> 00:21:00,160
నేను ఏ తప్పులు లేదు కనుక,
Dontdothis డాట్ స్లాష్ చేయండి.

471
00:21:00,160 --> 00:21:01,960
మరియు లెట్స్ ఒక పెద్ద విండోలో దీన్ని -

472
00:21:01,960 --> 00:21:03,210
డాట్ స్లాష్, dontdothis.

473
00:21:03,210 --> 00:21:07,590

474
00:21:07,590 --> 00:21:08,840
న కమ్.

475
00:21:08,840 --> 00:21:10,940

476
00:21:10,940 --> 00:21:11,890
అయ్యో.

477
00:21:11,890 --> 00:21:13,100
స్పష్టంగా, మీరు చేయవచ్చు.

478
00:21:13,100 --> 00:21:15,190
ఇది డామన్.

479
00:21:15,190 --> 00:21:16,190
OK.

480
00:21:16,190 --> 00:21:16,580
వేచి.

481
00:21:16,580 --> 00:21:17,370
ఉండండి.

482
00:21:17,370 --> 00:21:18,270
మేము -

483
00:21:18,270 --> 00:21:20,110
మేము అది ఉపయోగించారు.

484
00:21:20,110 --> 00:21:22,050
>> [విచార నిట్టూర్పుని]

485
00:21:22,050 --> 00:21:25,110
>> నాకు తెలుసు కానీ నేను మనం అనుకున్నదానికన్నా
కేవలం తొలగించినట్లు.

486
00:21:25,110 --> 00:21:28,410
ఉహ్, yeah.

487
00:21:28,410 --> 00:21:30,660
ఇది డామన్.

488
00:21:30,660 --> 00:21:32,640
ఈ రాబ్ పరిష్కరించడానికి.

489
00:21:32,640 --> 00:21:34,678
ఏమి?

490
00:21:34,678 --> 00:21:35,928
ఇది చాలా సులభం.

491
00:21:35,928 --> 00:21:43,820

492
00:21:43,820 --> 00:21:47,360
అవును, మేము ఆప్టిమైజేషన్ ఆపివేయబడింది.

493
00:21:47,360 --> 00:21:48,970
OK, బై నిలబడటానికి.

494
00:21:48,970 --> 00:21:49,950
ఇప్పుడు నేను మంచి అనుభూతి.

495
00:21:49,950 --> 00:21:51,390
OK.

496
00:21:51,390 --> 00:21:51,780
అన్ని కుడి.

497
00:21:51,780 --> 00:21:53,430
>> సో యొక్క ఈ మళ్ళీ కంపైల్ చెయ్యండి వీలు -

498
00:21:53,430 --> 00:21:55,880
మీరు dontdothis చేయండి.

499
00:21:55,880 --> 00:22:00,090
మీరు ఈ పేరు ఉంటుంది
కేవలం ఒక క్షణం లో dothis.c.

500
00:22:00,090 --> 00:22:00,710
అక్కడ మేము వెళ్ళి.

501
00:22:00,710 --> 00:22:01,240
ధన్యవాదాలు.

502
00:22:01,240 --> 00:22:02,050
OK.

503
00:22:02,050 --> 00:22:05,480
నేను ప్రింటింగ్ వాస్తవాన్ని
ఏదో బయటకు కేవలం నిజానికి ఉంది

504
00:22:05,480 --> 00:22:08,150
ప్రక్రియ నెమ్మదిగా ఇది మనం
ఆ స్థానానికి చేరుకునేందుకు ఉండేది.

505
00:22:08,150 --> 00:22:08,510
OK.

506
00:22:08,510 --> 00:22:08,870
అయ్యో!

507
00:22:08,870 --> 00:22:11,180
>> సో వాట్ నిజంగా జరుగుతుందో?

508
00:22:11,180 --> 00:22:14,440
కేవలం జనాంతికంగా అక్కడ కారణం,, ఉంది
ఇన్పుట్ పరంగా ఏదైనా చేయడం మరియు

509
00:22:14,440 --> 00:22:17,270
అవుట్పుట్ నెమ్మదిగా ఉంటుంది ఎందుకంటే మీరు
పాత్రల వ్రాయడానికి కలిగి

510
00:22:17,270 --> 00:22:18,600
తెర, ఇది స్క్రోల్ ఉంది.

511
00:22:18,600 --> 00:22:21,720
చాలా కాలం కథ చిన్న, నేను నిజానికి కలిగి
కాబట్టి సహనం జరిగింది, మేము కలిగి ఉంటుంది

512
00:22:21,720 --> 00:22:23,260
అలాగే ఈ ముగింపు ఫలితంగా చూసిన.

513
00:22:23,260 --> 00:22:26,220
నేను ముద్రణ-ups రైడ్ వచ్చింది, ఇప్పుడు ఆ
మేము వెంటనే చూడండి.

514
00:22:26,220 --> 00:22:28,410
సో ఎందుకు ఈ ఫోజు.

515
00:22:28,410 --> 00:22:31,300
బాగా, కోర్సు యొక్క సులభమైన వివరణ,
ఆ foo బహుశా ఉండాలి

516
00:22:31,300 --> 00:22:32,500
కూడా పిలుచుచున్నారు.

517
00:22:32,500 --> 00:22:34,470
>> ఇప్పుడు సాధారణ పరంగా,
ఈ సూత్రం ఉంది.

518
00:22:34,470 --> 00:22:36,970
మరియు మేము ఒక జంట వారాల ఆలోచన
క్రితం పునరావృత మంచి.

519
00:22:36,970 --> 00:22:40,330
సూత్రం ఈ మాయా మార్గం
క్లుప్తమైన సూపర్ మిమ్మల్ని వ్యక్తం.

520
00:22:40,330 --> 00:22:41,400
మరియు అది పనిచేస్తుంది.

521
00:22:41,400 --> 00:22:45,060
కానీ అన్ని ఒక కీలకమైన అంశం ఉంది
మేము మాట్లాడారు చేసిన పునరావృత కార్యక్రమాలు

522
00:22:45,060 --> 00:22:48,260
గురించి మరియు చూశారు ఇప్పటివరకు, ఇది
వారు ఏమి లేదని ఉంది?

523
00:22:48,260 --> 00:22:52,610
కొన్ని హార్డ్ కోడెడ్ ఇది ఒక బేస్ సందర్భంలో,
కొన్ని సందర్భాలలో చెప్పారు కేసు

524
00:22:52,610 --> 00:22:56,210
స్పష్టంగా ఇది foo, కాల్ లేదు
ఇక్కడ సందర్భం.

525
00:22:56,210 --> 00:22:58,920
>> సో వాట్ నిజంగా ఏమి జరుగుతుందో
ఈ చిత్రం పరంగా?

526
00:22:58,920 --> 00:23:01,790
బాగా, మిగిలిన ముఖ్య foo, దీనిని
మెమరీ స్లైస్ గెట్స్.

527
00:23:01,790 --> 00:23:04,150
Foo foo కాల్స్, అది గెట్స్
మెమరీ స్లైస్.

528
00:23:04,150 --> 00:23:06,430
Foo foo కాల్స్, అది ఒక స్లైస్ గెట్స్.

529
00:23:06,430 --> 00:23:07,080
ఇది ఒక స్లైస్ గెట్స్.

530
00:23:07,080 --> 00:23:08,120
ఇది ఒక స్లైస్ గెట్స్.

531
00:23:08,120 --> 00:23:09,460
Foo తిరిగి ఎప్పుడూ ఎందుకంటే.

532
00:23:09,460 --> 00:23:12,160
మేము వారిలో erasing ఎప్పుడూ మీరు
స్టాక్ నుండి ఫ్రేమ్లను.

533
00:23:12,160 --> 00:23:15,930
కాబట్టి మేము, కుప్ప ద్వారా కాదు ఊదడం చేస్తున్నారు
ఎవరు ఏమి వేరే తెలుసు, మరియు చెప్పలేదు

534
00:23:15,930 --> 00:23:19,600
మేము మా యొక్క సరిహద్దులు అధిగమించడం చేస్తున్నారు
మెమరీ విభాగం అని పిలుస్తారు.

535
00:23:19,600 --> 00:23:21,790
విభజన తప్పుడు వెళ్ళి లోపం.

536
00:23:21,790 --> 00:23:24,110
>> సో అక్కడ, పరిష్కార
స్పష్టంగా దీన్ని లేదు.

537
00:23:24,110 --> 00:23:28,830
కానీ పెద్ద చిక్కుముడి ఆ, అవును, ఉంది
ఖచ్చితంగా కొన్ని పరిమితి ఉంది

538
00:23:28,830 --> 00:23:32,470
ఇది బాగా ఎలా, నిర్వచించబడలేదు అయినా
మీరు ఒక లో కాల్ చేయవచ్చు అనేక విధులు

539
00:23:32,470 --> 00:23:34,970
కార్యక్రమం, ఎన్ని సార్లు ఒక ఫంక్షన్
కూడా చేపట్టవచ్చు.

540
00:23:34,970 --> 00:23:38,430
మేము సూత్రం బోధించడానికి అదే అయినప్పటికీ
ఈ శక్తివంతమైన మాయా విషయం ఒక

541
00:23:38,430 --> 00:23:41,870
సిగ్మా కోసం క్రితం వారాల జంట
ఫంక్షన్, మరియు మేము డేటా పొందుటకు

542
00:23:41,870 --> 00:23:45,270
నిర్మాణాలు మరియు CS50, మీరు ఇతర చూస్తారు
అది అప్లికేషన్లు, అది కాదు

543
00:23:45,270 --> 00:23:46,500
తప్పనిసరిగా గొప్పదనం.

544
00:23:46,500 --> 00:23:50,070
ఒక ఫంక్షన్ కూడా కాల్స్, ఉంటే ఎందుకంటే
ఒక బేస్ ఉంది కూడా, కూడా కాల్స్

545
00:23:50,070 --> 00:23:54,860
కేసు, మీరు బేస్ కేసు హిట్ లేకపోతే
1,000 కాల్స్ లేదా 10,000 కాల్స్ కోసం, ద్వారా

546
00:23:54,860 --> 00:23:58,800
మీరు గది రన్నవుట్ ఉండవచ్చని సమయం
మీ అని పిలవబడే స్టాక్ మరియు విజయవంతమైన

547
00:23:58,800 --> 00:24:00,400
మెమరీ కొన్ని ఇతర భాగాలు.

548
00:24:00,400 --> 00:24:03,950
కనుక ఇది చాలా ఒక రూపకల్పన రాజీ ఉంది
చక్కదనం మరియు మధ్య

549
00:24:03,950 --> 00:24:06,920
మీ నిర్దిష్ట పుష్టి
అమలు.

550
00:24:06,920 --> 00:24:10,780
>> మరో ఇబ్బంది లేదా ఉంది
మేము దాన్ని మరొక gotcha

551
00:24:10,780 --> 00:24:11,720
ఇప్పటివరకు చేస్తున్న.

552
00:24:11,720 --> 00:24:12,980
నేను getstring అని చేసినప్పుడు -

553
00:24:12,980 --> 00:24:15,120
నాకు హలో-2 తిరిగి వెళ్ళి తెలపండి.

554
00:24:15,120 --> 00:24:18,170
, నేను getstring కాల్ వెబ్ గమనించవచ్చు
ఇది ఒక చిరునామా తిరిగి.

555
00:24:18,170 --> 00:24:20,730
మరియు మేము ఈ రోజు ప్రకటిస్తున్నారు చిరునామా
కుప్ప నుండి.

556
00:24:20,730 --> 00:24:24,480
మరియు ఇప్పుడు నేను ముద్రించిన చేస్తున్నాను
ఆ చిరునామా వద్ద స్ట్రింగ్.

557
00:24:24,480 --> 00:24:27,000
కానీ మేము అని ఎప్పుడూ
getstring వ్యతిరేకం.

558
00:24:27,000 --> 00:24:30,850
మేము వంటి ఒక ఫంక్షన్ calll కు లేడు
ఇక్కడ మీరు చేతి తిరిగి ungetstring,

559
00:24:30,850 --> 00:24:31,610
మెమరీ.

560
00:24:31,610 --> 00:24:33,250
కానీ స్పష్టముగా మేము బహుశా
ఉండాలి.

561
00:24:33,250 --> 00:24:37,390
ఎందుకంటే మేము కంప్యూటర్ అడుగుతూ ఉంచుకుంటే
వంటి ఒకరి మెమరీ కోసం, ద్వారా మార్గం

562
00:24:37,390 --> 00:24:40,830
getstring కానీ తప్పనిసరిగా, అది తిరిగి ఇవ్వాలని ఎప్పుడూ
ఆ చాలా దారి అనుగుణంగా ఉంటుంది

563
00:24:40,830 --> 00:24:42,970
మేము మెమరీ రన్నవుట్ అనగా సమస్యలు.

564
00:24:42,970 --> 00:24:46,140
>> వాస్తవానికి, మేము ఈ కోసం చూడవచ్చు
దీని ఉపయోగం కొత్త సాధనం సమస్యలు

565
00:24:46,140 --> 00:24:47,640
టైప్ కొద్దిగా నిగూఢ ఉంది.

566
00:24:47,640 --> 00:24:50,960
కానీ నాకు ముందుకు వెళ్లి అప్ స్ప్లాష్ వీలు
కేవలం ఒక క్షణం లో తెరపై.

567
00:24:50,960 --> 00:24:56,940
నేను ముందుకు వెళ్లి Valgrind అమలు వెళుతున్న
దీని మొదటి కమాండ్ పారామీటర్ తో

568
00:24:56,940 --> 00:25:00,260
లైన్ వాదన పేరు
ఆ కార్యక్రమం హలో-2 యొక్క.

569
00:25:00,260 --> 00:25:02,650
మరియు దురదృష్టవశాత్తు ఇది
అవుట్పుట్ atrociously ఉంది

570
00:25:02,650 --> 00:25:04,290
ఏ మంచి కారణం కోసం క్లిష్టమైన.

571
00:25:04,290 --> 00:25:06,280
కనుక మనం ఆ గజిబిజి చూడండి.

572
00:25:06,280 --> 00:25:07,530
డేవిడ్ నా పేరు రాష్ట్రము.

573
00:25:07,530 --> 00:25:09,760
తద్వారా ప్రోగ్రామ్
నిజానికి నడుస్తున్న.

574
00:25:09,760 --> 00:25:11,180
మరియు ఇప్పుడు మేము ఈ అవుట్పుట్ పొందుటకు.

575
00:25:11,180 --> 00:25:13,400
>> సో Valgrind పోలి ఉంటుంది
GDB కు ఆత్మ లో.

576
00:25:13,400 --> 00:25:14,950
ఇది దానంతట ఒక డీబగ్గర్ కాదు.

577
00:25:14,950 --> 00:25:16,270
కానీ అది ఒక మెమరీ తనిఖీ వార్తలు.

578
00:25:16,270 --> 00:25:20,140
ఇది మీ అమలు ఒక ప్రోగ్రామ్ యొక్క
ప్రోగ్రామ్ మరియు మీరు ఒక కోరితే మీరు చెప్పండి

579
00:25:20,140 --> 00:25:23,860
మెమరీ కంప్యూటర్ మరియు ఎప్పుడూ అందచేసి
తిరిగి, తద్వారా మీరు అర్థం

580
00:25:23,860 --> 00:25:24,570
మెమొరీ లీక్.

581
00:25:24,570 --> 00:25:26,240
మరియు మెమరీ లీకేజ్ చెడు ఉంటాయి.

582
00:25:26,240 --> 00:25:29,120
మరియు మీరు కంప్యూటర్ల వినియోగదారులు ఉంటుంది
బహుశా ఈ మీరు ఒక కలిగి లేదో, భావించాడు

583
00:25:29,120 --> 00:25:30,300
Mac లేదా ఒక PC.

584
00:25:30,300 --> 00:25:33,730
మీరు ఎప్పుడైనా మీ కంప్యూటర్ ఉపయోగించారు
మరియు అనేక లో జరిగితే కాదు అయితే

585
00:25:33,730 --> 00:25:36,820
రోజుల, లేదా మీరు కేవలం చాలా వచ్చింది చేసిన
నడుస్తున్న కార్యక్రమాలు, మరియు తిట్టు విషయం

586
00:25:36,820 --> 00:25:42,360
ఒక గ్రౌండింగ్ halt కు తగ్గిస్తుంది, లేదా కనీసం
ఎందుకంటే, ఉపయోగించడానికి సూపర్ బాధించే వార్తలు

587
00:25:42,360 --> 00:25:44,350
ప్రతిదీ కేవలం సూపర్ నెమ్మదిగా వచ్చింది.

588
00:25:44,350 --> 00:25:46,260
>> ఇప్పుడు ఆ కారణాలు ఏ సంఖ్య చేయవచ్చు.

589
00:25:46,260 --> 00:25:49,600
ఇది ఒక అనంతమైన లూప్, ఒక బగ్ కావచ్చు
ఒకరి కోడ్, లేదా, మరింత సాధారణంగా, ఇది

590
00:25:49,600 --> 00:25:53,250
మీరు మరింత ఉపయోగిస్తున్నారని అర్థం
మీ కంటే మెమరీ, లేదా ప్రయత్నిస్తున్న,

591
00:25:53,250 --> 00:25:54,920
కంప్యూటర్ వాస్తవానికి.

592
00:25:54,920 --> 00:25:57,770
మరియు ఉండవచ్చు కొన్ని కార్యక్రమంలో ఒక బగ్ ఉంది
మెమరీ కోరుతూ ఉంచే.

593
00:25:57,770 --> 00:26:02,480
సంవత్సరాలు బ్రౌజర్లు కోసం సంచలనాత్మక ఉన్నాయి
ఈ, మరింత మెమరీ కోరుతూ

594
00:26:02,480 --> 00:26:03,870
కానీ అది తిరిగి ఇవ్వడానికి ఎప్పుడూ.

595
00:26:03,870 --> 00:26:07,220
ఖచ్చితంగా, మీరు మాత్రమే ఒక పరిమిత కలిగి ఉంటే
మెమరీ మొత్తం, మీరు అడగవు

596
00:26:07,220 --> 00:26:09,990
కోసం అనంతమైన అనేక సార్లు
మెమరీ కొన్ని.

597
00:26:09,990 --> 00:26:13,070
>> అందువలన మీరు అయినప్పటికీ, ఇక్కడ చూడండి ఏమి
మళ్ళీ Valgrind యొక్క అవుట్పుట్ ఉంది

598
00:26:13,070 --> 00:26:17,490
ఒకసారి అవలోకనం కు అనవసరంగా క్లిష్టమైన
మొదటి, ఈ ఆసక్తికరమైన భాగం.

599
00:26:17,490 --> 00:26:18,890
కుప్ప -

600
00:26:18,890 --> 00:26:20,060
నిష్క్రమణ ఉపయోగిస్తున్నాయి.

601
00:26:20,060 --> 00:26:22,810
ఇక్కడ ఎంత మెమరీ చేయబడింది
వద్ద కుప్ప లో ఉపయోగంలో

602
00:26:22,810 --> 00:26:24,300
నా కార్యక్రమం ముగిసింది -

603
00:26:24,300 --> 00:26:27,280
ఒక బ్లాక్ లో స్పష్టంగా ఆరు బైట్లు.

604
00:26:27,280 --> 00:26:28,710
నేను నా చేతులు వేవ్ వెళుతున్నాను
ఏమి వద్ద ఒక బ్లాక్.

605
00:26:28,710 --> 00:26:31,270
మరింత, అది కేవలం ఒక భాగం ఉంది అనుకుంటున్నాను
భాగం కోసం సాంకేతిక పదం.

606
00:26:31,270 --> 00:26:33,140
ఆరు బైట్లు కానీ -

607
00:26:33,140 --> 00:26:36,870
ఆరు బైట్లు ఏమిటి
వాడుకలో ఉన్నాయి?

608
00:26:36,870 --> 00:26:37,390
>> సరిగ్గా.

609
00:26:37,390 --> 00:26:41,520
D-A-V-I-D బాక్ స్లాష్ సున్నా, ఐదు లేఖ
పేరు ప్లస్ శూన్య చివరను.

610
00:26:41,520 --> 00:26:46,350
సో ఈ కార్యక్రమం గమనించి Valgrind నేను
ద్వారా, స్పష్టంగా, ఆరు బైట్లు అడిగారు

611
00:26:46,350 --> 00:26:48,950
getstring మార్గం, కానీ ఎప్పుడూ
వాటిని తిరిగి ఇచ్చింది.

612
00:26:48,950 --> 00:26:52,030
వాస్తవానికి, ఈ విధంగా ఉండవు
నా కార్యక్రమం మూడు కాదు స్పష్టమైన ఉంటే

613
00:26:52,030 --> 00:26:53,590
లైన్లు, కానీ 300 లైన్లు వార్తలు.

614
00:26:53,590 --> 00:26:56,920
కాబట్టి మేము నిజానికి మరొక ఆదేశం ఇవ్వగలిగిన
లైన్ వాదన Valgrind కు

615
00:26:56,920 --> 00:26:58,290
మరింత మందమైన తయారు.

616
00:26:58,290 --> 00:26:59,760
దాన్ని గుర్తుంచుకోవాలని కొద్దిగా బాధించే వార్తలు.

617
00:26:59,760 --> 00:27:01,580
కానీ నేను లేకపోతే -

618
00:27:01,580 --> 00:27:01,930
యొక్క చూద్దాము.

619
00:27:01,930 --> 00:27:03,540
లీక్ -

620
00:27:03,540 --> 00:27:05,030
ఇది ఊఱుట జరిగినది -

621
00:27:05,030 --> 00:27:07,580
కూడా నేను వద్దు remember
అది చేతిని ఆఫ్ ఏమిటి.

622
00:27:07,580 --> 00:27:08,550
>> - లీక్-చెక్ పూర్తి సమానం.

623
00:27:08,550 --> 00:27:10,180
Yep, ధన్యవాదాలు.

624
00:27:10,180 --> 00:27:12,520
- లీక్-చెక్ పూర్తి సమానం.

625
00:27:12,520 --> 00:27:13,800
ఎంటర్ చెయ్యండి.

626
00:27:13,800 --> 00:27:14,940
అదే కార్యక్రమం నడుపుతుంది.

627
00:27:14,940 --> 00:27:16,180
మళ్ళీ డేవిడ్ లో టైప్ చెయ్యండి.

628
00:27:16,180 --> 00:27:17,660
ఇప్పుడు నేను ఒక చిన్న మరింత వివరాలు చూడండి.

629
00:27:17,660 --> 00:27:20,890
కానీ కుప్ప సారాంశం క్రింద, ఇది
నాలుగు కి - అహ్,

630
00:27:20,890 --> 00:27:22,120
ఈ nice రకం.

631
00:27:22,120 --> 00:27:25,460
ఇప్పుడు Valgrind నిజానికి చూస్తున్నానని
నా కోడ్ లో కష్టం కొద్దిగా.

632
00:27:25,460 --> 00:27:29,580
మరియు అది, స్పష్టంగా, ఆ విధంగా యొక్క
లైన్ malloc -

633
00:27:29,580 --> 00:27:30,580
మేము దూరంగా.

634
00:27:30,580 --> 00:27:31,980
వద్ద లైన్ -

635
00:27:31,980 --> 00:27:32,930
మేము అది ఏమి లైన్ చూడండి లేదు.

636
00:27:32,930 --> 00:27:35,110
కానీ malloc మొదటి దోషిగా.

637
00:27:35,110 --> 00:27:38,630
Malloc ఒక బ్లాగ్ ఉంది.

638
00:27:38,630 --> 00:27:39,810
>> అన్ని కుడి?

639
00:27:39,810 --> 00:27:40,450
OK, ఏ.

640
00:27:40,450 --> 00:27:40,940
కుడి?

641
00:27:40,940 --> 00:27:42,520
నేను getstring అని.

642
00:27:42,520 --> 00:27:44,460
getstring స్పష్టంగా malloc కాల్స్.

643
00:27:44,460 --> 00:27:47,800
సో వాట్ కోడ్ లైన్ స్పష్టంగా ఉంది
కలిగి తప్పు

644
00:27:47,800 --> 00:27:49,050
ఈ మెమరీ కేటాయించిన?

645
00:27:49,050 --> 00:27:51,560

646
00:27:51,560 --> 00:27:55,540
లెట్ యొక్క ఎవరైతే అతడ్ని malloc రాశాడు భావించేందుకు
చాలా కాలం ఇలాంటి చుట్టూ ఉంది

647
00:27:55,540 --> 00:27:56,390
వారి తప్పు.

648
00:27:56,390 --> 00:27:57,520
కనుక ఇది బహుశా గని యొక్క.

649
00:27:57,520 --> 00:28:02,000
cs50.c లో getstring - ఒక యొక్క తద్వారా
కంప్యూటర్ లో వేరే ఫైల్ -

650
00:28:02,000 --> 00:28:05,210
లైన్ లో 286 అపరాధి ఉన్నట్టుగా.

651
00:28:05,210 --> 00:28:08,140
ఇప్పుడు cs50 చేయబడిందని భావించండి వీలు
కాబట్టి సమయం decent మొత్తం, దాదాపు

652
00:28:08,140 --> 00:28:09,720
మేము చాలా అమోఘమైన ఉన్నాయి.

653
00:28:09,720 --> 00:28:14,080
కావున getstring బహుశా కాదు
బగ్ ఉంది, కానీ ఆ

654
00:28:14,080 --> 00:28:17,810
హలో-2.c లైన్ 18.

655
00:28:17,810 --> 00:28:20,670
>> సో యొక్క పరిశీలించి వీలు
లైనును 18 ఏమి ఉంది.

656
00:28:20,670 --> 00:28:21,130
ఓహ్.

657
00:28:21,130 --> 00:28:27,130
ఏదో ఈ లైన్ తప్పనిసరిగా కాదు
బగ్గీ, కేవలంగా, కానీ అది కారణం

658
00:28:27,130 --> 00:28:28,630
ఆ మెమొరీ లీక్ వెనుక.

659
00:28:28,630 --> 00:28:32,140
సో సూపర్ కేవలం, ఏ అకారణంగా చేస్తాను
ఇక్కడ పరిష్కారంగా?

660
00:28:32,140 --> 00:28:34,710
మేము మెమరీ కోరుతూ ఉంటే, ఎప్పుడూ ఉన్నాయి
అది తిరిగి ఇవ్వడం, మరియు ఒక ఉన్నట్టుగా

661
00:28:34,710 --> 00:28:37,940
సమస్య ఎందుకంటే నా కంప్యూటర్
మెమరీ రన్నవుట్ ఉండవచ్చు, నెమ్మది కావచ్చు

662
00:28:37,940 --> 00:28:42,110
డౌన్, చెడు విషయాలు బాగా, జరిగే
సాధారణ సహజమైన పరిష్కారం ఏమిటి?

663
00:28:42,110 --> 00:28:43,140
అది తిరిగి ఇవ్వాలని.

664
00:28:43,140 --> 00:28:44,770
>> ఎలా మీరు మెమరీ పెంచడం లేదు?

665
00:28:44,770 --> 00:28:49,970
బాగా, అదృష్టవశాత్తూ చాలా సులభం
కేవలం ఉచిత పేరు చెప్పటానికి.

666
00:28:49,970 --> 00:28:51,260
మరియు మేము ముందు ఈ ఎప్పుడూ చేసిన.

667
00:28:51,260 --> 00:28:55,890
కానీ మీరు తప్పనిసరిగా యొక్క ఆలోచించవచ్చు
malloc వ్యతిరేకం గా ఉచిత.

668
00:28:55,890 --> 00:28:58,030
ఉచిత వ్యతిరేకం
మెమరీ పెడుతోంది.

669
00:28:58,030 --> 00:28:59,540
కాబట్టి ఇప్పుడు నాకు ఈ మళ్ళీ కంపైల్ చెయ్యండి వీలు.

670
00:28:59,540 --> 00:29:02,050
హలో-2 తయారు.

671
00:29:02,050 --> 00:29:04,620
నాకు మళ్లీ అమలు లెట్. హలో-2 డేవిడ్.

672
00:29:04,620 --> 00:29:07,290
కనుక ఇది పని ఉంది
సరిగ్గా అదే విధంగా.

673
00:29:07,290 --> 00:29:11,180
కానీ నేను Valgrind వెళ్లి తిరిగి అమలు చేస్తే
నా కొత్తగా అదే ఆదేశం

674
00:29:11,180 --> 00:29:14,720
సంకలనం కార్యక్రమం, టైపింగ్
ముందు నా పేరు లో -

675
00:29:14,720 --> 00:29:15,370
బాగుంది.

676
00:29:15,370 --> 00:29:16,760
కుప్ప సారాంశం -

677
00:29:16,760 --> 00:29:17,740
- నిష్క్రమణ ఉపయోగిస్తున్నాయి

678
00:29:17,740 --> 00:29:19,370
సున్నా బ్లాక్స్ లో సున్నా బైట్లు.

679
00:29:19,370 --> 00:29:21,840
మరియు ఈ సూపర్ nice, అన్ని ఉంది
కుప్ప బ్లాక్స్ విడుదలయ్యారు.

680
00:29:21,840 --> 00:29:23,480
సంఖ్య దోషాలను సాధ్యమే.

681
00:29:23,480 --> 00:29:27,200
>> సో, కాదు సమస్య సెట్ 4, వస్తున్నప్పుడు
కానీ సమస్య సెట్ 5, ఫోరెన్సిక్స్ తో

682
00:29:27,200 --> 00:29:30,740
మరియు ముందుకు, ఈ చాలా అవుతుంది
మీ యొక్క ఖచ్చితత్వం యొక్క కొలత

683
00:29:30,740 --> 00:29:33,630
మీరు లేదో కార్యక్రమం,
లేదా మెమరీ లీకేజ్ లేదు.

684
00:29:33,630 --> 00:29:36,900
కానీ అదృష్టవశాత్తూ, మీరు సరైన కారణం కాదు మాత్రమే
వాటిని అకారణంగా, ఇది ద్వారా

685
00:29:36,900 --> 00:29:40,430
చిన్న ప్రోగ్రామ్ల కోసం సులభం, నిస్సందేహంగా, ఉంది
కానీ పెద్ద కార్యక్రమాలు కష్టం,

686
00:29:40,430 --> 00:29:43,860
, ఆ పెద్ద కార్యక్రమాలు, Valgrind
మీరు గుర్తించడానికి సహాయపడుతుంది

687
00:29:43,860 --> 00:29:45,360
ప్రత్యేక సమస్య.

688
00:29:45,360 --> 00:29:47,500
>> కానీ మరొక సమస్య ఉంది
ఆ సంభవించబోయే.

689
00:29:47,500 --> 00:29:51,245
, ఇది, నాకు ఇక్కడ ఈ ఫైలు అప్ తెరవడానికి లెట్
మళ్ళీ, కొంత చిన్న ఉదాహరణ.

690
00:29:51,245 --> 00:29:53,760
కానీ లెట్ యొక్క ఏమి దృష్టి
ఈ కార్యక్రమం చేస్తుంది.

691
00:29:53,760 --> 00:29:55,190
ఈ memory.c అంటారు.

692
00:29:55,190 --> 00:29:58,380
మేము ఈ తరువాత రోజు పోస్ట్ చేస్తాము
నేటి సోర్స్ కోడ్ యొక్క జిప్.

693
00:29:58,380 --> 00:30:01,610
మరియు నేను అని ఒక ఫంక్షన్ కలిగి గమనించవచ్చు
వాదనలు మరియు పడుతుంది f

694
00:30:01,610 --> 00:30:02,800
ఏమీ తిరిగి.

695
00:30:02,800 --> 00:30:07,240
లైన్ 20 లో, నేను స్పష్టంగా ప్రకటించారు వెబ్
ఒక Int మరియు x కాల్ కు పాయింటర్.

696
00:30:07,240 --> 00:30:09,570
నేను కేటాయించి వెబ్ రాబడి
malloc యొక్క విలువ.

697
00:30:09,570 --> 00:30:14,590
మరియు కేవలం నేను ఎన్ని బైట్లు, స్పష్టమైన ఉండాలి
నేను బహుశా malloc నుండి తిరిగి పొందడానికి

698
00:30:14,590 --> 00:30:17,080
ఈ పరిస్థితి లో?

699
00:30:17,080 --> 00:30:18,040
>> బహుశా 40.

700
00:30:18,040 --> 00:30:18,840
ఎక్కడ నుండి పొందుతారు?

701
00:30:18,840 --> 00:30:22,410
బాగా, మీరు ఒక Int తరచుగా అని గుర్తు ఉంటే
4 బైట్లు, కనీసం అది ఉంది

702
00:30:22,410 --> 00:30:25,110
ఉపకరణం, సార్లు 4 10 ఖచ్చితంగా 40.

703
00:30:25,110 --> 00:30:28,920
సో malloc యొక్క చిరునామా తిరిగి
ఒక మెమరీ భాగం మరియు నిల్వ చేసే

704
00:30:28,920 --> 00:30:30,800
x చివరికి పరిష్కరించేందుకు.

705
00:30:30,800 --> 00:30:32,570
సో, స్పష్టమైన ఉండాలి ఏమి
అప్పుడు ఏమి జరుగుతుందో?

706
00:30:32,570 --> 00:30:34,990
బాగా, నాకు తిరిగి మారవచ్చు వీలు
ఇక్కడ మా చిత్రానికి.

707
00:30:34,990 --> 00:30:38,150
నాకు నా దిగువన డ్రా లేదు లెట్
కంప్యూటర్ యొక్క మెమరీ, నాకు ముందుకు వెళ్ళి వీలు మరియు

708
00:30:38,150 --> 00:30:42,990
మొత్తం దీర్ఘచతురస్ర ఆకర్షించే
నా RAM యొక్క అన్ని సూచిస్తుంది.

709
00:30:42,990 --> 00:30:44,790
>> మేము చెప్పటానికి మేము స్టాక్
అడుగున ఉంది.

710
00:30:44,790 --> 00:30:47,010
మరియు ఒక టెక్స్ట్ విభాగంలో ఉంది
అవినియోగిత డేటా.

711
00:30:47,010 --> 00:30:49,880
కానీ నేను వియుక్త ఆ వెళుతున్న
దూరంగా డాట్, డాట్, డాట్ వంటి ఇతర విషయాలు.

712
00:30:49,880 --> 00:30:53,470
నేను ఈ చూడండి వెళుతున్న
ఎగువన కుప్ప వంటి.

713
00:30:53,470 --> 00:30:57,070
ఆపై ఈ చిత్రాన్ని దిగువన,
ప్రధాన ప్రాతినిధ్యం, నేను వెళుతున్నాను

714
00:30:57,070 --> 00:30:59,880
అది ఒక ముక్కలు మెమరీ ఇవ్వాలని
స్టాక్ న.

715
00:30:59,880 --> 00:31:03,150
F కోసం, నేను ఒక స్లైస్ ఇవ్వాలని వెళుతున్నాను
స్టాక్ న మెమరీ.

716
00:31:03,150 --> 00:31:05,140
ఇప్పుడు, నేను నా సంప్రదించండి వచ్చింది
మళ్ళీ సోర్స్ కోడ్.

717
00:31:05,140 --> 00:31:07,170
ప్రధాన స్థానిక వేరియబుల్స్ ఏమిటి?

718
00:31:07,170 --> 00:31:10,710
స్పష్టంగా ఏమీ, తద్వారా స్లైస్ ఉంది
సమర్థవంతంగా ఖాళీ లేదా కూడా పెద్ద

719
00:31:10,710 --> 00:31:11,600
నేను తీసిన చేసిన వంటి.

720
00:31:11,600 --> 00:31:15,730
కానీ ఎఫ్ లో, నేను, ఒక స్థానిక వేరియబుల్ కలిగి
ఇది x అంటారు.

721
00:31:15,730 --> 00:31:20,410
నేను ముందుకు వెళ్లి f ఇవ్వాలని వెళుతున్నాను
ఇది x కాల్ మెమరీ భాగం.

722
00:31:20,410 --> 00:31:24,680
>> , 10 సార్లు 4 మరియు ఇప్పుడు malloc
ఆ పేరు malloc 40, సో

723
00:31:24,680 --> 00:31:25,430
మెమరీ నుండి వస్తున్న?

724
00:31:25,430 --> 00:31:27,530
మేము ఒక చిత్రాన్ని తీసిన కాదు చేసిన
ముందు ఈ ఇష్టం.

725
00:31:27,530 --> 00:31:31,140
కానీ దానిని సమర్థవంతంగా అని అనుకుంటే వీలు
కాబట్టి ఒక, ఇక్కడ నుండి వస్తున్న,

726
00:31:31,140 --> 00:31:33,170
రెండు, మూడు, నాలుగు, ఐదు.

727
00:31:33,170 --> 00:31:34,680
మరియు ఇప్పుడు నేను ఈ యొక్క 40 అవసరం.

728
00:31:34,680 --> 00:31:37,540
సో నేను సూచించారు డాట్, డాట్, డాట్ చేస్తాను
మరింత మెమరీ ఉందని

729
00:31:37,540 --> 00:31:39,350
కుప్ప నుండి తిరిగి వచ్చే.

730
00:31:39,350 --> 00:31:40,710
ఇప్పుడు చిరునామా ఏమిటి?

731
00:31:40,710 --> 00:31:42,620
లెట్ యొక్క మా అనియత ఎంచుకోండి
ఎల్లప్పుడూ పరిష్కరించేందుకు -

732
00:31:42,620 --> 00:31:46,310
ఇది బహుశా జరగబోతోంది అయినప్పటికీ Ox123,
పూర్తిగా వేర్వేరు ఏదో ఒక.

733
00:31:46,310 --> 00:31:50,420
ఆ మొదటి బైట్ యొక్క చిరునామా వార్తలు
నేను malloc అడుగుతూ వెబ్ జ్ఞప్తి.

734
00:31:50,420 --> 00:31:53,630
>> సో చిన్న, ఒకసారి లైన్ లో 20, అమలు
వాచ్యంగా ఏమిటి

735
00:31:53,630 --> 00:31:57,170
ఇక్కడ x లోపలి నిల్వ?

736
00:31:57,170 --> 00:31:58,730
Ox123.

737
00:31:58,730 --> 00:32:00,370
Ox123.

738
00:32:00,370 --> 00:32:01,550
మరియు ఆక్స్ రసహీనమైన ఉంది.

739
00:32:01,550 --> 00:32:03,200
ఇది కేవలం వార్తలు ఇక్కడ అర్థం ఒక
హెక్సాడెసిమల్ సంఖ్య.

740
00:32:03,200 --> 00:32:06,490
కానీ కీ యొక్క నేను స్టోర్ చేసిన ఏమి ఉంది
x లో, ఇది ఒక స్థానిక వేరియబుల్ ఉంది.

741
00:32:06,490 --> 00:32:10,260
కానీ దాని డేటా రకం, మళ్ళీ,
ఒక Int ఒక చిరునామా.

742
00:32:10,260 --> 00:32:12,710
Well, నేను Ox123 నిల్వ వెళుతున్న.

743
00:32:12,710 --> 00:32:16,610
కానీ మళ్ళీ, కొద్దిగా చాలా ఆ ఉంటే
నేను స్క్రోల్ చేయండి, అనవసరంగా సంక్లిష్టంగా

744
00:32:16,610 --> 00:32:21,490
తిరిగి, మేము ఈ దూరంగా వియుక్త చెయ్యవచ్చు చాలా
సహేతుక మరియు కేవలం చెప్పే ఆ x ఒక

745
00:32:21,490 --> 00:32:23,910
మెమరీ యొక్క భాగం కు పాయింటర్.

746
00:32:23,910 --> 00:32:24,070
>> OK.

747
00:32:24,070 --> 00:32:26,230
ఇప్పుడు చేతిలో ప్రశ్న
ఇలా -

748
00:32:26,230 --> 00:32:29,910
లైన్ 21, దాన్ని చేస్తుంది, బగ్గీ ఉంది.

749
00:32:29,910 --> 00:32:31,160
ఎందుకు?

750
00:32:31,160 --> 00:32:34,890

751
00:32:34,890 --> 00:32:36,930
>> క్షమించాలి?

752
00:32:36,930 --> 00:32:38,640
ఇది లేదు -

753
00:32:38,640 --> 00:32:40,390
ఒకసారి మరింత చెప్తారు.

754
00:32:40,390 --> 00:32:41,240
బాగా, అది ఉచిత లేదు.

755
00:32:41,240 --> 00:32:42,350
తద్వారా రెండవ కానీ.

756
00:32:42,350 --> 00:32:45,000
సో ఇతర ప్రత్యేకంగా ఒక ఉంది
లైన్ 21.

757
00:32:45,000 --> 00:32:49,480

758
00:32:49,480 --> 00:32:50,040
>> సరిగ్గా.

759
00:32:50,040 --> 00:32:54,980
కోడ్ యొక్క ఈ సులభమైన మార్గం కేవలం ఒక ఉంది
బఫర్ ఓవర్ఫ్లో, ఒక బఫర్ పారిపోవడం.

760
00:32:54,980 --> 00:32:57,050
ఒక బఫర్ కేవలం మెమరీ భాగం అర్థం.

761
00:32:57,050 --> 00:33:01,520
కానీ మెమరీ యొక్క భాగం పరిమాణంలో ఉంటుంది
10, 10 పూర్ణాంకాల, అంటే మనం

762
00:33:01,520 --> 00:33:05,350
వాక్యనిర్మాణ చక్కెర ద్వారా లోకి సూచిక
అర్రే సంజ్ఞామానం, చదరపు

763
00:33:05,350 --> 00:33:09,220
బ్రాకెట్లలో, మీరు యాక్సెస్
x బ్రాకెట్ 0 x బ్రాకెట్ 1 x,

764
00:33:09,220 --> 00:33:10,390
బ్రాకెట్ డాట్, డాట్, డాట్.

765
00:33:10,390 --> 00:33:13,270
x బ్రాకెట్ 9 అతిపెద్ద ఒకటి.

766
00:33:13,270 --> 00:33:17,680
నేను x బ్రాకెట్ 10, ఎంత ఉంటే పేరు
నేను నిజానికి మెమరీ లో వెళుతున్న?

767
00:33:17,680 --> 00:33:19,120
>> Well, నేను 10 Int ఉంటే -

768
00:33:19,120 --> 00:33:21,070
వీలు యొక్క నిజానికి అన్ని డ్రా
ఇక్కడ ఈ అవ్ట్.

769
00:33:21,070 --> 00:33:22,700
తద్వారా మొదటి ఐదు సంవత్సరాల.

770
00:33:22,700 --> 00:33:24,660
ఇక్కడ ఇతర ఐదు ints వార్తలు.

771
00:33:24,660 --> 00:33:29,580
సో x బ్రాకెట్ 0 ఇక్కడ ఉంది. x బ్రాకెట్ 1
ఇక్కడ. x బ్రాకెట్ 9 ఇక్కడ ఉంది. x బ్రాకెట్

772
00:33:29,580 --> 00:33:37,960
10 ఇక్కడ, ఇది, నేను చెప్పడం చేస్తున్నాను అంటే
లైన్ 21 లో, కంప్యూటర్ ఉంచాలి

773
00:33:37,960 --> 00:33:39,400
సంఖ్య పేరు?

774
00:33:39,400 --> 00:33:42,010
సంఖ్య 0 పేరు?

775
00:33:42,010 --> 00:33:43,380
బాగా, అది అవును 0 వార్తలు.

776
00:33:43,380 --> 00:33:45,460
కానీ కేవలం నిజానికి దాని 0
ఏకకాల రకం.

777
00:33:45,460 --> 00:33:47,140
ఇది సంఖ్య కావచ్చు
50, మేము శ్రమ అన్ని కోసం.

778
00:33:47,140 --> 00:33:50,480
కానీ మేము x బ్రాకెట్ వద్ద అది చాలు ప్రయత్నిస్తున్న
పేరు ఈ ఇది 10,

779
00:33:50,480 --> 00:33:53,700
ప్రశ్న గుర్తు, డ్రా ఇది
ఒక మంచి విషయం కాదు.

780
00:33:53,700 --> 00:33:57,070
ఈ కార్యక్రమం చాలా బాగా బలం
ఫలితంగా క్రాష్.

781
00:33:57,070 --> 00:33:59,400
>> ఇప్పుడు, యొక్క ముందుకు వెళ్లి చూసేందుకు ఈ ఉంటే
నిజానికి, ఏమి జరుగుతుంది ఉంది.

782
00:33:59,400 --> 00:34:02,600
మెమరీ చేయండి, తరువాత ఫైల్ను
memory.c అంటారు.

783
00:34:02,600 --> 00:34:05,950
లెట్ యొక్క ముందుకు వెళ్లి అమలు
ప్రోగ్రామ్ మెమరీలో.

784
00:34:05,950 --> 00:34:08,239
కాబట్టి మేము అదృష్ట వచ్చింది, నిజానికి, అది కనిపిస్తుంది.

785
00:34:08,239 --> 00:34:09,340
మేము అదృష్ట వచ్చింది.

786
00:34:09,340 --> 00:34:11,060
కాని ఇప్పుడు Valgrind అమలు లేదో యొక్క చూసేలా.

787
00:34:11,060 --> 00:34:14,170
మొదటి చూపులో, నా కార్యక్రమం వాటిని
సంపూర్ణ సరైన అనిపించడం.

788
00:34:14,170 --> 00:34:18,010
అయితే Valgrind నాకు అమలు తెలపండి
- లీక్-చెక్ మెమరీ పూర్తి సమానం.

789
00:34:18,010 --> 00:34:20,110
>> మరియు ఇప్పుడు నేను ఈ పరిగెడతారు -

790
00:34:20,110 --> 00:34:21,030
ఆసక్తికరమైన.

791
00:34:21,030 --> 00:34:26,800
చెల్లని వద్ద పరిమాణం 4 యొక్క వ్రాయండి
memory.c యొక్క లైన్ 21.

792
00:34:26,800 --> 00:34:29,284
Memory.c యొక్క లైన్ 21 ఇది ఒకటి?

793
00:34:29,284 --> 00:34:30,340
ఓహ్, ఆసక్తికరమైన.

794
00:34:30,340 --> 00:34:31,080
కానీ వేచి.

795
00:34:31,080 --> 00:34:32,389
సైజు 4, సూచిస్తూ ఆ ఏమిటి?

796
00:34:32,389 --> 00:34:34,969
నేను మాత్రమే ఒక, వ్రాయడానికి లేదు
కానీ అది పరిమాణం 4 యొక్క.

797
00:34:34,969 --> 00:34:36,889
ఎందుకు 4?

798
00:34:36,889 --> 00:34:39,280
అది ఒక Int, ఎందుకంటే ఇది
మళ్ళీ, నాలుగు బైట్లు, ఉంది.

799
00:34:39,280 --> 00:34:42,510
సో Valgrind ఒక బగ్ దొరకలేదు నేను,
నా కోడ్ చూసుకుంటూ ఉండడాన్ని, కాదు.

800
00:34:42,510 --> 00:34:45,040
మరియు ఉండవచ్చు మీ TF చేస్తాను లేదా కాదు.

801
00:34:45,040 --> 00:34:48,469
కానీ ఖచ్చితంగా దొరకలేదు కోసం Valgrind ఏమి
మేము కూడా, అక్కడ ఒక తప్పు చేసిన

802
00:34:48,469 --> 00:34:52,719
మేము అదృష్ట వచ్చింది, మరియు అయితే కంప్యూటర్
నిర్ణయించుకుంది, EH, నేను క్రాషవ్వటానికి వెళ్ళడం లేదు

803
00:34:52,719 --> 00:34:57,470
మీరు ఒక బైట్, ఒక తాకిన కేవలం ఎందుకంటే
మీరు లేదని మెమరీ Int యొక్క విలువ

804
00:34:57,470 --> 00:34:58,550
నిజానికి సొంత.

805
00:34:58,550 --> 00:35:00,380
>> బాగా, ఇక్కడ బగ్గీ ఏమి ఉంది.

806
00:35:00,380 --> 00:35:01,180
చిరునామా -

807
00:35:01,180 --> 00:35:03,190
ఈ ఒక వెర్రి చూస్తున్న చిరునామా
హెక్సాడెసిమల్ లో.

808
00:35:03,190 --> 00:35:06,890
కేవలం ఎక్కడా కుప్ప ఉంది అంటే
పరిమాణం 40 నిరోధించిన తర్వాత సున్నా బైట్లు

809
00:35:06,890 --> 00:35:07,620
కేటాయించబడుతుంది.

810
00:35:07,620 --> 00:35:10,610
నాకు ఇక్కడ దూరంగా మరియు చూద్దాం ఉంటే
ఈ కొద్దిగా మరింత ఉపయోగకరంగా ఉంటుంది.

811
00:35:10,610 --> 00:35:11,410
ఆసక్తికరమైన.

812
00:35:11,410 --> 00:35:15,600
40 బైట్లు ఖచ్చితంగా పోయాయి
1 నష్టం రికార్డు 1 లో.

813
00:35:15,600 --> 00:35:17,840
మళ్ళీ, కంటే ఎక్కువ పదాలు ఇక్కడ ఉపయోగకరంగా ఉంటుంది.

814
00:35:17,840 --> 00:35:21,350
కానీ, హైలైట్ పంక్తులు ఆధారంగా
పేరు నేను బహుశా దృష్టి పెట్టాలి నా

815
00:35:21,350 --> 00:35:24,070
మరొక బగ్ కోసం శ్రద్ధ?

816
00:35:24,070 --> 00:35:26,570
Memory.c ఒక లైన్ 20 అనిపిస్తోంది.

817
00:35:26,570 --> 00:35:30,990
>> మేము లైన్ 20 తిరిగి వెళ్ళి కనుక, ఆ
మీరు ముందు గుర్తించిన ఒక.

818
00:35:30,990 --> 00:35:33,030
మరియు అది బగ్గీ అవసరం లేదు.

819
00:35:33,030 --> 00:35:35,160
కానీ మేము ఈ దాని ప్రభావాలు తిరిగి.

820
00:35:35,160 --> 00:35:38,790
సో ఎలా నేను కనీసం సరి లేదు
ఆ తప్పులను ఒకటి?

821
00:35:38,790 --> 00:35:42,240
నేను లైన్ 21 తర్వాత ఏమి కాలేదు?

822
00:35:42,240 --> 00:35:47,110
నేను, x యొక్క ఉచిత ఉంది అలా
మెమరీ తిరిగి ఇవ్వాలని.

823
00:35:47,110 --> 00:35:49,230
మరియు నేను ఈ బగ్ ఎలా పరిష్కరించాలి?

824
00:35:49,230 --> 00:35:52,120
నేను ఖచ్చితంగా వెళ్ళాలి
ఏ దూరంగా 0 కంటే.

825
00:35:52,120 --> 00:35:53,670
సో నాకు ప్రయత్నించండి మరియు ఈ తిరిగి అమలు తెలపండి.

826
00:35:53,670 --> 00:35:56,080
క్షమించాలి, ఖచ్చితంగా వెళ్ళండి
ఏ దూరంగా 9 కంటే.

827
00:35:56,080 --> 00:35:57,510
మెమరీ చేయండి.

828
00:35:57,510 --> 00:36:00,650
Valgrind నాకు తిరిగి లెట్
ఒక పెద్ద విండోలో.

829
00:36:00,650 --> 00:36:01,580
మరియు ఇప్పుడు చూడండి.

830
00:36:01,580 --> 00:36:02,250
నీస్.

831
00:36:02,250 --> 00:36:03,270
అన్ని కుప్ప బ్లాక్స్ విడుదలయ్యారు.

832
00:36:03,270 --> 00:36:04,270
సంఖ్య దోషాలను సాధ్యమే.

833
00:36:04,270 --> 00:36:07,520
మరియు ఇక్కడ పైన, ప్రస్తావనే లేదు ఉంది
చెల్లని హక్కు ఏ.

834
00:36:07,520 --> 00:36:09,820
>> కేవలం అత్యాశ పొందుటకు, మరియు లెట్ యొక్క
చూడండి మరొక ప్రదర్శన

835
00:36:09,820 --> 00:36:11,050
ఉద్దేశించబడింది వెళ్ళి లేదు -

836
00:36:11,050 --> 00:36:12,560
నేను ఒక క్షణం క్రితం అదృష్ట వచ్చాం.

837
00:36:12,560 --> 00:36:15,530
మరియు ఈ 0 వాస్తవం బహుశా ఉంది
అనవసరంగా తప్పుదోవ పట్టించే.

838
00:36:15,530 --> 00:36:20,650
కేవలం 50, కొంత అనియత అన్నారు యొక్క
సంఖ్య, మెమరీ డాట్ స్లాష్ మెమరీ తయారు -

839
00:36:20,650 --> 00:36:21,410
ఇప్పటికీ అదృష్ట పొందుటకు.

840
00:36:21,410 --> 00:36:22,510
ఏమీ క్రాష్ యొక్క.

841
00:36:22,510 --> 00:36:26,150
నేను నిజంగా ఏదో ఊహించు
వెర్రి, మరియు నేను 100 చేయండి.

842
00:36:26,150 --> 00:36:30,360
, నాకు మెమరీ రీమేక్ లెట్
డాట్ స్లాష్ మెమరీ -

843
00:36:30,360 --> 00:36:31,075
మళ్ళీ అదృష్ట వచ్చింది.

844
00:36:31,075 --> 00:36:32,800
ఎలా 1,000?

845
00:36:32,800 --> 00:36:35,370
దాటి ints, సుమారు,
నేను ఎక్కడ ఉండాలి?

846
00:36:35,370 --> 00:36:37,410
మెమరీ చేయండి -

847
00:36:37,410 --> 00:36:38,570
ఇది డామన్.

848
00:36:38,570 --> 00:36:39,920
>> [నవ్వు]

849
00:36:39,920 --> 00:36:41,270
>> OK.

850
00:36:41,270 --> 00:36:43,920
యొక్క ఇకపై చుట్టూ విసిగిపోకండి కాదు లెట్.

851
00:36:43,920 --> 00:36:45,120
మెమరీ తిరిగి.

852
00:36:45,120 --> 00:36:45,840
అక్కడ మేము వెళ్ళి.

853
00:36:45,840 --> 00:36:46,410
అన్ని కుడి.

854
00:36:46,410 --> 00:36:52,500
సో స్పష్టంగా మీరు ఇండెక్స్ 100,000 ints
మీరు ఉన్నాయి చోట దాటి

855
00:36:52,500 --> 00:36:54,410
మెమరీ, చెడు విషయాల జరిగే.

856
00:36:54,410 --> 00:36:56,430
సో ఈ ఖచ్చితంగా కాదు
ఒక హార్డ్, ఫాస్ట్ పాలన.

857
00:36:56,430 --> 00:36:58,190
నేను విచారణ ఉపయోగించి రకం ఉంది
మరియు లోపం పొందుటకు.

858
00:36:58,190 --> 00:37:02,230
కానీ ఈ, ఎందుకంటే, దీర్ఘ కథ చిన్న ఉంది
మీ కంప్యూటర్ యొక్క మెమరీ కూడా విభజించబడింది

859
00:37:02,230 --> 00:37:03,580
ఈ విషయాలు లోకి భాగాలు అని.

860
00:37:03,580 --> 00:37:07,260
మరియు కొన్నిసార్లు, కంప్యూటర్ నిజానికి
మీరు కొద్దిగా మరింత మెమరీ ఇచ్చింది

861
00:37:07,260 --> 00:37:08,400
మీరు అడిగే కంటే.

862
00:37:08,400 --> 00:37:12,170
కానీ సామర్థ్యం కోసం, ఇది కేవలం సులభం
మరింత మెమరీ పొందుటకు కానీ మాత్రమే మీరు చెప్పండి

863
00:37:12,170 --> 00:37:13,780
మీరు ఒక భాగం పొందడానికి చేయవచ్చు.

864
00:37:13,780 --> 00:37:16,370
>> మరియు మీరు కొన్నిసార్లు అదృష్ట పొందుటకు ఉంటే,
అందువలన, మీరు తాకే చేయవచ్చు

865
00:37:16,370 --> 00:37:17,795
మెమరీ మీకు సంబంధించినది కాదు.

866
00:37:17,795 --> 00:37:21,860
సందర్సకులలో మీ సంఖ్య హామీ కలిగి ఏమి విలువ
మీరు, అక్కడ ఉండాలని ఉంటుంది చాలు ఎందుకంటే

867
00:37:21,860 --> 00:37:25,080
కంప్యూటర్ ఇప్పటికీ అది భావిస్తోంది
మీదే, కానీ అది తప్పనిసరిగా మాత్రం కాదు

868
00:37:25,080 --> 00:37:29,910
లో మెమరీ మరొక విభాగం నొక్కండి
కంప్యూటర్ మరియు ఒక తప్పు వంటి ప్రేరేపించడానికి

869
00:37:29,910 --> 00:37:31,710
ఇక్కడ ఈ ఒక.

870
00:37:31,710 --> 00:37:32,060
అన్ని కుడి.

871
00:37:32,060 --> 00:37:37,240
అప్పుడు ఏదైనా ప్రశ్నలు మెమొరీ?

872
00:37:37,240 --> 00:37:37,590
>> అన్ని కుడి.

873
00:37:37,590 --> 00:37:40,610
వద్ద, అప్పుడు, యొక్క ఇక్కడ ఒక లుక్ తీసుకుందాం
మేము తీసుకోవడం చేసిన ఏదో

874
00:37:40,610 --> 00:37:48,361
కొంతకాలంగా మంజూరు, ఇది
cs50.h. అని ఈ ఫైలు ఉంది

875
00:37:48,361 --> 00:37:49,420
సో ఈ ఫైలు.

876
00:37:49,420 --> 00:37:51,130
ఈ కేవలం ఒక మొత్తం బంచ్ ఉంటాయి
టాప్ వ్యాఖ్యానాలు.

877
00:37:51,130 --> 00:37:53,900
మరియు మీరు ఈ ఉంటే చూశారు ఉండవచ్చు
మీరు ఉపకరణం చుట్టూ ఎత్తిచూపారు.

878
00:37:53,900 --> 00:37:57,000
కానీ, అన్ని సమయం హాజరవుతారు
మేము ఒక స్ట్రింగ్ ఉపయోగించారు ఉన్నప్పుడు

879
00:37:57,000 --> 00:38:01,130
పర్యాయపదంగా, మేము ప్రకటించారు మార్గాలుగా
ఆ పర్యాయపదంగా ఈ తో

880
00:38:01,130 --> 00:38:03,990
రకం నిర్వచనం కోసం typedef కీవర్డ్.

881
00:38:03,990 --> 00:38:07,500
మరియు మేము తప్పనిసరిగా చెబుతున్న దాన్ని, తయారు
చార్ స్టార్ పర్యాయపదంగా స్ట్రింగ్.

882
00:38:07,500 --> 00:38:11,190
అనగా ద్వారా స్టాక్
అని పిలిచే ఈ శిక్షణ చక్రాలు రూపొందించినవారు

883
00:38:11,190 --> 00:38:12,040
స్ట్రింగ్.

884
00:38:12,040 --> 00:38:14,830
>> ఇప్పుడు ఇక్కడ కేవలం ఒక నమూనా యొక్క
getchar కోసం.

885
00:38:14,830 --> 00:38:17,350
మేము ముందు చూసిన ఉండవచ్చు, కానీ ఆ
నిజానికి అది చేస్తుంది. getchar

886
00:38:17,350 --> 00:38:19,070
, వాదనలు సంఖ్య పడుతుంది ఒక చార్ తిరిగి.

887
00:38:19,070 --> 00:38:21,340
getdouble, వాదనలు సంఖ్య పడుతుంది
డబుల్ తిరిగి.

888
00:38:21,340 --> 00:38:24,440
getfloat వాదనలు సంఖ్య, తిరిగి పడుతుంది
ఫ్లోట్, మొదలగునవి.

889
00:38:24,440 --> 00:38:27,270
getint ఇక్కడ ఉంది. getlonglong
ఇక్కడ ఉంది.

890
00:38:27,270 --> 00:38:28,820
మరియు getstring ఇక్కడ ఉంది.

891
00:38:28,820 --> 00:38:29,420
అంతే.

892
00:38:29,420 --> 00:38:33,080
ఈ ఊదా లైన్ మరొక ప్రాసెసర్ ఉంది
ఎందుకంటే నిర్దేశకం

893
00:38:33,080 --> 00:38:35,550
ఇది ప్రారంభంలో హాష్ ట్యాగ్.

894
00:38:35,550 --> 00:38:35,870
>> అన్ని కుడి.

895
00:38:35,870 --> 00:38:38,380
కాబట్టి ఇప్పుడు నాకు cs50.c. లోకి వెళ్ళి తెలపండి

896
00:38:38,380 --> 00:38:40,400
మరియు మేము ఈ చాలా పొడవుగా మాట్లాడను ఉంటుంది.

897
00:38:40,400 --> 00:38:43,280
కానీ మీరు ఏది సంగ్రహావలోకనం ఇవ్వాలని
అన్ని ఈ జరుగుతున్నాయి

898
00:38:43,280 --> 00:38:46,434
సమయం, నాకు వీలు -

899
00:38:46,434 --> 00:38:48,250
వీలు యొక్క getchar చేయండి.

900
00:38:48,250 --> 00:38:51,050
సో getchar ఎక్కువగా వ్యాఖ్యానాలు ఉంది.

901
00:38:51,050 --> 00:38:52,060
కానీ అది ఇలా కనిపిస్తుంది.

902
00:38:52,060 --> 00:38:54,800
సో ఈ వాస్తవ ఫంక్షన్
మేము కూడా చేసిన getchar

903
00:38:54,800 --> 00:38:56,055
మంజూరు కోసం తీసుకొని ఉంది.

904
00:38:56,055 --> 00:38:59,370
మరియు మేము ఈ ఒక ఉపయోగించని మాత్రం
తరచుగా, ఉంటే ఎప్పుడూ, అది కనీసం ఆ

905
00:38:59,370 --> 00:39:00,470
సులభమైన.

906
00:39:00,470 --> 00:39:02,580
కనుక ఇది ఒక వెచ్చించడం ఉపయోగకరమని
ఇక్కడ శీఘ్ర లుక్.

907
00:39:02,580 --> 00:39:06,540
>> సో getchar, అనంతమైన లూప్ ఉంది
ఉద్దేశపూర్వకంగా స్పష్టంగా.

908
00:39:06,540 --> 00:39:10,050
ఇది అప్పుడు కాల్స్ - మరియు ఈ ఒక రకం
కోడ్ యొక్క nice మళ్ళీ మనం రాశారు.

909
00:39:10,050 --> 00:39:11,220
ఇది getstring కాల్స్.

910
00:39:11,220 --> 00:39:12,460
అది ఏమి ఎందుకంటే
ఒక చార్ పొందుటకు అర్థం?

911
00:39:12,460 --> 00:39:14,730
బాగా, మీరు అలాగే ఒక పొందుటకు ప్రయత్నించండి
మొత్తం యూజర్ నుండి టెక్స్ట్ లైన్ మరియు

912
00:39:14,730 --> 00:39:16,940
అప్పుడు కేవలం ఒక చూడండి
ఆ పాత్రలు.

913
00:39:16,940 --> 00:39:19,170
లైన్ 60 లో, ఇక్కడ ఒక చిన్న వార్తలు
ఒక చిత్తశుద్ధిపై చెక్ బిట్.

914
00:39:19,170 --> 00:39:21,610
Getstring శూన్య తిరిగి ఉంటే,
యొక్క ముందుకు వీలు.

915
00:39:21,610 --> 00:39:22,820
ఏదో తప్పు జరిగింది.

916
00:39:22,820 --> 00:39:28,120
>> ఇప్పుడు ఇది కాస్త బాధించే కానీ
బహుశా సి చార్ గరిష్టంగా సంప్రదాయ

917
00:39:28,120 --> 00:39:29,960
సూచిస్తుంది ఏమి కేవలం
దాని పేరు ఆధారంగా?

918
00:39:29,960 --> 00:39:31,670
అది స్థిరమైన వార్తలు.

919
00:39:31,670 --> 00:39:36,040
ఇది సంఖ్యా విలువ వంటిది
మీతో సూచిస్తుంది చార్ అతిపెద్ద

920
00:39:36,040 --> 00:39:40,370
బహుశా సంఖ్య ఇది ​​ఒక కాటు,
అతిపెద్ద సంఖ్య మీరు ఇది 255,

921
00:39:40,370 --> 00:39:42,720
, ఎనిమిది బిట్స్ ప్రాతినిధ్యం
సున్నా నుంచి.

922
00:39:42,720 --> 00:39:47,460
నేను ఉన్నప్పుడు, ఈ ఫంక్షన్ లో, ఈ ఉపయోగించడానికి చేసిన
మాత్రమే ఎందుకంటే, ఈ కోడు రాయడం

923
00:39:47,460 --> 00:39:51,753
ఏదో getchar లో తప్పు జరిగితే కానీ ఉంటే
జీవితం లో దాని ఉద్దేశ్యం తిరిగి ఉంది

924
00:39:51,753 --> 00:39:54,830
చార్ మీరు ఏదో ఉండాలి
యూజర్కు సంకేతంగా

925
00:39:54,830 --> 00:39:55,840
ఏదో తప్పు జరిగింది.

926
00:39:55,840 --> 00:39:56,970
మనం శూన్య తిరిగి.

927
00:39:56,970 --> 00:39:58,480
ఇది శూన్య ఒక పాయింటర్ అని హాజరవుతారు.

928
00:39:58,480 --> 00:40:01,030
మళ్ళీ, getchar ఉంది
ఒక చార్ తిరిగి.

929
00:40:01,030 --> 00:40:04,760
>> సో సమావేశం, ఏదో పోతే
తప్పు, మీరు ప్రోగ్రామర్, లేదా, ఉంది

930
00:40:04,760 --> 00:40:08,160
ఈ సందర్భంలో, నాకు గ్రంథాలయం, నేను కలిగి
ఒక కేవలం ఉంటే ఏకపక్ష నిర్ణయించుకుంటారు

931
00:40:08,160 --> 00:40:12,230
ఏదో తప్పు జరిగితే, నేను వెళుతున్నాను
నిజంగా ఇది సంఖ్య 255, తిరిగి

932
00:40:12,230 --> 00:40:17,240
మేము వినియోగదారు టైప్ కాదు ఇవ్వలేదు
ద్వారా ప్రాతినిధ్యం పాత్ర

933
00:40:17,240 --> 00:40:21,410
మేము కలిగి ఎందుకంటే సంఖ్య 255 ఒక అది దొంగతనం
ఒక అని పిలవబడే కాపలాదారుడు విలువ

934
00:40:21,410 --> 00:40:23,410
ఒక సమస్య సూచిస్తాయి.

935
00:40:23,410 --> 00:40:27,010
ఇప్పుడు దాన్ని చేస్తుంది ఆ పాత్ర 255
మీరు టైప్ ఏదో కాదు

936
00:40:27,010 --> 00:40:28,380
మీ కీబోర్డ్, కాబట్టి అది ఏ పెద్ద ఒప్పందం వార్తలు.

937
00:40:28,380 --> 00:40:30,910
వినియోగదారు నోటీస్ లేదు
నేను ఈ పాత్ర దొంగిలించబడిన చేసిన.

938
00:40:30,910 --> 00:40:34,620
కానీ మీరు ఎప్పుడూ ఒక వ్యక్తి పేజీలు చూస్తున్న ఉంటే
ఒక కంప్యూటర్ వ్యవస్థ కొన్ని సూచన

939
00:40:34,620 --> 00:40:38,560
, అని స్థిరంగా ఈ వంటి అన్ని పరిమితులను
లోపం ఈ స్థిరంగా మైట్ సందర్భాల్లో

940
00:40:38,560 --> 00:40:42,720
తిరిగి, ఆ చేసింది అన్ని కొన్ని మానవ వార్తలు
సంవత్సరాల క్రితం ఏకపక్ష నిర్ణయించారు

941
00:40:42,720 --> 00:40:45,680
ఈ ప్రత్యేక విలువ మరియు తిరిగి
అది విషయంలో స్థిరమైన కాల్

942
00:40:45,680 --> 00:40:46,840
ఏదో తప్పు జరిగితే.

943
00:40:46,840 --> 00:40:48,580
>> ఇప్పుడు మేజిక్ ఇక్కడ డౌన్ జరుగుతుంది.

944
00:40:48,580 --> 00:40:52,600
మొదటి, నేను లైన్ 67 లో ప్రకటించారు వెబ్
రెండు అక్షరాలు, C1 మరియు C2.

945
00:40:52,600 --> 00:40:57,080
ఆపై లైన్ 68 లో, నిజానికి ఉంది
స్మృతిగా ఆ కోడ్ యొక్క ఒక లైన్

946
00:40:57,080 --> 00:41:01,140
మా స్నేహితుడు printf, ఇచ్చిన అది
కోట్స్ లో శాతం C లు కలిగి లేదు.

947
00:41:01,140 --> 00:41:06,490
కానీ ఇక్కడ ఏం గమనించవచ్చు.
sscanf స్ట్రింగ్ స్కాన్ అంటే -

948
00:41:06,490 --> 00:41:11,690
ఒక ఆకృతీకరణ స్కాన్ అర్థం
స్ట్రింగ్, ergo sscanf.

949
00:41:11,690 --> 00:41:12,590
ఆ అర్థం ఏమిటి?

950
00:41:12,590 --> 00:41:16,310
ఇది మీరు ఒక స్ట్రింగ్ sscanf వెళుతుందని అర్థం.

951
00:41:16,310 --> 00:41:18,420
మరియు లైన్ సంసార ఉంది
సైన్ యూజర్ రకాల

952
00:41:18,420 --> 00:41:23,520
మీరు ఒక ఫార్మాట్ స్ట్రింగ్ వంటి sscanf వెళుతుందని
ఏమిటి scanf చెబుతాడు ఈ

953
00:41:23,520 --> 00:41:25,870
మీరు యూజర్ సైన్ టైప్ ఉంది ఆశతో

954
00:41:25,870 --> 00:41:29,730
అప్పుడు మీరు పాస్-రెండు చిరునామాలు
ఈ సందర్భంలో మెమరీ రాళ్లను,,

955
00:41:29,730 --> 00:41:31,150
నేను రెండు placeholders ఎందుకంటే.

956
00:41:31,150 --> 00:41:34,610
నేను దాన్ని చిరునామా ఇవ్వాలని వెళుతున్నాను
C1 మరియు C2 యొక్క చిరునామా.

957
00:41:34,610 --> 00:41:37,700
>> మరియు మీరు ఒక ఫంక్షన్ ఇవ్వాలని గుర్తుచేసుకున్నారు
కొన్ని వేరియబుల్ చిరునామా, ఏమిటి

958
00:41:37,700 --> 00:41:38,950
చిక్కుముడి?

959
00:41:38,950 --> 00:41:41,400

960
00:41:41,400 --> 00:41:45,050
ఆ ఫంక్షన్ ఫలితంగా ఏమి చెయ్యగలరు
అది ఒక చిరునామా ఇవ్వడం

961
00:41:45,050 --> 00:41:48,170
వేరియబుల్ గా వ్యతిరేకంగా
వేరియబుల్ కూడా?

962
00:41:48,170 --> 00:41:49,450
ఇది కుడి, అది మార్చవచ్చు?

963
00:41:49,450 --> 00:41:53,250
మీరు ఎవరైనా ఒక భౌతికమైన ఒక చిహ్నం కలిగి ఉంటే
చిరునామా, వారు అక్కడ వెళ్ళి చేయవచ్చు

964
00:41:53,250 --> 00:41:54,750
ఆ చిరునామా వద్ద కావలసిన.

965
00:41:54,750 --> 00:41:55,800
ఇక్కడ అదే ఆలోచన.

966
00:41:55,800 --> 00:41:59,950
మేము sscanf, రెండు చిరునామాకు పాస్ ఉంటే
కూడా మెమరీ రాళ్లను, ఈ చిన్న

967
00:41:59,950 --> 00:42:03,585
మెమరీ, C1 మరియు C2 కొద్దిగా రాళ్లను, కానీ
మేము వాటిని యొక్క చిరునామా చెప్పండి

968
00:42:03,585 --> 00:42:05,170
sscanf మార్చుకోవచ్చు.

969
00:42:05,170 --> 00:42:08,530
>> జీవితం లో sscanf యొక్క ప్రయోజనం సో, మేము చదవడానికి
మనిషి పేజీ, చదవడానికి ఏమిటి

970
00:42:08,530 --> 00:42:13,420
యూజర్ టైప్ కలిగి వినియోగదారు కోసం ఆశిస్తున్నాము
ఒక పాత్ర లో టైప్ చేసి

971
00:42:13,420 --> 00:42:16,470
మరొక పాత్ర, మరియు ఏ యూజర్
టైప్, మొదటి పాత్ర వెళ్తాడు

972
00:42:16,470 --> 00:42:19,310
ఇక్కడ, రెండవ పాత్ర ఇక్కడ వెళ్తాడు.

973
00:42:19,310 --> 00:42:22,470
ఇప్పుడు, జనాంతికంగా, ఈ, మరియు మీరు చేస్తాను
మాత్రమే, డాక్యుమెంటేషన్ నుండి ఈ తెలుసు

974
00:42:22,470 --> 00:42:25,570
నేను అక్కడ ఒక ఖాళీ ఉంచాలి వాస్తవం
నేను పట్టించుకోను అర్థం ఉంటే

975
00:42:25,570 --> 00:42:28,440
యూజర్ స్పేస్ బార్ కొన్ని హిట్స్
అతను లేదా ఆమె ఒక పడుతుంది ముందు

976
00:42:28,440 --> 00:42:30,400
పాత్ర, నేను పట్టించుకోకుండా వెళుతున్న
ఏ తెల్లని స్థలం.

977
00:42:30,400 --> 00:42:32,510
కనుక, నేను నుండి తెలుసు
డాక్యుమెంటేషన్.

978
00:42:32,510 --> 00:42:36,570
>> రెండవ% సి ఉంది వాస్తవం
వైట్ స్పేస్ నిజానికి

979
00:42:36,570 --> 00:42:37,410
ఉద్దేశపూర్వక.

980
00:42:37,410 --> 00:42:41,190
నేను గుర్తించగలిగారు ఉండాలనుకుంటున్నాను ఉంటే యూజర్
ఇరుక్కొనిపోయింది లేదా సహకరించలేదు.

981
00:42:41,190 --> 00:42:45,630
నేను యూజర్ మాత్రమే టైప్ చేసి ఆశతో వెబ్
ఒక పాత్ర లో, అందువలన నేను ఆశతో వెబ్

982
00:42:45,630 --> 00:42:50,640
ఆ sscanf మాత్రమే తిరిగి వెళ్తున్నారు
విలువ 1 నేను చదవడానికి, మళ్ళీ, ఎందుకంటే

983
00:42:50,640 --> 00:42:55,400
డాక్యుమెంటేషన్, sscanf యొక్క ప్రయోజనం లో
జీవితం యొక్క సంఖ్య తిరిగి ఉంది

984
00:42:55,400 --> 00:42:59,170
నిండిపోతాయి అని వేరియబుల్
యూజర్ ఇన్పుట్ తో.

985
00:42:59,170 --> 00:43:02,270
>> నేను రెండు వేరియబుల్స్ లో ఆమోదించింది
చిరునామాలు, C1 మరియు C2.

986
00:43:02,270 --> 00:43:06,420
నేను ఆ, అయితే, ఆశతో వెబ్ ఒకే ఒక
వాటిని చంపబడుతాడు ఎందుకంటే ఉంటే sscanf

987
00:43:06,420 --> 00:43:11,130
తిరిగి 2, బహుశా ఏమిటి
తార్కికంగా చిక్కుముడి?

988
00:43:11,130 --> 00:43:14,600
యూజర్ నాకు ఒక ఇవ్వాలని లేదు
పాత్ర నేను చెప్పాడు లేదా ఆమె.

989
00:43:14,600 --> 00:43:17,860
వారు బహుశా వద్ద టైప్
కనీసం రెండు అక్షరాలు.

990
00:43:17,860 --> 00:43:22,430
నేను బదులుగా రెండవ లేదు కనుక
% సి, నేను, ఒక కలిగి

991
00:43:22,430 --> 00:43:25,370
స్పష్టముగా మరింత స్పష్టమైన ఉంటుంది
విధానం, నేను ఒక మొదటి చూపులో అనుకుంటున్నాను,

992
00:43:25,370 --> 00:43:30,220
మీరు గుర్తించగలిగారు అవతరిస్తుంది లేదు
యూజర్ మీరు మరింత ఇస్తున్నారు ఉంటే

993
00:43:30,220 --> 00:43:31,780
మీరు నిజంగానే కావలెను కంటే ఇన్పుట్.

994
00:43:31,780 --> 00:43:34,100
సో ఈ ఒక అవ్యక్త రూపం
దోష పరిశీలన యొక్క.

995
00:43:34,100 --> 00:43:35,640
>> కానీ నేను ఇక్కడ ఏమి గమనించవచ్చు.

996
00:43:35,640 --> 00:43:39,970
ఒకసారి నేను వినియోగదారు ఒక ఇచ్చిన ఖచ్చితంగా రెడీ!
పాత్ర, నేను చేస్తున్న, లైన్ విడిపించేందుకు

997
00:43:39,970 --> 00:43:44,450
getstring వ్యతిరేకంగా, ఇది క్రమంగా
నేను తిరిగి అప్పుడు malloc ఉపయోగిస్తుంది, మరియు

998
00:43:44,450 --> 00:43:51,030
C1, నేను భావిస్తున్నట్లు పాత్ర
యూజర్ అందిస్తుంది మరియు ఇది అందించింది.

999
00:43:51,030 --> 00:43:54,680
సో శీఘ్ర మాత్రమే చూడటం, కానీ
getchar ఏ ప్రశ్నలు?

1000
00:43:54,680 --> 00:43:57,450

1001
00:43:57,450 --> 00:43:59,590
మేము ఇతరులు కొన్ని తిరిగి వచ్చి ఉంటుంది.

1002
00:43:59,590 --> 00:44:03,770
>> బాగా, నాకు ముందుకు వెళ్లి ఈ తెలియజేసేలా -
కేవలం ప్రోత్సహించటానికి, ఇప్పుడు ఊహించు మా

1003
00:44:03,770 --> 00:44:08,910
ఒక వారం పాటు సమయంలో చర్చ ఈ
structs.h అనే ఫైలు ఉంది.

1004
00:44:08,910 --> 00:44:11,440
మళ్ళీ, ఈ కేవలం ఒక రుచి ఉంది
ముందుకు ఉంది ఏదో యొక్క.

1005
00:44:11,440 --> 00:44:13,090
కానీ నోటీసు ఒక చాలా
ఈ వ్యాఖ్యలు ఉంది.

1006
00:44:13,090 --> 00:44:17,440
సో నాకు హైలైట్ వీలు మాత్రమే
ఇప్పుడు కోసం ఆసక్తికరమైన భాగంగా.

1007
00:44:17,440 --> 00:44:18,020
typedef -

1008
00:44:18,020 --> 00:44:19,700
అదే కీవర్డ్ మళ్ళీ ఉంది.

1009
00:44:19,700 --> 00:44:23,100
typedef మేము స్ట్రింగ్ డిక్లేర్ ఉపయోగించడానికి
ఒక ప్రత్యేక డేటా టైప్.

1010
00:44:23,100 --> 00:44:27,490
మీరు సరిక్రొత్త సృష్టించడానికి typedef ఉపయోగించవచ్చు
ఉన్నప్పుడు లేవని డేటా రకాలు

1011
00:44:27,490 --> 00:44:28,570
సి కనుగొన్నారు.

1012
00:44:28,570 --> 00:44:32,520
ఉదాహరణకు, Int సి చార్ తో వస్తుంది
సి డబుల్ C. తో వస్తుంది తో వస్తుంది కానీ

1013
00:44:32,520 --> 00:44:34,000
ఒక విద్యార్థి యొక్క భావన ఉంది.

1014
00:44:34,000 --> 00:44:37,230
మరియు ఇంకా అది చాలా ఉపయోగకరంగా ఉంటుంది
నిల్వ ఒక ప్రోగ్రామ్ను రాయడం చేయగలరు

1015
00:44:37,230 --> 00:44:40,440
ఒక వేరియబుల్ ఒక విద్యార్థి యొక్క ID నంబర్,
వారి పేరు, మరియు వారి ఇంటి.

1016
00:44:40,440 --> 00:44:42,890
ఇతర మాటలలో, మూడు ముక్కలు
డేటా, ఒక Int మరియు ఒక ఇష్టం

1017
00:44:42,890 --> 00:44:44,420
స్ట్రింగ్ మరియు మరొక స్ట్రింగ్.

1018
00:44:44,420 --> 00:44:48,220
>> Typedef తో, ఏ అందంగా శక్తివంతమైన వార్తలు
ఈ మరియు కీవర్డ్ sturct గురించి

1019
00:44:48,220 --> 00:44:53,660
నిర్మాణం, మీరు, 2013 లో ప్రోగ్రామర్,
నిజానికి మీ సొంత నిర్వచించలేదు

1020
00:44:53,660 --> 00:44:57,530
సంవత్సరాల లేవని డేటా రకాలు
క్రితం కానీ మీ ప్రయోజనాల సరిపోయేందుకు.

1021
00:44:57,530 --> 00:45:01,910
మరియు ఇక్కడ, 19 ద్వారా పంక్తులు 13 లో,
మేము వంటి, ఒక కొత్త డేటా రకం ప్రకటించారు చేస్తున్నారు

1022
00:45:01,910 --> 00:45:04,320
ఒక Int, కానీ విద్యార్ధి కాల్.

1023
00:45:04,320 --> 00:45:09,310
మరియు లోపల ఈ వేరియబుల్ కానుంది
ఒక Int, ఒక స్ట్రింగ్, - మూడు అంశాలను

1024
00:45:09,310 --> 00:45:09,930
మరియు ఒక స్ట్రింగ్.

1025
00:45:09,930 --> 00:45:13,040
సో మీరు నిజంగా ఏది ఆలోచించవచ్చు
ఈ అయినప్పటికీ, ఇక్కడ జరిగిన ఒక

1026
00:45:13,040 --> 00:45:17,160
నేడు కోసం ఒక సాధారణీకరణ బిట్,
ఒక విద్యార్థి తప్పనిసరిగా వెళ్తున్నారు

1027
00:45:17,160 --> 00:45:19,450
ఈ లాగా.

1028
00:45:19,450 --> 00:45:22,580
దాని యొక్క ఒక భాగం అవతరిస్తుంది
ఒక ID తో మెమరీ, ఒక పేరు

1029
00:45:22,580 --> 00:45:25,580
రంగంలో, మరియు ఒక ఇంటి రంగంలో.

1030
00:45:25,580 --> 00:45:30,670
మరియు మేము ఆ రాళ్లను ఉపయోగించడం చెయ్యగలరు
మెమరీ మరియు వాటిని యాక్సెస్ క్రింది.

1031
00:45:30,670 --> 00:45:38,870
>> నేను struct0.c లోకి వెళ్ళి ఉంటే, ఇక్కడ ఒక ఉంది
చాలా కాలం, కానీ తరువాత

1032
00:45:38,870 --> 00:45:42,630
కోడ్ యొక్క నమూనా, ఆ
ఈ కొత్త ట్రిక్ ఉపయోగిస్తుంది.

1033
00:45:42,630 --> 00:45:45,790
సో మొదటి, మీ దృష్టిని ఆకర్షించడం వీలు
టాప్ ఆసక్తికరమైన భాగాలకు.

1034
00:45:45,790 --> 00:45:49,670
వెంటనే విద్యార్థులు 3 నిర్వచిస్తుంది, ప్రకటించాడు ఒక
స్థిరంగా అని విద్యార్థులు మరియు హక్కుదారులు

1035
00:45:49,670 --> 00:45:53,450
ఇది కేవలం ఏకపక్ష సంఖ్య 3,
కాబట్టి నేను ఉపయోగించి మూడు విద్యార్థులను

1036
00:45:53,450 --> 00:45:54,830
ఇప్పుడు ఈ కార్యక్రమానికి.

1037
00:45:54,830 --> 00:45:55,960
ఇక్కడ ప్రధాన వస్తుంది.

1038
00:45:55,960 --> 00:45:58,860
మరియు నోటీసు, ఎలా నేను డిక్లేర్ లేదు
విద్యార్ధులు ఒక అర్రే?

1039
00:45:58,860 --> 00:46:00,480
బాగా, నేను అదే వాక్యనిర్మాణాన్ని ఉపయోగించుకుంటాయి.

1040
00:46:00,480 --> 00:46:02,110
పదం విద్యార్థి ఖచ్చితంగా కొత్తది.

1041
00:46:02,110 --> 00:46:04,790
కానీ విద్యార్ధి, తరగతి, బ్రాకెట్ విద్యార్థులు.

1042
00:46:04,790 --> 00:46:06,720
>> సో దురదృష్టవశాత్తు చాలా ఉంది
ఇక్కడ నిబంధనలు మళ్ళీ యొక్క.

1043
00:46:06,720 --> 00:46:07,660
ఈ కేవలం ఒక సంఖ్య.

1044
00:46:07,660 --> 00:46:09,040
సో ఈ మూడు మాట్లాడుతూ వంటిది.

1045
00:46:09,040 --> 00:46:11,430
తరగతి నేను కోరుకున్న ఏమి ఉంది
వేరియబుల్ కాల్.

1046
00:46:11,430 --> 00:46:12,840
నేను విద్యార్థులు పిలవగలరు.

1047
00:46:12,840 --> 00:46:15,880
అయితే తరగతి, ఈ ఒక ఒక తరగతి కాదు
ఆబ్జెక్ట్ ఓరియంటెడ్ జావా రకమైన మార్గం.

1048
00:46:15,880 --> 00:46:17,220
ఇది కేవలం విద్యార్ధులు ఒక తరగతి యొక్క.

1049
00:46:17,220 --> 00:46:20,590
మరియు ప్రతి మూలకం యొక్క డేటా రకం
ఆ శ్రేణి లో విద్యార్థి.

1050
00:46:20,590 --> 00:46:23,040
సో ఈ కొద్దిగా భిన్నంగా ఉంటుంది
మరియు ఏదో విధంగా నుండి

1051
00:46:23,040 --> 00:46:25,250
ఈ వంటి, అది కేవలం వార్తలు -

1052
00:46:25,250 --> 00:46:29,500
నేను మూడు విద్యార్థులు ఇవ్వాలని మాట్లాడుతూ వెబ్
మరియు ఆ శ్రేణి తరగతి కాల్.

1053
00:46:29,500 --> 00:46:29,800
>> అన్ని కుడి.

1054
00:46:29,800 --> 00:46:30,680
ఇప్పుడు ఇక్కడ ఒక నాలుగు లూప్ యొక్క.

1055
00:46:30,680 --> 00:46:33,480
ఈ వ్యక్తి యొక్క తెలిసిన - iterate
మీద సున్నా నుంచి మూడు.

1056
00:46:33,480 --> 00:46:35,160
మరియు ఇక్కడ సింటెక్స్ కొత్త ముక్క యొక్క.

1057
00:46:35,160 --> 00:46:37,710
కార్యక్రమం, నాకు ప్రాంప్ట్ అవకాశముంది
అది ఒక విద్యార్థి ఇవ్వాలని మానవ,

1058
00:46:37,710 --> 00:46:39,200
ఒక Int ఇది ID.

1059
00:46:39,200 --> 00:46:44,650
మరియు ఇక్కడ మీరు చేయవచ్చు సింటాక్స్ వార్తలు
వద్ద ID రంగంలో ఏదో నిల్వ

1060
00:46:44,650 --> 00:46:48,630
నగర తరగతి బ్రాకెట్ I. సో
ఈ సింటాక్స్ కొత్త కాదు.

1061
00:46:48,630 --> 00:46:51,450
ఈ నాకు ఎనిమిదవ ఇవ్వాలని అర్థం
తరగతి విద్యార్థి.

1062
00:46:51,450 --> 00:46:52,940
కానీ ఈ చిహ్నం కొత్తది.

1063
00:46:52,940 --> 00:46:56,320
అప్ ఇప్పుడు వరకు, మేము, డాట్ ఉపయోగిస్తారు కాదు చేసిన
ఈ వంటి కనీసం లో కోడ్.

1064
00:46:56,320 --> 00:47:01,490
ఈ సాధనంగా తెలిసిన struct వెళ్ళండి
ఒక విద్యార్థి మరియు అక్కడ ఏదో చాలు.

1065
00:47:01,490 --> 00:47:05,670
అదేవిధంగా, ఈ తదుపరి లైన్ లో, 31, వెళ్ళి
ముందుకు మరియు చాలు సంసార యూజర్ రకాల

1066
00:47:05,670 --> 00:47:10,530
ఇక్కడ ఒక పేరు కోసం మరియు అవి ఏమి ఒక కోసం చేయండి
ఇల్లు, అదే విషయం, ముందుకు వెళ్ళి,

1067
00:47:10,530 --> 00:47:13,230
. ఇంట్లో అది చాలు.

1068
00:47:13,230 --> 00:47:15,955
>> సో ఈ కార్యక్రమం దేనిని
ఆ విధంగా?

1069
00:47:15,955 --> 00:47:17,220
మీరు అక్కడ ఒక చిన్న టీజర్ చూడగలరు.

1070
00:47:17,220 --> 00:47:24,780
నాకు ముందుకు వెళ్లి structs 0 తయారు చెయ్యాలి లెట్
డాట్ స్లాష్ struct 0, విద్యార్థి యొక్క ID 1,

1071
00:47:24,780 --> 00:47:28,250
డేవిడ్ మాథుర్, విద్యార్థి ID 2 చెప్పటానికి.

1072
00:47:28,250 --> 00:47:32,070
రాబ్ కిర్క్ల్యాండ్, విద్యార్థి ID 3.

1073
00:47:32,070 --> 00:47:35,010
లారెన్ Leverit -

1074
00:47:35,010 --> 00:47:38,380
మరియు ఈ ప్రోగ్రామ్ చేసిన మాత్రమే విషయం,
ఇది, కేవలం పూర్తిగా ఏకపక్షంగా ఉంది

1075
00:47:38,380 --> 00:47:40,980
నేను, ఈ సమాచారం ఆహా
నేను ఎలా మాకు నేర్పించారు ఇప్పుడు ఆ

1076
00:47:40,980 --> 00:47:43,450
structs ఉపయోగించడానికి, నేను కలిగి ఉంది
ఇక్కడ ఈ అదనపు లూప్.

1077
00:47:43,450 --> 00:47:45,260
నేను విద్యార్థులు శ్రేణి పైగా iterate.

1078
00:47:45,260 --> 00:47:49,170
నేను మా, బహుశా ఇప్పుడు తెలిసిన స్నేహితుడు, ఉపయోగిస్తారు
పదబంధానికి, stircomp సరిపోల్చండి

1079
00:47:49,170 --> 00:47:53,780
చెక్ 8 విద్యార్థి యొక్క హౌస్ ఉంది
మాథుర్ సమానంగా?

1080
00:47:53,780 --> 00:47:56,760
మరియు కనుక కేవలం ఏదో ప్రింట్
ఏకపక్ష ఇష్టం, అవును, అది ఉంది.

1081
00:47:56,760 --> 00:47:59,430
కానీ మళ్ళీ, కేవలం నాకు అవకాశాలు ఇవ్వడం
మరియు ఉపయోగించడానికి మరియు తిరిగి

1082
00:47:59,430 --> 00:48:02,270
ఈ కొత్త డాట్ సంజ్ఞామానం తిరిగి.

1083
00:48:02,270 --> 00:48:03,250
>> సో ఎవరు కుడి, పట్టించుకుంటారు?

1084
00:48:03,250 --> 00:48:06,270
ఒక విద్యార్థి ప్రోగ్రామ్ వస్తోంది
కొంతవరకు అనియత, కానీ దాన్ని మారుతుంది

1085
00:48:06,270 --> 00:48:09,800
మేము ఉపయోగకరమైన పనులు చేయగలనని
ఈ ఉదాహరణకు క్రింది.

1086
00:48:09,800 --> 00:48:14,600
ఈ ఒక చాలా సంక్లిష్టంగా struct ఉంది
సి లో ఇది ఒక డజను లేదా మరింత ఖాళీలను సంపాదించి

1087
00:48:14,600 --> 00:48:15,880
కొంతవరకు నిగూఢమైన పేరు.

1088
00:48:15,880 --> 00:48:20,110
కానీ మీరు ఎప్పుడూ ఒక గ్రాఫిక్స్ విన్న చేసిన ఉంటే
బిట్మ్యాప్ అని ఫైల్ ఫార్మాట్, BMP, అది

1089
00:48:20,110 --> 00:48:22,830
హాజరవుతారు ఆ బిట్మ్యాప్ ఫైల్ ఫార్మాట్
అందంగా చాలా ఇది కనిపిస్తుంది.

1090
00:48:22,830 --> 00:48:24,200
ఇది ఒక పెద్ద చిన్న నవ్వుతున్న ముఖం యొక్క.

1091
00:48:24,200 --> 00:48:27,840
ఇది నేను జూమ్ చేసిన ఒక చిన్న చిత్రం యొక్క
అందంగా పెద్ద నేను ప్రతి చూడగలిగిన కాబట్టి

1092
00:48:27,840 --> 00:48:30,410
వ్యక్తిగత చుక్కలు లేదా పిక్సెల్.

1093
00:48:30,410 --> 00:48:33,800
మేము ఒక సూచిస్తుంది ఇప్పుడు, అది మారుతుంది
సంఖ్య 0, చెప్పటానికి, నల్లని డాట్.

1094
00:48:33,800 --> 00:48:35,520
సంఖ్య 1 తో మరియు ఒక తెల్లని డాట్.

1095
00:48:35,520 --> 00:48:39,140
>> సో ఇతర పదాలు లో, మీకు కావలసిన ఒక డ్రా
నవ్వుతున్న ముఖం మరియు ఒక లో చిత్రం సేవ్

1096
00:48:39,140 --> 00:48:42,680
కంప్యూటర్, ఇది సున్నాలు నిల్వ మరియు సంతృప్తి పరుస్తుంది
ఇలా వాటిని, పేరు,

1097
00:48:42,680 --> 00:48:45,250
మళ్ళీ, వాటిని తెలుపు
మరియు సున్నాలు నలుపు.

1098
00:48:45,250 --> 00:48:48,290
మరియు కలిసి, మీరు సమర్థవంతంగా ఉంటే
వాటిని మరియు సున్నాలు యొక్క పట్టీతో గట్టిగా చుట్టు ఒక, మీరు ఒక కలిగి

1099
00:48:48,290 --> 00:48:51,030
పిక్సెల్ గ్రిడ్, మరియు మీరు లే ఉంటే
వాటిని, మీరు ఒక అందమైన కలిగి

1100
00:48:51,030 --> 00:48:52,560
కొద్దిగా నవ్వుతున్న ముఖం.

1101
00:48:52,560 --> 00:48:58,150
ఇప్పుడు, బిట్మ్యాప్ ఫైల్ ఫార్మాట్, BMP, ఉంది
ప్రభావవంతమైన హుడ్ కింద,

1102
00:48:58,150 --> 00:49:00,970
కానీ మరింత పిక్సెళ్ళు SOT తో మీరు
నిజానికి రంగులు సూచిస్తుంది.

1103
00:49:00,970 --> 00:49:05,170
>> కానీ మీరు మరింత ఆధునిక ఉన్నప్పుడు
BMP మరియు JPEG మరియు GIF వంటి ఫైల్ ఫార్మాట్లు

1104
00:49:05,170 --> 00:49:09,360
ఇది మీకు, ఆ పరిచయం కావచ్చు
డిస్కులో ఫైళ్లు సాధారణంగా మాత్రమే

1105
00:49:09,360 --> 00:49:13,760
సున్నాలు మరియు పిక్సెళ్ళు కోసం వాటిని కలిగి, కానీ
వారు అలాగే కొన్ని మెటాడేటా కలిగి -

1106
00:49:13,760 --> 00:49:16,960
నిజంగా కాదు అర్థంలో మెటా
డేటా కానీ కలిగి ఉపయోగం.

1107
00:49:16,960 --> 00:49:21,370
ఇక్కడ ఈ ఖాళీలను విధిస్తుంది మరియు
మేము P సెట్ల మరింత వివరంగా ఈ చూస్తారు

1108
00:49:21,370 --> 00:49:25,810
5, ఆ సున్నాలు మరియు వాటిని ముందు
, ఒక చిత్రం లో పిక్సెళ్ళు ప్రాతినిధ్యం

1109
00:49:25,810 --> 00:49:29,110
మెటాడేటా యొక్క ఒక సమూహం వలె ఉంది
చిత్రం యొక్క పరిమాణాన్ని మరియు

1110
00:49:29,110 --> 00:49:30,250
చిత్రం యొక్క వెడల్పు.

1111
00:49:30,250 --> 00:49:32,910
మరియు నేను కొన్ని ఆఫ్ plucking వెబ్ గమనించవచ్చు
ఇక్కడ అనియత విషయాలు -

1112
00:49:32,910 --> 00:49:34,260
వెడల్పు మరియు ఎత్తు.

1113
00:49:34,260 --> 00:49:36,160
బిట్ లెక్కించటం కొన్ని ఇతర విషయాలు.

1114
00:49:36,160 --> 00:49:37,840
సో ఒక ఫైల్ లో కొన్ని మెటాడేటా లేదు.

1115
00:49:37,840 --> 00:49:41,470
>> కానీ ఫైళ్లు వేశాడు ఎలా అర్థం చేసుకోవడానికి
ఈ విధంగా, మీరు వాస్తవానికి

1116
00:49:41,470 --> 00:49:45,890
అప్పుడు చిత్రాలు మార్చటానికి, చిత్రాలు తిరిగి
డిస్కు నుండి, చిత్రాలు పరిమాణాన్ని.

1117
00:49:45,890 --> 00:49:47,560
కానీ మీరు తప్పనిసరిగా కాదు
వాటిని విస్తరించేందుకు.

1118
00:49:47,560 --> 00:49:48,480
నేను ఒక ఫోటో అవసరమైన.

1119
00:49:48,480 --> 00:49:52,840
నేను మీరు చూసిన, ఇక్కడ RJ తిరిగి వెళ్ళింది
కొంతకాలంగా క్రితం తెరపై.

1120
00:49:52,840 --> 00:49:57,160
నేను ఇక్కడ కీనోట్ తెరుచుకుంటుంది ఉంటే, ఈ ఉంది
మీరు జూమ్ ప్రయత్నించండి ఉంటే జరుగుతుంది మరియు

1121
00:49:57,160 --> 00:49:59,380
RJ విస్తరించేందుకు.

1122
00:49:59,380 --> 00:50:01,480
అతను నిజంగా ఏ మెరుగుపడుతున్నాయి కాదు.

1123
00:50:01,480 --> 00:50:06,240
ఇప్పుడు కీనోట్ అది ఒక గొడవ రకం
కొద్దిగా, కేవలం వ్యాఖ్యానం కు

1124
00:50:06,240 --> 00:50:11,040
RJ ముఖ్యంగా పొందుటకు లేదు వాస్తవం
మీరు సైన్ జూమ్ చేసినప్పుడు మెరుగైన

1125
00:50:11,040 --> 00:50:13,310
మరియు అది ఈ విధంగా లేకపోతే,
చతురస్రాలు చూడండి?

1126
00:50:13,310 --> 00:50:15,490
అవును, మీరు ఖచ్చితంగా చూడవచ్చు
ఒక ప్రాజెక్టర్లో చతురస్రాలు.

1127
00:50:15,490 --> 00:50:17,690
>> మీరు విస్తరించేందుకు మీరు పొందుటకు ఏమిటి.

1128
00:50:17,690 --> 00:50:22,570
కానీ అర్థం చేసుకోవడానికి మా RJ లేదా
నవ్వుతున్న ముఖం అమలు మాకు అనుమతిస్తుంది

1129
00:50:22,570 --> 00:50:24,950
నిజానికి మార్పు కోడ్ వ్రాయడానికి
ఈ విషయాలు.

1130
00:50:24,950 --> 00:50:29,970
మరియు నేను, నేను ఈ నోట్ న అంతం ఇష్టం ఆలోచన
ఒక 55 సెకన్ల, ఆ విస్తరించేందుకు

1131
00:50:29,970 --> 00:50:31,230
నేను కాకుండా తప్పుదోవ పట్టించే చెప్పటానికి, ధైర్యం.

1132
00:50:31,230 --> 00:50:32,990
>> [వీడియో ప్లేబ్యాక్]

1133
00:50:32,990 --> 00:50:34,790
>> -అతను అబద్ధం యొక్క.

1134
00:50:34,790 --> 00:50:38,310
ఏమి గురించి, నాకు తెలీదు.

1135
00:50:38,310 --> 00:50:41,200
>> -కనుక మనం ఏమి తెలుసు?

1136
00:50:41,200 --> 00:50:45,280
>> -ఆ 9:15 రే Santoya వద్ద
ATM వద్ద ఉంది.

1137
00:50:45,280 --> 00:50:47,830
>> -సో ప్రశ్న ఏమిటి
అతను 9:16 వద్ద చేస్తున్న?

1138
00:50:47,830 --> 00:50:50,750
>> షూటింగ్ తొమ్మిది మిల్లీ
ఏదో వద్ద.

1139
00:50:50,750 --> 00:50:52,615
అతను స్నిపర్ చూసింది.

1140
00:50:52,615 --> 00:50:54,760
>> లేదా అతనితో పని.

1141
00:50:54,760 --> 00:50:56,120
>> -వేచి.

1142
00:50:56,120 --> 00:50:57,450
ఒక తిరిగి వెళ్ళు.

1143
00:50:57,450 --> 00:50:58,700
>> దాన్ని మీరు చూస్తారు?

1144
00:50:58,700 --> 00:51:05,530

1145
00:51:05,530 --> 00:51:09,490
>> , పూర్తి స్క్రీన్ తన ముఖాన్ని-తీసుకురండి.

1146
00:51:09,490 --> 00:51:09,790
>> -అతని అద్దాలు.

1147
00:51:09,790 --> 00:51:11,040
>> -ఉన్నాయి ప్రతిబింబం యొక్క.

1148
00:51:11,040 --> 00:51:21,790

1149
00:51:21,790 --> 00:51:23,520
>> -ఆ Neuvitas బేస్బాల్ జట్టు.

1150
00:51:23,520 --> 00:51:24,530
వారి చిహ్నం యొక్క.

1151
00:51:24,530 --> 00:51:27,040
>> మరియు అతను ఎవరైతే అతడ్ని మాట్లాడుతున్నారా లో
ఆ జాకెట్ ధరించి.

1152
00:51:27,040 --> 00:51:27,530
>> [END వీడియో ప్లేబ్యాక్]

1153
00:51:27,530 --> 00:51:29,180
>> డేవిడ్ J. మలన్: ఈ అవుతుంది
సమస్య సెట్ 5 ఉంటుంది.

1154
00:51:29,180 --> 00:51:30,720
వచ్చే వారం మీరు చూస్తారు.

1155
00:51:30,720 --> 00:51:32,330
>> MALE చూడండి: తదుపరి CS50 వద్ద.

1156
00:51:32,330 --> 00:51:39,240
>> [క్రికెట్ కిచకిచలు]

1157
00:51:39,240 --> 00:51:41,270
>> [సంగీతాన్ని]