1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 ಲೈಬ್ರರಿ]

2
00:00:02,490 --> 00:00:04,220
[ನೇಟ್ Hardison] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,220 --> 00:00:07,260
[ಈ CS50 ಹೊಂದಿದೆ. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
CS50 ಗ್ರಂಥಾಲಯದ ನಾವು ಉಪಕರಣದಲ್ಲಿ ಅನುಸ್ಥಾಪಿತವಾದ ಒಂದು ಉಪಯುಕ್ತ ಸಾಧನ

5
00:00:11,510 --> 00:00:15,870
ನೀವು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಬರೆಯಲು ಸುಲಭವಾಗುತ್ತದೆ ಎಂದು ಇನ್ಪುಟ್ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಬಳಕೆದಾರರು.

6
00:00:15,870 --> 00:00:21,670
ಈ ವಿಡಿಯೋ, ನಾವು ಕೂಡು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ಮಾಡುತ್ತೇವೆ ಮತ್ತು CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನಿಖರವಾಗಿ ಏನು ನೋಡೋಣ.

7
00:00:21,670 --> 00:00:25,520
>> ಸಿ ಗ್ರಂಥಾಲಯಗಳು ಮೇಲೆ ವಿಡಿಯೋ, ನಾವು ನೀವು # ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಹೇಗೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು

8
00:00:25,520 --> 00:00:27,570
ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಗ್ರಂಥಲಯದ,

9
00:00:27,570 --> 00:00:31,150
ತದನಂತರ ನೀವು ಲಿಂಕ್ ಹಂತದಲ್ಲಿ ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತದಲ್ಲಿ ಲಿಂಕ್

10
00:00:31,150 --> 00:00:33,140
ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯ.

11
00:00:33,140 --> 00:00:36,440
ಹೆಡರ್ ಕಡತಗಳನ್ನು ಗ್ರಂಥಲಯದ ಇಂಟರ್ಫೇಸ್ ಸೂಚಿಸಿ.

12
00:00:36,440 --> 00:00:41,280
ಎಂದು ಅವರು ವಿವರ ನೀವು ಬಳಸಲು ಗ್ರಂಥಾಲಯದ ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಹೊಂದಿದೆ

13
00:00:41,280 --> 00:00:45,250
ಕಾರ್ಯ ಘೋಷಣೆಗಳು, ಸ್ಥಿರ, ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರಗಳು ನಂತಹ.

14
00:00:45,250 --> 00:00:48,890
ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಫೈಲ್, ಗ್ರಂಥಾಲಯದ ಅನುಷ್ಠಾನಕ್ಕೆ ಒಳಗೊಂಡಿದೆ

15
00:00:48,890 --> 00:00:54,580
ಇದು ಗ್ರಂಥಾಲಯದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಮತ್ತು ಗ್ರಂಥಾಲಯದಲ್ಲಿ. ಸಿ ಮೂಲ ಕೋಡ್ ಕಡತಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

16
00:00:54,580 --> 00:00:59,820
>> ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತ ಅದು ಬೈನರಿ ರಲ್ಲಿ, ಅಲ್ಲದೆ, ಅವರ ನಂತರ ನೋಡಲು ಕುತೂಹಲಕಾರಿ ಅಲ್ಲ.

17
00:00:59,820 --> 00:01:03,300
ಆದ್ದರಿಂದ, ಶೀರ್ಷಿಕೆ ಗ್ರಂಥಾಲಯಕ್ಕೆ ಕಡತಗಳನ್ನು ಬದಲಿಗೆ ಅವಲೋಕಿಸೋಣ.

18
00:01:03,300 --> 00:01:07,710
ಈ ಸಂದರ್ಭದಲ್ಲಿ, cs50.h. ಎಂಬ ಕೇವಲ ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಇಲ್ಲ

19
00:01:07,710 --> 00:01:11,040
ನಾವು ಬಳಕೆದಾರರು ಅನುಸ್ಥಾಪನೆಯ ನೀವು ಕೋಶವನ್ನು ಸೇರಿವೆ

20
00:01:11,040 --> 00:01:15,150
ಇತರ ವ್ಯವಸ್ಥೆಯ ಲೈಬ್ರರಿಗಳನ್ನು 'ಹೆಡರ್ ಕಡತಗಳನ್ನು ಜೊತೆಗೆ.

21
00:01:15,150 --> 00:01:21,530
>> ನೀವು ಗಮನಿಸಿ ಮೊಟ್ಟ ಮೊದಲ ಕೆಲಸಗಳಲ್ಲಿ ಒಂದು cs50.h # ಇತರ ಲೈಬ್ರರಿಗಳಿಂದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಯನ್ನು ಹೊಂದಿದೆ -

22
00:01:21,530 --> 00:01:25,670
ಫ್ಲೋಟ್, ಮಿತಿಗಳನ್ನು, ಪ್ರಮಾಣಿತ bool, ಮತ್ತು ಪ್ರಮಾಣಿತ lib.

23
00:01:25,670 --> 00:01:28,800
ಮತ್ತೆ, ಚಕ್ರ `ಪುನರ್ ಶೋಧನೆ ಇಲ್ಲ ತತ್ವ ಅನುಸರಿಸಿ,

24
00:01:28,800 --> 00:01:33,490
ನಾವು ಇತರ ನಮಗೆ ಒದಗಿಸಿದ ಉಪಕರಣಗಳು ಬಳಸಿಕೊಂಡು CS0 ಗ್ರಂಥಾಲಯ ನಿರ್ಮಾಣ ಮಾಡಿದ.

25
00:01:33,490 --> 00:01:38,690
>> ನೀವು ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನೋಡುತ್ತಾರೆ ಮುಂದೆ ನಾವು ಎಂಬ ಹೊಸ ರೀತಿಯ ವ್ಯಾಖ್ಯಾನ ಎಂದು "ಸ್ಟ್ರಿಂಗ್."

26
00:01:38,690 --> 00:01:42,330
ಈ ಲೈನ್ ನಿಜವಾಗಿಯೂ ಕೇವಲ ಚಾರ್ * ರೀತಿಯ ಅಲಿಯಾಸ್ ಸೃಷ್ಟಿಸುತ್ತದೆ,

27
00:01:42,330 --> 00:01:46,000
ಆದ್ದರಿಂದ ಮಾಂತ್ರಿಕವಾಗಿ ಲಕ್ಷಣಗಳು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ imbue ಇಲ್ಲ

28
00:01:46,000 --> 00:01:49,650
ಸಾಮಾನ್ಯವಾಗಿ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುಗಳ ಸಂಬಂಧಿತ

29
00:01:49,650 --> 00:01:50,850
ಉದಾಹರಣೆಗೆ ಉದ್ದ.

30
00:01:50,850 --> 00:01:55,180
ನಾವು ಮಾಡಿದ ಕಾರಣಕ್ಕಾಗಿ ರಕ್ತಸಿಕ್ತ ವಿವರಗಳನ್ನು ಹೊಸ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ರಕ್ಷಿಸಲು ಆಗಿದೆ

31
00:01:55,180 --> 00:01:57,580
ಪಾಯಿಂಟರ್ಗಳ ಅವರು ಸಿದ್ಧರಾಗಿರುವಾಗ ರವರೆಗೆ.

32
00:01:57,580 --> 00:02:00,130
>> ಹೆಡರ್ ಕಡತವನ್ನು ಮುಂದಿನ ಭಾಗವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಘೋಷಣೆಯಾಗಿದೆ

33
00:02:00,130 --> 00:02:04,410
CS50 ಗ್ರಂಥಾಲಯದ ದಸ್ತಾವೇಜನ್ನು ಜೊತೆಗೆ ಒದಗಿಸುತ್ತದೆ.

34
00:02:04,410 --> 00:02:06,940
ಇಲ್ಲಿ ಕಾಮೆಂಟ್ಗಳನ್ನು ವಿವರವಾಗಿ ಮಟ್ಟವನ್ನು ಗಮನಿಸಿ.

35
00:02:06,940 --> 00:02:10,560
ಜನರು ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಗೊತ್ತಿಲ್ಲ ಆದ್ದರಿಂದ ಈ ಪ್ರಮುಖ ಸೂಪರ್ ಆಗಿದೆ.

36
00:02:10,560 --> 00:02:19,150
ನಾವು ಪ್ರತಿಯಾಗಿ, ಘೋಷಿಸಲು, ಬಳಕೆದಾರ ಮತ್ತು ರಿಟರ್ನ್ ಅಕ್ಷರಗಳನ್ನು, ಡಬಲ್ಸ್, ಫ್ಲೋಟ್ಗಳು, ints, ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

37
00:02:19,150 --> 00:02:24,160
ದೀರ್ಘ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ತಂತಿಗಳು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ ಬಳಸಿ.

38
00:02:24,160 --> 00:02:26,260
ಇನ್ಫರ್ಮೇಷನ್ ಹೈಡಿಂಗ್ ತತ್ವ ಅನುಸರಿಸಿ,

39
00:02:26,260 --> 00:02:31,640
. ನಾವು ಪ್ರತ್ಯೇಕ ಸಿ ಅನುಷ್ಠಾನ ಕಡತದಲ್ಲಿ ನಮ್ಮ ವ್ಯಾಖ್ಯಾನ ಹಾಕಬಹುದು - cs50.c--

40
00:02:31,640 --> 00:02:35,110
ಬಳಕೆದಾರ ಮೂಲ ಕೋಶದಲ್ಲಿ ಇದೆ.

41
00:02:35,110 --> 00:02:38,040
ನೀವು ಒಂದು ನೋಟ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ ನಾವು ಆ ಕಡತ ಒದಗಿಸಲಾದ

42
00:02:38,040 --> 00:02:41,490
ಅದರಿಂದ ತಿಳಿಯಲು, ಮತ್ತು ನೀವು ಬಯಸಿದರೆ ವಿವಿಧ ಗಣಕಗಳಲ್ಲಿ ಇದು ಮರುಸಂಕಲಿಕೆಯು,

43
00:02:41,490 --> 00:02:45,510
ನಾವು ಈ ವರ್ಗದ APPLIANCE ಕೆಲಸ ಮಾಡಲು ಉತ್ತಮ ಭಾವಿಸುತ್ತೇನೆ ಸಹ.

44
00:02:45,510 --> 00:02:47,580
ಹೇಗಾದರೂ, ಈಗ ಅದು ಒಂದು ಅವಲೋಕಿಸೋಣ.

45
00:02:49,020 --> 00:02:54,620
>> ಕಾರ್ಯಗಳನ್ನು GetChar, GetDouble, GetFloat, GetInt, ಮತ್ತು GetLongLong

46
00:02:54,620 --> 00:02:58,160
ಎಲ್ಲಾ GetString ಕ್ರಿಯೆಯ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.

47
00:02:58,160 --> 00:03:01,510
ಅವರು ಎಲ್ಲಾ ಅದೇ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ತಿರುಗುತ್ತದೆ.

48
00:03:01,510 --> 00:03:04,870
ಅವರು ಇನ್ಪುಟ್ ಒಂದು ಸಾಲಿನ ಬಳಕೆದಾರ ಮಾಡುವಂತೆ ಸ್ವಲ್ಪ ಲೂಪ್ ಅನ್ನು.

49
00:03:04,870 --> 00:03:08,430
ಅವರು ಯೂಸರ್ ಇನ್ಪುಟ್ಸ್ ಖಾಲಿ ಸಾಲು ವೇಳೆ ವಿಶೇಷ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

50
00:03:08,430 --> 00:03:11,750
ಅವರು, ಸೂಕ್ತ ರೀತಿಯ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಪಾರ್ಸ್ ಪ್ರಯತ್ನ

51
00:03:11,750 --> 00:03:15,010
ಅದು ಅಕ್ಷರ, ಎರಡು, ಒಂದು ಫ್ಲೋಟ್, ಇತ್ಯಾದಿ ಎಂದು

52
00:03:15,010 --> 00:03:18,710
ಇನ್ಪುಟ್ ಯಶಸ್ವಿಯಾಗಿ ಪಾರ್ಸ್ ಎಂದು ಅವನ್ನು ಎರಡೂ ಪರಿಣಾಮವಾಗಿ ಹಿಂತಿರುಗಿ

53
00:03:18,710 --> 00:03:21,330
ಅಥವಾ ಬಳಕೆದಾರ reprompt.

54
00:03:21,330 --> 00:03:24,230
>> ಒಂದು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ, ನಿಜವಾಗಿಯೂ ಟ್ರಿಕಿ ಏನೂ ಇಲ್ಲಿ ಇಲ್ಲ.

55
00:03:24,230 --> 00:03:28,760
ನೀವು ಹಿಂದೆ ಇದೇ ರಚನಾತ್ಮಕ ಕೋಡ್ ನೀವೇ ಬರೆದಿದ್ದಾರೆ ಇರಬಹುದು.

56
00:03:28,760 --> 00:03:34,720
ಬಹುಶಃ ಅತ್ಯಂತ ರಹಸ್ಯ ಕಾಣುವ ಭಾಗ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ parses ಎಂದು sscanf ಕರೆಯಾಗಿದೆ.

57
00:03:34,720 --> 00:03:38,160
Sscanf ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕುಟುಂಬದ ಭಾಗವಾಗಿದೆ.

58
00:03:38,160 --> 00:03:42,300
, ಅದು ಪ್ರಮಾಣಿತ io.h ವಾಸಿಸುತ್ತಾರೆ, ಮತ್ತು ಅದರ ಕೆಲಸ ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಪರ್ಸ್ ಮಾಡುವ

59
00:03:42,300 --> 00:03:46,520
ವೇರಿಯಬಲ್ ಅನ್ನು ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ವರೂಪ ಪ್ರಕಾರ

60
00:03:46,520 --> 00:03:48,720
ಕಾಲರ್ ಒದಗಿಸಿದ.

61
00:03:48,720 --> 00:03:53,570
ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕಾರ್ಯಗಳನ್ನು ತುಂಬಾ ಉಪಯುಕ್ತ, ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರಣ

62
00:03:53,570 --> 00:03:56,160
, ಮೊದಲು ಅಂತರ್ಬೋಧೆಯ ಸೂಪರ್ ಎಂದು

63
00:03:56,160 --> 00:03:58,300
ನಾವು sscanf ಕೆಲಸ ಹೇಗೆ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ.

64
00:03:58,300 --> 00:04:03,330
>> sscanf ಮೊದಲ ವಾದವನ್ನು ಒಂದು ಚಾರ್ * ಹೊಂದಿದೆ - ಒಂದು ಅಕ್ಷರಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್.

65
00:04:03,330 --> 00:04:05,150
ಕಾರ್ಯವನ್ನು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು

66
00:04:05,150 --> 00:04:08,340
ಆ ಪಾತ್ರ, ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಅಕ್ಷರ ಆಗಿರಬೇಕು

67
00:04:08,340 --> 00:04:12,270
ಶೂನ್ಯ \ 0 ಅಕ್ಷರದೊಂದಿಗೆ ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ.

68
00:04:12,270 --> 00:04:15,120
ಈ ಪಾರ್ಸ್ ಸರಣಿಯನ್ನು ಹೊಂದಿದೆ

69
00:04:15,120 --> 00:04:18,269
sscanf ಎರಡನೇ ವಾದ, ಒಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ

70
00:04:18,269 --> 00:04:20,839
ವಿಶಿಷ್ಟವಾಗಿ, ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ರಲ್ಲಿ ಜಾರಿಗೆ

71
00:04:20,839 --> 00:04:24,040
ಮತ್ತು ನೀವು printf ಬಳಸುವಾಗ ಮೊದಲು ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನೋಡಿರಬಹುದು.

72
00:04:24,040 --> 00:04:28,650
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಶೇಕಡಾ ಚಿಹ್ನೆ ಒಂದು ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಸೂಚಿಸುತ್ತದೆ.

73
00:04:28,650 --> 00:04:30,850
ಅಕ್ಷರ ತಕ್ಷಣ, ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ನಂತರ

74
00:04:30,850 --> 00:04:35,430
ನಾವು ಮತಾಂತರಗೊಳ್ಳಲು sscanf ಬಯಸುವ ಸಿ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

75
00:04:35,430 --> 00:04:40,090
GetInt, ನೀವು ಒಂದು% s ಮತ್ತು% ಸಿ ಎಂದು ನೋಡಿ.

76
00:04:40,090 --> 00:04:48,690
% D - - ಮತ್ತು ಚಾರ್ -% ಸಿ ಈ sscanf ಒಂದು ದಶಮಾಂಶ ಇಂಟ್ ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಎಂದರ್ಥ.

77
00:04:48,690 --> 00:04:51,510
ಫಾರ್ಮ್ಯಾಟ್ ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಗೆ,

78
00:04:51,510 --> 00:04:56,620
sscanf ತನ್ನ ವಾದವನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ವಾದದ ನಂತರ ನಿರೀಕ್ಷಿಸುತ್ತದೆ.

79
00:04:56,620 --> 00:05:00,850
ಎಂಬ ವಾದವನ್ನು ಒಂದು ಸೂಕ್ತವಾಗಿ ಟೈಪ್ ಸ್ಥಳ ಬೆಟ್ಟು ಮಾಡಬೇಕು

80
00:05:00,850 --> 00:05:04,000
ಪರಿವರ್ತನೆ ಫಲಿತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು ಇದರಲ್ಲಿ.

81
00:05:04,000 --> 00:05:08,910
>> ಈ ಮಾಡುವ ವಿಶಿಷ್ಟ ರೀತಿಯಲ್ಲಿ sscanf ಕರೆ ಮೊದಲು ಸ್ಟಾಕ್ ಮೇಲೆ ವೇರಿಯಬಲ್ ರಚಿಸುವುದು

82
00:05:08,910 --> 00:05:11,440
ನೀವು ದಾರದಿಂದ ಪಾರ್ಸ್ ಬಯಸುವ ಪ್ರತಿ ಐಟಂಗೆ

83
00:05:11,440 --> 00:05:15,520
ಪಾಯಿಂಟರ್ಸ್ ರವಾನಿಸಲು - ವನ್ನಾಗಲಿ - ತದನಂತರ ವಿಳಾಸಕ್ಕೆ ಆಯೋಜಕರು ಬಳಸಿ

84
00:05:15,520 --> 00:05:19,100
sscanf ಕರೆ ಆ ಏರುಪೇರುಗಳಲ್ಲಿ.

85
00:05:19,100 --> 00:05:22,720
ನೀವು GetInt ನಾವು ನಿಖರವಾಗಿ ಇದನ್ನು ಕಾಣಬಹುದು.

86
00:05:22,720 --> 00:05:28,240
ಬಲ sscanf ಕರೆ ಮೊದಲು, ನಾವು, n ಎಂಬ ಒಂದು ಇಂಟ್ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಚಾರ್ ಕರೆ ಸಿ ಘೋಷಿಸಲು

87
00:05:28,240 --> 00:05:32,340
ಮತ್ತು ನಾವು sscanf ಕರೆ ಅವುಗಳನ್ನು ರೀತಿಯು ಹಾದುಹೋಗುತ್ತವೆ.

88
00:05:32,340 --> 00:05:35,800
ಸ್ಟಾಕ್ ಈ ಅಸ್ಥಿರಗಳು ಪುಟ್ಟಿಂಗ್ ನಿಯೋಜಿತವಾದ ಸ್ಥಳವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಆದ್ಯತೆ

89
00:05:35,800 --> 00:05:39,350
ನೀವು malloc ಕರೆಯ ಓವರ್ಹೆಡ್ ತಪ್ಪಿಸಲು ರಿಂದ malloc ಹೊಂದಿರುವ ರಾಶಿ, ಮೇಲೆ,

90
00:05:39,350 --> 00:05:43,060
ಮತ್ತು ನೀವು ಮೆಮೊರಿ ಸೋರಿಕೆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

91
00:05:43,060 --> 00:05:47,280
ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ಅದಕ್ಕೆ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಅಕ್ಷರಗಳು ಪರಿವರ್ತನೆ ಮಾಡುವಂತೆ ಇಲ್ಲ.

92
00:05:47,280 --> 00:05:50,380
ಬದಲಿಗೆ ಅವರು ಸ್ವರೂಪದ ವಿಶಿಷ್ಟ ಸೇರಿಸಲು.

93
00:05:50,380 --> 00:05:56,500
>> ಉದಾಹರಣೆಗೆ, GetInt ಸ್ವರೂಪದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಬದಲಿಗೆ% s ಆಗಿದ್ದರೆ,

94
00:05:56,500 --> 00:05:59,800
sscanf, ಒಂದು int ನಂತರ ಪತ್ರವನ್ನು ನೋಡಿ ಎಂದು

95
00:05:59,800 --> 00:06:04,360
ಇದು ಇಂಟ್ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಾಗಿ ಸಂದರ್ಭದಲ್ಲೇ ಇದು ಒಂದು ಜೊತೆ ಬೇರೆ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

96
00:06:04,360 --> 00:06:07,440
ಈ ಮಾತ್ರ ಹೊರತುಪಡಿಸಿ ಜಾಗಗಳನ್ನು ಹೊಂದಿದೆ.

97
00:06:07,440 --> 00:06:11,030
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ವೈಟ್ ಜಾಗದ ಅಕ್ಷರಗಳನ್ನು ಜಾಗಗಳನ್ನು ಯಾವುದೇ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿಸಲು -

98
00:06:11,030 --> 00:06:12,890
ಎಲ್ಲಾ ನಲ್ಲಿಯೂ ಯಾವುದೇ.

99
00:06:12,890 --> 00:06:18,100
ಕಾಮೆಂಟ್ ಪ್ರಮುಖ ಮತ್ತು / ಅಥವಾ ಜಾಗಗಳನ್ನು ಹಿಂದುಳಿದಿದ್ದರು ಜೊತೆ ಪ್ರಾಯಶಃ ಉಲ್ಲೇಖಿಸುತ್ತಾನೆ ಏಕೆ, ಇದು.

100
00:06:18,100 --> 00:06:22,910
ಆದ್ದರಿಂದ, ನಮ್ಮ sscanf ಕರೆ ತೋರುತ್ತಿದೆ ಈ ಹಂತದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವಾಕ್ಯವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ

101
00:06:22,910 --> 00:06:25,380
ಸಂಭಾವ್ಯ ಪ್ರಮುಖ ಜಾಗಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಮೂಲಕ,

102
00:06:25,380 --> 00:06:29,300
ಇಂಟ್ ವೇರಿಯಬಲ್ N ಪರಿವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಒಂದು ಇಂಟ್ ನಂತರ

103
00:06:29,300 --> 00:06:33,090
ಜಾಗಗಳನ್ನು ಸ್ವಲ್ಪ ನಂತರ, ಮತ್ತು ಒಂದು ಪಾತ್ರದ ನಂತರ

104
00:06:33,090 --> 00:06:35,810
ಚಾರ್ ವೇರಿಯಬಲ್ ಸಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

105
00:06:35,810 --> 00:06:37,790
>> ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಏನು?

106
00:06:37,790 --> 00:06:41,560
Sscanf, ಪೂರ್ಣಗೊಳಿಸಲು ಪ್ರಾರಂಭದಿಂದ ಆದಾನ ಸಾಲಿನಲ್ಲಿ ಪಾರ್ಸ್ ಕಾಣಿಸುತ್ತದೆ

107
00:06:41,560 --> 00:06:44,860
ಆದಾನ ಒಂದು ಗುಣವು ತುದಿಯನ್ನು ತಲುಪಿದಾಗ ನಿಲ್ಲಿಸುವ ಅಥವಾ

108
00:06:44,860 --> 00:06:49,320
ಒಂದು ರೂಪದಲ್ಲಿ ಪಾತ್ರ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಅಥವಾ ಒಂದು ಪರಿವರ್ತನೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಮಾಡಿದಾಗ.

109
00:06:49,320 --> 00:06:52,690
ಅದನ್ನು ಮರಳಿ ಮೌಲ್ಯವನ್ನು ನಿಲ್ಲಿಸಿದಾಗಿನಿಂದ ಪ್ರತ್ಯೇಕವಾದಿ ಬಳಸಲಾಗುತ್ತದೆ.

110
00:06:52,690 --> 00:06:55,670
ಇದು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯನ್ನು ತಲುಪಿದ ಕಾರಣ, ನಿಲ್ಲಿಸಿದ ವೇಳೆ

111
00:06:55,670 --> 00:07:00,630
ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮುನ್ನ ಮತ್ತು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಭಾಗವಾಗಿ ಹೊಂದಿಸಲು ವಿಫಲಗೊಳ್ಳುವ ಮುಂಚೆ ಮೊದಲಿಗೆ,

112
00:07:00,630 --> 00:07:04,840
ನಂತರ ವಿಶೇಷ ಸ್ಥಿರ EOF ಮರಳಿ.

113
00:07:04,840 --> 00:07:08,200
ಇಲ್ಲವಾದರೆ, ಅದು ಯಶಸ್ವಿ ಮಾರ್ಪಾಡುಗಳ ಸಂಖ್ಯೆಯಿಂದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

114
00:07:08,200 --> 00:07:14,380
ನಾವು ಎರಡು ಪರಿವರ್ತನೆಗಾಗಿ ಕೇಳಿದ್ದೀರಿ ಏಕೆಂದರೆ ಇದು, 0, 1, ಅಥವಾ 2 ಎಂದು.

115
00:07:14,380 --> 00:07:19,000
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನಾವು ಬಳಕೆದಾರರು ಇಂಟ್ ಮತ್ತು ಕೇವಲ ಒಂದು ಇಂಟ್ ಬೆರಳಚ್ಚಿಸಿದ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

116
00:07:19,000 --> 00:07:23,370
>> ಆದ್ದರಿಂದ, ನಾವು sscanf 1 ಮರಳಲು ಬಯಸುವ. ಏಕೆ ನೋಡಿ?

117
00:07:23,370 --> 00:07:26,850
Sscanf 0 ಮರಳಿದರು, ನಂತರ ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮಾಡಲಾಯಿತು,

118
00:07:26,850 --> 00:07:31,690
ಆದ್ದರಿಂದ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಇಂಟ್ ಬೇರೆಯಾಗಿರುತ್ತದೆ ಟೈಪಿಸಿದ.

119
00:07:31,690 --> 00:07:37,100
Sscanf 2 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ, ನಂತರ ಬಳಕೆದಾರರು ಸರಿಯಾಗಿ, ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಅದನ್ನು ಟೈಪ್ ಮಾಡಲಿಲ್ಲ

120
00:07:37,100 --> 00:07:41,390
ಆದರೆ ಅವರು ನಂತರ ಕೆಲವು ಅಲ್ಲದ ಜಾಗಗಳನ್ನು ಪಾತ್ರ ಬೆರಳಚ್ಚಿಸಿದ

121
00:07:41,390 --> 00:07:44,940
% ರಿಂದ C ಪರಿವರ್ತನೆ ಯಶಸ್ವಿಯಾದರು.

122
00:07:44,940 --> 00:07:49,570
ವಾಹ್, ಎಂದು ಸ್ವಲ್ಪ ಒಂದು ಫಂಕ್ಷನ್ ಕರೆಗೆ ಸುದೀರ್ಘ ವಿವರಣೆ ಇಲ್ಲಿದೆ.

123
00:07:49,570 --> 00:07:53,460
ಹೇಗಾದರೂ, ನೀವು sscanf ಮತ್ತು ಅದರ ಸಿಬ್ಲಿಂಗ್ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಬೇಕಾದರೆ,

124
00:07:53,460 --> 00:07:57,130
ಮನುಷ್ಯ ಪುಟಗಳು, ಗೂಗಲ್, ಅಥವಾ ಎರಡೂ ಪರಿಶೀಲಿಸಿ.

125
00:07:57,130 --> 00:07:58,780
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಾಕಷ್ಟು ಇವೆ

126
00:07:58,780 --> 00:08:03,830
ಸಿ ರಲ್ಲಿ ತಂತಿಗಳನ್ನು ಪಾರ್ಸ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ ಮತ್ತು ಈ ಹಸ್ತಚಾಲಿತ ಕಾರ್ಮಿಕ ಸಾಕಷ್ಟು ಉಳಿಸಬಹುದು

127
00:08:03,830 --> 00:08:07,180
>> ನೋಡಲು ಗ್ರಂಥಾಲಯದ ಅಂತಿಮ ಕ್ರಿಯೆ GetString ಹೊಂದಿದೆ.

128
00:08:07,180 --> 00:08:10,310
ಇದು GetString ಸರಿಯಾಗಿ ಬರೆಯಲು ಟ್ರಿಕಿ ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ

129
00:08:10,310 --> 00:08:14,290
ಅದು ಒಂದು ಸರಳ, ಸಾಮಾನ್ಯ ಕೆಲಸವನ್ನು ಹಾಗೆ ತೋರುತ್ತದೆ ಸಹ.

130
00:08:14,290 --> 00:08:16,170
ಏಕೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ?

131
00:08:16,170 --> 00:08:21,380
ಅಲ್ಲದೆ, ನ ಹೇಗೆ ನಾವು ಲೈನ್ ಶೇಖರಿಸಿಡಲು ನೀನು ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಲು ಸೈನ್ ಬಳಕೆದಾರ ವಿಧಗಳು

132
00:08:21,380 --> 00:08:23,880
ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಅನುಕ್ರಮದ, ಏಕೆಂದರೆ

133
00:08:23,880 --> 00:08:26,430
ನಾವು, ಸ್ಟಾಕ್ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇದು ಶೇಖರಿಸಿಡಲು ಬಯಸಬಹುದು

134
00:08:26,430 --> 00:08:31,250
ಆದರೆ ನಾವು ಅದನ್ನು ಘೋಷಿಸಬಹುದು ಮಾಡಿದಾಗ ವ್ಯೂಹ ಎಂದು ಹೋಗುತ್ತದೆ ಎಷ್ಟು ತಿಳಿಯಲು ಅಗತ್ಯವಿದೆ.

135
00:08:31,250 --> 00:08:34,030
ಹಾಗೆಯೇ, ನಾವು ರಾಶಿ ಮೇಲೆ ಹಾಕಲು ಬಯಸಿದಲ್ಲಿ,

136
00:08:34,030 --> 00:08:38,090
ನಾವು, malloc ನಾವು ಮೀಸಲು ಬಯಸುವ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ಪಾಸ್ ಅಗತ್ಯವಿದೆ

137
00:08:38,090 --> 00:08:39,730
ಆದರೆ ಈ ಅಸಾಧ್ಯ.

138
00:08:39,730 --> 00:08:42,760
ನಾವು ಬಳಕೆದಾರರು ಟೈಪ್ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಕಲ್ಪನೆಯೂ ಇಲ್ಲ

139
00:08:42,760 --> 00:08:46,590
ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಟೈಪ್ ಮೊದಲು.

140
00:08:46,590 --> 00:08:50,720
>> ಈ ಸಮಸ್ಯೆಗೆ ಸರಳ ಪರಿಹಾರ ಕೇವಲ, ಜಾಗವನ್ನು ದೊಡ್ಡ ಚಂಕ್ ಕಾಯ್ದಿರಿಸಬೇಕು ಹೇಳುತ್ತಾರೆ, ಆಗಿದೆ

141
00:08:50,720 --> 00:08:54,540
ಬಳಕೆದಾರರ ಸೇರಿಸುವ 1000 ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಬ್ಲಾಕ್,

142
00:08:54,540 --> 00:08:57,980
ಬಳಕೆದಾರ ದೀರ್ಘ ಸ್ಟ್ರಿಂಗ್ ಟೈಪ್ ಎಂದಿಗೂ ಎಂದು ಊಹಿಸಿ.

143
00:08:57,980 --> 00:09:00,810
ಈ ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ ಒಂದು ಕೆಟ್ಟ ಕಲ್ಪನೆ.

144
00:09:00,810 --> 00:09:05,280
ಮೊದಲು, ಬಳಕೆದಾರರು ಸಾಮಾನ್ಯವಾಗಿ ದೀರ್ಘ ತಂತಿಗಳನ್ನು ಟೈಪ್ ಎಂದು ಊಹಿಸಿಕೊಂಡು

145
00:09:05,280 --> 00:09:07,610
ನೀವು ಮೆಮೊರಿ ಸಾಕಷ್ಟು ತ್ಯಾಜ್ಯವನ್ನು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

146
00:09:07,610 --> 00:09:10,530
ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ ಆಧುನಿಕ ಗಣಕಗಳಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಇರಬಹುದು

147
00:09:10,530 --> 00:09:13,890
ಒಂದು ಅಥವಾ ಎರಡು ಪ್ರತ್ಯೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ,

148
00:09:13,890 --> 00:09:17,630
ಆದರೆ ನೀವು ಒಂದು ಆವರ್ತನದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಂಡು ನಂತರ ಬಳಕೆಗೆ ಸಂಗ್ರಹಿಸುವ ಬಳಸುತ್ತಿದ್ದರೆ,

149
00:09:17,630 --> 00:09:20,870
ನೀವು ಬೇಗನೆ ಮೆಮೊರಿಯ ಒಂದು ಟನ್ ಅಪ್ ಹೀರುವಂತೆ ಮಾಡಬಹುದು.

150
00:09:20,870 --> 00:09:24,450
ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಸಣ್ಣ ಕಂಪ್ಯೂಟರ್ ಹೊಂದಿದೆ -

151
00:09:24,450 --> 00:09:28,100
ಸೀಮಿತ ಮೆಮೊರಿಯಲ್ಲಿ ಸ್ಮಾರ್ಟ್ಫೋನ್ ಅಥವಾ ಯಾವುದೋ ಒಂದು ಸಾಧನ -

152
00:09:28,100 --> 00:09:32,060
ಈ ಪರಿಹಾರವನ್ನು ಸಾಕಷ್ಟು ವೇಗವಾಗಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

153
00:09:32,060 --> 00:09:36,450
ಈ ಮಾಡದಿರುವುದು ಎರಡನೇ, ಗಂಭೀರ ಕಾರಣ ಇದು ದುರ್ಬಲ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಲೆಗಳನ್ನು ಅಂದರೆ

154
00:09:36,450 --> 00:09:39,710
ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿ ಎಂಬ ಏನನ್ನು ಮಾಡಲು.

155
00:09:39,710 --> 00:09:45,840
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಬಫರ್, ತಾತ್ಕಾಲಿಕವಾಗಿ ಇನ್ಪುಟ್ ಅಥವಾ ಹೊರಹೋಗುವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮೆಮೊರಿ ಹೊಂದಿದೆ

156
00:09:45,840 --> 00:09:48,980
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ 1000-ಚಾರ್ ಬ್ಲಾಕ್ ಇದು.

157
00:09:48,980 --> 00:09:53,370
ದತ್ತಾಂಶ ವಿಭಾಗಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ಕಳೆದ ಬರೆಯಲಾಗಿದೆ ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ಸಂಭವಿಸುತ್ತದೆ.

158
00:09:53,370 --> 00:09:57,790
>> ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಳಕೆದಾರ ವಾಸ್ತವವಾಗಿ 1000 ಕ್ಕೂ ಹೆಚ್ಚು ಅಕ್ಷರಗಳನ್ನು ಟೈಪ್ ಮಾಡಿದರೆ.

159
00:09:57,790 --> 00:10:01,570
ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಅನುಭವಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.

160
00:10:01,570 --> 00:10:05,620
ನೀವು 10 ints ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಏನೂ ಓದಲು ಅಥವಾ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುವಾಗ ನೀವು ನಿಲ್ದಾಣಗಳು

161
00:10:05,620 --> 00:10:07,810
15 ಇಂಟ್.

162
00:10:07,810 --> 00:10:10,000
ಯಾವುದೇ ಕಂಪೈಲರ್ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಅಥವಾ ದೋಷಗಳಿವೆ.

163
00:10:10,000 --> 00:10:13,250
ಪ್ರೋಗ್ರಾಂ ಕೇವಲ ನೇರವಾಗಿ ಮುಂದಕ್ಕೆ ಪ್ರಮಾದಗಳ ಮತ್ತು ಮೆಮೊರಿ ಪ್ರವೇಶ

164
00:10:13,250 --> 00:10:18,150
ಇದು ಯೋಚಿಸುತ್ತಾನೆ ಅಲ್ಲಿ 15 ಇಂಟ್ ಆಗಿರುತ್ತದೆ, ಮತ್ತು ಇದು ನಿಮ್ಮ ಇತರ ಅಸ್ಥಿರ ಬದಲಿಸಿ.

165
00:10:18,150 --> 00:10:22,040
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆಂತರಿಕ ಕೆಲವು ಬದಲಿಸಿ

166
00:10:22,040 --> 00:10:26,820
ನಿಯಂತ್ರಣ ಕಾರ್ಯವಿಧಾನಗಳು, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾರಣವಾಗುತ್ತದೆ ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು

167
00:10:26,820 --> 00:10:28,340
ನೀವು ಉದ್ದೇಶಿಸಿದ ಹೆಚ್ಚು.

168
00:10:28,340 --> 00:10:31,360
>> ಈಗ, ಇದು, ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಮಾಡಲು ಸಾಮಾನ್ಯ ಅಲ್ಲ

169
00:10:31,360 --> 00:10:35,150
ಆದರೆ ಈ ಕೆಟ್ಟ ಜನರು ಕಾರ್ಯಕ್ರಮಗಳು ಮುರಿಯಲು ಬಳಸುವ ಒಂದು ಸರ್ವೇಸಾಮಾನ್ಯ ತಂತ್ರ

170
00:10:35,150 --> 00:10:39,080
ಮತ್ತು ಇತರ ಜನರ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಪುಟ್.

171
00:10:39,080 --> 00:10:42,910
ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ನಿಷ್ಕಪಟ ಪರಿಹಾರ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

172
00:10:42,910 --> 00:10:45,590
ನಾವು ಖಂಡನೀಯವಾಗಿರುವ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಒಂದು ದಾರಿ ಬೇಕಿದೆ

173
00:10:45,590 --> 00:10:47,880
ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿಗೆ.

174
00:10:47,880 --> 00:10:51,430
ಇದನ್ನು ಮಾಡಲು, ನಾವು ಓದುವ ನಮ್ಮ ಬಫರ್ ಬೆಳೆಯುತ್ತವೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ

175
00:10:51,430 --> 00:10:53,850
ಬಳಕೆದಾರ ಹೆಚ್ಚಿನ ಇನ್ಪುಟ್.

176
00:10:53,850 --> 00:10:57,440
ಪರಿಹಾರ? ನಾವು ರಾಶಿ ನಿಯೋಜಿತವಾದ ಬಫರ್ ಅನ್ನು.

177
00:10:57,440 --> 00:10:59,950
ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಇದು, ಗಣಕತೆರೆ realloc ಕಾರ್ಯ ಬಳಸಿ

178
00:10:59,950 --> 00:11:04,580
ಮತ್ತು ನಾವು ಎರಡು ಸಂಖ್ಯೆಗಳ ಟ್ರ್ಯಾಕ್ - ಮುಂದಿನ ಖಾಲಿ ಸ್ಲಾಟ್ ಸೂಚಕ ಬಫರ್

179
00:11:04,580 --> 00:11:08,390
ಮತ್ತು ಉದ್ದ ಅಥವಾ ಬಫರ್ ಸಾಮರ್ಥ್ಯ.

180
00:11:08,390 --> 00:11:13,210
ನಾವು fgetc ಕಾರ್ಯಕಾರಿತ್ವ ಬಳಸಿಕೊಂಡು ಒಂದು ಸಮಯದಲ್ಲಿ ಬಳಕೆದಾರ ಒಂದರಿಂದ ಅಕ್ಷರಗಳನ್ನು ಓದಲು.

181
00:11:13,210 --> 00:11:19,360
stdin - - fgetc ಕಾರ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆರ್ಗ್ಯುಮೆಂಟ್, ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಉಲ್ಲೇಖವಾಗಿತ್ತು

182
00:11:19,360 --> 00:11:23,810
ಇದು ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವರ್ಗಾಯಿಸಲು ಬಳಸುವ preconnected ಇನ್ಪುಟ್ ಚಾನಲ್ನಲ್ಲಿ

183
00:11:23,810 --> 00:11:26,270
ಟರ್ಮಿನಲ್ ನಿಂದ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ.

184
00:11:26,270 --> 00:11:29,890
>> ಯಾವಾಗ ಒಂದು ಹೊಸ ಪಾತ್ರದ ಬಳಕೆದಾರ ರೀತಿಯ ನಾವು ಪರೀಕ್ಷಿಸಿ ವೇಳೆ ಸೂಚ್ಯಂಕ

185
00:11:29,890 --> 00:11:35,810
ಮುಂದಿನ ಉಚಿತ ಸ್ಲಾಟ್ ಆಫ್ ಪ್ಲಸ್ 1 ಬಫರ್ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ.

186
00:11:35,810 --> 00:11:39,690
+1, ಮುಂದಿನ ಉಚಿತ ಸೂಚ್ಯಂಕ 5 ವೇಳೆ ಏಕೆಂದರೆ ಬರುತ್ತದೆ

187
00:11:39,690 --> 00:11:44,150
ನಂತರ ನಮ್ಮ ಬಫರ್ ಉದ್ದವು 6 ಧನ್ಯವಾದಗಳು 0 ಅನುಕ್ರಮಣಿಕೆ ಇರಬೇಕು.

188
00:11:44,150 --> 00:11:48,350
ನಾವು ಬಫರ್ ಸ್ಥಳವು ನೀವು, ನಾವು, ಅದನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಪ್ರಯತ್ನ

189
00:11:48,350 --> 00:11:51,690
ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಆ ಬಾರಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಕಡಿಮೆ ಇದರಿಂದ ಡಬಲ್

190
00:11:51,690 --> 00:11:54,760
ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಬಹಳ ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸುವುದನ್ನು ವೇಳೆ.

191
00:11:54,760 --> 00:11:57,950
ಸ್ಟ್ರಿಂಗ್ ತುಂಬಾ ನೆತ್ತಿಗೇರಿದೆ ಅಥವಾ ನಾವು ರಾಶಿ ಮೆಮೊರಿಯ ರನ್ ಔಟ್ ವೇಳೆ ವೇಳೆ,

192
00:11:57,950 --> 00:12:01,350
ನಮ್ಮ ಬಫರ್ ಮತ್ತು ರಿಟರ್ನ್ ಶೂನ್ಯ ಮುಕ್ತಗೊಳಿಸಲು.

193
00:12:01,350 --> 00:12:04,170
>> ಅಂತಿಮವಾಗಿ, ನಾವು ಬಫರ್ ಗೆ ಚಾರ್ ಸೇರಿಸಿಕೊಳ್ಳುತ್ತವೆ.

194
00:12:04,170 --> 00:12:08,200
ಬಳಕೆದಾರ ಹಿಟ್ ನಮೂದಿಸಿ ಅಥವಾ ಮರಳಿ, ಹೊಸ ಲೈನ್ ಸಂಕೇತ, ಒಮ್ಮೆ

195
00:12:08,200 --> 00:12:12,050
ಅಥವಾ ವಿಶೇಷ ಚಾರ್ - ನಿಯಂತ್ರಣ D - ಇನ್ಪುಟ್ ಒಂದು ಕೊನೆಯಲ್ಲಿ ಸಂಕೇತಗಳನ್ನು,

196
00:12:12,050 --> 00:12:16,240
ನಾವು ಬಳಕೆದಾರರು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲ ಏನು ಬೆರಳಚ್ಚಿಸಿದ ನೀವು ಒಂದು ಚೆಕ್ ಮಾಡಿ.

197
00:12:16,240 --> 00:12:18,820
ಅಲ್ಲ, ನಾವು ಶೂನ್ಯ ಹಿಂತಿರುಗಿ.

198
00:12:18,820 --> 00:12:22,280
ಇಲ್ಲದಿದ್ದರೆ, ನಮ್ಮ ಬಫರ್ ನಾವು ಅವಶ್ಯಕತೆ ಹೆಚ್ಚು ಬಹುಶಃ ದೊಡ್ಡ ಕಾರಣ,

199
00:12:22,280 --> 00:12:24,830
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಮಗೆ ಸುಮಾರು ಎರಡು ಪಟ್ಟು ದೊಡ್ಡದಾಗಿರುವುದರಿಂದ

200
00:12:24,830 --> 00:12:27,830
ನಾವು ಗಾತ್ರ ಬದಲಾವಣೆ ಪ್ರತಿ ಬಾರಿ ಡಬಲ್, ಏಕೆಂದರೆ

201
00:12:27,830 --> 00:12:31,840
ನಾವು ಅಗತ್ಯವಿರುವ ಜಾಗವನ್ನು ಕೇವಲ ಪ್ರಮಾಣವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ಹೊಸ ನಕಲನ್ನು ಮಾಡಿ.

202
00:12:31,840 --> 00:12:34,220
ನಾವು, malloc ಕರೆಗೆ ಹೆಚ್ಚುವರಿ 1 ಸೇರಿಸಿ

203
00:12:34,220 --> 00:12:37,810
\ 0, - ವಿಶೇಷ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರಕ್ಕೆ ಸ್ಥಳವಿರುವ ಎಂದು ಆದ್ದರಿಂದ

204
00:12:37,810 --> 00:12:41,990
ಇದು ನಾವು ಪಾತ್ರಗಳು ಉಳಿದ ನಕಲಿಸಿ ಒಮ್ಮೆ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಸೇರಿಸಲು,

205
00:12:41,990 --> 00:12:45,060
ಬದಲಿಗೆ strcpy ಆಫ್ strncpy ಬಳಸಿ

206
00:12:45,060 --> 00:12:48,830
ಆದ್ದರಿಂದ ನಾವು ನಕಲಿಸಲು ಬಯಸುವ ನಿಖರವಾಗಿ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಸೂಚಿಸಬಹುದು.

207
00:12:48,830 --> 00:12:51,690
ಇದು \ 0 ತಾಗುತ್ತದೆ ರವರೆಗೆ Strcpy ನಕಲಿಸುತ್ತದೆ.

208
00:12:51,690 --> 00:12:55,740
ನಂತರ ನಮ್ಮ ಬಫರ್ ಮುಕ್ತಗೊಳಿಸಲು ಮತ್ತು ಕಾಲರ್ ಗೆ ಪ್ರತಿಯನ್ನು ಮರಳಿ.

209
00:12:55,740 --> 00:12:59,840
>> ಯಾರು ಇಂತಹ ಸರಳ ತೋರಿಕೆಯ ಕಾರ್ಯ ಸಂಕೀರ್ಣಗೊಳಿಸಿದೆ ಎಂದು ತಿಳಿದಿದ್ದರು?

210
00:12:59,840 --> 00:13:02,820
ಈಗ ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯೋಣ.

211
00:13:02,820 --> 00:13:06,470
>> ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]