1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> ಸ್ಪೀಕರ್: ಇಲ್ಲಿಯವರೆಗೆ, ಇದು ಸಾಧ್ಯತೆ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಎಂದು

3
00:00:07,870 --> 00:00:10,170
ಸ್ವಲ್ಪ ನಶ್ವರ ಎಂದು.

4
00:00:10,170 --> 00:00:13,310
ನೀವು ಮಾರಿಯೋ ಅಥವಾ ದುರಾಸೆಯ ಒಂದು ಪ್ರೋಗ್ರಾಂ ರನ್.

5
00:00:13,310 --> 00:00:17,350
ಇದು ಬಹುಶಃ ಅಪೇಕ್ಷಿಸುತ್ತದೆ, ಏನೋ ಮಾಡುತ್ತದೆ
ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಬಳಕೆದಾರರನ್ನು,

6
00:00:17,350 --> 00:00:20,400
ತೆರೆಗೆ ಕೆಲವು ಔಟ್ಪುಟ್ ಮುದ್ರಿಸಿ
ಆದರೆ ನಂತರ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ಮುಗಿಯುವ

7
00:00:20,400 --> 00:00:23,252
ಯಾವುದೇ ಪುರಾವೆಗಳು ನಿಜವಾಗಿಯೂ ಇಲ್ಲ
ಇದು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ನಡೆಸುತ್ತಿದ್ದರು.

8
00:00:23,252 --> 00:00:25,960
ನಾನು ಖಚಿತವಾಗಿ, ನೀವು ಬಿಟ್ಟು ಇರಬಹುದು, ಅರ್ಥ
ಇದು, ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ತೆರೆಯಿರಿ

9
00:00:25,960 --> 00:00:29,770
ನಿಮ್ಮ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ವೇಳೆ, ಇಲ್ಲ
ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಪುರಾವೆ.

10
00:00:29,770 --> 00:00:33,720
ನಾವು ಸಂಗ್ರಹಿಸುವ ಸಾಧನವಾಗಿ ಇಲ್ಲ
ನಿರಂತರ ಮಾಹಿತಿ, ಮಾಹಿತಿ

11
00:00:33,720 --> 00:00:36,890
ನಮ್ಮ ನಂತರ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಸ್ಥಗಿತಗೊಂಡಿದೆ,

12
00:00:36,890 --> 00:00:39,241
ಅಥವಾ ನಾವು ಈ ಹಂತದವರೆಗೆ ಮಾಡಿಲ್ಲ.

13
00:00:39,241 --> 00:00:41,490
ಅದೃಷ್ಟವಶಾತ್ ಆದರೂ, ಸಿ ಮಾಡುತ್ತದೆ
ಸಾಮರ್ಥ್ಯವನ್ನು ನಮಗೆ ಒದಗಿಸುತ್ತದೆ

14
00:00:41,490 --> 00:00:44,220
ಅಳವಡಿಸಿಕೊಂಡು ಇದನ್ನು
ಕರೆಯುವುದನ್ನು

15
00:00:44,220 --> 00:00:48,330
ಒಂದು ಕಡತವನ್ನು ಒಂದು ರಚನೆ ಮೂಲತಃ
ನೀವು ದುಪ್ಪಟ್ಟಾದ ಒಂದು ಕಡತ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

16
00:00:48,330 --> 00:00:53,826
ನೀವು ಇಂತಹ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಕ್ಲಿಕ್
ಒಂದು ರೇಖಾತ್ಮಕ ಬಳಕೆದಾರ ವಾತಾವರಣದೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ.

17
00:00:53,826 --> 00:00:55,700
ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡುವಾಗ
ಸಿ, ನಾವು ವಾಸ್ತವವಾಗಿ ಆರ್

18
00:00:55,700 --> 00:00:59,965
ಕೆಲಸ ಹೋಗುವ
ಪಾಯಿಂಟರ್ಸ್ ಕಡತ ಕಡತಗಳನ್ನು ಗೆ stars--

19
00:00:59,965 --> 00:01:02,090
ಸ್ವಲ್ಪ ಹೊರತುಪಡಿಸಿ
ನಾವು ಒಂದೆರಡು ಬಗ್ಗೆ ಮಾತನಾಡಿ

20
00:01:02,090 --> 00:01:04,560
ಕಾರ್ಯಗಳನ್ನು ಎಂದು
ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ.

21
00:01:04,560 --> 00:01:08,990
ನೀವು ನಿಜವಾಗಿಯೂ ಅಗೆದು ಹೊಂದಿವೆ ಮಾಡಬೇಕಿಲ್ಲ
ತಿಳುವಳಿಕೆ ಪಾಯಿಂಟರ್ಸ್ ತುಂಬಾ ಆಳವಾದ

22
00:01:08,990 --> 00:01:09,730
ತಮ್ಮನ್ನು.

23
00:01:09,730 --> 00:01:12,870
ಸ್ವಲ್ಪ ಚಿಕ್ಕ ಬಿಟ್ ಇಲ್ಲ
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಅಲ್ಲಿ,

24
00:01:12,870 --> 00:01:18,090
ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಫೈಲ್ ಮತ್ತು
ಪಾಯಿಂಟರ್ಸ್, ಪರಸ್ಪರ ಆದರೆ,

25
00:01:18,090 --> 00:01:20,290
ಒಂದೇ ವಿಷಯ ಅಲ್ಲ.

26
00:01:20,290 --> 00:01:22,440
>> ಈಗ ನಾನು ಯಾವಾಗ ಅರ್ಥವೇನು
ನಾನು ನಿರಂತರ ಡೇಟಾ ಹೇಳುತ್ತಾರೆ?

27
00:01:22,440 --> 00:01:23,650
ನಿರಂತರ ಡೇಟಾ ಏನು?

28
00:01:23,650 --> 00:01:25,232
ನಾವು ಅದರ ಬಗ್ಗೆ ಏಕೆ ಕಾಳಜಿ ಇಲ್ಲ?

29
00:01:25,232 --> 00:01:27,190
ಎಂದು, ಉದಾಹರಣೆಗೆ, ಸೇ
ನೀವು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ

30
00:01:27,190 --> 00:01:29,850
ಅಥವಾ ನೀವು ಬರೆದಿದ್ದೇವೆ ಒಂದು
ಒಂದು ಆಟವಾಗಿದೆ ಎಂದು ಪ್ರೋಗ್ರಾಂ,

31
00:01:29,850 --> 00:01:32,960
ಮತ್ತು ನೀವು ಟ್ರ್ಯಾಕ್ ಬಯಸುವ
ಬಳಕೆದಾರರ ಚಲಿಸುತ್ತದೆ ಎಲ್ಲಾ

32
00:01:32,960 --> 00:01:36,620
ಆದ್ದರಿಂದ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ಬಹುಶಃ ವೇಳೆ,
ನೀವು ಆಟದ ನಂತರ ಕಡತ ವಿಮರ್ಶಿಸುವುದರ.

33
00:01:36,620 --> 00:01:39,970
ಆ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಅರ್ಥ ಇಲ್ಲಿದೆ
ನಿರಂತರ ಮಾಹಿತಿ ಬಗ್ಗೆ ಮಾತನಾಡಲು.

34
00:01:39,970 --> 00:01:43,930
>> ಓಟದ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ, ಒಂದು ಫೈಲ್ ಅನ್ನು ರೂಪಿಸಿದಾಗ.

35
00:01:43,930 --> 00:01:45,680
ಮತ್ತು ಯಾವಾಗ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ
ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಗಿತಗೊಂಡಿದೆ,

36
00:01:45,680 --> 00:01:48,689
ಫೈಲ್ ಇನ್ನೂ ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

37
00:01:48,689 --> 00:01:50,230
ಮತ್ತು ನಾವು ಅದನ್ನು ನೋಡಿದರೆ ಮತ್ತು ಪರೀಕ್ಷಿಸುತ್ತಾರೆ.

38
00:01:50,230 --> 00:01:53,670
ಆದ್ದರಿಂದ ಕಾರ್ಯಕ್ರಮದ ಸೆಟ್ ಎಂದು
ಕೆಲವು ನಿರಂತರ ಡೇಟಾ ರಚಿಸಿದ,

39
00:01:53,670 --> 00:01:57,390
ಡೇಟಾ ಪ್ರೋಗ್ರಾಂ ನಂತರ ಅಸ್ತಿತ್ವ
ಚಾಲನೆಯಲ್ಲಿರುವ ಮುಗಿದಿದೆ.

40
00:01:57,390 --> 00:02:02,320
>> ಈಗ ಕೆಲಸ ಈ ಎಲ್ಲಾ ಚಟುವಟಿಕೆಗಳಿಗೆ
ಕಡತಗಳ ಮತ್ತು ಕುಶಲಬಳಕೆಯ ಜೊತೆ

41
00:02:02,320 --> 00:02:04,940
ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಅವುಗಳ
ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h ವಾಸಿಸುತ್ತಿದ್ದಾರೆ,

42
00:02:04,940 --> 00:02:08,210
ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಎಂದು
ನೀವು ಸಾಧ್ಯತೆ ಪೌಂಡ್ ಇಲ್ಲಿಗೆ

43
00:02:08,210 --> 00:02:10,910
ಸಾಕಷ್ಟು ಮೇಲಿರುವ ಸೇರಿದಂತೆ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಹೆಚ್ಚು ಎಲ್ಲಾ

44
00:02:10,910 --> 00:02:14,130
ಇದು ಒಂದು ಹೊಂದಿದೆ ಏಕೆಂದರೆ
ನಮಗೆ ಅತ್ಯಂತ ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು

