[ಸಂಗೀತ] ಡೌಗ್ LLOYD: ಸರಿ ಸಲಹೆ ಇಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು. ನೀವು ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ ಇದ್ದರೆ ನೀವು ಮೊದಲ ಮಾಡಲು ಬಯಸಬಹುದು ಕಚೇರಿ. ಈ ವೀಡಿಯೊ ಏಕೆಂದರೆ ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ರೀತಿಯಲ್ಲಿ. 

ಆದ್ದರಿಂದ ಮಾತನಾಡಲು ಹೋಗುವುದಿಲ್ಲ ಕೆಲವು ವಿಚಾರಗಳನ್ನು ಕುರಿತು ನಾವು ಆವರಿಸುವ ವೀಡಿಯೊ ಪಾಯಿಂಟರ್ಸ್, ಮತ್ತು ನಾವು ನೀವು ಈಗ ಅವುಗಳನ್ನು ಮೇಲೆ ಟಿಪ್ಪಣಿ ಹೋಗುವ, ಅವರು ಈಗಾಗಲೇ ಎಂಬುದನ್ನು ಊಹಿಸಿಕೊಂಡು ರೀತಿಯ ಅರ್ಥ. ಇದರಿಂದ ಕೇವಲ ನಿಮ್ಮ ನ್ಯಾಯೋಚಿತ ಎಚ್ಚರಿಕೆ ಇಲ್ಲಿದೆ ನೀವು ಈ ವೀಡಿಯೊ ನೋಡಿದ ಬಳಸುತ್ತಿದ್ದರೆ ಮತ್ತು ನೀವು ನೋಡಿಲ್ಲ ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ, ಇದು ಬಹುಶಃ ರೀತಿಯ ನಿಮ್ಮ ತಲೆಯ ಮೇಲೆ ಸ್ವಲ್ಪ ಹಾರುತ್ತವೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಉತ್ತಮ ಇರಬಹುದು ಆ ದೃಷ್ಟಿಯಿಂದ ಇದು ವೀಕ್ಷಿಸಲು. 

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

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

ನಾವು ಇಷ್ಟ ಅಲ್ಲ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಎಷ್ಟು ಐಟಂಗಳನ್ನು ನಮೂದಿಸಿ ನೀವು ಅಗತ್ಯವಿದೆ ಭಾವಿಸುತ್ತೇನೆ. ಸರಿ ಊಹೆ ತಪ್ಪು ಏನು ವೇಳೆ? ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ರೀತಿಯ ನಮಗೆ ರೀತಿಯಲ್ಲಿ ಅನುಮತಿಸುತ್ತದೆ ಈ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರ. ಮತ್ತು ರೀತಿಯಲ್ಲಿ ಅದು ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಲ್ಪಡುತ್ತದೆ. 

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

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

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

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

ಮೆಲ್ಲಾಕ್ ನೀವು ಯಾವುದೇ ನೀಡಲು ಆಗದಿದ್ದರೆ ಮೆಮೊರಿ ನೀವು ರನ್ ಔಟ್ ಮಾಡಿದ ಕಾರಣ, ಇದು ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ನೀವು ನೀಡುತ್ತೇನೆ. ನೀವು ನಾವು ಏನಾಗುತ್ತದೆ ನೆನಪಿದೆಯೇ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್? ನಾವು, ಒಂದು seg ತಪ್ಪು ಸಹಿಸಲಿ ಎಂದು ಬಹುಶಃ ಉತ್ತಮ ಅಲ್ಲ. 

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

ಇಂಟ್ X. ನಾವು ಬಹುಶಃ ಮಾಡಿದ ಬಾರಿ ಗುಂಪೇ, ಬಲ? ಈ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಸೃಷ್ಟಿಸುತ್ತದೆ ಸ್ಟಾಕ್ ಮೇಲೆ ಜೀವಿಸುವ ಎಕ್ಸ್. ಹೇಗೆ ನಾವು ಸಕ್ರಿಯವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಇಲ್ಲ? ಇಂಟ್ ಸ್ಟಾರ್ px malloc 4 ಸಮನಾಗಿರುತ್ತದೆ. 

