[Powered by Google Translate] [ವಿಭಾಗ 5 - ಹೆಚ್ಚು ಆರಾಮದಾಯಕ] [ರಾಬ್ ಬೌಡೆನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ] [ಈ CS50 ಹೊಂದಿದೆ. - CS50.TV] 

ನನ್ನ ಇಮೇಲ್ ಹೇಳಿದರು ಹಾಗೆ, ನೀವು ಬಳಸಬಹುದು ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಇವೆ ವಾಸ್ತವವಾಗಿ ಸಮಸ್ಯೆ ಸೆಟ್ ಮಾಡಲು APPLIANCE ಬೇರೆ. ನಾವು ನಾವು ಸುಲಭವಾಗಿ ನೀವು ಸಹಾಯ ಮಾಡಬಹುದು ಕೇವಲ ನೀವು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅದನ್ನು ಶಿಫಾರಸು ನಾವು ಎಲ್ಲವನ್ನೂ ಕೆಲಸ ಹೋಗುತ್ತದೆ ಹೇಗೆ ಗೊತ್ತು. ಆದರೆ ಹೇಳಿ, ನೀವು ವಸ್ತುಗಳನ್ನು ಮಾಡಬಹುದು ಅಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿ, ನೀವು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಒಂದು APPLIANCE ಅಥವಾ ನೀವು ಸೈನ್ಸ್ ಸೆಂಟರ್ ನೆಲಮಾಳಿಗೆಯಲ್ಲಿ ಕೆಲಸ ಬಯಸುವ - ಇದು ವಾಸ್ತವವಾಗಿ ಅವರು ತುಂಬಾ APPLIANCE ಹೊಂದಿವೆ - ನೀವು ಎಲ್ಲಿಯಾದರೂ ಕೆಲಸ ಬಯಸಿದರೆ. ಒಂದು ಉದಾಹರಣೆಗೆ ನೀವು ಕಾಣಬಹುದು / SSH ನ ಕೇಳಿರಬಹುದು ಇದೆ? SSH ಕೇವಲ ಏನೋ ಸಂಪರ್ಕ ಮುಂತಾದ ಮೂಲಭೂತ. ವಾಸ್ತವವಾಗಿ, ಇದೀಗ ನಾನು APPLIANCE ಆಗಿ SSHed ನುಡಿದರು. ನಾನು ಉಪಕರಣಗಳಲ್ಲಿರುವ ನೇರವಾಗಿ ಕೆಲಸ ಇಲ್ಲ. ಇಲ್ಲಿ APPLIANCE ಹೊಂದಿದೆ, ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಕೆಳಗೆ ನೋಡಿದರೆ ಈ IP ವಿಳಾಸವನ್ನು ನೋಡಿ. ನಾನು APPLIANCE ಸ್ವತಃ ಕೆಲಸ ಇಲ್ಲ; ನಾನು ಯಾವಾಗಲೂ ಒಂದು iTerm2 ವಿಂಡೋ / ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಗೆ ಬರುತ್ತಾರೆ. ನಿಮ್ಮ IP ವಿಳಾಸವನ್ನು, SSH jharvard@192.168.129.128 ಇದಕ್ಕೆ SSH ಮಾಡಬಹುದು. ಇದು ಎ ನೈಸ್ ಮಾದರಿ, ಏಕೆಂದರೆ ನಾನು ತುಂಬಾ ಸುಲಭವಾಗಿ ಆ ಸಂಖ್ಯೆ ನೆನಪಿಡಿ. ಆದರೆ ನನ್ನ ಪಾಸ್ವರ್ಡ್ ನನಗೆ ಕೇಳುತ್ತೇವೆ, ಮತ್ತು ಈಗ ನಾನು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಆಗಿದ್ದೇನೆ. ಮೂಲತಃ, ಈ ಹಂತದಲ್ಲಿ, ನೀವು, APPLIANCE ಸ್ವತಃ ಒಳಗೆ ಒಂದು ಟರ್ಮಿನಲ್ ತೆರೆದಿವೆ ಈ ಇಂಟರ್ಫೇಸ್, ಆದರೆ ನೀವು ಅದನ್ನು ಬಳಸಬಹುದು, ನಿಖರವಾಗಿ ಒಂದೇ ಇಂಟರ್ಫೇಸ್ ಎಂದು ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಬಳಸಿಕೊಂಡು ನಾನು ಆದರೆ ಈಗ ನೀವು SSHed ಮಾಡುತ್ತಿದ್ದೇವೆ. ನೀವು APPLIANCE ಇದಕ್ಕೆ SSH ಇಲ್ಲ. ನಿಮ್ಮನ್ನು ಸಾಧ್ಯವೋ SSH ಇನ್ನೊಂದು ಸ್ಥಳದ ಒಂದು ಉದಾಹರಣೆಗೆ ನಾನು ನೀವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿರುತ್ತವೆ ಬಹಳ ಖಚಿತವಾಗಿ ನನಗೆ - ಓಹ್. ದೊಡ್ಡ. ನೀವು ಎಲ್ಲಾ FAS ಸರ್ವರ್ಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ FAS ಖಾತೆಗಳನ್ನು ಅದಕ್ಕೆ ಇರಬೇಕು. ನನಗೆ, ನಾನು SSH rbowden@nice.fas.harvard.edu ಇಚ್ಚಿಸುತ್ತಾರೆ. ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಕೇಳಲು ವಿಶೇಷವೇನು, ಮತ್ತು ನೀವು ಸೇ ಯಸ್. ನನ್ನ ಪಾಸ್ವರ್ಡ್ ನನ್ನ FAS ಪಾಸ್ವರ್ಡ್ ಏರಲಿದೆ. ಆದ್ದರಿಂದ ಈಗ, ನಾನು ಸಂತೋಷವನ್ನು ಸರ್ವರ್ಗಳಿಗೆ SSHed ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ನಾನು ಇಲ್ಲಿ ನೀವು ಏನು ಮಾಡಬಹುದು. ನೀವು 124 ನಂತಹ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ತರಗತಿಗಳು ಬಹಳಷ್ಟು, ನೀವು ಇಲ್ಲಿ ವಿಷಯವನ್ನು ಅಪ್ಲೋಡ್ ಹೊಂದಿರುತ್ತವೆ ಹೋಗುವ ವಾಸ್ತವವಾಗಿ ನಿಮ್ಮ ಸಮಸ್ಯೆ ಸೆಟ್ ಸಲ್ಲಿಸಲು. ಆದರೆ ನೀವು ನಿಮ್ಮ APPLIANCE ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಹೇಳುತ್ತಾರೆ. ನಂತರ ನೀವು, ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು ಇಲ್ಲಿ ಮೇಲೆ ನಂತಹ ಇದು ಹೇಳುವುದಿಲ್ಲ - ಈ ಕೇವಲ ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ಹೊಂದಿದೆ. ಇದು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಇದನ್ನು ಮಾಡಲು ನೀವು ಕೇಳುತ್ತೇವೆ. ಬದಲಿಗೆ ನಾನು ಸರ್ವರ್ ಅದನ್ನು ಮಾಡುತ್ತೇನೆ. ನಾನು ಅನ್ಜಿಪ್ ಪಡೆಯಲಿದ್ದೇನೆ. ಸಮಸ್ಯೆಯನ್ನು ನೀವು ಜಿಎಡಿಟ್ Name ರೀತಿಯ ಬಳಸಿಕೊಂಡು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಏರಲಿದೆ APPLIANCE ಅಥವಾ ಯಾವುದೇ ಒಳಗೆ. ನೀವು FAS ಸರ್ವರ್ ಮೇಲೆ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ. ಇದು ಕೇವಲ ಈ ಪಠ್ಯ ಇಂಟರ್ಫೇಸ್ ಎಂದು ವಿಶೇಷವೇನು. ನೀವು, ಅವರು ನಿಮಗೆ ಒಂದು ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ ತಿಳಿಯಲು ಒಂದೋ ಪ್ರಯತ್ನಿಸಬಹುದು. ಅವರು ನ್ಯಾನೋ ಹೊಂದಿರುತ್ತವೆ. ನ್ಯಾನೋ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲು ಬಹಳ ಸುಲಭ. ನಿಮ್ಮ ಬಾಣಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಟೈಪ್ ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ಹಾರ್ಡ್ ಅಲ್ಲ. ನೀವು ನಿಜವಾಗಿಯೂ ಅಲಂಕಾರಿಕ ಪಡೆಯಲು ಬಯಸಿದರೆ ನೀವು ಈಮಾಕ್ಸ್ GenericName ಬಳಸಬಹುದು ನಾನು ಈಮಾಕ್ಸ್ GenericName ಮುಚ್ಚಿ ಗೊತ್ತಿಲ್ಲದ ಕಾರಣ ಇದು ನಾನು ಬಹುಶಃ ತೆರೆಯಿತು ಮಾಡಬಾರದಾಗಿತ್ತು. ಕಂಟ್ರೋಲ್ ಎಕ್ಸ್, ಕಂಟ್ರೋಲ್ ಸಿ? ಹೌದು. ಅಥವಾ ನೀವು ನಾನು ಬಳಸಲು ಯಾವ ಇದು ಕಸುವು, ಬಳಸಬಹುದು. ಮತ್ತು ಆದ್ದರಿಂದ ಆ ನಿಮ್ಮ ಆಯ್ಕೆಗಳು ಹೀಗಿವೆ. ನೀವು ಮಾಡಲು ಬಯಸದಿದ್ದರೆ, ನೀವು ಸಹ, ನೀವು ನೋಡಿದರೆ manual.cs50.net-- ಓಹ್. ಒಂದು PC ಯಲ್ಲಿ, ನೀವು SSH, ಪುಟ್ಟಿ ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ ಡೌನ್ಲೋಡ್ ಮಾಡಲಿಕ್ಕೆ ನೀವು ಇದು. ಒಂದು ಮ್ಯಾಕ್ ಮೇಲೆ, ನೀವು ಕೇವಲ ಡೀಫಾಲ್ಟ್ ಬಳಕೆಯ ಟರ್ಮಿನಲ್ ಅಥವಾ ನೀವು iTerm2 ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು ಇದು ಒಂದು ಉತ್ತಮ, ಅಲಂಕಾರಿಕ ಟರ್ಮಿನಲ್ ಹಾಗೆ. ನೀವು manual.cs50.net ಹೋಗಿ ನೀವು ನೋಟ್ಪಾಡ್ ಲಿಂಕ್ ನೋಡುತ್ತಾರೆ + + ಇದು ನೀವು ಒಂದು PC ಯಲ್ಲಿ ಬಳಸಬಹುದು ಏನು. ಇದು ನೋಟ್ಪಾಡ್ ನೀವು SFTP ಅನುಮತಿಸುತ್ತದೆ + +, ಇದು ಮೂಲತಃ SSH ಹೊಂದಿದೆ. ಎಂಬುದನ್ನು ನೀವೇ ಮಾಡಿ ಕಾಣಿಸುತ್ತದೆ, ಸ್ಥಳೀಯವಾಗಿ ನಿಮ್ಮ ಕಡತಗಳನ್ನು ಸಂಪಾದಿಸಲು ತದನಂತರ ನೀವು ಉಳಿಸಲು ಬಯಸುವ ಮಾಡಿದಾಗ, ಅದು, nice.fas ಉಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ ನೀವು ನಂತರ ಅವುಗಳನ್ನು ಚಾಲನೆ ಮಾಡಬಹುದು. ಮತ್ತು ಮ್ಯಾಕ್ ಮೇಲೆ ಸಮಾನ TextWrangler ಏರಲಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಒಂದೇ ವಿಷಯವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಇದು ನೀವು ಸ್ಥಳೀಯವಾಗಿ ಕಡತಗಳನ್ನು ಸಂಪಾದಿಸಲು ಮತ್ತು nice.fas ಅವರನ್ನು ಉಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ನೀವು ನಂತರ ಅವುಗಳನ್ನು ಚಾಲನೆ ಮಾಡಬಹುದು. ಎಂದಾದರೂ ಒಂದು APPLIANCE ಇಲ್ಲದೆ ಸಿಕ್ಕಿಕೊಂಡುಬಿಟ್ಟಿರುತ್ತೇವೆ ಆದ್ದರಿಂದ, ನೀವು ಈ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿವೆ ನಿಮ್ಮ ಸಮಸ್ಯೆ ಸೆಟ್ ಮಾಡಲು ಸಹ. ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ ಎಂದು ಎಂದು ಹೋಗುತ್ತದೆ nice.fas ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ. ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು - ನಾನು ಈ ಹಂತದಲ್ಲಿ ಅಗತ್ಯವಿದೆ ಯೋಚಿಸುವುದಿಲ್ಲ. ನೀವು, CS50 ಗ್ರಂಥಾಲಯದ ಡೌನ್ಲೋಡ್ ಮತ್ತು nice.fas ಅದನ್ನು ನಕಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಅಥವಾ ನಾನು ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಹೇಗಾದರೂ ಇನ್ನೆಂದಿಗೂ ಬಳಸಬೇಡಿ ಭಾವಿಸುತ್ತೇನೆ. ನಾವು ಅಥವಾ, ನೀವು ಬಾರಿಗೆ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಎಂದು ಮಾಡಬಹುದು ಹೇಗಾದರೂ CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಅಳವಡಿಕೆಗಳು. ಆದ್ದರಿಂದ ಒಂದು ನಿರ್ಬಂಧದ ಹೆಚ್ಚು ಇರಬಾರದು. ಮತ್ತು ಆ ಸ್. 

ನಾನು ಈಗ APPLIANCE ಮರಳಿ ಹೋಗುತ್ತೇನೆ; ನಾವು ಉಪಕರಣಗಳಲ್ಲಿರುವ ಎಲ್ಲವನ್ನು ಮಾಡುತ್ತೇನೆ. ನನ್ನ ಇಮೇಲ್ ಹೇಳಿದರು ನಂತಹ, ಆರಂಭದಲ್ಲಿ, ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನೀವು ವೀಕ್ಷಿಸಲು ಭಾವಿಸಲಾಗಿತ್ತು ಸಣ್ಣ ಒಂದು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಹೊಂದಿವೆ. ನಾವು ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ & ಪೈಪ್ಸ್ ಮತ್ತು ಈ ಮೂರು ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ. 

ಯಾವ ಸ್ಟ್ರೀಮ್ ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು printf ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬರೆಯುವಿರಾ? ಸ್ಟ್ರೀಮ್ ಆದ್ದರಿಂದ. ಒಂದು ಸ್ಟ್ರೀಮ್ ಎಂದರೇನು? ಇದು ಕೆಲವು ಆದಂತೆ ಒಂದು ಸ್ಟ್ರೀಮ್ ಮೂಲತಃ ಹೊಂದಿದೆ - ಇದು 1 ಸೆ 0 ಸೆ ಮತ್ತು ಮೂಲವಾಗಿ ಈಸ್ ನಾಟ್. ಇಲ್ಲಿ ಕೇಳುವ ಅವರ ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಆಗಿದೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಮಾನದಂಡಾತ್ಮಕ ಔಟ್ ಒಂದು ಸ್ಟ್ರೀಮ್ ನೀವು ಅದನ್ನು ಬರೆಯುತ್ತೇನೆ ಅದನ್ನು ತೆರೆಯ ಮೇಲೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್, ಸ್ಟ್ರೀಮ್ ಮೂಲಕ, ನೀವು ಕೇವಲ 1 ಸೆ ಮತ್ತು ಅದರ 0 ಸೆ ಬರೆಯಲು ಅರ್ಥ ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ಇತರೆ ಕೊನೆಯಲ್ಲಿ ಕೇವಲ ಸ್ಟ್ರೀಮ್ನ ಓದುತ್ತದೆ. ಇದು ಕೇವಲ 1 ಸೆ 0 ಸೆ ಮತ್ತು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನ. ನೀವು ಹೊಳೆಗಳು ಬರೆಯಬಹುದು ಅಥವಾ ನೀವು ತೊರೆಗಳಿಂದ ಓದಬಹುದು ಸ್ಟ್ರೀಮ್ ವಾಸ್ತವವಾಗಿ ಎನ್ನುವುದನ್ನು ಅವಲಂಬಿಸಿ. ಇತರ ಎರಡು ಡೀಫಾಲ್ಟ್ ತೊರೆಗಳು ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ ಮಾನಕವಾಗಿಬಿಟ್ಟಿದೆ. ನೀವು GetString ಇಲ್ಲ ಬಂದಾಗಲೆಲ್ಲಾ ಗುಣಮಟ್ಟದ, ಇದು ನೀವು ಇನ್ಪುಟ್ ವಿಷಯ ಕಾಯುವ ನ. ಆದ್ದರಿಂದ ನೀವು ಕಾಯುತ್ತಿರದಿದ್ದರೆ, ನಿಜವಾಗಿ, ಗುಣಮಟ್ಟದ ಮೇಲೆ ಕಾಯುವ ವಿಶೇಷವೇನು ಇದು ನೀವು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ನೀವು ಪಡೆಯಿರಿ ನಿಜವಾಗಿಯೂ ಹೊಂದಿದೆ. ನೀವು ಲಾಗಿನ್ ಆಗಿ ಪ್ರಮಾಣಿತ ಟೈಪ್ ನೀವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ, ಪ್ರಮಾಣಿತ ಔಟ್ ಗೆ ಮೂಲತಃ ಸಮನಾಗಿರುತ್ತದೆ ನೀವು ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿಸಲು ಆದರೆ ಇದು, ಆ ವಿಶೇಷ ಇಲ್ಲಿದೆ ನೀವು ಮಾತ್ರ ಆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಭಾವಿಸಲಾದ ನೀವು ಆದ್ದರಿಂದ ನೀವು ತೆರೆಯಲ್ಲಿ ಮುದ್ರಿತವಾಗಬಹುದು ನಿಯಮಿತ ಸಂದೇಶಗಳನ್ನು ಬೇರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಅವರು ಪ್ರಮಾಣಿತ ಔಟ್ ಅಥವಾ ಪ್ರಮಾಣಿತ ದೋಷ ಹೋದರು ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ವಿರುದ್ಧ. ತುಂಬಾ ಕಡತಗಳು. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್, ಸ್ಟ್ಯಾಂಡರ್ಡ್, ಮತ್ತು ಸಾಮಾನ್ಯ ದೋಷ, ಕೇವಲ ವಿಶೇಷ ವಾಹಿನಗಳೆಂದರೆ ಆದರೆ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಕಡತ, ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆದಾಗ, ಅದು ಬೈಟ್ಗಳು ಒಂದು ಸ್ಟ್ರೀಮ್ ಆಗುತ್ತದೆ ಅಲ್ಲಿ ನೀವು ಆ ರಾಶಿಯಿಂದ ಓದಬಹುದು. ನೀವು, ಬಹುತೇಕ ಭಾಗ, ಕೇವಲ ಬೈಟ್ಗಳು ಪ್ರವಾಹವು ಒಂದು ಕಡತ ನಗರದ. ಆದ್ದರಿಂದ ಯಾವ ಹೊಳೆಗಳು ಅವರು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬರೆದು? ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್. 

> ಮತ್ತು >> ನಡುವಿನ ಭಿನ್ನತೆ ಏನು? ಯಾರಾದರೂ ಮೊದಲೇ ವಿಡಿಯೋ ವೀಕ್ಷಿಸಲು ಮಾಡಿದ್ದೀರಾ? ಸರಿ. >, ನೀವು ಫೈಲ್ಗಳನ್ನು ಆಗಿ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಹೇಗೆ ಎಂದು ಹೋಗುತ್ತದೆ ಮತ್ತು >> ಸಹ, ಕಡತಗಳು ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶಿಸಲು ಹೋಗುತ್ತದೆ ಆದರೆ ಬದಲಿಗೆ ಕಡತವನ್ನು ಸೇರಿಸಲು ಹೋಗುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಈಗ ನಾನು ಇಲ್ಲಿಯೇ dict ಹೊಂದಿರುತ್ತವೆ ಸಂಭವಿಸಬಹುದು ಹೇಳುತ್ತಾರೆ ಮತ್ತು dict ಒಳಗೆ ಮಾತ್ರ ವಿಷಯವನ್ನು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ನಾಯಿ. ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಹೊಂದಿರುವ ಒಂದು ಆಜ್ಞೆಯನ್ನು, ಬೆಕ್ಕು ಆಗಿದೆ ಇದು ಕೇವಲ ಒಂದು ಕಡತದಲ್ಲಿ ಎಂಬುದನ್ನು ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ಹಾಗಾಗಿ ಬೆಕ್ಕು dict ಹೇಳುತ್ತಾರೆ, ಇದು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ನಾಯಿ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು. ಎಲ್ಲಾ ಬೆಕ್ಕು ಮಾಡುತ್ತದೆ ಇಲ್ಲಿದೆ. ಅದು ಬೆಕ್ಕು, ಬೆಕ್ಕು, ನಾಯಿ, ಮೀನು, ಶ್ವಾನ ಔಟ್ ಗುಣಮಟ್ಟದ ಮುದ್ರಿತ ಎಂದರ್ಥ. ನಾನು ಬದಲಿಗೆ ಕಡತ ಎಂದು ಮರುನಿರ್ದೇಶಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಬಳಸಿ> ಮತ್ತು ಕಡತ ಯಾವುದೇ ಅದನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. ನಾನು ಫೈಲ್ ಫೈಲ್ ಕರೆ ಮಾಡುತ್ತೇವೆ. ನಾನು LS ಆದ್ದರಿಂದ ಈಗ, ನಾನು ಕಡತ ಎಂಬ ಹೊಸ ಕಡತ ಹೊಂದಿರುತ್ತವೆ ನೋಡುತ್ತಾರೆ. ನಾನು ಅದನ್ನು ತೆರೆಯಲು ಮತ್ತು, ಒಂದು ವೇಳೆ ಬೆಕ್ಕು ಆಜ್ಞಾ ಸಾಲಿನ ಮಟ್ಟದಲ್ಲಿದೆ ನಿಖರವಾಗಿ ಏನು ಹೊಂದಿದ್ದರೆ ಹೋಗುವುದಿಲ್ಲ. ನಾನು ಮತ್ತೆ ಹಾಗೆ ಆದ್ದರಿಂದ ಈಗ, ಆಗ ಫೈಲ್ ಆಗಿ ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶಿಸಲು ವಿಶೇಷವೇನು ಮತ್ತು ನಾನು ಅದೇ ನಿಖರ ವಸ್ತು ಹೊಂದಿರುವ ಪಡೆಯಲಿದ್ದೇನೆ. ಆದ್ದರಿಂದ ತಾಂತ್ರಿಕವಾಗಿ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ನಾವು ಯಾವ overrode. ಮತ್ತು ನಾನು dict ಬದಲಾಯಿಸಲು ನಾವು ನೋಡುತ್ತಾರೆ, ನಾನು ನಾಯಿ ತೆಗೆದುಕೊಂಡರು. ಈಗ ಮತ್ತೆ ಕಡತ ನಾವು ಬೆಕ್ಕು dict ವೇಳೆ, ನಾವು ನಾಯಿ ತೆಗೆದು ಹೊಸ ಆವೃತ್ತಿ ಹೊಂದಿರುವ ನೀನು. ಆದ್ದರಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ನಾವು >> ಬಳಸುವ ಬದಲು, ಇದು ಕಡತ ಸೇರಿಸಲು ಹೋಗುವುದಿಲ್ಲ. ಈಗ, ಕಡತವನ್ನು ತೆರೆಯುವ, ನಾವು ಎರಡು ಮುದ್ರಿತ ಕೇವಲ ಒಂದೇ ನೋಡಬಹುದು ಒಮ್ಮೆ ಇರಲಿಲ್ಲ ಏಕೆಂದರೆ, ಆಗ ಮೂಲ ಸೇರಿಸಲಾಗಿದೆ. ಇದರಿಂದ ಆ ಯಾವ> ಮತ್ತು >> ಹಾಗೆ. ಮುಂದಿನ ಒಂದು ಕೇಳಲು ಇಲ್ಲ - ಇದು ಸುಮಾರು ಕೇಳುವುದಿಲ್ಲ. 