45
00:02:14,130 --> 00:02:16,130
ಸಹ ಅನುಮತಿಸುತ್ತದೆ, printf
ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h. ವಾಸಿಸುವ

46
00:02:16,130 --> 00:02:20,400
ಆದ್ದರಿಂದ ನೀವು ಸೇರಿವೆ ಪೌಂಡ್ ಅಗತ್ಯವಿಲ್ಲ
ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕಡತಗಳನ್ನು ಬಹುಶಃ

47
00:02:20,400 --> 00:02:23,540
ಸಲುವಾಗಿ ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ.

48
00:02:23,540 --> 00:02:29,980
>> ಈಗ ಪ್ರತಿಯೊಂದು ಕಡತ ಪಾಯಿಂಟರ್ ಕಾರ್ಯ,
ಅಥವಾ ಪ್ರತಿಯೊಂದು ಕಡತ ನಾನು / ಒ, ಇನ್ಪುಟ್ ಔಟ್ಪುಟ್

49
00:02:29,980 --> 00:02:33,310
ಕಾರ್ಯ, ಒಂದು ಸ್ವೀಕರಿಸುತ್ತದೆ
ಅದರ ನಿಯತಾಂಕಗಳನ್ನು ಅಥವಾ ಒಳಹರಿವಿನ

50
00:02:33,310 --> 00:02:35,822
ಹೊರತುಪಡಿಸಿ ಫೈಲ್ ಪಾಯಿಂಟರ್
ಒಂದು, fopen ಇದು

51
00:02:35,822 --> 00:02:38,280
ನೀವು ಕಡತ ಪಡೆಯಲು ಬಳಸಲು ಏನು
ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಪಾಯಿಂಟರ್.

52
00:02:38,280 --> 00:02:41,010
ಆದರೆ ನೀವು ತೆರೆದಿರುವ ನಂತರ
ಫೈಲ್ ಮತ್ತು ನೀವು ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಪಡೆಯಲು,

53
00:02:41,010 --> 00:02:43,510
ನೀವು ನಂತರ ಅವುಗಳನ್ನು ರವಾನಿಸಬಹುದು
ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ವಾದಗಳು

54
00:02:43,510 --> 00:02:46,720
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ನೀನು
ಇಂದು, ಹಾಗೂ ಅನೇಕರು

55
00:02:46,720 --> 00:02:48,520
ಆದ್ದರಿಂದ ನೀವು ಕಡತಗಳನ್ನು ಕೆಲಸ ಮಾಡಬಹುದು.

56
00:02:48,520 --> 00:02:50,980
>> ಆದ್ದರಿಂದ ಆರು ಸಾಕಷ್ಟು ಇವೆ
ಸಾಮಾನ್ಯ ಮೂಲ ಪದಗಳಿಗಿಂತ

57
00:02:50,980 --> 00:02:52,870
ನಾವು ಇಂದು ಬಗ್ಗೆ ಮಾತನಾಡಲು ನೀನು.

58
00:02:52,870 --> 00:02:57,160
fopen ಮತ್ತು ಅದರ ಜೊತೆಗಾರ
ಕಾರ್ಯ fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ fputc,
ಮತ್ತು fread ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ,

60
00:03:02,670 --> 00:03:03,820
ರಚಿಸುವಲ್ಲಿ.

61
00:03:03,820 --> 00:03:05,180
ಆದ್ದರಿಂದ ಬಲ ಪಡೆಯಲು ಅವಕಾಶ.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- ಇದು ಏನು ಮಾಡುತ್ತದೆ?

63
00:03:07,050 --> 00:03:10,050
ಸರಿ, ಇದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಇದು
ಇದು ಒಂದು ಕಡತವನ್ನು ನೀವು ಪಾಯಿಂಟರ್ ನೀಡುತ್ತದೆ,

64
00:03:10,050 --> 00:03:14,000
ಆದ್ದರಿಂದ ನೀವು ಆ ಬಳಸಬಹುದಾದ
ಒಂದು ಚರ್ಚೆಯಂತೆ ಪಾಯಿಂಟರ್ ಫೈಲ್

65
00:03:14,000 --> 00:03:16,730
ಇತರ ಕಡತ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ಯಾವುದೇ.

66
00:03:16,730 --> 00:03:19,100
ಪ್ರಮುಖ ವಿಷಯ
fopen ಜೊತೆ ನೆನಪಿಡುವ

67
00:03:19,100 --> 00:03:24,222
ನೀವು ತೆರೆದಿದ್ದೀರಿ ಎಂದು ನಂತರ
ಫೈಲ್ ಅಥವಾ ಇಲ್ಲಿ ಒಂದು ರೀತಿಯ ಕರೆ ಮಾಡಿದ,

68
00:03:24,222 --> 00:03:26,930
ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ
ನೀವು ಮತ್ತೆ ಕೊಂಡಿರುವ ಪಾಯಿಂಟರ್

69
00:03:26,930 --> 00:03:28,320
ಶೂನ್ಯ ಸಮನಾಗಿರುತ್ತದೆ ಅಲ್ಲ.

70
00:03:28,320 --> 00:03:31,320
ನೀವು ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ ಇದ್ದರೆ
ಪಾಯಿಂಟರ್ಸ್, ಈ ಅರ್ಥ ಇರಬಹುದು.

71
00:03:31,320 --> 00:03:35,639
ಆದರೆ ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ವೇಳೆ
ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಮರುಸ್ಥಾಪನೆ,

72
00:03:35,639 --> 00:03:38,180
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಬಹುಶಃ ಹಾನಿಯಾಗುತ್ತದೆ
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ [ಕೇಳಿಸುವುದಿಲ್ಲ].

73
00:03:38,180 --> 00:03:40,540
ನಾವು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ ನಾವು
ಕಾನೂನುಬದ್ಧ ಪಾಯಿಂಟರ್ ಹಿಂದಕ್ಕೆ ಪಡೆದರು.

74
00:03:40,540 --> 00:03:43,665
ಸಮಯದ ಬಹುಪಾಲು ನಾವು ತಿನ್ನುವೆ
ಮತ್ತೆ ಕಾನೂನುಬದ್ಧ ಪಾಯಿಂಟರ್ ನೆತ್ತಿಗೇರಿದೆ

75
00:03:43,665 --> 00:03:45,280
ಮತ್ತು ಇದು ಒಂದು ಸಮಸ್ಯೆ ಆಗುವುದಿಲ್ಲ.

76
00:03:45,280 --> 00:03:46,760
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಕರೆ fopen ಮಾಡಲು ಹೇಗೆ?

77
00:03:46,760 --> 00:03:48,051
ಈ ರೀತಿಯ ಬಹುಮಟ್ಟಿಗೆ ಕಾಣುತ್ತದೆ.

78
00:03:48,051 --> 00:03:52,690
ಒಂದು ವಿಶಿಷ್ಟ ಎಂಬ ptr ptr-- ಫೈಲ್ ಸ್ಟಾರ್
ಪಾಯಿಂಟರ್ fopen ಕಡತ ಹೆಸರು

79
00:03:52,690 --> 00:03:57,300
ಮತ್ತು ನಾವು, ಎರಡು ವಿಷಯಗಳಲ್ಲಿ ಒಂದು ಕಡತದ ಹೆಸರು ಹಾದು
ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯ ನಾವು ಕೈಗೊಳ್ಳಲು ಬಯಸುವ.

80
00:03:57,300 --> 00:04:01,690
ನಾವು ತೋರುತ್ತಿದೆ ಒಂದು ಕರೆ ಹೊಂದಿರಬಹುದು
this-- ಕಡತ ಸ್ಟಾರ್ ptr 1 fopen ಸಮನಾಗಿರುತ್ತದೆ

81
00:04:01,690 --> 00:04:04,040
file1.txt.

82
00:04:04,040 --> 00:04:07,020
ನಾನು ಆಯ್ಕೆ ಮಾಡಿದ ಕಾರ್ಯಾಚರಣೆ ಆರ್ ಆಗಿದೆ.

83
00:04:07,020 --> 00:04:08,639
>> ಈಗ ನೀವೇನು ಆರ್ ಇಲ್ಲಿದೆ ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

84
00:04:08,639 --> 00:04:11,180
ವಸ್ತುಗಳ ರೀತಿಯ ಯಾವುವು ನಾವು
ಕಡತಗಳನ್ನು ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ?

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
R ಆದ್ದರಿಂದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಾವು
ನಾವು ಒಂದು ಕಡತ ಓದಲು ಬಯಸಿದಾಗ ಆಯ್ಕೆ.

87
00:04:17,500 --> 00:04:20,260
ನಾವು ಮೂಲತಃ ಮಾಡಿದಾಗ ಏಕೆ
ನಾವು ಈ ರೀತಿಯ ಕರೆ ಮಾಡಿ

88
00:04:20,260 --> 00:04:25,440
ನಾವೇ ಕಡತ ಪಾಯಿಂಟರ್ ಪಡೆಯಲಾಗುತ್ತದೆ
ನಾವು ನಂತರ ಮಾಹಿತಿ ಓದಲು ಎಂದು ಇಂತಹ

89
00:04:25,440 --> 00:04:27,770
file1.txt ರಿಂದ.

90
00:04:27,770 --> 00:04:34,190
>> ಹಾಗೆಯೇ, ನಾವು ಫೈಲ್ 2.txt ತೆರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ptr2 ಬರವಣಿಗೆಗೆ ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ

91
00:04:34,190 --> 00:04:38,210
ನಾನು ಇಲ್ಲಿ ರಚಿಸಿದ ಕಡತ ಪಾಯಿಂಟರ್
ಯಾವುದೇ ಕಾರ್ಯಕ್ಕೆ ಒಂದು ಚರ್ಚೆಯಂತೆ

