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

2
00:00:02,420 --> 00:00:05,189

3
00:00:05,189 --> 00:00:05,980
సల అన్ని కుడి.

4
00:00:05,980 --> 00:00:08,540
కాబట్టి యొక్క మరొక గురించి మాట్లాడటానికి వీలు
సి రకమైన ఏకైక అని విషయం

5
00:00:08,540 --> 00:00:10,010
ఇది డేటా రకాలను మరియు వేరియబుల్స్.

6
00:00:10,010 --> 00:00:12,340
చేసినప్పుడు నేను చెప్పే ఏకైక C వరకు, నేను నిజంగా
మాత్రమే సందర్భంలో అర్థం,

7
00:00:12,340 --> 00:00:14,470
మీరు ఒక ప్రోగ్రామర్ ఉన్నాను ఉంటే
ఒక నిజంగా కాలం,

8
00:00:14,470 --> 00:00:16,270
మీరు బహుశా లేదు చేసిన
డేటా రకాల పని

9
00:00:16,270 --> 00:00:18,470
మీరు ఆధునిక ఉపయోగించి ఉంటే
ప్రోగ్రామింగ్ భాషలు.

10
00:00:18,470 --> 00:00:20,432
వంటి ఆధునిక భాషలు
PHP మరియు JavaScript,

11
00:00:20,432 --> 00:00:22,640
మేము కూడా కొద్దిగా చూస్తారు ఇది
తరువాత కోర్సు లో,

12
00:00:22,640 --> 00:00:25,550
మీరు నిజంగా తెలుపుటకు లేదు
ఒక వేరియబుల్ యొక్క డేటా రకం

13
00:00:25,550 --> 00:00:26,270
మీరు ఉపయోగించినప్పుడు.

14
00:00:26,270 --> 00:00:28,067
>> మీరు కేవలం అది ప్రకటించి ఉపయోగించడం ప్రారంభించడానికి.

15
00:00:28,067 --> 00:00:29,900
అది ఒక పూర్ణాంకం, అది
అది ఒక పూర్ణాంకం తెలుసు.

16
00:00:29,900 --> 00:00:31,960
ఇది ఒక పాత్ర యొక్క ఉంటే, అది
ఇది ఒక పాత్ర యొక్క తెలుసు.

17
00:00:31,960 --> 00:00:35,320
అది ఒక పదం, అది తెలుసు
ఇది అని పిలవబడే ఒక స్ట్రింగ్, వార్తలు.

18
00:00:35,320 --> 00:00:37,300
>> కానీ సి లో ఇది ఒక
పాత భాష, మేము అవసరం

19
00:00:37,300 --> 00:00:39,420
డేటా తెలుపుటకు
ప్రతి వేరియబుల్ రకం

20
00:00:39,420 --> 00:00:42,990
మేము మొదటి సారి సృష్టించే
మేము ఆ వేరియబుల్ ఉపయోగించడానికి ఆ.

21
00:00:42,990 --> 00:00:45,030
కాబట్టి సి కొన్ని వస్తుంది
అంతర్నిర్మిత డేటా రకాల.

22
00:00:45,030 --> 00:00:46,972
మరియు యొక్క తెలిసిన పొందుటకు వీలు
ఆ కొన్ని.

23
00:00:46,972 --> 00:00:50,180
ఆపై తర్వాత మేము కూడా ఒక మాట్లాడదాము
డేటా రకాల కొన్ని గురించి కొద్దిగా

24
00:00:50,180 --> 00:00:54,450
మేము మీరు రాసిన చేసిన,
కాబట్టి మీరు CS50 లో వాటిని ఉపయోగించవచ్చు.

25
00:00:54,450 --> 00:00:56,130
>> మొదటి Int ఉంది.

26
00:00:56,130 --> 00:00:59,110
పూర్ణాంకానికి డేటా రకం వేరియబుల్స్ కోసం ఉపయోగిస్తారు
ఆ పూర్ణాంక విలువలు నిల్వ చేస్తుంది.

27
00:00:59,110 --> 00:01:03,210
కాబట్టి 1, 2, 3, ప్రతికూల 1, 2, 3, మరియు అందువలన న.

28
00:01:03,210 --> 00:01:05,960
ఏదో మీరు ఇది పూర్ణ,
క్విజ్ గుర్తుంచుకోండి ఉండాలి,

29
00:01:05,960 --> 00:01:09,590
ఎల్లప్పుడూ నాలుగు బైట్లు పడుతుంది
మెమరీ, 32 బిట్స్ ఉంది.

30
00:01:09,590 --> 00:01:11,620
ఒక బైట్ ఎనిమిది బిట్స్ ఉన్నాయి.

31
00:01:11,620 --> 00:01:14,470
>> కాబట్టి ఈ పరిధిలో అర్థం
పూర్ణాంకం నిల్వ చేసే విలువలను

32
00:01:14,470 --> 00:01:19,130
లోపల ఇముడుతుంది ఏమి ద్వారా పరిమితం చేయబడింది
సమాచారం యొక్క విలువ 32 బిట్స్.

33
00:01:19,130 --> 00:01:21,850
ఇప్పుడు దాన్ని మారుతుంది గా,
ఇది చాలా కాలం క్రితం నిర్ణయించారు

34
00:01:21,850 --> 00:01:24,310
మేము విభజించదు అని
32 బిట్స్ ఆ పరిధిలో

35
00:01:24,310 --> 00:01:26,650
ప్రతికూల పూర్ణాంకాల లోకి
మరియు ధనాత్మక పూర్ణాంకాలు,

36
00:01:26,650 --> 00:01:28,390
పరిధి యొక్క ప్రతి పొందడానికి సగం.

37
00:01:28,390 --> 00:01:32,230
మేము సూచిస్తుంది ఆ విలువల పరిధి కాబట్టి
ప్రతికూల 2 నుండి ఒక పూర్ణ పరిధితో

38
00:01:32,230 --> 00:01:36,520
2 31 అధికారంలోకి కు
31 శక్తి మైనస్ 1,

39
00:01:36,520 --> 00:01:38,190
మీరు కూడా 0 స్పాట్ అవసరం కారణం.

40
00:01:38,190 --> 00:01:41,650
>> సాధ్యనీయ విలువలు కాబట్టి ప్రాథమికంగా సగం
మీరు ప్రతికూల Int లో ఇముడుతుంది

41
00:01:41,650 --> 00:01:42,610
మరియు సగం అనుకూలంగా ఉంటాయి.

42
00:01:42,610 --> 00:01:47,270
మరియు సుమారు ఇక్కడ, ఈ ప్రతికూల గురించి
2 బిలియన్ సానుకూల 2 బిలియన్ గురించి.

