1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> SPEAKER 1: హాయ్ అందరూ.

3
00:00:05,680 --> 00:00:07,530
మేము ప్రారంభించడానికి వెళ్తున్నారు.

4
00:00:07,530 --> 00:00:09,330
నేను ప్రజలు ఇప్పటికీ వెళుతున్న భావిస్తున్నాము
వడపోత ఉండాలి.

5
00:00:09,330 --> 00:00:12,840
కానీ సమయం ఆసక్తి, మేము చాలా
సమయం ఇక్కడ నుంచి మీరు అబ్బాయిలు పొందండి

6
00:00:12,840 --> 00:00:14,110
మేము ఆరంభమవుతుంది చేస్తున్నారు.

7
00:00:14,110 --> 00:00:18,780
కాబట్టి CS50 క్విజ్ 0 సమీక్ష స్వాగతం.

8
00:00:18,780 --> 00:00:23,020
నెరవేరలేదు చేసిన మీరు ఆ కోసం
ఇంకా, మీరు బుధవారం ఒక ప్రశ్న కలిగి.

9
00:00:23,020 --> 00:00:25,700
హుర్రే.

10
00:00:25,700 --> 00:00:29,780
>> మీరు ఇంకా అధ్యయనం ప్రారంభించారు ఉండకపోతే లేదా
ఈ ఇంకా ఉందని గ్రహించారు లేదు,

11
00:00:29,780 --> 00:00:34,070
గత క్విజెస్ మరియు గురించి అన్ని సమాచారం
మీ క్విజ్ cs50.net/quizzes ఉన్నాయి.

12
00:00:34,070 --> 00:00:38,090
కొన్ని చాలా మంచి విషయాలు అక్కడ ఉంది,
10 గత నుండి గత క్విజెస్

13
00:00:38,090 --> 00:00:43,760
సంవత్సరాల అలాగే సమాచారం
ఈ క్విజ్ మరియు విషయాలు గురించి

14
00:00:43,760 --> 00:00:46,250
ఆ కవర్ చేస్తుంది.

15
00:00:46,250 --> 00:00:48,980
కాబట్టి యొక్క ప్రారంభించడానికి అనుమతిస్తాయి.

16
00:00:48,980 --> 00:00:54,240
>> కాబట్టి మీరు అబ్బాయిలు, మొదటి గుర్తు ఉండవచ్చు
తరగతి దావీదు రోజు ఆ దీపాలు న వచ్చింది.

17
00:00:54,240 --> 00:00:59,650
కాబట్టి ముఖ్యంగా, ప్రతిదీ వెళ్ళే
ఒక కంప్యూటర్ హుడ్ కింద న

18
00:00:59,650 --> 00:01:00,860
బైనరీ జరుగుతుంది.

19
00:01:00,860 --> 00:01:04,080
బైనరీ అది ధ్వనులు ఏమి అర్థం
వంటి, 0 మరియు 1 యొక్క.

20
00:01:04,080 --> 00:01:09,290
ఇది రెండు విలువలు కలిగి
ప్రాతినిధ్యం చేయవచ్చు.

21
00:01:09,290 --> 00:01:14,675
>> కాబట్టి కేవలం విభాగం మొదటి రోజు వంటి
డేవిడ్ ఒక కాంతి ఏట

22
00:01:14,675 --> 00:01:21,990
బల్బ్, మన కంప్యూటర్లో దల లేదా 1
అర్థం 0 గా బైనరీ మరియు

23
00:01:21,990 --> 00:01:24,110
1 యొక్క ఆన్ లేదా ఆఫ్.

24
00:01:24,110 --> 00:01:25,360
బైనరీ యొక్క బేసిక్స్.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
ప్రతి చోటు ప్రాతినిధ్యం వహిస్తుంది
బేస్ రెండు లో.

27
00:01:32,470 --> 00:01:36,260
కాబట్టి మీకు 0 జోడించండి 2
1 అన్ని మార్గం అప్ 2.

28
00:01:36,260 --> 00:01:41,970
>> మీ బైనరీ ఏమి లెక్కించేందుకు
దశాంశ, మీరు కేవలం ఈ సమీకరణం అనుసరించండి

29
00:01:41,970 --> 00:01:42,840
రకం విషయం.

30
00:01:42,840 --> 00:01:49,510
ఆ ప్రాంతాలలో ఏ లో ఒక 1 ఉంటే,
మీరు ద్వారా గుణిస్తారు సంసార

31
00:01:49,510 --> 00:01:53,820
అది యొక్క మూల వరకు జోడించవచ్చు, మరియు
మీరు దశాంశ పొందండి.

32
00:01:53,820 --> 00:01:57,930
కాబట్టి ఈ మీరు COUNT ఎలా ఉంది
బైనరీ 5.

33
00:01:57,930 --> 00:02:01,400
జస్ట్ మేము చేస్తున్న ఏమి వంటి
గత స్లయిడ్ ఈ ఎలా మీరు చేస్తాను ఉంది

34
00:02:01,400 --> 00:02:02,650
5 ద్వారా 1 సూచిస్తాయి.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> అదేవిధంగా, కేవలం మీరు జోడించవచ్చు ఇష్టం మరియు
దశాంశ లో వ్యవకలనం లేదా 10 బేస్, లేదా

37
00:02:09,660 --> 00:02:13,040
నిజంగా ఏ బేస్, న జోడించవచ్చు
మరియు బైనరీ లో వ్యవకలనం.

38
00:02:13,040 --> 00:02:18,400
మీరు మీరు ఆశించిన వేటి
ఇది అధిక సమానం ఉంటే, రెండు వరకు జోడించవచ్చు

39
00:02:18,400 --> 00:02:24,220
1 కంటే, మీరు ఒక 1, అది ఒక 0 చేయడానికి తీసుకు,
మరియు కేవలం, అదనంగా ఆ విధంగా చేయండి

40
00:02:24,220 --> 00:02:29,910
వంటి మీరు రెగ్యులర్ తో ఆలోచించే
దశాంశ లేదా ఏ ఇతర బేస్.

41
00:02:29,910 --> 00:02:30,970
కూల్.

42
00:02:30,970 --> 00:02:35,140
>> నేను, ప్రతిదీ ముందు చెప్పారు వంటి కాబట్టి ఆ
మా కంప్యూటర్ యొక్క హుడ్ కింద వెళ్తాడు

43
00:02:35,140 --> 00:02:37,560
0 మరియు 1 యొక్క, లేదా బైనరీ జరుగుతుంది.

44
00:02:37,560 --> 00:02:43,470
కాబట్టి మేము వ్యక్తం చేస్తావు, ఉదాహరణకు,
లేఖలు లేదా నంబర్లు, లేదా అక్షరాలు?

45
00:02:43,470 --> 00:02:45,560
ఆ సమాధానం ASCII ఉంది.

46
00:02:45,560 --> 00:02:49,380
>> ASCII అక్షరాలు మధ్య మాపింగ్ ఉంది
మేము సాధారణంగా చూస్తాము ఆ

47
00:02:49,380 --> 00:02:53,360
A యొక్క, B యొక్క వంటి ఆంగ్ల భాష,
సి యొక్క, తక్కువగా, డాష్లు మరియు

48
00:02:53,360 --> 00:02:54,910
ఆ వంటి ఏదైనా.

49
00:02:54,910 --> 00:02:57,260
మరియు అది ఒక ASCII విలువ ఆ పటములు.

50
00:02:57,260 --> 00:03:03,080
ఒక ASCII విలువ కేవలం ఒక సంఖ్య అని
మీ కంప్యూటర్ అర్ధం చేసుకోవచ్చు.

51
00:03:03,080 --> 00:03:07,430
మరియు మీరు అదనంగా చేయవచ్చు వలె మరియు
సంఖ్యలు తీసివేత, మీరు చేయవచ్చు

52
00:03:07,430 --> 00:03:10,890
ASCII విలువలు వాటిని.

53
00:03:10,890 --> 00:03:14,050
>> ఈ ఉదాహరణలో సో వాట్
ఈ ముద్రించాలా ఉంటుంది?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
అవును, కాబట్టి కేవలం ఒక అంతరిక్ష బి స్పేస్ సి స్థలం
డి ఎక్కడ నా మౌస్ వెళ్ళి వచ్చింది?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
మీరు 65 వద్ద ఒక పూర్ణాంకానికి నిర్వచించలేదు గమనించండి.

58
00:03:43,380 --> 00:03:47,080
మరియు మీరు ఉపయోగించి ఆ ప్రింట్ చేసినప్పుడు
శాతం సి, ఇది ఒక వంటి కొందరు వివరించినప్పటికీ చేస్తాము

59
00:03:47,080 --> 00:03:49,330
పాత్ర మరియు A. ముద్రిస్తుంది

60
00:03:49,330 --> 00:03:52,800
>> అదేవిధంగా, మీరు ప్రకటించవచ్చు
అది ఒక చార్ వంటి.

61
00:03:52,800 --> 00:03:56,860
మరియు మీరు శాతం ఉపయోగించి దాన్ని ప్రింట్ చేసినప్పుడు
సి, ఇది ఆ అనువదించేందుకు చేస్తాము

62
00:03:56,860 --> 00:04:05,240
శాతం D. మరియు మీరు ఒక జోడించండి చేయవచ్చు వలె
సంఖ్య, మీరు అక్షరాలు ఉంటాయి జోడించవచ్చు

63
00:04:05,240 --> 00:04:06,878
ఈ సందర్భంలో ASCII విలువలు.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> ప్రతిఒక్కరికీ కాబట్టి కొద్దిగా పాయింటర్.

66
00:04:16,130 --> 00:04:19,610
5, ఒక స్ట్రింగ్ వంటి, లేదు
నిజంగా 5 సమం.

67
00:04:19,610 --> 00:04:26,610
కాబట్టి మేము ఎలా మార్చేందుకు ఉండవచ్చు
పూర్ణాంక 5 స్ట్రింగ్ 5?

68
00:04:26,610 --> 00:04:28,930
ఏదైనా ఆలోచనలు?

69
00:04:28,930 --> 00:04:31,630
అవును.

70
00:04:31,630 --> 00:04:36,720
>> కాబట్టి మేము ఒక స్ట్రింగ్ వంటి 5 కలిగి ఉంటే,
మేము 0 తీసివేయడం చేయవచ్చు.

71
00:04:36,720 --> 00:04:37,820
మరియు మాకు 5 ఇస్తాము.

72
00:04:37,820 --> 00:04:41,670
మరియు అలాగే, మేము ఒక వంటి 5 కలిగి ఉంటే
పూర్ణాంక, స్ట్రింగ్ 0 జోడించండి.

73
00:04:41,670 --> 00:04:43,112
మరియు మాకు స్ట్రింగ్ 5 ఇస్తుంది.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
కూల్.

76
00:04:48,350 --> 00:04:52,940
>> ఇప్పుడు ఒక పేరు లెక్చర్ తిరిగి గుర్తుకు
అల్గోరిథంలు గురించి మాట్లాడారు.

77
00:04:52,940 --> 00:04:57,260
కాబట్టి మేము నిజానికి ఒక కంప్యూటర్ అనుకుంటున్నారు ఎలా
ఆసక్తికరమైన పనులు?

78
00:04:57,260 --> 00:05:00,460
మీరు, జోడించడం మరియు తీసివేయడం, తెలుసు
సంఖ్యలు మరియు ప్రింటింగ్ విషయాలు బయటకు కాదు

79
00:05:00,460 --> 00:05:01,730
ఆ ఉత్తేజకరమైన.

80
00:05:01,730 --> 00:05:04,620
సాధారణంగా, మేము మా కంప్యూటర్ అనుకుంటే
అల్గోరిథం యొక్క రకమైన నిర్వహించడానికి.

81
00:05:04,620 --> 00:05:07,820
కొద్దిగా క్లిష్టమైన ఏదో
కేవలం సాధారణ అంకగణిత కంటే.

82
00:05:07,820 --> 00:05:11,930
>> ఒక అల్గోరిథం అడుగు సెట్ ద్వారా కేవలం ఒక అడుగు
నిర్వహించడానికి ఎలా సూచనలను

83
00:05:11,930 --> 00:05:14,640
ఒక నిర్దిష్ట task--

84
00:05:14,640 --> 00:05:15,660
కేవలం ఒక వంటకం ఇష్టపడితే.

85
00:05:15,660 --> 00:05:19,990
మీరు మొదటి రోజు గుర్తు ఉండవచ్చు
డేవిడ్ మాకు ఒక గది COUNT కలిగి ఉన్న తరగతి

86
00:05:19,990 --> 00:05:22,550
ప్రజలు మరియు ఎంత మంది
గది ఉన్నాయి.

87
00:05:22,550 --> 00:05:24,480
మీరు లెక్కింపు వాడవచ్చు
ఒకరి.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
ఆ సందర్భంలో, ఒక సరళ సమయం అల్గోరిథం.

90
00:05:28,010 --> 00:05:31,710
>> కానీ డేవిడ్ ఒక అల్గోరిథం పరిచయం
మీరు గదిలో ఉన్నారు లెక్కించడానికి

91
00:05:31,710 --> 00:05:37,340
ప్రతి ఒక్కరూ నిలబడి ఉన్న, మీరు మీ చెప్పటానికి
మరో వ్యక్తికి సంఖ్య, ఆ జోడించండి

92
00:05:37,340 --> 00:05:39,200
సంఖ్య అప్, మరియు ఒక వ్యక్తి డౌన్ కూర్చుని.

93
00:05:39,200 --> 00:05:40,410
మరియు మీరు ఆ పునరావృతం.

94
00:05:40,410 --> 00:05:42,910
ఆ అల్గోరిథం యొక్క ఒక రకం వార్తలు.

95
00:05:42,910 --> 00:05:47,520
మేము ఎలా సమర్థవంతంగా ఒక విశ్లేషిస్తుంది
ఇది సమయం రన్ నా మీద అల్గోరిథం ఆధారపడి ఉంటుంది.

96
00:05:47,520 --> 00:05:49,680
కానీ మేము కొద్దిగా మాట్లాడదాము
ఆ తరువాత దీని గురించి మరింత.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> కాబట్టి అన్ని అల్గోరిథంలు కూడా చెయ్యవచ్చు
pseudocode లో వ్రాయవచ్చు.

99
00:05:57,090 --> 00:06:01,120
Pseudocode కేవలం వంటి ఒక ఆంగ్ల
వాక్యనిర్మాణం ప్రాతినిధ్యం ఉపయోగిస్తారు

100
00:06:01,120 --> 00:06:02,420
ఒక ప్రోగ్రామింగ్ భాష.

101
00:06:02,420 --> 00:06:06,070
ఉదాహరణకు, ఒక వినియోగదారు మేము కోరుకుంటే గోవా
నా ఇష్టమైన సంఖ్య ఊహించడానికి, మేము

102
00:06:06,070 --> 00:06:08,390
వంటి pseudocode ఉండవచ్చు.

103
00:06:08,390 --> 00:06:09,850
>> ఒక వినియోగదారులు అంచనా పొందండి.

104
00:06:09,850 --> 00:06:13,570
అంచనా సరైనదైతే, వాటిని చెప్పండి
వారు సరైన, వేరే వాటిని చెప్పండి

105
00:06:13,570 --> 00:06:15,560
వారు సరైన లేదు.

106
00:06:15,560 --> 00:06:22,530
మరియు pseudocode సులభంగా ఒక మార్గం ఉంది
ఒక ఆలోచన లేదా ఒక అల్గోరిథం ప్రాతినిధ్యం.

107
00:06:22,530 --> 00:06:26,910
కాబట్టి ఇప్పుడు మేము నిజానికి రాయాలనుకుంటున్నాను ఉండవచ్చు
ఈ భాషలో ఆ కంప్యూటర్

108
00:06:26,910 --> 00:06:27,980
అవగాహన కలిగింది.

109
00:06:27,980 --> 00:06:35,660
కాబట్టి మేము మా pseudocode రాస్తుంది
సోర్స్ కోడ్ కొందరు వివరించినప్పటికీ.

110
00:06:35,660 --> 00:06:41,320
>> ఇప్పటివరకు, సోర్స్ కోడ్ కట్టుబడి ఉండాలి
ఒక నిర్దిష్ట వాక్యనిర్మాణం

111
00:06:41,320 --> 00:06:42,490
ఒక ప్రోగ్రామింగ్ భాష.

112
00:06:42,490 --> 00:06:45,430
ఇప్పటివరకు, CS50 లో, మేము చేసిన
ఎక్కువగా సి ఉపయోగించి చేయబడ్డాయి.

113
00:06:45,430 --> 00:06:48,320
కాబట్టి ఈ సి సోర్స్ కోడ్ ఉండవచ్చు.

114
00:06:48,320 --> 00:06:51,440
తరువాత కోర్సు లో, మీరు రాత్రి వచ్చి
ఇతర ప్రోగ్రామింగ్ తో పరిచయం లోకి

115
00:06:51,440 --> 00:06:52,480
PHP వంటి భాషలు.

116
00:06:52,480 --> 00:06:57,540
లేదా మీరు కూడా, మీరు ఇతర తరగతులను తీసుకోవటానికి ఉంటే
జావా, పైథాన్, లేదా OCML చేయండి ఉండవచ్చు.

117
00:06:57,540 --> 00:07:01,570
కానీ మా సి కార్యక్రమం భాష లో, ఈ ఉంది
మేము సోర్స్ కోడ్ వ్రాయడానికి ఎలా

118
00:07:01,570 --> 00:07:04,760
pseudocode అల్గోరిథం
నేను ముందుగా వివరించిన.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> సో ఎలా నిజానికి మీ కంప్యూటర్ చేస్తుంది
ఆ అర్థం?

121
00:07:11,430 --> 00:07:14,490
నేను మాత్రమే నిజంగా అది ముందు చెప్పినట్టూ
సున్నాలు మరియు వాటిని అర్థం.

122
00:07:14,490 --> 00:07:17,880
కాబట్టి ఎలా మూలం నుండి పొందడానికి లేదు
ఉంటుంది ఏదో కోడ్

123
00:07:17,880 --> 00:07:18,960
అర్థం?

124
00:07:18,960 --> 00:07:22,920
Well, మేము ఏదైనా కలిగి
ఒక కంపైలర్ అని.

125
00:07:22,920 --> 00:07:28,450
>> మీరు చాలా లో తిరిగి గుర్తు ఉంటే మీ
psets, మీరు ప్రోగ్రామ్ యొక్క రకమైన కలిగి

126
00:07:28,450 --> 00:07:30,370
ఒక డాట్ సి ఫైలు వ్రాసిన.

127
00:07:30,370 --> 00:07:32,550
ఆపై మీరు తయారు టైప్ చేస్తుంది.

128
00:07:32,550 --> 00:07:35,970
సో వాట్ తయారు చేస్తోంది?

129
00:07:35,970 --> 00:07:39,970
>> మీరు కంపైల్ తయారు టైప్ చేయవచ్చు మీ
కార్యక్రమం someone-- ఎందుకంటే

130
00:07:39,970 --> 00:07:42,730
ఎవరైతే మీ p సెట్ రాశాడు;
బహుశా David--

131
00:07:42,730 --> 00:07:44,190
ఒక మేకప్ ఫైలు రూపొందించినవారు.

132
00:07:44,190 --> 00:07:51,320
మరియు ఆ రన్ తెలుసు చేయడానికి చెబుతుంది మీ
కంపైలర్, గణగణమని ద్వని అని, సంకల్ప

133
00:07:51,320 --> 00:07:55,560
అప్పుడు వస్తువు మీ సోర్స్ కోడ్ కంపైల్
సున్నాలు మరియు వాటిని ఇది కోడ్

134
00:07:55,560 --> 00:07:57,720
మీ కంప్యూటర్లో అర్థం.

135
00:07:57,720 --> 00:08:01,610
కాని ఆ తర్వాత కొద్దిగా, మేము వెళ్తుంది
కంపైలర్స్ గురించి లోతు ఎక్కువ.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> కాబట్టి గుర్తుకు pset 0, where-- అవును,
మీరు ఒక ప్రశ్న ఉందా?

138
00:08:10,800 --> 00:08:11,620
>> ప్రేక్షకులు: [వినబడని]?

139
00:08:11,620 --> 00:08:12,490
>> SPEAKER 1: అవును.

140
00:08:12,490 --> 00:08:14,960
నేను నిజానికి వారు అనుకుంటున్నాను
ఆన్లైన్ ఉండాలి.

141
00:08:14,960 --> 00:08:15,120
అవును.

142
00:08:15,120 --> 00:08:16,572
>> ప్రేక్షకులు: [వినబడని] వంటిది?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> SPEAKER 1: ఇది కాదు.

145
00:08:20,830 --> 00:08:25,810
ది cs50.net/quizzes ఉన్నాయి.

146
00:08:25,810 --> 00:08:32,900
>> ప్రేక్షకులు: స్లాష్ క్విజెస్, 2013 స్లాష్
0 స్లాష్, మరియు కేవలం ద్వారా క్లిక్

147
00:08:32,900 --> 00:08:35,956
క్విజెస్ 2013 మరియు క్విజ్ 0,
విభాగం స్లయిడ్లను సమీక్షించండి.

148
00:08:35,956 --> 00:08:40,380
>> SPEAKER 1: అవును, కాబట్టి మీరు అబ్బాయిలు అనుకుంటే
ఇది పుల్ అప్ మరియు అది చూసి మీ

149
00:08:40,380 --> 00:08:42,740
సొంత కంప్యూటర్, అది చాలా మంచిది.

150
00:08:42,740 --> 00:08:43,130
మళ్ళీ సే.

151
00:08:43,130 --> 00:08:44,546
>> ప్రేక్షకులు: [వినబడని].

152
00:08:44,546 --> 00:08:48,780
>> SPEAKER 1: అవును, [వినబడని]
నకిలీ చరరాశి.

153
00:08:48,780 --> 00:08:49,644
ఓహ్, అవును?

154
00:08:49,644 --> 00:08:51,372
>> ప్రేక్షకులు: [వినబడని]?

155
00:08:51,372 --> 00:08:54,300
>> SPEAKER 1: లేదు, దాడులు
పరీక్షలో కాదు.

156
00:08:54,300 --> 00:08:55,950
క్షమించండి, ఆమె ప్రశ్న
పరీక్షలో దాడులు.

157
00:08:55,950 --> 00:08:59,530
ఇది కాదు.

158
00:08:59,530 --> 00:09:05,780
కాబట్టి pset 0, మీరు అబ్బాయిలు ఉండాల్సిందని
మొదటి ఉపయోగించి ఏదైనా అమలు.

159
00:09:05,780 --> 00:09:13,100
మరియు మేము కొన్ని ప్రాథమిక ప్రోగ్రామింగ్ నేర్చుకున్నాడు
మొదటి ఉపయోగించి బిల్డింగ్ బ్లాక్స్.

160
00:09:13,100 --> 00:09:15,590
>> కాబట్టి యొక్క కొన్ని పరిశీలించి తెలియజేయండి
ఈ బిల్డింగ్ బ్లాక్స్

161
00:09:15,590 --> 00:09:18,170
ఒక కార్యక్రమాన్ని ఏర్పాటు చేయడానికి.

162
00:09:18,170 --> 00:09:20,570
మొదటి బూలియన్ వ్యక్తీకరణ.

163
00:09:20,570 --> 00:09:24,540
బూలియన్ వ్యక్తీకరణలు వాటిని మరియు
కలిగి 0 లేదా ఏదైనా

164
00:09:24,540 --> 00:09:25,700
రెండు విలువలను.

165
00:09:25,700 --> 00:09:30,320
ఈ సందర్భంలో, నిజమైన లేదా తప్పుడు,
ఆన్ లేదా ఆఫ్, మరియు అవును లేదా సంఖ్య.

166
00:09:30,320 --> 00:09:35,390
చాలా సులభమైన, సాధారణ యొక్క ఒక ఉదాహరణ,
ఒక బూలియన్ ఉపయోగించే కార్యక్రమం

167
00:09:35,390 --> 00:09:39,140
ఇక్కడ వ్యక్తీకరణ అప్.

168
00:09:39,140 --> 00:09:43,220
>> కాబట్టి బూలియన్ వ్యక్తీకరణలు క్రమంలో
ఉపయోగము, మేము బూలియన్ ఆపరేటర్లను ఉన్నాయి.

169
00:09:43,220 --> 00:09:48,920
ఈ వాడుకోవచ్చు నిర్వాహకులు
కొన్ని విలువలు పోల్చడానికి.

170
00:09:48,920 --> 00:09:52,820
కాబట్టి మేము కలిగి మరియు లేదా సమాన తక్కువ
కంటే ఎక్కువ లేదా కంటే ఎక్కువ సమానంగా లేదా

171
00:09:52,820 --> 00:09:55,130
సమానంగా, మరియు కంటే తక్కువ
కంటే ఎక్కువ లేదా ఎక్కువ.

172
00:09:55,130 --> 00:09:59,060
కానీ ఈ ఆపరేటర్లకు చాలా ఉపయోగకరంగా లేవు
మేము వాటిని మిళితం చేయవచ్చు తప్ప

173
00:09:59,060 --> 00:10:00,320
పరిస్థితులు.

174
00:10:00,320 --> 00:10:04,370
>> కాబట్టి మీరు అబ్బాయిలు మొదటి నుండి గుర్తు ఉండవచ్చు
మరియు మీ p నుండి మేము అమర్చుతుంది

175
00:10:04,370 --> 00:10:05,400
పరిస్థితులు వచ్చింది.

176
00:10:05,400 --> 00:10:09,710
వారు చెంచాలు వంటి, ముఖ్యంగా,
మీ కార్యక్రమాన్ని తర్కం

177
00:10:09,710 --> 00:10:12,670
దానిపై ఆధారపడి అమలు
ఒక పరిస్థితి ఏర్పడితే.

178
00:10:12,670 --> 00:10:18,150
మేము కలిగి పరిస్థితులు కాబట్టి ఒక
ఈ కోర్సులో అనేక సార్లు ఉపయోగిస్తారు

179
00:10:18,150 --> 00:10:21,470
ఎవరికి ఉంటే, మరియు మిగతా పరిస్థితులు, ఉంటే.

180
00:10:21,470 --> 00:10:24,060
>> ఇక్కడ ఎలా ఒక ఉదాహరణ వార్తలు
మీరు ఆ ఉపయోగించవచ్చు.

181
00:10:24,060 --> 00:10:28,430
ఎవరికీ మధ్య తేడా కలది
కేవలం ప్రకటనలు ఉంటే ఉపయోగించి

182
00:10:28,430 --> 00:10:32,530
ఉంటే, మిగతా పద్యాల డౌన్ మార్గం,
ఉంటే, మరియు మిగిలిన కలిపి?

183
00:10:32,530 --> 00:10:33,013
అవును?

184
00:10:33,013 --> 00:10:34,263
>> ప్రేక్షకులు: [వినబడని].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> SPEAKER 1: ఖచ్చితంగా.

187
00:10:42,160 --> 00:10:50,210
కాబట్టి నేను కలిగి ఉంటే ఈ డౌన్ అన్ని మార్గం
మార్గం, కూడా ఈ పరిస్థితి తిరిగి ఉంటే

188
00:10:50,210 --> 00:10:52,800
నిజమైన, ఇది ఇప్పటికీ కొనసాగుతుంది
తదుపరి రెండు పరీక్ష.

189
00:10:52,800 --> 00:11:00,120
, అయితే ఒక else ఉంటే, ఒక else తో
ప్రకటన ఒక నిజమైన తిరిగి ఉంటే,

190
00:11:00,120 --> 00:11:02,640
ఇతరులు వేయబడతాయి.

191
00:11:02,640 --> 00:11:05,955
గురించి ఏదైనా ప్రశ్నలు?

192
00:11:05,955 --> 00:11:06,890
కూల్.

193
00:11:06,890 --> 00:11:12,240
>> సో మీరు ఒక else ఒక ఉంటే-else ఉపయోగించడానికి
మీకు తెలిస్తే ఆ ప్రకటన అది మాత్రమే చెయ్యగలరు

194
00:11:12,240 --> 00:11:14,470
ఈ కేసులలో ఒకటైన ఉంటుంది.

195
00:11:14,470 --> 00:11:21,550
X కంటే తక్కువ 0 ఉంటే కాబట్టి మేము అది, తెలుసు
ఖచ్చితంగా అవతరిస్తుంది లేదు

196
00:11:21,550 --> 00:11:22,890
0 కన్నా ఎక్కువ.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> తదుపరి, మరొక భవనం బ్లాక్
మేము నేర్చుకున్న అని ఉచ్చులు ఉన్నాయి.

199
00:11:31,480 --> 00:11:33,310
మేము ఉచ్చులు మూడు రకాల ఉన్నాయి.

200
00:11:33,310 --> 00:11:35,830
ఉచ్చులు కోసం, ఉచ్చులు అయితే,
మరియు ఉచ్చులు సమయంలో.

201
00:11:35,830 --> 00:11:38,730
మరియు సాధారణంగా, మీరు ఉన్నప్పుడు కూర్చో
ఏదో వ్రాయడానికి, మీరు నిర్ణయించుకుంటారు ఉంటుంది

202
00:11:38,730 --> 00:11:40,060
మీరు ఉపయోగించడానికి అనుకుంటున్నారా మూడు ఏది.

203
00:11:40,060 --> 00:11:41,900
సో ఎలా మేము ఇది ఒక నిర్ణయిస్తారు?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> మేము తెలిస్తే మేము సాధారణంగా లూప్ ఒక ఉపయోగించకూడదని
ఎన్ని సార్లు మేము iterate మీరు

206
00:11:48,790 --> 00:11:53,650
ఏదో ద్వారా లేదా ఎన్ని సార్లు
మేము ఒక పని అనుకుంటే.

207
00:11:53,650 --> 00:11:58,830
మేము కొన్ని అవసరం అయితే మేము ఉచ్చులు అయితే ఉపయోగించడానికి
పరిస్థితి నడుస్తున్న ఉంచడానికి నిజమని.

208
00:11:58,830 --> 00:12:03,730
మరియు మేము చాలా పోలి అయితే డో
అయితే, కానీ మేము మా కోడ్ అమలు కావాలి

209
00:12:03,730 --> 00:12:04,880
కనీసం ఒక సమయం.

210
00:12:04,880 --> 00:12:09,410
>> దో ఏమైనా అలా అయితే, రెడీ
ఎల్లప్పుడూ కనీసం ఒక సమయం అమలు.

211
00:12:09,410 --> 00:12:13,120
, అయితే అయితే, అది
అన్ని వద్ద ఉంటే అమలు చేయకపోవచ్చు

212
00:12:13,120 --> 00:12:15,490
పరిస్థితి సంతృప్తి లేదు.

213
00:12:15,490 --> 00:12:16,740
ఆ ఏదైనా ప్రశ్నలు?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> లూప్ ఒక కాబట్టి నిర్మాణం.

216
00:12:22,860 --> 00:12:23,620
మీరు అబ్బాయిలు ఈ సాధించింది.

217
00:12:23,620 --> 00:12:25,320
మీరు ప్రారంభించడం.

218
00:12:25,320 --> 00:12:26,600
మీరు పరిస్థితి రకమైన కలిగి.

219
00:12:26,600 --> 00:12:32,340
కాబట్టి, ఉదాహరణకు, మేము ప్రారంభించడం ఉండవచ్చు
కోసం నేను 0 సమానం.

220
00:12:32,340 --> 00:12:34,040
నేను కంటే తక్కువ 10 ఉంది.

221
00:12:34,040 --> 00:12:35,442
మరియు నేను ++.

222
00:12:35,442 --> 00:12:39,010
మేము చేసిన ఆ చాలా సులభమైన ఒకటి.

223
00:12:39,010 --> 00:12:42,210
>> ఒక సమయంలో లూప్, అదేవిధంగా, మీరు కలిగి
ప్రారంభ రకమైన కలిగి,

224
00:12:42,210 --> 00:12:44,980
పరిస్థితి రకమైన, మరియు
నవీకరణ రకమైన.

225
00:12:44,980 --> 00:12:51,990
కాబట్టి మేము కూడా లూప్ మా అమలు చేయవచ్చు
ఒక సమయంలో లూప్ ఈ ఉపయోగించి.

226
00:12:51,990 --> 00:12:56,000
మరియు అలాగే ఒక డో సమయంలో లూప్ తో,
మేము కొన్ని ప్రారంభ కలిగి ఉండవచ్చు,

