1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [ವಾರದ 5]

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

3
00:00:04,760 --> 00:00:11,990
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[ವುಮನ್] ಅವರು ಸುಳ್ಳು ಮಾಡಿದ; ಬಗ್ಗೆ, ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

5
00:00:17,780 --> 00:00:20,300
[ಮ್ಯಾನ್] ಆದ್ದರಿಂದ ನಾವು ಏನು ಗೊತ್ತು?

6
00:00:20,300 --> 00:00:24,120
[ವುಮನ್] 9:15 ನಲ್ಲಿ, ರೇ Santoya ಎಟಿಎಂ ನಲ್ಲಿ ಎಂದು.

7
00:00:24,120 --> 00:00:27,420
[ಮ್ಯಾನ್] ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆಗೆ, ಅವರು 9:16 ಎಷ್ಟು ಮಾಡುತ್ತಿದ್ದ ಇದೆ?

8
00:00:27,420 --> 00:00:29,980
[ವುಮನ್] ಏನೋ 9 ಎಂಎಂ ಶೂಟಿಂಗ್.

9
00:00:29,980 --> 00:00:31,900
ಬಹುಶಃ ಅವರು ಸ್ನೈಪರ್ ಕಂಡಿತು.

10
00:00:31,900 --> 00:00:34,000
[ಮ್ಯಾನ್] ಅಥವಾ ಅವರ ಜತೆ ಕೆಲಸ.

11
00:00:34,000 --> 00:00:36,330
[ವುಮನ್] ನಿರೀಕ್ಷಿಸಿ. ಒಂದು ಹಿಂತಿರುಗಿ.

12
00:00:36,330 --> 00:00:38,330
[ಮ್ಯಾನ್] ನೀವು ಏನನ್ನು ನೋಡುತ್ತಾರೆ?

13
00:00:38,330 --> 00:00:44,520
[♫ ಕುತೂಹಲಕಾರೀ ಸಂಗೀತ ♫]

14
00:00:44,520 --> 00:00:48,320
[ವುಮನ್] ತನ್ನ ಮೇಲ್ಮುಖ ತನ್ನಿ. ಪೂರ್ಣ ಪರದೆ.

15
00:00:48,320 --> 00:00:51,230
[ಮ್ಯಾನ್] ಅವರ ಕನ್ನಡಕ. >> ಒಂದು ಪ್ರತಿಬಿಂಬ ಇಲ್ಲ.

16
00:00:51,230 --> 00:01:00,810
[♫ ಕುತೂಹಲಕಾರೀ ಸಂಗೀತ ♫]

17
00:01:00,810 --> 00:01:03,580
[ಮ್ಯಾನ್] ಆ Nuevita ನ ಬೇಸ್ಬಾಲ್ ತಂಡದ. ಅವರ ಲೋಗೋವನ್ನು ಇಲ್ಲಿದೆ.

18
00:01:03,580 --> 00:01:07,790
[ವುಮನ್] ಮತ್ತು ಆ ಜಾಕೆಟ್ ಧರಿಸಿದ ಅವರ ಯಾರೇ ಮಾತನಾಡಲು ನ.

19
00:01:07,790 --> 00:01:13,730
>> [ಡೇವಿಡ್ Malan] ಆದ್ದರಿಂದ, ಈ CS50 ವಾರ 5, ಮತ್ತು ಇಂದು ನಾವು ನೀವು ದೂರದರ್ಶನ ಮತ್ತು ಚಿತ್ರದ ಒಂದು ಬಿಟ್ ನಾಶಮಾಡಲು.

20
00:01:13,730 --> 00:01:16,170
ನೀವು ಇಲ್ಲಿ ಈ ಒಂದು ರೀತಿಯ ಪ್ರದರ್ಶನ ವೀಕ್ಷಿಸಿದ ಪ್ರಕಟಿಸಿದಾಗ,

21
00:01:16,170 --> 00:01:19,910
ಮತ್ತು ಪೊಲೀಸರು "ನೀವು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ?" ಸೇ ಅಥವಾ "ಹೆಚ್ಚಿಸಲು"

22
00:01:19,910 --> 00:01:21,900
ನೈಜ ಜಗತ್ತಿನ ವರ್ಧಿಸಲು ಇಲ್ಲ.

23
00:01:21,900 --> 00:01:25,220
ವಾಸ್ತವವಾಗಿ, ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಪಡೆಯಲು ಈ ರೀತಿಯ ಒಂದು ಸಣ್ಣ ವಿಷಯ.

24
00:01:25,220 --> 00:01:27,570
ನಾನು ಪುಟದಿಂದ ಸಿಬ್ಬಂದಿ ಫೋಟೋಗಳಲ್ಲಿ ಒಂದು ಮೇಲಕ್ಕೆಳೆಯಲ್ಪಡುತ್ತದೆ ಮಾಡಿದ್ದೀರಿ.

25
00:01:27,570 --> 00:01:30,980
ಈ ಫೋಟೋಶಾಪ್ ಎಂಬ ಕಾರ್ಯಕ್ರಮ. ಈ, 2 Bowdens ಆಫ್ 1

26
00:01:30,980 --> 00:01:36,300
ವಾಸ್ತವವಾಗಿ 1 3 Bowdens, ಇಂದು ನಾವು ರಾಬ್ ಮತ್ತು ಪಾಲ್ ಜೊತೆ, ಜೊತೆಗೆ ಇಲ್ಲಿ ಶ್ರೀಮತಿ ಬೌಡೆನ್ ಏಕೆಂದರೆ.

27
00:01:36,300 --> 00:01:41,950
ಆದರೆ ಇಲ್ಲಿ ತೆರೆಯಲ್ಲಿ ರಾಬ್, ಮತ್ತು ಒಂದು ವೇಳೆ ಅವರು ಯಾವಾಗಲೂ ತನ್ನ ಕಣ್ಣಿನ ಹೊಂದಿತ್ತು ಎಂದು ಪ್ರತಿಫಲಿಸು ಮೇಲೆ ನಾವು ಜೂಮ್,

28
00:01:41,950 --> 00:01:47,600
ನಿಮಗೆ ನಿಜವಾಗಿ ನೋಡಿದರು ನೀವು ನೋಡಿ ನೀವು ಪಡೆಯಿರಿ ಎಂದು.

29
00:01:47,600 --> 00:01:51,690
ಈ "ವರ್ಧಿತ" ಆದ್ದರಿಂದ "CSI" ಇದು ಸ್ವಲ್ಪ ತಪ್ಪು ಹೊಂದಿರುತ್ತವೆ.

30
00:01:51,690 --> 00:01:55,190
ನಾವು ಸ್ವಲ್ಪ ಮುಂದೆ "CSI" ಮೇಲೆ ಆಯ್ಕೆ ಮಾಡಬಹುದಾಗಿದೆ ಇತರ ಕ್ಲಿಪ್, ಇಲ್ಲ.

31
00:01:55,190 --> 00:01:58,500
ಈ ಒಂದು ನೀವು ಬಯಸಿದರೆ ಮುಂದೆ ಉತ್ತರ ಒಂದು ಸಂತೋಷವನ್ನು ನುಡಿಗಟ್ಟು ಆಗಿದೆ

32
00:01:58,500 --> 00:02:10,280
ನಿಜವಾಗಿಯೂ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಏನೂ ಹೇಳುವ ಮಾಡಿದಾಗ, ನಿಮ್ಮ ಸ್ನೇಹಿತರೊಂದಿಗೆ ತಾಂತ್ರಿಕ ಧ್ವನಿ.

33
00:02:10,280 --> 00:02:12,970
>> [ಮ್ಯಾನ್] ವಾರಗಳ ನಾನು ಕ್ಯಾಬರೆ ಕಿಲ್ಲರ್ ಕೊಲೆಗಳ ತನಿಖೆ ಮಾಡಲಾಗಿದೆ

34
00:02:12,970 --> 00:02:15,360
ಕೆಲವು ಅಸ್ವಸ್ಥ ವಶೀಕರಣ ಜೊತೆ.

