1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [ವೀಕ್ 5]

2
00:00:02,860 --> 00:00:04,860
[ಡೇವಿಡ್ ಜೆ Malan - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

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

4
00:00:07,260 --> 00:00:09,740
>> ಈ CS50, ವಾರ 5 ಆಗಿದೆ.

5
00:00:09,740 --> 00:00:12,900
ಇಂದು ಮತ್ತು ಈ ವಾರದಲ್ಲಿ, ನಾವು ನ್ಯಾಯ ಜಗತ್ತಿನ ಸ್ವಲ್ಪ ಪರಿಚಯಿಸಲು

6
00:00:12,900 --> 00:00:14,850
ಸಮಸ್ಯೆ ಸಂದರ್ಭದಲ್ಲಿ 4 ಹೊಂದಿಸಿ.

7
00:00:14,850 --> 00:00:18,480
ಇಲ್ಲಿ ಒಂದು ವಿಶೇಷ ಘಟನೆ ನಂತರ ಇರುವುದರಿಂದ ಇಂದು ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಉಪನ್ಯಾಸ ನಡೆಯಲಿದೆ.

8
00:00:18,480 --> 00:00:21,940
ನಾವು ಒಂದು ಪೀಕ್ ತೆಗೆದುಕೊಂಡು ವಿದ್ಯಾರ್ಥಿಗಳು ಮತ್ತು ಸಮಾನವಾಗಿ ಪೋಷಕರು ಇಂದು ಎರಡೂ ಕೀಟಲೆ ವಿಲ್

9
00:00:21,940 --> 00:00:24,600
ದಿಗಂತದ ಮೇಲೆ ವಸ್ತುಗಳನ್ನು ಕೆಲವು.

10
00:00:24,600 --> 00:00:29,050
>> ಅವುಗಳಲ್ಲಿ, ಸೋಮವಾರ ರ, ನೀವು ಕೆಲವು ಸಹಪಾಠಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

11
00:00:29,050 --> 00:00:32,980
edX, ಹಾರ್ವರ್ಡ್ ಮತ್ತು ಓಪನ್ಕೋರ್ಸ್ವೇರ್ ಮತ್ತು ಹೆಚ್ಚಿನ MIT ಯ ಹೊಸ ಆನ್ಲೈನ್ ಪ್ರಾರಂಭ

12
00:00:32,980 --> 00:00:36,730
ಸೋಮವಾರ ಬರುತ್ತಾರೆ ಅಂದರೆ ಸೋಮವಾರ, ಮೇಲೆ ಹಾರ್ವರ್ಡ್ ನ ಆವರಣದಲ್ಲಿ ಹಮ್ಮಿಕೊಳ್ಳುತ್ತಲಿದೆ

13
00:00:36,730 --> 00:00:40,930
ನೀವು ಕಳೆದ ಎಣಿಕೆ ರ 86,000 ಹೆಚ್ಚುವರಿ ಸಹಪಾಠಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ

14
00:00:40,930 --> 00:00:43,680
CS50 ನ ಉಪನ್ಯಾಸಗಳು ಮತ್ತು ವಿಭಾಗಗಳ ಜೊತೆ ಜೊತೆಗೆ ನಂತರ ಮಾಡಲಾಗುತ್ತದೆ

15
00:00:43,680 --> 00:00:45,890
ಮತ್ತು ಪರಿಗಣನೆಗಳು ಮತ್ತು ಸಮಸ್ಯೆ ಸೆಟ್.

16
00:00:45,890 --> 00:00:51,870
ಮತ್ತು ಈ ಭಾಗವಾಗಿ, ನೀವು CS50 ಈಗ CS50x ಉದ್ಘಾಟನಾ ವರ್ಗದ ಸದಸ್ಯರು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

17
00:00:51,870 --> 00:00:56,150
ಈ ಭಾಗವಾಗಿ ಈಗ, ಜೊತೆಗೆ ಕೆಲವು ಸಮನಾಗಿ ಇರುತ್ತದೆ ಎಂದು ಅರ್ಥ.

18
00:00:56,150 --> 00:01:00,620
ವಿದ್ಯಾರ್ಥಿಗಳು ಬೃಹತ್ ಸಂಖ್ಯೆಯ, ಇದಕ್ಕೆ ತಯಾರಾಗಬೇಕು,

19
00:01:00,620 --> 00:01:03,820
ಹೇಳಲು ಇದು ಸಾಕಾಗುತ್ತದೆ ನಾವು 108 TFS ಮತ್ತು ಸಿಎಎಸ್ ಹೊಂದಿರುತ್ತವೆ ಸಹ

20
00:01:03,820 --> 00:01:07,560
ನಾವು ವಿದ್ಯಾರ್ಥಿಗಳು 80,000 ಹಿಟ್ ಒಮ್ಮೆ ಸಾಕಷ್ಟು ಉತ್ತಮ ವಿದ್ಯಾರ್ಥಿಗಳು ಶಿಕ್ಷಕ ಅನುಪಾತ ಅಲ್ಲ.

21
00:01:07,560 --> 00:01:09,830
ನಾವು, ಕೈಯಾರೆ ಹೊಂದಿಸುತ್ತದೆ ಅನೇಕ ಸಮಸ್ಯೆಯನ್ನು ಅದರ ಶ್ರೇಣಿಕೃತ ಮಾಡುವುದಕ್ಕೆ ಎಂದು ಹೋಗುತ್ತಿಲ್ಲ

22
00:01:09,830 --> 00:01:13,050
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ ಈ ವಾರ ಪರಿಚಯಿಸಿತು CS50 ಚೆಕ್ ಆಗಿರುತ್ತದೆ

23
00:01:13,050 --> 00:01:15,410
APPLIANCE ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಯುಕ್ತತೆಯನ್ನು ಎಂದು ಹೋಗುವ ಇದು

24
00:01:15,410 --> 00:01:17,880
ಈ ವಾರಾಂತ್ಯದ ನಂತರ ಅಪ್ಡೇಟ್ ಒಮ್ಮೆ ನೀವು ಪಡೆಯುತ್ತೀರಿ ಎಂದು.

25
00:01:17,880 --> 00:01:21,030
ನೀವು ನಿಮ್ಮ ಸ್ವಂತ pset ಒಂದು ಆಜ್ಞೆಯನ್ನು check50, ರನ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ

26
00:01:21,030 --> 00:01:24,770
ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸರಿಯಾದ ಅಥವಾ ತಪ್ಪಾಗಿದೆ ಎಂಬುದರ ಬಗ್ಗೆ ತ್ವರಿತ ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆಯುತ್ತೀರಿ

27
00:01:24,770 --> 00:01:27,980
ನಾವು ಒದಗಿಸಿದ ವಿವಿಧ ವಿನ್ಯಾಸ ವಿಶೇಷಣಗಳು ಪ್ರಕಾರ.

28
00:01:27,980 --> 00:01:30,310
ಸಮಸ್ಯೆ ಸೆಟ್ ನಿರ್ದಿಷ್ಟತೆಯು ಆ ಮೇಲೆ ಹೆಚ್ಚು.

29
00:01:30,310 --> 00:01:34,220
CS50x ಸಹಪಾಠಿಗಳು ಹಾಗೂ ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

30
00:01:34,220 --> 00:01:36,170
>> ಸಮಸ್ಯೆ ಸೆಟ್ 4, ಎಲ್ಲಾ ಫರೆನ್ಸಿಕ್ಸ್ ಸುಮಾರು

31
00:01:36,170 --> 00:01:38,630
ಮತ್ತು ಈ pset ನಿಜವಾಗಿಯೂ ಕೆಲವು ನಿಜ ಜೀವನದ ಸಂಗತಿಗಳನ್ನು ಸ್ಫೂರ್ತಿ

32
00:01:38,630 --> 00:01:41,210
ಆ ಮೂಲಕ ನಾನು ಪದವಿ ಶಾಲೆಯಲ್ಲಿ ಆಗ ನಾನು ಆ ಕೂಡಿಟ್ಟರು

33
00:01:41,210 --> 00:01:45,270
ಮಿಡ್ಲ್ಸೆಕ್ಸ್ ಕೌಂಟಿಯ ಜಿಲ್ಲಾ ನ್ಯಾಯವಾದಿಗಳ ಕಚೇರಿಗೆ ನ್ಯಾಯ ಕೆಲಸ ಜೊತೆ

34
00:01:45,270 --> 00:01:47,660
ಅವರ ಪ್ರಮುಖ ನ್ಯಾಯ ಪರೀಕ್ಷಕನ ಜೊತೆ.

35
00:01:47,660 --> 00:01:50,280
ನಾನು ಕೆಲವು ವಾರಗಳ ಹಿಂದೆ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ ಯೋಚಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ಇದು, ತನ್ನ ಪಾಲನ್ನು

36
00:01:50,280 --> 00:01:52,720
ಮಾಸ್ ರಾಜ್ಯ ಪೊಲೀಸ್ ಅಥವಾ ಇತರರು ರಲ್ಲಿ ಬರುತ್ತದೆ ಇದೆ

37
00:01:52,720 --> 00:01:56,150
ಅವರು, ಹಾರ್ಡ್ ಡ್ರೈವ್ ಮತ್ತು CD ಗಳು ಮತ್ತು ಫ್ಲಾಪಿ ಡಿಸ್ಕ್ಗಳು ​​ಮತ್ತು ನಂತಹ ವಿಷಯಗಳನ್ನು ಬಿಟ್ಟು ಎಂದು

38
00:01:56,150 --> 00:01:58,770
ಮತ್ತು ನಂತರ ನ್ಯಾಯ ಕಚೇರಿ ಗುರಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಆಗಿತ್ತು

39
00:01:58,770 --> 00:02:01,470
ಇರಲಿಲ್ಲ ಅಥವಾ ಕೆಲವು ರೀತಿಯ ಪುರಾವೆಯಲ್ಲ ಎಂದು.

40
00:02:01,470 --> 00:02:04,730
ಈ ಸ್ಪೆಷಲ್ ಇನ್ವೆಸ್ಟಿಗೇಶನ್ಸ್ ಯುನಿಟ್, ಅದು ಬಿಳಿ ಕಾಲರ್ ಅಪರಾಧ ಆಗಿತ್ತು.

41
00:02:04,730 --> 00:02:10,949
ಇದು ಅಪರಾಧಗಳಿಗೆ ಹೆಚ್ಚು ತೊಂದರೆ ರೀತಿಯ, ಡಿಜಿಟಲ್ ಮಾಧ್ಯಮದ ರೀತಿಯ ಒಳಗೊಂಡ ಏನು ಆಗಿತ್ತು.

42
00:02:10,949 --> 00:02:16,450
ಹಲವು ಜನರು ಹೇಳುವ ಇಮೇಲ್ ಬರೆಯಲು ಎಂದು, "ನಾನು ಅದನ್ನು ಮಾಡಿದರು." ಎಂದು ತಿರುಗುತ್ತದೆ

43
00:02:16,450 --> 00:02:20,490
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಹೆಚ್ಚಾಗಿ, ಈ ನ್ಯಾಯ ಹುಡುಕಾಟಗಳು, ಎಲ್ಲಾ ಹೆಚ್ಚು ಹಣ್ಣು ಎದ್ದು ಬರದ

44
00:02:20,490 --> 00:02:22,820
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಜನರು ಇಮೇಲ್ಗಳನ್ನು ಬರೆಯಬೇಕಿತ್ತು.

45
00:02:22,820 --> 00:02:25,240
ಆದ್ದರಿಂದ ಕೆಲವೊಮ್ಮೆ, ಪ್ರಯತ್ನಗಳು ಬಹುಮಾನ ನೀಡಲಾಗುತ್ತಿತ್ತು.

46
00:02:25,240 --> 00:02:31,210
>> ಆದರೆ ಈ ನ್ಯಾಯ pset ನಾವು pset4 ಗ್ರಾಫಿಕ್ಸ್ ಸ್ವಲ್ಪ ಪರಿಚಯಿಸುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ ಅಪ್ ಕಾರಣವಾಗುತ್ತದೆ.

47
00:02:31,210 --> 00:02:35,410
ನೀವು ಬಹುಶಃ ಲಘುವಾಗಿ ಈ ವಸ್ತುಗಳನ್ನು ಪಡೆಯಲು - JPEGs, GIF ಗಳನ್ನು ಬಳಸಬಹುದಾಗಿದೆ, ಮತ್ತು ಹಾಗೆ - ಈ ದಿನಗಳಲ್ಲಿ.

48
00:02:35,410 --> 00:02:38,320
ಆದರೆ ನೀವು ಅದರ ಬಗ್ಗೆ ನಿಮಗೆ ಅನಿಸಿದರೆ, ಚಿತ್ರವನ್ನು ಹೆಚ್ಚು ರಾಬ್ ಮುಖದ ಹಾಗೆ,

49
00:02:38,320 --> 00:02:41,270
ಚುಕ್ಕೆಗಳು ಅಥವಾ ಪಿಕ್ಸೆಲ್ ಒಂದು ಅನುಕ್ರಮ ರೂಪುಗೊಳ್ಳಬಹುದು.

50
00:02:41,270 --> 00:02:43,380
ರಾಬ್ ಮುಖದ ಸಂದರ್ಭದಲ್ಲಿ, ಬಣ್ಣಗಳ ಎಲ್ಲಾ ರೀತಿಯ, ಇಲ್ಲ

51
00:02:43,380 --> 00:02:46,760
ಮತ್ತು ನಾವು, ಇಲ್ಲದಿದ್ದರೆ ಪಿಕ್ಸೆಲ್ಗಳು ಎಂದು ಮಾಲಿಕ ಚುಕ್ಕೆಗಳು, ನೋಡಲು ಪ್ರಾರಂಭಿಸಿದರು

52
00:02:46,760 --> 00:02:48,610
ಒಮ್ಮೆ ನಾವು ಸೈನ್ ಜೂಮ್ ಆರಂಭಿಸಿದರು

53
00:02:48,610 --> 00:02:54,660
ಆದರೆ ವಿಶ್ವದ ಒಂದು ಬಿಟ್ ಸರಳಗೊಳಿಸುವ ಮತ್ತು ಕೇವಲ ಇಲ್ಲಿ ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ರಾಬ್ ಹೇಳುತ್ತಾರೆ ವೇಳೆ,

54
00:02:54,660 --> 00:02:57,490
ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ಪ್ರತಿನಿಧಿಸಲು, ನಾವು ಅವಳಿ ಬಳಸಬಹುದು.

55
00:02:57,490 --> 00:03:01,660
ಮತ್ತು ನಾವು ಅವಳಿ ಬಳಸಲು ನೀನು ವೇಳೆ, 1 ಅಥವಾ 0, ನಾವು ಇದೇ ಚಿತ್ರವನ್ನು ವ್ಯಕ್ತಪಡಿಸಬಹುದು

56
00:03:01,660 --> 00:03:06,140
ಬಿಟ್ಗಳು ಈ ಮಾದರಿಯ ರಾಬ್ ನ ನಗುತ್ತಿರುವ ಮುಖದ.

57
00:03:06,140 --> 00:03:12,100
11000011 ಬಿಳಿ, ಬಿಳಿ, ಕಪ್ಪು, ಕಪ್ಪು, ಕಪ್ಪು, ಕಪ್ಪು, ಬಿಳಿ, ಬಿಳಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

58
00:03:12,100 --> 00:03:16,150
ಮತ್ತು ಆದ್ದರಿಂದ, ವರ್ಣಮಯ ಛಾಯಾಚಿತ್ರಗಳನ್ನು ಬಗ್ಗೆ ಆರಂಭಿಸಲು ನಂತರ ಭಾರಿ ಅಧಿಕ ಅಲ್ಲ

59
00:03:16,150 --> 00:03:18,600
ನೀವು ಫೇಸ್ಬುಕ್ ಮೇಲೆ ನೋಡಿ ಅಥವಾ ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾದೊಂದಿಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸುವ ವಿಷಯಗಳನ್ನು.

60
00:03:18,600 --> 00:03:21,410
ಆದರೆ ಇದು ಖಂಡಿತವಾಗಿ ಬಣ್ಣಗಳ ಬಂದಾಗ, ನೀವು ಹೆಚ್ಚಿನ ಬಿಟ್ಗಳು ಅಗತ್ಯವಿದೆ.

61
00:03:21,410 --> 00:03:25,690
ಮತ್ತು ಛಾಯಾಚಿತ್ರಗಳನ್ನು ಜಗತ್ತಿನ ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದರೆ 1-ಬಿಟ್ ಬಣ್ಣ ಬಳಸುವುದು

62
00:03:25,690 --> 00:03:29,560
ಈ ಸೂಚಿಸುತ್ತದೆ, ಆದರೆ 24 ಬಿಟ್ ಬಣ್ಣ, ನೀವು ವಾಸ್ತವವಾಗಿ ಬಣ್ಣಗಳನ್ನು ಲಕ್ಷಾಂತರ ಪಡೆಯಲು ಅಲ್ಲಿ. ಮಾಹಿತಿ

63
00:03:29,560 --> 00:03:32,250
ನಾವು ರಾಬ್ ಕಣ್ಣಿನ ಮೇಲೆ ಜೂಮ್ ಮಾಡಿದಾಗ ವಿಷಯದಲ್ಲಿ,

64
00:03:32,250 --> 00:03:36,370
ವಿಭಿನ್ನ ವರ್ಣರಂಜಿತ ಸಾಧ್ಯತೆಗಳನ್ನು ಲಕ್ಷಾಂತರ ಯಾವುದೇ ಸಂಖ್ಯೆ.

65
00:03:36,370 --> 00:03:39,040
ಆದ್ದರಿಂದ ನಾವು, ಸಮಸ್ಯೆ ಸೆಟ್ 4 ಅಲ್ಲದೇ ದರ್ಶನ ಈ ಪರಿಚಯಿಸಲು ವಿಲ್

66
00:03:39,040 --> 00:03:43,370
ಏಕೆಂದರೆ ಇಲ್ಲಿ ಶುಕ್ರವಾರ ಅವರ ಉಪನ್ಯಾಸ ವಾಡಿಕೆಯ 2:30 ಬದಲಿಗೆ ಮಧ್ಯಾಹ್ನ 3:30 ನಲ್ಲಿ ಇಂದು ವಾಗಿರುತ್ತದೆ.

67
00:03:43,370 --> 00:03:46,620
ಆದರೆ ವೀಡಿಯೊ ಸಾಮಾನ್ಯ ನಾಳೆ ಮಾಹಿತಿ ಆನ್ಲೈನ್ನಲ್ಲಿ ಕಾಣಿಸುತ್ತದೆ.

68
00:03:46,620 --> 00:03:48,820
>> ನಾವು ಇನ್ನೊಂದು ಫೈಲ್ ಸ್ವರೂಪಕ್ಕೆ ನೀವು ಪರಿಚಯಿಸಲು ಮಾಡುತ್ತೇವೆ.

69
00:03:48,820 --> 00:03:51,270
ಈ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ, ಮೊದಲಿಗೆ ಬೆದರಿಸುವ ನೋಡಲು ಅರ್ಥ ಇದೆ

70
00:03:51,270 --> 00:03:55,670
ಆದರೆ ಈ ಒಂದು ಸಿ struct ಕೇವಲ ಕೆಲವು ದಾಖಲೆಗಳನ್ನು ಹೊಂದಿದೆ.

71
00:03:55,670 --> 00:03:58,940
ಇದು ಮೈಕ್ರೋಸಾಫ್ಟ್ ವರ್ಷಗಳ ಹಿಂದೆ ಈ ರೂಪದಲ್ಲಿ ಜನಪ್ರಿಯಗೊಳಿಸಲು ಸಹಕಾರಿಯಾಯಿತು ಎಂದು ತಿರುಗುತ್ತದೆ

72
00:03:58,940 --> 00:04:05,150
ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್ ಸ್ವರೂಪ, BMP, ಮತ್ತು ಈ ಒಂದು ಸೂಪರ್ ಸರಳ, ವರ್ಣರಂಜಿತ ಚಿತ್ರಾತ್ಮಕ ಕಡತ ಸ್ವರೂಪ ಎಂದು ಕರೆದಿದೆ

73
00:04:05,150 --> 00:04:10,150
ಆ ಡೆಸ್ಕ್ ಮೇಲೆ ವಾಲ್ಪೇಪರ್ಗಳಿಗಾಗಿ ಕೆಲವೊಮ್ಮೆ ಇನ್ನೂ ಒಂದಷ್ಟು ಕಾಲ ಬಳಸಲ್ಪಟ್ಟಿತು.

74
00:04:10,150 --> 00:04:14,760
ನೀವು Windows XP ಮತ್ತು ಬೆಟ್ಟ ಗುಡ್ಡಗಳು ಮತ್ತು ನೀಲಿ ಆಕಾಶ ಮತ್ತೆ ಭಾವಿಸಿದರೆ,

75
00:04:14,760 --> 00:04:17,170
ಎಂದು ವಿಶಿಷ್ಟವಾಗಿ BMP ಅಥವಾ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ ಆಗಿತ್ತು.

76
00:04:17,170 --> 00:04:19,959
ಅವರು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣತೆ ಏಕೆಂದರೆ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ನಮಗೆ ಆನಂದದಾಯಕವಾಗುವ.

77
00:04:19,959 --> 00:04:22,610
ಇದು ಸಾಕಷ್ಟು 0 ಸೆ ಮತ್ತು 1 ಈ ಗ್ರಿಡ್ ಸರಳ ಮಾಹಿತಿ ಇಲ್ಲಿದೆ.

78
00:04:22,610 --> 00:04:27,510
ಬದಲಿಗೆ, ನೀವು ಕಡತದ ಆರಂಭದಲ್ಲಿ ಒಂದು ಹೆಡರ್ ವಿಷಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

79
00:04:27,510 --> 00:04:31,990
ಆದ್ದರಿಂದ ಒಳಗೆ ಒಂದು. BMP ಫೈಲ್ ಇತರೆ ಪದಗಳಲ್ಲಿ 0 ಸೆ ಮತ್ತು 1 ಗಳ ಇಡೀ ಗುಂಪೇ, ಆಗಿದೆ

80
00:04:31,990 --> 00:04:34,910
ಆದರೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ 0 ಸೆ ಮತ್ತು 1 ಇಲ್ಲ.

81
00:04:34,910 --> 00:04:38,220
ಮತ್ತು ವರ್ಷಗಳ ಕಾಲ ಲಘುವಾಗಿ ನಾವು ಬಹುಶಃ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಂದು ತಿರುಗುತ್ತದೆ -

82
00:04:38,220 --> 00:04:45,170
. ಡಾಕ್ ಅಥವಾ. xls ಅಥವಾ. MP3, ರೀತಿಯ ಕಡತ ಸ್ವರೂಪಗಳನ್ನು. MP4, ಯಾವುದೇ ಕಡತ ಸ್ವರೂಪಗಳು

83
00:04:45,170 --> 00:04:48,480
ನಿಮಗೆ ಪರಿಚಿತವಾಗಿರುವ ಆ - ಎಂಬುದನ್ನು ಇದು, ಒಂದು ಕಡತ ಸ್ವರೂಪ ಎಂದು ಅರ್ಥವೇನು

84
00:04:48,480 --> 00:04:52,480
ದಿನದ ಕೊನೆಯಲ್ಲಿ ಈ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ನಾವು 0 ಸೆ ಮತ್ತು 1 ಹೊಂದಿರುತ್ತವೆ ಬಳಸಲು ಕಾರಣ.

85
00:04:52,480 --> 00:04:56,810
ಮತ್ತು ಬಹುಶಃ ಆ 0 ಸೆ ಮತ್ತು 1 ASCII ಮೂಲಕ ಎಬಿಸಿ ಅಥವಾ ಹಾಗೆ ಪ್ರತಿನಿಧಿಸಲು

86
00:04:56,810 --> 00:04:58,820
ಆದರೆ ದಿನದ ಕೊನೆಯಲ್ಲಿ, ಇದು ಇನ್ನೂ ಕೇವಲ 0 ಸೆ ಮತ್ತು 1 ರ.

87
00:04:58,820 --> 00:05:02,100
ಆದ್ದರಿಂದ ಮಾನವರು ಕೇವಲ ಸಾಂದರ್ಭಿಕವಾಗಿ ಒಂದು ಹೊಸ ಕಡತ ಸ್ವರೂಪದ ಆವಿಷ್ಕರಿಸಲು ನಿರ್ಧರಿಸಿದಲ್ಲಿ

88
00:05:02,100 --> 00:05:06,420
ಅವರು ಬಿಟ್ಸ್ ಮಾದರಿಗಳು ವಾಸ್ತವವಾಗಿ ಅರ್ಥವೇನು ಪ್ರಮಾಣಕವಾಗಿಸಲು ಅಲ್ಲಿ.

89
00:05:06,420 --> 00:05:09,220
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಜನರಾಗಿದ್ದರು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಸ್ವರೂಪದ ವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದಂತಹ

90
00:05:09,220 --> 00:05:15,620
ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್ ತುಂಬಾ ಮೊದಲ ಬೈಟ್ ನಲ್ಲಿ, ಮಾಹಿತಿ ಇಲ್ಲ ಆಫ್ಸೆಟ್ 0 ಸೂಚಿಸಲಾಗುತ್ತದೆ ಹೇಳಿದರು,

91
00:05:15,620 --> 00:05:18,940
ಕೆಲವು cryptically ಹೆಸರಿನ ವೇರಿಯಬಲ್ ಎಂಬ bfType, ಇರುವಂತೆ ಹೋಗುತ್ತದೆ

92
00:05:18,940 --> 00:05:23,080
ಕೇವಲ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ರೀತಿಯ ನಿಂತಿರುವ, ಏನು ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್ ಇದು.

93
00:05:23,080 --> 00:05:27,700
ನೀವು 2 ಆಫ್ಸೆಟ್ ಎಂದು ಎರಡನೇ ಸಾಲು, ಬೈಟ್ ಸಂಖ್ಯೆ 2, ನಿಂದ ಬಹುಶಃ ನಿರ್ಣಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

94
00:05:27,700 --> 00:05:33,740
ಯಾವ ಪ್ರತಿನಿಧಿಸುವ 0 ಸೆ ಮತ್ತು 1 ಗಳ ಒಂದು ಮಾದರಿಯನ್ನು ಹೊಂದಿದೆ? ಏನೋ ಗಾತ್ರವನ್ನು.

95
00:05:33,740 --> 00:05:35,310
ಮತ್ತು ಅಲ್ಲಿಂದ ಮೇಲೆ ಹೋಗುತ್ತದೆ.

96
00:05:35,310 --> 00:05:37,410
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ 4, ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಕೆಲವು ಮೂಲಕ ನಡೆದರು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ.

97
00:05:37,410 --> 00:05:39,520
ನಾವು ಎಲ್ಲಾ ಬಗ್ಗೆ caring ಅಪ್ ಕೊನೆಗೊಂಡಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ.

98
00:05:39,520 --> 00:05:47,510
ಆದರೆ ಬೈಟ್ 54 ಸುಮಾರು ಆಸಕ್ತಿದಾಯಕ ಪಡೆಯಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಗಮನಕ್ಕೆ: rgbtBlue, ಹಸಿರು, ಮತ್ತು ಕೆಂಪು.

99
00:05:47,510 --> 00:05:52,110
ನೀವು ಆಲಿಸಿದ ನೀವು ಪ್ರಥಮಾಕ್ಷರಿ RGB - ಕೆಂಪು, ಹಸಿರು, ನೀಲಿ - ಈ ಆ ಉಲ್ಲೇಖವಾಗಿತ್ತು

100
00:05:52,110 --> 00:05:54,610
ಇದನ್ನು ತಿರುಗುತ್ತದೆ ಏಕೆಂದರೆ ನೀವು ಮಳೆಬಿಲ್ಲಿನ ಎಲ್ಲಾ ಬಣ್ಣಗಳ ಪೇಂಟ್

101
00:05:54,610 --> 00:05:58,180
ಕೆಂಪು ಮತ್ತು ನೀಲಿ ಮತ್ತು ಹಸಿರು ಕೆಲವು ಸಂಯೋಜನೆಯೊಂದಿಗೆ.

102
00:05:58,180 --> 00:06:03,320
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಕೋಣೆಯಲ್ಲಿ ಪೋಷಕರು ಆರಂಭಿಕ ಪ್ರಕ್ಷೇಪಕಗಳು ಕೆಲವು ಮರುಪಡೆಯಲು ಇರಬಹುದು.

103
00:06:03,320 --> 00:06:05,890
ಈ ದಿನಗಳಲ್ಲಿ, ನೀವು ಕೇವಲ ಒಂದು ಪ್ರಕಾಶಮಾನವಾದ ಬೆಳಕಿನ ಒಂದು ಮಸೂರದ ಹೊರಬರುತ್ತಿರುವ ನೋಡಿ

104
00:06:05,890 --> 00:06:09,800
ಆದರೆ ದಿನದಲ್ಲಿ ನೀವು, ಕೆಂಪು ಮಸೂರ, ನೀಲಿ ಲೆನ್ಸ್, ಮತ್ತು ಹಸಿರು ಮಸೂರ ಹೊಂದಿತ್ತು

105
00:06:09,800 --> 00:06:13,380
ಒಟ್ಟಾಗಿ ಅವರು ಸ್ಕ್ರೀನ್ ಗುರಿ ಮತ್ತು ವರ್ಣರಂಜಿತ ಚಿತ್ರವನ್ನು ರಚಿಸಿದರು.

106
00:06:13,380 --> 00:06:16,270
ಮತ್ತು ಸ್ವಲ್ಪ ಹೆಚ್ಚಾಗಿ, ಮಧ್ಯಮ ಶಾಲೆಗಳು ಮತ್ತು ಪ್ರೌಢಶಾಲೆಗಳು ಆ ಮಸೂರಗಳು ಹೊಂದಿರುತ್ತದೆ

107
00:06:16,270 --> 00:06:19,720
ಎಂದಿಗೂ ಆ ಸ್ವಲ್ಪ ವಕ್ರವಾಗಿ, ಆದ್ದರಿಂದ ನೀವು ಎರಡು ಅಥವಾ ಮೂರು ಚಿತ್ರಗಳನ್ನು ನೋಡುವ ರೀತಿಯ.

108
00:06:19,720 --> 00:06:24,100
ಆದರೆ ಆ ಐಡಿಯಾ. ನೀವು ಒಂದು ಚಿತ್ರಣ ಕೆಂಪು ಮತ್ತು ಹಸಿರು ಮತ್ತು ನೀಲಿ ಬೆಳಕಿನ ಹೊಂದಿತ್ತು.

109
00:06:24,100 --> 00:06:26,590
ಮತ್ತು ಅದೇ ತತ್ವವನ್ನು ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

110
00:06:26,590 --> 00:06:30,230
>> ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ನಿಮ್ಮನ್ನು ನಂತರ ಸವಾಲುಗಳನ್ನು ನಡುವೆ ಸೆಟ್ 4 ಕೆಲವು ವಿಷಯಗಳನ್ನು ಮುಂದುವರೆಸುತ್ತೇವೆ.

111
00:06:30,230 --> 00:06:34,800
ಒಂದು ವಾಸ್ತವವಾಗಿ ಚಿತ್ರವನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಹೊಂದಿದೆ, 0 ಸೆ ಮತ್ತು 1 ಗಳ ಒಂದು ಮಾದರಿಯನ್ನು ತೆಗೆದುಕೊಂಡು,

112
00:06:34,800 --> 00:06:40,200
, 0 ಸೆ ಮತ್ತು 1 ಗಳ ಭಾಗಗಳಲ್ಲಿ ಒಂದು ರಚನೆ ಯಾವ ಇಂತಹ ಪ್ರತಿನಿಧಿಸುವ ಔಟ್ ಲೆಕ್ಕಾಚಾರ

113
00:06:40,200 --> 00:06:43,630
ರೆಡ್ಸ್, ಬ್ಲೂಸ್, ಹಸಿರು - ಮತ್ತು ನಂತರ ಪಿಕ್ಸೆಲ್ಗಳು ಪುನರಾವರ್ತಿಸಲು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ -

114
00:06:43,630 --> 00:06:46,660
ಒಳಗೆ ಆದ್ದರಿಂದ ಚಿತ್ರವನ್ನು ಆರಂಭದಲ್ಲಿ ಈ ರೀತಿ ನೋಡಿದಾಗ,

115
00:06:46,660 --> 00:06:49,210
ಆ ನಂತರ ಬದಲಿಗೆ ಈ ರೀತಿ ಇರಬಹುದು.

116
00:06:49,210 --> 00:06:53,640
ಇತರ ಸವಾಲುಗಳನ್ನು ನಡುವೆ ತುಂಬಾ ನೀವು ನ್ಯಾಯ ಚಿತ್ರ ಹಸ್ತಾಂತರಿಸುವಾಗ ಮಾಡುತ್ತೇನೆ ಎಂದು ಹೋಗುತ್ತದೆ

117
00:06:53,640 --> 00:06:56,030
ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾ ಒಂದು ನಿಜವಾದ ಕಡತದ.

118
00:06:56,030 --> 00:06:58,960
ಮತ್ತು ಕ್ಯಾಮೆರಾ ಮೇಲೆ, ವನ್ಸ್ ಅಪಾನ್ ಎ ಟೈಮ್, ಫೋಟೋಗಳನ್ನು ಇಡೀ ಗುಂಪೇ ಇತ್ತು.

119
00:06:58,960 --> 00:07:03,760
ಸಮಸ್ಯೆಯನ್ನು ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ಅಳಿಸಿಹಾಕಿತು ಅಥವಾ ಚಿತ್ರವನ್ನು ಹೇಗಾದರೂ ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಬೀರಿತ್ತು.

120
00:07:03,760 --> 00:07:05,750
ಬ್ಯಾಡ್ ಥಿಂಗ್ಸ್ ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾಗಳಲ್ಲಿ ಸಂಭವಿಸಬಹುದು.

121
00:07:05,750 --> 00:07:09,150
ಆದ್ದರಿಂದ ಬೇಗ, ನೀವು ಆ ಕಾರ್ಡಿನ 0 ಸೆ ಮತ್ತು 1 ಆಫ್ ಎಲ್ಲಾ ನಕಲು

122
00:07:09,150 --> 00:07:13,610
4 ಹೊಂದಿಸಿ ಒಂದು ದೊಡ್ಡ ಫೈಲ್ ಅವರನ್ನು ಎಲ್ಲಾ ಉಳಿಸಲಾಗಿದೆ, ಮತ್ತು ನಂತರ ನಾವು ಸಮಸ್ಯೆ ನಿಮ್ಮನ್ನು ಅವುಗಳನ್ನು ಹ್ಯಾಂಡ್ ವಿಲ್

123
00:07:13,610 --> 00:07:19,320
ನೀವು ಆದ್ದರಿಂದ ಆ JPEGs ಎಲ್ಲಾ ಚೇತರಿಸಿಕೊಳ್ಳಲು ಅದು ಸಿ ಬರೆಯುವ ಒಂದು ಪ್ರೊಗ್ರಾಮ್ ಇದರಿಂದ.

124
00:07:19,320 --> 00:07:23,330
ಮತ್ತು ಅವರು ಒಂದು ಸಂಕೀರ್ಣ ಕಡತ ಸ್ವರೂಪದ ಸ್ವಲ್ಪ ಮಾಡಿದ್ದರೂ ಸಹ, ಆ JPEGs ತಿರುಗಿದರೆ -

125
00:07:23,330 --> 00:07:26,360
ಅವರು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಇಲ್ಲಿ ಈ ನಗುತ್ತಿರುವ ಮುಖವನ್ನು ಹೆಚ್ಚು ಆರ್ -

126
00:07:26,360 --> 00:07:31,160
ಪ್ರತಿ JPEG 0 ಸೆ ಮತ್ತು 1 ಅದೇ ಮಾದರಿಗಳನ್ನು ಆರಂಭವಾಗುತ್ತದೆ ಎಂದು ತಿರುಗುತ್ತದೆ.

127
00:07:31,160 --> 00:07:35,630
ಆದ್ದರಿಂದ ಬಳಸಿ, ಅಂತಿಮವಾಗಿ, ಲೂಪ್ ಅಥವಾ ಅಂತಹುದೇ ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಅಥವಾ,

128
00:07:35,630 --> 00:07:38,880
ನೀವು ಈ ನ್ಯಾಯ ಚಿತ್ರದಲ್ಲಿ ಎಲ್ಲಾ 0 ಸೆ ಮತ್ತು 1 ಮೇಲೆ ತಿರುಗಿ ಮಾಡಬಹುದು

129
00:07:38,880 --> 00:07:43,150
ಮತ್ತು ನೀವು ಸಮಸ್ಯೆ ಸೆಟ್ ವಿವರಣೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ವಿಶೇಷ ಮಾದರಿಯನ್ನು ನೋಡಿ ಪ್ರತಿ ಬಾರಿ,

130
00:07:43,150 --> 00:07:47,880
ನೀವು, ಅತ್ಯಂತ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆಯನ್ನು ಹೊಂದಿರುವ, ಒಂದು JPEG ಆರಂಭದಲ್ಲಿ ಇಲ್ಲಿ ಪಡೆದುಕೊಳ್ಳಬಹುದು.

131
00:07:47,880 --> 00:07:51,230
ಮತ್ತು ತಕ್ಷಣ ನೀವು ಅದೇ ಮಾದರಿಯನ್ನು ಬೈಟ್ಗಳು ಕೆಲವು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ಮಾಹಿತಿ

132
00:07:51,230 --> 00:07:55,430
ಅಥವಾ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಅಥವಾ ಮೆಗಾಬೈಟ್ ನಂತರ, ನೀವು ಇಲ್ಲಿ ಪಡೆದುಕೊಳ್ಳಬಹುದು, ಎರಡನೇ jpeg ಆಗಿದೆ

133
00:07:55,430 --> 00:07:57,380
ಫೋಟೋ ನಾನು ಮೊದಲ ನಂತರ ಪಡೆದರು.

134
00:07:57,380 --> 00:08:01,370
ನನ್ನ ಮೊದಲ ಕಡತ ಓದುವ ನಿಲ್ಲಿಸಲು ಅವಕಾಶ, ಈ ಹೊಸ ಬರೆಯಲು ಆರಂಭಿಸಲು

135
00:08:01,370 --> 00:08:06,310
ಮತ್ತು pset4 ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ ಅನೇಕ 50 JPEGs ಏರಲಿದೆ.

136
00:08:06,310 --> 00:08:09,270
ಇದು 50 JPEGs ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ನೀವು ಒಂದು ಲೂಪ್ ಒಂದು ಬಿಟ್ ಹೊಂದಿವೆ.

137
00:08:09,270 --> 00:08:12,490
ನೀವು JPEGs ಒಂದು ಅನಂತ ಸಂಖ್ಯೆ, ನೀವು ಅನಂತ ಆದೇಶಗಳ ಹೊಂದಿರುತ್ತವೆ.

138
00:08:12,490 --> 00:08:14,910
ಆದ್ದರಿಂದ ತುಂಬಾ ತುಂಬಾ ಸಾಮಾನ್ಯ ಸಂದರ್ಭ.

139
00:08:14,910 --> 00:08:16,600
ಆದ್ದರಿಂದ ಕ್ಷಿತಿಜದಲ್ಲಿ ಎಂಬುದನ್ನು ಇಲ್ಲಿದೆ.

140
00:08:16,600 --> 00:08:21,310
>> ನಮಗೆ ಹಿಂದೆ 0 ಕುಚೋದ್ಯ, ಸಂತೋಷದಿಂದ ಎರಡೂ ಹೊಂದಿರುವ ಜನರನ್ನು ಏಕರೂಪವಾಗಿ ಇವೆ ನನ್ನ ಇಮೇಲ್ ಪ್ರತಿ ಅರ್ಥ

141
00:08:21,310 --> 00:08:23,640
ತಟಸ್ಥ ಮತ್ತು ರಸಪ್ರಶ್ನೆ ಸುಮಾರು ದುಃಖ 0 ಕಾಲದ ರೀತಿಯ.

142
00:08:23,640 --> 00:08:26,800
ಮತ್ತು ತಲೆ TF Zamyla, ನಿಮ್ಮ ಸ್ವಂತ TF, ನನಗೆ ತಲುಪಿ ದಯವಿಟ್ಟು

143
00:08:26,800 --> 00:08:31,180
ನೀವು ವಿಷಯಗಳನ್ನು ಹೋದರು ಹೇಗೆ ಚರ್ಚಿಸಲು ಬಯಸುತ್ತೇನೆ ನೀವು ತಿಳಿದಿರುವುದರಿಂದ CAS ಅಥವಾ ಒಂದು.

144
00:08:31,180 --> 00:08:35,539
>> ಆದ್ದರಿಂದ ಕೋಣೆಯಲ್ಲಿ ಇಲ್ಲಿ ಪೋಷಕರು ಮೆಚ್ಚಿಸಲೆಂದೇ, CS50 ಗ್ರಂಥಾಲಯದ ಏನು?

145
00:08:36,429 --> 00:08:40,390
[ನಗು] ಉತ್ತಮ ಕೆಲಸ.

146
00:08:40,390 --> 00:08:48,340
CS50 ಗ್ರಂಥಾಲಯದ ಯಾವುದು? ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಕೋಡ್ ಪೂರ್ವ ಲಿಖಿತ ಸೆಟ್ ನ [ಕೇಳಿಸುವುದಿಲ್ಲ]

147
00:08:48,340 --> 00:08:49,750
ಸರಿ, ಉತ್ತಮ.

148
00:08:49,750 --> 00:08:53,240
ನಾವು ಸಿಬ್ಬಂದಿ ಬರೆದ ಕೋಡ್ ಪೂರ್ವ ಲಿಖಿತ ಸೆಟ್ ನ, ನಾವು, ನೀವು ನೀಡಲು

149
00:08:53,240 --> 00:08:55,030
ಎಂದು, ಕೆಲವು ಸಾಮಾನ್ಯ ಒದಗಿಸುತ್ತದೆ

150
00:08:55,030 --> 00:08:59,020
ಅಂತ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ನಂತಹ ಸ್ಟಫ್ ನನ್ನನ್ನು ಪಡೆಯಲು ಒಂದು ಇಂಟ್ - ಇಲ್ಲಿ ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ ಕಾರ್ಯಗಳ ಎಲ್ಲಾ.

151
00:08:59,020 --> 00:09:02,260
>> ಈಗ ಪ್ರಾರಂಭವಾಗುತ್ತಿದೆ, ನಾವು ಈ ತರಬೇತಿ ಚಕ್ರಗಳು ತೆಗೆದುಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿ.

152
00:09:02,260 --> 00:09:05,050
ನಾವು, ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ತೆಗೆದುಕೊಳ್ಳುವ ಆರಂಭಿಸಲು ನೀನು

153
00:09:05,050 --> 00:09:08,870
ಇದು ರಿಕಾಲ್ ಏನು ನಿಜವಾದ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಕೇವಲ ಒಂದು ಸಮಾನಾರ್ಥಕ ಪದವಾಯಿತು? >> [ಬಹು ವಿದ್ಯಾರ್ಥಿಗಳು] ಚಾರ್ *.

154
00:09:08,870 --> 00:09:12,730
ಚಾರ್ *. ಪೋಷಕರು, ಆ ಬಹುಶಃ [ಮಾಡುತ್ತದೆ whooshing ಧ್ವನಿ] ಆಗಿತ್ತು. ಎಂದು ಒಳ್ಳೆಯದು.

155
00:09:12,730 --> 00:09:17,550
ಚಾರ್ * ನಾವು ನಮ್ಮ ಶಬ್ದಕೋಶವನ್ನು ತಂತುಗಳಿಗೆ ತೆಗೆದು ಎಲ್ಲಾ ಹೆಚ್ಚಿನ ತೆರೆಯ ಮೇಲೆ ನೋಡಲು ಪ್ರಾರಂಭಿಸಿ

156
00:09:17,550 --> 00:09:19,730
ವಾಸ್ತವವಾಗಿ ಕೋಡ್ ಬರೆಯಲು ಅದನ್ನು ಬರುತ್ತದೆ ಕನಿಷ್ಠ ಮಾಡಿದಾಗ.

157
00:09:19,730 --> 00:09:22,840
ಹಾಗೆಯೇ, ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ಕೆಲವು ಹೆಚ್ಚು ಬಳಸಿಕೊಂಡು ನಿಲ್ಲಿಸಲು ವಿಲ್

158
00:09:22,840 --> 00:09:25,280
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಅತ್ಯಾಧುನಿಕ ಕಾಣುವುದು ಏಕೆಂದರೆ.

159
00:09:25,280 --> 00:09:28,480
ಬದಲಿಗೆ ಕೇವಲ, ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಮಿಟುಕಿಸುವುದು ಜೊತೆ ಕುಳಿತುಕೊಂಡು ಕಾರ್ಯಸೂಚಿಗಳನ್ನು ಬರೆಯಲು

160
00:09:28,480 --> 00:09:31,870
ಏನೋ ಟೈಪ್ ಬಳಕೆದಾರರು ಕಾಯುವ, ನೀವು ಬೇರೆಡೆಯಿಂದ ನಿಮ್ಮ ಒಳಹರಿವು ಪಡೆಯುತ್ತೀರಿ.

161
00:09:31,870 --> 00:09:35,490
ಉದಾಹರಣೆಗೆ, ನೀವು ಸ್ಥಳೀಯ ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಬಿಟ್ಗಳು ಸರಣಿಯನ್ನು ಅವುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ.

162
00:09:35,490 --> 00:09:38,580
ನೀವು ಬದಲಿಗೆ, ಒಂದು ಜಾಲಬಂಧ ಸಂಪರ್ಕವನ್ನು ರಿಂದ ಭವಿಷ್ಯದಲ್ಲಿ ಅವುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ

163
00:09:38,580 --> 00:09:40,230
ಎಲ್ಲೋ ಕೆಲವು ವೆಬ್ಸೈಟ್.

164
00:09:40,230 --> 00:09:44,110
>> ಆದ್ದರಿಂದ ಮೊದಲ ಬಾರಿಗೆ ಮರಳಿ ಈ ಪದರವನ್ನು ಪೀಲ್ ನಾವು ಮತ್ತು CS50 ಯಂತ್ರ ಅಪ್ ಪುಲ್

165
00:09:44,110 --> 00:09:49,010
ನೀವು # ವಾರಗಳ ಸೇರಿದಂತೆ ಮಾಡಿರುವ ಇದು cs50.h ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ಫೈಲ್,

166
00:09:49,010 --> 00:09:51,140
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಈ ಒಳಗೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

167
00:09:51,140 --> 00:09:54,430
ನೀಲಿ ಫೈಲ್ ಮೇಲೆ ಕೇವಲ ಕಾಮೆಂಟ್ಗಳ ಇಡೀ ಗುಂಪೇ ಹೊಂದಿದೆ:

168
00:09:54,430 --> 00:09:57,050
ಖಾತರಿ ಮಾಹಿತಿ ಮತ್ತು ಪರವಾನಗಿ.

169
00:09:57,050 --> 00:09:59,050
ಈ ತಂತ್ರಾಂಶದ ಸಾಮಾನ್ಯ ನಿದರ್ಶನದ ತೆರನಾದ

170
00:09:59,050 --> 00:10:01,580
ಸಾಫ್ಟ್ವೇರ್ ಬಹಳಷ್ಟು ಈ ದಿನಗಳ ಮುಕ್ತ ಆಕರ ಎಂದು ಏನನ್ನು ಏಕೆಂದರೆ,

171
00:10:01,580 --> 00:10:05,220
ಇದು ಯಾರೋ ಕೋಡ್ ಬರೆದು ಇದು ಉಚಿತವಾಗಿ ಲಭ್ಯವಿದೆ ಎಂದು ಅರ್ಥ

172
00:10:05,220 --> 00:10:10,470
ಕೇವಲ ಚಲಾಯಿಸಲು ಮತ್ತು ಬಳಸಲು ಆದರೆ ವಾಸ್ತವವಾಗಿ ಓದಲು ಮತ್ತು ಮಾರ್ಪಡಿಸುವ ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಕೆಲಸ ಒಂದುಗೂಡುವ.

173
00:10:10,470 --> 00:10:14,660
ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಚಿಕ್ಕ ರೂಪ, ಆದರೂ, ತೆರೆದ ಮೂಲ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ ಇಲ್ಲಿದೆ.

174
00:10:14,660 --> 00:10:18,560
ನಾನು ಕಾಮೆಂಟ್ಗಳನ್ನು ಕಳೆದ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ಆದರೂ ನಾವು ಕೆಲವು ಹೆಚ್ಚು ಪರಿಚಿತ ವಸ್ತುಗಳು ನೋಡಲು ಪ್ರಾರಂಭಿಸಿ.

175
00:10:18,560 --> 00:10:25,010
Cs50.h ಕಡತ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಂದು ಇಡೀ ಗುಂಪೇ ಒಳಗೊಂಡಿರುವ ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಸೂಚನೆ.

176
00:10:25,010 --> 00:10:28,560
ಇವುಗಳಲ್ಲಿ, ನಾವು ಮೊದಲು ನೋಡಿಯೇ ಇಲ್ಲ, ಆದರೆ ಒಂದು ಚಿರಪರಿಚಿತವಾಗಿದೆ.

177
00:10:28,560 --> 00:10:32,270
ಇವುಗಳಲ್ಲಿ ನಾವು ಇದುವರೆಗಿನ, ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಆದರೂ, ನೋಡಿದ್ದೇವೆ? >> [ವಿದ್ಯಾರ್ಥಿ] ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಗ್ರಂಥಾಲಯ.

178
00:10:32,270 --> 00:10:35,810
ಹೌದು, ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯ. stdlib.h malloc ಹೊಂದಿದೆ.

179
00:10:35,810 --> 00:10:38,320
ಒಮ್ಮೆ ನಾವು, ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಆರಂಭಿಸುತ್ತಾನೆ

180
00:10:38,320 --> 00:10:41,650
ನಾವು ಜೊತೆಗೆ ಮುಂದಿನ ವಾರ ಹಿಂತಿರುಗಿ ವಿಲ್ ಇದು, ಆ ಫೈಲ್ ಸೇರಿಸಿಕೊಳ್ಳಲು ಆರಂಭಿಸಿತು.

181
00:10:41,650 --> 00:10:46,640
ಇದು bool ಮತ್ತು ತಪ್ಪೆಂದು ವಾಸ್ತವವಾಗಿ ಸಿ ಪ್ರತಿ ಸೆ ಅಸ್ತಿತ್ವದಲ್ಲಿ ಇಲ್ಲವೇ ಇಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ

182
00:10:46,640 --> 00:10:49,440
ನೀವು ಇಲ್ಲಿ ಈ ಫೈಲ್, ಹೊರತು.

183
00:10:49,440 --> 00:10:52,710
ನಾವು ವಾರಗಳ stdbool.h ಸೇರಿದಂತೆ ಮಾಡಲಾಗಿದೆ

184
00:10:52,710 --> 00:10:55,620
ನೀವು ಒಂದು, bool ಸರಿ ಅಥವಾ ತಪ್ಪು. ಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತಾರೆ ಇದರಿಂದ

185
00:10:55,620 --> 00:10:58,620
ಈ, ನೀವು ನಕಲಿ ಅದನ್ನು ವಿಂಗಡಿಸಲು ಮತ್ತು ಒಂದು ಇಂಟ್ ಬಳಸಬೇಕಾಗಿಬರುತ್ತಿತ್ತು

186
00:10:58,620 --> 00:11:02,610
ಮತ್ತು ಕೇವಲ ನಿರಂಕುಶವಾಗಿ 0 ತಪ್ಪಾಗಿದೆ ಮತ್ತು 1 ನಿಜವಾದ ಭಾವಿಸುತ್ತವೆ.

187
00:11:02,610 --> 00:11:07,150
ನಾವು ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ಇಲ್ಲಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ವ್ಯಾಖ್ಯಾನವಾಗಿದೆ.

188
00:11:07,150 --> 00:11:11,390
ಈ ನಕ್ಷತ್ರ ಅಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಪರವಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ನಾವು ಮೊದಲು ಹೇಳುತ್ತಿದ್ದೆ ಎಂದು, ಔಟ್ ತಿರುಗುತ್ತದೆ.

189
00:11:11,390 --> 00:11:13,720
ನೀವು ಎಲ್ಲಾ ಸುಮಾರು ಜಾಗವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

190
00:11:13,720 --> 00:11:16,740
ಈ ಸೆಮಿಸ್ಟರ್ ಸ್ಪಷ್ಟಪಡಿಸಲು ಈ ಎಂದು ಪ್ರಚಾರ ಮಾಡಲಾಗಿದೆ

191
00:11:16,740 --> 00:11:18,620
ಸ್ಟಾರ್ ಟೈಪ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಂದು

192
00:11:18,620 --> 00:11:21,700
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಅಲ್ಲ ಆದರೆ, ಕೇವಲ ಸಾಮಾನ್ಯ ಅರ್ಥ

193
00:11:21,700 --> 00:11:24,430
ಅದನ್ನು ಆಗಲು, ಆದರೆ ಕಾರ್ಯತತ್ಪರವಾಗಿಲ್ಲದಿರಬಹುದು ಅದೇ ವಿಷಯ.

194
00:11:24,430 --> 00:11:27,720
ನಾವು ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಓದಲು ಆದರೆ ಈಗ, ಅವರ GetInt ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ

195
00:11:27,720 --> 00:11:32,190
ನಾವು ಬೇರೆ ಏನು ಈ ಸೆಮಿಸ್ಟರ್ ಮುಂಚೆ ಬಹುಶಃ ಮೊದಲ ಬಳಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ.

196
00:11:32,190 --> 00:11:37,440
ಇಲ್ಲಿ GetInt ಹೊಂದಿದೆ. ಇದು ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ಮಾದರಿ. >> ಇದು ಕೇವಲ ಒಂದು ಮಾದರಿ ಹೊಂದಿದೆ.

197
00:11:37,440 --> 00:11:41,410
ಸಾಮಾನ್ಯವಾಗಿ, ನಮ್ಮ ಮೇಲ್ಭಾಗಗಳು ನಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಹಾಕಬಹುದು. ಸಿ ಕಡತಗಳನ್ನು,

198
00:11:41,410 --> 00:11:46,690
ಆದರೆ ನೀವು ಇಲ್ಲಿ ಈ ಒಂದು ರೀತಿಯ ಹೆಡರ್ ಕಡತಗಳನ್ನು. H ಕಡತಗಳನ್ನು, ರಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಹಾಕಬಹುದು

199
00:11:46,690 --> 00:11:50,840
ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ನೀವು, ಇತರ ಜನರು ಬಳಸಲು ಬಯಸುವ

200
00:11:50,840 --> 00:11:53,550
ಇದು ನಿಖರವಾಗಿ CS50 ಗ್ರಂಥಾಲಯದ ಸಂದರ್ಭ

201
00:11:53,550 --> 00:11:57,040
ನೀವು cs50.c ಸ್ವಲ್ಪ ನಿಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ ಮಾತ್ರ

202
00:11:57,040 --> 00:12:02,790
ನೀವು ಆ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಆದರೆ ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಪುಟ್.

203
00:12:02,790 --> 00:12:07,170
ನಂತರ ಹೆಡರ್ ಕಡತವನ್ನು ಸ್ನೇಹಿತರು ಮತ್ತು ಸಹೋದ್ಯೋಗಿಗಳು ಸೇರಿವೆ ಏನು

204
00:12:07,170 --> 00:12:09,760
ಜೊತೆಗೆ # ತಮ್ಮದೇ ಕೋಡ್ ಒಳಗೊಂಡಿದೆ.

205
00:12:09,760 --> 00:12:12,210
ಈ ಸಮಯ ಆದ್ದರಿಂದ, ನೀವು, ಈ ಮೂಲಮಾದರಿಗಳನ್ನು ಸೇರಿದಂತೆ ಮಾಡಿರುವ

206
00:12:12,210 --> 00:12:16,580
ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿಮ್ಮ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಆದರೆ ಈ ಮೂಲಕ #, ಯಾಂತ್ರಿಕ ಸೇರಿವೆ

207
00:12:16,580 --> 00:12:20,070
ನಿಮ್ಮ ಸ್ವಂತಕ್ಕೆ ಇದು ಮೂಲಭೂತವಾಗಿ ಪ್ರತಿಗಳು ಮತ್ತು ಜಲಪಿಷ್ಟಗಳು ಈ ಕಡತ.

208
00:12:20,070 --> 00:12:23,070
ಇಲ್ಲಿ ಕೆಲವು ತಕ್ಕಮಟ್ಟಿಗೆ ವಿವರವಾದ ದಾಖಲೆಯನ್ನು ಹೊಂದಿದೆ.

209
00:12:23,070 --> 00:12:25,640
GetInt ಒಂದು ಇಂಟ್ ಗಳಿಸುವ ಮಂಜೂರು ನಾವು ಅತ್ಯಧಿಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು,

210
00:12:25,640 --> 00:12:27,640
ಕೆಲವು ಮೂಲೆಯಲ್ಲಿ ಇರುವ ಔಟ್ ಆದರೆ ತಿರುಗುತ್ತದೆ.

211
00:12:27,640 --> 00:12:31,810
ಯಾವ ಒಂದು quintillion, ದಾರಿ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಎಂದು ಅನೇಕ ಬಳಕೆದಾರರು ರೀತಿಯ ವೇಳೆ,

212
00:12:31,810 --> 00:12:35,490
ಕೇವಲ ಒಂದು ಇಂಟ್ ನ ಹಿಡಿಸುವಂತೆ ಸಾಧ್ಯವಿಲ್ಲ? ನಿರೀಕ್ಷಿತ ವರ್ತನೆಯನ್ನು ಎಂದರೇನು?

213
00:12:35,490 --> 00:12:38,020
ತಾತ್ತ್ವಿಕವಾಗಿ ಇದು ಊಹಿಸಬಹುದಾದ ಇಲ್ಲಿದೆ.

214
00:12:38,020 --> 00:12:40,280
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ, ಫೈನ್ ಪ್ರಿಂಟ್ ಓದಲು

215
00:12:40,280 --> 00:12:44,500
ನೀವು ನಿಜವಾಗಿಯೂ ಸಾಲನ್ನು ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ ವೇಳೆ, ಈ ಮರಳುತ್ತದೆ INT_MAX ನೋಡುತ್ತಾರೆ.

216
00:12:44,500 --> 00:12:48,320
ನಾವು ಈ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು, ಆದರೆ ತನ್ನ ಬಂಡವಾಳೀಕರಣ ಆಧರಿಸಿ, ಇದು ಯಾವ ಬಹುಶಃ ಎಂದಿಗೂ ನೀವು?

217
00:12:48,320 --> 00:12:50,640
[ವಿದ್ಯಾರ್ಥಿ] ನಿರಂತರ. >> ಇದು ಒಂದು ಸ್ಥಿರ ಇಲ್ಲಿದೆ.

218
00:12:50,640 --> 00:12:54,770
ಬಹುಶಃ ಆ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಂದು ಘೋಷಣೆ ಮಾಡಿದ ಕೆಲವು ವಿಶೇಷ ಸ್ಥಿರ ಇಲ್ಲಿದೆ

219
00:12:54,770 --> 00:13:00,090
, ಆ ಕಡತವನ್ನು ಎತ್ತರದ, ಮತ್ತು INT_MAX ಸುಮಾರು 2 ಶತಕೋಟಿ ಹಾಗೆ ಬಹುಶಃ ವಿಷಯ

220
00:13:00,090 --> 00:13:04,990
ನಾವು ಹೇಗೋ ಏನೋ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಬೇಕಾಗುತ್ತದೆ ಎಂಬುದು ಕಲ್ಪನೆಯು ತಪ್ಪಾಗಿದೆ

221
00:13:04,990 --> 00:13:10,700
ನಾವು, ಹೌದು, ನಮ್ಮ ಇತ್ಯರ್ಥವಾಗದ 4 ಬಿಲಿಯನ್ ಸಂಖ್ಯೆಯ: -2 ಶತಕೋಟಿ 2 ಬಿಲಿಯನ್ ಮೇಲೆ, ನೀಡಲು ಅಥವಾ ಪಡೆಯಲು.

222
00:13:10,700 --> 00:13:14,710
ಅಲ್ಲದೆ, ಯಾವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಮಾನ್ಯವಾಗಿದೆ, ನೀವು ಆ ಸಂಖ್ಯೆಗಳ ಒಂದು ಕಳ್ಳತನ ಆಗಿದೆ

223
00:13:14,710 --> 00:13:18,920
ಬಹುಶಃ 0, ಬಹುಶಃ 2 ಬಿಲಿಯನ್, ಬಹುಶಃ -2 ಶತಕೋಟಿ

224
00:13:18,920 --> 00:13:23,280
ನೀವು ಜಗತ್ತಿನ ಬದ್ಧರಾಗುತ್ತಾರೆ ಆ ಮೂಲಕ ನೀವು ನಿಮ್ಮ ಸಂಭಾವ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಒಂದು ಕಾಲ

225
00:13:23,280 --> 00:13:26,820
ಒಂದು ವೇಳೆ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ನಾನು ಈ ಸೂಪರ್ ದೊಡ್ಡ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗುವುದು.

226
00:13:26,820 --> 00:13:31,030
ಆದರೆ ನೀವು ಬಳಕೆದಾರ 234 ತರಹದ ಗೂಢ ಏನೋ ಟೈಪ್ ಬಯಸುವುದಿಲ್ಲ ..., ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಸಂಖ್ಯೆ.

227
00:13:31,030 --> 00:13:34,060
ನೀವು ಒಂದು ಸ್ಥಿರ ಬದಲಿಗೆ ಇದು ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ.

228
00:13:34,060 --> 00:13:38,060
ನೀವು ಕಳೆದ ಕೆಲವು ವಾರಗಳ ಗುದ ಎಂದು ವೇಳೆ ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ, ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನೀವು GetInt ಎಂಬ

229
00:13:38,060 --> 00:13:42,900
ಪರಿಸ್ಥಿತಿ INT_MAX ಬಳಕೆದಾರ ಟೈಪ್ ಮಾಡಿದರೆ ನೀವು ಜೊತೆಗೆ ಪರೀಕ್ಷಿಸುವ ನಡೆಯಬೇಕಾಗಿತ್ತು,

230
00:13:42,900 --> 00:13:46,590
ಅಥವಾ, ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಇದು ಮಾಡಿದರೆ ಏಕೆಂದರೆ, GetInt ರಿಟರ್ನ್ INT_MAX ಮಾಡಿದರು,

231
00:13:46,590 --> 00:13:51,830
ಎಂದು ವಾಸ್ತವವಾಗಿ ಅವರು ಅದನ್ನು ಟೈಪ್ ಇಲ್ಲ ಅರ್ಥ. ಏನೋ ಈ ಪ್ರಕರಣದಲ್ಲಿ ತಪ್ಪಾಗಿದೆ.

232
00:13:51,830 --> 00:13:56,080
ಆದ್ದರಿಂದ ಈ ಸಾಮಾನ್ಯವಾಗಿ ವಿಶೇಷ ಅಂದರೆ ಒಂದು ಸೆಂಟಿನೆಲ್ ಮೌಲ್ಯ, ಎಂದು ಏನನ್ನು ಹೊಂದಿದೆ.

233
00:13:56,080 --> 00:13:58,120
>> . ಸಿ ಕಡತ ಬದಲಾಗುತ್ತವೆ ಈಗ ನೋಡೋಣ.

234
00:13:58,120 --> 00:14:01,340
ಸಿ ಕಡತ ಕೆಲವು ಬಾರಿಗೆ ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅಸ್ತಿತ್ವದಲ್ಲಿತ್ತು.

235
00:14:01,340 --> 00:14:06,840
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, APPLIANCE ಇದು ಪೂರ್ವ ಕಂಪೈಲ್ ನಾವು ವಸ್ತುವಿನ ಕೋಡ್ ಎಂಬ ವಿಷಯ ಆಗಿ ನೀವು ಹೊಂದಿದೆ

236
00:14:06,840 --> 00:14:09,540
ವ್ಯವಸ್ಥೆಯ ತಿಳಿದಿರುವ ಕಾರಣ ಅದು ಅಲ್ಲಿ ಆದರೆ ಇದು ನಿಮಗೆ ಸಂಬಂಧಿಸಿದ ಇಲ್ಲ

237
00:14:09,540 --> 00:14:11,730
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಎಲ್ಲಿ: APPLIANCE.

238
00:14:11,730 --> 00:14:17,400
ಈ ಬಾರಿ GetInt ಮತ್ತು GetInt ಕೆಲಸ ಎಂಬುದನ್ನು ನೋಡಲು ಈಗ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಲೆಟ್ಸ್.

239
00:14:17,400 --> 00:14:19,460
ಇಲ್ಲಿ ನಾವು ಮೊದಲು ಇದೇ ಕಾಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಿವೆ.

240
00:14:19,460 --> 00:14:21,660
ನನಗೆ ಕೇವಲ ಕೋಡ್ ಭಾಗದಲ್ಲಿ ಜೂಮ್ ಲೆಟ್.

241
00:14:21,660 --> 00:14:23,900
ಮತ್ತು ನಾವು GetInt ಹೊಂದಿರುವ ಕೆಳಗಿನ ಹೊಂದಿದೆ.

242
00:14:23,900 --> 00:14:25,700
ಇದು ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

243
00:14:25,700 --> 00:14:29,510
, ಇದು (ನಿಜವಾದ) ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು int ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಅನಂತ ಆದೇಶಗಳ ಹೊಂದಿವೆ

244
00:14:29,510 --> 00:14:33,180
ಆದರೆ ಬಹುಶಃ ನಾವು ಹೇಗಾದರೂ ಈ ದಾಳಿ ಅಥವಾ ಈ ಒಳಗಿನ ಬರುತ್ತೇವೆ.

245
00:14:33,180 --> 00:14:34,870
>> ನ ಹೇಗೆ ಈ ಕೆಲಸಗಳನ್ನು ನೋಡೋಣ.

246
00:14:34,870 --> 00:14:39,240
ನಾವು, ಲೂಪ್ ಒಳಗೆ ಈ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ 166 GetString ಬಳಸಿಕೊಂಡು ತೋರುತ್ತಿದೆ.

247
00:14:39,240 --> 00:14:43,780
ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ GetString ಹಿಂದಿರುಗಬಹುದು ಏಕೆಂದರೆ ಈಗ ಉತ್ತಮ ಅಭ್ಯಾಸ

248
00:14:43,780 --> 00:14:47,660
ವಿಶೇಷ ಕೀವರ್ಡ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು? >> [ವಿದ್ಯಾರ್ಥಿ] ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ವೇಳೆ.

249
00:14:47,660 --> 00:14:51,630
ಒಂದು ವೇಳೆ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ. ಮತ್ತು ನೀವು GetString ರೀತಿಯ ಕರೆ ಮಾಡಿದಾಗ ತಪ್ಪು ಹೋಗಿ ಎಂದು ಏನು?

250
00:14:54,960 --> 00:14:57,640
ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] Malloc ಇದು ints ನೀಡಲು ವಿಫಲವಾಗುತ್ತದೆ.