ನಾವು ಇತರ ಒಂದು ಪ್ರಮಾಣಿತ ಔಟ್ ಪುನರ್ನಿರ್ದೇಶನಗಳು <ವೇಳೆ ಇದು,>, ಆಗಿದೆ <ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಸೈನ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಏರಲಿದೆ ನಾವು ಒಂದು ಉದಾಹರಣೆಗೆ ಹೊಂದಿದ್ದರೆ ನೋಡೋಣ. ನಾನು ಒಂದು ನೈಜ ಕ್ಷಿಪ್ರ ಬರೆಯಬಹುದು. ಯಾವುದೇ ಕಡತ, hello.c ನೋಡೋಣ. ತುಲನಾತ್ಮಕವಾಗಿ ಸಂಬಂಧ ಕಡತ. ನಾನು ಕೇವಲ ಪ್ರವೇಶಿಸಿತು ಸ್ಟ್ರಿಂಗ್ ಎಂಬ ಏನೇ "ಹಲೋ" ಮುದ್ರಣದ ನಂತರ ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಮತ್ತು ನಾನು. ಆದ್ದರಿಂದ ನಿನ್ನ ನಿನ್ನ ತದನಂತರ ಮಾಡಿ. /. ಈಗ, ಏನೋ ನಮೂದಿಸಿ ನನ್ನನ್ನು ಪ್ರೇರೇಪಿಸಿತು ವಿಶೇಷವೇನು ಇದು ಸೈನ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ನಮೂದಿಸಲಾಗುವ ವಿಷಯಗಳನ್ನು ಮೇಲೆ ಕಾಯುವ ನ ಅರ್ಥ ಆದ್ದರಿಂದ ನಾವು ರಾಬ್, ಹಲೋ ಹೇಳಲು ನೀನು ಸೈನ್ ನಾನು ಪ್ರಮಾಣಿತ ಭಾಷೆಗೆ ಬಯಸುವ ಯಾವುದೇ ನಮೂದಿಸಿ! ಅದು, ಹಲೋ ಔಟ್ ಗುಣಮಟ್ಟದ ರಾಬ್ ಮುದ್ರಿಸುವ ನ! ನಾನು. / ನಿನ್ನ ತದನಂತರ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಮಾಡಿದರೆ ಈಗ ನೀವು ಕೇವಲ ಒಂದು ಕಡತದಿಂದ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. ನಾನು ಕೆಲವು ಫೈಲ್ ಸಂದೇಶ ನೀಡಿದರು ಮತ್ತು ನಾನು, ರಾಬ್ ಪುಟ್ ಆದ್ದರಿಂದ ನಾನು ನಿನ್ನ ರನ್ ಮತ್ತು ಆಗ ಫೈಲ್ ಸಂದೇಶ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ. / ಹಲೋ, ಇದು ರಾಬ್, ಹಲೋ ಹೇಳಲು ಹೋಗುವುದಿಲ್ಲ! ತಕ್ಷಣವೇ. ಇದು ಮೊದಲ GetString ಗೆ ಪಡೆಯುತ್ತದೆ ಮತ್ತು, ಗುಣಮಟ್ಟದ ಮೇಲೆ ಕಾಯುವ ಸಂದರ್ಭದಲ್ಲಿ ಗುಣಮಟ್ಟದ ಪ್ರವೇಶಿಸಿತು ನಿಮಗೆ ಅಕ್ಷಾಂಶ ಕೀಬೋರ್ಡ್ ಮೇಲೆ ಕಾಯುವ ಇನ್ನು ಮುಂದೆ. ಬದಲಾಗಿ, ನಾವು ಫೈಲ್ ಸಂದೇಶ ನಿಂದ ಓದಲು ಗುಣಮಟ್ಟದ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ ಮಾಡಿದ್ದಾರೆ. ಮತ್ತು ಆದ್ದರಿಂದ, ಕೇವಲ ಲೈನ್ ರಾಬ್ ಇದು ಕಡತ ಸಂದೇಶ ನಿಂದ ಓದಲು ವಿಶೇಷವೇನು ನಂತರ ಅದನ್ನು ಹಲೋ, ರಾಬ್ ಮುದ್ರಿಸಲು ಹೋಗುವುದಿಲ್ಲ! ನಾನು ಬಯಸಿದರೆ, ನಾನು ಸಹ ಇಲ್ಲ. / ನಿನ್ನ <ಸಂದೇಶ ತದನಂತರ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎಂದು ಹಲೋ ಇದು ಇದು ಮುದ್ರಣ, ರಾಬ್! ನಾನು ಅದರ ಸ್ವಂತ ಫೈಲ್ ಆಗಿ ಆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು. ನಾನು ನಿನ್ನ ಕಡತ ಕರೆ ಮಾಡುತ್ತೇವೆ - ಯಾವುದೇ, ನಾನು ತಿನ್ನುವೆ, ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಏಕೆಂದರೆ - txt2. ಈಗ, txt2 ಹಲೋ ಎಂದು ಹೋಗುವ ಇದು. / ನಿನ್ನ <ಸಂದೇಶ, ರಾಬ್ ಉತ್ಪತ್ತಿಯು ಮಾಡಲಿಕ್ಕೆ ಇದೆ! 

ಪ್ರಶ್ನೆಗಳು? 

ಸರಿ. ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಪೈಪ್ಲೈನಿನ. ಪೈಪ್ ಪುನರ್ನಿರ್ದೇಶನ ಕೊನೆಯ ಘಟಕ ಇವೆ. 

ಓಹ್. ನಾನು ಪುನರ್ನಿರ್ದೇಶನ ಮತ್ತೊಂದು ಘಟಕ ವೇಳೆ ಬದಲಿಗೆ ಊಹಿಸಿದರು> ನೀವು 2 ಮಾಡಲು> ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ನ. ಏನೋ ಸ್ಥಿರದೋಷ ಹೋದರು ಆದ್ದರಿಂದ ಅದನ್ನು txt2 ಜಾರಿಗೆ ಪಡೆಯುತ್ತೀರಿ ಎಂದು. ಆದರೆ 2> ಹೋದರೆ ಗಮನಿಸಿ, ನಂತರ ಅದು ಇನ್ನೂ ರಾಬ್, ಹಲೋ ಮುದ್ರಿಸುವ ನ! ಆಜ್ಞಾ ಸಾಲಿನ ನಾನು ಕೇವಲ ಪ್ರಮಾಣಿತ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಭಾವಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ, ನಾನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತಿಲ್ಲ ನುಡಿದರು. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷ ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ನೀವು ನಿಜವಾಗಿಯೂ ಗುಣಮಟ್ಟದ ದೋಷದ ಬರೆಯಲು ಇಚ್ಛಿಸುತ್ತೇನೆ, ವೇಳೆ ನಂತರ ನಾನು stderr ಗೆ fprintf ಈ ಬದಲಾಯಿಸಬಹುದು. ಆದ್ದರಿಂದ printf, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪ್ರಮಾಣಿತ ಔಟ್ ಗೆ ಮುದ್ರಿಸುತ್ತದೆ. ನಾನು ಕೈಯಿಂದ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷದ ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ, ನಂತರ ನಾನು fprintf ಬಳಸಲು ಹೊಂದಿವೆ ಮತ್ತು ನಾನು ಮುದ್ರಿಸಲು ಯಾವ ಸೂಚಿಸಿ. ಬದಲಿಗೆ ನಾನು fprintf stdout ಮಾಡಿದರೆ, ನಂತರ printf ಗೆ ಮೂಲತಃ ಸಮನಾಗಿದೆ. ಆದರೆ fprintf ಸ್ಟ್ಯಾಂಡರ್ಡ್ ದೋಷದ. ಈಗ, ನಾನು txt2 ಈ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ, ಹಲೋ, ರಾಬ್! ಇನ್ನೂ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಮುದ್ರಿತ ಗೆಟ್ಟಿಂಗ್ ಇದು ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿತ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಮತ್ತು ನಾನು ಮಾತ್ರ ಪ್ರಮಾಣಿತ ಔಟ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ನಾನು ರಿಂದ. ನಾನು ಈಗ ಸಾಮಾನ್ಯ ದೋಷ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ವೇಳೆ, ಈಗ ಮುದ್ರಿತ ಆಗಲಿಲ್ಲ, ಮತ್ತು txt2, ಹಲೋ ರಾಬ್ ಏರಲಿದೆ! ಈಗ, ನೀವು ಸಾಮಾನ್ಯ ದೋಷ ನಿಮ್ಮ ನಿಜವಾದ ದೋಷಗಳನ್ನು ಮುದ್ರಿಸಬಹುದು ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ ನಿಮ್ಮ ನಿಯಮಿತ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆದ್ದರಿಂದ, ನೀವು 2 ನಿನ್ನ ಈ ರೀತಿಯ ಚಾಲನೆ. / ಮಾಡಬಹುದು> ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮ, ಸಾಮಾನ್ಯವಾಗಿ ರನ್ ಹೋಗಿ ಹೀಗೆ ಆದರೆ ನೀವು ಪಡೆಯಲು ಯಾವುದೇ ದೋಷ ಸಂದೇಶಗಳನ್ನು, ನಿಮ್ಮ ದೋಷ ಲಾಗ್ ನಂತರ ಪರಿಶೀಲಿಸಬಹುದು ದೋಷಗಳನ್ನು ಆದ್ದರಿಂದ, ಮತ್ತು ನಂತರ ನೋಡಿ ಮತ್ತು ನಿಮ್ಮ ದೋಷಗಳನ್ನು ಕಡತ ಸಂಭವಿಸಿದ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. 

ಪ್ರಶ್ನೆಗಳು? 

ಕಳೆದ ಒಂದು ನೀವು ಒಂದು ಆಜ್ಞೆಯನ್ನು ಮಾನದಂಡದ ಔಟ್ ಮೂಲಕ ನಗರದ ಇದರಲ್ಲಿ ಪೈಪ್, ಆಗಿದೆ ಮತ್ತು ಮುಂದಿನ ಆಜ್ಞೆಯು ಗುಣಮಟ್ಟದ ಮಾಡುವ. ಉದಾಹರಣೆ ಇಲ್ಲಿ ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಿಷಯ ಇದೆ ಕೇವಲ ನಾನು ಅದರ ಚರ್ಚೆಯಂತೆ ಪುಟ್ ಯಾವುದೇ ಪ್ರತಿಧ್ವನಿಸುವಂತೆ ಹೋಗುತ್ತದೆ. ನಾನು ಪುಟ್ ಉಲ್ಲೇಖಗಳನ್ನು ಮಾಡುವುದಿಲ್ಲ. ಪ್ರತಿಧ್ವನಿ blah, blah, blah ಕೇವಲ blah, blah, blah ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ಮೊದಲು, ನಾನು ಹೇಳಿದ ನಾನು ಒಂದು ಸಂದೇಶ ಫೈಲ್ ಆಗಿ ರಾಬ್ ಹಾಕಲು ಹೊಂದಿತ್ತು ನಾನು ಮಾತ್ರ ಸಂದೇಶ ಕಡತಗಳನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಬದಲಿಗೆ ಏಕೆಂದರೆ, / ನಾನು ರಾಬ್ ಪ್ರತಿಧ್ವನಿಸಿದವು ವೇಳೆ ತದನಂತರ ಪೈಪ್ ಇದನ್ನು. / ಹಲೋ, ಸಹ ವಿಷಯ ಅದೇ ರೀತಿಯ ಮಾಡುತ್ತದೆ. ಈ ಆಜ್ಞೆಯ ಉತ್ಪತ್ತಿಯು, ಪ್ರತಿಧ್ವನಿ ರಾಬ್, ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದೆ ಮತ್ತು ಇನ್ಪುಟ್ ಆಗಿ ಬಳಸಿಕೊಂಡು. / ನಿನ್ನ. ನೀವು ಮೊದಲು ಫೈಲ್ ಆಗಿ ಪ್ರತಿಧ್ವನಿ ರಾಬ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಇದು ನಗರದ ತದನಂತರ. / ನಿನ್ನ ಆ ಫೈಲ್ ಆಗಿ ಇನ್ಪುಟ್ ಕೇವಲ outputted ಎಂದು. ಆದರೆ ಚಿತ್ರದ ತಾತ್ಕಾಲಿಕ ಕಡತ ಔಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. 

ಆ ಪ್ರಶ್ನೆಗಳು? 

ಮುಂದಿನ ಪ್ರಶ್ನೆ ಈ ಒಳಗೊಂಡಿರುತ್ತವೆ ಹೋಗುವ ಇದೆ. ಏನು ಪೈಪ್ಲೈನ್ ನೀವು names.txt ಎಂಬ ಕಡತದಲ್ಲಿ ಅನನ್ಯ ಹೆಸರುಗಳು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ಬಳಸಬಹುದಾದ? ನಾವು ಇಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಆಜ್ಞೆಗಳನ್ನು ಅನನ್ಯ, ಆದ್ದರಿಂದ uniq, ತದನಂತರ WC ಇವೆ. ನೀವು, ವಾಸ್ತವವಾಗಿ ಆ ಏನು ನೋಡಲು ಮನುಷ್ಯ uniq ಮಾಡಬಹುದು ಮತ್ತು ಇದು ಕೇವಲ ಇನ್ಪುಟ್ ಪಕ್ಕದ ತಾಳೆಯಾಗುವ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಹೋಗುವುದಿಲ್ಲ. ಮತ್ತು ಮನುಷ್ಯ WC ಹೊಸಸಾಲು, ಪದ, ಮತ್ತು ಪ್ರತಿ ಕಡತಕ್ಕೆ ಬೈಟ್ ಎಣಿಕೆಗಳು ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ಮತ್ತು ನಾವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಕಳೆದ ಒಂದು ತೆರನಾದ ಇದು ಕೇವಲ ಸಂದೇಶ ಕಡತ ಸಾಲುಗಳನ್ನು ವಿಂಗಡಿಸಲು ಹೋಗುತ್ತದೆ. ನಾನು ಕೆಲವು ಸಂದೇಶ ಫೈಲ್, names.txt, ಮಾಡಲು ಮತ್ತು ರಾಬ್, ಟಾಮಿ, ಜೋಸೆಫ್, ಟಾಮಿ, ಜೋಸೆಫ್, ಆರ್ಜೆ, ರಾಬ್, ದ ವೇಳೆ ಏನು ನಾನು ಇಲ್ಲಿ ಮಾಡಲು ಬಯಸುವುದು ಈ ಕಡತದಲ್ಲಿ ಅನನ್ಯ ಹೆಸರುಗಳು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ಆಗಿದೆ. ಆದ್ದರಿಂದ ಉತ್ತರ ಏನಿರಬಹುದು? >> [ವಿದ್ಯಾರ್ಥಿ] 4. >> ಹೌದು. ಇದು ರಾಬ್, ಟಾಮಿ, ಜೋಸೆಫ್ ರಿಂದ 4, ಆರ್ಜೆ ಈ ಕಡತದಲ್ಲಿ ಮಾತ್ರ ಅನನ್ಯ ಹೆಸರುಗಳು. ಮೊದಲ ಹಂತದ, ನಾನು names.txt ಮೇಲೆ ಪದಗಳ ಎಣಿಕೆ ಮಾಡಿದರೆ, ಈ ವಾಸ್ತವವಾಗಿ ನನಗೆ ಎಲ್ಲವನ್ನೂ ಹೇಳುವ ಇದೆ. ಈ ವಾಸ್ತವವಾಗಿ ಮುದ್ರಣ ಹೊಂದಿದೆ - ಹೊಸ ಸಾಲುಗಳನ್ನು, ಪದಗಳು ಮತ್ತು ಬೈಟ್ ಎಣಿಕೆ - ಮ್ಯಾನ್ WC, ನೋಡೋಣ. ನಾನು ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಗಮನ ನೀಡುವ ವೇಳೆ, ನಂತರ ನಾನು WC-L names.txt ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ಹಂತ 1. Names.txt ಕೇವಲ ಎಲ್ಲಾ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ ಆದರೆ ನಾನು, WC-L names.txt ಬಯಸುವುದಿಲ್ಲ ಮತ್ತು ನಾನು ಯಾವುದೇ ಅನನ್ಯ ಬಿಡಿಗಳ ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಯಸುವ. ನಾನು uniq names.txt ಮಾಡಲು ಆದ್ದರಿಂದ, ಆ ಸಾಕಷ್ಟು ನಾನು ಯಾವ ನನಗೆ ನೀಡುವುದಿಲ್ಲ ನಕಲು ಹೆಸರುಗಳು ಇನ್ನೂ ಕಾರಣ. ಏಕೆ ಎಂದು? ಏಕೆ uniq ನಾನು ಬಯಸುವ ಏನು ಇಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] ನಕಲುಗಳನ್ನು ಅಲ್ಲ [ಕೇಳಿಸುವುದಿಲ್ಲ] >> ಹೌದು. Uniq ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೆನಪಿಡಿ ಫಿಲ್ಟರ್ ಪಕ್ಕದ ಹೊಂದಾಣಿಕೆಗೆ ಸಾಲುಗಳನ್ನು ಹೇಳುತ್ತಾರೆ. ಅವರು ಪಕ್ಕದ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದಿಲ್ಲ. ನಾನು ಅವುಗಳನ್ನು ವಿಂಗಡಿಸಲು ವೇಳೆ, ರೀತಿಯ names.txt ಒಟ್ಟಿಗೆ ಎಲ್ಲಾ ನಕಲಿ ಸಾಲುಗಳನ್ನು ಹಾಕಲು ಹೋಗುತ್ತದೆ. ಈಗ ರೀತಿಯ names.txt ಎಂಬುದು. Uniq | ನಾನು ಇದು uniq, ಇನ್ಪುಟ್ ಎಂದು ಬಳಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. ನನಗೆ ಜೋಸೆಫ್, ಆರ್ಜೆ, ರಾಬ್, ಟಾಮಿ, ನೀಡುತ್ತದೆ ಮತ್ತು ನಾನು, WC-L ಇನ್ಪುಟ್ ಎಂದು ಬಳಸಲು ಬಯಸುವ ಇದು ನನ್ನ 4 ನೀಡಲು ಹೋಗುತ್ತದೆ. ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಲೈಕ್, ನೀವು ಏನು ಪೈಪ್ಲೈನ್ ಬಳಸಬಹುದಿತ್ತು? ನೀವು ಆಜ್ಞೆಗಳ ಒಂದು ಸರಣಿಯನ್ನು ಬಳಸಿ ವಿಷಯಗಳನ್ನು ಬಹಳಷ್ಟು ಮಾಡಬಹುದು ನೀವು ಮುಂದಿನ ಆದೇಶಕ್ಕೆ ಇನ್ಪುಟ್ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಉತ್ಪತ್ತಿಯನ್ನು ಬಳಸುವ. ನೀವು ಬಹಳಷ್ಟು ಸಂಗತಿಗಳನ್ನು, ಬುದ್ಧಿವಂತ ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಮಾಡಬಹುದು. 

ಪ್ರಶ್ನೆಗಳು? ಸರಿ. ಪೈಪ್ ಮತ್ತು ಮರುನಿರ್ದೇಶನವಿಲ್ಲದ್ದಕ್ಕೆ ಆ ಸ್. 

ಈಗ ನಾವು ನಿಜವಾದ ಸಂಗತಿಗಳನ್ನು, ಕೋಡಿಂಗ್ ವಿಷಯ ಹೋಗುತ್ತಾರೆ. ಈ PDF ಒಳಗೆ, ನೀವು, ಈ ಆಜ್ಞೆಯನ್ನು ನೋಡುತ್ತಾರೆ ಮತ್ತು ನಿಮ್ಮ ಉಪಕರಣಗಳಲ್ಲಿರುವ ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಬಯಸುವಿರಿ. wget ಮೂಲಭೂತವಾಗಿ, ಕೇವಲ ಇಂಟರ್ನೆಟ್ ಏನನ್ನೋ ಪಡೆಯಲು ಆಜ್ಞೆಯ ಆದ್ದರಿಂದ wget ಮತ್ತು ಈ URL. ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ಈ URL ಗೆ ಹೋದರೆ, ಆ ಕಡತವನ್ನು ಡೌನ್ಲೋಡ್ ಎಂದು. ನಾನು ಅದರ ಮೇಲೆ ಕ್ಲಿಕ್, ಆದ್ದರಿಂದ ನನಗೆ ಕಡತವನ್ನು ಡೌನ್ಲೋಡ್. ಆದರೆ ಟರ್ಮಿನಲ್ ಒಳಗೆ ಆ ವಿಷಯ wget ಬರೆಯಲು ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅದನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಲು ಹೋಗುತ್ತದೆ. ನಾನು section5.zip ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು section5.zip ಅನ್ಜಿಪ್ ಬಯಸುವಿರಿ ಇದು ನೀವು section5 ಎಂಬ ಫೋಲ್ಡರ್ ನೀಡಲು ಹೋಗುತ್ತದೆ ನಾವು ಒಳಗೆ ಇಂದು ಬಳಸುತ್ತಿರುವ ಎಂದು ನೀನು ಕಡತಗಳನ್ನು ಎಲ್ಲಾ ಮಾಡಲಿಕ್ಕೆ ಇದು. ಈ ಕಾರ್ಯಕ್ರಮಗಳು 'ಕಡತದ ಹೆಸರುಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಅವರು ಸ್ವಲ್ಪ ದೋಷಯುಕ್ತ ಆರ್, ನಿಮ್ಮ ಮಿಷನ್ GDB ಅನ್ನು ಏಕೆ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಹೊಂದಿದೆ. ಅವುಗಳನ್ನು ಎಲ್ಲರಿಗೂ ಡೌನ್ಲೋಡ್ / ಅವುಗಳನ್ನು ಡೌನ್ಲೋಡ್ ಹೇಗೆ ತಿಳಿದಿರುವ ಹೊಂದಿದೆ ತಮ್ಮ APPLIANCE ಗೆ? ಸರಿ. 

