1
00:00:00,000 --> 00:00:00,440

2
00:00:00,440 --> 00:00:00,860
>> SPEAKER 1: అన్ని కుడి.

3
00:00:00,860 --> 00:00:03,260
చివరి కార్యక్రమం కొద్దిగా బోరింగ్ ఉంది.

4
00:00:03,260 --> 00:00:05,510
యొక్క ముందుకు వెళ్లి వ్యక్తీకరించడానికి లెట్
ఈ కొద్దిగా.

5
00:00:05,510 --> 00:00:07,710
, ప్రపంచ హలో చెప్పండి కాకుండా
ఎందుకు మేము ముందుకు వెళ్లి,

6
00:00:07,710 --> 00:00:09,680
మరియు డేవిడ్ హలో, చెప్పటానికి?

7
00:00:09,680 --> 00:00:12,500
బాగా, దీన్ని, నేను ఆశ్రయించాల్సి
మార్గాలు ఈ.

8
00:00:12,500 --> 00:00:15,760
నేను, కోర్సు యొక్క, కేవలం హార్డ్ కోడ్
డేవిడ్, కానీ అన్ని కాదు అని

9
00:00:15,760 --> 00:00:17,650
ప్రాథమిక
గత వెర్షన్ నుండి.

10
00:00:17,650 --> 00:00:21,430
కాబట్టి యొక్క ముందుకు లీపు తీసుకుందాం, దిద్దుబాటు రద్దుచెయ్యి ఆ
మార్చడానికి, మరియు బదులుగా ఒక కొత్త ఇన్సర్ట్

11
00:00:21,430 --> 00:00:23,980
లైన్ ఐదు ఒకప్పుడు పేరు కోడ్ యొక్క లైన్.

12
00:00:23,980 --> 00:00:28,970
>> ముఖ్యంగా, నేను ఇక్కడ చేయ బోతున్నాను
తద్వారా, స్ట్రింగ్ పేరు లో చేర్చండి ఉంది

13
00:00:28,970 --> 00:00:30,920
ఒక వేరియబుల్ ప్రకటించారు.

14
00:00:30,920 --> 00:00:34,240
సి లో, మీరు ఎందుకు చెయ్యాలి మాత్రమే గమనించండి
ఒక వేరియబుల్ పేరు ఇవ్వడం, దీనిలో కు

15
00:00:34,240 --> 00:00:38,110
ఈ సందర్భంలో మీరు కూడా కలిగి, పేరు
అది ఏమిటో రకాన్ని పేర్కొనాలి.

16
00:00:38,110 --> 00:00:41,970
మేము మధ్య, ముందు కాలం ఇతర రకాల చూస్తారు
వాటిని పూర్ణ మరియు ఫ్లోటింగ్ పాయింట్

17
00:00:41,970 --> 00:00:46,480
విలువలు మరియు మరింత, కానీ ఇప్పుడు కోసం, స్ట్రింగ్
కేవలం ఒక పదం లేదా ఒక పదబంధం ఎక్కువ

18
00:00:46,480 --> 00:00:49,340
అధికారికంగా, సున్నా ఒక క్రమం
లేదా ఎక్కువ అక్షరాలు.

19
00:00:49,340 --> 00:00:53,760
కాబట్టి సమయంలో, ఈ లైన్ ఐదు ఉంది
, నాకు నేమ్ అనే వేరియబుల్ ఇవ్వండి అని

20
00:00:53,760 --> 00:00:56,560
స్ట్రింగ్ దీని డేటా రకం.

21
00:00:56,560 --> 00:01:00,460
>> ఇప్పుడు, నేను, అక్కడ ఒక విలువ నిల్వ మీరు
మరియు C లో అలా, మనం సమాన ఉపయోగించడానికి

22
00:01:00,460 --> 00:01:03,030
లేకుంటే అని పిలుస్తారు, సైన్
కార్య ఆపరేటర్లు.

23
00:01:03,030 --> 00:01:04,860
నేను క్రింది ముందుకు వెళుతున్న.

24
00:01:04,860 --> 00:01:10,220
సమానం కోట్, unquote, D-A-V-I-D,
క్లోజ్డ్ కోట్ సెమికోలన్.

25
00:01:10,220 --> 00:01:15,595
లైన్ ఐదుగురిలో నికర ప్రభావం ఇప్పుడు ఉంది
నిల్వ, ఒక స్ట్రింగ్, D-A-V-I-D డిక్లేర్

26
00:01:15,595 --> 00:01:19,480
ఈ కుడి వైపు నుండి
న వేరియబుల్ వ్యక్తీకరణ

