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

ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ಭಾಗಕ್ಕೆ ಹೋಗಿ ಮಾಡಬಹುದು. ನಾನು ಮೊದಲು ಸ್ಥಳದ URL ಅನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ. ಪ್ರಶ್ನೆಗಳನ್ನು ವಿಭಾಗದ ಪ್ರಾರಂಭದ ಹೇಳುತ್ತಾರೆ- ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಬಹಳ ಸುಲಭವಾದ ಪ್ರಶ್ನೆ unsick-ಹೊಂದಿದೆ ಸಂಪೂರ್ಣವಾಗಿ ಅಲ್ಲ valgrind ಸ್ವಲ್ಪ ಏನು? Valgrind ಏನು ಮಾಡುತ್ತದೆ? ಯಾರಾದರೂ valgrind ಏನು ಹೇಳಲು ಬಯಸುತ್ತೀರಿ? [ವಿದ್ಯಾರ್ಥಿ] ಪರೀಕ್ಷಣೆ ಮೆಮೊರಿ ಸೋರುವಿಕೆ. ಹೌದು, valgrind ಸಾಮಾನ್ಯ ಮೆಮೊರಿ ಪರೀಕ್ಷಕ ಹೊಂದಿದೆ. ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಹೊಂದಿದ್ದರೆ ಇದು ಕೊನೆಯಲ್ಲಿ, ನೀವು ಹೇಳುತ್ತದೆ ನೀವು ಬಯಸುವ ನಾವು ಏಕೆಂದರೆ ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಏನನ್ನು ಬಹುಮಟ್ಟಿಗೆ ಸಮಸ್ಯೆ ಸೆಟ್ ಅಥವಾ ನೀವು ಬಯಸುವ ವೇಳೆ ಉತ್ತಮವಾಗಿ ದೊಡ್ಡ ಮಂಡಳಿಯಲ್ಲಿ ಪಡೆಯುವುದು, ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಮಾಡಬೇಕು ಮತ್ತು ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಹೇಗೆ ಸಾಧ್ಯವಿಲ್ಲ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿವೆ ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಮಾಡಿದಾಗ ಸಹ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ ಮತ್ತು ನೀವು ಇದನ್ನು ಮುಚ್ಚಿ ಹೋದರೆ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಇಲ್ಲಿದೆ. 

ಬಹಳಷ್ಟು ಜನರು ಅವರು ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಕೆಲವು ನೋಡ್ ಹುಡುಕುತ್ತಿರುವ ಆಗ ನಿಜವಾಗಿಯೂ, ಅವರು ಮೊದಲ ಹಂತದಲ್ಲಿ ನಿಘಂಟು ಮುಚ್ಚಿ ಮಾಡಲಿಲ್ಲ. ಇದು, ನೀವು ಯಾವುದೇ ಅಮಾನ್ಯವಾಗಿದೆ ಹೊಂದಿದ್ದರೆ ಓದುತ್ತದೆ ತಿಳಿಸುವುದು ಅಥವಾ ಬರೆಯುತ್ತಾರೆ ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ವೇಳೆ ಇದು ಅರ್ಥ ಆ ರಾಶಿ ಕೊನೆಯ ಆಚೆಗೆ ಮತ್ತು ಇದು seg ತಪ್ಪು ಸಂಭವಿಸಿದಾಗ ಇಲ್ಲ ಆದರೆ valgrind, ನಿಜವಾಗಿಯೂ ಅಲ್ಲಿ ಬರೆಯಲು ಮಾಡಬಾರದು ಎಂದು, ಅದನ್ನು ಹಿಡಿಯಲು ಆದ್ದರಿಂದ ನೀವು ಖಂಡಿತವಾಗಿ ಆ ಎರಡೂ ಯಾವುದೇ ಹಾಗಿಲ್ಲ. ನೀವು ಹೇಗೆ valgrind ಬಳಸುತ್ತಾರೆಯೇ? ನೀವು ಹೇಗೆ valgrind ಬಳಸುತ್ತಾರೆಯೇ? 

ಇದು ಒಂದು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆ ಇಲ್ಲಿದೆ ರೀತಿಯ ಚಾಲನೆ ಮತ್ತು ಔಟ್ಪುಟ್ ನೋಡಲು. ಔಟ್ಪುಟ್ ಬಾರಿ ಬಹಳಷ್ಟು ಸುಲಭವಾಗಿ ಇದೆ. ನೀವು ಕೆಲವು ಭಯಾನಕ ತಪ್ಪು ವಿಷಯ ಹೊಂದಿದ್ದರೆ ವಿನೋದ ದೋಷಗಳು ಇಲ್ಲ ಒಂದು ಆವರ್ತನದಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ, ನಂತರ ಅಂತಿಮವಾಗಿ ", ವೇ ಹಲವಾರು ದೋಷಗಳನ್ನು ಹೇಳುವುದಿಲ್ಲ. ನಾನು ಈಗ ಎಣಿಸುವ ನಿಲ್ಲಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. " ಇದು ಮೂಲತಃ ನೀವು ಬಿಡಿಸಿ ಅವುಗಳ ಗ್ರಾಂಥಿಕ ಔಟ್ಪುಟ್ ಇಲ್ಲಿದೆ. ಕೊನೆಯಲ್ಲಿ, ಇದು, ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ತಿಳಿಸುವರು ಉಪಯುಕ್ತ ಎಷ್ಟು ಬ್ಲಾಕ್ಗಳನ್ನು, ಮಾಡಬಹುದು ಏಕೆಂದರೆ ಒಂದು ಬ್ಲಾಕ್ unfreed ಇದ್ದರೆ, ನಂತರ ಅದನ್ನು ಪಡೆಯುವ ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭ 1,000 ಬ್ಲಾಕ್ಗಳನ್ನು unfreed ಹೆಚ್ಚು. Unfreed 1,000 ಬ್ಲಾಕ್ಗಳನ್ನು ಬಹುಶಃ ನೀವು ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಅರ್ಥ ಸೂಕ್ತವಾಗಿ ಅಥವಾ ಏನಾದರೂ ನಿಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿಗಳು. ಆ valgrind ನ. 

ಈಗ ನಾವು, ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ಹೊಂದಿವೆ ನೀವು ಡೌನ್ಲೋಡ್ ಅಗತ್ಯವಿಲ್ಲ. ನೀವು ನನ್ನ ಹೆಸರನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಸ್ಥಳದಲ್ಲಿ ಅವುಗಳನ್ನು ಬರಬಹುದು. ಈಗ ನನ್ನ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ. ಪರಿಷ್ಕರಣೆ 1 ನಾವು ಮೊದಲ ಮಾಡುತ್ತಿರುವುದು ಇದು ಸ್ಟಾಕ್, ಎಂದು ಕಾಣಿಸುತ್ತದೆ. ಪರಿಷ್ಕರಣೆ 2 ಕ್ಯೂ ಇರುತ್ತದೆ, ಮತ್ತು ಪುನರಾವರ್ತನಾ 3 ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಇರುತ್ತದೆ. ನಮ್ಮ ಸ್ಟಾಕ್ ಜೊತೆಗೆ ಪ್ರಾರಂಭ. ಇಲ್ಲಿ ಹೇಳುವಂತೆ, ಒಂದು ಸ್ಟಾಕ್, ಮೂಲಭೂತ ಒಂದಾಗಿದೆ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ಮೂಲಭೂತ ಅಕ್ಷಾಂಶ ರಚನೆಗಳು. ಅತ್ಯಂತ ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ ಊಟದ ಪ್ರಾಂಗಣದಲ್ಲಿ ಟ್ರೇಗಳು ಸ್ಟಾಕ್. ನೀವು ಸ್ಟಾಕ್ ಜಾರಿಗೊಳಿಸಲಾಗಿದೆ ಮಾಡಿದಾಗ ಇದು, ಮೂಲತಃ ಇಲ್ಲಿದೆ ಯಾರಾದರೂ, ಹೇಳಲು ಹೋಗುತ್ತದೆ "ಟ್ರೇನಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ನಂತಹ, ಓ." ನೀವು ಟ್ರೇಗಳು ಅಪ್ ಬಣವೆ. ನಂತರ ನೀವು ಒಂದು ಟ್ರೇ ಎಳೆಯಲು ಹೋಗಿ, ಎಳೆದ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಎಂದು ಮೊದಲ ಟ್ರೇ ಸ್ಟಾಕ್ ಸೇರಿಸಲಾಗಿತ್ತು ಕೊನೆಯ ಒಂದಾಗಿದೆ. ಇದು ರೀತಿಯ ಸ್ಟ್ಯಾಕ್ ಇಲ್ಲಿಗೆ ಹೇಳುತ್ತಾರೆ ನಾವು ಸ್ಟಾಕ್ ಎಂಬ ಸ್ಮರಣೆ ಭಾಗವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಮತ್ತು ಏಕೆ ಸ್ಟಾಕ್ ಕರೆಯಲಾಗುತ್ತದೆ? 

ಏಕೆಂದರೆ ಒಂದು ಸ್ಟಾಕ್ ಅಕ್ಷಾಂಶ ರಚನೆಯಾಗಿದೆ, ಇದು, ಸ್ಟಾಕ್ ಮೇಲೆ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ತಳ್ಳುತ್ತದೆ ಮತ್ತು ಪಾಪ್ಸ್ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕ್ರಿಯೆಯ ನಿರ್ದಿಷ್ಟ ಕಾಲ್ ಹಾಗೆ ಅಲ್ಲಿ ಇವೆ. ಮತ್ತು ಒಂದು ಸ್ಟಾಕ್ ರೀತಿಯಲ್ಲಿ ನೀವು ಯಾವಾಗಲೂ ಮರಳಲು ಹೊಂದಿರುತ್ತದೆ ಒಂದು ಕಾರ್ಯ ಕರೆ ನೀವು ಮತ್ತೆ ಕಡಿಮೆ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕೆಳಭಾಗಕ್ಕೆ ಪಡೆಯಲು ಮೊದಲು. ನೀವು ಮುಖ್ಯ ಕರೆ foo ಕರೆ ಬಾರ್ ಮತ್ತು ಮುಖ್ಯ ನೇರವಾಗಿ ಗೆ ಬಾರ್ ರಿಟರ್ನ್ ಹೊಂದುವಂತಿಲ್ಲ. ಯಾವಾಗಲೂ ತಳ್ಳುವುದು ಮತ್ತು ಪಾಪಿಂಗ್ ಸರಿಯಾದ ಸ್ಟಾಕ್ ಅನುಸರಿಸಲು ಅವರಲ್ಲಿದೆ. ಎರಡು ಕಾರ್ಯಾಚರಣೆಗಳು, ನಾನು ಹೇಳಿದ ಹಾಗೆ, ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಇವೆ. ಆ ಸಾರ್ವತ್ರಿಕ ಪದಗಳು. ನೀವು ರಾಶಿಯನ್ನು ಯಾವುದೇ ಪರಿಭಾಷೆಯಲ್ಲಿ ಪುಶ್ ಮತ್ತು ಪಾಪ್ ತಿಳಿಯಬೇಕಿದೆ. ನಾವು ಸಾಲುಗಳನ್ನು ವಿವಿಧ ರೀತಿಯ ಅವು ನೋಡುತ್ತಾರೆ. ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು ಸಾರ್ವತ್ರಿಕ ಪದವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಪುಶ್ ಮತ್ತು ಪಾಪ್ ರಾಶಿಯನ್ನು ಸಾರ್ವತ್ರಿಕ ಇವೆ. ಪುಶ್ ಕೇವಲ ಸ್ಟಾಕ್ ಇಡಲಾಗುತ್ತದೆ. ಪಾಪ್ ಸ್ಟಾಕ್ ತೆಗೆದುಕೊಳ್ಳಲು ಹೊಂದಿದೆ. ಮತ್ತು ನಾವು ನಮ್ಮ typedef struct ಸ್ಟಾಕ್ ಹೊಂದಿವೆ ಇಲ್ಲಿ ನೋಡಿ ಆದ್ದರಿಂದ ನಾವು ಚಾರ್ ** ತಂತುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಯಾವುದೇ ** ಗಾಬರಿಯಾಗಿ ಇರುವುದಿಲ್ಲ. ಈ ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಅಷ್ಟೇ ಆಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತಿದೆ ಹಾಕುತ್ತದೆ ಪಾತ್ರಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳ ಅಥವಾ ರಚನೆಯ ಅಲ್ಲಿ ಪಾತ್ರಗಳು ರೀತಿಯು ತಂತಿಗಳನ್ನು ಒಲವು. ಇದು ತಂತಿಗಳನ್ನು ಎಂದು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಇಲ್ಲಿ ಅವರು ತಂತಿಗಳನ್ನು ಎಂದು ನೀನು. 

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

ಇದು ಆಗಬಹುದು ಒಂದು ರೀತಿಯಲ್ಲಿ ತಕ್ಷಣ ನೀವು 10 ಅಂಶಗಳನ್ನು ಹಿಟ್ ಎಂದು, ನಂತರ ನೀವು ಮುಗಿಸಿದ್ದೀರಿ ಹೊಂದಿದೆ. ನೀವು ಜಗತ್ತಿನ 10 ವಸ್ತುಗಳ ಬೌಂಡ್ ಒಂದು ಮೇಲ್ ಎಂದು ಪರಿಚಯವಿರಬಹುದಾದ ನೀವು, ನಿಮ್ಮ ಸ್ಟಾಕ್ ಹೆಚ್ಚು 10 ವಿಷಯಗಳನ್ನು ಎಂದಿಗೂ ಆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮ ಸ್ಟಾಕ್ ಗಾತ್ರವನ್ನು ಬೌಂಡ್ ಒಂದು ಮೇಲ್ ಹೊಂದಬಹುದು. ಅಥವಾ ನೀವು ನಿಮ್ಮ ಸ್ಟಾಕ್ ಮಿತಿ ಎಂದು ತೋರಿಸಬಹುದಿತ್ತು ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತಿರುವುದು ಆದರೆ, ಆ, ಪ್ರತಿಯೊಂದು ಬಾರಿ 10 ಅಂಶಗಳನ್ನು ಹಿಟ್ ಅರ್ಥ ನೀವು 20 ಅಂಶಗಳನ್ನು ಹೊಡೆದಾಗ ನಂತರ ನೀವು, 20 ಅಂಶಗಳ ಬೆಳೆಯುತ್ತದೆ ಮಾಡಲಿಕ್ಕೆ, ಮತ್ತು ನೀವು ನೀವು 30 ಅಂಶಗಳನ್ನು ಅಥವಾ 40 ಅಂಶಗಳನ್ನು ನಿಮ್ಮ ರಚನೆಯ ಬೆಳೆಯಲು ಹೊಂದಿರುವ ನೀನು. ನಾವು ಇಲ್ಲಿ ಹೋಗಿ ಏನನ್ನು ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು. ನಾವು, ನಮ್ಮ ಸ್ಟಾಕ್ ಗರಿಷ್ಠ ಗಾತ್ರವನ್ನು ತಲುಪಲು ಪ್ರತಿಯೊಂದು ಸಮಯ ನಾವು ಯಾರ ಮೇಲೆ ಏನೋ ಪುಶ್ ನಾವು ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು. ಇಲ್ಲಿ, ನಾವು ಪುಶ್ bool ಪುಶ್ (ಚಾರ್ * Str) ಎಂದು ಘೋಷಿಸಿದರು. ಚಾರ್ * Str, ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ತಳ್ಳುವುದು ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ ಮತ್ತು bool ನಾವು ಯಶಸ್ವಿಯಾದರು ಅಥವಾ ವಿಫಲವಾಗಿದೆ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ. 