92
00:04:38,210 --> 00:04:40,080
ಫೈಲ್ ಮಾಹಿತಿ ಬರೆಯುತ್ತಾರೆ.

93
00:04:40,080 --> 00:04:43,767
ಆ ಬರಹವು ಹೋಲುವ ಇಲ್ಲ
ಆಯ್ಕೆಯನ್ನು ಒಂದು, ಸೇರಿಸಲು.

94
00:04:43,767 --> 00:04:45,600
ನಡುವಿನ ವ್ಯತ್ಯಾಸ
ಬರೆಯಲು ಮತ್ತು ಸೇರಿಸುವುದರಿಂದ

95
00:04:45,600 --> 00:04:50,920
ಎಂಬ ಒಂದು ಕಡತವನ್ನು ನೀವು ಬರೆಯುತ್ತೇನೆ ಎಂದು,
ನೀವು ಬರವಣಿಗೆಗೆ fopen ಕರೆ ಮಾಡಿದರೆ

96
00:04:50,920 --> 00:04:54,761
ಮತ್ತು ಆ ಕಡತ ಈಗಾಗಲೇ ಅಷ್ಟೇ, ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
ಇಡೀ ಕಡತ ಬದಲಿಸಿ ಹೋಗುವ.

97
00:04:54,761 --> 00:04:56,510
ಇದು ಆರಂಭಿಸಲು ವಿಶೇಷವೇನು
ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ,

98
00:04:56,510 --> 00:04:58,820
ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಅಳಿಸುವುದು
ಈಗಾಗಲೇ ಇಲ್ಲ.

99
00:04:58,820 --> 00:05:02,210
>> ನೀವು ಸೇರಿಸುವುದರಿಂದ ಇದು ತೆರೆಯಲು ವೇಳೆ ಆದರೆ,
ಇದು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹೋಗುತ್ತದೆ

100
00:05:02,210 --> 00:05:04,340
ಈಗಾಗಲೇ ಪಠ್ಯ ಇಲ್ಲ ವೇಳೆ
ಇದು ಅಥವಾ ಮಾಹಿತಿ,

101
00:05:04,340 --> 00:05:06,040
ಮತ್ತು ನಂತರ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ
ಅಲ್ಲಿಂದ ಬರೆಯುವ.

102
00:05:06,040 --> 00:05:08,570
ಆದ್ದರಿಂದ ನೀವು ಯಾವುದೇ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ
ನೀವು ಮೊದಲು ಮಾಡಿದ ಮಾಹಿತಿ.

103
00:05:08,570 --> 00:05:12,110
ನೀವು ಬರೆಯಲು ಅಥವಾ ಸೇರಿಸಲು ಬಯಸುವ ಎಂದು
ರೀತಿಯ ಪರಿಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.

104
00:05:12,110 --> 00:05:16,840
ಆದರೆ ನೀವು ಬಹುಶಃ ನಮಗೆ ಮಾಡುತ್ತೇವೆ
ಸಮಯ ಬಂದಾಗ ಸರಿಯಾದ ಕಾರ್ಯಾಚರಣೆ.

105
00:05:16,840 --> 00:05:18,020
ಆದ್ದರಿಂದ fopen ಇಲ್ಲಿದೆ.

106
00:05:18,020 --> 00:05:18,930
>> ಏನು fclose ಬಗ್ಗೆ?

107
00:05:18,930 --> 00:05:21,600
ಸರಿ, ಸಾಕಷ್ಟು ಸರಳವಾಗಿ, fclose
ಕೇವಲ ಕಡತ ಪಾಯಿಂಟರ್ ಸ್ವೀಕರಿಸುತ್ತದೆ.

108
00:05:21,600 --> 00:05:24,000
ಮತ್ತು ನೀವು ನಿರೀಕ್ಷಿಸಿದ,
ಆ ಕಡತ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ.

109
00:05:24,000 --> 00:05:29,270
ನಾವು ಒಂದು ಕಡತ ಮುಚ್ಚಿದರೂ ಒಮ್ಮೆ, ನಾವು
ಇನ್ನು ಕಡತ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು

110
00:05:29,270 --> 00:05:31,420
ಓದಲು ಅಥವಾ ಫೈಲ್ನಲ್ಲಿ, ಬರೆಯಲು.

111
00:05:31,420 --> 00:05:36,444
ನಾವು ಪುನಃ ತೆರೆಯಲು ಹೊಂದಿರುತ್ತವೆ
ಸಲುವಾಗಿ ಇನ್ನೊಂದು ಬಾರಿ ಫೈಲ್

112
00:05:36,444 --> 00:05:38,610
ಕೆಲಸ ಮುಂದುವರಿಸಲು
ಇದು ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು.

113
00:05:38,610 --> 00:05:41,520
ನಾವು ಮುಗಿಸಿದ್ದೀರಿ ಆದ್ದರಿಂದ fclose ಸಾಧನವಾಗಿ
ಈ ಕಡತ ಕೆಲಸ.

114
00:05:41,520 --> 00:05:44,690
ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ ಎಲ್ಲಾ ಹೊಂದಿದೆ
ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರು.

115
00:05:44,690 --> 00:05:50,010
ಒಂದೆರಡು ಹಿಂದೆ ಸ್ಲೈಡ್ಗಳು ಮೇಲೆ ಆದ್ದರಿಂದ, ನಾವು
ಓದುವ fopened ಕಡತ 1 ಡಾಟ್ ಪಠ್ಯ

116
00:05:50,010 --> 00:05:52,854
ಮತ್ತು ನಾವು ಅದಕ್ಕೆ
ptr1 ಸೂಚಕವನ್ನು ಫೈಲ್.

117
00:05:52,854 --> 00:05:55,020
ಈಗ ನಾವು ನೀವು ನಿರ್ಧರಿಸಿದ್ದಾರೆ ಬಂದಿದೆ
ಕಡತದಿಂದ ಓದುವ ಮಾಡಲಾಗುತ್ತದೆ.

118
00:05:55,020 --> 00:05:56,561
ನಾವು ಯಾವುದೇ ಹೆಚ್ಚು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ.

119
00:05:56,561 --> 00:05:58,890
ನಾವು ಕೇವಲ fclose ptr1 ಮಾಡಬಹುದು.

120
00:05:58,890 --> 00:06:01,950
ಮತ್ತು ಹಾಗೆಯೇ, ನಾವು ಎಂದು
ಇತರೆ ಆಟಗಳಾಗಿದ್ದವು fclose.

121
00:06:01,950 --> 00:06:02,450
ಆಯ್ತು.

122
00:06:02,450 --> 00:06:03,700
ಆದ್ದರಿಂದ ಮುಚ್ಚುವ ವಿಶೇಷವೇನು.

123
00:06:03,700 --> 00:06:05,780
ಆ ಎರಡು ಮೂಲ
ಕಾರ್ಯಾಚರಣೆ ಆರಂಭಿಸಿದ.

124
00:06:05,780 --> 00:06:08,050
>> ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಬಯಸುವ
ಕೆಲವು ಕುತೂಹಲಕಾರಿ ವಿಷಯವನ್ನು,

125
00:06:08,050 --> 00:06:11,940
ಮತ್ತು ಮೊದಲ ಕಾರ್ಯ ಎಂದು ನಾವು ಮಾಡುತ್ತೇವೆ
ಎಂದು fgetc-- ಎಂದು ಮಾಡುತ್ತಾರೆ ನೋಡಿ

126
00:06:11,940 --> 00:06:14,110
ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು ಸಲ್ಲಿಸುವಂತೆ.

127
00:06:14,110 --> 00:06:17,350
ಸಾಮಾನ್ಯವಾಗಿ fgetc ಇಲ್ಲಿದೆ
ಭಾಷಾಂತರಿಸಲು ಎಂದು.

128
00:06:17,350 --> 00:06:20,190
ಜೀವನದಲ್ಲಿ ತನ್ನ ಗೋಲು ಆಗಿದೆ
ಮುಂದಿನ ಅಕ್ಷರವನ್ನೂ ಓದಲು,

129
00:06:20,190 --> 00:06:22,079
ಅಥವಾ ಈ ನಿಮ್ಮ ಬಹಳ ವೇಳೆ
fgetc ಮೊದಲ ಕರೆ

130
00:06:22,079 --> 00:06:23,870
ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಡತ,
ಮೊದಲ ಅಕ್ಷರ.

131
00:06:23,870 --> 00:06:26,210
ಆದರೆ ಆ ನಂತರ,
ನೀವು, ಮುಂದಿನ ಒಂದು ಪಡೆಯಲು

132
00:06:26,210 --> 00:06:31,500
ಫೈಲ್ ಮಾರನೇ ಪಾತ್ರ
ಒಂದು ಪಾತ್ರ ವೇರಿಯಬಲ್ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

133
00:06:31,500 --> 00:06:34,490
ನಾವು ಇಲ್ಲಿ ಮಾಡಿದ ಎಂದು,
ಚಾರ್ ಚ, fgetc ಸಮನಾಗಿರುತ್ತದೆ

134
00:06:34,490 --> 00:06:36,389
ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರಿನಲ್ಲಿ ಪಾಸ್.

135
00:06:36,389 --> 00:06:38,180
ಮತ್ತೆ, ಇದು ಬಹಳ ಇಲ್ಲಿದೆ
ನೆನಪಿಡುವ ಇಲ್ಲಿ ಮುಖ್ಯ

136
00:06:38,180 --> 00:06:41,430
ಸಲುವಾಗಿ ಹೊಂದಲು ಎಂದು
ಈ ಕಾರ್ಯನಿರ್ವಹಿಸಲು,

