1
00:00:00,000 --> 00:00:00,180

2
00:00:00,180 --> 00:00:02,920
>> SPEAKER 1: యొక్క ఒక ప్రోగ్రామ్ను రాయడం లెట్
యూజర్ నుండి ఒక స్ట్రింగ్ గెట్స్

3
00:00:02,920 --> 00:00:05,700
CS50 లైబ్రరీ యొక్క ఉపయోగించి
GetString పని.

4
00:00:05,700 --> 00:00:08,720
ఇది చేయుటకు, మేము ముందుకు వెళ్లి ఉపయోగిస్తాము
scanf, ఫంక్షన్ అని GetString

5
00:00:08,720 --> 00:00:10,950
ఫంక్షన్ నిజానికి ఉపయోగిస్తుంది
హుడ్ కింద.

6
00:00:10,950 --> 00:00:13,780
కానీ నేను ఉద్దేశపూర్వకంగా దీన్ని వెళుతున్న
ఒక బగ్గీ విధంగా.

7
00:00:13,780 --> 00:00:17,230
నేను నేను ఒక విధంగా చేయ బోతున్నాను
కుడి, కానీ అవుతుంది అని

8
00:00:17,230 --> 00:00:19,380
నా ఊహ చేస్తాడు
చాలా, చాలా పొరపాట్లు.

9
00:00:19,380 --> 00:00:20,800
నిజానికి, చాలా ప్రమాదకరమైన.

10
00:00:20,800 --> 00:00:24,750
ఎందుకంటే నేను ఉన్నాను ఒక వంటి దోషాలు
వ్యతిరేకుల ద్వారా చేజిక్కించుకోవడానికి తయారు

11
00:00:24,750 --> 00:00:28,870
ఆ మీ యంత్రం లేదా మీ ప్రోగ్రామ్
సమర్థవంతంగా పైగా తీసుకుంటారు.

12
00:00:28,870 --> 00:00:30,200
>> క్రింది యొక్క ప్రారంభించండి.

13
00:00:30,200 --> 00:00:33,540
మొదటి యొక్క మా స్ట్రింగ్ డిక్లేర్ తెలియజేయండి,
లేకపోతే, ఒక చార్ స్టార్ గా పిలిచే

14
00:00:33,540 --> 00:00:34,750
మరియు అది s కాల్.

15
00:00:34,750 --> 00:00:39,400
తదుపరి స్ట్రింగ్ కోసం వినియోగదారును ప్రాంప్ట్ అనుమతిస్తుంది,
"దయచేసి స్ట్రింగ్." తో వంటి మరియు

16
00:00:39,400 --> 00:00:44,250
ఇప్పుడు వినియోగదారు నుండి స్ట్రింగ్ ఉండకుండా
unquote కోట్, "% s.", scanf ఉపయోగించి లో

17
00:00:44,250 --> 00:00:47,760
ఇతర పదాలు, యొక్క మేము scanf సమాచారం వీలు
నిజానికి ఒక స్ట్రింగ్ పొందడానికి అనుకుంటున్నావా

18
00:00:47,760 --> 00:00:48,630
యూజర్ నుండి.

19
00:00:48,630 --> 00:00:50,810
>> అయితే ఇప్పుడు మేము scanf చెప్పడం అవసరం
ఒక విషయం ఇతర -

20
00:00:50,810 --> 00:00:53,350
స్ట్రింగ్ చాలు ఎక్కడ అని
యూజర్ అందిస్తుంది.

21
00:00:53,350 --> 00:00:57,840
Well, నేను చాలా కేవలం ప్రారంభం వెళుతున్న
కామా లు, నేను ఇష్టపడే తెలుపుతూ తో

22
00:00:57,840 --> 00:00:59,320
scanf ఉన్నాయి స్ట్రింగ్ ఉంచాలి.

23
00:00:59,320 --> 00:01:04,818
నేను తరువాత ఏదో ప్రింట్ వెళుతున్న
% s కోసం printf ధన్యవాదాలు "వంటి

