1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [2 వ వారం, కంటిన్యూడ్]

2
00:00:02,270 --> 00:00:04,220
[డేవిడ్ J. మలన్, హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,220 --> 00:00:06,880
[ఈ CS50 ఉంది. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
అన్ని కుడి. ఈ CS50, మరియు ఈ వారం 2 ముగింపు.

5
00:00:10,990 --> 00:00:14,410
మీరు, ఈ సమయంలో రేపు ఆకలితో కోరుకోవడం ఉంటే

6
00:00:14,410 --> 00:00:18,620
మేము ఒక చిన్న సమూహం రేపు, గురువారం, 1:15 pm వంటి సమావేశం చూడాలని తెలుసు.

7
00:00:18,620 --> 00:00:21,360
మీరు RSVP చెయ్యాలనుకుంటే ఈ URL ఇక్కడ ఉంది.

8
00:00:21,360 --> 00:00:26,740
స్పేస్ తక్కువ ఉంది, కాబట్టి మీరు రూపం ఈ పూర్తి సమయం భర్తీ ఉంది క్షమించు దయచేసి.

9
00:00:26,740 --> 00:00:29,300
ఆసక్తి ఉండవచ్చు మరొక URL, అయితే, ఈ ఉంది.

10
00:00:29,300 --> 00:00:32,369
కేవలం ఒక నెల సమయం గురించి లో, కోర్సు అందుబాటులో అన్నారు

11
00:00:32,369 --> 00:00:36,890
అన్ని విస్తారంగా edX ద్వారా, ఇది ద్వారా ఇంటర్నెట్ లో ఫొల్క్స్ పాటు అనుసరించండి చేయగలరు

12
00:00:36,890 --> 00:00:39,380
నిజానికి, చాలా చురుకుగా కోర్సు చేస్తుంది.

13
00:00:39,380 --> 00:00:42,270
వారు చర్చించండి CS50 ఉపకరణం మరియు CS50 ఉపయోగించి వస్తుంది

14
00:00:42,270 --> 00:00:45,490
మరియు మేము ఇప్పటికే ఈ సెమిస్టర్ ఉపయోగించి చేసిన వివిధ సాఫ్ట్వేర్ పనిముట్లు చాలా.

15
00:00:45,490 --> 00:00:48,710
మరియు మేము ఈ సంవత్సరం ఒక ప్రయోగం వంటి తీసుకోవాలనుకుంటున్న కావలసిన ప్రయత్నాలను ఒక

16
00:00:48,710 --> 00:00:51,930
మేము అనువదిస్తుంది ఎంత కంటెంట్ చూడటానికి

17
00:00:51,930 --> 00:00:53,960
ఇతర మాట్లాడే మరియు రాత భాషలలో.

18
00:00:53,960 --> 00:00:57,500
మీరు ఈ ప్రాజెక్ట్ పాల్గొనడానికి ఆసక్తి కలిగి ఉండవచ్చు కనుక

19
00:00:57,500 --> 00:01:02,270
మేము కోర్సు యొక్క ప్రసంగాలకు ఆంగ్ల అనువాదాలు మరియు ఉపశీర్షికలు అందిస్తుంది వస్తే

20
00:01:02,270 --> 00:01:05,450
మరియు లఘు చిత్రాలు మరియు సెమినార్లు మరియు విభాగాలు మరియు వంటి,

21
00:01:05,450 --> 00:01:08,200
మీరు స్పష్టంగా మాట్లాడే లేదా, సరళముగా ఇతర భాష వ్రాయడానికి ఉంటే

22
00:01:08,200 --> 00:01:12,290
మీరు వీడియోలను ఒకటి లేదా ఎక్కువ పడుతుంది అనగా మేము ఈ ప్రాజెక్ట్ లో మీరు నిమగ్నం చేయాలనకుంటున్నాను

23
00:01:12,290 --> 00:01:15,200
మీరు చాలా బాగా తెలిసిన ఒక భాష వాటిని అనువాదం.

24
00:01:15,200 --> 00:01:18,700
>> మీరు ఇంటర్ఫేస్ యొక్క ఒక భావాన్ని, ఈ వెబ్ ఆధారిత వినియోగదారు ఇంటర్ఫేస్ ఉంది

25
00:01:18,700 --> 00:01:22,090
మేము తప్పనిసరిగా ఈ వంటి UI సృష్టిస్తుంది ఉపయోగించి వస్తుంది ఆ.

26
00:01:22,090 --> 00:01:24,290
ఈ నాకు, కొన్ని హాలోవీన్ క్రితం బోధన జరిగినది

27
00:01:24,290 --> 00:01:27,390
మరియు ఈ సమయంలో స్టాంపులు పక్కన బ్లాక్ లో కుడి వైపు,

28
00:01:27,390 --> 00:01:31,210
మీరు, ఆ రోజు నా నోటి వచ్చేది వివిధ విషయాలను చూస్తారు

29
00:01:31,210 --> 00:01:34,850
మరియు అప్పుడు మీరు కొన్ని ఇతర భాషలోకి అనువదించు చేయగలరు

30
00:01:34,850 --> 00:01:38,690
మ్యాపింగ్ ఈ సందర్భంలో, మధ్య ఖచ్చితంగా ఏమి ఇంగ్లీష్ మరియు, స్పానిష్ చెప్పారు.

31
00:01:38,690 --> 00:01:40,440
కనుక ఇది నిజానికి ఒక చాలా యూజర్ ఫ్రెండ్లీ సాధనం.

32
00:01:40,440 --> 00:01:43,370
మీరు కీబోర్డ్ షార్ట్కట్స్ తో చాలా సులభంగా వేగంగా ముందుకు రివైండ్ మరియు చేయవచ్చు.

33
00:01:43,370 --> 00:01:47,490
మీరు ఈ ప్రయోగం లో పాల్గొనటానికి మరియు మీరు కోరుకుంటున్నారో అయితే మీ పదాలు కనిపించే మరియు చదవండి

34
00:01:47,490 --> 00:01:51,850
అక్కడ వారిని సమర్థవంతమైన వేల పాల్గొని సంకోచించకండి దయచేసి.

35
00:01:51,850 --> 00:01:54,350
సోమవారం నుండి కిట్టెన్ గురించి ఒక పదం.

36
00:01:54,350 --> 00:02:00,350
మేము ఒక అతిగా స్కేరీ సందేశాన్ని పంపారు, లేకపోతే కార్యాలయం గంటల సూచించినట్లు, రియలైజ్

37
00:02:00,350 --> 00:02:03,300
విభాగాలు సూచించినట్లు మరియు, కోర్సు యొక్క రూపకల్పన చాలా ఉంది

38
00:02:03,300 --> 00:02:07,360
విద్యార్థులు సమస్య సెట్ల ద్వారా సహకరించే మరియు పని మాట్లాడుతూ చేసిన

39
00:02:07,360 --> 00:02:11,260
మరియు కలిసి సమస్యలు, మరియు నిజంగా లైన్ కేవలం క్రిందికి వస్తుంది,

40
00:02:11,260 --> 00:02:16,010
మళ్ళీ, మీరు చివరకు submit పని మీ స్వంత ఉండాలి.

41
00:02:16,010 --> 00:02:18,860
కాబట్టి చాలా నిజాయితీగా, ఆఫీస్ అవర్స్ లో, పూర్తిగా సాధారణ యొక్క

42
00:02:18,860 --> 00:02:22,240
ఇది పూర్తిగా మీరు పక్కన స్నేహితుడు చాట్ చెయ్యడానికి, కూడా భావిస్తున్నారు చెయ్యాలో.

43
00:02:22,240 --> 00:02:24,370
>> , అతను లేదా ఆమె కొన్ని టాపిక్ తో పోరాడుతున్న మరియు మీరు వంటి అయితే

44
00:02:24,370 --> 00:02:27,940
"ఓహ్, మంచిది, నన్ను మీరు నేను రాసిన కోడ్ కొన్ని లైన్ ఒక సంగ్రహావలోకనం కల్పించడానికి అనుమతిస్తాయి," ఆ, మంచిది

45
00:02:27,940 --> 00:02:31,250
ఆ జరుగుతుంది, మరియు ఆ అభ్యాసం ప్రక్రియ, నేను అనుకుంటున్నాను, చాలా సహాయకారి ఉంది.

46
00:02:31,250 --> 00:02:36,750
తల చాలా చాలా సెకన్ల కోసం ఇక్కడ విధమైన పక్కకు పై ఉన్నప్పుడు ఎక్కడ రేఖను అధిగమించి ఉంటుంది ఉంది

47
00:02:36,750 --> 00:02:41,160
లేదా ఆ నిజంగా కోసం నిమిషాల కేవలం, మీ స్నేహితుడు ఒక అనుమతించడంలో అవకాశం ఉందని

48
00:02:41,160 --> 00:02:44,160
మరియు ఖచ్చితంగా విషయాలు, ఇమెయిల్ మరియు డ్రాప్బాక్స్ మరియు వంటి ద్వారా మార్పిడి ఎప్పుడు

49
00:02:44,160 --> 00:02:45,640
చాలా మార్గం కూడా ఉంది.

50
00:02:45,640 --> 00:02:48,620
కాబట్టి అన్ని ద్వారా సుఖంగా మరియు స్నేహితులతో చాట్ చేయడానికి ప్రోత్సహించింది భావనలు

51
00:02:48,620 --> 00:02:52,810
మరియు psets మరియు మరింత గురించి మరియు కేవలం సహ విద్యార్థులను మీరు చివరకు submit ఏమి గుర్తించలేరు

52
00:02:52,810 --> 00:02:57,340
నిజంగా మీ సృష్టి మరియు ఇతరుల యొక్క ఉత్పత్తి ఉండాలి.

53
00:02:57,340 --> 00:03:00,490
Pset2 కోసం డొమైన్ నిర్దిష్ట సమస్యలను కావున,

54
00:03:00,490 --> 00:03:04,740
చివరి రేపు రాత్రి వస్తుంది, ఇది, గూఢ లిపి శాస్త్రం యొక్క ప్రపంచ ప్రవేశిస్తాడు ఉంది

55
00:03:04,740 --> 00:03:08,970
ఇది సమాచారం ఎన్క్రిప్ట్ లేదా స్క్రాంబ్లింగ్ యొక్క కళ

56
00:03:08,970 --> 00:03:12,600
మరియు ఈ చివరకు భద్రత ప్రపంచ సంబంధించినది.

57
00:03:12,600 --> 00:03:16,560
ఇప్పుడు, మాకు చాలా కోసం భద్రతా చాలా లౌకిక విధానాల రూపంలో వస్తుంది.

58
00:03:16,560 --> 00:03:19,050
మాకు అన్ని యూజర్ పేర్లు మరియు పాస్వర్డ్లను కలిగి

59
00:03:19,050 --> 00:03:23,450
మరియు మాకు అన్ని ఎక్కువగా చాలా చెడ్డ వినియోగదారు పేర్లు మరియు పాస్వర్డ్లను కలిగి ఉంటాయి.

60
00:03:23,450 --> 00:03:28,240
>> మీ పాస్వర్డ్ను బహుళ వెబ్సైట్లలో అదే ఉంటే, ఆ, బహుశా ఆలోచన కాదు

61
00:03:28,240 --> 00:03:30,070
మేము సెమిస్టర్ చివరిలో చర్చించడానికి వీలుగా.

62
00:03:30,070 --> 00:03:34,720
నో జోక్ - - మీ పాస్వర్డ్ sticky గమనిక లో జరుగుతుంది మీ మానిటర్ మీద,

63
00:03:34,720 --> 00:03:38,350
ఆ చాలా అవసరం బెస్ట్ డిజైన్ కానీ అది ఒక సాధారణ దృగ్విషయంగా కాదు.

64
00:03:38,350 --> 00:03:42,470
మరియు మీరు మీ పాస్వర్డ్లను గుప్తీకరించడానికి గూఢ ఉపయోగించకుంటే,

65
00:03:42,470 --> 00:03:44,210
వారు గురవుతుంటాయి.

66
00:03:44,210 --> 00:03:47,270
మీరు ఒక రహస్య పద పత్రం ద్వారా తెలివైన సూపర్ ఉండటం భావిస్తున్నాను అయితే

67
00:03:47,270 --> 00:03:49,910
ఎక్కడో హార్డు డ్రైవులో మీ పాస్వర్డ్లను అన్ని

68
00:03:49,910 --> 00:03:53,670
కానీ ఎవరూ కూడా చాలా సురక్షిత విధానం కాదని, చూసి వెళుతున్న ఒక ఫోల్డర్ లో ఉంది.

69
00:03:53,670 --> 00:03:56,990
కాబట్టి ఏమి pset2 ప్రవేశపెడుతుంది గూఢ లిపి శాస్త్రం యొక్క ఈ కళ

70
00:03:56,990 --> 00:04:02,010
పాస్వర్డ్లను వంటి వాటిని అన్ని మరింత సురక్షితం తద్వారా మరియు సమాచారం స్క్రాంబ్లింగ్.

71
00:04:02,010 --> 00:04:05,790
ఇక్కడ సందర్భం అని అసురక్షిత డేటా తో

72
00:04:05,790 --> 00:04:07,930
అది గుప్తీకరించడానికి మరియు పెనుగులాటలకు అవకాశం వచ్చింది.

73
00:04:07,930 --> 00:04:11,470
కాబట్టి ఈ, ఉదాహరణకు, ఒక గుప్తీకరించిన సందేశాన్ని యొక్క ఒక ఉదాహరణ.

74
00:04:11,470 --> 00:04:14,700
ఈ నిజానికి ఇంగ్లీష్ ఏదో చెబుతుంది, కాని స్పష్టంగా పూర్తిగా స్పష్టమైన కాదు.

75
00:04:14,700 --> 00:04:18,279
మరియు మేము ఇక్కడ ఈ రహస్య సందేశం ఏ కాకుండా బాధించటం నేడు ఫుల్ సర్కిల్ వచ్చి చేస్తాము.

76
00:04:18,279 --> 00:04:23,490
వారు ఇంగ్లీష్ పదబంధాలు కావచ్చు వంటి కానీ కంప్యూటర్ల వాస్తవిక ప్రపంచంలో, విషయాలు కూడా కనిపించడం లేదు.

77
00:04:23,490 --> 00:04:28,430
ఉదాహరణకు, మీరు ప్రామాణిక Linux లేదా Mac లేదా UNIX కంప్యూటర్ కనుగొనే ఏమిటి

78
00:04:28,430 --> 00:04:32,070
ఒక సమయంలో పాస్వర్డ్ను ఫైలు అని మీద ఒక ఫైల్ లో ఆ ఒకప్పుడు.

79
00:04:32,070 --> 00:04:34,200
>> ఈ రోజుల్లో అది ఇతర ప్రదేశాలకు వెళ్లారు పేర్కొన్నాడు.

80
00:04:34,200 --> 00:04:39,210
మీరు సిస్టమ్ లో సరైన స్థలం లో చూడవచ్చు అయితే, మీరు మీ సభ్యనామం మాత్రమే చూస్తారు

81
00:04:39,210 --> 00:04:43,400
లేదా సిస్టమ్ ఇతర వ్యక్తుల, కానీ మీరు వారి పాస్ వర్డ్ ఎన్క్రిప్టెడ్ వెర్షన్ చూస్తారు.

82
00:04:43,400 --> 00:04:47,980
నిజానికి, అక్కడ పదం గోరీ, క్రింది విషయాల గుప్తీకరించబడింది సూచిస్తుంది

83
00:04:47,980 --> 00:04:52,680
మరియు ఈ కారణం యాదృచ్ఛిక అక్షరాలు మరియు అక్షరాలు మరియు సంఖ్యల శ్రేణి మరియు మొదలైనవి

84
00:04:52,680 --> 00:04:56,480
మాత్రమే సాధారణంగా కొన్ని రహస్య తెలుసుకోవడం వ్యక్తపరచడం చేయవచ్చు -

85
00:04:56,480 --> 00:04:58,840
ఒక రహస్య పదం, ఒక రహస్య సంఖ్య -

86
00:04:58,840 --> 00:05:03,160
అందువలన నిజానికి, గూఢ లిపి శాస్త్రం చివరికి దిమ్మల డౌన్ యొక్క కళ విధమైన విశ్వసించాలని

87
00:05:03,160 --> 00:05:05,650
మరియు ఎవరైనా లేదు ఏదో తెలుసుకోవటం.

88
00:05:05,650 --> 00:05:10,090
కాబట్టి మేము ఈ రోజు ఒక బిట్ మరింత వివరంగా ఈ అన్వేషించడానికి మీరు మరియు pset వచ్చిన.

89
00:05:10,090 --> 00:05:12,200
ఇప్పుడు పాస్ / ఫెయిల్ ఒక పదం.

90
00:05:12,200 --> 00:05:15,360
మీరు కొన్ని pset1, ఉపకరణ, ముందుకు అధిగమించాడు ముఖ్యంగా వంటి

91
00:05:15,360 --> 00:05:19,080
మరియు మీ కోసం చాలా కొత్త వరల్డ్, తెలుసుకుంటారు ఆ చిరాకులను మరియు గందరగోళం

92
00:05:19,080 --> 00:05:21,700
మరియు కేవలం సాంకేతిక సమస్యలను చాలా అంచనా ఉంది,

93
00:05:21,700 --> 00:05:24,180
ముఖ్యంగా చాలా కొత్త ఇక్కడ మొదటి pset తో,

94
00:05:24,180 --> 00:05:27,730
కేవలం ls మరియు CD పరిచయం చేయటం మరియు ఈ అద్భుత ఆదేశాలు

95
00:05:27,730 --> 00:05:33,050
మరియు ఒక కొత్త వాతావరణం మరియు నిజమైన భౌతిక మరియు స్వయంగా కార్యక్రమాలను ప్రత్యేక ఉంది.

96
00:05:33,050 --> 00:05:36,940
కాబట్టి ఒక మద్దతు నిర్మాణం వంటి ఉనికిలో కార్యాలయం గంటల ఖచ్చితంగా ఉన్నాయి చాలా తెలుసుకుంటారు.

97
00:05:36,940 --> 00:05:38,880
>> విభాగాలు ఈ రాబోయే ఆదివారం ప్రారంభం.

98
00:05:38,880 --> 00:05:42,960
కానీ చాలా ముఖ్యంగా, మీరు ఈ మీ కోసం ప్రపంచ కాదు ఆ ఫీలింగ్ చేస్తుంటే,

99
00:05:42,960 --> 00:05:44,710
అది నిజంగా ని పడుతుంది అని తెలుసుకోవటం.

100
00:05:44,710 --> 00:05:48,600
మరియు అది, విఫలం / a తరగతి పాస్ తీసుకునే నాకు సంవత్సరాల క్రితం ఈ అవకాశం కోసం కాదు

101
00:05:48,600 --> 00:05:50,990
నిజాయితీగా, నేను కూడా తరగతిలో అడుగు సెట్ చేసిన ఎప్పుడూ.

102
00:05:50,990 --> 00:05:53,690
మరియు మీరు,, వరకు ఈ మార్పు చోటు సే, కోర్సు యొక్క ఐదవ సోమవారం చేయవచ్చు

103
00:05:53,690 --> 00:05:58,280
మీరు ఇప్పుడు అంచున ఉన్నారు కనుక మొత్తంగా ఆ తెలుసుకుంటారు కాకుండా తల కొన్ని ఇతర నీటిలో,

104
00:05:58,280 --> 00:06:01,260
ఖచ్చితంగా కేవలం పాస్ / విఫలం మారుతుంది భావించబడినది.

105
00:06:01,260 --> 00:06:04,570
మళ్లీ, విషయాలు తీసుకునే హార్వర్డ్ వద్ద ఇక్కడ నిజంగా ఈ సంస్కృతి అక్కడ కాదు పాస్ / విఫలం

106
00:06:04,570 --> 00:06:08,670
ప్రతి ఒక్కరూ నిజంగా, సాధించడానికి లేదా overachieve కోరుకుంటున్నారు నుండి

107
00:06:08,670 --> 00:06:11,130
కానీ స్పష్టముగా, ఇది ఏదో ప్రయత్నిస్తున్న ఒక చక్కని మార్గం

108
00:06:11,130 --> 00:06:16,720
,, చాలా చక్కటి మీకు తెలిసిన కాదు, మరియు మీరు చాలా సందర్భాలలో, చేయడం ముగుస్తుంది మేము

109
00:06:16,720 --> 00:06:18,210
మీ ఆశ్చర్యం బహుశా చాలా.

110
00:06:18,210 --> 00:06:20,980
మరియు కాంక్రీటు పరంగా, నేను, చేస్తుంది సాధారణంగా విఫలం / పాస్ ఏమనుకుంటున్నారు

111
00:06:20,980 --> 00:06:22,940
మీరు pset0 అనుభవించిన ఉండవచ్చు ముఖ్యంగా,

112
00:06:22,940 --> 00:06:26,560
మీరు కొన్ని pset లోకి 10 గంటల, 15 గంటల, 25 గంటల్లో ఉంచితే

113
00:06:26,560 --> 00:06:29,920
మరియు మీరు గోడ మీ తల banging చేస్తున్నారు మరియు అర్థరాత్రి సూపర్ సంతరించుకోనుంది

114
00:06:29,920 --> 00:06:33,950
కానీ మీరు మార్గం pset 90% తీసుకున్నారు మీకు ఒక విషయం గుర్తించడానికి కాదు

115
00:06:33,950 --> 00:06:36,520
నిజంగా ఈ వంటి తరగతి యొక్క అంచు పడుతుంది విఫలం / పాస్,

116
00:06:36,520 --> 00:06:39,100
మీరు సంతోషంగా, సరే, నేను పరిపూర్ణ కాదు తెలుసు "సే యొక్క క్రమం ఇక్కడ

117
00:06:39,100 --> 00:06:42,350
కానీ నేను ఈ నా గాడిద ఆఫ్ పని, నేను ", దానిని ఆగిపోయిన తో అందంగా సంతోషంగా ఉన్నాను

118
00:06:42,350 --> 00:06:44,850
మరియు ఆ పాస్ కోసం ఆశించిన / విఫలమౌతుంది.

119
00:06:44,850 --> 00:06:47,540
కాబట్టి గుర్తుంచుకోండి లేదు. అన్ని కుడి.

120
00:06:47,540 --> 00:06:50,520
>> హార్వర్డ్ విశ్వవిద్యాలయం Wi-Fi ఉపయోగించడానికి ఇబ్బందిపడ్డారు మీకు ఆ సో,

121
00:06:50,520 --> 00:06:54,780
చుట్టూ తేలియాడే ఒక CS50 SSID, Wi-Fi కనెక్షన్, అక్కడ మనకు తెలుసు

122
00:06:54,780 --> 00:06:56,490
మీరు మంచి అదృష్టం చూపించే.

123
00:06:56,490 --> 00:07:00,130
ఇది ఒక చిన్న వ్యంగ్య అని మీరు ఈ కనెక్ట్ చెయ్యడానికి ప్రయత్నించండి అని ఈ కోసం పాస్వర్డ్

124
00:07:00,130 --> 00:07:08,350
మరియు ఇది బాగా ఉంటే మాకు తెలియజేయండి - - మంచి వేగం 12345, అన్ని మార్గం అప్ 8 ఉంది

125
00:07:08,350 --> 00:07:10,910
8 5 కంటే ఎక్కువ సురక్షితమైనది ఎందుకంటే.

126
00:07:10,910 --> 00:07:16,910
మీరు Wi-Fi పాస్వర్డ్ను అవసరమైతే, తీగరహిత ఇక్కడ CS50 కు 12345678 కనెక్ట్

127
00:07:16,910 --> 00:07:20,380
మీరు ఇప్పటికీ అడపాదడపా కనెక్టివిటీ సమస్యలు ఉంటే CS50 న పోస్ట్ చర్చించండి

128
00:07:20,380 --> 00:07:25,420
మరియు మేము ఈ స్థలం కోసం తెలిసిన అధికారులకు తెలియజేస్తాము. అన్ని కుడి.

129
00:07:25,420 --> 00:07:32,230
ముఖ్యంగా అన్ని విషయాలను Apple యొక్క అభిమాని బాలురు లేదా బాలికలు ఎవరు మీరు యొక్క ఆ కోసం కాబట్టి త్వరగా టీజర్,.

130
00:07:32,230 --> 00:07:37,460
నేను తిరిగి కొన్ని సంవత్సరాల నుండి త్రవ్వి, ఇక్కడ iUnlock.c ఈ ఫైలు ఉంది

131
00:07:37,460 --> 00:07:39,930
కేవలం రకమైన మరింత కాంక్రీటు మరియు మరింత క్లిష్టమైన చేయడానికి

132
00:07:39,930 --> 00:07:42,560
మేము రాయడం చేసిన మరింత ప్రాథమిక సి కార్యక్రమాలు కొన్ని.

133
00:07:42,560 --> 00:07:46,910
నేను iUnlock.c, ఈ ఫైల్ అప్ ప్రారంభించింది. ఇది నేడు కోసం లెక్చర్స్ పేజీలో అందుబాటులో ఉంటుంది.

134
00:07:46,910 --> 00:07:49,810
ఎడమ చేతి వైపు మీరు విధులు యొక్క ఒక పొడవైన జాబితాను చూడండి.

135
00:07:49,810 --> 00:07:53,230
కాబట్టి ఈ రాశాడు తోటి కేవలం ప్రధాన కంటే ఎక్కువ విధులు చాలా, అప్ రాశారు.

136
00:07:53,230 --> 00:07:57,340
ఆయన ఇక్కడ లైబ్రరీలను మొత్తం బంచ్ ఉపయోగిస్తారు, మరియు మేము ద్వారా స్క్రోలింగ్ ప్రారంభం ఉంటే,

137
00:07:57,340 --> 00:08:04,890
ఈ వాస్తవానికి అసలైన ఐఫోన్ కోసం మొట్టమొదటి, నేను అనుకున్నట్లుగా, పగులు ఉంది.

138
00:08:04,890 --> 00:08:09,830
>> మీరు అసలైన ఐఫోన్ jailbreak చేయాలనుకున్నప్పుడు, ఇది AT & T నుండి untether అది అర్థం

139
00:08:09,830 --> 00:08:13,710
మరియు వాస్తవానికి, ఇది ప్రత్యేక సాఫ్ట్వేర్ను ఇన్స్టాల్ మరియు ఆపిల్ ప్రజలు ఏమి లేదని పనులను

140
00:08:13,710 --> 00:08:18,480
ఎవరైనా, వారు సాఫ్ట్వేర్ లోపాలు దోపిడీ చేయవచ్చో ఎలా గుర్తించడానికి సమయం పట్టింది

141
00:08:18,480 --> 00:08:22,690
అందువలన ఆపిల్ సాఫ్ట్వేర్ లో తప్పులు, దోషాలు, మరియు జన్మించాడు iUnlock.c -

142
00:08:22,690 --> 00:08:26,760
మీరు మీ కంప్యూటర్లో సంకలనం మరియు ఒక ఐఫోన్ లో అది ఇన్స్టాల్ ఉంటే

143
00:08:26,760 --> 00:08:29,430
ఆ, ఒక USB కేబుల్, సే, ద్వారా మీ కంప్యూటర్ కు కనెక్ట్ చేయబడింది

144
00:08:29,430 --> 00:08:32,450
ఈ మీరు మీ ఐఫోన్ లో పరిపాలనా లేదా root అధికారాలను ఇస్తుంది

145
00:08:32,450 --> 00:08:34,620
మరియు మీరు చాలా చక్కని మీకు కావలసిన పనులను తెలియజేయండి.

146
00:08:34,620 --> 00:08:36,400
కాబట్టి ఈ మనోహరమైన పిల్లి మరియు ఎలుక ఆట ఉన్నాయి

147
00:08:36,400 --> 00:08:39,340
ఆపిల్ మరియు ముఖ్యంగా ప్రపంచంలోని మిగిలిన వారు మధ్య, అనేక సంస్థలు వలె,

148
00:08:39,340 --> 00:08:43,350
మీరు మాత్రమే వారు ఉద్దేశం ఏది ఏమి విధంగా వారి అంశాలను లాక్ చేసేందుకు ప్రయత్నించండి.

149
00:08:43,350 --> 00:08:47,360
కానీ ఈ వంటి వ్యక్తులు మరియు తక్కువ స్థాయి వివరాలు అవగాహన కృతజ్ఞతలు -

150
00:08:47,360 --> 00:08:50,830
మరియు ఈ విషయంలో సి ప్రోగ్రామింగ్ - మరియు తెలిసిన నిర్మాణాలు చాలా

151
00:08:50,830 --> 00:08:55,280
మేము తో ఆడుతున్న చేసారు, నిజంగా హార్డ్వేర్ పరపతి చేయగలరు

152
00:08:55,280 --> 00:08:59,250
ఒక పద్ధతిలో మీరు ఆరోగ్యంగా మరియు కొన్ని కార్పొరేట్ పరిధి అవసరం చూడండి.

153
00:08:59,250 --> 00:09:01,600
కాబట్టి ఉదాహరణకు, నేను, ఈ ఏమి సంఖ్య ఆలోచన ఉంది

154
00:09:01,600 --> 00:09:03,580
కానీ GetVersion, అందంగా సూటిగా ధ్వనులు

155
00:09:03,580 --> 00:09:05,710
మరియు ఈ ఈ వ్యక్తి రాసిన ఒక ఫంక్షన్ ఉన్నట్లు తెలుస్తుంది.

156
00:09:05,710 --> 00:09:09,250
ఇది ఒక వాదన వంటి పూర్ణాంక రకమైన పడుతుంది, ఏదైనా తిరిగి లేదు

157
00:09:09,250 --> 00:09:13,710
కానీ ఇక్కడ లూప్ ఒక మరియు ఒక ఉంటే పరిస్థితి, పరిస్థితి బ్రేక్ ఉంటే, తో లూప్ కనిపిస్తుంది

158
00:09:13,710 --> 00:09:16,770
మేము డౌన్ స్క్రోల్ చేయండి మరియు ఏదో, వెర్షన్ సంఖ్యలను సంబంధం

159
00:09:16,770 --> 00:09:19,650
ఈ కీలక పదాలు చాలా కొత్త ఉంటాయని నేను కూడా.

160
00:09:19,650 --> 00:09:22,590
మరియు మేము ఎప్పుడూ చూడలేదు మరియు ఎప్పుడూ చూడండి కాదు ఇక్కడ విధులు పూర్తి చాలామంది ఉన్నారు

161
00:09:22,590 --> 00:09:24,350
సెమిస్టర్ క్రమంలో.

162
00:09:24,350 --> 00:09:29,160
>> రోజు ముగింపులో, అది మేము ఇప్పటివరకు ఆడటం చేసిన అదే నియమాలు మరియు తర్కం అనుసరిస్తుంది.

163
00:09:29,160 --> 00:09:34,340
కాబట్టి ఈ, మీ ఐఫోన్ 3S లేదా 4s లేదా వెంటనే 5s ఈ రోజుల్లో పగుళ్లు చాలా పాతది

164
00:09:34,340 --> 00:09:38,830
కానీ ఇది అన్ని చాలా మేము ముందుకు అధిగమించాడు చేసిన ఈ ప్రపంచంలో నుండి మనకు తెలుసు.

165
00:09:38,830 --> 00:09:42,280
యొక్క కొంత చిన్న ఉదాహరణ పరిశీలించి లెట్:

166
00:09:42,280 --> 00:09:46,260
ఈ ఒకటి, కొన్ని సిన్టాక్సుతో అప్ వేడెక్కినప్పుడు పెట్టడానికి మరియు కొన్ని ఇతర డేటా రకం

167
00:09:46,260 --> 00:09:48,910
మేము గురించి మాట్లాడారు చేసిన కానీ నిజంగా C. లో చూడని ఆ

168
00:09:48,910 --> 00:09:53,670
ఈ positive1.c అనే ఫైలు, మరియు ఎగువన వ్యాఖ్యలు శాతం,

169
00:09:53,670 --> 00:09:56,070
ఇది ఒక యూజర్ సానుకూల నంబర్ అందించే కోరతాడు.

170
00:09:56,070 --> 00:09:59,910
కాబట్టి అది వినియోగదారు పరస్పర కార్యక్రమాలు nice ఇది డో-సమయంలో లూప్ యొక్క ఉదాహరణకు

171
00:09:59,910 --> 00:10:02,070
మీరు ఏదో ఒకటి చేయడానికి వినియోగదారు చెప్పడం అవసరం పేరు,

172
00:10:02,070 --> 00:10:05,530
మరియు వారు మీరు వాటిని అరుస్తుంటారు లేదా వారి ఇన్పుట్ తిరస్కరించడానికి సహకారం లేకపోతే.

173
00:10:05,530 --> 00:10:10,480
పాయింట్ కేస్: నేను 24 ద్వారా 19 పంక్తులు చేయడానికి నేను

174
00:10:10,480 --> 00:10:14,620
కాబట్టి కాలం యూజర్ me సానుకూల నంబర్ ఇవ్వలేదు.

175
00:10:14,620 --> 00:10:21,340
లైన్ 18 న ఇక్కడ ఈ వివరాలు, నేను ఈ మొత్తం మళ్ళీ వెతికినా నిర్మించడం పై n ప్రకటించాడు

176
00:10:21,340 --> 00:10:26,870
సరైన లైన్ 22 పక్కన నేను నిజానికి n పొందడానికి శ్రద్ధ పేరు వ్యతిరేకంగా? అవును.

177
00:10:26,870 --> 00:10:29,330
[విద్యార్థి] స్కోప్. >> అవును, స్కోప్ కాబట్టి ఈ సమస్యను.

178
00:10:29,330 --> 00:10:31,770
మరియు లేమాన్ నియమాలు, స్కోప్ ఏ చూడండి లేదు?

179
00:10:34,880 --> 00:10:41,560
అవును. >> [వినబడని విద్యార్థి ప్రతిస్పందన] >> మీరు బిగ్గరగా కొద్దిగా స్పీక్?

180
00:10:41,560 --> 00:10:45,440
[విద్యార్థి] మీరు ఆ వేరియబుల్ యాక్సెస్ చేయవచ్చు ఎక్కడ. >> పర్ఫెక్ట్.

181
00:10:45,440 --> 00:10:47,610
మీరు ఒక నిర్దిష్ట వేరియబుల్ యాక్సెస్ చేయవచ్చు ఎక్కడ.

182
00:10:47,610 --> 00:10:50,990
మరియు సాధారణంగా, సైద్ధాంతిక నియమం ఇప్పటివరకు ఉంది కొన్ని వేరియబుల్ యొక్క పరిధిని

183
00:10:50,990 --> 00:10:56,140
మీరు చూసిన ఇటీవల వంకర జంట కలుపులు నిర్వచించబడింది.

184
00:10:56,140 --> 00:11:03,070
>> నేను లైన్ 22 న n ప్రకటించే పొరపాటు ఉంటే ఈ సందర్భంలో, ఆ లైన్ పని చేస్తుంది.

185
00:11:03,070 --> 00:11:10,840
నేను ఒక పూర్ణాంకానికి పొందుతారు, మరియు నేను లైన్ 22 ఆ వేరియబుల్ n లో ఉంచుతాడు

186
00:11:10,840 --> 00:11:17,060
కానీ ఇది కోడ్ లైన్ ఇప్పుడు నేను మాట్లాడటం చేస్తున్నాను ఏ ఆలోచన ఉంది? >> [విద్యార్థి] 25.

187
00:11:17,060 --> 00:11:23,840
[మలన్] 25, మరియు ఈ సందర్భంలో అది వంకర జంట కలుపులు బయట పడుతుంది ఎందుకంటే అది 24 అవుతుంది.

188
00:11:23,840 --> 00:11:28,550
చాలా సులభంగా కేవలం వేరియబుల్ ప్రకటిస్తూ కొంచెం ఒక విసుగుగా యొక్క బిట్ అయితే పరిష్కరించవచ్చు

189
00:11:28,550 --> 00:11:30,700
ఫంక్షన్ యొక్క వెలుపల.

190
00:11:30,700 --> 00:11:32,760
మీరు ఒక అడుగు ముందుకు వెళ్ళే తరువాత నేడు చూస్తారు

191
00:11:32,760 --> 00:11:34,940
మరియు మీరు కూడా ఒక చిన్న సోమరి పొందుతారు.

192
00:11:34,940 --> 00:11:39,660
మరియు ఈ సాధారణంగా పనికిరావు, అయితే మీరు కూడా సోమరితనం పొందలేరు

193
00:11:39,660 --> 00:11:44,150
మరియు, కాబట్టి ఒక లూప్ యొక్క లోపల, ఒక ఫంక్షన్ యొక్క లోపల, కాదు కాదు మాట్లాడటం, ప్రపంచవ్యాప్తంగా ఒక వేరియబుల్ ఉంచండి

194
00:11:44,150 --> 00:11:49,800
నేను లైన్ 15 ఇక్కడ వలె కాని ఫైల్ లోనే, ఫంక్షన్స్ అన్ని వెలుపల మీరు, వ్రాయలేదు.

195
00:11:49,800 --> 00:11:55,220
ఈ సాధారణంగా, పై frowned, కానీ ఈ కొన్నిసార్లు ఇతర సమస్యలకు ఒక పరిష్కారం తెలుసుకుంటారు ఉంది

196
00:11:55,220 --> 00:11:56,910
మేము చివరికి చూస్తారు వంటి.

197
00:11:56,910 --> 00:11:59,500
కాబట్టి ఇప్పుడు మేము ఈ వంటి చెప్పను, కాని మేము ఈ తిరగరాసే లేదో చూడటానికి లెట్స్

198
00:11:59,500 --> 00:12:02,360
కేవలం భిన్నంగా మేమే కొద్దిగా వ్యక్తం ప్రారంభించడానికి.

199
00:12:02,360 --> 00:12:05,550
ఈ కార్యక్రమం కేవలం స్పష్టతను, positive1 ఉంది.

200
00:12:05,550 --> 00:12:11,980
నాకు ఇక్కడ ముందుకు వెళ్లి నా టెర్మినల్ విండో లో ఎంటర్ positive1 తయారు చేద్దాము.

201
00:12:11,980 --> 00:12:15,080
సరే కూర్చింది. నేను Enter ని, positive1 అమలు వెళుతున్న.

202
00:12:15,080 --> 00:12:19,250
నేను మీరు నాకు సానుకూల పూర్ణాంక ఇవ్వాలని కోరుతుంది. నేను -1 సే చేస్తాము. ఆ పని చేయలేదు.

203
00:12:19,250 --> 00:12:22,340
0, 99. ఆ పని ఉంది.

204
00:12:22,340 --> 00:12:25,310
బహుశా కాకపోవచ్చు అత్యంత కఠినమైన పరీక్ష, కానీ కనీసం అది ఒక nice తెలివి చెక్ యొక్క

205
00:12:25,310 --> 00:12:27,100
మేము సరైన చేయవచ్చు.

206
00:12:27,100 --> 00:12:29,570
>> కాబట్టి ఇప్పుడు, నాకు ముందుకు వెళ్లి ఈ యొక్క వెర్షన్ 2 తెరిచి తెలియజేయండి

207
00:12:29,570 --> 00:12:32,800
మరియు ఇప్పటికే వివిధ ఏమిటి?

208
00:12:32,800 --> 00:12:39,030
ఇది ఇదే అమలు చేస్తుంది, అయితే ఏ స్పష్టంగా వివిధ ఈ సారి నుండి దూకడం యొక్క?

209
00:12:40,790 --> 00:12:47,090
ఆకుపచ్చ ఈ bool. గ్రీన్, ఒక డేటా రకాన్ని ఇది bool పిలవబడే ఈ కీవర్డ్ లో హైలైట్ ఉంది.

210
00:12:47,090 --> 00:12:50,510
ఇది C. యొక్క అన్ని రూపాలను కు నిర్మించారు రాదు

211
00:12:50,510 --> 00:12:52,650
మీరు ఒక నిర్దిష్ట గ్రంధాలయం ఉన్నాయి అవసరం.

212
00:12:52,650 --> 00:12:56,460
మేము bool ప్రాప్తి తద్వారా మా సందర్భంలో, నేను CS50 లైబ్రరీ ఉన్నాయి.

213
00:12:56,460 --> 00:12:59,860
కానీ లైన్ 18 లో, మేము ధన్యవాదాలు అని ఇక్కడ బూలియన్ విలువ కలిగి ఉంటాయి.

214
00:12:59,860 --> 00:13:02,190
నేను ఈ ఏదైనా అని ఉండవచ్చు, కాని దాన్ని ధన్యవాదాలు అని

215
00:13:02,190 --> 00:13:04,750
కేవలం రకం కొన్ని అర్థ అర్థం తెలియజేయడానికి.

216
00:13:04,750 --> 00:13:07,700
కాబట్టి మొదట లైన్ 18 న, నేను స్పష్టంగా ధన్యవాదాలు కాదు

217
00:13:07,700 --> 00:13:12,230
ధన్యవాదాలు బూలియన్ విలువ లైన్ 18 లో తప్పుకు initialized ఎందుకంటే.

218
00:13:12,230 --> 00:13:16,500
అది నేను 23 ద్వారా 21 పంక్తులు ఇక్కడ చేసిన ఏ తెలుస్తోంది

219
00:13:16,500 --> 00:13:19,200
నేను రకమైన నా తర్కం తిరిగి చేసిన ఉంది.

220
00:13:19,200 --> 00:13:26,100
ఏ క్రియాశీలకంగా భిన్నం కాబట్టి Int యూజర్ అందించారు ఉంటే, కాని లైన్ 22 లో ఇప్పుడు నేను తనిఖీ

221
00:13:26,100 --> 00:13:31,360
0 కంటే ఎక్కువ, అప్పుడు నేను అది నిజం చేసినందుకు ధన్యవాదాలు విలువ మారుతుంది.

222
00:13:31,360 --> 00:13:35,590
నేను ఎందుకు ఆ చేయాలి? లైన్ 25 లో ఎందుకంటే, స్పష్టంగా నేను పరిస్థితులను తనిఖీ వెళుతున్న.

223
00:13:35,590 --> 00:13:39,760
ధన్యవాదాలు తప్పుగా ఈ లూప్ చేయండి.

224
00:13:39,760 --> 00:13:42,960
నేను వెర్షన్ 1 ప్రత్యామ్నాయంగా ఈ ప్రతిపాదించారు

225
00:13:42,960 --> 00:13:47,050
అది బహుశా కనీసం కొంత స్పష్టమైన ఎందుకంటే, అది కొంచెం ఇంగ్లీష్ లో స్థాపితమైన ఉంది.

226
00:13:47,050 --> 00:13:51,980
ధన్యవాదాలు తప్పుగా మీరు ధన్యవాదాలు లేదు లేదా అందువలన ఈ క్రింది వాటిని.

227
00:13:51,980 --> 00:13:56,220
మరియు ఈ సమయంలో చాలా నేను స్పష్టంగా యూజర్ టైప్ గుర్తు అవసరం నాకు లేదు

228
00:13:56,220 --> 00:14:00,050
ప్రకటన ఎందుకంటే అక్కడ ఏ వేరియబుల్ n, కాబట్టి నిజంగా, ఒక చిన్న తెల్లని అబద్ధం లేదు.

229
00:14:00,050 --> 00:14:03,290
>> మేము అది దిగువ ను ఒకసారి ప్రయోజనాత్మకంగా, ప్రోగ్రామ్ భిన్నమైనది

230
00:14:03,290 --> 00:14:04,960
నేను n ఏది గుర్తు లేదు ఎందుకంటే.

231
00:14:04,960 --> 00:14:09,120
కానీ నేను ఇక్కడ ప్రదర్శిస్తారు అనుకున్నారు కూడా మేము GetInt చూసిన కూడా

232
00:14:09,120 --> 00:14:13,780
మరియు ఒక యొక్క కుడి వైపు ఉపయోగిస్తారు GetString ఇప్పటివరకు సైన్ సమానం

233
00:14:13,780 --> 00:14:17,310
కాబట్టి మేము ఖచ్చితంగా అవసరమైన కాని విలువ, సాంకేతికంగా, గుర్తున్నది.

234
00:14:17,310 --> 00:14:20,290
మీరు కేవలం విలువ సేవ్ పట్టించుకోను కారణం ఏదైనా

235
00:14:20,290 --> 00:14:25,540
మీరు, మేము కేవలం GetInt ఈ రాయడం అని గుర్తించలేకపోతే, విలువ తనిఖీ మీరు

236
00:14:25,540 --> 00:14:27,320
ఓపెన్ బ్రాకెట్, దగ్గరగా బ్రాకెట్.

237
00:14:27,320 --> 00:14:30,570
మేము చెప్పడం చేసిన ఆ ఫంక్షన్, ఒక విలువ తిరిగి అన్నారు.

238
00:14:30,570 --> 00:14:32,220
ఇది ఒక పూర్ణాంకానికి మీరు తిరిగి ఇవ్వాలని జరగబోతోంది.

239
00:14:32,220 --> 00:14:34,460
కాబట్టి మీరు మానసికంగా, ఈ రకమైన అనుకుంటే

240
00:14:34,460 --> 00:14:38,190
నేను 99 లో టైప్ చేసినప్పుడు, GetInt, సంఖ్య 99 తిరిగి

241
00:14:38,190 --> 00:14:41,840
అందువలన సంభావితంగా, అది నా కోడ్ వాస్తవానికి ఈ వలె అయితే ఉంది.

242
00:14:41,840 --> 00:14:45,950
99 0 కంటే ఎక్కువ నిజానికి ఉంది కాబట్టి, అప్పుడు ధన్యవాదాలు నిజమైన అవుతుంది,

243
00:14:45,950 --> 00:14:50,810
నేను ఇప్పుడు యామ్ థ్యాంక్ఫుల్ ఎందుకంటే అప్పుడు లైన్ 25 ooh గుర్తిస్తాడు, మేము, పూర్తి చేసిన

244
00:14:50,810 --> 00:14:53,970
మరియు లైన్ 26 లో, మేము కేవలం "సానుకూల పూర్ణాంక ధన్యవాదాలు!" అని

245
00:14:53,970 --> 00:14:55,960
అది జరిగిన ఏ.

246
00:14:55,960 --> 00:14:59,140
ఇప్పుడు మాట్లాడటానికి, ఇక్కడ కొంచెం వాక్యనిర్మాణ చక్కెర చేయండి చూద్దాం.

247
00:14:59,140 --> 00:15:04,670
మేము positive3 ఈ మూడవ మరియు ఆఖరి వేరియంట్ తో ఈ లైన్ 25 శుభ్రం లేదో యొక్క చూసేలా.

248
00:15:04,670 --> 00:15:13,600
>> ఇప్పుడు ఏమి కోడ్ లైన్ మాత్రమే తేడా గమనించండి? >> [విద్యార్థి] 25. >> [మలన్] అవును, 25.

249
00:15:13,600 --> 00:15:17,680
మరియు మేము నిజంగా ఇంకా ఈ ట్రిక్ చూడలేదు చేసిన, కానీ మేము, సోమవారం ఆశ్చర్యార్థకం పాయింట్ చూడండి లేదు

250
00:15:17,680 --> 00:15:21,070
ఇది వాటిని సూచిస్తుంది? >> [విద్యార్థి] Not. >> లేదు లేదా రుణాత్మక.

251
00:15:21,070 --> 00:15:23,510
కాబట్టి బూలియన్ విలువ తీసుకోవటానికి మరియు విలువ కుదుపు.

252
00:15:23,510 --> 00:15:25,810
ట్రూ తప్పుడు అవుతుంది, తప్పుడు నిజమైన అవుతుంది.

253
00:15:25,810 --> 00:15:30,420
ఈ సో, నేను ప్రపోజ్ చేస్తుంది, కోడ్ రాయడం కూడా కొంచెం చూడగానే ఒక మార్గం

254
00:15:30,420 --> 00:15:33,430
నేను ఇప్పటికీ తప్పుడు చేసినందుకు ధన్యవాదాలు ప్రారంభించడం ఎందుకంటే, నేను ఇప్పటికీ, క్రింది వాటిని

255
00:15:33,430 --> 00:15:36,010
సమయం వచ్చినప్పుడు నేను, నిజమైన చేసినందుకు ధన్యవాదాలు సెట్

256
00:15:36,010 --> 00:15:40,880
కానీ ఇప్పుడు మీరు నిజంగా కేవలం మాటల ద్వారా ఎడమ ఈ కోడ్ అనువదిస్తుంది

257
00:15:40,880 --> 00:15:45,630
అయితే (ధన్యవాదాలు!); బ్యాంగ్ లేదా ఆశ్చర్యార్థకం పాయింట్, కాని భావన సూచిస్తుంది కాబట్టి

258
00:15:45,630 --> 00:15:47,580
కాబట్టి ధన్యవాదాలు లేదు, అయితే.

259
00:15:47,580 --> 00:15:49,900
మరలా, మేము పర్ సే ఏ కొత్త భావనలను ప్రవేశపెట్టింది లేదు.

260
00:15:49,900 --> 00:15:53,730
మేము ప్రారంభం ఆడి మేము, తిరిగి Booleans గురించి మాట్లాడారు

261
00:15:53,730 --> 00:15:56,720
కానీ మేము అనేక రకాలుగా మా కోడ్ రాయటం మొదలుపెట్టాలని ఇప్పుడు అర్ధమవుతుంది.

262
00:15:56,720 --> 00:16:01,060
కాబట్టి ముఖ్యంగా pset1 లో మీరు, కొన్ని ప్రోగ్రామ్ను రాయడం మార్గం గుర్తించడానికి పోరాడుతున్న యొక్క విధమైన అయితే

263
00:16:01,060 --> 00:16:04,340
SOLUTIONS ఎన్ని ఉంటుంది ఎందుకంటే అసమానత మీరు లక్ ఉన్నారు ఉంటాయి

264
00:16:04,340 --> 00:16:06,110
మీరు మీద ఇదే.

265
00:16:06,110 --> 00:16:10,500
ఉదాహరణకు, ఈ కార్యక్రమాలను కూడా సరళమైన కేవలం 3. అన్ని కుడి.

266
00:16:10,500 --> 00:16:14,200
ఇప్పుడు సోమవారం మేము తిరిగి విలువలతో ఈ సూచన వదిలి గుర్తు.

267
00:16:14,200 --> 00:16:18,450
కాబట్టి మొదటి సారి మేము ప్రధాన లేదు ప్రోగ్రామ్ రాశారు;

268
00:16:18,450 --> 00:16:22,550
అది కూడా నేను ఇక్కడ రాసిన దాని స్వంత కస్టమ్ లక్షణం ఉంది.

269
00:16:22,550 --> 00:16:26,810
కాబట్టి లైన్ 31 లో 34 ద్వారా నేను ఒక ఘనం ఫంక్షన్ అమలు చేసిన.

270
00:16:26,810 --> 00:16:30,240
ఇది క్లిష్టమైన కాదు. ఇది కేవలం ఒక వ్యక్తి యొక్క ఒక * A * ఈ సందర్భంలో.

271
00:16:30,240 --> 00:16:34,750
కాని దాని గురించి ముఖ్యమైన నేను రూపంలో ఇన్పుట్ తీసుకుని చేస్తున్నాను అని

272
00:16:34,750 --> 00:16:39,180
మరియు నేను * A * ఒక రూపంలో అవుట్పుట్ తిరిగి నేను.

273
00:16:39,180 --> 00:16:43,560
కాబట్టి ఇప్పుడు నేను సామర్థ్యం కలిగి, నేను prinf ఒంటరిగా తో ఉపయోగిస్తారు వంటి,

274
00:16:43,560 --> 00:16:47,240
క్యూబ్ చర్యను కాల్ ఈ ఫంక్షన్ కాల్.

275
00:16:47,240 --> 00:16:51,970
>> మరియు క్యూబ్ ఫంక్షన్ కొన్ని ఇన్పుట్ పడుతుంది, మరియు క్యూబ్ ఫంక్షన్ కొన్ని అవుట్పుట్ తిరిగి.

276
00:16:51,970 --> 00:16:56,960
దీనికి విరుద్ధంగా, printf కేవలం ఏదో చేశారు.

277
00:16:56,960 --> 00:17:00,840
జనాంతికంగా ఒక విలువ తిరిగి అయినప్పటికీ ఇది మేము గురించి ఆలోచించలేదు అని దేన్నీ;

278
00:17:00,840 --> 00:17:03,110
మీరు సాధారణంగా పట్టించుకోరు.

279
00:17:03,110 --> 00:17:06,510
Printf కేవలం ఏదో చేశారు. ఇది స్క్రీన్ కి ముద్రించడం ఒక ప్రభావాలను.

280
00:17:06,510 --> 00:17:11,770
ఇక్కడ దీనికి విరుద్ధంగా, మేము నిజంగా ఏదో చూపించే క్యూబ్ ఫంక్షన్ కలిగి.

281
00:17:11,770 --> 00:17:15,520
కాబట్టి ఈ పరిచయం వారిలో, అది ఒక చాలా సులభంగా ఆలోచన.

282
00:17:15,520 --> 00:17:19,640
కానీ ఇన్పుట్లను అక్కడ మరియు ప్రతిఫలాన్ని తిరిగి పొందడానికి ఈ ఆలోచన తక్కువ తెలిసి వారికి,

283
00:17:19,640 --> 00:17:21,950
యొక్క కేవలం ఏదో సూపర్ సాధారణ ప్రయత్నించండి తెలియజేయండి.

284
00:17:21,950 --> 00:17:25,490
సౌకర్యవంతమైన ఎవరైనా క్లుప్తంగా వేదికపై వస్తోంది?

285
00:17:25,490 --> 00:17:28,040
మీరు మీరు ఒక కెమెరా తో సౌకర్యవంతమైన ఉండాలి. Yeah? సరే.

286
00:17:28,040 --> 00:17:31,240
మీ పేరు ఏమిటి? >> [విద్యార్థి] కెన్. >> కెన్. అన్ని కుడి. కెన్, అప్ న వస్తాయి.

287
00:17:31,240 --> 00:17:35,050
కెన్ ఇక్కడ రకాల ఒక కార్యకలాపంగా అన్నారు.

288
00:17:35,050 --> 00:17:38,720
యొక్క ముందుకు వెళ్లి మనం. యొక్క కొద్దిగా ఫాన్సీ పొందండి లెట్.

289
00:17:38,720 --> 00:17:42,260
మీరు ఎవరిని నీస్. సెంటర్ స్టేజ్ కు స్వాగతం. అన్ని కుడి.

290
00:17:42,260 --> 00:17:46,640
యొక్క ఇక్కడ ఈ బటన్ నొక్కండి లెట్. అన్ని కుడి.

291
00:17:46,640 --> 00:17:49,820
ఇక్కడ మీరు ఒక ఆధునిక సుద్ద బోర్డ్ కలిగి

292
00:17:49,820 --> 00:17:53,470
మరియు నేను, ఉదాహరణకు, ప్రధాన విధి

293
00:17:53,470 --> 00:17:56,460
మరియు నేను నా చేతిలో ఒక ఐప్యాడ్ లేదు.

294
00:17:56,460 --> 00:17:59,710
>> Well, నేను ఆ చెప్పలేను - నేను నిజంగా ఎలా గుర్తు లేదు.

295
00:17:59,710 --> 00:18:02,480
నేను నిజంగా మంచి చేతిరాత లేదు

296
00:18:02,480 --> 00:18:05,520
కాబట్టి నేను మీరు నాకు తెరపై ఏదో ప్రింట్ మీరు.

297
00:18:05,520 --> 00:18:12,040
నేను ప్రధాన ప్రోగ్రామ్, నేను నా ఈ చెప్పించావలసి వెళుతున్న

298
00:18:12,040 --> 00:18:16,720
నా కోడి మొదటి దానిని రాయడం మరియు మీరు ఒక ఇన్పుట్ ప్రసరించటం ద్వారా.

299
00:18:16,720 --> 00:18:20,400
ఈ వ్యాయామం అయినప్పటికీ కాబట్టి వెర్రి, ఫంక్షన్స్ భావన మరియు ఒక చర్యను కాల్

300
00:18:20,400 --> 00:18:22,400
మరియు ఈ ఒక ఫంక్షన్ నిజంగా దిమ్మల డౌన్ వచ్చారు.

301
00:18:22,400 --> 00:18:26,260
నేను ప్రధాన am, నేను, తెరపై printf, కోట్-unquote ఏదో వ్రాశారు

302
00:18:26,260 --> 00:18:29,110
నేను, ఈ కార్యక్రమాన్ని నిర్వహించే am, మరియు వెంటనే printf అని చెపుతాడు

303
00:18:29,110 --> 00:18:32,880
అది ఒక వాదన లేదా డబుల్ కోట్స్ మధ్య కొన్నిసార్లు ఒక పారామితి పడుతుంది.

304
00:18:32,880 --> 00:18:35,880
ఇక్కడ ఆ వాదన ఉంది. నేను కెన్ దానిని ప్రయాణిస్తున్న నేను.

305
00:18:35,880 --> 00:18:39,020
అతను సంవత్సరాల కొన్ని సంఖ్య క్రితం రాసిన ఒక బ్లాక్ బాక్స్

306
00:18:39,020 --> 00:18:41,510
ఆ స్పష్టంగా మాత్రమే తెరపై విషయాలు ప్రింట్ ఎలా తెలుసు.

307
00:18:41,510 --> 00:18:43,150
కాబట్టి అమలు.

308
00:18:49,280 --> 00:18:51,280
ఆ చెడు కాదు. చాలా మంచి.

309
00:18:51,280 --> 00:18:55,510
కాబట్టి ఇప్పుడు కెన్ అమలు చేయబడుతుంది. నాకు ఏదైనా తిరిగి చేతితో మార్చాలి?

310
00:18:55,510 --> 00:18:57,470
మేము ఇప్పటివరకు చూసిన కాదు.

311
00:18:57,470 --> 00:19:00,460
మళ్లీ, printf వాస్తవానికి అనేక తిరిగి, కానీ మేము ఇప్పుడు ఆ విస్మరించండి చూడాలని

312
00:19:00,460 --> 00:19:03,470
మేము ఉపయోగించారు ఎప్పుడూ చేసిన ఎందుకంటే. కాబట్టి కెన్ కోసం ఆ.

313
00:19:03,470 --> 00:19:08,580
కాబట్టి ఇప్పుడు ప్రధాన మళ్లీ ప్రోగ్రామ్ యొక్క నియంత్రణ పైగా పడుతుంది

314
00:19:08,580 --> 00:19:11,060
కోడ్ యొక్క లైనును, printf, అమలు జరుగుతుంది ఎందుకంటే.

315
00:19:11,060 --> 00:19:14,050
మరియు మేము మార్గాలు ఉన్నాయి ఏ అమలు, మా మార్గం గురించి వెళ్ళండి.

316
00:19:14,050 --> 00:19:17,320
కాబట్టి ఇప్పుడు యొక్క స్వల్పంగా ఉదాహరణ ప్రయత్నించండి తెలియజేయండి.

317
00:19:17,320 --> 00:19:24,940
ఈ సమయంలో ఇక్కడ యొక్క మొదటి స్క్రీన్ క్లియర్ వివరించారు, ఈ సమయంలో మేము, cubing ఫంక్షన్ చేస్తాను

318
00:19:24,940 --> 00:19:27,080
కానీ ఈ సమయంలో, నేను ఒక అవుట్పుట్ విలువ అంచనా.

319
00:19:27,080 --> 00:19:29,180
>> కాబట్టి యొక్క ముందుకు వెళ్లి మనం.

320
00:19:29,180 --> 00:19:35,790
ఇప్పుడు నేను x x యొక్క క్యూబ్ గెట్స్ అని కోడ్ ఒక లైన్ ఉంది.

321
00:19:41,370 --> 00:19:46,370
కోడ్ లైన్, రీకాల్, ఈ కనిపిస్తోంది: x = ఘనం (x);

322
00:19:46,370 --> 00:19:50,930
కాబట్టి ఎలా ఈ పని అన్నారు? యొక్క ముందుకు వెళ్లి మళ్లీ మిమ్మల్ని తెల్లవాడు స్క్రీన్ కల్పించడానికి అనుమతిస్తాయి.

323
00:19:50,930 --> 00:19:54,070
నేను, ఇప్పుడు x విలువ వ్రాసి నేను

324
00:19:54,070 --> 00:20:01,400
సమయం లో ఈ సమయంలో నిర్మాణము ఇది, ఇది సాధారణ ఉంచడానికి, చెప్పాలి 2 తెలియజేయండి.

325
00:20:01,400 --> 00:20:06,150
నేను కాగితంపై నా విలువ x ఇది 2 యొక్క విలువ, క్రిందికి వ్రాశారు.

326
00:20:06,150 --> 00:20:10,920
నేను కెన్ దానిని చేతితో. >> నేను సమాధానం వ్రాయండి? >> అవును, యొక్క సమాధానం వ్రాయుటకు అనుమతి.

327
00:20:12,760 --> 00:20:18,940
సరే. ఇప్పుడు అతను నాకు ఏదో తిరిగి ఉంటుంది. పర్ఫెక్ట్. Segue నీస్.

328
00:20:18,940 --> 00:20:23,120
కాబట్టి ఇప్పుడు ఈ కేసులో 8 విలువ నాకు తిరిగి అందిస్తుంది, మరియు నేను దానిని ఏమి చేస్తారు?

329
00:20:23,120 --> 00:20:28,250
అసలైన - ఈ సాధించడం, యొక్క చూసేలా. నేను అది ఏమి నేను?

330
00:20:28,250 --> 00:20:33,440
ఇప్పుడు నేను ఈ విలువ తీసుకొని నిజానికి మెమరీ లో ఆ అదే బిట్స్ లో నిల్వ వెళుతున్న.

331
00:20:33,440 --> 00:20:35,170
కానీ నేను ఇక్కడ పోరాడుతున్న రకం ఉన్నాను గమనిస్తారు.

332
00:20:35,170 --> 00:20:38,210
నేను ఎక్కడ వాస్తవానికి x విలువ రాయడానికి ఎందుకంటే నేను, కొద్దిగా తికమక ఉన్నాను

333
00:20:38,210 --> 00:20:43,150
నేను కేవలం చేసిన భౌతికంగా చేతి కెన్ విలువ 2 కలిగి కాగితంపై, ఎందుకంటే

334
00:20:43,150 --> 00:20:46,590
ఇది x, మరియు నిజానికి ఆ ఏమి ఖచ్చితంగా ఉంది.

335
00:20:46,590 --> 00:20:50,210
కాబట్టి మీరు ఫంక్షన్ కాల్ మరియు మీరు వాదన లో ప్రయాణించిన అవుతుంది

336
00:20:50,210 --> 00:20:53,290
హలో మాదిరిగా ప్రపంచ లేదా మీరు, 2 వంటి ఒక వాదన లో పాస్

337
00:20:53,290 --> 00:20:57,110
సాధారణంగా, మీరు ఆ వాదన కాపీని అక్కడ చేస్తున్నారు.

338
00:20:57,110 --> 00:21:00,730
కాబట్టి నేను ఇక్కడ సంఖ్య 2 రాశాడు మరియు కెన్ అందచేసి కేవలం

339
00:21:00,730 --> 00:21:04,720
ఆ నేను ఇప్పటికీ ఎక్కడో విలువ 2 యొక్క ఒక కాపీ అని ఉండాలి

340
00:21:04,720 --> 00:21:08,890
నిజానికి, ఇప్పుడు నేను విలువ 8 చెవిలో చేసిన, నేను RAM తిరిగి వెళ్లవలసిన అవసరం ఎందుకంటే

341
00:21:08,890 --> 00:21:12,130
నేను ఒకసారి సంఖ్య 2 ఉండడం మరియు నిజంగా 8 వ్రాసి.

342
00:21:12,130 --> 00:21:16,950
కాబట్టి దృశ్యపరంగా, వాచ్యంగా, విలువ యొక్క ఒక కాపీని తరలింపు ఈ భావన గుర్తుంచుకోవాలి.

343
00:21:16,950 --> 00:21:20,780
>> ఈ కేసులో 8 వంటి విలువ - - కెన్ తన విషయం, తిరిగి ఏదో నాకు చేతులు చేస్తుంది

344
00:21:20,780 --> 00:21:24,980
నేను చుట్టూ ఉంచడానికి కావాలా అప్పుడు నేను ఆ విలువ ఏదో చేయాలి.

345
00:21:24,980 --> 00:21:29,650
కాబట్టి ఈ అన్ని దీర్ఘ ముందు అన్ని చాలా అవగాహన మళ్ళీ వస్తుంది.

346
00:21:29,650 --> 00:21:34,920
ఇక్కడ ఈ డెమో చాలా కెన్ ధన్యవాదాలు. [చప్పట్లు]

347
00:21:34,920 --> 00:21:36,920
చాలా చక్కగా చేసారు.

348
00:21:36,920 --> 00:21:42,690
చివరికి మేము ఇక్కడ చేస్తున్న చేసిన కాల్ ఫంక్షన్ కొన్ని సంబంధించి ఎంత చూద్దాం.

349
00:21:42,690 --> 00:21:47,910
నాకు ముందుకు వెళ్లి ఇక్కడ cubing ఉదాహరణ మాకు బాగు లెట్.

350
00:21:47,910 --> 00:21:53,300
గమనికను మేము నిజానికి ఈ మరింత ఆరంభిస్తాయి అనుకుంటే ఆ,

351
00:21:53,300 --> 00:21:57,570
మేము సంఖ్య x ఇక్కడ జారీ చేయబడిన ఆ వాస్తవం గురించి జాగ్రత్త వహించండి కు చూడాలని

352
00:21:57,570 --> 00:22:01,530
నిజానికి కు జారీ చేయబడిన వాటిని భిన్నంగా ఉంటుంది.

353
00:22:01,530 --> 00:22:05,880
మరలా, కాపీ ద్వారా ఈ పాస్ ఒక్క నిమిషం లో చాలా సంబంధించి మారింది అన్నారు.

354
00:22:05,880 --> 00:22:09,580
యొక్క సరైన ఇంకా పనిచేయని ఏదో పరిశీలించి చూద్దాం.

355
00:22:09,580 --> 00:22:13,250
నేను, ముందుకు వెళ్ళి, ప్రకృతి ద్వారా పొరపాట్లు ఒక మూడవ బగ్గీ ఉదాహరణకు, తెరిచి వెళుతున్న

356
00:22:13,250 --> 00:22:18,550
మరియు అది buggy3 అని మరియు అది ఒక ఇచ్చిపుచ్చుకోవడంతో ఫంక్షన్ అమలు ఉంది.

357
00:22:18,550 --> 00:22:25,110
ఇక్కడ మేము x మరియు y ఏకపక్ష వరుసగా 1, 2 నుండి initialized ఒక ప్రధాన చర్య.

358
00:22:25,110 --> 00:22:27,700
, మేము GetInt వాడవచ్చు కానీ మేము కేవలం వ్యాయామం అవసరం

359
00:22:27,700 --> 00:22:30,170
కాబట్టి ఇది 1 మరియు 2 వంటి హార్డ్ కోడెడ్ ఉంది.

360
00:22:30,170 --> 00:22:35,340
పంక్తులు 21 మరియు 22, మేము స్పష్టంగా x మరియు y, పంక్తికి 1 ప్రింట్.

361
00:22:35,340 --> 00:22:39,720
అప్పుడు లైన్ 23 న, నేను, డాట్, డాట్, డాట్ ఈ విలువలు ఇచ్చిపుచ్చుకోవడంతో am పేర్కొన్నారు.

362
00:22:39,720 --> 00:22:44,170
నేను స్పష్టంగా లైన్ లో ఒక ఫంక్షన్ 2 వాదనలు కనిపించే 24 పిలువబడే swap కాల్.

363
00:22:44,170 --> 00:22:48,300
విధులు 2 వాదనలు కావడానికి ఇది పూర్తిగా నమ్మకమైన యొక్క. మేము printf ఇప్పటికే అది చూసిన.

364
00:22:48,300 --> 00:22:51,830
>> కాబట్టి, swap స్పష్టంగా x మరియు y ను తీసుకుంటుంది మరియు దాని పేరు సూచించిన విధంగా

365
00:22:51,830 --> 00:22:54,670
నేను ఈ 2 విలువలు స్వాప్ వెళుతున్న భావిస్తున్నాము చేస్తుంది.

366
00:22:54,670 --> 00:23:00,090
కాబట్టి అప్పుడు నేను 25 "మార్చుకున్నారు!" లైన్ పై దావా మరియు నేను x మరియు y రీప్రింట్

367
00:23:00,090 --> 00:23:03,070
ఇవి నిజానికి మార్చుకున్నారు చేసిన ఆ భావన కింద.

368
00:23:03,070 --> 00:23:06,080
కానీ నిజానికి ఈ కార్యక్రమం అమలు చేస్తే - నాకు టెర్మినల్ విండో తెరుచుకుంటుంది తెలియజేయండి

369
00:23:06,080 --> 00:23:09,860
నాకు buggy3 తయారు చేద్దాము - పేరు సూచించినట్లు, ఈ అదే ముగించడానికి వెళ్ళడం లేదు

370
00:23:09,860 --> 00:23:15,770
నేను, Enter x 1 అని గమనించి కొట్టాడు, y, 2 ఎందుకంటే

371
00:23:15,770 --> 00:23:19,420
మరియు ఇంకా కార్యక్రమం చివరిలో, వారు నిజానికి, ఇప్పటికీ ఒకటే.

372
00:23:19,420 --> 00:23:22,960
కాబట్టి ఇప్పుడు కెన్ తో, ఏ వాస్తవానికి జరగబోతోంది ప్రదర్శన ఆధారంగా?

373
00:23:22,960 --> 00:23:28,710
ఈ swap ఫంక్షన్ ప్రవేశిస్తాడు యొక్క లెట్. ఇది చిన్న సూపర్ ఉంది. ఇది మాత్రమే దీర్ఘ కోడ్ యొక్క కొన్ని పంక్తులు ఉంది.

374
00:23:28,710 --> 00:23:34,520
కానీ కెన్ తో ఇక్కడ చెప్పారు సాధారణ కథ ఆధారంగా ప్రాథమిక సమస్య ఏమిటి?

375
00:23:34,520 --> 00:23:36,670
ఎందుకు swap విభజించబడింది?

376
00:23:36,670 --> 00:23:39,660
[విద్యార్థి] మీరు కాపీని, కాని వేరియబుల్ కు నిల్వ చేస్తున్నారు.

377
00:23:39,660 --> 00:23:43,980
సరిగ్గా. మేము వేరియబుల్, ఒక కాపీని కూడా లేదు నిల్వ చేస్తున్నారు.

378
00:23:43,980 --> 00:23:47,170
ఇతర మాటలలో, swap స్పష్టంగా 2 వాదనలు, ఒక Int, పడుతుంది

379
00:23:47,170 --> 00:23:49,370
మరియు కక్ష్య, a మరియు b అని

380
00:23:49,370 --> 00:23:54,420
మరియు ఇక్కడ నేను వరుసగా 1 మరియు 2 ఇవి x మరియు y, జారీ చేసిన

381
00:23:54,420 --> 00:23:58,770
కానీ నేను అక్షరాలా x అక్కడ లేదు, నేను అక్షరాలా, Y అక్కడ లేదు

382
00:23:58,770 --> 00:24:01,450
నేను x యొక్క ఒక కాపీని మరియు y యొక్క ఒక కాపీని ప్రయాణిస్తున్న నేను.

383
00:24:01,450 --> 00:24:04,510
ఇది దాదాపు అయితే మీరు కాపీ మరియు స్వాప్ లో అతికించబడింది యొక్క

384
00:24:04,510 --> 00:24:07,810
మీరు నిజంగా సవరించడానికి కావలసిన విలువలు.

385
00:24:07,810 --> 00:24:14,480
ఆ సందర్భంలో, నేను ప్రోగ్రామ్ ప్రారంభం లైన్ అమలు చేసినప్పుడు 35 తర్వాత 36, కాబట్టి ఉంటే

386
00:24:14,480 --> 00:24:18,650
నేను కథ ఈ సమయంలో, లైన్ 37 వచ్చినప్పుడు, ఏది యొక్క విలువ?

387
00:24:21,040 --> 00:24:25,050
కథలో ఈ సమయంలో, లైన్ 37, ఈ సమయంలో ఒక విలువ ఏమిటి? >> [విద్యార్థి] 1.

388
00:24:25,050 --> 00:24:29,280
[మలన్] x మొదటి వాదన వంటి జారీ ఎందుకంటే అది కుడి, 1 ఉండాలి,

389
00:24:29,280 --> 00:24:33,080
మరియు ఈ చర్య కేవలం ఏకపక్ష మొదటి వాదన ఒక కాల్.

390
00:24:33,080 --> 00:24:38,200
అదేవిధంగా రెండవ వాదన Y మరియు ఇది కేవలం ఏకపక్ష రెండవ వాదన బి కాలింగ్ యొక్క.

391
00:24:38,200 --> 00:24:40,990
>> ఈ వైరుధ్యాన్ని వాస్తవానికి చాలా సరళంగా వివరించారు. దాని గురించి ఆలోచించండి.

392
00:24:40,990 --> 00:24:43,320
మాకు ఎవరూ, printf రాసిన వ్యక్తి వచ్చాయి

393
00:24:43,320 --> 00:24:50,770
కాబట్టి ఖచ్చితంగా, అతను లేదా ఆమె మా వేరియబుల్స్ 30 సంవత్సరాల తరువాత పిలుస్తారు ఎంత తెలియదు.

394
00:24:50,770 --> 00:24:56,650
కాబట్టి మీరు రాస్తున్నాం విధులు లో వేరియబుల్స్ కాల్ ఏమి మధ్య వ్యత్యాసం ఉండాలి

395
00:24:56,650 --> 00:25:02,080
మరియు మీరు కాల్ లేదా ఉపయోగించే విధులు లో వేరియబుల్స్ కాల్ ఏమి.

396
00:25:02,080 --> 00:25:05,340
కాబట్టి ఇతర మాటలలో, నేను, x మరియు y నా వేరియబుల్స్ వ్రాశారు

397
00:25:05,340 --> 00:25:08,890
ఎవరో swap ఫంక్షన్ రాసిన అయితే, అతను లేదా ఆమె ఖచ్చితంగా తెలియదు

398
00:25:08,890 --> 00:25:10,690
నా వేరియబుల్స్, అని ఎంత

399
00:25:10,690 --> 00:25:13,830
కాబట్టి మీరు పేర్లు ఈ ప్రవృత్తిగల ఎందుకు ఈ అని అర్ధమవుతుంది.

400
00:25:13,830 --> 00:25:16,750
సాంకేతికంగా, నేను, యాదృచ్ఛికంగానో ఈ చేయగల

401
00:25:16,750 --> 00:25:20,080
కానీ వారు ఇప్పటికీ కాపీలు గా సంక్రమిస్తుంది.

402
00:25:20,080 --> 00:25:23,650
ఇది కేవలం పూర్తిగా యాదృచ్చికం ఉంటుంది అందమైన ఉంటే swap రాసిన వ్యక్తి

403
00:25:23,650 --> 00:25:26,150
అదే పేర్లు ఉపయోగించాడు.

404
00:25:26,150 --> 00:25:32,370
కాబట్టి కథ ఈ సమయంలో, లైన్ 37, ఒక 1, బి 2, మరియు ఇప్పుడు నేను వాటిని మార్పిడి కొనసాగండి.

405
00:25:32,370 --> 00:25:34,900
అన్ని మొదటి, నాకు నిజంగా చాలా సరళంగా మనం.

406
00:25:34,900 --> 00:25:36,690
నేను కోడ్ ఆ 3 లైన్లు ఏమి తెలియదు.

407
00:25:36,690 --> 00:25:41,210
నాకు కేవలం మనం: బి = ఒక; a = b; పూర్తయింది.

408
00:25:41,210 --> 00:25:44,690
ఎందుకు ఈ తార్కికంగా, బ్రోకెన్ ఉంది?

409
00:25:46,490 --> 00:25:48,900
ఇది కుడి, సహజమైన విషయం రకంగా?

410
00:25:48,900 --> 00:25:52,560
ఒక మారుతుంది అవుతుంది బి అండ్ బి సో

411
00:25:52,560 --> 00:25:57,730
కానీ సమస్య లైన్ 37 అమలు వెంటనే, ఒక మరియు బి విలువ ఏమిటి అని?

412
00:25:57,730 --> 00:26:03,410
మీరు clobbered ఎందుకంటే 1, అదే, మాట్లాడటానికి, మీరు ఒక సమం బి మార్చారు.

413
00:26:03,410 --> 00:26:08,890
కాబట్టి ఒకసారి లైన్ 37 అమలు చేసింది, ఆ గొప్ప, మీరు ఇప్పుడు సంఖ్య 1 యొక్క 2 కాపీలు ఉన్నాయి

414
00:26:08,890 --> 00:26:13,350
ఈ చర్యను లోపల, మీరు లైన్ 38 లో చెప్పిన కాబట్టి అప్పుడు a = b,

415
00:26:13,350 --> 00:26:17,640
మీరు 1 నుండి 1 కేటాయించి ఎందుకంటే మీరు రకమైన చిత్తు చేశాడు చేస్తున్నారు.

416
00:26:17,640 --> 00:26:20,580
మీరు రకమైన మీరు గురించి ఆలోచించలేదు విలువ కోల్పోయి.

417
00:26:20,580 --> 00:26:23,220
కాబట్టి ఈ యొక్క యదార్థ సంస్కరణలో, నేను ఏమి గమనిస్తారు.

418
00:26:23,220 --> 00:26:26,850
నేను బదులుగా ఈ అని కోడ్ యొక్క మూడవ పంక్తి ఉంది.

419
00:26:26,850 --> 00:26:28,580
నేను ఒక తాత్కాలిక వేరియబుల్ ప్రకటిస్తాయి.

420
00:26:28,580 --> 00:26:32,170
>> Tmp తాత్కాలిక వేరియబుల్ కోసం ఒక సాధారణ పేరు, మరియు అది ఒక పూర్ణాంకానికి యొక్క

421
00:26:32,170 --> 00:26:34,580
నేను యొక్క నకలును చేయడానికి ఏమి మ్యాచ్ ఉంటుంది ఎందుకంటే.

422
00:26:34,580 --> 00:26:39,770
లైన్ 37 అమలు చేసింది కాబట్టి ఒకసారి నేను, tmp ఒక లోపల నకలు నిల్వ

423
00:26:39,770 --> 00:26:45,860
ఒక యొక్క విలువ - శీఘ్ర తెలివి చెక్ - 1, బి విలువ, 2

424
00:26:45,860 --> 00:26:48,970
మరియు tmp విలువ కూడా 1.

425
00:26:48,970 --> 00:26:52,060
కాబట్టి ఇప్పుడు నేను లైన్ 38 అమలు.

426
00:26:52,060 --> 00:27:00,540
లైన్ 38 అమలు ఒకసారి, ఒక బి విలువ తీసుకుంటుంది. అండ్ బి 2, అందువలన ఒక ఇప్పుడు 2.

427
00:27:00,540 --> 00:27:05,210
కాబట్టి కథ ఈ సమయంలో, ఒక 2, బి 2, మరియు tmp 1

428
00:27:05,210 --> 00:27:11,060
కాబట్టి ఇప్పుడు తార్కికంగా, మేము బి లోకి కేవలం plop tmp యొక్క విలువ మరియు మేము పూర్తి చేసిన.

429
00:27:11,060 --> 00:27:12,800
కాబట్టి మేము ఆ సమస్యను పరిష్కరించింది చేసిన.

430
00:27:12,800 --> 00:27:17,720
దురదృష్టవశాత్తు, నేను ఈ రూపంలో ఈ అమలు చేసేటప్పుడు, నిజానికి ఏ విలువలు స్వాప్ లేదు.

431
00:27:17,720 --> 00:27:20,100
కానీ, ఎందుకు స్పష్టంగా ఉండాలి?

432
00:27:23,660 --> 00:27:26,450
నేను, ఒక్క నిమిషం క్రితం నుండి తార్కిక సమస్య పరిష్కరించబడింది

433
00:27:26,450 --> 00:27:31,020
నేను ఈ కార్యక్రమం అమలు చేస్తే కానీ మళ్లీ, x మరియు y మారదు

434
00:27:31,020 --> 00:27:33,310
కార్యక్రమం యొక్క అమలు చివరికి.

435
00:27:33,310 --> 00:27:37,220
[వినబడని విద్యార్థి వ్యాఖ్య] >> మేము ఏదైనా తిరిగి లేదు, నిజం కాబట్టి.

436
00:27:37,220 --> 00:27:39,670
ఎందుకంటే ఇప్పటివరకు సమస్య ఒక బిట్ ఇక్కడ ఉంది అవుట్ కానీ మారుతుంది

437
00:27:39,670 --> 00:27:44,170
మేము తిరిగి చేయగలిగారు చేసిన మాత్రమే విషయం విషయం, మరియు ఈ C. యొక్క పరిమితి ఉంది

438
00:27:44,170 --> 00:27:49,070
నేను రకమైన ఇక్కడ కష్టం ఉన్నాను కేసు దీనిలో మీరు, నిజంగా ఒక విలువ తిరిగి

439
00:27:49,070 --> 00:27:53,310
నేను x యొక్క కొత్త విలువ తిరిగి లేదా ఎందుకంటే నేను, Y యొక్క కొత్త విలువ తిరిగి విధుల్లో

440
00:27:53,310 --> 00:27:55,190
కానీ నేను రెండు తిరిగి కావలసిన.

441
00:27:55,190 --> 00:27:58,650
చాలా సింపుల్ పరిష్కారం ఇక్కడ లేదు వచ్చారు.

442
00:27:58,650 --> 00:28:01,710
కానీ సమస్య మౌలికంగా ఎందుకు? మేము నిజంగా ఏమి మార్చుకున్నారు చేశారు?

443
00:28:01,710 --> 00:28:04,190
[విద్యార్థి] ఒక అండ్ బి. >> ఒక అండ్ బి.

444
00:28:04,190 --> 00:28:08,230
కానీ అండ్ బి మేము ఈ కృతి యొక్క అన్ని చేసాడు అంటే x మరియు y, యొక్క నకళ్ళు

445
00:28:08,230 --> 00:28:11,650
మేము, swap ఫంక్షన్ మరియు అంశాలపై అన్ని 3 గురించి మాట్లాడుతూ 3 నిముషాలు ఖర్చు

446
00:28:11,650 --> 00:28:15,420
మరియు ఆ, ఒంటరిగా ఖచ్చితంగా సరైన, గొప్ప పని

447
00:28:15,420 --> 00:28:20,740
కానీ ఒక అండ్ బి యొక్క పరిధిని మాత్రమే ఇక్కడ ఈ పంక్తులు ఉంది.

448
00:28:20,740 --> 00:28:24,790
>> కాబట్టి కేవలం, లూప్ ఒక మీకు నేను, లూప్ లోపల పూర్ణాంకం డిక్లేర్ ఉంటే

449
00:28:24,790 --> 00:28:28,760
అదేవిధంగా, మీరు వ్రాసిన చేసిన ఒక చర్య యొక్క ఒక అండ్ బి లోపల ప్రకటించారు చేస్తుంటే,

450
00:28:28,760 --> 00:28:33,320
ఆ ఫంక్షన్ యొక్క మాత్రమే చెల్లుబాటు అయ్యే లోపల ఉన్నారు, ఇది వెంటనే అమలు swap చేయబడుతుంది వంటి అర్థం

451
00:28:33,320 --> 00:28:38,470
మరియు మేము లైన్ 25 పంక్తి 24 నుండి వెళ్లి, x మరియు y అన్ని వద్ద మార్చబడలేదు.

452
00:28:38,470 --> 00:28:42,790
మీరు వేరియబుల్స్ యొక్క కాపీలు ఇచ్చిపుచ్చుకోవడంతో సమయం మొత్తం చాలా వృధా.

453
00:28:42,790 --> 00:28:47,010
కాబట్టి ఈ పరిష్కారం వాస్తవానికి కాని స్పష్టమైన అని అవుతుంది.

454
00:28:47,010 --> 00:28:50,670
మేము మాత్రమే 1 విలువ తిరిగి ఎందుకంటే ఇది విలువలు తిరిగి పూర్తిగా సరిపోతాయి కాదు

455
00:28:50,670 --> 00:28:53,470
మరియు నేను నిజంగా, అదే సమయంలో x మరియు y రెండు స్వాప్ అనుకుంటున్నారు

456
00:28:53,470 --> 00:28:55,210
కాబట్టి మేము ఈ కి తిరిగి రావాలని చూడాలని.

457
00:28:55,210 --> 00:29:01,020
కానీ ఇప్పుడు కోసం, సమస్యను ప్రాథమికంగా ఒక అండ్ బి కాపీలు వాస్తవం నుండి గుర్తించలేరు

458
00:29:01,020 --> 00:29:03,630
మరియు వారు తమ సొంత పరిధిలో ఉంటాయి.

459
00:29:03,630 --> 00:29:05,050
యొక్క కొన్ని విధంగా ఈ పరిష్కరించడానికి ప్రయత్నించండి లెట్.

460
00:29:05,050 --> 00:29:11,250
యొక్క, ఈ యొక్క నాల్గవ రకం, buggy4 అని పిలవబడు, నాకు నిజంగా ఇక్కడ మళ్లీ స్క్రోల్ లెట్ మరియు తెరవండి.

461
00:29:11,250 --> 00:29:13,370
ఈ గురించి?

462
00:29:13,370 --> 00:29:17,810
ఈ మేము దీనిని సాధించే ఒక ఉదంతం పడుతుంది ముందు కు ఇదే కాని సులభమైన సమస్య.

463
00:29:17,810 --> 00:29:24,190
ఈ కార్యక్రమం పెంపు అంటారు స్పష్టంగా లైన్ 18 లో 1 నుంచి ఒక x పూర్ణాంక initializes ఉంది.

464
00:29:24,190 --> 00:29:28,150
నేను అప్పుడు x 1 దావా, నేను "పెంచడం ..." దావా

465
00:29:28,150 --> 00:29:33,730
నేను అప్పుడు పెంపు పిలుస్తాము, కానీ అప్పుడు పంక్తులు 22 మరియు 23 లో, నేను పెరిగిన చెయ్యబడిన దావా

466
00:29:33,730 --> 00:29:40,220
2, బహుశా - - నేను x ఇది ఏమైనా ఇప్పుడు దావా కాని ఈ కార్యక్రమం బగ్గీ ఉంది.

467
00:29:40,220 --> 00:29:42,610
సమస్య ఏమిటి?

468
00:29:43,440 --> 00:29:50,160
అవును. >> [వినబడని విద్యార్థి ప్రతిస్పందన] >> ఖచ్చితంగా.

469
00:29:50,160 --> 00:29:52,490
కాబట్టి x లైన్ 18 న, సహజంగా, ప్రకటించబడింది.

470
00:29:52,490 --> 00:29:54,700
ప్రధాన యొక్క వంకర జంట కలుపులు లోపల ఉంది.

471
00:29:54,700 --> 00:29:58,440
ఇక్కడ సాధారణ సమాధానం, x ఇక్కడ ఉంది, అయితే ఆ

472
00:29:58,440 --> 00:30:03,930
ఇది పంక్తి 32 లేదు, ఈ కార్యక్రమం నిజానికి కూడా కంపైల్ అందువల్ల.

473
00:30:03,930 --> 00:30:07,940
నేను ఈ కోడ్ కంపైల్ ప్రయత్నించండి కంపైలర్ నాకు అరుస్తుంటారు అన్నారు

474
00:30:07,940 --> 00:30:14,100
కొన్ని ప్రకటించనివారు ఐడెంటిఫైయర్ లేదా ప్రభావంతో గురించి. నిజానికి, యొక్క ప్రయత్నించండి తెలియజేయండి.

475
00:30:14,100 --> 00:30:18,470
ఈ buggy4 తయారు ఉంది. అక్కడ ఇది.

476
00:30:18,470 --> 00:30:22,110
లైన్ 32 లో ప్రకటించనివారు ఐడెంటిఫైయర్ 'x' యొక్క ఉపయోగించండి.

477
00:30:22,110 --> 00:30:25,580
మరియు వాస్తవానికి, ఈ ఉపయోగపడుతుంది కనుక యొక్క ఇక్కడ నేడు మరింత స్పష్టమైన లెట్

478
00:30:25,580 --> 00:30:27,580
ఆఫీస్ అవర్స్ లో మరియు ఇంటిలో.

479
00:30:27,580 --> 00:30:29,300
>> అది cryptically రాసిన లిటిల్ గమనించాలి.

480
00:30:29,300 --> 00:30:37,270
కానీ గణగణమని ద్వని చేయు వాస్తవం buggy4.c మాట్లాడుతూ, మాకు కోప్పడ్డాడు: 32:5, వాస్తవానికి ఉపయోగపడుతుంది.

481
00:30:37,270 --> 00:30:42,050
ఇది లోపం పాత్ర స్థానం 5 వద్ద లైన్ 32 న అని అర్థం.

482
00:30:42,050 --> 00:30:46,700
కాబట్టి 1, 2, 3, 4, 5. సమస్య అనేది నిజానికి, ఉంది.

483
00:30:46,700 --> 00:30:49,790
మరియు, చాలా, ఆఫీస్ అవర్స్ లో మరియు ఇంటిలో గుర్తుంచుకోండి, నేను ఇక్కడ ఉన్నాను లక్కీ.

484
00:30:49,790 --> 00:30:52,990
నేను ఒక పొరపాటు ఉంది. దాన్ని పరిష్కరించడానికి సులభంగా చేస్తాడు.

485
00:30:52,990 --> 00:30:55,990
కానీ మీరు అధిక దోష సందేశాలు పూర్తి మొత్తం స్క్రీన్ వస్తే,

486
00:30:55,990 --> 00:31:00,330
మళ్ళీ bottommost ఇప్పుడే మిక్కిలి శ్రేష్టమైన ఒక చిహ్నంగా ఉంటుంది అని తెలుసుకోవటం.

487
00:31:00,330 --> 00:31:03,450
కాబట్టి ఎల్లప్పుడు ఎగువ డౌన్ నుండి మీ దోషాలు డౌన్ తరుముతూ

488
00:31:03,450 --> 00:31:05,820
ఒక డైసీ గొలుసు ప్రభావం ఉండవచ్చు ఎందుకంటే

489
00:31:05,820 --> 00:31:09,240
మీరు మీరు నిజంగా కంటే మార్గం మరింత సమస్యలు సూచిస్తూ ఉంటుంది.

490
00:31:09,240 --> 00:31:15,150
నా లక్ష్యం x పెంచడం ఉంటే కాబట్టి మేము ఎలా పరిష్కరించడానికి కాలేదు? >> [విద్యార్థి] x ప్రపంచ చేయండి.

491
00:31:15,150 --> 00:31:17,060
సరే, మేము x ప్రపంచ చేయవచ్చు.

492
00:31:17,060 --> 00:31:20,480
, లెట్ యొక్క నేను ముందు ఎక్కడ సత్వరమార్గం తీసుకుంటారు కానీ హెక్, మేము త్వరగా పరిష్కారం అవసరం

493
00:31:20,480 --> 00:31:25,730
కాబట్టి కేవలం ఇక్కడ Int x సే తెలియజేయండి. ఆ x ప్రపంచ చేస్తుంది.

494
00:31:25,730 --> 00:31:31,800
కాబట్టి ఇప్పుడు ప్రధాన, అది యాక్సెస్ మరియు పెంపు దానిని ప్రాప్తి కలిగి ఉన్నాయి

495
00:31:31,800 --> 00:31:34,110
అందువలన నాకు ముందుకు వెళ్లి ఇప్పుడు ఈ సంకలనం తెలియజేయండి.

496
00:31:34,110 --> 00:31:37,630
Buggy4 చేయండి నమోదు చేయండి. ఇప్పుడు కంపైల్ తెలుస్తోంది.

497
00:31:37,630 --> 00:31:41,230
యొక్క buggy4 అమలు అయ్యేలా అనుమతించండి. మరియు అది నిజానికి పని ఉంది.

498
00:31:41,230 --> 00:31:45,150
ఇది నేను కాదు, నేను చెప్పినట్లు చేయండి చేసే ఈ విషయాలు ఒకటి

499
00:31:45,150 --> 00:31:47,010
నేను ఇక్కడ చేసినట్లుగానే, ఎందుకంటే సాధారణంగా,

500
00:31:47,010 --> 00:31:50,440
మా కార్యక్రమాలు ఈ కంటే ఎక్కువ ఆసక్తికరమైన మరియు చాలా ఎక్కువ సమయం పొందడానికి వెళ్తున్నారు,

501
00:31:50,440 --> 00:31:56,390
మరియు జీవితం యొక్క సమస్యలకు పరిష్కారం మీ మీ ఫైల్ ఎగువన అన్ని విషయాల్లోనూ పెట్టబడింది ఉంటే,

502
00:31:56,390 --> 00:31:59,690
చాలా త్వరగా కార్యక్రమాలు నిర్వహించడానికి భయంకర కష్టం ఎలా.

503
00:31:59,690 --> 00:32:02,190
ఇది కొత్త వేరియబుల్ పేర్లు అప్ ఆలోచించడం కష్టం గెట్స్

504
00:32:02,190 --> 00:32:05,240
ఇది ఏమి ఏమి వేరియబుల్ అర్థం కష్టం గెట్స్

505
00:32:05,240 --> 00:32:08,460
అందువలన సాధారణంగా, ఈ మంచి పరిష్కారం కాదు.

506
00:32:08,460 --> 00:32:10,030
కాబట్టి మంచి దీన్ని చూద్దాం.

507
00:32:10,030 --> 00:32:12,160
మేము ఇక్కడ ఒక ప్రపంచ వేరియబుల్ ఉపయోగించడానికి లేదు.

508
00:32:12,160 --> 00:32:16,240
>> నేను x పెంచడం అనుకుంటున్నారు, నేను ఖచ్చితంగా కాలేదు -

509
00:32:16,240 --> 00:32:18,670
మేము దీన్ని ఎందుకంటే రోజు ముగింపులో, ఈ ఒక వెర్రి కథ రకం -

510
00:32:18,670 --> 00:32:24,450
కానీ నేను ఆ ఆపరేటర్లు అవగాహన లేదు లేదా నేను ప్రధాన కూడా వారు మార్చవచ్చు దొరకకపోతే,

511
00:32:24,450 --> 00:32:30,730
ఎలా else ఈ సమయంలో కాదు క్యూబ్ ఇక్కడ పైగా కెన్ అమలు కాలేదు కానీ పెంచడం?

512
00:32:31,380 --> 00:32:33,190
నేను ఇక్కడ ఈ విషయం మార్చాలి? అవును.

513
00:32:33,190 --> 00:32:38,480
[విద్యార్థి] x లో పాస్ తరువాత తిరిగి [వినబడని] >> సరే, మంచి.

514
00:32:38,480 --> 00:32:41,900
అందుచే నేను, x లో పాస్ మరియు తరువాత కంటే తిరిగి లేదు

515
00:32:41,900 --> 00:32:44,870
ఎందుకు నేను x + 1 తిరిగి చేయడం లేదు.

516
00:32:44,870 --> 00:32:47,710
ఒక జంట మరింత ఇక్కడ మార్చాల్సి ఉంటుంది. నేను ట్రాక్ ఉన్నాను.

517
00:32:47,710 --> 00:32:49,770
నేను ఏమి సర్దుబాటు చేయాలి? వేరొకరు. అవును.

518
00:32:49,770 --> 00:32:51,740
[వినబడని విద్యార్థి ప్రతిస్పందన]

519
00:32:51,740 --> 00:32:54,730
అది రద్దు కాదు నేను పెంపు తిరిగి టైప్ మార్చాలి.

520
00:32:54,730 --> 00:32:57,780
శూన్యం అంటే ఏదీ, తిరిగివచ్చారు, కానీ స్పష్టంగా ఇప్పుడు చెప్పవచ్చు

521
00:32:57,780 --> 00:32:59,830
ఈ అవసరాలను మార్చడానికి - >> [విద్యార్థి] Int.

522
00:32:59,830 --> 00:33:02,740
నిజానికి తిరిగి నేను ఏ అనుగుణంగా ఉన్నట్లు Int.

523
00:33:02,740 --> 00:33:05,180
ఇప్పుడు ఏదో ఇక్కడ ఇప్పటికీ బగ్గీ ఉంది. అవును.

524
00:33:05,180 --> 00:33:08,400
[వినబడని విద్యార్థి ప్రతిస్పందన] >> [మలన్] నేను x పెంచడం అవసరం కాబట్టి?

525
00:33:08,400 --> 00:33:12,080
[వినబడని విద్యార్థి ప్రతిస్పందన] >> [మలన్] ఆహ్, నేను x పాస్ అవసరం.

526
00:33:12,080 --> 00:33:16,660
నేను ఇక్కడ ఈ చేయాలి. >> [వినబడని విద్యార్థి వ్యాఖ్య]

527
00:33:16,660 --> 00:33:20,050
[మలన్] కాబట్టి నమూనా, నేను ఇక్కడ ఈ అప్ మార్చాల్సి ఉంటుంది.

528
00:33:20,050 --> 00:33:22,930
ఈ ఒక పూర్ణాంకానికి మారింది ఉంటుంది కాబట్టి, ఈ మారింది ఉంటుంది -

529
00:33:22,930 --> 00:33:25,620
అయ్యో, నేను నిజానికి ఇక్కడ ఒక బగ్ డౌన్ ఉంటాయి. మొదటి ఈ ఒక పరిష్కరించడానికి లెట్.

530
00:33:25,620 --> 00:33:29,590
ఈ నిజానికి ఉండాలి? ఇది ఒక పూర్ణాంకానికి ఏదో తీరవలసినదే.

531
00:33:29,590 --> 00:33:32,700
మీరు మీ వేరియబుల్స్ x యొక్క మొత్తం అభ్యర్థన ప్రారంభం అది, స్పష్టముగా x, కాని కాలేదు

532
00:33:32,700 --> 00:33:35,390
ఇది ఇది తక్కువ మరియు తక్కువ స్పష్టమైన పొందడానికి జరగబోతోంది.

533
00:33:35,390 --> 00:33:39,560
>> కాబట్టి యొక్క కేవలం ఏకపక్ష నా helper విధులు కోసం వేరొక నామకరణ ఎంచుకోనివ్వండి,

534
00:33:39,560 --> 00:33:41,940
నేను వ్రాసే నేను పనిచేస్తుంది. మేము ఒక పిలుస్తాను, లేదా మేము వాటిని కాల్ కాలేదు -

535
00:33:41,940 --> 00:33:45,010
లెట్ యొక్క మరింత స్పష్టమైన ఉంటుంది ఇది కాల్.

536
00:33:45,010 --> 00:33:47,560
కాబట్టి నేను సంఖ్య ప్లస్ 1, ఉండే వస్తువు తిరిగి కలిగి

537
00:33:47,560 --> 00:33:50,740
మరియు ఇప్పుడు నేను ఇక్కడ మరియు ఇక్కడ ఒక విషయం ఇతర అప్ 1 ఇతర విషయం అప్ మార్చాల్సి ఉంటుంది.

538
00:33:50,740 --> 00:33:54,350
నేను మొదటి లైన్ 21 న మార్చడానికి ఏమి ఉన్నాయి? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

539
00:33:54,350 --> 00:33:57,610
[మలన్] నేను x కు కేటాయించి ఉంటుంది. నేను (x) పెంపు కాల్ చెయ్యలేరు.

540
00:33:57,610 --> 00:34:01,960
నేను ఎడమ చేతి వైపు x విలువ మార్చడం ద్వారా సమాధానం గుర్తుంచుకోవాల్సిన అవసరం.

541
00:34:01,960 --> 00:34:04,680
మరియు x ఇప్పుడు అయినప్పటికీ ఎడమ మరియు కుడి, ఆ పూర్తిగా మంచిది

542
00:34:04,680 --> 00:34:08,860
కుడి వైపు మొదటి అమలు అవుతుంది ఎందుకంటే అప్పుడు ఎడమ చేతి విషయం లోకి plopped వచ్చింది -

543
00:34:08,860 --> 00:34:10,600
ఈ సందర్భంలో x.

544
00:34:10,600 --> 00:34:12,159
మరియు తర్వాత చివరగా, ఈ ఇప్పుడు ఒక సులభమైన పరిష్కారం ఉంది.

545
00:34:12,159 --> 00:34:17,230
ఇది Int సంఖ్య, క్రింద ఏమి డౌన్ 'స్ మ్యాచ్ ఉండాలి.

546
00:34:17,230 --> 00:34:20,570
కాబట్టి నిజంగా తెలివితక్కువదని ఫంక్షన్ కోసం మార్పులు మొత్తం బంచ్

547
00:34:20,570 --> 00:34:24,420
కానీ మేము ఎక్కువగా చేయాలనుకుంటున్నారా మేము విషయాలను ప్రతినిధి.

548
00:34:24,420 --> 00:34:27,090
కాబట్టి buggy4 చేయండి. నేను ఎక్కడో ఇరుక్కొనిపోయింది చేసిన.

549
00:34:27,090 --> 00:34:30,139
ఓహ్, నా దేవుని. 6 లైన్ కార్యక్రమంలో ఐదు తప్పులు.

550
00:34:30,139 --> 00:34:35,690
కాబట్టి పాత్ర లైన్ 18 న ఏమి 5 ఏమిటి?

551
00:34:35,690 --> 00:34:39,610
నేను ఈ, Int ప్రకటించాలని ఉన్నాయి.

552
00:34:39,610 --> 00:34:41,920
యొక్క చూసేలా. ఇతర లోపాల మొత్తం అక్కడ చాలా ఉన్నాయి.

553
00:34:41,920 --> 00:34:47,010
ఓహ్, నా దేవుని - 19, 18, 21 - మళ్ళీ కాని, మనం ఇక్కడ, కంట్రోల్ L స్క్రీన్ క్లియర్ తెలియజేయండి

554
00:34:47,010 --> 00:34:49,380
మరియు గణగణమని ద్వని చేయు తిరిగి.

555
00:34:49,380 --> 00:34:51,340
కాబట్టి 5 సమస్యలు నిజానికి ఆ 1.

556
00:34:51,340 --> 00:34:57,520
కాబట్టి ఇప్పుడు ఎంటర్ యొక్క buggy4 అమలు అనుమతిస్తాయి. Whew, x సరిగ్గా పెరుగుదల ఉంది.

557
00:34:57,520 --> 00:35:02,720
అన్ని కుడి. సంఖ్యలు పెంచడం ఎలా ఏదైనా ప్రశ్నలు? అవును.

558
00:35:02,720 --> 00:35:09,870
[వినబడని విద్యార్థి ప్రశ్న] >> మంచి ప్రశ్న.

559
00:35:09,870 --> 00:35:14,220
అది నేను అనేక x మార్చవచ్చు మరియు ప్రోగ్రామ్ వెంటనే తెలుస్తుంది ఆ ఎలా ఉంది?

560
00:35:14,220 --> 00:35:16,200
>> మళ్ళీ, ఈ ఊహ గా భావిస్తారు.

561
00:35:16,200 --> 00:35:21,600
నేను ప్రధాన am మరియు కెన్ స్పష్టముగా, పెంపు ఉంటే కనుక, నేను కెన్ తన ఐప్యాడ్ పిలిచే పట్టించుకోను.

562
00:35:21,600 --> 00:35:26,570
నేను ఈ కార్యాచరణ యొక్క తన అమలు సంబంధం కలిగి ఉంటుంది, ఆ ఏదైనా పిలిచే పట్టించుకోను.

563
00:35:26,570 --> 00:35:33,340
ఈ నేను, ప్రధాన, పట్టించుకోనట్లు లేని ఒక అమలు వివరాలు ఉంది.

564
00:35:33,340 --> 00:35:38,250
కాబట్టి కేవలం పనితీరు లోపల నిరంతరంగా మారుతున్న - సంఖ్య ఇక్కడ మరియు ఇక్కడ సంఖ్య -

565
00:35:38,250 --> 00:35:40,960
నేను మళ్ళీ కంపైల్ చెయ్యండి చాలాకాలం పాటు పడుతుంది అన్ని ఉంటుంది.

566
00:35:40,960 --> 00:35:44,180
మీరు అనుకుంటే ఇది విధమైన ఇష్టం యొక్క యొక్క డ్రైవర్ లైసెన్సులు మీకు, ఆ మాకు యొక్క గురించి అనేక

567
00:35:44,180 --> 00:35:46,770
మీరు కూడా ఒక కారులో నడిచే ఉంటే, లేదా నిర్వహిస్తాయి

568
00:35:46,770 --> 00:35:50,950
మాకు చాలా ఒక కారు హుడ్ కింద ఎలా పని సంఖ్య ఆలోచన ఉంది.

569
00:35:50,950 --> 00:35:54,970
మీరు హుడ్, మాకు చాలా అప్ తెరిస్తే మరియు వాచ్యంగా, - నాకు ఉంది -

570
00:35:54,970 --> 00:35:56,940
మేము వద్ద చూస్తున్న ఏమి వెళ్ళడం లేదు,

571
00:35:56,940 --> 00:35:59,220
మీరు ఇప్పుడు ఈ కుడి వంటి విషయాలలో అనుభూతి చెందుతాడు వంటి రకం.

572
00:35:59,220 --> 00:36:01,480
కానీ మేము నిజంగా, కారు ఎలా పనిచేస్తుంది శ్రద్ధ లేదు

573
00:36:01,480 --> 00:36:05,970
మేము శ్రద్ధ లేదు ఏమి కారు లోపలి రాడ్లను మరియు పిస్టన్లు మరియు తీగలు అన్ని

574
00:36:05,970 --> 00:36:08,160
వాస్తవానికి చేస్తున్న.

575
00:36:08,160 --> 00:36:12,770
మీరు పిస్టన్ ఈ సందర్భంలో ఇక్కడ పట్టింపు లేదు కాల్ ఏమి లో లాగ కాబట్టి. అదే ఆలోచన.

576
00:36:12,770 --> 00:36:25,300
అవును. >> [వినబడని విద్యార్థి ప్రశ్న]

577
00:36:25,300 --> 00:36:29,180
వేరియబుల్ XA క్షణం మరింత ఉపయోగాలు క్రితం ఉంటే,

578
00:36:29,180 --> 00:36:32,150
మీరు, ప్రోగ్రామర్, ప్రతిచోటా వాటిని మార్చవలసి ఉంటుంది.

579
00:36:32,150 --> 00:36:36,600
లేదా మీరు వాచ్యంగా ఫైలు, మెనూ చేయండి, తరువాత భర్తీ కనుగొనగలిగితే - అలాంటిదే -

580
00:36:36,600 --> 00:36:39,170
అయితే ఆ మార్పులు మీరే చేయడానికి పొందబోతున్నారు.

581
00:36:39,170 --> 00:36:47,450
మీరు స్థిరమైన ఉండాలి. >> [విద్యార్థి] బహుళ వేరియబుల్స్ ఉంటే [వినబడని]

582
00:36:47,450 --> 00:36:53,100
ఇక్కడ వంటి ఒక నిర్దిష్ట క్రమంలో, ఈ ఉంటే మరొక సంఖ్య Int? >> [విద్యార్థి] సరిదిద్దండి.

583
00:36:53,100 --> 00:36:56,590
[మలన్] అవును. మీరు చర్యను కాల్ చేస్తున్నప్పుడు ఆర్డర్ ముఖ్యమైనది.

584
00:36:56,590 --> 00:37:00,050
>> నేను, ఏదో కామా ఏదో ఇక్కడ పెంపు కాల్ అలా అయితే

585
00:37:00,050 --> 00:37:01,680
ఒక ప్రత్యక్ష మ్యాపింగ్ ఉంది.

586
00:37:01,680 --> 00:37:05,690
అది అని ఏ మొదటి వేరియబుల్, ఇక్కడ పైగా మొదటి వాదన కాపీని తయారు చేస్తారు.

587
00:37:05,690 --> 00:37:07,760
క్షమించాలి. ఈ ఒక కుండలీకరణములలో ఉండకూడదు.

588
00:37:07,760 --> 00:37:11,490
రెండవ రెండవ వాదన లైన్లు. ఆర్డర్ కాబట్టి, అవును, ముఖ్యమైనది. అన్ని కుడి.

589
00:37:11,490 --> 00:37:17,020
క్షమించాలి. నేను అక్కడ పొందడానికి చాలా దూరంగా పట్టింది. ఇతర ప్రశ్నలు? అన్ని కుడి.

590
00:37:17,020 --> 00:37:20,610
కాబట్టి మేము నిజంగా ఇక్కడ ఏమి చిత్రాన్ని చిత్రించటానికి కాదు లేదో యొక్క చూసేలా

591
00:37:20,610 --> 00:37:23,090
హుడ్ కింద, మాట్లాడటానికి.

592
00:37:23,090 --> 00:37:26,640
ఇది మీ కంప్యూటర్ యొక్క మెమరీ ప్రతిఫలించే ఒక దీర్ఘ చతురస్రం ఉంది.

593
00:37:26,640 --> 00:37:30,970
మీరు మెమరీ పనిచేస్తుంది లేదా ఎలా RAM ఎలా పనిచేస్తుంది ఆలోచన లేదు సరే,

594
00:37:30,970 --> 00:37:33,940
కనీసం మీరు ఈ రోజుల్లో అది పుష్పగుచ్ఛాలు కలిగి ఊహించుకొనుము.

595
00:37:33,940 --> 00:37:36,280
మీరు దాని మెగాబైట్ల పొందారు, మీరు దానిని గిగాబైట్ల పొందారు

596
00:37:36,280 --> 00:37:40,870
మరియు మేము ఒక బైట్ కేవలం అదే వారం 0 నుండి తెలుసా? >> [విద్యార్థి] 8 బిట్స్.

597
00:37:40,870 --> 00:37:42,950
8 బిట్స్ కుడి? కాబట్టి 8 సున్నాల మరియు 1.

598
00:37:42,950 --> 00:37:45,880
మీ కంప్యూటర్ RAM యొక్క ప్రదర్శన, RAM యొక్క 2 వేదికలను ఈ రోజులు ఉన్నాయి అయితే

599
00:37:45,880 --> 00:37:55,030
మీరు మెమరీ బిలియన్ లేదా 2 బిలియన్ బైట్లు లేదా సుమారు 8 బిలియన్ లేదా 16 బిలియన్ బిట్స్ కలిగి

600
00:37:55,030 --> 00:37:56,890
మీ కంప్యూటర్ లోపల.

601
00:37:56,890 --> 00:38:00,590
చిన్న Wooly విల్లీ ఉదాహరణ వలె కాకుండా, ఇది సాధారణంగా ఇకపై అయస్కాంత అణువులు కాదు.

602
00:38:00,590 --> 00:38:04,450
అధికంగా - ల్యాప్టాప్ లో కనీసం - ఘన స్టేట్ డ్రైవ్స్, SSDs, యొక్క

603
00:38:04,450 --> 00:38:08,580
కేవలం ఎటువంటి కదిలే భాగాలు ఉంటాయి. అన్ని ఎలక్ట్రానిక్ ఉంది. అన్ని విద్యుత్ ఆధారిత ఉంది.

604
00:38:08,580 --> 00:38:14,060
కాబట్టి మీరు కలిగి మెమరీ 1 లేదా 2 గిగాబైట్ల ప్రాతినిధ్యం ఈ దీర్ఘ చతురస్రం యొక్క భావిస్తున్నాను.

605
00:38:14,060 --> 00:38:16,020
>> కనుక ఇది మెమరీ భాగం ఉంది.

606
00:38:16,020 --> 00:38:19,830
విధమైన ఆఫ్ విభజించబడిన కంప్యూటర్ సైన్స్ యొక్క ప్రపంచ ఉంది

607
00:38:19,830 --> 00:38:22,950
మెమరీ భాగాలుగా వివిధ పనులు.

608
00:38:22,950 --> 00:38:27,190
ఈ మీ కంప్యూటర్ యొక్క RAM ఉంటే ఉదాహరణకు, వంటి, అక్కడ దీర్ఘ చతురస్రం సూచించారు

609
00:38:27,190 --> 00:38:31,130
ఇది సాంప్రదాయకంగా, మీ RAM యొక్క పైభాగంలో, మాట్లాడటానికి ఆ అవుతుంది

610
00:38:31,130 --> 00:38:33,660
ఒక టెక్స్ట్ విభాగంలో అని ఏమి ఉంటుంది.

611
00:38:33,660 --> 00:38:36,740
ఆ మీరు సంకలనం చేసిన 0 సె మరియు 1s ఉంటాయి.

612
00:38:36,740 --> 00:38:39,020
మేము, a.out ఏమి వద్ద హుడ్ కింద కనిపించింది చేసిన అప్పుడు

613
00:38:39,020 --> 00:38:41,980
ఈ 0 సె మరియు 1s, మీరు ఒక అమలు చేసేటప్పుడు,

614
00:38:41,980 --> 00:38:46,290
ఆ 0 సె మరియు 1s, RAM అనే మీ హార్డు డ్రైవు నుండి లోడ్

615
00:38:46,290 --> 00:38:49,320
మరియు RAM వారు ఎగువన ఉంచారు చేస్తున్నారు.

616
00:38:49,320 --> 00:38:52,770
అదే సమయంలో, మీరు ఇతర విషయాలు కలిగి ఉంటాయి: డేటాను uninitialize, డేటా ప్రారంభించడం.

617
00:38:52,770 --> 00:38:57,510
మెమరీ ఆ 2 swaths మీరు తరచుగా ఉపయోగించే లేని ప్రపంచ వేరియబుల్స్, చూడండి

618
00:38:57,510 --> 00:39:00,760
మీరు అయితే కొన్నిసార్లు, అవి అలాగే అక్కడికి ముగుస్తుంది.

619
00:39:00,760 --> 00:39:04,260
పరిసరం, మేము ఎక్కువ సమయం ఇది, అప్పుడు కొన్ని ఇతర అంశాలు ఉన్నాయి

620
00:39:04,260 --> 00:39:06,860
కానీ అప్పుడు 2 ముఖ్యమైన విషయాలు ఆ, సెమిస్టర్ అంతా తిరిగి వస్తారు

621
00:39:06,860 --> 00:39:08,550
స్టాక్ మరియు కుప్ప.

622
00:39:08,550 --> 00:39:12,210
ఒక ప్రోగ్రామ్ను అమలు కనుక మీ కంప్యూటర్ యొక్క మెమరీ చాలా ప్రత్యేకించబడింది

623
00:39:12,210 --> 00:39:15,370
ఏదో కోసం స్టాక్ అనే మరియు ఏదో కుప్ప అని.

624
00:39:15,370 --> 00:39:18,840
మేము ఈ రోజు కుప్ప మాట్లాడటానికి వెళ్ళడం లేదు, కానీ మాకు స్టాక్ గురించి చర్చ ఉంటుంది.

625
00:39:18,840 --> 00:39:24,600
స్టాక్ మాథుర్ హౌస్ భోజనశాల భోజనం ట్రేలు యొక్క దృశ్య అప్ సూచించడానికి అర్థం

626
00:39:24,600 --> 00:39:28,110
లేదా భోజనశాల సిబ్బంది ప్రతి రోజు వాటిని శుభ్రం పేరు మీరు కావడం అక్కడ,

627
00:39:28,110 --> 00:39:30,180
వారు, మీద నేల నుండి స్టేక్ అప్

628
00:39:30,180 --> 00:39:34,550
మరియు అలాగే, మెమరీ లో, ఒక స్టాక్ న ఏదో చూస్తూ ఈ ఆలోచన ఉంది

629
00:39:34,550 --> 00:39:36,860
ఒక స్టాక్ న ఏదో చూస్తూ, ఒక స్టాక్ న ఏదో నిలిపివేసింది.

630
00:39:36,860 --> 00:39:38,240
మరియు మేము ఈ ద్వారా ఏమిటి?

631
00:39:38,240 --> 00:39:41,860
>> ఈ చిత్రంలో కేవలం దిగువ సగం, మీ కంప్యూటర్ యొక్క RAM, లో జూమ్ యొక్క లెట్

632
00:39:41,860 --> 00:39:44,330
క్రింది అడగడానికి.

633
00:39:44,330 --> 00:39:48,170
ఇది అవుతుంది మీరు a.out లేదా హలో వంటి అమలు చేసేటప్పుడు -

634
00:39:48,170 --> 00:39:50,100
- ప్రోగ్రామ్ మీరు రాసిన చేసిన ఉండే వస్తువు

635
00:39:50,100 --> 00:39:54,020
మళ్ళీ, ఆ 0 సె మరియు 1s, దీర్ఘకాల నిల్వ, మీ హార్డు డ్రైవు నుండి లోడ్

636
00:39:54,020 --> 00:39:57,230
మీరు RAM లోకి లోడ్ ప్లగ్, పుల్ కూడా అక్కడ ఉంటాయి.

637
00:39:57,230 --> 00:40:00,610
RAM హార్డ్ డ్రైవ్ కంటే వేగంగా - అది హార్డ్ డ్రైవ్ కంటే చిన్న ఉంది -

638
00:40:00,610 --> 00:40:03,300
మీరు వాటిని అమలు చేస్తున్నారు సమయంలో ప్రోగ్రామ్లు పేరు కాని ఇది.

639
00:40:03,300 --> 00:40:08,230
కాబట్టి మీరు డబుల్ ఒక మాక్ లేదా PC లో ఒక కార్యక్రమం క్లిక్ చేసి, అది RAM లోకి హార్డు డ్రైవు నుండి లోడ్ అన్నారు.

640
00:40:08,230 --> 00:40:11,520
ఇది RAM, మార్గం ఎగువన 0 సె మరియు 1s గో లోకి లోడ్ యొక్క త్వరగా

641
00:40:11,520 --> 00:40:16,610
అని పిలవబడే టెక్స్ట్ విభాగంలో, కానీ వెంటనే మీ ప్రోగ్రామ్ వాస్తవానికి మొదలవుతుంది గా ఈవిధంగా

642
00:40:16,610 --> 00:40:21,360
ప్రధాన విధి, అని, మరియు ప్రధాన, మేము చూసిన, తరచుగా స్థానిక వేరియబుల్స్ ఉన్నాయి

643
00:40:21,360 --> 00:40:24,870
మరియు అది ints మరియు తీగలను మరియు అక్షరాలు మరియు వంటి ఉంది.

644
00:40:24,870 --> 00:40:29,180
మీ మీరు రాసిన కార్యక్రమం లేదా మీరు డబుల్ క్లిక్ చేసిన ప్రోగ్రామ్ ఉంటే

645
00:40:29,180 --> 00:40:32,970
కొన్ని వేరియబుల్స్ ప్రధాన యొక్క లోపల,

646
00:40:32,970 --> 00:40:37,240
వారు మాట్లాడటానికి, మెమరీ మీ స్టాక్ దిగువన ముగుస్తుంది.

647
00:40:37,240 --> 00:40:39,410
మరిన్ని concretely ఇది నిజానికి అర్థం ఏమిటి?

648
00:40:39,410 --> 00:40:48,450
ఇది అర్థం మేము మీ కంప్యూటర్ లో RAM యొక్క బైట్లు వెళ్ళి ఉంటే,

649
00:40:48,450 --> 00:40:55,750
ఈ బైట్ సంఖ్య 0 కావచ్చు అని గుర్తించలేకపోతే, ఈ బైట్ సంఖ్య 1, 2, 3, 4, 5, 6, కావచ్చు

650
00:40:55,750 --> 00:41:01,480
2 బిలియన్ వరకు అక్కడికి ఎగువన అన్ని మార్గం.

651
00:41:01,480 --> 00:41:05,880
కాబట్టి ఇతర మాటల్లో చెప్పాలంటే, బైట్లు పరంగా RAM లేదా మెమరీ గురించి మాట్లాడినప్పుడు

652
00:41:05,880 --> 00:41:11,500
అది కేవలం ఒకరు మెమరీ ఆ రాళ్లను ప్రతి సంఖ్య ఏ నిర్ణయించింది అర్థం.

653
00:41:11,500 --> 00:41:16,650
కాబట్టి మీరు ఒక పూర్ణాంకానికి కోసం 32 బిట్స్ అవసరం లేదా మీరు ఒక చార్ కోసం 8 బిట్స్ అవసరం వచ్చినప్పుడు,

654
00:41:16,650 --> 00:41:18,840
వారు మెమరీలో పేరు ముగుస్తుంది చెయ్యాలి?

655
00:41:18,840 --> 00:41:22,350
>> సైధ్ధాంతికంగా, వారు కేవలం స్టాక్ అనే ఈ విషయం దిగువన ముగుస్తుంది.

656
00:41:22,350 --> 00:41:25,870
ప్రధాన ఒక ఫంక్షన్ కాల్స్ కానీ ఇప్పుడు ఆసక్తికరంగా ఉంటుంది -

657
00:41:25,870 --> 00:41:28,750
foo అనే ఫంక్షన్, కేవలం ఏకపక్ష పేరు అనుకుందాం -

658
00:41:28,750 --> 00:41:32,330
మెమరీ ఈ స్టాక్ దిగువన ఏమి జరుగుతుందనే ప్రధాన ఉంటుంది;

659
00:41:32,330 --> 00:41:35,680
foo ఇప్పుడు మెమరీలో ప్రధాన పైన ఉంచబడుతుంది.

660
00:41:35,680 --> 00:41:40,990
Foo సంభావితంగా ప్రధాన ఆ పైన విధమైన ముగుస్తుంది అని ఏ స్థానిక వేరియబుల్స్ కాబట్టి.

661
00:41:40,990 --> 00:41:47,070
Foo బార్ అనే మరొక ఫంక్షన్ ఉంటే, ఆ వేరియబుల్స్ ఇక్కడ ముగుస్తుంది.

662
00:41:47,070 --> 00:41:50,120
బార్ ఇక్కడ ఇక్కడ ఏదో, ఇక్కడ, కాల్స్ ఉంటే.

663
00:41:50,120 --> 00:41:53,830
సో వాట్ ఒక ప్రోగ్రామ్ను అమలు గురించి ఆసక్తికరంగా మీరు కాల్ ప్రమేయాలు వంటి ఉంది

664
00:41:53,830 --> 00:41:57,750
మరియు ఆ విధులు విధులు కాల్ మరియు ఆ విధులు విధులు కాల్ వంటి,

665
00:41:57,750 --> 00:42:01,470
మీరు మెమరీలో విధులను ఈ స్టాక్ నిర్మించే.

666
00:42:01,470 --> 00:42:06,890
మరియు మాత్రమే ఒక తిరిగి వచ్చే చర్యలు ఒకసారి మీరు ఆ స్మృతి చేరుకోవడంలో ప్రారంభం లేదు.

667
00:42:06,890 --> 00:42:10,860
కాబట్టి ఒక కంప్యూటర్ ప్రోగ్రామ్ లో మెమరీ రన్నవుట్ సులభమైన మార్గాలు ఒకటి

668
00:42:10,860 --> 00:42:14,360
ఎన్నటికీ తిరిగి ఆ విధులు రాయడానికి ఉంది.

669
00:42:14,360 --> 00:42:18,900
కాబట్టి ఉదాహరణకు, యొక్క ఉద్దేశపూర్వకంగా బగ్గీ కార్యక్రమం చాలా ప్రదర్శించేందుకు వీలు.

670
00:42:18,900 --> 00:42:22,230
నాకు ముందుకు వెళ్లి # <stdio.h> ఉన్నాయి మనం,

671
00:42:22,230 --> 00:42:25,000
Int ప్రధాన (తప్ప),

672
00:42:25,000 --> 00:42:32,940
మరియు నేను, (2> 1), ఇది బహుశా ఎప్పుడూ మాకు మార్పు లేదు ఉన్నప్పుడు వెళుతున్న

673
00:42:32,940 --> 00:42:37,560
మరియు నాకు ఇప్పుడు ముందుకు వెళ్లి printf తెలియజేసేలా.

674
00:42:37,560 --> 00:42:40,700
అసలైన, తక్కువ దృశ్యపరంగా ఆసక్తికరమైన చేస్తాడు. దీన్ని యొక్క లెట్.

675
00:42:40,700 --> 00:42:50,240
కోసం Int i = 0; i> 0 - యొక్క ఈ తప్పు తయారు చేద్దాము - నేను + +.

676
00:42:50,240 --> 00:42:52,720
మరియు ఇక్కడ యొక్క printf లేదు తెలియజేయండి. యొక్క నేను బోధనలు దాని సాధన లెట్.

677
00:42:52,720 --> 00:43:00,190
, లెట్స్, ఇక్కడ తప్ప కోరస్ ఒక పద్ధతి మరియు మేము Int ఐ సే చేస్తాము

678
00:43:00,190 --> 00:43:06,830
మరియు నేను printf చెప్పడానికి వెళుతున్న - ఏ, లెట్స్ ఈ ఆసక్తికరమైన చేస్తాయి.

679
00:43:06,830 --> 00:43:15,790
యొక్క నిజానికి వద్ద ఏదైనా ముద్రించడం సాధ్యం లెట్. కోరస్ (i): ఈ విధంగా యొక్క లెట్.

680
00:43:15,790 --> 00:43:20,390
అన్ని కుడి. ఎందుకంటే వై సో ఈ బగ్గీ ఉంది?

681
00:43:20,390 --> 00:43:23,380
కార్యక్రమం నిజానికి ఆసక్తి ఏమీ లేదు ఎందుకంటే నేను నేను ఈ ముందుకెళ్లి చేస్తున్నాను.

682
00:43:23,380 --> 00:43:25,320
>> కానీ ఆ లక్ష్యాన్ని కాదు.

683
00:43:25,320 --> 00:43:29,630
గోల్ దీని ప్రధాన విధి ఏమి, స్పష్టంగా చేస్తుంది ప్రోగ్రామ్ రచన?

684
00:43:30,720 --> 00:43:32,860
స్వయంగా కాల్. మరియు వాస్తవానికి, మేము లూప్ అవసరం లేదు.

685
00:43:32,860 --> 00:43:37,200
లెట్ యొక్క కూడా కేవలం నిజంగా ప్రాథమిక బగ్ చూసి కోల్పోవడం కాదు ఈ సులభతరం.

686
00:43:37,200 --> 00:43:39,640
ప్రధాన కాల్స్ కోరస్ కొన్ని కోరస్ పాడే,

687
00:43:39,640 --> 00:43:41,440
అప్పుడు నేను స్టుపిడ్ ఏదో చేశారు మరియు నేను కోరస్ కాల్ బృందగానం కలిగి

688
00:43:41,440 --> 00:43:43,760
నేను ఎవరో దీనికి అమలు వెళ్లి భావించింది ఎందుకంటే

689
00:43:43,760 --> 00:43:47,210
మరియు ఇప్పుడు ఈ ఇంకా కంపైల్ ఉండదని. ఏమి చేయాలి?

690
00:43:47,210 --> 00:43:49,970
నేను నమూనా అవసరం గుర్తుంచుకోండి.

691
00:43:49,970 --> 00:43:56,110
నేను (Int i) ఇక్కడ తప్ప బృందగానం కలిగి ఉంది;

692
00:43:56,110 --> 00:43:59,210
నేను ఇక్కడ డౌన్ వెళ్ళి చేస్తే ఇప్పుడు - నిజానికి, యొక్క పెద్ద విండో ఉపయోగించడానికి అనుమతిస్తున్నట్లు.

693
00:43:59,210 --> 00:44:01,980
యొక్క ముందుకు వెళ్లి కోరస్ తయారు చేద్దాము.

694
00:44:01,980 --> 00:44:06,490
యొక్క ముందుకు వెళ్లి కోరస్ తయారు చేద్దాము.

695
00:44:06,490 --> 00:44:08,370
ప్రకటించనివారు ఐడెంటిఫైయర్ నేను ఉపయోగం.

696
00:44:08,370 --> 00:44:12,500
ఓహ్, ఆ స్టుపిడ్ ఉంది. మేము వాదన లేదు. కేవలం ఇది యొక్క లెట్.

697
00:44:12,500 --> 00:44:16,370
మనం ఈ విధంగా ప్రారంభించారు అనుకుంటున్నారా. వ్రాయుటకు చాలా సులభంగా కార్యక్రమం ఉండేది.

698
00:44:16,370 --> 00:44:25,590
అక్కడ. ఇప్పుడు, నా టెర్మినల్ విండో కు వెళ్ళి గణగణమని ద్వని చేయు తిరిగి, మరియు ఇక్కడ మేము వదలి వేస్తారు.

699
00:44:25,590 --> 00:44:28,460
ఆ వేగం ఉంది.

700
00:44:28,460 --> 00:44:31,150
ఏమి నిజానికి అయితే, జరిగింది?

701
00:44:31,150 --> 00:44:33,730
మేము చూడగలరు Well, ఇప్పుడు నేను ప్రింట్ లైన్ జోడించాలి.

702
00:44:33,730 --> 00:44:43,490
నాకు ("నేను ఇక్కడ ఉన్నాను") printf అని పిలవబడు - ఏ వేరియబుల్స్. మేము ఆ వంటి చెప్పను.

703
00:44:43,490 --> 00:44:47,480
తయారు నాకు తిరిగి లెట్. నాకు కోరస్ తిరిగి లెట్.

704
00:44:47,480 --> 00:44:57,380
మరియు ... న వస్తాయి. కొనసాగించడాన్ని.

705
00:44:57,380 --> 00:44:59,930
జనాంతికంగా, ఎందుకు ఇంకా క్రాష్ లేదు?

706
00:44:59,930 --> 00:45:02,080
విభజన లోపంగా ముందు సూపర్ ఫాస్ట్ జరిగింది.

707
00:45:02,080 --> 00:45:06,570
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఖచ్చితంగా. కాబట్టి అది కుడి, ముద్రించడానికి సమయం పడుతుంది?

708
00:45:06,570 --> 00:45:08,610
ఇది కేవలం కంప్యూటర్ యొక్క భాగంగా మరింత పనిని పడుతుంది.

709
00:45:08,610 --> 00:45:10,620
మరియు అక్కడ అది: విభజన లోపంగా.

710
00:45:10,620 --> 00:45:12,340
>> కాబట్టి ఫాస్ట్ ప్రోగ్రామ్లను అమలు ఎంత గమనిస్తారు.

711
00:45:12,340 --> 00:45:14,130
మీరు ఏదైనా, సూపర్ ఫాస్ట్ ప్రింటింగ్ కాకపోతే.

712
00:45:14,130 --> 00:45:18,770
ఏ జరగలేదు ఎందుకంటే కానీ మేము ఇంకా ఈ విభజన లోపంగా వచ్చింది?

713
00:45:18,770 --> 00:45:21,210
మీరు మీ కంప్యూటర్ యొక్క మెమరీ సిద్ధం ఎలా గురించి మీరు భావిస్తే,

714
00:45:21,210 --> 00:45:28,740
ఈ ప్రధాన నిర్మాణము, కాని ఇక్కడ యొక్క ఈ కోరస్ కాల్ వివరించారు, ఈ కోరస్ కాల్ లెట్స్.

715
00:45:28,740 --> 00:45:34,550
నేను నా అలంకారం లేకపోతే ఇప్పుడు, ఈ కేవలం కోరస్, కోరస్, కోరస్, చెప్పడానికి అన్నారు

716
00:45:34,550 --> 00:45:40,550
కోరస్, కోరస్, కోరస్, కోరస్, ప్రకటన nauseum, మరియు చివరికి, ఏమి ఏమి?

717
00:45:40,550 --> 00:45:45,630
బిగ్ పిక్చర్, వాచ్యంగా, ఈ ఉంటే, ఏ కేవలం సంభావితంగా జరుగుతుంది?

718
00:45:46,520 --> 00:45:48,630
స్టాక్ కారణంతో కుప్ప.

719
00:45:48,630 --> 00:45:51,940
లేదా, దారుణంగా, మీరు టెక్స్ట్ విభాగంలో సహా ప్రతిదీ, ఆక్రమిత

720
00:45:51,940 --> 00:45:54,590
మీ ప్రోగ్రామ్ సూచించే 0 సె మరియు 1s ఇది.

721
00:45:54,590 --> 00:45:57,080
చిన్న లో, ఈ కేవలం సూపర్, సూపర్ చెడ్డది.

722
00:45:57,080 --> 00:45:58,830
మీ ప్రోగ్రామ్ నియంత్రణ మొదలైంది ఉంది.

723
00:45:58,830 --> 00:46:01,220
మీరు ఉద్దేశించిన కంటే మార్గం అధిక మెమరీ ఉపయోగించే

724
00:46:01,220 --> 00:46:03,960
అన్ని ఎందుకంటే ఈ సందర్భంలో ఒక పెద్ద తప్పు యొక్క,

725
00:46:03,960 --> 00:46:08,040
లేదా ఈ సందర్భంలో చాలా ఉద్దేశపూర్వకంగా చేసిన ఫంక్షన్ కూడా పిలుపునిచ్చింది.

726
00:46:08,040 --> 00:46:09,500
ఇప్పుడు, ఈ అన్ని చెడు లేదు.

727
00:46:09,500 --> 00:46:13,800
మీరు దాన్ని సరిగ్గా ఉపయోగించేటప్పుడు తాము కాల్ విధులు నిజానికి గొప్ప శక్తిని కలిగి ఉంది.

728
00:46:13,800 --> 00:46:15,800
నేను సరిగ్గా ఇక్కడ ఉపయోగించలేదు.

729
00:46:15,800 --> 00:46:19,780
కాబట్టి ఈ అన్ని చెడు కాదు, కానీ నేను నిజంగా ఆపడానికి ఎప్పుడూ వాస్తవం నాకు కాల్

730
00:46:19,780 --> 00:46:23,520
ఈ కార్యక్రమం యొక్క ఇక్కడ ఒక ప్రాథమిక బలహీనత ఉంది.

731
00:46:23,520 --> 00:46:26,400
కాబట్టి అక్కడ ఈ మొత్తం వెళ్తున్నారు? నిజంగా ఏమి జరుగుతున్నది?

732
00:46:26,400 --> 00:46:30,340
మేము ఆ ఉదాహరణలలో చేస్తున్న వంటి నేను పెంపు ఫంక్షన్ కాల్ చేసినప్పుడు,

733
00:46:30,340 --> 00:46:33,420
నేను సైన్ వెళ్ళే 1 వంటి విలువను

734
00:46:33,420 --> 00:46:37,570
నేను సంఖ్య 1 యొక్క ఒక కాపీని లో పాస్, కాబట్టి కింది జరుగుతుంది.

735
00:46:37,570 --> 00:46:44,240
పెంపు ఉదాహరణ లోకి వెళ్ళి తెలపండి యొక్క ఇక్కడే ఈ గై.

736
00:46:44,240 --> 00:46:46,870
ఇక్కడ వాస్తవానికి ఏం ఉంది.

737
00:46:46,870 --> 00:46:53,400
నేను పెంపు కాల్ మరియు నేను ఇక్కడ ఏమి, చిత్రాల, x లో పాస్ చేసినప్పుడు ఈ ఉంది.

738
00:46:53,400 --> 00:46:59,520
>> నేను ఇక్కడ నిల్వ 1 యొక్క విలువ మరియు నిజానికి పెంపు కాల్ ఉంటే,

739
00:46:59,520 --> 00:47:04,330
ఇది ఇప్పుడు కోరస్ అంటారు - ఐప్యాడ్ ఇక్కడ నాకు ఆఫ్ విసిరే ఉంది.

740
00:47:04,330 --> 00:47:09,760
లెట్ యొక్క ఈ పెంపు కాల్, మరియు మేము ఈ తదుపరి చర్య మాత్రం ఏమి లేదు.

741
00:47:09,760 --> 00:47:14,840
సో వాట్ వాస్తవానికి జరుగుతున్నది ప్రధాన ఎక్కడో ఇక్కడ నేను మెమరీ భాగం కలిగి

742
00:47:14,840 --> 00:47:17,000
ఆ సంఖ్యను 1 నిల్వ.

743
00:47:17,000 --> 00:47:19,380
నేను పెంపు కాల్ చేసినప్పుడు, నేను, మెమరీ మరొక భాగం ఉపయోగించి నేను

744
00:47:19,380 --> 00:47:21,230
కానీ ఇప్పుడు నేను 1 యొక్క కాపీ.

745
00:47:21,230 --> 00:47:26,660
నేను ఆ విలువ పెంచడం, ఈ, 2 అవుతుంది

746
00:47:26,660 --> 00:47:30,560
కానీ అప్పుడు ఏమి పెంపు తిరిగి వెంటనే జరుగుతుంది?

747
00:47:30,560 --> 00:47:33,630
ఈ మెమరీ కేవలం, ఆపరేటింగ్ సిస్టమ్ తిరిగి అప్పగించారు అవుతుంది

748
00:47:33,630 --> 00:47:37,450
మీరు చేసిన అన్ని ఉపయోగకరమైన ఏమీ అర్థం.

749
00:47:37,450 --> 00:47:43,120
వాస్తవానికి ప్రధాన ఉందని 1 వాస్తవానికి ఇప్పటికీ ఉంది.

750
00:47:43,120 --> 00:47:44,890
కాబట్టి అక్కడ ఈ తో వెళ్తున్నారు?

751
00:47:44,890 --> 00:47:49,770
ఇది మెమరీ లో మీరు బైట్లు ఈ తిరిగి-to-తిరిగి సన్నివేశం ఆ అవుతుంది

752
00:47:49,770 --> 00:47:53,050
మీరు stuff ఉంచవచ్చు, మరియు అది మేము ఇప్పటికే ఏదో చూసిన ఆ అవుతుంది ఆ

753
00:47:53,050 --> 00:47:55,390
వెనుకకు తిరిగి తిరిగి విషయాలను తిరిగి చూస్తూ ఉంటుంది అని.

754
00:47:55,390 --> 00:47:59,860
వారం 1 మరియు ఇప్పుడు వారం 2 ఆధారంగా ఒక స్ట్రింగ్ అంటే ఏంటి?

755
00:48:00,020 --> 00:48:01,980
ఇది కేవలం అక్షరాలు సమాహారం ఉంది.

756
00:48:01,980 --> 00:48:04,310
అది మీరు మెమరీ సంఖ్యలు ఉంచవచ్చు కేవలం అవుతుంది

757
00:48:04,310 --> 00:48:06,990
అదేవిధంగా మీరు మెమరీ పాత్రలు ఉంచవచ్చు.

758
00:48:06,990 --> 00:48:10,530
మరియు ఒకసారి మేము, తిరిగి తిరిగి తిరిగి తిరిగి మెమరీలో ఉంచడం అక్షరాలు ప్రారంభం

759
00:48:10,530 --> 00:48:13,620
అది అవుతుంది లూప్ లేదా కొంత లూప్ ఒక వంటి వాటిని సాధారణ ఉపయోగించి ఆ,

760
00:48:13,620 --> 00:48:17,170
మేము ఒక స్ట్రింగ్ లో అక్షరాలు పైన ఎడమ నుండి కుడికి iterate చేయవచ్చు

761
00:48:17,170 --> 00:48:20,600
మరియు మొత్తంగా వేర్వేరు అక్షరాలు వాటిని మర్దనా ప్రారంభం -

762
00:48:20,600 --> 00:48:23,370
ఒక బి మారవచ్చు, బి సి మారవచ్చు -

763
00:48:23,370 --> 00:48:27,780
చివరికి, మేము నిజంగా అర్ధమే ఆ ఆంగ్ల వాక్యం పడుతుంది కాబట్టి

764
00:48:27,780 --> 00:48:30,310
మరియు ఒక సమయంలో ఆ అక్షరాలు ఒక ప్రతి మార్పిడి

765
00:48:30,310 --> 00:48:34,400
మా కంప్యూటర్ యొక్క మెమరీ ద్వారా వాకింగ్ ప్రకారం గుప్తీకరించడానికి ఎడమ.

766
00:48:34,400 --> 00:48:35,810
కాబట్టి యొక్క ఇక్కడ మా ఐదు నిమిషాల విరామం తీసుకుందాం,

767
00:48:35,810 --> 00:48:40,730
మరియు మేము తిరిగి వచ్చినప్పుడు, మేము సమాచారం స్క్రాంబ్లింగ్ ఈ ప్రక్రియ మొదలుపెడతారు.

768
00:48:42,020 --> 00:48:43,520
>> అన్ని కుడి.

769
00:48:43,520 --> 00:48:48,070
, మేము కొన్ని crypto ప్రవేశిస్తాడు మరియు ఈ విషయాలు శ్రేణుల అని ముందు

770
00:48:48,070 --> 00:48:51,470
నేను నిజంగా రకమైన muddled వంటి నేను భావిస్తున్నాను ఎందుకంటే నాకు ఏ ప్రశ్నలు నిలిపివేయి తెలియజేయండి

771
00:48:51,470 --> 00:48:54,080
ఆ కొన్ని అంశాలను. మేము చేస్తే ఇప్పుడు యొక్క పరిష్కరించడానికి అనుమతిస్తాయి.

772
00:48:54,080 --> 00:48:58,700
మేము తిరిగి విలువలు గురించి మాట్లాడారు, మేము, వాదనలు గురించి మాట్లాడారు

773
00:48:58,700 --> 00:49:03,250
మరియు మేము, మేము వచ్చి వారాల్లో వచ్చి మేము, ఈ భావన గురించి మాట్లాడారు

774
00:49:03,250 --> 00:49:08,720
యొక్క మాట్లాడటానికి, ఈ అమర్చినట్లు ట్రేలు యొక్క మొత్తం బంచ్ గా మెమరీ చూడటం

775
00:49:08,720 --> 00:49:12,660
అటువంటి అప్ క్రింద నుండి ఆ స్టాక్ మీద ఉంచే ప్రతి ట్రే

776
00:49:12,660 --> 00:49:16,530
ప్రస్తుతం పిలువబడే ఒక విధిని సూచిస్తుంది.

777
00:49:17,900 --> 00:49:20,260
ఏదైనా ప్రశ్నలు?

778
00:49:20,260 --> 00:49:22,640
నాకు ఇక్కడ ఒక ప్రశ్న అడగండి లెట్.

779
00:49:22,640 --> 00:49:27,890
నన్ను మా ముందు Q & A. యొక్క కొన్ని ముందు ఈ తిరిగి సులభతరం లెట్

780
00:49:27,890 --> 00:49:35,570
పెంపు ఓపెన్ కుండలీకరణములలో, Int ఉన్నాయి వాస్తవం, కుండలీకరణములలో మూసివేయబడింది -

781
00:49:35,570 --> 00:49:39,110
Int సంఖ్య ఏ ప్రాతినిధ్యం లేదు?

782
00:49:39,110 --> 00:49:42,790
[విద్యార్థి] ఒక వాదన. >> ఒక వాదన. సరే. కానీ ఒక వాదన ఏమిటి?

783
00:49:42,790 --> 00:49:46,370
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి? మీరు వెళ్ళే >> [విద్యార్థి] ఏదో

784
00:49:46,370 --> 00:49:49,940
సరే, మీరు పాస్ మరియు మరింత సాధారణంగా, ఇది ఇన్పుట్ ఏదో ఒకటి.

785
00:49:49,940 --> 00:49:52,450
మీరు జీవితంలో ఒక ఫంక్షన్ మరియు ఆ ఫంక్షన్ యొక్క ప్రయోజనం రాసే ఉంటే

786
00:49:52,450 --> 00:49:55,770
, ఏదో మీరు దీనిని ఉపయోగించడానికి కొంత వివిధ ప్రతిసారీ ఏమి చేయాలో

787
00:49:55,770 --> 00:50:00,110
అప్పుడు నిజంగా జరిగే ఆ ఏకైక మార్గం ఇన్పుట్ అందించగల అగుపిస్తుంది

788
00:50:00,110 --> 00:50:03,510
ఆ ఇన్పుట్ ప్రతి సమయం వివిధ ఏదో ఒకటి చేయవచ్చు.

789
00:50:03,510 --> 00:50:06,650
>> కాబట్టి మీరు ఒక ఫంక్షన్ ఇన్పుట్ తీసుకోవడము రెండు విషయాలు పేర్కొనాలి.

790
00:50:06,650 --> 00:50:09,590
మీరు ఆ ఇన్పుట్ ఇవ్వడానికి కావలసిన పేరు పేర్కొనాలి

791
00:50:09,590 --> 00:50:12,700
పూర్తిగా మీ స్వంత సౌలభ్యం కోసం మీరు చూడండి విధంగా

792
00:50:12,700 --> 00:50:16,540
నేను లైన్ 32 లో వలె మీరే, వ్రాస్తున్న ఆ ఫంక్షన్ లో.

793
00:50:16,540 --> 00:50:20,800
కానీ మీరు కూడా సి ప్రోగ్రామింగ్ భాష ఎందుకంటే దాని రకాన్ని పేర్కొనాలి

794
00:50:20,800 --> 00:50:25,940
కేవలం, మీరు ఒక వేరియబుల్ మీరు అది ఏమిటో డేటా రకం కంప్యూటర్ చెప్పడం కలిగి ఉండాలి

795
00:50:25,940 --> 00:50:30,200
తద్వారా అధిక భాగం లో ఆ వేరియబుల్ కోసం కేటాయించే ఎన్ని బిట్స్ తెలుసు

796
00:50:30,200 --> 00:50:33,020
ఇది 6 ఎందుకంటే - క్షమించండి, 6 ఉండదు.

797
00:50:33,020 --> 00:50:37,080
ఇది 16 కావచ్చు, ఇది 8 కావచ్చు, ఇది కూడా 64, 32 ఉంటుంది

798
00:50:37,080 --> 00:50:39,130
కానీ కంప్యూటర్ తెలుసుకోవాలి.

799
00:50:39,130 --> 00:50:43,180
ఇప్పుడు, ఎడమ చేతి వైపు Int విరుద్ధంగా ఏ, సూచిస్తుంది?

800
00:50:46,350 --> 00:50:48,850
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి? పనితీరు >> [విద్యార్థి] పద్ధతి.

801
00:50:48,850 --> 00:50:53,610
ఒక చర్య యొక్క రకం మరియు, ముఖ్యంగా దాని అవుట్పుట్ యొక్క రకం. కుడి.

802
00:50:53,610 --> 00:50:57,380
కాబట్టి కుండలీకరణాల్లో విషయం అయితే దాని ఇన్పుట్, ఏదైనా ఉంటే, సూచిస్తుంది

803
00:50:57,380 --> 00:50:59,660
ఎడమవైపు విషయం దాని అవుట్పుట్ సూచిస్తుంది.

804
00:50:59,660 --> 00:51:03,530
మరియు ఈ సందర్భంలో, పెంపు స్పష్టంగా ఒక పూర్ణాంకానికి తిరిగి,

805
00:51:03,530 --> 00:51:07,690
అందువలన Int ఈ ఫంక్షన్ తిరిగి రకం.

806
00:51:07,690 --> 00:51:09,340
అంటే తిరిగి శతకము

807
00:51:09,340 --> 00:51:15,090
సాహిత్యపరంగా, మీరు ముఖ్యపదాన్ని తిరిగి ఉపయోగించడానికి మరియు తిరిగి ఏ ఉంటే

808
00:51:15,090 --> 00:51:18,600
కీవర్డ్ కుడివైపున ఒక పూర్ణ సంఖ్య,

809
00:51:18,600 --> 00:51:21,660
ఆ మేము వాగ్దానం ఏమి తో నిజానికి స్థిరంగా ఉంటుంది.

810
00:51:21,660 --> 00:51:26,410
హలో, ప్రపంచం - - మీరు ఈ ఏదో ఒకటి అని ఒక స్ట్రింగ్ ఎందుకంటే.

811
00:51:26,410 --> 00:51:28,860
>> నిజానికి, ఇది ఒక పూర్ణ సంఖ్య కాదు.

812
00:51:28,860 --> 00:51:33,140
కాబట్టి చిన్న లో, భారం మాకు న నిజంగా ఉంది, ప్రోగ్రామర్, నిర్దిష్ట ఉండాలి

813
00:51:33,140 --> 00:51:37,770
మేము తిరిగి ఏమి కు మరియు తరువాత దీన్ని తిరిగి గురించి వెళ్ళండి.

814
00:51:37,770 --> 00:51:43,440
ఇక్కడ సందర్భం ఇప్పుడు మీ కంప్యూటర్ యొక్క మెమరీ ఒక గిగాబైట్, 2 గిగాబైట్ల ఉంటుంది -

815
00:51:43,440 --> 00:51:45,920
ఏ - అది ఇంకా ఉండవచ్చు దీనికి తక్కువగా,

816
00:51:45,920 --> 00:51:49,050
కానీ కంప్యూటర్ వివిధ విభాగాలు కలిగి అది అభిప్రాయపడ్డాడు.

817
00:51:49,050 --> 00:51:51,200
ఏదో పని చెయ్యకపోతే, ఏదో, అక్కడ పెరుగుతుంది

818
00:51:51,200 --> 00:51:54,290
వివిధ అంశాలను మధ్య జరిగే, మరియు నేడు మేము కథ చెప్పడం మొదలు

819
00:51:54,290 --> 00:51:56,340
కానీ మేము ఈ మీద వచ్చి చేస్తాము.

820
00:51:56,340 --> 00:51:59,980
ప్రస్తుతం, మేము నిజంగా శ్రద్ధ మెమరీ మాత్రమే ముక్క టెక్స్ట్ విభాగంలో ఉంది

821
00:51:59,980 --> 00:52:03,360
కేవలం 0 సె మరియు 1s ఆ గణగణమని ద్వని చేయు ప్రాతినిధ్యం ఎందుకంటే outputted ఉంది.

822
00:52:03,360 --> 00:52:06,050
మీరు a.out వంటి కీబోర్డ్ వద్ద ఒక ఆదేశాన్ని అప్పుడు

823
00:52:06,050 --> 00:52:09,110
లేదా మీరు డబుల్, Mac OS లేదా Windows లో ఒక చిహ్నాన్ని క్లిక్ చెయ్యండి

824
00:52:09,110 --> 00:52:11,880
మీ ప్రోగ్రామ్ మీ హార్డు డ్రైవు నుండి RAM లోకి లోడ్

825
00:52:11,880 --> 00:52:16,330
మరియు అది మాట్లాడటానికి, మీ కంప్యూటర్ యొక్క RAM ఎగువన plopped యొక్క.

826
00:52:16,330 --> 00:52:20,450
ఇంతలో, మీ ప్రోగ్రామ్ మొదలవుతుంది వంటి నడుస్తున్న మరియు ప్రధాన అని చెపుతాడు

827
00:52:20,450 --> 00:52:23,640
కార్యక్రమంలో మీరు రాశారు లేదా ప్రోగ్రామ్ మైక్రోసాఫ్ట్ లేదా Apple రాశాడు

828
00:52:23,640 --> 00:52:27,860
దాని స్థానిక వేరియబుల్స్ యొక్క ఏ మీ కంప్యూటర్ యొక్క మెమరీ దిగువన అక్కడ డౌన్ ముగుస్తుంది.

829
00:52:27,860 --> 00:52:33,230
కానీ స్వయంగా చరరాశులు లేదా వాదనలు కలిగి ప్రధాన కాల్స్ మరొక ఫంక్షన్ ఉంటే అవి దానిని పై ముగుస్తుంది.

830
00:52:33,230 --> 00:52:36,680
ఆ ఫంక్షన్ ఏదో కాల్స్, వారు పై, పై, పై ముగుస్తుంది.

831
00:52:36,680 --> 00:52:41,460
>> మరియు మాత్రమే ఒకసారి ఒక ఫంక్షన్ అమలు చేయబడుతుంది ట్రేలు యొక్క స్టాక్ మాట్లాడటానికి లేదు,

832
00:52:41,460 --> 00:52:43,240
తక్కువ మరియు తక్కువ పొందడానికి ప్రారంభించండి.

833
00:52:43,240 --> 00:52:48,250
మరియు ఈ తరువాత, క్లుప్తంగా, మీరు క్యూబ్ కాల్ ఎందుకు ఉన్నప్పుడు వివరిస్తుంది ఏమిటి

834
00:52:48,250 --> 00:52:51,550
మీరు పెంపు కాల్ లేదా, మీరు విలువ యొక్క కాపీని అక్కడ చేస్తున్నారు.

835
00:52:51,550 --> 00:52:55,520
మరియు ఆ చిత్రాల అంటే మీరు వాచ్యంగా సంఖ్య 1 రాస్తున్నాం ఉంది

836
00:52:55,520 --> 00:53:00,460
మెమరీ మరొక భాగంలో, మారుతున్న పెంపు విషయంలో 1 నుండి 2

837
00:53:00,460 --> 00:53:04,820
లేదా తర్వాత ఒక ఘనం విషయంలో 8 మరియు దూరంగా ఆ స్మృతి విసిరే

838
00:53:04,820 --> 00:53:09,140
వెంటనే పెంపు లేదా క్యూబ్ తిరిగి వచ్చే చర్యలు వంటి. ప్రశ్న.

839
00:53:09,140 --> 00:53:12,900
[విద్యార్థి] ఎక్కడ ప్రపంచ వేరియబుల్స్ నిల్వ చేయబడతాయి?

840
00:53:12,900 --> 00:53:18,100
గ్లోబల్ వేరియబుల్స్, ప్రస్తుతం initialized డేటా లేదా అవినియోగిత డేటా అనే ఏమి నిల్వ చేయబడతాయి

841
00:53:18,100 --> 00:53:21,920
మీరు ఒక ప్రపంచ వేరియబుల్ కలిగి మరియు మీరు వెంటనే ఒక విలువ అది కేటాయించి ఉంటే తేడా ఉండటం

842
00:53:21,920 --> 00:53:24,640
సైన్ సమానం, ఇది, అక్కడ టాప్ వద్ద ముగుస్తుంది

843
00:53:24,640 --> 00:53:29,200
మీరు Int x చెప్పుకోవాలంటే మరియు; విలువ లేకుండా, అది RAM లో కొద్దిగా తక్కువ ముగుస్తుంది

844
00:53:29,200 --> 00:53:31,710
కేవలం కన్వెన్షన్ ద్వారా.

845
00:53:31,710 --> 00:53:34,940
ఇతర ప్రశ్నలు? అన్ని కుడి.

846
00:53:34,940 --> 00:53:37,340
మేము మరింత శక్తివంతమైన పొందండి కాబట్టి ఈ చిత్రం తిరిగి వస్తారు

847
00:53:37,340 --> 00:53:39,170
మేము కంప్యూటర్ చెయ్యగలరు తో,

848
00:53:39,170 --> 00:53:42,720
కానీ ఇప్పుడు కోసం, యొక్క గూఢ లిపి శాస్త్రానికి ఒక క్లుప్తమైన పరిచయ వివరించారు

849
00:53:42,720 --> 00:53:46,080
ప్రపంచ సమస్యలన్నింటినీ పరిష్కరించేందుకు లేదు గూఢ లిపి శాస్త్రం యొక్క ఒక నిర్దిష్ట రకం

850
00:53:46,080 --> 00:53:47,720
కానీ వాటిలో కొన్ని పరిష్కరించడానికి లేదు.

851
00:53:47,720 --> 00:53:51,700
ఇక్కడ ఈ సందర్భంలో, మనం రహస్య కీ గూఢ లిపి శాస్త్రం అనే ఉంది.

852
00:53:51,700 --> 00:53:56,410
రహస్య కీ గూఢ లిపి శాస్త్రం, పేరు సూచించినట్లు, ఒక రహస్య నుంచి భద్రతా వచ్చింది.

853
00:53:56,410 --> 00:54:00,690
>> మీరు గ్రేడ్ పాఠశాల తిరిగి మరియు ఉదాహరణకు, మీరు ఒక చిన్న రహస్య ప్రేమ లేఖ అయ్యేది

854
00:54:00,690 --> 00:54:04,850
మీరు ప్రేక్షకుల ద్వారా గమనించండి పాస్ కోరుకుంటే బాయ్ లేదా అమ్మాయి మిమ్మల్ని పై అణిచివేత చేశారు,

855
00:54:04,850 --> 00:54:08,380
మీరు బహుశా ఇంగ్లీష్ లో ఒక గమనిక రాయడం లేదా ఏ మీ స్థానిక భాష కాదు.

856
00:54:08,380 --> 00:54:13,340
అయితే, మీరు గుప్తీకరించడానికి ఉండవచ్చు లేదా మీరు ఈ రోజుల్లో వాటిని ఒక టెక్స్ట్ సందేశం పంపండి ఉండవచ్చు.

857
00:54:13,340 --> 00:54:15,460
కానీ మీరు నిజంగా తరగతిలో వరకు అలాగే ఒక గమనిక తరలి.

858
00:54:15,460 --> 00:54:18,700
మరియు విధంగా సురక్షితంగా దీన్ని మీ స్నేహితులు మరియు teacher

859
00:54:18,700 --> 00:54:22,650
మీకు రాయడం ఏమి తెలియదు, మీరు, ఒక నిరాడంబర అల్గోరిథం ఆలోచన కావచ్చు

860
00:54:22,650 --> 00:54:25,920
మీరు కావచ్చు యువ అయితే, కేవలం పదాలు పెనుగులాటలకు.

861
00:54:25,920 --> 00:54:28,130
కాబట్టి బదులుగా ఒక వ్రాసే మీరు, బి వ్రాస్తానని

862
00:54:28,130 --> 00:54:30,220
బదులుగా బి యొక్క మీరు, సి వ్రాస్తానని

863
00:54:30,220 --> 00:54:32,140
బదులుగా సి యొక్క మీరు ముందుకు d వ్రాయడానికి, మరియు ఉండవచ్చు.

864
00:54:32,140 --> 00:54:34,360
లేదా మీరు మరింత ఆధునిక అనువాదం తో వస్తుంది

865
00:54:34,360 --> 00:54:36,720
వివిధ అక్షరాలకు అక్షరాల.

866
00:54:36,720 --> 00:54:39,740
కానీ క్యాచ్ మీరు ఈ గమనికను పంపిస్తున్నాం ఎవరికి బాయ్ లేదా అమ్మాయి

867
00:54:39,740 --> 00:54:45,020
అవసరాలు ఏమిటి, ఖచ్చితంగా ఇది ఏదో, తెలుసుకోవటానికి? >> [విద్యార్థి] మీరు పంపే ఏమి.

868
00:54:45,020 --> 00:54:49,720
మీ రహస్య ఒక యొక్క అండ్ బి మరియు సి మరియు డి లు మధ్య ఒక మ్యాపింగ్ గురించే, ఉంది.

869
00:54:49,720 --> 00:54:54,650
ఇది కేవలం నుంచి బి, బి కి సి వెళ్ళడానికి అక్షరాలు ప్రతి 1 జోడించడం ఉంటుంది?

870
00:54:54,650 --> 00:54:56,670
ఆ కంటే క్లిష్టమైనది?

871
00:54:56,670 --> 00:55:01,540
>> కాబట్టి మీరు మరియు మీ ప్రేమను ఈ రహస్య సమాచారం కలిగి ఉండాలి

872
00:55:01,540 --> 00:55:03,190
కానీ ఇక్కడ ఒక క్యాచ్-22 రకం ఉంది.

873
00:55:03,190 --> 00:55:06,830
ఈ మొదటిసారిగా ఉంటే మీరు, తరగతి ద్వారా ఈ ప్రేమ లేఖ పంపిస్తున్నాం

874
00:55:06,830 --> 00:55:10,720
ఎలా బాయ్ లేదా అమ్మాయి రహస్య కూడా తెలుసు అన్నారు?

875
00:55:10,720 --> 00:55:13,930
కాబట్టి రహస్య కీని crypto, ప్రపంచ సమస్యలన్నింటినీ పరిష్కరించేందుకు లేదు

876
00:55:13,930 --> 00:55:16,320
మరియు ఒక సంబంధం మేము సెమిస్టర్ చివరలో వచ్చి మేము ఇక్కడ వాస్తవానికి ఉంది.

877
00:55:16,320 --> 00:55:25,110
అదేవిధంగా మా చాలా Amazon.com వద్ద, ఉదాహరణకు, పనిచేసే ఎవరైనా తెలియదు

878
00:55:25,110 --> 00:55:28,190
మరియు ఇంకా మాకు చాలా బహుశా, Amazon.com వద్ద stuff కొనుగోలు

879
00:55:28,190 --> 00:55:31,990
మరియు మేము ఈ e-కామర్స్ లావాదేవీలకు సురక్షిత భావించాలి నేర్చుకున్నాడు చేసిన.

880
00:55:31,990 --> 00:55:36,470
URL బహుశా, https, ఎక్కడో బహుశా ఒక వెర్రి చిన్న ప్యాడ్లాక్ను చిహ్నం ఉంది అన్నారు

881
00:55:36,470 --> 00:55:39,930
మీ క్రెడిట్ కార్డు సమాచారాన్ని సురక్షితం గూఢ లిపి శాస్త్రం యొక్క కొన్ని రకం ఉంది

882
00:55:39,930 --> 00:55:42,160
మీరు మరియు Amazon.com మధ్య.

883
00:55:42,160 --> 00:55:45,430
గూఢ లిపి శాస్త్రం ఉంటుంది ఉంటే ఇంకా కొన్ని రహస్య తెలుసుకోవడం

884
00:55:45,430 --> 00:55:48,620
మరియు ఇంకా నేను అమెజాన్ లో ఎవరైనా తెలియదు మరియు నేను ఖచ్చితంగా రహస్య ఎలాంటి అమర్చిన చేసిన

885
00:55:48,620 --> 00:55:52,710
అమెజాన్ వద్ద ఒకరితో, ఎలా ఇలా నా కంప్యూటర్ లేదా నా బ్రౌజర్?

886
00:55:52,710 --> 00:55:55,720
గూఢ లిపి శాస్త్రం యొక్క ఇతర రకాలు సమస్య పరిష్కరించే పూర్తిగా ఉంది అది మారుతుంది.

887
00:55:55,720 --> 00:55:57,670
అయితే ఈ రోజు కోసం, మేము సులభం దృష్టి చేస్తాము

888
00:55:57,670 --> 00:56:00,290
మీరు కొన్ని రహస్య తెలుసుకోవటానికి ముందుగానే ఏర్పాటు చేసుకోవచ్చు పేరు

889
00:56:00,290 --> 00:56:03,760
+1 లేదా ఒక యొక్క అండ్ బి యొక్క మధ్య కొన్ని మ్యాపింగ్ ఇష్టపడుతున్నారు.

890
00:56:03,760 --> 00:56:05,840
మరియు గూఢ లిపి శాస్త్రం యొక్క ప్రక్రియను సాధారణంగా ఈ ఉంటుంది.

891
00:56:05,840 --> 00:56:08,620
మీరు ఎడమ వద్ద ఇక్కడ వర్ణించబడిన కొన్ని సాదా టెక్స్ట్, కలిగి

892
00:56:08,620 --> 00:56:12,930
మీరు గుప్తీకరించి కోసం అల్గోరిథం లేదా ప్రక్రియ యొక్క రకమైన ద్వారా అమలు -

893
00:56:12,930 --> 00:56:15,100
బహుశా కేవలం యొక్క ఒక బి అవుతుంది, బి సి అవుతుంది -

894
00:56:15,100 --> 00:56:17,490
మరియు తర్వాత మీరు సాంకేతికపాఠం తో ముగుస్తుంది.

895
00:56:17,490 --> 00:56:20,380
ఇంతలో, ఒకసారి మీ ప్రేమను ఈ రహస్య గమనిక అందుకుంటుంది

896
00:56:20,380 --> 00:56:24,200
అతను లేదా ఆమె అప్పుడు దానిని సాధారణంగా ఆ అల్గోరిథం విపర్యయ ఉంటుంది

897
00:56:24,200 --> 00:56:27,190
సాదా టెక్స్ట్ తిరిగి పొందడానికి తద్వారా.

898
00:56:27,190 --> 00:56:28,960
ఈ భౌతిక అవతారాలు ఉన్నాయి.

899
00:56:28,960 --> 00:56:31,680
>> ఉదాహరణకు, ఈ, కొద్దిగా రహస్య డికోడర్ రింగ్ ఉంది

900
00:56:31,680 --> 00:56:35,110
మరియు ఈ రెండు ఫలకాలు ఇక్కడ ఉంది అనేది ఒక వలయంగా చెప్పవచ్చు.

901
00:56:35,110 --> 00:56:38,490
ఈ విషయం బయట అంచున, Z ద్వారా లేఖలు, లేదు

902
00:56:38,490 --> 00:56:40,340
వారు వరుస క్రమంలో ఉన్నారు, అయితే

903
00:56:40,340 --> 00:56:42,880
మరియు లోపల, కొన్ని సంఖ్యలను వాస్తవానికి ఉంది

904
00:56:42,880 --> 00:56:46,620
ఈ రింగ్ మీకు రకమైన లోపల వెలుపల మలుపు కానీ ఆ

905
00:56:46,620 --> 00:56:49,140
అక్షరాలతో సంఖ్యలు వరుసలో చేయడానికి.

906
00:56:49,140 --> 00:56:53,020
ఒక క్రిస్మస్ స్టోరీ అనే చిత్రంలో, మీరు ఆ చిన్న Ralphie చూస్తారు

907
00:56:53,020 --> 00:56:58,000
లిటిల్ ఆర్ఫన్ అన్నీ యొక్క రహస్య సందేశాన్ని తాను ఏ గుర్తించడానికి కనుక చూపారు

908
00:56:58,000 --> 00:57:02,570
ఒక ధాన్యం బాక్స్ లో సంఖ్యా సందేశాల రూపంలో, నేను అనుకుంటున్నాను, ప్రసారం చేశారు

909
00:57:02,570 --> 00:57:07,220
మరియు మీరు, ధాన్యం బాక్స్ లో వచ్చిన అన్ని చిన్న కార్డులు పొందిన కలిగి

910
00:57:07,220 --> 00:57:09,770
మీరు వాటిని మెయిల్ వచ్చింది, మీరు రహస్య డికోడర్ రింగ్ తిరిగి వచ్చింది

911
00:57:09,770 --> 00:57:13,910
మీరు చివరకు మ్యాపింగ్ అక్షరాలు మరియు సంఖ్యలను మధ్య ఏమి గుర్తించడానికి కనుక

912
00:57:13,910 --> 00:57:15,550
లేదా అక్షరాలు మరియు అక్షరాలు.

913
00:57:15,550 --> 00:57:19,520
మేము ఈ వంటి వాటిని అమలు లేదా ప్రాతినిధ్యం గురించి ఎలా కంప్యూటర్ లో వెళ్ళవచ్చు?

914
00:57:19,520 --> 00:57:22,560
మేము కొంచెం తేలికగా మేమే వ్యక్తపరిచే ఒక మార్గం అవసరం

915
00:57:22,560 --> 00:57:25,080
మా వేరియబుల్స్ ఇప్పటివరకు అనుమతించింది కంటే.

916
00:57:25,080 --> 00:57:29,000
మేము అక్షరాలు చేశాము, ints చేశాము, మేము, తేలియాడుతున్న మరియు డబుల్స్ మరియు కొన్ని ఇతరులు చేశాము

917
00:57:29,000 --> 00:57:34,200
కానీ ఆ నిజంగా మాకు విషయాలు వ్యక్తీకరించడానికి అనుమతించని మెమరీ వ్యక్తిగత ముక్కలు ఉంటాయి

918
00:57:34,200 --> 00:57:36,440
పదాలు మరియు వాక్యాలను మరియు పదబంధాలను ఇష్టపడుతున్నారు.

919
00:57:36,440 --> 00:57:38,630
నిజానికి, మేము అలాంటి వాటిని తీగలను అని చేసిన

920
00:57:38,630 --> 00:57:42,660
కానీ మేము ఈ నిజంగా CS50 లైబ్రరీలో కేవలం సరళమైనది హామీ

921
00:57:42,660 --> 00:57:45,540
మేము తిరిగి రాలిపోవడం ఉద్దేశించి చేయవచ్చు.

922
00:57:45,540 --> 00:57:47,500
మరియు ఇక్కడ ఆ విధంగా చేయడానికి ప్రారంభిద్దాం.

923
00:57:47,500 --> 00:57:49,840
నాకు ముందుకు వెళ్లి ఒక ఫైల్ తెరుచుకుంటుంది లెట్ -

924
00:57:49,840 --> 00:57:54,100
ఈ ఫైళ్లు అన్ని అందుబాటులో ఉన్నాయి, వంటి సాధారణ, ఆన్లైన్ - అని array.c

925
00:57:54,100 --> 00:57:58,960
తీగలను సంబంధం లేని ఒక సమస్యను పరిష్కరించడానికి కానీ ఇక్కడ చిత్రాన్ని వర్ణాలను ఉపయోగించేందుకు

926
00:57:58,960 --> 00:58:01,520
ఎలా మేము వ్యూహం అని ఏదో ఉపయోగించవచ్చు.

927
00:58:01,520 --> 00:58:04,050
>> ఒక అమరిక ఒక డేటా రకం.

928
00:58:04,050 --> 00:58:10,730
అనేక చిన్న డేటా రకాల అది లోపల కలిగి రకాల వేరియబుల్ ఒక రకం

929
00:58:10,730 --> 00:58:12,680
బ్యాక్ టు బ్యాక్ వెనుకకు వెనుకకు.

930
00:58:12,680 --> 00:58:16,980
మీ క్విజ్ సగటు ఇస్తుంది ఒక చిన్న ప్రోగ్రామ్ను రాయడం అనుకున్నారు కాబట్టి ఉదాహరణకు, ఒకవేళ

931
00:58:16,980 --> 00:58:19,780
2 క్విజ్ కలిగి 50 వంటి కోర్సు కోసం,

932
00:58:19,780 --> 00:58:23,450
మీరు చాలా సులభంగా కూడా గత వారం యొక్క కొన్ని విషయాలు ఆధారంగా ఈ కార్యక్రమం రాస్తుంది

933
00:58:23,450 --> 00:58:28,830
GetInt మరియు వేరియబుల్స్ యొక్క ఒక జంట ఉపయోగించి: Int quiz1, Int quiz2.

934
00:58:28,830 --> 00:58:30,550
మరియు ఇది అందంగా సూటిగా ఉంది.

935
00:58:30,550 --> 00:58:33,500
ఇది కోడ్ మాక్స్ యొక్క 20 పంక్తులు ఒక కార్యక్రమం అమలు, బహుశా 10 లు

936
00:58:33,500 --> 00:58:38,940
2 క్విజ్ స్కోర్లు కోసం వినియోగదారు అడుగుతుంది మరియు వారి సగటు గణిస్తుంది ఆ

937
00:58:38,940 --> 00:58:42,020
వాటిని కలిసి జోడించడం 2 విభజన, మరియు అప్పుడు ఫలితాలు ముద్రించడం ద్వారా.

938
00:58:42,020 --> 00:58:46,400
మేము బహుశా నిమిషాల కొన్ని సంఖ్య తర్వాత చాలా సులభంగా ఇప్పుడు ఆ పని చేయడు.

939
00:58:46,400 --> 00:58:49,450
కానీ సమస్య 50 3 క్విజ్లు లేదా 4 ఉందని అనుకుందాం ఉంటుంది.

940
00:58:49,450 --> 00:58:52,830
మీరు క్విజ్ వీక్లీ ఉందని ఒక తరగతి ఒకే కార్యక్రమం ఉపయోగించడానికి కోరుకున్నాడు అనుకుందాం.

941
00:58:52,830 --> 00:58:55,100
వారం క్విజ్లు ఒక తరగతి గురించి ఆలోచించండి.

942
00:58:55,100 --> 00:58:58,840
ఒక సెమిస్టర్ లో 16 లేదా వారాల ఉంటే, ఇప్పుడు మీరు 16 వేరియబుల్స్ ఉన్నాయి:

943
00:58:58,840 --> 00:59:03,030
Int quiz1, Int quiz2, Int quiz3, Int quiz4.

944
00:59:03,030 --> 00:59:06,870
మీరు ఈ రిడెండెన్సీ చూడడాన్ని ప్రారంభించడానికి వెంటనే, ఈ, కాపీ మరియు కోడ్ అతికించి

945
00:59:06,870 --> 00:59:09,810
మీరు ఒక మంచి మార్గం ఉన్నాయి అనుకుంటున్నారా చేయడానికి ప్రారంభం కావాలి.

946
00:59:09,810 --> 00:59:13,610
మరియు కృతజ్ఞతగా, ఎందుకంటే శ్రేణుల యొక్క ఉంది. కాబట్టి దీన్ని చూద్దాం.

947
00:59:13,610 --> 00:59:16,700
మొదటి, నాకు మేము ఇప్పటివరకు ఉపయోగించని చేసిన చాలా చిన్న విషయం పరిచయం తెలియజేయండి

948
00:59:16,700 --> 00:59:18,820
కానీ మీరు కోడ్ అప్పుడప్పుడు అది చూస్తారు.

949
00:59:18,820 --> 00:59:21,270
>> ఈ సాధారణంగా స్థిరమైన అని ఏమిటి.

950
00:59:21,270 --> 00:59:24,410
కాబట్టి ఈ విలువ మారదు ఎప్పుడూ అనేది ఒక నిరంతర ఉంది.

951
00:59:24,410 --> 00:59:26,450
స్థిరమైన సృష్టిస్తున్నప్పుడు మానవ కన్వెన్షన్

952
00:59:26,450 --> 00:59:30,420
కేవలం అది నిజంగా మీ కోడ్ లో ఉన్నటువంటి, అన్ని అక్షరాలు ఉపయోగిస్తారు

953
00:59:30,420 --> 00:59:34,270
మరియు మీరు C లో ఉపయోగించే ప్రత్యేక కీవర్డ్ # define ఉంది.

954
00:59:34,270 --> 00:59:39,970
కాబట్టి మేము # అప్పుడు, అప్పుడు, మీరు స్థిరమైన యొక్క పేరు కోసం ఉపయోగించే కావలసిన పదం ఒక స్థలాన్ని విశదీకరిస్తాయి సే

955
00:59:39,970 --> 00:59:41,730
మరియు తర్వాత స్థిరమైన విలువ.

956
00:59:41,730 --> 00:59:44,710
ఇది వేరియబుల్ ఏదో కేటాయించి భిన్నంగా ఉంటుంది గమనించండి.

957
00:59:44,710 --> 00:59:46,430
సైన్ సమానం లేదు, ఏ సెమికోలన్ ఉంది.

958
00:59:46,430 --> 00:59:49,140
ఇది సాధారణంగా ఒక ప్రాసెసర్ ఆదేశం గా పిలిచే ఏమిటి

959
00:59:49,140 --> 00:59:50,840
మరో సమయం కాని.

960
00:59:50,840 --> 00:59:56,350
ఇప్పుడు, ఈ క్విజ్లు అని ఒక మార్పులేని విలువ సృష్టిస్తుంది

961
00:59:56,350 --> 00:59:58,290
దీని అసలు సంఖ్యను 2.

962
00:59:58,290 --> 01:00:02,180
కాబట్టి ఎక్కడైనా మీరు, ఈ ఫైల్ అంతటా క్విజ్లు, క్విజ్, క్విజ్ చూడండి

963
01:00:02,180 --> 01:00:04,230
కేవలం సంఖ్య 2 ఉంది.

964
01:00:04,230 --> 01:00:06,550
నేను ఇప్పుడు ప్రధాన దృష్టి ఉంటే, ఎలా ఈ పనులు చూడటానికి.

965
01:00:06,550 --> 01:00:09,770
మొదట ఒక చిన్న గుప్తమైన కనిపిస్తుంది, కానీ వారం 1 నుండి అన్ని విషయాలు అనిపిస్తుంది.

966
01:00:09,770 --> 01:00:12,210
తరగతులు యూజర్ అడగండి. దీన్ని మేము ఎలా చేయాలి?

967
01:00:12,210 --> 01:00:17,350
లైన్ 22 In - ఈ నిజంగా జ్యుసి భాగం - I ఫ్లోట్ డిక్లేర్

968
01:00:17,350 --> 01:00:23,240
కానీ కేవలం ఒకే ఫ్లోట్. నేను కాకుండా, ఫ్లోటింగ్ పాయింట్ విలువలు యొక్క వ్యూహం ప్రకటించారు చేస్తున్నాను.

969
01:00:23,240 --> 01:00:27,700
ఆ వేరియబుల్ ఇక్కడ సూచించినట్లు వంటి, తరగతులు పిలుస్తారు అన్నారు

970
01:00:27,700 --> 01:00:31,420
కానీ కొత్త వాక్యనిర్మాణం యొక్క మాత్రమే ముక్క ఈ చదరపు బ్రాకెట్లలో ఉంటాయి.

971
01:00:31,420 --> 01:00:37,280
నేను ఫ్లోట్ తరగతులు తర్వాత తెరిచి బ్రాకెట్ మరియు తరువాత సంఖ్య అని చేసిన నిజానికి -

972
01:00:37,280 --> 01:00:40,980
ఈ ఈ కేవలం ఈ చేశాడు ఒక స్థిరంగా ఉంటే నోటీసు -

973
01:00:40,980 --> 01:00:46,840
ఈ అర్థం, "హే కంప్యూటర్, నాకు 2 తేలియాడుతున్న ఇవ్వాలని మరియు యొక్క సమిష్టిగా వారిని తరగతులు కాల్ తెలియజేయండి."

974
01:00:46,840 --> 01:00:51,780
>> ఈ వంటి మరింత దుర్భరమైన ప్రక్రియ భిన్నంగా ఉంటుంది: ఫ్లోట్ grade1;

975
01:00:51,780 --> 01:00:54,580
grade2 తేలుతూ; మొదలగునవి.

976
01:00:54,580 --> 01:00:58,310
కాబట్టి వ్యూహం మాకు ఈ ఆలోచన అమలు అనుమతిస్తుంది కానీ తక్కువ messily,

977
01:00:58,310 --> 01:01:04,560
మేము సే,, బదులుగా ఒక 16 వారాల సెమిస్టర్ 16 కోడ్ 1 లైన్ రాయడం ఆ విధంగా.

978
01:01:04,560 --> 01:01:09,060
నేను హార్డ్ కోడ్ 2 ఇష్టం లేదు ఎందుకంటే మీరు తార్కికంగా ఇప్పుడు ఈ గురించి అనుకుంటే,

979
01:01:09,060 --> 01:01:12,560
3 CS50 మార్పులు బదులుగా క్విజ్లు తరువాత సంవత్సరం అనుకుంటే

980
01:01:12,560 --> 01:01:15,010
మరియు నేను ఇక్కడ సంఖ్య 2 కలిగి, నేను, ఇక్కడ సంఖ్య 2 కలిగి

981
01:01:15,010 --> 01:01:17,210
నేను ఇక్కడ 2, ఇక్కడ సంఖ్య సంఖ్య 2 ఉంది.

982
01:01:17,210 --> 01:01:19,890
ఇది అప్ మేకు చాలా దుర్భరమైన మరియు చాలా సులభం అవుతుంది

983
01:01:19,890 --> 01:01:26,550
మరియు అనుకోకుండా 3 1 విలువను మార్చడానికి మరియు 2 యొక్క కొన్ని ఇతర విలువ మిస్.

984
01:01:26,550 --> 01:01:30,660
నేను, ఈ దూరంగా బదులుగా వియుక్త వెళ్లి ఈ స్థిరంగా ఆ ఉపయోగించడానికి నేను

985
01:01:30,660 --> 01:01:32,520
దాని పేరు సూచించిన విధంగా, మార్పులు చేయలేదు.

986
01:01:32,520 --> 01:01:35,870
ఇప్పుడు మేము వేరే అని ఉన్నా, ఈ సంవత్సరం లేదా తదుపరి క్విజ్లు

987
01:01:35,870 --> 01:01:39,380
నేను ఎగువన ఇక్కడ ఒక స్థానంలో దానిని మార్చవలసి.

988
01:01:39,380 --> 01:01:41,230
కాబట్టి అంతే ఒక స్థిరాంకం.

989
01:01:41,230 --> 01:01:47,100
ఇంతలో, కొత్త సంభావిత ఫీచర్ వ్యూహం యొక్క ఉంటుంది.

990
01:01:47,100 --> 01:01:55,030
కాబట్టి చదరపు బ్రాకెట్లలో ఈ అనేక తేలియాడుతున్న ఇవ్వాలని మరియు నాకు సమిష్టిగా వాటిని ఇక్కడ తరగతులు కాల్ చేస్తుంది.

991
01:01:55,030 --> 01:01:56,720
కాబట్టి ఇప్పుడు నేను వెళుతున్న ఏ చూద్దాం.

992
01:01:56,720 --> 01:01:59,220
ఇక్కడ లైన్ 24 లో లూప్ ఒక ప్రారంభంలో ఉంది.

993
01:01:59,220 --> 01:02:03,380
>> ఇది నిజంగా ఏమీ ఫాన్సీ ఉంది. ఇది కేవలం క్విజ్లు ఉపయోగించడానికి బదులుగా ఒక హార్డ్ కోడెడ్ సంఖ్య యొక్క.

994
01:02:03,380 --> 01:02:06,740
అయితే గత వారం నుండి తెలివైన వివిధ ఏదీ లేదు.

995
01:02:06,740 --> 01:02:11,650
ఈ ("% d యొక్క% d క్విజ్:") కాబట్టి printf, కేవలం printf ఉంది

996
01:02:11,650 --> 01:02:16,670
నేను నాకు 2 సంఖ్య 1 క్విజ్ ఆపై 2 యొక్క 2 ఇవ్వాలని ముద్రించాలా కావలసిన ఎందుకంటే.

997
01:02:16,670 --> 01:02:18,480
కాబట్టి ఈ ఒక కేవలం సౌందర్య విషయం.

998
01:02:18,480 --> 01:02:21,000
కానీ ఆసక్తికరమైన భాగంగా ఇప్పుడు లైన్ 27 లో ఉంది.

999
01:02:21,000 --> 01:02:27,840
ఒక ఫ్లోటింగ్ పాయింట్ విలువ రెండు placeholders ఒకటి పూర్తి చేయడానికి,

1000
01:02:27,840 --> 01:02:29,640
మీరు మళ్ళీ చదరపు బ్రాకెట్లలో ఉపయోగించండి.

1001
01:02:29,640 --> 01:02:35,170
లూప్ ఈ స్పష్టంగా, నేను ఏం విలువ సమం ప్రారంభించండి ఎందుకంటే ఈ సందర్భంలో, నేను ఉపయోగించి నేను?

1002
01:02:35,170 --> 01:02:36,670
[విద్యార్థి] 0. >> [మలన్] 0.

1003
01:02:36,670 --> 01:02:40,990
కాబట్టి ఈ లూప్ యొక్క మొదటి మళ్ళా న, నేను కోడ్ ఈ రాశాడు గానీ ఉంది,

1004
01:02:40,990 --> 01:02:46,310
నా కోడ్ లో ఈ రాశాడు అయితే కానీ ఈ లూప్ యొక్క రెండవ మళ్ళా న, ఇది.

1005
01:02:46,310 --> 01:02:49,970
పేరు సూచించినట్లు, ఎందుకంటే కానీ వేరియబుల్ను వుపయోగిస్తూ నేను నిజానికి, ఖచ్చితంగా ఉంది

1006
01:02:49,970 --> 01:02:52,600
ఇది ప్రతి పునరుక్తి దాని విలువ వివిధ యొక్క

1007
01:02:52,600 --> 01:02:55,900
నేను ఒక సమయంలో ఈ శ్రేణి ఒక మచ్చ నింపి చేస్తున్నాను.

1008
01:02:55,900 --> 01:02:57,380
ఈ శ్రేణి అంటే ఎలా ఉంటుంది?

1009
01:02:57,380 --> 01:03:01,570
నేను ఇక్కడ తెరపై సూపర్ సాధారణ దీర్ఘ చతురస్రం ఆకర్షించింది కారణం ముందు ఈ కారణంగా ఉంది.

1010
01:03:01,570 --> 01:03:05,590
ఒక అమరిక కేవలం మెమరీ మరొక భాగం తర్వాత మెమరీ భాగం ఉంది

1011
01:03:05,590 --> 01:03:08,570
మెమరీ మరొక భాగం తర్వాత మొదలగునవి.

1012
01:03:08,570 --> 01:03:13,120
నా శ్రేణి ఇక్కడ ఈ సందర్భంలో పరిమాణం 2 యొక్క కాబట్టి, అన్ని నేను చేస్తూయుండేవారు

1013
01:03:13,120 --> 01:03:20,200
నా క్విజ్ స్కోర్లు టైప్ చేయడం ద్వారా ఇక్కడ ఇష్టం - నేను ఈ ఒక 100 వచ్చింది మరియు నేను ఈ ఒక మీద 99 వచ్చింది -

1014
01:03:20,200 --> 01:03:24,970
నేను మాత్రమే కంప్యూటర్ అడిగారు ఎందుకంటే ఈ మెమరీ కూడా ఉపయోగించవచ్చు కాదు

1015
01:03:24,970 --> 01:03:26,840
పరిమాణం 2 యొక్క వ్యూహం కోసం.

1016
01:03:26,840 --> 01:03:28,600
ఆ చతురస్రాలు కుడి, ఇప్పటికీ?

1017
01:03:28,600 --> 01:03:32,670
మీరు కేవలం 2 తేలియాడుతున్న కోరుతూ చేస్తున్నప్పుడు కూడా మీరు ఇప్పటికీ RAM యొక్క 2 గిగాబైట్ల ఉన్నాయి.

1018
01:03:32,670 --> 01:03:36,840
కాబట్టి శ్రేణుల వెనుక ఆలోచన కంప్యూటర్ కేవలం మెమరీ భాగం తీసుకుంటుంది ఉంది

1019
01:03:36,840 --> 01:03:41,340
ఆ తర్వాత మళ్లీ తిరిగి తిరిగి తిరిగి చిన్న ముక్కలు apportions.

1020
01:03:41,340 --> 01:03:43,310
కాబట్టి అన్ని వ్యూహం పత్రిక.

1021
01:03:43,310 --> 01:03:47,350
>> మీరు విషయాలను ఉంచవచ్చు వీటిలో మెమరీ లోపల ఒక ఆనుకొని భాగం ఉంది.

1022
01:03:47,350 --> 01:03:50,700
ఈ అప్పుడు కొన్ని బోరింగ్ లెక్కలు నేర్చుకుంటారు నిర్మాణము.

1023
01:03:50,700 --> 01:03:54,640
నేను ఇక్కడ స్క్రోల్ డౌన్ ఉంటే నేను శ్రేణి మీద iterate పేరు, ఈ ఉంది.

1024
01:03:54,640 --> 01:03:58,020
నేను, అర్రే విలువలు అన్ని సమ్మషన్ ఆలోచన

1025
01:03:58,020 --> 01:04:02,470
మరియు నేను నిజంగా క్విజ్లు ద్వారా విభజించబడింది మొత్తం చేయడానికి ఇక్కడ రౌండ్ క్రియాశీలతను ఉపయోగించదు.

1026
01:04:02,470 --> 01:04:06,320
కానీ నాకు ఇప్పుడు తగినంత అంకగణితం యొక్క విధమైన ఆ నా చేతి దుర్చాల్సిన తెలియజేయండి.

1027
01:04:06,320 --> 01:04:08,370
కానీ నాకు ఏమి అన్ని చివరికి సగటు కంప్యూటింగ్.

1028
01:04:08,370 --> 01:04:13,580
కాబట్టి మొదటి క్విజ్ ప్లస్ రెండవ క్విజ్ 2 తో విభజించాలి మరియు ఒక పూర్ణాంకానికి గా ముద్రించిన.

1029
01:04:13,580 --> 01:04:17,280
String1 అనే మరొక ఉదాహరణ కాని లెట్స్ ఇప్పుడు పరివర్తన,

1030
01:04:17,280 --> 01:04:20,700
అదే విధమైన చిత్రం కాని ఉపయోగించి తీగలను నింపేశారు.

1031
01:04:20,700 --> 01:04:23,940
నాకు ముందుకు వెళ్లి ఒక క్షణం ఈ సులభతరం లెట్.

1032
01:04:23,940 --> 01:04:27,090
ఇప్పుడు కోసం ఇండెంటేషన్ని క్షమించు.

1033
01:04:27,090 --> 01:04:30,870
ఈ ఉదాహరణ యొక్క లైన్ 19 లో నోటీసు, నేను వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందండి.

1034
01:04:30,870 --> 01:04:34,640
కానీ నేను తరువాత లైన్స్ లో 22 తరువాత చేస్తున్నదాన్ని గమనిస్తారు.

1035
01:04:34,640 --> 01:04:41,250
నిజానికి నేను నుండి iterating ఉన్నాను - మరియు ఈ కొత్త ట్రిక్ ఉంది - strlen, స్ట్రింగ్ పొడవు.

1036
01:04:41,250 --> 01:04:44,880
ఇది మీరు ఒక స్ట్రింగ్ పాస్ ఉంటే, C తో పాటు వచ్చే ఒక విధి

1037
01:04:44,880 --> 01:04:47,730
ఆ స్ట్రింగ్ లో ఎన్ని అక్షరాలు మీరు చెబుతుంది. అంతే.

1038
01:04:47,730 --> 01:04:51,550
మరియు అది బదులుగా స్ట్రింగ్ పొడవు యొక్క strlen అని నిజానికి అది మరింత సంక్షిప్తమైన యొక్క కనుక ఉంది.

1039
01:04:51,550 --> 01:04:55,100
ముప్పై సంవత్సరాల క్రితం, ప్రజలు, వంటి క్లుప్తమైన సాధ్యమైనంత విషయాలు రాయడానికి ఇష్టపడ్డారు

1040
01:04:55,100 --> 01:04:57,630
కాబట్టి మేము ఇక్కడ ఆ సమావేశం ఉంచింది చేసిన.

1041
01:04:57,630 --> 01:05:00,660
నేను + + కేవలం ప్రతి పునరావృతం లో నేను పెంచడం అంటే.

1042
01:05:00,660 --> 01:05:02,990
ఇప్పుడు నిజంగా ఆసక్తికరమైన ఇది ఈ గమనిస్తారు.

1043
01:05:02,990 --> 01:05:09,180
లైన్ 24 లో నేను, "కంప్యూటర్, నాకు 8 బిట్స్ ఒక పాత్ర ఇవ్వాలని, మరియు అది సి కాల్."

1044
01:05:09,180 --> 01:05:12,630
కానీ ఈ కుడి వైపు అని ఏమిటి?

1045
01:05:13,490 --> 01:05:16,530
ఇంగ్లీష్ లో, ఏ ప్రాతినిధ్యం లేదు?

1046
01:05:16,530 --> 01:05:18,730
[విద్యార్థి] శ్రేణి లో మొదటి అక్షరం.

1047
01:05:18,730 --> 01:05:20,790
సరిగ్గా. నాకు శ్రేణి లో మొదటి అక్షరం ఇవ్వండి.

1048
01:05:20,790 --> 01:05:24,090
లేదా, మరింత సాధారణంగా, నాకు యెరే నందలి ith పాత్ర ఇవ్వాలని.

1049
01:05:24,090 --> 01:05:26,100
ఇప్పుడు అది ముఖ్యం తెలుసుకుంటారు కంప్యూటర్ శాస్త్రవేత్తలు,

1050
01:05:26,100 --> 01:05:27,890
మేము నిజంగా 0 నుండి లెక్కింపు చేస్తున్నారు.

1051
01:05:27,890 --> 01:05:29,720
>> మీరు ఈ చేయడం ప్రారంభించడానికి ఇప్పుడు విచక్షణతో లేదు.

1052
01:05:29,720 --> 01:05:34,160
ఇప్పుడు మీరు కంప్యూటర్ యొక్క అంచనాలను అనుగుణంగా ప్రవర్తించాలి మరియు 0 నుండి లెక్కించాలి

1053
01:05:34,160 --> 01:05:38,180
[0] ఎందుకంటే, ఒక స్ట్రింగ్ లో మొదటి అక్షరం అన్నారు

1054
01:05:38,180 --> 01:05:42,150
[1] రెండవ ఉండబోతుంది, [2] మూడవ మరియు ఆ విధంగా ముందుకు అని అన్నారు.

1055
01:05:42,150 --> 01:05:49,720
కాబట్టి ఈ ప్రోగ్రామ్, నేను కంపైల్ ఉంటే, మళ్ళీ string1, కాబట్టి string1 తయారు,

1056
01:05:49,720 --> 01:05:54,670
మరియు ఇప్పుడు నా టెర్మినల్ విండో లో string1 అమలు చేసిన.

1057
01:05:54,670 --> 01:05:58,330
, ఇది ఇన్పుట్ కోసం వేచి, దాంతో నేను, డేవిడ్ టైప్ ఎంటర్ వెళుతున్న

1058
01:05:58,330 --> 01:06:02,540
ప్రకటన నేను ఏమి ఎందుకంటే, ఇప్పుడు అన్ని విభిన్న లైన్లతో డేవిడ్ ముద్రిస్తుంది.

1059
01:06:02,540 --> 01:06:05,820
నేను ఒక సమయంలో ఒక పాత్ర ప్రింటింగ్ చేస్తున్నాను.

1060
01:06:05,820 --> 01:06:10,100
మేము ఈ రోజు వివరాలను కాదు, కానీ నేను ఇక్కడ ఈ చెక్ క్రితం ఒక సందర్భం తొలగించారు.

1061
01:06:10,100 --> 01:06:15,480
ఇది వినియోగదారుకు తప్పుగా ప్రవర్తిస్తోంది ఉంటే ఆ అవుతుంది, శత్రువులు, లేదా గందరగోళం,

1062
01:06:15,480 --> 01:06:20,210
మీరు నిజంగా కొన్ని పొడవు యొక్క స్ట్రింగ్ ఇవ్వాలని విఫలం కావచ్చు.

1063
01:06:20,210 --> 01:06:22,860
మీరు కీబోర్డ్ మీద తప్పు కీ నొక్కండి, మీరు, అసలు స్ట్రింగ్ ఇవ్వాలని ఉండవచ్చు

1064
01:06:22,860 --> 01:06:26,950
మీరు హానికరమైన అయితే లేదా, మీరు ఒక వ్యాసం యొక్క ఒక గిగాబైట్ యొక్క విలువ పేస్ట్ ప్రయత్నించండి

1065
01:06:26,950 --> 01:06:29,290
కంప్యూటర్ మెమరీ అయిపోతే ఈ స్ట్రింగ్ నింపి మరియు,

1066
01:06:29,290 --> 01:06:32,710
అది మేము NULL అని ఈ ప్రత్యేక విలువ తిరిగి చూడాలని ఉద్దేశ్యంతో అవుతుంది.

1067
01:06:32,710 --> 01:06:35,580
ఇప్పటివరకు, నిరర్థక అని ఈ ప్రత్యేక విలువ లేదు తెలుసు

1068
01:06:35,580 --> 01:06:39,580
మాకు మేము ఇతర విషయాలతోపాటు, మెమరీ ఉన్నప్పుడు తనిఖీ అనుమతిస్తుంది.

1069
01:06:39,580 --> 01:06:45,630
కానీ ఇప్పుడు string2 అప్ తెరిస్తే, ఇక్కడ ఒక తేడా గమనించవచ్చు.

1070
01:06:45,630 --> 01:06:48,210
String2 ఇక్కడ తేడా గమనించండి.

1071
01:06:48,210 --> 01:06:51,340
String2 తో, లూప్ ఈ చిన్న భిన్నంగా ఉంటుంది.

1072
01:06:51,340 --> 01:06:55,010
>> మేము ఆ మరొక సారి మాట్లాడటానికి విధంగా నాకు NULLs తొలగించండి లెట్.

1073
01:06:55,010 --> 01:06:57,800
ఏ లూప్ ఈ సమయం గురించి విభిన్నమైనది?

1074
01:06:59,620 --> 01:07:01,670
నేను గత ఉదాహరణకు వెళ్లవచ్చు.

1075
01:07:01,670 --> 01:07:08,580
వెర్షన్ 2 కాబట్టి, ఈ వెర్షన్ 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
పేరు strlen పిలుపు?

1078
01:07:16,660 --> 01:07:18,860
ఇది లూప్ యొక్క మొదటి భాగం ఉంది.

1079
01:07:18,860 --> 01:07:21,830
నేను ఇలా చేస్తున్నాను ఎందుకు ఏదైనా ఆలోచనలు? అవును.

1080
01:07:21,830 --> 01:07:24,560
[విద్యార్థి] కాబట్టి మీరు ఫంక్షన్ ప్రతి సమయం కాల్ లేదు.

1081
01:07:24,560 --> 01:07:26,440
[మలన్] మేము ఫంక్షన్ ప్రతి సమయం కాల్ కాబట్టి. సరిగ్గా.

1082
01:07:26,440 --> 01:07:28,300
వారు సూపర్ సాధారణ అని ఉచ్చులు కోసం నుండి రీకాల్

1083
01:07:28,300 --> 01:07:31,770
ఒకసారి మీరు విధమైన ఈ ప్రారంభ, పరిస్థితి, మరియు నవీకరణ అని అర్థం.

1084
01:07:31,770 --> 01:07:34,750
సమస్య పరిస్థితి లూప్ యొక్క ప్రతి మళ్ళా లో జరిగే ఉంటుంది.

1085
01:07:34,750 --> 01:07:40,010
మరియు ఇక్కడ ఈ ఉదాహరణలో, ఈ నా పరిస్థితి ఏమిటంటే గురించి తప్పుగా ఉంది?

1086
01:07:40,010 --> 01:07:41,830
[విద్యార్థి] మీరు strlen కాల్ చేస్తున్నారు.

1087
01:07:41,830 --> 01:07:44,340
[మలన్] మీరు మళ్లీ మళ్లీ మళ్లీ strlen కాల్ చేస్తుంది.

1088
01:07:44,340 --> 01:07:47,410
కానీ ఒకసారి నేను డేవిడ్ లో టైప్ చేసిన, ఆ స్ట్రింగ్ యొక్క పొడవు, 5

1089
01:07:47,410 --> 01:07:49,650
మరియు అది లూప్ యొక్క ప్రతి మళ్ళా మార్పు మాత్రం కాదు

1090
01:07:49,650 --> 01:07:51,670
స్ట్రింగ్ ఉంది D-a-V-i-D. ఎందుకంటే

1091
01:07:51,670 --> 01:07:55,320
కాబట్టి ఈ ప్రధాన ఆలోచన మారింది ఏమి వద్ద ఒక సూచన ఉంది

1092
01:07:55,320 --> 01:08:00,410
కేవలం కంప్యూటర్ అనవసరమైన పని చేయటం లేదు పేరు ఒక నిర్ణయానికి అని పిలుస్తారు.

1093
01:08:00,410 --> 01:08:03,920
>> జస్ట్ వంటి ప్రామాణిక ఎడిషన్ pset2, pset2 ఒక స్నీక్ ప్రివ్యూ

1094
01:08:03,920 --> 01:08:07,030
వాస్తవానికి సాంకేతికలిపుల కొన్ని సంఖ్య అమలు మీరు సవాలు అన్నారు,

1095
01:08:07,030 --> 01:08:10,410
మీరు రెండు గుప్తీకరించడానికి తద్వారా గుప్తలేఖన యాంత్రిక పద్ధతులకు కొన్ని సంఖ్య,

1096
01:08:10,410 --> 01:08:13,840
మరియు చాలా ఒక Ralphie వంటి వ్యక్తీకరించడానికి రహస్య సందేశాలు డీకోడ్.

1097
01:08:13,840 --> 01:08:16,810
Pset2 యొక్క హ్యాకర్ ఎడిషన్ లో, మేము ఒక చిన్న ముందుకు వెళుతున్నాం.

1098
01:08:16,810 --> 01:08:19,649
మేము అసలు కంప్యూటర్ సిస్టమ్ నుండి మీరు ఒక ఫైల్ చేతితో చూడాలని

1099
01:08:19,649 --> 01:08:23,479
ఆ యూజర్ అసలు ఎన్క్రిప్టెడ్ పాస్వర్డ్లను యొక్క మొత్తం బంచ్ కలిగి

1100
01:08:23,479 --> 01:08:26,939
మరియు హ్యాకర్ ఎడిషన్ కోసం సవాలు ఆ రహస్యపదాలను ఛేదించడానికి అవతరిస్తుంది

1101
01:08:26,939 --> 01:08:33,200
మరియు వాస్తవానికి ఆ పాస్వర్డ్లను ఉత్పత్తి చేయడానికి ఉపయోగించే దాని గూఢ లిపి లేదా ఏ రహస్యం చూడవచ్చు.

1102
01:08:33,200 --> 01:08:36,109
మరియు మేము ఇక్కడ సి ఒక కొత్త ఫీచర్ ఉపయోగించి ఈ చేయబోతున్నామని

1103
01:08:36,109 --> 01:08:40,630
నేను మీరు ఆదేశ పంక్తి వాదనలు పిలవబడే ఒక డెమో ఇస్తాము ఆ.

1104
01:08:40,630 --> 01:08:44,229
మీరు కొన్ని విభాగంలో లేదా పాఠ్యపుస్తకాల్లో చూసిన ఇది,, అవుతుంది

1105
01:08:44,229 --> 01:08:48,260
ప్రధాన ఎల్లప్పుడూ కుండలీకరణాల్లో చెల్లనిదనీ లేదు.

1106
01:08:48,260 --> 01:08:52,430
ఇది రెండు వాదనలు తో, ప్రధాన కూడా ఈ వంటి వ్రాయగలిగిన అవుతుంది

1107
01:08:52,430 --> 01:08:56,870
argc పదాల సంఖ్య argc మరియు argv,

1108
01:08:56,870 --> 01:09:00,020
మీరు మీ ఆదేశ ప్రోగ్రామ్ యొక్క పేరు తర్వాత టైప్ ఆ

1109
01:09:00,020 --> 01:09:03,420
మరియు argv వాస్తవ పదాలు.

1110
01:09:03,420 --> 01:09:07,540
అక్కడ చదరపు బ్రాకెట్లలో సూచించినట్లు మరియు, స్పష్టంగా argv ఒక శ్రేణి.

1111
01:09:07,540 --> 01:09:12,210
ఇది మెమరీ లో ఒక స్ట్రింగ్ తరువాత స్ట్రింగ్ తరువాత స్ట్రింగ్ చేస్తాడు.

1112
01:09:12,210 --> 01:09:16,010
>> కాబట్టి ఈ వంటి ఏదో మనం pset 2 ప్రారంభమయ్యే చేస్తామని చూడాలని ఉంది.

1113
01:09:16,010 --> 01:09:21,350
మనం సోమవారం తిరిగి వచ్చి, మరియు అమలు చేస్తాము ఒక ఉదాహరణ ఇది argv1, చేస్తే

1114
01:09:21,350 --> 01:09:23,370
అది ఇంకా ఏమీ కనిపించడం లేదు అని గుర్తించలేకపోతే.

1115
01:09:23,370 --> 01:09:25,490
ఇది కేవలం తన సొంత పేరు అవ్ట్ ముద్రిస్తుంది.

1116
01:09:25,490 --> 01:09:31,479
కానీ నేను ఈ కార్యక్రమం స్పష్టంగా iterates ఆ వీడ్కోలు తరగతి, ప్రకటన చెప్పుకోవాలంటే

1117
01:09:31,479 --> 01:09:35,479
ప్రాంప్ట్ వద్ద టైప్ చేసిన పదాలను ప్రతి మీద.

1118
01:09:35,479 --> 01:09:41,630
మరియు మేము వినియోగదారును ప్రాంప్ట్ వద్ద టైప్ అని పదాలకు యాక్సెస్ ఉంటుంది మార్గాలుగా

1119
01:09:41,630 --> 01:09:49,160
ప్రధాన (argc, argv) పూర్ణాంకానికి Int ప్రధాన (తప్ప) నుండి ఈ వారాంతంలో ప్రారంభ ప్రధాన మార్చడం ద్వారా ఉంది

1120
01:09:49,160 --> 01:09:52,050
మరియు ఆ విధంగా ఆదేశ పంక్తి వాదనలు జననం ఉంటుంది.

1121
01:09:52,050 --> 01:09:57,100
మరియు ఒకసారి మీరు ఈ వద్ద నిజంగా ఆధునిక పొందండి, మీరు నిజంగా trippy ప్రోగ్రాములను వ్రాయటానికి చేయగలరు

1122
01:09:57,100 --> 01:09:59,610
అటువంటి పైన మరియు దాటి ఇది ఇక్కడ ఈ ఒక,

1123
01:09:59,610 --> 01:10:03,940
కార్యాచరణ యొక్క కొన్ని మేము ఇప్పటివరకు చేసిన కానీ చాలా శక్తివంతమైన చేసిన.

1124
01:10:03,940 --> 01:10:08,950
>> కాబట్టి మేము తెరపై ఈ ఈ చెప్పను, మరియు మేము సోమవారం మీరు చూస్తారు.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]