./buggy1 ರನ್ನಿಂಗ್, ಇದು, ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ (ಕೋರ್ ಸುರಿಸಿದ) ಹೇಳುವುದಿಲ್ಲ ಇದು ನೀವು ಒಂದು segfault ಪಡೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ಇದು ಒಂದು ಕೆಟ್ಟ ವಿಷಯ. ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು segfault ಸಿಗುತ್ತವೆ? [ವಿದ್ಯಾರ್ಥಿ] ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ Dereferencing. >> ಹೌದು. ಆದ್ದರಿಂದ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ. ನೀವು segfault ಪಡೆಯಲು ನೀನು ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ Dereferencing. ನೀವು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ಏನನ್ನು ಸಾಧನವಾಗಿ segfault ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು. ಆದ್ದರಿಂದ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing, ವಿಳಾಸಕ್ಕೆ 0 ಸ್ಪರ್ಶಿಸುವಂತಹದ್ದನ್ನು ಮತ್ತು ಮೂಲತಃ, ಎಲ್ಲಾ ಕಂಪ್ಯೂಟರ್ಗಳು ದಿನಗಳಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ 0 ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿ ಹೇಳುತ್ತಾರೆ. ಒಂದು segfault ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಫಲಿತಾಂಶಗಳು dereferencing ಏಕೆ ಆ ನ. ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಗೆ ಉಂಟಾಗುತ್ತದೆ, ಅದು, ಒಂದು ಕಸದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ ಆದ್ದರಿಂದ ನೀವು dereference ಪ್ರಯತ್ನಿಸಿ ಇದು, ಬಹುಶಃ ನಿಮ್ಮ ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು ಎಂದು ಎಲ್ಲಿಯೂ ಮಧ್ಯದಲ್ಲಿ ಇಲ್ಲಿದೆ. ನಿಮಗೆ ಅದೃಷ್ಟ ಮತ್ತು ಕಸ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಸಂಭವಿಸಿದಾಗ ಸ್ಟ್ಯಾಕ್ ಅಥವಾ ವಿಚಾರದ ಬಗ್ಗೆ ಎಲ್ಲೋ ತೋರಿಸಲು ಸಂಭವಿಸಿದ, ನಂತರ ನೀವು ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಮಾಡಿರುವ ನೀವು dereference, ಏನೂ ತಪ್ಪು ಹೋಗುತ್ತದೆ. ಇದು ತೋರುತ್ತಿರುವಂತೆ ಸರಿ ಆದರೆ, ಎಲ್ಲೋ ಸ್ಟ್ಯಾಕ್ ಮತ್ತು ಹೀಪ್ ನಡುವೆ, ಸೇ ಅಥವಾ ಅದು ಕೇವಲ ಎಲ್ಲೋ, ಇನ್ನೂ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಬಳಸಲಾಗಿಲ್ಲ ಎಂದು ಸೂಚಿಸುವ ವಿಶೇಷವೇನು ನಂತರ ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು ಮತ್ತು ನೀವು segfault. ನೀವು ಒಂದು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ಬರೆಯಲು ಮತ್ತು ಅದನ್ನು ಹಲವಾರು ಬಾರಿ recurses ಮಾಡಿದಾಗ ಮತ್ತು ನಿಮ್ಮ ಸ್ಟಾಕ್ ವಿಷಯಗಳನ್ನು ಕೂಡ ದೊಡ್ಡ ಮತ್ತು ಸ್ಟಾಕ್ ಘರ್ಷಿಸಿದಾಗ ಬೆಳೆಯುತ್ತದೆ ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಅದು ಘರ್ಷಿಸಲು ಮಾಡಬಾರದು ಎಂದು, ನೀವು ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು, ಆದ್ದರಿಂದ ನೀವು segfault. ಎಂದು ಯಾವ ಒಂದು segfault ಆಗಿದೆ. 

ಅದೇ ಕಾರಣದಿಂದ ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿದ್ದರೆ - ಹಿಂದಿನ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಮರಳಲು ಅವಕಾಶ. ರಲ್ಲಿ hello.c-I'm ಕೇವಲ ಯಾವುದೋ ಮಾಡಲು ಹೋಗಿ. ಚಾರ್ * ರು = "ಹಲೋ ವರ್ಲ್ಡ್"; ನಾನು ಬಳಸಿದರೆ * ರು = ಏನೋ ಅಥವಾ ರು [0] = 'ಎಕ್ಸ್'; ಆದ್ದರಿಂದ ನಿನ್ನ ಮಾಡಿ. / ನಿನ್ನ, ಏಕೆ ಎಂದು segfault ನೀಡಲಿಲ್ಲ? ಏಕೆ ಈ segfault ನೀಡಲಿಲ್ಲ? ನೀವು ಏನಾಗುವುದು ನಿರೀಕ್ಷಿಸಬಹುದು? ನಾನು printf ಮಾಡಿದರೆ ("% s \ n" ರು); ಏನು ಮುದ್ರಿತವಾಗಬಹುದು ನಿರೀಕ್ಷಿಸಬಹುದು? [ವಿದ್ಯಾರ್ಥಿ] ಎಕ್ಸ್ ನಿನ್ನ. >> ಹೌದು. ಸಮಸ್ಯೆ, ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮಾಡಿದಾಗ ಘೋಷಿಸುವಂತೆ ಆಗಿದೆ ರು, ಸ್ಟಾಕ್ ಮೇಲೆ ಹೋಗುತ್ತಿದ್ದೇವೆ ಎಂದು ಸೂಚಿಯಾಗಿದೆ ಮತ್ತು ರು ತೋರುತ್ತಿರುವಂತೆ ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ಒಳಗೊಂಡಿರುವ ಇದು ಈ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ. ಕೇವಲ ಹೆಸರು, ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ಮಾಡಲು, ನೀವು ಕಲ್ಪನೆಯನ್ನು ಪಡೆಯಬೇಕು ನೀವು ಓದಲು ಮಾತ್ರ ಸ್ಮರಣೆ ರಲ್ಲಿ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ನೀವು ಮೆಮೊರಿಯಲ್ಲಿ ಮಾಡಬಾರದು ಏನೋ ಮಾಡುತ್ತಿರುವುದು ಮತ್ತು ನೀವು segfault. ಈ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಗಳು ಮತ್ತು ಚಾರ್ ರು [] ನಡುವಿನ ದೊಡ್ಡ ವ್ಯತ್ಯಾಸ. ಆದ್ದರಿಂದ ಚಾರ್ ರು [], ಈಗ ಈ ಸ್ಟ್ರಿಂಗ್ ಸ್ಟಾಕ್ ಒಳಪಡಿಸಿದರು ಹೋಗುವ ಇದೆ, ಮತ್ತು ಸ್ಟಾಕ್ ಈ ನಿಖರವಾಗಿ ಉತ್ತಮ ಕೆಲಸ ಮಾಡಬೇಕು, ಅಂದರೆ, ಓದಲು ಮಾತ್ರ ಅಲ್ಲ. ಮತ್ತು ಅದು. ನೆನಪಿಡಿ ನಾನು ಚಾರ್ ಮಾಡಿದಾಗ * ರು = "ಹಲೋ ವರ್ಲ್ಡ್", ರು ಸ್ವತಃ ಸ್ಟಾಕ್ ಮೇಲೆ ಆದರೆ ರು ಎಲ್ಲೋ ಬೇರೆ ಮಾಡಲು ಅಂಕಗಳನ್ನು, ಮತ್ತು ಬೇರೆ ಎಲ್ಲಾದರೂ ಓದಲು ಮಾತ್ರ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ. ಆದರೆ ಚಾರ್ ರು [] ಕೇವಲ ಸ್ಟಾಕ್ ಮೇಲೆ ಸಂಗತಿಯಾಗಿದೆ. ಆದ್ದರಿಂದ ಒಂದು segfault ನಡೆಯುತ್ತಿದೆ ಇನ್ನೊಂದು ಉದಾಹರಣೆ. 