137
00:06:41,430 --> 00:06:45,690
ಕಡತ ಪಾಯಿಂಟರ್ ಸ್ವತಃ must've
ಓದುವ ಆರಂಭಿಸಲಾಗಿದೆ.

138
00:06:45,690 --> 00:06:50,589
ನಾವು ಒಂದು ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರ ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ
ನಾವು ಬರೆಯುವ ಆರಂಭಿಸಲಾಗಿದೆ ಪಾಯಿಂಟರ್.

139
00:06:50,589 --> 00:06:52,630
ಆದ್ದರಿಂದ ಒಂದಾಗಿದೆ
fopen ಮಿತಿಗಳನ್ನು, ಬಲ?

140
00:06:52,630 --> 00:06:55,470
ನಾವು ನಿರ್ಬಂಧಿಸಲು ಹೊಂದಿವೆ
ನಮ್ಮಲ್ಲಿ ಮಾತ್ರ ಪ್ರದರ್ಶನ

141
00:06:55,470 --> 00:06:57,710
ಒಂದು ಕಡತವನ್ನು ಪಾಯಿಂಟರ್ ಒಂದು ಕಾರ್ಯಾಚರಣೆ.

142
00:06:57,710 --> 00:07:00,220
ನಾವು ಓದಲು ಬಯಸಿದರೆ
ಅದೇ ಕಡತದಿಂದ ಬರೆಯಲು,

143
00:07:00,220 --> 00:07:03,840
ನಾವು ಮುಕ್ತ ಎರಡು ಪ್ರತ್ಯೇಕ ಎಂದು
ಅದೇ ಕಡತವನ್ನು ಕಡತ ಪಾಯಿಂಟರ್ಸ್

144
00:07:03,840 --> 00:07:05,670
ಓದುವ ಒಂದು, ಬರವಣಿಗೆಗೆ ಒಂದು.

145
00:07:05,670 --> 00:07:08,400
>> ಆದ್ದರಿಂದ ಮತ್ತೆ, ಮಾತ್ರ ಕಾರಣ
ನಾನು ಈಗ ಆ ತರಲು

146
00:07:08,400 --> 00:07:11,920
ನಾವು ಕರೆ ಮಾಡಲು ನೀನು ಏಕೆಂದರೆ
fgetc, ಆ ಕಡತ ಪಾಯಿಂಟರ್ must've

147
00:07:11,920 --> 00:07:14,172
ಓದುವ ಆರಂಭಿಸಲಾಗಿದೆ.

148
00:07:14,172 --> 00:07:15,880
ತದನಂತರ ಸಾಕಷ್ಟು ಸರಳವಾಗಿ,
ಎಲ್ಲಾ ನಾವು ಮಾಡಬೇಕಾದ್ದು

149
00:07:15,880 --> 00:07:17,546
ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರಿನಲ್ಲಿ ಪಾಸ್ ಆಗಿದೆ.

150
00:07:17,546 --> 00:07:21,060
ಆದ್ದರಿಂದ ಚಾರ್ ಚ fgetc ptr1 ಸಮನಾಗಿರುತ್ತದೆ.

151
00:07:21,060 --> 00:07:23,200
>> ಅದು ನಮಗೆ ಪಡೆಯಲು ವಿಶೇಷವೇನು
ಮುಂದಿನ character--

152
00:07:23,200 --> 00:07:25,575
ಅಥವಾ ಮತ್ತೆ ಈ ಮೊದಲು ವೇಳೆ
ಈ ಕರೆ ಮಾಡಿದ ಸಮಯ,

153
00:07:25,575 --> 00:07:29,750
ಮೊದಲ character-- ಯಾವುದೇ
ಕಡತ ptr1 ತೋರಿಸಿದರು.

154
00:07:29,750 --> 00:07:32,210
ಫೈಲ್ 1 ಡಾಟ್ ಪಠ್ಯ ಸ್ಮರಿಸುತ್ತಾರೆ.

155
00:07:32,210 --> 00:07:36,490
ಇದು ಮೊದಲ ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ಮಾಡುತ್ತೇವೆ
ಮತ್ತು ನಾವು ವೇರಿಯಬಲ್ ಚ ಶೇಖರಿಸಿಡಬೇಕು ಮಾಡುತ್ತೇವೆ.

156
00:07:36,490 --> 00:07:37,941
ಬಹಳ ಸರಳ.

157
00:07:37,941 --> 00:07:40,190
ನಾವು ಕೇವಲ ಮೂರು ನೋಡಿದ್ದಾರೆ ಬಂದಿದೆ
ಕಾರ್ಯಗಳನ್ನು ಮತ್ತು ನಾವು ಈಗಾಗಲೇ

158
00:07:40,190 --> 00:07:43,070
ಬಹಳ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಏನಾದರೂ ಮಾಡಬಹುದು.

159
00:07:43,070 --> 00:07:46,320
>> ನಾವು ಈ ಸಾಮರ್ಥ್ಯವನ್ನು ಪಡೆಯಲು ಆದ್ದರಿಂದ
ಒಂದು ಪಾತ್ರ ಮಾಡುವ

160
00:07:46,320 --> 00:07:48,943
ಮತ್ತು ನಾವು ಲೂಪ್ ಆದ್ದರಿಂದ ಅದನ್ನು ನಾವು
ಪಾತ್ರಗಳು ಪಡೆಯಲು ಮುಂದುವರೆಯಲು

161
00:07:48,943 --> 00:07:51,390
ಒಂದು ಕಡತದಿಂದ ಮೇಲೆ ಮತ್ತು
ಮೇಲೆ ಮತ್ತು over-- ಈಗ ನಾವು

162
00:07:51,390 --> 00:07:54,500
ಪ್ರತಿಯೊಂದು ಓದಬಹುದು
ಒಂದು ಕಡತದ ಪಾತ್ರ.

163
00:07:54,500 --> 00:07:58,670
ಮತ್ತು ನಾವು ಪ್ರತಿ ಪಾತ್ರ ಮುದ್ರಿಸಲು ವೇಳೆ
ನಾವು ಅದನ್ನು ಓದಲು ತಕ್ಷಣ,

164
00:07:58,670 --> 00:08:01,960
ನಾವು ಈಗ ಒಂದು ಕಡತದಿಂದ ಓದಲು ಮತ್ತು
ತೆರೆಗೆ ಅದರ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿತ.

165
00:08:01,960 --> 00:08:05,610
ನಾವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪೋಣಿಸಿದ ಬಂದಿದೆ
ತೆರೆಯಲ್ಲಿ ಆ ಕಡತ.

166
00:08:05,610 --> 00:08:09,670
ಮತ್ತು ಏನು
ಲಿನಕ್ಸ್ ಆಜ್ಞಾ ಬೆಕ್ಕು ಮಾಡುತ್ತದೆ.

167
00:08:09,670 --> 00:08:13,250
>> ನೀವು ಫೈಲ್ ಹೆಸರು ಬೆಕ್ಕು ಟೈಪ್ ವೇಳೆ, ಇದು
ಸಂಪೂರ್ಣ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ

168
00:08:13,250 --> 00:08:15,160
ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಫೈಲ್.

169
00:08:15,160 --> 00:08:19,010
ಮತ್ತು ಇಲ್ಲಿ ಈ ಸ್ವಲ್ಪ ಲೂಪ್,
ಕೋಡ್ ಕೇವಲ ಮೂರು ಸಾಲುಗಳು,

170
00:08:19,010 --> 00:08:23,270
ಆದರೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಕಲುಗಳನ್ನು
ಲಿನಕ್ಸ್ ಆಜ್ಞಾ ಬೆಕ್ಕು.

171
00:08:23,270 --> 00:08:25,210
ಆದ್ದರಿಂದ ಈ ವಾಕ್ಯ ಮಾಡಬಹುದು
, ಸ್ವಲ್ಪ ವಿಯರ್ಡ್ ನೋಡಲು

172
00:08:25,210 --> 00:08:26,670
ಆದರೆ ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ.

173
00:08:26,670 --> 00:08:31,460
ಚ fgetc ಸಮನಾಗಿರುತ್ತದೆ ಆದರೆ, ptr ಅಲ್ಲ
ಇದು ಒಂದು ಇಡೀ mouthful ಇಲ್ಲಿದೆ EOF-- ಸಮಾನವಾಗಿತ್ತು

174
00:08:31,460 --> 00:08:34,669
ಆದರೆ ಇದು ಕೇವಲ ಮುರಿಯಲು ಅವಕಾಶ
ಆದ್ದರಿಂದ ವಾಕ್ಯ ಸ್ಪಷ್ಟ ಇಲ್ಲಿದೆ.

175
00:08:34,669 --> 00:08:37,169
ನಾನು ಇದನ್ನು ಕ್ರೋಡೀಕರಿಸಿದರು ಬಂದಿದೆ
ಜಾಗವನ್ನು ಸಲುವಾಗಿ,

176
00:08:37,169 --> 00:08:39,049
ಇದು ಸ್ವಲ್ಪ ಆದರೂ
syntactically ಟ್ರಿಕಿ.

177
00:08:39,049 --> 00:08:41,194
>> ಆದ್ದರಿಂದ ಹಸಿರು ಹಕ್ಕಿನಿಂದ ಈ ಭಾಗದ
ಈಗ, ಅದು ಏನು?

178
00:08:41,194 --> 00:08:42,860
ಸರಿ, ಆ ನಮ್ಮ fgetc ಕರೆ ಬಲ?

179
00:08:42,860 --> 00:08:44,530
ನಾವು ಮೊದಲು ನೋಡಿದ.

180
00:08:44,530 --> 00:08:49,500
ಇದು ಒಂದು ಪಡೆಯಲು ವಿಶೇಷವೇನು
ಕಡತದಿಂದ ಪಾತ್ರ.

