1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [వీక్ 4]

2
00:00:03,000 --> 00:00:05,000
[డేవిడ్ J. మలన్] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:05,000 --> 00:00:08,000
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> ఆల్ ది రైట్, ఈ CS50, మరియు ఈ వారం 4 ప్రారంభంలో ఉంది

5
00:00:12,000 --> 00:00:16,000
మరియు ఈ నెమ్మదిగా సాధ్యం సార్టింగ్ అల్గోరిథంలు ఒకటి.

6
00:00:16,000 --> 00:00:19,000
ఏ మేము అక్కడే వీక్షించారు అదేమిటో?

7
00:00:19,000 --> 00:00:24,000
ఆ, (n ^ 2) + మొత్తం పెద్ద O క్రమంలో, బబుల్ సార్ట్ ఉంది

8
00:00:24,000 --> 00:00:28,000
నిజానికి మేము అనాలో అతనికి ఈ ప్రపంచంలో మాత్రమే వాటిని కాదు

9
00:00:28,000 --> 00:00:30,000
ఏ బబుల్ సార్ట్ లేదా దాని అమలు సమయం.

10
00:00:30,000 --> 00:00:33,000
నిజానికి, ఈ Google యొక్క ఎరిక్ ష్మిత్ ఒక ఇంటర్వ్యూలో

11
00:00:33,000 --> 00:00:45,000
మరియు మాజీ సెనేటర్ బరాక్ ఒబామా కేవలం కొన్ని సంవత్సరాల క్రితం.

12
00:00:45,000 --> 00:00:48,000
>> ఇప్పుడు, సెనేటర్, మీరు, Google వద్ద ఇక్కడ ఉన్నాము

13
00:00:48,000 --> 00:00:54,000
మరియు నేను ఒక ఉద్యోగ ఇంటర్వ్యూ వంటి అధ్యక్ష ఆలోచించడానికి ఇష్టపడతాను.

14
00:00:54,000 --> 00:00:58,000
ఇప్పుడు, అధ్యక్షుడు గా ఉద్యోగంలో పొందడానికి కష్టం, మరియు మీరు ఇప్పుడు వాతావరణాన్ని ద్వారా వెళుతున్న.

15
00:00:58,000 --> 00:01:00,000
ఇది Google ఒక ఉద్యోగం పొందడానికి కూడా కష్టం.

16
00:01:00,000 --> 00:01:05,000
, మేము ప్రశ్నలు, మరియు మేము మా అభ్యర్ధులు ప్రశ్నలు అడగండి

17
00:01:05,000 --> 00:01:10,000
మరియు ఈ ఒక లారీ స్క్విమ్మర్ నుండి.

18
00:01:10,000 --> 00:01:14,000
మీరు అబ్బాయిలు నేను తమాషా థింక్ అయామ్? ఇది కుడి ఇక్కడ ఉన్నారు.

19
00:01:14,000 --> 00:01:18,000
ఒక మిలియన్ 32-bit పూర్ణాంకాల క్రమం అత్యంత ప్రభావవంతమైన మార్గం ఏమిటి?

20
00:01:18,000 --> 00:01:21,000
[నవ్వు]

21
00:01:21,000 --> 00:01:24,000
బాగా

22
00:01:24,000 --> 00:01:26,000
క్షమించండి. >> లేదు, లేదు, లేదు, లేదు.

23
00:01:26,000 --> 00:01:34,000
నేను బబుల్ సార్ట్ వెళ్ళడానికి తప్పు మార్గంలో ఉంటుందని భావిస్తున్నాను.

24
00:01:34,000 --> 00:01:39,000
>> అతనికి ఈ చెప్పారు ఎవరు, న వస్తాయి?

25
00:01:39,000 --> 00:01:43,000
గత వారం, మేము కనీసం ఒక రోజు, కోడ్ విరామం తీసుకుంది రీకాల్

26
00:01:43,000 --> 00:01:46,000
మరియు సాధారణంగా పరిష్కార కొన్ని ఉన్నత స్థాయి ఆలోచనలను మరియు సమస్య దృష్టి సారించడం ప్రారంభించారు

27
00:01:46,000 --> 00:01:49,000
శోధించడం మరియు క్రమబద్ధీకరించేందుకు సందర్భంలో,

28
00:01:49,000 --> 00:01:53,000
మరియు మేము, మేము గత వారం ఈ పేరు చరుస్తారు లేదని ఏదో పరిచయం

29
00:01:53,000 --> 00:01:56,000
కానీ asymptotic సంజ్ఞామానం, బిగ్ O, బిగ్ ఒమేగా,

30
00:01:56,000 --> 00:02:00,000
మరియు కొన్నిసార్లు బిగ్ తీటా సంజ్ఞామానం, మరియు ఈ కేవలం మార్గాలు ఉన్నాయి

31
00:02:00,000 --> 00:02:02,000
అల్గోరిథంలు యొక్క రన్నింగ్ సమయం వివరించే,

32
00:02:02,000 --> 00:02:05,000
ఇది అమలు చేయడానికి ఒక అల్గోరిథం పట్టే ఎంత సమయం.

33
00:02:05,000 --> 00:02:08,000
>> మరియు మీరు పరిమాణం పరంగా మీరు నడుస్తున్న సమయంలో గురించి మాట్లాడారు గుర్తుచేసుకున్నారు ఉండవచ్చు

34
00:02:08,000 --> 00:02:11,000
మేము సాధారణంగా సమస్య ఉండవచ్చు ఏ, n కాల్ ఇన్పుట్, యొక్క,

35
00:02:11,000 --> 00:02:13,000
పేరు n, గది లో ప్రజల సంఖ్య

36
00:02:13,000 --> 00:02:17,000
ఒక ఫోన్ బుక్ లోని పేజీల సంఖ్య, మరియు మేము విషయాలను రాయడం మొదలు

37
00:02:17,000 --> 00:02:21,000
O వంటి (n ^ 2) లేదా O (n) లేదా O (N log N),

38
00:02:21,000 --> 00:02:24,000
మరియు గణిత చాలా ఖచ్చితంగా పని చెయ్యలేదు కూడా

39
00:02:24,000 --> 00:02:28,000
మరియు అది n ఉంది ² - n / 2 లేదా అలాంటిదే

40
00:02:28,000 --> 00:02:31,000
మేము బదులుగా కేవలం, లోయర్ ఆర్డర్ నిబంధనలు కొన్ని తీసివేసినట్లు చేస్తుంది

41
00:02:31,000 --> 00:02:34,000
మరియు ప్రేరణ మేము నిజంగా ఒక కావలసిన ఉంది

42
00:02:34,000 --> 00:02:37,000
విశ్లేషించే లక్ష్యం మార్గం విధమైన

43
00:02:37,000 --> 00:02:39,000
కార్యక్రమాలు యొక్క పనితీరు లేదా అల్గోరిథంలు యొక్క ప్రదర్శన

44
00:02:39,000 --> 00:02:42,000
ఆ రోజు చివరిలో, ఉదాహరణకు, లేదు

45
00:02:42,000 --> 00:02:45,000
మీ కంప్యూటర్ యొక్క వేగాన్ని రోజు.

46
00:02:45,000 --> 00:02:47,000
>> ఉదాహరణకు, మీరు బబుల్ సార్ట్ అమలు ఉంటే,

47
00:02:47,000 --> 00:02:50,000
లేదా మీరు, నేటి కంప్యూటర్లో విధమైన లేదా ఎంపిక విధమైన విలీనం అమలు

48
00:02:50,000 --> 00:02:53,000
ఒక 2 GHz కంప్యూటర్, మరియు మీరు, అమలు

49
00:02:53,000 --> 00:02:56,000
మరియు అది ఒక 3 GHz ఉంది తరువాత సంవత్సరం, సెకన్లు కొన్ని సంఖ్య పడుతుంది

50
00:02:56,000 --> 00:02:59,000
లేదా ఒక 4 GHz కంప్యూటర్, మరియు మీరు ఆ "వావ్, నా అల్గోరిథం దావా ఉండవచ్చు

51
00:02:59,000 --> 00:03:03,000
వాస్తవానికి ఆ సందర్భంలో ఖచ్చితంగా కాదు ఉన్నప్పుడు ", రెండుసార్లు వేగంగా ఉంది.

52
00:03:03,000 --> 00:03:06,000
ఇది కేవలం హార్డ్వేర్ వేగంగా సంపాదించిన చేసింది, కానీ మీ కంప్యూటర్

53
00:03:06,000 --> 00:03:10,000
, అందువలన మేము నిజంగా వంటి వాటిని తీసివేసినట్లు కావలసిన లేదు

54
00:03:10,000 --> 00:03:13,000
2 యొక్క గుణిజాలను లేదా 3 యొక్క గుణిజాలను దానిని వివరించేటప్పుడు విషయానికి వస్తే

55
00:03:13,000 --> 00:03:17,000
ఎంత వేగంగా లేదా నెమ్మదిగా వెళుతున్నా ఒక అల్గోరిథం మరియు నిజంగా కేవలం దృష్టి

56
00:03:17,000 --> 00:03:20,000
n లేదా దాని కొన్ని అంశం, న

57
00:03:20,000 --> 00:03:24,000
కొన్ని శక్తి దాని గత వారం నుండి రకాల సందర్భంలో.

58
00:03:24,000 --> 00:03:27,000
, విలీనం విధమైన సహాయంతో గుర్తుచేసుకున్నారు

59
00:03:27,000 --> 00:03:31,000
మేము బబుల్ సార్ట్ మరియు ఎంపిక విధమైన కంటే ఎక్కువ చేస్తామని ఉన్నాయి

60
00:03:31,000 --> 00:03:33,000
మరియు కూడా ప్రవేశాన్ని విధమైన.

61
00:03:33,000 --> 00:03:36,000
>> మేము మళ్లీ n లాగ్ n మొదలుపెట్టాను, మరియు

62
00:03:36,000 --> 00:03:39,000
లాగ్ n సాధారణంగా పెరిగే ఏదో సూచిస్తుంది గుర్తుచేసుకున్నారు

63
00:03:39,000 --> 00:03:43,000
నెమ్మదిగా తరువాత n, కాబట్టి N log N ఇప్పటివరకు మంచి ఉంది

64
00:03:43,000 --> 00:03:45,000
అది n ² కంటే తక్కువ ఎందుకంటే.

65
00:03:45,000 --> 00:03:47,000
కానీ విలీనంతో విధమైన తో n సాధించడానికి n లాగిన్

66
00:03:47,000 --> 00:03:51,000
మేము పరపతి వచ్చింది ఒక ఆలోచన యొక్క ప్రాధమిక క్రిమి ఏమిటి

67
00:03:51,000 --> 00:03:54,000
మేము కూడా వారం 0 లో తిరిగి కొనుగోలు చేసే?

68
00:03:54,000 --> 00:03:58,000
మేము ఎలా విలీనంతో విధమైన తో తెలివిగా క్రమబద్ధీకరించేందుకు సమస్య పరిష్కరించడానికి వచ్చింది?

69
00:03:58,000 --> 00:04:04,000
బహుశా, కీ అంతర్దృష్టి ఏమిటి?

70
00:04:04,000 --> 00:04:07,000
ఎవరైనా అన్ని వద్ద.

71
00:04:07,000 --> 00:04:09,000
సరే, యొక్క ఒక అడుగు వెనక్కు తీసుకుందాం.

72
00:04:09,000 --> 00:04:11,000
మీ సొంత మాటలలో ది విధమైన విలీనం వివరించండి.

73
00:04:11,000 --> 00:04:15,000
అది ఎలా పని చేశారు?

74
00:04:15,000 --> 00:04:17,000
సరే, మేము వారం 0 తిరిగి వరుస చేస్తాము.

75
00:04:17,000 --> 00:04:19,000
సరే, అవును.

76
00:04:19,000 --> 00:04:22,000
[వినబడని-విద్యార్థి]

77
00:04:22,000 --> 00:04:26,000
మంచి, సరే, మేము 2 ముక్కలుగా సంఖ్యల శ్రేణి విభజించబడింది.

78
00:04:26,000 --> 00:04:29,000
, మేము ఆ ముక్కలు ప్రతి క్రమబద్ధీకరించబడతాయి, ఆపై మేము వాటిని విలీనం

79
00:04:29,000 --> 00:04:33,000
ఈ పెద్ద అని ఒక సమస్యను యొక్క ముందు మరియు మేము ఈ ఆలోచన చూసిన

80
00:04:33,000 --> 00:04:36,000
మరియు ఈ పెద్ద లేదా ఈ పెద్దది ఒక సమస్య గా అప్ వేరుచేయడానికి.

81
00:04:36,000 --> 00:04:38,000
>> ఫోన్ బుక్ ఉదాహరణ గుర్తు.

82
00:04:38,000 --> 00:04:42,000
, క్రితం వారాల నుండి స్వీయ లెక్కింపు అల్గోరిథం రీకాల్

83
00:04:42,000 --> 00:04:45,000
కాబట్టి విలీనం విధమైన ఇక్కడ ఈ pseudocode సంగ్రహించబడిన జరిగినది.

84
00:04:45,000 --> 00:04:48,000
మీరు n మూలకాలు ఇచ్చిన చేసినప్పుడు, మొదటి అది తెలివి తనిఖీ ఉంది.

85
00:04:48,000 --> 00:04:51,000
N <2 అప్పుడు అన్ని వద్ద ఏమీ లేకపోతే

86
00:04:51,000 --> 00:04:55,000
n <2 అప్పుడు n స్పష్టంగా 0 లేదా 1 ఉంటే ఎందుకంటే,

87
00:04:55,000 --> 00:04:57,000
అది గాని ఉంటే మరియు కనుక 0 లేదా 1 క్రమం ఏమీ లేదు.

88
00:04:57,000 --> 00:04:59,000
మీరు పూర్తి చేసిన.

89
00:04:59,000 --> 00:05:01,000
మీ జాబితా ఇప్పటికే తేలికగా క్రమబద్ధీకరించబడింది.

90
00:05:01,000 --> 00:05:04,000
కానీ మీరు 2 లేదా ఎక్కువ అంశాలను పొందారు లేకపోతే ఉంటే కొనసాగి, వాటిని విభజించడానికి

91
00:05:04,000 --> 00:05:06,000
2 భాగాలుగా విడదీస్తుంది, ఎడమ మరియు కుడి.

92
00:05:06,000 --> 00:05:09,000
ఆ చొక్కాలను ప్రతి క్రమీకరించు, ఆపై క్రమబద్ధీకరించబడతాయి విభజించటం విలీనం.

93
00:05:09,000 --> 00:05:13,000
కానీ ఇక్కడ సమస్య మేము punting చేస్తున్నట్లు మొదటి చూపులో ఈ భావం ఉంటుంది.

94
00:05:13,000 --> 00:05:17,000
నేను ఈ n మూలకాలు క్రమం చేయడానికి మీరు అడిగారు ఈ ఆ ఒక వృత్తాకార నిర్వచనం

95
00:05:17,000 --> 00:05:22,000
మరియు మీరు "ఆల్ ది రైట్, జరిమానా, మేము ఆ n / 2 మరియు ఆ n / 2 అంశాలు క్రమం చేస్తాము" నాకు చెప్పుకుంటున్నారు

96
00:05:22,000 --> 00:05:27,000
నా తదుపరి ప్రశ్నకు ఉండబోతుంది "ఎలా మీరు n / 2 అంశాలు క్రమబద్ధీకరించాలి, ఫైన్?"

97
00:05:27,000 --> 00:05:30,000
>> కాని ఈ ప్రోగ్రామ్ యొక్క విధానం యొక్క,

98
00:05:30,000 --> 00:05:33,000
ఈ బేస్ ఆధారాలున్నాయి కాబట్టి, మాట్లాడుతున్నారు,

99
00:05:33,000 --> 00:05:39,000
n వెంటనే 2 తిరిగి వంటి కొన్ని నిర్దిష్ట విలువను <ఉంటే అని ఈ ప్రత్యేక సందర్భంలో.

100
00:05:39,000 --> 00:05:42,000
అదే వృత్తాకార సమాధానం తో ప్రతిస్పందించము.

101
00:05:42,000 --> 00:05:46,000
ఈ ప్రక్రియ, ఈ cyclicity చివరికి ముగుస్తుంది.

102
00:05:46,000 --> 00:05:50,000
నేను "క్రమీకరించు ఈ n మూలకాలు," మీరు అడగండి మీరు, చెప్పినట్టైతే "ఫైన్, ఈ n / 2 క్రమం"

103
00:05:50,000 --> 00:05:53,000
అప్పుడు మీరు "ఫైన్, క్రమీకరించు ఈ n / 4, n / 8, n/16," సే

104
00:05:53,000 --> 00:05:56,000
చివరకు మీరు ఒక పెద్ద తగినంత సంఖ్యలో తిరగడానికి చేస్తాము

105
00:05:56,000 --> 00:05:59,000
మీరు, మీరు చెప్పగలదు సమయంలో, కేవలం 1 మూలకం ఎడమ ఉండాలని

106
00:05:59,000 --> 00:06:02,000
"ఇక్కడ, ఇక్కడ ఒక క్రమబద్ధీకరించబడతాయి ఒకే అంశం."

107
00:06:02,000 --> 00:06:06,000
ఈ అల్గోరిథం యొక్క మెరుపులో అప్ ఇక్కడ నిజానికి నుంచి ఉద్భవించిందని ఉంది

108
00:06:06,000 --> 00:06:09,000
ఒకసారి మీరు ఈ వ్యక్తిగతంగా క్రమబద్ధీకరించబడతాయి జాబితాలు అన్ని,

109
00:06:09,000 --> 00:06:12,000
పనికిరాని కనబడే పరిమాణం 1, మాత్రమే ఉంటాయి అన్ని

110
00:06:12,000 --> 00:06:15,000
మీరు వాటిని విలీనం మరియు వాటిని విలీనం ప్రారంభించిన తర్వాత

111
00:06:15,000 --> 00:06:19,000
రాబ్ వీడియో చివరకు క్రమబద్ధీకరించబడతాయి జాబితా వచ్చింది మీరు చివరకు నిర్మించే.

112
00:06:19,000 --> 00:06:22,000
>> కానీ ఈ ఆలోచన చాలా సార్టింగ్ దాటి.

113
00:06:22,000 --> 00:06:26,000
సూత్రం పిలిచే ఈ కార్యక్రమంలో పొందుపర్చిన ఈ ఆలోచన ఉంది

114
00:06:26,000 --> 00:06:29,000
మీరు ఒక ప్రోగ్రామ్ వస్తే ఆలోచన,

115
00:06:29,000 --> 00:06:32,000
మరియు మీరు మీరే కాల్ కొన్ని సమస్యను పరిష్కరించడానికి,

116
00:06:32,000 --> 00:06:36,000
లేదా, మీరు ఒక పనిచేస్తాయి ప్రోగ్రామింగ్ భాషలు సందర్భంలో ఉంచండి

117
00:06:36,000 --> 00:06:39,000
మరియు ఒక సమస్యను పరిష్కరించడానికి, మీరు ఫంక్షన్ మీరే కాల్

118
00:06:39,000 --> 00:06:42,000
మళ్ళీ, మళ్ళీ, మళ్ళీ, కానీ మీరు చర్య

119
00:06:42,000 --> 00:06:44,000
మీరే అనంతమైన అనేక సార్లు కాల్ చెయ్యలేరు.

120
00:06:44,000 --> 00:06:47,000
చివరికి మీరు, మాట్లాడటానికి, క్రింద అవుట్ ఉంటుంది

121
00:06:47,000 --> 00:06:49,000
మరియు అని కొన్ని హార్డ్ కోడెడ్ బేస్ పరిస్థితిని

122
00:06:49,000 --> 00:06:53,000
ఈ సమయంలో అలా మీరే అని పిలవడం ఆపివేయండి అని మొత్తం ప్రక్రియ

123
00:06:53,000 --> 00:06:56,000
చివరకు నిజానికి ఆగుతుంది.

124
00:06:56,000 --> 00:06:58,000
ఇది నిజంగా recurse కు, శతకము

125
00:06:58,000 --> 00:07:01,000
>> మేము సే,, తో ఉన్న ఒక సరళమైన, అల్పమైన ఉదాహరణ చేయవచ్చు ఉంటే, యొక్క చూసేలా

126
00:07:01,000 --> 00:07:03,000
ఇక్కడ వేదికపై నాతో 3 ప్రజలు, ఎవరైనా సౌకర్యవంతమైన ఉంటే.

127
00:07:03,000 --> 00:07:06,000
అప్, 2 మరియు 3 న 1, వస్తాయి.

128
00:07:06,000 --> 00:07:09,000
మీరు 3 ఇక్కడ వచ్చి చేయండి.

129
00:07:09,000 --> 00:07:12,000
మీరు ఒక లైన్ లో ఇక్కడ నాకు కుడి ప్రక్కన నిలబడి చేయాలనుకుంటే, అనుకుందాం ఆ చేతిలో సమస్య

130
00:07:12,000 --> 00:07:15,000
చాలా తేలికగా ఇక్కడ ఉన్నారు వ్యక్తుల గణన.

131
00:07:15,000 --> 00:07:18,000
కానీ స్పష్టముగా, నేను ఈ లెక్కింపు ఉదాహరణ అలసిన ఉన్నాను.

132
00:07:18,000 --> 00:07:21,000
ఇది కొంత సమయం, 1, 2, మరియు డాట్, డాట్, డాట్ తీసుకోవాలని అన్నారు.

133
00:07:21,000 --> 00:07:23,000
ఇది ఎప్పటికీ తీసుకోవాలని చెప్పారు.

134
00:07:23,000 --> 00:07:25,000
నేను సహాయంతో పూర్తిగా రౌడీ ఈ సమస్య యొక్క మీ పేరు ఏమిటి? కాకుండా మీరు

135
00:07:25,000 --> 00:07:27,000
సారా. >> సారా, అన్ని కుడి.

136
00:07:27,000 --> 00:07:29,000
కెల్లీ. >> కెల్లీ మరియు?

137
00:07:29,000 --> 00:07:31,000
>> విల్లీ. >> విల్లీ, సారా, కెల్లీ, మరియు విల్లీ.

138
00:07:31,000 --> 00:07:34,000
ప్రస్తుతం నేను ఎవరో ప్రశ్న కోరారు

139
00:07:34,000 --> 00:07:37,000
ఎంత మంది ఈ వేదికపై వరకు, మరియు నేను సంఖ్య ఆలోచన ఉంది.

140
00:07:37,000 --> 00:07:40,000
ఈ ఒక నిజంగా పొడవైన జాబితా, కావున బదులుగా నేను ఈ ట్రిక్ చేయ బోతున్నాను.

141
00:07:40,000 --> 00:07:43,000
నేను, కృతి యొక్క అత్యంత చేయడానికి నా ప్రక్కన వ్యక్తి అడగండి వెళుతున్న

142
00:07:43,000 --> 00:07:46,000
మరియు ఒకసారి ఆమె పని చాలా చేయడం జరుగుతుంది

143
00:07:46,000 --> 00:07:49,000
నేను సాధ్యం పని కనీసం మొత్తం చేయబోవడం మరియు కేవలం 1 జోడించండి నేను

144
00:07:49,000 --> 00:07:51,000
, కాబట్టి ఇక్కడ వెళ్ళండి ఏమైనా ఆమె సమాధానం కు.

145
00:07:51,000 --> 00:07:54,000
నేను వేదిక పై ఎన్ని ప్రజలు కోరారు చేసిన.

146
00:07:54,000 --> 00:07:57,000
ఎంత మంది మీరు ఎడమ వైపున వేదికపై ఉన్నాయి?

147
00:07:57,000 --> 00:08:00,000
సరే >>? నా ఎడమ, కానీ మోసం లేదు.

148
00:08:00,000 --> 00:08:04,000
ఆ సరైన అని, మంచి, కానీ మేము ఈ తర్కం కొనసాగించాలని మీరు ఉంటే

149
00:08:04,000 --> 00:08:08,000
మీరు అదేవిధంగా మీరు ఎడమ వైపున రౌడీ ఈ సమస్య చేయదలిచిన యొక్క ఊహించుకోవటం తెలియజేయండి

150
00:08:08,000 --> 00:08:11,000
కాబట్టి కాకుండా సమాధానం కంటే నేరుగా ముందుకు మరియు కేవలం బక్ పాస్.

151
00:08:11,000 --> 00:08:14,000
ఓహ్, నా ఎడమ ఎన్ని ప్రజలు?

152
00:08:14,000 --> 00:08:16,000
ఎడమవైపు ఎంత మంది ఉన్నారు?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[నవ్వు]

155
00:08:27,000 --> 00:08:30,000
సరే, 0, కనుక ఇప్పుడు విల్లీ చేశారు

156
00:08:30,000 --> 00:08:33,000
మీ సమాధానం 0 మాట్లాడుతూ ఈ దిశలో తిరిగి చేసిన ఉంది.

157
00:08:33,000 --> 00:08:36,000
ఇప్పుడు, మీరు ఏమి చెయ్యాలి? >> 1.

158
00:08:36,000 --> 00:08:39,000
సరే, మీరు 1, కాబట్టి మీరు చెప్పిన "అన్ని కుడి, నేను 1 జోడించండి వెళుతున్న

159
00:08:39,000 --> 00:08:41,000
కు ఏ విల్లీ యొక్క లెక్కింపు జరిగింది, "కాబట్టి 1 + 0.

