ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ನಾವು ಅದರ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿರುವಾಗಇವುಗಳು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪುನರಾವರ್ತನೆಯಾಗುವ ನಿಯಂತ್ರಣ ರಚನೆಗಳಲ್ಲಿನ ಸೂಚನೆಗಳು, ಅವುಗಳ ಮುಖ್ಯ ಕಾರ್ಯಗಳಲ್ಲಿ ಸತ್ಯ ಅಥವಾ ತಪ್ಪುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಹಲವಾರು ಸೂಚನೆಗಳನ್ನು ತಡೆಯುವುದು, ಜೊತೆಗೆ, ಲೂಪ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಬಹಿರಂಗಪಡಿಸಲಾಗಿದೆ.
ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿರುವಾಗ
ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿರುವ ಸಮಯ ಯಾವುದು, ಒಂದು ನಿಯಂತ್ರಣ ರಚನೆಯಲ್ಲಿ ಹಲವು ಬಾರಿ ಪುನರಾವರ್ತನೆಯಾಗುವ ಸೂಚನೆಗಳ ಸರಣಿಯನ್ನು ನೀಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಸಂಪರ್ಕಿತ ಅಭಿವ್ಯಕ್ತಿಯ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು / ಅಥವಾ ತಾರ್ಕಿಕ ಅಥವಾ ತಪ್ಪಾಗಿರುವ ಸಂದರ್ಭದಲ್ಲಿ, ಸೂಚನೆಗಳ ಸರಣಿಯನ್ನು ತಡೆಯುವ ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ.
ಇದರರ್ಥ ಸೂಚನೆಯ ಮೌಲ್ಯಮಾಪನವು ನಿಜವಾಗಿದ್ದಾಗ ಮಾತ್ರ ಅದು ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ.
ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ if ಅಥವಾ ಸ್ವಿಚ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನಂತಹ ನಿಯಂತ್ರಣ ರಚನೆಗಳ ಜೊತೆಗೆ, ಪುನರಾವರ್ತಿತ ರಚನೆಗಳು ಸಹ ಇವೆ.
ಪುನರಾವರ್ತಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ರಚನೆಗಳಲ್ಲಿ, ಸ್ವಲ್ಪ ಲೂಪ್‌ಗೆ ಸಂಬಂಧಿಸಿ, ಅದು ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿರುವವರೆಗೂ ಕೋಡ್ ಬ್ಲಾಕ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಅದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವ್ಯಕ್ತಪಡಿಸಬಹುದು:
- ಅದೇ ಸಮಯದಲ್ಲಿ (ಷರತ್ತು).
- {.
- ಸೂಚನೆಗಳು ;.
- }.
ನೀವು ನೋಡುವಂತೆ ಪುನರಾವರ್ತನೆಗಳು ಮತ್ತು ಕುಣಿಕೆಗಳು ಇವೆ, ಆದಾಗ್ಯೂ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಲೂಪ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ:
- ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಷರತ್ತು ನಿಜ ಅಥವಾ ತಪ್ಪು, ಮತ್ತು ಲೂಪ್‌ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಮೇಲೆ ಇದನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ.
- ಷರತ್ತು ನಿಜವಾಗಿದ್ದರೆ ಕೋಡ್‌ನ ಸಾಲುಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವ ಹೇಳಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.
ಈ ರೀತಿಯ ಲೂಪ್‌ನ ಗುಣಲಕ್ಷಣಗಳೆಂದರೆ, ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಸ್ಥಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ನಂತರ, ಫಲಿತಾಂಶವು ತಪ್ಪಾಗಿದ್ದರೆ, ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇನ್ನೊಂದು ರೀತಿಯ ಲೂಪ್ ಒಂದೇ ಬಾರಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ .
ಸಂಬಂಧಿಸಿದ ಆಸಕ್ತಿದಾಯಕ ಲೇಖನವನ್ನು ಇಲ್ಲಿ ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ ಸಿ ಭಾಷೆ.
ಆದ್ದರಿಂದ, ಕುಣಿಕೆಗಳ ಸಮಯದಲ್ಲಿ, ಇದು ಒಂದು ಆವರ್ತಕ ರಚನೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು ಒಂದು ಅಥವಾ ಬೇರೆ ಸಾಲುಗಳ ಕೋಡ್ ಅನ್ನು ಪದೇ ಪದೇ ಪುನರಾವರ್ತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರದೆ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ನಿರೀಕ್ಷಿತ ಅಂತಿಮ ಮೌಲ್ಯವನ್ನು ಯಾವಾಗ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದು ತಿಳಿಯದೆ.
ಲೂಪ್‌ಗಳು ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳಿಗೆ ಒಳಪಡದಿದ್ದರೂ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ ಅವು ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿವೆ, ಅಂದರೆ ನಿಜವಾದ ಅಥವಾ ತಪ್ಪು ಸ್ಥಿತಿಯ ಸತ್ಯ ಮೌಲ್ಯ.
ವೈಲ್ ಲೂಪ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
ಲೂಪ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಈ ಭಾಗದಲ್ಲಿ ನಾವು ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮವಾಗಿ ದೃಶ್ಯೀಕರಿಸಲು ಕಾರಣವಾಗುವ ಉದಾಹರಣೆಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ.
ಉದಾಹರಣೆಯಾಗಿ, ಕೆಲವು ಕಾರಣಗಳಿಂದಾಗಿ, ಬಳಕೆದಾರರಿಗೆ ಸಂಭವಿಸುವ ಹಲವಾರು ಸಂಖ್ಯೆಗಳನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಮತ್ತು ಅವರು 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸುತ್ತಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.
ನೀವು ನೋಡುವಂತೆ, ನೀವು ಒಂದು ಲೂಪ್ ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಬಳಕೆದಾರರು 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸುತ್ತಾರೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲ, ಇದನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯವರೆಗೆ ಅನಂತವಾಗಿ ಕ್ರಿಯೆಯನ್ನು ಮಾಡಲು ಲೂಪ್ ಒಪ್ಪುತ್ತದೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ನಮೂದಿಸಿದ ಸಂಖ್ಯೆ 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿದೆ.
ಆದ್ದರಿಂದ, ಬಳಕೆದಾರರು ಈ ಕೆಳಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರಂತರವಾಗಿ ನಮೂದಿಸಿದರೆ: 1, 50, 99, 49, 21, 30, 100, ಪ್ರೋಗ್ರಾಂ ಪೂರ್ಣಗೊಳ್ಳುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಸಂಖ್ಯೆಗಳು 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಿಲ್ಲ, ಆದರೆ, ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ 300, ಕಾರ್ಯಕ್ರಮವು ತಕ್ಷಣವೇ ಕೊನೆಗೊಳ್ಳುವ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದೆ.
ಸಿ ++ ನಲ್ಲಿ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಲೂಪ್ ಮಾಡಿ
ಸ್ವಲ್ಪ ಸಮಯದ ಲೂಪ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸರಳವಾಗಿದೆ ಮತ್ತು ಸಿ ++ ನಲ್ಲಿನ ಲೂಪ್‌ಗಿಂತ ಹೆಚ್ಚು ಓದಬಲ್ಲದು, ಏಕೆಂದರೆ ಇದಕ್ಕೆ ನಿಖರವಾದ ಸ್ಟಾಪ್ ಷರತ್ತು ಮಾತ್ರ ಬೇಕಾಗುತ್ತದೆ.
ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಭಾಷೆಗಳು ಸ್ವಲ್ಪ ಸಮಯದ ಲೂಪ್ ಅನ್ನು ಬರೆಯುವ ವಿಧಾನವು ತುಂಬಾ ಹೋಲುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಲೂಪ್‌ನ ಮುಕ್ತಾಯ ಸ್ಥಿತಿಯನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು.
ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ಅಂತಿಮ ಸ್ಥಿತಿಯನ್ನು ಹೇಗೆ ಇರಿಸಲಾಗುವುದು ಎಂದು ನೋಡೋಣ:
- (ಅಂತ್ಯ ಸ್ಥಿತಿ) // ಉದಾಹರಣೆಗೆ ಸಂಖ್ಯೆ == 100.
- {.
- ....
- ....
- ....
- ....
- }.
ಮೇಲೆ ತಿಳಿಸಿದ ಕೋಡ್‌ನ ಸಾಲನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ, ಇದರ ಅರ್ಥವೇನೆಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
1 ಸಾಲು
ವಾಕ್ಯರಚನೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಆವರಣದೊಳಗೆ ಒಂದು ಸ್ಥಿತಿಯು ಕಂಡುಬರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು, ಉದಾಹರಣೆಗೆ: «==. >, <,> =, <= ,! = »ಅಥವಾ ಬಹುಶಃ ಇತರರು, ವಿಶೇಷವಾಗಿ ಹೇಳಲಾದ ಸ್ಥಿತಿಯು, ಅದೇ ಸ್ಥಿತಿಯು ಕಾರ್ಯಗತಗೊಳಿಸದಿರುವ ಹಂತವನ್ನು ತಲುಪುವವರೆಗೆ ಚಕ್ರವು ಪೂರೈಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆ == 50 ಎಂದು ನೀವು ದೃ areೀಕರಿಸುತ್ತಿರುವಿರಿ, ಯಾವುದೇ ಸಂಖ್ಯೆಯು 50 ಕ್ಕೆ ಸಮನಾದಾಗ ಮಾತ್ರ ಚಕ್ರವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ; ಅದರ ಮೌಲ್ಯವನ್ನು ಬೇರೆ ಯಾವುದೇ ಪ್ರಮಾಣದಲ್ಲಿ ಮಾರ್ಪಡಿಸಿದಾಗ, ಲೂಪ್ ತನ್ನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ನ ಇತರ ಭಾಗದೊಂದಿಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.
ನೋಂದಾಯಿತ ಸ್ಥಿತಿಯು ಯಾವಾಗಲೂ ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಬೇಕು, ಅಂದರೆ ನಿಜ ಅಥವಾ ತಪ್ಪು.
2 ಸಾಲು
ಆದಾಗ್ಯೂ, ಈ ಕೀಲಿಯನ್ನು ಇಡುವುದು ಕಡ್ಡಾಯವಲ್ಲ, ಆದರೆ, ಅದನ್ನು ಇರಿಸದಿದ್ದರೆ, ಅದನ್ನು ಮೊದಲ ತಕ್ಷಣದ ಸಾಲಿನಲ್ಲಿ ತೋರಿಸಿರುವ ಸಮಯದಲ್ಲಿ ಲೂಪ್‌ನಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಲೂಪ್ ಘೋಷಣೆ, ಇದರರ್ಥ ನೀವು ಬಯಸದಿದ್ದರೆ ಅದು ವಿಭಿನ್ನವಾಗಿದ್ದರೆ ಚಕ್ರದಲ್ಲಿ ಸಾಲುಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ, ಕೀಗಳನ್ನು ಇಡಬೇಕು.
3 ರಿಂದ 7 ರ ಸಾಲುಗಳು: ಈ ಸಾಲುಗಳು ಸೈಕಲ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನೀವು ಪದೇ ಪದೇ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ. ಈ ಬ್ಲಾಕ್ ಅಗತ್ಯವಿರುವ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರಬಹುದು.
ಸಾಲು 8: ಇದು ಕೊನೆಯ ಸಾಲಾಗಿದೆ ಮತ್ತು ಕೀಲಿಯನ್ನು ಮುಚ್ಚುವ ಮೂಲಕ ಬಳಸಬೇಕು "}", ಲೂಪ್‌ನ ಬ್ಲಾಕ್‌ನಿಂದ ಸ್ಥಾಪಿಸಿದಂತೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ಆದಾಗ್ಯೂ, ಉಳಿದ ಅಲ್ಗಾರಿದಮ್ ಮುಂದುವರಿಯುತ್ತದೆ.
ಈಗ ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ತೋರಿಸುತ್ತೇವೆ ಅದು ಸಿ ++ ನಲ್ಲಿ ಲೂಪ್‌ಗಳ ಬಳಕೆಯನ್ನು ಬಳಕೆದಾರರು ಸ್ಪಷ್ಟ ಮತ್ತು ಸರಳ ರೀತಿಯಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಾರಣವಾಗುತ್ತದೆ, ನಾವು ಇದನ್ನು ಆರಂಭಿಸುತ್ತೇವೆ:
ಉದಾಹರಣೆ 1: ಒಂದು ಸಂಖ್ಯೆಯು 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಾಗುವವರೆಗೆ ಪರದೆಯ ಮೇಲೆ ಸಂಖ್ಯೆಗಳನ್ನು ಕೇಳಿ
ಮೇಲೆ ಸೂಚಿಸಿದ ಉದಾಹರಣೆಯೊಂದಿಗೆ ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಪ್ರೋಗ್ರಾಂಗೆ ಮುಂದುವರಿಯುತ್ತೇವೆ, ಬಳಕೆದಾರರು ಹಲವಾರು ಸಂಖ್ಯೆಗಳನ್ನು ನಮೂದಿಸುವಂತೆ ಕೇಳುತ್ತೇವೆ, ಅವುಗಳು ಏನೇ ಇರಲಿ, ಮತ್ತು ಬಳಕೆದಾರರು 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿದಾಗ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ. ಒಂದು ಉದಾಹರಣೆ ಪ್ರಾಯೋಗಿಕ ಮತ್ತು ಸುಲಭ, ಮೇಲೆ ತಿಳಿಸಿದದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು.
ಪರಿಹಾರ ಉದಾಹರಣೆ 1:
ನಾವು ಪರಿಹಾರವನ್ನು ನೀಡಲಿದ್ದೇವೆ, ಷರತ್ತನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಎಂಬುದನ್ನು ಮನಸ್ಸಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕು, ಇದರಿಂದ ಚಕ್ರವು ಸಂಖ್ಯೆಯನ್ನು ವಿನಂತಿಸುತ್ತದೆ, ನಮೂದಿಸಿದ ಸಂಖ್ಯೆ 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಾದಾಗ ಮಾತ್ರ ಚಕ್ರವು ನಿಲ್ಲುತ್ತದೆ, ನಂತರ ನಾನು ಮುಂದುವರಿಯುವ ಸ್ಥಿತಿ ಸಂಸ್ಕರಣೆಯು ಸಂಖ್ಯೆ 100 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದೆ, ನಿಲ್ಲಿಸಲು ಸಂಖ್ಯೆ 100 ಕ್ಕಿಂತ ಹೆಚ್ಚಿರಬೇಕು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಸಲು ಸಂಖ್ಯೆ 100 ಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರಬೇಕು.
ಇದು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಪ್ರತಿಫಲಿಸುತ್ತದೆ ಎಂದು ಕಾಣಬಹುದು:
- ಇಂಟ್ ಸಂಖ್ಯೆ;
- ಸಿನ್ >> ಸಂಖ್ಯೆ;.
- ಅದೇ ಸಮಯದಲ್ಲಿ (ಸಂಖ್ಯೆ <= 100).
- {.
- ಕೌಟ್ << «ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ« ;.
- ಸಿನ್ >> ಸಂಖ್ಯೆ;.
- }.
ಸಂಪೂರ್ಣ ಕ್ರಿಯಾತ್ಮಕ ಕೋಡ್ ಅನ್ನು ಬಳಕೆದಾರರು ನಿರ್ವಹಿಸುವುದು ತುಂಬಾ ಸುಲಭ, ಅದನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂಬ ಅಭ್ಯಾಸವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:
- #"iostream" ಅನ್ನು ಸೇರಿಸಿ.
- ನೇಮ್‌ಸ್ಪೇಸ್ ಸ್ಟಡಿ ಬಳಸಿ;
- ಇಂಟ್ ಮುಖ್ಯ ().
- {.
- ಇಂಟ್ ಸಂಖ್ಯೆ;
- ಕೌಟ್ << «ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ« ;.
- ಸಿನ್ >> ಸಂಖ್ಯೆ;.
- ಅದೇ ಸಮಯದಲ್ಲಿ (ಸಂಖ್ಯೆ <= 100).
- {.
- ಕೌಟ್ << «ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ« ;.
- ಸಿನ್ >> ಸಂಖ್ಯೆ;.
- }.
- ವ್ಯವಸ್ಥೆ ("PAUSE");.
- ರಿಟರ್ನ್ 0;.
- }.
ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿನ ಲೂಪ್‌ಗಳು ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಲೂಪ್‌ಗಳಿಗೆ ಇತರ ರೀತಿಯ ದಕ್ಷತೆ ಮತ್ತು ಸಿಂಧುತ್ವದ ಅಂಶದಿಂದ, ಪ್ರತಿ ಬಾರಿಯೂ ಲೂಪ್ ಅಥವಾ ಯಾವುದೇ ರೀತಿಯ ಲೂಪ್ ಹೋಗುವಾಗ ಅವುಗಳನ್ನು ಬಳಸಬಾರದು ಎಂದು ಸೂಚಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಬೇಕು. ಬಳಸಬೇಕು. ಸೈಕಲ್, ಅದರ ಬಳಕೆ ಅತ್ಯಗತ್ಯವಾಗಿದೆಯೇ ಅಥವಾ ಅದನ್ನು ಬಳಸಲು ಇನ್ನೊಂದು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗವಿದ್ದಲ್ಲಿ ಮೊದಲು ಸಮಾಲೋಚಿಸುವುದು ಉತ್ತಮ.