>> ಸ್ಪೀಕರ್: ಇಲ್ಲಿಯವರೆಗೆ, ಇದು ಸಾಧ್ಯತೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಎಂದು
ಸ್ವಲ್ಪ ನಶ್ವರ ಎಂದು.
ನೀವು ಮಾರಿಯೋ ಅಥವಾ ದುರಾಸೆಯ ಒಂದು ಪ್ರೋಗ್ರಾಂ ರನ್.
ಇದು ಬಹುಶಃ ಅಪೇಕ್ಷಿಸುತ್ತದೆ, ಏನೋ ಮಾಡುತ್ತದೆ ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಬಳಕೆದಾರರನ್ನು,
ತೆರೆಗೆ ಕೆಲವು ಔಟ್ಪುಟ್ ಮುದ್ರಿಸಿ ಆದರೆ ನಂತರ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ಮುಗಿಯುವ
ಯಾವುದೇ ಪುರಾವೆಗಳು ನಿಜವಾಗಿಯೂ ಇಲ್ಲ ಇದು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ನಡೆಸುತ್ತಿದ್ದರು.
ನಾನು ಖಚಿತವಾಗಿ, ನೀವು ಬಿಟ್ಟು ಇರಬಹುದು, ಅರ್ಥ ಇದು, ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ತೆರೆಯಿರಿ
ನಿಮ್ಮ ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ವೇಳೆ, ಇಲ್ಲ ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಪುರಾವೆ.
ನಾವು ಸಂಗ್ರಹಿಸುವ ಸಾಧನವಾಗಿ ಇಲ್ಲ ನಿರಂತರ ಮಾಹಿತಿ, ಮಾಹಿತಿ
ನಮ್ಮ ನಂತರ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಸ್ಥಗಿತಗೊಂಡಿದೆ,
ಅಥವಾ ನಾವು ಈ ಹಂತದವರೆಗೆ ಮಾಡಿಲ್ಲ.
ಅದೃಷ್ಟವಶಾತ್ ಆದರೂ, ಸಿ ಮಾಡುತ್ತದೆ ಸಾಮರ್ಥ್ಯವನ್ನು ನಮಗೆ ಒದಗಿಸುತ್ತದೆ
ಅಳವಡಿಸಿಕೊಂಡು ಇದನ್ನು ಕರೆಯುವುದನ್ನು
ಒಂದು ಕಡತವನ್ನು ಒಂದು ರಚನೆ ಮೂಲತಃ ನೀವು ದುಪ್ಪಟ್ಟಾದ ಒಂದು ಕಡತ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
ನೀವು ಇಂತಹ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಕ್ಲಿಕ್ ಒಂದು ರೇಖಾತ್ಮಕ ಬಳಕೆದಾರ ವಾತಾವರಣದೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ.
ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡುವಾಗ ಸಿ, ನಾವು ವಾಸ್ತವವಾಗಿ ಆರ್
ಕೆಲಸ ಹೋಗುವ ಪಾಯಿಂಟರ್ಸ್ ಕಡತ ಕಡತಗಳನ್ನು ಗೆ stars--
ಸ್ವಲ್ಪ ಹೊರತುಪಡಿಸಿ ನಾವು ಒಂದೆರಡು ಬಗ್ಗೆ ಮಾತನಾಡಿ
ಕಾರ್ಯಗಳನ್ನು ಎಂದು ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ.
ನೀವು ನಿಜವಾಗಿಯೂ ಅಗೆದು ಹೊಂದಿವೆ ಮಾಡಬೇಕಿಲ್ಲ ತಿಳುವಳಿಕೆ ಪಾಯಿಂಟರ್ಸ್ ತುಂಬಾ ಆಳವಾದ
ತಮ್ಮನ್ನು.
ಸ್ವಲ್ಪ ಚಿಕ್ಕ ಬಿಟ್ ಇಲ್ಲ ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಅಲ್ಲಿ,
ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಫೈಲ್ ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್, ಪರಸ್ಪರ ಆದರೆ,
ಒಂದೇ ವಿಷಯ ಅಲ್ಲ.
>> ಈಗ ನಾನು ಯಾವಾಗ ಅರ್ಥವೇನು ನಾನು ನಿರಂತರ ಡೇಟಾ ಹೇಳುತ್ತಾರೆ?
ನಿರಂತರ ಡೇಟಾ ಏನು?
ನಾವು ಅದರ ಬಗ್ಗೆ ಏಕೆ ಕಾಳಜಿ ಇಲ್ಲ?
ಎಂದು, ಉದಾಹರಣೆಗೆ, ಸೇ ನೀವು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ
ಅಥವಾ ನೀವು ಬರೆದಿದ್ದೇವೆ ಒಂದು ಒಂದು ಆಟವಾಗಿದೆ ಎಂದು ಪ್ರೋಗ್ರಾಂ,
ಮತ್ತು ನೀವು ಟ್ರ್ಯಾಕ್ ಬಯಸುವ ಬಳಕೆದಾರರ ಚಲಿಸುತ್ತದೆ ಎಲ್ಲಾ
ಆದ್ದರಿಂದ ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ಬಹುಶಃ ವೇಳೆ, ನೀವು ಆಟದ ನಂತರ ಕಡತ ವಿಮರ್ಶಿಸುವುದರ.
ಆ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಅರ್ಥ ಇಲ್ಲಿದೆ ನಿರಂತರ ಮಾಹಿತಿ ಬಗ್ಗೆ ಮಾತನಾಡಲು.
>> ಓಟದ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ಒಂದು ಫೈಲ್ ಅನ್ನು ರೂಪಿಸಿದಾಗ.
ಮತ್ತು ಯಾವಾಗ ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಗಿತಗೊಂಡಿದೆ,
ಫೈಲ್ ಇನ್ನೂ ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.
ಮತ್ತು ನಾವು ಅದನ್ನು ನೋಡಿದರೆ ಮತ್ತು ಪರೀಕ್ಷಿಸುತ್ತಾರೆ.
ಆದ್ದರಿಂದ ಕಾರ್ಯಕ್ರಮದ ಸೆಟ್ ಎಂದು ಕೆಲವು ನಿರಂತರ ಡೇಟಾ ರಚಿಸಿದ,
ಡೇಟಾ ಪ್ರೋಗ್ರಾಂ ನಂತರ ಅಸ್ತಿತ್ವ ಚಾಲನೆಯಲ್ಲಿರುವ ಮುಗಿದಿದೆ.
>> ಈಗ ಕೆಲಸ ಈ ಎಲ್ಲಾ ಚಟುವಟಿಕೆಗಳಿಗೆ ಕಡತಗಳ ಮತ್ತು ಕುಶಲಬಳಕೆಯ ಜೊತೆ
ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಅವುಗಳ ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h ವಾಸಿಸುತ್ತಿದ್ದಾರೆ,
ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಎಂದು ನೀವು ಸಾಧ್ಯತೆ ಪೌಂಡ್ ಇಲ್ಲಿಗೆ
ಸಾಕಷ್ಟು ಮೇಲಿರುವ ಸೇರಿದಂತೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಹೆಚ್ಚು ಎಲ್ಲಾ
ಇದು ಒಂದು ಹೊಂದಿದೆ ಏಕೆಂದರೆ ನಮಗೆ ಅತ್ಯಂತ ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು
ಸಹ ಅನುಮತಿಸುತ್ತದೆ, printf ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h. ವಾಸಿಸುವ
ಆದ್ದರಿಂದ ನೀವು ಸೇರಿವೆ ಪೌಂಡ್ ಅಗತ್ಯವಿಲ್ಲ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕಡತಗಳನ್ನು ಬಹುಶಃ
ಸಲುವಾಗಿ ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ.
>> ಈಗ ಪ್ರತಿಯೊಂದು ಕಡತ ಪಾಯಿಂಟರ್ ಕಾರ್ಯ, ಅಥವಾ ಪ್ರತಿಯೊಂದು ಕಡತ ನಾನು / ಒ, ಇನ್ಪುಟ್ ಔಟ್ಪುಟ್
ಕಾರ್ಯ, ಒಂದು ಸ್ವೀಕರಿಸುತ್ತದೆ ಅದರ ನಿಯತಾಂಕಗಳನ್ನು ಅಥವಾ ಒಳಹರಿವಿನ
ಹೊರತುಪಡಿಸಿ ಫೈಲ್ ಪಾಯಿಂಟರ್ ಒಂದು, fopen ಇದು
ನೀವು ಕಡತ ಪಡೆಯಲು ಬಳಸಲು ಏನು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಪಾಯಿಂಟರ್.
ಆದರೆ ನೀವು ತೆರೆದಿರುವ ನಂತರ ಫೈಲ್ ಮತ್ತು ನೀವು ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಪಡೆಯಲು,
ನೀವು ನಂತರ ಅವುಗಳನ್ನು ರವಾನಿಸಬಹುದು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ವಾದಗಳು
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ನೀನು ಇಂದು, ಹಾಗೂ ಅನೇಕರು
ಆದ್ದರಿಂದ ನೀವು ಕಡತಗಳನ್ನು ಕೆಲಸ ಮಾಡಬಹುದು.
>> ಆದ್ದರಿಂದ ಆರು ಸಾಕಷ್ಟು ಇವೆ ಸಾಮಾನ್ಯ ಮೂಲ ಪದಗಳಿಗಿಂತ
ನಾವು ಇಂದು ಬಗ್ಗೆ ಮಾತನಾಡಲು ನೀನು.
fopen ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ fclose, fgetc
ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ fputc, ಮತ್ತು fread ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ,
ರಚಿಸುವಲ್ಲಿ.
ಆದ್ದರಿಂದ ಬಲ ಪಡೆಯಲು ಅವಕಾಶ.
>> fopen-- ಇದು ಏನು ಮಾಡುತ್ತದೆ?
ಸರಿ, ಇದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಇದು ಇದು ಒಂದು ಕಡತವನ್ನು ನೀವು ಪಾಯಿಂಟರ್ ನೀಡುತ್ತದೆ,
ಆದ್ದರಿಂದ ನೀವು ಆ ಬಳಸಬಹುದಾದ ಒಂದು ಚರ್ಚೆಯಂತೆ ಪಾಯಿಂಟರ್ ಫೈಲ್
ಇತರ ಕಡತ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ಯಾವುದೇ.
ಪ್ರಮುಖ ವಿಷಯ fopen ಜೊತೆ ನೆನಪಿಡುವ
ನೀವು ತೆರೆದಿದ್ದೀರಿ ಎಂದು ನಂತರ ಫೈಲ್ ಅಥವಾ ಇಲ್ಲಿ ಒಂದು ರೀತಿಯ ಕರೆ ಮಾಡಿದ,
ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ ನೀವು ಮತ್ತೆ ಕೊಂಡಿರುವ ಪಾಯಿಂಟರ್
ಶೂನ್ಯ ಸಮನಾಗಿರುತ್ತದೆ ಅಲ್ಲ.
ನೀವು ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ ಇದ್ದರೆ ಪಾಯಿಂಟರ್ಸ್, ಈ ಅರ್ಥ ಇರಬಹುದು.
ಆದರೆ ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ವೇಳೆ ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಮರುಸ್ಥಾಪನೆ,
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಬಹುಶಃ ಹಾನಿಯಾಗುತ್ತದೆ ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ [ಕೇಳಿಸುವುದಿಲ್ಲ].
ನಾವು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ ನಾವು ಕಾನೂನುಬದ್ಧ ಪಾಯಿಂಟರ್ ಹಿಂದಕ್ಕೆ ಪಡೆದರು.
ಸಮಯದ ಬಹುಪಾಲು ನಾವು ತಿನ್ನುವೆ ಮತ್ತೆ ಕಾನೂನುಬದ್ಧ ಪಾಯಿಂಟರ್ ನೆತ್ತಿಗೇರಿದೆ
ಮತ್ತು ಇದು ಒಂದು ಸಮಸ್ಯೆ ಆಗುವುದಿಲ್ಲ.
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಕರೆ fopen ಮಾಡಲು ಹೇಗೆ?
ಈ ರೀತಿಯ ಬಹುಮಟ್ಟಿಗೆ ಕಾಣುತ್ತದೆ.
ಒಂದು ವಿಶಿಷ್ಟ ಎಂಬ ptr ptr-- ಫೈಲ್ ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ fopen ಕಡತ ಹೆಸರು
ಮತ್ತು ನಾವು, ಎರಡು ವಿಷಯಗಳಲ್ಲಿ ಒಂದು ಕಡತದ ಹೆಸರು ಹಾದು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯ ನಾವು ಕೈಗೊಳ್ಳಲು ಬಯಸುವ.
ನಾವು ತೋರುತ್ತಿದೆ ಒಂದು ಕರೆ ಹೊಂದಿರಬಹುದು this-- ಕಡತ ಸ್ಟಾರ್ ptr 1 fopen ಸಮನಾಗಿರುತ್ತದೆ
file1.txt.
ನಾನು ಆಯ್ಕೆ ಮಾಡಿದ ಕಾರ್ಯಾಚರಣೆ ಆರ್ ಆಗಿದೆ.
>> ಈಗ ನೀವೇನು ಆರ್ ಇಲ್ಲಿದೆ ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?
ವಸ್ತುಗಳ ರೀತಿಯ ಯಾವುವು ನಾವು ಕಡತಗಳನ್ನು ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ?
R ಆದ್ದರಿಂದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಾವು ನಾವು ಒಂದು ಕಡತ ಓದಲು ಬಯಸಿದಾಗ ಆಯ್ಕೆ.
ನಾವು ಮೂಲತಃ ಮಾಡಿದಾಗ ಏಕೆ ನಾವು ಈ ರೀತಿಯ ಕರೆ ಮಾಡಿ
ನಾವೇ ಕಡತ ಪಾಯಿಂಟರ್ ಪಡೆಯಲಾಗುತ್ತದೆ ನಾವು ನಂತರ ಮಾಹಿತಿ ಓದಲು ಎಂದು ಇಂತಹ
file1.txt ರಿಂದ.
>> ಹಾಗೆಯೇ, ನಾವು ಫೈಲ್ 2.txt ತೆರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ptr2 ಬರವಣಿಗೆಗೆ ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ
ನಾನು ಇಲ್ಲಿ ರಚಿಸಿದ ಕಡತ ಪಾಯಿಂಟರ್ ಯಾವುದೇ ಕಾರ್ಯಕ್ಕೆ ಒಂದು ಚರ್ಚೆಯಂತೆ
ಫೈಲ್ ಮಾಹಿತಿ ಬರೆಯುತ್ತಾರೆ.
ಆ ಬರಹವು ಹೋಲುವ ಇಲ್ಲ ಆಯ್ಕೆಯನ್ನು ಒಂದು, ಸೇರಿಸಲು.
ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಬರೆಯಲು ಮತ್ತು ಸೇರಿಸುವುದರಿಂದ
ಎಂಬ ಒಂದು ಕಡತವನ್ನು ನೀವು ಬರೆಯುತ್ತೇನೆ ಎಂದು, ನೀವು ಬರವಣಿಗೆಗೆ fopen ಕರೆ ಮಾಡಿದರೆ
ಮತ್ತು ಆ ಕಡತ ಈಗಾಗಲೇ ಅಷ್ಟೇ, ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಇಡೀ ಕಡತ ಬದಲಿಸಿ ಹೋಗುವ.
ಇದು ಆರಂಭಿಸಲು ವಿಶೇಷವೇನು ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ,
ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಅಳಿಸುವುದು ಈಗಾಗಲೇ ಇಲ್ಲ.
>> ನೀವು ಸೇರಿಸುವುದರಿಂದ ಇದು ತೆರೆಯಲು ವೇಳೆ ಆದರೆ, ಇದು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹೋಗುತ್ತದೆ
ಈಗಾಗಲೇ ಪಠ್ಯ ಇಲ್ಲ ವೇಳೆ ಇದು ಅಥವಾ ಮಾಹಿತಿ,
ಮತ್ತು ನಂತರ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಅಲ್ಲಿಂದ ಬರೆಯುವ.
ಆದ್ದರಿಂದ ನೀವು ಯಾವುದೇ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ನೀವು ಮೊದಲು ಮಾಡಿದ ಮಾಹಿತಿ.
ನೀವು ಬರೆಯಲು ಅಥವಾ ಸೇರಿಸಲು ಬಯಸುವ ಎಂದು ರೀತಿಯ ಪರಿಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ಆದರೆ ನೀವು ಬಹುಶಃ ನಮಗೆ ಮಾಡುತ್ತೇವೆ ಸಮಯ ಬಂದಾಗ ಸರಿಯಾದ ಕಾರ್ಯಾಚರಣೆ.
ಆದ್ದರಿಂದ fopen ಇಲ್ಲಿದೆ.
>> ಏನು fclose ಬಗ್ಗೆ?
ಸರಿ, ಸಾಕಷ್ಟು ಸರಳವಾಗಿ, fclose ಕೇವಲ ಕಡತ ಪಾಯಿಂಟರ್ ಸ್ವೀಕರಿಸುತ್ತದೆ.
ಮತ್ತು ನೀವು ನಿರೀಕ್ಷಿಸಿದ, ಆ ಕಡತ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ.
ನಾವು ಒಂದು ಕಡತ ಮುಚ್ಚಿದರೂ ಒಮ್ಮೆ, ನಾವು ಇನ್ನು ಕಡತ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು
ಓದಲು ಅಥವಾ ಫೈಲ್ನಲ್ಲಿ, ಬರೆಯಲು.
ನಾವು ಪುನಃ ತೆರೆಯಲು ಹೊಂದಿರುತ್ತವೆ ಸಲುವಾಗಿ ಇನ್ನೊಂದು ಬಾರಿ ಫೈಲ್
ಕೆಲಸ ಮುಂದುವರಿಸಲು ಇದು ನಾನು / O ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು.
ನಾವು ಮುಗಿಸಿದ್ದೀರಿ ಆದ್ದರಿಂದ fclose ಸಾಧನವಾಗಿ ಈ ಕಡತ ಕೆಲಸ.
ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ ಎಲ್ಲಾ ಹೊಂದಿದೆ ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರು.
ಒಂದೆರಡು ಹಿಂದೆ ಸ್ಲೈಡ್ಗಳು ಮೇಲೆ ಆದ್ದರಿಂದ, ನಾವು ಓದುವ fopened ಕಡತ 1 ಡಾಟ್ ಪಠ್ಯ
ಮತ್ತು ನಾವು ಅದಕ್ಕೆ ptr1 ಸೂಚಕವನ್ನು ಫೈಲ್.
ಈಗ ನಾವು ನೀವು ನಿರ್ಧರಿಸಿದ್ದಾರೆ ಬಂದಿದೆ ಕಡತದಿಂದ ಓದುವ ಮಾಡಲಾಗುತ್ತದೆ.
ನಾವು ಯಾವುದೇ ಹೆಚ್ಚು ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲ.
ನಾವು ಕೇವಲ fclose ptr1 ಮಾಡಬಹುದು.
ಮತ್ತು ಹಾಗೆಯೇ, ನಾವು ಎಂದು ಇತರೆ ಆಟಗಳಾಗಿದ್ದವು fclose.
ಆಯ್ತು.
ಆದ್ದರಿಂದ ಮುಚ್ಚುವ ವಿಶೇಷವೇನು.
ಆ ಎರಡು ಮೂಲ ಕಾರ್ಯಾಚರಣೆ ಆರಂಭಿಸಿದ.
>> ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಬಯಸುವ ಕೆಲವು ಕುತೂಹಲಕಾರಿ ವಿಷಯವನ್ನು,
ಮತ್ತು ಮೊದಲ ಕಾರ್ಯ ಎಂದು ನಾವು ಮಾಡುತ್ತೇವೆ ಎಂದು fgetc-- ಎಂದು ಮಾಡುತ್ತಾರೆ ನೋಡಿ
ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು ಸಲ್ಲಿಸುವಂತೆ.
ಸಾಮಾನ್ಯವಾಗಿ fgetc ಇಲ್ಲಿದೆ ಭಾಷಾಂತರಿಸಲು ಎಂದು.
ಜೀವನದಲ್ಲಿ ತನ್ನ ಗೋಲು ಆಗಿದೆ ಮುಂದಿನ ಅಕ್ಷರವನ್ನೂ ಓದಲು,
ಅಥವಾ ಈ ನಿಮ್ಮ ಬಹಳ ವೇಳೆ fgetc ಮೊದಲ ಕರೆ
ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಡತ, ಮೊದಲ ಅಕ್ಷರ.
ಆದರೆ ಆ ನಂತರ, ನೀವು, ಮುಂದಿನ ಒಂದು ಪಡೆಯಲು
ಫೈಲ್ ಮಾರನೇ ಪಾತ್ರ ಒಂದು ಪಾತ್ರ ವೇರಿಯಬಲ್ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ನಾವು ಇಲ್ಲಿ ಮಾಡಿದ ಎಂದು, ಚಾರ್ ಚ, fgetc ಸಮನಾಗಿರುತ್ತದೆ
ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರಿನಲ್ಲಿ ಪಾಸ್.
ಮತ್ತೆ, ಇದು ಬಹಳ ಇಲ್ಲಿದೆ ನೆನಪಿಡುವ ಇಲ್ಲಿ ಮುಖ್ಯ
ಸಲುವಾಗಿ ಹೊಂದಲು ಎಂದು ಈ ಕಾರ್ಯನಿರ್ವಹಿಸಲು,
ಕಡತ ಪಾಯಿಂಟರ್ ಸ್ವತಃ must've ಓದುವ ಆರಂಭಿಸಲಾಗಿದೆ.
ನಾವು ಒಂದು ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರ ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ ನಾವು ಬರೆಯುವ ಆರಂಭಿಸಲಾಗಿದೆ ಪಾಯಿಂಟರ್.
ಆದ್ದರಿಂದ ಒಂದಾಗಿದೆ fopen ಮಿತಿಗಳನ್ನು, ಬಲ?
ನಾವು ನಿರ್ಬಂಧಿಸಲು ಹೊಂದಿವೆ ನಮ್ಮಲ್ಲಿ ಮಾತ್ರ ಪ್ರದರ್ಶನ
ಒಂದು ಕಡತವನ್ನು ಪಾಯಿಂಟರ್ ಒಂದು ಕಾರ್ಯಾಚರಣೆ.
ನಾವು ಓದಲು ಬಯಸಿದರೆ ಅದೇ ಕಡತದಿಂದ ಬರೆಯಲು,
ನಾವು ಮುಕ್ತ ಎರಡು ಪ್ರತ್ಯೇಕ ಎಂದು ಅದೇ ಕಡತವನ್ನು ಕಡತ ಪಾಯಿಂಟರ್ಸ್
ಓದುವ ಒಂದು, ಬರವಣಿಗೆಗೆ ಒಂದು.
>> ಆದ್ದರಿಂದ ಮತ್ತೆ, ಮಾತ್ರ ಕಾರಣ ನಾನು ಈಗ ಆ ತರಲು
ನಾವು ಕರೆ ಮಾಡಲು ನೀನು ಏಕೆಂದರೆ fgetc, ಆ ಕಡತ ಪಾಯಿಂಟರ್ must've
ಓದುವ ಆರಂಭಿಸಲಾಗಿದೆ.
ತದನಂತರ ಸಾಕಷ್ಟು ಸರಳವಾಗಿ, ಎಲ್ಲಾ ನಾವು ಮಾಡಬೇಕಾದ್ದು
ಕಡತ ಪಾಯಿಂಟರ್ ಹೆಸರಿನಲ್ಲಿ ಪಾಸ್ ಆಗಿದೆ.
ಆದ್ದರಿಂದ ಚಾರ್ ಚ fgetc ptr1 ಸಮನಾಗಿರುತ್ತದೆ.
>> ಅದು ನಮಗೆ ಪಡೆಯಲು ವಿಶೇಷವೇನು ಮುಂದಿನ character--
ಅಥವಾ ಮತ್ತೆ ಈ ಮೊದಲು ವೇಳೆ ಈ ಕರೆ ಮಾಡಿದ ಸಮಯ,
ಮೊದಲ character-- ಯಾವುದೇ ಕಡತ ptr1 ತೋರಿಸಿದರು.
ಫೈಲ್ 1 ಡಾಟ್ ಪಠ್ಯ ಸ್ಮರಿಸುತ್ತಾರೆ.
ಇದು ಮೊದಲ ಅಕ್ಷರವನ್ನು ಪಡೆಯಲು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಾವು ವೇರಿಯಬಲ್ ಚ ಶೇಖರಿಸಿಡಬೇಕು ಮಾಡುತ್ತೇವೆ.
ಬಹಳ ಸರಳ.
ನಾವು ಕೇವಲ ಮೂರು ನೋಡಿದ್ದಾರೆ ಬಂದಿದೆ ಕಾರ್ಯಗಳನ್ನು ಮತ್ತು ನಾವು ಈಗಾಗಲೇ
ಬಹಳ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಏನಾದರೂ ಮಾಡಬಹುದು.
>> ನಾವು ಈ ಸಾಮರ್ಥ್ಯವನ್ನು ಪಡೆಯಲು ಆದ್ದರಿಂದ ಒಂದು ಪಾತ್ರ ಮಾಡುವ
ಮತ್ತು ನಾವು ಲೂಪ್ ಆದ್ದರಿಂದ ಅದನ್ನು ನಾವು ಪಾತ್ರಗಳು ಪಡೆಯಲು ಮುಂದುವರೆಯಲು
ಒಂದು ಕಡತದಿಂದ ಮೇಲೆ ಮತ್ತು ಮೇಲೆ ಮತ್ತು over-- ಈಗ ನಾವು
ಪ್ರತಿಯೊಂದು ಓದಬಹುದು ಒಂದು ಕಡತದ ಪಾತ್ರ.
ಮತ್ತು ನಾವು ಪ್ರತಿ ಪಾತ್ರ ಮುದ್ರಿಸಲು ವೇಳೆ ನಾವು ಅದನ್ನು ಓದಲು ತಕ್ಷಣ,
ನಾವು ಈಗ ಒಂದು ಕಡತದಿಂದ ಓದಲು ಮತ್ತು ತೆರೆಗೆ ಅದರ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿತ.
ನಾವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪೋಣಿಸಿದ ಬಂದಿದೆ ತೆರೆಯಲ್ಲಿ ಆ ಕಡತ.
ಮತ್ತು ಏನು ಲಿನಕ್ಸ್ ಆಜ್ಞಾ ಬೆಕ್ಕು ಮಾಡುತ್ತದೆ.
>> ನೀವು ಫೈಲ್ ಹೆಸರು ಬೆಕ್ಕು ಟೈಪ್ ವೇಳೆ, ಇದು ಸಂಪೂರ್ಣ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ
ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಫೈಲ್.
ಮತ್ತು ಇಲ್ಲಿ ಈ ಸ್ವಲ್ಪ ಲೂಪ್, ಕೋಡ್ ಕೇವಲ ಮೂರು ಸಾಲುಗಳು,
ಆದರೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಕಲುಗಳನ್ನು ಲಿನಕ್ಸ್ ಆಜ್ಞಾ ಬೆಕ್ಕು.
ಆದ್ದರಿಂದ ಈ ವಾಕ್ಯ ಮಾಡಬಹುದು , ಸ್ವಲ್ಪ ವಿಯರ್ಡ್ ನೋಡಲು
ಆದರೆ ಇಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ.
ಚ fgetc ಸಮನಾಗಿರುತ್ತದೆ ಆದರೆ, ptr ಅಲ್ಲ ಇದು ಒಂದು ಇಡೀ mouthful ಇಲ್ಲಿದೆ EOF-- ಸಮಾನವಾಗಿತ್ತು
ಆದರೆ ಇದು ಕೇವಲ ಮುರಿಯಲು ಅವಕಾಶ ಆದ್ದರಿಂದ ವಾಕ್ಯ ಸ್ಪಷ್ಟ ಇಲ್ಲಿದೆ.
ನಾನು ಇದನ್ನು ಕ್ರೋಡೀಕರಿಸಿದರು ಬಂದಿದೆ ಜಾಗವನ್ನು ಸಲುವಾಗಿ,
ಇದು ಸ್ವಲ್ಪ ಆದರೂ syntactically ಟ್ರಿಕಿ.
>> ಆದ್ದರಿಂದ ಹಸಿರು ಹಕ್ಕಿನಿಂದ ಈ ಭಾಗದ ಈಗ, ಅದು ಏನು?
ಸರಿ, ಆ ನಮ್ಮ fgetc ಕರೆ ಬಲ?
ನಾವು ಮೊದಲು ನೋಡಿದ.
ಇದು ಒಂದು ಪಡೆಯಲು ವಿಶೇಷವೇನು ಕಡತದಿಂದ ಪಾತ್ರ.
ನಂತರ ನಾವು ಹೋಲಿಸಿ EOF ವಿರುದ್ಧ ಪಾತ್ರ.
EOF ಎಂದು ವಿಶೇಷ ಕೆಳಗಿನ ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h, ರಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಿ
ಕಡತ ರ ಅಂತ್ಯ.
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಸಂಭವಿಸಿ ಹೋಗಿ ಏನನ್ನು ಈ ಲೂಪ್ ಒಂದು ಅಕ್ಷರವನ್ನೂ ಓದಲು ಕಾಣಿಸುತ್ತದೆ ಇದೆ,
, EOF ಹೋಲಿಸಿ ಫೈಲ್ ಪಾತ್ರದ ಕೊನೆಯ.
ಅವರು ಹೊಂದುತ್ತಿಲ್ಲ ವೇಳೆ, ನಾವು ಹೊಂದಿರದಿದ್ದಲ್ಲಿ , ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು
ನಾವು ಪಾತ್ರದ ಮುದ್ರಿಸುತ್ತದೆ ವಿಲ್.
ನಂತರ ನಾವು ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ ಮತ್ತೆ ಲೂಪ್ ಆರಂಭ.
ನಾವು ಒಂದು ಪಾತ್ರ ಪಡೆಯುತ್ತೀರಿ, ಪರಿಶೀಲಿಸಿ EOF ವಿರುದ್ಧ, ಹೀಗೆ ಮುದ್ರಿಸುತ್ತದೆ, ಮತ್ತು
ಹೀಗೆ ಹೀಗೆ, ಆ ರೀತಿಯಲ್ಲಿ ಮೂಲಕ ಲೂಪಿಂಗ್
ನಾವು ಫೈಲ್ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ ರವರೆಗೆ.
ತದನಂತರ ಆ ಮೂಲಕ ನಾವು ಮುದ್ರಿತ ಕಾಣಿಸುತ್ತದೆ
ಕಡತದ ಸಂಪೂರ್ಣ ವಿಷಯಗಳನ್ನು ಔಟ್.
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾವು ಮಾತ್ರ ನೋಡಿದ fopen, fclose, ಮತ್ತು fgetc
ಮತ್ತು ಈಗಾಗಲೇ ನಾವು ನಕಲು ಮಾಡಬಹುದು ಒಂದು ಲೈನಕ್ಸ್ ಟರ್ಮಿನಲ್ ಆಜ್ಞೆಯನ್ನು.
>> ನಾನು ಆರಂಭದಲ್ಲಿ ಹೇಳಿದಂತೆ, ನಾವು fgetc ಮತ್ತು fputc ಹೊಂದಿತ್ತು,
ಮತ್ತು fputc ಒಡನಾಡಿಯಾಗಿದ್ದ fgetc ಕಾರ್ಯ.
ಆದ್ದರಿಂದ, ನೀವು, ಕಲ್ಪಿಸಬಹುದಾದ ಇರಬಹುದು ಬರವಣಿಗೆಯು ಸಮನಾಗಿರುತ್ತದೆ.
ಇದು ನಮಗೆ ಒಂದು ಬರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ ಫೈಲ್ ಏಕ ಪಾತ್ರ.
>> ಮತ್ತೆ, ಸರಿಯಾಗಿ ಎಂದು, ಕೇವಲ ಇದು fgetc ಜೊತೆ ಹಾಗೆ, ಫೈಲ್
ನಾವು must've ಗೆ ಬರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು ಮಾಡಲಾಗಿದೆ ಬರವಣಿಗೆಗೆ ಅಥವಾ ಸೇರಿಸುವುದರಿಂದ ಆರಂಭಿಸಲಾಗಿದೆ.
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಕಡತದ ಮೇಲೆ fputc ಬಳಸಿದರೆ ನಾವು ಓದುವ ತೆರೆದಿರುವ,
ನಾವು ಬಳಲುತ್ತಿದ್ದಾರೆ ನೀನು ತಪ್ಪು ಒಂದು ಬಿಟ್.
ಆದರೆ ಕರೆ ಬಹಳ ಸರಳವಾಗಿದೆ.
fputc ಬಂಡವಾಳ ptr2, ಎಲ್ಲಾ ಹಾಗೆ ವಿಶೇಷವೇನು ಅದು ಆಗಿದೆ
ಪತ್ರ ಬರೆಯಲು ಹೋಗಿ ಒಂದು ಫೈಲ್ ಆಗಿ 2 ಡಾಟ್ ಒಳಗೆ
ಹೆಸರು ಪಠ್ಯ, ನಾವು ತೆರೆದು ಅದಕ್ಕೆ ಆ ಫೈಲ್
ಪಾಯಿಂಟರ್ ptr2 ಗೆ.
ನಾವು ಒಂದು ಬರೆಯಲು ನೀನು ಬಂಡವಾಳ 2 ಡಾಟ್ ಪಠ್ಯ ಸಲ್ಲಿಸುವಂತೆ.
ಮತ್ತು ನಾವು ಒಂದು ಆಶ್ಚರ್ಯಸೂಚಕವಾಗಿ ಬರೆಯಲು ಮಾಡುತ್ತೇವೆ 3 ಡಾಟ್ ಸಲ್ಲಿಸುವಂತೆ ಬೆಟ್ಟು
ptr3 ಮೂಲಕ ತೋರಿಸಿದರು ಇದು ಪಠ್ಯ,.
ಆದ್ದರಿಂದ ಮತ್ತೆ, ಇಲ್ಲಿ ಬಹಳ ಸರಳ.
>> ಆದರೆ ಈಗ ನಾವು ಮತ್ತೊಂದು ವಿಷಯ ಮಾಡಬಹುದು.
ಈ ಉದಾಹರಣೆ ನಾವು ಹೋಗುವಾಗ ಮಾಡಲಾಯಿತು
ಬೆಕ್ಕು ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಬಗ್ಗೆ ಲಿನಕ್ಸ್ ಆಜ್ಞಾ, ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ ಒಂದು
ತೆರೆಗೆ.
ಸರಿ, ಈಗ ನಾವು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ ಕಡತಗಳನ್ನು ಪಾತ್ರಗಳು ಓದಲು
ಮತ್ತು, ಕಡತಗಳನ್ನು ಅಕ್ಷರಗಳನ್ನು ಬರೆಯಲು ಏಕೆ ನಾವು ಕೇವಲ ಬದಲಿಗೆ ಇಲ್ಲ
fputc ಕರೆ printf ಕರೆ.
>> ಮತ್ತು ಈಗ ನಾವು CP ನಕಲು ಮಾಡಿದ, ಒಂದು ಮೂಲಭೂತ ಲಿನಕ್ಸ್ ಆಜ್ಞಾ
ನಾವು ರೀತಿಯಲ್ಲಿ ದೀರ್ಘ ಕುರಿತು ಹಿಂದೆ ಲಿನಕ್ಸ್ ವೀಡಿಯೊ ಆದೇಶಿಸುತ್ತದೆ.
ನಾವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಂದಿದೆ ಇಲ್ಲಿಯೇ ಎಂದು ನಕಲು.
ನಾವು ಒಂದು ಪಾತ್ರ ಓದುವ ನಂತರ ನಾವು ಆರ್ ಇನ್ನೊಂದು ಫೈಲ್ ಪಾತ್ರದ ಬರೆಯಲು.
ಒಂದು ಕಡತದಿಂದ ಓದಲು, ಬರೆಯಲು ಮೇಲೆ ಮತ್ತು ಮೇಲೆ ಮತ್ತೊಂದು, ಗೆ
ಮತ್ತು ಮತ್ತೆ ನಾವು EOF ಹಿಟ್ ರವರೆಗೆ.
ನಾವು ಕೊನೆಯಲ್ಲಿ ಮಾಡಲೇಬೇಕು ಫೈಲ್ ನಾವು ನಕಲಿಸಿ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ.
ಆ ಮೂಲಕ ನಾವು ಎಲ್ಲಾ ಬರೆದಿದ್ದಾರೆ ಮಾಡುತ್ತೇವೆ ಪಾತ್ರಗಳ ನಾವು ಫೈಲ್ ಅಗತ್ಯವಿದೆ
ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು.
ಆದ್ದರಿಂದ ಈ CP, ಲಿನಕ್ಸ್ ಪ್ರತಿಯನ್ನು ಆದೇಶ.
>> ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ ಈ ವೀಡಿಯೊ, ನಾನು ಸರಿಯಾಗಿ ಹೊಂದಿತ್ತು
ನಾವು ಮಾತನಾಡಲು ಎಂದು ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.
ನಾವು ನೀವು ಅಲ್ಲಿ ಇಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಹೋಗಿ
ಜೊತೆಗೆ ಪಾಯಿಂಟರ್ಸ್ ಸಲ್ಲಿಸುವಂತೆ.
ಈ ಕ್ರಿಯೆ ರೀತಿಯ ಭಯಾನಕ ಕಾಣುತ್ತದೆ.
ಇದು ಹಲವಾರು ನಿಯತಾಂಕಗಳನ್ನು ಅವರಲ್ಲಿದೆ.
ಇಲ್ಲಿ ನಡೆಯುತ್ತಿರುವ ಸಾಕಷ್ಟು.
ವಿವಿಧ ಬಹಳಷ್ಟು ಇಲ್ಲ ಬಣ್ಣಗಳು ಮತ್ತು ಗ್ರಂಥಗಳು.
ಆದರೆ ನಿಜವಾಗಿಯೂ, ಇದು ಕೇವಲ ಇಲ್ಲಿದೆ fgetc ಜೆನೆರಿಕ್ ಆವೃತ್ತಿ
ನಮಗೆ ಯಾವುದೇ ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ ಮಾಹಿತಿ ಪ್ರಮಾಣವನ್ನು.
ನಾವು ಇಂತಹ ಸ್ವಲ್ಪ ಅಸಮರ್ಥವೆನಿಸಿದ ಒಂದು ಸಮಯದಲ್ಲಿ ಪಾತ್ರಗಳು ಒಂದು ಪಡೆಯುವಲ್ಲಿ,
ಕಡತ ಮೂಲಕ iterating ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ.
ಅದನ್ನು ಪಡೆಯಲು ಒಳ್ಳೆಯದೆಂದು ಎಂದು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಬಾರಿ ಅಥವಾ 500 100?
>> ಸರಿ, fread ಮತ್ತು ಅದರ ಜೊತೆಗಾರ ಕಾರ್ಯ ರಚಿಸುವಲ್ಲಿ, ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ವಿಲ್
ಎರಡನೇ, ನಮಗೆ ಹಾಗೆ ಅವಕಾಶ.
ನಾವು ಒಂದು ಕ್ರಮವಿಲ್ಲದ ಪ್ರಮಾಣದ ಓದಬಹುದು ಫೈಲ್ ಮಾಹಿತಿ
ಮತ್ತು ನಾವು ಎಲ್ಲೋ ತಾತ್ಕಾಲಿಕವಾಗಿ ಶೇಖರಿಸಿಡಬೇಕು.
ಬದಲಿಗೆ ಕೇವಲ ಸಮರ್ಥವಾಗಿ ಒಂದು ವೇರಿಯಬಲ್ ಅದು ಸೈನ್,
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇದು ಸಂಗ್ರಹಿಸಲು ಬೇಕು.
ಆದ್ದರಿಂದ, ನಾವು ನಾಲ್ಕು ಹಾದು ವಾದಗಳು ಒಂದು ಪಾಯಿಂಟರ್ fread-- ಗೆ
ನಾವು ಆರ್ ಅಲ್ಲಿ ಸ್ಥಳ ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವೇನು,
ಹೇಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರತಿ ಘಟಕ ದೊಡ್ಡ ಎಂದು, ಮಾಹಿತಿ ಎಷ್ಟು ಘಟಕಗಳು
ನಾವು ಪಡೆಯಲು ಬಯಸುವ, ಮತ್ತು ಕಡತ ನಾವು ಪಡೆಯಲು ಬಯಸುವ.
ಬಹುಶಃ ಅತ್ಯುತ್ತಮ ಸಚಿತ್ರ ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಗೆ ಜೊತೆ.
ಆದ್ದರಿಂದ ನಾವು ಘೋಷಿಸಲು ಎಂದು ತಿಳಿಸಿ 10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು.
ನಾವು ಮೇಲೆ ಡಿಕ್ಲೇರ್ಡ್ ನಿರಂಕುಶವಾಗಿ ಬಣವೆ ಆಗ 10 ಇಂಟ್.
ಆದ್ದರಿಂದ ಬಹಳ ಸರಳ.
ಈಗ ನಾವು ಆದರೂ ಮಾಡುತ್ತಿರುವುದು frecall ನಾವು ಇಂಟ್ ಗಾತ್ರವನ್ನು ಓದುವ ನೀವು ಇದೆ
ಬಾರಿ ಮಾಹಿತಿಯನ್ನು 10 ಬೈಟ್ಗಳು.
ಇಂಟ್ ಎಂಬ ಗಾತ್ರ ಇಲ್ಲಿದೆ four-- ಸಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು.
>> ಹಾಗಾಗಿ ನಾವು ಮಾಡುತ್ತಿರುವುದು ನಾವು ಓದುವ ನೀವು ಆಗಿದೆ ಮಾಹಿತಿ ಮೌಲ್ಯದ 40 ಬೈಟ್ಗಳು
ಕಡತದಿಂದ ptr ಮೂಲಕ ತೋರಿಸಿದರು.
ಮತ್ತು ನಾವು ಆ ಸಂಗ್ರಹಿಸಲು ನೀವು 40 ಬೈಟ್ಗಳು ಎಲ್ಲೋ
ನಾವು ಬದಿಗಿಟ್ಟು ಅಲ್ಲಿ ಮೆಮೊರಿ ಮೌಲ್ಯದ 40 ಬೈಟ್ಗಳು.
ಅದೃಷ್ಟವಶಾತ್, ನಾವು ಈಗಾಗಲೇ ಮೂಲಕ ಮಾಡಿದ ವ್ಯೂಹ ಅಲ್ಲಿಯೇ ಆಗ ಘೋಷಿಸುವ.
ಆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು 10 ನಾಲ್ಕು ಬೈಟ್ ಘಟಕಗಳು.
ಒಟ್ಟು ಆದ್ದರಿಂದ, ಇದು 40 ಹಿಡಿಸುವ ಬೈಟ್ಗಳು ಮಾಹಿತಿಯನ್ನು ಮೌಲ್ಯದ.
ನಾವು ಈಗ 40 ಬೈಟ್ಗಳು ಓದುತ್ತಿದ್ದಲ್ಲಿ ಫೈಲ್ ಮಾಹಿತಿ,
ಮತ್ತು ನಾವು ಆಗ ಇದನ್ನು ಸಂಗ್ರಹಿಸಲು ನೀವು.
>> ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ ಕರೆಸಿಕೊಳ್ಳುವುದು ಎಂದು ಇಂತಹ ಆಗ ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಹೆಸರು,
ನಿಜವಾಗಿಯೂ ಒಂದು ಪಾಯಿಂಟರ್ ಅದರ ಮೊದಲ ಅಂಶ.
ಆದ್ದರಿಂದ ನಾವು ಆಗ ಹಾದುಹೋದಾಗ, ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಹಾದುಹೋಗುವ, ವಾಸ್ತವವಾಗಿ, ಅವು.
>> ಅದೇ ರೀತಿ ನಾವು ಈ ಮಾಡಬಹುದು ನಾವು ಎಂದೇನೂ ಇಲ್ಲ
ಸ್ಟಾಕ್ ನಮ್ಮ ಬಫರ್ ಉಳಿಸಲು ಅಗತ್ಯ.
ನಾವು ಸಕ್ರಿಯವಾಗಿ ನಿಯೋಜಿಸಿ ಎಂದು ಒಂದು malloc ಬಳಸಿಕೊಂಡು, ಈ ರೀತಿಯ ಬಫರ್.
ನಾವು ನೆನಪಿಡಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ,
ನಾವು ಅದನ್ನು ಉಳಿಸುವ ರಾಶಿ, ಸ್ಟಾಕ್.
ಆದರೆ ಇದು ಇನ್ನೂ ಒಂದು ಬಫರ್ ಇಲ್ಲಿದೆ.
>> ಇದು ಇನ್ನೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಆಗಿದೆ ಮಾಹಿತಿಯನ್ನು 640 ಬೈಟ್ಗಳು ಹಿಡುವಳಿ
ಎರಡು ಎಂಟು ಬೈಟ್ಗಳು ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ.
ಮತ್ತು ನಾವು ಅವರನ್ನು 80 ಕೇಳುತ್ತಿದ್ದೇವೆ.
ನಾವು ಜಾಗವನ್ನು ಬೇಕು 80 ಡಬಲ್ಸ್ ಹಿಡಿದಿಡಲು.
ಆದ್ದರಿಂದ 80 ಬಾರಿ 8 640 ಬೈಟ್ಗಳು ಮಾಹಿತಿಯಾಗಿದೆ.
ಮತ್ತು fread ಎಂದು ಕರೆಯಾಗಿದೆ ಮಾಹಿತಿಯನ್ನು 640 ಬೈಟ್ಗಳು ಸಂಗ್ರಹಿಸುವ
ಕಡತ ಮೂಲಕ ತೋರಿಸಿದರು ರಿಂದ ptr ಮತ್ತು arr2 ಈಗ ಸಂಗ್ರಹಿಸುವ.
>> ಈಗ ನಾವು fread ಚಿಕಿತ್ಸೆ ಕೇವಲ fgetc ಕರೆ ನಂತಹ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಕಡತದಿಂದ ಒಂದು ಅಕ್ಷರವನ್ನಾದರೂ ಪಡೆಯಿರಿ.
ಮತ್ತು ನಾವು ಒಂದು ಅಗತ್ಯವಿಲ್ಲ ಶ್ರೇಣಿಯನ್ನು ಒಂದು ಪಾತ್ರದ ಹಿಡಿದಿಡಲು.
ನಾವು ಅದನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಒಂದು ಪಾತ್ರ ವೇರಿಯಬಲ್.
>> ಕ್ಯಾಚ್, ಆದರೂ, ಎಂದು ನಾವು ಕೇವಲ ಒಂದು ವೇರಿಯೇಬಲ್ ಹೊಂದಿರುವಾಗ,
ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ ಎಂದು ವೇರಿಯಬಲ್ ವಿಳಾಸ
ಮರುಸ್ಥಾಪನೆ ಏಕೆಂದರೆ fread ಮೊದಲ ವಾದವನ್ನು
ಸ್ಥಳ ಮತ್ತು ಮೆಮೊರಿ ಒಂದು ಪಾಯಿಂಟರ್ ನಾವು ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಎಲ್ಲಿ.
ಮತ್ತೆ, ಒಂದು ಹೆಸರು ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಯಾಗಿದೆ.
ನಾವು ವನ್ನಾಗಲಿ ಅರೇ ಅಗತ್ಯವಿಲ್ಲ.
ಆದರೆ ಸಿ, ಪಾತ್ರದ ಸಿ ಇಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಅಲ್ಲ.
ಇದು ಕೇವಲ ಒಂದು ವೇರಿಯೇಬಲ್ ನ.
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಪಾಸ್ ಅಗತ್ಯವಿದೆ ವನ್ನಾಗಲಿ ಸಿ ಸೂಚಿಸಲು
ನಾವು ಎಲ್ಲಿ ವಿಳಾಸ ಎಂದು ಮಾಹಿತಿ ಈ ಒಂದು ಬೈಟ್ ಶೇಖರಿಸಿಡಲು,
ಈ ಒಂದು ಪಾತ್ರ ನಾವು ptr ಸಂಗ್ರಹಿಸುವ ನೀವು.
ನಾನು ಮೂಲಕ ಹೋಗುತ್ತೇನೆ Fwrite-- ಈ ಸ್ವಲ್ಪ ಹೆಚ್ಚು
ವೇಗವಾಗಿ ಅತ್ಯಧಿಕವಾಗಿ fread ನಿಖರವಾದ ಸಮಾನ
ಇದು ಬರವಣಿಗೆಗೆ ಹೊರತುಪಡಿಸಿ ಬದಲಿಗೆ ಓದುವ, ಕೇವಲ
other-- ರೀತಿಯ ನಾವು ಮುಕ್ತ ಹೊಂದಿತ್ತು ಬಂದಿದೆ ಮತ್ತು ನಿಕಟ, ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು,
ಒಂದು ಪಾತ್ರ ಬರೆಯಲು.
ಈಗ ಅನಿಯಂತ್ರಿತ ಪಡೆಯಲು ಇಲ್ಲಿದೆ ಮಾಹಿತಿಯ ಪ್ರಮಾಣ
ಮಾಹಿತಿ ಬಲ ಅನಿಯಂತ್ರಿತ ಪ್ರಮಾಣವನ್ನು.
ಆದ್ದರಿಂದ ಮೊದಲಿನಂತೆ, ನಾವು 10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ
ಅಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ ಮಾಹಿತಿ ಬಹುಶಃ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.
>> ಇದು ಬಹುಶಃ ಕೋಡ್ ಕೆಲವು ಸಾಲುಗಳನ್ನು ಈ ಎರಡು ನಡುವೆ ಹೋಗಬೇಕು
ನಾನು ಆಗ ತುಂಬಲು ಅಲ್ಲಿ ಅರ್ಥಪೂರ್ಣ ಏನೋ.
ನಾನು 10 ವಿವಿಧ ಪೂರ್ಣಾಂಕಗಳ ಅದನ್ನು ತುಂಬಲು.
ಬದಲಾಗಿ, ನಾನು ಬಳಕೆದಾರ ನನಗೆ ಮಾಡುವ ಆಗ ಬರೆಯಲು ಇದೆ
ಮತ್ತು ಆಗ ಮಾಹಿತಿ ಸಂಗ್ರಹಿಸುವ.
ನಾನು ಮಾಹಿತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಬಾಗುತ್ತೇನೆ ಮತ್ತು ಕಡತ ಒಳಗೆ ಹಾಕುವ.
>> ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಅದರಿಂದ ಎಂಬ ಬಫರ್ ಫೈಲ್,
ನಾವು ಈಗ ನೀನು ಫೈಲ್ ಬಫರ್.
ಆದ್ದರಿಂದ ಕೇವಲ ತಿರುಗಿಸೋಣ.
ಮೊದಲಿನಂತೆ ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾವು ಮೆಮೊರಿ ಒಂದು ರಾಶಿ ಪಾಲನ್ನು ಹೊಂದಿವೆ
ನಾವು ಸಕ್ರಿಯವಾಗಿ ಬಂದಿದೆ ಎಂದು ಹಂಚಿಕೆ ಮತ್ತು ಓದುವುದಕ್ಕೆ
ಮತ್ತು ಕಡತ ಎಂದು ಬರೆಯಲು.
>> ಮತ್ತು ನಾವು ಒಂದು ವೇರಿಯಬಲ್ ಹೊಂದಿವೆ ಒಂದು ಬೈಟ್ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು
ಇಂತಹ ಪಾತ್ರವಾಗಿ ಮಾಹಿತಿಯಿಲ್ಲದೆ.
ಆದರೆ ಮತ್ತೆ, ನಾವು ಪಾಸ್ ಅಗತ್ಯವಿದೆ ಎಂದು ವೇರಿಯಬಲ್ ವಿಳಾಸ
ನಾವು ಅದರಿಂದ ಓದಲು ಬಯಸಿದಾಗ.
ನಾವು ಮಾಹಿತಿ ಬರೆಯಬಹುದು ನಾವು ಆ ವಿಳಾಸದಲ್ಲಿ ಕಾಣಬಹುದು
ಕಡತ ಪಾಯಿಂಟರ್, ptr.
>> ಇತರ ಸಾಕಷ್ಟು ಇಲ್ಲ ದೊಡ್ಡ ಫೈಲ್ ನಾನು / O ಕಾರ್ಯಗಳನ್ನು
ಅದಲ್ಲದೆ ವಿವಿಧ ಕೆಲಸಗಳನ್ನು ಇವನ್ನು ನಾವು ಇಂದು ಕುರಿತು ಬಂದಿದೆ.
ಇಚ್ಛೆಗಳ ಒಂದೆರಡು ನಿಮಗೆ ಉಪಯುಕ್ತ ಎಂದು
fgets ಮತ್ತು fputs ಇವೆ, ಇದು ಸಮನಾಗಿದೆ
fgetc ಮತ್ತು fputc ಆದರೆ ಓದಲು ಒಂದು ಕಡತದಿಂದ ಒಂದು ಸ್ಟ್ರಿಂಗ್.
ಬದಲಿಗೆ ಒಂದು ಅಕ್ಷರ, ಇದು ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಓದಲು ಕಾಣಿಸುತ್ತದೆ.
ಮೂಲತಃ ಅನುಮತಿಸುವ fprintf, ನೀವು ಸಲ್ಲಿಸುವಂತೆ ಬರೆಯಲು printf ಬಳಸಲು.
ನೀವು ಮಾಡಬಹುದು ಆದ್ದರಿಂದ ಕೇವಲ, ಬಳಸಿಕೊಂಡು ವೇರಿಯೇಬಲ್ ಪರ್ಯಾಯ
ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ಗಳೊಂದಿಗೆ ಶೇಕಡಾ ನಾನು ಮತ್ತು printf ಶೇಕಡಾ D, ಹೀಗೆ,
ನೀವು ಅದೇ ರೀತಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು printf ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಮುದ್ರಣ ಏನೋ
ಫೈಲ್ ಹಾಗೆ.
>> fseek-- ನೀವು ಡಿವಿಡಿ ಪ್ಲೇಯರ್ ಹೊಂದಿದ್ದರೆ ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲಿ ಬಳಸಲು ಸಾದೃಶ್ಯದ ಆಗಿದೆ
ರೀತಿಯ ಬಳಸಿಕೊಂಡು ಹಾಗೆ ನಿಮ್ಮ ಸುರುಳಿಗಳನ್ನು ಮತ್ತು ವೇಗವಾಗಿ ಮುಂದೆ
ಗುಂಡಿಗಳು ಚಿತ್ರ ಸುತ್ತಲು.
ಹಾಗೆಯೇ, ನೀವು ಫೈಲ್ ಸುಮಾರು ಚಲಿಸಬಹುದು.
ಒಳಗೆ ಕೆಲಸವೆಂದರೆ ಆ ಕಡತ ರಚನೆ
ನೀವು ಸೂಚಕವಾಗಿದೆ ಎಂದು ಸಿ ಅಲ್ಲಿ ನೀವು ಕಡತದಲ್ಲಿ ಇವೆ.
ನೀವು ಬಹಳ ಇರುತ್ತದೆ ಬೈಟ್ ಶೂನ್ಯ, ಆರಂಭದಲ್ಲಿ?
ನೀವು ಬೈಟ್ 100 ಗಳು, ಬೈಟ್ 1,000, ಹೀಗೆ?
ನೀವು ನಿರಂಕುಶವಾಗಿ ಸರಿಸಲು fseek ಬಳಸಬಹುದು ಮುಂದೆ ಹಿಂದುಳಿದ ಸೂಚಕ.
>> ಮತ್ತೆ, ftell ಒಂದು ಡಿವಿಡಿ ಪ್ಲೇಯರ್ ಹೋಲುವ,
ಹೇಳುವ ಸ್ವಲ್ಪ ಗಡಿಯಾರ ಹಾಗೆ ನೀವು ಎಷ್ಟು ನಿಮಿಷಗಳು ಮತ್ತು ಸೆಕೆಂಡುಗಳು ನೀವು
ಒಂದು ನಿರ್ದಿಷ್ಟ ಚಿತ್ರ ಒಳಗೆ ಇವೆ.
ಹಾಗೆಯೇ, ftell ನೀವು ಹೇಗೆ ಹೇಳುತ್ತದೆ ಎಷ್ಟು ಬೈಟ್ಗಳು ನೀವು ಕಡತ ಒಳಗೆ ಇವೆ.
feof ಬೇರೆ ಆವೃತ್ತಿಯಾಗಿದೆ ನೀವು ಬಂದಿದೆ ಎಂದು ಗುರುತಿಸುವುದರ
ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು.
ಮತ್ತು ferror ಕ್ರಿಯೆಯಾಗಿದೆ ನೀವು ಬಳಸಬಹುದಾದ
ಏನೋ ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಪತ್ತೆ ಫೈಲ್ ತಪ್ಪು ಕೆಲಸ ಹೋದರು.
ಮತ್ತೆ ಇದು ಕೇವಲ ಮೇಲ್ಮೈ ಲಾಭ.
ಸಾಕಷ್ಟು ಹೆಚ್ಚು ಕಡತ ನಾನು / ಒ ಇನ್ನೂ ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h. ಕಾರ್ಯಗಳನ್ನು
ಆದರೆ ಬಹುಶಃ ನೀವು ಪಡೆಯುತ್ತಾನೆ ಕಡತ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ಆರಂಭಿಸಿದರು.
ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ.
ಈ CS50 ಹೊಂದಿದೆ.