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

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

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

4
00:00:08,920 --> 00:00:13,350
మీరు అబ్బాయిలు ఆ తెలియదు సందర్భంలో మేము ఒక క్విజ్ రేపు ఉన్నాయి.

5
00:00:14,810 --> 00:00:20,970
మీరు క్లాస్ లో చూసిన ఉండవచ్చు లేదా తరగతి చూడవచ్చు వుండాలి అన్నింటికీ ప్రధానంగా ఉంది.

6
00:00:20,970 --> 00:00:26,360
వారు చాలా ఇటీవల విషయం ఉన్నప్పటికీ, గమనికలు ఉన్నాయి.

7
00:00:26,360 --> 00:00:29,860
మీరు కనీసం వాటిని అధిక స్థాయిలో అర్థం చేసుకోవాలి.

8
00:00:29,860 --> 00:00:34,760
మీరు క్విజ్ అర్థం ఉండాలి తరగతి లో చనిపోయాడన్న విషయం ఏదైనా.

9
00:00:34,760 --> 00:00:37,320
మీరు వాటిని ప్రశ్నలు ఉంటే, మీకు వాటిని ఇప్పుడు అడగవచ్చు.

10
00:00:37,320 --> 00:00:43,280
మీరు అబ్బాయిలు ప్రశ్నలు అడగండి ఇలా, ఒక విద్యార్థి నేతృత్వంలోని చాలా సెషన్ అని అన్నారు

11
00:00:43,280 --> 00:00:45,060
కాబట్టి ఆశాజనక ప్రజలు ప్రశ్నలు.

12
00:00:45,060 --> 00:00:48,020
ఎవరైనా ప్రశ్నలు ఉందా?

13
00:00:49,770 --> 00:00:52,090
అవును. >> [విద్యార్థి] మీరు గమనికలు విషయంలో వెళ్ళే?

14
00:00:52,090 --> 00:00:54,350
నేను గమనికలు వెళ్ళి చేస్తాము.

15
00:00:54,350 --> 00:00:59,180
మీ వేరియబుల్స్ యొక్క అన్ని తప్పనిసరిగా మెమరీ నివసిస్తున్నారు

16
00:00:59,180 --> 00:01:04,450
కానీ సాధారణంగా దాని గురించి ఆందోళన చెందకండి మరియు మీరు x + 2 మరియు y + 3 సే

17
00:01:04,450 --> 00:01:07,080
మరియు కంపైలర్ విషయాలు మీరు నివసిస్తున్న ఇక్కడ గుర్తించడానికి చేస్తుంది.

18
00:01:07,080 --> 00:01:12,990
మీరు ఇప్పుడు మీరు స్పష్టంగా ఆ మెమరీ చిరునామాలను ఉపయోగించే, గమనికలు వ్యవహరించే చేస్తున్నారు.

19
00:01:12,990 --> 00:01:19,800
కాబట్టి ఒక వేరియబుల్ మాత్రమే ఎప్పుడూ ఏ సమయంలో ఒకే చిరునామా వద్ద నివసిస్తున్నారు కనిపిస్తుంది.

20
00:01:19,800 --> 00:01:24,040
మేము ఒక పాయింటర్ డిక్లేర్ చెయ్యడానికి, ఏ రకం లాగా ఉండబోతుంది?

21
00:01:24,040 --> 00:01:26,210
>> నేను ఒక పాయింటర్ p ప్రకటించాలని కావలసిన. ఏ రకం లాగా లేదు?

22
00:01:26,210 --> 00:01:33,530
[విద్యార్థి] Int * p. >> అవును. కాబట్టి Int * p.

23
00:01:33,530 --> 00:01:38,030
మరియు నేను దానిని ఎలా x సూచించడానికి సంపాదిస్తారు? >> [విద్యార్థి] ఎమ్పారసన్డ్.

24
00:01:40,540 --> 00:01:45,300
[బౌడెన్] కాబట్టి ఆంపర్సండ్ చిహ్నం అక్షరాలా ఆపరేటర్లు చిరునామా అని పిలుస్తారు.

25
00:01:45,300 --> 00:01:50,460
కాబట్టి నేను & చేసినప్పుడు x అది చరరాశి X యొక్క మెమరీ చిరునామా సంతరించుకోనుంది.

26
00:01:50,460 --> 00:01:56,790
కాబట్టి ఇప్పుడు నేను పాయింటర్ p కలిగి, ఎక్కడైనా నా కోడ్ లో నేను * p ఉపయోగించవచ్చు

27
00:01:56,790 --> 00:02:02,960
లేదా నేను x ఉపయోగించవచ్చు మరియు ఇది ఖచ్చితమైన విషయం ఉంటుంది.

28
00:02:02,960 --> 00:02:09,520
(* P). ఈ ఏమి ఉంది? ఆ స్టార్ శతకము

29
00:02:09,520 --> 00:02:13,120
[విద్యార్థి] ఇది ఆ సమయంలో ఒక విలువ అర్థం. >> అవును.

30
00:02:13,120 --> 00:02:17,590
మేము దాన్ని చూస్తే కనుక, డయాగ్రమ్స్ అవుట్ డ్రా చాలా ఉపయోగపడుతుంది

31
00:02:17,590 --> 00:02:22,230
ఈ విలువ 4 ఉంటాయి, ఇది x కోసం మెమరీ చిన్న పెట్టెలో, ఇక్కడ

32
00:02:22,230 --> 00:02:25,980
అప్పుడు మేము, p కోసం మెమరీ కొద్దిగా బాక్స్

33
00:02:25,980 --> 00:02:31,590
అందువలన x కు p పాయింట్లు, కాబట్టి మేము p నుండి x ఒక బాణం డ్రా.

34
00:02:31,590 --> 00:02:40,270
కాబట్టి మేము చెప్పినప్పుడు మీరు * p మేము p అని బాక్స్ వెళ్ళండి చెబుతున్న దాన్ని.

35
00:02:40,270 --> 00:02:46,480
స్టార్ బాణం అనుసరించండి మరియు మీరు అక్కడే ఆ బాక్స్ తో అనుకుంటున్నారు ఏ.

36
00:02:46,480 --> 00:03:01,090
నేను * p = 7 చెప్పగలదు మరియు ఆ x మరియు 7 మార్పు అని బాక్స్ వెళతారు.

37
00:03:01,090 --> 00:03:13,540
లేదా నేను కాలేదు Int z = * p * 2; కంగారు అదే ఇది యొక్క నక్షత్రం, నక్షత్రం ఎందుకంటే.

38
00:03:13,540 --> 00:03:19,230
ఒక స్టార్ p dereferencing ఉంది, ఇతర స్టార్ 2 గుణించడం ఉంది.

39
00:03:19,230 --> 00:03:26,780
నేను అలాగే x తో * p భర్తీ కాలేదు గమనించండి.

40
00:03:26,780 --> 00:03:29,430
మీరు ఇదే విధంగా వాటిని ఉపయోగించవచ్చు.

41
00:03:29,430 --> 00:03:38,000
తర్వాత నేను పూర్తిగా కొత్త విషయాల p పాయింట్ కలిగి ఉంటాయి.

42
00:03:38,000 --> 00:03:42,190
నేను చెప్పగలను p = &z;

43
00:03:42,190 --> 00:03:44,940
కాబట్టి ఇప్పుడు x ఇకపై పాయింట్లు P ఇది z సూచిస్తుంది.

44
00:03:44,940 --> 00:03:50,510
నేను * p చేసే ఏ సమయంలో అది z చేయడం వంటి సేమ్.

45
00:03:50,510 --> 00:03:56,170
మేము విధులు వెళ్ళడం ప్రారంభించిన తర్వాత ఈ ఉపయోగకరమైన విషయం.

46
00:03:56,170 --> 00:03:59,790
>> ఇది ఏదో ఆ పాయింట్లు పాయింటర్ ప్రకటించాలని పనికిరాని రకంగా

47
00:03:59,790 --> 00:04:03,140
మరియు తర్వాత మీరు దాన్ని dereferencing చేస్తున్నారు

48
00:04:03,140 --> 00:04:06,060
మీరు ప్రారంభించడానికి అసలు వేరియబుల్ ఉపయోగించారు లేనప్పటికీ.

49
00:04:06,060 --> 00:04:18,190
కానీ మీరు విధులు లోకి వచ్చినప్పుడు - కాబట్టి, మేము యొక్క కొన్ని ఫంక్షన్, Int foo కలిగి అని పిలవబడు

50
00:04:18,190 --> 00:04:32,810
ఒక పాయింటర్ తీసుకుని కేవలం * p = 6 చేస్తుంది;

51
00:04:32,810 --> 00:04:39,990
మేము స్వాప్ తో ముందు చూసిన వలె, మీరు సమర్థవంతమైన swap మరియు ఒక ప్రత్యేక చర్య చేయలేను

52
00:04:39,990 --> 00:04:45,180
సి లో ప్రతిదీ ఎల్లప్పుడూ విలువ ద్వారా ప్రయాణిస్తున్న ఎందుకంటే కేవలం పూర్ణ ప్రసరించటం ద్వారా.

53
00:04:45,180 --> 00:04:48,360
మీరు గమనికలు ప్రయాణిస్తున్న ఉన్నప్పటికీ మీరు విలువ ద్వారా ప్రయాణిస్తున్న చేస్తున్నారు.

54
00:04:48,360 --> 00:04:51,940
ఇది కేవలం కాబట్టి ఆ విలువలు మెమరీ చిరునామాలు ఇలా జరిగింది.

55
00:04:51,940 --> 00:05:00,770
అప్పుడు నేను foo (p); నేను ఫంక్షన్ foo లోకి పాయింటర్ ప్రయాణిస్తున్న నేను

56
00:05:00,770 --> 00:05:03,910
ఆపై foo * p = 6 చేస్తున్న;

57
00:05:03,910 --> 00:05:08,600
లోపల ఆ ఫంక్షన్ యొక్క కాబట్టి, * p, ఇప్పటికీ x సమానం

58
00:05:08,600 --> 00:05:12,720
ఆ ఫంక్షన్ లో దర్శిని గల కాదు ఎందుకంటే కాని నేను ఆ ఫంక్షన్ యొక్క లోపల x ఉపయోగించలేరు.

59
00:05:12,720 --> 00:05:19,510
కాబట్టి * p = 6 నేను మరొక ఫంక్షన్ స్థానిక వేరియబుల్ యాక్సెస్ చేయవచ్చు మాత్రమే మార్గం.

60
00:05:19,510 --> 00:05:23,600
లేదా, బాగా, గమనికలు నేను మరొక ఫంక్షన్ స్థానిక వేరియబుల్ యాక్సెస్ చేయవచ్చు మాత్రమే మార్గం.

61
00:05:23,600 --> 00:05:31,600
[విద్యార్థి] మీరు ఒక పాయింటర్ తిరిగి కోరారు చెప్పారు. మీరు ఎలా సరిగ్గా ఆ చేయాలి?

62
00:05:31,600 --> 00:05:44,270
[బౌడెన్] Int y = 3 లో లాగ ఒక పాయింటర్ చూపించు; తిరిగి & పీ? >> [విద్యార్థి] అవును.

63
00:05:44,270 --> 00:05:48,480
[బౌడెన్] సరే. మీరు దీన్ని ఎప్పుడూ. ఈ తప్పు.

64
00:05:48,480 --> 00:05:59,480
నేను ఈ ఉపన్యాసం స్లయిడ్లను చూసిన అనుకుంటున్నాను మీరు మెమరీ ఈ మొత్తం రేఖాచిత్రం చూసిన మొదలు

65
00:05:59,480 --> 00:06:02,880
ఎక్కడ ఇక్కడ మీరు మెమరీ చిరునామా 0 పొందారు

66
00:06:02,880 --> 00:06:09,550
మరియు డౌన్ ఇక్కడ మీరు 32 మెమరీ చిరునామా 4 వేదికలను లేదా 2 ఉన్నాయి.

67
00:06:09,550 --> 00:06:15,120
కాబట్టి మీరు కొన్ని విషయాలను మరియు కొన్ని అంశాలను పొందారు మరియు మీ స్టాక్ కలిగి

68
00:06:15,120 --> 00:06:21,780
మరియు మీరు కేవలం పెరుగుతూ గురించి నేర్చుకోవడం ప్రారంభించింది మీ కుప్ప, పొందారు.

69
00:06:21,780 --> 00:06:24,390
[విద్యార్థి] స్టాక్ పై కుప్ప కదా?

70
00:06:24,390 --> 00:06:27,760
>> అవును. కుప్ప మీద, ఇది? >> [విద్యార్థి] Well, అతను పైన 0 ఉంచండి.

71
00:06:27,760 --> 00:06:30,320
[విద్యార్థి] ఓహ్, అతను పైన 0 ఉంచండి. >> [విద్యార్థి] ఓహ్, ఓకే.

72
00:06:30,320 --> 00:06:36,060
నిభంధనలు: ఎనీవేర్ CS50 మీకు ఈ విధంగా చూడండి చూడాలని. >> [విద్యార్థి] సరే.

73
00:06:36,060 --> 00:06:40,290
ఇది కేవలం ఆ మీరు మొదటి, స్టాక్స్ చూసిన చేసినప్పుడు

74
00:06:40,290 --> 00:06:45,000
మీరు మరొక పైన విషయాలు స్టాకింగ్ యొక్క భావించే స్టాక్ గురించి ఆలోచించినప్పుడు ఇష్టం.

75
00:06:45,000 --> 00:06:50,810
కాబట్టి మేము స్టాక్ ఒక స్టాక్ సాధారణ వంటి పెరుగుతూ ఉంటుంది చుట్టూ ఈ కుదుపు ఉంటాయి

76
00:06:50,810 --> 00:06:55,940
బదులుగా స్టాక్ డౌన్ ఉరి. >> [విద్యార్థి] అయితే heaps సాంకేతికంగా చాలా స్థాయికి లేదా?

77
00:06:55,940 --> 00:07:01,100
ఇది స్థాయికి ద్వారా మీ ఉద్దేశ్యం ఏమిటి ఆధారపడి ఉంటుంది.

78
00:07:01,100 --> 00:07:04,010
స్టాక్ మరియు కుప్ప ఎల్లప్పుడూ వ్యతిరేక దిశలో పెరుగుతాయి.

79
00:07:04,010 --> 00:07:09,420
ఒక స్టాక్ ఎల్లప్పుడూ పెరగటాన్ని కోణంలో అప్ పెరుగుతోంది

80
00:07:09,420 --> 00:07:12,940
అధిక మెమరీ చిరునామాలు, మరియు కుప్ప డౌన్ పెరుగుతోంది వైపు

81
00:07:12,940 --> 00:07:17,260
అంటే ఇది తక్కువ మెమోరీ చిరునామాలను వైపు పెరగటాన్ని.

82
00:07:17,260 --> 00:07:20,250
కాబట్టి టాప్ 0 మరియు దిగువ ఉన్నత మెమరీ చిరునామాలను ఉంది.

83
00:07:20,250 --> 00:07:26,390
వారు కేవలం ఆదేశాలు వ్యతిరేకించడంలో, పెంచుకుంటున్నాం రెండు.

84
00:07:26,390 --> 00:07:29,230
[విద్యార్థి] మీరు అడుగున స్టాక్ ఉంచారు మాట్లాడుతూ నేను అర్థం

85
00:07:29,230 --> 00:07:33,640
ఇది స్టాక్ కోసం ఒక నిండుగా ఎగువన ప్రారంభించడానికి ఎందుకంటే మరింత స్పష్టమైన ఉంది, ఎందుకంటే

86
00:07:33,640 --> 00:07:37,520
కుప్ప, చాలా యొక్క పైన కాబట్టి that's ఉంది - >> అవును.

87
00:07:37,520 --> 00:07:44,960
మీరు కూడా స్టాక్ ఎక్కువగా పెరిగే మరియు పెద్ద వంటి కుప్ప యొక్క అనుకుంటున్నాను, కానీ.

88
00:07:44,960 --> 00:07:50,280
కాబట్టి స్టాక్ మేము రకమైన పెరుగుతూ చూపించడానికి కావలసిన ఒకటి.

89
00:07:50,280 --> 00:07:55,390
కానీ ప్రతిచోటా మీరు లేకపోతే చూడండి ఎగువన చిరునామా 0 చూపించడానికి అన్నారు

90
00:07:55,390 --> 00:07:59,590
మరియు దిగువన అత్యధిక మెమరీ చిరునామా, కాబట్టి ఈ మెమరీ మీ సాధారణ అభిప్రాయం.

91
00:07:59,590 --> 00:08:02,100
>> మీరు ఒక ప్రశ్న ఉందా?

92
00:08:02,100 --> 00:08:04,270
[విద్యార్థి] మీరు మాకు కుప్ప గురించి మరింత వివరంగా చెప్పగలరా?

93
00:08:04,270 --> 00:08:06,180
అవును. నేను రెండవ ఆ చూస్తారు.

94
00:08:06,180 --> 00:08:12,220
మొదటి, & పీ తిరిగి ఎందుకు తిరిగి వెళ్ళడం, ఒక చెడ్డ విషయం

95
00:08:12,220 --> 00:08:18,470
స్టాక్ మీద మీరు విధులను అన్ని సూచించే స్టాక్ ఫ్రేములు కొంత కలిగి

96
00:08:18,470 --> 00:08:20,460
ఇది పిలిచారు.

97
00:08:20,460 --> 00:08:27,990
మునుపటి విషయాలు విస్మరించి కాబట్టి, మీ స్టాక్ ఎగువ ఎల్లప్పుడూ ప్రధాన కార్యకలాపంగా అన్నారు

98
00:08:27,990 --> 00:08:33,090
ఆ అని చేయబడిన మొదటి చర్య యొక్క నుండి.

99
00:08:33,090 --> 00:08:37,130
ఆపై మీరు మరొక ఫంక్షన్ కాల్ చేసినప్పుడు, స్టాక్ డౌన్ పెరుగుతాయి అన్నారు.

100
00:08:37,130 --> 00:08:41,640
నేను కొన్ని ఫంక్షన్, foo, కాల్ మరియు ఇది తన స్వంత స్టాక్ ఫ్రేమ్ గెట్స్ అయితే,

101
00:08:41,640 --> 00:08:47,280
అది కొన్ని ఫంక్షన్, బార్ కాల్ చేయవచ్చు; తన స్వంత స్టాక్ ఫ్రేమ్ పొందుతాడు.

102
00:08:47,280 --> 00:08:49,840
మరియు, బార్ పునరావృత ఉంటుంది మరియు అది కూడా కాల్ కాలేదు

103
00:08:49,840 --> 00:08:54,150
అందువలన బార్ రెండో కాల్ తన సొంత స్టాక్ ఫ్రేమ్ పొందగలిగిన అని.

104
00:08:54,150 --> 00:08:58,880
కాబట్టి ఈ స్టాక్ ఫ్రేమ్లలో క్రియల స్థానిక వేరియబుల్స్ అన్ని

105
00:08:58,880 --> 00:09:03,450
మరియు ఆ ఫంక్షన్ వాదనలు -

106
00:09:03,450 --> 00:09:08,730
ఈ ఫంక్షన్ కు స్థానికంగా దర్శిని గల ఏ విషయాలు ఈ స్టాక్ ఫ్రేమ్లలో వెళ్ళండి.

107
00:09:08,730 --> 00:09:21,520
కాబట్టి, నేను బార్ లో లాగ ఒక ఫంక్షన్ ఉంది ఉన్నప్పుడు అర్థం

108
00:09:21,520 --> 00:09:29,270
నేను ఒక పూర్ణాంకం ప్రకటించి ఆ పూర్ణాంక ఒక పాయింటర్ తిరిగి వెళుతున్న.