43
00:01:47,270 --> 00:01:50,207
ఇవ్వండి లేదా రెండు వందల మిలియన్ పడుతుంది.

44
00:01:50,207 --> 00:01:52,290
తద్వారా మీరు ఇముడుతుంది ఏమిటి
పూర్ణాంకం వేరియబుల్.

45
00:01:52,290 --> 00:01:55,490
ఇప్పుడు మేము కూడా ఏదైనా కలిగి
సంతకం లేని పూర్ణ అని.

46
00:01:55,490 --> 00:01:59,220
ఇప్పుడు సైన్ చేయని ints ఒక ఉన్నాయి
వేరియబుల్ ప్రత్యేక రకం.

47
00:01:59,220 --> 00:02:01,590
అయితే, సైన్ చేయని ఉంది
ఏమి ఒక క్వాలిఫైయర్ అని.

48
00:02:01,590 --> 00:02:04,990
ఇది డేటా మార్పు
కొద్దిగా పూర్ణాంక రకం.

49
00:02:04,990 --> 00:02:07,850
>> మరియు ఈ సందర్భంలో, ఏ సైన్ చేయని
means-- మరియు మీరు కూడా

50
00:02:07,850 --> 00:02:11,530
సైన్ చేయని ఇతర డేటా రకాల ఉపయోగించండి
పూర్ణాంకం మాత్రమే ఒకటి కాదు.

51
00:02:11,530 --> 00:02:15,310
వాట్ ఇట్ సమర్థవంతంగా చేస్తుంది డబుల్స్ ఉంది
విలువలు సానుకూల పరిధి

52
00:02:15,310 --> 00:02:19,350
పూర్ణాంకం వద్ద పడుతుందని
ఇకపై అనుమతించటం వ్యయంతో

53
00:02:19,350 --> 00:02:21,140
మీరు ప్రతికూల విలువలు తీసుకుంటే.

54
00:02:21,140 --> 00:02:25,400
నీకు తెలిసిన సంఖ్యలు కలిగి ఉంటే
కంటే ఎక్కువ 2 బిలియన్ కానీ తక్కువ పొందుతారు

55
00:02:25,400 --> 00:02:31,280
4 బిలియన్ కంటే, ఉదాహరణకు కోసం
ఇది 32 వ 2 ఉంది power--

56
00:02:31,280 --> 00:02:33,330
మీరు వుపయోగించాలని అనుకొనుచున్న
మీరు ఒక ఉంటే Int సైన్ చేయని

57
00:02:33,330 --> 00:02:35,050
మీ విలువ ప్రతికూల ఎప్పటికీ తెలుసు.

58
00:02:35,050 --> 00:02:37,216
>> మీరు అప్పుడప్పుడు ఉంటుంది
సైన్ చేయని వేరియబుల్స్ కోసం ఉపయోగిస్తారు

59
00:02:37,216 --> 00:02:39,460
నేను ఇక్కడ అది పేర్కొనటం ఎందుకు CS50 లో, ఇది ఉంది.

60
00:02:39,460 --> 00:02:43,830
కానీ విలువలు మళ్ళీ, పరిధి మీరు
సంతకం లేని పూర్ణ తో సూచిస్తాయి

61
00:02:43,830 --> 00:02:48,240
సాధారణ పూర్ణాంక t గా, 0 ఉంటాయి
32 వ శక్తి మైనస్ 1 కు 2,

62
00:02:48,240 --> 00:02:50,840
లేదా సుమారు 0 4 బిలియన్.

63
00:02:50,840 --> 00:02:53,730
కాబట్టి మీరు సమర్థవంతంగా రెట్టింపు చేసిన
మీరు సరిపోయే చేసే సానుకూల పరిధి,

64
00:02:53,730 --> 00:02:56,270
కానీ మీరు అన్ని ఇచ్చాను
ప్రతికూల విలువలు.

65
00:02:56,270 --> 00:03:00,040
>> ఇప్పుడు ఒక ప్రక్కన, సైన్ చేయని వంటి
మాత్రమే క్వాలిఫైయర్ కాదు

66
00:03:00,040 --> 00:03:01,790
మేము చూడవచ్చిరి
వేరియబుల్ డేటా రకాల.

67
00:03:01,790 --> 00:03:05,779
అనే విషయాలు కూడా ఉన్నాయి
లఘు మరియు దీర్ఘమైన మరియు కాన్స్ట్.

68
00:03:05,779 --> 00:03:07,820
కాన్స్ట్ మేము కొద్దిగా చూస్తారు
బిట్ తర్వాత.

69
00:03:07,820 --> 00:03:10,830
లఘు మరియు దీర్ఘమైన, మేము బహుశా లేదు.

70
00:03:10,830 --> 00:03:12,830
>> కానీ ఆ తెలుసు
ఇతర ఉత్తీర్ణుల ఉన్నాయి.

71
00:03:12,830 --> 00:03:14,080
సంతకం మాత్రమే కాదు.

72
00:03:14,080 --> 00:03:16,596
కానీ అది మేము ఉన్నాము మాత్రమే దక్కుతుంది
ప్రస్తుతం గురించి మాట్లాడటానికి వెళుతున్నారు.

73
00:03:16,596 --> 00:03:17,310
సో అన్ని కుడి.

74
00:03:17,310 --> 00:03:18,393
కాబట్టి మనం పూర్ణాంకం కవర్ చేసిన.

75
00:03:18,393 --> 00:03:19,200
ఏం నెక్స్ట్?

76
00:03:19,200 --> 00:03:20,130
>> అక్షరాలు.

77
00:03:20,130 --> 00:03:23,620
కాబట్టి అక్షరాలు వేరియబుల్స్ కోసం ఉపయోగిస్తారు
ఆ ఒకే ఒక పాత్రలు నిల్వ చేస్తుంది.

78
00:03:23,620 --> 00:03:24,850
చార్ పాత్ర సంక్షిప్తరూపం.

79
00:03:24,850 --> 00:03:27,870
మరియు కొన్నిసార్లు మీరు వినడానికి ఉండవచ్చు
వ్యక్తులు కారు గా పలుకుతారు.

80
00:03:27,870 --> 00:03:32,020
>> అక్షరాలు ఎల్లప్పుడూ ఒక పడుతుంది కాబట్టి
కేవలం 8 బిట్స్ ఉంది ఇది మెమరీ బైట్.

81
00:03:32,020 --> 00:03:35,700
కాబట్టి ఈ వారు మాత్రమే ఇముడుతుంది అర్థం
ప్రతికూల 2 పరిధిలో విలువలు

82
00:03:35,700 --> 00:03:42,430
ఏడవ శక్తి, లేదా ప్రతికూల 128,
2 7 శక్తి 1, లేదా 127 మైనస్.