ಅಥವಾ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿ ನಾವು ಇಂಟ್ ಸ್ಟಾರ್ px ಹೇಳುವೆನು ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ ಕೇವಲ ಕೆಲವು ಕಡಿಮೆ ಎಸೆಯಲು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಸುಮಾರು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಗಳು. ಇದು ನಮಗೆ ಪಡೆಯಲು ಹೋಗುತ್ತದೆ ರಾಶಿ ಮೆಮೊರಿ ನಾಲ್ಕು ಬೈಟ್ಗಳು, ಮತ್ತು ಪಾಯಿಂಟರ್ ನಾವು ಪಡೆಯಲು ಮರಳಿ px ಕರೆಯಲಾಗುತ್ತದೆ. ನಂತರ ನಾವು ಮಾಡಿದ ಕೇವಲ ನಾವು ಹಿಂದೆ ಮಾಡಿದ ಮಾಡಬಹುದು px ಆಗಿರುತ್ತದೆ, dereference ಮೆಮೊರಿ ಪ್ರವೇಶಿಸಲು. ಹೇಗೆ ನಾವು ಬಳಕೆದಾರ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಇಲ್ಲ? ನಾವು ಇಂಟ್ X ಇಂಟ್ ಪಡೆಯಲು ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಬಹುದು. ಆ ಬಹಳ ಸರಳ ಇಲ್ಲಿದೆ. ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ ಏನು ಸ್ಟಾಕ್ ಜೀವಿಸುವ ಫ್ಲೋಟ್ಗಳು x? ಆ ಹೆಸರು stack_array-- ಚಲಿಸುವಂತೆ ನಮ್ಮ ಸರಣಿ ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು x ನ. ಅದು ನಮಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ ಸ್ಟಾಕ್ ಜೀವಿಸುವ ಫ್ಲೋಟ್ಗಳು x. ನಾವು ಫ್ಲೋಟ್ಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಬಹುದು ಅದೂ, ರಾಶಿ ವಾಸಿಸುತ್ತಾನೆ. ವಾಕ್ಯ ಕಂಡುಬರುವಂತಹ , ಹೆಚ್ಚು ತೊಡಕಿನ ಸ್ವಲ್ಪ ಆದರೆ ನಾವು ಫ್ಲೋಟ್ ಹೇಳಬಹುದು ಸ್ಟಾರ್ heap_array ಸಮನಾಗಿರುತ್ತದೆ malloc X ಬಾರಿ ಫ್ಲೋಟ್ ಗಾತ್ರ. ನಾನು ಹಿಡಿದಿಡಲು ಸಾಕಷ್ಟು ಕೊಠಡಿ ಅಗತ್ಯವಿದೆ ಎಕ್ಸ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳ. ಹಾಗಾಗಿ 100 ಅಗತ್ಯವಿದೆ ಹೇಳುತ್ತಾರೆ ಫ್ಲೋಟ್ಗಳು, ಅಥವಾ 1,000 ಫ್ಲೋಟ್ಗಳು. ಆ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಎಂದು 100 ಫ್ಲೋಟ್ಗಳು 400 ಬೈಟ್ಗಳು, ಅಥವಾ 1,000 ಫ್ಲೋಟ್ಗಳು 4,000 ಬೈಟ್ಗಳು, ಪ್ರತಿ ಫ್ಲೋಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ ಜಾಗವನ್ನು ನಾಲ್ಕು ಬೈಟ್ಗಳು. 

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

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

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

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