ನಾವು ./buggy1 ಒಂದು segfault ಕಾರಣವಾಗಿದ್ದ ಕಂಡಿತು. ಸಿದ್ಧಾಂತದಲ್ಲಿ, ನೀವು ತಕ್ಷಣ buggy1.c ನೋಡಲು ಮಾಡಬಾರದು. ಬದಲಾಗಿ, ನಾವು GDB ಮೂಲಕ ನೋಡಲು ಮಾಡುತ್ತೇವೆ. ನೀವು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ (ಕೋರ್ ಸುರಿಸಿದ) ಪಡೆದಾಗ ಗಮನಿಸಿ, ನೀವು ಇಲ್ಲಿ ಎಂದು ಕೋರ್ ಈ ಕಡತವನ್ನು ಪಡೆಯಲು. ನಾವು ls-l, ನಾವು ಆ ಕೋರ್ ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ದೊಡ್ಡ ಫೈಲ್ ನೋಡುತ್ತಾರೆ. ಈ ಕಡತದ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆ, ಆದ್ದರಿಂದ 250-ಏನೋ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಕಾಣುತ್ತಿಲ್ಲ. ಈ ಕಾರಣ ಕೋರ್ ಡಂಪ್ ನಿಜವಾಗಿ ಏನು ಎಂದು ಯಾವಾಗ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ, ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮೆಮೊರಿ ರಾಜ್ಯ ಕೇವಲ ನಕಲು ಮತ್ತು ಈ ಫೈಲ್ ಅಂಟಿಸಲಾಗಿದೆ ಮುಟ್ಟುತ್ತದೆ. ಆ ಫೈಲ್ ಆಗಿ ತೊರೆಯುತ್ತಾನೆ. ಈ ಪ್ರೋಗ್ರಾಂ ಸಹಾ ತನ್ನನ್ನು ನಡೆಸುತ್ತಿರುವ, ಸುಮಾರು 250 ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಒಂದು ಸ್ಮರಣೆ ಬಳಕೆಯನ್ನು ಹೊಂದಿವೆ ಏನಾಯಿತು ಆದ್ದರಿಂದ ಈ ಫೈಲ್ ಸುರಿಯಲ್ಪಟ್ಡು ಪಡೆದುಕೊಂಡಿದೆ ಇಲ್ಲಿದೆ. ನಾವು GDB buggy1 ಕೋರ್ ಹೋದರೆ ಈಗ ಆ ಕಡತವನ್ನು ನೋಡಬಹುದು. ನಾವು GDB buggy1 ಮಾಡಬಹುದು, ಮತ್ತು ಕೇವಲ, ನಿಯಮಿತವಾಗಿ GDB ಅಪ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಇದರ ಇನ್ಪುಟ್ ಫೈಲ್ buggy1 ಬಳಸಿ. ನೀವು GDB buggy1 ಕೋರ್ ಹಾಗೆ ಆದರೆ, ಅದು ನಿರ್ದಿಷ್ಟವಾಗಿ GDB ಆರಂಭಿಸುವ ವಿಶೇಷವೇನು ಆ ಕೋರ್ ಕಡತವನ್ನು ನೋಡಿ. ಮತ್ತು ನೀವು buggy1 ಸಾಧನವಾಗಿ GDB ಹೇಳುವ ಆ ಕೋರ್ ಕಡತ buggy1 ಪ್ರೋಗ್ರಾಂ ಬರುತ್ತದೆ ತಿಳಿದಿದೆ. ಆದ್ದರಿಂದ GDB buggy1 ಕೋರ್ ತಕ್ಷಣ ನಮಗೆ ತರಲಿದೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಅಂತ್ಯಗೊಳಿಸಲು ಸಂಭವಿಸಿದ ಅಲ್ಲಿ ಗೆ. ನಾವು ಪ್ರೋಗ್ರಾಂ ಸಂಕೇತವನ್ನು 11, ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಜೊತೆ ರದ್ದು ಇಲ್ಲಿ ನೋಡಿ. ಪ್ರಾಯಶಃ ನಾವು ಬಹಳ ಉಪಯುಕ್ತ ಇರುವಂತಹ ಅಸೆಂಬ್ಲಿ, ಒಂದು ಸಾಲನ್ನು ನೋಡಿ ಸಂಭವಿಸಬಹುದು. ನೀವು BT ಅಥವಾ backtrace ಟೈಪ್ ಆದರೆ, ಆ ಕಾರ್ಯ ಎಂದು ವಿಶೇಷವೇನು ಎಂದು ನಮ್ಮ ಪ್ರಸ್ತುತ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುತ್ತದೆ. ಆದ್ದರಿಂದ backtrace. ನಾವು ಕೇವಲ ಎರಡು ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕಾಣುತ್ತದೆ. ಮೊದಲ, ನಮ್ಮ ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಆಗಿದೆ ಮತ್ತು ಎರಡನೇ, ನಾವು ಎಂದು ಹುಟ್ಟಿಕೊಂಡ ಈ ಕ್ರಿಯೆಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಆಗಿದೆ ನಾವು ಮಾತ್ರ ವಿಧಾನಸಭೆಯಲ್ಲಿ ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ ನಂತಹ ಇದು ಕಾಣುತ್ತದೆ. ಆದ್ದರಿಂದ ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ಮತ್ತೆ ಹೋಗಿ ಅವಕಾಶ ಮತ್ತು ನಾವು ಫ್ರೇಮ್ 1 ಮಾಡಬಹುದು ಹಾಗೆ, ಮತ್ತು ನಾವು ಕೂಡ ಡೌನ್ ಮಾಡಬಹುದು ಯೋಚಿಸುವುದು, ಅಪ್ ಅಥವಾ - ಆದರೆ ಬಹುತೇಕ ಕೆಳಗೆ ಮಾಡಲೇ ಇಲ್ಲ. ಹೌದು. ಮೇಲೆ ಮತ್ತು ಕೆಳಗೆ. ಅಪ್ ನೀವು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ನೀವು ಕೆಳಗೆ ತರುತ್ತದೆ ಕೆಳಗೆ, ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ತೆರೆದಿಡುತ್ತದೆ. ನಾನು ಬಳಸಲು ಎಂದಿಗೂ ಪ್ರವೃತ್ತಿ. ನಾನು ನಿರ್ದಿಷ್ಟವಾಗಿ 1 ಲೇಬಲ್ ಫ್ರೇಮ್ ಹೋಗಿ ಇದು ಫ್ರೇಮ್ 1, ಸೇ. ಫ್ರೇಮ್ 1, ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ನಮ್ಮನ್ನು ತರಲಿದೆ ಮತ್ತು ಇಲ್ಲಿಯೇ ನಾವು ಎಂದು ಸಂಭವಿಸಿ ಕೋಡ್ ಸಾಲನ್ನು ಹೇಳುತ್ತಾಳೆ. ನಾವು ಕೋಡ್ ಒಂದೆರಡು ಹೆಚ್ಚು ಸಾಲುಗಳನ್ನು ಬಯಸಿದರೆ, ನಾವು, ಪಟ್ಟಿ ಹೇಳಬಹುದು ಮತ್ತು ನಮಗೆ ಸುತ್ತ ಕೋಡ್ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ನೀಡಲು ವಿಶೇಷವೇನು. ನಾವು segfaulted ಲೈನ್ 6 ಆಗಿತ್ತು: ವೇಳೆ (strcmp ("CS50 ಕಲ್ಲುಗಳು", argv [1]) == 0). ಅದು ಇನ್ನೂ ಸ್ಪಷ್ಟ ಇದ್ದರೆ, ನೀವು ಅದನ್ನು segfaulted ಏಕೆ ಆಲೋಚನೆ ಇಲ್ಲಿ ನೇರವಾಗಿ ಅದನ್ನು ಪಡೆಯಬಹುದು. ಆದರೆ ನಾವು ಒಂದು ಹೆಜ್ಜೆ ಮುಂದೆ ಹೋಗಿ ತೆಗೆದುಕೊಂಡು ಹೇಳುತ್ತಾರೆ, "ವೈ argv [1] segfault ಎಂದು?" ಮಾಡಬಹುದು ಲೆಟ್ಸ್ ಮುದ್ರಣ argv [1], ಮತ್ತು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಇದು ಅದು 0x0, ತೋರುತ್ತಿದೆ. ನಾವು segfault ಇನ್ನು ಎಷ್ಟು CS50 ಬಂಡೆಗಳು ಮತ್ತು ಶೂನ್ಯ strcmping, ಮತ್ತು ನೀವು. ಮತ್ತು ಏಕೆ ಹೊಂದಿದೆ argv [1] ಶೂನ್ಯ? [ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನೀಡದಿರುವುದರಿಂದ. ಹೌದು. ನಾವು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನೀಡಿಲ್ಲ. ಆದ್ದರಿಂದ ./buggy1 ಮಾತ್ರ argv [0] ./buggy1 ಎಂದು ಮಾಡಲಿಕ್ಕೆ ಇದೆ. ಇದು argv [1] ಮಾಡಲಿಕ್ಕೆ ಅಲ್ಲ, segfault ಇನ್ನು ಎಷ್ಟು. ಬದಲಿಗೆ, ನಾನು CS50 ಹಾಗೆ, ಆದರೆ, ಇದು ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ ಹೇಳಲು ವಿಶೇಷವೇನು ಅದು ಏನು ಮಾಡಬೇಕೋ ಎಂಬುದನ್ನು ಏಕೆಂದರೆ. Buggy1.c ನೋಡುವ, ಅದನ್ನು ಮುದ್ರಿಸಲು ಮಾಡಬೇಕೋ "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" - Argv [1] "CS50 ಕಲ್ಲುಗಳು", ಬೇರೆ, "ನೀವು ಒಂದು ಡಿ ಪಡೆಯಿರಿ" ಇದ್ದಲ್ಲಿ "ನೀವು ಒಂದು ಪಡೆಯಿರಿ!" ನಾವು ಒಂದು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ನಾವು ನಿಜವಾದ ಎಂದು ಹೋಲಿಸಿ ಈ ಅಗತ್ಯವಿದೆ ಇದು 0 ಗೆ ಹೋಲಿಸುವ ಅರ್ಥ. ಆದ್ದರಿಂದ argv [1] "CS50 ಕಲ್ಲುಗಳು" ಅಗತ್ಯವಿದೆ. ನೀವು ಕಮಾಂಡ್ ಸಾಲಿನಲ್ಲಿ ಮಾಡಲು ಬಯಸಿದರೆ, ನೀವು ಜಾಗವನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳಲು \ ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ CS50 \ ಬಂಡೆಗಳು ಮತ್ತು ನೀವು ಒಂದು ಪಡೆಯಿರಿ! ನೀವು backslash ಮಾಡದಿದ್ದರೆ, ಏಕೆ ಈ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಎರಡು ವಿವಿಧ ವಾದಗಳು ಇಲ್ಲಿದೆ. >> ಹೌದು. Argv [1] CS50 ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು argv [2] ಕಲ್ಲುಗಳು ಎಂದು ಹೋಗುತ್ತದೆ. ಸರಿ. 

ಈಗ ./buggy2 ಮತ್ತೆ segfault ಹೋಗುವ ಇದೆ. ಬದಲಿಗೆ ಅದರ ಕೋರ್ ಕಡತ ಅದನ್ನು ತೆರೆಯುವ ನ, ನಾವು ನೇರವಾಗಿ buggy2 ತೆರೆಯುತ್ತದೆ ವಿಲ್ GDB buggy2 ಆದ್ದರಿಂದ. ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವೇಳೆ ಈಗ, ಅದು, ಪ್ರೋಗ್ರಾಂ ಸಂಕೇತವನ್ನು SIGSEGV ಪಡೆದರು ಹೇಳಲು ವಿಶೇಷವೇನು ಇದು ಸಿಗ್ನಲ್ segfault ಇದು ಸಂಭವಿಸಬಹುದು ಏನಾಯಿತು ಅಲ್ಲಿ ಇದು. ನಮ್ಮ backtrace ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನಾವು ಕಾರ್ಯ oh_no ಎಂದು ನೋಡಿ ಇದು ಕಾರ್ಯ binky ಘೋಶಿಸಿದರು ಕಾರ್ಯನಿರ್ವಹಿಸುವ dinky, ಘೋಶಿಸಿದರು ಮುಖ್ಯ ಘೋಶಿಸಿದರು. ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ನೋಡಬಹುದು. dinky ಮತ್ತು binky ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಆಗಿತ್ತು. ನಾವು ಕಾರ್ಯ oh_no ಪಟ್ಟಿ, ನಾವು oh_no ಕೇವಲ ಚಾರ್ ** ರು = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುವುದರಿಂದ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ನೋಡಿ; * ರು = "ಬೂಮ್"; ಏಕೆ ವಿಫಲರಾಗಿದ್ದಾರೆ? [ವಿದ್ಯಾರ್ಥಿ] ನೀವು dereference ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಸಾಧ್ಯವಿಲ್ಲ? >> ಹೌದು. ಒಂದು ಚಾರ್ ** ಎಂದು ಉಂಟಾದರೆ ಇದು ಕೇವಲ, ಲೆಕ್ಕಿಸದೆ, ರು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ ಹೇಳುತ್ತಾರೆ ನೀವು ವಿವರಿಸುವುದಕ್ಕೆ ಹೇಗೆ ಅವಲಂಬಿಸಿ, ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ಪಾಯಿಂಟರ್ ಸಾಧ್ಯವಿದೆ, ಅಥವಾ ತಂತಿಗಳ ಒಂದು ಸರಣಿ. ಅದು ರು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ * ಗಳು, ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಇದೆ ಆದ್ದರಿಂದ ಈ ಕುಸಿತಕ್ಕೆ ಹೋಗುತ್ತದೆ. ನೀವು ಬಹುಶಃ segfault ಮಾಡಬಹುದು ತ್ವರಿತ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದು. ಇದು ಕೇವಲ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಘೋಷಿಸುವ ಮತ್ತು ತಕ್ಷಣ segfaulting ನ. ಆ oh_no ಮಾಡುತ್ತಿರುವ ಇಲ್ಲಿದೆ. ನಾವು ಒಂದು ಫ್ರೇಮ್ ಹೋಗುತ್ತಾರೆ, ಆಗ ನಾವು oh_no ಎಂಬ ಕ್ರಿಯೆಯ ಬರಲು ನೀನು. ನಾನು ಕೆಳಗೆ ಹಾಗೆ ಮಾಡಬೇಕು. ನೀವು ಒಂದು ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಇದ್ದರೆ ನೀವು, ಮತ್ತೆ ನಮೂದಿಸಿ ಹಿಟ್ ಕೇವಲ ನೀವು ನಡೆದ ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೀರಿ. ನಾವು ಫ್ರೇಮ್ 1 ಇವೆ. ಈ ಫ್ರೇಮ್ ಪಟ್ಟಿ, ನಾವು ನಮ್ಮ ಕಾರ್ಯ ನೋಡಿ. ನೀವು ಮತ್ತೆ ಪಟ್ಟಿಯಲ್ಲಿ ಹಿಟ್ ಮಾಡಬಹುದು, ಅಥವಾ ನೀವು ಪಟ್ಟಿಯಲ್ಲಿ 20 ಮಾಡಬಹುದು ಮತ್ತು ಅದು ಹೆಚ್ಚು ಪಟ್ಟಿ ಕಾಣಿಸುತ್ತದೆ. ಕಾರ್ಯ dinky ನಾನು 1 ವೇಳೆ, ನಂತರ, oh_no ಕಾರ್ಯ ಹೋಗಿ ಹೇಳುತ್ತಾರೆ ಬೇರೆ ತೆಳ್ಳನೆಯ ಕಾರ್ಯ ಹೋಗಿ. ಮತ್ತು ನಾವು ಇಲ್ಲಿ ನೋಡಲು ಸಂಭವಿಸಿ ಏಕೆಂದರೆ ನಾನು 1 ತಿಳಿಯುವುದಕ್ಕಿಂತ ಆ dinky ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಕರೆಯಲಾಯಿತು. ಅಥವಾ ನೀವು ಕೇವಲ ನಾನು ಮುದ್ರಿಸಲು ಮಾಡಬಹುದಾದ ಮತ್ತು ನಾನು 1 ಹೇಳುವುದಿಲ್ಲ. ನಾವು dinky ಪ್ರಸ್ತುತ, ಮತ್ತು ಮತ್ತೊಂದು ಫ್ರೇಮ್ ಹೋಗುತ್ತಾರೆ ವೇಳೆ, ನಾವು binky ಅಂತ್ಯಗೊಂಡರೂ ಮಾಡುತ್ತೇವೆ ತಿಳಿದಿದೆ. ಅಪ್. ಈಗ ನಾವು binky ಮಾಡುತ್ತೇವೆ. ಅರ್ಧ ನನ್ನನ್ನು ಕತ್ತರಿಸಿ ಮೊದಲು ಪಟ್ಟಿ - - ಈ ಕಾರ್ಯ ಪಟ್ಟಿ ಇ 0 ವೇಳೆ ಇದು ಪ್ರಾರಂಭವಾಯಿತು, ನಂತರ ನಾವು oh_no ಕರೆಯಲು ನೀನು, ಬೇರೆ dinky ಕರೆ. ನಾವು ನಾನು 1 ಗೊತ್ತಿರಲಿಲ್ಲ, ಆದ್ದರಿಂದ dinky ಕರೆಯಲಾಗುತ್ತದೆ. ಮತ್ತು ಈಗ ನಾವು ಮುಖ್ಯ ಮತ್ತೆ ಆರ್, ಮತ್ತು ಮುಖ್ಯ ಕೇವಲ ಇಂಟ್ I = RAND ()% 3 ಎಂದು ಹೋಗುತ್ತದೆ; ಕೇವಲ ನೀವು ಎರಡೂ 0, 1, ಅಥವಾ 2 ಎಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ನೀಡಲು ಹೋಗುತ್ತದೆ. ಆ ಸಂಖ್ಯೆಯ binky ಕರೆಯಲು ವಿಶೇಷವೇನು, ಮತ್ತು 0 ಹಿಂತಿರುಗುವುದು. ಈ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ಕೇವಲ, ತಕ್ಷಣವೇ ಅದನ್ನು ಓಡಿಸದೇ ಕೈಯಾರೆ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ವಾಕಿಂಗ್ ನೀವು ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಸೆಟ್ ಎಂದು, ಇದು ನಾವು ಪ್ರೋಗ್ರಾಂ ಆ ಅರ್ಥ ಇದು ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಬಡಿಯುವ ವರೆಗು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹಾದು ಹೋಗುತ್ತದೆ. ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಅದು ರನ್ ಮತ್ತು ನಂತರ ಮುಖ್ಯ ಕಾರ್ಯ ಹಿಟ್ ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತವೆ. ಈಗ ನಾವು ಮುಖ್ಯ ಒಳಗೆ ಇದ್ದೇವೆ ಹಂತದ ಅಥವಾ ಮುಂದಿನ ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ನಮಗೆ ತರಲಿದೆ. ನೀವು ಹಂತದ ಅಥವಾ ಮುಂದಿನ ಮಾಡಬಹುದು. ಮುಂದಿನ ಹೊಡೆಯುವುದು, ಈಗ RAND ()% 3, ಆದ್ದರಿಂದ ನಾವು ನಾನು ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಬಹುದು, ತಿಳಿಸಲಾಗಿತ್ತು ಮತ್ತು ನಾನು 1 ಹೇಳುವುದಿಲ್ಲ. ಈಗ ನಾವು ಮುಂದಿನ ಅಥವಾ ಹಂತದ ಬಳಸಲು ಎಂದು ವಿಷಯವಾಗಿದೆ. ನಾನು ಹಿಂದಿನ ಒಂದು ಪ್ರಾಮುಖ್ಯ ಊಹಿಸುತ್ತಾರೆ, ಆದರೆ ಮುಂದಿನ ಬಳಸಲು ಬಯಸುತ್ತೇನೆ. ನಾವು ಹಂತದ ಬಳಸಿದರೆ, ನಾವು ಕಾರ್ಯ ಒಳಗೆ ಹೆಜ್ಜೆಯಿಟ್ಟು, ಇದು ನಿಜವಾದ ವಸ್ತು ನೋಡು ಅರ್ಥ ಆ binky ಒಳಗೆ ನಡೆಯುತ್ತಿದೆ. ನಾವು ಮುಂದಿನ ಬಳಸಿದರೆ, ನಂತರ ಇದು ಕ್ರಿಯೆಯ ಮೇಲೆ ಹೋಗಿ ಅರ್ಥ ಮತ್ತು ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ ಕೋಡ್ ಮುಂದಿನ ಲೈನ್ ಹೋಗಿ. ಇಲ್ಲಿಯೇ ಈ ಸಾಲಿನಲ್ಲಿ, ನಾನು RAND ()% 3 ಹೇಳಿದರು ಅಲ್ಲಿ ಆಗಿತ್ತು; ನಾನು ಹಂತದ ಆದರೆ ಅದನ್ನು RAND ಅನುಷ್ಠಾನಕ್ಕೆ ಹೋಗಿ ಎಂದು ಮತ್ತು ಅಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು, ಮತ್ತು ನಾನು RAND ಕ್ರಿಯೆಯ ಮೂಲಕ ಹೆಜ್ಜೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಆದರೆ ನಾನು RAND ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಹೆದರುವುದಿಲ್ಲ. ನಾನು ಮುಖ್ಯ ಸಂಕೇತವನ್ನು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು ಬಯಸುವ, ಆದ್ದರಿಂದ ನಾನು ಮುಂದಿನ ಬಳಸಿ. ಆದರೆ ಈಗ ನಾನು binky ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಕಾಳಜಿ ಮಾಡಬೇಕು, ಆದ್ದರಿಂದ ನಾನು ಒಳಗೆ ಹೆಜ್ಜೆಯಿಟ್ಟು ಬಯಸುವ. ಈಗ ನಾನು binky ರಲ್ಲಿ ಆಮ್. ಕೋಡ್ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ (ನಾನು == 0), ನಾನು ಒಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಂಡು ಹೇಳಲು ಹೋಗುತ್ತದೆ, ನಾವು dinky ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ನೋಡಿ. ನಾವು ಪಟ್ಟಿ ವಿಷಯಗಳು, ನಾವು ಪರಿಶೀಲಿಸಿದ ಎಂದು ನೋಡಿ ನಾನು = 0 ಆಗಿದೆ. , ಇ 0 ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಬೇರೆ ಸ್ಥಿತಿಯನ್ನು ಹೋದರು ಇದು dinky (I) ಕರೆಯಲು ಹೋಗುತ್ತದೆ. ನೀವು ತಪ್ಪಾಗಿ ಇರಬಹುದು. ನೀವು ನೇರವಾಗಿ ಈ ಸಾಲುಗಳನ್ನು ನೋಡಿದರೆ, ನೀವು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು, (ನಾನು == 0) ವೇಳೆ ಸರಿ, ನಾನು ಒಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಂಡಿತು ಮತ್ತು ಈಗ ನಾನು dinky (I) ನಲ್ಲಿ ನಾನು ನೀವು ನಾನು = 0 ಅಥವಾ ಏನಾದರೂ ಅರ್ಥ ಮಾಡಬೇಕು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು. ಇಲ್ಲ, ಕೇವಲ ಅದು ಲೈನ್ dinky (I) ನೇರವಾಗಿ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಮಾಡಬಹುದು ತಿಳಿದಿದೆ ಎಂದರ್ಥ. ಇ 0 ಏಕೆಂದರೆ, ಮುಂದಿನ ಹಂತದಲ್ಲಿ ಬೇರೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ. ಎಲ್ಸ್ ಇದು ನಿಲ್ಲಿಸಿ ಇನ್ನು ಒಂದು ಸಾಲನ್ನು ಅಲ್ಲ. ಅದು ನಿಜವಾಗಿ ಇದು (ನಾನು) dinky ಹೊಂದಿದೆ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು ವಿಶೇಷವೇನು. Dinky (i) ರ ಒಳಗೆ ಕಾಲಿಟ್ಟರೆ, ನಾವು (ನಾನು == 1) ವೇಳೆ. ನಾವು ಹೆಜ್ಜೆ, ನಾವು oh_no ಕೊನೆಗೊಳ್ಳಲು ನೀನು ತಿಳಿಯಲು, I = 1 ಗೊತ್ತು ನಾನು = 1 ನೀವು ಹೆಜ್ಜೆ ಇದು ಫಂಕ್ಷನ್ oh_no, ಕಾಲ್ಸ್ ಏಕೆಂದರೆ ಸೆಟ್ ಹೋಗುವ ಇದು ಚಾರ್ ** ರು = ಶೂನ್ಯ ತಕ್ಷಣ "ಬೂಮ್" ಗೆ. ಮತ್ತು ನಂತರ ವಾಸ್ತವವಾಗಿ, buggy2 ಅನುಷ್ಠಾನಕ್ಕೆ ನೋಡಿ 0, 1, ಅಥವಾ 2 - - ಕರೆ binky, ಈ, ನಾನು ಒಂದು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಇ 0 ವೇಳೆ ಇದು oh_no ಕರೆಯುತ್ತದೆ, ಬೇರೆ ಇದು dinky ಕರೆ, ಇದು ಇಲ್ಲಿ ಬರುತ್ತದೆ. ನಾನು, ಕರೆ oh_no 1 ವೇಳೆ, ಬೇರೆ, ಇಲ್ಲಿ ಬರುವ ಇದು, ತೆಳ್ಳನೆಯ ಕರೆ ನಾನು 2 ವೇಳೆ, oh_no ಕರೆ. ನಾನು ಕೂಡ ಒಂದು ರೀತಿಯಲ್ಲಿ ಯೋಚಿಸುವುದಿಲ್ಲ - ಯಾರಾದರೂ ಈ segfault ಎಂಬುದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ನೋಡಿ ಡಸ್? ನಾನು ಏನೋ ಕಾಣೆಯಾಗಿದೆ ನಾನು ಹೊರತು ನಾನು 0 ವೇಳೆ, ನೀವು ತಕ್ಷಣ segfault ಮಾಡುತ್ತೇವೆ ಏಕೆಂದರೆ, ನೀವು, ನಾನು segfault 1 ವೇಳೆ ಇದು ಒಂದು ಕಾರ್ಯ ಹೋಗಿ ನೀವು ನಾನು ವೇಳೆ 2 ನೀವು segfault ಅಲ್ಲಿ ಒಂದು ಕಾರ್ಯವನ್ನು ಹೋಗಿ. ಇನ್ನು ನೀವು ಏನು ಪರವಾಗಿಲ್ಲ ಆದ್ದರಿಂದ, ನೀವು segfault. 

ನಾನು, ಇದು ಬದಲಿಗೆ ಚಾರ್ ** ರು = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುವ ಎಂದು ಸರಿಪಡಿಸಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ ಊಹೆ ಆ ವಾಕ್ಯವನ್ನು ಜಾಗ malloc ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. Sizeof ಏನು - ನಾವು malloc (sizeof) ಇಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] (ಚಾರ್) * 5? >> ಈ ಹಕ್ಕನ್ನು ತೋರುತ್ತಿಲ್ಲ? ನಾನು ವಾಸ್ತವವಾಗಿ ಇದು ನಡೆಯಿತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಊಹಿಸಿಕೊಂಡು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ನಾನು ಬಯಸುತ್ತೇನೆ ಏನು ಅಲ್ಲ. ರು ಮಾದರಿ ನೋಡಿ. ನ ಇಂಟ್ * ಸೇರಿಸಲು ಅವಕಾಶ, ಆದ್ದರಿಂದ ಇಂಟ್ * X. ನಾನು (sizeof (ಇಂಟ್)) malloc ಮಾಡಬೇಕಾಗುವುದು. ಅಥವಾ ನಾನು 5 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಯಸಿದರೆ, ನಾನು (sizeof (ಇಂಟ್) * 5) ಮಾಡುತ್ತಿದ್ದರು; ಏನು ನಾನು ಇಂಟ್ ** ಹೊಂದಿದ್ದರೆ? ನಾನು malloc ಬಯಸುವಿರಾ? ಪಾಯಿಂಟರ್ ಆಫ್ [ವಿದ್ಯಾರ್ಥಿ] ಗಾತ್ರ. >> ಹೌದು. (Sizeof (ಇಂಟ್ *)); ಕೆಳಗೆ ಇಲ್ಲಿ ಒಂದೇ. ನಾನು (sizeof (ಚಾರ್ *)) ನೀವು; ಈ "ಬೂಮ್" ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಎಂದು ಪಾಯಿಂಟರ್ ಜಾಗವನ್ನು ನಿಯೋಜಿಸಿ ಹೋಗುವ ಇದೆ. ನಾನು "ಬೂಮ್" ಸ್ಥಳಾವಕಾಶ ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿಲ್ಲ ನಾನು ಮೊದಲು ಹೇಳಿದ್ದಾರೆ ಎಂಬುದನ್ನು ಮೂಲಭೂತವಾಗಿ ಸಮಾನ ಏಕೆಂದರೆ ಚಾರ್ ನ * X = "ಬೂಮ್". "ಬೂಮ್" ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಇದು ಮೆಮೊರಿ ಓದಲು ಮಾತ್ರ ಪ್ರದೇಶದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವುದು ಸಂಭವಿಸಿದರೆ. ರು ಒಂದು ಚಾರ್ ** ವೇಳೆ ಆದರೆ ಈಗಾಗಲೇ, ಕೋಡ್ ಈ ಸಾಲಿನಲ್ಲಿ ಅಂದರೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ನಂತರ * ರು ಒಂದು ಚಾರ್ * ಮತ್ತು ನೀವು "ಬೂಮ್" ತೋರಿಸಲು ಈ ಚಾರ್ * ಹೊಂದಿಸುವಾಗ ನೀವು. ನಾನು ರು ಆಗಿ "ಬೂಮ್" ಕಾಪಿ ಬಯಸಿದರೆ, ನಂತರ ನಾನು ರು ಜಾಗವನ್ನು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ. ನಾನು ಮಾಡುತ್ತೇನೆ * ರು = malloc (sizeof (ಚಾರ್) * 5); ಏಕೆ 5? ಏಕೆ 4? "ಬೂಮ್" 4 ಅಕ್ಷರಗಳು ತೋರುತ್ತಿದೆ. >> [ವಿದ್ಯಾರ್ಥಿ] ಶೂನ್ಯ ಪಾತ್ರ. ಹೌದು. ನಿಮ್ಮ ತಂತಿಗಳ ಎಲ್ಲಾ ಶೂನ್ಯಚಿಹ್ನೆ ಅಗತ್ಯವಿದೆ ಹೋಗುವ. ಈಗ ನಾನು strcat ರೀತಿಯ ಮಾಡಬಹುದು - ಸ್ಟ್ರಿಂಗ್ ಸಿದ್ದಗೊಳಿಸಲು ಕಾರ್ಯವೇನು? [ವಿದ್ಯಾರ್ಥಿ] cpy? >> Strcpy. ಮನುಷ್ಯ strcpy. ಆದ್ದರಿಂದ strcpy ಅಥವಾ strncpy. ನೀವು ಸೂಚಿಸಬಹುದು ರಿಂದ strncpy ಸ್ವಲ್ಪ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂಬುದನ್ನು ಅನೇಕ ಪಾತ್ರಗಳು, ನಾವು ತಿಳಿದಿರುವ ಕಾರಣ ಆದರೆ ಇಲ್ಲಿ ಲೆಕ್ಕಕ್ಕೆ ಬರುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ strcpy ಮತ್ತು ವಾದಗಳನ್ನು ನಲ್ಲಿ ನೋಡಬಹುದು. ಮೊದಲ ವಾದವನ್ನು ನಮ್ಮ ತಾಣವಾಗಿದೆ. ಎರಡನೇ ವಾದವು ನಮ್ಮ ಮೂಲವಾಗಿದೆ. ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ * ಗೆ ನಕಲಿಸಲು ನೀನು ಪಾಯಿಂಟರ್ "ಬೂಮ್" s. ಏಕೆ ನೀವು ಮೊದಲು ಬದಲಿಗೆ ನಾವು ಏನು ಒಂದು strcpy ಈ ಮಾಡಲು ಬಯಸಬಹುದು * s ನ = "ಬೂಮ್"? ಅಲ್ಲಿ ಇದನ್ನು ಮಾಡಲು ಬಯಸಬಹುದು ಕಾರಣವೆಂದರೆ, ಆದರೆ ಕಾರಣವನ್ನು ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ನೀವು "ಬೂಮ್" ಏನೋ ಬದಲಾಯಿಸಲು ಬಯಸಿದರೆ. >> ಹೌದು. ಈಗ ನಾನು ರು ರೀತಿಯ ಮಾಡಬಹುದು [0] = 'ಎಕ್ಸ್'; ರು ಅಂಕಗಳನ್ನು ರಾಶಿ ಮೇಲೆ ರಾಶಿ ಮತ್ತು ಆ ಜಾಗವನ್ನು ಗೆ ರು ತೋರುತ್ತಿರುವಂತೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ "ಬೂಮ್" ಸಂಗ್ರಹಿಸುವ ಯಾವ ರಾಶಿ ಮೇಲೆ ಹೆಚ್ಚು ಜಾಗವನ್ನು ಒಂದು ಸೂಚಿಯಾಗಿದೆ. ಆದ್ದರಿಂದ "ಬೂಮ್" ಈ ಪ್ರತಿಯನ್ನು ರಾಶಿ ಶೇಖರವಾಗುತ್ತದೆ ಇದೆ. ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ "ಬೂಮ್" ಎರಡು ಪ್ರತಿಗಳನ್ನು ತಾಂತ್ರಿಕವಾಗಿ ಇವೆ. ಈ "ಬೂಮ್" ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ನೀಡಿದ ಎಂದು ಮೊದಲ ಬಾರಿಗೆ ಇಲ್ಲ ಮತ್ತು "ಬೂಮ್" ಎರಡನೇ ನಕಲು strcpy "ಬೂಮ್" ಪ್ರತಿಯನ್ನು ರಚಿಸಿದ. ಆದರೆ "ಬೂಮ್" ಪ್ರತಿಯು ರಾಶಿ ಶೇಖರಿಸಿಡಲು, ಮತ್ತು ರಾಶಿ ನೀವು ಬದಲಾಯಿಸಲು ಉಚಿತ ಆರ್ ಮಾಡಲಾಗುತ್ತಿದೆ. ರಾಶಿ ಓದಲು ಮಾತ್ರ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಅರ್ಥ ರು [0] ನೀವು "ಬೂಮ್" ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ ಹೋಗುತ್ತದೆ. ನೀವು ಆ ಪಾತ್ರಗಳು ಬದಲಾಯಿಸಲು ಅವಕಾಶ ವಿಶೇಷವೇನು. 

ಪ್ರಶ್ನೆಗಳು? ಸರಿ. 

