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

2
00:00:12,410 --> 00:00:12,830
>> DAVID మలన్: అన్ని కుడి.

3
00:00:12,830 --> 00:00:13,370
స్వాగతము.

4
00:00:13,370 --> 00:00:16,510
ఈ CS50 ఉంది, మరియు ఈ ఉంది
వారం ఒక, కంటిన్యూడ్.

5
00:00:16,510 --> 00:00:20,050
కనుక మనం ప్రయాణిస్తున్న చేసిన కారణాలలో ఒకటి
వంటి సాంకేతికతపై

6
00:00:20,050 --> 00:00:24,120
Google గ్లాస్ వారు వచ్చి ఉంటుంది
ఒక API అని పిలుస్తారు ఏదో ఒక

7
00:00:24,120 --> 00:00:25,980
అప్లికేషన్ ప్రోగ్రామింగ్ ఇంటర్ఫేస్.

8
00:00:25,980 --> 00:00:28,830
ఏ అంటే ఉంది
కుడి ఫైళ్లు మరియు కుడి

9
00:00:28,830 --> 00:00:32,850
డాక్యుమెంటేషన్, మీరు నిజంగానే వ్రాయగలరు
ఈ లాంటి పరికరాలను సాఫ్ట్వేర్.

10
00:00:32,850 --> 00:00:36,200
>> అందువలన మేము వైపు మనస్సు లో ఏమి
ఒక ప్రాజెక్ట్ ఉంటే సెమిస్టర్లు ముగింపు ఉంది

11
00:00:36,200 --> 00:00:39,310
Google గ్లాస్, చెప్పటానికి, ఉండవచ్చు పాల్గొన్న
అప్పీల్, మేము లో చెయ్యగలరు చూస్తారు

12
00:00:39,310 --> 00:00:42,220
కొన్ని మీరు hooking పరంగా
loaner హార్డ్వేర్ మరియు

13
00:00:42,220 --> 00:00:46,500
బహిరంగంగా వినియోగించుకోగల API మీరు చెయ్యవచ్చు తద్వారా
నిజానికి సాఫ్ట్వేర్ సృష్టిని ప్రారంభించేందుకు

14
00:00:46,500 --> 00:00:48,630
ఆ అదే Google గ్లాస్ లో నడుస్తుంది.

15
00:00:48,630 --> 00:00:51,710
>> మేము ప్లే చేసిన మరొక పరికరం
మనం అనుకున్నాను ఆలస్యంగా తో

16
00:00:51,710 --> 00:00:53,910
సెమిస్టర్ చివరిలో సరదాగా ఉంటుంది
ఇక్కడ ఈ చిన్న విషయం.

17
00:00:53,910 --> 00:00:56,860
ఇది లీప్ మోషన్ అని, మరియు మీరు ఏమి లో
చూడబోతున్నారు సాంకేతికంగా ఉంది

18
00:00:56,860 --> 00:01:00,280
పరికర కోసం ప్రకటన, కానీ
ఈ ప్రత్యేక ఏమి మాట్లాడలేదు లేదు

19
00:01:00,280 --> 00:01:01,240
పరికర సామర్ధ్యం కలిగి ఉంటుంది.

20
00:01:01,240 --> 00:01:05,550
మరియు అది, చాలా, ద్వారా ఒక API తో వస్తుంది
మీరు సాఫ్ట్వేర్ వ్రాయవచ్చు ఇది

21
00:01:05,550 --> 00:01:10,545
ఒక పద్ధతిలో మీ సొంత కంప్యూటర్ నియంత్రించడానికి
చాలా ఇక్కడ ఈ ఒక నిమిషం చిత్రం ఇష్టం.

22
00:01:10,545 --> 00:01:12,070
>> [వీడియో ప్లేబ్యాక్]

23
00:01:12,070 --> 00:02:08,002

24
00:02:08,002 --> 00:02:08,590
>> [END వీడియో ప్లేబ్యాక్]

25
00:02:08,590 --> 00:02:11,190
>> సో ఇప్పుడు, ఈ పరికరానికి జరుగుతుంది
కొద్దిగా USB వంటి అమలు

26
00:02:11,190 --> 00:02:14,290
మీరు మీ లోకి ప్రదర్శించాడు చేయవచ్చు కనెక్టర్
కంప్యూటర్, కానీ నేను ఆశ్చర్యం కాదు

27
00:02:14,290 --> 00:02:17,930
మేము ఈ రకాల కలిగి దీర్ఘ ముందు ఉంటే
PC లు తరువాతి బ్యాచ్ లో సాంకేతిక

28
00:02:17,930 --> 00:02:20,510
మరియు మాక్స్ మీరు తద్వారా నిజానికి,
దానితో సంకర్షణ

29
00:02:20,510 --> 00:02:21,650
ఆ వంటి పద్ధతిలో.

30
00:02:21,650 --> 00:02:24,250
నిజానికి, నేను ఏ చాలా, నేను ఇష్టం ఆలోచనను
నేను కొద్దిగా ప్రదర్శన ఆగింది

31
00:02:24,250 --> 00:02:25,860
కార్యక్రమం ఈ సాఫ్ట్వేర్ తో వస్తుంది.

32
00:02:25,860 --> 00:02:28,700
నేను కొద్దిగా సెన్సార్ ఉంచిన
నా లాప్టాప్ ముందు.

33
00:02:28,700 --> 00:02:32,420
>> మీరు చూడగలరు గా, ఇది ఇప్పటికే గుర్తిస్తాడు
నా చేతి ఉంది

34
00:02:32,420 --> 00:02:33,400
అది నియంత్రించడానికి.

35
00:02:33,400 --> 00:02:37,900
మరియు అన్ని ఈ అప్లికేషన్ చూపుతాడు
ఈ వంటి swimmingly కొద్దిగా విషయాలు.

36
00:02:37,900 --> 00:02:41,080
కానీ మీరు నిజంగా, ఆ చూడగలరు
నేను అక్కడ ఐదు వేళ్లు కలిగి.

37
00:02:41,080 --> 00:02:44,270
మేము పొందవచ్చు ఉంటే అది అన్ని 10 చేయాలని
మీరు చక్కగా పియానో ​​ఊహించుకోగల

38
00:02:44,270 --> 00:02:45,390
అప్లికేషన్ లేదా ఇష్టపడుతున్నారు.

39
00:02:45,390 --> 00:02:47,820
మీరు తరగతి తర్వాత వచ్చిన అవ్వాలనుకుంటే అయితే
ఆ రోజు మరియు నాటకం

40
00:02:47,820 --> 00:02:49,720
బాగా, మీరు స్వాగతం ఉంటాయి.

41
00:02:49,720 --> 00:02:52,930
సెమిస్టర్ చివరిలో ఆ ఎక్కువ.

42
00:02:52,930 --> 00:02:54,420
>> సో పరిపాలనా ఒక జంట
ప్రకటనలు.

43
00:02:54,420 --> 00:02:58,690
ఒక, ఈ శుక్రవారం విభాగం చేయండి
cs60.net/section వద్ద మధ్యాహ్నం.

44
00:02:58,690 --> 00:03:01,260
ఆ URL కోర్సు యొక్క ఉంది
హోమ్ అలాగే.

45
00:03:01,260 --> 00:03:04,010
ఈ సమయంలో, అయితే, supersections
ఈ ఆదివారం రాబోతున్నాయి.

46
00:03:04,010 --> 00:03:07,800
Supersections, ఒక సమయం విషయం ఉంటాయి
మాకు పని కొంత సమయం పడుతుంది ఎందుకంటే

47
00:03:07,800 --> 00:03:09,470
బయటకు ఎవరు ఇది విభాగంలో మరియు వార్తలు.

48
00:03:09,470 --> 00:03:12,280
>> ఈ రాబోయే ఆదివారం కాబట్టి, అక్కడ ఉంటాం
ఆ తక్కువ సౌకర్యవంతమైన విభాగంలో,

49
00:03:12,280 --> 00:03:14,040
ఆ కోసం ఒక విభాగాన్ని
మరింత సౌకర్యవంతమైన.

50
00:03:14,040 --> 00:03:16,110
మరియు మీరు యొక్క ఆ ఎక్కడా లో
మధ్య వెళ్ళడానికి సంతోషాన్నిస్తుంది

51
00:03:16,110 --> 00:03:17,850
గాని లేదా రెండు లేదా కానీ.

52
00:03:17,850 --> 00:03:19,150
ఈ రెండు చిత్రీకరించారు ఉంటుంది.

53
00:03:19,150 --> 00:03:22,740
వారు కంటే పెద్ద ఆడిటోరియం ఉంటాము
ఒక విభాగంలో సాధారణంగా సైన్ ఉంటుంది

54
00:03:22,740 --> 00:03:26,110
కానీ ఇక్కడ లక్ష్యంతో మీరు సిద్ధం ఉంది
సమస్య కొన్ని సౌకర్యం ఒక సెట్

55
00:03:26,110 --> 00:03:29,910
CS50 ఉపకరణం తో సి, ఈ తో
వారాంతంలో, మీరు కనుగొనేందుకు ముందే మీ

56
00:03:29,910 --> 00:03:31,050
దుస్తులు విభాగం కేటాయింపు.

57
00:03:31,050 --> 00:03:34,700
సో మీరు మీ TF మరియు మీ చిన్న కలుస్తాను
లో sectionmates సమూహం

58
00:03:34,700 --> 00:03:36,350
ఒక వారం యొక్క సమయం.

59
00:03:36,350 --> 00:03:38,200
>> ఆఫీసు గంటల సమయంలో,
జరుగుతున్నాయి.

60
00:03:38,200 --> 00:03:41,020
లేదా రాత్రి వాటిని ప్రయోజనాన్ని చేయండి
మీరు అని రేపు రాత్రి.

61
00:03:41,020 --> 00:03:43,460
సమస్య సెట్ 0 శుక్రవారం కారణం.

62
00:03:43,460 --> 00:03:46,680
ఈ ఒక రోజు తరువాత కంటే
గురువారం రెగ్యులేటరీ షెడ్యూల్.

63
00:03:46,680 --> 00:03:50,410
కానీ సమస్య సెట్ 1, మీరు చూస్తారు
ఇది కొన్ని సన్నాహక కలిగి

64
00:03:50,410 --> 00:03:52,770
వ్యాయామాలు ఇది మీకు మీరే
మీ పొడిగించవచ్చు

65
00:03:52,770 --> 00:03:54,660
శుక్రవారం గురువారం గడువుకు.

66
00:03:54,660 --> 00:03:58,410
సమస్య సెట్ 1, మరోవైపు, రాబోతున్నాయి
కోర్సు యొక్క వెబ్సైట్ ఈ రాబోయే న

67
00:03:58,410 --> 00:04:02,000
శుక్రవారం, మీరు అప్ వలయములుగా చెయ్యాలనుకుంటే
నేను చివరిలో ఒక సమయం మీద ఒకప్పుడు వంటి

68
00:04:02,000 --> 00:04:04,370
మీ గదిలో శుక్రవారం రాత్రి.

69
00:04:04,370 --> 00:04:07,660
>> సో cs50.net/appliance ప్రదేశం పేరు
మీరు CS50 ఉపకరణం పొందవచ్చు

70
00:04:07,660 --> 00:04:09,040
మేము సోమవారం ఉపయోగించడం మొదలుపెట్టానని.

71
00:04:09,040 --> 00:04:10,140
మేము ఒక బిట్ మరింత నేడు అది ఉపయోగించండి.

72
00:04:10,140 --> 00:04:14,040
కానీ మిగిలిన సమస్య 1 సెట్ హామీ
వివరణ ద్వారా మీరు నడిచే

73
00:04:14,040 --> 00:04:16,490
మీరు అవసరం ఖచ్చితంగా దశలను
ఆ అప్ పొందడానికి మరియు రన్ చెయ్యడానికి.

74
00:04:16,490 --> 00:04:22,120
సో ముందు చేయడం గురించి ఆందోళన లేదు
Pset 1 మీరు బదులుగా కాదు అనుకుంటే.

75
00:04:22,120 --> 00:04:22,660
>> అన్ని కుడి.

76
00:04:22,660 --> 00:04:27,180
కాబట్టి మేము, సోర్స్ కోడ్ వద్ద సోమవారం చూసారు
కానీ ఒక కొత్త సందర్భంలో

77
00:04:27,180 --> 00:04:30,895
ప్రోగ్రామింగ్ భాష, అవి C. మరియు C,
స్క్రాచ్ కాకుండా, గ్రాఫికల్ కాదు.

78
00:04:30,895 --> 00:04:32,270
ఇది ముక్కలు పజిల్ కాదు.

79
00:04:32,270 --> 00:04:34,450
ఇది మరింత ఆంగ్ల సింటాక్స్ను వార్తలు.

80
00:04:34,450 --> 00:04:37,140
మరియు చేరి దశలను జంట ఉంది
నిజానికి రాయడం మరియు నడుస్తున్న లో

81
00:04:37,140 --> 00:04:41,650
ఎందుకంటే మూలం పాటు సి కార్యక్రమం,
ఈ వంటి కోడ్, మీరు ఏదో అవసరం

82
00:04:41,650 --> 00:04:42,890
ఒక కంపైలర్ అని.

83
00:04:42,890 --> 00:04:46,682
మరియు లేమాన్ పరంగా, ఏ
ఒక కంపైలర్ మాకు చేస్తుంది?

84
00:04:46,682 --> 00:04:47,650
అవును.

85
00:04:47,650 --> 00:04:51,040
>> STUDENT: ఇది కోడ్ మారుస్తుంది
మీరు 0 సె మరియు 1s వ్రాయండి ఆ.

86
00:04:51,040 --> 00:04:51,151
>> DAVID మలన్: గుడ్.

87
00:04:51,151 --> 00:04:53,580
కనుక ఇది కోడ్ మార్చే
మేము 0 సె మరియు 1s వ్రాయండి.

88
00:04:53,580 --> 00:04:57,730
ఇది అని పిలవబడే సోర్స్ కోడ్ మారుస్తుంది
వస్తువు కోడ్, కనిపిస్తోంది రెండోది

89
00:04:57,730 --> 00:04:59,140
ఈ వంటి ఒక చిన్న ఏదో.

90
00:04:59,140 --> 00:05:02,860
మరియు అది మీ CPU, లోపలి మెదడుల్లో వార్తలు
మీ కంప్యూటర్, ఎందుకంటే యొక్క

91
00:05:02,860 --> 00:05:06,280
ఆ కంప్యూటర్లు ఏర్పరచిన వారికి,
తెలిసిన ఆ శ్రేణులు

92
00:05:06,280 --> 00:05:07,460
0 సె మరియు 1s సగటు యొక్క.

93
00:05:07,460 --> 00:05:08,640
>> దీనికి ముద్రణ అనగా.

94
00:05:08,640 --> 00:05:10,265
దీనికి అదనంగా అంటే.

95
00:05:10,265 --> 00:05:11,610
దీనికి తీసివేత అర్థం.

96
00:05:11,610 --> 00:05:13,350
దీనికి ఒక గ్రాఫిక్ ప్రదర్శించడానికి అర్థం.

97
00:05:13,350 --> 00:05:16,870
బిట్స్ ముందే నమూనాలు ఉన్నాయి
ప్రపంచ అర్థం నిర్ణయించుకున్నట్లు

98
00:05:16,870 --> 00:05:17,700
కొన్ని విషయాలు.

99
00:05:17,700 --> 00:05:20,760
కానీ ఈ కోర్సు లో చాలా భాగం,
మేము అధిక స్థాయిలో పని, మరియు ఉంటాం

100
00:05:20,760 --> 00:05:24,180
ఉన్నాయని మంజూరు కోసం మేము తీసుకుంటాము
ఆ చెయ్యవచ్చు సంకలనం వంటి విషయాలు

101
00:05:24,180 --> 00:05:27,670
మా మూలం కోడ్ ఫంక్షన్ తయారు
విధంగా మేము ఉద్దేశ్యము.

102
00:05:27,670 --> 00:05:31,660
>> కార్యక్రమం కాబట్టి మేము గత వారం మొదటి రాశాడు
మరియు ఆ విధంగా చేయడానికి, పోర్ట్ ప్రారంభమైంది

103
00:05:31,660 --> 00:05:33,920
సి ఈ గత, మాట్లాడటం
సోమవారం, ఇది.

104
00:05:33,920 --> 00:05:35,700
ఆకుపచ్చ జెండా క్లిక్ చేసినప్పుడు, హలో చెప్పండి.

105
00:05:35,700 --> 00:05:37,430
ఈ, కోర్సు యొక్క, ఉంది
స్క్రాచ్ లో వ్రాసిన.

106
00:05:37,430 --> 00:05:40,710
మరియు నేను పేర్కొన్నారు సమానమైన
సి కార్యక్రమం కొద్దిగా చూసారు

107
00:05:40,710 --> 00:05:41,520
ఈ వంటి ఏదో.

108
00:05:41,520 --> 00:05:45,050
>> సో నేను మేము మొదటి వద్ద అలా ఇష్టం ఆలోచన,
వీలు యొక్క మొదటి వద్ద, కనిపిస్తుందో అనేదానికి వేరుగా బాధించటం

109
00:05:45,050 --> 00:05:48,790
చూపులో, ఆమోదం వంటి బొత్తిగా మర్మమైన
వాక్యనిర్మాణం, కానీ మీరు గమనించవచ్చు ప్రారంభించగలరు

110
00:05:48,790 --> 00:05:50,160
చాలా త్వరగా నమూనాలను.

111
00:05:50,160 --> 00:05:53,770
మనం కూడా నేడు చేస్తాను అందించడానికి ఉంది
మీరు కొన్ని మానసిక మోడల్ తో

112
00:05:53,770 --> 00:05:57,280
కానానికల్, కొన్ని ప్రామాణిక నిర్మాణాలు
ప్రోగ్రామింగ్ లో.

113
00:05:57,280 --> 00:06:00,420
ఆపై మేము నిజానికి మా చేతులు పొందుతారు
అలాగే కొన్ని ఉదాహరణలు అనుచిత.

114
00:06:00,420 --> 00:06:04,140
>> సో మీరు యొక్క ఆ కోసం మరింత సౌకర్యవంతమైన,
గుర్తించలేరు ఈ వారం తరువాత

115
00:06:04,140 --> 00:06:05,940
వారం బాగా సమీక్ష ఒక బిట్ కావచ్చు.

116
00:06:05,940 --> 00:06:08,810
కానీ ముఖ్యంగా హ్యాకర్ ఎడిషన్
సమస్య యొక్క సెట్ 1 బయటికి వెళ్తాడు

117
00:06:08,810 --> 00:06:12,330
శుక్రవారం కోర్సు యొక్క వెబ్సైట్, నేను అనుకుంటున్నాను లేదు
మీరు పూర్తి కూడా మీరు ఆ చూడండి

118
00:06:12,330 --> 00:06:15,390
తదుపరి వారం లేదా రెండు, కొంత డమ్మీ
మీరు మరింత పొందడానికి చేస్తాము

119
00:06:15,390 --> 00:06:18,410
సవాలు మరియు ఎదుర్కునే
కొత్త మరియు కొత్త విషయాలు.

120
00:06:18,410 --> 00:06:21,310
>> సో లెట్స్ కాకుండా ఈ కార్యక్రమం బాధించటం
ఒక సమయంలో కొన్ని పంక్తులు.

121
00:06:21,310 --> 00:06:24,140
అగ్రభాగాన, మేము ఏమి కలిగి
సాంకేతికంగా ఒక అని

122
00:06:24,140 --> 00:06:25,950
ప్రాసెసర్ నిర్దేశకం.

123
00:06:25,950 --> 00:06:30,510
ఈ కేవలం అని కోడ్ ఒక లైన్
ఒక ఫైల్ యొక్క కంటెంట్లు చేర్చడానికి,

124
00:06:30,510 --> 00:06:35,080
- ప్రామాణిక I / N, ప్రామాణిక ఇన్పుట్ అని
లేదా, క్షమించండి, ప్రామాణిక I / O, ప్రామాణిక

125
00:06:35,080 --> 00:06:38,670
ఇన్పుట్ / అవుట్పుట్. h, లోపల
నా సొంత కార్యక్రమం.

126
00:06:38,670 --> 00:06:41,670
>> నేను ఈ రాశారు కాబట్టి ఇతర పదాలు లో, ఉంటే
వంటి సాధారణ టెక్స్ట్ ఎడిటర్ తో కార్యక్రమం

127
00:06:41,670 --> 00:06:45,260
gedit యొక్క సులభమైన సమానమైన
Microsoft Word వంటి ఏదో

128
00:06:45,260 --> 00:06:50,970
బోధన # stdio.h ఉన్నాయి, కేవలం
కంపైలర్ చెప్పడానికి వెళుతున్న, పట్టుకోడానికి

129
00:06:50,970 --> 00:06:56,080
ఇతర ఫైల్, stdio.h, విషయాలు
మరియు కుడి ఇక్కడ పెట్టండి.

130
00:06:56,080 --> 00:06:57,090
>> ఇప్పుడు, నేను శ్రద్ధ లేదు?

131
00:06:57,090 --> 00:07:01,850
మేము ఈ ఫైలు యొక్క లోపల ఏమిటి క్లెయిమ్ చేయలేదు
నిల్వ ఇది stdio.h, అని