251
00:14:57,640 --> 00:14:59,150
ಹೌದು. ಬಹುಶಃ malloc ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

252
00:14:59,150 --> 00:15:03,190
ಎಲ್ಲೋ HOOD ಕೆಳಗೆ, GetString ಮೆಮೊರಿ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ ಇದು malloc, ಕರೆ ಇದೆ

253
00:15:03,190 --> 00:15:06,020
ಇದು ಅಕ್ಷರಗಳ ಎಲ್ಲಾ ಕಂಪ್ಯೂಟರ್ ಅಂಗಡಿ ಅನುಮತಿಸುತ್ತದೆ

254
00:15:06,020 --> 00:15:07,750
ಎಂದು ಕೀಬೋರ್ಡ್ ಆಗಿ ಬಳಕೆದಾರ ರೀತಿಯ.

255
00:15:07,750 --> 00:15:11,590
ಮತ್ತು, ಬಳಕೆದಾರರಿಗೆ ಉಚಿತ ಸಮಯವನ್ನು ಇಡೀ ಬಹಳಷ್ಟು ಮತ್ತು ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚು ಟೈಪ್ ಇಟ್ಟುಕೋ

256
00:15:11,590 --> 00:15:16,160
ಕಂಪ್ಯೂಟರ್ ಹೆಚ್ಚು ಪಾತ್ರಗಳು, ಹೆಚ್ಚು 2 ಬಿಲಿಯನ್ ಪಾತ್ರಗಳು ಕೂಡ RAM ಹೊಂದಿದೆ.