181
00:08:49,500 --> 00:08:53,220
ನಂತರ ನಾವು ಹೋಲಿಸಿ
EOF ವಿರುದ್ಧ ಪಾತ್ರ.

182
00:08:53,220 --> 00:08:57,470
EOF ಎಂದು ವಿಶೇಷ ಕೆಳಗಿನ
ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h, ರಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಿ

183
00:08:57,470 --> 00:08:59,390
ಕಡತ ರ ಅಂತ್ಯ.

184
00:08:59,390 --> 00:09:03,450
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಸಂಭವಿಸಿ ಹೋಗಿ ಏನನ್ನು
ಈ ಲೂಪ್ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು ಕಾಣಿಸುತ್ತದೆ ಇದೆ,

185
00:09:03,450 --> 00:09:07,445
, EOF ಹೋಲಿಸಿ
ಫೈಲ್ ಪಾತ್ರದ ಕೊನೆಯ.

186
00:09:07,445 --> 00:09:10,070
ಅವರು ಹೊಂದುತ್ತಿಲ್ಲ ವೇಳೆ, ನಾವು ಹೊಂದಿರದಿದ್ದಲ್ಲಿ
, ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು

187
00:09:10,070 --> 00:09:11,490
ನಾವು ಪಾತ್ರದ ಮುದ್ರಿಸುತ್ತದೆ ವಿಲ್.

188
00:09:11,490 --> 00:09:13,740
ನಂತರ ನಾವು ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ
ಮತ್ತೆ ಲೂಪ್ ಆರಂಭ.

189
00:09:13,740 --> 00:09:18,310
ನಾವು ಒಂದು ಪಾತ್ರ ಪಡೆಯುತ್ತೀರಿ, ಪರಿಶೀಲಿಸಿ
EOF ವಿರುದ್ಧ, ಹೀಗೆ ಮುದ್ರಿಸುತ್ತದೆ, ಮತ್ತು

190
00:09:18,310 --> 00:09:21,094
ಹೀಗೆ ಹೀಗೆ,
ಆ ರೀತಿಯಲ್ಲಿ ಮೂಲಕ ಲೂಪಿಂಗ್

191
00:09:21,094 --> 00:09:22,760
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ ರವರೆಗೆ.

192
00:09:22,760 --> 00:09:24,593
ತದನಂತರ ಆ ಮೂಲಕ
ನಾವು ಮುದ್ರಿತ ಕಾಣಿಸುತ್ತದೆ

193
00:09:24,593 --> 00:09:26,210
ಕಡತದ ಸಂಪೂರ್ಣ ವಿಷಯಗಳನ್ನು ಔಟ್.

194
00:09:26,210 --> 00:09:29,450
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾವು ಮಾತ್ರ ನೋಡಿದ
fopen, fclose, ಮತ್ತು fgetc

195
00:09:29,450 --> 00:09:34,950
ಮತ್ತು ಈಗಾಗಲೇ ನಾವು ನಕಲು ಮಾಡಬಹುದು
ಒಂದು ಲೈನಕ್ಸ್ ಟರ್ಮಿನಲ್ ಆಜ್ಞೆಯನ್ನು.

196
00:09:34,950 --> 00:09:38,850
>> ನಾನು ಆರಂಭದಲ್ಲಿ ಹೇಳಿದಂತೆ,
ನಾವು fgetc ಮತ್ತು fputc ಹೊಂದಿತ್ತು,

197
00:09:38,850 --> 00:09:41,860
ಮತ್ತು fputc ಒಡನಾಡಿಯಾಗಿದ್ದ
fgetc ಕಾರ್ಯ.

198
00:09:41,860 --> 00:09:44,880
ಆದ್ದರಿಂದ, ನೀವು, ಕಲ್ಪಿಸಬಹುದಾದ ಇರಬಹುದು
ಬರವಣಿಗೆಯು ಸಮನಾಗಿರುತ್ತದೆ.

199
00:09:44,880 --> 00:09:49,440
ಇದು ನಮಗೆ ಒಂದು ಬರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ
ಫೈಲ್ ಏಕ ಪಾತ್ರ.

200
00:09:49,440 --> 00:09:53,290
>> ಮತ್ತೆ, ಸರಿಯಾಗಿ ಎಂದು, ಕೇವಲ
ಇದು fgetc ಜೊತೆ ಹಾಗೆ, ಫೈಲ್

201
00:09:53,290 --> 00:09:56,660
ನಾವು must've ಗೆ ಬರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು ಮಾಡಲಾಗಿದೆ
ಬರವಣಿಗೆಗೆ ಅಥವಾ ಸೇರಿಸುವುದರಿಂದ ಆರಂಭಿಸಲಾಗಿದೆ.

202
00:09:56,660 --> 00:10:00,820
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಕಡತದ ಮೇಲೆ fputc ಬಳಸಿದರೆ
ನಾವು ಓದುವ ತೆರೆದಿರುವ,

203
00:10:00,820 --> 00:10:02,760
ನಾವು ಬಳಲುತ್ತಿದ್ದಾರೆ ನೀನು
ತಪ್ಪು ಒಂದು ಬಿಟ್.

204
00:10:02,760 --> 00:10:04,440
ಆದರೆ ಕರೆ ಬಹಳ ಸರಳವಾಗಿದೆ.

205
00:10:04,440 --> 00:10:08,000
fputc ಬಂಡವಾಳ ptr2, ಎಲ್ಲಾ
ಹಾಗೆ ವಿಶೇಷವೇನು ಅದು ಆಗಿದೆ

206
00:10:08,000 --> 00:10:12,040
ಪತ್ರ ಬರೆಯಲು ಹೋಗಿ
ಒಂದು ಫೈಲ್ ಆಗಿ 2 ಡಾಟ್ ಒಳಗೆ

207
00:10:12,040 --> 00:10:14,760
ಹೆಸರು ಪಠ್ಯ,
ನಾವು ತೆರೆದು ಅದಕ್ಕೆ ಆ ಫೈಲ್

208
00:10:14,760 --> 00:10:17,280
ಪಾಯಿಂಟರ್ ptr2 ಗೆ.

209
00:10:17,280 --> 00:10:20,430
ನಾವು ಒಂದು ಬರೆಯಲು ನೀನು
ಬಂಡವಾಳ 2 ಡಾಟ್ ಪಠ್ಯ ಸಲ್ಲಿಸುವಂತೆ.

210
00:10:20,430 --> 00:10:24,592
ಮತ್ತು ನಾವು ಒಂದು ಆಶ್ಚರ್ಯಸೂಚಕವಾಗಿ ಬರೆಯಲು ಮಾಡುತ್ತೇವೆ
3 ಡಾಟ್ ಸಲ್ಲಿಸುವಂತೆ ಬೆಟ್ಟು

211
00:10:24,592 --> 00:10:27,330
ptr3 ಮೂಲಕ ತೋರಿಸಿದರು ಇದು ಪಠ್ಯ,.

212
00:10:27,330 --> 00:10:29,730
ಆದ್ದರಿಂದ ಮತ್ತೆ, ಇಲ್ಲಿ ಬಹಳ ಸರಳ.

213
00:10:29,730 --> 00:10:32,727
>> ಆದರೆ ಈಗ ನಾವು ಮತ್ತೊಂದು ವಿಷಯ ಮಾಡಬಹುದು.

214
00:10:32,727 --> 00:10:34,560
ಈ ಉದಾಹರಣೆ
ನಾವು ಹೋಗುವಾಗ ಮಾಡಲಾಯಿತು

215
00:10:34,560 --> 00:10:38,950
ಬೆಕ್ಕು ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಬಗ್ಗೆ
ಲಿನಕ್ಸ್ ಆಜ್ಞಾ, ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ ಒಂದು

216
00:10:38,950 --> 00:10:40,500
ತೆರೆಗೆ.

217
00:10:40,500 --> 00:10:43,510
ಸರಿ, ಈಗ ನಾವು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ
ಕಡತಗಳನ್ನು ಪಾತ್ರಗಳು ಓದಲು

218
00:10:43,510 --> 00:10:46,590
ಮತ್ತು, ಕಡತಗಳನ್ನು ಅಕ್ಷರಗಳನ್ನು ಬರೆಯಲು
ಏಕೆ ನಾವು ಕೇವಲ ಬದಲಿಗೆ ಇಲ್ಲ

219
00:10:46,590 --> 00:10:50,720
fputc ಕರೆ printf ಕರೆ.

220
00:10:50,720 --> 00:10:54,090
>> ಮತ್ತು ಈಗ ನಾವು CP ನಕಲು ಮಾಡಿದ,
ಒಂದು ಮೂಲಭೂತ ಲಿನಕ್ಸ್ ಆಜ್ಞಾ

221
00:10:54,090 --> 00:10:59,100
ನಾವು ರೀತಿಯಲ್ಲಿ ದೀರ್ಘ ಕುರಿತು
ಹಿಂದೆ ಲಿನಕ್ಸ್ ವೀಡಿಯೊ ಆದೇಶಿಸುತ್ತದೆ.

222
00:10:59,100 --> 00:11:01,070
ನಾವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಂದಿದೆ
ಇಲ್ಲಿಯೇ ಎಂದು ನಕಲು.

223
00:11:01,070 --> 00:11:04,790
ನಾವು ಒಂದು ಪಾತ್ರ ಓದುವ ನಂತರ ನಾವು ಆರ್
ಇನ್ನೊಂದು ಫೈಲ್ ಪಾತ್ರದ ಬರೆಯಲು.