109
00:09:29,270 --> 00:09:33,790
కాబట్టి Y పేరు వాడుకలో ఉంది?

110
00:09:33,790 --> 00:09:36,900
[విద్యార్థి] y బార్ లో నివసిస్తున్నారు. >> [బౌడెన్] అవును.

111
00:09:36,900 --> 00:09:45,010
ఎక్కడో మెమరీ ఈ చిన్న స్క్వేర్లో అది Y కలిగి littler కూడలి.

112
00:09:45,010 --> 00:09:53,370
నేను తిరిగి & పీ, నేను, మెమరీ ఈ చిన్న బ్లాక్ ఒక పాయింటర్ తిరిగి నేను.

113
00:09:53,370 --> 00:09:58,400
కానీ ఒక తిరిగి వచ్చే చర్యలు, దాని స్టాక్ ఫ్రేమ్ స్టాక్ ఆఫ్ popped తీర్చుకుంటాడు.

114
00:10:01,050 --> 00:10:03,530
ఇది స్టాక్ అని ఎందుకు మరియు ఆ.

115
00:10:03,530 --> 00:10:06,570
మీరు ఏ తెలిస్తే ఇది స్టాక్ డేటా నిర్మాణం వలె ఉంటుంది.

116
00:10:06,570 --> 00:10:11,580
లేదా ట్రేలు ఒక స్టాక్ వలె, ఎల్లప్పుడూ ఉదాహరణ

117
00:10:11,580 --> 00:10:16,060
ప్రధాన అడుగున వెళ్ళి అన్నారు, అప్పుడు మీరు కాల్ మొదటి చర్య, ఆ పైన వెళ్ళండి అన్నారు

118
00:10:16,060 --> 00:10:20,400
మీరు పిలుస్తారు అన్ని విధులు నుండి తిరిగి వరకు మరియు మీరు ప్రధాన తిరిగి పొందలేము

119
00:10:20,400 --> 00:10:22,340
అది పైన ఉంచారు.

120
00:10:22,340 --> 00:10:28,650
>> మీరు చేస్తే [విద్యార్థి] కాబట్టి & పీ, ఆ విలువ నోటీసు లేకుండా మార్చబడవచ్చు ఉంది తిరిగి.

121
00:10:28,650 --> 00:10:31,290
అవును, it's - >> ఇది భర్తీ అవుతుంది [విద్యార్థి]. >> అవును.

122
00:10:31,290 --> 00:10:34,660
మీరు ప్రయత్నించండి ఉంటే మరియు - పూర్తిగా ఉంది -

123
00:10:34,660 --> 00:10:38,040
అది ఒక పాయింటర్ తిరిగి ఎందుకంటే ఇది, ఒక పూర్ణాంకానికి * బార్ ఉంటుంది

124
00:10:38,040 --> 00:10:41,310
కాబట్టి తిరిగి టైప్ Int * ఉంది.

125
00:10:41,310 --> 00:10:46,500
మీరు ఈ చర్యను తిరిగి విలువ ఉపయోగించడానికి ప్రయత్నించండి, అది వివరింపబడని ప్రవర్తన యొక్క

126
00:10:46,500 --> 00:10:51,770
ఆ పాయింటర్ చెడ్డ జ్ఞాపకం పాయింతు ఎందుకంటే. >> [విద్యార్థి] సరే.

127
00:10:51,770 --> 00:11:01,250
సో వాట్ ఉంటే, ఉదాహరణకు, మీరు డిక్లేర్డ్ Int * Y = malloc (sizeof (Int))?

128
00:11:01,250 --> 00:11:03,740
ఆ మంచి పని. అవును.

129
00:11:03,740 --> 00:11:07,730
[విద్యార్థి] మేము మా రీసైకిల్ బిన్ విషయాలను డ్రాగ్ మేము ఎలా గురించి మాట్లాడారు

130
00:11:07,730 --> 00:11:11,750
వారు వాస్తవానికి మాసిపోయిన లేదు; మేము వారి గమనికలు కోల్పోతారు.

131
00:11:11,750 --> 00:11:15,550
కాబట్టి ఈ విషయంలో మేము దీన్ని మెమరీ ఇప్పటికీ అక్కడ విలువ వేయండి లేదా ఉంది లేదు?

132
00:11:15,550 --> 00:11:19,130
చాలా వరకు, అది ఇప్పటికీ అక్కడ చేస్తాడు.

133
00:11:19,130 --> 00:11:24,220
కానీ లెట్స్ మేము కొన్ని ఇతర చర్య, బాజ్ కాల్ జరిగే చెప్పారు.

134
00:11:24,220 --> 00:11:28,990
బాజ్ ఇక్కడ దాని స్వంత స్టాక్ ఫ్రేమ్ పొందడానికి అన్నారు.

135
00:11:28,990 --> 00:11:31,470
ఇది ఈ విషయాన్ని అన్ని తిరిగి రాయటం చేస్తాడు

136
00:11:31,470 --> 00:11:34,180
మరియు మీరు తర్వాత, మీరు ముందు వచ్చింది అని పాయింటర్ ప్రయత్నించండి మరియు ఉపయోగిస్తే

137
00:11:34,180 --> 00:11:35,570
ఒకే విలువ మాత్రం కాదు.

138
00:11:35,570 --> 00:11:38,150
మీరు ఫంక్షన్ బాజ్ అని ఎందుకంటే కేవలం మార్చిన చెప్పారు.

139
00:11:38,150 --> 00:11:43,080
[విద్యార్థి] కానీ మేము, మేము ఇప్పటికీ 3 పొందుతారు లేదు?

140
00:11:43,080 --> 00:11:44,990
[బౌడెన్] అన్ని సంభావ్యత లో, మీరు ఆ.

141
00:11:44,990 --> 00:11:49,670
కానీ మీరు ఆ నమ్మలేని. సి కేవలం వివరింపబడని ప్రవర్తన అన్నారు.

142
00:11:49,670 --> 00:11:51,920
>> [విద్యార్థి] ఓహ్, అది. సరే.

143
00:11:51,920 --> 00:11:58,190
Malloc ఉపయోగంలో వస్తుంది కాబట్టి మీరు ఒక పాయింటర్ తిరిగి ఉంటుంది, ఈ ఉంది.

144
00:12:00,930 --> 00:12:15,960
నిజానికి రాయడం నేను కేవలం malloc తిరిగి (3 * sizeof (Int)).

145
00:12:17,360 --> 00:12:24,050
మేము రెండవ మరింత malloc వెళ్ళి చేస్తాము, కానీ malloc యొక్క ఆలోచన మీ స్థానిక వేరియబుల్స్ యొక్క అన్ని

146
00:12:24,050 --> 00:12:26,760
ఎప్పుడూ స్టాక్ సాగుతుంది.

147
00:12:26,760 --> 00:12:31,570
Malloced చేసే ఏదైనా కుప్ప వెళ్లి, మరియు అది ఎప్పటికీ మరియు ఎల్లప్పుడూ నిండుగా ఉంటుంది

148
00:12:31,570 --> 00:12:34,490
మీరు స్పష్టంగా ఇది ఉచితం వరకు.

149
00:12:34,490 --> 00:12:42,130
కాబట్టి ఈ సమయంలో మీకు malloc ఏదో, అది తిరిగి వచ్చే చర్యలు తర్వాత మనుగడకు జరగబోతోంది అర్థం.

150
00:12:42,130 --> 00:12:46,800
ప్రోగ్రామ్ను అమలు ఆపి తర్వాత [విద్యార్థి] ఇది విల్ సర్వైవ్? >> నం

151
00:12:46,800 --> 00:12:53,180
సరే, ఈ కార్యక్రమం అన్ని మార్గం అమలు చేయబడుతుంది వరకు అక్కడ చేస్తాడు. >> అవును.

152
00:12:53,180 --> 00:12:57,510
మేము ప్రోగ్రామ్ను అమలు ఆపి ఏం వివరాలు మీద వెళ్ళవచ్చు.

153
00:12:57,510 --> 00:13:02,150
మీరు నన్ను గుర్తు అవసరం ఉండవచ్చు, కానీ ఆ పూర్తిగా వేరే విషయం.

154
00:13:02,150 --> 00:13:04,190
[విద్యార్థి] కాబట్టి malloc ఒక పాయింటర్ సృష్టిస్తుంది? >> అవును.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [విద్యార్థి] నేను malloc ఒక పాయింటర్ ఉపయోగించే మెమరీ బ్లాక్ అప్పగిస్తారు భావిస్తున్నాను.

156
00:13:15,400 --> 00:13:19,610
[బౌడెన్] నేను మళ్ళీ ఆ చిత్రం కావలసిన. >> [విద్యార్థి] ఈ పనిచేసినప్పటికీ, పనిచేస్తుంది?

157
00:13:19,610 --> 00:13:26,430
[విద్యార్థి] అవును, malloc మీరు ఉపయోగించే మెమరీ బ్లాక్ అప్పగిస్తారు,

158
00:13:26,430 --> 00:13:30,470
మరియు అప్పుడు ఆ మెమరీ మొదటి బ్లాక్ యొక్క చిరునామా తిరిగి.

159
00:13:30,470 --> 00:13:36,750
>> [బౌడెన్] అవును. కాబట్టి మీరు malloc, మీరు మెమరీ కొన్ని బ్లాక్ పట్టుకుని చేస్తున్నారు

160
00:13:36,750 --> 00:13:38,260
ఆ కుప్ప ప్రస్తుతం ఉంది.

161
00:13:38,260 --> 00:13:43,040
కుప్ప చాలా చిన్న ఉంటే, అప్పుడు కుప్ప కేవలం పెరగడం అంటే, మరియు ఈ దిశలో పెరుగుతుంది.

162
00:13:43,040 --> 00:13:44,650
కాబట్టి యొక్క కుప్ప చాలా తక్కువ అని పిలవబడు.

163
00:13:44,650 --> 00:13:49,960
అప్పుడు కొద్దిగా పెరుగుతాయి మరియు కేవలం పెరిగింది ఈ బ్లాక్ ఒక పాయింటర్ తిరిగి గురించి.

164
00:13:49,960 --> 00:13:55,130
మీరు ఉచిత స్టఫ్ మీరు కుప్ప మరింత గది చేస్తున్న సమయంలో,

165
00:13:55,130 --> 00:14:00,030
కాబట్టి తరువాత malloc పిలుపు మీరు గతంలో విడుదలైన అని ఆ స్మృతి తిరిగి చేయవచ్చు.

166
00:14:00,030 --> 00:14:09,950
malloc మరియు ఉచిత గురించి ముఖ్యమైన విషయం ఏమిటంటే, మీరు పూర్తి నియంత్రణ ఇస్తుంది ఉంది

167
00:14:09,950 --> 00:14:12,700
ఈ మెమరీ బ్లాక్లు యొక్క జీవితకాలంపై.

168
00:14:12,700 --> 00:14:15,420
గ్లోబల్ వేరియబుల్స్ ఎల్లప్పుడూ సజీవంగా ఉన్నాయి.

169
00:14:15,420 --> 00:14:18,500
స్థానిక వేరియబుల్స్ వాటి పరిధిలో జీవించి ఉన్నారు.

170
00:14:18,500 --> 00:14:22,140
వెంటనే మీకు ఒక వంకర కలుపు గత వెళ్ళి వంటి, స్థానిక వేరియబుల్స్ నాశనమయ్యాయి.

171
00:14:22,140 --> 00:14:28,890
మీరు జీవించి ఉన్నట్టు ఉంటుంది Malloced మెమరీ నిలిచి

172
00:14:28,890 --> 00:14:33,480
మీరు విడుదల చెప్పాలి ఉన్నప్పుడు మరియు తరువాత విడుదల.

173
00:14:33,480 --> 00:14:38,420
ఆ నిజంగా, నిజంగా మెమరీ మాత్రమే 3 రకాలు.

174
00:14:38,420 --> 00:14:41,840
స్టాక్ ఉంది ఆటోమేటిక్ స్మృతి నిర్వహణ, ఉన్నాయి.

175
00:14:41,840 --> 00:14:43,840
థింగ్స్ స్వయంచాలకంగా మీ కొరకు జరిగే.

176
00:14:43,840 --> 00:14:46,910
మీరు Int x చెప్పినప్పుడు మెమరీ Int x కోసం కేటాయించబడుతుంది.

177
00:14:46,910 --> 00:14:51,630
X స్కోప్ వస్తారు, మెమరీ x కోసం తిరిగి క్లెయిమ్.

178
00:14:51,630 --> 00:14:54,790
అప్పుడు డైనమిక్ మెమరీ నిర్వహణ, ఇది malloc అంటే ఏమిటి, అక్కడ

179
00:14:54,790 --> 00:14:56,740
మీరు కంట్రోల్ ఉన్నప్పుడు ఇది.

180
00:14:56,740 --> 00:15:01,290
మీరు డైనమిక్ మెమరీ మరియు కేటాయించబడుతుంది కూడదు వచ్చినపుడు నిర్ణయించుకుంటారు.

181
00:15:01,290 --> 00:15:05,050
మరియు తర్వాత స్థిరమైన ఉంది, ఇది దానిని ఎప్పటికీ నివసిస్తున్నారు అర్థం

182
00:15:05,050 --> 00:15:06,610
ఇది ప్రపంచ వేరియబుల్స్ ఏమిటో ఉంది.

183
00:15:06,610 --> 00:15:10,240
వారు మెమరీ కేవలం ఎప్పుడూ ఉన్నాము.

184
00:15:10,960 --> 00:15:12,760
>> ప్రశ్నలు?

185
00:15:14,490 --> 00:15:17,230
[విద్యార్థి] మీరు వంకర జంట కలుపులు ఉపయోగించి ఒక బ్లాక్ నిర్వచించలేదు

186
00:15:17,230 --> 00:15:21,220
కానీ అవసరం లేదు ఒక ప్రకటన లేదా వంటి అయితే ప్రకటన లేదా ఏదైనా ఉంటే?

187
00:15:21,220 --> 00:15:29,130
మీరు ఒక ఫంక్షన్ లో ఒక బ్లాక్ నిర్వచించే, కానీ అది చాలా వంకర జంట కలుపులు ఉంది.

188
00:15:29,130 --> 00:15:32,100
[విద్యార్థి] కాబట్టి మీరు మీ కోడ్ లో కర్లీ జంట కలుపులు ఒక అనిర్దిష్ట జత వంటి ఉండకూడదు

189
00:15:32,100 --> 00:15:35,680
స్థానిక వేరియబుల్స్ కలిగి? >> అవును, మీరు చెయ్యగలరు.

190
00:15:35,680 --> 00:15:45,900
Int బార్ లోపల మేము {Int y = 3;} ఉన్నాయి.

191
00:15:45,900 --> 00:15:48,440
కుడివైపు ఇక్కడ రావలసిన యొక్క.

192
00:15:48,440 --> 00:15:52,450
కానీ పూర్తిగా Int y యొక్క పరిధిని నిర్వచిస్తుంది.

193
00:15:52,450 --> 00:15:57,320
ఆ రెండవ వంకర కలుపు తరువాత, Y ఇకపై ఉపయోగించలేరు.

194
00:15:57,910 --> 00:16:00,630
మీరు అయితే, అలా ఎన్నడూ.

195
00:16:02,940 --> 00:16:07,370
, ఒక ప్రోగ్రామ్ ముగుస్తుంది ఏం తిరిగి పొందడం

196
00:16:07,370 --> 00:16:18,760
మేము విషయాలు సులభంగా చేయడానికి ఇచ్చే ఒక దురభిప్రాయం / సగం అబద్ధం రకం ఉంది.

197
00:16:18,760 --> 00:16:24,410
మీరు చెప్పే మీరు మెమరీని కేటాయించాల్సిన ఉన్నప్పుడు

198
00:16:24,410 --> 00:16:29,860
మీరు ఆ వేరియబుల్ కోసం RAM యొక్క కొన్ని భాగం కేటాయించడం చేస్తున్నారు.

199
00:16:29,860 --> 00:16:34,190
కానీ మీరు నిజంగా నేరుగా మీ కార్యక్రమాలలో ఎప్పుడూ RAM తాకడం లేదు.

200
00:16:34,190 --> 00:16:37,490
మీరు ఆలోచించి ఉంటే, ఎలా నేను డ్రూ -

201
00:16:37,490 --> 00:16:44,330
మీరు GDB లో ద్వారా వెళ్ళి ఉంటే వాస్తవానికి, మీరు ఇదే చూస్తారు.

202
00:16:51,120 --> 00:16:57,590
సంబంధం లేకుండా మీరు మీ ప్రోగ్రామ్ లేదా మీరు అమలు చేస్తున్నారు ఏ కార్యక్రమం, అమలు ఎన్ని సార్లు

203
00:16:57,590 --> 00:16:59,950
స్టాక్ ఎప్పుడూ మొదలు అన్నారు -

204
00:16:59,950 --> 00:17:06,510
మీరు ఎల్లప్పుడూ చిరునామా oxbffff ఏదో చుట్టూ వేరియబుల్స్ చూడండి చూడాలని.

205
00:17:06,510 --> 00:17:09,470
ఇది ఆ ప్రాంతంలో ఎక్కడో సాధారణంగా ఉంది.

206
00:17:09,470 --> 00:17:18,760
కానీ ఎలా 2 కార్యక్రమాలు బహుశా అదే స్మృతికి గమనికలు కలిగి ఉంటాయి?

207
00:17:20,640 --> 00:17:27,650
[విద్యార్థి] oxbfff RAM న రావలసిన కౌంటీ యొక్క స్వేచ్ఛా హోదా ఉంది

208
00:17:27,650 --> 00:17:31,320
వాస్తవానికి ఫంక్షన్ పిలిచినప్పుడు బట్టి వివిధ ప్రాంతాలలో ఉంటుంది.

209
00:17:31,320 --> 00:17:35,920
అవును. పదం కాల్పనిక స్మృతి ఉంది.

210
00:17:35,920 --> 00:17:42,250
ఆలోచన ప్రతి ప్రక్రియ, మీ కంప్యూటర్లో రన్ ప్రతి ఒక్క ప్రోగ్రామ్

211
00:17:42,250 --> 00:17:49,450
తన సొంత ఉంది - పూర్తిగా స్వతంత్ర చిరునామా స్థలం - లెట్స్ 32 బిట్స్ భావిస్తాయి.

212
00:17:49,450 --> 00:17:51,590
ఈ చిరునామా స్థలం.

213
00:17:51,590 --> 00:17:56,220
ఇది ఉపయోగించడానికి దాని స్వంత పూర్తిగా స్వతంత్ర 4 గిగాబైట్లు ఉంది.

214
00:17:56,220 --> 00:18:02,220
>> మీరు ఒకేసారి 2 ప్రోగ్రామ్లను అమలు చేస్తే, ఈ కార్యక్రమం దాని 4 గిగాబైట్లు చూస్తాడు

215
00:18:02,220 --> 00:18:04,870
ఈ కార్యక్రమం దాని 4 గిగాబైట్లు చూస్తాడు

216
00:18:04,870 --> 00:18:07,720
మరియు ఈ కార్యక్రమం కోసం dereference ఒక పాయింటర్ అసాధ్యం

217
00:18:07,720 --> 00:18:10,920
మరియు ఈ ప్రోగ్రామ్ నుంచి మెమరీ ముగిసేవి.

218
00:18:10,920 --> 00:18:18,200
మరియు కాల్పనిక స్మృతి ఒక ప్రక్రియలు చిరునామా స్థలం నుండి ఒక మాపింగ్ ఉంది

219
00:18:18,200 --> 00:18:20,470
RAM న అసలు విషయాలను.