ಆದ್ದರಿಂದ ನಾವು ಮಾಡುತ್ತೇವೆ ಹೇಳುತ್ತಾರೆ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮಧ್ಯದಲ್ಲಿ, ನಾವು 50 ಪಾತ್ರಗಳು malloc ಬಯಸುವ. ನಾವು ಒಂದು ರಚನೆ malloc ಬಯಸುವ 50 ಪಾತ್ರಗಳು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು. ಮತ್ತು ನಾವು ಮತ್ತೆ ಒಂದು ಪಾಯಿಂಟರ್ ಪಡೆದಾಗ ಆ ಪಾಯಿಂಟರ್ ಹೆಸರು ಪದ. ನಾವು ನೀವು ಏನೇ ಮಾಡಲು ಪದ ಮಾಡಲು ಹೋಗುವ, ಮತ್ತು ನಾವು ಇರುವಾಗ ನಾವು ಅದನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ. ಮತ್ತು ಈಗ ನಾವು ಆ 50 ಹಿಂದಿರುಗಿವೆ ಮತ್ತೆ ವ್ಯವಸ್ಥೆಗೆ ಮೆಮೊರಿ ಬೈಟ್ಗಳು. ಕೆಲವು ಇತರ ಕಾರ್ಯ ಅವುಗಳನ್ನು ಬಳಸಬಹುದು. ನಾವು ಒಂದು ಬಳಲುತ್ತಿರುವ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ನಾವು ಪದ ಬಿಡುಗಡೆ ಏಕೆಂದರೆ. ನಾವು ಮತ್ತೆ ಮೆಮೊರಿ ನೀಡಿದ್ದೇನೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಕೆಲಸ ಮುಗಿಸಿದ್ದೀರಿ. ಆದ್ದರಿಂದ ಮೂರು ಇವೆ ಎಂದು ಮಾಡಬೇಕು ಗೋಲ್ಡನ್ ನಿಯಮಗಳು ನೀವು ಬಂದ ಮನದಲ್ಲಿಟ್ಟುಕೊಂಡಿರಬೇಕು ಸಕ್ರಿಯವಾಗಿ ಮೆಮೊರಿ ಹಂಚುತ್ತಾರೆ malloc ಜೊತೆ. ಮೆಮೊರಿ ಪ್ರತಿ ಬ್ಲಾಕ್ ಎಂದು ನೀವು malloc ಬಿಡುಗಡೆ ಮಾಡಬೇಕು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೊದಲು ಚಲಿಸುತ್ತಿರುವ ಮುಗಿಸಿದ. ಈಗ ಮತ್ತೆ, ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅಥವಾ ಐಡಿಇ ಈ ರೀತಿಯ ಹೇಗಾದರೂ ನೀವು ನಡೆಯುತ್ತದೆ you-- ಈ ಹೇಗಾದರೂ ಸಂಭವಿಸುತ್ತದೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸ್ಥಗಿತಗೊಳಿಸಿದರೆ, ಅದು ಬಳಸುತ್ತಿದ್ದ ಎಲ್ಲಾ ಮೆಮೊರಿ ಬಿಡುಗಡೆಯಾಗಲಿದೆ. ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮ ಕೋಡಿಂಗ್ ಇಲ್ಲಿದೆ ಅಭ್ಯಾಸ ಯಾವಾಗಲೂ, ನೀವು ಪೂರೈಸಿದಾಗ, ನೀವು mallocd ಏನು ಮುಕ್ತಗೊಳಿಸಲು. 

ಎಂದು, ಕೇವಲ ವಿಷಯಗಳನ್ನು ನೀವು mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು ಬಂದಿದೆ. ನೀವು ಜಡವಾಗಿ ಘೋಷಿಸಿದ ವೇಳೆ ಒಂದು ಪೂರ್ಣಾಂಕ, ಇಂಟ್ X ಅರೆ ಕೊಲೊನ್, ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಾನೆ, ನೀವು ಆಗ x ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುವುದಿಲ್ಲ. ನೀವು ಬಂದಿದೆ ಆದ್ದರಿಂದ ಕೇವಲ ವಿಷಯಗಳನ್ನು mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು. 