, Buggy3 ಗೆ ನಾವು GDB buggy3 ಚಲಿಸುತ್ತಿರುತ್ತದೆ. ನಾವು ಚಾಲನೆ ಮತ್ತು ನಾವು ಒಂದು segfault ಪಡೆಯುವುದು ನೋಡಿ. ನಾವು backtrace ವೇಳೆ, ಕೇವಲ ಎರಡು ಕಾರ್ಯಗಳಿವೆ. ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ವಿಭಾಗಿಸಲ್ಪಟ್ಟಿದೆ ಹೋದರೆ, ನಾವು ಈ ಸಾಲಿನಲ್ಲಿ segfaulted ಎಂದು ನೋಡಿ. ಆದ್ದರಿಂದ ಕೇವಲ (ಕಾಲ, ಈ ರೇಖೆಯನ್ನು ನೋಡಿ ಇಂಟ್ ಲೈನ್ = 0; fgets ಈ ವಿಷಯವನ್ನು ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುತ್ತದೆ; ಸಾಲು + +). ನಮ್ಮ ಹಿಂದಿನ ಫ್ರೇಮ್ _IO_fgets ಕರೆಯಲಾಯಿತು. ಆ ಅಂತರ್ನಿರ್ಮಿತ ಸಿ ಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಬಹಳಷ್ಟು, ನೋಡುತ್ತಾರೆ ನೀವು segfault ಪಡೆದಾಗ, ನಿಜವಾಗಿಯೂ ರಹಸ್ಯ ಕಾರ್ಯ ಹೆಸರುಗಳಿವೆ ಎಂದು ಈ _IO_fgets ನಂತಹ. ಆದರೆ ಈ fgets ಕರೆ ಸಂಬಂಧವನ್ನು ವಿಶೇಷವೇನು. ಎಲ್ಲೋ ಇಲ್ಲಿ ಒಳಗೆ, ನಾವು segfaulting ಮಾಡಲಾಗುತ್ತದೆ. ನಾವು fgets ಆರ್ಗ್ಯುಮೆಂಟುಗಳನ್ನು ನೋಡಿದರೆ, ನಾವು ಬಫರ್ ಮುದ್ರಿಸಬಹುದು. ನ ಮುದ್ರಿಸಲು ಅವಕಾಶ ಒಂದು ಮಾಹಿತಿ - ಓಹ್, ಇಲ್ಲ. ಮುದ್ರಣ ನಿಖರವಾಗಿ ನಾನು ಬಯಸುತ್ತೇನೆ ಎಂದು ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ. ನಿಜವಾದ ಪ್ರೋಗ್ರಾಂ ನೋಡೋಣ. ಬಫರ್ ಒಂದು ಪಾತ್ರದ ರಚನೆ. ಇದು 128 ಅಕ್ಷರಗಳನ್ನು ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ನ. ಹಾಗಾಗಿ ಮುದ್ರಣ ಬಫರ್ ಹೇಳುತ್ತಾರೆ, ಅದು, ಆ 128 ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು ಇದು ನನ್ನ ಊಹೆಯ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಏನು. ನಾನು ಹುಡುಕುತ್ತಿದ್ದನು, ಬಫರ್ ವಿಳಾಸವನ್ನು ಮುದ್ರಿಸಲು ಆಗಿದೆ ಆದರೆ ನಿಜವಾಗಿಯೂ ನನಗೆ ಹೆಚ್ಚು ಹೇಳುವುದಿಲ್ಲ. ಹಾಗಾಗಿ ಇಲ್ಲಿ X ಬಫರ್ ಅನ್ನು ಹೇಳಲು ಉಂಟಾಗುತ್ತದೆ, ಅದು ನನಗೆ 0xbffff090 ತೋರಿಸುತ್ತದೆ ನೀವು ಹಿಂದಿನ ಅಥವಾ ಕೆಲವು ಬಿಂದುವಿನಿಂದ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ, Oxbffff ಒಂದು ಮೆದೆ ರೀತಿಯಲ್ಲಿ ಪ್ರದೇಶ ಎಂದು ನೀಡುತ್ತದೆ. ಸ್ಟಾಕ್ ಕೇವಲ 0xc000 ಅಡಿಯಲ್ಲಿ ಎಲ್ಲೋ ಆರಂಭಿಸಲು ಒಲವು. ಈ ವಿಳಾಸಕ್ಕೆ ನೋಡುವ ಮೂಲಕ, ನಾನು ಬಫರ್ ಸ್ಟಾಕ್ ಮೇಲೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಪ್ರತಿರೋಧಿಸುತ್ತದೆ, ಅಪ್, ರನ್, ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಪುನರ್ ನಾವು ಆಗಿತ್ತು ಪಾತ್ರಗಳು ಈ ಸರಣಿಯನ್ನು ಕಂಡಿತು ನಟನೆಯೆಂಬುದು ಅರ್ಥಹೀನ. ನಂತರ ಕಡತ ಮುದ್ರಣ, ಯಾವ ಫೈಲ್ ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ? [ವಿದ್ಯಾರ್ಥಿ] ಖಾಲಿ. >> ಹೌದು. , ಫೈಲ್ ಪ್ರಕಾರ FILE * ಒಂದು, ಆದ್ದರಿಂದ ಒಂದು ಸೂಚಿಯಾಗಿದೆ ಮತ್ತು ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಶೂನ್ಯ ಆಗಿದೆ. ಆದ್ದರಿಂದ fgets, ಪರೋಕ್ಷ ರೀತಿಯಲ್ಲಿ ಆ ಪಾಯಿಂಟರ್ ನಿಂದ ಓದಲು ಪ್ರಯತ್ನಿಸಿ ಹೋಗಿ ಇದೆ ಆದರೆ ಪಾಯಿಂಟರ್ ಪ್ರವೇಶಿಸಲು, ಇದು dereference ಅದು ಹೊಂದಿದೆ. ಅಥವಾ, ಇದು dereferences ಇದು ತೋರುತ್ತಿರುವಂತೆ ಏನು ಮಾಡಬೇಕೆಂದು ಪ್ರವೇಶಿಸಲು. ಆದ್ದರಿಂದ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಮತ್ತು segfaults dereferencing ನ. ನಾನು ಅದನ್ನು ಪುನಃ ಇರಬಹುದು. ನಮ್ಮ ಮುಖ್ಯ ಹಂತದಲ್ಲಿ ಮುರಿಯಲು ಮತ್ತು ರನ್ ವೇಳೆ, ಕೋಡ್ ಮೊದಲ ಸಾಲಿನ ಚಾರ್ * FILENAME = "nonexistent.txt" ಆಗಿದೆ; ಈ ಪ್ರೋಗ್ರಾಂ ವಿಫಲವಾದರೆ ಏಕೆ ಒಂದು ಸಾಕಷ್ಟು ದೊಡ್ಡ ಸುಳಿವು ನೀಡಬೇಕು. ನಾನು ಈ ಕಡತವನ್ನು ತೆರೆಯಲು ಅಲ್ಲಿ ಮುಂದಿನ ಟೈಪ್, ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ನನ್ನನ್ನು ತೆರೆದಿಡುತ್ತದೆ ತದನಂತರ ನಾನು ತಕ್ಷಣ ಒಮ್ಮೆ ನಾನು ಮುಂದಿನ ಹೊಡೆಯಲು ಅಲ್ಲಿ ನಮ್ಮ ಲೈನ್, ಮನಸ್ಸು, ಇದು segfault ಹೋಗುವುದಿಲ್ಲ. ಯಾರಾದರೂ ನಾವು segfaulting ಇರಬಹುದು ಏಕೆ ಒಂದು ಕಾರಣ ಔಟ್ ಎಸೆಯಲು ಬಯಸುವಿರಾ? [ವಿದ್ಯಾರ್ಥಿ] ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. >> ಹೌದು. ಈ ಸುಳಿವನ್ನು ಆಗಿರಬೇಕು ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುವಾಗ ಬಳಸುವಾಗಲೆಲ್ಲ ನೀವು ಫೈಲ್ ವಾಸ್ತವವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕು ಎಂದು. ಇಲ್ಲಿ, "nonexistent.txt"; ನಾವು ಓದುವ fopen FILENAME, ನಾವು ಹೇಳಲು ಅವಶ್ಯಕತೆ ವೇಳೆ (ಕಡತ == ಸಾಂಕೇತಿಕಕೊಂಡಿಯು) ಮತ್ತು printf ("ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ!" ಸೇ ಅಥವಾ - ಇನ್ನೂ ಉತ್ತಮ - FILENAME); ರಿಟರ್ನ್ 1; ಈಗ ನಾವು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇಲ್ಲಿದೆ ನೀವು ಪರೀಕ್ಷಿಸಿ ಮೊದಲು ವಾಸ್ತವವಾಗಿ ನಿರಂತರ ಮತ್ತು ಕಡತದಿಂದ ಓದಲು ಪ್ರಯತ್ನಿಸುವಾಗ. ನಾವು ಆ ಕೃತಿಗಳು ಎಂದು ನೋಡಲು ಅದನ್ನು ರೀಮೇಕ್ ಮಾಡಬಹುದು. ನಾನು ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಿ ಉದ್ದೇಶ. ಈಗ nonexistent.txt ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ನೀವು ಯಾವಾಗಲೂ ವಿಷಯವೆಂದರೆ ಈ ರೀತಿಯ ಪರಿಶೀಲಿಸಿ ಮಾಡಬೇಕು. ನೀವು ಯಾವಾಗಲೂ fopen ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಬೇಕು. ನೀವು ಯಾವಾಗಲೂ malloc ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬೇಕು ಅಥವಾ ನೀವು segfault. 

ಈಗ buggy4.c. ರನ್ನಿಂಗ್. ನಾನು ಇನ್ಪುಟ್ ಅಥವಾ ಬಹುಶಃ ಅನಂತ ಆವರ್ತಿಸುವ ಕಾಯುತ್ತಿದೆ ಈ ಊಹೆ ನುಡಿದರು. ಹೌದು, ಇದು ಅನಂತ ಆವರ್ತಿಸುವ ಇಲ್ಲಿದೆ. Buggy4 ಆದ್ದರಿಂದ. ನಾವು ಅನಂತ ಆವರ್ತಿಸುವ ತೋರುತ್ತಿದೆ. ನಾವು ಪ್ರಮುಖ ನಲ್ಲಿ ಮುರಿಯುತ್ತವೆ, ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ. GDB ರಲ್ಲಿ, ಅಲ್ಲಿಯವರೆಗೆ ನೀವು ಬಳಸಲು ಸಂಕ್ಷೇಪಣ ಸ್ಪಷ್ಟವಾಗಿದೆ ಎಂದು ಅಥವಾ ನೀವು ಒದಗಿಸುವ ವಿಶೇಷ ಸಂಕ್ಷೇಪಣಗಳು, ನಂತರ ನೀವು ಬದಲಿಗೆ ಮುಂದಿನ ಎಲ್ಲಾ ದಾರಿ ಟೈಪ್ ಹೊಂದುವ ಮುಂದಿನ ಬಳಸಲು N ಬಳಸಬಹುದು. ಮತ್ತು ಈಗ ನಾನು ಒಮ್ಮೆ ಹಿಟ್ N ಮಾಡಿರುವುದರಿಂದ, ನಾನು ಮುಂದಿನ ಮುಂದುವರಿಸುವುದಕ್ಕೆ ನಮೂದಿಸಿ ಹೊಡೆಯಬಹುದು ಬದಲಿಗೆ ಹಿಟ್ N ನಮೂದಿಸಿ, N ನಮೂದಿಸಿ, N ನಮೂದಿಸಿ ಹೊಂದುವ. ನಾನು [I] 0 ರಚನೆಯ ಹೊಂದಿಸುವ ಎಂದು ಲೂಪ್ ಫಾರ್ ತೆರನಾದ ಆಮ್ ತೋರುತ್ತಿದೆ. ಇದು ನಾನು ಲೂಪ್ ಈ ಆಫ್ ಹುಟ್ಟಿಕೊಂಡ ಎಂದಿಗೂ ನಾನು ತೋರುತ್ತಿದೆ. ನಾನು ಮುದ್ರಿಸಲು, ಹಾಗಾಗಿ 2 ವೇಳೆ, ನಂತರ ನಾನು ಮುಂದಿನ ಹೋಗುತ್ತೇನೆ. ನಾನು ಮುಂದಿನ ಹೋಗುತ್ತೇನೆ ನಾನು 3, ನಾನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ. ನಾನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಾನು 3. ಮುಂದೆ, ನಾನು ಮುದ್ರಿಸಲು, ಇ 4. ವಾಸ್ತವವಾಗಿ, ಮುದ್ರಣ sizeof (ಸರಣಿ), ಆದ್ದರಿಂದ ರಚನೆಯ ಗಾತ್ರ 20 ಆಗಿದೆ. ಕೆಲವು ವಿಶೇಷ GDB ಆಜ್ಞೆಯನ್ನು ಏನಾದರೂ ಸಂಭವಿಸಿದರೆ ರವರೆಗೆ ಹೋಗುವ ಇಲ್ಲ ಆದರೆ ಇದು ಕಾಣುತ್ತದೆ. ಇದು ವೇರಿಯಬಲ್ ಮೌಲ್ಯದ ಒಂದು ಸ್ಥಿತಿ ಸೆಟ್ಟಿಂಗ್ ರೀತಿಯಲ್ಲಿ. ಆದರೆ ನಾನು ನೆನಪಿರುವುದಿಲ್ಲ. - ನಾವು ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಹಾಗಿದ್ದಲ್ಲಿ ನೀವು ಏನು ಹೇಳುತ್ತಿದ್ದಾರೆ ಮಾಡಲಾಯಿತು? ನೀವು ಹೇಗಿದ್ದೀರಿ ತರಲು ಹೋಗಲಿಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] ಪ್ರದರ್ಶಿಸಲು ನಾನು ಸೇರಿಸಲು ಡಸ್ - >> ಹೌದು. ನಾನು ಸಹಾಯ ಮಾಡಬಹುದು ಪ್ರದರ್ಶಿಸಲು. ನಾವು ನಾನು ಪ್ರದರ್ಶಿಸಲು ವೇಳೆ, ನಾನು ಮೌಲ್ಯವನ್ನು ಏನು ಇಲ್ಲಿ ಹಾಕುತ್ತಾನೆ ಆದ್ದರಿಂದ ನಾನು ಪ್ರತಿ ಬಾರಿ ಅದನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿಲ್ಲ. ನಾವು ಮುಂದಿನ ಮುಂದುವರಿಸುವುದಕ್ಕೆ, ನಾವು 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 ನೋಡಿ. ಏನೋ ಆಪತ್ತು ತಪ್ಪು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಐ 0 ಮರುಹೊಂದಿಸಿ ಮಾಡಲಾಗುತ್ತಿದೆ. Buggy4.c ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನಾವು ನಡೆಯುವ ಎಲ್ಲಾ ಇಂಟ್ ರಚನೆಯ [5] ನೋಡಿ; (; ನಾನು <= sizeof (ಸರಣಿ); ನಾನು + + ನಾನು = 0) ರಚನೆಯ [I] = 0; ನಾವು ಇಲ್ಲಿ ತಪ್ಪು ಎಂಬುದನ್ನು ನೋಡುತ್ತಾರೆ? ಸುಳಿವು ಎಂದು, ನಾನು GDB buggy4 ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ - ಮುಖ್ಯ, ರನ್ ಮುರಿಯಲು ನಾವು - ನಾನು ಮುದ್ರಣ sizeof (ಸರಣಿ) ನಾನು ಅಂತಿಮವಾಗಿ ಔಟ್ ಉಂಟುವಾಡುವುದಿಲ್ಲ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ ಎಂಬುದನ್ನು ನೀಡಲಿಲ್ಲ. ಅಲ್ಲಿ ನಾನು? ನಾನು ಔಟ್ ನೀಡಲಿಲ್ಲ? ನಾನು ಇನ್ನೂ ಘೋಷಿಸಲು ಮಾಡಲಿಲ್ಲ. ಆದ್ದರಿಂದ, sizeof (ಸರಣಿ) ಮುದ್ರಿಸಲು ಮತ್ತು 20 ರ ಇದು ನನ್ನ ರಚನೆಯ ಗಾತ್ರ 5 ಏಕೆಂದರೆ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಮತ್ತು 5 ಪೂರ್ಣಾಂಕಗಳ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ ಆದ್ದರಿಂದ ಇಡೀ ವಿಷಯ sizeof (ಇಂಟ್) 4 ಕಾಣುತ್ತಾರೆ ಅಲ್ಲಿ 5 * sizeof (ಇಂಟ್) ಬೈಟ್ಗಳು, ಇರಬೇಕು. ಆದ್ದರಿಂದ sizeof (ಸರಣಿ) 20. ಈ ಏನಾಗಿರಬೇಕು? [ವಿದ್ಯಾರ್ಥಿ] sizeof (ಇಂಟ್) ಭಾಗಿಸಿ. >> ಹೌದು, / sizeof (ಇಂಟ್). ಸಮಸ್ಯೆ ಇಲ್ಲಿ ಇನ್ನೂ ತೋರುತ್ತಿದೆ. ನಾನು ಕೇವಲ ಎಂದೆನಿಸುವ < ಅದು ಬಹುಮಟ್ಟಿಗೆ ಯಾವಾಗಲೂ ಯ <ಮತ್ತು ಎಂದಿಗೂ <=. ಈಗ ಈ ವಾಸ್ತವವಾಗಿ ಮುರಿದು ಏಕೆ ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡೋಣ. ಯಾರಾದರೂ ನಾನು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ಮೂಲಕ 0 ಊಹೆಗಳು ಮರುಹೊಂದಿಸಿದ್ದೇವೆ ಹ್ಯಾವ್? ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ ಎಂದು ಒಳಗೆ ಮಾತ್ರ ವಿಷಯ [I] 0 ಗೆ ಸೆಟ್ ಎಂದು ರಚನೆ. ಆದ್ದರಿಂದ ಹೇಗಾದರೂ, ಕೋಡ್ ಈ ಸಾಲನ್ನು ನಾನು 0 ಅನ್ನು ನಮ್ಮ ಇಂಟ್ ಕಾರಣವಾಗಿದೆ. ನಾನು ಈ ಭಾಗದ ಮೆಮೊರಿ ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಸಾಧ್ಯ ಅದು ರಚನೆಯ ಮುಂದಿನ ಅಂಶವಾಗಿದೆ? ಭಾವಿಸುತ್ತಾರೆ ಯಾವಾಗ >> [ಬೌಡೆನ್] ಹೌದು. ನಮ್ಮ ರಚನೆಯ ಕೊನೆಯ ಮೀರಿ ನೀವು, ನಾವು ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ನೀವು ಹೇಗಾದರೂ ಆ ಜಾಗವನ್ನು ನಾನು ಮೌಲ್ಯವನ್ನು ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ಇದೆ. ನಾವು buggy4 ತನಿಖೆ ವೇಳೆ ಆದ್ದರಿಂದ, ಮುಖ್ಯ, ರನ್ ಮುರಿಯಲು ಐ ಆಫ್ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ಅವಕಾಶ. ಇದು bffff124 ಕಾಣುತ್ತಿಲ್ಲ. ಈಗ ಅವರ ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ಅವಕಾಶ [0]. 110. ಏನು [1] ಬಗ್ಗೆ? 114. [2], 118. 11C, 120. ರಚನೆಯ [5] bfff124 ಹೊಂದಿದೆ. ಅರೇ ಆದ್ದರಿಂದ [5] ನಾನು ಆ ಶ್ರೇಣಿಯನ್ನು [5] ನಾನು ಅಂದರೆ ಅದೇ ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ. ಅವರು ಅದೇ ವಿಳಾಸಕ್ಕೆ ಹೊಂದಿದ್ದರೆ, ಅವು ಒಂದೇ ಆಗಿವೆ. ನಾವು ಸರಣಿ [5] ಸೆಟ್ ಮಾಡಿದಾಗ 0 ಗೆ, ನಾವು 0 ಗೆ ನಾನು ಮಾಡುತ್ತಿದ್ದೀರಿ. ಮತ್ತು ನೀವು ಸ್ಟಾಕ್ ಪರಿಭಾಷೆಯಲ್ಲಿ ಈ ಬಗ್ಗೆ ನಿಮಗೆ ಅನಿಸಿದರೆ, ಇಂಟ್ ನಾನು ಸ್ಟಾಕ್ ಕೆಲವು ಜಾಗವನ್ನು ಗೆಟ್ಸ್ ಅಂದರೆ, ಮೊದಲ ಘೋಷಿಸಲಾಗುತ್ತದೆ. ನಂತರ ಸರಣಿ [5] ಆದ್ದರಿಂದ 20 ಬೈಟ್ಗಳು ಸ್ಟಾಕ್ ಮೇಲೆ ಹಂಚಲಾಗುತ್ತದೆ, ಹಂಚಿಕೆ ಇದೆ. ಆದ್ದರಿಂದ ನಾನು ಈ 20 ಬೈಟ್ಗಳು ನಿಯೋಜಿತವಾದ ಪಡೆಯುತ್ತೀರಿ, ಮೊದಲ ನಿಯೋಜಿತವಾದ ಮುಟ್ಟುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸರಿಯಾದ ಶ್ರೇಣಿಯನ್ನು ಮುಂಚಿತವಾಗಿ ನಡೆಯುತ್ತದೆ ಮತ್ತು ರೀತಿಯ ಕಾರಣ ನಾನು, ತಾಂತ್ರಿಕವಾಗಿ ಸ್ಟಾಕ್ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತದೆ, ಕಳೆದ ವಾರ ಹೇಳಿದರು ಒಂದು ಅರ್ರೆಯ್ ಗೆ ನೀವು ಸೂಚ್ಯಂಕ, ನಾವು ಖಾತರಿ ಎಂದು ಶ್ರೇಣಿಯಲ್ಲಿನ 0th ಸ್ಥಾನ ಯಾವಾಗಲೂ ರಚನೆಯ ಮೊದಲ ಸ್ಥಾನವನ್ನು ಮೊದಲು ನಡೆಯುತ್ತದೆ. ನಾನು ಕಳೆದ ವಾರ ಚಿತ್ರಿಸಿದಂತೆ ಹೇಗೆ ರೀತಿಯ. ಕೆಳಗೆ ನಾವು ವಿಳಾಸಕ್ಕೆ 0 ಮತ್ತು ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾವು ವಿಳಾಸಕ್ಕೆ ಮ್ಯಾಕ್ಸ್ ಎಂದು ಗಮನಿಸಿ. ಸ್ಟಾಕ್ ಯಾವಾಗಲೂ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತಿದೆ. ನಮಗೆ ನಾನು ನಿಯೋಜಿಸಿ ಹೇಳುತ್ತಾರೆ. ನಾವು ಪೂರ್ಣಾಂಕ ನಿಯೋಜಿಸಿ ನಾನು, ನಾವು ಇಲ್ಲಿ ಪೂರ್ಣಾಂಕ ನಾನು ನಿಯೋಜಿತವಾದ ಮುಟ್ಟುತ್ತದೆ ಅಪ್ ಹೇಳಿ ಅಂದರೆ. ನಂತರ ನಾವು ಕೆಳಗೆ ಅಂದರೆ 5 ಪೂರ್ಣಾಂಕಗಳ ನಮ್ಮ ರಚನೆಯ, ನಿಯೋಜಿಸಿ ಸ್ಟಾಕ್ ಕೆಳಗೆ ಬೆಳೆಯುತ್ತಿರುವ ಕಾರಣ, ಆ 5 ಪೂರ್ಣಾಂಕಗಳ ನಿಯೋಜಿತವಾದ ಪಡೆಯುತ್ತೀರಿ. ಆದರೆ ರಚನೆಗಳು ಹೇಗೆ ಕೆಲಸ ಕಾರಣ, ನಾವು ಖಾತರಿ ನೀವು ರಚನೆಯ ಮೊದಲ ಸ್ಥಾನ ಯಾವಾಗಲೂ ರಚನೆಯ ಎರಡನೆಯ ವಿಷಯ ಕಡಿಮೆ ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ರಚನೆಯ ಸ್ಥಾನವನ್ನು 0 ಯಾವಾಗಲೂ ಮೆಮೊರಿ ಮೊದಲ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ ಸರಣಿ 1 ಸ್ಥಾನವನ್ನು ನಂತರ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ ಆದರೆ ಮತ್ತು ಶ್ರೇಣಿಯನ್ನು ಸ್ಥಾನವನ್ನು 2, ನಂತರ ತೀರುತ್ತದೆ ಹೊಂದಿದೆ ಆ ಸರಣಿ ಸ್ಥಾನವನ್ನು 0, ಕೆಳಗೆ ಇಲ್ಲಿ ಎಲ್ಲೋ ಏನಾಗಬಹುದು ಅರ್ಥ ಅರೇ ಸ್ಥಾನ 1 ಆ ಮೇಲೆ ಏನಾಗಬಹುದು ಮೂವಿಂಗ್ ಅಪ್ ಗರಿಷ್ಠ ವಿಳಾಸಕ್ಕೆ ಇಲ್ಲಿ ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ವಿಳಾಸಗಳನ್ನು ಅರ್ಥ. ಏಕೆಂದರೆ ಕೆಳಗೆ ಇಲ್ಲಿ ರಚನೆಯ [0] ಆದ್ದರಿಂದ, ಸರಣಿ [1] ಅನ್ನು ಇಲ್ಲಿ, ಸರಣಿ [2] ಅನ್ನು ಇಲ್ಲಿ, ಸರಣಿ [3] ಅನ್ನು ಇಲ್ಲಿ. ನಾವು ಇಲ್ಲಿ ನಾನು ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಅಪ್, ಪೂರ್ಣಾಂಕ ಹಂಚಿಕೆ ಹೇಗೆ ಮುನ್ನ ಗಮನಿಸಿ ನಮ್ಮ ರಚನೆಯ ಮೇಲೆ ಮತ್ತಷ್ಟು ಪ್ರಯಾಣ, ನಾವು ಹತ್ತಿರಕ್ಕೆ ನಮ್ಮ ಪೂರ್ಣಾಂಕ ನಾನು ಪಡೆಯುತ್ತಿದ್ದಾರೆ. ಅದು ಹಾಗೆ, ಇದು ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಮೀರಿ ಒಂದು ಸ್ಥಾನವನ್ನು, ಆ ಶ್ರೇಣಿಯನ್ನು [5] ಸಂಭವಿಸುತ್ತದೆ ಅದನ್ನೇ ಹಂಚಲಾಗುವುದು ಏನಾಯಿತು ಅಲ್ಲಿ ಪೂರ್ಣಾಂಕವಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು ಸ್ಟಾಕ್ ಜಾಗವನ್ನು ಅಪ್ಪಳಿಸುತ್ತಿರಬಹುದು ಸಂಭವಿಸಿದಾಗ ಅಲ್ಲಿ ಪಾಯಿಂಟುಗಳ ಆ ಪೂರ್ಣಾಂಕ ನಾನು ನೀಡಲಾಯಿತು, ಮತ್ತು ನಾವು 0 ಹೊಂದಿಸುವಾಗ ನೀವು. 

ಆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಪ್ರಶ್ನೆಗಳು? ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ಪರವಾಗಿಲ್ಲ. ಸರಿ. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ದೋಷಗಳನ್ನು ಈ ಬಗೆಯ ತಪ್ಪಿಸಬಹುದು? ದೋಷಗಳು ಈ ತೆರನಾದ? ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಸಿ ಬಳಸಬೇಡಿ. ಪರೀಕ್ಷಿಸುವ ಅರೇ ಬೌಂಡ್ಸ್ ಹೊಂದಿದೆ ಒಂದು ಭಾಷೆಯನ್ನು ಬಳಸಿ. ಎಲ್ಲಿಯವರೆಗೆ ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ಮಾಡಿದಾಗ, ನಿಮ್ಮ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ದಾಟಿ ತಪ್ಪಿಸಲು ಅಗತ್ಯವಿದೆ. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಿಮ್ಮ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ದಾಟಿ ಹೋದಾಗ - [ಬೌಡೆನ್] ವಿಷಯಗಳನ್ನು ತಪ್ಪು ಹೋಗುವ ಆರಂಭಿಸಲು ಅಲ್ಲೇ. >> [ವಿದ್ಯಾರ್ಥಿ] ಓಹ್, ಸರಿ. ಎಲ್ಲಿಯವರೆಗೆ ನಿಮ್ಮ ಶ್ರೇಣಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಒಳಗೆ ಮಾಹಿತಿ, ನೀವು ಉತ್ತಮ ಆರ್. ಆದರೆ ಸಿ ಯಾವುದೇ ದೋಷ ತಪಾಸಣೆ ಮಾಡುವುದಿಲ್ಲ. ನಾನು ರಚನೆಯ ಮಾಡಿದರೆ [1000], ಇದು ಸಂತೋಷದಿಂದ ಕೇವಲ ಸಂಭವಿಸಿದರೆ ಯಾವುದೇ ಮಾರ್ಪಡಿಸಿ ಕಾಣಿಸುತ್ತದೆ - ಇದು ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ಹೋಗುತ್ತದೆ, ಅದು ನಂತರ 1000 ಸ್ಥಾನಗಳ ಹೋಗುತ್ತದೆ ಮತ್ತು ಇದು 0 ಹೊಂದಿಸುತ್ತದೆ. ಇದು ಓಹ್, ಈ ವಾಸ್ತವವಾಗಿ ಇದು 1000 ವಿಷಯಗಳನ್ನು ಯಾವುದೇ ತಪಾಸಣೆ ಮಾಡುವುದಾಗಲೀ. 1000, ರೀತಿಯಲ್ಲಿ ನಾನು ಬದಲಾವಣೆ ಮಾಡಬೇಕು ಮೀರಿ ಆಗಿದೆ ಜಾವಾ ಅಥವಾ ನೀನು ಪರಿಧಿಯಿಂದ ಸೂಚ್ಯಂಕದ ರಚನೆಯ ಔಟ್ ಪಡೆಯುತ್ತೀರಿ ಆದರೆ ಅಥವಾ ಗಡಿಯಿಂದ ಎಕ್ಸೆಪ್ಶನ್ ಸೂಚ್ಯಂಕ ಔಟ್. ಉನ್ನತ ಮಟ್ಟದ ಭಾಷೆ ಬಹಳಷ್ಟು ಈ ವಿಷಯಗಳನ್ನು ಏಕೆ ಆ ನೀವು ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ಮೀರಿ ಹೋದರೆ ಅಲ್ಲಿ, ನೀವು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ನೀವು ಕೆಳಗೆ ವಸ್ತುಗಳ ಬದಲಿಸಲಾಗುವುದಿಲ್ಲ ಆದ್ದರಿಂದ ತದನಂತರ ವಿಷಯಗಳನ್ನು ಕೇವಲ ಒಂದು ವಿನಾಯಿತಿ ಪಡೆಯಲು ಹೆಚ್ಚು ಕೆಟ್ಟದಾಗಿ ಹೋಗಿ ನೀವು ರಚನೆಯ ಕೊನೆಯ ಆಚೆ ಹೋಯಿತು ಎಂದು. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನಾವು ಬದಲಾಗಿದೆ ಬೇಕು <= ಕೇವಲ <? >> [ಬೌಡೆನ್] ಹೌದು. ಇದು <sizeof (ಸರಣಿ) / sizeof (ಇಂಟ್) ಆಗಿರಬೇಕು; sizeof (ಸರಣಿ) 20 ಆಗಿದೆ, ಆದರೆ ನಾವು ಕೇವಲ 5 ಬಯಸುವ ರಿಂದ. >> [ವಿದ್ಯಾರ್ಥಿ] ರೈಟ್. ಹೆಚ್ಚು ಪ್ರಶ್ನೆಗಳು? ಸರಿ. 

[ವಿದ್ಯಾರ್ಥಿ] ನಾನು ಒಂದು ಪ್ರಶ್ನೆ ಹೊಂದಿವೆ. >> ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ನಿಜವಾದ ರಚನೆಯ ವೇರಿಯಬಲ್ ಎಂದರೇನು? [ಬೌಡೆನ್] ಲೈಕ್ ರಚನೆಯ ಏನು? ಅರೇ ಸ್ವತಃ ಸಂಕೇತವಾಗಿದೆ. ನಾವು ಗುರುತಿಸಲಾಗುತ್ತಿದೆ ಎಂದು 20 ಬೈಟ್ಗಳು ಆರಂಭದ ವಿಳಾಸ. ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು ನಗರದ, ಆದರೆ ಅದು ಒಂದು ಸ್ಥಿರ ಸೂಚಿಯಾಗಿದೆ. ತಕ್ಷಣ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದರು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ವೇರಿಯಬಲ್ ರಚನೆಯ ಎಲ್ಲಿಯೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಹೇಗೆ ರಚನೆಯ ಗಾತ್ರ ಹೇಗೆ ಮಾಡುತ್ತದೆ? ರಚನೆಯ ಗಾತ್ರ ಆ ಚಿಹ್ನೆಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ಬ್ಲಾಕ್ ಗಾತ್ರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಾನು printf ರೀತಿಯ ("% ಪುಟ \ n", ಸರಣಿ) ಮಾಡಿದಾಗ; ನ ಚಲಾಯಿಸಲು ಅವಕಾಶ. ನಾನು ಏನು ತಪ್ಪು ಮಾಡಿದನು? ಅರೇ 'ವ್ಯೂಹ' ಇಲ್ಲಿ ಘೋಷಿಸಿದರು. ಓಹ್, ಅಪ್ ಇಲ್ಲಿ. ಖಣಿಲು ಚತುರ, ಮತ್ತು ನಾನು 5 ಅಂಶಗಳನ್ನು ಮಾಹಿತಿ ರಚನೆಯ ಡಿಕ್ಲೇರ್ಡ್ ಗಮನಿಸಿದಿರಾ ಸಂಭವಿಸಿದರೆ ಆದರೆ ನಾನು ಸ್ಥಾನವನ್ನು 1000 ಗೆ ಸೂಚಿ ನುಡಿದರು. ಈ ಕೇವಲ ಸ್ಥಿರ ಏಕೆಂದರೆ ಹಾಗೆ ಮಾಡಬಹುದು. ಇದು ಕೇವಲ ನನ್ನ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು ಮೀರಿ ನಾನು ಗಮನಿಸಿದ ಇಲ್ಲಿಯವರೆಗೆ ಹೋಗಬಹುದು. ಆದರೆ, ನಾವು ನಾನು ತಪ್ಪಾಗಿರಬಹುದು ಬಂದಾಗ ಮೊದಲು ಗಮನಕ್ಕೆ ಅದು, ನಾನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಷ್ಟು ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದ್ದರಿಂದ ನಾನು ರಚನೆಯ ಕೊನೆಯ ಮೀರಿ ಎಂದು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಕೇವಲ ಚತುರ ಎಂದು ಖಣಿಲು ಇಲ್ಲಿದೆ. 

ಆದರೆ ಈಗ buggy4 ಮಾಡಿ. ನಾನು ತಪ್ಪು ಬೇರೆ ಏನು ನಾನು? ಸೂಚ್ಯವಾಗಿ ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ 'printf' ಘೋಷಿಸಿದರು. ನಾನು # <stdio.h> ಸೇರಿಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. ಸರಿ. ಈಗ buggy4 ಚಾಲನೆಯಲ್ಲಿರುವ. ರೀತಿಯ ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುವ ನಾನು ಪಾಯಿಂಟರ್ ಅದನ್ನು ಮುದ್ರಿಸುವ, ಇಲ್ಲಿ ಮಾಡಿದರು ಈ ತೋರುತ್ತಿದೆ ಎಂದು ಮುದ್ರಿತ ಏನೋ - bfb8805c - ಕೆಲವು ವಿಳಾಸಕ್ಕೆ ಇದು ಆ ಸ್ಟಾಕ್-ರೀತಿಯಲ್ಲಿ ಪ್ರದೇಶದಲ್ಲಿ ನ. , ಅರೇ ಸ್ವತಃ ಒಂದು ಪಾಯಿಂಟರ್ ರೀತಿಯ, ಆದರೆ ಇದು ನಿಜವಾದ ಪಾಯಿಂಟರ್ ಅಲ್ಲ ಸಾಮಾನ್ಯ ಪಾಯಿಂಟರ್ ರಿಂದ ನಾವು ಬದಲಾಯಿಸಬಹುದು. ಅರೇ ಕೆಲವು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಮೆಮೊರಿ 20 ಬ್ಲಾಕ್ಗಳನ್ನು ವಿಳಾಸಕ್ಕೆ 0xbfb8805c ಆರಂಭವಾಗುವುದು. ಈ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಆದ್ದರಿಂದ bfb8805c +20- ಅಥವಾ ನಾನು -20 ಊಹೆ - ಈ ಶ್ರೇಣಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಎಲ್ಲ ಆಗಿದೆ. ಅರೇ, ವೇರಿಯಬಲ್ ಸ್ವತಃ ಎಲ್ಲಿಯಾದರೂ ಸಂಗ್ರಹಿಸಲು ಆಗುವುದಿಲ್ಲ. ನೀವು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ, ಕಂಪೈಲರ್ - ಇದು ಕೈ ತರಂಗ - ಇದು ಸರಣಿಯಾಗಿರಬೇಕು ತಿಳಿದುಕೊಳ್ಳದೇ ಅಲ್ಲಿ ಆದರೆ ಕಂಪೈಲರ್ ಕೇವಲ ಬಳಸುತ್ತದೆ. ಆ ಸರಣಿ ಆರಂಭವಾಗುತ್ತದೆ ಅಲ್ಲಿ ಇದು ತಿಳಿದಿರುವ ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಯಾವಾಗಲೂ ಕೇವಲ ಆರಂಭದಿಂದಲೂ ಪರಿಹಾರಗಳನ್ನು ಪರಿಭಾಷೆಯಲ್ಲಿ ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು. ಇದು ರಚನೆಯ ಪ್ರತಿನಿಧಿಸಲು ವೇರಿಯಬಲ್ ಸ್ವತಃ ಅಗತ್ಯವಿಲ್ಲ. ಆದರೆ ನಾನು ಇಂಟ್ * ಪು = ರಚನೆಯ ಸ್ವಲ್ಪ ಮಾಡಿದಾಗ; ಈಗ ಪು, ಆ ಶ್ರೇಣಿಯನ್ನು ಕೇಂದ್ರೀಕೃತವಾಗಿರುವ ಸೂಚಿಯಾಗಿದೆ ಮತ್ತು ಈಗ ಪುಟ ವಾಸ್ತವವಾಗಿ ಸ್ಟಾಕ್ ಮೇಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತದೆ. ನಾನು ಪುಟ ಬದಲಾಯಿಸಲು ಉಚಿತ ಆಮ್. ನಾನು ಪುಟ = malloc ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ಮೂಲತಃ ರಚನೆಯ ತೋರಿಸಿದರು; ಈಗ ರಾಶಿ ಮೇಲೆ ಕೆಲವು ಜಾಗವನ್ನು ಸೂಚಿತವಾಗಿರುತ್ತದೆ. ನಾನು ಅರೇ = malloc ಸಾಧ್ಯವಿಲ್ಲ. ಖಣಿಲು ಬುದ್ಧಿವಂತ ವೇಳೆ, ಇದು ಬಲ ಬ್ಯಾಟ್ ಆಫ್ ನನಗೆ ಕೋಪ ಕಾಣಿಸುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ನಾನು GCC ತುಂಬಾ ಹೀಗೆ ಎಂದು ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ. ಆದ್ದರಿಂದ ರಚನೆಯ ಪ್ರಕಾರ 'ಇಂಟ್ [5]' ವಹಿಸಿಕೊಡುವುದಾಗಲಿ ಅಲ್ಲ. ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೀತಿಯ ಏನಾದರೂ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಸರಣಿ ಕೇವಲ ಸ್ಥಿರ ಕಾರಣ. ಇದು ಉಲ್ಲೇಖಗಳು ಆ 20 ಬೈಟ್ಗಳು ಸಂಕೇತವಾಗಿದೆ. ನಾನು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. 

[ವಿದ್ಯಾರ್ಥಿ] ಮತ್ತು ರಚನೆಯ ಗಾತ್ರ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಇದೆ? [ಬೌಡೆನ್] ಇದು ಎಲ್ಲೂ ಸಂಗ್ರಹವಾಗಿರುವ ಅಲ್ಲ. ಇದು ಕಂಪೈಲ್ ಸಂದರ್ಭದಲ್ಲಿ ಇದು. ಆದ್ದರಿಂದ ರಚನೆಯ ಗಾತ್ರ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಇದೆ? ನೀವು ಕೇವಲ ಶ್ರೇಣಿಯನ್ನು ಸ್ವತಃ ಡಿಕ್ಲೇರ್ಡ್ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕಾರ್ಯದ ಒಳಗೆ sizeof (ಸರಣಿ) ಬಳಸಬಹುದು. ನಾನು ಕೆಲವು ಫಂಕ್ಷನ್, foo, ಏನು ಮತ್ತು ನಾನು ಹಾಗಾಗಿ (ಇಂಟ್ ರಚನೆಯ []) printf ("% s \ n", sizeof (ಸರಣಿ)); ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ನಾನು foo (ಸರಣಿ) ಕರೆ; ಈ ಕಾರ್ಯದ ಒಳಗೆ - ನ ಚಲಾಯಿಸಲು ಅವಕಾಶ. ಈ ಮತ್ತೆ ಬುದ್ಧಿವಂತ ಎಂದು ಖಣಿಲು ಹೊಂದಿದೆ. ನನಗೆ ಹೇಳುವ ಎಂದು ರಚನೆಯ ಕಾರ್ಯ ಪ್ಯಾರಾಮೀಟರ್ sizeof 'ಇಂಟ್ *' ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗುವುದು. ನಾನು ಸಂಭವಿಸಿ ಬಯಸಿದ್ದರು ಏನು ಅಲ್ಲ ಈ ದೋಷ ಎಂದು. ನ ವಾಸ್ತವವಾಗಿ Werror ಆಫ್ ಲೆಟ್. ಎಚ್ಚರಿಕೆ. ಎಚ್ಚರಿಕೆಗಳನ್ನು ಉತ್ತಮವಾಗಿವೆ. ಇದು ಒಂದು ಎಚ್ಚರಿಕೆ ಹೊಂದಿದೆ ಎಂದು ಇದು ಇನ್ನೂ ಉದ್ದನೆಯ ಕಂಪೈಲ್ ಕಾಣಿಸುತ್ತದೆ. . / A.out 4 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ರಚಿಸಿದ್ದಾರೆ ಎಂದು ಎಚ್ಚರಿಕೆ ತಪ್ಪಾಗಿದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟ ಸೂಚಕವಾಗಿದೆ. ಈ ಇಂಟ್ ರಚನೆಯ ಕೇವಲ sizeof (ಇಂಟ್ *) ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ನಾನು ಇಲ್ಲಿ ರಚನೆಯ [5] ಪುಟ್ ಸಹ, ಇದು ಈಗಲೂ ಕೇವಲ sizeof (ಇಂಟ್ *) ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು. ಆದ್ದರಿಂದ ತಕ್ಷಣ ನೀವು ಕಾರ್ಯ ಅದನ್ನು ಸಾಗುತ್ತಿರುವಾಗ ರಚನೆಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಈ, ಸ್ಟಾಕ್ ರಂದು ಘೋಷಿಸಲಾಯಿತು ಎಂದು ಸರಣಿಯಾಗಿರಬೇಕು ಸಂಭವಿಸಿದರೆ ಆದರೆ ನಾವು ಆ ಮೌಲ್ಯವನ್ನು ಸಾಗುತ್ತಿರುವಾಗ ಆ 0xbf blah, blah, ಈ ಕಾರ್ಯ ಆಗಿ blah, ನಂತರ ಈ ಪಾಯಿಂಟರ್ ಸ್ಟಾಕ್ ಆ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿತವಾಗಿರುತ್ತದೆ. Sizeof ಕೇವಲ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಯಿತು ಎಂದು ಕಾರ್ಯದಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ ಎಂದರೆ ಆದ್ದರಿಂದ, ಇದು ಅರ್ಥ ನೀವು ಈ ಕಾರ್ಯವನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ ಖಣಿಲು ಈ ಕ್ರಿಯೆಯ ಮೂಲಕ ಹೋದಾಗ, ಅದು ರಚನೆಯ ಗಾತ್ರ 5 ನ ಇಂಟ್ ರಚನೆ ನೋಡುತ್ತಾನೆ. ಆದ್ದರಿಂದ ಅದು sizeof (ಸರಣಿ) ನೋಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಆ 20 ಇಲ್ಲಿದೆ. ಆ sizeof ಮೂಲಭೂತವಾಗಿ ಎಲ್ಲಾ ಸಂದರ್ಭದಲ್ಲಿಯೂ ಕೆಲಸ ಹೇಗೆ ವಾಸ್ತವವಾಗಿ. Sizeof ಒಂದು ಕ್ರಿಯೆ ಅಲ್ಲ ಅದು ಒಂದು ಆಯೋಜಕರು ಇಲ್ಲಿದೆ. ನೀವು sizeof ಕಾರ್ಯ ಕರೆ ಮಾಡಬೇಡಿ. Sizeof (ಇಂಟ್), ಕಂಪೈಲರ್ ಕೇವಲ 4 ಭಾಷಾಂತರಿಸುತ್ತದೆ. ಅರ್ಥವಾಯಿತು? ಸರಿ. 

