1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [ವಿಭಾಗವು 5: ಕಡಿಮೆ ಆರಾಮದಾಯಕ]

2
00:00:02,730 --> 00:00:05,180
[ನೇಟ್ Hardison, ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:05,180 --> 00:00:08,260
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:08,260 --> 00:00:11,690
ಆದ್ದರಿಂದ ಪುರುಷರಿಗೆ ಸ್ವಾಗತಿಸುತ್ತಾರೆ.

5
00:00:11,690 --> 00:00:16,320
ವಿಭಾಗ 5 ಸ್ವಾಗತ.

6
00:00:16,320 --> 00:00:20,220
ಈ ಹಂತದಲ್ಲಿ, ರಸಪ್ರಶ್ನೆ 0 ಸಂಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ ಮತ್ತು ನೀವು ಮಾಡಿದ ಹೇಗೆ ಕಂಡುದಾಗಿ,

7
00:00:20,220 --> 00:00:25,770
ನಾನು ಬಹಳ ಈ ವಿಭಾಗದಲ್ಲಿ ಅಂಕಗಳು ಪ್ರಭಾವಿತರಾಗಿದ್ದ ಏಕೆಂದರೆ ಆಶಾದಾಯಕವಾಗಿ ನೀವು ನಿಜವಾಗಿಯೂ ಒಳ್ಳೆಯ ಭಾವನೆ.

8
00:00:25,770 --> 00:00:28,050
ನಮ್ಮ ಆನ್ಲೈನ್ ವೀಕ್ಷಕರಿಗೆ, ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದೆರಡು ಹೊಂದಿತ್ತು ಮಾಡಿದ

9
00:00:28,050 --> 00:00:33,680
ಸಮಸ್ಯೆ ಸೆಟ್ನಲ್ಲಿ ಕಳೆದ ಎರಡು ಸಮಸ್ಯೆಗಳನ್ನು - ಅಥವಾ ರಸಪ್ರಶ್ನೆ ಮೇಲೆ, ಬದಲಿಗೆ.

10
00:00:33,680 --> 00:00:39,690
ಆದ್ದರಿಂದ ನಾವು ಎಲ್ಲರೂ ಏನಾಯಿತು ನೋಡುತ್ತಾನೆ ಇದರಿಂದ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಆ ಮೇಲೆ ಹೋಗಲು ನೀನು

11
00:00:39,690 --> 00:00:45,060
ಮತ್ತು ಕೇವಲ ಪರಿಹಾರವನ್ನು ಸ್ವತಃ ನೋಡುವ ಹೆಚ್ಚು ವಾಸ್ತವಿಕ ಪರಿಹಾರದ ಮೂಲಕ ಹೋಗಲು ಹೇಗೆ.

12
00:00:45,060 --> 00:00:50,330
ನಾವು ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಸಮಸ್ಯೆಗಳ ಕಳೆದ ಒಂದೆರಡು ವರ್ಷಗಳಿಂದ ಹೋಗಲು 32 ಮತ್ತು 33 ನೀನು.

13
00:00:50,330 --> 00:00:53,240
ಕೇವಲ, ಮತ್ತೆ, ಆದ್ದರಿಂದ ಆನ್ಲೈನ್ ವೀಕ್ಷಕರು ಈ ನೋಡಬಹುದು.

14
00:00:53,240 --> 00:00:59,080
>> ನೀವು ಪುಟ 13 ರಂದು ಇದು ನಿಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು 32, ಬದಲಾಗುತ್ತವೆ ವೇಳೆ

15
00:00:59,080 --> 00:01:02,730
16 ಆಫ್ 13 ಔಟ್, ಸಮಸ್ಯೆಯನ್ನು 32 ಎಲ್ಲಾ ಸ್ವಾಪ್ಸ್ ಸುಮಾರು.

16
00:01:02,730 --> 00:01:05,010
ಇದು ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ವಿನಿಮಯ ಎಲ್ಲಾ.

17
00:01:05,010 --> 00:01:08,740
ನಾವು ಉಪನ್ಯಾಸ ಬಾರಿ ಒಂದೆರಡು ಮೇಲೆ ಹೋದ ಬಯಸುವ ಸಮಸ್ಯೆ.

18
00:01:08,740 --> 00:01:13,590
ಮತ್ತು ಇಲ್ಲಿ, ನಾವು ನೀವು ಏನು ಕೇಳುತ್ತಿದ್ದರು ತ್ವರಿತ ಸ್ಮರಣೆಯ ಜಾಡನ್ನು ಹೊಂದಿದೆ.

19
00:01:13,590 --> 00:01:17,000
ಅವರು ಸ್ಟಾಕ್ ಇರುತ್ತವೆ ಎಂದು ಚರಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ತುಂಬಲು

20
00:01:17,000 --> 00:01:20,250
ಕೋಡ್ ಈ ಸ್ವಾಪ್ ಕ್ರಿಯೆಯ ಮೂಲಕ ಹೋಗುತ್ತದೆ ಎಂದು.

21
00:01:20,250 --> 00:01:24,500
ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ - I'm ಈ ಐಪ್ಯಾಡ್ ಪತನವಾದರೆ ಹೋಗಿ -

22
00:01:24,500 --> 00:01:29,650
ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ ಈ ಸಾಲನ್ನು ಇಲ್ಲಿ 6 ಬಲ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿದೆ.

23
00:01:29,650 --> 00:01:36,740
ಮತ್ತು ಹಿಂದಿನ ಸಮಸ್ಯೆಯನ್ನು ಕೇವಲ contiguity 6 ಸಂಖ್ಯೆಯ ನ.

24
00:01:36,740 --> 00:01:41,720
ನಾವು ಮಾಡಲು ಬಯಸುವ ಮೆಮೊರಿಯನ್ನು ರಾಜ್ಯದ ಪ್ರದರ್ಶಿಸಲು ಅಥವಾ ಲೇಬಲ್

25
00:01:41,720 --> 00:01:46,090
ಇದು ಈ ಸಾಲಿನ ಸಂಖ್ಯೆ 6 ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಮಯದಲ್ಲಿ ಹೊಂದಿದೆ, ಎಂದು

26
00:01:46,090 --> 00:01:52,540
ಇದು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇಲ್ಲಿಯೇ ನಮ್ಮ ಸ್ವಾಪ್ ಫಂಕ್ಷನ್ ನಿಂದ ಹಿಂದಿರುಗಿತು.

27
00:01:52,540 --> 00:01:59,450
ನಾವು ಇಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ನಾವು ಮೆಮೊರಿ ಎಲ್ಲ ವಿಳಾಸಗಳನ್ನು ನಮಗೆ ಒದಗಿಸಿದ ಎಂದು ಕಂಡಿತು.

28
00:01:59,450 --> 00:02:02,540
ಇದು ಬಹಳ ಪ್ರಮುಖವಾಗಿದೆ; ನಾವು ಒಂದು ಕ್ಷಣ ಅದನ್ನು ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ.

29
00:02:02,540 --> 00:02:09,240
ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ಕೆಳಭಾಗದಲ್ಲಿ, ನಾವು ಸೂಚಿಸಲು ನೀನು ಒಂದು ಸಣ್ಣ ಮೆಮೊರಿ ರೇಖಾಚಿತ್ರ ಹೊಂದಿತ್ತು.

30
00:02:09,240 --> 00:02:12,490
ನಾನು ನನ್ನ ಐಪ್ಯಾಡ್ನಲ್ಲಿ ಈ ಔಟ್ ಮಾಡಿದ.

31
00:02:12,490 --> 00:02:20,720
ಆದ್ದರಿಂದ ನಾನು ಉಲ್ಲೇಖಕ್ಕಾಗಿ ಐಪ್ಯಾಡ್ ಮತ್ತು ಈ ಕೋಡ್ ನಡುವೆ ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಪರ್ಯಾಯವಾಗಿ ಪಡೆಯಲಿದ್ದೇನೆ.

32
00:02:20,720 --> 00:02:26,540
>> ಇದೀಗ ಪ್ರಾರಂಭಿಸೋಣ. ಮೊದಲ ಹಕ್ಕನ್ನು ಇಲ್ಲಿ ಮುಖ್ಯ ಸಾಲುಗಳನ್ನು ಮೊದಲ ದಂಪತಿ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಅವಕಾಶ.

33
00:02:26,540 --> 00:02:30,220
ಆರಂಭಿಸಲು, ನಾವು 2 1 ಮತ್ತು ವೈ, x ಆರಂಭಿಸಲು ನೀನು.

34
00:02:30,220 --> 00:02:33,040
ನಾವು ಎರಡು ಪೂರ್ಣಾಂಕ ಅಸ್ಥಿರ ಹೊಂದಿರುತ್ತವೆ ಆದ್ದರಿಂದ, ಅವರು ಸ್ಟಾಕ್ ಅವನ್ನು ನೀನು ಎರಡೂ.

35
00:02:33,040 --> 00:02:36,050
ನಾವು ಅವರಿಗೆ ಒಂದು 1 ಮತ್ತು 2 ಹಾಕಲು ನೀನು.

36
00:02:36,050 --> 00:02:43,150
ನನ್ನ ಐಪ್ಯಾಡ್ ಗೆ ಮಗುಚಲ್ಪಡುತ್ತವೆ ಆದ್ದರಿಂದ, ಆಶಾದಾಯಕವಾಗಿ, ನೋಡೋಣ -

37
00:02:43,150 --> 00:02:48,660
ಆಪಲ್ ಟಿವಿ ಪ್ರತಿರೂಪಿಸುವಿಕೆಯನ್ನು, ಹಾಗೂ ನಾವು ಹೋಗಿ. ಸರಿ.

38
00:02:48,660 --> 00:02:51,670
ನನ್ನ ಐಪ್ಯಾಡ್ ಗೆ ಮಗುಚಲ್ಪಡುತ್ತವೆ ಹಾಗಾಗಿ,

39
00:02:51,670 --> 00:02:56,220
ನಾನು 2 1 ಮತ್ತು ವೈ, x ಆರಂಭಿಸಲು ಬಯಸುವ.

40
00:02:56,220 --> 00:03:00,580
ನಾವು X ಗುರುತು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ 1 ಬರೆದು ಸ್ವಲ್ಪ ಸುಮ್ಮನೆ ಹಾಗೆ

41
00:03:00,580 --> 00:03:07,730
ಮತ್ತು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ 2 ವೈ ಗುರುತಿಸಲಾಗಿದೆ. ಸರಳವಾದ.

42
00:03:07,730 --> 00:03:11,620
ಈಗ ಅವರ ಲ್ಯಾಪ್ಟಾಪ್ ಹಿಂತಿರುಗಿ ಅವಕಾಶ ಮುಂದಿನ ಏನಾಗುತ್ತದೆ ನೋಡಿ.

43
00:03:11,620 --> 00:03:15,810
ವಸ್ತುಗಳು ಟ್ರಿಕಿ ಪಡೆಯಲು ಅಲ್ಲಿ ಈ ಮುಂದಿನ ಸಾಲು.

44
00:03:15,810 --> 00:03:28,110
ನಾವು ನಿಯತಾಂಕಗಳನ್ನು ಮಾಹಿತಿ x ನ ವಿಳಾಸಕ್ಕೆ ಮತ್ತು y ನ ವಿಳಾಸಕ್ಕೆ ರವಾನಿಸಲು ಸ್ವಾಪ್ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಒಂದು ಮತ್ತು ಬಿ.

45
00:03:28,110 --> 00:03:32,380
x ಮತ್ತು y ವಿಳಾಸವನ್ನು ವಿಳಾಸವನ್ನು ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ವಸ್ತುಗಳು

46
00:03:32,380 --> 00:03:36,360
ಈ ಬುಲೆಟ್ ಉಲ್ಲೇಖಿಸುವಾಗ ಇಲ್ಲದೆ ಇಲ್ಲಿ ಬಲ ಕೆಳಗೆ ಸೂಚಿಸುತ್ತಿದೆ.

47
00:03:36,360 --> 00:03:39,750
ಮತ್ತು ಅದೃಷ್ಟವಶಾತ್, ಮೊದಲ ಎರಡು ಬುಲೆಟ್ ಪಾಯಿಂಟ್ ಉತ್ತರಗಳು ನಿಖರವಾಗಿ ಎಂದು ನಮಗೆ ತಿಳಿಸಿ.

48
00:03:39,750 --> 00:03:44,740
ಮೆಮೊರಿ x ನ ವಿಳಾಸಕ್ಕೆ 10, ಮತ್ತು ಮೆಮೊರಿ y ನ ವಿಳಾಸಕ್ಕೆ 14 ಆಗಿದೆ.

49
00:03:44,740 --> 00:03:51,870
ಆದ್ದರಿಂದ ಆ ಆಗಿ ಜಾರಿಗೆ ಪಡೆಯುತ್ತೀರಿ ಎಂದು ಮೌಲ್ಯಗಳು ಒಂದು ಮತ್ತು ನಮ್ಮ ಸ್ವಾಪ್ ಕಾರ್ಯದಲ್ಲಿ ಅಪ್ ಅಗ್ರ ಬೌ.

50
00:03:51,870 --> 00:04:00,760
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಮ್ಮ ಚಿತ್ರದಲ್ಲಿ ಮತ್ತೆ ಸ್ವಿಚಿಂಗ್, ನಾನು ಒಂದು 10 ಬರೆಯಬಹುದು

51
00:04:00,760 --> 00:04:07,400
ಬೌ ಮತ್ತು ಒಂದು 14.

52
00:04:07,400 --> 00:04:11,610
ನಾವು ಸ್ವಾಪ್ ಮುಂದುವರಿಸಲು ಅಲ್ಲಿ ಈಗ, ಈ ಬಿಂದುವಾಗಿದೆ.

53
00:04:11,610 --> 00:04:14,520
ಆದ್ದರಿಂದ, ಮತ್ತೆ ಲ್ಯಾಪ್ಟಾಪ್ ಮತ್ತೆ ಫ್ಲಿಪ್ಪಿಂಗ್

54
00:04:14,520 --> 00:04:21,079
ನಾವು ಸ್ವಾಪ್ ಕೆಲಸ ರೀತಿಯಲ್ಲಿ tmp ಒಂದು ಮತ್ತು ಅಂಗಡಿ ಪರಿಣಾಮವಾಗಿ ನಾನು ಮೊದಲ dereference ಎಂದು ನೋಡಿ.

55
00:04:21,079 --> 00:04:27,650
ಆದ್ದರಿಂದ dereference ಆಯೋಜಕರು ಹೇ "ಹೇಳುತ್ತಾರೆ. ವಿಳಾಸವನ್ನು ವಿವಿಧ ಒಂದು ವಿಷಯಗಳನ್ನು ಟ್ರೀಟ್.

56
00:04:27,650 --> 00:04:33,830
ಆ ವಿಳಾಸದಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ ಯಾವುದೇ ಹೋಗಿ, ಮತ್ತು ಅದನ್ನು ಲೋಡ್. "

57
00:04:33,830 --> 00:04:41,720
ಏನು ವೇರಿಯಬಲ್ ಔಟ್ ಲೋಡ್ ನಮ್ಮ tmp ವೇರಿಯಬಲ್ ಗೆ ಸಂಗ್ರಹಿಸಲು ಹೋಗುತ್ತದೆ.

58
00:04:41,720 --> 00:04:45,150
ಐಪ್ಯಾಡ್ ಮರಳಿ ಫ್ಲಿಪ್ಪಿಂಗ್.

59
00:04:45,150 --> 00:04:51,690
ನಾವು 10 ತಿಳಿಸಲು ಹೋದರೆ, ನಾವು ವಿಳಾಸಕ್ಕೆ 10 varible X ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ

60
00:04:51,690 --> 00:04:55,480
ನಾವು ಮೆಮೊರಿ x ನ ವಿಳಾಸಕ್ಕೆ 10 ಎಂದು ನಮ್ಮ ಬುಲೆಟ್ ಪಾಯಿಂಟ್ ಹೇಳಿದ ಕಾರಣ.

61
00:04:55,480 --> 00:05:00,180
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಐಪ್ಯಾಡ್ ಮೇಲೆ ನೋಡಿ ಎಂದು, ಅಲ್ಲಿ ಹೋಗಿ 1 ಅದು ಮೌಲ್ಯವನ್ನು, ಪಡೆಯುವುದು

62
00:05:00,180 --> 00:05:06,300
ಮತ್ತು tmp ಆಗಿ ಲೋಡ್.

63
00:05:06,300 --> 00:05:08,250
ಮತ್ತೆ, ಈ ಅಂತಿಮ ವಿಷಯಗಳ ಅಲ್ಲ.

64
00:05:08,250 --> 00:05:14,350
ನಾವು ಸಂಚರಿಸಲು ನೀನು ಮತ್ತು ನಾವು ಕೊನೆಯಲ್ಲಿ ಕಾರ್ಯಕ್ರಮದ ನಮ್ಮ ಅಂತಿಮ ಸ್ಥಿತಿಗೆ ಪಡೆಯುತ್ತೀರಿ.

65
00:05:14,350 --> 00:05:17,210
ಆದರೆ ಈಗ, ನಾವು tmp ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮೌಲ್ಯ 1 ಹೊಂದಿರುತ್ತವೆ.

66
00:05:17,210 --> 00:05:19,210
>> ಮತ್ತು ಇಲ್ಲಿ ಮೇಲೆ ತ್ವರಿತ ಪ್ರಶ್ನೆ ಇಲ್ಲ.

67
00:05:19,210 --> 00:05:23,980
[ಅಲೆಕ್ಸಾಂಡರ್] dereference ಆಯೋಜಕರು ಈಸ್ - ಕೇವಲ ವೇರಿಯಬಲ್ ಮುಂದೆ ನಕ್ಷತ್ರ ಸರಿ?

68
00:05:23,980 --> 00:05:27,600
>> ಹೌದು. , ನಾವು ಮತ್ತೊಮ್ಮೆ ನಮ್ಮ ಲ್ಯಾಪ್ಟಾಪ್ ಮತ್ತೆ ಫ್ಲಿಪ್ ಎಂದು, dereference ಆಯೋಜಕರು ಆದ್ದರಿಂದ

69
00:05:27,600 --> 00:05:33,780
ಬಲ ಮುಂದೆ ಈ ನಟ.

70
00:05:33,780 --> 00:05:37,460
ಆ ಅರ್ಥದಲ್ಲಿ, ಅದು - ನೀವು ಗುಣಾಕಾರ ಆಯೋಜಕರು ಅದನ್ನು ಕಾಂಟ್ರಾಸ್ಟ್

71
00:05:37,460 --> 00:05:42,400
ಎರಡು ವಸ್ತುಗಳ ಅಗತ್ಯವಿದೆ; dereference ಆಯೋಜಕರು ಒಂದು unary ಆಯೋಜಕರು ಹೊಂದಿದೆ.

72
00:05:42,400 --> 00:05:46,130
ಕೇವಲ ಅವಳಿ ಆಯೋಜಕರು ವಿರುದ್ಧವಾಗಿ ಒಂದು ಮೌಲ್ಯವನ್ನು ಅನ್ವಯಿಸಲಾಗಿದೆ,

73
00:05:46,130 --> 00:05:48,810
ನೀವು ಎರಡು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತವೆ ಅಲ್ಲಿ.

74
00:05:48,810 --> 00:05:52,080
ಆದ್ದರಿಂದ ಈ ಸಾಲಿನಲ್ಲಿ ಏನಾಗುತ್ತದೆ ಇಲ್ಲಿದೆ.

75
00:05:52,080 --> 00:05:58,390
ನಾವು ಮೌಲ್ಯ 1 ಲೋಡ್ ಮತ್ತು ನಮ್ಮ ತಾತ್ಕಾಲಿಕ ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

76
00:05:58,390 --> 00:06:05,800
ಮುಂದಿನ ಸಾಲು, ನಾವು ಬೌ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು -

77
00:06:05,800 --> 00:06:12,630
ಅಥವಾ, ಹೆಚ್ಚಾಗಿ, ನಾವು ಬೌ ಒಂದು ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲಿ ಸ್ಥಾನಕ್ಕೇರಿತು ತೋರುತ್ತಿರುವಂತೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು.

78
00:06:12,630 --> 00:06:17,690
ನಾವು ಎಡ ಹಕ್ಕನ್ನು ಈ ವಿಶ್ಲೇಷಿಸಲು, ನಾವು, dereference ಬೌ ಹೋಗುವ

79
00:06:17,690 --> 00:06:23,580
ನಾವು 14 ಪರಿಹರಿಸಲು ಹೋಗುವ, ನಾವು, ಎಂದು ಪೂರ್ಣಾಂಕ ಕಿತ್ತುಕೊಂಡು ಹೋಗುವ

80
00:06:23,580 --> 00:06:26,900
ನಂತರ ನಾವು, ವಿಳಾಸಕ್ಕೆ 10 ಹೋಗುತ್ತಿದ್ದೇವೆ

81
00:06:26,900 --> 00:06:34,240
ಮತ್ತು ನಾವು ಬಾಹ್ಯಾಕಾಶಕ್ಕೆ ಬೌ ನಮ್ಮ dereference ಪರಿಣಾಮವಾಗಿ ಎಸೆದು ಹೋಗುವ.

82
00:06:34,240 --> 00:06:40,080
ನಾವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಕಾಂಕ್ರೀಟ್ ಮಾಡಲು ನಮ್ಮ ಐಪ್ಯಾಡ್, ಮತ್ತೆ ಫ್ಲಿಪ್ಪಿಂಗ್,

83
00:06:40,080 --> 00:06:44,070
ನಾನು ಇಲ್ಲಿ ವಿಳಾಸಗಳು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳ ಬರೆಯಲು ಅದನ್ನು ಸಹಾಯವಾಗಬಹುದು.

84
00:06:44,070 --> 00:06:53,820
ನಾವು ವೈ ನಲ್ಲಿ, ನಾವು ವಿಳಾಸಕ್ಕೆ 14 ನಲ್ಲಿ ನಮಗೆ ತಿಳಿದಿದೆ, X ವಿಳಾಸಕ್ಕೆ 10 ಆಗಿದೆ.

85
00:06:53,820 --> 00:07:00,180
ನಾವು ಬೌ ಆರಂಭವಾಗುವುದು, ನಾವು dereference ಬೌ, ನಾವು ಮೌಲ್ಯ 2 ಪಡೆದುಕೊಳ್ಳುವುದಕ್ಕೆ ನೀನು.

86
00:07:00,180 --> 00:07:08,320
ನಾವು ಆ ವಿಳಾಸಕ್ಕೆ 14 ನೇ ಜೀವಿಸುವ ಮೌಲ್ಯವನ್ನು ಏಕೆಂದರೆ ಈ ಮೌಲ್ಯವನ್ನು ಕಿತ್ತುಕೊಂಡು ಹೋಗುವ.

87
00:07:08,320 --> 00:07:15,700
ಮತ್ತು ನಾವು, ವಿಳಾಸಕ್ಕೆ 10 ಜೀವಿಸುವ ವೇರಿಯಬಲ್ ಹಾಕಿದರೆ ಎಂದು ನೀನು

88
00:07:15,700 --> 00:07:19,160
ಇದು ನಮ್ಮ ವ್ಯತ್ಯಯ X ಅನುಗುಣವಾಗಿ, ಬಲ ಇದೆ.

89
00:07:19,160 --> 00:07:21,810
ನಾವು ಇಲ್ಲಿ ಮೇಲೆಯೆ ಒಂದು ಸ್ವಲ್ಪ ಮಾಡಬಹುದು

90
00:07:21,810 --> 00:07:35,380
ನಮ್ಮ 1 ತೊಡೆದುಹಾಕಲು ಮತ್ತು ಬದಲಿಗೆ ನಾವು 2 ಬರೆಯಲು ಅಲ್ಲಿ.

91
00:07:35,380 --> 00:07:39,560
ಎಲ್ಲಾ ನಾವು ಈಗ ಬರೆಯಲ್ಪಟ್ಟಿತೆಂದರೆ X ಮಾಡಿದ ಸಹ, ಹಾಗೂ ವಿಶ್ವದ ಒಳ್ಳೆಯದು.

92
00:07:39,560 --> 00:07:44,890
ನಮ್ಮ tmp ವೇರಿಯಬಲ್ X ಹಳೆಯ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು.

93
00:07:44,890 --> 00:07:50,210
ನಾವು ಮುಂದಿನ ಸಾಲಿನ ಸ್ವಾಪ್ ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

94
00:07:50,210 --> 00:07:53,030
ನಮ್ಮ ಲ್ಯಾಪ್ಟಾಪ್ ಮತ್ತೆ ಫ್ಲಿಪ್ಪಿಂಗ್.

95
00:07:53,030 --> 00:07:58,150
ಈಗ ಆ ಅವಶೇಷಗಳು ನಮ್ಮ ತಾತ್ಕಾಲಿಕ ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ವಿಷಯಗಳನ್ನು ಔಟ್ ತೆಗೆದುಕೊಳ್ಳಲು ಹೊಂದಿದೆ

96
00:07:58,150 --> 00:08:05,630
ಮತ್ತು ಬಿ ಹಿಡುವಳಿ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ವಿಳಾಸದಲ್ಲಿ ಜೀವಿಸುವ ವೇರಿಯಬಲ್ ಅವುಗಳನ್ನು ಶೇಖರಿಸಿಡಲು.

97
00:08:05,630 --> 00:08:10,230
ನಾವು ವೇರಿಯಬಲ್ ಪ್ರವೇಶ ಪಡೆಯಲು ಪರಿಣಾಮಕಾರಿಯಾಗಿ dereference ಬೌ ಎಂದು ನೀನು

98
00:08:10,230 --> 00:08:14,340
ಎಂದು, ಬೌ ಅದು ಹೊಂದಿರುವ ವಿಳಾಸದಲ್ಲಿ ಆಗಿದೆ

99
00:08:14,340 --> 00:08:19,190
ಮತ್ತು ನಾವು tmp ಇದನ್ನು ಹಿಡಿದಿರುವ ಮೌಲ್ಯವನ್ನು ವಿಷಯ ನೀನು.

100
00:08:19,190 --> 00:08:23,280
ಮತ್ತೊಮ್ಮೆ ಐಪ್ಯಾಡ್ ಮರಳಿ ಫ್ಲಿಪ್ಪಿಂಗ್.

101
00:08:23,280 --> 00:08:31,290
ನಾನು, ಇಲ್ಲಿ 2 ಈ ಮೌಲ್ಯವನ್ನು ಅಳಿಸಿಹಾಕಬಹುದು

102
00:08:31,290 --> 00:08:41,010
ಮತ್ತು ಬದಲಿಗೆ ನಾವು ಇದನ್ನು 1 ಬಲ ನಕಲಿಸಿ ಮಾಡುತ್ತೇವೆ.

103
00:08:41,010 --> 00:08:43,059
ನಂತರ ಆಫ್ ನಿರ್ವಹಿಸುವ ಮುಂದಿನ ಸಾಲು -

104
00:08:43,059 --> 00:08:47,150
ನಾವು ಲ್ಯಾಪ್ಟಾಪ್ ಮತ್ತೆ ತಿರುಗಿಸಿಕೊಳ್ಳುವ ವೇಳೆ - ಈ 6

105
00:08:47,150 --> 00:08:52,500
ನಮ್ಮ ಚಿತ್ರದಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಭರ್ತಿ ಹೊಂದಬೇಕೆಂಬ ಆಸೆ ಬಿಂದುವನ್ನು ಇದು.

106
00:08:52,500 --> 00:08:58,940
ಆದ್ದರಿಂದ ಐಪ್ಯಾಡ್ ಮರಳಿ ಫ್ಲಿಪ್ಪಿಂಗ್ ಮತ್ತೊಮ್ಮೆ, ಕೇವಲ ಆದ್ದರಿಂದ ನೀವು ಪೂರ್ಣಗೊಳಿಸಿದ ಚಿತ್ರದಲ್ಲಿ ನೋಡಬಹುದು

107
00:08:58,940 --> 00:09:06,610
ನಾವು X ನಲ್ಲಿ ಒಂದು 10, ಬೌ ಒಂದು 14, tmp ಒಂದು 1, 2, ಮತ್ತು ವೈ ಒಂದು 1 ಎಂದು ನೋಡಬಹುದು.

108
00:09:06,610 --> 00:09:11,000
ಈ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಇವೆ?

109
00:09:11,000 --> 00:09:14,640
ಈ ಮೂಲಕ ಸರಿದು ನಂತರ, ಹೆಚ್ಚು ಅರ್ಥ ಡಸ್?

110
00:09:14,640 --> 00:09:24,850
ಕಡಿಮೆ ಅರ್ಥ? ಆಶಾದಾಯಕವಾಗಿ ಅಲ್ಲ. ಸರಿ.

111
00:09:24,850 --> 00:09:28,230
>> ಪಾಯಿಂಟರ್ಸ್ ಬಹಳ ಟ್ರಿಕಿ ವಿಷಯವಾಗಿದೆ.

112
00:09:28,230 --> 00:09:33,420
ನಾವು ಕೆಲಸ ವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಒಬ್ಬ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮಾತುಗಳೆಂದರೆ ಹೊಂದಿದೆ:

113
00:09:33,420 --> 00:09:36,590
"ಪಾಯಿಂಟರ್ಸ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನೀವು ಮೊದಲ ಪಾಯಿಂಟರ್ಸ್ ಅರ್ಥ ಬೇಕು."

114
00:09:36,590 --> 00:09:40,530
ಇದು ನಾನು ಬಹಳ ನಿಜವಾದ ಎಂದು. ಇದು ಬಳಸಲಾಗುತ್ತದೆ ತಲುಪುವ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮಾಡುತ್ತದೆ.

115
00:09:40,530 --> 00:09:45,360
ಬಹಳ ಸಹಾಯ, ಚಿತ್ರಗಳು ಚೀಟಿ ಎತ್ತುವುದು ಇಂತಹ ಮೆಮೊರಿ ಚಿತ್ರಗಳು ಸಾಕಷ್ಟು ರೇಖಾಚಿತ್ರ

116
00:09:45,360 --> 00:09:49,480
ಮತ್ತು ನೀವು ಉದಾಹರಣೆಗೆ ನಂತರ ಉದಾಹರಣೆಗೆ ನಂತರ ಉದಾಹರಣೆಗೆ ಸಂಚರಿಸಲು ನಂತರ,

117
00:09:49,480 --> 00:09:54,450
ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥದಲ್ಲಿ ಮತ್ತು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥದಲ್ಲಿ ಮತ್ತು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥ ಪ್ರಾರಂಭಿಸಿ.

118
00:09:54,450 --> 00:10:01,560
ಅಂತಿಮವಾಗಿ, ಒಂದು ದಿನ, ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಮಾಸ್ಟರಿಂಗ್ ಹೊಂದಿರುತ್ತದೆ.

119
00:10:01,560 --> 00:10:13,800
ಮುಂದಿನ ಸಮಸ್ಯೆ ಕಡೆಗೆ? ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಮೊದಲು ಎಲ್ಲಾ ಸರಿ.

120
00:10:13,800 --> 00:10:18,840
ಆದ್ದರಿಂದ ಲ್ಯಾಪ್ಟಾಪ್ ಮತ್ತೆ ಮೀಟು.

121
00:10:18,840 --> 00:10:23,300
ನಾವು ಮುಂದಿನ ಸಮಸ್ಯೆ ಸಮಸ್ಯೆ ಸಂಖ್ಯೆ 33 ಫೈಲ್ ಮೇಲೆ I / O

122
00:10:23,300 --> 00:10:26,350
ಈ ಸ್ವಲ್ಪ ಜೂಮ್.

123
00:10:26,350 --> 00:10:28,710
ಸಮಸ್ಯೆಯನ್ನು 33 - ಹೌದು?

124
00:10:28,710 --> 00:10:32,110
>> [ಡೇನಿಯಲ್] ನಾನು ಒಂದು ತ್ವರಿತ ಪ್ರಶ್ನೆ ಹೊಂದಿತ್ತು. ಈ ನಕ್ಷತ್ರ ಅಥವಾ ನಕ್ಷತ್ರ,

125
00:10:32,110 --> 00:10:35,590
ನೀವು ಮೊದಲು ಒಂದು ನಕ್ಷತ್ರ ಬಳಸಿದಾಗ dereferencing ಕರೆಯಲಾಗುತ್ತದೆ.

126
00:10:35,590 --> 00:10:38,820
ನೀವು ಮೊದಲು ವನ್ನಾಗಲಿ ಬಳಸುವಾಗ ಅದು ಯಾವ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ?

127
00:10:38,820 --> 00:10:43,140
>> ವನ್ನಾಗಲಿ ಮೊದಲು ವಿಳಾಸಕ್ಕೆ ಆಫ್ ಆಯೋಜಕರು ಹೊಂದಿದೆ.

128
00:10:43,140 --> 00:10:45,880
ಆದ್ದರಿಂದ ಅವರ ಹಿಂದಿರುಗಿ ಸ್ಕ್ರಾಲ್ ಅವಕಾಶ.

129
00:10:45,880 --> 00:10:49,310
ಓಹ್. ನಾನು ಇದರಿಂದ ನಿಜವಾಗಿಯೂ ಚಲನ ಅಲ್ಲ ಜೂಮ್ ಕ್ರಮದಲ್ಲಿ ಆಗಿದ್ದೇನೆ.

130
00:10:49,310 --> 00:10:52,780
ನಾವು ಇಲ್ಲಿಯೇ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಈ ಕೋಡ್ ನೋಡಿದರೆ,

131
00:10:52,780 --> 00:10:54,980
ಮತ್ತೆ ಅದೇ ವಿಷಯ ನಡೆಯುತ್ತಿದೆ.

132
00:10:54,980 --> 00:10:59,180
ನಾವು ಇಲ್ಲಿಯೇ ಈ ಕೋಡ್ ನೋಡಿದರೆ, ಈ ಸಾಲಿನಲ್ಲಿ ನಾವು ಕರೆ, ಸ್ವ್ಯಾಪ್ ಮಾಡಲು ಅಲ್ಲಿ

133
00:10:59,180 --> 00:11:10,460
ವನ್ನಾಗಲಿ ಕೇವಲ "ವಿಳಾಸಕ್ಕೆ ಇದು ವ್ಯತ್ಯಯ X ಜೀವನದಲ್ಲಿ ಪಡೆಯಿರಿ." ಹೇಳುತ್ತಾರೆ

134
00:11:10,460 --> 00:11:14,460
ನಿಮ್ಮ ಕಂಪೈಲರ್ ನಿಮ್ಮ ಕೋಡ್ ಸಂಗ್ರಹಿಸುತ್ತಾ ಮಾಡಿದಾಗ,

135
00:11:14,460 --> 00:11:20,590
ನಿಜವಾಗಿ ಭೌತಿಕವಾಗಿ ವಾಸಿಸಲು ನಿಮ್ಮ ಅಸ್ಥಿರ ಎಲ್ಲಾ ಮೆಮೊರಿ ಒಂದು ಸ್ಥಳವನ್ನು ಗುರುತಿಸಲು ಹೊಂದಿದೆ.

136
00:11:20,590 --> 00:11:24,910
ಎಲ್ಲವೂ ಕಂಪೈಲ್ ಒಮ್ಮೆ ಹೀಗೆ ಕಂಪೈಲರ್ ನಂತರ, ಏನು ಮಾಡಬಹುದು

137
00:11:24,910 --> 00:11:31,110
ಇದು "ಓಹ್, ನಾನು ವಿಳಾಸಕ್ಕೆ 10 X ಪುಟ್. ನಾನು ವಿಳಾಸಕ್ಕೆ 14 ನಲ್ಲಿ ವೈ ಪುಟ್.", ತಿಳಿದಿರುವ

138
00:11:31,110 --> 00:11:34,640
ನಂತರ ನೀವು ಈ ಮೌಲ್ಯಗಳನ್ನು ಭರ್ತಿ ಮಾಡಬಹುದು.

139
00:11:34,640 --> 00:11:44,740
ಆದ್ದರಿಂದ ನೀವು ಮಾಡಬಹುದು - ಇದು ನಂತರ ಹಾಗೆಯೇ ಮತ್ತು ಪಾಸ್ & ಲಿಸಿ ಈ ರವಾನಿಸಬಹುದು.

140
00:11:44,740 --> 00:11:50,730
ಈ ಹುಡುಗರಿಗೆ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು, ಆದರೆ ಅವರು, ನೀವು ಸ್ವಾಪ್ ಕಾರ್ಯ ಅವುಗಳನ್ನು ರವಾನಿಸಲು

141
00:11:50,730 --> 00:11:55,690
ಈ ರೀತಿಯ ಮಾಹಿತಿ, ಇಲ್ಲಿಯೇ ಈ ಇಂಟ್ *, ಕಂಪೈಲರ್ ಹೇಳುತ್ತದೆ

142
00:11:55,690 --> 00:12:01,350
"ಸರಿ, ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ಒಂದು ವಿಳಾಸಕ್ಕೆ ಈ ವಿಳಾಸಕ್ಕೆ ವ್ಯಾಖ್ಯಾನ ಮಾಡಲು ನೀನು."

143
00:12:01,350 --> 00:12:05,900
ಒಂದು ಇಂಟ್ ಒಂದು ವಿಳಾಸ, ಒಂದು ಪಾತ್ರವು ಚರಾಂಶದ ವಿಳಾಸಕ್ಕೆ ಭಿನ್ನವಾಗಿದೆ

144
00:12:05,900 --> 00:12:09,930
ಒಂದು ಇಂಟ್ ಒಂದು 32 ಬಿಟ್ ಗಣಕದಲ್ಲಿ, ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ, ಜಾಗವನ್ನು 4 ಬೈಟ್ಗಳು ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

145
00:12:09,930 --> 00:12:13,310
ಒಂದು ಪಾತ್ರವನ್ನು ಮಾತ್ರ ಜಾಗವನ್ನು 1 ಬೈಟ್ ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆದರೆ.

146
00:12:13,310 --> 00:12:17,310
ಆದ್ದರಿಂದ ಅದು ಕೂಡ ತಿಳಿಯಲು ಪ್ರಮುಖ - ವಾಸಿಸುತ್ತಾರೆ ಏನು, ಮೌಲ್ಯದ ಬಗೆ

147
00:12:17,310 --> 00:12:20,340
ಸೈನ್ ಜಾರಿಗೆ ಕೊಂಡಿರುವ ವಿಳಾಸಕ್ಕೆ ವಾಸಿಸುತ್ತಿದ್ದ ಇದೆ

148
00:12:20,340 --> 00:12:22,020
ನೀವು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು ಅಥವಾ ವಿಳಾಸಕ್ಕೆ.

149
00:12:22,020 --> 00:12:29,020
ಆ ರೀತಿಯಲ್ಲಿ, ನೀವು ಎಷ್ಟು ಬೈಟ್ಗಳು ಮಾಹಿತಿಯನ್ನು ವಾಸ್ತವವಾಗಿ ನಿಮ್ಮ RAM ನ ಔಟ್ ಲೋಡ್ ತಿಳಿದಿರುವ.

150
00:12:29,020 --> 00:12:31,780
ತದನಂತರ, ಹೌದು, ನೀವು ರೀತಿ dereference ಆಯೋಜಕರು, ಕೇಳುತ್ತಿದ್ದರು

151
00:12:31,780 --> 00:12:37,200
ಹೋಗುತ್ತದೆ ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ ವಿಳಾಸದಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಕೇಳಬಹುದು.

152
00:12:37,200 --> 00:12:42,820
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಈ ಒಂದು ವೇರಿಯೇಬಲ್ ಜೊತೆಗೆ, ಹೇಳುತ್ತಾರೆ, ಒಂದು ವಿಳಾಸಕ್ಕೆ ಒಂದು ವಿಷಯಗಳನ್ನು ಚಿಕಿತ್ಸೆ,

153
00:12:42,820 --> 00:12:47,880
ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ, ಮತ್ತು ಔಟ್ ಪುಲ್, ಒಂದು ರಿಜಿಸ್ಟರ್ನಲ್ಲಿ ಪ್ರೊಸೆಸರ್, ಲೋಡ್ ಆಗಿ ಲೋಡ್

154
00:12:47,880 --> 00:12:56,340
ನಿಜವಾದ ಮೌಲ್ಯಗಳನ್ನು ಅಥವಾ ವಿಳಾಸದಲ್ಲಿ ವಾಸಿಸುವ ವಿಷಯಗಳ.

155
00:12:56,340 --> 00:12:59,620
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಈ ಉತ್ತಮ ಪ್ರಶ್ನೆಗಳು.

156
00:12:59,620 --> 00:13:01,650
ಇದು ತುಂಬಾ ಹೊಸ ಪರಿಭಾಷೆ ಸಂಗತಿಯೇ.

157
00:13:01,650 --> 00:13:09,800
ವಿವಿಧ ಸ್ಥಳಗಳಲ್ಲಿ ಮತ್ತು ಮತ್ತು * ನೋಡಿದ ಸಹ ಮೋಜಿನ ಭಾಸವಾಗುತ್ತದೆ.

158
00:13:09,800 --> 00:13:13,180
>> ಎಲ್ಲಾ ಸರಿ.

159
00:13:13,180 --> 00:13:18,530
ಆದ್ದರಿಂದ ಮತ್ತೆ ಸಮಸ್ಯೆಯನ್ನು 33, ಫೈಲ್ ಐ / ಒ

160
00:13:18,530 --> 00:13:22,540
ನಾನು ವಸ್ತುಗಳ ಒಂದೆರಡು ಸಂಭವಿಸಿದ ಭಾವಿಸುತ್ತೇನೆ ಆ ಸಮಸ್ಯೆಗಳನ್ನು ಒಂದಾಗಿತ್ತು.

161
00:13:22,540 --> 00:13:25,400
ಒಂದು, ಅದು ಸಾಕಷ್ಟು ಹೊಸ ವಿಷಯ ಇಲ್ಲಿದೆ.

162
00:13:25,400 --> 00:13:30,590
ಇದು, ರಸಪ್ರಶ್ನೆ ಮೊದಲು ಸ್ವಲ್ಪ ಸಮಯದಲ್ಲಿಯೇ ನೀಡಲಾಯಿತು

163
00:13:30,590 --> 00:13:33,400
ತದನಂತರ ನಾನು ಗಣಿತ ಆ ಪದ ಸಮಸ್ಯೆಗಳನ್ನು ಒಂದು ರೀತಿಯ ರೀತಿಯ ಭಾವಿಸಿದೆವು

164
00:13:33,400 --> 00:13:39,720
ಅಲ್ಲಿ ಅವರು ನೀವು ಸಾಕಷ್ಟು ನೀಡಿ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಇದು ಒಂದು ಟನ್ ಬಳಸಲು ಹೊಂದಿರುವ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಇಲ್ಲ.

165
00:13:39,720 --> 00:13:44,060
ಈ ಸಮಸ್ಯೆಯ ಮೊದಲ ಭಾಗ ಒಂದು CSV ಕಡತ ಏನು ವಿವರಿಸುವ ಇದೆ.

166
00:13:44,060 --> 00:13:50,620
ಈಗ, ಒಂದು CSV ಕಡತ, ವಿವರಣೆ ಪ್ರಕಾರ, ಒಂದು ಅಲ್ಪವಿರಾಮ ಬೇರ್ಪಡಿಸಿದ ಮೌಲ್ಯಗಳು ಕಡತವಾಗಿರುತ್ತದೆ.

167
00:13:50,620 --> 00:13:55,300
ಈ ಎಲ್ಲಾ ಕುತೂಹಲಕಾರಿ ಇರುತ್ತದೆ ಕಾರಣ, ಮತ್ತು ನೀವು ಎಂದಾದರೂ ಅವುಗಳನ್ನು ಬಳಸಲು ಕಾರಣ,

168
00:13:55,300 --> 00:14:00,800
, ಏಕೆಂದರೆ, ನೀವು ಅನೇಕ ಹಿಂದೆಂದೂ ಎಕ್ಸೆಲ್ ಮೂಲವಸ್ತುವನ್ನು ಬಳಸಿದ್ದಾರೆ ಇದೆ?

169
00:14:00,800 --> 00:14:03,240
, ಬಹುಶಃ, ಅಥವಾ ನಿಮ್ಮ ಜೀವನದಲ್ಲಿ ಕೆಲವು ಹಂತದಲ್ಲಿ ಬಳಸುತ್ತದೆ ನೀವು ಅತ್ಯಂತ ಚಿತ್ರ.

170
00:14:03,240 --> 00:14:06,430
ನೀವು ಎಕ್ಸೆಲ್ ರೀತಿಯ ಬಳಸಿ.

171
00:14:06,430 --> 00:14:10,940
ಒಂದು ಎಕ್ಸೆಲ್ ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಮಾಹಿತಿ ಪಡೆಯಲು ಅಥವಾ ಅದರೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಗೆ ಯಾವುದೇ ರೀತಿಯ ಮಾಡಲು,

172
00:14:10,940 --> 00:14:17,240
ನೀವು ಒಂದು ಸಿ ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಪೈಥಾನ್ ಪ್ರೊಗ್ರಾಮ್, ಜಾವಾ ಪ್ರೋಗ್ರಾಮ್, ಬರೆಯಲು ಬಯಸಿದರೆ

173
00:14:17,240 --> 00:14:20,070
ನೀವು ಸಂಗ್ರಹಿಸಲಾದ ದತ್ತಾಂಶ ವ್ಯವಹರಿಸಲು,

174
00:14:20,070 --> 00:14:23,170
ಇದನ್ನು ಪಡೆಯಲು ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದು CSV ಕಡತ ರಲ್ಲಿ ಆಗಿದೆ.

175
00:14:23,170 --> 00:14:26,850
ನೀವು, ಸಂಭಾಷಣೆ 'ಅಂತೆ ಉಳಿಸು' ಹೋದಾಗ ಮತ್ತು ನೀವು ಎಕ್ಸೆಲ್ ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಮಾಡಬಹುದು

176
00:14:26,850 --> 00:14:32,840
ನೀವು ನಿಜವಾದ CSV ಕಡತ ಔಟ್ ಪಡೆಯುವುದು.

177
00:14:32,840 --> 00:14:35,890
>> ಈ ವಿಷಯಗಳನ್ನು ಹೇಗೆ ತಿಳಿಯಲು ಹ್ಯಾಂಡಿ.

178
00:14:35,890 --> 00:14:42,010
ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನದಲ್ಲಿ ಅದು ಹೋಲುತ್ತದೆ ಎಂದು ಹೊಂದಿದೆ - ನನ್ನ ಪ್ರಕಾರ, ಇದು ಮೂಲಭೂತವಾಗಿ, ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಅನುಕರಿಸುವ ವಿಶೇಷವೇನು

179
00:14:42,010 --> 00:14:47,590
ಅಲ್ಲಿ, ನಾವು ಇಲ್ಲಿ ನೋಡಿ ಎಂದು, ತುಂಬಾ ಬಿಟ್ಟು ಅತ್ಯಂತ ತುಣುಕು,

180
00:14:47,590 --> 00:14:49,910
ನಾವು ಕೊನೆಯ ಹೆಸರು.

181
00:14:49,910 --> 00:14:54,670
ನಾವು ನಂತರ Malan, Hardison, ತದನಂತರ ಬೌಡೆನ್, MacWilliam, ಮತ್ತು ನಂತರ ಚಾನ್ ಹೊಂದಿರುತ್ತವೆ.

182
00:14:54,670 --> 00:14:59,470
ಎಲ್ಲಾ ಕೊನೆಯ ಹೆಸರುಗಳು. ಮತ್ತು ನಂತರ ಒಂದು ಅಲ್ಪವಿರಾಮ ಮೊದಲ ಹೆಸರುಗಳನ್ನು ಕೊನೆಯ ಹೆಸರುಗಳು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.

183
00:14:59,470 --> 00:15:02,970
ಡೇವಿಡ್, ನೇಟ್, ರಾಬ್, ಟಾಮಿ, ಮತ್ತು Zamyla.

184
00:15:02,970 --> 00:15:06,850
ನಾನು ಯಾವಾಗಲೂ ರಾಬಿ ಮತ್ತು ಟಾಮ್ ಅಪ್ ಮಿಶ್ರಣ.

185
00:15:06,850 --> 00:15:10,940
ನಂತರ, ಅಂತಿಮವಾಗಿ ಮೂರನೇ ಕಾಲಮ್ ಇಮೇಲ್ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿದೆ.

186
00:15:10,940 --> 00:15:18,500
ನೀವು ಅರ್ಥ ಒಮ್ಮೆ, ಕಾರ್ಯಕ್ರಮದ ಉಳಿದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ತಕ್ಕಮಟ್ಟಿಗೆ ನೇರವಾಗಿರುತ್ತದೆ.

187
00:15:18,500 --> 00:15:23,850
ನಮ್ಮ ಸಿ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಇದೇ ವಿನ್ಯಾಸವನ್ನು ಅನುಕರಿಸುವ ಸಲುವಾಗಿ ಮಾಡಿದ ಏನು

188
00:15:23,850 --> 00:15:27,510
ನಾವು ಒಂದು ರಚನೆ ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಿದ ಇದೆ.

189
00:15:27,510 --> 00:15:30,520
ನಾವು ಹಾಗೆಯೇ ಈ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಟವಾಡಿ ಮಾಡುತ್ತೇವೆ.

190
00:15:30,520 --> 00:15:35,790
ನಾವು ನಿಘಂಟುಗಳು ವ್ಯವಹರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಸಮಸ್ಯೆ ಸೆಟ್ 3, ಮೊದಲ ಸ್ವಲ್ಪ ಅವುಗಳನ್ನು ಕಂಡಿತು.

191
00:15:35,790 --> 00:15:40,290
ಆದರೆ ಈ ಸಿಬ್ಬಂದಿ struct ಕೊನೆಯ ಹೆಸರು, ಮೊದಲ ಹೆಸರು ಮತ್ತು ಇಮೇಲ್ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

192
00:15:40,290 --> 00:15:44,500
ನಮ್ಮ CSV ಕಡತ ರೀತಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುವ ಮಾಡಲಾಯಿತು.

193
00:15:44,500 --> 00:15:47,950
ಆದ್ದರಿಂದ ಈ ಒಂದು ರೂಪದಲ್ಲಿ ಇನ್ನೊಂದಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಇದೆ.

194
00:15:47,950 --> 00:15:54,630
ನಾವು, ಒಂದು ಮಾರ್ಗ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ಸಿಬ್ಬಂದಿ struct ಪರಿವರ್ತಿಸಲು ಹೊಂದಿವೆ

195
00:15:54,630 --> 00:15:59,060
ಕೇವಲ ಒಂದು ಅಲ್ಪವಿರಾಮ ಬೇರ್ಪಡಿಸಿದ ಲೈನ್.

196
00:15:59,060 --> 00:16:01,500
ಎಂದು ಅರ್ಥ ಡಸ್? ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ರಸಪ್ರಶ್ನೆ ತೆಗೆದುಕೊಂಡು, ಎಂದು

197
00:16:01,500 --> 00:16:07,680
ಆದ್ದರಿಂದ ನಾನು ನೀವು ಕನಿಷ್ಟ ಈ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು ಕೆಲವು ಸಮಯ ಇನ್ನೂ ಕಲ್ಪನೆ.

198
00:16:07,680 --> 00:16:16,410
>> ಬಾಡಿಗೆ ಕಾರ್ಯದಲ್ಲಿ, ಸಮಸ್ಯೆಯನ್ನು ನಾವು ತೆಗೆದುಕೊಳ್ಳಲು ಕೇಳುತ್ತದೆ - ಈ ಸ್ವಲ್ಪ ಮೇಲೆ we'll ಜೂಮ್ -

199
00:16:16,410 --> 00:16:22,480
, ಹೆಸರು ರು ಜೊತೆ, ಸಿಬ್ಬಂದಿ ವಿನ್ಯಾಸ, ಸಿಬ್ಬಂದಿ struct ಕೈಗೊಳ್ಳಬೇಕಾದ

200
00:16:22,480 --> 00:16:30,900
ಮತ್ತು ನಮ್ಮ staff.csv ಕಡತವನ್ನು ಅದರ ವಿಷಯಗಳನ್ನು ಸೇರಿಸಲು.

201
00:16:30,900 --> 00:16:34,230
ಇದು ಬಳಸಲು ಸಾಕಷ್ಟು ನೇರ ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

202
00:16:34,230 --> 00:16:37,430
ನಾವು ರೀತಿಯ ಸ್ವಲ್ಪ ಈ ಕಾರ್ಯಗಳನ್ನು ಇಂದು ಸುಮಾರು ಆಡಲು ಮಾಡುತ್ತೇವೆ.

203
00:16:37,430 --> 00:16:44,510
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, fprintf ಕಾರ್ಯ ನಿಜಕ್ಕೂ ಕೀಲಿಯಾಗಿದೆ.

204
00:16:44,510 --> 00:16:51,960
ಆದ್ದರಿಂದ fprintf ಜೊತೆಗೆ, ನಾವು ನೀವು ಹುಡುಗರಿಗೆ printf ಇಡೀ ಪದವನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ ರೀತಿಯಲ್ಲಿಯೇ, ಮುದ್ರಿಸಬಹುದು.

205
00:16:51,960 --> 00:16:55,050
ನೀವು ಒಂದು ಕಡತವನ್ನು printf ಒಂದು ಸಾಲಿನ ಮಾಡಬಹುದು.

206
00:16:55,050 --> 00:16:59,030
ಬದಲಾಗಿ ಕೇವಲ ಸಾಮಾನ್ಯ printf ಕರೆ ಮಾಡುವ ಆದ್ದರಿಂದ ನೀವು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ ಅಲ್ಲಿ

207
00:16:59,030 --> 00:17:05,380
ತದನಂತರ ನೀವು ಕೆಳಗಿನ ವಾದಗಳನ್ನು ಎಲ್ಲಾ ವ್ಯತ್ಯಾಸಗಳ ಬದಲಿಗೆ

208
00:17:05,380 --> 00:17:11,290
fprintf ಜೊತೆಗೆ, ನಿಮ್ಮ ಮೊದಲ ವಾದವನ್ನು ಬದಲಿಗೆ ನೀವು ಬರೆಯಲು ಬಯಸುವ ಫೈಲ್ ಆಗಿದೆ.

209
00:17:11,290 --> 00:17:21,170
ನಾವು, ಮಾನವ fprintf, ಉದಾಹರಣೆಗೆ, ಉಪಕರಣಗಳಲ್ಲಿರುವ ಈ ನೋಡಲು ಬಂದಾಗ

210
00:17:21,170 --> 00:17:25,980
ನಾವು printf ಮತ್ತು fprintf ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡಬಹುದು.

211
00:17:25,980 --> 00:17:28,960
ನಾನು ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಜೂಮ್ ಮಾಡುತ್ತೇವೆ.

212
00:17:28,960 --> 00:17:33,140
Printf ಹೊಂದಿರುವ ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ, ತದನಂತರ ಮುಂದಿನ ವಾದಗಳು

213
00:17:33,140 --> 00:17:37,580
ನಮ್ಮ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಬದಲಾವಣೆ ಅಥವಾ ಪರ್ಯಾಯ ಎಲ್ಲಾ ಚರಗಳಾಗಿವೆ.

214
00:17:37,580 --> 00:17:47,310
Fprintf ಹೊಂದಿರುವ ಆದರೆ, ಮೊದಲ ವಾದವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಹರಿವು ಎನ್ನುವರು ಈ ಫೈಲ್ * ಹೊಂದಿದೆ.

215
00:17:47,310 --> 00:17:51,800
>> ನಮ್ಮ ಬಾಡಿಗೆ ಇಲ್ಲಿ ಮೇಲೆ ಹಿಂದಕ್ಕೆ ಚಲಿಸುವ

216
00:17:51,800 --> 00:17:54,550
ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಫೈಲ್ * ಸ್ಟ್ರೀಮ್ ನಮಗೆ ತೆರೆಯಿತು ಮಾಡಲೇಬೇಕು.

217
00:17:54,550 --> 00:17:57,810
ಆ ನ ಈ ಮೊದಲ ಲೈನ್ ಏನು ಇದು staff.csv ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ,

218
00:17:57,810 --> 00:18:01,690
ಇದು ಸೇರ್ಪಡಿಸಲಾದ ಕ್ರಮದಲ್ಲಿ ಇದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಮತ್ತು ಹಾಗೆ ಮಾಡಲು ಎಡಭಾಗದ ಎಲ್ಲಾ ಹೊಂದಿದೆ

219
00:18:01,690 --> 00:18:08,640
ಕಡತದ ಸಿಬ್ಬಂದಿ ರಚನೆಯ ಬರೆಯಲು.

220
00:18:08,640 --> 00:18:10,870
ಮತ್ತು, ನಾನು ಐಪ್ಯಾಡ್ ಬಳಸಲು ಬಯಸುತ್ತಾರೆ, ನೋಡೋಣ?

221
00:18:10,870 --> 00:18:17,900
ನಾನು ಐಪ್ಯಾಡ್ ಬಳಸಿ. ನಾವು ಶೂನ್ಯವನ್ನು ಹೊಂದಿವೆ - ನಾನು ಸ್ವಲ್ಪ ಉತ್ತಮ ಬರೆಯಬಹುದು ಹಾಗೆ ಮೇಜಿನ ಮೇಲೆ ಈ ಪುಟ್ ನೋಡೋಣ -

222
00:18:17,900 --> 00:18:33,680
ಬಾಡಿಗೆ ಶೂನ್ಯವಾಗುವ ಮತ್ತು, ಒಂದು ವಾದದಲ್ಲಿನ ರು ಎಂಬ ಸಿಬ್ಬಂದಿ ರಚನೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

223
00:18:33,680 --> 00:18:44,120
ನಮ್ಮ ಕಟ್ಟುಪಟ್ಟಿಗಳು ಗಾಟ್, ನಾವು, ಕಡತ ಎಂದು ನಮ್ಮ ಫೈಲ್ * ಪಡೆದಿರುವಿರಿ

224
00:18:44,120 --> 00:18:48,380
ನಾವು, ನಮಗೆ ನೀಡಿರುವ ನಮ್ಮ fopen ಲೈನ್ ಹೊಂದಿವೆ

225
00:18:48,380 --> 00:18:51,890
ಇದು pedia ಈಗಾಗಲೇ ರಿಂದ ಮತ್ತು ನಾನು ಚುಕ್ಕೆಗಳು ಎಂದು ಬರೆಯಲು ಮಾಡುತ್ತೇವೆ.

226
00:18:51,890 --> 00:19:00,530
ನಂತರ ನಮ್ಮ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ, ನಾವು fprintf ಗೆ ಕರೆ ಮಾಡಲು ನೀನು

227
00:19:00,530 --> 00:19:03,700
ಮತ್ತು ನಾವು, ನಾವು ಮುದ್ರಿಸಲು ಬಯಸುವ ಕಡತದಲ್ಲಿ ರವಾನಿಸಲು ನೀನು

228
00:19:03,700 --> 00:19:10,290
ತದನಂತರ ನಮ್ಮ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್, ಇದು -

229
00:19:10,290 --> 00:19:14,300
ನಾನು ನೀವು ಹುಡುಗರಿಗೆ ಇದು ಕಾಣುತ್ತದೆ ಹೇಳಿ ತಿಳಿಸುತ್ತೇವೆ.

230
00:19:14,300 --> 00:19:20,500
ಹೇಗೆ ನೀವು, ಸ್ಟೆಲ್ಲಾ? ನೀವು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಭಾಗವಾಗಿ ಕಾಣುತ್ತದೆ ಏನು ಗೊತ್ತೇ?

231
00:19:20,500 --> 00:19:24,270
[ಸ್ಟೆಲ್ಲಾ] ನಾನು ಖಚಿತವಿಲ್ಲ. >> ಜಿಮ್ಮಿ ಕೇಳಲು ಹಿಂಜರಿಯಬೇಡಿ.

232
00:19:24,270 --> 00:19:27,690
ನೀವು, ಜಿಮ್ಮಿ ತಿಳಿಯುವುದು?

233
00:19:27,690 --> 00:19:31,000
[ಜಿಮ್ಮಿ] ಇದು ಕೇವಲ ಕೊನೆಯ ಬಯಸುವಿರಾ? ನನಗೆ ಗೊತ್ತಿಲ್ಲ. ನಾನು ಸಂಪೂರ್ಣವಾಗಿ ಖಚಿತವಿಲ್ಲ.

234
00:19:31,000 --> 00:19:39,020
ಸರಿ >>. ಹೇಗೆ, ಯಾರೇ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಈ ಸರಿಯಾದ ಬಂದೆವು?

235
00:19:39,020 --> 00:19:41,770
ಆಲ್ ರೈಟ್ ನಂ.

236
00:19:41,770 --> 00:19:47,920
ಇಲ್ಲಿ ನಾವು ಎಲ್ಲಾ ನಮ್ಮ ಸಿಬ್ಬಂದಿ ರಚನೆಯ ಪ್ರತಿ ಭಾಗವನ್ನು ಬಯಸುವ ಎಂದು ತಿರುಗಿದರೆ

237
00:19:47,920 --> 00:19:53,290
ನಮ್ಮ ಫೈಲ್ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಔಟ್ ಮುದ್ರಿತವಾಗಬಹುದು.

238
00:19:53,290 --> 00:19:59,900
ನಾವು ಕೊನೆಯ ಹೆಸರು ಏಕೆಂದರೆ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಪರ್ಯಾಯ ಅಕ್ಷರ ಮೂರು ವಿವಿಧ ಬಾರಿ ಬಳಸಲು

239
00:19:59,900 --> 00:20:07,160
ಅಲ್ಪವಿರಾಮ ನಂತರ, ನಂತರ ಮೊದಲ ಹೆಸರು, ಚಿಹ್ನೆಗಳಿಂದ ನಂತರ

240
00:20:07,160 --> 00:20:12,430
ತದನಂತರ ಅಂತಿಮವಾಗಿ ಇದು ಇಮೇಲ್ ವಿಳಾಸಕ್ಕೆ ನಂತರ - ಇರುವಂತಹ

241
00:20:12,430 --> 00:20:15,140
ನನ್ನ ತೆರೆಯಲ್ಲಿ ಅಳವಡಿಸುವುದಿಲ್ಲ - ಆದರೆ ಒಂದು ಹೊಸಸಾಲು ಪಾತ್ರಕ್ಕೆ ಅನುಸರಿಸಿದರು.

242
00:20:15,140 --> 00:20:20,060
ಆದ್ದರಿಂದ ನಾನು ಕೆಳಗೆ ಅದನ್ನು ಬರೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ.

243
00:20:20,060 --> 00:20:23,560
ತದನಂತರ, ನಮ್ಮ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ನಂತರ

244
00:20:23,560 --> 00:20:27,880
ನಾವು ನಾವು ಡಾಟ್ ಸಂಕೇತಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರವೇಶಿಸಲು ಇದು ಬದಲಿ ಹೊಂದಿವೆ

245
00:20:27,880 --> 00:20:31,370
ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಸೆಟ್ 3 ರಲ್ಲಿ ಕಂಡರು.

246
00:20:31,370 --> 00:20:48,820
ನಾವು s.last, s.first, ಮತ್ತು s.email ಬಳಸಬಹುದು

247
00:20:48,820 --> 00:20:58,990
ನಮ್ಮ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಇಂತಹ ಮೂರು ಮೌಲ್ಯಗಳನ್ನು ಬದಲಿಗೆ.

248
00:20:58,990 --> 00:21:06,190
ಆದ್ದರಿಂದ ಹೇಗೆ ಹೋಗಿವೆ? ಅರ್ಥ?

249
00:21:06,190 --> 00:21:09,700
ಹೌದು? ಇಲ್ಲ? ಬಹುಶಃ? ಸರಿ.

250
00:21:09,700 --> 00:21:14,180
>> ನಾವು ಮುದ್ರಿತ ನೀವು ಮತ್ತು ನಾವು ನಮ್ಮ ಫೈಲ್ ತೆರೆಯಿತು ಮಾಡಿದ ನಂತರ ನಂತರ ನಾವು ಮಾಡುವ ಅಂತಿಮ ವಿಷಯ:

251
00:21:14,180 --> 00:21:17,370
ನಾವು ಒಂದು ಕಡತ ತೆರೆಯಿತು ಇಲ್ಲಿಗೆ ಬಂದಾಗಲೆಲ್ಲಾ, ನಾವು ಯಾವಾಗಲೂ ಮುಚ್ಚಲು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

252
00:21:17,370 --> 00:21:19,430
ಇಲ್ಲದಿದ್ದರೆ ನಾವು ಮೆಮೊರಿ ಸೋರಿಕೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡುತ್ತೇವೆ ಏಕೆಂದರೆ,

253
00:21:19,430 --> 00:21:22,500
ಫೈಲ್ ವಿವರಣೆಗಳ ಉಪಯೋಗಿಸಿ.

254
00:21:22,500 --> 00:21:25,950
ನಾವು ಯಾವ ಕಾರ್ಯ ಬಳಸುವುದು, ಅದನ್ನು ಮುಚ್ಚಲು? ಡೇನಿಯಲ್?

255
00:21:25,950 --> 00:21:30,120
[ಡೇನಿಯಲ್] fclose? ನಿಖರವಾಗಿ >> fclose.

256
00:21:30,120 --> 00:21:37,520
ಆದ್ದರಿಂದ ಈ ಸಮಸ್ಯೆಯನ್ನು ಕೊನೆಯ ಭಾಗವಾಗಿದೆ, fclose ಕಾರ್ಯಕಾರಿತ್ವ ಬಳಸಿಕೊಂಡು, ಫೈಲ್ ಸರಿಯಾಗಿ ಮುಚ್ಚಿ ಆಗಿತ್ತು

257
00:21:37,520 --> 00:21:40,370
ಇದು ಕೇವಲ ಎಂದು ತೋರುತ್ತಿದೆ.

258
00:21:40,370 --> 00:21:43,880
ತುಂಬಾ ಕ್ರೇಜಿ ಅಲ್ಲ.

259
00:21:43,880 --> 00:21:46,990
ಕೂಲ್.

260
00:21:46,990 --> 00:21:49,520
ಆದ್ದರಿಂದ ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಸಮಸ್ಯೆಯನ್ನು 33 ಇಲ್ಲಿದೆ.

261
00:21:49,520 --> 00:21:52,480
ನಾವು I / O ಮುಂಬರುವ ಖಂಡಿತವಾಗಿಯೂ ಹೆಚ್ಚು ಕಡತವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

262
00:21:52,480 --> 00:21:55,130
ನಾವು, ಇಂದು ಇಂದು ಉಪನ್ಯಾಸ ಒಂದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮಾಡಲು, ಅಥವಾ ವಿಭಾಗದಲ್ಲಿ ವಿಲ್

263
00:21:55,130 --> 00:22:01,710
ಈ ಮುಂಬರುವ pset ಬಹುಭಾಗವು ರಚಿಸಲು ಏನು ನಡೆಯುತ್ತಿದೆ, ಏಕೆಂದರೆ.

264
00:22:01,710 --> 00:22:05,020
ನ ಈ ಹಂತದಲ್ಲಿ ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಚಲಿಸೋಣ. ಹೌದು?

265
00:22:05,020 --> 00:22:10,880
>> [ಷಾರ್ಲೆಟ್]] ವೈ ಬದಲಿಗೆ fclose ಆಫ್ fclose (ಕಡತ) (staff.csv)?