220
00:18:20,470 --> 00:18:22,940
కాబట్టి అది మీకు మీ ఆపరేటింగ్ సిస్టమ్ ఇష్టం,

221
00:18:22,940 --> 00:18:28,080
హేయ్, ఈ వ్యక్తి dereferences పాయింటర్ oxbfff, ఆ నిజంగా అర్థం

222
00:18:28,080 --> 00:18:31,040
అతను RAM బైట్ 1000, కోరుకుంటున్నట్లు

223
00:18:31,040 --> 00:18:38,150
అయితే ఈ కార్యక్రమం dereferences oxbfff, అతను నిజంగా RAM బైట్ 10000 కోరుకుంటున్నారు.

224
00:18:38,150 --> 00:18:41,590
వారు అహేతుకంగా దూరంగా విడిగా ఉంటుంది.

225
00:18:41,590 --> 00:18:48,730
ఈ ఒక్క ప్రక్రియలు చిరునామా స్థలం లోపల విషయాలు కూడా వర్తిస్తుంది.

226
00:18:48,730 --> 00:18:54,770
కాబట్టి లాగా కూడా అన్ని 4 గిగాబైట్లు, అయితే అని పిలవబడు యొక్క -

227
00:18:54,770 --> 00:18:57,290
[విద్యార్థి] ప్రతి ప్రక్రియ లేదు -

228
00:18:57,290 --> 00:19:01,350
మీరు RAM యొక్క మాత్రమే 4 గిగాబైట్ల ఒక కంప్యూటర్ కలిగి చెప్పారు.

229
00:19:01,350 --> 00:19:06,430
ప్రతి ప్రక్రియ మొత్తం 4 గిగాబైట్లు చూడండి లేదు? >> అవును.

230
00:19:06,430 --> 00:19:13,060
కానీ అది చూసే 4 గిగాబైట్లు ఒక అబద్ధం ఉంది.

231
00:19:13,060 --> 00:19:20,460
ఇది కేవలం అది ఏ ఇతర ప్రక్రియ ఉంది తెలియని కారణంగా అది ఈ జ్ఞాపకం ఆలోచించడం మాత్రమే.

232
00:19:20,460 --> 00:19:28,140
నిజానికి అవసరం ఇది మాత్రమే మెమరీని ఉపయోగిస్తుంది.

233
00:19:28,140 --> 00:19:32,340
ఆపరేటింగ్ సిస్టమ్ ఈ ప్రక్రియ RAM ఇవ్వాలని వెళ్ళడం లేదు

234
00:19:32,340 --> 00:19:35,750
ఈ మొత్తం ప్రాంతంలో ఏ మెమరీ ఉపయోగించడం దాన్ని.

235
00:19:35,750 --> 00:19:39,300
ఇది ఆ ప్రాంతం కోసం మెమరీ ఇవ్వాలని మాత్రం కాదు.

236
00:19:39,300 --> 00:19:54,780
కానీ ఆలోచన ఉంది - నేను ఆలోచించడానికి దీనికై - నేను ఒక సారూప్యత భావిస్తారు కాదు.

237
00:19:54,780 --> 00:19:56,780
సారూప్యాలు కష్టం.

238
00:19:57,740 --> 00:20:02,700
వర్చ్యువల్ మెమొరీ సమస్యలలో ఒకటి లేదా పరిష్కరించడానికి యొక్క విషయాలు ఒక

239
00:20:02,700 --> 00:20:06,810
ప్రక్రియలు ఒకదానికొకటి పూర్తిగా తెలియదు ఉండాలని.

240
00:20:06,810 --> 00:20:12,140
మరియు మీరు ఏ కార్యక్రమం రాయడం కేవలం dereferences ఏ పాయింటర్,

241
00:20:12,140 --> 00:20:19,340
కేవలం, * (ox1234) అని ఒక ప్రోగ్రామ్ను రాయడం ఇష్టం

242
00:20:19,340 --> 00:20:22,890
మరియు యొక్క ఆ dereferencing మెమరీ చిరునామా 1234.

243
00:20:22,890 --> 00:20:28,870
>> కానీ అది ఏ 1234 అంటే అనువదించడానికి ఆపరేటింగ్ సిస్టమ్ ఇష్టం.

244
00:20:28,870 --> 00:20:33,960
అయితే 1234, ఈ ప్రక్రియ కోసం చెల్లుబాటు అయ్యే మెమరీ చిరునామా నిర్మాణము

245
00:20:33,960 --> 00:20:38,800
ఇది స్టాక్ లేదా ఏదైనా వలె, తర్వాత ఇది మెమరీ చిరునామా విలువ తిరిగి

246
00:20:38,800 --> 00:20:41,960
చాలా ప్రక్రియ తెలుసుకోవచ్చు.

247
00:20:41,960 --> 00:20:47,520
భూమి నిర్మాణము వంటి అయితే 1234, ఒక చెల్లని చిరునామా

248
00:20:47,520 --> 00:20:52,910
స్టాక్ మించిన ఇక్కడ మెమరీ కొన్ని చిన్న ముక్క లో మరియు కుప్ప దాటి

249
00:20:52,910 --> 00:20:57,200
మరియు మీరు నిజంగా మీరు segfaults వంటి వాటిని వచ్చిన ఆ, అప్పుడు ఆ ఉపయోగించలేదు

250
00:20:57,200 --> 00:21:00,260
మీరు తాకడం లేదు ఆ స్మృతి తాకడం అయినందున.

251
00:21:07,180 --> 00:21:09,340
ఈ కూడా వాస్తవం -

252
00:21:09,340 --> 00:21:15,440
ఒక 32-bit వ్యవస్థ, 32 బిట్స్ మీరు ఒక మెమరీ చిరునామా నిర్వచించడానికి 32 బిట్స్ కలిగివుంటాయి.

253
00:21:15,440 --> 00:21:22,970
లేదా 4 బైట్లు - గమనికలు 8 బైట్లు ఎందుకు 32 బిట్స్ 8 బైట్లు ఎందుకంటే ఇది.

254
00:21:22,970 --> 00:21:25,250
గమనికలు 4 బైట్లు ఉంటాయి.

255
00:21:25,250 --> 00:21:33,680
కాబట్టి మీరు oxbfffff వంటి పాయింటర్ చూసినప్పుడు, ఆ -

256
00:21:33,680 --> 00:21:40,080
ఏ కార్యక్రమం లోపల మీరు ఏ అనియత పాయింటర్ నిర్మించవచ్చు

257
00:21:40,080 --> 00:21:46,330
ఎక్కడైనా ox0 నుండి ఆక్స్ 8 f's కు - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[విద్యార్థి] వారు 4 బైట్లు అని చెప్పుకోవాలంటే లేదు? >> అవును.

259
00:21:49,180 --> 00:21:52,730
[విద్యార్థి] అప్పుడు ప్రతి బైట్ ఉంటుంది - >> [బౌడెన్] హెక్సాడెసిమల్.

260
00:21:52,730 --> 00:21:59,360
హెక్సాడెసిమల్ - 5, 6, 7, 8. గమనికలు మీరు ఎల్లప్పుడూ హెక్సాడెసిమల్ లో చూడండి చూడాలని.

261
00:21:59,360 --> 00:22:01,710
ఇది మేము గమనికలు వర్గీకరించడానికి ఎలా కేవలం ఉంది.

262
00:22:01,710 --> 00:22:05,240
హెక్సాడెసిమల్ యొక్క ప్రతి 2 అంకెలు 1 బైట్ ఉంది.

263
00:22:05,240 --> 00:22:09,600
కాబట్టి 4 బైట్లు కోసం 8 హెక్సాడెసిమల్ సంఖ్యలను ఉన్నట్లు జరగబోతోంది.

264
00:22:09,600 --> 00:22:14,190
కాబట్టి ఒక 32-bit వ్యవస్థలో ప్రతి ఒక్క పాయింటర్, 4 బైట్లు అవతరిస్తుంది

265
00:22:14,190 --> 00:22:18,550
ఇది మీ ప్రక్రియలో మీరు ఏ అనియత 4 బైట్లు నిర్మించవచ్చు అంటే

266
00:22:18,550 --> 00:22:20,550
మరియు, అది ఒక పాయింటర్ చేసుకుంటారు

267
00:22:20,550 --> 00:22:32,730
ఇది చాలా అది తెలుసు యొక్క, ఇది మెమరీ 32 బైట్లు ఒక పూర్తి 2 తెలుపుతుంది అర్థం.

268
00:22:32,730 --> 00:22:34,760
అది నిజంగా ఆ ప్రాప్తి లేదు ఉన్నప్పటికీ,

269
00:22:34,760 --> 00:22:40,190
మీ కంప్యూటర్ మాత్రమే 512 మెగాబైట్ల ఉన్నప్పటికీ అది ఆ మెమరీని కలిగి భావిస్తున్నారు.

270
00:22:40,190 --> 00:22:44,930
మరియు ఆపరేటింగ్ సిస్టమ్ మాత్రమే మీరు నిజంగా అవసరమైన కేటాయించాలని ఆ తగినంత స్మార్ట్ ఉంది.

271
00:22:44,930 --> 00:22:49,630
4 వేదికలను: ఇది కేవలం, OH, ఒక కొత్త ప్రక్రియ పోదు.

272
00:22:49,630 --> 00:22:51,930
>> అవును. >> [విద్యార్థి] ఆక్స్ శతకము ఎందుకు మీరు వ్రాస్తారా?

273
00:22:51,930 --> 00:22:54,980
ఇది కేవలం హెక్సాడెసిమల్ కోసం చిహ్నం యొక్క.

274
00:22:54,980 --> 00:22:59,590
మీరు ఎద్దు ఒక సంఖ్య ప్రారంభం చూసినప్పుడు, వరుస విషయాలు హెక్సాడెసిమల్ ఉంటాయి.

275
00:23:01,930 --> 00:23:05,760
[విద్యార్థి] మీరు ఒక కార్యక్రమం ముగిసిన తరువాత ఏమి జరుగుతుందో వివరించే చేశారు. >> అవును.

276
00:23:05,760 --> 00:23:09,480
ఏ ప్రోగ్రాం ముగిసిన తరువాత జరుగుతుంది ఆపరేటింగ్ సిస్టమ్

277
00:23:09,480 --> 00:23:13,600
కేవలం erases ఈ చిరునామాలకు ఉంది, అంతే ఆ లను.

278
00:23:13,600 --> 00:23:17,770
ఆపరేటింగ్ సిస్టమ్ ఇప్పుడు కేవలం ఉపయోగించడానికి మరొక ప్రోగ్రామ్ మెమరీ ఇస్తుంది.

279
00:23:17,770 --> 00:23:19,490
[విద్యార్థి] సరే.

280
00:23:19,490 --> 00:23:24,800
కాబట్టి మీరు కుప్ప లేదా స్టాక్ లేదా ప్రపంచ చరరాశులు లేదా ఏదైనా న ఏదో కేటాయించాలని ఉన్నప్పుడు,

281
00:23:24,800 --> 00:23:27,010
వారు అన్ని కేవలం వెంటనే కార్యక్రమం ముగుస్తుంది వంటి అదృశ్యం

282
00:23:27,010 --> 00:23:32,120
ఆపరేటింగ్ సిస్టమ్ ఇప్పుడు ఇతర ప్రక్రియ ఆ మెమరీ ఇవ్వాలని ఉచిత ఎందుకంటే.

283
00:23:32,120 --> 00:23:35,150
[విద్యార్థి] వ్రాసిన విలువలు ఇంకా బహుశా అక్కడ అయినప్పటికీ? >> అవును.

284
00:23:35,150 --> 00:23:37,740
విలువలు ఇంకా అవకాశం ఉన్నాయి.

285
00:23:37,740 --> 00:23:41,570
ఇది కేవలం వారికి వద్ద వేయటం కష్టం చేస్తాడు అన్నారు.

286
00:23:41,570 --> 00:23:45,230
అది ఒక తొలగించిన ఫైలు వద్ద పొందడానికి కంటే ఇది వాటిని పొందడానికి చాలా కష్టం

287
00:23:45,230 --> 00:23:51,450
యొక్క తొలగించబడిన ఫైలు రకం కాలం అక్కడ కూర్చుని, హార్డ్ డ్రైవ్ చాలా పెద్దగా ఉంది కాబట్టి.

288
00:23:51,450 --> 00:23:54,120
కనుక ఇది మెమరీ వివిధ ప్రాంతాల ఓవర్రైట్ జరగబోతోంది

289
00:23:54,120 --> 00:23:58,640
ఆ ఫైలు వద్ద కలిగిన మెమరీ భాగం ఓవర్రైట్ జరిగినప్పుడు ముందు.

290
00:23:58,640 --> 00:24:04,520
కానీ ప్రధాన మెమరీ, వేగంగా చాలా ద్వారా మీరు చక్రం RAM,

291
00:24:04,520 --> 00:24:08,040
కాబట్టి ఇది చాలా వేగంగా భర్తీ చేస్తాడు.

292
00:24:10,300 --> 00:24:13,340
ఈ లేదా ఏదైనా ప్రశ్నలకు?

293
00:24:13,340 --> 00:24:16,130
[విద్యార్థి] నేను వేరే అంశం గురించి ప్రశ్నలు. సరే >>.

294
00:24:16,130 --> 00:24:19,060
ఎవరైనా ఈ ప్రశ్నలకు కలిగి ఉందా?

295
00:24:20,170 --> 00:24:23,120
>> సరే. వివిధ టాపిక్. >> [విద్యార్థి] సరే.

296
00:24:23,120 --> 00:24:26,550
నేను, ఆచరణలో పరీక్షలు కొన్ని ద్వారా వెళుతున్న

297
00:24:26,550 --> 00:24:30,480
మరియు వాటిని ఒకటి దానిని sizeof మాట్లాడుతున్న

298
00:24:30,480 --> 00:24:35,630
మరియు విలువ తిరిగి లేదా వివిధ రకాల వేరియబుల్ ఆ. >> అవును.

299
00:24:35,630 --> 00:24:45,060
మరియు అది Int మరియు పొడవైన రెండు తిరిగి 4 రెండు, కాబట్టి వారు రెండు 4 బైట్లు దీర్ఘ అని చెప్పారు.

300
00:24:45,060 --> 00:24:48,070
ఒక Int మరియు దీర్ఘ ఏమైనా తేడా ఉందా, లేదా అదే విషయం?

301
00:24:48,070 --> 00:24:50,380
అవును, ఒక తేడా ఉంది.

302
00:24:50,380 --> 00:24:52,960
సి ప్రామాణిక -

303
00:24:52,960 --> 00:24:54,950
నేను బహుశా మురికిని వెళుతున్న.

304
00:24:54,950 --> 00:24:58,800
సి ప్రామాణిక కేవలం సి, సి అధికారిక డాక్యుమెంటేషన్ గురించే ఉంది

305
00:24:58,800 --> 00:25:00,340
ఈ అది ఏమిటి.

306
00:25:00,340 --> 00:25:08,650
కాబట్టి సి ప్రామాణిక కేవలం చార్ ఎప్పటికీ మరియు ఎల్లప్పుడూ 1 బైట్ చెబుతుంది.

307
00:25:10,470 --> 00:25:19,040
ఆ తర్వాత అంతా - ఒక చిన్న ఎల్లప్పుడూ కంటే ఎక్కువ లేదా ఒక చార్ కు సమానమని నిర్వచించబడింది ఉంది.

308
00:25:19,040 --> 00:25:23,010
ఈ ఖచ్చితంగా కంటే ఎక్కువ, కాని సానుకూల లేదు కావచ్చు.

309
00:25:23,010 --> 00:25:31,940
ఒక పూర్ణాంకానికి కేవలం కంటే ఎక్కువ లేదా తక్కువ కు సమానమని నిర్వచించబడింది.

310
00:25:31,940 --> 00:25:36,210
మరియు పొడవైన కేవలం కంటే ఎక్కువ లేదా ఒక పూర్ణాంకానికి సమానంగా నిర్వచించారు.

311
00:25:36,210 --> 00:25:41,600
మరియు ఒక లాంగ్ లాంగ్ కంటే ఎక్కువ లేదా సుదీర్ఘ సమానంగా ఉంటుంది.

312
00:25:41,600 --> 00:25:46,610
కాబట్టి సి ప్రామాణిక నిర్వచిస్తుంది మాత్రమే విషయం ప్రతిదీ సంబంధిత క్రమం ఉంటుంది.

313
00:25:46,610 --> 00:25:54,880
విషయాలు పడుతుంది ఆ స్మృతి మొత్తం వాస్తవిక, అప్ అమలు సాధారణంగా ఉంటుంది

314
00:25:54,880 --> 00:25:57,640
కానీ ప్రెట్టీ బాగా ఈ సమయంలో నిర్వచించిన ఉంది. >> [విద్యార్థి] సరే.

315
00:25:57,640 --> 00:26:02,490
కాబట్టి లఘు చిత్రాలు దాదాపు ఎల్లప్పుడూ 2 బైట్లు ఉంటాయని నేను.

316
00:26:04,920 --> 00:26:09,950
Ints దాదాపు ఎల్లప్పుడూ 4 బైట్లు ఉంటాయని నేను.

317
00:26:12,070 --> 00:26:15,340
లాంగ్ longs దాదాపు ఎల్లప్పుడూ 8 బైట్లు ఉంటాయని నేను.

318
00:26:17,990 --> 00:26:23,160
మరియు మీరు ఒక 32-bit లేదా 64-bit వ్యవస్థ ఉపయోగించే అనేదాని మీద ఆధారపడి ఉంటుంది, longs.

319
00:26:23,160 --> 00:26:27,450
కాబట్టి సుదీర్ఘ వ్యవస్థ యొక్క రకం అనుగుణంగా అన్నారు.

320
00:26:27,450 --> 00:26:31,920
మీరు ఉపకరణం వంటి 32-bit వ్యవస్థ ఉపయోగిస్తున్నట్లయితే, అది 4 బైట్లు చేస్తాడు.

321
00:26:34,530 --> 00:26:42,570
మీరు ఇటీవల కంప్యూటర్ల చాలా వంటి 64-bit ఉపయోగిస్తున్నట్లయితే, అది 8 బైట్లు చేస్తాడు.

322
00:26:42,570 --> 00:26:45,230
>> Ints దాదాపు ఎల్లప్పుడూ ఈ సమయంలో 4 బైట్లు ఉంటాయి.

323
00:26:45,230 --> 00:26:47,140
లాంగ్ longs దాదాపు ఎల్లప్పుడూ 8 బైట్లు ఉంటాయి.

324
00:26:47,140 --> 00:26:50,300
గతంలో, ints మాత్రమే 2 బైట్లు ఉండాలి.

325
00:26:50,300 --> 00:26:56,840
కానీ ఈ పూర్తిగా కంటే ఎక్కువ మరియు సమానంగా ఈ సంబంధాలు అన్ని తృప్తిపరిచే విధంగా గుర్తిస్తారు.

326
00:26:56,840 --> 00:27:01,280
సో లాంగ్ ఖచ్చితంగా పూర్ణాంకం వంటి ఒకే పరిమాణాన్ని అనుమతించబడిన,

327
00:27:01,280 --> 00:27:04,030
మరియు అది కూడా పెద్ద కాలం ఒకే పరిమాణాన్ని అనుమతించబడతాయో.

328
00:27:04,030 --> 00:27:11,070
మరియు ఇది కేవలం కాబట్టి వ్యవస్థలు 99.999%, ఇది సమానంగా అన్నారు ఆ నిర్మాణము