132
00:07:01,850 --> 00:07:05,490
ఎక్కడా నా హార్డు డ్రైవు, లేదా ఈ లో
కేసు, ఎక్కడా CS50 ఉపకరణం లో?

133
00:07:05,490 --> 00:07:06,635
ఎవరో నాకు అక్కడ అది చాలు.

134
00:07:06,635 --> 00:07:09,910
కానీ అది ఏమిటి?

135
00:07:09,910 --> 00:07:13,020
>> అవును, కాబట్టి అది ఒక ప్రకటన
ఒక ఫంక్షన్ printf అని.

136
00:07:13,020 --> 00:07:17,400
సో printf ఆ ఫంక్షన్ గుర్తు
డిస్ప్లేలు పదాలు మరియు అక్షరాలు మరియు

137
00:07:17,400 --> 00:07:20,160
నా వేలం వద్ద తెరపై సంఖ్యలు.

138
00:07:20,160 --> 00:07:21,220
కానీ నేను వ్రాయుటకు లేదు.

139
00:07:21,220 --> 00:07:22,230
CS50 వ్రాయుటకు లేదు.

140
00:07:22,230 --> 00:07:26,990
ఎవరైనా సంవత్సరాల క్రితం రాసింది, మరియు వారు
ముఖ్యంగా మాకు అది రెసిపీ ఇచ్చింది

141
00:07:26,990 --> 00:07:29,110
stdio.h అనే ఫైల్ లో.

142
00:07:29,110 --> 00:07:33,240
తద్వారా మొదటి రేఖ నాకు యాక్సెస్ ఇస్తుంది
విధులు ఆ ఎవరో

143
00:07:33,240 --> 00:07:36,500
మధ్య, సంవత్సరాల క్రితం రాశాడు
ఇది printf ఉన్నాయి.

144
00:07:36,500 --> 00:07:39,450
>> ఇప్పుడు, తదుపరి లైన్ నా వేవ్ వెళుతున్నాను
చేతి కనీసం వచ్చే వారం వరకు, వద్ద.

145
00:07:39,450 --> 00:07:43,620
కానీ ఇప్పుడు కోసం, తెలిసిన Int ప్రధాన (శూన్యమైన) ఉంది
ఈ ముఖ్యమైన సమానమైన

146
00:07:43,620 --> 00:07:46,310
పసుపు పజిల్ ముక్క ఉన్నప్పుడు
ఆకుపచ్చ జెండా క్లిక్.

147
00:07:46,310 --> 00:07:49,510
ప్రపంచ సంవత్సరాల క్రితం, నిర్ణయించుకున్నారు ఉంటే
మీరు ఒక ప్రోగ్రామ్ రాస్తున్నాం

148
00:07:49,510 --> 00:07:53,150
సి, మీరు మొదలు అని భాష
ఒక లైన్ తో మీ కార్యక్రమం

149
00:07:53,150 --> 00:07:54,410
ఆ కనిపిస్తుంది.

150
00:07:54,410 --> 00:07:57,650
కేవలం ఒక వారం యొక్క సమయం లో, అది చేస్తాము
భావం ఏమి Int నిరర్ధకమయినది ఏమి ఉంది.

151
00:07:57,650 --> 00:08:00,840
కానీ ఇప్పుడు కోసం, కేవలం ఆలోచించి
ఈ పసుపు పజిల్ ముక్కలుగా.

152
00:08:00,840 --> 00:08:04,550
>> ఇప్పుడు తదుపరి, మేము తర్వాత ఒక గిరజాల జంట కలిగి
మరొక దగ్గరగా గిరజాల జంట ద్వారా,

153
00:08:04,550 --> 00:08:05,240
మాట్లాడటానికి.

154
00:08:05,240 --> 00:08:07,430
మరియు మేము ఈ మొత్తం చూస్తారు
సి కార్యక్రమాలు, అలాగే

155
00:08:07,430 --> 00:08:08,930
జావాస్క్రిప్ట్ మరియు PHP.

156
00:08:08,930 --> 00:08:11,345
మరియు ఈ కేవలం టూకీగా
కోడ్ యొక్క సంబంధిత పంక్తులు.

157
00:08:11,345 --> 00:08:14,600
ఓపెన్ గిరజాల జంట తప్పనిసరిగా
, ఇక్కడ కొన్ని కోడ్ వస్తుంది చెప్పారు.

158
00:08:14,600 --> 00:08:17,590
మరియు ఇది మూసి గిరజాల కలుపు,
ఇతర దిశలో వంగి, కేవలం

159
00:08:17,590 --> 00:08:19,920
మాధ్యమంగా, అంతే
సంబంధిత కోడ్.

160
00:08:19,920 --> 00:08:22,970
>> సో ఈ మొదటి లో జూసీ లైన్
కార్యక్రమం, గత, printf ఉంది

161
00:08:22,970 --> 00:08:25,080
కోట్-unquote, ప్రపంచ హలో.

162
00:08:25,080 --> 00:08:30,670
మరియు నేను మధ్య విషయం అని
కోట్స్ ఏమి చివరిసారి?

163
00:08:30,670 --> 00:08:31,285
కనుక ఇది ఒక స్ట్రింగ్ యొక్క.

164
00:08:31,285 --> 00:08:35,309
మరియు ఒక స్ట్రింగ్ కేవలం techie ఉంది
ఒక క్రమం పదం

165
00:08:35,309 --> 00:08:37,169
అక్షరాలు, ఒక పదం, ఒక పదబంధం.

166
00:08:37,169 --> 00:08:39,380
ఒకే లేఖ అనుకొనుట
డబుల్ కోట్.

167
00:08:39,380 --> 00:08:41,840
కానీ సున్నా క్రమంలో వార్తలు
అక్షరాలు లేదా ఎక్కువ.

168
00:08:41,840 --> 00:08:43,650
>> బాక్ స్లాష్-n, అయితే, ఉంది
ఒక బిట్ వింత.

169
00:08:43,650 --> 00:08:46,290
కానీ అది కేవలం ఏదో అర్థం
కంప్యూటర్ సాధారణ.

170
00:08:46,290 --> 00:08:48,060
బాక్ స్లాష్-n ఏమిటి?

171
00:08:48,060 --> 00:08:48,570
కొత్త లైన్.

172
00:08:48,570 --> 00:08:52,490
తద్వారా కేవలం ప్రత్యేక శ్రేణి యొక్క
ప్రపంచ నిర్ణయించింది అక్షరాలు

173
00:08:52,490 --> 00:08:56,880
అంటే, కుడి అక్కడ ఒక లైన్ బ్రేక్ చాలు
కంపైలర్ నిజానికి పొందుతారు ఎందుకంటే

174
00:08:56,880 --> 00:09:02,280
చాలా, మీరు, సాధారణంగా, గందరగోళం
అర్థవంతమైన, కానీ తప్పుగా, కేవలం

175
00:09:02,280 --> 00:09:04,570
ఉంచాలి ఎంటర్ కొట్టడం మొదలు
మీ కోడ్ లో కొత్త మార్గాల.

176
00:09:04,570 --> 00:09:07,150
మీరు కొద్దిగా మరింత ఉండాలి
బాక్ స్లాష్-n తో స్పష్టమైన.

177
00:09:07,150 --> 00:09:10,540
>> మరియు మేము కొన్ని ఇతర ఉంది చూస్తారు
ప్రత్యేక అక్షరాలు కోసం నమూనాలు.

178
00:09:10,540 --> 00:09:14,340
ఉదాహరణకు, మీరు కోరుకుంటే చేయడానికి మీ
ఒక మూలలో కేసు తిరుగు చూసుకొని

179
00:09:14,340 --> 00:09:18,080
నేను ఒక ప్రింట్ కోరుకున్నాడు ఊహించు
స్క్రీన్ మీద డబుల్ కోట్

180
00:09:18,080 --> 00:09:21,840
సంసార కారణం, ఆ అనిపించవచ్చు
కొద్దిగా ఇబ్బందులు హక్కు?

181
00:09:21,840 --> 00:09:24,990
ఎందుకంటే నేను ఒక డబుల్ కోట్ చాలు ఉంటే
మధ్యలో "హలో, ప్రపంచం," సంసార కోసం

182
00:09:24,990 --> 00:09:30,120
కారణం, ఎందుకు అని అనిపించడం లేదు
శక్తివంతమైన సమస్యాత్మక?

183
00:09:30,120 --> 00:09:32,180
అది స్ట్రింగ్ తొలగిస్తుంది.

184
00:09:32,180 --> 00:09:34,700
>> కంపైలర్ కేవలం ఒక కార్యక్రమం.

185
00:09:34,700 --> 00:09:37,210
ఒక కంపైలర్ వంటి ఒక ప్రోగ్రామ్ కేవలం వెళ్తున్నారు
దిగువ మీ కోడ్ టాప్ చదవడానికి,

186
00:09:37,210 --> 00:09:37,990
ఎడమ.

187
00:09:37,990 --> 00:09:41,850
మరియు ఉంటే బదులుగా మూడు డబుల్ కోట్స్ చూస్తుంది
రెండు, తెలిసిన మాత్రం కాదు

188
00:09:41,850 --> 00:09:45,210
మీరు దీనిని ఉంటే ఎడమ విషయం
స్ట్రింగ్, లేదా విషయం ఉండాలి

189
00:09:45,210 --> 00:09:46,570
కుడి, లేదా మొత్తం విషయం.

190
00:09:46,570 --> 00:09:50,560
ఇది సందిగ్ధంగా ఉంది, మరియు సాధారణ కాబట్టి ఏమి ఒక
కంపైలర్ అని కేవలం బయటకు ఫ్రీక్ ఉంది,

191
00:09:50,560 --> 00:09:53,710
మరియు మీరు కొన్ని లోపం సందేశాన్ని ఇవ్వాలని, మరియు
మీరు సమస్యను డీల్.

192
00:09:53,710 --> 00:09:58,120
>> సో బాక్ స్లాష్-n ఒక కొత్త అర్థం ఇవ్వడం
లైన్, ఇప్పుడు నీ కోరికలు చేస్తాను

193
00:09:58,120 --> 00:10:02,610
మీరు కూడా కోరుకుంటే అని మొదలు
డబుల్ వంటి అసాధారణ ఏదో

194
00:10:02,610 --> 00:10:06,210
ఈ లేకపోతే కోటెడ్ లోపలి కోట్
స్ట్రింగ్?

195
00:10:06,210 --> 00:10:07,640
బాక్ స్లాష్-డబుల్ కోట్.

196
00:10:07,640 --> 00:10:09,630
అందువలన మేము ఈ చూస్తారు
చాలా నమూనా రకం.

197
00:10:09,630 --> 00:10:12,490
>> మీరు కొద్దిగా చేయాలని ఉంటే
వింత, మీరు చూడండి అని

198
00:10:12,490 --> 00:10:15,060
పరిష్కారాలను తరచుగా ఒక నమూనా అనుసరించండి,
మరియు బాక్ స్లాష్

199
00:10:15,060 --> 00:10:17,150
ఒక ఎస్కేప్ సీక్వెన్స్ సూచిస్తుంది.

200
00:10:17,150 --> 00:10:20,320
మరియు అది కేవలం ప్రత్యేక అర్ధం
మేము ఒక ప్రాతినిథ్యం అవసరం

201
00:10:20,320 --> 00:10:21,060
భిన్నంగా.

202
00:10:21,060 --> 00:10:23,830
మీరు ప్రతిబింబించవు ఎలా కొరకు
బాక్ స్లాష్, బాగా, మేము చేస్తాము

203
00:10:23,830 --> 00:10:24,550
ఆ తిరిగి వస్తాయి.

204
00:10:24,550 --> 00:10:26,930
కానీ సమాధానం, చాలా, నిజానికి ఉంది
ఒక బిట్ స్పష్టమైన.

205
00:10:26,930 --> 00:10:31,080
>> సో యొక్క కొన్ని ఇతర పరిచయం తెలపండి
ప్రోగ్రామింగ్ నిర్మాణాలు

206
00:10:31,080 --> 00:10:31,915
మీరు స్క్రాచ్ లో జరిగింది.

207
00:10:31,915 --> 00:10:34,790
మీరు బహుశా మంజూరు కోసం తీసుకున్నారు
మీరు ఇప్పటికే లోకి dived చేసిన ఇప్పటికే ఉంటే

208
00:10:34,790 --> 00:10:36,060
సమస్య 0 సెట్.

209
00:10:36,060 --> 00:10:40,950
కానీ ప్రస్తుతం సి సింటెక్స్ పరిచయం తెలపండి
ఈ లేకపోతే బొత్తిగా సులభంగా కోసం

210
00:10:40,950 --> 00:10:42,300
ఆలోచనలు, వాటిని కనీసం కొన్ని.

211
00:10:42,300 --> 00:10:45,570
>> సో ఈ పరిస్థితిని భావన లేదా
ఒక శాఖ, అయితే గతంలో మేము

212
00:10:45,570 --> 00:10:49,330
కనిపిస్తున్నాడు కోడ్ తో ప్రాతినిధ్యం
స్క్రాచ్ ఎడమ వైపున ఈ వంటి -

213
00:10:49,330 --> 00:10:52,200
x y కంటే తక్కువ ఉంటే, అప్పుడు చెప్పడానికి -

214
00:10:52,200 --> 00:10:56,760
బదులుగా ప్రస్తుతం సి లో - నాకు మెరుగుపరచుకోవడం వీలు
సులభంగా లో -

215
00:10:56,760 --> 00:11:01,235
, తెరిస్తే మేము కేవలం, చెప్పటానికి చేయబోతున్నామని
కుండలీకరణములలో, ఏదో నిజం - ఒక

216
00:11:01,235 --> 00:11:04,190
బూలియన్ వ్యక్తీకరణ వెళ్ళడానికి వెళ్తున్నారు
నేను పరిస్థితి చెప్పారు పేరు -

217
00:11:04,190 --> 00:11:08,170
దగ్గరగా కుండలీకరణములలో, అప్పుడు ఏమి చెయ్యాలి
ఆ గిరజాల కలుపులు లోపలి.

218
00:11:08,170 --> 00:11:11,020
>> ఇక్కడ, చాలా, గిరజాల కలుపులు
స్క్రాచ్ యొక్క వంటి రకమైన ఉన్నాయి

219
00:11:11,020 --> 00:11:12,460
U-ఆకారంలో పజిల్ ముక్కలు.

220
00:11:12,460 --> 00:11:14,890
ఈ గిరజాల కలుపులు లోపల ఏమి లేదు.

221
00:11:14,890 --> 00:11:16,790
ఈ సందర్భంలో, స్లాష్ స్లాష్.

222
00:11:16,790 --> 00:11:19,720
మరియు ఈ ఒక ముందుకు ఉంది గమనించవచ్చు
, ఒక బాక్ స్లాష్ స్లాష్.

223
00:11:19,720 --> 00:11:21,440
ఫార్వర్డ్, ముందుకు స్లాష్, స్లాష్
ప్రోగ్రామ్ చేసిన వారికి

224
00:11:21,440 --> 00:11:23,370
ముందు, కేవలం అర్థం -

225
00:11:23,370 --> 00:11:24,190
ఇది కేవలం ఒక వ్యాఖ్యను వార్తలు.

226
00:11:24,190 --> 00:11:26,630
ఒక వ్యాఖ్యను లైన్ కాదు
కోడ్ యొక్క, కేవలంగా.

227
00:11:26,630 --> 00:11:30,200
ఇది మీరు, ఆంగ్ల ఒక లైన్
మానవ, మీరే వ్రాసిన చేశారు

228
00:11:30,200 --> 00:11:33,540
బహుశా కు, ఏదో చేయాలని మీరు గుర్తు
కు వివరించడానికి, మీకు వివరించడానికి

229
00:11:33,540 --> 00:11:35,260
ఎవరో, మీ కోడ్ ఏమి ఉంది.

230
00:11:35,260 --> 00:11:37,050
ఇది కేవలం ఒక వివరణాత్మక కామెంట్స్.

231
00:11:37,050 --> 00:11:40,880
>> ఇప్పుడు, కోర్సు యొక్క, మేము ఒక రెండు మార్గం కలిగి
ఒక, ఈ చేయడం ద్వారా రోడ్డు FORK

232
00:11:40,880 --> 00:11:43,930
చేయడం ద్వారా రహదారి మూడు మార్గం fork
ఈ, మరియు మీరు ఈ కొనసాగితే

233
00:11:43,930 --> 00:11:47,570
నమూనా, మీరు, నాలుగు విధంగా చేయవచ్చు
రోడ్డు ఐదు మార్గం, ఆరు మార్గం ఫోర్కులు ఉంటే

234
00:11:47,570 --> 00:11:50,150
మీరు, వాస్తవానికి, నిర్వహించడానికి అవసరం
అనేక పరిస్థితులు.

235
00:11:50,150 --> 00:11:52,010
మరియు ఇక్కడ సమాంతరత గమనించవచ్చు -

236
00:11:52,010 --> 00:11:55,070
, వేరే (పరిస్థితి) ఉంటే, (పరిస్థితి) ఉంటే
మరియు ఒక లిటిల్ మాత్రమే

237
00:11:55,070 --> 00:11:58,010
వింత ఇది గత ఉంది
ఆ else ఉంది.

238
00:11:58,010 --> 00:12:01,170
కానీ మళ్ళీ, ఈ ఒకేరకంగా ఉంటుంది,
సందర్భానుసారంగా, మేము పూర్తి చేసిన దానికి

239
00:12:01,170 --> 00:12:04,690
ఇప్పటికే, అయినప్పటికీ సింటాక్స్ అవుతుంది
ఉపయోగించే విధానం కొద్దిగా పడుతుంది.

240
00:12:04,690 --> 00:12:07,730
>> ఇప్పుడు, ఈ ఉదాహరణలో, ఉన్నాయి
కొన్ని ఇతర వింత సింటాక్స్.

241
00:12:07,730 --> 00:12:11,220
మేము,, printf మళ్ళీ ఓపెన్ కుండలీకరణములలో చూడండి
మరియు దగ్గరగా కుండలీకరణములలో.

242
00:12:11,220 --> 00:12:13,190
మరియు లోపల ఉంది
కోట్ స్ట్రింగ్.

243
00:12:13,190 --> 00:12:17,060
సందర్భంలో బ్రాకెట్లు
printf యొక్క, ఎడమ న వెళ్ళి

244
00:12:17,060 --> 00:12:18,160
మరియు కుడి ఏమి?

245
00:12:18,160 --> 00:12:22,190
మేము కోట్ అని వివరిస్తాయి లేదు
మరింత సాధారణంగా స్ట్రింగ్?

246
00:12:22,190 --> 00:12:23,320
>> కనుక ఇది ఒక వాదన ఉంది.

247
00:12:23,320 --> 00:12:26,620
ఏ సమయంలోనైనా వంటి, ఒక ఫంక్షన్ కలిగి
printf, ఆపై ఒక ఓపెన్ బ్రాకెట్ మరియు ఒక

248
00:12:26,620 --> 00:12:30,330
లోపలి దగ్గరగా బ్రాకెట్ మరియు ఏదో
ఇది, అని ఒక స్ట్రింగ్, లేదా ఒక

249
00:12:30,330 --> 00:12:34,420
పూర్ణాంక, లేదా మరేదైనా, విషయం లో
ఆ బ్రాకెట్ల అంటారు మధ్య

250
00:12:34,420 --> 00:12:35,110
ఒక వాదన.

251
00:12:35,110 --> 00:12:37,910
>> మరియు ఒక వాదన కేవలం ప్రభావితం
ఫంక్షన్ యొక్క ప్రవర్తన.

252
00:12:37,910 --> 00:12:39,990
ఈ సందర్భంలో, అది చాలా స్పష్టత ఉంది.

253
00:12:39,990 --> 00:12:44,480
x <y, లో ఆమోదించింది చేయబడిన ఏమిటి
కాబట్టి ఒక వాదన వంటి, మాట్లాడటం.

254
00:12:44,480 --> 00:12:47,720
మరియు printf కానుంది
సరిగ్గా ఆ ప్రింట్.

255
00:12:47,720 --> 00:12:51,590
తప్పనిసరిగా, వ్యక్తి సంవత్సరాల క్రితం ఎందుకంటే
ఈయన printf ఆలోచన అమలు

256
00:12:51,590 --> 00:12:55,000
మేము మానవ వారసులు ఉన్నారు ఏమి
కోసం printf ఉపయోగించడానికి వెళుతున్న.

257
00:12:55,000 --> 00:12:58,610
వాదనలు ఉన్నాయి ఎందుకు అలా ఆ, వార్తలు
ఒక ఫంక్షన్ యొక్క తరువాత ప్రవర్తన ప్రభావితం

258
00:12:58,610 --> 00:12:59,450
వ్రాయబడ్డాయి.

259
00:12:59,450 --> 00:13:00,780
>> ఇప్పుడు, బూలియన్ వ్యక్తీకరణ.

260
00:13:00,780 --> 00:13:02,470
మేము స్క్రాచ్ ముందు ఈ చూసిన.

261
00:13:02,470 --> 00:13:06,680
ఇది C లో మీరు కూడా చెయ్యవచ్చు బయటకు వచ్చాడు "లేదా"
కలిసి వారిని, మాట్లాడటానికి.

262
00:13:06,680 --> 00:13:10,930
రెండు నిలువు బార్లు అనగా ఈ బ్లాక్
కోడ్ యొక్క ఈ దీన్ని అందిస్తాడు