224
00:11:04,790 --> 00:11:07,660
ಒಂದು ಕಡತದಿಂದ ಓದಲು, ಬರೆಯಲು
ಮೇಲೆ ಮತ್ತು ಮೇಲೆ ಮತ್ತೊಂದು, ಗೆ

225
00:11:07,660 --> 00:11:11,350
ಮತ್ತು ಮತ್ತೆ ನಾವು EOF ಹಿಟ್ ರವರೆಗೆ.

226
00:11:11,350 --> 00:11:14,250
ನಾವು ಕೊನೆಯಲ್ಲಿ ಮಾಡಲೇಬೇಕು
ಫೈಲ್ ನಾವು ನಕಲಿಸಿ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ.

227
00:11:14,250 --> 00:11:18,500
ಆ ಮೂಲಕ ನಾವು ಎಲ್ಲಾ ಬರೆದಿದ್ದಾರೆ ಮಾಡುತ್ತೇವೆ
ಪಾತ್ರಗಳ ನಾವು ಫೈಲ್ ಅಗತ್ಯವಿದೆ

228
00:11:18,500 --> 00:11:19,500
ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು.

229
00:11:19,500 --> 00:11:24,270
ಆದ್ದರಿಂದ ಈ CP, ಲಿನಕ್ಸ್ ಪ್ರತಿಯನ್ನು ಆದೇಶ.

230
00:11:24,270 --> 00:11:26,550
>> ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ
ಈ ವೀಡಿಯೊ, ನಾನು ಸರಿಯಾಗಿ ಹೊಂದಿತ್ತು

231
00:11:26,550 --> 00:11:29,840
ನಾವು ಮಾತನಾಡಲು ಎಂದು
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.

232
00:11:29,840 --> 00:11:32,480
ನಾವು ನೀವು ಅಲ್ಲಿ ಇಲ್ಲಿ ವಿಶೇಷವಾಗಿ
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಹೋಗಿ

233
00:11:32,480 --> 00:11:34,800
ಜೊತೆಗೆ ಪಾಯಿಂಟರ್ಸ್ ಸಲ್ಲಿಸುವಂತೆ.

234
00:11:34,800 --> 00:11:37,870
ಈ ಕ್ರಿಯೆ ರೀತಿಯ ಭಯಾನಕ ಕಾಣುತ್ತದೆ.

235
00:11:37,870 --> 00:11:39,120
ಇದು ಹಲವಾರು ನಿಯತಾಂಕಗಳನ್ನು ಅವರಲ್ಲಿದೆ.

236
00:11:39,120 --> 00:11:40,430
ಇಲ್ಲಿ ನಡೆಯುತ್ತಿರುವ ಸಾಕಷ್ಟು.

237
00:11:40,430 --> 00:11:42,760
ವಿವಿಧ ಬಹಳಷ್ಟು ಇಲ್ಲ
ಬಣ್ಣಗಳು ಮತ್ತು ಗ್ರಂಥಗಳು.

238
00:11:42,760 --> 00:11:47,100
ಆದರೆ ನಿಜವಾಗಿಯೂ, ಇದು ಕೇವಲ ಇಲ್ಲಿದೆ
fgetc ಜೆನೆರಿಕ್ ಆವೃತ್ತಿ

239
00:11:47,100 --> 00:11:50,110
ನಮಗೆ ಯಾವುದೇ ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ
ಮಾಹಿತಿ ಪ್ರಮಾಣವನ್ನು.

240
00:11:50,110 --> 00:11:53,560
ನಾವು ಇಂತಹ ಸ್ವಲ್ಪ ಅಸಮರ್ಥವೆನಿಸಿದ
ಒಂದು ಸಮಯದಲ್ಲಿ ಪಾತ್ರಗಳು ಒಂದು ಪಡೆಯುವಲ್ಲಿ,

241
00:11:53,560 --> 00:11:55,770
ಕಡತ ಮೂಲಕ iterating
ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ.

242
00:11:55,770 --> 00:12:00,230
ಅದನ್ನು ಪಡೆಯಲು ಒಳ್ಳೆಯದೆಂದು ಎಂದು
ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಬಾರಿ ಅಥವಾ 500 100?

243
00:12:00,230 --> 00:12:03,250
>> ಸರಿ, fread ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ
ರಚಿಸುವಲ್ಲಿ, ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ವಿಲ್

244
00:12:03,250 --> 00:12:05,490
ಎರಡನೇ, ನಮಗೆ ಹಾಗೆ ಅವಕಾಶ.

245
00:12:05,490 --> 00:12:08,480
ನಾವು ಒಂದು ಕ್ರಮವಿಲ್ಲದ ಪ್ರಮಾಣದ ಓದಬಹುದು
ಫೈಲ್ ಮಾಹಿತಿ

246
00:12:08,480 --> 00:12:10,290
ಮತ್ತು ನಾವು ಎಲ್ಲೋ ತಾತ್ಕಾಲಿಕವಾಗಿ ಶೇಖರಿಸಿಡಬೇಕು.

247
00:12:10,290 --> 00:12:12,980
ಬದಲಿಗೆ ಕೇವಲ ಸಮರ್ಥವಾಗಿ
ಒಂದು ವೇರಿಯಬಲ್ ಅದು ಸೈನ್,

248
00:12:12,980 --> 00:12:15,790
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇದು ಸಂಗ್ರಹಿಸಲು ಬೇಕು.

249
00:12:15,790 --> 00:12:19,980
ಆದ್ದರಿಂದ, ನಾವು ನಾಲ್ಕು ಹಾದು
ವಾದಗಳು ಒಂದು ಪಾಯಿಂಟರ್ fread-- ಗೆ

250
00:12:19,980 --> 00:12:23,940
ನಾವು ಆರ್ ಅಲ್ಲಿ ಸ್ಥಳ
ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವೇನು,

251
00:12:23,940 --> 00:12:29,180
ಹೇಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರತಿ ಘಟಕ ದೊಡ್ಡ
ಎಂದು, ಮಾಹಿತಿ ಎಷ್ಟು ಘಟಕಗಳು

252
00:12:29,180 --> 00:12:35,192
ನಾವು ಪಡೆಯಲು ಬಯಸುವ, ಮತ್ತು
ಕಡತ ನಾವು ಪಡೆಯಲು ಬಯಸುವ.

253
00:12:35,192 --> 00:12:37,150
ಬಹುಶಃ ಅತ್ಯುತ್ತಮ ಸಚಿತ್ರ
ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಗೆ ಜೊತೆ.

254
00:12:37,150 --> 00:12:41,640
ಆದ್ದರಿಂದ ನಾವು ಘೋಷಿಸಲು ಎಂದು ತಿಳಿಸಿ
10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

255
00:12:41,640 --> 00:12:45,080
ನಾವು ಮೇಲೆ ಡಿಕ್ಲೇರ್ಡ್
ನಿರಂಕುಶವಾಗಿ ಬಣವೆ ಆಗ 10 ಇಂಟ್.

256
00:12:45,080 --> 00:12:46,970
ಆದ್ದರಿಂದ ಬಹಳ ಸರಳ.

257
00:12:46,970 --> 00:12:51,970
ಈಗ ನಾವು ಆದರೂ ಮಾಡುತ್ತಿರುವುದು
frecall ನಾವು ಇಂಟ್ ಗಾತ್ರವನ್ನು ಓದುವ ನೀವು ಇದೆ

258
00:12:51,970 --> 00:12:54,180
ಬಾರಿ ಮಾಹಿತಿಯನ್ನು 10 ಬೈಟ್ಗಳು.

259
00:12:54,180 --> 00:12:59,040
ಇಂಟ್ ಎಂಬ ಗಾತ್ರ ಇಲ್ಲಿದೆ four--
ಸಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು.

260
00:12:59,040 --> 00:13:02,790
>> ಹಾಗಾಗಿ ನಾವು ಮಾಡುತ್ತಿರುವುದು ನಾವು ಓದುವ ನೀವು ಆಗಿದೆ
ಮಾಹಿತಿ ಮೌಲ್ಯದ 40 ಬೈಟ್ಗಳು

261
00:13:02,790 --> 00:13:05,850
ಕಡತದಿಂದ ptr ಮೂಲಕ ತೋರಿಸಿದರು.

262
00:13:05,850 --> 00:13:08,600
ಮತ್ತು ನಾವು ಆ ಸಂಗ್ರಹಿಸಲು ನೀವು
40 ಬೈಟ್ಗಳು ಎಲ್ಲೋ

263
00:13:08,600 --> 00:13:12,080
ನಾವು ಬದಿಗಿಟ್ಟು ಅಲ್ಲಿ
ಮೆಮೊರಿ ಮೌಲ್ಯದ 40 ಬೈಟ್ಗಳು.

264
00:13:12,080 --> 00:13:15,970
ಅದೃಷ್ಟವಶಾತ್, ನಾವು ಈಗಾಗಲೇ ಮೂಲಕ ಮಾಡಿದ
ವ್ಯೂಹ ಅಲ್ಲಿಯೇ ಆಗ ಘೋಷಿಸುವ.

265
00:13:15,970 --> 00:13:19,770
ಆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು
10 ನಾಲ್ಕು ಬೈಟ್ ಘಟಕಗಳು.

266
00:13:19,770 --> 00:13:22,860
ಒಟ್ಟು ಆದ್ದರಿಂದ, ಇದು 40 ಹಿಡಿಸುವ
ಬೈಟ್ಗಳು ಮಾಹಿತಿಯನ್ನು ಮೌಲ್ಯದ.

267
00:13:22,860 --> 00:13:26,540
ನಾವು ಈಗ 40 ಬೈಟ್ಗಳು ಓದುತ್ತಿದ್ದಲ್ಲಿ
ಫೈಲ್ ಮಾಹಿತಿ,