329
00:27:11,070 --> 00:27:15,800
ఒక పూర్ణాంకానికి లేదా లాంగ్ లాంగ్ గాని. ఇది కేవలం 32-bit లేదా 64-bit ఆధారపడి ఉంటుంది. >> [విద్యార్థి] సరే.

330
00:27:15,800 --> 00:27:24,600
తేలియాడుతున్న లో బిట్స్ పరంగా నియమించబడిన దశాంశ పాయింట్ ఎలా ఉంది?

331
00:27:24,600 --> 00:27:27,160
బైనరీ వంటి నచ్చిందా? >> అవును.

332
00:27:27,160 --> 00:27:30,570
మీరు CS50 కోసం మీకు లేదు.

333
00:27:30,570 --> 00:27:32,960
మీరు కూడా 61 ఆ తెలుసుకోవడానికి లేదు.

334
00:27:32,960 --> 00:27:37,350
మీరు ఏ కోర్సులో ఆ నిజంగా తెలుసుకోవడానికి లేదు.

335
00:27:37,350 --> 00:27:42,740
ఇది కేవలం ప్రాతినిధ్యం ఉంది.

336
00:27:42,740 --> 00:27:45,440
నేను ఖచ్చితమైన బిట్ కేటాయింపులు మర్చిపోతే.

337
00:27:45,440 --> 00:27:53,380
ఫ్లోటింగ్ పాయింట్ ఆలోచన మీరు ప్రాతినిధ్యం బిట్స్ ఒక నిర్దిష్ట సంఖ్య కేటాయించాలని ఉంది -

338
00:27:53,380 --> 00:27:56,550
సాధారణంగా, ప్రతిదీ శాస్త్రీయ విధానంలో ఉంది.

339
00:27:56,550 --> 00:28:05,600
కాబట్టి మీరు 1,2345 వంటి సంఖ్య కూడా ప్రాతినిధ్యం బిట్స్ ఒక నిర్దిష్ట సంఖ్య కేటాయించాలని.

340
00:28:05,600 --> 00:28:10,200
నేను 5 కంటే ఎక్కువ అంకెలు ఒక సంఖ్య ప్రాతినిధ్యం ఎప్పుడూ.

341
00:28:12,200 --> 00:28:26,300
ఇలాంటి ఉంటుంది కాబట్టి మీరు కూడా బిట్స్ ఒక నిర్దిష్ట సంఖ్య కేటాయించాలని

342
00:28:26,300 --> 00:28:32,810
మీరు కలిగి అతిపెద్ద ఆనవాలు యొక్క మీకు మాత్రమే, ఒక నిర్దిష్ట సంఖ్యలో వరకు వెళ్ళవచ్చు,

343
00:28:32,810 --> 00:28:36,190
మరియు మీరు మాత్రమే, ఒక నిర్దిష్ట ఆనవాలు క్రిందికి వెళ్ళే

344
00:28:36,190 --> 00:28:38,770
మీరు కలిగి చిన్న ఆనవాలు అని ఇష్టం.

345
00:28:38,770 --> 00:28:44,410
>> నేను, ఖచ్చితమైన మార్గం బిట్స్ ఈ విలువలు అన్ని కేటాయించిన గుర్తుంచుకోండి లేదు

346
00:28:44,410 --> 00:28:47,940
కానీ బిట్స్ నిర్దిష్ట సంఖ్యలో, 1,2345 అంకితమయ్యారు

347
00:28:47,940 --> 00:28:50,930
బిట్స్ మరొక నిర్దిష్ట సంఖ్యలో, ఆనవాలు అంకితమయ్యారు

348
00:28:50,930 --> 00:28:55,670
మరియు ఒక నిర్దిష్ట పరిమాణం యొక్క ఒక ఆనవాలు ప్రాతినిధ్యం మాత్రమే సాధ్యం.

349
00:28:55,670 --> 00:29:01,100
[విద్యార్థి], డబుల్? ఒక అదనపు కాలం ఫ్లోట్ లాగా ఉంటుంది? >> అవును.

350
00:29:01,100 --> 00:29:07,940
ఇది ఇప్పుడు మీరు బదులుగా 4 బైట్లు 8 బైట్లు ఉపయోగించే తప్ప ఫ్లోట్ అదే విషయం.

351
00:29:07,940 --> 00:29:11,960
ఇప్పుడు మీరు, 9 అంకెలు లేదా 10 అంకెలు చేయగలరు

352
00:29:11,960 --> 00:29:16,630
మరియు ఈ 300 బదులుగా 100 వరకు వెళ్ళి చేయగలరు. >> [విద్యార్థి] సరే.

353
00:29:16,630 --> 00:29:21,550
మరియు తేలియాడుతున్న కూడా 4 బైట్లు ఉంటాయి. >> అవును.

354
00:29:21,550 --> 00:29:27,520
Well, మళ్ళీ, అది బహుశా, సాధారణ అమలు పై మొత్తం ఆధారపడి ఉంటుంది

355
00:29:27,520 --> 00:29:30,610
కానీ తేలియాడుతున్న 4 బైట్లు ఉంటాయి, డబుల్స్ 8 ఉన్నాయి.

356
00:29:30,610 --> 00:29:33,440
వారు డబుల్ తెప్పల పరిమాణం ఎందుకంటే డబుల్స్ డబుల్ అంటారు.

357
00:29:33,440 --> 00:29:38,380
[విద్యార్థి] సరే. మరియు అక్కడ డబుల్స్ ఉన్నాయి? >> లేవు.

358
00:29:38,380 --> 00:29:43,660
నేను అనుకుంటున్నాను - దీర్ఘ longs ఇలా >> [విద్యార్థి]? >> అవును. నేను భావించడం లేదు. అవును.

359
00:29:43,660 --> 00:29:45,950
గత సంవత్సరం పరీక్ష ఆన్ [విద్యార్థి] ప్రధాన విధి గురించి ప్రశ్న ఉంది

360
00:29:45,950 --> 00:29:49,490
మీ కార్యక్రమంలో ఒక భాగం అవసరం.

361
00:29:49,490 --> 00:29:52,310
సమాధానం మీ కార్యక్రమంలో ఒక భాగం లేదు అని.

362
00:29:52,310 --> 00:29:55,100
ఏ పరిస్థితిలో? నేను చూసిన ఉంది.

363
00:29:55,100 --> 00:29:59,090
[బౌడెన్] ఇది ఉంది - >> [విద్యార్థి] ఏమిటి పరిస్థితి?

364
00:29:59,090 --> 00:30:02,880
మీరు సమస్య ఉందా? >> [విద్యార్థి] అవును, నేను ఖచ్చితంగా ఇది పుల్ అప్ చేయవచ్చు.

365
00:30:02,880 --> 00:30:07,910
ఇది సాంకేతికంగా, కావలసిన అవసరం లేదు, కానీ ప్రధానంగా ఇది చేస్తాడు.

366
00:30:07,910 --> 00:30:10,030
[విద్యార్థి] నేను వేరే సంవత్సరం లో ఒక చూసింది.

367
00:30:10,030 --> 00:30:16,220
ఇది ఒప్పు లేదా తప్పు నచ్చింది: సరైన - >> ఓహ్, ఒక సి ఫైలు.?

368
00:30:16,220 --> 00:30:18,790
. [విద్యార్థి] ఏదైనా సి ఫైల్ కలిగి ఉండాలి - [ఒకేసారి మాట్లాడే రెండు - అపారదర్శక]

369
00:30:18,790 --> 00:30:21,120
సరే. కాబట్టి ప్రత్యేక ఉంది.

370
00:30:21,120 --> 00:30:26,800
>> ఒక. సి ఫైలు కేవలం విధులు కలిగి ఉంది.

371
00:30:26,800 --> 00:30:32,400
మీరు ఒక యంత్రం కోడ్ లోకి ఫైలు, బైనరీ, ఏ, కంపైల్ చేయవచ్చు

372
00:30:32,400 --> 00:30:36,620
లేకుండా ఇంకా executable ఉంది.

373
00:30:36,620 --> 00:30:39,420
సరైన executable ఒక ప్రధాన విధి కలిగి ఉండాలి.

374
00:30:39,420 --> 00:30:45,460
మీరు 100 1 ఫైలు లో విధులు కాని ప్రధాన రాయడం

375
00:30:45,460 --> 00:30:48,800
తరువాత, బైనరీ ఆ డౌన్ కంపైల్

376
00:30:48,800 --> 00:30:54,460
అప్పుడు మీరు మాత్రమే ప్రధాన మరో ఫైల్ను వ్రాయడానికి కానీ ఈ విధులను కొంత కాల్స్

377
00:30:54,460 --> 00:30:56,720
ఇక్కడ ఈ బైనరీ ఫైలు లో.

378
00:30:56,720 --> 00:31:01,240
కాబట్టి మీరు executable చేస్తున్న సమయంలో, ఆ లింకర్ దేనిని యొక్క

379
00:31:01,240 --> 00:31:05,960
ఈ 2 బైనరీ ఫైళ్ళను ఒక ఎక్జిక్యూటబుల్ లోకి మిళితం ఉంది.

380
00:31:05,960 --> 00:31:11,400
కాబట్టి ఒక. సి ఫైల్ అన్ని వద్ద ఒక ప్రధాన చర్య అవసరం లేదు.

381
00:31:11,400 --> 00:31:19,220
మరియు పెద్ద కోడ్ స్థావరాలు మీరు. సి ఫైళ్ళను మరియు 1 ప్రధాన ఫైలు వేల చూస్తారు.

382
00:31:23,960 --> 00:31:26,110
మరిన్ని ప్రశ్నలు?

383
00:31:29,310 --> 00:31:31,940
[విద్యార్థి] మరొక ప్రశ్న ఉంది.

384
00:31:31,940 --> 00:31:36,710
ఇది తయారు ఒక కంపైలర్ చెప్పాడు. సత్యం లేదా అసత్యం?

385
00:31:36,710 --> 00:31:42,030
మరియు సమాధానాన్ని తప్పుడు, మరియు అది గణగణమని ద్వని చేయు వంటి కాదు నేను అర్థం.

386
00:31:42,030 --> 00:31:44,770
కానీ మేము అలా కాకపోతే ఏమి కాల్ చెయ్యాలి?

387
00:31:44,770 --> 00:31:49,990
చేయి కేవలం రప్పించింది - నేను దీనిని సరిగ్గా అదే చూడగలరు.

388
00:31:49,990 --> 00:31:52,410
కానీ అది కేవలం ఆదేశాలను నడుస్తుంది.

389
00:31:53,650 --> 00:31:55,650
చేయి.

390
00:31:58,240 --> 00:32:00,870
నేను ఈ పుల్ అప్ చేయవచ్చు. అవును.

391
00:32:10,110 --> 00:32:13,180
ఓహ్, అవును. చేయి కూడా ఆ చేస్తుంది.

392
00:32:13,180 --> 00:32:17,170
చేయండి ప్రయోజనం ప్రయోజనం స్వయంచాలకంగా గుర్తించడానికి చెప్పారు

393
00:32:17,170 --> 00:32:19,610
ఒక పెద్ద కార్యక్రమం ముక్కలు recompiled అవసరం ఇది

394
00:32:19,610 --> 00:32:22,350
మరియు వారిని మళ్ళీ కంపైల్ చెయ్యండి ఆదేశాలను జారీ.

395
00:32:22,350 --> 00:32:27,690
మీరు ఖచ్చితంగా భారీ ఫైళ్ళను తయారు చేయవచ్చు.

396
00:32:27,690 --> 00:32:33,210
చేయి, మేము ముందు చెప్పారు వంటి ఫైళ్ళ టైమ్ స్టాంప్స్ చూసి,

397
00:32:33,210 --> 00:32:36,930
మీరు ఒక్కొక్క ఫైళ్ళు డౌన్ కంపైల్ చేయవచ్చు, మరియు మీరు లింకర్ ను వరకు అది కాదు

398
00:32:36,930 --> 00:32:39,270
వారు ఒక ఎక్జిక్యూటబుల్ లోకి కలిసి చేస్తున్న.

399
00:32:39,270 --> 00:32:43,810
మీరు 10 వివిధ ఫైళ్లను కలిగి మరియు మీరు, వాటిలో 1 మార్పు చేసుకుంటూ ఉంటే

400
00:32:43,810 --> 00:32:47,870
అప్పుడు ఏమి ఉందని అన్నారు కేవలం మళ్ళీ కంపైల్ చెయ్యండి అని 1 ఫైలు

401
00:32:47,870 --> 00:32:50,640
ఆపై కలిసి ప్రతిదీ మళ్లీ లింక్.

402
00:32:50,640 --> 00:32:53,020
కానీ కంటే dumber ఉంది.

403
00:32:53,020 --> 00:32:55,690
ఇది పూర్తిగా అది చేయడం చేయాలి ఏమి లేదని నిర్వచించే వరకు మీరు ఉంది.

404
00:32:55,690 --> 00:32:59,560
ఇది సిద్ధంగా, ఈ టైమ్ స్టాంప్ stuff గుర్తించి సామర్ధ్యాన్ని కలిగి ఉంది

405
00:32:59,560 --> 00:33:03,220
కానీ మీరు ఏదైనా ఒక మొదలు ఫైలు వ్రాయగలవు.

406
00:33:03,220 --> 00:33:09,150
మీరు వ్రాసే ఫైలు చేస్తే మీరు ఇది CD యొక్క మరొక డైరెక్టరీ చేయడానికి టైప్ చేసినప్పుడు.

407
00:33:09,150 --> 00:33:15,560
నేను విసుగు పొందారు నేను టాక్ ప్రతిదీ నా ఉపకరణం లోపల ఎందుకంటే

408
00:33:15,560 --> 00:33:21,740
మరియు నేను Mac నుండి PDF చూడవచ్చు.

409
00:33:21,740 --> 00:33:30,720
>> నేను శోధిని వెళ్ళండి మరియు నేను క్రమబద్ధీకరించడం, సర్వర్కు కనెక్ట్,

410
00:33:30,720 --> 00:33:36,950
మరియు నేను కనెక్ట్ సర్వర్ నా ఉపకరణం, ఆ తరువాత PDF ప్రారంభం

411
00:33:36,950 --> 00:33:40,190
ఆ LaTeX సంకలనం తీర్చుకుంటాడు.

412
00:33:40,190 --> 00:33:49,320
కానీ నేను విసుగు పొందారు నేను PDF రిఫ్రెష్ అవసరం ప్రతి సమయం ఎందుకంటే,

413
00:33:49,320 --> 00:33:53,900
నేను ప్రాప్తి చేయగల నిర్దిష్ట డైరెక్టరీ కాపీ వచ్చింది

414
00:33:53,900 --> 00:33:57,710
మరియు అది బాధించే పొందారు.

415
00:33:57,710 --> 00:34:02,650
కాబట్టి బదులుగా నేను మీరు విషయాలు చేస్తుంది ఎలా నిర్వచించాలి కలిగి ఉండే మొదలు ఫైలు, రాశాడు.

416
00:34:02,650 --> 00:34:06,130
మీరు ఎలా ఈ PDF LaTeX ఉంది.

417
00:34:06,130 --> 00:34:10,090
ఏ ఇతర మొదలు ఫైల్ - లేదా నేను మీరు చేసే ఫైళ్లను చూడని ఊహించడం,

418
00:34:10,090 --> 00:34:13,510
కానీ మేము, ఉపకరణ కేవలం అని ప్రపంచ మొదలు ఫైలుని కలిగి

419
00:34:13,510 --> 00:34:16,679
మీరు ఒక ఫైల్ సి కంపైల్ ఉంటే, గణగణమని ద్వని చేయు ఉపయోగించవచ్చు.

420
00:34:16,679 --> 00:34:20,960
మరియు ఇక్కడ నా మొదలు ఫైలులో నేను చెబుతాను ఆ,

421
00:34:20,960 --> 00:34:25,020
ఈ ఫైలు మీరు PDF LaTeX తో కంపైల్ మీరు చూడాలని.

422
00:34:25,020 --> 00:34:27,889
మరియు అందువలన సేకరించి ఏమి ఆ PDF LaTeX ఉంది.

423
00:34:27,889 --> 00:34:31,880
చేయి కంపైల్ లేదు. ఇది కేవలం నేను పేర్కొన్న క్రమంలో ఈ ఆదేశాలను అమలు ఉంది.

424
00:34:31,880 --> 00:34:36,110
కనుక ఇది PDF LaTeX నడుస్తుంది, ఇది నేను కాపీ అనుకుంటే డైరెక్టరీ అది కాపీ

425
00:34:36,110 --> 00:34:38,270
ఇది CD యొక్క డైరెక్టరీ మరియు ఇతర పనులు చేసే,

426
00:34:38,270 --> 00:34:42,380
కానీ అది అన్ని, ఒక ఫైల్ మార్పుల గుర్తించి ఉంది

427
00:34:42,380 --> 00:34:45,489
అది మార్చినట్లయితే మరియు, అది అమలు భావించే ఆదేశాలను కనిపిస్తుంది

428
00:34:45,489 --> 00:34:48,760
ఉన్నప్పుడు ఫైల్ మార్పుల. >> [విద్యార్థి] సరే.

429
00:34:50,510 --> 00:34:54,420
నేను ప్రపంచ మొదలు ఫైళ్లను నాకు దాన్ని తనిఖీ కోసం ఎక్కడ తెలియదు.

430
00:34:57,210 --> 00:35:04,290
ఇతర ప్రశ్నలు? గత ఏదైనా క్విజ్లు? ఏదైనా పాయింటర్ విషయాలు?

431
00:35:06,200 --> 00:35:08,730
వంటి గమనికలు తో సూక్ష్మ విషయాలు ఉన్నాయి -

432
00:35:08,730 --> 00:35:10,220
నేను ఒక క్విజ్ ప్రశ్న కనుగొనగలరు వెళుతున్న కాదు -

433
00:35:10,220 --> 00:35:16,250
కానీ విషయం ఈ విధమైన ఇష్టపడుతున్నారు.

434
00:35:19,680 --> 00:35:24,060
నేను మీరు అర్థం నిర్ధారించుకోండి Int * x * Y -

435
00:35:24,890 --> 00:35:28,130
ఈ ఖచ్చితంగా ఇక్కడ ఏదైనా కాదు, నేను ఊహిస్తున్నాను.

436
00:35:28,130 --> 00:35:32,140
కానీ వంటి * x * Y, ఆ స్టాక్ మీద ఉన్న 2 వేరియబుల్స్ ఉన్నాయి.

437
00:35:32,140 --> 00:35:37,220
నేను ఎప్పుడు x = malloc (sizeof (Int)), x, ఇప్పటికీ స్టాక్ ఒక చరరాశి

438
00:35:37,220 --> 00:35:41,180
malloc కుప్ప లో కొంత బ్లాక్, మరియు మేము కుప్ప కు x పాయింట్ సమస్య.

439
00:35:41,180 --> 00:35:43,900
>> కుప్ప కు స్టాక్ పాయింట్లు ఏదో కాబట్టి.

440
00:35:43,900 --> 00:35:48,100
ఎప్పుడు మీరు malloc ఏదైనా, మీరు తప్పనిసరిగా ఒక పాయింటర్ లోపలి నిల్వ చేస్తున్నారు.

441
00:35:48,100 --> 00:35:55,940
ఆ పాయింటర్ స్టాక్ ఉంది కాబట్టి, malloced బ్లాక్ కుప్ప ఉంది.

442
00:35:55,940 --> 00:36:01,240
మంది అయోమయం పొందండి మరియు చెప్పడానికి Int * x = malloc; x కుప్ప ఉంది.

443
00:36:01,240 --> 00:36:04,100
X సూచిస్తుంది ఏమి నం కుప్ప ఉంది.