27
00:01:19,480 --> 00:01:21,480
ఈ వ్యక్తీకరణ యొక్క ఎడమ వైపు.

28
00:01:21,480 --> 00:01:25,970
కాబట్టి ఈ లైన్ చివరికి, మేము
D-A-V-I-D వేరియబుల్ లోపల నిల్వ

29
00:01:25,970 --> 00:01:27,450
పేరు అని.

30
00:01:27,450 --> 00:01:28,910
>> ఇప్పుడు ఈ వేరియబుల్ ఉపయోగించడానికి వీలు.

31
00:01:28,910 --> 00:01:35,010
లైన్ ఆరు, నేను భర్తీ వెళుతున్న వెబ్
ఒక హోల్డర్ తో ప్రపంచ.

32
00:01:35,010 --> 00:01:39,960
% S ప్రకారం నిర్వచిస్తారు
ఒక గా printf కోసం డాక్యుమెంటేషన్

33
00:01:39,960 --> 00:01:41,690
ఒక స్ట్రింగ్ కోసం హోల్డర్.

34
00:01:41,690 --> 00:01:44,620
ఇతర మాటలలో, ఇది సమాచారం యొక్క ఒక మార్గం
నేను చాలు వెళుతున్న printf

35
00:01:44,620 --> 00:01:47,930
ఇక్కడ కొన్ని ఇతర విలువ, కానీ నన్ను
కేవలం ఒక క్షణం లో మీరు చెప్పండి ఎలా

36
00:01:47,930 --> 00:01:49,180
ఇది చేస్తాడు.

37
00:01:49,180 --> 00:01:52,800
ఇప్పుడు, ఎలా నేను printf చెప్పడం ముందుకి సాగే
ఆ విలువ అన్నారు ఏమి?

38
00:01:52,800 --> 00:01:56,850
>> Well, నేను ఒక తో printf అందించాలి
రెండవ వాదన, మరియు అలా, నేను

39
00:01:56,850 --> 00:02:00,460
మొట్టమొదటి తరువాత కామాతో ఉంచాలి
ఈ ఉటంకించబడింది ఇది వాదన,

40
00:02:00,460 --> 00:02:04,990
స్ట్రింగ్, మరియు నేను ఏమి పేర్కొనాలి
విలువ నేను ఆ లోకి ప్లగ్ మీరు

41
00:02:04,990 --> 00:02:07,010
మొదటి వాదన యొక్క హోల్డర్.

42
00:02:07,010 --> 00:02:10,880
నా వేరియబుల్ పేరు యొక్క,
కోర్సు, పేరు, టైపు సంతృప్తి పరుస్తుంది కాబట్టి

43
00:02:10,880 --> 00:02:14,000
రెండవ వంటి "పేరు"
వాదన printf.

44
00:02:14,000 --> 00:02:15,070
ఇప్పుడు పట్టిన లేదు.

45
00:02:15,070 --> 00:02:20,440
కామాతో లోపలి లేనప్పటికీ
కోట్ స్ట్రింగ్ నిజముగా ఉంది

46
00:02:20,440 --> 00:02:24,370
స్ట్రింగ్ లోపల కాబట్టి అది లేదు
మరొక నుండి ఒక వాదన వేరు.

47
00:02:24,370 --> 00:02:28,740
ఆ వెలుపల ఉంది మాత్రమే ఈ కామా
కోట్ స్ట్రింగ్ నిజానికి వేరు

48
00:02:28,740 --> 00:02:31,700
నుండి printf యొక్క మొదటి వాదన
దాని రెండవ వాదన.

49
00:02:31,700 --> 00:02:34,270
>> యొక్క ఇప్పుడు ఈ ప్రోగ్రామ్ కంపైల్ తెలియజేయండి.

50
00:02:34,270 --> 00:02:36,500
హలో చేయండి.

51
00:02:36,500 --> 00:02:39,570
మంచితనం ఓహ్, ఉత్పత్తి ఐదు లోపాలు,
నా ప్రోగ్రామ్ యొక్క

52
00:02:39,570 --> 00:02:41,100
ఏడు పంక్తులు పొడవు.

53
00:02:41,100 --> 00:02:44,720
బాగా, ఎప్పటిలాగే, గత చూడండి లేదు
మీ తెరపై లోపాల.

54
00:02:44,720 --> 00:02:47,960
మొట్టమొదటి ఎందుకంటే చూడండి బహుశా
సమయానుకూలంగా అనగా ఉంది

55
00:02:47,960 --> 00:02:51,600
కేవలం ఒక లోపం టాప్ రూపొందించినవారు
అక్కడ కంటే ఎక్కువ లోపాలు రూపాన్ని