ಮತ್ತು ಕೊನೆಯದಾಗಿ, ಎರಡು ಬಾರಿ ಉಚಿತವಾಗಿ ಏನಾದರೂ. ಆ ಕಾರಣವಾಗಬಹುದು ಮತ್ತೊಂದು ವಿಲಕ್ಷಣ ಪರಿಸ್ಥಿತಿ. ನೀವು ಮಾಡಿದ ಎಂದು ಆದ್ದರಿಂದ ಎಲ್ಲವೂ mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು. ನೀವು ಬಂದಿದೆ ಮಾತ್ರ ವಸ್ತುಗಳು malloc ಬಿಡುಗಡೆ ಮಾಡಬೇಕು. ಮತ್ತು ಎರಡು ಬಾರಿ ಉಚಿತವಾಗಿ ಏನಾದರೂ. 

ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಗೆ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ ಕೆಲವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿತವಾದ ಏನು ಮೆಮೊರಿ ಮಿಶ್ರ ರೀತಿ ಇರಬಹುದು ಕೆಲವು ಸ್ಥಿರ ಮೆಮೊರಿ ರಲ್ಲಿ. ಇಲ್ಲಿ ಏನು ಆಗಬಹುದೆಂದು? ನೀವು ಅನುಸರಿಸಬಹುದು ನೋಡಲು ಜೊತೆಗೆ ಮತ್ತು ಇಲ್ಲಿದೆ ಊಹೆ ನಾವು ಹೋಗಿ ಎಂದು ಸಂಭವಿಸಿ ಹೋಗಿ ಕೋಡ್ ಎಲ್ಲಾ ಈ ಸಾಲುಗಳ ಮೂಲಕ. 

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

ನಾನು ನಂತರ ಇಂಟ್ ನಕ್ಷತ್ರ ಏನು ಹೇಳಬಹುದು ವೇಳೆ? ಸರಿ ಸಾಕಷ್ಟು ಹೋಲುವ ಇಲ್ಲಿದೆ. ನಾನು ಬಾಕ್ಸ್ ಎಂಬ ರಚಿಸಲು ನಾನು. ಹಿಡಿದಿರುವುದು ಇಂಟ್ ಸಾಮರ್ಥ್ಯವನ್ನು ನಕ್ಷತ್ರಗಳು, ಪೂರ್ಣಾಂಕಗಳ ಪಾಯಿಂಟರ್ಸ್. ಆದ್ದರಿಂದ ನಾನು ಸಹ ಹಸಿರು ರೀತಿಯಲ್ಲಿ ಬಣ್ಣ ಬಾಗುತ್ತೇನೆ. 

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

ಇಂಟ್ ನಕ್ಷತ್ರ ಬಿ ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ. ಈ ಒಂದು ಸ್ವಲ್ಪ ಟ್ರಿಕಿ ಇರಬಹುದು. ಎರಡನೇ ಟೇಕ್ ಮತ್ತು ನೀವು ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಈ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ಏನಾಗುವುದು ನಿರೀಕ್ಷಿಸಬಹುದು. ಇಂಟ್ ನಕ್ಷತ್ರ ಬಿ ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ. 

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

ನಾವು ಇದು mallocd. ಅದನ್ನು ರಾಶಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಆದರೆ ಬಿ ಹೆಸರನ್ನು ಹೊಂದಿದೆ. ಇದು ಬಿ ಎಂಬ ಪಾಯಿಂಟರ್ ವೇರಿಯೇಬಲ್ ನ. ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಾನೆ. 

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

ಒಂದು ಬಿ ಸಮನಾಗಿರುತ್ತದೆ. ಸರಿ ಇಲ್ಲಿ ಇನ್ನೊಂದು ಒಂದು ಇಲ್ಲಿದೆ. ಒಬ್ಬ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ. ಏನು ತೀರುತ್ತದೆ ರೇಖಾಚಿತ್ರ ಈ ಬಾರಿ? 

ಸರಿ ಸ್ಮರಿಸುತ್ತಾರೆ ಹುದ್ದೆ ಆಯೋಜಕರು ಕೃತಿಗಳು ಮೇಲೆ ಮೌಲ್ಯ ನಿಯೋಜಿಸುವ ಮೂಲಕ ಬಲ ಎಡ ಮೌಲ್ಯಕ್ಕೆ. ಮೀ ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಒಂದು ತೋರುಗಡ್ಡಿ, ಈಗ ಬಿ ಅಂಕಗಳನ್ನು ಅದೇ ಸ್ಥಳದಲ್ಲಿ ಸೂಚಿತವಾಗಿರುತ್ತದೆ. ಒಂದು, ಒಂದು B ಬಿಂದುವಿನವರೆಗೆ ಇಲ್ಲ ಅಲ್ಲಿ ಬೌ ಅಂಕಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ. 