444
00:36:04,100 --> 00:36:08,540
ఏ కారణం చేతనైనా సరే మీరు x ప్రపంచ చరరాశి ఉంటే తప్ప x కూడా, స్టాక్ ఉంది

445
00:36:08,540 --> 00:36:11,960
ఈ సందర్భంలో అది మెమొరీ మరొక ప్రాంతంలో నిర్మాణము.

446
00:36:13,450 --> 00:36:20,820
పర్యవేక్షించడం కాబట్టి, ఈ బాక్స్ మరియు బాణం చిత్రాలు క్విజ్ కోసం చాలా సాధారణం.

447
00:36:20,820 --> 00:36:25,740
అది క్విజ్ 0 లో లేకుంటే లేదా, అది క్విజ్ 1 ఉంటుంది.

448
00:36:27,570 --> 00:36:31,940
మీరు కంపైల్ లో దశలను ఈ అన్ని తెలుసుకోవాలి

449
00:36:31,940 --> 00:36:35,740
ఆ ప్రశ్నలకు సమాధానం వచ్చేది. అవును.

450
00:36:35,740 --> 00:36:38,940
[విద్యార్థి] మేము ఆ దశలను వెళ్ళి కాలేదు - >> ఖచ్చితంగా.

451
00:36:48,340 --> 00:36:58,640
దశలు మరియు కంపైల్ ముందు మేము, preprocessing కలిగి

452
00:36:58,640 --> 00:37:16,750
, కంపైల్ కలపడం మరియు కలుపుతుంది.

453
00:37:16,750 --> 00:37:21,480
Preprocessing. ఆ ఏమి చేస్తుంది?

454
00:37:29,720 --> 00:37:32,290
అది సులభమైన దశ - బాగా, కాదు వంటి -

455
00:37:32,290 --> 00:37:35,770
అది స్పష్టమైన ఉండాలి కాదు, కానీ సులభమైన దశల ఉంది.

456
00:37:35,770 --> 00:37:38,410
మీరు అబ్బాయిలు ఇది నిన్ను నీవు అమలు కాలేదు. అవును.

457
00:37:38,410 --> 00:37:43,410
[విద్యార్థి] మీరు మీ కలిగి దీన్ని ఇష్టపడుతున్నారు కలిగి టేక్ మరియు అది ప్రతులు మరియు తరువాత కూడా నిర్వచిస్తుంది.

458
00:37:43,410 --> 00:37:49,250
ఇది # ఉన్నాయి వంటి వాటిని పరీక్షిస్తుంది మరియు # define

459
00:37:49,250 --> 00:37:53,800
అది కాపీలు మరియు ముద్ద ఆ నిజానికి అర్ధాన్ని.

460
00:37:53,800 --> 00:37:59,240
కాబట్టి మీరు # cs50.h ఉన్నాయి చెప్పినప్పుడు ప్రీప్రాసెసర్ కాపీ మరియు పేస్ట్ cs50.h ఉంది

461
00:37:59,240 --> 00:38:01,030
ఆ లైను.

462
00:38:01,030 --> 00:38:06,640
మీరు # 4 కు x నిర్వచించే చెప్పినప్పుడు ప్రీప్రాసెసర్ మొత్తం కార్యక్రమం ద్వారా వెళుతుంది

463
00:38:06,640 --> 00:38:10,400
మరియు 4 తో x యొక్క అన్ని పర్యాయాలు భర్తీ.

464
00:38:10,400 --> 00:38:17,530
కాబట్టి ప్రీప్రాసెసర్ చెల్లుబాటు అయ్యే సి ఫైల్ తీసుకుని చెల్లుబాటు అయ్యే సి ఫైలు అందిస్తుంది

465
00:38:17,530 --> 00:38:20,300
పేరు విషయాలు కాపీ అతికించినది జరిగింది.

466
00:38:20,300 --> 00:38:24,230
కాబట్టి ఇప్పుడు కంపైల్. ఆ ఏమి చేస్తుంది?

467
00:38:25,940 --> 00:38:28,210
[విద్యార్థి] ఇది C నుండి బైనరీ వెళుతుంది.

468
00:38:28,210 --> 00:38:30,970
>> [బౌడెన్] ఇది బైనరీ అన్ని వ్యాపించదు.

469
00:38:30,970 --> 00:38:34,220
[విద్యార్థి] యంత్రం కోడ్ తరువాత? >> ఇది యంత్రం కోడ్ కాదు.

470
00:38:34,220 --> 00:38:35,700
[విద్యార్థి] అసెంబ్లీ? >> అసెంబ్లీ.

471
00:38:35,700 --> 00:38:38,890
అది సి కోడ్ వరకు వెళ్ళే ముందు ఇది అసెంబ్లీ కి వెళతాడు

472
00:38:38,890 --> 00:38:45,010
మరియు అనేక భాషల్లో ఈ వంటి ఏదో ఒకటి.

473
00:38:47,740 --> 00:38:50,590
ఏ స్థాయి భాష ఎంచుకోండి మరియు మీరు కంపైల్ చూడాలని ఉంటే,

474
00:38:50,590 --> 00:38:52,390
అది దశల్లో తయారు చేసుకుని ఉండవచ్చు.

475
00:38:52,390 --> 00:38:58,140
మొదట సి కు పైథాన్ కంపైల్ అవకాశముంది, అప్పుడు, శాసనసభకు సి కంపైల్ వెళుతున్న

476
00:38:58,140 --> 00:39:01,600
తరువాత అసెంబ్లీ బైనరీ అనువదించబడింది get అన్నారు.

477
00:39:01,600 --> 00:39:07,800
కాబట్టి కంపైల్ సి నుండి అసెంబ్లీ ముందుకు తీసుకుని అన్నారు.

478
00:39:07,800 --> 00:39:12,130
కంపైల్ పదం సాధారణంగా ఒక ఉన్నత స్థాయి నుండి తీసుకు అర్థం

479
00:39:12,130 --> 00:39:14,340
తక్కువ స్థాయి ప్రోగ్రామింగ్ భాష.

480
00:39:14,340 --> 00:39:19,190
కాబట్టి మీరు ఉన్నత స్థాయి భాష ప్రారంభం పేరు సంకలనంలో మాత్రమే అడుగు

481
00:39:19,190 --> 00:39:23,270
మరియు తక్కువ స్థాయి భాషలో ముగుస్తుంది, మరియు దశల కంపైల్ అంటారు ఎందుకు ఆ.

482
00:39:25,280 --> 00:39:33,370
కంపైల్ సమయంలో [విద్యార్థి], యొక్క మీరు # ఉన్నాయి పూర్తి చేసిన అని పిలవబడు cs50.h.

483
00:39:33,370 --> 00:39:42,190
కంపైలర్ మళ్ళీ కంపైల్ చెయ్యండి cs50.h విల్, అక్కడ ఉన్న విధులు వలె,

484
00:39:42,190 --> 00:39:45,280
మరియు అలాగే ఆ అసెంబ్లీ కోడ్ అనువదించు

485
00:39:45,280 --> 00:39:50,830
లేదా ముందు అసెంబ్లీ చేసినది కాపీ చేసి అతికించిన కనిపిస్తుంది?

486
00:39:50,830 --> 00:39:56,910
cs50.h చాలా చక్కని అసెంబ్లీలో ముగుస్తుంది ఎప్పుడూ.

487
00:39:59,740 --> 00:40:03,680
ఫంక్షన్ నమూనాలను మరియు విషయాలు వంటి స్టఫ్ మీరు జాగ్రత్తగా కేవలం ఉంటాయి.

488
00:40:03,680 --> 00:40:09,270
మీరు విధులు కాల్ చేస్తున్నారు కంపైలర్ విషయాలు తనిఖీ చేయవచ్చు హామీని

489
00:40:09,270 --> 00:40:12,910
కుడివైపు తిరిగి రకాల మరియు కుడి వాదనలు మరియు విషయాలలో.

490
00:40:12,910 --> 00:40:18,350
>> ఇది కంపైల్ యొక్క కనుక cs50.h అప్పుడు ఫైల్లోకి ప్రాసెస్, మరియు ఉంటుంది

491
00:40:18,350 --> 00:40:22,310
ప్రతిదీ సరిగ్గా అని ఉంది అని మీరు చేస్తుంది తరువాత ఇది ప్రాథమికంగా దూరంగా విసిరిన యొక్క.

492
00:40:22,310 --> 00:40:29,410
కానీ CS50 లైబ్రరీలో నిర్వచించిన చర్యలు, cs50.h వేరుగా ఉంటుంది ఇది

493
00:40:29,410 --> 00:40:33,610
ఆ వేరుగా సంకలనం కాదు.

494
00:40:33,610 --> 00:40:37,270
వాస్తవానికి లింక్ దశలో డౌన్ వస్తుందని, కాబట్టి మేము రెండవ ఆ చూస్తారు.

495
00:40:37,270 --> 00:40:40,100
కానీ మొదటి, ఏ సమీకరించడం ఉంది?

496
00:40:41,850 --> 00:40:44,500
బైనరీ కు [విద్యార్థి] అసెంబ్లీ? >> అవును.

497
00:40:46,300 --> 00:40:48,190
అసెంబ్లింగ్.

498
00:40:48,190 --> 00:40:54,710
అసెంబ్లీ చాలా చక్కని బైనరీ యొక్క స్వచ్ఛమైన అనువాదం ఎందుకంటే మేము కంపైల్ కాల్ లేదు.

499
00:40:54,710 --> 00:41:00,230
అసెంబ్లీ నుంచి బైనరీ వెళ్ళి చాలా తక్కువ తర్కం ఉంది.

500
00:41:00,230 --> 00:41:03,180
ఇది కేవలం ఒక టేబుల్ లో చూస్తున్నప్పుడు ఇష్టం అన్నారు, OH, మేము ఈ ఆదేశం కలిగి ఉంటాయి;

501
00:41:03,180 --> 00:41:06,290
ఆ బైనరీ 01110 సూచించదు.

502
00:41:10,200 --> 00:41:15,230
కాబట్టి ఫైళ్ళను బహిర్గత అంశాలను ఉత్పత్తి సాధారణంగా సిద్ధం. O ఫైళ్లు.

503
00:41:15,230 --> 00:41:19,020
మరియు. O ఫైళ్ళను మేము ముందు చెప్పడం ఏ ఉంటాయి,

504
00:41:19,020 --> 00:41:21,570
ఎలా ఫైలు ప్రధాన చర్య అవసరం లేదు.

505
00:41:21,570 --> 00:41:27,640
ఏదైనా ఫైల్ చెల్లుబాటు అయ్యే సి ఫైల్ కాలం ఒక. O ఫైలుకు డౌన్ సంకలనం చేయవచ్చు.

506
00:41:27,640 --> 00:41:30,300
ఇది. O క్రిందికి సంకలనం చేయవచ్చు.

507
00:41:30,300 --> 00:41:43,030
ఇప్పుడు, కలుపుతుంది. వాస్తవానికి కొంత తెస్తుంది ఏ o ఫైళ్ళను మరియు ఒక ఎక్జిక్యూటబుల్ వాటిని తెస్తుంది.

508
00:41:43,030 --> 00:41:51,110
కాబట్టి ఏమి లింకింగ్ చేస్తుంది మీరు ఒక. O ఫైల్ వలె CS50 లైబ్రరీ యొక్క ఆలోచించవచ్చు ఉంది.

509
00:41:51,110 --> 00:41:56,980
ఇది ఇప్పటికే సంకలనం బైనరీ ఫైలు.

510
00:41:56,980 --> 00:42:03,530
కాబట్టి మీరు GetString పిలిచే మీ ఫైలు, మీ hello.c, కంపైల్ సమయంలో

511
00:42:03,530 --> 00:42:06,360
hello.c, hello.o క్రిందికి సంకలనం అవుతుంది

512
00:42:06,360 --> 00:42:08,910
hello.o బైనరీ లో ఉంది.

513
00:42:08,910 --> 00:42:12,830
, ఇది GetString ఉపయోగిస్తుంది, అందువలన దీనిని cs50.o కు వెళ్ళి అవసరం

514
00:42:12,830 --> 00:42:16,390
మరియు లింకర్ కలిసి వాటిని smooshes మరియు ఈ ఫైల్లోకి GetString కాపీ

515
00:42:16,390 --> 00:42:20,640
మరియు అది అవసరం అన్ని పనులు చేసే executable తో బయటకు వస్తుంది.

516
00:42:20,640 --> 00:42:32,620
కాబట్టి cs50.o నిజానికి ఒక O ఫైల్ కాదు, కానీ ఏ విధమైన మౌలిక తేడా లేదని దగ్గరగా ఉంది.

517
00:42:32,620 --> 00:42:36,880
కాబట్టి కేవలం లింక్ కలిసి ఫైళ్లను కొంత తెస్తుంది

518
00:42:36,880 --> 00:42:41,390
విడిగా విధులను అన్ని కలిగి నేను ఉపయోగించాలి

519
00:42:41,390 --> 00:42:46,120
మరియు వాస్తవానికి అమలు చేసే executable సృష్టిస్తుంది.

520
00:42:48,420 --> 00:42:50,780
>> అందువలన, మేము ముందు చెప్పడం ఏ కూడా

521
00:42:50,780 --> 00:42:55,970
మీరు 1000 చెయ్యగల. సి ఫైళ్లు, మీరు వాటిని అన్ని కంపైల్. o ఫైళ్లు,

522
00:42:55,970 --> 00:43:00,040
బహుశా కొంత తీసుకునే, అప్పుడు మీరు 1 మార్చండి. సి ఫైలు.

523
00:43:00,040 --> 00:43:05,480
మీరు ఆ 1. సి ఫైల్ మరియు తరువాత మిగిలిన మళ్లీ లింక్ ప్రతిదీ, మళ్ళీ కంపైల్ చెయ్యండి అవసరం

524
00:43:05,480 --> 00:43:07,690
తిరిగి కలిసి ప్రతిదీ లింక్.

525
00:43:09,580 --> 00:43:11,430
[విద్యార్థి] మేము lcs50 వ్రాయండి లింక్ చేసినపుడు?

526
00:43:11,430 --> 00:43:20,510
అవును, ఈ lcs50. మీరు ఆ లైబ్రరీలో లింక్ చేయాలని లింకర్ ఆ జెండా సంకేతాలు.

527
00:43:26,680 --> 00:43:28,910
ప్రశ్నలు?

528
00:43:41,310 --> 00:43:46,860
మేము మొదటి ఉపన్యాసం ఆ 5 సెకన్ల కంటే ఇతర బైనరీ పైగా గాన్?

529
00:43:50,130 --> 00:43:53,010
నేను భావించడం లేదు.

530
00:43:55,530 --> 00:43:58,820
మీరు, మేము దాటి చేసిన పెద్ద Os అన్ని తెలుసుకోవాలి

531
00:43:58,820 --> 00:44:02,670
మేము మీరు ఒక ఫంక్షన్ ఇచ్చింది ఉంటే మరియు మీరు,, సామర్థ్యాన్ని కలిగి ఉండాలి

532
00:44:02,670 --> 00:44:09,410
మీరు ఇది దాదాపు, పెద్ద O చెప్పాలి ఉండాలి. లేదా బాగా, పెద్ద O ఆటుపోట్లు.

533
00:44:09,410 --> 00:44:15,300
మీరు విషయాలను అదే నెంబర్ పైగా మళ్ళీ వెతికినా ఉచ్చులు కోసం సమూహం చూడండి అయితే,

534
00:44:15,300 --> 00:44:22,260
>> [విద్యార్థి] n స్క్వేర్డ్ - ఇంట్ J, j <n; Int నేను, i <n ఇష్టపడుతున్నారు. >> అది స్క్వేర్డ్ అయి n ఉంటుంది.

535
00:44:22,260 --> 00:44:25,280
మీరు ట్రిపుల్ సమూహం ఉంటే, n cubed ఉంటుంది.

536
00:44:25,280 --> 00:44:29,330
కాబట్టి విషయం ఆ విధమైన మీరు వెంటనే అభిప్రాయపడుతున్నారు విధంగా ఉండాలి.

537
00:44:29,330 --> 00:44:33,890
మీరు ప్రవేశాన్ని విధమైన మరియు బబుల్ సార్ట్ తెలిసిన మరియు విధమైన మరియు ఆ అన్ని విలీనం చేయాలి.

538
00:44:33,890 --> 00:44:41,420
ఆ n స్క్వేర్డ్ మరియు N log N మరియు అన్ని ఎందుకు అర్థం సులభంగా

539
00:44:41,420 --> 00:44:47,810
మనం ప్రధానంగా మీరు ఇచ్చిన పేరు ఒక సంవత్సరం ఒక క్విజ్ న ఉంది అనుకుంటున్నాను ఎందుకంటే

540
00:44:47,810 --> 00:44:55,050
బబుల్ సార్ట్ అభివృద్దిని మరియు "ఈ చర్యను అమలు సమయం అంటే ఏమిటి?", అన్నాడు

541
00:44:55,050 --> 00:45:01,020
మీరు బబుల్ సార్ట్ గుర్తిస్తాయి అయితే, మీరు వెంటనే n స్క్వేర్డ్ చెప్పగలను.

542
00:45:01,020 --> 00:45:05,470
మీరు దీనిని చూడండి అయితే, మీరు కూడా ఇది బబుల్ సార్ట్ గుర్తించడం అవసరం లేదు;

543
00:45:05,470 --> 00:45:08,990
మీరు ఈ ఈ ఈ చేస్తోంది చెప్పగలను. ఈ స్క్వేర్డ్ n.

544
00:45:12,350 --> 00:45:14,710
[విద్యార్థి] మీరు ఆలోచన ఏ కఠినమైన ఉదాహరణలు ఉన్నాయి,

545
00:45:14,710 --> 00:45:20,370
ఇందుకు ఇదే ఆలోచన నచ్చిందా?

546
00:45:20,370 --> 00:45:24,450
>> నేను మీరు ఏ కఠినమైన ఉదాహరణలు ఇస్తుంది భావించడం లేదు.

547
00:45:24,450 --> 00:45:30,180
బబుల్ సార్ట్ విషయం, మేము పాటు దాదాపు వంటి కఠినమైన ఉంది

548
00:45:30,180 --> 00:45:36,280
మరియు కూడా కాలం మీరు అర్థం మీరు శ్రేణి మీద iterating చేస్తున్న, ఆ

549
00:45:36,280 --> 00:45:41,670
అర్రే ప్రతి మూలకం కోసం, ఇది స్క్వేర్డ్ n చేసినది అని అన్నారు.

550
00:45:45,370 --> 00:45:49,940
మనం ఇక్కడే వంటి సాధారణ ప్రశ్నలు ఉన్నాయి - ఓహ్.

551
00:45:55,290 --> 00:45:58,530
జస్ట్ ఇతర రోజు, డౌగ్ పేర్కొన్నారు, "నేను ఒక అర్రే క్రమం చేసే ఒక అల్గోరిథం తున్నారు

552
00:45:58,530 --> 00:46:01,780
"ఓ (లాగ్ n) సమయం! లో n సంఖ్యల"

553
00:46:01,780 --> 00:46:04,900
కాబట్టి మేము ఎలా ఆ అసాధ్యం తెలుసు?

554
00:46:04,900 --> 00:46:08,850
[వినబడని విద్యార్థి ప్రతిస్పందన] >> అవును.

555
00:46:08,850 --> 00:46:13,710
కనీసం, మీరు, అర్రే ప్రతి మూలకం టచ్ ఉంటుంది

556
00:46:13,710 --> 00:46:16,210
కాబట్టి ఇది ఒక వరుస క్రమం అసాధ్యం అనేది -