24
00:01:04,818 --> 00:01:10,670
బాక్ స్లాష్ n కామా. "మరియు ఎల్లప్పుడూ, నేను ఉన్నాను
స్ట్రింగ్, s లో పాస్ వెళ్ళడం.

25
00:01:10,670 --> 00:01:14,920
ఇప్పుడు, యొక్క సేవ్ చేసేలా కంపైల్, ఈ అమలు
మేము ప్రేరేపించడానికి పోతే కార్యక్రమం, మరియు చూడండి

26
00:01:14,920 --> 00:01:16,590
సమస్య నేను అంచనా.

27
00:01:16,590 --> 00:01:18,650
>> Scanf-1.

28
00:01:18,650 --> 00:01:20,960
./scanf-1.

29
00:01:20,960 --> 00:01:21,830
స్ట్రింగ్ దయచేసి.

30
00:01:21,830 --> 00:01:25,540
యొక్క, వంటి ఏదో అందించడానికి లెట్ "హలో."
"శూన్య ధన్యవాదాలు." అయ్యో, కాదు

31
00:01:25,540 --> 00:01:26,750
నేను ఆశించే జరిగినది ఏమి.

32
00:01:26,750 --> 00:01:28,240
కాబట్టి ఇక్కడికి జరగబోతోంది?

33
00:01:28,240 --> 00:01:32,040
>> మేము డిక్లేర్డ్ ఎందుకంటే అదే, ఇది అవుతుంది
లు ఒక చార్ స్టార్ వంటి కానీ మేము కాదు

34
00:01:32,040 --> 00:01:36,120
నిజానికి ఒక యొక్క చిరునామా s నిల్వ
మెమరీ వాస్తవ భాగం, scanf కాదు

35
00:01:36,120 --> 00:01:38,940
స్ట్రింగ్ ఉంచాలి ఎక్కడైనా కలిగి
వినియోగదారు సైన్ టైప్

36
00:01:38,940 --> 00:01:42,510
నిజానికి, వాడి ఉంటే ఇప్పుడు టైప్
"హలో" కంటే ఎక్కువ స్ట్రింగ్

37
00:01:42,510 --> 00:01:46,780
ఉదాహరణకు అనేక టెక్స్ట్ యొక్క పంక్తులు లేదా
టెక్స్ట్ యొక్క అనేక పేరాలు, ఇది చాలా ఉంది

38
00:01:46,780 --> 00:01:50,280
మేము ప్రేరేపించడానికి ఉండవచ్చు అవకాశం ఒక
విభజన లోపంగా అని పిలవబడే.

39
00:01:50,280 --> 00:01:53,570
>> Scanf తెలుసు ఉండదని ఆ
నేను నిజానికి ఒక చిరునామా పెట్టలేదా

40
00:01:53,570 --> 00:01:54,610
లు లోపలి.

41
00:01:54,610 --> 00:01:58,000
అయితే, కొన్ని విలువ చూడండి వెళుతున్న
లు లో, కొన్ని నమూనా బిట్స్ మే,

42
00:01:58,000 --> 00:02:00,910
బాగా ఒక చెత్త విలువ,
అక్కడ కేవలం అవకాశం ద్వారా.

43
00:02:00,910 --> 00:02:04,600
మరియు scanf ఇప్పటికీ రాయడానికి ప్రయత్నించండి అన్నారు
ఆ చిరునామాకు యూజర్ స్ట్రింగ్,

44
00:02:04,600 --> 00:02:08,789
ఇది ఒక చెత్త విలువ, అయినా ఇది
నిజానికి క్రాష్ కలిగిస్తున్నాయని.

45
00:02:08,789 --> 00:02:10,130
>> కాబట్టి మేము ఎలా పరిష్కరించడానికి వెళ్తున్నారు?

46
00:02:10,130 --> 00:02:12,523