83
00:03:42,430 --> 00:03:45,710
>> ASCII ధన్యవాదాలు, అది
చాలా కాలం క్రితం ఒక మార్గం నిర్ణయించుకుంది

84
00:03:45,710 --> 00:03:50,805
నుండి ఆ అనుకూల సంఖ్యలు మ్యాప్
వివిధ పాత్రలు 0 127

85
00:03:50,805 --> 00:03:52,182
అన్ని మా కీబోర్డ్ మీద ఉండే.

86
00:03:52,182 --> 00:03:54,640
మేము తరువాత చూస్తారు కాబట్టి
కోర్సు, మరియు మీరు బహుశా చేస్తాము

87
00:03:54,640 --> 00:03:57,700
కొన్ని గుర్తు వచ్చి
పాయింట్ రాజధాని A, ఉదాహరణకు కోసం

88
00:03:57,700 --> 00:04:00,732
పాత్ర రాజధాని ఫంక్షన్
సంఖ్య 65 కు పటాలు.

89
00:04:00,732 --> 00:04:02,940
మరియు ఆ కారణం ఉంది
ఆ ఎందుకంటే అది ఏమిటి

90
00:04:02,940 --> 00:04:05,490
ASCII ప్రామాణిక ద్వారా కేటాయించారు.

91
00:04:05,490 --> 00:04:07,850
>> చిన్న ఒక 97 ఉంది.

92
00:04:07,850 --> 00:04:11,900
మీరు కోసం మూర్తి 0
నిజానికి, పాత్ర లేదు టైప్

93
00:04:11,900 --> 00:04:13,532
సున్న ప్రాతినిధ్యం, 48 ఉంది.

94
00:04:13,532 --> 00:04:15,240
మీరు ఒక జంట నేర్చుకోవచ్చు
వీటిలో మీరు వెళ్ళండి.

95
00:04:15,240 --> 00:04:17,990
మరియు మీరు ఖచ్చితంగా అవసరం వచ్చి చేస్తాము
వాటిని కొద్దిగా తరువాత CS50 లో.

96
00:04:17,990 --> 00:04:20,450

97
00:04:20,450 --> 00:04:23,390
>> తదుపరి ప్రధాన డేటా రకం
ఫ్లోటింగ్ పాయింట్ సంఖ్యల్లో ఉంటుంది.

98
00:04:23,390 --> 00:04:26,100
కాబట్టి ఫ్లోటింగ్ పాయింట్ సంఖ్యలు
కూడా వాస్తవ సంఖ్యలు అని పిలుస్తారు.

99
00:04:26,100 --> 00:04:28,850
ఇవి ప్రధానంగా సంఖ్యలు అని
వాటిని ఒక దశాంశ బిందువు కలిగి ఉంటుంది.

100
00:04:28,850 --> 00:04:33,360
ఫ్లోటింగ్ పాయింట్ విలువలు
పూర్ణ వంటి కూడా ఉన్నాయి

101
00:04:33,360 --> 00:04:36,090
మెమరీ 4 బైట్లు ఇమిడి.

102
00:04:36,090 --> 00:04:37,580
ఇప్పుడు ఇక్కడ ఎటువంటి చార్ట్ లేదు.

103
00:04:37,580 --> 00:04:40,890
ఏ సంఖ్య లైన్ ఎందుకంటే, అక్కడ
ఒక ఫ్లోట్ పరిధి వర్ణించే

104
00:04:40,890 --> 00:04:44,550
సరిగ్గా స్పష్టమైన లేదా సహజమైన కాదు.

105
00:04:44,550 --> 00:04:47,350
>> మీరు చెప్పడానికి అది తగినంత
పని 32 బిట్స్ కలిగి.

106
00:04:47,350 --> 00:04:49,730
మరియు మీరు ఒక సంఖ్య ఉంటే
కలిగి వంటి pi,

107
00:04:49,730 --> 00:04:55,510
పూర్ణాంకం భాగంగా 3 ఫ్లోటింగ్
పాయింట్ భాగంగా, లేదా దశాంశ భాగం 0,14159,

108
00:04:55,510 --> 00:04:58,735
మరియు అందువలన న, మీరు ఉండాలి
దానిని అన్ని ప్రాతినిధ్యం వహించగలదు

109
00:04:58,735 --> 00:05:02,420
పూర్ణాంక భాగం మరియు దశాంశ భాగం.

110
00:05:02,420 --> 00:05:04,550
>> సో వాట్ మీరు కావచ్చు ఆలోచిస్తాడు?

111
00:05:04,550 --> 00:05:08,180
ఒక విషయం అని దశాంశ ఉంటే
భాగంగా ఇక మరియు ఎక్కువ పొందుతాడు

112
00:05:08,180 --> 00:05:10,660
నేను చాలా పెద్ద ఉంటే
పూర్ణాంక భాగం, నేను అలా కాదు

113
00:05:10,660 --> 00:05:13,090
వంటి ఖచ్చితమైన చేయగలరు
దశాంశ భాగం.

114
00:05:13,090 --> 00:05:15,280
మరియు ఆ నిజంగా వార్తలు
ఒక ఫ్లోట్ పరిమితి.

115
00:05:15,280 --> 00:05:17,229
>> తేలియాడుతున్న ఒక PRECISION సమస్య.

116
00:05:17,229 --> 00:05:19,270
మేము మాత్రమే 32 బిట్స్ కలిగి
పని, అందువలన మేము మాత్రమే చెయ్యవచ్చు

117
00:05:19,270 --> 00:05:22,510
మా దశాంశ భాగం కాబట్టి ఖచ్చితమైన ఉండాలి.

118
00:05:22,510 --> 00:05:27,300
మేము తప్పనిసరిగా ఒక దశాంశ ఉండకూడదు
100 లేదా 200 అంకెలు ఖచ్చితమైన భాగం,

119
00:05:27,300 --> 00:05:29,710
మేము మాత్రమే ఎందుకంటే
32 బిట్స్ తో పని.

120
00:05:29,710 --> 00:05:31,590
కాబట్టి ఒక ఫ్లోట్ ఒక పరిమితి ఉంది.

121
00:05:31,590 --> 00:05:33,590
>> ఇప్పుడు అదృష్టవశాత్తూ ఉంది
అని మరొక డేటా రకం

122
00:05:33,590 --> 00:05:36,530
డబుల్ ఇది కొంతవరకు
ఈ సమస్య వ్యవహరిస్తుంది.

123
00:05:36,530 --> 00:05:39,980
డబుల్స్ తేలియాడుతున్న వంటి, కూడా ఉపయోగిస్తారు
వాస్తవ సంఖ్యలు, లేదా ఫ్లోటింగ్ పాయింట్ నిల్వ

