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

2
00:00:06,030 --> 00:00:08,390
>> డౌ LLOYD: గమనికలు, ఇక్కడ మేము ఉన్నాయి.

3
00:00:08,390 --> 00:00:11,080
ఈ బహుశా అన్నారు
అతి క్లిష్టమైన అంశం

4
00:00:11,080 --> 00:00:12,840
మేము CS50 గురించి మాట్లాడితే.

5
00:00:12,840 --> 00:00:15,060
మరియు మీరు చదివారు ఉంటే
గమనికలు గురించి ఏదైనా

6
00:00:15,060 --> 00:00:19,080
మీరు కొద్దిగా కావచ్చు ముందు
భయపెట్టడం ఈ వీడియో వెళ్లడానికి.

7
00:00:19,080 --> 00:00:21,260
ఇది గమనికలు నిజం
మీరు సామర్ధ్యానికి అనుమతిస్తాయి లేదు

8
00:00:21,260 --> 00:00:23,740
బహుశా అప్ మేకు
అందంగా చెడుగా మీరు ఉన్నప్పుడు

9
00:00:23,740 --> 00:00:27,450
వేరియబుల్స్ మరియు సమాచారంతో పనిచేసే,
మరియు మీ ప్రోగ్రామ్ క్రాష్ దీనివల్ల.

10
00:00:27,450 --> 00:00:30,490
కాని అవి నిజానికి నిజంగా ఉపయోగకరంగా ఉన్నారు
మరియు వారు మాకు ఒక గొప్ప మార్గం అనుమతిస్తుంది

11
00:00:30,490 --> 00:00:33,340
తిరిగి డేటా పాస్ మరియు
ముందుకు విధులు మధ్య,

12
00:00:33,340 --> 00:00:35,490
మేము లేకపోతే చెయ్యలేకపోతే.

13
00:00:35,490 --> 00:00:37,750
>> కాబట్టి మేము నిజంగా
రైలు ఇక్కడ చేయాలనుకుంటున్నారా

14
00:00:37,750 --> 00:00:41,060
మీరు మంచి పాయింటర్ క్రమశిక్షణ కలిగి, కాబట్టి
మీరు సమర్థవంతంగా గమనికలు ఉపయోగించవచ్చు ఆ

15
00:00:41,060 --> 00:00:43,850
మీ కార్యక్రమాలు మెరుగ్గా చేయడానికి.

16
00:00:43,850 --> 00:00:48,220
నేను అన్నాడు వంటి గమనికలు మాకు వేరే ఇవ్వాలని
వే ఫంక్షన్ మధ్య డేటా పాస్.

17
00:00:48,220 --> 00:00:50,270
ఇప్పుడు మీరు గుర్తు ఉంటే
అంతకుముందు వీడియో, ఎప్పుడు

18
00:00:50,270 --> 00:00:53,720
మేము గురించి మాట్లాడుతూ
వేరియబుల్ స్కోప్, నేను చెప్పిన

19
00:00:53,720 --> 00:01:00,610
మేము మధ్య పాస్ అన్ని డేటా
సి లో విధులు విలువ ద్వారా ముగిసింది.

20
00:01:00,610 --> 00:01:03,070
మరియు నేను ఉపయోగించే ఉండకపోవచ్చు
పదం నేను అక్కడ అర్థం ఏమి

21
00:01:03,070 --> 00:01:07,170
మేము డేటా యొక్క కాపీలు ప్రయాణిస్తున్న ఉంది.

22
00:01:07,170 --> 00:01:12,252
మేము ఒక ఫంక్షన్ ఒక వేరియబుల్ పాస్ చేసినప్పుడు,
మేము నిజంగా వేరియబుల్ ప్రయాణిస్తున్న లేదు

23
00:01:12,252 --> 00:01:13,210
ఫంక్షన్, కుడి?

24
00:01:13,210 --> 00:01:17,670
మేము కాపీని అక్కడ చేస్తున్నారు
ఫంక్షన్ ఆ డేటా.

25
00:01:17,670 --> 00:01:20,760
ఫంక్షన్ ఏమి అది చేస్తుంది
మరియు అది కొన్ని విలువ లెక్కిస్తుంది,

26
00:01:20,760 --> 00:01:23,180
మరియు బహుశా మేము ఆ విలువ ఉపయోగించడానికి
అది తిరిగి ఇచ్చే ఉన్నప్పుడు.

27
00:01:23,180 --> 00:01:26,700
>> ఒక మినహాయింపు ఉంది
విలువ ద్వారా ప్రయాణిస్తున్న ఈ నిబంధనను

28
00:01:26,700 --> 00:01:31,210
మరియు మేము ఏమి ఆ వచ్చి చేస్తాము
ఈ వీడియో లో తర్వాత కొద్దిగా ఉంది.

29
00:01:31,210 --> 00:01:34,880
మేము బదులుగా గమనికలు ఉపయోగిస్తే
వేరియబుల్స్ ఉపయోగించి యొక్క,

30
00:01:34,880 --> 00:01:38,180
లేదా వేరియబుల్ ఉపయోగించి బదులు
తమను లేదా వేరియబుల్స్ యొక్క కాపీలు,

31
00:01:38,180 --> 00:01:43,790
మేము ఇప్పుడు చుట్టూ వేరియబుల్స్ పాస్
వేరే విధంగా విధులు మధ్య.

32
00:01:43,790 --> 00:01:46,550
ఈ మేము చేస్తే అర్థం
ఒక ఫంక్షన్ లో ఒక మార్పు,

33
00:01:46,550 --> 00:01:49,827
ఆ మార్పు నిజానికి పడుతుంది
వేరే ఫంక్షన్ లో ప్రభావితం.

34
00:01:49,827 --> 00:01:52,160
మళ్ళీ, ఈ ఏదో అని
మేము గతంలో ఏమి కాలేదు

35
00:01:52,160 --> 00:01:56,979
మరియు మీరు ఎప్పుడైనా మారడానికి ప్రయత్నించాము ఉంటే
ఒక ఫంక్షన్ లో రెండు వేరియబుల్స్ విలువ

36
00:01:56,979 --> 00:01:59,270
మీరు ఈ సమస్యను గమనించి చేసిన
చర్మము యొక్క విధమైన, కుడి?

37
00:01:59,270 --> 00:02:04,340
>> మనం X, Y మరియు మేము స్వాప్ అనుకుంటే
swap అనే ఫంక్షన్ వాటిని పాస్,

38
00:02:04,340 --> 00:02:08,680
ఫంక్షన్ లోపలి మార్పిడి
వేరియబుల్స్ మార్పిడి విలువలు చేయండి.

39
00:02:08,680 --> 00:02:12,600
ఒకటి రెండు అవుతుంది, రెండు అవుతుంది
ఒకటి, కానీ మేము నిజంగా లేదు

40
00:02:12,600 --> 00:02:16,890
అసలు ఏదైనా మార్చడానికి
ఫంక్షన్, కాలర్ లో.

41
00:02:16,890 --> 00:02:19,550
ఎందుకంటే మేము, మేము ఉన్నాము మాత్రమే
వాటిలో కాపీలు పని.

42
00:02:19,550 --> 00:02:24,760
అయితే గమనికలు తో, మేము
నిజానికి ఒక ఫంక్షన్ X మరియు Y పాస్.

43
00:02:24,760 --> 00:02:26,960
ఆ ఫంక్షన్ చేయవచ్చు
వారితో ఏదో.

44
00:02:26,960 --> 00:02:29,250
మరియు ఆ వేరియబుల్స్ విలువలు
నిజానికి మార్చవచ్చు.

45
00:02:29,250 --> 00:02:33,710
కాబట్టి ఆ చాలా మార్పు వార్తలు
డేటా పని మా సామర్థ్యాన్ని.

46
00:02:33,710 --> 00:02:36,100
>> మేము ప్రవేశిస్తాడు ముందు
గమనికలు, నేను అది విలువ వార్తలు అనుకుంటున్నాను

47
00:02:36,100 --> 00:02:38,580
కొన్ని నిమిషాలు తీసుకొని
ఇక్కడ తిరిగి బేసిక్స్ వెళ్ళండి.

48
00:02:38,580 --> 00:02:41,000
మరియు ఎలా వద్ద ఒక లుక్ కలిగి
కంప్యూటర్ మెమరీలో రచనలు

49
00:02:41,000 --> 00:02:45,340
ఈ రెండు విషయాలను వెళ్తున్నారు ఎందుకంటే
నిజానికి చాలా ఒకదానితో మరొకటి సంబంధం ఉండాలి.

50
00:02:45,340 --> 00:02:48,480
బహుశా మీకు బాగా తెలిసి,
మీ కంప్యూటర్ సిస్టమ్పై

51
00:02:48,480 --> 00:02:51,310
మీరు హార్డు డ్రైవు లేదా
బహుశా ఒక ఘన రాష్ట్ర డ్రైవ్,

52
00:02:51,310 --> 00:02:54,430
ఫైలు నిల్వ నగర విధమైన.

53
00:02:54,430 --> 00:02:57,950
ఇది ఎక్కడో సాధారణంగా ఉంది
250 గిగాబైట్ల యొక్క పొరుగు

54
00:02:57,950 --> 00:02:59,810
ఇప్పుడు టెరాబైట్ల బహుశా ఒక జంట.

55
00:02:59,810 --> 00:03:02,270
మరియు అది అన్ని మీ
ఫైళ్లు చివరికి, నివసిస్తున్నారు

56
00:03:02,270 --> 00:03:04,870
మీ కంప్యూటర్ షట్ కూడా
ఆఫ్, మీరు తిరిగి చెయ్యవచ్చు

57
00:03:04,870 --> 00:03:09,190
మరియు మీరు మీ ఫైళ్ళను ఉన్నాయి పొందుతారు
మళ్ళీ మీరు మీ సిస్టమ్ రీబూట్ చేసినప్పుడు.

58
00:03:09,190 --> 00:03:14,820
కానీ ఒక హార్డ్ డిస్క్ డ్రైవ్ వంటి డిస్క్ డ్రైవ్
ఒక HDD, లేదా ఒక ఘన రాష్ట్ర డ్రైవ్, ఒక SSD,

59
00:03:14,820 --> 00:03:16,050
కేవలం నిల్వ స్థలాన్ని ఉన్నాయి.

60
00:03:16,050 --> 00:03:20,400
>> మేము నిజానికి ఏమీ కాదు
హార్డ్ డిస్క్ లో ఆ డేటా,

61
00:03:20,400 --> 00:03:22,080
లేదా ఒక ఘన రాష్ట్ర డ్రైవ్ లో.

62
00:03:22,080 --> 00:03:24,950
నిజానికి మార్చటానికి
డేటా లేదా దాని చుట్టూ తరలించడానికి,

63
00:03:24,950 --> 00:03:28,800
మేము దానిని తరలించడానికి కలిగి
RAM, రాండమ్ యాక్సెస్ మెమరీ.

64
00:03:28,800 --> 00:03:31,170
ఇప్పుడు RAM, మీరు చాలా కలిగి
మీ కంప్యూటర్ లో తక్కువ.

65
00:03:31,170 --> 00:03:34,185
మీరు ఎక్కడో ఉండవచ్చు
512 మెగాబైట్ల పొరుగు

66
00:03:34,185 --> 00:03:38,850
మీరు పాత కంప్యూటర్ ఉంటే,
బహుశా రెండు, నాలుగు, ఎనిమిది, 16,