ಹೇಗೆ ನಾವು ವಿಫಲಗೊಳ್ಳಬಹುದು? ನೀವು ನಗರದ ಏಕೈಕ ಪರಿಸ್ಥಿತಿ ಏನು ನಾವು ತಪ್ಪು ಹಿಂದಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ ಅಲ್ಲಿ? ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಪೂರ್ಣ ಮತ್ತು ನಾವು ಸುತ್ತುವರಿದಿದೆ ಅನುಷ್ಠಾನ ಬಳಸುತ್ತಿದ್ದರೆ. ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲು-ಅವನು ಉತ್ತರ ಪೂರ್ಣ ಮತ್ತು ನಾವು ಪರಿಮಿತಿಗೊಳಪಟ್ಟ ಅನುಷ್ಠಾನ ಬಳಸುತ್ತಿದ್ದರೆ. ನಾವು ಖಂಡಿತವಾಗಿಯೂ ತಪ್ಪು ಹಿಂತಿರುಗುವುದು. ತಕ್ಷಣ ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ 10 ವಿಷಯಗಳನ್ನು ಹಿಟ್ ಎಂದು, ನಾವು 11 ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ ಸಾಧ್ಯವಿಲ್ಲ, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗಿ ಆದ್ದರಿಂದ. ಇದು ಮಿತಿ ಏನು? ಹೌದು. ನೀವು ಕೆಲವು ಕಾರಣಕ್ಕಾಗಿ ಶ್ರೇಣಿಯನ್ನು ವಿಸ್ತರಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ವೇಳೆ. ಹೌದು, ಆದ್ದರಿಂದ ಮೆಮೊರಿ, ಸೀಮಿತ ಸಂಪನ್ಮೂಲವಾಗಿದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಮತ್ತೆ ಮತ್ತು ಮೇಲೆ ಸ್ಟಾಕ್ ಮೇಲೆ ತಳ್ಳುವುದು ವಸ್ತುಗಳು ಇದ್ದರೆ, ನಾವು ಹೊಂದಿಕೊಳ್ಳಲು ದೊಡ್ಡ ವ್ಯೂಹ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ನಿಯೋಜಿಸಿ ಎಂದು ನೀನು ನಾವು ಬಳಸುತ್ತಿರುವ ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯ, ಮತ್ತು malloc ಅಥವಾ ಯಾವುದೇ ತಪ್ಪು ಮರಳಲು ಹೋಗುತ್ತದೆ. ಅಲ್ಲದೆ, malloc ಶೂನ್ಯ ಹಿಂತಿರುಗುವುದು. 

ನೆನಪಿಡಿ, ನೀವು ಎಂದಾದರೂ malloc ಕರೆ ಪ್ರತಿಯೊಂದು ಸಮಯ, ನೀವು ನೋಡಲು ತಪಾಸಣೆ ಮಾಡಬೇಕು ಅದು ಶೂನ್ಯ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಅಥವಾ ಯಾವುದೇ ಒಂದು ಸರಿಯಾಗಿವೆ ವ್ಯವಕಲನವಾಗುತ್ತದೆ. ನಾವು ಒಂದು ಅಸೀಮ ಸ್ಟಾಕ್ ಬೇಕು ಏಕೆಂದರೆ, ನಾವು ಪ್ರಯತ್ನಿಸಿ ನಾವು ತಪ್ಪು ಮರಳುವುದಾಗಿ ಎಂದು ನೀನು ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ ಸಾಮರ್ಥ್ಯ ಮತ್ತು malloc ಹೆಚ್ಚಿಸಲು ಅಥವಾ ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಯಾವುದೇ. ನಂತರ ಪಾಪ್, ಆರ್ಗುಮೆಂಟುಗಳಿಲ್ಲದೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಏನೇ ಇತ್ತೀಚೆಗೆ ಸ್ಟಾಕ್ ಮೇಲೆ ಹಾಕಲಾಯಿತು, ಹಿಂದಿರುಗಿದ ಯಾವ ಪಾಪ್ ಮತ್ತು ಇದು ಸ್ಟಾಕ್ ಇದು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಏನೂ ಇಲ್ಲ ಅದು ಶೂನ್ಯ ಮರಳಿಸುವ ಗಮನಿಸುವುದಿಲ್ಲ. ಇದು ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು ಯಾವಾಗಲೂ ಸಾಧ್ಯವಿದೆ. ಜಾವಾದಲ್ಲಿ, ಆ, ಅಥವಾ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಬಳಸುತ್ತಿದ್ದರೆ, ಖಾಲಿ ಸ್ಟಾಕ್ ಪಾಪ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಹೊರತುಪಡಿಸಿ ಅಥವಾ ಏನಾದರೂ ಕಾರಣವಾಗಬಹುದು. 

ಆದರೆ ಸಿ, ಶೂನ್ಯ ಈ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ಹೇಗೆ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಾಕಷ್ಟು ರೀತಿಯ. ಶೂನ್ಯ ಮರಳಿದ ನಾವು ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ನೀನು ಹೇಗೆ. ನಾವು, ನಿಮ್ಮ ಸ್ಟ್ಯಾಕ್ನ ಕಾರ್ಯತ್ಮಕತೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಎಂದು ಕೋಡ್ ಒದಗಿಸಲಾದ ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಜಾರಿಗೆ. ಈ ಕೋಡ್ ಒಂದು ಸಾಕಷ್ಟು ಆಗುವುದಿಲ್ಲ. ಅದನ್ನೇ ತಿನ್ನುವೆ-ವಾಸ್ತವವಾಗಿ, ನಾವು ಹಾಗೆ ಮೊದಲು, ಸುಳಿವನ್ನು, ಸುಳಿವನ್ನು- ನೀವು ಕಾಣಬಹುದು ಇದ್ದರೆ, malloc ಮಾತ್ರ ಕಾರ್ಯ ಅಲ್ಲ ಎಂದು ನೀವು ರಾಶಿ ಮೆಮೊರಿಯ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ. Alloc ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಕುಟುಂಬ ಇವೆ. ಮೊದಲ ನೀವು ಬಳಸಲಾಗುತ್ತದೆ ನೀವು ಯಾವ malloc, ಆಗಿದೆ. ನಂತರ malloc ಅದೇ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ ಇದು calloc, ಇಲ್ಲ ಆದರೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಔಟ್ ಸೊನ್ನೆಗೆ ಕಾಣಿಸುತ್ತದೆ. ನೀವು ಎಂದಾದರೂ ಏನಾದರೂ mallocing ನಂತರ ಶೂನ್ಯ ಎಲ್ಲವನ್ನೂ ಸೆಟ್ ಬಯಸಿದರು ನೀವು ಬದಲಿಗೆ ನೀವು ಬರೆಯುವ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ calloc ಬಳಸಬೇಕಿತ್ತು ಮೆಮೊರಿ ಸಂಪೂರ್ಣ ಬ್ಲಾಕ್ ಔಟ್ ಸೊನ್ನೆಗೆ ಲೂಪ್ ಒಂದು. 

Realloc, malloc ಹಾಗೆ ಹಾಗೂ ವಿಶೇಷ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ಹೊಂದಿದೆ ಆದರೆ ಮೂಲತಃ realloc ಏನು ಆಗಿದೆ ಇದು ಈಗಾಗಲೇ ಹಂಚಲಾಗಿತ್ತು ಎಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. Realloc ನೀವು ಇಲ್ಲಿ ಗಮನ ಪಾವತಿ ಬೇಕಿರುವ ಕಾರ್ಯ. ಇದು ಈಗಾಗಲೇ malloc ಹಿಂದಿರುಗಿದ ಎಂದು ಒಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಲೆಟ್ಸ್ ನೀವು malloc 10 ಬೈಟ್ಗಳು ಒಂದು ಪಾಯಿಂಟರ್ ಮನವಿ ಹೇಳುತ್ತಾರೆ. ನಂತರ ನೀವು 20 ಬೈಟ್ಗಳು ಬಯಸಿದ್ದರು ಅರ್ಥ ಆದ್ದರಿಂದ, 20 ಬೈಟ್ಗಳು ಆ ಪಾಯಿಂಟರ್ ಮೇಲೆ realloc ಕರೆ ಮತ್ತು realloc ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎಲ್ಲವನ್ನೂ ಲಿಂಕುಗಳು ಕಾಣಿಸುತ್ತದೆ. ನೀವು ನಾನು 10 ಬೈಟ್ಗಳು ಒಂದು ಬ್ಲಾಕ್ ಮಾಡಿದಂತೆ ಮತ್ತೆ malloc ಕರೆಯಲಾಗುತ್ತದೆ. ವೇಳೆ ಈಗ ನಾನು 20 ಬೈಟ್ಗಳು ಒಂದು ಬ್ಲಾಕ್, ಅಗತ್ಯವಿದೆ ಆದ್ದರಿಂದ ನಾನು malloc 20 ಬೈಟ್ಗಳು, ಆಗ ನಾನು ಕೈಯಿಂದ ಮೊದಲನೆಯದಾಗಿ 10 ಬೈಟ್ಗಳು ಲಿಂಕುಗಳು ಮಾಡಬೇಕು ಮೊದಲನೆಯದಾಗಿ ಎರಡನೇ ವಿಷಯ ಆಗಿ ತದನಂತರ ಉಚಿತ. Realloc ನೀವು ಆ ನಿರ್ವಹಿಸುವಿರಿ. 

ಸಹಿ, ಶೂನ್ಯವನ್ನು * ಎಂದು ಹೋಗುತ್ತದೆ ಗಮನಿಸಿ ಇದು ಕೇವಲ, ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಮರಳಲಿದ್ದಾರೆ ನಂತರ ಅನೂರ್ಜಿತ * ptr. ನೀವು ಒಂದು ಜೆನೆರಿಕ್ ಪಾಯಿಂಟರ್ ಮಾಹಿತಿ ಅನೂರ್ಜಿತ * ನಗರದ. ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು, ಶೂನ್ಯವನ್ನು * ವ್ಯವಹರಿಸಲು ಇಲ್ಲ ಆದರೆ malloc ಒಂದು ಶೂನ್ಯವನ್ನು * ಹಿಂದಿರುಗಿದ, ಮತ್ತು ಅದು ಕೇವಲ ರೀತಿಯ ಬಳಕೆಯ ಈ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಎಂದು ಹೋಗುತ್ತದೆ. malloc ನೀಡಿದ ಎಂದು ಹಿಂದಿನ ಅನೂರ್ಜಿತ * ಈಗ ಗಾತ್ರ ನಂತರ realloc ರವಾನಿಸಬಹುದು ಹೋಗುವ, ಮತ್ತು ನೀವು ನಿಯೋಜಿಸಿ ಬಯಸುವ ಬೈಟ್ಗಳು ಹೊಸ ಸಂಖ್ಯೆ, ನಿಮ್ಮ ಹೊಸ ಸಾಮರ್ಥ್ಯ ಹೊಂದಿದೆ. ನಾನು ನೀವು ಒಂದೆರಡು ನಿಮಿಷಗಳ ಸಮಯ ನೀಡಿ, ಮತ್ತು ನಮ್ಮ ಜಾಗದಲ್ಲಿ ಅದನ್ನು ಮಾಡುತ್ತೇನೆ. ಪರಿಷ್ಕರಣೆ 1 ಆರಂಭಿಸಿ. ನಾನು, ಪುಷ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಸಾಕಷ್ಟು ಸಮಯ ಸುಮಾರು ನಂತರ ಆಶಾದಾಯಕವಾಗಿ ನೀವು ನಿಲ್ಲಿಸಲು ವಿಲ್ ತದನಂತರ ನಾನು ಪಾಪ್ ಮಾಡಲು ಮತ್ತೊಂದು ಬ್ರೇಕ್ ನೀಡುತ್ತೇನೆ. ಆದರೆ ನಿಜವಾಗಿಯೂ ಅದು ಸಾಕಷ್ಟು ಕೋಡ್ ಅಲ್ಲ. ಅತ್ಯಂತ ಕೋಡ್ ವಿಸ್ತರಣೆಗೆ, ಬಹುಶಃ ವಿಸ್ತರಿಸುವ ವಿಷಯವನ್ನು ಹೊಂದಿದೆ. ಸರಿ, ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ಯಾವುದೇ ಒತ್ತಡ, ಆದರೆ ಎಲ್ಲಿಯವರೆಗೆ ನೀವು ಸರಿಯಾದ ಹಾದಿಯಲ್ಲಿ ಭಾವಿಸುತ್ತಾರೆ ಎಂದು, ಅದು ಒಳ್ಳೆಯದು. 

ಯಾರಾದರೂ ನನ್ನ ಪಡೆದುಕೊಳ್ಳಬಹುದು ಜೊತೆ ಹಾಯಾಗಿರುತ್ತೇನೆ ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿದೆ? ಹೌದು, ಅದನ್ನೇ ತಿನ್ನುವೆ, ಆದರೆ ಯಾರಾದರೂ ನಾನು ಬರಬಹುದು ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿದೆ? ಸರಿ, ನೀವು ಯಾವುದೇ, ಅದನ್ನು ಉಳಿಸಲು, ಪ್ರಾರಂಭಿಸಬಹುದು? ನಾನು ಯಾವಾಗಲೂ ಆ ಹಂತದ ಮರೆಯಬೇಡಿ. ಸರಿ, ಪುಶ್ ನೋಡಿ, ನಿಮ್ಮ ಕೋಡ್ ವಿವರಿಸಲು ಬಯಸುತ್ತೀರಿ? [ವಿದ್ಯಾರ್ಥಿ] ಎಲ್ಲಾ ಮೊದಲ, ನಾನು ಗಾತ್ರ ಹೆಚ್ಚಾಗಿದೆ. ನಾನು ಬಹುಶಃ ನಾನು-ಹೇಗಾದರೂ ಇರಬೇಕು ಊಹೆ, ನಾನು, ಗಾತ್ರ ಹೆಚ್ಚಳ ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಇದ್ದರೆ ಮತ್ತು ನಾನು ನೋಡಿ. ಮತ್ತು ಸಾಮರ್ಥ್ಯ ಕಡಿಮೆ ಇದ್ದರೆ, ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ ವ್ಯೂಹ ಸೇರಿಸಲು. ಇದು ಅಲ್ಲ, ನಾನು, 2 ಸಾಮರ್ಥ್ಯವನ್ನು ಗುಣಿಸಿ ನಾನು ಈಗ ಒಂದು ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯ ಗಾತ್ರದೊಂದಿಗೆ ಕೆಲಸಕ್ಕೆ ತಂತಿಗಳನ್ನು ರಚನೆಯ ಪುನರ್ವಿಂಗಡಿಸು. ಆ ವಿಫಲವಾದಲ್ಲಿ ನಂತರ, ನಾನು ಬಳಕೆದಾರ ಹೇಳುತ್ತೇನೆ, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ ಇದು ಉತ್ತಮ ಇದ್ದರೆ ಮತ್ತು, ನಂತರ ನಾನು ಗದ್ದೆಯನ್ನು ತಂತುವನ್ನು ಪುಟ್. 