124
00:05:39,980 --> 00:05:40,840
విలువలు.

125
00:05:40,840 --> 00:05:44,340
తేడా ఉంది
డబుల్స్ ద్వంద్వ ఖచ్చితత్వాన్ని ఉన్నాయి.

126
00:05:44,340 --> 00:05:48,177
వారు 64 బిట్స్ ఇముడుతుంది
డేటా, లేదా ఎనిమిది బైట్లు.

127
00:05:48,177 --> 00:05:49,010
ఆ అర్థం ఏమిటి?

128
00:05:49,010 --> 00:05:51,801
సరే, మేము ఉంటుంది అర్థం చాలా
దశాంశ బిందువు కచ్చితమైన.

129
00:05:51,801 --> 00:05:54,830
బదులుగా ఏడు pi కలిగి
ఫ్లోట్ ఉండవచ్చు ప్రదేశాలు,

130
00:05:54,830 --> 00:05:56,710
మేము బహుశా 30 ప్రదేశాలకు ఇది కలిగి ఉంటుంది.

131
00:05:56,710 --> 00:05:59,824
ఆ ముఖ్యం, మీరు అనుకోవచ్చు
బదులుగా ఒక ఫ్లోట్ ఒక డబుల్ ఉపయోగించడానికి.

132
00:05:59,824 --> 00:06:01,740
సాధారణంగా, మీరు అయితే
ఏదైనా ఎక్కడ పని

133
00:06:01,740 --> 00:06:06,540
ఒక నిజంగా దీర్ఘ దశాంశ స్థానంలో కలిగి
మరియు ఖచ్చితత్వము చాలా ముఖ్యం

134
00:06:06,540 --> 00:06:08,630
మీరు బహుశా కావలసిన
ఒక డబుల్ overfloat ఉపయోగించండి.

135
00:06:08,630 --> 00:06:11,250
ఇప్పుడే మీ రచనలపై కోసం
CS50, ఫ్లోట్ సరిపోవును.

136
00:06:11,250 --> 00:06:15,340
కానీ జోడీ వంటి ఉనికిలో తెలుసు
కొంతవరకు ఖచ్చితత్వము పరిష్కరించేందుకు మార్గం

137
00:06:15,340 --> 00:06:20,980
మీరు 32 అదనపు ఇవ్వడం ద్వారా సమస్య
బిట్స్ మీ నంబర్లు కోసం పని.

138
00:06:20,980 --> 00:06:23,650
>> ఇప్పుడు ఈ ఒక డేటా రకం కాదు.

139
00:06:23,650 --> 00:06:24,390
ఈ రకం.

140
00:06:24,390 --> 00:06:25,340
మరియు అది శూన్యమైన అని.

141
00:06:25,340 --> 00:06:27,506
మరియు నేను దాని గురించి మాట్లాడటం వెబ్
ఇక్కడ మేము బహుశా చేసిన ఎందుకంటే

142
00:06:27,506 --> 00:06:29,520
ఇప్పటికే కొన్ని సార్లు CS50 లో చూసిన.

143
00:06:29,520 --> 00:06:32,020
మరియు మీరు వొండరింగ్ ఉండవచ్చు
అది గురించి.

144
00:06:32,020 --> 00:06:33,390
>> సో శూన్యమైన ఒక రకం.

145
00:06:33,390 --> 00:06:34,097
ఇది ఉండవు.

146
00:06:34,097 --> 00:06:35,180
కానీ అది ఒక డేటా రకం కాదు.

147
00:06:35,180 --> 00:06:39,350
>> మేము రకం ఒక వేరియబుల్ సృష్టించడానికి కాదు
రద్దు మరియు అది ఒక లెక్కించాల్సి.

148
00:06:39,350 --> 00:06:42,519
కానీ విధులు, ఉదాహరణకు,
ఒక గర్జన తిరిగి రకం కలిగి ఉంటాయి.

149
00:06:42,519 --> 00:06:45,060
సాధారణంగా, మీరు ఒక ఫంక్షన్ చూడండి ఉంటే
ఒక గర్జన తిరిగి రకం,

150
00:06:45,060 --> 00:06:46,970
అది ఒక విలువ తిరిగి లేదు అర్థం.

151
00:06:46,970 --> 00:06:49,440
మీరు ఒక సాధారణ ఆలోచించవచ్చు
మేము ఇప్పటివరకు ఉపయోగించారు చేసిన ఆ ఫంక్షన్

152
00:06:49,440 --> 00:06:52,780
CS50 లో ఒక విలువ తిరిగి లేదు?

153
00:06:52,780 --> 00:06:54,700
>> Printf ఒకటి.

154
00:06:54,700 --> 00:06:56,820
Printf వాస్తవానికి లేదు
మీకు ఏదైనా తిరిగి.

155
00:06:56,820 --> 00:06:59,850
ఇది ఏదో ముద్రిస్తుంది
స్క్రీన్, మరియు అది ప్రాథమికంగా

156
00:06:59,850 --> 00:07:01,650
printf ఏమి ఒక వైపు ప్రభావం.

157
00:07:01,650 --> 00:07:03,620
కానీ అది మీరు ఒక విలువను తిరిగి ఇవ్వాలని లేదు.

158
00:07:03,620 --> 00:07:08,419
మీరు ఫలితంగా మరియు స్టోర్ పట్టుకుని లేదు
కొన్ని వేరియబుల్ ఇది తరువాత దీన్ని ఉపయోగించడానికి.

159
00:07:08,419 --> 00:07:10,710
ఇది కేవలం ఏదో ముద్రిస్తుంది
స్క్రీన్ మరియు మీరు పూర్తి చేసిన.

160
00:07:10,710 --> 00:07:14,360
>> కాబట్టి మేము printf అని చెప్పటానికి
ఒక గర్జన ఫంక్షన్ ఉంది.

161
00:07:14,360 --> 00:07:16,450
ఇది ఏమీ తిరిగి.

162
00:07:16,450 --> 00:07:18,580
>> ఒక చుట్టుకొలత జాబితా
ఫంక్షన్ కూడా గర్జన ఉంటుంది.

163
00:07:18,580 --> 00:07:21,410
మరియు మీరు కూడా చూసిన
చాలా CS50 లో కొంచెం.

164
00:07:21,410 --> 00:07:22,300
Int ప్రధాన శూన్యమైన.

165
00:07:22,300 --> 00:07:23,260
ఒక గంట మోగించిన ఆ చేస్తుంది?

166
00:07:23,260 --> 00:07:24,080

167
00:07:24,080 --> 00:07:27,220
ప్రధానంగా అంటే ఏమిటి అని
ప్రధాన ఏ పారామితులు తీసుకోదు.