263
00:13:10,930 --> 00:13:15,350
మొదటి పరిస్థితి నిజమైతే అమలు
లేదా రెండవ పరిస్థితి వర్తిస్తుంది.

264
00:13:15,350 --> 00:13:17,710
మరియు మీరు పూర్తి కాకపోవచ్చు అయినప్పటికీ
ఈ స్క్రాచ్ లో, మీరు నిజంగా అనుకొనుట

265
00:13:17,710 --> 00:13:20,580
స్క్రాచ్ లో దీన్ని, మరియు మీరు చేయవచ్చు
విభిన్నంగా మీ వ్యక్తం -

266
00:13:20,580 --> 00:13:25,300
ఉంటే మొదటి పరిస్థితి మరియు రెండవ
పరిస్థితి నిజమైన అప్పుడు ఏమి చెయ్యాలి

267
00:13:25,300 --> 00:13:27,160
గిరజాల కలుపులు లోపలి.

268
00:13:27,160 --> 00:13:31,210
>> మరియు కేవలం ఒక పక్కన, కారణం ఇది
డబుల్ ఆంపర్సండ్ చిహ్నం మరియు ఒక డబుల్

269
00:13:31,210 --> 00:13:34,610
నిలువు బార్, మేము చివరికి చూస్తారు
ఒక వర్టికల్ బార్ మరియు ఒక

270
00:13:34,610 --> 00:13:38,710
ఒకే ఆంపర్సండ్ చిహ్నం నిజానికి వేర్వేరు
ఇప్పుడు కోసం సో C. లో అర్థం,

271
00:13:38,710 --> 00:13:41,840
చిహ్నాలు యొక్క నకలు
కావాలని ఉంది.

272
00:13:41,840 --> 00:13:45,070
>> సో, క్లుప్తంగా, యొక్క పరిచయం తెలపండి
సింటెక్స్ ఈ ఇతర బిట్.

273
00:13:45,070 --> 00:13:48,940
ఈ చాలా కొనసాగుతుంది లేదు
మొదటి, కానీ నేను క్లెయిమ్ నేను ఆ

274
00:13:48,940 --> 00:13:55,190
ఒకవేళ ఒక ఉంటే else యొక్క భావన అమలు
వేరే వేరే ఉంటే, వేరే ప్రకటన ఉపయోగించి ఉంటే

275
00:13:55,190 --> 00:13:56,760
ఏదో ఒక స్విచ్ ప్రకటన అని.

276
00:13:56,760 --> 00:14:00,820
మరియు ఈ నిజంగా ఉంది మాత్రమే కారణం
కేవలం, ప్రోగ్రామర్ మీరు ఇవ్వాలని ఉంది, ఒక

277
00:14:00,820 --> 00:14:05,470
కొన్ని పరిష్కార కొద్దిగా భిన్నంగా
సమస్య, అయినప్పటికీ తార్కికంగా ఇది

278
00:14:05,470 --> 00:14:07,340
మీరు ఏ కొత్త సామర్థ్యాలు ఇవ్వదు.

279
00:14:07,340 --> 00:14:08,530
>> ద్వారా నేను ఈ అర్థం.

280
00:14:08,530 --> 00:14:13,330
మీరు స్విచ్, మరియు ఆపై ఖాళీని, చెప్పినప్పుడు
ఆపై వక్ర ఒక జత, లోపల

281
00:14:13,330 --> 00:14:14,570
ఇది ఒక వ్యక్తీకరణ వెళ్తాడు -

282
00:14:14,570 --> 00:14:18,010
మరియు ఈ కొద్దిగా కాని స్పష్టమైన కావచ్చు
, మొదటి, కానీ ఈ వాదన కాదు

283
00:14:18,010 --> 00:14:20,680
సాంకేతికంగా, ఎందుకంటే స్విచ్
ఒక క్రియ కాదు.

284
00:14:20,680 --> 00:14:24,230
కాబట్టి ఇప్పుడు కోసం, మేము ఉపయోగించే భావించేందుకు
వివిధ ప్రదేశాల్లో కుండలీకరణాలు

285
00:14:24,230 --> 00:14:25,250
వివిధ కారణాల కోసం.

286
00:14:25,250 --> 00:14:29,310
>> సో వ్యక్తీకరణ మీద స్విచ్ నేను అర్థం
వారిలో వేరియబుల్ లోపల ఉంచాలి

287
00:14:29,310 --> 00:14:31,350
ఇది వ్యక్తీకరణ చెప్పినట్లు వక్ర.

288
00:14:31,350 --> 00:14:33,090
మరియు ఆ వేరియబుల్ ఉంటే -

289
00:14:33,090 --> 00:14:35,400
ఇది x అని అనుకుంటే, మరియు
ఇది కేవలం ఒక పూర్ణాంకం యొక్క -

290
00:14:35,400 --> 00:14:38,900
నేను నా స్లయిడ్ లో వివరించినప్పుడు చేయవచ్చు
ఈ వంటి ఇక్కడ ఏదో.

291
00:14:38,900 --> 00:14:41,690
X నా వేరియబుల్ ఉంది, మరియు నేను ఉంటే
ఏదో చేయాలని అనుకుంటే x

292
00:14:41,690 --> 00:14:43,480
1 సమానం, నేను ఆ చేయవచ్చు.

293
00:14:43,480 --> 00:14:46,660
>> నేను బదులుగా చేయాలని ఉంటే
x 2 ఉంటే, నేను ఆ చేయవచ్చు.

294
00:14:46,660 --> 00:14:50,390
వేరే నేను ఏదో చేయాలని అనుకుంటే
పూర్తిగా, నేను ఒక డిఫాల్ట్ సందర్భంలో ఉండవచ్చు

295
00:14:50,390 --> 00:14:52,750
ఈ సందర్భంలో నేను ఈ ఇతర పనిని.

296
00:14:52,750 --> 00:14:58,730
ఈ కోణంలో చూస్తే, అది ఒక సమానం వార్తలు
x, ఉంటే else వేరే 1 సమానం సమానం ఉంటే

297
00:14:58,730 --> 00:15:01,150
కానీ ఇప్పుడు ఈ చెప్పలేదు కనుక
మేము మళ్ళీ చూస్తారు.

298
00:15:01,150 --> 00:15:03,720
కానీ ఇప్పుడు కోసం, కేవలం ఇది ఉంది తెలుసు.

299
00:15:03,720 --> 00:15:04,220
>> అన్ని కుడి.

300
00:15:04,220 --> 00:15:07,660
సో ఈ గత జంట కొద్దిగా ఎక్కువ
మొదటి చూపులో సంక్లిష్టంగా, కానీ అవి అలా

301
00:15:07,660 --> 00:15:09,385
చాలా సులభంగా ఏదో.

302
00:15:09,385 --> 00:15:14,410
సి లో లూప్ ఒక కోడ్ ఒక భాగం అని
కేవలం మళ్ళీ ఏదో చేస్తుంది మరియు

303
00:15:14,410 --> 00:15:15,330
మళ్ళీ మళ్ళీ.

304
00:15:15,330 --> 00:15:17,590
మరియు దాని గురించి మాత్రమే బాధించే విషయం
అది కొద్దిగా నిగూఢ ఆ ఉంది

305
00:15:17,590 --> 00:15:21,380
ఈ చక్రీయ మీరు వ్యక్తపరచటానికి
న నమూనా, కానీ ప్రపంచ ప్రామాణిక

306
00:15:21,380 --> 00:15:22,450
కింది విధంగా.

307
00:15:22,450 --> 00:15:25,760
>> మీరు లూప్ ఒక ఉపయోగించినప్పుడు, మీరు వచ్చింది చేసిన
మళ్ళీ వక్ర ఒక జత.

308
00:15:25,760 --> 00:15:27,570
మరియు రెండు సెమికోలన్లు గమనించవచ్చు
అక్కడ.

309
00:15:27,570 --> 00:15:34,380
మూడు వేర్వేరు ఆ రెండు సెమికోలన్లు
లోపలి భిన్న భావాలు

310
00:15:34,380 --> 00:15:35,020
వక్ర.

311
00:15:35,020 --> 00:15:37,170
అని పిలవబడే initializations ఉంది.

312
00:15:37,170 --> 00:15:38,830
అని పిలవబడే పరిస్థితి.

313
00:15:38,830 --> 00:15:40,210
మరియు ఒక అని పిలవబడే నవీకరణలను ఉంది.

314
00:15:40,210 --> 00:15:43,240
>> సంగ్రహంగా చూశారు, ఇది
పూర్తిగా కాని స్పష్టమైన, కాబట్టి యొక్క చూద్దాం

315
00:15:43,240 --> 00:15:44,630
ఒక కాంక్రీట్ ఉదాహరణకు వద్ద.

316
00:15:44,630 --> 00:15:46,720
స్క్రాచ్ లో మేము తిరిగి బ్లాక్ కలిగి.

317
00:15:46,720 --> 00:15:50,670
మరియు ఈ బ్లాక్ చెప్పటానికి, 10 సార్లు పునరావృతం అన్నారు
"హలో, ప్రపంచం." నాకు క్లెయిమ్ లెట్

318
00:15:50,670 --> 00:15:53,810
ఇప్పుడు, మరియు మేము ఈ తిరిగి వచ్చి, మరియు ఉంటాం
ఈ, చాలా, ఎక్కువ బాగా ఉంటుంది

319
00:15:53,810 --> 00:15:57,345
ముందు కాలం మీరు సమానమైన సి
కోడ్ ఈ చెప్పబడుతుంది చేయవచ్చు -

320
00:15:57,345 --> 00:16:02,320
ప్రకటన మరియు ఒక స్పేస్, ఒక జత కోసం ఒక
బ్రాకెట్లు లో సెమికోలన్లు గమనించవచ్చు

321
00:16:02,320 --> 00:16:05,730
అక్కడ, ఇది మూడు విభిన్న వేరు
విషయాలు, ప్రారంభ,

322
00:16:05,730 --> 00:16:07,320
పరిస్థితి, మరియు నవీకరణ.

323
00:16:07,320 --> 00:16:08,840
>> మరియు ఒక అంచనా పడుతుంది ఏమి
మొదటి చేస్తోంది.

324
00:16:08,840 --> 00:16:10,690
Int i = 0.

325
00:16:10,690 --> 00:16:15,120
కఠినమైన లేమాన్ నియమాల్లో, ఏమిటి
మాకు చేయడం ఆ, బహుశా?

326
00:16:15,120 --> 00:16:15,590
Yeah సో.

327
00:16:15,590 --> 00:16:19,630
, నేను దీనిని ఒక వేరియబుల్ ప్రకటించారు లో
మరియు అది ఏ విలువ ఇవ్వడం లో?

328
00:16:19,630 --> 00:16:20,220
0.

329
00:16:20,220 --> 00:16:24,280
సో దీనిని ఒక వేరియబుల్ సృష్టించడం లో
నేను, అది విలువ 0 నిల్వ.

330
00:16:24,280 --> 00:16:26,420
అని పిలవబడే ప్రారంభ వార్తలు.

331
00:16:26,420 --> 00:16:29,360
>> అన్ని కుడి, ఇప్పుడు నేను ముందు పేర్కొన్నారు
మధ్య విషయం, నేను

332
00:16:29,360 --> 00:16:31,760
<10, పరిస్థితి.

333
00:16:31,760 --> 00:16:32,730
సో ఏమి ఉంది?

334
00:16:32,730 --> 00:16:36,560
బాగా, ఏమి కోసం లూప్ చేసినప్పుడు ఒక చేస్తుంది
లూప్ ఒక కార్యక్రమాన్ని అమలు ఉంది, ఉంది

335
00:16:36,560 --> 00:16:41,050
కంప్యూటర్ ద్వారా నడుస్తుంది ప్రతిసారీ
ఈ లూప్, పైనుంచి, టాప్

336
00:16:41,050 --> 00:16:43,740
కేవలం మీరు అబ్బాయిలు వంటి క్రింది, చేసుకుంది
yourselves లెక్కింపు మరియు, కూర్చొని

337
00:16:43,740 --> 00:16:47,090
మళ్ళీ మళ్ళీ మళ్ళీ,
కంప్యూటర్ వెళ్తున్నారు

338
00:16:47,090 --> 00:16:48,560
ఆ పరిస్థితి తనిఖీ.

339
00:16:48,560 --> 00:16:51,140
మరియు, నేను కంటే తక్కువ 10 ఉంటే
మళ్ళీ చేయును.

340
00:16:51,140 --> 00:16:53,100
I కంటే తక్కువ 10, ఉంటే
మళ్ళీ చేయును.

341
00:16:53,100 --> 00:16:55,030
I కంటే తక్కువ పది, ఉంటే
మళ్ళీ చేయును.

342
00:16:55,030 --> 00:16:57,330
సూచించినట్టు కనిపిస్తుంది కనుక
ఆశాజనక నేను మారుతుంది.

343
00:16:57,330 --> 00:16:59,010
లేకపోతే, మేము ఒక అనంతమైన లూప్ కలిగి ఇష్టం.

344
00:16:59,010 --> 00:17:02,590
ఎందుకంటే నిజానికి, నేను, మారుతున్న
సెమికోలన్ తర్వాత గత విషయము

345
00:17:02,590 --> 00:17:05,569
నేను + + యొక్క కొంతవరకు నిగూఢ వాక్యనిర్మాణం.

346
00:17:05,569 --> 00:17:07,630
కానీ ఇది చేసిన ఎవరు మీరు యొక్క ఆ
ముందు, కేవలం అర్థం

347
00:17:07,630 --> 00:17:08,609
చాలా కేవలం ఏమి?

348
00:17:08,609 --> 00:17:09,730
>> విద్యార్థులు: [వాయిసెస్ INTERPOSING].

349
00:17:09,730 --> 00:17:10,740
>> DAVID మలన్: నేను 1 జోడించండి.

350
00:17:10,740 --> 00:17:11,819
I పెంచడం.

351
00:17:11,819 --> 00:17:13,910
కనుక మనం ఒక స్క్రాచ్ పజిల్ చూసింది
ఆ కోసం ముక్క, నిజానికి.

352
00:17:13,910 --> 00:17:18,230
ఇది నేను + +, కానీ లాగా లేదు కేవలం
అంటే, చాలా సరళంగా పెంచడం

353
00:17:18,230 --> 00:17:24,040
నేను 1 మీరు దీన్ని ప్రతి సమయం విలువ.

354
00:17:24,040 --> 00:17:26,910
సో వాచ్యంగా, మీరు మొదలు
0 నేను ప్రారంభించడం.

355
00:17:26,910 --> 00:17:29,520
అప్పుడు మీరు మీ పరిస్థితిని తనిఖీ.

356
00:17:29,520 --> 00:17:31,070
10 కంటే 0 తక్కువ?

357
00:17:31,070 --> 00:17:31,730
అవును.

358
00:17:31,730 --> 00:17:32,910
మేము లూప్ ద్వారా వెళ్లండి.

359
00:17:32,910 --> 00:17:35,150
>> నేను కంప్యూటర్ యొక్క క్లెయిమ్ తదుపరి విషయం
చేయబోవడం ఇది జరగబోతోంది ఉంది

360
00:17:35,150 --> 00:17:35,910
i పెంచడం.

361
00:17:35,910 --> 00:17:37,080
నేను ఇప్పుడు 1.

362
00:17:37,080 --> 00:17:37,940
ఇది పరిస్థితి తనిఖీ.

363
00:17:37,940 --> 00:17:39,290
10 కంటే 1 తక్కువ?

364
00:17:39,290 --> 00:17:39,930
కోర్సు యొక్క.

365
00:17:39,930 --> 00:17:41,030
కావున ఈ చేస్తుంది.

366
00:17:41,030 --> 00:17:43,580
నేను + + 2 అప్పుడు పొందుతారు.

367
00:17:43,580 --> 00:17:44,610
10 కంటే 2 తక్కువ?

368
00:17:44,610 --> 00:17:45,230
అవును.

369
00:17:45,230 --> 00:17:46,670
మళ్ళీ మళ్లీ మళ్లీ.

370
00:17:46,670 --> 00:17:50,070
మరియు చివరికి, ఎందుకంటే
ప్లస్-plussing, మేము i 10 సమానం పొందండి.

371
00:17:50,070 --> 00:17:51,675
10 కంటే 10 తక్కువ?

372
00:17:51,675 --> 00:17:52,990
బాగా, ఖచ్చితంగా కాదు.

373
00:17:52,990 --> 00:17:55,320
మరియు ఆ పాయింట్ వద్ద
లూప్ కేవలం స్టాప్ల.

374
00:17:55,320 --> 00:17:58,320
మరియు మీరు మరింత కోడ్ కలిగి ఉంటే
క్రింద స్క్రీన్ క్రిందుగా, కంప్యూటర్

375
00:17:58,320 --> 00:18:01,620
బదులుగా ఆ కోడ్ అమలు నిధులను.

376
00:18:01,620 --> 00:18:05,380
>> మరలా, ఈ వెళ్తున్నారు అయినప్పటికీ
చూడండి మరియు ఒక చిన్న వింత అనుభూతి

377
00:18:05,380 --> 00:18:07,830
మొదటి, ఖచ్చితంగా మీరు యొక్క ఆ కోసం ఎవరు
ముందు ప్రోగ్రామ్ ఎప్పుడూ, అది

378
00:18:07,830 --> 00:18:11,640
వాచ్యంగా సందర్భానుసారంగా తగ్గిస్తుంది
లేకపోతే చాలా ఏమి కు

379
00:18:11,640 --> 00:18:14,330
నేరుగా పజిల్
స్క్రాచ్ లో ముక్క.

380
00:18:14,330 --> 00:18:19,130
>> అన్ని కుడి, నేను వాగ్దానం ఉండనే ఇష్టం
స్క్రాచ్ ఇతర పోలికలు ఉంటుంది.

381
00:18:19,130 --> 00:18:20,060
ఈ ఒక చాలా ఉంది.

382
00:18:20,060 --> 00:18:21,700
మరియు మేము ఈ క్లుప్తంగా చివరిసారి చూసింది.

383
00:18:21,700 --> 00:18:23,530
కానీ ఎప్పటికీ గుర్తుంచుకోవాలి
స్క్రాచ్ లో బ్లాక్?

384
00:18:23,530 --> 00:18:25,490
ఇది కేవలం ఎప్పటికీ ఏదో చేస్తాడు?

385
00:18:25,490 --> 00:18:27,470
నేను మీరు అమలు అని పేర్కొన్నారు
ఈ విధంగా.

386
00:18:27,470 --> 00:18:29,740
మరియు మీరు నిజంగానే ఈ అమలు చేయవచ్చు
వివిధ మార్గాల్లో ఒక సమూహం లో.

387
00:18:29,740 --> 00:18:34,260
>> కానీ అయితే లూప్ వేరొక ఉంది
మీ వ్యక్తం సి మార్గం.

388
00:18:34,260 --> 00:18:37,080
రోజు చివరిలో, మీరు చెయ్యలేరని
ఒక సమయంలో లూప్ తో ఏదైనా మీరు

389
00:18:37,080 --> 00:18:38,360
చెయ్యలేరు లూప్ ఒక తో.

390
00:18:38,360 --> 00:18:41,430
కాబట్టి అవి చివర ఉన్నాము
క్రియాశీలంగా రోజు అదే.

391
00:18:41,430 --> 00:18:43,840
కానీ మీరు మిమ్మల్ని మీరు వ్యక్తం అనుమతిస్తుంది
కొంచెం విభిన్నంగా లో

392
00:18:43,840 --> 00:18:44,850
కింది విధంగా.

393
00:18:44,850 --> 00:18:49,720
>> అయితే లూప్ తో, దానిలో ఏముంది
మళ్ళీ తనిఖీ మరియు ఆ బ్రాకెట్ల

394
00:18:49,720 --> 00:18:51,050
మళ్ళీ మళ్ళీ.

395
00:18:51,050 --> 00:18:55,100
మరియు వెంటనే ఆ వ్యక్తీకరణ తప్పుగా వంటి,
అప్పుడు లూప్, అమలు స్టాప్ల

396
00:18:55,100 --> 00:18:57,890
మరియు కంప్యూటర్ ఉపక్రమించాడు
అమలు సంసార ఇతర కోడ్

397
00:18:57,890 --> 00:18:59,230
మీ ఫైల్ కలిగి.

398
00:18:59,230 --> 00:19:02,180
>> కానీ ఇక్కడ ఆసక్తికరమైన ఏమి ఉంది వార్తలు
నేను కచ్చితంగా నిజం టైప్ చేసి.

399
00:19:02,180 --> 00:19:06,680
మరియు నిజమైన, బూలియన్ విలువ ఒక రకం
ఒక నిజమైన లేదా తప్పుడు విలువ.

400
00:19:06,680 --> 00:19:09,750
సో నిజమైన ఎప్పుడూ కావచ్చు
నేను వాచ్యంగా చేసిన తప్పుడు ఉంటే

401
00:19:09,750 --> 00:19:11,970
నా కార్యక్రమం గా హార్డ్ కోడెడ్?

402
00:19:11,970 --> 00:19:12,470
దీనిని.

403
00:19:12,470 --> 00:19:13,730
ఇది నేను చేసింది ఒక చిన్న వింత వార్తలు.