557
00:46:16,210 --> 00:46:20,850
ప్రతిదీ క్రమబద్ధీకరించనిది క్రమంలో ఉంటే, అప్పుడు మీరు, అర్రే లో ప్రతిదీ తాకడం కావడం చేస్తున్నారు

558
00:46:20,850 --> 00:46:25,320
కాబట్టి ఇది n ఓ కంటే తక్కువ చేయటానికి అసాధ్యం.

559
00:46:27,430 --> 00:46:30,340
[విద్యార్థి] మీరు మాకు n యొక్క O లో దీనిని చేసే ఆ ఉదాహరణకు చూపించింది

560
00:46:30,340 --> 00:46:33,920
మీరు మెమరీ చాలా ఉపయోగిస్తే. >> అవును.

561
00:46:33,920 --> 00:46:37,970
మరియు that's - నేను that's మర్చిపోలేరు - అది విధమైన లెక్కింపు ఉంటుంది?

562
00:46:47,360 --> 00:46:51,330
అయ్యో. ఒక పూర్ణాంకం సార్టింగ్ అల్గోరిథం.

563
00:46:59,850 --> 00:47:05,100
నేను గత వారం గుర్తు అని ఈ ప్రత్యేక పేరు కోసం ఎదురు చూసింది.

564
00:47:05,100 --> 00:47:13,000
అవును. ఈ n యొక్క పెద్ద O విషయాలను సాధించడానికి చేసే రకాల రకాలు.

565
00:47:13,000 --> 00:47:18,430
మీరు ఒక నిర్దిష్ట సంఖ్యలో పూర్ణాంకాల అప్ ఉపయోగించవచ్చు వంటి కానీ పరిమితులు ఉన్నాయి.

566
00:47:20,870 --> 00:47:24,560
ప్లస్ మీరు ఏదో that's క్రమం ప్రయత్నిస్తున్న ఉంటే -

567
00:47:24,560 --> 00:47:30,750
మీ శ్రేణి 012, -12, 151, 4 మిలియన్ ఉంటే

568
00:47:30,750 --> 00:47:35,120
ఆ ఒక్క మూలకం పూర్తిగా మొత్తం సార్టింగ్ నాశనం అన్నారు.

569
00:47:42,060 --> 00:47:44,030
>> ప్రశ్నలు?

570
00:47:49,480 --> 00:47:58,870
[విద్యార్థి] మీరు ఒక పునరావృత చర్య మరియు అది కేవలం పునరావృత కాల్స్ చేస్తే

571
00:47:58,870 --> 00:48:02,230
తిరిగి ప్రకటన లోపల, ఆ, తోక పునరావృత యొక్క

572
00:48:02,230 --> 00:48:07,360
అందువలన, రన్టైమ్ సమయంలో అధిక మెమరీ ఉపయోగించడానికి కాదు

573
00:48:07,360 --> 00:48:12,550
ఒక పరిష్కారం పునరుత్థాన వంటి లేదా కనీసం పోల్చదగిన మెమరీ ఉపయోగించే?

574
00:48:12,550 --> 00:48:14,530
[బౌడెన్] అవును.

575
00:48:14,530 --> 00:48:19,840
ఉండవచ్చు కొంతవరకు నెమ్మదిగా కాదు, కానీ నిజంగా. చేస్తుంది

576
00:48:19,840 --> 00:48:23,290
పునరావృత తోక ప్రెట్టి గుడ్ ఉంది.

577
00:48:23,290 --> 00:48:32,640
స్టాక్ ఫ్రేములు తిరిగి గురించి, లెట్స్ మేము ప్రధాన ఉన్నాయి, అవి

578
00:48:32,640 --> 00:48:42,920
మరియు మేము Int బార్ (Int x) లేదా ఏదైనా కలిగి.

579
00:48:42,920 --> 00:48:52,310
ఈ పరిపూర్ణ పునరావృత క్రియ కాదు, కానీ తిరిగి బార్ (x - 1).

580
00:48:52,310 --> 00:48:57,620
కాబట్టి సహజంగా, ఈ పొరపాట్లు. మీరు బేస్ కేసులు మరియు stuff అవసరం.

581
00:48:57,620 --> 00:49:00,360
కానీ ఇక్కడ ఆలోచన, ఈ పునరావృత తోక ఉంటుంది

582
00:49:00,360 --> 00:49:06,020
అది దాని స్టాక్ ఫ్రేమ్ పరుచుట కొరకు ఉన్నప్పుడు ప్రధాన కాల్స్ బార్ అర్థం.

583
00:49:09,550 --> 00:49:12,440
ఈ స్టాక్ ఫ్రేమ్ లో మెమరీ తక్కువ బ్లాక్ ఉన్నట్లు జరగబోతోంది

584
00:49:12,440 --> 00:49:17,490
దాని వాదన x సూచించదు.

585
00:49:17,490 --> 00:49:25,840
కాబట్టి లెట్స్ ప్రధాన బార్ (100) కాల్ ఏమవుతుంది say;

586
00:49:25,840 --> 00:49:30,050
కాబట్టి x 100 ప్రారంభించాలని అన్నారు.

587
00:49:30,050 --> 00:49:35,660
కంపైలర్ ఈ, ఒక తోక పునరావృత విధి అని శోధిస్తే

588
00:49:35,660 --> 00:49:38,540
బార్, దాని పునరావృత కాల్ బార్ చేస్తుంది అప్పుడు

589
00:49:38,540 --> 00:49:45,490
బదులుగా స్టాక్ ఎక్కువగా పెరుగుతున్న ప్రారంభిస్తారు ఇది ఒక కొత్త స్టాక్ ఫ్రేమ్, తయారీ,

590
00:49:45,490 --> 00:49:48,220
చివరికి అది కుప్ప ఆకస్మికంగా మరియు మీరు segfaults పొందండి

591
00:49:48,220 --> 00:49:51,590
మెమరీ గుద్దుకునే మొదలవుతుంది ఎందుకంటే.

592
00:49:51,590 --> 00:49:54,830
>> బదులుగా తన స్వంత స్టాక్ ఫ్రేమ్ చేయడానికి కాబట్టి, ఇది గుర్తించడం చేయవచ్చు

593
00:49:54,830 --> 00:49:59,080
హే, నేను నిజంగా, ఈ స్టాక్ ఫ్రేమ్ తిరిగి రావాలి ఎప్పుడూ

594
00:49:59,080 --> 00:50:08,040
కాబట్టి బదులుగా నేను 99 తో ఈ వాదన స్థానంలో మరియు తరువాత బార్ పై ప్రారంభించగలరు.

595
00:50:08,040 --> 00:50:11,810
, - (1 x) మరియు తర్వాత మళ్లీ ఇది చేస్తుంది మరియు అది తిరిగి బార్ చేరుకుంటుంది

596
00:50:11,810 --> 00:50:17,320
మరియు బదులుగా ఒక కొత్త స్టాక్ ఫ్రేమ్ తయారు చేసే అది కలిసి 98 దాని ప్రస్తుత వాదన భర్తీ చేస్తుంది

597
00:50:17,320 --> 00:50:20,740
ఆపై బార్ ప్రారంభం తిరిగి వెళ్ళు.

598
00:50:23,860 --> 00:50:30,430
ఆ కార్యకలాపాలను, స్టాక్ ఆ 1 విలువ స్థానంలో మరియు ప్రారంభంలో తిరిగి ఎగరడం,

599
00:50:30,430 --> 00:50:32,430
అందంగా సామర్థ్యాన్ని కలిగి ఉంటాయి.

600
00:50:32,430 --> 00:50:41,500
కాబట్టి కేవలం ఈ పద్దతి ఒక ప్రత్యేక ఫంక్షన్ అదే స్మృతి వాడకం ఉంది

601
00:50:41,500 --> 00:50:45,390
మీరు మాత్రమే 1 స్టాక్ ఫ్రేమ్ ఉపయోగించే, కానీ మీరు దుష్ప్రభావాలు బాధ లేదు ఎందుకంటే

602
00:50:45,390 --> 00:50:47,240
కాల్ ప్రమేయాలు అవసరం యొక్క.

603
00:50:47,240 --> 00:50:50,240
అది ఈ సెటప్ చేయాలి ఎందుకంటే కాలింగ్ విధులు కొంతవరకు ఖరీదైనది కావచ్చు

604
00:50:50,240 --> 00:50:52,470
మరియు teardown మరియు ఈ విషయం.

605
00:50:52,470 --> 00:50:58,160
కాబట్టి ఈ తోక సూత్రం మంచిదే.

606
00:50:58,160 --> 00:51:01,170
[విద్యార్థి] ఎందుకు కొత్త విధానాలను రూపొందించడానికి లేదు?

607
00:51:01,170 --> 00:51:02,980
అది గుర్తిస్తాడు ఎందుకంటే అది అవసరం లేదు.

608
00:51:02,980 --> 00:51:07,800
బార్ పిలుపు కేవలం పునరావృత కాల్ తిరిగి.

609
00:51:07,800 --> 00:51:12,220
కాబట్టి అది తిరిగి విలువ ఏమీ చేయాల్సిన అవసరం లేదు.

610
00:51:12,220 --> 00:51:15,120
ఇది కేవలం వెంటనే తిరిగి వెళుతున్న.

611
00:51:15,120 --> 00:51:20,530
కాబట్టి ఇది దాని స్వంత వాదన స్థానంలో మరియు పైగా ఆరంభమవుతుంది.

612
00:51:20,530 --> 00:51:25,780
మరియు, మీరు తోక పునరావృత వెర్షన్ లేకపోతే,

613
00:51:25,780 --> 00:51:31,460
అప్పుడు మీరు ఈ బార్ వచ్చినప్పడు అన్ని ఈ బార్లు పొందండి

614
00:51:31,460 --> 00:51:36,010
ఇది బార్ వెంటనే తిరిగి ఆ తర్వాత, ఈ ఒక దాని విలువ తిరిగి ఉంది

615
00:51:36,010 --> 00:51:39,620
మరియు ఈ ఒక దాని విలువ తిరిగి, అది కేవలం వెంటనే తిరిగి వెళుతున్న

616
00:51:39,620 --> 00:51:41,350
మరియు ఈ ఒక దాని విలువ తిరిగి.

617
00:51:41,350 --> 00:51:45,350
కాబట్టి మీరు స్టాక్ ఈ విషయాలను అన్నింటిని పాపింగ్ ఈ సేవ్ చేస్తున్న

618
00:51:45,350 --> 00:51:48,730
తిరిగి విలువ ఎలాగైనా తిరిగి అన్ని మార్గం జరిగింది కావడం వలన.

619
00:51:48,730 --> 00:51:55,400
ఎందుకు కేవలం నవీకరించబడింది వాదన మన వాదన స్థానంలో, ప్రారంభించవచ్చు లేదా?

620
00:51:57,460 --> 00:52:01,150
- మీ వంటి ఏదో ఒకటి ఉంటే ఫంక్షన్, తోక పునరావృత లేకపోతే

621
00:52:01,150 --> 00:52:07,530
[విద్యార్థి] ఉంటే బార్ (x + 1). >> అవును.

622
00:52:07,530 --> 00:52:11,770
>> మీరు పరిస్థితిలో ఉంచారు కాబట్టి, మీరు తిరిగి విలువ ఏదో చేయుచున్నారు.

623
00:52:11,770 --> 00:52:16,260
లేదా మీరు తిరిగి 2 పోయినా * బార్ (x - 1).

624
00:52:16,260 --> 00:52:23,560
కాబట్టి ఇప్పుడు బార్ - 2 సార్లు విలువ లెక్కించేందుకు కోసం (x 1), క్రమంలో తిరిగి కావాలి

625
00:52:23,560 --> 00:52:26,140
కాబట్టి ఇప్పుడు, సొంత ప్రత్యేక స్టాక్ ఫ్రేమ్ అవసరం లేదు

626
00:52:26,140 --> 00:52:31,180
మరియు ఇప్పుడు, మీరు ప్రయత్నించండి ఎలా హార్డ్ ఉన్నా, మీరు అవసరం చూడాలని -

627
00:52:31,180 --> 00:52:34,410
ఈ పునరావృత తోక కాదు.

628
00:52:34,410 --> 00:52:37,590
[విద్యార్థి] నేను తోక సూత్రం కోసం ప్రయత్నించవచ్చు ఒక సూత్రం తీసుకుని ప్రయత్నిస్తాయి -

629
00:52:37,590 --> 00:52:41,450
[బౌడెన్] ఆదర్శవంతమైన ప్రపంచంలో, కాని CS50 మీకు లేదు.

630
00:52:43,780 --> 00:52:49,280
తోక సూత్రం పొందటానికి, సాధారణంగా, మీరు అదనపు వాదన ఏర్పాటు

631
00:52:49,280 --> 00:52:53,550
బార్ Y లోకి Int x పడుతుంది పేరు

632
00:52:53,550 --> 00:52:56,990
మరియు y మీరు తిరిగి కావలసిన అల్టిమేట్ విషయం సూచించదు.

633
00:52:56,990 --> 00:53:03,650
(- 1 x), 2 * Y కాబట్టి ఈ మీరు బార్ తిరిగి చూడాలని.

634
00:53:03,650 --> 00:53:09,810
కేవలం కాబట్టి ఒక ఉన్నత స్థాయి మీరు విషయాలు తోక పునరావృత అని అనుకరిస్తే ఎలా.

635
00:53:09,810 --> 00:53:13,790
కానీ అదనపు వాదన -

636
00:53:13,790 --> 00:53:17,410
మరియు తర్వాత చివరికి మీ బేస్ కేసు చేరినపుడు, మీరు Y తిరిగి

637
00:53:17,410 --> 00:53:22,740
మీరు మొత్తం సమయాన్ని మీకు కావలసిన తిరిగి విలువ పొందుపరచబడుతున్న చేసిన ఎందుకంటే.

638
00:53:22,740 --> 00:53:27,280
యొక్క మీరు రకమైన పునరుత్ధాన ఇది చేయడం కానీ పునరావృత కాల్స్ ఉపయోగిస్తున్నాము.

639
00:53:32,510 --> 00:53:34,900
ప్రశ్నలు?

640
00:53:34,900 --> 00:53:39,890
తీగలు ఉపయోగించి విధంగా ఉండవచ్చు అంక గణితానికి గురించి [విద్యార్థి]. >> ఖచ్చితంగా.

641
00:53:39,890 --> 00:53:43,610
పాయింటర్ అంకగణితం.

642
00:53:43,610 --> 00:53:48,440
తీగలను చార్ నక్షత్రాలు ఎందుకంటే తీగలు ఉపయోగించి అది, సులభం

643
00:53:48,440 --> 00:53:51,860
అక్షరాలు, ఎప్పటికీ మరియు ఎల్లప్పుడూ ఒకే బైట్ ఉంటాయి

644
00:53:51,860 --> 00:53:57,540
అందువలన అంక గణితానికి మీరు తీగలను వ్యవహరించే చేసినప్పుడు సాధారణ అంకగణిత సమానం.

645
00:53:57,540 --> 00:54:08,790
లెట్ యొక్క కేవలం చార్ * s = "హలో" అని.

646
00:54:08,790 --> 00:54:11,430
కాబట్టి మేము మెమరీ ఒక బ్లాక్ ఉంటాయి.

647
00:54:19,490 --> 00:54:22,380
మీరు ఎల్లప్పుడూ శూన్య టెర్మినేటర్ అవసరం ఎందుకంటే ఇది 6 బైట్లు కావాలి.

648
00:54:22,380 --> 00:54:28,620
మరియు చార్ * s ఈ శ్రేణి యొక్క ప్రారంభానికి పాయింటు అన్నారు.

649
00:54:28,620 --> 00:54:32,830
కాబట్టి s అక్కడ చూపాడు.

650
00:54:32,830 --> 00:54:36,710
ఇప్పుడు, ఈ, ప్రధానంగా ఏ శ్రేణి ఎలా పని ఉంది

651
00:54:36,710 --> 00:54:40,780
లేకుండా malloc ద్వారా లేదా స్టాక్ మీద కావచ్చు తిరిగి అని యొక్క.

652
00:54:40,780 --> 00:54:47,110
ఏదైనా శ్రేణి, ప్రధానంగా శ్రేణి యొక్క ప్రారంభ ఒక పాయింటర్ గా

653
00:54:47,110 --> 00:54:53,640
మరియు తర్వాత ఏ శ్రేణి ఆపరేషన్, ఏ ఇండెక్సింగ్, కేవలం కొన్ని ఆఫ్సెట్ ఆ శ్రేణి లో అన్నారు.

654
00:54:53,640 --> 00:55:05,360
>> నేను s [3] వంటి ఏదైనా చెప్పండి ఉన్నప్పుడు; ఈ s వెళ్లి సైన్ 3 అక్షరాలు లెక్కింపు ఉంటుంది

655
00:55:05,360 --> 00:55:12,490
కాబట్టి s [3], మేము 0 కలిగి, 1, 2, 3, కాబట్టి s [3] ఈ l చూడండి అన్నారు.

656
00:55:12,490 --> 00:55:20,460
[విద్యార్థి] మరియు మేము s + 3 చేయడం మరియు తర్వాత కుండలీకరణాలు నటుడు అదే విలువ చేరగలిగింది?

657
00:55:20,460 --> 00:55:22,570
అవును.

658
00:55:22,570 --> 00:55:26,010
ఈ * (s + 3) కు సమానంగా చెప్పవచ్చు;

659
00:55:26,010 --> 00:55:31,240
మరియు ఆ ఎప్పటికీ మరియు ఎల్లప్పుడూ సమానంగా మీరు ఏ విషయం.

660
00:55:31,240 --> 00:55:34,070
మీరు బ్రాకెట్ సింటాక్స్ ఉపయోగించడానికి అవసరం లేదు.

661
00:55:34,070 --> 00:55:37,770
మీరు ఎల్లప్పుడూ (s + 3) సింటాక్స్ * ఉపయోగించవచ్చు.

662
00:55:37,770 --> 00:55:40,180
ప్రజలు అయితే, బ్రాకెట్ సింటాక్స్ ఇష్టం ఉంటాయి.

663
00:55:40,180 --> 00:55:43,860
[విద్యార్థి] కాబట్టి అన్ని శ్రేణుల కేవలం వాస్తవానికి గమనికలు ఉన్నాయి.

664
00:55:43,860 --> 00:55:53,630
నేను ఒక కొంచెం తేడా ఉంది Int x [4]; >> [విద్యార్థి] ఆ స్మృతి సృష్టించదు?

665
00:55:53,630 --> 00:56:03,320
[బౌడెన్] కానీ అలా 16 బైట్లు మొత్తం, స్టాక్ 4 ints సృష్టించడానికి అన్నారు.

666
00:56:03,320 --> 00:56:05,700
ఇది స్టాక్ మీద 16 బైట్లు సృష్టించడానికి జరగబోతోంది.

667
00:56:05,700 --> 00:56:09,190
x ఎక్కడైనా నిల్వ చెయ్యబడదు.

668
00:56:09,190 --> 00:56:13,420
ఇది కేవలం విషయం ప్రారంభాన్ని సూచిస్తూ గుర్తు.

669
00:56:13,420 --> 00:56:17,680
మీరు, ఈ ఫంక్షన్ లోపలి అమరిక ప్రకటించింది ఎందుకంటే

670
00:56:17,680 --> 00:56:22,340
కంపైలర్ చేయబోవడం ఏమి కేవలం చరరాశి X యొక్క అన్ని సందర్భాలలో స్థానంలో

671
00:56:22,340 --> 00:56:26,400
ఈ 16 బైట్లు ఉండడానికి ఎంచుకున్న జరిగింది పేరు తో.

672
00:56:26,400 --> 00:56:30,040
S అసలు పాయింటర్ ఎందుకంటే ఇది చార్ * s ఆ చెయ్యలేరు.

