1 00:00:00,000 --> 00:00:02,500 [Powered by Google Translate] [ವಿಭಾಗ 5 - ಹೆಚ್ಚು ಆರಾಮದಾಯಕ] 2 00:00:02,500 --> 00:00:04,690 [ರಾಬ್ ಬೌಡೆನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ] 3 00:00:04,690 --> 00:00:07,250 [ಈ CS50 ಹೊಂದಿದೆ. - CS50.TV] 4 00:00:08,990 --> 00:00:14,250 >> ನನ್ನ ಇಮೇಲ್ ಹೇಳಿದರು ಹಾಗೆ, ನೀವು ಬಳಸಬಹುದು ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಇವೆ 5 00:00:14,250 --> 00:00:17,060 ವಾಸ್ತವವಾಗಿ ಸಮಸ್ಯೆ ಸೆಟ್ ಮಾಡಲು APPLIANCE ಬೇರೆ. 6 00:00:17,060 --> 00:00:19,910 ನಾವು ನಾವು ಸುಲಭವಾಗಿ ನೀವು ಸಹಾಯ ಮಾಡಬಹುದು ಕೇವಲ ನೀವು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅದನ್ನು ಶಿಫಾರಸು 7 00:00:19,910 --> 00:00:22,070 ನಾವು ಎಲ್ಲವನ್ನೂ ಕೆಲಸ ಹೋಗುತ್ತದೆ ಹೇಗೆ ಗೊತ್ತು. 8 00:00:22,070 --> 00:00:26,950 ಆದರೆ ಹೇಳಿ, ನೀವು ವಸ್ತುಗಳನ್ನು ಮಾಡಬಹುದು ಅಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿ, ನೀವು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ 9 00:00:26,950 --> 00:00:31,570 ಒಂದು APPLIANCE ಅಥವಾ ನೀವು ಸೈನ್ಸ್ ಸೆಂಟರ್ ನೆಲಮಾಳಿಗೆಯಲ್ಲಿ ಕೆಲಸ ಬಯಸುವ - 10 00:00:31,570 --> 00:00:33,090 ಇದು ವಾಸ್ತವವಾಗಿ ಅವರು ತುಂಬಾ APPLIANCE ಹೊಂದಿವೆ - 11 00:00:33,090 --> 00:00:35,150 ನೀವು ಎಲ್ಲಿಯಾದರೂ ಕೆಲಸ ಬಯಸಿದರೆ. 12 00:00:35,150 --> 00:00:42,370 ಒಂದು ಉದಾಹರಣೆಗೆ ನೀವು ಕಾಣಬಹುದು / SSH ನ ಕೇಳಿರಬಹುದು ಇದೆ? 13 00:00:44,380 --> 00:00:47,780 SSH ಕೇವಲ ಏನೋ ಸಂಪರ್ಕ ಮುಂತಾದ ಮೂಲಭೂತ. 14 00:00:47,780 --> 00:00:51,340 ವಾಸ್ತವವಾಗಿ, ಇದೀಗ ನಾನು APPLIANCE ಆಗಿ SSHed ನುಡಿದರು. 15 00:00:51,340 --> 00:00:54,290 ನಾನು ಉಪಕರಣಗಳಲ್ಲಿರುವ ನೇರವಾಗಿ ಕೆಲಸ ಇಲ್ಲ. 16 00:00:55,930 --> 00:01:01,060 ಇಲ್ಲಿ APPLIANCE ಹೊಂದಿದೆ, ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಕೆಳಗೆ ನೋಡಿದರೆ ಈ IP ವಿಳಾಸವನ್ನು ನೋಡಿ. 17 00:01:01,060 --> 00:01:03,650 ನಾನು APPLIANCE ಸ್ವತಃ ಕೆಲಸ ಇಲ್ಲ; 18 00:01:03,650 --> 00:01:08,840 ನಾನು ಯಾವಾಗಲೂ ಒಂದು iTerm2 ವಿಂಡೋ / ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಗೆ ಬರುತ್ತಾರೆ. 19 00:01:08,840 --> 00:01:15,910 ನಿಮ್ಮ IP ವಿಳಾಸವನ್ನು, SSH jharvard@192.168.129.128 ಇದಕ್ಕೆ SSH ಮಾಡಬಹುದು. 20 00:01:15,910 --> 00:01:20,390 ಇದು ಎ ನೈಸ್ ಮಾದರಿ, ಏಕೆಂದರೆ ನಾನು ತುಂಬಾ ಸುಲಭವಾಗಿ ಆ ಸಂಖ್ಯೆ ನೆನಪಿಡಿ. 21 00:01:20,390 --> 00:01:24,920 ಆದರೆ ನನ್ನ ಪಾಸ್ವರ್ಡ್ ನನಗೆ ಕೇಳುತ್ತೇವೆ, ಮತ್ತು ಈಗ ನಾನು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಆಗಿದ್ದೇನೆ. 22 00:01:24,920 --> 00:01:33,060 ಮೂಲತಃ, ಈ ಹಂತದಲ್ಲಿ, ನೀವು, APPLIANCE ಸ್ವತಃ ಒಳಗೆ ಒಂದು ಟರ್ಮಿನಲ್ ತೆರೆದಿವೆ 23 00:01:33,060 --> 00:01:36,350 ಈ ಇಂಟರ್ಫೇಸ್, ಆದರೆ ನೀವು ಅದನ್ನು ಬಳಸಬಹುದು, ನಿಖರವಾಗಿ ಒಂದೇ 24 00:01:36,350 --> 00:01:40,010 ಇಂಟರ್ಫೇಸ್ ಎಂದು ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಬಳಸಿಕೊಂಡು ನಾನು ಆದರೆ ಈಗ ನೀವು SSHed ಮಾಡುತ್ತಿದ್ದೇವೆ. 25 00:01:42,240 --> 00:01:44,920 ನೀವು APPLIANCE ಇದಕ್ಕೆ SSH ಇಲ್ಲ. 26 00:01:44,920 --> 00:01:52,360 ನಿಮ್ಮನ್ನು ಸಾಧ್ಯವೋ SSH ಇನ್ನೊಂದು ಸ್ಥಳದ ಒಂದು ಉದಾಹರಣೆಗೆ ನಾನು ನೀವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿರುತ್ತವೆ ಬಹಳ ಖಚಿತವಾಗಿ ನನಗೆ - 27 00:01:52,360 --> 00:01:55,020 ಓಹ್. ದೊಡ್ಡ. 28 00:01:55,020 --> 00:02:01,130 ನೀವು ಎಲ್ಲಾ FAS ಸರ್ವರ್ಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ FAS ಖಾತೆಗಳನ್ನು ಅದಕ್ಕೆ ಇರಬೇಕು. 29 00:02:01,130 --> 00:02:06,840 ನನಗೆ, ನಾನು SSH rbowden@nice.fas.harvard.edu ಇಚ್ಚಿಸುತ್ತಾರೆ. 30 00:02:06,840 --> 00:02:11,610 ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಕೇಳಲು ವಿಶೇಷವೇನು, ಮತ್ತು ನೀವು ಸೇ ಯಸ್. 31 00:02:11,610 --> 00:02:15,840 ನನ್ನ ಪಾಸ್ವರ್ಡ್ ನನ್ನ FAS ಪಾಸ್ವರ್ಡ್ ಏರಲಿದೆ. 32 00:02:15,840 --> 00:02:22,650 ಆದ್ದರಿಂದ ಈಗ, ನಾನು ಸಂತೋಷವನ್ನು ಸರ್ವರ್ಗಳಿಗೆ SSHed ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ನಾನು ಇಲ್ಲಿ ನೀವು ಏನು ಮಾಡಬಹುದು. 33 00:02:22,650 --> 00:02:28,560 ನೀವು 124 ನಂತಹ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ತರಗತಿಗಳು ಬಹಳಷ್ಟು, ನೀವು ಇಲ್ಲಿ ವಿಷಯವನ್ನು ಅಪ್ಲೋಡ್ ಹೊಂದಿರುತ್ತವೆ ಹೋಗುವ 34 00:02:28,560 --> 00:02:30,950 ವಾಸ್ತವವಾಗಿ ನಿಮ್ಮ ಸಮಸ್ಯೆ ಸೆಟ್ ಸಲ್ಲಿಸಲು. 35 00:02:30,950 --> 00:02:34,100 ಆದರೆ ನೀವು ನಿಮ್ಮ APPLIANCE ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಹೇಳುತ್ತಾರೆ. 36 00:02:34,100 --> 00:02:37,910 ನಂತರ ನೀವು, ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು ಇಲ್ಲಿ ಮೇಲೆ ನಂತಹ ಇದು ಹೇಳುವುದಿಲ್ಲ - 37 00:02:37,910 --> 00:02:42,160 ಈ ಕೇವಲ ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ಹೊಂದಿದೆ. 38 00:02:42,160 --> 00:02:45,070 ಇದು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಇದನ್ನು ಮಾಡಲು ನೀವು ಕೇಳುತ್ತೇವೆ. 39 00:02:45,070 --> 00:02:47,790 ಬದಲಿಗೆ ನಾನು ಸರ್ವರ್ ಅದನ್ನು ಮಾಡುತ್ತೇನೆ. 40 00:02:47,790 --> 00:02:50,560 ನಾನು ಅನ್ಜಿಪ್ ಪಡೆಯಲಿದ್ದೇನೆ. 41 00:02:50,560 --> 00:02:55,670 ಸಮಸ್ಯೆಯನ್ನು ನೀವು ಜಿಎಡಿಟ್ Name ರೀತಿಯ ಬಳಸಿಕೊಂಡು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಏರಲಿದೆ 42 00:02:55,670 --> 00:02:58,160 APPLIANCE ಅಥವಾ ಯಾವುದೇ ಒಳಗೆ. 43 00:02:58,160 --> 00:03:01,830 ನೀವು FAS ಸರ್ವರ್ ಮೇಲೆ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ. 44 00:03:01,830 --> 00:03:04,110 ಇದು ಕೇವಲ ಈ ಪಠ್ಯ ಇಂಟರ್ಫೇಸ್ ಎಂದು ವಿಶೇಷವೇನು. 45 00:03:04,110 --> 00:03:09,180 ನೀವು, ಅವರು ನಿಮಗೆ ಒಂದು ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ ತಿಳಿಯಲು ಒಂದೋ ಪ್ರಯತ್ನಿಸಬಹುದು. 46 00:03:09,180 --> 00:03:12,130 ಅವರು ನ್ಯಾನೋ ಹೊಂದಿರುತ್ತವೆ. 47 00:03:12,130 --> 00:03:14,990 ನ್ಯಾನೋ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲು ಬಹಳ ಸುಲಭ. 48 00:03:14,990 --> 00:03:19,470 ನಿಮ್ಮ ಬಾಣಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಟೈಪ್ ಮಾಡಬಹುದು. 49 00:03:19,470 --> 00:03:21,250 ಆದ್ದರಿಂದ ಹಾರ್ಡ್ ಅಲ್ಲ. 50 00:03:21,250 --> 00:03:24,720 ನೀವು ನಿಜವಾಗಿಯೂ ಅಲಂಕಾರಿಕ ಪಡೆಯಲು ಬಯಸಿದರೆ ನೀವು ಈಮಾಕ್ಸ್ GenericName ಬಳಸಬಹುದು 51 00:03:24,720 --> 00:03:29,850 ನಾನು ಈಮಾಕ್ಸ್ GenericName ಮುಚ್ಚಿ ಗೊತ್ತಿಲ್ಲದ ಕಾರಣ ಇದು ನಾನು ಬಹುಶಃ ತೆರೆಯಿತು ಮಾಡಬಾರದಾಗಿತ್ತು. 52 00:03:29,850 --> 00:03:32,760 ಕಂಟ್ರೋಲ್ ಎಕ್ಸ್, ಕಂಟ್ರೋಲ್ ಸಿ? ಹೌದು. 53 00:03:32,760 --> 00:03:35,310 ಅಥವಾ ನೀವು ನಾನು ಬಳಸಲು ಯಾವ ಇದು ಕಸುವು, ಬಳಸಬಹುದು. 54 00:03:35,310 --> 00:03:37,800 ಮತ್ತು ಆದ್ದರಿಂದ ಆ ನಿಮ್ಮ ಆಯ್ಕೆಗಳು ಹೀಗಿವೆ. 55 00:03:37,800 --> 00:03:43,830 ನೀವು ಮಾಡಲು ಬಯಸದಿದ್ದರೆ, ನೀವು ಸಹ, ನೀವು ನೋಡಿದರೆ manual.cs50.net-- 56 00:03:43,830 --> 00:03:45,410 ಓಹ್. 57 00:03:45,410 --> 00:03:49,920 ಒಂದು PC ಯಲ್ಲಿ, ನೀವು SSH, ಪುಟ್ಟಿ ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು 58 00:03:49,920 --> 00:03:51,940 ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ ಡೌನ್ಲೋಡ್ ಮಾಡಲಿಕ್ಕೆ ನೀವು ಇದು. 59 00:03:51,940 --> 00:03:55,460 ಒಂದು ಮ್ಯಾಕ್ ಮೇಲೆ, ನೀವು ಕೇವಲ ಡೀಫಾಲ್ಟ್ ಬಳಕೆಯ ಟರ್ಮಿನಲ್ ಅಥವಾ ನೀವು iTerm2 ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು 60 00:03:55,460 --> 00:03:58,490 ಇದು ಒಂದು ಉತ್ತಮ, ಅಲಂಕಾರಿಕ ಟರ್ಮಿನಲ್ ಹಾಗೆ. 61 00:03:58,490 --> 00:04:03,780 ನೀವು manual.cs50.net ಹೋಗಿ ನೀವು ನೋಟ್ಪಾಡ್ ಲಿಂಕ್ ನೋಡುತ್ತಾರೆ + + 62 00:04:03,780 --> 00:04:07,120 ಇದು ನೀವು ಒಂದು PC ಯಲ್ಲಿ ಬಳಸಬಹುದು ಏನು. 63 00:04:07,120 --> 00:04:13,340 ಇದು ನೋಟ್ಪಾಡ್ ನೀವು SFTP ಅನುಮತಿಸುತ್ತದೆ + +, ಇದು ಮೂಲತಃ SSH ಹೊಂದಿದೆ. 64 00:04:13,340 --> 00:04:17,750 ಎಂಬುದನ್ನು ನೀವೇ ಮಾಡಿ ಕಾಣಿಸುತ್ತದೆ, ಸ್ಥಳೀಯವಾಗಿ ನಿಮ್ಮ ಕಡತಗಳನ್ನು ಸಂಪಾದಿಸಲು 65 00:04:17,750 --> 00:04:20,670 ತದನಂತರ ನೀವು ಉಳಿಸಲು ಬಯಸುವ ಮಾಡಿದಾಗ, ಅದು, nice.fas ಉಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ 66 00:04:20,670 --> 00:04:23,670 ನೀವು ನಂತರ ಅವುಗಳನ್ನು ಚಾಲನೆ ಮಾಡಬಹುದು. 67 00:04:23,670 --> 00:04:26,880 ಮತ್ತು ಮ್ಯಾಕ್ ಮೇಲೆ ಸಮಾನ TextWrangler ಏರಲಿದೆ. 68 00:04:26,880 --> 00:04:28,760 ಆದ್ದರಿಂದ ನೀವು ಒಂದೇ ವಿಷಯವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. 69 00:04:28,760 --> 00:04:32,800 ಇದು ನೀವು ಸ್ಥಳೀಯವಾಗಿ ಕಡತಗಳನ್ನು ಸಂಪಾದಿಸಲು ಮತ್ತು nice.fas ಅವರನ್ನು ಉಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ 70 00:04:32,800 --> 00:04:35,730 ನೀವು ನಂತರ ಅವುಗಳನ್ನು ಚಾಲನೆ ಮಾಡಬಹುದು. 71 00:04:35,730 --> 00:04:40,400 ಎಂದಾದರೂ ಒಂದು APPLIANCE ಇಲ್ಲದೆ ಸಿಕ್ಕಿಕೊಂಡುಬಿಟ್ಟಿರುತ್ತೇವೆ ಆದ್ದರಿಂದ, ನೀವು ಈ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿವೆ 72 00:04:40,400 --> 00:04:44,230 ನಿಮ್ಮ ಸಮಸ್ಯೆ ಸೆಟ್ ಮಾಡಲು ಸಹ. 73 00:04:44,230 --> 00:04:48,250 ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ ಎಂದು ಎಂದು ಹೋಗುತ್ತದೆ 74 00:04:48,250 --> 00:04:51,580 nice.fas ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ. 75 00:04:51,580 --> 00:04:55,970 ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು - 76 00:04:55,970 --> 00:04:58,470 ನಾನು ಈ ಹಂತದಲ್ಲಿ ಅಗತ್ಯವಿದೆ ಯೋಚಿಸುವುದಿಲ್ಲ. 77 00:04:58,470 --> 00:05:03,270 ನೀವು, CS50 ಗ್ರಂಥಾಲಯದ ಡೌನ್ಲೋಡ್ ಮತ್ತು nice.fas ಅದನ್ನು ನಕಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ 78 00:05:03,270 --> 00:05:07,450 ಅಥವಾ ನಾನು ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಹೇಗಾದರೂ ಇನ್ನೆಂದಿಗೂ ಬಳಸಬೇಡಿ ಭಾವಿಸುತ್ತೇನೆ. 79 00:05:07,450 --> 00:05:12,720 ನಾವು ಅಥವಾ, ನೀವು ಬಾರಿಗೆ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಎಂದು ಮಾಡಬಹುದು 80 00:05:12,720 --> 00:05:18,480 ಹೇಗಾದರೂ CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಅಳವಡಿಕೆಗಳು. 81 00:05:18,480 --> 00:05:21,370 ಆದ್ದರಿಂದ ಒಂದು ನಿರ್ಬಂಧದ ಹೆಚ್ಚು ಇರಬಾರದು. 82 00:05:21,370 --> 00:05:23,710 ಮತ್ತು ಆ ಸ್. 83 00:05:26,460 --> 00:05:29,820 >> ನಾನು ಈಗ APPLIANCE ಮರಳಿ ಹೋಗುತ್ತೇನೆ; ನಾವು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಎಲ್ಲವನ್ನು ಮಾಡುತ್ತೇನೆ. 84 00:05:29,820 --> 00:05:37,510 ನನ್ನ ಇಮೇಲ್ ಹೇಳಿದರು ನಂತಹ, ಆರಂಭದಲ್ಲಿ, ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, 85 00:05:37,510 --> 00:05:43,620 ನೀವು ವೀಕ್ಷಿಸಲು ಭಾವಿಸಲಾಗಿತ್ತು ಸಣ್ಣ ಒಂದು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಹೊಂದಿವೆ. 86 00:05:43,620 --> 00:05:51,980 ನಾವು ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ & ಪೈಪ್ಸ್ ಮತ್ತು ಈ ಮೂರು ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ. 87 00:05:51,980 --> 00:05:56,070 >> ಯಾವ ಸ್ಟ್ರೀಮ್ ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು printf ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬರೆಯುವಿರಾ? 88 00:05:56,070 --> 00:05:59,130 ಸ್ಟ್ರೀಮ್ ಆದ್ದರಿಂದ. ಒಂದು ಸ್ಟ್ರೀಮ್ ಎಂದರೇನು? 89 00:06:06,520 --> 00:06:15,100 ಇದು ಕೆಲವು ಆದಂತೆ ಒಂದು ಸ್ಟ್ರೀಮ್ ಮೂಲತಃ ಹೊಂದಿದೆ - 90 00:06:15,100 --> 00:06:21,450 ಇದು 1 ಸೆ 0 ಸೆ ಮತ್ತು ಮೂಲವಾಗಿ ಈಸ್ ನಾಟ್. 91 00:06:21,450 --> 00:06:24,920 ಇಲ್ಲಿ ಕೇಳುವ ಅವರ ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಆಗಿದೆ. 92 00:06:24,920 --> 00:06:27,250 ಮತ್ತು ಆದ್ದರಿಂದ ಮಾನದಂಡಾತ್ಮಕ ಔಟ್ ಒಂದು ಸ್ಟ್ರೀಮ್ ನೀವು ಅದನ್ನು ಬರೆಯುತ್ತೇನೆ 93 00:06:27,250 --> 00:06:30,940 ಅದನ್ನು ತೆರೆಯ ಮೇಲೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. 94 00:06:30,940 --> 00:06:36,860 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್, ಸ್ಟ್ರೀಮ್ ಮೂಲಕ, ನೀವು ಕೇವಲ 1 ಸೆ ಮತ್ತು ಅದರ 0 ಸೆ ಬರೆಯಲು ಅರ್ಥ 95 00:06:36,860 --> 00:06:40,220 ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ಇತರೆ ಕೊನೆಯಲ್ಲಿ ಕೇವಲ ಸ್ಟ್ರೀಮ್ನ ಓದುತ್ತದೆ. 96 00:06:40,220 --> 00:06:43,540 ಇದು ಕೇವಲ 1 ಸೆ 0 ಸೆ ಮತ್ತು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನ. 97 00:06:43,540 --> 00:06:45,570 ನೀವು ಹೊಳೆಗಳು ಬರೆಯಬಹುದು ಅಥವಾ ನೀವು ತೊರೆಗಳಿಂದ ಓದಬಹುದು 98 00:06:45,570 --> 00:06:47,950 ಸ್ಟ್ರೀಮ್ ವಾಸ್ತವವಾಗಿ ಎನ್ನುವುದನ್ನು ಅವಲಂಬಿಸಿ. 99 00:06:47,950 --> 00:06:52,800 ಇತರ ಎರಡು ಡೀಫಾಲ್ಟ್ ತೊರೆಗಳು ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ ಮಾನಕವಾಗಿಬಿಟ್ಟಿದೆ. 100 00:06:52,800 --> 00:06:57,540 ನೀವು GetString ಇಲ್ಲ ಬಂದಾಗಲೆಲ್ಲಾ ಗುಣಮಟ್ಟದ, ಇದು ನೀವು ಇನ್ಪುಟ್ ವಿಷಯ ಕಾಯುವ ನ. 101 00:06:57,540 --> 00:07:01,570 ಆದ್ದರಿಂದ ನೀವು ಕಾಯುತ್ತಿರದಿದ್ದರೆ, ನಿಜವಾಗಿ, ಗುಣಮಟ್ಟದ ಮೇಲೆ ಕಾಯುವ ವಿಶೇಷವೇನು 102 00:07:01,570 --> 00:07:04,880 ಇದು ನೀವು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ನೀವು ಪಡೆಯಿರಿ ನಿಜವಾಗಿಯೂ ಹೊಂದಿದೆ. 103 00:07:04,880 --> 00:07:07,530 ನೀವು ಲಾಗಿನ್ ಆಗಿ ಪ್ರಮಾಣಿತ ಟೈಪ್ ನೀವು 104 00:07:07,530 --> 00:07:10,050 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ, ಪ್ರಮಾಣಿತ ಔಟ್ ಗೆ ಮೂಲತಃ ಸಮನಾಗಿರುತ್ತದೆ 105 00:07:10,050 --> 00:07:13,280 ನೀವು ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿಸಲು ಆದರೆ ಇದು, ಆ ವಿಶೇಷ ಇಲ್ಲಿದೆ 106 00:07:13,280 --> 00:07:16,770 ನೀವು ಮಾತ್ರ ಆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಭಾವಿಸಲಾದ ನೀವು 107 00:07:16,770 --> 00:07:20,200 ಆದ್ದರಿಂದ ನೀವು ತೆರೆಯಲ್ಲಿ ಮುದ್ರಿತವಾಗಬಹುದು ನಿಯಮಿತ ಸಂದೇಶಗಳನ್ನು ಬೇರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ 108 00:07:20,200 --> 00:07:24,560 ಅವರು ಪ್ರಮಾಣಿತ ಔಟ್ ಅಥವಾ ಪ್ರಮಾಣಿತ ದೋಷ ಹೋದರು ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ವಿರುದ್ಧ. 109 00:07:24,560 --> 00:07:28,660 ತುಂಬಾ ಕಡತಗಳು. 110 00:07:28,660 --> 00:07:32,440 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್, ಸ್ಟ್ಯಾಂಡರ್ಡ್, ಮತ್ತು ಸಾಮಾನ್ಯ ದೋಷ, ಕೇವಲ ವಿಶೇಷ ವಾಹಿನಗಳೆಂದರೆ 111 00:07:32,440 --> 00:07:36,810 ಆದರೆ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಕಡತ, ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆದಾಗ, ಅದು ಬೈಟ್ಗಳು ಒಂದು ಸ್ಟ್ರೀಮ್ ಆಗುತ್ತದೆ 112 00:07:36,810 --> 00:07:40,740 ಅಲ್ಲಿ ನೀವು ಆ ರಾಶಿಯಿಂದ ಓದಬಹುದು. 113 00:07:40,740 --> 00:07:47,770 ನೀವು, ಬಹುತೇಕ ಭಾಗ, ಕೇವಲ ಬೈಟ್ಗಳು ಪ್ರವಾಹವು ಒಂದು ಕಡತ ನಗರದ. 114 00:07:47,770 --> 00:07:51,190 ಆದ್ದರಿಂದ ಯಾವ ಹೊಳೆಗಳು ಅವರು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬರೆದು? ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್. 115 00:07:51,190 --> 00:07:56,980 >> > ಮತ್ತು >> ನಡುವಿನ ಭಿನ್ನತೆ ಏನು? 116 00:07:58,140 --> 00:08:03,710 ಯಾರಾದರೂ ಮೊದಲೇ ವಿಡಿಯೋ ವೀಕ್ಷಿಸಲು ಮಾಡಿದ್ದೀರಾ? ಸರಿ. 117 00:08:03,710 --> 00:08:10,960 >, ನೀವು ಫೈಲ್ಗಳನ್ನು ಆಗಿ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಹೇಗೆ ಎಂದು ಹೋಗುತ್ತದೆ 118 00:08:10,960 --> 00:08:15,240 ಮತ್ತು >> ಸಹ, ಕಡತಗಳು ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶಿಸಲು ಹೋಗುತ್ತದೆ 119 00:08:15,240 --> 00:08:17,820 ಆದರೆ ಬದಲಿಗೆ ಕಡತವನ್ನು ಸೇರಿಸಲು ಹೋಗುವುದಿಲ್ಲ. 120 00:08:17,820 --> 00:08:23,430 ಉದಾಹರಣೆಗೆ, ಈಗ ನಾನು ಇಲ್ಲಿಯೇ dict ಹೊಂದಿರುತ್ತವೆ ಸಂಭವಿಸಬಹುದು ಹೇಳುತ್ತಾರೆ 121 00:08:23,430 --> 00:08:27,020 ಮತ್ತು dict ಒಳಗೆ ಮಾತ್ರ ವಿಷಯವನ್ನು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ನಾಯಿ. 122 00:08:27,020 --> 00:08:31,530 ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಹೊಂದಿರುವ ಒಂದು ಆಜ್ಞೆಯನ್ನು, ಬೆಕ್ಕು ಆಗಿದೆ 123 00:08:31,530 --> 00:08:34,539 ಇದು ಕೇವಲ ಒಂದು ಕಡತದಲ್ಲಿ ಎಂಬುದನ್ನು ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 124 00:08:34,539 --> 00:08:40,679 ಹಾಗಾಗಿ ಬೆಕ್ಕು dict ಹೇಳುತ್ತಾರೆ, ಇದು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ನಾಯಿ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು. ಎಲ್ಲಾ ಬೆಕ್ಕು ಮಾಡುತ್ತದೆ ಇಲ್ಲಿದೆ. 125 00:08:40,679 --> 00:08:46,280 ಅದು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ಶ್ವಾನ ಔಟ್ ಗುಣಮಟ್ಟದ ಮುದ್ರಿತ ಎಂದರ್ಥ. 126 00:08:46,280 --> 00:08:53,240 ನಾನು ಬದಲಿಗೆ ಕಡತ ಎಂದು ಮರುನಿರ್ದೇಶಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಬಳಸಿ> ಮತ್ತು ಕಡತ ಯಾವುದೇ ಅದನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. 127 00:08:53,240 --> 00:08:56,460 ನಾನು ಫೈಲ್ ಫೈಲ್ ಕರೆ ಮಾಡುತ್ತೇವೆ. 128 00:08:56,460 --> 00:09:00,320 ನಾನು LS ಆದ್ದರಿಂದ ಈಗ, ನಾನು ಕಡತ ಎಂಬ ಹೊಸ ಕಡತ ಹೊಂದಿರುತ್ತವೆ ನೋಡುತ್ತಾರೆ. 129 00:09:00,320 --> 00:09:05,700 ನಾನು ಅದನ್ನು ತೆರೆಯಲು ಮತ್ತು, ಒಂದು ವೇಳೆ ಬೆಕ್ಕು ಆಜ್ಞಾ ಸಾಲಿನ ಮಟ್ಟದಲ್ಲಿದೆ ನಿಖರವಾಗಿ ಏನು ಹೊಂದಿದ್ದರೆ ಹೋಗುವುದಿಲ್ಲ. 130 00:09:05,700 --> 00:09:11,040 ನಾನು ಮತ್ತೆ ಹಾಗೆ ಆದ್ದರಿಂದ ಈಗ, ಆಗ ಫೈಲ್ ಆಗಿ ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶಿಸಲು ವಿಶೇಷವೇನು 131 00:09:11,040 --> 00:09:13,930 ಮತ್ತು ನಾನು ಅದೇ ನಿಖರ ವಸ್ತು ಹೊಂದಿರುವ ಪಡೆಯಲಿದ್ದೇನೆ. 132 00:09:13,930 --> 00:09:17,910 ಆದ್ದರಿಂದ ತಾಂತ್ರಿಕವಾಗಿ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ನಾವು ಯಾವ overrode. 133 00:09:17,910 --> 00:09:22,970 ಮತ್ತು ನಾನು dict ಬದಲಾಯಿಸಲು ನಾವು ನೋಡುತ್ತಾರೆ, ನಾನು ನಾಯಿ ತೆಗೆದುಕೊಂಡರು. 134 00:09:22,970 --> 00:09:29,980 ಈಗ ಮತ್ತೆ ಕಡತ ನಾವು ಬೆಕ್ಕು dict ವೇಳೆ, ನಾವು ನಾಯಿ ತೆಗೆದು ಹೊಸ ಆವೃತ್ತಿ ಹೊಂದಿರುವ ನೀನು. 135 00:09:29,980 --> 00:09:32,400 ಆದ್ದರಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಅತಿಕ್ರಮಿಸುತ್ತದೆ. 136 00:09:32,400 --> 00:09:36,640 ನಾವು >> ಬಳಸುವ ಬದಲು, ಇದು ಕಡತ ಸೇರಿಸಲು ಹೋಗುವುದಿಲ್ಲ. 137 00:09:36,640 --> 00:09:40,860 ಈಗ, ಕಡತವನ್ನು ತೆರೆಯುವ, ನಾವು ಎರಡು ಮುದ್ರಿತ ಕೇವಲ ಒಂದೇ ನೋಡಬಹುದು 138 00:09:40,860 --> 00:09:44,920 ಒಮ್ಮೆ ಇರಲಿಲ್ಲ ಏಕೆಂದರೆ, ಆಗ ಮೂಲ ಸೇರಿಸಲಾಗಿದೆ. 139 00:09:44,920 --> 00:09:48,130 ಇದರಿಂದ ಆ ಯಾವ> ಮತ್ತು >> ಹಾಗೆ. 140 00:09:48,130 --> 00:09:50,580 ಮುಂದಿನ ಒಂದು ಕೇಳಲು ಇಲ್ಲ - ಇದು ಸುಮಾರು ಕೇಳುವುದಿಲ್ಲ. 141 00:09:50,580 --> 00:09:59,050 >> ನಾವು ಇತರ ಒಂದು ಪ್ರಮಾಣಿತ ಔಟ್ ಪುನರ್ನಿರ್ದೇಶನಗಳು <ವೇಳೆ ಇದು,>, ಆಗಿದೆ 142 00:09:59,050 --> 00:10:01,970 <ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಸೈನ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಏರಲಿದೆ 143 00:10:01,970 --> 00:10:12,050 ನಾವು ಒಂದು ಉದಾಹರಣೆಗೆ ಹೊಂದಿದ್ದರೆ ನೋಡೋಣ. 144 00:10:14,750 --> 00:10:16,930 ನಾನು ಒಂದು ನೈಜ ಕ್ಷಿಪ್ರ ಬರೆಯಬಹುದು. 145 00:10:17,870 --> 00:10:25,700 ಯಾವುದೇ ಕಡತ, hello.c ನೋಡೋಣ. 146 00:10:56,060 --> 00:10:59,070 ತುಲನಾತ್ಮಕವಾಗಿ ಸಂಬಂಧ ಕಡತ. 147 00:10:59,070 --> 00:11:03,570 ನಾನು ಕೇವಲ ಪ್ರವೇಶಿಸಿತು ಸ್ಟ್ರಿಂಗ್ ಎಂಬ ಏನೇ "ಹಲೋ" ಮುದ್ರಣದ ನಂತರ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಮತ್ತು ನಾನು. 148 00:11:03,570 --> 00:11:07,990 ಆದ್ದರಿಂದ ನಿನ್ನ ನಿನ್ನ ತದನಂತರ ಮಾಡಿ. /. 149 00:11:07,990 --> 00:11:10,720 ಈಗ, ಏನೋ ನಮೂದಿಸಿ ನನ್ನನ್ನು ಪ್ರೇರೇಪಿಸಿತು ವಿಶೇಷವೇನು 150 00:11:10,720 --> 00:11:15,070 ಇದು ಸೈನ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ನಮೂದಿಸಲಾಗುವ ವಿಷಯಗಳನ್ನು ಮೇಲೆ ಕಾಯುವ ನ ಅರ್ಥ 151 00:11:15,070 --> 00:11:20,450 ಆದ್ದರಿಂದ ನಾವು ರಾಬ್, ಹಲೋ ಹೇಳಲು ನೀನು ಸೈನ್ ನಾನು ಪ್ರಮಾಣಿತ ಭಾಷೆಗೆ ಬಯಸುವ ಯಾವುದೇ ನಮೂದಿಸಿ! 152 00:11:20,450 --> 00:11:23,310 ಅದು, ಹಲೋ ಔಟ್ ಗುಣಮಟ್ಟದ ರಾಬ್ ಮುದ್ರಿಸುವ ನ! 153 00:11:23,310 --> 00:11:28,860 ನಾನು. / ನಿನ್ನ ತದನಂತರ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಮಾಡಿದರೆ 154 00:11:30,740 --> 00:11:34,310 ಈಗ ನೀವು ಕೇವಲ ಒಂದು ಕಡತದಿಂದ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. 155 00:11:34,310 --> 00:11:41,720 ನಾನು ಕೆಲವು ಫೈಲ್ ಸಂದೇಶ ನೀಡಿದರು ಮತ್ತು ನಾನು, ರಾಬ್ ಪುಟ್ ಆದ್ದರಿಂದ 156 00:11:41,720 --> 00:11:52,300 ನಾನು ನಿನ್ನ ರನ್ ಮತ್ತು ಆಗ ಫೈಲ್ ಸಂದೇಶ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ. / ಹಲೋ, ಇದು ರಾಬ್, ಹಲೋ ಹೇಳಲು ಹೋಗುವುದಿಲ್ಲ! ತಕ್ಷಣವೇ. 157 00:11:52,300 --> 00:11:57,160 ಇದು ಮೊದಲ GetString ಗೆ ಪಡೆಯುತ್ತದೆ ಮತ್ತು, ಗುಣಮಟ್ಟದ ಮೇಲೆ ಕಾಯುವ ಸಂದರ್ಭದಲ್ಲಿ 158 00:11:57,160 --> 00:12:01,730 ಗುಣಮಟ್ಟದ ಪ್ರವೇಶಿಸಿತು ನಿಮಗೆ ಅಕ್ಷಾಂಶ ಕೀಬೋರ್ಡ್ ಮೇಲೆ ಕಾಯುವ ಇನ್ನು ಮುಂದೆ. 159 00:12:01,730 --> 00:12:05,980 ಬದಲಾಗಿ, ನಾವು ಫೈಲ್ ಸಂದೇಶ ನಿಂದ ಓದಲು ಗುಣಮಟ್ಟದ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ ಮಾಡಿದ್ದಾರೆ. 160 00:12:05,980 --> 00:12:10,290 ಮತ್ತು ಆದ್ದರಿಂದ, ಕೇವಲ ಲೈನ್ ರಾಬ್ ಇದು ಕಡತ ಸಂದೇಶ ನಿಂದ ಓದಲು ವಿಶೇಷವೇನು 161 00:12:10,290 --> 00:12:13,380 ನಂತರ ಅದನ್ನು ಹಲೋ, ರಾಬ್ ಮುದ್ರಿಸಲು ಹೋಗುವುದಿಲ್ಲ! 162 00:12:13,380 --> 00:12:18,180 ನಾನು ಬಯಸಿದರೆ, ನಾನು ಸಹ ಇಲ್ಲ. / ನಿನ್ನ <ಸಂದೇಶ 163 00:12:18,180 --> 00:12:21,500 ತದನಂತರ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎಂದು ಹಲೋ ಇದು ಇದು ಮುದ್ರಣ, ರಾಬ್! 164 00:12:21,500 --> 00:12:24,700 ನಾನು ಅದರ ಸ್ವಂತ ಫೈಲ್ ಆಗಿ ಆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. 165 00:12:24,700 --> 00:12:29,790 ನಾನು ನಿನ್ನ ಕಡತ ಕರೆ ಮಾಡುತ್ತೇವೆ - ಯಾವುದೇ, ನಾನು ತಿನ್ನುವೆ, ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಏಕೆಂದರೆ - txt2. 166 00:12:29,790 --> 00:12:40,150 ಈಗ, txt2 ಹಲೋ ಎಂದು ಹೋಗುವ ಇದು. / ನಿನ್ನ <ಸಂದೇಶ, ರಾಬ್ ಉತ್ಪತ್ತಿಯು ಮಾಡಲಿಕ್ಕೆ ಇದೆ! 167 00:12:41,370 --> 00:12:43,520 >> ಪ್ರಶ್ನೆಗಳು? 168 00:12:45,900 --> 00:12:49,090 >> ಸರಿ. ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಪೈಪ್ಲೈನಿನ. 169 00:12:49,090 --> 00:12:53,510 ಪೈಪ್ ಪುನರ್ನಿರ್ದೇಶನ ಕೊನೆಯ ಘಟಕ ಇವೆ. 170 00:12:53,510 --> 00:12:58,750 >> ಓಹ್. ನಾನು ಪುನರ್ನಿರ್ದೇಶನ ಮತ್ತೊಂದು ಘಟಕ ವೇಳೆ ಬದಲಿಗೆ ಊಹಿಸಿದರು> ನೀವು 2 ಮಾಡಲು> 171 00:12:58,750 --> 00:13:01,070 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ನ. 172 00:13:01,070 --> 00:13:06,280 ಏನೋ ಸ್ಥಿರದೋಷ ಹೋದರು ಆದ್ದರಿಂದ ಅದನ್ನು txt2 ಜಾರಿಗೆ ಪಡೆಯುತ್ತೀರಿ ಎಂದು. 173 00:13:06,280 --> 00:13:12,480 ಆದರೆ 2> ಹೋದರೆ ಗಮನಿಸಿ, ನಂತರ ಅದು ಇನ್ನೂ ರಾಬ್, ಹಲೋ ಮುದ್ರಿಸುವ ನ! ಆಜ್ಞಾ ಸಾಲಿನ 174 00:13:12,480 --> 00:13:18,600 ನಾನು ಕೇವಲ ಪ್ರಮಾಣಿತ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಭಾವಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ, ನಾನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತಿಲ್ಲ ನುಡಿದರು. 175 00:13:18,600 --> 00:13:22,210 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. 176 00:13:24,210 --> 00:13:27,080 ನೀವು ನಿಜವಾಗಿಯೂ ಗುಣಮಟ್ಟದ ದೋಷದ ಬರೆಯಲು ಇಚ್ಛಿಸುತ್ತೇನೆ, ವೇಳೆ 177 00:13:27,080 --> 00:13:35,080 ನಂತರ ನಾನು stderr ಗೆ fprintf ಈ ಬದಲಾಯಿಸಬಹುದು. 178 00:13:35,080 --> 00:13:37,850 ಆದ್ದರಿಂದ printf, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪ್ರಮಾಣಿತ ಔಟ್ ಗೆ ಮುದ್ರಿಸುತ್ತದೆ. 179 00:13:37,850 --> 00:13:41,720 ನಾನು ಕೈಯಿಂದ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷದ ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ, ನಂತರ ನಾನು fprintf ಬಳಸಲು ಹೊಂದಿವೆ 180 00:13:41,720 --> 00:13:45,010 ಮತ್ತು ನಾನು ಮುದ್ರಿಸಲು ಯಾವ ಸೂಚಿಸಿ. 181 00:13:45,010 --> 00:13:49,720 ಬದಲಿಗೆ ನಾನು fprintf stdout ಮಾಡಿದರೆ, ನಂತರ printf ಗೆ ಮೂಲತಃ ಸಮನಾಗಿದೆ. 182 00:13:49,720 --> 00:13:55,530 ಆದರೆ fprintf ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷದ. 183 00:13:57,790 --> 00:14:03,650 ಈಗ, ನಾನು txt2 ಈ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ, ಹಲೋ, ರಾಬ್! ಇನ್ನೂ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಮುದ್ರಿತ ಗೆಟ್ಟಿಂಗ್ 184 00:14:03,650 --> 00:14:08,270 ಇದು ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿತ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಮತ್ತು ನಾನು ಮಾತ್ರ ಪ್ರಮಾಣಿತ ಔಟ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ನಾನು ರಿಂದ. 185 00:14:08,270 --> 00:14:16,420 ನಾನು ಈಗ ಸಾಮಾನ್ಯ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ, ಈಗ ಮುದ್ರಿತ ಆಗಲಿಲ್ಲ, ಮತ್ತು txt2, ಹಲೋ ರಾಬ್ ಏರಲಿದೆ! 186 00:14:16,420 --> 00:14:21,910 ಈಗ, ನೀವು ಸಾಮಾನ್ಯ ದೋಷ ನಿಮ್ಮ ನಿಜವಾದ ದೋಷಗಳನ್ನು ಮುದ್ರಿಸಬಹುದು 187 00:14:21,910 --> 00:14:24,720 ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ನಿಮ್ಮ ನಿಯಮಿತ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. 188 00:14:24,720 --> 00:14:31,420 ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆದ್ದರಿಂದ, ನೀವು 2 ನಿನ್ನ ಈ ರೀತಿಯ ಚಾಲನೆ. / ಮಾಡಬಹುದು> 189 00:14:31,420 --> 00:14:33,800 ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮ, ಸಾಮಾನ್ಯವಾಗಿ ರನ್ ಹೋಗಿ ಹೀಗೆ 190 00:14:33,800 --> 00:14:38,400 ಆದರೆ ನೀವು ಪಡೆಯಲು ಯಾವುದೇ ದೋಷ ಸಂದೇಶಗಳನ್ನು, ನಿಮ್ಮ ದೋಷ ಲಾಗ್ ನಂತರ ಪರಿಶೀಲಿಸಬಹುದು 191 00:14:38,400 --> 00:14:44,500 ದೋಷಗಳನ್ನು ಆದ್ದರಿಂದ, ಮತ್ತು ನಂತರ ನೋಡಿ ಮತ್ತು ನಿಮ್ಮ ದೋಷಗಳನ್ನು ಕಡತ ಸಂಭವಿಸಿದ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. 192 00:14:45,200 --> 00:14:47,540 >> ಪ್ರಶ್ನೆಗಳು? 193 00:14:47,540 --> 00:14:58,070 >> ಕಳೆದ ಒಂದು ನೀವು ಒಂದು ಆಜ್ಞೆಯನ್ನು ಮಾನದಂಡದ ಔಟ್ ಮೂಲಕ ನಗರದ ಇದರಲ್ಲಿ ಪೈಪ್, ಆಗಿದೆ 194 00:14:58,070 --> 00:15:01,210 ಮತ್ತು ಮುಂದಿನ ಆಜ್ಞೆಯು ಗುಣಮಟ್ಟದ ಮಾಡುವ. 195 00:15:01,210 --> 00:15:05,570 ಉದಾಹರಣೆ ಇಲ್ಲಿ ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಿಷಯ ಇದೆ 196 00:15:05,570 --> 00:15:11,840 ಕೇವಲ ನಾನು ಅದರ ಚರ್ಚೆಯಂತೆ ಪುಟ್ ಯಾವುದೇ ಪ್ರತಿಧ್ವನಿಸುವಂತೆ ಹೋಗುತ್ತದೆ. ನಾನು ಪುಟ್ ಉಲ್ಲೇಖಗಳನ್ನು ಮಾಡುವುದಿಲ್ಲ. 197 00:15:11,840 --> 00:15:16,150 ಪ್ರತಿಧ್ವನಿ blah, blah, blah ಕೇವಲ blah, blah, blah ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 198 00:15:16,150 --> 00:15:20,600 ಮೊದಲು, ನಾನು ಹೇಳಿದ ನಾನು ಒಂದು ಸಂದೇಶ ಫೈಲ್ ಆಗಿ ರಾಬ್ ಹಾಕಲು ಹೊಂದಿತ್ತು 199 00:15:20,600 --> 00:15:28,830 ನಾನು ಮಾತ್ರ ಸಂದೇಶ ಕಡತಗಳನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಬದಲಿಗೆ ಏಕೆಂದರೆ, / ನಾನು ರಾಬ್ ಪ್ರತಿಧ್ವನಿಸಿದವು ವೇಳೆ 200 00:15:28,830 --> 00:15:35,520 ತದನಂತರ ಪೈಪ್ ಇದನ್ನು. / ಹಲೋ, ಸಹ ವಿಷಯ ಅದೇ ರೀತಿಯ ಮಾಡುತ್ತದೆ. 201 00:15:35,520 --> 00:15:39,160 ಈ ಆಜ್ಞೆಯ ಉತ್ಪತ್ತಿಯು, ಪ್ರತಿಧ್ವನಿ ರಾಬ್, ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದೆ 202 00:15:39,160 --> 00:15:43,610 ಮತ್ತು ಇನ್ಪುಟ್ ಆಗಿ ಬಳಸಿಕೊಂಡು. / ನಿನ್ನ. 203 00:15:44,790 --> 00:15:49,560 ನೀವು ಮೊದಲು ಫೈಲ್ ಆಗಿ ಪ್ರತಿಧ್ವನಿ ರಾಬ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಇದು ನಗರದ 204 00:15:49,560 --> 00:15:54,160 ತದನಂತರ. / ನಿನ್ನ ಆ ಫೈಲ್ ಆಗಿ ಇನ್ಪುಟ್ ಕೇವಲ outputted ಎಂದು. 205 00:15:54,160 --> 00:15:57,850 ಆದರೆ ಚಿತ್ರದ ತಾತ್ಕಾಲಿಕ ಕಡತ ಔಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. 206 00:16:01,890 --> 00:16:04,460 >> ಆ ಪ್ರಶ್ನೆಗಳು? 207 00:16:04,460 --> 00:16:07,150 >> ಮುಂದಿನ ಪ್ರಶ್ನೆ ಈ ಒಳಗೊಂಡಿರುತ್ತವೆ ಹೋಗುವ ಇದೆ. 208 00:16:07,150 --> 00:16:15,310 ಏನು ಪೈಪ್ಲೈನ್ ನೀವು names.txt ಎಂಬ ಕಡತದಲ್ಲಿ ಅನನ್ಯ ಹೆಸರುಗಳು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ಬಳಸಬಹುದಾದ? 209 00:16:15,310 --> 00:16:24,160 ನಾವು ಇಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಆಜ್ಞೆಗಳನ್ನು ಅನನ್ಯ, ಆದ್ದರಿಂದ uniq, ತದನಂತರ WC ಇವೆ. 210 00:16:24,160 --> 00:16:28,840 ನೀವು, ವಾಸ್ತವವಾಗಿ ಆ ಏನು ನೋಡಲು ಮನುಷ್ಯ uniq ಮಾಡಬಹುದು 211 00:16:28,840 --> 00:16:34,840 ಮತ್ತು ಇದು ಕೇವಲ ಇನ್ಪುಟ್ ಪಕ್ಕದ ತಾಳೆಯಾಗುವ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಹೋಗುವುದಿಲ್ಲ. 212 00:16:34,840 --> 00:16:40,690 ಮತ್ತು ಮನುಷ್ಯ WC ಹೊಸಸಾಲು, ಪದ, ಮತ್ತು ಪ್ರತಿ ಕಡತಕ್ಕೆ ಬೈಟ್ ಎಣಿಕೆಗಳು ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 213 00:16:40,690 --> 00:16:43,760 ಮತ್ತು ನಾವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಕಳೆದ ಒಂದು ತೆರನಾದ 214 00:16:43,760 --> 00:16:47,410 ಇದು ಕೇವಲ ಸಂದೇಶ ಕಡತ ಸಾಲುಗಳನ್ನು ವಿಂಗಡಿಸಲು ಹೋಗುತ್ತದೆ. 215 00:16:47,410 --> 00:16:58,080 ನಾನು ಕೆಲವು ಸಂದೇಶ ಫೈಲ್, names.txt, ಮಾಡಲು ಮತ್ತು ರಾಬ್, ಟಾಮಿ, ಜೋಸೆಫ್, ಟಾಮಿ, ಜೋಸೆಫ್, ಆರ್ಜೆ, ರಾಬ್, ದ ವೇಳೆ 216 00:16:58,080 --> 00:17:03,910 ಏನು ನಾನು ಇಲ್ಲಿ ಮಾಡಲು ಬಯಸುವುದು ಈ ಕಡತದಲ್ಲಿ ಅನನ್ಯ ಹೆಸರುಗಳು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ಆಗಿದೆ. 217 00:17:03,910 --> 00:17:08,750 ಆದ್ದರಿಂದ ಉತ್ತರ ಏನಿರಬಹುದು? >> [ವಿದ್ಯಾರ್ಥಿ] 4. >> ಹೌದು. 218 00:17:08,750 --> 00:17:13,780 ಇದು ರಾಬ್, ಟಾಮಿ, ಜೋಸೆಫ್ ರಿಂದ 4, ಆರ್ಜೆ ಈ ಕಡತದಲ್ಲಿ ಮಾತ್ರ ಅನನ್ಯ ಹೆಸರುಗಳು. 219 00:17:13,780 --> 00:17:20,180 ಮೊದಲ ಹಂತದ, ನಾನು names.txt ಮೇಲೆ ಪದಗಳ ಎಣಿಕೆ ಮಾಡಿದರೆ, 220 00:17:20,180 --> 00:17:24,290 ಈ ವಾಸ್ತವವಾಗಿ ನನಗೆ ಎಲ್ಲವನ್ನೂ ಹೇಳುವ ಇದೆ. 221 00:17:24,290 --> 00:17:32,560 ಈ ವಾಸ್ತವವಾಗಿ ಮುದ್ರಣ ಹೊಂದಿದೆ - ಹೊಸ ಸಾಲುಗಳನ್ನು, ಪದಗಳು ಮತ್ತು ಬೈಟ್ ಎಣಿಕೆ - ಮ್ಯಾನ್ WC, ನೋಡೋಣ. 222 00:17:32,560 --> 00:17:38,270 ನಾನು ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಗಮನ ನೀಡುವ ವೇಳೆ, ನಂತರ ನಾನು WC-L names.txt ಮಾಡಬಹುದು. 223 00:17:41,730 --> 00:17:44,300 ಆದ್ದರಿಂದ ಹಂತ 1. 224 00:17:44,300 --> 00:17:50,510 Names.txt ಕೇವಲ ಎಲ್ಲಾ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ ಆದರೆ ನಾನು, WC-L names.txt ಬಯಸುವುದಿಲ್ಲ 225 00:17:50,510 --> 00:17:54,170 ಮತ್ತು ನಾನು ಯಾವುದೇ ಅನನ್ಯ ಬಿಡಿಗಳ ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಯಸುವ. 226 00:17:54,170 --> 00:18:01,200 ನಾನು uniq names.txt ಮಾಡಲು ಆದ್ದರಿಂದ, ಆ ಸಾಕಷ್ಟು ನಾನು ಯಾವ ನನಗೆ ನೀಡುವುದಿಲ್ಲ 227 00:18:01,200 --> 00:18:03,760 ನಕಲು ಹೆಸರುಗಳು ಇನ್ನೂ ಕಾರಣ. 228 00:18:03,760 --> 00:18:07,690 ಏಕೆ ಎಂದು? ಏಕೆ uniq ನಾನು ಬಯಸುವ ಏನು ಇಲ್ಲ? 229 00:18:07,690 --> 00:18:10,500 [ವಿದ್ಯಾರ್ಥಿ] ನಕಲುಗಳನ್ನು ಅಲ್ಲ [ಕೇಳಿಸುವುದಿಲ್ಲ] >> ಹೌದು. 230 00:18:10,500 --> 00:18:16,370 Uniq ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೆನಪಿಡಿ ಫಿಲ್ಟರ್ ಪಕ್ಕದ ಹೊಂದಾಣಿಕೆಗೆ ಸಾಲುಗಳನ್ನು ಹೇಳುತ್ತಾರೆ. 231 00:18:16,370 --> 00:18:19,680 ಅವರು ಪಕ್ಕದ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದಿಲ್ಲ. 232 00:18:19,680 --> 00:18:31,100 ನಾನು ಅವುಗಳನ್ನು ವಿಂಗಡಿಸಲು ವೇಳೆ, ರೀತಿಯ names.txt ಒಟ್ಟಿಗೆ ಎಲ್ಲಾ ನಕಲಿ ಸಾಲುಗಳನ್ನು ಹಾಕಲು ಹೋಗುತ್ತದೆ. 233 00:18:31,100 --> 00:18:34,450 ಈಗ ರೀತಿಯ names.txt ಎಂಬುದು. 234 00:18:34,450 --> 00:18:40,550 Uniq | ನಾನು ಇದು uniq, ಇನ್ಪುಟ್ ಎಂದು ಬಳಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. 235 00:18:40,550 --> 00:18:43,390 ನನಗೆ ಜೋಸೆಫ್, ಆರ್ಜೆ, ರಾಬ್, ಟಾಮಿ, ನೀಡುತ್ತದೆ 236 00:18:43,390 --> 00:18:49,260 ಮತ್ತು ನಾನು, WC-L ಇನ್ಪುಟ್ ಎಂದು ಬಳಸಲು ಬಯಸುವ 237 00:18:49,260 --> 00:18:52,740 ಇದು ನನ್ನ 4 ನೀಡಲು ಹೋಗುತ್ತದೆ. 238 00:18:52,740 --> 00:18:56,930 ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಲೈಕ್, ನೀವು ಏನು ಪೈಪ್ಲೈನ್ ಬಳಸಬಹುದಿತ್ತು? 239 00:18:56,930 --> 00:19:01,390 ನೀವು ಆಜ್ಞೆಗಳ ಒಂದು ಸರಣಿಯನ್ನು ಬಳಸಿ ವಿಷಯಗಳನ್ನು ಬಹಳಷ್ಟು ಮಾಡಬಹುದು 240 00:19:01,390 --> 00:19:05,130 ನೀವು ಮುಂದಿನ ಆದೇಶಕ್ಕೆ ಇನ್ಪುಟ್ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಉತ್ಪತ್ತಿಯನ್ನು ಬಳಸುವ. 241 00:19:05,130 --> 00:19:08,780 ನೀವು ಬಹಳಷ್ಟು ಸಂಗತಿಗಳನ್ನು, ಬುದ್ಧಿವಂತ ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಮಾಡಬಹುದು. 242 00:19:08,780 --> 00:19:11,440 >> ಪ್ರಶ್ನೆಗಳು? 243 00:19:12,910 --> 00:19:14,600 ಸರಿ. 244 00:19:14,600 --> 00:19:17,880 ಪೈಪ್ ಮತ್ತು ಮರುನಿರ್ದೇಶನವಿಲ್ಲದ್ದಕ್ಕೆ ಆ ಸ್. 245 00:19:18,370 --> 00:19:24,090 >> ಈಗ ನಾವು ನಿಜವಾದ ಸಂಗತಿಗಳನ್ನು, ಕೋಡಿಂಗ್ ವಿಷಯ ಹೋಗುತ್ತಾರೆ. 246 00:19:24,090 --> 00:19:29,100 ಈ PDF ಒಳಗೆ, ನೀವು, ಈ ಆಜ್ಞೆಯನ್ನು ನೋಡುತ್ತಾರೆ 247 00:19:29,100 --> 00:19:32,950 ಮತ್ತು ನಿಮ್ಮ ಉಪಕರಣಗಳಲ್ಲಿರುವ ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಬಯಸುವಿರಿ. 248 00:19:36,240 --> 00:19:42,250 wget ಮೂಲಭೂತವಾಗಿ, ಕೇವಲ ಇಂಟರ್ನೆಟ್ ಏನನ್ನೋ ಪಡೆಯಲು ಆಜ್ಞೆಯ 249 00:19:42,250 --> 00:19:45,180 ಆದ್ದರಿಂದ wget ಮತ್ತು ಈ URL. 250 00:19:45,180 --> 00:19:49,110 ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ಈ URL ಗೆ ಹೋದರೆ, ಆ ಕಡತವನ್ನು ಡೌನ್ಲೋಡ್ ಎಂದು. 251 00:19:49,110 --> 00:19:52,510 ನಾನು ಅದರ ಮೇಲೆ ಕ್ಲಿಕ್, ಆದ್ದರಿಂದ ನನಗೆ ಕಡತವನ್ನು ಡೌನ್ಲೋಡ್. 252 00:19:52,510 --> 00:19:55,650 ಆದರೆ ಟರ್ಮಿನಲ್ ಒಳಗೆ ಆ ವಿಷಯ wget ಬರೆಯಲು 253 00:19:55,650 --> 00:19:58,620 ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅದನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಲು ಹೋಗುತ್ತದೆ. 254 00:19:58,620 --> 00:20:02,750 ನಾನು section5.zip ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು section5.zip ಅನ್ಜಿಪ್ ಬಯಸುವಿರಿ 255 00:20:02,750 --> 00:20:06,520 ಇದು ನೀವು section5 ಎಂಬ ಫೋಲ್ಡರ್ ನೀಡಲು ಹೋಗುತ್ತದೆ 256 00:20:06,520 --> 00:20:11,550 ನಾವು ಒಳಗೆ ಇಂದು ಬಳಸುತ್ತಿರುವ ಎಂದು ನೀನು ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಮಾಡಲಿಕ್ಕೆ ಇದು. 257 00:20:33,380 --> 00:20:37,710 ಈ ಕಾರ್ಯಕ್ರಮಗಳು 'ಕಡತದ ಹೆಸರುಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಅವರು ಸ್ವಲ್ಪ ದೋಷಯುಕ್ತ ಆರ್, 258 00:20:37,710 --> 00:20:40,990 ನಿಮ್ಮ ಮಿಷನ್ GDB ಅನ್ನು ಏಕೆ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಹೊಂದಿದೆ. 259 00:20:40,990 --> 00:20:44,560 ಅವುಗಳನ್ನು ಎಲ್ಲರಿಗೂ ಡೌನ್ಲೋಡ್ / ಅವುಗಳನ್ನು ಡೌನ್ಲೋಡ್ ಹೇಗೆ ತಿಳಿದಿರುವ ಹೊಂದಿದೆ 260 00:20:44,560 --> 00:20:47,480 ತಮ್ಮ APPLIANCE ಗೆ? ಸರಿ. 261 00:20:47,480 --> 00:20:56,400 >> ./buggy1 ರನ್ನಿಂಗ್, ಇದು, ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ (ಕೋರ್ ಸುರಿಸಿದ) ಹೇಳುವುದಿಲ್ಲ 262 00:20:56,400 --> 00:21:00,500 ಇದು ನೀವು ಒಂದು segfault ಪಡೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ಇದು ಒಂದು ಕೆಟ್ಟ ವಿಷಯ. 263 00:21:00,500 --> 00:21:03,810 ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು segfault ಸಿಗುತ್ತವೆ? 264 00:21:03,810 --> 00:21:08,210 [ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ Dereferencing. >> ಹೌದು. ಆದ್ದರಿಂದ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ. 265 00:21:08,210 --> 00:21:11,580 ನೀವು segfault ಪಡೆಯಲು ನೀನು ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ Dereferencing. 266 00:21:11,580 --> 00:21:16,720 ನೀವು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ಏನನ್ನು ಸಾಧನವಾಗಿ segfault ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು. 267 00:21:16,720 --> 00:21:21,350 ಆದ್ದರಿಂದ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing, ವಿಳಾಸಕ್ಕೆ 0 ಸ್ಪರ್ಶಿಸುವಂತಹದ್ದನ್ನು 268 00:21:21,350 --> 00:21:28,060 ಮತ್ತು ಮೂಲತಃ, ಎಲ್ಲಾ ಕಂಪ್ಯೂಟರ್ಗಳು ದಿನಗಳಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ 0 ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿ ಹೇಳುತ್ತಾರೆ. 269 00:21:28,060 --> 00:21:31,920 ಒಂದು segfault ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಫಲಿತಾಂಶಗಳು dereferencing ಏಕೆ ಆ ನ. 270 00:21:31,920 --> 00:21:37,210 ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಗೆ ಉಂಟಾಗುತ್ತದೆ, ಅದು, ಒಂದು ಕಸದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ 271 00:21:37,210 --> 00:21:41,520 ಆದ್ದರಿಂದ ನೀವು dereference ಪ್ರಯತ್ನಿಸಿ ಇದು, ಬಹುಶಃ ನಿಮ್ಮ ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು 272 00:21:41,520 --> 00:21:43,540 ಎಂದು ಎಲ್ಲಿಯೂ ಮಧ್ಯದಲ್ಲಿ ಇಲ್ಲಿದೆ. 273 00:21:43,540 --> 00:21:45,650 ನಿಮಗೆ ಅದೃಷ್ಟ ಮತ್ತು ಕಸ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಸಂಭವಿಸಿದಾಗ 274 00:21:45,650 --> 00:21:48,440 ಸ್ಟ್ಯಾಕ್ ಅಥವಾ ವಿಚಾರದ ಬಗ್ಗೆ ಎಲ್ಲೋ ತೋರಿಸಲು ಸಂಭವಿಸಿದ, 275 00:21:48,440 --> 00:21:50,820 ನಂತರ ನೀವು ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಮಾಡಿರುವ ನೀವು dereference, 276 00:21:50,820 --> 00:21:52,730 ಏನೂ ತಪ್ಪು ಹೋಗುತ್ತದೆ. 277 00:21:52,730 --> 00:21:55,480 ಇದು ತೋರುತ್ತಿರುವಂತೆ ಸರಿ ಆದರೆ, ಎಲ್ಲೋ ಸ್ಟ್ಯಾಕ್ ಮತ್ತು ಹೀಪ್ ನಡುವೆ, ಸೇ 278 00:21:55,480 --> 00:21:59,850 ಅಥವಾ ಅದು ಕೇವಲ ಎಲ್ಲೋ, ಇನ್ನೂ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಬಳಸಲಾಗಿಲ್ಲ ಎಂದು ಸೂಚಿಸುವ ವಿಶೇಷವೇನು 279 00:21:59,850 --> 00:22:02,240 ನಂತರ ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು ಮತ್ತು ನೀವು segfault. 280 00:22:02,240 --> 00:22:06,370 ನೀವು ಒಂದು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ಬರೆಯಲು ಮತ್ತು ಅದನ್ನು ಹಲವಾರು ಬಾರಿ recurses ಮಾಡಿದಾಗ 281 00:22:06,370 --> 00:22:08,720 ಮತ್ತು ನಿಮ್ಮ ಸ್ಟಾಕ್ ವಿಷಯಗಳನ್ನು ಕೂಡ ದೊಡ್ಡ ಮತ್ತು ಸ್ಟಾಕ್ ಘರ್ಷಿಸಿದಾಗ ಬೆಳೆಯುತ್ತದೆ 282 00:22:08,720 --> 00:22:12,270 ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಅದು ಘರ್ಷಿಸಲು ಮಾಡಬಾರದು ಎಂದು, ನೀವು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು, 283 00:22:12,270 --> 00:22:14,810 ಆದ್ದರಿಂದ ನೀವು segfault. 284 00:22:14,810 --> 00:22:17,010 ಎಂದು ಯಾವ ಒಂದು segfault ಆಗಿದೆ. 285 00:22:17,010 --> 00:22:21,810 >> ಅದೇ ಕಾರಣದಿಂದ ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿದ್ದರೆ - 286 00:22:21,810 --> 00:22:23,930 ಹಿಂದಿನ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಮರಳಲು ಅವಕಾಶ. 287 00:22:23,930 --> 00:22:28,530 ರಲ್ಲಿ hello.c-I'm ಕೇವಲ ಯಾವುದೋ ಮಾಡಲು ಹೋಗಿ. 288 00:22:28,530 --> 00:22:33,770 ಚಾರ್ * ರು = "ಹಲೋ ವರ್ಲ್ಡ್"; 289 00:22:33,770 --> 00:22:42,310 ನಾನು ಬಳಸಿದರೆ * ರು = ಏನೋ ಅಥವಾ ರು [0] = 'ಎಕ್ಸ್'; 290 00:22:42,310 --> 00:22:47,290 ಆದ್ದರಿಂದ ನಿನ್ನ ಮಾಡಿ. / ನಿನ್ನ, ಏಕೆ ಎಂದು segfault ನೀಡಲಿಲ್ಲ? 291 00:22:48,410 --> 00:22:51,250 ಏಕೆ ಈ segfault ನೀಡಲಿಲ್ಲ? 292 00:22:55,660 --> 00:22:57,890 ನೀವು ಏನಾಗುವುದು ನಿರೀಕ್ಷಿಸಬಹುದು? 293 00:22:57,890 --> 00:23:06,640 ನಾನು printf ಮಾಡಿದರೆ ("% s \ n" ರು); ಏನು ಮುದ್ರಿತವಾಗಬಹುದು ನಿರೀಕ್ಷಿಸಬಹುದು? 294 00:23:06,640 --> 00:23:09,930 [ವಿದ್ಯಾರ್ಥಿ] ಎಕ್ಸ್ ನಿನ್ನ. >> ಹೌದು. 295 00:23:09,930 --> 00:23:15,140 ಸಮಸ್ಯೆ, ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮಾಡಿದಾಗ ಘೋಷಿಸುವಂತೆ ಆಗಿದೆ 296 00:23:15,140 --> 00:23:18,190 ರು, ಸ್ಟಾಕ್ ಮೇಲೆ ಹೋಗುತ್ತಿದ್ದೇವೆ ಎಂದು ಸೂಚಿಯಾಗಿದೆ 297 00:23:18,190 --> 00:23:25,880 ಮತ್ತು ರು ತೋರುತ್ತಿರುವಂತೆ ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ಒಳಗೊಂಡಿರುವ ಇದು ಈ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ. 298 00:23:25,880 --> 00:23:30,560 ಕೇವಲ ಹೆಸರು, ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ಮಾಡಲು, ನೀವು ಕಲ್ಪನೆಯನ್ನು ಪಡೆಯಬೇಕು 299 00:23:30,560 --> 00:23:33,010 ನೀವು ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ರಲ್ಲಿ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, 300 00:23:33,010 --> 00:23:36,670 ನೀವು ಮೆಮೊರಿಯಲ್ಲಿ ಮಾಡಬಾರದು ಏನೋ ಮಾಡುತ್ತಿರುವುದು ಮತ್ತು ನೀವು segfault. 301 00:23:36,670 --> 00:23:45,360 ಈ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಗಳು ಮತ್ತು ಚಾರ್ ರು [] ನಡುವಿನ ದೊಡ್ಡ ವ್ಯತ್ಯಾಸ. 302 00:23:45,360 --> 00:23:48,790 ಆದ್ದರಿಂದ ಚಾರ್ ರು [], ಈಗ ಈ ಸ್ಟ್ರಿಂಗ್ ಸ್ಟಾಕ್ ಒಳಪಡಿಸಿದರು ಹೋಗುವ ಇದೆ, 303 00:23:48,790 --> 00:23:53,960 ಮತ್ತು ಸ್ಟಾಕ್ ಈ ನಿಖರವಾಗಿ ಉತ್ತಮ ಕೆಲಸ ಮಾಡಬೇಕು, ಅಂದರೆ, ಓದಲು ಮಾತ್ರ ಅಲ್ಲ. 304 00:23:55,500 --> 00:23:57,370 ಮತ್ತು ಅದು. 305 00:23:57,370 --> 00:24:06,250 ನೆನಪಿಡಿ ನಾನು ಚಾರ್ ಮಾಡಿದಾಗ * ರು = "ಹಲೋ ವರ್ಲ್ಡ್", ರು ಸ್ವತಃ ಸ್ಟಾಕ್ ಮೇಲೆ 306 00:24:06,250 --> 00:24:10,390 ಆದರೆ ರು ಎಲ್ಲೋ ಬೇರೆ ಮಾಡಲು ಅಂಕಗಳನ್ನು, ಮತ್ತು ಬೇರೆ ಎಲ್ಲಾದರೂ ಓದಲು ಮಾತ್ರ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ. 307 00:24:10,390 --> 00:24:15,640 ಆದರೆ ಚಾರ್ ರು [] ಕೇವಲ ಸ್ಟಾಕ್ ಮೇಲೆ ಸಂಗತಿಯಾಗಿದೆ. 308 00:24:17,560 --> 00:24:21,760 ಆದ್ದರಿಂದ ಒಂದು segfault ನಡೆಯುತ್ತಿದೆ ಇನ್ನೊಂದು ಉದಾಹರಣೆ. 309 00:24:21,760 --> 00:24:27,820 >> ನಾವು ./buggy1 ಒಂದು segfault ಕಾರಣವಾಗಿದ್ದ ಕಂಡಿತು. 310 00:24:27,820 --> 00:24:31,810 ಸಿದ್ಧಾಂತದಲ್ಲಿ, ನೀವು ತಕ್ಷಣ buggy1.c ನೋಡಲು ಮಾಡಬಾರದು. 311 00:24:31,810 --> 00:24:35,170 ಬದಲಾಗಿ, ನಾವು GDB ಮೂಲಕ ನೋಡಲು ಮಾಡುತ್ತೇವೆ. 312 00:24:35,170 --> 00:24:37,750 ನೀವು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ (ಕೋರ್ ಸುರಿಸಿದ) ಪಡೆದಾಗ ಗಮನಿಸಿ, 313 00:24:37,750 --> 00:24:40,850 ನೀವು ಇಲ್ಲಿ ಎಂದು ಕೋರ್ ಈ ಕಡತವನ್ನು ಪಡೆಯಲು. 314 00:24:40,850 --> 00:24:45,200 ನಾವು ls-l, ನಾವು ಆ ಕೋರ್ ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ದೊಡ್ಡ ಫೈಲ್ ನೋಡುತ್ತಾರೆ. 315 00:24:45,200 --> 00:24:51,580 ಈ ಕಡತದ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆ, ಆದ್ದರಿಂದ 250-ಏನೋ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಕಾಣುತ್ತಿಲ್ಲ. 316 00:24:51,580 --> 00:24:56,120 ಈ ಕಾರಣ ಕೋರ್ ಡಂಪ್ ನಿಜವಾಗಿ ಏನು ಎಂದು 317 00:24:56,120 --> 00:25:01,410 ಯಾವಾಗ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ, ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮೆಮೊರಿ ರಾಜ್ಯ 318 00:25:01,410 --> 00:25:05,230 ಕೇವಲ ನಕಲು ಮತ್ತು ಈ ಫೈಲ್ ಅಂಟಿಸಲಾಗಿದೆ ಮುಟ್ಟುತ್ತದೆ. 319 00:25:05,230 --> 00:25:07,270 ಆ ಫೈಲ್ ಆಗಿ ತೊರೆಯುತ್ತಾನೆ. 320 00:25:07,270 --> 00:25:13,060 ಈ ಪ್ರೋಗ್ರಾಂ ಸಹಾ ತನ್ನನ್ನು ನಡೆಸುತ್ತಿರುವ, ಸುಮಾರು 250 ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಒಂದು ಸ್ಮರಣೆ ಬಳಕೆಯನ್ನು ಹೊಂದಿವೆ ಏನಾಯಿತು 321 00:25:13,060 --> 00:25:17,040 ಆದ್ದರಿಂದ ಈ ಫೈಲ್ ಸುರಿಯಲ್ಪಟ್ಡು ಪಡೆದುಕೊಂಡಿದೆ ಇಲ್ಲಿದೆ. 322 00:25:17,040 --> 00:25:23,630 ನಾವು GDB buggy1 ಕೋರ್ ಹೋದರೆ ಈಗ ಆ ಕಡತವನ್ನು ನೋಡಬಹುದು. 323 00:25:23,630 --> 00:25:30,130 ನಾವು GDB buggy1 ಮಾಡಬಹುದು, ಮತ್ತು ಕೇವಲ, ನಿಯಮಿತವಾಗಿ GDB ಅಪ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ 324 00:25:30,130 --> 00:25:33,800 ಇದರ ಇನ್ಪುಟ್ ಫೈಲ್ buggy1 ಬಳಸಿ. 325 00:25:33,800 --> 00:25:38,260 ನೀವು GDB buggy1 ಕೋರ್ ಹಾಗೆ ಆದರೆ, ಅದು ನಿರ್ದಿಷ್ಟವಾಗಿ GDB ಆರಂಭಿಸುವ ವಿಶೇಷವೇನು 326 00:25:38,260 --> 00:25:40,330 ಆ ಕೋರ್ ಕಡತವನ್ನು ನೋಡಿ. 327 00:25:40,330 --> 00:25:45,560 ಮತ್ತು ನೀವು buggy1 ಸಾಧನವಾಗಿ GDB ಹೇಳುವ ಆ ಕೋರ್ ಕಡತ buggy1 ಪ್ರೋಗ್ರಾಂ ಬರುತ್ತದೆ ತಿಳಿದಿದೆ. 328 00:25:45,560 --> 00:25:49,580 ಆದ್ದರಿಂದ GDB buggy1 ಕೋರ್ ತಕ್ಷಣ ನಮಗೆ ತರಲಿದೆ 329 00:25:49,580 --> 00:25:52,060 ಕಾರ್ಯಕ್ರಮವನ್ನು ಅಂತ್ಯಗೊಳಿಸಲು ಸಂಭವಿಸಿದ ಅಲ್ಲಿ ಗೆ. 330 00:25:57,720 --> 00:26:02,340 ನಾವು ಪ್ರೋಗ್ರಾಂ ಸಂಕೇತವನ್ನು 11, ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಜೊತೆ ರದ್ದು ಇಲ್ಲಿ ನೋಡಿ. 331 00:26:02,340 --> 00:26:10,110 ಪ್ರಾಯಶಃ ನಾವು ಬಹಳ ಉಪಯುಕ್ತ ಇರುವಂತಹ ಅಸೆಂಬ್ಲಿ, ಒಂದು ಸಾಲನ್ನು ನೋಡಿ ಸಂಭವಿಸಬಹುದು. 332 00:26:10,110 --> 00:26:15,360 ನೀವು BT ಅಥವಾ backtrace ಟೈಪ್ ಆದರೆ, ಆ ಕಾರ್ಯ ಎಂದು ವಿಶೇಷವೇನು 333 00:26:15,360 --> 00:26:19,430 ಎಂದು ನಮ್ಮ ಪ್ರಸ್ತುತ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುತ್ತದೆ. 334 00:26:19,430 --> 00:26:23,150 ಆದ್ದರಿಂದ backtrace. ನಾವು ಕೇವಲ ಎರಡು ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕಾಣುತ್ತದೆ. 335 00:26:23,150 --> 00:26:26,310 ಮೊದಲ, ನಮ್ಮ ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಆಗಿದೆ 336 00:26:26,310 --> 00:26:29,810 ಮತ್ತು ಎರಡನೇ, ನಾವು ಎಂದು ಹುಟ್ಟಿಕೊಂಡ ಈ ಕ್ರಿಯೆಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಆಗಿದೆ 337 00:26:29,810 --> 00:26:34,440 ನಾವು ಮಾತ್ರ ವಿಧಾನಸಭೆಯಲ್ಲಿ ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ ನಂತಹ ಇದು ಕಾಣುತ್ತದೆ. 338 00:26:34,440 --> 00:26:38,050 ಆದ್ದರಿಂದ ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ಮತ್ತೆ ಹೋಗಿ ಅವಕಾಶ 339 00:26:38,050 --> 00:26:42,300 ಮತ್ತು ನಾವು ಫ್ರೇಮ್ 1 ಮಾಡಬಹುದು ಹಾಗೆ, ಮತ್ತು ನಾವು ಕೂಡ ಡೌನ್ ಮಾಡಬಹುದು ಯೋಚಿಸುವುದು, 340 00:26:42,300 --> 00:26:45,160 ಅಪ್ ಅಥವಾ - ಆದರೆ ಬಹುತೇಕ ಕೆಳಗೆ ಮಾಡಲೇ ಇಲ್ಲ. ಹೌದು. 341 00:26:45,160 --> 00:26:50,710 ಮೇಲೆ ಮತ್ತು ಕೆಳಗೆ. ಅಪ್ ನೀವು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ನೀವು ಕೆಳಗೆ ತರುತ್ತದೆ ಕೆಳಗೆ, ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ತೆರೆದಿಡುತ್ತದೆ. 342 00:26:50,710 --> 00:26:53,240 ನಾನು ಬಳಸಲು ಎಂದಿಗೂ ಪ್ರವೃತ್ತಿ. 343 00:26:53,240 --> 00:26:59,120 ನಾನು ನಿರ್ದಿಷ್ಟವಾಗಿ 1 ಲೇಬಲ್ ಫ್ರೇಮ್ ಹೋಗಿ ಇದು ಫ್ರೇಮ್ 1, ಸೇ. 344 00:26:59,120 --> 00:27:01,750 ಫ್ರೇಮ್ 1, ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ನಮ್ಮನ್ನು ತರಲಿದೆ 345 00:27:01,750 --> 00:27:05,570 ಮತ್ತು ಇಲ್ಲಿಯೇ ನಾವು ಎಂದು ಸಂಭವಿಸಿ ಕೋಡ್ ಸಾಲನ್ನು ಹೇಳುತ್ತಾಳೆ. 346 00:27:05,570 --> 00:27:07,950 ನಾವು ಕೋಡ್ ಒಂದೆರಡು ಹೆಚ್ಚು ಸಾಲುಗಳನ್ನು ಬಯಸಿದರೆ, ನಾವು, ಪಟ್ಟಿ ಹೇಳಬಹುದು 347 00:27:07,950 --> 00:27:11,280 ಮತ್ತು ನಮಗೆ ಸುತ್ತ ಕೋಡ್ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ನೀಡಲು ವಿಶೇಷವೇನು. 348 00:27:11,280 --> 00:27:13,360 ನಾವು segfaulted ಲೈನ್ 6 ಆಗಿತ್ತು: 349 00:27:13,360 --> 00:27:17,360 ವೇಳೆ (strcmp ("CS50 ಕಲ್ಲುಗಳು", argv [1]) == 0). 350 00:27:17,360 --> 00:27:24,130 ಅದು ಇನ್ನೂ ಸ್ಪಷ್ಟ ಇದ್ದರೆ, ನೀವು ಅದನ್ನು segfaulted ಏಕೆ ಆಲೋಚನೆ ಇಲ್ಲಿ ನೇರವಾಗಿ ಅದನ್ನು ಪಡೆಯಬಹುದು. 351 00:27:24,130 --> 00:27:28,800 ಆದರೆ ನಾವು ಒಂದು ಹೆಜ್ಜೆ ಮುಂದೆ ಹೋಗಿ ತೆಗೆದುಕೊಂಡು ಹೇಳುತ್ತಾರೆ, "ವೈ argv [1] segfault ಎಂದು?" ಮಾಡಬಹುದು 352 00:27:28,800 --> 00:27:38,830 ಲೆಟ್ಸ್ ಮುದ್ರಣ argv [1], ಮತ್ತು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಇದು ಅದು 0x0, ತೋರುತ್ತಿದೆ. 353 00:27:38,830 --> 00:27:44,750 ನಾವು segfault ಇನ್ನು ಎಷ್ಟು CS50 ಬಂಡೆಗಳು ಮತ್ತು ಶೂನ್ಯ strcmping, ಮತ್ತು ನೀವು. 354 00:27:44,750 --> 00:27:48,280 ಮತ್ತು ಏಕೆ ಹೊಂದಿದೆ argv [1] ಶೂನ್ಯ? 355 00:27:48,640 --> 00:27:51,280 [ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನೀಡದಿರುವುದರಿಂದ. 356 00:27:51,280 --> 00:27:53,390 ಹೌದು. ನಾವು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನೀಡಿಲ್ಲ. 357 00:27:53,390 --> 00:27:58,460 ಆದ್ದರಿಂದ ./buggy1 ಮಾತ್ರ argv [0] ./buggy1 ಎಂದು ಮಾಡಲಿಕ್ಕೆ ಇದೆ. 358 00:27:58,460 --> 00:28:02,100 ಇದು argv [1] ಮಾಡಲಿಕ್ಕೆ ಅಲ್ಲ, segfault ಇನ್ನು ಎಷ್ಟು. 359 00:28:02,100 --> 00:28:07,450 ಬದಲಿಗೆ, ನಾನು CS50 ಹಾಗೆ, ಆದರೆ, ಇದು ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ ಹೇಳಲು ವಿಶೇಷವೇನು 360 00:28:07,450 --> 00:28:09,950 ಅದು ಏನು ಮಾಡಬೇಕೋ ಎಂಬುದನ್ನು ಏಕೆಂದರೆ. 361 00:28:09,950 --> 00:28:15,240 Buggy1.c ನೋಡುವ, ಅದನ್ನು ಮುದ್ರಿಸಲು ಮಾಡಬೇಕೋ "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" - 362 00:28:15,240 --> 00:28:20,820 Argv [1] "CS50 ಕಲ್ಲುಗಳು", ಬೇರೆ, "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" ಇದ್ದಲ್ಲಿ "ನೀವು ಒಂದು ಪಡೆಯಿರಿ!" 363 00:28:20,820 --> 00:28:25,660 ನಾವು ಒಂದು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ನಾವು ನಿಜವಾದ ಎಂದು ಹೋಲಿಸಿ ಈ ಅಗತ್ಯವಿದೆ 364 00:28:25,660 --> 00:28:28,710 ಇದು 0 ಗೆ ಹೋಲಿಸುವ ಅರ್ಥ. 365 00:28:28,710 --> 00:28:31,100 ಆದ್ದರಿಂದ argv [1] "CS50 ಕಲ್ಲುಗಳು" ಅಗತ್ಯವಿದೆ. 366 00:28:31,100 --> 00:28:35,660 ನೀವು ಕಮಾಂಡ್ ಸಾಲಿನಲ್ಲಿ ಮಾಡಲು ಬಯಸಿದರೆ, ನೀವು ಜಾಗವನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳಲು \ ಬಳಸಬೇಕಾಗುತ್ತದೆ. 367 00:28:35,660 --> 00:28:41,690 ಆದ್ದರಿಂದ CS50 \ ಬಂಡೆಗಳು ಮತ್ತು ನೀವು ಒಂದು ಪಡೆಯಿರಿ! 368 00:28:41,690 --> 00:28:44,060 ನೀವು backslash ಮಾಡದಿದ್ದರೆ, ಏಕೆ ಈ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ? 369 00:28:44,060 --> 00:28:47,190 [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಎರಡು ವಿವಿಧ ವಾದಗಳು ಇಲ್ಲಿದೆ. >> ಹೌದು. 370 00:28:47,190 --> 00:28:52,540 Argv [1] CS50 ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು argv [2] ಕಲ್ಲುಗಳು ಎಂದು ಹೋಗುತ್ತದೆ. ಸರಿ. 371 00:28:52,540 --> 00:28:56,470 >> ಈಗ ./buggy2 ಮತ್ತೆ segfault ಹೋಗುವ ಇದೆ. 372 00:28:56,470 --> 00:29:01,880 ಬದಲಿಗೆ ಅದರ ಕೋರ್ ಕಡತ ಅದನ್ನು ತೆರೆಯುವ ನ, ನಾವು ನೇರವಾಗಿ buggy2 ತೆರೆಯುತ್ತದೆ ವಿಲ್ 373 00:29:01,880 --> 00:29:05,000 GDB buggy2 ಆದ್ದರಿಂದ. 374 00:29:05,000 --> 00:29:09,590 ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವೇಳೆ ಈಗ, ಅದು, ಪ್ರೋಗ್ರಾಂ ಸಂಕೇತವನ್ನು SIGSEGV ಪಡೆದರು ಹೇಳಲು ವಿಶೇಷವೇನು 375 00:29:09,590 --> 00:29:15,530 ಇದು ಸಿಗ್ನಲ್ segfault ಇದು ಸಂಭವಿಸಬಹುದು ಏನಾಯಿತು ಅಲ್ಲಿ ಇದು. 376 00:29:15,530 --> 00:29:21,250 ನಮ್ಮ backtrace ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನಾವು ಕಾರ್ಯ oh_no ಎಂದು ನೋಡಿ 377 00:29:21,250 --> 00:29:23,900 ಇದು ಕಾರ್ಯ binky ಘೋಶಿಸಿದರು ಕಾರ್ಯನಿರ್ವಹಿಸುವ dinky, ಘೋಶಿಸಿದರು 378 00:29:23,900 --> 00:29:26,460 ಮುಖ್ಯ ಘೋಶಿಸಿದರು. 379 00:29:26,460 --> 00:29:31,680 ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ನೋಡಬಹುದು. 380 00:29:31,680 --> 00:29:34,680 dinky ಮತ್ತು binky ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಆಗಿತ್ತು. 381 00:29:34,680 --> 00:29:44,390 ನಾವು ಕಾರ್ಯ oh_no ಪಟ್ಟಿ, ನಾವು oh_no ಕೇವಲ ಚಾರ್ ** ರು = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುವುದರಿಂದ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ನೋಡಿ; 382 00:29:44,390 --> 00:29:47,410 * ರು = "ಬೂಮ್"; 383 00:29:47,410 --> 00:29:50,330 ಏಕೆ ವಿಫಲರಾಗಿದ್ದಾರೆ? 384 00:29:54,330 --> 00:29:58,380 [ವಿದ್ಯಾರ್ಥಿ] ನೀವು dereference ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಸಾಧ್ಯವಿಲ್ಲ? >> ಹೌದು. 385 00:29:58,380 --> 00:30:06,090 ಒಂದು ಚಾರ್ ** ಎಂದು ಉಂಟಾದರೆ ಇದು ಕೇವಲ, ಲೆಕ್ಕಿಸದೆ, ರು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ ಹೇಳುತ್ತಾರೆ 386 00:30:06,090 --> 00:30:12,070 ನೀವು ವಿವರಿಸುವುದಕ್ಕೆ ಹೇಗೆ ಅವಲಂಬಿಸಿ, ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ಪಾಯಿಂಟರ್ ಸಾಧ್ಯವಿದೆ, 387 00:30:12,070 --> 00:30:15,550 ಅಥವಾ ತಂತಿಗಳ ಒಂದು ಸರಣಿ. 388 00:30:15,550 --> 00:30:21,430 ಅದು ರು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ * ಗಳು, ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಇದೆ 389 00:30:21,430 --> 00:30:24,800 ಆದ್ದರಿಂದ ಈ ಕುಸಿತಕ್ಕೆ ಹೋಗುತ್ತದೆ. 390 00:30:24,800 --> 00:30:27,540 ನೀವು ಬಹುಶಃ segfault ಮಾಡಬಹುದು ತ್ವರಿತ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದು. 391 00:30:27,540 --> 00:30:31,300 ಇದು ಕೇವಲ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಘೋಷಿಸುವ ಮತ್ತು ತಕ್ಷಣ segfaulting ನ. 392 00:30:31,300 --> 00:30:34,570 ಆ oh_no ಮಾಡುತ್ತಿರುವ ಇಲ್ಲಿದೆ. 393 00:30:34,570 --> 00:30:43,400 ನಾವು ಒಂದು ಫ್ರೇಮ್ ಹೋಗುತ್ತಾರೆ, ಆಗ ನಾವು oh_no ಎಂಬ ಕ್ರಿಯೆಯ ಬರಲು ನೀನು. 394 00:30:43,400 --> 00:30:44,830 ನಾನು ಕೆಳಗೆ ಹಾಗೆ ಮಾಡಬೇಕು. 395 00:30:44,830 --> 00:30:48,610 ನೀವು ಒಂದು ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಇದ್ದರೆ ನೀವು, ಮತ್ತೆ ನಮೂದಿಸಿ ಹಿಟ್ 396 00:30:48,610 --> 00:30:52,350 ಕೇವಲ ನೀವು ನಡೆದ ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೀರಿ. 397 00:30:52,350 --> 00:30:56,610 ನಾವು ಫ್ರೇಮ್ 1 ಇವೆ. 398 00:30:56,610 --> 00:31:04,650 ಈ ಫ್ರೇಮ್ ಪಟ್ಟಿ, ನಾವು ನಮ್ಮ ಕಾರ್ಯ ನೋಡಿ. 399 00:31:04,650 --> 00:31:08,520 ನೀವು ಮತ್ತೆ ಪಟ್ಟಿಯಲ್ಲಿ ಹಿಟ್ ಮಾಡಬಹುದು, ಅಥವಾ ನೀವು ಪಟ್ಟಿಯಲ್ಲಿ 20 ಮಾಡಬಹುದು ಮತ್ತು ಅದು ಹೆಚ್ಚು ಪಟ್ಟಿ ಕಾಣಿಸುತ್ತದೆ. 400 00:31:08,520 --> 00:31:13,640 ಕಾರ್ಯ dinky ನಾನು 1 ವೇಳೆ, ನಂತರ, oh_no ಕಾರ್ಯ ಹೋಗಿ ಹೇಳುತ್ತಾರೆ 401 00:31:13,640 --> 00:31:15,960 ಬೇರೆ ತೆಳ್ಳನೆಯ ಕಾರ್ಯ ಹೋಗಿ. 402 00:31:15,960 --> 00:31:18,700 ಮತ್ತು ನಾವು ಇಲ್ಲಿ ನೋಡಲು ಸಂಭವಿಸಿ ಏಕೆಂದರೆ ನಾನು 1 ತಿಳಿಯುವುದಕ್ಕಿಂತ 403 00:31:18,700 --> 00:31:22,560 ಆ dinky ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಕರೆಯಲಾಯಿತು. 404 00:31:22,560 --> 00:31:27,560 ಅಥವಾ ನೀವು ಕೇವಲ ನಾನು ಮುದ್ರಿಸಲು ಮಾಡಬಹುದಾದ ಮತ್ತು ನಾನು 1 ಹೇಳುವುದಿಲ್ಲ. 405 00:31:27,560 --> 00:31:33,770 ನಾವು dinky ಪ್ರಸ್ತುತ, ಮತ್ತು ಮತ್ತೊಂದು ಫ್ರೇಮ್ ಹೋಗುತ್ತಾರೆ ವೇಳೆ, ನಾವು binky ಅಂತ್ಯಗೊಂಡರೂ ಮಾಡುತ್ತೇವೆ ತಿಳಿದಿದೆ. 406 00:31:33,770 --> 00:31:36,600 ಅಪ್. ಈಗ ನಾವು binky ಮಾಡುತ್ತೇವೆ. 407 00:31:36,600 --> 00:31:41,340 ಅರ್ಧ ನನ್ನನ್ನು ಕತ್ತರಿಸಿ ಮೊದಲು ಪಟ್ಟಿ - - ಈ ಕಾರ್ಯ ಪಟ್ಟಿ 408 00:31:41,340 --> 00:31:52,670 ಇ 0 ವೇಳೆ ಇದು ಪ್ರಾರಂಭವಾಯಿತು, ನಂತರ ನಾವು oh_no ಕರೆಯಲು ನೀನು, ಬೇರೆ dinky ಕರೆ. 409 00:31:52,670 --> 00:31:57,000 ನಾವು ನಾನು 1 ಗೊತ್ತಿರಲಿಲ್ಲ, ಆದ್ದರಿಂದ dinky ಕರೆಯಲಾಗುತ್ತದೆ. 410 00:31:57,000 --> 00:32:05,030 ಮತ್ತು ಈಗ ನಾವು ಮುಖ್ಯ ಮತ್ತೆ ಆರ್, ಮತ್ತು ಮುಖ್ಯ ಕೇವಲ ಇಂಟ್ I = RAND ()% 3 ಎಂದು ಹೋಗುತ್ತದೆ; 411 00:32:05,030 --> 00:32:08,790 ಕೇವಲ ನೀವು ಎರಡೂ 0, 1, ಅಥವಾ 2 ಎಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ನೀಡಲು ಹೋಗುತ್ತದೆ. 412 00:32:08,790 --> 00:32:12,780 ಆ ಸಂಖ್ಯೆಯ binky ಕರೆಯಲು ವಿಶೇಷವೇನು, ಮತ್ತು 0 ಹಿಂತಿರುಗುವುದು. 413 00:32:12,780 --> 00:32:16,700 ಈ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, 414 00:32:16,700 --> 00:32:19,880 ಕೇವಲ, ತಕ್ಷಣವೇ ಅದನ್ನು ಓಡಿಸದೇ ಕೈಯಾರೆ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ವಾಕಿಂಗ್ 415 00:32:19,880 --> 00:32:25,400 ನೀವು ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್ ಎಂದು, ಇದು ನಾವು ಪ್ರೋಗ್ರಾಂ ಆ ಅರ್ಥ 416 00:32:25,400 --> 00:32:31,020 ಇದು ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಬಡಿಯುವ ವರೆಗು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹಾದು ಹೋಗುತ್ತದೆ. 417 00:32:31,020 --> 00:32:35,450 ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಅದು ರನ್ ಮತ್ತು ನಂತರ ಮುಖ್ಯ ಕಾರ್ಯ ಹಿಟ್ ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತವೆ. 418 00:32:35,450 --> 00:32:44,700 ಈಗ ನಾವು ಮುಖ್ಯ ಒಳಗೆ ಇದ್ದೇವೆ ಹಂತದ ಅಥವಾ ಮುಂದಿನ ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ನಮಗೆ ತರಲಿದೆ. 419 00:32:44,700 --> 00:32:47,050 ನೀವು ಹಂತದ ಅಥವಾ ಮುಂದಿನ ಮಾಡಬಹುದು. 420 00:32:47,050 --> 00:32:51,800 ಮುಂದಿನ ಹೊಡೆಯುವುದು, ಈಗ RAND ()% 3, ಆದ್ದರಿಂದ ನಾವು ನಾನು ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಬಹುದು, ತಿಳಿಸಲಾಗಿತ್ತು 421 00:32:51,800 --> 00:32:55,280 ಮತ್ತು ನಾನು 1 ಹೇಳುವುದಿಲ್ಲ. 422 00:32:55,280 --> 00:32:58,110 ಈಗ ನಾವು ಮುಂದಿನ ಅಥವಾ ಹಂತದ ಬಳಸಲು ಎಂದು ವಿಷಯವಾಗಿದೆ. 423 00:32:58,110 --> 00:33:01,000 ನಾನು ಹಿಂದಿನ ಒಂದು ಪ್ರಾಮುಖ್ಯ ಊಹಿಸುತ್ತಾರೆ, ಆದರೆ ಮುಂದಿನ ಬಳಸಲು ಬಯಸುತ್ತೇನೆ. 424 00:33:01,000 --> 00:33:06,000 ನಾವು ಹಂತದ ಬಳಸಿದರೆ, ನಾವು ಕಾರ್ಯ ಒಳಗೆ ಹೆಜ್ಜೆಯಿಟ್ಟು, ಇದು ನಿಜವಾದ ವಸ್ತು ನೋಡು ಅರ್ಥ 425 00:33:06,000 --> 00:33:07,940 ಆ binky ಒಳಗೆ ನಡೆಯುತ್ತಿದೆ. 426 00:33:07,940 --> 00:33:10,510 ನಾವು ಮುಂದಿನ ಬಳಸಿದರೆ, ನಂತರ ಇದು ಕ್ರಿಯೆಯ ಮೇಲೆ ಹೋಗಿ ಅರ್ಥ 427 00:33:10,510 --> 00:33:14,070 ಮತ್ತು ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ ಕೋಡ್ ಮುಂದಿನ ಲೈನ್ ಹೋಗಿ. 428 00:33:14,070 --> 00:33:17,900 ಇಲ್ಲಿಯೇ ಈ ಸಾಲಿನಲ್ಲಿ, ನಾನು RAND ()% 3 ಹೇಳಿದರು ಅಲ್ಲಿ ಆಗಿತ್ತು; 429 00:33:17,900 --> 00:33:21,320 ನಾನು ಹಂತದ ಆದರೆ ಅದನ್ನು RAND ಅನುಷ್ಠಾನಕ್ಕೆ ಹೋಗಿ ಎಂದು 430 00:33:21,320 --> 00:33:25,110 ಮತ್ತು ಅಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು, ಮತ್ತು ನಾನು RAND ಕ್ರಿಯೆಯ ಮೂಲಕ ಹೆಜ್ಜೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. 431 00:33:25,110 --> 00:33:26,920 ಆದರೆ ನಾನು RAND ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಹೆದರುವುದಿಲ್ಲ. 432 00:33:26,920 --> 00:33:30,190 ನಾನು ಮುಖ್ಯ ಸಂಕೇತವನ್ನು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು ಬಯಸುವ, ಆದ್ದರಿಂದ ನಾನು ಮುಂದಿನ ಬಳಸಿ. 433 00:33:30,190 --> 00:33:35,800 ಆದರೆ ಈಗ ನಾನು binky ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಕಾಳಜಿ ಮಾಡಬೇಕು, ಆದ್ದರಿಂದ ನಾನು ಒಳಗೆ ಹೆಜ್ಜೆಯಿಟ್ಟು ಬಯಸುವ. 434 00:33:35,800 --> 00:33:37,730 ಈಗ ನಾನು binky ರಲ್ಲಿ ಆಮ್. 435 00:33:37,730 --> 00:33:42,040 ಕೋಡ್ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ (ನಾನು == 0), ನಾನು ಒಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಂಡು ಹೇಳಲು ಹೋಗುತ್ತದೆ, 436 00:33:42,040 --> 00:33:44,930 ನಾವು dinky ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ನೋಡಿ. 437 00:33:44,930 --> 00:33:51,620 ನಾವು ಪಟ್ಟಿ ವಿಷಯಗಳು, ನಾವು ಪರಿಶೀಲಿಸಿದ ಎಂದು ನೋಡಿ ನಾನು = 0 ಆಗಿದೆ. 438 00:33:51,620 --> 00:33:55,470 , ಇ 0 ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಬೇರೆ ಸ್ಥಿತಿಯನ್ನು ಹೋದರು 439 00:33:55,470 --> 00:33:59,540 ಇದು dinky (I) ಕರೆಯಲು ಹೋಗುತ್ತದೆ. 440 00:33:59,540 --> 00:34:04,030 ನೀವು ತಪ್ಪಾಗಿ ಇರಬಹುದು. 441 00:34:04,030 --> 00:34:07,380 ನೀವು ನೇರವಾಗಿ ಈ ಸಾಲುಗಳನ್ನು ನೋಡಿದರೆ, ನೀವು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು, (ನಾನು == 0) ವೇಳೆ 442 00:34:07,380 --> 00:34:10,800 ಸರಿ, ನಾನು ಒಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಂಡಿತು ಮತ್ತು ಈಗ ನಾನು dinky (I) ನಲ್ಲಿ ನಾನು 443 00:34:10,800 --> 00:34:14,120 ನೀವು ನಾನು = 0 ಅಥವಾ ಏನಾದರೂ ಅರ್ಥ ಮಾಡಬೇಕು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು. 444 00:34:14,120 --> 00:34:18,980 ಇಲ್ಲ, ಕೇವಲ ಅದು ಲೈನ್ dinky (I) ನೇರವಾಗಿ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಮಾಡಬಹುದು ತಿಳಿದಿದೆ ಎಂದರ್ಥ. 445 00:34:18,980 --> 00:34:23,300 ಇ 0 ಏಕೆಂದರೆ, ಮುಂದಿನ ಹಂತದಲ್ಲಿ ಬೇರೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ. 446 00:34:23,300 --> 00:34:26,239 ಎಲ್ಸ್ ಇದು ನಿಲ್ಲಿಸಿ ಇನ್ನು ಒಂದು ಸಾಲನ್ನು ಅಲ್ಲ. 447 00:34:26,239 --> 00:34:31,570 ಅದು ನಿಜವಾಗಿ ಇದು (ನಾನು) dinky ಹೊಂದಿದೆ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು ವಿಶೇಷವೇನು. 448 00:34:31,570 --> 00:34:36,090 Dinky (i) ರ ಒಳಗೆ ಕಾಲಿಟ್ಟರೆ, ನಾವು (ನಾನು == 1) ವೇಳೆ. 449 00:34:36,090 --> 00:34:42,670 ನಾವು ಹೆಜ್ಜೆ, ನಾವು oh_no ಕೊನೆಗೊಳ್ಳಲು ನೀನು ತಿಳಿಯಲು, I = 1 ಗೊತ್ತು 450 00:34:42,670 --> 00:34:46,489 ನಾನು = 1 ನೀವು ಹೆಜ್ಜೆ ಇದು ಫಂಕ್ಷನ್ oh_no, ಕಾಲ್ಸ್ ಏಕೆಂದರೆ 451 00:34:46,489 --> 00:34:52,969 ಸೆಟ್ ಹೋಗುವ ಇದು ಚಾರ್ ** ರು = ಶೂನ್ಯ ತಕ್ಷಣ "ಬೂಮ್" ಗೆ. 452 00:34:54,270 --> 00:34:59,690 ಮತ್ತು ನಂತರ ವಾಸ್ತವವಾಗಿ, buggy2 ಅನುಷ್ಠಾನಕ್ಕೆ ನೋಡಿ 453 00:34:59,690 --> 00:35:04,590 0, 1, ಅಥವಾ 2 - - ಕರೆ binky, ಈ, ನಾನು ಒಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ 454 00:35:04,590 --> 00:35:10,610 ಇ 0 ವೇಳೆ ಇದು oh_no ಕರೆಯುತ್ತದೆ, ಬೇರೆ ಇದು dinky ಕರೆ, ಇದು ಇಲ್ಲಿ ಬರುತ್ತದೆ. 455 00:35:10,610 --> 00:35:18,100 ನಾನು, ಕರೆ oh_no 1 ವೇಳೆ, ಬೇರೆ, ಇಲ್ಲಿ ಬರುವ ಇದು, ತೆಳ್ಳನೆಯ ಕರೆ 456 00:35:18,100 --> 00:35:20,460 ನಾನು 2 ವೇಳೆ, oh_no ಕರೆ. 457 00:35:20,460 --> 00:35:24,720 ನಾನು ಕೂಡ ಒಂದು ರೀತಿಯಲ್ಲಿ ಯೋಚಿಸುವುದಿಲ್ಲ - 458 00:35:24,720 --> 00:35:30,030 ಯಾರಾದರೂ ಈ segfault ಎಂಬುದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ನೋಡಿ ಡಸ್? 459 00:35:30,030 --> 00:35:37,530 ನಾನು ಏನೋ ಕಾಣೆಯಾಗಿದೆ ನಾನು ಹೊರತು ನಾನು 0 ವೇಳೆ, ನೀವು ತಕ್ಷಣ segfault ಮಾಡುತ್ತೇವೆ ಏಕೆಂದರೆ, 460 00:35:37,530 --> 00:35:41,250 ನೀವು, ನಾನು segfault 1 ವೇಳೆ ಇದು ಒಂದು ಕಾರ್ಯ ಹೋಗಿ 461 00:35:41,250 --> 00:35:44,540 ನೀವು ನಾನು ವೇಳೆ 2 ನೀವು segfault ಅಲ್ಲಿ ಒಂದು ಕಾರ್ಯವನ್ನು ಹೋಗಿ. 462 00:35:44,540 --> 00:35:46,810 ಇನ್ನು ನೀವು ಏನು ಪರವಾಗಿಲ್ಲ ಆದ್ದರಿಂದ, ನೀವು segfault. 463 00:35:46,810 --> 00:35:52,380 >> ನಾನು, ಇದು ಬದಲಿಗೆ ಚಾರ್ ** ರು = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುವ ಎಂದು ಸರಿಪಡಿಸಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಊಹೆ 464 00:35:52,380 --> 00:35:55,610 ಆ ವಾಕ್ಯವನ್ನು ಜಾಗ malloc ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. 465 00:35:55,610 --> 00:36:04,230 Sizeof ಏನು - ನಾವು malloc (sizeof) ಇಲ್ಲ? 466 00:36:09,910 --> 00:36:15,190 [ವಿದ್ಯಾರ್ಥಿ] (ಚಾರ್) * 5? >> ಈ ಹಕ್ಕನ್ನು ತೋರುತ್ತಿಲ್ಲ? 467 00:36:15,190 --> 00:36:21,060 ನಾನು ವಾಸ್ತವವಾಗಿ ಇದು ನಡೆಯಿತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಊಹಿಸಿಕೊಂಡು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ನಾನು ಬಯಸುತ್ತೇನೆ ಏನು ಅಲ್ಲ. 468 00:36:24,400 --> 00:36:32,940 ರು ಮಾದರಿ ನೋಡಿ. ನ ಇಂಟ್ * ಸೇರಿಸಲು ಅವಕಾಶ, ಆದ್ದರಿಂದ ಇಂಟ್ * X. 469 00:36:32,940 --> 00:36:35,600 ನಾನು (sizeof (ಇಂಟ್)) malloc ಮಾಡಬೇಕಾಗುವುದು. 470 00:36:35,600 --> 00:36:40,490 ಅಥವಾ ನಾನು 5 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಯಸಿದರೆ, ನಾನು (sizeof (ಇಂಟ್) * 5) ಮಾಡುತ್ತಿದ್ದರು; 471 00:36:40,490 --> 00:36:44,210 ಏನು ನಾನು ಇಂಟ್ ** ಹೊಂದಿದ್ದರೆ? 472 00:36:46,260 --> 00:36:49,140 ನಾನು malloc ಬಯಸುವಿರಾ? 473 00:36:49,140 --> 00:36:53,510 ಪಾಯಿಂಟರ್ ಆಫ್ [ವಿದ್ಯಾರ್ಥಿ] ಗಾತ್ರ. >> ಹೌದು. (Sizeof (ಇಂಟ್ *)); 474 00:36:53,510 --> 00:36:56,960 ಕೆಳಗೆ ಇಲ್ಲಿ ಒಂದೇ. 475 00:36:56,960 --> 00:37:01,280 ನಾನು (sizeof (ಚಾರ್ *)) ನೀವು; 476 00:37:06,170 --> 00:37:12,840 ಈ "ಬೂಮ್" ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಎಂದು ಪಾಯಿಂಟರ್ ಜಾಗವನ್ನು ನಿಯೋಜಿಸಿ ಹೋಗುವ ಇದೆ. 477 00:37:12,840 --> 00:37:15,330 ನಾನು "ಬೂಮ್" ಸ್ಥಳಾವಕಾಶ ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿಲ್ಲ 478 00:37:15,330 --> 00:37:17,210 ನಾನು ಮೊದಲು ಹೇಳಿದ್ದಾರೆ ಎಂಬುದನ್ನು ಮೂಲಭೂತವಾಗಿ ಸಮಾನ ಏಕೆಂದರೆ 479 00:37:17,210 --> 00:37:20,870 ಚಾರ್ ನ * X = "ಬೂಮ್". 480 00:37:20,870 --> 00:37:27,950 "ಬೂಮ್" ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಇದು ಮೆಮೊರಿ ಓದಲು ಮಾತ್ರ ಪ್ರದೇಶದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವುದು ಸಂಭವಿಸಿದರೆ. 481 00:37:27,950 --> 00:37:35,200 ರು ಒಂದು ಚಾರ್ ** ವೇಳೆ ಆದರೆ ಈಗಾಗಲೇ, ಕೋಡ್ ಈ ಸಾಲಿನಲ್ಲಿ ಅಂದರೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ 482 00:37:35,200 --> 00:37:43,900 ನಂತರ * ರು ಒಂದು ಚಾರ್ * ಮತ್ತು ನೀವು "ಬೂಮ್" ತೋರಿಸಲು ಈ ಚಾರ್ * ಹೊಂದಿಸುವಾಗ ನೀವು. 483 00:37:43,900 --> 00:37:50,040 ನಾನು ರು ಆಗಿ "ಬೂಮ್" ಕಾಪಿ ಬಯಸಿದರೆ, ನಂತರ ನಾನು ರು ಜಾಗವನ್ನು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ. 484 00:37:55,170 --> 00:38:03,900 ನಾನು ಮಾಡುತ್ತೇನೆ * ರು = malloc (sizeof (ಚಾರ್) * 5); 485 00:38:03,900 --> 00:38:06,210 ಏಕೆ 5? 486 00:38:06,210 --> 00:38:10,860 ಏಕೆ 4? "ಬೂಮ್" 4 ಅಕ್ಷರಗಳು ತೋರುತ್ತಿದೆ. >> [ವಿದ್ಯಾರ್ಥಿ] ಶೂನ್ಯ ಪಾತ್ರ. 487 00:38:10,860 --> 00:38:14,580 ಹೌದು. ನಿಮ್ಮ ತಂತಿಗಳ ಎಲ್ಲಾ ಶೂನ್ಯಚಿಹ್ನೆ ಅಗತ್ಯವಿದೆ ಹೋಗುವ. 488 00:38:14,580 --> 00:38:23,590 ಈಗ ನಾನು strcat ರೀತಿಯ ಮಾಡಬಹುದು - ಸ್ಟ್ರಿಂಗ್ ಸಿದ್ದಗೊಳಿಸಲು ಕಾರ್ಯವೇನು? 489 00:38:23,590 --> 00:38:28,520 [ವಿದ್ಯಾರ್ಥಿ] cpy? >> Strcpy. 490 00:38:28,520 --> 00:38:32,700 ಮನುಷ್ಯ strcpy. 491 00:38:36,120 --> 00:38:39,590 ಆದ್ದರಿಂದ strcpy ಅಥವಾ strncpy. 492 00:38:39,590 --> 00:38:43,410 ನೀವು ಸೂಚಿಸಬಹುದು ರಿಂದ strncpy ಸ್ವಲ್ಪ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂಬುದನ್ನು ಅನೇಕ ಪಾತ್ರಗಳು, 493 00:38:43,410 --> 00:38:46,190 ನಾವು ತಿಳಿದಿರುವ ಕಾರಣ ಆದರೆ ಇಲ್ಲಿ ಲೆಕ್ಕಕ್ಕೆ ಬರುವುದಿಲ್ಲ. 494 00:38:46,190 --> 00:38:50,340 ಆದ್ದರಿಂದ strcpy ಮತ್ತು ವಾದಗಳನ್ನು ನಲ್ಲಿ ನೋಡಬಹುದು. 495 00:38:50,340 --> 00:38:53,100 ಮೊದಲ ವಾದವನ್ನು ನಮ್ಮ ತಾಣವಾಗಿದೆ. 496 00:38:53,100 --> 00:38:56,770 ಎರಡನೇ ವಾದವು ನಮ್ಮ ಮೂಲವಾಗಿದೆ. 497 00:38:56,770 --> 00:39:10,310 ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ * ಗೆ ನಕಲಿಸಲು ನೀನು ಪಾಯಿಂಟರ್ "ಬೂಮ್" s. 498 00:39:10,310 --> 00:39:19,820 ಏಕೆ ನೀವು ಮೊದಲು ಬದಲಿಗೆ ನಾವು ಏನು ಒಂದು strcpy ಈ ಮಾಡಲು ಬಯಸಬಹುದು 499 00:39:19,820 --> 00:39:22,800 * s ನ = "ಬೂಮ್"? 500 00:39:22,800 --> 00:39:28,630 ಅಲ್ಲಿ ಇದನ್ನು ಮಾಡಲು ಬಯಸಬಹುದು ಕಾರಣವೆಂದರೆ, ಆದರೆ ಕಾರಣವನ್ನು ಏನು? 501 00:39:28,630 --> 00:39:31,940 [ವಿದ್ಯಾರ್ಥಿ] ನೀವು "ಬೂಮ್" ಏನೋ ಬದಲಾಯಿಸಲು ಬಯಸಿದರೆ. >> ಹೌದು. 502 00:39:31,940 --> 00:39:37,950 ಈಗ ನಾನು ರು ರೀತಿಯ ಮಾಡಬಹುದು [0] = 'ಎಕ್ಸ್'; 503 00:39:37,950 --> 00:39:48,190 ರು ಅಂಕಗಳನ್ನು ರಾಶಿ ಮೇಲೆ ರಾಶಿ ಮತ್ತು ಆ ಜಾಗವನ್ನು ಗೆ ರು ತೋರುತ್ತಿರುವಂತೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ 504 00:39:48,190 --> 00:39:52,320 "ಬೂಮ್" ಸಂಗ್ರಹಿಸುವ ಯಾವ ರಾಶಿ ಮೇಲೆ ಹೆಚ್ಚು ಜಾಗವನ್ನು ಒಂದು ಸೂಚಿಯಾಗಿದೆ. 505 00:39:52,320 --> 00:39:55,150 ಆದ್ದರಿಂದ "ಬೂಮ್" ಈ ಪ್ರತಿಯನ್ನು ರಾಶಿ ಶೇಖರವಾಗುತ್ತದೆ ಇದೆ. 506 00:39:55,150 --> 00:39:58,780 ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ "ಬೂಮ್" ಎರಡು ಪ್ರತಿಗಳನ್ನು ತಾಂತ್ರಿಕವಾಗಿ ಇವೆ. 507 00:39:58,780 --> 00:40:03,500 ಈ "ಬೂಮ್" ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ನೀಡಿದ ಎಂದು ಮೊದಲ ಬಾರಿಗೆ ಇಲ್ಲ 508 00:40:03,500 --> 00:40:09,250 ಮತ್ತು "ಬೂಮ್" ಎರಡನೇ ನಕಲು strcpy "ಬೂಮ್" ಪ್ರತಿಯನ್ನು ರಚಿಸಿದ. 509 00:40:09,250 --> 00:40:13,100 ಆದರೆ "ಬೂಮ್" ಪ್ರತಿಯು ರಾಶಿ ಶೇಖರಿಸಿಡಲು, ಮತ್ತು ರಾಶಿ ನೀವು ಬದಲಾಯಿಸಲು ಉಚಿತ ಆರ್ ಮಾಡಲಾಗುತ್ತಿದೆ. 510 00:40:13,100 --> 00:40:17,250 ರಾಶಿ ಓದಲು ಮಾತ್ರ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಅರ್ಥ ರು [0] 511 00:40:17,250 --> 00:40:20,500 ನೀವು "ಬೂಮ್" ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ ಹೋಗುತ್ತದೆ. 512 00:40:20,500 --> 00:40:23,130 ನೀವು ಆ ಪಾತ್ರಗಳು ಬದಲಾಯಿಸಲು ಅವಕಾಶ ವಿಶೇಷವೇನು. 513 00:40:23,130 --> 00:40:26,640 >> ಪ್ರಶ್ನೆಗಳು? 514 00:40:27,740 --> 00:40:29,290 ಸರಿ. 515 00:40:29,290 --> 00:40:35,500 >> , Buggy3 ಗೆ ನಾವು GDB buggy3 ಚಲಿಸುತ್ತಿರುತ್ತದೆ. 516 00:40:35,500 --> 00:40:39,840 ನಾವು ಚಾಲನೆ ಮತ್ತು ನಾವು ಒಂದು segfault ಪಡೆಯುವುದು ನೋಡಿ. 517 00:40:39,840 --> 00:40:46,550 ನಾವು backtrace ವೇಳೆ, ಕೇವಲ ಎರಡು ಕಾರ್ಯಗಳಿವೆ. 518 00:40:46,550 --> 00:40:52,970 ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ವಿಭಾಗಿಸಲ್ಪಟ್ಟಿದೆ ಹೋದರೆ, ನಾವು ಈ ಸಾಲಿನಲ್ಲಿ segfaulted ಎಂದು ನೋಡಿ. 519 00:40:52,970 --> 00:41:00,180 ಆದ್ದರಿಂದ ಕೇವಲ (ಕಾಲ, ಈ ರೇಖೆಯನ್ನು ನೋಡಿ ಇಂಟ್ ಲೈನ್ = 0; fgets ಈ ವಿಷಯವನ್ನು ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುತ್ತದೆ; 520 00:41:00,180 --> 00:41:03,770 ಸಾಲು + +). 521 00:41:03,770 --> 00:41:08,010 ನಮ್ಮ ಹಿಂದಿನ ಫ್ರೇಮ್ _IO_fgets ಕರೆಯಲಾಯಿತು. 522 00:41:08,010 --> 00:41:10,720 ಆ ಅಂತರ್ನಿರ್ಮಿತ ಸಿ ಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಬಹಳಷ್ಟು, ನೋಡುತ್ತಾರೆ 523 00:41:10,720 --> 00:41:15,350 ನೀವು segfault ಪಡೆದಾಗ, ನಿಜವಾಗಿಯೂ ರಹಸ್ಯ ಕಾರ್ಯ ಹೆಸರುಗಳಿವೆ ಎಂದು 524 00:41:15,350 --> 00:41:18,090 ಈ _IO_fgets ನಂತಹ. 525 00:41:18,090 --> 00:41:21,770 ಆದರೆ ಈ fgets ಕರೆ ಸಂಬಂಧವನ್ನು ವಿಶೇಷವೇನು. 526 00:41:21,770 --> 00:41:25,850 ಎಲ್ಲೋ ಇಲ್ಲಿ ಒಳಗೆ, ನಾವು segfaulting ಮಾಡಲಾಗುತ್ತದೆ. 527 00:41:25,850 --> 00:41:30,340 ನಾವು fgets ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ನೋಡಿದರೆ, ನಾವು ಬಫರ್ ಮುದ್ರಿಸಬಹುದು. 528 00:41:30,340 --> 00:41:41,180 ನ ಮುದ್ರಿಸಲು ಅವಕಾಶ ಒಂದು ಮಾಹಿತಿ - ಓಹ್, ಇಲ್ಲ. 529 00:41:48,980 --> 00:41:51,900 ಮುದ್ರಣ ನಿಖರವಾಗಿ ನಾನು ಬಯಸುತ್ತೇನೆ ಎಂದು ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ. 530 00:41:55,460 --> 00:41:58,000 ನಿಜವಾದ ಪ್ರೋಗ್ರಾಂ ನೋಡೋಣ. 531 00:42:02,200 --> 00:42:09,640 ಬಫರ್ ಒಂದು ಪಾತ್ರದ ರಚನೆ. ಇದು 128 ಅಕ್ಷರಗಳನ್ನು ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ನ. 532 00:42:09,640 --> 00:42:14,980 ಹಾಗಾಗಿ ಮುದ್ರಣ ಬಫರ್ ಹೇಳುತ್ತಾರೆ, ಅದು, ಆ 128 ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು 533 00:42:14,980 --> 00:42:18,300 ಇದು ನನ್ನ ಊಹೆಯ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಏನು. 534 00:42:18,300 --> 00:42:21,390 ನಾನು ಹುಡುಕುತ್ತಿದ್ದನು, ಬಫರ್ ವಿಳಾಸವನ್ನು ಮುದ್ರಿಸಲು ಆಗಿದೆ 535 00:42:21,390 --> 00:42:23,680 ಆದರೆ ನಿಜವಾಗಿಯೂ ನನಗೆ ಹೆಚ್ಚು ಹೇಳುವುದಿಲ್ಲ. 536 00:42:23,680 --> 00:42:30,770 ಹಾಗಾಗಿ ಇಲ್ಲಿ X ಬಫರ್ ಅನ್ನು ಹೇಳಲು ಉಂಟಾಗುತ್ತದೆ, ಅದು ನನಗೆ 0xbffff090 ತೋರಿಸುತ್ತದೆ 537 00:42:30,770 --> 00:42:38,690 ನೀವು ಹಿಂದಿನ ಅಥವಾ ಕೆಲವು ಬಿಂದುವಿನಿಂದ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ, Oxbffff ಒಂದು ಮೆದೆ ರೀತಿಯಲ್ಲಿ ಪ್ರದೇಶ ಎಂದು ನೀಡುತ್ತದೆ. 538 00:42:38,690 --> 00:42:46,020 ಸ್ಟಾಕ್ ಕೇವಲ 0xc000 ಅಡಿಯಲ್ಲಿ ಎಲ್ಲೋ ಆರಂಭಿಸಲು ಒಲವು. 539 00:42:46,020 --> 00:42:51,890 ಈ ವಿಳಾಸಕ್ಕೆ ನೋಡುವ ಮೂಲಕ, ನಾನು ಬಫರ್ ಸ್ಟಾಕ್ ಮೇಲೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. 540 00:42:51,890 --> 00:43:04,500 ಪ್ರತಿರೋಧಿಸುತ್ತದೆ, ಅಪ್, ರನ್, ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಪುನರ್ ನಾವು ಆಗಿತ್ತು ಪಾತ್ರಗಳು ಈ ಸರಣಿಯನ್ನು ಕಂಡಿತು 541 00:43:04,500 --> 00:43:06,530 ನಟನೆಯೆಂಬುದು ಅರ್ಥಹೀನ. 542 00:43:06,530 --> 00:43:12,270 ನಂತರ ಕಡತ ಮುದ್ರಣ, ಯಾವ ಫೈಲ್ ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ? 543 00:43:15,120 --> 00:43:17,310 [ವಿದ್ಯಾರ್ಥಿ] ಖಾಲಿ. >> ಹೌದು. 544 00:43:17,310 --> 00:43:22,610 , ಫೈಲ್ ಪ್ರಕಾರ FILE * ಒಂದು, ಆದ್ದರಿಂದ ಒಂದು ಸೂಚಿಯಾಗಿದೆ 545 00:43:22,610 --> 00:43:26,610 ಮತ್ತು ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಶೂನ್ಯ ಆಗಿದೆ. 546 00:43:26,610 --> 00:43:33,240 ಆದ್ದರಿಂದ fgets, ಪರೋಕ್ಷ ರೀತಿಯಲ್ಲಿ ಆ ಪಾಯಿಂಟರ್ ನಿಂದ ಓದಲು ಪ್ರಯತ್ನಿಸಿ ಹೋಗಿ ಇದೆ 547 00:43:33,240 --> 00:43:37,320 ಆದರೆ ಪಾಯಿಂಟರ್ ಪ್ರವೇಶಿಸಲು, ಇದು dereference ಅದು ಹೊಂದಿದೆ. 548 00:43:37,320 --> 00:43:40,550 ಅಥವಾ, ಇದು dereferences ಇದು ತೋರುತ್ತಿರುವಂತೆ ಏನು ಮಾಡಬೇಕೆಂದು ಪ್ರವೇಶಿಸಲು. 549 00:43:40,550 --> 00:43:43,810 ಆದ್ದರಿಂದ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಮತ್ತು segfaults dereferencing ನ. 550 00:43:46,600 --> 00:43:48,730 ನಾನು ಅದನ್ನು ಪುನಃ ಇರಬಹುದು. 551 00:43:48,730 --> 00:43:52,170 ನಮ್ಮ ಮುಖ್ಯ ಹಂತದಲ್ಲಿ ಮುರಿಯಲು ಮತ್ತು ರನ್ ವೇಳೆ, 552 00:43:52,170 --> 00:43:57,320 ಕೋಡ್ ಮೊದಲ ಸಾಲಿನ ಚಾರ್ * FILENAME = "nonexistent.txt" ಆಗಿದೆ; 553 00:43:57,320 --> 00:44:00,870 ಈ ಪ್ರೋಗ್ರಾಂ ವಿಫಲವಾದರೆ ಏಕೆ ಒಂದು ಸಾಕಷ್ಟು ದೊಡ್ಡ ಸುಳಿವು ನೀಡಬೇಕು. 554 00:44:00,870 --> 00:44:06,080 ನಾನು ಈ ಕಡತವನ್ನು ತೆರೆಯಲು ಅಲ್ಲಿ ಮುಂದಿನ ಟೈಪ್, ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ನನ್ನನ್ನು ತೆರೆದಿಡುತ್ತದೆ 555 00:44:06,080 --> 00:44:11,140 ತದನಂತರ ನಾನು ತಕ್ಷಣ ಒಮ್ಮೆ ನಾನು ಮುಂದಿನ ಹೊಡೆಯಲು ಅಲ್ಲಿ ನಮ್ಮ ಲೈನ್, ಮನಸ್ಸು, ಇದು segfault ಹೋಗುವುದಿಲ್ಲ. 556 00:44:11,140 --> 00:44:16,880 ಯಾರಾದರೂ ನಾವು segfaulting ಇರಬಹುದು ಏಕೆ ಒಂದು ಕಾರಣ ಔಟ್ ಎಸೆಯಲು ಬಯಸುವಿರಾ? 557 00:44:16,880 --> 00:44:19,130 [ವಿದ್ಯಾರ್ಥಿ] ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. >> ಹೌದು. 558 00:44:19,130 --> 00:44:22,250 ಈ ಸುಳಿವನ್ನು ಆಗಿರಬೇಕು 559 00:44:22,250 --> 00:44:29,570 ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುವಾಗ ಬಳಸುವಾಗಲೆಲ್ಲ ನೀವು ಫೈಲ್ ವಾಸ್ತವವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕು ಎಂದು. 560 00:44:29,570 --> 00:44:31,510 ಇಲ್ಲಿ, "nonexistent.txt"; 561 00:44:31,510 --> 00:44:34,700 ನಾವು ಓದುವ fopen FILENAME, ನಾವು ಹೇಳಲು ಅವಶ್ಯಕತೆ 562 00:44:34,700 --> 00:44:45,870 ವೇಳೆ (ಕಡತ == ಸಾಂಕೇತಿಕಕೊಂಡಿಯು) ಮತ್ತು printf ("ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ!" ಸೇ 563 00:44:45,870 --> 00:44:56,340 ಅಥವಾ - ಇನ್ನೂ ಉತ್ತಮ - FILENAME); ರಿಟರ್ನ್ 1; 564 00:44:56,340 --> 00:45:00,300 ಈಗ ನಾವು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇಲ್ಲಿದೆ ನೀವು ಪರೀಕ್ಷಿಸಿ 565 00:45:00,300 --> 00:45:03,930 ಮೊದಲು ವಾಸ್ತವವಾಗಿ ನಿರಂತರ ಮತ್ತು ಕಡತದಿಂದ ಓದಲು ಪ್ರಯತ್ನಿಸುವಾಗ. 566 00:45:03,930 --> 00:45:08,800 ನಾವು ಆ ಕೃತಿಗಳು ಎಂದು ನೋಡಲು ಅದನ್ನು ರೀಮೇಕ್ ಮಾಡಬಹುದು. 567 00:45:11,020 --> 00:45:14,970 ನಾನು ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಿ ಉದ್ದೇಶ. 568 00:45:21,090 --> 00:45:25,290 ಈಗ nonexistent.txt ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 569 00:45:26,890 --> 00:45:30,040 ನೀವು ಯಾವಾಗಲೂ ವಿಷಯವೆಂದರೆ ಈ ರೀತಿಯ ಪರಿಶೀಲಿಸಿ ಮಾಡಬೇಕು. 570 00:45:30,040 --> 00:45:33,870 ನೀವು ಯಾವಾಗಲೂ fopen ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಬೇಕು. 571 00:45:33,870 --> 00:45:38,170 ನೀವು ಯಾವಾಗಲೂ malloc ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬೇಕು 572 00:45:38,170 --> 00:45:41,410 ಅಥವಾ ನೀವು segfault. 573 00:45:42,200 --> 00:45:45,930 >> ಈಗ buggy4.c. 574 00:45:49,190 --> 00:45:58,440 ರನ್ನಿಂಗ್. ನಾನು ಇನ್ಪುಟ್ ಅಥವಾ ಬಹುಶಃ ಅನಂತ ಆವರ್ತಿಸುವ ಕಾಯುತ್ತಿದೆ ಈ ಊಹೆ ನುಡಿದರು. 575 00:45:58,440 --> 00:46:01,870 ಹೌದು, ಇದು ಅನಂತ ಆವರ್ತಿಸುವ ಇಲ್ಲಿದೆ. 576 00:46:01,870 --> 00:46:05,560 Buggy4 ಆದ್ದರಿಂದ. ನಾವು ಅನಂತ ಆವರ್ತಿಸುವ ತೋರುತ್ತಿದೆ. 577 00:46:05,560 --> 00:46:12,590 ನಾವು ಪ್ರಮುಖ ನಲ್ಲಿ ಮುರಿಯುತ್ತವೆ, ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ. 578 00:46:12,590 --> 00:46:20,180 GDB ರಲ್ಲಿ, ಅಲ್ಲಿಯವರೆಗೆ ನೀವು ಬಳಸಲು ಸಂಕ್ಷೇಪಣ ಸ್ಪಷ್ಟವಾಗಿದೆ ಎಂದು 579 00:46:20,180 --> 00:46:23,420 ಅಥವಾ ನೀವು ಒದಗಿಸುವ ವಿಶೇಷ ಸಂಕ್ಷೇಪಣಗಳು, 580 00:46:23,420 --> 00:46:29,020 ನಂತರ ನೀವು ಬದಲಿಗೆ ಮುಂದಿನ ಎಲ್ಲಾ ದಾರಿ ಟೈಪ್ ಹೊಂದುವ ಮುಂದಿನ ಬಳಸಲು N ಬಳಸಬಹುದು. 581 00:46:29,020 --> 00:46:33,730 ಮತ್ತು ಈಗ ನಾನು ಒಮ್ಮೆ ಹಿಟ್ N ಮಾಡಿರುವುದರಿಂದ, ನಾನು ಮುಂದಿನ ಮುಂದುವರಿಸುವುದಕ್ಕೆ ನಮೂದಿಸಿ ಹೊಡೆಯಬಹುದು 582 00:46:33,730 --> 00:46:36,640 ಬದಲಿಗೆ ಹಿಟ್ N ನಮೂದಿಸಿ, N ನಮೂದಿಸಿ, N ನಮೂದಿಸಿ ಹೊಂದುವ. 583 00:46:36,640 --> 00:46:44,630 ನಾನು [I] 0 ರಚನೆಯ ಹೊಂದಿಸುವ ಎಂದು ಲೂಪ್ ಫಾರ್ ತೆರನಾದ ಆಮ್ ತೋರುತ್ತಿದೆ. 584 00:46:44,630 --> 00:46:50,510 ಇದು ನಾನು ಲೂಪ್ ಈ ಆಫ್ ಹುಟ್ಟಿಕೊಂಡ ಎಂದಿಗೂ ನಾನು ತೋರುತ್ತಿದೆ. 585 00:46:50,510 --> 00:46:54,780 ನಾನು ಮುದ್ರಿಸಲು, ಹಾಗಾಗಿ 2 ವೇಳೆ, ನಂತರ ನಾನು ಮುಂದಿನ ಹೋಗುತ್ತೇನೆ. 586 00:46:54,780 --> 00:46:59,250 ನಾನು ಮುಂದಿನ ಹೋಗುತ್ತೇನೆ ನಾನು 3, ನಾನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ. 587 00:46:59,250 --> 00:47:05,360 ನಾನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಾನು 3. ಮುಂದೆ, ನಾನು ಮುದ್ರಿಸಲು, ಇ 4. 588 00:47:05,360 --> 00:47:14,520 ವಾಸ್ತವವಾಗಿ, ಮುದ್ರಣ sizeof (ಸರಣಿ), ಆದ್ದರಿಂದ ರಚನೆಯ ಗಾತ್ರ 20 ಆಗಿದೆ. 589 00:47:16,310 --> 00:47:32,870 ಕೆಲವು ವಿಶೇಷ GDB ಆಜ್ಞೆಯನ್ನು ಏನಾದರೂ ಸಂಭವಿಸಿದರೆ ರವರೆಗೆ ಹೋಗುವ ಇಲ್ಲ ಆದರೆ ಇದು ಕಾಣುತ್ತದೆ. 590 00:47:32,870 --> 00:47:37,620 ಇದು ವೇರಿಯಬಲ್ ಮೌಲ್ಯದ ಒಂದು ಸ್ಥಿತಿ ಸೆಟ್ಟಿಂಗ್ ರೀತಿಯಲ್ಲಿ. ಆದರೆ ನಾನು ನೆನಪಿರುವುದಿಲ್ಲ. 591 00:47:37,620 --> 00:47:44,100 - ನಾವು ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಹಾಗಿದ್ದಲ್ಲಿ 592 00:47:44,100 --> 00:47:47,120 ನೀವು ಏನು ಹೇಳುತ್ತಿದ್ದಾರೆ ಮಾಡಲಾಯಿತು? ನೀವು ಹೇಗಿದ್ದೀರಿ ತರಲು ಹೋಗಲಿಲ್ಲ? 593 00:47:47,120 --> 00:47:50,500 [ವಿದ್ಯಾರ್ಥಿ] ಪ್ರದರ್ಶಿಸಲು ನಾನು ಸೇರಿಸಲು ಡಸ್ - >> ಹೌದು. ನಾನು ಸಹಾಯ ಮಾಡಬಹುದು ಪ್ರದರ್ಶಿಸಲು. 594 00:47:50,500 --> 00:47:54,530 ನಾವು ನಾನು ಪ್ರದರ್ಶಿಸಲು ವೇಳೆ, ನಾನು ಮೌಲ್ಯವನ್ನು ಏನು ಇಲ್ಲಿ ಹಾಕುತ್ತಾನೆ 595 00:47:54,530 --> 00:47:56,470 ಆದ್ದರಿಂದ ನಾನು ಪ್ರತಿ ಬಾರಿ ಅದನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿಲ್ಲ. 596 00:47:56,470 --> 00:48:02,930 ನಾವು ಮುಂದಿನ ಮುಂದುವರಿಸುವುದಕ್ಕೆ, ನಾವು 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 ನೋಡಿ. 597 00:48:02,930 --> 00:48:08,530 ಏನೋ ಆಪತ್ತು ತಪ್ಪು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಐ 0 ಮರುಹೊಂದಿಸಿ ಮಾಡಲಾಗುತ್ತಿದೆ. 598 00:48:13,330 --> 00:48:22,220 Buggy4.c ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನಾವು ನಡೆಯುವ ಎಲ್ಲಾ ಇಂಟ್ ರಚನೆಯ [5] ನೋಡಿ; 599 00:48:22,220 --> 00:48:26,200 (; ನಾನು <= sizeof (ಸರಣಿ); ನಾನು + + ನಾನು = 0) 600 00:48:26,200 --> 00:48:28,550 ರಚನೆಯ [I] = 0; 601 00:48:28,550 --> 00:48:31,390 ನಾವು ಇಲ್ಲಿ ತಪ್ಪು ಎಂಬುದನ್ನು ನೋಡುತ್ತಾರೆ? 602 00:48:31,390 --> 00:48:39,480 ಸುಳಿವು ಎಂದು, ನಾನು GDB buggy4 ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ - ಮುಖ್ಯ, ರನ್ ಮುರಿಯಲು ನಾವು - 603 00:48:39,480 --> 00:48:45,980 ನಾನು ಮುದ್ರಣ sizeof (ಸರಣಿ) ನಾನು ಅಂತಿಮವಾಗಿ ಔಟ್ ಉಂಟುವಾಡುವುದಿಲ್ಲ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ ಎಂಬುದನ್ನು ನೀಡಲಿಲ್ಲ. 604 00:48:47,690 --> 00:48:51,100 ಅಲ್ಲಿ ನಾನು? ನಾನು ಔಟ್ ನೀಡಲಿಲ್ಲ? 605 00:48:51,100 --> 00:48:54,280 ನಾನು ಇನ್ನೂ ಘೋಷಿಸಲು ಮಾಡಲಿಲ್ಲ. 606 00:48:54,280 --> 00:48:58,680 ಆದ್ದರಿಂದ, sizeof (ಸರಣಿ) ಮುದ್ರಿಸಲು ಮತ್ತು 20 ರ 607 00:48:58,680 --> 00:49:06,690 ಇದು ನನ್ನ ರಚನೆಯ ಗಾತ್ರ 5 ಏಕೆಂದರೆ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಮತ್ತು 5 ಪೂರ್ಣಾಂಕಗಳ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ 608 00:49:06,690 --> 00:49:12,410 ಆದ್ದರಿಂದ ಇಡೀ ವಿಷಯ sizeof (ಇಂಟ್) 4 ಕಾಣುತ್ತಾರೆ ಅಲ್ಲಿ 5 * sizeof (ಇಂಟ್) ಬೈಟ್ಗಳು, ಇರಬೇಕು. 609 00:49:12,410 --> 00:49:14,780 ಆದ್ದರಿಂದ sizeof (ಸರಣಿ) 20. 610 00:49:14,780 --> 00:49:17,420 ಈ ಏನಾಗಿರಬೇಕು? 611 00:49:17,420 --> 00:49:21,720 [ವಿದ್ಯಾರ್ಥಿ] sizeof (ಇಂಟ್) ಭಾಗಿಸಿ. >> ಹೌದು, / sizeof (ಇಂಟ್). 612 00:49:21,720 --> 00:49:30,630 ಸಮಸ್ಯೆ ಇಲ್ಲಿ ಇನ್ನೂ ತೋರುತ್ತಿದೆ. ನಾನು ಕೇವಲ ಎಂದೆನಿಸುವ < 613 00:49:30,630 --> 00:49:36,960 ಅದು ಬಹುಮಟ್ಟಿಗೆ ಯಾವಾಗಲೂ ಯ <ಮತ್ತು ಎಂದಿಗೂ <=. 614 00:49:36,960 --> 00:49:44,860 ಈಗ ಈ ವಾಸ್ತವವಾಗಿ ಮುರಿದು ಏಕೆ ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡೋಣ. 615 00:49:44,860 --> 00:49:53,370 ಯಾರಾದರೂ ನಾನು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ಮೂಲಕ 0 ಊಹೆಗಳು ಮರುಹೊಂದಿಸಿದ್ದೇವೆ ಹ್ಯಾವ್? 616 00:50:01,300 --> 00:50:09,350 ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ ಎಂದು ಒಳಗೆ ಮಾತ್ರ ವಿಷಯ [I] 0 ಗೆ ಸೆಟ್ ಎಂದು ರಚನೆ. 617 00:50:09,350 --> 00:50:15,350 ಆದ್ದರಿಂದ ಹೇಗಾದರೂ, ಕೋಡ್ ಈ ಸಾಲನ್ನು ನಾನು 0 ಅನ್ನು ನಮ್ಮ ಇಂಟ್ ಕಾರಣವಾಗಿದೆ. 618 00:50:16,730 --> 00:50:23,130 ನಾನು ಈ ಭಾಗದ ಮೆಮೊರಿ ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಸಾಧ್ಯ 619 00:50:23,130 --> 00:50:27,970 ಅದು ರಚನೆಯ ಮುಂದಿನ ಅಂಶವಾಗಿದೆ? ಭಾವಿಸುತ್ತಾರೆ ಯಾವಾಗ >> [ಬೌಡೆನ್] ಹೌದು. 620 00:50:27,970 --> 00:50:33,880 ನಮ್ಮ ರಚನೆಯ ಕೊನೆಯ ಮೀರಿ ನೀವು, 621 00:50:33,880 --> 00:50:39,870 ನಾವು ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ನೀವು ಹೇಗಾದರೂ ಆ ಜಾಗವನ್ನು ನಾನು ಮೌಲ್ಯವನ್ನು ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ಇದೆ. 622 00:50:39,870 --> 00:50:48,030 ನಾವು buggy4 ತನಿಖೆ ವೇಳೆ ಆದ್ದರಿಂದ, ಮುಖ್ಯ, ರನ್ ಮುರಿಯಲು 623 00:50:48,030 --> 00:50:53,120 ಐ ಆಫ್ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ಅವಕಾಶ. 624 00:50:53,120 --> 00:50:57,280 ಇದು bffff124 ಕಾಣುತ್ತಿಲ್ಲ. 625 00:50:57,280 --> 00:51:03,930 ಈಗ ಅವರ ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ಅವಕಾಶ [0]. 110. 626 00:51:03,930 --> 00:51:06,290 ಏನು [1] ಬಗ್ಗೆ? 114. 627 00:51:06,290 --> 00:51:07,920 [2], 118. 628 00:51:07,920 --> 00:51:14,530 11C, 120. ರಚನೆಯ [5] bfff124 ಹೊಂದಿದೆ. 629 00:51:14,530 --> 00:51:26,990 ಅರೇ ಆದ್ದರಿಂದ [5] ನಾನು ಆ ಶ್ರೇಣಿಯನ್ನು [5] ನಾನು ಅಂದರೆ ಅದೇ ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ. 630 00:51:26,990 --> 00:51:30,720 ಅವರು ಅದೇ ವಿಳಾಸಕ್ಕೆ ಹೊಂದಿದ್ದರೆ, ಅವು ಒಂದೇ ಆಗಿವೆ. 631 00:51:30,720 --> 00:51:38,410 ನಾವು ಸರಣಿ [5] ಸೆಟ್ ಮಾಡಿದಾಗ 0 ಗೆ, ನಾವು 0 ಗೆ ನಾನು ಮಾಡುತ್ತಿದ್ದೀರಿ. 632 00:51:38,410 --> 00:51:46,070 ಮತ್ತು ನೀವು ಸ್ಟಾಕ್ ಪರಿಭಾಷೆಯಲ್ಲಿ ಈ ಬಗ್ಗೆ ನಿಮಗೆ ಅನಿಸಿದರೆ, 633 00:51:46,070 --> 00:51:55,590 ಇಂಟ್ ನಾನು ಸ್ಟಾಕ್ ಕೆಲವು ಜಾಗವನ್ನು ಗೆಟ್ಸ್ ಅಂದರೆ, ಮೊದಲ ಘೋಷಿಸಲಾಗುತ್ತದೆ. 634 00:51:55,590 --> 00:52:04,730 ನಂತರ ಸರಣಿ [5] ಆದ್ದರಿಂದ 20 ಬೈಟ್ಗಳು ಸ್ಟಾಕ್ ಮೇಲೆ ಹಂಚಲಾಗುತ್ತದೆ, ಹಂಚಿಕೆ ಇದೆ. 635 00:52:04,730 --> 00:52:08,400 ಆದ್ದರಿಂದ ನಾನು ಈ 20 ಬೈಟ್ಗಳು ನಿಯೋಜಿತವಾದ ಪಡೆಯುತ್ತೀರಿ, ಮೊದಲ ನಿಯೋಜಿತವಾದ ಮುಟ್ಟುತ್ತದೆ. 636 00:52:08,400 --> 00:52:11,400 ಆದ್ದರಿಂದ, ಸರಿಯಾದ ಶ್ರೇಣಿಯನ್ನು ಮುಂಚಿತವಾಗಿ ನಡೆಯುತ್ತದೆ 637 00:52:11,400 --> 00:52:19,230 ಮತ್ತು ರೀತಿಯ ಕಾರಣ ನಾನು, ತಾಂತ್ರಿಕವಾಗಿ ಸ್ಟಾಕ್ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತದೆ, ಕಳೆದ ವಾರ ಹೇಳಿದರು 638 00:52:19,230 --> 00:52:28,520 ಒಂದು ಅರ್ರೆಯ್ ಗೆ ನೀವು ಸೂಚ್ಯಂಕ, ನಾವು ಖಾತರಿ ಎಂದು ಶ್ರೇಣಿಯಲ್ಲಿನ 0th ಸ್ಥಾನ 639 00:52:28,520 --> 00:52:31,970 ಯಾವಾಗಲೂ ರಚನೆಯ ಮೊದಲ ಸ್ಥಾನವನ್ನು ಮೊದಲು ನಡೆಯುತ್ತದೆ. 640 00:52:31,970 --> 00:52:35,900 ನಾನು ಕಳೆದ ವಾರ ಚಿತ್ರಿಸಿದಂತೆ ಹೇಗೆ ರೀತಿಯ. 641 00:52:35,900 --> 00:52:42,210 ಕೆಳಗೆ ನಾವು ವಿಳಾಸಕ್ಕೆ 0 ಮತ್ತು ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾವು ವಿಳಾಸಕ್ಕೆ ಮ್ಯಾಕ್ಸ್ ಎಂದು ಗಮನಿಸಿ. 642 00:52:42,210 --> 00:52:44,880 ಸ್ಟಾಕ್ ಯಾವಾಗಲೂ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತಿದೆ. 643 00:52:48,100 --> 00:52:53,500 ನಮಗೆ ನಾನು ನಿಯೋಜಿಸಿ ಹೇಳುತ್ತಾರೆ. 644 00:52:53,500 --> 00:52:59,680 ನಾವು ಪೂರ್ಣಾಂಕ ನಿಯೋಜಿಸಿ ನಾನು, ನಾವು ಇಲ್ಲಿ ಪೂರ್ಣಾಂಕ ನಾನು ನಿಯೋಜಿತವಾದ ಮುಟ್ಟುತ್ತದೆ ಅಪ್ ಹೇಳಿ ಅಂದರೆ. 645 00:52:59,680 --> 00:53:06,420 ನಂತರ ನಾವು ಕೆಳಗೆ ಅಂದರೆ 5 ಪೂರ್ಣಾಂಕಗಳ ನಮ್ಮ ರಚನೆಯ, ನಿಯೋಜಿಸಿ 646 00:53:06,420 --> 00:53:11,230 ಸ್ಟಾಕ್ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತಿರುವ ಕಾರಣ, ಆ 5 ಪೂರ್ಣಾಂಕಗಳ ನಿಯೋಜಿತವಾದ ಪಡೆಯುತ್ತೀರಿ. 647 00:53:11,230 --> 00:53:15,900 ಆದರೆ ರಚನೆಗಳು ಹೇಗೆ ಕೆಲಸ ಕಾರಣ, ನಾವು ಖಾತರಿ ನೀವು ರಚನೆಯ ಮೊದಲ ಸ್ಥಾನ 648 00:53:15,900 --> 00:53:22,260 ಯಾವಾಗಲೂ ರಚನೆಯ ಎರಡನೆಯ ವಿಷಯ ಕಡಿಮೆ ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ. 649 00:53:22,260 --> 00:53:28,270 ಆದ್ದರಿಂದ ರಚನೆಯ ಸ್ಥಾನವನ್ನು 0 ಯಾವಾಗಲೂ ಮೆಮೊರಿ ಮೊದಲ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ 650 00:53:28,270 --> 00:53:30,700 ಸರಣಿ 1 ಸ್ಥಾನವನ್ನು ನಂತರ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ ಆದರೆ 651 00:53:30,700 --> 00:53:33,310 ಮತ್ತು ಶ್ರೇಣಿಯನ್ನು ಸ್ಥಾನವನ್ನು 2, ನಂತರ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ 652 00:53:33,310 --> 00:53:37,900 ಆ ಸರಣಿ ಸ್ಥಾನವನ್ನು 0, ಕೆಳಗೆ ಇಲ್ಲಿ ಎಲ್ಲೋ ಏನಾಗಬಹುದು ಅರ್ಥ 653 00:53:37,900 --> 00:53:40,690 ಅರೇ ಸ್ಥಾನ 1 ಆ ಮೇಲೆ ಏನಾಗಬಹುದು 654 00:53:40,690 --> 00:53:45,530 ಮೂವಿಂಗ್ ಅಪ್ ಗರಿಷ್ಠ ವಿಳಾಸಕ್ಕೆ ಇಲ್ಲಿ ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ವಿಳಾಸಗಳನ್ನು ಅರ್ಥ. ಏಕೆಂದರೆ 655 00:53:45,530 --> 00:53:50,490 ಕೆಳಗೆ ಇಲ್ಲಿ ರಚನೆಯ [0] ಆದ್ದರಿಂದ, ಸರಣಿ [1] ಅನ್ನು ಇಲ್ಲಿ, ಸರಣಿ [2] ಅನ್ನು ಇಲ್ಲಿ, ಸರಣಿ [3] ಅನ್ನು ಇಲ್ಲಿ. 656 00:53:50,490 --> 00:53:55,620 ನಾವು ಇಲ್ಲಿ ನಾನು ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಅಪ್, ಪೂರ್ಣಾಂಕ ಹಂಚಿಕೆ ಹೇಗೆ ಮುನ್ನ ಗಮನಿಸಿ 657 00:53:55,620 --> 00:54:01,040 ನಮ್ಮ ರಚನೆಯ ಮೇಲೆ ಮತ್ತಷ್ಟು ಪ್ರಯಾಣ, ನಾವು ಹತ್ತಿರಕ್ಕೆ ನಮ್ಮ ಪೂರ್ಣಾಂಕ ನಾನು ಪಡೆಯುತ್ತಿದ್ದಾರೆ. 658 00:54:01,040 --> 00:54:07,640 ಅದು ಹಾಗೆ, ಇದು ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಮೀರಿ ಒಂದು ಸ್ಥಾನವನ್ನು, ಆ ಶ್ರೇಣಿಯನ್ನು [5] ಸಂಭವಿಸುತ್ತದೆ 659 00:54:07,640 --> 00:54:13,010 ಅದನ್ನೇ ಹಂಚಲಾಗುವುದು ಏನಾಯಿತು ಅಲ್ಲಿ ಪೂರ್ಣಾಂಕವಾಗಿರುತ್ತದೆ. 660 00:54:13,010 --> 00:54:16,920 ಆದ್ದರಿಂದ ನಾವು ಸ್ಟಾಕ್ ಜಾಗವನ್ನು ಅಪ್ಪಳಿಸುತ್ತಿರಬಹುದು ಸಂಭವಿಸಿದಾಗ ಅಲ್ಲಿ ಪಾಯಿಂಟುಗಳ 661 00:54:16,920 --> 00:54:21,680 ಆ ಪೂರ್ಣಾಂಕ ನಾನು ನೀಡಲಾಯಿತು, ಮತ್ತು ನಾವು 0 ಹೊಂದಿಸುವಾಗ ನೀವು. 662 00:54:21,680 --> 00:54:26,160 >> ಆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಪ್ರಶ್ನೆಗಳು? ಹೌದು. 663 00:54:26,160 --> 00:54:30,710 [ವಿದ್ಯಾರ್ಥಿ] ಪರವಾಗಿಲ್ಲ. ಸರಿ. 664 00:54:30,710 --> 00:54:33,090 [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ದೋಷಗಳನ್ನು ಈ ಬಗೆಯ ತಪ್ಪಿಸಬಹುದು? 665 00:54:33,090 --> 00:54:41,190 ದೋಷಗಳು ಈ ತೆರನಾದ? ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಸಿ ಬಳಸಬೇಡಿ. 666 00:54:41,190 --> 00:54:45,840 ಪರೀಕ್ಷಿಸುವ ಅರೇ ಬೌಂಡ್ಸ್ ಹೊಂದಿದೆ ಒಂದು ಭಾಷೆಯನ್ನು ಬಳಸಿ. 667 00:54:45,840 --> 00:54:55,900 ಎಲ್ಲಿಯವರೆಗೆ ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ಮಾಡಿದಾಗ, ನಿಮ್ಮ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ದಾಟಿ ತಪ್ಪಿಸಲು ಅಗತ್ಯವಿದೆ. 668 00:54:55,900 --> 00:54:58,300 [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಿಮ್ಮ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ದಾಟಿ ಹೋದಾಗ - 669 00:54:58,300 --> 00:55:01,840 [ಬೌಡೆನ್] ವಿಷಯಗಳನ್ನು ತಪ್ಪು ಹೋಗುವ ಆರಂಭಿಸಲು ಅಲ್ಲೇ. >> [ವಿದ್ಯಾರ್ಥಿ] ಓಹ್, ಸರಿ. 670 00:55:01,840 --> 00:55:05,730 ಎಲ್ಲಿಯವರೆಗೆ ನಿಮ್ಮ ಶ್ರೇಣಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಒಳಗೆ ಮಾಹಿತಿ, ನೀವು ಉತ್ತಮ ಆರ್. 671 00:55:05,730 --> 00:55:12,400 ಆದರೆ ಸಿ ಯಾವುದೇ ದೋಷ ತಪಾಸಣೆ ಮಾಡುವುದಿಲ್ಲ. ನಾನು ರಚನೆಯ ಮಾಡಿದರೆ [1000], ಇದು ಸಂತೋಷದಿಂದ ಕೇವಲ ಸಂಭವಿಸಿದರೆ ಯಾವುದೇ ಮಾರ್ಪಡಿಸಿ ಕಾಣಿಸುತ್ತದೆ - 672 00:55:12,400 --> 00:55:16,500 ಇದು ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ಹೋಗುತ್ತದೆ, ಅದು ನಂತರ 1000 ಸ್ಥಾನಗಳ ಹೋಗುತ್ತದೆ ಮತ್ತು ಇದು 0 ಹೊಂದಿಸುತ್ತದೆ. 673 00:55:16,500 --> 00:55:20,000 ಇದು ಓಹ್, ಈ ವಾಸ್ತವವಾಗಿ ಇದು 1000 ವಿಷಯಗಳನ್ನು ಯಾವುದೇ ತಪಾಸಣೆ ಮಾಡುವುದಾಗಲೀ. 674 00:55:20,000 --> 00:55:22,750 1000, ರೀತಿಯಲ್ಲಿ ನಾನು ಬದಲಾವಣೆ ಮಾಡಬೇಕು ಮೀರಿ ಆಗಿದೆ 675 00:55:22,750 --> 00:55:26,940 ಜಾವಾ ಅಥವಾ ನೀನು ಪರಿಧಿಯಿಂದ ಸೂಚ್ಯಂಕದ ರಚನೆಯ ಔಟ್ ಪಡೆಯುತ್ತೀರಿ ಆದರೆ 676 00:55:26,940 --> 00:55:29,820 ಅಥವಾ ಗಡಿಯಿಂದ ಎಕ್ಸೆಪ್ಶನ್ ಸೂಚ್ಯಂಕ ಔಟ್. 677 00:55:29,820 --> 00:55:33,950 ಉನ್ನತ ಮಟ್ಟದ ಭಾಷೆ ಬಹಳಷ್ಟು ಈ ವಿಷಯಗಳನ್ನು ಏಕೆ ಆ 678 00:55:33,950 --> 00:55:37,340 ನೀವು ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ಮೀರಿ ಹೋದರೆ ಅಲ್ಲಿ, ನೀವು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ 679 00:55:37,340 --> 00:55:40,070 ನೀವು ಕೆಳಗೆ ವಸ್ತುಗಳ ಬದಲಿಸಲಾಗುವುದಿಲ್ಲ ಆದ್ದರಿಂದ 680 00:55:40,070 --> 00:55:42,590 ತದನಂತರ ವಿಷಯಗಳನ್ನು ಕೇವಲ ಒಂದು ವಿನಾಯಿತಿ ಪಡೆಯಲು ಹೆಚ್ಚು ಕೆಟ್ಟದಾಗಿ ಹೋಗಿ 681 00:55:42,590 --> 00:55:44,940 ನೀವು ರಚನೆಯ ಕೊನೆಯ ಆಚೆ ಹೋಯಿತು ಎಂದು. 682 00:55:44,940 --> 00:55:50,970 [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನಾವು ಬದಲಾಗಿದೆ ಬೇಕು <= ಕೇವಲ > [ಬೌಡೆನ್] ಹೌದು. 683 00:55:50,970 --> 00:55:54,800 ಇದು 00:55:59,560 sizeof (ಸರಣಿ) 20 ಆಗಿದೆ, ಆದರೆ ನಾವು ಕೇವಲ 5 ಬಯಸುವ ರಿಂದ. >> [ವಿದ್ಯಾರ್ಥಿ] ರೈಟ್. 685 00:55:59,560 --> 00:56:04,060 ಹೆಚ್ಚು ಪ್ರಶ್ನೆಗಳು? ಸರಿ. 686 00:56:04,060 --> 00:56:07,380 >> [ವಿದ್ಯಾರ್ಥಿ] ನಾನು ಒಂದು ಪ್ರಶ್ನೆ ಹೊಂದಿವೆ. >> ಹೌದು. 687 00:56:07,380 --> 00:56:16,440 [ವಿದ್ಯಾರ್ಥಿ] ನಿಜವಾದ ರಚನೆಯ ವೇರಿಯಬಲ್ ಎಂದರೇನು? 688 00:56:16,440 --> 00:56:20,000 [ಬೌಡೆನ್] ಲೈಕ್ ರಚನೆಯ ಏನು? 689 00:56:20,000 --> 00:56:24,930 ಅರೇ ಸ್ವತಃ ಸಂಕೇತವಾಗಿದೆ. 690 00:56:24,930 --> 00:56:31,490 ನಾವು ಗುರುತಿಸಲಾಗುತ್ತಿದೆ ಎಂದು 20 ಬೈಟ್ಗಳು ಆರಂಭದ ವಿಳಾಸ. 691 00:56:31,490 --> 00:56:38,070 ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು ನಗರದ, ಆದರೆ ಅದು ಒಂದು ಸ್ಥಿರ ಸೂಚಿಯಾಗಿದೆ. 692 00:56:38,070 --> 00:56:44,140 ತಕ್ಷಣ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದರು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ವೇರಿಯಬಲ್ ರಚನೆಯ ಎಲ್ಲಿಯೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 693 00:56:44,140 --> 00:56:48,210 [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಹೇಗೆ ರಚನೆಯ ಗಾತ್ರ ಹೇಗೆ ಮಾಡುತ್ತದೆ? 694 00:56:48,210 --> 00:56:54,130 ರಚನೆಯ ಗಾತ್ರ ಆ ಚಿಹ್ನೆಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ಬ್ಲಾಕ್ ಗಾತ್ರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. 695 00:56:54,130 --> 00:57:01,240 ನಾನು printf ರೀತಿಯ ("% ಪುಟ \ n", ಸರಣಿ) ಮಾಡಿದಾಗ; 696 00:57:01,240 --> 00:57:05,140 ನ ಚಲಾಯಿಸಲು ಅವಕಾಶ. 697 00:57:12,960 --> 00:57:15,530 ನಾನು ಏನು ತಪ್ಪು ಮಾಡಿದನು? 698 00:57:15,530 --> 00:57:19,220 ಅರೇ 'ವ್ಯೂಹ' ಇಲ್ಲಿ ಘೋಷಿಸಿದರು. 699 00:57:20,820 --> 00:57:23,200 ಓಹ್, ಅಪ್ ಇಲ್ಲಿ. 700 00:57:23,200 --> 00:57:31,250 ಖಣಿಲು ಚತುರ, ಮತ್ತು ನಾನು 5 ಅಂಶಗಳನ್ನು ಮಾಹಿತಿ ರಚನೆಯ ಡಿಕ್ಲೇರ್ಡ್ ಗಮನಿಸಿದಿರಾ ಸಂಭವಿಸಿದರೆ 701 00:57:31,250 --> 00:57:34,540 ಆದರೆ ನಾನು ಸ್ಥಾನವನ್ನು 1000 ಗೆ ಸೂಚಿ ನುಡಿದರು. 702 00:57:34,540 --> 00:57:38,450 ಈ ಕೇವಲ ಸ್ಥಿರ ಏಕೆಂದರೆ ಹಾಗೆ ಮಾಡಬಹುದು. 703 00:57:38,450 --> 00:57:43,370 ಇದು ಕೇವಲ ನನ್ನ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ಮೀರಿ ನಾನು ಗಮನಿಸಿದ ಇಲ್ಲಿಯವರೆಗೆ ಹೋಗಬಹುದು. 704 00:57:43,370 --> 00:57:46,880 ಆದರೆ, ನಾವು ನಾನು ತಪ್ಪಾಗಿರಬಹುದು ಬಂದಾಗ ಮೊದಲು ಗಮನಕ್ಕೆ 705 00:57:46,880 --> 00:57:51,040 ಅದು, ನಾನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಷ್ಟು ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ 706 00:57:51,040 --> 00:57:55,540 ಆದ್ದರಿಂದ ನಾನು ರಚನೆಯ ಕೊನೆಯ ಮೀರಿ ಎಂದು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. 707 00:57:55,540 --> 00:57:59,430 ಕೇವಲ ಚತುರ ಎಂದು ಖಣಿಲು ಇಲ್ಲಿದೆ. 708 00:57:59,430 --> 00:58:03,340 >> ಆದರೆ ಈಗ buggy4 ಮಾಡಿ. ನಾನು ತಪ್ಪು ಬೇರೆ ಏನು ನಾನು? 709 00:58:03,340 --> 00:58:05,970 ಸೂಚ್ಯವಾಗಿ ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ 'printf' ಘೋಷಿಸಿದರು. 710 00:58:05,970 --> 00:58:14,960 ನಾನು # ಸೇರಿಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. 711 00:58:14,960 --> 00:58:18,710 ಸರಿ. ಈಗ buggy4 ಚಾಲನೆಯಲ್ಲಿರುವ. 712 00:58:18,710 --> 00:58:24,840 ರೀತಿಯ ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುವ ನಾನು ಪಾಯಿಂಟರ್ ಅದನ್ನು ಮುದ್ರಿಸುವ, ಇಲ್ಲಿ ಮಾಡಿದರು 713 00:58:24,840 --> 00:58:30,060 ಈ ತೋರುತ್ತಿದೆ ಎಂದು ಮುದ್ರಿತ ಏನೋ - bfb8805c - ಕೆಲವು ವಿಳಾಸಕ್ಕೆ ಇದು 714 00:58:30,060 --> 00:58:33,450 ಆ ಸ್ಟಾಕ್-ರೀತಿಯಲ್ಲಿ ಪ್ರದೇಶದಲ್ಲಿ ನ. 715 00:58:33,450 --> 00:58:41,820 , ಅರೇ ಸ್ವತಃ ಒಂದು ಪಾಯಿಂಟರ್ ರೀತಿಯ, ಆದರೆ ಇದು ನಿಜವಾದ ಪಾಯಿಂಟರ್ ಅಲ್ಲ 716 00:58:41,820 --> 00:58:45,410 ಸಾಮಾನ್ಯ ಪಾಯಿಂಟರ್ ರಿಂದ ನಾವು ಬದಲಾಯಿಸಬಹುದು. 717 00:58:45,410 --> 00:58:54,700 ಅರೇ ಕೆಲವು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಮೆಮೊರಿ 20 ಬ್ಲಾಕ್ಗಳನ್ನು ವಿಳಾಸಕ್ಕೆ 0xbfb8805c ಆರಂಭವಾಗುವುದು. 718 00:58:54,700 --> 00:59:09,020 ಈ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಆದ್ದರಿಂದ bfb8805c +20- ಅಥವಾ ನಾನು -20 ಊಹೆ - 719 00:59:09,020 --> 00:59:17,400 ಈ ಶ್ರೇಣಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಎಲ್ಲ ಆಗಿದೆ. 720 00:59:17,400 --> 00:59:20,350 ಅರೇ, ವೇರಿಯಬಲ್ ಸ್ವತಃ ಎಲ್ಲಿಯಾದರೂ ಸಂಗ್ರಹಿಸಲು ಆಗುವುದಿಲ್ಲ. 721 00:59:20,350 --> 00:59:27,660 ನೀವು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ, ಕಂಪೈಲರ್ - ಇದು ಕೈ ತರಂಗ - 722 00:59:27,660 --> 00:59:33,060 ಇದು ಸರಣಿಯಾಗಿರಬೇಕು ತಿಳಿದುಕೊಳ್ಳದೇ ಅಲ್ಲಿ ಆದರೆ ಕಂಪೈಲರ್ ಕೇವಲ ಬಳಸುತ್ತದೆ. 723 00:59:33,060 --> 00:59:36,090 ಆ ಸರಣಿ ಆರಂಭವಾಗುತ್ತದೆ ಅಲ್ಲಿ ಇದು ತಿಳಿದಿರುವ 724 00:59:36,090 --> 00:59:40,910 ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಯಾವಾಗಲೂ ಕೇವಲ ಆರಂಭದಿಂದಲೂ ಪರಿಹಾರಗಳನ್ನು ಪರಿಭಾಷೆಯಲ್ಲಿ ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು. 725 00:59:40,910 --> 00:59:43,960 ಇದು ರಚನೆಯ ಪ್ರತಿನಿಧಿಸಲು ವೇರಿಯಬಲ್ ಸ್ವತಃ ಅಗತ್ಯವಿಲ್ಲ. 726 00:59:43,960 --> 00:59:53,730 ಆದರೆ ನಾನು ಇಂಟ್ * ಪು = ರಚನೆಯ ಸ್ವಲ್ಪ ಮಾಡಿದಾಗ; ಈಗ ಪು, ಆ ಶ್ರೇಣಿಯನ್ನು ಕೇಂದ್ರೀಕೃತವಾಗಿರುವ ಸೂಚಿಯಾಗಿದೆ 727 00:59:53,730 --> 00:59:57,830 ಮತ್ತು ಈಗ ಪುಟ ವಾಸ್ತವವಾಗಿ ಸ್ಟಾಕ್ ಮೇಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತದೆ. 728 00:59:57,830 --> 01:00:01,950 ನಾನು ಪುಟ ಬದಲಾಯಿಸಲು ಉಚಿತ ಆಮ್. ನಾನು ಪುಟ = malloc ಮಾಡಬಹುದು. 729 01:00:01,950 --> 01:00:06,500 ಆದ್ದರಿಂದ ಮೂಲತಃ ರಚನೆಯ ತೋರಿಸಿದರು; ಈಗ ರಾಶಿ ಮೇಲೆ ಕೆಲವು ಜಾಗವನ್ನು ಸೂಚಿತವಾಗಿರುತ್ತದೆ. 730 01:00:06,500 --> 01:00:09,620 ನಾನು ಅರೇ = malloc ಸಾಧ್ಯವಿಲ್ಲ. 731 01:00:09,620 --> 01:00:13,710 ಖಣಿಲು ಬುದ್ಧಿವಂತ ವೇಳೆ, ಇದು ಬಲ ಬ್ಯಾಟ್ ಆಫ್ ನನಗೆ ಕೋಪ ಕಾಣಿಸುತ್ತದೆ. 732 01:00:17,000 --> 01:00:21,430 ವಾಸ್ತವವಾಗಿ, ನಾನು GCC ತುಂಬಾ ಹೀಗೆ ಎಂದು ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ. 733 01:00:21,430 --> 01:00:25,010 ಆದ್ದರಿಂದ ರಚನೆಯ ಪ್ರಕಾರ 'ಇಂಟ್ [5]' ವಹಿಸಿಕೊಡುವುದಾಗಲಿ ಅಲ್ಲ. 734 01:00:25,010 --> 01:00:28,040 ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೀತಿಯ ಏನಾದರೂ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ 735 01:00:28,040 --> 01:00:30,500 ಸರಣಿ ಕೇವಲ ಸ್ಥಿರ ಕಾರಣ. 736 01:00:30,500 --> 01:00:34,760 ಇದು ಉಲ್ಲೇಖಗಳು ಆ 20 ಬೈಟ್ಗಳು ಸಂಕೇತವಾಗಿದೆ. ನಾನು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. 737 01:00:34,760 --> 01:00:37,690 >> [ವಿದ್ಯಾರ್ಥಿ] ಮತ್ತು ರಚನೆಯ ಗಾತ್ರ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಇದೆ? 738 01:00:37,690 --> 01:00:40,670 [ಬೌಡೆನ್] ಇದು ಎಲ್ಲೂ ಸಂಗ್ರಹವಾಗಿರುವ ಅಲ್ಲ. ಇದು ಕಂಪೈಲ್ ಸಂದರ್ಭದಲ್ಲಿ ಇದು. 739 01:00:40,670 --> 01:00:46,310 ಆದ್ದರಿಂದ ರಚನೆಯ ಗಾತ್ರ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಇದೆ? 740 01:00:46,310 --> 01:00:51,870 ನೀವು ಕೇವಲ ಶ್ರೇಣಿಯನ್ನು ಸ್ವತಃ ಡಿಕ್ಲೇರ್ಡ್ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕಾರ್ಯದ ಒಳಗೆ sizeof (ಸರಣಿ) ಬಳಸಬಹುದು. 741 01:00:51,870 --> 01:01:03,150 ನಾನು ಕೆಲವು ಫಂಕ್ಷನ್, foo, ಏನು ಮತ್ತು ನಾನು ಹಾಗಾಗಿ (ಇಂಟ್ ರಚನೆಯ []) 742 01:01:03,150 --> 01:01:10,450 printf ("% s \ n", sizeof (ಸರಣಿ)); 743 01:01:10,450 --> 01:01:21,330 ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ನಾನು foo (ಸರಣಿ) ಕರೆ; 744 01:01:21,330 --> 01:01:24,840 ಈ ಕಾರ್ಯದ ಒಳಗೆ - ನ ಚಲಾಯಿಸಲು ಅವಕಾಶ. 745 01:01:34,200 --> 01:01:36,840 ಈ ಮತ್ತೆ ಬುದ್ಧಿವಂತ ಎಂದು ಖಣಿಲು ಹೊಂದಿದೆ. 746 01:01:36,840 --> 01:01:43,890 ನನಗೆ ಹೇಳುವ ಎಂದು ರಚನೆಯ ಕಾರ್ಯ ಪ್ಯಾರಾಮೀಟರ್ sizeof 747 01:01:43,890 --> 01:01:46,690 'ಇಂಟ್ *' ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗುವುದು. 748 01:01:46,690 --> 01:01:55,150 ನಾನು ಸಂಭವಿಸಿ ಬಯಸಿದ್ದರು ಏನು ಅಲ್ಲ ಈ ದೋಷ ಎಂದು. 749 01:01:55,150 --> 01:01:58,960 ನ ವಾಸ್ತವವಾಗಿ Werror ಆಫ್ ಲೆಟ್. 750 01:02:14,950 --> 01:02:17,590 ಎಚ್ಚರಿಕೆ. ಎಚ್ಚರಿಕೆಗಳನ್ನು ಉತ್ತಮವಾಗಿವೆ. 751 01:02:17,590 --> 01:02:19,960 ಇದು ಒಂದು ಎಚ್ಚರಿಕೆ ಹೊಂದಿದೆ ಎಂದು ಇದು ಇನ್ನೂ ಉದ್ದನೆಯ ಕಂಪೈಲ್ ಕಾಣಿಸುತ್ತದೆ. 752 01:02:19,960 --> 01:02:22,910 . / A.out 4 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 753 01:02:22,910 --> 01:02:28,650 ರಚಿಸಿದ್ದಾರೆ ಎಂದು ಎಚ್ಚರಿಕೆ ತಪ್ಪಾಗಿದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟ ಸೂಚಕವಾಗಿದೆ. 754 01:02:28,650 --> 01:02:34,120 ಈ ಇಂಟ್ ರಚನೆಯ ಕೇವಲ sizeof (ಇಂಟ್ *) ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 755 01:02:34,120 --> 01:02:39,790 ನಾನು ಇಲ್ಲಿ ರಚನೆಯ [5] ಪುಟ್ ಸಹ, ಇದು ಈಗಲೂ ಕೇವಲ sizeof (ಇಂಟ್ *) ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು. 756 01:02:39,790 --> 01:02:47,440 ಆದ್ದರಿಂದ ತಕ್ಷಣ ನೀವು ಕಾರ್ಯ ಅದನ್ನು ಸಾಗುತ್ತಿರುವಾಗ ರಚನೆಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸ 757 01:02:47,440 --> 01:02:49,670 ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 758 01:02:49,670 --> 01:02:52,640 ಈ, ಸ್ಟಾಕ್ ರಂದು ಘೋಷಿಸಲಾಯಿತು ಎಂದು ಸರಣಿಯಾಗಿರಬೇಕು ಸಂಭವಿಸಿದರೆ 759 01:02:52,640 --> 01:02:58,300 ಆದರೆ ನಾವು ಆ ಮೌಲ್ಯವನ್ನು ಸಾಗುತ್ತಿರುವಾಗ ಆ 0xbf blah, blah, ಈ ಕಾರ್ಯ ಆಗಿ blah, 760 01:02:58,300 --> 01:03:03,350 ನಂತರ ಈ ಪಾಯಿಂಟರ್ ಸ್ಟಾಕ್ ಆ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿತವಾಗಿರುತ್ತದೆ. 761 01:03:03,350 --> 01:03:08,310 Sizeof ಕೇವಲ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಯಿತು ಎಂದು ಕಾರ್ಯದಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ ಎಂದರೆ ಆದ್ದರಿಂದ, 762 01:03:08,310 --> 01:03:11,230 ಇದು ಅರ್ಥ ನೀವು ಈ ಕಾರ್ಯವನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ 763 01:03:11,230 --> 01:03:17,330 ಖಣಿಲು ಈ ಕ್ರಿಯೆಯ ಮೂಲಕ ಹೋದಾಗ, ಅದು ರಚನೆಯ ಗಾತ್ರ 5 ನ ಇಂಟ್ ರಚನೆ ನೋಡುತ್ತಾನೆ. 764 01:03:17,330 --> 01:03:20,640 ಆದ್ದರಿಂದ ಅದು sizeof (ಸರಣಿ) ನೋಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಆ 20 ಇಲ್ಲಿದೆ. 765 01:03:20,640 --> 01:03:26,440 ಆ sizeof ಮೂಲಭೂತವಾಗಿ ಎಲ್ಲಾ ಸಂದರ್ಭದಲ್ಲಿಯೂ ಕೆಲಸ ಹೇಗೆ ವಾಸ್ತವವಾಗಿ. 766 01:03:26,440 --> 01:03:31,150 Sizeof ಒಂದು ಕ್ರಿಯೆ ಅಲ್ಲ ಅದು ಒಂದು ಆಯೋಜಕರು ಇಲ್ಲಿದೆ. 767 01:03:31,150 --> 01:03:33,570 ನೀವು sizeof ಕಾರ್ಯ ಕರೆ ಮಾಡಬೇಡಿ. 768 01:03:33,570 --> 01:03:38,280 Sizeof (ಇಂಟ್), ಕಂಪೈಲರ್ ಕೇವಲ 4 ಭಾಷಾಂತರಿಸುತ್ತದೆ. 769 01:03:41,480 --> 01:03:43,700 ಅರ್ಥವಾಯಿತು? ಸರಿ. 770 01:03:43,700 --> 01:03:47,520 >> [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಮುಖ್ಯ ಮತ್ತು foo ರಲ್ಲಿ sizeof (ಸರಣಿ) ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು? 771 01:03:47,520 --> 01:03:52,840 ನಾವು ವಿಧದ ಇಂಟ್ * ನ ಇದು sizeof (ಸರಣಿ), ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ಏಕೆಂದರೆ 772 01:03:52,840 --> 01:03:57,120 ರಚನೆಯ ಕೆಳಗೆ ಇಲ್ಲಿ ಅಲ್ಲ ರೀತಿಯ ಇಂಟ್ * ಆಫ್ ಆದರೆ, ಇದು ಒಂದು ಇಂಟ್ ಶ್ರೇಣಿಯನ್ನು ನ. 773 01:03:57,120 --> 01:04:04,540 >> [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನೀವು ರಚನೆಯ [] ಬದಲಿಗೆ ಇಂಟ್ * ಶ್ರೇಣಿಯಲ್ಲಿನ ನಿಯತಾಂಕ ಹೊಂದಿದ್ದರೆ, 774 01:04:04,540 --> 01:04:09,230 ಈಗ ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಏಕೆಂದರೆ ನೀವು ಇನ್ನೂ ರಚನೆಯ ಬದಲಾಯಿಸಬಹುದು ಅರ್ಥ? 775 01:04:09,230 --> 01:04:14,250 [ಬೌಡೆನ್] ಈ ಲೈಕ್? >> [ವಿದ್ಯಾರ್ಥಿ] ಹೌದು. ನೀವು ಈಗ ಕಾರ್ಯ ಒಳಗೆ ರಚನೆಯ ಬದಲಿಸಬಹುದು? 776 01:04:14,250 --> 01:04:18,420 [ಬೌಡೆನ್] ನೀವು ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ರಚನೆಯ ಬದಲಾಯಿಸಬಹುದು. 777 01:04:18,420 --> 01:04:23,130 ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎರಡೂ ನೀವು ರಚನೆಯ [4] = 0 ಹೇಳಲು ಉಚಿತ. 778 01:04:23,130 --> 01:04:26,590 [ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ನೀವು ಯಾವುದೇ ಕೆಲಸಕ್ಕೆ ರಚನೆಯ ಪಾಯಿಂಟ್ ಮಾಡಬಹುದು? 779 01:04:26,590 --> 01:04:30,230 [ಬೌಡೆನ್] ಓಹ್. ಹೌದು. ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ - >> [ವಿದ್ಯಾರ್ಥಿ] ಹೌದು. 780 01:04:30,230 --> 01:04:38,410 [ಬೌಡೆನ್] ರಚನೆಯ [] ಮತ್ತು ಒಂದು ಇಂಟ್ * ರಚನೆಯ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಇಲ್ಲ. 781 01:04:38,410 --> 01:04:42,570 ನೀವು ಇಲ್ಲಿ ಕೆಲವು ಮಲ್ಟಿಡೈಮೆನ್ಷನಲ್ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯುವುದು 782 01:04:42,570 --> 01:04:47,050 ಕೆಲವು ಅನುಕೂಲಕರ ವಾಕ್ಯ, ಆದರೆ ಇದು ಇನ್ನೂ ಕೇವಲ ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ. 783 01:04:47,050 --> 01:04:56,400 ನಾನು ರಚನೆಯ ಮಾಡಲು ಮುಕ್ತನಾಗಿದ್ದೇನೆ ಅರ್ಥ = malloc (sizeof (ಇಂಟ್)) ಮತ್ತು ಈಗ ಎಲ್ಲೋ ಬೇರೆ ಸೂಚಿಸುತ್ತಾರೆ. 784 01:04:56,400 --> 01:04:59,610 ಆದರೆ, ಈ ಶಾಶ್ವತವಾಗಿ ಮತ್ತು ಯಾವಾಗಲೂ ಕೆಲಸ ಹೇಗೆ ಇಷ್ಟ 785 01:04:59,610 --> 01:05:03,210 ಇದರಿಂದಾಗಿ ಈ ವ್ಯೂಹ ಬದಲಾಯಿಸುವ ಯಾವುದೋ ಬೆರಳು 786 01:05:03,210 --> 01:05:07,570 ಇದು, ವಾದದ ಪ್ರತಿಯನ್ನು ಏಕೆಂದರೆ ಇಲ್ಲಿ ಈ ರಚನೆಯ ಕೆಳಗೆ ಬದಲಾಗುವುದಿಲ್ಲ 787 01:05:07,570 --> 01:05:10,780 ಆ ವಾದವನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಅಲ್ಲ. 788 01:05:10,780 --> 01:05:16,070 ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಅದನ್ನು ಒಂದೇ ಎಂದು ಹೆಚ್ಚು ಸೂಚನೆ - 789 01:05:16,070 --> 01:05:21,100 ನಾವು ಈಗಾಗಲೇ ಮುದ್ರಣ ರಚನೆಯ ಮುದ್ರಿತ ಏನು ಕಂಡಿತು - 790 01:05:21,100 --> 01:05:31,410 ನಾವು ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಅಥವಾ ರಚನೆಯ ವಿಳಾಸ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ವೇಳೆ 791 01:05:31,410 --> 01:05:36,290 ಆ ಎರಡೂ ಗೆ? 792 01:05:41,770 --> 01:05:45,220 ಅವರ ಈ ಒಂದು ನಿರ್ಲಕ್ಷಿಸಿ ಲೆಟ್. 793 01:05:48,140 --> 01:05:51,660 ಸರಿ. ಇದು ಉತ್ತಮವಾಗಿದೆ. ಈಗ. / A.out ಚಾಲನೆಯಲ್ಲಿರುವ ನ. 794 01:05:51,660 --> 01:06:00,220 ಮುದ್ರಣ ರಚನೆಯ ನಂತರ ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ, ಅವು ಒಂದೇ ಆಗಿವೆ. 795 01:06:00,220 --> 01:06:02,870 ಅರೇ ಕೇವಲ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 796 01:06:02,870 --> 01:06:08,190 ನೀವು ವ್ಯೂಹ ಮುದ್ರಿಸುವ ಮಾಡಿದಾಗ, ಆ 20 ಬೈಟ್ಗಳು ಉಲ್ಲೇಖಿಸುವ ಸಂಕೇತವನ್ನು ಮುದ್ರಿಸುವ ನೋಸ್. 797 01:06:08,190 --> 01:06:11,940 ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ, ಹಾಗೂ, ಸರಣಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 798 01:06:11,940 --> 01:06:17,200 ಇದು ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ 20 ಬೈಟ್ಗಳು ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುತ್ತದೆ. 799 01:06:20,820 --> 01:06:28,150 ತಕ್ಷಣ ನೀವು ಕೆಳಗೆ ಕಂಪೈಲ್ ಮಾಹಿತಿ, ನಿಮ್ಮ ಕಂಪೈಲ್ buggy4 ರೀತಿಯಲ್ಲಿರುತ್ತದೆ. / A.out 800 01:06:28,150 --> 01:06:30,340 ಅರೇ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 801 01:06:30,340 --> 01:06:33,640 ಪಾಯಿಂಟರ್ಸ್ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಅರೆಸ್ ಮಾಡುವುದಿಲ್ಲ. 802 01:06:34,300 --> 01:06:38,060 ಅರೇ ಪ್ರತಿನಿಧಿಸುವ ಮೆಮೊರಿಯ ಬ್ಲಾಕ್ಗಳನ್ನು ಈಗಲೂ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, 803 01:06:38,060 --> 01:06:43,270 ಆದರೆ ವೇರಿಯಬಲ್ ವ್ಯೂಹ ಮತ್ತು ಆ ರೀತಿಯ ಅಸ್ಥಿರ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. 804 01:06:46,260 --> 01:06:50,270 ಆ ಸಾಲುಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹಾಗೆ 805 01:06:50,270 --> 01:06:55,590 ತಕ್ಷಣ ನೀವು ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಎಂದು, ಯಾವುದೇ ವ್ಯತ್ಯಾಸಗಳಿವೆ. 806 01:06:55,590 --> 01:07:00,460 ಆದರೆ ಒಳಗೆ ರಚನೆಯ ಸ್ವತಃ ಡಿಕ್ಲೇರ್ಡ್ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕ್ರಿಯೆಯ, sizeof ವಿಭಿನ್ನವಾಗಿ ಕೆಲಸ 807 01:07:00,460 --> 01:07:05,190 ನೀವು ಬದಲಿಗೆ ರೀತಿಯ ಗಾತ್ರವನ್ನು ಬ್ಲಾಕ್ಗಳನ್ನು ಗಾತ್ರವನ್ನು ಮುದ್ರಿಸುವ ಕಾರಣ, 808 01:07:05,190 --> 01:07:08,950 ಇದು ಸಂಕೇತವಾಗಿ ಏಕೆಂದರೆ ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. 809 01:07:08,950 --> 01:07:14,370 ವಿಷಯ ವಸ್ತು ಮತ್ತು ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ ಒಂದೇ ಮುದ್ರಿಸುತ್ತದೆ. 810 01:07:14,370 --> 01:07:18,480 ಮತ್ತು ಅದು ಬಹುಮಟ್ಟಿಗೆ ಇಲ್ಲಿದೆ. 811 01:07:18,480 --> 01:07:20,820 [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಒಂದು ಬಾರಿ ಹೇಳಬಹುದು? 812 01:07:21,170 --> 01:07:24,170 ನಾನು ಏನೋ ಹೊರ ಹೋದಂತೆ. 813 01:07:24,170 --> 01:07:29,260 ರಚನೆಯ ಮುದ್ರಣ ವ್ಯೂಹ ಮತ್ತು ವಿಳಾಸ, ಒಂದೇ ವಿಷಯವನ್ನು ತೋರಿಸುತ್ತದೆ 814 01:07:29,260 --> 01:07:33,180 ನೀವು ಪಾಯಿಂಟರ್ ವಿಳಾಸವನ್ನು ವಿರುದ್ಧದ ಪಾಯಿಂಟರ್ ಮುದ್ರಿಸಲು ವೇಳೆ ಆದರೆ, 815 01:07:33,180 --> 01:07:36,010 ಒಂದು ವಿಷಯ ನಿಮಗೆ ಸೂಚಿಸುವ ಏನನ್ನು ವಿಳಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ, 816 01:07:36,010 --> 01:07:40,360 ಇತರ ಸ್ಟಾಕ್ ಪಾಯಿಂಟರ್ಗೆ ವಿಳಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ. 817 01:07:40,360 --> 01:07:47,040 ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಬದಲಾಯಿಸಬಹುದು; ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಚಿಹ್ನೆ ಬದಲಿಸಲಾಗುವುದಿಲ್ಲ. 818 01:07:47,740 --> 01:07:53,270 ಮತ್ತು sizeof ಸೂಚಿಗೆ ದುವಿನ ಪ್ರಕಾರದ ಗಾತ್ರ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 819 01:07:53,270 --> 01:07:57,470 ಆದ್ದರಿಂದ ಇಂಟ್ * ಪುಟ sizeof (ಪು), 4 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ 820 01:07:57,470 --> 01:08:04,110 ಆದರೆ ಇಂಟ್ ರಚನೆಯ [5] ಮುದ್ರಣ sizeof (ಸರಣಿ) 20 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. 821 01:08:04,110 --> 01:08:07,480 [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಇಂಟ್ ರಚನೆಯ [5] 20 ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ? >> ಹೌದು. 822 01:08:07,480 --> 01:08:13,300 ಏಕೆ ಒಳಗೆ buggy4 ಅದನ್ನು sizeof (ಸರಣಿ) ಎಂದು ಬಳಸಿದಾಗ ಆ 823 01:08:13,300 --> 01:08:16,660 ನಾನು <20 ಮಾಡುತ್ತಿದ್ದ, ಇದು ನಾವು ಬೇಕಾಗಿದ್ದಾರೆ ಏನು ಅಲ್ಲ. 824 01:08:16,660 --> 01:08:20,880 ನಾವು ನಾನು <5 ಬಯಸುವ. >> [ವಿದ್ಯಾರ್ಥಿ] ಸರಿ. 825 01:08:20,880 --> 01:08:25,569 [ಬೌಡೆನ್] ನಂತರ ತಕ್ಷಣ ನೀವು ಕಾರ್ಯಗಳನ್ನು ಸಾಗುವ ಪ್ರಾರಂಭಿಸಿ, 826 01:08:25,569 --> 01:08:34,340 ನಾವು ಮಾಡಿದರೆ ಇಂಟ್ * ಪು = ಸರಣಿ; 827 01:08:34,340 --> 01:08:39,779 ಈ ಕಾರ್ಯದ ಒಳಗೆ, ನಾವು ಮೂಲತಃ, ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಪು ಮತ್ತು ಬಳಸಿಕೊಳ್ಳಬಹುದು 828 01:08:39,779 --> 01:08:43,710 sizeof ಸಮಸ್ಯೆ ಮತ್ತು ಬದಲಾಗುವ ಸಮಸ್ಯೆಯನ್ನು ಹೊರತುಪಡಿಸಿ. 829 01:08:43,710 --> 01:08:49,810 ಆದರೆ ಪು [0] = 1; ರಚನೆಯ [0] = 1 ಹೇಳುವ ಒಂದೇ; 830 01:08:49,810 --> 01:08:55,600 ಮತ್ತು ತಕ್ಷಣ ನಾವು foo (ಸರಣಿ) ಎಂದು ಹೇಳುತ್ತಾರೆ; ಅಥವಾ foo (ಪುಟ); 831 01:08:55,600 --> 01:08:59,760 foo ಕಾರ್ಯದ ಒಳಗೆ, ಈ ಬಾರಿ ಅದೇ ಕರೆಯಾಗಿದೆ. 832 01:08:59,760 --> 01:09:03,350 ಈ ಎರಡು ಕರೆಗಳನ್ನು ನಡುವೆ ವ್ಯತ್ಯಾಸವಿದೆ. 833 01:09:07,029 --> 01:09:11,080 >> ಆ ಉತ್ತಮ ಎಲ್ಲರಿಗೂ? ಸರಿ. 834 01:09:14,620 --> 01:09:17,950 ನಾವು 10 ನಿಮಿಷಗಳ ಹೊಂದಿರುತ್ತವೆ. 835 01:09:17,950 --> 01:09:28,319 >> ನಾವು, ಈ ಹ್ಯಾಕರ್ Typer ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ 836 01:09:28,319 --> 01:09:32,350 ಕಳೆದ ವರ್ಷ ಅಥವಾ ಏನಾದರೂ ಹೊರಬಂದು ಈ ವೆಬ್ಸೈಟ್. 837 01:09:34,149 --> 01:09:41,100 ನೀವು ಯಾದೃಚ್ಛಿಕವಾಗಿ ನಮೂದಿಸಿ ಮತ್ತು ಅದನ್ನು ತೋರಿಸುತ್ತದೆ ಎಂದು ಕೇವಲ ಎಂದು ಮಾಡಬೇಕೋ - 838 01:09:41,100 --> 01:09:46,729 ಯಾವುದೇ ಕಡತ ಅದನ್ನು ಲೋಡ್ ಸಂಭವಿಸಿದರೆ ನೀವು ಟೈಪ್ ಮಾಡುತ್ತಿರುವಂತೆ ತೋರುತ್ತಿದೆ ಏನು. 839 01:09:46,729 --> 01:09:52,069 ಅದು ಕಾರ್ಯ ವ್ಯವಸ್ಥೆಯನ್ನು ಕೋಡ್ ರೀತಿಯ ತೋರುತ್ತಿದೆ. 840 01:09:53,760 --> 01:09:56,890 ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬೇಕು. 841 01:10:08,560 --> 01:10:11,690 ನೀವು hacker_typer ಎಂಬ ಯುಗಳ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಇರಬೇಕು 842 01:10:11,690 --> 01:10:14,350 ಆ ಫೈಲ್, ಒಂದೇ ವಾದದಲ್ಲಿನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ "ಹ್ಯಾಕರ್ ಬಗೆ." 843 01:10:14,350 --> 01:10:16,480 ಕಾರ್ಯಗತಗೊಳ್ಳುವ ರನ್ನಿಂಗ್ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ಮಾಡಬೇಕು 844 01:10:16,480 --> 01:10:20,850 ತದನಂತರ ಬಳಕೆದಾರ ಪ್ರೆಸ್ ಪ್ರಮುಖ ಪ್ರತಿ ಬಾರಿ ಜಾರಿಗೆ ಇನ್ ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಮುದ್ರಿಸುತ್ತದೆ. 845 01:10:20,850 --> 01:10:24,990 ನೀವು ಒತ್ತಿ ಯಾವುದೇ ಪ್ರಮುಖ ಆದ್ದರಿಂದ, ಎಸೆದು ಮತ್ತು ಬದಲಿಗೆ ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರ ಮುದ್ರಿಸು ಮಾಡಬೇಕು 846 01:10:24,990 --> 01:10:27,810 ಆ ವಾದವು. 847 01:10:29,880 --> 01:10:34,350 ನಾನು ಅತ್ಯಧಿಕವಾಗಿ ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಎಂದು ನೀನು ವಸ್ತುಗಳು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. 848 01:10:34,350 --> 01:10:36,440 ಆದರೆ ನಾವು termios ಲೈಬ್ರರಿ ಪರಿಶೀಲಿಸಲು ಬಯಸುವ. 849 01:10:36,440 --> 01:10:44,840 ನನ್ನ ಸಂಪೂರ್ಣ ಜೀವನದಲ್ಲಿ ಈ ಗ್ರಂಥಾಲಯದ ಬಳಸಲಾಗುತ್ತದೆ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಬಹಳ ಕಡಿಮೆ ಉದ್ದೇಶಗಳನ್ನು ಹೊಂದಿದೆ. 850 01:10:44,840 --> 01:10:48,610 ಆದರೆ ನಾವು ನೀವು ಹಿಟ್ ಪಾತ್ರ ಎಸೆದು ಬಳಸಬಹುದಾದ ಗ್ರಂಥಾಲಯದ ಏರಲಿದೆ 851 01:10:48,610 --> 01:10:52,390 ನೀವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಆಗಿ ಟೈಪ್ ಮಾಡಿದಾಗ 852 01:10:56,970 --> 01:11:05,840 ಆದ್ದರಿಂದ hacker_typer.c, ಮತ್ತು ನಾವು # ಸೇರಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು. 853 01:11:05,840 --> 01:11:12,870 Termios ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡುವ - I'm ಇದು ಟರ್ಮಿನಲ್ OS ಅಥವಾ ಏನೋ ಊಹೆ - 854 01:11:12,870 --> 01:11:16,240 ನಾನು ಓದಲು ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ. 855 01:11:16,240 --> 01:11:21,040 ಈ ನೋಡುವುದರಿಂದ, ಈ 2 ಕಡತಗಳನ್ನು ಸೇರಿಸಲು ಹೇಳುತ್ತಾರೆ, ನಾವು ಹಾಗೆ ಮಾಡುತ್ತೇವೆ. 856 01:11:37,620 --> 01:11:46,820 >> ಮೊದಲನೆಯದಾಗಿ ಮೊದಲ, ನಾವು ತೆರೆಯಬೇಕು ಕಡತ ಇದು ಒಂದು ವಾದವು, ಕೈಗೊಳ್ಳಬೇಕಾದ ಬಯಸುವ. 857 01:11:46,820 --> 01:11:52,420 ಆದ್ದರಿಂದ ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ? ಹೇಗೆ ನಾನು ಒಂದು ವಾದವು ಹೊಂದಿರುತ್ತವೆ ಪರೀಕ್ಷಿಸಿ ಇಲ್ಲ? 858 01:11:52,420 --> 01:11:56,480 [ವಿದ್ಯಾರ್ಥಿ] argc ಇದು ಸಮನಾಗಿರುತ್ತದೆ ವೇಳೆ. >> [ಬೌಡೆನ್] ಹೌದು. 859 01:11:56,480 --> 01:12:21,250 ಆದ್ದರಿಂದ (argc = 2!) Printf ("ಬಳಕೆ:% s [ಕಡತವನ್ನು ತೆರೆಯಲು]"). 860 01:12:21,250 --> 01:12:32,750 ನಾನು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ನೀಡದೆಯೇ ಈ ರನ್ ವೇಳೆ ಈಗ - ಓಹ್, ನಾನು ಹೊಸ ಲೈನ್ ಅಗತ್ಯವಿದೆ - 861 01:12:32,750 --> 01:12:36,240 ನೀವು ಹೇಳುತ್ತಾರೆ ಬಳಕೆಯ ನೋಡುತ್ತಾರೆ:. / hacker_typer, 862 01:12:36,240 --> 01:12:39,770 ತದನಂತರ ಎರಡನೆಯ ವಾದವನ್ನು ನಾನು ತೆರೆಯಲು ಬಯಸುವ ಫೈಲ್ ಆಗಿರಬೇಕು. 863 01:12:58,430 --> 01:13:01,260 ಈಗ ನಾನು ಏನು ಮಾಡಬೇಕು? 864 01:13:01,260 --> 01:13:08,490 ನಾನು ಈ ಕಡತದಿಂದ ಓದಲು ಬಯಸುವ. ನಾನು ಒಂದು ಕಡತದಿಂದ ಓದಲು ಇಲ್ಲ? 865 01:13:08,490 --> 01:13:11,920 [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಮೊದಲ ಅದನ್ನು ತೆರೆಯಲು. >> ಹೌದು. 866 01:13:11,920 --> 01:13:15,010 ಆದ್ದರಿಂದ fopen. Fopen ಯಾವ ರೀತಿ ಮಾಡುವುದಿಲ್ಲ? 867 01:13:15,010 --> 01:13:22,980 [ವಿದ್ಯಾರ್ಥಿ] ಕಡತದಹೆಸರು. >> [ಬೌಡೆನ್] ಫೈಲ್ಹೆಸರು argv [1] ಎಂದು ಹೋಗುತ್ತದೆ. 868 01:13:22,980 --> 01:13:26,110 [ವಿದ್ಯಾರ್ಥಿ] ನಂತರ ನಿಮಗೆ ಅದನ್ನು ಮಾಡಲು ಬಯಸುವ, ಆದ್ದರಿಂದ - >> [ಬೌಡೆನ್] ಹೌದು. 869 01:13:26,110 --> 01:13:28,740 ನೀವು ನೆನಪಿಡುವ ಮಾಡಲಿಲ್ಲ ಆದ್ದರಿಂದ, ನೀವು, ಮನುಷ್ಯ fopen ರೀತಿಯಲ್ಲಿಯೇ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ 870 01:13:28,740 --> 01:13:32,960 ಅದು ಮಾರ್ಗ FILENAME ಅಲ್ಲಿ ಒಂದು const ಚಾರ್ * ಮಾರ್ಗ ಎಂದು ವಿಶೇಷವೇನು ಅಲ್ಲಿ, 871 01:13:32,960 --> 01:13:34,970 const ಚಾರ್ * ಮೋಡ್. 872 01:13:34,970 --> 01:13:38,660 ನೀವು ವಿಧಾನವಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿರುವುದಿಲ್ಲ ಸಂಭವಿಸಿದಾಗ ನೀವು ಕ್ರಮಕ್ಕೆ ನೋಡಬಹುದು. 873 01:13:38,660 --> 01:13:44,660 ಮನುಷ್ಯ ಪುಟಗಳ ಒಳಗೆ, ಕತ್ತರಿಸಿ ಪಾತ್ರವನ್ನು ನೀವು ವಿಷಯಗಳನ್ನು ಹುಡುಕಲು ಬಳಸಬಹುದಾದ ಏನು. 874 01:13:44,660 --> 01:13:49,790 ಹಾಗಾಗಿ ಮೋಡ್ ಹುಡುಕಲು / ಮೋಡ್ ಟೈಪಿಸಿ. 875 01:13:49,790 --> 01:13:57,130 n ಮತ್ತು ಎನ್ ನೀವು ಹುಡುಕಾಟ ಪಂದ್ಯಗಳಲ್ಲಿ ಮೂಲಕ ಚಕ್ರದ ಬಳಸಬಹುದಾದ ಯಾವುವು. 876 01:13:57,130 --> 01:13:59,800 ಇಲ್ಲಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ ಮೋಡ್ ಅಂಕಗಳನ್ನು ಹೇಳುತ್ತಾರೆ 877 01:13:59,800 --> 01:14:01,930 ಕೆಳಗಿನ ಅನುಕ್ರಮಗಳನ್ನು ಒಂದನ್ನು ಪ್ರಾರಂಭಿಸಿ. 878 01:14:01,930 --> 01:14:06,480 ಓದುವ R ಆದ್ದರಿಂದ ಓಪನ್ ಪಠ್ಯ ಕಡತ. ನಾವು ಏನು ಬೇಕು. 879 01:14:08,930 --> 01:14:13,210 ಓದುವ, ಮತ್ತು ನಾನು ಆ ಶೇಖರಿಸಿಡಲು ಪಡೆಯಲು. 880 01:14:13,210 --> 01:14:18,720 ವಿಷಯ ಫೈಲ್ * ಎಂದು ಹೋಗುತ್ತದೆ. ಈಗ ನಾನು ನೀವು ಏನು? 881 01:14:18,720 --> 01:14:21,200 ಅಂತ ಎರಡನೇ ನೀಡಿ. 882 01:14:28,140 --> 01:14:30,430 ಸರಿ. ಈಗ ನಾನು ನೀವು ಏನು? 883 01:14:30,430 --> 01:14:32,940 [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ. >> [ಬೌಡೆನ್] ಹೌದು. 884 01:14:32,940 --> 01:14:38,690 ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ನೀವು ಯಶಸ್ವಿಯಾಗಿ ತೆರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. 885 01:14:58,930 --> 01:15:10,460 >> ನಾನು ಮೊದಲ ನನ್ನ ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಓದಲು ಬಯಸುವ ಅಲ್ಲಿ ಈಗ ನಾನು termios ಸ್ಟಫ್ ಮಾಡಲು ಬಯಸುವುದು 886 01:15:10,460 --> 01:15:14,050 ಮತ್ತು ಏನಾದರೂ ಇಂತಹ ಉಳಿಸಲು, ನಂತರ ನನ್ನ ಬದಲಾಯಿಸಲು ಬಯಸುವ 887 01:15:14,050 --> 01:15:19,420 , ನಾನು ಟೈಪ್ ಯಾವುದೇ ಪಾತ್ರ ದೂರ ಎಸೆಯಲು 888 01:15:19,420 --> 01:15:22,520 ತದನಂತರ ಆ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೇನೆ. 889 01:15:22,520 --> 01:15:27,250 ನಂತರ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ, ನನ್ನ ಮೂಲ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಮತ್ತೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ. 890 01:15:27,250 --> 01:15:32,080 ಆದ್ದರಿಂದ struct ರೀತಿಯ termios ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಆ ಎರಡು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. 891 01:15:32,080 --> 01:15:35,600 ಮೊದಲನೆಯದು, ನನ್ನ current_settings ಏರಲಿದೆ 892 01:15:35,600 --> 01:15:42,010 ತದನಂತರ ಅವರು ನನ್ನ hacker_settings ಎಂದು ನೀನು. 893 01:15:42,010 --> 01:15:48,070 ಮೊದಲ, ನಾನು, ನನ್ನ ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಉಳಿಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ 894 01:15:48,070 --> 01:15:53,790 ಆಗ ನಾನು, hacker_settings ನವೀಕರಿಸಲು ಬಯಸುತ್ತೀರೆ ಪಡೆಯಲಿದ್ದೇನೆ 895 01:15:53,790 --> 01:16:01,570 ತದನಂತರ ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ರೀತಿಯಲ್ಲಿ, ನಾನು ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳಿಗೆ ಹಿಂದಿರುಗುತ್ತವೆ ಬಯಸುವ. 896 01:16:01,570 --> 01:16:08,660 ಆದ್ದರಿಂದ, ನಾವು ಮಾನವ termios ಕೆಲಸ ರೀತಿಯಲ್ಲಿ, ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಉಳಿಸುವಲ್ಲಿ. 897 01:16:08,660 --> 01:16:15,810 ನಾವು ಈ ಇಂಟ್ tcsetattr, ಇಂಟ್ tcgetattr ಎಂದು ನೋಡಿ. 898 01:16:15,810 --> 01:16:22,960 ನಾನು ಅದರ ಪಾಯಿಂಟರ್ ಮೂಲಕ termios struct ರಲ್ಲಿ ಪಾಸ್. 899 01:16:22,960 --> 01:16:30,640 ಈ ನೋಡೋಣ ದಾರಿ - I've ಈಗಾಗಲೇ ಕಾರ್ಯ ಕರೆಯುತ್ತಿದ್ದ ಮರೆತು. 900 01:16:30,640 --> 01:16:34,930 ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ. 901 01:16:39,150 --> 01:16:45,500 Tcgetattr ಆದ್ದರಿಂದ, ನಂತರ ನಾನು ಮಾಹಿತಿ ಉಳಿಸುವಲ್ಲಿ ನಾನು struct ರಲ್ಲಿ ರವಾನಿಸ ಬೇಕೆಂದಿರುವ 902 01:16:45,500 --> 01:16:49,650 ಇದು current_settings ಏರಲಿದೆ 903 01:16:49,650 --> 01:16:59,120 ಮತ್ತು ಮೊದಲ ವಾದವನ್ನು ನಾನು ಬಹಳ ಉಳಿಸಲು ಬಯಸುವ ವಿಷಯ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಹೊಂದಿದೆ. 904 01:16:59,120 --> 01:17:04,360 ಯಾವ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಹಾಗೆ, ಅದು ಒಂದು ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಪಡೆಯುತ್ತದೆ. 905 01:17:04,360 --> 01:17:14,560 ನಾನು fopen argv [1], ಇದು ನೀವು ಉಲ್ಲೇಖಗಳನ್ನು ಆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಗೆಟ್ಸ್ 906 01:17:14,560 --> 01:17:16,730 ನೀವು ಅದನ್ನು ಓದಲು ಅಥವಾ ಬರೆಯಲು ಮಾಡಿ. 907 01:17:16,730 --> 01:17:19,220 ನಾನು ಇಲ್ಲಿ ಬಳಸಬೇಕಿರುವ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಅಲ್ಲ. 908 01:17:19,220 --> 01:17:21,940 ನೀವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿರುತ್ತವೆ ಮೂರು ಫೈಲ್ ವಿವರಣೆಗಳ ಇವೆ 909 01:17:21,940 --> 01:17:24,310 ಇದು ಪ್ರಮಾಣಿತ ಔಟ್, ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ ಮಾನಕವಾಗಿಬಿಟ್ಟಿದೆ. 910 01:17:24,310 --> 01:17:29,960 ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಾನು 0, ಪ್ರಮಾಣಿತ ಔಟ್ 1, ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ 2 ಆಗಿದೆ ಗುಣಮಟ್ಟದ ಆಲೋಚಿಸಬೇಕು. 911 01:17:29,960 --> 01:17:33,980 ಹಾಗಾಗಿ ನಾನು ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೀರಿ? 912 01:17:33,980 --> 01:17:37,370 ನಾನು ಒಂದು ಪಾತ್ರ ಹಿಟ್ ಬಂದಾಗಲೆಲ್ಲಾ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಬದಲಿಸಲು ಬಯಸುವ 913 01:17:37,370 --> 01:17:41,590 ನಾನು ಬದಲಿಗೆ ತೆರೆಗೆ ಅದನ್ನು ಮುದ್ರಿಸುವ ದೂರ ಪಾತ್ರದ ಎಸೆಯಲು ಬಯಸುವ. 914 01:17:41,590 --> 01:17:45,960 ಏನು ಸ್ಟ್ರೀಮ್ - - ಪ್ರಮಾಣಿತ ಔಟ್, ಅಥವಾ ಸಾಮಾನ್ಯ ದೋಷ, ಗುಣಮಟ್ಟದ 915 01:17:45,960 --> 01:17:52,050 ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದಾಗ ವಸ್ತುಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ? >> >> ಹೌದು ಸೈನ್ [ವಿದ್ಯಾರ್ಥಿ] ಸ್ಟ್ಯಾಂಡರ್ಡ್. 916 01:17:52,050 --> 01:17:56,450 ಹಾಗಾಗಿ ಎರಡೂ 0 ಮಾಡಬಹುದು ಅಥವಾ ನಾನು stdin ಮಾಡಬಹುದು. 917 01:17:56,450 --> 01:17:59,380 ನಾನು ಸೈನ್ ಗುಣಮಟ್ಟದ current_settings ಗೆಟ್ಟಿಂಗ್ ದೇರ್ 918 01:17:59,380 --> 01:18:01,720 >> ಈಗ ನಾನು, ಆ ಸೆಟ್ಟಿಂಗ್ಸ್ ಅನ್ನು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೀರಾ 919 01:18:01,720 --> 01:18:07,200 ಆದ್ದರಿಂದ ಮೊದಲ ನನ್ನ current_settings ಏನು hacker_settings ಗೆ ನಕಲಿಸಿ ಮಾಡುತ್ತೇವೆ. 920 01:18:07,200 --> 01:18:10,430 ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಕೆಲಸ ಹೇಗೆ ನಕಲು ಕಾಣಿಸುತ್ತದೆ. 921 01:18:10,430 --> 01:18:14,510 ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ಈ ಎಲ್ಲಾ ಜಾಗ ನಕಲಿಸುತ್ತದೆ. 922 01:18:14,510 --> 01:18:17,410 >> ಈಗ ನಾನು ಜಾಗ ಕೆಲವು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೇನೆ. 923 01:18:17,410 --> 01:18:21,670 Termios ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನೀವು ಈ ಸಾಕಷ್ಟು ಓದಲು ಇರಬೇಕು 924 01:18:21,670 --> 01:18:24,110 ನೀವು ನೋಡಲು ಬಯಸುವ ಎಂದು ನೋಡಲು, 925 01:18:24,110 --> 01:18:28,210 ಆದರೆ ನೀವು ನೋಡಲು ಬಯಸುವ ಎಂದು ನೀನು ಧ್ವಜಗಳು, ಪ್ರತಿಧ್ವನಿ ಗಳು 926 01:18:28,210 --> 01:18:33,110 ಆದ್ದರಿಂದ ಎಕೋ ಅಕ್ಷರಗಳನ್ನು ಇನ್ಪುಟ್ ಪ್ರತಿಧ್ವನಿ. 927 01:18:33,110 --> 01:18:37,710 ಮೊದಲ ಸೆಟ್ ನಾನು ಬಯಸುವ - ಜಾಗ ಎಂಬುದನ್ನು ಈಗಾಗಲೇ ಮರೆತು I've. 928 01:18:45,040 --> 01:18:47,900 ಈ struct ಕಾಣುತ್ತದೆ ಏನು. 929 01:18:47,900 --> 01:18:51,060 ಇನ್ಪುಟ್ ವಿಧಾನಗಳನ್ನು ಆದ್ದರಿಂದ ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ ಭಾವಿಸುತ್ತೇನೆ. 930 01:18:51,060 --> 01:18:54,210 ನಾವು ನಾವು ಬದಲಾಯಿಸಲು ಬೇಕು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಪರಿಹಾರಗಳನ್ನು ನೋಡಲು ಮಾಡುತ್ತೇವೆ. 931 01:19:04,060 --> 01:19:12,610 ನಾವೆಲ್ಲರೂ ಈ ಮೂಲಕ ನೋಡಲು ಬಯಸುವ ತಡೆಯಲು lflag ಬದಲಾಯಿಸಲು ಬಯಸುವ. 932 01:19:12,610 --> 01:19:14,670 ನಾವು ಸ್ಥಳೀಯ ವಿಧಾನಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸುವ. 933 01:19:14,670 --> 01:19:17,710 ನೀವು ಎಲ್ಲವನ್ನೂ ಸೇರಿದವನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಈ ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ಓದಲು ಇರಬೇಕು 934 01:19:17,710 --> 01:19:19,320 ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ. 935 01:19:19,320 --> 01:19:24,120 ಆದರೆ ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಅಲ್ಲಿ ಸ್ಥಳೀಯ ವಿಧಾನಗಳ ಒಳಗೆ ಇಲ್ಲಿದೆ. 936 01:19:27,080 --> 01:19:33,110 ಆದ್ದರಿಂದ hacker_settings.cc_lmode ಇದನ್ನು ಏನನ್ನು ಹೊಂದಿದೆ. 937 01:19:39,630 --> 01:19:43,020 c_lflag. 938 01:19:49,060 --> 01:19:52,280 ನಾವು bitwise ನಿರ್ವಾಹಕರು ಬರಲು ಅಲ್ಲಿ ಇದು. 939 01:19:52,280 --> 01:19:54,860 ನಾವು ಸಮಯ ರೀತಿಯ ಕೋರುತ್ತೇವೆ, ಆದರೆ ನಾವು ನೈಜ ಕ್ಷಿಪ್ರ ಮೂಲಕ ಹೋಗುತ್ತೇನೆ. 940 01:19:54,860 --> 01:19:56,600 ನಾವು bitwise ನಿರ್ವಾಹಕರು ಬರಲು ಅಲ್ಲಿ ಇದು ಹೊಂದಿದೆ 941 01:19:56,600 --> 01:19:59,950 ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಅಲ್ಲಿ ನಾನು ಒಂದು ಕಾಲದಲ್ಲಿ ಬಹಳ ಹಿಂದೆಯೇ ಹೇಳಿದ್ದಾರೆ ನೀವು ಧ್ವಜಗಳು ವ್ಯವಹರಿಸುವಾಗ ಆರಂಭಿಸಲು ಪ್ರಕಟಿಸಿದಾಗ, 942 01:19:59,950 --> 01:20:03,370 ನೀವು bitwise ಆಯೋಜಕರು ಸಾಕಷ್ಟು ಬಳಸಿಕೊಂಡು ಎಂದು ನೀನು. 943 01:20:03,370 --> 01:20:08,240 ಧ್ವಜ ಪ್ರತಿ ಬಿಟ್ ವರ್ತನೆಯ ಕೆಲವೊಂದು ಬಗೆಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಸಂಬಂಧಿಸಿರುತ್ತದೆ. 944 01:20:08,240 --> 01:20:14,090 ಇಲ್ಲಿ, ಈ ಧ್ವಜ ಎಲ್ಲಾ ಬೇರೆ ಅರ್ಥ ಅಲ್ಲಿ ವಿವಿಧ ವಸ್ತುಗಳು, ಒಂದು ಗುಂಪನ್ನು ಹೊಂದಿದೆ. 945 01:20:14,090 --> 01:20:18,690 ಆದರೆ ನಾನು ಯಾವ ಕೇವಲ ಪ್ರತಿಧ್ವನಿ ಅನುರೂಪವಾಗಿರುವ ಬಿಟ್ ಆಫ್ ಇದೆ. 946 01:20:18,690 --> 01:20:25,440 ಹಾಗೆ ಮಾಡಲು ನಾನು ಏನು ಆಫ್ & = ¬ ಪ್ರತಿಧ್ವನಿ. 947 01:20:25,440 --> 01:20:30,110 ವಾಸ್ತವವಾಗಿ, ನಾನು tECHO ಅಥವಾ ಯಾವುದೋ ರೀತಿಯ ಆಲೋಚಿಸಬೇಕು. ನಾನು ಮತ್ತೆ ಪರಿಶೀಲಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ. 948 01:20:30,110 --> 01:20:34,050 ನಾನು termios ಮಾಡಬಹುದು. ಇದು ಕೇವಲ ಪ್ರತಿಧ್ವನಿ ನ. 949 01:20:34,050 --> 01:20:38,440 ECHO ಒಂದು ಬಿಟ್ ಏರಲಿದೆ. 950 01:20:38,440 --> 01:20:44,230 ¬ ECHO ಎಲ್ಲಾ ಧ್ವಜಗಳು ನಿಜವಾದ ಸಿದ್ಧವಾಗಿವೆ ಅಂದರೆ, ಎಲ್ಲಾ ಬಿಟ್ಗಳು 1 ಸಿದ್ಧವಾಗಿವೆ ಅರ್ಥ ಹೋಗುತ್ತದೆ 951 01:20:44,230 --> 01:20:47,140 ECHO ಬಿಟ್ ಹೊರತುಪಡಿಸಿ. 952 01:20:47,140 --> 01:20:53,830 ಈ ನನ್ನ ಸ್ಥಳೀಯ ಧ್ವಜಗಳು ಕೊನೆಗೊಳ್ಳುವ ಹೊತ್ತಿಗೆ, ಇದು ಪ್ರಸ್ತುತ ನಿಜವಾದ ಗೆ ಸೆಟ್ ಎಲ್ಲಾ ಧ್ವಜಗಳು ಅರ್ಥ 953 01:20:53,830 --> 01:20:56,520 ಇನ್ನೂ ನಿಜವಾದ ಅನ್ನು ಕಾಣಿಸುತ್ತದೆ. 954 01:20:56,520 --> 01:21:03,240 ನನ್ನ ECHO ಧ್ವಜ ನಿಜವಾದ ಹೊಂದಿಸಲಾಗಿದೆ ವೇಳೆ, ನಂತರ ಈ ಅಗತ್ಯವಾಗಿ ECHO ಧ್ವಜ ಮೇಲೆ ಸುಳ್ಳು ಹೊಂದಿಸಲಾಗಿದೆ. 955 01:21:03,240 --> 01:21:07,170 ಆದ್ದರಿಂದ ಕೋಡ್ ಈ ರೇಖೆಯು ECHO ಫ್ಲ್ಯಾಗ್ ಆಫ್ ತಿರುಗುತ್ತದೆ. 956 01:21:07,170 --> 01:21:16,270 ಕೋಡ್ ಇತರೆ ಸಾಲುಗಳನ್ನು ನಾನು ಅವರಿಗೆ ಆ ಬಗ್ಗೆ ನಕಲಿಸಿ ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ. 957 01:21:27,810 --> 01:21:30,180 ದ್ರಾವಣದಲ್ಲಿ, ಆತ 0 ಹೇಳಿದರು. 958 01:21:30,180 --> 01:21:33,880 ಇದು ಸ್ಪಷ್ಟವಾಗಿ stdin ಹೇಳಲು ಬಹುಶಃ ಉತ್ತಮ. 959 01:21:33,880 --> 01:21:42,100 >> ಇಲ್ಲಿ ICANON | ನಾನು ECHO ಮಾಡುತ್ತಿರುವೆ ಗಮನಿಸಿ. 960 01:21:42,100 --> 01:21:46,650 ICANON ಅಂಗೀಕೃತ ಕ್ರಮದಲ್ಲಿ ಅಂದರೆ ಪ್ರತ್ಯೇಕ ಏನೋ ಉಲ್ಲೇಖಿಸುತ್ತದೆ. 961 01:21:46,650 --> 01:21:50,280 ನೀವು ಆಜ್ಞಾ ಸಾಲಿನ ಔಟ್ ಟೈಪ್ ಮಾಡಿದಾಗ ಏನು ಅಂಗೀಕೃತ ಮೋಡ್ ಎಂದರೆ, ಸಾಮಾನ್ಯವಾಗಿ 962 01:21:50,280 --> 01:21:54,670 ನೀವು ಹೊಸಸಾಲು ಹಿಟ್ ರವರೆಗೆ ಗುಣಮಟ್ಟದ ಏನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮಾಡುವುದಿಲ್ಲ. 963 01:21:54,670 --> 01:21:58,230 ಆದ್ದರಿಂದ ನೀವು GetString ಮಾಡುವಾಗ ನೀವು ಹೊಸಸಾಲು ಹಿಟ್ ನಂತರ, ವಸ್ತುಗಳ ಒಂದು ಗುಂಪೇ ಟೈಪಿಸಿ. 964 01:21:58,230 --> 01:22:00,590 ಇದು ಸೈನ್ ಗುಣಮಟ್ಟದ ಕಳುಹಿಸುವ ಆ ಸ್ 965 01:22:00,590 --> 01:22:02,680 ಡೀಫಾಲ್ಟ್ ಇಲ್ಲಿದೆ. 966 01:22:02,680 --> 01:22:05,830 ನಾನು, ನೀವು ಒತ್ತಿ ಈಗ ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಅಂಗೀಕೃತ ಮೋಡ್ ಆಫ್ ಮಾಡಿದಾಗ 967 01:22:05,830 --> 01:22:10,910 ಏನು, ಈ ವಿಷಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಧಾನ ಏಕೆಂದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ರೀತಿಯ ಇದು ಸಂಸ್ಕರಿಸಿದ ಮುಟ್ಟುತ್ತದೆ ಇದೆ 968 01:22:10,910 --> 01:22:14,330 ಇದು ಸಂಪೂರ್ಣ ಸಾಲಾಗಿ ಇದು ಪ್ರತಿರೋಧಿಸುತ್ತದೆ ಉತ್ತಮ ಎಂಬುದನ್ನು ಇದು. 969 01:22:14,330 --> 01:22:16,810 ಆದರೆ ನಾನು ಪ್ರತಿ ಪಾತ್ರದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ 970 01:22:16,810 --> 01:22:18,810 ನನ್ನ ಹೊಸಸಾಲು ಹೊಡೆಯಲು ಅದನ್ನು ನಿರೀಕ್ಷಿಸಿ ಬಯಸುವುದಿಲ್ಲ ರಿಂದ 971 01:22:18,810 --> 01:22:21,280 ಎಲ್ಲಾ ಪಾತ್ರಗಳು ಸಂಸ್ಕರಿಸುವ ಮುನ್ನ ನಾನು ಟೈಪ್ ಮಾಡಲಾಗಿದೆ. 972 01:22:21,280 --> 01:22:24,760 ಈ ಅಂಗೀಕೃತ ಮೋಡ್ ಆಫ್ ತಿರುಗುತ್ತದೆ. 973 01:22:24,760 --> 01:22:31,320 ಇದು ವಾಸ್ತವವಾಗಿ ಪಾತ್ರಗಳು ಸಂಸ್ಕರಿಸುವಾಗ ಈ ವಿಷಯವನ್ನು ಕೇವಲ ಅರ್ಥ. 974 01:22:31,320 --> 01:22:35,830 , ತಕ್ಷಣ ನಾನು ಅವುಗಳನ್ನು ಟೈಪ್ ನಾನು ಅವುಗಳನ್ನು ಸಂಸ್ಕರಿಸಲು; ಈ ತಕ್ಷಣವೇ ಅವುಗಳನ್ನು ಸಂಸ್ಕರಿಸಲು ಅರ್ಥ. 975 01:22:35,830 --> 01:22:42,510 ಮತ್ತು ಇದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ನನ್ನ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ನವೀಕರಿಸುವಾಗ ಇದು ಕಾರ್ಯ 976 01:22:42,510 --> 01:22:45,480 ಮತ್ತು TCSA ಎಂದರೆ ಈಗ ಅದನ್ನು. 977 01:22:45,480 --> 01:22:50,310 ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಎಲ್ಲ ಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುವ ತನಕ ಇತರ ಆಯ್ಕೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ ಮಾಡಲಾಗುತ್ತದೆ. 978 01:22:50,310 --> 01:22:52,030 ನಿಜಕ್ಕೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ. 979 01:22:52,030 --> 01:22:56,920 ಕೇವಲ ಇದೀಗ ನನ್ನ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು hacker_typer_settings ಪ್ರಸ್ತುತ ಯಾವುದೇ ಎಂದು ಬದಲಾಯಿಸಿ. 980 01:22:56,920 --> 01:23:02,210 ನಾನು hacker_settings ಎಂಬ ಊಹೆ, ಆದ್ದರಿಂದ ಅವರ ಎಂದು ಬದಲಾಯಿಸಲು ಅವಕಾಶ. 981 01:23:09,610 --> 01:23:13,500 Hacker_settings ಎಲ್ಲವನ್ನೂ ಬದಲಿಸಿ. 982 01:23:13,500 --> 01:23:16,870 >> ಈಗ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ನಾವು ಹಿಂತಿರುಗಿ ಬಯಸುವ ಎಂದು ನೀನು 983 01:23:16,870 --> 01:23:20,210 normal_settings ಒಳಗೆ ಪ್ರಸ್ತುತ ಏನು, 984 01:23:20,210 --> 01:23:26,560 ಇದು ಕೇವಲ & normal_settings ಕಾಣುವಂತೆ ಹೋಗುತ್ತದೆ. 985 01:23:26,560 --> 01:23:30,650 ನಾನು ಮೂಲತಃ ಅದನ್ನು ಪಡೆಯಲು ರಿಂದ ನನ್ನ normal_settings ಯಾವುದೇ ಬದಲಾವಣೆಯಾಗಿಲ್ಲ ಗಮನಿಸಿ. 986 01:23:30,650 --> 01:23:34,520 ನಂತರ ಅವುಗಳನ್ನು ಮತ್ತೆ ಬದಲಾಯಿಸಲು, ನಾನು ಕೊನೆಯಲ್ಲಿ ಅವರನ್ನು ಮರಳಿ ಹಾದುಹೋಗುತ್ತವೆ. 987 01:23:34,520 --> 01:23:38,390 ಈ ಅಪ್ಡೇಟ್ ಆಗಿತ್ತು. ಸರಿ. 988 01:23:38,390 --> 01:23:43,900 >> ಒಳಗೆ ಇಲ್ಲಿ ಈಗ ನಾನು ಆ ಬಗ್ಗೆ ಕೋಡ್ ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ. 989 01:23:43,900 --> 01:23:46,350 ಇದು ಸಾಕಷ್ಟು ಕೋಡ್ ಅಲ್ಲ. 990 01:23:50,770 --> 01:24:03,750 ನಾವು ಕಡತದಿಂದ ಒಂದು ಪಾತ್ರ ಓದಿ ನೋಡಿ. ನಾವು ಎಫ್ ಕರೆಯಲಾಗುತ್ತದೆ. 991 01:24:03,750 --> 01:24:07,850 ಈಗ ನೀವು ಮನುಷ್ಯ fgetc ಮಾಡಬಹುದು, ಆದರೆ ಹೇಗೆ fgetc ಕೆಲಸ ಹೋಗುತ್ತದೆ 992 01:24:07,850 --> 01:24:11,910 ಕೇವಲ ನೀವು ಕೇವಲ ಓದಲು ಅಥವಾ EOF ಪಾತ್ರದ ಮರಳಲು ವಿಶೇಷವೇನು ಇದೆ, 993 01:24:11,910 --> 01:24:15,680 ಇದು ಕಡತ ಅಥವಾ ಕೆಲವು ದೋಷ ಸಂಭವಿಸುವುದರ ಕೊನೆಯಲ್ಲಿ ಅನುರೂಪವಾಗಿದೆ. 994 01:24:15,680 --> 01:24:19,900 ನಾವು, ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು ಮುಂದುವರಿಸಿದ್ದೇವೆ ಲೂಪಿಂಗ್ ಮಾಡಲಾಗುತ್ತದೆ 995 01:24:19,900 --> 01:24:22,420 ನಾವು ಓದಲು ಪಾತ್ರಗಳ ರನ್ ಔಟ್ ಮಾಡಿದ ರವರೆಗೆ. 996 01:24:22,420 --> 01:24:26,650 ನಾವು ಮಾಡುತ್ತಿರುವುದು ಆದರೆ, ನಾವು ಸೈನ್ ದರ್ಜೆಯಿಂದ ಒಂದೇ ಪಾತ್ರದ ಮೇಲೆ ನಿರೀಕ್ಷಿಸಿ 997 01:24:26,650 --> 01:24:29,090 ಪ್ರತಿಯೊಂದು ಬಾರಿ, ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಏನೋ ಟೈಪ್ 998 01:24:29,090 --> 01:24:32,820 ಸೈನ್ ಪ್ರಮಾಣಿತ ಒಂದು ಅಕ್ಷರ ಓದುವ ಎಂದು 999 01:24:32,820 --> 01:24:38,330 ನಂತರ putchar ನಾವು ಕಡತದಿಂದ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಮಾಡಲು ಇಲ್ಲಿ ಓದಲು ಚಾರ್ ಹಾಕಲು ಹೋಗುತ್ತದೆ. 1000 01:24:38,330 --> 01:24:42,890 ನೀವು ಮನುಷ್ಯ putchar ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಕೇವಲ ಗುಣಮಟ್ಟದ ಹೊರಹಾಕುವ, ಅದು ಪಾತ್ರದ ಮುದ್ರಣ ಮಾಡಿದ. 1001 01:24:42,890 --> 01:24:51,600 ಅದೇ ಪರಿಕಲ್ಪನೆಯನ್ನು; ನೀವು ಕೇವಲ printf ("% s", ಸಿ) ಇಲ್ಲ. 1002 01:24:53,330 --> 01:24:56,670 ನಮ್ಮ ಕೆಲಸದ ಬಲ್ಕ್ ಮಾಡಲು ವಿಶೇಷವೇನು. 1003 01:24:56,670 --> 01:25:00,300 >> ನಾವು ಬಯಸುವ ಎಂದು ನೀನು ಕಡೆಯದಾಗಿ ನಮ್ಮ ಫೈಲ್ fclose ಹೊಂದಿದೆ. 1004 01:25:00,300 --> 01:25:03,310 ನೀವು fclose ಇದ್ದರೆ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಇಲ್ಲಿದೆ. 1005 01:25:03,310 --> 01:25:06,680 ನಾವು ಮೂಲತಃ ತೆರೆಯಿತು ಕಡತ fclose ಬಯಸುವ, ಮತ್ತು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. 1006 01:25:06,680 --> 01:25:13,810 ನಾವು ಮಾಡಿದರೆ, ನಾನು ಈಗಾಗಲೇ ಸಮಸ್ಯೆಗಳನ್ನು ದೊರೆತಿದೆ. 1007 01:25:13,810 --> 01:25:17,260 ನೋಡೋಣ. 1008 01:25:17,260 --> 01:25:19,960 ಇದು ಬಗ್ಗೆ ದೂರು ನೀಡಲಿಲ್ಲ? 1009 01:25:19,960 --> 01:25:30,220 ನಿರೀಕ್ಷಿತ 'ಇಂಟ್' ಆದರೆ ವಾದದ ಪ್ರಕಾರ 'struct _IO_FILE *' ಹೊಂದಿದೆ. 1010 01:25:36,850 --> 01:25:39,370 ಆ ಕೆಲಸ ನಾವು ನೋಡುತ್ತಾರೆ. 1011 01:25:45,210 --> 01:25:53,540 ಕೇವಲ C99 ಅನುಮತಿ. Augh. ಸರಿ, hacker_typer ಮಾಡಿ. 1012 01:25:53,540 --> 01:25:57,760 ಈಗ ನಾವು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ವಿವರಣೆ ಸಿಗುತ್ತದೆ. 1013 01:25:57,760 --> 01:25:59,900 ಆದ್ದರಿಂದ ಘೋಷಿಸಲ್ಪಡದ ಗುರುತು 'normal_settings' ಬಳಕೆ. 1014 01:25:59,900 --> 01:26:04,170 ನಾನು normal_settings ಕಾಲ್ ಮಾಡಲಿಲ್ಲ. ನಾನು current_settings ಕರೆಯಲಾಗುತ್ತದೆ. 1015 01:26:04,170 --> 01:26:12,090 ಇದರಿಂದ ಆ ಎಲ್ಲಾ ಬದಲಾಯಿಸಲು ಅವಕಾಶ. 1016 01:26:17,920 --> 01:26:21,710 ಈಗ ವಾದ ಹಾದುಹೋಗುವ. 1017 01:26:26,290 --> 01:26:29,500 ನಾನು ಈಗ ಈ 0 ಮಾಡಿಕೊಳ್ಳುವಿರಿ. 1018 01:26:29,500 --> 01:26:36,720 ಸರಿ. . / Hacker_typer cp.c. 1019 01:26:36,720 --> 01:26:39,590 ನಾನು ಆರಂಭದಲ್ಲಿ ತೆರೆ ತೆರವುಗೊಳಿಸಿ ಮಾಡಲಿಲ್ಲ. 1020 01:26:39,590 --> 01:26:42,960 ಆದರೆ ನೀವು ತೆರೆಯ ತೆರವುಗೊಳಿಸಿ ಹೇಗೆ ನೋಡಲು ಕೊನೆಯ ಸಮಸ್ಯೆ ಸೆಟ್ ಮತ್ತೆ ನೋಡಬಹುದು. 1021 01:26:42,960 --> 01:26:45,160 ಇದು ಕೆಲವು ಪಾತ್ರಗಳು ಮುದ್ರಿಸುವ ವಿಶೇಷವೇನು 1022 01:26:45,160 --> 01:26:47,210 ಈ ನಾನು ಬಯಸುವ ಏನು ಹಾಗೆಯೇ. 1023 01:26:47,210 --> 01:26:48,900 ಸರಿ. 1024 01:26:48,900 --> 01:26:55,280 ಮತ್ತು ಈ ಬದಲಿಗೆ stdin 0 ಎಂದು ಅಗತ್ಯವಿದೆ ಏಕೆ ವಿಚಾರ, 1025 01:26:55,280 --> 01:27:00,560 ಇದು # 0 ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡಬೇಕು 1026 01:27:00,560 --> 01:27:03,890 ಈ ಎಂದು ದೂರು ಇದೆ - 1027 01:27:13,150 --> 01:27:19,360 ನಾನು ಫೈಲ್ ವಿವರಣೆಗಳ ಇಲ್ಲ ಎಂದು ಆದರೆ ನೀವು ನಿಮ್ಮ ಫೈಲ್ * ಹೊಂದಿರುವಾಗ ಮೊದಲು, 1028 01:27:19,360 --> 01:27:23,210 ಒಂದು ಕಡತ ವಿವರಣೆಗಾರನನ್ನು, ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕ 1029 01:27:23,210 --> 01:27:26,970 ಫೈಲ್ * ಇದು ಸಂಬಂಧಿಸಿದ ವಿಷಯದ ಸಂಪೂರ್ಣ ಗುಂಪೇ ಹೊಂದಿದೆ ಆದರೆ. 1030 01:27:26,970 --> 01:27:30,380 ನಾವು ಬದಲಿಗೆ stdin 0 ಹೇಳಲು ಅಗತ್ಯವಿದೆ ಕಾರಣ 1031 01:27:30,380 --> 01:27:37,480 ಆ stdin ಕಡತ ವಿವರಣೆಗಾರನನ್ನು 0 ಉಲ್ಲೇಖಿಸುತ್ತಿದ್ದಾರೆ ವಿಷಯ ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಇದು ಫೈಲ್ * ಆಗಿದೆ. 1032 01:27:37,480 --> 01:27:45,070 ಆದ್ದರಿಂದ ಕೂಡ ಇಲ್ಲಿ ನಾನು fopen ಮಾಡಿದಾಗ (argv [1], ನಾನು ಮತ್ತೆ ಫೈಲ್ * ಗೆಟ್ಟಿಂಗ್ ದೇರ್. 1033 01:27:45,070 --> 01:27:51,180 ಆದರೆ ಎಲ್ಲೋ ಫೈಲ್ * ಆ ಕಡತ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಸಂಬಂಧಪಟ್ಟ ವಿಷಯ. 1034 01:27:51,180 --> 01:27:57,430 ನೀವು ತೆರೆದ ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಿದರೆ, ಆದ್ದರಿಂದ ನಾನು ಮನುಷ್ಯ 3 ಮುಕ್ತ ಮಾಡಬೇಕು ತಿಳಿಯುತ್ತೇನೆ - ಇಲ್ಲ - 1035 01:27:57,430 --> 01:27:59,380 ಮ್ಯಾನ್ 2 ತೆರೆದ - ಹೌದು. 1036 01:27:59,380 --> 01:28:06,250 ನೀವು ತೆರೆದ ಪುಟವನ್ನು ನೋಡಿದರೆ, ಮುಕ್ತ, ಕಡಿಮೆ ಮಟ್ಟದ fopen ಹಾಗೆ 1037 01:28:06,250 --> 01:28:09,350 ಮತ್ತು ಅದು ವಾಸ್ತವಿಕ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಮರಳಿದ ನ. 1038 01:28:09,350 --> 01:28:12,050 fopen ತೆರೆದ ಮೇಲೆ ವಿಷಯವನ್ನು ಒಂದು ಗುಂಪೇ ಮಾಡುತ್ತದೆ, 1039 01:28:12,050 --> 01:28:17,640 ಬದಲಿಗೆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಇಡೀ FILE * ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಕೇವಲ ಹಿಂದಿರುಗಿದ ಯಾವ 1040 01:28:17,640 --> 01:28:20,590 ಒಳಗೆ ನಮ್ಮ ಕಡಿಮೆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಹೊಂದಿದೆ. 1041 01:28:20,590 --> 01:28:25,020 FILE * ವಿಷಯ ಸೂಚಿಸುತ್ತದೆ ತುಂಬಾ ಸಾಮಾನ್ಯ, 1042 01:28:25,020 --> 01:28:29,120 0 ಸ್ವತಃ ಕೇವಲ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಗುಣಮಟ್ಟದ ಸೂಚಿಸುತ್ತದೆ ಆದರೆ. 1043 01:28:29,120 --> 01:28:32,160 >> ಪ್ರಶ್ನೆಗಳು? 1044 01:28:32,160 --> 01:28:35,930 [ನಗು] ಆ ಮೂಲಕ ಉಡಾಯಿಸಿದರು. 1045 01:28:35,930 --> 01:28:39,140 ಎಲ್ಲಾ ಸರಿ. ನಾವು ಮುಗಿಸಿದ್ದೀರಿ. [ನಗು] 1046 01:28:39,140 --> 01:28:42,000 >> [CS50.TV]