257
00:15:16,160 --> 00:15:19,250
GetString ನಿಮಗೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

258
00:15:19,250 --> 00:15:22,560
ಈ ಒಂದು ಸೂಪರ್, ಸೂಪರ್ ಅಸಾಮಾನ್ಯ ಮೂಲೆಯಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ, ಸಹ

259
00:15:22,560 --> 00:15:24,340
ಅದು ಹೇಗೋ ಈ ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

260
00:15:24,340 --> 00:15:28,750
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಹಿಂದಿರುಗಿ ಅದರ ದಸ್ತಾವೇಜನ್ನು ಓದಲು, GetString ವಾಸ್ತವವಾಗಿ ರಿಟರ್ನ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಯಾವ.

261
00:15:28,750 --> 00:15:34,460
GetString ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ವಿಫಲವಾದರೆ ಈಗ ವೇಳೆ, GetInt INT_MAX ಮರಳಿ ವಿಫಲವಾದ ಹೋಗುತ್ತದೆ

262
00:15:34,460 --> 00:15:37,690
ಕೇವಲ ಸೆಂಟಿನೆಲ್ ಮಾಹಿತಿ. ಈ ಕೇವಲ ಮಾನವ ಮಾದರಿಗಳಿವೆ.

263
00:15:37,690 --> 00:15:41,450
ಈ ಸಂದರ್ಭದಲ್ಲಿ ತಿಳಿಯುವುದಿಲ್ಲ ಕೇವಲ ರೀತಿಯಲ್ಲಿ ದಸ್ತಾವೇಜನ್ನು ಓದುವ ಮೂಲಕ.