227
00:12:56,000 --> 00:12:58,640
, ఏదో అమలు అది అప్డేట్, మరియు
అప్పుడు పరిస్థితి తనిఖీ.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> కాబట్టి ఇప్పుడు పని.

230
00:13:05,140 --> 00:13:06,460
మేము కలిసి ప్రతిదీ ఉంచండి.

231
00:13:06,460 --> 00:13:10,140
మేము కొన్ని రాయాలనుకుంటున్నాను ఉండవచ్చు
ఫంక్షన్ రకం.

232
00:13:10,140 --> 00:13:12,790
సాధారణ ఫంక్షన్ మీరు వాటిని
ఇప్పటికే చూసిన ప్రధాన ఉంది.

233
00:13:12,790 --> 00:13:13,770
ప్రధాన ఒక ఫంక్షన్ ఉంది.

234
00:13:13,770 --> 00:13:16,160
ఇది ఒక తిరిగి టైప్ Int కలిగి.

235
00:13:16,160 --> 00:13:18,470
ఇది ప్రధాన ఒక ఫంక్షన్ పేరు ఉంది.

236
00:13:18,470 --> 00:13:20,810
మరియు వాదనలు, argc మరియు argv ఉంది.

237
00:13:20,810 --> 00:13:24,040
కాబట్టి ప్రధాన కేవలం ఒక విధి.

238
00:13:24,040 --> 00:13:27,230
>> మీరు ఉపయోగించిన ఉండవచ్చు ఇతర విధులు,
printf-- printf ఒక ఫంక్షన్ ఉంది

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
కానీ వీటిని జరిగే
ద్వారా మాకు అమలు

241
00:13:32,010 --> 00:13:33,270
లైబ్రరీ రకమైన.

242
00:13:33,270 --> 00:13:37,400
మీరు అబ్బాయిలు సహా గుర్తుంచుకుంటే
ఈ cs50.h లైబ్రరీ లేదా

243
00:13:37,400 --> 00:13:38,510
ప్రామాణిక I / O లైబ్రరీ.

244
00:13:38,510 --> 00:13:39,200
అవును, ప్రశ్న?

245
00:13:39,200 --> 00:13:41,610
>> ప్రేక్షకులు: సి లో కేవలం స్వాభావిక ప్రధాన ఏమిటి?

246
00:13:41,610 --> 00:13:44,740
ఇది కేవలం రకమైన [వినబడని] డజ్?

247
00:13:44,740 --> 00:13:47,370
>> SPEAKER 1: ప్రశ్న
ప్రధాన ఉంటే సి సహజమని.

248
00:13:47,370 --> 00:13:51,460
మరియు అవును, అన్ని విధులు
ఒక ప్రధాన చర్య.

249
00:13:51,460 --> 00:13:55,290
ఇది రకమైన కంప్యూటర్ కోసం అవసరమైన వార్తలు
ఎక్కడ ప్రారంభించాలో తెలుసు

250
00:13:55,290 --> 00:13:55,993
కోడ్ అమలు.

251
00:13:55,993 --> 00:13:58,108
>> ప్రేక్షకులు: సో మీరు లేదు [వినబడని]?

252
00:13:58,108 --> 00:13:59,480
>> SPEAKER 1: నం

253
00:13:59,480 --> 00:14:00,760
ఏదైనా ఇతర ప్రశ్నలు?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
కూల్.

256
00:14:04,770 --> 00:14:08,050
మీరు ఒక ఫంక్షన్ ఉపయోగించవచ్చు కాబట్టి కేవలం
మీరు కోసం వ్రాసిన, మీరు కూడా చెయ్యవచ్చు

257
00:14:08,050 --> 00:14:10,380
మీ సొంత ఫంక్షన్ వ్రాయండి.

258
00:14:10,380 --> 00:14:17,050
ఈ ఎవరైనా వాటిని ఒక ఫంక్షన్ ఉంది
వాల్యూమ్ లెక్కించేందుకు వ్రాశారు

259
00:14:17,050 --> 00:14:18,395
ఉదాహరణకు ఒక q యొక్క.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
తిరిగి రకం ఈ సందర్భంలో, ఇక్కడ ఉంది
Int, మా ఫంక్షన్ పేరు q మరియు మా

262
00:14:29,500 --> 00:14:31,360
పారామితులు జాబితా.

263
00:14:31,360 --> 00:14:34,550
>> మరియు మీరు డేటా వ్రాయడానికి గమనించండి
మీరు పారామితి రకం

264
00:14:34,550 --> 00:14:38,660
ఉపయోగించడానికి లేదా పనిచేయదని వేరే
ఏ రకమైన తెలుసు

265
00:14:38,660 --> 00:14:41,650
పారామితి నేను అంగీకరించడం చేయాలి.

266
00:14:41,650 --> 00:14:48,110
కాబట్టి, ఈ సందర్భంలో, మనం కావలసిన
మా ఇన్పుట్ వంటి పూర్ణాంకం.

267
00:14:48,110 --> 00:14:50,390
సో ఎందుకు మేము విధులు వుపయోగించాలని అనుకొనుచున్న?

268
00:14:50,390 --> 00:14:52,800
>> అన్ని మొదటి, సంస్థ కోసం గొప్ప.

269
00:14:52,800 --> 00:14:56,350
వారు లోకి మీ కోడ్ విచ్ఛిన్నం సహాయం
మరింత రాళ్లను వ్యవస్థీకృత మరియు తయారు

270
00:14:56,350 --> 00:14:57,960
సులభంగా చదవటానికి.

271
00:14:57,960 --> 00:14:59,760
సాధారణీకరణ.

272
00:14:59,760 --> 00:15:01,740
ఈ డిజైన్ మంచిది.

273
00:15:01,740 --> 00:15:04,570
మీరు కోడ్ యొక్క ఒక భాగాన్ని చదివిన వెన్
మరియు ప్రధాన విధి, నిజంగా ఉంది

274
00:15:04,570 --> 00:15:07,750
నిజంగా దీర్ఘ, అది కష్టం కావచ్చు
జరగబోతోంది ఏమి గురించి కారణం.

275
00:15:07,750 --> 00:15:11,710
కాబట్టి మీరు విధులు లోకి అది విచ్ఛిన్నం ఉంటే,
ఇది చదవడానికి సులభంగా ఉంటుంది.

276
00:15:11,710 --> 00:15:12,750
మరియు మళ్ళీ సామర్థ్యం.

277
00:15:12,750 --> 00:15:16,940
మీరు కోడ్ యొక్క ఒక భాగం కలిగి ఉంటే చేయబడిన
అని లేదా అనేకసార్లు అమలు,

278
00:15:16,940 --> 00:15:20,690
బదులుగా ఆ కోడ్ 10 సార్లు మళ్లీ
మీ ప్రధాన విధి, మీరు వాటిని

279
00:15:20,690 --> 00:15:21,440
అది తిరిగి కావలసిన.

280
00:15:21,440 --> 00:15:25,740
ఆపై ప్రతిసారీ మీరు ఉపయోగించడానికి అవసరం
కోడ్ యొక్క భాగం, ఫంక్షన్ కాల్.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> కాబట్టి ఇప్పుడు మేము తిరిగి గీతలు గుర్తు ఉంటే,
మేము కూడా, కొన్ని అంశాల గురించి మాట్లాడారు

283
00:15:35,380 --> 00:15:37,680
వీటిలో ఒకటి థ్రెడ్డింగ్ ఉంది.

284
00:15:37,680 --> 00:15:41,120
థ్రెడ్ బహుళ భావన ఉంది
కోడ్ క్రమాలపై

285
00:15:41,120 --> 00:15:43,040
అదే సమయంలో అమలు.

286
00:15:43,040 --> 00:15:47,490
కాబట్టి డేవిడ్ కలిగి ఉన్న రోజు ఒక తిరిగి అనుకుంటున్నాను
మీరు అబ్బాయిలు సంఖ్య ఆఫ్ లెక్కించడానికి

287
00:15:47,490 --> 00:15:48,440
గదిలో ప్రజలు.

288
00:15:48,440 --> 00:15:50,550
>> ముఖ్యంగా, ఏమి జరుగుతోందో
మీరు అబ్బాయిలు అన్ని పట్టాయి

289
00:15:50,550 --> 00:15:52,370
ప్రత్యేక దారాలను నడుస్తున్న.

290
00:15:52,370 --> 00:15:55,540
మరియు ఆ దారాలను కలిసి రావడం జరిగింది
సమాధానం రకమైన పొందడానికి.

291
00:15:55,540 --> 00:15:58,890
అదేవిధంగా, స్క్రాచ్ లో, మీరు ఎప్పుడు
బహుళ స్ప్రిట్స్, మీరు వాటిని

292
00:15:58,890 --> 00:16:01,070
ఒక పిల్లి మరియు ఒక కుక్క ఉంటుంది.

293
00:16:01,070 --> 00:16:08,770
మరియు వారు ఏకకాలంలో ఉంటుంది
వారి సొంత స్క్రిప్ట్స్ అమలు.

294
00:16:08,770 --> 00:16:10,020
ఆ త్రెడింగ్ యొక్క ఒక ఉదాహరణ.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> మరియు ఇతర భావన, అని
స్క్రాచ్ పరిచయం సంఘటనలు.

297
00:16:18,000 --> 00:16:22,550
మరియు ఈవెంట్స్ ఉన్నప్పుడు బహుళ భాగాలు
మీ కోడ్ ప్రతి ఇతర కమ్యూనికేట్.

298
00:16:22,550 --> 00:16:26,840
మీరు ఉపయోగించినప్పుడు స్క్రాచ్ లో, ఈ ఉంది
ప్రసార నియంత్రణ మరియు నేను ఎప్పుడు

299
00:16:26,840 --> 00:16:29,500
బ్లాక్స్ స్వీకరించండి.

300
00:16:29,500 --> 00:16:35,170
>> కూడా, ప్రాబ్లం సెట్ 4 లో, మేము చూసిన
అలాగే ఈవెంట్స్ కొద్దిగా.

301
00:16:35,170 --> 00:16:38,250
మీరు అబ్బాయిలు ఉపయోగించిన ఉండవచ్చు
Gevent లైబ్రరీ.

302
00:16:38,250 --> 00:16:42,450
మరియు ఒక ఫంక్షన్ ఉంది waitForClick
మీరు వేచి ఉన్నాయి

303
00:16:42,450 --> 00:16:44,300
యూజర్ క్లిక్ చేయండి.

304
00:16:44,300 --> 00:16:47,870
మరియు మీ క్లిక్, ఈ సందర్భంలో, ఉంటుంది
క్లిక్ ఘటనా మరియు వేచి మీ ఉంది

305
00:16:47,870 --> 00:16:49,120
ఈవెంట్ హ్యాండ్లర్.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> కూడా, మీ psets అంతటా నడుస్తున్న
మరియు మీ psets పని, మీరు

308
00:16:58,630 --> 00:17:01,920
తాకదు ఉండవచ్చు
ఈ ఆదేశాలను కొన్ని.

309
00:17:01,920 --> 00:17:05,579
ఈ మీరు టైప్ చేసిన ఏమి ఉంది మీ
టెర్మినల్ విండో లేదా సంసార విండో

310
00:17:05,579 --> 00:17:12,119
ఆ, మీ గ్రా మార్చు న అప్ చూపిస్తుంది
ముఖ్యంగా మీ కంప్యూటర్లో నావిగేట్.

311
00:17:12,119 --> 00:17:19,440
>> కాబట్టి ఉదాహరణకు, LS జాబితా
ఒక డైరెక్టరీ యొక్క కంటెంట్లను.

312
00:17:19,440 --> 00:17:22,510
డైరెక్టరీ ఒక కొత్త ఫోల్డర్ సృష్టిస్తుంది చేయండి.

313
00:17:22,510 --> 00:17:24,819
CD, మార్పు డైరెక్టరీ.

314
00:17:24,819 --> 00:17:28,400
RM, తొలగించడం, ఒక ఫైల్ తొలగిస్తే
లేదా కొన్ని డైరెక్టరీ.

315
00:17:28,400 --> 00:17:31,050
ఆపై డైరెక్టరీ తొలగించడానికి
ఒక డైరెక్టరీ తొలగిస్తుంది.

316
00:17:31,050 --> 00:17:32,300
>> ప్రేక్షకులు: [వినబడని]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> SPEAKER 1: అవును, ఖచ్చితంగా.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
క్షమించండి, ప్రశ్న మీరు ఉంటే
ఈ పెట్టటం సూచిస్తాయి

321
00:17:46,040 --> 00:17:48,840
మోసగాడు షీట్ మీద.

322
00:17:48,840 --> 00:17:49,440
ఇది ఉపయోగపడుతుంది.

323
00:17:49,440 --> 00:17:51,490
మీరు గది ఉంటే, మీరు ఉంచవచ్చు.

324
00:17:51,490 --> 00:17:56,170
ఇది కూడా తగినంత కేవలం సాధారణంగా మంచి వార్తలు
మీరు దీనిని ఉపయోగించడానికి ఉన్నప్పుడు ఎందుకంటే గుర్తుంచుకోవడానికి

325
00:17:56,170 --> 00:17:59,060
మీరు అనుకోవచ్చు కేవలం
అది జ్ఞాపకం చేశారు.

326
00:17:59,060 --> 00:18:02,750
మీ జీవితంలోని చాలా సులభం చేస్తాము.

327
00:18:02,750 --> 00:18:04,000
నేను మీ ప్రశ్నకు సమాధానం లేదు?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> కాబట్టి ఇప్పుడు, మేము ఒక చిన్న బిట్ మాట్లాడుకున్నారు
గ్రంధాలయాలు గురించి క్లుప్తంగా.

330
00:18:14,290 --> 00:18:18,570
కానీ రెండు ప్రధాన వాటిని మనం చేసిన
ఇప్పటివరకు కోర్సులో ఉంటాయి ఉపయోగించి

331
00:18:18,570 --> 00:18:20,860
ప్రామాణిక I / O మరియు CS50.

332
00:18:20,860 --> 00:18:25,410
విషయాలు ఏ విధమైన చేర్చబడ్డాయి
ప్రామాణిక I / O లైబ్రరీ లో?

333
00:18:25,410 --> 00:18:28,410
>> అవును, ఇప్పటివరకు మేము printf ఉపయోగించి.

334
00:18:28,410 --> 00:18:31,150
CS50 లో, మేము GetInt ఉపయోగించారు చేసిన
మరియు GetString.

335
00:18:31,150 --> 00:18:37,200
మరియు డేటా రకం స్ట్రింగ్ కూడా జరుగుతుంది
ఈ CS50 లైబ్రరీలో ప్రకటించాలని.

336
00:18:37,200 --> 00:18:40,250
మేము గురించి లోతుగా కొద్దిగా ఎక్కువ మాట్లాడదాము
ఎలా గ్రంధాలయాలు పని మరియు ఎలా వారు

337
00:18:40,250 --> 00:18:41,870
మీ మిగిలిన కోడ్ సంకర్షణ.

338
00:18:41,870 --> 00:18:46,220
కానీ ఆ రెండు ప్రధాన కలవి మేము
ఇప్పటివరకు తో కలసినప్పుడు చేశారు

339
00:18:46,220 --> 00:18:48,430
కోర్సు.

340
00:18:48,430 --> 00:18:50,050
>> రకాలు.

341
00:18:50,050 --> 00:18:58,120
ఈ ఎంత గుర్తు బాగున్నాయి
ప్రతి రకం ఎలా లేదా సూచించబడుతుంది

342
00:18:58,120 --> 00:19:02,840
అనేక బైట్లు రకం ప్రతి requires--

343
00:19:02,840 --> 00:19:04,990
పూర్ణాంకానికి 4 బైట్లు; చార్ 1 బైట్.

344
00:19:04,990 --> 00:19:06,550
ఫ్లోట్ 4 బైట్లు.

345
00:19:06,550 --> 00:19:07,782
ఒక డబుల్ ఏమిటి?

346
00:19:07,782 --> 00:19:09,032
>> ప్రేక్షకులు: [వినబడని].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> SPEAKER 1: అవును, కాబట్టి ఒక ఫ్లోట్
కానీ పరిమాణం రెట్టింపు.

349
00:19:16,240 --> 00:19:17,150
ఏం ఒక దీర్ఘ గురించి?

350
00:19:17,150 --> 00:19:18,400
>> ప్రేక్షకులు: [వినబడని].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> SPEAKER 1: సరే.

353
00:19:24,680 --> 00:19:25,410
ఒక దీర్ఘ ఏమిటి?

354
00:19:25,410 --> 00:19:26,660
>> ప్రేక్షకులు: [వినబడని].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> SPEAKER 1: అవును, ఒక పూర్ణాంకానికి రెట్టింపు.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
అవును.

359
00:19:34,705 --> 00:19:36,100
>> ప్రేక్షకులు: [వినబడని].

360
00:19:36,100 --> 00:19:38,030
>> SPEAKER 1: లాంగ్ [వినబడని].

361
00:19:38,030 --> 00:19:41,860
ఆపై ఒక లాంగ్ లాంగ్ ఆ రెట్టింపు.

362
00:19:41,860 --> 00:19:42,814
>> ప్రేక్షకులు: ఏ.

363
00:19:42,814 --> 00:19:47,107
ఒక దీర్ఘ కేవలం ఒక పూర్ణాంకానికి ఉంది.

364
00:19:47,107 --> 00:19:50,910
ఇది నిర్మాణం మీద ఆధారపడి
ముందు [వినబడని]

365
00:19:50,910 --> 00:19:52,922
మరియు Int అదే పరిమాణం కలిగి ఉంటాయి.

366
00:19:52,922 --> 00:19:54,172
[వినబడని].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> SPEAKER 1: సో ఒక దీర్ఘ మరియు
ఒక పూర్ణాంకానికి ఒకటే.

369
00:20:00,920 --> 00:20:02,943
ఆపై సుదీర్ఘ కాలం
డబుల్ పూర్ణాంకానికి ఉంది.

370
00:20:02,943 --> 00:20:03,910
కూల్.

371
00:20:03,910 --> 00:20:05,550
ఆపై, చివరి రకానికి ఏమిటి?

372
00:20:05,550 --> 00:20:06,510
>> ప్రేక్షకులు: పాయింటర్.

373
00:20:06,510 --> 00:20:10,350
>> SPEAKER 1: అవును, కాబట్టి మేము నేర్చుకున్న
గమనికలు గురించి కొద్దిగా.

374
00:20:10,350 --> 00:20:14,015
సంబంధం లేకుండా ఒక పాయింటర్ ఉంది ఏమి
ఇది ఆలోచన పై ఒక చార్ స్టార్ కావచ్చు

375
00:20:14,015 --> 00:20:15,880
లేదా ఒక పూర్ణాంకానికి star--

376
00:20:15,880 --> 00:20:20,530
ఇది ఎల్లప్పుడూ ఒక పాయింటర్ 4 బైట్లు ఉంది.

377
00:20:20,530 --> 00:20:21,633
గురించి ప్రశ్నలు?

378
00:20:21,633 --> 00:20:22,116
అవును?

379
00:20:22,116 --> 00:20:24,531
>> ప్రేక్షకులు: [వినబడని]?

380
00:20:24,531 --> 00:20:29,530
>> SPEAKER 1: సో ఒక దీర్ఘ మరియు ఒక పూర్ణాంకానికి ఉన్నాయి
ఈ CS50 పరికరంలోని అదే.

381
00:20:29,530 --> 00:20:32,302
>> ప్రేక్షకులు: ఉపకరణం వున్నాయి
మార్చుకోగలిగిన.

382
00:20:32,302 --> 00:20:33,510
>> SPEAKER 1: అవును.

383
00:20:33,510 --> 00:20:36,610
కాబట్టి అప్పుడు ఒక లాంగ్ లాంగ్ డబుల్ ఒక పూర్ణాంకానికి ఉంది.

384
00:20:36,610 --> 00:20:39,250
>> ప్రేక్షకులు: 32 బిట్ ఉంది?

385
00:20:39,250 --> 00:20:40,620
>> SPEAKER 1: 32 బిట్, అవును.

386
00:20:40,620 --> 00:20:43,572
>> ప్రేక్షకులు: సో [వినబడని]?

387
00:20:43,572 --> 00:20:46,790
>> SPEAKER 1: అవును, అది లేనప్పుడు
స్పష్టంగా, మీరు చెప్పే

388
00:20:46,790 --> 00:20:47,870
32 బిట్ భావించాలి.

389
00:20:47,870 --> 00:20:50,040
>> ప్రేక్షకులు: ఇది ఏదో చెబుతా
ఒక ఊహిస్తూ వంటి

390
00:20:50,040 --> 00:20:51,498
ఉపకరణం వలె నిర్మాణం.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 బిట్, మాత్రమే విషయాలు ఆ
మార్పు longs మరియు గమనికలు ఉన్నాయి.

393
00:21:01,710 --> 00:21:05,614
వారు రెండు [వినబడని].

394
00:21:05,614 --> 00:21:06,590
>> SPEAKER 1: అవును?

395
00:21:06,590 --> 00:21:07,566
>> ప్రేక్షకులు: ప్రశ్న.

396
00:21:07,566 --> 00:21:10,982
ఆచరణలో క్విజ్లు ఒకటి కాబట్టి,
అది ఒక Int సైన్ చేయని గురించి అడుగుతుంది.

397
00:21:10,982 --> 00:21:15,374
కాబట్టి ఎలా లెక్కిస్తారు
ఒక పూర్ణాంకానికి [వినబడని] నుండి?

398
00:21:15,374 --> 00:21:18,140
>> SPEAKER 1: ఎన్ సైన్ చేయని
కూడా 4 బైట్లు.

399
00:21:18,140 --> 00:21:21,172
కానీ ఒక సంతకం గురించి వివిధ ఏమిటి
Int మరియు ఒక Int సైన్ చేయని?

400
00:21:21,172 --> 00:21:22,422
>> ప్రేక్షకులు: [వినబడని].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> SPEAKER 1: రైట్.

403
00:21:25,630 --> 00:21:27,570
వన్ ప్రతికూల విలువలను సూచిస్తాయి చేయవచ్చు.

404
00:21:27,570 --> 00:21:28,580
కానీ ఎలా ఆ ఏమి చేస్తుంది?

405
00:21:28,580 --> 00:21:30,536
>> ప్రేక్షకులు: [వినబడని].

406
00:21:30,536 --> 00:21:36,370
>> SPEAKER 1: అవును, అది 1 ఆదా
బిట్ సైన్ సూచించడానికి.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
సంతకం ఒక బిట్ ఉంది
సైన్ సూచిస్తుంది.

409
00:21:45,040 --> 00:21:48,886
మరియు పేరు తెలియని కేవలం అన్ని పాజిటివ్ ఉంది.

410
00:21:48,886 --> 00:21:50,365
>> ప్రేక్షకులు: సరే.

411
00:21:50,365 --> 00:21:54,230
కాబట్టి మీరు ఒక డబుల్ అని చెప్పటానికి
ఒక ఫ్లోట్ రెండుసార్లు పరిమాణం?

412
00:21:54,230 --> 00:21:58,202
>> SPEAKER 1: డబుల్ రెండుసార్లు ఉంది
ఒక ఫ్లోట్ యొక్క పరిమాణం, అవును.

413
00:21:58,202 --> 00:22:01,639
>> ప్రేక్షకులు: ఒక పాయింటర్ చేస్తుంది ఎలా
ఒక దీర్ఘ కాలం [వినబడని]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> SPEAKER 1: ఎలా కాబట్టి ప్రశ్న
ఒక లాంగ్ లాంగ్ పాయింటర్

416
00:22:10,870 --> 00:22:13,800
ఎలా అని మాత్రమే నాలుగు బైట్లు చేసినప్పుడు ఉంది
దాని 8 బైట్లు ఒక లాంగ్ లాంగ్.

417
00:22:13,800 --> 00:22:17,310
కాబట్టి ఒక పాయింటర్ ఉంది ఏమి గుర్తు
ముఖ్యంగా, చాలా బేస్ విలువ వద్ద.

418
00:22:17,310 --> 00:22:19,046
>> ప్రేక్షకులు: [వినబడని].

419
00:22:19,046 --> 00:22:22,670
>> SPEAKER 1: అవును, కాబట్టి ఒక పాయింటర్
కేవలం మెమరీ స్థానం.

420
00:22:22,670 --> 00:22:28,040
కనుక ఇది ఎంత ఖాళీ పట్టింపు లేదు
ఆ పాయింటర్ కు సూచిస్తుంది.

421
00:22:28,040 --> 00:22:32,060
ఇది మాత్రమే ట్రాక్ 4 బైట్లు కావాలి
ఆ మెమరీ స్థానం యొక్క.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
ఏదైనా ఇతర ప్రశ్నలు?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
కూల్.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> గత విషయం నేను కలిగి
ప్రామాణిక అవుట్పుట్ ఉంది.

428
00:22:47,460 --> 00:22:51,020
మీరు తరచుగా వాటిని ఉపయోగించాలి
మీరు గుర్తు చేసే తగినంత.

429
00:22:51,020 --> 00:22:54,800
మేము ఉపయోగించినప్పుడు కానీ ఈ ఉంది
printf, ఉదాహరణకు.

430
00:22:54,800 --> 00:22:59,260
మరియు మేము ఈ కలిగి placeholders కలిగి
ఫార్మాట్ సంకేతాలు పిలిచారు.

431
00:22:59,260 --> 00:23:03,910
>> కాబట్టి Int శాతం సి చార్ శాతం నేను,
మరియు మేము కూడా శాతం d ఉపయోగించవచ్చు.

432
00:23:03,910 --> 00:23:05,130
ఇది అదే విషయం.

433
00:23:05,130 --> 00:23:08,200
కానీ, సాధారణంగా, లో CS50 మేము
శాతం నేను ఉపయోగించడానికి ప్రయత్నించండి.

434
00:23:08,200 --> 00:23:09,860
ఫ్లోట్ శాతం ఎఫ్.

435
00:23:09,860 --> 00:23:15,620
దీర్ఘ కాలం శాతం LD మరియు
స్ట్రింగ్ శాతం లు.

436
00:23:15,620 --> 00:23:18,550
>> అదేవిధంగా, మేము కొన్ని ఉపయోగించి పరిష్కరించగలుగుతున్నాము
ఈ ఎస్కేప్ సన్నివేశాలు.

437
00:23:18,550 --> 00:23:22,431
ఉదాహరణకు, బాక్ స్లాష్ n లకు కొత్త లైన్ కోసం.

438
00:23:22,431 --> 00:23:26,910
ఈ మీరు ఫార్మాటింగ్ చేసినప్పుడు కేవలం ఉంది
ముద్రణ F మీ కోడ్.

439
00:23:26,910 --> 00:23:27,260
అవును?

440
00:23:27,260 --> 00:23:28,906
>> ప్రేక్షకులు: శాతం d ఏం ఉంది?

441
00:23:28,906 --> 00:23:31,850
>> SPEAKER 1: సో ప్రశ్న
శాతం d ఏమి ఉంది?

442
00:23:31,850 --> 00:23:33,270
శాతం d ints కోసం ఉంది.

443
00:23:33,270 --> 00:23:37,392
శాతం d మరియు శాతం నేను ఒకటే.

444
00:23:37,392 --> 00:23:41,130
>> ప్రేక్షకులు: మధ్య తేడా ఏమిటి
బాక్ స్లాష్ n మరియు బాక్ స్లాష్ R?

445
00:23:41,130 --> 00:23:45,300
>> SPEAKER 1: సో ప్రశ్న ఏమిటి
ఎదురుదెబ్బ n మరియు మధ్య తేడా

446
00:23:45,300 --> 00:23:48,615
ఎదురుదెబ్బ R?

447
00:23:48,615 --> 00:23:50,906
నేను బాక్ స్లాష్ R అనుకుంటున్నాను is--

448
00:23:50,906 --> 00:23:54,340
>> ప్రేక్షకులు: సో బాక్ స్లాష్ R కేవలం సూచిస్తుంది
లైన్ ప్రారంభానికి తిరిగి

449
00:23:54,340 --> 00:23:56,670
నిజానికి ఒక కొత్త లైన్ వెళుతున్న లేకుండా.

450
00:23:56,670 --> 00:24:01,000
సో మీరు ఒక బాక్ స్లాష్ R ప్రింట్ మరియు మీరు ఉంటే
లైన్ ప్రారంభానికి తిరిగి వెళ్ళడానికి

451
00:24:01,000 --> 00:24:04,005
అప్పుడు మీరు తిరిగి రాస్తుంది మరింత stuff ప్రింట్
ఇప్పటికే stuff ఆ

452
00:24:04,005 --> 00:24:04,390
[వినబడని].

453
00:24:04,390 --> 00:24:06,725
అయితే, N అసలైన కొత్త వెళ్తాడు
లైన్ మరియు [వినబడని] వెళ్తాడు.

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> SPEAKER 1: బాగా, ఏ ఇతర ప్రశ్నలు?

456
00:24:13,915 --> 00:24:15,430
అన్ని కుడి.

457
00:24:15,430 --> 00:24:18,617
నేను దానిని ఆఫ్ చేతితో వెళుతున్న
Continue అవుతుంది డాన్.

458
00:24:18,617 --> 00:24:25,078
>> [చప్పట్లు]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN: అన్ని righty.

461
00:25:09,720 --> 00:25:18,590
నేను మరొక వెడల్పు గురించి మాట్లాడటం అవుతారు
అని తరగతి నుండి ఆలోచనలను పరిధి

462
00:25:18,590 --> 00:25:23,220
సుమారు వారం రెండు ప్రతినిధి మరియు
వారం మూడు ప్రారంభంలో ఆఫ్ మొదలు

463
00:25:23,220 --> 00:25:28,690
కేవలం ఒక మార్గం ఉంది దీనిలో కాస్టింగ్ తో
ఒక నిర్దిష్ట రకం విలువ వంటి చికిత్స

464
00:25:28,690 --> 00:25:30,830
వేరే రకం విలువ.

465
00:25:30,830 --> 00:25:34,110
కాబట్టి మేము అక్షరాలు తో చేయవచ్చు
ints, ints కు తేలియాడే మరియు

466
00:25:34,110 --> 00:25:35,360
దీర్ఘ longs రెట్టింపు.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> ఈ విషయాలు అన్ని విధాలుగా ఉపయోగించవచ్చు
కొన్ని సంఖ్యా విలువ చికిత్స యొక్క

469
00:25:44,500 --> 00:25:48,370
కొన్ని ఇతర మైనస్ చార్
సంఖ్యా విలువ.

470
00:25:48,370 --> 00:25:54,480
కొన్ని సమస్యలు ఈ తో ఉన్నాయి కాబట్టి
మీరు వేసిన ఉన్నప్పుడు వస్తుంది కోర్సు,

471
00:25:54,480 --> 00:25:57,860
ints కు ఫ్లోట్ వంటి విషయాలు.

472
00:25:57,860 --> 00:26:00,500
కాబట్టి ఈ కొద్దిగా అదృష్టము ఉంది.

473
00:26:00,500 --> 00:26:03,170
మేము 1.31 అని ఒక ఫ్లోట్ కలిగి.

474
00:26:03,170 --> 00:26:05,220
మేము 10,000 ద్వారా గుణిస్తారు.

475
00:26:05,220 --> 00:26:08,380
మరియు తర్వాత మేము ఒక పూర్ణాంకానికి గా ప్రింట్.

476
00:26:08,380 --> 00:26:09,630
ఈ కృషిని ఏమి చేస్తుంది?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 సార్లు 1.31.

479
00:26:14,020 --> 00:26:18,761
కాబట్టి 13,000 అనుకుంటారో?

480
00:26:18,761 --> 00:26:20,685
>> ప్రేక్షకులు: నేను 10,000 భావిస్తున్నాను.

481
00:26:20,685 --> 00:26:24,234
>> DAN: సో నేను 10,000 గుణించడం చేస్తున్నాను
నేను కాస్టింగ్ చేస్తున్నాను ముందు.

482
00:26:24,234 --> 00:26:25,202
>> ప్రేక్షకులు: ఓహ్.

483
00:26:25,202 --> 00:26:27,622
అక్కడ ఒక 9 కాదు
మరియు కొన్ని 0 సంఖ్యలు?

