1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [4 వ వారం కొనసాగిన]

2
00:00:02,310 --> 00:00:04,240
[డేవిడ్ J. మలన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:04,240 --> 00:00:07,290
[ఈ CS50 ఉంది. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> ఈ CS50, మరియు ఈ వారం 4 ముగింపు.

5
00:00:11,290 --> 00:00:14,030
కొన్ని మంచి వార్తలు మరియు కొన్ని చెడు వార్తలను కాబట్టి.

6
00:00:14,030 --> 00:00:26,240
సోమవారం సంఖ్య ఉపన్యాసం, ఏ సమస్య వచ్చే వారం సెట్. [విద్యార్థులు ప్రోత్సహిస్తున్నారు]

7
00:00:26,240 --> 00:00:28,680
మీరు ఈ వెళ్లి కౌంటీ ఇష్టం వెళ్ళి లేదు.

8
00:00:28,680 --> 00:00:31,590
కానీ మేము వచ్చే బుధవారం బదులుగా ఈ ఉన్నాయి,

9
00:00:31,590 --> 00:00:37,740
మరియు తరువాత శుక్రవారం మేము ట్రాక్ లో ఉండడానికి వీలుగా సిలబస్ 1 శుక్రవారం ఉపన్యాసం శాతం కూడా ఉంది.

10
00:00:37,740 --> 00:00:40,580
అయితే ప్రతి సాధారణ వంటి చిత్రీకరించారు చేయబడుతుంది, కాబట్టి ఆందోళన లేదు.

11
00:00:40,580 --> 00:00:44,100
>> మరియు సంబంధించిన మేము వారం యొక్క ముగింపు వైపు చేస్తాను ఏమి 0 క్విజ్ కు

12
00:00:44,100 --> 00:00:47,140
కోర్సు యొక్క హోమ్ cs50.net వివరణ న పోస్ట్

13
00:00:47,140 --> 00:00:50,160
అది మొదటి క్విజ్ విషయానికి వస్తే మీరు ఉండాలి అంచనాలను ఏ విధమైన.

14
00:00:50,160 --> 00:00:55,100
సాధారణంగా, దానిలో బహుళఐచ్చిక, నిజం తప్పుడు, చిన్న సమాధానం, చిన్న కోడింగ్ సమస్యలు ఉంటుంది.

15
00:00:55,100 --> 00:00:57,360
మీరు సమానమైన అమలు అంచనా కావడం లేదు

16
00:00:57,360 --> 00:01:00,030
మీరు ఒక pset న చూడండి ఒక సమస్య కారణంగా, ఇది మీరు కంప్యూటర్ కలిగి

17
00:01:00,030 --> 00:01:03,240
మరియు ఒక డీబగ్గర్ మరియు వంటి, కానీ చిన్న కోడింగ్ సమస్యలు ఉంటుంది.

18
00:01:03,240 --> 00:01:06,900
>> నిజానికి, CS50 క్విజ్లు దేనిని పొందడానికి ఉత్తమ గైడ్ వంటివి

19
00:01:06,900 --> 00:01:09,180
cs50.net వెళ్ళండి ఉంది,, క్విజ్ లింక్ వెళ్ళండి

20
00:01:09,180 --> 00:01:11,920
మరియు మీరు క్విజ్ యొక్క విలువ గత కొన్ని సంవత్సరాల చూడగలరు.

21
00:01:11,920 --> 00:01:16,600
జస్ట్ పాఠ్య ప్రణాళిక ఎప్పుడూ సంవత్సరాల అదే కాదు విషయాన్ని గ్రహించే.

22
00:01:16,600 --> 00:01:18,510
కొన్నిసార్లు మేము కొన్నిసార్లు తీసివేయడం, జోడించండి

23
00:01:18,510 --> 00:01:20,670
ఆ పాత క్విజ్లు ఒకటి కొన్ని టాపిక్ చూడండి అయితే

24
00:01:20,670 --> 00:01:25,380
మీరు దాని గురించి మాట్లాడుతూ ఉంటాడు ఏ ఆలోచన కలిగి, అది కవర్ అని గాని యొక్క

25
00:01:25,380 --> 00:01:27,210
లేదా మేము వాటిని కవర్ కాదు అని.

26
00:01:27,210 --> 00:01:31,110
అయితే సమీక్షలు రూపంలో, ఈ ఆదివారం, సోమవారం, మరియు మంగళవారం

27
00:01:31,110 --> 00:01:34,770
అలాగే ఆదివారం రాత్రి ఒక కోర్సు వ్యాప్తంగా సమీక్ష సమావేశాలు -

28
00:01:34,770 --> 00:01:37,500
కోర్సు యొక్క హోమ్ పేజీలో ప్రకటించింది సమయం మరియు నగర -

29
00:01:37,500 --> 00:01:40,120
మీరు అన్ని కోర్సు యొక్క టీచింగ్ సభ్యులు సమీక్షించడానికి ఒక అవకాశం ఉంది

30
00:01:40,120 --> 00:01:44,830
విభాగంలో మరియు పూర్తి తరగతి రెండు ఈ సంవత్సరం భౌతిక,

31
00:01:44,830 --> 00:01:48,400
మరియు ఆ అలాగే సాధారణ వంటి చిత్రీకరించారు చేయబడుతుంది.

32
00:01:48,400 --> 00:01:53,380
>> అన్ని కుడి. కనుక తదుపరి శ్రమ లేకుండా, పయనంలో ఒక వ్యాఖ్య / విఫలం మరియు డ్రాప్ / జోడించండి.

33
00:01:53,380 --> 00:01:57,980
మీరు గత రాత్రి నా గమనికలు చూసిన, మరియు ఇది నిజంగా కొన్ని అదనపు అభయమిచ్చిన ఉంది

34
00:01:57,980 --> 00:02:01,250
మీరు ప్రత్యేకించి తక్కువ సౌకర్యవంతంగా లేదా మరొక మధ్య పొందినవారిలో ఉంటే

35
00:02:01,250 --> 00:02:04,870
మరియు మీరు, మీ తలపై కేవలం కొద్దిగా ఫీలింగ్ చేస్తున్నారు

36
00:02:04,870 --> 00:02:08,430
నిజానికి చాలా సాధారణ అని తెలుసుకుంటారు, మరియు స్థానంలో ఒక పుష్కల మద్దతు నిర్మాణం ఉంది,

37
00:02:08,430 --> 00:02:13,530
ఆఫీస్ అవర్స్ నా ఇమెయిల్ గత రాత్రి అన్ని మరింత మెరుగుపరచడానికి ఉద్దేశం ఇది ఒకటి,

38
00:02:13,530 --> 00:02:16,520
మరియు పాస్ వంటి ఒక ఎంపికను / ఈ వంటి తరగతి విఫలం కూడా గుర్తించడం

39
00:02:16,520 --> 00:02:21,540
నిజంగా ఈ వంటి కోర్సు యొక్క అంచు రావడానికి విధానం వలె ఉద్దేశించబడింది,

40
00:02:21,540 --> 00:02:24,200
తద్వారా మీరు ఆ 10, 15, 20 గంటల పాటు చేసిన మళ్ళీ ఉంటే

41
00:02:24,200 --> 00:02:28,160
పనిచేసేలా కొన్ని pset పొందడానికి ప్రయత్నిస్తున్న మరియు మీరు అక్కడ మార్గం 90-95% కాదని మాకు తెలుసు

42
00:02:28,160 --> 00:02:32,100
కానీ మీరు ఒక పాస్ లో, కొన్ని భీకర బగ్ కనుగొనేందుకు / విధమైన సరైందే అని మోడల్ విఫలం కాదు.

43
00:02:32,100 --> 00:02:36,230
>> ఆలోచన విధానం తో మీరు మీ ఇతర psets దృష్టి వెళ్ళే ఉంది

44
00:02:36,230 --> 00:02:39,530
లేదా నిద్ర లేదా మీరు దృష్టి కేంద్రీకరించాలి అని ఏ.

45
00:02:39,530 --> 00:02:43,390
కాబట్టి మీరు ఈ వస్తున్న మంగళవారం వరకు లేదని గుర్తించడం - సాంకేతికంగా 5 వ సోమవారం,

46
00:02:43,390 --> 00:02:50,840
కానీ అది చాలా, ఈ రాబోయే మంగళవారం ఒక సెలవు ఉంది - పాస్ నుండి మారడానికి / గ్రేడెడ్ లేదా పక్కకు విఫలం.

47
00:02:50,840 --> 00:02:54,450
మరియు మీరు ఎత్తైన కొండ చరియ న నిజంగా ఉన్నారు మరియు మొత్తంగా పడిపోయాడు గురించి ఆలోచిస్తూ ఉంటే,

48
00:02:54,450 --> 00:02:56,440
ఉపన్యాసం తర్వాత నన్ను పట్టుకోండి లేదా నాకు గమనిక డ్రాప్ చెయ్యండి.

49
00:02:56,440 --> 00:02:59,990
మీరు దండం బిడ్ ముందు మేము కనీసం చాట్ మేము ఇష్టపడతాము.

50
00:02:59,990 --> 00:03:03,470
అన్ని కుడి. కాబట్టి మేము చివరిసారి ఆఫ్ శిక్షణ చక్రాలు తీసుకోవడం మొదలు.

51
00:03:03,470 --> 00:03:06,030
ముఖ్యంగా, మేము స్ట్రింగ్ దృష్టి సారించింది.

52
00:03:06,030 --> 00:03:09,740
స్ట్రింగ్, CS50 లైబ్రరీలో ప్రకటించబడిన విషయం

53
00:03:09,740 --> 00:03:14,340
ప్రత్యేకంగా cs50.h అనే ఫైల్ లో మేము ఈ వారం చూడండి ప్రారంభించగలరు ఇది.

54
00:03:14,340 --> 00:03:17,250
కానీ స్ట్రింగ్ నిజంగా ఏదో ఒక సూక్ష్మీకరణ

55
00:03:17,250 --> 00:03:20,980
ఒక కొంచం arcanely చార్ * వర్ణించారు ఉంది.

56
00:03:20,980 --> 00:03:24,090
మేము గురించి తెలిసి చార్. ఇది కేవలం ఒక పాత్ర.

57
00:03:24,090 --> 00:03:28,010
కానీ సోమవారం యొక్క * అంటే సూచిస్తారు? >> [విద్యార్థి] A పాయింటర్.

58
00:03:28,010 --> 00:03:31,290
ఒక పాయింటర్. మరియు ఒక పాయింటర్ ఏది? >> [విద్యార్థి] ఒక చిరునామా.

59
00:03:31,290 --> 00:03:33,420
>> ఇది ఒక చిరునామా, మెమరీలో స్థానం వంటిది.

60
00:03:33,420 --> 00:03:35,910
ఒక చిరునామా లేదా నగర లేదా మెమరీ ఏమిటి?

61
00:03:35,910 --> 00:03:40,290
మళ్లీ, మాకు అన్ని ఈ రోజుల్లో ఎక్కువగా ఒక ప్రదర్శన లేదా RAM యొక్క 2 గిగాబైట్ల ల్యాప్టాప్లు కలిగి

62
00:03:40,290 --> 00:03:44,160
మరియు మీరు మెమరీ విలువ ఒక బిలియన్ లేదా 2 బిలియన్ బైట్లు కలిగివుంటాయి.

63
00:03:44,160 --> 00:03:46,240
అది నిజంగా, అది భౌతికంగా ఎలా పట్టింపు లేదు

64
00:03:46,240 --> 00:03:51,220
కానీ మీరు మీ స్వంత ల్యాప్టాప్ కలిగి వ్యక్తిగత బైట్లు అన్ని సంఖ్య చేసే విశ్వాసం పడుతుంది -

65
00:03:51,220 --> 00:03:54,580
ఈ 0 బైట్, ఈ బైట్ 1, ఈ 2 బిలియన్ బైట్ ఉంది -

66
00:03:54,580 --> 00:03:56,100
మరియు ఖచ్చితంగా ఒక కంప్యూటర్ చేస్తుంది ఏమిటి.

67
00:03:56,100 --> 00:04:00,030
మీరు ఒకే ఒక పాత్ర స్థలాన్ని కేటాయించాలని చేసినప్పుడు, ఉదాహరణకు,

68
00:04:00,030 --> 00:04:02,480
ఇది సహజంగా, మీ కంప్యూటర్ యొక్క మెమరీ లో ఎక్కడో జీవించడానికి ఉంది

69
00:04:02,480 --> 00:04:05,860
మరియు దీనికి, 12345 బైట్ సంఖ్య వద్ద ఉంది

70
00:04:05,860 --> 00:04:08,470
మరియు మీ కంప్యూటర్ యొక్క మెమరీ లో ఇక్కడ ఎక్కడో ఉంది.

71
00:04:08,470 --> 00:04:12,630
మరియు ఆ పాత్ర యొక్క తరువాత చిరునామా 12345.

72
00:04:12,630 --> 00:04:16,140
>> ఇప్పుడు, ఇప్పుడు ద్వారా ఇప్పటివరకు వారం 0 లో, మేము నిజంగా పట్టించుకునేది లేదు

73
00:04:16,140 --> 00:04:19,170
మేము సాధారణంగా చిహ్నాలు ఉపయోగిస్తాయి పేరు మెమరీ విషయాల, నిల్వ చేయబడతాయి

74
00:04:19,170 --> 00:04:22,540
వేరియబుల్స్, మరియు శ్రేణుల వాస్తవానికి మా వద్ద డేటా పొందడానికి.

75
00:04:22,540 --> 00:04:24,950
కానీ సోమవారం మరియు అన్ని మరింత రోజుకి, మీరు ఇప్పుడు చూడాలని

76
00:04:24,950 --> 00:04:27,710
రచన కార్యక్రమాలు అన్ని మరింత వ్యక్తీకరణ సామర్థ్యాలు

77
00:04:27,710 --> 00:04:31,330
నిజంగా అయితే మీరు సరైనది అని ఒక కంప్యూటర్ యొక్క మెమరీ సవరించడానికి,

78
00:04:31,330 --> 00:04:33,720
మంచి ప్రయోజనాల మరియు చెడు రెండూ,

79
00:04:33,720 --> 00:04:39,620
దోషాలు ఈ విషయాన్ని తెలుసుకున్న ఈ సమయంలో ఒక సాధారణ ఫలితంగా.

80
00:04:39,620 --> 00:04:42,460
కాని అది నిజంగా ఒక చార్ * అని శతకము

81
00:04:42,460 --> 00:04:46,140
మరియు నేడు వాగ్దానం వంటి మేము Binky వచ్చి ఉంటుంది - యొక్క తిరిగి ముందుకు వెళ్ళి తెలపండి.

82
00:04:46,140 --> 00:04:48,670
యొక్క ఇక్కడ ఒక చిన్న ఉదాహరణ వెళ్ళనిస్తున్నారని.

83
00:04:48,670 --> 00:04:53,060
ఈ ఫైలు compare.c వంటి సేవ్, మరియు నాకు కేవలం ఇక్కడ కొన్ని టెంప్లేట్ కోడ్ పొందండి తెలియజేయండి లెట్

84
00:04:53,060 --> 00:05:00,490
కాబట్టి stdio.h ఉన్నాయి, నాకు కూడా నాకు ఉంటాయి కల్పించడానికి అనుమతిస్తాయి cs50.h. నేను అక్కడ దగ్గరికి జూమ్ చేస్తాము.

85
00:05:00,490 --> 00:05:05,850
నాకు ప్రధాన ప్రధాన Int, (తప్ప) రాయటం మొదలుపెట్టాలని, మరియు ఇప్పుడు నేను ఈ వంటి చేయాలని లెట్:

86
00:05:05,850 --> 00:05:13,520
printf ("నాకు స్ట్రింగ్ ఇవ్వండి:") మరియు తర్వాత నేను స్ట్రింగ్ s GetString అవుతుంది ఉపయోగించే

87
00:05:13,520 --> 00:05:16,750
యూజర్ నుండి ఒక స్ట్రింగ్ పొందడానికి, అప్పుడు నేను మరొక ఒక వినియోగదారుని అభ్యర్థించడం వెళుతున్న.

88
00:05:16,750 --> 00:05:21,870
మరియు నేను పొందడానికి GetString ద్వారా వారిని అడగండి వెళుతున్న: ("నాకు మరొక స్ట్రింగ్ ఇవ్వండి").

89
00:05:21,870 --> 00:05:27,020
ఇది అందంగా సాధారణ ఉంటే s మరియు s స్ట్రింగ్ కోసం ఒక మంచి పేరు తర్వాత t వస్తుంది ఎందుకంటే నేను దానిని పిలుస్తాను.

90
00:05:27,020 --> 00:05:30,030
కాబట్టి GetString, మరియు ఇప్పుడు నేను తెలివి చెక్ చేయాలనుకుంటున్నారా మరియు నేను వెళుతున్నాను

91
00:05:30,030 --> 00:05:39,770
(s == t) అప్పుడు నేను ("! మీరు \ n ఇదే టైప్") printf యూజర్ చెప్పడం వెళుతున్న ఉంటే;

92
00:05:39,770 --> 00:05:45,520
ఇంకా నేను వంటి ("మీరు టైప్ చేసిన ఏదో వివిధ! \ n") ఏదో ముద్రించాలా వెళుతున్న

93
00:05:45,520 --> 00:05:48,460
లేదా ఏ శిక్ష ఉంటుంది. కాబట్టి ఆ వంటివి.

94
00:05:48,460 --> 00:05:52,200
తరువాత యధావిధిగా, నేను, ఆ ఏమీ చెడు జరిగింది తెలియజేయడం ఇది 0 తిరిగి ఉంటాం

95
00:05:52,200 --> 00:05:54,400
మరియు నేను ముందుకు వెళ్లి ఈ కార్యక్రమం కంపైల్ మరియు అమలు వెళుతున్న.

96
00:05:54,400 --> 00:05:56,540
>> కానీ సోమవారం మేము, ఈ కార్యక్రమాన్ని

97
00:05:56,540 --> 00:06:00,420
మరియు వాస్తవానికి హలో హలో కాదు మరియు గుడ్బై గుడ్బై కాదు చెప్పారు.

98
00:06:00,420 --> 00:06:03,140
మేము చూసిన ప్రవర్తన ఈ వంటి కొంచం పెద్దది.

99
00:06:03,140 --> 00:06:11,450
నాకు, నా మూల డైరెక్టరీ లోకి వెళ్ళి ఇక్కడ జూమ్, మరియు యొక్క పోల్చి తయారు మనం లెట్.

100
00:06:11,450 --> 00:06:14,570
సరే సంకలనం. పోల్చి నాకు అమలు అయ్యేలా అనుమతించండి. నాకు స్ట్రింగ్ ఇవ్వండి: HELLO.

101
00:06:14,570 --> 00:06:16,300
నాకు మరొక స్ట్రింగ్ ఇవ్వండి: HELLO.

102
00:06:16,300 --> 00:06:18,000
మీరు వేరొక టైప్!

103
00:06:18,000 --> 00:06:22,650
Well, నాకు సులభమైన 50, 50 లో లాగ ప్రయత్నించండి తెలియజేయండి. మీరు వేరొక టైప్!

104
00:06:22,650 --> 00:06:25,740
హాయ్, హాయ్. నుంచే, ఏదో ఇక్కడ జరుగుతోంది.

105
00:06:25,740 --> 00:06:28,440
కానీ ఎందుకు వివరణ ఏమిటి?

106
00:06:28,440 --> 00:06:33,850
స్పష్టంగా, లైన్ 12 పూర్తిగా పనిచేయడం లేదు.

107
00:06:34,300 --> 00:06:39,430
ఇక్కడ ప్రాధమిక సమస్య ఏమిటి? అవును. >> [విద్యార్థి] ఇది చిరునామాలను పోల్చడం యొక్క.

108
00:06:39,430 --> 00:06:41,850
అవును, సరిగ్గా. ఇది వాస్తవానికి చిరునామాలను పోల్చడం యొక్క

109
00:06:41,850 --> 00:06:44,580
దీనిలో HELLO HELLO మరియు నిల్వ చేయబడతాయి.

110
00:06:44,580 --> 00:06:48,290
ఇది మళ్లీ మళ్లీ HELLO అక్షరాలు పోల్చడం కాదు

111
00:06:48,290 --> 00:06:52,370
ఏ రియల్లీ హాపెండ్ ఎందుకంటే, మనం GetString ఉపయోగించి చేసిన -

112
00:06:52,370 --> 00:06:56,130
ఈ నల్లబల్ల, మళ్ళీ మా కంప్యూటర్ యొక్క మెమరీ

113
00:06:56,130 --> 00:07:00,100
మరియు లెట్స్ నేను వేరియబుల్ s ప్రకటించి GetString కాల్ అని చెపుతారు.

114
00:07:00,100 --> 00:07:01,930
నా మెమరీ అంటే ఎలా ఉంటుంది?

115
00:07:01,930 --> 00:07:07,070
లెట్ యొక్క కక్ష్య s ఈ కనిపించే చెప్పారు. ఒక చదరపు ఉంది.

116
00:07:07,070 --> 00:07:09,040
మరియు చాలా చక్కని ఏ సమయంలో నేను తెరపై మెమరీ యొక్క భాగాన్ని డ్రా చేసిన

117
00:07:09,040 --> 00:07:12,860
ఇది 32 బిట్స్ అయితే నేను, పరికరంలోని ఎందుకంటే నిజానికి ఈ వంటి చతురస్రాలు గీయడం చేసిన

118
00:07:12,860 --> 00:07:17,380
ఒక పాయింటర్, చిరునామా, 32 బిట్స్ ఉంది. ఇది ఒక పూర్ణాంకానికి అదే ఉంది.

119
00:07:17,380 --> 00:07:19,420
కంప్యూటర్ సిస్టమ్ ఆధారంగా మారుతుంటాయి.

120
00:07:19,420 --> 00:07:24,630
మీ Mac లేదా PC 64 బిట్స్ నిజాన్ని తో అస్పష్టంగా తెలిసిన మీరు యొక్క ఆ,

121
00:07:24,630 --> 00:07:28,120
వాస్తవానికి, మీ కంప్యూటర్ 64-bit గమనికలు ఉపయోగించి అని సూచిస్తుంది

122
00:07:28,120 --> 00:07:33,730
64-bit చిరునామాలు, మరియు ఆ యొక్క చేయబడనపుడు మధ్య మీ కంప్యూటర్ల ఉంది

123
00:07:33,730 --> 00:07:35,560
ఒకప్పటి కంటే RAM కలిగి ఉంటాయి.

124
00:07:35,560 --> 00:07:39,240
లాంగ్ కథ చిన్న, తిరిగి రోజు కంప్యూటర్లు మాత్రమే 32 బిట్స్ ఉపయోగించినప్పుడు

125
00:07:39,240 --> 00:07:42,740
చిరునామాలు ప్రాతినిధ్యం, బైట్లు అతిపెద్ద సంఖ్య మీరు ప్రాతినిధ్యం వహిస్తుంది

126
00:07:42,740 --> 00:07:46,280
ఆ సందర్భంలో గురించి మీరు 32 బిట్స్ ఉంటే?

127
00:07:46,280 --> 00:07:49,590
2 32 4 బిలియన్ ఎందుకంటే, కుడి, బిలియన్ 4 కాబట్టి.

128
00:07:49,590 --> 00:07:51,370
ఈ సంఖ్య కోర్సు పునరావృత చేయబడింది.

129
00:07:51,370 --> 00:07:55,240
>> మీరు మాత్రమే 32 బిట్స్ కలిగి అయితే మీకు పరిగణించబడుతుంది అత్యధిక సంఖ్య సుమారు 4 బిలియన్.

130
00:07:55,240 --> 00:07:58,750
కానీ కొన్ని సంవత్సరాల క్రితం వరకు కంప్యూటర్ల యొక్క ప్రాధమిక పరిమితి ఉంది

131
00:07:58,750 --> 00:08:01,180
మీరు మాత్రమే 4 బిలియన్ వంటి అధిక పరిగణించబడుతుంది ఉంటే ఎందుకంటే,

132
00:08:01,180 --> 00:08:05,270
మీరు RAM 8 గిగాబైట్ల లేదా RAM కూడా 5 గిగాబైట్ల కొనుగోలు ఉంటే అది పట్టింపు లేదు;

133
00:08:05,270 --> 00:08:07,780
మీరు అధిక లెక్కింపు సాధ్యం కాదు, కాబట్టి ఇది పనిచేయదు.

134
00:08:07,780 --> 00:08:11,430
మీరు మీ కంప్యూటర్ యొక్క మెమరీ మొదటి 3 లేదా 4 గిగాబైట్లు పొందలేక.

135
00:08:11,430 --> 00:08:14,410
ఇప్పుడు సమస్య తక్కువ, మరియు మీరు మాక్బుక్ ప్రోస్ అండ్ Dells కొనుగోలు చేయవచ్చు

136
00:08:14,410 --> 00:08:17,680
8 RAM యొక్క గిగాబైట్ల లేదా మరింత ఈ రోజుల్లో తో.

137
00:08:17,680 --> 00:08:24,100
నేను ఈ కార్యక్రమం చాలా సులువుగా ఒక పాయింటర్ కేటాయించాలని అయితే, ఒక పాయింటర్, s అనే

138
00:08:24,100 --> 00:08:28,370
నిజానికి మేము ఈ పొర తిరిగి రాలిపోవడం అవసరం ఎందుకంటే అది తెరపై ఇలా ఉండవచ్చు.

139
00:08:28,370 --> 00:08:33,520
నేను చెప్పడం స్ట్రింగ్ ఉంచండి, కాని వంటి సోమవారం యొక్క స్ట్రింగ్ నిజంగా చార్ * ఉంది

140
00:08:33,520 --> 00:08:35,590
కొన్ని పాత్ర యొక్క చిరునామా.

141
00:08:35,590 --> 00:08:39,280
కాబట్టి మేము ఇప్పుడు కోసం GetString ఉపయోగించి చేస్తాము అయినప్పటికీ యొక్క ఆఫ్ ఆ శిక్షణ చక్రం తీసుకుందాం.

142
00:08:39,280 --> 00:08:42,600
నేను s డిక్లేర్డ్ చేసిన, మరియు ఈ మెమరీ భాగం, 32 బిట్స్ ఉంది.

143
00:08:42,600 --> 00:08:47,370
అప్రమేయంగా మెమరీలో ఇక్కడ ఏమిటి? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

144
00:08:47,370 --> 00:08:50,040
ఆ ఏమిటి? >> [విద్యార్థి] గార్బేజ్. >> గార్బేజ్. సరిగ్గా.

145
00:08:50,040 --> 00:08:54,610
మీరు ప్రోగ్రామర్ ఒక వేరియబుల్ విలువను ఉంచారు లేకపోతే, దాని ఏమి తెలుసు?

146
00:08:54,610 --> 00:08:57,990
కొన్నిసార్లు మీరు లక్కీ పొందండి మరియు 0 యొక్క, ఇది ఒక మంచి, క్లీన్ డిఫాల్ట్ విలువ రకం

147
00:08:57,990 --> 00:09:00,310
సోమవారం చేసుకునేందుకు కానీ, కొన్నిసార్లు, పూర్తి అర్ధంలేని ఉంది

148
00:09:00,310 --> 00:09:04,130
ఆ పేరు నుండి వచ్చింది చాలా పెద్ద అనుకూల లేదా ప్రతికూల సంఖ్య?

149
00:09:05,350 --> 00:09:07,010
అవును. ముందు >> [విద్యార్థి] ఫంక్షన్. >> అవును.

150
00:09:07,010 --> 00:09:10,170
>> తరచుగా గుర్తు ఎందుకంటే ముందు అని వచ్చింది అని ఫంక్షన్

151
00:09:10,170 --> 00:09:13,920
మీరు మెమరీలో విధులు పిలుస్తారు, వారు, దిగువ నుండి మరింత స్థలాన్ని ఆక్రమిస్తాయి

152
00:09:13,920 --> 00:09:17,040
మరియు వెంటనే తిరిగి వచ్చే చర్యలు వంటి, ఆ స్మృతి తిరిగి అవుతుంది

153
00:09:17,040 --> 00:09:20,890
అని చెపుతాడు ఆ తర్వాత గై ద్వారా, వారు మెమరీ మీ అదే ముక్క ఉపయోగిస్తోంది.

154
00:09:20,890 --> 00:09:23,450
మరియు మీరు అక్కడ ఎడమ చెత్త, మునుపటి విలువలు, ఉంటే

155
00:09:23,450 --> 00:09:28,190
మేము అక్కడ ఏదైనా పెట్టలేదు తర్వాత కొన్ని విలువ కలిగి s పొరబడేటట్లు ఉండవచ్చు.

156
00:09:28,190 --> 00:09:30,960
కాబట్టి ఈ సమయంలో మా RAM ఈ కనిపిస్తోంది.

157
00:09:30,960 --> 00:09:36,030
ఇప్పుడు 7 యొక్క కుడి వైపు మేము, GetString కాల్ చేస్తున్నారు

158
00:09:36,030 --> 00:09:40,150
ఇది మేము వారాలు చేస్తున్న చేసిన, కానీ నిజంగా చేయడం GetString ఉంది?

159
00:09:40,150 --> 00:09:43,350
CS50 సిబ్బంది రాసిన GetString కొద్దిగా తెలివైన

160
00:09:43,350 --> 00:09:46,500
ఆ వినియోగదారు టైప్ కీలు మరియు హిట్స్ నమోదు చేయండి మొదలవుతుంది వెంటనే

161
00:09:46,500 --> 00:09:50,010
ఎన్ని కీస్ట్రోక్ యూజర్ హిట్ చేశాడు GetString గణాంకాలు అవ్ట్,

162
00:09:50,010 --> 00:09:53,360
ఎన్ని అక్షరాలు నేను కోసం RAM కేటాయించాల్సిన అవసరం లేదు.

163
00:09:53,360 --> 00:09:55,660
మరియు ఆ RAM నుండి వచ్చి ఎవరికి తెలుసు?

164
00:09:55,660 --> 00:09:58,930
మీ కంప్యూటర్ యొక్క 2 గిగాబైట్ల లేదా మెమరీ whatnot ఎక్కడో ఉంది.

165
00:09:58,930 --> 00:10:05,200
కానీ కంప్యూటర్ ఇక్కడే HELLO పదం స్థలాన్ని కనుగొన్నారు అనుకుందాం తెలియజేయండి.

166
00:10:05,200 --> 00:10:08,710
నేను టైప్ పదం H-E-L-L-O ఉంది.

167
00:10:08,710 --> 00:10:13,510
మరియు మేము అక్షరాలు యొక్క ఒక క్రమంలో ఈ డ్రా ఉంటే, మేము ఈ మాదిరిగా డ్రా ఉండవచ్చు.

168
00:10:13,510 --> 00:10:17,860
కానీ నేను 1 అదనపు పనిని చేయడానికి అవసరం. ఏ సి ఏ తీగ చివర చెందిన?

169
00:10:17,860 --> 00:10:20,710
మేము \ 0 గా వ్రాసి ఇది శూన్య పాత్ర.

170
00:10:20,710 --> 00:10:23,980
ఇది సాంకేతికంగా సంఖ్య 0, కానీ బాక్ స్లాష్ అన్ని స్పష్టమైన చేస్తుంది

171
00:10:23,980 --> 00:10:28,150
సాహిత్యపరంగా సంఖ్య 0, పూర్ణాంక 0 అని;

172
00:10:28,150 --> 00:10:32,440
మీరు కీబోర్డ్ వద్ద టైప్ చేసే ఉదాహరణకు, కోట్-unquote 0 కోసం, కాదు.

173
00:10:32,440 --> 00:10:33,940
కాబట్టి ఈ HELLO ఉంది.

174
00:10:33,940 --> 00:10:36,350
>> మరియు మేము సోమవారం ఏమి చెప్పాలి అని GetString వంటి ఫంక్షన్

175
00:10:36,350 --> 00:10:39,580
వాస్తవానికి ఈ వారాల తిరిగి?

176
00:10:39,580 --> 00:10:43,960
ఆ నిజంగా అర్థం లేవు ఇది పర్ సే స్ట్రింగ్ తిరిగి కాదు

177
00:10:43,960 --> 00:10:47,710
తీగలు లేని ఎందుకంటే. వారు CS50 లైబ్రరీలో ఒక కల్పన విధమైన ఉన్నారు.

178
00:10:47,710 --> 00:10:51,300
సాంకేతికంగా ఏ, నిజంగా ఒక స్ట్రింగ్? >> [విద్యార్థి] ఇది మొదటి పాత్ర.

179
00:10:51,300 --> 00:10:55,950
సరిగ్గా. ఇది వినియోగదారు సైన్ టైప్ చేసి చాలా సరళంగా మొదటి పాత్ర యొక్క చిరునామా యొక్క

180
00:10:55,950 --> 00:11:02,810
అయితే బైట్ సంఖ్య 123 వద్ద మరియు తరువాత బైట్ సంఖ్య 124 వద్ద ముగుస్తుంది HELLO నా పదం,

181
00:11:02,810 --> 00:11:08,320
125, 126, మొదలైనవి, మీద 0 నుంచి నేను సంఖ్య నా బైట్లు ఉంటే,

182
00:11:08,320 --> 00:11:12,650
వాట్ రియల్లీ GetString తిరిగి అక్షరాలా సంఖ్య 123 ఉంది.

183
00:11:12,650 --> 00:11:19,270
సో వాట్ s ఉంచే సంఖ్య 123, కాదు లేఖ H, కాని పదం, HELLO ఉంది

184
00:11:19,270 --> 00:11:23,130
చాలా సరళంగా నేను HELLO మొదటి అక్షరం పొందవచ్చు చిరునామా.

185
00:11:23,130 --> 00:11:26,500
కానీ తగినంత వంటి కనిపించడం లేదు. నేను, ఒక స్ట్రింగ్ కోసం ఒక పాత్ర మీరు అడిగారు.

186
00:11:26,500 --> 00:11:32,970
కాబట్టి మేము ఎలా లేదా కంప్యూటర్ ఆ ELLO రకమైన H పాటు వచ్చిన తెలుసు?

187
00:11:35,760 --> 00:11:37,460
మనం ఒప్పందం యొక్క విధమైన ఏమిటి? అవును.

188
00:11:37,460 --> 00:11:40,100
[విద్యార్థి] ఇది కొన్ని ఎక్కువ అక్షరాలు కనుగొనేందుకు కూడా చెప్పడం ఉంచుతుంది. ఖచ్చితంగా >>.

189
00:11:40,100 --> 00:11:44,570
>> మీరు తీగలను వ్యవహరించే చేయటం ఈ మానవ కంప్యూటర్ కన్వెన్షన్, ఉన్నాయి

190
00:11:44,570 --> 00:11:49,410
లేకపోతే ఇప్పుడు చార్ నక్షత్రాలు అంటారు, మీరు కేవలం గుర్తించడానికి కలిగి

191
00:11:49,410 --> 00:11:54,350
జీవితంలో ప్రతి స్ట్రింగ్ ముగింపు నిజంగా కేవలం, లూప్ ఒక దాన్ని పైగా iterating ద్వారా ఉన్న

192
00:11:54,350 --> 00:11:57,820
ఒక సమయంలో లూప్, ఏ, తద్వారా మీరు స్ట్రింగ్ ముగింపు చూసినప్పుడు

193
00:11:57,820 --> 00:12:02,160
ఇప్పుడు మీరు ఆ నుండి ప్రతిపాదించే చేయవచ్చు, OH, పూర్తి పదాన్ని HELLO ఉంది.

194
00:12:02,160 --> 00:12:04,820
ముందు ప్రోగ్రామింగ్ అనుభవాన్ని మీకు ఆ జావా లో తెలిసిన

195
00:12:04,820 --> 00:12:09,880
మీరు. కాల్ పొడవు మరియు ఇతర భాషలలో మీరు పొడవు లేదా ఇలాంటి కాల్ ఉండవచ్చును.

196
00:12:09,880 --> 00:12:14,060
భాషలు చాలా లో, ముఖ్యంగా విషయాలు ఆబ్జెక్ట్ ఆధారిత భాషలు అని ఎందుకంటే ఆ, యొక్క

197
00:12:14,060 --> 00:12:18,580
ఏదో యొక్క పొడవు, డేటా యొక్క భాగం యొక్క కప్పబడుతుంది లోపల రకం

198
00:12:18,580 --> 00:12:24,000
చాలా మేము కప్పబడుతుంది ID లు మరియు పేర్లు మరియు సోమవారం ఒక విద్యార్థి యొక్క లోపల ఇళ్ళు వంటి.

199
00:12:24,000 --> 00:12:28,700
కానీ సి చాలా తక్కువ స్థాయి ఉంది. మీరు ముందు ఆ పదాలు విని ఉంటే ఏ వస్తువులు లేదా తరగతులు ఉన్నాయి.

200
00:12:28,700 --> 00:12:31,490
మీరు అన్ని నిజంగా మెమరీ చిరునామాలను ఉంది.

201
00:12:31,490 --> 00:12:35,540
కాబట్టి ఈ ఆసక్తికరమైన డేటా నిర్మాణాలు ప్రాతినిధ్యం యొక్క పాత ఫ్యాషన్ మార్గం విధమైన ఉంది.

202
00:12:35,540 --> 00:12:38,760
మీరు మొదటి పాత్ర యొక్క చిరునామా వంటి ప్రారంభ విలువ

203
00:12:38,760 --> 00:12:42,340
ఆపై ప్రతి ఒక్కరూ అనుసరించండి ఒప్పుకున్న కొన్ని ఏకపక్ష కన్వెన్షన్.

204
00:12:42,340 --> 00:12:46,420
కాబట్టి స్ట్రింగ్ పొడవు అమలు ఎలా, మేము ప్రపోజ్ చేయలేదు?

205
00:12:46,420 --> 00:12:51,360
మీరు కొన్ని ఇప్పుడు కొన్ని సార్లు ఉపయోగించారు, ఇది Strlen, strlen. ఇది కుడి, అందంగా సులభం?

206
00:12:51,360 --> 00:12:53,060
ఇది కోడ్ 2 లైన్లు వంటిది.

207
00:12:53,060 --> 00:12:56,140
ఇది బహుశా ఒక అదనపు స్థానిక వేరియబుల్ తో, చాలా చక్కని విధమైన ఒక కోసం లూప్ ఉంది.

208
00:12:56,140 --> 00:13:00,540
కానీ strlen కేవలం \ 0 వెతుకుతున్న ప్రారంభం తర్వాత ఒక పాయింటర్ తీసుకొని ఉంటుంది.

209
00:13:00,540 --> 00:13:05,190
>> మరియు వెంటనే అది కనుగొంది, ఇది ఆ స్ట్రింగ్ లో తీసుకోబడింది దశలను మొత్తం తిరిగి రావచ్చు.

210
00:13:05,190 --> 00:13:07,150
కాబట్టి రాబోయే వెళ్లి ఈ నుండి ప్రతిపాదించే చేయవచ్చు.

211
00:13:07,150 --> 00:13:11,850
నేను లైన్ 10 లో చేసినట్లుగానే నేను t డిక్లేర్ అప్పుడు అనుకుందాం.

212
00:13:11,850 --> 00:13:14,280
ఈ కొన్ని చెత్త విలువ. ఎవరు మొదటి వద్ద తెలుసు?

213
00:13:14,280 --> 00:13:18,490
కానీ 10 యొక్క మార్గం యొక్క కుడి వైపు నేను మళ్ళీ GetString కాల్ చేస్తున్నాను.

214
00:13:18,490 --> 00:13:20,050
ఈ ముగుస్తుంది ఎవరు తెలుసు?

215
00:13:20,050 --> 00:13:23,830
లెట్ యొక్క కక్ష్య ఆపరేటింగ్ సిస్టమ్ ఇక్కడ అది పైగా దొరికింది చెబుతారు.

216
00:13:23,830 --> 00:13:28,610
నేను, మళ్ళీ యాదృచ్ఛికంగా H-E-L-L-O టైప్ జరిగే

217
00:13:28,610 --> 00:13:31,260
అందువలన మేము చిత్రాన్ని ఒక రకమైన డ్రా చేయవచ్చు.

218
00:13:31,260 --> 00:13:34,290
కానీ నేను మళ్లీ గీసి ఈ చిత్రాన్ని చేసిన నిజానికి ఉద్దేశపూర్వక ఉంది

219
00:13:34,290 --> 00:13:37,720
ఆ ఎందుకంటే ఈ ఒక కంటే HELLO వివిధ.

220
00:13:37,720 --> 00:13:43,920
ఇక్కడ ఈ నగర 456 కావచ్చు, ఈ 457, మరియు మొదలైనవి.

221
00:13:43,920 --> 00:13:47,170
ప్రశ్న గుర్తు ఒకప్పుడు పేరు సో వాట్ ఉంచే?

222
00:13:47,170 --> 00:13:50,190
ఈ సందర్భంలో 456 లో.

223
00:13:50,190 --> 00:13:53,540
మేము ఈ రోజు తర్వాత ఎందుకంటే నిజంగా ఏకపక్ష ఈ సంఖ్యలు ఎంచుకోవడం చేస్తున్నారు

224
00:13:53,540 --> 00:13:57,110
మేము ఏదైనా యొక్క చిరునామా గురించి చాలా శ్రద్ధ వెళ్ళి లేదు.

225
00:13:57,110 --> 00:14:02,690
మనం శ్రద్ధ అన్ని మేము HELLO వంటి డేటా యొక్క కొన్ని భాగం యొక్క చిరునామా గుర్తించడానికి ఉంది.

226
00:14:02,690 --> 00:14:07,100
>> కాబట్టి నిజంగా మెమరీ చిరునామాలు గురించి మాట్లాడుతున్నప్పుడు చాలా మంది కంప్యూటర్ సైన్స్ లో ఏమి

227
00:14:07,100 --> 00:14:10,210
మరియు, ప్రత్యేకించి గమనికలు గురించి మాట్లాడటం

228
00:14:10,210 --> 00:14:14,220
ఈ విషయాన్ని వాస్తవానికి ఉన్న ఎవరు పట్టించుకుంటారు, - 123 ఇందుకు ఇబ్బంది కాకుండా

229
00:14:14,220 --> 00:14:17,440
మేము దానిని కొన్ని సంఖ్యా చిరునామా వద్ద అని తెలుసు -

230
00:14:17,440 --> 00:14:22,180
మేము ప్రపంచ సులభతరం మరియు కేవలం s పాత్ర కు సూచిస్తుంది చెబుతారు

231
00:14:22,180 --> 00:14:25,080
మరియు t ఆ పాత్ర కు సూచిస్తుంది.

232
00:14:25,080 --> 00:14:27,430
మరియు అది ఒక బాణం అని నిజానికి చాలా కావాలని ఉంది

233
00:14:27,430 --> 00:14:31,610
సాహిత్యపరంగా ఇప్పుడు s H మరియు t వద్ద గురిపెట్టి ఎందుకంటే ఇతర H వద్ద సూచించబడిన

234
00:14:31,610 --> 00:14:34,720
రోజు ముగింపులో, అది చిరునామా ఎందుకు, ఎందుకంటే

235
00:14:34,720 --> 00:14:40,240
కానీ మేము కోడ్ యొక్క కొన్ని ముక్క ఆ చిరునామా వ్యక్తం సామర్థ్యం అవసరం.

236
00:14:40,240 --> 00:14:42,730
మమ్మల్ని ఇంకా ఈ చిరునామాలను అవకతవకలు లేదు

237
00:14:42,730 --> 00:14:47,770
కాబట్టి మేము, మేము ఆశ్చర్యంకలిగించునట్లు చేయు మరియు గమనికలు తో పనులు యొక్క క్రమం ఇక్కడ చూస్తారు

238
00:14:47,770 --> 00:14:52,030
కానీ అక్షరాలా 12 ఇప్పుడు లైన్ లో ఏమి విలువలు మేము పోల్చడం ఉంటాయి

239
00:14:52,030 --> 00:14:55,500
లైన్ 12 లో ఈ కథ ప్రకారం?

240
00:14:56,570 --> 00:15:01,290
మేము 456 కు 123 సమాన సమానం చెబుతున్న దాన్ని? మరియు ఆ ఖచ్చితంగా కేసు కాదు.

241
00:15:01,290 --> 00:15:05,320
మరియు విషయపరంగా, ఈ పాయింటర్ ఖచ్చితంగా ఈ అదే కాదు

242
00:15:05,320 --> 00:15:09,500
, మీరు రెండుసార్లు GetString అని, మరియు GetString తెలివైన సూపర్ గా ప్రయత్నించండి లేదు ఎందుకంటే

243
00:15:09,500 --> 00:15:12,470
ఇది గుర్తించడం ప్రయత్నించండి లేదు, OH, మీరు 5 నిమిషాల క్రితం HELLO టైప్;

244
00:15:12,470 --> 00:15:15,090
నేను ముందు మీరు ఇచ్చిన నన్ను మీరు అదే పాయింటర్ కల్పించడానికి అనుమతిస్తాయి,

245
00:15:15,090 --> 00:15:18,450
ఇది మెమరీ కొత్త భాగం మీరు కాల్ ప్రతిసారీ కేటాయించుకునే.

246
00:15:18,450 --> 00:15:20,350
>> మేము ఈ సమస్య కాబట్టి ఎలా పరిష్కరించాలి?

247
00:15:20,350 --> 00:15:24,270
ఉన్నత స్థాయి ఉంటే నేను తీగలు HELLO HELLO మరియు పోల్చడానికి ఎంచుకోండి -

248
00:15:24,270 --> 00:15:28,680
నేను గమనికలు గురించి పట్టించుకోను - నేను ప్రశ్నకు సమాధానం గురించి ఎలా ఏం చేస్తావు,

249
00:15:28,680 --> 00:15:31,980
వినియోగదారు ఒకే విషయం టైప్ చేశారా? ఇక్కడికి అవసరం? అవును.

250
00:15:31,980 --> 00:15:35,200
[విద్యార్థి] ఒక చర్య ఉపయోగించండి. >> నేను పెట్టె యొక్క ఒక చర్యను పరిష్కరించటానికి ఉపయోగించవచ్చు.

251
00:15:35,200 --> 00:15:38,170
నేను, strcmp, s-t-r-c-m-p అనే క్రియాశీలతను ఉపయోగించగలదు

252
00:15:38,170 --> 00:15:41,190
స్ట్రింగ్ పోల్చి చెప్పడం కేవలం సంక్షిప్త రూపం.

253
00:15:41,190 --> 00:15:45,070
మరియు మేము వెళ్లి ఉంటే, ఉదాహరణకు, నేటి handouts మధ్య ఇది ​​2 పోల్చి

254
00:15:45,070 --> 00:15:46,690
నేను ఖచ్చితంగా అలా.

255
00:15:46,690 --> 00:15:51,750
నేను, 26 లేదా క్రిందికి న అన్నిటికీ పంక్తి 1 నుండి అదే ఉంచిన

256
00:15:51,750 --> 00:15:54,360
మరియు ఇప్పుడు ఈ భాగం కేవలం కొద్దిగా మార్చబడింది గమనిస్తారు.

257
00:15:54,360 --> 00:15:57,690
యొక్క ఒక క్షణం లైన్ 28 విస్మరించండి మరియు ఈ ఒక మాత్రమే దృష్టి లెట్.

258
00:15:57,690 --> 00:16:00,410
మేము STR సరిపోల్చుతుంది ఆ సోమవారం ఏమి చేశారు?

259
00:16:00,410 --> 00:16:05,200
ఇది, ఈ విషయంలో 2 గమనికలు, s మరియు t తీసుకునే విధానాన్ని నిర్వహిస్తుంది

260
00:16:05,200 --> 00:16:08,480
క్రమీకరించు వాస్తవంగా, ఆ 2 అక్షరాలు దాని వేలు పెట్టటం

261
00:16:08,480 --> 00:16:11,530
మరియు అది చేయాలి, లూప్ కొంత లూప్ లేదా ఒక వంటిది

262
00:16:11,530 --> 00:16:16,050
మరియు ఈ అదే ఉన్నాయో? అలా అయితే, దీనిని వేళ్లు లేదా ముందుకు గమనికలు తరలిస్తుంది.

263
00:16:16,050 --> 00:16:17,970
ఈ ఒకటే, ఈ అదే, ఈ అదే,

264
00:16:17,970 --> 00:16:22,710
ఈ అదే, ఈ అదే? మరియు ooh, నేను s మరియు t రెండు వద్ద స్ట్రింగ్ చివరిలో ఉన్నాను.

265
00:16:22,710 --> 00:16:26,780
నేను ఏ వైరుధ్యాలు కనుగొనలేకపోయాము. అవును, ఈ తీగలు ఒకే విధంగా ఉంటాయి.

266
00:16:26,780 --> 00:16:31,940
2 రెమ్మలు అదే ఉంటే మరియు STR, స్పష్టంగా తిరిగి ఏ సరిపోల్చుతుంది? జీరో.

267
00:16:31,940 --> 00:16:35,900
కాబట్టి 0 ఈ విషయంలో మంచి ఎందుకంటే అది -1 లేదా +1, తిరిగి ఉంటే

268
00:16:35,900 --> 00:16:40,560
ఆ s కేవలం t అక్షర ముందు లేదా t తర్వాత వచ్చిన జరిగినప్పుడు అర్థం.

269
00:16:40,560 --> 00:16:43,760
ఎందుకు ఆ స్ట్రింగ్ ముందు వచ్చి మీరు చెబుతుంది ఒక చర్యను కలిగి ఉపయోగకరంగా ఉంటుంది

270
00:16:43,760 --> 00:16:46,720
లేదా ఒక నిఘంటువులో తర్వాత?

271
00:16:46,720 --> 00:16:48,740
[విద్యార్థి] శోధిస్తోంది. >> శోధిస్తోంది మరియు క్రమబద్ధీకరించేందుకు.

272
00:16:48,740 --> 00:16:51,730
>> కాబట్టి మీరు బైనరీ శోధన లేదా బబుల్ సార్ట్ వంటి విషయాలను లేదా విధమైన విలీనం చెయ్యగలరు

273
00:16:51,730 --> 00:16:53,230
మీరు విషయాలను పోల్చి ఉంటుంది.

274
00:16:53,230 --> 00:16:56,420
ఇంతవరకు మేము కొన్ని మూలల్లో కట్ రకమైన మీరు మరియు మాత్రమే క్రమబద్ధీకరించేందుకు గురించి మాట్లాడారు

275
00:16:56,420 --> 00:16:59,430
సంఖ్యల సందర్భంలో దాని గురించి మాట్లాడటానికి nice మరియు సులభం, ఎందుకంటే

276
00:16:59,430 --> 00:17:02,430
కానీ మీరు ఖచ్చితంగా తీగలు, ఆపిల్ మరియు అరటి, సరిపోల్చవచ్చు

277
00:17:02,430 --> 00:17:05,349
ఆపిల్ అదేవిధంగా, అరటి ముందు ఉన్నట్లు తెలిస్తే, ఎందుకంటే

278
00:17:05,349 --> 00:17:09,319
మీరు వీడియో లో విలీనం విధమైన ద్వారా కూడా రాబ్ వంటి మెమరీలో చుట్టూ తీగలను తరలించవచ్చు

279
00:17:09,319 --> 00:17:15,880
మరియు మేము ఎంపిక విధమైన, చొప్పించడం విధమైన, మరియు బబుల్ సార్ట్ వేదికపై ఇక్కడ చేశాడు.

280
00:17:15,880 --> 00:17:18,710
కాబట్టి పేరు ఇంకా మేము ఈ పడుతుంది? యొక్క ఈ ప్రయత్నించండి లెట్.

281
00:17:18,710 --> 00:17:23,980
యొక్క లెట్స్ విధమైన క్షణం ఆ పాఠం మర్చిపోతే మరియు ఇప్పుడు ప్రయత్నించండి మరియు ఈ క్రిందివి చేయడానికి 1.c కాపీ.

282
00:17:23,980 --> 00:17:26,800
లైన్ 21 లో నేను, ముద్రణ ఏదో చెప్పడం నేను

283
00:17:26,800 --> 00:17:28,520
అప్పుడు నేను, వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందుతున్నాను

284
00:17:28,520 --> 00:17:30,690
అప్పుడు నేను ఈ తనిఖీ చేస్తున్నాను.

285
00:17:30,690 --> 00:17:33,620
మమ్మల్ని ఇంకా ఈ అలవాటు లో సంపాదించిన, కానీ యొక్క ఇప్పుడు మనం లేదు.

286
00:17:33,620 --> 00:17:40,990
ఈ పొర చర్మము వాస్తవానికి యొక్క లెట్. ఇది నిజంగా చార్ * ఉంది. ఈ వ్యక్తి నిజంగా చార్ * ఉంది.

287
00:17:40,990 --> 00:17:45,690
కనుక ఇది s == NULL ఉంటే తనిఖీ చేయడానికి అర్థం ఏమిటి?

288
00:17:45,690 --> 00:17:48,380
ఇది అవుతుంది మీరు GetString వంటి ఫంక్షన్ కాల్ చేసినప్పుడు

289
00:17:48,380 --> 00:17:51,540
లేదా సాధారణంగా కేవలం, మీరు కొన్ని మెమరీ ఇవ్వాలని ఒక కంప్యూటర్ అడగండి

290
00:17:51,540 --> 00:17:53,030
ఏదో తప్పు వెళ్ళటానికి.

291
00:17:53,030 --> 00:17:56,630
నీకేమైనా పిచ్చా మరియు మెమరీ టెరాబైట్ కోసం కంప్యూటర్ అడగండి కాలేదు

292
00:17:56,630 --> 00:18:01,780
కేవలం కంప్యూటర్ లో లేని మెమరీ బైట్లు ట్రిలియన్ల కోసం అడిగారు,

293
00:18:01,780 --> 00:18:05,130
కానీ GetString మరియు ఇతర చర్యలు మీరు వద్ద పదాన్ని కొన్ని మార్గం అవసరం

294
00:18:05,130 --> 00:18:06,820
మీరు చాలా అడిగారు ఉంటే.

295
00:18:06,820 --> 00:18:10,450
మీరు అధిక మెమరీ అడిగారు ఉంటే GetString చేస్తుంది మార్గం

296
00:18:10,450 --> 00:18:14,250
ఆ సూపర్, సూపర్ తక్కువ సంభావ్యత అయినా, కంప్యూటర్ అందుబాటులో ఉంది కంటే

297
00:18:14,250 --> 00:18:17,730
మాకు ఎవరూ, Enter ని అప్పుడు ట్రిలియన్ అక్షరాలను టైప్ మరియు వెళ్ళే ఎందుకంటే

298
00:18:17,730 --> 00:18:21,980
కానీ ఉండవచ్చు అయితే తక్కువ సంభావ్యత, నేను ఇప్పటికీ, కేవలం సందర్భంలో అది తనిఖీ మీరు

299
00:18:21,980 --> 00:18:26,120
మరియు ప్రత్యేక విలువ GetString, సమాధానం, మరియు ఇతర విధులు తిరిగి ఆ

300
00:18:26,120 --> 00:18:30,630
ఏదో సమస్య ఉంది ఉంటే అన్ని CAPS లో NULL.

301
00:18:30,630 --> 00:18:36,520
>> మరియు NULL ఏమిటి? NULL కేవలం ఒక పాయింటర్ ప్రాతినిధ్యం జరుగుతుంది. ఇది మెమరీ చిరునామా 0 ఉంది.

302
00:18:36,520 --> 00:18:40,800
ఈ నా కంప్యూటర్ యొక్క మెమరీ ఉంటే వరల్డ్, ఆ కక్ష్య నిర్ణయించుకుంది - మీకు తెలిసిన వాటిని? -

303
00:18:40,800 --> 00:18:46,260
మేము ప్రతి కంప్యూటర్ యొక్క మెమరీ కేవలం 1 బైట్ దొంగతనం చూడాలని, మరియు ఈ నగర 0.

304
00:18:46,260 --> 00:18:49,560
మేము NULL యొక్క మారుపేరు ఇవ్వడం వెళుతున్న మరియు మేము హామీ చూడాలని

305
00:18:49,560 --> 00:18:52,660
మేము నిజంగా అక్కడ నిజమైన డేటా ఎన్నడూ ఆ

306
00:18:52,660 --> 00:18:56,770
మేము కేవలం ఏకపక్ష ప్రత్యేక విలువ, 0, aka NULL, అవసరం ఎందుకంటే

307
00:18:56,770 --> 00:19:00,230
ఏదో తప్పు జరిగితే మేము వినియోగదారులు అరుస్తుంటారు చేయవచ్చు.

308
00:19:00,230 --> 00:19:03,590
లేకపోతే మీరు 0 ఇక్కడ ఏదో ఉంచండి అర్థం లేదు తెలియదు ఉండవచ్చు

309
00:19:03,590 --> 00:19:05,490
లేదా ఏదో తప్పు జరిగింది శతకము

310
00:19:05,490 --> 00:19:09,190
మేము ఆ NULL అంటే ఏమీ తిరిగి అంగీకరిస్తున్నారు ఉంటుంది

311
00:19:09,190 --> 00:19:11,700
సరైన చిరునామా రాలేదు.

312
00:19:11,700 --> 00:19:15,210
ఇప్పుడు, ఇక్కడ నేను నా మానవ కన్వెన్షన్ స్వీకరించేందుకు నేను ప్రధాన నుండి 1 తిరిగి

313
00:19:15,210 --> 00:19:17,040
ఏదో తప్పు పోతే.

314
00:19:17,040 --> 00:19:20,650
ప్రధాన తిరిగి సమావేశం 0 మంచి ఉంటే తిరిగి ఎందుకంటే ఆ, యొక్క

315
00:19:20,650 --> 00:19:22,990
1 లేదా కొన్ని ఇతర విలువ చెడ్డ ఉంటే.

316
00:19:22,990 --> 00:19:28,200
కానీ GetString మరియు NULL మెమరీ రిటర్న్స్ ఒప్పందాలు ఏదో చెడు పోతే ఏ ఫంక్షన్.

317
00:19:28,200 --> 00:19:33,480
>> సరే. కాబట్టి దురదృష్టవశాత్తు, లైన్ 27, అది అయినప్పటికీ సూపర్ సాధారణ, పూర్తిగా స్ట్రింగ్ కాపీ విఫలమైంది.

318
00:19:33,480 --> 00:19:35,740
ఎందుకు? మేము ఈ క్రింది చూడవచ్చు.

319
00:19:35,740 --> 00:19:40,120
నేను s యొక్క ఒక నకలు మరియు దానిని కాల్ చేయడానికి లైన్ 27 దావా చేస్తున్నాను.

320
00:19:40,120 --> 00:19:45,790
నేను 2 రెమ్మలు ఈ సారి యూజర్ అడగడం లేదు; నేను s లో విలువను చెప్పడం నేను

321
00:19:45,790 --> 00:19:47,870
అలాగే T లో ముంచాలి.

322
00:19:47,870 --> 00:19:52,890
కాబట్టి ఇప్పుడు కేవలం 29 తరువాత నేను ఏమి చేస్తున్నాను లైన్ లో, ఈ ఎలా బ్రోకెన్ ప్రదర్శించేందుకు?

323
00:19:52,890 --> 00:19:56,980
T యొక్క పొడవు 0 కన్నా ఎక్కువ ఉంటే మొదటి నేను తనిఖీ చేస్తున్నాను.

324
00:19:56,980 --> 00:19:59,330
అక్కడ కొన్ని స్ట్రింగ్ ఉంది. యూజర్ సైన్ ఏదో టైప్

325
00:19:59,330 --> 00:20:03,410
స్పష్టంగా లైన్ చేస్తున్న 32, ఏమిటి?

326
00:20:03,410 --> 00:20:08,910
[వినబడని విద్యార్థి ప్రతిస్పందన] >> కుడి. మీరు రకమైన నేను చేయుచున్నాడు మాట్లాడుతూ నుండి ప్రతిపాదించే చేయవచ్చు.

327
00:20:08,910 --> 00:20:13,200
కానీ సాంకేతికంగా, ఈ ఏమి ఉంది? t [0] ఏ సూచిస్తుంది?

328
00:20:13,200 --> 00:20:15,140
[విద్యార్థి] జేరోయేత్ పాత్ర. >> [మలన్] జేరోయేత్ పాత్ర.

329
00:20:15,140 --> 00:20:19,620
లేదా, మరింత మానవ వంటి, T లో మొదటి అక్షరం, ఆ ఏమైనా H బహుశా ఈ విషయంలో.

330
00:20:19,620 --> 00:20:24,990
మరియు toupper అది దేనిని. దానిని యొక్క జేరోయేత్ పాత్ర క్యాపిటల్ అక్షరాలలో మరియు మార్చుకుంటారు.

331
00:20:24,990 --> 00:20:28,430
ఈ t యొక్క జేరోయేత్ పాత్ర తీసుకుంటాయి కాబట్టి, అది పెద్ద తయారు

332
00:20:28,430 --> 00:20:30,320
మరియు అదే స్థానంలో తిరిగి ఉంచండి.

333
00:20:30,320 --> 00:20:35,540
నేను చిన్న లో హలో టైప్ చేస్తే, ఈ ఒక రాజధాని H. కు చిన్న h మార్చాలి

334
00:20:35,540 --> 00:20:41,400
కానీ సమస్య లైన్స్ లో 35 మరియు నేను గురించి నేను ఏమి 36 మాకు s మరియు t కోసం ప్రింట్ ఉంటుంది.

335
00:20:41,400 --> 00:20:43,120
మరియు మీ hunch ఏది?

336
00:20:43,120 --> 00:20:47,250
నిజానికి నేను చిన్న లో హలో లో టైప్ చూడండి ఏమి వెళ్తున్నాను?

337
00:20:47,250 --> 00:20:52,280
ఏ ముద్రించిన పెట్టడానికి జరగబోతోంది? >> [వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి?

338
00:20:52,280 --> 00:20:58,360
[విద్యార్థి] బిగ్ H మరియు మిగిలిన చిన్న. చిన్న >> పెద్ద H మరియు మిగిలిన ఇది కోసం, s లేదా t?

339
00:20:58,360 --> 00:21:03,170
[విద్యార్థి] రెండూ. >> రెండూ. సరిగ్గా. ఇక్కడ ఏమి చూద్దాం.

340
00:21:03,170 --> 00:21:08,380
>> నాకు ముందుకు వెళ్లి ఈ సంకలనం లెట్. ఈ copy1, కాబట్టి copy1 చేయండి. అన్ని కుడి.

341
00:21:08,380 --> 00:21:14,840
చిన్న లో హలో: నాకు ముందుకు వెళ్లి copy1 అమలు, Enter, ఏదైనా చెప్పండి లెట్ సైన్ జూమ్ చెయ్యండి.

342
00:21:14,840 --> 00:21:19,570
, కాపీ క్యాపిటల్, కానీ ఇది స్పష్టంగా అదే అసలు క్యాపిటల్

343
00:21:19,570 --> 00:21:22,070
ఇప్పుడు ఈ కథ జరుగుతుంది ఎందుకంటే?

344
00:21:22,070 --> 00:21:27,030
లైన్ 27 లో నేను నిజానికి, స్ట్రింగ్ కాపీ చేయబడుతుంది కనిపించడం లేదు

345
00:21:27,030 --> 00:21:30,450
కానీ మీరు intuitively కేసు అని భావించాడు ఉండవచ్చు అయినప్పటికీ,

346
00:21:30,450 --> 00:21:33,680
మీరు ఈ చిత్రాన్ని గురించి అనుకుంటే, ఏ నిజంగా నేను చేసిన?

347
00:21:33,680 --> 00:21:35,410
చిత్రం సగం ఉంటుంది.

348
00:21:35,410 --> 00:21:39,390
ఇంకా కథ లేదు కాబట్టి కాబట్టి యొక్క తిరిగి సమయంలో రోల్ తెలియజేయండి.

349
00:21:39,390 --> 00:21:43,160
S కథ ఉన్నాయి, కానీ లెట్స్ హలో ఈ సమయంలో చిన్న.

350
00:21:43,160 --> 00:21:46,710
నేను నిజానికి సైన్ టైప్ ఏమి నాకు పరిష్కరించడానికి అనుమతిస్తాయి

351
00:21:46,710 --> 00:21:51,280
ఇక్కడ ఈ సందర్భంలో మనం h-e-l-l-o ఉన్నాయి.

352
00:21:51,280 --> 00:21:58,050
మేము అక్షరాలు క్రమం గా డ్రా చేస్తాము, ఇక్కడ నా వేరుచేసే పంక్తులు ఉంచండి మరియు నా \ 0.

353
00:21:58,050 --> 00:22:05,980
కాబట్టి ఈ మేము 24-ish ద్వారా వెంటనే లైన్ 1 గా ఉంది ఇక్కడ ఇవ్వడం లేదా తీసుకుని, అమలు చేశాయి.

354
00:22:05,980 --> 00:22:07,800
ఈ నా మెమరీ చిత్రం.

355
00:22:07,800 --> 00:22:10,800
నేను లైన్ 27 పొందినప్పుడు, ఏమి జరుగుతుంది?

356
00:22:10,800 --> 00:22:14,730
ముందు వలె, నేను ఈ చదరపు వంటి డ్రా మేము ఒక పాయింటర్ పొందండి.

357
00:22:14,730 --> 00:22:19,740
దానిని అని. మరియు సిద్ధంగా దాని విలువ ఏమిటి? ఎవరు తెలుసు? కొన్ని చెత్త విలువ.

358
00:22:19,740 --> 00:22:22,060
>> కాబట్టి దూరంగా ఒక ప్రశ్న గుర్తు వంటి వియుక్త చేస్తాము.

359
00:22:22,060 --> 00:22:27,670
మరియు వెంటనే లైన్ 27 కుడి వైపు అమలు వంటి, నేను t లోపలి ఉంచడం వున్నాను?

360
00:22:27,670 --> 00:22:30,770
s ఉందని ఇదే.

361
00:22:30,770 --> 00:22:34,120
ఒక క్షణం మేము బాణం ఈ ఊహ తొలగించి మేము చెప్పిన అయితే

362
00:22:34,120 --> 00:22:40,330
OH, ఈ మీరు t లు, సెమికోలన్ గెట్స్ చెప్పినప్పుడు మెమరీ లోడ్ చిరునామా 123 ఉంది,

363
00:22:40,330 --> 00:22:42,700
మీరు వాచ్యంగా ఇక్కడ 123 ఉంచడం చేస్తున్నారు.

364
00:22:42,700 --> 00:22:45,200
మేము రకమైన చిత్రాలు మళ్ళీ మన ప్రపంచం సులభతరం ఇప్పుడు ఉంటే,

365
00:22:45,200 --> 00:22:48,750
మీరు నిజంగా చేశాను మీ ప్రపంచానికి మరొక బాణం చేర్చబడింది

366
00:22:48,750 --> 00:22:52,910
ఆ t అదే ఖచ్చితమైన స్ట్రింగ్ సూచించే యొక్క.

367
00:22:52,910 --> 00:22:59,730
కాబట్టి లైన్ 31 మరియు 32 లో నేను నిజంగా t [0] మార్చడం గురించి అనుకుంటే,

368
00:22:59,730 --> 00:23:05,580
t ఏమిటి [0] ఇప్పుడు తో స్పష్టంగా పర్యాయపదంగా? s [0]

369
00:23:05,580 --> 00:23:07,030
కాబట్టి అన్ని జరుగుతున్నది ఆ.

370
00:23:07,030 --> 00:23:09,900
మరియు ఈ విధమైన అయితే అనిపిస్తుంది కొద్దిగా తక్కువ స్థాయిలో మరియు రహస్య

371
00:23:09,900 --> 00:23:12,760
మరియు ఈ విధమైన బహుశా intuitively ఇది పని వుండాలి అనుకుని -

372
00:23:12,760 --> 00:23:15,410
నేను ముందు విషయాలను కాపీలు చేసిన అది పని -

373
00:23:15,410 --> 00:23:18,590
మీరు నిజంగా స్ట్రింగ్ నిజంగా ఏమి గురించి అనుకుంటే, అది ఒక చార్ * ఉంది.

374
00:23:18,590 --> 00:23:21,700
అయితే, అది ఏమిటి? ఇది కొన్ని పాత్ర యొక్క చిరునామా ఉంది.

375
00:23:21,700 --> 00:23:24,930
అప్పుడు బహుశా అది మరింత అర్థవంతంగా ఉంటుంది మీరు ఏదో ఒకటి చేయడానికి ప్రయత్నించినప్పుడు

376
00:23:24,930 --> 00:23:29,220
ఈ వంటి సూపర్ మామూలు, మీరు చేయుచున్నారు అన్ని కాపీ ఒక మెమరీ చిరునామా ఉంది.

377
00:23:29,220 --> 00:23:32,530
మీరు నిజంగా స్ట్రింగ్ తో ఏదైనా చేయడం లేదు.

378
00:23:32,530 --> 00:23:37,500
మీరు సంఖ్య ఆలోచన ఉంది కూడా చేస్తే మీరు, కోడ్ ఈ సమస్యను పరిష్కరించడానికి ఎలా

379
00:23:37,500 --> 00:23:45,080
ఉన్నత స్థాయి, విషయపరంగా, మేము స్పష్టంగా, s యొక్క నిజమైన కాపీ TA చేయడానికి ఏమి చేయాలి?

380
00:23:46,670 --> 00:23:48,820
అవును. >> [విద్యార్థి] అది ఒక న్యూ నగర ఇవ్వండి? ఖచ్చితంగా >>.

381
00:23:48,820 --> 00:23:50,800
>> మేము T ఒక బ్రాండ్ కొత్త ప్రదేశము అవసరం.

382
00:23:50,800 --> 00:23:55,230
మేము, ఏదో మేము మెమరీ కొత్త భాగం పొందండి దీనిలో ప్రపంచ సృష్టించాలి

383
00:23:55,230 --> 00:24:00,090
కేవలం స్పష్టత కోసమని నేను ఈ క్రింద ఒక డ్రా చేస్తాము, కానీ అది అక్కడ అది అవసరం లేదు.

384
00:24:00,090 --> 00:24:04,880
కానీ అదే పరిమాణం ఉండాలి, నేను అదే స్థానంలో నిలువు వరుసలతో డ్రా చేస్తాము.

385
00:24:04,880 --> 00:24:09,720
ఈ ప్రారంభంలో అన్ని చెత్త ఉంటే ఇది మంచిది. ఎవరు ఉంది ఏమి తెలుసు?

386
00:24:09,720 --> 00:24:13,850
నేను అవసరం కానీ స్టెప్ 1 మెమరీని వంటి నాకు ఇవ్వండి ఉంటుంది అన్నారు

387
00:24:13,850 --> 00:24:18,630
హలో కాపీని సరిపోయే, అప్పుడు, ఇక్కడ h కాపీ ఎలా ఇక్కడ ఇ గుర్తించడానికి

388
00:24:18,630 --> 00:24:20,390
ఇక్కడ మొదలైనవి l.

389
00:24:20,390 --> 00:24:24,880
వివరాలు కొన్ని ఇప్పటికీ వియుక్త కూడా అయితే ఈ అప్పటికే కొద్దిగా స్పష్టమైన భావించరు.

390
00:24:24,880 --> 00:24:28,690
ఈ ఈ స్ట్రింగ్ కృతిని కాపీ చేసుకోవచ్చు, ఇది కేవలం లూప్ లేదా కొంత లూప్ యొక్క

391
00:24:28,690 --> 00:24:31,580
లేదా మీరు అన్ని ఉండే విధముగా చేసిన తో ఏదో.

392
00:24:31,580 --> 00:24:35,970
కాబట్టి యొక్క ఈ ప్రయత్నించండి తెలియజేయండి. నాకు copy2.c లోకి వెళ్ళి తెలపండి.

393
00:24:35,970 --> 00:24:43,270
Copy2.c లో మేము లైన్ 27 మినహా దాదాపు అదే ప్రోగ్రామ్ను.

394
00:24:43,270 --> 00:24:47,260
ఇది కాస్త క్లిష్టమైన ఉంది, కానీ మేము ముక్కగా అది విచ్ఛిన్నం ఉంటే

395
00:24:47,260 --> 00:24:48,950
ఎడమ చేతి వైపు ఉంటుంది.

396
00:24:48,950 --> 00:24:52,790
చార్ * t ఒక ప్రశ్న గుర్తు ఉన్నప్పటికీ, మెమరీ లో ఈ విషయం సృష్టిస్తుంది

397
00:24:52,790 --> 00:24:54,680
మేము సంఖ్య ఆలోచన ఉంది ఎందుకంటే సిద్ధంగా ఉన్నాయి ఏమిటి.

398
00:24:54,680 --> 00:24:57,920
కుడి వైపు మేము ఇప్పుడు, ఒక కొత్త ఫంక్షన్ malloc పరిచయం చేస్తున్నారు

399
00:24:57,920 --> 00:25:00,640
మెమరీని కేటాయించాల్సిన కోసం, నాకు మెమరీ ఇవ్వాలని

400
00:25:00,640 --> 00:25:06,900
మరియు ఇది స్పష్టంగా పట్టే అనేక వాదనలు, ఎన్ని కుండలీకరణాలు లోపల విషయాలు?

401
00:25:09,660 --> 00:25:12,130
నేను 1 మరియు 2 యొక్క murmurings విన్నాను, కాని అది కేవలం 1.

402
00:25:12,130 --> 00:25:15,320
కుండలీకరణాలు లోపల కేవలం 1 విషయము అంటే ఏ కామా, ఉన్నాయి.

403
00:25:15,320 --> 00:25:17,720
ఇతర కుండలీకరణాలు ఉంది ఉన్నప్పటికీ, నాకు హైలైట్ తెలియజేయండి

404
00:25:17,720 --> 00:25:21,460
అన్నింటి కుండలీకరణాలు యొక్క లోపల ఏముంది, మరియు ఈ వ్యక్తీకరణ ఉంది:

405
00:25:21,460 --> 00:25:25,880
(Strlen (s) + 1) * sizeof (చార్).

406
00:25:25,880 --> 00:25:29,190
మేము నిజంగా ద్వారా ఈ అనుకుంటే కాబట్టి, ఈ నాకు s యొక్క పొడవు ఇవ్వాలని చెబుతున్నారు.

407
00:25:29,190 --> 00:25:34,440
నేను పొడవు లో 1 జోడించడం, అయితే, వున్నాను? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

408
00:25:34,440 --> 00:25:40,200
సరిగ్గా. మేము తోక వద్ద ఈ గై స్థలాన్ని, ఆంగ్ల అర్థం కలిగి ఆరవ పాత్ర అవసరం

409
00:25:40,200 --> 00:25:42,250
కానీ ప్రత్యేక ప్రోగ్రాముల అర్థం కాదు.

410
00:25:42,250 --> 00:25:46,800
>> కాబట్టి మేము ఆ కోసం ఒక + 1 అవసరం ఎందుకంటే strlen తిరిగి పొడవు యొక్క మానవ నిరీక్షణ,

411
00:25:46,800 --> 00:25:50,890
హలో లేదా 5, మీరు అదనపు శూన్య పాత్ర ఉండదు.

412
00:25:50,890 --> 00:25:52,980
నేను మానవీయంగా + 1 తో ఈ జోడించండి.

413
00:25:52,980 --> 00:25:56,060
మరియు ఈ యొక్క * పరిమాణం (చార్), మేము ఈ ముందు చూడలేదు.

414
00:25:56,060 --> 00:25:57,480
ఈ సాంకేతికంగా ఒక క్రియ కాదు.

415
00:25:57,480 --> 00:26:04,150
ఇది కేవలం ఏ పరిమాణం ఒక కంప్యూటర్లో కొన్ని డేటా రకం మీరు చెబుతుంది ఒక ప్రత్యేక కీవర్డ్ యొక్క

416
00:26:04,150 --> 00:26:06,980
వాస్తవానికి ఎందుకంటే, మాకు కొన్ని 32-bit కంప్యూటర్లు ఉన్నాయి.

417
00:26:06,980 --> 00:26:10,900
నేను ఇంట్లో ఒక అందమైన పాత కంప్యూటర్ కలిగి, మరియు అది మాత్రమే గమనికలు ప్రాతినిధ్యం వహించేందుకు 32 బిట్లను ఉపయోగిస్తుంది.

418
00:26:10,900 --> 00:26:13,900
నేను ఒక డేటా రకాన్ని యొక్క పరిమాణం చేయకుంటే, కనుక 32 బిట్స్ కావచ్చు.

419
00:26:13,900 --> 00:26:18,300
నా కొత్త ఫ్యాన్సీ కంప్యూటర్ ఉపయోగించి నేను, నేను 64 బిట్స్ విలువ తిరిగి ఉండవచ్చు

420
00:26:18,300 --> 00:26:20,510
ఒక చిరునామా వంటి వాటి కోసం.

421
00:26:20,510 --> 00:26:25,400
కాబట్టి ఈ విషయంలో కేవలం సూపర్ సురక్షితంగా ఉంచడానికి, మేము వంటి గట్టి కోడ్ ఏదో వెళ్ళడం లేదు -

422
00:26:25,400 --> 00:26:28,740
అలాగే, మేము ఇప్పటివరకు చెప్పారు చేసిన వాటిని ప్రకారం ఒక చార్ యొక్క పరిమాణం ఏమిటి?

423
00:26:28,740 --> 00:26:34,450
మేము చాలా ఎక్కువగా 1 బైట్, మరియు ఆ అన్ని కోణాల్లో చాలా చక్కని నిజమని మాటలతో చెప్పారు చేసాము.

424
00:26:34,450 --> 00:26:37,000
కానీ మళ్ళీ, అంచనాలు చెడు ఉంటాయి.

425
00:26:37,000 --> 00:26:40,850
ప్రజలు మీరు భావించలేదు విధాలుగా మీ సాఫ్ట్వేర్ను ఉపయోగించడానికి వారు బగ్గీ సాఫ్ట్వేర్ దారి.

426
00:26:40,850 --> 00:26:44,750
కాబట్టి లెట్స్ వియుక్త ఈ దూరంగా మరియు కేవలం మరింత సామాన్యముగా సే

427
00:26:44,750 --> 00:26:46,830
నేను మెమరీ ఈ అనేక భాగాలు అవసరం

428
00:26:46,830 --> 00:26:50,210
మరియు మెమరీ ప్రతి భాగం, ఒక పాత్ర యొక్క పరిమాణం సమానంగా ఉండాలి

429
00:26:50,210 --> 00:26:54,870
ఈ సందర్భంలో 1 సమానంగా నిజానికి ఇది, కానీ అది వ్రాసే మరింత సాధారణ మార్గం.

430
00:26:54,870 --> 00:27:00,460
పదం హలో ఉంటే కాబట్టి, ఎన్ని బైట్లు malloc స్పష్టంగా హలో కోసం కేటాయించే లేదు?

431
00:27:00,460 --> 00:27:04,980
[విద్యార్థి] సిక్స్. >> ఆరు. మేము తెరపై ప్రశ్నార్థకాలుగా కలిగి ఖచ్చితంగా అనేక.

432
00:27:04,980 --> 00:27:07,800
మరియు తర్వాత ఒక ఇప్పుడు GetString యొక్క అర్థం ఆధారంగా అంచనా పడుతుంది

433
00:27:07,800 --> 00:27:12,790
malloc బహుశా ఏ తిరిగి లేదు? >> [విద్యార్థి] ఒక చిరునామా.

434
00:27:12,790 --> 00:27:17,020
ఏ యొక్క చిరునామాను? మెమరీ మొదటి భాగం యొక్క.

435
00:27:17,020 --> 00:27:20,670
>> మేము ఏమి అక్కడ సంఖ్య ఆలోచన ఉంది ఎందుకంటే కొన్ని ఇతర చర్య

436
00:27:20,670 --> 00:27:23,010
గతంలో ఈ మెమరీ ఉపయోగించడం కావచ్చు.

437
00:27:23,010 --> 00:27:28,380
కానీ malloc, GetString వంటి మెమరీ మొదటి బైట్ యొక్క చిరునామా తిరిగి

438
00:27:28,380 --> 00:27:30,540
మీరు ప్రక్కన పెట్టినవి అని.

439
00:27:30,540 --> 00:27:38,380
అయితే, ఏ దీనిని లేదు బాక్ స్లాష్ శూన్య పాత్ర ఈ ఖాళీ పూర్తి ఉంది

440
00:27:38,380 --> 00:27:43,030
ints, తీగలు, శ్రేణులను: మీరు ఏదైనా కేటాయించే malloc ఉపయోగించవచ్చు అది మారుతుంది ఎందుకంటే

441
00:27:43,030 --> 00:27:45,700
తేలుతుంది, విద్యార్థి నిర్మాణాలు.

442
00:27:45,700 --> 00:27:47,750
మీరు పూర్తిగా సామాన్యముగా malloc ఉపయోగించవచ్చు.

443
00:27:47,750 --> 00:27:51,470
ఇది శ్రద్ధ లేదా మీరు మెమరీ పెడుతోంది ఏమి తెలుసుకోవాలి లేదు.

444
00:27:51,470 --> 00:27:55,810
కాబట్టి దీనిని \ 0 ఉంచాలి malloc కోసం presumptuous ఉంటుంది

445
00:27:55,810 --> 00:27:58,340
మెమరీ ప్రతి భాగం యొక్క ముగింపులో మీరు ఇచ్చే యొక్క

446
00:27:58,340 --> 00:28:02,620
ఈ \ 0 విషయం కేవలం తీగల యొక్క కన్వెన్షన్ ఎందుకంటే.

447
00:28:02,620 --> 00:28:06,310
ఇది ints ఉపయోగిస్తారు కాదు, అది తేలియాడుతున్న ఉపయోగిస్తారు కాదు, అది విద్యార్ధులు ఉపయోగిస్తారు కాదు.

448
00:28:06,310 --> 00:28:11,730
కాబట్టి malloc తో gotcha భారం మీరు పూర్తిగా ప్రోగ్రామర్ ఉంటుంది

449
00:28:11,730 --> 00:28:16,790
మీరు కేటాయించింది ఎన్ని బైట్లు గుర్తుంచుకోవడానికి మరియు ఎప్పుడూ లూప్ ఒక ఉపయోగించకూడదని

450
00:28:16,790 --> 00:28:21,570
లేదా కొంత లూప్ మరియు మీరు ఇచ్చిన చేసిన మెమరీ భాగం యొక్క సరిహద్దు గత వెళ్ళండి.

451
00:28:21,570 --> 00:28:23,540
వెంటనే మీకు మెమరీని కేటాయించాల్సిన వంటి, మరొక విధంగా ఉంచండి

452
00:28:23,540 --> 00:28:28,510
మీరు ఆపరేటింగ్ సిస్టమ్ అడగవు, OH, ద్వారా, ఈ ఎలా మెమరీ భాగం యొక్క పెద్ద ఉంది?

453
00:28:28,510 --> 00:28:32,080
మీరు ఆ విలువ అవసరం ఉంటే గుర్తు వరకు మీరు పూర్తిగా ఉంది.

454
00:28:32,080 --> 00:28:34,330
>> నేను ఈ మెమరీ ఉపయోగించడానికి ముందుకు ఎలా చూడటానికి.

455
00:28:34,330 --> 00:28:38,430
లైన్ 28 మరియు 29 లో నేను ఇలా చేస్తున్నాను?

456
00:28:39,850 --> 00:28:42,260
జస్ట్ మొత్తం తెలివి చెక్.

457
00:28:42,260 --> 00:28:45,110
ఏదో తప్పు జరిగింది ఒకవేళ, నేను మెమరీ కొన్ని క్రేజీ మొత్తం ఎంటర్టైన్

458
00:28:45,110 --> 00:28:48,690
లేదా నేను అనేక మైన, కేవలం తగినంత మెమరీ సామర్థ్యం ఉండదు ఆ కంప్యూటర్లో అమలు

459
00:28:48,690 --> 00:28:51,780
అలాంటిదే, నేను కనీసం శూన్య తనిఖీ మీరు.

460
00:28:51,780 --> 00:28:55,260
వాస్తవంలో, అనేక మంది కంప్యూటర్లు మీరు భ్రమ ఇస్తుంది ప్రతి కార్యక్రమం

461
00:28:55,260 --> 00:28:57,080
మీ RAM మొత్తం ఉపయోగించవచ్చు,

462
00:28:57,080 --> 00:29:00,740
కానీ చాలా, బహుశా కొన్ని క్రేజీ దీర్ఘ స్ట్రింగ్ లో యూజర్ రకాల ఉంటే వారు ఒక చెడ్డ నువ్వే ఎందుకంటే

463
00:29:00,740 --> 00:29:03,440
మరియు వారు నిజానికి, అది మీ ప్రోగ్రామ్ లేదా హాక్ క్రాష్ ప్రయత్నిస్తున్న

464
00:29:03,440 --> 00:29:07,300
మీరు కనీసం malloc తిరిగి విలువ తనిఖీ మీరు మరియు అది శూన్య సమానం అని.

465
00:29:07,300 --> 00:29:11,630
మరియు అది ఉంటే, నేను ఆ సందర్భంలో ఏమి తెలియదు ఎందుకంటే యొక్క ప్రస్తుతం విడిచి తెలియజేయండి.

466
00:29:11,630 --> 00:29:13,950
నేను స్ట్రింగ్ కాపీ చెయ్యాలి? దీన్ని కొన్ని మార్గాలు ఉన్నాయి.

467
00:29:13,950 --> 00:29:18,850
అక్కడ STR సి లో విధులు కాపీ, కానీ మాకు ఈ పాత ఫ్యాషన్ విధంగా చేయడానికి ఇది సులభమైన సూపర్ ఉంది.

468
00:29:18,850 --> 00:29:23,110
>> మొదటి నాకు s యొక్క పొడవు ఏ గుర్తించడానికి అనుమతిస్తాయి.

469
00:29:23,110 --> 00:29:26,930
నేను లూప్ లో ఈ చేసి ఉండవచ్చు కానీ బదులుగా నేను స్పష్టత కోసం ఇక్కడ ఉంచారు.

470
00:29:26,930 --> 00:29:30,610
కాబట్టి n ఇప్పుడు స్పష్టంగా 5 ఇది అసలు స్ట్రింగ్ యొక్క పొడవు, నిల్వ చేస్తుంది.

471
00:29:30,610 --> 00:29:35,290
నా కోసం లూప్ లో నేను, n వరకు న 0 నుండి iterating నేను

472
00:29:35,290 --> 00:29:40,940
మరియు ప్రతి పునరావృతం న నేను చూస్తూ నేను s [i] t లోపలి [i].

473
00:29:40,940 --> 00:29:45,060
అక్కడ నేను ముందు తీగలను వద్ద గురిపెట్టి నా 2 వేళ్ళతో సూచించినట్లు ఏమిటి.

474
00:29:45,060 --> 00:29:49,260
లూప్ ఈ ఈ వంటి iterates, నేను, ఇక్కడ లోకి h కాపీ చేయబడుతుంది వెళుతున్న

475
00:29:49,260 --> 00:29:52,890
ఇక్కడ, l ఇక్కడ లోకి లోకి ఇ ఈ లు ఎందుకంటే, ఈ t ఉంది.

476
00:29:52,890 --> 00:29:58,770
మరియు తర్వాత చివరగా, లైన్ 35 లో నేను ఇలా చేస్తున్నాను?

477
00:29:58,770 --> 00:30:03,770
నేను స్ట్రింగ్ t ముగింపు కాబట్టి నిర్ధారించుకోవాలనుకుంటున్నాము.

478
00:30:03,770 --> 00:30:06,170
నేను స్పష్టమైన సూపర్ అని దానిని ఈ విధంగా చేసాడు.

479
00:30:06,170 --> 00:30:09,510
కానీ, మీరు చేయగలిగితే,, ఇలా వేరే మార్గం ఎవరైనా ప్రతిపాదిస్తున్నాయి.

480
00:30:09,510 --> 00:30:13,930
నేను నిజంగా లైన్ 35 లేదు. దీన్ని మరొక విధంగా ఉన్నాయి.

481
00:30:13,930 --> 00:30:18,880
అవును. >> [వినబడని విద్యార్థి ప్రతిస్పందన] >> అది బిగ్గరగా సే.

482
00:30:18,880 --> 00:30:20,960
[విద్యార్థి] కన్నా తక్కువ లేదా సమానం. ఖచ్చితంగా >>.

483
00:30:20,960 --> 00:30:24,450
మేము కంటే తక్కువ లేదా సాధారణంగా చెడు ఉంది n, సమానంగా చెప్పగల్గినవి

484
00:30:24,450 --> 00:30:28,190
మేము లెక్కింపు చేస్తున్న విషయం కూడా సమాన వరకు వెళ్ళి దాదాపు ఎల్లప్పుడూ ఉన్నప్పుడు ఎందుకంటే

485
00:30:28,190 --> 00:30:30,000
మేము చాలా దూరం 1 దశల వెళ్ళండి.

486
00:30:30,000 --> 00:30:32,170
కానీ గుర్తుంచుకోండి, మేము ఎన్ని బైట్లు కేటాయించాలని చేశారు?

487
00:30:32,170 --> 00:30:37,210
మేము 6 మొత్తం, కాబట్టి 5 + 1 S యొక్క strlen కేటాయించింది.

488
00:30:37,210 --> 00:30:39,980
కాబట్టి ఈ విషయంలో మేము ఈ వంటి ఏదో ఒకటి కాలేదు

489
00:30:39,980 --> 00:30:46,450
మేము చాలా చివరిలో కేవలం హలో కూడా \ 0 లేదు కాపీ చేసిన కాబట్టి.

490
00:30:46,450 --> 00:30:49,860
ప్రత్యామ్నాయంగా, మేము, strcpy, STR కాపీ అని ఒక ఫంక్షన్ ఉపయోగించవచ్చు

491
00:30:49,860 --> 00:30:51,700
కానీ దాదాపు చాలా సరదాగా కాదు.

492
00:30:51,700 --> 00:30:54,000
కాని ఇది హుడ్ కింద చేస్తుంది అంతే.

493
00:30:54,000 --> 00:30:56,050
అప్పుడు చివరగా, మేము ముందు గా ఇదే.

494
00:30:56,050 --> 00:31:01,620
నేను t పెట్టుబడి మరియు అప్పుడు నేను అసలు ఈ మరియు కాపీ అనిపిస్తుంది కనిపిస్తోంది పేర్కొన్నారు.

495
00:31:01,620 --> 00:31:08,570
కాబట్టి యొక్క ఇప్పుడు ఈ ప్రయత్నించండి తెలియజేయండి. నాకు ఇక్కడ వెళ్ళి తెలపండి. Copy2 చేయండి. మేము లో జూమ్ మరియు copy2 అమలు చేస్తాము.

496
00:31:08,570 --> 00:31:13,840
నేను చిన్న లో హలో టైప్ వెళుతున్న, నిజానికి నేను అసలు హలో చిన్న పొందండి

497
00:31:13,840 --> 00:31:16,930
కానీ కాపీ కోసం హలో రాజధాని.

498
00:31:16,930 --> 00:31:20,300
కానీ నేను ఇంకా పూర్తి కాదు. నేను ఇక్కడ 1 లాస్ట్ థింగ్ చేయాలి.

499
00:31:20,300 --> 00:31:28,000
46 మరియు 47 స్పష్టంగా మెమరీ ఉండండి, కానీ వాస్తవానికి అర్థం ఏమిటి?

500
00:31:28,000 --> 00:31:33,250
నేను లైన్ 46 మరియు 47 లైన్ కాల్ మీరు, అనుకుంటున్నాను, ఏమి చేస్తున్న?

501
00:31:33,250 --> 00:31:38,900
ఏ ప్రభావం కలిగి ఉన్నారు? అవును.

502
00:31:38,900 --> 00:31:43,140
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఖచ్చితంగా.

503
00:31:43,140 --> 00:31:46,380
>> మీకు హే, ఇది మెమరీ ధన్యవాదాలు ఆపరేటింగ్ సిస్టమ్ చెప్పడం ఉంటాయి.

504
00:31:46,380 --> 00:31:48,320
మీరు ఇప్పుడు ఎవరో దానిని ఉపయోగించవచ్చు.

505
00:31:48,320 --> 00:31:50,790
మరియు ఇక్కడ చెత్త విలువలు మంచి ఉదాహరణగా ఉంది.

506
00:31:50,790 --> 00:31:55,430
నేను, 2 స్థానాల్లో హలో పదం వ్రాయుటకు ఈ మెమరీ ఉపయోగించారు

507
00:31:55,430 --> 00:31:57,490
ఇక్కడ, ఇక్కడ, ఇక్కడ, మరియు ఇక్కడ.

508
00:31:57,490 --> 00:32:00,910
కాబట్టి ఈ h-e-l-l-o-\ 0.

509
00:32:00,910 --> 00:32:06,960
కానీ నేను లైన్ 46 మరియు 47 లైన్ కాల్, మరియు మీరు చిత్రాన్ని పరంగా అక్కడ ఏమి తెలుసు?

510
00:32:06,960 --> 00:32:10,010
అసలైన, వేచి, ఈ చిత్రం పాత ఒకటి.

511
00:32:10,010 --> 00:32:12,550
మేము కాపీని ఒకసారి, ఈ వ్యక్తి నిజంగా, ఇక్కడ సూచించబడిన

512
00:32:12,550 --> 00:32:16,110
మరలా సంఖ్యలు తొలగించి కేవలం వియుక్త దూరంగా మా బాణాలు వంటి చూద్దాం.

513
00:32:16,110 --> 00:32:19,370
నేను ఉచిత కాల్ ఏమి ఈ చిత్రంలో జరుగుతుంది?

514
00:32:19,370 --> 00:32:22,750
[వినబడని విద్యార్థి ప్రతిస్పందన] >> కూడా.

515
00:32:22,750 --> 00:32:29,510
నేను s మరియు t ఉచిత కాల్ ఉంటే - ఒక ట్రిక్ ప్రశ్న రకం - ఈ చిత్రం అన్ని వద్ద మారదు

516
00:32:29,510 --> 00:32:33,880
s కాల్ మరియు కాలింగ్ ఎందుకంటే t కేవలం, ఆపరేటింగ్ సిస్టమ్ చెబుతుంది

517
00:32:33,880 --> 00:32:39,010
హేయ్, మీరు మళ్లీ ఈ మెమరీ ఉపయోగించవచ్చు, కానీ ఈ శూన్యం మార్పు లేదు

518
00:32:39,010 --> 00:32:41,840
లేదా కొన్ని ప్రత్యేక పాత్ర అది, ఈ మారదు

519
00:32:41,840 --> 00:32:47,350
అది h లేదా ఇ లేదా మరేదైనా గానీ స్థానంలో l లేదా l లేదా o మారదు.

520
00:32:47,350 --> 00:32:51,610
చిత్రం పరంగా, వెంటనే మీకు ఉచిత, ఏమీ మార్పులు కాల్ వంటి.

521
00:32:51,610 --> 00:32:56,570
మరియు అందులో చెత్త విలువలు మూలం ఉంది ఎందుకంటే నేను తర్వాత ఈ కార్యక్రమం లో

522
00:32:56,570 --> 00:33:01,010
ఆ GetString లేదా malloc లేదా లాగ మరింత మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడగండి

523
00:33:01,010 --> 00:33:04,900
మరియు ఆపరేటింగ్ సిస్టమ్, ఖచ్చితంగా, నేను కేవలం విముక్తి మెమరీ 12 బైట్లు కలిగి అన్నారు

524
00:33:04,900 --> 00:33:08,080
ఈ ఉపయోగించడానికి, మీరు జారీ వెళ్తున్నారు?

525
00:33:08,080 --> 00:33:10,830
మీరు మేము సాధారణంగా అందుకున్నాయి ఆ మెమరీ భాగం జారీ వెళుతున్న

526
00:33:10,830 --> 00:33:13,700
ప్రశ్న మార్కులతో, కాని ఆ ప్రశ్న గుర్తులు ఏవి?

527
00:33:13,700 --> 00:33:17,000
H-e-l-l-o, h-e-l-l-o కావడం.

528
00:33:17,000 --> 00:33:20,940
ఈ వెంటనే ఆ మెమరీ వరకు ఉచితం గా మా కొత్త చెత్త విలువలు.

529
00:33:20,940 --> 00:33:22,750
>> ఒక నిజ ప్రపంచ సూత్రప్రాయంగా చాలా ఇక్కడ ఉంది.

530
00:33:22,750 --> 00:33:24,720
ఈ RAM తో జరుగుతుంది, కానీ మీ కంప్యూటర్ల

531
00:33:24,720 --> 00:33:26,720
వాస్తవానికి డిస్క్ తో ఇదే.

532
00:33:26,720 --> 00:33:30,620
మేము ఫోరెన్సిక్స్ దృష్టి సారించిన ఒక భవిష్యత్తు సమస్య సమితి ముఖ్యంగా ఈ గురించి మాట్లాడదాము.

533
00:33:30,620 --> 00:33:36,170
మీరు మీ డెస్క్టాప్ మీద కొన్ని సున్నితమైన ఆర్థిక ఫైలుని కలిగి ఉంటే కాని వాస్తవానికి జరుగుతుంది

534
00:33:36,170 --> 00:33:39,600
లేదా కొన్ని నమూనాలను JPEG మరియు మీరు, మీ ట్రాష్ లోకి లాగండి

535
00:33:39,600 --> 00:33:44,390
మీరు ట్రాష్ లేదా రీసైకిల్ బిన్ లోకి లాగండి ఏమి జరుగుతుంది?

536
00:33:44,390 --> 00:33:47,240
మీరు నేను మాట్లాడుతున్న తెలుసు. [నవ్వు]

537
00:33:47,240 --> 00:33:52,370
మీరు మీ రీసైకిల్ బిన్ లేదా ట్రాష్ కెన్ ఆ సాక్ష్యం లాగారు చేసిన ఏమి జరుగుతుంది?

538
00:33:52,370 --> 00:33:55,920
[వినబడని విద్యార్థి ప్రతిస్పందన]

539
00:33:55,920 --> 00:33:58,000
Well, కాబట్టి జాగ్రత్తగా. మీరు అలా ఏమి జరుగుతుంది?

540
00:33:58,000 --> 00:34:01,030
చిన్న సమాధానం కుడి, కాదు?

541
00:34:01,030 --> 00:34:04,790
అసంపూర్ణం లేదా సున్నితమైన ఫైల్ ఇంకా మీ హార్డు డ్రైవు ఎక్కడో అక్కడ కూర్చొని.

542
00:34:04,790 --> 00:34:07,940
మాకు చాలా కనీసం మీరు మీ ట్రాష్ను ఖాళీ చేయవలసి ఎంత క్లిష్టంగా ఉందో చేశారు

543
00:34:07,940 --> 00:34:10,429
లేదా మీ రీసైకిల్ బిన్ నిజానికి ఫైళ్ళను తొలగించడానికి.

544
00:34:10,429 --> 00:34:13,440
నిజానికి, మీరు కుడి క్లిక్ చేయండి లేదా మీ ట్రాష్ క్లిక్ నియంత్రించండి ఉన్నప్పుడు చెయ్యవచ్చు

545
00:34:13,440 --> 00:34:15,580
లేదా ఫైలు, ఖాళీ ట్రాష్ లేదా ఎలాగైనా ఎంచుకోండి

546
00:34:15,580 --> 00:34:21,420
మరియు మీరు నిజంగానే ట్రాష్ కెన్ లేదా వాస్తవానికి ఈ చిత్రానికి అప్పుడు ఏమి రీసైకిల్ బిన్, ఖాళీ?

547
00:34:22,810 --> 00:34:25,969
మరిన్ని ఏమీ. ఏదీ నిజానికి డిస్కు న జరుగుతుంది.

548
00:34:25,969 --> 00:34:30,880
>> మేము తాత్కాలికంగా రచనలో ప్రస్తుతం ప్రస్తావిస్తున్న అంశాన్ని వదిలేసి వేరే అంశం గురించి చర్చించు మరియు వ్రాయడానికి ఉంటే - I'll ఈ వెనుక ఉపయోగించండి.

549
00:34:30,880 --> 00:34:34,639
కాబట్టి ఇప్పుడు కథ కార్యక్రమాలు అక్కడకు ఇది RAM నుండి మారుతుంది

550
00:34:34,639 --> 00:34:39,250
మీరు డిస్కు, వాటిని అమలు చేస్తున్నారు వారు దీర్ఘకాల నిల్వ ఇక్కడ, ఇది

551
00:34:39,250 --> 00:34:42,920
శక్తి ఇప్పుడు కోసం, విడుదలయ్యింది కూడా - మరియు మేము భవిష్యత్తులో ఈ వచ్చి ఉంటుంది -

552
00:34:42,920 --> 00:34:46,380
లెట్స్ ఈ మీ కంప్యూటర్ యొక్క హార్డ్ డ్రైవ్ లోపల ప్రాతినిధ్యం నటిస్తారు

553
00:34:46,380 --> 00:34:50,110
ఎందుకంటే తన రోజు వారు చాలా ఫ్లాపీ డిస్కుల వంటి వృత్తాకార డిస్కులు ఉండేవారు.

554
00:34:50,110 --> 00:34:55,130
మీరు కొన్ని సున్నితమైన Excel ఫైల్ కలిగి చేస్తే, అది మెమొరీ ఈ భాగం పట్టవచ్చు

555
00:34:55,130 --> 00:34:59,770
మీ కంప్యూటర్ యొక్క డిస్కులో, మరియు నేను అదే ఏకపక్ష 1s మరియు 0 సె గీయడం చేస్తున్నాను.

556
00:34:59,770 --> 00:35:03,970
మీ ట్రాష్కు వలె లాగండి చేసినప్పుడు లేదా బిన్ రీసైకిల్ చేయవచ్చు,

557
00:35:03,970 --> 00:35:07,750
ఆపిల్ మరియు మైక్రోసాఫ్ట్ కేవలం నిర్ణయించుకున్నాను ఎందుకంటే అక్షరాలా ఏమీ జరగలేదు

558
00:35:07,750 --> 00:35:10,450
ట్రాష్ కెన్ మరియు రీసైకిల్ బిన్ నిజంగా ఒక తాత్కాలిక ప్రతిక్షేపణిలు.

559
00:35:10,450 --> 00:35:14,710
బహుశా చివరికి OS మీరు ఖాళీ ఉంటుంది, కానీ సాధారణంగా, ఇది ఏదీ చెయ్యవద్దు

560
00:35:14,710 --> 00:35:17,090
మీరు ఖాళీ న నిజంగా తక్కువ ఉన్నారు కనీసం వరకు.

561
00:35:17,090 --> 00:35:20,870
>> అయితే, మీరు ఖాళీ ట్రాష్ లేదా ఖాళీ రీసైకిల్ బిన్ వెళ్లి,

562
00:35:20,870 --> 00:35:23,460
అదేవిధంగా, ఏమీ ఈ చిత్రం ఏమవుతుంది.

563
00:35:23,460 --> 00:35:28,590
జరిగినప్పుడు అన్ని చోట్ల మీ కంప్యూటర్లో ఉంది, టేబుల్ యొక్క రకమైన ఉంది.

564
00:35:28,590 --> 00:35:35,400
ఇది, resume.doc, సే అనుమతించే అని కొద్దిగా మోసగాడు షీట్ వంటి విధమైన యొక్క

565
00:35:35,400 --> 00:35:40,920
మీ హార్డ్ డిస్క్ లో నగర 123 వద్ద ఉన్నాను ఒక Microsoft Word ఫైల్ లో మీ రెజ్యూమ్

566
00:35:40,920 --> 00:35:43,710
కాదు మెమరీ మరియు కాదు RAM లో కాని మీ హార్డ్ డిస్క్లో,

567
00:35:43,710 --> 00:35:49,050
మరియు 456 మీ నమూనాలను JPEG జీవితాలను, మరియు మీ Excel ఫైల్ 789 వద్ద లేదా అక్కడ నివసిస్తున్నారు.

568
00:35:49,050 --> 00:35:53,640
మీరు నిజంగా చెత్త లేదా రీసైకిల్ బిన్ ఖాళీ ద్వారా ఫైళ్లను తొలగిస్తున్నప్పుడు,

569
00:35:53,640 --> 00:35:59,530
ఈ చిత్రం మారదు. మీ హార్డు డ్రైవు 0 సె మరియు 1s ఎక్కడైనా వెళ్ళరు.

570
00:35:59,530 --> 00:36:03,930
కానీ ఈ పట్టిక, రకాల ఈ చిన్న డేటాబేస్, మార్పు చేస్తుంది.

571
00:36:03,930 --> 00:36:08,750
ఫైలు కొన్ని భావంలో తొలగించబడుతుంది అయితే మీరు మీ పునఃప్రారంభం తొలగించండి, అది ఉంది

572
00:36:08,750 --> 00:36:12,790
ఆ విషయం మీ హార్డు డ్రైవు జీవించింది కానీ కంప్యూటర్ మర్చిపోతే ఉంది లేదు.

573
00:36:12,790 --> 00:36:17,870
మీ రెస్యూమ్ లేదా ఈ ఇతర ఫైళ్ళలో ఏదైనా సృష్టించే 0 సె మరియు 1s ఇప్పటికీ చెక్కుచెదరకుండా.

574
00:36:17,870 --> 00:36:21,960
>> మీరు అనుకోకుండా ఈ చేశాడు అలా అయితే, నాన్ జీరో సంభావ్యత ఇప్పటికీ ఉంది

575
00:36:21,960 --> 00:36:25,800
మీరు నార్టన్ యుటిలిటీస్ లేదా కొన్ని వాణిజ్య సాఫ్ట్వేర్ ఉపయోగించి మీ డేటాను పునరుద్ధరించడానికి చేయవచ్చు

576
00:36:25,800 --> 00:36:29,810
జీవితంలో దీని ఉద్దేశ్యం 0 సె మరియు విధమైన అనాథ చేసిన 1s కనుగొనేందుకు ఉంది

577
00:36:29,810 --> 00:36:33,300
ఇక్కడ మర్చిపోయి కాని మీరు తిరిగి మీ డేటా పొందవచ్చు కనుక, ఇక్కడ వదిలి.

578
00:36:33,300 --> 00:36:38,410
లేదా పోలీసు లేదా FBI తో ఫోరెన్సిక్ పరిశోధకులు వాస్తవానికి హార్డ్ డ్రైవ్ పడుతుంది

579
00:36:38,410 --> 00:36:42,550
మరియు వాస్తవానికి, 0 సె మరియు JPEGs ఎలా, Excel ఫైళ్లను మాదిరిగానే కన్పిస్తాయి 1s యొక్క నమూనాలు కోసం చూడండి

580
00:36:42,550 --> 00:36:46,400
మరియు వాటిని కంప్యూటర్ వాటిని మర్చిపోయారు ఉన్నప్పటికీ ఆ విధంగా తిరిగి.

581
00:36:46,400 --> 00:36:49,820
కాబట్టి మేము భవిష్యత్తులో చర్చించడానికి వీలుగా డేటా తొలగించడానికి నిజంగా ఏకైక మార్గం,

582
00:36:49,820 --> 00:36:54,190
ద్వారా ఫైల్ లేదా హార్డ్ డిస్క్ కుంచెతో శుభ్రం చేయు లేదా తుడిచివేయడానికి ఉంది -

583
00:36:54,190 --> 00:36:56,540
మీరు నిజంగా 0 సె మరియు 1s వదిలించుకోవటం కాదు

584
00:36:56,540 --> 00:36:59,440
లేకపోతే మీరు ఒక గిగాబైట్ హార్డు డ్రైవు ప్రారంభం కావలసిన ఎందుకంటే

585
00:36:59,440 --> 00:37:02,380
మీరు ఎప్పుడు తొలగించడం వలన మరియు మీరు ఒక మెగాబైట్ హార్డ్ డ్రైవ్ తో ముగుస్తుంది భావిస్తున్న

586
00:37:02,380 --> 00:37:04,380
సాహిత్యపరంగా, 0 సె మరియు 1s.

587
00:37:04,380 --> 00:37:06,310
మీరు నిజంగా మీ ట్రాక్స్ పూర్తి చేయాలని అనుకుంటున్నట్లు చేస్తే మీరు ఏమి చేస్తుంది

588
00:37:06,310 --> 00:37:10,510
మరియు ప్రాథమిక సమస్య ఇప్పటికీ 0 సె మరియు డిస్కులో 1s అక్కడ ఉంది?

589
00:37:10,510 --> 00:37:14,930
నేను మీరు భౌతికంగా పరికరం బ్రేక్ అని సైగలు చేయగల ఎవరైనా చూడండి. ఆ పని చేస్తుంది.

590
00:37:14,930 --> 00:37:19,600
అత్యంత ఖరీదైన పరిష్కారం రకంగా ఉంటే [నవ్వు] కానీ, ఏమి మరింత సమంజసమైన ఉంటుంది?

591
00:37:19,600 --> 00:37:23,270
అవును. >> [విద్యార్థి] వాటిని ఓవర్రైట్. >> ఏ వాటిని భర్తీ చేయాలా? >> [విద్యార్థి] ఇతర డేటా.

592
00:37:23,270 --> 00:37:29,070
ఇతర డేటా. మీరు 0 సె లేదా 1s లేదా అన్ని 0 సె, అన్ని 1s మీ డిస్కు తిరిగి రాస్తుంది చేయవచ్చు.

593
00:37:29,070 --> 00:37:31,230
>> మరియు సాఫ్ట్వేర్ కొన్ని ఏమి నిజంగా ఉంది.

594
00:37:31,230 --> 00:37:33,570
మీరు, సాఫ్ట్వేర్ కొనుగోలు లేదా ఉచిత సాఫ్టువేరు పొందవచ్చు

595
00:37:33,570 --> 00:37:36,610
మరియు, తక్కువగా Windows లో, ఈ రోజుల్లో Mac OS కు నిర్మించారు

596
00:37:36,610 --> 00:37:38,660
సురక్షితంగా తొలగించ సామర్ధ్యం.

597
00:37:38,660 --> 00:37:41,960
మీరు నేడు అన్ని హోం రన్ అనుకుంటే అసలైన, మీరు ఒక Mac మరియు ఈ లేకపోతే

598
00:37:41,960 --> 00:37:45,740
మీరు పొందారు మీ ట్రాష్ లో కొన్ని అంశాలు, మీరు, సురక్షిత ఖాళీ ట్రాష్ చేయవచ్చు చేయవచ్చు

599
00:37:45,740 --> 00:37:47,610
ఇది ఖచ్చితంగా ఆ చేస్తుంది.

600
00:37:47,610 --> 00:37:53,350
అయితే ఇక్కడ కేవలం చెరిపివేయి ఫైళ్లు కంటే, అది, 0 సె మరియు 1s ఇక్కడ వేయండి లేదు

601
00:37:53,350 --> 00:38:01,240
బదులుగా, అది కేవలం 0 సె మరియు డాట్, డాట్, డాట్ కు, ఉదాహరణకు, వాటిని అన్ని మార్పులు.

602
00:38:01,240 --> 00:38:05,330
మీ భవిష్యత్తు psets ఒకటి నిజానికి కావాలని డేటాను పునరుద్ధరించడానికి ఉంటుంది -

603
00:38:05,330 --> 00:38:08,430
మేము ప్రాంగణంలో వ్యక్తులు, ప్రదేశాలు, మరియు విషయాల తీసిన చేసిన ఛాయాచిత్రాలు

604
00:38:08,430 --> 00:38:12,810
ఇది కోసం మేము, ఒక డిజిటల్ కెమెరా యొక్క మెమరీ కార్డ్ ఒక ఫోరెన్సిక్ చిత్రం చేస్తాము

605
00:38:12,810 --> 00:38:17,120
ఇది ఖచ్చితమైన ఆలోచన - మరియు మీరు నిజంగానే కనుగొనేందుకు సవాలు ఉంటుంది

606
00:38:17,120 --> 00:38:20,160
మీ హార్డు డ్రైవు JPEGs సూచించే నమూనాలు,

607
00:38:20,160 --> 00:38:23,610
చాలా దీని ఇమెయిల్ మాజీ విద్యార్ధి అని నేను కొన్ని వారాల క్రితం చదివిన చేశాడు

608
00:38:23,610 --> 00:38:25,860
తన సోదరి ఛాయాచిత్రాలను తిరిగి.

609
00:38:25,860 --> 00:38:30,300
ఎందుకు మేము ఇక్కడ ఒక 5 నిమిషాల విరామం లేదు, మరియు మేము జ్ఞాపకశక్తి ఎక్కువ పునఃసమీకరించుకోగలిగాడు చేస్తాము.

610
00:38:33,030 --> 00:38:38,610
కాబట్టి ఇక్కడ విషయాలు కొద్దిగా మనస్సు-వంచి చోటే, కానీ ఇది చాలా శక్తివంతమైన అడుగు

611
00:38:38,610 --> 00:38:40,480
ఈ అన్ని మరింత అర్థం చేసుకునేందుకు.

612
00:38:40,480 --> 00:38:42,900
ఇక్కడ pointers.c అనే ప్రోగ్రామ్.

613
00:38:42,900 --> 00:38:45,430
ఇది నేటి నమూనా కోడ్ ఉంది.

614
00:38:45,430 --> 00:38:51,280
మొదటి కొన్ని లైన్లు లో, 22 ద్వారా 19, మేము చేస్తున్నా అన్ని GetString వంటి ఏదో ఉంది అని గుర్తించలేకపోతే

615
00:38:51,280 --> 00:38:54,460
మరియు s లో నిల్వ, ఒక చిరునామా వచ్చారు.

616
00:38:54,460 --> 00:38:58,380
ఇకమీదట pset కూడా 3 మీకు కావలసిన అయితే pset 4 మరియు న

617
00:38:58,380 --> 00:39:01,030
మీరు, మీ ఆఫ్ ఈ శిక్షణ చక్రాలు మొదలయ్యాయి చేయవచ్చు

618
00:39:01,030 --> 00:39:04,030
తీగలను ఇకపై ఉనికిలో నటిస్తాడు ఏ కారణం ఉంది.

619
00:39:04,030 --> 00:39:07,030
ఇది కచ్చితంగా కేవలం చార్ * చెప్పడం మొదలు సరైందే.

620
00:39:07,030 --> 00:39:12,610
>> జనాంతికంగా, ఆన్లైన్ సూచనలు మరియు పుస్తకాలలో మీరు తరచుగా వేరియబుల్ పక్కన స్టార్ చూడవచ్చు.

621
00:39:12,610 --> 00:39:15,600
మీరు కూడా ఇది రెండు భుజాల చుట్టూ ఖాళీలు చూడవచ్చు.

622
00:39:15,600 --> 00:39:17,680
ఆ అన్ని క్రియాశీలంగా సరైన ఉన్నాయి.

623
00:39:17,680 --> 00:39:21,180
ఇప్పుడు కోసం, అయితే, మేము సూపర్ క్లియర్ చేయడానికి ఈ విధానాన్ని ప్రామాణికంగా చేస్తాము

624
00:39:21,180 --> 00:39:24,000
ఆ చార్ * పాత్ర పాయింటర్ చెప్పడం వంటిది.

625
00:39:24,000 --> 00:39:25,680
ఆ డేటా రకం.

626
00:39:25,680 --> 00:39:28,730
ఆపై వేరియబుల్ పేరు ఈ సందర్భంలో s ఉంది.

627
00:39:28,730 --> 00:39:31,180
కాబట్టి మేము ఒక స్ట్రింగ్ సంపాదించిన చేసిన మరియు మేము అది s అనే చేసిన.

628
00:39:31,180 --> 00:39:35,180
మరియు దిగువకు ఇక్కడ నేను నిజంగా జిత్తుల యొక్క కొద్దిగా చేస్తున్నదాన్ని గుర్తించాము.

629
00:39:35,180 --> 00:39:39,080
ఈ సూపర్ సాధారణ యొక్క విధమైన ఇది అంక గణితానికి, పిలుస్తారు.

630
00:39:39,080 --> 00:39:41,790
ఇది కేవలం గమనికలు ఆ సంఖ్యలను సంకలనం మరియు వ్యవకలనాలకు అర్థం.

631
00:39:41,790 --> 00:39:43,660
కానీ ఈ వాస్తవానికి పనిచేస్తుంది.

632
00:39:43,660 --> 00:39:49,170
ఈ కార్యక్రమం స్పష్టంగా అటువంటి తుది ఫలితంగా ఆ పంక్తికి స్ట్రింగ్ s 1 పాత్ర ముద్రిస్తుంది -

633
00:39:49,170 --> 00:39:54,920
కేవలం ఈ వెళ్లి కౌంటీ, పాడు గమనికలు తయారు, గమనికలు అమలు, నాకు సైన్ జూమ్ తెలియజేయవచ్చు

634
00:39:54,920 --> 00:39:58,940
ఇప్పుడు HELLO మరియు రకం ఎంటర్ లో లాగ నా రకం తెలియజేయండి

635
00:39:58,940 --> 00:40:01,080
మరియు అది పంక్తికి 1 పాత్ర ముద్రిస్తుంది.

636
00:40:01,080 --> 00:40:04,730
అప్ రెండవ క్రితం వరకు, మేము చదరపు బ్రాకెట్ సంజ్ఞామానం ఈ చేసారు అని.

637
00:40:04,730 --> 00:40:09,760
మేము లూప్ ఒక భావిస్తాను మరియు మేము s యొక్క printf చేయండి భావిస్తున్న [i] మరియు మేము మళ్ళీ మళ్లీ మళ్లీ అలా భావిస్తున్న

638
00:40:09,760 --> 00:40:11,950
ప్రతి లైన్ చివరిలో బాక్ స్లాష్ n తో.

639
00:40:11,950 --> 00:40:16,800
కానీ ఈ ప్రోగ్రామ్ భిన్నంగా ఉంటుంది. ఈ కార్యక్రమం, వాచ్యంగా, అంకగణితం ఉపయోగిస్తోంది.

640
00:40:16,800 --> 00:40:18,860
సో వాట్ ఇక్కడ జరగబోతోంది?

641
00:40:18,860 --> 00:40:24,720
ఈ లూప్ కూడా అమలు ముందు అన్ని మొదటి, ఏమిటి, కేవలం స్పష్టతను, s వాస్తవానికి?

642
00:40:24,720 --> 00:40:27,270
S ఉంది? >> [విద్యార్థి] ఒక చిరునామా. >> ఒక చిరునామా.

643
00:40:27,270 --> 00:40:32,980
>> మరియు అది హలో విషయంలో, చిరునామా ఏమిటి, ఆ పదం లో మొదటి అక్షరం, ఇది h ఉంది.

644
00:40:32,980 --> 00:40:37,370
కాబట్టి s, ఈ ప్రత్యేక ఉదాహరణ లో, h యొక్క చిరునామా.

645
00:40:37,370 --> 00:40:41,850
కనుక ఇది s చేయడానికి అర్థం ఏమిటి + i?

646
00:40:41,850 --> 00:40:46,280
Well, నేను లూప్ ఈ 0 మొదలవుతుంది. మేము అనేక సార్లు చేసిన.

647
00:40:46,280 --> 00:40:49,760
నేను స్పష్టంగా, స్ట్రింగ్ యొక్క పొడవు వరకు వెళ్ళి అన్నారు.

648
00:40:49,760 --> 00:40:53,950
కాబట్టి ఈ లూప్ యొక్క మొదటి మళ్ళా, ఐ స్పష్టంగా 0.

649
00:40:53,950 --> 00:41:01,740
బదులుగా, s +0--స్పష్టమైన కేవలం s యొక్క - కాబట్టి ఈ వ్యక్తీకరణ s + i చెబుతున్నారు.

650
00:41:01,740 --> 00:41:04,320
కాబట్టి * ఇక్కడ s ఏమిటి?

651
00:41:04,320 --> 00:41:08,530
ఇప్పుడు మేము కొద్దిగా భిన్నంగా స్టార్ ఉపయోగిస్తున్నారు.

652
00:41:08,530 --> 00:41:13,080
నాకు ముందుకు వెళ్లి మేము T మరియు s కాపీలు గురించి మాట్లాడటం పూర్తి చేసిన ఎందుకంటే t వదిలించుకోవటం లెట్.

653
00:41:13,080 --> 00:41:15,540
ఇప్పుడు మేము s సంబంధించిన కథ చెప్పడం.

654
00:41:15,540 --> 00:41:20,090
అది ముందు చేసిన చాలా ఇష్టం కాబట్టి ఈ సమయంలో, రకం స్ట్రింగ్ తరువాత, మన ప్రపంచం కనిపిస్తోంది

655
00:41:20,090 --> 00:41:26,630
కేవలం s h యొక్క చిరునామా నిల్వ మరియు సాధారణంగా హలో స్ట్రింగ్ వద్ద గురిపెట్టి తో.

656
00:41:26,630 --> 00:41:33,170
నేను ఇప్పుడు * వంటి లైన్ చేస్తే (s + i), ఇది ప్రయత్నించండి.

657
00:41:33,170 --> 00:41:40,140
కాబట్టి * (s + i). ఈ 0 ఎందుకంటే నాకు ఈ సులభతరం తెలియజేయండి, కనుక ఈ * (s +0) ఉంది.

658
00:41:40,140 --> 00:41:43,790
Well, ఒక నిమిషం ఆగండి. మరింత సులభతరం. ఈ * (s).

659
00:41:43,790 --> 00:41:47,020
Well, ఇప్పుడు కుండలీకరణాలు స్టుపిడ్ రకం, అందుచే ఇప్పుడు యొక్క కేవలం చేయండి * s తెలియజేయండి.

660
00:41:47,020 --> 00:41:50,540
కాబట్టి ఈ లూప్, హైలైట్ చేసే ఆ లైన్, 26 మొదటి మళ్ళా లో,

661
00:41:50,540 --> 00:41:53,650
ఈ ప్రింటింగ్ కు చాలా చక్కని సమానంగా ఉంటుంది.

662
00:41:53,650 --> 00:41:56,040
* S యొక్క డేటా రకం ఏమిటి?

663
00:41:56,040 --> 00:42:00,770
స్టార్, s స్వయంగా తర్వాత ఏమవుతుంది ఈ సందర్భంలో, ఎందుకంటే

664
00:42:00,770 --> 00:42:04,930
కానీ ప్రత్యేకంగా, మేము ఇకపై, s ప్రకటించారు ఎందుకంటే

665
00:42:04,930 --> 00:42:09,730
మేము ఇకపై ఒక వేరియబుల్ సృష్టించడం లేదు, లైన్ 26 లో చార్ * యొక్క ప్రస్తావనే లేదు, లేదు

666
00:42:09,730 --> 00:42:14,280
కీవర్డ్ స్ట్రింగ్ యొక్క ప్రస్తావనే లేదు లేదు, మేము, s అనే వేరియబుల్ ఉపయోగిస్తున్నారు

667
00:42:14,280 --> 00:42:19,650
అది ఇప్పుడు స్టార్ అర్థం అయోమయాన్ని ఆమోదం కొద్దిగా భిన్నంగా ఉంటుంది మరియు అవుతుంది.

668
00:42:19,650 --> 00:42:26,590
ఇక్కడ * s ఉంది ఏ s లో చిరునామా మరియు ముద్రణ వెళ్ళండి అర్థం.

669
00:42:26,590 --> 00:42:33,750
కాబట్టి s ఇక్కడే ఉంది, * s ఉంది - క్రమీకరించు చూట్స్ మరియు నిచ్చెనల వంటి యొక్క, బాణం అనుసరించండి - ఇక్కడ.

670
00:42:33,750 --> 00:42:35,850
కాబట్టి ఈ * s ఉంది.

671
00:42:35,850 --> 00:42:39,060
>> కాబట్టి లైన్ 26 ఆ లూప్ యొక్క మొదటి మళ్ళా ఏమి ప్రింట్ అవుతుంది?

672
00:42:39,060 --> 00:42:42,170
నేను ఒక పాత్ర కోసం ప్లేస్హోల్డర్ ఇది% సి, అవ్ట్ ప్రింట్

673
00:42:42,170 --> 00:42:48,520
అప్పుడు ఒక కొత్త లైన్ కోసం ఒక \ n. * (S + i) నేను 0 ఈ కలిగి ఉంటుంది.

674
00:42:48,520 --> 00:42:53,670
సో వాట్ చార్ నేను% సి కోసం ఉంచండి చెయ్యాలి? హెచ్

675
00:42:53,670 --> 00:42:56,900
ఈ వెళ్లి కౌంటీ మీరు బహుశా చూడగలరు - - లూప్ యొక్క తరువాత మళ్ళా లో

676
00:42:56,900 --> 00:43:01,350
తరువాత మళ్ళా నేను స్పష్టంగా 1, కాబట్టి ఈ మార్గాల s +1,

677
00:43:01,350 --> 00:43:05,580
ఇప్పుడు స్టార్ చెప్పడానికి అవసరం ఎందుకంటే తరువాత ఇప్పుడు నేను కుండలీకరణాలు అవసరం

678
00:43:05,580 --> 00:43:08,620
మెమరీ చిరునామా s +1 వెళ్ళండి.

679
00:43:08,620 --> 00:43:14,170
S ఏమిటి? యొక్క సమయంలో వెనక్కి తీసుకుని మరియు ఈ బాణం ఇప్పుడు వాస్తవానికి మాకు ఏ సహాయాలు చేయడం లేదు అని పిలవబడు.

680
00:43:14,170 --> 00:43:18,450
ఈ సంఖ్య 123 నిల్వ ఉంటుంది అని ప్రత్యేకంగా లెట్స్

681
00:43:18,450 --> 00:43:25,110
ఈ స్ట్రింగ్ యొక్క ప్రారంభ హలో, ఈ చిరునామా 123 ఎందుకంటే, ఈ మొదలైనవి 124, మరియు.

682
00:43:25,110 --> 00:43:30,550
నేను s +1 చెప్పడం ఉన్నపుడు రెండవ మళ్ళా న, ఆ, 123 +1 చెప్పడం వంటిది

683
00:43:30,550 --> 00:43:35,340
లేకపోతే 124 గా గుర్తిస్తారు, చార్ రెండవ మళ్ళా న ప్రింట్ అవుతుంది ఏమి కాబట్టి?

684
00:43:35,340 --> 00:43:37,850
మెమరీ చిరునామా 124 వద్ద E.

685
00:43:37,850 --> 00:43:44,440
మేము ఇక్కడ పెట్టడానికి ముందు తరువాత + మళ్లీ, 125, 126, 127, మరియు ఈ లూప్ కృతజ్ఞతగా ఆపి

686
00:43:44,440 --> 00:43:49,040
నేను చాలా అధికంగా కౌంట్ లేదు నిర్ధారించాలి strlen ఉపయోగించి నేను ఎందుకంటే.

687
00:43:49,040 --> 00:43:50,810
కాబట్టి ఆ కూడా ఉంది.

688
00:43:50,810 --> 00:43:55,000
మళ్ళీ, ఈ మేము ఒక వారం క్రితం చేసిన కేవలం అయితే ఉంది.

689
00:43:55,000 --> 00:43:59,200
మేము రెండు చేయాలనుకుంటున్నారా లేదు అయినప్పటికీ నాకు లైన్ దిగువ దాన్ని వ్రాయుటకు అనుమతి.

690
00:43:59,200 --> 00:44:02,500
ఈ ఇప్పుడు ఒకే విధంగా ఉంటుంది.

691
00:44:02,500 --> 00:44:08,310
>> కాబట్టి మేము వారాలు పిలుస్తూ చేశారు s, ఒక స్ట్రింగ్ అయినప్పటికీ, s నిజంగా చార్ * ఉంది.

692
00:44:08,310 --> 00:44:13,270
మేము సూపర్ ఆసన అని అనుకుంటే, అది ప్రత్యేక పాత్ర రాయడానికి నిజంగా సరైన యొక్క

693
00:44:13,270 --> 00:44:17,490
ఈ సంఖ్యా చిరునామాలు మరియు ఈ స్టార్ ఆపరేటర్లు ఉపయోగించి ith స్థానంలో,

694
00:44:17,490 --> 00:44:20,470
కానీ స్పష్టముగా, ఈ చాలా క్లీనర్ ఉంది. కాబట్టి ఈ చెడు లేదు.

695
00:44:20,470 --> 00:44:26,720
, ఏ కారణం ఇక్కడ లైన్ 27 చేయడం నిలిపివేసింది, కానీ 26 క్రియాశీలంగా అదే ఉంది

696
00:44:26,720 --> 00:44:31,570
మరియు అది మేము ఇప్పటివరకు చర్చిస్తున్న చేసిన సరిగ్గా కారణాల క్రియాశీలంగా సేమ్.

697
00:44:31,570 --> 00:44:33,650
చివరికి, 29 కేవలం మంచి పద్ధతి.

698
00:44:33,650 --> 00:44:38,420
S యొక్క ఉచిత కాలింగ్ ఇప్పుడు మీరు GetString మీరు ఇచ్చిన మెమరీ తిరిగి ఇవ్వడం మీరు అర్థం

699
00:44:38,420 --> 00:44:41,630
మళ్ళీ, నేను వారాలు GetString, సోమవారం పేర్కొన్నారు ఎందుకంటే

700
00:44:41,630 --> 00:44:44,180
మీ కోడ్ ఒక బగ్ పరిచయం చేయబడింది.

701
00:44:44,180 --> 00:44:46,490
వారాలు మీ కోడ్ మెమరీ లీకేజ్ ఉంది

702
00:44:46,490 --> 00:44:49,970
అనగా మీరు మెమరీ కోసం GetString కోరుతూ చేసిన కాని మీరు దానిని తిరిగి ఇవ్వడం ఎప్పుడూ చేసిన.

703
00:44:49,970 --> 00:44:53,410
మరియు ఉద్దేశపూర్వకంగా pedagogically మాకు ఎంపిక చేశారు

704
00:44:53,410 --> 00:44:55,880
ఇది ప్రారంభ గురించి ఆలోచించటం చాలా ఎక్కువ ఎందుకంటే.

705
00:44:55,880 --> 00:44:57,710
అయితే ఇప్పుడు మేము మరింత సౌష్టవం అవసరం.

706
00:44:57,710 --> 00:45:00,830
మీరు మెమరీ కంప్యూటర్ అడిగితే, వంటి, GetString సందర్భంగా

707
00:45:00,830 --> 00:45:02,820
ఈ కేసు, malloc కోసం కాదు

708
00:45:02,820 --> 00:45:07,970
మీరు pset 4 తరువాత కూడా ఉచిత ఏ మెమరీ ఇప్పుడు తప్పనిసరిగా.

709
00:45:07,970 --> 00:45:11,650
ఈ Int n చెప్పడం భిన్నంగా ఉంటుంది గమనించండి.

710
00:45:11,650 --> 00:45:15,040
మీరు GetString కాల్ ఎందుకంటే మీరు ఈ ఉచిత లేదు

711
00:45:15,040 --> 00:45:16,890
మరియు మీరు malloc కాల్ లేదు.

712
00:45:16,890 --> 00:45:20,610
>> మేము చివరికి చూస్తారు మరియు కూడా మీరు, GetInt అని ఉంటే

713
00:45:20,610 --> 00:45:25,520
మీరు నిజంగా పూర్ణాంకాల చుట్టూ పాస్ ఎందుకంటే GetInt మీరు మెమరీని కేటాయించాల్సిన లేదు

714
00:45:25,520 --> 00:45:29,430
మరియు మేము వారాలు చేయడం చేసిన జస్ట్ ది వే తేలియాడుతున్న మరియు అక్షరాలు.

715
00:45:29,430 --> 00:45:33,960
నిజంగా వారు బహుళ అక్షరాలు యొక్క కూర్పు ఉన్నారు ఎందుకంటే స్ట్రింగ్స్, అయితే, ప్రత్యేక ఉంటాయి.

716
00:45:33,960 --> 00:45:37,450
కాబట్టి వారు అక్షరాలు మరియు తేలియాడుతున్న మరియు ints నుంచి వివిధ అయి, ఇష్టం.

717
00:45:37,450 --> 00:45:39,980
కానీ మేము చాలా కాలం క్రితమే వచ్చి చేస్తాము.

718
00:45:39,980 --> 00:45:44,920
ఏదైనా ప్రశ్నలు తర్వాత గమనికలు ఈ ప్రారంభమైన? అవును.

719
00:45:44,920 --> 00:45:49,690
[వినబడని విద్యార్థి ప్రశ్న]

720
00:45:49,690 --> 00:45:51,440
ఆహ్, చాలా మంచి ప్రశ్న.

721
00:45:51,440 --> 00:45:55,790
సి అయితే మీరు కొన్ని చేస్తుంది విషయాలు ఒకటి, ఇది సౌకర్యంగా ఉంటుంది

722
00:45:55,790 --> 00:46:00,110
అది పరిమాణం డేటా రకం ఏమిటో కొరకు-xid ఉంది

723
00:46:00,110 --> 00:46:03,060
మరియు మీకు గుణకారం ఆ రకమైన చేస్తుంది.

724
00:46:03,060 --> 00:46:06,610
దాదాపు చార్ 1 బైట్ ఈ, అక్షరాలు విషయంలో సంబంధం లేదు

725
00:46:06,610 --> 00:46:08,150
ఈ పనిచేస్తుంది.

726
00:46:08,150 --> 00:46:11,220
కానీ, చర్చ కొరకు మీరు నిజంగా పూర్ణాంకాల ప్రింటింగ్ ఉంటే

727
00:46:11,220 --> 00:46:15,500
మరియు మీరు, కొన్ని విలువ s పూర్ణాంకం వద్ద గురిపెట్టి ఆ అవ్ట్ ముద్రించడానికి ప్రయత్నిస్తున్న

728
00:46:15,500 --> 00:46:20,720
ఒక పూర్ణాంకానికి 4 బైట్లు * నేను ఎందుకంటే మీరు అదేవిధంగా + 4 చెయ్యాల్సిన కాదు.

729
00:46:20,720 --> 00:46:25,780
పాయింటర్ అంకగణితం సి మరియు కంపైలర్ మీరు అన్ని ఆ గణిత ఉంటారని అర్థం.

730
00:46:25,780 --> 00:46:29,190
మీరు పట్టించుకోనట్లు అన్ని మానవ భావం యొక్క విధమైన లో లెక్కింపు ఉంటుంది. అవును.

731
00:46:29,190 --> 00:46:35,200
[విద్యార్థి] మీరు లూప్ ఒక లోపల స్ట్రింగ్ డిక్లేర్, మీరు తర్వాత ఇది ఉచితం చేయాలి?

732
00:46:35,200 --> 00:46:36,760
ప్రశ్న గుడ్.

733
00:46:36,760 --> 00:46:41,390
>> మీరు లూప్ యొక్క స్ట్రింగ్ లోపల డిక్లేర్డ్, మీరు తర్వాత ఇది ఉచితం చేయాలి?

734
00:46:41,390 --> 00:46:47,520
మీరు GetString లేదా malloc తో కేటాయించాలని స్వేచ్ఛా మెమొరీ అవసరం.

735
00:46:47,520 --> 00:46:53,110
మీరు ఏదో ఇష్టం చెప్పడానికి అయితే - అన్ని కోడ్ సంబంధం ఉంది కాబట్టి నన్ను ఇప్పుడు వంకర జంట కలుపులు ఉంచారు తెలియజేయండి.

736
00:46:53,110 --> 00:46:58,580
మీరు ఈ buggily అయితే ఏదో, పొతే, చార్ * t = s,

737
00:46:58,580 --> 00:47:03,450
t malloc లేదా GetString సంబంధించిన అంశాలను కలిగి లేదు ఎందుకంటే మీరు ఉచిత t లేదు.

738
00:47:03,450 --> 00:47:08,960
మీరు ఈ చేశాడు విరుద్ధంగా ఉంటే, GetString, అప్పుడు అవును, మీరు ఉచిత t వుంటుంది.

739
00:47:08,960 --> 00:47:14,350
నిజానికి, ఆ విధంగా చేయడానికి మీ మాత్రమే అవకాశం స్కోప్ ఇదే విషయం కోసం, ఈ లూప్ లోపల ఇప్పుడు

740
00:47:14,350 --> 00:47:16,060
మేము గతంలో చర్చించారు చేసిన.

741
00:47:16,060 --> 00:47:18,830
లేకపోతే మీరు,, మెమరీ పెడుతోంది మెమరీ కేటాయించడం మెమరీ పెడుతోంది లోనవుతాను

742
00:47:18,830 --> 00:47:21,230
మరియు కార్యక్రమం చివరిలో మీరు, ఆ లూప్ బయట ఉన్నారు ఎందుకంటే

743
00:47:21,230 --> 00:47:24,240
t లేదు, కానీ మీరు ఆపరేటింగ్ సిస్టమ్ చెప్పారు ఎప్పుడూ

744
00:47:24,240 --> 00:47:26,750
మీరు ఇకపై ఆ స్మృతి అవసరం లేదని.

745
00:47:26,750 --> 00:47:30,430
మరియు పొడవైన ముందు, pset 4 లేదా 5 కోసం మేము, Valgrind అని పిలిచే ఒక కార్యక్రమం మీకు యంత్రాంగ చేస్తాము

746
00:47:30,430 --> 00:47:34,160
ఇది, ఇది ఒక అద్భుత ఇంటర్ఫేస్ యొక్క కొంతవరకు సంపాదించి ఆ ఆత్మ లో GDB పోలి ఉంటుంది

747
00:47:34,160 --> 00:47:35,750
కానీ జీవితంలో దాని ప్రయోజనాన్ని మీరు సహాయం చేస్తుంది.

748
00:47:35,750 --> 00:47:39,380
మరియు Valgrind భవిష్యత్తులో మీ కార్యక్రమాలు శోధిస్తుంది ప్రోగ్రామ్

749
00:47:39,380 --> 00:47:42,550
మెమరీ లీకేజ్ కోసం చూస్తూ, GetString లేదా malloc నుండి లేదో,

750
00:47:42,550 --> 00:47:47,800
ఇది మనం చాలా CS50 లైబ్రరీ చెప్పవలసిన అన్ని మరింత ఉపయోగించి ప్రారంభించగలరు.

751
00:47:47,800 --> 00:47:53,030
మేము చివరికి ఇప్పుడు పదజాలం విధమైన మరియు సిద్ధాంతం మానసిక నమూనా విధమైన కలిగి

752
00:47:53,030 --> 00:47:55,170
ఈ విరిగిన కార్యక్రమం పరిష్కరించడానికి తో.

753
00:47:55,170 --> 00:47:59,410
>> కాబట్టి ఈ విరిగిన కార్యక్రమంలో, swap, swap యొక్క లోపల పనిచేస్తుంది

754
00:47:59,410 --> 00:48:05,280
ప్రధాన x మరియు y, రీకాల్ జారీ ఎందుకంటే అయితే, ప్రధాన పని ఎప్పుడూ

755
00:48:05,280 --> 00:48:07,260
మరియు ఆ మాట్లాడటానికి, విలువల ద్వారా ఆమోదించబడ్డాయి.

756
00:48:07,260 --> 00:48:09,330
వాటిలో కాపీలు స్వాప్ కు ఇవ్వబడింది.

757
00:48:09,330 --> 00:48:12,520
Swap చివరి నాటికి ఒక అండ్ బి నిజానికి మార్పిడి జరిగింది,

758
00:48:12,520 --> 00:48:16,120
కానీ కోర్సు యొక్క మేము సోమవారం చర్చించినట్లు x మరియు y, కాలేదు.

759
00:48:16,120 --> 00:48:19,940
నేను ఈ ఇక్కడ వాస్తవానికి పరిష్కారం ఇక్కడ గ్రీన్ ప్రతిపాదిస్తున్నాయి.

760
00:48:19,940 --> 00:48:22,640
మరియు వాస్తవానికి, నాకు కేవలం స్థిరంగా ఉండటానికి నా నక్షత్రాలు తరలించడానికి తెలియజేయండి

761
00:48:22,640 --> 00:48:24,440
అయినప్పటికీ, మళ్లీ, క్రియాశీలంగా ఈ పట్టింపు లేదు.

762
00:48:24,440 --> 00:48:28,730
ఎప్పుడు ఎందుకు అది అవసరం భవిష్యత్తు వారాల్లో మేము వివరించడానికి చేస్తాము.

763
00:48:28,730 --> 00:48:30,600
కాబట్టి గ్రీన్ ఇప్పుడు ఒక పరిష్కారం.

764
00:48:30,600 --> 00:48:33,700
నేను ఈ నక్షత్రాలను అన్ని ఎందుకంటే స్పష్టముగా, అది నిజంగా చాలా messier కనిపిస్తోంది.

765
00:48:33,700 --> 00:48:35,380
నాకు ఒక విషయం అభిప్రాయపడుతున్నారు లెట్.

766
00:48:35,380 --> 00:48:40,040
అది Int * ఒక మరియు Int * b చెప్పినట్లు ఇక్కడ టాప్ లైన్

767
00:48:40,040 --> 00:48:42,820
ఇది ఎల్లప్పుడూ కలిగి ప్రాథమికంగా అదే చేస్తున్నాడు.

768
00:48:42,820 --> 00:48:47,070
ఇది మారడానికి 2 వాదనలు లేదా పారామితులు ప్రకటించటం

769
00:48:47,070 --> 00:48:49,940
ఒక పూర్ణాంకానికి పాయింటర్ ఇది మొదటి, ఒక అని

770
00:48:49,940 --> 00:48:53,100
ఇది యొక్క రెండవ బి అని ఒక పూర్ణాంకానికి పాయింటర్ ఉంది.

771
00:48:53,100 --> 00:48:55,770
ఈ సమయంలో కొత్త అని మాత్రమే విషయం ఒక నక్షత్రం ఉంది అక్కడ వాస్తవం.

772
00:48:55,770 --> 00:48:59,340
>> ఆ శతకము ఒక ఒక పూర్ణాంకానికి కాదు, బి ఒక పూర్ణాంకానికి కాదు.

773
00:48:59,340 --> 00:49:04,100
ఒక ఒక పూర్ణాంకానికి యొక్క చిరునామా మరియు బి వేరే Int యొక్క చిరునామా.

774
00:49:04,100 --> 00:49:06,980
నేను సి గందరగోళంగా గెట్స్ ఒప్పుకుంటే పేరు డౌన్ ఇక్కడ, ఈ ఉంది.

775
00:49:06,980 --> 00:49:09,790
ఇప్పుడు మేము ఒక స్టార్ ఉపయోగించే, కానీ ఈ సందర్భంలో వివిధ అర్ధాన్ని కలిగి ఉంది.

776
00:49:09,790 --> 00:49:13,150
మేము ఇక్కడ ఉంటాయి మేము గమనికలు ప్రకటించారు లేదు ఎందుకంటే,

777
00:49:13,150 --> 00:49:15,500
ఇక్కడ మేము విషయాలు dereferencing ఉంటాయి.

778
00:49:15,500 --> 00:49:21,520
కాబట్టి సాంకేతికంగా, swap యొక్క లోపల, మొదటి రెండవ, మూడవ మరియు లైన్ యొక్క ఈ సందర్భంలో స్టార్

779
00:49:21,520 --> 00:49:24,560
కేవలం అంటే dereference ఆపరేటర్లు, అక్కడ గో.

780
00:49:24,560 --> 00:49:27,400
నా వేలు h బాణం తర్వాత, సో కేవలం

781
00:49:27,400 --> 00:49:31,100
* ఒక అంటే చిరునామాకు వెళ్ళి నాకు అక్కడ Int కనుగొనండి.

782
00:49:31,100 --> 00:49:34,250
* బి అంటే చిరునామా వెళ్ళి ఏమి నాకు పాస్.

783
00:49:34,250 --> 00:49:40,730
కాబట్టి యొక్క సోమవారం ఇప్పుడు ఒక ఫ్రేమ్ల స్టాక్ ఉపయోగించి నుండి చిత్రాన్ని పునర్ తెలియజేయండి

784
00:49:40,730 --> 00:49:43,130
ఇది దిగువ ఒక ప్రధాన అవతరిస్తుంది

785
00:49:43,130 --> 00:49:47,600
ఇది ఎగువ ఒక, swap అవతరిస్తుంది

786
00:49:47,600 --> 00:49:50,880
మన ప్రపంచం ఈ వంటి కేవలం సోమవారం వంటి కనిపిస్తుంది కాబట్టి.

787
00:49:50,880 --> 00:49:53,620
ఇక్కడ ప్రధాన ఉపయోగించడానికి అన్నారు ఆ మెమరీ భాగం ఉంది.

788
00:49:53,620 --> 00:49:56,520
>> కార్యక్రమం కేవలం 2 వేరియబుల్స్ ఉందని సోమవారం నుండి రీకాల్

789
00:49:56,520 --> 00:50:01,930
ఒక X మరియు Y అని ఒక అని, మరియు నేను అక్కడ సంఖ్యలు 1 మరియు 2 ఉంచింది.

790
00:50:01,930 --> 00:50:06,580
ఇప్పుడు నేను వంటి స్వాప్ కాల్ నేను సోమవారం చేశాడు,

791
00:50:06,580 --> 00:50:11,000
నేను ఈ కార్యక్రమం యొక్క ఎరుపు సంస్కరణను ఉపయోగించారు గతంలో ఉన్నప్పుడు, ఇది ఈ కనిపిస్తోంది

792
00:50:11,000 --> 00:50:17,470
నేను 2 పారామితులు, a మరియు b వచ్చింది, మరియు మేము ఇక్కడ మరియు ఇక్కడ ఏమి వ్రాసి లేదు?

793
00:50:17,470 --> 00:50:21,160
కేవలం 1 మరియు 2, సాహిత్యపరంగా x మరియు y ప్రతులు.

794
00:50:21,160 --> 00:50:23,070
ఈ రోజు మనం ఆ మార్చండి.

795
00:50:23,070 --> 00:50:28,510
నేడు బదులుగా ints అక్కడ ఒక అండ్ బి మేము 2 చిరునామాలలో పాస్ చూడాలని.

796
00:50:28,510 --> 00:50:34,290
ఆ చిరునామాలను ints సూచించడానికి జరిగే, కానీ ఆ చిరునామాలను తాము ints లేదు.

797
00:50:34,290 --> 00:50:37,330
వారు చిరునామాలు. ఇది బదులుగా ఒక పోస్టల్ చిరునామా వంటిది.

798
00:50:37,330 --> 00:50:40,580
కాబట్టి ఇప్పుడు మేము నాకు తెరపై కొంచెం వివరాలు ఇవ్వడానికి అవసరం.

799
00:50:40,580 --> 00:50:43,250
అది రోజంతా ఉన్నారు ఈ నా కంప్యూటర్ యొక్క మెమరీ ఉంది.

800
00:50:43,250 --> 00:50:45,120
ఇప్పుడు మేము స్వేచ్ఛా అంకెల పథకాన్ని అవసరం.

801
00:50:45,120 --> 00:50:50,580
కాబట్టి ఈ మెమరీ చిరునామా 123, 124 అని, కేవలం అవకాశం ద్వారా, కేవలం సే తెలియజేయండి.

802
00:50:50,580 --> 00:50:55,660
లెట్ యొక్క ఈ 125 అంటారు, ఈ 126, మరియు మొదలైనవి, కానీ పూర్తిగా ఏకపక్షంగా ఉంది.

803
00:50:55,660 --> 00:50:58,590
మేము నా జ్ఞాపకాలలో కొన్ని అంకెల పథకాన్ని అవసరం.

804
00:50:58,590 --> 00:51:04,030
కాబట్టి ఇప్పుడు నేను నిజంగా x మరియు y లో పాస్, నేను, x మరియు y లో పాస్ వెళ్ళడం లేదు;

805
00:51:04,030 --> 00:51:08,400
నేను x యొక్క మరియు y యొక్క, మాట్లాడటానికి, పోస్టల్ చిరునామా లో పాస్ వెళుతున్న

806
00:51:08,400 --> 00:51:11,870
సో వాట్ ఇక్కడ మరియు ఇక్కడ నిల్వ అవుతుంది 1 మరియు 2 కాదని,

807
00:51:11,870 --> 00:51:16,030
మీరు నా చిన్న టెక్స్ట్ చూడగలరు అయితే ఇక్కడికి మరియు ఇక్కడ జారీ అవుతుంది?

808
00:51:16,030 --> 00:51:23,340
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఖచ్చితంగా. 123 ఇక్కడ ఉంచే మరియు 124 ఇక్కడ ఉంచే.

809
00:51:23,340 --> 00:51:28,910
>> ఇప్పుడు, ఎందుకంటే నేను, ఎగువ భాగంలో ఇక్కడ ఈ మొట్టమొదటి లైన్ విధంగా స్టార్ ఉపయోగిస్తారు

810
00:51:28,910 --> 00:51:34,340
నా కార్యక్రమం కేవలం వారు స్పష్టంగా పూర్ణాంకాల ఉన్నప్పటికీ, ఆ 123 మరియు 124 తెలుసు

811
00:51:34,340 --> 00:51:40,160
ఏ మానవ గమనించి అని, వారు చిరునామాలు, సంఖ్యా చిరునామాలను వలె అంచనా ఉండాలి.

812
00:51:40,160 --> 00:51:43,250
వారు ints మరియు తమ యొక్క కాదు, వారు, చిరునామాలు ఉన్నారు

813
00:51:43,250 --> 00:51:46,120
నేను స్పష్టంగా అక్కడ నక్షత్రాలు చేసి ఎందుకంటే మరియు ఆ.

814
00:51:46,120 --> 00:51:51,360
కాబట్టి ఇప్పుడు ఇక్కడికి జరిగినప్పుడు అసలు కోడ్ నా మొదటి, రెండవ, మూడవ మరియు లైన్ లో?

815
00:51:51,360 --> 00:51:53,380
చిత్రం యొక్క మిగిలిన డ్రా లెట్.

816
00:51:53,380 --> 00:51:56,980
Tmp దీనిని సోమవారం లాగానే ఉంది. Tmp గురించి ప్రత్యేకించి ఏమీ లేదు.

817
00:51:56,980 --> 00:52:03,060
ఇది కేవలం ఒక స్థానిక 32 బిట్స్ వేరియబుల్, మరియు లోపల యొక్క నేను స్పష్టంగా * ఒక విలువ నిల్వ am.

818
00:52:03,060 --> 00:52:08,580
ఇప్పుడు, నేను చెప్పారు ఉంటే tmp = ఒక, నేను ఇక్కడ ఏమి ఉంచుతాడు? >> [విద్యార్థి] 123.

819
00:52:08,580 --> 00:52:10,370
123. కానీ నేను ఏమి కాదు.

820
00:52:10,370 --> 00:52:13,670
నేను tmp మాట్లాడుతూ నేను = * ఒక. స్టార్ అంటే అక్కడ వెళ్ళండి.

821
00:52:13,670 --> 00:52:19,370
ఇక్కడ ఒక, 123 ఉంది. నేను ఎలా ఉన్నాయి గో? ఒక బాణం ఉన్నట్లు నటిస్తారు.

822
00:52:19,370 --> 00:52:24,460
Well, అక్కడ అది, 1. కాబట్టి స్పష్టంగా, tmp లో ఏం నిల్వ అవుతుంది? కేవలం 1.

823
00:52:24,460 --> 00:52:29,620
కాబట్టి ఇతర మాటలలో, tmp * ఒక, * ఒక పద్ధతిలో ఒక ప్రస్తుతానికి ఆ చిరునామాకు గో,

824
00:52:29,620 --> 00:52:31,320
ఇది స్పష్టంగా 123 ఉంది.

825
00:52:31,320 --> 00:52:33,910
>> సరే, ఇక్కడ మేము నగర 123 ఉన్నాయి, నేను, సంఖ్య 1 చూడండి

826
00:52:33,910 --> 00:52:35,670
నేను అక్కడ 1 ఉంచారు వెళుతున్న.

827
00:52:35,670 --> 00:52:39,020
ఇప్పుడు నేను పంక్తి 2 ఏమి, * a = b *?

828
00:52:39,020 --> 00:52:44,570
ఒక ఏమిటి ఇప్పుడు ఎందుకంటే ఈ ఒక కొంచెం సంక్లిష్టమైంది? ఇది 123 ఉంది.

829
00:52:44,570 --> 00:52:50,220
కాబట్టి * ఒక ఎక్కడ ఉంది? కుడి నేను ముందు ఉన్నారు. సో అక్కడ వెళ్ళండి. సరే.

830
00:52:50,220 --> 00:52:53,420
ఇప్పుడు, చివరగా, ఆపై చివరకు ఈ, ఆశాజనక, సమంజసం మొదలవును

831
00:52:53,420 --> 00:53:00,280
* బి బి లో ఏమి అర్థం? 124. నేను 2 ఇది అక్కడ వెళ్లాలి.

832
00:53:00,280 --> 00:53:03,430
నేను ఎక్కడ ఏమి ఉంచగలను?

833
00:53:03,430 --> 00:53:10,100
* B * ఒక లోకి వెళుతుంది కాబట్టి 2 ఇక్కడ వెళతాడు. కాబట్టి చేస్తాను.

834
00:53:10,100 --> 00:53:13,120
మరియు మీరు ఇప్పటికే ఎక్కువ దగ్గరగా ఉన్నట్లు, బహుశా, చూడగలరు

835
00:53:13,120 --> 00:53:17,710
మొదటి సారి సరిగ్గా ఈ స్టుపిడ్, సాధారణ సమస్య పరిష్కారానికి

836
00:53:17,710 --> 00:53:20,920
ఇప్పుడు మేము ఇప్పటికీ x ఎలా ఒక జ్ఞప్తికి తెచ్చుకొను ఎందుకంటే,

837
00:53:20,920 --> 00:53:23,230
మేము, Y యొక్క, ఆమోదం 2 కాపీలు ఉన్నాయి

838
00:53:23,230 --> 00:53:25,850
కానీ లైన్ 3 ఇప్పుడు * b చెప్పారు.

839
00:53:25,850 --> 00:53:31,080
ఇక్కడ బి ఉంది. * బి అంటే అక్కడ వెళ్ళండి. కాబట్టి నగర 124 ఎక్కడ ఉంది?

840
00:53:31,080 --> 00:53:35,560
ఇది ఇక్కడ స్పష్టంగా ఉంది. నేను ఇక్కడ ఏమి ఉంచగలను? నిజానికి, tmp.

841
00:53:35,560 --> 00:53:39,600
కాబట్టి ఇప్పుడు నేను దీన్ని. నేను ఇక్కడ 1 ఇక్కడ మరియు 2 ఉన్నాయి.

842
00:53:39,600 --> 00:53:43,560
ఇప్పుడు ఈ అన్ని 123, 124, మరియు 1 గురించి?

843
00:53:43,560 --> 00:53:47,910
వెంటనే swap పునరాగమనం, ఈ జ్ఞాపకశక్తి కోల్పోయే వలె మంచిగా ఉంది

844
00:53:47,910 --> 00:53:51,070
వెంటనే swap తిరిగి, ఆపరేటింగ్ సిస్టమ్ వంటి ఎందుకంటే

845
00:53:51,070 --> 00:53:54,190
భవిష్యత్తులో మళ్ళీ ఆ స్మృతి ఉపయోగించడానికి ఉచితం.

846
00:53:54,190 --> 00:53:58,870
ఈ అని పిలవబడే స్టాక్ దిగువన మాత్రమే ప్రధాన యొక్క మెమరీ చుట్టూ అంటుకుని ఉంటుంది.

847
00:53:58,870 --> 00:54:01,470
>> కాబట్టి మేము చివరకు ఇప్పుడు ఒక పని సంస్కరణను కలిగి ఉన్నారు.

848
00:54:01,470 --> 00:54:06,310
నాకు swap.c వెళ్ళండి, మరియు క్రింది గమనించి లెట్.

849
00:54:06,310 --> 00:54:11,280
కార్యక్రమం ఎగువన నా నమూనా అని మార్చారు Int * ఒక మరియు Int * బి.

850
00:54:11,280 --> 00:54:15,000
నేను చెడు ఇది ఎరుపు,, నుండి మంచి ఇది ఆకుపచ్చ, వెళ్ళి మార్చారు ఒకే ఒక విషయం,

851
00:54:15,000 --> 00:54:17,350
నేను ఈ రోజు ఈ నక్షత్రాలను జోడిస్తారు.

852
00:54:17,350 --> 00:54:21,520
కానీ డౌన్ ఇక్కడ కూడా స్వాప్ నేను కాపీ వచ్చింది, కేవలం స్లయిడ్ లో ఏమి అతికించండి.

853
00:54:21,520 --> 00:54:24,140
నేను ఇక్కడ ఒక స్టార్ ఉంది, ఇక్కడ స్టార్ - ఆ నమూనా సరిపోలే -

854
00:54:24,140 --> 00:54:27,930
మరియు ఈ అన్ని విషయాలను ఇప్పుడు tmp తప్ప నక్షత్రాలు ఉన్నాయి

855
00:54:27,930 --> 00:54:30,680
ఒక తాత్కాలిక వేరియబుల్ ఉపయోగించడం వలన, కొత్త ఏమీ లేదు లేదు.

856
00:54:30,680 --> 00:54:33,040
నేను ఒక పూర్ణాంకానికి తాత్కాలిక నిల్వ అవసరం.

857
00:54:33,040 --> 00:54:34,820
కాబట్టి మేము అక్కడ ఒక స్టార్ అవసరం లేదు.

858
00:54:34,820 --> 00:54:39,310
మేము ఏకపక్ష సరిహద్దు యొక్క ఈ విధమైన cross విధంగా మేము స్టార్ అవసరం

859
00:54:39,310 --> 00:54:42,900
నా కంప్యూటర్ యొక్క మెమరీ లో ఈ 2 ఫ్రేమ్ల మధ్య.

860
00:54:42,900 --> 00:54:45,630
కానీ ఒక విషయం గత మార్చడానికి ఉంది, మరియు మీరు ఇప్పటికే అది చూడటం ఉండవచ్చు.

861
00:54:45,630 --> 00:54:48,810
ఏ ఇతర లైన్ ఇప్పుడు స్పష్టంగా వైవిధ్యంగా ఉంటుంది? >> [విద్యార్థి] & x.

862
00:54:48,810 --> 00:54:53,270
>> అవును, కాబట్టి 25 నేను పని ఈ కోసం మార్చాలి కోడ్ చివరి పంక్తి.

863
00:54:53,270 --> 00:54:58,360
ఒక వారం క్రితం కూడా సోమవారం లైన్ 25 ఇలా, x మరియు y, స్వాప్

864
00:54:58,360 --> 00:55:02,020
మీరు చెప్పుకోవాలంటే ఎందుకంటే మరియు ఈ కేవలం ఉల్లంఘించబడింది స్వాప్ (x, y)

865
00:55:02,020 --> 00:55:05,660
మీరు, అది దాని విషయం ఏమి, మారడానికి x మరియు y యొక్క కాపీలు ఇస్తున్నారు

866
00:55:05,660 --> 00:55:09,080
కానీ మీరు నిజంగా x మరియు y కూడా మారుతున్న ఎప్పుడూ చేస్తున్నారు.

867
00:55:09,080 --> 00:55:12,880
మీరు కోడ్ ఆంపర్సండ్ చిహ్నం తో ముందు ఈ పాత్ర ఎప్పుడూ చూడలేదు కాబట్టి కూడా,

868
00:55:12,880 --> 00:55:15,860
కేవలం ఒక అంచనా పడుతుంది. ఆంపర్సండ్ చిహ్నం స్పష్టంగా, ఏమి చేస్తుంది?

869
00:55:15,860 --> 00:55:17,890
[విద్యార్థి] చిరునామా టేక్స్. >> చిరునామా టేక్స్.

870
00:55:17,890 --> 00:55:21,160
కాబట్టి ఆంపర్సండ్ చిహ్నం నాకు x యొక్క చిరునామాను ఇవ్వండి అని.

871
00:55:21,160 --> 00:55:25,590
అది ఎక్కడ ఎవరు తెలుసు? ఇది 123 నిర్మాణము. నేను పట్టించుకోను. నా x యొక్క చిరునామాను ఇవ్వండి.

872
00:55:25,590 --> 00:55:28,340
& పీ నాకు y యొక్క చిరునామాను ఇవ్వండి అర్థం.

873
00:55:28,340 --> 00:55:34,450
మరియు కథ చిత్రంతో ఖచ్చితంగా స్థిరంగా ఉంటుంది ఆ సమయంలో మేము ఒక క్షణం క్రితం ఆకర్షించింది.

874
00:55:34,450 --> 00:55:38,310
>> నేను మొదటి ఈ నేర్చుకోవడం ప్రారంభించింది కనుక నేను, నాకు ఖచ్చితంగా, గమనికలు ఒప్పుకుంటే చేస్తాము

875
00:55:38,310 --> 00:55:40,570
ఖచ్చితంగా చుట్టూ నా మనస్సు మూసివేయాలని కష్టతరమైన పనులు ఒకటి.

876
00:55:40,570 --> 00:55:43,760
కానీ, మేము విషయాలను ఈ రకాల ఆడటం ఉంచేందుకు ముఖ్యంగా, తెలుసుకుంటారు

877
00:55:43,760 --> 00:55:48,030
మీరు ఈ సూపర్ సాధారణ విధమైన అది విచ్ఛిన్నం ఉంటే మేధస్సును సమస్యలు రసహీనమైన

878
00:55:48,030 --> 00:55:52,270
కేవలం గమనికలు గందరగోళం చాలా వరకు చుట్టూ సమాధానం సంఖ్యలు కదిలే

879
00:55:52,270 --> 00:55:56,590
నిజంగా ఈ ప్రాధమిక మెకానిక్స్ నుండి చేయవచ్చు.

880
00:55:56,590 --> 00:55:59,070
ఇక్కడ ఒక చిరునామా ఉంది. స్టార్ తో అక్కడ వెళ్ళండి.

881
00:55:59,070 --> 00:56:03,830
లేదా దీనికి విరుద్ధంగా, ఇక్కడ ఒక ఆంపర్సండ్ చిహ్నం ఉంది. చిరునామా నిజానికి ఏమిటి అవ్ట్ Figure.

882
00:56:03,830 --> 00:56:06,270
అన్ని కుడి.

883
00:56:06,270 --> 00:56:09,000
కాబట్టి ఇది మెమరీ నుండి వస్తోంది?

884
00:56:09,000 --> 00:56:12,360
, మేము ఈ చిత్రాన్ని సార్లు రెండు డ్రా, నేను మేము అది తిరిగి వచ్చి మీరు మంచి ఉంచడానికి

885
00:56:12,360 --> 00:56:14,920
కానీ ఇక్కడ మీ కంప్యూటర్ యొక్క మెమరీ ప్రాతినిథ్యం

886
00:56:14,920 --> 00:56:17,420
ఆ ఇక్కడ కొంచెం లేబుల్ మా సుద్ద బోర్డ్ కంటే ఎక్కువగా ఉపయోగించారు.

887
00:56:17,420 --> 00:56:21,590
ఎగువన టెక్స్ట్ విభాగంలో మీ ప్రోగ్రామ్ సంబంధించి ఏ సూచిస్తుంది?

888
00:56:21,590 --> 00:56:26,090
[వినబడని విద్యార్థి ప్రతిస్పందన] >> క్షమించాలి? మళ్ళీ సే.

889
00:56:26,090 --> 00:56:28,660
[విద్యార్థి] వాస్తవ కార్యక్రమం. >> అసలు కార్యక్రమం.

890
00:56:28,660 --> 00:56:32,430
>> 0 సె మరియు మీరు సి కోడ్ రాసిన తరువాత సంకలనం చేసిన 1s మరియు అప్పుడు నడుస్తున్న గణగణమని ద్వని చేయు కాబట్టి

891
00:56:32,430 --> 00:56:35,910
మరియు 0 సె మరియు 1s ముగుస్తుంది ఉత్పత్తి మెమరీ లో ఉంచి విధానం

892
00:56:35,910 --> 00:56:38,570
మీరు డబుల్ మీ Mac లేదా PC లో ఒక ఐకాన్ క్లిక్ చేసినప్పుడు ఎందుకంటే

893
00:56:38,570 --> 00:56:43,010
లేదా మీ 0 సె మరియు 1s డిస్క్ నుండి, మీ ప్రాంప్టులో మారియో వంటి ఆదేశాన్ని

894
00:56:43,010 --> 00:56:45,700
కంప్యూటర్ వాటిని చేయవచ్చు తద్వారా మెమోరీలో లోడ్ get

895
00:56:45,700 --> 00:56:47,540
మరియు వీటిని చాలా తొందరగా అమలు.

896
00:56:47,540 --> 00:56:50,880
కాబట్టి initialized డేటా మరియు అవినియోగిత డేటా, మేము, ఆ గురించి ఎక్కువ మాట్లాడను కనిపిస్తుంది

897
00:56:50,880 --> 00:56:52,420
కానీ కేవలం కొన్ని ప్రపంచ వేరియబుల్స్ ఉన్నాయి.

898
00:56:52,420 --> 00:56:54,710
Initialized మీకు విలువలు ఇచ్చిన ప్రపంచ వేరియబుల్స్ అర్థం;

899
00:56:54,710 --> 00:56:59,300
అవినియోగిత మీరు ఇంకా వరకు విలువలను ఇవ్వలేదని ప్రపంచ వేరియబుల్స్ అర్థం.

900
00:56:59,300 --> 00:57:01,900
అప్పుడు నేను పూర్తిగా నా చేతి దుర్చాల్సిన మేము ఈ పరిసరం, లేదు

901
00:57:01,900 --> 00:57:04,860
కానీ అవి ఆ మీ యూజర్ పేరు దుకాణాలలో విషయాలు

902
00:57:04,860 --> 00:57:08,090
తక్కువ స్థాయి వివరాలు మరియు ఇతర విధమైన.

903
00:57:08,090 --> 00:57:12,880
కానీ మీ మెమరీ లేఅవుట్ యొక్క juiciest ముక్కలు స్టాక్ మరియు కుప్ప అని ఈ విషయం ఉంది.

904
00:57:12,880 --> 00:57:17,470
మళ్ళీ స్టాక్ స్పష్టతను, ధర్మాలని పిలుస్తారు చేసినప్పుడు ఉపయోగించబడుతుంది మెమరీ

905
00:57:17,470 --> 00:57:19,710
స్థానిక వేరియబుల్స్ ఉన్నాయి చేసినప్పుడు

906
00:57:19,710 --> 00:57:22,120
మరియు చేసినప్పుడు పారామితులు చుట్టూ అక్కడ జారీ చేస్తున్నారు.

907
00:57:22,120 --> 00:57:24,490
ఆ అన్ని స్టాక్ జరుగుతుంది.

908
00:57:24,490 --> 00:57:29,570
కుప్ప మేము గురించి మాట్లాడారు, కాని కుప్ప ఉపయోగించే ఒక అంచనా పడుతుంది లేదు.

909
00:57:31,120 --> 00:57:32,690
మెమరీ వేరొక భాగం.

910
00:57:32,690 --> 00:57:36,620
ఇది ఎగువన ఇక్కడ డ్రా నిర్మాణము, కానీ ఆ ఏకపక్ష చిత్ర సమావేశముల.

911
00:57:36,620 --> 00:57:41,670
అది వారాలు కుప్ప నుండి మెమరీ ఉపయోగించడం చేయబడింది?

912
00:57:41,670 --> 00:57:44,830
ఇది సాంకేతికంగా మీరు కానీ పరోక్షంగా ఉంది. >> [విద్యార్థి] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString మరియు malloc. ఇక్కడ మౌలిక భేదాన్ని ఉంది.

914
00:57:47,950 --> 00:57:51,300
>> మీరు మెమరీ అవసరం ఉంటే, ఒక వేరియబుల్ డిక్లేర్ గత కొన్ని వారాలు తెలుసు.

915
00:57:51,300 --> 00:57:54,560
మీరు మెమరీ మా ఉంటే, లోపలే మీ విధి యొక్క వ్యూహం ప్రకటిస్తాయి.

916
00:57:54,560 --> 00:57:59,620
మీరు స్థానికంగా లోపల విధులను వేరియబుల్స్ డిక్లేర్ అయితే మేము ఎదుర్కొంటున్న ఉంచింది చేసిన సమస్య ఉంది

917
00:57:59,620 --> 00:58:05,340
వెంటనే తిరిగి వచ్చే చర్యలు వంటి, ఏ మెమరీ మరియు ఆ వేరియబుల్స్ ఏమవుతుంది?

918
00:58:05,340 --> 00:58:09,620
అది కేవలం విధమైన హక్కు, మీదే గడువు ముగిసిన? ఇది కేవలం సంభావితంగా యొక్క విధమైన అదృశ్యమవుతుంది.

919
00:58:09,620 --> 00:58:13,950
ఇది సహజంగా, భౌతికంగా ఇప్పటికీ, కానీ ఇకపై ఉపయోగించడానికి మీ సరియే.

920
00:58:13,950 --> 00:58:17,160
మీరు జీవితంలో విధులు రాయడానికి మీరు అనుకుంటే ఇది ఏమాత్రం సమస్యాత్మకం

921
00:58:17,160 --> 00:58:20,440
నిజానికి మెమరీ కేటాయించాలి మరియు అది వెంటనే తిరిగి ఇవ్వాలని లేదు అని.

922
00:58:20,440 --> 00:58:24,180
పాయింట్ కేస్: జీవితంలో GetString యొక్క ప్రయోజనం ముందుగానే సంఖ్య ఆలోచన ఉంది ఉంది

923
00:58:24,180 --> 00:58:26,390
ఎలా నేను కీబోర్డ్ వద్ద టైప్ వెళుతున్న ఒక స్ట్రింగ్ యొక్క పెద్ద,

924
00:58:26,390 --> 00:58:30,390
కానీ డేవిడ్ లేదా హలో పట్టుకుని మెమరీని కేటాయించాల్సిన చేయగలరు తీరవలసినదే

925
00:58:30,390 --> 00:58:32,860
యూజర్ సైన్ టైప్ ఉండవచ్చని లేదా మొత్తం వ్యాసం

926
00:58:32,860 --> 00:58:35,280
కాబట్టి GetString malloc ఉపయోగించింది.

927
00:58:35,280 --> 00:58:38,910
Malloc కాబట్టి కాదు స్టాక్ ఉపయోగించి తప్పక;

928
00:58:38,910 --> 00:58:40,770
బదులుగా ఇది కుప్ప అని ఈ విషయం ఉపయోగించి మాత్రమే.

929
00:58:40,770 --> 00:58:44,430
మెమరీ గురించి వివిధ ఏదీ లేదు. ఇది వేగంగా లేదా నెమ్మదిగా లేదా అలాంటిదే మాత్రం కాదు.

930
00:58:44,430 --> 00:58:46,570
ఇది మరొక స్థానాన్ని కేవలం భౌతికంగా ఉంది.

931
00:58:46,570 --> 00:58:50,120
>> కాని ఈ నియమం అని కుప్ప కేటాయింపబడుతుంది చేసే మెమరీ

932
00:58:50,120 --> 00:58:56,180
మీరు కాల్ వరకు మీరు దూరంగా తీసుకెళ్లడం ఎప్పటికీ - ఒక అంచనా పడుతుంది - ఉచిత.

933
00:58:56,180 --> 00:59:00,510
దీనికి విరుద్ధంగా, ఏదైనా మెమరీ మీరు వ్యూహం ప్రకటిస్తూ స్టాక్ న గోవా

934
00:59:00,510 --> 00:59:03,320
లేదా మేము వారాలు చేయడం చేసిన వంటి వేరియబుల్ ప్రకటించారు,

935
00:59:03,320 --> 00:59:05,640
డిఫాల్ట్ ద్వారా స్టాక్ న ముగుస్తుంది.

936
00:59:05,640 --> 00:59:09,550
మరియు ఆ అరుదైన సందర్భాలలో సమయం గొప్ప 90% పనిచేస్తుంది, కానీ

937
00:59:09,550 --> 00:59:12,470
మీరు, మెమరీని కేటాయించాల్సిన మరియు దాని చుట్టూ ఉంచాలని పేరు

938
00:59:12,470 --> 00:59:14,730
అప్పుడు మీరు malloc వంటి ఫంక్షన్ ఉపయోగించాలి.

939
00:59:14,730 --> 00:59:19,370
లేదా మేము బదులుగా malloc ఉపయోగించే GetString, ఒక ఫంక్షన్ ఉపయోగించారు.

940
00:59:19,370 --> 00:59:23,300
ఈ విచ్ఛిన్నం మరియు తరువాత Binky ఒక పీక్ పడుతుంది పేరు యొక్క చూసేలా.

941
00:59:23,300 --> 00:59:25,820
మేము భవిష్యత్తులో ఆ వచ్చి చేస్తాము.

942
00:59:25,820 --> 00:59:29,270
ఇక్కడ మొదటి 2 లైన్స్ లో చేసే సూపర్ సాధారణ ప్రోగ్రామ్?

943
00:59:29,270 --> 00:59:33,460
ఇంగ్లీష్ లో కోడ్ యొక్క ఈ మొదటి 2 లైన్లు లోపల ప్రధాన ఏమి చేయాలి?

944
00:59:33,460 --> 00:59:35,600
[వినబడని విద్యార్థి ప్రతిస్పందన]

945
00:59:35,600 --> 00:59:37,880
జాగ్రత్త. ఇది నాకు X లేదా Y యొక్క చిరునామా ఉండదు.

946
00:59:37,880 --> 00:59:41,840
[విద్యార్థి] ints కు గమనికలు ఇస్తుంది. >> గుడ్. పూర్ణాంకాల నాకు 2 గమనికలు ఇవ్వండి.

947
00:59:41,840 --> 00:59:45,130
ఇతర మాటలలో, నాకు ఈ రోజు డ్రాయింగ్ కొనసాగించండి మెమరీ 2 భాగాలు, ఇవ్వండి

948
00:59:45,130 --> 00:59:46,950
అయినప్పటికీ నేను చతురస్రాకార, ఇప్పుడు అది తుడిచివేసింది.

949
00:59:46,950 --> 00:59:50,000
నాకు మెమరీ 2 భాగాలు ఇవ్వండి, ఒక x అనే ఒక y అనే -

950
00:59:50,000 --> 00:59:54,320
మునుపటి నేను s మరియు t అని - మరియు మెమరీ ఆ భాగం యొక్క రకం ఏమిటి?

951
00:59:54,320 --> 00:59:57,160
ఇది ఒక చిరునామా నిల్వ చెప్పారు.

952
00:59:57,160 --> 00:59:59,110
టైపు Int * యొక్క ఉంటుంది.

953
00:59:59,110 --> 01:00:01,630
>> కాబట్టి ఒక పూర్ణాంకానికి యొక్క చిరునామా చివరికి, x నివసిస్తున్నారు కనిపిస్తుంది

954
01:00:01,630 --> 01:00:03,860
ఒక పూర్ణాంకానికి యొక్క చిరునామా చివరికి, Y నివసిస్తున్నారు కనిపిస్తుంది

955
01:00:03,860 --> 01:00:08,460
కానీ ముందుగా, x మరియు y యొక్క లోపల ఏముంది? ఎవరు తెలుసు? చెత్త విలువలు.

956
01:00:08,460 --> 01:00:10,180
ఇది గమనికలు తో లేదు.

957
01:00:10,180 --> 01:00:12,720
మేము అక్కడ నిజంగా ఏమి తెలిసిన అక్కడ ఏదో, పెట్టలేదు ఉంటే?

958
01:00:12,720 --> 01:00:18,950
ఇప్పుడు, x. ఇక్కడికి జరుగుతుంది? X ఒక పాయింటర్ ఈ ఇప్పుడు సక్రమం ఉంది. ఇది ఒక పూర్ణాంకానికి * ఉంది.

959
01:00:18,950 --> 01:00:21,870
నేను x లో మెమరీ కొన్ని భాగం యొక్క చిరునామా ఉంచవచ్చు అనగా.

960
01:00:21,870 --> 01:00:25,120
Malloc ఏమిటి తిరిగి లేదు? పర్ఫెక్ట్, అది, చిరునామాలు తిరిగి

961
01:00:25,120 --> 01:00:28,510
మెమరీ మొత్తం భాగం మొదటి బైట్ యొక్క చిరునామా.

962
01:00:28,510 --> 01:00:31,140
ఈ స్పష్టంగా పరికరంలోని, ఉదాహరణకు, ఎన్ని బైట్లు పెడుతోంది ఉంది?

963
01:00:31,140 --> 01:00:33,510
ఒక పూర్ణాంకానికి యొక్క పరిమాణం ఏమిటి? 4.

964
01:00:33,510 --> 01:00:36,600
మీరు వారం 1 తిరిగి భావిస్తే, అది ఎప్పుడూ గుర్తుంచుకోవడం ముఖ్యం సూపర్ కాదు

965
01:00:36,600 --> 01:00:38,870
కానీ ఈ విషయంలో అది, 4 బైట్లు తెలుసుకోవటానికి ఉపయోగం.

966
01:00:38,870 --> 01:00:41,770
కాబట్టి ఈ కుప్ప 4 బైట్లు న పెడుతోంది ఉంది

967
01:00:41,770 --> 01:00:46,110
మరియు కక్ష్య నాకు మొదటి ఒకటి చిరునామా తిరిగి ఉంది.

968
01:00:46,110 --> 01:00:47,700
ఇప్పుడు, x ఏమి ఉంది?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 ఏమి ఉంది?

970
01:00:52,200 --> 01:00:57,150
మేము కొన్ని చెత్త విలువతో ఈ కనిపిస్తోంది, x, కలిగి కథ ఈ సమయంలో ఉంటే

971
01:00:57,150 --> 01:01:04,120
ఈ ఇప్పుడు లైన్ 3 లో నేను 4 బైట్లు కేటాయించింది చేసిన, ఇప్పుడు కొన్ని చెత్త విలువతో y ఉంది.

972
01:01:04,120 --> 01:01:06,950
ఈ చిత్రం ముఖ్యంగా ఈ కనిపిస్తోంది.

973
01:01:06,950 --> 01:01:12,010
ఈ ఏకపక్ష చిరునామా 123 ఉంటే లేదా ప్రత్యేకంగా, ఈ మా కథ ఇప్పుడు ఎలా ఉంది.

974
01:01:12,010 --> 01:01:23,940
* X = 42 ఇప్పుడు అర్థం? చిరునామా 123 కు వెళ్ళి అనేక 42 ఉంచారు అనగా.

975
01:01:23,940 --> 01:01:26,220
మేము తీగలను చేయడం లేదు ఎందుకంటే నేను ఈ పంక్తులు డ్రా అవసరం లేదు.

976
01:01:26,220 --> 01:01:29,480
>> నేను, ఈ వంటి రాసిన, మరియు కేవలం ప్రదర్శన కోసమని వుండాలి

977
01:01:29,480 --> 01:01:33,240
ఒక పూర్ణాంకానికి రకమైన వంటి 42, 4 బైట్లు స్పేస్ చాలా తీసుకుంటుంది.

978
01:01:33,240 --> 01:01:35,960
కాబట్టి ఆ అక్కడ జరిగిన ఏమి, కానీ సమస్య ఇప్పుడు లేదు.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. ఇక్కడికి జరిగే అవకాశముంది?

980
01:01:40,580 --> 01:01:46,470
సమస్య మా సరళమైన ప్రపంచంలో * Y కేవలం Y చిరునామా వెళ్ళండి అర్థం.

981
01:01:46,470 --> 01:01:48,590
Y లో ఏమిటి? ఇది కొన్ని చెత్త విలువ ఏమిటి.

982
01:01:48,590 --> 01:01:53,150
కాబట్టి ఆ చెత్త విలువ, ఆ క్రేజీ లైక్ ఏదో 5551212 అని యొక్క ఊహించుకోవటం తెలియజేయండి.

983
01:01:53,150 --> 01:01:56,750
* Y అంటే 5551212 చిరునామాకు వెళ్లు.

984
01:01:56,750 --> 01:02:00,450
ఇక్కడ పైగా ఇష్టం అన్నారు. ఇది ఉదాహరణకు, లేదు.

985
01:02:00,450 --> 01:02:05,310
కాబట్టి * Y నేను ఇక్కడ 13 డ్రా దీనికై 13 అంటే పొందుతాడు. ఇది లేదు.

986
01:02:05,310 --> 01:02:08,790
నేను నల్లబల్ల యొక్క విభాగం అధిగమించారు. నేను ఏం వస్తుందా?

987
01:02:08,790 --> 01:02:14,930
నేను మెమరీ అందించేందుకు దీనికై ఎందుకంటే ఆ గుప్తమైన సందేశాన్ని విభజన లోపంగా

988
01:02:14,930 --> 01:02:19,470
ఉనికిలో లేని ఒక ప్రదేశంలో 13 వంటి విలువ.

989
01:02:19,470 --> 01:02:23,900
కార్యక్రమం మిగిలిన అది కాదు ఆ సమయం వరకు సరే, అయితే పనిచేయవచ్చు.

990
01:02:23,900 --> 01:02:25,350
కాబట్టి యొక్క ఈ కథ చెప్పడానికి ప్రయత్నించండి తెలియజేయండి.

991
01:02:25,350 --> 01:02:27,830
మేము ఆ మేము hex గురించి మాట్లాడారు చేసిన తర్వాత తిరిగి వచ్చి ఉంటుంది.

992
01:02:27,830 --> 01:02:30,290
యొక్క ఈ తిరిగి వెళ్ళి Binky అని ఈ విషయం ముగుస్తుంది లెట్

993
01:02:30,290 --> 01:02:33,710
ఇది రీకాల్ స్ ఎ క్లెమేషన్ ఆడటం ఇంట్లో కూర్చొని ఒక స్టాన్ఫోర్డ్ ప్రొఫెసర్

994
01:02:33,710 --> 01:02:36,380
సరిగ్గా అదే కార్యక్రమం యొక్క కథ చెప్పడం.

995
01:02:36,380 --> 01:02:40,580
ఇది కేవలం పొడవైన 3 నిమిషాలు ఉంటుంది. ఇక్కడ మేము Binky ఉన్నాయి.

996
01:02:40,580 --> 01:02:45,030
[వీడియో న పురుషుడు స్పీకర్] హేయ్ Binky, మేల్కొలపడానికి. ఇది పాయింటర్ వినోదం కోసం సమయం.

997
01:02:45,030 --> 01:02:50,080
[Binky] ఆ ఏమిటి? గమనికలు గురించి తెలుసుకోండి? ఓహ్, GOODY!

998
01:02:50,080 --> 01:02:53,700
[పురుషుడు స్పీకర్] Well, ప్రారంభించడానికి, మనం ఒక జంట గమనికలు అవసరం చూడాలని అనుకుంటున్నాను.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] సరే. ఈ కోడ్ పూర్ణాంకాల లను సూచిస్తుంది ఇది 2 గమనికలు కేటాయించుకునే.

1000
01:02:57,890 --> 01:03:02,220
[పురుషుడు స్పీకర్] సరే. Well, నేను 2 గమనికలు చూడండి, కానీ వారు ఏదైనా ను సూచిస్తాయి కనిపించడం లేదు.

1001
01:03:02,220 --> 01:03:05,550
[Binky] కుడి యొక్క. మొదట్లో, గమనికలు ఏదైనా సూచించడానికి లేదు.

1002
01:03:05,550 --> 01:03:09,270
వారు సూచించడానికి విషయాలు pointees అని, మరియు వాటిని ఏర్పాటు చేయడం ప్రత్యేక అడుగు ఉంటాయి.

1003
01:03:09,270 --> 01:03:12,330
[పురుషుడు స్పీకర్] ఓహ్, హక్కు,. నేను తెలుసు. pointees విడిగా ఉంటాయి.

1004
01:03:12,330 --> 01:03:15,630
Er, కాబట్టి మీరు ఒక pointee కేటాయించాలని చెయ్యాలి?

1005
01:03:15,630 --> 01:03:21,510
[Binky] సరే. ఈ కోడ్ ఒక కొత్త పూర్ణాంక pointee కేటాయించుకునే, మరియు ఈ భాగం x అది సూచించడానికి అమర్చుతుంది.

1006
01:03:21,510 --> 01:03:23,500
[పురుషుడు స్పీకర్] హేయ్, మంచి కనిపిస్తోంది.

1007
01:03:23,500 --> 01:03:26,030
కాబట్టి అది ఏదో ఒకటి చేయండి. >> [Binky] సరే.

1008
01:03:26,030 --> 01:03:30,300
నేను dereference పాయింటర్ x దాని pointee లోకి సంఖ్య 42 నిల్వ చేస్తాము.

1009
01:03:30,300 --> 01:03:34,410
ఈ ట్రిక్ కోసం నేను dereferencing నా మాజిక్ మంత్ర చేయాలి.

1010
01:03:34,410 --> 01:03:38,610
[పురుషుడు స్పీకర్] dereferencing యొక్క మీ మేజిక్ మంత్రదండం? ఆ గొప్ప పని.

1011
01:03:38,610 --> 01:03:44,230
[Binky] ఈ కోడ్ ఎలా ఉంది. నేను ఏర్పాటు మరియు చేస్తాము ... [ధ్వని పాపింగ్]

1012
01:03:44,230 --> 01:03:46,100
చూడండి [పురుషుడు స్పీకర్] హేయ్, అక్కడ అది వెళుతుంది.

1013
01:03:46,100 --> 01:03:50,990
కాబట్టి x ఒక dereference చేయడం, బాణం దాని pointee ప్రాప్తి చేయడానికి క్రింది

1014
01:03:50,990 --> 01:03:53,230
ఈ సందర్భంలో అక్కడ 42 నిల్వ.

1015
01:03:53,230 --> 01:03:57,630
హేయ్, ఇతర పాయింటర్, Y ద్వారా సంఖ్య 13 నిల్వ దానిని ఉపయోగించి ప్రయత్నించండి.

1016
01:03:57,630 --> 01:04:03,250
[Binky] సరే. నేను y ఇక్కడ వెళ్ళి సంఖ్య 13 ఏర్పాటు పొందుతారు

1017
01:04:03,250 --> 01:04:08,360
మరియు అప్పుడు dereferencing మరియు మంత్రదండం పడుతుంది ... [సందడిగల ధ్వని] ఆహా!

1018
01:04:08,360 --> 01:04:10,980
[పురుషుడు స్పీకర్] హేయ్ ఓహ్, ఆ పని చేయలేదు.

1019
01:04:10,980 --> 01:04:14,870
>> Binky, సే, నేను y dereferencing మంచి ఆలోచన కాదు అనుకునే

1020
01:04:14,870 --> 01:04:17,880
pointee ఏర్పాటు ప్రత్యేక అడుగు ఎందుకంటే

1021
01:04:17,880 --> 01:04:19,850
మరియు మనం ఎప్పుడూ చేసియున్నారు భావించడం లేదు.

1022
01:04:19,850 --> 01:04:21,770
[Binky] అయ్యో, మంచి పాయింట్.

1023
01:04:21,770 --> 01:04:26,640
[పురుషుడు స్పీకర్] అవును. మేము పాయింటర్ Y కేటాయించింది అయితే pointee సూచించడానికి సెట్ ఎప్పుడూ.

1024
01:04:26,640 --> 01:04:28,780
[Binky] అయ్యో, చాలా గమనించే.

1025
01:04:28,780 --> 01:04:30,690
[పురుషుడు స్పీకర్] హేయ్, మీరు Binky, అక్కడ మంచి ఉన్నాము.

1026
01:04:30,690 --> 01:04:34,160
మీరు దాన్ని పరిష్కరించడానికి చేసే x అదే pointee కు y పాయింట్లు? >> [Binky] షూర్.

1027
01:04:34,160 --> 01:04:37,100
నేను పాయింటర్ అప్పగించిన నా మాజిక్ మంత్ర ఉపయోగిస్తాము.

1028
01:04:37,100 --> 01:04:39,070
[పురుషుడు స్పీకర్] ముందు వంటి సమస్య అన్నారు ఆ?

1029
01:04:39,070 --> 01:04:40,840
[Binky] లేదు, ఈ pointees టచ్ లేదు.

1030
01:04:40,840 --> 01:04:44,780
ఇది మరొక అదే విషయం సూచించడానికి ఒక పాయింటర్ మారుస్తుంది. [ధ్వని పాపింగ్]

1031
01:04:44,780 --> 01:04:48,570
[పురుషుడు స్పీకర్] ఓహ్, నేను చూడండి. X అదే స్థానంలో ఇప్పుడు Y పాయింట్లు.

1032
01:04:48,570 --> 01:04:51,140
కాబట్టి వేచి. ఇప్పుడు Y పరిష్కరించబడింది. ఇది ఒక pointee ఉంది.

1033
01:04:51,140 --> 01:04:54,520
కాబట్టి మీరు 13 పంపడానికి మళ్ళీ dereferencing యొక్క దండం ప్రయత్నించవచ్చు.

1034
01:04:54,520 --> 01:04:58,130
[Binky] ఉహ్, సరే. ఇక్కడ వస్తుంది. [ధ్వని పాపింగ్]

1035
01:04:58,130 --> 01:05:01,250
[పురుషుడు స్పీకర్] హేయ్, ఆ దృష్టి. ఇప్పుడు Y పనులు dereferencing.

1036
01:05:01,250 --> 01:05:05,200
గమనికలు ఒక pointee భాగస్వామ్యం ఎందుకంటే, వారు రెండు 13 చూడండి.

1037
01:05:05,200 --> 01:05:06,910
[Binky] అవును, భాగస్వామ్యం. ఏమైనప్పటికీ.

1038
01:05:06,910 --> 01:05:08,880
>> కాబట్టి మేము ఇప్పుడు ప్రదేశాలు మారడానికి వెళ్తున్నారు?

1039
01:05:08,880 --> 01:05:11,420
[పురుషుడు స్పీకర్] లుక్ ఓహ్, మేము సమయం లేదు. >> [Binky] కానీ -

1040
01:05:11,420 --> 01:05:13,880
[పురుషుడు స్పీకర్] 3 పాయింటర్ నియమాలు జస్ట్ గుర్తు.

1041
01:05:13,880 --> 01:05:18,630
సంఖ్య 1, ప్రాథమిక నిర్మాణాన్ని మీరు ఒక పాయింటర్ కలిగి ఉంది మరియు ఇది ఒక pointee కు చూపాడు.

1042
01:05:18,630 --> 01:05:23,120
కానీ పాయింటర్ మరియు pointee విడిగా ఉంటాయి, మరియు సాధారణ లోపాన్ని పాయింటర్ ఏర్పాటు చేయడం

1043
01:05:23,120 --> 01:05:25,680
కానీ ఒక pointee ఇవ్వాలని మర్చిపోవటానికి.

1044
01:05:25,680 --> 01:05:29,580
సంఖ్య 2, పాయింటర్ dereferencing పాయింటర్ మొదలవుతుంది మరియు దాని బాణం క్రింది

1045
01:05:29,580 --> 01:05:31,060
దాని pointee ప్రాప్తి చేయడానికి.

1046
01:05:31,060 --> 01:05:34,340
మేము అన్ని తెలిసి ఒక pointee ఉంటే ఈ మాత్రమే పనిచేస్తుంది

1047
01:05:34,340 --> 01:05:36,460
ఇది రకమైన సంఖ్య 1 పాలన వచ్చేస్తుంది.

1048
01:05:36,460 --> 01:05:39,870
సంఖ్య 3, పాయింటర్ అప్పగించిన ఒక పాయింటర్ తీసుకుని మార్చుకుంటారు

1049
01:05:39,870 --> 01:05:42,390
మరొక పాయింటర్ అదే pointee మార్చాలి.

1050
01:05:42,390 --> 01:05:45,890
కాబట్టి అప్పగించిన తర్వాత, 2 గమనికలు అదే pointee కు ఆకర్షిస్తాయి.

1051
01:05:45,890 --> 01:05:47,800
కొన్నిసార్లు భాగస్వామ్య అని.

1052
01:05:47,800 --> 01:05:50,910
>> మరియు ఆ నిజంగా అది ఉంది అంతే. ఇప్పుడు బై-బై.

1053
01:05:50,910 --> 01:05:55,840
ఈ Binky ఉంది. ఈ CS50 ఉంది. వచ్చే వారం మీరు చూస్తారు. [చప్పట్లు]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]