160
00:08:41,000 --> 00:08:43,000
కుడివైపు మీ సమాధానం మీరు ఇప్పుడు 1 ఉన్నాము ఇప్పుడు

161
00:08:43,000 --> 00:08:45,000
1. >> ఆ గని 2 ఉంటుంది.

162
00:08:45,000 --> 00:08:48,000
, కాబట్టి మీరు, 1 మునుపటి సమాధానం గుడ్ వేస్తున్నాము

163
00:08:48,000 --> 00:08:51,000
మీరు చేయాలనుకుంటున్నారా పని తక్కువగా జోడించడం, ఇది +1 ఉంది.

164
00:08:51,000 --> 00:08:55,000
మీరు ఇప్పుడు 2 కలిగి, మరియు మీరు నాకు ఏ విలువ చేతితో?

165
00:08:55,000 --> 00:08:57,000
3, నేను, క్షమించాలి, 2 అర్ధం.

166
00:08:57,000 --> 00:08:59,000
గుడ్.

167
00:08:59,000 --> 00:09:02,000
>> Well, మేము ఎడమ 0 వచ్చింది.

168
00:09:02,000 --> 00:09:05,000
, అప్పుడు మేము 1, మరియు ఆ తరువాత మేము 2 జోడించండి

169
00:09:05,000 --> 00:09:07,000
ఇప్పుడు మీరు నాకు సంఖ్య 2 ఇవ్వడానికి మీరు

170
00:09:07,000 --> 00:09:10,000
మరియు నేను 3, +1, సరే, చెప్పడం నేను.

171
00:09:10,000 --> 00:09:13,000
ఈ వేదికపై నా ప్రక్కన నిలబడి 3 ప్రజలు నిజానికి ఉంది

172
00:09:13,000 --> 00:09:16,000
కాబట్టి మేము సహజంగా, చాలా సరళంగా ఈ చేసి

173
00:09:16,000 --> 00:09:19,000
స్పష్టమైన పద్ధతిలో చాలా, కాని మేము నిజంగా ఏం చేసావ్?

174
00:09:19,000 --> 00:09:21,000
మేము మొదట పరిమాణం 3 యొక్క ఒక సమస్య పట్టింది.

175
00:09:21,000 --> 00:09:24,000
మేము అప్పుడు, పరిమాణం 2 యొక్క ఒక సమస్య గా విఫలమయ్యాయి

176
00:09:24,000 --> 00:09:27,000
అప్పుడు 1 పరిమాణం సమస్య, మరియు అప్పుడు మూల కేసు చివరకు

177
00:09:27,000 --> 00:09:29,000
నిజానికి, OH, అక్కడ ఎవరూ ఉన్నది

178
00:09:29,000 --> 00:09:33,000
ఈ దశలో విల్లీ, ఒక హార్డ్ కోడెడ్ సమాధానం సార్లు రెండు సమర్థవంతంగా తిరిగి

179
00:09:33,000 --> 00:09:36,000
మరియు రెండవది తర్వాత, bubbled, అప్ bubbled, అప్ bubbled జరిగినది

180
00:09:36,000 --> 00:09:39,000
మరియు ఈ ఒక అదనపు 1 లో జోడించడం ద్వారా

181
00:09:39,000 --> 00:09:41,000
మేము సూత్రం ఈ ప్రాథమిక ఆలోచన అమలు చేసిన.

182
00:09:41,000 --> 00:09:44,000
>> ఇప్పుడు, ఈ సందర్భంలో ఇది నిజంగా ఒక సమస్యను పరిష్కరించడానికి లేదు

183
00:09:44,000 --> 00:09:46,000
ఏ మరింత సమర్థవంతంగా అప్పుడు మేము ఇప్పటివరకు చూసిన.

184
00:09:46,000 --> 00:09:48,000
కానీ మేము ఇప్పటివరకు వేదిక చేసిన అల్గోరిథంలు గురించి ఆలోచించటం.

185
00:09:48,000 --> 00:09:51,000
మేము, సుద్ద బోర్డ్ పత్రిక యొక్క 8 ముక్కలు కలిగి

186
00:09:51,000 --> 00:09:55,000
వీడియో మీద సీన్ సంఖ్య 7 కోసం చూస్తున్నాడు, మరియు అతను నిజంగా ఏం చేసావ్ ఉన్నప్పుడు?

187
00:09:55,000 --> 00:09:58,000
Well, అతను విభజన ఎలాంటి చేయండి మరియు ఆక్రమించేందుకు లేదు.

188
00:09:58,000 --> 00:10:01,000
ఆయన సూత్రం ఎలాంటి ఆడలేదు.

189
00:10:01,000 --> 00:10:03,000
అయితే అతను ఈ సరళ అల్గోరిథం చేశాడు.

190
00:10:03,000 --> 00:10:07,000
కానీ మేము వేదిక పైన విభజించిన సంఖ్యల ఆలోచన పరిచయం చేసినప్పుడు గత వారం నివసిస్తున్నారు

191
00:10:07,000 --> 00:10:09,000
అప్పుడు మేము, మధ్య వెళ్ళి ఈ స్వభావం కలిగి

192
00:10:09,000 --> 00:10:13,000
ఈ సమయంలో మేము, పరిమాణం 4 లేదా పరిమాణం 4 యొక్క మరొక జాబితా యొక్క ఒక చిన్న జాబితా కలిగి

193
00:10:13,000 --> 00:10:17,000
మరియు తర్వాత మేము ఖచ్చితమైన సమస్య ఉంది, అందుచే మేము పునరావృతం, పునరావృతం, పునరావృతం.

194
00:10:17,000 --> 00:10:19,000
ఇతర మాటల్లో చెప్పాలంటే, recursed.

195
00:10:19,000 --> 00:10:24,000
మాతో సూత్రం ప్రదర్శించినందుకు ఇక్కడ మా 3 స్వచ్ఛంద సేవకుల చాలా ధన్యవాదాలు.

196
00:10:24,000 --> 00:10:28,000
>> మేము ఇప్పుడు కొంచెం కాంక్రీటు ఈ చేయలేరు లేదో యొక్క చూసేలా,

197
00:10:28,000 --> 00:10:30,000
మళ్ళీ మేము చాలా సులభంగా చేయగల ఒక సమస్యలను పరిష్కరించటం,

198
00:10:30,000 --> 00:10:34,000
కానీ మేము ఈ ప్రాథమిక ఆలోచన అమలు ఒక పునాది రాయి గా ఉపయోగించండి.

199
00:10:34,000 --> 00:10:37,000
నేను, సంఖ్యల సమూహాన్ని సమ్మషన్ గణించడం చేయాలనుకుంటే

200
00:10:37,000 --> 00:10:39,000
ఉదాహరణకు, మీరు సంఖ్య 3 లో పాస్ ఉంటే,

201
00:10:39,000 --> 00:10:42,000
నేను, మీరు సిగ్మా 3 యొక్క విలువ ఇవ్వాలని

202
00:10:42,000 --> 00:10:46,000
కాబట్టి 3 మొత్తం + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
నేను, సమాధానం 6 తిరిగి పొందడానికి కావలసిన

204
00:10:48,000 --> 00:10:51,000
కాబట్టి మేము ఈ సిగ్మా ఫంక్షన్, ఈ సమ్మషన్ ఫంక్షన్ అమలు ఉంటాం

205
00:10:51,000 --> 00:10:54,000
ఆ, మళ్ళీ, ఇన్పుట్ లో పడుతుంది, మరియు అప్పుడు సమ్మషన్ తిరిగి

206
00:10:54,000 --> 00:10:57,000
డౌన్ 0 ఆ సంఖ్య అన్ని మార్గం.

207
00:10:57,000 --> 00:10:59,000
మేము కుడి, అందంగా కేవలం ఈ చేయగల?

208
00:10:59,000 --> 00:11:01,000
మేము, మళ్ళీ వెతికినా నిర్మాణం ఏదో ఈ చేయగల

209
00:11:01,000 --> 00:11:04,000
కాబట్టి నన్ను ముందుకు వెళ్లి ఈ ప్రారంభించడానికి అనుమతిస్తాయి.

210
00:11:04,000 --> 00:11:07,000
>> Stdio.h చేర్చండి.

211
00:11:07,000 --> 00:11:09,000
ఇక్కడ పని నాకు ప్రధాన లోకి నాకు పొందండి లెట్.

212
00:11:09,000 --> 00:11:12,000
లెట్ యొక్క sigma.c ఈ సేవ్.

213
00:11:12,000 --> 00:11:14,000
అప్పుడు నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు నేను, ఒక పూర్ణాంకానికి n డిక్లేర్ వెళుతున్న

214
00:11:14,000 --> 00:11:18,000
మరియు నేను యూజర్ సహకారం లేదు, అయితే క్రింది వాటిని వెళుతున్న.

215
00:11:18,000 --> 00:11:22,000
యూజర్ me సానుకూల నంబర్ ఇవ్వలేదు అయితే

216
00:11:22,000 --> 00:11:26,000
నాకు ముందుకు వెళ్లి n = GetInt కోసం ప్రాంప్ట్ తెలియజేయండి

217
00:11:26,000 --> 00:11:28,000
మరియు, వారిని ఏమి కొన్ని సూచనలు కల్పించడానికి అనుమతిస్తాయి

218
00:11:28,000 --> 00:11:33,000
కాబట్టి printf ("సానుకూల పూర్ణాంక దయచేసి").

219
00:11:33,000 --> 00:11:39,000
సమయానికి మేము లైన్ 14 కొట్టిన ఈ వంటి సులభమైన జస్ట్ ఏదో

220
00:11:39,000 --> 00:11:42,000
మేము ఇప్పుడు n బహుశా ఒక సానుకూల పూర్ణాంక ఉన్నాయి.

221
00:11:42,000 --> 00:11:44,000
>> ఇప్పుడు అది ఏదో ఒకటి చూద్దాం.

222
00:11:44,000 --> 00:11:50,000
నాకు ముందుకు వెళ్లి సమ్మషన్ గణించడం తెలియజేయండి, కనుక Int మొత్తం = సిగ్మా (n).

223
00:11:50,000 --> 00:11:54,000
సిగ్మా కేవలం సమ్మషన్ ఉంది, కాబట్టి నేను ఫ్యాన్సియెర్స్ విధంగా అది వ్రాసే నేను.

224
00:11:54,000 --> 00:11:56,000
మేము అక్కడే అది సిగ్మా పిలుస్తాను.

225
00:11:56,000 --> 00:11:58,000
ఆ మొత్తాన్ని, మరియు ఇప్పుడు నేను, ఫలితంగా ముద్రించాలా వెళుతున్న

226
00:11:58,000 --> 00:12:08,000
printf (మొత్తం "మొత్తం d, \ n% ఉంది").

227
00:12:08,000 --> 00:12:11,000
మరియు నేను మంచి కొలత కోసం 0 తిరిగి పొందుతారు.

228
00:12:11,000 --> 00:12:15,000
మేము, ఆసక్తికరమైన భాగంగా తప్ప ఈ కార్యక్రమం అవసరం ప్రతిదీ చేసిన

229
00:12:15,000 --> 00:12:18,000
ఇది వాస్తవానికి సిగ్మా ఫంక్షన్ అమలు ఉంది.

230
00:12:18,000 --> 00:12:22,000
>> నాకు క్రింద ఇక్కడ డౌన్ వెళ్ళి, నాకు ఫంక్షన్ సిగ్మా డిక్లేర్ తెలియజేయండి లెట్.

231
00:12:22,000 --> 00:12:26,000
ఇది రకం పూర్ణాంకం యొక్క అని ఒక వేరియబుల్ తీసుకోవాలని సంపాదించి

232
00:12:26,000 --> 00:12:30,000
ఏ డేటా రకం సిగ్మా నుండి బహుశా తిరిగి అనుకుంటున్నారు?

233
00:12:30,000 --> 00:12:34,000
Int, నేను లైన్ 15 నా అంచనాలను మ్యాచ్ మీరు ఎందుకంటే.

234
00:12:34,000 --> 00:12:37,000
ఇక్కడ నాకు ముందుకు వెళ్లి ఈ అమలు తెలియజేయండి

235
00:12:37,000 --> 00:12:41,000
ఒక అందమైన సూటిగా విధంగా.

236
00:12:41,000 --> 00:12:45,000
>> యొక్క ముందుకు వెళ్లి Int మొత్తం = 0 అని పిలవబడు,

237
00:12:45,000 --> 00:12:47,000
మరియు ఇప్పుడు నేను ఇక్కడ లూప్ కొద్దిగా కలిగి వెళ్ళి వెళుతున్న

238
00:12:47,000 --> 00:12:50,000
ఆ, ఈ వంటి ఏదో చెప్పడానికి జరగబోతోంది

239
00:12:50,000 --> 00:13:01,000
మొత్తం + = i (; నేను <= సంఖ్య i + + Int i = 0) కోసం.

240
00:13:01,000 --> 00:13:05,000
మరియు నేను మొత్తం తిరిగి వెళుతున్న.

241
00:13:05,000 --> 00:13:07,000
నేను మార్గాల్లో సంఖ్య ఈ అమలు చేశారు.

242
00:13:07,000 --> 00:13:09,000
నేను కొంత లూప్ ఉపయోగించారు కాలేదు.

243
00:13:09,000 --> 00:13:11,000
నేను నిజంగా కోరుకుంటే మొత్తం వేరియబుల్ను వుపయోగిస్తూ దాటవేయబడింది ఉండవచ్చు

244
00:13:11,000 --> 00:13:15,000
కానీ చిన్న లో, మేము నిజంగా కాదు ఉంటే మందమతి మొత్తం 0 ప్రకటించే ఒక చర్య.

245
00:13:15,000 --> 00:13:18,000
అప్పుడు, సంఖ్య ద్వారా మీద 0 నుంచి iterates

246
00:13:18,000 --> 00:13:23,000
మరియు ప్రతి పునరావృతం మీద మొత్తానికి ప్రస్తుత విలువ జతచేస్తుంది మరియు తరువాత మొత్తం తిరిగి.

247
00:13:23,000 --> 00:13:25,000
>> ఇప్పుడు, ఇక్కడ కొంచెం ఆప్టిమైజేషన్ ఉంది.

248
00:13:25,000 --> 00:13:29,000
ఈ బహుశా ఒక వృధా దశ, కానీ అందువలన ఇది. ఇప్పుడు ఆ మంచిది.

249
00:13:29,000 --> 00:13:32,000
మేము కనీసం ఉన్నారు పరిపూర్ణమైన ఉండటం మరియు న 0 గోయింగ్ ఆల్ ది వే.

250
00:13:32,000 --> 00:13:34,000
చాలా హార్డ్ మరియు చాలా సూటిగా లేదు,

251
00:13:34,000 --> 00:13:37,000
కానీ సిగ్మా ఫంక్షన్ తో మేము అదే అవకాశం అవుతుంది

252
00:13:37,000 --> 00:13:39,000
మేము వేదిక పైన ఇక్కడ వలె.

253
00:13:39,000 --> 00:13:42,000
వేదికపై మేము, నా ప్రక్కన ఎంత మంది మంది పౌరులు

254
00:13:42,000 --> 00:13:47,000
కానీ బదులుగా మేము సంఖ్య 3 + 2 + 1 లెక్కించడానికి కోరుకుంటే

255
00:13:47,000 --> 00:13:51,000
క్రిందికి 0 లో మేము ఒక ఫంక్షన్ వలె రౌడీ అనుకొనుట

256
00:13:51,000 --> 00:13:55,000
నేను బదులుగా పునరావృత గా వివరించడానికి మేము.

257
00:13:55,000 --> 00:13:57,000
ఇక్కడ శీఘ్ర తెలివి తనిఖీ మరియు నేను మందమతి పడరాదని మనం.

258
00:13:57,000 --> 00:14:00,000
>> నేను తప్పు అని ఈ కార్యక్రమంలో కనీసం ఒక్క విషయము తెలుసు.

259
00:14:00,000 --> 00:14:04,000
నేను ఎంటర్ నొక్కండి నేను నా పదాన్ని ఎలాంటి పొందడానికి వెళ్తున్నాను?

260
00:14:04,000 --> 00:14:06,000
నేను కోప్పడ్డాడు చేయడానికి ఏం వెళ్తున్నాను?

261
00:14:06,000 --> 00:14:11,000
అవును, నేను మర్చిపోయాను నమూనా, నేను లైన్ 15 సిగ్మా అనే చర్యను ఉపయోగించటం నేను అలా

262
00:14:11,000 --> 00:14:16,000
కానీ 22 వ వరుస వరకు డిక్లేర్డ్, నేను ఉత్తమ ముందుగా ఇక్కడ వెళ్ళండి కాదు

263
00:14:16,000 --> 00:14:22,000
మరియు ఒక నమూనా, మరియు నేను Int సిగ్మా (Int సంఖ్య) చెప్పడానికి చేస్తాము, అంతే.

264
00:14:22,000 --> 00:14:24,000
ఇది దిగువన అమలు ఉంది.

265
00:14:24,000 --> 00:14:27,000
>> లేదా నేను ఈ పరిష్కరించేందుకు కాలేదు మరొక విధంగా,

266
00:14:27,000 --> 00:14:30,000
నేను, ఇది చెడు కాదు, అక్కడ అప్ ఫంక్షన్ తరలించడానికి కాలేదు

267
00:14:30,000 --> 00:14:32,000
కానీ కనీసం మీ కార్యక్రమాలు, స్పష్టముగా, దీర్ఘ పొందడానికి ప్రారంభించిన

268
00:14:32,000 --> 00:14:35,000
నేను ఎల్లప్పుడూ ఎగువన ప్రధాన కలిగి కొన్ని విలువ ఉందని నేను అనుకుంటున్నాను

269
00:14:35,000 --> 00:14:38,000
మీరు రీడర్ లో ఫైల్ను తెరవడం వెంటనే చూడగలరు ఆ

270
00:14:38,000 --> 00:14:40,000
ప్రోగ్రామ్ ద్వారా అన్వేషణ చేయకుండా ఏమి

271
00:14:40,000 --> 00:14:42,000
ప్రధాన విధి వెతుకుతున్న.

272
00:14:42,000 --> 00:14:49,000
యొక్క ఇక్కడ నా టెర్మినల్ విండో క్రిందికి వెళ్ళి తెలపండి, సిగ్మా సిగ్మా తయారు చేయడం ప్రయత్నించండి

273
00:14:49,000 --> 00:14:51,000
మరియు నేను చాలా ఇక్కడ చిత్తు చేశాడు.

274
00:14:51,000 --> 00:14:55,000
ఫంక్షన్ GetInt యొక్క పరిపూర్ణమైన ప్రకటన ఏమి else చేయడానికి ను మర్చిపోతే అంటే?

275
00:14:55,000 --> 00:14:57,000
[వినబడని-విద్యార్థి]

276
00:14:57,000 --> 00:15:00,000
గుడ్, కాబట్టి స్పష్టంగా సాధారణ తప్పు, కాబట్టి, ఇక్కడ యొక్క ఈ ఏర్పాటు తెలియజేయండి

277
00:15:00,000 --> 00:15:04,000
cs50.h, మరియు ఇప్పుడు నా టెర్మినల్ విండో తిరిగి వదలి వేస్తారు.

278
00:15:04,000 --> 00:15:08,000
>> నేను తెర క్లియర్ చేస్తాము, మరియు నేను సిగ్మా తయారు తిరిగి పొందుతారు.

279
00:15:08,000 --> 00:15:11,000
ఇది సంకలనం తెలుస్తోంది. నాకు ఇప్పుడు సిగ్మా అమలు అయ్యేలా అనుమతించండి.

280
00:15:11,000 --> 00:15:15,000
నేను సంఖ్య 3 టైప్ చేస్తాము, మరియు నేను 6 పొందండి, కనుక ఒక కఠినమైన చెక్

281
00:15:15,000 --> 00:15:18,000
కానీ కనీసం అది మొదటి చూపులో పని తెలుస్తోంది, కానీ ఇప్పుడు లెట్స్ అది వేరుగా రిప్

282
00:15:18,000 --> 00:15:21,000
మరియు లెట్స్ వాస్తవానికి, మళ్ళీ, సూత్రం యొక్క ఆలోచన పరపతి

283
00:15:21,000 --> 00:15:24,000
చాలా సులభమైన సందర్భంలో కాబట్టి కొన్ని వారాల సమయం లో

284
00:15:24,000 --> 00:15:27,000
మేము శ్రేణుల కంటే ఫ్యాన్సియెర్స్ డేటా నిర్మాణాలు అన్వేషించడం ప్రారంభించిన

285
00:15:27,000 --> 00:15:30,000
మేము ఇది తో సంచిలో మరొక సాధనం కలిగి

286
00:15:30,000 --> 00:15:33,000
మేము చూస్తారు ఆ డేటా నిర్మాణాలు సర్దుబాటు.

287
00:15:33,000 --> 00:15:36,000
ఈ పద్దతి విధానం, లూప్ ఆధారిత విధానం.

288
00:15:36,000 --> 00:15:39,000
>> ఇప్పుడు దీన్ని బదులుగా నాకు లెట్.

289
00:15:39,000 --> 00:15:44,000
బదులుగా ఏమంటారంటే నాకు లెట్ ఆ సంఖ్యను సమ్మషన్

290
00:15:44,000 --> 00:15:48,000
నిజంగా అదే విషయం 0 క్రిందికి ఉంది

291
00:15:48,000 --> 00:15:53,000
సంఖ్య + సిగ్మా (సంఖ్య - 1).

292
00:15:53,000 --> 00:15:57,000
ఇతర మాటలలో, కేవలం వేదికపై నేను, నా ప్రక్కన ప్రజలు ప్రతి punted

293
00:15:57,000 --> 00:16:00,000
మరియు అవి, మనం చివరికి విల్లీ వద్ద అవుట్ పడిపోవటంతో వరకు punting ఉంచిన

294
00:16:00,000 --> 00:16:03,000
ఎవరు 0 వంటి హార్డ్ కోడెడ్ సమాధానం తిరిగి వచ్చింది.

295
00:16:03,000 --> 00:16:07,000
ఇక్కడ ఇప్పుడు మేము అదేవిధంగా సిగ్మా కొరకు punting చేస్తున్నారు

296
00:16:07,000 --> 00:16:10,000
అదే ఫంక్షన్ అసలు, కాని కీ అంతర్దృష్టి ఇక్కడ జరిగినది

297
00:16:10,000 --> 00:16:12,000
మేము సమంగా సిగ్మా కాల్ చేస్తున్నట్లు ఉంది.

298
00:16:12,000 --> 00:16:14,000
మేము n అక్కడ లేదు.

299
00:16:14,000 --> 00:16:17,000
మనం స్పష్టంగా సంఖ్య అక్కడ ఉన్నాం - 1,

300
00:16:17,000 --> 00:16:20,000
కాబట్టి కొద్దిగా చిన్న సమస్య, కొద్దిగా చిన్న సమస్య.

301
00:16:20,000 --> 00:16:23,000
>> దురదృష్టవశాత్తు, ఈ ఇంకా చాలా పరిష్కారం కాదు, మరియు మేము పరిష్కరించడానికి ముందు

302
00:16:23,000 --> 00:16:26,000
మీరు కొన్ని వద్ద స్పష్టమైన వంటి ఏమిటో జంపింగ్ ఉండవచ్చు

303
00:16:26,000 --> 00:16:28,000
నాకు ముందుకు వెళ్లి తయారు తిరిగి తెలియజేయండి.

304
00:16:28,000 --> 00:16:30,000
ఇది సరే కంపైల్ తెలుస్తోంది.

305
00:16:30,000 --> 00:16:32,000
నాకు 6 తో సిగ్మా తిరిగి లెట్.

306
00:16:32,000 --> 00:16:37,000
అయ్యో, నాకు 6 తో సిగ్మా తిరిగి తెలియజేయండి.

307
00:16:37,000 --> 00:16:42,000
మేము అదే అనుకోకుండా చివరిసారి అయితే ముందు ఈ చూసిన.

308
00:16:42,000 --> 00:16:48,000
నేను ఈ గుప్తమైన విభజన లోపంగా వచ్చింది? అవును.

309
00:16:48,000 --> 00:16:50,000
[వినబడని-విద్యార్థి]

310
00:16:50,000 --> 00:16:53,000
మరింత ప్రత్యేకంగా ఎటువంటి ఆధారం కేస్, మరియు, బహుశా ఏ జరిగింది?

311
00:16:53,000 --> 00:16:58,000
ఇది ఏమిటి ప్రవర్తన యొక్క ఒక లక్షణం?

312
00:16:58,000 --> 00:17:00,000
కొద్దిగా గట్టిగా చెప్పాను.

313
00:17:00,000 --> 00:17:02,000
[వినబడని-విద్యార్థి]

314
00:17:02,000 --> 00:17:05,000
ఇది ప్రభావవంతంగా ఒక అనంతమైన లూప్, మరియు అనంత వలయాలు తో సమస్య

315
00:17:05,000 --> 00:17:08,000
వారు ఈ విషయంలో సూత్రం కలిగి ఉన్నప్పుడు, ఒక ఫంక్షన్ కూడా కాల్

316
00:17:08,000 --> 00:17:10,000
మీరు ఒక ఫంక్షన్ కాల్ ప్రతిసారీ జరుగుతుంది?

317
00:17:10,000 --> 00:17:13,000
Well, మేము ఒక కంప్యూటర్ లో మెమొరీ సిద్ధం ఎలా తిరిగి అనుకుంటున్నాను.