268
00:13:26,540 --> 00:13:30,330
ಮತ್ತು ನಾವು ಆಗ ಇದನ್ನು ಸಂಗ್ರಹಿಸಲು ನೀವು.

269
00:13:30,330 --> 00:13:35,470
>> ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ ಕರೆಸಿಕೊಳ್ಳುವುದು ಎಂದು
ಇಂತಹ ಆಗ ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಹೆಸರು,

270
00:13:35,470 --> 00:13:38,370
ನಿಜವಾಗಿಯೂ ಒಂದು ಪಾಯಿಂಟರ್
ಅದರ ಮೊದಲ ಅಂಶ.

271
00:13:38,370 --> 00:13:43,680
ಆದ್ದರಿಂದ ನಾವು ಆಗ ಹಾದುಹೋದಾಗ, ನಾವು
ಒಂದು ಪಾಯಿಂಟರ್ ಹಾದುಹೋಗುವ, ವಾಸ್ತವವಾಗಿ, ಅವು.

272
00:13:43,680 --> 00:13:46,120
>> ಅದೇ ರೀತಿ ನಾವು ಈ ಮಾಡಬಹುದು
ನಾವು ಎಂದೇನೂ ಇಲ್ಲ

273
00:13:46,120 --> 00:13:51,200
ಸ್ಟಾಕ್ ನಮ್ಮ ಬಫರ್ ಉಳಿಸಲು ಅಗತ್ಯ.

274
00:13:51,200 --> 00:13:54,990
ನಾವು ಸಕ್ರಿಯವಾಗಿ ನಿಯೋಜಿಸಿ ಎಂದು
ಒಂದು malloc ಬಳಸಿಕೊಂಡು, ಈ ರೀತಿಯ ಬಫರ್.

275
00:13:54,990 --> 00:13:57,340
ನಾವು ನೆನಪಿಡಿ
ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ,

276
00:13:57,340 --> 00:14:00,550
ನಾವು ಅದನ್ನು ಉಳಿಸುವ
ರಾಶಿ, ಸ್ಟಾಕ್.

277
00:14:00,550 --> 00:14:02,110
ಆದರೆ ಇದು ಇನ್ನೂ ಒಂದು ಬಫರ್ ಇಲ್ಲಿದೆ.

278
00:14:02,110 --> 00:14:06,810
>> ಇದು ಇನ್ನೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಆಗಿದೆ
ಮಾಹಿತಿಯನ್ನು 640 ಬೈಟ್ಗಳು ಹಿಡುವಳಿ

279
00:14:06,810 --> 00:14:09,230
ಎರಡು ಎಂಟು ಬೈಟ್ಗಳು ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ.

280
00:14:09,230 --> 00:14:11,570
ಮತ್ತು ನಾವು ಅವರನ್ನು 80 ಕೇಳುತ್ತಿದ್ದೇವೆ.

281
00:14:11,570 --> 00:14:13,770
ನಾವು ಜಾಗವನ್ನು ಬೇಕು
80 ಡಬಲ್ಸ್ ಹಿಡಿದಿಡಲು.

282
00:14:13,770 --> 00:14:17,210
ಆದ್ದರಿಂದ 80 ಬಾರಿ 8 640 ಬೈಟ್ಗಳು ಮಾಹಿತಿಯಾಗಿದೆ.

283
00:14:17,210 --> 00:14:21,880
ಮತ್ತು fread ಎಂದು ಕರೆಯಾಗಿದೆ
ಮಾಹಿತಿಯನ್ನು 640 ಬೈಟ್ಗಳು ಸಂಗ್ರಹಿಸುವ

284
00:14:21,880 --> 00:14:27,770
ಕಡತ ಮೂಲಕ ತೋರಿಸಿದರು ರಿಂದ
ptr ಮತ್ತು arr2 ಈಗ ಸಂಗ್ರಹಿಸುವ.

285
00:14:27,770 --> 00:14:32,770
>> ಈಗ ನಾವು fread ಚಿಕಿತ್ಸೆ
ಕೇವಲ fgetc ಕರೆ ನಂತಹ.

286
00:14:32,770 --> 00:14:37,140
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ
ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಪಡೆಯಿರಿ.

287
00:14:37,140 --> 00:14:40,070
ಮತ್ತು ನಾವು ಒಂದು ಅಗತ್ಯವಿಲ್ಲ
ಶ್ರೇಣಿಯನ್ನು ಒಂದು ಪಾತ್ರದ ಹಿಡಿದಿಡಲು.

288
00:14:40,070 --> 00:14:43,170
ನಾವು ಅದನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು
ಒಂದು ಪಾತ್ರ ವೇರಿಯಬಲ್.

289
00:14:43,170 --> 00:14:46,390
>> ಕ್ಯಾಚ್, ಆದರೂ, ಎಂದು
ನಾವು ಕೇವಲ ಒಂದು ವೇರಿಯೇಬಲ್ ಹೊಂದಿರುವಾಗ,

290
00:14:46,390 --> 00:14:50,290
ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ
ಎಂದು ವೇರಿಯಬಲ್ ವಿಳಾಸ

291
00:14:50,290 --> 00:14:52,550
ಮರುಸ್ಥಾಪನೆ ಏಕೆಂದರೆ
fread ಮೊದಲ ವಾದವನ್ನು

292
00:14:52,550 --> 00:14:59,210
ಸ್ಥಳ ಮತ್ತು ಮೆಮೊರಿ ಒಂದು ಪಾಯಿಂಟರ್
ನಾವು ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಎಲ್ಲಿ.

293
00:14:59,210 --> 00:15:01,550
ಮತ್ತೆ, ಒಂದು ಹೆಸರು
ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಯಾಗಿದೆ.

294
00:15:01,550 --> 00:15:04,200
ನಾವು ವನ್ನಾಗಲಿ ಅರೇ ಅಗತ್ಯವಿಲ್ಲ.

295
00:15:04,200 --> 00:15:07,270
ಆದರೆ ಸಿ, ಪಾತ್ರದ ಸಿ
ಇಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಅಲ್ಲ.

296
00:15:07,270 --> 00:15:08,390
ಇದು ಕೇವಲ ಒಂದು ವೇರಿಯೇಬಲ್ ನ.

297
00:15:08,390 --> 00:15:11,840
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಪಾಸ್ ಅಗತ್ಯವಿದೆ
ವನ್ನಾಗಲಿ ಸಿ ಸೂಚಿಸಲು

298
00:15:11,840 --> 00:15:15,350
ನಾವು ಎಲ್ಲಿ ವಿಳಾಸ ಎಂದು
ಮಾಹಿತಿ ಈ ಒಂದು ಬೈಟ್ ಶೇಖರಿಸಿಡಲು,

299
00:15:15,350 --> 00:15:20,479
ಈ ಒಂದು ಪಾತ್ರ
ನಾವು ptr ಸಂಗ್ರಹಿಸುವ ನೀವು.

300
00:15:20,479 --> 00:15:22,270
ನಾನು ಮೂಲಕ ಹೋಗುತ್ತೇನೆ Fwrite--
ಈ ಸ್ವಲ್ಪ ಹೆಚ್ಚು

301
00:15:22,270 --> 00:15:25,440
ವೇಗವಾಗಿ ಅತ್ಯಧಿಕವಾಗಿ
fread ನಿಖರವಾದ ಸಮಾನ

302
00:15:25,440 --> 00:15:27,720
ಇದು ಬರವಣಿಗೆಗೆ ಹೊರತುಪಡಿಸಿ
ಬದಲಿಗೆ ಓದುವ, ಕೇವಲ

303
00:15:27,720 --> 00:15:31,610
other-- ರೀತಿಯ ನಾವು ಮುಕ್ತ ಹೊಂದಿತ್ತು ಬಂದಿದೆ
ಮತ್ತು ನಿಕಟ, ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು,

304
00:15:31,610 --> 00:15:32,530
ಒಂದು ಪಾತ್ರ ಬರೆಯಲು.

305
00:15:32,530 --> 00:15:35,040
ಈಗ ಅನಿಯಂತ್ರಿತ ಪಡೆಯಲು ಇಲ್ಲಿದೆ
ಮಾಹಿತಿಯ ಪ್ರಮಾಣ

306
00:15:35,040 --> 00:15:37,170
ಮಾಹಿತಿ ಬಲ ಅನಿಯಂತ್ರಿತ ಪ್ರಮಾಣವನ್ನು.

307
00:15:37,170 --> 00:15:39,790
ಆದ್ದರಿಂದ ಮೊದಲಿನಂತೆ, ನಾವು
10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ

308
00:15:39,790 --> 00:15:43,210
ಅಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ
ಮಾಹಿತಿ ಬಹುಶಃ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

309
00:15:43,210 --> 00:15:46,580
>> ಇದು ಬಹುಶಃ ಕೋಡ್ ಕೆಲವು ಸಾಲುಗಳನ್ನು
ಈ ಎರಡು ನಡುವೆ ಹೋಗಬೇಕು

310
00:15:46,580 --> 00:15:49,990
ನಾನು ಆಗ ತುಂಬಲು ಅಲ್ಲಿ
ಅರ್ಥಪೂರ್ಣ ಏನೋ.

311
00:15:49,990 --> 00:15:51,880
ನಾನು 10 ವಿವಿಧ ಪೂರ್ಣಾಂಕಗಳ ಅದನ್ನು ತುಂಬಲು.

312
00:15:51,880 --> 00:15:54,920
ಬದಲಾಗಿ, ನಾನು ಬಳಕೆದಾರ ನನಗೆ
ಮಾಡುವ ಆಗ ಬರೆಯಲು ಇದೆ

313
00:15:54,920 --> 00:15:58,600
ಮತ್ತು ಆಗ ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸುವ.