484
00:26:27,622 --> 00:26:29,270
>> డాన్: మీరు కొన్ని విచిత్రమైన అంకెలు ఉండవచ్చు.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
కాబట్టి కుడి, అది 1.3 సార్లు 10,000 ఉంది.

487
00:26:37,670 --> 00:26:40,040
కాబట్టి ఆ 13,000 ఉంది.

488
00:26:40,040 --> 00:26:41,313
మరియు ఈ అదనపు అసహజ

489
00:26:41,313 --> 00:26:42,160
>> ప్రేక్షకులు: 13,100.

490
00:26:42,160 --> 00:26:42,650
>> డాన్: 13,100.

491
00:26:42,650 --> 00:26:44,910
రాబ్ ధన్యవాదాలు.

492
00:26:44,910 --> 00:26:46,610
మరియు ఈ అదనపు weirdness--

493
00:26:46,610 --> 00:26:48,060
ఈ 9,9--

494
00:26:48,060 --> 00:26:53,860
కేవలం ఈ కాస్టింగ్ ఎందుకంటే
ముగించారు డౌన్ ఇక్కడ చుట్టుముట్టే

495
00:26:53,860 --> 00:26:55,394
ఇది ఉండకూడదు.

496
00:26:55,394 --> 00:26:55,871
అవును.

497
00:26:55,871 --> 00:26:58,256
>> ప్రేక్షకులు: కాస్టింగ్ జరుగుతుంది
ఏదైనా తర్వాత?

498
00:26:58,256 --> 00:27:03,865
>> DAN: ఎందుకంటే నేను అది ముద్రణలో ఈ కలిగి
ఇది ముందు ఈ గుణకారం చేస్తుంది

499
00:27:03,865 --> 00:27:05,230
ఈ కాస్టింగ్ లేదు.

500
00:27:05,230 --> 00:27:06,140
>> ప్రేక్షకులు: [వినబడని].

501
00:27:06,140 --> 00:27:11,350
>> డాన్: నేను, అది మొదటి నటించారు అనుకుంటున్నాను
అవును, 10,000 ఇది ఉంటుంది.

502
00:27:11,350 --> 00:27:12,610
ఏదైనా?

503
00:27:12,610 --> 00:27:13,330
కూల్.

504
00:27:13,330 --> 00:27:16,344
కాబట్టి ఈ 13.099 ఉంది.

505
00:27:16,344 --> 00:27:17,840
ఎందుకు ఈ ఏర్పడుతుందా?

506
00:27:17,840 --> 00:27:18,900
ఖచ్చితంగా చెప్పలేని.

507
00:27:18,900 --> 00:27:21,020
>> తేలియాడుతున్న సరైనవి కావు.

508
00:27:21,020 --> 00:27:27,550
వారు మాత్రమే సంఖ్యలు ప్రాతినిధ్యం చేయవచ్చు
ముఖ్యమైన సంఖ్యలు కొన్ని సంఖ్య.

509
00:27:27,550 --> 00:27:35,120
మేము 8 SIG అత్తి పండ్లను ముద్రించాలా చేస్తే
ఈ ఫ్లోట్, మేము ఒక రకం పొందండి

510
00:27:35,120 --> 00:27:36,800
అగ్లీ చూస్తున్న సంఖ్య.

511
00:27:36,800 --> 00:27:45,580
ఎందుకంటే మరియు ఆ 1.31 ఖచ్చితంగా కాదు
సాధారణ ద్వారా ప్రాతినిధ్యం

512
00:27:45,580 --> 00:27:49,000
యంత్రం రెండు శక్తులు.

513
00:27:49,000 --> 00:27:53,530
అది సన్నిహిత తీసుకొని ముగుస్తుంది కాబట్టి
ఇది ముగుస్తుంది, అంచనా

514
00:27:53,530 --> 00:27:55,710
ఒక కొద్దిగా తక్కువ ఉండటం.

515
00:27:55,710 --> 00:27:57,730
సమంజసం?

516
00:27:57,730 --> 00:27:59,110
సరే.

517
00:27:59,110 --> 00:28:05,840
>> ఇప్పుడు స్విచ్ యొక్క వేరొక మార్గం
నియత ప్రకటనలు అన్ని చేయడం

518
00:28:05,840 --> 00:28:09,900
మేము ఒక వేరియబుల్ ఉంది పట్టించుకోనట్లు.

519
00:28:09,900 --> 00:28:16,570
కాబట్టి ఈ ప్రత్యేక ఉదాహరణ, మేము ఉన్నాము
వినియోగదారు నుండి ఒక పూర్ణ పొందడానికి.

520
00:28:16,570 --> 00:28:21,070
మరియు తర్వాత మేము వద్ద చూస్తున్న
ఆ పూర్ణాంక ఏమిటి.

521
00:28:21,070 --> 00:28:23,500
బహుశా, అది సంఖ్య వార్తలు
ఒక మరియు నాలుగు మధ్య.

522
00:28:23,500 --> 00:28:24,800
ఆ మేము కోరుతూ ఏమి ఉంది.

523
00:28:24,800 --> 00:28:28,450
>> సో మీరు ఒక స్విచ్ చేయండి
వేరియబుల్ పేరు.

524
00:28:28,450 --> 00:28:34,290
అప్పుడు మీరు వీలైనంత కేసులు ఏర్పాటు
అది కావచ్చు కట్టారు.

525
00:28:34,290 --> 00:28:37,730
కాబట్టి ఒక సందర్భంలో, అది తక్కువ చెప్పాలి.

526
00:28:37,730 --> 00:28:41,080
ఆపై మీరు పొందడానికి బ్రేక్
స్విచ్ పరిస్థితి అలా

527
00:28:41,080 --> 00:28:43,270
మీరు కొనసాగించడాన్ని లేదు.

528
00:28:43,270 --> 00:28:44,830
>> తదుపరి సందర్భంలో

529
00:28:44,830 --> 00:28:46,940
కాబట్టి కేసు రెండు మరియు సందర్భంలో three--

530
00:28:46,940 --> 00:28:51,920
అది సందర్భంలో రెండు అయితే అది డౌన్ పడిపోతుంది
దానితో గా చూస్తాడు కోడ్ మొదటి లైన్

531
00:28:51,920 --> 00:28:55,400
అది ఒక విరామం చూస్తాడు వరకు మూడు కేసు.

532
00:28:55,400 --> 00:29:00,430
కాబట్టి కారణం మీకు కేసు ఒక పొందండి
మాత్రమే ప్రింట్ తక్కువ నేను ఎందుకంటే

533
00:29:00,430 --> 00:29:01,890
ఇక్కడ ఈ విరామం ఉంటుంది.

534
00:29:01,890 --> 00:29:05,360
నేను చేస్తే, సే, ఈ break-- నిర్లక్ష్యం
నేను ఈ breakaway-- విసిరారు ఉంటే

535
00:29:05,360 --> 00:29:09,740
ఇది తక్కువ ప్రింట్ చేస్తుంది, మరియు అప్పుడు అది చేస్తాను
మధ్యలో ప్రింట్ మరియు అప్పుడు అది బ్రేక్ చేస్తుంది.

536
00:29:09,740 --> 00:29:12,200
>> విరామాలు ఒక ముఖ్యమైన భాగంగా ఉన్నాయి కాబట్టి
పరిస్థితులు మారి

537
00:29:12,200 --> 00:29:14,340
వారు అక్కడ ఉండాలి.

538
00:29:14,340 --> 00:29:20,070
వివరంగా చెప్పింది లేని ఏ కేసులు
అప్రమేయంగా పరిష్కరించే

539
00:29:20,070 --> 00:29:26,645
మరియు స్విచ్ కేసు వేసిన చేయాలి.

540
00:29:26,645 --> 00:29:31,363
>> ప్రేక్షకులు: సో 1, 2, 3,
మరియు 4 లేదా ఉంటుంది?

541
00:29:31,363 --> 00:29:33,310
>> DAN: N ఉండాలనే విలువలు.

542
00:29:33,310 --> 00:29:34,654
అవును.

543
00:29:34,654 --> 00:29:35,146
అవును?

544
00:29:35,146 --> 00:29:37,606
>> ప్రేక్షకులు: సో మీరు కలిగి ఉన్నప్పుడు
[వినబడని]?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> డాన్: మీరు తక్కువ తర్వాత ప్రింట్, మరియు
అది మధ్యలో ప్రింట్, మరియు

547
00:29:46,830 --> 00:29:47,400
అప్పుడు అది విచ్ఛిన్నం చేస్తుంది.

548
00:29:47,400 --> 00:29:50,244
>> ప్రేక్షకులు: ఎందుకు అది ప్రింట్ చేస్తుంది
మధ్యలో ఉంటే [వినబడని]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> డాన్: కేసు కింద ప్రతిదీ
విరామం కింద పడిపోతుంది ముందు.

551
00:30:00,550 --> 00:30:09,390
కాబట్టి కేసు ఒక ముద్రణ కింద కేసు
ఒకటి ఈ క్రింది ముద్రణ ఉంది.

552
00:30:09,390 --> 00:30:09,890
అవును?

553
00:30:09,890 --> 00:30:11,140
>> ప్రేక్షకులు: [వినబడని]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN: సో ఈ సంఖ్య కేవలం ఒక నిర్దిష్ట ఉంది
విలువ ఈ వేరియబుల్

556
00:30:22,170 --> 00:30:23,420
కుడి, పట్టవచ్చు?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
ఆ సమంజసం లేదు?

559
00:30:28,490 --> 00:30:28,990
అవును.

560
00:30:28,990 --> 00:30:31,490
>> ప్రేక్షకులు: [వినబడని]?

561
00:30:31,490 --> 00:30:34,130
>> డాన్: అవును, కేసు రెండు ప్రింట్ చేస్తుంది
మధ్య మరియు తరువాత విడిపోయారు.

562
00:30:34,130 --> 00:30:35,380
>> ప్రేక్షకులు: [వినబడని]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> డాన్: నేను ఏ భావిస్తున్నారా?

565
00:30:40,050 --> 00:30:43,855
ఏం ఇతర డేటా రకాల
మీరు మారవచ్చు?

566
00:30:43,855 --> 00:30:46,320
>> ప్రేక్షకులు: మీరు మారవచ్చు
ఏ డేటా రకాల.

567
00:30:46,320 --> 00:30:50,905
కానీ అది మాత్రమే అక్షరాలు పైగా ఏదైనా అర్థం
మరియు ints వంటి విషయాలను ఎందుకంటే

568
00:30:50,905 --> 00:30:55,600
మీరు ఒక పాయింటర్ మారే చేస్తుంటే
నిజంగా, అర్ధవంతం లేదు

569
00:30:55,600 --> 00:30:59,555
అది కూడా వీలు ఉంటే, లోడ్లు మారే
మీరు ఎందుకంటే ఫ్లోటింగ్ పాయింట్, అలా

570
00:30:59,555 --> 00:31:02,840
PRECISION లో, మీరు నిజంగా చెప్పమంటారా
ఏమైనప్పటికీ ఆ చేయాలనుకుంటున్నారా.

571
00:31:02,840 --> 00:31:07,320
కాబట్టి అందంగా చాలా, కేవలం ints మరియు
ఆ వంటి అక్షరాలు మరియు stuff.

572
00:31:07,320 --> 00:31:12,360
>> డాన్: మీరు స్పష్టమైన ఉన్నప్పుడు అవును, అది వార్తలు
మీకు తెలిసిన విలువలు, నేను అనుకుంటున్నాను, ఉంటుంది

573
00:31:12,360 --> 00:31:14,250
ఒక స్విచ్ వాస్తవానికి ఉపయోగపడుతుంది.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
గుడ్?

576
00:31:18,990 --> 00:31:21,370
సరే.

577
00:31:21,370 --> 00:31:26,180
>> స్కోప్ ప్రకటించిన ఆ పరిధిలో ఉంది
వేరియబుల్ విస్తరించింది.

578
00:31:26,180 --> 00:31:32,190
నేను కలిగి కోడ్ యొక్క ఈ చిన్న భాగం కాబట్టి,
ఇది లోపాలను పూర్తి అవుతుంది.

579
00:31:32,190 --> 00:31:41,450
మరియు కారణం నేను ఈ Int ప్రకటించుకుంది
నేను లూప్ ఈ పరిధిలో.

580
00:31:41,450 --> 00:31:46,390
ఆపై నేను ప్రస్తావించడానికి దీనికై
నేను లూప్ ఆస్కారం ఆ వెలుపల.

581
00:31:46,390 --> 00:31:50,330
>> కాబట్టి ప్రాథమికంగా, మీరు పరిధిని గురించి ఆలోచించవచ్చు
మీరు ప్రకటించాలని ఏదైనా

582
00:31:50,330 --> 00:31:59,750
గిరజాల జంట కలుపులు సమితి లోపల మాత్రమే
ఆ గిరజాల జంట కలుపులు లోపల ఉంది.

583
00:31:59,750 --> 00:32:04,990
మరియు మీరు ప్రయత్నించండి మరియు ఆ వేరియబుల్ ఉపయోగిస్తే
ఆ గిరజాల జంట కలుపులు బయట, మీరు చేస్తాము

584
00:32:04,990 --> 00:32:08,356
కంపైలర్ నుండి లోపం.

585
00:32:08,356 --> 00:32:08,812
అవును?

586
00:32:08,812 --> 00:32:09,724
>> ప్రేక్షకులు: సో ఈ ఒక పని లేదు?

587
00:32:09,724 --> 00:32:11,790
>> డాన్: అవును ఈ పని లేదు.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
తీగలను.

590
00:32:18,660 --> 00:32:19,780
స్ట్రింగ్ ఒక చార్ * ఉంది.

591
00:32:19,780 --> 00:32:22,250
వారు అదే ఉన్నారు.

592
00:32:22,250 --> 00:32:25,540
వారు కేవలం అక్షరాలు గమనికలు ఉన్నాయి.

593
00:32:25,540 --> 00:32:33,000
మరియు మీరు ఏ తీగలను అంతం చేయాలి
కేవలం ఇది బాక్ స్లాష్ సున్నా తో

594
00:32:33,000 --> 00:32:34,410
ఒక సి సమావేశం.

595
00:32:34,410 --> 00:32:36,680
>> ఇది NULL టెర్మినేటర్ అంటారు.

596
00:32:36,680 --> 00:32:39,050
మరియు శూన్య

597
00:32:39,050 --> 00:32:41,670
రాజధాని N, రాజధాని U, రాజధాని
ఎల్, రాజధాని L--

598
00:32:41,670 --> 00:32:44,290
అదే కాదు
NULL టెర్మినేటర్.

599
00:32:44,290 --> 00:32:46,640
ఈ ఒక పాయింటర్ ఉంది.

600
00:32:46,640 --> 00:32:48,280
ఈ ఒక పాత్ర.

601
00:32:48,280 --> 00:32:49,530
వారు చాలా వైవిధ్యంగా ఉంటాయి.

602
00:32:49,530 --> 00:32:50,200
ఇది గుర్తుంచుకోండి.

603
00:32:50,200 --> 00:32:52,320
ఇది బహుశా, క్విజ్ ఉంటుంది.

604
00:32:52,320 --> 00:32:54,040
నేను క్విజ్ చూడలేదు.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
అవును?

607
00:32:58,840 --> 00:33:01,232
>> ప్రేక్షకులు: సో నల్ పాయింటర్, సే?

608
00:33:01,232 --> 00:33:01,995
>> డాన్: అవును.

609
00:33:01,995 --> 00:33:05,170
>> ప్రేక్షకులు: [వినబడని] చేస్తుంది?

610
00:33:05,170 --> 00:33:10,050
>> DAN: చెప్పుకోవాలంటే, malloc అని ఉన్నప్పుడు మీరు
పొందుటకు తగినంత మెమరీ లేదు

611
00:33:10,050 --> 00:33:14,400
సంసార మీరు కోరుతూ చేస్తున్న పరిమాణం,
malloc శూన్య చూపిస్తుంది.

612
00:33:14,400 --> 00:33:19,550
ఒక ఫంక్షన్ ఉంది చేసినప్పుడు ఇది ప్రాథమికంగా, వార్తలు
ఒక పాయింటర్ తిరిగి చేయాలో, మీరు

613
00:33:19,550 --> 00:33:22,600
NULL ఎందుకంటే వ్యతిరేకంగా తనిఖీ చెయ్యాలి
నల్ ఒక అందమైన good-- ఉంది

614
00:33:22,600 --> 00:33:25,260
ఇది విధమైన, చెత్త విలువ ఏమిటి.

615
00:33:25,260 --> 00:33:27,050
ఇది చాలా గమనికలు వెళ్ళి ఒక సున్నా ఉంది.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> ఎప్పుడు మీరు ఒక ఫంక్షన్ కాల్,
ఒక పాయింటర్ తిరిగి.

618
00:33:32,250 --> 00:33:35,960
మీరు ఉండాలి చెక్ అనుకుంటున్నారా చూడాలని
ఆ పాయింటర్ NULL కాదని ఖచ్చితంగా

619
00:33:35,960 --> 00:33:37,760
నల్ చాలా సాధారణ ఎందుకంటే.

620
00:33:37,760 --> 00:33:40,160
ఇది ఒక చెత్త తిరిగి విధమైన ఉంది.

621
00:33:40,160 --> 00:33:44,902
ఏదో కుడి వెళ్ళలేదు కనుక,
కేవలం బదులుగా NULL తిరిగి.

622
00:33:44,902 --> 00:33:45,898
>> ప్రేక్షకులు: [వినబడని]?

623
00:33:45,898 --> 00:33:48,922
>> డాన్: అవును, మరియు ఈ ఉంది.

624
00:33:48,922 --> 00:33:51,750
>> ప్రేక్షకులు: [వినబడని]?

625
00:33:51,750 --> 00:33:52,800
>> DAN: ఈ గా స్పెల్.

626
00:33:52,800 --> 00:33:54,150
ఇది NULL టెర్మినేటర్ వార్తలు.

627
00:33:54,150 --> 00:33:56,560
ఇది చిన్న N-U-L-L ఉంటే వార్తలు
మీరు స్పెల్లింగ్ చేస్తున్నారు.

628
00:33:56,560 --> 00:33:59,860
>> ప్రేక్షకులు: నేను వెళ్ళింది
తిరిగి మరియు అది పరీక్షించారు.

629
00:33:59,860 --> 00:34:03,010
మరియు మీరు ఒక ఫ్లోటింగ్ పాయింట్ ఉంచాలి ప్రయత్నించండి ఉంటే
ఒక స్విచ్ లోకి విలువ, అది మీరు అరుస్తుంటారు చేస్తాము

630
00:34:03,010 --> 00:34:05,916
మాట్లాడుతూ, ప్రకటన వ్యక్తీకరణ అవసరం
పూర్ణాంక రకమైన.

631
00:34:05,916 --> 00:34:07,166
>> డాన్: అక్కడ మీరు వెళ్ళండి.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
కానీ అవును, ప్రశ్న మళ్ళీ ఏమి ఉంది?

634
00:34:12,246 --> 00:34:13,496
>> ప్రేక్షకులు: [వినబడని]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> డాన్: సో రాజధాని N, రాజధాని U, రాజధాని
ఎల్, రాజధాని L ఒక వాస్తవ సి విషయం.

637
00:34:23,679 --> 00:34:29,719
ఇది నల్ పాయింటర్ మరియు రెడీ
మాత్రమే వంటి చికిత్స సాధ్యం.

638
00:34:29,719 --> 00:34:33,530
మీరు ఎప్పుడూ ప్రయత్నించండి మరియు అక్షరక్రమ లేదు
NULL పాత్ర మరియు ఏ చూడండి

639
00:34:33,530 --> 00:34:35,630
ఈ కంటే ఇతర మార్గం.

640
00:34:35,630 --> 00:34:36,610
అవును?

641
00:34:36,610 --> 00:34:42,490
>> ప్రేక్షకులు: సో మాక్స్ చార్ తిరిగి లేదా
గమనికలు ఏదో చేస్తాను

642
00:34:42,490 --> 00:34:43,960
అదే ఫంక్షన్ రూపొందించు
[వినబడని] గా?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> ప్రేక్షకులు: సో మీరు సూచిస్తూ ఉంటాయి
GetChar నుండి చార్ మాక్స్ తిరిగి, లేదా

645
00:34:54,949 --> 00:34:55,444
సంసార అది?

646
00:34:55,444 --> 00:34:55,940
>> ప్రేక్షకులు: అవును.

647
00:34:55,940 --> 00:34:58,620
>> ప్రేక్షకులు: అవును, సాధారణ కాబట్టి
అన్ని ఆ విషయాలు పదం

648
00:34:58,620 --> 00:34:59,920
కాపలాదారుడు విలువలు.

649
00:34:59,920 --> 00:35:03,640
కాబట్టి GetInt నుండి Int మాక్స్ తిరిగి వంటి
మరియు GetChar నుండి చార్ మాక్స్, అది వార్తలు

650
00:35:03,640 --> 00:35:06,010
అన్ని హక్కు వంటి రావలసిన
ఈ విషయాలు మాకు తిరిగి ఉంటాయి

651
00:35:06,010 --> 00:35:07,210
ఏదో తప్పు జరిగింది.

652
00:35:07,210 --> 00:35:09,950
>> గమనికలు, మేము కేవలం కలిగి జరిగే
ఈ కాపలాదారుడు విలువ అని అందరికీ

653
00:35:09,950 --> 00:35:10,750
మీద అంగీకరిస్తాడు.

654
00:35:10,750 --> 00:35:13,210
మరియు ఈ మీరు తిరిగి విషయం
విషయాలు తప్పు.

655
00:35:13,210 --> 00:35:15,910
కాబట్టి చార్ మాక్స్ మేము ఉపయోగించి ఏమి ఉంది
ఏదో ప్రాతినిధ్యం

656
00:35:15,910 --> 00:35:18,100
NULL లేదా GetChar ఇష్టపడుతున్నారు.

657
00:35:18,100 --> 00:35:23,420
>> ప్రేక్షకులు: మీరు GetChar టెస్టింగ్ చేస్తున్నారు చేస్తే,
మీరు నిరర్థక చాలు కాలేదు?

658
00:35:23,420 --> 00:35:23,910
ఒక తేడా చేస్తుంది?

659
00:35:23,910 --> 00:35:25,400
>> డాన్: మీరు నిరర్థక తనిఖీ కాలేదు.

660
00:35:25,400 --> 00:35:30,130
మీరు ఎందుకంటే చార్ మాక్స్ తనిఖీ కలిగి ఇష్టం
ఫంక్షన్ నుండి తిరిగి విలువ ఉంది

661
00:35:30,130 --> 00:35:35,416
ఒక పాత్ర ఒక పాయింటర్ కాదు.

662
00:35:35,416 --> 00:35:35,888
అవును?

663
00:35:35,888 --> 00:35:38,248
>> ప్రేక్షకులు: ఈ ప్రశ్న అడుగుతుంది
స్ట్రింగ్ పొడవు కోసం.

664
00:35:38,248 --> 00:35:40,136
NULL పాత్ర ఉన్నాయి లేదు?

665
00:35:40,136 --> 00:35:41,000
>> DAN: నం

666
00:35:41,000 --> 00:35:45,930
మరియు ఆ ఎలా స్ట్రింగ్ పొడవు నిజానికి వార్తలు
ఇది గుండా వెళుతుంది ఎందుకంటే ఆపడానికి తెలుసు

667
00:35:45,930 --> 00:35:49,070
పాత్రల మీ శ్రేణి వరకు
అది ఒక NULL పాత్ర చూస్తాడు.

668
00:35:49,070 --> 00:35:51,030
మరియు అది అన్ని లాంటిది
కుడి, నేను పూర్తయింది.

669
00:35:51,030 --> 00:35:52,130
>> ప్రేక్షకులు: [వినబడని] అయిదు?

670
00:35:52,130 --> 00:35:53,990
>> డాన్: హలో ఐదు ఉంటుంది.

671
00:35:53,990 --> 00:35:55,240
YEP.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
కాబట్టి శ్రేణుల కొనసాగుతున్నాయి
మెమరీ బ్లాక్లు.

674
00:36:02,880 --> 00:36:08,480
వారు చెప్పి, తక్షణ యాక్సెస్
కర్లీ, అర్రే యొక్క పేరు మరియు అప్పుడు

675
00:36:08,480 --> 00:36:16,720
మీరు వెళ్ళడానికి కావలసిన సూచిక కలుపులు,
, వారు ద్వారా సున్నా నుండి ఇండెక్స్ చేస్తున్నారు

676
00:36:16,720 --> 00:36:20,100
1 మైనస్ శ్రేణి యొక్క పొడవు.

677
00:36:20,100 --> 00:36:23,070
>> మరియు వారు రకం ప్రకటించిన చేస్తున్నారు
మీరు నిల్వ చేస్తున్న విషయం

678
00:36:23,070 --> 00:36:29,750
అర్రే, అర్రే యొక్క పేరు, మరియు అప్పుడు
సంసార పరిమాణంలో ఆ శ్రేణి ఉంది.

679
00:36:29,750 --> 00:36:36,660
కాబట్టి ఈ పొడవు యొక్క ఒక చార్ శ్రేణి
ఈ విలువలు కలిగి ఆరు.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
అవును?

682
00:36:42,700 --> 00:36:43,950
>> ప్రేక్షకులు: [వినబడని]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> డాన్: అవును.

685
00:36:48,460 --> 00:36:51,340
>> ప్రేక్షకులు: [వినబడని]?

686
00:36:51,340 --> 00:36:56,700
>> డాన్: మీరు వెళ్తున్నారు ఏమి ఉంటే
అర్రే లోకి ఇప్పటికే చేసిన.

687
00:36:56,700 --> 00:37:02,260
కాబట్టి మీరు బదులుగా ఈ పేర్కొనవచ్చు అవకాశమున్నందున,
సే, చార్, సంసార పేరు మీ

688
00:37:02,260 --> 00:37:12,200
శ్రేణి ఖాళీగా బ్రాకెట్లలో కర్లీ సమానం, ఉంది
H కామా E కామా L కామా L కామా బ్రేస్

689
00:37:12,200 --> 00:37:16,290
ఓ కామా NULL పాత్ర
మరియు వంకర కలుపు.

690
00:37:16,290 --> 00:37:18,180
కూడా ఒక ప్రకటన పని చేస్తుంది.

691
00:37:18,180 --> 00:37:20,886
>> ప్రేక్షకులు: [వినబడని]?

692
00:37:20,886 --> 00:37:23,110
>> DAN: అప్పుడు మీరు కలిగి ఉండాలి
పరిమాణం ఇప్పటికే చేసిన.

693
00:37:23,110 --> 00:37:23,896
>> ప్రేక్షకులు: [వినబడని]?

694
00:37:23,896 --> 00:37:25,146
>> డాన్: అవును.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
అన్ని righty.

697
00:37:32,420 --> 00:37:36,430
కమాండ్ లైన్ వాదనలు మార్గం
యూజర్ నుండి ఇన్పుట్ పొందడానికి

698
00:37:36,430 --> 00:37:39,380
ప్రధాన వాదనలు.

699
00:37:39,380 --> 00:37:40,600
ప్రధాన రెండు వాదనలు పడుతుంది.

700
00:37:40,600 --> 00:37:47,680
ప్రవర్తిస్తే ఆ వాదనలు సంఖ్య
కమాండ్ లైన్ మరియు ఒక పాటు ఆమోదించేది

701
00:37:47,680 --> 00:37:55,340
స్ట్రింగ్ vector లేదా ఒక స్ట్రింగ్ శ్రేణి
వాదనలు అన్ని.

702
00:37:55,340 --> 00:38:07,840
>> కాబట్టి నేను, సే, వంటి ఒక ఫంక్షన్ అని ఉంటే
1 స్పేస్, 2 స్థలం, మూడు ఒక డాట్,

703
00:38:07,840 --> 00:38:10,110
argc 4 ఉంటుంది.

704
00:38:10,110 --> 00:38:17,370
మరియు argv 0 అవ్ట్ ఒక డాట్ ఉంటుంది.

705
00:38:17,370 --> 00:38:19,130
Argv1 1 ఉంటుంది.

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3 ఉంటుంది ఉంటుంది
3, నిర్దిష్ట సందర్భంలో.

707
00:38:23,030 --> 00:38:23,310
అవును?

708
00:38:23,310 --> 00:38:25,400
>> ప్రేక్షకులు: [వినబడని]?

709
00:38:25,400 --> 00:38:34,010
>> DAN: అర్రే చివరి మూలకం
శ్రేణి పొడవు argc, ఎందుకంటే ప్లస్

710
00:38:34,010 --> 00:38:41,050
argb ఒకటి, గత మూలకం
నల్ పాయింటర్ ఉంది.

711
00:38:41,050 --> 00:38:42,580
అది argc ప్లస్ 1.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
నేను కేవలం అన్నారు, అది ఆ సందర్భంలో కాబట్టి
0 argv అవుతుంది బయటకు ఒక డాట్ ఉంది.

714
00:38:52,150 --> 00:38:56,330
argv 1 1 argv2 3 3 2 argv ఉంది.

715
00:38:56,330 --> 00:39:03,490
ఒక పెద్ద ఇది argv 4,
argc కంటే శూన్య ఉంటుంది.

716
00:39:03,490 --> 00:39:04,870
>> ఆ నల్ పాయింటర్ ఉంది.

717
00:39:04,870 --> 00:39:06,590
అవును.

718
00:39:06,590 --> 00:39:11,250
స్ట్రింగ్ ఎందుకంటే ఆ వార్తలు
ఒక చార్ స్టార్ పాయింటర్ ఉంది.

719
00:39:11,250 --> 00:39:14,102
కాబట్టి ఇది అదే రకం ఉండాలి.

720
00:39:14,102 --> 00:39:14,595
అవును?

721
00:39:14,595 --> 00:39:16,074
>> ప్రేక్షకులు: రెండు ప్రశ్నలు.

722
00:39:16,074 --> 00:39:21,004
ఒక కాబట్టి, తేడా మధ్య ఏమి వార్తలు
ఒక రకం కంటే ఇతర ఈ మరియు GetString

723
00:39:21,004 --> 00:39:22,483
వినియోగదారు ఇంజిన్ లో?

724
00:39:22,483 --> 00:39:25,934
మరియు రెండు, దానిలోని నిల్వ ఉంది
మీ ఇటీవలి మెమరీ?

725
00:39:25,934 --> 00:39:28,399
కాబట్టి వంటి, GetString చేస్తాను
[వినబడని] ఉంటుంది?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> డాన్: ఇది ఎక్కడ నిల్వ చేయబడుతుంది?

728
00:39:33,650 --> 00:39:34,905
ఇది నిల్వ నేను ఎక్కడ తెలియదు.

729
00:39:34,905 --> 00:39:40,000
>> ప్రేక్షకులు: సో, వాస్తవానికి, మీరు ఎలా ఏ తెలుసు
మీరు వాదనలు యొక్క కాల్ పని

730
00:39:40,000 --> 00:39:42,170
స్టాక్ లో నిల్వ చేయబడతాయి?

731
00:39:42,170 --> 00:39:46,610
కాబట్టి argc మరియు argv వాదనలు ప్రధాన ఉంటాయి
మరియు వారు స్టాక్ ఉన్నాయి, లేదా నిజంగా

732
00:39:46,610 --> 00:39:49,131
కేవలం మీరు ఏమనుకుంటున్నారో పైన
స్టాక్ ప్రారంభం.

733
00:39:49,131 --> 00:39:53,490
ఇతర భాగంగా ఏమిటి
ప్రశ్న?

734
00:39:53,490 --> 00:39:56,821
>> ప్రేక్షకులు: సో వాట్ వార్తలు [వినబడని]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: అవును, అది కేవలం వేరే మార్గం
యూజర్ నుండి ఇన్పుట్ పొందడానికి.

736
00:40:00,990 --> 00:40:06,030
ఈ ఒక యొక్క కొద్దిగా మరింత సమర్థవంతంగా మరియు
ఇది స్క్రిప్ట్స్ కోసం handier మీరు ఎందుకంటే

737
00:40:06,030 --> 00:40:10,070
మీ ప్రధాన వాదనలు తరలిస్తారు
ఫంక్షన్ వేచి ఉండటం కంటే

738
00:40:10,070 --> 00:40:13,400
వినియోగదారులు మీరు ఏ వినియోగదారులు లేకపోతే.

