[Powered by Google Translate] GDB, GNU ಪ್ರಾಜೆಕ್ಟ್ ಡೀಬಗರ್, ಸಿ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಡೀಬಗ್ ಸಾಧನವಾಗಿದೆ
ಇತರ ಭಾಷೆಗಳ ಜೊತೆಗೆ.
ಅವರು ಪಾಲಿಸಲು ಮಾಡುತ್ತಲೇ ನೀವು, ನಿಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಮ್ಗಳ ಒಳಗಡೆ ಸುಮಾರು ಇರಿ ಅನುಮತಿಸುತ್ತದೆ
ಮತ್ತು ಇದು ನೀವು ಸಂಭವಿಸುತ್ತದೆ ನಿಖರವಾಗಿ ಏನನ್ನು ನೋಡಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ
ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಕುಸಿತಗೊಂಡಾಗ.
ಅದು ಸರಿ, ಬಹಳ ನಿಫ್ಟಿ ಈಸ್?
GDB ಉಚಿತ ಸಾಫ್ಟ್ವೇರ್ ಆಗಿದೆ, ಮತ್ತು ಇದು ಹಲವು ಜನಪ್ರಿಯ Unix ಚಲಿಸುತ್ತದೆ ಮತ್ತು
ವಿಂಡೋಸ್ ಆಧಾರಿತ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳು, ಆದ್ದರಿಂದ ಬಹಳ ವ್ಯಾಪಕ ಪರಿಕರವಾಗಿದ್ದು.
>> ನೀವು ಪ್ರೀತಿಸುವ ಕಲಿತುಕೊಳ್ಳಬೇಕು.
GDB ಸಾಧಕ ದೋಷಗಳನ್ನು ಕೆಳಗೆ ಟ್ರ್ಯಾಕ್ ಒಂದು ತುಂಬಾ ಸುಲಭವಾಗುತ್ತದೆ
ಊಹೆಗಳು ಬಳಸುವ ಮೂಲಕ ಅವ್ಯವಸ್ಥೆ ಯಾರು ಹೆಚ್ಚು
ಮತ್ತು ಪ್ರಿಂಟ್ ಔಟ್ ಹೇಳಿಕೆಗಳ ಅನಂತ ಪ್ರಮಾಣದಲ್ಲಿ.
GDB ನೀವು ಟರ್ಮಿನಲ್ ಅದನ್ನು ಸಂವಾದಿಸಬಹುದು ಅಂದರೆ, ಒಂದು ಆಜ್ಞಾ ಸಾಲು ಉಪಕರಣವಾಗಿರುತ್ತದೆ
ನಿಮ್ಮ ಇಲಿಯನ್ನು ಕೀಬೋರ್ಡ್ ಮೂಲಕ ಆದೇಶಗಳ ಬದಲಿಗೆ ಕ್ಲಿಕ್ ಬಟನ್ ನೀಡುವ.
>> GDB ಅನ್ನು ಆರಂಭಿಸಲು, ನೀವು ಅಕ್ಷರಶಃ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ಹಿಟ್ ಕೇವಲ ರೀತಿಯ GDB ನಮೂದಿಸಿ.
ನೀವು ತೆರೆಗೆ ಔಟ್ ಮುದ್ರಿತ ಕೆಲವು ಸಾಲುಗಳನ್ನು ನೋಡುತ್ತಾರೆ
, ನೀವು ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ ಎಂದು ನೀವು GDB ಆವೃತ್ತಿಯನ್ನು ತೋರಿಸುವ
ಕಾಪಿರೈಟ್ ಮಾಹಿತಿ, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ನೀವು GDB ಪ್ರಾಂಪ್ಟ್ ನೋಡುತ್ತಾರೆ: (GDB).
ನೀವು GDB ಆಜ್ಞೆಗಳನ್ನು ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಈ ಹಂತದಲ್ಲಿ, ಹೇಗೆ ತಿಳಿಯಲು ಪ್ರಮುಖ ವಿಷಯ ಬಿಟ್ಟು ಇದೆ.
ಅದೃಷ್ಟವಶಾತ್, ಇದು ತುಂಬಾ ಸುಲಭ.
ಬಿಟ್ಟು ಆಜ್ಞೆಯನ್ನು ಕೇವಲ ಮಾಡುತ್ತದೆ.
ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಮಾಹಿತಿ, ನೀವು ಪ್ರಶ್ನೆ ತುಂಬಾ ಬಳಸಬಹುದು.
ಮೋಜಿನ GDB ಅನ್ನು ಬೂಟ್ ತದನಂತರ ಕೂಡಲೇ ತೊರೆದು ಎಂದು ಆಗಿದೆ,
ಒಂದು ಪ್ರೋಗ್ರಾಂ ದೋಷ ಸಹಾಯ GDB ಬಳಸಿಕೊಂಡು ಬಗ್ಗೆ ಈಗ ನೋಡೋಣ.
>> ಆರಂಭಿಸಲು, ನಾನು ಇಲ್ಲಿ factorial.c ಒಂದು ಪ್ರೋಗ್ರಾಂ ಪಡೆದಿರುವಿರಿ
ಒಂದು ಇಂಟ್ ಪಡೆಯುತ್ತದೆ ಮತ್ತು ತನ್ನ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಾಚಾರ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಮೊದಲು factorials ನೋಡಿಯೇ ಇಲ್ಲ ಅಥವಾ ಅವುಗಳನ್ನು ನೆನಪಿರುವುದಿಲ್ಲ
ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ N N ಗುಣಲಬ್ಧಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ - (n - 1), (n - 2), ಹೀಗೆ -
ನೀವು 1 ಹಿಟ್ ರವರೆಗೆ.
ಆದ್ದರಿಂದ, 3 ಅಪವರ್ತನೀಯ 3 * 2 * 1, ಅಥವಾ 6,
ಮತ್ತು 4 ಅಪವರ್ತನೀಯ 4 * 3 * 2 * 1, ಅಥವಾ 24.
ಶೂನ್ಯ ಅಪವರ್ತನೀಯ ಬೆಸ ಸಂದರ್ಭದಲ್ಲಿ, ಇದನ್ನು, 1 ನ
ಮತ್ತು ಋಣ ಪೂರ್ಣಾಂಕಗಳ factorials ನಿರೂಪನೆಯಾಗಿಲ್ಲ.
ಹೇಗಾದರೂ, ನನ್ನ ಅಪವರ್ತನೀಯ ಕಾರ್ಯಕ್ರಮದ ಬಗ್ಗೆ ಏನಾದರೂ ಮೋಜಿನ ಹೊಂದಿದೆ.
ನಾನು ಔಟ್ ಅದು factorials ಏನೂ ಹೊಂದಿರುವ ವಿಲಕ್ಷಣ ಸಂಖ್ಯೆಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
>> ಆದ್ದರಿಂದ, ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಸಹಾಯ GDB ಬಳಸಬಹುದು.
GDB, ಕಾರ್ಯಸಾಧ್ಯವಾದ ಕಡತಗಳನ್ನೂ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ
ಇದು ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ಮಾಣದ ಬೈನರಿ ಕಡತಗಳನ್ನು.
ಅಂದರೆ, ನಮ್ಮ. ಸಿ ಮೇಲೆ GDB ರನ್ ಅಥವಾ ಸಾಧ್ಯವಿಲ್ಲ. Factorial.c ನಂತಹ H ಮೂಲ ಕೋಡ್ ಕಡತಗಳು.
ನಾವು ಕೇವಲ ಅಪವರ್ತನೀಯ ಟಾಪಿನಲ್ಲಿ ಚಲಾಯಿಸಲು ಬಯಸುವ.
ಪ್ರೋಗ್ರಾಂ ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಅಗತ್ಯವಿದ್ದಲ್ಲಿ,
ನಾವು ಅವುಗಳನ್ನು ಸೂಚಿಸಿ ಬಯಸುವ ಇದು.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅಪವರ್ತನೀಯ, ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ
ಆದ್ದರಿಂದ ನಾವು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ರನ್ ಅಥವಾ R ಟೈಪಿಸಿ.
>> ಈ ಅಪವರ್ತನೀಯ ಪ್ರೋಗ್ರಾಂ ಓಟ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ನಿಂತಾಗ, ನನ್ನ GDB ಮತ್ತೆ ಕೇಳುತ್ತದೆ ಪಡೆಯುತ್ತೀರಿ.
ಸರಿ, ನ 4 ಅಪವರ್ತನೀಯ, ಮತ್ತೆ ಒಂದೇ ಪ್ರಯತ್ನಿಸೋಣ.
ಸರಿ, ನಾವು GDB ಇಲ್ಲಿ ಜಂಕ್ ಅದೇ ರೀತಿಯ ಪಡೆಯುತ್ತಿದ್ದೀರಿ ಎಂದು ನೋಡಿ.
ಪ್ರೋಗ್ರಾಂ ಮುಗಿದಿದೆ ಈಗ ಆ,
ನಾವು ಹೋಗಿ ತನ್ನ ರಾಜ್ಯದ ಯಾವುದೇ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಆದ್ದರಿಂದ ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಮೊದಲು ಮತ್ತೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಆರಂಭಿಸಲು ಅಗತ್ಯವಿದೆ.
ಆದರೆ, ನಾವು ಅದರ ರನ್ ಮಧ್ಯದಲ್ಲಿ ವಿಷಯವೆಂದರೆ ಅದನ್ನು ನಿಲ್ಲಿಸಲು ಒಂದು ದಾರಿ ಬೇಕಿದೆ.
>> ಹಾಗೆ ಮಾಡಲು, ನಾವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಎಂದು ಏನನ್ನು ಬಳಸಿ.
ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಅಥವಾ ಮೂಲ ಕೋಡ್ ಸಾಲಿನಲ್ಲಿ ವಿರಾಮ ಪ್ರೋಗ್ರಾಂಗೆ GDB ತಿಳಿಸಿ
ಆದ್ದರಿಂದ ನಾವು, ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಪರೀಕ್ಷಿಸಲು ಮಾಡಬಹುದು
ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳು, ಮೆಮೊರಿ ರಾಜ್ಯ ಮತ್ತು, ಆ ಸಮಯದಲ್ಲಿ.
ನಾನು ವಿಷಯಗಳನ್ನು ತಪ್ಪು ಹೋಗುವ ಅಲ್ಲಿ ಗೊತ್ತಿಲ್ಲ ಏಕೆಂದರೆ,
>> ನಾನು, ಬಲ ಬಹಳ ಆರಂಭದಲ್ಲಿ ಡೀಬಗ್ ಆರಂಭಿಸಲು ಬಯಸುವ
ಮುಖ್ಯ ಆರಂಭವಾಗುತ್ತದೆ ಬಲ ಮಾಡಿದಾಗ.
ನಾವು ವಿರಾಮ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮುಖ್ಯ ಆರಂಭದಲ್ಲಿ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಮಾಡುತ್ತೇವೆ.
ನಾವು ವಿರಾಮ ಮೊಟಕಾದ ಗೆ ಬೌ ಬಳಸಬಹುದು.
ಈಗ ಕಾರ್ಯಕ್ರಮ ಮತ್ತೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಆರಂಭಿಸೋಣ.
ಇಲ್ಲಿ ನಾವು GDB ತಿಳಿಸುತ್ತದೆ ಕೇವಲ ನಂತಹ ಪ್ರಮುಖ ಆರಂಭದಲ್ಲಿ ಅವು.
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಗ್ಗೆ ಆದರೆ ಇನ್ನೂ ಆ ಕೋಡ್ ಸಾಲು
printf ರೇಖೆ.
ನಾವು ಕೋಡ್ ಈ ಸಾಲಿನ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು GDB ಹೇಳಬಹುದು
ಮುಂದಿನ ಅಥವಾ N ಆಜ್ಞೆ.
>> ಸರಿ, ಈಗ GDB ನಾವು GetInt ಸಾಲಿನಲ್ಲಿ ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತದೆ.
ನಾನು printf ಲೈನ್ ಔಟ್ ಇಲ್ಲ ತೋರುತ್ತಿದೆ ತಿಳಿದಿದೆ
ನಾವು ಕಾಣುವುದಿಲ್ಲ ನಂತರ, ಪರದೆಯ ಮೇಲೆ ಪ್ರಿಂಟ್ ಔಟ್ "ಒಂದು ಧನಾತ್ಮಕ ಪೂರ್ಣಸಂಖ್ಯೆ ನಮೂದಿಸಿ"
ಆದರೆ ಇದು ವಾಸ್ತವವಾಗಿ ಔಟ್ ನೀಡಲಿಲ್ಲ.
ನಾವು ನೋಡಿದ ನೀವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ತೆರೆಗೆ ಬರವಣಿಗೆ ಏನು ದಮನ ಆಗಿದೆ
ಸಂಪೂರ್ಣವಾಗಿ ಏಕೆ ಮುದ್ರಿತಪ್ರತಿಗಳನ್ನು ಜೊತೆ ಡೀಬಗ್ ಇದು ಬರುತ್ತದೆ ರವರೆಗೆ
ಕೆಲವೊಮ್ಮೆ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ ಕಾಣಿಸಬಹುದು.
ಹೇಗಾದರೂ, ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಿ ಒಂದು ಇಂಟ್ ನಲ್ಲಿ ನಮೂದಿಸಿ ಮತ್ತೆ ನೋಡೋಣ.
ಮತ್ತೆ, ಕೌಟುಂಬಿಕತೆ 4 ನೋಡೋಣ.
ಆದ್ದರಿಂದ ಈ ವಿಲಕ್ಷಣ ಕಾಣುತ್ತದೆ. ನಾವು, GDB ಪ್ರಕಾರ ಸಾಲಿನ 12 ರಂದು ಆರ್
ಆದರೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಗ್ಗೆ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ಕೇವಲ ಕರ್ಲಿ ಕಟ್ಟುಪಟ್ಟಿಯು.
>> ನಾವು ಒಂದು ಲೂಪ್ ಕೊನೆಯಲ್ಲಿ ನಾವು ಅಂದರೆ, ನಮ್ಮ ಹಾಗೆ ಆದರೆ ವಾಸ್ತವವಾಗಿ ಲೂಪ್,
ಮತ್ತು GDB ನಮಗೆ ಹೇಳುವುದು ಮುಕ್ತಾಯ ನಿಯಮ, ಶೂನ್ಯ ಹೆಚ್ಚು ಅಂದರೆ ಯಾವುದೇ ಕಡಿಮೆ,
ಮುಂದಿನ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ.
ಈ ಹಿಂದೆಂದೂ ಸ್ವಲ್ಪ ಗೊಂದಲಕ್ಕೆ ಗೆಟ್ಸ್ ವೇಳೆ,
ನಾವು ಪಟ್ಟಿ ಅಥವಾ L ಆಜ್ಞೆಯನ್ನು GDB ಸೋರ್ಸ್ ಕೋಡ್ ಅಪ್ ಬರಬಹುದು.
ಈ ಮೂಲ ಕೋಡ್ ಔಟ್ ತೋರಿಸುತ್ತದೆ
ನಾವು ಪ್ರಸ್ತುತ ನೀವು ಆ ಸಾಲಿನಲ್ಲಿ ಸುತ್ತ ನ.
ನಾವು ಮತ್ತೆ ಪಟ್ಟಿ ಅಥವಾ L ಟೈಪ್ ವೇಳೆ, ನಾವು ರೇಖೆಗಳ ಮುಂದಿನ ಸೆಟ್ ಮುದ್ರಿಸುತ್ತದೆ ನೋಡುತ್ತಾರೆ.
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ತನಕ ನಾವು ಮಾಡಬಹುದು.
>> ನಾವು ಅಲ್ಲಿ ಮರಳಿ ಪಡೆಯಲು, ನಾವು, ಒಂದು ಸಾಲಿನ ಸಂಖ್ಯೆಯ ಪಟ್ಟಿ ಪೂರೈಸುವ
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಾಲು 12.
ಹೇಗಾದರೂ, ಅವರ ಮೇಲೆ ಚಲಿಸೋಣ.
ಈಗ ನಾವು 4 ಲೂಪ್ ಇದ್ದೇವೆ.
ಲೆಟ್ಸ್ ನಮ್ಮ NUM ವೇರಿಯಬಲ್ 4 ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ನಾವು ಮುದ್ರಣ, ಅಥವಾ ಪು, ಆಜ್ಞೆಯನ್ನು ನೀವು ಹಾಗೆ.
ಆದ್ದರಿಂದ, GDB ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ NUM ವಾಸ್ತವವಾಗಿ, 4 ಸಂಗ್ರಹಿಸಲು ಎಂದು ನಮಗೆ ಹೇಳುತ್ತದೆ.
ಆ GDB ಮುದ್ರಿಸುತ್ತದೆ $ 1 ಔಟ್ ವಿಶೇಷ GDB ವ್ಯತ್ಯಯ
ಈಗ ಜೊತೆಗೆ ಸಂಖ್ಯೆ 4 ಶೇಖರಿಸಿಡಲು ಹೊಂದಿಸಲಾಗಿದೆ.
ನೀವು ಈಗ ಈ ಅಲಕ್ಷಿಸಬಹುದು, ಆದರೆ ಈ GDB ಅಸ್ಥಿರ HANDY ಸೂಪರ್ ಬರುತ್ತವೆ
ಹೆಚ್ಚು ಮುಂದುವರಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು ಹಿಂದೆ ಮಾಡಿದ ಯಾವ ಮರುಪಡೆಯಲು ಬಯಸಿದಾಗ.
ಹೇಗಾದರೂ, ಮುಂದಿನ ನಲ್ಲಿ ಚಲಿಸುವ, ನಾವು ಲೂಪ್ ಫಾರ್ ಮೂಲಕ ತೆರಳುತ್ತಾರೆ ಎಂದು ನೋಡಿ.
ಬಿಟ್ ಮೂಲಕ N ಬಿಟ್ ಇಲ್ಲಿ ಮೂಲಕ ಮುಂದುವರಿಸುವುದಕ್ಕೆ ನೋಡೋಣ.
ಬದಲಿಗೆ ಟೈಪಿಂಗ್ N ಪ್ರತಿ ಬಾರಿ ಹೆಚ್ಚು, ನೀವು ನಮೂದಿಸಿ ಹೊಡೆಯಬಹುದು ಕೇವಲ.
ನೀವು ಏನು ಟೈಪ್ ಇಲ್ಲದೆ ನಮೂದಿಸಿ ಹೊಡೆದಾಗ, GDB ಕೇವಲ ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಪುನರಾವರ್ತನೆಯಾಗಿದೆ.
ಈಗ ನಾವು printf ಕರೆ ಹಿಟ್ ಮಾಡಿದ.
ನಾವು ನಿಜಕ್ಕೂ ಲೂಪ್ 4 ಬಾರಿ ನಮ್ಮ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ ಎಂದು, ಹುಡುಕುತ್ತದೆ
ಇದು ನಾವು 1, 2, 3, ಮತ್ತು 4 ರಿಂದ ಗುಣಿಸುವುದು ಸಲುವಾಗಿ ಮಾಡಲು ಯಾವ ಹೊಂದಿದೆ.
>> ಎಲ್ಲವೂ ಕೆಲಸ ರೀತಿಯಲ್ಲಿಯೇ ತೋರುತ್ತದೆ,
ನಾವು ಮುಂದಿನ ಮತ್ತೆ ಹೊಡೆದಾಗ ಹೊರತುಪಡಿಸಿ ನಾವು ಬದಲಿಗೆ 24 ಈ ಭಾರಿ ಸಂಖ್ಯೆ ಸಿಗುತ್ತದೆ.
ನಾವು ಅಪವರ್ತನೀಯ ಬಳಸಿಕೊಂಡು ಪುಟ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ವೇಳೆ,
ನಾವು ಅಪವರ್ತನೀಯ ಇದು ಈ ಭಾರಿ ಸಂಖ್ಯೆಯ ಎಂಬುದನ್ನು ನೋಡಿ.
ಯಾವುದೋ ಖಂಡಿತವಾಗಿಯೂ ತಪ್ಪು ವಿಶೇಷವೇನು.
ಈ ಹಂತದಲ್ಲಿ, ಆದರೂ, ನಾವು, ಸುಮಾರು ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿದೆ
ಮತ್ತು ಅದು ಏನು ಸರಿಪಡಿಸಲು ತಡವಾಗಿ ಇಲ್ಲಿದೆ.
>> ಆದರೆ, ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತೆ ತದನಂತರ ವೈ ಆರ್ ನಮೂದಿಸುವ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭಿಸುತ್ತವೆ.
ಈಗ ನಾವು ಮುಖ್ಯ ಆರಂಭದಲ್ಲಿ ನಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಂದೆ ಆರ್.
ನಾವು ಎಲ್ಲವನ್ನೂ N ರಲ್ಲಿ ಓದುವ ಉತ್ತಮ ತೋರುತ್ತದೆ ತಿಳಿದಿದೆ.
ಆದ್ದರಿಂದ ನಾವು, n ಮುಂದೆ ದಾಟಬಲ್ಲಿರಿ.
ಏನು ನಂತರ ಪರ್ಯಾಯವಾಗಿ, ನಾವು ಒಂದು ಹೊಸ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಮಾಡುತ್ತದೆ ಲೂಪ್
ಹಾಗೂ ಜಿಗಿತವನ್ನು. ನ ಹಾಗೆ ಬಿಡಿ.
ಸಾಲು 14 ಕೇವಲ ಲೂಪ್ ನಂತರ ಬರುತ್ತದೆ ತೋರುತ್ತಿದೆ.
ನ ಇಲ್ಲಿ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಅವಕಾಶ.
ಈ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಆಜ್ಞೆಯಲ್ಲಿ ಫೈಲ್ ಹೆಸರನ್ನು ಸೂಚಿಸಲು ಉತ್ತಮ ಇಲ್ಲಿದೆ
ನೀವು ಬಹು ಫೈಲ್ಗಳನ್ನು ಕೆಲಸ ಬಳಸುತ್ತಿದ್ದರೆ GDB ತಪ್ಪಾಗಿ ಏಕೆಂದರೆ.
ಮುಂದೆ ಈ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ನ ಸರಿಸಲು, ನಾವು ಮುಂದುವರಿಸಲು ಅಥವಾ ಸಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.
>> ಸರಿ, ಇಲ್ಲಿ ನಾವು ಲೂಪ್ ಕಾಲ ಇರುತ್ತದೆ.
ನ ಲೂಪ್ ಫಾರ್ ಒಳಗೆ 1 ಹೆಚ್ಚು ಲೈನ್ ಹೋಗಿ ಅವಕಾಶ
ನಂತರ ನಾವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಮುದ್ರಣ ಅಸ್ಥಿರ ಪ್ರಾರಂಭಿಸಿ.
ಲೆಟ್ಸ್ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ನಾನು, ವಾಸ್ತವವಾಗಿ 1 ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ಎಲ್ಲಾ ಉತ್ತಮ ಎಂದು ಹೌದು.
ಅಪವರ್ತನೀಯ ಬಗ್ಗೆ ಏನು ಹೇಳಬಹುದು?
ಯಾವುದೇ ಉತ್ತಮ ಎಂದು ಓಹ್,.
ನಾವು ಇಲ್ಲಿ ಒಂದು ದೊಡ್ಡ ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ ಮಾಡಲೇಬೇಕು.
ಉಂಟಾಗುವ How'd?
ಹಾಗೆಯೇ, ನಾವು ಕೋಡ್ ಹಿಂತಿರುಗಿ ನೋಡಲು ವೇಳೆ,
ನಾವು ಅದನ್ನು ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಇಲ್ಲ ನೋಡಿ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಕಸದ ಮಾಡಲೇಬೇಕು.
ಅದು ಖಂಡಿತ ನಮ್ಮ ಲೆಕ್ಕ ದೂರ ಕಾಣಿಸುತ್ತದೆ.
>> ಅದೃಷ್ಟವಶಾತ್, ಈ ಸರಿಪಡಿಸಲು GDB ಬಿಡಲು ಇಲ್ಲ.
ನಾವು ಇಲ್ಲಿ ಆರಂಭಿಸಲು ಮತ್ತು ನಂತರ print ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಕೋಡ್ ಇದನ್ನು ಹೊಂದಿಸಬಹುದು.
ಶೂನ್ಯ ಮತ್ತು 1 factorials 1 ಎರಡೂ ಕಾರಣ ನಾವು, 1 ಇದನ್ನು ಆರಂಭಿಸಲು ಮಾಡುತ್ತೇವೆ
ನಾವು ಶೂನ್ಯ ಅದನ್ನು ಆರಂಭಿಸಲು ವೇಳೆ ಮತ್ತು ನಂತರ ನಾವು ಯಾವಾಗಲೂ ನಮ್ಮ ಪರಿಣಾಮವಾಗಿ ಶೂನ್ಯ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಬಯಸುವ.
ನೀವು ಸೂಪರ್ HANDY ಇದು ಯಾವುದೇ ವೇರಿಯಬಲ್ ಈ ರೀತಿಯಲ್ಲಿ, ಹೊಂದಿಸಬಹುದು.
ಈಗ, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ಮುಂದುವರಿಸಲು ಅವಕಾಶ.
ಲೆಟ್ಸ್ ಇದು ಮಾಡಬೇಕೋ ಅಲ್ಲಿ ಎಲ್ಲವೂ ಇಲ್ಲಿದೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ಸಂ 4, ನಾನು 1 ಆಗಿರಬೇಕು, ಮತ್ತು ಅಪವರ್ತನೀಯ ತುಂಬಾ 1 ಆಗಿರಬೇಕು.
ನಾವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಶಾರ್ಟ್ಕಟ್ ಮತ್ತು ನಮ್ಮ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಎಲ್ಲಾ ಮುದ್ರಿಸಬಹುದು
ಸೂಪರ್ ಸಹಾಯಕವಾಗಿದೆಯೆ ಆಜ್ಞೆಯನ್ನು ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರಲ್ಲಿ,
ಇದು ನಮ್ಮ ಇನ್ ಸ್ಕೋಪ್ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಎಲ್ಲಾ ಮುದ್ರಿಸುತ್ತದೆ.
ಎಲ್ಲವನ್ನೂ ಹೋಗಲು ಒಳ್ಳೆಯದು ನಂತಹ ಹೇಗಾದರೂ, ಇದು ಕಾಣುತ್ತದೆ.
>> ಕೇವಲ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತೊಂದು GO-ಸುತ್ತ ಕುಣಿಕೆ ಮಾಡೋಣ ನ.
ಸರಿ, ಎಲ್ಲವನ್ನೂ ಮಹಾನ್ ಕಾಣುತ್ತದೆ.
ಈಗ ನಾವು ಕೊನೆಗೆ ಹೋಗಿ ಮುಂದುವರಿಸಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.
ಸಿಹಿ! 4 ಅಪವರ್ತನೀಯ ನಿರೀಕ್ಷೆಯಂತೆ 24 ಮುದ್ರಣ ಮಾಡಿದ.
ಈಗ ನಾವು ನಮ್ಮ ಕೋಡ್ ಈ ಸರಿಪಡಿಸಲು ಹೋಗಬಹುದು.
ಬದಲಿಗೆ GDB ಹೊರಗೆ ಬಿಟ್ಟು ಹೆಚ್ಚು, ನಾವು ಇದನ್ನು ಮತ್ತೊಂದು ಟರ್ಮಿನಲ್ ಟ್ಯಾಬ್ ಬಳಸಿ.
ನಮ್ಮ GDB ಟ್ಯಾಬ್ ಹಿಂದಕ್ಕೆ ಹೋಗಿ, ನಾವು ಈಗ ನಮ್ಮ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮರುಸಂಕಲಿಕೆಯು ಅಗತ್ಯವಿದೆ.
GDB ಬಗ್ಗೆ ಉತ್ತಮ ಕೆಲಸವೆಂದರೆ ನೀವು ಚಲಾಯಿಸಲು GDB ಬಿಡಲು ಅಗತ್ಯವಿಲ್ಲ ಎಂದು.
ಆದ್ದರಿಂದ ನಾವು, ಹಳೆಯ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಡೆಯುವ ಇರಿಸಿಕೊಳ್ಳಲು ಎಂದು
ಈಗ ಅವುಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು, ನೀವು ಊಹಿಸಿದಂತೆ, ಆಜ್ಞೆಯನ್ನು ಅಶಕ್ತಗೊಳಿಸಿ.
ಈ ನಮ್ಮ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಎಲ್ಲಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ಈಗ, ನಾವು R ಕಾರ್ಯಕ್ರಮವನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಎಲ್ಲವೂ ಸರಿಯಾಗಿಯೆ ಖಚಿತವಾಗಿ ಮಾಡಬಹುದು.
ಎಲ್ಲವನ್ನೂ ಹೋಗಲು ಒಳ್ಳೆಯದು ತೋರುತ್ತಿದೆ.
24 ಔಟ್ 4 ಅಚ್ಚುಗಳ ಅಪವರ್ತನೀಯ, ಕೇವಲ ನಾವು ಭಾವಿಸಲಾಗಿದೆ.
GDB ನಿಮ್ಮ ಉಪಕರಣ ರಲ್ಲಿ ಪಡೆದಿರುವಿರಿ ಉಪಯುಕ್ತ ಉಪಕರಣಗಳು ಒಂದಾಗಿದೆ.
>> ನೀವು GDB ಜೊತೆಯಲ್ಲಿ ಮಾಡಬಹುದಾದ ಒಂದು ಟನ್ ಹೆಚ್ಚು ವಿಷಯಗಳನ್ನು ಇವೆ
ನೀವು ಸರಳ ಮುದ್ರಿತಪ್ರತಿಗಳನ್ನು ಜೊತೆಗೆ ಮಾಡಬಹುದು ತುಂಬಾ ಹೆಚ್ಚು.
ಮುಂದಿನ ಬಾರಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ನೀವು ಬಯಸುವ ಏನು ಇಲ್ಲ
ಒಳಗೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು GDB ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ.
ಅಭ್ಯಾಸದ ಸ್ವಲ್ಪ, ನೀವು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನಿಮ್ಮ ದೋಷ ಮೇಲೆ ಕೊರೆತಕ್ಕಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಹೊಂದಿದೆ. ಈ CS50 ಹೊಂದಿದೆ.