266
00:22:10,880 --> 00:22:19,100
>> ಆಹ್. ಆ ತಿರುಗಿದರೆ ಕಾರಣ - ಹೀಗೆ ಪ್ರಶ್ನೆ, ಒಂದು ದೊಡ್ಡ ಒಂದು ಇದು,

267
00:22:19,100 --> 00:22:27,800
ಏಕೆ, ನಾವು fclose ಬರೆಯಲು ನಾವು fclose (ಕಡತ) ಸ್ಟಾರ್ ವೇರಿಯಬಲ್ ಬರವಣಿಗೆಯಲ್ಲಿ ಇದೆ

268
00:22:27,800 --> 00:22:33,680
ಕಡತದ ಹೆಸರು, staff.csv ವಿರುದ್ಧವಾಗಿ? ಅದು ಸರಿಯೇ? ಹೌದು.

269
00:22:33,680 --> 00:22:39,570
ಆದ್ದರಿಂದ ಅವರ ಅವಲೋಕಿಸೋಣ. ನನ್ನ ಲ್ಯಾಪ್ಟಾಪ್ ಹಿಂದಿರುಗಿ ವೇಳೆ,

270
00:22:39,570 --> 00:22:45,040
ಮತ್ತು ಅವರ fclose ಕಾರ್ಯವನ್ನು ನೋಡೋಣ.