168
00:07:27,220 --> 00:07:29,520
ఏ వాదన ఉందని
ప్రధాన జారీ పొందుతారు.

169
00:07:29,520 --> 00:07:32,780
ఇప్పుడు తర్వాత మేము అక్కడ అని చూస్తారు
ఒక విధంగా, ప్రధాన లోకి వాదనలు పాస్

170
00:07:32,780 --> 00:07:36,189
కానీ ఇప్పటివరకు మేము చేసిన ఏమి
Int ప్రధాన శూన్యమైన కనిపిస్తుంది.

171
00:07:36,189 --> 00:07:37,730
ప్రధాన కేవలం ఏ వాదనలు తీసుకోదు.

172
00:07:37,730 --> 00:07:40,236
కాబట్టి మేము తప్ప చెప్పి పేర్కొనండి.

173
00:07:40,236 --> 00:07:42,110
మేము కేవలం చాలా ఉండటం చేస్తున్నాం
వాస్తవం గురించి స్పష్టమైన

174
00:07:42,110 --> 00:07:44,430
అది ఏ వాదనలు తీసుకోదు.

175
00:07:44,430 --> 00:07:47,160
>> కాబట్టి ఇప్పుడు కోసం, అది తగినంత
ప్రధానంగా ఆ తప్ప సే

176
00:07:47,160 --> 00:07:50,789
కేవలం ఒక ప్లేస్హోల్డర్ వంటి సర్వ్ చేయాలి
మీరు ఏమీ గురించి ఆలోచిస్తూ గా.

177
00:07:50,789 --> 00:07:52,080
ఇది నిజంగా ఏదైనా చేయడం లేదు.

178
00:07:52,080 --> 00:07:53,550
ఇక్కడ తిరిగి విలువ ఉంది.

179
00:07:53,550 --> 00:07:54,770
ఇక్కడ ఏ పారామితులు ఉంది.

180
00:07:54,770 --> 00:07:55,709
ఇది శూన్యమైన యొక్క.

181
00:07:55,709 --> 00:07:57,250
ఇది కంటే కొద్దిగా క్లిష్టమైన వార్తలు.

182
00:07:57,250 --> 00:08:00,640
కానీ ఈ కోసం తగినంత ఉండాలి
కోర్సు యొక్క మంచి భాగం.

183
00:08:00,640 --> 00:08:05,010
మరియు ఆశాజనక ఇప్పుడు మీరు కొద్దిగా కలిగి
శూన్యమైన అంటే ఒక భావన యొక్క మరింత బిట్.

184
00:08:05,010 --> 00:08:08,460
>> ఆ సో ఐదు రకాల మీరు చేస్తాము ఉంటాయి
అంతర్నిర్మిత సి ఎన్కౌంటర్

185
00:08:08,460 --> 00:08:10,670
కానీ CS50 లో మేము కూడా గ్రంధాలయాన్ని కలిగి.

186
00:08:10,670 --> 00:08:13,550
మీరు కూడా దాని CS50.h.

187
00:08:13,550 --> 00:08:15,930
మరియు మీకు అందించే
రెండు అదనపు రకాల

188
00:08:15,930 --> 00:08:18,280
మీరు బహుశా చేయగలరు
మీ పదవులు న ఉపయోగించడానికి,

189
00:08:18,280 --> 00:08:21,210
లేదా కేవలం సాధారణంగా పని ప్రోగ్రామింగ్.

190
00:08:21,210 --> 00:08:23,030
>> ఈ మొదటి bool ఉంది.

191
00:08:23,030 --> 00:08:26,780
కాబట్టి బూలియన్ డేటా రకం,
bool, వేరియబుల్స్ కోసం ఉపయోగిస్తారు

192
00:08:26,780 --> 00:08:28,114
ఒక బూలియన్ విలువ నిల్వ చేస్తుంది.

193
00:08:28,114 --> 00:08:29,863
మీరు ఇప్పటివరకు విన్న చేసిన ఉంటే
ఈ పదం ముందు, మీరు

194
00:08:29,863 --> 00:08:31,960
బూలియన్ అని తెలిసిన
విలువ మాత్రమే సామర్ధ్యం కలిగి ఉంటుంది

195
00:08:31,960 --> 00:08:34,440
రెండు వేర్వేరు విలక్షణమైన విలువలు పట్టుకొని.

196
00:08:34,440 --> 00:08:35,872
ట్రూ మరియు తప్పుడు.

197
00:08:35,872 --> 00:08:37,580
ఇప్పుడు ఈ అందంగా తెలుస్తోంది
ప్రాథమిక, కుడి?

198
00:08:37,580 --> 00:08:40,496
ఈ ఒక ఆశ్చర్యం రకంగా
ఇది అంతర్నిర్మిత వంటి సి లో ఉనికిలో లేదు.

199
00:08:40,496 --> 00:08:42,640
మరియు అనేక ఆధునిక భాషలు,
కోర్సు యొక్క, బూలియన్

200
00:08:42,640 --> 00:08:45,390
ప్రామాణిక సిద్ధ దత్తాంశ రకం.

201
00:08:45,390 --> 00:08:47,192
కానీ సి లో, వారు నిజానికి లేదు.

202
00:08:47,192 --> 00:08:48,400
కానీ మేము దాన్ని సృష్టించాను.

203
00:08:48,400 --> 00:08:51,910
మీరు ఎప్పుడైనా సృష్టించాలి చేస్తే
దీని రకం bool ఒక వేరియబుల్,

204
00:08:51,910 --> 00:08:55,230
కేవలం CS50.h # చేర్చాలనుకుంటే తప్పకుండా
మీ కార్యక్రమం ప్రారంభంలో,

205
00:08:55,230 --> 00:08:57,800
మరియు మీరు సృష్టించడానికి చేయగలరు
bool రకం వేరియబుల్స్.

206
00:08:57,800 --> 00:09:02,095
>> మీరు CS50.h # చేర్చాలనుకుంటే మర్చిపోతే, మరియు ఉంటే
మీరు బూలియన్ రకాన్ని వేరియబుల్స్ వాడండి

207
00:09:02,095 --> 00:09:04,970
మీరు కొన్ని సమస్యలు ఎదుర్కొనే కొన్ని
మీరు మీ కార్యక్రమాన్ని కంపైల్ చేస్తున్నారు.

208
00:09:04,970 --> 00:09:06,490
సో ఆ కోసం లుకౌట్ న.

209
00:09:06,490 --> 00:09:11,180
మరియు ఉండవచ్చు మీరు కేవలం పరిష్కరిస్తాము
cs50.h. సహా పౌండ్ ద్వారా సమస్యలను