67
00:03:38,850 --> 00:03:41,820
బహుశా కూడా కొద్దిగా
మరింత, RAM యొక్క గిగాబైట్ల.

68
00:03:41,820 --> 00:03:46,390
కాబట్టి ఆ చాలా చిన్న, కానీ ఆ
పేరు అస్థిర డేటా అవి ఉనికిలో.

69
00:03:46,390 --> 00:03:48,270
మేము విషయాలు మార్చవచ్చు పేర్కొంది.

70
00:03:48,270 --> 00:03:53,350
కానీ మేము మా కంప్యూటర్ ఆఫ్ మారినప్పుడు,
RAM లో డేటా యొక్క అన్ని నాశనం.

71
00:03:53,350 --> 00:03:57,150
>> మేము హార్డ్ డిస్క్ కలిగి ఉండాలి ఎందుకు కాబట్టి ఆ
ఇది మరింత శాశ్వత స్థానాన్ని,

72
00:03:57,150 --> 00:03:59,720
ఇది exists- కనుక అది చేస్తాను
నిజంగా చెడు ఉంటుంది ఉంటే ప్రతిసారీ మేము

73
00:03:59,720 --> 00:04:03,310
మా కంప్యూటర్ ఆఫ్ మారిన ప్రతి
మా సిస్టమ్ లో ఫైల్ నాశనం చేసింది జరిగినది.

74
00:04:03,310 --> 00:04:05,600
కాబట్టి మేము RAM యొక్క లోపల పని.

75
00:04:05,600 --> 00:04:09,210
మరియు ప్రతిసారీ మనం మాట్లాడే
మెమరీ, చాలా చక్కని, CS50 లో,

76
00:04:09,210 --> 00:04:15,080
మేము RAM, హార్డ్ లేదు డిస్క్ గురించి మాట్లాడటం చేస్తున్నాం.

77
00:04:15,080 --> 00:04:18,657
>> కాబట్టి మేము మెమరీ లోకి విషయాలు తరలించడానికి ఉన్నప్పుడు,
అది ఖాళీ కొన్ని మొత్తం తీసుకుంటుంది.

78
00:04:18,657 --> 00:04:20,740
అన్ని డేటా రకాలు ఆ
మేము పని చేసిన

79
00:04:20,740 --> 00:04:23,480
వేర్వేరు పడుతుంది
RAM లో స్థలం మొత్తంలో.

80
00:04:23,480 --> 00:04:27,600
కాబట్టి ప్రతి సమయం మీరు ఒక పూర్ణాంకం సృష్టించడానికి
మెమరీ వేరియబుల్ నాలుగు బైట్లు

81
00:04:27,600 --> 00:04:30,750
మీరు అలా RAM లో ప్రక్కన సెట్ ఉన్నాయి
ఆ పూర్ణాంక తో పని చేయవచ్చు.

82
00:04:30,750 --> 00:04:34,260
మీరు పూర్ణాంకం డిక్లేర్
దానిని మార్చడం, అది కేటాయించి

83
00:04:34,260 --> 00:04:36,700
పెరిగిన ఒక విలువ 10 కు
ఒకటి, అందువలన న న.

84
00:04:36,700 --> 00:04:39,440
లో ఏమి అవసరం అన్ని
RAM, మరియు మీరు నాలుగు బైట్లు పొందడానికి

85
00:04:39,440 --> 00:04:42,550
ప్రతి కోసం పని
మీరు సృష్టించే పూర్ణాంక.

86
00:04:42,550 --> 00:04:45,410
>> ప్రతి పాత్ర మీరు
సృష్టించడానికి ఒక బైట్ పొందుతాడు.

87
00:04:45,410 --> 00:04:48,160
ఆ స్థలం ఎంత ఉంది
ఒక పాత్ర నిల్వ అవసరం.

88
00:04:48,160 --> 00:04:51,310
ప్రతి ఫ్లోట్, నిజమైన
సంఖ్య నాలుగు బైట్లు గెట్స్

89
00:04:51,310 --> 00:04:53,390
అది ఒక డబుల్ తప్ప
ఖచ్చితత్వము ఫ్లోటింగ్ పాయింట్

90
00:04:53,390 --> 00:04:56,510
ఇది మిమ్మల్ని దీనికి అనుమతిస్తుంది సంఖ్య,
మరింత ఖచ్చితమైన లేదా ఎక్కువ అంకెలు కలిగి

91
00:04:56,510 --> 00:04:59,300
దశాంశ బిందువు తర్వాత
ఖచ్చితత్వము కోల్పోకుండా,

92
00:04:59,300 --> 00:05:01,820
ఇది మెమరీ ఎనిమిది బైట్లు పడుతుంది.

93
00:05:01,820 --> 00:05:06,730
లాంగ్ longs, నిజంగా పెద్ద పూర్ణాంకాల
కూడా మెమరీ ఎనిమిది బైట్లు పడుతుంది.

94
00:05:06,730 --> 00:05:09,000
ఎన్ని మెమరీ బైట్లు
తీగలను అప్ తీసుకుని చెయ్యాలి?

95
00:05:09,000 --> 00:05:12,990
Well యొక్క ఆ ప్రశ్న లో ఒక పిన్ ఉంచారు తెలియజేయండి
కానీ, ఇప్పుడు మేము తిరిగి వచ్చారు చేస్తాము.

96
00:05:12,990 --> 00:05:17,350
>> సో తిరిగి మెమొరీ ఈ ఆలోచన గా
బైట్-పరిమాణ కణాలు పెద్ద అర్రే.

97
00:05:17,350 --> 00:05:20,871
ఆ నిజంగా అది అంతే, అంతే
కణాల కేవలం ఒక భారీ శ్రేణి,

98
00:05:20,871 --> 00:05:23,370
కేవలం ఏ ఇతర శ్రేణి వంటి
మీకు తెలిసిన మరియు చూడండి,

99
00:05:23,370 --> 00:05:26,430
ప్రతి మూలకం తప్ప ఒక బైట్ వెడల్పుతో ఉంటుంది.

100
00:05:26,430 --> 00:05:30,030
మరియు కేవలం ఒక శ్రేణి వంటి,
ప్రతి మూలకం ఒక చిరునామా ఉంది.

101
00:05:30,030 --> 00:05:32,120
వ్యూహం ప్రతి మూలకం
ఒక ఇండెక్స్, మరియు మేము ఉంది

102
00:05:32,120 --> 00:05:36,302
అని పిలవబడే చేయాలని ఆ సూచిక ఉపయోగించవచ్చు
శ్రేణి రాండమ్ యాక్సెస్.

103
00:05:36,302 --> 00:05:38,510
మేము వద్ద ప్రారంభించడానికి కలిగి లేదు
అర్రే ప్రారంభంలో,

104
00:05:38,510 --> 00:05:40,569
ప్రతి ద్వారా iterate
ఒకే మూలకం వాటి,

105
00:05:40,569 --> 00:05:41,860
మేము చూస్తున్న ఏమి కనుగొనేందుకు.

106
00:05:41,860 --> 00:05:45,790
మేము కేవలం నేను పొందాలనుకోవడం చెప్పగలదు
15 వ మూలకం లేదా 100 వ మూలకం.

107
00:05:45,790 --> 00:05:49,930
మరియు మీరు ఆ సంఖ్య పాస్ చేయవచ్చు
మరియు మీరు చూస్తున్న విలువ పొందండి.

108
00:05:49,930 --> 00:05:54,460
>> అదేవిధంగా ప్రతి నగర
మెమరీ లో ఒక చిరునామా ఉంది.

109
00:05:54,460 --> 00:05:57,320
సో మీ మెమరీ ఉండవచ్చు
ఈ వంటి ఏదో చూడండి.

110
00:05:57,320 --> 00:06:01,420
ఇక్కడ చాలా చిన్న భాగం ఉంది
జ్ఞాపకశక్తి, ఈ మెమరీ 20 బైట్లు.

111
00:06:01,420 --> 00:06:04,060
మొదటి 20 బైట్లు ఎందుకంటే నా
దిగువన చిరునామాలు

112
00:06:04,060 --> 00:06:08,890
3, 2, 1, 0, మరియు అందువల్ల
19 వరకు అన్ని మార్గంలో.

113
00:06:08,890 --> 00:06:13,190
నేను వేరియబుల్స్ డిక్లేర్ ఎప్పుడు
నేను వారితో పని ప్రారంభించినప్పుడు,

114
00:06:13,190 --> 00:06:15,470
వ్యవస్థ సెట్ అన్నారు
నాకు పక్కన కొన్ని స్పేస్

115
00:06:15,470 --> 00:06:17,595
ఈ మెమరీ లో పని
నా వేరియబుల్స్ తో.

116
00:06:17,595 --> 00:06:21,610
నేను చార్ సి రాజధాని సమానం అనవచ్చు
హెచ్ ఏ జరిగే అవకాశముంది?

117
00:06:21,610 --> 00:06:23,880
వెల్ వ్యవస్థలో అన్నారు
నాకు ఒక బైట్ కోసం ప్రక్కన సెట్.

118
00:06:23,880 --> 00:06:27,870
ఈ సందర్భంలో అది బైట్ సంఖ్య ఎంచుకున్నాడు
నాలుగు, చిరునామా నాలుగు వద్ద బైట్,

119
00:06:27,870 --> 00:06:31,310
మరియు అది నిల్వ జరగబోతోంది
నాకు అక్కడ లేఖ రాజధాని H.

120
00:06:31,310 --> 00:06:34,350
నేను అప్పుడు పూర్ణాంకానికి వేగం చెప్పుకోవాలంటే
పరిమితి అంతే, 65 సమానం

121
00:06:34,350 --> 00:06:36,806
ప్రక్కన నాలుగు సెట్ వెళుతున్న
నాకు మెమరీ బైట్లు.

122
00:06:36,806 --> 00:06:39,180
మరియు ఇది ఆ చికిత్స జరగబోతోంది
ఒకే యూనిట్ గా నాలుగు బైట్లు

123
00:06:39,180 --> 00:06:41,305
మేము పని ఏమి ఎందుకంటే
ఇక్కడ పూర్ణాంకం ఉంది.

124
00:06:41,305 --> 00:06:44,350
మరియు ఇది అక్కడ 65 నిల్వ జరగబోతోంది.

125
00:06:44,350 --> 00:06:47,000
>> ఇప్పుడు ఇప్పటికే నేను రకమైన ఉన్నాను
మీరు ఒక అబద్ధం ఒక బిట్ చెప్పడం,

126
00:06:47,000 --> 00:06:50,150
కుడి, మేము తెలుసు ఎందుకంటే
కంప్యూటర్లు బైనరీ లో పని.

127
00:06:50,150 --> 00:06:53,100
వారు అర్థం లేదు
తప్పనిసరిగా ఒక రాజధాని H ఏమిటి

128
00:06:53,100 --> 00:06:57,110
లేదా ఒక 65 వారు మాత్రమే, ఏమిటి
బైనరీ, సున్నాలు మరియు వాటిని అర్థం.

129
00:06:57,110 --> 00:06:59,000
అందువలన నిజానికి ఏమిటి
మేము అక్కడ నిల్వ చేస్తున్నారు

130
00:06:59,000 --> 00:07:03,450
లేఖ H మరియు సంఖ్య 65, కాదు
కానీ బైనరీ ప్రాతినిధ్యాలు

131
00:07:03,450 --> 00:07:06,980
వాటి, ఇది చూడండి
ఈ వంటి చిన్న ఏదో.