271
00:22:45,040 --> 00:22:51,460
ಆದ್ದರಿಂದ, fclose ಕ್ರಿಯೆಯ ಒಂದು ಸ್ಟ್ರೀಮ್ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ ಮತ್ತು ನಾವು ಮುಚ್ಚಲು ಬಯಸುವ ಸ್ಟ್ರೀಮ್ಗೆ ದಿಕ್ಸೂಚಕ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

272
00:22:51,460 --> 00:22:57,010
ಎಂದು ನಾವು ಮುಚ್ಚಲು ಬಯಸುವ ವಾಸ್ತವಿಕ ಕಡತ ಹೆಸರು ವಿರೋಧಿಸಿದರು.

273
00:22:57,010 --> 00:23:01,620
ಮತ್ತು ಈ ಕಾರಣದಿಂದಾಗಿ ತೆರೆಮರೆಯಲ್ಲಿ, ನೀವು fopen ಒಂದು ಕರೆ ಮಾಡಿದಾಗ, ಆಗಿದೆ

274
00:23:01,620 --> 00:23:12,020
ನೀವು ಒಂದು ಫೈಲ್ ಅನ್ನು ತೆರೆದಾಗ, ನೀವು ವಾಸ್ತವವಾಗಿ ಫೈಲ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮೆಮೊರಿ ಹಂಚುತ್ತಾರೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

275
00:23:12,020 --> 00:23:16,380
ಆದ್ದರಿಂದ ನೀವು ಕಡತದ ಬಗೆಗಿನ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುವ ಕಡತವನ್ನು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ

276
00:23:16,380 --> 00:23:23,080
ಅದನ್ನು ತೆರೆಯಲು ಉದಾಹರಣೆಗೆ, ನೀವು ಫೈಲ್ ಪ್ರಸ್ತುತ ಅಲ್ಲಿ ಅದರ ಗಾತ್ರ,

277
00:23:23,080 --> 00:23:29,100
ನೀವು ಓದಲು ಮತ್ತು ಕಡತ ಒಳಗೆ ನಿರ್ದಿಷ್ಟ ಸ್ಥಳಕ್ಕೆ ಕರೆಗಳು ಬರೆಯಲು ಇದರಿಂದ.

278
00:23:29,100 --> 00:23:38,060
ಬದಲಾಗಿ ನೀವು ಫೈಲ್ ಹೆಸರು ಮುಚ್ಚುವ ಪಾಯಿಂಟರ್ ಮುಚ್ಚುವ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

279
00:23:38,060 --> 00:23:48,990
>> ಹೌದು? [ಡೇನಿಯಲ್] ಆದ್ದರಿಂದ ಬಾಡಿಗೆ ಬಳಸಲು, ನೀವು ಹೇಳಬಹುದು - ಹೇಗೆ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಮಾಡುತ್ತದೆ?

280
00:23:48,990 --> 00:23:53,830
Fprintf ಕೇವಲ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ನಿರೀಕ್ಷಿಸಿ ಮಾಡುತ್ತೇವೆ ಎಂಬ ಅರ್ಥದಲ್ಲಿ GetString ವರ್ತಿಸುತ್ತಾರೆ ಡಸ್

281
00:23:53,830 --> 00:23:57,180
ಮತ್ತು ನೀವು ಈ ಟೈಪಿಸಲು ಕೇಳಿ - ಅಥವಾ ನೀವು ಈ ಮೂರು ವಿಷಯಗಳನ್ನು ಟೈಪಿಸಿ ನಿರೀಕ್ಷಿಸಿ?

282
00:23:57,180 --> 00:24:00,480
ಅಥವಾ ನೀವು ಬಾಡಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಏನೋ ಬಳಸಲು ಬೇಕು?

283
00:24:00,480 --> 00:24:04,100
>> ಹೌದು. ನಾವು ಇಲ್ಲ - ಪ್ರಶ್ನೆ, ಹೇಗೆ ನಾವು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಸಿಗುತ್ತವೆ ಮಾಡಲಾಯಿತು

284
00:24:04,100 --> 00:24:09,220
ಬಾಡಿಗೆ ಜಾರಿಗೆ ಸಲುವಾಗಿ? ಮತ್ತು ಇಲ್ಲಿರುವುದು, ಬಾಡಿಗೆ ಆಫ್ ಕಾಲರ್ ಆಗಿದೆ

285
00:24:09,220 --> 00:24:17,690
ಈಗಾಗಲೇ struct ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾವನ್ನು ಈ ಸಿಬ್ಬಂದಿ struct ರಲ್ಲಿ ಅನುಮೋದಿಸಿತು.

286
00:24:17,690 --> 00:24:22,990
ಆದ್ದರಿಂದ fprintf ಕೇವಲ ಕಡತ ನೇರವಾಗಿ ಡೇಟಾವನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

287
00:24:22,990 --> 00:24:25,690
ಯಾವುದೇ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಕಾಯುತ್ತಿರುವ ಇಲ್ಲ.

288
00:24:25,690 --> 00:24:32,110
ಬಳಕೆದಾರ ಈಗಾಗಲೇ ಸರಿಯಾಗಿ ಈ ಸಿಬ್ಬಂದಿ struct ನಲ್ಲಿ ಹಾಕುವ ಮೂಲಕ ಇನ್ಪುಟ್ ನೀಡಿದ ನ.

289
00:24:32,110 --> 00:24:36,510
ಆ ಪಾಯಿಂಟರ್ಗಳ ಯಾವುದೇ ಶೂನ್ಯ ವೇಳೆ ಮತ್ತು ವಿಷಯಗಳು, ಕೋರ್ಸ್, ಮುರಿಯಬಲ್ಲ

290
00:24:36,510 --> 00:24:40,370
ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಮತ್ತೆ ಸ್ಕ್ರಾಲ್ ಮತ್ತು ನಮ್ಮ struct ನೋಡಲು.

291
00:24:40,370 --> 00:24:43,640
ನಾವು ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯ ವಾಕ್ಯವನ್ನು ಮೊದಲ, ಸ್ಟ್ರಿಂಗ್ ಇಮೇಲ್ ಹೊಂದಿರುತ್ತವೆ.

292
00:24:43,640 --> 00:24:48,530
ನಾವು ಈಗ ಆ ನಿಜವಾಗಿಯೂ ಎಲ್ಲಾ HOOD ಅಡಿಯಲ್ಲಿ, ಚಾರ್ * ಚರಗಳಾಗಿವೆ ತಿಳಿದಿದೆ.

293
00:24:48,530 --> 00:24:53,470
ಆ ಶೂನ್ಯ ತೋರುತ್ತಿರುವಂತೆ ಇರಬಹುದು ಅಥವಾ.

294
00:24:53,470 --> 00:24:55,800
ಅವರು, ರಾಶಿ ಮೆಮೊರಿಯ ತೋರುತ್ತಿರುವಂತೆ ಮಾಡಬಹುದು

295
00:24:55,800 --> 00:24:59,650
ಸ್ಟಾಕ್ ಮೇಲೆ ಬಹುಶಃ ಮೆಮೊರಿ.

296
00:24:59,650 --> 00:25:04,580
ನಾವು ನಿಜವಾಗಿ, ಆದರೆ ಈ ಪಾಯಿಂಟರ್ಗಳ ಯಾವುದೇ ಶೂನ್ಯ, ಅಥವಾ ಅಮಾನ್ಯವಾಗಿದೆ ವೇಳೆ, ಇಲ್ಲ

297
00:25:04,580 --> 00:25:08,120
ಖಂಡಿತವಾಗಿಯೂ ನಮ್ಮ ಬಾಡಿಗೆ ಕಾರ್ಯ ಕುಸಿತಕ್ಕೆ ಮಾಡುತ್ತೇವೆ ಆ.

298
00:25:08,120 --> 00:25:11,050
ಆ ಪರೀಕ್ಷೆಯಲ್ಲಿ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿ ರೀತಿಯ ಎಂದು ಏನೋ.

299
00:25:11,050 --> 00:25:16,440
ನಾವು ಚಿಂತಿಸುತ್ತಿರುತ್ತಿದ್ದನು ಇಲ್ಲ.

300
00:25:16,440 --> 00:25:22,170
ಗ್ರೇಟ್. ಸರಿ. ಆದ್ದರಿಂದ ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಚಲಿಸುವ.

301
00:25:22,170 --> 00:25:25,760
>> ನ ಈ ವ್ಯಕ್ತಿ ಮುಚ್ಚಿ ಅವಕಾಶ, ಮತ್ತು ನಾವು pset 4 ನೋಡಲು ನೀನು.

302
00:25:25,760 --> 00:25:34,700
ನೀವು ಹುಡುಗರಿಗೆ pset ವಿಶೇಷ ನೋಡಲು ಆದ್ದರಿಂದ, ಒಮ್ಮೆ ನೀವು ಪ್ರವೇಶಿಸಬಹುದು, cs50.net/quizzes,

303
00:25:34,700 --> 00:25:42,730
ನಾವು ವಿಭಾಗ ಸಮಸ್ಯೆಗಳು ಇಂದು ಕೆಲವು ಮೂಲಕ ಹೋಗುತ್ತಿದ್ದೇವೆ.

304
00:25:42,730 --> 00:25:52,240
ನಾನು ಕೆಳಗೆ ಸ್ಕ್ರೋಲ್ ನಾನು - ಪ್ರಶ್ನೆಗಳನ್ನು ವಿಭಾಗ pset ಸ್ಪೆಕ್ನ ಮೂರನೇ ಪುಟದಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ.

305
00:25:52,240 --> 00:25:57,800
ಮತ್ತು ಮೊದಲ ಭಾಗವಾಗಿ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮತ್ತು ಪೈಪುಗಳ ಮೇಲೆ ಹೋಗಿ ಸಣ್ಣ ವೀಕ್ಷಿಸಲು ನೀವು ಕೇಳುತ್ತದೆ.

306
00:25:57,800 --> 00:26:02,820
ತಂಪಾದ ಸಣ್ಣ ರೀತಿಯ ಇದು, ನೀವು ಬಳಸಬಹುದಾದ ಕೆಲವು ಹೊಸ ತಂಪು ಆಜ್ಞಾ ಸಾಲಿನ ಟ್ರಿಕ್ಸ್ ತೋರಿಸುತ್ತದೆ.

307
00:26:02,820 --> 00:26:06,050
ನಂತರ ನಾವು ಮತ್ತು ನೀವು ಕೆಲವು ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾಡಲೇಬೇಕು.

308
00:26:06,050 --> 00:26:10,860
ತೊರೆಗಳು ಬಗ್ಗೆ ಈ ಮೊದಲ ಪ್ರಶ್ನೆ, printf ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬರೆಯುತ್ತಾರೆ ಯಾವ,

309
00:26:10,860 --> 00:26:15,920
ನಾವು ರೀತಿಯ ಕೊಂಚ ಹಿಂದೆ ಸ್ವಲ್ಪ ಮೇಲೆ ಮುಟ್ಟಲಿಲ್ಲ.

310
00:26:15,920 --> 00:26:22,380
ನಾವು ಚರ್ಚಿಸುತ್ತಿದ್ದಾರೆ ಎಂದು ಈ fprintf ಅದರ ಚರ್ಚೆಯಂತೆ ಫೈಲ್ * ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

311
00:26:22,380 --> 00:26:26,580
fclose, ಹಾಗೆಯೇ ಒಂದು ಕಡತ * ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

312
00:26:26,580 --> 00:26:32,660
ಮತ್ತು fopen ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಹಾಗು ನೀವು ಕಡತವನ್ನು * ಸ್ಟ್ರೀಮ್ ನೀಡುತ್ತದೆ.

313
00:26:32,660 --> 00:26:36,060
ನಾವು printf ವ್ಯವಹರಿಸಿದೆ ನಾವು ನಾವು ಮೊದಲು ಆ ನೋಡಿಲ್ಲ ಕಾರಣ

314
00:26:36,060 --> 00:26:39,450
printf ಒಂದು ಡೀಫಾಲ್ಟ್ ಸ್ಟ್ರೀಮ್ ಹೊಂದಿದೆ ಏಕೆಂದರೆ.

315
00:26:39,450 --> 00:26:41,810
ಮತ್ತು ಅದನ್ನು ಬರೆಯುತ್ತಾರೆ ಯಾವ ಡೀಫಾಲ್ಟ್ ಸ್ಟ್ರೀಮ್

316
00:26:41,810 --> 00:26:45,190
ನೀವು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಬಗ್ಗೆ ಕಾಣುವಿರಿ.

317
00:26:45,190 --> 00:26:50,080
ಆದ್ದರಿಂದ ಖಂಡಿತವಾಗಿ ಇದು ನೋಡೋಣ.

318
00:26:50,080 --> 00:26:53,010
>> ಇಂದಿನ ವಿಭಾಗದಲ್ಲಿ, ನಾವು, GDB ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮಾತನಾಡಲು ನೀನು

319
00:26:53,010 --> 00:26:57,720
ಹೆಚ್ಚು ಪರಿಚಿತ ನೀವು ಹೊಂದಿರುವ ಕಾರಣ, ಹೆಚ್ಚು ಅಭ್ಯಾಸ ನೀವು, ಅದನ್ನು ಪಡೆಯಲು

320
00:26:57,720 --> 00:27:01,390
ಸಮರ್ಥವಾಗಿರುತ್ತವೆ ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಸ್ವಂತ ಕೋಡ್ ನ್ಯೂನತೆಗಳನ್ನು ಬೇಟೆಯಾಡಲು ಇರುವಿರಿ.

321
00:27:01,390 --> 00:27:05,540
ಈ ಮಹತ್ತರವಾಗಿ ಅಪ್ ಡೀಬಗ್ ಪ್ರಕ್ರಿಯೆಯ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

322
00:27:05,540 --> 00:27:09,230
ಆದ್ದರಿಂದ printf ಬಳಸಿಕೊಂಡು, ಪ್ರತಿ ಬಾರಿ ನೀವು ನಿಮ್ಮ ಕೋಡ್ ಮರುಸಂಕಲಿಕೆಯು ಮಾಡಬೇಕು ಹಾಗೆ

323
00:27:09,230 --> 00:27:13,000
ನೀವು ಮತ್ತೆ ಚಲಾಯಿಸಲು ಹೊಂದಿರುತ್ತವೆ, ಕೆಲವೊಮ್ಮೆ ನೀವು, ಸುಮಾರು printf ಕರೆ ಸ್ಥಳಾಂತರಿಸಲು

324
00:27:13,000 --> 00:27:17,100
ಕೋಡ್ ಔಟ್ ಕಾಮೆಂಟ್, ಇದು ಕೇವಲ ಸ್ವಲ್ಪ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

