1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [ಫೈಲ್ I / O]

2
00:00:02,000 --> 00:00:04,000
[ಜಾಸನ್ ಹಿರ್ಸ್ಚೋರ್ನ್, ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,000 --> 00:00:07,000
[ಇದು CS50.TV CS50 ಹೊಂದಿದೆ]

4
00:00:07,000 --> 00:00:11,000
ನಾವು ಒಂದು ಕಡತದ ಯೋಚನೆ ಮಾಡಿದರೆ, ಏನು, ಒಂದು ಮೈಕ್ರೊಸಾಫ್ಟ್ ವರ್ಡ್ ದಸ್ತಾವೇಜು ಮನಸ್ಸಿಗೆ ಬರುತ್ತದೆ

5
00:00:11,000 --> 00:00:14,000
ಒಂದು JPEG ಚಿತ್ರ, ಅಥವಾ ಒಂದು MP3 ಹಾಡು,

6
00:00:14,000 --> 00:00:17,000
ಮತ್ತು ನಾವು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಕಡತಗಳನ್ನು ಈ ರೀತಿಯ ಪ್ರತಿಯೊಂದು ಸಂವಹನ.

7
00:00:17,000 --> 00:00:20,000
ಉದಾಹರಣೆಗೆ, ಒಂದು ದಾಖಲ ನಾವು ಪಠ್ಯ ಸೇರಿಸಿ

8
00:00:20,000 --> 00:00:24,000
ಒಂದು JPEG ಚಿತ್ರ ನಾವು ಅಂಚುಗಳ ಔಟ್ ಕ್ರಾಪ್ ಅಥವಾ ಬಣ್ಣಗಳು ಪರಿಷ್ಕರಿಸು ಇರಬಹುದು ಆದರೆ.

9
00:00:24,000 --> 00:00:28,000
ಇನ್ನೂ HOOD ಅಡಿಯಲ್ಲಿ ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಕಡತಗಳ ಎಲ್ಲಾ ಹೆಚ್ಚು ಏನೂ ಗಳು

10
00:00:28,000 --> 00:00:31,000
ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಸುದೀರ್ಘ ಸರಣಿಯನ್ನು ಹೊರತುಪಡಿಸಿ.

11
00:00:31,000 --> 00:00:33,000
ಇದು ಕಡತ ಪರಸ್ಪರ ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್ ಬಿಟ್ಟಿದ್ದು

12
00:00:33,000 --> 00:00:38,000
ಈ ಸುದೀರ್ಘ ಸರಣಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು ಬಳಕೆದಾರರು ಇದನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಲು ಹೇಗೆ ನಿರ್ಧರಿಸುವುದು.

13
00:00:38,000 --> 00:00:41,000
ಒಂದು ಕಡೆ, ಒಂದು ದಾಖಲೆ, ಕೇವಲ ಒಂದು ಬೈಟ್ ನೋಡಲು ಮಾಡಬಹುದು

14
00:00:41,000 --> 00:00:45,000
ಅಥವಾ 8 ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳು, ಮತ್ತು ತೆರೆಯ ಮೇಲೆ ಒಂದು ASCII ಅಕ್ಷರ ಪ್ರದರ್ಶಿಸಲು.

15
00:00:45,000 --> 00:00:48,000
ಮತ್ತೊಂದೆಡೆ, ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಚಿತ್ರ, 3 ಬೈಟ್ಗಳು ನೋಡಲು ಮಾಡಬಹುದು

16
00:00:48,000 --> 00:00:50,000
ಅಥವಾ 24 ಸೊನ್ನೆಗಳು ಮತ್ತು ಸಾವು

17
00:00:50,000 --> 00:00:53,000
ಮತ್ತು 3 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಖ್ಯೆಗಳನ್ನು ಅವುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ

18
00:00:53,000 --> 00:00:56,000
ಕೆಂಪು, ಹಸಿರು, ಮತ್ತು ನೀಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು

19
00:00:56,000 --> 00:00:58,000
ಚಿತ್ರವನ್ನು ಒಂದು ಪಿಕ್ಸೆಲ್ ರಲ್ಲಿ.

20
00:00:58,000 --> 00:01:01,000
ಏನೇ ತಮ್ಮ ಅಂತರಂಗದಲ್ಲಿ, ನಿಮ್ಮ ಪರದೆಯ ಮೇಲೆ ಕಾಣುವಂತೆ ಮಾಡಬಹುದು

21
00:01:01,000 --> 00:01:05,000
ಕಡತಗಳನ್ನು ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಅನುಕ್ರಮ ಹೆಚ್ಚೇನೂ ಇವೆ.

22
00:01:05,000 --> 00:01:08,000
ಆದ್ದರಿಂದ ನಾವು ರಲ್ಲಿ ಧುಮುಕುವುದಿಲ್ಲ ಮತ್ತು ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಕುಶಲತೆಯಿಂದ ಹೇಗೆ ನೋಡಲು

23
00:01:08,000 --> 00:01:12,000
ಇದನ್ನು ಬರೆಯಲು ಮತ್ತು ಒಂದು ಕಡತದಿಂದ reading ಗೆ ಬಂದಾಗ.

24
00:01:12,000 --> 00:01:15,000
>> ನಾನು ಸರಳ 3 ಭಾಗದ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅದನ್ನು ಒಡೆಯುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ.

25
00:01:15,000 --> 00:01:19,000
ಮುಂದೆ, ನಾನು ಈ ಮೂರು ಭಾಗಗಳು ಪ್ರದರ್ಶಿಸುವ ಎರಡು ಕೋಡ್ ಉದಾಹರಣೆಗಳು ಆಗಿ ಧುಮುಕುವುದಿಲ್ಲ ಮಾಡುತ್ತೇವೆ.

26
00:01:19,000 --> 00:01:23,000
ಅಂತಿಮವಾಗಿ, ನಾನು ಪ್ರಕ್ರಿಯೆ ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಅದರ ಪ್ರಮುಖ ವಿವರಗಳು ಕೆಲವು ಮಾಡುತ್ತೇವೆ.

27
00:01:23,000 --> 00:01:25,000
ನಿಮ್ಮ ಡೆಸ್ಕ್ ಟಾಪ್ ಮೇಲೆ ಕುಳಿತು ಯಾವುದೇ ಕಡತದಲ್ಲಿ,

28
00:01:25,000 --> 00:01:28,000
ಮಾಡಲು ಮೊದಲನೆಯದಾಗಿ ಇದು ತೆರೆಯುವುದು.

29
00:01:28,000 --> 00:01:31,000
ಸಿ ನಾವು ಪೂರ್ವನಿರ್ಧರಿತ struct ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸುವ ಮೂಲಕ ಇದನ್ನು

30
00:01:31,000 --> 00:01:33,000
ಡಿಸ್ಕ್ ಒಂದು ಕಡತ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

31
00:01:33,000 --> 00:01:38,460
ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯಲ್ಲಿ, ನಾವು ನಾವು ಬರೆಯಲು ಅಥವಾ ಕಡತದಿಂದ ಓದಲು ನಿರ್ಧರಿಸಿದರು.

32
00:01:38,460 --> 00:01:41,660
ಮುಂದೆ, ನಾವು ನಿಜವಾದ ಓದುವ ಮತ್ತು ಬರೆಯುವ ಹಾಗೆ.

33
00:01:41,660 --> 00:01:44,800
ಈ ಭಾಗದಲ್ಲಿ ಬಳಸಬಹುದು ವಿಶೇಷ ಕಾರ್ಯಗಳನ್ನು ಅನೇಕ ಇವೆ

34
00:01:44,800 --> 00:01:48,790
ಮತ್ತು ಬಹುತೇಕ ಎಲ್ಲ ಕಡತ ನಿಂತಿರುವ ಲೆಟರ್ ಎಫ್, ಪ್ರಾರಂಭಿಸಿ.

35
00:01:48,790 --> 00:01:53,560
ಕೊನೆಯ, ಫೈಲ್ಗಳನ್ನು ಮೇಲಿನ ಮೂಲೆಯಲ್ಲಿ ಸ್ವಲ್ಪ ಕೆಂಪು X ಸದೃಶವಾಗಿ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ತೆರೆಯಲು

36
00:01:53,560 --> 00:01:56,680
ನಾವು ಅಂತಿಮ ಕ್ರಿಯೆ ಕರೆಯೊಂದಿಗೆ ಕಡತ ಮುಚ್ಚಿ.

37
00:01:56,680 --> 00:01:59,540
ಈಗ ನಾವು ಏನು ನೀನು ಯಾವ ಸಾಮಾನ್ಯ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿರುವ,

38
00:01:59,540 --> 00:02:02,000
ಕೋಡ್ಗೆ ಡೈವ್ ನೋಡೋಣ.

39
00:02:02,000 --> 00:02:06,100
>> ಈ ಕೋಶದಲ್ಲಿ, ನಾವು ಎರಡು ಸಿ ಫೈಲ್ಗಳು ಮತ್ತು ಅವುಗಳ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಕಡತಗಳು ಹೊಂದಿರುತ್ತವೆ.

40
00:02:06,100 --> 00:02:09,710
ಬೆರಳಚ್ಚು ಯಂತ್ರದ ಪ್ರೋಗ್ರಾಮ್, ಒಂದು ಆಜ್ಞೆ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

41
00:02:09,710 --> 00:02:12,060
ನಾವು ಸೃಷ್ಟಿಸಲು ಬಯಸುವ ಡಾಕ್ಯುಮೆಂಟ್ ಹೆಸರು.

42
00:02:12,060 --> 00:02:16,160
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು doc.txt ಕರೆ ಮಾಡುತ್ತೇವೆ.

43
00:02:16,160 --> 00:02:19,080
ಕಾರ್ಯಕ್ರಮದ ರನ್ ಮತ್ತು ಸಾಲುಗಳನ್ನು ಒಂದೆರಡು ನಮೂದಿಸಿ ಲೆಟ್.

44
00:02:19,080 --> 00:02:23,660
ಹಾಯ್. ನನ್ನ ಹೆಸರು ಜೇಸನ್ ಹೊಂದಿದೆ.

45
00:02:23,660 --> 00:02:26,710
ಅಂತಿಮವಾಗಿ, ನಾವು "ಬಿಟ್ಟು." ಟೈಪ್ ವಿಲ್

46
00:02:26,710 --> 00:02:29,720
ನಾವು ಈಗ ಈ ಕೋಶದಲ್ಲಿ ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಪಟ್ಟಿ ವೇಳೆ

47
00:02:29,720 --> 00:02:33,770
ನಾವು ಒಂದು ಹೊಸ ಡಾಕ್ಯುಮೆಂಟ್ doc.txt ಎಂಬ ಹೆಸರಿನ ಎಂದು ನೋಡಿ.

48
00:02:34,190 --> 00:02:36,110
ಫೈಲ್ ಕೇವಲ ದಾಖಲಿಸಿದವರು ಈ ಕಾರ್ಯಕ್ರಮವು ಆ.

49
00:02:36,110 --> 00:02:40,520
ಮತ್ತು ಸಹಜವಾಗಿ, ಇದು ತುಂಬಾ ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಸುದೀರ್ಘ ಸರಣಿಯನ್ನು ಹೆಚ್ಚೇನೂ.

50
00:02:41,100 --> 00:02:43,260
ಈ ಹೊಸ ಕಡತವನ್ನು ತೆರೆಯಲು ವೇಳೆ,

51
00:02:43,260 --> 00:02:45,870
ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಪ್ರವೇಶಿಸಿತು ಕೋಡ್ 3 ಸಾಲುಗಳನ್ನು ನೋಡಿ -

52
00:02:46,060 --> 00:02:49,060
ಹಾಯ್. ಮೇ ಹೆಸರು ಜೇಸನ್ ಹೊಂದಿದೆ.

53
00:02:49,580 --> 00:02:52,090
ಆದರೆ ನಿಜವಾಗಿ typewriter.c ರನ್ ಮಾಡಿದಾಗ ವಿಶೇಷವೇನು?

54
00:02:52,810 --> 00:02:55,520
ನಮಗೆ ಆಸಕ್ತಿ ಮೊದಲ ಸಾಲು ಸಾಲು 24.

55
00:02:55,560 --> 00:02:58,490
ಈ ಸಾಲಿನಲ್ಲಿ ನಮ್ಮ ಫೈಲ್ ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿದ.

56
00:02:59,080 --> 00:03:03,140
ಈ ಪಾಯಿಂಟರ್, fopen ಮರಳಿಸುವ ಕಾರ್ಯವನ್ನು ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

57
00:03:03,140 --> 00:03:07,440
ಮೊದಲ ಕಡತ ವಿಸ್ತರಣೆಯನ್ನು ಸರಿಯಾದ ವೇಳೆ ಸೇರಿದಂತೆ ಫೈಲ್ ಹೆಸರು.

58
00:03:07,440 --> 00:03:10,980
ಒಂದು ಕಡತ ವಿಸ್ತರಣೆಯನ್ನು ಅದರ ಕಡಿಮೆ ಮಟ್ಟದಲ್ಲಿ ಕಡತ ಪರಿಣಾಮವನ್ನೇನೂ ಬೀರುವುದಿಲ್ಲ ಎಂದು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

59
00:03:10,980 --> 00:03:14,640
ನಾವು ಯಾವಾಗಲೂ ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಸುದೀರ್ಘ ಸರಣಿಯನ್ನು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ.

60
00:03:14,640 --> 00:03:19,630
ಆದರೆ ಕಡತಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ಗಳು ಅವುಗಳನ್ನು ತೆರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ ಹೇಗೆ ಪ್ರಭಾವ ಮಾಡುತ್ತದೆ.

61
00:03:19,630 --> 00:03:22,290
fopen ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಒಂದು ಪತ್ರ

62
00:03:22,290 --> 00:03:25,300
ಎಂದು ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು ನಂತರ ಮಾಡಲು ಯೋಜನೆ ಏನನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

63
00:03:25,300 --> 00:03:30,630
W, ಆರ್, ಮತ್ತು ಎ - ಈ ವಾದ ಮೂರು ಲಭ್ಯವಿದೆ

64
00:03:30,630 --> 00:03:34,900
ನಾವು ಕಡತಕ್ಕೆ ಬರೆಯಲು ಬಯಸುವ ಏಕೆಂದರೆ ನಾವು ಈ ಸಂದರ್ಭದಲ್ಲಿ W ಆಯ್ಕೆ ಮಾಡಿದ.

65
00:03:34,900 --> 00:03:38,820
ಆರ್, ನೀವು ಬಹುಶಃ ಊಹೆ ಮಾಡಬಹುದು ಎಂದು, ಕಡತವನ್ನು ಓದಲು ಹೊಂದಿದೆ.

66
00:03:38,820 --> 00:03:41,760
ಮತ್ತು ಒಂದು ಕಡತಕ್ಕೆ ಸೇರಿಸುವುದರಿಂದ ಮಾತ್ರ.

67
00:03:41,760 --> 00:03:44,960
ಆದರೆ W ಮತ್ತು ಕಡತಗಳನ್ನು ಬರೆಯಲು ಬಳಸಬಹುದಾಗಿದೆ ಎರಡೂ,

68
00:03:44,960 --> 00:03:47,460
W ಕಡತದ ಆರಂಭದಿಂದ ಬರೆಯುವ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

69
00:03:47,460 --> 00:03:50,810
ಮತ್ತು ಸಂಭಾವ್ಯ ಹಿಂದೆ ಶೇಖರಿಸಿದ ಯಾವುದೇ ಡೇಟಾವನ್ನು ಬದಲಿಸಿ.

70
00:03:50,810 --> 00:03:54,070
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ನಾವು, ತೆರೆಯಲು ಕಡತ,

71
00:03:54,070 --> 00:03:57,180
ನಮ್ಮ ಪ್ರಸ್ತುತ ಕೆಲಸ ಕೋಶವನ್ನು ಸೃಷ್ಟಿಯಾದ.

72
00:03:57,180 --> 00:04:00,540
ಆದರೆ, ನಾವು ಬೇರೆ ಸ್ಥಳದಲ್ಲಿ ಒಂದು ಕಡತವನ್ನು ಪ್ರವೇಶಿಸಲು ಅಥವಾ ರಚಿಸಲು ಬಯಸಿದರೆ,

73
00:04:00,540 --> 00:04:02,650
fopen ಮೊದಲ ವಾದದಲ್ಲಿನ,

74
00:04:02,650 --> 00:04:05,840
ನಾವು ಫೈಲ್ ಹೆಸರು ಜೊತೆಗೆ ಒಂದು ಕಡತ ಪಥವನ್ನು ಸೂಚಿಸಬಹುದು.

75
00:04:05,840 --> 00:04:09,490
ಈ ಪ್ರಕ್ರಿಯೆಯ ಮೊದಲ ಭಾಗವಾಗಿ ದೀರ್ಘ ಕೋಡ್ ಒಂದೇ ಸಾಲು, ಹಾಗೆಯೇ

76
00:04:09,490 --> 00:04:12,350
ಇದು ರೇಖೆಗಳ ಮತ್ತೊಂದು ಸೇರಿಸಲು ಯಾವಾಗಲೂ ಉತ್ತಮ ಇಲ್ಲಿದೆ

77
00:04:12,350 --> 00:04:15,930
ಫೈಲ್ ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು ಅಥವಾ ಸ್ಥಾಪಿಸಲಾಯಿತು ಖಚಿತಪಡಿಸಲು ಪರಿಶೀಲಿಸಿ.

78
00:04:15,930 --> 00:04:20,300
Fopen ಶೂನ್ಯ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ನಾವು, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ ಮುಂದಕ್ಕೆ ಸೃಷ್ಟಿಸಲು ಬಯಸುವ ಎಂದು

79
00:04:20,300 --> 00:04:23,270
ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂ ಮೆಮೊರಿ ಔಟ್ ವೇಳೆ ಈ ಸಂಭವಿಸಬಹುದು

80
00:04:23,270 --> 00:04:27,940
ಅಥವಾ ನಾವು ಸರಿಯಾದ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿರಲಿಲ್ಲ ಒಂದು ಕೋಶದಲ್ಲಿ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಪ್ರಯತ್ನಿಸಿದರೆ.

81
00:04:27,940 --> 00:04:31,780
>> ಪ್ರಕ್ರಿಯೆಯ ಭಾಗ ಎರಡು ಬೆರಳಚ್ಚುಯಂತ್ರದ ನ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ನಡೆಯುತ್ತದೆ.

82
00:04:31,780 --> 00:04:35,000
ನಾವು, ಬಳಕೆದಾರ ಸೂಚನೆಗಳನ್ನು ಪಡೆಯಲು CS50 ಗ್ರಂಥಾಲಯದ ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು

83
00:04:35,000 --> 00:04:37,190
ಮತ್ತು, ಅವರು ಪ್ರೋಗ್ರಾಂನಿಂದ ಹೊರನಡೆ ಬಯಸುವುದಿಲ್ಲ ಊಹಿಸಿಕೊಂಡು

84
00:04:37,190 --> 00:04:41,940
ನಾವು ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಕಡತಕ್ಕೆ ಬರೆಯಲು ಕಾರ್ಯ fputs ಬಳಸಿ.

85
00:04:41,940 --> 00:04:46,700
fputs ನಾವು ಕಡತಕ್ಕೆ ಬರೆಯಲು ಬಳಸುವ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ.

86
00:04:46,700 --> 00:04:51,920
ಇತರೆ fwrite, fputc, ಮತ್ತು fprintf ಸೇರಿವೆ.

87
00:04:51,920 --> 00:04:54,840
ಹೊರತಾಗಿ ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಯ ನಾವು, ಆದರೂ, ಬಳಸಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ

88
00:04:54,840 --> 00:04:57,480
ಎಲ್ಲಾ ಅವರ ವಾದಗಳನ್ನು ಮೂಲಕ ಅವಶ್ಯಕತೆ

89
00:04:57,480 --> 00:04:59,670
ಕನಿಷ್ಠ ಎರಡು ವಿಷಯಗಳ -

90
00:04:59,670 --> 00:05:03,140
ಅದರ ಲಿಖಿತ ಅಗತ್ಯವಿದೆ ಅಲ್ಲಿ ಬರೆದು ಅಗತ್ಯವಿದೆ.

91
00:05:03,140 --> 00:05:07,240
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ಇನ್ಪುಟ್ ಲಿಖಿತ ಅಗತ್ಯವಿದೆ ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ

92
00:05:07,240 --> 00:05:11,290
ಮತ್ತು FP ನಾವು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಅಲ್ಲಿ ನಮ್ಮನ್ನು ನಿರ್ದೇಶಿಸುತ್ತದೆ ಸೂಚಿಯಾಗಿದೆ.

93
00:05:11,290 --> 00:05:15,330
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವಾಗಿ ಎರಡು ಬದಲಿಗೆ ನೇರವಾಗಿರುತ್ತದೆ.

94
00:05:15,330 --> 00:05:17,360
ನಾವು ಕೇವಲ ಬಳಕೆದಾರರ ಒಂದು ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ನೀವು

95
00:05:17,360 --> 00:05:22,120
ಮತ್ತು ನಮ್ಮ ಫೈಲ್ ನೇರವಾಗಿ ಸೇರಿಸಲು ಕಡಿಮೆ ಮಾಡಲು ಯಾವುದೇ ಇನ್ಪುಟ್ ಊರ್ಜಿತಗೊಳಿಸುವಿಕೆ ಅಥವಾ ಭದ್ರತಾ ಪರೀಕ್ಷೆಗಳು ಸೇರಿವೆ.

96
00:05:22,120 --> 00:05:26,160
ಸಾಮಾನ್ಯವಾಗಿ, ಆದಾಗ್ಯೂ, ಎರಡನೇ ಭಾಗ ನಿಮ್ಮ ಕೋಡ್ ಬೃಹತ್ ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

97
00:05:26,160 --> 00:05:30,580
ನಾವು ಫೈಲ್ ಮುಚ್ಚಿ ಅಲ್ಲಿ ಅಂತಿಮವಾಗಿ, ಭಾಗ ಮೂರು, ಸಾಲು 58 ಮೇಲೆ.

98
00:05:30,580 --> 00:05:34,860
ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಮೂಲ ಕಡತ ಪಾಯಿಂಟರ್ fclose ಮತ್ತು ರವಾನಿಸಲು ಕರೆ.

99
00:05:34,860 --> 00:05:39,500
ನಂತರದ ಸಾಲಿನಲ್ಲಿ, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯ ಸಂಕೇತ, ಶೂನ್ಯ ಹಿಂತಿರುಗಿ.

100
00:05:39,500 --> 00:05:42,630
ಮತ್ತು, ಹೌದು, ಭಾಗ ಮೂರು ಎಂದು ಮಾಹಿತಿ ಸರಳವಾಗಿದೆ.

101
00:05:42,630 --> 00:05:45,260
>> ನ ಕಡತಗಳನ್ನು ಓದಲು ಕಡೆಗೆ ನೋಡೋಣ.

102
00:05:45,260 --> 00:05:48,220
ಮತ್ತೆ ನಮ್ಮ ಕೋಶದಲ್ಲಿ ನಾವು printer.c ಎಂಬ ಕಡತ ಹೊಂದಿರುತ್ತವೆ.

103
00:05:48,220 --> 00:05:50,910
ನಾವು ಕೇವಲ ದಾಖಲಿಸಿದವರು ಕಡತವನ್ನು ಚಲಾಯಿಸಲು ಅವಕಾಶ -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
ಈ ಕಾರ್ಯಕ್ರಮ, ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಕೇವಲ ಕಡತದ ವಿಷಯಗಳನ್ನು ಇದು ರವಾನಿಸಲಾಗಿದೆ ಮುದ್ರಿಸುತ್ತದೆ ಕಾಣಿಸುತ್ತದೆ.

106
00:05:58,150 --> 00:06:00,230
ಹಾಗೂ ನಾವು ಹೊಂದಿಲ್ಲ.

107
00:06:00,230 --> 00:06:03,780
ಕೋಡ್ ಸಾಲುಗಳನ್ನು ನಾವು ಹಿಂದಿನ ಬೆರಳಚ್ಚು ಮತ್ತು doc.txt ರಲ್ಲಿ ಉಳಿಸಿದ ಎಂದು.

108
00:06:03,780 --> 00:06:06,980
ಹಾಯ್. ನನ್ನ ಹೆಸರು ಜೇಸನ್ ಹೊಂದಿದೆ.

109
00:06:06,980 --> 00:06:09,120
ವೇಳೆ printer.c ನಾವು ಡೈವ್,

110
00:06:09,120 --> 00:06:13,570
ನಾವು ಕೋಡ್ ಸಾಕಷ್ಟು ನಾವು typewriter.c ಮೂಲಕ ನಡೆದರು ಏನು ಹೋಲುತ್ತದೆ ಎಂದು ನೋಡಿ.

111
00:06:13,570 --> 00:06:16,720
ನಾವು ಫೈಲ್ ತೆರೆಯಿತು ಅಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಸಾಲು 22,,

112
00:06:16,720 --> 00:06:19,220
ನಾವು ಫೈಲ್ ಮುಚ್ಚಲಾಗಿದೆ ಅಲ್ಲಿ ಮತ್ತು ಸಾಲು 39,,

113
00:06:19,220 --> 00:06:23,890
ಎರಡೂ typewriter.c ಬಹುತೇಕ ಒಂದೇ, fopen ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಉಳಿಸಿ.

114
00:06:23,890 --> 00:06:26,510
ನಾವು ಒಂದು ಕಡತದಿಂದ ಓದಲು ನೀವು ಈ ಸಮಯದಲ್ಲಿ,

115
00:06:26,510 --> 00:06:29,040
ಆದ್ದರಿಂದ ನಾವು W ಬದಲಿಗೆ R ಆಯ್ಕೆ ಮಾಡಿದ್ದೀರಿ.

116
00:06:29,040 --> 00:06:31,950
ಹೀಗಾಗಿ, ಅವರ ಪ್ರಕ್ರಿಯೆಯ ಎರಡನೇ ಭಾಗದಲ್ಲಿ ಕೇಂದ್ರೀಕರಿಸಲು ಅವಕಾಶ.

117
00:06:31,950 --> 00:06:36,060
ಸಾಲು 35 ರಲ್ಲಿ, ನಮ್ಮ 4 ಲೂಪ್ ಎರಡನೇ ಸ್ಥಿತಿ,

118
00:06:36,060 --> 00:06:38,590
ನಾವು, fgets ಗೆ ಕರೆ ಮಾಡಿ

119
00:06:38,590 --> 00:06:42,190
ಮೊದಲು fputs ಕಂಪ್ಯಾನಿಯನ್ ಟು ಕಾರ್ಯ.

120
00:06:42,190 --> 00:06:44,660
ನಾವು ಮೂರು ವಾದಗಳನ್ನು ಹೊಂದಿರುವ ಈ ಸಮಯದಲ್ಲಿ.

121
00:06:44,660 --> 00:06:48,810
ಮೊದಲ ಸಾಲನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಅಲ್ಲಿ ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಯಾಗಿದೆ.

122
00:06:48,810 --> 00:06:52,670
ಎರಡನೇ ಓದಬಹುದು ಪಾತ್ರಗಳು ಗರಿಷ್ಟ ಸಂಖ್ಯೆ.

123
00:06:52,670 --> 00:06:56,010
ಮತ್ತು ಮೂರನೇ ನಾವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ ಯಾವ ಕಡತಕ್ಕೆ ಸೂಚಿಯಾಗಿದೆ.

124
00:06:56,010 --> 00:07:00,780
ನೀವು fgets ಶೂನ್ಯ ಮರಳಿದಾಗ ಲೂಪ್ ಫಾರ್ ಕೊನೆಗೊಳ್ಳುವ ಗಮನಕ್ಕೆ ಮಾಡುತ್ತೇವೆ.

125
00:07:00,780 --> 00:07:02,940
ಈ ಸಂಭವಿಸಿರಬಹುದು ಎರಡು ಕಾರಣ ಇವೆ.

126
00:07:02,940 --> 00:07:05,380
ಮೊದಲ, ದೋಷ ಸಂಭವಿಸಿರಬಹುದು.

127
00:07:05,380 --> 00:07:10,740
ಎರಡನೇ ಮತ್ತು ಹೆಚ್ಚು, ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು ಮತ್ತು ಯಾವುದೇ ಹೆಚ್ಚಿನ ಅಕ್ಷರಗಳನ್ನು ಓದಲು ಮಾಡಲಾಯಿತು.

128
00:07:10,740 --> 00:07:14,040
ನೀವು ಚಕಿತಗೊಳಿಸುತ್ತದೆ ಮಾಡುತ್ತಿರುವ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ಕ್ರಿಯೆಗಳನ್ನು ನಮಗೆ ಅವಕಾಶ ಎಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ

129
00:07:14,040 --> 00:07:17,160
ಯಾವ ಕಾರಣಕ್ಕಾಗಿ ಈ ನಿರ್ದಿಷ್ಟ ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಕಾರಣವನ್ನು ಹೊಂದಿದೆ.

130
00:07:17,160 --> 00:07:21,090
ಮತ್ತು, ನಿರೀಕ್ಷೆಯಂತೆ, ಕಡತಗಳನ್ನು ಕೆಲಸ ಜೊತೆ ಮಾಡಬೇಕು ಏಕೆಂದರೆ,

131
00:07:21,090 --> 00:07:26,940
ferror ಕಾರ್ಯ ಮತ್ತು feof ಕಾರ್ಯದ ಆರಂಭದ ಅಕ್ಷರದ ಎಫ್ ಜೊತೆ. ಎರಡೂ

132
00:07:26,940 --> 00:07:32,130
>> ಅಂತಿಮವಾಗಿ, ನಾವು ಅಂತ್ಯಗೊಳಿಸುವ ಮುನ್ನ, ಕಡತ ಕ್ರಿಯೆಯ ಕೊನೆಯಲ್ಲಿ ಬಗ್ಗೆ ಒಂದು ತ್ವರಿತ ಟಿಪ್ಪಣಿ,

133
00:07:32,130 --> 00:07:36,690
ಇದು, ಕೇವಲ ಹೇಳಿದಂತೆ, feof ಎಂದು ಬರೆಯಲಾಗಿದೆ.

134
00:07:36,690 --> 00:07:41,550
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಮಾಡುವಾಗ ಮತ್ತು ಲೂಪ್ ಫಾರ್ ಹಂತಹಂತವಾಗಿ ಕಡತಗಳನ್ನು ಮೂಲಕ ನಿಮ್ಮ ರೀತಿಯಲ್ಲಿ ಓದಲು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಕಾಣುವಿರಿ.

135
00:07:41,550 --> 00:07:45,790
ನೀವು ಈ ಕಡತಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು ನಂತರ ಆದ್ದರಿಂದ, ನೀವು ಈ ಕುಣಿಕೆಗಳು ಕೊನೆಗೊಳಿಸಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಗತ್ಯವಿದೆ.

136
00:07:45,790 --> 00:07:50,510
ನಿಮ್ಮ ಕಡತ ಪಾಯಿಂಟರ್ ಮೇಲೆ feof ಕರೆ ಮತ್ತು ಇದು ನಿಜ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುವ

137
00:07:50,510 --> 00:07:52,310
ಕೇವಲ ಹಾಗೆ ಎಂದು.

138
00:07:52,310 --> 00:07:59,820
ಆದ್ದರಿಂದ, ಪರಿಸ್ಥಿತಿ (! Feof (FP)) ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಕರಾರುವಾಕ್ಕಾಗಿ ಸೂಕ್ತವಾದ ಪರಿಹಾರವನ್ನು ಹೋಲುವಂತಿದ್ದು ಇರಬಹುದು.

139
00:07:59,820 --> 00:08:03,770
ಆದರೆ, ನಾವು ನಮ್ಮ ಪಠ್ಯ ಫೈಲ್ ಉಳಿದ ಒಂದು ಲೈನ್ ಹೊಂದಿವೆ ಸೇ.

140
00:08:03,770 --> 00:08:07,130
ನಮ್ಮ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಅನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಯೋಜಿಸಿದಂತೆ ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

141
00:08:07,130 --> 00:08:12,750
ಮೂಲಕ ಮುಂದಿನ ಸುತ್ತಿನಲ್ಲಿ ರಂದು, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ, FP ಆಫ್ feof ನಿಜ ನೀವು ಪರೀಕ್ಷಿಸಿ ಕಾಣಿಸುತ್ತದೆ

142
00:08:12,750 --> 00:08:15,430
ಆದರೆ - ಮತ್ತು ಈ ಇಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ -

143
00:08:15,430 --> 00:08:17,770
ಇದು ಇನ್ನೂ ನಿಜವಾದ ಸಾಧ್ಯವಿಲ್ಲ.

144
00:08:17,770 --> 00:08:21,110
Feof ಉದ್ದೇಶಕ್ಕಾಗಿ ಪರಿಶೀಲಿಸಲು ಏಕೆಂದರೆ ಆ

145
00:08:21,110 --> 00:08:24,400
ಒಂದು ಓದಲು ಕಾರ್ಯಕ್ಕೆ ಮುಂದಿನ ಕರೆ ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹೊಡೆಯಲು ಹೋದರೆ,

146
00:08:24,400 --> 00:08:28,190
ಆದರೆ ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಈಗಾಗಲೇ ತಲುಪಿದೆ ಇಲ್ಲವೋ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಲು.

147
00:08:28,190 --> 00:08:30,140
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ,

148
00:08:30,140 --> 00:08:32,780
ನಮ್ಮ ಕಡತದ ಕೊನೆಯ ಸಾಲನ್ನು ಓದುವ ನಿಖರವಾಗಿ ಸರಾಗವಾಗಿ ಹೋಗುತ್ತದೆ,

149
00:08:32,780 --> 00:08:36,210
ಆದರೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಇನ್ನೂ ನಮ್ಮ ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹೊಡೆಯಲು ನೀವು ಗೊತ್ತಿಲ್ಲ.

150
00:08:36,210 --> 00:08:40,549
ಒಂದು ಹೆಚ್ಚುವರಿ ಓದಲು ಮಾಡುತ್ತದೆ ರವರೆಗೆ ಇದು ಅಲ್ಲ ಇದು ಕೌಂಟರ್ ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ಆ.

151
00:08:40,549 --> 00:08:43,210
ಆದ್ದರಿಂದ, ಒಂದು ಸರಿಯಾದ ಸ್ಥಿತಿಯನ್ನು ಕೆಳಗಿನ ಎಂದು:

152
00:08:43,210 --> 00:08:49,330
fgets ಮತ್ತು ಅದರ ಮೂರು ವಾದಗಳನ್ನು - ಉತ್ಪಾದನೆ, ಉತ್ಪಾದನೆಯ ಗಾತ್ರ, ಮತ್ತು FP -

153
00:08:49,330 --> 00:08:52,570
ಮತ್ತು ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ ಎಲ್ಲಾ ಶೂನ್ಯ ಗೆ.

154
00:08:52,570 --> 00:08:55,260
ಇದು ನಾವು printer.c ಹೋಗಿದ್ದರಿಂದ ಮಾರ್ಗ

155
00:08:55,260 --> 00:08:57,890
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಲೂಪ್ ಹೊರಟ ನಂತರ,

156
00:08:57,890 --> 00:09:04,290
ನೀವು feof ಅಥವಾ ferror ಈ ಲೂಪ್ ನಿರ್ಗಮಿಸುವ ನಿರ್ದಿಷ್ಟ ತರ್ಕಕ್ಕೆ ಬಳಕೆದಾರ ತಿಳಿಸಲು ಕರೆಯಬಹುದು.

157
00:09:04,290 --> 00:09:08,100
>> ಗೆ ಬರವಣಿಗೆ ಮತ್ತು ಒಂದು ಕಡತವನ್ನು ಓದುವಲ್ಲಿ, ಅದರ ಮೂಲಭೂತ ನಲ್ಲಿ, ಆಗಿದೆ

158
00:09:08,100 --> 00:09:10,150
ಸರಳ 3 ಭಾಗದ ಪ್ರಕ್ರಿಯೆ.

159
00:09:10,150 --> 00:09:12,530
ಮೊದಲ, ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು.

160
00:09:12,530 --> 00:09:16,740
ಎರಡನೇ, ನಾವು ನಮ್ಮ ಫೈಲ್ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಪುಟ್ ಅಥವಾ ಹೊರಗೆ ಕೆಲವು ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಡಿ.

161
00:09:16,740 --> 00:09:19,200
ಮೂರನೇ, ನಾವು ಕಡತ ಮುಚ್ಚಿ.

162
00:09:19,200 --> 00:09:21,170
ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಭಾಗಗಳು ಸುಲಭ.

163
00:09:21,170 --> 00:09:23,920
ಟ್ರಿಕಿ ಸ್ಟಫ್ ಇರುತ್ತದೆ ಅಲ್ಲಿ ಮಧ್ಯಮ ಭಾಗವಾಗಿದೆ.

164
00:09:23,920 --> 00:09:27,760
ಮತ್ತು ಆದರೂ HOOD ಕೆಳಗೆ ನಾವು ಯಾವಾಗಲೂ, ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಸುದೀರ್ಘ ಸರಣಿಯನ್ನು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ

165
00:09:27,760 --> 00:09:30,710
ಅಮೂರ್ತತೆಯ ಒಂದು ಪದರ ಸೇರಿಸಲು ಕೋಡಿಂಗ್ ಅದು ಸಹಾಯ ಮಾಡುತ್ತದೆ

166
00:09:30,710 --> 00:09:35,350
ಹೆಚ್ಚು ನಿಕಟವಾಗಿ ನಾವು ನೋಡಿದ ಬಳಸಲಾಗುತ್ತದೆ ಏನನ್ನು ಹೋಲುವ ಏನಾದರೂ ಆಗಿ ಅನುಕ್ರಮ ತಿರುಗುತ್ತದೆ.

167
00:09:35,350 --> 00:09:39,570
ಉದಾಹರಣೆಗೆ, ನಾವು ಒಂದು 24 ಬಿಟ್ ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ ಕೆಲಸ ಬಳಸುತ್ತಿದ್ದರೆ,

168
00:09:39,570 --> 00:09:43,290
ನಾವು ಸಾಧ್ಯತೆ ಓದಲು ಅಥವಾ ಒಂದು ಸಮಯದಲ್ಲಿ ಮೂರು ಬೈಟ್ಗಳು ಬರೆಯುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ.

169
00:09:43,290 --> 00:09:46,450
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ಸೂಕ್ತವಾಗಿ ಹೆಸರಿಸಲು ಅರ್ಥ ಎಂದು

170
00:09:46,450 --> 00:09:48,980
3 ಬೈಟ್ಗಳು ದೊಡ್ಡ ಒಂದು struct.

171
00:09:48,980 --> 00:09:51,410
>> ಕಡತಗಳನ್ನು ಕೆಲಸ ಸಂಕೀರ್ಣ ಕಾಣಿಸಬಹುದು ಆದಾಗ್ಯೂ,

172
00:09:51,410 --> 00:09:54,530
ಅವುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಮಗೆ ನಿಜವಾಗಿಯೂ ಗಮನಾರ್ಹ ಏನೋ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.

173
00:09:54,530 --> 00:09:58,880
ನಾವು, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೊರಗೆ ವಿಶ್ವದ ರಾಜ್ಯದ ಬದಲಾಯಿಸಬಹುದು

174
00:09:58,880 --> 00:10:01,730
ನಾವು, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಜೀವನ ಮೀರಿ ಜೀವಿಸುವ ಏನೋ ರಚಿಸಬಹುದು

175
00:10:01,730 --> 00:10:07,190
ಅಥವಾ ನಾವು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಮೊದಲು ಸೃಷ್ಟಿಯಾಯಿತು ಏನೋ ಬದಲಾಯಿಸಬಹುದು.

176
00:10:07,190 --> 00:10:11,210
ಕಡತಗಳನ್ನು ಪರಸ್ಪರ ಸಿ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಒಂದು ನಿಜವಾಗಿಯೂ ಪ್ರಬಲ ಭಾಗವಾಗಿದೆ

177
00:10:11,210 --> 00:10:15,300
ಮತ್ತು ನಾನು ಬರಲು ಕೋಡ್ ರಲ್ಲಿ ಇದನ್ನು ರಚಿಸಲು ನೀನು ಎಂಬುದನ್ನು ಖುಷಿ ತಂದಿದೆ.

178
00:10:15,300 --> 00:10:19,770
ನನ್ನ ಹೆಸರು ಜೇಸನ್ ಹಿರ್ಸ್ಚೋರ್ನ್ ಹೊಂದಿದೆ. ಈ CS50 ಹೊಂದಿದೆ.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [ಲಾಫ್ಟರ್]

181
00:10:25,940 --> 00:10:29,330
ಸರಿ. ಒಂದು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಇಲ್ಲಿ ನಾವು ಹೋಗಿ.

182
00:10:49,000 --> 00:10:52,140
ನಾವು ಒಂದು ಕಡತದ ಯೋಚನೆ ಮಾಡಿದರೆ - >> ಓಹ್, ನಿರೀಕ್ಷಿಸಿ. ಕ್ಷಮಿಸಿ.

183
00:10:52,140 --> 00:10:56,800
[ಲಾಫ್ಟರ್] ಸರಿ.

184
00:11:06,620 --> 00:11:09,970
ಹಲೋ.

185
00:11:13,670 --> 00:11:16,310
ನಾವು ಒಂದು ಕಡತದ ಯೋಚನೆ ಮಾಡಿದರೆ -

186
00:11:17,610 --> 00:11:20,710
ನೀವು ಒಂದು ಕಡತದ ಯೋಚನೆ ಮಾಡಿದರೆ - ಸರಿ. ನೀವು ಸಿದ್ಧರಾದಾಗ ಹೇಳಿ.

187
00:11:20,710 --> 00:11:22,520
ಓಹ್, ಮಹಾನ್.

188
00:11:22,520 --> 00:11:26,180
ಒಂದು ಟೆಲಿಪ್ರೊಂಪ್ಟೆರನ್ನು ಓದುವಲ್ಲಿ ಆದರೂ ಕಾಣಿಸಬಹುದು - ಯಾವುದೇ. ನನ್ನ ಕೆಟ್ಟ.