132
00:07:06,980 --> 00:07:10,360
మరియు ముఖ్యంగా
పూర్ణాంక వేరియబుల్ యొక్క నేపధ్యము

133
00:07:10,360 --> 00:07:13,559
అది కేవలం అది లోకి ఉమ్మి మాత్రం కాదు
అది ఒక నాలుగు గా చికిత్స మాత్రం కాదు

134
00:07:13,559 --> 00:07:15,350
బైట్ భాగం తప్పనిసరిగా
నిజానికి జరగబోతోంది

135
00:07:15,350 --> 00:07:19,570
నాలుగు ఒక బైట్ రాళ్లను గా చికిత్స,
ఈ వంటి ఏదో చూడండి ఉండవచ్చు.

136
00:07:19,570 --> 00:07:22,424
మరియు కూడా ఈ కాదు
పూర్తిగా నిజం గాని,

137
00:07:22,424 --> 00:07:24,840
అని ఏదో ఎందుకంటే
మేము లేదు ఒక endianness,

138
00:07:24,840 --> 00:07:26,965
, ఇప్పుడు పొందడానికి వెళ్ళడం కానీ
మీరు గురించి ఆసక్తిగా ఉంటే,

139
00:07:26,965 --> 00:07:29,030
మీరు చిన్న అప్ చదువుకోవచ్చు
మరియు పెద్ద endianness.

140
00:07:29,030 --> 00:07:31,640
కానీ ఈ వాదన కొరకు,
ఈ వీడియో కొరకు,

141
00:07:31,640 --> 00:07:34,860
యొక్క ఆ, ఉంది ఊహించుకోవటం తెలియజేయండి
నిజానికి, ఎలా సంఖ్య 65 చేస్తాను

142
00:07:34,860 --> 00:07:36,970
సూచించబడుతుంది
ప్రతి వ్యవస్థ మెమరీ,

143
00:07:36,970 --> 00:07:38,850
అది పూర్తిగా నిజం కాదు అయితే.

144
00:07:38,850 --> 00:07:41,700
>> కానీ యొక్క నిజానికి కేవలం పొందుటకు వీలు
పూర్తిగా అన్ని బైనరీ యొక్క వదులుకొను,

145
00:07:41,700 --> 00:07:44,460
మరియు కేవలం H గురించి ఆలోచించడం
మరియు 65, ఇది చాలా సులభం

146
00:07:44,460 --> 00:07:47,900
వంటి దాని గురించి ఆలోచించటం
ఒక మానవుడు ఆ.

147
00:07:47,900 --> 00:07:51,420
అన్ని కుడి, అది కూడా తెలుస్తోంది కాబట్టి బహుశా ఒక
చిన్న యాదృచ్ఛిక ఆ I've- నా సిస్టమ్

148
00:07:51,420 --> 00:07:55,130
బైట్లు 5, 6, 7 నాకు ఇవ్వలేదని,
మరియు 8 ఇంటీజర్ నిల్వ.

149
00:07:55,130 --> 00:07:58,580
ఆ కారణంగా, చాలా, ఉంది దీనిలో
మేము ఇప్పుడు లోకి పొందుటకు, కానీ తగినంత కాదు

150
00:07:58,580 --> 00:08:00,496
ఆ ఏమి చెప్పాలో
కంప్యూటర్ ఇక్కడ చేస్తున్న

151
00:08:00,496 --> 00:08:02,810
బహుశా దాని భాగంగా ఒక మంచి ఎత్తుగడ ఉంది.

152
00:08:02,810 --> 00:08:06,020
నాకు ఆ మెమరీ ఇవ్వాలని లేదు
తప్పనిసరిగా వెనక్కి తిరిగి.

153
00:08:06,020 --> 00:08:10,490
ఇప్పుడు అది చేయబోవడం అయితే
నేను మరొక స్ట్రింగ్ పొందడానికి అనుకుంటే,

154
00:08:10,490 --> 00:08:13,080
ఇంటిపేరు అని, మరియు నేను కావలసిన
అక్కడ లాయిడ్ ఉంచాలి.

155
00:08:13,080 --> 00:08:18,360
నేను ఒక సరిపోయే అవసరం వెళుతున్న
పాత్ర, ఆ ప్రతి అక్షరం

156
00:08:18,360 --> 00:08:21,330
ఒక అవసరం అన్నారు
పాత్ర, మెమరీ ఒకటి బైట్.

157
00:08:21,330 --> 00:08:26,230
నేను నా శ్రేణి లోకి లాయిడ్ చాలు కాలేదు చేస్తే
ఈ వంటి నేను, వెళ్ళడానికి చాలా మంచి రెడీ?

158
00:08:26,230 --> 00:08:28,870
వెలితి?

159
00:08:28,870 --> 00:08:31,840
>> ప్రతి స్ట్రింగ్ మేము పని గుర్తుంచుకోండి
సి బాక్ స్లాష్ సున్నా ముగుస్తుంది తో,

160
00:08:31,840 --> 00:08:33,339
మరియు మేము గాని, ఇక్కడ ఆ వదిలివేయు చేయవచ్చు.

161
00:08:33,339 --> 00:08:36,090
మేము ప్రక్కన ఒక బైట్ సెట్ అవసరం
మెమరీ కాబట్టి మేము ఆ పట్టుకోండి

162
00:08:36,090 --> 00:08:39,130
మా స్ట్రింగ్ ముగిసినప్పుడు తెలుసు.

163
00:08:39,130 --> 00:08:41,049
మరలా ఈ అమరిక
మార్గం విషయాలు

164
00:08:41,049 --> 00:08:42,799
మెమరీ మైట్ కనిపిస్తాయి
కొద్దిగా యాదృచ్ఛిక

165
00:08:42,799 --> 00:08:44,870
కానీ అది నిజానికి ఎలా ఉంది
అనేక వ్యవస్థలు రూపొందించబడ్డాయి.

166
00:08:44,870 --> 00:08:48,330
గుణిజాలను వాటిని వరుసలో
నాలుగు కారణాలు మళ్ళీ

167
00:08:48,330 --> 00:08:50,080
మేము అవసరం లేని
ప్రస్తుతం పొందడానికి.

168
00:08:50,080 --> 00:08:53,060
కానీ ఈ, కాబట్టి చెప్పడానికి అది తగినంత
కోడ్ యొక్క ఈ మూడు పంక్తులు తరువాత,

169
00:08:53,060 --> 00:08:54,810
ఈ మెమరీ లాగా ఉండవచ్చు ఏమిటి.

170
00:08:54,810 --> 00:08:58,930
నేను స్మృతిని అవసరం అయితే
4, 8, మరియు 12, నా డేటా పట్టుకోండి

171
00:08:58,930 --> 00:09:01,100
ఈ నా మెమరీ లాగా ఉండవచ్చు ఏమిటి.

172
00:09:01,100 --> 00:09:04,062
>> కేవలం ముఖ్యంగా ఉంటుంది
ఇక్కడ, ఎప్పుడు పాండిత్య ప్రకర్ష

173
00:09:04,062 --> 00:09:06,020
మేము మెమరీ గురించి మాట్లాడటం చేస్తున్నాం
చిరునామాలను సాధారణంగా మనం

174
00:09:06,020 --> 00:09:08,390
కాబట్టి హెక్సాడెసిమల్ నోటేషన్లు ఉపయోగించి.

175
00:09:08,390 --> 00:09:12,030
సో ఎందుకు మేము ఈ అన్ని మార్చేందుకు లేదు
హెక్సాడెసిమల్ సంజ్ఞామానం దశాంశ నుండి

176
00:09:12,030 --> 00:09:15,010
కేవలం ఆ సాధారణంగా ఎందుకంటే
ఎలా మేము మెమరీ చూడండి.

177
00:09:15,010 --> 00:09:17,880
సో బదులుగా ద్వారా 0 అనే
19, మనం సున్నా

178
00:09:17,880 --> 00:09:20,340
సున్నా x1 మూడు ద్వారా x సున్నా.

179
00:09:20,340 --> 00:09:23,790
ఆ మెమొరీ 20 బైట్లు అని మేము
లేదా మేము ఈ చిత్రం లో చూడటం చేస్తున్నారు

180
00:09:23,790 --> 00:09:25,540
ఇక్కడే.

181
00:09:25,540 --> 00:09:29,310
>> కాబట్టి ఆ చెప్పబడుతున్నాయి అన్ని, లెట్స్
రెండవ కోసం మెమరీ నుండి దూరంగా దశను

182
00:09:29,310 --> 00:09:30,490
మరియు తిరిగి గమనికలు.

183
00:09:30,490 --> 00:09:32,420
ఇక్కడ అత్యంత ముఖ్యం
విషయం గుర్తుంచుకోవాలని

184
00:09:32,420 --> 00:09:34,070
మేము గమనికలు పని మొదలు.

185
00:09:34,070 --> 00:09:36,314
ఒక పాయింటర్ ఏమీ
ఒక చిరునామా కంటే ఎక్కువ.

186
00:09:36,314 --> 00:09:38,230
నేను మళ్ళీ ఎందుకంటే చెప్పాను చేస్తాము
అది ముఖ్యం

187
00:09:38,230 --> 00:09:42,730
ఒక పాయింటర్ ఏమీ
ఒక చిరునామా కంటే ఎక్కువ.

188
00:09:42,730 --> 00:09:47,760
గమనికలు స్థానాలకు విలాసాలు
మెమరీలో వేరియబుల్స్ నివసించే.

189
00:09:47,760 --> 00:09:52,590
ఇది ఆశాజనక అవుతుంది అని తెలుసుకుంటే
సులభంగా కొద్దిగా వారితో పని.

190
00:09:52,590 --> 00:09:54,550
నేను ఇష్టం మరొక విషయం
అలా విధమైన కలిగి ఉంది

191
00:09:54,550 --> 00:09:58,510
దృశ్యపరంగా ఏమి ప్రాతినిధ్యం రేఖాచిత్రాలు
కోడ్ యొక్క వివిధ మార్గాల తో జరుగుతున్న.

192
00:09:58,510 --> 00:10:00,660
మరియు మేము ఈ జంట చేస్తాను
గమనికలు సార్లు,

193
00:10:00,660 --> 00:10:03,354
మరియు మేము డైనమిక్ గురించి మాట్లాడినప్పుడు
మెమరీ కేటాయింపు అలాగే.

194
00:10:03,354 --> 00:10:06,020
నేను ఈ చిత్రాలు అని అనుకుంటున్నాను ఎందుకంటే
ముఖ్యంగా సహాయపడతాయి.

195
00:10:06,020 --> 00:10:09,540
>> నేను ఉదాహరణకు సే చేస్తే, Int k
నా కోడ్ లో, ఏమి జరుగుతుందో?

196
00:10:09,540 --> 00:10:12,524
బాగా ప్రధానంగా ఉంటుంది జరుగుతున్నది
నేను నాకు పక్కన పెట్టింది మెమరీ పొందుతున్నాను

197
00:10:12,524 --> 00:10:14,690
కానీ నేను కూడా ఇష్టం లేదు
నేను ఆ వంటి దాని గురించి ఆలోచించటం

198
00:10:14,690 --> 00:10:16,300
ఒక బాక్స్ వంటి దాని గురించి ఆలోచించడానికి ఇష్టపడతాను.

199
00:10:16,300 --> 00:10:20,090
నేను ఒక బాక్స్ మరియు అది
రంగు ఆకుపచ్చ నేను ఎందుకంటే