264
00:15:41,450 --> 00:15:45,040
>> ಇಂಟ್ ವಾಸ್ತವವಾಗಿ ನೆತ್ತಿಗೇರಿದೆ ಅಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಲೆಟ್ಸ್.

265
00:15:45,040 --> 00:15:51,160
ನಾನು ಸ್ವಲ್ಪ ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ಸಾಲು 170 ರಲ್ಲಿ, ನಾವು ಈ ಸಾಲುಗಳನ್ನು ಮೇಲೆ ಕಾಮೆಂಟ್ ಹೊಂದಿರುತ್ತವೆ.

266
00:15:51,160 --> 00:15:55,100
ನಾವು 172 ರ ನಂತರ ಒಂದು int, N, ಮತ್ತು ಚಾರ್, ಸಿ, ಮತ್ತು ಈ ಹೊಸ ಕಾರ್ಯಗಳು ಘೋಷಿಸಲು

267
00:15:55,100 --> 00:15:58,930
ನೀವು ಕೆಲವು sscanf ಮೊದಲು ಎಡತಾಕಿರುವಿರಾ ಮಾಡಿದ್ದಾರೆ.

268
00:15:58,930 --> 00:16:00,870
ಈ ವಾಕ್ಯವನ್ನು scanf ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

269
00:16:00,870 --> 00:16:05,700
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನನಗೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ, ಆಸಕ್ತಿಯ ಮಾಹಿತಿಯನ್ನು ತುಣುಕುಗಳನ್ನು ಇದನ್ನು ಸ್ಕ್ಯಾನ್ ಕಾಣಿಸುತ್ತದೆ.

270
00:16:05,700 --> 00:16:07,360
ಎಂದು ಅರ್ಥ ಏನು?

271
00:16:07,360 --> 00:16:11,800
ನಾನು ನಮೂದಿಸಿ ಹಿಟ್ ನಂತರ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ 123, ಅಕ್ಷರಶಃ ಟೈಪ್ ಮತ್ತು ಎಂದು ಭಾವಿಸೋಣ.

272
00:16:11,800 --> 00:16:16,470
GetString ಅದಕ್ಕೆ ಹಿಂದಿರುಗಿದಾಗ 123 ಮಾಹಿತಿ ಪ್ರಕಾರ ಯಾವುದು? >> [ವಿದ್ಯಾರ್ಥಿ] ಸ್ಟ್ರಿಂಗ್.

273
00:16:16,470 --> 00:16:18,380
ಇದು ಬಲ, ನಿಸ್ಸಂಶಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ನ? ನಾನು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ದೊರೆತಿದೆ.

274
00:16:18,380 --> 00:16:23,220
ಆದ್ದರಿಂದ 123, ನಿಜವಾಗಿಯೂ ಉಲ್ಲೇಖ-ಕೊಡುವುದು, ಇದು ಕೊನೆಯಲ್ಲಿ \ 0 123 ಆಗಿದೆ.

275
00:16:23,220 --> 00:16:27,110
ಒಂದು ಇಂಟ್ ಅಲ್ಲ. ಒಂದು ಸಂಖ್ಯೆ ಅಲ್ಲ. ಇದು ಹಲವಾರು ಕಾಣುತ್ತದೆ ಆದರೆ ನಿಜವಾಗಿ ಅಲ್ಲ.

276
00:16:27,110 --> 00:16:29,080
ಆದ್ದರಿಂದ ಯಾವ GetInt ಮಾಡಲು ಹೊಂದಿದೆ?

277
00:16:29,080 --> 00:16:35,750
123 \ 0 - - ಮತ್ತು ಹೇಗಾದರೂ ನಿಜವಾದ ಪೂರ್ಣಾಂಕ ಮತಾಂತರಗೊಳ್ಳಲು ಅದು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಒಂದು ತಂತುವಿನ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಹೊಂದಿದೆ.

278
00:16:35,750 --> 00:16:37,850
ನೀವು ಇದನ್ನು ಹೇಗೆ ಎಂಬುದನ್ನು ಅಂದಾಜು ಮಾಡಬಹುದೆಂಬ.

279
00:16:37,850 --> 00:16:41,450
ನೀವು pset2 ಮರಳಿ ಭಾವಿಸಿದರೆ, ನೀವು ಬಹುಶಃ ಸೀಸರ್ ಒಂದು ಕಡಿಮೆ ಆರಾಮದಾಯಕ ಸಿಕ್ಕಿತು

280
00:16:41,450 --> 00:16:44,820
ಅಥವಾ Vigenere, ಆದ್ದರಿಂದ ನೀವು ಒಂದು ವಾಕ್ಯವನ್ನು ಮೇಲೆ ತಿರುಗಿ, ನೀವು ints ಗೆ ಅಕ್ಷರಗಳನ್ನು ಪರಿವರ್ತಿಸಬಹುದು.

281
00:16:44,820 --> 00:16:46,710
ಆದರೆ ಬೀಟಿಂಗ್, ಇದು ಕೆಲಸದ ಸಂಪೂರ್ಣ ಸಂಗತಿಯೇ.

282
00:16:46,710 --> 00:16:49,860
ಏಕೆ ಆ ಮಾಡುತ್ತದೆ sscanf ಒಂದು ಕ್ರಿಯೆ ಕರೆ?

283
00:16:49,860 --> 00:16:54,230
ಆದ್ದರಿಂದ sscanf ವಾದವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ - ಈ ಸಂದರ್ಭದಲ್ಲಿ ಲೈನ್ ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

284
00:16:54,230 --> 00:17:01,840
ನಂತರ ನಿಮಗೆ ಈ ಸಾಲಿನಲ್ಲಿ ನೋಡಿ ನಿರೀಕ್ಷೆ ಏನು, ಇದೇ ಗೆ printf, ಉಲ್ಲೇಖಗಳಲ್ಲಿ ಸೂಚಿಸಿ.

285
00:17:01,840 --> 00:17:09,000
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಹೇಳುವ ನಾನು ನಾನು ದಶಮಾಂಶ ಸಂಖ್ಯೆ ಮತ್ತು ಬಹುಶಃ ಒಂದು ಪಾತ್ರ ನೋಡಿ ನಿರೀಕ್ಷೆ ಹೊಂದಿದೆ.

286
00:17:09,000 --> 00:17:12,000
ಈ ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆ ಮತ್ತು ನಾವು ನೋಡುತ್ತಾರೆ.

287
00:17:12,000 --> 00:17:15,869
ಮತ್ತು ಈ ಸಂಕೇತವು ಈಗ ವಿಷಯವನ್ನು ನೆನಪಿಗೆ ತರುತ್ತದೆ ಎಂದು ತಿರುಗುತ್ತದೆ ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವ ಪ್ರಾರಂಭವಾಯಿತು

288
00:17:15,869 --> 00:17:17,619
ಕೇವಲ ಒಂದು ವಾರದ ಹಿಂದೆ.

289
00:17:17,619 --> 00:17:21,740
ಏನು & n ಮತ್ತು & ಸಿ ಇಲ್ಲಿ ನಮಗೆ ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] N ವಿಳಾಸ ಮತ್ತು ಸಿ ವಿಳಾಸ.

290
00:17:21,740 --> 00:17:25,400
ಹೌದು. ನನಗೆ ಸಿ ಆಫ್ n ಮತ್ತು ವಿಳಾಸ ವಿಳಾಸಕ್ಕೆ ನೀಡುವ ನ. ಏಕೆ ಮುಖ್ಯ?

291
00:17:25,400 --> 00:17:30,220
ನೀವು ಸಿ ಕಾರ್ಯಗಳನ್ನು ಜೊತೆಗೆ, ನೀವು ಯಾವಾಗಲೂ ಎಲ್ಲಾ ಒಂದು ಮೌಲ್ಯ ಅಥವಾ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಮರಳಬಹುದು ತಿಳಿದಿದೆ.

292
00:17:30,220 --> 00:17:34,530
ನೀವು ಒಂದು int, ಸ್ಟ್ರಿಂಗ್, ಒಂದು ಫ್ಲೋಟ್, ಒಂದು ಚಾರ್, ಏನೇ, ಅಥವಾ ನೀವು ಅನೂರ್ಜಿತ ಮರಳಬಹುದು, ಮರಳಬಹುದು

293
00:17:34,530 --> 00:17:38,030
ಆದರೆ ನೀವು ಮಾತ್ರ ಗರಿಷ್ಠ ಒಂದು ವಿಷಯ ಮರಳಬಹುದು.

294
00:17:38,030 --> 00:17:42,760
ಆದರೆ ಇಲ್ಲಿ ನಾವು sscanf ಬಹುಶಃ ಒಂದು int, ಒಂದು ದಶಮಾಂಶ ಸಂಖ್ಯೆ, ನನಗೆ ಮರಳಿ ಬಯಸುವ

295
00:17:42,760 --> 00:17:46,220
ಮತ್ತು ಒಂದು ಅಕ್ಷರ, ಮತ್ತು ನಾನು ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಏಕೆ ಚಾರ್ ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

296
00:17:46,220 --> 00:17:51,460
ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ sscanf ಎರಡು ವಿಷಯಗಳನ್ನು ಮರಳಲು ಬಯಸುವ, ಆದರೆ ಸಿ ಕೇವಲ ಆಗುವುದಿಲ್ಲ

297
00:17:51,460 --> 00:17:55,200
ನೀವು ಎರಡು ವಿಳಾಸಗಳನ್ನು ಸಾಗುವ ಆ ಕೆಲಸ ಮಾಡಬಹುದು

298
00:17:55,200 --> 00:17:57,370
ತಕ್ಷಣ ನೀವು ಕಾರ್ಯ ಎರಡು ವಿಳಾಸಗಳನ್ನು ಹ್ಯಾಂಡ್ ಏಕೆಂದರೆ,

299
00:17:57,370 --> 00:18:00,470
ಆ ಕಾರ್ಯ ಅವರೊಂದಿಗೆ ಏನು ಮಾಡಬಹುದು? >> [ವಿದ್ಯಾರ್ಥಿ] ಆ ವಿಳಾಸಗಳನ್ನು ಬರೆಯಿರಿ.

300
00:18:00,470 --> 00:18:02,010
ಇದು ಆ ವಿಳಾಸಗಳನ್ನು ಬರೆಯಬಹುದು.

301
00:18:02,010 --> 00:18:05,770
ನೀವು ಸ್ಟಾರ್ ಕಾರ್ಯಾಚರಣೆ ಬಳಸಲು ಮತ್ತು ಆ ವಿಳಾಸಗಳನ್ನು ಪ್ರತಿಯೊಂದು ಇಲ್ಲಿ ಹೋಗಬಹುದು.

302
00:18:05,770 --> 00:18:11,260
ಇದು ಚರಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಿರುವುದಕ್ಕಾಗಿ ರೀತಿಯ ಈ ಹಿಂದಿನ ಬಾಗಿಲಿನ ಯಾಂತ್ರಿಕ ಆದರೆ ಬಹಳ ಸಾಮಾನ್ಯವಾಗಿದೆ

303
00:18:11,260 --> 00:18:14,870
ಈ ಪ್ರಕರಣದಲ್ಲಿ, ಎರಡು - ಕೇವಲ ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಹೆಚ್ಚು.

304
00:18:14,870 --> 00:18:21,340
ಈಗ ನಾನು == 1 ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಮತ್ತು ನಂತರ, ವಾಸ್ತವವಾಗಿ, ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ಇದ್ದಲ್ಲಿ N ಹಿಂದಿರುಗಿದ ನಾನು ಗಮನಿಸಿ.

305
00:18:21,340 --> 00:18:26,170
ಆದ್ದರಿಂದ ಇಂದಿನ ವಿಶೇಷವೇನು? ತಾಂತ್ರಿಕವಾಗಿ, ನಾವು ನಿಜವಾಗಿಯೂ GetInt ನಡೆಯುತ್ತಿಲ್ಲ ಬಯಸುವ ಎಲ್ಲಾ ಇದು.

306
00:18:26,170 --> 00:18:30,740
ಉಲ್ಲೇಖ-ಕೊಡುವುದು 123 - ನಾವು ಮಾತನಾಡಲು, ಪಾರ್ಸ್ ಬಯಸುವ, ನಾವು ಸ್ಟ್ರಿಂಗ್ ಓದಲು ಬಯಸುವ -

307
00:18:30,740 --> 00:18:34,560
ಮತ್ತು ನಾವು ಮಾಡಲು sscanf ಹೇಳುವ ಏನನ್ನು ಅಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆ, ಇಲ್ಲ ತೋರುತ್ತಿದೆ ವೇಳೆ

308
00:18:34,560 --> 00:18:38,190
ಈ ವೇರಿಯಬಲ್ N ನನಗೆ - 123 - ಆ ಸಂಖ್ಯೆ ಹಾಕಲಾಗುತ್ತದೆ.

309
00:18:38,190 --> 00:18:42,090
ಆದ್ದರಿಂದ ನಾನು ವಾಸ್ತವವಾಗಿ ಇದು ಹೊಂದಿದೆ?

310
00:18:42,090 --> 00:18:48,220
ನೀವು ಇಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಸಿಗುತ್ತವೆ ಹೇಳುವ sscanf ಪಾತ್ರ ಏನು?

311
00:18:48,220 --> 00:18:53,470
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಒಂದು ದಶಮಾಂಶ ಬಿಂದುವಿನ ವಾಸ್ತವವಾಗಿ ಸಹಾಯಕವಾಗಿತ್ತು.

312
00:18:53,470 --> 00:18:56,330
ಒಂದು ಕ್ಷಣ ಭಾವಿಸಿದ್ದರು ನಿಲುವನ್ನು ಲೆಟ್. ಬೇರೆ ಏನು?

313
00:18:56,330 --> 00:18:59,270
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಆಗಿರಬಹುದು. >> ಉತ್ತಮ ಆಲೋಚನೆ. ಇದು ಶೂನ್ಯ ಪಾತ್ರ ಆಗಿರಬಹುದು.

314
00:18:59,270 --> 00:19:01,660
ಈ ಪ್ರಕರಣದಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಅಲ್ಲ. ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. ಅಥವಾ ನನ್ನನ್ನು ಮತ್ತಷ್ಟು ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ ಅವಕಾಶ.

316
00:19:04,340 --> 00:19:06,640
ಅಲ್ಲಿ% ಸಿ ಕೇವಲ ದೋಷ ಪರಿಶೀಲನೆಗಾಗಿ ಹೊಂದಿದೆ.

317
00:19:06,640 --> 00:19:09,300
ನಾವು, ಸಂಖ್ಯೆ ನಂತರ ಅಕ್ಷರ ಇರುವಂತೆ ಬಯಸುವುದಿಲ್ಲ

318
00:19:09,300 --> 00:19:11,870
ಆದರೆ ಏನು ಈ ನನಗೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ ಕೆಳಗಿನ ಹೊಂದಿದೆ.

319
00:19:11,870 --> 00:19:18,210
ಆ sscanf, ಇಲ್ಲಿ ಈ ಉದಾಹರಣೆಯಲ್ಲಿ n ಮತ್ತು ಸಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಜೊತೆಗೆ, ತಿರುಗಿದರೆ

320
00:19:18,210 --> 00:19:24,890
ಇದು ಅಸ್ಥಿರ ಸಂಖ್ಯೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಹೊಂದಿದೆ ಏನು ಇದು ಸೈನ್ ಮೌಲ್ಯಗಳನ್ನು ಪುಟ್

321
00:19:24,890 --> 00:19:30,260
ನೀವು ಕೇವಲ 123 ಟೈಪ್ ಆದ್ದರಿಂದ, ನಂತರ ಕೇವಲ% d, ಹೊಂದಿಸಲು ಹೋಗುತ್ತದೆ

322
00:19:30,260 --> 00:19:33,880
ಮತ್ತು ಕೇವಲ N, 123 ನಂತಹ ಮೌಲ್ಯದೊಂದಿಗೆ ಸಂಗ್ರಹವಾಗಿರುವ ಮುಟ್ಟುತ್ತದೆ

323
00:19:33,880 --> 00:19:35,640
ಮತ್ತು ಏನೂ ಸಿ ಇರಿಸಲಾಯಿತು ಮುಟ್ಟುತ್ತದೆ.

324
00:19:35,640 --> 00:19:37,620
ಸಿ ಆದ್ದರಿಂದ ಮಾತನಾಡಲು, ಒಂದು ಕಸದ ಮೌಲ್ಯ ಉಳಿಯುತ್ತದೆ -

325
00:19:37,620 --> 00:19:40,730
ಕಸ ಏಕೆಂದರೆ ಅದು ಕೆಲವು ಮೌಲ್ಯಕ್ಕೆ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಎಲ್ಲೂ.

326
00:19:40,730 --> 00:19:45,520
ನಾನು, ಆ ಪಾಯಿಂಟರ್ಗಳ 1 ಜನಸಂಖ್ಯೆ ಏಕೆಂದರೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ, sscanf 1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ

327
00:19:45,520 --> 00:19:50,190
ನಾನು ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಲೈನ್ ಮುಕ್ತಗೊಳಿಸಲು ಆದ್ದರಿಂದ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಇಂಟ್ ಹೊಂದಿವೆ

328
00:19:50,190 --> 00:19:54,000
ಆ GetString ವಾಸ್ತವವಾಗಿ ಹಂಚಿಕೆ, ಮತ್ತು ನಂತರ ನಾನು, N ಹಿಂತಿರುಗಿ

329
00:19:54,000 --> 00:19:58,500
ಹೇಳಿಕೆ ಬರುತ್ತದೆ ಮರುಪ್ರಯತ್ನಿಸಿ ಅಲ್ಲಿ ನೀವು ಎಂದಾದರೂ ಯೋಚಿಸಿದ್ದೀರಾ ಬೇರೆ ಅದನ್ನು ಇಲ್ಲಿಯೇ ಬರುತ್ತದೆ.

330
00:19:58,500 --> 00:20:04,390
ಹಾಗಾಗಿ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ನಾನು 123foo ಟೈಪ್ - ಪಠ್ಯದ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮ -

331
00:20:04,390 --> 00:20:08,490
sscanf ಸಂಖ್ಯೆ, ಸಂಖ್ಯೆ, ಸಂಖ್ಯೆ, F, ನೋಡಲು ಹೋಗುತ್ತದೆ