210
00:09:11,180 --> 00:09:14,590
>> ఇతర ముఖ్యమైన డేటా రకం మేము
CS50 లైబ్రరీ లో మీరు కోసం అందించడానికి

211
00:09:14,590 --> 00:09:15,670
స్ట్రింగ్.

212
00:09:15,670 --> 00:09:17,130
సో ఒక స్ట్రింగ్ ఏమిటి?

213
00:09:17,130 --> 00:09:18,520
స్ట్రింగ్స్ నిజంగా కేవలం పదాలు.

214
00:09:18,520 --> 00:09:20,000
వారు అక్షరాలు సేకరణలు ఉన్నారు.

215
00:09:20,000 --> 00:09:20,640
వారు పదాలు ఉన్నాము.

216
00:09:20,640 --> 00:09:21,390
వారు వాక్యాలు ఉన్నారు.

217
00:09:21,390 --> 00:09:22,480
వారు పేరాలు ఉన్నారు.

218
00:09:22,480 --> 00:09:25,850
కూడా, మొత్తం పుస్తకాలు కావచ్చు.

219
00:09:25,850 --> 00:09:29,690
>> చాలా పొడవుగా చాలా చిన్న
అక్షరాలు యొక్క సీరీస్.

220
00:09:29,690 --> 00:09:34,310
మీరు తీగలను ఉపయోగించడానికి అవసరం ఉంటే,
ఉదాహరణకు, ఒక పదం నిల్వ

221
00:09:34,310 --> 00:09:37,609
కేవలం cs50.h ఉన్నాయి నిర్థారించుకోండి
మీ కార్యక్రమం ప్రారంభంలో

222
00:09:37,609 --> 00:09:38,900
కాబట్టి మీరు స్ట్రింగ్ రకం ఉపయోగించవచ్చు.

223
00:09:38,900 --> 00:09:43,910
ఆపై మీరు వేరియబుల్స్ సృష్టించవచ్చు
దీని డేటా రకం స్ట్రింగ్.

224
00:09:43,910 --> 00:09:46,160
ఇప్పుడు తర్వాత కోర్సు లో,
మేము కూడా ఆ చూస్తారు

225
00:09:46,160 --> 00:09:47,752
గాని మొత్తం కథ.

226
00:09:47,752 --> 00:09:49,460
మేము విషయాలు చూస్తారు
అనే ఆకృతులను

227
00:09:49,460 --> 00:09:54,249
ఉండవచ్చు ఏమి గుంపుకు మీరు అనుమతించే
ఒక పూర్ణాంకం మరియు ఒక యూనిట్ లోకి ఒక స్ట్రింగ్.

228
00:09:54,249 --> 00:09:56,290
మరియు మేము ఆ ఉపయోగించవచ్చు
కొన్ని ప్రయోజనం, ఇది వాటిని

229
00:09:56,290 --> 00:09:57,750
కోర్సు తర్వాత ఉపయోగపడుట.

230
00:09:57,750 --> 00:09:59,500
>> మరియు మేము కూడా నేర్చుకోవచ్చు
నిర్వచించిన రకాల గురించి,

231
00:09:59,500 --> 00:10:01,720
ఇది మీరు సృష్టించడానికి అనుమతిస్తుంది
మీ స్వంత డేటా రకాల.

232
00:10:01,720 --> 00:10:03,060
మేము ఆందోళన అవసరం లేదు
ఇప్పుడు ఆ గురించి.

233
00:10:03,060 --> 00:10:04,550
కానీ కేవలం ఆ తెలుసు
హోరిజోన్ మీద ఏదో

234
00:10:04,550 --> 00:10:07,633
ఈ మొత్తం చాలా ఎక్కువ ఉంది
నేను మీరు చెప్పడం వెబ్ కంటే రకం విషయం

235
00:10:07,633 --> 00:10:08,133
ఇప్పుడు.

236
00:10:08,133 --> 00:10:10,591
కాబట్టి ఇప్పుడు మేము నేర్చుకున్న చేసిన
ప్రాథమిక డేటా గురించి కొద్దిగా

237
00:10:10,591 --> 00:10:14,230
రకాల మరియు CS50 డేటా రకాలు, లెట్స్
వేరియబుల్స్ తో పని ఎలా గురించి మాట్లాడండి

238
00:10:14,230 --> 00:10:18,530
మరియు ఈ ఉపయోగించి వాటిని సృష్టించడానికి
మా కార్యక్రమాలలో డేటా రకాల.

239
00:10:18,530 --> 00:10:22,670
మీరు ఒక వేరియబుల్ సృష్టించడానికి కావాలా,
మీరు చేయవలసిందల్లా అన్ని రెండు విషయాలు ఉంది.

240
00:10:22,670 --> 00:10:24,147
>> మొదట, మీరు ఒక రకం ఇవ్వాలని అవసరం.

241
00:10:24,147 --> 00:10:26,230
మీరు అవసరం రెండవ విషయం
అలా అది ఒక పేరు ఇచ్చి ఉంది.

242
00:10:26,230 --> 00:10:28,740
నీవు ఆ పనిని మరియు చెంప చేసిన ఒకసారి ఒక
ఆ లైన్ చివరిలో సెమికోలన్

243
00:10:28,740 --> 00:10:29,830
మీరు ఒక వేరియబుల్ సృష్టించాను.

244
00:10:29,830 --> 00:10:32,370
>> కాబట్టి ఇక్కడ రెండు ఉదాహరణలు వార్తలు.

245
00:10:32,370 --> 00:10:35,744
Int సంఖ్య; చార్ లేఖ ;.

246
00:10:35,744 --> 00:10:36,660
నేను ఇక్కడ ఏమి చేసారు?

247
00:10:36,660 --> 00:10:38,110
నేను రెండు వేరియబుల్స్ సృష్టించాను.

248
00:10:38,110 --> 00:10:40,190
>> వేరియబుల్, మొదటి
పేరు సంఖ్య.

249
00:10:40,190 --> 00:10:44,830
మరియు సంఖ్య పూర్ణాంకం నిలుపుకునే సామర్థ్యం కలిగి ఉంటుంది
దాని రకం పూర్ణాంకానికి ఎందుకంటే, విలువలు టైప్ చేయండి.

250
00:10:44,830 --> 00:10:48,040
లెటర్ మరో అనిశ్చితి
అక్షరాలు జరపవచ్చని

251
00:10:48,040 --> 00:10:50,240
దాని డేటా రకం చార్ ఎందుకంటే.

252
00:10:50,240 --> 00:10:51,772
>> ప్రెట్టీ సూటిగా, కుడి?

253
00:10:51,772 --> 00:10:53,480
మీరు మిమ్మల్ని మీరు కనుగొనడానికి ఉంటే
పరిస్థితి

