>> [ಸಂಗೀತ]
>> ಡೌಗ್ LLOYD: ಸರಿ, ಲೆಟ್ ತಂದೆಯ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡಲು.
ಆದ್ದರಿಂದ, ಇಲ್ಲಿಯವರೆಗೆ ಹಾದಿಯಲ್ಲಿ ಸಾಕಷ್ಟು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಹೆಚ್ಚು ಎಲ್ಲಾ
ಬಹುಶಃ ಪ್ರಾರಂಭಿಸಿದ this-- ಇಂಟ್ ಮುಖ್ಯ ಶೂನ್ಯ ನಂತಹ.
ನಾವು ಸಂಗ್ರಹಿಸುವ ಬಂದಿದೆ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ನಾವು ಅಗತ್ಯವಿದ್ದರೆ
ಉದಾಹರಣೆಗೆ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು, ಮಾರಿಯೋ ಪ್ರೋಗ್ರಾಂ, ಉದಾಹರಣೆಗೆ,
ಕಾರ್ಯಕ್ರಮದ ಅಪೇಕ್ಷಿಸುತ್ತದೆ ಮೂಲಕ.
ನಾವು ಮಾರ್ಪಡಿಸಲು ಅಗತ್ಯವಿದೆ ಮಾಡಿಲ್ಲ ಮುಖ್ಯ ಘೋಷಿಸಲ್ಪಟ್ಟಿತು
ಬದಲಿಗೆ ಮುಖ್ಯ ನಾವು ಒಳಗೆ ನೀವು ಇಂಟ್ ಪಡೆಯಲು ಕರೆ ಇರಬಹುದು, ಹೇಳುತ್ತಾರೆ.
ಹೇಗೆ ದೊಡ್ಡ ನೀವು ಪಿರಮಿಡ್ ಎಂದು ಬಯಸುತ್ತೀರಿ?
ಅಥವಾ ನೀವು ಪಡೆಯಲು ಕರೆ ಮಾಡಬಹುದು ಬದಲಾವಣೆ ಎಷ್ಟು float--
ಬಳಕೆದಾರರಿಗೆ ನಾನು ಔಟ್ಪುಟ್ ಮಾಡಬೇಕು?
>> ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ, ಆದರೂ ಇಲ್ಲ ಮತ್ತು ನಮ್ಮ ಬಳಕೆದಾರರನ್ನು ಬಯಸಿದರೆ
ಒದಗಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಡೇಟಾ
ಬದಲಿಗೆ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನಾ ಸಮಯದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ, ಚಾಲನೆಯಲ್ಲಿರುವ
ಒಂದು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸ ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಬಹಳ ಉಪಯುಕ್ತ ಒಂದು,
ನಾವು ಮುಖ್ಯ ಘೋಷಿಸುವ ಒಂದು ಹೊಸ ರೂಪ ಅಗತ್ಯವಿದೆ.
ನಾವು ಬಯಸಿದರೆ ಇಂಟ್ ಮುಖ್ಯ ಶೂನ್ಯ ಬಳಸುವಂತಿಲ್ಲ ಆಜ್ಞಾ ಸಾಲಿನ ಇತರ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು
ಬಳಕೆದಾರ ಪ್ರೋಗ್ರಾಂ ರನ್ ಮಾಡಿದಾಗ, ಆದ್ದರಿಂದ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.
>> ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಸಂಗ್ರಹಿಸಲು ಬಳಕೆದಾರರಿಂದ ವಾದಗಳು,
ನಿಮ್ಮ ಘೋಷಣೆ ಬದಲಾಯಿಸಲು this-- ಇಂಟ್ ರೀತಿ ಮುಖ್ಯ
ಮುಖ್ಯ ತೆರೆದ ಆವರಣ, ಇಂಟ್ argc, ಅಲ್ಪವಿರಾಮ, ಸ್ಟ್ರಿಂಗ್ argv, ಚೌಕಾಕಾರದ,
ತದನಂತರ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತೆರೆಯಲು.
ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ಅರ್ಥವೇನು?
ಹಾಗೆಯೇ, ನಾವು ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ಸಾಗಿ, ಮುಖ್ಯ ಅಥವಾ ವಾದಗಳು, ಅಥವಾ ಒಳಹರಿವು.
ಒಂದು, ಒಂದು ಪೂರ್ಣಾಂಕ ಎಂದು argc, ಮತ್ತು ಇತರ ಏನು?
ಅದು ಸರಿ, ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ?
ನಾವು ಆ ಚದರ ಬ್ರಾಕೆಟ್ ಸಂಕೇತನ ನೋಡಿ.
ಇದು ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ.
ಇದು ಒಂದು ಪ್ರತ್ಯೇಕ ಸಾಲನ್ನು ಅಲ್ಲ, ಇದು ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ.
ಮತ್ತು ಈ ಎರಡು ವಾದಗಳು argc ಮತ್ತು argv, ಯಾವ ದತ್ತಾಂಶವನ್ನು ಬಳಕೆದಾರರ ಗೊತ್ತು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಒದಗಿಸಿದೆ ಮತ್ತು ಎಷ್ಟು ವಿಷಯಗಳನ್ನು ಅವರು
ಆಜ್ಞಾ ಸಾಲಿನ ಒದಗಿಸಲಾಗುವುದು.
ಕೆಲಸ ಬಹಳ ಉಪಯುಕ್ತ ವಿಷಯಗಳನ್ನು.
>> Argc, ವಾದವು ಎಣಿಕೆ ಹೊಂದಲಾಗಿದೆ ಮತ್ತು ನೀವು ಮೂಲಕ, ತಿಳಿಯಬೇಕಿದೆ,
ನೀವು argc ಕರೆಯಬಹುದು ನೀವು ಬಯಸುವ ಯಾವುದೇ.
ನೀವು ನಮಗೇನು argv ಕರೆಯಬಹುದು.
ಈ ಕೇವಲ ಸಾಂಪ್ರದಾಯಿಕ ಹೆಸರುಗಳು ನಾವು them-- ವಾದವು ಎಣಿಕೆ ಬಳಸುವ,
ಮತ್ತು ನಾವು ಎರಡನೇ ನೋಡುತ್ತಾರೆ ಎಂದು, ವಾದ ವೆಕ್ಟರ್, argv.
ಆದರೆ ನೀವು ಕರೆ ಇಲ್ಲ ನಿಮಗೆ ಬೇಡವೆಂದಾದರೆ argc ಮತ್ತು argv,
ಆದರೆ ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ನಾವು ಏನು ಇಲ್ಲಿದೆ.
>> ಆದ್ದರಿಂದ ಹೇಗಾದರೂ, argc, ವಾದವು ಎಣಿಕೆ.
ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಮಾದರಿಯ ವೇರಿಯಬಲ್ ಮತ್ತು ಆದ್ದರಿಂದ, ಎಂದು ನಾವು ಎರಡು ವಿಷಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು, ಅಪೇಕ್ಷಿಸಬಹುದು
ನಾವು ಹುಡುಕುವ ನೀನು ಈ ಟೈಪ್ ಏನೆಂದು
ಮತ್ತು ಎಷ್ಟು ವಿಷಯವನ್ನು ಬಳಕೆದಾರ ಟೈಪ್, argc ಹೊಂದಿದೆ
ಎಷ್ಟು ನಮಗೆ ಹೇಳಲು ಹೋಗಿ ಟೈಪ್ ಬಳಕೆದಾರ ವಿಷಯವೂ.
ನೀವು ಹಲವಾರು ನೀಡುತ್ತದೆ ಆದ್ದರಿಂದ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಕೆದಾರ
ಪ್ರೋಗ್ರಾಂ ಗಲ್ಲಿಗೇರಿಸಲಾಯಿತು ಯಾವಾಗ ಟೈಪ್.
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮ ಆದ್ದರಿಂದ ಡಾಟ್ ದುರಾಸೆಯ ಕಡಿದು ರನ್,
ನಿಮ್ಮ ದುರಾಸೆಯ ಒಳಗೆ ನಿಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ ಪ್ರೋಗ್ರಾಂ
ಘೋಷಣೆ ಇಂಟ್ ಮುಖ್ಯ ಇಂಟ್ argc ಹೊಂದಿದೆ, ಸ್ಟ್ರಿಂಗ್ ನಂತರ, ಚದರ ಆವರಣಗಳಲ್ಲಿ argv
ಆ ಸಂದರ್ಭದಲ್ಲಿ argc ಒಂದಾಗಿದೆ.
ಈಗ ನಾವು ಅದನ್ನು ಗಮನಕ್ಕೆ ಎಷ್ಟು ವಿಷಯಗಳನ್ನು ಎಣಿಸಲು
ಬಳಕೆದಾರ ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ನಂತರ ಟೈಪ್.
ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ತಾನೇ ಎಣಿಕೆಗಳು ಆಜ್ಞಾ ಸಾಲಿನ ಚರ್ಚೆಯಂತೆ.
>> ಆದ್ದರಿಂದ, ದುರಾಸೆಯ ಡಾಟ್ ಕತ್ತರಿಸಿ ಆ ಸಂದರ್ಭದಲ್ಲಿ, argc ಒಂದಾಗಿದೆ.
ಬಳಕೆದಾರ ಕಡಿದು ದುರಾಸೆಯ 1024 CS50 ಟೈಪಿಸಿದ ಆ ಸಂದರ್ಭದಲ್ಲಿ argc ಆಜ್ಞಾ ಸಾಲಿನ, ನಲ್ಲಿ
ಮೂರು ಎಂದು.
ನಾವು ರೀತಿಯಲ್ಲಿ ಏಕೆಂದರೆ ಈ ಗೊತ್ತು ತಂತಿಗಳ ನಡುವೆ ವಿಭಜನೆ
ಎಂಬುದು ಪತ್ತೆ ಬಾಹ್ಯಾಕಾಶ, ಅಥವಾ ಒಂದು ಟ್ಯಾಬ್ ಇಲ್ಲ,
ಅಥವಾ ಅವುಗಳ ನಡುವೆ ಆ ರೀತಿಯ.
ಆದ್ದರಿಂದ ಜಾಗದಿಂದ ಯಾವುದೇ ಪ್ರಮಾಣವನ್ನು, ಕರೆಯಲ್ಪಡುವ, ಮೌಲ್ಯಗಳ ನಡುವಿನ ಆಜ್ಞಾ ಸಾಲಿನ ಟೈಪ್
ಅಲ್ಲಿ ಎಷ್ಟು ಸೂಚಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ ದುರಾಸೆಯ ಜಾಗವನ್ನು 1024 ಬಾಹ್ಯಾಕಾಶ ಡಾಟ್ ಕತ್ತರಿಸಿ CS50, argc, ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂರು.
>> Argv ವಾದ ವೆಕ್ಟರ್ ಆಗಿದೆ.
ವೆಕ್ಟರ್, ಮೂಲಕ, ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇನ್ನೊಂದು ಪದ,
ಮತ್ತು ಈ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತಂತಿಗಳ ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ಇದು ಅಂಶ ಪ್ರತಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್, ತಂತಿಗಳನ್ನು ಎಂದು ಬಳಕೆದಾರ ವಾಸ್ತವವಾಗಿ
ಆಜ್ಞಾ ಸಾಲಿನ ಟೈಪಿಸಿದ ಪ್ರೋಗ್ರಾಂ ಗಲ್ಲಿಗೇರಿಸಲಾಯಿತು ಯಾವಾಗ.
ಈಗ, ಸಂದರ್ಭ ಯಾವುದೇ ಸರಣಿಯೊಂದಿಗೆ, ನೀವು ವೇಳೆ
ನಮ್ಮ ಚರ್ಚೆ ಮರುಪಡೆಯಲು ರಚನೆಗಳು, argv ಮೊದಲ ಅಂಶ
ಯಾವಾಗಲೂ ಕಂಡುಬಂದಿಲ್ಲ ಹೋಗುತ್ತದೆ argv ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಶೂನ್ಯ.
ಮೊದಲ ಸೂಚ್ಯಂಕ argv ರಚನೆಯ.
ಆದ್ದರಿಂದ ತಿನ್ನುವೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಆ ವಿಲ್ ಯಾವಾಗಲೂ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ಎಂದು,
ಯಾವಾಗಲೂ ಇದೆ ಎಂಬುದನ್ನು argv ಚದರ ಬ್ರಾಕೆಟ್ ಶೂನ್ಯ.
>> Argv ಕೊನೆಯ ಅಂಶ ಯಾವಾಗಲೂ ಕಂಡುಬರುತ್ತದೆ argv ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು argc ಮೈನಸ್ ಒಂದು.
ನೀವು ಏಕೆ ನೋಡುತ್ತಾರೆ?
ಎಷ್ಟು ಅಂಶಗಳನ್ನು ನೆನಪಿಡಿ ಈ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.
ಹಾಗೆಯೇ, ನಾವು ಇಲ್ಲಿದೆ ಆ ಗೊತ್ತು ಅಂಶಗಳನ್ನು argc ಸಂಖ್ಯೆ.
ಬಳಕೆದಾರ ಮೂರು ವಿಷಯಗಳನ್ನು ಟೈಪಿಸಿದ ಆಜ್ಞಾ ಸಾಲಿನ, argc ಮೂರು.
ಆದರೆ ಸಿ, ನಾವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ರಚನೆಯ ಪ್ರತಿ ಅಂಶ,
ಅಥವಾ ಬದಲಿಗೆ ಸೂಚ್ಯಂಕಗಳು ರಚನೆಯ ಶೂನ್ಯ ಆರಂಭವಾಗುವುದು.
ನಾವು ಮೂರು ಅಂಶಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ನಮ್ಮ ಅರೇ, ನಾವು, argv ಶೂನ್ಯ ಒಂದು ಅಂಶ ಹೊಂದಿವೆ
argv ಒಂದು ಒಂದು ಅಂಶ, argv ಎರಡು ಮತ್ತು ಒಂದು ಅಂಶ.
Argv ಯಾವುದೇ ವಿಷಯವಿದೆ ಮೂರು, ಮತ್ತು ಗಾತ್ರದ ಮೂರು ಒಂದು ಶ್ರೇಣಿಯನ್ನು.
ಆದ್ದರಿಂದ ಏಕೆ ಕಳೆದ ಇಲ್ಲಿದೆ argv ಅಂಶ ಯಾವಾಗಲೂ
argv ಚದರ ಕಾಣಬಹುದು ಆವರಣ argc ಮೈನಸ್ ಒಂದು.
>> ಆದ್ದರಿಂದ ಬಳಕೆದಾರ ಕಾರ್ಯಗತಗೊಳಿಸಿ ಕಲ್ಪಿಸಿಕೊಳ್ಳೋಣ ಕೆಳಗಿನಂತೆ ಹಸಿವಿನ ಪ್ರೋಗ್ರಾಂ
ಅವರು ಆಜ್ಞಾ ಸಾಲಿನ ಡಾಟ್ ಟೈಪ್ , ದುರಾಸೆಯ ಜಾಗವನ್ನು 1024 ಬಾಹ್ಯಾಕಾಶ CS50 ಕಡಿದು
ಮತ್ತು ಯಾವುದೇ ಕಾರಣಕ್ಕೆ ನಾವು ಮಾಡಿದ ಈಗಾಗಲೇ ನಮ್ಮ ದುರಾಸೆಯ ಪ್ರೋಗ್ರಾಂ ತಯಾರಿಸಲಾಗುತ್ತದೆ
ತಿಳಿಯಲು ಮತ್ತು ಈ ಕೆಲಸ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.
ನಾವು ಕೆಲಸ ಮಾಡುವಾಗ ನಾವು ಹಿಂದೆ ಮಾಡಲಿಲ್ಲ ದುರಾಸೆಯ ಸಮಸ್ಯೆಗೆ ಇದು ಮೇಲೆ,
ಆದರೆ ನಾವು ಈಗ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ನಾವು ಹೇಳಲು ಅವಕಾಶ ಇದು ಎಷ್ಟು ಪ್ರಕ್ರಿಯೆಯನ್ನು
ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಶೂನ್ಯ argv ಡಾಟ್ ಕತ್ತರಿಸಿ ಹಸಿವಿನ.
Argv ಒಂದು ಯಾವುದು?
ಅಲ್ಲದೆ, ಇದು ಬಲ, 1024 ಇಲ್ಲಿದೆ?
ಇದು 1024, ಆದರೆ ಇಲ್ಲಿ ಒಂದು ಇಲ್ಲಿದೆ ನಿಜವಾಗಿಯೂ ಪ್ರಮುಖ distinction--
ನೀವು argv ಆಫ್ ಮಾಹಿತಿ ಪ್ರಕಾರ ನೆನಪಿದೆಯೇ?
>> ಅದು ಸರಿ, ತಂತಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ?
ಆದರೆ 1024 ತೋರುತ್ತಿದೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ.
ಇದು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ
ಏನೋ ಆಗಲು ಹೋಗಿ ಎಂದು ನೀವು ನಂತರ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ.
Argv ಎಲ್ಲವನ್ನೂ ಸ್ಟ್ರಿಂಗ್ ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.
ಆದ್ದರಿಂದ argv ಒಬ್ಬರ ವಿಷಯಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಒಂದು, ಶೂನ್ಯ, ಎರಡು, ನಾಲ್ಕು,
ಆ ನಾಲ್ಕು ಪಾತ್ರಗಳು ಒಳಗೊಂಡಿರುವ.
ಇದು ಬಳಕೆದಾರ ಟೈಪ್ ವೇಳೆ ಇಲ್ಲಿದೆ ಒಂದು, ಶೂನ್ಯ, ಎರಡು, ನಾಲ್ಕು
ವೈಯಕ್ತಿಕ ಅಕ್ಷರಗಳ ಅಥವಾ ಪಾತ್ರಗಳು.
ಇದು, ಪೂರ್ಣಾಂಕ 1024 ಅಲ್ಲ ಮತ್ತು ನೀವು ನೇರವಾಗಿ ಸಾಧ್ಯವಿಲ್ಲ
ಇಂಟ್ 1,000 ಹೇಳುವ ಮೂಲಕ ಇದು ಕೆಲಸ, ಅಥವಾ ಬದಲಿಗೆ ಇಂಟ್ X argv ಒಂದು ಮೈನಸ್ 24 ಸಮನಾಗಿರುತ್ತದೆ.
>> ಅಪರೋಕ್ಷವಾಗಿ, ನೀವು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು , ಸರಿ, ಇದು 1,024 ಮೈನಸ್ 24 ಇಲ್ಲಿದೆ, ಎಂದು
ಆದ್ದರಿಂದ X 1,000 ಸಮಾನವಾಗಿರುತ್ತದೆ.
ಆದರೆ ವಾಸ್ತವವಾಗಿ, ಆ ಪ್ರಕರಣದಲ್ಲಿ ಅಲ್ಲ argv ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಕಾರಣ.
ಸ್ಟ್ರಿಂಗ್ 1024.
ಈಗ ಎಂದು ಕ್ರಿಯೆ ಇಲ್ಲ ಪೂರ್ಣಾಂಕಗಳ ತಂತಿಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಉಪಯೋಗಿಸಲಾಗುತ್ತದೆ.
ನಾನು ನೀವು ಅದನ್ನು ಹಾಳು ಮಾಡುವುದಿಲ್ಲ ಈಗ, ಆದರೆ ನಾನು Zamyla ಸಂದೇಹವಿಲ್ಲ
ಅದರ ಬಗ್ಗೆ ಹೇಳಲು ಸಂತೋಷವಾಗಿರುವಿರಿ ಭವಿಷ್ಯದ ಸಮಸ್ಯೆಗೆ ದರ್ಶನ.
ಆದರೆ ನೀವು ಕಾಣಬಹುದು ಸಮಸ್ಯೆಗಳು ಹಾಗೆ ಕ್ಷಮಿಸಿ
ನನಗೆ, ಕಾರ್ಯಗಳನ್ನು ಎಂದು ಎಂದು ಉಲ್ಲೇಖ 50 ಇದನ್ನು,
ನೀವು ಉಲ್ಲೇಖ ಕೈಪಿಡಿ ಹೋಗಿ ನೀವು ಒಂದು ಕಾರ್ಯ ಕಾಣಬಹುದು
ನೀವು ಈ ಪರಿವರ್ತನೆ ಮಾಡುತ್ತದೆ.
ಆದರೆ ಮತ್ತೆ, ದರ್ಶನ ಭವಿಷ್ಯದ ಸಮಸ್ಯೆಗೆ,
Zamyla ಸಂತೋಷವಾಗಿರುವಿರಿ ಯಾವ ಕಾರ್ಯವನ್ನು ಹೇಳಲು
ಆ ಪರಿವರ್ತಿಸುತ್ತದೆ ಆಗಿದೆ ಪೂರ್ಣಾಂಕ 1024 ಸ್ಟ್ರಿಂಗ್ 1024.
>> ಸರಿ, ಮುನ್ನಡೆಯುವ.
ನಾವು ನಮ್ಮ argv ಶೂನ್ಯ ಒಳಗೊಂಡಿದೆ ಬಂದಿದೆ ನಾವು ಒಂದು argv ಒಳಗೊಂಡಿದೆ ಬಂದಿದೆ.
ಏನು argv ಎರಡು ಇಲ್ಲಿದೆ?
CS50.
ಒಂದು ಬಹುಶಃ ಬಹಳ ಸ್ವಯಂ ವಿವರಣಾತ್ಮಕ.
ಏನು argv ಮೂರು ಇಲ್ಲಿದೆ?
ಸರಿ ಮತ್ತೆ, ನಾವು ನಿಜವಾಗಿಯೂ ಗೊತ್ತಿಲ್ಲ, ಬಲ?
ನಾವು, ಗಾತ್ರ ಮೂರು ಒಂದು ಸರಣಿ ಎಂದು ಎಷ್ಟು ಅಂಶಗಳನ್ನು ಬಳಕೆದಾರರಾಗಿದ್ದಾರೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಟೈಪಿಸಿದ, ಆದ್ದರಿಂದ ನಾವು ಮೂರು argv ಹೋದಾಗ,
ನಾವು ಈಗ ದಾಟಿ ನೀವು ನಮ್ಮ ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು.
ಕಂಪೈಲರ್, ನಮಗೆ ಈ ಮಾಡಲು ಅವಕಾಶ ಮಾಡುತ್ತದೆ ಯಾವುದೇ ಅರ್ಥಗರ್ಭಿತ ಸಮಸ್ಯೆ ಇದು ಇಲ್ಲ,
ಆದರೆ ವಾಸ್ತವವಾಗಿ ದೃಷ್ಟಿಯಿಂದ ವಿಶೇಷವೇನು ಸಂಭವಿಸಿ, ನಾವು ನಿಜವಾಗಿಯೂ ಗೊತ್ತಿಲ್ಲ.
ಇದು ಅವಲಂಬಿಸಿದೆ ಮೆಮೊರಿ ಅಲ್ಲಿ ಇದೆ
argv ಮೂರು ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ದೂರ ಸ್ಕಾಟ್ ಉಚಿತ ಪಡೆಯುವಲ್ಲಿ.
ಹೆಚ್ಚು ಅಲ್ಲದಿದ್ದರೂ, ವಿಶೇಷವಾಗಿ ವಿರುದ್ಧವಾಗಿ, argv ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಯಾವುದೇ ರಚನೆಯ ಎಂದು, ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಇಲ್ಲಿದೆ
ನಾವು ಬಹುಶಃ ಬಳಲುತ್ತಿದ್ದಾರೆ ನೀನು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ. ಆದ್ದರಿಂದ ಮತ್ತೆ,
ರಭಸದಿಂದ ಮೀರಿ ಹೆಜ್ಜೆ ಇಡು ಖಾತರಿಯಿಲ್ಲ ಎಂದು ನಿಮ್ಮ ಸಾಲುಗಳು, ವಿಶೇಷವಾಗಿ argv,
ಅದರ ಉನ್ನತ ಮಟ್ಟದ ನೀಡಲಾಗಿದೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಪ್ರಾಮುಖ್ಯತೆ.
>> ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.
ಈ CS50 ಹೊಂದಿದೆ.