332
00:20:08,490 --> 00:20:16,410
ಮತ್ತು N ರಲ್ಲಿ 123 ಹಾಕಲು ವಿಶೇಷವೇನು ಇದು ಸಿ ಎಫ್ ಪುಟ್ ಮತ್ತು ನಂತರ 2 ಮರಳಲು ವಿಶೇಷವೇನು.

333
00:20:16,410 --> 00:20:20,640
ಆದ್ದರಿಂದ ನಾವು sscanf ವರ್ತನೆಯ, ಸರಳ ರೀತಿಯಲ್ಲಿ ಮೂಲ ವ್ಯಾಖ್ಯಾನ ಬಳಸಿಕೊಂಡು ಹೊಂದಿವೆ -

334
00:20:20,640 --> 00:20:23,900
ಹಾಗೆಯೇ, ಮೊದಲ ನೋಟದಲ್ಲಿ ಆದರೆ ದಿನದ ಸರಳವಾದ ಯಾಂತ್ರಿಕ ಕೊನೆಯಲ್ಲಿ ಸಂಕೀರ್ಣ -

335
00:20:23,900 --> 00:20:28,320
ಹೀಗೆ ಒಂದು ಇಂಟ್ ಇರುತ್ತದೆ ಮತ್ತು ಹಾಗಾಗಿ, ಎಂದು ನಾನು ಕಂಡು ಒಂದೇ ವಸ್ತು?

336
00:20:28,320 --> 00:20:29,860
ಮತ್ತು ಇಲ್ಲಿ ಜಾಗಗಳನ್ನು ಉದ್ದೇಶಪೂರ್ವಕ ಹೊಂದಿದೆ.

337
00:20:29,860 --> 00:20:34,000
ನೀವು sscanf ದಾಖಲೆಯನ್ನು ಓದಲು, ನೀವು ಜಾಗಗಳನ್ನು ತುಂಡು ಸೇರಿವೆ ವೇಳೆ ಸೂಚಿಸುತ್ತದೆ

338
00:20:34,000 --> 00:20:38,810
ಆರಂಭದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ, sscanf ಕೂಡ ಯಾವುದೇ ಕಾರಣದಿಂದಾಗಿ, ಬಳಕೆದಾರ ಅನುಮತಿಸುತ್ತದೆ

339
00:20:38,810 --> 00:20:41,860
ಸ್ಪೇಸ್ ಬಾರ್ 123 ಹೊಡೆಯಲು ಮತ್ತು ನ್ಯಾಯಸಮ್ಮತ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

340
00:20:41,860 --> 00:20:44,150
ಅವರು ಸ್ಪೇಸ್ ಬಾರ್ ಹೊಡೆಯಲು ಕೇವಲ ನಿಮ್ಮ ಬಳಕೆದಾರ ನಲ್ಲಿ ಕೂಗಿ ಆಗುವುದಿಲ್ಲ

341
00:20:44,150 --> 00:20:48,640
ಆರಂಭದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ, ಇದು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಕೇವಲ ಸ್ವಲ್ಪ ಹೆಚ್ಚು.

342
00:20:48,640 --> 00:20:52,300
>> ನಂತರ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು GetInt ಮೇಲೆ? ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಕೇವಲ ಒಂದು ಚಾರ್ ಇರಿಸಲಾಯಿತು ಏನಾಗುತ್ತದೆ?

343
00:20:52,300 --> 00:20:54,030
ಪ್ರಶ್ನೆ ಉತ್ತಮ.

344
00:20:54,030 --> 00:20:59,890
ನೀವು ಕೇವಲ ಎಫ್ ನಂತಹ ಚಾರ್ ಬೆರಳಚ್ಚಿಸಿದ ಮತ್ತು ಇದುವರೆಗೆ 123 ಟೈಪ್ ಇಲ್ಲದೆ ನಮೂದಿಸಿ ಹಿಟ್ ವೇಳೆ?

345
00:20:59,890 --> 00:21:02,420
ನೀವು ಕೋಡ್ ಈ ಸಾಲಿನ ವರ್ತನೆಯನ್ನು ನಂತರ ಎಂಬುದನ್ನು ತಿಳಿದಿರುವಿರಿ?

346
00:21:02,420 --> 00:21:04,730
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

347
00:21:04,730 --> 00:21:08,790
ಆ ಸಂದರ್ಭದಲ್ಲಿ, N ಅಥವಾ ಸಿ ತುಂಬಲು ಹಿಂದಿರುಗಬಹುದೆಂದು ಏಕೆಂದರೆ ಹೌದು, ಆದ್ದರಿಂದ sscanf ಅದೂ ಒಳಗೊಳ್ಳಬಹುದಾಗಿದೆ.

348
00:21:08,790 --> 00:21:15,310
ಇದು ಪ್ರಕರಣದಲ್ಲಿ ಇದರಲ್ಲಿ ನಾನು ಆ ಸನ್ನಿವೇಶದಲ್ಲಿ ಹಿಡಿಯುತ್ತಿರುವ ನಾನು ಬದಲು, 0 ಮರಳಲು ವಿಶೇಷವೇನು

349
00:21:15,310 --> 00:21:18,750
ನಾನು ಬಯಸುವ ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯ 1 ಕಾರಣ.

350
00:21:18,750 --> 00:21:22,000
ನಾನು ಕೇವಲ ಒಂದು ಬಯಸುವ ಮತ್ತು ಕೇವಲ ಒಂದೇ ಒಂದು ಕೆಲಸವನ್ನು ಮುಚ್ಚಬೇಕಾಗುತ್ತದೆ. ಪ್ರಶ್ನೆ ಉತ್ತಮ.

351
00:21:22,000 --> 00:21:24,290
>> ಇತರೆ? ಎಲ್ಲಾ ಸರಿ.

352
00:21:24,290 --> 00:21:26,250
>> ಇಲ್ಲಿ ಎಲ್ಲಾ ಚಟುವಟಿಕೆಗಳಿಗೆ ಮೂಲಕ ನಾವು ಬೇಡ,

353
00:21:26,250 --> 00:21:29,500
ಆದರೆ ಉಳಿದ ಆಸಕ್ತಿ ಬಹುಶಃ ತೋರುತ್ತದೆ ಒಂದು GetString ಆಗಿದೆ

354
00:21:29,500 --> 00:21:32,790
ಇದು GetLongLong, GetFloat, GetInt, GetDouble ಎಂದು ತಿರುಗುತ್ತದೆ ಏಕೆಂದರೆ

355
00:21:32,790 --> 00:21:36,260
ಎಲ್ಲಾ ಓಡ GetString ತಮ್ಮ ಕಾರ್ಯವನ್ನು ಸಾಕಷ್ಟು.

356
00:21:36,260 --> 00:21:39,750
ಆದ್ದರಿಂದ ಅವನು ಇಲ್ಲಿ ಜಾರಿಗೆ ಇದೆ ಹೇಗೆ ಅವಲೋಕಿಸೋಣ.

357
00:21:39,750 --> 00:21:43,630
ಈ ಒಂದು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಕಾಣುತ್ತದೆ, ಆದರೆ ಅದೇ ಮೂಲಭೂತ ಬಳಸುತ್ತದೆ

358
00:21:43,630 --> 00:21:45,670
ನಾವು ಕಳೆದ ವಾರ ಬಗ್ಗೆ ಆರಂಭಿಸಿದರು.

359
00:21:45,670 --> 00:21:49,490
GetString ರಲ್ಲಿ, ಇದು ಅಪ್ ಇಲ್ಲಿ ಅನೂರ್ಜಿತ ಪ್ರಕಾರ ಯಾವುದೇ ವಾದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

360
00:21:49,490 --> 00:21:53,730
ಮತ್ತು ಇದನ್ನು ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಬಫರ್ ಎಂಬ ವಾಕ್ಯವನ್ನು ಘೋಷಿಸಿ ನಾನು, ಸ್ಟ್ರಿಂಗ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

361
00:21:53,730 --> 00:21:56,270
ನಾನು ಎಂದು ಇನ್ನೂ ಬಳಸಬಹುದಾಗಿದೆ ವಿಶೇಷವೇನು ಏನು ಗೊತ್ತಿಲ್ಲ, ಆದರೆ ನಾವು ನೋಡುತ್ತಾರೆ.

362
00:21:56,270 --> 00:21:58,390
ಸಾಮರ್ಥ್ಯ ಡೀಫಾಲ್ಟ್ 0 ಮೂಲಕ ತೋರುತ್ತಿದೆ.

363
00:21:58,390 --> 00:22:01,350
ಹೆಚ್ಚು ಖಚಿತವಾಗಿ ಅಲ್ಲಿ ಈ N ಇನ್ನೂ ಬಳಸಲಾಗುತ್ತದೆ ಹೋಗುವ ಎಂಬುದನ್ನು ಖಚಿತವಾಗಿ ಅಲ್ಲದ ಹೋಗುತ್ತದೆ,

364
00:22:01,350 --> 00:22:03,590
ಆದರೆ ಈಗ ಅದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಸಕ್ತಿಕರ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ.

365
00:22:03,590 --> 00:22:06,520
ಲೈನ್ 243 ರಲ್ಲಿ, ನಾವು ಒಂದು int, ಸಿ ಘೋಷಿಸಿದ.

366
00:22:06,520 --> 00:22:08,800
ಈ ಒಂದು ಸ್ಟುಪಿಡ್ ವಿವರ ರೀತಿಯ ಹೊಂದಿದೆ.

367
00:22:08,800 --> 00:22:15,820
ಎ ಚಾರ್ 8 ಬಿಟ್ಗಳು, ಮತ್ತು 8 ಬಿಟ್ಗಳು ಎಷ್ಟು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು? >> [ವಿದ್ಯಾರ್ಥಿ] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
ನೀವು ಇದರಲ್ಲಿ 256 ವಿವಿಧ ASCII ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿವೆ ನೀವು ಸಮಸ್ಯೆ

369
00:22:20,730 --> 00:22:23,340
ನೀವು ಭಾವಿಸಿದರೆ - ಮತ್ತು ಈ ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಏನೋ ಅಲ್ಲ.

370
00:22:23,340 --> 00:22:25,710
ಆ ದೊಡ್ಡ ASCII ಪಟ್ಟಿಯಲ್ಲಿ ಮರಳಿ ಭಾವಿಸುತ್ತೇನೆ ಆದರೆ ನಾವು ವಾರಗಳ ಹಿಂದೆ ಹೊಂದಿದ್ದ,

371
00:22:25,710 --> 00:22:30,600
128 ಅಥವಾ 256 ASCII ಅಕ್ಷರಗಳನ್ನು ಆ ಸಂದರ್ಭದಲ್ಲಿ ಇರಲಿಲ್ಲ.

372
00:22:30,600 --> 00:22:32,940
ನಾವು 0 ಸೆ ಮತ್ತು 1 ಅನ್ನು ಎಲ್ಲಾ ವಿನ್ಯಾಸಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.

373
00:22:32,940 --> 00:22:36,210
ನೀವು ದೋಷ ಪತ್ತೆ ಮಾಡಲು ಬಯಸಿದರೆ ಒಂದು ಸಮಸ್ಯೆ

374
00:22:36,210 --> 00:22:40,190
ನೀವು ಈಗಾಗಲೇ ನಿಮ್ಮ ಪಾತ್ರಗಳಿಗೆ 256 ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಏಕೆಂದರೆ,

375
00:22:40,190 --> 00:22:43,050
ಈಗ ನೀವು ಹೇಳುವ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಏಕೆಂದರೆ ನೀವು ನಿಜವಾಗಿಯೂ, ಮುಂದೆ ಯೋಜನೆ ಇಲ್ಲ

376
00:22:43,050 --> 00:22:46,270
ಇದು ಅಸಲಿ ಅಕ್ಷರವಾಗಿದೆ, ಈ ಕೆಲವು ತಪ್ಪಾದ ಸಂದೇಶ.

377
00:22:46,270 --> 00:22:50,270
ಹಾಗಾಗಿ ವಿಶ್ವದ ಮಾಡುತ್ತದೆ ಮುಂದಿನ ದೊಡ್ಡ ಮೌಲ್ಯ, ಒಂದು int ಸ್ವಲ್ಪ, ಬಳಕೆಗೆ

378
00:22:50,270 --> 00:22:54,720
ನೀವು 4 ಶತಕೋಟಿ ಸಾಧ್ಯವಿರುವ ಮೌಲ್ಯಗಳನ್ನು, ಬಿಟ್ಸ್, 32 ಒಂದು ಕ್ರೇಜಿ ಸಂಖ್ಯೆಯ ಆದ್ದರಿಂದ

379
00:22:54,720 --> 00:22:58,860
ನೀವು ಸುಮ್ಮನೆ, ಮೂಲಭೂತವಾಗಿ 257 ಅವುಗಳಲ್ಲಿ ಬಳಸಿಕೊಂಡು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಇದರಿಂದ

380
00:22:58,860 --> 00:23:01,720
1 ಇದು ಒಂದು ದೋಷ ಕೆಲವು ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿದೆ.

381
00:23:01,720 --> 00:23:03,120
>> ಇದರಿಂದ ಹೇಗೆ ಈ ಕೆಲಸಗಳನ್ನು ನೋಡೋಣ.

382
00:23:03,120 --> 00:23:07,760
ಲೈನ್ 246 ರಲ್ಲಿ, ನಾನು, fgetc ಕರೆ ಇದೆ ಎಂದು ಈ ಸಂದರ್ಭದಲ್ಲಿ ದೊಡ್ಡ ಲೂಪ್ ಹೊಂದಿವೆ

383
00:23:07,760 --> 00:23:11,090
ಎಫ್ ಅರ್ಥ ಕಡತ, ಆದ್ದರಿಂದ getc, ತದನಂತರ stdin.

384
00:23:11,090 --> 00:23:15,520
ಇದು ಕೇವಲ ಕೀಬೋರ್ಡ್ ಸೂಚನೆಗಳನ್ನು ಓದಿ ಹೇಳುವ ಹೆಚ್ಚು ನಿಖರ ದಾರಿ ಔಟ್ ತಿರುಗುತ್ತದೆ.

385
00:23:15,520 --> 00:23:19,300
ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸಾಧನವಾಗಿ ಕೀಬೋರ್ಡ್, ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್, ಪರದೆಯ ಅರ್ಥ

386
00:23:19,300 --> 00:23:23,310
ಮತ್ತು ನಾವು pset4 ರಲ್ಲಿ ನೋಡುತ್ತಾರೆ ಇದು ಸಾಮಾನ್ಯ ದೋಷ, ಪರದೆಯ ಅರ್ಥ

387
00:23:23,310 --> 00:23:27,490
ಆದರೆ ಇದು ನಿಜವಾದ ಔಟ್ಪುಟ್ ಪರದೆ ವಿಶೇಷ ಭಾಗವನ್ನು ಒಟ್ಟುಗೂಡಿಸಿ ದೊರೆಯದಿದ್ದಲ್ಲಿ ಆದ್ದರಿಂದ

388
00:23:27,490 --> 00:23:30,750
ನೀವು ಮುದ್ರಿಸಬೇಕೆಂದು ಉದ್ದೇಶ ಎಂದು. ಭವಿಷ್ಯದಲ್ಲಿ ಆ ಆದರೆ.

389
00:23:30,750 --> 00:23:34,440
ಆದ್ದರಿಂದ fgetc ಕೇವಲ ಕೀಬೋರ್ಡ್ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು ಮತ್ತು ಅಲ್ಲಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ಅರ್ಥ?

390
00:23:34,440 --> 00:23:37,350
ಸಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಿ.

391
00:23:37,350 --> 00:23:41,360
ನಂತರ ಪರಿಶೀಲಿಸಿ - ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲಿ ಕೆಲವು ಬೂಲಿಯನ್ ಸಂಯೋಗಗಳು ಬಳಸಿಕೊಂಡು ನಾನು -

392
00:23:41,360 --> 00:23:46,000
ಇದು ಸಮಾನ ಮಾಡುವುದಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸಿ - \ N, ಆದ್ದರಿಂದ ಬಳಕೆದಾರರು ನಮೂದಿಸಿ ಬಾರಿಸಿದ್ದಾರೆ, ನಾವು ಆ ಸಮಯದಲ್ಲಿ ನಿಲ್ಲಿಸಲು ಬಯಸುವ,

393
00:23:46,000 --> 00:23:49,850
ಲೂಪ್ ಅಂತ್ಯಕ್ಕೆ - ಮತ್ತು ನಾವು ವಿಶೇಷ ಸ್ಥಿರ EOF ಪರಿಶೀಲಿಸಲು ಬಯಸುವ,

394
00:23:49,850 --> 00:23:53,610
ನಿಮಗೆ ಅಥವಾ ಊಹೆ ಅದನ್ನು ಯಾವ ಇದು ಉದ್ಧೇಶವೇನು? ಕಡತದ >> [ವಿದ್ಯಾರ್ಥಿ] ಎಂಡ್. ಕಡತದ >> ಎಂಡ್.

395
00:23:53,610 --> 00:23:56,560
ಈ ರೀತಿಯ ಅಸಂಬದ್ಧ ಏಕೆಂದರೆ ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಭಾವಿಸುತ್ತೇನೆ ವೇಳೆ,

396
00:23:56,560 --> 00:23:58,870
ಈ ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಕಡತ, ನಿಜವಾಗಿಯೂ ಇಲ್ಲ

397
00:23:58,870 --> 00:24:01,150
ಆದರೆ ಕೇವಲ ಬಳಸಲಾಗುತ್ತದೆ ಜೆನೆರಿಕ್ ಪದದ ವಿಂಗಡಿಸಲು ಇದೆ

398
00:24:01,150 --> 00:24:04,220
ಬೇರೆ ಯಾವುದೂ ಮಾನವನ ಬೆರಳುಗಳು ಬರುವ ಇದೆ.

399
00:24:04,220 --> 00:24:06,460
EOF - ಕಡತದ ಕೊನೆಯಲ್ಲಿ.

400
00:24:06,460 --> 00:24:09,920
ನೀವು ಎಂದಾದರೂ ನಿಮ್ಮ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಕಂಟ್ರೋಲ್ ಡಿ ಹೊಡೆಯಲು ನೀವು ಒಂದು ಪಕ್ಕಕ್ಕೆ, ನೀವು ಇನ್ನೂ ಹೊಂದಿದೆ ಎಂದು ಮಾಹಿತಿ -

401
00:24:09,920 --> 00:24:15,230
ನೀವು ಕಂಟ್ರೋಲ್ ಸಿ ಹಿಟ್ ಮಾಡಿದ - ಕಂಟ್ರೋಲ್ ಡಿ EOF ಎಂದು ಈ ವಿಶೇಷ ಸ್ಥಿರ ಕಳುಹಿಸುತ್ತದೆ.

402
00:24:15,230 --> 00:24:19,850
ಈಗ ನಾವು ಕೆಲವು ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಹೊಂದಿರುತ್ತವೆ.

403
00:24:19,850 --> 00:24:23,440
>> ಆದ್ದರಿಂದ (n + 1> ಸಾಮರ್ಥ್ಯ). ಈಗ ನಾನು N ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

404
00:24:23,440 --> 00:24:26,100
ಎನ್ ಕೇವಲ ಎಷ್ಟು ಬೈಟ್ಗಳು, ಬಫರ್ ಪ್ರಸ್ತುತ ಇದೆ

405
00:24:26,100 --> 00:24:28,620
ನೀವು ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರ ನಿರ್ಮಿಸುವ ನೀವು ಸ್ಟ್ರಿಂಗ್.

406
00:24:28,620 --> 00:24:33,450
ನೀವು ಬಫರ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುವ ಹೆಚ್ಚು ನಿಮ್ಮ ಬಫರ್ ಹೆಚ್ಚು ಪಾತ್ರಗಳು ಹೊಂದಿದ್ದರೆ,

407
00:24:33,450 --> 00:24:37,410
ಅಂತರ್ಬೋಧೆಯಿಂದ ನಾವು ಏನನ್ನು ಮಾಡಬೇಕು ಹೆಚ್ಚು ಸಾಮರ್ಥ್ಯವನ್ನು ನಿಯೋಜಿಸಿ ಇದೆ.

408
00:24:37,410 --> 00:24:43,330
ಹಾಗಾಗಿ ಇಲ್ಲಿ ಅಂಕಗಣಿತದ ಕೆಲವು ಮೇಲೆ ಕೆನೆರಹಿತ ಮತ್ತು ಇಲ್ಲಿ ಮಾತ್ರ ಈ ಕಾರ್ಯವನ್ನು ಗಮನ ಪಡೆಯಲಿದ್ದೇನೆ.

409
00:24:43,330 --> 00:24:46,070
ನೀವು malloc ಏನು ತಿಳಿದಿರುವ ಅಥವಾ ಕನಿಷ್ಠ ಸಾಮಾನ್ಯವಾಗಿ ಚಿರಪರಿಚಿತವಾಗಿದೆ.

410
00:24:46,070 --> 00:24:48,970
Realloc ಏನು ಒಂದು ಊಹೆ ತೆಗೆದುಕೊಳ್ಳಿ. >> [ವಿದ್ಯಾರ್ಥಿ] ಮೆಮೊರಿ ಸೇರಿಸುತ್ತದೆ.

411
00:24:48,970 --> 00:24:52,920
ಇದು ಸಾಕಷ್ಟು ಸ್ಮೃತಿಯಲ್ಲಿ ಅಲ್ಲ. ಇದು ಈ ಕೆಳಗಿನಂತೆ ಮೆಮೊರಿ reallocates.

412
00:24:52,920 --> 00:24:57,220
ಆ ಮೆಮೊರಿ ಹೆಚ್ಚು ನೀಡಲು ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ಕೊಠಡಿ ಇನ್ನೂ ವೇಳೆ

413
00:24:57,220 --> 00:25:00,000
ಇದು ಮೂಲತಃ ನೀವು ನೀಡುತ್ತದೆ, ನಂತರ ನೀವು ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಪಡೆಯುತ್ತೀರಿ.

414
00:25:00,000 --> 00:25:03,460
ಆದ್ದರಿಂದ ನೀವು ಹಿಂದಕ್ಕೆ ಮರಳಿ ಮರಳಿ ಮರಳಿ ಸ್ಟ್ರಿಂಗ್ ಪಾತ್ರಗಳು ಪುಟ್ಟಿಂಗ್ ಇರಿಸಬಹುದು.