318
00:17:13,000 --> 00:17:16,000
మేము, క్రింద ఉన్న స్టాక్ అనే మెమరీ ఈ భాగం ఉంది అన్నారు

319
00:17:16,000 --> 00:17:19,000
మరియు మీరు కొంచెం మెమరీ ఒక ఫంక్షన్ కాల్ ప్రతిసారీ ఉంచే

320
00:17:19,000 --> 00:17:24,000
ఆ ఫంక్షన్ యొక్క స్థానిక చరరాశులు లేదా పారామితులు కలిగిన ఈ అని పిలవబడే స్టాక్ న,

321
00:17:24,000 --> 00:17:27,000
సిగ్మా సిగ్మా కాల్స్ కాల్స్ అయితే సిగ్మా సిగ్మా కాల్స్

322
00:17:27,000 --> 00:17:29,000
 సిగ్మా కాల్స్ పేరు ఈ కథ ముగింపు చేస్తుంది?

323
00:17:29,000 --> 00:17:31,000
>> సరే, చివరికి కారణంతో మొత్తం

324
00:17:31,000 --> 00:17:33,000
మీరు మీ కంప్యూటర్ అందుబాటులో కలిగి మెమరీ.

325
00:17:33,000 --> 00:17:37,000
మీరు లోపల ఉండాలని కోరుకుంటున్నాము చేస్తున్న విభాగంలో, ఆక్రమిత

326
00:17:37,000 --> 00:17:40,000
మరియు మీరు ఈ విభజన లోపంగా పొందండి, కోర్, కురిపించింది

327
00:17:40,000 --> 00:17:43,000
మరియు కురిపించింది ఏ కోర్ అంటే నేను ఇప్పుడు కోర్ అనే ఫైల్ కలిగి ఉంటుంది

328
00:17:43,000 --> 00:17:46,000
ఇది సున్నాలు మరియు వాటిని కలిగి ఫైలు

329
00:17:46,000 --> 00:17:49,000
వాస్తవానికి భవిష్యత్తులో diagnostically ఉపయోగకరంగా ఉంటుంది.

330
00:17:49,000 --> 00:17:52,000
మీ బగ్ ఉన్న ఇది మీకు స్పష్టమైన కాకపోతే

331
00:17:52,000 --> 00:17:54,000
మీరు నిజంగా, మాట్లాడటానికి, ఫోరెన్సిక్ విశ్లేషణ యొక్క ఒక బిట్ చేయవచ్చు

332
00:17:54,000 --> 00:17:58,000
ఈ కోర్ డంప్ ఫైలు న, ఇది మళ్ళీ, కేవలం సున్నాలు మరియు వాటిని పూర్తి బంచ్ ఉంది

333
00:17:58,000 --> 00:18:02,000
ఆ ముఖ్యంగా మెమరీ మీ ప్రోగ్రామ్ యొక్క స్థితి సూచిస్తుంది

334
00:18:02,000 --> 00:18:05,000
క్షణం ఈ విధంగా కుప్పకూలింది.

335
00:18:05,000 --> 00:18:11,000
>> ఇక్కడ పరిష్కారం మేము గుడ్డిగా, సిగ్మా తిరిగి కాదు

336
00:18:11,000 --> 00:18:14,000
సంఖ్య + కొద్దిగా చిన్న సమస్య యొక్క సిగ్మా.

337
00:18:14,000 --> 00:18:16,000
మేము ఇక్కడ బేస్ కేసులో రకమైన కలిగి ఉండాలి

338
00:18:16,000 --> 00:18:19,000
మరియు బేస్ కేసు బహుశా ఉండాలి?

339
00:18:19,000 --> 00:18:22,000
[వినబడని-విద్యార్థి]

340
00:18:22,000 --> 00:18:25,000
సరే కాలం సంఖ్య సానుకూల మనం నిజంగా, ఈ తిరిగి ఉండాలి

341
00:18:25,000 --> 00:18:29,000
లేదా మరొక విధంగా చెప్పాలంటే, సంఖ్య ఉంటే, సే, <= 0 కు

342
00:18:29,000 --> 00:18:32,000
మీరు, నేను ముందుకు వెళ్లి 0 తిరిగి ఉంటాం ఏ, తెలిసిన

343
00:18:32,000 --> 00:18:36,000
విల్లీ చేశాడు అనే మరియు మిగిలినవి, నేను ముందుకు వెళుతున్న

344
00:18:36,000 --> 00:18:41,000
మరియు ఈ తిరిగి, కాబట్టి ఇది చాలా తక్కువ కాదు

345
00:18:41,000 --> 00:18:44,000
మేము మొదటి లూప్ ఒక ఉపయోగించి కొరడాతో ఆ పునరుత్థాన వెర్షన్,

346
00:18:44,000 --> 00:18:48,000
కానీ దానికి గాంభీర్యం, ఈ విధమైన అక్కడ గమనిస్తారు.

347
00:18:48,000 --> 00:18:51,000
బదులుగా కొన్ని సంఖ్య తిరిగి మరియు అన్ని ఈ గణిత ప్రదర్శన యొక్క

348
00:18:51,000 --> 00:18:54,000
మరియు స్థానిక వేరియబుల్స్ తో సంగతులకు జోడించడం

349
00:18:54,000 --> 00:18:57,000
మీరు బదులుగా చెబుతున్న దాన్ని "సరే, ఈ ఒక సూపర్ సులభంగా సమస్య ఉంటే,

350
00:18:57,000 --> 00:19:01,000
సంఖ్య <0 వలె నాకు వెంటనే 0 తిరిగి ఉంచబడుతుంది. "

351
00:19:01,000 --> 00:19:03,000
>> మేము, సహాయక ప్రతికూల సంఖ్యలు ఇబ్బంది వెళ్ళి లేదు

352
00:19:03,000 --> 00:19:05,000
నేను హార్డ్ కోడ్ కు 0 విలువ వెళుతున్న.

353
00:19:05,000 --> 00:19:08,000
అయితే, సంక్షిప్తం ఈ ఆలోచన అమలు

354
00:19:08,000 --> 00:19:11,000
ఈ సంఖ్యల అన్ని కలిసి మీరు సమర్థవంతంగా ఒక చిన్న కాటు పడుతుంది

355
00:19:11,000 --> 00:19:14,000
సమస్య నుండి, అనే మేము, వేదికపై ఇక్కడ చేశాడు

356
00:19:14,000 --> 00:19:18,000
అప్పుడు రౌడీ తదుపరి వ్యక్తికి సమస్య మిగిలిన,

357
00:19:18,000 --> 00:19:20,000
కానీ ఈ విషయంలో తదుపరి వ్యక్తి మీరే ఉంది.

358
00:19:20,000 --> 00:19:22,000
ఇది ఒక గుర్తింపు అనే ఫంక్షన్ ఉంది.

359
00:19:22,000 --> 00:19:25,000
జస్ట్ ఒక చిన్న మరియు చిన్నది సమస్య ప్రతి టైం పాస్

360
00:19:25,000 --> 00:19:28,000
మరియు మేము ఇక్కడ కోడ్ చెప్పుకోదగ్గ అధికారికంగా విషయాల్లో కూడా

361
00:19:28,000 --> 00:19:33,000
ఈ ఫోన్ బుక్ తో వారం 0 లో జరగబోతోంది సరిగ్గా అదే ఉంది.

362
00:19:33,000 --> 00:19:36,000
ఈ సీన్ తో గత వారాల్లో జరగబోతోంది సరిగ్గా ఏమిటి

363
00:19:36,000 --> 00:19:39,000
మరియు సంఖ్యలు కోసం శోధించే మా ప్రదర్శనలతో.

364
00:19:39,000 --> 00:19:42,000
ఇది ఒక సమస్యను మళ్ళీ మళ్ళీ విభజన మాత్రమే.

365
00:19:42,000 --> 00:19:44,000
>> ఇతర మాటలలో, అనువదించడం ఇప్పుడు ఒక మార్గం ఉందని

366
00:19:44,000 --> 00:19:47,000
ఇది నిజమైన ప్రపంచం నిర్మాణం, ఈ ఉన్నత స్థాయి నిర్మాణం

367
00:19:47,000 --> 00:19:51,000
విభజించి జయించటానికి మరియు మళ్లీ మళ్లీ దానిని చేయడం యొక్క

368
00:19:51,000 --> 00:19:56,000
కోడ్ లో, ఈ మేము సమయంలో మళ్ళీ చూస్తారు విషయం.

369
00:19:56,000 --> 00:20:00,000
మీరు సూత్రం కొత్త అయితే ఇప్పుడు, ఒక పక్కన, మీరు కనీసం ఇప్పుడు అర్థం చేసుకోవాలి

370
00:20:00,000 --> 00:20:02,000
ఎందుకు ఈ ఫన్నీ ఉంది.

371
00:20:02,000 --> 00:20:05,000
నేను, google.com వెళ్ళండి వెళుతున్న

372
00:20:05,000 --> 00:20:17,000
మరియు నేను సూత్రం మీద కొన్ని చిట్కాలు మరియు ట్రిక్స్ కోసం అన్వేషణ వెళుతున్న, ఇవ్వండి.

373
00:20:17,000 --> 00:20:21,000
అవి ఇప్పుడు నవ్వుతూ ఉండకపోతే మీరు పక్కన వ్యక్తి చెప్పండి.

374
00:20:21,000 --> 00:20:23,000
మీరు సూత్రం అడిగారా?

375
00:20:23,000 --> 00:20:25,000
మీరు తెలుసా అర్థం-AH, అక్కడ మేము వెళ్ళి.

376
00:20:25,000 --> 00:20:28,000
సరే, ఇప్పుడు ప్రతి ఒక్కరూ మిగిలిన ఉంది.

377
00:20:28,000 --> 00:20:30,000
ఒక చిన్న ఈస్టర్ గుడ్డు Google ఎక్కడో అక్కడ పొందుపరిచారు.

378
00:20:30,000 --> 00:20:33,000
ఒక పక్కన, మేము కోర్సు యొక్క వెబ్ సైట్ లో ఉంచారు లింకులు ఒకటిగా

379
00:20:33,000 --> 00:20:36,000
నేడు వివిధ సార్టింగ్ అల్గోరిథంలు యొక్క ఈ గ్రిడ్, ఉంది

380
00:20:36,000 --> 00:20:39,000
మేము గత వారం చూశారు, కానీ ఈ భావన గురించి మంచిది కొన్ని

381
00:20:39,000 --> 00:20:43,000
మీరు అల్గోరిథంలు సంబంధించిన వివిధ విషయాలను చుట్టూ మీ మనస్సు మూసివేయాలని ప్రయత్నించండి వంటి

382
00:20:43,000 --> 00:20:46,000
మీరు చాలా సులభంగా ఇప్పుడు ఇన్పుట్లను వివిధ రకాల మొదలుపెట్టవచ్చు తెలుసు.

383
00:20:46,000 --> 00:20:50,000
ఇన్పుట్లను అన్ని ఇన్పుట్లను యాదృచ్ఛిక మొదలైనవి, ఇన్పుట్లను ఎక్కువగా క్రమబద్ధీకరించిన తోసిపుచ్చింది.

384
00:20:50,000 --> 00:20:53,000
మీరు మళ్ళీ, ప్రయత్నించండి, మీ మనస్సులో ఈ విషయాలను వేరు

385
00:20:53,000 --> 00:20:57,000
గ్రహించే ఆ ఉపన్యాసాలు పేజీలో కోర్సు యొక్క వెబ్ సైట్ లో ఈ URL

386
00:20:57,000 --> 00:21:00,000
ఆ కొన్ని ద్వారా కారణం సహాయం ఉండవచ్చు.

387
00:21:00,000 --> 00:21:05,000
>> ఈ రోజు మనం చివరికి, తిరిగి కొంత నుండి ఈ సమస్యను పరిష్కరించడానికి పొందండి

388
00:21:05,000 --> 00:21:08,000
ఇది ఈ swap ఫంక్షన్ కేవలం పని చేయలేదు ఆ

389
00:21:08,000 --> 00:21:12,000
మరియు, ఈ ఫంక్షన్ స్వాప్ తో సమస్యను ఏమిటి

390
00:21:12,000 --> 00:21:15,000
ఇక్కడ మరియు ఇక్కడ ఒక విలువ మార్పిడి, మళ్ళీ, ఈ లక్ష్యం ఇది యొక్క

391
00:21:15,000 --> 00:21:17,000
ఇది జరిగినప్పుడు అలాంటి?

392
00:21:17,000 --> 00:21:20,000
ఈ నిజానికి పని చేయలేదు. ఎందుకు?

393
00:21:20,000 --> 00:21:22,000
అవును.

394
00:21:22,000 --> 00:21:28,000
[వినబడని-విద్యార్థి]

395
00:21:28,000 --> 00:21:31,000
ఈ bugginess కోసం ఖచ్చితంగా వివరణ

396
00:21:31,000 --> 00:21:34,000
మీరు C లో కాల్ ప్రమేయాలు ఉన్నప్పుడు ఎందుకంటే కేవలం ఉంది

397
00:21:34,000 --> 00:21:38,000
మరియు ఆ విధులు, a మరియు b ఇక్కడ వంటి వాదనలు పడుతుంది

398
00:21:38,000 --> 00:21:42,000
మీరు ఆ ఫంక్షన్ కు అందించే ఏ చేస్తున్నారు విలువ యొక్క కాపీలు అక్కడ ఉంటాయి.

399
00:21:42,000 --> 00:21:46,000
మీరు, అసలు విలువలు తాము లభిస్తుంది

400
00:21:46,000 --> 00:21:49,000
కాబట్టి మేము, buggyc సందర్భంలో చూసిన

401
00:21:49,000 --> 00:21:52,000
ఈ వంటి కొంత కనిపించింది ఇది buggy3.c.

402
00:21:52,000 --> 00:21:57,000
>> మేము x మరియు y వరుసగా 1, 2 నుండి initialized కలిగి గుర్తుచేసుకున్నారు.

403
00:21:57,000 --> 00:21:59,000
మేము అప్పుడు వారు ఏమి ముద్రించిన.

404
00:21:59,000 --> 00:22:03,000
నేను అప్పుడు నేను x, y యొక్క స్వాప్ కాల్ వాటిని ఇచ్చిపుచ్చుకోవడంతో అని వాదించాడు.

405
00:22:03,000 --> 00:22:06,000
కానీ సమస్య, ఇచ్చిపుచ్చుకోవడంతో పని చేసారు, ఆ

406
00:22:06,000 --> 00:22:10,000
కానీ స్వాప్ పరిధిని కూడా పని.

407
00:22:10,000 --> 00:22:13,000
మేము లైన్ 40 ఆ మార్చుకున్నారు విలువలు హిట్ వెంటనే

408
00:22:13,000 --> 00:22:16,000
దూరంగా విసిరి, మరియు ఏదీ

409
00:22:16,000 --> 00:22:21,000
అసలు ఫంక్షన్ లో ముఖ్య వాస్తవానికి, అన్ని వద్ద మార్చబడింది

410
00:22:21,000 --> 00:22:26,000
మీరు ఈ మా మెమరీ పరంగా కనిపిస్తోంది ఏమి అప్పుడు భావిస్తున్నాను అయితే

411
00:22:26,000 --> 00:22:29,000
బోర్డు ఈ ఎడమ వైపు సూచిస్తుంది-ఉంటే

412
00:22:29,000 --> 00:22:33,000
మరియు నేను చూడండి అందరి కోసం నా వంతు కృషి చేస్తాము ఈ-ఉంటే బోర్డు ఈ ఎడమ వైపు

413
00:22:33,000 --> 00:22:37,000
సూచిస్తుంది, మీ RAM, మరియు స్టాక్ ఈ విధంగా మీద పెరుగుతాయి అన్నారు

414
00:22:37,000 --> 00:22:43,000
మరియు మేము ప్రధాన వంటి ఫంక్షన్ కాల్, మరియు ప్రధాన 2 స్థానిక వేరియబుల్స్, x మరియు y, ఉంది

415
00:22:43,000 --> 00:22:48,000
యొక్క ఇక్కడ x ఆ వివరించడానికి వీలు, మరియు లెట్స్ ఇక్కడ y ఈ వివరించడానికి,

416
00:22:48,000 --> 00:22:55,000
మరియు యొక్క విలువలు 1 మరియు 2 ఉంచారు కదా,, ఈ ఇక్కడ ప్రధాన కనుక

417
00:22:55,000 --> 00:22:58,000
మరియు ప్రధాన swap ఫంక్షన్ ఆపరేటింగ్ వ్యవస్థ కాల్స్ ఉన్నప్పుడు

418
00:22:58,000 --> 00:23:02,000
, స్టాక్ న swap ఫంక్షన్ మెమరీ దాని స్వంత సమూహం ఇస్తుంది

419
00:23:02,000 --> 00:23:04,000
స్టాక్ దాని స్వంత ఫ్రేమ్, మాట్లాడటానికి.

420
00:23:04,000 --> 00:23:08,000
ఇది కూడా ఈ ints కోసం 32 బిట్స్ కేటాయించుకునే.

421
00:23:08,000 --> 00:23:11,000
ఇది వాటిని ఒక అండ్ బి కాల్ ఏమవుతుంది కానీ పూర్తిగా ఏకపక్షంగా ఉంది.

422
00:23:11,000 --> 00:23:13,000
ఇది కావాలి ఏ వారిని అని ఉండవచ్చు, కాని ప్రధాన ఏమి జరుగుతుందనే

423
00:23:13,000 --> 00:23:19,000
కాల్స్ swap ఇది ఈ 1 పడుతుంది అక్కడ కాపీని ఉంచుతుంది, అక్కడ ఒక కాపీని ఉంచుతుంది ఉంది.

424
00:23:19,000 --> 00:23:23,000
>> స్వాప్ లో 1 ఇతర స్థానిక వేరియబుల్ ఉంది, అయితే పిలిచేవారు? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, కాబట్టి, నాకు నేనే ఇక్కడ మరొక 32 బిట్స్ కల్పించడానికి అనుమతిస్తాయి

426
00:23:27,000 --> 00:23:29,000
మరియు నేను ఈ ఫంక్షన్ లో ఏం చేస్తారు?

427
00:23:29,000 --> 00:23:34,000
నేను Int tmp ఒక కాబట్టి, ఒక 1 ఉంది గెట్స్ చెప్పారు, కాబట్టి మేము గత ఈ ఉదాహరణ ఆడి నేను ఈ చేశాడు.

428
00:23:34,000 --> 00:23:39,000
అప్పుడు ఒక బి చేస్తారు, దీని వలన బి 2, కాబట్టి ఇప్పుడు ఈ 2 అవుతుంది,

429
00:23:39,000 --> 00:23:42,000
మరియు ఇప్పుడు, బి టెంప్ చేస్తారు, దీని వలన తాత్కాలిక 1

430
00:23:42,000 --> 00:23:44,000
కాబట్టి ఇప్పుడు బి ఈ అవుతుంది.

431
00:23:44,000 --> 00:23:46,000
ఆ గొప్ప పని. ఇది పని.

432
00:23:46,000 --> 00:23:49,000
కానీ వెంటనే తిరిగి వచ్చే చర్యలు వంటి

433
00:23:49,000 --> 00:23:52,000
swap యొక్క మెమరీ సమర్థవంతంగా దానిని తిరిగి వాడతారు కనుక అదృశ్యమవుతుంది

434
00:23:52,000 --> 00:23:58,000
భవిష్యత్తులో కొన్ని ఇతర చర్య ద్వారా, మరియు ప్రధాన స్పష్టంగా పూర్తిగా మారదు.

435
00:23:58,000 --> 00:24:00,000
మేము ప్రధానంగా ఈ సమస్య పరిష్కరించేందుకు ఒక మార్గం అవసరం

436
00:24:00,000 --> 00:24:03,000
మరియు ఈ రోజు మేము చివరకు వస్తే ఇలా ఒక మార్గం ఉంటుంది

437
00:24:03,000 --> 00:24:06,000
మేము ఒక పాయింటర్ అనే కలిగిస్తాయి.

438
00:24:06,000 --> 00:24:09,000
ఇది మేము ఈ సమస్య పరిష్కరించగల అవుతుంది

439
00:24:09,000 --> 00:24:12,000
x మరియు y యొక్క కాపీలు అక్కడ లేదు ద్వారా

440
00:24:12,000 --> 00:24:18,000
కానీ బదులుగా ఏమి లో గుండా, మీరు swap కు, ఆలోచిస్తాడు?

441
00:24:18,000 --> 00:24:20,000
అవును, చిరునామా గురించి ఏమి?

442
00:24:20,000 --> 00:24:22,000
మమ్మల్ని, చాలా వివరాలు చిరునామాలు గురించి మాట్లాడారు లేదు

443
00:24:22,000 --> 00:24:25,000
కానీ ఈ రాత బల్ల నా కంప్యూటర్ యొక్క మెమరీ సూచిస్తుంది ఉంటే

444
00:24:25,000 --> 00:24:28,000
మేము ఖచ్చితంగా నా RAM లో బైట్లు సంఖ్యలో ప్రారంభం కాలేదు

445
00:24:28,000 --> 00:24:31,000
మరియు ఈ బైట్ # 1 అంటారు, ఈ బైట్ # 3, # 2 బైట్ ఉంది

446
00:24:31,000 --> 00:24:35,000
బైట్ # 4, బైట్ # ... 2 బిలియన్ నేను RAM యొక్క 2 గిగాబైట్ల ఉంటే,

447
00:24:35,000 --> 00:24:38,000
కాబట్టి మేము ఖచ్చితంగా స్వేచ్ఛా అంకెల పథకాన్ని తో వస్తుంది

448
00:24:38,000 --> 00:24:41,000
నా కంప్యూటర్ యొక్క మెమరీ అన్ని వ్యక్తిగత బైట్లు కోసం.

449
00:24:41,000 --> 00:24:43,000
>> నేను swap ఏం బదులుగా కాల్ చేసినప్పుడు

450
00:24:43,000 --> 00:24:47,000
x మరియు y యొక్క కాపీలు కాకుండా పాస్

451
00:24:47,000 --> 00:24:51,000
నేను బదులుగా, ఇక్కడ x యొక్క చిరునామా లో అనుమతించబడవు

452
00:24:51,000 --> 00:24:55,000
ఇక్కడ y యొక్క చిరునామా, ముఖ్యంగా పోస్టల్ చిరునామా

453
00:24:55,000 --> 00:24:59,000
అతను సమాచారం ఉన్నట్లయితే x మరియు y యొక్క ఎందుకంటే అప్పుడు, స్వాప్

454
00:24:59,000 --> 00:25:01,000
x మరియు y యొక్క మెమరీలో చిరునామా,

455
00:25:01,000 --> 00:25:04,000
మేము అతనికి కొద్దిగా శిక్షణ అప్పుడు, స్వాప్

456
00:25:04,000 --> 00:25:07,000
అతను శక్తివంతంగా, మాట్లాడటానికి, ఆ చిరునామాకు డ్రైవ్ కాలేదు

457
00:25:07,000 --> 00:25:11,000
x, అక్కడ మార్చడానికి, అప్పుడు, Y యొక్క చిరునామాకు డ్రైవ్

458
00:25:11,000 --> 00:25:16,000
నిజానికి ఆ విలువలు తనను కాపీలు పొందడానికి కాదు కూడా, అక్కడ మార్చడానికి,

459
00:25:16,000 --> 00:25:19,000
మేము ప్రధాన యొక్క మెమరీ గా ఈ మాట్లాడారు కాబట్టి అయినప్పటికీ

460
00:25:19,000 --> 00:25:23,000
మరియు ఈ వంటి ఉండటం swap యొక్క మెమరీ శక్తివంతమైన మరియు C యొక్క ప్రమాదకరమైన భాగంగా

461
00:25:23,000 --> 00:25:28,000
ఏదైనా ఫంక్షన్, ఎక్కడైనా కంప్యూటర్ మెమొరీ ప్రభావితం చేయవచ్చని ఉంది

462
00:25:28,000 --> 00:25:32,000
మరియు ఈ మీరు C. లో కంప్యూటర్ ప్రోగ్రాములు చాలా ఫాన్సీ పనులు చేయగలనని లో శక్తివంతమైన

463
00:25:32,000 --> 00:25:36,000
మీరు కూడా చాలా సులభంగా అప్ మేకు ఎందుకంటే ఈ ప్రమాదకరం.

464
00:25:36,000 --> 00:25:39,000
నిజానికి, కార్యక్రమాలు అత్యంత సాధారణ మార్గాలు ఈ రోజుల్లో ఒక చేజిక్కించుకోవడానికి కు

465
00:25:39,000 --> 00:25:42,000
ఒక ప్రోగ్రామర్ గ్రహించడం కాదు కోసం ఇంకా

466
00:25:42,000 --> 00:25:45,000
అతను లేదా ఆమె ఒక డేటా అనుమతిస్తుంది అని

467
00:25:45,000 --> 00:25:49,000
ఉద్దేశించబడింది అని మెమరీలో స్థానం లో రాసిన.

468
00:25:49,000 --> 00:25:51,000
>> ఉదాహరణకు, అతను లేదా ఆమె పరిమాణం 10 యొక్క వ్యూహం ప్రకటించాడు

469
00:25:51,000 --> 00:25:56,000
కానీ అప్పుడు అనుకోకుండా, మెమరీ ఆ శ్రేణి లో 11 బైట్లు ఉంచేందుకు ప్రయత్నిస్తుంది