200
00:10:20,090 --> 00:10:21,750
ఆకుపచ్చ బాక్సులను లో పూర్ణాంకాల ఉంచవచ్చు.

201
00:10:21,750 --> 00:10:23,666
ఇది ఒక పాత్ర నేను ఒక
ఒక నీలం బాక్స్ ఉండవచ్చు.

202
00:10:23,666 --> 00:10:27,290
నేను సృష్టించడం నేను అయితే నేను ఎల్లప్పుడూ చెప్పటానికి
పూర్ణాంకాల జరపవచ్చని సూచించబడింది ఒక బాక్స్

203
00:10:27,290 --> 00:10:28,950
ఆ బాక్స్ ఆకుపచ్చ రంగు ఉంటుంది.

204
00:10:28,950 --> 00:10:33,020
నేను ఒక శాశ్వత మార్కర్ తీసుకొని
మరియు నేను వైపు k వ్రాయండి.

205
00:10:33,020 --> 00:10:37,590
నేను, k అనే ఒక బాక్స్
ఇందులో నేను పూర్ణాంకాల ఉంచవచ్చు.

206
00:10:37,590 --> 00:10:41,070
నేను Int k సే, ఆ
ఏమి నా తల జరుగుతుంది.

207
00:10:41,070 --> 00:10:43,140
నేను k ఐదు సమానం చెబితే, నేను ఏమి చేస్తున్నాను?

208
00:10:43,140 --> 00:10:45,110
Well, నేను ఐదు ఆటంకమవుతుంది
బాక్స్ లో, కుడి.

209
00:10:45,110 --> 00:10:48,670
ఈ ఉంటే, అందంగా సూటిగా ఉంటుంది
నేను Int k, k అనే బాక్స్ సృష్టించవచ్చు అంటున్నారు.

210
00:10:48,670 --> 00:10:52,040
ఉంటే నేను, k 5 సమానం చెప్పడానికి
పెట్టెలో ఐదు ఉంచారు.

211
00:10:52,040 --> 00:10:53,865
ఆశాజనక ఒక లీపు యొక్క చాలా కాదు.

212
00:10:53,865 --> 00:10:55,990
విషయాలు వెళ్ళి అక్కడ ఇక్కడ
అయితే ఆసక్తికరమైన కొద్దిగా.

213
00:10:55,990 --> 00:11:02,590
నేను Int * PK చెబితే, నేను పోయినా
ఈ తప్పనిసరిగా అర్థం ఏమి,

214
00:11:02,590 --> 00:11:06,150
ఇది స్పష్టంగా ఏదో తీరవలసినదే
ఒక పూర్ణాంకం చేయాలని.

215
00:11:06,150 --> 00:11:08,211
కాబట్టి నేను రంగు వెళుతున్న
ఆకుపచ్చ ఇష్ ఈ బాక్స్

216
00:11:08,211 --> 00:11:10,210
నేను ఏదో తీరవలసినదే తెలుసు
ఒక పూర్ణాంకం చేయాలని,

217
00:11:10,210 --> 00:11:13,400
కానీ అది ఒక పూర్ణాంకం కూడా కాదు,
అది ఒక పూర్ణాంకానికి తార ఎందుకంటే.

218
00:11:13,400 --> 00:11:15,390
ఏదో కొద్దిగా ఉంది
దాని గురించి వివిధ.

219
00:11:15,390 --> 00:11:17,620
కాబట్టి పూర్ణాంకం యొక్క చేరి
కానీ లేకపోతే అంతే

220
00:11:17,620 --> 00:11:19,830
నుండి చాలా భిన్నంగా లేదు
మనం గురించి మాట్లాడుతూ.

221
00:11:19,830 --> 00:11:24,240
ఇది ఒక బాక్స్, దాని, ఒక లేబుల్ వచ్చింది
అది ఒక లేబుల్ PK వేసుకొని,

222
00:11:24,240 --> 00:11:27,280
మరియు అది హోల్డింగ్ సామర్థ్యం
ఆ సంసార Int నక్షత్రాలు.

223
00:11:27,280 --> 00:11:29,894
వారు ఏదైనా కలిగి
పూర్ణాంకాల తో, స్పష్టంగా.

224
00:11:29,894 --> 00:11:31,060
ఇక్కడ చివరి పంక్తి అయితే అనిపిస్తుంది.

225
00:11:31,060 --> 00:11:37,650
నేను చెప్పే ఉంటే PK = & k, అయ్యో,
ఏమి కేవలం కుడి, జరిగింది?

226
00:11:37,650 --> 00:11:41,820
కాబట్టి ఈ యాదృచ్చిక సంఖ్య, అకారణంగా యాదృచ్ఛిక
అనేక ఉన్నాయి బాక్స్ లోనికి విసిరి కావాలి.

227
00:11:41,820 --> 00:11:44,930
అని అన్ని, PK ఉంది
k యొక్క చిరునామా గెట్స్.

228
00:11:44,930 --> 00:11:52,867
K మెమరీ జీవించింది నేను అంటుకునే చేస్తున్నాను,
దాని చిరునామా, దాని బైట్లు యొక్క చిరునామా.

229
00:11:52,867 --> 00:11:55,200
నేను అంతా నాకు ఉంది చెప్పడం
ఆ విలువ నేను వెళుతున్నాను ఏమి ఉంది

230
00:11:55,200 --> 00:11:59,430
నా బాక్స్ అని PK లోపల ఉంచాలి.

231
00:11:59,430 --> 00:12:02,080
మరియు ఈ విషయాలు ఉన్నాయి ఎందుకంటే
గమనికలు మరియు చూస్తున్న ఎందుకంటే

232
00:12:02,080 --> 00:12:04,955
సున్నా x వంటి స్ట్రింగ్ వద్ద
ఎనిమిది సున్నా సి ఏడు నాలుగు ఎనిమిది

233
00:12:04,955 --> 00:12:07,790
రెండు సున్నా బహుశా
చాలా అర్థవంతమైన కాదు.

234
00:12:07,790 --> 00:12:12,390
మేము సాధారణంగా గమనికలు ఊహించడానికి చేసినప్పుడు,
మేము నిజానికి గమనికలు వంటి అలా.

235
00:12:12,390 --> 00:12:17,000
PK మాకు సమాచారం ఇస్తుంది
మేము మెమరీలో k కనుగొనేందుకు అవసరం.

236
00:12:17,000 --> 00:12:19,120
కాబట్టి ప్రాథమికంగా PK అది ఒక బాణం ఉంది.

237
00:12:19,120 --> 00:12:21,670
మరియు మేము పొడవు నడిచి ఉంటే
ఆ బాణం ఊహించే

238
00:12:21,670 --> 00:12:25,280
మీరు నడిచే ఏదో ఉంది, మనం ఉంటే
బాణం యొక్క పొడవు వెంట నడిచి,

239
00:12:25,280 --> 00:12:29,490
ఆ బాణం చాలా కొన వద్ద, మేము
మెమరీలో స్థానం కనుగొంటారు

240
00:12:29,490 --> 00:12:31,390
ఇక్కడ k నివసిస్తున్నారు.

241
00:12:31,390 --> 00:12:34,360
మరియు ఆ నిజంగా ముఖ్యం
k జీవించింది మేము తెలుసు ఎందుకంటే ఒకసారి,

242
00:12:34,360 --> 00:12:37,870
మేము డేటా పని ప్రారంభించవచ్చు
ఆ మెమొరీ లోకేషన్ లోపల.

243
00:12:37,870 --> 00:12:40,780
మేము ఒక teeny పొందుతుంటే అయితే
ఇప్పుడు ముందుకు మనలోని బిట్.

244
00:12:40,780 --> 00:12:42,240
>> కాబట్టి ఒక పాయింటర్ ఏమిటి?

245
00:12:42,240 --> 00:12:45,590
ఒక పాయింటర్ దీని డేటా అంశం
విలువ ఒక మెమరీ చిరునామా ఉంది.

246
00:12:45,590 --> 00:12:49,740
ఆ ఉంది సున్నా x ఎనిమిది సున్నా స్టఫ్
జరగబోతోంది, ఒక మెమరీ చిరునామా ఉంది.

247
00:12:49,740 --> 00:12:52,060
ఆ మెమరీలో స్థానం ఉంది.

248
00:12:52,060 --> 00:12:55,080
మరియు ఒక పాయింటర్ రకం
రకం వివరిస్తుంది

249
00:12:55,080 --> 00:12:56,930
డేటా మీరు చూడండి
మెమరీ చిరునామా.

250
00:12:56,930 --> 00:12:58,810
కాబట్టి Int స్టార్ భాగం అక్కడే ఉంది.

251
00:12:58,810 --> 00:13:03,690
నేను ఆ బాణం అనుసరించండి, అంతే
ఒక స్థానానికి నాకు దారి చెప్పారు.

252
00:13:03,690 --> 00:13:06,980
మరియు ఆ ప్రదేశంలో, నేను
నా ఉదాహరణ లో కనుగొంటారు,

253
00:13:06,980 --> 00:13:08,240
ఒక ఆకుపచ్చ రంగు బాక్స్ ఉంది.

254
00:13:08,240 --> 00:13:12,650
ఇది ఆ ఏమి, పూర్ణాంకం నేను
నేను ఆ చిరునామాకు వెళ్ళి ఉంటే కనుగొంటారు.

255
00:13:12,650 --> 00:13:14,830
ఒక డేటా రకం
పాయింటర్ ఏమి వివరిస్తుంది

256
00:13:14,830 --> 00:13:17,936
మీరు ఆ స్మృతి చిరునామాను వద్ద కనుగొంటారు.

257
00:13:17,936 --> 00:13:19,560
ఇక్కడ అయితే నిజంగా చల్లని విషయం.

258
00:13:19,560 --> 00:13:25,090
గమనికలు మాకు పాస్ అనుమతిస్తుంది
విధులు మధ్య వేరియబుల్స్.

259
00:13:25,090 --> 00:13:28,520
మరియు వాస్తవానికి వేరియబుల్స్ పాస్
మరియు వాటిలో కాపీలు పాస్ లేదు.

260
00:13:28,520 --> 00:13:32,879
మేము తెలిస్తే ఎందుకంటే ఖచ్చితంగా
మెమరీలో ఒక వేరియబుల్ కనుగొనేందుకు,

261
00:13:32,879 --> 00:13:35,670
మేము ఒక కాపీని అవసరం లేదు
అది మనం ఆ స్థానానికి వెళ్ళే

262
00:13:35,670 --> 00:13:37,844
ఆ వేరియబుల్ పని.

263
00:13:37,844 --> 00:13:40,260
సారాంశం గమనికలు కాబట్టి విధమైన
ఒక కంప్యూటర్ వాతావరణాన్ని

264
00:13:40,260 --> 00:13:42,360
చాలా నిజమైన ప్రపంచంలో వంటి, కుడి.

265
00:13:42,360 --> 00:13:44,640
>> కాబట్టి ఇక్కడ ఒక సారూప్యత ఉంది.

266
00:13:44,640 --> 00:13:48,080
లెట్ యొక్క నేను ఒక నోట్బుక్ అని చెప్పారు ఆ,
కుడి, మరియు స్వరాల పూర్తిగా.

267
00:13:48,080 --> 00:13:50,230
నేను మీరు అది అప్డేట్ కోరుకుంటున్నారో.

268
00:13:50,230 --> 00:13:53,960
మీరు ఒక ఫంక్షన్ అని
నవీకరణలను గమనికలు, కుడి.