[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಮುಖ್ಯ ಮತ್ತು foo ರಲ್ಲಿ sizeof (ಸರಣಿ) ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು? ನಾವು ವಿಧದ ಇಂಟ್ * ನ ಇದು sizeof (ಸರಣಿ), ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ಏಕೆಂದರೆ ರಚನೆಯ ಕೆಳಗೆ ಇಲ್ಲಿ ಅಲ್ಲ ರೀತಿಯ ಇಂಟ್ * ಆಫ್ ಆದರೆ, ಇದು ಒಂದು ಇಂಟ್ ಶ್ರೇಣಿಯನ್ನು ನ. 

[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನೀವು ರಚನೆಯ [] ಬದಲಿಗೆ ಇಂಟ್ * ಶ್ರೇಣಿಯಲ್ಲಿನ ನಿಯತಾಂಕ ಹೊಂದಿದ್ದರೆ, ಈಗ ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಏಕೆಂದರೆ ನೀವು ಇನ್ನೂ ರಚನೆಯ ಬದಲಾಯಿಸಬಹುದು ಅರ್ಥ? [ಬೌಡೆನ್] ಈ ಲೈಕ್? >> [ವಿದ್ಯಾರ್ಥಿ] ಹೌದು. ನೀವು ಈಗ ಕಾರ್ಯ ಒಳಗೆ ರಚನೆಯ ಬದಲಿಸಬಹುದು? [ಬೌಡೆನ್] ನೀವು ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ರಚನೆಯ ಬದಲಾಯಿಸಬಹುದು. ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎರಡೂ ನೀವು ರಚನೆಯ [4] = 0 ಹೇಳಲು ಉಚಿತ. [ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ನೀವು ಯಾವುದೇ ಕೆಲಸಕ್ಕೆ ರಚನೆಯ ಪಾಯಿಂಟ್ ಮಾಡಬಹುದು? [ಬೌಡೆನ್] ಓಹ್. ಹೌದು. ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ - >> [ವಿದ್ಯಾರ್ಥಿ] ಹೌದು. [ಬೌಡೆನ್] ರಚನೆಯ [] ಮತ್ತು ಒಂದು ಇಂಟ್ * ರಚನೆಯ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಇಲ್ಲ. ನೀವು ಇಲ್ಲಿ ಕೆಲವು ಮಲ್ಟಿಡೈಮೆನ್ಷನಲ್ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯುವುದು ಕೆಲವು ಅನುಕೂಲಕರ ವಾಕ್ಯ, ಆದರೆ ಇದು ಇನ್ನೂ ಕೇವಲ ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ. ನಾನು ರಚನೆಯ ಮಾಡಲು ಮುಕ್ತನಾಗಿದ್ದೇನೆ ಅರ್ಥ = malloc (sizeof (ಇಂಟ್)) ಮತ್ತು ಈಗ ಎಲ್ಲೋ ಬೇರೆ ಸೂಚಿಸುತ್ತಾರೆ. ಆದರೆ, ಈ ಶಾಶ್ವತವಾಗಿ ಮತ್ತು ಯಾವಾಗಲೂ ಕೆಲಸ ಹೇಗೆ ಇಷ್ಟ ಇದರಿಂದಾಗಿ ಈ ವ್ಯೂಹ ಬದಲಾಯಿಸುವ ಯಾವುದೋ ಬೆರಳು ಇದು, ವಾದದ ಪ್ರತಿಯನ್ನು ಏಕೆಂದರೆ ಇಲ್ಲಿ ಈ ರಚನೆಯ ಕೆಳಗೆ ಬದಲಾಗುವುದಿಲ್ಲ ಆ ವಾದವನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಅಲ್ಲ. ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಅದನ್ನು ಒಂದೇ ಎಂದು ಹೆಚ್ಚು ಸೂಚನೆ - ನಾವು ಈಗಾಗಲೇ ಮುದ್ರಣ ರಚನೆಯ ಮುದ್ರಿತ ಏನು ಕಂಡಿತು - ನಾವು ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಅಥವಾ ರಚನೆಯ ವಿಳಾಸ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸಲು ವೇಳೆ ಆ ಎರಡೂ ಗೆ? ಅವರ ಈ ಒಂದು ನಿರ್ಲಕ್ಷಿಸಿ ಲೆಟ್. ಸರಿ. ಇದು ಉತ್ತಮವಾಗಿದೆ. ಈಗ. / A.out ಚಾಲನೆಯಲ್ಲಿರುವ ನ. ಮುದ್ರಣ ರಚನೆಯ ನಂತರ ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ, ಅವು ಒಂದೇ ಆಗಿವೆ. ಅರೇ ಕೇವಲ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ನೀವು ವ್ಯೂಹ ಮುದ್ರಿಸುವ ಮಾಡಿದಾಗ, ಆ 20 ಬೈಟ್ಗಳು ಉಲ್ಲೇಖಿಸುವ ಸಂಕೇತವನ್ನು ಮುದ್ರಿಸುವ ನೋಸ್. ರಚನೆಯ ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ, ಹಾಗೂ, ಸರಣಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಇದು ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ 20 ಬೈಟ್ಗಳು ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುತ್ತದೆ. ತಕ್ಷಣ ನೀವು ಕೆಳಗೆ ಕಂಪೈಲ್ ಮಾಹಿತಿ, ನಿಮ್ಮ ಕಂಪೈಲ್ buggy4 ರೀತಿಯಲ್ಲಿರುತ್ತದೆ. / A.out ಅರೇ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಪಾಯಿಂಟರ್ಸ್ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಅರೆಸ್ ಮಾಡುವುದಿಲ್ಲ. ಅರೇ ಪ್ರತಿನಿಧಿಸುವ ಮೆಮೊರಿಯ ಬ್ಲಾಕ್ಗಳನ್ನು ಈಗಲೂ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ಆದರೆ ವೇರಿಯಬಲ್ ವ್ಯೂಹ ಮತ್ತು ಆ ರೀತಿಯ ಅಸ್ಥಿರ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಆ ಸಾಲುಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹಾಗೆ ತಕ್ಷಣ ನೀವು ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಎಂದು, ಯಾವುದೇ ವ್ಯತ್ಯಾಸಗಳಿವೆ. ಆದರೆ ಒಳಗೆ ರಚನೆಯ ಸ್ವತಃ ಡಿಕ್ಲೇರ್ಡ್ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕ್ರಿಯೆಯ, sizeof ವಿಭಿನ್ನವಾಗಿ ಕೆಲಸ ನೀವು ಬದಲಿಗೆ ರೀತಿಯ ಗಾತ್ರವನ್ನು ಬ್ಲಾಕ್ಗಳನ್ನು ಗಾತ್ರವನ್ನು ಮುದ್ರಿಸುವ ಕಾರಣ, ಇದು ಸಂಕೇತವಾಗಿ ಏಕೆಂದರೆ ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ವಿಷಯ ವಸ್ತು ಮತ್ತು ವಿಳಾಸಕ್ಕೆ ಮುದ್ರಿಸುವ ಒಂದೇ ಮುದ್ರಿಸುತ್ತದೆ. ಮತ್ತು ಅದು ಬಹುಮಟ್ಟಿಗೆ ಇಲ್ಲಿದೆ. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಒಂದು ಬಾರಿ ಹೇಳಬಹುದು? ನಾನು ಏನೋ ಹೊರ ಹೋದಂತೆ. ರಚನೆಯ ಮುದ್ರಣ ವ್ಯೂಹ ಮತ್ತು ವಿಳಾಸ, ಒಂದೇ ವಿಷಯವನ್ನು ತೋರಿಸುತ್ತದೆ ನೀವು ಪಾಯಿಂಟರ್ ವಿಳಾಸವನ್ನು ವಿರುದ್ಧದ ಪಾಯಿಂಟರ್ ಮುದ್ರಿಸಲು ವೇಳೆ ಆದರೆ, ಒಂದು ವಿಷಯ ನಿಮಗೆ ಸೂಚಿಸುವ ಏನನ್ನು ವಿಳಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ, ಇತರ ಸ್ಟಾಕ್ ಪಾಯಿಂಟರ್ಗೆ ವಿಳಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ. ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಬದಲಾಯಿಸಬಹುದು; ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಚಿಹ್ನೆ ಬದಲಿಸಲಾಗುವುದಿಲ್ಲ. ಮತ್ತು sizeof ಸೂಚಿಗೆ ದುವಿನ ಪ್ರಕಾರದ ಗಾತ್ರ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಇಂಟ್ * ಪುಟ sizeof (ಪು), 4 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ ಆದರೆ ಇಂಟ್ ರಚನೆಯ [5] ಮುದ್ರಣ sizeof (ಸರಣಿ) 20 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ. [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಇಂಟ್ ರಚನೆಯ [5] 20 ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ? >> ಹೌದು. ಏಕೆ ಒಳಗೆ buggy4 ಅದನ್ನು sizeof (ಸರಣಿ) ಎಂದು ಬಳಸಿದಾಗ ಆ ನಾನು <20 ಮಾಡುತ್ತಿದ್ದ, ಇದು ನಾವು ಬೇಕಾಗಿದ್ದಾರೆ ಏನು ಅಲ್ಲ. ನಾವು ನಾನು <5 ಬಯಸುವ. >> [ವಿದ್ಯಾರ್ಥಿ] ಸರಿ. [ಬೌಡೆನ್] ನಂತರ ತಕ್ಷಣ ನೀವು ಕಾರ್ಯಗಳನ್ನು ಸಾಗುವ ಪ್ರಾರಂಭಿಸಿ, ನಾವು ಮಾಡಿದರೆ ಇಂಟ್ * ಪು = ಸರಣಿ; ಈ ಕಾರ್ಯದ ಒಳಗೆ, ನಾವು ಮೂಲತಃ, ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಪು ಮತ್ತು ಬಳಸಿಕೊಳ್ಳಬಹುದು sizeof ಸಮಸ್ಯೆ ಮತ್ತು ಬದಲಾಗುವ ಸಮಸ್ಯೆಯನ್ನು ಹೊರತುಪಡಿಸಿ. ಆದರೆ ಪು [0] = 1; ರಚನೆಯ [0] = 1 ಹೇಳುವ ಒಂದೇ; ಮತ್ತು ತಕ್ಷಣ ನಾವು foo (ಸರಣಿ) ಎಂದು ಹೇಳುತ್ತಾರೆ; ಅಥವಾ foo (ಪುಟ); foo ಕಾರ್ಯದ ಒಳಗೆ, ಈ ಬಾರಿ ಅದೇ ಕರೆಯಾಗಿದೆ. ಈ ಎರಡು ಕರೆಗಳನ್ನು ನಡುವೆ ವ್ಯತ್ಯಾಸವಿದೆ. 

ಆ ಉತ್ತಮ ಎಲ್ಲರಿಗೂ? ಸರಿ. ನಾವು 10 ನಿಮಿಷಗಳ ಹೊಂದಿರುತ್ತವೆ. 

ನಾವು, ಈ ಹ್ಯಾಕರ್ Typer ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಕಳೆದ ವರ್ಷ ಅಥವಾ ಏನಾದರೂ ಹೊರಬಂದು ಈ ವೆಬ್ಸೈಟ್. ನೀವು ಯಾದೃಚ್ಛಿಕವಾಗಿ ನಮೂದಿಸಿ ಮತ್ತು ಅದನ್ನು ತೋರಿಸುತ್ತದೆ ಎಂದು ಕೇವಲ ಎಂದು ಮಾಡಬೇಕೋ - ಯಾವುದೇ ಕಡತ ಅದನ್ನು ಲೋಡ್ ಸಂಭವಿಸಿದರೆ ನೀವು ಟೈಪ್ ಮಾಡುತ್ತಿರುವಂತೆ ತೋರುತ್ತಿದೆ ಏನು. ಅದು ಕಾರ್ಯ ವ್ಯವಸ್ಥೆಯನ್ನು ಕೋಡ್ ರೀತಿಯ ತೋರುತ್ತಿದೆ. ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬೇಕು. ನೀವು hacker_typer ಎಂಬ ಯುಗಳ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಇರಬೇಕು ಆ ಫೈಲ್, ಒಂದೇ ವಾದದಲ್ಲಿನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ "ಹ್ಯಾಕರ್ ಬಗೆ." ಕಾರ್ಯಗತಗೊಳ್ಳುವ ರನ್ನಿಂಗ್ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ಮಾಡಬೇಕು ತದನಂತರ ಬಳಕೆದಾರ ಪ್ರೆಸ್ ಪ್ರಮುಖ ಪ್ರತಿ ಬಾರಿ ಜಾರಿಗೆ ಇನ್ ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಮುದ್ರಿಸುತ್ತದೆ. ನೀವು ಒತ್ತಿ ಯಾವುದೇ ಪ್ರಮುಖ ಆದ್ದರಿಂದ, ಎಸೆದು ಮತ್ತು ಬದಲಿಗೆ ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರ ಮುದ್ರಿಸು ಮಾಡಬೇಕು ಆ ವಾದವು. ನಾನು ಅತ್ಯಧಿಕವಾಗಿ ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಎಂದು ನೀನು ವಸ್ತುಗಳು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ಆದರೆ ನಾವು termios ಲೈಬ್ರರಿ ಪರಿಶೀಲಿಸಲು ಬಯಸುವ. ನನ್ನ ಸಂಪೂರ್ಣ ಜೀವನದಲ್ಲಿ ಈ ಗ್ರಂಥಾಲಯದ ಬಳಸಲಾಗುತ್ತದೆ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಬಹಳ ಕಡಿಮೆ ಉದ್ದೇಶಗಳನ್ನು ಹೊಂದಿದೆ. ಆದರೆ ನಾವು ನೀವು ಹಿಟ್ ಪಾತ್ರ ಎಸೆದು ಬಳಸಬಹುದಾದ ಗ್ರಂಥಾಲಯದ ಏರಲಿದೆ ನೀವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಆಗಿ ಟೈಪ್ ಮಾಡಿದಾಗ ಆದ್ದರಿಂದ hacker_typer.c, ಮತ್ತು ನಾವು # <stdio.h> ಸೇರಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು. Termios ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡುವ - I'm ಇದು ಟರ್ಮಿನಲ್ OS ಅಥವಾ ಏನೋ ಊಹೆ - ನಾನು ಓದಲು ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ. ಈ ನೋಡುವುದರಿಂದ, ಈ 2 ಕಡತಗಳನ್ನು ಸೇರಿಸಲು ಹೇಳುತ್ತಾರೆ, ನಾವು ಹಾಗೆ ಮಾಡುತ್ತೇವೆ. 

ಮೊದಲನೆಯದಾಗಿ ಮೊದಲ, ನಾವು ತೆರೆಯಬೇಕು ಕಡತ ಇದು ಒಂದು ವಾದವು, ಕೈಗೊಳ್ಳಬೇಕಾದ ಬಯಸುವ. ಆದ್ದರಿಂದ ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ? ಹೇಗೆ ನಾನು ಒಂದು ವಾದವು ಹೊಂದಿರುತ್ತವೆ ಪರೀಕ್ಷಿಸಿ ಇಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] argc ಇದು ಸಮನಾಗಿರುತ್ತದೆ ವೇಳೆ. >> [ಬೌಡೆನ್] ಹೌದು. ಆದ್ದರಿಂದ (argc = 2!) Printf ("ಬಳಕೆ:% s [ಕಡತವನ್ನು ತೆರೆಯಲು]"). ನಾನು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ನೀಡದೆಯೇ ಈ ರನ್ ವೇಳೆ ಈಗ - ಓಹ್, ನಾನು ಹೊಸ ಲೈನ್ ಅಗತ್ಯವಿದೆ - ನೀವು ಹೇಳುತ್ತಾರೆ ಬಳಕೆಯ ನೋಡುತ್ತಾರೆ:. / hacker_typer, ತದನಂತರ ಎರಡನೆಯ ವಾದವನ್ನು ನಾನು ತೆರೆಯಲು ಬಯಸುವ ಫೈಲ್ ಆಗಿರಬೇಕು. ಈಗ ನಾನು ಏನು ಮಾಡಬೇಕು? ನಾನು ಈ ಕಡತದಿಂದ ಓದಲು ಬಯಸುವ. ನಾನು ಒಂದು ಕಡತದಿಂದ ಓದಲು ಇಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಮೊದಲ ಅದನ್ನು ತೆರೆಯಲು. >> ಹೌದು. ಆದ್ದರಿಂದ fopen. Fopen ಯಾವ ರೀತಿ ಮಾಡುವುದಿಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] ಕಡತದಹೆಸರು. >> [ಬೌಡೆನ್] ಫೈಲ್ಹೆಸರು argv [1] ಎಂದು ಹೋಗುತ್ತದೆ. [ವಿದ್ಯಾರ್ಥಿ] ನಂತರ ನಿಮಗೆ ಅದನ್ನು ಮಾಡಲು ಬಯಸುವ, ಆದ್ದರಿಂದ - >> [ಬೌಡೆನ್] ಹೌದು. ನೀವು ನೆನಪಿಡುವ ಮಾಡಲಿಲ್ಲ ಆದ್ದರಿಂದ, ನೀವು, ಮನುಷ್ಯ fopen ರೀತಿಯಲ್ಲಿಯೇ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಅದು ಮಾರ್ಗ FILENAME ಅಲ್ಲಿ ಒಂದು const ಚಾರ್ * ಮಾರ್ಗ ಎಂದು ವಿಶೇಷವೇನು ಅಲ್ಲಿ, const ಚಾರ್ * ಮೋಡ್. ನೀವು ವಿಧಾನವಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿರುವುದಿಲ್ಲ ಸಂಭವಿಸಿದಾಗ ನೀವು ಕ್ರಮಕ್ಕೆ ನೋಡಬಹುದು. ಮನುಷ್ಯ ಪುಟಗಳ ಒಳಗೆ, ಕತ್ತರಿಸಿ ಪಾತ್ರವನ್ನು ನೀವು ವಿಷಯಗಳನ್ನು ಹುಡುಕಲು ಬಳಸಬಹುದಾದ ಏನು. ಹಾಗಾಗಿ ಮೋಡ್ ಹುಡುಕಲು / ಮೋಡ್ ಟೈಪಿಸಿ. n ಮತ್ತು ಎನ್ ನೀವು ಹುಡುಕಾಟ ಪಂದ್ಯಗಳಲ್ಲಿ ಮೂಲಕ ಚಕ್ರದ ಬಳಸಬಹುದಾದ ಯಾವುವು. ಇಲ್ಲಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ ಮೋಡ್ ಅಂಕಗಳನ್ನು ಹೇಳುತ್ತಾರೆ ಕೆಳಗಿನ ಅನುಕ್ರಮಗಳನ್ನು ಒಂದನ್ನು ಪ್ರಾರಂಭಿಸಿ. ಓದುವ R ಆದ್ದರಿಂದ ಓಪನ್ ಪಠ್ಯ ಕಡತ. ನಾವು ಏನು ಬೇಕು. ಓದುವ, ಮತ್ತು ನಾನು ಆ ಶೇಖರಿಸಿಡಲು ಪಡೆಯಲು. ವಿಷಯ ಫೈಲ್ * ಎಂದು ಹೋಗುತ್ತದೆ. ಈಗ ನಾನು ನೀವು ಏನು? ಅಂತ ಎರಡನೇ ನೀಡಿ. ಸರಿ. ಈಗ ನಾನು ನೀವು ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ. >> [ಬೌಡೆನ್] ಹೌದು. ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ನೀವು ಯಶಸ್ವಿಯಾಗಿ ತೆರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. 

ನಾನು ಮೊದಲ ನನ್ನ ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಓದಲು ಬಯಸುವ ಅಲ್ಲಿ ಈಗ ನಾನು termios ಸ್ಟಫ್ ಮಾಡಲು ಬಯಸುವುದು ಮತ್ತು ಏನಾದರೂ ಇಂತಹ ಉಳಿಸಲು, ನಂತರ ನನ್ನ ಬದಲಾಯಿಸಲು ಬಯಸುವ , ನಾನು ಟೈಪ್ ಯಾವುದೇ ಪಾತ್ರ ದೂರ ಎಸೆಯಲು ತದನಂತರ ಆ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೇನೆ. ನಂತರ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ, ನನ್ನ ಮೂಲ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಮತ್ತೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ. ಆದ್ದರಿಂದ struct ರೀತಿಯ termios ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಆ ಎರಡು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ. ಮೊದಲನೆಯದು, ನನ್ನ current_settings ಏರಲಿದೆ ತದನಂತರ ಅವರು ನನ್ನ hacker_settings ಎಂದು ನೀನು. ಮೊದಲ, ನಾನು, ನನ್ನ ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಉಳಿಸಲು ಬಯಸುವ ಪಡೆಯಲಿದ್ದೇನೆ ಆಗ ನಾನು, hacker_settings ನವೀಕರಿಸಲು ಬಯಸುತ್ತೀರೆ ಪಡೆಯಲಿದ್ದೇನೆ ತದನಂತರ ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ರೀತಿಯಲ್ಲಿ, ನಾನು ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳಿಗೆ ಹಿಂದಿರುಗುತ್ತವೆ ಬಯಸುವ. ಆದ್ದರಿಂದ, ನಾವು ಮಾನವ termios ಕೆಲಸ ರೀತಿಯಲ್ಲಿ, ಪ್ರಸ್ತುತ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಉಳಿಸುವಲ್ಲಿ. ನಾವು ಈ ಇಂಟ್ tcsetattr, ಇಂಟ್ tcgetattr ಎಂದು ನೋಡಿ. ನಾನು ಅದರ ಪಾಯಿಂಟರ್ ಮೂಲಕ termios struct ರಲ್ಲಿ ಪಾಸ್. ಈ ನೋಡೋಣ ದಾರಿ - I've ಈಗಾಗಲೇ ಕಾರ್ಯ ಕರೆಯುತ್ತಿದ್ದ ಮರೆತು. ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ. Tcgetattr ಆದ್ದರಿಂದ, ನಂತರ ನಾನು ಮಾಹಿತಿ ಉಳಿಸುವಲ್ಲಿ ನಾನು struct ರಲ್ಲಿ ರವಾನಿಸ ಬೇಕೆಂದಿರುವ ಇದು current_settings ಏರಲಿದೆ ಮತ್ತು ಮೊದಲ ವಾದವನ್ನು ನಾನು ಬಹಳ ಉಳಿಸಲು ಬಯಸುವ ವಿಷಯ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಹೊಂದಿದೆ. ಯಾವ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಹಾಗೆ, ಅದು ಒಂದು ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಪಡೆಯುತ್ತದೆ. ನಾನು fopen argv [1], ಇದು ನೀವು ಉಲ್ಲೇಖಗಳನ್ನು ಆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಗೆಟ್ಸ್ ನೀವು ಅದನ್ನು ಓದಲು ಅಥವಾ ಬರೆಯಲು ಮಾಡಿ. ನಾನು ಇಲ್ಲಿ ಬಳಸಬೇಕಿರುವ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಅಲ್ಲ. ನೀವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿರುತ್ತವೆ ಮೂರು ಫೈಲ್ ವಿವರಣೆಗಳ ಇವೆ ಇದು ಪ್ರಮಾಣಿತ ಔಟ್, ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ ಮಾನಕವಾಗಿಬಿಟ್ಟಿದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಾನು 0, ಪ್ರಮಾಣಿತ ಔಟ್ 1, ಮತ್ತು ಪ್ರಮಾಣಿತ ದೋಷ 2 ಆಗಿದೆ ಗುಣಮಟ್ಟದ ಆಲೋಚಿಸಬೇಕು. ಹಾಗಾಗಿ ನಾನು ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೀರಿ? ನಾನು ಒಂದು ಪಾತ್ರ ಹಿಟ್ ಬಂದಾಗಲೆಲ್ಲಾ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ಬದಲಿಸಲು ಬಯಸುವ ನಾನು ಬದಲಿಗೆ ತೆರೆಗೆ ಅದನ್ನು ಮುದ್ರಿಸುವ ದೂರ ಪಾತ್ರದ ಎಸೆಯಲು ಬಯಸುವ. ಏನು ಸ್ಟ್ರೀಮ್ - - ಪ್ರಮಾಣಿತ ಔಟ್, ಅಥವಾ ಸಾಮಾನ್ಯ ದೋಷ, ಗುಣಮಟ್ಟದ ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದಾಗ ವಸ್ತುಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ? >> >> ಹೌದು ಸೈನ್ [ವಿದ್ಯಾರ್ಥಿ] ಸ್ಟ್ಯಾಂಡರ್ಡ್. ಹಾಗಾಗಿ ಎರಡೂ 0 ಮಾಡಬಹುದು ಅಥವಾ ನಾನು stdin ಮಾಡಬಹುದು. ನಾನು ಸೈನ್ ಗುಣಮಟ್ಟದ current_settings ಗೆಟ್ಟಿಂಗ್ ದೇರ್ 

ಈಗ ನಾನು, ಆ ಸೆಟ್ಟಿಂಗ್ಸ್ ಅನ್ನು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೀರಾ ಆದ್ದರಿಂದ ಮೊದಲ ನನ್ನ current_settings ಏನು hacker_settings ಗೆ ನಕಲಿಸಿ ಮಾಡುತ್ತೇವೆ. ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಕೆಲಸ ಹೇಗೆ ನಕಲು ಕಾಣಿಸುತ್ತದೆ. ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ಈ ಎಲ್ಲಾ ಜಾಗ ನಕಲಿಸುತ್ತದೆ. 

ಈಗ ನಾನು ಜಾಗ ಕೆಲವು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೇನೆ. Termios ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನೀವು ಈ ಸಾಕಷ್ಟು ಓದಲು ಇರಬೇಕು ನೀವು ನೋಡಲು ಬಯಸುವ ಎಂದು ನೋಡಲು, ಆದರೆ ನೀವು ನೋಡಲು ಬಯಸುವ ಎಂದು ನೀನು ಧ್ವಜಗಳು, ಪ್ರತಿಧ್ವನಿ ಗಳು ಆದ್ದರಿಂದ ಎಕೋ ಅಕ್ಷರಗಳನ್ನು ಇನ್ಪುಟ್ ಪ್ರತಿಧ್ವನಿ. ಮೊದಲ ಸೆಟ್ ನಾನು ಬಯಸುವ - ಜಾಗ ಎಂಬುದನ್ನು ಈಗಾಗಲೇ ಮರೆತು I've. ಈ struct ಕಾಣುತ್ತದೆ ಏನು. ಇನ್ಪುಟ್ ವಿಧಾನಗಳನ್ನು ಆದ್ದರಿಂದ ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ ಭಾವಿಸುತ್ತೇನೆ. ನಾವು ನಾವು ಬದಲಾಯಿಸಲು ಬೇಕು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಪರಿಹಾರಗಳನ್ನು ನೋಡಲು ಮಾಡುತ್ತೇವೆ. ನಾವೆಲ್ಲರೂ ಈ ಮೂಲಕ ನೋಡಲು ಬಯಸುವ ತಡೆಯಲು lflag ಬದಲಾಯಿಸಲು ಬಯಸುವ. ನಾವು ಸ್ಥಳೀಯ ವಿಧಾನಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸುವ. ನೀವು ಎಲ್ಲವನ್ನೂ ಸೇರಿದವನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಈ ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ಓದಲು ಇರಬೇಕು ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ. ಆದರೆ ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಅಲ್ಲಿ ಸ್ಥಳೀಯ ವಿಧಾನಗಳ ಒಳಗೆ ಇಲ್ಲಿದೆ. ಆದ್ದರಿಂದ hacker_settings.cc_lmode ಇದನ್ನು ಏನನ್ನು ಹೊಂದಿದೆ. c_lflag. ನಾವು bitwise ನಿರ್ವಾಹಕರು ಬರಲು ಅಲ್ಲಿ ಇದು. ನಾವು ಸಮಯ ರೀತಿಯ ಕೋರುತ್ತೇವೆ, ಆದರೆ ನಾವು ನೈಜ ಕ್ಷಿಪ್ರ ಮೂಲಕ ಹೋಗುತ್ತೇನೆ. ನಾವು bitwise ನಿರ್ವಾಹಕರು ಬರಲು ಅಲ್ಲಿ ಇದು ಹೊಂದಿದೆ ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಅಲ್ಲಿ ನಾನು ಒಂದು ಕಾಲದಲ್ಲಿ ಬಹಳ ಹಿಂದೆಯೇ ಹೇಳಿದ್ದಾರೆ ನೀವು ಧ್ವಜಗಳು ವ್ಯವಹರಿಸುವಾಗ ಆರಂಭಿಸಲು ಪ್ರಕಟಿಸಿದಾಗ, ನೀವು bitwise ಆಯೋಜಕರು ಸಾಕಷ್ಟು ಬಳಸಿಕೊಂಡು ಎಂದು ನೀನು. ಧ್ವಜ ಪ್ರತಿ ಬಿಟ್ ವರ್ತನೆಯ ಕೆಲವೊಂದು ಬಗೆಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಸಂಬಂಧಿಸಿರುತ್ತದೆ. ಇಲ್ಲಿ, ಈ ಧ್ವಜ ಎಲ್ಲಾ ಬೇರೆ ಅರ್ಥ ಅಲ್ಲಿ ವಿವಿಧ ವಸ್ತುಗಳು, ಒಂದು ಗುಂಪನ್ನು ಹೊಂದಿದೆ. ಆದರೆ ನಾನು ಯಾವ ಕೇವಲ ಪ್ರತಿಧ್ವನಿ ಅನುರೂಪವಾಗಿರುವ ಬಿಟ್ ಆಫ್ ಇದೆ. ಹಾಗೆ ಮಾಡಲು ನಾನು ಏನು ಆಫ್ & = ¬ ಪ್ರತಿಧ್ವನಿ. ವಾಸ್ತವವಾಗಿ, ನಾನು tECHO ಅಥವಾ ಯಾವುದೋ ರೀತಿಯ ಆಲೋಚಿಸಬೇಕು. ನಾನು ಮತ್ತೆ ಪರಿಶೀಲಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ. ನಾನು termios ಮಾಡಬಹುದು. ಇದು ಕೇವಲ ಪ್ರತಿಧ್ವನಿ ನ. ECHO ಒಂದು ಬಿಟ್ ಏರಲಿದೆ. ¬ ECHO ಎಲ್ಲಾ ಧ್ವಜಗಳು ನಿಜವಾದ ಸಿದ್ಧವಾಗಿವೆ ಅಂದರೆ, ಎಲ್ಲಾ ಬಿಟ್ಗಳು 1 ಸಿದ್ಧವಾಗಿವೆ ಅರ್ಥ ಹೋಗುತ್ತದೆ ECHO ಬಿಟ್ ಹೊರತುಪಡಿಸಿ. ಈ ನನ್ನ ಸ್ಥಳೀಯ ಧ್ವಜಗಳು ಕೊನೆಗೊಳ್ಳುವ ಹೊತ್ತಿಗೆ, ಇದು ಪ್ರಸ್ತುತ ನಿಜವಾದ ಗೆ ಸೆಟ್ ಎಲ್ಲಾ ಧ್ವಜಗಳು ಅರ್ಥ ಇನ್ನೂ ನಿಜವಾದ ಅನ್ನು ಕಾಣಿಸುತ್ತದೆ. ನನ್ನ ECHO ಧ್ವಜ ನಿಜವಾದ ಹೊಂದಿಸಲಾಗಿದೆ ವೇಳೆ, ನಂತರ ಈ ಅಗತ್ಯವಾಗಿ ECHO ಧ್ವಜ ಮೇಲೆ ಸುಳ್ಳು ಹೊಂದಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ ಕೋಡ್ ಈ ರೇಖೆಯು ECHO ಫ್ಲ್ಯಾಗ್ ಆಫ್ ತಿರುಗುತ್ತದೆ. ಕೋಡ್ ಇತರೆ ಸಾಲುಗಳನ್ನು ನಾನು ಅವರಿಗೆ ಆ ಬಗ್ಗೆ ನಕಲಿಸಿ ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ. ದ್ರಾವಣದಲ್ಲಿ, ಆತ 0 ಹೇಳಿದರು. ಇದು ಸ್ಪಷ್ಟವಾಗಿ stdin ಹೇಳಲು ಬಹುಶಃ ಉತ್ತಮ. 

ಇಲ್ಲಿ ICANON | ನಾನು ECHO ಮಾಡುತ್ತಿರುವೆ ಗಮನಿಸಿ. ICANON ಅಂಗೀಕೃತ ಕ್ರಮದಲ್ಲಿ ಅಂದರೆ ಪ್ರತ್ಯೇಕ ಏನೋ ಉಲ್ಲೇಖಿಸುತ್ತದೆ. ನೀವು ಆಜ್ಞಾ ಸಾಲಿನ ಔಟ್ ಟೈಪ್ ಮಾಡಿದಾಗ ಏನು ಅಂಗೀಕೃತ ಮೋಡ್ ಎಂದರೆ, ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಹೊಸಸಾಲು ಹಿಟ್ ರವರೆಗೆ ಗುಣಮಟ್ಟದ ಏನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮಾಡುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ ನೀವು GetString ಮಾಡುವಾಗ ನೀವು ಹೊಸಸಾಲು ಹಿಟ್ ನಂತರ, ವಸ್ತುಗಳ ಒಂದು ಗುಂಪೇ ಟೈಪಿಸಿ. ಇದು ಸೈನ್ ಗುಣಮಟ್ಟದ ಕಳುಹಿಸುವ ಆ ಸ್ ಡೀಫಾಲ್ಟ್ ಇಲ್ಲಿದೆ. ನಾನು, ನೀವು ಒತ್ತಿ ಈಗ ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಅಂಗೀಕೃತ ಮೋಡ್ ಆಫ್ ಮಾಡಿದಾಗ ಏನು, ಈ ವಿಷಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಧಾನ ಏಕೆಂದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ರೀತಿಯ ಇದು ಸಂಸ್ಕರಿಸಿದ ಮುಟ್ಟುತ್ತದೆ ಇದೆ ಇದು ಸಂಪೂರ್ಣ ಸಾಲಾಗಿ ಇದು ಪ್ರತಿರೋಧಿಸುತ್ತದೆ ಉತ್ತಮ ಎಂಬುದನ್ನು ಇದು. ಆದರೆ ನಾನು ಪ್ರತಿ ಪಾತ್ರದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ ನನ್ನ ಹೊಸಸಾಲು ಹೊಡೆಯಲು ಅದನ್ನು ನಿರೀಕ್ಷಿಸಿ ಬಯಸುವುದಿಲ್ಲ ರಿಂದ ಎಲ್ಲಾ ಪಾತ್ರಗಳು ಸಂಸ್ಕರಿಸುವ ಮುನ್ನ ನಾನು ಟೈಪ್ ಮಾಡಲಾಗಿದೆ. ಈ ಅಂಗೀಕೃತ ಮೋಡ್ ಆಫ್ ತಿರುಗುತ್ತದೆ. ಇದು ವಾಸ್ತವವಾಗಿ ಪಾತ್ರಗಳು ಸಂಸ್ಕರಿಸುವಾಗ ಈ ವಿಷಯವನ್ನು ಕೇವಲ ಅರ್ಥ. , ತಕ್ಷಣ ನಾನು ಅವುಗಳನ್ನು ಟೈಪ್ ನಾನು ಅವುಗಳನ್ನು ಸಂಸ್ಕರಿಸಲು; ಈ ತಕ್ಷಣವೇ ಅವುಗಳನ್ನು ಸಂಸ್ಕರಿಸಲು ಅರ್ಥ. ಮತ್ತು ಇದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ನನ್ನ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ನವೀಕರಿಸುವಾಗ ಇದು ಕಾರ್ಯ ಮತ್ತು TCSA ಎಂದರೆ ಈಗ ಅದನ್ನು. ಸ್ಟ್ರೀಮ್ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಎಲ್ಲ ಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುವ ತನಕ ಇತರ ಆಯ್ಕೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಿ ಮಾಡಲಾಗುತ್ತದೆ. ನಿಜಕ್ಕೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ. ಕೇವಲ ಇದೀಗ ನನ್ನ ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು hacker_typer_settings ಪ್ರಸ್ತುತ ಯಾವುದೇ ಎಂದು ಬದಲಾಯಿಸಿ. ನಾನು hacker_settings ಎಂಬ ಊಹೆ, ಆದ್ದರಿಂದ ಅವರ ಎಂದು ಬದಲಾಯಿಸಲು ಅವಕಾಶ. Hacker_settings ಎಲ್ಲವನ್ನೂ ಬದಲಿಸಿ. 

ಈಗ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ನಾವು ಹಿಂತಿರುಗಿ ಬಯಸುವ ಎಂದು ನೀನು normal_settings ಒಳಗೆ ಪ್ರಸ್ತುತ ಏನು, ಇದು ಕೇವಲ & normal_settings ಕಾಣುವಂತೆ ಹೋಗುತ್ತದೆ. ನಾನು ಮೂಲತಃ ಅದನ್ನು ಪಡೆಯಲು ರಿಂದ ನನ್ನ normal_settings ಯಾವುದೇ ಬದಲಾವಣೆಯಾಗಿಲ್ಲ ಗಮನಿಸಿ. ನಂತರ ಅವುಗಳನ್ನು ಮತ್ತೆ ಬದಲಾಯಿಸಲು, ನಾನು ಕೊನೆಯಲ್ಲಿ ಅವರನ್ನು ಮರಳಿ ಹಾದುಹೋಗುತ್ತವೆ. ಈ ಅಪ್ಡೇಟ್ ಆಗಿತ್ತು. ಸರಿ. 

ಒಳಗೆ ಇಲ್ಲಿ ಈಗ ನಾನು ಆ ಬಗ್ಗೆ ಕೋಡ್ ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ. ಇದು ಸಾಕಷ್ಟು ಕೋಡ್ ಅಲ್ಲ. ನಾವು ಕಡತದಿಂದ ಒಂದು ಪಾತ್ರ ಓದಿ ನೋಡಿ. ನಾವು ಎಫ್ ಕರೆಯಲಾಗುತ್ತದೆ. ಈಗ ನೀವು ಮನುಷ್ಯ fgetc ಮಾಡಬಹುದು, ಆದರೆ ಹೇಗೆ fgetc ಕೆಲಸ ಹೋಗುತ್ತದೆ ಕೇವಲ ನೀವು ಕೇವಲ ಓದಲು ಅಥವಾ EOF ಪಾತ್ರದ ಮರಳಲು ವಿಶೇಷವೇನು ಇದೆ, ಇದು ಕಡತ ಅಥವಾ ಕೆಲವು ದೋಷ ಸಂಭವಿಸುವುದರ ಕೊನೆಯಲ್ಲಿ ಅನುರೂಪವಾಗಿದೆ. ನಾವು, ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು ಮುಂದುವರಿಸಿದ್ದೇವೆ ಲೂಪಿಂಗ್ ಮಾಡಲಾಗುತ್ತದೆ ನಾವು ಓದಲು ಪಾತ್ರಗಳ ರನ್ ಔಟ್ ಮಾಡಿದ ರವರೆಗೆ. ನಾವು ಮಾಡುತ್ತಿರುವುದು ಆದರೆ, ನಾವು ಸೈನ್ ದರ್ಜೆಯಿಂದ ಒಂದೇ ಪಾತ್ರದ ಮೇಲೆ ನಿರೀಕ್ಷಿಸಿ ಪ್ರತಿಯೊಂದು ಬಾರಿ, ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಏನೋ ಟೈಪ್ ಸೈನ್ ಪ್ರಮಾಣಿತ ಒಂದು ಅಕ್ಷರ ಓದುವ ಎಂದು ನಂತರ putchar ನಾವು ಕಡತದಿಂದ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಮಾಡಲು ಇಲ್ಲಿ ಓದಲು ಚಾರ್ ಹಾಕಲು ಹೋಗುತ್ತದೆ. ನೀವು ಮನುಷ್ಯ putchar ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಕೇವಲ ಗುಣಮಟ್ಟದ ಹೊರಹಾಕುವ, ಅದು ಪಾತ್ರದ ಮುದ್ರಣ ಮಾಡಿದ. ಅದೇ ಪರಿಕಲ್ಪನೆಯನ್ನು; ನೀವು ಕೇವಲ printf ("% s", ಸಿ) ಇಲ್ಲ. ನಮ್ಮ ಕೆಲಸದ ಬಲ್ಕ್ ಮಾಡಲು ವಿಶೇಷವೇನು. 

ನಾವು ಬಯಸುವ ಎಂದು ನೀನು ಕಡೆಯದಾಗಿ ನಮ್ಮ ಫೈಲ್ fclose ಹೊಂದಿದೆ. ನೀವು fclose ಇದ್ದರೆ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಇಲ್ಲಿದೆ. ನಾವು ಮೂಲತಃ ತೆರೆಯಿತು ಕಡತ fclose ಬಯಸುವ, ಮತ್ತು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನಾವು ಮಾಡಿದರೆ, ನಾನು ಈಗಾಗಲೇ ಸಮಸ್ಯೆಗಳನ್ನು ದೊರೆತಿದೆ. ನೋಡೋಣ. ಇದು ಬಗ್ಗೆ ದೂರು ನೀಡಲಿಲ್ಲ? ನಿರೀಕ್ಷಿತ 'ಇಂಟ್' ಆದರೆ ವಾದದ ಪ್ರಕಾರ 'struct _IO_FILE *' ಹೊಂದಿದೆ. ಆ ಕೆಲಸ ನಾವು ನೋಡುತ್ತಾರೆ. ಕೇವಲ C99 ಅನುಮತಿ. Augh. ಸರಿ, hacker_typer ಮಾಡಿ. ಈಗ ನಾವು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ವಿವರಣೆ ಸಿಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಘೋಷಿಸಲ್ಪಡದ ಗುರುತು 'normal_settings' ಬಳಕೆ. ನಾನು normal_settings ಕಾಲ್ ಮಾಡಲಿಲ್ಲ. ನಾನು current_settings ಕರೆಯಲಾಗುತ್ತದೆ. ಇದರಿಂದ ಆ ಎಲ್ಲಾ ಬದಲಾಯಿಸಲು ಅವಕಾಶ. ಈಗ ವಾದ ಹಾದುಹೋಗುವ. ನಾನು ಈಗ ಈ 0 ಮಾಡಿಕೊಳ್ಳುವಿರಿ. ಸರಿ. . / Hacker_typer cp.c. ನಾನು ಆರಂಭದಲ್ಲಿ ತೆರೆ ತೆರವುಗೊಳಿಸಿ ಮಾಡಲಿಲ್ಲ. ಆದರೆ ನೀವು ತೆರೆಯ ತೆರವುಗೊಳಿಸಿ ಹೇಗೆ ನೋಡಲು ಕೊನೆಯ ಸಮಸ್ಯೆ ಸೆಟ್ ಮತ್ತೆ ನೋಡಬಹುದು. ಇದು ಕೆಲವು ಪಾತ್ರಗಳು ಮುದ್ರಿಸುವ ವಿಶೇಷವೇನು ಈ ನಾನು ಬಯಸುವ ಏನು ಹಾಗೆಯೇ. ಸರಿ. ಮತ್ತು ಈ ಬದಲಿಗೆ stdin 0 ಎಂದು ಅಗತ್ಯವಿದೆ ಏಕೆ ವಿಚಾರ, ಇದು # 0 ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡಬೇಕು ಈ ಎಂದು ದೂರು ಇದೆ - ನಾನು ಫೈಲ್ ವಿವರಣೆಗಳ ಇಲ್ಲ ಎಂದು ಆದರೆ ನೀವು ನಿಮ್ಮ ಫೈಲ್ * ಹೊಂದಿರುವಾಗ ಮೊದಲು, ಒಂದು ಕಡತ ವಿವರಣೆಗಾರನನ್ನು, ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕ ಫೈಲ್ * ಇದು ಸಂಬಂಧಿಸಿದ ವಿಷಯದ ಸಂಪೂರ್ಣ ಗುಂಪೇ ಹೊಂದಿದೆ ಆದರೆ. ನಾವು ಬದಲಿಗೆ stdin 0 ಹೇಳಲು ಅಗತ್ಯವಿದೆ ಕಾರಣ ಆ stdin ಕಡತ ವಿವರಣೆಗಾರನನ್ನು 0 ಉಲ್ಲೇಖಿಸುತ್ತಿದ್ದಾರೆ ವಿಷಯ ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಇದು ಫೈಲ್ * ಆಗಿದೆ. ಆದ್ದರಿಂದ ಕೂಡ ಇಲ್ಲಿ ನಾನು fopen ಮಾಡಿದಾಗ (argv [1], ನಾನು ಮತ್ತೆ ಫೈಲ್ * ಗೆಟ್ಟಿಂಗ್ ದೇರ್. ಆದರೆ ಎಲ್ಲೋ ಫೈಲ್ * ಆ ಕಡತ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಸಂಬಂಧಪಟ್ಟ ವಿಷಯ. ನೀವು ತೆರೆದ ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಿದರೆ, ಆದ್ದರಿಂದ ನಾನು ಮನುಷ್ಯ 3 ಮುಕ್ತ ಮಾಡಬೇಕು ತಿಳಿಯುತ್ತೇನೆ - ಇಲ್ಲ - ಮ್ಯಾನ್ 2 ತೆರೆದ - ಹೌದು. ನೀವು ತೆರೆದ ಪುಟವನ್ನು ನೋಡಿದರೆ, ಮುಕ್ತ, ಕಡಿಮೆ ಮಟ್ಟದ fopen ಹಾಗೆ ಮತ್ತು ಅದು ವಾಸ್ತವಿಕ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಮರಳಿದ ನ. fopen ತೆರೆದ ಮೇಲೆ ವಿಷಯವನ್ನು ಒಂದು ಗುಂಪೇ ಮಾಡುತ್ತದೆ, ಬದಲಿಗೆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಇಡೀ FILE * ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಕೇವಲ ಹಿಂದಿರುಗಿದ ಯಾವ ಒಳಗೆ ನಮ್ಮ ಕಡಿಮೆ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಹೊಂದಿದೆ. FILE * ವಿಷಯ ಸೂಚಿಸುತ್ತದೆ ತುಂಬಾ ಸಾಮಾನ್ಯ, 0 ಸ್ವತಃ ಕೇವಲ ಕಡತ ವಿವರಣೆಗಾರನನ್ನು ಗುಣಮಟ್ಟದ ಸೂಚಿಸುತ್ತದೆ ಆದರೆ. 

ಪ್ರಶ್ನೆಗಳು? [ನಗು] ಆ ಮೂಲಕ ಉಡಾಯಿಸಿದರು. ಎಲ್ಲಾ ಸರಿ. ನಾವು ಮುಗಿಸಿದ್ದೀರಿ. [ನಗು] 

[CS50.TV]