415
00:25:03,460 --> 00:25:05,830
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ ಆದರೆ ನೀವು ಬಹಳ ವಿಳಂಬ ಕಾರಣ

416
00:25:05,830 --> 00:25:07,940
ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ಏನೋ ನೆನಪಿಗಾಗಿ plopped ಪಡೆದುಕೊಂಡಿದೆ

417
00:25:07,940 --> 00:25:10,290
ಆದರೆ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಇಲ್ಲಿ ಕೆಳಗೆ ಇತ್ತು, ಆ ಸರಿಯಾಗಿಯೆ.

418
00:25:10,290 --> 00:25:13,100
Realloc, ನೀವು ಎಲ್ಲಾ ಭಾರೀ ತರಬೇತಿ ಮಾಡಲು ಹೋಗುತ್ತದೆ

419
00:25:13,100 --> 00:25:16,750
, ನೀವು ಇದುವರೆಗಿನ ಇಲ್ಲಿಂದ ರಲ್ಲಿ ಓದಿದ ಸ್ಟ್ರಿಂಗ್ ಸರಿಸಲು ಅದು ಅಲ್ಲಿ ಪತನವಾದರೆ,

420
00:25:16,750 --> 00:25:19,460
ತದನಂತರ ಆ ಹಂತದಲ್ಲಿ ಕೆಲವು ಹೆಚ್ಚು ರನ್ವೇ ನೀಡಿ.

421
00:25:19,460 --> 00:25:22,550
>> ಆದ್ದರಿಂದ ಕೈ ಅಲೆಗಳು, ನನಗೆ ಏನು GetString ಮಾಡುವುದರಿಂದ ಎಂದು ಹೇಳಲು ಅವಕಾಶ

422
00:25:22,550 --> 00:25:26,330
ಇದು ಒಂದು ಸಣ್ಣ ಬಫರ್, ಬಹುಶಃ ಒಂದೇ ಪಾತ್ರ, ಜೊತೆಗೆ ಶುರುವಾಗುತ್ತಿದೆ ಇದೆ

423
00:25:26,330 --> 00:25:30,820
ಮತ್ತು ಎರಡು ಪಾತ್ರಗಳು ಬಳಕೆದಾರ ರೀತಿಯ ವೇಳೆ, GetString realloc ಕರೆ ಸೇರುತ್ತದೆ ಮತ್ತು ಹೇಳುತ್ತಾರೆ

424
00:25:30,820 --> 00:25:33,150
ಒಂದು ಪಾತ್ರದ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ; ನನಗೆ ಎರಡು ಪಾತ್ರಗಳು ನೀಡಿ.

425
00:25:33,150 --> 00:25:35,950
ನೀವು ಲೂಪ್ ನ ತರ್ಕ ಓದಲು ನಂತರ ಅದನ್ನು ಹೇಳಲು ವಿಶೇಷವೇನು

426
00:25:35,950 --> 00:25:39,600
3 ಪಾತ್ರಗಳು ಬೆರಳಚ್ಚಿಸಿದ ಬಳಕೆದಾರ;, ಈಗ ಅಲ್ಲ 2 ಆದರೆ 4 ಪಾತ್ರಗಳು ನನಗೆ ನೀಡಿ

427
00:25:39,600 --> 00:25:42,320
ಆಗ ನನಗೆ 16 ಮತ್ತು 32 ನೀಡಿ ನಂತರ, ನನ್ನ 8 ನೀಡಿ.

428
00:25:42,320 --> 00:25:45,000
ನಾನು ಸಾಮರ್ಥ್ಯವನ್ನು ಪ್ರತಿ ಬಾರಿ ದುಪ್ಪಟ್ಟುಗೊಳಿಸುವುದರಿಂದ ನಾನು ವಾಸ್ತವವಾಗಿ

429
00:25:45,000 --> 00:25:48,570
ಬಫರ್ ನಿಧಾನವಾಗಿ ಬೆಳೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ ಅಂದರೆ, ಅದು ಅತೀ ವೇಗದ ಬೆಳೆಯಲು ವಿಶೇಷವೇನು.

430
00:25:48,570 --> 00:25:51,380
ಮತ್ತು ಆ ಪ್ರಯೋಜನವನ್ನು ಇರಬಹುದು?

431
00:25:51,380 --> 00:25:54,600
ನಾನು ಬಫರ್ ಗಾತ್ರದ ಡಬಲ್ ನಾನು

432
00:25:54,600 --> 00:25:58,020
ಬಳಕೆದಾರ ಕೇವಲ ಕೀಬೋರ್ಡ್ ಒಂದು ಹೆಚ್ಚುವರಿ ಪಾತ್ರ ಬೇಕು ಕೂಡ?

433
00:25:58,020 --> 00:26:01,750
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಅದು ಯಾವುದು? >> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಅದರ ಬೆಳವಣಿಗೆ ಹೊಂದಿಲ್ಲ.

434
00:26:01,750 --> 00:26:03,300
ನಿಖರವಾಗಿ. ನೀವು ಅದರ ಬೆಳವಣಿಗೆ ಹೊಂದಿಲ್ಲ.

435
00:26:03,300 --> 00:26:05,510
ಮತ್ತು ಇದು ಕೇವಲ ರೀತಿಯ, ಇಲ್ಲಿ ನಿಮ್ಮ ಪಂತಗಳನ್ನು ನಷ್ಟದ ನೀವು

436
00:26:05,510 --> 00:26:10,850
ಕಲ್ಪನೆಯನ್ನು ನಿಧಾನ ತಳಿಗಿಂತ ಏಕೆಂದರೆ ನೀವು realloc ಸಾಕಷ್ಟು ಕರೆ ಬಯಸುವುದಿಲ್ಲ ಎಂಬುದು.

437
00:26:10,850 --> 00:26:12,910
ನೀವು ಮೆಮೊರಿಗೆ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕೇಳಿ ಯಾವುದೇ ಸಮಯ

438
00:26:12,910 --> 00:26:16,990
ನೀವು ಬೇಗನೆ ಭವಿಷ್ಯದ ಸಮಸ್ಯೆ ಸೆಟ್ ನೋಡುತ್ತಾರೆ ಎಂದು, ಇದು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಒಲವು.

439
00:26:16,990 --> 00:26:20,010
ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಜಾಗವನ್ನು ಹಾಳುಮಾಡುತ್ತಿದೆ ನೀವು ಸಹ, ಆ ಪ್ರಮಾಣವನ್ನು ತಗ್ಗಿಸುತ್ತದೆ,

440
00:26:20,010 --> 00:26:21,900
ಒಳ್ಳೆಯದು ಕಾಣುತ್ತಾರೆ.

441
00:26:21,900 --> 00:26:24,060
>> ಆದರೆ ನಾವು ಇಲ್ಲಿ GetString ಅಂತಿಮ ಭಾಗದ ಮೂಲಕ ಓದಲು -

442
00:26:24,060 --> 00:26:27,950
ಮತ್ತೆ ಇಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಲಿನ ಅರ್ಥ ಇಂದು ಅಷ್ಟು ಪ್ರಮುಖವಲ್ಲ -

443
00:26:27,950 --> 00:26:30,530
ಅಂತಿಮವಾಗಿ ಮತ್ತೆ malloc ಅಪೇಕ್ಷಿಸುವ ಗಮನಕ್ಕೆ

444
00:26:30,530 --> 00:26:33,880
ಇದು ತಂತಿಗೆ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಅದು ಅನೇಕ ಬೈಟ್ಗಳು ಎಂದು ನಿಖರವಾಗಿ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ

445
00:26:33,880 --> 00:26:38,060
ತದನಂತರ ಉಚಿತ ಮಿತಿಮೀರಿದ ದೊಡ್ಡ ಬಫರ್ ಕರೆದು ದೂರ ಎಸೆಯುತ್ತಾನೆ

446
00:26:38,060 --> 00:26:40,080
ಇದು ನಿಜವಾಗಿಯೂ ಹಲವಾರು ಬಾರಿ ದುಪ್ಪಟ್ಟು ಪಡೆದುಕೊಂಡಿದೆ ವೇಳೆ.

447
00:26:40,080 --> 00:26:42,730
ಆದ್ದರಿಂದ ಸಣ್ಣ ರಲ್ಲಿ, ಆ GetString ಎಲ್ಲಾ ಈ ಕೆಲಸ ಮಾಡಲಾಗಿದೆ ಹೇಗೆ.

448
00:26:42,730 --> 00:26:47,060
ಎಲ್ಲಾ ಇದು, ಮತ್ತೆ ಪುನಃ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರ ಓದಲು ಇಲ್ಲ

449
00:26:47,060 --> 00:26:50,750
ಮತ್ತು ಕೆಲವು ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಅಗತ್ಯವಿದೆ ಪ್ರತಿ ಬಾರಿ, ಇದು ಫಾರ್ ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಕೇಳುತ್ತದೆ

450
00:26:50,750 --> 00:26:53,670
realloc ಕರೆದು.

451
00:26:53,670 --> 00:26:57,890
>> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಎಲ್ಲಾ ಸರಿ.

452
00:26:57,890 --> 00:26:59,270
>> ದಾಳಿ.

453
00:26:59,270 --> 00:27:04,060
ಈಗ ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅಥವಾ ಕನಿಷ್ಠ ಪಾಯಿಂಟರ್ಸ್ ಹೆಚ್ಚು ತಿಳಿದಿದೆ

454
00:27:04,060 --> 00:27:06,700
ಇಡೀ ವಿಶ್ವದ ಕುಸಿಯಲು ಆರಂಭಿಸುತ್ತದೆ ಹೇಗೆ ಪರಿಗಣಿಸೋಣ

455
00:27:06,700 --> 00:27:10,030
ನೀವು ತುಂಬಾ ವ್ಯತಿರಿಕ್ತ ಬಳಕೆದಾರರು ರಕ್ಷಿಸಿಕೊಳ್ಳಲು ಇದ್ದರೆ,

456
00:27:10,030 --> 00:27:11,850
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಹ್ಯಾಕ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವ ಜನರು,

457
00:27:11,850 --> 00:27:16,890
ಕೆಲವು ನೋಂದಣಿ ಕೋಡ್ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಿಮ್ಮ ಸಾಫ್ಟ್ವೇರ್ ಕದಿಯಲು ಪ್ರಯತ್ನಿಸುವ ಜನರು

458
00:27:16,890 --> 00:27:19,090
ಇಲ್ಲದಿದ್ದರೆ ಸೈನ್ ಟೈಪ್ ಮಾಡಬೇಕು ಎಂದು

459
00:27:19,090 --> 00:27:22,990
>> ಕೆಳಭಾಗದಲ್ಲಿ ಮುಖ್ಯ ಕ್ರಿಯೆಯಾಗಿ ಹೊಂದಿರುವ ಕೇವಲ ಸಿ ಕೋಡ್ ಇದು, ಇಲ್ಲಿ ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ

460
00:27:22,990 --> 00:27:26,380
ಒಂದು ಫಂಕ್ಷನ್ foo ಕರೆಗಳನ್ನು. ಮತ್ತು ಅದರ foo ಹಾದು ಇದೆ?

461
00:27:26,380 --> 00:27:29,680
[ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ವಾದ. >> [Malan] ಒಂದು ವಾದ.

462
00:27:29,680 --> 00:27:33,450
ಆದ್ದರಿಂದ argv [1], ಇದು ಬಳಕೆದಾರ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಟೈಪಿಸಿದ ಈ ಮೊದಲ ಪದದ ಅರ್ಥ

463
00:27:33,450 --> 00:27:36,360
a.out ಅಥವಾ ಯಾವುದೇ ನಂತರ ಪ್ರೋಗ್ರಾಂ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

464
00:27:36,360 --> 00:27:41,680
ಮೇಲ್ಭಾಗದಲ್ಲಿ foo ಒಂದು ಚಾರ್ * ರಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆದ್ದರಿಂದ. ಆದರೆ ಚಾರ್ * ಕೇವಲ ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಸರಣಿ.

465
00:27:41,680 --> 00:27:43,350
[Malan] ಸರಣಿ, ಹೊಸ ಏನೂ ಇಲ್ಲಿ ಇಲ್ಲ ಆದ್ದರಿಂದ.

466
00:27:43,350 --> 00:27:45,420
ಒಂದು ತಂತುವಿನ ನಿರಂಕುಶವಾಗಿ ಬಾರ್ ಎಂದು ಮಾಡಲಾಗುತ್ತಿದೆ.

467
00:27:45,420 --> 00:27:51,430
ಇಲ್ಲಿ ಈ ಸಾಲಿನಲ್ಲಿ, ಚಾರ್ ಸಿ [12]; ಅರೆ ತಾಂತ್ರಿಕ ಇಂಗ್ಲೀಷ್ ರೀತಿಯ ರಲ್ಲಿ, ಈ ಸಾಲಿನ ಮಾಡುತ್ತಿರುವುದಾದರೂ ಏನು?

468
00:27:51,430 --> 00:27:55,220
ದಿ [ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ಸರಣಿ - ಆಫ್ >> ಅರೇ? >> [ವಿದ್ಯಾರ್ಥಿ] ಪಾತ್ರಗಳು. >> ಪಾತ್ರಗಳು.

469
00:27:55,220 --> 00:27:58,870
ನನಗೆ 12 ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿ. ಆದ್ದರಿಂದ ನಾವು ಈ ಒಂದು ಬಫರ್ ಕರೆ ಇರಬಹುದು.

470
00:27:58,870 --> 00:28:02,920
ಇದು ತಾಂತ್ರಿಕವಾಗಿ ಸಿ ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಬಫರ್ ಕೇವಲ ಜಾಗವನ್ನು ಒಂದು ಗುಂಪೇ ಅರ್ಥ ನ

471
00:28:02,920 --> 00:28:04,800
ನೀವು ಕೆಲವು ಸಂಗತಿಗಳನ್ನು ಸೈನ್ ಆ

472
00:28:04,800 --> 00:28:07,940
ನಂತರ ಕೊನೆಯದಾಗಿ, memcpy ನಾವು ಮೊದಲು ಬಳಸದೆ ಮಾಡಿದ, ಆದರೆ ನೀವು ಬಹುಶಃ ಏನು ಊಹೆ ಮಾಡಬಹುದು.

473
00:28:07,940 --> 00:28:10,480
ಇದು ಮೆಮೊರಿ ನಕಲಿಸುತ್ತದೆ. ಅದು ಏನು ಮಾಡುತ್ತದೆ?

474
00:28:10,480 --> 00:28:19,270
ಇದು ಸ್ಪಷ್ಟವಾಗಿ ಸಿ ಆಗಿ, ತನ್ನ ಇನ್ಪುಟ್, ಬಾರ್ ನಕಲಿಸುತ್ತದೆ ಆದರೆ ಮಾತ್ರ ಪಟ್ಟಿಯ ಉದ್ದ.

475
00:28:19,270 --> 00:28:24,930
ಆದರೆ ಇಲ್ಲಿ ಒಂದು ದೋಷ ಇಲ್ಲ. >> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು sizeof ಪಾತ್ರದ ಅವಶ್ಯಕತೆ. ಸರಿ >>.

476
00:28:24,930 --> 00:28:30,860
ತಾಂತ್ರಿಕವಾಗಿ, ನಾವು ನಿಜವಾಗಿಯೂ strlen ಹಾಗೆ (ಬಾರ್) * sizeof (ಚಾರ್)). ಮಾಡಬೇಕು ಅದು ಸರಿ.

477
00:28:30,860 --> 00:28:33,930
ಆದರೆ ಇಲ್ಲಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರ ಆ that's ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ -

478
00:28:33,930 --> 00:28:35,950
ಸರಿ. ನಂತರ ಎರಡು ದೋಷಗಳು ಇಲ್ಲ.

479
00:28:35,950 --> 00:28:39,160
ಆದ್ದರಿಂದ sizeof (ಚಾರ್));

480
00:28:39,160 --> 00:28:41,290
ಇದನ್ನು ಸ್ವಲ್ಪ ಅಗಲವಾದ ಮಾಡೋಣ.