739
00:40:13,400 --> 00:40:16,280
>> ప్రేక్షకులు: అవును, తీగలను పొందండి
[వినబడని] ఉంటుంది.

740
00:40:16,280 --> 00:40:17,922
ఇది మీరు అవసరం stuff నిల్వ ఉంటుంది.

741
00:40:17,922 --> 00:40:18,834
>> డాన్: అవును?

742
00:40:18,834 --> 00:40:21,114
>> ప్రేక్షకులు: [వినబడని]?

743
00:40:21,114 --> 00:40:27,545
>> డాన్: అవును, argv 0 ఎప్పుడూ కలిగి
డాట్ ఫంక్షన్ కాల్ స్లాష్.

744
00:40:27,545 --> 00:40:28,042
అవును?

745
00:40:28,042 --> 00:40:29,292
>> ప్రేక్షకులు: [వినబడని]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> డాన్: అవును, వాదనలు ప్రతి ఉన్నాయి
NULL పాత్ర ముగిసింది వారు ఎందుకంటే

748
00:40:37,310 --> 00:40:38,310
తీగలు ఉంటాయి.

749
00:40:38,310 --> 00:40:40,892
>> ప్రేక్షకులు: [వినబడని]?

750
00:40:40,892 --> 00:40:44,116
>> డాన్: అవును, argv argc ఒక నల్ పాయింటర్ ఉంది.

751
00:40:44,116 --> 00:40:45,112
>> ప్రేక్షకులు: [వినబడని]?

752
00:40:45,112 --> 00:40:47,104
>> డాన్: అవును.

753
00:40:47,104 --> 00:40:48,100
అవును, సారీ.

754
00:40:48,100 --> 00:40:49,594
>> ప్రేక్షకులు: సో [వినబడని]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> డాన్: మీరు కలిగి ఉంటే ప్రశ్న కాబట్టి
కమాండ్ లైన్ డాట్, 2, 1 అవుట్ డాట్ స్లాష్

757
00:41:16,340 --> 00:41:20,410
చేస్తాను కమాండ్ లైన్ సంఖ్య
వాదనలు రెండు లేదా అది మూడు ఉంటుంది?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> ప్రేక్షకులు: నేను అది కాదు అనుకుంటున్నాను
నిజంగా పట్టింపు.

760
00:41:28,240 --> 00:41:31,370
నేను OH, మీరు పాస్ లేదు, చెప్పడానికి అవకాశం
ఏ ఆదేశ పంక్తి వాదనలు,

761
00:41:31,370 --> 00:41:32,730
సహజంగా, మీరు ఫంక్షన్ అని.

762
00:41:32,730 --> 00:41:37,950
కాబట్టి నేను విని మినహాయించాలని ఉంటాయి
కమాండ్ లైన్ నుండి ఫంక్షన్

763
00:41:37,950 --> 00:41:40,350
అంతే అయినప్పటికీ వాదనలు
argv చేర్చారు.

764
00:41:40,350 --> 00:41:42,600
>> DAN: కానీ అది test-- గా ఉంటే

765
00:41:42,600 --> 00:41:46,550
yeah-- మరియు కూడా మీరు ఏదో చెప్పుకోవాలంటే
argc 3 సమానం వంటి,

766
00:41:46,550 --> 00:41:48,512
మీరు సురక్షితంగా నిలబడి ఉన్నారు.

767
00:41:48,512 --> 00:41:49,416
అవును?

768
00:41:49,416 --> 00:41:50,666
>> ప్రేక్షకులు: [వినబడని]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> డాన్: నేను బదులుగా ఈ కాల్ అనుకుంటున్నారో
argc మరియు స్ట్రింగ్ argv బ్రాకెట్లలో

771
00:42:09,510 --> 00:42:14,350
కానీ అదే రకాల ఉంచింది మరియు కేవలం అని
ఒక వంటి వివిధ వాటిని ఏదో

772
00:42:14,350 --> 00:42:16,640
అండ్ బి, అది ఇప్పటికీ పని చేస్తుంది?

773
00:42:16,640 --> 00:42:18,790
మరియు అది ఇప్పటికీ పని చేస్తుంది,
మీరు కేవలం ఉంటుంది

774
00:42:18,790 --> 00:42:21,520
బదులుగా argc-- ఉపయోగించి
మీరు ఒక అండ్ బి ఉపయోగించడానికి ఇష్టం.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
అవును?

777
00:42:25,408 --> 00:42:26,658
>> ప్రేక్షకులు: [వినబడని]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> డాన్: ప్రశ్న కాబట్టి GetString ఉంది
కుప్ప మెమరీ కొట్టుకు వెళ్లి

780
00:42:38,850 --> 00:42:42,280
GetString చార్ * ఎందుకంటే.

781
00:42:42,280 --> 00:42:47,530
ఇది ఎందుకంటే కుప్ప మెమరీ నిల్వ
అసలు లోపల ఇప్పుడు malloc పిలుపు

782
00:42:47,530 --> 00:42:49,258
GetString యొక్క అమలు.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
సరే, వెళ్లడానికి.

785
00:42:55,090 --> 00:42:55,950
>> సెక్యూరిటీ.

786
00:42:55,950 --> 00:43:01,090
కాబట్టి నిజంగా సురక్షితమైనది, మీరు ఏ ఆధారపడి
ఒక మరియు మీరు ఏ ఎవరూ యాక్సెస్ అనుమతిస్తుంది

787
00:43:01,090 --> 00:43:04,540
మీ సమాచారం, ఇది ఎందుకు
ప్రతి ఒక్కరూ తమ సొంత బైక్కులకు

788
00:43:04,540 --> 00:43:09,580
వారి స్వంత ఆపరేటింగ్ వ్యవస్థలు, వారి
మొదటి నుండి కార్యక్రమాలు, మరియు స్పష్టంగా

789
00:43:09,580 --> 00:43:13,410
ఏ ఇతర యంత్రాలు కనెక్ట్ లేదు
ఇంటర్నెట్ ద్వారా.

790
00:43:13,410 --> 00:43:17,350
కాబట్టి కంప్యూటర్లు అసురక్షిత.

791
00:43:17,350 --> 00:43:19,200
వారు నిజంగా ఉంటాయి.

792
00:43:19,200 --> 00:43:20,940
మేము ఇతర వ్యక్తులు విశ్వసించాలని ఉన్నాయి.

793
00:43:20,940 --> 00:43:26,500
>> మరియు సెక్యూరిటీ ఆలోచన మీరు ఉన్నాము అని
మొత్తం పరిమితం ప్రయత్నిస్తున్న

794
00:43:26,500 --> 00:43:27,540
మీరు అవసరమైన విశ్వాసం.

795
00:43:27,540 --> 00:43:32,080
మరియు మార్గాల ఒక మీరు అలా
గూఢ ద్వారా.

796
00:43:32,080 --> 00:43:34,950
క్రిప్టోగ్రఫీ, ముఖ్యంగా, ఉంది
మేము సీక్రెట్స్ ఉన్నాయి.

797
00:43:34,950 --> 00:43:38,880
>> కొన్నిసార్లు మేము మా రహస్యాలు పాస్
పాటు ద్వారా, సే, ఇంటర్నెట్ లేదా

798
00:43:38,880 --> 00:43:39,980
ఇతర విషయాలు.

799
00:43:39,980 --> 00:43:43,180
మరియు మేము ప్రజలు వద్దు
ఈ రహస్యాలు తెలుసు.

800
00:43:43,180 --> 00:43:50,100
కాబట్టి మేము ఒక మార్గం లోకి మా రహస్యాలు గుప్తీకరించడానికి
మేము ఎవరూ దొరుకుతుందని చేయవచ్చు ఆశిస్తున్నాము.

801
00:43:50,100 --> 00:43:51,600
>> కాబట్టి మేము used--

802
00:43:51,600 --> 00:43:54,340
ఈ class-- కోర్సు ద్వారా

803
00:43:54,340 --> 00:44:00,750
సీజర్ సాంకేతికలిపి వంటి విషయాలు మరియు
రెండు చాలా, చాలా ఇవి [వినబడని],

804
00:44:00,750 --> 00:44:03,200
విషయాలు ఎన్క్రిప్ట్ యొక్క అసురక్షిత మార్గాలు.

805
00:44:03,200 --> 00:44:07,930
వారు బయటకు దొరుకుతుందని సులభం ఏమి చేస్తున్నామో వారు
మరియు మీ రహస్యాలు ఏమిటి.

806
00:44:07,930 --> 00:44:12,130
వాస్తవ ప్రపంచంలో ఎక్కువ ఉపయోగించే
సంక్లిష్టమైన ఎన్క్రిప్షన్ పథకాలు.

807
00:44:12,130 --> 00:44:13,880
మరియు మేము లోకి అందదు
కంటే ఎక్కువ.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> డీబగ్గింగ్.

810
00:44:19,430 --> 00:44:20,785
GDB ఉత్తమ ఉంది.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
నేను మళ్ళీ ఈ ఒత్తిడి వెళుతున్న.

813
00:44:25,810 --> 00:44:30,920
GDB అన్ని సమయం ప్రతి ఉపయోగించండి
సమయం మీరు ఒక సమస్య.

814
00:44:30,920 --> 00:44:36,030
GDB లో ఉపయోగపడతాయి ఆ ఆదేశాలు ఉన్నాయి
మీరు ఒక అనో పాస్, విచ్ఛిన్నం

815
00:44:36,030 --> 00:44:41,330
సంఖ్య, ఒక ఫంక్షన్ పేరు, తప్పనిసరిగా
ఇక్కడ మీ కోడ్ లో మీరు ఆపడానికి కావలసిన,

816
00:44:41,330 --> 00:44:45,600
మరియు నియంత్రణ తీసుకోవాలని చెయ్యగలరు.

817
00:44:45,600 --> 00:44:54,140
>> ప్రింట్ ఒక వేరియబుల్ పడుతుంది మరియు అవుట్ ముద్రిస్తుంది
ఆ వేరియబుల్ వద్ద ఉండే వస్తువు

818
00:44:54,140 --> 00:44:55,990
మీ మరణశిక్ష పాయింట్.

819
00:44:55,990 --> 00:45:00,130
తర్వాత మీ మరణశిక్ష కదులుతుంది
ఒక అడుగు పాటు.

820
00:45:00,130 --> 00:45:05,050
మరియు ఒక ఫంక్షన్ లోపల సోపానాలు
మీ అమలు.

821
00:45:05,050 --> 00:45:10,480
>> ఇతర విషయాలు ఎంత ఉంది, నడపబడుతున్నాయి
మీరు నిజంగా మీ కోడ్ అమలు.

822
00:45:10,480 --> 00:45:16,630
కొనసాగించు అవసరమైన అన్ని చర్యలు తీసుకుంటుంది
తదుపరి బ్రేక్ పాయింట్ చెయ్యడానికి.

823
00:45:16,630 --> 00:45:18,300
మరియు అనేక, అనేక ఇతరులు ఉన్నాయి.

824
00:45:18,300 --> 00:45:19,040
వాటిని వెదకండి.

825
00:45:19,040 --> 00:45:19,901
వారు గొప్ప ఉన్నాము.

826
00:45:19,901 --> 00:45:20,863
అవును?

827
00:45:20,863 --> 00:45:22,113
>> ప్రేక్షకులు: [వినబడని]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> డాన్: అవును, ఒక డీబగ్గర్ ఇది.

830
00:45:28,200 --> 00:45:34,230
కాబట్టి ఒక డీబగ్గర్ ప్రోగ్రామ్ ఆ
మీరు మీ కార్యక్రమాన్ని డీబగ్ అనుమతిస్తుంది.

831
00:45:34,230 --> 00:45:39,931
ఇది బగ్స్ కనుగొనగల ఒక కార్యక్రమం కాదు
మీరు అయితే ఆ గొప్ప విషయం.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> మరియు శోధన నాకు చివరి ఉంది.

834
00:45:46,040 --> 00:45:51,470
మేము మాట్లాడారు శోధన రకాల కాబట్టి
ఈ తరగతి లో సరళ శోధన,,

835
00:45:51,470 --> 00:45:55,960
ఇది మీరు ప్రతి ద్వారా అనిపించే కేవలం ఉంది
శోధన స్థలం యొక్క మూలకం, ఒక

836
00:45:55,960 --> 00:46:00,410
ఒక సమయంలో మూలకం, మీరు కనుగొనడానికి వరకు
మీరు లేదా మీరు చేరుకోవడానికి వరకు చూస్తున్నారా

837
00:46:00,410 --> 00:46:03,350
మీ శోధన స్థలం యొక్క ముగింపు ఇది వద్ద
మీరు కనుగొనడానికి అని చెప్పడానికి అభిప్రాయపడుతున్నారు

838
00:46:03,350 --> 00:46:06,360
మీరు వెతుకుతున్న ఆ మూలకం.

839
00:46:06,360 --> 00:46:13,450
మరియు ఈ, ఉత్తమ వద్ద స్థిరంగా సమయం పడుతుంది
ఇది 1 0 మరియు చెత్త సరళ వద్ద

840
00:46:13,450 --> 00:46:16,070
n యొక్క 0 ఇది సమయం.

841
00:46:16,070 --> 00:46:19,250
>> అవసరం బైనరీ శోధన,
అనైతిక అంశాలు.

842
00:46:19,250 --> 00:46:24,230
మీరు మీ అంశాల మధ్య వెళ్ళండి,
చూడండి మీరు చూస్తున్న మూలకం

843
00:46:24,230 --> 00:46:30,120
మూలకం కంటే పెద్ద లేదా చిన్న ఉంది
మీరు మధ్య వద్ద ఉన్నట్లు.

844
00:46:30,120 --> 00:46:36,510
ఇది పెద్ద పని, మీరు క్రింద చెప్తారు
మీ శోధన స్పేస్ మీ ఉంది

845
00:46:36,510 --> 00:46:41,550
ప్రస్తుత నగర, మధ్యతరగతి,
మరియు మీరు ప్రక్రియ పునఃప్రారంభించుము.

846
00:46:41,550 --> 00:46:46,150
ఇది చిన్న ఉంటే, మీరు చెప్పే చూడండి
అవును, ఇంకేంటి వాట్ అని?

847
00:46:46,150 --> 00:46:47,400
>> ప్రేక్షకులు: [వినబడని]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> డాన్: అవును.

850
00:46:54,260 --> 00:46:58,360
బోధించాడు చేయబడింది ఆ విధమైన ఏ విధమైన
తరగతి పరీక్ష కోసం ఫెయిర్ గేమ్ ఉంది.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [నవ్వు]

853
00:47:04,920 --> 00:47:10,260
>> డాన్: మీరు కలిగి లేరు వాస్తవం
సమస్య సెట్ కోసం దీన్ని, ఇది ఫెయిర్ వార్తలు

854
00:47:10,260 --> 00:47:12,420
పరీక్ష కోసం ఆట.

855
00:47:12,420 --> 00:47:15,186
>> ప్రేక్షకులు: మేము వెళ్ళి ఎలా ఆలోచన

856
00:47:15,186 --> 00:47:17,052
>> డాన్: ఇది దొంగలకి చేయబడుతుంది.

857
00:47:17,052 --> 00:47:20,496
>> SPEAKER 2: అసలైన కోడ్
[వినబడని] study.cs50.net ఉంది.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
మీరు ఆచరణలో సమస్య చూడండి చేస్తే
ల విలీనంతో విధమైన పేజీ లో

860
00:47:32,680 --> 00:47:35,880
study.cs50.net కోడ్ ఉంది
విధమైన విలీనం అమలు కోసం.

861
00:47:35,880 --> 00:47:38,550
కాబట్టి మీరు అమలు లేదు
అది మిమ్మల్ని టునైట్.

862
00:47:38,550 --> 00:47:42,090
కానీ మీరు బదులుగా అర్థం చేయడానికి
కంటే కేవలం ఇది గుర్తుంచుకోవడం.

863
00:47:42,090 --> 00:47:45,035
>> ప్రేక్షకులు: [వినబడని]?

864
00:47:45,035 --> 00:47:49,720
>> SPEAKER 2: విలీనం విధమైన పేజీ
study.cs50.net ప్రాక్టీస్ ఉంది

865
00:47:49,720 --> 00:47:53,570
మీరు ద్వారా క్లిక్ చేస్తే, సమస్య
సమస్య చాలా చివరిలో ఉంది ఒక

866
00:47:53,570 --> 00:47:56,280
కలిసిపోయినా ఇది పరిష్కారం,
విధమైన అమలు.

867
00:47:56,280 --> 00:47:58,510
కానీ నిర్ధారించుకోండి మీరు అర్థం
కేవలం ఇది గుర్తుంచుకోవడం కంటే

868
00:47:58,510 --> 00:47:59,760
లేదా దానిని డౌన్ కాపీ.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> ప్రేక్షకులు: మరియు ఒక సంపూర్ణ చెల్లుబాటు
పరీక్షల సమస్య ఉంటుందని

871
00:48:06,340 --> 00:48:07,990
ఇక్కడ లాగ జాబితా ఉంది.

872
00:48:07,990 --> 00:48:12,100
ఈ జాబితాను తర్వాత లాగా ఏమిటి
ఎంపికలు విధమైన ఒక అడుగు లేదా

873
00:48:12,100 --> 00:48:13,330
చొప్పించడం విధమైన లేదా సంసార.

874
00:48:13,330 --> 00:48:14,940
జాబితాలో ఒకటిగా పూర్తి మళ్ళా.

875
00:48:14,940 --> 00:48:18,530
మీరు చవిచూస్తారు ముగుస్తుంది లేదు కాబట్టి కూడా
కోసం కోడ్, మీరు అర్థం చేసుకోవాలి

876
00:48:18,530 --> 00:48:20,440
అది జరగబోతోంది ఎలా తెలుసు తగినంత
ఈ శ్రేణి సవరించుట వుంటుంది.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: ఆ నాకు ఉంది.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [చప్పట్లు]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: హే ప్రతి ఒక్కరూ.

883
00:49:07,410 --> 00:49:08,390
నా పేరు లుకాస్ ఉంది.

884
00:49:08,390 --> 00:49:16,840
నేను అన్ని సూత్రం గురించి మాట్లాడటానికి వెళుతున్న
మేము నేర్చుకున్న రకాల, మరియు ఒక

885
00:49:16,840 --> 00:49:18,050
అన్ని గమనికలు కొద్దిగా.

886
00:49:18,050 --> 00:49:18,740
సిద్ధమేనా?

887
00:49:18,740 --> 00:49:20,340
అన్ని కాబట్టి మొదటి సూత్రం.

888
00:49:20,340 --> 00:49:22,951
ఆ చెప్పటానికి అర్థం ఏమిటి
ఒక ఫంక్షన్ పునరావృత ఉంది?

889
00:49:22,951 --> 00:49:24,675
>> ప్రేక్షకులు: పిలుస్తుంది.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: సరే, అవును, కూడా కాల్స్.

891
00:49:26,500 --> 00:49:27,700
కాబట్టి ఉదాహరణకు, ఈ చిత్రంలో ఇష్టపడుతున్నారు.

892
00:49:27,700 --> 00:49:30,280
ఇది లోపల చిత్రాన్ని వంటిది
ఒక చిత్రాన్ని మరియు అందువలన న.

893
00:49:30,280 --> 00:49:35,740
కాబట్టి ఉదాహరణకు, మీరు డాన్ గా దగ్గర చేయవచ్చు
ఆ బైనరీ శోధన గురించి మాట్లాడుతున్నాను.

894
00:49:35,740 --> 00:49:41,840
ఇది ఒక మార్గం బైనరీ శోధన
పునరావృత మీరు వాస్తవం ఉంది

895
00:49:41,840 --> 00:49:43,130
అనేక కనుగొనేందుకు ప్రయత్నిస్తున్న.

896
00:49:43,130 --> 00:49:44,250
కాబట్టి మీరు మధ్య వెళ్ళండి.

897
00:49:44,250 --> 00:49:47,130
అక్కడ సంఖ్యలు ఉంటే ఆపై మీరు తనిఖీ
ఎడమ మరియు కుడి.

898
00:49:47,130 --> 00:49:49,650
>> ఆపై మీరు సంఖ్య కనుగొనేందుకు ఉంటే
ఎడమవైపు చేస్తాడు, అది సేమ్

899
00:49:49,650 --> 00:49:53,340
మళ్ళీ శోధన చేయడం వంటి విషయం కానీ
కేవలం జాబితా ఎడమ.

900
00:49:53,340 --> 00:49:57,350
అది ధ్వనులు ఎలా సో ఆ
లాగా పునరావృత ఉంది.

901
00:49:57,350 --> 00:50:01,870
మీరు అబ్బాయిలు పునరావృత ఎందుకు అలా ఆ వార్తలు
విలీనంతో విధమైన పరిష్కారం.

902
00:50:01,870 --> 00:50:04,270
>> OK, కాబట్టి ఇక్కడ ఒక ఉదాహరణ ఉంది.

903
00:50:04,270 --> 00:50:07,280
కాబట్టి యొక్క నేను ఎంచుకోవడానికి కావలసిన సే
1 నుండి n అన్ని సంఖ్యలు.

904
00:50:07,280 --> 00:50:13,790
నేను తెలుసుకుంటారు చేయవచ్చు n యొక్క మొత్తం
సంఖ్య n ప్లస్ లేదా మైనస్ 1 1 వరకు ఉంది.

905
00:50:13,790 --> 00:50:17,810
కానీ, నేను n 1 మైనస్ వద్ద చూస్తే ప్లస్
లేదా మైనస్ 2 ప్లస్ 1, అదే వార్తలు

906
00:50:17,810 --> 00:50:20,680
చేసి సంఖ్యలు వంటి విషయం
n కు మైనస్ 1 అప్.

907
00:50:20,680 --> 00:50:25,890
నేను సమాన మొత్తం మొత్తం చెప్పగలను
లేదా మైనస్ 1 యొక్క n ప్లస్ మొత్తం సమానం.

908
00:50:25,890 --> 00:50:28,010
ఆ సమంజసం లేదు?

909
00:50:28,010 --> 00:50:32,630
>> నేను కూడా ఏదో వుంటుంది
ఆ ఇది, బేస్ కేసు అని

910
00:50:32,630 --> 00:50:37,440
అప్ సంఖ్యల మొత్తం
సున్నా సున్నా ఉంటుంది.

911
00:50:37,440 --> 00:50:42,770
అందుకే వెంటనే సంఖ్యను పొందడానికి వంటి
సున్నా, నేను లెక్కింపు ఆపడానికి.

912
00:50:42,770 --> 00:50:45,330
ఆ సమంజసం లేదు?

913
00:50:45,330 --> 00:50:48,120
>> కాబట్టి ఇక్కడ ఎలా ఒక ఉదాహరణ వార్తలు
నేను అమలు చేయవచ్చు.

914
00:50:48,120 --> 00:50:49,860
కాబట్టి నేను కొన్ని ఈ చర్య.

915
00:50:49,860 --> 00:50:51,700
ఆ పూర్ణాంకం n పడుతుంది.

916
00:50:51,700 --> 00:50:56,300
N ఉంటే కాబట్టి ఇక్కడ నేను మొదటి తనిఖీ
తక్కువ లేదా సున్నా సమానం.

917
00:50:56,300 --> 00:51:00,310
కాబట్టి అది సున్నా తక్కువ లేదా సమానం ఉంటే నేను
మా బేస్ కేసు ఇది సున్నా తిరిగి.

918
00:51:00,310 --> 00:51:05,690
లేకపోతే, నేను తిరిగి చేయవచ్చు N ప్లస్
సంఖ్యలు మొత్తం నుండి

919
00:51:05,690 --> 00:51:07,190
లేదా మైనస్ ఒకరు.

920
00:51:07,190 --> 00:51:09,360
సమంజసం?

921
00:51:09,360 --> 00:51:10,100
సరే.

922
00:51:10,100 --> 00:51:11,610
>> ఇక్కడ అది కనిపిస్తోంది ఏమిటి.

923
00:51:11,610 --> 00:51:15,260
మీరు 2 సమానం మొత్తాన్ని కలిగి
2 ప్లస్ 1 మొత్తం.

924
00:51:15,260 --> 00:51:18,930
మరియు 1 యొక్క కొన్ని ప్లస్ 1
0 ఇది 0 మొత్తం.

925
00:51:18,930 --> 00:51:20,216
సమంజసం?

926
00:51:20,216 --> 00:51:25,342
మేము స్టాక్ చేస్తే మీ
ఈ కార్యక్రమానికి ఇది కనిపిస్తోంది ఏమిటి.

927
00:51:25,342 --> 00:51:26,820
>> మొదటి, మేము ప్రధాన చర్య.

928
00:51:26,820 --> 00:51:30,320
ఆపై ప్రధాన విధి
మొత్తం 2 అని.

929
00:51:30,320 --> 00:51:36,690
ఆపై మొత్తం 2 ఓహ్, చెప్పడానికి అన్నారు, మొత్తం
2 2 ప్లస్ ఒకటి మొత్తం సమానం.

930
00:51:36,690 --> 00:51:39,460
కాబట్టి నేను స్టాక్కు 1 మొత్తానికి జోడించండి.

931
00:51:39,460 --> 00:51:43,860
మరియు 1 మొత్తానికి మొత్తం కాల్ అన్నారు
0, ఇది కూడా చేర్చవచ్చు అన్నారు

932
00:51:43,860 --> 00:51:44,630
స్టాక్కు.

933
00:51:44,630 --> 00:51:49,240
అవుతున్నారని ఈ వాటిని అప్పటి ప్రతి
మరొక పైన తిరిగి

934
00:51:49,240 --> 00:51:52,020
ఇతర వాటిని కొనసాగించడాన్ని చేయవచ్చు ముందు.

935
00:51:52,020 --> 00:51:56,240
>> కాబట్టి ఉదాహరణకు, ఇక్కడ, 0 మొత్తం,
మొదటి, 0 తిరిగి అన్నారు.

936
00:51:56,240 --> 00:51:58,320
ఆపై 1 మొత్తం ఎంచుకోండి.

937
00:51:58,320 --> 00:52:00,850
అప్పుడు 1 మొత్తానికి అన్నారు
2 మొత్తానికి 1 తిరిగి.

938
00:52:00,850 --> 00:52:03,900
చివరకు, 2 మొత్తానికి అన్నారు
ప్రధాన 3 తిరిగి.

939
00:52:03,900 --> 00:52:05,320
ఆ సమంజసం లేదు?

940
00:52:05,320 --> 00:52:09,496
>> ఇది ఎలా అర్థం నిజంగా ముఖ్యమైన వార్తలు
స్టాక్ పని మరియు ప్రయత్నించండి

941
00:52:09,496 --> 00:52:11,980
ఇది అర్ధమే ఉంటే చూడండి.

942
00:52:11,980 --> 00:52:13,260
OK, కాబట్టి క్రమబద్ధీకరించేందుకు.

943
00:52:13,260 --> 00:52:16,170
ఎందుకు, ముఖ్యమైన అమర్చిన
మొదటి అన్ని యొక్క?

944
00:52:16,170 --> 00:52:18,260
ఎందుకు మేము జాగ్రత్త పడాలి?

945
00:52:18,260 --> 00:52:20,310
ఎవరైనా?

946
00:52:20,310 --> 00:52:20,695
నాకు ఒక ఉదాహరణ ఇవ్వండి?

947
00:52:20,695 --> 00:52:21,040
అవును?

948
00:52:21,040 --> 00:52:22,968
>> ప్రేక్షకులు: [వినబడని].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: సరే, అవును.

950
00:52:24,700 --> 00:52:26,090
కాబట్టి మీరు మరింత సమర్ధవంతంగా శోధించవచ్చు.

951
00:52:26,090 --> 00:52:28,580
ఒక మంచి మార్గం.

952
00:52:28,580 --> 00:52:32,462
కాబట్టి, ఉదాహరణకు, మేము చాలా ఉన్నాయి
విషయాలు, నిజానికి, మా జీవితాలను ఆ

953
00:52:32,462 --> 00:52:32,920
క్రమబద్ధీకరించబడతాయి.

954
00:52:32,920 --> 00:52:34,830
ఉదాహరణకు, నిఘంటువులు.

955
00:52:34,830 --> 00:52:39,210
>> ఇది అన్ని చాలా ముఖ్యమైన వార్తలు
ఆర్డర్ రకమైన పదాలు మనం

956
00:52:39,210 --> 00:52:41,970
సులభంగా యాక్సెస్ చేయవచ్చు.

957
00:52:41,970 --> 00:52:43,280
కాబట్టి అతను చెప్పాడు జరిగినది ఏమిటి.

958
00:52:43,280 --> 00:52:45,530
మీరు మరింత సమర్ధవంతంగా శోధించవచ్చు.

959
00:52:45,530 --> 00:52:48,740
అది ఒక కలిగి ఉంటుంది ఎలా హార్డ్ యొక్క థింక్
పదాలు లో ఇవి నిఘంటువు

960
00:52:48,740 --> 00:52:49,500
యాదృచ్ఛిక క్రమంలో.

961
00:52:49,500 --> 00:52:53,120
మీరు చాలా చక్కని చూడండి ఉంటుంది
ప్రతి ఒక్క పదం మీకు కనుగొనేందుకు వరకు

962
00:52:53,120 --> 00:52:54,720
మీరు వెతికే పదం.

963
00:52:54,720 --> 00:52:58,710
>> మీరు కూడా Facebook ఉపయోగించి ఉంటే, ఎప్పుడు
మీరు మీ స్నేహితులు వద్ద చూస్తున్న, మీరు ఉన్నాము

964
00:52:58,710 --> 00:53:03,540
ఫేస్బుక్ పెట్టే చూడటానికి వెళ్లి మీ
దగ్గరగా స్నేహితుడు వాటిని పైన వార్తలు

965
00:53:03,540 --> 00:53:05,470
మీరు చాలా మాట్లాడటానికి లేదు.

966
00:53:05,470 --> 00:53:08,080
మీరు దిగువ అన్ని మార్గం వెళ్ళి ఉంటే
మీ స్నేహితుల జాబితా, మీరు చూడండి చూడాలని

967
00:53:08,080 --> 00:53:11,250
మీరు బహుశా కూడా ఇవ్వలేదని ప్రజలు
మీరు స్నేహితులు ఉన్నారు గుర్తుంచుకోవాలి.

968
00:53:11,250 --> 00:53:14,590
ఆ Facebook రకాల ఎందుకంటే వార్తలు
ఎలా ఆధారంగా మీ స్నేహితులు

969
00:53:14,590 --> 00:53:16,472
మీరు వాటిని క్లోజ్.

970
00:53:16,472 --> 00:53:17,930
>> కాబట్టి డేటా నిర్వహించడం వంటి.

971
00:53:17,930 --> 00:53:18,450
అలాగే పోకీమాన్.

972
00:53:18,450 --> 00:53:21,400
కాబట్టి మీరు అన్ని Pokémons ఆ చూడండి
సంఖ్యలు ఉంటాయి.

973
00:53:21,400 --> 00:53:27,210
మరియు ఒక సులభమైన వంటిది
డేటా యాక్సెస్ యొక్క మార్గం.

974
00:53:27,210 --> 00:53:29,050
>> ప్రేక్షకులు: పోకీమాన్ ప్రాప్తి చేయడం.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: అవును.

976
00:53:29,890 --> 00:53:32,395
>> ప్రేక్షకులు: [వినబడని].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: YEP.

978
00:53:33,460 --> 00:53:35,140
సరే, అలా ఎంపిక విధమైన.

979
00:53:35,140 --> 00:53:41,610
ఎన్నిక విధమైన ఎంచుకోండి అన్నారు
జాబితా అతిచిన్న క్రమబద్ధీకరించనిది విలువ ప్రతి

980
00:53:41,610 --> 00:53:43,300
ప్రతి మళ్ళా సమయం.

981
00:53:43,300 --> 00:53:46,800
ఇది రకమైన మీరు ఆ విధమైన వంటిది
మీ తల లో మీరు ప్రయత్నిస్తున్న సమయంలో

982
00:53:46,800 --> 00:53:48,430
వైపు జాబితా క్రమం.

983
00:53:48,430 --> 00:53:51,990
>> సాధారణంగా, మీరు అన్ని మీరు చూడండి ఉంది
అతిచిన్న సంఖ్య కోసం.

984
00:53:51,990 --> 00:53:54,280
మీరు క్రమబద్ధీకరించబడతాయి జాబితాలో ఉంచారు.