470
00:25:56,000 --> 00:25:59,000
మరియు మీరు ఏ చెల్లని మెమరీ భాగాలను తాకుతూ ప్రారంభించండి.

471
00:25:59,000 --> 00:26:02,000
జస్ట్ సందర్భోచిత ఈ, మీరు కొన్ని తెలిసిన ఆ

472
00:26:02,000 --> 00:26:06,000
సాఫ్ట్వేర్ తరచుగా, సీరియల్ సంఖ్యలు లేదా నమోదు కొరకు కీస్ అడుగుతుంది

473
00:26:06,000 --> 00:26:08,000
Photoshop మరియు పద మరియు ఈ వంటి ప్రోగ్రామ్లు.

474
00:26:08,000 --> 00:26:12,000
, మీరు కొద్దిగా అమలు చేయవచ్చు ఆన్లైన్ పేరు, మీరు కొన్ని తెలిసిన, పగుళ్ళు ఉన్నాయి

475
00:26:12,000 --> 00:26:14,000
మరియు voila, ఒక క్రమ సంఖ్య కోసం no more అభ్యర్థన.

476
00:26:14,000 --> 00:26:16,000
ఎంత పని ఉంది?

477
00:26:16,000 --> 00:26:21,000
అనేక సందర్భాల్లో ఈ విషయాలు కేవలం కంప్యూటర్లలో కనుగొంటారు

478
00:26:21,000 --> 00:26:24,000
కంప్యూటర్ యొక్క నిజమైన సున్నాలు మరియు వాటిని టెక్స్ట్ విభాగాలు

479
00:26:24,000 --> 00:26:28,000
క్రమ సంఖ్య అభ్యర్థించిన కౌంటీ ఆ ఫంక్షన్, ఎక్కడ ఉంది

480
00:26:28,000 --> 00:26:31,000
కార్యక్రమం అమలులో ఉన్నప్పుడు మరియు ఆ స్థలాన్ని తిరిగి రాస్తుంది, లేదా

481
00:26:31,000 --> 00:26:33,000
కీ నిజానికి నిల్వ మీరు కనుగొనడానికి చేయవచ్చు

482
00:26:33,000 --> 00:26:37,000
ఏదో ఉపయోగించి ఒక డీబగ్గర్ అని, మరియు మీరు సాఫ్ట్వేర్ విధంగా పగుళ్లు ఏర్పడవచ్చు.

483
00:26:37,000 --> 00:26:40,000
ఈ, తదుపరి రెండు రోజుల్లో ఈ మా లక్ష్యం అని చెప్పడానికి కాదు

484
00:26:40,000 --> 00:26:42,000
కానీ చాలా వాస్తవ ప్రపంచ శాఖల కలిగి ఉంది.

485
00:26:42,000 --> 00:26:45,000
ఒక, సాఫ్ట్వేర్ దొంగతనం కలిగి చేసేట్టు

486
00:26:45,000 --> 00:26:47,000
కానీ మొత్తం యంత్రాల రాజీ కూడా ఉంది.

487
00:26:47,000 --> 00:26:50,000
>> నిజానికి, వెబ్సైట్లలో ఈ రోజుల్లో దోచుకున్నారు

488
00:26:50,000 --> 00:26:53,000
మరియు రాజీ డేటా బహిర్గతమైంది మరియు పాస్వర్డ్లను దొంగిలించబడతున్నాయి

489
00:26:53,000 --> 00:26:58,000
ఈ చాలా తరచుగా ఒక మెమరీ పేద నిర్వహణకు సంబంధించినది,

490
00:26:58,000 --> 00:27:01,000
లేదా, డేటాబేస్ విషయంలో వైఫల్యం, ఊహించడానికి

491
00:27:01,000 --> 00:27:03,000
రాబోయే వారాల్లో ఆ ఎక్కువ పటిష్టమయిన ఇన్పుట్,

492
00:27:03,000 --> 00:27:07,000
కానీ ఇప్పుడు కోసం మీరు చేసే నష్టం విధమైన ఒక స్నీక్ ప్రివ్యూ

493
00:27:07,000 --> 00:27:11,000
చాలా విషయాలు హుడ్ కింద పని ఎలా అర్థం కాదు ద్వారా.

494
00:27:11,000 --> 00:27:14,000
యొక్క ఈ విభజించబడింది ఎందుకు అవగాహనలతో వెళ్ళి తెలపండి

495
00:27:14,000 --> 00:27:17,000
ఒక సాధనం ఆ మరింత ఉపయోగకరంగా మారుతుంది

496
00:27:17,000 --> 00:27:19,000
మా కార్యక్రమాలు మరింత క్లిష్టంగా వంటి.

497
00:27:19,000 --> 00:27:21,000
మీరు మీ కార్యక్రమంలో ఒక బగ్ కలిగింది ఇంతవరకు ఉన్నప్పుడు

498
00:27:21,000 --> 00:27:23,000
ఎలా మీరు డీబగ్గింగ్ గురించి గాన్?

499
00:27:23,000 --> 00:27:25,000
మీ పద్ధతులు మీ TF బోధించారు లేదో ఇప్పటివరకు ఉన్నాయి

500
00:27:25,000 --> 00:27:27,000
లేదా స్వీయ శిక్షణ?

501
00:27:27,000 --> 00:27:29,000
[స్టూడెంట్] Printf.

502
00:27:29,000 --> 00:27:31,000
మీరు చూడాలనుకుంటే Printf, కాబట్టి printf బహుశా ఆ మీ స్నేహితుడు ఉంది

503
00:27:31,000 --> 00:27:33,000
మీ ప్రోగ్రామ్ యొక్క లోపల ఏం జరగబోతోంది

504
00:27:33,000 --> 00:27:36,000
మీరు printf ఇక్కడ, printf ఇక్కడ, printf ఇక్కడ ఉంచండి.

505
00:27:36,000 --> 00:27:38,000
అప్పుడు మీరు దీన్ని అమలు, మరియు మీరు తెరపై అంశాలను పూర్తి బంచ్ పొందండి

506
00:27:38,000 --> 00:27:43,000
మీరు నిజంగా మీ కార్యక్రమంలో తప్పు అన్నారు ఏమి రాబట్టడానికి ఉపయోగించే.

507
00:27:43,000 --> 00:27:45,000
>> Printf, ఒక శక్తివంతమైన విషయం ఉంటుంది

508
00:27:45,000 --> 00:27:47,000
కానీ చాలా మాన్యువల్ ప్రాసెస్ ఉంది.

509
00:27:47,000 --> 00:27:49,000
మీరు printf ఇక్కడ, ఇక్కడ ఒక printf ఉంచాలి

510
00:27:49,000 --> 00:27:51,000
మరియు మీరు ఒక లూప్ యొక్క లోపల ఉంచండి మీరు 100 పంక్తులు పొందండి ఉండవచ్చు

511
00:27:51,000 --> 00:27:53,000
మీరు ద్వారా జల్లెడ పట్టు కలిగి ఆ అవుట్పుట్ యొక్క.

512
00:27:53,000 --> 00:27:58,000
ఇది డీబగ్గింగ్ కార్యక్రమాలు చాలా యూజర్ ఫ్రెండ్లీ లేదా పరస్పర విధానం కాదు

513
00:27:58,000 --> 00:28:00,000
కానీ కృతజ్ఞతగా ప్రత్యామ్నాయాలు అందుబాటులో ఉన్నాయి.

514
00:28:00,000 --> 00:28:03,000
GDB అని ఉదాహరణకు ఒక కార్యక్రమం,, GNU డీబగ్గర్ ఉంటుంది

515
00:28:03,000 --> 00:28:06,000
ఇది మీరు ఎలా ఉపయోగిస్తున్నారో చిన్న రహస్య ఉంది.

516
00:28:06,000 --> 00:28:08,000
ఇది స్పష్టముగా కొద్దిగా క్లిష్టమైన, కానీ

517
00:28:08,000 --> 00:28:11,000
ఈ మీరు ఈ వారంలో ఉంచితే పొందిన అంశాల్లో ఒకటిగా మరియు తదుపరి

518
00:28:11,000 --> 00:28:14,000
GDB వంటి ఏదో అర్థం గంట

519
00:28:14,000 --> 00:28:18,000
ఇది దీర్ఘకాలంలో మీరు గంటల బహుశా పదుల సేవ్ చేస్తుంది

520
00:28:18,000 --> 00:28:21,000
కాబట్టి తో, మీరు ఈ విషయం ఎలా పనిచేస్తుంది అనే టీజర్ కల్పించడానికి అనుమతిస్తాయి.

521
00:28:21,000 --> 00:28:23,000
>> నా టెర్మినల్ విండో ఉన్నాను.

522
00:28:23,000 --> 00:28:26,000
నాకు ముందుకు వెళ్లి ఈ కార్యక్రమం buggy3 కంపైల్ లెట్.

523
00:28:26,000 --> 00:28:28,000
ఇది తాజాగా ఇప్పటికే.

524
00:28:28,000 --> 00:28:31,000
మేము ఒక అయితే తిరిగి, మరియు నిజానికి అది విభజించబడినట్లు యొక్క అప్పుడే నన్ను అమలు లెట్.

525
00:28:31,000 --> 00:28:34,000
కానీ ఎందుకు ఉంది? బహుశా నేను swap ఫంక్షన్ అప్ చిత్తు చేశాడు.

526
00:28:34,000 --> 00:28:37,000
దీనికి ఒక అండ్ బి ఉంది. నేను చాలా సరిగ్గా చుట్టూ కదిలే లేదు.

527
00:28:37,000 --> 00:28:39,000
నాకు ముందుకు వెళ్లి మనం.

528
00:28:39,000 --> 00:28:43,000
కంటే, నాకు బదులుగా ఈ కార్యక్రమం GDB అమలు అనుమతిస్తాయి buggy3 అమలు

529
00:28:43,000 --> 00:28:48,000
మరియు నేను, buggy3 అమలు చేయడానికి చెప్పాలి వెళుతున్న

530
00:28:48,000 --> 00:28:52,000
మరియు నేను కమాండ్ లైన్ వాదన,-టుయ్ ఉన్నాయి వెళుతున్న

531
00:28:52,000 --> 00:28:55,000
మరియు మేము గుర్తు స్పెక్ వద్ద భవిష్యత్తు సమస్యలు ఈ ఉంచుతాము.

532
00:28:55,000 --> 00:28:57,000
ఇప్పుడు ఈ నలుపు మరియు తెలుపు ఇంటర్ఫేస్, మళ్ళీ, ఆ అప్ popped

533
00:28:57,000 --> 00:28:59,000
ఈ ఉంది ఎందుకంటే మొదటి వద్ద కొద్దిగా అధిక ఉంది

534
00:28:59,000 --> 00:29:02,000
ఇక్కడ డౌన్ వారంటీ సమాచారం, కానీ కనీసం తెలిసిన విషయం ఏదైనా.

535
00:29:02,000 --> 00:29:04,000
విండో ఎగువన నా నిజమైన కోడ్ ఉంది

536
00:29:04,000 --> 00:29:08,000
మరియు నేను ఇక్కడ స్క్రోల్ చేయండి, నా ఫైలు యొక్క చాలా పైకి స్క్రోల్ అనుమతిస్తుంది

537
00:29:08,000 --> 00:29:11,000
నిజానికి, ఈ విండో దిగువన buggy3.c, మరియు ప్రకటన లేదు

538
00:29:11,000 --> 00:29:13,000
నేను ఈ GDB ప్రాంప్ట్ ఉంటాయి.

539
00:29:13,000 --> 00:29:16,000
>> ఈ నా సాధారణ జాన్ హార్వర్డ్ ప్రాంప్ట్ అదే కాదు.

540
00:29:16,000 --> 00:29:19,000
ఈ నాకు GDB నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తుంది వెళుతున్న ఒక ప్రేరణ ఉంటుంది.

541
00:29:19,000 --> 00:29:21,000
GDB ఒక డీబగ్గర్ ఉంది.

542
00:29:21,000 --> 00:29:24,000
ఒక డీబగ్గర్ మీరు నడవడానికి అనుమతిస్తుంది ప్రోగ్రామ్

543
00:29:24,000 --> 00:29:27,000
లైన్ ద్వారా లైన్ ద్వారా మీ ప్రోగ్రామ్ లైన్ అమలు,

544
00:29:27,000 --> 00:29:30,000
మార్గం మీరు ప్రోగ్రామ్ మీరు ఏదైనా చేయడం పాటు

545
00:29:30,000 --> 00:29:33,000
కూడా, మరింత ముఖ్యంగా, ఫంక్షన్స్ పిలుపు లేదా చూడటం

546
00:29:33,000 --> 00:29:35,000
వివిధ వేరియబుల్ విలువలు వద్ద.

547
00:29:35,000 --> 00:29:37,000
యొక్క ముందుకు వెళ్లి మనం.

548
00:29:37,000 --> 00:29:40,000
నేను, ముందుకు వెళ్ళి, GDB యొక్క ప్రాంప్టులో పరుగుల టైప్ వెళుతున్న

549
00:29:40,000 --> 00:29:43,000
నేను టైప్ అమలు చేసిన స్క్రీన్ యొక్క దిగువ ఎడమ వైపు గమనించి,

550
00:29:43,000 --> 00:29:45,000
మరియు నేను ఎంటర్ నొక్కండి చేసిన, మరియు ఆ ఏం చేసావ్?

551
00:29:45,000 --> 00:29:50,000
ఇది అక్షరాలా నా కార్యక్రమాన్ని, కానీ నిజానికి చాలా ఇక్కడ న వెళ్లిపోవడం లేదు

552
00:29:50,000 --> 00:29:55,000
నిజానికి డీబగ్గర్ చెప్పలేదు ఎందుకంటే

553
00:29:55,000 --> 00:29:57,000
ఒక నిర్దిష్ట సమయంలో ఆగిపోవటం.

554
00:29:57,000 --> 00:29:59,000
జస్ట్ పరుగుల టైప్ కార్యక్రమం నడుపుతుంది.

555
00:29:59,000 --> 00:30:01,000
నిజానికి ఏదైనా చూడలేదు. నేను సర్దుబాటు కాదు.

556
00:30:01,000 --> 00:30:03,000
>> బదులుగా నాకు మనం.

557
00:30:03,000 --> 00:30:08,000
ఈ GDB ప్రాంప్టులో నాకు బదులుగా ఎంటర్, బ్రేక్ టైప్ తెలియజేయండి.

558
00:30:08,000 --> 00:30:10,000
నేను టైప్ అర్థం కాదు.

559
00:30:10,000 --> 00:30:13,000
బ్రేక్ ప్రధాన టైప్ బదులుగా యొక్క లెట్.

560
00:30:13,000 --> 00:30:15,000
ఇతర మాటలలో, నేను ఒక బ్రేక్ పాయింట్ అని ఏదో, సెట్ చేయాలనుకుంటున్నారా

561
00:30:15,000 --> 00:30:18,000
ఇది బ్రేక్ లేదా విరామం ఎందుకంటే సముచితంగా అనే ఇది

562
00:30:18,000 --> 00:30:21,000
నిర్దిష్ట ప్రదేశంలో మీ ప్రోగ్రామ్ అమలు.

563
00:30:21,000 --> 00:30:23,000
ప్రధాన నా ప్రమేయం పేరు.

564
00:30:23,000 --> 00:30:25,000
GDB అందంగా స్మార్ట్ అని గమనించండి.

565
00:30:25,000 --> 00:30:28,000
ఇది ప్రధాన మార్గం 18 వద్ద సుమారు ప్రారంభించడానికి జరుగుతుందని కనుగొన్నారు

566
00:30:28,000 --> 00:30:32,000
buggy3.c యొక్క, మరియు అప్పుడు ఎడమ ఎగువన ఇక్కడ గమనించవచ్చు

567
00:30:32,000 --> 00:30:34,000
బి + లైన్ 18 హక్కును పక్కనే ఉంది.

568
00:30:34,000 --> 00:30:38,000
నేను లైన్ 18 వద్ద ఒక బ్రేక్ పాయింట్ సెట్ చేసిన నాకు గుర్తు ఉంది.

569
00:30:38,000 --> 00:30:42,000
ఈ సమయంలో నేను పరుగుల టైప్ చేసినప్పుడు, నా ప్రోగ్రామ్ రన్ వెళుతున్న

570
00:30:42,000 --> 00:30:45,000
అప్ వరకు, ఆ బ్రేక్పాయింట్ని హిట్స్

571
00:30:45,000 --> 00:30:48,000
కాబట్టి కార్యక్రమం లైన్ 18 వద్ద నాకు విరామం రెడీ.

572
00:30:48,000 --> 00:30:50,000
ఇక్కడ మేము, వెళ్ళి అమలు.

573
00:30:50,000 --> 00:30:53,000
ఏమీ జరగలేదు అనిపిస్తుంది, కానీ దిగువన ప్రకటన వదిలి

574
00:30:53,000 --> 00:30:58,000
ప్రారంభ కార్యక్రమం, buggy3, buggy3.c లైన్ 18 వద్ద ప్రధాన లో బ్రేక్పాయింట్ని 1.

575
00:30:58,000 --> 00:31:00,000
నేను ఇప్పుడు ఏమి చెయ్యగలను?

576
00:31:00,000 --> 00:31:03,000
>> గమనికను నేను, ముద్రణ వంటి వాటిని టైప్ చెయ్యవచ్చు

577
00:31:03,000 --> 00:31:08,000
కాదు printf, ముద్రణ x, మరియు ఇప్పుడు ఆ వింత ఉంది.

578
00:31:08,000 --> 00:31:11,000
మేము చూస్తారు వంటి $ 1, కేవలం ఉత్సుకత ఉంది

579
00:31:11,000 --> 00:31:14,000
మీరు ఏదో ప్రింట్ ప్రతిసారీ మీరు ఒక కొత్త $ విలువ పొందండి.

580
00:31:14,000 --> 00:31:18,000
, మీరు ఒకవేళ మునుపటి విలువలు తిరిగి చూడండి విధంగా ఉంది

581
00:31:18,000 --> 00:31:21,000
కానీ ఇప్పుడు ఏ print నాకు చెప్తుంటాడు అని కథ ఈ సమయంలో x విలువ

582
00:31:21,000 --> 00:31:26,000
స్పష్టంగా 134514032 ఉంది.

583
00:31:26,000 --> 00:31:29,000
ఏం? కూడా ఎక్కడ నుండి వచ్చింది?

584
00:31:29,000 --> 00:31:31,000
[వినబడని-విద్యార్థి]

585
00:31:31,000 --> 00:31:34,000
నిజానికి, ఈ మేము ఒక చెత్త విలువ పిలుస్తాను ఏమిటి, మరియు మేము ఇంకా ఈ మాట్లాడారు లేదు చేసిన

586
00:31:34,000 --> 00:31:37,000
కానీ మీరు వేరియబుల్స్ ప్రారంభించడం ఆ కారణం

587
00:31:37,000 --> 00:31:40,000
స్పష్టంగా తద్వారా మీరు వాటిని కలిగి కావలసిన కొన్ని విలువ కలిగి ఉంది.

588
00:31:40,000 --> 00:31:44,000
కానీ క్యాచ్ మీరు వేరియబుల్స్ ప్రకటించవచ్చు గుర్తుచేసుకున్నారు ఉంది

589
00:31:44,000 --> 00:31:46,000
నా సిగ్మా ఉదాహరణకు ఒక క్షణం క్రితం చేశాడు

590
00:31:46,000 --> 00:31:48,000
వాస్తవానికి ఒక విలువ ఇవ్వకుండా.

591
00:31:48,000 --> 00:31:50,000
నేను సిగ్మా ఇక్కడ పైగా చేసిన గుర్తు.

592
00:31:50,000 --> 00:31:52,000
నేను n డిక్లేర్డ్, కాని దాన్ని ఏ విలువ ఇవ్వడం లేదు?

593
00:31:52,000 --> 00:31:56,000
గమనిక, నేను తెలుసు ఎందుకంటే ఆ తర్వాత కొన్ని పంక్తులు లో

594
00:31:56,000 --> 00:31:59,000
GetInt n యొక్క లోపల విలువ ఉంచడం యొక్క సమస్య యొక్క రక్షణ పడుతుంది.

595
00:31:59,000 --> 00:32:02,000
>> కానీ లైన్ 11 యొక్క కథ ఈ సమయంలో

596
00:32:02,000 --> 00:32:05,000
మరియు లైన్ 12 మరియు 13 లైన్ మరియు లైన్ 14

597
00:32:05,000 --> 00:32:08,000
ఆ అనేక పంక్తులు అంతటా n విలువ ఏమిటి?

598
00:32:08,000 --> 00:32:10,000
సి లో మీకు లేదు.

599
00:32:10,000 --> 00:32:14,000
ఇది సాధారణంగా కొన్ని చెత్త విలువ, కొన్ని పూర్తిగా రాండమ్ నెంబర్

600
00:32:14,000 --> 00:32:17,000
మునుపటి ఫంక్షన్ తప్పనిసరిగా ను చేసే

601
00:32:17,000 --> 00:32:21,000
మీ కార్యక్రమం నడుపుతుంది కాబట్టి, రన్ జరిగింది

602
00:32:21,000 --> 00:32:24,000
ఫంక్షన్ FUNCTION, ఫంక్షన్, ఫంక్షన్ అందుతుంది అని గుర్తు.

603
00:32:24,000 --> 00:32:27,000
ఈ ఫ్రేములు, అప్పుడు ఆ విధులు తిరిగి మెమరీ పెట్టబడింది మరియు get

604
00:32:27,000 --> 00:32:31,000
మరియు కేవలం నేను వారి మెమరీ చివరకు తిరిగి ఎరేజర్ తో సూచించారు.

605
00:32:31,000 --> 00:32:37,000
సరే, కేవలం ఈ కార్యక్రమంలో ఈ చరరాశి X జరుగుతుంది

606
00:32:37,000 --> 00:32:41,000
134514032 వంటి కొన్ని చెత్త విలువ కలిగి ఉంది

607
00:32:41,000 --> 00:32:44,000
మునుపటి చర్య నుండి, కాని ఒక నేను రాసిన.

608
00:32:44,000 --> 00:32:47,000
ఇది నిర్వహణ వ్యవస్థ సమర్థవంతంగా వచ్చే ఏదో ఉంటుంది

609
00:32:47,000 --> 00:32:49,000
హుడ్ కింద కొన్ని ఫంక్షన్.

610
00:32:49,000 --> 00:32:52,000
>> సరే, ఆ మంచిది, కాని తర్వాత లైన్ చేరుకునేందుకు ఇప్పుడు చూద్దాం.

611
00:32:52,000 --> 00:32:55,000
నా GDB ప్రాంప్టులో "తర్వాత" టైపు ఉంటే నేను, ఎంటర్ నొక్కండి

612
00:32:55,000 --> 00:32:58,000
గమనించి ఆ, లైన్ 19 చేరుకుంటాడు డౌన్ హైలైట్

613
00:32:58,000 --> 00:33:01,000
కానీ తార్కిక సూత్రప్రాయంగా ఆ లైన్ 18

614
00:33:01,000 --> 00:33:06,000
ఇప్పుడు పూర్తి నేను మళ్ళీ టైప్ అయితే, అమలు "ముద్రణ x"

615
00:33:06,000 --> 00:33:10,000
నేను ఇప్పుడు 1 చూస్తారు, మరియు నిజానికి నేను.

616
00:33:10,000 --> 00:33:14,000
మళ్లీ, $ stuff GDB మీరు గుర్తు ఒక మార్గం

617
00:33:14,000 --> 00:33:17,000
అచ్చుల చరిత్ర మీరు పూర్తి చేసిన ఉపయోగించలేరు.

618
00:33:17,000 --> 00:33:21,000
, ఇప్పుడు నన్ను ముందుకు వెళ్లి Y ముద్రించాలా వీలు, మరియు నిజానికి Y అలాగే కొన్ని క్రేజీ విలువ

619
00:33:21,000 --> 00:33:24,000
కానీ పెద్ద ఒప్పందం లైన్ 19 లో మనం అది అప్పగించడం చేసారు ఎందుకంటే

620
00:33:24,000 --> 00:33:27,000
విలువ 2, కాబట్టి నన్ను మళ్ళీ "తర్వాత" టైప్ తెలియజేయండి.

621
00:33:27,000 --> 00:33:29,000
ఇప్పుడు మేము printf లైన్ లో ఉన్నారు.

622
00:33:29,000 --> 00:33:31,000
నాకు print x తెలియజేసేలా.

623
00:33:31,000 --> 00:33:34,000
నాకు print Y తెలియజేసేలా. స్పష్టముగా, నేను ఈ ప్రింటింగ్ కొద్దిగా అలసిపోయానని పొందుతున్నాను.

624
00:33:34,000 --> 00:33:38,000
నాకు బదులుగా "ప్రదర్శన x" మరియు "ప్రదర్శన y," టైప్ లెట్

625
00:33:38,000 --> 00:33:41,000
మరియు ఇప్పుడు ప్రతిసారీ నేను భవిష్యత్తులో ఒక ఆదేశాన్ని

626
00:33:41,000 --> 00:33:45,000
నేను ఏది గుర్తు చేస్తుంది ఏమి x మరియు y, x మరియు y, x మరియు y ఏమిటి.

627
00:33:45,000 --> 00:33:48,000
>> నేను కూడా, ఒక పక్కన, టైప్ "సమాచారం స్థానికులు."