[ರಾಬ್ ಬಿ] ನಾವು ಇಲ್ಲಿ ಉತ್ತಮ bitwise ಆಯೋಜಕರು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ 2 ರಿಂದ ಗುಣಿಸುವುದು. ನೆನಪಿಡಿ, ಎಡ ಶಿಫ್ಟ್ ಯಾವಾಗಲೂ 2 x ಏರಲಿದೆ. ನೀವು ಅರ್ಥ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಮಾಹಿತಿ ಹಕ್ಕು ಶಿಫ್ಟ್ ಕಾಲ 2 ರಿಂದ ಭಾಗಿಸಿದಾಗ 2 ಭಾಗಿಸಿ ಒಂದು ಪೂರ್ಣಾಂಕ ರಲ್ಲಿ 2 ರಿಂದ ಭಾಗಿಸಿ. ಇಲ್ಲಿ ಅಥವಾ ಅಲ್ಲಿ ಒಂದು 1 ಮೊಟಕುಗೊಳಿಸಲು ಇರಬಹುದು. ಆದರೆ 1 ಬಿಟ್ಟು ಶಿಫ್ಟ್ ಯಾವಾಗಲೂ, 2 x ಏರಲಿದೆ ನೀವು ಉಕ್ಕಿ ಪೂರ್ಣಾಂಕದ ಪರಿಧಿಯಿಂದ ಹೊರತು, ಮತ್ತು ಅದು ಸಾಧ್ಯವಿಲ್ಲ. ಒಂದು ಅಡ್ಡ ಕಾಮೆಂಟ್. ನಾನು, ಏನು ಇದು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಕೋಡಿಂಗ್ ಬದಲಾಯಿಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ ನೀವು ಆದರೆ ನಾನು ಈ ರೀತಿಯ ಮಾಡಲು ಇಷ್ಟ. ವಾಸ್ತವವಾಗಿ ಇದು ಸ್ವಲ್ಪ ಮುಂದೆ ಮಾಡಲು ಹೋಗುತ್ತದೆ. ಬಹುಶಃ ಇದು ಈ ತೋರಿಸಲು ಪರಿಪೂರ್ಣ ನಿಜವಲ್ಲ ಆದರೆ ಆಫ್ ಈ ಭಾಗಗಳನ್ನು ಖಂಡದ ಇಷ್ಟವಾದಲ್ಲಿ ಈ ಉಂಟಾದರೆ ವೇಳೆ ಸರಿ, ನಂತರ ನಾನು ಏನಾದರೂ ಪಡೆಯಲಿದ್ದೇನೆ ತದನಂತರ ಕಾರ್ಯವನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ನಾನು ಕಾರ್ಯ ಕೆಳಗೆ ನನ್ನ ಕಣ್ಣುಗಳು ಎಲ್ಲ ರೀತಿಯಲ್ಲಿ ಸ್ಕ್ರಾಲ್ ಅಗತ್ಯವಿಲ್ಲ ಬೇರೆ ನಂತರ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು. ಈ ಉಂಟಾದರೆ ವೇಳೆ ಇದು, ನಂತರ ನಾನು ಹಿಂತಿರುಗಿ. ಇದು ಈ ಮೀರಿ ಎಲ್ಲ ಸಂತೋಷವನ್ನು ಅಧಿಕ ಲಾಭ ಹೊಂದಿದೆ ಈಗ ಒಮ್ಮೆ ಬಿಟ್ಟು ವರ್ಗಾಯಿಸಲ್ಪಟ್ಟಿದೆ. ನಾನು ಇನ್ನು ಮುಂದೆ, ಮಾಡಲು ನೀವು ಎಂದಾದರೂ ಹಾಸ್ಯಾಸ್ಪದವಾಗಿ ಉದ್ದ ಸಾಲಿನ ಹತ್ತಿರ ಅಗತ್ಯವಿದೆ , ಆ 4 ಬೈಟ್ಗಳು ಸಹಾಯ ಮಾಡಬಹುದು, ಮತ್ತು ಹೆಚ್ಚು ಎಡ ವಿಷಯ ಕಡಿಮೆ ಸಮಾನ ಸರಿ, ನಾನು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ನೀವು ಭಾವಿಸಿದರೆ ಚಿತ್ತಸ್ಥೈರ್ಯವು ನಾನು ಲೂಪ್ ಒಂದು ಒಂದು ಬೇರೆ ಒಳಗೆ ಒಳಗೆ ಸ್ವಲ್ಪ ಲೂಪ್ ಪ್ರಸ್ತುತ ಆಗಿದ್ದೇನೆ. ಎಲ್ಲಿಯಾದರೂ ನೀವು ನಾನು ರೀತಿಯ ಹಾಗೆ, ತಕ್ಷಣ ಮರಳಿ ಮಾಡಬಹುದು. ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಐಚ್ಛಿಕ ಮತ್ತು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ನಿರೀಕ್ಷೆಯಿಲ್ಲ. 

[ವಿದ್ಯಾರ್ಥಿ] ಅಲ್ಲಿ ಒಂದು ಗಾತ್ರ ಹೀಗಿರಬೇಕು - ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯಲ್ಲಿ? ಇಲ್ಲಿ ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯನ್ನು ನಾವು ಹೌದು, realloc ವಿಫಲವಾಯಿತು ಇದೆ. , ಸಂಭಾವ್ಯವಾಗಿ, ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯಲ್ಲಿ ಹೇಗೆ ಗಮನಿಸಿ ನಾವು ಮುಕ್ತ ಸ್ಟಫ್ ನಂತರ, ನಾವು ಯಾವಾಗಲೂ ವಿಫಲವಾದ ನೀನು ನಾವು ಏನನ್ನಾದರೂ ತಳ್ಳಲು ಪ್ರಯತ್ನಿಸಬಹುದು ಎಷ್ಟು ಬಾರಿ ಯಾವುದೇ. ನಾವು ತಳ್ಳುವುದು ಇದ್ದರೆ, ನಾವು, ಏರಿಕೆಯ ಗಾತ್ರ ಇರಿಸಿಕೊಳ್ಳಲು ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ಏನು ಪುಟ್ಟಿಂಗ್ ಇಲ್ಲದಿದ್ದರೂ ಸಹ. ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ತನಕ ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು ಇಲ್ಲ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಸ್ಟಾಕ್ ಮೇಲೆ ಹೇಳಿಕೆಯ ನಂತರ. ನಾವು ಎರಡೂ ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ, ಹೇಳುತ್ತಾರೆ, ಇದು ಮಾಡಬೇಕಾಗುವುದು. ಬದಲಿಗೆ ≤ ಸಾಮರ್ಥ್ಯ s.size ಹೇಳುವ ಮತ್ತು ನಂತರ, ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಇಲ್ಲಿದೆ ಎಲ್ಲವೂ ಆಗಿತ್ತು ಅಲ್ಲಿ ನಾವು ಹೋದರು ಮಾತ್ರ ಕಾರಣ. 

ಮತ್ತು ನೆನಪಿಡಿ, ನಾವು ಬಹುಶಃ ತಪ್ಪು ಮಾತ್ರ ಹಿಂದಿರುಗಬಹುದು ಎಂದು realloc ಶೂನ್ಯ ಹಿಂದಿರುಗಿದರು ಅಲ್ಲಿ, ಇಲ್ಲಿ ಮತ್ತು ನೀವು ಪ್ರಮಾಣಿತ ದೋಷ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಂಭವಿಸಿದಾಗ ನೀವು ಒಂದು ಶಿಷ್ಟ ದೋಷ ಮುದ್ರಿಸಲು ಎಲ್ಲಿ ಬಹುಶಃ ನಿಮಗೆ, ಈ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ ಪರಿಗಣಿಸಬಹುದಾಗಿದೆ ಬದಲಿಗೆ ಕೇವಲ ಪ್ರಮಾಣಿತ ಔಟ್ ನೇರವಾಗಿ ಮುದ್ರಿಸುವ ಆದ್ದರಿಂದ fprintf stderr. ಮತ್ತೆ, ಒಂದು ನಿರೀಕ್ಷೆ ಅಲ್ಲ, ಆದರೆ ಒಂದು ದೋಷ ವೇಳೆ printf ನಮೂದಿಸಿ, ನಂತರ ನೀವು ಬದಲಿಗೆ ಗುಣಮಟ್ಟದ ಔಟ್ ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿಸಲು ಮಾಡಲು ಬಯಸಬಹುದು. 