269
00:13:53,960 --> 00:13:56,390
విధంగా మేము పరిష్కరించగలుగుతున్నాము
ఇప్పటివరకు పని ఏమి

270
00:13:56,390 --> 00:14:02,370
మీరు నా నోట్బుక్ పడుతుంది జరుగుతుంది,
మీరు కాపీని స్టోర్ వెళ్తాను

271
00:14:02,370 --> 00:14:06,410
మీరు ఒక జిరాక్స్ కాపీని చేస్తాము
నోట్బుక్ ప్రతి పేజీ.

272
00:14:06,410 --> 00:14:09,790
మీరు తిరిగి నా నోట్బుక్ చెప్పను
నా డెస్క్ మీద మీరు పూర్తి చేసినప్పుడు,

273
00:14:09,790 --> 00:14:14,600
మీరు వెళ్ళి విషయాలను దాటడానికి చేస్తాము నా
తేదీ లేదా తప్పు బయటకు ఉన్నాయని నోట్బుక్,

274
00:14:14,600 --> 00:14:19,280
ఆపై మీరు తిరిగి పాస్ చేస్తాము
నాకు జిరాక్స్ పేజీల స్టాక్

275
00:14:19,280 --> 00:14:22,850
నా నోట్బుక్ యొక్క ప్రతిబింబంగా తో ఉంది
మీరు దానికి చేసిన మార్పులు.

276
00:14:22,850 --> 00:14:27,040
మరియు ఆ సమయంలో, అది నాకు ఇష్టం
కాలింగ్ ఫంక్షన్, కాలర్ వంటి,

277
00:14:27,040 --> 00:14:30,582
మీ గమనికలు తీసుకోవాలని నిర్ణయానికి మరియు
నా నోట్బుక్ వాటిని తిరిగి ఇంటిగ్రేట్.

278
00:14:30,582 --> 00:14:32,540
కాబట్టి దశలను చాలా ఉంది
ఇక్కడ చేరి, కుడి.

279
00:14:32,540 --> 00:14:34,850
ఇలా అది మంచి కాదు
నేను చెప్పుకోవాలంటే, హే, మీరు చెయ్యవచ్చు

280
00:14:34,850 --> 00:14:38,370
నా నోట్బుక్ అప్డేట్
నాకు, మీరు నా నోట్బుక్ అప్పగించండి

281
00:14:38,370 --> 00:14:40,440
మరియు మీరు విషయాలు పడుతుంది మరియు
వాచ్యంగా వాటిని బయటకు క్రాస్

282
00:14:40,440 --> 00:14:42,810
మరియు నా నోట్బుక్ లో నా గమనికలు అప్డేట్.

283
00:14:42,810 --> 00:14:45,140
ఆపై నాకు నా నోట్బుక్ తిరిగి ఇవ్వాలని.

284
00:14:45,140 --> 00:14:47,320
ఆ రకంగా ఏమి
గమనికలు, మాకు అలా అనుమతిస్తాయి

285
00:14:47,320 --> 00:14:51,320
వారు ఈ వాతావరణంలో చాలా తయారు
మేము రియాలిటీ లో ఆపరేట్ ఎలా వంటి మరింత.

286
00:14:51,320 --> 00:14:54,640
>> తద్వారా అన్ని కుడి ఏమిటి
ఒక పాయింటర్, యొక్క మాట్లాడటానికి వీలు ఉంది

287
00:14:54,640 --> 00:14:58,040
గమనికలు సి లో పని, మరియు ఎలా గురించి
ఎలా మేము వారితో పని ప్రారంభించవచ్చు.

288
00:14:58,040 --> 00:15:02,550
కాబట్టి ఒక చాలా సాధారణ పాయింటర్ ఉంది
సి లో నల్ పాయింటర్ అని.

289
00:15:02,550 --> 00:15:04,830
ఏమీ నల్ పాయింటర్ పాయింట్లు.

290
00:15:04,830 --> 00:15:08,310
అంతే వంటి ఈ బహుశా తెలుస్తోంది
నిజానికి ఒక చాలా ఉపయోగకరంగా విషయం

291
00:15:08,310 --> 00:15:10,500
కానీ మేము ఒక చూస్తారు వంటి
తర్వాత కొద్దిగా, నిజానికి

292
00:15:10,500 --> 00:15:15,410
ఈ నల్ పాయింటర్ ఉందని
నిజానికి నిజంగా ఉపయోగపడుట చేయవచ్చు.

293
00:15:15,410 --> 00:15:19,090
మరియు మీరు ఒక పాయింటర్ సృష్టించడానికి చేసినప్పుడు, మరియు
మీరు దాని విలువ immediately- సెట్ లేదు

294
00:15:19,090 --> 00:15:21,060
సెట్ ఒక ఉదాహరణ
దాని విలువ వెంటనే

295
00:15:21,060 --> 00:15:25,401
తిరిగి జంట స్లయిడ్లను ఉంటుంది
నేను PK & క్ను సమానం చెప్పబడిన

296
00:15:25,401 --> 00:15:28,740
PK వంటి, k యొక్క చిరునామా గెట్స్
మేము అర్థం ఏమి చూస్తారు

297
00:15:28,740 --> 00:15:32,990
మేము ఆ కోడ్ ఎలా చూస్తారు shortly-
మేము ఏదో దాని విలువ సెట్ లేకపోతే

298
00:15:32,990 --> 00:15:35,380
వెంటనే అర్ధవంతమైన
మీరు ఎల్లప్పుడూ తప్పక

299
00:15:35,380 --> 00:15:37,480
శూన్యం సూచించడానికి మీ పాయింటర్ సెట్.

300
00:15:37,480 --> 00:15:40,260
మీరు ఏమీ సూచించడానికి సెట్ చేయాలి.

301
00:15:40,260 --> 00:15:43,614
>> కంటే విభిన్నమైనది
అది అంతే విలువ వదిలి

302
00:15:43,614 --> 00:15:45,530
ఆపై ఒక ప్రకటించుకున్నారు
పాయింటర్ మరియు కేవలం ఊహిస్తూ

303
00:15:45,530 --> 00:15:48,042
ఆ అరుదుగా నిజం ఎందుకంటే అది శూన్య.

304
00:15:48,042 --> 00:15:50,000
మీరు ఎల్లప్పుడూ సెట్ ఉండాలి
ఒక పాయింటర్ విలువ

305
00:15:50,000 --> 00:15:55,690
మీరు దాని విలువ సెట్ లేకపోతే శూన్యం
వెంటనే అర్ధవంతమైన ఏదో.

306
00:15:55,690 --> 00:15:59,090
మీరు తనిఖీ చేయవచ్చు ఒక పాయింటర్ యొక్క విలువను లేదో
సమానత్వం ఆపరేటర్లు ఉపయోగించి శూన్య

307
00:15:59,090 --> 00:16:05,450
(==), కేవలం మీరు ఏ పూర్ణాంక సరిపోల్చండి ఇష్టం
విలువలు లేదా వ్యక్తిత్వ విలువలను ఉపయోగించి (==)

308
00:16:05,450 --> 00:16:06,320
అలాగే.

309
00:16:06,320 --> 00:16:10,994
ఇది స్థిరంగా ఒక ప్రత్యేక విధమైన
మీరు పరీక్షించడానికి ఉపయోగించే విలువ.

310
00:16:10,994 --> 00:16:13,160
కాబట్టి ఒక చాలా సాధారణ ఉంది
పాయింటర్ శూన్య పాయింటర్.

311
00:16:13,160 --> 00:16:15,320
మరో మార్గం సృష్టించడానికి
ఒక పాయింటర్ సేకరించేందుకు ఉంది

312
00:16:15,320 --> 00:16:18,240
ఒక వేరియబుల్ చిరునామా
మీరు ఇప్పటికే సృష్టిస్తే,

313
00:16:18,240 --> 00:16:22,330
మరియు మీరు & ఈ ఉపయోగించి
ఆపరేటర్లు చిరునామా వెలికితీత.

314
00:16:22,330 --> 00:16:26,720
ఇది మేము ఇప్పటికే గతంలో చూసిన
మొదటి చిత్రంలో ఉదాహరణలో నేను చూపించాడు.

315
00:16:26,720 --> 00:16:31,450
X మేము చేసిన ఒక వేరియబుల్ చేస్తే
ఇప్పటికే రకం పూర్ణాంకం యొక్క రూపొందించినవారు,

316
00:16:31,450 --> 00:16:35,110
ఆపై & x పూర్ణాంకం ఒక పాయింటర్ ఉంది.

317
00:16:35,110 --> 00:16:39,810
& x IS- ఏ, & సేకరించేందుకు మాత్రం గుర్తుంచుకోండి
కుడివైపు విషయం యొక్క చిరునామా.

318
00:16:39,810 --> 00:16:45,350
మరియు ఒక పాయింటర్ కేవలం ఒక చిరునామా ఉంది నుండి,
కంటే & x పూర్ణాంకం ఒక పాయింటర్ ఉంది

319
00:16:45,350 --> 00:16:48,560
దీని విలువ ఉన్న మెమరీలో x జీవితాలను ఉంది.

320
00:16:48,560 --> 00:16:50,460
ఇది x యొక్క చిరునామా ఉంది.

321
00:16:50,460 --> 00:16:53,296
సో & x x యొక్క చిరునామా.

322
00:16:53,296 --> 00:16:55,670
యొక్క ఈ ఒక అడుగు తీసుకుందాం
మరింత మరియు ఏదో కనెక్ట్

323
00:16:55,670 --> 00:16:58,380
నేను ఒక మునుపటి వీడియో లో పేర్కొన్నట్లు.

324
00:16:58,380 --> 00:17:06,730
చేరే సమయం డబుల్స్ ఒక అర్రే అప్పుడు, ఉంటే
& చేరే చదరపు బ్రాకెట్ నేను ఒక పాయింటర్ ఉంది

325
00:17:06,730 --> 00:17:08,109
డబుల్.

326
00:17:08,109 --> 00:17:08,970
అలాగే.

327
00:17:08,970 --> 00:17:12,160
నేను ఉంటే చదరపు బ్రాకెట్ చేరే
చేరే సమయం, డబుల్స్ వ్యూహం

328
00:17:12,160 --> 00:17:19,069
అప్పుడు నేను చదరపు బ్రాకెట్ చేరే
ఆ శ్రేణి యొక్క i- వ మూలకంగా,

329
00:17:19,069 --> 00:17:29,270
మరియు & చదరపు బ్రాకెట్ చేరే సమయం నేను ఎక్కడ ఉంది
మెమరీ చేరే నేను-వ మూలకం ఉంది.

330
00:17:29,270 --> 00:17:31,790
>> సో చిక్కుముడి ఇక్కడ ఏముంది?

331
00:17:31,790 --> 00:17:34,570
ఒక శ్రేణుల పేరు, సూత్రప్రాయంగా
ఈ మొత్తం విషయం,

332
00:17:34,570 --> 00:17:39,290
వ్యూహం యొక్క పేరు అని ఉంది
నిజానికి కూడా ఒక పాయింటర్.

333
00:17:39,290 --> 00:17:41,170
మీరు పని చేసిన
అన్ని పాటు గమనికలు

334
00:17:41,170 --> 00:17:45,290
మీరు ఒక అర్రే ఉపయోగిస్తారు చేసిన ప్రతిసారీ.

335
00:17:45,290 --> 00:17:49,090
ఉదాహరణకు నుండి గుర్తు
వేరియబుల్ దర్శినిలో,