314
00:15:58,600 --> 00:16:02,390
ನಾನು ಮಾಹಿತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಬಾಗುತ್ತೇನೆ
ಮತ್ತು ಕಡತ ಒಳಗೆ ಹಾಕುವ.

315
00:16:02,390 --> 00:16:05,410
>> ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಅದರಿಂದ ಎಂಬ
ಬಫರ್ ಫೈಲ್,

316
00:16:05,410 --> 00:16:08,790
ನಾವು ಈಗ ನೀನು
ಫೈಲ್ ಬಫರ್.

317
00:16:08,790 --> 00:16:10,580
ಆದ್ದರಿಂದ ಕೇವಲ ತಿರುಗಿಸೋಣ.

318
00:16:10,580 --> 00:16:16,680
ಮೊದಲಿನಂತೆ ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾವು
ಮೆಮೊರಿ ಒಂದು ರಾಶಿ ಪಾಲನ್ನು ಹೊಂದಿವೆ

319
00:16:16,680 --> 00:16:19,600
ನಾವು ಸಕ್ರಿಯವಾಗಿ ಬಂದಿದೆ ಎಂದು
ಹಂಚಿಕೆ ಮತ್ತು ಓದುವುದಕ್ಕೆ

320
00:16:19,600 --> 00:16:21,570
ಮತ್ತು ಕಡತ ಎಂದು ಬರೆಯಲು.

321
00:16:21,570 --> 00:16:24,900
>> ಮತ್ತು ನಾವು ಒಂದು ವೇರಿಯಬಲ್ ಹೊಂದಿವೆ
ಒಂದು ಬೈಟ್ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು

322
00:16:24,900 --> 00:16:27,200
ಇಂತಹ ಪಾತ್ರವಾಗಿ ಮಾಹಿತಿಯಿಲ್ಲದೆ.

323
00:16:27,200 --> 00:16:29,830
ಆದರೆ ಮತ್ತೆ, ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ
ಎಂದು ವೇರಿಯಬಲ್ ವಿಳಾಸ

324
00:16:29,830 --> 00:16:31,840
ನಾವು ಅದರಿಂದ ಓದಲು ಬಯಸಿದಾಗ.

325
00:16:31,840 --> 00:16:35,280
ನಾವು ಮಾಹಿತಿ ಬರೆಯಬಹುದು
ನಾವು ಆ ವಿಳಾಸದಲ್ಲಿ ಕಾಣಬಹುದು

326
00:16:35,280 --> 00:16:39,050
ಕಡತ ಪಾಯಿಂಟರ್, ptr.

327
00:16:39,050 --> 00:16:41,630
>> ಇತರ ಸಾಕಷ್ಟು ಇಲ್ಲ
ದೊಡ್ಡ ಫೈಲ್ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು

328
00:16:41,630 --> 00:16:44,650
ಅದಲ್ಲದೆ ವಿವಿಧ ಕೆಲಸಗಳನ್ನು
ಇವನ್ನು ನಾವು ಇಂದು ಕುರಿತು ಬಂದಿದೆ.

329
00:16:44,650 --> 00:16:46,450
ಇಚ್ಛೆಗಳ ಒಂದೆರಡು
ನಿಮಗೆ ಉಪಯುಕ್ತ ಎಂದು

330
00:16:46,450 --> 00:16:50,840
fgets ಮತ್ತು fputs ಇವೆ,
ಇದು ಸಮನಾಗಿದೆ

331
00:16:50,840 --> 00:16:56,190
fgetc ಮತ್ತು fputc ಆದರೆ ಓದಲು
ಒಂದು ಕಡತದಿಂದ ಒಂದು ಸ್ಟ್ರಿಂಗ್.

332
00:16:56,190 --> 00:16:59,020
ಬದಲಿಗೆ ಒಂದು ಅಕ್ಷರ,
ಇದು ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಓದಲು ಕಾಣಿಸುತ್ತದೆ.

333
00:16:59,020 --> 00:17:02,940
ಮೂಲತಃ ಅನುಮತಿಸುವ fprintf,
ನೀವು ಸಲ್ಲಿಸುವಂತೆ ಬರೆಯಲು printf ಬಳಸಲು.

334
00:17:02,940 --> 00:17:05,619
ನೀವು ಮಾಡಬಹುದು ಆದ್ದರಿಂದ ಕೇವಲ,
ಬಳಸಿಕೊಂಡು ವೇರಿಯೇಬಲ್ ಪರ್ಯಾಯ

335
00:17:05,619 --> 00:17:09,900
ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ಗಳೊಂದಿಗೆ ಶೇಕಡಾ ನಾನು ಮತ್ತು
printf ಶೇಕಡಾ D, ಹೀಗೆ,

336
00:17:09,900 --> 00:17:14,690
ನೀವು ಅದೇ ರೀತಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು
printf ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಮುದ್ರಣ ಏನೋ

337
00:17:14,690 --> 00:17:16,800
ಫೈಲ್ ಹಾಗೆ.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- ನೀವು ಡಿವಿಡಿ ಪ್ಲೇಯರ್ ಹೊಂದಿದ್ದರೆ
ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲಿ ಬಳಸಲು ಸಾದೃಶ್ಯದ ಆಗಿದೆ

339
00:17:20,720 --> 00:17:23,109
ರೀತಿಯ ಬಳಸಿಕೊಂಡು ಹಾಗೆ ನಿಮ್ಮ
ಸುರುಳಿಗಳನ್ನು ಮತ್ತು ವೇಗವಾಗಿ ಮುಂದೆ

340
00:17:23,109 --> 00:17:25,819
ಗುಂಡಿಗಳು ಚಿತ್ರ ಸುತ್ತಲು.

341
00:17:25,819 --> 00:17:28,369
ಹಾಗೆಯೇ, ನೀವು ಫೈಲ್ ಸುಮಾರು ಚಲಿಸಬಹುದು.

342
00:17:28,369 --> 00:17:30,250
ಒಳಗೆ ಕೆಲಸವೆಂದರೆ
ಆ ಕಡತ ರಚನೆ

343
00:17:30,250 --> 00:17:34,270
ನೀವು ಸೂಚಕವಾಗಿದೆ ಎಂದು ಸಿ
ಅಲ್ಲಿ ನೀವು ಕಡತದಲ್ಲಿ ಇವೆ.

344
00:17:34,270 --> 00:17:36,420
ನೀವು ಬಹಳ ಇರುತ್ತದೆ
ಬೈಟ್ ಶೂನ್ಯ, ಆರಂಭದಲ್ಲಿ?

345
00:17:36,420 --> 00:17:39,290
ನೀವು ಬೈಟ್ 100 ಗಳು,
ಬೈಟ್ 1,000, ಹೀಗೆ?

346
00:17:39,290 --> 00:17:44,340
ನೀವು ನಿರಂಕುಶವಾಗಿ ಸರಿಸಲು fseek ಬಳಸಬಹುದು
ಮುಂದೆ ಹಿಂದುಳಿದ ಸೂಚಕ.

347
00:17:44,340 --> 00:17:46,744
>> ಮತ್ತೆ, ftell
ಒಂದು ಡಿವಿಡಿ ಪ್ಲೇಯರ್ ಹೋಲುವ,

348
00:17:46,744 --> 00:17:49,660
ಹೇಳುವ ಸ್ವಲ್ಪ ಗಡಿಯಾರ ಹಾಗೆ
ನೀವು ಎಷ್ಟು ನಿಮಿಷಗಳು ಮತ್ತು ಸೆಕೆಂಡುಗಳು ನೀವು

349
00:17:49,660 --> 00:17:52,480
ಒಂದು ನಿರ್ದಿಷ್ಟ ಚಿತ್ರ ಒಳಗೆ ಇವೆ.

350
00:17:52,480 --> 00:17:56,990
ಹಾಗೆಯೇ, ftell ನೀವು ಹೇಗೆ ಹೇಳುತ್ತದೆ
ಎಷ್ಟು ಬೈಟ್ಗಳು ನೀವು ಕಡತ ಒಳಗೆ ಇವೆ.

351
00:17:56,990 --> 00:18:00,210
feof ಬೇರೆ ಆವೃತ್ತಿಯಾಗಿದೆ
ನೀವು ಬಂದಿದೆ ಎಂದು ಗುರುತಿಸುವುದರ

352
00:18:00,210 --> 00:18:01,700
ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು.

353
00:18:01,700 --> 00:18:03,600
ಮತ್ತು ferror ಕ್ರಿಯೆಯಾಗಿದೆ
ನೀವು ಬಳಸಬಹುದಾದ

354
00:18:03,600 --> 00:18:06,959
ಏನೋ ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಪತ್ತೆ
ಫೈಲ್ ತಪ್ಪು ಕೆಲಸ ಹೋದರು.

355
00:18:06,959 --> 00:18:08,750
ಮತ್ತೆ ಇದು ಕೇವಲ
ಮೇಲ್ಮೈ ಲಾಭ.

356
00:18:08,750 --> 00:18:12,730
ಸಾಕಷ್ಟು ಹೆಚ್ಚು ಕಡತ ನಾನು / ಒ ಇನ್ನೂ
ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h. ಕಾರ್ಯಗಳನ್ನು

357
00:18:12,730 --> 00:18:16,620
ಆದರೆ ಬಹುಶಃ ನೀವು ಪಡೆಯುತ್ತಾನೆ
ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ಆರಂಭಿಸಿದರು.

358
00:18:16,620 --> 00:18:17,640
ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.

359
00:18:17,640 --> 00:18:19,750
ಈ CS50 ಹೊಂದಿದೆ.

360
00:18:19,750 --> 00:18:21,669