254
00:10:53,480 --> 00:10:56,250
మీరు బహుళ సృష్టించడానికి అవసరం
ఒకే రకమైన వేరియబుల్స్

255
00:10:56,250 --> 00:10:58,740
మీరు మాత్రమే పేర్కొనాలి
ఒకసారి రకం పేరు.

256
00:10:58,740 --> 00:11:01,600
అప్పుడు కేవలం వంటి అంశాలపై జాబితా
ఆ రకమైన మీరు అవసరం.

257
00:11:01,600 --> 00:11:04,230
>> నేను ఉదాహరణకు, ఇక్కడ అనుకొనుట
కోడ్ యొక్క ఈ మూడవ లైన్ లో,

258
00:11:04,230 --> 00:11:07,420
పూర్ణాంకానికి ఎత్తు ;, కొత్త లైన్ అంటున్నారు.

259
00:11:07,420 --> 00:11:08,291
Int వెడల్పు ;.

260
00:11:08,291 --> 00:11:09,290
మరియు ఆ చాలా పని చేస్తుంది.

261
00:11:09,290 --> 00:11:12,039
నేను ఇప్పటికీ రెండు వేరియబుల్స్ అని పొంది
ఎత్తు మరియు వెడల్పు, వీటిలో ప్రతి

262
00:11:12,039 --> 00:11:12,730
ఒక పూర్ణ సంఖ్య.

263
00:11:12,730 --> 00:11:16,970
కానీ నేను, సి సింటాక్స్ విషయాలు అనుమతి చేస్తున్నాను
ఒకే లైన్ లోకి ఏకీకృతం.

264
00:11:16,970 --> 00:11:20,230
Int ఎత్తు, వెడల్పు; ఇది అదే విషయం.

265
00:11:20,230 --> 00:11:23,900
నేను అనే రెండు వేరియబుల్స్ ఒకటి సృష్టించాను
వెడల్పు ఎత్తు అని ఒకటి, రెండూ

266
00:11:23,900 --> 00:11:26,730
సమర్ధుడు ఉంటాయి
పూర్ణాంకం రకం విలువలు.

267
00:11:26,730 --> 00:11:30,920
>> అదేవిధంగా ఇక్కడ, నేను మూడు సృష్టించవచ్చు
ఒకేసారి పాయింట్ విలువలు తేలు.

268
00:11:30,920 --> 00:11:33,350
నేను బహుశా ఒక వేరియబుల్ సృష్టించవచ్చు
2-- యొక్క వర్గమూలం అని

269
00:11:33,350 --> 00:11:35,766
ఇది బహుశా చివరికి
ఫ్లోటింగ్ పాయింట్ నొక్కి

270
00:11:35,766 --> 00:11:39,222
చదరపు ఆ ప్రాతినిధ్యం
2-- చదరపు 3 యొక్క రూట్, మరియు pi యొక్క మూల.

271
00:11:39,222 --> 00:11:41,180
నేను ఈ చేసిన కాలేదు
మూడు ప్రత్యేక లైన్లు.

272
00:11:41,180 --> 00:11:47,690
ఫ్లోట్, వర్గమూలం 2; వర్గమూలం ఫ్లోట్
3; pi తేలియాడుతాయి మరియు ఆ చాలా పని చేస్తుంది.

273
00:11:47,690 --> 00:11:50,590
>> కానీ మళ్ళీ, నేను ఏకీకృతం చేయవచ్చు
కోడ్ యొక్క ఒక లైన్ లోకి ఈ.

274
00:11:50,590 --> 00:11:54,050
విషయాలు కొద్దిగా చేస్తుంది
తక్కువ గా clunky లేదు.

275
00:11:54,050 --> 00:11:57,259
>> ఇప్పుడు సాధారణంగా, అది మాత్రమే మంచి డిజైన్
మీరు అది అవసరమైనప్పుడు ఒక వేరియబుల్ డిక్లేర్.

276
00:11:57,259 --> 00:11:59,050
మరియు మేము కొద్దిగా మాట్లాడండి చేస్తాము
గురించి బిట్ మరింత

277
00:11:59,050 --> 00:12:00,945
తరువాత కోర్సు లో
మేము పరిధిని చర్చించడానికి.

278
00:12:00,945 --> 00:12:03,320
సో తప్పనిసరిగా అవసరం లేదు
మీ వేరియబుల్స్ యొక్క అన్ని సృష్టించడానికి

279
00:12:03,320 --> 00:12:05,990
కార్యక్రమం ప్రారంభంలో ఇది
కొంతమంది గత చేసి ఉండవచ్చని

280
00:12:05,990 --> 00:12:08,700
లేదా ఖచ్చితంగా చాలా సాధారణ ఉంది
కోడింగ్ పద్ధతి అనేక సంవత్సరాల క్రితం

281
00:12:08,700 --> 00:12:11,700
C. తో పనిచేసేటప్పుడు మీరు కేవలం వాటిని
ఒక వేరియబుల్ కుడి సృష్టించడానికి కావలసిన

282
00:12:11,700 --> 00:12:13,140
మీరు అది అవసరం.

283
00:12:13,140 --> 00:12:13,640
అయితే సరే.

284
00:12:13,640 --> 00:12:15,150
కాబట్టి మేము వేరియబుల్ సృష్టించాను.

285
00:12:15,150 --> 00:12:16,790
ఎలా మేము వాటిని ఉపయోగించాలి?

286
00:12:16,790 --> 00:12:18,650
మేము డిక్లేర్ తర్వాత
వేరియబుల్, మేము అవసరం లేదు

287
00:12:18,650 --> 00:12:21,237
డేటా రకాన్ని పేర్కొనాలి
ఆ వేరియబుల్ ఇకపై.

288
00:12:21,237 --> 00:12:24,070
మీరు అలా ఉంటే నిజానికి, మీరు వాటిని
కొన్ని విచిత్రమైన పరిణామాలు తో ముగుస్తుంది

289
00:12:24,070 --> 00:12:25,490
మేము రకమైన ఇప్పుడు కోసం ఉపేక్షించ మేము.

290
00:12:25,490 --> 00:12:27,365
కానీ చెప్పటానికి ఇది తగినంత,
విచిత్రమైన విషయాలు వెళ్తున్నారు

291
00:12:27,365 --> 00:12:30,740
అనుకోకుండా మీరు ఉంటే జరుగుతున్న ప్రారంభించడానికి
అదే పేరుతో వేరియబుల్స్ డిక్లేర్ తిరిగి

292
00:12:30,740 --> 00:12:32,210
పదే పదే.

293
00:12:32,210 --> 00:12:33,882
>> ఇక్కడ నేను కోడ్ నాలుగు లైన్లు ఉన్నాయి.