336
00:17:49,090 --> 00:17:53,420
నేను ప్రస్తుత వీడియో చివరిలో
మేము ఒక ఫంక్షన్ కలిగి ఉన్న ఒక ఉదాహరణ

337
00:17:53,420 --> 00:17:56,890
అని సెట్ Int మరియు
ఫంక్షన్ సెట్ వ్యూహం అని.

338
00:17:56,890 --> 00:18:00,490
మరియు మీ సవాలు గుర్తించడానికి
లేదో, లేదా ఏ

339
00:18:00,490 --> 00:18:03,220
మేము ముద్రించిన ఆ విలువలు
ఫంక్షన్ ముగింపు,

340
00:18:03,220 --> 00:18:05,960
ప్రధాన కార్యక్రమం చివరిలో.

341
00:18:05,960 --> 00:18:08,740
>> మీరు ఉదాహరణకు నుండి గుర్తు ఉంటే
లేదా మీరు వీడియో చూసిన ఉంటే,

342
00:18:08,740 --> 00:18:13,080
మీరు కాల్ నిన్నూ ఉన్నప్పుడు తెలుసు
సెట్ పూర్ణాంకానికి సమర్థవంతంగా ఏమీ లేదు.

343
00:18:13,080 --> 00:18:16,390
అయితే కాల్ శ్రేణి చేస్తుంది సెట్.

344
00:18:16,390 --> 00:18:19,280
నేను విధమైన ఎందుకు పైగా గ్లాస్ద్
ఆ సమయంలో కేసు.

345
00:18:19,280 --> 00:18:22,363
నేను బాగా, అది ఒక అర్రే వార్తలు అన్నారు
ప్రత్యేక, మీకు తెలిసిన, ఒక కారణం ఉంది.

346
00:18:22,363 --> 00:18:25,020
కారణం వ్యూహం యొక్క ఉంటుంది
పేరు, నిజంగా కేవలం ఒక పాయింటర్ ఉంది

347
00:18:25,020 --> 00:18:28,740
మరియు ఈ ప్రత్యేక ఉంది
చదరపు బ్రాకెట్ సింటాక్స్ ఆ

348
00:18:28,740 --> 00:18:30,510
పని విషయాలు చాలా NICER చేస్తుంది.

349
00:18:30,510 --> 00:18:34,410
మరియు వారు ఒక ఆలోచన చేయడానికి
చాలా తక్కువ భయపెట్టడం గణితానికి,

350
00:18:34,410 --> 00:18:36,800
వారు విధమైన ఉన్నాము ఎందుకు ఆ
ఆ విధంగా సమర్పించారు.

351
00:18:36,800 --> 00:18:38,600
కానీ నిజంగా శ్రేణుల కేవలం గమనికలు ఉన్నాయి.

352
00:18:38,600 --> 00:18:41,580
ఆ ఎందుకు మేము
, అర్రే ఒక మార్పు చేసిన

353
00:18:41,580 --> 00:18:44,880
మేము ఒక ప్రామాణికంగా వ్యూహం ప్రవేశపెట్టినప్పుడు
ఒక ఫంక్షన్ లేదా ఒక వాదన గా

354
00:18:44,880 --> 00:18:50,110
యెరే యొక్క ఒక ఫంక్షన్, విషయాల
వాస్తవానికి రెండు callee లో మార్చబడింది

355
00:18:50,110 --> 00:18:51,160
మరియు కాలర్ లో.

356
00:18:51,160 --> 00:18:55,846
ప్రతి ఇతర రకమైన ఏ
మేము చూసిన వేరియబుల్ ఉండదు.

357
00:18:55,846 --> 00:18:58,970
కాబట్టి ఆ ఉంచాలని కేవలం ఏదో
మీరు గమనికలు పని చేసినప్పుడు చూసుకొని,

358
00:18:58,970 --> 00:19:01,610
అని ఒక పేరు
శ్రేణి అసలైన పాయింటర్

359
00:19:01,610 --> 00:19:04,750
ఆ శ్రేణి యొక్క మొదటి మూలకం.

360
00:19:04,750 --> 00:19:08,930
>> OK కాబట్టి ఇప్పుడు మేము ఈ కలిగి
వాస్తవాలు, కుడి, కొనసాగించడాన్ని వీలు.

361
00:19:08,930 --> 00:19:11,370
ఎందుకు మనం శ్రద్ధ లేదు
ఇక్కడ ఏదో నివసిస్తున్నారు.

362
00:19:11,370 --> 00:19:14,120
నేను అన్నాడు సరే వలె, ఇది అందంగా అనిపిస్తుంది
ఏదో జీవించింది తెలిసిన ఉపయోగకరంగా

363
00:19:14,120 --> 00:19:17,240
కాబట్టి మీరు అక్కడ వెళ్ళి మార్చవచ్చు.

364
00:19:17,240 --> 00:19:19,390
అది పని మరియు నిజానికి
విషయం మీకు

365
00:19:19,390 --> 00:19:23,710
ఆ వేరియబుల్ ప్రభావానికి చేయాలనుకుంటున్నారా,
మరియు అది కొన్ని కాపీని ప్రభావాన్ని తీసుకోవు.

366
00:19:23,710 --> 00:19:26,150
ఈ dereferencing అంటారు.

367
00:19:26,150 --> 00:19:28,690
మేము సూచన వెళ్లి
మేము అక్కడ విలువ మారుతుంది.

368
00:19:28,690 --> 00:19:32,660
మేము ఒక పాయింటర్ కలిగి మరియు ఉంటే ఇది అని
PC, మరియు ఇది ఒక పాత్ర చూపాడు,

369
00:19:32,660 --> 00:19:40,610
అప్పుడు మేము * PC మరియు * PC చెప్పగలను
మేము వెళ్ళి ఉంటే మేము పొందుతారు ఏమి యొక్క పేరు

370
00:19:40,610 --> 00:19:42,910
చిరునామా శాతానికి.

371
00:19:42,910 --> 00:19:47,860
మనం అక్కడ పొందుతారు ఒక పాత్ర మరియు
* PC మేము వద్ద డేటా చూడండి ఎలా ఉంది

372
00:19:47,860 --> 00:19:48,880
నగర.

373
00:19:48,880 --> 00:19:54,150
కాబట్టి మేము వంటి ఏదో చెప్పగల్గినవి
* PC = D లేదా అలాంటిదే,

374
00:19:54,150 --> 00:19:59,280
మరియు ఆ అర్థం సంసార
, మెమరీ చిరునామా PC వద్ద ఉంది

375
00:19:59,280 --> 00:20:07,040
ఏ పాత్ర గతంలో
మేము PC = D * అనవచ్చు ఉంటే అక్కడ, ఇప్పుడు D ఉంది.

376
00:20:07,040 --> 00:20:10,090
>> ఇక్కడ మేము మళ్ళీ వెళ్ళి
కొన్ని విచిత్రమైన సి stuff, కుడి.

377
00:20:10,090 --> 00:20:14,560
కాబట్టి మేము గా గతంలో * చూసిన
ఏదో డేటా రకం భాగంగా,

378
00:20:14,560 --> 00:20:17,160
మరియు ఇప్పుడు అది ఉపయోగిస్తారు చేయబడిన
కొంచెం సందర్భం

379
00:20:17,160 --> 00:20:19,605
ఒక ప్రదేశంలోని డేటా యాక్సెస్.

380
00:20:19,605 --> 00:20:22,480
నేను కొద్దిగా గందరగోళంగా తెలిసిన మరియు
వాస్తవానికి ఈ మొత్తం భాగంగా

381
00:20:22,480 --> 00:20:25,740
, ఎందుకు గమనికలు ఈ పురాణాల కలిగి
వాటిని చుట్టూ కాబట్టి క్లిష్టమైన గా,

382
00:20:25,740 --> 00:20:28,250
నిజాయితీగా, ఒక సింటాక్స్ సమస్య యొక్క రకం.

383
00:20:28,250 --> 00:20:31,810
కానీ * రెండు సందర్భాల్లో ఉపయోగిస్తారు,
రెండు రకం పేరు భాగంగా,

384
00:20:31,810 --> 00:20:34,100
మరియు మేము కొద్దిగా చూస్తారు
చాలా తరువాత ఏదో.

385
00:20:34,100 --> 00:20:36,490
మరియు ప్రస్తుతం ఉంది
dereference ఆపరేటర్లు.

386
00:20:36,490 --> 00:20:38,760
కాబట్టి ఇది సూచన వెళుతుంది,
అది డేటా యాక్సెస్

387
00:20:38,760 --> 00:20:43,000
పాయింటర్ స్థానాన్ని, మరియు
మీరు ఇష్టానికి వద్ద సర్దుబాటు అనుమతిస్తుంది.

388
00:20:43,000 --> 00:20:45,900
>> ఇప్పుడు ఈ చాలా పోలి ఉంటుంది
మీ పొరుగు సందర్శించడం, కుడి.

389
00:20:45,900 --> 00:20:48,710
మీకు తెలిస్తే మీ
పొరుగు మీరు ఉన్నాము, నివసిస్తుంది

390
00:20:48,710 --> 00:20:50,730
మీ పొరుగు సమావేశంలో లేదు.

391
00:20:50,730 --> 00:20:53,510
మీరు ఏమి తెలుసు
వారు నివసించే తెలుసు,

392
00:20:53,510 --> 00:20:56,870
కానీ ఆ ద్వారా అర్థం కాదు
ఆ జ్ఞానం యొక్క ధర్మం

393
00:20:56,870 --> 00:20:59,170
మీరు వాటిని పరిచయాత్మకంగా.

394
00:20:59,170 --> 00:21:01,920
మీరు వారితో చేయాలనుకుంటే,
మీరు వారి ఇంటికి వెళ్ళాలి

395
00:21:01,920 --> 00:21:03,760
మీరు వారు ఎక్కడ నివసిస్తున్నారు వెళ్ళాలి.

396
00:21:03,760 --> 00:21:07,440
మరియు మీరు అలా ఒకసారి,
అప్పుడు మీరు వ్యవహరించవచ్చు

397
00:21:07,440 --> 00:21:09,420
వారితో మీకు కావలసిన ఇష్టం.

398
00:21:09,420 --> 00:21:12,730
మరియు అలాగే చరరాశులు తో,
మీరు వారి చిరునామాకు వెళ్లాలి

399
00:21:12,730 --> 00:21:15,320
మీరు వాటిని సంకర్షణ అనుకుంటే,
మీరు కేవలం చిరునామా తెలియదు.

400
00:21:15,320 --> 00:21:21,495
మరియు మీరు చిరునామాకు వెళ్ళి మార్గం
* dereference ఆపరేటర్లు ఉపయోగించడానికి.

401
00:21:21,495 --> 00:21:23,620
మీరు ఏమి ఆలోచిస్తాడు
మేము ప్రయత్నించండి మరియు dereference ఉంటే

402
00:21:23,620 --> 00:21:25,260
దీని విలువ ఒక పాయింటర్ శూన్య?

403
00:21:25,260 --> 00:21:28,470
శూన్య గుర్తుచేసుకున్నారు
పాయింటర్ ఏమీ చూపాడు.

404
00:21:28,470 --> 00:21:34,110
మీరు ప్రయత్నించండి మరియు dereference చేస్తే
ఏమీ ఒక చిరునామా ఏమీ వెళ్ళండి లేదా,

405
00:21:34,110 --> 00:21:36,800
మీరు ఏమి ఆలోచిస్తాడు?