985
00:53:54,280 --> 00:53:56,230
ఆపై మీరు కోసం చూడండి
తదుపరి చిన్న సంఖ్య.

986
00:53:56,230 --> 00:54:00,080
ఆపై మీరు పనిని
ఆ మరియు అందువలన న.

987
00:54:00,080 --> 00:54:04,600
>> కాబట్టి ఎంపిక విధమైన మీరు రప్పించింది
ప్రతిసారీ చిన్న ఎంచుకోండి

988
00:54:04,600 --> 00:54:05,750
క్రమబద్ధీకరించనిది విలువ.

989
00:54:05,750 --> 00:54:10,840
క్రమబద్ధీకరించబడతాయి చివరిలో ఉంచండి
జాబితా భాగంగా.

990
00:54:10,840 --> 00:54:12,370
మరియు ఆ పనిని.

991
00:54:12,370 --> 00:54:15,890
కాబట్టి యొక్క త్వరగా చూద్దాం ఏమి
ఈ కనిపిస్తోంది.

992
00:54:15,890 --> 00:54:19,340
కాబట్టి ఇక్కడ క్రమబద్ధీకరించబడతాయి వార్తలు
మరియు క్రమబద్ధీకరించనిది జాబితా.

993
00:54:19,340 --> 00:54:23,350
>> జాబితా యొక్క క్రమబద్ధీకరించబడతాయి కాబట్టి,
మొదట ఖాళీ.

994
00:54:23,350 --> 00:54:26,760
ఆపై నేను ఎంచుకోవచ్చు వెళుతున్న
2 ఇది ఇక్కడ చిన్న సంఖ్య.

995
00:54:26,760 --> 00:54:30,650
కాబట్టి నేను సంఖ్య 2 పొందుటకు మరియు నేను చాలు
జాబితా ముందు.

996
00:54:30,650 --> 00:54:34,910
ఆపై నేను తదుపరి చిన్న కోసం చూడండి
3 ఇది మూలకం.

997
00:54:34,910 --> 00:54:37,050
కాబట్టి నేను ముగింపు వద్ద అది చాలు
క్రమబద్ధీకరించబడతాయి జాబితా.

998
00:54:37,050 --> 00:54:38,140
ఆపై నేను ఆ పనిని.

999
00:54:38,140 --> 00:54:40,040
నేను 4 కనుగొనేందుకు మరియు చివరిలో అది చాలు.

1000
00:54:40,040 --> 00:54:41,360
5 కనుగొను మరియు చివరిలో అది చాలు.

1001
00:54:41,360 --> 00:54:44,830
>> మరియు ఆ సార్లు ఎలా అన్ని చూడండి
నేను ముగింపు, వద్ద అది చాలు మాట్లాడుతూ నేను

1002
00:54:44,830 --> 00:54:46,850
ప్రధానంగా, రెండు విలువలు ఇచ్చిపుచ్చుకోవడంతో.

1003
00:54:46,850 --> 00:54:48,100
సిద్ధమేనా?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
ఆపై చివరి, మీరు కేవలం
ఒక మరింత మూలకం ఉన్నాయి.

1006
00:54:52,825 --> 00:54:55,870
కాబట్టి ఇది ఇప్పటికే క్రమబద్ధీకరించబడతాయి.

1007
00:54:55,870 --> 00:54:57,800
>> OK, కాబట్టి చొప్పించడం విధమైన.

1008
00:54:57,800 --> 00:55:03,180
చేర్పు విధమైన మీరు కూడా చూడాలని
ఒక క్రమబద్ధీకరించబడతాయి సరికొత్త ఆ విషయం

1009
00:55:03,180 --> 00:55:04,690
ఒక క్రమబద్ధీకరించనిది జాబితా.

1010
00:55:04,690 --> 00:55:14,540
మాత్రమే విషయం ప్రతిసారీ ఆ
మీరు క్రమబద్ధీకరించబడతాయి ఒక మూలకం జోడించడం చేస్తున్నారు

1011
00:55:14,540 --> 00:55:18,170
జాబితా, మీరు కేవలం మూలకం ఎంచుకొని ఆ
క్రమబద్ధీకరించనిది జాబితా ముందు ఉంది.

1012
00:55:18,170 --> 00:55:20,880
ఆపై మీరు ఏమి కనుగొనేందుకు వెళుతున్న
స్థానం విభజించిన ఉండాలి

1013
00:55:20,880 --> 00:55:22,300
జాబితా భాగంగా.

1014
00:55:22,300 --> 00:55:25,840
>> కాబట్టి ఈ కాబట్టి ఉంది ఏమి చూడండి లెట్
ఈ మరింత అర్థవంతంగా ఉంటుంది.

1015
00:55:25,840 --> 00:55:29,360
కాబట్టి మొదట, ఉదాహరణకు, నేను దీనికై
లో మూడవ ఇన్సర్ట్

1016
00:55:29,360 --> 00:55:30,680
జాబితా యొక్క క్రమబద్ధీకరించబడతాయి భాగం.

1017
00:55:30,680 --> 00:55:31,800
కాబట్టి జాబితా ఏదైనా లేదు.

1018
00:55:31,800 --> 00:55:34,160
సో నేను సంఖ్య 3 ఉంచవచ్చు.

1019
00:55:34,160 --> 00:55:37,480
>> ఇప్పుడు, నేను సంఖ్య 5 జోడించాలనుకుంటే
జాబితా యొక్క క్రమబద్ధీకరించబడతాయి భాగం.

1020
00:55:37,480 --> 00:55:38,900
కాబట్టి నేను సంఖ్య 5 చూడండి.

1021
00:55:38,900 --> 00:55:40,450
నేను 3 కంటే ఎక్కువ అని గుర్తించలేకపోతే.

1022
00:55:40,450 --> 00:55:41,980
కాబట్టి నేను 3 తర్వాత ఉండాలి అని తెలుసు.

1023
00:55:41,980 --> 00:55:44,100
కాబట్టి, నేను 3 మరియు 5 చాలు.

1024
00:55:44,100 --> 00:55:45,940
>> అప్పుడు నేను సంఖ్య 2 ఇన్సర్ట్ చెయ్యడానికి కావలసిన.

1025
00:55:45,940 --> 00:55:51,630
నేను సంఖ్య 2 వాస్తవానికి ఉంది అని గుర్తించలేకపోతే
తరువాత 3 మరియు 5 రెండు దాకా.

1026
00:55:51,630 --> 00:55:54,580
నేను నిజానికి ఇది అన్ని ఉంచాలి
జాబితా ప్రారంభంలో మార్గం.

1027
00:55:54,580 --> 00:55:59,030
కాబట్టి నేను రకమైన, అన్ని మార్చేందుకు
క్రమబద్ధీకరించబడతాయి జాబితా కాబట్టి నేను చెయ్యవచ్చు అంశాలు

1028
00:55:59,030 --> 00:56:01,970
సంఖ్య 2 కల్పించడం.

1029
00:56:01,970 --> 00:56:03,160
>> అప్పుడు నేను సంఖ్య 6 చూడండి.

1030
00:56:03,160 --> 00:56:05,450
నేను 5 తర్వాత ఉండాలి చూడండి.

1031
00:56:05,450 --> 00:56:06,240
కాబట్టి నేను అక్కడ ఉంచారు.

1032
00:56:06,240 --> 00:56:07,965
చివరకు, నేను సంఖ్య 4 వద్ద చూడండి.

1033
00:56:07,965 --> 00:56:11,030
మరియు నేను దానిని తప్పక గమనిస్తారు
3 మరియు 5 మధ్య ఉంటుంది.

1034
00:56:11,030 --> 00:56:14,870
ఆపై నేను అక్కడ అది చాలు మరియు షిఫ్ట్
అన్ని ఇతర మూలకాలను.

1035
00:56:14,870 --> 00:56:16,120
సమంజసం?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> బబుల్ సార్ట్.

1038
00:56:19,150 --> 00:56:25,730
కాబట్టి బబుల్ సార్ట్ మీరు ఏ రప్పించింది
అన్నారు మేము బుడగ కాల్ do-- కు

1039
00:56:25,730 --> 00:56:30,113
మీరు list-- ద్వారా వెళ్ళి విధమైన
నేను కేవలం చూపించు ఉంటే అది వాస్తవానికి మంచి పని

1040
00:56:30,113 --> 00:56:32,300
మీరు ఈ వంటి

1041
00:56:32,300 --> 00:56:35,030
మరియు మీరు పోల్చి చూడాలని
ప్రక్కనే సంఖ్యలు.

1042
00:56:35,030 --> 00:56:38,410
మరియు మీరు స్వాప్ వెళుతున్న వారి
స్థానాలు వారు తెలియకపోతే

1043
00:56:38,410 --> 00:56:39,190
కుడి క్రమంలో.

1044
00:56:39,190 --> 00:56:42,570
>> సో basically, ఏమి జరుగుతుందో
ఇక్కడ జరిగే, ఉదాహరణకు,

1045
00:56:42,570 --> 00:56:44,160
మీరు 8 మరియు 6 చేశారు.

1046
00:56:44,160 --> 00:56:47,270
మీరు క్రమబద్ధీకరించబడతాయి క్రమంలో లెఖ్ఖచేయను
నిజానికి కుడి 6 మరియు 5 ఉంటుంది?

1047
00:56:47,270 --> 00:56:49,540
కాబట్టి మీరు ఆదేశాలు మార్పిడి చూడాలని.

1048
00:56:49,540 --> 00:56:51,370
అప్పుడు నేను ఇక్కడ 8 మరియు 4 చూడండి.

1049
00:56:51,370 --> 00:56:52,250
నేను ఇదే.

1050
00:56:52,250 --> 00:56:53,400
నేను మళ్ళీ స్వాప్.

1051
00:56:53,400 --> 00:56:55,070
చివరకు, 2 మరియు 8.

1052
00:56:55,070 --> 00:56:56,670
నేను కూడా వాటిని మార్పిడి.

1053
00:56:56,670 --> 00:57:01,690
>> ఇది బబుల్ సార్ట్ తర్వాత ఎందుకంటే అని
ఈ నిద్రావస్థ ప్రతి, నిజానికి,

1054
00:57:01,690 --> 00:57:05,910
జాబితాలో సంఖ్యలో అన్ని గెట్స్
జాబితా చివర మార్గం.

1055
00:57:05,910 --> 00:57:06,940
ఆ సమంజసం లేదు?

1056
00:57:06,940 --> 00:57:11,880
అది ఇచ్చిపుచ్చుకోవడంతో ఉంచుతుంది ఎందుకంటే
మరియు కుడి అది కదిలే.

1057
00:57:11,880 --> 00:57:14,440
>> OK, కాబట్టి ఈ రెండవ మళ్ళా ఉంది.

1058
00:57:14,440 --> 00:57:17,200
ఇది అదే విషయం ఉంటుంది.

1059
00:57:17,200 --> 00:57:20,190
నేను ఒక స్వాప్ చేస్తాను
అప్పుడు చివరి.

1060
00:57:20,190 --> 00:57:23,290
మార్పిడులు ఉన్నాయి నేను
మరియు జాబితా క్రమబద్ధీకరించబడింది.

1061
00:57:23,290 --> 00:57:27,460
బబుల్ సార్ట్ లో కాబట్టి, మేము ప్రధానంగా ఉంచడానికి
జాబితా ద్వారా వెళ్లి ఇచ్చిపుచ్చుకోవడం

1062
00:57:27,460 --> 00:57:32,310
విషయాలు నేను చేయకపోవడంతో ప్రకటన వరకు
ఆ మళ్ళా చేయడం ఏ మార్పిడులు, ఇది

1063
00:57:32,310 --> 00:57:34,270
జాబితా ఇప్పటికే క్రమబద్ధీకరించబడింది ఆ అర్థం.

1064
00:57:34,270 --> 00:57:35,520
సమంజసం?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> యొక్క కొద్దిగా చర్చ లెట్
అమలు సమయం గురించి.

1067
00:57:40,870 --> 00:57:45,165
కాబట్టి మీరు అబ్బాయిలు బిగ్ గుర్తుంచుకోవాలి లేదు
ఓ, ఒమేగా, మరియు తీటా?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
అవును?

1070
00:57:50,990 --> 00:57:53,070
సరే, బిగ్ O అన్ని మొదటి, ఏమిటి?

1071
00:57:53,070 --> 00:57:54,315
>> ప్రేక్షకులు: [వినబడని].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: అవును, అది ఒక చెత్త సందర్భంలో అని
అది అంతే అంటే రన్టైమ్,

1073
00:57:59,070 --> 00:58:03,470
ఎంత మీరు ప్రోగ్రామ్ ఆశించడం
అమలు తీసుకోవాలని.

1074
00:58:03,470 --> 00:58:04,910
ఇలా, పరంగా of--

1075
00:58:04,910 --> 00:58:06,660
ఈ సందర్భంలో, n.

1076
00:58:06,660 --> 00:58:09,150
మూలకాల సంఖ్య
చెత్త సందర్భంలో జాబితా.

1077
00:58:09,150 --> 00:58:12,520
ఇలా, నీచమైన సందర్భంలో.

1078
00:58:12,520 --> 00:58:17,100
>> బబుల్ సార్ట్ కాబట్టి, ఉదాహరణకు,
మేము n చదరపు యొక్క బిగ్ O కలిగి.

1079
00:58:17,100 --> 00:58:20,580
ఎందుకు మేము కలిగి లేదు?

1080
00:58:20,580 --> 00:58:24,716
ఎందుకు బబుల్ బిగ్ O N చతురస్ర క్రమీకరించు ఉంది?

1081
00:58:24,716 --> 00:58:27,614
>> ప్రేక్షకులు: [వినబడని].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: అవును, కాబట్టి చెత్త సందర్భంలో ఉంటుంది
ఆ నేను n నిద్రావస్థ చేయండి ఉంటుంది.

1083
00:58:35,670 --> 00:58:39,260
కాబట్టి నిద్రావస్థ ప్రతి అన్నారు
చివర అతిపెద్ద సమకూరతాయని

1084
00:58:39,260 --> 00:58:40,290
జాబితా.

1085
00:58:40,290 --> 00:58:44,230
కాబట్టి చెత్త సందర్భంలో నేను కలిగి ఉంది
ఆ విషయం n సార్లు చేయాలని.

1086
00:58:44,230 --> 00:58:48,550
మరియు ఆ సార్లు ప్రతి, నేను కలిగి
నేను పోల్చడానికి కలిగి ఎందుకంటే మార్పిడులు చేయండి

1087
00:58:48,550 --> 00:58:49,870
ప్రతి రెండు అంశాలు.

1088
00:58:49,870 --> 00:58:53,730
అది n స్క్వేర్డ్ వై సో ఆ
అది n సార్లు n ఎందుకంటే.

1089
00:58:53,730 --> 00:59:00,120
>> అప్పుడు, ఎంపిక విధమైన కూడా n కూడలి
ఎందుకంటే, ప్రతి మళ్ళా కోసం, నేను కలిగి

1090
00:59:00,120 --> 00:59:02,650
ప్రతి మూలకం
జాబితాలో లేదు.

1091
00:59:02,650 --> 00:59:04,980
ఆపై, చిన్న కనుగొనేందుకు
ఇది నేను కలిగి అర్థం

1092
00:59:04,980 --> 00:59:06,130
n మూలకాలు ద్వారా చూడండి.

1093
00:59:06,130 --> 00:59:11,750
మరియు నేను ఎందుకంటే ఆ n సార్లు చేయాల్సిందల్లా
నేను అన్ని n మూలకాలు ఎంచుకోవాలి.

1094
00:59:11,750 --> 00:59:18,273
>> ఒక చొప్పించడం విధమైన కూడా n కూడలి
చెత్త దృష్టాంత ఎందుకంటే

1095
00:59:18,273 --> 00:59:20,950
, ఒక, నేను ఇన్సర్ట్ ఉంటుంది
n సంఖ్యలు, కుడి?

1096
00:59:20,950 --> 00:59:22,765
కాబట్టి నేను ఇప్పటికే నేను వెళ్తున్నాను అని తెలుసు
లేదా నిద్రావస్థ కలిగి.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
కానీ నేను కలిగి ఆ సంఖ్యల ప్రతి, ఉంటే
సంఖ్యల అన్ని చూడండి

1099
00:59:29,840 --> 00:59:34,380
క్రమబద్ధీకరించబడతాయి జాబితా మరియు దాని అన్ని మార్గం చాలు
ముందు, ఆ n చదరపు ఉంటుంది

1100
00:59:34,380 --> 00:59:36,230
n సార్లు n మళ్ళీ ఉంటుంది ఎందుకంటే.

1101
00:59:36,230 --> 00:59:38,280
సమంజసం?

1102
00:59:38,280 --> 00:59:41,512
ఏం ఒమేగా గురించి?

1103
00:59:41,512 --> 00:59:42,886
>> ప్రేక్షకులు: [వినబడని].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: ఇది ఉత్తమ దృష్టాంతంలో ఉంది.

1105
00:59:44,620 --> 00:59:48,810
కాబట్టి సార్లు చాలా కోసం, వంటిది
ఉత్తమ దృష్టాంతంలో ఉంది, సార్టింగ్

1106
00:59:48,810 --> 00:59:50,660
జాబితా ఇప్పటికే క్రమబద్ధీకరించబడింది.

1107
00:59:50,660 --> 00:59:52,670
కాబట్టి మీరు నిజంగా లేని
ఏమీ.

1108
00:59:52,670 --> 00:59:56,290
బబుల్ సార్ట్ ఉత్తమ ఉంది
n యొక్క దృష్టాంత.

1109
00:59:56,290 --> 00:59:58,820
మీరు అబ్బాయిలు ఎందుకు తెలుసా?

1110
00:59:58,820 --> 01:00:00,620
>> ప్రేక్షకులు: [వినబడని].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: అవును, మీరు ట్రాక్ ఉంటే
డేటా రేషన్ ఏ మార్పిడులు కలిగి లేదో

1112
01:00:05,640 --> 01:00:10,533
మీరు ఏదో కలిగి ఉంటే కాదు, సెట్ వంటి
ఒక పునరుక్తి చేస్తే అక్కడ అది నిజమైన

1113
01:00:10,533 --> 01:00:15,140
జాబితా ఇప్పటికే ప్రాథమికంగా, క్రమబద్ధీకరించబడింది
ఏ జరిగే అవకాశముంది నేను వెళుతున్న ఉంది

1114
01:00:15,140 --> 01:00:17,890
ప్రతి రెండు స్వాప్ ప్రయత్నించండి
ప్రక్కనే అంశాలు.

1115
01:00:17,890 --> 01:00:19,920
నేను చూడండి వెళుతున్న
మార్పిడులు ఉన్నాయి.

1116
01:00:19,920 --> 01:00:21,230
నేను కేవలం వెంటనే తిరిగి.

1117
01:00:21,230 --> 01:00:24,240
>> కాబట్టి నేను కేవలం వచ్చింది అర్థం
జాబితా ఒక సమయంలో ద్వారా వెళ్ళడానికి.

1118
01:00:24,240 --> 01:00:28,990
నేను చూడండి ఎందుకంటే అది n ఉంది
n మూలకాలు వద్ద.

1119
01:00:28,990 --> 01:00:30,930
ఎందుకు ఎంపిక విధమైన N చతురస్ర?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> అవును, జాబితా క్రమబద్ధీకరించబడింది కూడా, కోసం
ఎంపిక విధమైన ప్రతి మళ్ళా నేను

1122
01:00:45,520 --> 01:00:47,590
కనీస మూలకం ఎంచుకోవాలి.

1123
01:00:47,590 --> 01:00:49,980
కాబట్టి ఆ నేను చూడటానికి తెలుసుకో అర్థం
క్రమబద్ధీకరించనిది అన్ని అంశాలను

1124
01:00:49,980 --> 01:00:53,350
జాబితా మరియు కనీస కనుగొనడానికి
ప్రతి మళ్ళా కోసం.

1125
01:00:53,350 --> 01:00:54,600
ఆ సమంజసం లేదు?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> మరియు చొప్పించడం కత్తి ఎందుకంటే n లు
నేను ఇన్సర్ట్ దీనికై ఆ సందర్భంలో

1128
01:01:04,690 --> 01:01:09,320
సంఖ్యలు మరియు సంఖ్యల అన్ని, నేను
వాటిని ఇన్సర్ట్ చెయ్యడానికి ప్రయత్నించండి, నేను వారు చూడండి

1129
01:01:09,320 --> 01:01:10,510
కుడి స్థానంలో ఉన్నాయి.

1130
01:01:10,510 --> 01:01:15,120
నేను అన్ని ఇతర తనిఖీ వెళ్ళడానికి లేదు
క్రమబద్ధీకరించనిది జాబితా సంఖ్యలు.

1131
01:01:15,120 --> 01:01:17,170
అది n ఉంటుంది ఎందుకు కాబట్టి ఆ.

1132
01:01:17,170 --> 01:01:19,480
సమంజసం?

1133
01:01:19,480 --> 01:01:21,035
మరియు తీటా ఏమిటి?

1134
01:01:21,035 --> 01:01:23,410
>> ప్రేక్షకులు: [వినబడని].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: ఏం, క్షమించాలి?

1136
01:01:24,380 --> 01:01:24,960
మళ్ళీ చెప్పాను.

1137
01:01:24,960 --> 01:01:25,666
>> ప్రేక్షకులు: [వినబడని].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: ఖచ్చితంగా.

1139
01:01:26,490 --> 01:01:31,280
కాబట్టి మీరు ఆ కేవలం ఎంపిక చూడగలరు
విలీన నిల్వ విధమైన thetas చేశారు.

1140
01:01:31,280 --> 01:01:39,920
మీరు మాత్రమే తీటా కలిగి ఎందుకంటే ఆ వార్తలు
బిగ్ O మరియు ఒమేగా రెండూ ఒకే ఉంటే.

1141
01:01:39,920 --> 01:01:41,520
సరే.

1142
01:01:41,520 --> 01:01:44,210
చివరకు, లాగ్ n విధమైన విలీనం.

1143
01:01:44,210 --> 01:01:48,910
>> డాన్ విధంగా జరిగినది ఆపై, విలీనం విధమైన
రకమైన అదే విధంగా ఇష్టం అని

1144
01:01:48,910 --> 01:01:50,320
మీరు బైనరీ శోధన చేయండి.

1145
01:01:50,320 --> 01:01:53,530
సో మీరు జాబితా పొందుటకు.

1146
01:01:53,530 --> 01:01:55,170
మరియు మీరు సగం లో కట్ చూడాలని.

1147
01:01:55,170 --> 01:02:00,580
ఆపై మీరు వాటిని కట్
చిన్న భాగాల లో.

1148
01:02:00,580 --> 01:02:01,730
ఆపై మీరు వాటిని విలీనం.

1149
01:02:01,730 --> 01:02:02,960
మీరు అబ్బాయిలు, కుడి గుర్తు?

1150
01:02:02,960 --> 01:02:04,960
సరే, అతను విధంగా జరిగినది.

1151
01:02:04,960 --> 01:02:08,330
>> సరే, పాయింటర్లు.

1152
01:02:08,330 --> 01:02:11,078
కాబట్టి ఒక పాయింటర్ ఏమిటి?

1153
01:02:11,078 --> 01:02:12,050
>> ప్రేక్షకులు: [వినబడని].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: ఒక చిరునామా.

1155
01:02:12,820 --> 01:02:13,720
సరే.

1156
01:02:13,720 --> 01:02:18,530
నేను డేవిడ్ కొంత చూపే తెలుసు
Binky వీడియోలు మరియు విషయాలు గురిపెట్టి

1157
01:02:18,530 --> 01:02:19,080
ప్రతి ఇతర.

1158
01:02:19,080 --> 01:02:22,960
కానీ నేను గమనికలు ఆలోచించడానికి ఇష్టపడతాను
కేవలం ఒక చిరునామా వంటి.

1159
01:02:22,960 --> 01:02:26,110
కనుక ఇది వెళుతున్న ఒక వేరియబుల్ వార్తలు
ఒక చిరునామా నిల్వ.

1160
01:02:26,110 --> 01:02:31,940
>> కనుక ఇది కేవలం ఈ ప్రత్యేక వేరియబుల్ వార్తలు
నాలుగు బైట్ల పొడవు ఉంటుంది.

1161
01:02:31,940 --> 01:02:36,550
ఏదైనా ఆ పాయింటర్ ఉంది, గుర్తుంచుకో
మా 32-bit కోసం దీర్ఘ ఎల్లప్పుడూ నాలుగు బైట్లు

1162
01:02:36,550 --> 01:02:39,370
యంత్రం కేసు కాబట్టి
ఉపకరణం.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
మరియు అది కేవలం నగర ఉంది
అది లోపలి ఒక వేరియబుల్.

1165
01:02:47,050 --> 01:02:50,240
>> OK, కాబట్టి ప్రాథమికంగా, ఈ మెమరీ ఉంది.

1166
01:02:50,240 --> 01:02:57,420
కాబట్టి మెమరీ ప్రతి బ్లాక్ వాస్తవానికి ఒక
యొక్క చిరునామా ఇది లేబుల్,

1167
01:02:57,420 --> 01:02:58,890
slotty మెమరీ.

1168
01:02:58,890 --> 01:03:02,370
అక్కడ నేను దొరుకుతుంది
ఒక పాయింటర్

1169
01:03:02,370 --> 01:03:03,380
ఈ చిరునామాలకు ఏ.

1170
01:03:03,380 --> 01:03:09,930
కాబట్టి మేము గమనికలు ఉపయోగించవచ్చు చేస్తాము ఎందుకు కారణం
నేను స్థానాన్ని గుర్తు పెట్టుకోవాలి ఉంటే

1171
01:03:09,930 --> 01:03:12,300
ఒక నిర్దిష్ట వేరియబుల్ జ్ఞాపకాలు.

1172
01:03:12,300 --> 01:03:16,560
>> మీరు అబ్బాయిలు గుర్తు వారిలో ఆ
నేను ఒక ఫంక్షన్ కలిగి ఉంటే సందర్భాల్లో ఉంది

1173
01:03:16,560 --> 01:03:20,820
నేను నిజానికి ఉంటే మీరు కావలసిన
యధార్థాలలో కోసం స్వాప్, నేను నిజానికి

1174
01:03:20,820 --> 01:03:22,110
ఒక పాయింటర్ పంపడానికి కలిగి.

1175
01:03:22,110 --> 01:03:23,460
కాదు వేరియబుల్.

1176
01:03:23,460 --> 01:03:25,200
మీరు అబ్బాయిలు ఆ గుర్తు లేదా?

1177
01:03:25,200 --> 01:03:26,450
తేడా between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
పేరు ఏమిటి?

1180
01:03:34,120 --> 01:03:36,010
విలువ మరియు కాల్ కాలింగ్
సూచనగా, కుడి?

1181
01:03:36,010 --> 01:03:36,840
>> అవును, సరే.

1182
01:03:36,840 --> 01:03:38,330
కాబట్టి విలువ కాల్.

1183
01:03:38,330 --> 01:03:43,570
మీరు ఒక వేరియబుల్ కు పంపినప్పుడు
మీరు కేవలం ఒక విలువ పంపడం చేస్తున్న ఫంక్షన్.

1184
01:03:43,570 --> 01:03:45,610
కాబట్టి మీరు నిజంగా పంపిస్తున్నాం
వేరియబుల్ యొక్క నకలు.

1185
01:03:45,610 --> 01:03:49,720
మీ ప్రోగ్రామ్ తక్కువ పట్టించుకోరు కాలేదు
నిజానికి అదే వేరియబుల్ ఉంటే గురించి

1186
01:03:49,720 --> 01:03:51,650
నకలును.

1187
01:03:51,650 --> 01:03:56,330
>> మరియు సూచన అర్థం ద్వారా కాల్
నేను నిజానికి ఒక కాపీని పంపడం చేస్తున్నాను

1188
01:03:56,330 --> 01:03:57,550
ఆ వేరియబుల్ పాయింటర్.

1189
01:03:57,550 --> 01:04:00,970
కాబట్టి నేను పంపడం చేస్తున్నాను అని అర్థం
ఆ వేరియబుల్ యొక్క స్థానము.

1190
01:04:00,970 --> 01:04:04,440
కాబట్టి నేను స్థానాన్ని అంటుంది
వేరియబుల్, నేను కాల్ ఫంక్షన్

1191
01:04:04,440 --> 01:04:09,700
గమనికలు, నేను నిజానికి సామర్థ్యం రెడీ
ప్రధాన అని డేటా మార్చండి.

1192
01:04:09,700 --> 01:04:12,050
సమంజసం?

1193
01:04:12,050 --> 01:04:17,560
>> అయినప్పటికీ, పాయింటర్ కాపీని ఉంది
పాయింటర్ ఇప్పటికీ వాస్తవ చిరునామా ఉంది

1194
01:04:17,560 --> 01:04:20,090
నేను మార్చడానికి కావలసిన వేరియబుల్.

1195
01:04:20,090 --> 01:04:21,920
సమంజసం?

1196
01:04:21,920 --> 01:04:24,290
>> కాబట్టి గమనికలు సృష్టించడం.

1197
01:04:24,290 --> 01:04:28,410
ఎల్లప్పుడూ పాయింటర్ కలిగి గుర్తుంచుకో
ఇది సూచించే చేసే రకం

1198
01:04:28,410 --> 01:04:29,890
ఒక నక్షత్రానికి అప్పుడు.

1199
01:04:29,890 --> 01:04:31,030
ఆపై మీరు పేరు పెట్టి.

1200
01:04:31,030 --> 01:04:35,765
కాబట్టి మీరు తోచిన గుర్తుంచుకోవాలి
సంసార స్టార్, అది ఒక పాయింటర్ వంటిది

1201
01:04:35,765 --> 01:04:38,990
సంసార వేరియబుల్
మీరు కలిగి టైప్ చేయండి.

1202
01:04:38,990 --> 01:04:42,850
>> కాబట్టి ఇక్కడ స్టార్, ఉదాహరణకు, అది వార్తలు
ఒక పాయింటర్ మరియు పూర్ణాంకం.

1203
01:04:42,850 --> 01:04:47,680
ఆపై చార్ స్టార్ పాయింటర్ ఉంది
చార్ స్టార్ మొదలగునవి.

1204
01:04:47,680 --> 01:04:47,960
అవును?

1205
01:04:47,960 --> 01:04:52,710
>> ప్రేక్షకులు: మనం కలిగి ఉంటే ఒక
n కు పాయింటర్ x నటించనున్నాడు.

1206
01:04:52,710 --> 01:04:55,255
నేను ఆ x ఒక పాయింటర్ సృష్టిస్తుంది తెలుసు.

1207
01:04:55,255 --> 01:04:59,432
దీన్ని కూడా పూర్ణాంకం x డిక్లేర్ లేదు?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: OK, కాబట్టి మీరు n స్టార్ x చెప్పినప్పుడు,
మీరు ఒక ఒక పాయింటర్ సృష్టించడం లేదు

1209
01:05:05,170 --> 01:05:06,000
వేరియబుల్ x.

1210
01:05:06,000 --> 01:05:08,170
మీరు x అనే పాయింటర్ సృష్టిస్తున్నారు.

1211
01:05:08,170 --> 01:05:09,396
>> ప్రేక్షకులు: [వినబడని].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: నేను n స్టార్ x చెప్పినప్పుడు కనుక, నేను రెడీ
హే, మెమరీ లో, నేను వెళుతున్న, చెప్పడం

1213
01:05:14,250 --> 01:05:16,390
ఈ మూడు బాక్సులను ఒకటి పొందండి.

1214
01:05:16,390 --> 01:05:20,750
నేను ఆ చెప్పటానికి వెళుతున్న
ఇది x ఉంటుంది అన్నారు

1215
01:05:20,750 --> 01:05:22,000
వెళుతున్న ఒక పాయింటర్.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
గమనికలు గురించి ఆసక్తికరమైన ఏదో
మేము వారు అని చెప్పారు ఉంది

1218
01:05:30,640 --> 01:05:32,620
32-bit మిషన్ కోసం 4 బైట్లు.

1219
01:05:32,620 --> 01:05:36,320
మరియు ఆ కారణం ఎందుకంటే ఉంది
4 బైట్లు 32 బిట్స్ ఉంటాయి.

