C++ ನಲ್ಲಿ ಆಪರೇಟರ್ ಆಯ್ಕೆ ಮತ್ತು ಮೆಮೊರಿ ನಿರ್ವಹಣೆ
ನ ಕಸ್ಟಮ್ ಅನುಷ್ಠಾನಗಳು ಮತ್ತು C++ ನಲ್ಲಿನ ನಿರ್ವಾಹಕರು ಪ್ರಚಂಡ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ಒದಗಿಸುತ್ತಾರೆ. ಈ ನಿರ್ವಾಹಕರು ಡೆವಲಪರ್ಗಳಿಗೆ ತಮ್ಮ ತರಗತಿಗಳಲ್ಲಿ ಮೆಮೊರಿಯ ಹಂಚಿಕೆ ಮತ್ತು ಹಂಚಿಕೆಯ ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತಾರೆ. ಉಪವರ್ಗೀಕರಣವು ಗೊಂದಲಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಆಯ್ಕೆಮಾಡುವಾಗ ಅಳಿಸಿ ವಸ್ತು ನಾಶಕ್ಕಾಗಿ ಆಪರೇಟರ್.
C++ ನಲ್ಲಿ ಆಪರೇಟರ್ ಓವರ್ಲೋಡ್ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ, ಸರಿಯಾದ ಆಯ್ಕೆ ನಿರ್ವಾಹಕರು ನೇರವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಏಕೆಂದರೆ ನಿಜವಾದ ವರ್ಗವು ಹಂಚಿಕೆಯಲ್ಲಿ ತಿಳಿದಿದೆ. ಆದಾಗ್ಯೂ, ಸೂಕ್ತವಾದ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮವಾಗಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಮೂಲ ವರ್ಗದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪಡೆದ ವರ್ಗದ ನಿದರ್ಶನಕ್ಕೆ ಲಿಂಕ್ ಮಾಡಿದಾಗ.
ಮೂಲ ವರ್ಗದ ಪಾಯಿಂಟರ್ ಪಡೆದ ವರ್ಗ ವಸ್ತುವನ್ನು ಅಳಿಸಿದಾಗ, C++ ಅನ್ನು ಬಳಸುತ್ತದೆ ಬೇಸ್ ಅಥವಾ ಪಡೆದ ವರ್ಗದಿಂದ ಆಪರೇಟರ್? ಈ ನಿರ್ಧಾರವು ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮುಕ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಮೇಲೆ ಗಣನೀಯ ಪರಿಣಾಮವನ್ನು ಬೀರುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ಅನನ್ಯ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಅಲ್ಗಾರಿದಮ್ಗಳೊಂದಿಗೆ ತರಗತಿಗಳಲ್ಲಿ.
ಈ ಲೇಖನದಲ್ಲಿ, ಉಪವರ್ಗಗಳು ಅದನ್ನು ಅತಿಕ್ರಮಿಸಿದಾಗ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಆಯ್ಕೆಯನ್ನು g++ ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ. C++ ರನ್ಟೈಮ್ ಯಾವ ರೂಪವನ್ನು ಹೇಗೆ ನಿರ್ಧರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು ನಾವು ಉದಾಹರಣೆಯನ್ನು ಬಳಸುತ್ತೇವೆ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಇದು ಆಚರಣೆಯಲ್ಲಿ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.
| ಆಜ್ಞೆ | ಬಳಕೆಯ ಉದಾಹರಣೆ |
|---|---|
| operator delete | ಇದು ಡಿಲೀಟ್ ಆಪರೇಟರ್ನ ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ಅಳವಡಿಕೆಯಾಗಿದೆ. C++ ನಲ್ಲಿ, ನೀವು ಅತಿಕ್ರಮಿಸಬಹುದು ನಿಮ್ಮ ತರಗತಿಗೆ ಕಸ್ಟಮ್ ಮೆಮೊರಿ ಡಿಲೊಕೇಶನ್ ನಡವಳಿಕೆಯನ್ನು ರಚಿಸಲು. ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ನೋಡಿದಂತೆ, ಮೆಮೊರಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ std ::free(ptr) ಬಳಸಿ ಮುಕ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| operator new | ಅಂತೆಯೇ ಗೆ , ಈ ಕಸ್ಟಮ್ ಅನುಷ್ಠಾನ ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ಮೆಮೊರಿ ಹಂಚಿಕೆ ನಡವಳಿಕೆಯನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. std ::malloc(size) ಬಳಸಿಕೊಂಡು ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಯಾವ ವರ್ಗವು ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಿದೆ ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಕಸ್ಟಮ್ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಲು ಇದನ್ನು ಬಳಸಲಾಯಿತು. |
| virtual destructor | ವಸ್ತುವನ್ನು ಅಳಿಸಲು ಬೇಸ್ ಕ್ಲಾಸ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸುವಾಗ, ದಿ ಸೂಕ್ತ ವಿಧ್ವಂಸಕನನ್ನು ಕರೆಯುತ್ತದೆ. ಉದಾಹರಣೆಯಲ್ಲಿ, X ಮತ್ತು ArenaAllocatedX ಎರಡೂ ಮೆಮೊರಿ ಡೀಲೊಕೇಶನ್ ಅನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ. |
| gtest | ದಿ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಲು ಫ್ರೇಮ್ವರ್ಕ್ (GoogleTest) ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದು ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ಡೀಲೊಕೇಶನ್ ಕ್ರಿಯೆಗಳನ್ನು ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. |
| ASSERT_EQ | ನಿಂದ ಈ ಮ್ಯಾಕ್ರೋ ಎರಡು ಮೌಲ್ಯಗಳು ಸಮಾನವಾಗಿದ್ದರೆ ಗ್ರಂಥಾಲಯವು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಪರೀಕ್ಷಾ ಕೋಡ್ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸರಳೀಕೃತವಾಗಿದ್ದರೂ, ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಮೆಮೊರಿ ಸ್ಥಿತಿಗಳನ್ನು ಅಥವಾ ಅಳಿಸುವಿಕೆ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೋಲಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು. |
| vptr | vptr ಎಂಬುದು ವರ್ಚುವಲ್ ಫಂಕ್ಷನ್ಗಳೊಂದಿಗೆ ತರಗತಿಗಳಿಗೆ ಸೇರಿಸಲಾದ ಗುಪ್ತ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಇದು ವರ್ಚುವಲ್ ಕಾರ್ಯಗಳ ವಿಳಾಸಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ವರ್ಚುವಲ್ ಟೇಬಲ್ (VTable) ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ತಿಳುವಳಿಕೆ ವಸ್ತುವಿನ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರದ ಆಧಾರದ ಮೇಲೆ ಸೂಕ್ತವಾದ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಏಕೆ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. |
| VTable | ಎ (ವರ್ಚುವಲ್ ಟೇಬಲ್) ಎನ್ನುವುದು ವರ್ಚುವಲ್ ವಿಧಾನಗಳೊಂದಿಗೆ ಪ್ರತಿ ವರ್ಗಕ್ಕೆ ವರ್ಚುವಲ್ ಫಂಕ್ಷನ್ಗಳ ಉಲ್ಲೇಖಗಳನ್ನು ನಿರ್ವಹಿಸುವ ರಚನೆಯಾಗಿದೆ. ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಪಡೆದ ವರ್ಗಗಳಿಗೆ ಸೂಕ್ತವಾದ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ನಿರ್ಧರಿಸುವಲ್ಲಿ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. |
| malloc | ದಿ ಕಾರ್ಯವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ. ಕಸ್ಟಮ್ ನೇರ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗೆ ಒತ್ತು ನೀಡಲು ಮತ್ತು ವಿಭಿನ್ನ ಹಂಚಿಕೆ ಅಲ್ಗಾರಿದಮ್ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ ಹೆಚ್ಚು ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸಲು ಹೊಸದಕ್ಕೆ ಬದಲಾಗಿ ಬಳಸಲಾಗಿದೆ. |
ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಮತ್ತು C++ ನಲ್ಲಿ ಆಪರೇಟರ್ ಆಯ್ಕೆಯನ್ನು ಅಳಿಸಿ
ಹಿಂದೆ ನೀಡಲಾದ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು C++ ಹೇಗೆ ಸೂಕ್ತ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ ಎಂಬುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಉಪವರ್ಗದ ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಆಪರೇಟರ್. C++ ಅನ್ನು ಓವರ್ಲೋಡ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಅಳಿಸಿ ಕಸ್ಟಮ್ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ಡೀಲೊಕೇಶನ್ ಅಲ್ಗಾರಿದಮ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಆಪರೇಟರ್ಗಳು. ಉಪವರ್ಗಗಳು ತಮ್ಮ ಮೂಲ ವರ್ಗಗಳಿಗಿಂತ ವಿಭಿನ್ನ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಅಗತ್ಯತೆಗಳನ್ನು ಹೊಂದಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಪ್ರಸ್ತುತವಾಗಿದೆ. ಉದಾಹರಣೆ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು ಮೂಲ ವರ್ಗವನ್ನು ರಚಿಸುವ ಮೂಲಕ ಇದನ್ನು ತೋರಿಸುತ್ತವೆ ಮತ್ತು ಒಂದು ಉಪವರ್ಗ ಅರೆನಾ ಅಲೋಕೇಟೆಡ್ ಎಕ್ಸ್, ಎರಡೂ ಕಸ್ಟಮ್ ಅನುಷ್ಠಾನಗಳೊಂದಿಗೆ ಹೊಸ ಮತ್ತು ಅಳಿಸಿ ನಿರ್ವಾಹಕರು.
ಮೊದಲ ಲಿಪಿಯಲ್ಲಿ, ದಿ ಮತ್ತು ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ಮುಕ್ತಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಂದೇಶಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಆಪರೇಟರ್ಗಳು ಓವರ್ಲೋಡ್ ಆಗಿರುತ್ತಾರೆ. ಮೂಲ ವರ್ಗ ಒಂದೇ ಅನುಷ್ಠಾನವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಉಪವರ್ಗ ಅರೆನಾ ಅಲೋಕೇಟೆಡ್ ಎಕ್ಸ್ ಅದನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ. ಯಾವ ಆವೃತ್ತಿಯನ್ನು C++ ಹೇಗೆ ನಿರ್ಧರಿಸುತ್ತದೆ ಎಂಬುದು ಮುಖ್ಯ ಟೇಕ್ಅವೇ ಅಳಿಸಿ ವಸ್ತು ನಾಶವಾದಾಗ ಬಳಸಲು ಆಪರೇಟರ್. ಎರಡಕ್ಕೂ ಸರಿಯಾದ ಆಪರೇಟರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ X ಮತ್ತು ಅರೆನಾ ಅಲೋಕೇಟೆಡ್ ಎಕ್ಸ್, ವಸ್ತುವಿನ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರವು ಇದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಪಾಯಿಂಟರ್ ಪ್ರಕಾರವಲ್ಲ (ಇದು )
ಎರಡನೆಯ ಸ್ಕ್ರಿಪ್ಟ್ ಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ ಮತ್ತು . ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ C++ ವರ್ಚುವಲ್ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ರವಾನಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇವು ಅತ್ಯಗತ್ಯ. ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ VTable ನಲ್ಲಿ ಒಳಗೊಂಡಿಲ್ಲವಾದರೂ, ವಸ್ತುವಿನ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರದ ಆಧಾರದ ಮೇಲೆ ಸರಿಯಾದ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಆಹ್ವಾನಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವಲ್ಲಿ ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ. ವಿಧ್ವಂಸಕನು ಖಾತರಿಪಡಿಸುತ್ತಾನೆ ಯಾವಾಗ a ಪಾಯಿಂಟರ್ a ಗೆ ಸೂಚಿಸುತ್ತದೆ ಅರೆನಾ ಅಲೋಕೇಟೆಡ್ ಎಕ್ಸ್ ವಸ್ತು, ಉಪವರ್ಗದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಅಂತಿಮ ಸ್ಕ್ರಿಪ್ಟ್ GoogleTest ಚೌಕಟ್ಟನ್ನು ಬಳಸಿಕೊಂಡು ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸೂಕ್ತವಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಘಟಕ ಪರೀಕ್ಷೆಯು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನಾವು ಬಳಸುತ್ತೇವೆ ಬೇಸ್ ಮತ್ತು ಸಬ್ಕ್ಲಾಸ್ಗಳೆರಡೂ ಆಯಾ ಆಪರೇಟರ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಮೊರಿಯನ್ನು ಸರಿಯಾಗಿ ನಿಯೋಜಿಸುತ್ತವೆ ಮತ್ತು ಅಳಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು. ಇದು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು ಅಥವಾ ಸೂಕ್ತವಲ್ಲದ ಒಪ್ಪಂದಗಳು ಸಂಭವಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಅವಲಂಬಿಸಿರುವ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ ಪ್ರಮುಖವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚಿನ ವೇಗದ ಅಗತ್ಯವಿರುವ ಸಾಫ್ಟ್ವೇರ್ನಲ್ಲಿ.
ಒಟ್ಟಾರೆಯಾಗಿ, ಈ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು C++ ಆಪರೇಟರ್ ಓವರ್ಲೋಡಿಂಗ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳ ಅಗತ್ಯವನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ ಮತ್ತು ಆನುವಂಶಿಕ ಶ್ರೇಣಿಗಳಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರದ ನಿರ್ಣಯವನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ. VTable ನ ಯಂತ್ರಶಾಸ್ತ್ರ ಮತ್ತು ಪಾತ್ರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಏಕೆ ಸೂಕ್ತ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ ಆಪರೇಟರ್ ಅನ್ನು ರನ್ಟೈಮ್ನಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ, ಮೂಲಭೂತ ಮತ್ತು ಸಂಕೀರ್ಣ ವರ್ಗ ಶ್ರೇಣಿಗಳಲ್ಲಿ ಸರಿಯಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಮತ್ತು C++ ನಲ್ಲಿ ಆಪರೇಟರ್ ಆಯ್ಕೆಯನ್ನು ಅಳಿಸಿ
ಉಪವರ್ಗಗಳು ಅದನ್ನು ಅತಿಕ್ರಮಿಸಿದಾಗ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಹೇಗೆ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ತನಿಖೆ ಮಾಡಲು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಶುದ್ಧ C++ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಸರಿಯಾದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಕಾರ್ಯವಿಧಾನಗಳೊಂದಿಗೆ ನಾವು ವರ್ಗ ಮತ್ತು ಉಪವರ್ಗಗಳಲ್ಲಿ ಪರ್ಯಾಯ ಆಪರೇಟರ್ ಓವರ್ಲೋಡ್ಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇವೆ.
#include <iostream>#include <cstdlib>struct X {void* operator new(std::size_t size) {std::cout << "new X\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {std::cout << "new ArenaAllocatedX\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
ಆಪರೇಟರ್ ಅಳಿಸುವಿಕೆಗಾಗಿ C++ ನಲ್ಲಿ VTable ಪರಿಶೋಧನೆ
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ವರ್ಚುವಲ್ ಟೇಬಲ್ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಮತ್ತು ಡಿಲೀಟ್ ಆಪರೇಟರ್ಗಳನ್ನು ಹೇಗೆ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ. VTable ನ ರಚನೆಯನ್ನು ನೋಡಲು g++ ಕಂಪೈಲರ್ನ ಫ್ಲ್ಯಾಗ್ಗಳು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಮೆಮೊರಿ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಉಪಕರಣಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
#include <iostream>#include <cstdlib>struct X {virtual ~X() { std::cout << "X destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}};struct ArenaAllocatedX : public X {virtual ~ArenaAllocatedX() { std::cout << "ArenaAllocatedX destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
C++ ನಲ್ಲಿ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆಗಳು
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮತ್ತು ಅಳಿಸುವಿಕೆ ಸನ್ನಿವೇಶಗಳೆರಡಕ್ಕೂ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆಪರೇಟರ್ ಅಳಿಸುವ ವಿಧಾನಗಳನ್ನು ಸರಿಯಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು GoogleTest ನಂತಹ C++ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟುಗಳನ್ನು ಅವಲಂಬಿಸಿದೆ.
#include <iostream>#include <gtest/gtest.h>struct X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~ArenaAllocatedX() = default;};TEST(MemoryTest, DeleteX) {X* x = new X();delete x;ASSERT_EQ(1, 1); // Simplified check}TEST(MemoryTest, DeleteArenaAllocatedX) {X* x = new ArenaAllocatedX();delete x;ASSERT_EQ(1, 1); // Simplified check}int main(int argc, char argv) {::testing::InitGoogleTest(&argc, argv);return RUN_ALL_TESTS();}
ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಮೀರಿ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
C++ ನಲ್ಲಿ, ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯು ಯಾವುದನ್ನು ನಿರ್ಧರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅಳಿಸಿದಾಗ, ವಿಶೇಷವಾಗಿ ಉಪವರ್ಗದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಬಳಸಲು ಆಪರೇಟರ್. ಅಂತಹ ನಿದರ್ಶನಗಳಲ್ಲಿ, ರನ್ಟೈಮ್ನಲ್ಲಿ ವಸ್ತುವಿನ ನಿಜವಾದ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸಲು C++ ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್ ಪರಿಕಲ್ಪನೆಯನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದು ಅವಶ್ಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಮೂಲ ವರ್ಗದ ಉಲ್ಲೇಖವು ಪಡೆದ ವರ್ಗದ ವಸ್ತುವನ್ನು ಸೂಚಿಸಿದಾಗ, ಪಡೆದ ವರ್ಗದ ಡಿಸ್ಟ್ರಕ್ಟರ್ ಮತ್ತು ಡಿಲೀಟ್ ಆಪರೇಟರ್ ಅನ್ನು ಕರೆಯಬೇಕು.
ನೀಡಿರುವ ಉದಾಹರಣೆಯಲ್ಲಿ, ಮೂಲ ವರ್ಗ ಮತ್ತು ಉಪವರ್ಗ ಅವರ ಸ್ವಂತ ಆವೃತ್ತಿಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ಅಳಿಸಿ ನಿರ್ವಾಹಕರು. ವಸ್ತುವನ್ನು ತೆಗೆದುಹಾಕಿದಾಗ, C++ ಅದರ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಶೀಲಿಸುತ್ತದೆ (ವರ್ಚುವಲ್ ಪಾಯಿಂಟರ್) ತಂತ್ರ. ಡಿಸ್ಟ್ರಕ್ಟರ್ ವರ್ಚುವಲ್ ಆಗಿದ್ದು, ಅಳಿಸುವಿಕೆಯ ಅನುಕ್ರಮವು ಉಪವರ್ಗದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ವಸ್ತುವಿನ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರಕ್ಕೆ ಸರಿಯಾದ ಅಳಿಸುವಿಕೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಆಹ್ವಾನಿಸುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ಉಪವರ್ಗದಿಂದ ನಿಯೋಜಿಸಲಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸೂಕ್ತವಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಲು ಈ ವಿಧಾನವು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಈ ನಡವಳಿಕೆಯ ಮತ್ತೊಂದು ಗಮನಾರ್ಹ ಅಂಶವೆಂದರೆ C++ ನೇರವಾಗಿ ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ ಮತ್ತು ನಲ್ಲಿ ನಿರ್ವಾಹಕರು . ಬದಲಾಗಿ, ಸರಿಯಾದ ಅಳಿಸುವಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಆಹ್ವಾನಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ರನ್ಟೈಮ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಈ ವಿಧಾನವಿಲ್ಲದೆ, ಬೇಸ್ ಕ್ಲಾಸ್ ಪಾಯಿಂಟರ್ ಮೂಲಕ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನಾಶಪಡಿಸುವುದು ಅಪೂರ್ಣ ಮೆಮೊರಿ ಡಿಲೊಕೇಶನ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸದೆ ಬಿಡುತ್ತದೆ. ಇದು C++ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಶ್ರೇಣಿಗಳಲ್ಲಿ ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಕಸ್ಟಮ್ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ಬಳಸಿದಾಗ.
C++ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು
- ನ ಉದ್ದೇಶವೇನು C++ ನಲ್ಲಿ?
- ಎ ಬೇಸ್ ಕ್ಲಾಸ್ ಪಾಯಿಂಟರ್ ಮೂಲಕ ವಸ್ತುವನ್ನು ತೆಗೆದುಹಾಕಿದಾಗ, ಪಡೆದ ವರ್ಗಕ್ಕೆ ಡಿಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ ಎಂದು ಭರವಸೆ ನೀಡುತ್ತದೆ. ಇದು ಸರಿಯಾದ ಸಂಪನ್ಮೂಲ ಶುದ್ಧೀಕರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ಮಾಡುತ್ತದೆ ಆಪರೇಟರ್ VTable ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆಯೇ?
- ಇಲ್ಲ, ದಿ ಆಪರೇಟರ್ ಅನ್ನು VTable ನಲ್ಲಿ ಇರಿಸಲಾಗಿಲ್ಲ. ವಿಧ್ವಂಸಕನು ವರ್ಚುವಲ್ ಆಗಿದ್ದು, ಸೂಕ್ತವೆಂದು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ ವಸ್ತುವಿನ ಡೈನಾಮಿಕ್ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ ಆಪರೇಟರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ.
- C++ ಹೇಗೆ ನಿರ್ಧರಿಸುತ್ತದೆ ಕರೆ ಮಾಡಲು ಆಪರೇಟರ್?
- C++ ಮೂಲಕ ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ (ವರ್ಚುವಲ್ ಪಾಯಿಂಟರ್) ಸೂಕ್ತವಾದದನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅಳಿಸಲಾದ ವಸ್ತುವಿನ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ ಆಪರೇಟರ್.
- ಏಕೆ ಆಗಿದೆ ಉಪವರ್ಗ ಅಳಿಸುವಿಕೆಯಲ್ಲಿ ಮುಖ್ಯವಾದುದು?
- ದಿ VTable ಅನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ, ಇದು ಡಿಸ್ಟ್ರಕ್ಟರ್ನಂತಹ ವರ್ಚುವಲ್ ಫಂಕ್ಷನ್ಗಳ ವಿಳಾಸಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದು ಸೂಕ್ತವಾದ ಆವೃತ್ತಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಉಪವರ್ಗದ ವಸ್ತುವನ್ನು ಅಳಿಸಿದಾಗ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
- ನಾನು ಎರಡನ್ನೂ ಅತಿಕ್ರಮಿಸಬಹುದೇ? ಮತ್ತು C++ ನಲ್ಲಿ?
- ಅತಿಕ್ರಮಿಸುತ್ತಿದೆ ಮತ್ತು ಉದಾಹರಣೆಯಲ್ಲಿ ವಿವರಿಸಿದಂತೆ ಯಾವುದೇ ತರಗತಿಯಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ಹಂಚಲಾಗುತ್ತದೆ ಮತ್ತು ಮುಕ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ArenaAllocatedX.
ಸೂಕ್ತವಾದ ಆಯ್ಕೆ C++ ನಲ್ಲಿ ಆಪರೇಟರ್ಗೆ ವರ್ಚುವಲ್ ಡಿಸ್ಟ್ರಕ್ಟರ್ಗಳು ಮತ್ತು ಡೈನಾಮಿಕ್ ಪ್ರಕಾರಗಳು ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ. ಉಪವರ್ಗವು ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಕಾರ್ಯಗಳನ್ನು ಅತಿಕ್ರಮಿಸಿದಾಗ, ವಸ್ತುವಿನ ವಿನಾಶಕ್ಕೆ ಸೂಕ್ತವಾದ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು ಕಂಪೈಲರ್ ಖಾತರಿಪಡಿಸುತ್ತದೆ.
ಈ ವಿಧಾನವು ಮೆಮೊರಿ ಸೋರಿಕೆಯಿಂದ ರಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಉಪವರ್ಗ-ನಿರ್ದಿಷ್ಟ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗಳು ಮತ್ತು VTable ಅನ್ವೇಷಣೆಯ ಮೂಲಕ, ಕೋರ್ಸ್ C++ ಆನುವಂಶಿಕತೆಯ ಈ ನಿರ್ಣಾಯಕ ಅಂಶವನ್ನು ಮತ್ತು ಭಾಷೆಯು ಮೆಮೊರಿ ಡೀಲೊಕೇಶನ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಬೆಳಗಿಸುತ್ತದೆ.
- ಆಯ್ಕೆಗೆ ಸಂಬಂಧಿಸಿದ ವಿಷಯ C++ ನಲ್ಲಿನ ನಿರ್ವಾಹಕರು ಅಧಿಕೃತದಲ್ಲಿ ಕಂಡುಬರುವ ಮಾಹಿತಿಯನ್ನು ಆಧರಿಸಿದೆ C++ ಉಲ್ಲೇಖ ದಾಖಲಾತಿ .
- ಕಂಪೈಲರ್ ನಡವಳಿಕೆ ಮತ್ತು VTable ಉತ್ಪಾದನೆಯ ವಿವರಗಳನ್ನು ಒದಗಿಸಿದ ಸಂಪನ್ಮೂಲಗಳ ಮೂಲಕ ಅನ್ವೇಷಿಸಲಾಗಿದೆ GCC ದಾಖಲೆ .
- ಉದಾಹರಣೆ ಕೋಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪರೀಕ್ಷಿಸಲಾಗಿದೆ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಲಾಗಿದೆ ಕಂಪೈಲರ್ ಎಕ್ಸ್ಪ್ಲೋರರ್ (ಗಾಡ್ಬೋಲ್ಟ್) ವಿವಿಧ ಕಂಪೈಲರ್ಗಳಲ್ಲಿ ನೈಜ-ಸಮಯದ ಸಂಕಲನ ನಡವಳಿಕೆಯನ್ನು ಅನುಕರಿಸುವ ಸಾಧನ.