404
00:19:13,730 --> 00:19:15,190
కానీ నిజమైన వర్తిస్తుంది.

405
00:19:15,190 --> 00:19:16,320
కూడిక-plussing ఉంది.

406
00:19:16,320 --> 00:19:17,820
ఇక్కడ చరరాశులను ఉపయోగం ఉంది.

407
00:19:17,820 --> 00:19:22,740
నేను అయితే నిజమైన హార్డ్ కోడ్ వలన, ఈ
లూప్ ఎల్లప్పుడూ అంచనా అన్నారు

408
00:19:22,740 --> 00:19:24,090
మళ్ళీ మళ్ళీ మళ్ళీ.

409
00:19:24,090 --> 00:19:27,660
>> సో హలో ప్రపంచ ఎన్ని రెట్లు
తెరపై ప్రింట్ వెళుతున్న?

410
00:19:27,660 --> 00:19:28,170
ఎప్పటికీ.

411
00:19:28,170 --> 00:19:31,980
వరకు సార్లు అనంతమైన సంఖ్య
బ్యాటరీ మరణిస్తాడు లేదా కొన్ని ఇతర బాహ్య

412
00:19:31,980 --> 00:19:32,730
ఈవెంట్ జరుగుతుంది.

413
00:19:32,730 --> 00:19:35,880
సో ఈ ఉత్తమ ప్రోగ్రామ్ కాదేమో
, వ్రాయడానికి ఎందుకంటే వినియోగదారు

414
00:19:35,880 --> 00:19:38,660
మీ ప్రోగ్రామ్ విడిచి ఎప్పుడూ, అది
బహుశా మీరు ఉద్దేశించిన.

415
00:19:38,660 --> 00:19:41,070
>> కానీ కొన్నిసార్లు, కార్యక్రమాలు చేయాలి
అనంతమైన లూప్ కలిగి.

416
00:19:41,070 --> 00:19:44,050
ఉదాహరణకు, మీ కంప్యూటర్ ఉంది
అది గడియారం, అది ఖచ్చితంగా ఉంటుంది

417
00:19:44,050 --> 00:19:48,130
ఇది నవీకరించుటకు ఉంచేందుకు లేదు మీ గడియారం ఉంటే బాగుంది
ఒక ఒకసారి అయితే ఎప్పటికీ కూడా,

418
00:19:48,130 --> 00:19:50,500
రెండవ లేదా ఒకసారి ఒక నిమిషం లేదా
అలాంటిదే.

419
00:19:50,500 --> 00:19:53,690
సో కూడా అనంతమైన లూప్
వారి స్థానంలో లేదు.

420
00:19:53,690 --> 00:19:54,360
>> అన్ని కుడి.

421
00:19:54,360 --> 00:19:55,190
చివరగా, ఈ.

422
00:19:55,190 --> 00:19:57,770
మరియు ఈ ఒక కొద్దిగా భిన్నంగా ఉంటుంది
పనితీరు మరియు మేము తిరిగి వచ్చి ఉంటుంది

423
00:19:57,770 --> 00:19:59,460
ఈ బహుశా Pset 1 లో.

424
00:19:59,460 --> 00:20:02,370
కానీ లూప్ యొక్క మరొక రకం ఉంది
లూప్ ఉన్నప్పుడు ఒక అని.

425
00:20:02,370 --> 00:20:07,100
మరియు ఒక మధ్య ఇక్కడ మాత్రమే తేడా
లూప్ మరియు చెప్పటానికి అయితే, ఒక సమయంలో లూప్ చేయండి,

426
00:20:07,100 --> 00:20:11,120
పరిస్థితి తనిఖీ అని కాదు
మీరు కోడ్ అమలు, కానీ తరువాత ముందు

427
00:20:11,120 --> 00:20:12,080
మీరు కోడ్ అమలు.

428
00:20:12,080 --> 00:20:15,380
కాబట్టి టాప్ వద్ద
లూప్, అలా అయితే అయితే

429
00:20:15,380 --> 00:20:16,560
దిగువన అది తనిఖీ.

430
00:20:16,560 --> 00:20:21,370
>> మరియు ఈ కేవలం అర్థం అయితే లూప్
సాధారణంగా సార్లు అమలు అవుతుంది

431
00:20:21,370 --> 00:20:24,630
లేదా ఒక సమయంలో లూప్ కంటే తక్కువ సార్లు?

432
00:20:24,630 --> 00:20:30,810
శక్తివంతమైన మరింత సార్లు, ఒక చేస్తారు ఎందుకంటే
లూప్ స్పష్టంగా, దీన్ని అని అయితే

433
00:20:30,810 --> 00:20:34,600
మాత్రమే ఇది తరువాత మీరు తనిఖీ పాయింటు
ఉంటే పరిస్థితి లోపల

434
00:20:34,600 --> 00:20:35,980
వక్ర వర్తిస్తుంది.

435
00:20:35,980 --> 00:20:37,940
>> కాబట్టి మేము మళ్ళీ ఈ చూస్తారు
బహుశా Pset 1 లో.

436
00:20:37,940 --> 00:20:41,150
మీరు ఎప్పుడైనా వద్ద చేయాలని ఉంటే
కనీసం ఒకసారి ఆపై ఉండవచ్చు కొన్ని మరింత

437
00:20:41,150 --> 00:20:43,350
సార్లు, ఈ మంచి
ఉపయోగించడానికి నిర్మించేందుకు.

438
00:20:43,350 --> 00:20:46,970
అయితే లూప్, దీనికి విరుద్ధంగా, అవుతుంది
మొదటి దాని పరిస్థితి తనిఖీ.

439
00:20:46,970 --> 00:20:50,660
మరియు ఆ, సి లో ఉచ్చులు కోసం దీన్ని వార్తలు
అయితే, మరియు ఉచ్చులు కోసం, అయితే.

440
00:20:50,660 --> 00:20:54,700
మళ్ళీ, వారు అందంగా చక్కగా తిరిగి మ్యాప్
ఈ ఒక లేదు తప్ప, గీతలు

441
00:20:54,700 --> 00:20:57,350
చాలా స్క్రాచ్ లో అదే అనలాగ్ కలిగి.

442
00:20:57,350 --> 00:20:58,880
>> బాగా, ఎలా, ఇప్పుడు, వేరియబుల్?

443
00:20:58,880 --> 00:21:02,600
సో ఈ నేను ఒక వేరియబుల్ డిక్లేర్డ్ ఎలా
పదము ఇతర రోజు.

444
00:21:02,600 --> 00:21:06,440
నేను పేర్కొంది ఒక Int, కలిగి
ఒక పూర్ణ సంఖ్య.

445
00:21:06,440 --> 00:21:09,690
నేను అప్పుడు, ఒక వేరియబుల్ అని కౌంటర్ కలిగి
ఆపై ఒక సెమికోలన్.

446
00:21:09,690 --> 00:21:11,070
సో కోడ్ చేయడం ఈ లైన్ ఏమిటి?

447
00:21:11,070 --> 00:21:14,540
ఈ ప్రకటించారు, చాలా సరళంగా ఉంది
ఒక వేరియబుల్ -

448
00:21:14,540 --> 00:21:17,940
కంప్యూటర్ అడుగుతూ, అని, నాకు ఇవ్వండి
కొన్ని మెమరీ, నాకు కొన్ని బిట్స్ ఇవ్వాలని - లో

449
00:21:17,940 --> 00:21:19,450
ఇది నేను నిల్వ చేయవచ్చు?

450
00:21:19,450 --> 00:21:20,300
ఒక Int.

451
00:21:20,300 --> 00:21:23,570
మరియు సెమికోలన్ కేవలం అర్థం
కోడ్ యొక్క పంక్తి చివర.

452
00:21:23,570 --> 00:21:25,500
>> ఇప్పుడు, రెండవ పంక్తి బహుశా ఉంది
అందంగా ఊహించగల.

453
00:21:25,500 --> 00:21:29,710
కౌంటర్ = 0 ఏమిటి; చేయడం?

454
00:21:29,710 --> 00:21:31,690
దానిని ఎదుర్కోవడానికి 0 కేటాయించి లో.

455
00:21:31,690 --> 00:21:33,470
అందువలన ఈ ఇతర విషయం
ఒక చిన్న బాధించే వార్తలు

456
00:21:33,470 --> 00:21:34,540
బీజగణితం, చెప్పటానికి, వెర్సెస్.

457
00:21:34,540 --> 00:21:39,110
బీజగణితంలో, సమాన సైన్ అర్థం అయితే
సమాన, సి ఇక్కడ, సమానం

458
00:21:39,110 --> 00:21:40,470
సైన్ అప్పగించిన అర్థం.

459
00:21:40,470 --> 00:21:45,380
కనుక ఇది కుడి ఏమి చాలు అంటే
ఎడమ పై విధంగా.

460
00:21:45,380 --> 00:21:49,030
మరియు మేము సమానం, మరొక చిహ్నం చూస్తారు
మేము నిజానికి పరీక్షించడానికి కావలసినప్పుడు, సమానం

461
00:21:49,030 --> 00:21:50,570
నాణ్యత, కొంతవరకు annoyingly కోసం.

462
00:21:50,570 --> 00:21:52,590
>> కానీ ఈ ఒక కొద్దిగా అసమర్థత.

463
00:21:52,590 --> 00:21:55,090
ఇది రకమైన నేను కలిగి బాధించే వార్తలు
ఒక వేరియబుల్ ప్రకటించడాన్ని కు

464
00:21:55,090 --> 00:21:56,110
అది ఒక విలువ ఇస్తాయి.

465
00:21:56,110 --> 00:21:59,380
సి నిజానికి మాకు ఈ సరళీకృతం అనుమతిస్తుంది కనుక
మరియు కేవలం ఒకేసారి అన్ని లేదు.

466
00:21:59,380 --> 00:22:01,330
మీరు వేరియబుల్ ప్రకటించవచ్చు
ఎడమవైపు.

467
00:22:01,330 --> 00:22:04,590
మీరు ఇప్పటికీ అప్పగించిన చేయవచ్చు
లో సమాన సైన్ పెట్టటం ద్వారా కుడి

468
00:22:04,590 --> 00:22:05,030
మధ్య.

469
00:22:05,030 --> 00:22:08,740
సో రోజు ముగింపులో, ఈ రెండు
సమానమైన, కానీ ఈ ఒకటి, స్పష్టముగా,

470
00:22:08,740 --> 00:22:11,840
బహుశా పొందడానికి మంచి అలవాటు ఉంది
ఇది కొద్దిగా తక్కువగా కేవలం ఎందుకంటే

471
00:22:11,840 --> 00:22:15,040
కోడ్, అది చదవడానికి కొద్దిగా సులభం
మరియు అది కేవలం అప్ tightens

472
00:22:15,040 --> 00:22:17,470
మీ కోడ్, మాట్లాడటానికి.

473
00:22:17,470 --> 00:22:22,120
>> ఇప్పటివరకు లూప్ ల మీద ఏవైనా ప్రశ్నలు,
అంశాలపై, పరిస్థితులు, న

474
00:22:22,120 --> 00:22:27,001
బూలియన్, గాని సాంకేతికంగా
లేదా సందర్భానుసారంగా?

475
00:22:27,001 --> 00:22:28,010
అన్ని కుడి.

476
00:22:28,010 --> 00:22:30,690
కాబట్టి ఇప్పుడు ఈ తదుపరి ఒక గెట్స్
కొద్దిగా ఆసక్తికరమైన.

477
00:22:30,690 --> 00:22:34,790
మరియు ఈ నేను గత అప్ చాలు ఉదాహరణ
కేవలం ఒక స్క్రాచ్ ఉదాహరణకు పటాలను ఆ సమయం

478
00:22:34,790 --> 00:22:35,820
పైగా C. కు

479
00:22:35,820 --> 00:22:36,580
>> ఒక ఫంక్షన్ సో.

480
00:22:36,580 --> 00:22:38,110
లేమాన్ నియమాల్లో, ఏమి ఒక ఫంక్షన్ యొక్క?

481
00:22:38,110 --> 00:22:42,900

482
00:22:42,900 --> 00:22:44,350
మీ జవాబును తో పెద్ద ఉండాలి వచ్చింది.

483
00:22:44,350 --> 00:22:45,020
ఒక ఫంక్షన్ ఏమిటి?

484
00:22:45,020 --> 00:22:46,320
>> STUDENT: ఏదో లేదు.

485
00:22:46,320 --> 00:22:46,780
>> DAVID మలన్: ఆ ఏమిటి?

486
00:22:46,780 --> 00:22:48,000
>> STUDENT: ఏదో లేదు.

487
00:22:48,000 --> 00:22:48,710
>> DAVID మలన్: ఏదో లేదు.

488
00:22:48,710 --> 00:22:49,000
OK.

489
00:22:49,000 --> 00:22:49,590
మేము అక్కడ మొదలు పెడతారేమో.

490
00:22:49,590 --> 00:22:51,270
సో ఒక ఫంక్షన్ ఏదో చేస్తుంది.

491
00:22:51,270 --> 00:22:55,160
కనుక ఇది ఆ కోడ్ యొక్క ఒక ముక్క వార్తలు
తప్పనిసరిగా ఏదో ఒకచోట ఆ అమలు

492
00:22:55,160 --> 00:22:56,620
నిజానికి ఏదో చేస్తుంది.

493
00:22:56,620 --> 00:23:00,180
ఇప్పుడు, ఒక ఫంక్షన్ గురించి ఆసక్తికరమైన ఏమిటి
ఇది ఇన్పుట్ పట్టవచ్చు అని,

494
00:23:00,180 --> 00:23:02,710
మరియు అది ఉత్పత్తి చేయవచ్చు.

495
00:23:02,710 --> 00:23:05,090
మరియు లెట్ నిజానికి పడుతుంది యొక్క
ఈ పరిశీలించి.

496
00:23:05,090 --> 00:23:09,030
>> సో తెర వెనుక మనిషి
ఒక క్షణం క్రితం ఉద్ధేశ్యపూర్వకంగానే జాగ్రత్తలతో దాడి.

497
00:23:09,030 --> 00:23:10,320
ఇక్కడ మేము ఒక పట్టికను కలిగి.

498
00:23:10,320 --> 00:23:13,010
కానీ ఊహించు ఈ నిజానికి
ఒక పెద్ద బాక్స్ సూచిస్తుంది.

499
00:23:13,010 --> 00:23:14,940
సో ఈ పేరున్న బ్లాక్ బాక్స్ ఉంది.

500
00:23:14,940 --> 00:23:19,800
మరియు సాధారణంగా, డిజైన్ లో, కంప్యూటర్ లో
సైన్స్, బ్లాక్ బాక్సుల కేవలం చూడండి

501
00:23:19,800 --> 00:23:22,510
కార్యాచరణ ముక్కల ఎవరైనా
అమలు, మరియు మీరు లేదు ఉంది

502
00:23:22,510 --> 00:23:26,140
తప్పనిసరిగా తెలిసి ఉన్నా లేదా అది ఎలా శ్రద్ధ
హుడ్ కింద అమలు.

503
00:23:26,140 --> 00:23:28,960
మీరు కేవలం శ్రమ ఈ బ్లాక్ బాక్స్,
మేము ఇప్పుడు ఒక కాల్ మొదలు పెడతారేమో ఇది

504
00:23:28,960 --> 00:23:30,730
ఫంక్షన్, ఏదో చేస్తుంది.

505
00:23:30,730 --> 00:23:34,710
>> సో, ఉదాహరణకు, ఈ బ్లాక్ బాక్స్ లో ఉంటే
ఇక్కడ దశ, printf ప్రాతినిధ్యం ఒక

506
00:23:34,710 --> 00:23:38,040
ఫంక్షన్, నేను మునుపటి ఉదాహరణలు నుండి తెలుసు
ఆ printf పడుతుంది ఒకటి లేదా ఎక్కువ

507
00:23:38,040 --> 00:23:40,910
వాదనలు, మరియు ఆ మొదటి
వాదనలు వంటి, ఒక స్ట్రింగ్ ఉండాలి

508
00:23:40,910 --> 00:23:44,780
"హలో, ప్రపంచం." Well, నేను వ్యక్తిని ఉంటే
కార్యక్రమం రాయడం, మరియు నేను మీరు

509
00:23:44,780 --> 00:23:50,460
printf ఉపయోగించడానికి, నేను, ఉదాహరణకు, వాటిని
ఇక్కడ మరియు ఖాళీ కాగితం ముక్క తీసుకుని

510
00:23:50,460 --> 00:23:55,060
నలుపు మార్కర్ మరియు వ్రాయవచ్చు -

511
00:23:55,060 --> 00:23:56,580
నేను "ప్రపంచ" స్పెల్లింగ్ -

512
00:23:56,580 --> 00:23:59,560
H-E-L-L-O.

513
00:23:59,560 --> 00:24:04,220
>> నేను నా నల్ల మార్కర్ తీసుకొని వెళ్తాము మరియు నేను చేస్తాము
న పెద్ద మరియు legibly నేను వంటి, వ్రాయడానికి

514
00:24:04,220 --> 00:24:07,260
ఈ కాగితం ముక్క, "హలో, ప్రపంచం," మరియు
ఇప్పుడు నేను ఈ నా వాదన చేశారు.

515
00:24:07,260 --> 00:24:09,740
ఈ ప్రాతినిధ్యం ఒక స్ట్రింగ్
తెలుపు కాగితం ముక్క.

516
00:24:09,740 --> 00:24:13,030
మరియు ఇప్పుడు పనిచేయటం నా ఇన్పుట్
printf ఈ అవతరిస్తుంది.

517
00:24:13,030 --> 00:24:18,250
నేను ప్రయాణిస్తున్న, printf కాల్ చేస్తున్నాను
ఇది ఇన్పుట్ ఆ వాదన.

518
00:24:18,250 --> 00:24:22,110

519
00:24:22,110 --> 00:24:26,740
>> మరియు ఇప్పుడు, నేను ఎలా వ్యక్తి తెలియదు
printf సంవత్సరాల క్రితం, కాని రచన

520
00:24:26,740 --> 00:24:31,110
నేను దాని డాక్యుమెంటేషన్ నుండి తెలుసు
జీవితం లో దాని ప్రయోజనం నేను ప్రింట్ ఉంది

521
00:24:31,110 --> 00:24:34,410
ఇది ఇన్పుట్ గా అందించడానికి.

522
00:24:34,410 --> 00:24:40,630
అందువలన, అయినప్పటికీ ఈ అమలు
నాకు తెలియకుండా ఉంది

523
00:24:40,630 --> 00:24:44,170
హుడ్ కింద, ఇప్పుడు
నేను OH, అది జరుగుతుంది, చూడండి.

524
00:24:44,170 --> 00:24:45,740
ఇది ఏదో ముద్రించిన ఉంది
తెరపై.

525
00:24:45,740 --> 00:24:49,070
మరియు ఇప్పుడు, ఈ కార్యక్రమం యొక్క నియంత్రణను ఉంటే అక్కడ
, కోడ్ యొక్క మరిన్ని పంక్తులు ఉంటుంది ఉన్నాయి

526
00:24:49,070 --> 00:24:51,070
ఇప్పుడు నాకు వచ్చాయి.

527
00:24:51,070 --> 00:24:52,290
అందువలన నిజానికి కాల్టన్ ఆ -

528
00:24:52,290 --> 00:24:55,370
తన గుండె అనుగ్రహించు, కింద ఇక్కడ దాచి
మీరు అన్ని ముందు ఒక టేబుల్ -

529
00:24:55,370 --> 00:24:59,530
నాకు తెలీదు ఆ ఉద్దేశపూర్వకంగా ఉంది
మరియు నేను ఎలా printf ఉంది పట్టించుకోను

530
00:24:59,530 --> 00:25:00,100
అమలు.

531
00:25:00,100 --> 00:25:03,390
నేను దాని నుండి, మళ్ళీ, తెలుసు
అది ఏమి డాక్యుమెంటేషన్, మరియు ఎలా నేను

532
00:25:03,390 --> 00:25:05,040
ఇది ఉపయోగించడానికి కోరుకుంటున్నాము చేస్తున్నాను.

533
00:25:05,040 --> 00:25:09,140
>> ఇప్పుడు, printf పొందే విధంగా గుర్తు
కొద్దిగా మరింత ఆధునిక.

534
00:25:09,140 --> 00:25:12,220
మళ్ళీ, మేము కేవలం గురించి మాట్లాడటం చేస్తున్నాం
స్క్రాచ్ యొక్క సే బ్లాక్ సమానం.

535
00:25:12,220 --> 00:25:14,230
కానీ నేను కూడా ఈ చివరిసారి చేసింది.

536
00:25:14,230 --> 00:25:17,270
నా హలో కార్యక్రమం చేయాలని ఒక
కేవలం హార్డ్ కొద్దిగా మరింత శక్తివంతమైన మరియు కాదు

537
00:25:17,270 --> 00:25:19,740
కోడ్ ఏదో "ప్రపంచ," మరియు
ఖచ్చితంగా కాదు హార్డ్ కోడ్ ఏదో

538
00:25:19,740 --> 00:25:22,520
D-A-V-I-D వంటి అనియత
కార్యక్రమంలో.

539
00:25:22,520 --> 00:25:27,510
నేను అతని లేదా ఆమె కోసం వినియోగదారుని అభ్యర్థించడం కావలెను
పేరు, ఆపై ఏదో ఒకటి

