[Powered by Google Translate] [CS50 ಲೈಬ್ರರಿ]
[ನೇಟ್ Hardison] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]
[ಈ CS50 ಹೊಂದಿದೆ. CS50.TV]
CS50 ಗ್ರಂಥಾಲಯದ ನಾವು ಉಪಕರಣದಲ್ಲಿ ಅನುಸ್ಥಾಪಿತವಾದ ಒಂದು ಉಪಯುಕ್ತ ಸಾಧನ
ನೀವು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಬರೆಯಲು ಸುಲಭವಾಗುತ್ತದೆ ಎಂದು ಇನ್ಪುಟ್ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಬಳಕೆದಾರರು.
ಈ ವಿಡಿಯೋ, ನಾವು ಕೂಡು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ಮಾಡುತ್ತೇವೆ ಮತ್ತು CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನಿಖರವಾಗಿ ಏನು ನೋಡೋಣ.
>> ಸಿ ಗ್ರಂಥಾಲಯಗಳು ಮೇಲೆ ವಿಡಿಯೋ, ನಾವು ನೀವು # ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಹೇಗೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು
ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಗ್ರಂಥಲಯದ,
ತದನಂತರ ನೀವು ಲಿಂಕ್ ಹಂತದಲ್ಲಿ ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತದಲ್ಲಿ ಲಿಂಕ್
ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯ.
ಹೆಡರ್ ಕಡತಗಳನ್ನು ಗ್ರಂಥಲಯದ ಇಂಟರ್ಫೇಸ್ ಸೂಚಿಸಿ.
ಎಂದು ಅವರು ವಿವರ ನೀವು ಬಳಸಲು ಗ್ರಂಥಾಲಯದ ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಹೊಂದಿದೆ
ಕಾರ್ಯ ಘೋಷಣೆಗಳು, ಸ್ಥಿರ, ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರಗಳು ನಂತಹ.
ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಫೈಲ್, ಗ್ರಂಥಾಲಯದ ಅನುಷ್ಠಾನಕ್ಕೆ ಒಳಗೊಂಡಿದೆ
ಇದು ಗ್ರಂಥಾಲಯದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಮತ್ತು ಗ್ರಂಥಾಲಯದಲ್ಲಿ. ಸಿ ಮೂಲ ಕೋಡ್ ಕಡತಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.
>> ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತ ಅದು ಬೈನರಿ ರಲ್ಲಿ, ಅಲ್ಲದೆ, ಅವರ ನಂತರ ನೋಡಲು ಕುತೂಹಲಕಾರಿ ಅಲ್ಲ.
ಆದ್ದರಿಂದ, ಶೀರ್ಷಿಕೆ ಗ್ರಂಥಾಲಯಕ್ಕೆ ಕಡತಗಳನ್ನು ಬದಲಿಗೆ ಅವಲೋಕಿಸೋಣ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, cs50.h. ಎಂಬ ಕೇವಲ ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಇಲ್ಲ
ನಾವು ಬಳಕೆದಾರರು ಅನುಸ್ಥಾಪನೆಯ ನೀವು ಕೋಶವನ್ನು ಸೇರಿವೆ
ಇತರ ವ್ಯವಸ್ಥೆಯ ಲೈಬ್ರರಿಗಳನ್ನು 'ಹೆಡರ್ ಕಡತಗಳನ್ನು ಜೊತೆಗೆ.
>> ನೀವು ಗಮನಿಸಿ ಮೊಟ್ಟ ಮೊದಲ ಕೆಲಸಗಳಲ್ಲಿ ಒಂದು cs50.h # ಇತರ ಲೈಬ್ರರಿಗಳಿಂದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಯನ್ನು ಹೊಂದಿದೆ -
ಫ್ಲೋಟ್, ಮಿತಿಗಳನ್ನು, ಪ್ರಮಾಣಿತ bool, ಮತ್ತು ಪ್ರಮಾಣಿತ lib.
ಮತ್ತೆ, ಚಕ್ರ `ಪುನರ್ ಶೋಧನೆ ಇಲ್ಲ ತತ್ವ ಅನುಸರಿಸಿ,
ನಾವು ಇತರ ನಮಗೆ ಒದಗಿಸಿದ ಉಪಕರಣಗಳು ಬಳಸಿಕೊಂಡು CS0 ಗ್ರಂಥಾಲಯ ನಿರ್ಮಾಣ ಮಾಡಿದ.
>> ನೀವು ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನೋಡುತ್ತಾರೆ ಮುಂದೆ ನಾವು ಎಂಬ ಹೊಸ ರೀತಿಯ ವ್ಯಾಖ್ಯಾನ ಎಂದು "ಸ್ಟ್ರಿಂಗ್."
ಈ ಲೈನ್ ನಿಜವಾಗಿಯೂ ಕೇವಲ ಚಾರ್ * ರೀತಿಯ ಅಲಿಯಾಸ್ ಸೃಷ್ಟಿಸುತ್ತದೆ,
ಆದ್ದರಿಂದ ಮಾಂತ್ರಿಕವಾಗಿ ಲಕ್ಷಣಗಳು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ imbue ಇಲ್ಲ
ಸಾಮಾನ್ಯವಾಗಿ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುಗಳ ಸಂಬಂಧಿತ
ಉದಾಹರಣೆಗೆ ಉದ್ದ.
ನಾವು ಮಾಡಿದ ಕಾರಣಕ್ಕಾಗಿ ರಕ್ತಸಿಕ್ತ ವಿವರಗಳನ್ನು ಹೊಸ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ರಕ್ಷಿಸಲು ಆಗಿದೆ
ಪಾಯಿಂಟರ್ಗಳ ಅವರು ಸಿದ್ಧರಾಗಿರುವಾಗ ರವರೆಗೆ.
>> ಹೆಡರ್ ಕಡತವನ್ನು ಮುಂದಿನ ಭಾಗವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಘೋಷಣೆಯಾಗಿದೆ
CS50 ಗ್ರಂಥಾಲಯದ ದಸ್ತಾವೇಜನ್ನು ಜೊತೆಗೆ ಒದಗಿಸುತ್ತದೆ.
ಇಲ್ಲಿ ಕಾಮೆಂಟ್ಗಳನ್ನು ವಿವರವಾಗಿ ಮಟ್ಟವನ್ನು ಗಮನಿಸಿ.
ಜನರು ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಗೊತ್ತಿಲ್ಲ ಆದ್ದರಿಂದ ಈ ಪ್ರಮುಖ ಸೂಪರ್ ಆಗಿದೆ.
ನಾವು ಪ್ರತಿಯಾಗಿ, ಘೋಷಿಸಲು, ಬಳಕೆದಾರ ಮತ್ತು ರಿಟರ್ನ್ ಅಕ್ಷರಗಳನ್ನು, ಡಬಲ್ಸ್, ಫ್ಲೋಟ್ಗಳು, ints, ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ
ದೀರ್ಘ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ತಂತಿಗಳು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ ಬಳಸಿ.
ಇನ್ಫರ್ಮೇಷನ್ ಹೈಡಿಂಗ್ ತತ್ವ ಅನುಸರಿಸಿ,
. ನಾವು ಪ್ರತ್ಯೇಕ ಸಿ ಅನುಷ್ಠಾನ ಕಡತದಲ್ಲಿ ನಮ್ಮ ವ್ಯಾಖ್ಯಾನ ಹಾಕಬಹುದು - cs50.c--
ಬಳಕೆದಾರ ಮೂಲ ಕೋಶದಲ್ಲಿ ಇದೆ.
ನೀವು ಒಂದು ನೋಟ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ ನಾವು ಆ ಕಡತ ಒದಗಿಸಲಾದ
ಅದರಿಂದ ತಿಳಿಯಲು, ಮತ್ತು ನೀವು ಬಯಸಿದರೆ ವಿವಿಧ ಗಣಕಗಳಲ್ಲಿ ಇದು ಮರುಸಂಕಲಿಕೆಯು,
ನಾವು ಈ ವರ್ಗದ APPLIANCE ಕೆಲಸ ಮಾಡಲು ಉತ್ತಮ ಭಾವಿಸುತ್ತೇನೆ ಸಹ.
ಹೇಗಾದರೂ, ಈಗ ಅದು ಒಂದು ಅವಲೋಕಿಸೋಣ.
>> ಕಾರ್ಯಗಳನ್ನು GetChar, GetDouble, GetFloat, GetInt, ಮತ್ತು GetLongLong
ಎಲ್ಲಾ GetString ಕ್ರಿಯೆಯ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.
ಅವರು ಎಲ್ಲಾ ಅದೇ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ತಿರುಗುತ್ತದೆ.
ಅವರು ಇನ್ಪುಟ್ ಒಂದು ಸಾಲಿನ ಬಳಕೆದಾರ ಮಾಡುವಂತೆ ಸ್ವಲ್ಪ ಲೂಪ್ ಅನ್ನು.
ಅವರು ಯೂಸರ್ ಇನ್ಪುಟ್ಸ್ ಖಾಲಿ ಸಾಲು ವೇಳೆ ವಿಶೇಷ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.
ಅವರು, ಸೂಕ್ತ ರೀತಿಯ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಪಾರ್ಸ್ ಪ್ರಯತ್ನ
ಅದು ಅಕ್ಷರ, ಎರಡು, ಒಂದು ಫ್ಲೋಟ್, ಇತ್ಯಾದಿ ಎಂದು
ಇನ್ಪುಟ್ ಯಶಸ್ವಿಯಾಗಿ ಪಾರ್ಸ್ ಎಂದು ಅವನ್ನು ಎರಡೂ ಪರಿಣಾಮವಾಗಿ ಹಿಂತಿರುಗಿ
ಅಥವಾ ಬಳಕೆದಾರ reprompt.
>> ಒಂದು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ, ನಿಜವಾಗಿಯೂ ಟ್ರಿಕಿ ಏನೂ ಇಲ್ಲಿ ಇಲ್ಲ.
ನೀವು ಹಿಂದೆ ಇದೇ ರಚನಾತ್ಮಕ ಕೋಡ್ ನೀವೇ ಬರೆದಿದ್ದಾರೆ ಇರಬಹುದು.
ಬಹುಶಃ ಅತ್ಯಂತ ರಹಸ್ಯ ಕಾಣುವ ಭಾಗ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ parses ಎಂದು sscanf ಕರೆಯಾಗಿದೆ.
Sscanf ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕುಟುಂಬದ ಭಾಗವಾಗಿದೆ.
, ಅದು ಪ್ರಮಾಣಿತ io.h ವಾಸಿಸುತ್ತಾರೆ, ಮತ್ತು ಅದರ ಕೆಲಸ ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಪರ್ಸ್ ಮಾಡುವ
ವೇರಿಯಬಲ್ ಅನ್ನು ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ವರೂಪ ಪ್ರಕಾರ
ಕಾಲರ್ ಒದಗಿಸಿದ.
ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕಾರ್ಯಗಳನ್ನು ತುಂಬಾ ಉಪಯುಕ್ತ, ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರಣ
, ಮೊದಲು ಅಂತರ್ಬೋಧೆಯ ಸೂಪರ್ ಎಂದು
ನಾವು sscanf ಕೆಲಸ ಹೇಗೆ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ.
>> sscanf ಮೊದಲ ವಾದವನ್ನು ಒಂದು ಚಾರ್ * ಹೊಂದಿದೆ - ಒಂದು ಅಕ್ಷರಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್.
ಕಾರ್ಯವನ್ನು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು
ಆ ಪಾತ್ರ, ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಅಕ್ಷರ ಆಗಿರಬೇಕು
ಶೂನ್ಯ \ 0 ಅಕ್ಷರದೊಂದಿಗೆ ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ.
ಈ ಪಾರ್ಸ್ ಸರಣಿಯನ್ನು ಹೊಂದಿದೆ
sscanf ಎರಡನೇ ವಾದ, ಒಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ
ವಿಶಿಷ್ಟವಾಗಿ, ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ರಲ್ಲಿ ಜಾರಿಗೆ
ಮತ್ತು ನೀವು printf ಬಳಸುವಾಗ ಮೊದಲು ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನೋಡಿರಬಹುದು.
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಶೇಕಡಾ ಚಿಹ್ನೆ ಒಂದು ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಸೂಚಿಸುತ್ತದೆ.
ಅಕ್ಷರ ತಕ್ಷಣ, ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ನಂತರ
ನಾವು ಮತಾಂತರಗೊಳ್ಳಲು sscanf ಬಯಸುವ ಸಿ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
GetInt, ನೀವು ಒಂದು% s ಮತ್ತು% ಸಿ ಎಂದು ನೋಡಿ.
% D - - ಮತ್ತು ಚಾರ್ -% ಸಿ ಈ sscanf ಒಂದು ದಶಮಾಂಶ ಇಂಟ್ ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಎಂದರ್ಥ.
ಫಾರ್ಮ್ಯಾಟ್ ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಗೆ,
sscanf ತನ್ನ ವಾದವನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ವಾದದ ನಂತರ ನಿರೀಕ್ಷಿಸುತ್ತದೆ.
ಎಂಬ ವಾದವನ್ನು ಒಂದು ಸೂಕ್ತವಾಗಿ ಟೈಪ್ ಸ್ಥಳ ಬೆಟ್ಟು ಮಾಡಬೇಕು
ಪರಿವರ್ತನೆ ಫಲಿತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು ಇದರಲ್ಲಿ.
>> ಈ ಮಾಡುವ ವಿಶಿಷ್ಟ ರೀತಿಯಲ್ಲಿ sscanf ಕರೆ ಮೊದಲು ಸ್ಟಾಕ್ ಮೇಲೆ ವೇರಿಯಬಲ್ ರಚಿಸುವುದು
ನೀವು ದಾರದಿಂದ ಪಾರ್ಸ್ ಬಯಸುವ ಪ್ರತಿ ಐಟಂಗೆ
ಪಾಯಿಂಟರ್ಸ್ ರವಾನಿಸಲು - ವನ್ನಾಗಲಿ - ತದನಂತರ ವಿಳಾಸಕ್ಕೆ ಆಯೋಜಕರು ಬಳಸಿ
sscanf ಕರೆ ಆ ಏರುಪೇರುಗಳಲ್ಲಿ.
ನೀವು GetInt ನಾವು ನಿಖರವಾಗಿ ಇದನ್ನು ಕಾಣಬಹುದು.
ಬಲ sscanf ಕರೆ ಮೊದಲು, ನಾವು, n ಎಂಬ ಒಂದು ಇಂಟ್ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಚಾರ್ ಕರೆ ಸಿ ಘೋಷಿಸಲು
ಮತ್ತು ನಾವು sscanf ಕರೆ ಅವುಗಳನ್ನು ರೀತಿಯು ಹಾದುಹೋಗುತ್ತವೆ.
ಸ್ಟಾಕ್ ಈ ಅಸ್ಥಿರಗಳು ಪುಟ್ಟಿಂಗ್ ನಿಯೋಜಿತವಾದ ಸ್ಥಳವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಆದ್ಯತೆ
ನೀವು malloc ಕರೆಯ ಓವರ್ಹೆಡ್ ತಪ್ಪಿಸಲು ರಿಂದ malloc ಹೊಂದಿರುವ ರಾಶಿ, ಮೇಲೆ,
ಮತ್ತು ನೀವು ಮೆಮೊರಿ ಸೋರಿಕೆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.
ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ಅದಕ್ಕೆ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಅಕ್ಷರಗಳು ಪರಿವರ್ತನೆ ಮಾಡುವಂತೆ ಇಲ್ಲ.
ಬದಲಿಗೆ ಅವರು ಸ್ವರೂಪದ ವಿಶಿಷ್ಟ ಸೇರಿಸಲು.
>> ಉದಾಹರಣೆಗೆ, GetInt ಸ್ವರೂಪದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಬದಲಿಗೆ% s ಆಗಿದ್ದರೆ,
sscanf, ಒಂದು int ನಂತರ ಪತ್ರವನ್ನು ನೋಡಿ ಎಂದು
ಇದು ಇಂಟ್ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಾಗಿ ಸಂದರ್ಭದಲ್ಲೇ ಇದು ಒಂದು ಜೊತೆ ಬೇರೆ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.
ಈ ಮಾತ್ರ ಹೊರತುಪಡಿಸಿ ಜಾಗಗಳನ್ನು ಹೊಂದಿದೆ.
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ವೈಟ್ ಜಾಗದ ಅಕ್ಷರಗಳನ್ನು ಜಾಗಗಳನ್ನು ಯಾವುದೇ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿಸಲು -
ಎಲ್ಲಾ ನಲ್ಲಿಯೂ ಯಾವುದೇ.
ಕಾಮೆಂಟ್ ಪ್ರಮುಖ ಮತ್ತು / ಅಥವಾ ಜಾಗಗಳನ್ನು ಹಿಂದುಳಿದಿದ್ದರು ಜೊತೆ ಪ್ರಾಯಶಃ ಉಲ್ಲೇಖಿಸುತ್ತಾನೆ ಏಕೆ, ಇದು.
ಆದ್ದರಿಂದ, ನಮ್ಮ sscanf ಕರೆ ತೋರುತ್ತಿದೆ ಈ ಹಂತದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವಾಕ್ಯವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ
ಸಂಭಾವ್ಯ ಪ್ರಮುಖ ಜಾಗಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಮೂಲಕ,
ಇಂಟ್ ವೇರಿಯಬಲ್ N ಪರಿವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಒಂದು ಇಂಟ್ ನಂತರ
ಜಾಗಗಳನ್ನು ಸ್ವಲ್ಪ ನಂತರ, ಮತ್ತು ಒಂದು ಪಾತ್ರದ ನಂತರ
ಚಾರ್ ವೇರಿಯಬಲ್ ಸಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.
>> ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಏನು?
Sscanf, ಪೂರ್ಣಗೊಳಿಸಲು ಪ್ರಾರಂಭದಿಂದ ಆದಾನ ಸಾಲಿನಲ್ಲಿ ಪಾರ್ಸ್ ಕಾಣಿಸುತ್ತದೆ
ಆದಾನ ಒಂದು ಗುಣವು ತುದಿಯನ್ನು ತಲುಪಿದಾಗ ನಿಲ್ಲಿಸುವ ಅಥವಾ
ಒಂದು ರೂಪದಲ್ಲಿ ಪಾತ್ರ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಅಥವಾ ಒಂದು ಪರಿವರ್ತನೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಮಾಡಿದಾಗ.
ಅದನ್ನು ಮರಳಿ ಮೌಲ್ಯವನ್ನು ನಿಲ್ಲಿಸಿದಾಗಿನಿಂದ ಪ್ರತ್ಯೇಕವಾದಿ ಬಳಸಲಾಗುತ್ತದೆ.
ಇದು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯನ್ನು ತಲುಪಿದ ಕಾರಣ, ನಿಲ್ಲಿಸಿದ ವೇಳೆ
ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮುನ್ನ ಮತ್ತು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಭಾಗವಾಗಿ ಹೊಂದಿಸಲು ವಿಫಲಗೊಳ್ಳುವ ಮುಂಚೆ ಮೊದಲಿಗೆ,
ನಂತರ ವಿಶೇಷ ಸ್ಥಿರ EOF ಮರಳಿ.
ಇಲ್ಲವಾದರೆ, ಅದು ಯಶಸ್ವಿ ಮಾರ್ಪಾಡುಗಳ ಸಂಖ್ಯೆಯಿಂದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ನಾವು ಎರಡು ಪರಿವರ್ತನೆಗಾಗಿ ಕೇಳಿದ್ದೀರಿ ಏಕೆಂದರೆ ಇದು, 0, 1, ಅಥವಾ 2 ಎಂದು.
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನಾವು ಬಳಕೆದಾರರು ಇಂಟ್ ಮತ್ತು ಕೇವಲ ಒಂದು ಇಂಟ್ ಬೆರಳಚ್ಚಿಸಿದ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.
>> ಆದ್ದರಿಂದ, ನಾವು sscanf 1 ಮರಳಲು ಬಯಸುವ. ಏಕೆ ನೋಡಿ?
Sscanf 0 ಮರಳಿದರು, ನಂತರ ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮಾಡಲಾಯಿತು,
ಆದ್ದರಿಂದ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಇಂಟ್ ಬೇರೆಯಾಗಿರುತ್ತದೆ ಟೈಪಿಸಿದ.
Sscanf 2 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ, ನಂತರ ಬಳಕೆದಾರರು ಸರಿಯಾಗಿ, ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಅದನ್ನು ಟೈಪ್ ಮಾಡಲಿಲ್ಲ
ಆದರೆ ಅವರು ನಂತರ ಕೆಲವು ಅಲ್ಲದ ಜಾಗಗಳನ್ನು ಪಾತ್ರ ಬೆರಳಚ್ಚಿಸಿದ
% ರಿಂದ C ಪರಿವರ್ತನೆ ಯಶಸ್ವಿಯಾದರು.
ವಾಹ್, ಎಂದು ಸ್ವಲ್ಪ ಒಂದು ಫಂಕ್ಷನ್ ಕರೆಗೆ ಸುದೀರ್ಘ ವಿವರಣೆ ಇಲ್ಲಿದೆ.
ಹೇಗಾದರೂ, ನೀವು sscanf ಮತ್ತು ಅದರ ಸಿಬ್ಲಿಂಗ್ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಬೇಕಾದರೆ,
ಮನುಷ್ಯ ಪುಟಗಳು, ಗೂಗಲ್, ಅಥವಾ ಎರಡೂ ಪರಿಶೀಲಿಸಿ.
ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಾಕಷ್ಟು ಇವೆ
ಸಿ ರಲ್ಲಿ ತಂತಿಗಳನ್ನು ಪಾರ್ಸ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ ಮತ್ತು ಈ ಹಸ್ತಚಾಲಿತ ಕಾರ್ಮಿಕ ಸಾಕಷ್ಟು ಉಳಿಸಬಹುದು
>> ನೋಡಲು ಗ್ರಂಥಾಲಯದ ಅಂತಿಮ ಕ್ರಿಯೆ GetString ಹೊಂದಿದೆ.
ಇದು GetString ಸರಿಯಾಗಿ ಬರೆಯಲು ಟ್ರಿಕಿ ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ
ಅದು ಒಂದು ಸರಳ, ಸಾಮಾನ್ಯ ಕೆಲಸವನ್ನು ಹಾಗೆ ತೋರುತ್ತದೆ ಸಹ.
ಏಕೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ?
ಅಲ್ಲದೆ, ನ ಹೇಗೆ ನಾವು ಲೈನ್ ಶೇಖರಿಸಿಡಲು ನೀನು ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಲು ಸೈನ್ ಬಳಕೆದಾರ ವಿಧಗಳು
ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಅನುಕ್ರಮದ, ಏಕೆಂದರೆ
ನಾವು, ಸ್ಟಾಕ್ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇದು ಶೇಖರಿಸಿಡಲು ಬಯಸಬಹುದು
ಆದರೆ ನಾವು ಅದನ್ನು ಘೋಷಿಸಬಹುದು ಮಾಡಿದಾಗ ವ್ಯೂಹ ಎಂದು ಹೋಗುತ್ತದೆ ಎಷ್ಟು ತಿಳಿಯಲು ಅಗತ್ಯವಿದೆ.
ಹಾಗೆಯೇ, ನಾವು ರಾಶಿ ಮೇಲೆ ಹಾಕಲು ಬಯಸಿದಲ್ಲಿ,
ನಾವು, malloc ನಾವು ಮೀಸಲು ಬಯಸುವ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ಪಾಸ್ ಅಗತ್ಯವಿದೆ
ಆದರೆ ಈ ಅಸಾಧ್ಯ.
ನಾವು ಬಳಕೆದಾರರು ಟೈಪ್ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಕಲ್ಪನೆಯೂ ಇಲ್ಲ
ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಟೈಪ್ ಮೊದಲು.
>> ಈ ಸಮಸ್ಯೆಗೆ ಸರಳ ಪರಿಹಾರ ಕೇವಲ, ಜಾಗವನ್ನು ದೊಡ್ಡ ಚಂಕ್ ಕಾಯ್ದಿರಿಸಬೇಕು ಹೇಳುತ್ತಾರೆ, ಆಗಿದೆ
ಬಳಕೆದಾರರ ಸೇರಿಸುವ 1000 ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಬ್ಲಾಕ್,
ಬಳಕೆದಾರ ದೀರ್ಘ ಸ್ಟ್ರಿಂಗ್ ಟೈಪ್ ಎಂದಿಗೂ ಎಂದು ಊಹಿಸಿ.
ಈ ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ ಒಂದು ಕೆಟ್ಟ ಕಲ್ಪನೆ.
ಮೊದಲು, ಬಳಕೆದಾರರು ಸಾಮಾನ್ಯವಾಗಿ ದೀರ್ಘ ತಂತಿಗಳನ್ನು ಟೈಪ್ ಎಂದು ಊಹಿಸಿಕೊಂಡು
ನೀವು ಮೆಮೊರಿ ಸಾಕಷ್ಟು ತ್ಯಾಜ್ಯವನ್ನು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.
ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ ಆಧುನಿಕ ಗಣಕಗಳಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಇರಬಹುದು
ಒಂದು ಅಥವಾ ಎರಡು ಪ್ರತ್ಯೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ,
ಆದರೆ ನೀವು ಒಂದು ಆವರ್ತನದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಂಡು ನಂತರ ಬಳಕೆಗೆ ಸಂಗ್ರಹಿಸುವ ಬಳಸುತ್ತಿದ್ದರೆ,
ನೀವು ಬೇಗನೆ ಮೆಮೊರಿಯ ಒಂದು ಟನ್ ಅಪ್ ಹೀರುವಂತೆ ಮಾಡಬಹುದು.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಸಣ್ಣ ಕಂಪ್ಯೂಟರ್ ಹೊಂದಿದೆ -
ಸೀಮಿತ ಮೆಮೊರಿಯಲ್ಲಿ ಸ್ಮಾರ್ಟ್ಫೋನ್ ಅಥವಾ ಯಾವುದೋ ಒಂದು ಸಾಧನ -
ಈ ಪರಿಹಾರವನ್ನು ಸಾಕಷ್ಟು ವೇಗವಾಗಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಈ ಮಾಡದಿರುವುದು ಎರಡನೇ, ಗಂಭೀರ ಕಾರಣ ಇದು ದುರ್ಬಲ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಲೆಗಳನ್ನು ಅಂದರೆ
ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿ ಎಂಬ ಏನನ್ನು ಮಾಡಲು.
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಬಫರ್, ತಾತ್ಕಾಲಿಕವಾಗಿ ಇನ್ಪುಟ್ ಅಥವಾ ಹೊರಹೋಗುವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮೆಮೊರಿ ಹೊಂದಿದೆ
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ 1000-ಚಾರ್ ಬ್ಲಾಕ್ ಇದು.
ದತ್ತಾಂಶ ವಿಭಾಗಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ಕಳೆದ ಬರೆಯಲಾಗಿದೆ ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ಸಂಭವಿಸುತ್ತದೆ.
>> ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಳಕೆದಾರ ವಾಸ್ತವವಾಗಿ 1000 ಕ್ಕೂ ಹೆಚ್ಚು ಅಕ್ಷರಗಳನ್ನು ಟೈಪ್ ಮಾಡಿದರೆ.
ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಅನುಭವಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.
ನೀವು 10 ints ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಏನೂ ಓದಲು ಅಥವಾ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುವಾಗ ನೀವು ನಿಲ್ದಾಣಗಳು
15 ಇಂಟ್.
ಯಾವುದೇ ಕಂಪೈಲರ್ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಅಥವಾ ದೋಷಗಳಿವೆ.
ಪ್ರೋಗ್ರಾಂ ಕೇವಲ ನೇರವಾಗಿ ಮುಂದಕ್ಕೆ ಪ್ರಮಾದಗಳ ಮತ್ತು ಮೆಮೊರಿ ಪ್ರವೇಶ
ಇದು ಯೋಚಿಸುತ್ತಾನೆ ಅಲ್ಲಿ 15 ಇಂಟ್ ಆಗಿರುತ್ತದೆ, ಮತ್ತು ಇದು ನಿಮ್ಮ ಇತರ ಅಸ್ಥಿರ ಬದಲಿಸಿ.
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆಂತರಿಕ ಕೆಲವು ಬದಲಿಸಿ
ನಿಯಂತ್ರಣ ಕಾರ್ಯವಿಧಾನಗಳು, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾರಣವಾಗುತ್ತದೆ ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು
ನೀವು ಉದ್ದೇಶಿಸಿದ ಹೆಚ್ಚು.
>> ಈಗ, ಇದು, ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಮಾಡಲು ಸಾಮಾನ್ಯ ಅಲ್ಲ
ಆದರೆ ಈ ಕೆಟ್ಟ ಜನರು ಕಾರ್ಯಕ್ರಮಗಳು ಮುರಿಯಲು ಬಳಸುವ ಒಂದು ಸರ್ವೇಸಾಮಾನ್ಯ ತಂತ್ರ
ಮತ್ತು ಇತರ ಜನರ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಪುಟ್.
ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ನಿಷ್ಕಪಟ ಪರಿಹಾರ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ನಾವು ಖಂಡನೀಯವಾಗಿರುವ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಒಂದು ದಾರಿ ಬೇಕಿದೆ
ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿಗೆ.
ಇದನ್ನು ಮಾಡಲು, ನಾವು ಓದುವ ನಮ್ಮ ಬಫರ್ ಬೆಳೆಯುತ್ತವೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ
ಬಳಕೆದಾರ ಹೆಚ್ಚಿನ ಇನ್ಪುಟ್.
ಪರಿಹಾರ? ನಾವು ರಾಶಿ ನಿಯೋಜಿತವಾದ ಬಫರ್ ಅನ್ನು.
ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಇದು, ಗಣಕತೆರೆ realloc ಕಾರ್ಯ ಬಳಸಿ
ಮತ್ತು ನಾವು ಎರಡು ಸಂಖ್ಯೆಗಳ ಟ್ರ್ಯಾಕ್ - ಮುಂದಿನ ಖಾಲಿ ಸ್ಲಾಟ್ ಸೂಚಕ ಬಫರ್
ಮತ್ತು ಉದ್ದ ಅಥವಾ ಬಫರ್ ಸಾಮರ್ಥ್ಯ.
ನಾವು fgetc ಕಾರ್ಯಕಾರಿತ್ವ ಬಳಸಿಕೊಂಡು ಒಂದು ಸಮಯದಲ್ಲಿ ಬಳಕೆದಾರ ಒಂದರಿಂದ ಅಕ್ಷರಗಳನ್ನು ಓದಲು.
stdin - - fgetc ಕಾರ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆರ್ಗ್ಯುಮೆಂಟ್, ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಉಲ್ಲೇಖವಾಗಿತ್ತು
ಇದು ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವರ್ಗಾಯಿಸಲು ಬಳಸುವ preconnected ಇನ್ಪುಟ್ ಚಾನಲ್ನಲ್ಲಿ
ಟರ್ಮಿನಲ್ ನಿಂದ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ.
>> ಯಾವಾಗ ಒಂದು ಹೊಸ ಪಾತ್ರದ ಬಳಕೆದಾರ ರೀತಿಯ ನಾವು ಪರೀಕ್ಷಿಸಿ ವೇಳೆ ಸೂಚ್ಯಂಕ
ಮುಂದಿನ ಉಚಿತ ಸ್ಲಾಟ್ ಆಫ್ ಪ್ಲಸ್ 1 ಬಫರ್ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ.
+1, ಮುಂದಿನ ಉಚಿತ ಸೂಚ್ಯಂಕ 5 ವೇಳೆ ಏಕೆಂದರೆ ಬರುತ್ತದೆ
ನಂತರ ನಮ್ಮ ಬಫರ್ ಉದ್ದವು 6 ಧನ್ಯವಾದಗಳು 0 ಅನುಕ್ರಮಣಿಕೆ ಇರಬೇಕು.
ನಾವು ಬಫರ್ ಸ್ಥಳವು ನೀವು, ನಾವು, ಅದನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಪ್ರಯತ್ನ
ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಆ ಬಾರಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಕಡಿಮೆ ಇದರಿಂದ ಡಬಲ್
ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಬಹಳ ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸುವುದನ್ನು ವೇಳೆ.
ಸ್ಟ್ರಿಂಗ್ ತುಂಬಾ ನೆತ್ತಿಗೇರಿದೆ ಅಥವಾ ನಾವು ರಾಶಿ ಮೆಮೊರಿಯ ರನ್ ಔಟ್ ವೇಳೆ ವೇಳೆ,
ನಮ್ಮ ಬಫರ್ ಮತ್ತು ರಿಟರ್ನ್ ಶೂನ್ಯ ಮುಕ್ತಗೊಳಿಸಲು.
>> ಅಂತಿಮವಾಗಿ, ನಾವು ಬಫರ್ ಗೆ ಚಾರ್ ಸೇರಿಸಿಕೊಳ್ಳುತ್ತವೆ.
ಬಳಕೆದಾರ ಹಿಟ್ ನಮೂದಿಸಿ ಅಥವಾ ಮರಳಿ, ಹೊಸ ಲೈನ್ ಸಂಕೇತ, ಒಮ್ಮೆ
ಅಥವಾ ವಿಶೇಷ ಚಾರ್ - ನಿಯಂತ್ರಣ D - ಇನ್ಪುಟ್ ಒಂದು ಕೊನೆಯಲ್ಲಿ ಸಂಕೇತಗಳನ್ನು,
ನಾವು ಬಳಕೆದಾರರು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲ ಏನು ಬೆರಳಚ್ಚಿಸಿದ ನೀವು ಒಂದು ಚೆಕ್ ಮಾಡಿ.
ಅಲ್ಲ, ನಾವು ಶೂನ್ಯ ಹಿಂತಿರುಗಿ.
ಇಲ್ಲದಿದ್ದರೆ, ನಮ್ಮ ಬಫರ್ ನಾವು ಅವಶ್ಯಕತೆ ಹೆಚ್ಚು ಬಹುಶಃ ದೊಡ್ಡ ಕಾರಣ,
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಮಗೆ ಸುಮಾರು ಎರಡು ಪಟ್ಟು ದೊಡ್ಡದಾಗಿರುವುದರಿಂದ
ನಾವು ಗಾತ್ರ ಬದಲಾವಣೆ ಪ್ರತಿ ಬಾರಿ ಡಬಲ್, ಏಕೆಂದರೆ
ನಾವು ಅಗತ್ಯವಿರುವ ಜಾಗವನ್ನು ಕೇವಲ ಪ್ರಮಾಣವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ಹೊಸ ನಕಲನ್ನು ಮಾಡಿ.
ನಾವು, malloc ಕರೆಗೆ ಹೆಚ್ಚುವರಿ 1 ಸೇರಿಸಿ
\ 0, - ವಿಶೇಷ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರಕ್ಕೆ ಸ್ಥಳವಿರುವ ಎಂದು ಆದ್ದರಿಂದ
ಇದು ನಾವು ಪಾತ್ರಗಳು ಉಳಿದ ನಕಲಿಸಿ ಒಮ್ಮೆ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಸೇರಿಸಲು,
ಬದಲಿಗೆ strcpy ಆಫ್ strncpy ಬಳಸಿ
ಆದ್ದರಿಂದ ನಾವು ನಕಲಿಸಲು ಬಯಸುವ ನಿಖರವಾಗಿ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಸೂಚಿಸಬಹುದು.
ಇದು \ 0 ತಾಗುತ್ತದೆ ರವರೆಗೆ Strcpy ನಕಲಿಸುತ್ತದೆ.
ನಂತರ ನಮ್ಮ ಬಫರ್ ಮುಕ್ತಗೊಳಿಸಲು ಮತ್ತು ಕಾಲರ್ ಗೆ ಪ್ರತಿಯನ್ನು ಮರಳಿ.
>> ಯಾರು ಇಂತಹ ಸರಳ ತೋರಿಕೆಯ ಕಾರ್ಯ ಸಂಕೀರ್ಣಗೊಳಿಸಿದೆ ಎಂದು ತಿಳಿದಿದ್ದರು?
ಈಗ ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯೋಣ.
>> ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.
[CS50.TV]