628
00:33:48,000 --> 00:33:50,000
సమాచారం ప్రత్యేక ఆదేశం ఉంది.

629
00:33:50,000 --> 00:33:52,000
స్థానికులు అది నాకు స్థానిక వేరియబుల్స్ చూపిస్తుంది అర్థం.

630
00:33:52,000 --> 00:33:55,000
నేను మర్చిపోతే లేదా ఈ ఒక క్రేజీ, క్లిష్టమైన విధి ఒకవేళ

631
00:33:55,000 --> 00:33:57,000
నేను లేదా ఎవరో సమాచారం స్థానికులు ఇత్సెల్ఫ్ వ్రాసాడు

632
00:33:57,000 --> 00:34:00,000
ఈ స్థానిక ఫంక్షన్ లోపల అన్ని స్థానిక వేరియబుల్స్ ఏమి ఉన్నాయి

633
00:34:00,000 --> 00:34:03,000
మీరు మీ చుట్టూ దూర్చు అనుకుంటే శ్రద్ధ అని.

634
00:34:03,000 --> 00:34:07,000
ఇప్పుడు, printf కాబట్టి నన్ను ముందుకు మరియు కేవలం రకం వీడలేదు, అమలు గురించి "తర్వాత."

635
00:34:07,000 --> 00:34:10,000
మేము ఈ వాతావరణంలో ఉన్నారు మేము దీన్ని చూసిన లేదు

636
00:34:10,000 --> 00:34:14,000
ఇక్కడ డౌన్ అమలు, కానీ ఇక్కడ ఒక చిన్న నిర్వాహిత సంతరించుకోనుంది గమనిస్తారు.

637
00:34:14,000 --> 00:34:17,000
కానీ, అది తెర భర్తీ నోటీసు

638
00:34:17,000 --> 00:34:21,000
కనుక అది ఒక ఖచ్చితమైన కార్యక్రమం కాదు, కానీ నేను ఎప్పుడూ చుట్టూ దూర్చు ఎందుకంటే ఆ సరైందే

639
00:34:21,000 --> 00:34:23,000
నేను కావాలా print ఉపయోగించి.

640
00:34:23,000 --> 00:34:26,000
>> నా తర్వాత మళ్ళీ టైప్ లెట్, మరియు ఇప్పుడు ఇక్కడ ఆసక్తికరమైన భాగం.

641
00:34:26,000 --> 00:34:29,000
కథలో ఈ సమయంలో, Y 2, మరియు x 1

642
00:34:29,000 --> 00:34:32,000
ఇక్కడ సూచించిన, మరియు తిరిగి, వంటి

643
00:34:32,000 --> 00:34:35,000
నేను కమాండు ఉపయోగిస్తారు ఎందుకంటే ఈ స్వయంచాలకంగా ఇప్పుడు ప్రదర్శించడం ఉంది కారణం

644
00:34:35,000 --> 00:34:40,000
ప్రదర్శన x మరియు ప్రదర్శన y, నేను తరువాత టైప్ కాబట్టి క్షణం

645
00:34:40,000 --> 00:34:43,000
సిద్ధాంతం x మరియు y లో మార్చుకున్నారు మారాలి.

646
00:34:43,000 --> 00:34:45,000
ఇప్పుడు, మేము ఇప్పటికే కేసు మాత్రం కాదు మనకు తెలుసు,

647
00:34:45,000 --> 00:34:49,000
కానీ మేము నిజమైన వై గుర్తించడానికి లోతైన ఈత కొట్టడానికి ఎలా క్షణంలో చూస్తారు.

648
00:34:49,000 --> 00:34:54,000
దురదృష్టవశాత్తు తరువాత, మరియు, Y ఇప్పటికీ 2 మరియు x ఇంకా 1, మరియు నేను చాలా ధృవీకరించవచ్చు.

649
00:34:54,000 --> 00:34:56,000
ప్రింట్ x, y ముద్రణ.

650
00:34:56,000 --> 00:34:59,000
నిజానికి, ఇచ్చిపుచ్చుకోవడంతో ఏ వాస్తవానికి జరిగింది, ఈ పైగా ప్రారంభిద్దాం.

651
00:34:59,000 --> 00:35:01,000
స్పష్టంగా swap విభజించబడింది.

652
00:35:01,000 --> 00:35:04,000
యొక్క బదులుగా మళ్ళీ "రన్" టైప్ లెట్.

653
00:35:04,000 --> 00:35:07,000
నాకు అవును అని పిలవబడు, నేను ప్రారంభం నుండి దీన్ని మళ్ళీ ప్రారంభించండి మీరు నమోదు చేయండి.

654
00:35:07,000 --> 00:35:09,000
>> ఇప్పుడు నేను తిరిగి అప్ లైన్ 18 వద్ద ఉన్నాను.

655
00:35:09,000 --> 00:35:11,000
ఇప్పుడు x మరియు y మళ్లీ చెత్త విలువలు గమనిస్తారు.

656
00:35:11,000 --> 00:35:15,000
, తదుపరి తదుపరి, తర్వాత, తదుపరి.

657
00:35:15,000 --> 00:35:17,000
నేను విసుగు వస్తే నేను కూడా తర్వాతి కోసం n టైప్ చెయ్యవచ్చు.

658
00:35:17,000 --> 00:35:21,000
మీరు అక్షరాలు తక్కువ అవకాశం క్రమంలో అది సంక్షిప్తంగా చేయవచ్చు.

659
00:35:21,000 --> 00:35:23,000
Swap ఇప్పుడు విభజించబడింది.

660
00:35:23,000 --> 00:35:25,000
బదులుగా తరువాత టైప్ కాబట్టి, లో యొక్క డైవ్ లెట్

661
00:35:25,000 --> 00:35:30,000
నేను ఈ చర్య యొక్క లోపల పునాది చేస్తున్నాను కాబట్టి ఇప్పుడు నేను అడుగు టైప్ వెళుతున్న

662
00:35:30,000 --> 00:35:33,000
నేను నడుస్తూ, అందువలన నేను అడుగు హిట్ తరువాత ఎంటర్ కాబట్టి.

663
00:35:33,000 --> 00:35:37,000
గమనికను లైన్ 36 నా కార్యక్రమంలో హైలైట్ హెచ్చుతగ్గుల క్రింది ఆ.

664
00:35:37,000 --> 00:35:39,000
ఇప్పుడు స్థానిక వేరియబుల్స్ ఏవి?

665
00:35:39,000 --> 00:35:41,000
సమాచారం స్థానికులు.

666
00:35:41,000 --> 00:35:43,000
మేము ఆ లైన్ కు సంపాదించిన లేదు చేసిన ఎందుకంటే ఇంకా ఏదీ,

667
00:35:43,000 --> 00:35:47,000
కాబట్టి యొక్క ముందుకు వెళ్లి అని పిలవబడు "తర్వాత."

668
00:35:47,000 --> 00:35:50,000
ఇప్పుడు మేము tmp, ముద్రణ tmp ఉన్నారు.

669
00:35:50,000 --> 00:35:52,000
చెత్త విలువ, కుడి? నేను అలా అనుకుంటున్నాను.

670
00:35:52,000 --> 00:35:55,000
ఎలా ఒక, ముద్రణ బి, 1 మరియు 2 ప్రింట్?

671
00:35:55,000 --> 00:35:58,000
ఒక క్షణం లో, వెంటనే నేను తరువాత మళ్ళీ టైప్

672
00:35:58,000 --> 00:36:02,000
tmp, ఆశాజనక, 1 యొక్క విలువ తీసుకోవాలని అన్నారు

673
00:36:02,000 --> 00:36:05,000
tmp ఒక విలువ కేటాయించిన కావడం ఎందుకంటే.

674
00:36:05,000 --> 00:36:08,000
>> ఇప్పుడు ఒక, ముద్రణ బి ప్రింట్ చెయ్యాలి కదా,

675
00:36:08,000 --> 00:36:11,000
కానీ ఇప్పుడు tmp ప్రింట్ మరియు ఇది నిజంగానే 1 ఉంది.

676
00:36:11,000 --> 00:36:14,000
నా తర్వాత తెలియజేసేలా. నా తర్వాత తెలియజేసేలా.

677
00:36:14,000 --> 00:36:16,000
నేను swap ఫంక్షన్ పూర్తి చేసిన.

678
00:36:16,000 --> 00:36:19,000
నేను లైన్ 40 లో లోపలి ఇప్పటికీ ఉన్నాను, కాబట్టి నాకు ప్రింట్ తెలియజేయండి

679
00:36:19,000 --> 00:36:22,000
ముద్రణ బి, మరియు నేను tmp ఏమిటి పట్టించుకోను.

680
00:36:22,000 --> 00:36:27,000
అది ఒక అండ్ బి ఇచ్చిపుచ్చుకోవడంతో విషయానికి వస్తే swap సరైన ఉన్నట్లు తెలుస్తుంది.

681
00:36:27,000 --> 00:36:31,000
కానీ ఇప్పుడు తదుపరి టైప్ ఉంటే, నేను, లైన్ 25 తిరిగి వెళ్ళు

682
00:36:31,000 --> 00:36:34,000
అలాగే, x మరియు ముద్రణ y లో నేను టైపు చేస్తే

683
00:36:34,000 --> 00:36:38,000
వారు ఇప్పటికీ మారలేదు, కాబట్టి మేము సమస్య పరిష్కరించబడింది లేదు.

684
00:36:38,000 --> 00:36:41,000
కానీ diagnostically ఇప్పుడు బహుశా ఈ GDB కార్యక్రమం

685
00:36:41,000 --> 00:36:44,000
మేము కనీసం అవగాహన ఒక మెట్టు దగ్గరగా సంపాదించిన చేసిన

686
00:36:44,000 --> 00:36:47,000
ఇక్కడికి ఒక printf ఉంచడం ద్వారా లిట్టర్ మా కోడ్ చేయకుండా తప్పు అవకాశముంది,

687
00:36:47,000 --> 00:36:50,000
printf ఇక్కడ, ఇక్కడ printf తరువాత మళ్ళీ మళ్ళీ అమలు

688
00:36:50,000 --> 00:36:52,000
తప్పు ఏమి గుర్తించడానికి ప్రయత్నిస్తున్నారు.

689
00:36:52,000 --> 00:36:55,000
>> ఐ క్విట్ మొత్తంగా ముందుకు వెళ్లి ఈ నుండి నిష్క్రమించినప్పుడు వెళుతున్న.

690
00:36:55,000 --> 00:36:57,000
తర్వాత సే అవకాశముంది, "ఏమైనప్పటికీ నిష్క్రమించు?" అవును.

691
00:36:57,000 --> 00:37:00,000
ఇప్పుడు నా సాధారణ ప్రాంప్టులో తిరిగి ఉన్నాను, నేను GDB ఉపయోగించి పూర్తయింది.

692
00:37:00,000 --> 00:37:03,000
ఒక పక్కన, మీరు ఈ-టుయ్ జెండాను వినియోగించాలని అవసరం లేదు.

693
00:37:03,000 --> 00:37:07,000
మీరు దీనిని మినహాయించడం ఉంటే నిజానికి, మీరు తప్పనిసరిగా స్క్రీన్ దిగువన సగం పొందండి.

694
00:37:07,000 --> 00:37:11,000
నేను అప్పుడు అమలు తర్వాత విరామం ముఖ్యమైన మరియు ఉంటే

695
00:37:11,000 --> 00:37:15,000
నేను ఇప్పటికీ నా ప్రోగ్రామ్ రన్, కానీ అది చేస్తుంది ఎక్కువ textually ఉంటుంది

696
00:37:15,000 --> 00:37:18,000
ఒక సమయంలో నా ప్రస్తుత రేఖ ఒక చూపించు.

697
00:37:18,000 --> 00:37:21,000
-టుయ్, పాఠ్య యూజర్ ఇంటర్ఫేస్,

698
00:37:21,000 --> 00:37:25,000
కేవలం మీరు ఒకసారి, బహుశా ఒక బిట్ సంభావితంగా సులభంగా అనేది ప్రోగ్రామ్ యొక్క మరింత చూపిస్తుంది.

699
00:37:25,000 --> 00:37:27,000
కానీ నిజానికి, నేను, తర్వాత తర్వాత, తదుపరి చేయవచ్చు

700
00:37:27,000 --> 00:37:30,000
మరియు నేను ఒక సమయంలో ఒక వరుస చూడండి వెళుతున్న మరియు నేను నిజంగా ఏమి చూడాలనుకుంటే

701
00:37:30,000 --> 00:37:35,000
నేను జాబితా టైప్ మరియు పొరుగు రేఖల మొత్తంగా బంచ్ చూడగలరు.

702
00:37:35,000 --> 00:37:39,000
>> మేము సమస్య 3 సెట్స్ కోసం మీరు చూసే అడిగారు ఒక వీడియో ఉంది

703
00:37:39,000 --> 00:37:43,000
దీనిలో నేట్, GDB యొక్క చిక్కులతో కొన్ని కప్పి

704
00:37:43,000 --> 00:37:46,000
మరియు ఈ, నిజాయితీగా, ఆ విషయాలు ఒకటి పేరు మీరు కొన్ని కాని అల్పమైన శాతం

705
00:37:46,000 --> 00:37:49,000
GDB టచ్ కాదు, మరియు ఒక చెడ్డ అంశం ఉంటుంది

706
00:37:49,000 --> 00:37:53,000
అక్షరాలా మీరు ఈ సెమిస్టర్ తరువాత ఎక్కువ సమయం గడిపిన ముగింపు చేసే ఎందుకంటే

707
00:37:53,000 --> 00:37:56,000
దోషాలు డౌన్ వెంటాడుకునే మీరు ఆ అరగంట / గంట లో ఉంచుతాడు ఉంటే

708
00:37:56,000 --> 00:38:00,000
ఈ వారం లెర్నింగ్ GDB సౌకర్యవంతంగా పొందడానికి.

709
00:38:00,000 --> 00:38:02,000
Printf మీ స్నేహితుడు.

710
00:38:02,000 --> 00:38:05,000
GDB మీ స్నేహితుడు ఉండాలి.

711
00:38:05,000 --> 00:38:08,000
>> GDB ఏ ప్రశ్నలు?

712
00:38:08,000 --> 00:38:12,000
మరియు ఇక్కడ అత్యంత శక్తివంతమైన మరియు ఉపయోగకరమైన ఆదేశాలను కొన్ని శీఘ్ర జాబితా ఉంది.

713
00:38:12,000 --> 00:38:15,000
అవును. >> మీరు ఒక స్ట్రింగ్ ప్రింట్ చెయ్యగలనా?

714
00:38:15,000 --> 00:38:17,000
మీరు ఒక స్ట్రింగ్ ప్రింట్ చెయ్యగలనా? ఖచ్చితంగా.

715
00:38:17,000 --> 00:38:19,000
ఇది కేవలం పూర్ణ గా లేదు.

716
00:38:19,000 --> 00:38:22,000
ఒక వేరియబుల్ s print లు కేవలం రకం స్ట్రింగ్ ఉంటే.

717
00:38:22,000 --> 00:38:24,000
ఇది ఆ స్ట్రింగ్ వేరియబుల్ ఏమిటి మీరు చూపిస్తుంది.

718
00:38:24,000 --> 00:38:26,000
[వినబడని-విద్యార్థి]

719
00:38:26,000 --> 00:38:28,000
మీరు చిరునామా మరియు స్ట్రింగ్ కూడా ఇస్తుంది.

720
00:38:28,000 --> 00:38:32,000
మీరు రెండు చూపిస్తుంది.

721
00:38:32,000 --> 00:38:34,000
ఒక చివరి విషయం, ఈ చాలా గుడ్ టు నో ఎందుకంటే.

722
00:38:34,000 --> 00:38:37,000
వెనుకకు మరియు ఫ్రేమ్, నాకు ఈ చివరిసారిగా ప్రవేశిస్తాడు తెలియజేయండి

723
00:38:37,000 --> 00:38:39,000
GDB అదే ఖచ్చితమైన కార్యక్రమం.

724
00:38:39,000 --> 00:38:44,000
నాకు ముందుకు వెళ్లి పాఠ్య యూజర్ ఇంటర్ఫేస్ వెర్షన్ అమలు అయ్యేలా అనుమతించండి,

725
00:38:44,000 --> 00:38:46,000
ప్రధాన విడిపోయారు.

726
00:38:46,000 --> 00:38:49,000
నాకు ముందుకు వెళ్లి మళ్లీ అమలు అయ్యేలా అనుమతించండి. ఇక్కడ నేను.

727
00:38:49,000 --> 00:38:55,000
ఇప్పుడు నాకు, తర్వాత తర్వాత, తదుపరి, తర్వాత, తదుపరి వీడలేదు, మెట్టు, ఇవ్వండి.

728
00:38:55,000 --> 00:39:00,000
>> ఇప్పుడు నేను ఉద్దేశపూర్వకంగా స్వాప్ లో ఇప్పుడు రెడీ అనుకుందాం, కానీ నేను వంటి రెడీ "డామన్, x యొక్క విలువ ఏమిటి?"

729
00:39:00,000 --> 00:39:02,000
నేను ఏవిధంగానూ x చెయ్యలేరు.

730
00:39:02,000 --> 00:39:05,000
వారు పరిధిని చెయ్యని కారణంగా నేను y చెయ్యలేరు.

731
00:39:05,000 --> 00:39:07,000
వారు సందర్భంలో లేదు, కానీ సమస్య లేదు.

732
00:39:07,000 --> 00:39:09,000
నేను వెనుకకు టైప్ చెయ్యవచ్చు.

733
00:39:09,000 --> 00:39:13,000
నాకు ఈ సమయంలో వరకు అమలు చేసిన కార్యక్రమాలను అన్ని చూపిస్తుంది.

734
00:39:13,000 --> 00:39:16,000
గమనికను ప్రధాన ప్రధాన అడుగున ఒక, లైన్లు

735
00:39:16,000 --> 00:39:18,000
ఇక్కడ మా చిత్రం యొక్క అడుగు భాగం లో ఉంది.

736
00:39:18,000 --> 00:39:22,000
swap స్వాప్ ఇక్కడ మెమరీ పైన ఉండటం తో దానిని మార్గాల పైన నిజాన్ని,

737
00:39:22,000 --> 00:39:26,000
మరియు నేను తాత్కాలికంగా ప్రధాన తిరిగి పొందడానికి అనుకుంటే నేను "ఫ్రేమ్." చెప్పగలదు

738
00:39:26,000 --> 00:39:30,000
ఏమి సంఖ్య? మెయిన్ ఫ్రేమ్ # 1.

739
00:39:30,000 --> 00:39:32,000
నేను ముందుకు వెళ్లి చెప్పే వెళుతున్న "ఫ్రేమ్ 1."

740
00:39:32,000 --> 00:39:36,000
>> ఇప్పుడు నేను ప్రధాన తిరిగి ఉన్నాను, నేను x ముద్రించవచ్చు, మరియు నేను, Y ముద్రించవచ్చు

741
00:39:36,000 --> 00:39:40,000
కానీ నేను లేదా బి ముద్రించలేరు.

742
00:39:40,000 --> 00:39:43,000
నేను అయితే నేను, "సరే, ఒక నిమిషం ఆగండి. ఎక్కడ స్వాప్ ఉంది?" చేయవచ్చు

743
00:39:43,000 --> 00:39:46,000
నాకు ముందుకు వెళ్లి అని పిలవబడు "ఫ్రేమ్ 0."

744
00:39:46,000 --> 00:39:48,000
ఇప్పుడు నేను, నేను ఎక్కడ ఉన్నాను తిరిగి, మరియు జనాంతికంగా

745
00:39:48,000 --> 00:39:52,000
మీరు నిజంగా విసుగు టైపింగ్ తరువాత, తదుపరి, తర్వాత, తదుపరి పొందుతుంటే వంటి ఇతర ఆదేశాలు,, చాలా ఉంది

746
00:39:52,000 --> 00:39:56,000
మీరు సాధారణంగా ", తర్వాత 10" వంటి వాటిని చెప్పగలదు మరియు ఆ తరువాత 10 పంక్తులు ద్వారా దిగవచ్చు.

747
00:39:56,000 --> 00:39:59,000
మీరు నిజంగా అది ద్వారా పునాది విసుగు చెంది ఎప్పుడు "కొనసాగు" వ్రాయగలవు.

748
00:39:59,000 --> 00:40:05,000
అది మరొక బ్రేక్పాయింట్ని హిట్స్ వరకు కొనసాగు, ఆటంకం లేకుండా మీ అమలు చేస్తుంది

749
00:40:05,000 --> 00:40:07,000
ఒక లూప్ లో లేదా మీ కార్యక్రమంలో క్రింది.

750
00:40:07,000 --> 00:40:11,000
>> ఈ సందర్భంలో మనం చివరి వరకు కొనసాగింది, మరియు ప్రోగ్రామ్ సాధారణంగా ముగిసింది.

751
00:40:11,000 --> 00:40:13,000
ఈ ఒక ఫాన్సీ మార్గం, అధో ప్రక్రియ.

752
00:40:13,000 --> 00:40:16,000
మీ ప్రోగ్రామ్ సాధారణంగా ముగిసింది.

753
00:40:16,000 --> 00:40:24,000
వీడియో మరియు రాబోయే సెషన్స్ డీబగ్గింగ్ ఆ మరింత.

754
00:40:24,000 --> 00:40:26,000
ఒక నవ్వులాట.

755
00:40:26,000 --> 00:40:35,000
లెట్ యొక్క ఇక్కడ మా 5 నిమిషాల విరామం, మరియు మేము structs మరియు ఫైళ్లను తిరిగి పొందుతారు.

756
00:40:35,000 --> 00:40:38,000
>> మీరు ఇప్పటికే ఈ వారం యొక్క pset ముందుకు అధిగమించాడు ఉంటే

757
00:40:38,000 --> 00:40:41,000
మీరు, మేము పంపిణీ కోడ్ ఉపయోగించే తెలుసు ఉంటాం

758
00:40:41,000 --> 00:40:45,000
మేము ఒక ప్రారంభ బిందువు కొన్ని కొత్త పద్ధతులు మీకు అందించే సోర్స్ కోడ్.

759
00:40:45,000 --> 00:40:50,000
ముఖ్యంగా, మేము, నిర్మాణం కోసం, struct అని ఈ కొత్త కీవర్డ్ పరిచయం

760
00:40:50,000 --> 00:40:53,000
కాబట్టి మేము రకాల మలచుకొనిన వేరియబుల్స్ సృష్టించవచ్చు.

761
00:40:53,000 --> 00:40:57,000
మేము కూడా, ఫైలు I / O, ఫైలు ఇన్పుట్ మరియు అవుట్పుట్ యొక్క భావన పరిచయం

762
00:40:57,000 --> 00:41:00,000
మరియు ఈ మేము రాష్ట్ర సేవ్ చేయవచ్చు ఉంది

763
00:41:00,000 --> 00:41:03,000
మీ పెనుగులాట బోర్డు డిస్క్ లో ఉన్న ఒక ఫైల్ కు

764
00:41:03,000 --> 00:41:06,000
టీచింగ్ సభ్యులు మరియు నేను అర్ధం తద్వారా

765
00:41:06,000 --> 00:41:09,000
ఏ మానవీయంగా ప్లే చేయకుండా మీ ప్రోగ్రామ్ యొక్క లోపల జరగబోతోంది

766
00:41:09,000 --> 00:41:11,000
పెనుగులాట యొక్క గేమ్స్ డజన్ల కొద్దీ.

767
00:41:11,000 --> 00:41:13,000
మేము మరింత automatedly చేయవచ్చు.

768
00:41:13,000 --> 00:41:18,000
>> ఒక struct ఈ ఆలోచన పూర్తి ఖచ్చితంగా సమస్య పరిష్కారమవుతుంది.

769
00:41:18,000 --> 00:41:21,000
మేము కొన్ని కార్యక్రమం అమలు చేయదలిచిన ఒకవేళ

770
00:41:21,000 --> 00:41:25,000
ఆ ఏదో, విద్యార్థులు సమాచారాన్ని ట్రాక్

771
00:41:25,000 --> 00:41:28,000
మరియు విద్యార్థులు, ఉదాహరణకు, ఒక పేరు ఒక ID కలిగి ఉండవచ్చు

772
00:41:28,000 --> 00:41:31,000
మరియు హార్వర్డ్ వంటి ప్రదేశంలో ఒక ఇల్లు, కాబట్టి ఈ సమాచారం యొక్క 3 ముక్కలు ఉంటాయి

773
00:41:31,000 --> 00:41:34,000
మేము చుట్టూ ఉంచాలని, కాబట్టి నన్ను ముందుకు వెళ్లి ఇక్కడ ఒక చిన్న ప్రోగ్రామ్ రాయడం ప్రారంభిద్దాం,

774
00:41:34,000 --> 00:41:38,000
stdio.h ఉన్నాయి.

775
00:41:38,000 --> 00:41:42,000
నాకు cs50.h. ఉన్నాయి తెలియజేసేలా

776
00:41:42,000 --> 00:41:44,000
అప్పుడు నా ప్రధాన విధి ప్రారంభించండి.

777
00:41:44,000 --> 00:41:46,000
నేను ఏ ఆదేశ పంక్తి వాదనలు తో ఇబ్బంది లేదు

778
00:41:46,000 --> 00:41:49,000
మరియు ఇక్కడ నేను ఒక విద్యార్థి కావాలి, కాబట్టి నేను వెళుతున్నాను

