[Powered by Google Translate] [ಆಜ್ಞಾ ಸಾಲಿನ ವಾದ]
[ಕ್ರಿಸ್ಟೋಫರ್ ಬಾರ್ಥೊಲೊಮೆವ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]
[- CS50.TV ಈ CS50 ಹೊಂದಿದೆ]
ಒಂದು ಪ್ರೋಗ್ರಾಂ ಒಂದು ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಕೆದಾರ ಆದಾನವನ್ನು ಸ್ವೀಕರಿಸುವ ಆಗಿದೆ.
ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು CS50 ಗ್ರಂಥಾಲಯದ ಒಳಗೆ ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಪರಿಶೋಧಿಸಿದರು ನೀವು
ಉದಾಹರಣೆಗೆ ಬಳಕೆದಾರ ಇನ್ಪುಟ್, ಸ್ವೀಕರಿಸಲು ", ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು"
ಅನ್ವಯವು ಚಾಲನೆಯಲ್ಲಿದ್ದಾಗ, ಒಂದು ತಂತಿಗೆ, ಬಳಕೆದಾರರನ್ನು ಅಪೇಕ್ಷಿಸುತ್ತದೆ.
>> ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಇನ್ಪುಟ್ ಒದಗಿಸಲು ಬಯಸುವ ಅಲ್ಲಿ ಆದಾಗ್ಯೂ, ಪ್ರಕರಣಗಳು ಇವೆ
ಇದು ವಾಸ್ತವವಾಗಿ ಚಲಾಯಿಸುವ ಮೊದಲು.
ಈ ರೀತಿಯಾಗಿ, ನೀವು ನಿಮ್ಮ ಬಳಕೆದಾರ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಕೇಳಲು ಅಗತ್ಯವಿಲ್ಲ
ಸರಳ ಕೆಲಸವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ.
ಉದಾಹರಣೆಗೆ, MV ಅಥವಾ UNIX ಚಲಿಸುತ್ತವೆ ಆಜ್ಞೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ.
ಈ ಆಜ್ಞೆಯು ಬಳಕೆದಾರ ಒಂದು ಸ್ಥಳದಿಂದ ಮತ್ತೊಂದಕ್ಕೆ ಒಂದು ಕಡತ ಸರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ಕೈಪಿಡಿ ಪುಟಗಳು ಪ್ರಕಾರ, MV ಎರಡು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:
ಫೈಲ್ ಸರಿಸಲಾಗಿದೆ ಮತ್ತು ಸ್ಥಳ ಕಡತಕ್ಕೆ ಸರಿಸಲಾಗಿದೆ.
ಆದ್ದರಿಂದ ಈ ಉದಾಹರಣೆಗೆ ಎರಡು ವಾದಗಳ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿದೆ.
ಆದ್ದರಿಂದ ನಾವು ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ನಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಹೇಳಲು ಇಲ್ಲ?
>> ಹಾಗೆಯೇ, ನಾವು ಎಲ್ಲಾ ಸಿ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಬಳಸುವ ಮುಖ್ಯ, ರಹಸ್ಯ ಹೊಂದಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ.
Argc ಮತ್ತು argv: ಪ್ರಮುಖ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
ಈ ನಿಯಮಗಳನ್ನು ಮೇಲೆ ಹೋಗಿ ನೋಡೋಣ.
>> ವಾದವು ಎಣಿಕೆ ಹೊಂದಲಾಗಿದೆ ಮೊದಲ ನಿಯತಾಂಕ, argc,
ಪೂರ್ಣಾಂಕ ಒಂದು ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ.
argc ನಿಯತಾಂಕ ಆಜ್ಞೆಯನ್ನು ಸೇರಿದಂತೆ ವಾದಗಳನ್ನು ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿದೆ.
ನಮ್ಮ ನಡೆಯನ್ನು ಆಜ್ಞೆಯಲ್ಲಿ, ನಾವು ಕೇವಲ ಎರಡು ವಾದಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತಿದೆ ಆದರೂ,
argc ಮೌಲ್ಯದ 3 ಆಗಿರುತ್ತದೆ.
ವಾದವು ವೆಕ್ಟರ್ ಎಂದರೆ ಇದು ಎರಡನೇ ನಿಯತಾಂಕವನ್ನು, argv,
ತಂತಿಗಳನ್ನು ಬೆರಳು ಮಾಡುತ್ತಾರೆ ಚಾರ್ ಪಾಯಿಂಟರ್ಸ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.
>> ಈ, argv ಪ್ರತಿಯೊಂದು ಅಂಶ, ಶೂನ್ಯ ಆರಂಭಿಸಿ ಅರ್ಥ
ಆದೇಶ ಮತ್ತು ವಾದಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಉದಾಹರಣೆಗೆ, argv [0], ಇದು ನಾನು, argv ಶೂನ್ಯ ಎಂದು ನೋಡಿ ಮಾಡುತ್ತೇವೆ
ಯಾವಾಗಲೂ ರನ್ ಎಂದು ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿರುತ್ತವೆ -
ಈ ಸಂದರ್ಭದಲ್ಲಿ, MV.
argv [1] file.txt ಮೊದಲ ವಾದವನ್ನು, ಹೊಂದಿರುತ್ತವೆ
ಮತ್ತು argv [2] ಎರಡನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಹೊಂದಿರುತ್ತವೆ, ~ / cs50 /.
argv ಕೊನೆಯ ವಾದವನ್ನು ಯಾವಾಗಲೂ ಶೂನ್ಯ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ ಅವರ ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ಅವಕಾಶ.
ಹಿಂದಿನ ವ್ಯಾಯಾಮ, ನಾವು ಮುಖ್ಯ ನ ನಿಯತಾಂಕವಾಗಿ, ಏನೂ ಅರ್ಥ, ಶೂನ್ಯವನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ.
ಆದಾಗ್ಯೂ, ಸಲುವಾಗಿ ನಮಗೆ, ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸಲು
ನಾವು ಪ್ರಮುಖ ಇಂಟ್ argc, ಚಾರ್ * argv [] ನ ಅನೂರ್ಜಿತ ಮತ್ತು ಸ್ಥಳದ ಒಳಗೆ ತೆಗೆದು ಅಗತ್ಯವಿದೆ.
ಈಗ, ನಿಮ್ಮ ವಾದಗಳನ್ನು ಅವು argv ಸಂಪೂರ್ಣ ಅಂಶ, ಪ್ರವೇಶಿಸಲು,
ನೀವು ಕೇವಲ ಈ ರೀತಿಯ ಸರಣಿ ಮೂಲಕ, ತಿರುಗಿ, ಅಥವಾ ಲೂಪ್ ಮಾಡಬಹುದು.
ಆದ್ದರಿಂದ, ಒಳಗೆ ಮುಖ್ಯ ದೇಹದ, ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ಲೂಪ್ ಒಂದು ಟೈಪ್ ಎಂದು ನೀನು:
ಫಾರ್ (ಇಂಟ್ ನಾನು = 0; ನಾನು <argc; ನಾನು + +).
>> ನಾವು ಮಾತ್ರ ಕೋಡ್ ಒಂದು ಸಾಲು ಪಾಲಿಸಲು ಆಗಿರುವ ಕಾರಣ ನಾವು ಇಲ್ಲಿ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಅಗತ್ಯವಿಲ್ಲ
ಈ ಸಂಪರ್ಕದ ದೇಹದಲ್ಲಿ.
ನಾವು ಮುಂದೆ ಹೋಗಿ ಒಮ್ಮೆ ಟ್ಯಾಬ್ ಹಿಟ್ ವಿಲ್
ನಂತರ printf ಟೈಪ್ ("argv [% s] ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಪ್ರತಿನಿಧಿಸಲು,
ಹೊಸ ಲೈನ್ ಪಾತ್ರದ ನಂತರ, ತಂತಿಗೆ,% s ಆಗಿದೆ.
ನಂತರ ನಾವು ಲೂಪ್ ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆ ಫಾರ್ printf ನಾನು ಒದಗಿಸಲು
ಮತ್ತು argv [I] ಪ್ರಸ್ತುತ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದ ತಂತು ಫಾರ್.
ನಾವು ಎರಡು ವಾದಗಳನ್ನು ಚಾಲನೆ ಮಾಡಿದಾಗ, ನಾವು ಟರ್ಮಿನಲ್ ನಲ್ಲಿ ಪ್ರಕಟಗೊಳ್ಳುತ್ತಿಲ್ಲ ವಾದಗಳನ್ನು ನೋಡುತ್ತಾರೆ.
ಹಿಂದೆ ನಾವು argv ಚಾರ್ ಪಾಯಿಂಟರ್ಸ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಡೆದ ಹೇಳಿದರು.
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ ವೇಳೆ ಆದ್ದರಿಂದ, ಹೇಗೆ ನಾವು ನಂತರ ಪ್ರತಿ ವಾದವನ್ನು ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಹೇಗೆ?
ಉದಾಹರಣೆಗೆ, ನಾನು ಮೊದಲ ವಾದದಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಪಾತ್ರಕ್ಕೆ ನೋಡಲು ಬಯಸಿದರೆ ಏನು?
ಅಲ್ಲದೆ, ಉತ್ತರ ನಾವು ಒಂದು ಅಡಗಿಸಿದ ಲೂಪ್ ಅನ್ವಯಿಸಲು ಅಗತ್ಯವಿರುವ ಆಗಿದೆ
ಆ ವಾದವನ್ನು ಸ್ಟ್ರಿಂಗ್ ಅಂಶಗಳ ಪ್ರತಿ ಮೂಲಕ ಮರಳಿ ಕಾಣಿಸುತ್ತದೆ.
ನೀವು ಅದನ್ನು ಹೇಗೆ.
>> ಮೊದಲ, ನಾವು example2.c ಪ್ರತಿಯನ್ನು ಮಾಡಲು ನೀನು.
ನಂತರ, ಒಳಗೆ ಲೂಪ್ ಮೊದಲ,
ನಾವು ಲೂಪ್ ಒಂದು ಹೆಚ್ಚುವರಿ ಸೇರಿಸಲು ನೀನು.
ಸೋ ಫಾರ್ (ಇಂಟ್ ಜೆ = 0, N = strlen (argv [I]),
ಇದು ನಂತರ, ನಮಗೆ ಪ್ರಸ್ತುತ ವಾದದ ಉದ್ದ ನೀಡುತ್ತದೆ
; J <N; J + +)
ನಾವು ಪ್ರತಿ ಪಾತ್ರದ ಸ್ಥಳ ಮುದ್ರಿಸಲು ನೀನು
printf ಬಳಸಿಕೊಂಡು ಪ್ರಸ್ತುತ ವಾದದ ಒಳಗೆ.
ಆದ್ದರಿಂದ, printf ("argv [% d], ಪ್ರಸಕ್ತ ವಾದದ ಸೂಚ್ಯಂಕ ಪ್ರತಿನಿಧಿಸಲು,
ನಂತರ [% s] ಮತ್ತೊಮ್ಮೆ, ಪ್ರಸ್ತುತ ವಾದದ ಪ್ರಸ್ತುತ ಅಕ್ಷರ ಪ್ರತಿನಿಧಿಸಲು,
ಆಗಿದೆ:% ಸಿ, ವಾದದಲ್ಲಿನ ಪ್ರಸ್ತುತ ಪಾತ್ರಕ್ಕೆ.
ಕೊನೆಯದಾಗಿ, ನಾವು ಹೊರಗಿನ ಕುಣಿಕೆಯಿಂದ ಸೂಚಿಯನ್ನು printf ಒದಗಿಸಲು, ನಾನು,
ನಂತರ ಒಳ ಸಂಪರ್ಕದ ಸೂಚ್ಯಂಕ.
>> ಮತ್ತು ನಮ್ಮ ಕೊನೆಯಾಗಿ ಆರ್ಗ್ಯುಮೆಂಟ್ printf ಒದಗಿಸಿದ ವಾಗ್ವಾದದಲ್ಲಿ ನಿಜವಾದ ಪಾತ್ರ ಗೆ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ.
ಈಗ, ನಾನು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಪಡೆಯಲು ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯ strlen ಬಳಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ,
ನಾನು ನಮ್ಮ ಒಳಗೊಂಡಿದೆ ಮೇಲ್ಭಾಗಕ್ಕೆ string.h ಗ್ರಂಥಾಲಯದ ಸೇರಿಸಬೇಕು.
ಆದ್ದರಿಂದ, ಆ ಮಾಡಲು, ನಾವು ಹೋಗುತ್ತೇನೆ, ಮತ್ತು ಕೇವಲ stdio.h ಅಡಿಯಲ್ಲಿ, ನಾವು ಮಾಡಲು ನೀನು
# ಸೇರಿವೆ.
>> ಆದ್ದರಿಂದ, ನ ಸಂಕಲಿಸಲು ಮತ್ತು ರನ್ ಮತ್ತು ಇದು ನೈಜ ಆರ್ಗ್ಯುಮೆಂಟ್ ಒದಗಿಸಲು ಅವಕಾಶ.
>> ನಾವು ನೋಡಬಹುದು ಮತ್ತು, ನಾವು ಈಗ ವಾದವನ್ನು ಪ್ರತಿಯೊಂದು ಚಾರ್ ನಿಖರವಾದ ಸ್ಥಳ ಹೊಂದಿವೆ.
ಇದರಿಂದಾಗಿ ಅದು. ನಾನು ಕ್ರಿಸ್ಟೋಫರ್ ಬಾರ್ಥೊಲೊಮೆವ್ ಹೇಳುತ್ತಿಲ್ಲ; ಈ CS50 ಹೊಂದಿದೆ.
[CS50.TV]