ಯಾರಾದರೂ ಗಮನಿಸುವುದು ಬೇರೆ ಏನೂ? ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಮೇಲೆ ಹೋಗಬಹುದು? [ರಾಬ್ ಬಿ] ಹೌದು, ನಿಜವಾದ ಅದರ binariness ಅಥವಾ ಏನು ಅದು? [ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನೀವು 2 ಗುಣಿಸುತ್ತೇವೆ? [ರಾಬ್ ಬಿ] ಹೌದು, ಮೂಲತಃ. ಅವಳಿ ಭೂಮಿ, ನಾವು ಯಾವಾಗಲೂ ಅಂಕೆಗಳು ನಮ್ಮ ಸೆಟ್. ಬಲಭಾಗದ ನಲ್ಲಿ ಇಲ್ಲಿ ಮೂಲಭೂತವಾಗಿ ಒಳಸೇರಿಸಿದನು ಇದು 1 ಈ ಎಡ ಶಿಫ್ಟಿಂಗ್. ಹಿಂದೆ ಇದಕ್ಕೆ ಕೇವಲ ಅವಳಿ ಆ ಎಲ್ಲವನ್ನೂ ನೆನೆದು , 2 ಒಂದು ಶಕ್ತಿ, ಆದ್ದರಿಂದ ಈ 0 2 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ 1 ಈ 2 ಈ 2 2. ಈಗ ಬಲಭಾಗದ ಒಂದು 0 ಅಳವಡಿಸುವುದರ ಮೂಲಕ, ನಾವು ಎಲ್ಲವನ್ನೂ ಮೇಲೆ ರಜೆ. ವಾಟ್ 0 2 ಇದನ್ನು 2 ಈಗ 2 1 2 ಆಗಿರುತ್ತದೆ. ನಾವು ಸೇರಿಸಲಾಗಿದೆ ಎಂದು ಬಲಭಾಗದ ಅಗತ್ಯವಾಗಿ 0 ಏರಲಿದೆ, ಇದು ಅರ್ಥವಿಲ್ಲ. ನೀವು ಎಂದಾದರೂ 2 ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಗುಣಿಸಿದಾಗ, ಇದು, ಬೆಸ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಹಿಂದಿರುಗಬಹುದೆಂದು ಹಾಗೆ 0 ಸ್ಥಳಕ್ಕೆ 2, 0 ಆಗಿರಬೇಕು ನೀವು ಬದಲಾಗುವ ಸಂಭವಿಸಿ ವೇಳೆ ಮತ್ತು ನಾನು ಅರ್ಧದಷ್ಟು ಮೊದಲು ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆ ಏನು ಒಂದು ಪೂರ್ಣಾಂಕದಿಂದ ಬೈಟ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮೀರಿ, ಈ 1 ಆಫ್ ಹೋಗುವ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಹೋಗುತ್ತದೆ. ನೀವು ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ಸಂಭವಿಸಿದಾಗ ಮಾತ್ರ ಆತಂಕಕ್ಕೂ ಇಲ್ಲಿದೆ. ಆದರೆ ಆ ಸಮಯದಲ್ಲಿ, ನಂತರ ನೀವು, ವಸ್ತುಗಳ ಶತಕೋಟಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಹೇಗಾದರೂ ಮೆಮೊರಿ ಸೂಕ್ತವಾಗಿರಬಹುದು ಇರಬಹುದು ಇದು. 

ಈಗ ನಾವು ಸುಲಭವಾಗಿ ಇದು ಪಾಪ್, ಗೆ ಪಡೆಯಬಹುದು. ನೀವು ಒಂದು ಇಡೀ ಗುಂಪೇ ಪಾಪ್ ಸಂಭವಿಸಿದಾಗ ನೀವು ಅದನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಿ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಈಗ ನೀವು ಮತ್ತೆ ಅರ್ಧ ಸಾಮರ್ಥ್ಯವನ್ನು ಆರ್. ನೀವು, ನಿಮ್ಮ ಮೆಮೊರಿ ಪ್ರಮಾಣವನ್ನು ಸಂಕುಚಿಸುತ್ತವೆ realloc ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಆದರೆ ಆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಕೇವಲ realloc ಸಂದರ್ಭದಲ್ಲಿ ಏರಲಿದೆ , ಮೆಮೊರಿ ಕುಗ್ಗುತ್ತಿರುವ ಎಂದಿಗೂ, ಮೆಮೊರಿ ಬೆಳೆಯುತ್ತಿರುವ ಇದು ಪಾಪ್ ಸೂಪರ್ ಸುಲಭವಾಗಿ ಹೋಗುತ್ತದೆ. ರಾಶಿಯನ್ನು ಹಾಗೆ ಹೋಗುವ ಇದು ಈಗ ಸಾಲುಗಳನ್ನು, ಆದರೆ ನೀವು ವಿಷಯಗಳನ್ನು ತೆಗೆಯುವಂತೆ ಆದೇಶ ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ ಇದೆ. ಒಂದು ಕ್ಯೂ ಪ್ರೋಟೊಟಿಪಿಕಲ್ ಉದಾಹರಣೆಗೆ, ಒಂದು ರೇಖೆ ಆದ್ದರಿಂದ ನಾನು ಇಂಗ್ಲೀಷ್ ವೇಳೆ ಊಹೆ, ನಾನು ಹೇಳಿರಬಹುದು ಒಂದು ಸರತಿ ಒಂದು ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ ಕ್ಯೂ ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ಒಂದು ಲೈನ್ನ, ನೀವು ಸಾಲಿನ ಮೊದಲ ವ್ಯಕ್ತಿ ಇಂತಹ, ನೀವು ಸಾಲಿನ ಔಟ್ ಮೊದಲ ವ್ಯಕ್ತಿ ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು. ನೀವು ಸಾಲಿನಲ್ಲಿ ಕೊನೆಯ ವ್ಯಕ್ತಿ, ನೀವು ಸೇವೆಯುಕ್ತ ಕೊನೆಯ ವ್ಯಕ್ತಿ ಎಂದು ಹೋಗುವ. ಸ್ಟಾಕ್ LIFO ನಮೂನೆಯಾಗಿತ್ತು ಆದರೆ ನಾವು ಆ FIFO ಮಾದರಿ ಕರೆ. ಆ ಪದಗಳನ್ನು ಬಹಳ ಸಾರ್ವತ್ರಿಕವಾಗಿವೆ. 

ರಾಶಿಯನ್ನು ಲೈಕ್ ಮತ್ತು ಸರಣಿಗಳ ಭಿನ್ನವಾಗಿ, ಸಾಲುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಮಧ್ಯಮ ಅಂಶಗಳ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ. ಇಲ್ಲಿ, ಒಂದು ಸ್ಟಾಕ್, ನಾವು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಹೊಂದಿರುತ್ತವೆ. ಇಲ್ಲಿ, ನಾವು ಅವುಗಳನ್ನು ಎನ್ಕ್ಯೂ ಮತ್ತು dequeue ಎಂದು ಸಂಭವಿಸಬಹುದು. ನಾನು ಸಹ ಅವರನ್ನು ಶಿಫ್ಟ್ ಮತ್ತು unshift ಎಂದು ಕೇಳಿರಬಹುದು. ನಾನು ಜನರು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಸಾಲುಗಳನ್ನು ಸಹ ಅನ್ವಯಿಸಲು ಹೇಳುತ್ತಾರೆ ಕೇಳಿರುವ. ನಾನು, ತೆಗೆದುಹಾಕಲು, ಸೇರಿಸಲು ಕೇಳಿರಬಹುದು ಆದ್ದರಿಂದ ತಳ್ಳಲು ಮತ್ತು ನೀವು ರಾಶಿಯನ್ನು ಬಗ್ಗೆ, ನೀವು ತಳ್ಳುವುದು ಮತ್ತು ವರ್ಧಿಸುತ್ತಿವೆ, ಪಾಪ್. ನೀವು ಸಾಲುಗಳನ್ನು ಬಗ್ಗೆ ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಬಳಸುವ ಪದಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು ಅಳವಡಿಕೆ ಮತ್ತು ತೆಗೆಯಲು, ಮತ್ತು ಎಂದು ಏನನ್ನು ಒಮ್ಮತ ಇಲ್ಲ. ಆದರೆ ಇಲ್ಲಿ, ನಾವು ಎನ್ಕ್ಯೂ ಮತ್ತು dequeue ಹೊಂದಿರುತ್ತವೆ. ಈಗ, struct ಸ್ಟಾಕ್ struct ಏಕಸ್ವರೂಪದ್ದಾಗಿತ್ತು ಕಾಣುತ್ತದೆ. ಆದರೆ ತಲೆಯ ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಹೊಂದಿವೆ. ಅದನ್ನು ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಊಹಿಸುತ್ತಾರೆ, ಆದರೆ ಏಕೆ ನಾವು ತಲೆ ಬೇಕು? ಮೂಲಮಾದರಿಗಳ ತಳ್ಳಲು ಮತ್ತು ಪಾಪ್ ಮೂಲತಃ ಒಂದೇ. ನೀವು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಎಂದು ನಗರದ. ಒಂದೇ ಒಂದು ವ್ಯತ್ಯಾಸವೆಂದರೆ ಪಾಪ್ ಹಿಂದಿರುಗಿದ-ಬದಲಿಗೆ ಕೊನೆಯ, ಇದು ಮೊದಲ ಹಿಂದಿರುಗಿದ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ. 2, 1, 3, 4, ಅಥವಾ ಏನಾದರೂ. ಮತ್ತು ಇಲ್ಲಿ ಆರಂಭಿಸೋಣ. ನಮ್ಮ ಕ್ಯೂ ಸಂಪೂರ್ಣವಾಗಿ ಪೂರ್ಣ, ಆದ್ದರಿಂದ ನಾಲ್ಕು ಅಂಶಗಳು ಇಲ್ಲ. ನಮ್ಮ ಕ್ಯೂ ಕೊನೆಯಲ್ಲಿ, ಪ್ರಸ್ತುತ 2 ಮತ್ತು ಈಗ ನಾವು ಯಾವುದೋ ತೂರಿಸಲು ಹೋಗಿ. 

ನಾವು ಸ್ಟಾಕ್ ಆವೃತ್ತಿಯ ನಾವು ಏನು ಬೇರೆ ವಿಷಯ, ಸೇರಿಸಲು ಬಯಸಿದರೆ ನಾವು ಮೆಮೊರಿ ನಮ್ಮ ಬ್ಲಾಕ್ ವಿಸ್ತರಿಸಲಾಗಿದೆ. ಈ ಸಮಸ್ಯೆ ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ನೀವು 2 ಸರಿಸಲು. ನಾನು ಸರತಿ ಕೊನೆಯಲ್ಲಿ ಬಗ್ಗೆ ಮೊದಲು ತಿಳಿಸಿದರು, ವಾಟ್ ಈ, 1 ನಾವು ಆರಂಭಿಸುವ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ ನಾವು ನಂತರ dequeue 3, dequeue 4, dequeue 1 ಬಯಸುವ ನಂತರ dequeue 2, ನಂತರ ಈ ಒಂದು dequeue. ನಾವು ಈಗ realloc ಬಳಸುವಂತಿಲ್ಲ ಅಥವಾ ಕನಿಷ್ಟ ಪಕ್ಷ, ನೀವು ಬೇರೆ ರೀತಿಯಲ್ಲಿ realloc ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ. ಆದರೆ ನೀವು ಬಹುಶಃ ಕೇವಲ realloc ಉಪಯೋಗಿಸಬಾರದು. ನೀವು ಕೈಯಾರೆ ನಿಮ್ಮ ಮೆಮೊರಿ ನಕಲಿಸಲು ಹೊಂದಿವೆ ಹೋಗುವ. 

ಮೆಮೊರಿ ನಕಲಿಸಲು ಎರಡು ಕಾರ್ಯಗಳು ಇವೆ. Memcopy ಮತ್ತು memmove ಇಲ್ಲ. ನಾನು ಪ್ರಸ್ತುತ ನೀವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಒಂದು ನೋಡಲು ಮ್ಯಾನ್ ಪುಟಗಳನ್ನು ಓದುವ ನುಡಿದರು. ಸರಿ, memcopy, ವ್ಯತ್ಯಾಸ memcopy ಮತ್ತು memmove, ಒಂದು ಸರಿಯಾಗಿ ಕೇಸ್ ನಿರ್ವಹಿಸುತ್ತದೆ ನೀವು ಪ್ರದೇಶ ಹರಡಿರುತ್ತವೆ ಸಂಭವಿಸಿದರೆ ಒಂದು ಪ್ರದೇಶದ ನಕಲು ನೀವು ಅಲ್ಲಿ ನೀವು ನಕಲಿಸಲು ನೀವು. Memcopy ನಿರ್ವಹಿಸಲು ಇಲ್ಲ. Memmove ಮಾಡುತ್ತದೆ. ನೀವು ಸಮಸ್ಯೆ ನಗರದ ಈಗ, ನಾನು ಈ ವ್ಯಕ್ತಿ ನಕಲಿಸಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ ಈ ವ್ಯಕ್ತಿ ಈ ನಾಲ್ಕು. ಕೊನೆಯಲ್ಲಿ, ರಚನೆಯ ರೀತಿಯಲ್ಲಿ ಎಂಬುದನ್ನು ನೋಡಬೇಕು ನಕಲು ನಂತರ 2, 1, 2, 1, 3, 4, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಕೆಲವು ವಿಷಯವನ್ನು ನಂತರ. ಆದರೆ, ನಾವು ವಾಸ್ತವವಾಗಿ ನಕಲಿಸಿ ಯಾವ ಕ್ರಮದಲ್ಲಿ ಅವಲಂಬಿಸಿದೆ ನಾವು ಪ್ರದೇಶದಲ್ಲಿ ನಾವು ನಕಲು ನೀವು ವಾಸ್ತವವಾಗಿ ಪರಿಗಣಿಸುವುದಿಲ್ಲ ವೇಳೆ ರಿಂದ ಅತಿಕ್ರಮಿಸುತ್ತದೆ ನಾವು ನಕಲು ನೀವು ಒಂದು, ನಂತರ ನಾವು, ಇಲ್ಲಿ ಆರಂಭದ ಇಷ್ಟಪಡುತ್ತೀರಿ ನಾವು ಹೋಗಲು ಬಯಸುವ ಸ್ಥಾನಕ್ಕೇರಿತು 2 ನಕಲು ಇರಬಹುದು ನಂತರ ಮುಂದೆ ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಸಲು. 

ಈಗ ನಾವು ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ ಎಂದು ನೀನು, ಮತ್ತು ಈಗ ನಾವು ನಕಲಿಸಲು ಬಯಸುವ ಈ ವ್ಯಕ್ತಿ ಮೇಲೆ ಗೈ ಮತ್ತು ಮುಂದೆ ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಸಲು. ನಾವು ಪಡೆಯುವಲ್ಲಿ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು, 1, 2, 1, 2, 1 2 ಬದಲಿಗೆ ಸೂಕ್ತ 2, 1, 2, 1, 3, 4 ಏಕೆಂದರೆ 2, 1 ಮೂಲ 3, 4 overrode. Memmove ಸರಿಯಾಗಿ ಎಂದು ನಿಭಾಯಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂಲತಃ ಕೇವಲ ಯಾವಾಗಲೂ memmove ಬಳಸಿ ಇದು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವುದೇ ಕೆಟ್ಟ ಮಾಡುವುದಿಲ್ಲ. ಕಲ್ಪನೆ ಬದಲಿಗೆ ಆರಂಭದಿಂದ ಮತ್ತು ಈ ರೀತಿಯಲ್ಲಿ ನಕಲು ಹೊಂದಿದೆ ನಾವು ಇಲ್ಲಿ ಮಾಡಿದ ಹಾಗೆ, ಅದು, ತುದಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ನಕಲಿಸುತ್ತದೆ ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಸಮಸ್ಯೆ ಎಂದಿಗೂ. ಯಾವುದೇ ಪ್ರದರ್ಶನವನ್ನು ಇಲ್ಲವಾಗುತ್ತದೆ. ಯಾವಾಗಲೂ memmove ಬಳಸಿ. Memcopy ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ. ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ memmove ಮಾಡಲಿಕ್ಕೆ ನೀವು ಅಲ್ಲಿ ಆ ಸ್ ನಿಮ್ಮ ಕ್ಯೂ ನ ಸುತ್ತಿ-ಸುಮಾರು ಭಾಗ. ಚಿಂತಿಸ ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ವೇಳೆ ಅಲ್ಲ. ಈ ಸಂಗ್ರಹವು, ಪುಶ್, ಮತ್ತು ಪಾಪ್ ಹೆಚ್ಚು ಕಷ್ಟ. 

ಯಾರಾದರೂ ನಾವು ಕೆಲಸ ಮಾಡಬಹುದು ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ? ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ವೇಳೆ? [ವಿದ್ಯಾರ್ಥಿ] ಹೌದು, ಇದು ಆದರೂ, ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ಇಲ್ಲಿದೆ. ನಾವು ನೀವು ಪರಿಷ್ಕರಣೆ ಉಳಿಸಲು ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ತನಕ ದಂಡವನ್ನು ಹೊಂದಿದೆ? ನಾನು ಪ್ರತಿಯೊಂದು ಸಮಯ ಮರೆಯಬೇಡಿ. ನಾವು ವಸ್ತುಗಳ ಮರುಗಾತ್ರಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವಾಗ ಸರಿ, ಏನು ನಿರ್ಲಕ್ಷಿಸಿ ಸಂಭವಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣವಾಗಿ ಗಣಕತೆರೆ ನಿರ್ಲಕ್ಷಿಸಿ. ಈ ಕೋಡ್ ವಿವರಿಸಿ. ಗಾತ್ರ ಎಲ್ಲಾ ಮೊದಲ ನಕಲನ್ನು ಕಡಿಮೆ ವೇಳೆ ನಾನು ಮೊದಲ ಎಲ್ಲಾ ತಪಾಸಣೆ ನಾನು ಮತ್ತು ಆ ನಂತರ, ನಾನು ಸೇರಿಸಲು-ನಾನು ತಲೆ + ಗಾತ್ರ, ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಾನು, ಅದು ರಚನೆಯ ಸಾಮರ್ಥ್ಯವನ್ನು ಸುತ್ತಲೂ ಸುತ್ತಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ನಾನು ಸ್ಥಾನದಲ್ಲಿ ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಲು. ನಂತರ ನಾನು ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು ಮತ್ತು ನಿಜವಾದ ಹಿಂತಿರುಗಿ. 

[ರಾಬ್ ಬಿ] ಈ ಖಂಡಿತವಾಗಿಯೂ ನೀವು ಮೋಡ್ ಬಳಸಿ ಬೇಕಿರುವ ಎಂದು ನೀನು ಅಲ್ಲಿ ಆ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನೀವು ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಭಾವಿಸಿದರೆ ನೀವು,, ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಹೊಂದಿದ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವುದೇ ರೀತಿಯ ತಕ್ಷಣದ ಚಿಂತನೆಯ ಮಾಡ್ ಆಗಿರಬೇಕು. ತ್ವರಿತ ಉತ್ತಮಗೊಳಿಸುವಿಕೆ /, ನಿಮ್ಮ ಕೋಡ್ ಒಂದು ಸಾಲು ಸೀಮಿತಗೊಳಿಸಬಹುದು ನೀವು ಲೈನ್ ತಕ್ಷಣ ಈ ಒಂದು ನಂತರ ಗಮನಿಸಿ ಕೇವಲ ಗಾತ್ರ + +, ಆದ್ದರಿಂದ ನೀವು ವಿಲೀನಗೊಳ್ಳಲು ಈ ಮಾರ್ಗ, ಗಾತ್ರ + +. ಕೆಳಗೆ ಇಲ್ಲಿ ಈಗ, ನಾವು ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿವೆ ಅಲ್ಲಿ ನಾವು, ಸಾಕಷ್ಟು ಮೆಮೊರಿ ಇಲ್ಲ ಆದ್ದರಿಂದ ನಾವು 2 ನಮ್ಮ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗುತ್ತಿದೆ. , ನಾನು ಇಲ್ಲಿ ಅದೇ ಸಮಸ್ಯೆ ಎಂದು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ಈಗ ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು ವಿಫಲವಾಗಿದೆ ಅಲ್ಲಿ ವೇಳೆ, ನಂತರ ನೀವು ಮತ್ತೆ 2 ಮೂಲಕ ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಬಯಸುವ ಎಂದು ನೀನು. ಇನ್ನೊಂದು ಸಣ್ಣ ಟಿಪ್ಪಣಿಯನ್ನು ನೀವು ಮಾಡಬಹುದು ಕೇವಲ ಹಾಗೆ + =, ನೀವು << = ಮಾಡಬಹುದು. ಸಮನಾಗಿರುತ್ತದೆ ಮೊದಲು ಸುಮಾರು ಏನು ಹೋಗಬಹುದು, + =, | =, & =, << =. ಚಾರ್ * ಹೊಸ ಮೆಮೊರಿ ನಮ್ಮ ಹೊಸ ಬ್ಲಾಕ್ ಆಗಿದೆ. ಓಹ್, ಇಲ್ಲಿ ಹೆಚ್ಚು. 

ಜನರು ಮೆಮೊರಿ ನಮ್ಮ ಹೊಸ ಬ್ಲಾಕ್ ಮಾದರಿ ಬಗ್ಗೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಚಾರ್ ** ಆಗಿರಬೇಕು. ಅಪ್ ಇಲ್ಲಿ ನಮ್ಮ struct ಯೋಚಿಸುವಾಗ, ತಂತಿಗಳನ್ನು ನಾವು reallocating ಏನು ಆಗಿದೆ. ನಾವು ಸರದಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದು ಸಂಪೂರ್ಣ ಹೊಸ ಕ್ರಿಯಾತ್ಮಕ ಸಂಗ್ರಹಣೆ ಮಾಡುತ್ತಿದ್ದಾರೆ. ನಾವು ನಿಮ್ಮ ತಂತಿಗಳನ್ನು ಗೆ ನಿಯೋಜಿಸುವ ಎಂದು ನೀನು, ಇದೀಗ mallocing ಏನನ್ನು ಹೊಂದಿದೆ ಆದ್ದರಿಂದ ಹೊಸ ಒಂದು ಚಾರ್ ** ಎಂದು ಹೋಗುತ್ತದೆ. ಇದು ತಂತಿಗಳ ಸರಣಿಯಾಗಿರಬೇಕು ಹೋಗುವುದಿಲ್ಲ. ನಾವು ತಪ್ಪು ಮರಳಲು ನೀನು ಯಾವ ಸಂದರ್ಭದಲ್ಲಿ ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಚಾರ್ * ಮಾಡುವುದರಿಂದ ಹೋಗಬೇಕೇ? [ರಾಬ್ ಬಿ] ಹೌದು, ಒಳ್ಳೆಯ ಕರೆ. [ವಿದ್ಯಾರ್ಥಿ] ಏನು ಎಂಬುದು? [ರಾಬ್ ಬಿ] ನಾವು ಯಾವುದೇ ಏಕೆಂದರೆ ಚಾರ್ * ಗಾತ್ರವನ್ನು ಮಾಡಲು ಬಯಸಿದ್ದರು ಕಾಲ sizeof (ಚಾರ್) 1 ಏಕೆಂದರೆ ಈ ವಾಸ್ತವವಾಗಿ ಒಂದು ದೊಡ್ಡ ಸಮಸ್ಯೆ ಎಂದು. Sizeof ಚಾರ್ *, 4 ಏರಲಿದೆ ಆದ್ದರಿಂದ ನೀವು ints ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ ಬಾರಿ ಬಹಳಷ್ಟು, ನೀವು ಹೊರಗೆ ಪಡೆಯಲು ಯಾಕೇಂದರೆ ಇಂಟ್ * ನ ಇಂಟ್ ಮತ್ತು ಗಾತ್ರದ ಗಾತ್ರ ಒಂದು 32 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಒಂದೇ ಮುಂದುವರೆಸುತ್ತೇವೆ. ಆದರೆ ಇಲ್ಲಿ, sizeof (ಅಕ್ಷರ) ಮತ್ತು sizeof (ಚಾರ್ *) ಈಗ ಒಂದೇ ಮುಂದುವರೆಸುತ್ತೇವೆ. 

ನಾವು ತಪ್ಪು ಮರಳಿ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ ಏನು? [ವಿದ್ಯಾರ್ಥಿ] ನ್ಯೂ ಶೂನ್ಯ ಆಗಿದೆ. ಹೊಸ ಶೂನ್ಯ ವೇಳೆ ಹೌದು, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗಿ ನಾನು ಕೆಳಗೆ ಎಸೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ ಇಲ್ಲಿಗೆ [ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ] [ರಾಬ್ ಬಿ] ಹೌದು, ಈ ದಂಡವನ್ನು ಹೊಂದಿದೆ. ನೀವು 2 ಪಟ್ಟು ಸಾಮರ್ಥ್ಯವನ್ನು ಅಥವಾ ಸಾಮರ್ಥ್ಯ ಶಿಫ್ಟ್ 1 ಮತ್ತು ನಂತರ ಕೇವಲ ಇಲ್ಲಿ ಅಥವಾ ಯಾವುದೇ ಅದನ್ನು ಸೆಟ್ ಇಲ್ಲ. ನಾವು ಹಾಗೆ ನಾವು ಅದನ್ನು ಮಾಡುತ್ತೇನೆ. ಸಾಮರ್ಥ್ಯ >> = 1. ಮತ್ತು 1 ಸ್ಥಾನವನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಬಗ್ಗೆ ಚಿಂತೆ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ ನೀವು ನೀವು 1 ವರ್ಗಾಯಿಸಲಾಯಿತು ತೊರೆದರು ಏಕೆಂದರೆ, ಆದ್ದರಿಂದ 1 ಸ್ಥಾನವನ್ನು, ಅತ್ಯವಶ್ಯವಾಗಿ 0 ಆದ್ದರಿಂದ ಬಲ 1 ಬದಲಾಯಿಸುವ, ನೀವು ಇನ್ನೂ ಚೆನ್ನಾಗಿರುತ್ತದೆ ಎಂದು ನೀನು. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ರಿಟರ್ನ್ ಮೊದಲು ಮಾಡಲು ಬೇಕು? [ರಾಬ್ ಬಿ] ಹೌದು, ಈ ಸಂಪೂರ್ಣವಾಗಿ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ. 

ನಾವು ಕೊನೆಗೆ ನಿಜವಾದ ಹಿಂದಿರುಗಿದ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು ಈಗ ಊಹಿಸುತ್ತವೆ. ನಾವು ಈ memmoves ಮಾಡಲು ನೀನು ರೀತಿಯಲ್ಲಿ, ನಾವು ಅವುಗಳನ್ನು ಹೇಗೆ ಜಾಗರೂಕರಾಗಿರಿ ಎಂದು ಅಗತ್ಯವಿದೆ. ಯಾರಾದರೂ ನಾವು ಅವುಗಳನ್ನು ಹೇಗೆ ಯಾವುದೇ ಸಲಹೆಗಳನ್ನು ಹೊಂದಿದೆ? ಇಲ್ಲಿ ನಮ್ಮ ಆರಂಭಿಸೋಣ. ಅನಿವಾರ್ಯವಾಗಿ, ನಾವು ಮತ್ತೆ ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸಲು ಬಯಸುವ ಅಲ್ಲಿಂದ ಮತ್ತು ನಕಲು ವಸ್ತುಗಳು, 1, 3, 4, 2. ನೀವು ಹೇಗೆ ಮಾಡಬೇಕು? ಮೊದಲ, ನಾನು ಮತ್ತೆ memmove ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಲು ಹೊಂದಿವೆ. Memmove, ವಾದಗಳು ಕ್ರಮವನ್ನು ಮುಖ್ಯವಾದವರು. ನಾವು ಮೂಲ ಎರಡನೇ, ಮೂರನೇ ಗಾತ್ರ, ಮೊದಲ ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ಬಯಸುವ. ಮೂಲ ಮತ್ತು ಗಮ್ಯಸ್ಥಾನ ರಿವರ್ಸ್ ಕಾರ್ಯಗಳನ್ನು ಸಾಕಷ್ಟು ಇವೆ. ಗಮ್ಯಸ್ಥಾನ, ಮೂಲ ರೀತಿಯಲ್ಲಿ ಸ್ಥಿರವಾದ ಕಾಣುತ್ತಾರೆ. ವರ್ಗಾಯಿಸುವುದು, ಇದು ಯಾವ ಹಿಂದಿರುಗಿದ ಇದೆ? ಇದು ನೀವು ಬಯಸಬಹುದು ಯಾವುದೇ ಕಾರಣದಿಂದಾಗಿ, ಗಮ್ಯಸ್ಥಾನ ಒಂದು ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ನಾನು ಅದನ್ನು ಓದಬಹುದು ಚಿತ್ರ, ಆದರೆ ನಾವು ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ತೊಡಗಿಸಿಕೊಳ್ಳಲು ಬಯಸುವ. 

ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ಏನು ಏರಲಿದೆ? [ವಿದ್ಯಾರ್ಥಿ] ನ್ಯೂ. [ರಾಬ್ ಬಿ] ಹೌದು, ಮತ್ತು ಅಲ್ಲಿ ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ? ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ ಮೊದಲನೆಯದಾಗಿ ಈ 1, 3, 4. , 4 3 ಈ 1 ಏನು. ಈ 1 ವಿಳಾಸವನ್ನು ಎಂದರೇನು? ಆ 1 ವಿಳಾಸವನ್ನು ಎಂದರೇನು? [ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ] [ರಾಬ್ ಬಿ] ಹೆಡ್ + ಮೊದಲ ಅಂಶ ವಿಳಾಸ. ಹೇಗೆ ನಾವು ರಚನೆಯ ಮೊದಲ ಅಂಶ ಸಿಗುತ್ತದೆ? [ವಿದ್ಯಾರ್ಥಿ] ಸರದಿಗೆ. [ರಾಬ್ ಬಿ] ಹೌದು, q.strings. ನೆನಪಿಡಿ, ಇಲ್ಲಿ, ನಮ್ಮ ತಲೆಯ 1. ಇದು ಡಾರ್ನ್. ನಾನು ಗಿಡ ಮದ್ದಲ್ಲ ಮಾಂತ್ರಿಕವಾಗಿ- ಇಲ್ಲಿ, ನಮ್ಮ ತಲೆಯ 1. ನಾನು ತುಂಬಾ ನನ್ನ ಬಣ್ಣ ಬದಲಾಯಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. ಮತ್ತು ಇಲ್ಲಿ ತಂತಿ ಹೊಂದಿದೆ. ನಾವು ಇಲ್ಲಿ ಮೇಲೆ ಮಾಡಿದಂತೆ ಈ, ನಾವು ಅದನ್ನು ಬರೆಯಬಹುದು ತಲೆಗಳ + q.strings. ಬಹಳಷ್ಟು ಜನರು ಇದನ್ನು ಬರೆಯಲು ಮತ್ತು q.strings [ತಲೆ]. ಈ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಕಡಿಮೆ ಸಮರ್ಥವಾಗಿಲ್ಲ. ನೀವು dereferencing ತದನಂತರ ವಿಳಾಸವನ್ನು ಪಡೆಯುತ್ತಿದ್ದಾರೆ ಎಂದು ನೀವು, ಅದನ್ನು ನಗರದ ಇರಬಹುದು ಆದರೆ ಕಂಪೈಲರ್ q.strings + ತಲೆ, ಹೇಗಾದರೂ ನಾವು ಮೊದಲು ಹೊಂದಿದ್ದರು ಎಂಬುದನ್ನು ಇದು ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ. ನೀವು ನಗರದ ಬಯಸುವ ಯಾವುದೇ ರೀತಿ. 

ಮತ್ತು ಎಷ್ಟು ಬೈಟ್ಗಳು ನಾವು ನಕಲಿಸಿ ಬಯಸುತ್ತೀರಿ? [ವಿದ್ಯಾರ್ಥಿ] ಸಾಮರ್ಥ್ಯ - ತಲೆ. ಸಾಮರ್ಥ್ಯ - ತಲೆ. ತದನಂತರ ನೀವು ಯಾವಾಗಲೂ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಬರೆಯಬಹುದಾದರೆ ಆ ಸರಿ ವೇಳೆ ಔಟ್ ಲೆಕ್ಕಾಚಾರ. [ವಿದ್ಯಾರ್ಥಿ] ಇದು ನಂತರ 2 ಭಾಗಿಸಿ ಅಗತ್ಯವಿದೆ. ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಗಾತ್ರ ಬಳಸಬಹುದೆಂದು ಊಹೆ. ನಾವು ಇನ್ನೂ ಗಾತ್ರ ಹೊಂದಿವೆ- ಗಾತ್ರವನ್ನು ಬಳಸಿ, ನಾವು 4 ಸಮನಾದ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ. ನಮ್ಮ ಗಾತ್ರ 4. ನಮ್ಮ ತಲೆಯ 1. ನಾವು ಈ 3 ಅಂಶಗಳು ನಕಲಿಸಲು ಬಯಸುವ. ಆ ವಿವೇಕದ ಎಂದು ಗಾತ್ರ ಪರೀಕ್ಷಿಸೋಣ - ತಲೆ ಸರಿಯಾಗಿ 3. ನಾವು ಮೊದಲೇ ಹೇಳಿದ ಹಾಗೆ ಮತ್ತು,, ಇಲ್ಲಿ ಮರಳಿ ಬರುವ ನಾವು ಸಾಮರ್ಥ್ಯ ಬಳಸಿದರೆ, ಆಗ 2 ಭಾಗಿಸಿದಾಗ ಮಾಡಿದೆವು ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಸಾಮರ್ಥ್ಯ ಬೆಳೆದ ಮಾಡಿದ ಕಾರಣ, ಆದ್ದರಿಂದ ಬದಲಿಗೆ, ನಾವು ಗಾತ್ರ ಬಳಸಲು ನೀನು. ಆ ಪ್ರತಿಗಳನ್ನು ಭಾಗವು. ಈಗ, ನಾವು ಇತರ ಭಾಗದಲ್ಲಿ, ಆರಂಭ ಉಳಿದಿದ್ದು ಭಾಗವು ನಕಲು ಅಗತ್ಯವಿದೆ. 

ಎಂದು ಯಾವ ಸ್ಥಾನಕ್ಕೆ memmove ಗೆ ವಿಶೇಷವೇನು? [ವಿದ್ಯಾರ್ಥಿ] ಪ್ಲಸ್ ಗಾತ್ರ - ತಲೆ. ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಈಗಾಗಲೇ ಗಾತ್ರದಲ್ಲಿ ನಕಲಿಸಿದ - ತಲೆ ಬೈಟ್ಗಳು, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಉಳಿದ ಬೈಟ್ಗಳು ನಕಲಿಸಲು ಬಯಸುವ ಅಲ್ಲಿ ಹೊಸ ತದನಂತರ ಗಾತ್ರ ಮೈನಸ್ ಜೊತೆಗೆ, ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ನಾವು ಈಗಾಗಲೇ ಸೈನ್ ನಕಲು ಮಾಡಿದ ನಂತರ ಅಲ್ಲಿ ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ? [ವಿದ್ಯಾರ್ಥಿ] Q.strings [0]. [ರಾಬ್ ಬಿ] ಹೌದು, q.strings. ನಾವು ಎರಡೂ ಏನು & q.strings [0]. ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಇದು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ. ಇದು ಕೇವಲ 0 ಎಂದು ವಿಶೇಷವೇನು ವೇಳೆ, ನಂತರ ನೀವು q.strings ನೋಡಿ ಒಲವು ಮಾಡುತ್ತೇವೆ. ನಾವು ನಕಲು ನೀವು ಅಲ್ಲೇ. ನಾವು ನಕಲಿಸಲು ಎಷ್ಟು ಬೈಟ್ಗಳು ಬಿಟ್ಟು ಇಲ್ಲ? >> [ವಿದ್ಯಾರ್ಥಿ] 10. ರೈಟ್. [ವಿದ್ಯಾರ್ಥಿ] ನಾವು 5 ಗುಣಿಸುವುದು ಹೊಂದಿದ್ದೀರಾ - 10 ಬಾರಿ ಬೈಟ್ಗಳು ಅಥವಾ ಏನಾದರೂ ಗಾತ್ರವನ್ನು? ಹೌದು, ಈ ಅಲ್ಲಿ-ಎಂಬುದನ್ನು ನಾವು ನಕಲು ಪಡೆಯುತ್ತವೆ? [ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ] ನಾವು ನಕಲು ಮಾಡುತ್ತಿರುವ ವಿಷಯ ಪ್ರಕಾರ ಯಾವುದು? [ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ] ಆ ಮೂಲವನ್ನೂ ಹೌದು, ಚಾರ್ * ರು ನಾವು ನಕಲು ನೀವು ಆದ್ದರಿಂದ, ನಾವು ಗೊತ್ತಿಲ್ಲ. ಅಲ್ಲದೆ, ಅವರು ಸೂಚಿಸುವ ನೀವು ಅಲ್ಲಿ, ತಂತಿಗಳನ್ನು ನಂತಹ, ನಾವು ಕ್ಯೂ ಮೇಲೆ ತಳ್ಳುವ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಅಥವಾ ಕ್ಯೂ ನಲ್ಲಿಗೆ enqueuing. ಆ ಮೂಲವನ್ನೂ, ನಾವು ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ. ನಾವು ಚಾರ್ * ರು ತಮ್ಮ ಟ್ರ್ಯಾಕ್ ಅಗತ್ಯವಿದೆ. ತಲೆ ಬೈಟ್ಗಳು - ನಾವು ಗಾತ್ರ ನಕಲಿಸಿ ಬಯಸುವುದಿಲ್ಲ. ತಲೆ ಚಾರ್ * ಗಳು, - ನಾವು ಗಾತ್ರ ನಕಲಿಸಲು ಬಯಸುವ ಆದ್ದರಿಂದ ನಾವು sizeof (ಚಾರ್ *) ಈ ಗುಣಿಸುವುದು ನೀನು. ಅದೇ ಕೆಳಗೆ ಇಲ್ಲಿ, ತಲೆ * sizeof (ಚಾರ್ *). 

[ವಿದ್ಯಾರ್ಥಿ] ಯಾವುದರ ಬಗ್ಗೆ [ಕೇಳಿಸುವುದಿಲ್ಲ]? ಇಲ್ಲಿ ಈ ಬಲ? [ವಿದ್ಯಾರ್ಥಿ] ಇಲ್ಲ, ಕೆಳಗಿನ, ಗಾತ್ರ - ತಲೆ. [ರಾಬ್ ಬಿ] ಇಲ್ಲಿ ಈ ಬಲ? ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ. ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕೆಲಸ ಹೋಗುತ್ತದೆ ಹೇಗೆ ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಾವು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಆ ರೀತಿಯ ಗಾತ್ರ ಗುಣಿಸಿದರೆ. ಕೇವಲ, ಇಲ್ಲಿ ಹೆಚ್ಚು ಇಷ್ಟ ಹೊಸ + (ಗಾತ್ರ - ತಲೆ) & ಹೊಸ [- ತಲೆಯ ಗಾತ್ರ] ತದ್ವತ್ ಸಮ ನಾವು, ಸರಿಯಾಗಿ ಕೆಲಸ ನಿರೀಕ್ಷೆ ರವರೆಗೆ ನಾವು ಒಂದು ಇಂಟ್ ರಚನೆಯ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ವೇಳೆ ಏಕೆಂದರೆ, ನಾವು ಅದಕ್ಕೆ ಇಂಟ್-ಸೂಚ್ಯಂಕ ಹಾಗೆ ಆಗಿ ಅಥವಾ 5 ಗಾತ್ರದ ಮತ್ತು ನೀವು 4 ಅಂಶ ಬಯಸಿದರೆ, ನಾವು ಇಂಡೆಕ್ಸ್ ಇಂಟ್ ರಚನೆಯ [4]. ನೀವು don't-[4] ಇಂಟ್ ನ * ಗಾತ್ರ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ, ಮತ್ತು ಅಕ್ಷರಶಃ ಸಮ, ಆದ್ದರಿಂದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಕೇವಲ ತಕ್ಷಣ ನೀವು ಕಂಪೈಲ್ ಈ ಪರಿವರ್ತಿಸಬಹುದು ಹೋಗುವ ಇದೆ. ನೀವು ಆ ಕುರಿತು ಜಾಗರೂಕರಾಗಿರಿ ಅಗತ್ಯವಿದೆ ವಿಷಯ ನೀವು ಗಾತ್ರ ಸೇರಿಸುವ ಮಾಡಿದಾಗ - ತಲೆಗೆ ನೀವು ಒಂದು ಬೈಟ್ ಅಲ್ಲ ಸೇರಿಸಿದ್ದರೆ. ನೀವು ಒಂದು ಬೈಟ್ಗಳು ಅಥವಾ ಯಾವುದೇ ಆಗಿರಬಹುದು, ಒಂದು ಚಾರ್ * ಸೇರಿಸುವುದರಿಂದ ನೀವು. 

ಇತರ ಪ್ರಶ್ನೆಗಳು? ಸರಿ, dequeue ಸುಲಭ ಹೋಗುವ ಇದೆ. ನಾನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದು ನಿಮಿಷದ ನೀಡುತ್ತೇನೆ. ಒಹ್, ನಾನು ಇದೇ ಪರಿಸ್ಥಿತಿಯನ್ನು ಊಹೆ ಅಲ್ಲಿ ಯಾವ ಎನ್ಕ್ಯೂ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಶೂನ್ಯ enqueuing ಬಳಸುತ್ತಿದ್ದರೆ, ಬಹುಶಃ ನಾವು ನಿರ್ವಹಿಸಲು ಬಯಸುವ, ಬಹುಶಃ ನಾವು ಮಾಡುವುದಿಲ್ಲ. ನಾವು ಇಲ್ಲಿ ಮತ್ತೆ ಅದನ್ನು, ಆದರೆ ನಮ್ಮ ಸ್ಟಾಕ್ ಸಂದರ್ಭದಲ್ಲಿ ಅದೇ ಮಾಡುವುದಿಲ್ಲ. ನಾವು ಶೂನ್ಯ ಎನ್ಕ್ಯೂ ವೇಳೆ, ನಾವು ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಬಯಸಬಹುದು. ಯಾರಾದರೂ ನಾನು ಬರಬಹುದು ಕೆಲವು ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ? [ವಿದ್ಯಾರ್ಥಿ] ನಾನು dequeue ಹೊಂದಿರುತ್ತವೆ. ಆವೃತ್ತಿ 2 ಅಂದರೆ ತಪ್ಪಿಲ್ಲ. ನೀವು ವಿವರಿಸಲು ಬಯಸುತ್ತೇನೆ? [ವಿದ್ಯಾರ್ಥಿ] ಮೊದಲನೆಯದು, ಸರದಿಯಲ್ಲಿ ವಿಷಯವೆಂದರೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಗಾತ್ರ 1 ಕೆಳಗೆ ಹೋಗುತ್ತದೆ ಎಂದು. ನೀವು ಹಾಗೆ ಮಾಡಬೇಕು, ಮತ್ತು ನಂತರ ನೀವು ತಲೆ ಹಿಂತಿರುಗಿ ನಂತರ 1 ಅಪ್ ತಲೆ ಸರಿಸಲು. ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಪರಿಗಣಿಸಬೇಕಾಗುತ್ತದೆ ಮೂಲೆಗೆ ಉದಾಹರಣೆ ಇಲ್ಲ. ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ], ನಿಮ್ಮ ತಲೆ ಕೊನೆಯ ಅಂಶ ನಲ್ಲಿ ವೇಳೆ ನಂತರ ನೀವು ತಲೆ ರಚನೆಯ ಹೊರಗಿರುವ ತೋರಿಸಲು ಬಯಸುವುದಿಲ್ಲ. 