1220
01:05:36,320 --> 01:05:40,490
>> 64 బిట్స్ నిజానికి అని మరియు యంత్రాలు
గమనికలు చిరునామాలను కలిగి

1221
01:05:40,490 --> 01:05:43,480
64 బిట్స్ పొడవుగా ఉంటాయి.

1222
01:05:43,480 --> 01:05:49,820
కనుక ఇది కేవలం అర్థం యొక్క పరిమాణం
యంత్రం లో చిరునామాలను భిన్నంగా ఉంటుంది.

1223
01:05:49,820 --> 01:05:52,270
>> కాబట్టి సూచిస్తూ మరియు Dereferencing.

1224
01:05:52,270 --> 01:05:54,310
రెండు ఆపరేటర్ల ఉన్నాయి
మీరు అబ్బాయిలు గుర్తుంచుకోవాలి ఉండాలి.

1225
01:05:54,310 --> 01:05:55,450
మొదటి ఆంపర్సండ్ చిహ్నం ఉంది.

1226
01:05:55,450 --> 01:05:56,810
రెండవ నక్షత్రం.

1227
01:05:56,810 --> 01:06:05,060
ఆ స్టార్ మరియు ఈ ద్వారా అయోమయం పొందలేము
ఎందుకంటే, గుర్తుంచుకోవాలి నటుడు

1228
01:06:05,060 --> 01:06:06,950
ఈ సందర్భంలో, మీరు n స్టార్.

1229
01:06:06,950 --> 01:06:08,700
>> ఇది కలిసి మొత్తం విషయం వంటిది.

1230
01:06:08,700 --> 01:06:10,720
ఏ n ఖాళీ స్టార్ ఉంది.

1231
01:06:10,720 --> 01:06:12,070
కనుక ఇది రకం అని అర్థం.

1232
01:06:12,070 --> 01:06:14,870
మీరు కలిగి ఉన్నప్పుడు ఆ, గుర్తుంచుకో
వేరియబుల్ స్టార్, మీరు ఉన్నాము

1233
01:06:14,870 --> 01:06:16,230
రకం గురించి మాట్లాడటం.

1234
01:06:16,230 --> 01:06:20,540
>> మీరు అప్పుడు కేవలం స్టార్ కలిగి ఉన్నప్పుడు
వేరియబుల్ పేరు, అది అర్థం

1235
01:06:20,540 --> 01:06:24,100
మీరు పాయింటర్, dereferencing చేస్తున్నారు
మీరు శోధిస్తున్న అంటే

1236
01:06:24,100 --> 01:06:28,290
పాయింటర్, చిరునామా కనుగొనడంలో వార్తలు
చెబుతోంది ఆ చిరునామాకు వెళ్తున్నారు,

1237
01:06:28,290 --> 01:06:30,850
మరియు చేసినప్పుడు చూడటం
మీరు అక్కడ.

1238
01:06:30,850 --> 01:06:34,310
నేను మీరు కలిగి ఉన్నప్పుడు ఆ నా విద్యార్థులు చెప్పండి
స్టార్, మీరు ఆ భావించాలని

1239
01:06:34,310 --> 01:06:36,850
కంటెంట్ సంక్షిప్త.

1240
01:06:36,850 --> 01:06:39,770
>> మీరు ఒక పాయింటర్ కలిగి ఉంటే మరియు మీరు
స్టార్ పాయింటర్ పనిని, ఇది వార్తలు

1241
01:06:39,770 --> 01:06:41,720
పాయింటర్ యొక్క కంటెంట్.

1242
01:06:41,720 --> 01:06:44,580
కాబట్టి మీరు సూచించే సంసార వెళ్ళండి
మరియు స్థిర కంటెంట్ చూడండి.

1243
01:06:44,580 --> 01:06:47,730
మరియు ఆంపర్సండ్ చిహ్నం అదే ఉంది
చిరునామా వంటి విషయం.

1244
01:06:47,730 --> 01:06:52,560
>> నేను వంటి a-- ఒక వేరియబుల్ కలిగి ఉంటే కాబట్టి, లెట్స్
పూర్ణాంకానికి ఒక సమానం నేను అని చెప్పాలి 3--

1245
01:06:52,560 --> 01:06:56,900
నేను ఆ చిరునామా కనుగొనేందుకు కావాలా
వేరియబుల్ మెమరీ నేను చెయ్యాలి

1246
01:06:56,900 --> 01:06:58,240
ఒక ఆంపర్సండ్ చిహ్నం.

1247
01:06:58,240 --> 01:07:00,280
కాబట్టి అది ఒక చిరునామా ఉంది.

1248
01:07:00,280 --> 01:07:01,530
సమంజసం?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> కాబట్టి ఇక్కడ ఒక ఉదాహరణ ఉంది.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
ఈ Int బి మరియు Int సి లేదు.

1253
01:07:11,530 --> 01:07:16,520
ఒక 3 అంటే సమానం కాబట్టి Int ఆ
నేను మెమరీ వెళ్ళడానికి వెళుతున్న.

1254
01:07:16,520 --> 01:07:19,870
నేను ఒక స్లాట్ కనుగొనేందుకు వెళుతున్న
మరియు ఇక్కడ సంఖ్య 3 ఉంచండి.

1255
01:07:19,870 --> 01:07:22,200
>> ఆపై Int బి 4 సమానం.

1256
01:07:22,200 --> 01:07:23,100
నేను అదే పనిని చేయడానికి వెళుతున్న.

1257
01:07:23,100 --> 01:07:25,840
మెమరీ వెళ్ళండి మరియు ఒక సంఖ్య చాలు
బాక్సులను ఒకటి 4.

1258
01:07:25,840 --> 01:07:27,100
మరియు Int 5 సమానం.

1259
01:07:27,100 --> 01:07:29,740
మరొక బాక్స్ కనుగొను మరియు ఒక సంఖ్య 5 ఉంచండి.

1260
01:07:29,740 --> 01:07:36,160
>> కాబట్టి అవుట్ చేయడం ఈ లైన్ ఏమిటి?
n star PA ఆంపర్సండ్ చిహ్నం ఒక సమానం.

1261
01:07:36,160 --> 01:07:37,800
కాబట్టి అన్ని మొదటి, N స్టార్ PA.

1262
01:07:37,800 --> 01:07:39,050
ఇది ఏమి ఉంటుంది?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> ప్రేక్షకులు: [వినబడని].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: అవును, కాబట్టి n స్టార్ PA, మొదటి,
PA అనే ​​పాయింటర్ ప్రకటించాడు.

1266
01:07:47,890 --> 01:07:53,720
ఆపై దాని విలువను కేటాయించి యొక్క
ఆ పాయింటర్ ఒక యొక్క చిరునామా అవసరం.

1267
01:07:53,720 --> 01:07:55,790
కాబట్టి ఒక ఆంపర్సండ్ చిహ్నం.

1268
01:07:55,790 --> 01:07:58,510
అప్పుడు, నేను స్టార్ పీబీ లేకపోతే,
ఒక స్టార్ పీబీ ఏమిటి?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> ఓహ్, సారీ.

1271
01:08:03,150 --> 01:08:06,330
ఈ కూడా లేదు. n star పీబీ.

1272
01:08:06,330 --> 01:08:07,905
నేను స్టార్ PC అర్థం.

1273
01:08:07,905 --> 01:08:11,200
నేను క్షమించండి.

1274
01:08:11,200 --> 01:08:11,940
ఇది అదే విషయం.

1275
01:08:11,940 --> 01:08:16,408
కానీ ఇప్పుడు నేను ఒక పాయింటర్ సృష్టించడంలో AR మంచి ఉన్నాను
అప్పుడు సి ఒక పాయింటర్ B మరియు.

1276
01:08:16,408 --> 01:08:16,886
అవును?

1277
01:08:16,886 --> 01:08:18,136
>> ప్రేక్షకులు: [వినబడని]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: అవును.

1280
01:08:26,670 --> 01:08:32,630
కాబట్టి మీరు మెమరీ వెళ్ళండి మరియు మీరు వెళ్ళండి ఉంటే
PA కి రూపకల్పన బాక్స్,

1281
01:08:32,630 --> 01:08:37,149
మీరు నిజంగా చూడాలని
ఒక యొక్క చిరునామాను చూడండి.

1282
01:08:37,149 --> 01:08:38,399
సిద్ధమేనా?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
అవును?

1285
01:08:43,300 --> 01:08:45,605
>> ప్రేక్షకులు: [వినబడని]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: అవును, పాయింటర్ ఒక చిరునామా ఉంది.

1287
01:08:49,260 --> 01:08:50,120
ఎప్పుడూ మర్చిపోవద్దు.

1288
01:08:50,120 --> 01:08:52,800
ఇది అతి ముఖ్యమైన వంటిది
గమనికలు గురించి భాగంగా.

1289
01:08:52,800 --> 01:08:56,180
నిల్వ మరియు చిరునామా ఉంది
కొన్ని వేరియబుల్.

1290
01:08:56,180 --> 01:08:56,890
ఏదైనా?

1291
01:08:56,890 --> 01:08:58,370
ఏదైనా ఇతర ప్రశ్నలు?

1292
01:08:58,370 --> 01:08:59,189
సరే.

1293
01:08:59,189 --> 01:09:00,399
>> కాబట్టి గమనికలు మరియు వ్యూహాలను.

1294
01:09:00,399 --> 01:09:08,189
గుర్తుంచుకో నేను శ్రేణి 3 పూర్ణాంకానికి చేసినప్పుడు,
ప్రధానంగా, నేను ఏమి నేను రకమైన ఉన్నాను ఉంది

1295
01:09:08,189 --> 01:09:12,779
, ఒక పాయింటర్ లో ప్రకటించారు.

1296
01:09:12,779 --> 01:09:18,960
కాబట్టి శ్రేణి రకమైన ఒక పాయింటర్ వలె ఉంటుంది
మెమరీ నిర్దిష్ట స్థానంలో దీనిలో నేను

1297
01:09:18,960 --> 01:09:21,999
పూర్ణాంకాల మూడు విభాగాలు కేటాయించింది.

1298
01:09:21,999 --> 01:09:23,430
ఆ సమంజసం లేదు?

1299
01:09:23,430 --> 01:09:30,250
>> నేను Int శ్రేణి 3 అలా చేసినప్పుడు, నేను ఏమి రెడీ
చేయడం, ప్రధానంగా మూడు సృష్టిస్తుంది

1300
01:09:30,250 --> 01:09:31,479
మెమరీ లో స్లాట్లు.

1301
01:09:31,479 --> 01:09:33,899
నేను మెమరీలో మూడు విభాగాలు చూడండి.

1302
01:09:33,899 --> 01:09:38,810
నేను అప్పుడు, ఒక స్టార్ శ్రేణి, దీన్ని ఉంటే
ప్రధానంగా శ్రేణి యొక్క కంటెంట్ అర్థం,

1303
01:09:38,810 --> 01:09:46,180
ఇది నేను వెళ్ళి, నేను పాయింటర్ వేయండి అర్థం
అది సూచించే చేసే ఆ స్థానానికి,

1304
01:09:46,180 --> 01:09:47,939
నేను సంఖ్య ఒకటి చాలు.

1305
01:09:47,939 --> 01:09:53,729
>> ఆపై, నేను స్టార్ శ్రేణి ప్లస్ 1 చేస్తే,
ఆ శ్రేణి చేయడం అదే విషయం

1306
01:09:53,729 --> 01:09:59,690
కేవలం నేను వెళ్లి అంటే ఒక BRACKETS
ఇది వద్ద గురిపెట్టి ఆ స్థలం.

1307
01:09:59,690 --> 01:10:03,000
ఆపై ప్లస్ 1 తయారీలను
నాకు ఒక స్థానం మారవచ్చు.

1308
01:10:03,000 --> 01:10:06,510
నేను, వాస్తవానికి, ఈ స్థానం వెళ్ళండి
మరియు సంఖ్య రెండు ఉంచండి.

1309
01:10:06,510 --> 01:10:10,900
>> ఆపై, చివరకు, నేను ఉన్నప్పుడు చేయండి
శ్రేణి ప్లస్ 2, నేను ఎక్కడ వెళ్ళండి

1310
01:10:10,900 --> 01:10:11,825
శ్రేణి యొక్క పాయింటింగ్.

1311
01:10:11,825 --> 01:10:14,690
ఆపై నేను మెమరీ బ్లాక్స్ తరలించడానికి.

1312
01:10:14,690 --> 01:10:16,240
ఆపై నేను ఇక్కడ సంఖ్య మూడు ఉంచాలి.

1313
01:10:16,240 --> 01:10:16,600
అవును?

1314
01:10:16,600 --> 01:10:21,400
>> ప్రేక్షకులు: సో స్టార్ వ్యూహం కేవలం ఉంది
మొట్టమొదటి పాయింట్ పేర్కొంది.

1315
01:10:21,400 --> 01:10:25,090
మరియు మీరు కేవలం ఎందుకంటే, 1 జోడించవచ్చు
మేము మాత్రమే నిజంగా ఉన్నారు

1316
01:10:25,090 --> 01:10:27,295
మొదటి చిరునామా సూచిస్తూ.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: అవును.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
ఎందుకు మేము, ఉదాహరణకు, అర్రే చెప్పడం లేదు
0, అర్రే 1 యెరే 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
నేను, ఎందుకు మీరు 0 చేస్తారు మాట్లాడుతూ వెబ్
1, 2, 3 బదులుగా 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
కారణాలు, ఒకటి, కంప్యూటర్
ప్రోగ్రామర్లు ప్రారంభించడానికి ఇష్టపడతారు

1323
01:10:46,550 --> 01:10:47,750
0 నుండి లెక్కింపు.

1324
01:10:47,750 --> 01:10:52,370
మీరు శ్రేణి 0 చేసినప్పుడు ఎందుకంటే రెండు, ఉంది
అది యెరే చేయడం అదే విషయం

1325
01:10:52,370 --> 01:10:56,330
అంటే ప్లస్ 0, నేను వెళ్ళి
ఆ స్థానం, మరియు నేను లేదు

1326
01:10:56,330 --> 01:10:59,320
ఏ మెమరీ బ్లాక్స్ skip.

1327
01:10:59,320 --> 01:11:01,750
కాబట్టి నేను ఏ మెమరీ బ్లాక్స్ తరలించడానికి లేదు.

1328
01:11:01,750 --> 01:11:02,015
అవును?

1329
01:11:02,015 --> 01:11:03,265
>> ప్రేక్షకులు: [వినబడని]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: సో ఆమె ఏమి ఉంది కోరుతూ
చేయడం మధ్య తేడా

1332
01:11:12,670 --> 01:11:14,000
ఈ లేదా malloc చేయడం.

1333
01:11:14,000 --> 01:11:17,550
తేడాలు ఒకటి ఉంది
పూర్ణాంకానికి శ్రేణి 3 సృష్టిస్తుంది

1334
01:11:17,550 --> 01:11:19,260
స్టాక్ శ్రేణి.

1335
01:11:19,260 --> 01:11:23,080
మరియు నేను malloc లేనప్పుడు,
కుప్ప మీద సృష్టిస్తుంది.

1336
01:11:23,080 --> 01:11:25,250
ఆ సమంజసం లేదు?

1337
01:11:25,250 --> 01:11:28,870
>> సో ఎలా malloc వాస్తవానికి పని?

1338
01:11:28,870 --> 01:11:32,245
సో ఎందుకు మేము కూడా malloc ఉపయోగించవచ్చు చేయాలి?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
వ్యక్తులలో మీ కంపైలర్ రకమైన అన్ని
మీరు డిక్లేర్డ్ వేరియబుల్స్.

1341
01:11:39,700 --> 01:11:44,040
మరియు అతను అన్ని కోసం స్థలం సృష్టిస్తుంది
స్టాక్ లో వాటిలో.

1342
01:11:44,040 --> 01:11:47,180
సో మీ వేరియబుల్స్ యొక్క అన్ని వెళ్తున్నారు
ఎక్కడో స్టాక్ ఉండాలి.

1343
01:11:47,180 --> 01:11:49,460
కాబట్టి ఇక్కడ పరిసరం ఉంది.

1344
01:11:49,460 --> 01:11:53,850
>> ఆ వేరియబుల్స్ కాబట్టి ప్రాథమికంగా, స్పేస్
మెమరీలో వద్ద కేటాయించబడుతుంది

1345
01:11:53,850 --> 01:11:55,080
సమయం కంపైల్.

1346
01:11:55,080 --> 01:11:58,790
కనుక ఇది మీ కంప్యూటర్ ఉంది అని అర్థం
ఆ వేరియబుల్స్ యొక్క అన్ని తెలుసు

1347
01:11:58,790 --> 01:11:59,790
ముందుగానే.

1348
01:11:59,790 --> 01:12:02,500
ఇది ఏ విలువ తెలుసుకోవాలి లేదు
మీరు వాటిని ఉంచాలి చేయబోతున్నామని.

1349
01:12:02,500 --> 01:12:05,490
కానీ అది ఎలా తెలుసుకోవాలి
మీరు అవసరం మెమరీని.

1350
01:12:05,490 --> 01:12:09,380
>> కానీ ఇప్పుడు, యొక్క ఉదాహరణకు, అని పిలవబడు
మీరు ఒక అర్రే సృష్టించడంలో లేదా ఒక వేస్తున్నాము

1351
01:12:09,380 --> 01:12:13,430
మీరు వేస్తున్నాము స్ట్రింగ్
వినియోగదారు నుండి.

1352
01:12:13,430 --> 01:12:17,300
మీరు తెలియదు ఎలా దీర్ఘ స్ట్రింగ్
ఉదాహరణకు, అని అన్నారు.

1353
01:12:17,300 --> 01:12:20,600
సో మీరు ఖచ్చితంగా ఎన్ని తెలియదు
మెమరీ బ్లాక్స్ మీరు కుడి, కేటాయించాలని?

1354
01:12:20,600 --> 01:12:24,120
>> కనుక ఇది నిజంగా సమంజసం అనిపించుకోదు
మీరు 100 అక్షరాలు ఉంచాలి చెప్పటానికి.

1355
01:12:24,120 --> 01:12:26,420
ఆపై యూజర్ 150 రాశాడు ఏమి ఉంటే?

1356
01:12:26,420 --> 01:12:27,670
మీరు వత్తిడి కావడం చేస్తున్నారు.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> కాబట్టి ప్రాథమికంగా, మీరు ఎలా ఖచ్చితంగా కాదు
మీరు కేటాయించే అవసరం చాలా మెమరీ

1359
01:12:34,620 --> 01:12:35,960
ఉన్నప్పుడు మీరు ప్రోగ్రామ్ కంపైల్.

1360
01:12:35,960 --> 01:12:38,240
మీరు కేవలం అమలు సమయం తెలుసు.

1361
01:12:38,240 --> 01:12:39,950
మీరు కుప్ప ఎందుకు కాబట్టి ఆ.

1362
01:12:39,950 --> 01:12:47,610
కాబట్టి కుప్ప మెమరీ కలిగి అన్నారు
మీరు సమయంలో పెడుతోంది చేస్తున్న

1363
01:12:47,610 --> 01:12:50,810
ప్రోగ్రామ్ను అమలు వ్యవధి.

1364
01:12:50,810 --> 01:12:55,780
>> కాబట్టి ప్రాథమికంగా, మీరు malloc చేసినప్పుడు, ఏమి
మీరు మెమరీ పెడుతోంది ఉంది చేస్తున్నా

1365
01:12:55,780 --> 01:13:00,160
మీరు ఉన్నాం రన్టైమ్,
ఆ సమయంలో కుడి నిర్ణయించి మీరు

1366
01:13:00,160 --> 01:13:02,670
ఆ స్మృతి ఉండాలి.

1367
01:13:02,670 --> 01:13:04,210
మీరు పెడుతోంది చేసినప్పుడు కాబట్టి ఆ.

1368
01:13:04,210 --> 01:13:06,430
ఆ సమంజసం లేదు?

1369
01:13:06,430 --> 01:13:11,690
>> కాబట్టి స్టాక్ వేరియబుల్స్ ఉన్నాయి గుర్తుంచుకోవాలి
కంపైల్ సమయం సృష్టించబడతాయి.

1370
01:13:11,690 --> 01:13:14,560
ఆపై కుప్ప వేరియబుల్స్ ఉన్నాయి
మీరు వంటి సృష్టించబడతాయి

1371
01:13:14,560 --> 01:13:15,600
ఉదాహరణకు, malloc తో.

1372
01:13:15,600 --> 01:13:16,850
>> ప్రేక్షకులు: [వినబడని]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: కాబట్టి GetString ఉంది
malloc కాల్ అన్నారు.

1375
01:13:24,340 --> 01:13:26,710
నాకు malloc గురించి మాట్లాడటానికి లెట్, మరియు
నేను GetString వివరించడానికి చేస్తాము.

1376
01:13:26,710 --> 01:13:32,000
కాబట్టి malloc అదే విషయం
మెమరీ కేటాయింపు.

1377
01:13:32,000 --> 01:13:34,600
కాబట్టి కేటాయించాలని జరగబోతోంది
కుప్ప మీద మెమరీ.

1378
01:13:34,600 --> 01:13:40,010
మరియు అది ఒక పాయింటర్ తిరిగి వెళుతున్న
అక్కడ ఆ మెమరీ వద్ద కేటాయించారు.

1379
01:13:40,010 --> 01:13:43,090
>> కాబట్టి మీరు do-- ఉన్నప్పుడు

1380
01:13:43,090 --> 01:13:44,910
ఇక్కడ ఉదాహరణకు కోసం

1381
01:13:44,910 --> 01:13:45,830
n star పాయింటర్.

1382
01:13:45,830 --> 01:13:50,520
ఆపై పాయింటర్ malloc సమానం
అంగుళాల సార్లు 10 యొక్క పరిమాణం.

1383
01:13:50,520 --> 01:13:52,110
నేను ఒక పాయింటర్ సృష్టించడంలో చేస్తున్నాను.

1384
01:13:52,110 --> 01:13:59,020
ఆపై నేను ఆ పాయింటర్ కేటాయించి నేను
పాయింటర్ ఆ malloc యొక్క విలువ

1385
01:13:59,020 --> 01:13:59,680
నాకు కల్పించడం.

1386
01:13:59,680 --> 01:14:04,150
>> కాబట్టి నేను అడగడం malloc మీరు కేటాయించాలని
10 పూర్ణాంకాల స్థలం.

1387
01:14:04,150 --> 01:14:05,390
ఆ విధంగా అది ఏమిటి.

1388
01:14:05,390 --> 01:14:09,020
మరియు malloc నాకు తిరిగి ఇచ్చే ఒక
ఆ స్థానంలో పాయింటర్.

1389
01:14:09,020 --> 01:14:11,460
సమంజసం?

1390
01:14:11,460 --> 01:14:12,270
సరే.

1391
01:14:12,270 --> 01:14:17,940
నేను మరియు GetString, ప్రధానంగా, చేస్తున్న
మీరు కేటాయించాలని కాబట్టి malloc కాల్

1392
01:14:17,940 --> 01:14:21,680
రన్టైమ్ నందు మెమరీ.

1393
01:14:21,680 --> 01:14:26,460
>> ఎల్లప్పుడూ శూన్య తనిఖీ గుర్తు
malloc శూన్య తిరిగి వెళుతున్న ఎందుకంటే

1394
01:14:26,460 --> 01:14:28,200
ఇది మెమరీని కేటాయించాల్సిన పోతే.

1395
01:14:28,200 --> 01:14:31,660
మీరు ఒక పరిహాసాస్పదం గోవా అని పిలవబడు
మెమొరీ మొత్తం.

1396
01:14:31,660 --> 01:14:33,950
మీ కంప్యూటర్ చేస్తాడు లేదు
ఎక్కువ కేటాయించాల్సిన చేయగలరు.

1397
01:14:33,950 --> 01:14:36,410
>> కాబట్టి malloc కేవలం అన్నారు
శూన్య తిరిగి.

1398
01:14:36,410 --> 01:14:42,210
కాబట్టి ఎల్లప్పుడూ ఉంటే తనిఖీ గుర్తుంచుకోవాలి
మీరు malloc నుండి వచ్చింది అని పాయింటర్ ఉంది

1399
01:14:42,210 --> 01:14:45,640
NULL లేదా అది ఉంటే, మీరు వాటిని, ఎందుకంటే
ఒక పాయింటర్ dereferencing ఉంటుంది మరియు

1400
01:14:45,640 --> 01:14:48,340
సైడ్ లోపాలుగా దీనివల్ల.

1401
01:14:48,340 --> 01:14:50,930
చివరకు, మర్చిపోతే లేదు
మీ మెమరీ ఉచిత.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc కుప్ప లో మెమొరీ సృష్టిస్తుంది.

1404
01:15:00,560 --> 01:15:03,436
మరియు మీరు మెమరీ విడిపించేందుకు ఉంటుంది
కార్యక్రమం ముగుస్తుంది ముందు.

1405
01:15:03,436 --> 01:15:05,370
సరే, నాకు అన్ని పేర్కొంది.

1406
01:15:05,370 --> 01:15:07,900
క్షమించండి, రాబ్.

1407
01:15:07,900 --> 01:15:07,950
ధన్యవాదాలు.

1408
01:15:07,950 --> 01:15:09,878
>> [చప్పట్లు]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: ఏదైనా గత ప్రశ్నలు
రాబ్ వస్తుంది ముందు?

1410
01:15:12,679 --> 01:15:13,138
సంఖ్య?

1411
01:15:13,138 --> 01:15:13,597
అవును?

1412
01:15:13,597 --> 01:15:15,892
>> ప్రేక్షకులు: నేను చూడలేదు
ఈ ఒక ఆన్లైన్.

1413
01:15:15,892 --> 01:15:17,269
మీరు ఇంకా అది అప్లోడ్ చేసారా?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: నేను డేవ్ అనుకుంటాను
త్వరలో అప్లోడ్.

1415
01:15:19,106 --> 01:15:19,880
>> దవే: ఇది పోస్ట్ చేస్తాము.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: ఇది ఆన్లైన్ ఉంటాం.

1417
01:15:20,310 --> 01:15:21,175
>> ప్రేక్షకులు: ఇది ఇష్టం.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: ఇది జరుగుతోంది?

1419
01:15:22,090 --> 01:15:23,157
సరే.

1420
01:15:23,157 --> 01:15:23,644
అవును?

1421
01:15:23,644 --> 01:15:27,053
>> ప్రేక్షకులు: [వినబడని]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: అవును, మీరు విడిపించేందుకు ఉండాలి అన్ని
కుప్ప ప్రవేశపెడితే ఆ స్మృతి.

1423
01:15:30,285 --> 01:15:31,535
>> ప్రేక్షకులు: [వినబడని]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: అవును.

1426
01:15:36,160 --> 01:15:39,980
మీరు ఒక సంస్కృతి malloc ఏదైనా సమయం,
మీరు ఉచిత ఒక సంస్కృతి ఉండాలి

1427
01:15:39,980 --> 01:15:42,640
మీరు తర్వాత ఆ వేరియబుల్ ఉపయోగించి ఆపడానికి.

1428
01:15:42,640 --> 01:15:44,800
కాబట్టి malloc మరియు ఉచితం
ఎల్లప్పుడూ కలిసి.

1429
01:15:44,800 --> 01:15:45,410
వారి ఉత్తమ స్నేహితులు.

1430
01:15:45,410 --> 01:15:46,720
అవును.

1431
01:15:46,720 --> 01:15:47,970
రాబ్?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> రాబ్: నేను త్వరగా వెళ్తారో.

1434
01:15:56,850 --> 01:16:00,466
మరియు కూడా వీడియో ఇవ్వడానికి చేయబడుతుంది.

1435
01:16:00,466 --> 01:16:01,716
నేను సమయపు చేశారు.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> OK, కాబట్టి వారంలో ఐదు విషయం.

1438
01:16:26,230 --> 01:16:27,970
మేము కలిగి మొదటి విషయం స్టాక్ ఉంది.

1439
01:16:27,970 --> 01:16:33,390
కాబట్టి ఒకే ఒక స్టాక్ ఉంది గుర్తుంచుకోవాలి
క్రియాశీల ఫంక్షన్ కాల్ శాతం ఫ్రేమ్.

1440
01:16:33,390 --> 01:16:34,710
మేము రెండవ ఆ చూస్తారు.

1441
01:16:34,710 --> 01:16:37,850
మరియు వాస్తవానికి క్రియల గుర్తు
ప్రతి స్టాక్ ఫ్రేమ్ లో ఉన్నట్లు వెళ్తున్నారు

1442
01:16:37,850 --> 01:16:41,880
మా విధులు స్థానిక వేరియబుల్స్,
లోనికి ప్రవేశిస్తుంది అని వాదనలు మా

1443
01:16:41,880 --> 01:16:43,880
ఒక జంట తో పాటు విధులు,
ఇతర విషయాలు మీరు నిజంగా లేదు

1444
01:16:43,880 --> 01:16:45,260
గురించి ఆందోళన అవసరం.

1445
01:16:45,260 --> 01:16:50,950
>> కాబట్టి ఇక్కడ పేరు ఒక ఉదాహరణ కార్యక్రమం,
నోటీసు, ప్రధాన తిరిగి printfing ఉంది

1446
01:16:50,950 --> 01:16:52,830
foo 4 విలువ.

1447
01:16:52,830 --> 01:16:57,930
foo కేవలం తిరిగి అన్నారు
బార్ 4 కామా 6 విలువ.

1448
01:16:57,930 --> 01:17:02,380
మరియు బార్ కొన్ని స్థానిక కానుంది
4 సార్లు 6 సమానంగా వేరియబుల్ n.

1449
01:17:02,380 --> 01:17:03,920
మరియు అప్పుడు n తిరిగి.

1450
01:17:03,920 --> 01:17:09,130
>> కాబట్టి యొక్క అంతటా స్టాక్ చూద్దాం
ఈ కార్యక్రమం అసలు మళ్ళా.

1451
01:17:09,130 --> 01:17:10,500
కాబట్టి మన స్టాక్ దిగువన ఉంది.

1452
01:17:10,500 --> 01:17:12,620
స్టాక్ అప్ పెరుగుతుంది గుర్తుంచుకోండి.

1453
01:17:12,620 --> 01:17:15,370
మా స్టాక్ దిగువన కాబట్టి, మేము
ప్రధాన కోసం ఒక స్టాక్ ఫ్రేమ్ కలిగి ఉంటాయి.

1454
01:17:15,370 --> 01:17:17,000
చేసినప్పుడు కార్యక్రమం మొదలవుతుంది, ప్రధాన
ఎల్లప్పుడూ అవతరిస్తుంది

1455
01:17:17,000 --> 01:17:18,560
మా స్టాక్ దిగువన.

1456
01:17:18,560 --> 01:17:20,880
>> మరియు దాని లోపల ఏమి ఉంది మా
ప్రధాన కోసం ఫ్రేమ్ పేర్చడాన్ని?

1457
01:17:20,880 --> 01:17:23,810
అందువలన ప్రాంతీయ ఉన్నాయి అయినప్పటికీ
ప్రధాన వేరియబుల్స్ నేను ముందు చెప్పారు వంటి

1458
01:17:23,810 --> 01:17:29,670
మేము argc మరియు సినీనటి స్థలాన్ని తీసుకొని ఉన్నాయి
ప్రధాన స్టాక్ ఫ్రేమ్ లోపల.

1459
01:17:29,670 --> 01:17:33,260
ఇప్పుడు అన్నారు కాబట్టి ప్రధాన
ఫంక్షన్ foo కాల్.

1460
01:17:33,260 --> 01:17:35,125
ఆ foo మాత్రం అర్థం
దాని స్వంత స్టాక్ ఫ్రేమ్ పొందడానికి.

1461
01:17:35,125 --> 01:17:36,970
>> కాబట్టి ఇప్పుడు మేము లోపల ఉన్నారు
ఫంక్షన్ foo.

1462
01:17:36,970 --> 01:17:38,610
మరియు ఏమి ఇవ్వాలి
foo యొక్క స్టాక్ ఫ్రేమ్?

1463
01:17:38,610 --> 01:17:41,100
వెల్, foo ఒక వాదన లేదా ఉంది.

1464
01:17:41,100 --> 01:17:45,440
ఆ తరువాత మరియు n 4 సమానంగా ఏమి
ప్రధాన foo యొక్క వాదన వంటి గుండా ఉంది.