325
00:27:17,100 --> 00:27:20,850
ನಮ್ಮ ಗುರಿ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು GDB ಜೊತೆಗೆ, ನೀವು ಮೂಲಭೂತವಾಗಿ ಎಂಬುದನ್ನು ನೀವು ಮನವರಿಕೆ ಮಾಡುವುದು

326
00:27:20,850 --> 00:27:26,810
printf ನಿಮ್ಮ ಕೋಡ್ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಏನು ಮತ್ತು ನೀವು ಮರುಸಂಕಲಿಕೆಯು ಯಾವತ್ತೂ.

327
00:27:26,810 --> 00:27:35,120
ನೀವು ಆರಂಭಿಸಲು ಮತ್ತು ಅಲ್ಲಿ printf ಮುಂದಿನ ಊಹೆ ಇರಿಸಿಕೊಳ್ಳಲು ಎಂದಿಗೂ.

328
00:27:35,120 --> 00:27:40,910
ಮಾಡಲು ಮೊದಲನೆಯದಾಗಿ ಈ ಸಾಲಿನ ನಕಲಿಸಿ ಮತ್ತು ವೆಬ್ ನ ವಿಭಾಗ ಕೋಡ್ ಆಫ್ ಪಡೆಯುವುದು.

329
00:27:40,910 --> 00:27:47,530
ನಾನು "wget ​​http://cdn.cs50.net" ಹೇಳುತ್ತದೆ ಕೋಡ್ ಈ ಸಾಲನ್ನು ನಕಲು ನುಡಿದರು.

330
00:27:47,530 --> 00:27:49,510
ನಾನು ನಕಲಿಸುವುದು ಪಡೆಯಲಿದ್ದೇನೆ.

331
00:27:49,510 --> 00:27:55,950
ನನ್ನ APPLIANCE ಮೇಲೆ ಹೋಗುತ್ತಿದ್ದೇವೆ ಭಾವಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ, ನಾನು ಏನು ಮಾಡುತ್ತಿರುವೆ ನೋಡಬಹುದು ಝೂಮ್ ಔಟ್

332
00:27:55,950 --> 00:28:01,890
ಹಾಗಾದರೆ ಇದು ಅಂಟಿಸುವುದು, ಮತ್ತು ನಾನು ನಮೂದಿಸಿ ಹೊಡೆದಾಗ, ಈ wget ಆಜ್ಞೆಯನ್ನು ಅಕ್ಷರಶಃ ವೆಬ್ ಪಡೆಯಲು ಆಗಿದೆ.

333
00:28:01,890 --> 00:28:06,210
ಇದು ಇಂಟರ್ನೆಟ್ ಈ ಫೈಲ್ ಆಫ್ ಕೆಳಗೆ ಎಳೆಯಲು ವಿಶೇಷವೇನು

334
00:28:06,210 --> 00:28:11,790
ಮತ್ತು ಪ್ರಸಕ್ತ ಕೋಶವನ್ನು ಅದನ್ನು ಉಳಿಸಲು ವಿಶೇಷವೇನು.

335
00:28:11,790 --> 00:28:21,630
ನನ್ನ ಪ್ರಸ್ತುತ ಕೋಶದ ಪಟ್ಟಿ ವೇಳೆ ಈಗ ನೀವು ನಾನು ಅಲ್ಲಿಗೆ ಈ section5.zip ಕಡತ ಮಾಡಲೇಬೇಕು ಎಂದು ನೋಡಬಹುದು.

336
00:28:21,630 --> 00:28:25,260
ಆ ವ್ಯಕ್ತಿ ವ್ಯವಹರಿಸುವ ರೀತಿ, ಇದು ಅನ್ಜಿಪ್ ಆಗಿದೆ

337
00:28:25,260 --> 00:28:27,650
ಇದು ನೀವು ಈ ರೀತಿಯಲ್ಲಿ, ಆಜ್ಞಾ ಮಾಡಬಹುದು.

338
00:28:27,650 --> 00:28:31,880
Section5.zip.

339
00:28:31,880 --> 00:28:36,980
ಇದು ಅನ್ಜಿಪ್ ಮಾಡುತ್ತೇವೆ ಎಂದು, ನನಗೆ ಫೋಲ್ಡರ್ ರಚಿಸಿ

340
00:28:36,980 --> 00:28:40,410
ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಹಣದುಬ್ಬರ, ಅಲ್ಲಿ ಅವುಗಳನ್ನು ಪುಟ್.

341
00:28:40,410 --> 00:28:47,410
ಈಗ ನಾನು CD ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನನ್ನ ವಿಭಾಗವು 5 ಕೋಶಕ್ಕೆ ಹೋಗಬಹುದು.

342
00:28:47,410 --> 00:28:58,310
ಸ್ಪಷ್ಟ ಬಳಸಿ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ. ಆದ್ದರಿಂದ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ.

343
00:28:58,310 --> 00:29:02,280
ಈಗ ನಾನು ವ್ಯವಹರಿಸಲು ಉತ್ತಮ ಕ್ಲೀನ್ ಟರ್ಮಿನಲ್ ಮಾಡಲೇಬೇಕು.

344
00:29:02,280 --> 00:29:06,200
>> ನಾನು ಈ ಕೋಶದಲ್ಲಿ ನೋಡಿ ಎಲ್ಲಾ ಕಡತಗಳನ್ನು ಪಟ್ಟಿ ಈಗ ವೇಳೆ

345
00:29:06,200 --> 00:29:12,270
buggy1, buggy2, buggy3, ಮತ್ತು buggy4: ನೀವು ನಾಲ್ಕು ಫೈಲ್ಗಳನ್ನು ಮಾಡಲೇಬೇಕು ಎಂದು ನೋಡಿ.

346
00:29:12,270 --> 00:29:16,180
ನಾನು ಅವುಗಳ. ಸಿ ಕಡತಗಳನ್ನು ಮಾಡಲೇಬೇಕು.

347
00:29:16,180 --> 00:29:20,400
ನಾವು ಈಗ. ಸಿ ಕಡತಗಳನ್ನು ನೋಡಲು ಹೋಗುತ್ತಿಲ್ಲ.

348
00:29:20,400 --> 00:29:24,140
ಬದಲಾಗಿ, ನಾವು GDB ತೆರೆಯುತ್ತದೆ ಅವುಗಳನ್ನು ಬಳಸಲು ನೀನು.

349
00:29:24,140 --> 00:29:28,220
ನಾವು GDB ಬಳಸುತ್ತಿರುವ ನಾವು, ನಾವು ನಿಜವಾದ ಮೂಲ ಕೋಡ್ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ ಕೂರಲು ಸುಮಾರು ಇದ್ದರು ನಾವು

350
00:29:28,220 --> 00:29:32,740
ಆದರೆ ವಿಭಾಗ ಈ ಭಾಗದ ಗೋಲು GDB ಜೊತೆ ಸುಮಾರು ಟಿಂಕರ್ ಮಾಡುವುದು

351
00:29:32,740 --> 00:29:40,370
ಮತ್ತು ಈ ನಾಲ್ಕು ದೋಷಯುಕ್ತ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಪ್ರತಿಯೊಂದು ತಪ್ಪು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ನೋಡಿ.

352
00:29:40,370 --> 00:29:43,380
ಆದ್ದರಿಂದ ನಾವು, ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಕೋಣೆಯ ಸುತ್ತಲೂ ಎಂದು ನೀನು

353
00:29:43,380 --> 00:29:47,000
ಮತ್ತು ನಾನು, ದೋಷಯುಕ್ತ ಕಾರ್ಯಕ್ರಮಗಳ ಒಂದು ರನ್ ಯಾರಾದರೂ ಕೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

354
00:29:47,000 --> 00:29:54,730
ನಂತರ, ನಾವು GDB ಮೂಲಕ ಗುಂಪು ಹೋಗುತ್ತೇನೆ, ಮತ್ತು ನಾವು ಈ ಕಾರ್ಯಕ್ರಮಗಳು ಸರಿಪಡಿಸಲು ಏನು ಮಾಡಬಹುದು ನೋಡುತ್ತಾರೆ

355
00:29:54,730 --> 00:29:58,460
ಅಥವಾ ಕನಿಷ್ಠ ಅವುಗಳಲ್ಲಿ ಒಂದು ತಪ್ಪು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಗುರುತಿಸಲು.

356
00:29:58,460 --> 00:30:04,760
ಡೇನಿಯಲ್ ಇಲ್ಲಿ ಮೇಲೆ ಆರಂಭಿಸೋಣ. ನೀವು buggy1 ರನ್ ಕಾಣಿಸುತ್ತದೆ? ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.

357
00:30:04,760 --> 00:30:09,470
[ಡೇನಿಯಲ್] ಇದು ಅಪ್ಲಿಕೇಶನ್ ತಪ್ಪು ಇಲ್ಲ ಹೇಳುತ್ತಾರೆ. >> ಹೌದು. ನಿಖರವಾಗಿ.

358
00:30:09,470 --> 00:30:12,460
ನಾನು buggy1 ರನ್ ಆದ್ದರಿಂದ, ನಾನು seg ತಪ್ಪು ಪಡೆಯಲು.

359
00:30:12,460 --> 00:30:16,210
ಈ ಸಮಯದಲ್ಲಿ, ನಾನು ಹೋಗಿ buggy1.c ತೆರೆಯುತ್ತದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

360
00:30:16,210 --> 00:30:19,450
, ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ತಪ್ಪು ವಿಶೇಷವೇನು ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ

361
00:30:19,450 --> 00:30:22,000
ಆದರೆ ಈ seg ತಪ್ಪು ದೋಷ ಬಗ್ಗೆ ಅತ್ಯಂತ ಹೇಸಿಗೆಯ ವಸ್ತುಗಳ ಒಂದು

362
00:30:22,000 --> 00:30:27,610
ಯೋಜನೆಯನ್ನು ವಸ್ತುಗಳ ಲೈನ್ ವಾಸ್ತವವಾಗಿ ತಪ್ಪಾಗಿದೆ ಮತ್ತು ಮುರಿಯಿತು ಏನನ್ನು ಹೇಳಲು ಅದು ಹೊಂದಿದೆ.

363
00:30:27,610 --> 00:30:29,880
ನೀವು ರೀತಿಯ ಕೋಡ್ ನೋಡಲು ಹೊಂದಿವೆ

364
00:30:29,880 --> 00:30:33,990
ಮತ್ತು ಊಹೆ ಬಳಸಿ ಲೆಕ್ಕಾಚಾರ ಮತ್ತು ಪರಿಶೀಲಿಸಿ ಅಥವಾ printf ತಪ್ಪು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು.

365
00:30:33,990 --> 00:30:37,840
GDB ಬಗ್ಗೆ ಉತ್ತಮ ಕೆಲಸವೆಂದರೆ ಅದು ನಿಜವಾಗಿಯೂ ಸುಲಭ ಎಂದು

366
00:30:37,840 --> 00:30:42,170
ಲೈನ್ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ ನಲ್ಲಿ.

367
00:30:42,170 --> 00:30:46,160
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಕೇವಲ ಆ ವೇಳೆ, ಇದು ಬಳಸಲು ಉಚಿತ.

368
00:30:46,160 --> 00:30:56,190
ಆದ್ದರಿಂದ GDB ಬೂಟ್ ನಾನು GDB ನಮೂದಿಸಿ, ಮತ್ತು ನಂತರ ನಾನು ಚಲಾಯಿಸಲು ಬಯಸುವ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಅದನ್ನು ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ.

369
00:30:56,190 --> 00:31:01,960
ಇಲ್ಲಿ ನಾನು GDB ./buggy1 ಟೈಪ್ ನುಡಿದರು.

370
00:31:01,960 --> 00:31:06,600
Enter ಒತ್ತಿರಿ. , ನನಗೆ ಈ ಹಕ್ಕುಸ್ವಾಮ್ಯ ಮಾಹಿತಿ ನೀಡುತ್ತದೆ

371
00:31:06,600 --> 00:31:13,000
ಮತ್ತು ಕೆಳಗೆ ಇಲ್ಲಿ ನೀವು ", / home / ಇಂದ ಓದುವಿಕೆ ಚಿಹ್ನೆಗಳನ್ನು ಹೇಳುತ್ತದೆ ಈ ಸಾಲಿನ ನೋಡುತ್ತಾರೆ

372
00:31:13,000 --> 00:31:17,680
jharvard/section5/buggy1. "

373
00:31:17,680 --> 00:31:22,060
ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಹೋದಲ್ಲಿ ಮತ್ತು, ನೀವು ಈ ತೋರುತ್ತಿದೆ ಒಂದು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ನೋಡುತ್ತಾರೆ.

374
00:31:22,060 --> 00:31:25,500
ಚಿಹ್ನೆಗಳನ್ನು ನೀವು ಓದಲು, ಅದು "ನಾನು, ನಿಮ್ಮ ಫೈಲ್ ಸಂಕೇತಗಳಿಂದ ಓದುವ ನಾನು" ಹೇಳುತ್ತೇನೆ

375
00:31:25,500 --> 00:31:29,900
ನಂತರ ಇಲ್ಲಿ ಈ "ಮಾಡಲಾಗಿದೆ" ಸಂದೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

376
00:31:29,900 --> 00:31:35,410
ಈ ಕೆಲವು ವ್ಯತ್ಯಯ ನೋಡಿ, ಅಥವಾ ನೀವು ನೋಡಲು ವೇಳೆ ಚಿಹ್ನೆಗಳನ್ನು ಹುಡುಕಲಾಗಲಿಲ್ಲ

377
00:31:35,410 --> 00:31:41,460
ಅಥವಾ ಹಾಗೆ ಏನೋ, ಏನು ಅರ್ಥ ನೀವು ಸರಿಯಾಗಿ ನಿಮ್ಮ ಕಾರ್ಯಗತಗೊಳಿಸಬಲ್ಲ ಕಂಪೈಲ್ ಮಾಡಿರದ ಹೊಂದಿರುತ್ತವೆ.

378
00:31:41,460 --> 00:31:49,980
ನಾವು GDB ಉಪಯೋಗಿಸಲು ಕಾರ್ಯಕ್ರಮಗಳು ಕಂಪೈಲ್ ಮಾಡುವಾಗ, ನಾವು, ಆ ವಿಶೇಷ ಗ್ರಾಂ ಧ್ವಜ ಬಳಸಬೇಕು

379
00:31:49,980 --> 00:31:54,540
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಕಂಪೈಲ್ ವೇಳೆ ಮತ್ತು ಕೇವಲ ಮಾಡಲು ನಮೂದಿಸುವ ಮೂಲಕ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿಲ್ಲಿಸುವುದಾಗಿ

380
00:31:54,540 --> 00:31:59,320
ಅಥವಾ ದೋಷಯುಕ್ತ ಮಾಡಲು ಅಥವಾ ಆ ಯಾವುದೇ ಗುಣಮುಖನಾಗಿಸಬಹುದು.

381
00:31:59,320 --> 00:32:07,800
ಆದರೆ ನೀವು ಖಣಿಲು ಜೊತೆಗೆ ಕೈಯಿಂದ ಕಂಪೈಲ್ ಬಳಸುತ್ತಿದ್ದರೆ, ಆಗ ನೀವು ಹೋಗಿ ಎಂದು-G ಧ್ವಜ ಸೇರಿವೆ ಮಾಡಬೇಕಾಗಬಹುದು.

382
00:32:07,800 --> 00:32:10,310
>> ಈ ಹಂತದಲ್ಲಿ, ಈಗ ನಮ್ಮ GDB ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ, ಎಂದು

383
00:32:10,310 --> 00:32:12,310
ಇದು ಪ್ರೊಗ್ರಾಮನ್ನು ಬಹಳ ಸರಳ.

384
00:32:12,310 --> 00:32:19,740
ನಾವು ಎರಡೂ ರನ್ ಟೈಪ್ ಮಾಡಬಹುದು, ಅಥವಾ ನಾವು R ಟೈಪ್ ಮಾಡಬಹುದು.

385
00:32:19,740 --> 00:32:22,820
ಅತ್ಯಂತ GDB ಆಜ್ಞೆಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತ ಮಾಡಬಹುದು.

386
00:32:22,820 --> 00:32:25,940
ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ಸಂತೋಷವನ್ನು ಇದು ಕೇವಲ ಒಂದು ಅಥವಾ ಕೆಲವು ಅಕ್ಷರಗಳು, ಗೆ.

387
00:32:25,940 --> 00:32:30,980
ನೀವು R ಟೈಪ್ ಮತ್ತು ಏನಾಗುತ್ತದೆ, ನಮೂದಿಸಿ ಹಿಟ್ ಆದ್ದರಿಂದ, ಸಾದ್?

388
00:32:30,980 --> 00:32:39,390
[ಸಾದ್] ನಾನು SIGSEGV, ವಿಭಜನೆ ತಪ್ಪು, ತದನಂತರ ಈ gobbledygook ದೊರೆತಿದೆ.

389
00:32:39,390 --> 00:32:43,650
>> ಹೌದು.

390
00:32:43,650 --> 00:32:47,990
ಇದೀಗ ತೆರೆಯ ಮೇಲೆ ಕಾಣಿಸುವ ಮಾಡುತ್ತಿರುವಂತೆ, ಮತ್ತು ಸಾದ್ ಹೇಳಿದರು ಹಾಗೆ,

391
00:32:47,990 --> 00:32:53,430
ನಾವು ರನ್ ಅಥವಾ R ಟೈಪಿಸಿ ಮತ್ತು Enter ಹೊಡೆದಾಗ, ನಾವು ಅದೇ seg ತಪ್ಪು ಪಡೆಯಲು.

392
00:32:53,430 --> 00:32:55,830
ಆದ್ದರಿಂದ GDB ಬಳಸಿಕೊಂಡು ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ.

393
00:32:55,830 --> 00:32:59,120
ಆದರೆ ನಮಗೆ ಕೆಲವು gobbledygook ನೀಡುತ್ತದೆ, ಮತ್ತು ಇದು ತಿರುಗಿದರೆ ಈ gobbledygook

394
00:32:59,120 --> 00:33:03,080
ಇದು ನಡೆಯುತ್ತಿದೆ ಅಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ನಮಗೆ ಹೇಳುತ್ತದೆ.

395
00:33:03,080 --> 00:33:10,680
ಈ ಸ್ವಲ್ಪ ಪಾರ್ಸ್ ಮಾಡಲು, ಈ ಮೊದಲ ಬಿಟ್ ಎಲ್ಲವೂ ತಪ್ಪು ವಿಶೇಷವೇನು ಇದರಲ್ಲಿ ಕಾರ್ಯ.

396
00:33:10,680 --> 00:33:20,270
ಈ __ strcmp_sse4_2, ಮತ್ತು ಅದನ್ನು ಈ ಕಡತದಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ ಎಂದು ನಮಗೆ ಹೇಳುತ್ತದೆ

397
00:33:20,270 --> 00:33:29,450
sysdeps/i386 ಕರೆಯಲಾಗುತ್ತದೆ, ಈ, ಮತ್ತೆ, ಒಂದು ಅವ್ಯವಸ್ಥೆ ರೀತಿಯ - ಆದರೆ ಲೈನ್ 254.

398
00:33:29,450 --> 00:33:31,670
ಆ ಪಾರ್ಸ್ ಮಾಡಲು ರೀತಿಯ ಕಷ್ಟ. ನೀವು ಈ ಮೂಲವಸ್ತುವನ್ನು ನೋಡುತ್ತಿದ್ದಂತೆಯೇ ಸಾಮಾನ್ಯವಾಗಿ

399
00:33:31,670 --> 00:33:38,770
ಇದು ವ್ಯವಸ್ಥೆಯ ಲೈಬ್ರರಿಗಳನ್ನು ಒಂದು ದೋಷವ್ಯವಸ್ಥೆಯು seg ಎಂದು ಅರ್ಥ.

400
00:33:38,770 --> 00:33:43,220
ಆದ್ದರಿಂದ ಏನಾದರೂ strcmp ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನೀವು ಹುಡುಗರಿಗೆ ಮೊದಲು strcmp ನೋಡಿದ್ದೇವೆ.

401
00:33:43,220 --> 00:33:52,730
ತುಂಬಾ ಕ್ರೇಜಿ, ಆದರೆ ಈ strcmp strcmp ಸಮಸ್ಯೆ ಇಲ್ಲ ಎಂದು ಮುರಿದು ಅಥವಾ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಅರ್ಥವೇನು?

402
00:33:52,730 --> 00:33:57,110
ನೀವು, ಅಲೆಕ್ಸಾಂಡರ್ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

403
00:33:57,110 --> 00:34:04,890
[ಅಲೆಕ್ಸಾಂಡರ್] ಎಂಬುದು - 254 ರೇಖೆ? ಮತ್ತು - ಅಲ್ಲ ಅವಳಿ, ಆದರೆ ತಮ್ಮ CEILINGS ಅಲ್ಲ,

404
00:34:04,890 --> 00:34:10,590
ತದನಂತರ ಪ್ರತಿ ಕ್ರಿಯೆಯ ಇನ್ನೊಂದು ಭಾಷೆ ಇಲ್ಲ. - ಆ ಕಾರ್ಯದಲ್ಲಿ 254, ಅಥವಾ?

405
00:34:10,590 --> 00:34:21,460
>> ಇದು ಸಾಲಿನ 254 ನ. ಈ. ರು ಕಡತದಲ್ಲಿ ತೋರುತ್ತಿದೆ, ಬಹುಶಃ ಅದು ಅಸೆಂಬ್ಲಿ ಕೋಡ್ ಆದ್ದರಿಂದ.

406
00:34:21,460 --> 00:34:25,949
>> ಆದರೆ, ನಾನು, ನಾವು seg ತಪ್ಪು ನೆತ್ತಿಗೇರಿದೆ ನೀವು ಏಕೆಂದರೆ ಹೆಚ್ಚು ಗಹನವಾದ ವಿಷಯ, ಊಹಿಸಿದರು

407
00:34:25,949 --> 00:34:29,960
ಮತ್ತು strcmp ಕಾರ್ಯವನ್ನು ಬರುವ ಕಾಣುತ್ತಿಲ್ಲ,

408
00:34:29,960 --> 00:34:38,030
ಈ ಸೂಚಿಸುತ್ತದೆ ಇಲ್ಲ, ನಂತರ, ಆ strcmp ಮುರಿದಿದೆ?

409
00:34:38,030 --> 00:34:42,290
ಇದು ಆಶಾದಾಯಕ, ಮಾಡಬಾರದು. ನೀವು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಅವಕಾಶವಿದೆ ಕೇವಲ

410
00:34:42,290 --> 00:34:49,480
ವ್ಯವಸ್ಥೆಯ ಕ್ರಿಯೆಗಳನ್ನು ಒಂದು, ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಕೇವಲ ಸರಿಯಾಗಿ ಇದನ್ನು ಮಾಡಿಲ್ಲ ಎಂದರ್ಥ.

411
00:34:49,480 --> 00:34:52,440
ನಿಜವಾಗಿ ಇಂದಿನ ವಿಶೇಷವೇನು ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ತ್ವರಿತ ವಿಷಯ

412
00:34:52,440 --> 00:34:55,500
ನೀವು seg ತಪ್ಪು ನೋಡಿ ಬಂದಾಗಲೆಲ್ಲಾ ಇಂತಹ ಕ್ರೇಜಿ ಏನೋ, ನೋಡಿದಾಗ,

413
00:34:55,500 --> 00:34:59,800
ನೀವು ಹೆಚ್ಚು ಕೇವಲ ಮುಖ್ಯ ಬಳಸಿಕೊಂಡು ಎಂದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ವಿಶೇಷವಾಗಿ

414
00:34:59,800 --> 00:35:03,570
ಒಂದು backtrace ಬಳಸುವುದು.

415
00:35:03,570 --> 00:35:13,080
ನಾನು ಪೂರ್ಣ backtrace ಪದ ವಿರುದ್ಧವಾಗಿ, BT ಬರೆದು backtrace ಮೊಟಕಾದ.

416
00:35:13,080 --> 00:35:16,510
ಆದರೆ ಷಾರ್ಲೆಟ್, ನೀವು BT ಟೈಪ್ ಮತ್ತು ಹಿಟ್ ನಮೂದಿಸಿ ಏನಾಗುತ್ತದೆ?

417
00:35:16,510 --> 00:35:23,200
[ಷಾರ್ಲೆಟ್] ಇದು ನನ್ನ ಎರಡು ರೇಖೆಗಳು, ಲೈನ್ 0 ಮತ್ತು ಲೈನ್ 1 ತೋರಿಸುತ್ತದೆ.

418
00:35:23,200 --> 00:35:26,150
>> ಹೌದು. ಆದ್ದರಿಂದ ಲೈನ್ 0 ಮತ್ತು ಲೈನ್ 1.

419
00:35:26,150 --> 00:35:34,560
ಈ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ ನಾಟಕದಲ್ಲಿ ಪ್ರಸ್ತುತ ಎಂದು ನಿಜವಾದ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಇವೆ.

420
00:35:34,560 --> 00:35:42,230
ತುತ್ತತುದಿಯ ಫ್ರೇಮ್, ಫ್ರೇಮ್ 0 ಆರಂಭಿಸಿ, ಮತ್ತು ಫ್ರೇಮ್ 1 ಇದು, ಅತ್ಯಂತ ಕೆಳ ಹೋಗಿ.

421
00:35:42,230 --> 00:35:45,140
ನಮ್ಮ ಉನ್ನತವಾದ ಫ್ರೇಮ್ strcmp ಚೌಕಟ್ಟನ್ನು ಹೊಂದಿದೆ.

422
00:35:45,140 --> 00:35:50,080
ನೀವು ಈ ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಜೊತೆ ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಮಾಡುತ್ತಿಲ್ಲ ಎಂದು ಸಮಸ್ಯೆಗೆ ರೀತಿಯ ನಗರದ

423
00:35:50,080 --> 00:35:54,890
ಅಲ್ಲಿ ನಾವು, ಮುಖ್ಯ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನ ಮೇಲೆ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಸ್ವ್ಯಾಪ್ ಮಾಡಿದ

424
00:35:54,890 --> 00:35:59,700
ಮತ್ತು ನಾವು ಸ್ವಾಪ್ ಮುಖ್ಯ ಬಳಸಿಕೊಂಡು ಎಂದು ಚರಾಂಕಗಳ ಮೇಲೆ ಬಳಸಿ ಎಂದು ಚರಾಂಕಗಳ ಹೊಂದಿತ್ತು.

425
00:35:59,700 --> 00:36:08,440
ಇಲ್ಲಿ ನಮ್ಮ ಕ್ರ್ಯಾಶ್ ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ಎಂದು ಇದು ನಮ್ಮ strcmp ಫಂಕ್ಷನ್, ನಡೆದ

426
00:36:08,440 --> 00:36:14,370
ಮತ್ತು backtrace ನಮಗೆ ವಿಷಯಗಳನ್ನು ವಿಫಲವಾದ ಕಾರ್ಯಗಳನ್ನು ಕೇವಲ ನೀಡುವ ಇದೆ,

427
00:36:14,370 --> 00:36:16,440
ಎಲ್ಲವುಗಳಿಂದ ಎಂಬ ಅಲ್ಲಿ ಸಹ ನಮಗೆ ಹೇಳುವ ನ.

428
00:36:16,440 --> 00:36:18,830
ನಾನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮೇಲೆ ಸ್ಕ್ರಾಲ್, ಆದ್ದರಿಂದ

429
00:36:18,830 --> 00:36:26,110
ನಾವು ಹೌದು, ನಾವು ಈ strcmp-sse4.s ಕಡತದ ಸಾಲು 254 ಮೇಲೆ ಎಂದು ನೋಡಬಹುದು.

430
00:36:26,110 --> 00:36:32,540
ಆದರೆ ಕರೆ buggy1.c, ಲೈನ್ 6 ನಲ್ಲಿ ಮಾಡಲಾಯಿತು.