ಹೌದು, ಆದ್ದರಿಂದ ಬೇಗ ಮುಖ್ಯಸ್ಥ, ನಮ್ಮ ರಚನೆಯ ಕೊನೆಯ ಹಿಟ್ಸ್ ನಾವು dequeue ಮಾಡಿದಾಗ, ನಮ್ಮ ತಲೆಯ 0 ಮರಳಿ ಮಾಡ್ ಮಾಡಿದ ಮಾಡಬೇಕು. ದುರದೃಷ್ಟವಶಾತ್, ಒಂದು ಹಂತದಲ್ಲಿ ಹಾಗೆ ಮಾಡಬಹುದು. ನಾನು ಬಹುಶಃ ಅದನ್ನು ಸರಿಪಡಿಸಿ ಬಯಸುವ ರೀತಿಯಲ್ಲಿ ಊಹೆ ಈ ನಾವು ಹಿಂದಿರುಗಿದ ಏನನ್ನು, ಒಂದು ಚಾರ್ * ಎಂದು ಹೋಗುತ್ತದೆ ನಿಮ್ಮ ವೇರಿಯಬಲ್ ಹೆಸರು ಬಯಸುತ್ತಾರೆ ಯಾವುದೇ. ನಾವು ನಮ್ಮ ಸಾಮರ್ಥ್ಯಕ್ಕೆ ತಲೆ ಮಾಡ್ ಬಯಸುವ ತದನಂತರ ನಿವೃತ್ತ ಹಿಂತಿರುಗಿ. ಇಲ್ಲಿ ಬಹಳಷ್ಟು ಜನರು ಅವರು ಏನು-ಇರಬಹುದು ಈ-you'll ಸಂದರ್ಭದಲ್ಲಿ ಆಗಿದೆ ಜನರು ಏನು ನೋಡಿ ವೇಳೆ ತಲೆ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ, ತಲೆ ಹಾಗೆ - ಸಾಮರ್ಥ್ಯ. ಮತ್ತು ಕೇವಲ ಮಾಡ್ ಯಾವುದು ಸುತ್ತ ಕಾರ್ಯ. ಹೆಡ್ ಮಾಡ್ = ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚು ಸ್ವಚ್ಛವಾಗಿದೆ ಸಾಮರ್ಥ್ಯ -. ಸುಮಾರು ಸಾಮರ್ಥ್ಯ ತಲೆ ಹೆಚ್ಚು ತಲೆ ಹೆಚ್ಚಿನ ವೇಳೆ ಒಂದು ಜೋಡಣೆಯನ್ನು ಆಫ್ 