540
00:25:27,510 --> 00:25:29,720
వారు అందించే ఆ స్ట్రింగ్.

541
00:25:29,720 --> 00:25:32,690
>> సో కొద్దిగా వివిధ ఏదో
ఇక్కడ. printf, ఒక క్షణం క్రితం,

542
00:25:32,690 --> 00:25:35,860
నిజానికి, ఏదో, అయితే ఇది
నాకు దేన్నీ.

543
00:25:35,860 --> 00:25:36,020
కుడి?

544
00:25:36,020 --> 00:25:38,910
COLTON నాకు ఏదైనా అప్పగించండి లేదు
తిరిగి, కాగితం సంఖ్య ముక్క.

545
00:25:38,910 --> 00:25:40,320
ఒక వైపు ప్రభావం కేవలం ఉంది.

546
00:25:40,320 --> 00:25:44,510
నా అందించే "హలో, ప్రపంచం" ఒక గా
వాదన కాల్టన్ వచ్చింది

547
00:25:44,510 --> 00:25:48,420
ఒక పదం యొక్క దుష్ఫలితం, కొన్ని పదాలు,
తెరపై కనిపించే.

548
00:25:48,420 --> 00:25:51,350
>> getstring, అయితే, ఒక చిన్న ఉంది
వివిధ. getstring కూడా ఒక ఉంది

549
00:25:51,350 --> 00:25:54,590
పని, కానీ అది కొన్ని విలువ తిరిగి.

550
00:25:54,590 --> 00:25:56,370
ఇది కేవలం ఒక కలిగి లేదు
సౌందర్య వైపు ప్రభావం.

551
00:25:56,370 --> 00:26:00,230
ఇది నిజానికి వ్యక్తి, నాకు ఇస్తుంది
, కాల్ లేదా ఫంక్షన్ ఉపయోగించి

552
00:26:00,230 --> 00:26:01,320
తిరిగి ఏదో.

553
00:26:01,320 --> 00:26:05,740
సో ఈ సందర్భంలో, getstring ఉంది
getstring ఓపెన్ పిలిచింది

554
00:26:05,740 --> 00:26:07,510
బ్రాకెట్, దగ్గరగా బ్రాకెట్.

555
00:26:07,510 --> 00:26:11,370
Getstring, అందువలన, పడుతుంది
ఏ వాదనలు లేదా ఇన్పుట్?

556
00:26:11,370 --> 00:26:12,340
కాదు, అది పనిచేయదు.

557
00:26:12,340 --> 00:26:14,460
జీవితం లో దాని లక్ష్యం
కేవలం ఒక స్ట్రింగ్ పొందుటకు.

558
00:26:14,460 --> 00:26:16,910
ఇది కంటే ఎక్కువ వివరాలు అవసరం.

559
00:26:16,910 --> 00:26:20,430
సో నాకు ముందుకు వెళ్లి ఆ నటిస్తారు వీలు,
మళ్ళీ, ఈ బ్లాక్ బాక్స్, printf కాదు

560
00:26:20,430 --> 00:26:25,160
కానీ getstring, మరియు, వ్యక్తి నాకు వీలు
ఈ కార్యక్రమం వ్రాయడం, కాల్ లేదా ఉపయోగించడానికి

561
00:26:25,160 --> 00:26:29,720
కేవలం వ్రాయడం ద్వారా getstring
దగ్గరగా G-E-T-S-T-R-I-N-G, ఓపెన్ బ్రాకెట్,

562
00:26:29,720 --> 00:26:32,170
బ్రాకెట్, getstring.

563
00:26:32,170 --> 00:26:36,920
>> ఇప్పుడు, నాకు ఆలోచన ఎలా CS50 సిబ్బంది
getstring అమలు, కానీ నేను తెలుసు

564
00:26:36,920 --> 00:26:41,240
నేను చాలా కాలము వేచి ఉంటే, దాని చేస్తాను
హుడ్ కింద విషయం, బహుశా ఉపయోగించి

565
00:26:41,240 --> 00:26:44,940
కొన్ని వేరియబుల్స్ ఉండవచ్చు వాడి
పరిస్థితులు, బహుశా కొన్ని ఉచ్చులు ఉపయోగించి,

566
00:26:44,940 --> 00:26:48,170
బహుశా కొన్ని ఫంక్షన్లను ఉపయోగించి,
బహుశా ఉపయోగించి -

567
00:26:48,170 --> 00:26:52,290
కేవలం నిలిచిపోయినట్లు ప్రయత్నిస్తున్నారు - ఉండవచ్చు ఉపయోగించి
కొన్ని ఇతర ప్రోగ్రామింగ్ లక్షణాలు.

568
00:26:52,290 --> 00:26:55,350
కానీ, నేను చాలా కాలం తగినంత వేచి ఉంటే - వాస్తవానికి,
కంప్యూటర్ లో, ఈ జరుగుతుంది

569
00:26:55,350 --> 00:26:56,270
సూపర్ ఫాస్ట్ -

570
00:26:56,270 --> 00:26:59,910
నేను చాలా కాలము వేచి ఉంటే, ఈ ఫంక్షన్
getstring ఒక స్ట్రింగ్ పొందుటకు వెళ్తున్నారు

571
00:26:59,910 --> 00:27:04,060
బహుశా టైప్ వినియోగదారుకు నుండి
వారి కీబోర్డ్ మీద, మరియు

572
00:27:04,060 --> 00:27:08,090
అప్పుడు, మీరు getstring పూర్తి అయిన తర్వాత పొందడానికి
యూజర్ నుండి ఆ అక్షరాలు

573
00:27:08,090 --> 00:27:14,080
మరియు ఆ, ఒక స్ట్రింగ్ వాటిని నిల్వ
ఫంక్షన్, getstring కలిగి వెళ్తున్నారు

574
00:27:14,080 --> 00:27:17,990
నేను కొన్ని అవుట్పుట్ నాకు సిద్ధంగా
మార్గం ద్వారా తిరిగి వెళుతున్న

575
00:27:17,990 --> 00:27:19,470
అప్పగించిన ఆపరేటర్లు.

576
00:27:19,470 --> 00:27:25,390
>> మరియు నేను వెళ్ళి ఉంటే, నిజానికి, అవుట్పుట్ లోకి
ఇక్కడ, Obosi దాతృత్వముగా ఉంది

577
00:27:25,390 --> 00:27:29,900
ఈ తెలియకుండా, పాల్గొన్నారు
ఈ లో తన పేరు వ్రాయడం ద్వారా, ముందుకు

578
00:27:29,900 --> 00:27:33,100
ప్రాతినిధ్యం ఇది వేరియబుల్,
ఒక స్ట్రింగ్.

579
00:27:33,100 --> 00:27:35,640
ఇప్పుడు, అప్పగించిన ఆపరేటర్లు కూడా, అంటే
ఈ కొద్దిగా అనుభూతి చెందుతాడు అయితే

580
00:27:35,640 --> 00:27:38,790
పునరావృత, నేను నిజానికి అవసరము
ఈ నా సొంత కాపీని చేయడానికి.

581
00:27:38,790 --> 00:27:40,700
ఎడమ వైపు ఎందుకంటే
సైడ్ - అయ్యో! -

582
00:27:40,700 --> 00:27:45,760
నేను తప్పనిసరిగా స్ట్రింగ్ కలిగి గమనించవచ్చు
ఎడమ చేతి వైపు పేరు.

583
00:27:45,760 --> 00:27:48,280
నేను కూడా చేయడానికి వెళుతున్నాను
నా సొంత ఈ నకలు.

584
00:27:48,280 --> 00:27:50,990
మరియు ఈ ఒక తెల్ల అబద్ధం ఒక బిట్
మేము ఒక వారం లేదా రెండు యొక్క చూస్తారు ఎందుకంటే

585
00:27:50,990 --> 00:27:54,100
తీగలను నిజానికి లేని సమయం
అవి అలా కనిపిస్తుంది ఏమి.

586
00:27:54,100 --> 00:27:56,700
>> కానీ ఇప్పుడు కోసం, ఇక్కడ తిరిగి విలువ.

587
00:27:56,700 --> 00:28:00,160
ఇక్కడ అది నా సొంత కాపీని తర్వాత
అప్పగించిన ఆపరేటర్లు ఉపయోగించి.

588
00:28:00,160 --> 00:28:01,790
మరియు ఇప్పుడు, నేను తదుపరి ఏమి అనుకుంటున్నారు?

589
00:28:01,790 --> 00:28:04,080
మేము ఇప్పుడు రెండవ కలిగి
కోడ్ యొక్క రెండు లైన్ల.

590
00:28:04,080 --> 00:28:05,640
నేను ఇప్పుడు printf కాల్ అనుకుంటున్నారా.

591
00:28:05,640 --> 00:28:08,500
నల్ల ఇప్పుడు నటిస్తారు లెట్
బాక్స్ కావడంతో మళ్లీ ఉంది

592
00:28:08,500 --> 00:28:10,210
printf మరియు getstring.

593
00:28:10,210 --> 00:28:12,200
>> Printf ఈ సమయం కానుంది
ఎన్ని వాదనలు పడుతుంది?

594
00:28:12,200 --> 00:28:14,890

595
00:28:14,890 --> 00:28:16,770
సో చూడండి, అది రెండు వంటిది.

596
00:28:16,770 --> 00:28:18,860
అక్కడ రెండు కామాలతో కానీ
ఆ కామాలతో ఒకటిగా వార్తలు

597
00:28:18,860 --> 00:28:20,220
కోట్స్ లోపల.

598
00:28:20,220 --> 00:28:23,190
సో మొదటి వాదన వాచ్యంగా ఉంది
ఈ అవతరిస్తుంది.

599
00:28:23,190 --> 00:28:31,850
H-E-L-L-O, కామా, శాతం
లు, బాక్ స్లాష్-n.

600
00:28:31,850 --> 00:28:36,560
మరియు ఇప్పుడు నేను, కాదు ఒక వాదన అందించడం వెబ్
కానీ printf రెండు వాదనలు.

601
00:28:36,560 --> 00:28:39,530
>> ఏ printf తో ఏమి చేయాలో లో
నేను వాటిని పాస్ ఈ రెండు ఇన్పుట్లను తర్వాత

602
00:28:39,530 --> 00:28:42,050
వాదనలు?

603
00:28:42,050 --> 00:28:45,360
ఇది రెండవ తీసుకోవాలని అనుకున్నారు లో
నేను పేరు అని వాటిని,, కాబట్టి

604
00:28:45,360 --> 00:28:48,660
నేను వ్రాసియున్నాడు కాగితం రెండవ భాగం
ఒక క్షణం క్రితం పేరు అంటారు.

605
00:28:48,660 --> 00:28:53,550
ఇది విలువ లోపల ప్లగ్ అవకాశముంది
హోల్డర్ ఆ వేరియబుల్ యొక్క,

606
00:28:53,550 --> 00:28:58,310
% S, కాబట్టి, మళ్ళీ, కేవలం ఒక క్షణం లో
సమయం, మేము ఒక వైపు ప్రభావం చూస్తారు

607
00:28:58,310 --> 00:29:04,180
మేము ఇప్పుడు దానిద్వారా printf అనే సరికొత్త
కాదు "హలో, ప్రపంచం," కానీ "హలో, చూడండి

608
00:29:04,180 --> 00:29:04,710
Obosi. "

609
00:29:04,710 --> 00:29:08,730
>> కాబట్టి రెండు ప్రశంసలను ఒక పెద్ద రౌండ్
మా స్వచ్ఛందంగా, తెలుసు వారిలో ఒకరు మాత్రమే

610
00:29:08,730 --> 00:29:12,010
ఈ జరుగుతున్న అవుతుంది.

611
00:29:12,010 --> 00:29:12,990
అన్ని కుడి.

612
00:29:12,990 --> 00:29:16,480
, ఆ విధంగా, బహుశా, సాధారణ
ఖచ్చితంగా, మీరు ఇప్పటికే తెలిసిన అయితే

613
00:29:16,480 --> 00:29:20,190
అంటే, ఆశాజనక మీరు ఎప్పటికీ
ఎలా ఆ ప్రత్యేకమైన దృశ్యమాన మర్చిపోతే

614
00:29:20,190 --> 00:29:21,220
విధులు పని.

615
00:29:21,220 --> 00:29:23,000
>> సో కేవలం getstring కంటే ఉంది.

616
00:29:23,000 --> 00:29:26,020
CS50 లైబ్రరీ యొక్క లోపల ఒక ఉంది
విధులు మొత్తం బంచ్, అన్ని వీటిలో

617
00:29:26,020 --> 00:29:29,510
కేవలం స్పష్టమైన చేయడానికి క్యాపిటల్ అక్షరాలలో ఉంటాయి
మేము ఈ విధులు వ్రాసాడు.

618
00:29:29,510 --> 00:29:33,610
సాధారణంగా, సి లో, దాదాపు ప్రతి ఇతర
మీరు ఉపయోగిస్తాము ఫంక్షన్ చిన్నబడి ఉంది.

619
00:29:33,610 --> 00:29:36,190
కానీ మేము ఉద్దేశపూర్వకంగా క్యాపిటల్ లెటర్స్ ఉపయోగించడానికి
మనం స్పష్టమైన ఈ ఆ

620
00:29:36,190 --> 00:29:39,880
మేము చేస్తాము అని రకాల శిక్షణ చక్రాలు ఉంటాయి
కేవలం కొన్ని వారాల కోసం ఉపయోగించే

621
00:29:39,880 --> 00:29:42,890
పొందడానికి విధానాన్ని సులభం
యూజర్ నుండి ఇన్పుట్.

622
00:29:42,890 --> 00:29:46,740
>> CS50 లైబ్రరీ ఏదైనా లేదు
మీరు yourselves ద్వారా లేదు అని

623
00:29:46,740 --> 00:29:50,230
కేవలం ఒక నుండి సి కోడ్ ఉపయోగించి
oldschool పాఠ్య పుస్తకం.

624
00:29:50,230 --> 00:29:53,310
కానీ, మళ్లీ, మేము శిక్షణ వాటిని ఉపయోగించడానికి
కేవలం ఒక జంట కోసం రకాల చక్రాలు

625
00:29:53,310 --> 00:29:57,250
మేము వదిలించుకోవటం చేయవచ్చు వారాల తద్వారా
మీరు వెంటనే అర్థం మేము సంక్లిష్టత

626
00:29:57,250 --> 00:30:00,460
ఏదో చేయడం యొక్క మీ
పొందడానికి వంటి తక్షణ

627
00:30:00,460 --> 00:30:02,080
ఒక వినియోగదారు నుండి ఇన్పుట్.

628
00:30:02,080 --> 00:30:05,540
>> సో మీరు ప్రాప్తిని కలిగి ఉంటుంది తెలుసు
, GetChar GetDouble కు -

629
00:30:05,540 --> 00:30:06,050
రెట్టింపు.

630
00:30:06,050 --> 00:30:07,050
What's - ఆపై GetFloat.

631
00:30:07,050 --> 00:30:07,600
ఫ్లోట్ ఏమిటి?

632
00:30:07,600 --> 00:30:09,382
అక్కడ ప్రారంభిద్దాం.

633
00:30:09,382 --> 00:30:10,600
>> STUDENT: [వినబడని].

634
00:30:10,600 --> 00:30:10,790
>> DAVID మలన్: అవును.

635
00:30:10,790 --> 00:30:12,120
ఇది ఒక సౌకర్యం పాయింట్ తో నెంబర్.

636
00:30:12,120 --> 00:30:15,930
ఒక Int పూర్ణాంకం సో అయితే, ఇది
9 ద్వారా 0 తో కేవలం ఒక సంఖ్య, ఉంది

637
00:30:15,930 --> 00:30:18,940
వాటి పునరావృత్తులు యొక్క కొన్ని సంఖ్య,
ఫ్లోట్ ఏదో ఉంది

638
00:30:18,940 --> 00:30:20,100
ఒక దశాంశ బిందువు తో.

639
00:30:20,100 --> 00:30:26,090
మరియు ఒక డబుల్, మరోవైపు, ఒక కూడా ఉంది
ఒక దశాంశ బిందువు స్థానం, కానీ మరింత

640
00:30:26,090 --> 00:30:28,160
దశాంశ తరువాత సంఖ్యలు
పాయింట్, సమర్థవంతంగా.

641
00:30:28,160 --> 00:30:30,040
>> కాబట్టి మేము ఈ ముందు దీర్ఘ తిరిగి పొందుతారు.

642
00:30:30,040 --> 00:30:34,560
కానీ సాధారణంగా, ఈ రకాల యొక్క ప్రతి
డేటా, వేరియబుల్ రకాల ప్రతి

643
00:30:34,560 --> 00:30:39,380
మాది వంటి ఒక లైబ్రరీ తిరిగిపొందవచ్చు
మీరు, వివిధ సంఖ్యలు బిట్స్ ఉపయోగించే

644
00:30:39,380 --> 00:30:40,290
సమాచారం నిల్వ.

645
00:30:40,290 --> 00:30:43,910
కేవలం అంటే సాధారణంగా, ఒక చార్,
ఒక పాత్ర, 8 బిట్స్ ఉపయోగిస్తుంది.

646
00:30:43,910 --> 00:30:47,490
మరియు మా తో నిజానికి స్థిరమైన వార్తలు
వాలంటీర్లను బైట్ గత వారం ఎవరు

647
00:30:47,490 --> 00:30:50,410
అప్ వచ్చింది మరియు ఒక ప్రాతినిధ్యం
ఒక సమయంలో ASCII అక్షరాల.

648
00:30:50,410 --> 00:30:51,850
సో ఒక చార్ 8 బిట్లు.

649
00:30:51,850 --> 00:30:54,430
>> ఒక ఫ్లోట్ నిర్మాణము
32 బిట్స్, సాధారణంగా.

650
00:30:54,430 --> 00:30:59,230
మరియు ఒక డబుల్, మీరు ఊహించినట్లుగా, ఉంది
కేవలం మరింత ఇది నిజానికి 64 బిట్స్

651
00:30:59,230 --> 00:31:01,360
ఇది మీరు పెద్ద కలిగి దీని అర్థం
సంఖ్యలు లేదా మరింత కచ్చితత్వం.

652
00:31:01,360 --> 00:31:03,000
కానీ మళ్ళీ, మరింత మరొక సమయం.

653
00:31:03,000 --> 00:31:06,550
GetLongLong, మరోవైపు, అయితే stupidly
పేరు, కేవలం ఒక నిజంగా ఉంది

654
00:31:06,550 --> 00:31:10,770
రెండుసార్లు వంటి పెద్ద అని పూర్ణ, రెండుసార్లు వంటి
దీర్ఘ, సమర్థవంతంగా, ఒక సాధారణ

655
00:31:10,770 --> 00:31:12,940
పూర్ణాంక, బదులుగా 32 64 బిట్స్.

656
00:31:12,940 --> 00:31:14,560
మరియు మేము ఉపయోగిస్తున్నాను GetString.

657
00:31:14,560 --> 00:31:18,870
>> కానీ, CS50 లైబ్రరీ లో, మారిపోతాడు
మేము చూస్తారు వంటి దీనిలో, అమలు

658
00:31:18,870 --> 00:31:23,560
రెండు ఫైళ్లను రూపంలో, ఇది ఒకటి
cs50.h అంటారు, ఇతర రెండు

659
00:31:23,560 --> 00:31:24,770
అది డేటా రకాలు.

660
00:31:24,770 --> 00:31:29,700
బూలియన్ మీరు C. లేరు
కేవలం ఉపయోగించి వాటిని అనుకరించడానికి 0 సె మరియు 1s

661
00:31:29,700 --> 00:31:30,850
మీ కార్యక్రమాలు అంతటా.

662
00:31:30,850 --> 00:31:35,500
కానీ మేము CS50 లైబ్రరీ లో సృష్టించారు
చిహ్నాలు "నిజమైన" మరియు "తప్పుడు"

663
00:31:35,500 --> 00:31:38,580
మీరు లేదు కాబట్టి 1 మరియు 0 ప్రాతినిధ్యం
హార్డ్ కోడ్ ఏదో ఉంటుంది

664
00:31:38,580 --> 00:31:39,810
వాచ్యంగా 1 మరియు 0 ఇష్టపడుతున్నారు.

665
00:31:39,810 --> 00:31:40,980
కానీ మేము మళ్ళీ ఆ చూస్తారు.

666
00:31:40,980 --> 00:31:42,330
>> స్ట్రింగ్, చాలా, లేదు.

667
00:31:42,330 --> 00:31:44,520
నేను అది పేర్కొన్న ఎందుకు మరియు ఆ వార్తలు
ఇప్పుడు ఒక తెల్ల అబద్ధం ఒక బిట్.

668
00:31:44,520 --> 00:31:46,660
కానీ మేము తిరిగి చర్మము చేస్తాము
దీర్ఘ ముందు పొర.

669
00:31:46,660 --> 00:31:49,540
కానీ ఇప్పుడు కోసం, ఒక స్ట్రింగ్ ఒక
అక్షరాలు క్రమం.

670
00:31:49,540 --> 00:31:51,790
>> ఇంతలో, సి, మీరు నిజంగా
వివిధ డేటా రకాలను కలిగి.

671
00:31:51,790 --> 00:31:53,200
ఈ చిన్న ఉంటాయి గమనించవచ్చు.