406
00:21:36,800 --> 00:21:39,630
Well మీరు నిమ్మన సెగ్మెంటేషన్
తప్పు, మీరు కుడి భావించాలి.

407
00:21:39,630 --> 00:21:41,390
మీరు ప్రయత్నించండి మరియు dereference ఉంటే
ఒక నల్ పాయింటర్,

408
00:21:41,390 --> 00:21:43,140
మీరు సెగ్మెంటేషన్ గురవుతాయి
తప్పు. కానీ వేచి,

409
00:21:43,140 --> 00:21:45,820
నేను మీరు చెప్పండి లేదు
మీరు వెళుతున్న కాకపోతే

410
00:21:45,820 --> 00:21:49,220
మీ విలువ సెట్ మీ
అర్ధవంతమైన ఏదో ఒక పాయింటర్

411
00:21:49,220 --> 00:21:51,000
మీరు శూన్యం సెట్ ఉండాలి?

412
00:21:51,000 --> 00:21:55,290
నేను చదివింది మరియు నిజానికి సెగ్మెంటేషన్
లోపంగా ఒక మంచి ప్రవర్తన యొక్క రకం.

413
00:21:55,290 --> 00:21:58,680
>> మీరు ఎప్పుడైనా ఒక వేరియబుల్ డిక్లేర్డ్ మరియు కలవారు
వెంటనే దాని విలువ కేటాయించిన?

414
00:21:58,680 --> 00:22:02,680
సో మీరు కేవలం Int x సే; మీరు చేయలేని
వాస్తవానికి ఏదైనా దానిని కేటాయించవచ్చు

415
00:22:02,680 --> 00:22:05,340
మరియు తర్వాత మీ కోడ్ లో,
మీరు, x యొక్క విలువ ముద్రించాలా

416
00:22:05,340 --> 00:22:07,650
ఇప్పటికీ కలిగి
ఏదైనా దానిని అప్పగించింది.

417
00:22:07,650 --> 00:22:10,370
తరచుగా మీరు పొందుతారు
సున్నా, కానీ కొన్నిసార్లు మీరు

418
00:22:10,370 --> 00:22:15,000
కొన్ని యాదృచ్ఛిక సంఖ్యలో పొందండి, మరియు ఉండవచ్చు
మీరు ఎక్కడ నుండి వచ్చాయి సంఖ్య ఆలోచన ఉంది.

419
00:22:15,000 --> 00:22:16,750
అదేవిధంగా విషయాలు చెయ్యవచ్చు
గమనికలు తో జరిగే.

420
00:22:16,750 --> 00:22:20,110
మీరు ఒక పాయింటర్ డిక్లేర్ చేసినప్పుడు
Int * ఉదాహరణకు PK,

421
00:22:20,110 --> 00:22:23,490
మరియు మీరు, ఒక విలువ దానిని కేటాయించి లేదు
మీరు మెమరీ కోసం నాలుగు బైట్లు పొందండి.

422
00:22:23,490 --> 00:22:25,950
ఏది నాలుగు బైట్లు
వ్యవస్థ మెమరీ చెయ్యవచ్చు

423
00:22:25,950 --> 00:22:28,970
కొన్ని అర్ధవంతమైన విలువ కలిగి కనుగొనవచ్చు.

424
00:22:28,970 --> 00:22:31,760
మరియు కూడా ఉండవచ్చు
ఇప్పటికే అక్కడ ఏదో

425
00:22:31,760 --> 00:22:34,190
మరొక అవసరమైన ఇకపై
ఫంక్షన్, మీరు కేవలం కాబట్టి

426
00:22:34,190 --> 00:22:35,900
సంసార డేటా ఉంది.

427
00:22:35,900 --> 00:22:40,570
>> ఏం మీరు dereference చేయడానికి ప్రయత్నించాడు ఉంటే
మీరు ఉన్నాయి don't- కొన్ని చిరునామా

428
00:22:40,570 --> 00:22:43,410
ఇప్పటికే బైట్లు సమాచారాలను
అక్కడ, మీ పాయింటర్ ఇప్పుడు.

429
00:22:43,410 --> 00:22:47,470
మీరు ప్రయత్నించండి ఉంటే మరియు ఆ పాయింటర్ dereference
మీరు కొన్ని మెమరీ ఇబ్బందులను ఉండవచ్చు

430
00:22:47,470 --> 00:22:49,390
మీరు ఉద్దేశం లేదని
అన్ని ఆడకూడదని.

431
00:22:49,390 --> 00:22:51,639
మరియు నిజానికి మీరు చేయగల
నిజంగా వినాశకరమైన ఏదో

432
00:22:51,639 --> 00:22:54,880
వంటి మరొక ప్రోగ్రామ్ బ్రేక్,
లేదా మరొక ఫంక్షన్ బ్రేక్

433
00:22:54,880 --> 00:22:58,289
లేదా హానికరమైన ఏదో ఒకటి
మీరు అన్ని వద్ద చేయాలని ఉద్దేశ్యము లేదు.

434
00:22:58,289 --> 00:23:00,080
ఎందుకు కాబట్టి ఆ
నిజానికి ఒక మంచి ఆలోచన

435
00:23:00,080 --> 00:23:04,030
మీరు ఉంటే శూన్యం మీ గమనికలు సెట్
అర్ధవంతమైన ఏదో వారిని లేదు.

436
00:23:04,030 --> 00:23:06,760
ఇది బహుశా మంచి పని
మీ ప్రోగ్రామ్ రోజు చివరిలో

437
00:23:06,760 --> 00:23:09,840
దీన్ని తర్వాత క్రాష్
ఏదో ఆ మరలు అప్

438
00:23:09,840 --> 00:23:12,400
మరొక ప్రోగ్రామ్ లేదా మరొక ఫంక్షన్.

439
00:23:12,400 --> 00:23:15,207
ఆ ప్రవర్తన కూడా బహుశా
కేవలం క్రాష్ కంటే తక్కువ ఆదర్శ.

440
00:23:15,207 --> 00:23:17,040
ఎందుకు కాబట్టి ఆ
నిజానికి ఒక మంచి అలవాటు

441
00:23:17,040 --> 00:23:20,920
మీ గమనికలు సెట్ పొందడానికి
మీరు వాటిని సెట్ లేకపోతే శూన్యం

442
00:23:20,920 --> 00:23:24,540
ఒక అర్ధవంతమైన విలువ
మీకు తెలిసిన వెంటనే, క్రింది

443
00:23:24,540 --> 00:23:27,260
మరియు మీరు dereference సురక్షితంగా.

444
00:23:27,260 --> 00:23:32,240
>> కాబట్టి యొక్క ఇప్పుడు తిరిగి రావాలి చూడాల్సిన
పరిస్థితి యొక్క మొత్తం సింటాక్స్.

445
00:23:32,240 --> 00:23:37,400
నేను Int * p చెప్పుకోవాలంటే ;, నేను ఏమి చేసారు?

446
00:23:37,400 --> 00:23:38,530
నేను చేసిన ఈ ఉంది.

447
00:23:38,530 --> 00:23:43,290
నేను p విలువ ఒక చిరునామా ఉంది తెలుసు
అన్ని గమనికలు కేవలం ఎందుకంటే

448
00:23:43,290 --> 00:23:44,660
చిరునామాలు.

449
00:23:44,660 --> 00:23:47,750
నేను dereference p
* ఆపరేటర్లు ఉపయోగించి.

450
00:23:47,750 --> 00:23:51,250
చాలా ఇక్కడ ఈ సందర్భంలో,
టాప్ * రకం భాగం గుర్తు.

451
00:23:51,250 --> 00:23:53,510
Int * డేటా రకం.

452
00:23:53,510 --> 00:23:56,150
కానీ నేను dereference చెయ్యవచ్చు
* ఆపరేటర్లు ఉపయోగించి p,

453
00:23:56,150 --> 00:24:01,897
మరియు నేను అలా ఉంటే, నేను ఆ చిరునామాకు వెళ్ళి ఉంటే,
నేను ఆ చిరునామా వద్ద ఏమి కనుగొంటారు?

454
00:24:01,897 --> 00:24:02,855
నేను ఒక పూర్ణాంకం కనుగొంటారు.

455
00:24:02,855 --> 00:24:05,910
కాబట్టి Int * p రప్పించింది
మాట్లాడుతూ, p ఒక చిరునామా ఉంది.

456
00:24:05,910 --> 00:24:09,500
నేను p dereference మరియు ఉంటే
నేను, నేను ఒక పూర్ణాంకం కనుగొంటారు

457
00:24:09,500 --> 00:24:11,920
ఆ మెమొరీ లోకేషన్ వద్ద.

458
00:24:11,920 --> 00:24:14,260
>> సరే నేను మరొక లేదని తెలిపారు
నక్షత్రాలు తో బాధించే విషయం

459
00:24:14,260 --> 00:24:17,060
మరియు ఇక్కడ పేరు ఆ
నక్షత్రాలు తో బాధించే విషయం.

460
00:24:17,060 --> 00:24:21,640
మీరు ఎప్పుడైనా ప్రకటించాలని ప్రయత్నించారు
ఒకే రకమైన బహుళ వేరియబుల్స్

461
00:24:21,640 --> 00:24:24,409
కోడ్ యొక్క అదే లైన్ లో?

462
00:24:24,409 --> 00:24:27,700
కాబట్టి రెండవ కోసం, ఆ లైన్ నటిస్తారు
నేను నిజానికి ఆకుపచ్చ ఉన్నాయి కోడ్

463
00:24:27,700 --> 00:24:29,366
అక్కడ కాదు మరియు అది కేవలం Int x, y, z చెప్పారు ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
ఏం అలా నిజంగా సృష్టించడానికి ఉంది
మీరు మూడు పూర్ణాంక వేరియబుల్,

466
00:24:34,550 --> 00:24:36,930
ఒకటి అని x, అని ఒక
y, మరియు ఒక z అని.

467
00:24:36,930 --> 00:24:41,510
అది లేకుండా దీన్ని ఒక మార్గం
మూడు లైన్లలో విడిపోయినట్లు కలిగి.

468
00:24:41,510 --> 00:24:43,890
>> నక్షత్రాలు చోటే ఇక్కడ
అయితే మళ్ళీ బాధించే,

469
00:24:43,890 --> 00:24:49,200
* వాస్తవానికి భాగం ఎందుకంటే
రెండు రకం పేరు మరియు భాగంగా

470
00:24:49,200 --> 00:24:50,320
వేరియబుల్ పేరు.

471
00:24:50,320 --> 00:24:56,430
కాబట్టి నేను చెప్పుకోవాలంటే Int * px, PY, PZ, నేను
నిజంగా పొందండి పూర్ణాంకం ఒక పాయింటర్ ఉంది

472
00:24:56,430 --> 00:25:01,650
px మరియు రెండు పూర్ణాంకాల, PY మరియు PZ అని.

473
00:25:01,650 --> 00:25:04,950
మరియు ఆ బహుశా లేదు ఏమిటి
మేము మంచి కాదు, మీరు.

474
00:25:04,950 --> 00:25:09,290
>> నేను బహుళ గమనికలు సృష్టించడానికి కావాలా సో
అదే లైన్ లో, ఒకే రకమైన,

475
00:25:09,290 --> 00:25:12,140
నేను నిజానికి అవసరం ఏమిటి మరియు నక్షత్రాలు,
అలా * పీబీ, * శాతం, Int * pa చెప్పాలి.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
ఇప్పుడు కేవలం ఆ చెప్పాడు
మరియు ఇప్పుడు, మీరు ఈ చెప్పడం