ಪ್ರಶ್ನೆಗಳು? ಸರಿ, ನಾವು ಬಿಟ್ಟು ಕೊನೆಯಲ್ಲಿ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ. ನೀವು ಮಾಡಿದರೆ ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿ ನಡವಳಿಕೆ ಕೆಲವು ಬಳಸಬಹುದು ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಮಾಡಿದರೆ, ನಿಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಪಟ್ಟಿಯಲ್ಲಿ ಲಿಂಕ್. ನಾನು ಬಲವಾಗಿ ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಮಾಡುವ ಶಿಫಾರಸು. ನೀವು ಈಗಾಗಲೆ ಒಂದು trie ಮಾಡಿದ ಇರಬಹುದು ಆದರೆ ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಕಷ್ಟವಾಗುತ್ತದೆ. ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಅವರು asymptotically ಉತ್ತಮ ಆರ್. ಆದರೆ, ದೊಡ್ಡ ಬೋರ್ಡ್ ನೋಡಲು ಮತ್ತು ಚೆನ್ನಾಗಿ ಎಂದಿಗೂ ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಮತ್ತು ಅವರು ಹೆಚ್ಚು ಮೆಮೊರಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಎಲ್ಲದರ ಬಗ್ಗೆ ಅಪ್ ಹೆಚ್ಚಿನ ಕೆಲಸ ಕಳಪೆ ಎಂದು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಇದು ಡೇವಿಡ್ Malan ಪರಿಹಾರವೆಂದರೆ ಯಾವಾಗಲೂ ಏನು ಇಲ್ಲಿದೆ ಅವರು ಯಾವಾಗಲೂ ಪೋಸ್ಟ್ಗಳನ್ನು ತನ್ನ trie ಪರಿಹಾರ, ಮತ್ತು ಅವರು ಪ್ರಸ್ತುತ ಅಲ್ಲಿ ನೋಡೋಣ. ಅವರು ಡೇವಿಡ್ ಜೆ, ಅಡಿಯಲ್ಲಿ ಯಾವುದು? ಆತ # 18 ನ, ಆ ಭಯಾನಕ ಕೆಟ್ಟ ಅಲ್ಲ ಆದ್ದರಿಂದ ಮತ್ತು ಉತ್ತಮ ಎಂದು ವಿಶೇಷವೇನು ನೀವು ನಗರದ ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಅಥವಾ ಉತ್ತಮ ಒಂದು trie ಆಫ್ ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಅವರ ಮೂಲ ಪರಿಹಾರ ಕೂಡ ಅಲ್ಲ? Trie ಪರಿಹಾರಗಳನ್ನು RAM ಬಳಕೆಯ ಈ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಹೆಚ್ಚು ಒಲವು ಹಾಗೆ ನಾನು ಭಾವಿಸುತ್ತೇನೆ. 