779
00:41:49,000 --> 00:41:54,000
ఒక విద్యార్థి ఒక పేరు ఉంది, కాబట్టి నేను వెళుతున్నాను "స్ట్రింగ్ పేరు."

780
00:41:54,000 --> 00:41:59,000
అప్పుడు నేను, ఒక విద్యార్థి కూడా, కాబట్టి Int ID ఒక ID కలిగి వెళుతున్న

781
00:41:59,000 --> 00:42:03,000
మరియు ఒక విద్యార్ధి ఒక ఇల్లు ఉంది, నేను కూడా చెప్పడానికి వెళుతున్న "స్ట్రింగ్ హౌస్."

782
00:42:03,000 --> 00:42:06,000
అప్పుడు నేను ఈ వంటి మరింత సజావుగా ఈ చిన్న ఆర్డర్ చేస్తాము.

783
00:42:06,000 --> 00:42:11,000
సరే, ఇప్పుడు నేను, "ఒక విద్యార్థి." ఇది ఒక విద్యార్థి ప్రాతినిధ్యం 3 వేరియబుల్స్ ఉన్నాయి

784
00:42:11,000 --> 00:42:15,000
>> ఇప్పుడు నేను ఈ విలువలు జననివాసం మీరు, కాబట్టి నా లాంటి ఏదో ముందుకు వెళ్లి అని పిలవబడు

785
00:42:15,000 --> 00:42:18,000
"ID = 123."

786
00:42:18,000 --> 00:42:21,000
పేరు డేవిడ్ పొందడానికి అన్నారు.

787
00:42:21,000 --> 00:42:24,000
లెట్ యొక్క ఇల్లు, మాథుర్ పొందగలిగిన చెప్పారు