672
00:31:53,200 --> 00:31:56,960
విధులు సో మీరు ఒక క్షణం క్రితం చూసింది
విధులు CS50 ఆ రాస్తారు

673
00:31:56,960 --> 00:32:02,310
మీకు వస్తుంది విలువ తిరిగి ఉంటుంది
ఈ విభాగాల్లో ఏదో ఒకదాని.

674
00:32:02,310 --> 00:32:06,730
>> ఒక జంట మోసగాడు షీట్లను కేవలం మొక్క కు
ఇక్కడ సీడ్. printf కేవలం లేదు

675
00:32:06,730 --> 00:32:08,600
placeholders వంటి% s పడుతుంది.

676
00:32:08,600 --> 00:32:13,490
ఇది దశాంశ పూర్ణాంకాల కోసం% d పడుతుంది
లేదా% i అలాగే పని చేస్తుంది.

677
00:32:13,490 --> 00:32:19,450
% F పాయింట్ విలువలు తేలియాడే. % సి కోసం
ఒక చార్ మీరు కేవలం ఒక ప్రదర్శించాడు అనుకుంటే

678
00:32:19,450 --> 00:32:23,510
ఒక ముందుగానే క్రమపరచిన స్ట్రింగ్ లోకి పాత్ర
మేము చేస్తున్న చేసిన వంటి, మీరు% సి ఉపయోగించవచ్చు.

679
00:32:23,510 --> 00:32:28,490
>> ఆపై, కొంతవరకు annoyingly,% LLD ఉంది
ఒక దీర్ఘ, దీర్ఘ దశాంశ పూర్ణాంక కోసం,

680
00:32:28,490 --> 00:32:31,050
మీరు ఒక నిజంగా ఉంటే ఇది కేవలం అర్థం
పెద్ద సంఖ్య మరియు మీరు ఏదో ఉపయోగిస్తున్నారు

681
00:32:31,050 --> 00:32:35,450
ఒక దీర్ఘ కాలం, మేము వచ్చి చేస్తాము అనే
తిరిగి ఒక pset లో, మీరు% LLD ఉపయోగించవచ్చు

682
00:32:35,450 --> 00:32:40,700
ఒక నిజంగా పెద్ద printf, ప్లగ్ చెప్పండి
లేదా ఇక్కడ దాని రెండవ మార్గం ద్వారా పూర్ణాంకం

683
00:32:40,700 --> 00:32:41,830
కొన్ని ఇతర వాదన.

684
00:32:41,830 --> 00:32:45,700
>> చివరికి, నేను వాగ్దానం ఆ
కొన్ని ఇతర ఎస్కేప్ ఉంది

685
00:32:45,700 --> 00:32:47,670
printf మద్దతు శ్రేణులను.

686
00:32:47,670 --> 00:32:49,160
మేము బాక్ స్లాష్-n చూసిన.

687
00:32:49,160 --> 00:32:50,510
బాక్ స్లాష్-r మీరు చూడవచ్చు.

688
00:32:50,510 --> 00:32:51,780
ఇది ఒక పురాతన పాఠశాల విషయం యొక్క విధమైన ఉంది.

689
00:32:51,780 --> 00:32:55,920
మీరు ఎప్పుడైనా ఒక నిజమైన టైపురైటర్ యంత్రము సంవత్సరాల వుపయోగిస్తే
క్రితం మరియు మీరు క్రాంక్ న విరమించుకుంది

690
00:32:55,920 --> 00:32:59,810
ఇది చక్రం తిరుగుతుంది మాత్రమే
లైనప్ తరలించడానికి, అది కూడా తరలించబడింది

691
00:32:59,810 --> 00:33:03,730
కు తిరిగి మొత్తం విషయం అన్ని మార్గం
ఎడమ, బాగా, బాక్ స్లాష్-r కేవలం

692
00:33:03,730 --> 00:33:06,480
తప్పనిసరిగా మీ కర్సర్ తిరిగి తరలిస్తుంది
లైన్ ప్రారంభానికి

693
00:33:06,480 --> 00:33:07,830
అది డౌన్ కదలకుండా.

694
00:33:07,830 --> 00:33:09,780
కానీ మళ్ళీ, మరింత ఆ,
బహుశా, భవిష్యత్తులో.

695
00:33:09,780 --> 00:33:13,670
>> బాక్ స్లాష్ కోట్, బాక్ స్లాష్-డబుల్ కోట్,
బాక్ స్లాష్-బాక్ స్లాష్ ఉంది

696
00:33:13,670 --> 00:33:16,600
చిన్న చిన్న ప్రశ్నకు పరిష్కారం
నేను ముందు గమనార్హం.

697
00:33:16,600 --> 00:33:18,920
మరియు బాక్ స్లాష్-0 నిజానికి
చాలా ఆసక్తికరమైన.

698
00:33:18,920 --> 00:33:21,470
కానీ మేము తిరిగి వచ్చి ఉంటుంది
దీర్ఘ ముందు.

699
00:33:21,470 --> 00:33:25,640
>> సో CS50, నాకు ఇప్పుడు, లోకి వెళ్ళి తెలపండి
ఉపకరణం, మరియు యొక్క నిజానికి తెలియజేసేలా ఒక

700
00:33:25,640 --> 00:33:28,930
శీఘ్ర ఒక ఉదాహరణ వేడెక్కేలా
మేము ఇప్పటికే ఆపై కొనసాగండి లేదు

701
00:33:28,930 --> 00:33:31,160
కొద్దిగా క్లిష్టమైన ఏదో.

702
00:33:31,160 --> 00:33:34,980
నా కార్యక్రమం తెరుచుకుంటుంది కనుక
gedit అని -

703
00:33:34,980 --> 00:33:36,840
ఈ నా గ్రాఫికల్ ఎడిటర్.

704
00:33:36,840 --> 00:33:38,460
మరియు నేను ఆ చేయవచ్చు -

705
00:33:38,460 --> 00:33:39,820
నాకు అక్కడ ఆ విండోను మూసివేయండి వీలు -

706
00:33:39,820 --> 00:33:42,720
డౌన్ ఇక్కడ ఈ చిహ్నం ద్వారా,
ఎడమ లో gedit,

707
00:33:42,720 --> 00:33:44,170
మెను పక్కన మూలలో.

708
00:33:44,170 --> 00:33:48,670
>> నేను ముందుకు వెళ్లి ముందుకు వెళుతున్న, మరియు వెబ్
, అని, లోకి జాన్ ఈ ఉదాహరణ సేవ్

709
00:33:48,670 --> 00:33:49,660
హార్వర్డ్ యొక్క ఫోల్డర్.

710
00:33:49,660 --> 00:33:52,690
జాన్ హార్వర్డ్ యొక్క ఫోల్డర్ కేవలం తన ఉంది
తన ఫైళ్లు అన్ని నివసించే డైరెక్టరీ

711
00:33:52,690 --> 00:33:53,340
అప్రమేయంగా.

712
00:33:53,340 --> 00:33:58,410
మరియు నేను ఈ వంటి సేవ్ వెళుతున్న
హలో-0.c పిలువబడే ఒక ఫైల్.

713
00:33:58,410 --> 00:34:01,260
మరియు నేను ఈ పేరు ఎంచుకున్నారు ఇది
న నమూనా కోడ్ తో లైన్లు

714
00:34:01,260 --> 00:34:04,210
కోర్సు యొక్క వెబ్సైట్ మరియు
ఆన్లైన్ YouTube వీడియోలను.

715
00:34:04,210 --> 00:34:06,320
>> కాబట్టి ఇప్పుడు నేను ప్రారంభమవుతుంది వెళుతున్న
నా మొదటి ప్రోగ్రామ్ను రాయడం.

716
00:34:06,320 --> 00:34:08,469
నాకు అర్హత ఆధారంగా దత్తత కోసం జూమ్ లెట్.

717
00:34:08,469 --> 00:34:12,760
మరియు నేను ముందుకు వెళ్లి Int చెప్పటానికి వెళుతున్నాను
కేవలం ఇష్టం ఇది ప్రధాన శూన్యమైన, ఆ

718
00:34:12,760 --> 00:34:14,900
పసుపు పజిల్ ముక్క ఆ
ఒక కార్యక్రమం మొదలవుతుంది.

719
00:34:14,900 --> 00:34:18,290
నేను అలవాటు లోకి వెళ్ళి ఉండాల్సిందని
అప్పుడు, నా గిరజాల కలుపు ప్రారంభ సంవత్సరాలు

720
00:34:18,290 --> 00:34:22,000
ఇది మూసివేయడం తరువాత తిరిగి వెళుతున్న
నేను, నా కోడ్ను ఉంచాలి ఎక్కడ

721
00:34:22,000 --> 00:34:24,630
నాకు ప్రతిదీ ఉంచండి సహాయపడుతుంది ఎందుకంటే
ముఖ్యంగా నా వంటి, సమతుల్య

722
00:34:24,630 --> 00:34:25,880
కార్యక్రమం సుదీర్ఘ గెట్స్.

723
00:34:25,880 --> 00:34:29,239
>> మరియు ఇప్పుడు, ఇక్కడ, నేను ముందుకు వెళ్ళి వెళుతున్నాను
మరియు,, printf, చెప్పటానికి unquote కోట్

724
00:34:29,239 --> 00:34:34,330
హలో ప్రపంచ, బాక్ స్లాష్-n, దగ్గరగా కోట్,
దగ్గరగా కుండలీకరణములలో, సెమికోలన్.

725
00:34:34,330 --> 00:34:38,100
సో నేను మేము చేసిన ప్రతిదీ పునరావృతమైన వెబ్
ఇప్పటివరకు మంజూరు కోసం తీసుకోవడం.

726
00:34:38,100 --> 00:34:39,270
ఇప్పుడు నేను దూరంగా వెళుతున్న.

727
00:34:39,270 --> 00:34:43,030
>> మరియు డౌన్ ఇక్కడ ఈ టెర్మినల్ విండో, ఏ
నేను ఈ నల్ల చేయాలని అనుమతి

728
00:34:43,030 --> 00:34:44,389
మరియు విండో తెలుపు?

729
00:34:44,389 --> 00:34:46,977
నేను దేనిని ఉపయోగించవచ్చు?

730
00:34:46,977 --> 00:34:49,770
సో ఈ నేను ఆదేశాలను పేరు మరియు
పేరు నేను విషయాలు కంపైల్ చేయవచ్చు.

731
00:34:49,770 --> 00:34:50,620
మరియు నేను సాధారణ ఉంచడానికి వెళుతున్న.

732
00:34:50,620 --> 00:34:52,780
నేను ఒక కార్యక్రమం ఉపయోగించడానికి వెళుతున్నాను
మేక్ అని, ఇది కాదు

733
00:34:52,780 --> 00:34:54,020
సాంకేతికంగా ఒక కంపైలర్.

734
00:34:54,020 --> 00:34:56,360
కంపైలర్ యొక్క అని గణగణమని ద్వని చేయు, కానీ
మేము ఒక లో తిరిగి వచ్చి ఉంటుంది

735
00:34:56,360 --> 00:34:57,190
వారం లేదా రెండు యొక్క సమయం.

736
00:34:57,190 --> 00:35:03,410
>> ఇప్పుడు కోసం, నేను తయారు టైప్ వెళుతున్న
హలో-0, కానీ మీరు ఆ వారు

737
00:35:03,410 --> 00:35:07,050
మీ మనస్సుల్లో పోల్చడం నేను కేవలం
నేను టైప్ వుండాలి ఏమి టైప్ చేయవచ్చు

738
00:35:07,050 --> 00:35:10,180
నేను ఇప్పటికే తెలుసు
ఇక్కడ ఏదో.

739
00:35:10,180 --> 00:35:12,160
ఇప్పుడు, కొన్ని లోపాలు స్పష్టంగా ఉంది.

740
00:35:12,160 --> 00:35:16,742
నేను కూడా వారు ఏ, ఏమిటో చూడండి ముందు
నేను తప్పు ఏమి గా ఆలోచనలు?

741
00:35:16,742 --> 00:35:18,590
>> విద్యార్థులు: [వాయిసెస్ INTERPOSING].

742
00:35:18,590 --> 00:35:18,840
>> DAVID మలన్: అవును.

743
00:35:18,840 --> 00:35:20,640
నేను లైబ్రరీ యొక్క శీర్షికా ఫైలును లేదు చేస్తున్నాను.

744
00:35:20,640 --> 00:35:24,240
ఈ. H ఫైళ్ళలో ఏదైనా శీర్షిక అంటారు
ఫైళ్లను, మరియు వారు సమిష్టిగా

745
00:35:24,240 --> 00:35:25,680
గ్రంధాలయాలు అని విషయాలు చెందిన.

746
00:35:25,680 --> 00:35:28,030
లైబ్రరీస్ కేవలం కోడ్ రాళ్లను ఉన్నాయి
ఇతర ప్రజలు వ్రాసాడు.

747
00:35:28,030 --> 00:35:32,140
ప్రామాణిక [సో? నేను?] గ్రంథాలయం ఒక
కోడ్ కలిగి ఫైళ్లు సేకరణ

748
00:35:32,140 --> 00:35:33,330
ఇతర ప్రజలు వ్రాసాడు.

749
00:35:33,330 --> 00:35:34,820
>> కాబట్టి లేదు చేస్తున్నాను.

750
00:35:34,820 --> 00:35:36,520
అందుచే నేను ఒక లోపం పొందుతున్నాను?

751
00:35:36,520 --> 00:35:40,840
బాగా, నాకు తిరిగి అప్ లో స్క్రోల్ వీలు
ఇక్కడ నా టెర్మినల్ విండో.

752
00:35:40,840 --> 00:35:44,310
మరియు దురదృష్టవశాత్తు, సి లో, చాలా వంటి
ముఖ్యంగా ప్రోగ్రామింగ్ భాషలు,

753
00:35:44,310 --> 00:35:47,830
ఇది లోపం, మీకు అన్ని కొత్త ఉంటే
సందేశాలు నిర్దిష్టంగా ఉంటాయి, కానీ అవి కూడా ఉన్నారు

754
00:35:47,830 --> 00:35:48,620
చాలా రహస్యంగా.

755
00:35:48,620 --> 00:35:51,720
మరియు ఇక్కడ లోపం, ఎరుపు లో, ఉంది
"పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్

756
00:35:51,720 --> 00:35:57,660
printf రకం "మరియు అది స్క్రోల్స్
తదుపరి లైన్ కు "Int కాన్స్ట్ చార్ *,

757
00:35:57,660 --> 00:36:00,220
... "ఇది కేవలం నిజంగా గెట్స్
త్వరగా అధిక.

758
00:36:00,220 --> 00:36:04,420
>> అయితే మీరు,, చేయడానికి ప్రారంభం కావాలి
మళ్ళీ, ఈ అన్ని కొత్త, కేవలం కు

759
00:36:04,420 --> 00:36:06,010
కీలక పదాలు కోసం చూడండి ప్రారంభమవుతుంది.

760
00:36:06,010 --> 00:36:08,770
స్పష్టంగా, నేను సగం అర్థం కాదు
పదాల నేను ఇంకా tunnanu.

761
00:36:08,770 --> 00:36:10,140
మీరు అవుతుంది, అయితే, ఒక వారం యొక్క సమయం లో.

762
00:36:10,140 --> 00:36:11,230
కానీ నేను printf చూడండి.

763
00:36:11,230 --> 00:36:14,310
మరియు ఆ, దీర్ఘ ముందు, ప్రారంభం కావాలి
, అన్ని కుడి, printf మీ మెమరీ కుదుపు.

764
00:36:14,310 --> 00:36:15,210
ఏదో printf తో తప్పు.

765
00:36:15,210 --> 00:36:16,580
నేను తప్పు స్పెల్లింగ్ తెలుసా?

766
00:36:16,580 --> 00:36:18,130
కాదు, అది వంటి అనిపించడం లేదు - ఓహ్.

767
00:36:18,130 --> 00:36:21,350
నేను నేర్పిన తప్ప అది ఉపయోగించలేరు
అది ఉందని కంపైలర్.

768
00:36:21,350 --> 00:36:25,220
అందువలన, మళ్ళీ, నీ కోరికలు తో వెళ్ళి
మీరు నిజంగానే అర్థం లేదు కూడా

769
00:36:25,220 --> 00:36:26,510
అసలు లోపం సందేశాలు.

770
00:36:26,510 --> 00:36:30,240
>> నిజానికి, ఇక్కడ పరిష్కారం కేవలం ఉంది
ఫైలు యొక్క పైభాగం వద్ద ఉన్నాయి

771
00:36:30,240 --> 00:36:34,340
ఆ వలె నా ఫైలుతో resaving
కంట్రోల్-S లేదా ఫైల్ మెను.

772
00:36:34,340 --> 00:36:36,730
మరియు నేను ఇప్పుడు ఇక్కడ తిరిగి వెళ్ళి ఉంటే,
నేను ఈ క్లియర్ వెళుతున్న.

773
00:36:36,730 --> 00:36:39,150
కంట్రోల్-L కేవలం ఒక nice మార్గం
స్క్రీన్ క్లియర్.

774
00:36:39,150 --> 00:36:44,870
ఆపై నేను హలో తయారు "టైప్ వెళుతున్న
0 "ఎంటర్, మరియు ఇప్పుడు నేను ఇప్పటికీ ఒక చూడండి

775
00:36:44,870 --> 00:36:47,710
నిగూఢ సంకేతాలు క్రమం, కానీ
మేము తిరిగి వచ్చి ఉంటుంది.

776
00:36:47,710 --> 00:36:49,230
మీరు చేస్తున్న చేయండి ఏమిటి.

777
00:36:49,230 --> 00:36:52,590
ఇది తీసుకొనే ప్రక్రియ ఆటోమేటిక్గా లో
పాల్గొన్న అతి బాధించే ఆదేశం

778
00:36:52,590 --> 00:36:54,050
గణగణమని ద్వని చేయు, వాస్తవ కంపైలర్.

779
00:36:54,050 --> 00:36:57,460
కానీ నేను ఎటువంటి దోషాలు వచ్చింది వాస్తవం అర్థం
ఈ విషయం పని చేయాలి.

780
00:36:57,460 --> 00:37:00,630
>> నేను ఇప్పుడు చేయ బోతున్నాను -
నాకు మళ్ళీ జూమ్ వీలు -

781
00:37:00,630 --> 00:37:07,070
./hello-0 ఎంటర్, మరియు నిజానికి, నేను చూడండి
"హలో, ప్రపంచం." సో యొక్క ఇప్పుడు విస్తరించేందుకు వీలు

782
00:37:07,070 --> 00:37:12,105
ఈ ఇంత కొద్దిగా కేవలం ప్రతిబింబించేందుకు
దశలను మేము ఉద్దేశించిన.

783
00:37:12,105 --> 00:37:15,370
నేను ఈ పేరు వెళుతున్న
Hello1.c కు సేవ్.

784
00:37:15,370 --> 00:37:20,300
మరియు ఇప్పుడు నేను ఒక వేరియబుల్ డిక్లేర్ వెళుతున్నాను
పేరు, కాబట్టి స్ట్రింగ్ పేరు, అని

785
00:37:20,300 --> 00:37:23,420
మరియు నేను అది ఉంచాలి వెళుతున్నాను
కోట్-unquote విలువ

786
00:37:23,420 --> 00:37:27,030
D-A-V-I-D దగ్గరగా కోట్ సెమికోలన్.

787
00:37:27,030 --> 00:37:31,150
మరియు ఇప్పుడు నేను "ప్రపంచ" స్థానంలో వెళుతున్నాను
ఒక స్ట్రింగ్ కోసం ఏమి హోల్డర్ తో?

788
00:37:31,150 --> 00:37:32,200
% S.

789
00:37:32,200 --> 00:37:35,040
>> మరియు ఇప్పుడు, ఎన్ని వాదనలు తప్పక
printf ఈ సమయం పడుతుంది?

790
00:37:35,040 --> 00:37:35,700
రెండు సో.

791
00:37:35,700 --> 00:37:37,090
నేను వ్యాఖ్యలను బయట వెళ్ళండి.

792
00:37:37,090 --> 00:37:39,330
నేను ఒక కామా తర్వాత "పేరు" టైపు.

793
00:37:39,330 --> 00:37:41,550
కానీ నేను ఏదో చేశాను
వేరే తప్పు ఈ సమయం.

794
00:37:41,550 --> 00:37:43,940
కానీ యొక్క నేను లేదని భావించవచ్చు వీలు
ఆ ఇంకా గుర్తించలేరు.

795
00:37:43,940 --> 00:37:44,910
నాకు ఇక్కడ వీడలేదు.

796
00:37:44,910 --> 00:37:48,850
>> మరియు ప్రకటన, చాలా, నేను కొద్దిగా పొందుతున్నాను
టైపింగ్ విసుగు అన్ని "హలో 0 తయారు"

797
00:37:48,850 --> 00:37:50,180
సమయం, "తయారు" మరియు అన్ని ఈ.

798
00:37:50,180 --> 00:37:53,270
సో, దాన్ని చేస్తుంది, లినస్ వీటిని చెయ్యవచ్చు
తరచుగా మీ అప్ బాణం నొక్కండి

799
00:37:53,270 --> 00:37:56,850
కీబోర్డ్, మరియు మీరు నిజంగానే స్క్రోల్ చేయవచ్చు
నేను చేసిన ఆదేశాలను అన్ని ద్వారా