ಬಹಳ ಮೇಲೆ ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು RAM ಬಳಕೆಯ ಒಂದೇ ಅಂಕೆಗಳನ್ನು ಹೊಂದಿದೆ. ಕೆಳಗೆ ಕೆಳಭಾಗಕ್ಕೆ ಹೋಗಿ, ಮತ್ತು ನಂತರ ನೀವು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಗಮನಕ್ಕೆ ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಬೃಹತ್ RAM ಬಳಕೆಯ ಪಡೆಯಲು ಅಲ್ಲಿ, ಮತ್ತು ಪ್ರಯತ್ನಗಳ ಕಷ್ಟವಾಗುತ್ತದೆ. ಸಂಪೂರ್ಣವಾಗಿ ಇದನ್ನು ಆದರೆ ಶೈಕ್ಷಣಿಕ ಅನುಭವ ಮೌಲ್ಯದ ನೀವು ಮಾಡಿದರೆ. ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಮತ್ತು ಈ ಮೂರು ವಿಷಯಗಳನ್ನು, ಸ್ಟ್ಯಾಕ್ಗಳನ್ನು ಸಾಲುಗಳನ್ನು, ಮತ್ತು ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು, ಎಂದಾದರೂ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಯಾವುದೇ ಭವಿಷ್ಯದ ವಿಷಯ ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಜನಪ್ರಿಯತೆ ಹೊಂದಿವೆ ಹೊಂದಲಿದೆ. ಅವರು ಎಲ್ಲವನ್ನೂ ಕೇವಲ ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿದೆ. 

ಪಟ್ಟಿಗಳನ್ನು ಲಿಂಕ್, ಮತ್ತು ಇಲ್ಲಿ ನಾವು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ನಮ್ಮ ಅನುಷ್ಠಾನ ಎಂದು ಹೋಗುತ್ತದೆ ಎಂದು. ಒಬ್ಬಂಟಿಗನಾಗಿ ಏನು ಸಂಬಂಧ ಇಲ್ಲ ಎಂದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ವಿರುದ್ಧವಾಗಿ ಅರ್ಥ? ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಮಾತ್ರ, ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಬದಲಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಇದು ನಂತರ ಒಂದು ಮುಂಚಿನ ರೀತಿಯಲ್ಲಿ. ಹೌದು, ಹಾಗೆ ಚಿತ್ರ ರೂಪದಲ್ಲಿ, ನಾನು ಏನು ಮಾಡಿದನು? ನಾನು ಎರಡು ವಿಷಯಗಳನ್ನು. ನಾನು ಚಿತ್ರವನ್ನು ಮತ್ತು ಚಿತ್ರವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಚಿತ್ರ ರೂಪದಲ್ಲಿ, ನಮ್ಮ ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು, ಅನಿವಾರ್ಯವಾಗಿ, ನಾವು, ನಮ್ಮ ಪಟ್ಟಿಯ ತಲೆಗೆ ಪಾಯಿಂಟರ್ ಕೆಲವು ತರಹದ ತದನಂತರ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಳಗೆ, ನಾವು, ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿವೆ ಮತ್ತು ಬಹುಶಃ ಈ ಅಂಕಗಳನ್ನು ಶೂನ್ಯ ಗೆ. ಇದು ಒಂದು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನಿಮ್ಮ ವಿಶಿಷ್ಟ ಚಿತ್ರ ಎಂದು ವಿಶೇಷವೇನು. ಎ ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ, ನೀವು ಹಿಂದಕ್ಕೆ ಹೋಗಿ. ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಯಾವುದೇ ನೋಡ್ ಕೊಟ್ಟರೆ, ಆಗ ನೀವು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಪಡೆಯುವುದು ಯಾವುದೇ ನೋಡ್ ಪಟ್ಟಿಯಲ್ಲಿ ಇದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ ವೇಳೆ. ಆದರೆ ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಮೂರನೆಯ ನೋಡ್ ಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು ಒಂದು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಇದ್ದರೆ, ನೀವು ಮೊದಲ ಮತ್ತು ಎರಡನೇ ಗ್ರಂಥಿಗಳು ಪಡೆಯಲು ನೀನು. ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು ಮತ್ತು ತೊಂದರೆಗಳು, ಮತ್ತು ಒಂದು ಸ್ಪಷ್ಟವಾದ ಒಂದು ಇಲ್ಲ ನೀವು ಹೆಚ್ಚು ಗಾತ್ರ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಈಗ ತೋರುಗಡ್ಡಿ ಇಲ್ಲಿ ಕಾಪಾಡುವುದು ಹೊಂದಿರುತ್ತವೆ. ಆದರೆ ನಾವು ಮಾತ್ರ ಒಬ್ಬಂಟಿಗನಾಗಿ ಲಿಂಕ್ ಕೇರ್. 

ನಾವು ಜಾರಿಗೆ ಮಾಡಲಿಕ್ಕೆ ನೀವು ಕೆಲವು ವಿಷಯಗಳನ್ನು. ನಿಮ್ಮ typedef struct ನೋಡ್, ಇಂಟ್ ನಾನು: struct ನೋಡ್ * ಮುಂದಿನ; ನೋಡ್. ಆ typedef ನಿಮ್ಮ ಪ್ರತಿಭೆಯಾಗಿ ಸುಟ್ಟು ಹಾಕಬೇಕು. ರಸಪ್ರಶ್ನೆ 1, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನೋಡ್ ಒಂದು typedef ನೀಡಲು ಹೇಗಿರಬೇಕು ಮತ್ತು ನೀವು ತಕ್ಷಣ ಆ ಕೆಳಗೆ ಗೀಚುವ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಸಹ ಭಾವಿಸಲು ಇಲ್ಲದೆ. ನಾನು ಒಂದೆರಡು ಪ್ರಶ್ನೆಗಳನ್ನು ಊಹೆ, ಏಕೆ ನಾವು ಇಲ್ಲಿ struct ಬೇಕು? ಏಕೆ ನಾವು ನೋಡ್ * ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ? [ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ] ಹೌದು. ಒಂದು ವಸ್ತುವಿನ ಒಂದು ನೋಡ್ ವರ್ಣಿಸಬಹುದು ಮಾತ್ರ ವಿಷಯ ಸ್ವತಃ typedef ಹೊಂದಿದೆ. ಆದರೆ ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಈ struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನದ ಮೂಲಕ ಪಾರ್ಸಿಂಗ್ ರೀತಿಯ ಇರುವಾಗ, ನಾವು, typedef ಪರಿಪೂರ್ಣವಾಗಿರಲಿಲ್ಲವಾದ ಎಷ್ಟು ರಿಂದ, ಇನ್ನೂ ನಮ್ಮ typedef ಮುಗಿಸಿದರು ಮಾಡಿಲ್ಲ ನೋಡ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಆದರೆ struct ನೋಡ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಈ ನೋಡ್ ಇಲ್ಲಿ, ಇದು ಬೇರೆ ಏನು ಎಂದು ಕರೆಯಬಹುದು. ಈ N ಎಂದು ಕರೆಯಬಹುದು. ಇದು ಸಂಯೋಜಿತ ಪಟ್ಟಿ ನೋಡ್ ಎಂದು ಕರೆಯಬಹುದು. ಇದು ಏನು ಎಂದು ಕರೆಯಬಹುದು. ಆದರೆ ಈ struct ನೋಡ್ ಈ struct ನೋಡ್ ಅದೇ ವಿಷಯ ಎಂದು ಅಗತ್ಯವಿದೆ. ಈ ಸಹ ಇಲ್ಲಿ ಹೊಂದಿದೆ ಎಂದು ಕರೆಯುವ, ಮತ್ತು ಆದ್ದರಿಂದ ಕೂಡ ಪ್ರಶ್ನೆ ಎರಡನೇ ಹಂತದಲ್ಲಿ ಉತ್ತರಿಸಿದ ಏಕೆ ಒಂದು ನೀವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಆಫ್ typedefs ನೋಡಿದಾಗ ಬಾರಿ ಸಾಕಷ್ಟು, ಇದು ನೀವು typedef struct ನೋಡುತ್ತಾರೆ ಅಲ್ಲಿ ನೀವು, ಅನಾಮಧೇಯ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ನೋಡುತ್ತಾರೆ struct, ನಿಘಂಟು, ಅಥವಾ ಯಾವುದೇ ಅನುಷ್ಠಾನಕ್ಕೆ. 

ಏಕೆ ಇಲ್ಲಿ ನಾವು ನೋಡ್ ಹೇಳಲು ಬೇಕು? ಏಕೆ ಅನಾಮಿಕ struct ಸಾಧ್ಯವಿಲ್ಲ? ಸರಿಸುಮಾರು ಅದೇ ಉತ್ತರದ. [ವಿದ್ಯಾರ್ಥಿ] ನೀವು struct ಒಳಗೆ ನೋಡಿ ಅಗತ್ಯವಿದೆ. ಹೌದು, struct ಒಳಗೆ ನೀವು struct ಬಿಟ್ಟು ನೋಡಿ ಅಗತ್ಯವಿದೆ. ನೀವು struct ಹೆಸರನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ ಇದು ಅನಾಮಧೇಯ struct ಇದ್ದರೆ, ನೀವು ಸೂಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಮತ್ತು ಕೊನೆಯ ಆದರೆ ಕಡಿಮೆ ಈ ಎಲ್ಲಾ ಇರಬೇಕು ಸ್ವಲ್ಪ ಸರಳವಾಗಿ, ನೀವು ಈ ಕೆಳಗೆ ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ವೇಳೆ ಅವರು ನೀವು ಅರ್ಥ ಸಹಾಯ ವಸ್ತುಗಳ ಈ ರೀತಿಯ ಅರ್ಥ ಇದ್ದರೆ ನೀವು ಏನೋ ಮಾಡುತ್ತಿರುವುದು. ಕಡೆಯದಾಗಿ, ಏಕೆ ಈ struct ನೋಡ್ * ಎಂದು ಹೊಂದಿದೆ? ಏಕೆ ಮುಂದಿನ ನೋಡ್ struct ಸಾಧ್ಯವಿಲ್ಲ? ಮುಂದಿನ struct ಗೆ [ವಿದ್ಯಾರ್ಥಿ] ಪಾಯಿಂಟರ್. ನಾವು ಯಾವ ಅನಿವಾರ್ಯವಾಗಿ ಇಲ್ಲಿದೆ. ಏಕೆ ಮುಂದಿನ struct ನೋಡ್ ಸಾಧ್ಯವಿಲ್ಲ? ಏಕೆ * ಮುಂದಿನ struct ನೋಡ್ ಎಂದು ಹೊಂದಿದೆ? ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಅನಂತ ಆದೇಶಗಳ ಅನಿಸುತ್ತದೆ. ಹೌದು. [ವಿದ್ಯಾರ್ಥಿ] ಇದು ಒಂದು ಎಂದು. ಹೌದು, ನಾವು ಗಾತ್ರವನ್ನು ಅಥವಾ ಏನನ್ನಾದರೂ ಹೇಗೆ ಆಲೋಚಿಸಬೇಕು. ಒಂದು struct ಗಾತ್ರವು ಮೂಲತಃ + ಅಥವಾ - ಇಲ್ಲಿ ಅಥವಾ ಅಲ್ಲಿ ಕೆಲವು ಮಾದರಿ. ಇದು ಮೂಲತಃ struct ವಸ್ತುಗಳನ್ನು ಗಾತ್ರಗಳ ಮೊತ್ತವು ಎಂದು ವಿಶೇಷವೇನು. ಇಲ್ಲಿ ಈ ಹಕ್ಕನ್ನು, ಏನು ಬದಲಿಸದೇ, ಗಾತ್ರ ಸುಲಭ ಎಂದು ಹೋಗುತ್ತದೆ. Struct ನೋಡ್ನ ಗಾತ್ರವು ಮುಂದಿನ ನಾನು + ಗಾತ್ರದ ಗಾತ್ರ ಎಂದು ಹೋಗುತ್ತದೆ. ನಾನು ಗಾತ್ರವನ್ನು 4 ಏರಲಿದೆ. ಮುಂದಿನ ಗಾತ್ರ 4 ಏರಲಿದೆ. Struct ನೋಡ್ನ ಗಾತ್ರವು 8 ಏರಲಿದೆ. ನಾವು * ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, sizeof ಆಲೋಚನೆಯನ್ನೇ ನಂತರ sizeof (I) 4 ಏರಲಿದೆ. Struct ನೋಡ್ನ ಗಾತ್ರವು ಮುಂದಿನ ಮುಂದಿನ struct ನೋಡ್ನ + ಗಾತ್ರ ನಾನು ಗಾತ್ರವನ್ನು ಏರಲಿದೆ ಮುಂದಿನ struct ನೋಡ್ನ ನಾನು + ಗಾತ್ರದ + ಗಾತ್ರ. ಇದು ನೋಡ್ಗಳ ಅನಂತ ರಿಕರ್ಶನ್ ಎಂದು. ಈ ವಿಷಯಗಳನ್ನು ಎಂದು ಹೇಗೆ ಏಕೆ ಇದು. 

ಮತ್ತೆ, ಖಂಡಿತವಾಗಿ, ಎಂದು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಅಥವಾ ಕನಿಷ್ಠ ನೀವು ಸಾಧ್ಯವಾಯಿತು ಎಂದು ಸಾಕಷ್ಟು ಇದು ಅರ್ಥ ಅದು ಹೇಗಿರಬೇಕೆಂಬ ಮೂಲಕ ಕಾರಣ. ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ನೀನು ವಿಷಯಗಳು. ವೇಳೆ ಉದ್ದ ಪಟ್ಟಿ- ನೀವು ಮೋಸ ಮತ್ತು ಸುಮಾರು ಇಟ್ಟುಕೊಳ್ಳಬಹುದಾಗಿತ್ತು ಜಾಗತಿಕ ಉದ್ದ ಅಥವಾ ಏನೋ, ಆದರೆ ನಾವು ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ. ನಾವು ಪಟ್ಟಿಯ ಉದ್ದವನ್ನು ಲೆಕ್ಕ ನೀನು. ನಾವು ಹೊಂದಿದೆ ಎಂದು,, ಎಂದು ಮೂಲತಃ ಒಂದು ಹುಡುಕಾಟ ರೀತಿಯಲ್ಲಿ ಹಾಗೆ ಆದ್ದರಿಂದ ನಾವು ಈ ಪೂರ್ಣಾಂಕ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ವೇಳೆ ನೋಡಲು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿದ್ದಾರೆ. ಸೇರಿಸಿ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ. ಸೇರ್ಪಡಿಸಲಾದ ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ. Insert_sorted ಪಟ್ಟಿಯಲ್ಲಿ ವಿಂಗಡಿಸಲಾದ ಸ್ಥಾನಕ್ಕೆ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ. ಆಫ್ Insert_sorted ರೀತಿಯ ನೀವು ಸೇರಿಸಿ ಬಳಸಲಾಗುತ್ತದೆ ಅಥವಾ ಕೆಟ್ಟ ರೀತಿಯಲ್ಲಿ ಸೇರಿಸಲು ಎಂದಿಗೂ ಊಹಿಸುತ್ತದೆ. 