788
00:42:24,000 --> 00:42:31,000
మరియు నేను ("% s, ఏకపక్ష printf వంటి ఏదో ఒకటి వెళుతున్న

789
00:42:31,000 --> 00:42:37,000
దీని ID% d ఉంది,% s నివసిస్తున్నారు.

790
00:42:37,000 --> 00:42:41,000
ఇప్పుడు, నేను, ఇక్కడ ప్లగిన్ ఇతర తర్వాత ఏది కావాలి?

791
00:42:41,000 --> 00:42:47,000
పేరు, ID, house; తిరిగి 0.

792
00:42:47,000 --> 00:42:50,000
సరే, తప్ప ఎక్కడో ఇక్కడ ఇరుక్కొనిపోయింది

793
00:42:50,000 --> 00:42:54,000
మనం ఒక విద్యార్థి నిల్వ ఒక అందమైన మంచి కార్యక్రమం ఉంటుందని అనుకుంటున్నాను.

794
00:42:54,000 --> 00:42:57,000
అయితే, ఈ అన్ని ఆసక్తికరమైన కాదు. నేను 2 విద్యార్థులు కలిగి అనుకుంటే?

795
00:42:57,000 --> 00:42:59,000
ఏ పెద్ద ఒప్పందం పేర్కొంది. నేను 2 ప్రజలు మద్దతునిస్తుంది.

796
00:42:59,000 --> 00:43:03,000
నాకు ముందుకు వెళ్లి ఈ హైలైట్ మరియు ఇక్కడ కోల్పోండి,

797
00:43:03,000 --> 00:43:09,000
మరియు నేను కిర్క్ల్యాండ్ నివసించే రాబ్ వంటి ఒకరి కోసం "ID = 456" చెప్పగలను.

798
00:43:09,000 --> 00:43:12,000
>> సరే,, వేచి, కాని నేను ఈ ఇదే కాల్ చెయ్యలేరు

799
00:43:12,000 --> 00:43:15,000
మరియు నేను ఈ కాపీ కలిగి వెళుతున్న అనిపిస్తుంది,

800
00:43:15,000 --> 00:43:19,000
కాబట్టి నన్ను ఈ డేవిడ్ యొక్క వేరియబుల్స్ అని అని పిలవబడు,

801
00:43:19,000 --> 00:43:23,000
మరియు నాకు రాబ్ కోసం ఈ యొక్క కొన్ని కాపీలు పొందుటకు అనుమతిస్తుంది.

802
00:43:23,000 --> 00:43:27,000
ఈ రోబ్ యొక్క పిలుస్తాను కానీ ప్రస్తుతం పని వెళ్ళడం లేదు

803
00:43:27,000 --> 00:43:33,000
I-వేచి ఎందుకంటే, యొక్క NAME1 మరియు house1, id1 నాకు మార్చుకోవడానికి అనుమతించే.

804
00:43:33,000 --> 00:43:35,000
రాబ్, 2 2 ఉంటుంది.

805
00:43:35,000 --> 00:43:42,000
నేను ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ ఈ మార్పు వచ్చింది వచ్చింది.

806
00:43:42,000 --> 00:43:45,000
వేచి, ఏమి టామీ గురించి? మళ్ళీ ఇది యొక్క లెట్.

807
00:43:45,000 --> 00:43:49,000
మీరు ఇప్పటికీ ఈ ఈ చేయడం మంచి మార్గం అనుకుంటున్నాను నిజానికి, అది, కాదు

808
00:43:49,000 --> 00:43:52,000
కాబట్టి కాపీ / చెడు అతికించండి.

809
00:43:52,000 --> 00:43:55,000
అయితే వారం క్రితం ఈ పరిష్కారమైంది.

810
00:43:55,000 --> 00:43:59,000
>> మేము అదే రకం అనేక చోట్ల కలిగి కోరుకున్నారు మా పరిష్కారం ఏమిటి?

811
00:43:59,000 --> 00:44:01,000
[స్టూడెంట్స్] ఒక అమరిక.

812
00:44:01,000 --> 00:44:03,000
ఒక అమరిక, కాబట్టి ఈ శుభ్రం చేయడానికి ప్రయత్నించండి తెలియజేయండి.

813
00:44:03,000 --> 00:44:07,000
నాకు ఎగువన నా కోసం కొన్ని కల్పించడానికి, మరియు నాకు బదులుగా ఇక్కడ మనం లెట్.

814
00:44:07,000 --> 00:44:12,000
ఈ ప్రజలు పిలుస్తాను, మరియు బదులుగా నేను ", Int ఐడిలు" అని వెళుతున్న

815
00:44:12,000 --> 00:44:14,000
ఇప్పుడు మాకు యొక్క 3 మద్దతు వెళుతున్న.

816
00:44:14,000 --> 00:44:18,000
నేను, "స్ట్రింగ్ పేర్లు" అని నేను మా 3 మద్దతు చేస్తాము వెళుతున్న

817
00:44:18,000 --> 00:44:22,000
మరియు నేను ", స్ట్రింగ్ ఇళ్ళు" అని నేను మా 3 మద్దతు వెళుతున్న వెళుతున్న.

818
00:44:22,000 --> 00:44:26,000
ఇప్పుడు ఇక్కడ బదులుగా డేవిడ్ తన స్వంత స్థానిక వేరియబుల్స్ పొందడానికి లో

819
00:44:26,000 --> 00:44:28,000
మేము ఆ విమోచనం పొందవచ్చు.

820
00:44:28,000 --> 00:44:30,000
అంటే ఈ శుభ్రం చేస్తున్న మంచి భావిస్తాడు.

821
00:44:30,000 --> 00:44:35,000
నేను అప్పుడు డేవిడ్ [0] మరియు పేర్లు [0] అని అన్నారు చెప్పగలదు

822
00:44:35,000 --> 00:44:38,000
మరియు గృహాలు [0].

823
00:44:38,000 --> 00:44:41,000
మరియు తర్వాత మేము అదేవిధంగా ఈ సేవ్ చేయవచ్చు రోబ్.

824
00:44:41,000 --> 00:44:46,000
యొక్క ఈ డౌన్ ఇక్కడ ఉంచండి తెలియజేయండి, కనుక అతను ఏకపక్ష ఐడిలు [1] చేస్తాడు.

825
00:44:46,000 --> 00:44:50,000
అతను పేర్లు చేస్తాడు [1],

826
00:44:50,000 --> 00:44:53,000
మరియు తర్వాత చివరగా, ఇళ్ళు [1].

827
00:44:53,000 --> 00:44:57,000
>> , స్టిల్ కొద్దిగా శ్రమతో, మరియు ఇప్పుడు నేను ఈ గుర్తించడానికి కలిగి

828
00:44:57,000 --> 00:45:03,000
చెప్పడానికి "లెట్స్ పేర్లు [0], id [0] ఇళ్ళు [0]

829
00:45:03,000 --> 00:45:06,000
మరియు యొక్క ఈ ప్లూరలైజ్ తెలియజేయండి.

830
00:45:06,000 --> 00:45:09,000
ఐడీలు, ID లు, ఐడిలు.

831
00:45:09,000 --> 00:45:12,000
మరియు తిరిగి, దాని చేయటం నాకు నేను, మరలా, నేను ఇప్పటికే, మళ్ళీ అతికించండి / కాపీ నైజం నేను

832
00:45:12,000 --> 00:45:14,000
కాబట్టి అసమానత మరొక పరిష్కారం ఇక్కడ ఉంది ఉంటాయి.

833
00:45:14,000 --> 00:45:18,000
నేను బహుశా, ఆ వంటి లూప్ లేదా ఏదైనా మరింత ఈ శుభ్రం చేయవచ్చు

834
00:45:18,000 --> 00:45:21,000
కాబట్టి చిన్న లో ఇది కాస్త బెటర్ కానీ అనుకుని

835
00:45:21,000 --> 00:45:24,000
నేను అతికించండి / కాపీ నైజం చేస్తున్నాను, అయితే ఈ కూడా, నేను దావా

836
00:45:24,000 --> 00:45:27,000
నిజంగా ప్రాథమికంగా కుడి పరిష్కారం కాదు ఎందుకంటే

837
00:45:27,000 --> 00:45:29,000
కొన్నిసార్లు మేము నిర్ణయించుకుంటే మీరు ఏమి ఏమి?

838
00:45:29,000 --> 00:45:32,000
మమ్మల్ని డేవిడ్ మరియు రాబ్ కోసం ఇమెయిల్ చిరునామాలను నిల్వ వుండాలి

839
00:45:32,000 --> 00:45:34,000
మరియు ఈ కార్యక్రమంలో ప్రతి ఒక్కరూ.

840
00:45:34,000 --> 00:45:36,000
మేము కూడా ఫోన్ సంఖ్యలను నిల్వ చేయాలి.

841
00:45:36,000 --> 00:45:39,000
మేము కూడా అత్యవసర నంబర్లు నిల్వ చేయాలి.

842
00:45:39,000 --> 00:45:41,000
మేము, మేము నిల్వ కావలసిన డేటా అన్ని ఈ ముక్కలు కలిగి

843
00:45:41,000 --> 00:45:43,000
కాబట్టి మీరు చేసే విధంగా గురించి గో?

844
00:45:43,000 --> 00:45:46,000
>> పైన ఉన్న మరొక శ్రేణి ప్రకటించి, తర్వాత మీరు మానవీయంగా జోడించండి

845
00:45:46,000 --> 00:45:49,000
ఒక ఇమెయిల్ చిరునామా [0], ఇమెయిల్ చిరునామా [1]

846
00:45:49,000 --> 00:45:51,000
డేవిడ్ మరియు రాబ్ కోసం మొదలైనవి.

847
00:45:51,000 --> 00:45:56,000
కానీ ఈ రూపకల్పన అంతర్లీన కేవలం ఒక ఊహ నిజంగా ఉంది

848
00:45:56,000 --> 00:45:59,000
నేను మీకు గౌరవం వ్యవస్థ ఉపయోగిస్తున్నాను ఆ

849
00:45:59,000 --> 00:46:03,000
[I] అనేక శ్రేణుల యొక్క ప్రతి

850
00:46:03,000 --> 00:46:06,000
కేవలం ఒకే వ్యక్తి చూడండి ఏమవుతుంది

851
00:46:06,000 --> 00:46:10,000
కాబట్టి [0] ID లను సంఖ్య 123 ఉంది

852
00:46:10,000 --> 00:46:13,000
మరియు నేను ఆ పేర్లు ఊహించుకోవటం వెళుతున్న [0]

853
00:46:13,000 --> 00:46:16,000
అదే వ్యక్తి యొక్క పేరు మరియు ఇళ్ళు [0]

854
00:46:16,000 --> 00:46:21,000
నేను సృష్టించే వివిధ శ్రేణుల యొక్క అన్ని ఒకే వ్యక్తి యొక్క హౌస్ మొదలైనవి ఉంది.

855
00:46:21,000 --> 00:46:24,000
కానీ ప్రాథమిక బంధన ఉంది అని గుర్తించలేకపోతే

856
00:46:24,000 --> 00:46:27,000
సమాచారం, id, పేరు మరియు ఇంటి ఆ 3 ముక్కలు మధ్య,

857
00:46:27,000 --> 00:46:32,000
మేము ఈ కార్యక్రమంలో మోడల్ ప్రయత్నిస్తున్న పరిధి శ్రేణుల అయినప్పటికీ.

858
00:46:32,000 --> 00:46:35,000
వ్యూహాలను ఇలా ఈ ప్రోగ్రాముల మార్గం.

859
00:46:35,000 --> 00:46:38,000
మేము నిజంగా మా కార్యక్రమం లో మోడల్ చేయడానికి ఏమి ఒక వ్యక్తి

860
00:46:38,000 --> 00:46:41,000
డేవిడ్, ఇది లోపలి రాబ్ వంటి ఒక వ్యక్తి వలె

861
00:46:41,000 --> 00:46:46,000
లేదా encapsulating ఒక పేరు మరియు ID మరియు ఒక మందిరం.

862
00:46:46,000 --> 00:46:49,000
>> మేము ఏదో తొడుగు ఈ ఆలోచన వ్యక్తీకరించవచ్చు

863
00:46:49,000 --> 00:46:52,000
ఒక వ్యక్తి ఒక ID, ఒక పేరు మరియు ఒక ఇల్లు ఉంది అనగా

864
00:46:52,000 --> 00:46:55,000
మరియు నిజంగా ఈ హాక్ ఆశ్రయించాల్సిన లేదు వస్తే మేము

865
00:46:55,000 --> 00:46:58,000
ఆ బ్రాకెట్ ఏదో విశ్వసించే

866
00:46:58,000 --> 00:47:02,000
ఈ అసమాన శ్రేణుల యొక్క ప్రతి అదే మానవ పరిధి సూచిస్తుంది?

867
00:47:02,000 --> 00:47:04,000
మేము నిజంగా చేయవచ్చు.

868
00:47:04,000 --> 00:47:08,000
నాకు ఇప్పుడు పై ప్రధాన వెళ్లి, నా సొంత డేటా రకం సృష్టించడానికి వీలు లెట్

869
00:47:08,000 --> 00:47:10,000
మొదటిసారి నిజంగా కోసం.

870
00:47:10,000 --> 00:47:14,000
మేము, పెనుగులాట లో ఈ టెక్నిక్ ఉపయోగించిన

871
00:47:14,000 --> 00:47:17,000
కానీ ఇక్కడ నేను, ముందుకు వెళ్ళి, ఒక డేటా రకాన్ని సృష్టించడానికి వెళుతున్న

872
00:47:17,000 --> 00:47:19,000
మరియు మీరు ఏ, నేను, విద్యార్థి లేదా వ్యక్తి కాల్ వెళుతున్న తెలుసు

873
00:47:19,000 --> 00:47:23,000
మరియు నేను టైప్ ను నిర్వచిస్తాయి కోసం typedef ఉపయోగించడానికి వెళుతున్న.

874
00:47:23,000 --> 00:47:25,000
నేను, ఈ నిర్మాణం పేర్కొన్నారు వెళుతున్న

875
00:47:25,000 --> 00:47:29,000
మరియు ఈ నిర్మాణం, రకం విద్యార్థి యొక్క కోసం, మేము సే చేస్తాము అన్నారు

876
00:47:29,000 --> 00:47:31,000
అది నాకు ఇప్పుడు నాటి లిటిల్ అయినప్పటికీ.

877
00:47:31,000 --> 00:47:33,000
మేము "Int ID." అని మీరు

878
00:47:33,000 --> 00:47:35,000
మేము "స్ట్రింగ్ పేరు." అని మీరు

879
00:47:35,000 --> 00:47:37,000
అప్పుడు మేము "స్ట్రింగ్ హౌస్," అని మీరు

880
00:47:37,000 --> 00:47:40,000
కాబట్టి ఇప్పుడు కోడ్ ఈ కొన్ని పంక్తులు చివరికి

881
00:47:40,000 --> 00:47:45,000
నేను ఉంది గణగణమని ద్వని చేయు నేర్చుకున్న

882
00:47:45,000 --> 00:47:49,000
తీగలను పాటు ints పక్కన ఒక డేటా రకాన్ని, పాటు తేలియాడుతున్న పాటు, డబుల్స్.

883
00:47:49,000 --> 00:47:54,000
>> సమయ పంక్తి 11 లో ఈ క్షణం నాటికి, విద్యార్థులు అనే కొత్త రకం డేటా, ఇప్పుడు ఉంది

884
00:47:54,000 --> 00:47:58,000
మరియు ఇప్పుడు నేను, ఎక్కడైనా నేను అనుకుంటున్నాను ఒక విద్యార్థి వేరియబుల్ ప్రకటించవచ్చు

885
00:47:58,000 --> 00:48:01,000
కాబట్టి నన్ను ప్రజలు ఇక్కడ స్క్రోల్ డౌన్ తెలపండి.

886
00:48:01,000 --> 00:48:05,000
, ఇప్పుడు నేను ఈ వదిలించుకోవటం మరియు నేను ఇక్కడ డేవిడ్ తిరిగి డౌన్ వెళ్ళే

887
00:48:05,000 --> 00:48:10,000
మరియు డేవిడ్ కోసం నేను నిజంగా ఆ డేవిడ్, చెప్పగలదు

888
00:48:10,000 --> 00:48:13,000
మేము వాచ్యంగా, నాకు తర్వాత వేరియబుల్ పేరు చేయవచ్చు

889
00:48:13,000 --> 00:48:16,000
రకం విద్యార్థి అని అన్నారు.

890
00:48:16,000 --> 00:48:18,000
ఈ చిన్న అసహజ చూడండి ఉండవచ్చు కానీ ఈ అన్ని ఆ వివిధ కాదు

891
00:48:18,000 --> 00:48:22,000
ఒక పూర్ణాంకానికి లేదా ఒక స్ట్రింగ్ లేదా ఫ్లోట్ గా ఏదో ప్రకటించారు నుండి.

892
00:48:22,000 --> 00:48:24,000
ఇది కేవలం కాబట్టి, ఇప్పుడు విద్యార్థి అని ఏమవుతుంది

893
00:48:24,000 --> 00:48:28,000
మరియు నేను ఈ నిర్మాణం లోపల ఏదో ఉంచండి అనుకుంటే

894
00:48:28,000 --> 00:48:31,000
నేను ఇప్పుడు వాక్యనిర్మాణం యొక్క కొత్త భాగాన్ని ఉపయోగించడానికి ఉంటుంది, కాని అది చాలా సూటిగా ఉంది

895
00:48:31,000 --> 00:48:39,000
david.id = 123, రాజధాని D లో david.name = "డేవిడ్",

896
00:48:39,000 --> 00:48:42,000
మరియు david.house = "మాథుర్,"

897
00:48:42,000 --> 00:48:46,000
మరియు ఇప్పుడు నేను ఇక్కడ ఈ విషయాన్ని విమోచనం పొందవచ్చు.

898
00:48:46,000 --> 00:48:51,000
మేము ఇప్పుడు నిజంగా ఒక మంచి మార్గంలో మా కార్యక్రమం తిరిగి రూపకల్పన చేసిన ప్రకటన

899
00:48:51,000 --> 00:48:54,000
ఆ ఇప్పుడు మా కార్యక్రమం వాస్తవ ప్రపంచ ప్రతిబింబిస్తుంది.

900
00:48:54,000 --> 00:48:57,000
>> ఒక వ్యక్తి లేదా ఒక విద్యార్థి యొక్క వాస్తవ ప్రపంచ భావన ఉంది.

901
00:48:57,000 --> 00:49:02,000
ఇక్కడ మేము ఇప్పుడు ఒక వ్యక్తి లేదా ప్రత్యేకంగా ఒక విద్యార్థి ఒక సి సంస్కరణను కలిగి ఉన్నారు.

902
00:49:02,000 --> 00:49:05,000
ఆ వ్యక్తి యొక్క లోపలి ఈ సంబంధిత లక్షణాల ఉన్నాయి

903
00:49:05,000 --> 00:49:10,000
ID, పేరు మరియు ఇంటి, కాబట్టి రాబ్ ముఖ్యంగా డౌన్ ఇక్కడ ఇదే అవుతుంది,

904
00:49:10,000 --> 00:49:14,000
, విద్యార్థి రాబ్ కాబట్టి, మరియు ఇప్పుడు = 456 rob.id

905
00:49:14,000 --> 00:49:17,000
rob.name = "రాబ్."

906
00:49:17,000 --> 00:49:20,000
వేరియబుల్ రాబ్ అంటారు వాస్తవం అర్ధం యొక్క విధమైన ఉంది.

907
00:49:20,000 --> 00:49:22,000
మేము X లేదా Y లేదా z అని ఉండవచ్చు.

908
00:49:22,000 --> 00:49:25,000
మేము దానిని అర్థ వివరణ కలిగి రాబ్ అనే

909
00:49:25,000 --> 00:49:28,000
కానీ నిజంగా పేరు, ఆ రంగం యొక్క లోపల ఉంది

910
00:49:28,000 --> 00:49:30,000
కాబట్టి ఇప్పుడు నేను ఈ ఉంటాయి.

911
00:49:30,000 --> 00:49:33,000
ఈ చాలా గట్టిగా డేవిడ్ కోడ్ చేసిన అత్యుత్తమ డిజైన్ భావిస్తాను లేదు.

912
00:49:33,000 --> 00:49:35,000
నేను హార్డ్ రాబ్ కోడ్ చేసిన.

913
00:49:35,000 --> 00:49:39,000
నేను ఇప్పటికీ కొన్ని కాపీ ఆశ్రయించాల్సిన మరియు నేను కొత్త వేరియబుల్స్ కావలసిన ప్రతిసారీ పేస్ట్ చేయాలి.

914
00:49:39,000 --> 00:49:43,000
అంతేకాకుండా, నేను, స్పష్టంగా అంశాలపై ప్రతి ఒక పేరు ఇవ్వాల్సి ఉంటుంది

915
00:49:43,000 --> 00:49:46,000
నేను చాలా కాకుండా అంశాలపై వివరించడానికి మీరు కూడా

916
00:49:46,000 --> 00:49:48,000
 మరింత సామాన్యముగా వంటి విద్యార్థులు.

917
00:49:48,000 --> 00:49:52,000
>> ఇప్పుడు మేము బాగా పని చేసిన ఆలోచనలు విలీనం చెయ్యగలరు

918
00:49:52,000 --> 00:49:56,000
మరియు బదులుగా, మీరు నాకు వేరియబుల్ అని విద్యార్థులు ఇవ్వాలని ఏ, తెలిసిన "సే

919
00:49:56,000 --> 00:50:01,000
మరియు ఇప్పుడు నేను ఈ మరింత శుద్ధి కాబట్టి ", ఇది పరిమాణం 3 అయి వివరించారు,

920
00:50:01,000 --> 00:50:04,000
, మానవీయంగా డిక్లేర్డ్ డేవిడ్ వదిలించుకోవటం

921
00:50:04,000 --> 00:50:08,000
మరియు నేను బదులుగా [0] ఇక్కడ విద్యార్థులు వంటి ఏదో చెప్పగలను.

922
00:50:08,000 --> 00:50:11,000
నేను, [0] ఇక్కడ విద్యార్థులు చెప్పగలదు

923
00:50:11,000 --> 00:50:14,000
విద్యార్థులు ఇక్కడ, మొదలైనవి [0], మరియు నేను చుట్టూ వెళ్ళే

924
00:50:14,000 --> 00:50:16,000
మరియు రాబ్ ఆ శుభ్రం.

925
00:50:16,000 --> 00:50:19,000
నేను కూడా ఇప్పుడు బహుశా ఒక లూప్ జోడించడం గురించి వెళ్ళటానికి

926
00:50:19,000 --> 00:50:23,000
మరియు వాస్తవానికి వినియోగదారు నుండి ఈ విలువలు పొందడానికి GetString మరియు GetInt ఉపయోగించి.

927
00:50:23,000 --> 00:50:27,000
ఈ సాధారణంగా తప్పుడు పద్ధతి ఎందుకంటే నేను స్థిరమైన జోడించడం గురించి వెళ్ళటానికి

928
00:50:27,000 --> 00:50:29,000
ఇక్కడే 3 హార్డ్ కోడ్ కొన్ని స్వతంత్రమైన

929
00:50:29,000 --> 00:50:33,000
మరియు అప్పుడు మీరు ఇంకా ఏ 3 కంటే విద్యార్థులు ఉంచారు అని గుర్తు.

930
00:50:33,000 --> 00:50:36,000
ఇది బహుశా నా ఫైలు ఎగువన నిర్వచించే # ఉపయోగించడానికి మంచిదని

931
00:50:36,000 --> 00:50:40,000
మరియు అవ్ట్, కాబట్టి నిజానికి నాకు ముందుకు వెళ్లి ఈ క్రమపరచుట అనుమతించే అంశం.

932
00:50:40,000 --> 00:50:43,000
>> నాకు నేటి మధ్య ఉండే ఒక ఉదాహరణ ప్రారంభం లెట్

933
00:50:43,000 --> 00:50:46,000
ముందుగానే ఉదాహరణలు, structs1.

934
00:50:46,000 --> 00:50:49,000
ఈ # ఇక్కడ నిర్వచించే ఉపయోగించే మరింత పూర్తి కార్యక్రమం

935
00:50:49,000 --> 00:50:51,000
మరియు మేము సిద్ధంగా 3 విద్యార్ధులు చూడాలని అన్నారు.

936
00:50:51,000 --> 00:50:54,000
ఇక్కడ నేను, విద్యార్థులు ఒక తరగతి విలువ ప్రకటించి నేను

937
00:50:54,000 --> 00:50:57,000
విద్యార్థులు ఒక తరగతిలో కాబట్టి, మరియు ఇప్పుడు నేను ఒక లూప్ ఉపయోగించి నేను

938
00:50:57,000 --> 00:51:00,000
కేవలం కోడ్ కొంచెం సొగసైన చేయడానికి, తరగతి జననివాసం

939
00:51:00,000 --> 00:51:05,000
యూజర్ యొక్క ఇన్పుట్ తో, కాబట్టి 3 ఇది విద్యార్థులు, నేను = 0 నుండి అప్ iterate.

940
00:51:05,000 --> 00:51:07,000
మరియు నేను ఈ వెర్షన్ లో వినియోగదారును ప్రాంప్ట్

941
00:51:07,000 --> 00:51:10,000
 ఏ విద్యార్థి ID, మరియు నేను GetInt తో పొందండి.

942
00:51:10,000 --> 00:51:13,000
ఏ విద్యార్థి యొక్క పేరు, మరియు అప్పుడు నేను GetString తో పొందండి.

943
00:51:13,000 --> 00:51:15,000
విద్యార్థి ఇంటికి ఏమిటి? నేను GetString తో పొందండి.

944
00:51:15,000 --> 00:51:19,000
మరియు ఇక్కడ దిగువన నేను మార్చడానికి నిర్ణయించుకున్నారు

945
00:51:19,000 --> 00:51:22,000
నేను ఈ ముద్రించిన ఏళ్ళ అసలైన లూప్ ఎలా ఉపయోగించాలో,

946
00:51:22,000 --> 00:51:24,000
మరియు నేను చేసిన ప్రింటింగ్ వున్నాను?

947
00:51:24,000 --> 00:51:27,000
వ్యాఖ్య ప్రకారం నేను, మాథుర్ ఎవరైనా ప్రింటింగ్ నేను

948
00:51:27,000 --> 00:51:30,000
మరియు ఆ రాబ్ మరియు టామీ అదే విధంగా ముందుకు-వాస్తవానికి టామీ యొక్క మాథుర్ లో ఇది.

949
00:51:30,000 --> 00:51:34,000
టామీ మరియు డేవిడ్ ఈ సందర్భంలో ముద్రించబడిన, కానీ ఎలా ఈ పని ఉంది?

950
00:51:34,000 --> 00:51:40,000
మేము ముందు ఈ ఫంక్షన్ చూడరు, కానీ అలా ఏమి ఒక అంచనా పడుతుంది లేదు.

951
00:51:40,000 --> 00:51:42,000
తీగలను సరిపోలుస్తుంది.

952
00:51:42,000 --> 00:51:45,000
>> ఇది అవుతుంది ఎందుకంటే తీగలను సరిపోలుతుందో కొద్దిగా కాని స్పష్టమైన యొక్క

953
00:51:45,000 --> 00:51:49,000
అది అర్థం 0 తిరిగి ఉంటే తీగలు ఉంటాయి.

954
00:51:49,000 --> 00:51:53,000
అది ఒక -1 తిరిగి ఉంటే ఒక, ఇతర ముందు అక్షర వస్తుంది అంటే

955
00:51:53,000 --> 00:51:57,000
ఇతర పదం అర్థం +1 తిరిగి ఉంటే మరియు అక్షర వస్తుంది

956
00:51:57,000 --> 00:52:00,000
ఇతర ముందు, మరియు మీరు ఆన్లైన్ లేదా మనిషి పేజీ చూడవచ్చు

957
00:52:00,000 --> 00:52:04,000
సరిగ్గా ఇది మార్గం ఇది చూడటానికి, కానీ ఈ ఇప్పుడు చేస్తున్న అది చెప్పడం అని

958
00:52:04,000 --> 00:52:09,000
[i]. హౌస్ "మాథుర్" సమానంగా ఉంటే

959
00:52:09,000 --> 00:52:13,000
అప్పుడు ముందుకు వెళ్లి అలా ముద్రించాలా మరియు అందువలన మాథుర్ ఉంది.

960
00:52:13,000 --> 00:52:16,000
కానీ ఇక్కడ మేము ముందు చూడని ఏదో ఉంది, మరియు మేము ఈ వచ్చి చేస్తాము.

961
00:52:16,000 --> 00:52:21,000
నేను ఎప్పుడూ నా కార్యక్రమాలు ఏ దీన్ని అవసరం గుర్తు లేదు.

962
00:52:21,000 --> 00:52:24,000
ఉచిత స్పష్టంగా, మెమరీ సూచిస్తూ మెమరీ ఉండండి ఉంది

963
00:52:24,000 --> 00:52:31,000
కానీ నేను స్పష్టంగా ఈ కార్యక్రమం దిగువన ఈ లూప్ లో ఏం మెమరీ ఉండండి వున్నాను?

964
00:52:31,000 --> 00:52:34,000
నేను ఒక వ్యక్తి యొక్క పేరు ఉండండి నేను కనిపిస్తుంది

965
00:52:34,000 --> 00:52:37,000
మరియు ఒక వ్యక్తి యొక్క ఇల్లు, కాని ఎందుకు అని?

966
00:52:37,000 --> 00:52:41,000
>> మీరు GetString ఉపయోగించి చేసిన అన్ని ఈ వారాల అవుతుంది

967
00:52:41,000 --> 00:52:45,000
మేము రకమైన మీ కార్యక్రమాల ప్రతి ఒక ఒక బగ్ పరిచయం చేసిన.

968
00:52:45,000 --> 00:52:51,000
మీరు ఒక స్ట్రింగ్ తిరిగి విధంగా రూపకల్పన కేటాయించుకునే మెమరీ ద్వారా GetString,

969
00:52:51,000 --> 00:52:55,000
వంటి డేవిడ్, లేదా రాబ్, మరియు మీరు మీకు కావలసిన పనులను చేయవచ్చు

970
00:52:55,000 --> 00:52:59,000
మేము మీ కోసం మెమరీ రిజర్వు చేసిన ఎందుకంటే మీ కార్యక్రమంలో ఆ తీగ.

971
00:52:59,000 --> 00:53:02,000
సమస్య మీరు GetString కాల్ ప్రతిసారీ ఈ సమయం

972
00:53:02,000 --> 00:53:05,000
మేము, GetString రచయితలు, ఆపరేటింగ్ సిస్టమ్ అడగడం జరిగింది

973
00:53:05,000 --> 00:53:07,000
ఈ స్ట్రింగ్ కోసం మాకు RAM యొక్క ఒక బిట్ ఇవ్వాలని.

974
00:53:07,000 --> 00:53:09,000
ఈ తదుపరి స్ట్రింగ్ కోసం మాకు RAM యొక్క ఒక బిట్ ఇవ్వండి.

975
00:53:09,000 --> 00:53:11,000
మాకు ఈ తదుపరి స్ట్రింగ్ కోసం కొన్ని మరింత RAM ఇవ్వండి.

976
00:53:11,000 --> 00:53:13,000
ఏం మీరు, ప్రోగ్రామర్, చేస్తున్న ఎప్పుడూ

977
00:53:13,000 --> 00:53:15,000
, మాకు ఆ స్మృతి తిరిగి ఇవ్వడం ఉంది

978
00:53:15,000 --> 00:53:17,000
కాబట్టి ఈ అనేక వారాలు కార్యక్రమాలు అన్ని మీరు వ్రాయలేదు

979
00:53:17,000 --> 00:53:20,000
వారు ను ఉపయోగిస్తూ చేయటం కూడా మెమరీ లీపు అని ఏమి కలిగి

980
00:53:20,000 --> 00:53:24,000
మరింత మెమరీ మీరు GetString కాల్, మరియు ఆ మంచిది ప్రతిసారీ.

981
00:53:24,000 --> 00:53:27,000
ఇది ఆసక్తికరమైన కాదు ఎందుకంటే మేము ఉద్దేశపూర్వకంగా మొదటి వారాలలో అలా

982
00:53:27,000 --> 00:53:29,000
స్ట్రింగ్ నుంచి వస్తున్న కౌంటీ గురించి ఆందోళన కలిగి.

983
00:53:29,000 --> 00:53:34,000
మీరు అన్ని పదం ఉన్నప్పుడు యూజర్ రకాల అది సైన్ తిరిగి రావాలని రోబ్ ఉంది

984
00:53:34,000 --> 00:53:38,000
>> కానీ ముందుకు వెళ్ళటం మేము ఇప్పుడు దీని గురించి మరింత క్లిష్టమైన పొందడానికి ప్రారంభించడానికి కలిగి ఉంటాయి.

985
00:53:38,000 --> 00:53:42,000
మేము మెమరీని కేటాయించాల్సిన ఏ సమయంలో మేము మంచి చివరికి తిరిగి చేతితో.

986
00:53:42,000 --> 00:53:45,000
లేకపోతే మీ Mac లేదా PC లో నిజ ప్రపంచంలో మీరు అప్పుడప్పుడు అనుభవం కలిగి ఉండవచ్చు

987
00:53:45,000 --> 00:53:50,000
మీ కంప్యూటర్ చివరకు halt కు గ్రౌండింగ్ కౌంటీ లక్షణాలు

988
00:53:50,000 --> 00:53:54,000
లేదా స్టుపిడ్ స్పిన్నింగ్ బీచ్ బంతి కేవలం కంప్యూటర్ యొక్క భాగమును ఆక్రమించి ఉన్న

989
00:53:54,000 --> 00:53:56,000
మొత్తం దృష్టిని మరియు మీరు పనులను కాదు.

990
00:53:56,000 --> 00:54:00,000
ఆ దోషాలను ఎన్ని వివరించారు, కానీ ఆ అవకాశం దోషాలు మధ్య చేయవచ్చు

991
00:54:00,000 --> 00:54:03,000
విషయాలు మెమరీ లీకేజ్ అని చేయటం సాఫ్ట్వేర్ ఆ భాగాన్ని రాశాడు ఎవరైనా

992
00:54:03,000 --> 00:54:07,000
మీరు ఉచిత మెమరీ గుర్తుంచుకోండి లేదు ఉపయోగించే

993
00:54:07,000 --> 00:54:10,000
అతను లేదా ఆమె కోసం ఆపరేటింగ్ సిస్టమ్ కోరింది

994
00:54:10,000 --> 00:54:14,000
ఒక CS50 విషయం ఎందుకంటే, GetString ఉపయోగించి, కాని ఇలాంటి ఫంక్షన్లను ఉపయోగించి లేదు

995
00:54:14,000 --> 00:54:16,000
మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడిగే.

996
00:54:16,000 --> 00:54:19,000
మీరు లేదా అవి మేకు మరియు ఉంటే వాస్తవానికి ఆ స్మృతి ఎన్నటికీ తిరిగి

997
00:54:19,000 --> 00:54:24,000
ఒక ప్రోగ్రామ్ తగ్గిస్తుంది మరియు తగ్గిస్తుంది మరియు వేగం తగ్గితే ఆ ఉండాలనే ఒక కారణం

998
00:54:24,000 --> 00:54:26,000
మీరు ఉచిత కాల్ గుర్తుంచుకోండి తప్ప.

999
00:54:26,000 --> 00:54:28,000
>> ఎప్పుడు ఎందుకు మీరు ఉచిత అంటారని మేము వచ్చి చేస్తాము

1000
00:54:28,000 --> 00:54:32,000
కానీ యొక్క కేవలం మంచి కొలత కోసం ముందుకు వెళ్లి ఈ ప్రత్యేక కార్యక్రమం అమలు ప్రయత్నించండి తెలియజేయండి.

1001
00:54:32,000 --> 00:54:35,000
ఈ structs1 అని పిలిచేవారు, ఇవ్వండి.

1002
00:54:35,000 --> 00:54:40,000
డేవిడ్ మాథుర్, నాకు ముందుకు వెళ్లి structs1 అమలు 123 లెట్

1003
00:54:40,000 --> 00:54:47,000
456, రాబ్ కిర్క్ల్యాండ్, 789,

1004
00:54:47,000 --> 00:54:50,000
టామీ మాథుర్, మరియు మేము మాథుర్ డేవిడ్ చూడండి, టామీ యొక్క మాథుర్ లో.

1005
00:54:50,000 --> 00:54:53,000
ఈ కార్యక్రమం పనిచేస్తుందని కొంచెం తెలివి చెక్ ఉంది.

1006
00:54:53,000 --> 00:54:56,000
ఇప్పుడు, దురదృష్టవశాత్తు, ఈ కార్యక్రమం ఆ చిన్న నిరాశపరిచింది ఉంది

1007
00:54:56,000 --> 00:55:00,000
నేను 9 తీగలు అన్ని పని టైప్ లేదు, ఎంటర్ నొక్కండి

1008
00:55:00,000 --> 00:55:04,000
మాథుర్ లో ఉన్న చెప్పారు, ఇంకా ఖచ్చితంగా నేను టైప్ ఎందుకంటే ఇప్పటికే మాథుర్ లో తెలిసినట్లు జరిగినది.

1009
00:55:04,000 --> 00:55:07,000
ఈ కార్యక్రమం మరింత డేటాబేస్ వంటి ఉంటే కనీసం బాగుండేది

1010
00:55:07,000 --> 00:55:10,000
మరియు అది నిజానికి నేను టైప్ చేసిన తర్వాత ఏమి గుర్తు

1011
00:55:10,000 --> 00:55:12,000
నేను మళ్ళీ ఈ ఇన్పుట్ విద్యార్థి రికార్డులు అవసరం లేదు.

1012
00:55:12,000 --> 00:55:15,000
దీనికి ఒక registrarial వ్యవస్థ వంటిది.

1013
00:55:15,000 --> 00:55:21,000
>> మేము, ఫైలు I / O, ఫైలు ఇన్పుట్ మరియు అవుట్పుట్ గా పిలువబడే ఈ పద్ధతిని ఉపయోగించి చేయవచ్చు

1014
00:55:21,000 --> 00:55:24,000
మీరు ఫైల్లను చదవండి లేదా ఫైళ్ళను రాయడానికి కావలసిన సమయం చెప్పడం చాలా సాధారణ మార్గం

1015
00:55:24,000 --> 00:55:26,000
మీరు విధులను కొన్ని నియమాలకు తో చేయవచ్చు.

1016
00:55:26,000 --> 00:55:29,000
నాకు ముందుకు వెళ్లి ఈ ఉదాహరణ structs2.c తెరిచి లెట్

1017
00:55:29,000 --> 00:55:33,000
ఇది దాదాపు ఒకేలా ఉంటుంది, కానీ ఇప్పుడు ఏమి చూడటానికి యొక్క.

1018
00:55:33,000 --> 00:55:36,000
ఫైలు ఎగువన నేను విద్యార్థులు ఒక తరగతి ప్రకటిస్తాయి.

1019
00:55:36,000 --> 00:55:38,000
నేను, వినియోగదారు యొక్క ఇన్పుట్ తో క్లాస్ జననివాసం

1020
00:55:38,000 --> 00:55:41,000
కాబట్టి కోడ్ ఆ పంక్తులు సరిగ్గా ముందు వంటివే.

1021
00:55:41,000 --> 00:55:45,000
మాథుర్ లో ఉన్న ప్రతి ఒక్కరూ ఏకపక్ష ముందు నేను ఇక్కడ స్క్రోల్ డౌన్ అయితే నేను ప్రింట్

1022
00:55:45,000 --> 00:55:47,000
కానీ ఈ ఆసక్తికరమైన కొత్త లక్షణం.

1023
00:55:47,000 --> 00:55:51,000
, కోడ్ యొక్క ఈ పంక్తులు కొత్త అవి ఇక్కడ ఏదో పరిచయం

1024
00:55:51,000 --> 00:55:55,000
ఫైలు, అన్ని టోపీలు, మరియు అది ఇక్కడ * కలిగి ఉంది.

1025
00:55:55,000 --> 00:55:58,000
నాకు అదే ఇక్కడ పైగా, ఇక్కడ ఒక * ఈ తరలించడానికి లెట్.

1026
00:55:58,000 --> 00:56:00,000
>> ఈ ఫంక్షన్ మేము ముందు చూడని, fopen,

1027
00:56:00,000 --> 00:56:03,000
కానీ ఫైల్ను తెరువు అంటే, కనుక ఈ ద్వారా యొక్క చెడిపోయిన తెలియజేయండి

1028
00:56:03,000 --> 00:56:05,000
మరియు ఈ, మేము భవిష్యత్ psets లో తిరిగి వచ్చి మీరు విషయం

1029
00:56:05,000 --> 00:56:10,000
కానీ ఇక్కడ ఈ లైన్ ముఖ్యంగా, డేటాబేస్ గా పిలువబడే ఒక ఫైల్ తెరుచుకుంటుంది

1030
00:56:10,000 --> 00:56:13,000
మరియు అది ప్రత్యేకంగా అది ఏ చేసే విధంగా అది తెరుచుకుంటుంది?

1031
00:56:13,000 --> 00:56:15,000
[వినబడని-విద్యార్థి]

1032
00:56:15,000 --> 00:56:19,000
కుడి, కనుక "W" జస్ట్ ఆపరేటింగ్ సిస్టమ్ చెప్పుచున్నారు అర్థం

1033
00:56:19,000 --> 00:56:21,000
నేను వ్రాయగలరు విధంగా ఈ ఫైల్ను తెరవడం.

1034
00:56:21,000 --> 00:56:23,000
నేను చదవడం ఇష్టం లేదు. కేవలం ఇది కు ఇష్టం లేదు.

1035
00:56:23,000 --> 00:56:26,000
నేను, దాన్ని మార్చండి మరియు శక్తివంతంగా stuff జోడించదలచిన

1036
00:56:26,000 --> 00:56:28,000
మరియు ఫైల్ డేటాబేస్ అని అన్నారు.

1037
00:56:28,000 --> 00:56:30,000
ఈ ఏదైనా చెప్పబడతాయి.

1038
00:56:30,000 --> 00:56:32,000
ఈ database.txt ఉంటుంది. ఈ. DB ఉంటుంది.

1039
00:56:32,000 --> 00:56:37,000
ఈ foo లాంటి పదం ఉంటుంది, కానీ నేను ఏకపక్ష ఫైలు డేటాబేస్ పేరు ఎంచుకున్నాడు.

1040
00:56:37,000 --> 00:56:42,000
ఈ, మేము సమయం మీద ఎక్కువ వివరాలు వచ్చి మేము ఒక చిన్న తెలివి చెక్ ఉంది

1041
00:56:42,000 --> 00:56:47,000
fp, ఫైలు పాయింటర్ కోసం, సమాన NULL లేనప్పుడు అన్ని బాగా అర్థం.

1042
00:56:47,000 --> 00:56:51,000
>> లాంగ్ కథ చిన్న, fopen వంటి విధులను కొన్నిసార్లు విఫలం.

1043
00:56:51,000 --> 00:56:53,000
బహుశా ఫైల్ ఉనికిలో లేదు. బహుశా మీరు డిస్కు ఖాళీ లేదు.

1044
00:56:53,000 --> 00:56:55,000
బహుశా మీరు ఆ ఫోల్డర్ అనుమతి లేదు

1045
00:56:55,000 --> 00:56:58,000
fopen శూన్య ఏదో తిరిగి అయితే చెడు జరిగింది.

1046
00:56:58,000 --> 00:57:02,000
Fopen శూన్య తిరిగి ఒకవేళ విరుద్ధంగా, అన్ని బాగా ఉంటుంది

1047
00:57:02,000 --> 00:57:04,000
మరియు నేను ఈ ఫైలుకు రాయడం మొదలు పెట్టవచ్చు.

1048
00:57:04,000 --> 00:57:06,000
ఇక్కడ ఒక కొత్త ట్రిక్ యొక్క.

1049
00:57:06,000 --> 00:57:08,000
ఇది నా విద్యార్థులు ప్రతి పైగా iterating ఒక కోసం లూప్ ఉంది

1050
00:57:08,000 --> 00:57:10,000
మరియు ఈ, మేము ముందు చేసిన ఏ అలా పోలి ఉంది

1051
00:57:10,000 --> 00:57:15,000
కానీ ఈ ఫంక్షన్, printf printf ఫైల్ కోసం fprintf అని ఒక బంధువు

1052
00:57:15,000 --> 00:57:18,000
మరియు అది మాత్రమే 2 మార్గాలు వివిధ నోటీసు.

1053
00:57:18,000 --> 00:57:20,000
ఒకటి, అది, బదులుగా p యొక్క f మొదలవుతుంది

1054
00:57:20,000 --> 00:57:23,000
కానీ దాని మొదటి వాదన స్పష్టంగా ఏమిటి?

1055
00:57:23,000 --> 00:57:25,000
[స్టూడెంట్స్] ఫైలు. >> ఇది ఒక ఫైలు యొక్క.

1056
00:57:25,000 --> 00:57:30,000
మేము చివరికి ఒక ఫైలు పాయింటర్ ఏమిటి కాకుండా బాధించటం మేము fp అని ఈ విషయం,,

1057
00:57:30,000 --> 00:57:35,000
కానీ ఇప్పుడు కోసం fp కేవలం నేను తెరిచిన ఫైల్ సూచిస్తుంది

1058
00:57:35,000 --> 00:57:41,000
కాబట్టి fprintf ఇక్కడ, ఫైలు ఈ యూజర్ యొక్క ID ముద్రించడం సాధ్యం కు చెబుతున్నారు.

1059
00:57:41,000 --> 00:57:44,000
ఫైలు యూజర్ యొక్క పేరును, కాని స్క్రీన్ చేయడం, ముద్రించడం

1060
00:57:44,000 --> 00:57:47,000
ఫైల్ చేయడానికి, కాదు, సహజంగా, డౌన్ ఇక్కడ అప్పుడు స్క్రీన్ చేయడం, మరియు హౌస్

1061
00:57:47,000 --> 00:57:50,000
ఫైలు మూసివేయండి, అప్పుడు డౌన్ ఇక్కడ మెమరీ ఉచిత.

1062
00:57:50,000 --> 00:57:53,000
>> ఈ వెర్షన్ 2 మరియు సంస్కరణ 1 మధ్య తేడా

1063
00:57:53,000 --> 00:57:58,000
fopen పరిచయం మరియు * ఈ ఫైలు

1064
00:57:58,000 --> 00:58:01,000
మరియు fprintf యొక్క ఈ భావన, కాబట్టి ముగింపు ఫలితంగా ఏమిటి యొక్క చూసేలా.

1065
00:58:01,000 --> 00:58:03,000
నా టెర్మినల్ విండో లోకి వెళ్ళి తెలపండి.

1066
00:58:03,000 --> 00:58:06,000
నమోదు, నాకు structs2 అమలు అయ్యేలా అనుమతించండి.

1067
00:58:06,000 --> 00:58:09,000
అన్ని బాగా ఉన్నట్లు కనిపిస్తుంది. యొక్క structs2 తిరిగి లెట్.

1068
00:58:09,000 --> 00:58:15,000
123, డేవిడ్ మాథుర్, 456, రాబ్ కిర్క్ల్యాండ్,

1069
00:58:15,000 --> 00:58:19,000
789, టామీ మాథుర్, ఇవ్వండి.

1070
00:58:19,000 --> 00:58:23,000
ఒకే ప్రవర్తించారు కనిపిస్తోంది, కానీ ఇప్పుడు ls లేకపోతే

1071
00:58:23,000 --> 00:58:28,000
నా కోడ్ మధ్య ఇక్కడ ఏమి ఫైలు గమనించి, డేటాబేస్,

1072
00:58:28,000 --> 00:58:32,000
కాబట్టి యొక్క ఆ వద్ద ఆ, డేటాబేస్ యొక్క gedit, మరియు లుక్ తెరిచి తెలియజేయండి.

1073
00:58:32,000 --> 00:58:34,000
ఇది ఫైల్ ఫార్మాట్లు అత్యంత శృంగారమైన కాదు.

1074
00:58:34,000 --> 00:58:38,000
నిజంగా పంక్తికి పంక్తికి డేటా లైన్ ఒకటి భాగం

1075
00:58:38,000 --> 00:58:42,000
కానీ Excel లేదా CSV ఫైళ్లు ఉపయోగించే మీరు ఆ, కామా విలువలు వేరు

1076
00:58:42,000 --> 00:58:47,000
నేను ఖచ్చితంగా బదులుగా బహుశా దీన్ని ఇష్టపడుతున్నారు ఏదో ఒకటి చేయడానికి fprintf ఉపయోగించారు కాలేదు

1077
00:58:47,000 --> 00:58:50,000
నిజానికి Excel ఫైల్ యొక్క సమానమైన సృష్టించడానికి అందువల్ల ఆ

1078
00:58:50,000 --> 00:58:53,000
కామాలు, కేవలం కొత్త లైన్లను విషయాలు వేరుచేయడం ద్వారా.

1079
00:58:53,000 --> 00:58:56,000
>> ఈ సందర్భంలో నేను బదులుగా కామాలతో బదులుగా కొత్త మార్గాల ఉపయోగిస్తారు ఉంటే

1080
00:58:56,000 --> 00:59:01,000
నేను బదులుగా ఇలా చేసిన నేను అక్షరాలా Excel లో ఈ డేటాబేస్ ఫైల్ను తెరవడం సాధ్యం.

1081
00:59:01,000 --> 00:59:03,000
చిన్న లో, ఇప్పుడు మేము ఫైళ్లను వ్రాయడం అధికారం ఆ

1082
00:59:03,000 --> 00:59:07,000
మేము ఇప్పుడు డిస్క్ మీద ఉంచుకున్నాము, కొనసాగుతుంది డేటా ప్రారంభించవచ్చు

1083
00:59:07,000 --> 00:59:10,000
మేము మళ్లీ మళ్లీ చుట్టూ సమాచారాన్ని చేయవచ్చు.

1084
00:59:10,000 --> 00:59:14,000
ఇప్పుడు కొంచెం ఎక్కువగా తెలిసిన ఇతర విషయాలను గమనించండి.

1085
00:59:14,000 --> 00:59:16,000
ఈ సి ఫైలు ఎగువన మేము ఒక typedef కలిగి

1086
00:59:16,000 --> 00:59:21,000
మేము ఒక పదానికి ఒక డేటా రకాన్ని సృష్టించాలనుకుంది, ఎందుకంటే

1087
00:59:21,000 --> 00:59:25,000
ఈ రకం పదం అంటారు కాబట్టి, మరియు లోపల ఈ నిర్మాణం యొక్క

1088
00:59:25,000 --> 00:59:27,000
అది ఇప్పుడు చిన్న ఫ్యాన్సియెర్స్ ఉంది.

1089
00:59:27,000 --> 00:59:30,000
ఎందుకు పదం స్పష్టంగా వ్యూహం రూపొందించబడింది?

1090
00:59:30,000 --> 00:59:33,000
కేవలం intuitively పదం ఏమిటి?

1091
00:59:33,000 --> 00:59:35,000
>> ఇది అక్షరాలు యొక్క వ్యూహం ఉంది.

1092
00:59:35,000 --> 00:59:37,000
దానిని తిరిగి తిరిగి అక్షరాలు ఒక శ్రేణి యొక్క.

1093
00:59:37,000 --> 00:59:41,000
అన్ని CAPS లో అక్షరాలు మేము ఏకపక్ష సే నిర్మాణము గరిష్ట పొడవు

1094
00:59:41,000 --> 00:59:44,000
మేము పెనుగులాట కోసం ఉపయోగించే ఆ నిఘంటువులో ఏ పదం యొక్క.

1095
00:59:44,000 --> 00:59:46,000
నేను ఒక +1 ఉన్నాయి?

1096
00:59:46,000 --> 00:59:48,000
శూన్య పాత్ర.

1097
00:59:48,000 --> 00:59:51,000
మేము Bananagrams ఉదాహరణ చేసుకుంది మేము ఒక ప్రత్యేక విలువ అవసరం రీకాల్

1098
00:59:51,000 --> 00:59:55,000
ట్రాక్ పదం చివర క్రమంలో

1099
00:59:55,000 --> 00:59:59,000
సమస్య సెట్ వివరణ చెప్పారు పదాలు వాస్తవానికి ఆగిపోయిన యొక్క, మరియు

1100
00:59:59,000 --> 01:00:03,000
ఇక్కడ మేము, ఒక పదం బూలియన్ విలువ అనుబంధించడం చేస్తున్నారు

1101
01:00:03,000 --> 01:00:05,000
ఒక జెండా, కాబట్టి, ఒప్పు లేదా తప్పు మాట్లాడటం.

1102
01:00:05,000 --> 01:00:09,000
మేము గుర్తించడం ఎందుకంటే మీరు ఇప్పటికే ఈ పదం కనుగొన్నారు

1103
01:00:09,000 --> 01:00:13,000
మేము నిజంగా గుర్తు ఒక మార్గం అవసరం మాత్రమే పెనుగులాట ఒక పదం ఏమిటి

1104
01:00:13,000 --> 01:00:15,000
కానీ మీరు లేదో, మానవ, అది కనుగొన్నారు

1105
01:00:15,000 --> 01:00:20,000
మీరు కనుగొనడానికి లేకపోతే పదం "" మీరు టైప్ కాదు, అందువలన ఎంటర్, ఎంటర్, ఎంటర్

1106
01:00:20,000 --> 01:00:23,000
మరియు 3 పాయింట్లు, 3 పాయింట్లు, 3 పాయింట్లు, 3 పాయింట్లను పొందుతారు.

1107
01:00:23,000 --> 01:00:26,000
మేము ఒక bool అమర్చుట ద్వారా ఆ పదం బ్లాక్ లిస్టు చెయ్యడానికి మీరు

1108
01:00:26,000 --> 01:00:29,000
మీరు ఇప్పటికే అది అనిపిస్తే ఎందుకు నిజమైన, అందుచే మేము యొక్క

1109
01:00:29,000 --> 01:00:31,000
ఈ నిర్మాణం లో కప్పబడుతుంది.

1110
01:00:31,000 --> 01:00:35,000
>> ఇప్పుడు, డౌన్ ఇక్కడ పెనుగులాట లో నిఘంటువు అని ఈ ఇతర struct ఉంది.

1111
01:00:35,000 --> 01:00:39,000
ఇక్కడ కరువవడంతో typedef పదం ఎందుకంటే ఈ సందర్భంలో

1112
01:00:39,000 --> 01:00:43,000
మేము, ఒక నిఘంటువు యొక్క ఆలోచన మాత్రం అవసరం

1113
01:00:43,000 --> 01:00:46,000
మరియు ఒక నిఘంటువు, పదాల మొత్తం బంచ్ కలిగి

1114
01:00:46,000 --> 01:00:49,000
ఈ శ్రేణి సూచించినట్లు, మరియు ఎలా ఆ పదాలు చాలా ఉన్నాయి?

1115
01:00:49,000 --> 01:00:51,000
Well, ఈ వేరియబుల్ అని పరిమాణం అన్నారు ఏ.

1116
01:00:51,000 --> 01:00:53,000
కానీ మేము కేవలం ఒక నిఘంటువు అవసరం.

1117
01:00:53,000 --> 01:00:55,000
మేము నిఘంటువు అనే డేటా రకం అవసరం లేదు.

1118
01:00:55,000 --> 01:00:58,000
మేము వాటిని ఒక అవసరం, కాబట్టి ఇది C హాజరవుతారు

1119
01:00:58,000 --> 01:01:03,000
మీరు typedef చెప్పలేను, మీరు struct పేర్కొన్నట్లు, అప్పుడు వంకర జంట కలుపులు లోపల

1120
01:01:03,000 --> 01:01:05,000
మీరు పేరు పెట్టి తర్వాత, మీ వేరియబుల్స్ ఉంచండి.

1121
01:01:05,000 --> 01:01:09,000
ఈ ఒక వేరియబుల్ అని నిఘంటువు ప్రకటించటం

1122
01:01:09,000 --> 01:01:11,000
ఈ కనిపిస్తోంది.

1123
01:01:11,000 --> 01:01:16,000
దీనికి విరుద్ధంగా, ఈ పంక్తులు పదం అని ఒక పునర్వినియోగ డేటా నిర్మాణం సృష్టిస్తున్నారు

1124
01:01:16,000 --> 01:01:19,000
మేము సృష్టించిన వలె మీరు, పలు కాపీలు సృష్టించవచ్చు ఆ

1125
01:01:19,000 --> 01:01:22,000
విద్యార్థులు పలు కాపీలు.

1126
01:01:22,000 --> 01:01:24,000
>> ఈ చివరికి మాకు ఏమి అనుమతిస్తోంది?

1127
01:01:24,000 --> 01:01:30,000
నాకు సులువైన సార్లు నుండి, చెప్పాలి సాధారణ ఉదాహరణ కదా, తిరిగి వెళ్ళి తెలపండి,

1128
01:01:30,000 --> 01:01:34,000
మరియు compare1.c, యొక్క అని పిలవబడు, నాకు తెరవడం అనుమతిస్తాయి.

1129
01:01:34,000 --> 01:01:38,000
చేతిలో ఇక్కడ సమస్య వాస్తవానికి తిరిగి చర్మము ఉంది

1130
01:01:38,000 --> 01:01:41,000
ఒక స్ట్రింగ్ యొక్క పొర మరియు ఈ శిక్షణ చక్రాలు ఆఫ్ అవుతూ ప్రారంభం

1131
01:01:41,000 --> 01:01:44,000
అది ఒక స్ట్రింగ్ అన్ని ఈ సమయంలో అవుతుంది ఎందుకంటే

1132
01:01:44,000 --> 01:01:47,000
మేము నిజంగా వారం 1 కేవలం ఒక మారుపేరు వాగ్దానం వంటి ఉంది,

1133
01:01:47,000 --> 01:01:51,000
పర్యాయపదంగా కొంచెం గుప్తమైన కనిపించే ఏదో కోసం CS50 లైబ్రరీ నుండి,

1134
01:01:51,000 --> 01:01:53,000
చార్ *, మరియు మేము ముందు ఈ స్టార్ చూసిన.

1135
01:01:53,000 --> 01:01:55,000
మేము ఫైళ్లను సందర్భంలో చూశాడు.

1136
01:01:55,000 --> 01:01:59,000
>> మేము ఇప్పుడు కొంత సమయం కోసం ఈ వివరాలు దాచి చేసిన వై ఇప్పుడు చెప్పండి.

1137
01:01:59,000 --> 01:02:02,000
ఇక్కడ compare1.c గా పిలువబడే ఒక ఫైల్, ఉంది

1138
01:02:02,000 --> 01:02:07,000
మరియు ఇది స్పష్టంగా, s మరియు t, 2 రెమ్మలు కోసం వినియోగదారు అడుగుతుంది

1139
01:02:07,000 --> 01:02:11,000
మరియు అప్పుడు, లైన్ 26 లో సమానత్వం కోసం ఆ తీగలను పోల్చడం ప్రయత్నిస్తుంది

1140
01:02:11,000 --> 01:02:14,000
వారు అది సమాన అయితే, "మీరు అదే పని టైప్"

1141
01:02:14,000 --> 01:02:17,000
మరియు వారు సమానం కాదు అయితే అది "మీరు వివిధ విషయాలను టైప్" అని అంటాడు.

1142
01:02:17,000 --> 01:02:19,000
నాకు ముందుకు వెళ్లి ఈ ప్రోగ్రామ్ రన్ లెట్.

1143
01:02:19,000 --> 01:02:23,000
నా మూల డైరెక్టరీ లోకి వెళ్ళి తెలపండి, ఒక compare1 చేయండి. ఇది సరే సంకలనం.

1144
01:02:23,000 --> 01:02:25,000
నాకు compare1 అమలు అయ్యేలా అనుమతించండి.

1145
01:02:25,000 --> 01:02:27,000
నేను, జూమ్ నమోదు చేస్తారు.

1146
01:02:27,000 --> 01:02:29,000
ఏదైనా చెప్పండి. HELLO.

1147
01:02:29,000 --> 01:02:32,000
నేను మళ్ళీ ఏదైనా చెప్పండి చేస్తాము. HELLO.

1148
01:02:32,000 --> 01:02:34,000
నేను ఖచ్చితంగా వివిధ విషయాలను టైప్ లేదు.

1149
01:02:34,000 --> 01:02:37,000
>> నాకు మళ్ళీ ప్రయత్నించండి లెట్. బై బై.

1150
01:02:37,000 --> 01:02:40,000
ఖచ్చితంగా వివిధ కాదు, ఇక్కడ ఏమి కాబట్టి?

1151
01:02:40,000 --> 01:02:44,000
Well, నిజంగా లైన్ 26 లో ఏం పోలిస్తే ఉంది?

1152
01:02:44,000 --> 01:02:46,000
[వినబడని-విద్యార్థి]

1153
01:02:46,000 --> 01:02:49,000
అవును, కాబట్టి ఇది ఒక స్ట్రింగ్, డేటా రకం, ఒక తెల్ల అబద్ధం రకం అని అవుతుంది.

1154
01:02:49,000 --> 01:02:53,000
ఒక స్ట్రింగ్ ఒక చార్ *, కానీ ఒక చార్ * ఏమిటి?

1155
01:02:53,000 --> 01:02:56,000
ఒక చార్ *, వారు చెప్పగలను, ఒక పాయింటర్ గా

1156
01:02:56,000 --> 01:03:00,000
మరియు ఒక పాయింటర్, ప్రభావవంతంగా ఒక చిరునామా

1157
01:03:00,000 --> 01:03:05,000
ఒక మొత్తం మెమరీలో స్థానం, మరియు మీరు HELLO వంటి పదం టైప్ చేసిన తర్వాత జరిగితే,

1158
01:03:05,000 --> 01:03:08,000
తీగల యొక్క గత చర్చల నుండి రీకాల్

1159
01:03:08,000 --> 01:03:16,000
ఈ పదం వంటి HELLO ఉంది.

1160
01:03:16,000 --> 01:03:19,000
HELLO వంటి ప్రాతినిధ్యం పదం చేయవచ్చు గుర్తుంచుకోండి

1161
01:03:19,000 --> 01:03:22,000
ఈ వంటి పాత్రలు యొక్క వ్యూహం

1162
01:03:22,000 --> 01:03:25,000
తరువాత చివరిలో ఒక ప్రత్యేక పాత్ర, శూన్య పాత్ర అని

1163
01:03:25,000 --> 01:03:27,000
\ సూచిస్తుంది వంటి.

1164
01:03:27,000 --> 01:03:29,000
ఒక స్ట్రింగ్ నిజానికి ఏమిటి?

1165
01:03:29,000 --> 01:03:32,000
, ఈ మెమరీ బహుళ భాగాలుగా ఉంది అని గుర్తించలేకపోతే

1166
01:03:32,000 --> 01:03:36,000
మీరు మొత్తం స్ట్రింగ్ ద్వారా చూడండి ఒకసారి మరియు వాస్తవానికి, ముగింపు మాత్రమే అంటారు

1167
01:03:36,000 --> 01:03:38,000
ప్రత్యేక శూన్య పాత్ర కోసం చూస్తున్న.

1168
01:03:38,000 --> 01:03:41,000
కానీ ఈ నా కంప్యూటర్ యొక్క మెమరీ నుంచి మెమరీ భాగం ఉంది,

1169
01:03:41,000 --> 01:03:44,000
లెట్స్ ఏకపక్ష ఈ స్ట్రింగ్ కేవలం లక్కీ వచ్చింది, చెబుతారు

1170
01:03:44,000 --> 01:03:47,000
మరియు ఇది నా కంప్యూటర్ యొక్క RAM యొక్క చాలా ప్రారంభంలో ఉంచిన తీసుకున్నారు.

1171
01:03:47,000 --> 01:03:54,000
ఈ బైట్ 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> నేను GetString వంటి ఏదైనా చెప్పండి నేను స్ట్రింగ్ s = GetString చేసినప్పుడు

1173
01:04:02,000 --> 01:04:04,000
నిజంగా ఏమి తిరిగి చేయబడిన?

1174
01:04:04,000 --> 01:04:08,000
ఈ గత కొన్ని వారాలపాటు, వాట్ రియల్లీ s నిల్వ చేయబడిన

1175
01:04:08,000 --> 01:04:13,000
పర్ సే ఈ స్ట్రింగ్ కాదు, కానీ ఈ విషయంలో ఏ నిల్వ చేయబడిన ఉంది

1176
01:04:13,000 --> 01:04:18,000
GetString నిజానికి ఏమి చేస్తుంది ఎందుకంటే సంఖ్య 0

1177
01:04:18,000 --> 01:04:20,000
అది భౌతికంగా ఒక స్ట్రింగ్ తిరిగి లేదు.

1178
01:04:20,000 --> 01:04:22,000
కూడా నిజంగా సంభావిత సమంజసం అనిపించుకోదు.

1179
01:04:22,000 --> 01:04:24,000
అది తిరిగి అనేక ఏమి చేస్తుంది.

1180
01:04:24,000 --> 01:04:28,000
ఆ సంఖ్యను, మెమరీ లో హలో చిరునామా

1181
01:04:28,000 --> 01:04:32,000
మరియు స్ట్రింగ్ s తర్వాత, మేము తిరిగి చర్మము ఈ పొర, స్ట్రింగ్ నిజంగా లేకపోతే.

1182
01:04:32,000 --> 01:04:35,000
ఇది మాత్రమే CS50 లైబ్రరీలో సాధారణంగా ఉంది.

1183
01:04:35,000 --> 01:04:38,000
>> ఇది నిజంగా చార్ * అని ఏదో ఉంది.

1184
01:04:38,000 --> 01:04:41,000
ఏ HELLO వంటి పదం ఎందుకంటే చార్ అర్ధమే?

1185
01:04:41,000 --> 01:04:44,000
సరే, అక్షరాలు వరుస, అక్షరాలు ఒక సిరీస్ ఉంది.

1186
01:04:44,000 --> 01:04:47,000
చార్ *, ఒక పాత్ర యొక్క చిరునామా అర్థం

1187
01:04:47,000 --> 01:04:50,000
సో వాట్ ఒక స్ట్రింగ్ తిరిగి శతకము

1188
01:04:50,000 --> 01:04:53,000
ఒక స్ట్రింగ్ తిరిగి ఒక మంచి, సులభమైన మార్గం

1189
01:04:53,000 --> 01:04:57,000
ఉంది కాకుండా నేను 5 లేదా 6 వివిధ బైట్లు తిరిగి ఎలా గుర్తించడానికి ప్రయత్నించండి

1190
01:04:57,000 --> 01:05:01,000
నాకు ఇది బైట్ యొక్క చిరునామా తిరిగి తెలియజేయండి?

1191
01:05:01,000 --> 01:05:03,000
మొదటి ఒకటి.

1192
01:05:03,000 --> 01:05:06,000
ఇతర మాటలలో, నాకు మీరు మెమరీ ఒక పాత్ర యొక్క చిరునామా కల్పించడానికి అనుమతిస్తాయి.

1193
01:05:06,000 --> 01:05:10,000
ఆ, చార్ * సూచిస్తుంది ఏమి మెమోరీలో ఏక పాత్ర యొక్క చిరునామా ఉంది.

1194
01:05:10,000 --> 01:05:12,000
ఆ వేరియబుల్ s కాల్.

1195
01:05:12,000 --> 01:05:15,000
నేను ఏకపక్ష చెప్పాడు ఖచ్చితమైన చిరునామా, 0 అని s లో స్టోర్,

1196
01:05:15,000 --> 01:05:19,000
కేవలం విషయాలు సాధారణ ఉంచడానికి, కానీ నిజానికి అది సాధారణంగా ఒక పెద్ద సంఖ్య ఉంది.

1197
01:05:19,000 --> 01:05:21,000
>> ఒక నిమిషం ఆగండి.

1198
01:05:21,000 --> 01:05:23,000
మీరు మాత్రమే నా మొదటి పాత్ర యొక్క చిరునామా ఇచ్చి ఉంటే, నేను చిరునామా ఏమిటి తెలుసు

1199
01:05:23,000 --> 01:05:25,000
రెండవ పాత్ర, మూడవ, నాలుగవ మరియు ఐదవ?

1200
01:05:25,000 --> 01:05:27,000
[వినబడని-విద్యార్థి]

1201
01:05:27,000 --> 01:05:31,000
స్ట్రింగ్ ముగింపు ఈ సులభ ట్రిక్ ద్వారా ఉన్న మీరు, తెలిసిన

1202
01:05:31,000 --> 01:05:35,000
కాబట్టి మీరు వంటి printf ఏదో ఉపయోగిస్తున్నప్పుడు, ఏ printf వాచ్యంగా, దాని వాదన తీసుకుని

1203
01:05:35,000 --> 01:05:39,000
మేము ఈ% s ప్లేస్హోల్డర్ ఉపయోగించే గుర్తు, తరువాత మీరు పాస్

1204
01:05:39,000 --> 01:05:41,000
ఒక స్ట్రింగ్ నిల్వ చేసే వేరియబుల్.

1205
01:05:41,000 --> 01:05:47,000
ఏం మీరు నిజంగా ప్రయాణిస్తున్న చేస్తున్న స్ట్రింగ్ మొదటి అక్షరం యొక్క చిరునామా.

1206
01:05:47,000 --> 01:05:50,000
Printf తర్వాత, ఆ చిరునామా అందుకున్న తర్వాత లూప్ లేదా కొంత లూప్ ఒక ఉపయోగిస్తుంది

1207
01:05:50,000 --> 01:05:53,000
ఉదాహరణకు, 0, కనుక, నాకు ఇప్పుడు మనం

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" s);

1209
01:06:02,000 --> 01:06:07,000
నేను కాల్ చేసినప్పుడు printf ("% s \ n" s); నేను నిజంగా తో printf అందించే వెబ్

1210
01:06:07,000 --> 01:06:13,000
ఈ ఏకపక్ష కేసులో H. ఇది s లో మొదటి అక్షరం యొక్క చిరునామా, ఉంది

1211
01:06:13,000 --> 01:06:16,000
>> ఎలా printf తెరపై ప్రదర్శించడానికి సరిగ్గా ఏం తెలుసు?

1212
01:06:16,000 --> 01:06:19,000
అమలు వ్యక్తి printf లూప్ కొంత లూప్ లేదా ఒక అమలు

1213
01:06:19,000 --> 01:06:23,000
ఈ పాత్ర ప్రత్యేక శూన్య పాత్ర సమానంగా లేదు చెప్పారు?

1214
01:06:23,000 --> 01:06:25,000
లేకపోతే, ప్రింట్. ఎలా ఈ గురించి?

1215
01:06:25,000 --> 01:06:28,000
ప్రింట్ లేకపోతే, ప్రింట్ ప్రింట్, ప్రింట్.

1216
01:06:28,000 --> 01:06:32,000
ఓహ్, ఈ ఒక ప్రత్యేక ఉంది. ముద్రణ ఆపు మరియు వినియోగదారు తిరిగి.

1217
01:06:32,000 --> 01:06:35,000
మరియు ఆ, సాహిత్యపరంగా హుడ్ కింద జరుగుతున్న అయిన అంతే

1218
01:06:35,000 --> 01:06:38,000
మరియు ఆ, ఒక తరగతి యొక్క మొదటి రోజు జీర్ణమై పలు అంశాలు

1219
01:06:38,000 --> 01:06:43,000
కానీ ఇప్పుడు ఇది నిజంగా అవగాహన ప్రతిదీ యొక్క భవనం బ్లాక్

1220
01:06:43,000 --> 01:06:46,000
ఆ, మా కంప్యూటర్ యొక్క మెమరీ లోపల జరుగుతున్నాయి యొక్క

1221
01:06:46,000 --> 01:06:49,000
చివరకు మేము ఒక చిన్న సహాయం తో ఈ వేరుగా బాధించటం చేస్తాము

1222
01:06:49,000 --> 01:06:51,000
స్టాన్ఫోర్డ్ వద్ద మా ఫ్రెండ్స్ నుండి.

1223
01:06:51,000 --> 01:06:56,000
>> స్టాన్ఫోర్డ్ వద్ద ప్రొఫెసర్ నిక్ Parlante ఈ అద్భుతమైన వీడియో క్రమాన్ని చేశారు

1224
01:06:56,000 --> 01:06:58,000
పరిచయం వివిధ భాషల అన్ని రకాల నుండి

1225
01:06:58,000 --> 01:07:00,000
ఈ చిన్న స్ ఎ క్లెమేషన్ పాత్ర Binky.

1226
01:07:00,000 --> 01:07:03,000
మీరు కేవలం కొన్ని రెండవ స్నీక్ ప్రివ్యూ లో వినడానికి చేయబోతున్నారు వాయిస్

1227
01:07:03,000 --> 01:07:05,000
ఒక స్టాన్ఫోర్డ్ ప్రొఫెసర్ ఆ ఉంటుంది మరియు చేస్తున్నారు

1228
01:07:05,000 --> 01:07:07,000
ఈ హక్కు కేవలం 5 లేదా 6 సెకన్లు ఇప్పుడు,

1229
01:07:07,000 --> 01:07:09,000
కానీ ఈ రోజు మేము ముగించారు చేస్తాము ఏ గమనిక ఉంది

1230
01:07:09,000 --> 01:07:11,000
మరియు బుధవారం ప్రారంభమవుతుంది.

1231
01:07:11,000 --> 01:07:15,000
నేను మీరు Binky, ప్రివ్యూ తో పాయింటర్ ఫన్ ఇస్తాయి.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ సంగీతం] [ప్రొఫెసర్ Parlante] హేయ్, Binky.

1233
01:07:18,000 --> 01:07:21,000
నిద్రలేపే. ఇది పాయింటర్ వినోదం కోసం సమయం.

1234
01:07:21,000 --> 01:07:24,000
[Binky] ఆ ఏమిటి? గమనికలు గురించి తెలుసుకోండి?

1235
01:07:24,000 --> 01:07:26,000
ఓహ్, GOODY!

1236
01:07:26,000 --> 01:07:29,000
>> మేము బుధవారం మీరు చూస్తారు.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]