673
00:56:30,040 --> 00:56:32,380
తర్వాత ఇతర విషయాలు సూచించడానికి ఉచితం.

674
00:56:32,380 --> 00:56:36,140
x ఒక స్థిరాంకం. మీరు వేరొక శ్రేణి అది పాయింట్ ఉండకూడదు. >> [విద్యార్థి] సరే.

675
00:56:36,140 --> 00:56:43,420
కానీ ఈ ఆలోచన, ఈ ఇండెక్సింగ్, ఇది ఒక సాంప్రదాయ శ్రేణి కావచ్చు సంబంధం లేకుండా ఒకే ఉంది

676
00:56:43,420 --> 00:56:48,230
అది ఏదో లేదా ఒక పాయింటర్ అయితే లేదా ఒక malloced శ్రేణి ఒక పాయింటర్ ఉంది.

677
00:56:48,230 --> 00:56:59,770
నిజానికి, ఇది కూడా ఇదే అని తద్వారా సమానంగా ఉంటుంది.

678
00:56:59,770 --> 00:57:05,440
ఇది నిజానికి పరిధుల లోపల ఏమి అనువాదం మరియు, బ్రాకెట్లలో మిగిలిన

679
00:57:05,440 --> 00:57:07,970
వాటిని కలిసి జతచేస్తుంది, మరియు dereferences.

680
00:57:07,970 --> 00:57:14,710
కాబట్టి ఈ మాదిరిగా చెల్లదు * (s + 3) లేదా s [3].

681
00:57:16,210 --> 00:57:22,090
[విద్యార్థి] మీరు 2 డైమెన్షనల్ శ్రేణుల సూచించే గమనికలు ఉంటుందా?

682
00:57:22,090 --> 00:57:27,380
>> ఇది కష్టం. సాంప్రదాయకంగా, ఏ.

683
00:57:27,380 --> 00:57:34,720
ఒక 2 డైమెన్షనల్ శ్రేణి కొన్ని అనుకూలమైన సిన్టాక్సుతో ఒక 1 డైమెన్షనల్ శ్రేణి

684
00:57:34,720 --> 00:57:54,110
ఎందుకంటే నేను ఎప్పుడు Int x [3] [3], ఇది నిజంగా 9 విలువలతో కేవలం 1 శ్రేణి.

685
00:57:55,500 --> 00:58:03,000
కాబట్టి నేను ఇండెక్స్, కంపైలర్ వాట్ ఐ మీన్ తెలుసు ఉన్నప్పుడు.

686
00:58:03,000 --> 00:58:13,090
నేను x [1] [2], నేను రెండవ వరుసలో కు వెళ్లాలని మీరు అనుకుంటున్నారా తెలుసు, కాబట్టి ఇది మొదటి 3 skip అవకాశముంది, చెప్పినట్టైతే

687
00:58:13,090 --> 00:58:17,460
తరువాత, చాలా ఈ ఒక పరుచుట కొరకు ఆ రెండవ విషయం కోరుకుంటున్నారు.

688
00:58:17,460 --> 00:58:20,480
కాని ఇప్పటికీ కేవలం ఒకే పరిమాణాల శ్రేణి.

689
00:58:20,480 --> 00:58:23,660
కాబట్టి నేను, ఆ శ్రేణి ఒక పాయింటర్ కేటాయించి కోరుకుంటే

690
00:58:23,660 --> 00:58:29,770
నేను Int * p = x;

691
00:58:29,770 --> 00:58:33,220
x యొక్క రకం కేవలం ఉంది -

692
00:58:33,220 --> 00:58:38,280
అది గుర్తు ఎందుకంటే x యొక్క కఠినమైన చెప్పడం రకం మరియు అది అసలైన వేరియబుల్ కాదు

693
00:58:38,280 --> 00:58:40,140
కానీ అది కేవలం ఒక పూర్ణాంకానికి * ఉంది.

694
00:58:40,140 --> 00:58:44,840
x ఈ ప్రారంభాన్ని ఒక పాయింటర్ ఉంది. >> [విద్యార్థి] సరే.

695
00:58:44,840 --> 00:58:52,560
కాబట్టి నేను [1] [2] ప్రాప్తి చేయడానికి చెయ్యలేరు.

696
00:58:52,560 --> 00:58:58,370
నేను, ప్రత్యేక వాక్యనిర్మాణ ఒక పాయింటర్ చాటి ఉంది అనుకుంటున్నాను