478
00:25:20,300 --> 00:25:22,170
మీరు బహుశా దీన్ని ఎప్పటికీ.

479
00:25:22,170 --> 00:25:25,170
మరియు అది, నిజాయితీగా బహుశా ఒక మంచి విషయం
మీరు అనుకోకుండా కావచ్చు ఎందుకంటే

480
00:25:25,170 --> 00:25:26,544
ఒక స్టార్, అలాంటిదే వదిలేస్తారు.

481
00:25:26,544 --> 00:25:29,290
ఇది బహుశా ప్రకటించాలని బహుశా ఉత్తమ అనిపిస్తుంది
వ్యక్తిగత పంక్తులు గమనికలు,

482
00:25:29,290 --> 00:25:31,373
కానీ అది కేవలం మరొక ఒకటి
ఆ బాధించే సింటెక్స్

483
00:25:31,373 --> 00:25:35,310
చేసే నక్షత్రాలు తో విషయాలు
పని చాలా కష్టం గమనికలు.

484
00:25:35,310 --> 00:25:39,480
ఇది కేవలం ఈ వాక్యనిర్మాణ ఎందుకంటే
మెస్ మీరు ద్వారా పని ఉంటుంది.

485
00:25:39,480 --> 00:25:41,600
సాధన తో అది
నిజంగా రెండవ ప్రకృతి అవుతుంది.

486
00:25:41,600 --> 00:25:45,410
నేను ఇప్పటికీ అది పొరపాట్లను చేస్తాయి
10 సంవత్సరాలు ప్రోగ్రామింగ్ తర్వాత,

487
00:25:45,410 --> 00:25:49,630
ఏదో జరిగితే కనుక అసంతృప్తి వ్యక్తం లేదు
ఇది, మీరు ఒక్క అందంగా సాధారణ వార్తలు.

488
00:25:49,630 --> 00:25:52,850
ఇది రకమైన నిజంగా
సింటెక్స్ ఒక దోషం.

489
00:25:52,850 --> 00:25:54,900
>> OK కాబట్టి నేను రకమైన వాగ్దానం
మేము సందర్శించండి అని

490
00:25:54,900 --> 00:25:59,370
ఎలా పెద్ద భావన ఒక స్ట్రింగ్.

491
00:25:59,370 --> 00:26:02,750
సరే నేను ఒక మీరు చెప్పారు ఉంటే
స్ట్రింగ్, మేము రకమైన నిజంగా చేసిన

492
00:26:02,750 --> 00:26:04,140
మీరు మొత్తం సమయం అబద్ధం జరిగింది.

493
00:26:04,140 --> 00:26:06,181
పిలుపువచ్చింది డేటా రకం ఉంది
స్ట్రింగ్, మరియు నిజానికి నేను

494
00:26:06,181 --> 00:26:09,730
ఒకటి ఈ పేర్కొన్నారు మా
డేటా రకాల ప్రారంభ వీడియోలు,

495
00:26:09,730 --> 00:26:13,820
ఆ స్ట్రింగ్ ఒక డేటా రకం అని
cs50.h. లో మీ కోసం సృష్టించబడింది

496
00:26:13,820 --> 00:26:17,050
మీరు # చేర్చాలనుకుంటే కలిగి
ఇది ఉపయోగించడానికి క్రమంలో cs50.h.

497
00:26:17,050 --> 00:26:19,250
>> మంచి స్ట్రింగ్ కేవలం నిజంగా
ఏదో ఒక అలియాస్

498
00:26:19,250 --> 00:26:23,600
, చార్ * అనే
ఒక పాత్ర పాయింటర్.

499
00:26:23,600 --> 00:26:26,010
బాగా గమనికలు, రీకాల్,
కేవలం చిరునామాలు.

500
00:26:26,010 --> 00:26:28,780
కాబట్టి పరిమాణం ఏమిటి
ఒక స్ట్రింగ్ యొక్క బైట్లు?

501
00:26:28,780 --> 00:26:29,796
బాగా నాలుగు లేదా ఎనిమిది.

502
00:26:29,796 --> 00:26:32,170
మరియు నేను కారణం నాలుగు లేదా
ఎనిమిది ఎందుకంటే నిజానికి

503
00:26:32,170 --> 00:26:36,730
మీరు ఉపయోగిస్తున్నట్లయితే, వ్యవస్థ మీద ఆధారపడి ఉంటుంది
CS50 ide, చార్ * ఒక చార్ యొక్క పరిమాణం

504
00:26:36,730 --> 00:26:39,340
* ఇది ఒక 64-bit వ్యవస్థ, ఎనిమిది ఉంది.

505
00:26:39,340 --> 00:26:43,850
మెమరీలో ప్రతి చిరునామా 64 బిట్స్ పొడవుగా ఉంది.

506
00:26:43,850 --> 00:26:48,270
మీరు CS50 ఉపకరణం ఉపయోగించి ఉంటే
లేదా ఏ 32-bit మిషన్ ఉపయోగించి,

507
00:26:48,270 --> 00:26:51,640
మరియు మీరు ఆ పదం 32-బిట్ విన్న చేసిన
యంత్రం, ఒక 32-bit మిషన్ ఏమిటి?

508
00:26:51,640 --> 00:26:56,090
బాగా కేవలం ప్రతి అర్థం
మెమరీలో చిరునామా 32 బిట్స్ పొడవుగా ఉంది.

509
00:26:56,090 --> 00:26:59,140
కాబట్టి 32 బిట్స్ నాలుగు బైట్లు.

510
00:26:59,140 --> 00:27:02,710
సో ఒక చార్ * నాలుగు లేదా ఎనిమిది
మీ సిస్టం మీద ఆధారపడి బైట్లు.

511
00:27:02,710 --> 00:27:06,100
నిజానికి ఏ డేటా రకాలు,
మరియు ఏ డేటా ఒక పాయింటర్

512
00:27:06,100 --> 00:27:12,030
అన్ని గమనికలు కేవలం ఎందుకంటే, టైప్
చిరునామాలు, నాలుగు లేదా ఎనిమిది బైట్లు ఉంటాయి.

513
00:27:12,030 --> 00:27:14,030
కాబట్టి యొక్క ఈ సందర్శించండి వీలు
రేఖాచిత్రం మరియు యొక్క నిర్ధారించారు వీలు

514
00:27:14,030 --> 00:27:18,130
ఇక్కడ కొద్దిగా వ్యాయామం ఈ వీడియో.

515
00:27:18,130 --> 00:27:21,600
ఇక్కడ మేము వదిలి రేఖాచిత్రం వార్తలు
వీడియో చాలా ప్రారంభంలో.

516
00:27:21,600 --> 00:27:23,110
నేను * PK = 35 చెప్పే చేస్తే ఇప్పుడు ఏమి జరుగుతుంది?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
కనుక ఇది * PK = 35, నేను చెప్పినప్పుడు అర్థం ఏమిటి?

519
00:27:30,530 --> 00:27:32,420
రెండవ తీసుకోండి.

520
00:27:32,420 --> 00:27:34,990
* PK.

521
00:27:34,990 --> 00:27:39,890
ఇక్కడ సందర్భం లో, * ఉంది
dereference ఆపరేటర్లు.

522
00:27:39,890 --> 00:27:42,110
సో ఉన్నప్పుడు dereference
ఆపరేటర్లు, ఉపయోగిస్తారు

523
00:27:42,110 --> 00:27:48,520
చిరునామాకు చూపారు మేము వెళ్ళి
PK ద్వారా, మరియు మేము కనుగొనగలిగితే ఏమి మార్చడానికి.

524
00:27:48,520 --> 00:27:55,270
కాబట్టి * PK = 35 సమర్థవంతంగా
చిత్రాన్ని ఈ చేస్తుంది.

525
00:27:55,270 --> 00:27:58,110
కనుక ఇది పదము ప్రాథమికంగా
యొక్క ఒకేలా k = 35 చెప్పాడు.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> ఇంకొకటి.

528
00:28:01,930 --> 00:28:05,510
నేను Int m చెబితే, నేను సృష్టించడానికి
m అనే కొత్త వేరియబుల్.

529
00:28:05,510 --> 00:28:08,260
ఒక కొత్త బాక్స్, ఇది ఒక ఆకుపచ్చ బాక్స్ ఎందుకంటే
అది ఒక పూర్ణాంకం పట్టుకోండి జరగబోతోంది,

530
00:28:08,260 --> 00:28:09,840
మరియు అది m లేబుల్.

531
00:28:09,840 --> 00:28:14,960
నేను చి = 4 చెబితే, నేను ఒక చాలు
ఆ పెట్టెలో పూర్ణాంక.

532
00:28:14,960 --> 00:28:20,290
సే PK = & M, ఎలా చేస్తుందో లేదో
ఈ చిత్రంలో మార్పు?

533
00:28:20,290 --> 00:28:28,760
PK = & M, మీరు ఏమి గుర్తు లేదు
& ఆపరేటర్లు చేస్తుంది లేదా అంటారు?

534
00:28:28,760 --> 00:28:34,430
ఆ & కొన్ని వేరియబుల్ పేరు గుర్తుంచుకో
ఒక వేరియబుల్ పేరు చిరునామా.

535
00:28:34,430 --> 00:28:38,740
కాబట్టి మనం చెబుతున్న ఉంది
PK మీటర్ల చిరునామా గెట్స్.

536
00:28:38,740 --> 00:28:42,010
మరియు అది ప్రభావవంతంగా ఏమి జరుగుతుంది
రేఖాచిత్రం ఇకపై పాయింట్లు PK ఉంది

537
00:28:42,010 --> 00:28:46,420
m, కానీ పాయింట్లు k కు.

538
00:28:46,420 --> 00:28:48,470
>> మళ్ళీ గమనికలు చాలా ఉన్నాయి
పని గమ్మత్తైన

539
00:28:48,470 --> 00:28:50,620
మరియు వారు చాలా పడుతుంది
ఆచరణలో, కానీ ఎందుకంటే

540
00:28:50,620 --> 00:28:54,150
మీరు అనుమతిస్తాయి వారి సామర్ధ్యం
విధులు మధ్య డేటా పాస్

541
00:28:54,150 --> 00:28:56,945
మరియు వాస్తవానికి ఆ కలిగి
మార్పులు ప్రభావం పడుతుంది,

542
00:28:56,945 --> 00:28:58,820
చుట్టూ మీ తల పొందడానికి
నిజంగా ముఖ్యం.

543
00:28:58,820 --> 00:29:02,590
ఇది బహుశా అత్యంత సంక్లిష్టమైనది
మేము CS50 లో చర్చించడానికి టాపిక్

544
00:29:02,590 --> 00:29:05,910
కానీ విలువ మీరు
గమనికలు ఉపయోగించి నుండి పొందండి

545
00:29:05,910 --> 00:29:09,200
ఇప్పటివరకు ఉపద్రవాలు అధిగమిస్తుంది
ఆ వాటిని తెలుసుకున్న నుండి వస్తాయి.

546
00:29:09,200 --> 00:29:12,690
నేను మీరు ఉత్తమ అనుకుంటున్నారా
అదృష్టం గమనికలు గురించి నేర్చుకోవడం.

547
00:29:12,690 --> 00:29:15,760
నేను డౌ లాయిడ్ ఉన్నాను, ఈ CS50 ఉంది.

548
00:29:15,760 --> 00:29:17,447