ನೀವು ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡಿದಾಗ insert_sorted-Insert_sorted ನಮಗೆ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಹೊಂದಿವೆ ಸೇ. ಇದು ಪ್ರಸ್ತುತ 5, 4, 2, ಕಾಣುತ್ತದೆ ಏನು. ನಾನು, ಆದ್ದರಿಂದ ಎಲ್ಲಿಯವರೆಗೆ ಪಟ್ಟಿಯನ್ನು ಸ್ವತಃ ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ಎಂದು, 3 ಸೇರಿಸಲು ಬಯಸುವ ಇದು 3 ಸೇರಿದವನು ಪಡೆಯುವುದು ಸುಲಭ. ನಾನು 2 ಆರಂಭವಾಗುವುದು. ಸರಿ, 3 2 ಹೆಚ್ಚಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಹೋಗುವ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ. ಓಹ್,, 4 ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾನು 3 2 ಮತ್ತು 4 ನಡುವೆ ಹೋಗುತ್ತಿದ್ದೇವೆ ತಿಳಿದಿದೆ ಮತ್ತು ನಾನು ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಎಲ್ಲಾ ಸಂಗತಿಗಳನ್ನು ಸರಿಪಡಿಸಲು ಹೊಂದಿರುತ್ತವೆ. ಆದರೆ ನಾವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ, insert_sorted ಬಳಸಲು ಮಾಡದಿದ್ದಲ್ಲಿ ಇಷ್ಟ ಈಗ ಕೇವಲ, ನಾನು 6 ಮೊದಲೇ ಉದ್ದೇಶಿಸಬೇಕು ಹೇಳುತ್ತಾರೆ ನಂತರ ನನ್ನ ಲಿಂಕ್ ಪಟ್ಟಿ ಈ ಆಗಲು ಹೋಗುತ್ತದೆ. ಈಗ insert_sorted, ನೀವು ಕೇವಲ ಪಡೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ, ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ ಕಾರ್ಯಾಚರಣೆಗಳ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಸಹ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಗಳ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಇದು ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಅಲ್ಲ ಕಾರಣವಾಗಬಹುದು, ಮತ್ತು ಅಷ್ಟೇ. ಆ ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೊಂದಿರುವ ನೀನು ಮುಖ್ಯ ವಸ್ತುಗಳು ಅನುಕೂಲಕರ ಇನ್ಸರ್ಟ್-ಆದ್ದರಿಂದ ಕ್ಲಿಕ್. 

ಇದೀಗ, ಉದ್ದ ಮಾಡಲು ಸಮಯ ಮತ್ತು ಒಳಗೊಂಡಿದೆ ಮತ್ತು ಆ ತಕ್ಷಣದ ತುಲನಾತ್ಮಕ ಆಗಿರಬೇಕು. ಮುಕ್ತಾಯದ ಸಮಯವು ಸಮೀಪಿಸುತ್ತಿದೆ, ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಉದ್ದವನ್ನು ಏನೂ ಅಥವಾ ಒಳಗೊಂಡಿದೆ? ಅವರು ಹೆಚ್ಚುಕಡಿಮೆ ಒಂದೇ ಎಂದು ನೀನು. [ವಿದ್ಯಾರ್ಥಿ] ಉದ್ದ. , ನ ನೋಡಿ ಪರಿಷ್ಕರಣೆ ಲೆಟ್. ಸರಿ. ನೀವು ವಿವರಿಸಲು ಬಯಸುತ್ತೇನೆ? [ವಿದ್ಯಾರ್ಥಿ] ನಾನು ಕೇವಲ ಪಾಯಿಂಟರ್ ನೋಡ್ ರಚಿಸಲು ಮತ್ತು ನಮ್ಮ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಇದು ಮೊದಲ, ಇದನ್ನು ಆರಂಭಿಸಲು, ಮತ್ತು ನಂತರ ನಾನು ಒಂದು seg ತಪ್ಪು ಪಡೆಯಲು ಮತ್ತು ಕೇಸ್ ವೇಳೆ 0 ಹಿಂತಿರುಗಿ ಆದ್ದರಿಂದ ಇದು ಶೂನ್ಯ ಇಲ್ಲಿದೆ ನೀವು ಪರೀಕ್ಷಿಸಿ. ಇಲ್ಲವಾದರೆ, ನಾನು ಮೂಲಕ ಲೂಪ್, ಪೂರ್ಣಾಂಕ ಒಳಗೆ ಗಮನವಿಡುತ್ತಾ ನಾನು ಪಟ್ಟಿಯ ಮುಂದಿನ ಅಂಶ ಪ್ರವೇಶಿಸಲು ನೀವು ಎಷ್ಟು ಬಾರಿ ಮತ್ತು ಅದೇ ಇನ್ಕ್ರಿಮೆಂಟ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಹ, ವಾಸ್ತವಿಕ ಅಂಶ ಪ್ರವೇಶಿಸಲು ತದನಂತರ ನಾನು ನಿರಂತರವಾಗಿ, ಇದು ಶೂನ್ಯ ಇದ್ದರೆ ಚೆಕ್ ನೋಡಿ ಮಾಡಲು ಇದು ಶೂನ್ಯ ಇದ್ದರೆ ಮತ್ತು ಅದು ಸ್ಥಗಿತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಾನು ಪ್ರವೇಶಿಸಲು ನೀವು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. 

[ರಾಬ್ ಬಿ] ಯಾರಾದರೂ ಏನು ಯಾವುದೇ ಕಾಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಿದೆಯೇ? ಈ ದಂಡ ಸರಿಯಾಗಿವೆ ಬುದ್ಧಿವಂತರು ಕಾಣುತ್ತದೆ. [ವಿದ್ಯಾರ್ಥಿ] ನಾನು ನೀವು ನೋಡ್ == ಶೂನ್ಯ ಅಗತ್ಯವಿದೆ ಯೋಚಿಸುವುದಿಲ್ಲ. ಹೌದು, ಆದ್ದರಿಂದ ನೋಡ್ ವೇಳೆ == ಶೂನ್ಯ ರಿಟರ್ನ್ 0. ಆದರೆ ನೋಡ್ == ಶೂನ್ಯ ಈ-OH, ಒಂದು ಸರಿಯಾಗಿವೆ ಸಮಸ್ಯೆ ಇದ್ದರೆ. ಇದು ಕೇವಲ ನೀವು ನಾನು ಹಿಂದಿರುಗಿದ ಮಾಡುತ್ತಿರುವ, ಆದರೆ ಅದು ಈಗ ವ್ಯಾಪ್ತಿ ಅಲ್ಲ. ನೀವು ಇಂಟ್ ನಾನು ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ನಾನು = 0. ನೋಡ್ ಶೂನ್ಯ ವೇಳೆ ಆದರೆ, ನಂತರ ನಾನು ಈಗಲೂ 0 ಏರಲಿದೆ ಮತ್ತು ನಾವು 0 ಮರಳಲು ನೀನು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದೇ ಆದ್ದರಿಂದ. ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ವಿಷಯವಾಗಿ ಘೋಷಣೆ ಇರಿಸಿಕೊಳ್ಳುವುದೇ ಲೂಪ್ ದ ನೋಡ್ ಒಳಗೆ. ನೀವು ಹೇಳುವ-OH ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಯಾವುದೇ. ಈ ಮಾಹಿತಿ ಇರಿಸಿಕೊಳ್ಳಲು ನೋಡೋಣ. ನಾನು ಬಹುಶಃ, ಇಂಟ್ ನಾನು = 0 ಇಲ್ಲಿ ಹಾಕುತ್ತಾನೆ ನಂತರ ನೋಡ್ * ನೋಡ್ = ಇಲ್ಲಿ ಮೊದಲ. ಮತ್ತು ಈಗ ಈ ಬಿಡುಗಡೆ ಪಡೆಯುವ ಹೇಗೆ ಬಹುಶಃ. ಈ ನಾನು ಬರೆದಿದ್ದೇನೆ ಎಂಬುದನ್ನು ಬಹುಶಃ. ನೀವು ಈ ರೀತಿ ಕೂಡ ಕಾಣುವ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಇಲ್ಲಿಯೇ ಕುಣಿಕೆಯ ರಚನೆಯಲ್ಲಿ ಈ ಇಂಟ್ ನಾನು = 0 ನಿಮಗೆ ಸುಮಾರು ನೈಸರ್ಗಿಕ ಆಗಿರಬೇಕು ನಾನು ರಚನೆಯ ಉದ್ದವನ್ನು ಕಡಿಮೆ ನಾನು + +. ನೀವು ಒಂದು ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ ಹೇಗೆ, ಈ ನೀವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ತಿರುಗಿ ಹೇಗೆ. 

ಈ ಹಂತದಲ್ಲಿ ಎರಡನೇ ಪ್ರಕೃತಿ ಇರಬೇಕು. ಮನಸ್ಸಿನಲ್ಲಿ ಆ ಈ ಬಹುತೇಕ ಒಂದೇ ಎಂದು ಹೋಗುತ್ತದೆ. ನೀವು ಸಂಬಂಧಿಸಿದ ಪಟ್ಟಿಯ ಮೇಲೆ ಮರಳಿ ಬಯಸುವ ಎಂದು ನೀನು. ವೇಳೆ ನೋಡ್-ನಾನು ಮೌಲ್ಯ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ. ನೋಡ್ ನಾನು. ಆ ನೋಡ್ನಲ್ಲಿ ಮೌಲ್ಯ = ನಾನು ನಿಜವಾದ ಹಿಂದಿರುಗಿ, ಮತ್ತು ಅಷ್ಟೇ ವೇಳೆ. ಗಮನಿಸಿ ನಾವು ಎಂದಾದರೂ ಸುಳ್ಳು ಮರಳಲು ಕೇವಲ ದಾರಿ ನಾವು ಇಡೀ ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಮರಳಿ ಮತ್ತು ನಿಜವಾದ ಮರಳುವುದಿಲ್ಲ ವೇಳೆ ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಅವರ ಈ ಏನು. ಒಂದು ಅಡ್ಡ ನೋಟ್ ನಾವು ಬಹುಶಃ ಸೇರಿಸಲು ಅಥವಾ ಮೊದಲೇ ಉದ್ದೇಶಿಸಬೇಕು ಗೆ ಸಿಗುವುದಿಲ್ಲ. 

ತ್ವರಿತ ಕೊನೆಯಾಗಿ ಗಮನಿಸಿ. ನೀವು ಸ್ಥಬ್ಧ ಕೀವರ್ಡ್ ನೋಡಿ ವೇಳೆ, ಆದ್ದರಿಂದ ಅವರ ಸ್ಥಿರ ಇಂಟ್ ಎಣಿಕೆ = 0 ಹೇಳಲು ಅವಕಾಶ ನಂತರ ನಾವು ಎಣಿಕೆ ಮಾಡಲು + + ನೀವು ಮೂಲತಃ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು ನಗರದ, ನಾನು ಈ ನಾವು ಉದ್ದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು ಹೇಗೆ ಹೇಳಿದ್ದಾರೆ ಕೂಡ. ನಾನು ಇಲ್ಲಿ ಈ ರೀತಿ, ಮತ್ತು ನಂತರ + + ಎಣಿಕೆ ನುಡಿದರು. ನಾವು ನಮ್ಮ ಎಣಿಕೆ ಏರಿಕೆಯ ಮಾಡಲಾಗುತ್ತದೆ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ನೋಡ್ ನಮೂದಿಸಬಹುದು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ. ಈ ಕೇಂದ್ರದಲ್ಲಿ ಸ್ಥಿರ ಕೀವರ್ಡ್ ಅರ್ಥ ಏನು. ನಾನು ಇಂಟ್ ಎಣಿಕೆ ವೇಳೆ = ನಿಯಮಿತ ಹಳೆಯ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು 0. ಯಾವ ಸ್ಥಿರ ಇಂಟ್ ಎಣಿಕೆ ಎಂದರೆ ಈ ಫೈಲ್ ಒಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು. ಇದು, ಕೆಲವು ಇತರ ಕಡತ ಅಸಾಧ್ಯ ನೀವು ಪ್ರಾರಂಭಿಸಿದ ವೇಳೆ, pset 5 ನಗರದ ಇಷ್ಟ. , ನೀವು ಎರಡೂ speller.c ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು dictionary.c ಹೊಂದಿವೆ ಮತ್ತು ನೀವು speller.c ನಂತರ, ಏನು ಜಾಗತಿಕ ಒಂದು ವಿಷಯ ಘೋಷಿಸಿದ ವೇಳೆ dictionary.c ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು. ಜಾಗತಿಕ ಚರಾಂಕಗಳ ಯಾವುದೇ. ಸಿ ಫೈಲ್ ಪ್ರವೇಶಿಸಬಹುದು ಆದರೆ ಸ್ಥಿರ ಚರಾಂಕಗಳ ಕಡತ ಒಳಗೇ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು ಆದ್ದರಿಂದ ಒಳಗೆ dictionary.c ಆಫ್ ಪದಪರೀಕ್ಷಕ ಅಥವಾ ಒಳಗೆ, ಈ ನನ್ನ ರಚನೆಯ ಗಾತ್ರ ನನ್ನ ವೇರಿಯಬಲ್ ಘೋಷಿಸಲು ಹೇಗೆ ರೀತಿಯ ಅಥವಾ ನಿಘಂಟು ಪದಗಳ ನನ್ನ ಸಂಖ್ಯೆಯ ಗಾತ್ರ. ನಾನು ಯಾರಿಗೂ ಪ್ರವೇಶ ಎಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಘೋಷಿಸಲು ಬಯಸುವುದಿಲ್ಲ ರಿಂದ ನಾನು ಮಾತ್ರ ನನ್ನ ಸ್ವಂತ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅದನ್ನು ಕಾಳಜಿ. 

ಈ ಬಗ್ಗೆ ಒಳ್ಳೆಯದು ಸಂಪೂರ್ಣ ಹೆಸರು ಡಿಕ್ಕಿಯಿಂದ ವಿಷಯವನ್ನು ಹೊಂದಿದೆ. ಕೆಲವು ಫೈಲ್ ಎಣಿಕೆ ಎಂಬ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ವಿಷಯಗಳನ್ನು ತುಂಬಾ ತಪ್ಪು ಹೋಗಿ, ಆದ್ದರಿಂದ ಈ ಚೆನ್ನಾಗಿ ವಸ್ತುಗಳ ಸುರಕ್ಷಿತ ದೂರವಿಟ್ಟಿದೆ, ಮತ್ತು ಕೇವಲ ನೀವು ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಬೇರೆಯವರು ಮಾಡಬಹುದು, ಮತ್ತು ಬೇರೆಯವರು ಎಣಿಕೆ ಎಂಬ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಘೋಷಿಸುತ್ತದೆ ವೇಳೆ, ನಂತರ ಎಣಿಕೆ ಎಂಬ ನಿಮ್ಮ ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ. ಅದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಇಲ್ಲಿದೆ. ಇದು ಒಂದು ಕಡತ ಜಾಗತಿಕ ಅಸ್ಥಿರವಾಗಿದೆ. 

ಏನು ರಂದು ಪ್ರಶ್ನೆಗಳು? ಎಲ್ಲಾ ಸೆಟ್. ಬೈ. [CS50.TV]