431
00:36:32,540 --> 00:36:35,960
ನಾವು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಡೆಯುತ್ತಿರುವುದರ ನೋಡಿ ಹೋಗಿ ಆಗಿದೆ - ನಾವು ಮಾಡಬಹುದು ಅರ್ಥ, ಆದ್ದರಿಂದ

432
00:36:35,960 --> 00:36:39,930
buggy1.c, ಲೈನ್ 6.

433
00:36:39,930 --> 00:36:43,780
ಮತ್ತೆ, ಈ ಮಾಡಲು ಒಂದೆರಡು ಮಾರ್ಗಗಳಿವೆ. ಒಂದು GDB ಹೊರಗೆ ನಿರ್ಗಮಿಸಲು ಆಗಿದೆ

434
00:36:43,780 --> 00:36:49,460
ಅಥವಾ ನಿಮ್ಮ ಕೋಡ್ ಇನ್ನೊಂದು ವಿಂಡೋದಲ್ಲಿ ಮತ್ತು ಅಡ್ಡ ಉಲ್ಲೇಖಿಸುತ್ತದೆ ತೆರೆದುಕೊಂಡಿವೆ.

435
00:36:49,460 --> 00:36:54,740
ಈಗ ನೀವು ಆಫೀಸ್ ಅವರ್ಸ್ ಇಂತಹ ಏಕೆಂದರೆ, ಮತ್ತು ಸ್ವತಃ, ಬಹಳ HANDY ಆಗಿದೆ

436
00:36:54,740 --> 00:36:57,220
ಮತ್ತು ನೀವು seg ತಪ್ಪು ಪಡೆದಿರುವಿರಿ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಬ್ರೇಕಿಂಗ್ ಅಲ್ಲಿ ನಿಮ್ಮ TF, ಚಕಿತಗೊಳಿಸುತ್ತದೆ ವಿಶೇಷವೇನು

437
00:36:57,220 --> 00:36:59,710
ನೀವು ಕೇವಲ "ಓಹ್, ಲೈನ್ 6, ಹೇಳಬಹುದು. ನಾನು, ಇಂದಿನ ವಿಶೇಷವೇನು ಏನು ಗೊತ್ತಿಲ್ಲ

438
00:36:59,710 --> 00:37:03,670
ಆದರೆ ಲೈನ್ 6 ಬಗ್ಗೆ ಏನೋ ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಮುರಿಯಲು ಕಾರಣವಾಯಿತು ಇದೆ. "

439
00:37:03,670 --> 00:37:10,430
ಇದನ್ನು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ನೀವು GDB ಪಟ್ಟಿ ಎಂಬ ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಹೊಂದಿದೆ.

440
00:37:10,430 --> 00:37:13,650
ನೀವು L ಇದನ್ನು ಚಿಕ್ಕದಾದ ಮಾಡಬಹುದು.

441
00:37:13,650 --> 00:37:18,910
ನಾವು L ಹಿಟ್ ಆದ್ದರಿಂದ, ನಾವು ಏನು ಸಿಗುತ್ತದೆ?

442
00:37:18,910 --> 00:37:21,160
ನಾವು ವಿಲಕ್ಷಣ ಸ್ಟಫ್ ಒಂದು ಇಡೀ ಗುಂಪೇ ಪಡೆಯಿರಿ.

443
00:37:21,160 --> 00:37:26,030
ಈ ನಿಜವಾದ ಅಸೆಂಬ್ಲಿ ಸಂಕೇತಗಳನ್ನು

444
00:37:26,030 --> 00:37:29,860
ಆ strcmp_sse4_2 ರಲ್ಲಿ ಆಗಿದೆ.

445
00:37:29,860 --> 00:37:32,440
ಈ, ಮೋಜಿನ ರೀತಿಯ ಕಾಣುತ್ತದೆ

446
00:37:32,440 --> 00:37:36,520
ಮತ್ತು ನಾವು ಈ ಬರುತ್ತಿದೆ ಕಾರಣ, ಇದೀಗ ಏಕೆಂದರೆ

447
00:37:36,520 --> 00:37:40,160
GDB ಫ್ರೇಮ್ 0 ನಮಗೆ ಹೊಂದಿದೆ.

448
00:37:40,160 --> 00:37:43,070
>> ಆದ್ದರಿಂದ ಯಾವುದೇ ನಾವು ನೋಡಲು ಅಸ್ಥಿರ ನಲ್ಲಿ, ನಾವು ಮೂಲ ಕೋಡ್ ನೋಡಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ,

449
00:37:43,070 --> 00:37:50,530
ನಾವು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಸಂಬಂಧಿಸಿದೆ ನಾವು ಸೈನ್ ಪ್ರಸ್ತುತ ಎಂಬುದನ್ನು ಮೂಲ ಕೋಡ್ ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ

450
00:37:50,530 --> 00:37:53,200
ಆದ್ದರಿಂದ ಅರ್ಥಪೂರ್ಣ ಏನು ಪಡೆಯುವ ಸಲುವಾಗಿ, ನಾವು ಹೊಂದಿಲ್ಲ

451
00:37:53,200 --> 00:37:57,070
ಹೆಚ್ಚು ಅರ್ಥವನ್ನು ನೀಡುವ ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಸರಿಸಲು.

452
00:37:57,070 --> 00:38:00,180
ಈ ಪ್ರಕರಣದಲ್ಲಿ, ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್, ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥ ಎಂದು

453
00:38:00,180 --> 00:38:02,680
ಎಂದು ವಾಸ್ತವವಾಗಿ ನಾವು ಬರೆದ ಕೋಡ್ ಕಾರಣ.

454
00:38:02,680 --> 00:38:05,330
ಮಾಡಿರುವುದಿಲ್ಲ strcmp ಕೋಡ್.

455
00:38:05,330 --> 00:38:08,650
ನಾವು ಎರಡು ಕಾರಣ ನೀವು, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಫ್ರೇಮ್ಗಳ ನಡುವೆ ಚಲಿಸುವ ರೀತಿಯಲ್ಲಿ,

456
00:38:08,650 --> 00:38:10,430
ನಾವು, 0 ಮತ್ತು 1 ಹೊಂದಿವೆ

457
00:38:10,430 --> 00:38:13,650
ನೀವು ಅಪ್ ಮತ್ತು ಡೌನ್ ಆಜ್ಞೆಗಳನ್ನು ಹೊಂದಿರುವ ಹಾಗೆ.

458
00:38:13,650 --> 00:38:18,480
ನಾನು ಒಂದು ಚೌಕಟ್ಟು, ಇರುತ್ತದೆ ವೇಳೆ

459
00:38:18,480 --> 00:38:21,770
ಈಗ ನಾನು ಮುಖ್ಯ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಆಗಿದ್ದೇನೆ.

460
00:38:21,770 --> 00:38:24,330
ನಾನು, ನಾನು ಅಲ್ಲಿ ಮರಳಲು ಕೆಳಗೆ ಚಲಿಸಬಹುದು

461
00:38:24,330 --> 00:38:32,830
ಮತ್ತೆ ಹೋಗಿ, ಮತ್ತೆ ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು ಮತ್ತೆ ಹೋಗಿ.

462
00:38:32,830 --> 00:38:39,750
ನೀವು ಎಂದಾದರೂ GDB ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ನೀವು ಕುಸಿತದ ಪಡೆಯಲು, ನೀವು, backtrace ಪಡೆಯಿರಿ

463
00:38:39,750 --> 00:38:42,380
ಮತ್ತು ನೀವು ನೀವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ತಿಳಿದಿಲ್ಲ ಎಂದು ಕೆಲವು ಕಡತದಲ್ಲಿ ಎಂದು ನೋಡಿ.

464
00:38:42,380 --> 00:38:45,460
ನೀವು ಪಟ್ಟಿಯಿಂದ ಪ್ರಯತ್ನಿಸಿ, ಕೋಡ್, ನಿಮಗೆ ಪರಿಚಯವಿರುವ ತೋರುತ್ತಿಲ್ಲ

465
00:38:45,460 --> 00:38:48,150
ನಿಮ್ಮ ಚೌಕಟ್ಟುಗಳು ನೋಡೋಣ ಮತ್ತು ನೀವು ಅಲ್ಲಿ ಔಟ್ ಲೆಕ್ಕಾಚಾರ.

466
00:38:48,150 --> 00:38:51,010
ನೀವು ತಪ್ಪು ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಬಹುಶಃ ಆರ್.

467
00:38:51,010 --> 00:38:58,760
ಅಥವಾ ಕನಿಷ್ಠ ನೀವು ನಿಜವಾಗಿಯೂ ದೋಷ ಹೊಂದಿರುತ್ತದೆ ಎಂಬುದನ್ನು ಒಂದು ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಆರ್.

468
00:38:58,760 --> 00:39:03,110
ಈಗ ನಾವು ಸೂಕ್ತ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಕಾರಣ, ನಾವು, ಮುಖ್ಯ ಮಾಡುತ್ತೇವೆ

469
00:39:03,110 --> 00:39:08,100
ಈಗ ನಾವು ರೀತಿಯಾಗಿತ್ತು ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ ಪಟ್ಟಿಯನ್ನು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

470
00:39:08,100 --> 00:39:13,590
ಮತ್ತು ನೀವು ನೋಡಬಹುದು; ಅದು ಇಲ್ಲಿಯೇ ನಮಗೆ ಅದು ಪ್ರಕಟಿಸಿತು.

471
00:39:13,590 --> 00:39:19,470
ಆದರೆ ಒಂದೇ ಪಟ್ಟಿ ಹೊಡೆಯಬಹುದು, ಮತ್ತು ಪಟ್ಟಿಯು ಈ ಸಂತೋಷವನ್ನು ಪ್ರಿಂಟ್ ಔಟ್ ನೀಡುತ್ತದೆ

472
00:39:19,470 --> 00:39:23,920
ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ ಎಂದು ನಿಜವಾದ ಮೂಲ ಕೋಡ್.

473
00:39:23,920 --> 00:39:26,420
>> ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ಲೈನ್ 6 ನೋಡಬಹುದು.

474
00:39:26,420 --> 00:39:29,330
ನಾವು ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು.

475
00:39:29,330 --> 00:39:31,250
ನಾವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆ ಮಾಡುವ ಮಾಡುತ್ತಿರುವಂತೆ ಮತ್ತು ಕಾಣುತ್ತದೆ

476
00:39:31,250 --> 00:39:41,050
ಸ್ಟ್ರಿಂಗ್ "CS50 ಕಲ್ಲುಗಳು" ಮತ್ತು argv ನಡುವೆ [1].

477
00:39:41,050 --> 00:39:45,700
ಈ ಬಗ್ಗೆ ಏನಾದರೂ ಅಸಾಮಾನ್ಯ ಮಾಡಲಾಯಿತು.

478
00:39:45,700 --> 00:39:54,120
ಮಿಸ್ಸಿ ಆದ್ದರಿಂದ, ನೀವು ಇಲ್ಲಿ ಇಂದಿನ ಇರಬಹುದು ಯಾವುದೇ ಆಲೋಚನೆಗಳು ಹೊಂದಿಲ್ಲ?

479
00:39:54,120 --> 00:39:59,400
[ಮಿಸ್ಸಿ] ಇದು ಅಸಾಧಾರಣ ಎಂಬುದನ್ನು ನನಗೆ ಗೊತ್ತಿಲ್ಲ. ಇದು ಅಸಾಧಾರಣ ಎಂಬುದನ್ನು >> ನೀವು ಗೊತ್ತಿಲ್ಲ?

480
00:39:59,400 --> 00:40:02,700
ಜಿಮ್ಮಿ, ಯಾವುದೇ ಆಲೋಚನೆಗಳು?

481
00:40:02,700 --> 00:40:06,240
[ಜಿಮ್ಮಿ] ನಾನು ಸಂಪೂರ್ಣವಾಗಿ ಖಚಿತವಿಲ್ಲ, ಆದರೆ ಸ್ಟ್ರಿಂಗ್ ಬಳಸಲಾಗುತ್ತದೆ ಕಳೆದ ಬಾರಿಗೆ ಹೋಲಿಸಿದರೆ,

482
00:40:06,240 --> 00:40:10,260
ಅಥವಾ strcmp, ನಾವು ಅಡಿಯಲ್ಲಿ ಮೂರು ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಂತಹ ಹೊಂದಿತ್ತು.

483
00:40:10,260 --> 00:40:12,800
ನಾವು == ಹೊಂದಿಲ್ಲ, ನಾನು ಮೊದಲ ಸಾಲಿನಲ್ಲಿ, ಯೋಚಿಸುವುದಿಲ್ಲ.

484
00:40:12,800 --> 00:40:16,700
ಬದಲಿಗೆ ಇದು, ಮೂರು ಪ್ರತ್ಯೇಕಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಒಂದು == 0 ಆಗಿತ್ತು

485
00:40:16,700 --> 00:40:19,910
ಒಂದು <0, ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ಒಂದು> 0.

486
00:40:19,910 --> 00:40:22,590
ಹಾಗೆ ಆದ್ದರಿಂದ ಬಹುಶಃ ಏನೋ? >> ಹೌದು. ಆದ್ದರಿಂದ ಈ ಸಮಸ್ಯೆ ಇಲ್ಲ

487
00:40:22,590 --> 00:40:27,200
ಆಫ್ ನಾವು ಸರಿಯಾಗಿ ಹೋಲಿಕೆ ಮಾಡುತ್ತಿದ್ದಾರೆ?

488
00:40:27,200 --> 00:40:31,660
ಸ್ಟೆಲ್ಲಾ? ಯಾವುದೇ ಆಲೋಚನೆಗಳು?

489
00:40:31,660 --> 00:40:38,110
[ಸ್ಟೆಲ್ಲಾ] ನಾನು ಖಚಿತವಿಲ್ಲ. >> ಖಚಿತವಾಗಿಲ್ಲ. ಡೇನಿಯಲ್? ಆಲೋಚನೆಗಳು? ಸರಿ.

490
00:40:38,110 --> 00:40:44,770
ನಾವು ಕಾರ್ಯಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಿದ ಏನು ಇಲ್ಲಿಯೇ ನಡೆಯುತ್ತಿದೆ ಹೊಂದಿದೆ ತಿರುಗಿದರೆ

491
00:40:44,770 --> 00:40:48,370
ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಕಾರ್ಯಕ್ರಮ, ಡೇನಿಯಲ್, ನಡೆಸುತ್ತಿದ್ದರು ಮತ್ತು ನಾವು, seg ತಪ್ಪು ದೊರೆತಿದೆ

492
00:40:48,370 --> 00:40:50,800
ನೀವು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನೀಡಿಲ್ಲ?

493
00:40:50,800 --> 00:40:58,420
[ಡೇನಿಯಲ್] ನಂ >> ನಂ ಆ ಸಂದರ್ಭದಲ್ಲಿ, argv ಮೌಲ್ಯವನ್ನು ಏನು [1]?

494
00:40:58,420 --> 00:41:00,920
>> ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಇಲ್ಲ. >> ರೈಟ್.

495
00:41:00,920 --> 00:41:06,120
ಅಲ್ಲದೆ, ಯಾವುದೇ ಸರಿಯಾದ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯ ಇರುತ್ತದೆ.

496
00:41:06,120 --> 00:41:10,780
ಆದರೆ ಕೆಲವು ಮೌಲ್ಯ ಇರುತ್ತದೆ. ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಗಳಿಸುವ ಮೌಲ್ಯವನ್ನು ಏನು?

497
00:41:10,780 --> 00:41:15,130
>> ಒಂದು ಕಸದ ಮೌಲ್ಯ? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಯಾವುದೇ ಒಂದು ಕಸದ ಮೌಲ್ಯ ಅಥವಾ >>,

498
00:41:15,130 --> 00:41:19,930
argv ರಚನೆಯ ಕೊನೆಯಲ್ಲಿ ಯಾವಾಗಲೂ ಶೂನ್ಯ ಮೂಲಕ ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ.

499
00:41:19,930 --> 00:41:26,050
ಆದ್ದರಿಂದ ಯಾವ ವಾಸ್ತವವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಪಡೆದುಕೊಂಡಿದೆ ಶೂನ್ಯ ಇಲ್ಲ.

500
00:41:26,050 --> 00:41:30,810
ಇತರ ರೀತಿಯಲ್ಲಿ, ಬದಲಿಗೆ ಅದರ ಮೂಲಕ ಆಲೋಚನೆ ಹೆಚ್ಚು, ಈ ಪರಿಹರಿಸಲು

501
00:41:30,810 --> 00:41:33,420
ಅದನ್ನು ಮುದ್ರಿಸುವ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

502
00:41:33,420 --> 00:41:35,880
ನಾನು, GDB ಬಳಸಿಕೊಂಡು ಮಹಾನ್ ಎಂದು ಹೇಳಿಕೆಯ ಅಲ್ಲಿ ಇದು

503
00:41:35,880 --> 00:41:40,640
ನೀವು ಬಯಸುವ ನೀವು ಎಲ್ಲಾ ಅಸ್ಥಿರ ಮುದ್ರಿಸುತ್ತದೆ ಏಕೆಂದರೆ, ಎಲ್ಲಾ ಮೌಲ್ಯಗಳು

504
00:41:40,640 --> 00:41:43,230
ಈ ಕೈಮುಚ್ಚಾಟ ಪುಟ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

505
00:41:43,230 --> 00:41:48,520
ನಾನು ಪುಟ ಟೈಪ್ ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು, ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಅಥವಾ ವೇರಿಯಬಲ್ ಹೆಸರು ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸಿ

506
00:41:48,520 --> 00:41:55,320
, argc ಹೇಳುತ್ತಾರೆ, ನಾನು argc 1 ಎಂದು ನೋಡಿ.

507
00:41:55,320 --> 00:42:01,830
ನಾನು argv ಮುದ್ರಿಸುತ್ತದೆ ಬಯಸಿದರೆ [0], ನಾನು ಕೇವಲ ಹಾಗೆ ಮಾಡಬಹುದು.

508
00:42:01,830 --> 00:42:04,840
ನಾವು ನೋಡಿದ ಹಾಗೆ, argv [0] ಯಾವಾಗಲೂ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು,

509
00:42:04,840 --> 00:42:06,910
ಯಾವಾಗಲೂ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಹೆಸರು.

510
00:42:06,910 --> 00:42:09,740
ಇಲ್ಲಿ ನೀವು ಸಂಪೂರ್ಣ ಮಾರ್ಗವನ್ನು ಹೆಸರನ್ನು ನೋಡಿ.

511
00:42:09,740 --> 00:42:15,920
ನಾನು ಮುದ್ರಿಸುತ್ತದೆ argv [1] ಮತ್ತು ಏನಾಗುತ್ತದೆ ನೋಡಿ.

512
00:42:15,920 --> 00:42:20,890
>> ಇಲ್ಲಿ ನಾವು ಅತೀಂದ್ರಿಯ ಮೌಲ್ಯದ ಈ ರೀತಿಯ ದೊರೆತಿದೆ.

513
00:42:20,890 --> 00:42:23,890
ಈ 0x0 ದೊರೆತಿದೆ.

514
00:42:23,890 --> 00:42:27,850
ನಾವು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಖ್ಯೆಗಳನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಈ ಶಬ್ದವನ್ನು ಆರಂಭದಲ್ಲಿ ನೆನಪಿಡಿ?

515
00:42:27,850 --> 00:42:34,680
ಅಥವಾ ಹೆಕ್ಸ್ 50 ಪ್ರತಿನಿಧಿಸಲು ಹೇಗೆ pset 0 ಕೊನೆಯಲ್ಲಿ ಸಣ್ಣ ಪ್ರಶ್ನೆ?

516
00:42:34,680 --> 00:42:39,410
ನಾವು ಸಿಎಸ್ ರಲ್ಲಿ ಹೆಕ್ಸ್ ಸಂಖ್ಯೆಗಳನ್ನು ಬರೆಯುವ ರೀತಿಯಲ್ಲಿ, ಕೇವಲ ನಮ್ಮನ್ನು ಗೊಂದಲಕ್ಕೀಡು ಮಾಡಲು

517
00:42:39,410 --> 00:42:46,080
ಫೆಸಿಲಿಟಿ ಸಂಖ್ಯೆಯ, ನಾವು ಯಾವಾಗಲೂ 0x ಅವುಗಳನ್ನು ಪೂರ್ವಪ್ರತ್ಯಯ.

518
00:42:46,080 --> 00:42:51,420
ಆದ್ದರಿಂದ ಈ 0x ಪೂರ್ವಪ್ರತ್ಯಯ ಯಾವಾಗಲೂ ಕೇವಲ, ಒಂದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಖ್ಯೆಯಾಗಿ ಕೆಳಗಿನ ಸಂಖ್ಯೆ ವ್ಯಾಖ್ಯಾನಿಸುವ ಅರ್ಥ

519
00:42:51,420 --> 00:42:57,400
ಒಂದು ಸೆಟ್, ಒಂದು ದಶಮಾಂಶ ಸಂಖ್ಯೆ, ಒಂದು ದ್ವಿಮಾನ ಸಂಖ್ಯೆಯ.

520
00:42:57,400 --> 00:43:02,820
ಸಂಖ್ಯೆ 5-0 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಒಂದು ಮಾನ್ಯ ಸಂಖ್ಯೆಯನ್ನು ಕಾರಣ.

521
00:43:02,820 --> 00:43:06,240
ಮತ್ತು ಫೆಸಿಲಿಟಿ, 50 ಒಂದು ಸಂಖ್ಯೆಯ.

522
00:43:06,240 --> 00:43:10,050
ಈ ನಾವು ಅಸಂದಿಗ್ಧಕರಣ ಕೇವಲ ಹೇಗೆ.

523
00:43:10,050 --> 00:43:14,860
ಹಾಗೆಯೇ 0 ದಶಮಾಂಶ ಇದು 0x0 ಸಾಧನವಾಗಿ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ 0, ಅವಳಿ 0.

524
00:43:14,860 --> 00:43:17,030
ಇದು ಕೇವಲ ಮೌಲ್ಯವನ್ನು 0 ದ.

525
00:43:17,030 --> 00:43:22,630
ಈ ಶೂನ್ಯ ನೆನಪಿಗಾಗಿ, ನಿಜವಾಗಿ ಏನು ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

526
00:43:22,630 --> 00:43:25,940
ಶೂನ್ಯ ಕೇವಲ 0 ಆಗಿದೆ.

527
00:43:25,940 --> 00:43:37,010
ಇಲ್ಲಿ, ಅಂಶ [1] ಶೂನ್ಯ ಆಗಿದೆ argv ಸಂಗ್ರಹಿಸಿಡಬೇಕು.

528
00:43:37,010 --> 00:43:45,220
ಆದ್ದರಿಂದ ನಾವು ಶೂನ್ಯ ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ "CS50 ಕಲ್ಲುಗಳು" ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಸಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ.

529
00:43:45,220 --> 00:43:48,130
ಆದ್ದರಿಂದ ಶೂನ್ಯ dereferencing, ಶೂನ್ಯ ವಿಚಾರಗಳಲ್ಲಿ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ,

530
00:43:48,130 --> 00:43:55,050
ಆ ವಿಶಿಷ್ಟವಾಗಿ ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಅಥವಾ ಸಂಭವಿಸಿರುವ ಇತರ ಕೆಟ್ಟ ವಿಷಯಗಳನ್ನು ಕೆಲವು ರೀತಿಯ ಕಾರಣವಾಗಬಹುದು ಹೋಗುವ.

531
00:43:55,050 --> 00:43:59,350
ಮತ್ತು strcmp ಪರೀಕ್ಷಿಸಿ ಎಂಬುದನ್ನು ತಿರುಗಿದರೆ

532
00:43:59,350 --> 00:44:04,340
ನೀವು ಶೂನ್ಯ ಎಂದು ಒಂದು ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಅಥವಾ.

533
00:44:04,340 --> 00:44:06,370
ಬದಲಿಗೆ, ಇದು ಕೇವಲ ಮುಂದೆ ಹೋಗುತ್ತದೆ, ಅದರ ವಿಷಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ

534
00:44:06,370 --> 00:44:14,640
ಇದು ದೋಷಗಳನ್ನು seg ವೇಳೆ ಮತ್ತು ಅದು ದೋಷಗಳನ್ನು seg, ಮತ್ತು ಅದು ನಿಮ್ಮ ಸಮಸ್ಯೆ. ನೀವು ಅದನ್ನು ಸರಿಪಡಿಸಿ ಹೋಗಬೇಕಾಗುತ್ತದೆ.

535
00:44:14,640 --> 00:44:19,730
ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಬಗೆಹರಿಸಲು ಹೇಗೆ ಇರಬಹುದು? ಷಾರ್ಲೆಟ್?

536
00:44:19,730 --> 00:44:23,540
[ಷಾರ್ಲೆಟ್] ನೀವು ಬಳಸಿ ಪರೀಕ್ಷಿಸಬಹುದು.

537
00:44:23,540 --> 00:44:32,240
ಹಾಗಾಗಿ argv [1] ಶೂನ್ಯ ಆಗಿದೆ, == 0, ನಂತರ 1 ಮರಳಿ, ಅಥವಾ ಏನಾದರೂ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ].

538
00:44:32,240 --> 00:44:34,590
>> ಹೌದು. ಆದ್ದರಿಂದ, ನಾವು ನೋಡಲು ಪರಿಶೀಲಿಸಬಹುದು ಎಂದು, ಅದನ್ನು ಒಂದು ಉತ್ತಮ ವಿಧಾನ

539
00:44:34,590 --> 00:44:39,230
ನಾವು strcmp ಹಾದುಹೋದಾಗ ಬಗ್ಗೆ ನೀವು ಮೌಲ್ಯವನ್ನು, argv [1], ಇದು ಶೂನ್ಯ ಇದೆ?

540
00:44:39,230 --> 00:44:45,830
ಇದು ಶೂನ್ಯ ವೇಳೆ, ನಂತರ ನಾವು, ಸ್ಥಗಿತಗೊಳಿಸು ಸರಿ ಹೇಳಬಹುದು.

541
00:44:45,830 --> 00:44:49,450
>> ಇದನ್ನು ಮಾಡಲು ಒಂದು ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ argc ಮೌಲ್ಯವನ್ನು ಬಳಸುವುದು.

542
00:44:49,450 --> 00:44:52,040
ನೀವು ಮುಖ್ಯ ಆರಂಭದಲ್ಲಿ ಇಲ್ಲಿಯೇ ನೋಡಬಹುದು

543
00:44:52,040 --> 00:44:58,040
ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸುವಾಗ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡುವ ಮೊದಲ ಟೆಸ್ಟ್ ಕೈಬಿಡಲಾಗಿದೆ

544
00:44:58,040 --> 00:45:05,240
ಇದು ನಮ್ಮ argc ಮೌಲ್ಯವನ್ನು ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂಬುದನ್ನು ಅಥವಾ ಪರೀಕ್ಷಿಸಲು ಹೊಂದಿದೆ.

545
00:45:05,240 --> 00:45:10,290
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು, ಕನಿಷ್ಠ ಎರಡು ವಾದಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಿರುವುದಾಗಿ ನೀವು

546
00:45:10,290 --> 00:45:13,660
ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ಮತ್ತು ಇತರ ಒಂದು.

547
00:45:13,660 --> 00:45:17,140
ನಾವು ಇಲ್ಲಿಯೇ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಬಳಸಲು ಬಗ್ಗೆ ಇರುವ ಕಾರಣ.

548
00:45:17,140 --> 00:45:21,350
ಆದ್ದರಿಂದ ನಮ್ಮ strcmp ಕರೆ ಮೊದಲು ಮೊದಲು ಪರೀಕ್ಷೆಯ ವಿಧದ ಹೊಂದಿರುವ