ಚೂಪಾದ ಎಂದು ಬೌ ವೇಳೆ ಎಂದು ಒಂದು ವನ್ನಾಗಲಿ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ ಎಂದು. ಬದಲಿಗೆ ಒಂದು ಬೌ ಮೇಲೆ ಕೇವಲ ಸಮನಾಗಿರುತ್ತದೆ ಅರ್ಥ ಮತ್ತು ಬಿ ಈಗ , ಒಂದೇ ವಿಳಾಸ ಏಕೆಂದರೆ ಸೂಚಿಸುವ ಬಿ ಒಳಗೆ ಕೇವಲ ಒಂದು ವಿಳಾಸ. ಈಗ ಒಂದು ಒಳಗೆ ಅದೇ ವಿಳಾಸ. ಮೀ ಬಹುಶಃ = 10 ಹೆಚ್ಚಿನ ನೇರ ವಿಷಯ ನಾವು ಸ್ವಲ್ಪ ಮಾಡಿದ. ಬಾಕ್ಸ್ 10 ಹಾಕಿ. ಸ್ಟಾರ್ ಬೌ ಮೀ ಸಮನಾಗಿರುತ್ತದೆ ಜೊತೆಗೆ 2, ಮರುಪಡೆಯಲು ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ ಏನು ಸ್ಟಾರ್ ಬಿ ಅರ್ಥ. ನಾವು dereference ಬಿ ಮತ್ತು ಹಾಕಲು ನೀನು ಮೆಮೊರಿ ಸ್ಥಳ ಕೆಲವು ಮೌಲ್ಯವನ್ನು. ಈ ಸಂದರ್ಭದಲ್ಲಿ 12 ರಲ್ಲಿ. 

ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಪಾಯಿಂಟ್ dereference ನಾವು ಬಾಣದ ಕೆಳಗೆ ಪ್ರಯಾಣ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ. ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು ಮೆಮೊರಿ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ನಾವು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಕುಶಲತೆಯಿಂದ. ನಾವು ಅಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಪುಟ್. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಟಾರ್ ಬಿ ಮೀ ಸಮನಾಗಿರುತ್ತದೆ ಜೊತೆಗೆ 2 ಕೇವಲ ವೇರಿಯಬಲ್ ಹೋಗಿ, ಬಿ ಮೂಲಕ ತೋರಿಸಿದರು ಮೆಮೊರಿ ಹೋಗಿ, ಬಿ ಮೂಲಕ ತೋರಿಸಿದರು ಮತ್ತು 12, ಹಾಗಾದರೆ ಮೀ ಜೊತೆಗೆ 2 ಪುಟ್. 

ಈಗ ನಾನು ಬಿ ಫ್ರೀ. ನಾನು ಬಿ ಫ್ರೀ ಏನಾಗುತ್ತದೆ? ನಾನು ಮುಕ್ತ ಎಂದರೆ ಏನು ಹೇಳಿದರು ನೆನಪಿಡಿ. ನಾನು ಬಿ ಫ್ರೀ ನಾನು ಹೇಳುತ್ತಿರುವುದು? 

ನಾನು ಕೆಲಸ ಇದನ್ನು ಬಾಗುತ್ತೇನೆ? ನಾನು ಮೂಲಭೂತವಾಗಿ ಮೆಮೊರಿ ಬಿಟ್ಟುಕೊಡಲು. ನಾನು ವ್ಯವಸ್ಥೆಗೆ ಇದು ಮತ್ತೆ ನೀಡಿ. ನಾನು ಈ ಎಲ್ಲಿಯೂ ಅಗತ್ಯವಿಲ್ಲ ನಾನು ಅದರಲ್ಲಿ ಹೇಳುವ ನಾನು? 

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

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

ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ ಈ CS50 ಹೊಂದಿದೆ.