35
00:02:15,360 --> 00:02:17,160
[ವುಮನ್ # 1] ಈ ನೈಜ ಸಮಯದಲ್ಲಿ ಹೊಂದಿದೆ.

36
00:02:17,160 --> 00:02:22,930
[ವುಮನ್ # 2] ನಾನು ಒಂದು IP ವಿಳಾಸವನ್ನು ಪತ್ತೆ ನೋಡಲು, ವಿಷುಯಲ್ ಬೇಸಿಕ್ ಬಳಸಿ ಒಂದು GUI ಸಂಪರ್ಕಸಾಧನದ ರಚಿಸುತ್ತೇವೆ.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] ವಿಷುಯಲ್ ಬೇಸಿಕ್ ಬಳಸಿ ಒಂದು GUI ಸಂಪರ್ಕಸಾಧನದ ಸೃಷ್ಟಿಸುತ್ತದೆ ಪಕ್ಕಕ್ಕೆ ಸಿಂಕ್ ಹೊರಗೆ ಆದ್ದರಿಂದ ಆಡಿಯೋ

38
00:02:29,570 --> 00:02:31,820
IP ವಿಳಾಸವನ್ನು ಟ್ರ್ಯಾಕ್ ಸಂಪೂರ್ಣ ಅಸಂಬದ್ಧ.

39
00:02:31,820 --> 00:02:33,840
ಈ ದಿನಗಳಲ್ಲಿ ನೀವು, ವಿಷುಯಲ್ ಬೇಸಿಕ್ ಅನ್ನು ಎಂದು

40
00:02:33,840 --> 00:02:38,920
ಅಲ್ಲಿ ಒಂದು GUI ಅವಶ್ಯಕತೆ, ಮತ್ತು IP ವಿಳಾಸವನ್ನು ತಾಂತ್ರಿಕವಾಗಿ ನಿಖರ ಪದವಾಗಿದೆ.

41
00:02:38,920 --> 00:02:41,730
ಆದ್ದರಿಂದ ಈ ಒಂದು ಕಣ್ಣಿನ ಹೊರಗಿಡಲು, ಮತ್ತು ನನ್ನ ಮೆಚ್ಚಿನವುಗಳು ಒಂದು:

42
00:02:41,730 --> 00:02:45,070
ನೀವು ಬೇರೆ ಭಾಷೆಯ ಅವಶ್ಯಕತೆ ಈ ಒಂದು, ಸ್ವಲ್ಪ ಹೆಚ್ಚು ರಹಸ್ಯ ಇಲ್ಲಿದೆ.

43
00:02:45,070 --> 00:02:47,860
ಸಿ ಸೂಪರ್ಸೆಟ್ ಆಗಿದ್ದು ಇದು ಉದ್ದೇಶ-C ಎಂಬ ಭಾಷೆ ಇಲ್ಲ

44
00:02:47,860 --> 00:02:51,960
ಇದು ಅವುಗಳನ್ನು ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ನಡುವೆ ಅದು ಸಿ ಜೊತೆಗೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಲಕ್ಷಣಗಳನ್ನು, ಅರ್ಥ.

45
00:02:51,960 --> 00:02:55,070
ಮತ್ತು ಈ ಆಪಲ್ ಐಒಎಸ್ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸಿದ ಎಂದು ಭಾಷೆ.

46
00:02:55,070 --> 00:02:58,760
ಮತ್ತು ಇಲ್ಲಿ "ಸಂಖ್ಯೆಗಳು" ಇಂದ, ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ ಕಾರ್ಯಕ್ರಮದ ಒಂದು ಕ್ಲಿಪ್ ನ

47
00:02:58,760 --> 00:03:02,450
ನೀವು ನಿಜವಾಗಿಯೂ ಬಲ ಕ್ಷಣದಲ್ಲಿ ನಿಮ್ಮ TiVo ಮತ್ತು ವಿರಾಮ ಮೇಲೆ ಹತ್ತಿರದಿಂದ ನೋಡಿದರೆ,

48
00:03:02,450 --> 00:03:07,700
ನೀವು ಏನು ಅವರು ಹುಡುಕುತ್ತಿರುವ ಅಷ್ಟೇನು ವಿವರಿಸಲಾಗಿದೆ ಯಾವುದರ ಎಂದು ನೋಡುತ್ತಾರೆ.

49
00:03:07,700 --> 00:03:11,170
ನನ್ನನ್ನು ಇಲ್ಲಿ ವಿವಿಧ ಆಡಿಯೋ ಕನೆಕ್ಟರ್ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ನಾವು ವೇಳೆ ನೋಡೋಣ

50
00:03:11,170 --> 00:03:13,780
ಸಿಂಕ್ ಆಡಿಯೋ ಈ ಸಮಯ.

51
00:03:13,780 --> 00:03:20,530
ನಾನು "ಸಂಖ್ಯೆಗಳು." ನೀವು ನೀಡಿ

52
00:03:20,530 --> 00:03:23,240
>> [ಮ್ಯಾನ್ # 1] ಇದು ಒಂದು 32 ಬಿಟ್ IPv4 ವಿಳಾಸ ಇಲ್ಲಿದೆ.

53
00:03:23,240 --> 00:03:38,930
[ಮ್ಯಾನ್ # 2] ಐಪಿ, ಎಂದು ಇಂಟರ್ನೆಟ್. >> ಖಾಸಗಿ ನೆಟ್ವರ್ಕ್. ಇದು ಅನಿತಾ ಖಾಸಗಿ ಜಾಲವಾಗಿ.

54
00:03:38,930 --> 00:03:43,810
[Malan] ಸರಿ. ಈ ಉದ್ದೇಶ-C ಆಗಿರುತ್ತದೆ, ಮತ್ತು ಇದು ಕೆಲವು ಮಕ್ಕಳ ಬಣ್ಣ ಕಾರ್ಯಕ್ರಮ ಇಲ್ಲಿದೆ

55
00:03:43,810 --> 00:03:51,140
ನೀವು ಬಹುಶಃ ಅಲ್ಲಿ ವೇರಿಯಬಲ್ ಹೆಸರಿನಿಂದ ನಿರ್ಣಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು.

56
00:03:51,140 --> 00:03:54,410
ಆದ್ದರಿಂದ, ನಂತರ, "ಸಂಖ್ಯೆಗಳು" ಎಂದು. ನಾವು ಪರಿಚಯಿಸಲು ಇಂದು ಮತ್ತು ಈ ವಾರ ಆದ್ದರಿಂದ

57
00:03:54,410 --> 00:03:57,740
ನ್ಯಾಯ ಮತ್ತು ಆದ್ದರಿಂದ ಸಮಸ್ಯೆಗಳ ಸಂದರ್ಭದ ವಿಶ್ವದ ಸ್ವಲ್ಪ.

58
00:03:57,740 --> 00:04:00,590
ಇಲ್ಲಿ ಒಂದು ವಿಶೇಷ ಘಟನೆ ಇರುವುದರಿಂದ ಇಂದು ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಉಪನ್ಯಾಸ ನಡೆಯಲಿದೆ

59
00:04:00,590 --> 00:04:05,530
ನಂತರ, ನಾವು ವಿದ್ಯಾರ್ಥಿಗಳು ಮತ್ತು ಸಮಾನವಾಗಿ ಪೋಷಕರು ಇಂದು ಎರಡೂ ಒಂದು ಪೀಕ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ಕೀಟಲೆ ವಿಲ್

60
00:04:05,530 --> 00:04:07,420
ದಿಗಂತದ ಮೇಲೆ ವಸ್ತುಗಳನ್ನು ಕೆಲವು.

61
00:04:07,420 --> 00:04:12,240
ಅವುಗಳಲ್ಲಿ, ಸೋಮವಾರ ರ, ನೀವು ಕೆಲವು ಸಹಪಾಠಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

62
00:04:12,240 --> 00:04:16,050
EdX, ಹಾರ್ವರ್ಡ್ ಮತ್ತು ತೆರೆದ courseware ಫಾರ್ MITS ಹೊಸ ಆನ್ಲೈನ್ ಉಪಕ್ರಮ

63
00:04:16,050 --> 00:04:19,120
ಮತ್ತು ಹೆಚ್ಚು, ಸೋಮವಾರ ಹಾರ್ವರ್ಡ್ನ ಆವರಣದಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವ ಇದೆ.

64
00:04:19,120 --> 00:04:21,490
ಬರುವ ಸೋಮವಾರ ಅಂದರೆ ನೀವು ಹೊಂದಿರುತ್ತದೆ - ಕೊನೆಯ ಎಣಿಕೆ ರ,

65
00:04:21,490 --> 00:04:26,210
86,000 ಹೆಚ್ಚುವರಿ ಸಹಪಾಠಿಗಳನ್ನು CS50 ರ ಉಪನ್ಯಾಸಗಳ ಜೊತೆಗೆ ನಂತರ ಮಾಡಲಾಗುತ್ತದೆ

66
00:04:26,210 --> 00:04:29,170
ಮತ್ತು ವಿಭಾಗಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು ಮತ್ತು ಸಮಸ್ಯೆ ಸೆಟ್.

67
00:04:29,170 --> 00:04:32,350
ಮತ್ತು ಈ ಭಾಗವಾಗಿ, ನಿಮ್ಮ ಉದ್ಘಾಟನಾ ವರ್ಗದ ಸದಸ್ಯರು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ

68
00:04:32,350 --> 00:04:35,090
CS50 ಈಗ CS50x.

69
00:04:35,090 --> 00:04:39,310
>> ಇದರ ಭಾಗವಾಗಿ, ಈಗ, ಮತ್ತು ಕೆಲವು ಸಮನಾಗಿ ಇರುತ್ತದೆ ಎಂದು ಅರ್ಥ.

70
00:04:39,310 --> 00:04:43,790
ವಿದ್ಯಾರ್ಥಿಗಳು ಬೃಹತ್ ಸಂಖ್ಯೆಯ, ಇದಕ್ಕೆ ತಯಾರಾಗಬೇಕು,

71
00:04:43,790 --> 00:04:47,180
ಹೇಳಲು ಇದು ಸಾಕಾಗುತ್ತದೆ ನಾವು 108 TFS ಮತ್ತು ಸಿಎಎಸ್ ಹೊಂದಿರುತ್ತವೆ ಸಹ

72
00:04:47,180 --> 00:04:50,790
ಅಷ್ಟೇನು ಉತ್ತಮ ವಿದ್ಯಾರ್ಥಿ / ಶಿಕ್ಷಕ ಅನುಪಾತ ನಾವು 80,000 ಇತರ ವಿದ್ಯಾರ್ಥಿಗಳು ಹಿಟ್ ಒಮ್ಮೆ.

73
00:04:50,790 --> 00:04:52,850
ನಾವು ಅನೇಕ ಸಮಸ್ಯೆಯನ್ನು ಅದರ ಶ್ರೇಣಿಕೃತ ಮಾಡುವುದಕ್ಕೆ ಹಿಂದಿರುಗಬಹುದೆಂದು ನೀವು ಕೈಯಾರೆ ಹೊಂದಿಸುತ್ತದೆ.

74
00:04:52,850 --> 00:04:55,920
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ ಈ ವಾರ ಪರಿಚಯಿಸಿತು CS50 ಚೆಕ್ ಆಗಿರುತ್ತದೆ

75
00:04:55,920 --> 00:04:58,450
APPLIANCE ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಯುಕ್ತತೆಯನ್ನು ಎಂದು ಹೋಗುವ ಇದು

76
00:04:58,450 --> 00:05:01,200
ಈ ವಾರಾಂತ್ಯದ ನಂತರ ಅಪ್ಡೇಟ್ ಒಮ್ಮೆ ನೀವು ಪಡೆಯುತ್ತೀರಿ ಎಂದು,

77
00:05:01,200 --> 00:05:03,200
ಮತ್ತು ನೀವು ಒಂದು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ, 50 ಪರಿಶೀಲಿಸಿ

78
00:05:03,200 --> 00:05:06,500
ನಿಮ್ಮ ಸ್ವಂತ pset ಮೇಲೆ, ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಂದು ಕೆಲವು ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆಯುತ್ತೀರಿ

79
00:05:06,500 --> 00:05:11,160
ಸರಿ ಅಥವಾ ತಪ್ಪು ನಾವು ಒದಗಿಸಿದ ವಿವಿಧ ವಿನ್ಯಾಸ ವಿಶೇಷಣಗಳು ಪ್ರಕಾರ.

80
00:05:11,160 --> 00:05:13,580
ಆದ್ದರಿಂದ ಹೆಚ್ಚಿನ ಮತ್ತು ಸಮಸ್ಯೆ ಸೆಟ್ ವಿವರಣೆಯನ್ನು ಮತ್ತು

81
00:05:13,580 --> 00:05:17,240
CS50x ಸಹಪಾಠಿಗಳು ಹಾಗೂ ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

82
00:05:17,240 --> 00:05:19,230
>> ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ 4 ಫರೆನ್ಸಿಕ್ಸ್ ಬಗ್ಗೆ ಎಲ್ಲಾ ಹೊಂದಿದೆ.

83
00:05:19,230 --> 00:05:21,940
ಮತ್ತು ಈ ತುಂಡು, ಕೆಲವು ನಿಜ ಜೀವನದ ಸಂಗತಿಗಳನ್ನು ಸ್ಫೂರ್ತಿ

84
00:05:21,940 --> 00:05:24,620
ನಾನು ಪದವಿ ಶಾಲಾ ರಲ್ಲಿ ಆ ಮೂಲಕ ಯಾವಾಗ, ನಾನು ಸ್ವಲ್ಪ ಕಾಲ ಕೂಡಿಟ್ಟರು

85
00:05:24,620 --> 00:05:28,650
ಮಿಡ್ಲ್ಸೆಕ್ಸ್ ಕೌಂಟಿಯ ಡಿಸ್ಟ್ರಿಕ್ಟ್ ಅಟರ್ನಿ 'ಸ್ ಆಫೀಸ್ ನ್ಯಾಯ ಕೆಲಸ

86
00:05:28,650 --> 00:05:31,650
ಅವರ ಪ್ರಮುಖ ನ್ಯಾಯ ಪರೀಕ್ಷಕನ ಜೊತೆ, ಮತ್ತು ಈ ಪಾಲನ್ನು

87
00:05:31,650 --> 00:05:35,260
, ನಾನು ಕೆಲವು ವಾರದ ಹಿಂದೆ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ ಭಾವಿಸುತ್ತೇನೆ, ಮಾಸ್ ರಾಜ್ಯ ಪೊಲೀಸ್ ಅಥವಾ ಇತರರು ಇದು

88
00:05:35,260 --> 00:05:39,000
ರಲ್ಲಿ ಬರುತ್ತದೆ, ಅವರು ಹಾರ್ಡ್ ಡ್ರೈವ್ಗಳು ಮತ್ತು CD ಗಳು ಮತ್ತು ಫ್ಲಾಪಿ ಡಿಸ್ಕ್ಗಳು ​​ವಿಷಯಗಳನ್ನು ಬಿಟ್ಟು ಎಂದು

89
00:05:39,000 --> 00:05:42,340
ತದನಂತರ ನಂತಹ, ಮತ್ತು ನ್ಯಾಯ ಕಚೇರಿ ಗುರಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಎಂದು

90
00:05:42,340 --> 00:05:44,600
ಇರಲಿಲ್ಲ ಅಥವಾ ಕೆಲವು ರೀತಿಯ ಪುರಾವೆ ಇಲ್ಲ.

91
00:05:44,600 --> 00:05:48,010
ಈ ಸ್ಪೆಷಲ್ ಇನ್ವೆಸ್ಟಿಗೇಶನ್ಸ್ ಯುನಿಟ್, ಅದು ಬಿಳಿ ಕಾಲರ್ ಅಪರಾಧ ಎಂದು

92
00:05:48,010 --> 00:05:52,350
ಇದು, ಅಪರಾಧಗಳಿಗೆ ಹೆಚ್ಚು ತೊಂದರೆ ರೀತಿಯ

93
00:05:52,350 --> 00:05:55,990
ಡಿಜಿಟಲ್ ಮಾಧ್ಯಮದ ರೀತಿಯ ಒಳಗೊಂಡ ಏನು; ಔಟ್ ತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಅನೇಕ ಜನರು

94
00:05:55,990 --> 00:05:59,370
ಹೇಳುವ ಇಮೇಲ್ ಬರೆಯಲು "ನಾನು ಅದನ್ನು ಮಾಡಿದರು."

95
00:05:59,370 --> 00:06:03,290
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಹೆಚ್ಚಾಗಿ ಈ ಫರೆನ್ಸಿಕ್ಸ್ ಹುಡುಕಾಟಗಳು, ಎಲ್ಲಾ ಹೆಚ್ಚು ಹಣ್ಣು ಎದ್ದು ಬರದ

96
00:06:03,290 --> 00:06:05,850
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಜನರು ಇಮೇಲ್ಗಳನ್ನು ಬರೆಯಬೇಕಿತ್ತು.

97
00:06:05,850 --> 00:06:08,490
ಆದ್ದರಿಂದ ಕೆಲವೊಮ್ಮೆ ಪ್ರಯತ್ನಗಳು ಬಹುಮಾನ ನೀಡಲಾಗುತ್ತಿತ್ತು.

98
00:06:08,490 --> 00:06:14,420
>> ಆದರೆ ಈ ನ್ಯಾಯ pset ಮುನ್ನುಡಿಯಾಗಿದೆ ನಾವು pset 4 ಗ್ರಾಫಿಕ್ಸ್ ಸ್ವಲ್ಪ ರಲ್ಲಿ ಪರಿಚಯಿಸುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ.

99
00:06:14,420 --> 00:06:18,260
ನೀವು ಬಹುಶಃ ಮಂಜೂರು, JPEGs, GIF ಗಳನ್ನು ಬಳಸಬಹುದಾಗಿದೆ ಮತ್ತು ಈ ದಿನಗಳ ಹಾಗೆ ಈ ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಡಿ

100
00:06:18,260 --> 00:06:21,640
ಆದರೆ ನೀವು ಅದರ ಬಗ್ಗೆ ನಿಮಗೆ ಅನಿಸಿದರೆ, ಚಿತ್ರವನ್ನು ಹೆಚ್ಚು ರಾಬ್ ಮುಖದ ಹಾಗೆ,

101
00:06:21,640 --> 00:06:24,430
ಒಂದು ಚುಕ್ಕೆಗಳ ಅನುಕ್ರಮ, ಅಥವಾ ಪಿಕ್ಸೆಲ್ಗಳಷ್ಟು ರೂಪುಗೊಳ್ಳಬಹುದು.

102
00:06:24,430 --> 00:06:26,680
ಈಗ, ರಾಬ್ ಮುಖದ ಸಂದರ್ಭದಲ್ಲಿ, ಬಣ್ಣಗಳ ಎಲ್ಲಾ ರೀತಿಯ, ಇಲ್ಲ

103
00:06:26,680 --> 00:06:29,940
ಮತ್ತು ನಾವು, otherwide ಪಿಕ್ಸೆಲ್ಗಳು ಎಂದು ಮಾಲಿಕ ಚುಕ್ಕೆಗಳು, ನೋಡಲು ಪ್ರಾರಂಭಿಸಿದರು

104
00:06:29,940 --> 00:06:31,610
ಒಮ್ಮೆ ನಾವು ಸೈನ್ ಜೂಮ್ ಆರಂಭಿಸಿದರು

105
00:06:31,610 --> 00:06:35,590
ಆದರೆ ವಿಶ್ವದ ಒಂದು ಬಿಟ್ ಸರಳಗೊಳಿಸುವ, ಮತ್ತು ಕೇವಲ ಇಲ್ಲಿ ಈ ರಾಬ್ ಹೇಳುತ್ತಾರೆ ವೇಳೆ

106
00:06:35,590 --> 00:06:40,560
ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ, ಹಾಗೂ, ಪ್ರತಿನಿಧಿಸಲು ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ನಾವು ಅವಳಿ ಬಳಸಬಹುದು.

107
00:06:40,560 --> 00:06:44,960
ಮತ್ತು ನಾವು ಅವಳಿ ಬಳಸಲು ನೀನು ವೇಳೆ, 1 ಅಥವಾ 0, ನಾವು ಇದೇ ಚಿತ್ರವನ್ನು ವ್ಯಕ್ತಪಡಿಸಬಹುದು

108
00:06:44,960 --> 00:06:51,970
ಬಿಟ್ಗಳು ಈ ಮಾದರಿಯ ರಾಬ್ ನ ನಗುತ್ತಿರುವ ಮುಖದ: 11000011 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

109
00:06:51,970 --> 00:06:55,160
ಬಿಳಿ, ಬಿಳಿ, ಕಪ್ಪು, ಕಪ್ಪು, ಕಪ್ಪು, ಕಪ್ಪು, ಬಿಳಿ ಬಿಳಿ.

110
00:06:55,160 --> 00:06:59,290
ಮತ್ತು ಆದ್ದರಿಂದ ವರ್ಣಮಯ ಛಾಯಾಚಿತ್ರಗಳನ್ನು ಬಗ್ಗೆ ಆರಂಭಿಸಲು, ನಂತರ, ಒಂದು ದೊಡ್ಡ ಅಧಿಕ ಅಲ್ಲ.

111
00:06:59,290 --> 00:07:01,920
ನೀವು ಫೇಸ್ಬುಕ್ ಮೇಲೆ ನೋಡಿ ಅಥವಾ ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾದೊಂದಿಗೆ ಮಾಡುವುದಾಗಿ ಥಿಂಗ್ಸ್,

112
00:07:01,920 --> 00:07:04,730
ಆದರೆ, ಖಚಿತವಾಗಿ ಅದು ಬಣ್ಣಗಳ ಬಂದಾಗ, ನೀವು ಹೆಚ್ಚಿನ ಬಿಟ್ಗಳು ಅಗತ್ಯವಿದೆ.

113
00:07:04,730 --> 00:07:08,470
ಮತ್ತು ಛಾಯಾಚಿತ್ರಗಳನ್ನು ಜಗತ್ತಿನ ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದರೆ 1-ಬಿಟ್ ಬಣ್ಣ ಬಳಸುವುದು

114
00:07:08,470 --> 00:07:12,730
ಈ ಸೂಚಿಸುತ್ತದೆ, ಆದರೆ 24 ಬಿಟ್ ಬಣ್ಣ, ನೀವು ವಾಸ್ತವವಾಗಿ ಬಣ್ಣಗಳನ್ನು ಲಕ್ಷಾಂತರ ಪಡೆಯಲು ಅಲ್ಲಿ. ಮಾಹಿತಿ

115
00:07:12,730 --> 00:07:15,430
ನಾವು ರಾಬ್ ಕಣ್ಣಿನ ಮೇಲೆ ಜೂಮ್ ಮಾಡಿದಾಗ ವಿಷಯದಲ್ಲಿ,

116
00:07:15,430 --> 00:07:19,270
ವಿಭಿನ್ನ ವರ್ಣರಂಜಿತ ಸಾಧ್ಯತೆಗಳನ್ನು ಲಕ್ಷಾಂತರ ಯಾವುದೇ ಸಂಖ್ಯೆ.

117
00:07:19,270 --> 00:07:22,260
>> ಆದ್ದರಿಂದ ನಾವು, ಸಮಸ್ಯೆ ಸೆಟ್ 4 ಅಲ್ಲದೇ ದರ್ಶನ ಈ ಪರಿಚಯಿಸಲು ವಿಲ್

118
00:07:22,260 --> 00:07:27,050
ಏಕೆಂದರೆ ಇಲ್ಲಿ ಶುಕ್ರವಾರ ಅವರ ಉಪನ್ಯಾಸ ವಾಡಿಕೆಯ 2:30 ಬದಲಿಗೆ ಮಧ್ಯಾಹ್ನ 3:30 ನಲ್ಲಿ ಇಂದು ವಾಗಿರುತ್ತದೆ.

119
00:07:27,050 --> 00:07:29,930
ಆದರೆ ವೀಡಿಯೊ, ಎಂದಿನಂತೆ, ನಾಳೆ ಆನ್ಲೈನ್ನಲ್ಲಿ ಕಾಣಿಸುತ್ತದೆ.

120
00:07:29,930 --> 00:07:31,880
ನಾವು ಇನ್ನೊಂದು ಫೈಲ್ ಸ್ವರೂಪಕ್ಕೆ ನೀವು ಪರಿಚಯಿಸಲು ಮಾಡುತ್ತೇವೆ.

121
00:07:31,880 --> 00:07:34,150
ಆದ್ದರಿಂದ ಈ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ, ಮೊದಲಿಗೆ ಬೆದರಿಸುವ ನೋಡಲು ಅರ್ಥ ಇದೆ

122
00:07:34,150 --> 00:07:38,980
ಆದರೆ ಈ ಒಂದು ಸಿ struct ಕೇವಲ ಕೆಲವು ದಾಖಲೆಗಳನ್ನು ಹೊಂದಿದೆ.

123
00:07:38,980 --> 00:07:42,280
ಇದು, ಮೈಕ್ರೋಸಾಫ್ಟ್, ವರ್ಷಗಳ ಹಿಂದೆ, ಈ ಸ್ವರೂಪವನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸಲು ಸಹಕಾರಿಯಾಯಿತು ಎಂದು ತಿರುಗುತ್ತದೆ

124
00:07:42,280 --> 00:07:46,630
ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್ ಸ್ವರೂಪ, BMP, ಮತ್ತು ಈ ಒಂದು ಸೂಪರ್ ಸರಳವಾಗಿತ್ತು, ಎಂದು

125
00:07:46,630 --> 00:07:50,390
ಒಂದಷ್ಟು ಕಾಲ ಬಳಸಿದ ವರ್ಣರಂಜಿತ ಚಿತ್ರಾತ್ಮಕ ಕಡತ ಸ್ವರೂಪ

126
00:07:50,390 --> 00:07:53,640
ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಇನ್ನೂ ಗಣಕಯಂತ್ರದಲ್ಲಿ ವಾಲ್ಪೇಪರ್ಗಳಿಗಾಗಿ.

127
00:07:53,640 --> 00:07:57,410
ನೀವು Windows XP ಮತ್ತು ಬೆಟ್ಟ ಗುಡ್ಡಗಳು ಮತ್ತು ನೀಲಿ ಆಕಾಶ ಮತ್ತೆ ಭಾವಿಸಿದರೆ,

128
00:07:57,410 --> 00:08:00,660
ಎಂದು ವಿಶಿಷ್ಟವಾಗಿ BMP, ಅಥವಾ ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ, ಮತ್ತು ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಆಗಿತ್ತು

129
00:08:00,660 --> 00:08:03,340
ಅವರು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣತೆ ಏಕೆಂದರೆ ನಮಗೆ ಆನಂದದಾಯಕವಾಗುವ.

130
00:08:03,340 --> 00:08:05,640
0 ಮತ್ತು 1 ರ ಈ ಗ್ರಿಡ್ ಎಂದು ಸಾಕಷ್ಟು ಸರಳ ಅಲ್ಲ;

131
00:08:05,640 --> 00:08:10,680
ಬದಲಿಗೆ, ನೀವು ಕಡತದ ಆರಂಭದಲ್ಲಿ ಒಂದು ಹೆಡರ್ ವಿಷಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

132
00:08:10,680 --> 00:08:15,520
ಆದ್ದರಿಂದ ಅಂದರೆ, ಒಂದು. BMP ಫೈಲ್ ಒಳಗೆ 0 ಮತ್ತು 1 ರ ಇಡೀ ಗುಂಪೇ, ಆಗಿದೆ

133
00:08:15,520 --> 00:08:18,070
ಆದರೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ 0 ಮತ್ತು 1 ರ ಹಾಗಾದರೆ ಇಲ್ಲ.

134
00:08:18,070 --> 00:08:21,450
ಮತ್ತು ಇದು, ವರ್ಷಗಳ ಕಾಲ ಲಘುವಾಗಿ ನಾವು ಬಹುಶಃ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಂದು ತಿರುಗುತ್ತದೆ

135
00:08:21,450 --> 00:08:27,040
. ಡಾಕ್ ಅಥವಾ. xls ಅಥವಾ. MP3 ಅಥವಾ. MP4, ರೀತಿಯ ಕಡತ ಸ್ವರೂಪಗಳನ್ನು

136
00:08:27,040 --> 00:08:29,910
ನಿಮಗೆ ಪರಿಚಿತವಾಗಿರುವ ಅದು ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್ಗಳು.

137
00:08:29,910 --> 00:08:31,900
ಜೊತೆಗೆ, ಅದರ ಸಹ ಫೈಲ್ ಸ್ವರೂಪ ಎಂದು ಅರ್ಥವೇನು?

138
00:08:31,900 --> 00:08:35,740
ದಿನದ ಕೊನೆಯಲ್ಲಿ ಏಕೆಂದರೆ, ನಾವು ಬಳಸಲು ಈ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಇರುವ 0 ಮತ್ತು 1 ರ

139
00:08:35,740 --> 00:08:39,950
ಮತ್ತು ಬಹುಶಃ ಆ 0 ಮತ್ತು 1 ರ ಒಂದು, ಬಿ, ಸಿ, ASCII ಅಥವಾ ಮಾದರಿಯ ಮೂಲಕ, ಪ್ರತಿನಿಧಿಸುತ್ತವೆ

140
00:08:39,950 --> 00:08:42,030
ಆದರೆ ದಿನದ ಕೊನೆಯಲ್ಲಿ ಮೂಲಕ, ಇದು ಕೇವಲ 0 ಮತ್ತು 1 ರ ನ.

141
00:08:42,030 --> 00:08:45,300
>> ಆದ್ದರಿಂದ ಮಾನವರು ಕೇವಲ ಸಾಂದರ್ಭಿಕವಾಗಿ ಒಂದು ಹೊಸ ಕಡತ ಸ್ವರೂಪದ ಆವಿಷ್ಕರಿಸಲು ನಿರ್ಧರಿಸಿದಲ್ಲಿ

142
00:08:45,300 --> 00:08:49,420
ಅವರು ಬಿಟ್ಸ್ ಮಾದರಿಗಳು ವಾಸ್ತವವಾಗಿ ಅರ್ಥವೇನು ಪ್ರಮಾಣಕವಾಗಿಸಲು ಅಲ್ಲಿ.

143
00:08:49,420 --> 00:08:52,790
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಜನರಾಗಿದ್ದರು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಸ್ವರೂಪದ ವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದಂತಹ

144
00:08:52,790 --> 00:08:58,260
ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್ ತುಂಬಾ ಮೊದಲ ಬೈಟ್ ನಲ್ಲಿ, ಮಾಹಿತಿ ಆಫ್ಸೆಟ್ 0 ಸೂಚಿಸಲಾಗುತ್ತದೆ ಹೇಳಿದರು, ಅಲ್ಲಿ,

145
00:08:58,260 --> 00:09:02,320
ಕೆಲವು cryptically ಹೆಸರಿನ ವೇರಿಯಬಲ್ ಎಂಬ bfType, ಇರುವಂತೆ ವಿಶೇಷವೇನು

146
00:09:02,320 --> 00:09:06,510
ಇದು ಕೇವಲ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ರೀತಿಯ ನಿಂತಿದೆ; ಇದು ಏನೆಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಫೈಲ್.

147
00:09:06,510 --> 00:09:10,780
ನೀವು 2 ಆಫ್ಸೆಟ್ ಎಂದು ಎರಡನೇ ಸಾಲು, ಬೈಟ್ ಸಂಖ್ಯೆ 2, ನಿಂದ, ಬಹುಶಃ, ನಿರ್ಣಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

148
00:09:10,780 --> 00:09:15,980
0 ಮತ್ತು 1 ರ ಏನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಮಾದರಿಯನ್ನು ಹೊಂದಿದೆ?

149
00:09:15,980 --> 00:09:18,320
ಏನೋ ಗಾತ್ರ, ಮತ್ತು ಅಲ್ಲಿಂದ ಮೇಲೆ ಹೋಗುತ್ತದೆ.

150
00:09:18,320 --> 00:09:20,660
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ 4, ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಕೆಲವು ಮೂಲಕ ನಡೆದರು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ.

151
00:09:20,660 --> 00:09:24,480
>> ನಾವು ಎಲ್ಲಾ ಬಗ್ಗೆ caring ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಗಮನಿಸುವುದಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ ಇದು ಕುತೂಹಲಕಾರಿ ಪಡೆಯಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

152
00:09:24,480 --> 00:09:30,780
ಸಾಲು ಅಥವಾ ಬೈಟ್ 54, rgbtBlue, ಹಸಿರು ಮತ್ತು ಕೆಂಪು ಸುತ್ತ.

153
00:09:30,780 --> 00:09:35,280
ನೀವು ಎಂದಾದರೂ ಪ್ರಥಮಾಕ್ಷರಿ RGB, ಕೆಂಪು ಹಸಿರು ನೀಲಿ ಕೇಳಿರುವ, ಈ ಆ ಉಲ್ಲೇಖವಾಗಿತ್ತು.

154
00:09:35,280 --> 00:09:37,840
ಇದು ತಿರುಗಿದರೆ ನೀವು ಮಳೆಬಿಲ್ಲಿನ ಎಲ್ಲಾ ಬಣ್ಣಗಳ ಪೇಂಟ್

155
00:09:37,840 --> 00:09:41,580
ಕೆಂಪು ಮತ್ತು ನೀಲಿ ಮತ್ತು ಹಸಿರು ಕೆಲವು ಸಂಯೋಜನೆಯೊಂದಿಗೆ.

156
00:09:41,580 --> 00:09:46,560
ಮತ್ತು, ವಾಸ್ತವವಾಗಿ, ಕೋಣೆಯಲ್ಲಿ ಪೋಷಕರು ಆರಂಭಿಕ ಪ್ರಕ್ಷೇಪಕಗಳು ಕೆಲವು ಮರುಪಡೆಯಲು ಇರಬಹುದು.

157
00:09:46,560 --> 00:09:49,360
ಈ ದಿನಗಳಲ್ಲಿ, ನೀವು ಕೇವಲ 1 ಪ್ರಕಾಶಮಾನವಾದ ಬೆಳಕಿನ ಒಂದು ಮಸೂರದ ಹೊರಬರುತ್ತಿರುವ ನೋಡಿ.

158
00:09:49,360 --> 00:09:52,870
ಆದರೆ ಹಿಂದಿನ ದಿನ, ನೀವು ಕೆಂಪು ಮಸೂರ, ನೀಲಿ ಲೆನ್ಸ್, ಮತ್ತು ಹಸಿರು ಮಸೂರ ಹೊಂದಿತ್ತು

159
00:09:52,870 --> 00:09:56,620
ಒಟ್ಟಾಗಿ ಅವರು ತೆರೆಯ ಗುರಿ ಮತ್ತು ವರ್ಣರಂಜಿತ ಚಿತ್ರವನ್ನು ರಚಿಸಿದರು.

160
00:09:56,620 --> 00:09:59,590
ಮತ್ತು ಸ್ವಲ್ಪ ಹೆಚ್ಚಾಗಿ ಮಧ್ಯಮ ಶಾಲೆಗಳು ಮತ್ತು ಪ್ರೌಢಶಾಲೆಗಳು ಆ ಮಸೂರಗಳು ಹೊಂದಿರುತ್ತದೆ

161
00:09:59,590 --> 00:10:02,680
ಯಾವಾಗಲೂ ಹೀಗೆ ಸ್ವಲ್ಪ ವಕ್ರವಾಗಿ, ಆದ್ದರಿಂದ ನೀವು, ಎರಡು ಅಥವಾ ಮೂರು ಚಿತ್ರಗಳನ್ನು ನೋಡುವ ರೀತಿಯ

162
00:10:02,680 --> 00:10:07,500
ಆದರೆ ಆ ಐಡಿಯಾ. ನೀವು ಒಂದು ಚಿತ್ರಣ ಕೆಂಪು ಮತ್ತು ಹಸಿರು ಮತ್ತು ನೀಲಿ ಬೆಳಕಿನ ಹೊಂದಿತ್ತು.

163
00:10:07,500 --> 00:10:09,570
ಮತ್ತು ಅದೇ ತತ್ವವನ್ನು ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

164
00:10:09,570 --> 00:10:12,000
>> ಆದ್ದರಿಂದ ಸವಾಲುಗಳನ್ನು ನಡುವೆ, ನಂತರ, ನೀವು ಸಮಸ್ಯೆ 4 ಸೆಟ್

165
00:10:12,000 --> 00:10:16,080
ಕೆಲವು ವಿಷಯಗಳನ್ನು ಮುಂದುವರೆಸುತ್ತೇವೆ; ಒಂದು ವಾಸ್ತವವಾಗಿ ಚಿತ್ರವನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಹೊಂದಿದೆ.

166
00:10:16,080 --> 00:10:18,050
0 ಮತ್ತು 1 ರ ಒಂದು ಮಾದರಿಯಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಲು,

167
00:10:18,050 --> 00:10:22,840
, 0 ಮತ್ತು 1 ರ ಭಾಗಗಳಲ್ಲಿ ಒಂದು ರಚನೆ ಯಾವ ಇಂತಹ ಪ್ರತಿನಿಧಿಸುವ ಔಟ್ ಲೆಕ್ಕಾಚಾರ

168
00:10:22,840 --> 00:10:26,800
ರೆಡ್ಸ್, ಬ್ಲೂಸ್, ಗ್ರೀನ್ಸ್: ತದನಂತರ ಪಿಕ್ಸೆಲ್ಗಳು ಪುನರಾವರ್ತಿಸಲು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ

169
00:10:26,800 --> 00:10:32,460
ಆದ್ದರಿಂದ ಒಳಗೆ ಚಿತ್ರ ಆರಂಭದಲ್ಲಿ ಈ ಕಾಣುತ್ತದೆ, ಆ ನಂತರ ಬದಲಿಗೆ ಈ ರೀತಿ ಇರಬಹುದು.

170
00:10:32,460 --> 00:10:35,590
ಇತರ ಸವಾಲುಗಳನ್ನು ನಡುವೆ, ತುಂಬಾ, ನೀವು ಹಸ್ತಾಂತರಿಸುವಾಗ ಮಾಡುತ್ತೇನೆ ಎಂದು ಹೋಗುತ್ತದೆ

171
00:10:35,590 --> 00:10:38,900
ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾ ಒಂದು ನಿಜವಾದ ಕಡತವನ್ನು ಒಂದು ನ್ಯಾಯ ಚಿತ್ರ

172
00:10:38,900 --> 00:10:42,410
ಮತ್ತು ಕ್ಯಾಮೆರಾ ಮೇಲೆ, ವನ್ಸ್ ಅಪಾನ್ ಎ ಟೈಮ್, ಫೋಟೋಗಳನ್ನು ಇಡೀ ಗುಂಪೇ ಇತ್ತು.

173
00:10:42,410 --> 00:10:47,030
ಸಮಸ್ಯೆ, ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ಅಳಿಸಿಹಾಕಿತು ಅಥವಾ ಚಿತ್ರವನ್ನು ಹೇಗಾದರೂ ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಬೀರಿತ್ತು.

174
00:10:47,030 --> 00:10:51,040
ಬ್ಯಾಡ್ ಥಿಂಗ್ಸ್ ಡಿಜಿಟಲ್ ಕ್ಯಾಮೆರಾಗಳಲ್ಲಿ ಸಂಭವಿಸಬಹುದು ಮತ್ತು ಆದ್ದರಿಂದ ಬೇಗ 0 ಮತ್ತು 1 ರ ಎಲ್ಲಾ ನಕಲು

175
00:10:51,040 --> 00:10:55,410
ಆಫ್ ನೀವು ಆ ಕಾರ್ಡ್, 1 ದೊಡ್ಡ ಫೈಲ್ ಅವರನ್ನು ಎಲ್ಲಾ ಉಳಿಸಲಾಗಿದೆ, ಮತ್ತು ಆಗ ನೀವು ಅವರನ್ನು ಹ್ಯಾಂಡ್ ವಿಲ್

176
00:10:55,410 --> 00:11:00,000
ನೀವು ಚೇತರಿಸಿಕೊಳ್ಳಲು ಅದು ಸಿ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಬರೆಯಬಹುದು ಆ ಲೆಕ್ಕದಲ್ಲಿ 4 ಸೆಟ್

177
00:11:00,000 --> 00:11:02,660
ಆ JPEGs ಎಲ್ಲಾ ಆದ್ದರಿಂದ.

178
00:11:02,660 --> 00:11:06,280
ಮತ್ತು ಇದನ್ನು ಅವರು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಕಡತ ಸ್ವರೂಪದ ಮಾಡಿದ್ದರೂ ಸಹ, ಆ JPEGs ತಿರುಗಿದರೆ

179
00:11:06,280 --> 00:11:09,580
ಅವರು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಇಲ್ಲಿ ಈ ನಗುತ್ತಿರುವ ಮುಖವನ್ನು ಹೆಚ್ಚು ಆರ್.

180
00:11:09,580 --> 00:11:14,320
ಪ್ರತಿ JPEG 0 ಮತ್ತು 1 ರ ಇದೇ ಮಾದರಿಗಳನ್ನು ಆರಂಭವಾಗುತ್ತದೆ ಎಂದು ತಿರುಗುತ್ತದೆ.

181
00:11:14,320 --> 00:11:18,820
ಆದ್ದರಿಂದ ಲೂಪ್ ಅಥವಾ ಅಂತಹುದೇ ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಅಥವಾ ಬಳಸಿ,

182
00:11:18,820 --> 00:11:22,350
ನೀವು ಎಲ್ಲಾ 0 ಮತ್ತು 1 ರ ಈ ನ್ಯಾಯ ಚಿತ್ರದಲ್ಲಿ ಮೇಲೆ ತಿರುಗಿ ಮಾಡಬಹುದು

183
00:11:22,350 --> 00:11:26,670
ಮತ್ತು ನೀವು ಸಮಸ್ಯೆ ಸೆಟ್ ನ ವಿವರಣೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ವಿಶೇಷ ಮಾದರಿಯನ್ನು ನೋಡಿ ಪ್ರತಿ ಬಾರಿ,

184
00:11:26,670 --> 00:11:29,770
ನೀವು, ಅತ್ಯಂತ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆ, 'ಓಹ್, ಇಲ್ಲಿ, ಪಡೆದುಕೊಳ್ಳಬಹುದು

185
00:11:29,770 --> 00:11:33,520
ಒಂದು JPEG ಪ್ರಾರಂಭದಲ್ಲಿ, 'ಮತ್ತು ತಕ್ಷಣ ನಗರದಲ್ಲಿ ಅದೇ ಮಾದರಿಯಲ್ಲಿ,

186
00:11:33,520 --> 00:11:36,050
ನಂತರ ಬೈಟ್ಗಳು ಅಥವಾ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಅಥವಾ ಮೆಗಾಬೈಟ್ಗಳು ಕೆಲವು ಸಂಖ್ಯೆ,

187
00:11:36,050 --> 00:11:40,550
ನೀವು Ooh ', ಪಡೆದುಕೊಳ್ಳಬಹುದು! ಇಲ್ಲಿ ಎರಡನೇ JPEG, ನಾನು ಮೊದಲ ನಂತರ ತೆಗೆದುಕೊಂಡ ಫೋಟೋ ಆಗಿದೆ.

188
00:11:40,550 --> 00:11:44,720
ನನ್ನ ಮೊದಲ ಕಡತ ಓದುವ ನಿಲ್ಲಿಸಲು ಅವಕಾಶ, ಈ ಹೊಸ ಬರೆಯಲು ಆರಂಭಿಸಲು. '

189
00:11:44,720 --> 00:11:49,980
ಮತ್ತು pset 4 ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ ಅನೇಕ 50 JPEGs ಏರಲಿದೆ.

190
00:11:49,980 --> 00:11:52,400
ಇದು 50 JPEGs ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ನೀವು ಒಂದು ಲೂಪ್ ಒಂದು ಬಿಟ್ ಹೊಂದಿವೆ.

191
00:11:52,400 --> 00:11:55,580
ನೀವು JPEGs ಒಂದು ಅನಂತ ಸಂಖ್ಯೆ, ನೀವು ಅನಂತ ಆದೇಶಗಳ ಹೊಂದಿರುತ್ತವೆ.

192
00:11:55,580 --> 00:11:58,280
ಆದ್ದರಿಂದ, ತುಂಬಾ ತುಂಬಾ ಸಾಮಾನ್ಯ ಸಂದರ್ಭ.

193
00:11:58,280 --> 00:12:00,280
ಆ ಕ್ಷಿತಿಜದಲ್ಲಿ ಎಂಬುದನ್ನು ಇಲ್ಲಿದೆ.

194
00:12:00,280 --> 00:12:03,740
>> ನಮಗೆ ಹಿಂದೆ 0 ಗೇಲಿ. ಅರ್ಥ, ನನ್ನ ಇಮೇಲ್ ಪ್ರತಿ, ಅದು ಏಕರೂಪವಾಗಿ ಜನರಾಗಿದ್ದರು ಇಲ್ಲ

195
00:12:03,740 --> 00:12:06,820
ಸಂತೋಷ, ತಟಸ್ಥ ರೀತಿಯ, ಮತ್ತು ರಸಪ್ರಶ್ನೆ ಸುಮಾರು ದುಃಖ 0 ಬಾರಿ ಎರಡೂ ಯಾರು.

196
00:12:06,820 --> 00:12:10,160
ಮತ್ತು ತಲೆ TFS, Zamyla, ನಿಮ್ಮ ಸ್ವಂತ TF, ನನಗೆ ತಲುಪಿ ದಯವಿಟ್ಟು

197
00:12:10,160 --> 00:12:14,120
ನೀವು ವಿಷಯಗಳನ್ನು ಹೋದರು ಹೇಗೆ ಚರ್ಚಿಸಲು ಬಯಸುತ್ತೇನೆ ನೀವು ತಿಳಿದಿರುವುದರಿಂದ CAS ಅಥವಾ ಒಂದು.

198
00:12:14,120 --> 00:12:16,460
>> ಆದ್ದರಿಂದ, ಕೋಣೆಯಲ್ಲಿ ಇಲ್ಲಿ ಪೋಷಕರು ಮೆಚ್ಚಿಸಲೆಂದೇ

199
00:12:16,460 --> 00:12:23,990
CS50 ಗ್ರಂಥಾಲಯದ ಏನು? ಉತ್ತಮ ಕೆಲಸ.

200
00:12:23,990 --> 00:12:32,280
CS50 ಗ್ರಂಥಾಲಯದ ಯಾವುದು? ಯಾ? [ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರಗಳನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

201
00:12:32,280 --> 00:12:35,730
>>, ಸರಿ ಉತ್ತಮ. ಆದ್ದರಿಂದ ನಾವು, ಸಿಬ್ಬಂದಿ, ಬರೆದ ಕೋಡ್ ಒಂದು prewritten ಸೆಟ್ ನ,

202
00:12:35,730 --> 00:12:38,460
ನಾವು ಕೆಲವು ಸಾಮಾನ್ಯ ಕಾರ್ಯಕಾರಿತ್ವಗಳನ್ನು ಒದಗಿಸಲು, ನಿಮಗೆ ಒದಗಿಸುತ್ತದೆ.

203
00:12:38,460 --> 00:12:42,290
ಇಲ್ಲಿ ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ ಕಾರ್ಯಗಳ ಎಲ್ಲಾ, ನನಗೆ ಇಂಟ್ ಪಡೆಯಿರಿ; ಅಂತ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಮೂಲವಸ್ತುವನ್ನು.

204
00:12:42,290 --> 00:12:45,260
ಈಗ ಪ್ರಾರಂಭವಾಗುತ್ತಿದೆ, ನಾವು ಈ ತರಬೇತಿ ಚಕ್ರಗಳು ತೆಗೆದುಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿ.

205
00:12:45,260 --> 00:12:48,230
ನಾವು, ನೀವು ಒಂದು "ಸ್ಟ್ರಿಂಗ್" ತೆಗೆದುಕೊಳ್ಳುವ ಆರಂಭಿಸಲು ನೀನು

206
00:12:48,230 --> 00:12:52,790
ಇದು, ಮರುಸ್ಥಾಪನೆ, ಏನು ನಿಜವಾದ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಕೇವಲ ಒಂದು ಸಮಾನಾರ್ಥಕ ಪದವಾಯಿತು? ಚಾರ್ *.

207
00:12:52,790 --> 00:12:57,020
ಆದ್ದರಿಂದ ಪೋಷಕರು, ಆ ಕರೆದಿರಬಹುದು - ಉತ್ತಮ ಎಂದು, ಆದ್ದರಿಂದ ಚಾರ್ * ನಾವು ನೋಡಲು ಪ್ರಾರಂಭಿಸಿ

208
00:12:57,020 --> 00:13:00,810
ಪರದೆಯ ಮೇಲೆ ಎಲ್ಲಾ ನಮ್ಮ ಶಬ್ದಕೋಶವನ್ನು ನಿಂದ "ಸ್ಟ್ರಿಂಗ್" ತೆಗೆದು ಹೆಚ್ಚು,

209
00:13:00,810 --> 00:13:02,760
ವಾಸ್ತವವಾಗಿ ಕೋಡ್ ಬರೆಯಲು ಅದನ್ನು ಬರುತ್ತದೆ ಕನಿಷ್ಠ ಮಾಡಿದಾಗ.

210
00:13:02,760 --> 00:13:06,240
ಹಾಗೆಯೇ, ನಾವು ಹೆಚ್ಚು ಈ ಕಾರ್ಯಗಳನ್ನು ಕೆಲವು ಬಳಕೆಯನ್ನು ನಿಲ್ಲಿಸಲು ವಿಲ್

211
00:13:06,240 --> 00:13:08,390
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಅತ್ಯಾಧುನಿಕ ಕಾಣುವುದು ಏಕೆಂದರೆ

212
00:13:08,390 --> 00:13:11,370
ಬದಲಿಗೆ ಕೇವಲ, ಒಂದು ಪ್ರಾಂಪ್ಟ್ ಮಿಟುಕಿಸುವುದು ಜೊತೆ ಕುಳಿತುಕೊಂಡು ಕಾರ್ಯಸೂಚಿಗಳನ್ನು ಬರೆಯಲು

213
00:13:11,370 --> 00:13:13,580
ಸೈನ್ ಏನೋ ಟೈಪ್ ಬಳಕೆದಾರರು ಕಾಯುವ

214
00:13:13,580 --> 00:13:15,220
ನೀವು ಬೇರೆಡೆಯಿಂದ ನಿಮ್ಮ ಒಳಹರಿವು ಪಡೆಯುತ್ತೀರಿ.

215
00:13:15,220 --> 00:13:18,720
ಉದಾಹರಣೆಗೆ, ನೀವು ಸ್ಥಳೀಯ ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಬಿಟ್ಗಳು ಸರಣಿಯನ್ನು ಅವುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ.

216
00:13:18,720 --> 00:13:23,340
ಬದಲಾಗಿ ನೀವು ಕೆಲವು ವೆಬ್ಸೈಟ್ ಎಲ್ಲೋ, ಒಂದು ಜಾಲಬಂಧ ಸಂಪರ್ಕವನ್ನು ರಿಂದ ಭವಿಷ್ಯದಲ್ಲಿ ಅವುಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ.

217
00:13:23,340 --> 00:13:27,460
ಆದ್ದರಿಂದ ಮೊದಲ ಬಾರಿಗೆ ಮರಳಿ ಈ ಪದರವನ್ನು ಪೀಲ್ ನಾವು, ಮತ್ತು CS50 APPLIANCE ಅಪ್ ಪುಲ್

218
00:13:27,460 --> 00:13:32,300
ನೀವು ವಾರಗಳ ಸೇರಿದಂತೆ ಸರಿಯಾದ ಇಲ್ಲಿಗೆ ಯಾವ CS50.h ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ಫೈಲ್,.

219
00:13:32,300 --> 00:13:34,380
>> ಆದರೆ ವಾಸ್ತವವಾಗಿ ಈ ಒಳಗೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

220
00:13:34,380 --> 00:13:38,250
ಆದ್ದರಿಂದ ನೀಲಿ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ಕೇವಲ ಕಾಮೆಂಟ್ಗಳ ಇಡೀ ಗುಂಪೇ ಆಗಿದೆ

221
00:13:38,250 --> 00:13:41,340
ಖಾತರಿ ಮಾಹಿತಿ ಮತ್ತು ಪರವಾನಗಿ. ಈ ಸಾಮಾನ್ಯ ನಿದರ್ಶನದ ತೆರನಾದ

222
00:13:41,340 --> 00:13:44,600
ತಂತ್ರಾಂಶಗಳನ್ನು, ಏಕೆಂದರೆ ತಂತ್ರಾಂಶ ಬಹಳಷ್ಟು ಈ ದಿನಗಳಲ್ಲಿ ", ಮುಕ್ತ ಮೂಲ" ಎಂದು ಏನನ್ನು ಹೊಂದಿದೆ

223
00:13:44,600 --> 00:13:46,940
ಇದು ಯಾರೋ ಕೋಡ್ ಬರೆದಿದ್ದಾರೆ ಎಂದರೆ

224
00:13:46,940 --> 00:13:50,060
ಮತ್ತು, ಕೇವಲ ಚಲಾಯಿಸಲು ಮತ್ತು ಬಳಸಲು, ಇದನ್ನು ಉಚಿತವಾಗಿ ಲಭ್ಯವಾಗುವಂತೆ

225
00:13:50,060 --> 00:13:53,660
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಓದಲು ಮತ್ತು ಮಾರ್ಪಡಿಸುವ ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಕೆಲಸ ಸಂಯೋಜನೆ.

226
00:13:53,660 --> 00:13:55,790
ಆದ್ದರಿಂದ, ನೀವು ತೆರೆದ ಮೂಲ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ ಇಲ್ಲಿದೆ

227
00:13:55,790 --> 00:13:58,030
ಒಂದು ಸಣ್ಣ ರೂಪದಲ್ಲಿ ಆದರೂ.

228
00:13:58,030 --> 00:14:01,860
ನಾನು ಕಾಮೆಂಟ್ಗಳನ್ನು ಕಳೆದ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ಆದರೂ ನಾವು ಕೆಲವು ಹೆಚ್ಚು ಪರಿಚಿತ ವಸ್ತುಗಳು ನೋಡಲು ಪ್ರಾರಂಭಿಸಿ.

229
00:14:01,860 --> 00:14:08,090
ಆದ್ದರಿಂದ CS50.h ಕಡತ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಂದು ಇಡೀ ಗುಂಪೇ ಒಳಗೊಂಡಿದೆ, ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಗಮನಿಸುವುದಿಲ್ಲ.

230
00:14:08,090 --> 00:14:11,160
ಈಗ, ಈ ಅತ್ಯಂತ ನಾವು ಮೊದಲು ನೋಡಿಯೇ ಇಲ್ಲ, ಆದರೆ ಒಂದು

231
00:14:11,160 --> 00:14:15,640
ಚಿರಪರಿಚಿತ; ಇವುಗಳಲ್ಲಿ ನಾವು ಇದುವರೆಗಿನ, ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಆದರೂ, ನೋಡಿದ್ದೇವೆ?

232
00:14:15,640 --> 00:14:18,720
ಹೌದು, ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯಗಳು. Stdlib.h, malloc ಹೊಂದಿದೆ

233
00:14:18,720 --> 00:14:21,590
ಹಾಗೆ ಒಮ್ಮೆ ನಾವು, ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಆರಂಭಿಸುತ್ತಾನೆ

234
00:14:21,590 --> 00:14:24,960
ನಾವು ಜೊತೆಗೆ ಮುಂದಿನ ವಾರ ಹಿಂತಿರುಗಿ ವಿಲ್ ಇದು, ಆ ಫೈಲ್ ಸೇರಿಸಿಕೊಳ್ಳಲು ಆರಂಭಿಸಿತು.

235
00:14:24,960 --> 00:14:29,660
ಇದು bool ಮತ್ತು ತಪ್ಪೆಂದು ವಾಸ್ತವವಾಗಿ, ಪ್ರತಿ ಸೆ, ಸಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ತಿರುಗಿದರೆ

236
00:14:29,660 --> 00:14:32,460
ನೀವು ಇಲ್ಲಿ ಈ ಫೈಲ್, ಹೊರತು.

237
00:14:32,460 --> 00:14:35,770
ಆದ್ದರಿಂದ ನಾವು, ವಾರಗಳ, ಪ್ರಮಾಣಿತ bool.h ಸೇರಿದಂತೆ ಮಾಡಲಾಗಿದೆ

238
00:14:35,770 --> 00:14:39,020
ನೀವು ಒಂದು, bool ಸರಿ ಅಥವಾ ತಪ್ಪು. ಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತಾರೆ ಇದರಿಂದ

239
00:14:39,020 --> 00:14:41,830
ಈ, ನೀವು ನಕಲಿ ಅದನ್ನು ವಿಂಗಡಿಸಲು ಮತ್ತು ಒಂದು ಇಂಟ್ ಬಳಸಬೇಕಾಗಿಬರುತ್ತಿತ್ತು

240
00:14:41,830 --> 00:14:45,920
ಮತ್ತು ಕೇವಲ ನಿರಂಕುಶವಾಗಿ 0 ತಪ್ಪಾಗಿದೆ ಮತ್ತು 1 ನಿಜವಾದ ಭಾವಿಸುತ್ತವೆ.

241
00:14:45,920 --> 00:14:49,980
>> ಈಗ, ನಾವು ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ಇಲ್ಲಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ವ್ಯಾಖ್ಯಾನವಾಗಿದೆ.

242
00:14:49,980 --> 00:14:54,820
ಈ * ಅಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಪರವಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ನಾವು ಮೊದಲು ಹೇಳುತ್ತಿದ್ದೆ ಎಂದು, ಔಟ್ ತಿರುಗುತ್ತದೆ.

243
00:14:54,820 --> 00:14:56,750
ನೀವು ಎಲ್ಲಾ ಸುಮಾರು ಜಾಗವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

244
00:14:56,750 --> 00:15:01,550
ನಾವು, ಈ ಸೆಮಿಸ್ಟರ್, * ಕೌಟುಂಬಿಕತೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಂದು ಸ್ಪಷ್ಟಪಡಿಸಲು ಈ ಎಂದು ಪ್ರಚಾರ ಮಾಡಲಾಗಿದೆ.

245
00:15:01,550 --> 00:15:05,370
ಆದರೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಅಲ್ಲ, ಅದನ್ನು ಆಗಲು, ಕೇವಲ ಸಾಮಾನ್ಯ, ಅರ್ಥ

246
00:15:05,370 --> 00:15:07,480
ಆದರೆ ಕಾರ್ಯತತ್ಪರವಾಗಿಲ್ಲದಿರಬಹುದು ಅದೇ ವಿಷಯ.

247
00:15:07,480 --> 00:15:11,070
ನಾವು ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಓದಲು ಆದರೆ ಈಗ, ಸೇ 'ಒಂದು ನೋಟ GetInt, ನೋಡೋಣ

248
00:15:11,070 --> 00:15:15,350
ನಾವು ಬೇರೆ ಏನು ಈ ಸೆಮಿಸ್ಟರ್ ಮೊದಲು, ಬಹುಶಃ, ಬಳಸಿದೆ ಏಕೆಂದರೆ.

249
00:15:15,350 --> 00:15:19,620
ಮತ್ತು ಇಲ್ಲಿ GetInt ಹೊಂದಿದೆ. ಇದು ಏನು?

250
00:15:19,620 --> 00:15:24,650
ಈ ಮಾದರಿ ಹೊಂದಿದೆ. ಎಷ್ಟೋ ಬಾರಿ, ನಮ್ಮ ಮೇಲ್ಭಾಗಗಳು ನಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಹಾಕಬಹುದು. ಸಿ ಕಡತಗಳನ್ನು,

251
00:15:24,650 --> 00:15:28,190
ಆದರೆ ನೀವು ಹೆಡರ್ ಕಡತಗಳನ್ನು. H ಕಡತಗಳನ್ನು, ರಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಹಾಕಬಹುದು

252
00:15:28,190 --> 00:15:32,110
ಇಲ್ಲಿ ಈ ರೀತಿಯಲ್ಲಿ, ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಯಾವಾಗ

253
00:15:32,110 --> 00:15:36,790
ನೀವು ಇತರ ಜನರು ಬಳಸಲು ಬಯಸುವ, ಇದು CS50 ಗ್ರಂಥಾಲಯದ ನಿಖರವಾಗಿ ಸಂದರ್ಭದಲ್ಲಿ

254
00:15:36,790 --> 00:15:40,900
ನೀವು CS50.c ಸ್ವಲ್ಪ ನಿಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ ಮಾತ್ರ

255
00:15:40,900 --> 00:15:46,720
ನೀವು, ಆ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಮೂಲಮಾದರಿಗಳ ಪುಟ್, ಆದರೆ ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ

256
00:15:46,720 --> 00:15:50,810
ನಂತರ ಹೆಡರ್ ಫೈಲ್, ಸ್ನೇಹಿತರು ಮತ್ತು ಸಹೋದ್ಯೋಗಿಗಳು ಸೇರಿವೆ ಏನು

257
00:15:50,810 --> 00:15:52,800
ಚೂಪಾದ ತಮ್ಮ ಸ್ವಂತ ಕೋಡ್ ಒಳಗೊಂಡಿದೆ.

258
00:15:52,800 --> 00:15:55,440
ಈ ಸಮಯದಲ್ಲಿ ನೀವು ಈ ಮೂಲಮಾದರಿಗಳ ಸೇರಿದಂತೆ ಮಾಡಿರುವ

259
00:15:55,440 --> 00:15:59,870
ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿಮ್ಮ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ಆದರೆ ಈ ಚೂಪಾದ ಮೂಲಕ ಯಾಂತ್ರಿಕ ಸೇರಿವೆ

260
00:15:59,870 --> 00:16:03,320
ಆ ಮೂಲಭೂತವಾಗಿ ಪ್ರತಿಗಳು ಮತ್ತು ಜಲಪಿಷ್ಟಗಳು ನಿಮ್ಮ ಈ ಕಡತ.

261
00:16:03,320 --> 00:16:06,400
ಈಗ, ಇಲ್ಲಿ ಕೆಲವು ತಕ್ಕಮಟ್ಟಿಗೆ ವಿವರವಾದ ದಾಖಲೆಯನ್ನು ಹೊಂದಿದೆ.

262
00:16:06,400 --> 00:16:08,880
>> GetInt ಒಂದು ಇಂಟ್ ಗಳಿಸುವ ಮಂಜೂರು ನಾವು ಅತ್ಯಧಿಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು,

263
00:16:08,880 --> 00:16:10,740
ಕೆಲವು ಇಕ್ಕಟ್ಟಿನ ಪ್ರಕರಣಗಳು ಇಲ್ಲ ಔಟ್ ಆದರೆ, ಸರಿಯಾದ ತಿರುಗುತ್ತದೆ?

264
00:16:10,740 --> 00:16:14,320
ಯಾವ ರೀತಿಯಲ್ಲಿ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಎಂದು ಅನೇಕ ಬಳಕೆದಾರರು ರೀತಿಯ ವೇಳೆ?

265
00:16:14,320 --> 00:16:17,350
ಕೇವಲ ಒಂದು ಇಂಟ್ ನ ಹಿಡಿಸುವಂತೆ ಸಾಧ್ಯವಿಲ್ಲ ಒಂದು quintillion,?

266
00:16:17,350 --> 00:16:21,180
ನಿರೀಕ್ಷಿತ ವರ್ತನೆಯನ್ನು ಎಂದರೇನು? ಅಲ್ಲದೆ, ಆದ್ದರಿಂದ ಇದು ಊಹಿಸಬಹುದಾದ ಇಲ್ಲಿದೆ.

267
00:16:21,180 --> 00:16:23,460
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ, ಫೈನ್ ಪ್ರಿಂಟ್ ಓದಲು

268
00:16:23,460 --> 00:16:27,850
ನೀವು ಆ ಸಾಲಿನಲ್ಲಿ ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ ವೇಳೆ, ಈ ಮರಳುತ್ತದೆ INT_MAX ನೋಡುತ್ತಾರೆ.

269
00:16:27,850 --> 00:16:30,800
ನಾವು, ಈ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು, ಆದರೆ ತನ್ನ ಬಂಡವಾಳೀಕರಣ ಆಧರಿಸಿ ನಾನೆಂದಿಗೂ

270
00:16:30,800 --> 00:16:33,030
ಪ್ರಾಯಶಃ, ಏನು?

271
00:16:33,030 --> 00:16:36,610
ಇದು ಒಂದು ಸ್ಥಿರ, ಆದ್ದರಿಂದ ಇದು ಬಹುಶಃ ಘೋಷಣೆ ಮಾಡಿದ ಕೆಲವು ವಿಶೇಷ ಸ್ಥಿರ ಇಲ್ಲಿದೆ

272
00:16:36,610 --> 00:16:39,460
ಫೈಲ್ ಎತ್ತರದ ಎಂದು ಆ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಂದು,

273
00:16:39,460 --> 00:16:43,400
ಮತ್ತು INT_MAX ಬಹುಶಃ 2 ಬಿಲಿಯನ್, ಸ್ಥೂಲವಾಗಿ, ಇಷ್ಟಪಡುವ ಸಂಗತಿಯಾಗಿದೆ.

274
00:16:43,400 --> 00:16:48,160
ನಾವು ಹೇಗೋ ಏನೋ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಬೇಕಾಗುತ್ತದೆ ಎಂಬುದು ಕಲ್ಪನೆಯು ತಪ್ಪಾಗಿದೆ

275
00:16:48,160 --> 00:16:51,090
ನಾವು, ಹೌದು, ನಮ್ಮ ಇತ್ಯರ್ಥವಾಗದ 4 ಬಿಲಿಯನ್ ಸಂಖ್ಯೆಯ

276
00:16:51,090 --> 00:16:53,980
2 ಬಿಲಿಯನ್ ಮೇಲೆ ಋಣಾತ್ಮಕ 2 ಬಿಲಿಯನ್, ನೀಡಲು ಅಥವಾ ಪಡೆಯಲು.

277
00:16:53,980 --> 00:16:58,030
ಅಲ್ಲದೆ, ಯಾವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಮಾನ್ಯವಾಗಿದೆ ನೀವು ಆ ಸಂಖ್ಯೆಗಳ ಒಂದು ಕಳ್ಳತನ ಆಗಿದೆ.

278
00:16:58,030 --> 00:17:02,250
ಬಹುಶಃ 0, ಬಹುಶಃ 2 ಬಿಲಿಯನ್, ಬಹುಶಃ ಋಣಾತ್ಮಕ 2 ಬಿಲಿಯನ್.

279
00:17:02,250 --> 00:17:06,720
ನೀವು ಜಗತ್ತಿನ ಬದ್ಧರಾಗುತ್ತಾರೆ ಆ ಮೂಲಕ ನೀವು ನಿಮ್ಮ ಸಂಭಾವ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಒಂದು ಕಾಲ

280
00:17:06,720 --> 00:17:10,089
ಒಂದು ವೇಳೆ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ನಾನು ಈ ಸೂಪರ್ ದೊಡ್ಡ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗುವುದು.

281
00:17:10,089 --> 00:17:13,329
ಆದರೆ ನೀವು ಬಳಕೆದಾರ ತರಹದ ಗೂಢ ಏನೋ ಟೈಪ್ ಬಯಸುವುದಿಲ್ಲ "4, 2, 3 ..."

282
00:17:13,329 --> 00:17:17,079
ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಸಂಖ್ಯೆಯ, ಅಲ್ಲಿ ನೀವು ಒಂದು ಸ್ಥಿರ ಬದಲಿಗೆ ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ.

283
00:17:17,079 --> 00:17:19,380
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ, ನೀವು ಕಳೆದ ಕೆಲವು ವಾರಗಳ ಗುದ ಎಂದು ವೇಳೆ,

284
00:17:19,380 --> 00:17:23,800
ನೀವು GetInt ಕರೆ ಸಮಯದಲ್ಲಿ, ನೀವು ಒಂದು ವೇಳೆ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುವ ನಡೆಯಬೇಕಾಗಿತ್ತು.

285
00:17:23,800 --> 00:17:27,109
, ಅಥವಾ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, INT_MAX ಬಳಕೆದಾರ ರೀತಿಯ ಮಾಡಿದರು

286
00:17:27,109 --> 00:17:29,900
GetInt ರಿಟರ್ನ್ INT_MAX ಮಾಡಿದರು? ಏಕೆಂದರೆ ಅದನ್ನು ಮಾಡಿದರೆ,

287
00:17:29,900 --> 00:17:35,140
ಎಂದು ವಾಸ್ತವವಾಗಿ ಅವರು ಅದನ್ನು ಟೈಪ್ ಮಾಡಲಿಲ್ಲ ಎಂದರೆ; ಏನೋ ಈ ಪ್ರಕರಣದಲ್ಲಿ ತಪ್ಪಾಗಿದೆ.

288
00:17:35,140 --> 00:17:38,970
ಆದ್ದರಿಂದ ಈ ಸಾಮಾನ್ಯವಾಗಿ ವಿಶೇಷ ಅಂದರೆ ಒಂದು "ಸೆಂಟಿನಲ್" ಮೌಲ್ಯ, ಎಂದು ಏನನ್ನು ಹೊಂದಿದೆ.

289
00:17:38,970 --> 00:17:41,020
>> ಜೊತೆಗೆ, ಈಗ. ಸಿ ಕಡತಗಳನ್ನು ಗೆ ಮಾಡಲು ಅವಕಾಶ.

290
00:17:41,020 --> 00:17:44,500
ಸಿ ಫೈಲ್, ಕೆಲವು ಬಾರಿ ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅಸ್ತಿತ್ವದಲ್ಲಿತ್ತು

291
00:17:44,500 --> 00:17:47,540
ಮತ್ತು, ವಾಸ್ತವವಾಗಿ, APPLIANCE ನೀವು ಅದನ್ನು ಪೂರ್ವ ಸಂಕಲಿತವಾಗಿರುತ್ತವೆ ಹೊಂದಿದೆ

292
00:17:47,540 --> 00:17:49,720
ಆ ಕೆಲಸವನ್ನು ನಾವು ", ವಸ್ತುವಿನ ಕೋಡ್" ಎಂಬ

293
00:17:49,720 --> 00:17:52,940
ವ್ಯವಸ್ಥೆಯ ತಿಳಿದಿರುವ ಕಾರಣ ಅದು ಅಲ್ಲಿ ಆದರೆ ಇದು ನಿಮಗೆ ಸಂಬಂಧಿಸಿದ ಮಾಡುವುದಿಲ್ಲ,

294
00:17:52,940 --> 00:17:54,780
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದು ಅಲ್ಲಿ, APPLIANCE.

295
00:17:54,780 --> 00:18:00,620
ಆದರೆ GetInt ಈಗ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಅವಕಾಶ ಮತ್ತು GetInt ಈ ಸಮಯದಲ್ಲಿ ಕೆಲಸ ಎಂಬುದನ್ನು ನೋಡಿ.

296
00:18:00,620 --> 00:18:02,380
ಇಲ್ಲಿ ನಾವು ಮೊದಲು ಇದೇ ಕಾಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಿವೆ.

297
00:18:02,380 --> 00:18:04,930
ನನಗೆ ಕೇವಲ ಕೋಡ್ ಭಾಗದಲ್ಲಿ ಜೂಮ್ ಅವಕಾಶ

298
00:18:04,930 --> 00:18:07,410
ಮತ್ತು ನಾವು GetInt ಹೊಂದಿರುವ ಕೆಳಗಿನ ಹೊಂದಿದೆ.

299
00:18:07,410 --> 00:18:12,770
(ನಿಜವಾದ), ಆದ್ದರಿಂದ ನಾವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಅನಂತ ಆದೇಶಗಳ ಹೊಂದಿರುತ್ತವೆ, ಇದು ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಒಂದು ಇಂಟ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

300
00:18:12,770 --> 00:18:16,560
ಆದರೆ, ಬಹುಶಃ, ನಾವು ಹೇಗಾದರೂ ಈ ಭೇದಿಸಿ, ಅಥವಾ ಈ ಒಳಗಿನ ಬರುತ್ತೇವೆ.

301
00:18:16,560 --> 00:18:19,890
ಇದರಿಂದ ಹೇಗೆ ಈ ಕೆಲಸಗಳನ್ನು ನೋಡೋಣ. ಹಾಗೆಯೇ, ನಾವು GetString ಬಳಸಿಕೊಂಡು ತೋರುತ್ತಿದೆ

302
00:18:19,890 --> 00:18:22,550
ಲೂಪ್ 166 ಒಳಗೆ ಈ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ.

303
00:18:22,550 --> 00:18:25,320
ಈಗ ಉತ್ತಮ ಏಕೆಂದರೆ ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ

304
00:18:25,320 --> 00:18:30,820
GetString ಈ ವಿಶೇಷ ಕೀವರ್ಡ್, ಶೂನ್ಯ ಹಿಂದಿರುಗಬಹುದು?

305
00:18:30,820 --> 00:18:38,460
ಒಂದು ವೇಳೆ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ. ನೀವು GetString ರೀತಿಯ ಕರೆ ಮಾಡಿದಾಗ ತಪ್ಪು ಹೋಗಿ ಎಂದು ಏನು?

306
00:18:38,460 --> 00:18:42,550
ಯಾ? [ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ಹೌದು. ಆದ್ದರಿಂದ ಬಹುಶಃ malloc ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

307
00:18:42,550 --> 00:18:45,310
ಎಲ್ಲೋ HOOD GetString ಕೆಳಗೆ, malloc ಕರೆ ಇದೆ

308
00:18:45,310 --> 00:18:48,210
ಇದು ಕಂಪ್ಯೂಟರ್ ಅಂಗಡಿ ಅವಕಾಶ ನೀಡುವ, ಮೆಮೊರಿ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ

309
00:18:48,210 --> 00:18:50,950
ಅಕ್ಷರಗಳ ಎಲ್ಲ ಕೀಬೋರ್ಡ್ ಆಗಿ ಬಳಕೆದಾರ ರೀತಿಯ.

310
00:18:50,950 --> 00:18:53,270
ಮತ್ತು ಬಳಕೆದಾರರು ಉಚಿತ ಸಮಯವನ್ನು ಇಡೀ ಬಹಳಷ್ಟು ಹೊಂದಿತ್ತು ಇಟ್ಟುಕೋ

311
00:18:53,270 --> 00:18:56,470
ಮತ್ತು 2 ಬಿಲಿಯನ್ ಅಕ್ಷರಗಳಿಗಿಂತ, ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚು ಟೈಪ್.

312
00:18:56,470 --> 00:18:59,600
ಕಂಪ್ಯೂಟರ್ ಹೆಚ್ಚು ಪಾತ್ರಗಳು ಕೂಡ RAM ಹೊಂದಿದೆ.

313
00:18:59,600 --> 00:19:02,350
ಅಲ್ಲದೆ, GetString, ನೀವು ಆ ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ

314
00:19:02,350 --> 00:19:05,650
ಈ ಒಂದು ಸೂಪರ್, ಸೂಪರ್ ಅಸಾಮಾನ್ಯ ಮೂಲೆಯಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ಸಹ.

315
00:19:05,650 --> 00:19:08,490
ಅದು ಹೇಗೋ ಈ ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ GetString

316
00:19:08,490 --> 00:19:11,850
ನಾವು ಹಿಂದಿರುಗಿ ಮತ್ತು ಅದರ ದಸ್ತಾವೇಜನ್ನು ಓದಲು, ವಾಸ್ತವವಾಗಿ, ಶೂನ್ಯ ಹಿಂದಿರುಗಲು ಮಾಡುವುದಿಲ್ಲ.

317
00:19:11,850 --> 00:19:16,150
GetString ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ವಿಫಲವಾದರೆ ಈಗ ವೇಳೆ, GetInt ವಿಫಲವಾದ ಹೋಗುತ್ತದೆ

318
00:19:16,150 --> 00:19:19,370
ಕೇವಲ ಸೆಂಟಿನೆಲ್ ಮಾಹಿತಿ, INT_MAX ಮರಳಿ.

319
00:19:19,370 --> 00:19:22,650
ಈ ಕೇವಲ ಮಾನವ ಮಾದರಿಗಳಿವೆ. ಈ ತಿಳಿಯುವುದಿಲ್ಲ ಕೇವಲ ರೀತಿಯಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ

320
00:19:22,650 --> 00:19:24,840
ದಸ್ತಾವೇಜನ್ನು ಓದುವ ಮೂಲಕ.

321
00:19:24,840 --> 00:19:28,200
ಆದ್ದರಿಂದ ನ ಇಂಟ್ ವಾಸ್ತವವಾಗಿ GotInt ಅಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಅವಕಾಶ.

322
00:19:28,200 --> 00:19:34,220
>> ನಾನು ಸ್ವಲ್ಪ ಮತ್ತಷ್ಟು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಆದ್ದರಿಂದ, ಸಾಲು 170 ರಲ್ಲಿ ಈ ರೇಖೆಗಳ ಮೇಲೆ ಕಾಮೆಂಟ್ ಹೊಂದಿರುತ್ತವೆ.

323
00:19:34,220 --> 00:19:38,470
ಆದ್ದರಿಂದ, 172 ರಲ್ಲಿ, ಒಂದು int N ಮತ್ತು ಚಾರ್ ಸಿ, ಮತ್ತು ಈ ಹೊಸ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿದ

324
00:19:38,470 --> 00:19:41,870
ನೀವು ಕೆಲವು ಮೊದಲು ಎಡತಾಕಿರುವಿರಾ, ಆದರೆ sscanf ಮಾಡಿದ್ದಾರೆ.

325
00:19:41,870 --> 00:19:44,190
ಈ ಸರಣಿಯನ್ನು ಸ್ಕ್ಯಾನ್ F ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

326
00:19:44,190 --> 00:19:48,580
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನನಗೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ, ಆಸಕ್ತಿಯ ಮಾಹಿತಿಯನ್ನು ತುಣುಕುಗಳನ್ನು ಇದನ್ನು ಸ್ಕ್ಯಾನ್ ಕಾಣಿಸುತ್ತದೆ.

327
00:19:48,580 --> 00:19:53,820
ಇದರಿಂದ ಏನು? ಜೊತೆಗೆ, ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ 1 2 3, ಅಕ್ಷರಶಃ ಟೈಪ್ ಭಾವಿಸಿರಿ

328
00:19:53,820 --> 00:19:59,730
ನಂತರ enter ಅನ್ನು ಒತ್ತಿ. GetString ಅದಕ್ಕೆ ಹಿಂದಿರುಗಿದಾಗ 1 2 3 ಮಾಹಿತಿ ಪ್ರಕಾರ ಯಾವುದು?

329
00:19:59,730 --> 00:20:05,010
ಇದು ಬಲ, ನಿಸ್ಸಂಶಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ನ? ನಾನು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸಿಕ್ಕಿತು, ಆದ್ದರಿಂದ 1 2 3 ನಿಜವಾಗಿಯೂ "1 2 3" ಆಗಿದೆ

330
00:20:05,010 --> 00:20:07,260
ಇದು ಕೊನೆಯಲ್ಲಿ \ 0. ಒಂದು ಇಂಟ್ ಅಲ್ಲ.

331
00:20:07,260 --> 00:20:10,420
ಒಂದು ಸಂಖ್ಯೆ ಅಲ್ಲ. ಇದು ಹಲವಾರು ಕಾಣುತ್ತದೆ ಆದರೆ ನಿಜವಾಗಿ ಅಲ್ಲ.

332
00:20:10,420 --> 00:20:14,680
ಆದ್ದರಿಂದ ಯಾವ GetInt ಮಾಡಲು ಹೊಂದಿದೆ? ಇದು, ಎಡದಿಂದ ಬಲಕ್ಕೆ ಒಂದು ತಂತುವಿನ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಹೊಂದಿದೆ

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, ಮತ್ತು ಹೇಗೋ ನೈಜ ಪೂರ್ಣಾಂಕ ಗೆ ಬದಲಾಯಿಸಿ.

334
00:20:19,010 --> 00:20:21,010
ಈಗ, ನೀವು ಇದನ್ನು ಹೇಗೆ ಎಂಬುದನ್ನು ಅಂದಾಜು ಮಾಡಬಹುದೆಂಬ.

335
00:20:21,010 --> 00:20:24,240
ನೀವು pset 2 ಮರಳಿ ಭಾವಿಸಿದರೆ, ನೀವು ಸಂಭಾವ್ಯವಾಗಿ ಸ್ವಲ್ಪ ಆರಾಮದಾಯಕ ಸಿಕ್ಕಿತು

336
00:20:24,240 --> 00:20:26,810
ಸೀಸರ್ ಅಥವಾ vigenere ಜೊತೆ ಆದ್ದರಿಂದ ನೀವು ಒಂದು ವಾಕ್ಯವನ್ನು ಮೇಲೆ ತಿರುಗಿ ಮಾಡಬಹುದು

337
00:20:26,810 --> 00:20:29,800
ನೀವು ಪಿಕ್ ints ಗೆ ಅಕ್ಷರಗಳನ್ನು ಪರಿವರ್ತಿಸಬಹುದು. ಕೆಲಸದ ಒಟ್ಟಾರೆಯಾಗಿ ಬಹಳಷ್ಟು ಆ.

338
00:20:29,800 --> 00:20:32,800
ಏಕೆ ಆ ಮಾಡುತ್ತದೆ sscanf ಒಂದು ಕ್ರಿಯೆ ಕರೆ?

339
00:20:32,800 --> 00:20:37,520
ಆದ್ದರಿಂದ sscanf ಸ್ಟ್ರಿಂಗ್ ಇದು ಲೈನ್ ಎಂದು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ವಾದವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ.

340
00:20:37,520 --> 00:20:41,310
ನಂತರ, ಉಲ್ಲೇಖಗಳಲ್ಲಿ, printf ಹೋಲುತ್ತದೆ ಸೂಚಿಸಿ

341
00:20:41,310 --> 00:20:44,960
ಈ ಸಾಲಿನಲ್ಲಿ ನೋಡಲು ಏನನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು ಇಲ್ಲ?

342
00:20:44,960 --> 00:20:52,980
ನಾನು ಇಲ್ಲಿ ಹೇಳುವ ನನಗೆ, ನಾನು ದಶಮಾಂಶ ಸಂಖ್ಯೆ ಮತ್ತು ಬಹುಶಃ ಒಂದು ಪಾತ್ರ ನೋಡಿ ನಿರೀಕ್ಷೆ.

343
00:20:52,980 --> 00:20:54,990
ಈ ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆ ಮತ್ತು ನಾವು ನೋಡುತ್ತಾರೆ.

344
00:20:54,990 --> 00:20:58,440
ಈ ಸಂಕೇತವು ಈಗ ವಿಷಯವನ್ನು ನೆನಪಿಗೆ ತರುತ್ತದೆ ಎಂದು ತಿರುಗುತ್ತದೆ

345
00:20:58,440 --> 00:21:00,840
ನಾವು ಕೇವಲ ಒಂದು ವಾರದ ಹಿಂದೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಆರಂಭಿಸುತ್ತಾನೆ.

346
00:21:00,840 --> 00:21:05,430
>> ಏನು & n ಮತ್ತು & ಸಿ ಇಲ್ಲಿ ನಮಗೆ ಏನು? [ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರಗಳನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

347
00:21:05,430 --> 00:21:07,610
>> ಹೌದು. ನನಗೆ ಸಿ ಆಫ್ n ಮತ್ತು ವಿಳಾಸ ವಿಳಾಸಕ್ಕೆ ನೀಡುವ ನ.

348
00:21:07,610 --> 00:21:10,440
ಈಗ ಏಕೆ ಮುಖ್ಯ? ಅಲ್ಲದೆ, ನೀವು ತಿಳಿದಿರುವ ಸಿ ಕ್ರಿಯೆಗಳೊಂದಿಗೆ

349
00:21:10,440 --> 00:21:13,440
ನೀವು ಯಾವಾಗಲೂ ಎಲ್ಲಾ ಒಂದು ಮೌಲ್ಯ ಅಥವಾ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಮರಳಬಹುದು.

350
00:21:13,440 --> 00:21:16,630
ನೀವು ಒಂದು int, ಸ್ಟ್ರಿಂಗ್, ಒಂದು ಫ್ಲೋಟ್, ಒಂದು ಚಾರ್, ಏನೇ ಮರಳಬಹುದು.

351
00:21:16,630 --> 00:21:21,150
ಅಥವಾ ನೀವು ಅನೂರ್ಜಿತ ಮರಳಬಹುದು, ಆದರೆ ನೀವು ಮಾತ್ರ ಗರಿಷ್ಠ 1 ವಿಷಯ ಮರಳಬಹುದು.

352
00:21:21,150 --> 00:21:26,100
ಆದರೆ ಇಲ್ಲಿ ನಾವು sscanf ಬಹುಶಃ ಒಂದು int, ಒಂದು ದಶಮಾಂಶ ಸಂಖ್ಯೆ, ನನಗೆ ಮರಳಿ ಬಯಸುವ

353
00:21:26,100 --> 00:21:29,240
ಮತ್ತು ಒಂದು ಅಕ್ಷರ, ಮತ್ತು ನಾನು ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಏಕೆ ಚಾರ್ ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

354
00:21:29,240 --> 00:21:34,250
ಆದ್ದರಿಂದ ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಎಫ್ 2 ವಿಷಯಗಳನ್ನು ಮರಳಲು ಬಯಸುವ; ಎಂದು ಸಿ ಕೇವಲ ಆಗುವುದಿಲ್ಲ

355
00:21:34,250 --> 00:21:38,460
ಆದ್ದರಿಂದ ನೀವು 2 ವಿಳಾಸಗಳನ್ನು ಸಾಗುವ ಆ ಕೆಲಸ ಮಾಡಬಹುದು

356
00:21:38,460 --> 00:21:43,710
ನೀವು ಒಂದು ಕಾರ್ಯ 2 ವಿಳಾಸಗಳನ್ನು ಹ್ಯಾಂಡ್ ಬೇಗ, ಆ ಕಾರ್ಯವನ್ನು ಅವರೊಂದಿಗೆ ಏನು ಏಕೆಂದರೆ?

357
00:21:43,710 --> 00:21:49,880
ಇದು ಆ ವಿಳಾಸಗಳನ್ನು ಬರೆಯಬಹುದು. ನೀವು * ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಮತ್ತು ಆ ವಿಳಾಸಗಳನ್ನು ಪ್ರತಿಯೊಂದು "ಅಲ್ಲಿಗೆ ಹೋಗಿ" ಮಾಡಬಹುದು.

358
00:21:49,880 --> 00:21:54,320
ಈ ಹಿಂಬಾಗಿಲ ಯಾಂತ್ರಿಕ ರೀತಿಯ, ಆದರೆ ಚರಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಗುತ್ತಿರುವ ತುಂಬಾ ಸಾಮಾನ್ಯ

359
00:21:54,320 --> 00:21:58,020
ಈ ಸಂದರ್ಭದಲ್ಲಿ 2 ಕೇವಲ 1 ಸ್ಥಾನದಲ್ಲಿ ಹೆಚ್ಚು ರಲ್ಲಿ.

360
00:21:58,020 --> 00:22:04,590
ಈಗ, ನಾನು == to1 ಪರಿಶೀಲಿಸುತ್ತಿದೆ, ಮತ್ತು ನಂತರ, ವಾಸ್ತವವಾಗಿ, ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ಇದ್ದಲ್ಲಿ N ಹಿಂದಿರುಗಿದ ನಾನು ಗಮನಿಸಿ.

361
00:22:04,590 --> 00:22:09,340
ಆದ್ದರಿಂದ ಇಂದಿನ ವಿಶೇಷವೇನು? ಅಲ್ಲದೆ, ತಾಂತ್ರಿಕವಾಗಿ, ನಾವು ನಿಜವಾಗಿಯೂ GetInt ನಡೆಯುತ್ತಿಲ್ಲ ಬಯಸುವ ಎಲ್ಲಾ ಇದು.

362
00:22:09,340 --> 00:22:12,340
ನಾವು ಮಾತನಾಡಲು, ಪಾರ್ಸ್ ಬಯಸುವ; ನಾವು ಸ್ಟ್ರಿಂಗ್ ಓದಲು ಬಯಸುವ

363
00:22:12,340 --> 00:22:16,210
"1 2 3" ಮತ್ತು ಅಲ್ಲಿ ಅನೇಕ ಕಾಣುತ್ತಿಲ್ಲ ವೇಳೆ,

364
00:22:16,210 --> 00:22:21,360
ನಾವು ಮಾಡಲು sscanf ಹೇಳುತ್ತವೆ ನನಗೆ ಈ ವೇರಿಯಬಲ್ N ಈ ಸಂಖ್ಯೆ, 1 2 3, ಹಾಕಲಾಗುತ್ತದೆ.

365
00:22:21,360 --> 00:22:26,060
ಏಕೆ, ನಂತರ ನಾನು ಮತ್ತು ಈ ಹೊಂದಿರುವಿರಿ?

366
00:22:26,060 --> 00:22:33,750
ಸಹ sscanf, ನೀವು ಇಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಸಿಗುತ್ತವೆ, ಹೇಳುವ ಪಾತ್ರವನ್ನು ಏನು.

367
00:22:33,750 --> 00:22:36,890
[ವಿದ್ಯಾರ್ಥಿ ಮಾತನಾಡುವ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ಮಾಡಿರುವುದಿಲ್ಲ - ಒಂದು ದಶಮಾಂಶ ಬಿಂದುವಿನ ಸಹಾಯಕವಾಗಿತ್ತು.

368
00:22:36,890 --> 00:22:40,650
ಒಂದು ಕ್ಷಣ ಭಾವಿಸಿದ್ದರು ನಿಲುವನ್ನು ಲೆಟ್. ಬೇರೆ ಏನು?

369
00:22:40,650 --> 00:22:42,570
[ವಿದ್ಯಾರ್ಥಿ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ಆದ್ದರಿಂದ, ಒಳ್ಳೆಯ ಆಲೋಚನೆ, ಇದು ಶೂನ್ಯಚಿಹ್ನೆ ಆಗಿರಬಹುದು.

370
00:22:42,570 --> 00:22:44,970
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಜವಾಗಿ ಅಲ್ಲ. ಯಾ? [ವಿದ್ಯಾರ್ಥಿ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. ಅಥವಾ, ನನಗೆ ಮತ್ತಷ್ಟು ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ ಅವಕಾಶ.

372
00:22:47,100 --> 00:22:49,670
ಅಲ್ಲಿ% ಸಿ ಕೇವಲ ದೋಷ ಪರಿಶೀಲನೆಗಾಗಿ ಹೊಂದಿದೆ.

373
00:22:49,670 --> 00:22:52,510
ನಾವು, ಸಂಖ್ಯೆ ನಂತರ ಅಕ್ಷರ ಇರುವಂತೆ ಬಯಸುವುದಿಲ್ಲ

374
00:22:52,510 --> 00:22:54,980
ಆದರೆ ಏನು ಈ ನನಗೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ ಕೆಳಗಿನ ಹೊಂದಿದೆ:

375
00:22:54,980 --> 00:23:01,270
ಆ sscanf, ಇಲ್ಲಿ ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, n ಮತ್ತು ಸಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಜೊತೆಗೆ, ತಿರುಗಿದರೆ

376
00:23:01,270 --> 00:23:08,170
ಇದು ಅಸ್ಥಿರ ಸಂಖ್ಯೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಹೊಂದಿದೆ ಏನು ಇದು ಸೈನ್ ಮೌಲ್ಯಗಳನ್ನು ಪುಟ್

377
00:23:08,170 --> 00:23:13,330
ನೀವು ಮಾತ್ರ ನಂತರ 1 2 3 ಟೈಪ್ ಆದ್ದರಿಂದ ಕೇವಲ% d ಹೊಂದಿಸಲು ಹೋಗುತ್ತದೆ

378
00:23:13,330 --> 00:23:18,830
ಮತ್ತು ಕೇವಲ n 1 2 3 ರೀತಿಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಸಂಗ್ರಹವಾಗಿರುವ ಮುಟ್ಟುತ್ತದೆ ಮತ್ತು ಏನೂ ಸಿ ಇರಿಸಲಾಯಿತು ಮುಟ್ಟುತ್ತದೆ;

379
00:23:18,830 --> 00:23:20,870
ಸಿ ಆದ್ದರಿಂದ ಮಾತನಾಡಲು, ಒಂದು ಕಸದ ಮೌಲ್ಯವನ್ನು ಉಳಿದಿದೆ.

380
00:23:20,870 --> 00:23:23,550
ಇದು ಕೆಲವು ಮೌಲ್ಯದ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಎಲ್ಲೂ ಕಸ ಕಾರಣ.

381
00:23:23,550 --> 00:23:29,390
ನಾನು ಆ ಪಾಯಿಂಟರ್ಗಳ ಒಂದು ಜನಸಂಖ್ಯೆಯನ್ನು ಏಕೆಂದರೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ, sscanf, 1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ

382
00:23:29,390 --> 00:23:33,650
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಉತ್ತಮ. ನಾನು ಇಂಟ್ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾನು ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಲೈನ್ ಮುಕ್ತಗೊಳಿಸಲು

383
00:23:33,650 --> 00:23:37,150
ಆ GetString ವಾಸ್ತವವಾಗಿ ಹಂಚಿಕೆ, ಮತ್ತು ನಂತರ ನಾನು N ಹಿಂತಿರುಗಿ.

384
00:23:37,150 --> 00:23:42,210
ಆ ಮರುಪ್ರಯತ್ನಿಸಿ ಅಲ್ಲಿ ನೀವು ಎಂದಾದರೂ ಯೋಚಿಸಿದ್ದೀರಾ ವೇಳೆ ಬೇರೆ, ಹೇಳಿಕೆ ಬರುತ್ತದೆ, ಇಲ್ಲಿಯೇ ಬರುತ್ತದೆ.

385
00:23:42,210 --> 00:23:45,770
ವೇಳೆ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ನಾನು, 1 2 3 foo ಟೈಪ್

386
00:23:45,770 --> 00:23:48,640
ಪಠ್ಯದ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮ, sscanf, ನೋಡಲು ಹೋಗುತ್ತದೆ

387
00:23:48,640 --> 00:23:51,500
ಎಫ್ - ooh, ooh, ಸಂಖ್ಯೆ ಸಂಖ್ಯೆ ooh, ಸಂಖ್ಯೆ ooh.

388
00:23:51,500 --> 00:23:54,190
ಮತ್ತು N 1 2 3 ಹಾಕಲು ವಿಶೇಷವೇನು.

389
00:23:54,190 --> 00:23:59,970
ಇದು ಸಿ ಎಫ್ ಪುಟ್, ತದನಂತರ 2 ಮರಳಲು ವಿಶೇಷವೇನು.

390
00:23:59,970 --> 00:24:02,980
ಹಾಗಾಗಿ, ಕೇವಲ scanf ವರ್ತನೆಯ ಮೂಲ ವ್ಯಾಖ್ಯಾನ ಬಳಸಿಕೊಂಡು ಹೊಂದಿವೆ

391
00:24:02,980 --> 00:24:06,170
ಸರಳ ರೀತಿಯಲ್ಲಿ - ಅಲ್ಲದೇ, ಮೊದಲ ನೋಟದಲ್ಲಿ ಸಂಕೀರ್ಣ, ಆದರೆ ದಿನದ ಕೊನೆಯಲ್ಲಿ,

392
00:24:06,170 --> 00:24:11,460
ಹೇಳಲು ಸರಳವಾದ ಯಾಂತ್ರಿಕ, ಅಲ್ಲಿ ಒಂದು int, ಮತ್ತು ಹಾಗಾಗಿ, ಎಂದು ನಾನು ಕಂಡು ಒಂದೇ ವಸ್ತು?

393
00:24:11,460 --> 00:24:14,950
ಮತ್ತು ಇಲ್ಲಿ ಜಾಗದಿಂದ ಉದ್ದೇಶಪೂರ್ವಕ ಹೊಂದಿದೆ. ನೀವು sscanf ದಾಖಲೆಯನ್ನು, ಓದಲು

394
00:24:14,950 --> 00:24:18,690
ಇದು ನೀವು ಆರಂಭದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ ಜಾಗದಿಂದ ತುಂಡು ಸೇರಿವೆ, ನೀವು ಹೇಳುತ್ತದೆ

395
00:24:18,690 --> 00:24:24,990
sscanf ತುಂಬಾ spacebar 1 2 3 ಹೊಡೆಯಲು, ಯಾವುದೇ ಕಾರಣದಿಂದಾಗಿ, ಬಳಕೆದಾರ ಅನುಮತಿಸುತ್ತದೆ, ಮತ್ತು ಕಾನೂನುಬದ್ಧ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

396
00:24:24,990 --> 00:24:28,310
ಅವರು ಆರಂಭದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ spacebar ಹಿಟ್ ಕೇವಲ ಏಕೆಂದರೆ, ಬಳಕೆದಾರ ನಲ್ಲಿ ಕೂಗಿ ಆಗುವುದಿಲ್ಲ

397
00:24:28,310 --> 00:24:32,160
ಇದು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಕೇವಲ ಸ್ವಲ್ಪ ಹೆಚ್ಚು.

398
00:24:32,160 --> 00:24:34,160
>> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು, ನಂತರ, GetInts ಮೇಲೆ? ಯಾ?

399
00:24:34,160 --> 00:24:36,820
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

400
00:24:36,820 --> 00:24:40,740
>> ಒಳ್ಳೆಯ ಪ್ರಶ್ನೆ. ನೀವು ಕೇವಲ ಒಂದು ಚಾರ್ ಬೆರಳಚ್ಚಿಸಿದ ವೇಳೆ, ಎಫ್, ಮತ್ತು ಹಿಟ್ ತರಹದ ನಮೂದಿಸಿ ಏನು

401
00:24:40,740 --> 00:24:47,830
ಇದುವರೆಗೆ 1 2 3 ಟೈಪ್ ಇಲ್ಲದೆ; ನೀವು ಕೋಡ್ ಈ ಸಾಲಿನ ವರ್ತನೆಯನ್ನು ನಂತರ ಎಂಬುದನ್ನು ತಿಳಿದಿರುವಿರಿ?

402
00:24:47,830 --> 00:24:50,500
ಆದ್ದರಿಂದ sscanf, ತುಂಬಾ ಎಂದು ರಕ್ಷಣೆ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆಂದರೆ,

403
00:24:50,500 --> 00:24:56,280
ಇದು N ಅಥವಾ ಸಿ ತುಂಬಲು ಹಿಂದಿರುಗಬಹುದೆಂದು; ಬದಲು 0 ಮರಳಲು ವಿಶೇಷವೇನು.

404
00:24:56,280 --> 00:25:01,540
ನಾನು ಬಯಸುವ ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯ 1 ಏಕೆಂದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಸಹ, ಆ ಸನ್ನಿವೇಶದಲ್ಲಿ ಹಿಡಿಯುತ್ತಿರುವ ನುಡಿದರು.

405
00:25:01,540 --> 00:25:07,310
ನಾನು ಕೇವಲ 1 ಬಯಸುವ, ಮತ್ತು ಕೇವಲ 1 ವಿಷಯ ಮುಚ್ಚಬೇಕಾಗುತ್ತದೆ. ಪ್ರಶ್ನೆ ಉತ್ತಮ. ಇತರೆ?

406
00:25:07,310 --> 00:25:09,610
>> ಸರಿ, ಇಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿ ನಿಲ್ಲಿಸೋಣ,

407
00:25:09,610 --> 00:25:11,820
ಆದರೆ ಉಳಿದ ಆಸಕ್ತಿ, ಬಹುಶಃ, ತೋರುತ್ತದೆ ಒಂದು

408
00:25:11,820 --> 00:25:14,530
ಇದನ್ನು ತಿರುಗುತ್ತದೆ ಏಕೆಂದರೆ GetString ನಿಗದಿಪಡಿಸಲಾಗಿದೆ GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
ಎಲ್ಲಾ ಓಡ GetString ತಮ್ಮ ಕಾರ್ಯವನ್ನು ಸಾಕಷ್ಟು GetLongLong, GetDouble.

410
00:25:19,490 --> 00:25:22,860
ಆದ್ದರಿಂದ ಅವನು ಇಲ್ಲಿ ಜಾರಿಗೆ ಇದೆ ಹೇಗೆ ಅವಲೋಕಿಸೋಣ.

411
00:25:22,860 --> 00:25:27,040
ಈ ಒಂದು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಕಾಣುತ್ತದೆ ಆದರೆ ಅದೇ ಮೂಲಭೂತ ಬಳಸುತ್ತದೆ

412
00:25:27,040 --> 00:25:29,680
ನಾವು ಕಳೆದ ವಾರ ಬಗ್ಗೆ ಆರಂಭಿಸಿದರು. ಆದ್ದರಿಂದ GetString ರಲ್ಲಿ,

413
00:25:29,680 --> 00:25:32,670
ಇದು ಅಪ್ ಇಲ್ಲಿ ಅನೂರ್ಜಿತ ಪ್ರಕಾರ ಯಾವುದೇ ವಾದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

414
00:25:32,670 --> 00:25:37,110
ಹಾಗೂ ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ; ಆದ್ದರಿಂದ ನಾನು ಬಫರ್ ಎಂಬ ವಾಕ್ಯವನ್ನು ಘೋಷಿಸಿ ನಾನು.

415
00:25:37,110 --> 00:25:39,670
ನಾನು ಎಂದು ಇನ್ನೂ ಬಳಸಬಹುದಾಗಿದೆ ವಿಶೇಷವೇನು ಏನು ಗೊತ್ತಿಲ್ಲ, ಆದರೆ ನಾವು ನೋಡುತ್ತಾರೆ.

416
00:25:39,670 --> 00:25:42,950
ಸಾಮರ್ಥ್ಯ ತೋರುತ್ತಿದೆ ಡೀಫಾಲ್ಟ್, 0 ಮೂಲಕ ಹೊಂದಿದೆ; ಈ ಹೋಗಿ ಅಲ್ಲಿ ಖಾತ್ರಿ ಇಲ್ಲ.

417
00:25:42,950 --> 00:25:44,920
ಮಾಡಿರುವುದಿಲ್ಲ N ಇನ್ನೂ ಬಳಸಲಾಗುತ್ತದೆ ಹೋಗುವ ಏನನ್ನು ಖಚಿತವಾಗಿ.

418
00:25:44,920 --> 00:25:47,860
ಆದರೆ ಈಗ, ಆದ್ದರಿಂದ ಸಾಲಿನ 243 ರಲ್ಲಿ, ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಸಕ್ತಿಕರ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ

419
00:25:47,860 --> 00:25:51,760
ನಾವು ಒಂದು ಇಂಟ್ ಸಿ, ಈ ಒಂದು ಸ್ಟುಪಿಡ್ ವಿವರದ ತೆರನಾದ ಘೋಷಿಸಿದ.

420
00:25:51,760 --> 00:25:58,080
ಎ ಚಾರ್ 8 ಬಿಟ್ಗಳು, ಮತ್ತು 8 ಬಿಟ್ಗಳು ಎಷ್ಟು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು?

421
00:25:58,080 --> 00:26:03,310
256. ನೀವು 256 ವಿವಿಧ ASCII ಅಕ್ಷರಗಳನ್ನು ಬೇಕು ವೇಳೆ ತೊಂದರೆ ಆಗಿದೆ

422
00:26:03,310 --> 00:26:06,210
ಇದು ಅಲ್ಲಿ ನೀವು ಭಾವಿಸಿದರೆ, ಮತ್ತು ಈ ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಏನೋ ಅಲ್ಲ.

423
00:26:06,210 --> 00:26:09,100
ಆ ದೊಡ್ಡ ASCII ಪಟ್ಟಿಯಲ್ಲಿ ಮರಳಿ ಭಾವಿಸುತ್ತೇನೆ ಆದರೆ ನಾವು ವಾರಗಳ ಹಿಂದೆ ಹೊಂದಿದ್ದ,

424
00:26:09,100 --> 00:26:13,780
ಆ ಸಂದರ್ಭದಲ್ಲಿ, 128 ಅಥವಾ 256 ASCII ಅಕ್ಷರಗಳನ್ನು ರಲ್ಲಿ, ಇದ್ದವು.

425
00:26:13,780 --> 00:26:16,220
ನಾವು 0 ದ ಮಾದರಿಗಳನ್ನು ಮತ್ತು 1 ಬಿಟ್ಟಿದ್ದು ಬಳಸಲಾಗುತ್ತದೆ.

426
00:26:16,220 --> 00:26:19,410
ನೀವು ದೋಷ ಪತ್ತೆ ಮಾಡಲು ಬಯಸಿದರೆ ಒಂದು ಸಮಸ್ಯೆ.

427
00:26:19,410 --> 00:26:23,290
ನೀವು ಈಗಾಗಲೇ ನಿಮ್ಮ ಪಾತ್ರಗಳಿಗೆ 256 ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಏಕೆಂದರೆ,

428
00:26:23,290 --> 00:26:26,390
ಈಗ ನೀವು ಹೇಳುವ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಏಕೆಂದರೆ ನೀವು ನಿಜವಾಗಿಯೂ, ಮುಂದೆ ಯೋಜನೆ ಇಲ್ಲ

429
00:26:26,390 --> 00:26:29,750
"ಈ ಒಂದು ಅಸಲಿ ಅಕ್ಷರವಾಗಿದೆ; ಈ ಕೆಲವು ತಪ್ಪಾದ ಸಂದೇಶವಾಗಿದೆ."

430
00:26:29,750 --> 00:26:32,430
ಹಾಗಾಗಿ ವಿಶ್ವದ ಹೊಂದಿದವರಿಗೆ, ಮುಂದಿನ ದೊಡ್ಡ ಮೌಲ್ಯವನ್ನು ಬಳಸುತ್ತಾರೆ,

431
00:26:32,430 --> 00:26:35,790
ಒಂದು ಇಂಟ್ ರೀತಿಯ ನೀವು ಬಿಟ್ಗಳು ಒಂದು ಕ್ರೇಜಿ ಸಂಖ್ಯೆಯ ಆದ್ದರಿಂದ,

432
00:26:35,790 --> 00:26:39,610
4 ಶತಕೋಟಿ ಸಾಧ್ಯವಿರುವ ಮೌಲ್ಯಗಳನ್ನು 32, ಆದ್ದರಿಂದ ನೀವು ಸುಮ್ಮನೆ, ಬಳಸಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡಬಹುದು

433
00:26:39,610 --> 00:26:44,800
ಮೂಲಭೂತವಾಗಿ, ಅವುಗಳಲ್ಲಿ 257, 1 ಇದು ಒಂದು ದೋಷ ಕೆಲವು ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿದೆ.

434
00:26:44,800 --> 00:26:49,190
>> ಇದರಿಂದ ಹೇಗೆ ಈ ಕೆಲಸಗಳನ್ನು ನೋಡೋಣ. ಲೈನ್ 246 ರಲ್ಲಿ, ಈ ದೊಡ್ಡ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಹೊಂದಿವೆ

435
00:26:49,190 --> 00:26:54,530
ಆ fgetc ಕರೆ ಇದೆ; ನಂತರ ಎಫ್ ಅರ್ಥ ಕಡತ, getc, ಮತ್ತು stdin.

436
00:26:54,530 --> 00:26:59,030
ಈ ಕೇವಲ ಹೇಳುವ ಹೆಚ್ಚು ನಿಖರ ಮಾರ್ಗವಾಗಿದೆ ತಿರುಗಿದರೆ "ಕೀಬೋರ್ಡ್ ಸೂಚನೆಗಳನ್ನು ಓದಿ."

437
00:26:59,030 --> 00:27:02,730
ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸಾಧನವಾಗಿ ಕೀಬೋರ್ಡ್, ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್, ಪರದೆಯ ಅರ್ಥ

438
00:27:02,730 --> 00:27:06,920
ಮತ್ತು ನಾವು pset 4 ನೋಡುತ್ತಾರೆ ಇದು ಸಾಮಾನ್ಯ ದೋಷ, ಪರದೆಯ ಅರ್ಥ

439
00:27:06,920 --> 00:27:09,670
ಆದರೆ ಇದನ್ನು ತೆರೆಯ ವಿಶೇಷ ಭಾಗವನ್ನು ಒಟ್ಟುಗೂಡಿಸಿ ದೊರೆಯದಿದ್ದಲ್ಲಿ ಆದ್ದರಿಂದ

440
00:27:09,670 --> 00:27:13,760
ನೀವು ಮುದ್ರಿಸಬೇಕೆಂದು ಉದ್ದೇಶವನ್ನು ನಿಜವಾದ ಔಟ್ಪುಟ್ನೊಂದಿಗೆ; ಆದರೆ ಭವಿಷ್ಯದಲ್ಲಿ ಮೇಲೆ ಹೆಚ್ಚು.

441
00:27:13,760 --> 00:27:19,430
ಆದ್ದರಿಂದ fgetc ಕೇವಲ ಕೀಬೋರ್ಡ್ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು, ಮತ್ತು ಅಲ್ಲಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ಅರ್ಥ?

442
00:27:19,430 --> 00:27:24,000
ಸಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಿ, ನಂತರ ಪರಿಶೀಲಿಸಿ, ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲಿ ಕೆಲವು ಬೂಲಿಯನ್ ಸಂಯೋಗಗಳು ಬಳಸಿಕೊಂಡು ನಾನು,

443
00:27:24,000 --> 00:27:28,430
ಇದು N, ಆದ್ದರಿಂದ ಬಳಕೆದಾರರು ನಮೂದಿಸಿ ಬಾರಿಸಿದ್ದಾರೆ \ ಸಮಾನ ಮಾಡುವುದಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸಿ.

444
00:27:28,430 --> 00:27:31,510
ನಾವು ಆ, ಲೂಪ್ ಕೊನೆಯಲ್ಲಿ ನಿಲ್ಲಿಸಲು ಬಯಸುವ, ಮತ್ತು ನಾವು ಪರಿಶೀಲಿಸಿ ಬಯಸುವ

445
00:27:31,510 --> 00:27:36,170
ನೀವು ತಿಳಿದುಕೊಳ್ಳಲು ಅಥವಾ ಊಹಿಸಲು ವೇಳೆ ವಿಶೇಷ ನಿಯತಾಂಕ EOF, - ಇದು ಯಾವ ಉದ್ಧೇಶವೇನು?

446
00:27:36,170 --> 00:27:39,860
ಕಡತದ ಕೊನೆಯಲ್ಲಿ. ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಭಾವಿಸುತ್ತೇನೆ ವೇಳೆ ಏಕೆಂದರೆ ಈ, ಅಸಂಬದ್ಧ ರೀತಿಯ

447
00:27:39,860 --> 00:27:41,900
ಈ ಒಳಗೊಂಡಿರುವ ಯಾವುದೇ ಕಡತ, ನಿಜವಾಗಿಯೂ ಇಲ್ಲ

448
00:27:41,900 --> 00:27:44,330
ಆದರೆ ಕೇವಲ ಬಳಸಲಾಗುತ್ತದೆ ಜೆನೆರಿಕ್ ಪದದ ವಿಂಗಡಿಸಲು ಇದೆ

449
00:27:44,330 --> 00:27:50,320
ಬೇರೆ ಯಾವುದೂ ಮಾನವನ ಬೆರಳುಗಳು ಬರುವ ಇದೆ. EOF. ಕಡತದ ಕೊನೆಯಲ್ಲಿ.

450
00:27:50,320 --> 00:27:52,600
ಅತ್ತ, ನೀವು ಎಂದಾದರೂ ನಿಮ್ಮ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ನಿಯಂತ್ರಣ D ಹೊಡೆಯಲು ನೀವು,

451
00:27:52,600 --> 00:27:54,680
ನೀವು ಇನ್ನೂ ಹೊಂದಿದೆ ಎಂದು; ನೀವು ನಿಯಂತ್ರಣ ಸಿ ಹಿಟ್ ಮಾಡಿದ.

452
00:27:54,680 --> 00:27:57,920
ಆದರೆ ನಿಯಂತ್ರಣ ಇಷ್ಟಪಟ್ಟಿದ್ದಾರೆ ವಿಶೇಷ ಸ್ಥಿರ ಎಂಬ EOF ಕಳುಹಿಸುತ್ತದೆ.

453
00:27:57,920 --> 00:28:03,100
>> ಈಗ ನಾವು ಕೆಲವು ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಹೊಂದಿರುತ್ತವೆ.

454
00:28:03,100 --> 00:28:06,460
N + 1> ಸಾಮರ್ಥ್ಯ, ಈಗ ನಾನು N ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ ಆದ್ದರಿಂದ.

455
00:28:06,460 --> 00:28:09,380
N ಕೇವಲ ಎಷ್ಟು ಬೈಟ್ಗಳು, ಬಫರ್ ಪ್ರಸ್ತುತ ಇದೆ

456
00:28:09,380 --> 00:28:11,970
ನೀವು ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರ ನಿರ್ಮಿಸುವ ನೀವು ಸ್ಟ್ರಿಂಗ್.

457
00:28:11,970 --> 00:28:16,240
ನೀವು ಬಫರ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುವ ಹೆಚ್ಚು ನಿಮ್ಮ ಬಫರ್ ಹೆಚ್ಚು ಪಾತ್ರಗಳು ಹೊಂದಿದ್ದರೆ,

458
00:28:16,240 --> 00:28:20,760
ಅಂತರ್ದೃಷ್ಟಿಯಿಂದ ನಾವು ನಂತರ ಅಗತ್ಯವಾಗಿ ಹೆಚ್ಚು ಸಾಮರ್ಥ್ಯವನ್ನು ನಿಯೋಜಿಸಿ ಇದೆ.

459
00:28:20,760 --> 00:28:24,490
ನಾನು ಇಲ್ಲಿ ಅಂಕಗಣಿತದ ಕೆಲವು ಮೇಲೆ ಕೆನೆರಹಿತ ಪಡೆಯಲಿದ್ದೇನೆ

460
00:28:24,490 --> 00:28:26,900
ಮತ್ತು ಇಲ್ಲಿ ಮಾತ್ರ ಈ ಕಾರ್ಯವನ್ನು ಗಮನ.

461
00:28:26,900 --> 00:28:29,170
ನೀವು malloc ಏನೆಂಬುದನ್ನು ತಿಳಿಯುವುದು, ಅಥವಾ ಕನಿಷ್ಠ ಸಾಮಾನ್ಯವಾಗಿ ಚಿರಪರಿಚಿತವಾಗಿದೆ.

462
00:28:29,170 --> 00:28:32,380
Realloc ಏನು ಒಂದು ಊಹೆ ತೆಗೆದುಕೊಳ್ಳಿ. [ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

463
00:28:32,380 --> 00:28:35,690
>> ಹೌದು. ಮತ್ತು ಅದು ಸಾಕಷ್ಟು ಸ್ಮೃತಿಯಲ್ಲಿ ದೊರೆಯದಿದ್ದಲ್ಲಿ ಇದು ಕೆಳಕಂಡಂತೆ ಮೆಮೊರಿ reallocates:

464
00:28:35,690 --> 00:28:40,530
ಆ ಮೆಮೊರಿ ಹೆಚ್ಚು ನೀಡಲು ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ಕೊಠಡಿ ಇನ್ನೂ ವೇಳೆ

465
00:28:40,530 --> 00:28:43,370
ಇದು ಮೂಲತಃ ನೀವು ನೀಡುತ್ತದೆ, ನಂತರ ನೀವು ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಪಡೆಯುತ್ತೀರಿ.

466
00:28:43,370 --> 00:28:46,640
ಆದ್ದರಿಂದ ನೀವು ಹಿಂದಕ್ಕೆ ಮರಳಿ ಮರಳಿ ಮರಳಿ ತಂತಿಗಳನ್ನು ಪಾತ್ರಗಳು ಪುಟ್ಟಿಂಗ್ ಮಾಡಬಹುದು.

467
00:28:46,640 --> 00:28:49,290
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ ಆದರೆ, ಏಕೆಂದರೆ ನೀವು ಬಹಳ ವಿಳಂಬ

468
00:28:49,290 --> 00:28:51,700
ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ಏನೋ ಮೆಮೊರಿಗೆ plopped ಪಡೆದರು, ಆದರೆ ಹೆಚ್ಚುವರಿ ಇಲ್ಲ

469
00:28:51,700 --> 00:28:56,480
ಇಲ್ಲಿ ಕೆಳಗೆ ಮೆಮೊರಿ ಆ ಸರಿಯಾಗಿಯೆ. Realloc, ನೀವು ಎಲ್ಲಾ ಭಾರೀ ತರಬೇತಿ ಮಾಡಲು ಹೋಗುತ್ತದೆ

470
00:28:56,480 --> 00:28:58,810
, ನೀವು ಇದುವರೆಗಿನ ಇಲ್ಲಿಂದ ರಲ್ಲಿ ಓದಿದ ಸ್ಟ್ರಿಂಗ್ ಸರಿಸಲು

471
00:28:58,810 --> 00:29:02,550
ಇಲ್ಲಿ ಬರೆಯಿರಿ, ಮತ್ತು ನಂತರ ನೀವು ಆ ಸಮಯದಲ್ಲಿ ಕೆಲವು ಹೆಚ್ಚು ರನ್ವೇ ನೀಡಿ.

472
00:29:02,550 --> 00:29:05,610
ಆದ್ದರಿಂದ ಕೈ ಅಲೆಗಳು, ನನಗೆ ಏನು GetString ಮಾಡುವುದರಿಂದ ಎಂದು ಹೇಳಲು ಅವಕಾಶ

473
00:29:05,610 --> 00:29:09,540
ಇದು ಒಂದು ಸಣ್ಣ ಬಫರ್, ಬಹುಶಃ 1 ಏಕ ಪಾತ್ರ, ಜೊತೆಗೆ ಶುರುವಾಗುತ್ತಿದೆ ಇದೆ

474
00:29:09,540 --> 00:29:12,300
ಮತ್ತು 2 ಪಾತ್ರಗಳು ಬಳಕೆದಾರ ರೀತಿಯ ವೇಳೆ, GetString ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ

475
00:29:12,300 --> 00:29:15,210
realloc ಕರೆದು Ooh ', ಹೇಳುತ್ತಾರೆ, 1 ಅಕ್ಷರ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

476
00:29:15,210 --> 00:29:18,480
ನನಗೆ 2 ಪಾತ್ರಗಳು ನೀಡಿ. ' ನೀವು, ಲೂಪ್ ನ ತರ್ಕ ಓದಲು ನಂತರ ವೇಳೆ

477
00:29:18,480 --> 00:29:21,070
ಇದು, Ooh ', 3 ಪಾತ್ರಗಳು ಬೆರಳಚ್ಚಿಸಿದ ಬಳಕೆದಾರ ಹೇಳಲು ವಿಶೇಷವೇನು.

478
00:29:21,070 --> 00:29:25,690
ಈಗ ಇಲ್ಲ 2 ಆದರೆ 4 ಪಾತ್ರಗಳು ನನಗೆ ನೀಡಿ, ಆಗ ನನಗೆ 16 ಮತ್ತು 32 ನೀಡಿ ನಂತರ, ನನ್ನ 8 ನೀಡಿ. '

479
00:29:25,690 --> 00:29:28,180
ನಾನು ಸಾಮರ್ಥ್ಯವನ್ನು ಪ್ರತಿ ಬಾರಿ ದುಪ್ಪಟ್ಟುಗೊಳಿಸುವುದರಿಂದ ನಾನು ವಾಸ್ತವವಾಗಿ

480
00:29:28,180 --> 00:29:30,320
ಬಫರ್ ನಿಧಾನವಾಗಿ ಬೆಳೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಎಂಬುದು ಇದರರ್ಥ.

481
00:29:30,320 --> 00:29:35,870
ಇದು ಅತೀ ವೇಗದ ಬೆಳೆಯಲು ವಿಶೇಷವೇನು, ಮತ್ತು ಪ್ರಯೋಜನವನ್ನು ಇರಬಹುದು ಏನು?

482
00:29:35,870 --> 00:29:38,540
ನಾನು ಬಳಕೆದಾರ ಸಹ ಬಫರ್ ಗಾತ್ರದ ಡಬಲ್ ನಾನು

483
00:29:38,540 --> 00:29:41,450
ಕೇವಲ ಕೀಬೋರ್ಡ್ ನಿಂದ 1 ಹೆಚ್ಚುವರಿ ಪಾತ್ರ ಬೇಕು?

484
00:29:41,450 --> 00:29:44,830
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]. >> ಏನು ಎಂದು ಈಸ್?

485
00:29:44,830 --> 00:29:46,750
ನಿಖರವಾಗಿ. ನೀವು ಅದರ ಬೆಳವಣಿಗೆ ಹೊಂದಿಲ್ಲ.

486
00:29:46,750 --> 00:29:48,870
ಮತ್ತು ಇದು ಕೇವಲ ರೀತಿಯ - you're ಇಲ್ಲಿ ನಿಮ್ಮ ಪಂತಗಳನ್ನು ನಷ್ಟದ.

487
00:29:48,870 --> 00:29:54,150
ಕಲ್ಪನೆಯನ್ನು ನಿಧಾನ ಕಾಣುತ್ತಾರೆ ಕಾರಣ ನೀವು, realloc ಸಾಕಷ್ಟು ಕರೆ ಬಯಸುವುದಿಲ್ಲ ಎಂಬುದು.

488
00:29:54,150 --> 00:29:56,840
ನೀವು ಬೇಗನೆ ನೋಡುತ್ತಾರೆ ಎಂದು ನೀವು ಮೆಮೊರಿಗೆ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕೇಳಿ ಯಾವುದೇ ಸಮಯ

489
00:29:56,840 --> 00:30:00,620
ಮುಂದಿನ ಸಮಸ್ಯೆ ಸೆಟ್, ಇದು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಒಲವು.

490
00:30:00,620 --> 00:30:04,980
ನೀವು ಕೆಲವು ಜಾಗವನ್ನು ಹಾಳುಮಾಡುತ್ತಿದೆ ನೀವು ಸಹ, ಆ ಪ್ರಮಾಣವನ್ನು ತಗ್ಗಿಸುತ್ತದೆ ಆದ್ದರಿಂದ, ಒಂದು ರೀತಿಯಲ್ಲಿ ಒಳ್ಳೆಯದೇ ಒಲವು.

491
00:30:04,980 --> 00:30:07,250
>> ಆದರೆ ನಾವು ಇಲ್ಲಿ GetString ಅಂತಿಮ ಭಾಗದ ಮೂಲಕ ಓದಲು,

492
00:30:07,250 --> 00:30:10,880
ಮತ್ತೆ, ಇಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಲಿನ ಅರ್ಥ ಇಂದು ತುಂಬಾ ಮುಖ್ಯವಾಗಿದೆ.

493
00:30:10,880 --> 00:30:14,830
ಆದರೆ ಅಂತಿಮವಾಗಿ ಮತ್ತೆ malloc ಅಪೇಕ್ಷಿಸುವ ಗಮನಿಸಿ, ಮತ್ತು ಇದನ್ನು ವಿಂಗಡಿಸಿ

494
00:30:14,830 --> 00:30:16,980
ಇದು ಸ್ಟ್ರಿಂಗ್ ಅನೇಕ ಬೈಟ್ಗಳು ಅಗತ್ಯವಿದೆ ಎಂದು ನಿಖರವಾಗಿ ಮಾಹಿತಿ

495
00:30:16,980 --> 00:30:21,620
ಮತ್ತು ನಂತರ ಹೆಚ್ಚು ದೊಡ್ಡ ಬಫರ್, ಉಚಿತ ಕರೆದು ದೂರ ಎಸೆಯುತ್ತಾನೆ

496
00:30:21,620 --> 00:30:23,510
ಇದು ನಿಜವಾಗಿಯೂ ಹಲವಾರು ಬಾರಿ ದುಪ್ಪಟ್ಟು ಪಡೆದುಕೊಂಡಿದೆ ವೇಳೆ.

497
00:30:23,510 --> 00:30:25,970
ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳಬೇಕೆಂದರೆ, ಆ GetString ಎಲ್ಲಾ ಈ ಕೆಲಸ ಮಾಡಲಾಗಿದೆ ಹೇಗೆ.

498
00:30:25,970 --> 00:30:30,100
ಅದು ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತೆ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರ ಓದಲು

499
00:30:30,100 --> 00:30:37,930
ಮತ್ತು ಕೆಲವು ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿ ಅಗತ್ಯವಿದೆ ಪ್ರತಿ ಬಾರಿ, ಇದು realloc ಕರೆದು ಅದಕ್ಕೆ ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಕೇಳುತ್ತದೆ.

500
00:30:37,930 --> 00:30:41,660
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಎಲ್ಲಾ ಸರಿ.

501
00:30:41,660 --> 00:30:45,220
>> ದಾಳಿ. ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಅರ್ಥ ಈಗ ಎಂದು, ಅಥವಾ ಕನಿಷ್ಠ

502
00:30:45,220 --> 00:30:47,560
, ಪಾಯಿಂಟರ್ಸ್ ಹೆಚ್ಚು ತಿಳಿದಿದೆ

503
00:30:47,560 --> 00:30:50,020
ಇಡೀ ವಿಶ್ವದ ಕುಸಿಯಲು ಆರಂಭಿಸುತ್ತದೆ ಹೇಗೆ ಪರಿಗಣಿಸೋಣ

504
00:30:50,020 --> 00:30:53,160
ನೀವು ತುಂಬಾ ವ್ಯತಿರಿಕ್ತ ಬಳಕೆದಾರರು ರಕ್ಷಿಸಿಕೊಳ್ಳಲು ಇದ್ದರೆ,

505
00:30:53,160 --> 00:30:55,180
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಹ್ಯಾಕ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವ ಜನರು.

506
00:30:55,180 --> 00:31:00,260
ಕೆಲವು ನೋಂದಣಿ ಕೋಡ್ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಿಮ್ಮ ಸಾಫ್ಟ್ವೇರ್ ಕದಿಯಲು ಪ್ರಯತ್ನಿಸುವ ಜನರು

507
00:31:00,260 --> 00:31:02,150
ಇಲ್ಲದಿದ್ದರೆ ಸೈನ್ ಟೈಪ್ ಮಾಡಬೇಕು ಎಂದು

508
00:31:02,150 --> 00:31:04,860
ಕೇವಲ ಸಿ ಕೋಡ್ ಇದು, ಇಲ್ಲಿ ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ

509
00:31:04,860 --> 00:31:07,920
ಎಂದು ಕೆಳಭಾಗದಲ್ಲಿ ಮುಖ್ಯ ಕ್ರಿಯೆಯಾಗಿದೆ ಹೊಂದಿದೆ, ಎಂದು, ಒಂದು ಕಾರ್ಯ foo ​​ಕರೆಗಳು

510
00:31:07,920 --> 00:31:12,100
ಮತ್ತು ಅದರ foo ಹಾದು ಇದೆ? [ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ವಾದ.

511
00:31:12,100 --> 00:31:15,660
>> ಏಕ ವಾದ. ಆದ್ದರಿಂದ argv [1], ಇದು ಬಳಕೆದಾರ ಟೈಪಿಸಿದ ಮೊದಲ ಪದದ ಅರ್ಥ

512
00:31:15,660 --> 00:31:19,150
a.out ಅಥವಾ ಯಾವುದೇ ನಂತರ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

513
00:31:19,150 --> 00:31:24,920
Foo ಆದ್ದರಿಂದ, ಮೇಲೆ, ಒಂದು ಚಾರ್ * ರಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಚಾರ್ * ಕೇವಲ ಏನು?

514
00:31:24,920 --> 00:31:28,860
ಸ್ಟ್ರಿಂಗ್. ಅಲ್ಲಿ ಹೊಸ ಏನೂ ಇಲ್ಲಿ, ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ನಿರಂಕುಶವಾಗಿ ಬಾರ್ ಎಂದು ಮಾಡಲಾಗುತ್ತಿದೆ.

515
00:31:28,860 --> 00:31:36,090
ಇಲ್ಲಿ ಈ ಸಾಲಿನಲ್ಲಿ, ಚಾರ್ ಸಿ [12], ಅರೆ ತಾಂತ್ರಿಕ ಇಂಗ್ಲೀಷ್ ರೀತಿಯ ರಲ್ಲಿ, ಈ ಸಾಲಿನ ಮಾಡುತ್ತಿರುವುದಾದರೂ ಏನು?

516
00:31:36,090 --> 00:31:40,640
ವ್ಯೂಹವನ್ನು -? ಪಾತ್ರಗಳು. ನನಗೆ 12 ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿ.

517
00:31:40,640 --> 00:31:44,970
ಆದ್ದರಿಂದ ನಾವು ಈ ಒಂದು ಬಫರ್ ಕರೆ ಇರಬಹುದು. ಇದು ತಾಂತ್ರಿಕವಾಗಿ ಸಿ ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಬಫರ್ ವಿಶೇಷವೇನು

518
00:31:44,970 --> 00:31:47,890
ಕೇವಲ ನೀವು ಕೆಲವು ಸಂಗತಿಗಳನ್ನು ಸೈನ್ ಆ ಜಾಗವನ್ನು ಒಂದು ಗುಂಪೇ ಅರ್ಥ

519
00:31:47,890 --> 00:31:49,940
>> ನಂತರ ಕೊನೆಯದಾಗಿ, memcpy, ನಾವು ಮೊದಲು ಬಳಸದೆ ಮಾಡಿದ.

520
00:31:49,940 --> 00:31:52,380
ಆದರೆ ನೀವು ಬಹುಶಃ ಏನು ಊಹೆ ಮಾಡಬಹುದು. ಇದು ಮೆಮೊರಿ ನಕಲಿಸುತ್ತದೆ.

521
00:31:52,380 --> 00:31:58,790
ಅದು ಏನು ಮಾಡುತ್ತದೆ? ಅಲ್ಲದೆ, ಇದು ಸ್ಪಷ್ಟವಾಗಿ, ಸಿ ಗೆ, ಇದರ ಇನ್ಪುಟ್, ಬಾರ್ ನಕಲಿಸುತ್ತದೆ

522
00:31:58,790 --> 00:32:03,420
ಆದರೆ ಮಾತ್ರ ಪಟ್ಟಿಯ ಉದ್ದ.

523
00:32:03,420 --> 00:32:07,440
ಆದರೆ ಇಲ್ಲಿ ಒಂದು ದೋಷ ಇಲ್ಲ.

524
00:32:07,440 --> 00:32:14,500
ಸರಿ, ಆದ್ದರಿಂದ ತಾಂತ್ರಿಕವಾಗಿ ನಾವು (ಬಾರ್) ಸರಿಯಾದ ಎಂದು X sizeof (ಅಕ್ಷರ), strlen ಮಾಡಬೇಕು.

525
00:32:14,500 --> 00:32:17,920
ಆದರೆ ಇಲ್ಲಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರ ಆ that's ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ - ಆದ್ದರಿಂದ, ಸರಿ.

526
00:32:17,920 --> 00:32:23,760
ನಂತರ 2 ದೋಷಗಳನ್ನು ಇಲ್ಲ. ಆದ್ದರಿಂದ sizeof (ಅಕ್ಷರ), ಸರಿ, ಇದನ್ನು ಸ್ವಲ್ಪ ಅಗಲವಾದ ಮಾಡೋಣ.

527
00:32:23,760 --> 00:32:28,860
ಆದ್ದರಿಂದ ಈಗ ಇದು ಒಂದು ದೋಷವನ್ನು, ಇನ್ನೂ?

528
00:32:28,860 --> 00:32:31,630
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಯಾವ >> ಚೆಕ್? ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ತಪಾಸಣೆ ಮಾಡಬೇಕು

529
00:32:31,630 --> 00:32:35,010
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು, ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಸಂದರ್ಭದಲ್ಲಿ ಕೆಟ್ಟ ಘಟನೆಗಳು ಸಂಭವಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ,

530
00:32:35,010 --> 00:32:38,490
ನೀವು ಹೋಗುವ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಎಂದು, ಮತ್ತು ನೀವು ಎಂದಾದರೂ ಶೂನ್ಯ ಹೋಗುವ ಮಾಡಬಾರದು ಏಕೆಂದರೆ

531
00:32:38,490 --> 00:32:40,890
* ಆಯೋಜಕರು ಅದನ್ನು dereferencing ಅದಕ್ಕೆ.

532
00:32:40,890 --> 00:32:45,250
ಆದ್ದರಿಂದ ಒಳ್ಳೆಯದು, ಮತ್ತು ನಾವು ಬೇರೆ ಏನು ಮಾಡುತ್ತಿದ್ದಿಯಾ? ತಾರ್ಕಿಕವಾಗಿ ಒಂದು ನ್ಯೂನತೆಯು ತುಂಬಾ ಇಲ್ಲಿ ಇಲ್ಲ.

533
00:32:45,250 --> 00:32:47,650
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

534
00:32:47,650 --> 00:32:51,340
>> ಆದ್ದರಿಂದ argc ≥ 2 ಪರಿಶೀಲಿಸಿ?

535
00:32:51,340 --> 00:32:54,130
ಸರಿ, ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ 3 ದೋಷಗಳನ್ನು ಇಲ್ಲಿ ಇಲ್ಲ ಆದ್ದರಿಂದ.

536
00:32:54,130 --> 00:33:00,080
ಬಳಕೆದಾರ ವಾಸ್ತವಿಕವಾಗಿ argv [1], ಉತ್ತಮ ಒಳಗೆ ಏನು ಬೆರಳಚ್ಚಿಸಿದ ನಾವು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದೇವೆ ಇಲ್ಲ.

537
00:33:00,080 --> 00:33:02,240
ಆದ್ದರಿಂದ ಮೂರನೇ ದೋಷ ಎಂಬುದರ? ಯಾ?

538
00:33:02,240 --> 00:33:04,420
ಗುಡ್ [ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >>.

539
00:33:04,420 --> 00:33:09,590
ನಾವು ಒಂದು ಸನ್ನಿವೇಶದಲ್ಲಿ ಪರಿಶೀಲಿಸಿದ. ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ ಹೆಚ್ಚು ಮೆಮೊರಿ ನಕಲಿಸಬೇಡಿ ಪರಿಶೀಲಿಸಿದ

540
00:33:09,590 --> 00:33:12,800
ಬಾರ್ ಉದ್ದವನ್ನು ಮೀರುತ್ತದೆ ಹೆಚ್ಚು.

541
00:33:12,800 --> 00:33:15,720
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ ಬೆರಳಚ್ಚಿಸಿದ ಬಳಕೆದಾರ 10 ಪಾತ್ರಗಳು ಉದ್ದವಾಗಿದೆ,

542
00:33:15,720 --> 00:33:18,260
ಈ 'ಕೇವಲ 10 ಅಕ್ಷರಗಳನ್ನು ನಕಲಿಸಿ.', ಹೇಳುತ್ತಾರೆ

543
00:33:18,260 --> 00:33:21,140
ಮತ್ತು ಸರಿ, ಆದರೆ ಹೀಗಾದರೆ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಪದ ಬೆರಳಚ್ಚಿಸಿದ ಬಳಕೆದಾರ

544
00:33:21,140 --> 00:33:29,360
20 ಅಕ್ಷರ ಪದ ನಂತಹ; ಈ ಯಾವುದನ್ನು ಪಟ್ಟಿಯಿಂದ ಪ್ರತಿಯನ್ನು 20 ಪಾತ್ರಗಳು ಹೇಳುವ ಹೊಂದಿದೆ?

545
00:33:29,360 --> 00:33:32,840
ಇಲ್ಲದಿದ್ದರೆ ನಮ್ಮ ಬಫರ್ ಎಂದು ಸಿ, ಇದು ನೀವು ಡೇಟಾವನ್ನು ಬರೆದರು ಅರ್ಥ

546
00:33:32,840 --> 00:33:35,950
ನೀವು ಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ 8 ಬೈಟ್ ಸ್ಥಾನಗಳಿಗೆ,

547
00:33:35,950 --> 00:33:38,320
ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ನಿಯೋಜಿತವಾದ ಎಂದಿಗೂ ಆ ಅರ್ಥದಲ್ಲಿ ಅವುಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

548
00:33:38,320 --> 00:33:41,190
ಆದ್ದರಿಂದ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿ ಯಂತೆ ಏನು

549
00:33:41,190 --> 00:33:46,650
ಅರ್ಥದಲ್ಲಿ ಅಥವಾ ಬಫರ್ ಅತಿಕ್ರಮಣ ದಾಳಿ, ಮತ್ತು ಅದು ದಾಳಿ ಎಂದು ವೇಳೆ ಬಳಕೆದಾರ

550
00:33:46,650 --> 00:33:50,650
ಅಥವಾ ನಿಮ್ಮ ಕಾರ್ಯವನ್ನು ಕರೆ ಎಂದು ಪ್ರೋಗ್ರಾಂ, ದುರುದ್ಧೇಶಪೂರಿತವಾಗಿ ಈ ರೀತಿ ಇದೆ

551
00:33:50,650 --> 00:33:53,780
ನಿಜವಾಗಿ ಮುಂದಿನ ಸಾಕಷ್ಟು ಕೆಟ್ಟ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ.

552
00:33:53,780 --> 00:33:55,690
>> ನ ಇಲ್ಲಿ ಈ ಚಿತ್ರವನ್ನು ಗಮನಿಸೋಣ.

553
00:33:55,690 --> 00:33:59,070
ಈ ಚಿತ್ರವನ್ನು ಮೆಮೊರಿಯ ನಿಮ್ಮ ಸ್ಟಾಕ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

554
00:33:59,070 --> 00:34:01,050
ಮತ್ತು, ಪ್ರತಿ ಬಾರಿ ನೀವು ಕಾರ್ಯ ಕರೆ ಸ್ಮರಿಸುತ್ತಾರೆ

555
00:34:01,050 --> 00:34:04,520
ನೀವು ಸ್ಟಾಕ್ ಈ ಕಡಿಮೆ ಫ್ರೇಮ್ ಪಡೆಯಲು ಮತ್ತು ನಂತರ ಇನ್ನೊಂದು ತದನಂತರ ಮತ್ತೊಂದು ನಂತರ ಮತ್ತೊಂದು.

556
00:34:04,520 --> 00:34:07,250
ಮತ್ತು ಇದುವರೆಗಿನ ನಾವು ಕೇವಲ ರೀತಿಯ ಮಾಡಿದ ಆಯತಗಳನ್ನು ಈ ದೂರ ಬೇರ್ಪಡಿಸಿದರೆ

557
00:34:07,250 --> 00:34:09,380
ಅಲ್ಲಿ ಮಂಡಳಿಯಲ್ಲಿ ಅಥವಾ ಇಲ್ಲಿ ತೆರೆಯಲ್ಲಿ ಒಂದೋ.

558
00:34:09,380 --> 00:34:12,219
ಆದರೆ ನಾವು ಆ ಆಯತಗಳನ್ನು ಮೇಲೆ ಜೂಮ್ ವೇಳೆ,

559
00:34:12,219 --> 00:34:16,460
ನೀವು ಒಂದು ಕಾರ್ಯ foo ​​ಕರೆ ಮಾಡಿದಾಗ, ಅದು ಹೆಚ್ಚು ಸ್ಟಾಕ್ ಮೇಲೆ ಇಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ

560
00:34:16,460 --> 00:34:18,739
ಆ ಫ್ರೇಮ್ ಮತ್ತು ಆಯತದ ಒಳಗೆ

561
00:34:18,739 --> 00:34:23,370
ಹೆಚ್ಚು ನಾವು ಸ್ವಾಪ್ ಬಗ್ಗೆ ಮಾಡಲಿಲ್ಲ ಹಾಗೆ ಕೇವಲ X ಮತ್ತು Y ಮತ್ತು ಒಂದು ಮತ್ತು ಬಿ,.

562
00:34:23,370 --> 00:34:25,949
ಇದು, ಕೆಲವು ಕಡಿಮೆ ಮಟ್ಟದ ವಿವರಗಳು ಇವೆ ಎಂದು ತಿರುಗುತ್ತದೆ

563
00:34:25,949 --> 00:34:27,780
ಅವುಗಳಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಹಿಂತಿರುಗಿ.

564
00:34:27,780 --> 00:34:33,020
ಮುಖ್ಯ foo ​​ಕರೆಗಳನ್ನು ಅದು ತಿರುಗಿದರೆ, ಮುಖ್ಯ foo ​​ತಿಳಿಸಲು ಹೊಂದಿದೆ

565
00:34:33,020 --> 00:34:36,760
ಕಂಪ್ಯೂಟರ್ನ ಸ್ಮರಣೆಯ ಯಾವ ಮುಖ್ಯ ನ ವಿಳಾಸ.

566
00:34:36,760 --> 00:34:40,659
ಇಲ್ಲವಾದಲ್ಲಿ, ತಕ್ಷಣ foo ಮಾಹಿತಿ, ಇಲ್ಲಿ ಈ ವಿಷಯದಲ್ಲಿ, ಪಾಲಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ

567
00:34:40,659 --> 00:34:43,790
ಒಮ್ಮೆ, foo ಕೊನೆಯಲ್ಲಿ ಈ ನಿಕಟ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತಲುಪಲು

568
00:34:43,790 --> 00:34:48,860
ಕಾರ್ಯಕ್ರಮದ ನಿಯಂತ್ರಣ ಹೋಗಿ ಹೇಳಲಾಗುವ ಅಲ್ಲಿ ಹೇಗೆ ಬೀಟಿಂಗ್ foo ತಿಳಿದಿದೆಯೇ?

569
00:34:48,860 --> 00:34:52,460
ಆ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರ ಇಲ್ಲಿ ಕೆಂಪು ಆಯತ ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

570
00:34:52,460 --> 00:34:56,130
ಈ ಒಂದು ಪಾಯಿಂಟರ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ತಾತ್ಕಾಲಿಕವಾಗಿ, ಶೇಖರಿಸಿಡಲು ಕಂಪ್ಯೂಟರ್ ಬಿಟ್ಟಿದ್ದು

571
00:34:56,130 --> 00:35:00,250
ಕರೆಯಲ್ಪಡುವ ಸ್ಟಾಕ್ ಮೇಲೆ ಎಷ್ಟು ಬೇಗ foo ಎಂದು ಮುಖ್ಯ ವಿಳಾಸವನ್ನು ಪಾಲಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ,

572
00:35:00,250 --> 00:35:04,110
ಕಂಪ್ಯೂಟರ್ ಅಲ್ಲಿ ಮತ್ತು ಹಿಂತಿರುಗಿ ಮುಖ್ಯ ಯಾವ ಸಾಲು ತಿಳಿದಿದೆ.

573
00:35:04,110 --> 00:35:06,900
ಉಳಿಸಿದ ಫ್ರೇಮ್ ಪಾಯಿಂಟರ್ ಈ ರೀತಿಯಲ್ಲಿ ಸಂಬಂಧಿಸಿದೆ.

574
00:35:06,900 --> 00:35:09,620
ಇಲ್ಲಿ ಚಾರ್ * ಬಾರ್ ಏನನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ?

575
00:35:09,620 --> 00:35:14,740
ಅಲ್ಲದೆ, ಈ ನೀಲಿ ಭಾಗವನ್ನು ಇಲ್ಲಿ foo ನ ಫ್ರೇಮ್ ಹೊಂದಿದೆ, ಬಾರ್ ಏನು?

576
00:35:14,740 --> 00:35:18,300
ಸರಿ, ಆದ್ದರಿಂದ ಬಾರ್ foo ಕಾರ್ಯವನ್ನು ಕೇವಲ ವಾದವು.

577
00:35:18,300 --> 00:35:20,720
>> ಈಗ ನಾವು ಪರಿಚಿತ ಚಿತ್ರವನ್ನು ಮರಳಿದ್ದೀರಿ.

578
00:35:20,720 --> 00:35:22,960
ತೆರೆಯ ಮೇಲೆ ಹೆಚ್ಚು ವಿಷಯವನ್ನು ಹೆಚ್ಚು ಗೊಂದಲ ಇಲ್ಲ

579
00:35:22,960 --> 00:35:27,490
ಆದರೆ ಈ ಬೆಳಕಿನ ನೀಲಿ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಸ್ವಾಪ್ ರೀತಿಯ ಯಾವುದನ್ನಾದರೂ chalkboard ರಚಿಸಿದರು ನಾವು ಏನು.

580
00:35:27,490 --> 00:35:31,890
ಎಂದು, ಬಾರ್ ಇದೀಗ foo ಗೆ ಫ್ರೇಮ್ ಮತ್ತು ಇದು ಕೇವಲ ವಿಷಯ

581
00:35:31,890 --> 00:35:34,630
ಈ ನಿಯತಾಂಕವನ್ನು ಹೊಂದಿದೆ.

582
00:35:34,630 --> 00:35:39,840
ಆದರೆ ಬೇರೆ ಯಾವ ಇಲ್ಲಿ ಈ ಕೋಡ್ ಪ್ರಕಾರ, ಸ್ಟಾಕ್ ಇರಬೇಕು?

583
00:35:39,840 --> 00:35:44,280
ಚಾರ್ ಸಿ [12]. ಹಾಗಾಗಿ, ಮೆಮೊರಿ 12 ಚೌಕಗಳನ್ನು ನೋಡಿ ಮಾಡಬೇಕು

584
00:35:44,280 --> 00:35:46,260
ಸಿ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಹಂಚಿಕೆ.

585
00:35:46,260 --> 00:35:48,340
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ತೆರೆಯ ಮೇಲೆ ಪಡೆದಿವೆ.

586
00:35:48,340 --> 00:35:51,650
ತುದಿಯನ್ನು ಇಲ್ಲ ಸಿ [0] ಈ ಚಿತ್ರದ, ಮತ್ತು ನಂತರ ಲೇಖಕ

587
00:35:51,650 --> 00:35:55,130
ಚೌಕಗಳನ್ನು ಎಲ್ಲಾ ಸೆಳೆಯುವಲ್ಲಿ ಬಗ್ ಆದರೆ 12 ನಿಜಕ್ಕೂ ಇವೆ ಇಲ್ಲ

588
00:35:55,130 --> 00:36:00,120
ಏಕೆಂದರೆ ನೀವು ಕೆಳಗಿನ ಬಲಭಾಗದಲ್ಲಿ ನೋಡಿದರೆ, ಸಿ [11], ನೀವು 0 ರಿಂದ ಎಣಿಕೆ ವೇಳೆ, 12 ಇಂತಹ ಬೈಟ್ಸ್.

589
00:36:00,120 --> 00:36:06,190
ಆದರೆ ಇಲ್ಲಿ ಸಮಸ್ಯೆ: ಇದು ದಿಕ್ಕಿನಲ್ಲಿ ರಲ್ಲಿ ಸಿ ಬೆಳೆಯುತ್ತಿದೆ?

590
00:36:06,190 --> 00:36:10,390
ಕೆಳಕ್ಕೆ ರೀತಿಯ, ಬಲ? ಇದು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಆರಂಭವಾಗಿ ಕೆಳಕ್ಕೆ ಬೆಳೆದರೆ,

591
00:36:10,390 --> 00:36:13,480
ನಾವು ಇಲ್ಲಿ ನಾವೇ ಹೆಚ್ಚು ರನ್ವೇ ಬಿಟ್ಟು ಕಂಡುಬರುತ್ತಿಲ್ಲ.

592
00:36:13,480 --> 00:36:15,320
ನಾವು ರೀತಿಯ, ಒಂದು ಮೂಲೆಯಲ್ಲಿ ನಾವೇ ಬಣ್ಣ ಮಾಡಿದ

593
00:36:15,320 --> 00:36:20,210
ಮತ್ತು ಸಿ [11] ಸ್ಟ್ಯಾಕ್ ಫೇಮ್ ಪಾಯಿಂಟರ್ ವಿರುದ್ಧ ಬಲಕ್ಕೆ ಇದು ಬಾರ್ ವಿರುದ್ಧ ಬಲ ಅಪ್,

594
00:36:20,210 --> 00:36:23,800
ವಾರ್ಷಿಕ ವಿಳಾಸಕ್ಕೆ ವಿರುದ್ಧ ಬಲ ಅಪ್; ಯಾವುದೇ ಅವಕಾಶವಿಲ್ಲ.

595
00:36:23,800 --> 00:36:26,100
ನೀವು ಸ್ಕ್ರೂ ಆದ್ದರಿಂದ ಗೋಜಲನ್ನು, ನಂತರ ಇದನ್ನೇ

596
00:36:26,100 --> 00:36:30,460
ಮತ್ತು ನೀವು 12 ಬೈಟ್ ಬಫರ್ ಆಗಿ 20 ಬೈಟ್ಗಳು ಓದಲು ಪ್ರಯತ್ನಿಸಿ?

597
00:36:30,460 --> 00:36:33,460
ಅಲ್ಲಿ ಆ 8 ಹೆಚ್ಚುವರಿ ಬೈಟ್ಗಳು ಹೋಗುತ್ತಿದ್ದೇವೆ?

598
00:36:33,460 --> 00:36:36,370
ಎಲ್ಲವೂ ಒಳಗೆ, ಇದು ಕೆಲವು ಪ್ರಮುಖ ಸೂಪರ್ ಆಗಿದೆ.

599
00:36:36,370 --> 00:36:40,480
ಮತ್ತು ಪ್ರಮುಖ ವಿಷಯವೆಂದರೆ, ಸಂಭಾವ್ಯವಾಗಿ, ಅಲ್ಲಿಗೆ ಮರಳುತ್ತಾರೆ ವಿಳಾಸಕ್ಕೆ ಕೆಂಪು ಬಾಕ್ಸ್.

600
00:36:40,480 --> 00:36:44,720
ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಅಥವಾ adversarially ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ ಏಕೆಂದರೆ

601
00:36:44,720 --> 00:36:48,040
ಆ 4 ಬೈಟ್ಗಳು, ಆ ಪಾಯಿಂಟರ್ ವಿಳಾಸಕ್ಕೆ, ಬದಲಿಸಿ

602
00:36:48,040 --> 00:36:53,190
ಕೇವಲ ಕಸದ ಜೊತೆ, ಆದರೆ ಮೆಮೊರಿ ಒಂದು ನಿಜವಾದ ವಿಳಾಸಕ್ಕೆ ಪ್ರತಿನಿಧಿಸಲು ನಡೆಯುವ ಹಲವಾರು?

603
00:36:53,190 --> 00:36:55,930
ತಾರ್ಕಿಕವಾಗಿ implicaiton, ಏನು?

604
00:36:55,930 --> 00:36:59,080
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರಗಳನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ನಿಖರವಾಗಿ. Foo ಮರಳಿದಾಗ

605
00:36:59,080 --> 00:37:03,560
ಮತ್ತು ಹಿಟ್ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಎಂದು, ಕಾರ್ಯಕ್ರಮ, ಮುಖ್ಯ ಹಿಂದಿರುಗಿಸಲು ಮುಂದುವರೆಯಲು ಹೋಗುತ್ತದೆ

606
00:37:03,560 --> 00:37:08,320
ಆ ಕೆಂಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಯಾವುದೇ ವಿಳಾಸಕ್ಕೆ ಮರಳಲು ವಿಶೇಷವೇನು.

607
00:37:08,320 --> 00:37:11,560
>> ಈಗ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ತಂತ್ರಾಂಶ ನೋಂದಣಿ ಸಂದರ್ಭದಲ್ಲಿ,

608
00:37:11,560 --> 00:37:14,400
ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಹಿಂದಿರುಗಿಸುವ ಎಂದು ವಿಳಾಸಕ್ಕೆ ಎಂದರೇನು

609
00:37:14,400 --> 00:37:18,820
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಸಾಫ್ಟ್ವೇರ್ ಪಾವತಿ ಮಾಡಿದ ನಂತರ ಎಂದು ನಿಮ್ಮ ನೋಂದಣಿ ಕೋಡ್ ಇನ್ಪುಟ್ ಗಳಿಸುವ?

610
00:37:18,820 --> 00:37:23,160
ನೀವು ಇಲ್ಲಿ ಹೋಗುತ್ತಿಲ್ಲ ಆಗಿ ಟ್ರಿಕ್ ಕಂಪ್ಯೂಟರ್ನ ವಿಂಗಡಿಸಲು, ಆದರೆ, ಇಲ್ಲಿ ಹೋಗುವುದು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

611
00:37:23,160 --> 00:37:27,950
ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ ಇಂತಹ ಅಥವಾ, ಪ್ರತಿಕೂಲ ವಾಸ್ತವವಾಗಿ, ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಮಾಡಬಹುದು

612
00:37:27,950 --> 00:37:32,500
ಉದಾಹರಣೆಗೆ, ಒಂದು ನಿಜವಾದ ಪದ ಅಲ್ಲ 20 ಪಾತ್ರಗಳು, ಆದರೆ ಭಾವಿಸಿರಿ ಅವನು ಅಥವಾ ಅವಳು

613
00:37:32,500 --> 00:37:36,200
ಕೋಡ್ ಪ್ರತಿನಿಧಿಸುವ ಕೆಲವು ಅಕ್ಷರಗಳನ್ನು ರೀತಿಯ?

614
00:37:36,200 --> 00:37:38,860
ಮತ್ತು ಸಿ ಕೋಡ್ ಎಂದು ಹೋಗುವ ಅಲ್ಲ, ಅದು ಪಾತ್ರಗಳು ಎಂದು ವಿಶೇಷವೇನು

615
00:37:38,860 --> 00:37:42,920
ಆ ಅವಳಿ ಯಂತ್ರ ಸಂಕೇತಗಳು, 0 ಮತ್ತು 1 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

616
00:37:42,920 --> 00:37:46,740
ಆದರೆ ಹೇಗಾದರೂ GetString ಪ್ರಾಂಪ್ಟ್ ಅಂಟಿಸಿ ಮಾಡಲು, ಹಾಗೆ ಸಾಕಷ್ಟು ಬುದ್ಧಿವಂತ ಆರ್ ಇಟ್ಟುಕೋ

617
00:37:46,740 --> 00:37:49,460
ಮೂಲಭೂತವಾಗಿ ಕೋಡ್ ಸಂಕಲಿತಗೊಂಡಿದೆ ವಿಷಯ,

618
00:37:49,460 --> 00:37:56,900
ಮತ್ತು ಕೊನೆಯ 4 ಬೈಟ್ಗಳು ಎಂದು ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಬದಲಿಸಿ, ಮತ್ತು ಇನ್ಪುಟ್ ಯಾವ ವಿಳಾಸಕ್ಕೆ ಮಾಡುತ್ತದೆ?

619
00:37:56,900 --> 00:38:01,860
ಈ ಕೆಂಪು ಆಯತ ಬಫರ್ ಮೊದಲ ಬೈಟ್ ವಿಳಾಸಕ್ಕೆ ಅಂಗಡಿಗಳು.

620
00:38:01,860 --> 00:38:04,270
ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ ಇರಬೇಕು, ಮತ್ತು ಈ ಪ್ರಯೋಗ ಮತ್ತು ದೋಷ ಬಹಳಷ್ಟು ಹೊಂದಿದೆ

621
00:38:04,270 --> 00:38:08,500
ಕೆಟ್ಟ ಅಲ್ಲಿಗೆ ಜನರು, ಆದರೆ ನೀವು ಈ ಬಫರ್ ಎಷ್ಟು ದೊಡ್ಡ ಊಹಿಸಲು ಸಾಧ್ಯವೇ ಫಾರ್

622
00:38:08,500 --> 00:38:12,170
ನೀವು ಪ್ರೋಗ್ರಾಂಗೆ ಆದಾನ ಕಳೆದ ಕೆಲವು ಬೈಟ್ಗಳು ಒದಗಿಸುವ ಇಂತಹ

623
00:38:12,170 --> 00:38:15,970
ನಿಮ್ಮ ಬಫರ್ ಪ್ರಾರಂಭವಾಗುವ ವಿಳಾಸಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಸಂಭವಿಸಬಹುದು,

624
00:38:15,970 --> 00:38:22,270
ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು. ನಾವು ವೇಳೆ, ಸಾಮಾನ್ಯವಾಗಿ, ಹಲೋ, ಮತ್ತು \ 0, ಆ ಬಫರ್ ಸೇರುತ್ತದೆ ಇಲ್ಲಿದೆ.

625
00:38:22,270 --> 00:38:27,860
ಆದರೆ ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ಆರ್, ಮತ್ತು ನಾವು ಸಾರ್ವತ್ರಿಕವಾಗಿ ದಾಳಿಯ ಕೋಡ್ ಕರೆ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ಆ ಬಫರ್ ತುಂಬಲು ವೇಳೆ,

626
00:38:27,860 --> 00:38:31,920
ಎ, ಎ, ಎ, ಎ: ಅಟ್ಯಾಕ್, ದಾಳಿ, ಆಕ್ರಮಣ, ದಾಳಿ, ಈ ಕೇವಲ ಕೆಟ್ಟ ಮಾಡದಿರುವಂಥದ್ದನ್ನು ವಿಷಯ ಅಲ್ಲಿ.

627
00:38:31,920 --> 00:38:35,190
ಅಲ್ಲದೆ, ಯಾವ ನೀವು ನಿಜವಾಗಿಯೂ ಬುದ್ಧಿವಂತ, ನೀವು ಹಾಗೆ ಇರಬಹುದು ನಡೆಯುತ್ತದೆ:

628
00:38:35,190 --> 00:38:41,740
80, CO, 35, 08: ಇಲ್ಲಿ ಕೆಂಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮದ.

629
00:38:41,740 --> 00:38:44,890
ಎಂದು ಇಲ್ಲಿ ಎಂದು ಸಂಖ್ಯೆಯನ್ನು ಹೋಲುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

630
00:38:44,890 --> 00:38:47,280
ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ, ಆದರೆ ಕೆಲವು ಬಾರಿ ಹೆಚ್ಚು.

631
00:38:47,280 --> 00:38:51,430
ಮರಳಿ ವಿಳಾಸಕ್ಕೆ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬದಲಾಯಿಸಿತು ಎಂದು ಗಮನಿಸಿ

632
00:38:51,430 --> 00:38:54,970
ಇಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಅಪ್ ಸಮವಾಗಿದೆ, ಮುಖ್ಯ ಅಲ್ಲ ವಿಳಾಸಕ್ಕೆ.

633
00:38:54,970 --> 00:39:00,170
ಕೆಟ್ಟ ವ್ಯಕ್ತಿ ಸೂಪರ್ ಸ್ಮಾರ್ಟ್ ಆದ್ದರಿಂದ, ಅವನು ಅಥವಾ ಅವಳು ದಾಳಿ ಕೋಡ್ ಸೇರಿಸಬಹುದು ಹೋಗುತ್ತದೆ

634
00:39:00,170 --> 00:39:02,890
ಏನಾದರೂ, ಹಾಗೆ 'ಬಳಕೆದಾರನ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಅಳಿಸಿ.'

635
00:39:02,890 --> 00:39:06,320
ಅಥವಾ 'ನಾನು ಲಾಗ್ ಒಂದು ಬಳಕೆದಾರ ಖಾತೆಯನ್ನು ರಚಿಸಿ.', ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ನಕಲಿಸಿ 'ಅಥವಾ

636
00:39:06,320 --> 00:39:10,130
ಅದು ಏನು ಮತ್ತು ಈ ಅಪಾಯ ಮತ್ತು ಸಿ ಶಕ್ತಿ ಎರಡೂ

637
00:39:10,130 --> 00:39:12,900
ನೀವು ಪಾಯಿಂಟರ್ಗಳ ಮೂಲಕ ಮೆಮೊರಿ ಪ್ರವೇಶ ಏಕೆಂದರೆ

638
00:39:12,900 --> 00:39:15,950
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿಗೆ ಬಯಸುವ ಏನು ಬರೆಯಬಹುದು.

639
00:39:15,950 --> 00:39:19,290
ನೀವು ಕಂಪ್ಯೂಟರ್ ನೀವು ಕೇವಲ ನೀವು ಏನು ಅದಕ್ಕೆ ಏನು ಮಾಡಬಹುದು

640
00:39:19,290 --> 00:39:22,780
ತನ್ನ ಸ್ವಂತ ಮೆಮೊರಿ ಜಾಗವನ್ನು ಸುಮಾರು ಜಂಪ್ ನಂತರ.

641
00:39:22,780 --> 00:39:27,230
ಆದ್ದರಿಂದ, ಈ ದಿನ, ಹೀಗೆ ಅನೇಕ ಕಾರ್ಯಕ್ರಮಗಳು ಮತ್ತು ಧಕ್ಕೆಯುಂಟಾಗಿದೆ ಎಂದು ಅನೇಕ ವೆಬ್ಸೈಟ್ಗಳು

642
00:39:27,230 --> 00:39:29,730
ಈ ಅನುಕೂಲ ಪಡೆದು ಜನರಿಗೆ ಡೌನ್ ಹುಣ್ಣು.

643
00:39:29,730 --> 00:39:32,510
ಮತ್ತು ಈ, ಒಂದು ಸೂಪರ್ ಅತ್ಯಾಧುನಿಕ ದಾಳಿ ಹೋಲುವಂತಿದ್ದು ಇರಬಹುದು

644
00:39:32,510 --> 00:39:34,220
ಆದರೆ ಯಾವಾಗಲೂ ಆ ರೀತಿಯಲ್ಲಿ ಆರಂಭಿಸಲು ಇಲ್ಲ.

645
00:39:34,220 --> 00:39:36,770
>> ವಾಸ್ತವವಾಗಿ, ಯಾವ ಕೆಟ್ಟ ಜನರು ವಿಶಿಷ್ಟವಾಗಿ ಮಾಡುತ್ತದೆ ಎಂದು

646
00:39:36,770 --> 00:39:41,470
ಇದು ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಒಂದು ಪ್ರೋಗ್ರಾಮ್ ಅಥವಾ ಒಂದು GUI ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಒಂದು ವೆಬ್ಸೈಟ್, ಆಗಿರುತ್ತದೆ

647
00:39:41,470 --> 00:39:43,290
ನೀವು ಕೇವಲ ಅಸಂಬದ್ಧ ಒದಗಿಸುವ ಪ್ರಾರಂಭ.

648
00:39:43,290 --> 00:39:46,940
ನೀವು ಹುಡುಕಾಟ ಕ್ಷೇತ್ರದಲ್ಲಿ ಮತ್ತು ಹಿಟ್ ನಮೂದಿಸಿ ಒಂದು ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಪದವನ್ನು ನಮೂದಿಸಿ

649
00:39:46,940 --> 00:39:49,030
ಮತ್ತು ನೀವು ವೆಬ್ಸೈಟ್ ಕ್ರ್ಯಾಶ್ ನೋಡಲು ನಿರೀಕ್ಷಿಸಿ.

650
00:39:49,030 --> 00:39:53,270
ಅಥವಾ ನೀವು ಕಾರ್ಯಕ್ರಮದ ಕೆಲವು ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನೋಡಲು ನಿರೀಕ್ಷಿಸಿ.

651
00:39:53,270 --> 00:39:55,480
ನಿಮಗೆ ಅದೃಷ್ಟ ಪಡೆಯಲು ವೇಳೆ, ಏಕೆಂದರೆ ಕೆಟ್ಟ ವ್ಯಕ್ತಿ,

652
00:39:55,480 --> 00:39:59,610
ಮತ್ತು ನೀವು, ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ ಕೆಲವು ಅಸಾಮಾನ್ಯ ಇನ್ಪುಟ್ ಒದಗಿಸಲು

653
00:39:59,610 --> 00:40:02,280
ಆ ಪ್ರೋಗ್ರಾಮರ್ ನಿಮ್ಮ ಕೆಟ್ಟ ವರ್ತನೆ ನಿರೀಕ್ಷೆ ಇಟ್ಟುಕೊಂಡಿರಲಿಲ್ಲ ಅರ್ಥ

654
00:40:02,280 --> 00:40:05,420
ಇದು ಸಾಕಷ್ಟು ಪ್ರಯತ್ನ, ನೀವು ಬಹುಶಃ ಎಂದರ್ಥ

655
00:40:05,420 --> 00:40:09,870
ಸಾಕಷ್ಟು ಪ್ರಯೋಗ ಮತ್ತು ದೋಷ, ಹೆಚ್ಚು ನಿಖರವಾದ ದಾಳಿ ಹೂಡಲು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ.

656
00:40:09,870 --> 00:40:15,900
ಭದ್ರತೆಯ ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಭಾಗವಾಗಿ ಕೇವಲ ಒಟ್ಟಾರೆಯಾಗಿ ಈ ದಾಳಿಗಳು ತಪ್ಪಿಸುವ, ಆದರೆ ಅವುಗಳನ್ನು ಪತ್ತೆ ಇಲ್ಲ

657
00:40:15,900 --> 00:40:20,250
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ದಾಖಲೆಗಳು ನೋಡುತ್ತಿರುವುದು ಕ್ರೇಜಿ ಒಳಹರಿವು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿನ ಟೈಪಿಸಿದ ಜನರು ಏನು ನೋಡಿದ.

658
00:40:20,250 --> 00:40:26,040
ಯಾವ ಹುಡುಕಾಟ ಪದಗಳನ್ನು ಕೆಲವು ಬಫರ್ ಸುರಿಯುತ್ತಿರುವ ಭರವಸೆಯಲ್ಲಿ ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿನ ಜನರು ಟೈಪ್ ಮಾಡಿದ್ದೀರಿ?

659
00:40:26,040 --> 00:40:28,900
ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂಬುದನ್ನು ಸರಳ ಮೂಲಭೂತ ಈ ಎಲ್ಲಾ ಕುದಿಯುವ ಕೆಳಗೆ,

660
00:40:28,900 --> 00:40:32,510
ಮತ್ತು ಅದರ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಮತ್ತು ಬಳಸಲು ಅರ್ಥವೇನು?

661
00:40:32,510 --> 00:40:34,920
ಮತ್ತು ಸಂಬಂಧಿಸಿದ ಸಹ ಇದು.

662
00:40:34,920 --> 00:40:37,520
>> ಆದ್ದರಿಂದ ಇನ್ನೂ ಮತ್ತೆ ಒಂದು ಹಾರ್ಡ್ ಡ್ರೈವ್ ಒಳಗೆ ಮಿಂಚು ನೋಡೋಣ.

663
00:40:37,520 --> 00:40:40,190
ಆದ್ದರಿಂದ ನೀವು ನೆನಪಿಗೆ ಒಂದು ವಾರ ಅಥವಾ ಎರಡು ಹಿಂದೆ ನೀವು ಕಡತಗಳನ್ನು ಡ್ರ್ಯಾಗ್ ಮಾಡುವಾಗ

664
00:40:40,190 --> 00:40:45,470
ನಿಮ್ಮ ಮರುಬಳಕೆ ಬಿನ್ ಅಥವಾ ಕಸದ ತೊಟ್ಟಿ, ಏನಾಗುತ್ತದೆ?

665
00:40:45,470 --> 00:40:47,850
[ವಿದ್ಯಾರ್ಥಿ] ನಥಿಂಗ್. >> ಹೌದು, ಸಂಪೂರ್ಣವಾಗಿ ಏನೂ. ನೀವು ಕಡಿಮೆ ರನ್ ಅಂತಿಮವಾಗಿ ವೇಳೆ

666
00:40:47,850 --> 00:40:51,370
ಡಿಸ್ಕ್ ಜಾಗದ ಮೇಲೆ, ವಿಂಡೋಸ್ ಅಥವಾ ಮ್ಯಾಕ್ OS ನೀವು ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

667
00:40:51,370 --> 00:40:53,670
ನೀವು ಏನಾದರೂ ಎಳೆಯಿರಿ ಆದರೆ, ನಂತರ ಅದು ಎಲ್ಲಾ ಸುರಕ್ಷಿತ ನಲ್ಲಿ ಅಲ್ಲ.

668
00:40:53,670 --> 00:40:56,550
ಎಲ್ಲಾ ನಿಮ್ಮ roomate, ಕುಟುಂಬದ ಸದಸ್ಯರು ಅಥವಾ ಸ್ನೇಹಿತರು ಮಾಡಲು ಹೊಂದಿದೆ ಡಬಲ್ ಕ್ಲಿಕ್ ಮಾಡಿ, ಮತ್ತು voila ಇದೆ.

669
00:40:56,550 --> 00:40:59,720
ನೀವು ಅಳಿಸಲು ಪ್ರಯತ್ನಿಸಿದ ಎಲ್ಲಾ ಹುರುಳಿಲ್ಲದ ಕಡತಗಳು ಇಲ್ಲ.

670
00:40:59,720 --> 00:41:02,840
ನಮಗೆ ಅತ್ಯಂತ ಆದ್ದರಿಂದ ಕನಿಷ್ಠ ನೀವು ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಅಥವಾ ಕ್ಲಿಕ್ ನಿಯಂತ್ರಿಸಲು ಎಂಬುದನ್ನು

671
00:41:02,840 --> 00:41:05,320
ಮತ್ತು ಖಾಲಿ ಕಸ, ಅಥವಾ ಆ ರೀತಿಯ.

672
00:41:05,320 --> 00:41:07,900
ಆದರೆ ನಂತರ, ಆ ಸಾಕಷ್ಟು ಟ್ರಿಕ್ ಮಾಡುವುದಾಗಲೀ.

673
00:41:07,900 --> 00:41:11,340
ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಒಂದು ಫೈಲ್ ಹೊಂದಿದ್ದು, ಏನಾಗುತ್ತದೆ ಏಕೆಂದರೆ

674
00:41:11,340 --> 00:41:14,590
ಕೆಲವು ದಾಖಲ ಅಥವಾ ಕೆಲವು JPEG ಪ್ರತಿನಿಧಿಸುತ್ತದೆ?

675
00:41:14,590 --> 00:41:18,820
ಮತ್ತು, ಈ ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ಈಗ ಇಲ್ಲಿ ಈ ಹಚ್ಚೆ ಫೈಲ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಹೇಳುತ್ತಾರೆ

676
00:41:18,820 --> 00:41:21,640
ಮತ್ತು 0 ಮತ್ತು 1 ರ ಇಡೀ ಗುಂಪೇ ಒಳಗೊಂಡ ನ.

677
00:41:21,640 --> 00:41:25,470
ನೀವು ಕೇವಲ ಕಸಬುಟ್ಟಿ Name ಅಥವಾ ಮರುಬಳಕೆ ತೊಟ್ಟಿಯು ಫೈಲ್ ಎಳೆಯಿರಿ ಇಲ್ಲ ಏನು, ಏನಾಗುತ್ತದೆ

678
00:41:25,470 --> 00:41:30,390
ಆದರೆ ಅದು ಖಾಲಿ?

679
00:41:30,390 --> 00:41:32,820
ಯಾವುದೇ ರೀತಿಯ. ಈಗ ಸಂಪೂರ್ಣವಾಗಿ ಏನೂ ಅಲ್ಲ.

680
00:41:32,820 --> 00:41:37,630
ಸ್ವಲ್ಪ ಏನಾದರೂ ಈ ಟೇಬಲ್ ರೂಪದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಈಗ, ಕೇವಲ ಏನೂ ಇಲ್ಲಿದೆ.

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

682
00:41:41,170 --> 00:41:44,470
ಆ ಮೂಲಭೂತವಾಗಿ, ಫೈಲ್ಗಳನ್ನು ಹೆಸರುಗಳು 1 ಕಾಲಮ್ ಹೊಂದಿದೆ

683
00:41:44,470 --> 00:41:50,550
ಈ ಸ್ಥಳ 123, ಕೇವಲ ಒಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಇರಬಹುದು ಅಲ್ಲಿ ಕಡತದ ಸ್ಥಳ, 1 ಕಾಲಮ್.

684
00:41:50,550 --> 00:41:58,270
ನಾವು x.jpg ರೀತಿಯ, ಮತ್ತು ಸ್ಥಳ 123 ಹೊಂದಿರಬಹುದು.

685
00:41:58,270 --> 00:42:02,870
ನಿಮ್ಮ ಕಸದ ಖಾಲಿ ಯಾವಾಗ ಮತ್ತು ಯಾವ, ನಂತರ ಏನಾಗುತ್ತದೆ?

686
00:42:02,870 --> 00:42:06,720
ದೂರ ಹೋಗುತ್ತದೆ ಎಂದು. ಆದರೆ ಯಾವ ದೂರ ಹೋಗುವುದಿಲ್ಲ 0 ಮತ್ತು 1 ರ ಹೊಂದಿದೆ.

687
00:42:06,720 --> 00:42:09,690
>> ಹಾಗಾಗಿ, ನಂತರ, ಸಂಪರ್ಕ 4 pset ಟು?

688
00:42:09,690 --> 00:42:13,460
ಅಲ್ಲದೆ, pset 4, ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ಅಳಿಸಿಹಾಕಿತು ನೀವು ಕೇವಲ

689
00:42:13,460 --> 00:42:15,890
ಈ ಫೋಟೋಗಳನ್ನು ಎಲ್ಲಾ ಎಂದು ಕಾಂಪ್ಯಾಕ್ಟ್ ಫ್ಲಾಶ್ ಕಾರ್ಡ್,

690
00:42:15,890 --> 00:42:18,710
ಅಥವಾ ದುರದೃಷ್ಟವಶಾತ್ ಅದು ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಆಯಿತು, ಏಕೆಂದರೆ

691
00:42:18,710 --> 00:42:21,170
0 ಮತ್ತು 1 ರ ಈಗಲೂ ಇಲ್ಲ ಎಂದು ಅರ್ಥವಲ್ಲ.

692
00:42:21,170 --> 00:42:23,920
ಏನೋ ಭ್ರಷ್ಟಗೊಂಡಿದೆ ಪಡೆಯಿತು ಏಕೆಂದರೆ ಪ್ರಾಯಶಃ ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಕಳೆದುಹೋಗಿವೆ

693
00:42:23,920 --> 00:42:26,530
ಕೆಲವು 0 ನ 1 ಮತ್ತು 1 ರ ಆಯಿತು ಅರ್ಥದಲ್ಲಿ 0 ನ ಆಯಿತು.

694
00:42:26,530 --> 00:42:30,460
ದೋಷಯುಕ್ತ ತಂತ್ರಾಂಶ ಅಥವಾ ದೋಷಯುಕ್ತ ಯಂತ್ರಾಂಶದ ಏಕೆಂದರೆ ಕೆಟ್ಟ ಸಂಗತಿಗಳು ಸಂಭವಿಸುತ್ತವೆ.

695
00:42:30,460 --> 00:42:33,510
ಆದರೆ ಆ ಬಿಟ್ಗಳು ಹಲವಾರು, ಬಹುಶಃ ಅವುಗಳನ್ನು ಕೂಡ 100%, ಇನ್ನೂ ಇವೆ

696
00:42:33,510 --> 00:42:38,330
ಇದು JPEG 1 ಪ್ರಾರಂಭಿಸಿದರು ಕಂಪ್ಯೂಟರ್ ಅಥವಾ ಕ್ಯಾಮೆರಾ ಗೊತ್ತಿಲ್ಲ ಎಂದು ಜಸ್ಟ್

697
00:42:38,330 --> 00:42:41,660
ಮತ್ತು JPEG 2 ಪ್ರಾರಂಭಿಸಿದರು, ಆದರೆ ನೀವು, ಪ್ರೋಗ್ರಾಮರ್,

698
00:42:41,660 --> 00:42:45,800
ಆ JPEGs ಅಥವಾ ಅವರು ಯಾವ ರೀತಿ ಅಲ್ಲಿ ಜಾಣತನ ಒಂದು ಬಿಟ್, ಜೊತೆಗೆ, ಗೊತ್ತಿಲ್ಲ,

699
00:42:45,800 --> 00:42:49,570
ನೀವು 0 ಮತ್ತು 1 ರ ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು Ooh 'ಹೇಳಬಹುದು. JPEG. , JPEG Ooh. '

700
00:42:49,570 --> 00:42:52,830
ನೀವು ಮೂಲಭೂತವಾಗಿ ಕೇವಲ ಗಾಗಿ ಒಂದು ಪ್ರೋಗ್ರಾಮ್ ಅನ್ನು ಬರೆಯುವುದು ಅಥವಾ ಮಾಡುತ್ತದೆ ಲೂಪ್

701
00:42:52,830 --> 00:42:56,100
ಆ ಫೈಲ್ಗಳ ಪ್ರತಿಯೊಂದು ಒಂದು ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತಾನೆ.

702
00:42:56,100 --> 00:42:59,360
ಪಾಠದ ನಂತರ, "ಸುರಕ್ಷಿತವಾಗಿ" ನಿಮ್ಮ ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಿಹಾಕುತ್ತವೆ ಆರಂಭಿಸಲು ಆದ್ದರಿಂದ

703
00:42:59,360 --> 00:43:01,720
ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಇದನ್ನು ತಪ್ಪಿಸಲು ಬಯಸಿದಲ್ಲಿ. ಹೌದು?

704
00:43:01,720 --> 00:43:06,940
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

705
00:43:06,940 --> 00:43:11,150
>> ನೀವು ಮೊದಲು ಮಾಡಿದರು ಹೆಚ್ಚು ಮೆಮೊರಿ -

706
00:43:11,150 --> 00:43:14,790
ಓಹ್! ಪ್ರಶ್ನೆ ಉತ್ತಮ. ಆದ್ದರಿಂದ, ನಂತರ, ಅನುಪಯುಕ್ತವನ್ನು ಖಾಲಿ ನಂತರ,

707
00:43:14,790 --> 00:43:18,300
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ನೀವು ಮೊದಲು ಮಾಡಿದರು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಹೊಂದಿರುವ ಹೇಳಲು ಇಲ್ಲ?

708
00:43:18,300 --> 00:43:22,450
ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಸುಳ್ಳು ಮಾಡಿದ ಕಾರಣ. ಹೆಚ್ಚು ತಾಂತ್ರಿಕವಾಗಿ, ನೀವು ಹೆಚ್ಚು ಜಾಗವಿದೆಯೇ.

709
00:43:22,450 --> 00:43:26,720
ಈಗ ನೀವು ಹೇಳಿದ ಕಾರಣ ಆ ಕಡತ ಹಿಂದೊಮ್ಮೆ ಅಲ್ಲಿ, ನೀವು ಇತರ ವಿಷಯವನ್ನು ಇರಿಸಬಹುದು,

710
00:43:26,720 --> 00:43:28,930
ಆದರೆ, ಬಿಟ್ಸ್ ದೂರ ಹೋಗುವ ಅರ್ಥವಲ್ಲ

711
00:43:28,930 --> 00:43:33,070
ಮತ್ತು ಬಿಟ್ಗಳು ನಿಮ್ಮ ರಕ್ಷಣೆಗಾಗಿ, ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ 0 ನ ಬದಲಾಗಿದೆ ಎಂದು ಅರ್ಥವಲ್ಲ.

712
00:43:33,070 --> 00:43:37,520
ಇದಕ್ಕೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ನೀವು "ಸುರಕ್ಷಿತವಾಗಿ" ಅಳಿಸು ಫೈಲ್ಗಳು ಅಥವಾ ಭೌತಿಕವಾಗಿ ಸಾಧನ ನಾಶ ವೇಳೆ,

713
00:43:37,520 --> 00:43:40,810
ನಿಜಕ್ಕೂ ಆ ಸುತ್ತ, ಕೆಲವೊಮ್ಮೆ, ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ.

714
00:43:40,810 --> 00:43:45,300
ಆದ್ದರಿಂದ ನಾವು ಅರೆ ಹೆದರಿಕೆಯೆ ಗಮನಿಸಿ ಹೊರಡಲು ಇಲ್ಲ, ಮತ್ತು ನಾವು ಸೋಮವಾರ ನೀವು ನೋಡಬಹುದು.

715
00:43:45,300 --> 00:43:52,810
CS50.TV