800
00:37:56,850 --> 00:37:58,830
ఇప్పుడు గత అమలు.

801
00:37:58,830 --> 00:38:02,040
నేను కనుక, అప్, అప్, ఆ
హలో 0 తయారు ఉంది.

802
00:38:02,040 --> 00:38:02,610
నేను ఆ వద్దు.

803
00:38:02,610 --> 00:38:05,450
నేను ఆ మార్చడానికి కావలసిన
హలో 1 ఈ సమయం, ఎంటర్ చెయ్యండి.

804
00:38:05,450 --> 00:38:07,620
చివరికి, విల్
మీరు కొంత సమయం సేవ్.

805
00:38:07,620 --> 00:38:08,150
>> అన్ని కుడి.

806
00:38:08,150 --> 00:38:09,520
దురదృష్టవశాత్తు, లోపం ఉంది అనిపిస్తుంది.

807
00:38:09,520 --> 00:38:10,980
సో నాకు పైకి స్క్రోల్ వీలు.

808
00:38:10,980 --> 00:38:13,120
ఈ నేను నిజంగా కనిపిస్తుంది
ఈ కార్యక్రమం butchered.

809
00:38:13,120 --> 00:38:16,530
నేను, నా దేవుడు అర్థం, అది కోడ్ యొక్క రెండు లైన్ల వార్తలు
మరియు లోపాలు దాని 10 పంక్తులు.

810
00:38:16,530 --> 00:38:18,800
కానీ మొదటి టాప్ ఒక చూడండి.

811
00:38:18,800 --> 00:38:21,640
అస్పష్టమైన గుర్తింపు స్ట్రింగ్ యొక్క ఉపయోగించండి.

812
00:38:21,640 --> 00:38:23,270
నేను n ప్రామాణిక అడిగారా?

813
00:38:23,270 --> 00:38:23,930
సంఖ్య నిజంగా కాదు.

814
00:38:23,930 --> 00:38:24,940
నేను స్ట్రింగ్ అంటే.

815
00:38:24,940 --> 00:38:29,390
>> కానీ స్ట్రింగ్ వేరియబుల్ పేరు ఉంది
రకం, డిక్లేర్డ్ మేము చెప్పటానికి dd?

816
00:38:29,390 --> 00:38:30,730
కనుక ఇది CS50 లైబ్రరీ ఉంది.

817
00:38:30,730 --> 00:38:33,740
సో ఈ మొదటి లో, తగినంత లేదు
వారాల జంట, కేవలం ఉపయోగించడానికి

818
00:38:33,740 --> 00:38:34,860
ఏ సి మాకు ఇస్తుంది.

819
00:38:34,860 --> 00:38:38,120
నేను కూడా ఇక్కడ వెళ్ళడానికి వెళ్ళడం, మరియు నేను రెడీ!
పైన లేదా క్రింది అది చాలు, కానీ నేను చేస్తాము కాలేదు

820
00:38:38,120 --> 00:38:40,340
అది అక్షర ఉంచేందుకు
విషయాలు క్రమముగా ఉంచడానికి.

821
00:38:40,340 --> 00:38:43,470
నేను, cs50.h ఉన్నాయి వెళుతున్న
ముందే ఇన్స్టాల్ ఇది

822
00:38:43,470 --> 00:38:44,900
CS50 ఉపకరణం మీరు.

823
00:38:44,900 --> 00:38:47,640
మరియు ప్రజలు కూడా ఓపెన్ సోర్స్, కనుక
ఇంటర్నెట్ వారి మీద ఉపయోగించవచ్చు

824
00:38:47,640 --> 00:38:48,450
సొంత కంప్యూటర్లు.

825
00:38:48,450 --> 00:38:50,700
కానీ అది CS50 ఉపకరణం తో వస్తుంది.

826
00:38:50,700 --> 00:38:55,320
>> కాబట్టి ఇప్పుడు నాకు తిరిగి వెళ్ళి మళ్ళీ కంపైల్ చెయ్యండి వీలు
ఈ హలో 1 తయారు.

827
00:38:55,320 --> 00:38:55,710
ఇది డామన్.

828
00:38:55,710 --> 00:38:57,240
మరో లోపం.

829
00:38:57,240 --> 00:38:59,370
అయితే, నాకు మొదటి వరకు స్క్రోల్ లెట్.

830
00:38:59,370 --> 00:39:00,630
ఈ ఒక కొద్దిగా క్లిష్టమైన వార్తలు.

831
00:39:00,630 --> 00:39:03,830
స్థిరంగా బహుళ పాత్ర పాత్ర.

832
00:39:03,830 --> 00:39:04,890
నాకు సహాయం లేదు.

833
00:39:04,890 --> 00:39:08,220
కానీ నోటీసు, గణగణమని ద్వని చేయు కనీసం ఒక చిన్న ఉంది
బిట్ మంచి, అనగా ఒక కొద్దిపాటి

834
00:39:08,220 --> 00:39:11,890
ఆకుపచ్చ caret చిహ్నం, ఇది మాట్లాడుతూ లో
నేను ఇరుక్కొనిపోయింది పేరు ఇక్కడ ఉంది.

835
00:39:11,890 --> 00:39:16,160
ఎందుకు ఆ తక్కువగా, సూచించబడిన
తర్వాతి సింగిల్ కోట్ కు ఆకుపచ్చ బాణం,

836
00:39:16,160 --> 00:39:18,290
నా పేరు?

837
00:39:18,290 --> 00:39:20,880
>> సో ఈ మీరు కేవలం విషయాలు ఒకటి
మీరు నేను ప్రత్యేకంగా, అలవాటుపడతారు

838
00:39:20,880 --> 00:39:23,980
పైథాన్, లేదా జావాస్క్రిప్ట్ లో ప్రోగ్రామింగ్,
లేదా ఇతర భాషలు పేరు ఈ వివరాలు

839
00:39:23,980 --> 00:39:24,560
పట్టింపు లేదు.

840
00:39:24,560 --> 00:39:25,740
సి లో, అది అవసరం.

841
00:39:25,740 --> 00:39:29,520
మీరు ఒక స్ట్రింగ్ ప్రకటించారు ఉంటే, ఇది
0 లేదా ఎక్కువ అక్షరాలు ఒక క్రమం,

842
00:39:29,520 --> 00:39:32,280
మీరు నిజంగానే డబుల్ కోట్స్ ఉపయోగించాలి.

843
00:39:32,280 --> 00:39:36,670
నేను నిజానికి ఈ తిరిగి మార్చడానికి అవసరం
కోట్ తెరవడానికి, తో, కోట్ ముగించలేదు

844
00:39:36,670 --> 00:39:37,800
డబుల్ కోట్స్.

845
00:39:37,800 --> 00:39:41,610
సింగిల్ కోట్స్ వారి స్థానంలో లేదు, కానీ
మీరు వ్యక్తిగత ఉపయోగిస్తున్నారు మాత్రమే

846
00:39:41,610 --> 00:39:44,100
మరొక సమయం అక్షరాలు, కాని.

847
00:39:44,100 --> 00:39:46,550
ఇప్పుడు కోసం, డబుల్ కోట్స్
అవసరమైన.

848
00:39:46,550 --> 00:39:50,460
>> కాబట్టి ఇప్పుడు, నా టెర్మినల్ తిరిగి వెళ్ళి తెలపండి
విండో, హలో 1 తయారు.

849
00:39:50,460 --> 00:39:51,450
మరియు నమ్మకంగా వార్తలు?

850
00:39:51,450 --> 00:39:53,800
ఈ కార్యక్రమం ఇప్పుడు వెళ్తున్నారు
సరిగ్గా కంపైల్ చేయుటకు?

851
00:39:53,800 --> 00:39:58,250

852
00:39:58,250 --> 00:39:58,540
OK.

853
00:39:58,540 --> 00:39:59,780
సో మాకు మూడు ఈ అనుకుంటున్నాను.

854
00:39:59,780 --> 00:40:00,280
అన్ని కుడి.

855
00:40:00,280 --> 00:40:01,190
ఎంటర్ చెయ్యండి.

856
00:40:01,190 --> 00:40:02,440
మరియు అది నిజానికి.

857
00:40:02,440 --> 00:40:05,130
అందువలన లోపాలు ఈ సమయం కూడా, ఉంది
ఈ కార్యక్రమం ఒక బిట్ సంపాదించిన లో అయితే

858
00:40:05,130 --> 00:40:05,840
మరింత క్లిష్టమైన.

859
00:40:05,840 --> 00:40:10,110
నేను ఇప్పుడు dot స్లాష్ హలో 1 లేకపోతే, ఎంటర్
ఇది చెప్పటానికి జరగబోతోంది "హలో, డేవిడ్."

860
00:40:10,110 --> 00:40:11,750
>> కానీ వీలు యొక్క మూడవ పునరుక్తి చేయండి
ఈ, పేరు

861
00:40:11,750 --> 00:40:13,380
కార్యక్రమం నిజంగా డైనమిక్ ఉంది.

862
00:40:13,380 --> 00:40:16,770
నాకు ముందుకు వెళ్లి ఫైలు మార్చడానికి లెట్
కేవలం అనుగుణ్యంగా పేరు,

863
00:40:16,770 --> 00:40:20,410
మీరు అందుబాటులో ఉంటుంది ఫైళ్లు
మీకు తర్వాత ఆన్లైన్.

864
00:40:20,410 --> 00:40:21,620
ఎంటర్ చెయ్యండి.

865
00:40:21,620 --> 00:40:25,510
మరియు ఇప్పుడు నేను మరియు వెళ్ళడానికి వెళుతున్నాను
హార్డ్ ఇక్కడ కోడ్ "డేవిడ్" నిల్వ.

866
00:40:25,510 --> 00:40:28,826
నేను చాలా మామూలుగా ఏమి కాలేదు
ఈ కార్యక్రమం అభివృద్ధి?

867
00:40:28,826 --> 00:40:30,520
>> నేను getstring అని పిలుస్తాము.

868
00:40:30,520 --> 00:40:33,240
ఇది కొద్దిగా కాని స్పష్టమైన ఏమిటి కావచ్చు
ఏమి గురించి, నేను వెళుతున్నాను

869
00:40:33,240 --> 00:40:38,470
నిజానికి మరొక లైన్, printf, జోడించడానికి
మరియు కేవలం, పేరు, కోలన్, దగ్గరగా కోట్ చెప్పటానికి

870
00:40:38,470 --> 00:40:40,790
యూజర్ ఒక ప్రాంప్ట్ ఇవ్వాలని
తెరపై.

871
00:40:40,790 --> 00:40:42,980
మరియు ఇప్పుడు నేను ఇక్కడకి వెళుతున్న, మరియు నేను రెడీ!
నా కీబోర్డ్ సత్వర మార్గాన్ని ఉపయోగించండి వెళుతున్న.

872
00:40:42,980 --> 00:40:47,680
నేను అప్, అప్ వెళ్ళడానికి వెళ్ళడం, మరియు మార్చడానికి వెబ్
హలో 2 1 హలో, ఎంటర్ చెయ్యండి.

873
00:40:47,680 --> 00:40:49,260
మరియు అదృష్టవశాత్తూ, నేను పురోభివృద్ధి సాధిస్తున్నట్లు వెబ్.

874
00:40:49,260 --> 00:40:52,720
>> మరియు ఇప్పుడు నేను వెళ్ళడానికి వెళుతున్నాను
డాట్ స్లాష్ హలో మరియు

875
00:40:52,720 --> 00:40:54,690
2, ఎంటర్ మార్చే.

876
00:40:54,690 --> 00:40:55,650
మరియు ఇప్పుడు నా కార్యక్రమం -

877
00:40:55,650 --> 00:40:57,700
నేను జూమ్ చేస్తాను - పెరిగిపోతుంది
prettier కొద్దిగా.

878
00:40:57,700 --> 00:41:02,190
పేరు అవతరిస్తుంది, వీలు యొక్క రాబ్ చెప్పటానికి
ఈ సమయం, హలో, రాబ్ ఎంటర్ చెయ్యండి.

879
00:41:02,190 --> 00:41:03,260
మేము మళ్ళీ చేయవచ్చు.

880
00:41:03,260 --> 00:41:05,360
పేరు, లారెన్, ఎంటర్ చెయ్యండి.

881
00:41:05,360 --> 00:41:07,820
పేరు, జోసెఫ్, ఎంటర్ చెయ్యండి.

882
00:41:07,820 --> 00:41:11,596
పేరు, అని ప్రయత్నించండి
కష్టం, ఎంటర్ చెయ్యండి.

883
00:41:11,596 --> 00:41:12,410
EH.

884
00:41:12,410 --> 00:41:14,680
ఇది నిజంగా ఒక బగ్ కాదు.

885
00:41:14,680 --> 00:41:16,090
కనుక ఇది కేవలం ఒక చిన్న అగ్లీ యొక్క.

886
00:41:16,090 --> 00:41:18,640
సో ఉండవచ్చు మేము ఈ పరిష్కరించడానికి కాలేదు
భవిష్యత్తులో, కాదు ఇప్పుడు.

887
00:41:18,640 --> 00:41:20,840
>> కానీ ఎలా మీరు సహజంగా చేస్తాను
ప్రసంగిస్తున్న గురించి వెళ్ళండి

888
00:41:20,840 --> 00:41:21,990
నిర్దిష్ట సవాలు?

889
00:41:21,990 --> 00:41:23,710
ఇది కేవలం తెలివితక్కువదని ఉంది.

890
00:41:23,710 --> 00:41:27,320
ఎలా మీరు విషయాలు తప్పించాలి
తెలివితక్కువదని చూస్తున్నారా?

891
00:41:27,320 --> 00:41:29,890
కనుక మనం చేయగల, OK, నేను ఒక జంట విన్న
విషయాలు, ఒక పరిస్థితి మరియు ఒక లూప్.

892
00:41:29,890 --> 00:41:33,340
మేము తనిఖీ, ఒక పరిస్థితి ఒక వాడవచ్చు
స్ట్రింగ్ యొక్క పొడవు ఏమిటి

893
00:41:33,340 --> 00:41:34,190
యూజర్ మాకు ఇచ్చింది?

894
00:41:34,190 --> 00:41:37,100
మరియు అది 0 అయితే, అది కేవలం unquote కోట్ లో
వారు కేవలం అప్పుడు, ఎంటర్ నొక్కండి

895
00:41:37,100 --> 00:41:38,930
బహుశా నేను వాటిని అరుస్తుంటారు ఉండాలి
మరియు వాటిని తిరిగి అడుగుతుంది.

896
00:41:38,930 --> 00:41:39,970
కానీ ఒక మళ్ళీ వాటిని ఎలా ప్రాంప్ట్ లేదు?

897
00:41:39,970 --> 00:41:44,230
Well, నేను కూడా లూప్ విన్న, మరియు నేను అనుకొనుట
మళ్ళీ మళ్ళీ మళ్ళీ అలా

898
00:41:44,230 --> 00:41:47,010
అదే విషయం కోసం యూజర్ ప్రాంప్ట్.

899
00:41:47,010 --> 00:41:48,880
>> వెల్, ఒక ఇతర ఉదాహరణకు అలా చేసుకుందాం
వేరే ఉపయోగించి

900
00:41:48,880 --> 00:41:50,620
CS50 లైబ్రరీ ఫంక్షన్.

901
00:41:50,620 --> 00:41:52,330
నాకు ఈ ఫైలు ముగించలేదు లెట్.

902
00:41:52,330 --> 00:41:53,510
నాకు ఒక క్రొత్త దాన్ని సృష్టించవచ్చు లెట్.

903
00:41:53,510 --> 00:41:58,510
మరియు నేను adder.c కాల్ చేస్తాము, కనుక
ఇది సులభమైన లెక్కలు నేర్చుకుంటారు సులభం

904
00:41:58,510 --> 00:42:00,890
ఈ పూర్తిగా ఉంటుంది అయినప్పటికీ
మీరు ఏ తో అంశం

905
00:42:00,890 --> 00:42:02,250
ఏ ఆధునిక కంప్యూటర్ తో.

906
00:42:02,250 --> 00:42:03,750
>> కానీ ఇప్పుడు నాకు ముందుకు వెళ్ళి వీలు మరియు -

907
00:42:03,750 --> 00:42:10,680
నేను చివరిసారిగా నా పాఠం నేర్చుకున్న - ఉన్నాయి
cs50.h, వాటిలో stdio.h, Int

908
00:42:10,680 --> 00:42:14,170
ప్రధాన శూన్యమైన, ఇది, ఇప్పుడు కోసం, నేను చేస్తాము
అంధ విశ్వాసం తీసుకుంటే, కానీ మేము చేపట్టడానికి చేస్తాము

909
00:42:14,170 --> 00:42:16,380
అర్థం అని
దీర్ఘ ముందు అంటే.

910
00:42:16,380 --> 00:42:21,030
మరియు నేను ఏదో చెప్పటానికి వెళుతున్నాను
వంటి "నాకు ఒక Int ఇవ్వాలని."

911
00:42:21,030 --> 00:42:22,140
>> మరియు ఇప్పుడు, నేను ఒక Int వస్తుందా?

912
00:42:22,140 --> 00:42:26,820
నేను చివరికి ఒక వేరియబుల్ డిక్లేర్ అనుకుంటున్నారా
రకం Int యొక్క x మరియు అని

913
00:42:26,820 --> 00:42:29,240
అది యూజర్ నుండి ఒక పూర్ణ సంఖ్య నిల్వ.

914
00:42:29,240 --> 00:42:29,970
తద్వారా ఒక మౌత్ఫుల్ ఉంది.

915
00:42:29,970 --> 00:42:35,680
కానీ ఎవరైనా అడగాలని కోరుకుంటుంది ఉంటే, ఎలా
నేను పూర్ణాంకం అని x డిక్లేర్ చెయ్యాలి?

916
00:42:35,680 --> 00:42:36,310
Int x.

917
00:42:36,310 --> 00:42:37,430
>> కనుక ఇది నిజంగా సులభం.

918
00:42:37,430 --> 00:42:38,240
నాకు ఒక Int ఇవ్వండి.

919
00:42:38,240 --> 00:42:39,070
ఇది x కాల్.

920
00:42:39,070 --> 00:42:40,580
ఇప్పుడు నేను అప్పగించిన ఆపరేటర్లు ఉపయోగించడానికి.

921
00:42:40,580 --> 00:42:43,400
మరియు ఎలా నేను నిల్వ లేదు
యూజర్ యొక్క విలువ ఎడమ?

922
00:42:43,400 --> 00:42:47,310
నేను, getstring కాల్ వద్దు
ఖచ్చితంగా, కానీ getint.

923
00:42:47,310 --> 00:42:49,060
ఏ వాదనలు?

924
00:42:49,060 --> 00:42:49,350
నం

925
00:42:49,350 --> 00:42:51,870
కనుక ఇది బ్రాకెట్, దగ్గరగా బ్రాకెట్ తెరవబడి
వెంటనే, ఆపై ఒక

926
00:42:51,870 --> 00:42:53,440
సెమికోలన్ లైన్ ముగుస్తుంది.

927
00:42:53,440 --> 00:42:54,930
>> ఇప్పుడు నాకు మళ్ళీ మనం.

928
00:42:54,930 --> 00:42:57,070
నాకు మరొక Int ఇవ్వండి.

929
00:42:57,070 --> 00:43:01,850
ఈ సమయం నేను Int చేస్తాను, లెట్స్
ఇది y కాల్, getint సమానం.

930
00:43:01,850 --> 00:43:05,060
మరియు ఇప్పుడు నాకు సూపర్ సాధారణ ఏదో తెలియజేసేలా
కొన్ని గణిత వంటి.

931
00:43:05,060 --> 00:43:14,340
సో printf,% d మొత్తం ఉంది
ఒక Int కోసం హోల్డర్.

932
00:43:14,340 --> 00:43:20,030
మరియు% d, కాలం, బాక్ స్లాష్-n.

933
00:43:20,030 --> 00:43:20,360
>> అన్ని కుడి.

934
00:43:20,360 --> 00:43:21,670
తద్వారా నిజానికి గణిత కాదు.

935
00:43:21,670 --> 00:43:25,500
కానీ నేను ఈ మొత్తం అంతరంలో ఉంటే
విలువ ప్లస్ ఈ విలువ సమానం

936
00:43:25,500 --> 00:43:29,320
ఇతర విలువ, ఎన్ని వాదనలు లోకి
మొత్తం నేను, printf ఇవ్వడం చేయాలి

937
00:43:29,320 --> 00:43:30,520
చివరికి?

938
00:43:30,520 --> 00:43:31,420
నాలుగు సో, కుడి?

939
00:43:31,420 --> 00:43:33,790
అప్పుడు ఈ స్ట్రింగ్ మరియు మూడు విలువలు.

940
00:43:33,790 --> 00:43:37,560
X మొదటి కాబట్టి నేను ఉండాలనుకుంటున్నాను
% d మొదటి ప్లగ్.

941
00:43:37,560 --> 00:43:39,270
y తదుపరి అవతరిస్తుంది.

942
00:43:39,270 --> 00:43:42,030
>> మరియు ఇప్పుడు నేను రకమైన అంతరంలో
z, కానీ z లేదు.

943
00:43:42,030 --> 00:43:43,190
కానీ ఒక పెద్ద ఒప్పందం కాదు.

