Debug code
ದೋಷಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಅಥವಾ ದೋಷದ ಕಾರಣವನ್ನು ನಿರ್ಧರಿಸಲು ಸಹಾಯ ಮಾಡಲು ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಂಗೆ ಪರಿಚಯಿಸಲಾದ ಕಂಪ್ಯೂಟರ್ ಕೋಡ್ ಡೀಬಗ್ ಕೋಡ್ ಆಗಿದೆ. ಪ್ರೋಗ್ರಾಂನ ಕೆಲವು ಹಂತಗಳಲ್ಲಿ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲು ಇದು ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞೆಯಂತೆ ಸರಳವಾಗಿರಬಹುದು. ಆಧುನಿಕ ಸಮಗ್ರ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳು ಕೆಲವೊಮ್ಮೆ ಪ್ರೋಗ್ರಾಂನ ನಿರ್ದಿಷ್ಟ ಸ್ಥಳಗಳಲ್ಲಿ ಸ್ಟಾಪ್ ಪಾಯಿಂಟ್ಗಳನ್ನು ಇರಿಸಲು ಅವಕಾಶ ನೀಡುವ ಮೂಲಕ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಔಟ್ಪುಟ್ ಬದಲಿಗೆ ಐಡಿಇ ಮೂಲಕ ಅಸ್ಥಿರಗಳ ಮೌಲ್ಯವನ್ನು ನೋಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಇದನ್ನು ಅನಗತ್ಯವಾಗಿಸುತ್ತವೆ. ಡೀಬಗ್ ಕೋಡ್ನ ಬಳಕೆಗಳು ಡೀಬಗ್ ಕೋಡ್ನ ಮುಖ್ಯ ಕಾರ್ಯವೆಂದರೆ ಡೀಬಗ್ ಕೋಡ್ಗೆ ಸಹಾಯ ಮಾಡುವುದು. ಮುದ್ರಣ ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸುವುದು, ಆಜ್ಞೆಗಳನ್ನು ದೃಢೀಕರಿಸುವುದು ಮತ್ತು ಘಟಕ ಪರೀಕ್ಷೆಯಂತಹ ಹಲವಾರು ವಿಧಾನಗಳಲ್ಲಿ ಇದನ್ನು ಮಾಡಬಹುದು. ಕೋಡಿಂಗ್ನಲ್ಲಿ ಬಳಸಿ ಪ್ರೋಗ್ರಾಂನೊಳಗಿನ ದೋಷಗಳ ಉಪಸ್ಥಿತಿ ಮತ್ತು ಸ್ಥಳವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಣ್ಣ ಹೇಳಿಕೆಗಳನ್ನು ಕೋಡ್ಗೆ ಸೇರಿಸಬಹುದು. ಪ್ರೋಗ್ರಾಂ ಸ್ವೀಕರಿಸಲು ಸಾಧ್ಯವಾಗಬಹುದಾದ ಸಂಭವನೀಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅನುಕರಿಸಲು ಪರೀಕ್ಷಾ ಒಳಹರಿವುಗಳನ್ನು ಒದಗಿಸಲು ಸಹ ಇದನ್ನು ಬಳಸಬಹುದು. ಇನ್ನೂ ಅಭಿವೃದ್ಧಿಯ ಹಂತದಲ್ಲಿರುವ ಕೋಡ್ಗೆ ಪ್ಲೇಸ್ ಹೋಲ್ಡರ್ ಆಗಿಯೂ ಇದನ್ನು ಬಳಸಬಹುದು. ವೀಡಿಯೊ ಆಟಗಳಲ್ಲಿ ಬಳಸಿ ಅನೇಕ ವೀಡಿಯೊ ಗೇಮಿಂಗ್ ಮೋಡ್, ಚೀಟ್ ಕೋಡ್ಗಳು, ಉದಾಹರಣೆಗೆ ಲೆವೆಲ್ ಚೀಟ್ ಕೋಡ್, ಇನ್ವಿನ್ಸಿಬಿಲಿಟಿ, ಇತ್ಯಾದಿ. ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಮತ್ತು/ಅಥವಾ ಪರೀಕ್ಷಕರು ಪರೀಕ್ಷಿಸಬೇಕಾದ ಆಟದ ಭಾಗಗಳಿಗೆ ವೇಗವಾಗಿ ಹೋಗುವುದನ್ನು ತಡೆಯುವ ಅಡೆತಡೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಅನುವು ಮಾಡಿಕೊಡಲು ಮೂಲತಃ ಡೀಬಗ್ ಕೋಡ್ ಆಗಿ ಪರಿಚಯಿಸಲಾಯಿತು; ಮತ್ತು ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಚೀಟ್ ಮೋಡ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಡೀಬಗ್ ಮೋಡ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್ಗಳ ಉತ್ಪಾದನಾ ಆವೃತ್ತಿಗಳಿಂದ ಡೀಬಗ್ ಮಾಡುವ ಕೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವೆಂದು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ, ಏಕೆಂದರೆ ಅದು ಅವುಗಳನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕೆಲವು ಆಟಗಳು ಈ ಆಜ್ಞೆಗಳನ್ನು ಮತ್ತು ವಂಚನೆಗಳನ್ನು ಆಟಗಾರರಿಗೆ ತಮ್ಮ ಆಟದ ಅನುಭವವನ್ನು ಹೆಚ್ಚಿಸುವ ಮಾರ್ಗವಾಗಿ ಬಳಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ದಿ ಎಲ್ಡರ್ ಸ್ಕ್ರಾಲ್ಸ್ ವಿಃ ಸ್ಕೈರಿಮ್ನ ಪಿಸಿ ಆವೃತ್ತಿಯು ಆಟಗಾರರಿಗೆ ಕಮಾಂಡ್ ಕನ್ಸೋಲ್ಗೆ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಅವರ ಆಟದ ಕೆಲವು ಅಂಶಗಳನ್ನು ಚಲಾಯಿಸುತ್ತಿರುವಾಗ ಮಾರ್ಪಡಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ. ಈ ಆಜ್ಞೆಗಳಲ್ಲಿ ಆಟಗಾರನಿಗೆ ಅಜೇಯತೆ, ಟೆಲಿಪೋರ್ಟೇಶನ್ ಮತ್ತು ಅನಿಯಮಿತ ಚಿನ್ನವನ್ನು ನೀಡುವುದು ಸೇರಿದೆ. ಡೀಬಗ್ ಕೋಡ್ ಪ್ರಿಂಟ್ ಡೀಬಗ್ಗಿನ ಉದಾಹರಣೆಗಳು ಪ್ರಿಂಟ್ ಡೀಬಗ್ಗಿಂಗ್ ಎಂದರೆ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮತ್ತು ಪ್ರತ್ಯೇಕಿಸಲು ಮುದ್ರಣ ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸುವುದು. ಕೋಡ್ ತುಣುಕಿನ ದತ್ತಾಂಶ ಮೌಲ್ಯಗಳ ಹರಿವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಇದನ್ನು ಬಳಸಬಹುದು. ಈ ರೀತಿಯ ಡೀಬಗ್ ಕೋಡ್ ಕೆಲವು ವಿಶಿಷ್ಟ ಅನಾನುಕೂಲಗಳನ್ನು ಹೊಂದಿದೆ. ಇದು ತಾತ್ಕಾಲಿಕವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ದೋಷವನ್ನು ಪರಿಹರಿಸಿದಾಗ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ಅನೇಕ ಮುದ್ರಣ ಹೇಳಿಕೆಗಳ ಬಳಕೆಯು ಪ್ರೋಗ್ರಾಂನ ನಿಜವಾದ ಔಟ್ಪುಟ್ನ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು ಮತ್ತು ಮುದ್ರಣ ಹೇಳಿಕೆಗಳನ್ನು ಎಷ್ಟು ಬಾರಿ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ರನ್-ಟೈಮ್ ಅನ್ನು ನಿಧಾನಗೊಳಿಸಬಹುದು. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಮುದ್ರಣ ಹೇಳಿಕೆಗಳು ಸಮಸ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುವುದಿಲ್ಲ, ಉದಾಹರಣೆಗೆ ಸಿ + + ಸ್ಟಡ್ಔಟ್ ಬಫರ್ಡ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಬಫರ್ನ ವಿಷಯಗಳು ಕಳೆದುಹೋಗಿ ತಪ್ಪಾದ ದೋಷನಿವಾರಣೆ ಮಾಹಿತಿಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ಸಿ + + ಉದಾಹರಣೆ ಅನೂರ್ಜಿತ ಟೆಸ್ಟ್ಫಂಕ್ಷನ್ (ಇಂಟ್ ಟೈಮ್ಸ್ ಟೂ ರನ್) {cout <<"ಅಲ್ಗಾರಿದಮ್ ರನ್ ಆಗಬೇಕು" <<ಟೈಮ್ಸ್ ಟೂ ರನ್ <<"ಟೈಮ್ಸ್" <<STD:: ಎಂಡ್ಎಲ್; (ಇಂಟ್ ಐ = 0; ಐ <= ಟೈಮ್ಸ್ ಟೂ ರನ್; ಐ + +) {// ರನ್ ಅಲ್ಗಾರಿದಮ್ ಅಲ್ಗಾರಿದಮ್ ();// ಡೀಬಗ್ ಪ್ರಿಂಟ್ ಸ್ಟೇಟ್ಮೆಂಟ್ cout <<"ಅಲ್ಗಾರಿದಮ್ ರನ್" <<ಐ + + <<"ಟೈಮ್ಸ್". <<std::<unk>;}} ಮೇಲಿನ ಕೋಡ್ನಲ್ಲಿ ಒಂದು ದೋಷವಿದೆ. 5ರ ಇನ್ಪುಟ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಕನ್ಸೋಲ್ಗೆ ಮುದ್ರಿಸಬೇಕು. ಅಲ್ಗಾರಿದಮ್ 5 ಬಾರಿ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು 1 ಬಾರಿ ಚಲಾಯಿಸಬೇಕು. ಅಲ್ಗಾರಿದಮ್ 2 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 3 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 4 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 5 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ನಿಜವಾದ ಔಟ್ಪುಟ್ ಈ ಕೆಳಗಿನಂತಿದ್ದು, ಅದು ತಪ್ಪಾಗಿದೆ. ಅಲ್ಗಾರಿದಮ್ 5 ಬಾರಿ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು 1 ಬಾರಿ ಚಲಾಯಿಸಬೇಕು. ಅಲ್ಗಾರಿದಮ್ 2 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 3 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 4 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 5 ಬಾರಿ ರನ್ ಆಗುತ್ತದೆ. ಅಲ್ಗಾರಿದಮ್ 6 ಬಾರಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಮ್ಮ ಕಾರ್ಯವು ಅಲ್ಗಾರಿದಮ್ನ ಮೂಲಕ ಹೆಚ್ಚುವರಿ ಸಮಯವನ್ನು ನಡೆಸುತ್ತಿದೆ, ಮತ್ತು ಹತ್ತಿರದಿಂದ ಪರಿಶೀಲಿಸಿದಾಗ ನಮ್ಮ ಲೂಪ್ ಅನ್ನು ತಪ್ಪಾಗಿ ಕೋಡ್ ಮಾಡಲಾಗಿದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಹೇಳಿಕೆಗಳನ್ನು ದೃಢೀಕರಿಸಿ ಸಾಮಾನ್ಯವಾಗಿ ದೋಷವನ್ನು ಸರಿಪಡಿಸಲು ಉತ್ತಮ ಸಮಯವೆಂದರೆ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವ ಮೊದಲು. ಕೋಡ್ನಲ್ಲಿ ಸಮರ್ಥನೆಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು. ಸಿ ಯಲ್ಲಿ ಇದನ್ನು ಅಸ್ಸಾರ್ಟ್ () ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಮಾಡಬಹುದು. ಪ್ರೋಗ್ರಾಂನ ಈ ಹಂತದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಸರಿಯಾದ ಷರತ್ತುಗಳನ್ನು ನಡೆಸುತ್ತಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಸ್ಸಾರ್ಟ್ ಕಮಾಂಡ್ ಪರಿಶೀಲಿಸಬಹುದು. C ಉದಾಹರಣೆ int i, a [10]; for (i = 0; i <10; + + i) {a [i] = 10-i;} for (i = 0; i <10; + + i) {a [a [i]] = a [i];} ಮೇಲಿನ ಕೋಡ್ ಕಾರಣವಾಗುತ್ತದೆ ಇದು ಕೆಲವು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುವ ಮಿತಿಯಿಲ್ಲದ ದೋಷವನ್ನು ಹೊಂದಿದೆ. ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ, ಸಮರ್ಥನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕೋಡ್ ಅನ್ನು ಸುರಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ ಬರೆಯಬಹುದು. #include <assert.h> int i, a [10]; ಫಾರ್ (i = 0; i <10; + + i) {ಅಸ್ಸೇರ್ಟ್ (0 <= i & & i <10); a [i] = 10-i;} ಫಾರ್ (i = 0; i <10; + + i) {ಅಸ್ಸೇರ್ಟ್ (0 <= i & & i <10); ಅಸ್ಸೇರ್ಟ್ (0 <= a [i] & & & a [i] <10); a [a [i] = a [i];} JUnit JUnit ಎಂಬುದು ಜಾವಾಗೆ ಲಭ್ಯವಿರುವ ಪುನರಾವರ್ತನೀಯ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಲು ಬಳಸುವ ಸರಳ ಚೌಕಟ್ಟಾಗಿದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ ತಮ್ಮದೇ ಆದ ಘಟಕ ಪರೀಕ್ಷೆಯನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಯುನಿಟ್ ಪರೀಕ್ಷೆಯು ಪರೀಕ್ಷಿಸಬೇಕಾದ ಕೋಡ್ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬರೆಯಲಾದ ಕೋಡ್ ಆಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಕೋಡ್ನ ಸಣ್ಣ ಘಟಕವನ್ನು ಗುರಿಯಾಗಿರಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಅಂತಹ ಒಂದೇ ವಿಧಾನ ಅಥವಾ ವರ್ಗ. ಅಸ್ಸೇರ್ಟ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು ಮತ್ತು ಇತರ ಪರೀಕ್ಷಾ ಹೇಳಿಕೆಗಳ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ಒಂದು ವಿಧಾನ ಅಥವಾ ಕಾರ್ಯವನ್ನು ಸರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತಿದೆಯೇ ಎಂದು ತಿಳಿಸಲು ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳ ಸೂಟ್ಗಳನ್ನು ರಚಿಸಬಹುದು. ಉಲ್ಲೇಖಗಳ ತಂತ್ರಾಂಶ ನಿರ್ವಹಣೆ