56
00:02:51,600 --> 00:02:52,570
ఉన్నాయి.

57
00:02:52,570 --> 00:02:56,620
>> కాబట్టి నన్ను పైకి స్క్రోల్, అంతేకాక
ఇక్కడ boldfaced లోపం ఉపయోగించడం

58
00:02:56,620 --> 00:02:59,140
అస్పష్టమైన గుర్తింపు స్ట్రింగ్.

59
00:02:59,140 --> 00:03:00,630
మీరు ప్రామాణిక అర్థం?

60
00:03:00,630 --> 00:03:01,990
ఏ Well, నేను కాదు.

61
00:03:01,990 --> 00:03:06,700
నేను స్ట్రింగ్ అర్ధం, కానీ నేను అవుతుంది
ఆ స్ట్రింగ్ ఒక వంటి లేదు మర్చిపోయాను

62
00:03:06,700 --> 00:03:10,830
డేటా C. భావన లో సాంకేతికంగా టైప్
ఇది ఉంది, అయితే పదం

63
00:03:10,830 --> 00:03:16,210
"స్ట్రింగ్" మాత్రమే ఉంది ఎందుకంటే CS50
సిబ్బంది మాట్లాడటానికి, ఇది ప్రకటించాయి,

64
00:03:16,210 --> 00:03:18,160
మనం రాసిన ఒక ఫైల్ లో.

65
00:03:18,160 --> 00:03:22,540
నిజానికి, కేవలం ఎవరైనా కాలం క్రితం వంటి
ఒక ఫైల్ లో printf ఫంక్షన్ ప్రకటించింది

66
00:03:22,540 --> 00:03:28,310
ప్రామాణిక IO.H అని, కాబట్టి మేము
సిబ్బంది ఒక డేటా రకం లో వంటి స్ట్రింగ్ డిక్లేర్

67
00:03:28,310 --> 00:03:32,470
ఒక ఫైలు, ఏ ఆశ్చర్యం,
cs50.h. అంటారు

68
00:03:32,470 --> 00:03:36,340
>> కాబట్టి యొక్క పైన తిరిగి వీడలేదు నా
ప్రోగ్రామ్ మరియు కంపైలర్ సమాచారం ఆ

69
00:03:36,340 --> 00:03:40,130
నేను చిహ్నం వాడదలచారు మాత్రమే
స్ట్రింగ్, నేను కూడా విద్య కావలసిన

70
00:03:40,130 --> 00:03:42,160
ఆ గుర్తు అంటే కంపైలర్.

71
00:03:42,160 --> 00:03:47,010
మరియు చాలా సరళంగా అలా, నేను వెళ్ళే
తిరిగి ఒక లైన్ వరకు, ఒక కొత్త లైన్ ఇన్సర్ట్

72
00:03:47,010 --> 00:03:54,070
ఇక్కడ, మరియు ", cs50.h ఉన్నాయి", జోడించండి
కూడా కోణ బ్రాకెట్లలో మధ్య.

73
00:03:54,070 --> 00:03:58,170
ఈ సూచనల, చాలా ఆ వంటి ఇప్పుడు
లైన్ రెండు, తెలియజేయడానికి అన్నారు

74
00:03:58,170 --> 00:04:02,460
ఉన్నాయి ఉండాలి కంపైలర్
cs50.h విషయాలు వారు ఎక్కడ

75
00:04:02,460 --> 00:04:06,620
నా ప్రోగ్రామ్ యొక్క లోపల నా హార్డ్ డ్రైవ్ లో,
తద్వారా వంటి కంపైలర్ విద్య

76
00:04:06,620 --> 00:04:09,050
స్ట్రింగ్ ద్వారా అనవచ్చు.

77
00:04:09,050 --> 00:04:13,420
>> యొక్క నా ప్రోగ్రామ్ మళ్ళీ కంపైల్ చెయ్యండి లెట్
మార్పులు సేవ్ తర్వాత.

78
00:04:13,420 --> 00:04:15,500
హలో చేయండి.

79
00:04:15,500 --> 00:04:16,440
నమోదు చేయండి.

80
00:04:16,440 --> 00:04:17,730
మెరుగైన.

81
00:04:17,730 --> 00:04:23,760
ఇప్పుడు నేను ఒక మెరిసే ప్రాంప్ట్ కలిగి నేను
, ". / హలో," మరియు voila టైప్ చెయ్యవచ్చు.

82
00:04:23,760 --> 00:04:25,010
హలో డేవిడ్.

83
00:04:25,010 --> 00:04:26,402