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

2
00:00:00,180 --> 00:00:02,920
>> ಸ್ಪೀಕರ್ 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
ಕಾರ್ಯ ವಾಸ್ತವವಾಗಿ ಬಳಸುವ
HOOD ಕೆಳಗೆ.

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
ಮತ್ತು ರು ಕರೆ.

15
00:00:34,750 --> 00:00:39,400
ಮುಂದಿನ ಸ್ಟ್ರಿಂಗ್ ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಅನುಮತಿಸುತ್ತದೆ,
"ದಯವಿಟ್ಟು ಸ್ಟ್ರಿಂಗ್." ಜೊತೆ ಮತ್ತು

16
00:00:39,400 --> 00:00:44,250
ಈಗ ಬಳಕೆದಾರರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಅವಕಾಶ
ಕೊಡುವುದು ಉಲ್ಲೇಖ, msgstr "% 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
ನಾನು ಸಾಕಷ್ಟು ಸರಳವಾಗಿ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಅಲ್ಪವಿರಾಮ ಗಳು, ನಾನು ಬಯಸುವ ಸ್ಪಷ್ಟಪಡಿಸಿದ್ದಾಳೆ ಜೊತೆ

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. "ಮತ್ತು ಯಾವಾಗಲೂ, ನಾನು
ಸ್ಟ್ರಿಂಗ್, ರು ರಲ್ಲಿ ಹಾದು ಹೋಗುವ.

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
ವಾಸ್ತವವಾಗಿ ಒಂದು ವಿಳಾಸವನ್ನು ರು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ
ಮೆಮೊರಿ ನಿಜವಾದ ಪಡೆ, 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