[Powered by Google Translate] ನ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಒಟ್ಟಿಗೆ ಅಸ್ಥಿರಗಳ ಕನಸುಗಳಿವೆ ಗುಂಪಿಗೆ ಒಂದು ರೀತಿಯಲ್ಲಿ ನಮಗೆ ಒದಗಿಸಿ
ಉತ್ತಮ ಪ್ಯಾಕೇಜ್ ಆಗಿ.
ಇದು ಸರಿಯಾದ ಉದಾಹರಣೆ ನೋಡಿ ಬಹುಶಃ ಸುಲಭವಾದ ಇಲ್ಲಿದೆ
ಆದ್ದರಿಂದ ನಾವು, struct ಹೇಳುತ್ತಾರೆ
ನಂತರ, ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತೆರೆಯುವ
ಮತ್ತು ಈ struct ರಲ್ಲಿ, ನಾವು, ಒಂದು int ವಯಸ್ಸು ನಿಮಗಿದೆ
ಒಂದು ಚಾರ್ * ಹೆಸರು
ಮತ್ತು ಅಷ್ಟೇ.
ಇದು, ಒಂದು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನಂತರ ಒಂದು ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ವಿಲಕ್ಷಣ ಕಾಣಬಹುದು
ಆದರೆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಅಗತ್ಯ ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿದೆ.
ಯಾವುದೇ ಮಾನ್ಯ ರೀತಿಯ struct ವಿವರಣೆಗೆ ಹೋಗಬಹುದು.
ಇಲ್ಲಿ, ನಾವು, ಒಂದು int ಮತ್ತು ಚಾರ್ * ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಿದ
ಆದರೆ ನೀವು, ಅಭಿಪ್ರಾಯಗಳಿಂದಲೇ, 100 ಅಂಶಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಳಸುತ್ತವೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಅಥವಾ ಇನ್ನೊಂದು struct.
ನೀವು ಸಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಿಕೊಂಡು ನೀವು,
ನೀವು ಹೊಸ ರೀತಿಯ ರಚಿಸುತ್ತಿದೆ
ಇತರ ವಿಧಗಳ ಸಂಗ್ರಹಣೆಗೆ ಔಟ್.
ಇಲ್ಲಿ, ನಾವು ಒಂದು ಹೊಸ ರೀತಿಯ ಮಾಡುತ್ತಿದ್ದೀಯ
ಒಂದು ಪೂರ್ಣಾಂಕ ಮತ್ತು ಚಾರ್ * ಹೊರಗೆ.
ನಾವು ನಂತರ ನೋಡುತ್ತಾರೆ ಎಂದು, ಒಂದು struct ಕೌಟುಂಬಿಕತೆ
ನೀವು ಬಳಸುವ ನೀವು ಯಾವುದೇ ರೀತಿಯ ಸಮಾನ ಹಾದಿಗಳಿವೆ ರಲ್ಲಿ ಆಗಿದೆ.
ಸಾಮಾನ್ಯವಾಗಿ, ನಾನು ಹೇಗೆ struct ರೀತಿಯ ಹೋಲಿಸುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ
ಒಂದು ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರವನ್ನು ಹೋಲುತ್ತದೆ.
ನಾವು ಬರೆದ ಕೋಡ್ ಮಾನ್ಯ C ಆಗಿರುತ್ತದೆ, ಆದರೆ
ಇದು ಬಹಳ ಉಪಯುಕ್ತ ಅಲ್ಲ
ಮತ್ತು ಖಣಿಲು ನಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮತ್ತು ಅದರ ರೀತಿಯ ಎಷ್ಟು ನೆನಪಿಡಿ?
ಹಾಗೆಯೇ, ನಾವು ಮೂಲತಃ ಕೇವಲ ಹೇಳಿದರು
ಇಂಟ್,
ಇದು ಬಹಳ ಉಪಯುಕ್ತ ಸಾಲನ್ನು ಅಲ್ಲ.
ಆದ್ದರಿಂದ ಅವರ ವಾಸ್ತವವಾಗಿ ಆ ರೀತಿಯ ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಲು ಅವಕಾಶ
ಇದು ಅಲ್ಪ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು ಮೊದಲು ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಮೂಲಕ.
ನಾವು ವೇರಿಯಬಲ್ ವಿದ್ಯಾರ್ಥಿ ಕರೆ ಮಾಡುತ್ತೇವೆ.
ಈಗ ನಾವು ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂದು ವಿದ್ಯಾರ್ಥಿ ಡಿಕ್ಲೇರ್ಡ್ ಮಾಡಿದ
struct ನೀಡಿದ ರೀತಿಯ.
ಹೇಗೆ ನಾವು struct ಒಳಗೆ ಏರುಪೇರುಗಳಲ್ಲಿ ಸಿಗುತ್ತವೆ?
ಈ ಅಸ್ಥಿರಗಳು ತಾಂತ್ರಿಕವಾಗಿ, ಹೆಸರುಗಳು
ಸದಸ್ಯರು.
ವಿದ್ಯಾರ್ಥಿ struct ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಸದಸ್ಯ ಪ್ರವೇಶಿಸಲು,
ನೀವು, ವೇರಿಯಬಲ್ ಹೆಸರಿನ ಒಂದು ಬಿಂದುವನ್ನು ಸೇರಿಸಲು
ನೀವು ಸದಸ್ಯರ ಹೆಸರಿನ ಮೊದಲು.
ಇಲ್ಲಿ, ಕೇವಲ 2 ಮಾನ್ಯ ಸಾಧ್ಯತೆಗಳನ್ನು
student.age ಗಳು
ಮತ್ತು student.name.
ಮತ್ತು ನಾವು ಏನನ್ನಾದರೂ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು
student.age = 12
ಮತ್ತು student.name = ವಿದ್ಯಾರ್ಥಿ.
ಈಗ ನಾವು ಎರಡನೇ ವಿದ್ಯಾರ್ಥಿ ಮಾಡಲು ಬಯಸಿದರೆ?
ಈ ಸಾಲುಗಳನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಯೋಚಿಸುವಿರಾ ಇರಬಹುದು
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2 ಅಥವಾ ಕೆಲಸಕ್ಕೆ ವಿದ್ಯಾರ್ಥಿ ಬದಲಾಯಿಸಲು,
ಮತ್ತು ಕೆಲಸ,
ಆದರೆ ತಾಂತ್ರಿಕವಾಗಿ, ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2
ಅದೇ ರೀತಿಯ ಹೊಂದಿಲ್ಲ.
ನೋಡಿ, ನೀವು ಪರಸ್ಪರ ಅವರನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಇದು ಏಕೆಂದರೆ, ಇಲ್ಲಿಯವರೆಗೆ ಆಗಿದೆ
ನಿಮ್ಮ struct ಅನಾಮಧೇಯ ಬಂದಿದೆ.
ನಾವು ಒಂದು ಹೆಸರನ್ನು ನೀಡಲು ಅಗತ್ಯವಿದೆ.
ಹಾಗೆ ಮಾಡಲು, ನಾವು struct ಹೆಸರನ್ನು ಸೇರಿಸಲು
ಪದ struct ನಂತರ.
ವಿದ್ಯಾರ್ಥಿ,
ವ್ಯಾಖ್ಯಾನವನ್ನು ಅನುಸರಿಸಿ.
ನಾವು ಇನ್ನೂ ತಕ್ಷಣವೇ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ ಘೋಷಿಸಬಹುದು
ನಾವು ಮೊದಲು ಮಾಡಿದ ರೀತಿಯಲ್ಲಿ, ವಿದ್ಯಾರ್ಥಿ struct.
ನಾವು S1 ಕರೆ ಮಾಡುತ್ತೇವೆ
Struct ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಮೂಲಕ,
ನಾವು ಈಗ struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು
ಹೆಚ್ಚೂಕಮ್ಮಿ ಅದೇ ರೀತಿಯಲ್ಲಿ ನಾವು ಇಂಟ್ ಬಳಸಬಹುದು.
ಆದ್ದರಿಂದ ನಾವು, ಕೌಟುಂಬಿಕತೆ struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಬಹುದು
ಅಂತಹ
struct ವಿದ್ಯಾರ್ಥಿ ಎಸ್ 2.
ಸರಣಿಗಳ ನಂತಹ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ, ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಆರಂಭಕ್ಕೆ ವಾಕ್ಯ ಒದಗಿಸಲು
ನಾವು ವಿದ್ಯಾರ್ಥಿ ಎಸ್ 2 struct, ಹೇಳಬಹುದು
ಸಮನಾಗಿರುತ್ತದೆ
ಎಡ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ 3, ಎಸ್ 2.
ಇಲ್ಲಿ, S2.age, 3 ಆಗಿರುತ್ತದೆ
ಮತ್ತು S2.name S2 ಬೆಟ್ಟು ಕಾಣಿಸುತ್ತದೆ.
ಒಂದು ಇಂಟ್ ರೀತಿಯ ನೀವು ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಥಿಂಕ್
ಮತ್ತು ಅವುಗಳನ್ನು ಅತ್ಯಂತ ನೀವು struct ವಿದ್ಯಾರ್ಥಿ ರೀತಿಯ ಮಾಡಬಹುದು.
ನಾವು ಒಂದು ಕಾರ್ಯ ನಿಯತಾಂಕದ ಒಂದು ರೀತಿಯ ಒಂದು struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು.
ನಾವು ಹೊಸ struct ಒಳಗೆ struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು.
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಬಹುದು.
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಗಾತ್ರವನ್ನು ಮಾಡಬಹುದು.
Struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ವಿಧ
ಕೇವಲ ಇಂಟ್ ಒಂದು ವಿಧ.
ನಾವು ಎಸ್ 2 ಗೆ S1 ನಿಯೋಜಿಸಲು ಮಾಡಬಹುದು
ಎರಡೂ ಒಂದೇ ರೀತಿಯ ಕಾರಣ, ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು
ಎಸ್ 1 = ಎಸ್ 2.
ನಾವು ಏನಾಗುತ್ತದೆ
S1.age = 10?
ಎಲ್ಲ S2 ಬದಲಾಗಬಹುದು?
ಮತ್ತೆ, ಕೇವಲ ಸಾಮಾನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಮಾಹಿತಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ನಗರದ.
ನಾವು ಕೆಲವು ಇಂಟ್ ವೈ ಕೆಲವು ಇಂಟ್ ಎಕ್ಸ್ ನಿಯೋಜಿಸಲು ವೇಳೆ,
x = y ಹಾಗೆ
ತದನಂತರ, ಎಕ್ಸ್ ಬದಲಾಯಿಸಲು
ಎಂದು ಎಕ್ಸ್ + +
ವೈ ಎಲ್ಲಾ ಬದಲಾವಣೆ ಇಲ್ಲ?
ವೈ ಇಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು, ಮತ್ತು ಆದ್ದರಿಂದ ಎರಡೂ ಮೇಲೆ S2 ಮಾದರಿಯನ್ನು ನೀಡುವುದಿಲ್ಲ.
S2.age ಇನ್ನೂ 3.
ಆದರೆ ಗಮನಿಸಿ ಮತ್ತೊಂದು struct ನಿಯೋಜಿಸುವ ಆ,
ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಈಗಲೂ ಒಂದೇ ಬೆರಳು
ಅವರು ಕೇವಲ ನಕಲಿಸಲಾಗಿದೆ ರಿಂದ.
ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸದಿದ್ದರೆ,
ನೀವು ಕೈಯಾರೆ ಎಂದು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ
ಬಹುಶಃ ಪಾಯಿಂಟರ್ಗಳ ಒಂದು ಮೆಮೊರಿಯ ಒಂದು ಬ್ಲಾಕ್ malicking ಮೂಲಕ ತೋರಿಸಲು
ಮತ್ತು ಡೇಟಾವನ್ನು ನಕಲು.
ಇದು ಎಲ್ಲೆಡೆ struct ವಿದ್ಯಾರ್ಥಿ ಬರೆಯಲು ಹೊಂದಿರುವ ಕಿರಿಕಿರಿ ಇರಬಹುದು.
ಒಂದು ರೀತಿಯ ಡೆಫ್ ಬಳಸಿ, ನಾವು ಮಾಡಬಹುದು
ರೀತಿಯ ಡೆಫ್
struct
ಮತ್ತು ನಾವು ವಿದ್ಯಾರ್ಥಿ ಕರೆ ಮಾಡುತ್ತೇವೆ.
ಈಗ, ನಾವು ಎಲ್ಲೆಡೆ ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಲು ಬಳಸಿದ.
ಈ ರೀತಿಯ ಡೆಫ್ ಅನಾಮಿಕ struct ಇಲ್ಲಿದೆ
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಕರೆ.
ಆದರೆ ನಾವು ವಿದ್ಯಾರ್ಥಿ ಗುರುತು ಇರಿಸಿಕೊಳ್ಳಲು ವೇಳೆ
ಪದ struct ಮುಂದೆ, typedef struct ವಿದ್ಯಾರ್ಥಿ ಎಂದು,
ನಾವು ಅದಲು ಈಗ struct ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಎರಡೂ ಬಳಸಬಹುದಾಗಿತ್ತು.
ಅವರು ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಿವೆ ಇಲ್ಲ.
ನಾವು ಬಾಬ್ ಗೆ ಡೆಫ್ struct ವಿದ್ಯಾರ್ಥಿ ಟೈಪ್ ಮಾಡಬಹುದು
ನಂತರ ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ಬಾಬ್ struct
ಪರಸ್ಪರ ರೀತಿಯ ಎಂದು.
ಹೊರತಾಗಿ ರೀತಿಯ ಡೆಫ್ ನ,
ನಾವು struct ಮುಂದಿನ ಗುರುತು ಅವಶ್ಯಕತೆ
ವೇಳೆ struct ವ್ಯಾಖ್ಯಾನವನ್ನು
ಪುನರಾವರ್ತಿತ ಹೊಂದಿದೆ.
ಉದಾಹರಣೆಗೆ,
ರೀತಿಯ ಡೆಫ್ struct ನೋಡ್
ಮತ್ತು ಇದು ಒಂದು ಇಂಟ್ Val ವ್ಯಾಖ್ಯಾನಿಸಲಾಯಿತು
ಮತ್ತು ಇನ್ನೊಂದು struct ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತದೆ.,
* ಮುಂದಿನ struct ನೋಡ್ನಲ್ಲಿ ಮಾಹಿತಿ.
ನಂತರ ನಾವು ನೋಡ್ ಕರೆ ಮಾಡುತ್ತೇವೆ.
ಈ struct, ಪುನರಾವರ್ತಿತ ಆಗಿದೆ
struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಇದು ಒಳಗೆ ಒಳಗೊಂಡಿರುತ್ತದೆ
ಒಂದು struct ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್.
ನಾವು struct ನೋಡ್ * ಮುಂದಿನ ಹೇಳಬೇಕೆಂದು ಗಮನಿಸಿ
struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನದ ಒಳಗೆ,
ರೀತಿಯ ಡೆಫ್ ಅವಕಾಶ ಇನ್ನೂ ಮುಗಿದ ಕಾರಣ ಈ ಸರಳಗೊಳಿಸುವ
ಕೇವಲ ನೋಡ್ * ಮುಂದೆ.
ಈ ರೀತಿಯ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಕಲಿಯೋಣ
ಆಗ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಮತ್ತು ಮರಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ.
ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಏನು?
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನ್ಯವಾಗಿಲ್ಲ.
ನಾವು ತೋರಿಸಬಹುದಿತ್ತು
func ಶೂನ್ಯವಾಗುವ
ಇದು, ಒಂದು ಚರ್ಚೆಯಂತೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ವಿದ್ಯಾರ್ಥಿ ರು
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳ ಜೊತೆ ಏನೋ ಮಾಡುತ್ತದೆ.
ನಂತರ ನಾವು ಹಾಗೆ ವಿದ್ಯಾರ್ಥಿ struct ಮಾಹಿತಿ ಸರಿಸುತ್ತದೆ.
ಮೊದಲು S1 ಆಫ್ Func.
struct ವರ್ತಿಸುತ್ತದೆ
ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಫಂಕ್ಷನ್ ರವಾನಿಸಲಾಗಿದೆ ಮಾಡುತ್ತವೆ ನಿಖರವಾಗಿ ಮಾಹಿತಿ.
Func S1 ಪ್ರತಿಯನ್ನು ಪಡೆಯುತ್ತದೆ
ಮತ್ತು ಆದ್ದರಿಂದ S1 ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ;
ಬದಲಿಗೆ, ಎಸ್ ಅದನ್ನು ಕೇವಲ ಪ್ರತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು
ನೀವು ಬಯಸಿದರೆ ಕಾರ್ಯ S1 ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಗೆ
func, ವಿದ್ಯಾರ್ಥಿ * ಎಸ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು
ಮತ್ತು ನೀವು ಹಾಗೆ ವಿಳಾಸಕ್ಕೆ ಅದಕ್ಕೆ S1 ಹಾದು ಮಾಡಬೇಕಾಗಬಹುದು.
ವಿದ್ಯಾರ್ಥಿ * ಎಸ್, func & S1.
ಇಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಹಾದು ಮತ್ತೊಂದು ಕಾರಣಗಳಿವೆ.
ನಮ್ಮ struct 100 ಜಾಗ ಹೊಂದಿತ್ತು ಯಾವ ವೇಳೆ?
ನಾವು func ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಪಾಸ್ ಪ್ರತಿಯೊಂದು ಸಮಯ,
ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ, func ವಾದವನ್ನು ಎಸ್ ಇಂತಹ 100 ಜಾಗ ಎಲ್ಲಾ ನಕಲಿಸಿ ಅಗತ್ಯವಿದೆ
ಸಹ ಅದನ್ನು ಅವುಗಳಲ್ಲಿ ಬಹುಪಾಲು ಎಂದಿಗೂ ಬಳಸುವುದಿಲ್ಲ.
Func ವಿದ್ಯಾರ್ಥಿ ಮಾರ್ಪಡಿಸುವ ಯೋಜನೆ ಇಲ್ಲ ಹಾಗಾಗಿ,
ಇನ್ನೂ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಹಾದುಹೋಗಲು ಬೆಲೆಬಾಳುತ್ತದೆ ವೇಳೆ.
ಸರಿ, ನಾವು struct ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸಲು ಬಯಸಿದರೆ ಏನು?
ನಾವು ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು
ವಿದ್ಯಾರ್ಥಿ * ಎಸ್
malloc ಸಮನಾಗಿರುತ್ತದೆ
ವಿದ್ಯಾರ್ಥಿ ಗಾತ್ರವನ್ನು.
ಈಗಲೂ ಇಲ್ಲಿ ಕೆಲಸ ಆ ಗಾತ್ರವನ್ನು ಗಮನಿಸಿ.
ಆದ್ದರಿಂದ ನಾವು ಈಗ ವಯಸ್ಸು ಸದಸ್ಯ ಪ್ರವೇಶ ಇಲ್ಲ
ಬ್ಲಾಕ್ನ ಎಸ್ ಅಂಕಗಳನ್ನು ಎಂದು?
ನೀವು ಮೊದಲ ಮಾಡಲು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು
* S.age = 4,
ಆದರೆ ಈ ಸಾಕಷ್ಟು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.
ಈ ನಿಜವಾಗಿಯೂ ಸೂಚಿಸಲು ಕಾರಣ
ಆವರಣ = 4 * S.age,
ಇದು ಸಹ, ಕಂಪೈಲ್ ಆಗುವುದಿಲ್ಲ
ಎಸ್ ಒಂದು struct ಒಂದು struct ಅಥವಾ ಬದಲಿಗೆ ಪಾಯಿಂಟರ್ ಕಾರಣ,
ಮತ್ತು ಆದ್ದರಿಂದ ಡಾಟ್ ಇಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.
ನಾವು ಮಾಡಬಹುದಾದ
(* ಎಸ್). ವಯಸ್ಸು = 4
ಆದರೆ ಆವರಣ ಕಿರಿಕಿರಿ ಮತ್ತು ಗೊಂದಲಮಯ ಪಡೆಯುವುದು.
Thankfully, ನಾವು ಒಂದು ವಿಶೇಷ ಬಾಣದ ಆಯೋಜಕರು ಹೊಂದಿವೆ
ವಿಷಯ ತೋರುತ್ತಿದೆ
ಎಸ್> ವಯಸ್ಸು = 4.
ವಯಸ್ಸು ಉಲ್ಲೇಖಗಳನ್ನು ಈ 2 ರೀತಿಯಲ್ಲಿ
ಸಮನಾಗಿದೆ
ಮತ್ತು ನಾವು ಎಂದಿಗೂ, ಬಾಣದ ಆಯೋಜಕರು ಅಗತ್ಯವಿಲ್ಲ
ಆದರೆ ವಿಷಯಗಳನ್ನು ಒಳ್ಳೆಯದೆಂದು ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ.
ಎಸ್ struct ಹೊಂದಿರುವ ಮೆಮೊರಿ ಕೆಲವು ಬ್ಲಾಕ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಏಕೆಂದರೆ,
ಪಾಯಿಂಟರ್ ಬಾಣದ ಅನುಸರಿಸಲು ನೀವು ಎಸ್> ವಯಸ್ಸು ನಗರದ
ಮತ್ತು ವಯಸ್ಸಿನ ಸದಸ್ಯ ಕೀಳುತ್ತಾರೆ.
ಆದ್ದರಿಂದ ನಾವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಬೇಕು?
ಇದು, ಕೇವಲ ಪ್ರಾಚೀನ ಪೂರ್ಣಾಂಕಗಳ ಹೊರಗೆ ಪಡೆಯಲು ಖಂಡಿತವಾಗಿಯೂ ಸಾಧ್ಯತೆಯೂ
ಅಕ್ಷರಗಳು, ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಹಾಗೆ
ನಾವು ಬಳಸುವ ನೀವು;
ಬದಲಿಗೆ ಎಸ್ 1 ಮತ್ತು ಎಸ್ 2 ಮುಂಚೆ,
ನಾವು age1, age2, NAME1, ಮತ್ತು NAME2 ಹೊಂದಿದ್ದವು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರ ಎಲ್ಲಾ.
ಇದು ಕೇವಲ 2 ವಿದ್ಯಾರ್ಥಿಗಳು ಉತ್ತಮವಾಗಿದೆ
ಆದರೆ ನಾವು ಅವರಲ್ಲಿ 10 ಹೊಂದಿದ್ದರೆ?
ಮತ್ತು ಯಾವ ವೇಳೆ ಬದಲು ಕೇವಲ 2 ಜಾಗ,
ವಿದ್ಯಾರ್ಥಿ struct 100 ಜಾಗ ಹೊಂದಿತ್ತು?
GPa, ಶಿಕ್ಷಣ, ಕೂದಲು ಬಣ್ಣ, ಲಿಂಗ, ಹೀಗೆ.
ಬದಲಿಗೆ ಕೇವಲ 10 ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ, ನಾವು 1,000 ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರ ಅಗತ್ಯವಿದೆ.
ಅಲ್ಲದೆ, ಒಂದು ಕಾರ್ಯವನ್ನು ಪರಿಗಣಿಸಿ
ಅದರ ಏಕೈಕ ವಾದವನ್ನು 100 ಜಾಗ ಆ struct ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಮತ್ತು ಎಲ್ಲಾ ಜಾಗ ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ.
ನಾವು struct ಬಳಸಲು ಇದ್ದರೆ,
ನಾವು, ಆ ಕ್ರಿಯೆ ಕರೆ ಪ್ರತಿಯೊಂದು ಸಮಯ
ನಾವು, ಎಲ್ಲಾ 100 ಅಸ್ಥಿರ ನಲ್ಲಿ ಪಾಸ್ ಅಗತ್ಯವಿದೆ
ನಾವು ವಿದ್ಯಾರ್ಥಿ 1 100 ಅಸ್ಥಿರ ಹೊಂದಿದ್ದರೆ,
ಮತ್ತು 100 ವಿದ್ಯಾರ್ಥಿ 2 ಚರಾಂಕಗಳ
ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ವಿದ್ಯಾರ್ಥಿ 1 ಕೆಲವು ಅಸ್ಥಿರ ತೇರ್ಗಡೆಹೊಂದಿಲ್ಲ ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2 ಕೆಲವು ಅಸ್ಥಿರ.
ಇದು, ಒಂದು struct ಆ ತಪ್ಪು ಮಾಡಲು ಅಸಾಧ್ಯ
ಎಲ್ಲಾ 100 ಚರಾಂಕಗಳ ಒಂದೇ ಪ್ಯಾಕೇಜ್ ಒಳಗೊಂಡಿರುವ ಕಾರಣ.
ಅಂತಿಮ ಟಿಪ್ಪಣಿಗಳನ್ನು ಕೇವಲ ಒಂದೆರಡು:
ಈ ಹಂತದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಅಪ್, ಮಹಾನ್ ಅರ್ಥ ನೀವು.
ವೀಡಿಯೊ ಉಳಿದ ಕೇವಲ ಕಂಪ್ಲೀಟ್ನೆಸ್ 'ಸಲುವಾಗಿಯೇ.
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪಾಯಿಂಟರ್ ಯಾವುದೇ ರೀತಿಯ ಹಿಡಿಸುತ್ತದೆ ಏಕೆಂದರೆ,
ಅವರು ಕಾರ್ಯ ಪಾಯಿಂಟರ್ಸ್ ಹಿಡಿಸುತ್ತದೆ.
ನೀವು ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಪರಿಚಿತವಾಗಿರುವ ನೀವು,
ಈ ವಸ್ತು ಆಧಾರಿತ ಶೈಲಿಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂಗೆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ.
ಮತ್ತೊಂದು ಸಮಯದಲ್ಲಿ ಕಾರ್ಯವನ್ನು ಪಾಯಿಂಟರ್ಸ್ ಹೆಚ್ಚು.
ಕೂಡ, ಕೆಲವೊಮ್ಮೆ ನೀವು 2 ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಹೊಂದಿರಬಹುದು
ಇವುಗಳ ವ್ಯಾಖ್ಯಾನಗಳು ಪರಸ್ಪರ ಅವಲಂಬಿಸಿರುತ್ತವೆ.
ಉದಾಹರಣೆಗೆ,
ನಾವು, struct ಎ ತೋರಿಸಬಹುದಿತ್ತು
ಇದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
ಒಂದು struct ಬಿ ಒಂದು ಪಾಯಿಂಟರ್,
struct ಬಿ * ಎಕ್ಸ್,
ಮತ್ತು ಈಗ ನಾವು struct ಬಿ ಹೊಂದಬಹುದು
ಒಂದು ಪಾಯಿಂಟರ್ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
ಒಂದು struct ಎ, ಗೆ
struct ಎ * ವೈ
ಆದರೆ, ಕಂಪೈಲ್ ಆಗುವುದಿಲ್ಲ
struct ಬಿ struct ಒಂದು ಸಂಕಲಿಸಿದ ಎಂದು ಸಮಯದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ರಿಂದ.
ಮತ್ತು ನಾವು struct ಎ ಮತ್ತು struct ಸ್ವ್ಯಾಪ್ ವೇಳೆ ಬಿ,
ನಂತರ ನಾವು ಅದೇ ಸಮಸ್ಯೆಯನ್ನು ಬಿಟ್ಟು ಎಂದೆನಿಸಿತ್ತು;
ಈ ಸಮಯದಲ್ಲಿ, ಒಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಲ್ಲ struct.
ಈ ಪರಿಹರಿಸಲು ನಾವು ಬರೆಯಬಹುದು
struct ಬಿ;
struct ಎ ವ್ಯಾಖ್ಯಾನವನ್ನು ಮೊದಲು
ಇದು ಮುಂದೆ ಘೋಷಣೆ ಕರೆಯಲಾಗುತ್ತದೆ.
ಈ ಕೇವಲ ಕಂಪೈಲರ್ ತಿಳಿದಿರುವ ಅನುಮತಿಸುತ್ತದೆ
struct ಬಿ ಸಂಪೂರ್ಣವಾಗಿ ನಂತರ ಅಥವಾ ಬೇರೆ ಕಡೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಮಾನ್ಯ ವಿಧ.
ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್ ಬೌಡೆನ್ ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.
[CS50.TV]