1465
01:17:45,440 --> 01:17:48,490
>> కాబట్టి ఇప్పుడు foo బార్ కాల్ అన్నారు.

1466
01:17:48,490 --> 01:17:52,070
ఏం బార్ లోపల కలిగి అన్నారు
దాని 'స్టాక్ ఫ్రేమ్?

1467
01:17:52,070 --> 01:17:55,610
ఇది ఆరు సమానంగా 4 y కు సమానంగా x ఉంది.

1468
01:17:55,610 --> 01:17:58,540
మనం చేయబోతున్నామని అన్ని కాదు
బార్ ఎందుకంటే స్టాక్ ఫ్రేమ్ లో

1469
01:17:58,540 --> 01:18:00,580
కూడా ఒక స్థానిక వేరియబుల్ n ఉంది.

1470
01:18:00,580 --> 01:18:03,370
మరియు n మేము 24 సమానంగా సెట్ చూడాలని.

1471
01:18:03,370 --> 01:18:05,750
>> కాబట్టి ఇప్పుడు బార్ లేదా తిరిగి అన్నారు.

1472
01:18:05,750 --> 01:18:09,300
కాబట్టి బార్ 24 చేరుకుంటున్నాయి
స్టాక్ ఫ్రేమ్ foo.

1473
01:18:09,300 --> 01:18:12,560
మరియు బార్ ఇప్పుడు ఆ, తిరిగి ఎందుకంటే
మేము స్టాక్ ఫ్రేమ్ పాపింగ్ చేస్తున్నారు అర్థం

1474
01:18:12,560 --> 01:18:14,250
స్టాక్ ఆఫ్ బార్.

1475
01:18:14,250 --> 01:18:18,430
బార్ జరిగింది కాబట్టి అన్ని మెమరీ
ఉపయోగించి స్టాక్ ఇప్పుడు ఆఫ్లో ఉంది.

1476
01:18:18,430 --> 01:18:21,550
>> ఇప్పుడు, foo కూడా అన్నారు
ప్రధాన 24 తిరిగి.

1477
01:18:21,550 --> 01:18:25,470
కాబట్టి ఇప్పుడు ఆ foo, మెమరీ తిరిగి
ఆ foo దాని 'లో వాడుకుంటున్నారని

1478
01:18:25,470 --> 01:18:27,550
స్టాక్ ఫ్రేమ్ కూడా వెళ్లిపోయిన.

1479
01:18:27,550 --> 01:18:29,660
ఇప్పుడు, ప్రధాన printf కాల్ అన్నారు.

1480
01:18:29,660 --> 01:18:31,660
కాబట్టి printf కేవలం మరొక విధి.

1481
01:18:31,660 --> 01:18:35,320
మేము printf కాల్ చేసినప్పుడు, అది చేస్తాడు
printf మరో స్టాక్ ఫ్రేమ్

1482
01:18:35,320 --> 01:18:36,470
ఫంక్షన్ కాల్.

1483
01:18:36,470 --> 01:18:37,990
>> ఏం మేము printf ప్రయాణిస్తున్న?

1484
01:18:37,990 --> 01:18:40,090
ఆ వెళ్ళడానికి జరగబోతోంది ఏమిటి
దాని స్టాక్ ఫ్రేమ్ లో.

1485
01:18:40,090 --> 01:18:44,970
చాలా కనీసం, మేము అక్కడ చేస్తున్నారు
ఆ శాతం నేను n బ్యాక్స్లాష్ మరియు

1486
01:18:44,970 --> 01:18:47,180
వాదన 24.

1487
01:18:47,180 --> 01:18:50,370
ఇది స్టాక్ ఫ్రేమ్ లో ఇది ఎక్కువ ఉండవచ్చు
printf కొన్ని ఉపయోగించి జరిగితే

1488
01:18:50,370 --> 01:18:51,200
స్థానిక వేరియబుల్స్.

1489
01:18:51,200 --> 01:18:51,920
మేము తెలియదు.

1490
01:18:51,920 --> 01:18:53,810
>> కానీ ఆ printf యొక్క వెళుతుంది
ఫ్రేమ్ స్టేక్.

1491
01:18:53,810 --> 01:18:55,740
ఇది printf అమలు జరగబోతోంది.

1492
01:18:55,740 --> 01:18:56,830
తరువాత printf ప్రదర్శనతో.

1493
01:18:56,830 --> 01:18:57,820
ఇది చేరుకుంటాయి.

1494
01:18:57,820 --> 01:18:58,960
చివరగా, ప్రధాన జరుగుతుంది.

1495
01:18:58,960 --> 01:18:59,860
ప్రధాన చేరుకుంటాయి.

1496
01:18:59,860 --> 01:19:02,020
ఆపై మా కార్యక్రమం జరుగుతుంది.

1497
01:19:02,020 --> 01:19:02,480
అవును?

1498
01:19:02,480 --> 01:19:04,505
>> ప్రేక్షకులు: మీరు చూస్తున్నారు [వినబడని]

1499
01:19:04,505 --> 01:19:05,900
వాదనలు [వినబడని]

1500
01:19:05,900 --> 01:19:06,830
పారామితులు?

1501
01:19:06,830 --> 01:19:09,970
>> రాబ్: సో ఒక సూక్ష్మ తేడా ఉంది
వాదనలు మరియు పారామితులు మధ్య.

1502
01:19:09,970 --> 01:19:14,400
మరియు నిజంగా, సాధారణ మాట్లాడటం, ప్రజలు ఉంటాయి
కేవలం వాటిని అన్ని సమయం అప్ కలపాలి.

1503
01:19:14,400 --> 01:19:17,550
కానీ పారామితులు దుస్తులు ఉంటాయి
విషయాలు యొక్క పేరు లో.

1504
01:19:17,550 --> 01:19:20,180
>> కాబట్టి argc మరియు argv ఉంటాయి
ప్రధాన పరామితులు.

1505
01:19:20,180 --> 01:19:23,440
వాదనలు ఏమి మీరు నిజంగానే
ఆ పారామితులు లో పాస్.

1506
01:19:23,440 --> 01:19:28,340
సో అక్కడ నేను 4 foo, 4 కాల్ చేసినప్పుడు
నేను ప్రయాణిస్తున్న నేను వాదన ఉంది.

1507
01:19:28,340 --> 01:19:31,460
మరియు దాని లోపల పారామితి లేదా,
foo, విలువ 4 తీసుకుంటుంది

1508
01:19:31,460 --> 01:19:32,880
4 నుండి వాదన.

1509
01:19:32,880 --> 01:19:35,826
>> ప్రేక్షకులు: [వినబడని]?

1510
01:19:35,826 --> 01:19:37,880
>> రాబ్: N బార్ ఒక స్థానిక వేరియబుల్ ఉంది.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
N, ఇప్పటికీ foo స్థానిక కానీ
ఇది foo ఒక పారామితి ఉంది.

1513
01:19:44,960 --> 01:19:48,190
ఇది ఒక స్థానిక వేరియబుల్ కాదు.

1514
01:19:48,190 --> 01:19:48,546
అవును?

1515
01:19:48,546 --> 01:19:51,180
>> ప్రేక్షకులు: [వినబడని]?

1516
01:19:51,180 --> 01:19:55,400
>> రాబ్: foo కేవలం కాల్ బార్ మరియు
సంసార బార్ రాబడి తిరిగి.

1517
01:19:55,400 --> 01:19:56,786
>> ప్రేక్షకులు: [వినబడని]?

1518
01:19:56,786 --> 01:19:59,591
>> రాబ్: అవును, కేవలం బహుళ చూడండి
ఫ్రేములు స్టేక్.

1519
01:19:59,591 --> 01:20:00,082
అవును?

1520
01:20:00,082 --> 01:20:03,519
>> ప్రేక్షకులు: ఎందుకు foo అని పిలిచేవారు
printf ముందు?

1521
01:20:03,519 --> 01:20:05,920
>> రాబ్: ఎందుకు foo printf ముందు పిలిచారు?

1522
01:20:05,920 --> 01:20:10,740
నేను చూపుతుంది కాబట్టి, బదులుగా, ఏదో ఒకటి
Int వంటి x 4 వాటిలో foo సమానం

1523
01:20:10,740 --> 01:20:12,980
మరియు అప్పుడు x ముద్రించబడింది.

1524
01:20:12,980 --> 01:20:17,900
కానీ బదులుగా, నేను ఫంక్షన్ కలిపి
printf వాదన కాల్.

1525
01:20:17,900 --> 01:20:23,670
>> కానీ నోటీసు మేము నిజంగా కాదు
మేము వరకు printf కాల్ అమలు

1526
01:20:23,670 --> 01:20:25,610
4 foo ఏమి దొరుకుతుందని.

1527
01:20:25,610 --> 01:20:27,480
కాబట్టి మేము ఈ విశ్లేషించడానికి చూడాలని.

1528
01:20:27,480 --> 01:20:32,504
మరియు ఆ పని యొక్క మాత్రమే ఒకసారి వెళ్తున్నారు
తిరిగి వచ్చి ఈ విశ్లేషించడానికి.

1529
01:20:32,504 --> 01:20:32,990
అవును?

1530
01:20:32,990 --> 01:20:37,364
>> ప్రేక్షకులు: రెండు బార్ నుండి [వినబడని]

1531
01:20:37,364 --> 01:20:41,738
విలువ, మనం [వినబడని] లేదు?

1532
01:20:41,738 --> 01:20:44,400
>> రాబ్: వారు పూర్తిగా పూర్ణాంకానికి ఉండాలి.

1533
01:20:44,400 --> 01:20:46,260
ఆ పై ఆకర్షించింది లేదు
పలుసార్లు.

1534
01:20:46,260 --> 01:20:49,010
కాబట్టి అది Int బార్ మరియు Int ఉండాలి
ఆ రెండూ foo

1535
01:20:49,010 --> 01:20:50,460
పూర్ణాంకాల వస్తుంటాయి.

1536
01:20:50,460 --> 01:20:54,214
వారు వెళ్లి కాకపోతే శూన్యం మాత్రమే
అసలైన విలువలు తిరిగి.

1537
01:20:54,214 --> 01:20:54,692
అవును?

1538
01:20:54,692 --> 01:20:58,038
>> ప్రేక్షకులు: మీరు ఒక లైన్ కలిగి ఉంటే పైన
తిరిగి, [వినబడని]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> రాబ్: తిరిగి పైన ఒక లైన్?

1541
01:21:03,730 --> 01:21:04,410
>> ప్రేక్షకులు: అవును.

1542
01:21:04,410 --> 01:21:10,780
ఇలా మీరు printf మరియు [వినబడని] చేస్తే,
రెండుసార్లు ప్రింట్ చేస్తుంది?

1543
01:21:10,780 --> 01:21:12,992
>> రాబ్: foo లోపలి కాబట్టి?

1544
01:21:12,992 --> 01:21:15,945
మేము ఇక్కడే ఒక printf కలిగి ఉంటే?

1545
01:21:15,945 --> 01:21:16,750
>> ప్రేక్షకులు: అవును.

1546
01:21:16,750 --> 01:21:19,510
>> రాబ్: ఉంటే కాబట్టి మేము ఒక printf హక్కు
ఇక్కడ, అది ఒకసారి ప్రింట్ చేస్తుంది.

1547
01:21:19,510 --> 01:21:23,400
మేము ఒకసారి కుడి foo కాల్ నుండి
ఇక్కడ అప్పుడు మేము printf హిట్ చేస్తాము.

1548
01:21:23,400 --> 01:21:24,620
అప్పుడు మేము బార్ పిలుస్తాను.

1549
01:21:24,620 --> 01:21:25,710
ఆపై foo చేరుకుంటాయి.

1550
01:21:25,710 --> 01:21:26,275
అంతే.

1551
01:21:26,275 --> 01:21:30,985
మేము మాత్రమే ఎప్పుడూ ఎదుర్కునే
ఒకసారి printf.

1552
01:21:30,985 --> 01:21:31,482
అవును?

1553
01:21:31,482 --> 01:21:32,973
>> ప్రేక్షకులు: [వినబడని]

1554
01:21:32,973 --> 01:21:37,950
మేము మొదటి ఉన్నాము ఎందుకంటే printf foo కాల్
printf కాల్ మరియు అప్పుడు మేము అక్కడ చేస్తున్నారు

1555
01:21:37,950 --> 01:21:38,580
వాదనలు.

1556
01:21:38,580 --> 01:21:40,960
>> రాబ్: సిద్ధాంతం కాబట్టి, కాదు
printf foo కాల్?

1557
01:21:40,960 --> 01:21:42,220
సో సంఖ్య.

1558
01:21:42,220 --> 01:21:47,360
సి అన్నారు జస్ట్ ఆర్డర్
మేము ముందు ఈ విషయాలు ఉంది అమలు

1559
01:21:47,360 --> 01:21:49,800
వాదనలు అన్ని ఒక ఫంక్షన్ కాల్
ఫంక్షన్ కలిగి

1560
01:21:49,800 --> 01:21:51,600
పూర్తిగా నిర్ధారణ.

1561
01:21:51,600 --> 01:21:53,540
కాబట్టి ఈ పూర్తిగా పరీక్షించబడుతుంది?

1562
01:21:53,540 --> 01:21:54,610
అవును, అది కేవలం ఒక స్ట్రింగ్.

1563
01:21:54,610 --> 01:21:55,480
ఇది కేవలం ఒక విలువ.

1564
01:21:55,480 --> 01:21:57,200
>> అప్పుడు మేము పూర్తిగా కలిగి
ఈ విశ్లేషించడానికి.

1565
01:21:57,200 --> 01:21:59,720
ఈ ఇప్పుడు అన్ని యొక్క, పూర్తయితే
దాని వాదనలు పరిశీలించిన ఉంటాయి.

1566
01:21:59,720 --> 01:22:01,982
ఇప్పుడు మేము చేయవచ్చు
printf కాల్.

1567
01:22:01,982 --> 01:22:02,478
అవును?

1568
01:22:02,478 --> 01:22:03,966
>> ప్రేక్షకులు: ఒక ప్రశ్న అడిగారు.

1569
01:22:03,966 --> 01:22:06,942
మీరు ఒక గర్జన ఫంక్షన్ కలిగి ఉంటే, తప్పక
మీరు తిరిగి సెమికోలన్ ఉందా?

1570
01:22:06,942 --> 01:22:09,910
>> రాబ్: మీరు తిరిగి సెమికోలన్ లేదు
మీరు ఒక గర్జన ఫంక్షన్ ఉంటే.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
సరే.

1573
01:22:14,780 --> 01:22:15,830
కాబట్టి ఇప్పుడు కొన్ని కుప్ప విషయం.

1574
01:22:15,830 --> 01:22:19,640
కాబట్టి కుప్ప మేము వ్యవహరించే చూడాలని ఎలా ఉంది
డైనమిక్ మెమరీ నిర్వహణ.

1575
01:22:19,640 --> 01:22:23,100
మరియు ఈ నేరుగా తో విభేదిస్తుంది
మేము ఆటోమేటిక్ అంటారని స్టాక్

1576
01:22:23,100 --> 01:22:24,100
మెమరీ నిర్వహణ.

1577
01:22:24,100 --> 01:22:27,140
>> స్టాక్ కాబట్టి, మీరు నిజంగా ఎప్పుడూ
ఎలా స్థానిక వేరియబుల్స్ వ్యవహరించే

1578
01:22:27,140 --> 01:22:30,400
ముందుకు మరియు అన్ని ఆఫ్ popped చేస్తున్నారు
ఈ స్టాక్ ఫ్రేమ్లలో మరియు అన్ని అంశాలను.

1579
01:22:30,400 --> 01:22:31,070
మీరు దాని గురించి ఆందోళన చెందనవసరం లేదు.

1580
01:22:31,070 --> 01:22:32,070
ఇది స్వయంచాలక.

1581
01:22:32,070 --> 01:22:36,990
కాబట్టి కుప్ప మాన్యువల్ ఉంది.

1582
01:22:36,990 --> 01:22:38,070
మరియు [వినబడని]

1583
01:22:38,070 --> 01:22:41,260
ఈ విధులను నుండి వస్తుంది
malloc మరియు ఉచితం.

1584
01:22:41,260 --> 01:22:43,550
>> ఇక్కడ మరొక కార్యక్రమం.

1585
01:22:43,550 --> 01:22:47,145
మేము చేస్తున్నా అన్ని mallocing ఉంది
పూర్ణాంకం.

1586
01:22:47,145 --> 01:22:49,360
మేము స్టార్ X లో నిల్వ చేస్తున్నారు.

1587
01:22:49,360 --> 01:22:52,520
కోర్సు యొక్క, మేము తనిఖీ చేయాలి
X శూన్య ఉంటే చూడటానికి.

1588
01:22:52,520 --> 01:22:56,400
అప్పుడు మేము ఏమి సెట్ చూడాలని
X 50 కు సూచిస్తుంది.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
కు సూచిస్తుంది ఏమి X ముద్రించు
ముద్రణ x, మరియు అప్పుడు ఉచిత x.

1591
01:23:03,260 --> 01:23:08,920
>> కాబట్టి ఎలా ఈ వాస్తవానికి చూడండి అన్నారు
మేము మా స్టాక్ మరియు కుప్ప వద్ద చూస్తే?

1592
01:23:08,920 --> 01:23:10,950
కాబట్టి మేము మళ్ళీ మొదలు పెడతారేమో.

1593
01:23:10,950 --> 01:23:12,580
ముందు గా మా స్టాక్ దిగువన.

1594
01:23:12,580 --> 01:23:15,930
నిన్ను నేరుగా నిండుగా గుర్తుంచుకోండి
స్టాక్ వ్యతిరేకిస్తోంది?

1595
01:23:15,930 --> 01:23:18,850
కాబట్టి మేము చూడాలని
అక్కడికి మా కుప్ప.

1596
01:23:18,850 --> 01:23:22,590
>> మా స్టాక్ దిగువన కాబట్టి, మేము కలిగి
ప్రధాన కోసం మా స్టాక్ ఫ్రేమ్.

1597
01:23:22,590 --> 01:23:28,000
అది argc, argv కోసం స్థలాన్ని, మరియు మేము
ఇప్పుడు ఒక స్థానిక వేరియబుల్ x, కలిగి ఇది

1598
01:23:28,000 --> 01:23:30,030
ఒక పూర్ణాంకానికి నక్షత్రం.

1599
01:23:30,030 --> 01:23:32,240
కాబట్టి మేము iterate చూడాలని
ఈ కార్యక్రమం ద్వారా.

1600
01:23:32,240 --> 01:23:34,420
మేము కలిగి మొదటి విషయం
malloc కాల్.

1601
01:23:34,420 --> 01:23:36,250
>> కాబట్టి మేము malloc కాల్ చేస్తున్న.

1602
01:23:36,250 --> 01:23:37,100
Malloc ఒక ఫంక్షన్ ఉంది.

1603
01:23:37,100 --> 01:23:38,770
ఇది ఒక స్టాక్ ఫ్రేమ్ పరుచుట.

1604
01:23:38,770 --> 01:23:40,180
మనం malloc కు ప్రయాణిస్తున్న?

1605
01:23:40,180 --> 01:23:41,610
ఆ లోపల వెళ్ళడానికి జరగబోతోంది
స్టాక్ ఫ్రేమ్.

1606
01:23:41,610 --> 01:23:45,130
మేము 4 n, పరిమాణం ప్రయాణిస్తున్న చేస్తున్నారు.

1607
01:23:45,130 --> 01:23:49,700
కాబట్టి ఆ malloc కు పంపబడును.

1608
01:23:49,700 --> 01:23:50,910
>> Malloc ఏమి చేస్తుంది?

1609
01:23:50,910 --> 01:23:53,820
ఇది మాకు కుప్ప మీద కొన్ని అంతరిక్ష పనిచేయకుండా.

1610
01:23:53,820 --> 01:23:55,320
కాబట్టి మేము కుప్ప వెళ్ళండి చూడాలని.

1611
01:23:55,320 --> 01:23:57,990
మరియు మేము పట్టుకొను చూడాలని
కుప్ప నుండి 4 బైట్లు.

1612
01:23:57,990 --> 01:24:01,500
కాబట్టి యొక్క ఆ కల్పించడానికి అనుమతిస్తాయి
ఏకపక్ష చిరునామా.

1613
01:24:01,500 --> 01:24:06,680
0x123 జస్ట్ ఒక నటిస్తారు
కుప్ప అని చిరునామా.

1614
01:24:06,680 --> 01:24:12,300
>> కాబట్టి ఆ లోపలి నిజానికి ఏమిటి
చిరునామా Ox123 మెమరీ ప్రాంతంలో?

1615
01:24:12,300 --> 01:24:13,080
గార్బేజ్.

1616
01:24:13,080 --> 01:24:15,270
కాబట్టి మేము అది ఏదైనా నిల్వ లేదు.

1617
01:24:15,270 --> 01:24:18,830
కాబట్టి వరకు మేము తెలిసిన
ఏదైనా కావచ్చు.

1618
01:24:18,830 --> 01:24:20,560
మీరు అది సున్నా వార్తలు భావించవచ్చు.

1619
01:24:20,560 --> 01:24:23,870
ఇది సున్నా ఎక్కువగా ఉంది.

1620
01:24:23,870 --> 01:24:26,260
>> కాబట్టి ఇప్పుడు, malloc తిరిగి వస్తుంది.

1621
01:24:26,260 --> 01:24:28,020
మరియు మేము ఉన్నప్పుడు malloc రాబడి ఏమి చేస్తారు?

1622
01:24:28,020 --> 01:24:29,800
మేము తిరిగి ఏమి సెట్.

1623
01:24:29,800 --> 01:24:32,290
మేము సమానంగా x సెట్ ఏమి
ఇది తిరిగి.

1624
01:24:32,290 --> 01:24:33,690
సో వాట్ అది తిరిగి?

1625
01:24:33,690 --> 01:24:38,150
ఆ ఎందుకంటే ఇది 0x123 తిరిగి
మెమరీ యొక్క బ్లాక్ చిరునామా ఆ

1626
01:24:38,150 --> 01:24:40,850
కేవలం కుప్ప లో కేటాయించింది.

1627
01:24:40,850 --> 01:24:47,160
>> కాబట్టి 0x123 X ఇప్పుడు సెట్ కావడం తిరిగి
0x123 కన్నా, చిత్రాల,

1628
01:24:47,160 --> 01:24:52,940
మేము తరచుగా ఒక వాస్తవ కలిగి X వంటి డ్రా
ఆ బ్లాక్ సూచించే బాణం.

1629
01:24:52,940 --> 01:24:55,820
కానీ x కేవలం ఆ చిరునామా నిల్వ.

1630
01:24:55,820 --> 01:24:58,670
కాబట్టి ఇప్పుడు మేము x శూన్య ఉంటే తనిఖీ చేశారు.

1631
01:24:58,670 --> 01:24:59,120
అది శూన్య కాదు.

1632
01:24:59,120 --> 01:25:02,170
మేము ఆ malloc విజయవంతమైన నటిస్తారు.

1633
01:25:02,170 --> 01:25:04,950
>> కాబట్టి ఇప్పుడు స్టార్ X 50 సమానం.

1634
01:25:04,950 --> 01:25:08,450
కాబట్టి నటుడు అది అర్థం గుర్తు
ఆ చిరునామా వెళ్ళండి.

1635
01:25:08,450 --> 01:25:12,700
కాబట్టి 0x123 మేము చేయబోతున్నామని
ఆ చిరునామా వెళ్ళండి.

1636
01:25:12,700 --> 01:25:14,660
కాబట్టి ఆ అక్కడ మాకు అప్ తెస్తుంది.

1637
01:25:14,660 --> 01:25:16,310
మేము ఆ చిరునామా వద్ద ఏం చేస్తున్నారు?

1638
01:25:16,310 --> 01:25:19,020
మేము 50 నిల్వ చేస్తున్నారు.

1639
01:25:19,020 --> 01:25:22,500
>> కాబట్టి ఈ లైన్ తర్వాత, అది ఏమిటి
విషయాలు లాగా వెళ్తున్నారు.

1640
01:25:22,500 --> 01:25:24,640
కాబట్టి ఇప్పుడు అది ఇకపై వార్తలు
అక్కడ చెత్త.

1641
01:25:24,640 --> 01:25:28,910
ఇప్పుడు మేము 50 ఆ అని తెలుసు
ముఖ్యంగా చిరునామా ఎందుకంటే

1642
01:25:28,910 --> 01:25:32,410
మేము ఆ దానిని సెట్.

1643
01:25:32,410 --> 01:25:32,790
సిద్ధమేనా?

1644
01:25:32,790 --> 01:25:34,370
కాబట్టి ఇప్పుడు మేము F ప్రింట్ చూడాలని.

1645
01:25:34,370 --> 01:25:38,490
>> కాబట్టి మొదటి మేము స్టార్ ముద్రించవచ్చు x చూడాలని.

1646
01:25:38,490 --> 01:25:39,640
కాబట్టి స్టార్ X అంటే ఏంటి?

1647
01:25:39,640 --> 01:25:44,300
మళ్ళీ, స్టార్ x కు వెళ్ళి అర్థం
x సూచించే ఆ విషయం.

1648
01:25:44,300 --> 01:25:47,140
కాబట్టి x ఆ 0x123 గో నిల్వ.

1649
01:25:47,140 --> 01:25:48,490
మేము 50 పొందండి.

1650
01:25:48,490 --> 01:25:50,540
కాబట్టి ఆ F ప్రింట్.

1651
01:25:50,540 --> 01:25:54,900
మరియు అది 50 ముద్రించడానికి జరగబోతోంది అర్థం.

1652
01:25:54,900 --> 01:25:56,850
ఆపై తిరిగి.

1653
01:25:56,850 --> 01:25:58,340
>> ఆపై మేము రెండవ printf కలిగి.

1654
01:25:58,340 --> 01:25:59,370
మేము ఇప్పుడు శాతం పేజి ఉన్నారు.

1655
01:25:59,370 --> 01:26:01,680
మీరు చూడని ఉంటే, ఆ
కేవలం మీరు ఒక పాయింటర్ ప్రింట్ ఎలా.

1656
01:26:01,680 --> 01:26:04,960
కాబట్టి మేము, శాతము ఐ
f, మరియు ఇప్పటికే వారిలో అన్ని.

1657
01:26:04,960 --> 01:26:07,160
కాబట్టి శాతం పే, ఒక పాయింటర్ ప్రింట్.

1658
01:26:07,160 --> 01:26:08,920
>> కాబట్టి x ఒక పాయింటర్ ఉంది.

1659
01:26:08,920 --> 01:26:13,440
కాబట్టి మేము కూడా ముద్రించవచ్చు x చూడాలని ఉంటే,
మేము లోపల నిజానికి ఏమిటి ప్రింటింగ్ చేస్తున్నారు

1660
01:26:13,440 --> 01:26:19,220
కాబట్టి మొదటి 0x123, x,
ముద్రణ F 50 ప్రింట్ అన్నారు.

1661
01:26:19,220 --> 01:26:23,620
రెండవ ముద్రణ F అన్నారు
అవును 0x123 ప్రింట్?

1662
01:26:23,620 --> 01:26:27,460
>> ప్రేక్షకులు: మీరు శాతం ఉపయోగిస్తున్నారా
X ఒక పాయింటర్ ప్రింట్?

1663
01:26:27,460 --> 01:26:31,200
>> రాబ్: సో మీరు శాతం ఉపయోగించగలను
X ఒక పాయింటర్ ప్రింట్?

1664
01:26:31,200 --> 01:26:38,350
కాబట్టి, మీరు కానీ శాతం x కేవలం ఉంది
సాధారణంగా, వంటి మీరు కొన్ని కలిగి ఉంటే

1665
01:26:38,350 --> 01:26:40,325
పూర్ణాంక మరియు మీరు ముద్రించడానికి కావలసిన
అది ఒక హెక్సాడెసిమల్ వంటి.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
మీరు అలా ఎలా కేవలం వార్తలు.

1668
01:26:44,880 --> 01:26:47,160
>> అయితే, శాతం d చేస్తాను
దశాంశంగా ప్రింట్.

1669
01:26:47,160 --> 01:26:50,310
మేము శాతం పొందండి అని వార్తలు
D. నేను కేవలం పూర్ణసంఖ్య.

1670
01:26:50,310 --> 01:26:52,690
శాతం పేజి ప్రత్యేకంగా
గమనికలు కోసం.

1671
01:26:52,690 --> 01:26:54,060
>> కాబట్టి x ఒక పాయింటర్ ఉంది.

1672
01:26:54,060 --> 01:26:56,360
మేము శాతం పేజి ఉపయోగించాలనుకుంటున్నాను.

1673
01:26:56,360 --> 01:26:57,937
కానీ శాతం x పని కాలేదు.

1674
01:26:57,937 --> 01:26:58,414
అవును?

1675
01:26:58,414 --> 01:26:59,664
>> ప్రేక్షకులు: [వినబడని]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> రాబ్: అవును.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
ఈ కోసం కనీసం కాబట్టి కాల్ నేను
ఇక్కడ అది చేర్చలేదు.

1680
01:27:13,440 --> 01:27:19,850
కానీ ఈ రెండు వాదనలు తప్పనిసరిగా ఉంటాయి
ఈ స్టాక్ ఫ్రేమ్ లోపలి

1681
01:27:19,850 --> 01:27:23,040
ఏ స్థానిక వేరియబుల్స్ తో పాటు
printf ఉపయోగించి నిర్మాణము.

1682
01:27:23,040 --> 01:27:27,020
ఆపై తదుపరి కాల్ printf ఇప్పుడు వరకు
printf లోపల స్టాక్ ఫ్రేమ్ ఉంది

1683
01:27:27,020 --> 01:27:33,960
శాతం పేజి బాక్ స్లాష్ n మరియు సంసార
x యొక్క విలువ 0x123 ఇది ఉంది.

1684
01:27:33,960 --> 01:27:34,425
అవును?

1685
01:27:34,425 --> 01:27:35,675
>> ప్రేక్షకులు: [వినబడని]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> రాబ్: ఇది ఏదో ప్రింట్ చేస్తాము
ఈ కనిపిస్తోంది.

1688
01:27:40,880 --> 01:27:41,846
>> ప్రేక్షకులు: [వినబడని].

1689
01:27:41,846 --> 01:27:44,510
>> రాబ్: సో అది చిరునామా రూపంలో ముద్రిస్తుంది.

1690
01:27:44,510 --> 01:27:47,003
ఇది ఒక చిరునామా కనిపిస్తోంది.

1691
01:27:47,003 --> 01:27:47,494
అవును?

1692
01:27:47,494 --> 01:27:49,458
>> ప్రేక్షకులు: [వినబడని]?

1693
01:27:49,458 --> 01:27:51,075
>> రాబ్: ఎందుకు ఏమిటి?

1694
01:27:51,075 --> 01:27:52,920
>> ప్రేక్షకులు: [వినబడని]?

1695
01:27:52,920 --> 01:27:55,240
>> రాబ్: ఎందుకు ఈ పాయింటర్ 4 బైట్లు?

1696
01:27:55,240 --> 01:27:58,500
కాబట్టి ఒక మొత్తం బంచ్ ఉన్నాయి
ఈ ముందు 0 యొక్క.

1697
01:27:58,500 --> 01:28:03,740
కనుక ఇది నిజంగా 0x0000000123 వార్తలు.

1698
01:28:03,740 --> 01:28:06,510
ఒక 64-bit వ్యవస్థ, అక్కడ ఉంటుంది
మరింత సున్నాలు యొక్క మొత్తం బంచ్.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
అవును?

1701
01:28:11,900 --> 01:28:13,150
>> ప్రేక్షకులు: [వినబడని].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> రాబ్: సో మొదటి printf
print-- అన్నారు

1704
01:28:21,130 --> 01:28:21,980
>> ప్రేక్షకులు: [వినబడని].

1705
01:28:21,980 --> 01:28:24,420
>> రాబ్: అవును, అది ముద్రించడానికి జరగబోతోంది
ఏమి x సూచించే ఉంది.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
స్టార్ ఈ ఏమి చెప్పారు
విషయం చెబుతోంది.

1708
01:28:29,070 --> 01:28:30,300
ఇది సాధించండి.

1709
01:28:30,300 --> 01:28:31,455
కాబట్టి అది సూచించే ఏమి?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
ఇది సాధించండి.