549
00:45:21,350 --> 00:45:37,390
argv ಕನಿಷ್ಠ 2 ಅಥವಾ ಇಲ್ಲವೋ ಎಂಬುದನ್ನು ಆ ಪರೀಕ್ಷೆಗಳು ಸಹ ವಿಷಯ ರೀತಿಯಲ್ಲಿ ಮಾಡಬೇಕಾಗುವುದು.

550
00:45:37,390 --> 00:45:40,620
ಮತ್ತೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಕಾರ್ಯ ನಾವು ನೋಡಬಹುದು.

551
00:45:40,620 --> 00:45:45,610
ನೀವು ಯಾವಾಗಲೂ ನಿಜವಾಗಿ ಸಂತೋಷವನ್ನು ಇದು GDB, ಒಳಗೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭಿಸುತ್ತವೆ.

552
00:45:45,610 --> 00:45:49,310
, ನೀವು ಚಲಾಯಿಸಬಹುದು, ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ರಲ್ಲಿ ಹಾದುಹೋದಾಗ

553
00:45:49,310 --> 00:45:53,060
ನೀವು GDB ಬೂಟ್ ಮಾಡುವಾಗ, ನೀವು ಚಲಾಯಿಸಲು ಕರೆ ಮಾಡಿದಾಗ ಅವುಗಳನ್ನು ಸಫಲವಾಗಲಿಲ್ಲ.

554
00:45:53,060 --> 00:45:57,120
ಈ ರೀತಿಯಲ್ಲಿ ನೀವು ವಿವಿಧ ವಾದಗಳು ಪ್ರತಿ ಬಾರಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಪ್ರಚೋದಿಸುವುದು ಇರಿಸಬಹುದು.

555
00:45:57,120 --> 00:46:08,080
ಆದ್ದರಿಂದ ಔಟ್, ಅಥವಾ ಮತ್ತೆ, ನಾನು R ಟೈಪ್ ಮಾಡಬಹುದು, ಮತ್ತು ನಾವು ಟೈಪ್ ಏನು "ಹಲೋ" ಏನಾಗುತ್ತದೆ ನೋಡೋಣ ನ.

556
00:46:08,080 --> 00:46:11,140
ನೀವು ಮತ್ತೆ ಆರಂಭದಿಂದಲೂ ಆರಂಭಿಸಲು ನೀವು ಯಾವಾಗಲೂ ನೀವು ಕೇಳುತ್ತೇವೆ.

557
00:46:11,140 --> 00:46:17,490
ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ಮತ್ತೆ ಆರಂಭದಿಂದಲೂ ಆರಂಭಿಸಲು ಬಯಸುತ್ತೀರಿ.

558
00:46:17,490 --> 00:46:25,010
ಈ ಹಂತದಲ್ಲಿ, ಅದು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಇದು ಮತ್ತೊಮ್ಮೆ, ಇದು ತೋರಿಸುತ್ತದೆ

559
00:46:25,010 --> 00:46:28,920
ನಾವು ವಾದ ನಿನ್ನ ಜೊತೆ, buggy1 ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ ಎಂದು ಪ್ರೋಗ್ರಾಂ,

560
00:46:28,920 --> 00:46:32,720
ಮತ್ತು ಇದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ ಇದು ದುಃಖ ಮುಖ "ನೀವು, ಡಿ ಪಡೆಯಿರಿ" ಹೇಳುತ್ತಾರೆ.

561
00:46:32,720 --> 00:46:37,610
ಆದರೆ ತಪ್ಪು seg ಮಾಡಲಿಲ್ಲ. ಆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮಿಸಿದೆ ಹೇಳಿದರು.

562
00:46:37,610 --> 00:46:39,900
ಆದ್ದರಿಂದ ಒಳ್ಳೆಯ ಕಾಣುತ್ತದೆ.

563
00:46:39,900 --> 00:46:43,050
ಯಾವುದೇ seg ತಪ್ಪು, ನಾವು, ಈ ಹಿಂದೆ ಮಾಡಿದ

564
00:46:43,050 --> 00:46:48,190
ಎಂದು ವಾಸ್ತವವಾಗಿ ನಾವು ಪಡೆಯಲು ಎಂದು seg ತಪ್ಪು ದೋಷ ಹಾಗೆ ಆದ್ದರಿಂದ ಕಾಣುತ್ತದೆ.

565
00:46:48,190 --> 00:46:51,540
ದುರದೃಷ್ಟವಶಾತ್, ನಾವು ಡಿ ಬರುತ್ತಿದೆ ಎಂದು ನಮಗೆ ಹೇಳುತ್ತದೆ

566
00:46:51,540 --> 00:46:54,090
>> ನಾವು ಹಿಂದಿರುಗಿ ಹೋಗಿ ಕೋಡ್ ನೋಡಲು ಹಾಗೂ ನಡೆಯುತ್ತಿರುವುದರ ನೋಡಬಹುದು

567
00:46:54,090 --> 00:46:57,980
ಏನು ಔಟ್ ಲೆಕ್ಕಾಚಾರ - ನಾವು ಡಿ ಗಿಟ್ಟಿಸಿದರು ಎಂದು ನಮಗೆ ಹೇಳುವ ಏಕೆ

568
00:46:57,980 --> 00:47:03,690
ಈ printf ನೀವು ಡಿ ದೊರೆತಿದೆ ಎಂದು ನೋಡೋಣ, ಇಲ್ಲಿ ಮಾಡಲಾಯಿತು

569
00:47:03,690 --> 00:47:08,540
ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಟೈಪ್ ನೀವು ಟೈಪ್ ಪಟ್ಟಿಯನ್ನು ಇಟ್ಟುಕೊಳ್ಳಬಹುದು ಎಂದು, ಇದು, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ಕೆಳಗೆ iterating ಇಡುತ್ತದೆ

570
00:47:08,540 --> 00:47:10,940
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮೊದಲ ಕೆಲವು ಸಾಲುಗಳನ್ನು ತೋರುವಿರಿ.

571
00:47:10,940 --> 00:47:15,450
ನಂತರ ಮುಂದಿನ ಕೆಲವು ಸಾಲುಗಳು, ಮತ್ತು ಮುಂದಿನ ಪಡೆ ಮತ್ತು ಮುಂದಿನ ಚಂಕ್ ತೋರುವಿರಿ.

572
00:47:15,450 --> 00:47:18,240
ಮತ್ತು ಅದನ್ನು ಹೋಗಲು ಪ್ರಯತ್ನಿಸುವಾಗ ವಿಲ್ ಕೀಪ್.

573
00:47:18,240 --> 00:47:21,180
ಮತ್ತು ಈಗ ನಾವು "ಸಂಖ್ಯೆ 16 ಶ್ರೇಣಿಯ ಔಟ್ ಲೈನ್." ಗೆ ಪಡೆಯುತ್ತೀರಿ

574
00:47:21,180 --> 00:47:23,940
ಅದು ಕೇವಲ 15 ಸಾಲುಗಳನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ.

575
00:47:23,940 --> 00:47:30,310
ಈ ಬಿಂದುವಿನಲ್ಲಿ ಪಡೆಯುವುದು ಮತ್ತು ನಿಮ್ಮ "ನಾನು ಏನು ಮಾಡಬೇಕು?", ಚಕಿತಗೊಳಿಸುತ್ತದೆ ವೇಳೆ ನೀವು ಸಹಾಯ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

576
00:47:30,310 --> 00:47:34,340
ಸಹಾಯ ಮತ್ತು ನಂತರ ಒಂದು ಆಜ್ಞೆಯ ಹೆಸರನ್ನು ಬಳಸಿ.

577
00:47:34,340 --> 00:47:36,460
ಮತ್ತು ನೀವು GDB ನಮಗೆ ಸ್ಟಫ್ ಎಲ್ಲಾ ಈ ರೀತಿಯ ನೀಡುತ್ತದೆ ನೋಡಿ.

578
00:47:36,460 --> 00:47:43,870
ಇದು "ಯಾವುದೇ ವಾದವನ್ನು, ಹಿಂದಿನ ಪಟ್ಟಿಯನ್ನು ನಂತರ ಅಥವಾ ಸುಮಾರು ಹತ್ತು ಹೆಚ್ಚು ಸಾಲುಗಳನ್ನು ಪಟ್ಟಿ ಹೇಳುತ್ತಾರೆ.

579
00:47:43,870 --> 00:47:47,920
ಪಟ್ಟಿ - ಮೊದಲು ಹತ್ತು ಸಾಲುಗಳನ್ನು ಪಟ್ಟಿ - "

580
00:47:47,920 --> 00:47:52,960
ಆದ್ದರಿಂದ ಪಟ್ಟಿಯಲ್ಲಿ ಮೈನಸ್ ಬಳಸಿಕೊಂಡು ಪ್ರಯತ್ನಿಸೋಣ.

581
00:47:52,960 --> 00:47:57,000
ಮತ್ತು 10 ಸಾಲುಗಳನ್ನು ಹಿಂದಿನ ಪಟ್ಟಿ; ನೀವು ಪಟ್ಟಿಯನ್ನು ಸ್ವಲ್ಪ ಸುಮಾರು ವಹಿಸುತ್ತದೆ.

582
00:47:57,000 --> 00:48:02,330
ನೀವು ಪಟ್ಟಿ, ಪಟ್ಟಿ ಮಾಡಬಹುದು - ನೀವು ಕೂಡ ಪಟ್ಟಿಯಲ್ಲಿ 8 ನಂತಹ ಪಟ್ಟಿ ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ನೀಡುತ್ತದೆ

583
00:48:02,330 --> 00:48:07,500
ಮತ್ತು ಸಾಲಿನ 8 ಸುಮಾರು 10 ಸಾಲುಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತೇವೆ.

584
00:48:07,500 --> 00:48:10,290
ನೀವು ಯಾವುದೇ ಒಂದು ಸರಳ ಮಾಡಲೇಬೇಕು ಇದೆ ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು.

585
00:48:10,290 --> 00:48:13,980
ನೀವು CS50 ಬಂಡೆಗಳಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದರೆ, "ನೀವು ಒಂದು ಎ ಪಡೆಯಲು" ಔಟ್ ತೋರಿಸುತ್ತದೆ

586
00:48:13,980 --> 00:48:16,530
ಇಲ್ಲವಾದರೆ ಅದು "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" ಔಟ್ ತೋರಿಸುತ್ತದೆ

587
00:48:16,530 --> 00:48:23,770
ದೇವರೇ ಪಟ್ಟಣ. ಎಲ್ಲಾ ಸರಿ. ಹೌದು?

588
00:48:23,770 --> 00:48:26,730
>> [ಡೇನಿಯಲ್] ಹಾಗಾಗಿ ಖೋಟ್ಗಳಿಲ್ಲದ CS50 ಬಂಡೆಗಳು ಮಾಡುವುದರಿಂದ ಪ್ರಯತ್ನಿಸಿದಾಗ,

589
00:48:26,730 --> 00:48:29,290
ಇದು "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" ಹೇಳುತ್ತಾರೆ

590
00:48:29,290 --> 00:48:32,560
ನಾನು ಕೆಲಸ ಪಡೆಯಲು ಉಲ್ಲೇಖಗಳು ಅಗತ್ಯವಿದೆ; ಏಕೆ ಎಂದು?

591
00:48:32,560 --> 00:48:38,490
>> ಹೌದು. ಅದನ್ನು ತಿರುಗಿಸುತ್ತದೆ ಸಂದರ್ಭದಲ್ಲಿ - ಈ ಇನ್ನೊಂದು ವಿನೋದ ಕಡಿಮೆ tidbit ಹೊಂದಿದೆ -

592
00:48:38,490 --> 00:48:47,900
ನಾವು ರನ್ ನೀವು ಪ್ರೊಗ್ರಾಮನ್ನು ಮತ್ತು ನಾವು CS50 ಬಂಡೆಗಳಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದಾಗ,

593
00:48:47,900 --> 00:48:50,800
ಕೇವಲ ರೀತಿಯಲ್ಲಿ, ಡೇನಿಯಲ್ ಅವರು ಹೇಳಿದರು, ಮತ್ತು ನೀವು Enter ಅನ್ನು ಒತ್ತುವ

594
00:48:50,800 --> 00:48:52,870
ಈಗಲೂ ನಾವು ಡಿ ಪಡೆಯಿರಿ ಹೇಳುತ್ತಾರೆ

595
00:48:52,870 --> 00:48:55,580
ಮತ್ತು ಪ್ರಶ್ನೆ ಏಕೆ ಇದು ಇದೆ?

596
00:48:55,580 --> 00:49:02,120
ಮತ್ತು ನಮ್ಮ ಟರ್ಮಿನಲ್ ಮತ್ತು GDB ಎರಡೂ ಈ ಎರಡು ಪ್ರತ್ಯೇಕ ವಾದಗಳನ್ನು ಪಾರ್ಸ್ ಎಂದು ತಿರುಗುತ್ತದೆ.

597
00:49:02,120 --> 00:49:04,800
ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಒಂದು ಸ್ಥಳವನ್ನು ಇಲ್ಲ ಏಕೆಂದರೆ

598
00:49:04,800 --> 00:49:08,730
ಮೊದಲ ವಾದವನ್ನು ಕೊನೆಗೊಂಡಿದೆ; ಮುಂದಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರಾರಂಭವಾಗುವುದನ್ನು.

599
00:49:08,730 --> 00:49:13,260
ಎರಡು ಇಂತಹ ಸಂಯೋಜಿಸಲು ರೀತಿಯಲ್ಲಿ, ಅಥವಾ ಕ್ಷಮಿಸಿ, ಒಂದು ವಾದವನ್ನು ಆಗಿ,

600
00:49:13,260 --> 00:49:18,510
ಉಲ್ಲೇಖಗಳು ಬಳಸುವುದು.

601
00:49:18,510 --> 00:49:29,560
ನಾವು ಉಲ್ಲೇಖಗಳು ಹೇಳಿದಂತೆ ಮತ್ತೆ ಚಾಲನೆ ಆದ್ದರಿಂದ ಈಗ, ನಾವು ಎ ಪಡೆಯಿರಿ

602
00:49:29,560 --> 00:49:38,780
ಆದ್ದರಿಂದ ಕೇವಲ ಪುನರವಲೋಕನ ಮಾಡಲು, ಯಾವುದೇ ಉಲ್ಲೇಖಗಳು, CS50 ಮತ್ತು ಬಂಡೆಗಳ ಎರಡು ಪ್ರತ್ಯೇಕ ವಾದಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಲಾಗಿದೆ.

603
00:49:38,780 --> 00:49:45,320
ಉಲ್ಲೇಖಗಳು, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದು ಚರ್ಚೆಯಂತೆ ಪಾರ್ಸ್ ನ.

604
00:49:45,320 --> 00:49:53,070
>> ನಾವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಈ ನೋಡಬಹುದು.

605
00:49:53,070 --> 00:49:54,920
ಈವರೆಗೆ ನಾವು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ನಾವು, ಮತ್ತು ಓಟದ ಮಾಡಲಾಗಿದೆ

606
00:49:54,920 --> 00:49:58,230
ಅದನ್ನು ದೋಷಗಳು ಅಥವಾ ಹಿಟ್ ದೋಷ seg ರವರೆಗೆ

607
00:49:58,230 --> 00:50:05,930
ಅಥವಾ ನಿರ್ಗಮಿಸಿದೆ ಮತ್ತು ಎಲ್ಲಾ ಸಂಪೂರ್ಣವಾಗಿ ಉತ್ತಮ ಇದುವರೆಗೂ.

608
00:50:05,930 --> 00:50:08,360
ಕೆಲವೊಮ್ಮೆ ಈ, ಅವಶ್ಯವಾಗಿ ಅತ್ಯಂತ ಸಹಾಯಕವಾಗಿದೆಯೆ ಕೆಲಸವಲ್ಲ

609
00:50:08,360 --> 00:50:11,840
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ದೋಷವು, ಆದರೆ ಇದು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ ಅಲ್ಲ.

610
00:50:11,840 --> 00:50:16,950
ನಿಮ್ಮ ನಿಲ್ಲಿಸಲು ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಹಾಗೆ ಏನು ಕಾರಣವಾಗುತ್ತದೆ ಅಲ್ಲ.

611
00:50:16,950 --> 00:50:20,730
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ ತಾತ್ಕಾಲಿಕ GDB ಪಡೆಯಲು ದಾರಿ

612
00:50:20,730 --> 00:50:23,260
ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಆಗಿದೆ.

613
00:50:23,260 --> 00:50:26,520
ನೀವು ಒಂದು ಕಾರ್ಯ ಹೆಸರಿನಲ್ಲಿ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಂದಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು

614
00:50:26,520 --> 00:50:30,770
ಅಥವಾ ನೀವು ಕೋಡ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಮಾರ್ಗದ ಮೇಲೆ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಂದಿಸಬಹುದು.

615
00:50:30,770 --> 00:50:34,450
ನೆನಪಿಡಿ ಸುಲಭ, - ಏಕೆಂದರೆ ನಾನು ಕಾರ್ಯ ಹೆಸರುಗಳಲ್ಲಿ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ನೀವು

616
00:50:34,450 --> 00:50:37,700
ಮತ್ತು ನೀವು ನಿಜವಾಗಿಯೂ ರಲ್ಲಿ ಹೋಗಿ ಸ್ವಲ್ಪ ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಬದಲಿಸಿದರೆ,

617
00:50:37,700 --> 00:50:42,020
ನಂತರ ನಿಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ವಾಸ್ತವವಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ಒಳಗೆ ಅದೇ ಸ್ಥಳದಲ್ಲಿ ಉಳಿಯಲು ಕಾಣಿಸುತ್ತದೆ.

618
00:50:42,020 --> 00:50:44,760
ಆದರೆ ನೀವು ಸಾಲಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಮತ್ತು ಸಾಲಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಬದಲಿಸಿದರೆ

619
00:50:44,760 --> 00:50:51,740
ನೀವು ಕೆಲವು ಕೋಡ್ ಸೇರಿಸಲು ಅಥವಾ ಅಳಿಸಲು ಏಕೆಂದರೆ, ನಂತರ ನಿಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಎಲ್ಲಾ ಸಂಪೂರ್ಣವಾಗಿ ಸಂಕುಚಿತಗೊಳಿಸಲ್ಪಟ್ಟಿರುವ ಮಾಡಲಾಗುತ್ತದೆ.

620
00:50:51,740 --> 00:50:58,590
ನಾನು ಸಾಮಾನ್ಯ ವಸ್ತುಗಳ ಒಂದು ಮುಖ್ಯ ಕಾರ್ಯ ಮೇಲೆ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಂದಿಸಲಾಗಿದೆ.

621
00:50:58,590 --> 00:51:05,300
ಸಾಮಾನ್ಯವಾಗಿ ನಾನು GDB ಬೂಟ್, ನಾನು ನಮೂದಿಸಿ ಹಿಟ್, ಬೌ ಮುಖ್ಯ ಟೈಪ್ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ವಿಲ್

622
00:51:05,300 --> 00:51:10,630
ಕೇವಲ ಹೇಳುತ್ತದೆ ಮುಖ್ಯ ಕಾರ್ಯದ, ", ತಕ್ಷಣ ನೀವು ಚಲಾಯಿಸುತ್ತಿರುವ ಪ್ರಾರಂಭಿಸಿ ಪ್ರೋಗ್ರಾಂ ವಿರಾಮ"

623
00:51:10,630 --> 00:51:17,960
ಆ ರೀತಿಯಲ್ಲಿ, ನಾನು ಎಂದು CS50 ಬಂಡೆಗಳು, ಹೇಳುತ್ತಾರೆ, ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಎರಡು ವಾದಗಳು

624
00:51:17,960 --> 00:51:24,830
ಮತ್ತು, ನಮೂದಿಸಿ ಹಿಟ್, ಇದು ಮುಖ್ಯ ಕಾರ್ಯ ಮಾರಿದರೆ ಅದು ಸರಿಯಾದ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ನಿಲ್ಲುತ್ತದೆ

625
00:51:24,830 --> 00:51:30,620
ಇದು strcmp ಕಾರ್ಯವನ್ನು ಮೌಲ್ಯಮಾಪನ ಬಲ ಮೊದಲು.

626
00:51:30,620 --> 00:51:34,940
>> ನಾನು ವಿರಾಮಗೊಳಿಸಲಾಗಿದೆ ಭಾವಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ, ಈಗ ನಾನು ಸುಮಾರು mucking ಮತ್ತು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಿದ ಆರಂಭಿಸಬಹುದು

627
00:51:34,940 --> 00:51:40,250
ನನ್ನ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ರವಾನಿಸಲ್ಪಡುತ್ತದೆ ವಿಭಿನ್ನ ಅಸ್ಥಿರ ಎಲ್ಲಾ.

628
00:51:40,250 --> 00:51:43,670
ಇಲ್ಲಿ ನಾನು argc ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು.

629
00:51:43,670 --> 00:51:50,030
ಅದು 3 ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳನ್ನು ಗಾಟ್ ಏಕೆಂದರೆ argc, 3 ಎಂದು ನೋಡಿ.

630
00:51:50,030 --> 00:51:54,060
ಇದು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ಪಡೆಯಿತು, ಅದು ಮೊದಲ ವಾದವನ್ನು ಮತ್ತು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅವರಲ್ಲಿದೆ.

631
00:51:54,060 --> 00:52:09,330
ನಾವು argv ನೋಡಿ ಆ ಮುದ್ರಿಸುತ್ತದೆ [0], argv [1], ಮತ್ತು argv [2].

632
00:52:09,330 --> 00:52:12,030
ಈ strcmp ಕರೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಹೋಗುವ ಏಕೆ ಈಗ ನೀವು ಕೂಡ ನೋಡಬಹುದು

633
00:52:12,030 --> 00:52:21,650
ನೀವು ಎರಡು ಪ್ರತ್ಯೇಕ ವಾಗ್ವಾದಗಳಲ್ಲಿ CS50 ಮತ್ತು ಬಂಡೆಗಳ ಬೇರೆಯಾಗುತ್ತಾರೆ ಎಂದು ನೋಡಿ ಏಕೆಂದರೆ.

634
00:52:21,650 --> 00:52:27,250
ನೀವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ ಒಮ್ಮೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ಹಂತಕ್ಕೆ ಮುಂದುವರಿಸಬಹುದು

635
00:52:27,250 --> 00:52:32,920
ರೇಖೆಯಿಂದ ಸಾಲು, ಮತ್ತೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ಆರಂಭಿಸಿದೆ ವಿರೋಧಿಸಿದರು.

636
00:52:32,920 --> 00:52:35,520
ನೀವು ಮತ್ತೆ ನಿಮ್ಮ ಆರಂಭಿಸಲು ಬಯಸುವುದಿಲ್ಲ ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಮುಂದುವರೆಸುವೆವು

637
00:52:35,520 --> 00:52:41,970
ನೀವು ಮುಂದುವರಿಸಲು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಮತ್ತು ಮುಂದುವರೆಯಲು ಕೊನೆಯ ಪ್ರೊಗ್ರಾಮನ್ನು ಕಾಣಿಸುತ್ತದೆ.

638
00:52:41,970 --> 00:52:45,010
ಅದನ್ನು ಇಲ್ಲಿ ಮಾಡಿದ ಹಾಗೆ.

639
00:52:45,010 --> 00:52:54,880
ನಾನು ಕಾರ್ಯಕ್ರಮ CS50 ಬಂಡೆಗಳು ಮರುಪ್ರಾರಂಭಿಸಿ ಆದಾಗ್ಯೂ, ಇದು, ಮತ್ತೆ ನನ್ನ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ಸ್

640
00:52:54,880 --> 00:52:59,670
ಈ ಸಮಯದಲ್ಲಿ, ನಾನು, ಕಾರ್ಯಕ್ರಮದ ಉಳಿದ ಎಲ್ಲಾ ರೀತಿ ಕೇವಲ ಹೋಗಲು ಬಯಸುವುದಿಲ್ಲ

641
00:52:59,670 --> 00:53:08,040
ನಾನು ಸಹ, n ಮೊಟಕಾದ ಮುಂದಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

642
00:53:08,040 --> 00:53:12,960
ಮತ್ತು ಈ ರೇಖೆಯಿಂದ ಪ್ರೋಗ್ರಾಮ್ ಸಾಲು ಹೆಜ್ಜೆ ಕಾಣಿಸುತ್ತದೆ.

643
00:53:12,960 --> 00:53:17,530
ವಿಷಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆದ್ದರಿಂದ ನೀವು ವಿಷಯಗಳನ್ನು ಅಪ್ಡೇಟ್ಗೊಳಿಸಲಾಗಿದೆ ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ಮಾಹಿತಿ ವ್ಯತ್ಯಾಸಗಳ ಬದಲಾವಣೆ ವೀಕ್ಷಿಸಬಹುದು.

644
00:53:17,530 --> 00:53:21,550
ಇದು ಬಹಳ ಸಂತೋಷ.

645
00:53:21,550 --> 00:53:26,570
ಇತರ ತಂಪಾದ ವಿಷಯ, ಬದಲಾಗಿ ಮತ್ತೆ ಮೇಲೆ ಮತ್ತು ಸುಮಾರು ಅದೇ ಆದೇಶ ಪುನರಾವರ್ತಿಸುವ ಹೆಚ್ಚು

646
00:53:26,570 --> 00:53:30,670
ನೀವು Enter ಅನ್ನು ಒತ್ತುವ ವೇಳೆ - ಇಲ್ಲಿ ನೀವು ನಾನು ಏನು ಬೆರಳಚ್ಚಿಸಿದ ಮಾಡಿಲ್ಲ ನೋಡಿ -

647
00:53:30,670 --> 00:53:33,780
ನಾನು ನಮೂದಿಸಿ ಹೊಡೆಯಲು ಅದನ್ನು, ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೀರಿ

648
00:53:33,780 --> 00:53:36,900
ಅಥವಾ ಹಿಂದಿನ GDB ಆಜ್ಞೆಯನ್ನು ನಾನು ಸೈನ್ ಅಳವಡಿಸಿರುವ

649
00:53:36,900 --> 00:53:56,000
ನಾನು ನಮೂದಿಸಿ ಹೊಡೆಯುವ ಇರಿಸಬಹುದು ಮತ್ತು ರೇಖೆಯಿಂದ ನನ್ನ ಕೋಡ್ ಲೈನ್ ಮೂಲಕ ಮೆಟ್ಟಿಲು ವಿಲ್ ಕೀಪ್.

650
00:53:56,000 --> 00:53:59,310
ನಾನು ವ್ಯಕ್ತಿಗಳು ಇತರ ದೋಷಯುಕ್ತ ಕಾರ್ಯಕ್ರಮಗಳು ಮತ್ತು ಪರಿಶೀಲಿಸಿ ಹೋಗಲು ಪ್ರೇರೇಪಿಸುತ್ತೇವೆ ಎಂದು.

651
00:53:59,310 --> 00:54:01,330
ನಾವು ಎಲ್ಲಾ ಇಂದು ವಿಭಾಗದಲ್ಲಿ ಮೂಲಕ ಪಡೆಯಲು ಸಮಯ ಹೊಂದಿಲ್ಲ.

652
00:54:01,330 --> 00:54:05,890
ಮೂಲ ಕೋಡ್ ಇಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಿ ರೀತಿಯ ಮಾಡಬಹುದು

653
00:54:05,890 --> 00:54:07,730
ನೀವು ನಿಜವಾಗಿಯೂ ಮಧ್ಯ ಸಿಲುಕಿಕೊಂಡರೆ ತೆರೆಮರೆಯಲ್ಲಿ,

654
00:54:07,730 --> 00:54:11,940
ಆದರೆ ಕನಿಷ್ಠ, ಕೇವಲ, GDB ಅನ್ನು ಬೂಟ್ ಅಭ್ಯಾಸ

655
00:54:11,940 --> 00:54:13,940
ನೀವು ಮೇಲೆ ಒಡೆಯುವ ವರೆಗೆ, ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ

656
00:54:13,940 --> 00:54:18,260
, backtrace ಪಡೆಯುವಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ರಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಕುರಿತಾಗಿ

657
00:54:18,260 --> 00:54:24,450
ಯಾವ ಸಾಲು, ಕೆಲವು ಬದಲಾಗುವ ಮೌಲ್ಯಗಳನ್ನು ಔಟ್ ಮುದ್ರಿಸುವ, ಮೇಲೆ

658
00:54:24,450 --> 00:54:30,140
ನಿಜಕ್ಕೂ ನೀವು ಮುಂದುವರಿಸಲಾಗುತ್ತದೆ ಸಹಾಯ ಏಕೆಂದರೆ ಕೇವಲ ಆದ್ದರಿಂದ, ಅದು ಒಂದು ಭಾವನೆ ಪಡೆಯಿರಿ.

659
00:54:30,140 --> 00:54:36,340
ಈ ಹಂತದಲ್ಲಿ, ನೀವು ಪ್ರಶ್ನೆ ಬಿಟ್ಟು ಬಳಸಿ ಅಥವಾ ಇವು, GDB ಹೊರಗೆ ಬಿಡಲು ನೀನು.

660
00:54:36,340 --> 00:54:40,460
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಈಗಲೂ ಚಾಲ್ತಿಯಲ್ಲಿದೆ ಮಧ್ಯದಲ್ಲಿ ಇದು ನಿರ್ಗಮಿಸಿದೆ ಇದ್ದಲ್ಲಿ,

661
00:54:40,460 --> 00:54:43,510
ಯಾವಾಗಲೂ ನೀವು ಕೇಳಬಹುದು, "ನೀವು ನಿಜವಾಗಿಯೂ ಬಿಡಲು ಖಚಿತವಾಗಿ ಬಯಸುವಿರಾ?"

662
00:54:43,510 --> 00:54:48,770
ನೀವು ಹೌದು ಹೊಡೆಯಬಹುದು.

663
00:54:48,770 --> 00:54:55,250
>> ಈಗ ನಾವು ಬೆಕ್ಕು ಪ್ರೋಗ್ರಾಂ ಇದು ನಾವು ಮುಂದಿನ ಸಮಸ್ಯೆ, ನೋಡಲು ನೀನು.

664
00:54:55,250 --> 00:54:59,880
ನೀವು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮತ್ತು ಪೈಪುಗಳ ಮೇಲೆ ಸಣ್ಣ ವೀಕ್ಷಿಸಲು, ನೀವು ಟಾಮಿ ಈ ಪ್ರೋಗ್ರಾಂ ಬಳಸುವ ನೋಡುತ್ತಾರೆ

665
00:54:59,880 --> 00:55:07,540
ಮೂಲಭೂತ ತೆರೆಗೆ ಫೈಲ್ ಎಲ್ಲಾ ಔಟ್ಪುಟ್ ಮುದ್ರಿಸುತ್ತದೆ.

666
00:55:07,540 --> 00:55:12,660
ನಾನು ಬೆಕ್ಕು ರನ್ ಹಾಗಿದ್ದಲ್ಲಿ, ಈ ಯಂತ್ರಕ್ಕಾಗಿ ವಾಸ್ತವವಾಗಿ ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಕ್ರಮವಾಗಿದ್ದು,

667
00:55:12,660 --> 00:55:16,860
ನೀವು ಮ್ಯಾಕ್ಗಳ ಹೊಂದಿದ್ದರೆ ನೀವು ಟರ್ಮಿನಲ್ ತೆರೆಯುತ್ತದೆ ವೇಳೆ ಮತ್ತು ನೀವು ಸಹ ನಿಮ್ಮ ಮ್ಯಾಕ್ ಈ ಮಾಡಬಹುದು.

668
00:55:16,860 --> 00:55:25,630
ಮತ್ತು ನಾವು - ಬೆಕ್ಕು, ನ, cp.c ಹೇಳಲು ಅವಕಾಶ, ಮತ್ತು ನಮೂದಿಸಿ ಹಿಟ್.

669
00:55:25,630 --> 00:55:29,640
ಈ ಏನು, ನಾವು ಸ್ವಲ್ಪ ಅಪ್ ಸ್ಕ್ರಾಲ್ ಮತ್ತು ನಾವು ಲೈನ್ ಓಡಿ ಅಲ್ಲಿ ನೋಡಿ ವೇಳೆ

670
00:55:29,640 --> 00:55:40,440
ಅಥವಾ ನಾವು ಬೆಕ್ಕು ಆಜ್ಞೆಯನ್ನು ಓಡಿ ಅಲ್ಲಿ, ಅದು ಅಕ್ಷರಶಃ ನಮ್ಮ ತೆರೆಗೆ cp.c ವಿಷಯಗಳನ್ನು ಔಟ್ ಮುದ್ರಿತ.

671
00:55:40,440 --> 00:55:44,140
ನಾವು ಮತ್ತೆ ಚಾಲನೆ ಮತ್ತು ನೀವು ಒಟ್ಟಿಗೆ ಬಹು ಫೈಲ್ಗಳನ್ನು ರಲ್ಲಿ ಹಾಕಬಹುದು.

672
00:55:44,140 --> 00:55:49,880
, ಆದ್ದರಿಂದ ನೀವು ಬೆಕ್ಕು cp.c ಮಾಡಬಹುದು, ತದನಂತರ ನಾವು cat.c ಕಡತ concatenate ಮಾಡಬಹುದು

673
00:55:49,880 --> 00:55:53,250
ಇದು, ನಾವು ಬಗ್ಗೆ ಬರೆಯಲು ನೀವು ಕಾರ್ಯಕ್ರಮ

674
00:55:53,250 --> 00:55:58,140
ಮತ್ತು ನಮ್ಮ ತೆರೆಗೆ ಬ್ಯಾಕ್ ಮತ್ತೆ ಎರಡೂ ಕಡತಗಳನ್ನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ.

675
00:55:58,140 --> 00:56:05,490
ನಾವು ಸ್ವಲ್ಪ ಅಪ್ ಸ್ಕ್ರಾಲ್ ಆದ್ದರಿಂದ, ನಾವು ನೋಡಿ ನಾವು ಈ ಬೆಕ್ಕು cp.c, cat.c, ನಡೆಸುತ್ತಿದ್ದರು

676
00:56:05,490 --> 00:56:17,110
ಮೊದಲು CP ಕಡತ ಮುದ್ರಣ, ಮತ್ತು ನಂತರ ಅದನ್ನು ಕೆಳಗೆ, ಇದು ಬಲ ಕೆಳಗೆ ಇಲ್ಲಿ cat.c ಕಡತ ಮುದ್ರಣ ಮಾಡಿದ.

677
00:56:17,110 --> 00:56:19,650
ನಾವು ನಮ್ಮ ಪಾದಗಳನ್ನು ತೇವ ಪಡೆಯಲು ಈ ಬಳಸಲು ನೀನು.

678
00:56:19,650 --> 00:56:25,930
ಟರ್ಮಿನಲ್ ಸರಳ ಮುದ್ರಣ ಜೊತೆ ಸುಮಾರು ಪ್ಲೇ, ಆ ಕೆಲಸ ಹೇಗೆ ನೋಡಿ.

679
00:56:25,930 --> 00:56:39,170
ನೀವು ಹುಡುಗರಿಗೆ ಜಿಎಡಿಟ್ Name cat.c ಜೊತೆ ತೆರೆಯುತ್ತದೆ ವೇಳೆ, ನಮೂದಿಸಿ ಹಿಟ್

680
00:56:39,170 --> 00:56:43,760
ನಾವು ಬರೆಯಲು ಬಗ್ಗೆ ನೀವು ಕಾರ್ಯಕ್ರಮದ ನೋಡಬಹುದು.

681
00:56:43,760 --> 00:56:48,980
ಈ ಸಂತೋಷವನ್ನು ಬಾಯ್ಲರ್ ಪ್ಲೇಟ್ ಒಳಗೊಂಡಿತ್ತು ಮಾಡಿದ, ನಾವು ಎಲ್ಲಾ ಎಂದು ಟೈಪ್ ಸಮಯ ಕಳೆಯಲು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ.

682
00:56:48,980 --> 00:56:52,310
ನಾವು ಸೈನ್ ಜಾರಿಗೆ ವಾದಗಳನ್ನು ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ

683
00:56:52,310 --> 00:56:56,910
ನಾವು ಉತ್ತಮ ಬಳಕೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

684
00:56:56,910 --> 00:57:00,950
>> ಈ, ಮತ್ತೆ, ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ ಮಾಡಿರುವುದರಿಂದ, ವಿಷಯ ತೆರನಾದ

685
00:57:00,950 --> 00:57:04,490
ಇದು ಬಹುತೇಕ ಸ್ನಾಯು ಮೆಮೊರಿ ಅನಿಸುತ್ತದೆ.

686
00:57:04,490 --> 00:57:07,190
ಕೇವಲ ಸ್ಟಫ್ ರೀತಿಯಲ್ಲಿ ನಡೆಸುವ ಮರೆಯದಿರಿ

687
00:57:07,190 --> 00:57:11,310
ಮತ್ತು ಯಾವಾಗಲೂ ಸಹಾಯಕವಾಗಿದೆಯೆ ಸಂದೇಶದ ವಿಧದ ಔಟ್ ಮುದ್ರಣ

688
00:57:11,310 --> 00:57:17,670
ಆದ್ದರಿಂದ ಜನರು ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮನ್ನು ಗೊತ್ತಿಲ್ಲ.

689
00:57:17,670 --> 00:57:21,630
ಬೆಕ್ಕು, ಇದು ಬಹಳ ಸರಳವಾಗಿದೆ; ನಾವು ವಿವಿಧ ವಾದಗಳು ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಲು ನೀನು

690
00:57:21,630 --> 00:57:24,300
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ ಜಾರಿಗೆ ತಂದಿತು, ಮತ್ತು ನಾವು ಮುದ್ರಿಸಲು ನೀನು

691
00:57:24,300 --> 00:57:29,950
ಒಂದು ಸಮಯದಲ್ಲಿ ಪರದೆಯ ಒಂದು ತಮ್ಮ ವಿಷಯಗಳನ್ನು ಔಟ್.

692
00:57:29,950 --> 00:57:35,670
ತೆರೆಗೆ ಕಡತಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಸಲುವಾಗಿ, ನಾವು ಹೋಲುತ್ತದೆ ಏನನ್ನಾದರೂ ಮಾಡಲು ನೀನು

693
00:57:35,670 --> 00:57:38,120
ನಾವು ರಸಪ್ರಶ್ನೆ ಕೊನೆಯಲ್ಲಿ ಏನು ಮಾಡಿದರು ಎಂದು.

694
00:57:38,120 --> 00:57:45,350
ಪ್ರೋಗ್ರಾಂ ನೇಮಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಎಂದು ರಸಪ್ರಶ್ನೆ, ಕೊನೆಯಲ್ಲಿ, ನಾವು, ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲು ಹೊಂದಿತ್ತು

695
00:57:45,350 --> 00:57:48,490
ಮತ್ತು ನಾವು ಅದನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿತ್ತು.

696
00:57:48,490 --> 00:57:54,660
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲು ನೀನು ಮತ್ತು ನಾವು ಬದಲಿಗೆ ಅದರಿಂದ ಓದಲು ನೀನು.

697
00:57:54,660 --> 00:58:00,630
ನಂತರ ನಾವು ಬದಲಿಗೆ ಒಂದು ಕಡತಕ್ಕೆ ಆಫ್, ಮುದ್ರಿಸಲು ನೀನು, ನಾವು ತೆರೆಗೆ ಮುದ್ರಿಸಲು ನೀನು.

698
00:58:00,630 --> 00:58:05,830
ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ printf ಜೊತೆ ಮೊದಲು ಮಾಡಿದ ಪರದೆಯ ಮುದ್ರಿಸುವ.

699
00:58:05,830 --> 00:58:08,290
ಆದ್ದರಿಂದ ತುಂಬಾ ಕ್ರೇಜಿ ಅಲ್ಲ.

700
00:58:08,290 --> 00:58:12,190
ಆದರೆ ಕಡತ ಓದುವ ವಿಲಕ್ಷಣ ರೀತಿಯ.

701
00:58:12,190 --> 00:58:17,300
ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಸ್ವಲ್ಪ ಮೂಲಕ ಹೋಗುತ್ತೇನೆ.

702
00:58:17,300 --> 00:58:20,560
ನೀವು ಹುಡುಗರಿಗೆ ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ, ಸಮಸ್ಯೆಯನ್ನು 33, ಆ ಕೊನೆಯ ಸಮಸ್ಯೆಗೆ ಹಿಂದಕ್ಕೆ ಹೋದರೆ

703
00:58:20,560 --> 00:58:27,280
ನಾವು ಇಲ್ಲಿ ಮಾಡಲು ನೀನು ಮೊದಲ ಸಾಲು, ಫೈಲ್ ತೆರೆಯುವ, ನಾವು ಏನು ಮಾಡಿದರು ಹೋಲುತ್ತದೆ.

704
00:58:27,280 --> 00:58:36,370
ಸ್ಟೆಲ್ಲಾ ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ಕಡತವನ್ನು ತೆರೆದಾಗ, ಆ ಸಾಲಿನ ನೋಟ ಮಾಡುತ್ತದೆ?

705
00:58:36,370 --> 00:58:47,510
[ಸ್ಟೆಲ್ಲಾ] ಕ್ಯಾಪಿಟಲ್ FILE *, ಕಡತ - >> ಸರಿ. >> - Fopen ಸಮಾನವಾಗಿರುತ್ತದೆ. >> ಹೌದು.

706
00:58:47,510 --> 00:58:55,980
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವುದು? ಇದು ಕಾಮೆಂಟ್ನಲ್ಲಿ ಇಲ್ಲಿದೆ.

707
00:58:55,980 --> 00:59:06,930
>> ಇದು ಕಾಮೆಂಟ್ ಯಾರಿದ್ದಾರೆ? argv [I] ಮತ್ತು ಆರ್?

708
00:59:06,930 --> 00:59:11,300
ನಿಖರವಾಗಿ >>. ಬಲ. ಆದ್ದರಿಂದ ಸ್ಟೆಲ್ಲಾ ಸಂಪೂರ್ಣವಾಗಿ ಸರಿ.

709
00:59:11,300 --> 00:59:13,720
ಈ ಲೈನ್ ಕಾಣುತ್ತದೆ ಏನು.

710
00:59:13,720 --> 00:59:19,670
ನಾವು, ಒಂದು ಕಡತ ಸ್ಟ್ರೀಮ್ ವ್ಯತ್ಯಯ ಫೈಲ್ * ಅದನ್ನು ಮಳಿಗೆಗೆ ಹೋಗಿ, ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ ಕ್ಯಾಪ್ಸ್,

711
00:59:19,670 --> 00:59:25,720
ಫೈಲ್ *, ಮತ್ತು ಈ ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಫೈಲ್ ಕಾಣಿಸುತ್ತದೆ.

712
00:59:25,720 --> 00:59:32,250
ನಾವು ಇಷ್ಟ ಇರಲಿ ಇದು ಕರೆಯಬಹುದು. ನಾವು ಬಯಸುವ ಯಾವುದೇ, ಅದು first_file, ಅಥವಾ file_i ಕರೆಯಬಹುದು.

713
00:59:32,250 --> 00:59:37,590
ತದನಂತರ ಫೈಲ್ ಹೆಸರು ಈ ಪ್ರೋಗ್ರಾಂಗೆ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ರಲ್ಲಿ ಅಂಗೀಕರಿಸಿತು.

714
00:59:37,590 --> 00:59:44,450
ಆದ್ದರಿಂದ argv ಸಂಗ್ರಹಗೊಂಡಿರುವಂತಹ [ನಾನು] ಮತ್ತು ನಂತರ ನಾವು ಓದಲು ಕ್ರಮದಲ್ಲಿ ಈ ಕಡತವನ್ನು ತೆರೆಯಲು ನೀನು.

715
00:59:44,450 --> 00:59:48,100
ನಾವು ಫೈಲ್ ತೆರೆಯಿತು ನೀವು ಈಗ ಆ, ನಾವು ಯಾವಾಗಲೂ ಮಾಡಲು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಹೊಂದಿರುವ ವಿಷಯ

716
00:59:48,100 --> 00:59:52,230
ನಾವು ಒಂದು ಕಡತ ತೆರೆಯಿತು ನೀವು ಯಾವಾಗ? ಅದನ್ನು ಮುಚ್ಚಿ.

717
00:59:52,230 --> 00:59:57,220
ಮಿಸ್ಸಿ ಆದ್ದರಿಂದ, ಹೇಗೆ ನಾವು ಫೈಲ್ ಕ್ಲೋಸ್?

718
00:59:57,220 --> 01:00:01,020
[ಮಿಸ್ಸಿ] fclose (ಕಡತ) >> fclose (ಕಡತ). ನಿಖರವಾಗಿ.

719
01:00:01,020 --> 01:00:05,340
ಗ್ರೇಟ್. ಸರಿ. ನಾವು ಇಲ್ಲಿಯೇ ಕಾಮೆಂಟ್ ಮಾಡಲು ಈ ನೋಡಲು, ವೇಳೆ

720
01:00:05,340 --> 01:00:11,940
ಇದು "ಓಪನ್ argv [I] ಮತ್ತು stdout ಅದರ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ." ಹೇಳುತ್ತಾರೆ

721
01:00:11,940 --> 01:00:15,460
>> ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ವಿಚಿತ್ರವಾಗಿ ಹೆಸರು. Stdout ಹೇಳುವ ಕೇವಲ ನಮ್ಮ ದಾರಿ

722
01:00:15,460 --> 01:00:22,880
ನಾವು ಟರ್ಮಿನಲ್ ಅದನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುವ; ನಾವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪ್ರದಾನ ಸ್ಟ್ರೀಮ್ ಅದನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುವ.

723
01:00:22,880 --> 01:00:26,450
ನಾವು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿಯೇ ಈ ಅಭಿಪ್ರಾಯವನ್ನು ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.

724
01:00:26,450 --> 01:00:36,480
ನಾನು ಅದನ್ನು ನಕಲಿಸಿ ಮತ್ತು ನಾವು ಮಾಡಲಿಲ್ಲ ಎಂಬುದನ್ನು ಇದು ಅಂಟಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ.

725
01:00:36,480 --> 01:00:41,290
ಈ ಹಂತದಲ್ಲಿ, ಈಗ ನಾವು ಬಿಟ್ ಮೂಲಕ ಕಡತ ಬಿಟ್ ಓದಲು ಹೊಂದಿವೆ.

726
01:00:41,290 --> 01:00:46,300
ನಾವು ಓದುವ ಕಡತಗಳ ರೀತಿಯಲ್ಲಿ ಒಂದೆರಡು ಚರ್ಚಿಸಲಾಗಿದೆ ಮಾಡಿದ್ದೀರಿ.

727
01:00:46,300 --> 01:00:51,830
ಇದು ಬಿಡಿಗಳ ಇಲ್ಲಿಯವರೆಗೆ ನಿಮ್ಮ ಅಚ್ಚುಮೆಚ್ಚಾಗಿವೆ?

728
01:00:51,830 --> 01:00:57,960
ಯಾವ ರೀತಿಯಲ್ಲಿ ನೀವು ನೋಡಿರುವ ಅಥವಾ ನೀವು ಕಡತಗಳನ್ನು ಓದಲು, ನಿಮಗೆ ನೆನಪಿದೆಯೇ?

729
01:00:57,960 --> 01:01:04,870
[ಡೇನಿಯಲ್] fread? >> Fread? ಆದ್ದರಿಂದ fread ಒಂದಾಗಿದೆ. ಜಿಮ್ಮಿ, ನೀವು ಯಾವುದೇ ಇತರರು ತಿಳಿಯುವುದು?

730
01:01:04,870 --> 01:01:12,150
[ಜಿಮ್ಮಿ] ನಂ >> ಸರಿ. ಇಲ್ಲ. ಷಾರ್ಲೆಟ್? ಅಲೆಕ್ಸಾಂಡರ್? ಯಾವುದೇ ಇತರರು? ಸರಿ.

731
01:01:12,150 --> 01:01:20,740
ಆದ್ದರಿಂದ ಇತರ ಬಿಡಿಗಳ ನಾವು ಬಹಳಷ್ಟು ಬಳಸಿ ಎಂದು, ಒಂದು fgetc ಮಾಡುವುದಾಗಿತ್ತು.

732
01:01:20,740 --> 01:01:26,410
ಸಹ fscanf ಇಲ್ಲ; ನೀವು ಹುಡುಗರಿಗೆ ಇಲ್ಲಿ ಮಾದರಿಯನ್ನು ನೋಡಿ?

733
01:01:26,410 --> 01:01:29,170
ಅವರು ಎಲ್ಲಾ ಎಫ್ ಆರಂಭವಾಗುತ್ತವೆ. ಒಂದು ಕಡತವನ್ನು ಮಾಡಲು ಏನು.

734
01:01:29,170 --> 01:01:35,260
Fread, fgetc, fscanf ಇಲ್ಲ. ಈ ಓದುವ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ.

735
01:01:35,260 --> 01:01:49,120
ನಾವು fwrite ಹೊಂದಿರುತ್ತವೆ ಬರೆಯಲು, ನಾವು ಬದಲಿಗೆ fgetc ಆಫ್ fputc ಹೊಂದಿರುತ್ತವೆ.

736
01:01:49,120 --> 01:01:58,250
ನಾವು fprintf ನಾವು ರಸಪ್ರಶ್ನೆ ನೋಡಿದ ಹಾಗೆ ಮಾಡಿದ್ದಾರೆ.

737
01:01:58,250 --> 01:02:01,680
ಈ ಒಂದು ಕಡತವನ್ನು ಓದುವಲ್ಲಿ ಒಳಗೊಂಡ ಒಂದು ಸಮಸ್ಯೆಯಾಗಿದೆ, ಏಕೆಂದರೆ

738
01:02:01,680 --> 01:02:04,940
ನಾವು ಈ ಮೂರು ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಬಳಸಲು ನೀನು.

739
01:02:04,940 --> 01:02:10,890
ನಾವು ಇಲ್ಲಿ ಈ ಕಾರ್ಯಗಳನ್ನು ಕೆಳಗೆ ಬಳಸಲು ಹೋಗುತ್ತಿಲ್ಲ.

740
01:02:10,890 --> 01:02:14,880
ಈ ಕಾರ್ಯಗಳು ಎಲ್ಲಾ ಪ್ರಮಾಣಿತ I / O lib ಕಂಡುಬರುತ್ತವೆ.

741
01:02:14,880 --> 01:02:17,510
ಈ ಕಾರ್ಯಕ್ರಮದ ಪ್ರಮುಖ ನೋಡಲು, ಆದ್ದರಿಂದ

742
01:02:17,510 --> 01:02:24,110
ನಾವು ಈಗಾಗಲೇ ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O lib ಫಾರ್ ಹೆಡರ್ ಫೈಲ್ ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು.

743
01:02:24,110 --> 01:02:27,120
ನಾವು ಊಹಿಸಲು ಬಯಸಿದರೆ ಇದು ಒಂದು ನಾವು ಬಳಸಲು ಬಯಸುವ,

744
01:02:27,120 --> 01:02:29,690
ನಾವು ಯಾವಾಗಲೂ ಮನುಷ್ಯ ಪುಟಗಳು ತೆರೆದುಕೊಳ್ಳಬಹುದು.

745
01:02:29,690 --> 01:02:34,350
ಆದ್ದರಿಂದ ಮನುಷ್ಯ stdio ಟೈಪ್ ಮಾಡಬಹುದು

746
01:02:34,350 --> 01:02:43,180
ಮತ್ತು ಸಿ ರಲ್ಲಿ stdio ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಕಾರ್ಯಗಳನ್ನು ಬಗ್ಗೆ ಎಲ್ಲಾ ಓದಿ

747
01:02:43,180 --> 01:02:49,870
ನಾವು ಈಗಾಗಲೇ ಓಹ್, ನೋಡಲು ನೋಡಬಹುದು. ಇದು fgetc ಪ್ರಸ್ತಾಪಿಸಿ, ಅದು fputc ಪ್ರಸ್ತಾಪಿಸಿ ನ.

748
01:02:49,870 --> 01:02:57,220
ಆದ್ದರಿಂದ ನೀವು fgetc, ಸ್ವಲ್ಪ ಕೆಳಗೆ ಕೊರೆತಕ್ಕಾಗಿ ಮತ್ತು ನೋಡಲು, ಹೇಳಬಹುದು

749
01:02:57,220 --> 01:03:00,060
ಮತ್ತು ಅದರ ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಿ.

750
01:03:00,060 --> 01:03:03,430
ನೀವು ಇದನ್ನು ಇತರ ಕಾರ್ಯಗಳನ್ನು ಇಡೀ ಗುಂಪೇ ನಡೆದುಕೊಳ್ಳುತ್ತಾನೆ ಎಂದು ನೋಡಬಹುದು:

751
01:03:03,430 --> 01:03:12,640
fgetc, fgets, getc, getchar, ಗೆಟ್ಸ್, ungetc, ಮತ್ತು ಪಾತ್ರಗಳು ಮತ್ತು ತಂತಿಗಳ ಇದರ ಇನ್ಪುಟ್.

752
01:03:12,640 --> 01:03:19,180
ಆದ್ದರಿಂದ ಈ, ನಾವು ಗುಣಮಟ್ಟದ ಇನ್ಪುಟ್ ಫೈಲ್ಗಳನ್ನು ಪಾತ್ರಗಳು ಮತ್ತು ತಂತಿಗಳನ್ನು ಓದಲು ಹೇಗೆ

753
01:03:19,180 --> 01:03:21,990
ಇದು ಬಳಕೆದಾರರ ಪ್ರಮುಖವಾಗಿ.

754
01:03:21,990 --> 01:03:24,780
ಈ ನಾವು ನಿಜವಾದ ಸಿ ಇದನ್ನು ಹೇಗೆ

755
01:03:24,780 --> 01:03:30,850
ಆದ್ದರಿಂದ ಈ GetString ಮತ್ತು GetChar ಕಾರ್ಯಗಳನ್ನು ಬಳಸದೇ

756
01:03:30,850 --> 01:03:36,840
ನಾವು CS50 ಲೈಬ್ರರಿಯಿಂದ ಬಳಸಿದ.

757
01:03:36,840 --> 01:03:39,710
ನಾವು ರೀತಿಯಲ್ಲಿ ಒಂದೆರಡು ಈ ಸಮಸ್ಯೆಯನ್ನು ಮಾಡಲು ನೀನು

758
01:03:39,710 --> 01:03:43,430
ಆದ್ದರಿಂದ ನೀವು ಮಾಡುವ ಎರಡು ರೀತಿಯಲ್ಲಿ ನೋಡಬಹುದು.

759
01:03:43,430 --> 01:03:48,490
Fread ಡೇನಿಯಲ್ ತಿಳಿಸಿದ ಕಾರ್ಯವನ್ನು ಮತ್ತು fgetc ಎರಡೂ ಅದನ್ನು ಉತ್ತಮ ವಿಧಾನಗಳಿವೆ.

760
01:03:48,490 --> 01:03:53,790
ಇದು ಏಕೆಂದರೆ ನೀವು ನೋಡಿ ಎಂದು ನಾನು,,, fgetc ಸ್ವಲ್ಪ ಸುಲಭ ಎಂದು

761
01:03:53,790 --> 01:03:59,660
ಒಂದು ವಾದದ, ನಾವು ಪಾತ್ರ ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಫೈಲ್ *,

762
01:03:59,660 --> 01:04:02,740
ಮತ್ತು ಅದರ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಒಂದು ಇಂಟ್ ಹೊಂದಿದೆ.