697
00:58:58,370 --> 00:59:12,480
Int వంటి హాస్యాస్పదంగా ఏదో (* p [-. పూర్తిగా నమ్మశక్యం నేను కూడా తెలియదు.

698
00:59:12,480 --> 00:59:17,090
కానీ కుండలీకరణాలు మరియు వస్తువులు వంటి గమనికలు ప్రకటించారు కోసం ఒక సింటాక్స్ ఉంది.

699
00:59:17,090 --> 00:59:22,960
ఇది కూడా మీరు ఆ తెలియజేసేలా కాదు.

700
00:59:22,960 --> 00:59:26,640
నా నిజం చెప్పాలంటే దానిని తిరిగి కనిపించాలి.

701
00:59:26,640 --> 00:59:34,160
పాయింట్ ఒక సింటాక్స్ లేకపోతే నేను, తర్వాత అది కోసం కనిపిస్తుంది. కానీ మీరు చూడరు.

702
00:59:34,160 --> 00:59:39,670
మరియు కూడా వాక్యనిర్మాణం మీరు ఉపయోగిస్తే, ప్రజలు అడ్డుపడిన చేయబడుతుంది కాబట్టి ప్రాచీనమైనది.

703
00:59:39,670 --> 00:59:43,540
ఇది వంటి వివిధ పరిమాణాల శ్రేణుల అందంగా అరుదు.

704
00:59:43,540 --> 00:59:44,630
చాలా చక్కని మీరు -

705
00:59:44,630 --> 00:59:48,490
మీరు మాతృక పనులను చేస్తున్నారు ఉంటే సరే,, అరుదుగా మాత్రం కాదు

706
00:59:48,490 --> 00:59:56,730
కానీ సి లో మీరు అరుదుగా బహుమితీయ వ్యూహాన్ని ఉపయోగిస్తాయి కావడం చేస్తున్నారు.

707
00:59:57,630 --> 01:00:00,470
అవును. >> [విద్యార్థి] మీరు ఒక నిజంగా దీర్ఘ శ్రేణి కలిగి చెప్పారు.

708
01:00:00,470 --> 01:00:03,900
>> కాబట్టి కాల్పనిక స్మృతి లో, అన్ని వరుస కనిపిస్తుంది

709
01:00:03,900 --> 01:00:05,640
ప్రతి ఇతర హక్కు తదుపరి మూలకాలను వంటి,

710
01:00:05,640 --> 01:00:08,770
కానీ భౌతిక మెమొరీ లో, దానిని విభజించబడింది ఆ సాధ్యమవుతుంది? >> అవును.

711
01:00:08,770 --> 01:00:16,860
మెమరీ ఎలా పనిచేస్తుందనే వర్చ్యువల్ ఇది వేరు -

712
01:00:19,220 --> 01:00:24,860
కేటాయింపు యూనిట్ 4 లు ఉంటుంది ఒక పేజీ, ఇది

713
01:00:24,860 --> 01:00:29,680
అందువలన ఒక ప్రక్రియ చెప్పినప్పుడు, హే, నేను, ఈ మెమరీ ఉపయోగించాలనుకుంటున్నాను

714
01:00:29,680 --> 01:00:35,970
ఆపరేటింగ్ సిస్టమ్ అది మెమొరీ ఆ చిన్న బ్లాక్ కోసం 4 లు కేటాయించాలని అన్నారు.

715
01:00:35,970 --> 01:00:39,100
మీరు మాత్రమే మెమరీ మొత్తం బ్లాక్ లో ఒక చిన్న బైట్, ఉపయోగించడానికి కూడా

716
01:00:39,100 --> 01:00:42,850
ఆపరేటింగ్ సిస్టమ్ అది పూర్తి 4 లు ఇవ్వాలని అన్నారు.

717
01:00:42,850 --> 01:00:49,410
కాబట్టి ఈ పధ్ధతి నేను కలిగి - ఈ నా స్టాక్ అంటారు లెట్స్.

718
01:00:49,410 --> 01:00:53,180
ఈ స్టాక్ వేరు చేయబడింది. నా స్టాక్ మెగాబైట్ల మరియు మెగాబైట్ల ఉంటుంది.

719
01:00:53,180 --> 01:00:55,020
నా స్టాక్ భారీ ఉంటుంది.

720
01:00:55,020 --> 01:01:00,220
కానీ స్టాక్ స్వయంగా ఒక్కొక్క పేజీ విభజించబడింది ఉంటుంది

721
01:01:00,220 --> 01:01:09,010
ఈ మా RAM అంటారు మేము ఇక్కడ పైగా చూస్తే ఇది లెట్స్,

722
01:01:09,010 --> 01:01:16,600
నేను RAM యొక్క 2 గిగాబైట్ల ఉంటే, ఈ, నా RAM యొక్క జేరోయేత్ బైట్ వంటి వాస్తవ చిరునామా 0

723
01:01:16,600 --> 01:01:22,210
మరియు ఈ ఇక్కడ 2 గిగాబైట్ల అన్ని మార్గం డౌన్.

724
01:01:22,210 --> 01:01:27,230
కాబట్టి ఈ పేజీ ఇక్కడ ఈ బ్లాక్ అనుగుణంగా ఉండవచ్చు.

725
01:01:27,230 --> 01:01:29,400
ఈ పేజీకి ఇక్కడ ఈ బ్లాక్ అనుగుణంగా ఉండవచ్చు.

726
01:01:29,400 --> 01:01:31,560
ఈ ఒక ఇక్కడ ఈ ఒక అనుగుణంగా ఉండవచ్చు.

727
01:01:31,560 --> 01:01:35,540
ఆపరేటింగ్ సిస్టమ్ భౌతికంగా మెమరీ కేటాయించి ఉచిత కనుక

728
01:01:35,540 --> 01:01:39,320
ఏకపక్ష ఏ వ్యక్తి పేజీకి.

729
01:01:39,320 --> 01:01:46,180
మరియు అని ఈ సరిహద్దు వ్యూహం నడిపే జరిగితే,

730
01:01:46,180 --> 01:01:50,070
ఒక వరుస ఈ యొక్క ఎడమ నిర్మాణము మరియు కుడి ఒక పేజీ యొక్క ఈ ఆర్డర్

731
01:01:50,070 --> 01:01:54,460
ఆ శ్రేణి భౌతిక మెమొరీ లో విభజించబడింది అన్నారు.

732
01:01:54,460 --> 01:01:59,280
ప్రక్రియ ముగిసిన తరువాత ఆపై మీరు, ప్రోగ్రామ్ నిష్క్రమించినప్పుడు,

733
01:01:59,280 --> 01:02:05,690
ఈ లను మాసిపోయిన పొందండి మరియు అప్పుడు అది ఇతర విషయాల కోసం ఈ చిన్న బ్లాక్లను ఉపయోగించడానికి ఉచితం.

734
01:02:14,730 --> 01:02:17,410
మరిన్ని ప్రశ్నలు?

735
01:02:17,410 --> 01:02:19,960
[విద్యార్థి] అంక గణితానికి. >> అవును.

736
01:02:19,960 --> 01:02:28,410
స్ట్రింగ్స్, సులువుగా ఉంటాయి కానీ ints వంటి ఏదో చూడటం

737
01:02:28,410 --> 01:02:35,000
కాబట్టి తిరిగి Int x [4];

738
01:02:35,000 --> 01:02:41,810
ఈ వ్యూహం ఉందా లేదా 4 పూర్ణాంకాల యొక్క malloced శ్రేణి ఒక పాయింటర్ కావచ్చు

739
01:02:41,810 --> 01:02:47,060
అది అదే విధంగా చికిత్స జరగబోతోంది.

740
01:02:50,590 --> 01:02:53,340
కాబట్టి శ్రేణుల కుప్ప న [విద్యార్థి] ఉంటాయి?

741
01:03:01,400 --> 01:03:05,270
[బౌడెన్] వ్యూహాలను కుప్ప లేదు. >> [విద్యార్థి] ఓహ్.

742
01:03:05,270 --> 01:03:08,320
>> [బౌడెన్] శ్రేణి యొక్క ఈ రకం స్టాక్ మీద ఉంటుంది

743
01:03:08,320 --> 01:03:12,220
తప్ప మీరు వద్ద ప్రకటించింది - ప్రపంచ వేరియబుల్స్ విస్మరించడం. ప్రపంచ వేరియబుల్స్ ఉపయోగించకండి.

744
01:03:12,220 --> 01:03:16,280
నేను ఒక ఫంక్షన్ యొక్క ఇన్సైడ్ Int x [4];

745
01:03:16,280 --> 01:03:22,520
ఈ శ్రేణి కోసం స్టాక్ లో 4 పూర్ణసంఖ్యలు బ్లాక్ సృష్టించడానికి జరగబోతోంది.

746
01:03:22,520 --> 01:03:26,960
కానీ ఈ malloc (4 * sizeof (Int)); కుప్ప మీద వెళ్ళి అన్నారు.

747
01:03:26,960 --> 01:03:31,870
కానీ ఈ పాయింట్ తరువాత నేను, చాలా చక్కని అదే విధాలుగా x మరియు p ఉపయోగించవచ్చు

748
01:03:31,870 --> 01:03:36,140
మీరు p ఉంచేందుకు చేయవచ్చు గురించి ముందు నేను అన్నాడు మినహాయింపులు కంటే ఇతర.

749
01:03:36,140 --> 01:03:40,960
సాంకేతికంగా వారి పరిమాణాలు కొంతవరకు భిన్నంగా ఉంటాయి, అయితే పూర్తిగా అసంబద్ధం ఉంది.

750
01:03:40,960 --> 01:03:43,310
మీరు నిజంగా వాటి పరిమాణాన్ని ఎప్పుడూ ఉపయోగించవద్దు.

751
01:03:48,020 --> 01:03:56,810
నేను కాలేదు p p [3] = 2; లేదా x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
మీరు ఖచ్చితంగా అదే మార్గాల్లో వాటిని ఉపయోగించవచ్చు.

753
01:03:59,680 --> 01:04:01,570
ఇప్పుడు అంక గణితానికి - అవును.

754
01:04:01,570 --> 01:04:07,390
[విద్యార్థి] మీరు బ్రాకెట్లలో ఉంటే p * చేయడానికి లేదా?

755
01:04:07,390 --> 01:04:11,720
బ్రాకెట్లలో ఒక అవ్యక్త dereference ఉంటాయి. సరే >>.

756
01:04:11,720 --> 01:04:20,200
అసలైన, కూడా మీకు తో చెబుతున్న దాన్ని మీరు బహుమితీయ శ్రేణుల పొందవచ్చు

757
01:04:20,200 --> 01:05:02,650
గమనికలు తో, మీరు ఏమి చేయవచ్చు యొక్క అని పిలవబడు, ఏదో ఉంటుంది, Int ** పేజీలు = malloc (sizeof (Int *) * 5);

758
01:05:02,650 --> 01:05:06,900
నేను ఇవన్నీ మొదటి వ్రాయండి చేస్తాము.

759
01:05:37,880 --> 01:05:41,020
నేను ఒక కోరుకోలేదు.

760
01:05:41,020 --> 01:05:42,550
సరే.

761
01:05:42,550 --> 01:05:48,910
నేను ఇక్కడ ఏమి ఉంది - ఆ పేజీలు [i] ఉండాలి.

762
01:05:48,910 --> 01:05:53,680
కాబట్టి పేజీలు ఒక పాయింటర్ ఒక పాయింటర్ ఉంది.

763
01:05:53,680 --> 01:06:02,420
మీరు 5 Int నక్షత్రాలు యొక్క వ్యూహం సూచించడానికి పేజీలు mallocing చేస్తున్నారు.

764
01:06:02,420 --> 01:06:10,950
కాబట్టి మెమరీలో మీరు స్టాక్ పేజీలు కలిగి

765
01:06:10,950 --> 01:06:20,150
అన్ని గమనికలు తాము ఇవి 5 బ్లాక్స్ యొక్క వ్యూహం సూచించడానికి జరగబోతోంది.

766
01:06:20,150 --> 01:06:28,210
మరియు అప్పుడు ఇక్కడ నేను malloc డౌన్, నేను malloc ఆ వ్యక్తి గమనికలు ప్రతి

767
01:06:28,210 --> 01:06:32,080
కుప్ప మీద 4 బైట్లు యొక్క ఒక ప్రత్యేక బ్లాక్ సూచించడానికి ఉండాలి.

768
01:06:32,080 --> 01:06:35,870
4 బైట్లు కనుక ఈ పాయింట్లు.

769
01:06:37,940 --> 01:06:40,660
మరియు వేరొక 4 బైట్లు ఈ ఒక పాయింట్లు.

770
01:06:40,660 --> 01:06:43,200
>> మరియు వాటిని అన్ని వారి స్వంత 4 బైట్లు సూచించారు.

771
01:06:43,200 --> 01:06:49,080
ఈ నాకు బహుమితీయ పనులను ఒక మార్గాన్ని అందిస్తుంది.

772
01:06:49,080 --> 01:06:58,030
నేను పేజీలు [3] [4], అయితే ఇప్పుడు ఈ ఇదే కాదు వంటి బహుమితీయ శ్రేణుల చెప్పగల్గినవి

773
01:06:58,030 --> 01:07:05,390
బహుమితీయ శ్రేణుల అది అనువాదం ఎందుకంటే [3] [4] x శ్రేణి లోకి ఆఫ్సెట్ ఒక లోకి.

774
01:07:05,390 --> 01:07:14,790
ఈ dereferences p, dereferences తర్వాత, మూడవ సూచిక ప్రాప్తి చేయడానికి

775
01:07:14,790 --> 01:07:20,790
మరియు ప్రాప్తిని - 4 చెల్లని ఉంటుంది - రెండవ సూచిక.

776
01:07:24,770 --> 01:07:31,430
అయితే మేము ఉన్నప్పుడు Int x [3] [4] ఒక బహుమితీయ వ్యూహం ముందు

777
01:07:31,430 --> 01:07:35,740
మరియు మీరు బ్రాకెట్ డబుల్ అది, నిజంగా ఒకే dereference యొక్క

778
01:07:35,740 --> 01:07:40,490
, మీరు ఒక పాయింటర్ అనుసరిస్తున్నారు మరియు తరువాత ఒక ఆఫ్సెట్

779
01:07:40,490 --> 01:07:42,850
ఇది నిజంగా 2D సూచనలు ఉంది.

780
01:07:42,850 --> 01:07:45,840
మీరు 2 ప్రత్యేక గమనికలు అనుసరించండి.

781
01:07:45,840 --> 01:07:50,420
ఈ కూడా సాంకేతికంగా అనుమతిస్తుంది మీరు బహుమితీయ శ్రేణుల కలిగి

782
01:07:50,420 --> 01:07:53,550
ప్రతి వ్యక్తి శ్రేణి వివిధ పరిమాణాలు ఉంటుంది.

783
01:07:53,550 --> 01:07:58,000
నేను కత్తిరించిన బహుమితీయ శ్రేణుల దీనిని ఏమి భావిస్తే

784
01:07:58,000 --> 01:08:01,870
నిజంగా మొదటి విషయం 10 అంశాలను కలిగి ఏదో సూచించడానికి ఎందుకంటే,

785
01:08:01,870 --> 01:08:05,540
రెండవ విషయం 100 అంశాలను కలిగి ఏదో సూచించడానికి కాలేదు.

786
01:08:05,540 --> 01:08:10,790
[విద్యార్థి] మీరు కలిగి గమనికలు సంఖ్య ఏ పరిమితి లేదు

787
01:08:10,790 --> 01:08:14,290
ఇతర గమనికలు సూచించే? >> నం

788
01:08:14,290 --> 01:08:17,010
మీరు Int ***** p కలిగి ఉంటాయి.

789
01:08:18,050 --> 01:08:23,760
తిరిగి పాయింటర్ గణిత - >> [విద్యార్థి] ఓహ్. >> అవును.

790
01:08:23,760 --> 01:08:35,649
[విద్యార్థి] నేను Int *** p కలిగి మరియు ఉంటే నేను dereferencing చేయండి మరియు నేను p * ఈ విలువకు సమానంగా అంటారు,

791
01:08:35,649 --> 01:08:39,560
అది మాత్రమే dereferencing యొక్క 1 స్థాయి చేయండి ఉండబోతుంది? >> అవును.

792
01:08:39,560 --> 01:08:43,340
- నేను గత పాయింటర్ వద్ద సూచించబడిన ఆ విషయం యాక్సెస్ మీరు అనుకుంటే

793
01:08:43,340 --> 01:08:46,210
అప్పుడు మీరు *** p చేయండి. సరే >>.

794
01:08:46,210 --> 01:08:54,080
కాబట్టి ఈ 1 బ్లాక్, మరొక బ్లాక్ కు పాయింట్లు, మరొక బ్లాక్ కు పాయింట్లకు p పాయింట్లు.

795
01:08:54,080 --> 01:09:02,010
మీరు * లేకపోతే అప్పుడు p = ఏదో, అప్పుడు మీరు ఈ మారుస్తుంది

796
01:09:02,010 --> 01:09:13,640
ఇప్పుడు వేరే బ్లాక్ కు మార్చాలి. సరే >>.

797
01:09:13,640 --> 01:09:17,649
>> ఈ malloced ఒకవేళ [బౌడెన్] మరియు, మీరు ఇప్పుడు మెమరీ వెల్లడైంది చేశారు

798
01:09:17,649 --> 01:09:20,430
మీరు ఈ వివిధ సూచనలు కలిగి జరిగే తప్ప

799
01:09:20,430 --> 01:09:25,270
మీరు మీరు దూరంగా విసిరే దోజ్ వన్స్ తిరిగి పొందలేము నుండి.

800
01:09:25,270 --> 01:09:29,550
పాయింటర్ అంకగణితం.

801
01:09:29,550 --> 01:09:36,310
Int x [4]; 4 పూర్ణాంకాల యొక్క వ్యూహం కేటాయించాలని అన్నారు

802
01:09:36,310 --> 01:09:40,670
x అనునది యెరే యొక్క ప్రారంభానికి పాయింటు అన్నారు పేరు.

803
01:09:40,670 --> 01:09:50,420
కాబట్టి నేను x [1] వంటి ఏదైనా చెప్పండి; నేను శ్రేణి రెండవ పూర్ణాంక వెళ్ళండి అర్థం కావాలి,

804
01:09:50,420 --> 01:09:53,319
ఈ ఒకరు.

805
01:09:53,319 --> 01:10:04,190
ఈ ఇంటీజర్ 4 బైట్లు తీసుకుంటుంది కాబట్టి నిజంగా, ఆ శ్రేణి లో 4 బైట్లు ఉంది.

806
01:10:04,190 --> 01:10:08,470
1 యొక్క ఆఫ్సెట్ ఒక నిజంగా ఒక 1 యొక్క ఆఫ్సెట్ అని చెప్పుకుంటారు

807
01:10:08,470 --> 01:10:12,030
యెరే యొక్క రకం వస్తువు యొక్క రెట్లు.

808
01:10:12,030 --> 01:10:17,170
ఈ పూర్ణాంకాల యొక్క వ్యూహం, కాబట్టి అది ఆఫ్సెట్ చేసినప్పుడు అది Int యొక్క 1 సార్లు పరిమాణం చేయడానికి తెలుసు.

809
01:10:17,170 --> 01:10:25,260
ఇతర సింటాక్స్. ఈ * (x + 1) కు సమానమైన అని గుర్తుంచుకోండి;

810
01:10:25,260 --> 01:10:35,250
నేను పాయింటర్ దాన్ని తిరిగి పాయింటర్ నిల్వ ఆ చిరునామా + 1, చెప్పినప్పుడు

811
01:10:35,250 --> 01:10:40,360
ప్లస్ 1 సార్లు పాయింటర్ రకం పరిమాణం.

812
01:10:40,360 --> 01:10:59,510
అయితే x = ox100, అప్పుడు x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
మరియు మీరు ఈ దుర్వినియోగం మరియు ఏదో చెప్పగలను చార్ వంటి * c = (చార్ *) x;

814
01:11:19,750 --> 01:11:23,050
మరియు ఇప్పుడు C x అదే చిరునామా అన్నారు.

815
01:11:23,050 --> 01:11:26,040
సి, ox100 సమానంగా అన్నారు

816
01:11:26,040 --> 01:11:31,490
కానీ సి + 1 ox101 సమానంగా అన్నారు

817
01:11:31,490 --> 01:11:38,030
అంక గణితానికి మీరు జోడించడం ఉంటాయి పాయింటర్ బట్టి మారుతుంది నుండి.

818
01:11:38,030 --> 01:11:45,390
కాబట్టి సి + 1, అది సి వద్ద ఉంది, ఇది ఒక చార్ పాయింటర్, కనుక ఇది చార్ యొక్క 1 సార్లు పరిమాణం జోడించడానికి జరగబోతోంది

819
01:11:45,390 --> 01:11:48,110
, ఇది ఎల్లప్పుడూ 1 కానుంది, కాబట్టి మీరు 101 పొందండి

820
01:11:48,110 --> 01:11:54,890
నేను ఇప్పటికీ కూడా 100, x, లేకపోతే, x + 1 104 మాత్రం ఉంటుంది.

821
01:11:56,660 --> 01:12:06,340
[విద్యార్థి] మీరు సి + + 1 మీ పాయింటర్ ముందుకెళ్లేందుకు ఉపయోగించవచ్చా?

822
01:12:06,340 --> 01:12:09,810
అవును, మీరు చెయ్యగలరు.

823
01:12:09,810 --> 01:12:16,180
X కేవలం గుర్తు ఎందుకంటే మీరు x తో అలా కాదు, ఇది ఒక స్థిరాంకం; మీరు x మార్చలేరు.

824
01:12:16,180 --> 01:12:22,610
>> కానీ సి ఒక పాయింటర్ ఉంటుంది, కాబట్టి సి + + ఖచ్చితంగా చెల్లుతుంది మరియు 1 పెంచడం కనిపిస్తుంది.

825
01:12:22,610 --> 01:12:32,440
సి కేవలం ఒక పూర్ణాంకానికి *, అప్పుడు సి + + 104 చేస్తుంది.

826
01:12:32,440 --> 01:12:41,250
+ + చేస్తుంది అంక గణితానికి కేవలం సి + 1 అంక గణితానికి పూర్తి చేస్తుంది ఉన్నాయి.

827
01:12:43,000 --> 01:12:48,870
ఈ నిజానికి విలీనంతో విధమైన వంటి విషయాలను ఎలా చాలా ఉంది -

828
01:12:49,670 --> 01:12:55,710
బదులుగా విషయాలను కాపీలు సృష్టించే, మీరు బదులుగా ప్రసారమవుతుంది -

829
01:12:55,710 --> 01:13:02,400
ఈ కొన్ని వేయండి చూద్దాం - నేను శ్రేణి యొక్క ఈ సగం పాస్ కోరుకుంటే ఇష్టపడుతున్నారు.

830
01:13:04,770 --> 01:13:10,520
లెట్ యొక్క నేను ఒక ఫంక్షన్ లో శ్రేణిని ఈ వైపు పాస్ అనుకున్నారు చెప్పారు.

831
01:13:10,520 --> 01:13:12,700
నేను ఆ ఫంక్షన్ కు చేరుతుందని?

832
01:13:12,700 --> 01:13:17,050
నేను x పాస్ ఉంటే, నేను ఈ చిరునామా ప్రయాణిస్తున్న am.

833
01:13:17,050 --> 01:13:23,780
కానీ నేను ఈ నిర్దిష్ట చిరునామా పాస్ కోరుకుంటున్నాను. నేను ఏమి పాస్ చేయాలి?

834
01:13:23,780 --> 01:13:26,590
[విద్యార్థి] పాయింటర్ + 2?

835
01:13:26,590 --> 01:13:29,350
[బౌడెన్] కాబట్టి x + 2. అవును.

836
01:13:29,350 --> 01:13:31,620
ఈ చిరునామా చేస్తాడు.

837
01:13:31,620 --> 01:13:42,810
మీరు కూడా చాలా తరచుగా ఇది చూస్తారు x [2] మరియు ఆ యొక్క చిరునామా.

838
01:13:42,810 --> 01:13:47,850
కాబట్టి మీరు బ్రాకెట్ ఒక అవ్యక్త dereference ఎందుకంటే అది యొక్క చిరునామా తీసుకోవాలి.

839
01:13:47,850 --> 01:13:53,250
x [2], ఈ బాక్స్ లో అని విలువను సూచిస్తుంది, మరియు అప్పుడు మీరు ఆ బాక్స్ చిరునామా కావాలా

840
01:13:53,250 --> 01:13:56,850
కాబట్టి మీరు చెప్పే & x [2].

841
01:13:56,850 --> 01:14:02,880
తద్వారా మీరు ఏదో సగం జాబితా పాస్ చోట కలిసే విధమైన లో ఎలా సమ్థింగ్ '

842
01:14:02,880 --> 01:14:08,790
మీరు నిజంగా కేవలం PASS & x [2], మరియు ఇప్పుడు చాలా పునరావృత కాల్ సంబంధించినంతవరకు,

843
01:14:08,790 --> 01:14:12,510
నా కొత్త సమాహారం ఉంది మొదలవుతుంది.

844
01:14:12,510 --> 01:14:15,130
చివరి నిమిషం ప్రశ్నలు.

845
01:14:15,130 --> 01:14:20,050
[విద్యార్థి] మేము ఒక ఆంపర్సండ్ చిహ్నం ఉంచండి లేదా లేకపోతే - ఏ అని? >> స్టార్?

846
01:14:20,050 --> 01:14:23,200
[విద్యార్థి] స్టార్. >> సాంకేతికంగా, dereference ఆపరేటర్లు, కానీ - >> [విద్యార్థి] Dereference.

847
01:14:23,200 --> 01:14:29,310
>> మేము స్టార్ లేదా ఒక ఆంపర్సండ్ చిహ్నం ఉంచవద్దు ఉంటే నేను y చెప్పుకోవాలంటే, ఏమి జరుగుతుందనే = x మరియు x ఒక పాయింటర్ గా?

848
01:14:29,310 --> 01:14:34,620
Y రకం ఏమిటి? >> [విద్యార్థి] నేను దాని పాయింటర్ 2 సే చేస్తాము.

849
01:14:34,620 --> 01:14:38,270
మీరు చెప్పడానికి అయితే y = x, ఇప్పుడు x మరియు y పాయింట్ ఇదే కు. >> ఇదే కు [విద్యార్థి] పాయింట్.

850
01:14:38,270 --> 01:14:45,180
మరియు x ఒక పూర్ణాంకానికి పాయింటర్ ఉంది? మీరు గమనికలు కేటాయించలేరు ఎందుకంటే >> ఇది ఫిర్యాదు చేశారు.

851
01:14:45,180 --> 01:14:46,540
[విద్యార్థి] సరే.

852
01:14:46,540 --> 01:14:51,860
మేము బాణాలు వాటిని డ్రా అయినప్పటికీ ఆ గమనికలు గుర్తుంచుకో,

853
01:14:51,860 --> 01:15:02,010
నిజంగా అన్ని వారు స్టోర్ - Int * x - నిజంగా అన్ని x నిల్వ, ox100 వంటిది

854
01:15:02,010 --> 01:15:06,490
ఇది మేము 100 వద్ద నిల్వ బ్లాక్ సూచించే వంటి ప్రాతినిధ్యం పొందుతున్నారు.

855
01:15:06,490 --> 01:15:19,660
నేను చెప్పినప్పుడు మీరు Int * Y = x; నేను y లోకి ox100 కాపీ చేస్తున్నాను,

856
01:15:19,660 --> 01:15:24,630
ఇది మేము కూడా ox100 సూచించే, Y వంటి చూడాలని.

857
01:15:24,630 --> 01:15:39,810
నేను ఉంటే Int i = (Int) x; అప్పుడు నేను ox100 యొక్క విలువ ఏ నిల్వ అన్నారు

858
01:15:39,810 --> 01:15:45,100
అది లోపల, కానీ ఇప్పుడు అది బదులుగా ఒక పాయింటర్ యొక్క పూర్ణాంకం వ్యాఖ్యానించబడింది చెప్పారు.

859
01:15:45,100 --> 01:15:49,310
కానీ మీరు తారాగణం అవసరం లేదంటే అది ఫిర్యాదు కనిపిస్తుంది.

860
01:15:49,310 --> 01:15:53,300
[విద్యార్థి] కాబట్టి మీరు నటింపచేయాలని అర్థం లేదు -

861
01:15:53,300 --> 01:16:00,290
అది y యొక్క x లేదా CASTING Int యొక్క Int కాస్టింగ్ ఉండబోతుంది?

862
01:16:00,290 --> 01:16:03,700
[బౌడెన్] ఏమిటి?

863
01:16:03,700 --> 01:16:07,690
[విద్యార్థి] సరే. ఈ కుండలీకరణాలు తర్వాత అక్కడ ఒక x లేదా అక్కడ ay ఉండబోతుంది?

864
01:16:07,690 --> 01:16:11,500
>> [బౌడెన్] గాని. x మరియు y సమానంగా ఉంటాయి. >> [విద్యార్థి] సరే.

865
01:16:11,500 --> 01:16:14,390
వారు రెండు పాయింటర్లు ఉన్నారు. >> అవును.

866
01:16:14,390 --> 01:16:21,050
[విద్యార్థి] కనుక ఇది పూర్ణాంక రూపంలో హెక్సాడెసిమల్ 100 నిల్వ చేస్తుంది? >> [బౌడెన్] అవును.

867
01:16:21,050 --> 01:16:23,620
కానీ ఇది సూచిస్తుంది వస్తువు యొక్క విలువ.

868
01:16:23,620 --> 01:16:29,940
[బౌడెన్] అవును. >> [విద్యార్థి] కాబట్టి పూర్ణాంక రూపంలో కేవలం చిరునామా. సరే.

869
01:16:29,940 --> 01:16:34,720
మీరు కొన్ని విచిత్రమైన కారణం కోరుకున్నారు, [బౌడెన్] ఉంటే

870
01:16:34,720 --> 01:16:38,900
మీరు ప్రత్యేకంగా గమనికలు వ్యవహరించే మరియు పూర్ణాంకాల తో వ్యవహరించే ఎప్పుడూ కాలేదు

871
01:16:38,900 --> 01:16:49,240
మరియు కేవలం Int * x = 0 లాగా.

872
01:16:49,240 --> 01:16:53,000
అప్పుడు మీరు అంక గణితానికి సంభవించే మొదలవుతుంది ఒకసారి నిజంగా గందరగోళం పొందగలిగిన చేస్తున్నారు.

873
01:16:53,000 --> 01:16:56,570
కాబట్టి వారు నిల్వ ఆ సంఖ్యలు అర్థరహితమని.

874
01:16:56,570 --> 01:16:58,940
మీరు వాటిని వివరించడంలో ముగుస్తుంది కేవలం ఎలా.

875
01:16:58,940 --> 01:17:02,920
నేను, ఒక పూర్ణాంకానికి ఒక పూర్ణాంకానికి * నుండి ox100 కాపీ ఉచిత ఉన్నాను

876
01:17:02,920 --> 01:17:07,790
బహుశా కాస్టింగ్ లేదు కోసం కోప్పడ్డాడు పొందగలిగిన you're - నేను కేటాయించి ఉచిత ఉన్నాను -

877
01:17:07,790 --> 01:17:18,160
నేను ఈ ఏకపక్ష Int * లోకి (Int *) ox1234 లాగ కేటాయించి ఉచిత ఉన్నాను.

878
01:17:18,160 --> 01:17:25,480
కాబట్టి ox123 చెల్లుబాటు అయ్యే ఒక మెమరీ చిరునామా వంటి & పీ మాత్రమే ఉంది.

879
01:17:25,480 --> 01:17:32,060
& పీ చాలా చక్కని ox123 అని ఏదో తిరిగి జరుగుతుంది.

880
01:17:32,060 --> 01:17:35,430
[విద్యార్థి] ఆ హెక్సాడెసిమల్ నుండి దశాంశ రూపం వెళ్ళడానికి నిజంగా చల్లని మార్గం,

881
01:17:35,430 --> 01:17:39,230
మీరు ఒక పాయింటర్ ఉంటే ఇష్టం మీరు ఒక పూర్ణాంకానికి గా నటించారు?

882
01:17:39,230 --> 01:17:44,860
[బౌడెన్] మీరు నిజంగా కేవలం printf వంటి ఉపయోగించి ముద్రించవచ్చు.

883
01:17:44,860 --> 01:17:50,300
లెట్ యొక్క నేను Int y = 100 కలిగి చెప్పారు.

884
01:17:50,300 --> 01:18:02,700
కాబట్టి printf (% d \ n - మీరు ఇప్పటికే తెలుసుకోవాలి వంటి - print that వంటి పూర్ణాంకం,% x.

885
01:18:02,700 --> 01:18:05,190
మేము దానిని హెక్సాడెసిమల్ గా ముద్రించండి చేస్తాము.

886
01:18:05,190 --> 01:18:10,760
కాబట్టి ఒక పాయింటర్, హెక్సాడెసిమల్ వంటి నిల్వ లేదు

887
01:18:10,760 --> 01:18:12,960
మరియు పూర్ణాంకం దశాంశ వంటి నిల్వ చెయ్యబడదు.

888
01:18:12,960 --> 01:18:14,700
అంతా బైనరీ అవుతుంది.

889
01:18:14,700 --> 01:18:17,950
ఇది మేము హెక్సాడెసిమల్ వంటి గమనికలు చూపుతున్నాయి మాత్రమే ఉంది

890
01:18:17,950 --> 01:18:23,260
మేము, ఈ 4-బైట్ బ్లాక్లలో విషయాలను అనుకుంటున్నాను ఎందుకంటే

891
01:18:23,260 --> 01:18:25,390
మరియు మెమరీ చిరునామాలు తెలిసిన ఉంటాయి.

892
01:18:25,390 --> 01:18:28,890
అది BF మొదలవుతుంది, అది స్టాక్ న నిర్మాణము, వంటి మమ్మల్ని.

893
01:18:28,890 --> 01:18:35,560
కాబట్టి ఇది హెక్సాడెసిమల్ వంటి గమనికలు మా వ్యాఖ్యానం ఉంది.

894
01:18:35,560 --> 01:18:39,200
సరే. ఏదైనా చివరి ప్రశ్నలు?

895
01:18:39,200 --> 01:18:41,700
>> మీరు ఏదైనా కలిగి ఉంటే నేను తర్వాత కొంతసేపు ఇక్కడే ఉంటాం.

896
01:18:41,700 --> 01:18:46,070
మరియు ఆ ముగింపు ఉంది.

897
01:18:46,070 --> 01:18:48,360
>> [విద్యార్థి] అవును! [చప్పట్లు]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]