1712
01:28:32,410 --> 01:28:33,390
అంటే మనం ప్రింట్ చూడాలని ఏమిటి.

1713
01:28:33,390 --> 01:28:37,020
తదుపరి, అయితే, మేము ఉన్నాము
కేవలం స్వయంగా x ప్రింటింగ్.

1714
01:28:37,020 --> 01:28:38,850
F లోపలి ఏమిటి?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
సరే.

1717
01:28:44,500 --> 01:28:46,620
>> ఆపై, చివరకు, మేము ఉచిత ఉంటుంది.

1718
01:28:46,620 --> 01:28:48,040
మనం విడిపించేందుకు ప్రయాణిస్తున్న?

1719
01:28:48,040 --> 01:28:49,470
మనకు x ప్రయాణిస్తున్న చేస్తున్నారు.

1720
01:28:49,470 --> 01:28:52,380
నేను వాస్తవానికి ప్రదర్శించబడతాయి ఆ సమయం
ఇది స్టాక్ ఫ్రేమ్ లో.

1721
01:28:52,380 --> 01:28:56,370
>> కాబట్టి మేము విలువ ప్రయాణిస్తున్న చేస్తున్నారు
0x123 విముక్తికై.

1722
01:28:56,370 --> 01:28:59,070
కాబట్టి ఇప్పుడు తెలుసు ఉచిత, అన్ని కుడి,
నేను నిండుగా వరకు వెళ్ళాలి

1723
01:28:59,070 --> 01:29:00,050
మరియు ఆ మెమరీ ఉచితం.

1724
01:29:00,050 --> 01:29:03,920
ఇది ఇకపై ఉపయోగించి ఏమి
చిరునామా 0x123 వద్ద ఉంది.

1725
01:29:03,920 --> 01:29:07,010
>> కాబట్టి ఉచిత విడుదల కానుంది
కుప్ప నుండి ఆ.

1726
01:29:07,010 --> 01:29:09,490
ఇప్పుడు మా కుప్ప మళ్ళీ ఖాళీగా ఉంది.

1727
01:29:09,490 --> 01:29:11,120
మేము ఏ మెమరీ లీకేజ్.

1728
01:29:11,120 --> 01:29:12,940
ఇప్పుడు ఉచిత చేరుకుంటాయి.

1729
01:29:12,940 --> 01:29:16,130
ఆ x ఇప్పటికీ 0x123 ఉంటుంది గమనించండి.

1730
01:29:16,130 --> 01:29:18,240
కానీ ఇప్పుడు చెల్లుబాటు అయ్యే మెమరీ కాదు.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
మేము ఇకపై dereference X తప్పక.

1733
01:29:23,986 --> 01:29:24,440
అవును?

1734
01:29:24,440 --> 01:29:27,240
>> ప్రేక్షకులు: 0 అనవసరమైన రాబడి?

1735
01:29:27,240 --> 01:29:28,290
>> రాబ్: 0 అనవసరమైన returen ఉంది?

1736
01:29:28,290 --> 01:29:31,110
అవును.

1737
01:29:31,110 --> 01:29:33,950
మేము అక్కడే ఎందుకంటే ఆ చాలు
మేము గాలి కోసం తిరిగి ఒకటి.

1738
01:29:33,950 --> 01:29:36,830
కాబట్టి అవును, అనుమతిస్తుంది, వంటిది
తిరిగి 0 ఉన్నాయి.

1739
01:29:36,830 --> 01:29:37,310
అవును?

1740
01:29:37,310 --> 01:29:38,560
>> ప్రేక్షకులు: [వినబడని]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> రాబ్: సో ఉచిత ఎక్స్ తర్వాత, ఏమి ఏమవుతుంది
మేము పాయింటర్ dereference ప్రయత్నించినప్పుడు?

1743
01:29:45,580 --> 01:29:47,240
ఇది ఏమీ తప్పు వెళ్ళే అవకాశం ఉంది.

1744
01:29:47,240 --> 01:29:49,330
మేము ఇప్పటికీ 50 పొందుతారు ఇది సాధ్యం.

1745
01:29:49,330 --> 01:29:53,590
>> ఇది మెమరీ ఉంది, కూడా, అవకాశం
ఇప్పుడు ఏదో కోసం వాడుతున్నారు.

1746
01:29:53,590 --> 01:29:57,140
కనుక ఇది వివరింపబడని ప్రవర్తన అనిపిస్తుంది.

1747
01:29:57,140 --> 01:30:00,772
మరియు వివరింపబడని ఏదైనా అర్థం
జరగవచ్చు.

1748
01:30:00,772 --> 01:30:01,250
అవును?

1749
01:30:01,250 --> 01:30:02,500
>> ప్రేక్షకులు: [వినబడని]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> రాబ్: కాదు, కాబట్టి మీరు కేటాయించి
ఏదో x.

1752
01:30:10,830 --> 01:30:15,870
కాబట్టి ఇక్కడే ఉంటే మేము x సమానం అన్నారు
malloc ఏదో else--

1753
01:30:15,870 --> 01:30:17,100
malloc పరిమాణం event--

1754
01:30:17,100 --> 01:30:20,180
ఆ మూలమైన బ్లాక్
మెమరీ విముక్తి లేదు.

1755
01:30:20,180 --> 01:30:21,490
మరియు మేము అధికారికంగా దానిని కోల్పోయారు.

1756
01:30:21,490 --> 01:30:23,150
ఆ మెమొరీ లీక్ ఉంది.

1757
01:30:23,150 --> 01:30:25,090
మేము అన్ని సూచనలు కోల్పోయి
మెమరీ ఆ నిరోధించేందుకు.

1758
01:30:25,090 --> 01:30:26,827
మనం ఇది ఉచితం మార్గమే లేదు.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
OK, కాబట్టి పూర్తి అప్పుడు 0 అంటే తిరిగి.

1761
01:30:36,630 --> 01:30:37,900
>> All right, కాబట్టి స్టాక్ ఓవర్ఫ్లో.

1762
01:30:37,900 --> 01:30:39,320
ఇక్కడ ఆలోచన ఏమిటి?

1763
01:30:39,320 --> 01:30:41,210
కాబట్టి, గుర్తు, కుప్ప డౌన్ అన్నారు.

1764
01:30:41,210 --> 01:30:43,480
స్టాక్ అప్ అన్నారు.

1765
01:30:43,480 --> 01:30:48,000
కాబట్టి ఈ ఉపన్యాసం నుంచి ఉదాహరణకు, ఉంది
నేను ఎక్కడ ప్రధాన కేవలం అన్నారు, అనుకుంటున్నాను

1766
01:30:48,000 --> 01:30:51,380
అన్నారు ఈ ఫంక్షన్ foo, కాల్
పైగా పునరావృతంగా కూడా కాల్ మరియు

1767
01:30:51,380 --> 01:30:52,320
మళ్ళీ.

1768
01:30:52,320 --> 01:30:55,370
>> కాబట్టి ఫ్రేములు వెళ్తున్నారు స్టేక్
సరిగ్గా అదే పని.

1769
01:30:55,370 --> 01:30:58,130
కాబట్టి మనం ప్రధాన తో ఆరంభమవుతుంది చేస్తున్నారు
దిగువన స్టాక్ ఫ్రేమ్.

1770
01:30:58,130 --> 01:31:02,000
అప్పుడు ప్రధాన, foo కాల్ అన్నారు ఇది
ఒక స్టాక్ ఫ్రేమ్ పొందగలిగిన.

1771
01:31:02,000 --> 01:31:04,260
>> అప్పుడు foo foo కాల్ అన్నారు
మళ్ళీ, ఇది పొందగలిగిన

1772
01:31:04,260 --> 01:31:05,500
మరో స్టాక్ ఫ్రేమ్.

1773
01:31:05,500 --> 01:31:08,270
ఆపై మళ్ళీ, మళ్ళీ, మళ్ళీ,
మళ్ళీ వరకు, చివరికి, మేము అమలు

1774
01:31:08,270 --> 01:31:09,190
కుప్ప లోకి.

1775
01:31:09,190 --> 01:31:11,990
కాబట్టి ఈ మేము ఎంత ఉంది
ఒక స్టాక్ ఓవర్ఫ్లో.

1776
01:31:11,990 --> 01:31:14,910
మరియు ఈ సమయంలో, మీరు తప్పు seg.

1777
01:31:14,910 --> 01:31:17,335
లేదా మీరు నిజంగా seg ముందు లోపం ఇష్టం
ఈ సమయంలో కానీ అవును.

1778
01:31:17,335 --> 01:31:19,660
>> ప్రేక్షకులు: కోర్ డంప్
seg లోపం అదే?

1779
01:31:19,660 --> 01:31:26,140
>> రాబ్: సో మీరు విభజన చూస్తారు
తప్పు ముడి వేసారు.

1780
01:31:26,140 --> 01:31:28,760
మీరు ఒక కోర్ డంప్ ఉన్నప్పుడు పొందండి
మీరు తప్పు seg.

1781
01:31:28,760 --> 01:31:32,580
మరియు అది అన్ని ఒక డంప్ వంటిది
మీ ప్రస్తుత మెమరీ విషయాల కాబట్టి

1782
01:31:32,580 --> 01:31:36,670
మీరు ప్రయత్నించండి మరియు గుర్తించడానికి చేసే
ఎందుకు మీరు విమర్శలకు గురయ్యారు seg.

1783
01:31:36,670 --> 01:31:37,135
అవును?

1784
01:31:37,135 --> 01:31:38,385
>> ప్రేక్షకులు: [వినబడని]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> రాబ్: సో ఒక విభజన లోపంగా అంటే
ఒక స్టాక్ ఓవర్ఫ్లో ఉంది.

1787
01:31:45,460 --> 01:31:47,060
కాబట్టి అవసరం లేదు.

1788
01:31:47,060 --> 01:31:49,880
విభజన లోపంగా మీరు ఉన్నాం
ఒక విధంగా హత్తుకునే మెమరీ

1789
01:31:49,880 --> 01:31:50,880
మీరు ఉండకూడదు.

1790
01:31:50,880 --> 01:31:54,750
కాబట్టి ఆ రకమైన ఒక మార్గం, ఎప్పుడు ఉంది
మీరు మేము హత్తుకునే మొదలు, ఓవర్ఫ్లో స్టేక్

1791
01:31:54,750 --> 01:31:58,736
మేము ఉండకూడదు విధంగా మెమరీ.

1792
01:31:58,736 --> 01:31:59,208
అవును?

1793
01:31:59,208 --> 01:32:00,458
>> ప్రేక్షకులు: [వినబడని]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> రాబ్: ఒక అనంతమైన లూప్ యొక్క లోపల కాబట్టి.

1796
01:32:05,830 --> 01:32:08,770
ఇలా, ఈ ఒక పునరావృత అనంతం వంటిది
లూప్ మరియు మేము మరొక పొందండి

1797
01:32:08,770 --> 01:32:09,770
స్టాక్ ప్రతి సమయం ఫ్రేమ్.

1798
01:32:09,770 --> 01:32:13,540
కానీ కేవలం ఒక సాధారణ యొక్క లోపల
అనంతం one-- అయితే

1799
01:32:13,540 --> 01:32:16,390
అలాగే, యొక్క కూడా ముద్రించడం సాధ్యం లెట్ f--

1800
01:32:16,390 --> 01:32:17,040
ఏదో ఒకటి.

1801
01:32:17,040 --> 01:32:18,390
ఏది.

1802
01:32:18,390 --> 01:32:20,610
>> మేము పొందడానికి వెళ్ళడం లేదు చేస్తున్నాం
మరో స్టాక్ ఫ్రేమ్.

1803
01:32:20,610 --> 01:32:22,530
మేము కేవలం వెతికినా ఉంచడానికి వెళుతున్న
ఈ సింగిల్ ఇన్స్ట్రక్షన్ పైగా.

1804
01:32:22,530 --> 01:32:23,920
స్టాక్ పెరుగుతున్న లేదు.

1805
01:32:23,920 --> 01:32:27,290
ఇది ప్రతి పునరావృత వాస్తవం వార్తలు
కాల్ మాకు ఒక స్టాక్ ఫ్రేమ్ కల్పించడం.

1806
01:32:27,290 --> 01:32:31,231
మేము ఒక స్టాక్ ఓవర్ఫ్లో పొందండి ఎందుకు ఆ వార్తలు.

1807
01:32:31,231 --> 01:32:31,728
అవును?

1808
01:32:31,728 --> 01:32:38,189
>> ప్రేక్షకులు: మీరు చేస్తే మీరు పొందడానికి అన్నారు
లూప్ మరియు తరువాత [వినబడని]?

1809
01:32:38,189 --> 01:32:42,000
>> రాబ్: ఉంటే అయితే లూప్ యొక్క లోపల కాబట్టి
ఒక printf ఉంది, మీరు ఇప్పటికీ చేస్తాను

1810
01:32:42,000 --> 01:32:42,790
seg లోపం.

1811
01:32:42,790 --> 01:32:46,090
నేను విషయాలు తికమక కోరుకోలేదు.

1812
01:32:46,090 --> 01:32:46,610
ఇది లూప్ చేస్తాను.

1813
01:32:46,610 --> 01:32:48,225
మీరు ఒక స్టాక్ పొంది
printf కోసం ఫ్రేమ్.

1814
01:32:48,225 --> 01:32:49,580
>> తరువాత printf తిరిగి ఉంటుంది.

1815
01:32:49,580 --> 01:32:50,280
అప్పుడు మీరు మళ్ళీ లూప్ మీరు.

1816
01:32:50,280 --> 01:32:51,460
మీరు ఒక స్టాక్ పొంది
printf కోసం ఫ్రేమ్.

1817
01:32:51,460 --> 01:32:52,850
ఇది తిరిగి ఉంటుంది.

1818
01:32:52,850 --> 01:32:54,060
సింగిల్ స్టాక్ ఫ్రేమ్.

1819
01:32:54,060 --> 01:33:00,215
కాబట్టి మీరు ఈ అనంత పొందడానికి లేదు
స్టాక్ ఫ్రేములు అమర్చాడు.

1820
01:33:00,215 --> 01:33:03,185
>> ప్రేక్షకులు: [వినబడని]?

1821
01:33:03,185 --> 01:33:04,040
>> రాబ్: అవును.

1822
01:33:04,040 --> 01:33:09,360
కాబట్టి ఈ స్టాక్ ఓవర్ఫ్లో జరుగుతుంది
ఈ ఎవరూ ఎందుకంటే

1823
01:33:09,360 --> 01:33:11,600
foo కాల్స్ వస్తుంటాయి.

1824
01:33:11,600 --> 01:33:15,250
మేము తిరిగి ఉంటే, అప్పుడు మేము అలా
స్టాక్ ఫ్రేములు ఓడిపోయిన ప్రారంభం.

1825
01:33:15,250 --> 01:33:17,870
మరియు తర్వాత మేము ఓవర్ఫ్లో పేర్చడాన్ని కాదు.

1826
01:33:17,870 --> 01:33:20,070
మీరు ఒక బేస్ కేసు అవసరం ఎందుకు ఆ వార్తలు
మీ వ్యక్తిగత విధులు కోసం.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
అవును?

1829
01:33:23,479 --> 01:33:27,375
>> ప్రేక్షకులు: సంభావ్య పరిమాణం మరియు
కుప్ప ఒకే స్టాక్

1830
01:33:27,375 --> 01:33:29,880
అన్ని కార్యక్రమాలు?

1831
01:33:29,880 --> 01:33:31,910
>> రాబ్: సుమారు.

1832
01:33:31,910 --> 01:33:35,090
స్టాక్ సంభావ్య పరిమాణం మరియు
అన్ని కార్యక్రమాలు అదే కుప్ప?

1833
01:33:35,090 --> 01:33:37,180
సుమారు.

1834
01:33:37,180 --> 01:33:40,080
కొన్ని పొరబాటున ఉంది
తోబుట్టువుల స్టాక్ మొదలవుతుంది మరియు

1835
01:33:40,080 --> 01:33:42,400
పేరు కుప్ప మొదలవుతుంది.

1836
01:33:42,400 --> 01:33:45,870
మీరు ఒక మొత్తం చాలా కలిగి జరిగితే
ప్రపంచ వేరియబుల్స్ మరియు విషయాలు మీరు వాటిని

1837
01:33:45,870 --> 01:33:49,520
కొన్ని అంతరిక్ష నుండి సర్వులు
మీ కుప్ప కోసం.

1838
01:33:49,520 --> 01:33:54,060
>> ఒక 64-bit వ్యవస్థ మీద, మీరు వాస్తవంగా
అనంతం మెమరీ చేశారు.

1839
01:33:54,060 --> 01:33:55,820
కేవలం చాలా ఉంది.

1840
01:33:55,820 --> 01:33:59,250
32 బిట్స్ మరియు 64 బిట్స్, ఆ మధ్య
ఒక ముఖ్యమైన తేడా ఉంది.

1841
01:33:59,250 --> 01:34:02,350
>> మీరు మరింత మొత్తం చాలా పొందగలిగిన చేస్తున్నారు
ఒక 64-bit స్టాక్ మరియు కుప్ప స్పేస్

1842
01:34:02,350 --> 01:34:05,810
వ్యవస్థ కేవలం ఇంకా ఉంది ఎందుకంటే
వారు ఉపయోగించే చిరునామాలు.

1843
01:34:05,810 --> 01:34:09,360
కానీ ఒక వ్యక్తి వ్యవస్థ మీద, అది రెడీ
స్టాక్ సుమారు అదే మొత్తం

1844
01:34:09,360 --> 01:34:10,785
మరియు కుప్ప స్పేస్.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
అన్ని కుడి.

1847
01:34:15,530 --> 01:34:18,220
>> గత విషయం సంగ్రహం.

1848
01:34:18,220 --> 01:34:19,810
కాబట్టి మీరు ఈ ప్రక్రియను తెలుసుకోవాలి.

1849
01:34:19,810 --> 01:34:22,240
నాలుగు పెద్ద దశలు ఉన్నాయి.

1850
01:34:22,240 --> 01:34:24,400
మొదటి ఒకటి ఉండాలి
గుర్తుంచుకోవడానికి సులభంగా ఉంటుంది.

1851
01:34:24,400 --> 01:34:25,085
ప్రీ ప్రాసెసింగ్.

1852
01:34:25,085 --> 01:34:28,390
ఇది ముందస్తుగా ఉపసర్గ ఉంది.

1853
01:34:28,390 --> 01:34:32,080
కాబట్టి అది అన్నిటికీ ముందు వస్తుంది.

1854
01:34:32,080 --> 01:34:34,000
>> గుర్తు విషయం హాష్ ఉంది.

1855
01:34:34,000 --> 01:34:37,250
కాబట్టి హాష్ నిర్వచిస్తుంది మరియు హాష్ కలిగి
ఆ అన్ని లో.

1856
01:34:37,250 --> 01:34:39,560
ఆ అన్ని ముందు ప్రోసెసర్
నిర్దేశకాలు.

1857
01:34:39,560 --> 01:34:42,030
ఈ విషయాలు ఉన్నాయి
ముందు ప్రాసెసర్ జాగ్రత్త తీసుకుంటుంది.

1858
01:34:42,030 --> 01:34:43,680
>> కాబట్టి ముందుగా ప్రాసెసర్ ఏమి చేస్తుంది?

1859
01:34:43,680 --> 01:34:44,850
ఇది నిజంగా మూగ విషయం.

1860
01:34:44,850 --> 01:34:49,380
ఇది సామర్థ్యం అన్ని ఈ అన్ని ఉన్నాయి
కాపీ, మరియు కట్, మరియు పేస్ట్ కార్యకలాపాలు.

1861
01:34:49,380 --> 01:34:51,790
>> కాబట్టి హాష్ ప్రామాణిక I0 డాట్ h ఇచ్చింది.

1862
01:34:51,790 --> 01:34:52,990
చేయడం ఏమిటి?

1863
01:34:52,990 --> 01:34:56,610
ఇది ప్రామాణిక I0 డాట్ h పట్టుకుని
ఫైల్ మరియు టాప్ లో పేస్ట్

1864
01:34:56,610 --> 01:34:58,960
ఎక్కడికి హాష్ కలిగి చెప్పారు
ప్రామాణిక I0 డాట్ h.

1865
01:34:58,960 --> 01:35:02,480
>> మరియు ఏ హాష్ మేము చేసిన నిర్వచించే
చూసిన, ఏమి అని?

1866
01:35:02,480 --> 01:35:06,730
దీని హాష్ ఆ విలువ కాపీ
మరియు అతికించడానికి నిర్వచిస్తారు నిర్వచించిన

1867
01:35:06,730 --> 01:35:08,500
ఎక్కడ మీరు విలువ ఉపయోగిస్తున్నారు.

1868
01:35:08,500 --> 01:35:13,400
కాబట్టి ప్రాసెసర్ కేవలం నిజంగా చేస్తుంది
సాధారణ టెక్స్ట్ ఆధారిత కార్యకలాపాలు.

1869
01:35:13,400 --> 01:35:15,870
ఇది స్మార్ట్ ఏమీ లేదు.

1870
01:35:15,870 --> 01:35:18,920
కాబట్టి అన్నిటికీ ఉంది
మరింత సంక్లిష్టంగా.

1871
01:35:18,920 --> 01:35:22,970
>> కాబట్టి ఇప్పుడు ఆ ప్రాసెసర్ ఉంది
పూర్తి, మేము నిజానికి తయారు.

1872
01:35:22,970 --> 01:35:24,320
కాబట్టి కంపైల్ అర్థం ఏమిటి?

1873
01:35:24,320 --> 01:35:27,310
మేము ఇప్పుడు సి కోడ్ నుండి వెళుతున్న
అసెంబ్లీ కోడ్.

1874
01:35:27,310 --> 01:35:27,570
అవును?

1875
01:35:27,570 --> 01:35:28,820
>> ప్రేక్షకులు: [వినబడని]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> రాబ్: అవును, మేము ఆ ఆకర్షించింది.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
కాబట్టి కంపైల్.

1880
01:35:38,660 --> 01:35:40,310
మేము అసెంబ్లీకి సి నుండి వెళుతున్న.

1881
01:35:40,310 --> 01:35:42,470
కాబట్టి ఈ ఒక వాస్తవ భాష మార్పు.

1882
01:35:42,470 --> 01:35:45,240
స్వయంగా కంపైల్ నుండి వెళుతున్న అంటే
అధిక స్థాయి భాష

1883
01:35:45,240 --> 01:35:47,340
తక్కువ స్థాయి భాష.

1884
01:35:47,340 --> 01:35:50,720
>> మరియు C అధిక స్థాయి భాష
అసెంబ్లీ పోలిస్తే.

1885
01:35:50,720 --> 01:35:52,320
అసెంబ్లీ ఏమిటి?

1886
01:35:52,320 --> 01:35:56,440
అని దాని సూచనలను, అందంగా
చాలా మీ CPU కోసం చేసిన.

1887
01:35:56,440 --> 01:35:59,130
కానీ మీ కంప్యూటర్లో ఇప్పటికీ చేస్తుంది
అసెంబ్లీ అర్థం కాదు.

1888
01:35:59,130 --> 01:36:01,570
ఇది మాత్రమే వాటిని మరియు సున్నాలు అర్థం.

1889
01:36:01,570 --> 01:36:06,160
కాబట్టి తదుపరి దశలో సమీకరించడం ఇది
ఈ సూచనలను నుండి మాకు తెస్తుంది

1890
01:36:06,160 --> 01:36:08,760
మీ CPU అర్థం మరియు నిజానికి
, వాటిని అనువదిస్తుంది

1891
01:36:08,760 --> 01:36:10,820
వాటిని మరియు సున్నాలు.

1892
01:36:10,820 --> 01:36:13,570
>> బైనరీ అసెంబ్లీ సి సో.

1893
01:36:13,570 --> 01:36:15,870
కానీ నేను ఇంకా ఒక ఎక్జిక్యూటబుల్ లేదు.

1894
01:36:15,870 --> 01:36:19,550
కాబట్టి CS50 లైబ్రరీ యొక్క ఆలోచించవచ్చు.

1895
01:36:19,550 --> 01:36:23,070
మేము ఒక బైనరీ తో మీరు అందించిన
GetString ఉంది ఈ CS50 లైబ్రరీ,

1896
01:36:23,070 --> 01:36:24,400
మరియు GetInt మరియు అన్ని ఆ.

1897
01:36:24,400 --> 01:36:25,700
>> కానీ CS50 లైబ్రరీ

1898
01:36:25,700 --> 01:36:27,650
మరియు స్వయంగా యొక్క ఎక్జిక్యూటబుల్ కాదు.

1899
01:36:27,650 --> 01:36:29,570
ఇది ఒక ప్రధాన చర్య లేదు.

1900
01:36:29,570 --> 01:36:32,230
ఇది బైనరీ కేవలం ఒక బంచ్ వార్తలు
మీరు ఉపయోగించవచ్చు.

1901
01:36:32,230 --> 01:36:41,730
కాబట్టి లింకింగ్ మేము కలిసి అన్ని తీసుకుని ఎలా ఉంది
ఈ వివిధ బైనరీ ఫైళ్ళను

1902
01:36:41,730 --> 01:36:43,110
ఒక వాస్తవ ఎక్జిక్యూటబుల్ లోకి.

1903
01:36:43,110 --> 01:36:45,900
మీరు టైప్ చేసే వన్
డాట్ ఒక డాట్ స్లాష్.

1904
01:36:45,900 --> 01:36:51,660
>> కాబట్టి ఈ ఫైలు వంటిది మీరు
, రాశాడు - సంసార మీ ప్రోగ్రామ్ is--

1905
01:36:51,660 --> 01:36:53,620
Ceaser డాట్ సి.

1906
01:36:53,620 --> 01:36:55,100
కానీ ఇప్పుడు అది సంకలనం చేసిన
బైనరీ డౌన్.

1907
01:36:55,100 --> 01:36:56,480
కాబట్టి Ceaser డాట్ ఓ.

1908
01:36:56,480 --> 01:36:59,620
ఈ మా CS50 బైనరీ గ్రంథాలయాలు ఉంది.

1909
01:36:59,620 --> 01:37:02,284
మరియు వారు కలిపి చేస్తున్నారు
ఒకే ఎక్జిక్యూటబుల్ లోకి.

1910
01:37:02,284 --> 01:37:02,758
అవును?

1911
01:37:02,758 --> 01:37:04,008
>> ప్రేక్షకులు: [వినబడని]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> రాబ్: సో మొదటి ఉన్నాయి, గుర్తు
ఉన్నాయి మరియు వాస్తవానికి ఒక ఉంది హాష్

1914
01:37:12,710 --> 01:37:13,810
ముందు ప్రాసెసర్ అడుగు.

1915
01:37:13,810 --> 01:37:14,750
కానీ ఆ ప్రత్యేక ఉంది.

1916
01:37:14,750 --> 01:37:20,730
మీరు ఏ విధులు ఉపయోగించి కాకపోతే ఆ
అప్పుడు మీ ఫైల్ యొక్క వెలుపల ఉన్నాయి,

1917
01:37:20,730 --> 01:37:26,100
లేదు, మీరు ఏదైనా లింక్ అవసరం లేదు
మీరు ప్రతిదీ కలిగి నుండి.

1918
01:37:26,100 --> 01:37:30,310
>> అన్నాడు ఆ printf లో లింక్ అవుతోంది.

1919
01:37:30,310 --> 01:37:32,820
మీరు printf ఉపయోగించడానికి ఉంటే, ఏదో వార్తలు
ఆ లింక్ చేయాలి

1920
01:37:32,820 --> 01:37:35,740
మీరు వ్రాసే లేదు ఎందుకంటే.

1921
01:37:35,740 --> 01:37:39,530
మరియు, నిజానికి, printf స్వయంచాలకంగా ఉంది
లో లింక్.

1922
01:37:39,530 --> 01:37:42,760
మీరు తెలుసు ఎలా కమాండ్ లైన్ వద్ద లేదా
మీరు కలిగి చూడండి, తయారు టైప్

1923
01:37:42,760 --> 01:37:46,690
లింక్ ఇది డాష్ L CS50,
CS50 లైబ్రరీలో?

1924
01:37:46,690 --> 01:37:49,070
ఆ వంటి printf, మరియు stuff, వెళ్ళి
స్వయంచాలకంగా లింక్ కు.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
ఏదైనా ఏ ఇతర ప్రశ్నలు?

1927
01:37:53,930 --> 01:37:56,280
>> ప్రేక్షకులు: [వినబడని]?

1928
01:37:56,280 --> 01:37:58,300
>> రాబ్: లింకింగ్?

1929
01:37:58,300 --> 01:38:03,450
మేము ఒక మొత్తం బంచ్ కలిగి
వివిధ బైనరీ ఫైళ్లు.

1930
01:38:03,450 --> 01:38:06,410
ఈ కానానికల్ ఉదాహరణ
మేము ఉపయోగించే CS50 లైబ్రరీ ఉంది.

1931
01:38:06,410 --> 01:38:09,960
మేము కంపైల్ మరియు మీరు ఇచ్చిన
ఈ CS50 లైబ్రరీ బైనరీ.

1932
01:38:09,960 --> 01:38:12,410
>> మీరు GetString ఉపయోగించడానికి కావలసిన
మీ ప్రోగ్రామ్ లో.

1933
01:38:12,410 --> 01:38:14,750
కాబట్టి మీరు వెళ్లి, GetString ఉపయోగించడానికి.

1934
01:38:14,750 --> 01:38:19,700
కానీ నా బైనరీ కోడ్ లేకుండా
GetString, మీరు మీ కోడ్ కంపైల్ చేసినప్పుడు

1935
01:38:19,700 --> 01:38:23,140
డౌన్, మీరు నిజంగా అమలు కాదు మీ
కార్యక్రమం GetString స్ట్రింగ్ ఎందుకంటే

1936
01:38:23,140 --> 01:38:25,080
ఇంకా పూర్తిగా నిర్వచించిన లేదు.

1937
01:38:25,080 --> 01:38:29,220
>> మీరు నా బైనరీ లో లింక్ ఇది మాత్రమే
అన్ని, ఇప్పుడు GetString కలిగి

1938
01:38:29,220 --> 01:38:31,130
కుడి, నేను నిజంగా,
GetString అమలు.

1939
01:38:31,130 --> 01:38:32,330
నా ఫైలు పూర్తయింది.

1940
01:38:32,330 --> 01:38:34,208
నేను ఈ అమలు చేయవచ్చు.

1941
01:38:34,208 --> 01:38:34,697
అవును?

1942
01:38:34,697 --> 01:38:37,631
>> ప్రేక్షకులు: మార్చేందుకు లింకింగ్ లేదు
బైనరీ ఎక్సిక్యూటబుల్ ఎలా?

1943
01:38:37,631 --> 01:38:42,032
మీరు ఇతర లేదు కాబట్టి కూడా
గ్రంధాలయాలు, అది ఇప్పటికీ కాదు

1944
01:38:42,032 --> 01:38:44,477
అనువదించడానికి అవసరం
[వినబడని]?

1945
01:38:44,477 --> 01:38:48,640
>> రాబ్: సో ఒక ఎక్జిక్యూటబుల్
బైనరీ లో ఇప్పటికీ ఉంది.

1946
01:38:48,640 --> 01:38:51,750
ఇది కేవలం ఒక మొత్తం కలపడం యొక్క
బైనరీలు కొంత.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> ప్రేక్షకులు: మీరు చాలా ధన్యవాదాలు.

1949
01:38:56,591 --> 01:38:58,560
>> రాబ్: కాదు సమస్య.

1950
01:38:58,560 --> 01:38:59,540
ఏదైనా ఇతర ప్రశ్నలు?

1951
01:38:59,540 --> 01:39:02,001
లేకపోతే, మేము అన్ని సెట్ చేస్తున్నాం.

1952
01:39:02,001 --> 01:39:02,690
అన్ని కుడి.

1953
01:39:02,690 --> 01:39:02,990
ధన్యవాదాలు.

1954
01:39:02,990 --> 01:39:03,590
>> [చప్పట్లు]

1955
01:39:03,590 --> 01:39:04,490
>> ప్రేక్షకులు: ధన్యవాదాలు.

1956
01:39:04,490 --> 01:39:05,740
>> రాబ్: అవును.

1957
01:39:05,740 --> 01:39:06,582