763
01:04:02,740 --> 01:04:05,610
ಈ ಹಕ್ಕನ್ನು, ಸ್ವಲ್ಪ ಗೊಂದಲಮಯವಾಗಿದೆ?

764
01:04:05,610 --> 01:04:11,450
>> ನಾವು ಒಂದು ಪಾತ್ರ ಬರುತ್ತಿದೆ ಏಕೆಂದರೆ, ಆದ್ದರಿಂದ ಈ ರಿಟರ್ನ್ ಒಂದು ಚಾರ್ ಮಾಡುವುದಿಲ್ಲ?

765
01:04:11,450 --> 01:04:18,700
ನೀವು ಹುಡುಗರಿಗೆ ಈ ಚಾರ್ ಹಿಂದಿರುಗಲು ಇರಬಹುದು ಏಕೆ ಯಾವುದೇ ಕಲ್ಪನೆಗಳನ್ನು ಹೊಂದಿವೆ?

766
01:04:18,700 --> 01:04:25,510
[ಮಿಸ್ಸಿ ಉತ್ತರಗಳನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ಹೌದು. ಆದ್ದರಿಂದ ಮಿಸ್ಸಿ ಸಂಪೂರ್ಣವಾಗಿ ಸರಿ.

767
01:04:25,510 --> 01:04:31,570
ಇದು ASCII ನ ವೇಳೆ, ನಂತರ ಈ ಪೂರ್ಣಾಂಕ ನಿಜವಾದ ಚಾರ್ ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.

768
01:04:31,570 --> 01:04:33,520
ಒಂದು ASCII ಅಕ್ಷರ ಎಂದು, ಮತ್ತು ಸರಿ ಆಗಲಿಲ್ಲ.

769
01:04:33,520 --> 01:04:36,220
ಕರಾರುವಾಕ್ಕಾಗಿ ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು.

770
01:04:36,220 --> 01:04:39,190
ಇದು ಹೆಚ್ಚಿನ ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿದೆ ಸರಳವಾಗಿ ಏಕೆಂದರೆ ನಾವು ಒಂದು ಇಂಟ್ ಬಳಸುತ್ತಿದ್ದೀರಿ.

771
01:04:39,190 --> 01:04:44,750
ನಮ್ಮ ಚಾರ್ ಕೇವಲ 8 ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ನಮ್ಮ 32-ಬಿಟ್ ಗಣಕಗಳಲ್ಲಿ 1 ಬೈಟ್ ಎಂದು; ಇದು ಅಕ್ಷರ ದೊಡ್ಡ ಇಲ್ಲಿದೆ.

772
01:04:44,750 --> 01:04:48,520
ಮತ್ತು ಒಂದು ಇಂಟ್ ಎಲ್ಲಾ ಜಾಗವನ್ನು 4 ಬೈಟ್ಗಳು 'ಮೌಲ್ಯದ ಹೊಂದಿದೆ.

773
01:04:48,520 --> 01:04:50,940
ಮತ್ತು ರೀತಿಯಲ್ಲಿ fgetc ಕೆಲಸ ತಿರುಗಿದರೆ,

774
01:04:50,940 --> 01:04:53,940
ನಾವು ಈ ಮನುಷ್ಯನ ಪುಟ ಸ್ವಲ್ಪ ನಮ್ಮ ಸಾರಾಂಶ ತನ್ನಿಂದ ಸ್ಕ್ರಾಲ್ ವೇಳೆ,

775
01:04:53,940 --> 01:05:05,000
ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್. ಅವರು EOF ಎಂದು ಈ ವಿಶೇಷ ಮೌಲ್ಯ ಬಳಸುವ ಔಟ್ ತಿರುಗುತ್ತದೆ.

776
01:05:05,000 --> 01:05:09,640
ಇದು fgetc ಕ್ರಿಯೆಯ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಒಂದು ವಿಶೇಷ ಸ್ಥಿರ ಇಲ್ಲಿದೆ

777
01:05:09,640 --> 01:05:14,570
ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಅಥವಾ ನೀವು ದೋಷ ಪಡೆಯಲು ವೇಳೆ. ಬಂದಾಗಲೆಲ್ಲಾ

778
01:05:14,570 --> 01:05:18,170
ಮತ್ತು ಇದು, ಸರಿಯಾಗಿ EOF ಈ ಹೋಲಿಕೆಗಳ ಮಾಡಲು ಎಂದು ತಿರುಗುತ್ತದೆ

779
01:05:18,170 --> 01:05:24,060
ನೀವು ಒಂದು ಇಂಟ್ ನಲ್ಲಿ ನೀವು ಹೊಂದಿರುವ ಮಾಹಿತಿಯನ್ನು ಹೆಚ್ಚುವರಿ ಪ್ರಮಾಣದ ಬೇಕು

780
01:05:24,060 --> 01:05:28,420
ಒಂದು ಚಾರ್ ವೇರಿಯಬಲ್ ಬಳಸಿಕೊಂಡು ವಿರೋಧಿಸಿದರು.

781
01:05:28,420 --> 01:05:32,130
Fgetc ಪರಿಣಾಮಕಾರಿಯಾಗಿ, ಒಂದು ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ಸಹ

782
01:05:32,130 --> 01:05:38,450
ನೀವು ನೀವು ಪ್ರಕಾರವನ್ನು ಇಂಟ್ ನ ಹೊಂದಿರುವ ವಿಷಯ ಹಿಂದಿರುಗಿದ ಎಂದು ನೆನಪಿಡುವ ಬಯಸುವ.

783
01:05:38,450 --> 01:05:41,360
ಇದು ಬಳಸಲು ಸಾಕಷ್ಟು ಸುಲಭ, ಹೇಳಿದರು.

784
01:05:41,360 --> 01:05:44,960
ಇದು ನಮಗೆ ಒಂದು ಪಾತ್ರವನ್ನು ನೀಡಲು ವಿಶೇಷವೇನು; ಆದ್ದರಿಂದ ನಾವು ಎಲ್ಲಾ ಕಡತ ಕೇಳುವ ಇರಿಸಿಕೊಳ್ಳಲು ಹೊಂದಿದೆ,

785
01:05:44,960 --> 01:05:48,440
"ನನ್ನ ಮುಂದಿನ ಪಾತ್ರದ ನೀಡಿ, ನನ್ನ ಮುಂದಿನ ಪಾತ್ರದ ನೀಡಿ, ನನ್ನ ಮುಂದಿನ ಪಾತ್ರದ ನೀಡಿ"

786
01:05:48,440 --> 01:05:51,400
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯಲು ತನಕ.

787
01:05:51,400 --> 01:05:54,730
ಮತ್ತು, ನಮ್ಮ ಕಡತದಿಂದ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರದಲ್ಲಿ ಪುಲ್ ಕಾಣಿಸುತ್ತದೆ

788
01:05:54,730 --> 01:05:56,250
ನಂತರ ನಾವು ಅದನ್ನು ಇಷ್ಟಪಡುವ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು.

789
01:05:56,250 --> 01:06:00,160
ನಾವು ಸಂಗ್ರಹಿಸಬಹುದು, ನಾವು, ಒಂದು ಸಾಲನ್ನು ಸೇರಿಸಿ ನಾವು ಮುದ್ರಿಸುತ್ತದೆ.

790
01:06:00,160 --> 01:06:04,630
ಆ ಯಾವುದೇ.

791
01:06:04,630 --> 01:06:09,600
>> ಹಿಂದಿನ ಝೂಮ್ ಮತ್ತು ನಮ್ಮ cat.c ಪ್ರೋಗ್ರಾಂ ಹಿಂದಕ್ಕೆ ಹೋಗಿ,

792
01:06:09,600 --> 01:06:16,170
ನಾವು fgetc ಬಳಸಲು ನೀನು ವೇಳೆ,

793
01:06:16,170 --> 01:06:21,710
ಹೇಗೆ ನಾವು ಕೋಡ್ ಈ ಮುಂದಿನ ಸಾಲು ಸಮೀಪಿಸಲು ಇರಬಹುದು?

794
01:06:21,710 --> 01:06:26,020
ನಾವು ಬಳಸಲು ನೀನು - fread ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಬೇರೆ ಮಾಡುತ್ತದೆ.

795
01:06:26,020 --> 01:06:32,600
ಈ ಸಮಯದಲ್ಲಿ, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು fgetc ಬಳಸಲು ನೀನು.

796
01:06:32,600 --> 01:06:40,910
ಒಂದು ಸಂಪೂರ್ಣ ಫೈಲ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು, ನಾವು ಮಾಡಬೇಕು ಎಂದು?

797
01:06:40,910 --> 01:06:44,030
ಅಲ್ಲಿ ಒಂದು ಕಡತದಲ್ಲಿ ಎಷ್ಟು ಪಾತ್ರ?

798
01:06:44,030 --> 01:06:47,390
ಸಾಕಷ್ಟು ಇವೆ. ನೀವು ಬಹುಶಃ ಒಂದು ಸಿಗತ್ತೆ

799
01:06:47,390 --> 01:06:49,860
ನಂತರ ಮತ್ತೊಂದು ಪಡೆಯಲು ಮತ್ತೊಂದು ಪಡೆಯಲು ಮತ್ತೊಂದು ಸಿಗುತ್ತದೆ.

800
01:06:49,860 --> 01:06:53,330
ನಾವು ಇಲ್ಲಿ ಬಳಸಲು ಹೊಂದಿರಬಹುದು ಕ್ರಮಾವಳಿಯ ಯಾವ ರೀತಿಯ ತಿಳಿದಿರುವಿರಿ?

801
01:06:53,330 --> 01:06:55,470
ಯಾವ ಪ್ರಕಾರದ -? ಲೂಪ್ ಫಾರ್ [ಅಲೆಕ್ಸಾಂಡರ್] ಎ? ನಿಖರವಾಗಿ >>.

802
01:06:55,470 --> 01:06:57,500
ಲೂಪ್ ಕೆಲವು ರೀತಿಯ.

803
01:06:57,500 --> 01:07:03,380
ಲೂಪ್ ಒಂದು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಾಸ್ತವವಾಗಿ ಶ್ರೇಷ್ಠವಾಗಿರುತ್ತದಲ್ಲದೇ.

804
01:07:03,380 --> 01:07:08,620
ನೀವು ಸಂಪೂರ್ಣ ಫೈಲ್ ಮೇಲೆ ಲೂಪ್ ಬಯಸುವ, ಮತ್ತು ನೀವು ಹೇಳುವ ಮಾಡಲಾಯಿತು ನಂತಹ, ಇದು, ಶಬ್ದಗಳನ್ನು

805
01:07:08,620 --> 01:07:11,820
ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು.

806
01:07:11,820 --> 01:07:13,850
ರೀತಿ ಎಂಬ ಬಗ್ಗೆ ಯಾವುದೇ ಸಲಹೆಗಳನ್ನು?

807
01:07:13,850 --> 01:07:22,090
[ಅಲೆಕ್ಸಾಂಡರ್, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

808
01:07:22,090 --> 01:07:30,050
>> ಸರಿ, ನೀವು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಯಾವ ಇಂಗ್ಲೀಷ್ ನಲ್ಲಿ ಹೇಳಿ? [ಅಲೆಕ್ಸಾಂಡರ್, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

809
01:07:30,050 --> 01:07:36,270
ನಾವು ಸಂಪೂರ್ಣ ಫೈಲ್ ಮೇಲೆ ಲೂಪ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ತರಹ ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದು ಧ್ವನಿಸುತ್ತದೆ.

810
01:07:36,270 --> 01:07:45,330
[ಅಲೆಕ್ಸಾಂಡರ್] ಹಾಗಾಗಿ <ಇಂಟ್ ಗಾತ್ರವನ್ನು? >> ಗಾತ್ರವನ್ನು -?

811
01:07:45,330 --> 01:07:49,290
ನಾನು, ಕಡತದ ಗಾತ್ರ ಊಹೆ? ಗಾತ್ರ - we'll ಅದನ್ನು ಈ ರೀತಿ ಬರೆಯಲು.

812
01:07:49,290 --> 01:07:57,470
ಬಾರಿಗೆ ಕಡತದ ಗಾತ್ರದ, ನಾನು + +.

813
01:07:57,470 --> 01:08:04,610
ಆದ್ದರಿಂದ, ನೀವು ಈ fgetc ಬಳಸಿಕೊಂಡು, ಮತ್ತು ಹಾಗೆ ಈ ಹೊಸ ಎಂದು ತಿರುಗಿದರೆ

814
01:08:04,610 --> 01:08:10,460
ಕೇವಲ ಒಂದು ಕಡತದ ಗಾತ್ರವನ್ನು ಪಡೆಯಲು ಯಾವುದೇ ಸುಲಭ ದಾರಿ ಇಲ್ಲ ಎಂದು

815
01:08:10,460 --> 01:08:16,979
ನೀವು ಮೊದಲು ನೋಡಬಹುದು ನಿರ್ಮಿಸಲು ಈ "sizeof" ರೀತಿಯ.

816
01:08:16,979 --> 01:08:20,910
ನಾವು fgetc ಕಾರ್ಯವನ್ನು ಬಳಸಲು, ನಾವು ಕೆಲವು ರೀತಿಯ ಪರಿಚಯಿಸುವ ನೀವು

817
01:08:20,910 --> 01:08:29,069
ಲೂಪ್ ಈ ಹೊಸ, ಮೋಜಿನ ವಾಕ್ಯ, ಅಲ್ಲಿ ಕೇವಲ ಒಂದು ಮೂಲ ಪ್ರತಿ ಬಳಸುವ

818
01:08:29,069 --> 01:08:33,920
ಪಾತ್ರಕ್ಕೆ ಪಾತ್ರ ಹೋಗಲು, ನಾವು, ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಎಳೆಯಲು ನೀನು

819
01:08:33,920 --> 01:08:37,120
ಒಂದು ಸಮಯದಲ್ಲಿ ಅಕ್ಷರ, ಮತ್ತು ನಾವು ತಿಳಿದಿರುವ ರೀತಿಯಲ್ಲಿ ನಾವು ಕೊನೆಯಲ್ಲಿ ಆರ್

820
01:08:37,120 --> 01:08:41,290
ನಾವು ಪಾತ್ರಗಳ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಕೆ ಮಾಡಿದ ಸಂದರ್ಭದಲ್ಲಿ,

821
01:08:41,290 --> 01:08:49,939
ಆದರೆ ನಾವು ಹಿಂದೆಗೆದುಕೊಳ್ಳಬೇಕು ಪಾತ್ರ ಕಡತ ಪಾತ್ರದ ವಿಶೇಷ ಕೊನೆಯಲ್ಲಿ ಯಾವಾಗ.

822
01:08:49,939 --> 01:08:58,689
ಈ ಚ ಕರೆ, ಮತ್ತು ನಾವು ಆರಂಭಿಸಲು ನೀನು - ಆದ್ದರಿಂದ ನಾವು ಈ ಮಾಡಬಹುದು

823
01:08:58,689 --> 01:09:08,050
ಕಡತದ ಔಟ್ ಮೊದಲ ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ನಮ್ಮ ಮೊದಲ ಕರೆಯೊಂದಿಗೆ.

824
01:09:08,050 --> 01:09:14,979
ಇಲ್ಲಿಯೇ ಈ ಭಾಗವನ್ನು ಆದ್ದರಿಂದ, ಈ ಫೈಲ್ ಒಂದು ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ಹೋಗುತ್ತದೆ

825
01:09:14,979 --> 01:09:20,840
ಮತ್ತು ವೇರಿಯಬಲ್ ಚ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು.

826
01:09:20,840 --> 01:09:25,420
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯಲು ತನಕ ನಾವು ಈ ನಡೆಸುವ ಎಂದು ನೀನು,

827
01:09:25,420 --> 01:09:41,170
ಇದು ನಾವು ವಿಶೇಷ EOF ಪಾತ್ರಕ್ಕೆ ಸಮನಾದ ಕಾರಣ ಪಾತ್ರಕ್ಕೆ ಪರೀಕ್ಷಿಸುವ ಮೂಲಕ ಮಾಡಬೇಕು.

828
01:09:41,170 --> 01:09:48,750
ಬದಲಿಗೆ ಚ ಮಾಡುವ ಮತ್ತು ನಂತರ + +, ಇದು ಕೇವಲ, ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು ಎಂದು

829
01:09:48,750 --> 01:09:52,710
ನಾವು ಫೈಲ್ ಒಂದು ಒಂದು ಔಟ್, ಎ, ಹೇಳಲು ಒಂದು ರಾಜಧಾನಿ ಓದಿ ಹಾಗಿದ್ದಲ್ಲಿ

830
01:09:52,710 --> 01:09:56,810
ಚ + + ನಮಗೆ ಬೌ ನೀಡುತ್ತದೆ, ಮತ್ತು ನಾವು ಸಿ ಮತ್ತು ನಂತರ D ಹೋಗಬಹುದು.

831
01:09:56,810 --> 01:09:59,310
ನಾವು ಯಾವ ಸ್ಪಷ್ಟವಾಗಿ ಅಲ್ಲ. ನಾವು ಇಲ್ಲಿ ಯಾವ

832
01:09:59,310 --> 01:10:05,830
ಈ ಕೊನೆಯ ಬಿಟ್ ನಾವು ಕಡತದಿಂದ ಮುಂದಿನ ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ಬಯಸುವ ಇದೆ.

833
01:10:05,830 --> 01:10:09,500
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಕಡತದಿಂದ ಮುಂದಿನ ಅಕ್ಷರ ಸಿಗುತ್ತವೆ?

834
01:10:09,500 --> 01:10:13,470
ನಾವು ಫೈಲ್ ಮೊದಲ ಅಕ್ಷರ ಸಿಗುತ್ತವೆ?

835
01:10:13,470 --> 01:10:17,200
[ವಿದ್ಯಾರ್ಥಿ] fgetfile? >> Fgetc, ಅಥವಾ, ಕ್ಷಮಿಸಿ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಸರಿ.

836
01:10:17,200 --> 01:10:20,470
ನಾನು ಅದನ್ನು ತಪ್ಪಾಗಿಬರೆಯಲಾದಪದ. ಹೌದು ಹಾಗೆ.

837
01:10:20,470 --> 01:10:26,240
ಇಲ್ಲಿ ಬದಲಿಗೆ ಚ ಮಾಡುವ + +

838
01:10:26,240 --> 01:10:29,560
ನಾವು ಮತ್ತೆ fgetc (ಕಡತ) ಕರೆಯಲು ನೀನು

839
01:10:29,560 --> 01:10:39,180
ಮತ್ತು ನಮ್ಮ ಅದೇ ಚ ವೇರಿಯಬಲ್ ಫಲಿತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು.

840
01:10:39,180 --> 01:10:43,730
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

841
01:10:43,730 --> 01:10:52,390
ಈ ಫೈಲ್ * ಹುಡುಗರಿಗೆ ವಿಶೇಷವಾಗಿದೆ ಅಲ್ಲಿ >> ಇದು.

842
01:10:52,390 --> 01:10:59,070
ಅವರು ಕೆಲಸ ರೀತಿಯಲ್ಲಿ ಅವರು ಹೊಂದಿದೆ - ನೀವು ಮೊದಲ ತೆರೆದಾಗ - ನೀವು ಮೊದಲ ಎಂದು fopen ಕರೆ ಮಾಡಿದಾಗ,

843
01:10:59,070 --> 01:11:04,260
FILE * ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಡತ ಆರಂಭಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

844
01:11:04,260 --> 01:11:12,830
ತದನಂತರ ನೀವು fgetc ಕರೆ ಪ್ರತಿ ಬಾರಿ, ಇದು ಕಡತ ಮೂಲಕ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಚಲಿಸುತ್ತದೆ.

845
01:11:12,830 --> 01:11:23,280
ಈ ಕಾಲ್ ಹಾಗೆ ಮಾಡುವಾಗ, ನೀವು ಒಂದು ಪಾತ್ರಕ್ಕೆ ಕಡತ ಪಾಯಿಂಟರ್ ಏರಿಕೆಯ ಮಾಡುತ್ತಿದ್ದೇವೆ.

846
01:11:23,280 --> 01:11:26,210
ಮತ್ತು ನೀವು ಮತ್ತೆ fgetc ಮಾಡಿದಾಗ, ನೀವು ಇನ್ನೊಂದು ಪಾತ್ರ ಸರಿಸುತ್ತಿರುವೆವು

847
01:11:26,210 --> 01:11:28,910
ಮತ್ತು ಇನ್ನೊಂದು ಪಾತ್ರ ಮತ್ತು ಇನ್ನೊಂದು ಪಾತ್ರ ಮತ್ತು ಇನ್ನೊಂದು ಪಾತ್ರ.

848
01:11:28,910 --> 01:11:32,030
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] >> ಮತ್ತು that's - ಹೌದು.

849
01:11:32,030 --> 01:11:34,810
ಇದು HOOD ಅಡಿಯಲ್ಲಿ ಈ ಮ್ಯಾಜಿಕ್ ಭಾಸವಾಗುತ್ತದೆ.

850
01:11:34,810 --> 01:11:37,930
ನೀವು ಮೂಲಕ ಏರಿಕೆಯ ಇರಿಸಿಕೊಳ್ಳಲು.

851
01:11:37,930 --> 01:11:46,510
ಈ ಹಂತದಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ ಅಕ್ಷರದೊಂದಿಗೆ ಕೆಲಸ ಆರ್.

852
01:11:46,510 --> 01:11:52,150
ಆದ್ದರಿಂದ ನಾವು ಈಗ ತೆರೆಗೆ ಈ ಮುದ್ರಿಸುತ್ತದೆ ಇರಬಹುದು?

853
01:11:52,150 --> 01:11:58,340
ನಾವು ಮೊದಲು ಬಳಸಿದ ಅದೇ printf ವಿಷಯ ಬಳಸಬಹುದು.

854
01:11:58,340 --> 01:12:00,330
ನಾವು ಎಲ್ಲಾ ಸೆಮಿಸ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ ಎಂದು.

855
01:12:00,330 --> 01:12:05,450
ನಾವು, printf ಕರೆಯಬಹುದು

856
01:12:05,450 --> 01:12:21,300
ಮತ್ತು ನಾವು ಕೇವಲ ಪಾತ್ರದ ರವಾನಿಸಬಹುದು.

857
01:12:21,300 --> 01:12:27,430
ಇದನ್ನು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ, ಬದಲಿಗೆ printf ಬಳಸಿಕೊಂಡು ಈ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಮಾಡಲು ಹೊಂದಿರುವ ಹೆಚ್ಚು

858
01:12:27,430 --> 01:12:29,490
ನಾವು ಇತರ ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಬಳಸಬಹುದು.

859
01:12:29,490 --> 01:12:40,090
ನಾವು ತೆರೆಗೆ ಒಂದು ಪಾತ್ರ ಮುದ್ರಿಸುತ್ತದೆ ಇದು fputc, ಬಳಸಬಹುದು

860
01:12:40,090 --> 01:12:52,580
ನಾವು fputc ನೋಡಿದರೆ ಹೊರತುಪಡಿಸಿ - ಅಂತ ಸ್ವಲ್ಪ ಝೂಮ್ ಔಟ್ ಲೆಟ್.

861
01:12:52,580 --> 01:12:56,430
ನಾವು ಏನನ್ನು ಸಂತೋಷವನ್ನು ಇದನ್ನು ನಾವು fgetc ಬಳಸಿ ಓದುವ ಅಕ್ಷರದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಗಮನಕ್ಕೆ

862
01:12:56,430 --> 01:13:05,100
ಆದರೆ ನಾವು ಅದನ್ನು ಮುದ್ರಿಸಲು ಒಂದು ಸ್ಟ್ರೀಮ್ ನೀಡಲು ಹೊಂದಿವೆ.

863
01:13:05,100 --> 01:13:11,850
ನಾವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ನೇರವಾಗಿ ಪುಟ್ ಇದು putchar ಫಂಕ್ಷನ್, ಬಳಸಬಹುದು.

864
01:13:11,850 --> 01:13:16,070
ನಾವು ಮುದ್ರಣಕ್ಕೆ ಬಳಸಬಹುದಾದ ವಿವಿಧ ಆಯ್ಕೆಗಳ ಒಂದು ಸಂಪೂರ್ಣ ಗುಂಪೇ ಇದೆ.

865
01:13:16,070 --> 01:13:19,580
ಅವರು ಪ್ರಮಾಣಿತ I / O lib ಎಲ್ಲಾ ಆರ್.

866
01:13:19,580 --> 01:13:25,150
ನೀವು ಮುದ್ರಿಸಬೇಕೆಂದು ಬೇಕಾದಾಗ - ಆದ್ದರಿಂದ printf, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಸ್ಟ್ರೀಮ್ ಔಟ್ ವಿಶೇಷ ಗುಣಮಟ್ಟದ ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ

867
01:13:25,150 --> 01:13:27,910
ಆ stdout ಇದು.

868
01:13:27,910 --> 01:13:41,300
ಆದ್ದರಿಂದ ನಾವು ಈ ಮ್ಯಾಜಿಕ್ ಮೌಲ್ಯ, ಇಲ್ಲಿ stdout ರೀತಿಯ ಎಂದು ಉಲ್ಲೇಖಿಸಬಹುದು.

869
01:13:41,300 --> 01:13:48,410
ಓಹ್. ಹೊರಗೆ ಅಲ್ಪವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ಇರಿಸಿ.

870
01:13:48,410 --> 01:13:52,790
>> ಇಲ್ಲಿ ಹೊಸ, ಮೋಜಿನ ಮಾಹಿತಿಯನ್ನು ಸಾಕಷ್ಟು ಆಗಿದೆ.

871
01:13:52,790 --> 01:13:58,600
ಈ ಬಹಳಷ್ಟು ಈ ಕೋಡ್ ಎಂದು ಅರ್ಥದಲ್ಲಿ ಬಹಳ ಭಾಷಾನುಗುಣವಾದ ಆಗಿದೆ

872
01:13:58,600 --> 01:14:05,700
ಇದು, ಓದಲು ಸುಲಭ ಓದಲು ಕ್ಲೀನ್ ಕೇವಲ ಏಕೆಂದರೆ ಈ ರೀತಿ ಬರೆಯಲಾಗಿದೆ ಎಂದು.

873
01:14:05,700 --> 01:14:11,520
ಅದನ್ನು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ, ನೀವು ಬಳಸಬಹುದು ವಿಭಿನ್ನ ಕಾರ್ಯಚಟುವಟಿಕೆಗಳು, ಇವೆ

874
01:14:11,520 --> 01:14:14,680
ಆದರೆ ನಾವು ಕೇವಲ ಮತ್ತು ಮೇಲೆ ಇದೇ ಮಾದರಿಗಳನ್ನು ಒಲವು.

875
01:14:14,680 --> 01:14:20,180
ನೀವು ಮತ್ತೆ ಮತ್ತೆ ಬರುವ ಈ ಕೋಡ್ ನೋಡಿ ಆದ್ದರಿಂದ ಆಶ್ಚರ್ಯಪಡುತ್ತಾರೆ ಇಲ್ಲ.

876
01:14:20,180 --> 01:14:25,690
ಎಲ್ಲಾ ಸರಿ. ಈ ಸಮಯದಲ್ಲಿ, ನಾವು ದಿನಕ್ಕೆ ಮುರಿಯಲು ಅಗತ್ಯವಿದೆ.

877
01:14:25,690 --> 01:14:31,300
ಬರುವ ಧನ್ಯವಾದಗಳು. ನೀವು ಆನ್ಲೈನ್ನಲ್ಲಿ ವೇಳೆ ವೀಕ್ಷಿಸಲು ಧನ್ಯವಾದಗಳು. ಮತ್ತು ನಾವು ಮುಂದಿನ ವಾರದಲ್ಲಿ ನೀವು ನೋಡುತ್ತೀರಿ.

878
01:14:31,300 --> 01:14:33,890
[CS50.TV]