944
00:43:43,190 --> 00:43:45,440
ఎందుకంటే మీరు, సహజంగా ఏం చేస్తారు
మీరు ఒక కలిగి ముఖ్యంగా

945
00:43:45,440 --> 00:43:47,820
గ్రాఫింగ్ కాలిక్యులేటర్, మీరు ఏమి టైప్ చెయ్యాలి?

946
00:43:47,820 --> 00:43:48,760
ఎలా x ప్లస్ y గురించి?

947
00:43:48,760 --> 00:43:50,200
కనుక ఇది ఒక వాస్తవ వేరియబుల్ కాదు.

948
00:43:50,200 --> 00:43:51,820
ఇది కేవలం రెండు మొత్తం వార్తలు
ఇతర చరరాశుల.

949
00:43:51,820 --> 00:43:53,170
మరియు ఆ సంపూర్ణ చట్టబద్ధమైన వార్తలు.

950
00:43:53,170 --> 00:43:56,630
సి ఖచ్చితంగా సాధారణ అర్థం
ఈ వంటి అంక.

951
00:43:56,630 --> 00:43:58,450
>> సెమికోలన్, సేవ్.

952
00:43:58,450 --> 00:44:02,080
ఇప్పుడు నాకు ఇక్కడ డౌన్ వీలు మరియు
ఎంటర్, కట్లపాము తయారు టైప్ చేయండి.

953
00:44:02,080 --> 00:44:04,100
సంఖ్య లోపం, చాలా పురోగతి యొక్క తద్వారా.

954
00:44:04,100 --> 00:44:04,890
కట్లపాము టైప్ చేయండి.

955
00:44:04,890 --> 00:44:07,100
మరియు మరొక కీబోర్డ్ సత్వరమార్గం,
మీరు విసుగు చెంది ఉంటాడు చేసుకోగా మొదలు ఉంటే

956
00:44:07,100 --> 00:44:08,760
- అన్ని ఆదేశాలను తో

957
00:44:08,760 --> 00:44:12,650
మీరు ఒక కమాండ్ టైప్ మొదలు ఉంటే, వంటి డాట్
ప్రకటన స్లాష్, మరియు ఆ పేరు మీ

958
00:44:12,650 --> 00:44:16,020
విసుగు మీరు సాధారణంగా నొక్కండి, లో కిక్స్
టాబ్ కంప్యూటర్ పూర్తి కలిగి

959
00:44:16,020 --> 00:44:20,510
అది కాదు మీరు కోసం పదబంధం యొక్క విశ్రాంతి
అస్పష్ట ఏమి ప్రకటనతో వచ్చి ఉండాలి.

960
00:44:20,510 --> 00:44:23,950
>> కాబట్టి ఇప్పుడు నాకు ముందుకు వెళ్ళి తెలపండి
మరియు మీరు Enter ని క్లిక్ చెయ్యండి.

961
00:44:23,950 --> 00:44:27,490
నాకు ఒక Int, 1, 2 ఇవ్వండి, మరియు
అదృష్టవశాత్తూ, అది 3 వార్తలు.

962
00:44:27,490 --> 00:44:29,900
కానీ ఎప్పుడూ, కార్యక్రమాలు పరీక్ష
తగ్గించేందుకు ఉండకూడదు

963
00:44:29,900 --> 00:44:30,820
కేవలం ఒకసారి ప్రయత్నిస్తున్నారు.

964
00:44:30,820 --> 00:44:35,560
నాకు ప్రతికూల వలె ఒక మూల సందర్భంలో, ప్రయత్నించండి లెట్
1, నాకు 1 ఇవ్వాలని, మరియు ఒక

965
00:44:35,560 --> 00:44:36,210
అలాగే అవుట్ తనిఖీ.

966
00:44:36,210 --> 00:44:38,870
మరియు నేను బహుశా కొన్ని మరింత చేయాలనుకుంటున్నారా
కఠిన పరీక్ష, కానీ నేను అందంగా ఉంటాను

967
00:44:38,870 --> 00:44:40,630
ఆ ఎక్కడ సౌకర్యంగా.

968
00:44:40,630 --> 00:44:43,110
>> బాగా, ఇప్పుడు యొక్క మరొక కార్యక్రమం ప్రయత్నించండి తెలపండి
ఈ సమయం ఒక ఉపయోగిస్తుంది

969
00:44:43,110 --> 00:44:44,620
ఇతర సింటెక్స్ బిట్.

970
00:44:44,620 --> 00:44:46,100
నాకు ఒక కొత్త ఫైల్ సృష్టించడానికి వీలు.

971
00:44:46,100 --> 00:44:51,050
నేను లైన్ ఈ conditions0.c కాల్ చేస్తాము
అప్ కొన్ని నమూనా కోడ్ ఆన్లైన్ తో.

972
00:44:51,050 --> 00:44:55,550
మరియు నాకు ముందుకు వెళ్లి తెలియజేసేలా
ఉన్నాయి, cs50.h ఉన్నాయి

973
00:44:55,550 --> 00:45:00,320
ప్రధాన శూన్యంలో stdio.h, -

974
00:45:00,320 --> 00:45:01,030
OK.

975
00:45:01,030 --> 00:45:01,850
అక్కడ మేము వెళ్ళి.

976
00:45:01,850 --> 00:45:03,010
మేము మా ప్రామాణిక బాయిలెర్ప్లేట్ కలిగి.

977
00:45:03,010 --> 00:45:08,170
>> మరియు ఈ సమయం నేను, printf చెప్పటానికి వెళుతున్నాను
కేవలం "నేను ఒక Int, దయచేసి, అవ్వాలనుకుంటే"

978
00:45:08,170 --> 00:45:10,030
ప్రాంప్ట్ కొద్దిగా తయారు
మరింత అనుకూలమైన.

979
00:45:10,030 --> 00:45:11,620
మరియు ఇప్పుడు నేను ఒక పొందాలనుకోవడం
యూజర్ నుండి INT.

980
00:45:11,620 --> 00:45:15,010
నేను, అది n ఈ సమయం కాల్ వెళుతున్న
n సంఖ్య వంటి ధ్వనులు ఎందుకంటే.

981
00:45:15,010 --> 00:45:18,140
getint, మరియు ఇప్పుడు, ఏమి
నేను చేయాలనుకుంటున్నారా?

982
00:45:18,140 --> 00:45:21,640
బాగా, n ఉంటే - మరియు నేను జూమ్ చేస్తాను -

983
00:45:21,640 --> 00:45:25,930
n 0 కంటే ఎక్కువ ఉంటే, నేను మీరు
కింది చేయాలని -

984
00:45:25,930 --> 00:45:36,060
printf "మీరు ఒక అనుకూల సంఖ్య ఎంపిక."
వేరే ఐ "printf టైప్ వెళుతున్న

985
00:45:36,060 --> 00:45:37,870
ఒక ప్రతికూల ఎంపిక

986
00:45:37,870 --> 00:45:39,650
సంఖ్య. "అన్ని కుడి.

987
00:45:39,650 --> 00:45:44,410
నేను చేసింది కూడా అయితే ఈ కార్యక్రమం,
ఫాస్ట్, కుడి పదము కనిపిస్తుంది.

988
00:45:44,410 --> 00:45:45,010
నాకు ఈ ప్రయత్నించండి లెట్.

989
00:45:45,010 --> 00:45:46,890
పరిస్థితి 0 చేయండి.

990
00:45:46,890 --> 00:45:47,710
అమలు తెలుస్తోంది.

991
00:45:47,710 --> 00:45:49,230
పరిస్థితి 0, ఎంటర్.

992
00:45:49,230 --> 00:45:51,910
యొక్క 50 యొక్క ఒక Int ఇవ్వాలని లెట్.

993
00:45:51,910 --> 00:45:53,160
నేను ఒక మంచి సంఖ్య చేసుకుంది.

994
00:45:53,160 --> 00:45:54,230
యొక్క మళ్ళీ ప్రయత్నించండి లెట్.

995
00:45:54,230 --> 00:45:54,930
పరిస్థితి 0.

996
00:45:54,930 --> 00:45:56,260
50 ప్రతికూల.

997
00:45:56,260 --> 00:45:57,290
నేను రుణ సంఖ్య చేసుకుంది.

998
00:45:57,290 --> 00:46:00,350
>> కానీ ఇప్పుడు, మేము ఉంటాం ఏమి నాకు ఎంచుకోండి తెలపండి
ఒక మూలలో కేసు కాల్, ఇది ఎక్కువ

999
00:46:00,350 --> 00:46:04,702
మీరు భావించే ఒక ఆసక్తికరమైన విషయం
మీరు కొన్ని సమస్యలు, 0 ఇస్తాయి.

1000
00:46:04,702 --> 00:46:07,940
ఇప్పుడు, నేను ఈ ఒకటి అందంగా ఖచ్చితంగా రెడీ!
సున్నా పేరు ఆ మూలలో కేసులు

1001
00:46:07,940 --> 00:46:12,330
అనుకూల లేదా ప్రతికూల కానీ, నా
కార్యక్రమం, పదము, అయితే

1002
00:46:12,330 --> 00:46:15,440
సరి - ఇది కూర్చింది, అది నడుస్తుంది -
తార్కికంగా సరియైన కాదు.

1003
00:46:15,440 --> 00:46:21,050
నేను అనుకుంటే చాలా సులభ పరిష్కారము ఇక్కడ ఏమిటి
నేను n నిర్వహించడానికి అనుకుంటే, గుర్తించడం

1004
00:46:21,050 --> 00:46:23,840
విడివిడిగా 0 సమానం?

1005
00:46:23,840 --> 00:46:32,980
>> N 0 సమానం అయితే, అప్పుడు నేను చెప్పాలనుకోవడం
printf వంటి ఏదో "మీరు 0 చేసుకుంది."

1006
00:46:32,980 --> 00:46:33,990
నాకు ఇప్పుడు ఈ ప్రయత్నించండి లెట్.

1007
00:46:33,990 --> 00:46:38,320
క్లియర్, నాకు తిరిగి ఇక్కడకి లెట్
నా విండో, మరియు మళ్ళీ కంపైల్ చెయ్యండి.

1008
00:46:38,320 --> 00:46:38,690
అవును.

1009
00:46:38,690 --> 00:46:39,770
ఒక దోషాన్ని.

1010
00:46:39,770 --> 00:46:41,630
కానీ, నేను మీరు తనిఖీ చెయ్యాలనుకుంటున్నారా
n 0 సమానం ఉంటే.

1011
00:46:41,630 --> 00:46:44,230

1012
00:46:44,230 --> 00:46:47,720
>> మరలా, మరొక తెలివితక్కువదని విషయం
ఉపయోగిస్తారు పొందడానికి, సమాన చిహ్నం

1013
00:46:47,720 --> 00:46:48,910
అప్పగించిన ఆపరేటర్లు.

1014
00:46:48,910 --> 00:46:52,240
సో ఈ, వాస్తవానికి ఆ తప్పు
సాంకేతికంగా, అయినప్పటికీ కంపైలర్

1015
00:46:52,240 --> 00:46:56,450
నాకు నుండి నాకు రక్షణ, మేము ఇష్టం
సాంకేతికంగా n లోకి 0 కాపీ అవుతుంది, ఇది

1016
00:46:56,450 --> 00:46:57,590
నేను ఏమి లేదు.

1017
00:46:57,590 --> 00:47:00,950
నేను సమానత్వం కోసం పరీక్షించడానికి కావలసిన
తో సమానం సమానం.

1018
00:47:00,950 --> 00:47:03,390
అందువలన ఇప్పుడు కావచ్చు
నా మంచి పరిష్కారం.

1019
00:47:03,390 --> 00:47:07,810
>> నాకు నిజానికి, ఈ resave చెప్పటానికి, లెట్
conditions1, కొత్త మరియు మెరుగైన ఉండాలి.

1020
00:47:07,810 --> 00:47:10,480
నేను ఈ మళ్ళీ కంపైల్ చెయ్యండి సో ఇప్పుడు,
పరిస్థితులు చేస్తుంది -

1021
00:47:10,480 --> 00:47:16,960
అయ్యో - తయారు conditions1 డాట్ స్లాష్
conditions1, నేను ఒక Int అవ్వాలనుకుంటే ", ఎంటర్

1022
00:47:16,960 --> 00:47:18,760
. "నేను వెళ్ళి వెళుతున్న దయచేసి
ముందుకు మరియు 50 టైప్ చేయండి.

1023
00:47:18,760 --> 00:47:19,660
ఇది ఇప్పటికీ బావుంటుంది.

1024
00:47:19,660 --> 00:47:21,200
ఇప్పటికీ మంచి, 50 ప్రతికూల.

1025
00:47:21,200 --> 00:47:24,920
0, మరియు అది, నిజానికి, కనుగొనబడింది
నేను 0 తీసుకున్నట్టు.

1026
00:47:24,920 --> 00:47:28,200
>> సో వాట్ మరింత నేను ఇప్పుడు ఈ తో చేయవచ్చు?

1027
00:47:28,200 --> 00:47:32,280
బాగా, మేము ఖచ్చితంగా ఎక్కువ చేయవచ్చు
సంక్లిష్ట విషయాలను.

1028
00:47:32,280 --> 00:47:37,240
కానీ నేను ప్రతిపాదించారు అవ్వాలనుకుంటే ఉంది
మేము ఇక్కడ ఈ నోట్ న ముగించి.

1029
00:47:37,240 --> 00:47:41,680
మేము ఈ పుల్ అప్, మీరు, బహుశా, చూస్తారు
మీ యొక్క ఇష్టమైన కార్టూన్

1030
00:47:41,680 --> 00:47:43,326
ఈరోజు వరకు వాటిని
అర్థం ఎప్పుడూ.

1031
00:47:43,326 --> 00:47:46,550

1032
00:47:46,550 --> 00:47:49,520
మరియు ఆ నవ్వు నాణ్యత గురించి
మీరు CS జోకులు తో పొందాలి.

1033
00:47:49,520 --> 00:47:51,060
తద్వారా గురించి సరియే.

1034
00:47:51,060 --> 00:47:54,900
>> మరింత compellingly, నేను ఇష్టం ఆలోచన
మాకు సోమవారం కొద్దిగా టీజర్ ఇవ్వాలని.

1035
00:47:54,900 --> 00:47:56,430
సో మనం పూర్ణాంకం ఉపయోగించడం ప్రారంభించారు చేసిన.

1036
00:47:56,430 --> 00:47:57,510
మేము తేలటం సూచిస్తారు చేసిన.

1037
00:47:57,510 --> 00:48:00,120
మేము కూడా, డబుల్స్ సూచిస్తారు చేసిన
ఇది, తిరిగి, మీరు సంఖ్యలు చెబుతాయి

1038
00:48:00,120 --> 00:48:01,390
డెసిమల్ పాయింట్లు తరువాత.

1039
00:48:01,390 --> 00:48:04,230
>> కానీ ఆ తేలటం హాజరవుతారు మరియు
డబుల్స్, మరియు, నిజంగా, కంప్యూటర్లు,

1040
00:48:04,230 --> 00:48:08,470
ప్రాథమికంగా, వ్యక్తం కాదు
ఖచ్చితంగా కొన్ని విలువలు.

1041
00:48:08,470 --> 00:48:12,840
మేము గణిత శాస్త్ర తరగతుల్లో నుండి తెలుసు మీరు చేస్తాడు
తరువాత సంఖ్యల ఏ సంఖ్య కలిగి

1042
00:48:12,840 --> 00:48:13,510
దశాంశ బిందువు.

1043
00:48:13,510 --> 00:48:16,460
మరియు మీరు కూడా ఒక నిలువు బార్ ఉంచవచ్చు
ఈ ఎప్పటికీ కొనసాగుతాయి చెప్పటానికి.

1044
00:48:16,460 --> 00:48:18,810
>> దురదృష్టవశాత్తు, మీరు నిజంగానే మార్చలేను
ఒక కంప్యూటర్ లో అలా.

1045
00:48:18,810 --> 00:48:20,400
అందువలన మూలలో కేసులు ఉత్పన్నమయ్యే.

1046
00:48:20,400 --> 00:48:23,120
ఉదాహరణకు, మీరు ఊహించు
ఆర్థిక ఏదో చేయడం.

1047
00:48:23,120 --> 00:48:25,700
మీరు గణితం చేస్తున్న
శాతం, మరియు

1048
00:48:25,700 --> 00:48:27,030
తో డాలర్లని సెంట్లు.

1049
00:48:27,030 --> 00:48:29,230
మరియు ఆ సెంట్లు లేదు
లైన్ అప్ అవసరం.

1050
00:48:29,230 --> 00:48:34,120
బాగా, అది ఆ భిన్నాలు హాజరవుతారు
పెన్నీలు చేస్తున్న జోడించడానికి ప్రారంభించవచ్చు

1051
00:48:34,120 --> 00:48:37,250
ఒక కంప్యూటర్ వ్యవస్థ చిత్రించిన
విధంగా తెలివైన

1052
00:48:37,250 --> 00:48:39,100
మానవులు పొందగలరు.

1053
00:48:39,100 --> 00:48:42,650
>> మరియు చూడని ఎవరు మీరు యొక్క ఆ, నేను ఇష్టం
మీరు ఒక 30 సెకన్ల టీజర్ ఇవ్వాలని ఇష్టం

1054
00:48:42,650 --> 00:48:48,290
ఆఫీస్ స్పేస్ అని పిలిచే ఒక అద్భుతమైన చిత్రం,
ఒక చిత్రాన్ని చిత్రించడానికి ఇది

1055
00:48:48,290 --> 00:48:51,205
మేము అధిగమించేందుకు కమిటీ సమస్య
సోమవారం మొదటి విషయం.

1056
00:48:51,205 --> 00:48:53,960
మేము వాల్యూమ్ పెంచడానికి అని
కొద్దిగా, నేను మీరు 30 ఇవ్వాలని

1057
00:48:53,960 --> 00:48:55,495
ఆఫీస్ స్పేస్ సెకన్లు.

1058
00:48:55,495 --> 00:48:55,770
>> [వీడియో ప్లేబ్యాక్]

1059
00:48:55,770 --> 00:48:59,000
>> I-అర్థం, మీరు, మీరు చూపిస్తున్న కాలేదు
అప్ మరియు మీరు మీ పని ఉంచాలని పొందుటకు.

1060
00:48:59,000 --> 00:49:00,620
>> -అసలైన, నేను ప్రచారంలోకి వెబ్.

1061
00:49:00,620 --> 00:49:03,240
>> -నేను ఇష్టం ఒక వైరస్ ప్రోగ్రామ్ కాలేదు
పెద్ద సమయం ఆఫ్ ఆ స్థలం చీల్చివేయు.

1062
00:49:03,240 --> 00:49:04,430
>> బాగా, అది ఎలా పనిచేస్తుంది?

1063
00:49:04,430 --> 00:49:06,782
>> ఒక బ్యాంకు లావాదేవీ ఉంది-ప్రతిసారీ
ఆసక్తి లెక్కించవచ్చు, మరియు అక్కడ ఉన్న

1064
00:49:06,782 --> 00:49:10,160
వేల ఒక రోజు ఉన్నాయి, కంప్యూటర్ ముగుస్తుంది
ఒక శాతం ఈ భిన్నాలు తో.

1065
00:49:10,160 --> 00:49:12,030
>> కాని నేను వెళ్ళడం లేదు
అక్రమ ఏదైనా.

1066
00:49:12,030 --> 00:49:12,660
>> అక్రమ?

1067
00:49:12,660 --> 00:49:15,075
సమీర్, ఈ అమెరికా ఉంది.

1068
00:49:15,075 --> 00:49:16,570
>> -మేము దేవుని ప్రమాణ కలిగి.

1069
00:49:16,570 --> 00:49:19,070
>> -ఉంటే ఎవరూ దీని గురించి తెలుసు
కానీ మాకు, అన్ని కుడి?

1070
00:49:19,070 --> 00:49:21,920
కుటుంబ సభ్యులు, సంఖ్య
స్నేహితులు, ఎవరూ.

1071
00:49:21,920 --> 00:49:22,700
>> ఆఫ్ కోర్సు.

1072
00:49:22,700 --> 00:49:23,320
>> -అంగీకరించింది.

1073
00:49:23,320 --> 00:49:24,280
>> ఆందోళన, మనిషి Don't.

1074
00:49:24,280 --> 00:49:25,640
నేను గాని ఎవరికీ లేదు.

1075
00:49:25,640 --> 00:49:26,504
>> [END వీడియో ప్లేబ్యాక్]

1076
00:49:26,504 --> 00:49:30,030
>> DAVID మలన్: సో ఈ, అప్పుడు, CS50 ఉంది,
ఆ ఆఫీస్ స్పేస్ ఉంది, మరియు ఇది అన్ని అవుతుంది

1077
00:49:30,030 --> 00:49:31,465
సోమవారం అర్ధవంతం.

1078
00:49:31,465 --> 00:49:33,940
అప్పుడు మీరు చూడండి.

1079
00:49:33,940 --> 00:49:37,880
>> కథకుడు: తదుపరి CS50, రాబ్ వద్ద
ఆఫ్ కావడంతో సర్దుబాటు

1080
00:49:37,880 --> 00:49:39,130
హార్వర్డ్ భోజన పథకం.

1081
00:49:39,130 --> 00:49:56,160