294
00:12:33,882 --> 00:12:36,090
నేను ఒక జంట కలిగి
కేవలం సూచిస్తూ అక్కడ వ్యాఖ్యలు

295
00:12:36,090 --> 00:12:37,840
ఏమి జరుగుతున్నది
ప్రతి లైన్ కేవలం సహాయం

296
00:12:37,840 --> 00:12:40,520
మీరు జరగబోతోంది ఏమి నెలకొని కలుగుతుంది.

297
00:12:40,520 --> 00:12:41,520
కాబట్టి Int సంఖ్య ;.

298
00:12:41,520 --> 00:12:42,520
మీరు ఇంతకు ముందు చూసింది.

299
00:12:42,520 --> 00:12:44,000
ఒక వేరియబుల్ ప్రకటన వార్తలు.

300
00:12:44,000 --> 00:12:46,670
>> నేను ఇప్పుడు ఒక వేరియబుల్ సృష్టించాను
వార్తలు అని సంఖ్య

301
00:12:46,670 --> 00:12:48,970
పూర్ణాంక-రకం విలువలు సమర్ధుడు.

302
00:12:48,970 --> 00:12:50,210
నేను డిక్లేర్డ్ చేసిన.

303
00:12:50,210 --> 00:12:53,770
>> నేను కేటాయించి వెబ్ తదుపరి లైన్
సంఖ్య ఒక విలువ.

304
00:12:53,770 --> 00:12:54,992
సంఖ్య 17 సమానం.

305
00:12:54,992 --> 00:12:55,950
అక్కడ ఏం జరుగుతున్నది?

306
00:12:55,950 --> 00:12:58,880
నేను సంఖ్య 17 ఆటంకమవుతుంది
ఆ వేరియబుల్ లోపల.

307
00:12:58,880 --> 00:13:02,760
>> నేను అప్పుడు ఎప్పుడూ బయటకు ప్రింట్ చేస్తే ఏమి
సంఖ్య యొక్క కంటెంట్లను తరువాత ఉన్నాయి,

308
00:13:02,760 --> 00:13:04,030
వారు 17 నాకు చెప్పండి చేస్తాము.

309
00:13:04,030 --> 00:13:07,030
కాబట్టి నేను ఒక వేరియబుల్ డిక్లేర్డ్ చేసిన,
ఆపై నేను కేటాయించిన చేసిన.

310
00:13:07,030 --> 00:13:10,570
>> మేము ప్రక్రియ తిరిగి చేయవచ్చు
మళ్ళీ చార్ అక్షరంతో ;.

311
00:13:10,570 --> 00:13:11,640
ఒక డిక్లరేషన్ ఉంది.

312
00:13:11,640 --> 00:13:14,010
లేఖ రాజధాని సమానం
H. ఒక కార్య వార్తలు.

313
00:13:14,010 --> 00:13:16,030
ప్రెట్టీ సూటిగా, చాలా.

314
00:13:16,030 --> 00:13:18,319
>> ఇప్పుడు ఈ ప్రక్రియ ఉండవచ్చు
రకమైన వెర్రి కనిపిస్తుంది.

315
00:13:18,319 --> 00:13:20,110
ఎందుకు మేము ఈ చేస్తున్న
కోడ్ రెండు పంక్తులు?

316
00:13:20,110 --> 00:13:21,401
దీన్ని ఒక మంచి మార్గం ఉంది?

317
00:13:21,401 --> 00:13:22,250
నిజానికి, ఉంది.

318
00:13:22,250 --> 00:13:24,375
కొన్నిసార్లు మీరు చూడవచ్చు
ఈ ప్రారంభ అంటారు.

319
00:13:24,375 --> 00:13:28,446
మీరు ఒక వేరియబుల్ డిక్లేర్ చేసినప్పుడు ఇది
మరియు అదే సమయంలో ఒక లెక్కించాల్సి.

320
00:13:28,446 --> 00:13:30,320
ఈ నిజానికి ఒక చాలా ఉంది
సాధారణ విషయం చేయాలని.

321
00:13:30,320 --> 00:13:32,870
మీరు ఒక వేరియబుల్, మీరు సాధారణంగా రూపొందించినప్పుడు
ఇది కొన్ని ప్రాథమిక విలువ కలిగి అనుకుంటున్నారా.

322
00:13:32,870 --> 00:13:34,330
అలాంటి అది 0 లేదా ఏదో ఉంటే.

323
00:13:34,330 --> 00:13:36,180
మీరు కేవలం మీరు ఒక విలువ ఇవ్వాలని.

324
00:13:36,180 --> 00:13:38,360
>> మీరు ఒక వేరియబుల్ ప్రారంభించడం చెయ్యవచ్చు.

325
00:13:38,360 --> 00:13:42,320
17 సమానం సంఖ్య Int అదే ఉంది
పైన కోడ్ మొదటి రెండు పంక్తులు.

326
00:13:42,320 --> 00:13:46,829
చార్ లెటర్ హెచ్ అదే సమానం
పైన కోడ్ యొక్క మూడవ మరియు నాల్గవ పంక్తులు.

327
00:13:46,829 --> 00:13:49,620
ఇక్కడ అతి ముఖ్యమైన takeaway
మేము ప్రకటించుకున్నారు మరియు కేటాయించి చేసినప్పుడు

328
00:13:49,620 --> 00:13:51,740
మేము చేసిన తర్వాత వేరియబుల్స్
ప్రకటించి, నోటీసు

329
00:13:51,740 --> 00:13:53,700
నేను మళ్ళీ డేటా రకం ఉపయోగించి కాదు.

330
00:13:53,700 --> 00:13:57,916
నేను Int సంఖ్య 17 సమానం చెప్పడం లేదు
ఉదాహరణకు రెండవ లైన్ కోడ్.

331
00:13:57,916 --> 00:13:59,290
నేను సంఖ్య 17 సమానం మాట్లాడుతూ నేను.

332
00:13:59,290 --> 00:14:02,537
>> మళ్ళీ, ఒక వేరియబుల్ తరువాత తిరిగి ప్రకటిస్తూ
మీరు ఇప్పటికే అది దారితీస్తుంది డిక్లేర్డ్ చేసిన

333
00:14:02,537 --> 00:14:03,620
కొన్ని విచిత్రమైన పరిణామం కు.

334
00:14:03,620 --> 00:14:05,950
కాబట్టి ఆ జాగ్రత్తగా ఉండాలి.

335
00:14:05,950 --> 00:14:06,660
>> నేను డౌ లాయిడ్ ఉన్నాను.

336
00:14:06,660 --> 00:14:08,870
మరియు ఈ CS50 ఉంది.

337
00:14:08,870 --> 00:14:10,499