481
00:28:41,290 --> 00:28:44,910
ಆದ್ದರಿಂದ ಈಗ ಇದು ಒಂದು ದೋಷವನ್ನು, ಇನ್ನೂ? >> [ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

482
00:28:44,910 --> 00:28:46,990
ಏನು ಪರಿಶೀಲಿಸಿ? >> [ವಿದ್ಯಾರ್ಥಿ] ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಪರಿಶೀಲಿಸಿ.

483
00:28:46,990 --> 00:28:50,270
ಕೆಟ್ಟ ಸಂಗತಿಗಳು ಸಂಭವಿಸುತ್ತವೆ ಏಕೆಂದರೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಮಾಡಬೇಕು

484
00:28:50,270 --> 00:28:53,200
ನೀವು ಅಲ್ಲಿಗೆ ಹೋಗುವುದನ್ನು ಅಂತ್ಯಗೊಳಿಸಲು ಏಕೆಂದರೆ ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಯಾವಾಗ

485
00:28:53,200 --> 00:28:57,630
ಮತ್ತು ನೀವು ಎಂದಾದರೂ ನಕ್ಷತ್ರ ಆಯೋಜಕರು ಅದನ್ನು dereferencing ಮೂಲಕ ಶೂನ್ಯ ಹೋಗುವ ಮಾಡಬಾರದು.

486
00:28:57,630 --> 00:29:01,050
ಆದ್ದರಿಂದ ಒಳ್ಳೆಯದು. ಮತ್ತು ನಾವು ಬೇರೆ ಏನು ಮಾಡುತ್ತಿದ್ದಿಯಾ? ತಾರ್ಕಿಕವಾಗಿ, ಒಂದು ನ್ಯೂನತೆಯು ತುಂಬಾ ಇಲ್ಲಿ ಇಲ್ಲ.

487
00:29:01,050 --> 00:29:04,450
[ವಿದ್ಯಾರ್ಥಿ] argc> = 2 ವೇಳೆ ಪರಿಶೀಲಿಸಿ.

488
00:29:04,450 --> 00:29:10,550
Argc> = 2 ವೇಳೆ ಆದ್ದರಿಂದ ಪರಿಶೀಲಿಸಿ. ಸರಿ, ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಮೂರು ದೋಷಗಳು ಇಲ್ಲಿ ಇಲ್ಲ ಆದ್ದರಿಂದ.

489
00:29:10,550 --> 00:29:16,630
ಬಳಕೆದಾರ ವಾಸ್ತವಿಕವಾಗಿ argv ಒಳಗೆ ಏನು ಬೆರಳಚ್ಚಿಸಿದ ನಾವು ಈಗ ಪರೀಕ್ಷಿಸುವ ನೀವು [1]. ಗುಡ್.

490
00:29:16,630 --> 00:29:20,950
ಆದ್ದರಿಂದ ಮೂರನೇ ದೋಷ ಎಂಬುದರ? ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ಸಿ ಸಾಕಷ್ಟು ದೊಡ್ಡ ಇರಬಹುದು.

491
00:29:20,950 --> 00:29:23,320
ಗುಡ್. ನಾವು ಒಂದು ಸನ್ನಿವೇಶದಲ್ಲಿ ಪರಿಶೀಲಿಸಿದ.

492
00:29:23,320 --> 00:29:29,520
ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ ಬಾರ್ ಉದ್ದವನ್ನು ಮೀರುತ್ತದೆ ಹೆಚ್ಚು ಮೆಮೊರಿ ನಕಲಿಸಬೇಡಿ ಪರಿಶೀಲಿಸಿದ.

493
00:29:29,520 --> 00:29:32,510
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ ಬೆರಳಚ್ಚಿಸಿದ ಬಳಕೆದಾರ 10 ಪಾತ್ರಗಳು ಉದ್ದವಾಗಿದೆ,

494
00:29:32,510 --> 00:29:36,020
ಇದು ಕೇವಲ 10 ಅಕ್ಷರಗಳನ್ನು ಕಾಪಿ ಹೇಳುತ್ತಾರೆ. ಮತ್ತು ಸರಿಯಾಗಿಯೆ.

495
00:29:36,020 --> 00:29:39,940
ಆದರೆ ಬಳಕೆದಾರರು 20 ಅಕ್ಷರ ಪದ ನಂತಹ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಪದ ಯಾವ ಟೈಪಿಸಿದ ವೇಳೆ?

496
00:29:39,940 --> 00:29:44,900
ಈ ಯಾವುದನ್ನು ಪಟ್ಟಿಯಿಂದ ಪ್ರತಿಯನ್ನು 20 ಪಾತ್ರಗಳು ಹೇಳುತ್ತಾರೆ?

497
00:29:44,900 --> 00:29:49,750
ಇಲ್ಲದಿದ್ದರೆ ನಮ್ಮ ಬಫರ್ ಎಂದು ಸಿ, ಇದು ನೀವು ಡೇಟಾವನ್ನು ಬರೆದರು ಅರ್ಥ

498
00:29:49,750 --> 00:29:52,540
ನೀವು ಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ 8 ಬೈಟ್ ಸ್ಥಾನಗಳಿಗೆ,

499
00:29:52,540 --> 00:29:54,870
ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ನಿಯೋಜಿತವಾದ ಎಂದಿಗೂ ಆ ಅರ್ಥದಲ್ಲಿ ಅವುಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

500
00:29:54,870 --> 00:30:00,370
ಆದ್ದರಿಂದ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿ ಅಥವಾ ಬಫರ್ ಅತಿಕ್ರಮಣ ದಾಳಿ ಎಂದು ಏನನ್ನು ಹೊಂದಿದೆ.

501
00:30:00,370 --> 00:30:05,580
ಮತ್ತು ಇದು ಅರ್ಥದಲ್ಲಿ ಒಂದು ದಾಳಿ ಎಂದು ವೇಳೆ ಬಳಕೆದಾರ ಅಥವಾ ನಿಮ್ಮ ಕಾರ್ಯವನ್ನು ಕರೆ ಎಂದು ಪ್ರೋಗ್ರಾಂ

502
00:30:05,580 --> 00:30:10,490
ವಾಸ್ತವವಾಗಿ ಮುಂದಿನ ಏನಾಗುತ್ತದೆ, ದುರುದ್ಧೇಶಪೂರಿತವಾಗಿ ಈ ರೀತಿ ಇದೆ ವಾಸ್ತವವಾಗಿ ಸಾಕಷ್ಟು ಕೆಟ್ಟ ಆಗಿರಬಹುದು.

503
00:30:10,490 --> 00:30:12,450
>> ಆದ್ದರಿಂದ ನ ಇಲ್ಲಿ ಈ ಚಿತ್ರವನ್ನು ಅವಲೋಕಿಸೋಣ.

504
00:30:12,450 --> 00:30:16,060
ಈ ಚಿತ್ರವನ್ನು ಮೆಮೊರಿಯ ನಿಮ್ಮ ಸ್ಟಾಕ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

505
00:30:16,060 --> 00:30:19,580
ನೀವು ಒಂದು ಕಾರ್ಯ ಕರೆ ಪ್ರತಿ ಬಾರಿ ನೀವು ಸ್ಟಾಕ್ ಈ ಕಡಿಮೆ ಫ್ರೇಮ್ ಪಡೆಯಲು ಸ್ಮರಿಸುತ್ತಾರೆ

506
00:30:19,580 --> 00:30:21,520
ನಂತರ ಮತ್ತೊಂದು ತದನಂತರ ಮತ್ತೊಂದು ಮತ್ತೊಂದು.

507
00:30:21,520 --> 00:30:24,300
ಮತ್ತು ಇದುವರೆಗಿನ, ನಾವು ಕೇವಲ ರೀತಿಯ ಮಾಡಿದ ಈ ಆಯತಗಳನ್ನು ಮಾಹಿತಿ ಬೇರ್ಪಡಿಸಿದರೆ

508
00:30:24,300 --> 00:30:26,290
ಮಂಡಳಿಯಲ್ಲಿ ಅಥವಾ ಇಲ್ಲಿ ತೆರೆಯಲ್ಲಿ ಒಂದೋ.

509
00:30:26,290 --> 00:30:30,580
ಆದರೆ ನಾವು ನೀವು ಒಂದು ಕಾರ್ಯ foo ​​ಕರೆ ಮಾಡಿದಾಗ ಆ ಆಯತಗಳನ್ನು ಒಂದು ಮೇಲೆ ಜೂಮ್ ವೇಳೆ,

510
00:30:30,580 --> 00:30:35,880
ಇದು ಹೆಚ್ಚು ಎಂದು ಆಯಾತ ಆ ಫ್ರೇಮ್ನ ಸ್ಟಾಕ್ ಒಳಗೆ ಇಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ

511
00:30:35,880 --> 00:30:40,060
ಹೆಚ್ಚು ನಾವು ಸ್ವಾಪ್ ಬಗ್ಗೆ ಮಾಡಲಿಲ್ಲ ಹಾಗೆ ಕೇವಲ X ಮತ್ತು Y ಮತ್ತು ಒಂದು ಮತ್ತು ಬಿ,.

512
00:30:40,060 --> 00:30:44,410
ಇದು ಕಡಿಮೆ ಮಟ್ಟದ ವಿವರಗಳು ರಿಟರ್ನ್ ವಿಳಾಸ ಅವರಲ್ಲಿ ಇಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ.

513
00:30:44,410 --> 00:30:49,550
ಮುಖ್ಯ foo ​​ಕರೆಗಳನ್ನು ಅದು ತಿರುಗಿದರೆ, ಮುಖ್ಯ foo ​​ತಿಳಿಸಲು ಹೊಂದಿದೆ

514
00:30:49,550 --> 00:30:53,520
ಯಾವ ಮುಖ್ಯ ವಿಳಾಸ ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿ ಹೊಂದಿದೆ

515
00:30:53,520 --> 00:30:57,770
ಇಲ್ಲವಾದಲ್ಲಿ, ತಕ್ಷಣ foo ಮಾಹಿತಿ, ಇಲ್ಲಿ ಈ ವಿಷಯದಲ್ಲಿ, ಪಾಲಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ

516
00:30:57,770 --> 00:31:00,830
ಒಮ್ಮೆ, foo ಕೊನೆಯಲ್ಲಿ ಈ ಮುಚ್ಚಿದ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತಲುಪಲು

517
00:31:00,830 --> 00:31:05,310
ಕಾರ್ಯಕ್ರಮದ ನಿಯಂತ್ರಣ ಹೋಗಿ ಹೇಳಲಾಗುವ ಅಲ್ಲಿ ಹೇಗೆ ಬೀಟಿಂಗ್ foo ತಿಳಿದಿದೆಯೇ?

518
00:31:05,310 --> 00:31:08,970
ಆ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ಇಲ್ಲಿ ಈ ಕೆಂಪು ಆಯತ ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

519
00:31:08,970 --> 00:31:12,670
ಈ ಒಂದು ಪಾಯಿಂಟರ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ತಾತ್ಕಾಲಿಕವಾಗಿ ಶೇಖರಿಸಿಡಲು ಕಂಪ್ಯೂಟರ್ ಬಿಟ್ಟಿದ್ದು

520
00:31:12,670 --> 00:31:17,030
ಕರೆಯಲ್ಪಡುವ ಸ್ಟಾಕ್ ಮೇಲೆ ಎಷ್ಟು ಬೇಗ foo ಎಂದು ಮುಖ್ಯ ವಿಳಾಸವನ್ನು ಪಾಲಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ,

521
00:31:17,030 --> 00:31:21,120
ಕಂಪ್ಯೂಟರ್ ಅಲ್ಲಿ ಮತ್ತು ಹಿಂತಿರುಗಿ ಮುಖ್ಯ ಯಾವ ಸಾಲು ತಿಳಿದಿದೆ.

522
00:31:21,120 --> 00:31:23,940
ಉಳಿಸಿದ ಫ್ರೇಮ್ ಪಾಯಿಂಟರ್ ಈ ರೀತಿಯಲ್ಲಿ ಸಂಬಂಧಿಸಿದೆ.

523
00:31:23,940 --> 00:31:26,310
ಇಲ್ಲಿ ಚಾರ್ * ಬಾರ್ ಏನನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ?

524
00:31:26,310 --> 00:31:31,350
ಈಗ ಈ ನೀಲಿ ಭಾಗವನ್ನು ಇಲ್ಲಿ foo ನ ಫ್ರೇಮ್ ಹೊಂದಿದೆ. ಬಾರ್ ಎಂದರೇನು?

525
00:31:31,570 --> 00:31:35,010
ಬಾರ್ ಕೇವಲ foo ಕಾರ್ಯನಿರ್ವಹಿಸಲು ವಾದವು.

526
00:31:35,010 --> 00:31:37,500
ಈಗ ನಾವು ಪರಿಚಿತ ಚಿತ್ರದ ರೀತಿಯ ಹಿಂದೆ ಆರ್.

527
00:31:37,500 --> 00:31:39,850
ತೆರೆಯ ಮೇಲೆ ಹೆಚ್ಚು ವಿಷಯವನ್ನು ಹೆಚ್ಚು ಗೊಂದಲ, ಇಲ್ಲ

528
00:31:39,850 --> 00:31:43,380
ಆದರೆ ಈ ಬೆಳಕಿನ ನೀಲಿ ವಿಭಾಗದಲ್ಲಿ ನಾವು chalkboard ರಚಿಸಿದರು ನಾವು ಏನು

529
00:31:43,380 --> 00:31:45,790
ಸ್ವಾಪ್ ರೀತಿಯ ಫಾರ್. ಆ foo ಗೆ ಚೌಕಟ್ಟನ್ನು ಹೊಂದಿದೆ.

530
00:31:45,790 --> 00:31:51,490
ಮತ್ತು ಇದು ಕೇವಲ ವಿಷಯ ಇದೀಗ ಈ ನಿಯತಾಂಕ, ಇದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದೆ.

531
00:31:51,490 --> 00:31:55,220
ಆದರೆ ಬೇರೆ ಯಾವ ಇಲ್ಲಿ ಈ ಕೋಡ್ ಪ್ರಕಾರ ಸ್ಟಾಕ್ ಇರಬೇಕು?

532
00:31:55,220 --> 00:31:57,760
[ವಿದ್ಯಾರ್ಥಿ] ಚಾರ್ ಸಿ [12]. >> [Malan] ಚಾರ್ ಸಿ [12].

533
00:31:57,760 --> 00:32:02,810
ನಾವು, ಸಿ, ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಮಂಜೂರು ಮೆಮೊರಿಯ 12 ಚೌಕಗಳನ್ನು ನೋಡಿ ಮಾಡಬೇಕು

534
00:32:02,810 --> 00:32:04,970
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ತೆರೆಯ ಮೇಲೆ ಪಡೆದಿವೆ.

535
00:32:04,970 --> 00:32:08,480
ತುದಿಯನ್ನು ಇಲ್ಲ ಸಿ [0] ಈ ಚಿತ್ರದ, ಮತ್ತು ನಂತರ ಲೇಖಕ

536
00:32:08,480 --> 00:32:11,850
ಚೌಕಗಳನ್ನು ಎಲ್ಲಾ ಸೆಳೆಯುವಲ್ಲಿ ತೊಂದರೆಯಾದರೆ, ಆದರೆ 12 ನಿಜಕ್ಕೂ ಇವೆ ಇಲ್ಲ

537
00:32:11,850 --> 00:32:16,590
ಏಕೆಂದರೆ ನೀವು ಕೆಳಗಿನ ಬಲಭಾಗದಲ್ಲಿ ನೋಡಿದರೆ, ಸಿ [11] ನೀವು 0 ರಿಂದ ಎಣಿಕೆ ವೇಳೆ 12 ಇಂತಹ ಬೈಟ್.

538
00:32:16,590 --> 00:32:18,400
ಆದರೆ ಇಲ್ಲಿ ಸಮಸ್ಯೆ.

539
00:32:18,400 --> 00:32:22,390
ಸಿ ಯಾವ ದಿಕ್ಕಿನಲ್ಲಿ ಬೆಳೆಯುತ್ತಿದೆ?

540
00:32:22,390 --> 00:32:27,080
ರೀತಿಯ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಆರಂಭವಾಗಿ ಕೆಳಕ್ಕೆ ಬೆಳೆದರೆ ಕೆಳಕ್ಕೆ ನ.

541
00:32:27,080 --> 00:32:30,110
ನಾವು ಇಲ್ಲಿ ನಾವೇ ಹೆಚ್ಚು ರನ್ವೇ ಬಿಟ್ಟು ಎಂದು ತೋರುತ್ತಿಲ್ಲ.

542
00:32:30,110 --> 00:32:32,090
ನಾವು ರೀತಿಯ, ಒಂದು ಮೂಲೆಯಲ್ಲಿ ನಾವೇ ಬಣ್ಣ ಮಾಡಿದ

543
00:32:32,090 --> 00:32:36,940
ಮತ್ತು ಸಿ [11] ಉಳಿಸಲಾಗಿದೆ ಫ್ರೇಮ್ ಪಾಯಿಂಟರ್ ವಿರುದ್ಧ ಬಲಕ್ಕೆ ಇದು ಬಾರ್ ವಿರುದ್ಧ ಬಲ ಅಪ್,

544
00:32:36,940 --> 00:32:39,960
ಇದು ರಿಟರ್ನ್ ವಿಳಾಸ ವಿರುದ್ಧ ಬಲ ಅಪ್. ಯಾವುದೇ ಅವಕಾಶವಿಲ್ಲ.

545
00:32:39,960 --> 00:32:42,810
ನೀವು ಸ್ಕ್ರೂ ಆದ್ದರಿಂದ ಸೂಚನೆಯ ನಂತರ ಇಲ್ಲಿದೆ

546
00:32:42,810 --> 00:32:46,500
ಮತ್ತು ನೀವು 12 ಬೈಟ್ ಬಫರ್ ಆಗಿ 20 ಬೈಟ್ಗಳು ಓದಲು ಪ್ರಯತ್ನಿಸಿ?

547
00:32:46,500 --> 00:32:50,060
ಅಲ್ಲಿ ಆ 8 ಹೆಚ್ಚುವರಿ ಬೈಟ್ಗಳು ಹೋಗುತ್ತಿದ್ದೇವೆ? >> [ವಿದ್ಯಾರ್ಥಿ] ಇನ್ಸೈಡ್ -

548
00:32:50,060 --> 00:32:53,200
ಎಲ್ಲವೂ ಒಳಗೆ, ಇದು ಕೆಲವು ಪ್ರಮುಖ ಸೂಪರ್ ಆಗಿದೆ.

549
00:32:53,200 --> 00:32:57,260
ಮತ್ತು ಅತ್ಯಂತ ಪ್ರಮುಖ ವಸ್ತು, ಸಾಮರ್ಥ್ಯ,,, ಅಲ್ಲಿ ರಿಟರ್ನ್ ವಿಳಾಸ ಕೆಂಪು ಬಾಕ್ಸ್

550
00:32:57,260 --> 00:33:03,560
ಏಕೆಂದರೆ, ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಅಥವಾ adversarially ಆ 4 ಬೈಟ್ಗಳು ಬದಲಿಸಿ ಎಂದು ತಿಳಿದಿದ್ದಾರೆ

551
00:33:03,560 --> 00:33:07,260
ಕಸ ಆದರೆ ಹಲವಾರು ಕೇವಲ ಆ ಪಾಯಿಂಟರ್ ವಿಳಾಸಕ್ಕೆ,

552
00:33:07,260 --> 00:33:09,810
ಆ ನೆನಪಿಗಾಗಿ ನಿಜವಾದ ವಿಳಾಸಕ್ಕೆ ಪ್ರತಿನಿಧಿಸಲು ಸಂಭವಿಸುತ್ತದೆ.

553
00:33:09,810 --> 00:33:13,880
ತಾರ್ಕಿಕವಾಗಿ ಗೋಜಲನ್ನು, ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಫಂಕ್ಷನ್ ಬೇರೆ ಸ್ಥಳಕ್ಕೆ ಹಿಂದಿರುಗಿ ಹೋಗಿ ಇದೆ.

554
00:33:13,880 --> 00:33:15,250
ನಿಖರವಾಗಿ.

555
00:33:15,250 --> 00:33:19,170
Foo ಮರಳುತ್ತದೆ ಮತ್ತು ಹಿಟ್ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಎಂದು, ಪ್ರೋಗ್ರಾಂ ಮುಂದುವರೆಯಲು ಹತ್ತಿದರೆ

556
00:33:19,170 --> 00:33:25,060
ಮುಖ್ಯ ಮರಳಲು ಅಲ್ಲ, ಅದು ಕೆಂಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಯಾವುದೇ ವಿಳಾಸಕ್ಕೆ ಮರಳಲು ವಿಶೇಷವೇನು.

557
00:33:25,060 --> 00:33:28,600
>> ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ತಂತ್ರಾಂಶ ನೋಂದಣಿ ಸಂದರ್ಭದಲ್ಲಿ,

558
00:33:28,600 --> 00:33:32,260
ಶರೀರಕ್ಕೆ ಹಿಂದಿರುಗಿಸುವ ಎಂದು ವಿಳಾಸಕ್ಕೆ ಸಾಮಾನ್ಯವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ ಗಳಿಸುವ ಕಾರ್ಯ ಹೀಗಾದರೆ

559
00:33:32,260 --> 00:33:35,690
ನೀವು ತಂತ್ರಾಂಶ ಹಣ ಮತ್ತು ನಿಮ್ಮ ನೋಂದಣಿ ಕೋಡ್ ಇನ್ಪುಟ್? ಮಾಡಿದ ನಂತರ

560
00:33:35,690 --> 00:33:39,870
ನೀವು ಇಲ್ಲಿ ಹೋಗುತ್ತಿಲ್ಲ ಆಗಿ ಟ್ರಿಕ್ ಕಂಪ್ಯೂಟರ್ನ ವಿಂಗಡಿಸಲು ಬದಲಿಗೆ ಇಲ್ಲಿ ಹೋಗಿ ಮಾಡಬಹುದು.

561
00:33:39,870 --> 00:33:45,100
ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ ಇಂತಹ ಅಥವಾ, ಪ್ರತಿಕೂಲ ವಾಸ್ತವವಾಗಿ, ಉದಾಹರಣೆಗೆ, ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಮಾಡಬಹುದು

562
00:33:45,100 --> 00:33:50,690
ಒಂದು ನಿಜವಾದ ಪದ ಅಲ್ಲ 20 ಪಾತ್ರಗಳು, ಆದರೆ ಆತ ಅಥವಾ ಆಕೆ ವಾಸ್ತವವಾಗಿ ರೀತಿಯ ಇಟ್ಟುಕೋ

563
00:33:50,690 --> 00:33:52,770
ಕೋಡ್ ಪ್ರತಿನಿಧಿಸುವ ಕೆಲವು ಪಾತ್ರಗಳು.

564
00:33:52,770 --> 00:33:55,320
ಮತ್ತು ಸಿ ಕೋಡ್ ಎಂದು ಹೋಗುವ ಅಲ್ಲ, ಅದು ವಾಸ್ತವವಾಗಿ ಪಾತ್ರಗಳು ಎಂದು ವಿಶೇಷವೇನು

565
00:33:55,320 --> 00:33:59,290
ಆ 0 ಸೆ ಮತ್ತು 1 ದ್ವಿಮಾನ ಯಂತ್ರದ ಕೋಡ್, ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.

566
00:33:59,290 --> 00:34:01,290
ಆದರೆ, ಅವರು ಹಾಗೆ ಸಾಕಷ್ಟು ಬುದ್ಧಿವಂತ ಆರ್ ಇಟ್ಟುಕೋ

567
00:34:01,290 --> 00:34:06,500
ಹೇಗಾದರೂ ಮೂಲಭೂತವಾಗಿ ಕಂಪೈಲ್ ಕೋಡ್ ಎಂದು GetString ಪ್ರಾಂಪ್ಟ್ ಏನೋ ಅಂಟಿಸಿ ಗೆ,

568
00:34:06,500 --> 00:34:09,980
ಮತ್ತು ಕೊನೆಯ 4 ಬೈಟ್ಗಳು ಎಂದು ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಬದಲಿಸಿ.

569
00:34:09,980 --> 00:34:13,360
ಮತ್ತು ಇನ್ಪುಟ್ ಯಾವ ವಿಳಾಸಕ್ಕೆ ಮಾಡುತ್ತದೆ?

570
00:34:13,360 --> 00:34:18,630
ವಾಸ್ತವವಾಗಿ ಈ ಕೆಂಪು ಆಯತ ಬಫರ್ ಮೊದಲ ಬೈಟ್ ವಿಳಾಸಕ್ಕೆ ಅಂಗಡಿಗಳು.

571
00:34:18,630 --> 00:34:23,070
, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ ಇರಬೇಕು, ಮತ್ತು ಇದನ್ನು ಅಲ್ಲಿ ಕೆಟ್ಟ ಜನರಿಗೆ ಪ್ರಯೋಗ ಮತ್ತು ದೋಷ ಬಹಳಷ್ಟು ಹೊಂದಿದೆ

572
00:34:23,070 --> 00:34:25,639
ಆದರೆ ನೀವು ಈ ಬಫರ್ ಎಷ್ಟು ದೊಡ್ಡದಾಗಿದೆ ವ್ಯಕ್ತಿಯು ಒಂದು ವೇಳೆ

573
00:34:25,639 --> 00:34:28,820
ಆದಾನ ಕಳೆದ ಕೆಲವು ಬೈಟ್ಗಳು ನೀವು ಪ್ರೋಗ್ರಾಂಗೆ ಒದಗಿಸುವ ಇಂತಹ

574
00:34:28,820 --> 00:34:33,540
ನಿಮ್ಮ ಬಫರ್ ಪ್ರಾರಂಭವಾಗುವ ವಿಳಾಸಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಸಂಭವಿಸಿದಾಗ, ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು.

575
00:34:33,540 --> 00:34:39,320
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಹಲೋ ಮತ್ತು \ 0 ಹೇಳಲು ವೇಳೆ, ಆ ಬಫರ್ ಸೇರುತ್ತದೆ ಇಲ್ಲಿದೆ.

576
00:34:39,320 --> 00:34:44,420
ಆದರೆ ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ನೀವು ಮತ್ತು ನಾವು ಸಾರ್ವತ್ರಿಕವಾಗಿ ದಾಳಿಯ ಕೋಡ್ ಕರೆ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ಆ ಬಫರ್ ತುಂಬಲು ವೇಳೆ -

577
00:34:44,420 --> 00:34:48,860
AAA, ದಾಳಿ, ಆಕ್ರಮಣ, ದಾಳಿ - ಈ ಕೇವಲ ಕೆಟ್ಟ ಮಾಡದಿರುವಂಥದ್ದನ್ನು ವಿಷಯ ಅಲ್ಲಿ,

578
00:34:48,860 --> 00:34:51,820
ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ ಆರ್ ಏನಾಗುತ್ತದೆ, ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು.

579
00:34:51,820 --> 00:34:58,610
80, C0, 35, 08 - ಇಲ್ಲಿ ಕೆಂಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮದ.

580
00:34:58,610 --> 00:35:01,610
ಎಂದು ಇಲ್ಲಿ ಎಂದು ಸಂಖ್ಯೆಯನ್ನು ಹೋಲುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

581
00:35:01,610 --> 00:35:04,430
ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ, ಆದರೆ ಕೆಲವು ಬಾರಿ ಹೆಚ್ಚು.

582
00:35:04,430 --> 00:35:08,140
ಮರಳಿ ವಿಳಾಸಕ್ಕೆ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬದಲಾಯಿಸಿತು ಎಂದು ಗಮನಿಸಿ

583
00:35:08,140 --> 00:35:12,020
ಇಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಅಪ್ ಸಮವಾಗಿದೆ, ಮುಖ್ಯ ಅಲ್ಲ ವಿಳಾಸಕ್ಕೆ.

584
00:35:12,020 --> 00:35:17,500
ಕೆಟ್ಟ ವ್ಯಕ್ತಿ ಸೂಪರ್ ಸ್ಮಾರ್ಟ್ ಆದ್ದರಿಂದ, ಅವನು ಅಥವಾ ಅವಳು ದಾಳಿ ಕೋಡ್ ಸೇರಿಸಬಹುದು ಹೋಗುತ್ತದೆ

585
00:35:17,500 --> 00:35:20,930
ಬಳಕೆದಾರನ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಅಳಿಸಿ ಅಥವಾ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ನಕಲಿಸಿ ಏನೋ ಹಾಗೆ

586
00:35:20,930 --> 00:35:24,680
ಅಥವಾ ನಾನು ನಂತರ ಪ್ರವೇಶಿಸಲು ಒಂದು ಬಳಕೆದಾರ ಖಾತೆಯನ್ನು ರಚಿಸಿ - ಏನು ಎಲ್ಲ.

587
00:35:24,680 --> 00:35:26,950
>> ಈ ಅಪಾಯ ಮತ್ತು ಸಿ ಶಕ್ತಿ ಎರಡೂ

588
00:35:26,950 --> 00:35:29,840
ನೀವು ಪಾಯಿಂಟರ್ಗಳ ಮೂಲಕ ಮೆಮೊರಿ ಪ್ರವೇಶ ಏಕೆಂದರೆ

589
00:35:29,840 --> 00:35:32,520
ಮತ್ತು ನೀವು ಆದ್ದರಿಂದ, ಒಂದು ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿಗೆ ನೀವು ಏನು ಬರೆಯಬಹುದು

590
00:35:32,520 --> 00:35:35,080
ನೀವು ಕಂಪ್ಯೂಟರ್ ನೀವು ಏನು ಮಾಡಬಹುದು

591
00:35:35,080 --> 00:35:39,550
ಸರಳವಾಗಿ ಅದನ್ನು ತನ್ನದೇ ಮೆಮೊರಿ ಜಾಗವನ್ನು ಸುಮಾರು ಜಂಪ್ ನಂತರ.

592
00:35:39,550 --> 00:35:44,650
ಆದ್ದರಿಂದ ಈ ದಿನ ಅನೇಕ ಕಾರ್ಯಕ್ರಮಗಳು ಮತ್ತು ಅನೇಕ ವೆಬ್ಸೈಟ್ಗಳು ಧಕ್ಕೆಯುಂಟಾಗಿದೆ ಎಂದು

593
00:35:44,650 --> 00:35:46,200
ಈ ಅನುಕೂಲ ಪಡೆದು ಜನರಿಗೆ ಡೌನ್ ಹುಣ್ಣು.

594
00:35:46,200 --> 00:35:50,760
ಮತ್ತು ಈ ಒಂದು ಸೂಪರ್ ಅತ್ಯಾಧುನಿಕ ದಾಳಿ ಹೋಲುವಂತಿದ್ದು ಇರಬಹುದು, ಆದರೆ ಯಾವಾಗಲೂ ಆ ರೀತಿಯಲ್ಲಿ ಆರಂಭಿಸಲು ಇಲ್ಲ.

595
00:35:50,760 --> 00:35:53,560
ವಾಸ್ತವವಾಗಿ, ಯಾವ ಕೆಟ್ಟ ಜನರು ವಿಶಿಷ್ಟವಾಗಿ ಮಾಡುತ್ತದೆ ಎಂದು

596
00:35:53,560 --> 00:35:58,200
ಇದು ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಒಂದು ಪ್ರೋಗ್ರಾಮ್ ಅಥವಾ ಒಂದು GUI ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಒಂದು ವೆಬ್ಸೈಟ್, ಆಗಿರುತ್ತದೆ

597
00:35:58,200 --> 00:35:59,940
ನೀವು ಕೇವಲ ಅಸಂಬದ್ಧ ಒದಗಿಸುವ ಪ್ರಾರಂಭಿಸಿ.

598
00:35:59,940 --> 00:36:03,980
ನೀವು ಹುಡುಕಾಟ ಕ್ಷೇತ್ರದಲ್ಲಿ ಮತ್ತು ಹಿಟ್ ನಮೂದಿಸಿ ಒಂದು ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಪದವನ್ನು ನಮೂದಿಸಿ

599
00:36:03,980 --> 00:36:05,780
ಮತ್ತು ನೀವು ವೆಬ್ಸೈಟ್ ಕ್ರ್ಯಾಶ್ ನೋಡಲು ನಿರೀಕ್ಷಿಸಿ

600
00:36:05,780 --> 00:36:09,990
ಅಥವಾ ನೀವು ಕಾರ್ಯಕ್ರಮದ ಕೆಲವು ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನೋಡಲು ನಿರೀಕ್ಷಿಸಿ

601
00:36:09,990 --> 00:36:14,330
ನೀವು ಕೆಟ್ಟ ವ್ಯಕ್ತಿಯ ಅದೃಷ್ಟ ಪಡೆಯಲು ಮತ್ತು ನೀವು ಕೆಲವು ಅಸಾಮಾನ್ಯ ಇನ್ಪುಟ್ ಒದಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ

602
00:36:14,330 --> 00:36:18,980
ಪ್ರೋಗ್ರಾಮರ್ ನಿಮ್ಮ ಕೆಟ್ಟ ವರ್ತನೆ ನಿರೀಕ್ಷೆ ಇಟ್ಟುಕೊಂಡಿರಲಿಲ್ಲ ಅರ್ಥ ಪ್ರೋಗ್ರಾಂ, ಅಪಘಾತಗೊಂಡಿರುತ್ತದೆ ಎಂದು

603
00:36:18,980 --> 00:36:23,630
ಇದು, ನೀವು ಸಾಕಷ್ಟು ಪ್ರಯತ್ನ, ಸಾಕಷ್ಟು ಪ್ರಯೋಗ ಮತ್ತು ದೋಷದೊಂದಿಗೆ ಬಹುಶಃ ಎಂದರ್ಥ

604
00:36:23,630 --> 00:36:26,650
ಹೆಚ್ಚು ನಿಖರವಾದ ದಾಳಿ ಹೂಡಲು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ.

605
00:36:26,650 --> 00:36:31,410
ಭದ್ರತೆಯ ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಭಾಗವಾಗಿ ಕೇವಲ ಒಟ್ಟಾರೆಯಾಗಿ ಈ ದಾಳಿಗಳು ತಪ್ಪಿಸುವ ಇಲ್ಲ

606
00:36:31,410 --> 00:36:34,100
ಆದರೆ ಅವುಗಳನ್ನು ಪತ್ತೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ ದಾಖಲೆಗಳನ್ನು ನೋಡಿ

607
00:36:34,100 --> 00:36:36,780
ಮತ್ತು ಕ್ರೇಜಿ ಒಳಹರಿವು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿನ ಟೈಪಿಸಿದ ಜನರು ಏನು ನೋಡಿದ,

608
00:36:36,780 --> 00:36:38,960
ಯಾವ ಹುಡುಕಾಟ ಪದಗಳು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿನ ಜನರು ಟೈಪ್ ಮಾಡಿದ

609
00:36:38,960 --> 00:36:42,870
ಕೆಲವು ಬಫರ್ ಸುರಿಯುತ್ತಿರುವ ಭರವಸೆಯಲ್ಲಿ.

610
00:36:42,870 --> 00:36:45,500
ಮತ್ತು ಸರಳ ಮೂಲಭೂತ ಈ ಎಲ್ಲಾ ಕುದಿಯುವ ಕೆಳಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ

611
00:36:45,500 --> 00:36:49,080
ಮತ್ತು ಅದರ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಮತ್ತು ಬಳಸಲು ಅರ್ಥವೇನು.

612
00:36:49,080 --> 00:36:51,710
>> ಅದು ತುಂಬಾ ಇದು ಸಂಬಂಧಿಸಿದೆ.

613
00:36:51,710 --> 00:36:54,280
ನ ಇನ್ನೂ ಮತ್ತೆ ಒಂದು ಹಾರ್ಡ್ ಡ್ರೈವ್ ಒಳಗೆ ಮಿಂಚು ಲೆಟ್.

614
00:36:54,280 --> 00:36:58,440
ನೀವು ಹಿಂದೆ ಒಂದು ವಾರ ಅಥವಾ ಎರಡು ಹಿಂತೆಗೆದುಕೊಳ್ಳಬೇಕು ಎಂಬುದಾಗಿ ನಿಮ್ಮ ಮರುಬಳಕೆ ಬಿನ್ ಅಥವಾ ಕಸದ ತೊಟ್ಟಿ ಫೈಲ್ಗಳನ್ನು ಎಳೆಯಿರಿ ಆಗ

615
00:36:58,440 --> 00:37:03,710
ಏನಾಗುತ್ತದೆ? >> [ವಿದ್ಯಾರ್ಥಿ] ನಥಿಂಗ್. >> ಖಂಡಿತವಾಗಲೂ ಇಲ್ಲ, ಬಲ?

616
00:37:03,710 --> 00:37:05,740
ನೀವು ಡಿಸ್ಕ್ ಸ್ಪೇಸ್ ನಲ್ಲಿ ಕಡಿಮೆ ರನ್, ಅಂತಿಮವಾಗಿ ವೇಳೆ

617
00:37:05,740 --> 00:37:08,190
ವಿಂಡೋಸ್ ಅಥವಾ ಮ್ಯಾಕ್ OS ನೀವು ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

618
00:37:08,190 --> 00:37:10,390
ನೀವು ಏನಾದರೂ ಎಳೆಯಿರಿ ಆದರೆ, ಎಲ್ಲಾ ಸುರಕ್ಷಿತ ನಲ್ಲಿ ಅಲ್ಲ.

619
00:37:10,390 --> 00:37:13,800
ಎಲ್ಲಾ ನಿಮ್ಮ ಕೊಠಡಿ ಸಹವಾಸಿ ಅಥವಾ ಕುಟುಂಬದ ಸದಸ್ಯರು ಅಥವಾ ಸ್ನೇಹಿತರು ಮಾಡಲು ಹೊಂದಿದೆ ಡಬಲ್ ಕ್ಲಿಕ್ ಮಾಡಿ, voila, ಇದೆ

620
00:37:13,800 --> 00:37:16,310
ನೀವು ಅಳಿಸಲು ಪ್ರಯತ್ನಿಸಿದ ಎಲ್ಲಾ ಹುರುಳಿಲ್ಲದ ಕಡತಗಳು ಇಲ್ಲ.

621
00:37:16,310 --> 00:37:19,590
ನಮಗೆ ಅತ್ಯಂತ ಕನಿಷ್ಠ ನೀವು ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಅಥವಾ ಕ್ಲಿಕ್ ನಿಯಂತ್ರಣ ಎಂಬುದನ್ನು

622
00:37:19,590 --> 00:37:22,310
ಹಾಗೆ ಕಸ ಅಥವಾ ಏನೋ ಖಾಲಿ.

623
00:37:22,310 --> 00:37:25,000
ಆದರೆ ನಂತರ ಸಾಕಷ್ಟು ಟ್ರಿಕ್ ಏನು ಎಂಬುದನ್ನು

624
00:37:25,000 --> 00:37:28,010
ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಒಂದು ಫೈಲ್ ಹೊಂದಿದ್ದು, ಏನಾಗುತ್ತದೆ ಏಕೆಂದರೆ

625
00:37:28,010 --> 00:37:32,770
, ಕೆಲವು ದಾಖಲ ಅಥವಾ ಕೆಲವು JPEG ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ಇದು ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

626
00:37:32,770 --> 00:37:35,350
ಮತ್ತು ಈಗ ಇಲ್ಲಿ ಈ ಹಚ್ಚೆ, ಫೈಲ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಹೇಳುತ್ತಾರೆ

627
00:37:35,350 --> 00:37:38,390
ಮತ್ತು 0 ಸೆ ಮತ್ತು 1 ಗಳ ಇಡೀ ಗುಂಪೇ ಒಳಗೊಂಡ ನ.

628
00:37:38,390 --> 00:37:42,470
ನಿಮಗೆ ಮಾತ್ರ ಅನುಪಯುಕ್ತಕ್ಕೆ ಫೈಲ್ ಎಳೆಯಿರಿ ಅಲ್ಲ ಸಂಭವಿಸುತ್ತದೆ ಅಥವಾ ಬಿನ್ ಮರುಬಳಕೆ ಮಾಡಬಹುದು

629
00:37:42,470 --> 00:37:48,020
ಆದರೆ ಅದು ಖಾಲಿ? ಯಾವುದೇ ರೀತಿಯ.

630
00:37:48,020 --> 00:37:49,640
ಈಗ ಸಂಪೂರ್ಣವಾಗಿ ಏನೂ ಅಲ್ಲ.

631
00:37:49,640 --> 00:37:54,290
ಸ್ವಲ್ಪ ಏನಾದರೂ ಈ ಟೇಬಲ್ ರೂಪದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಈಗ ಕೇವಲ ಏನೂ ಇಲ್ಲಿದೆ.

632
00:37:54,290 --> 00:37:58,370
ಆದ್ದರಿಂದ ಒಂದು ಗಣಕದ ಮೆಮೊರಿಯ ಒಳಗೆ ಡೇಟಾಬೇಸ್ ಅಥವಾ ಮೇಜಿನ ರೀತಿಯ ಇಲ್ಲ

633
00:37:58,370 --> 00:38:03,850
ಆ ಮೂಲಭೂತವಾಗಿ, ಕಡತಗಳನ್ನು ಒಂದು ಕಾಲಮ್ ಹೆಸರುಗಳು ಮತ್ತು ಕಡತಗಳನ್ನು ಒಂದು ಕಾಲಮ್ 'ಸ್ಥಳ ಹೊಂದಿದೆ

634
00:38:03,850 --> 00:38:07,720
ಅಲ್ಲಿ ಈ ಸ್ಥಳ 123, ಕೇವಲ ಒಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಇರಬಹುದು.

635
00:38:07,720 --> 00:38:14,560
ನಾವು x.jpeg ಮತ್ತು ಸ್ಥಳ 123 ರೀತಿಯ ಹೊಂದಿರಬಹುದು.

636
00:38:14,560 --> 00:38:18,800
ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಕಸದ ಖಾಲಿ ಏನು ನಂತರ ಏನಾಗುತ್ತದೆ?

637
00:38:18,800 --> 00:38:20,330
ದೂರ ಹೋಗುತ್ತದೆ ಎಂದು.

638
00:38:20,330 --> 00:38:23,610
ಆದರೆ ಯಾವ ದೂರ ಹೋಗುವುದಿಲ್ಲ 0 ಸೆ ಮತ್ತು 1 ಹೊಂದಿದೆ.

639
00:38:23,610 --> 00:38:26,270
>> ಆದ್ದರಿಂದ pset4 ಸಂಪರ್ಕವನ್ನು ನಂತರ ಇದನ್ನೇ?

640
00:38:26,270 --> 00:38:31,240
ಅಲ್ಲದೆ, pset4 ಜೊತೆಗೆ, ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ಕಾಂಪ್ಯಾಕ್ಟ್ ಫ್ಲಾಶ್ ಕಾರ್ಡ್ ಅಳಿಸಿಹಾಕಿತು ಮಾಡಿದ ಕಾರಣ

641
00:38:31,240 --> 00:38:35,750
ದುರದೃಷ್ಟವಶಾತ್ ಈ ಫೋಟೋಗಳನ್ನು ಎಲ್ಲಾ ಅಥವಾ ಅದು ಎಂದು ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಆಯಿತು

642
00:38:35,750 --> 00:38:38,000
0 ಸೆ ಮತ್ತು 1 ಈಗಲೂ ಇಲ್ಲ ಎಂದು ಅರ್ಥವಲ್ಲ.

643
00:38:38,000 --> 00:38:40,410
ಏನೋ ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಪಡೆಯಿತು ಏಕೆಂದರೆ ಪ್ರಾಯಶಃ ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಕಳೆದುಹೋಗಿವೆ

644
00:38:40,410 --> 00:38:43,320
ಕೆಲವು 0 ಸೆ 1 ಸೆ ಹಾಗೂ 1 ಸೆ 0 ಸೆ ಆಯಿತು ಅರ್ಥದಲ್ಲಿ.

645
00:38:43,320 --> 00:38:47,240
ದೋಷಯುಕ್ತ ತಂತ್ರಾಂಶ ಅಥವಾ ದೋಷಯುಕ್ತ ಯಂತ್ರಾಂಶದ ಏಕೆಂದರೆ ಕೆಟ್ಟ ಸಂಗತಿಗಳು ಸಂಭವಿಸುತ್ತವೆ.

646
00:38:47,240 --> 00:38:50,370
ಆದರೆ ಆ ಬಿಟ್ಗಳು ಹಲವಾರು, ಬಹುಶಃ ಅವುಗಳನ್ನು ಕೂಡ 100%, ಇನ್ನೂ ಇವೆ.

647
00:38:50,370 --> 00:38:55,050
ಇದು JPEG1 ಪ್ರಾರಂಭಿಸಿದರು ಕಂಪ್ಯೂಟರ್ ಅಥವಾ ಕ್ಯಾಮೆರಾ ಗೊತ್ತಿಲ್ಲ ಎಂದು ಜಸ್ಟ್

648
00:38:55,050 --> 00:38:56,910
ಮತ್ತು ಅಲ್ಲಿ JPEG2 ಆರಂಭಿಸಿದರು.

649
00:38:56,910 --> 00:39:01,070
ಆದರೆ ನೀವು, ಪ್ರೋಗ್ರಾಮರ್, ಆ JPEGs ಅವು ಅಲ್ಲಿ ಜಾಣತನ ಒಂದು ಬಿಟ್ ಪರಿಚಯವಿರುವ

650
00:39:01,070 --> 00:39:06,010
ಅಥವಾ ಅವರು ರೀತಿ ನೀವು 0 ಸೆ ಮತ್ತು 1 ಮತ್ತು ಹೇಳುತ್ತಾರೆ JPEG, JPEG, ಪರಿಶೀಲಿಸಬಹುದು

651
00:39:06,010 --> 00:39:09,440
ನೀವು ಮೂಲಭೂತವಾಗಿ ಕೇವಲ ಗಾಗಿ ಒಂದು ಪ್ರೋಗ್ರಾಮ್ ಅನ್ನು ಬರೆಯುವುದು ಅಥವಾ ಮಾಡುತ್ತದೆ ಲೂಪ್

652
00:39:09,440 --> 00:39:12,820
ಆ ಕಡತಗಳ ಪ್ರತಿ ಒಂದು ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತಾನೆ.

653
00:39:12,820 --> 00:39:16,030
ಪಾಠದ ನಂತರ ಸುರಕ್ಷಿತವಾಗಿ ನಿಮ್ಮ ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಿಹಾಕುತ್ತವೆ ಆರಂಭಿಸಲು ಆದ್ದರಿಂದ

654
00:39:16,030 --> 00:39:18,340
ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಇದನ್ನು ತಪ್ಪಿಸಲು ಬಯಸಿದಲ್ಲಿ. ಹೌದು.

655
00:39:18,340 --> 00:39:21,010
>> [ವಿದ್ಯಾರ್ಥಿ] ಹೇಗೆ ಬಂದು ಅದನ್ನು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಹೇಳುತ್ತಾರೆ

656
00:39:21,010 --> 00:39:23,550
ನೀವು ಮೊದಲು ಮಾಡಿದರು ಹೆಚ್ಚು ಮೆಮೊರಿ ಎಂದು?

657
00:39:23,550 --> 00:39:27,820
ನೀವು ಮೊದಲು ಮಾಡಿದರು ಹೆಚ್ಚು ಮೆಮೊರಿ - >> [ವಿದ್ಯಾರ್ಥಿ] ಇನ್ನಷ್ಟು ಲಭ್ಯವಿರುವ ಸ್ಮರಣೆ.

658
00:39:27,820 --> 00:39:29,630
ಓಹ್. ಪ್ರಶ್ನೆ ಉತ್ತಮ.

659
00:39:29,630 --> 00:39:32,360
ಆದ್ದರಿಂದ ನಂತರ ಅನುಪಯುಕ್ತವನ್ನು ಖಾಲಿ ನಂತರ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ನೀವು ಹೇಳಲು ಇಲ್ಲ

660
00:39:32,360 --> 00:39:34,910
ನೀವು ಮೊದಲು ಮಾಡಿದರು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಹೊಂದಿರುವ?

661
00:39:34,910 --> 00:39:36,770
ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಸುಳ್ಳು ಮಾಡಿದ ಕಾರಣ.

662
00:39:36,770 --> 00:39:40,740
ಈಗ ನೀವು ಹೇಳಿದ ಕಾರಣ ಹೆಚ್ಚು ತಾಂತ್ರಿಕವಾಗಿ, ನೀವು ಹೆಚ್ಚು ಜಾಗವಿದೆಯೇ

663
00:39:40,740 --> 00:39:43,680
ಫೈಲ್ ಹಿಂದೊಮ್ಮೆ ಅಲ್ಲಿ ನೀವು ಇತರ ವಿಷಯವನ್ನು ಇರಿಸಬಹುದು.

664
00:39:43,680 --> 00:39:45,450
ಆದರೆ, ಬಿಟ್ಸ್ ದೂರ ಹೋಗುವ ಅರ್ಥವಲ್ಲ

665
00:39:45,450 --> 00:39:48,590
ಮತ್ತು ಬಿಟ್ಗಳು, ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ 0 ಸೆ ಬದಲಾಯಿತು ಎಂದು ಅರ್ಥವಲ್ಲ

666
00:39:48,590 --> 00:39:50,150
ನಿಮ್ಮ ರಕ್ಷಣೆಗಾಗಿ.

667
00:39:50,150 --> 00:39:54,640
ಆದ್ದರಿಂದ ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ನೀವು ಸುರಕ್ಷಿತವಾಗಿ ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಿ ಅಥವಾ ಭೌತಿಕವಾಗಿ ಸಾಧನ ನಾಶ ವೇಳೆ,

668
00:39:54,640 --> 00:39:57,300
ನಿಜಕ್ಕೂ ಆ ಸುತ್ತ ಕೆಲವೊಮ್ಮೆ ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ.

669
00:39:57,300 --> 00:40:02,020
>> ಆದ್ದರಿಂದ ನಾವು ಅರೆ ಹೆದರಿಕೆಯೆ ಗಮನಿಸಿ ಹೊರಡಲು ಇಲ್ಲ, ಮತ್ತು ನಾವು ಸೋಮವಾರ ನೀವು ನೋಡಬಹುದು.

670
00:40:02,020 --> 00:40:07,000
[ಚಪ್ಪಾಳೆಯನ್ನು]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]