ಡೇಟಾ ಪ್ರಕಾರಗಳು. C ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾರ್ಯವಿಧಾನದ ಭಾಷೆಗಳಲ್ಲಿನ ಪ್ರೋಗ್ರಾಂ, ವಿವಿಧ ಪ್ರಕಾರಗಳ ಪ್ರಮಾಣದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳ ವಿವರಣೆಯಾಗಿದೆ. ಒಂದು ಪ್ರಕಾರವು ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದಾದ ಮೌಲ್ಯಗಳ ಸೆಟ್ ಮತ್ತು ಅದು ಭಾಗವಹಿಸಬಹುದಾದ ಕಾರ್ಯಾಚರಣೆಗಳ ಗುಂಪನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.

ಸಿ ಭಾಷೆಯಲ್ಲಿ, ಪ್ರಕಾರಗಳು ಪ್ರಮಾಣಗಳ ಹೆಸರುಗಳೊಂದಿಗೆ (ಗುರುತಿಸುವಿಕೆಗಳು) ಸಂಬಂಧಿಸಿವೆ, ಅಂದರೆ ಅಸ್ಥಿರಗಳೊಂದಿಗೆ. ಸಿ ಭಾಷೆಯಲ್ಲಿನ ವೇರಿಯೇಬಲ್ ಮೆಮೊರಿ ಸ್ಥಳದೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿದೆ. ವೇರಿಯಬಲ್‌ನ ಪ್ರಕಾರವು ಕೋಶದ ಗಾತ್ರ, ಅದರ ವಿಷಯಗಳನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡುವ ವಿಧಾನ ಮತ್ತು ಈ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯದ ಮೇಲೆ ಸ್ವೀಕಾರಾರ್ಹ ರೂಪಾಂತರಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಎಲ್ಲಾ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸುವ ಮೊದಲು ಅವುಗಳನ್ನು ಘೋಷಿಸಬೇಕು. ಪ್ರತಿಯೊಂದು ವೇರಿಯಬಲ್ ಅನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಘೋಷಿಸಬೇಕು.

ವಿವರಣೆಯು ವೇರಿಯೇಬಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಅನುಸರಿಸಿ ಟೈಪ್ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಸ್ಥಿರಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಲಾಗಿದೆ. ವಿವರಣೆಯ ಕೊನೆಯಲ್ಲಿ ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು ಇರಿಸಲಾಗಿದೆ.

ಉದಾಹರಣೆ ವಿವರಣೆಗಳು:

ಚಾರ್ a,b; /* ವೇರಿಯೇಬಲ್‌ಗಳು a ಮತ್ತು b ಪ್ರಕಾರವನ್ನು ಹೊಂದಿವೆ

ಚಾರ್ */ intх; /* ವೇರಿಯೇಬಲ್ x ಇಂಟ್ ಪ್ರಕಾರವಾಗಿದೆ

*/ ಚಾರ್ ಸಿಮ್; /" ಚಾರ್ ಪ್ರಕಾರದ ಅಸ್ಥಿರ ಸಿಮ್ ಅನ್ನು ವಿವರಿಸಲಾಗಿದೆ;

*/ int count.num; /* ಸಂಖ್ಯೆ ಮತ್ತು ಪ್ರಕಾರದ ಸಂಖ್ಯೆ ಇಂಟ್ */

ಅಸ್ಥಿರಗಳನ್ನು ಅವುಗಳ ಘೋಷಣೆಗಳಲ್ಲಿ ಆರಂಭಿಕ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಬಹುದು. ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಸಮಾನ ಚಿಹ್ನೆ ಮತ್ತು ಸ್ಥಿರದಿಂದ ಅನುಸರಿಸಿದರೆ, ಆ ಸ್ಥಿರವು ಇನಿಶಿಯಲೈಸರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು:ಚಾರ್ ಬ್ಯಾಕ್ = "\0";

ಸಿ ಭಾಷೆಯಲ್ಲಿ ಮುಖ್ಯ ಪ್ರಕಾರಗಳನ್ನು ನೋಡೋಣ.

ಇಂಟ್ - ಪೂರ್ಣಾಂಕ ("ಪೂರ್ಣಾಂಕ").ಈ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳು ಕೆಲವು ಸೀಮಿತ ವ್ಯಾಪ್ತಿಯ ಪೂರ್ಣಾಂಕಗಳಾಗಿವೆ (ಸಾಮಾನ್ಯವಾಗಿ - 32768 ರಿಂದ 32767 ವರೆಗೆ). ಶ್ರೇಣಿಯನ್ನು ಪ್ರಕಾರದ ಸೆಲ್ ಗಾತ್ರದಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಇಂಟ್ ಪ್ರಕಾರದೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಕಾರ್ಯ ಪದಗಳಿವೆ: ಶಾರ್ಟ್ ಇಂಟ್ (“ಶಾರ್ಟ್ ಪೂರ್ಣಾಂಕ” - “ಶಾರ್ಟ್ ಪೂರ್ಣಾಂಕ”), ಸಹಿ ಮಾಡದ ಪೂರ್ಣಾಂಕ (“ಸಹಿ ಮಾಡದ ಪೂರ್ಣಾಂಕ” - “ಸಹಿ ಮಾಡದ ಪೂರ್ಣಾಂಕ”), ಲಾಂಗ್ ಇಂಟ್ (“ದೀರ್ಘ ಪೂರ್ಣಾಂಕ ” ), ಇದು ಸಂಖ್ಯೆಗಳ ಪ್ರಾತಿನಿಧ್ಯದ ವ್ಯಾಪ್ತಿಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಅಥವಾ ವಿಸ್ತರಿಸುತ್ತದೆ.

ಚಾರ್- ಪಾತ್ರ ("ಪಾತ್ರ"). ಈ ಪ್ರಕಾರಕ್ಕೆ ಮಾನ್ಯವಾದ ಮೌಲ್ಯವು ಒಂದು ಅಕ್ಷರವಾಗಿದೆ (ಪಠ್ಯದೊಂದಿಗೆ ಗೊಂದಲಕ್ಕೀಡಾಗಬಾರದು!). ಚಿಹ್ನೆಯನ್ನು ಅಪಾಸ್ಟ್ರಫಿಗಳಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ.

ಉದಾಹರಣೆಗಳು:"x"2"?"

ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಯಲ್ಲಿ, ಒಂದು ಅಕ್ಷರವು ಒಂದು ಬೈಟ್ ಅನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ಇದು ಸಂಗ್ರಹವಾಗಿರುವ ಸಂಕೇತವಲ್ಲ, ಆದರೆ ಒಂದು ಸಂಖ್ಯೆ - ಸಂಕೇತ ಸಂಕೇತ (0 ರಿಂದ 255 ರವರೆಗೆ). ವಿಶೇಷ ಎನ್‌ಕೋಡಿಂಗ್ ಕೋಷ್ಟಕಗಳು ಎಲ್ಲಾ ಮಾನ್ಯವಾದ ಅಕ್ಷರಗಳು ಮತ್ತು ಅವುಗಳ ಅನುಗುಣವಾದ ಕೋಡ್‌ಗಳನ್ನು ಸೂಚಿಸುತ್ತವೆ.

ಸಿ ಭಾಷೆಯಲ್ಲಿ, ಚಾರ್ ಪ್ರಕಾರವನ್ನು ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಬಳಸಲು ಅನುಮತಿಸಲಾಗಿದೆ, ಅಂದರೆ, ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರದ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅಕ್ಷರ ಕೋಡ್‌ನೊಂದಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು - (ಇಂಟ್).

ಫ್ಲೋಟ್ - ನೈಜ (ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್).ಈ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳು ಸಂಖ್ಯೆಗಳಾಗಿವೆ, ಆದರೆ, ಚಾರ್ ಮತ್ತು ಇಂಟ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ಪೂರ್ಣಾಂಕಗಳ ಅಗತ್ಯವಿಲ್ಲ.

12.87 -316.12 -3.345e5 12.345e-15

ಡಬಲ್ - ಡಬಲ್ ನಿಖರವಾದ ನೈಜ ಸಂಖ್ಯೆಗಳು.ಈ ಪ್ರಕಾರವು ಫ್ಲೋಟ್ ಪ್ರಕಾರವನ್ನು ಹೋಲುತ್ತದೆ, ಆದರೆ ಗಮನಾರ್ಹವಾಗಿ ದೊಡ್ಡ ಶ್ರೇಣಿಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ (ಉದಾಹರಣೆಗೆ, ಬೋರ್ಲ್ಯಾಂಡ್-ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗೆ 3.4E-38 ರಿಂದ 1.7E-308 ರಿಂದ 1.7E+308 ವರೆಗಿನ ವ್ಯಾಪ್ತಿಯ ಬದಲಿಗೆ ಫ್ಲೋಟ್ ಪ್ರಕಾರಕ್ಕಾಗಿ 3.4E+38). ಆದಾಗ್ಯೂ, ಸಂಖ್ಯೆಯ ಪ್ರಾತಿನಿಧ್ಯದ ವ್ಯಾಪ್ತಿ ಮತ್ತು ನಿಖರತೆಯ ಹೆಚ್ಚಳವು ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ವೇಗದಲ್ಲಿ ಇಳಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಕಂಪ್ಯೂಟರ್ RAM ನ ವ್ಯರ್ಥ ಬಳಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ತಂತಿಗಳನ್ನು ವಿವರಿಸಲು C ನಲ್ಲಿ ಯಾವುದೇ ವಿಶೇಷ ಪ್ರಕಾರವಿಲ್ಲ. ಬದಲಾಗಿ, ತಂತಿಗಳನ್ನು ಚಾರ್ ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಅಕ್ಷರಗಳು ಪಕ್ಕದ ಮೆಮೊರಿ ಕೋಶಗಳಲ್ಲಿ ಇರುತ್ತವೆ.

ರಚನೆಯ ಕೊನೆಯ ಅಂಶವು \0 ಅಕ್ಷರವಾಗಿದೆ ಎಂದು ಗಮನಿಸಬೇಕು. ಇದು "ಶೂನ್ಯ" ಅಕ್ಷರವಾಗಿದೆ, ಮತ್ತು ಸಿ ಭಾಷೆಯಲ್ಲಿ ಇದನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನ ಅಂತ್ಯವನ್ನು ಗುರುತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಶೂನ್ಯ ಅಕ್ಷರವು ಸಂಖ್ಯೆ 0 ಅಲ್ಲ; ಇದನ್ನು ಮುದ್ರಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ASCII ಕೋಡ್ ಕೋಷ್ಟಕದಲ್ಲಿ 0 ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿದೆ. ಶೂನ್ಯ ಅಕ್ಷರದ ಉಪಸ್ಥಿತಿಯು ರಚನೆಯ ಕೋಶಗಳ ಸಂಖ್ಯೆಯು ಇರಬೇಕು ಎಂದರ್ಥ. ಮೆಮೊರಿಯಲ್ಲಿ ಶೇಖರಿಸಬೇಕಾದ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಗಿಂತ ಕನಿಷ್ಠ ಒಂದು ಹೆಚ್ಚು.

ತಂತಿಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಯನ್ನು ನೀಡೋಣ.

ಕಾರ್ಯಕ್ರಮ 84

#ಸೇರಿಸು ಮುಖ್ಯ()

scanf("%s",string) ;

printf("%s",ಸ್ಟ್ರಿಂಗ್);

ಈ ಉದಾಹರಣೆಯು 31 ಮೆಮೊರಿ ಸ್ಥಳಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ, ಅವುಗಳಲ್ಲಿ 30 ಒಂದೇ ಚಾರ್ ಅಂಶವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು. ಕಾರ್ಯವನ್ನು ಕರೆಯುವಾಗ ಅದನ್ನು ನಮೂದಿಸಲಾಗಿದೆ scanf("%s",string); ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವಾಗ "&" ಕಾಣೆಯಾಗಿದೆ.

ಸೈನ್‌ಪೋಸ್ಟ್‌ಗಳು. ಪಾಯಿಂಟರ್ ಎನ್ನುವುದು ವೇರಿಯೇಬಲ್‌ಗಾಗಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಸ್ಥಳದ ವಿಳಾಸದ ಕೆಲವು ಸಾಂಕೇತಿಕ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ.

ಉದಾಹರಣೆಗೆ, &name ಎಂಬುದು ಹೆಸರಿನ ವೇರಿಯಬಲ್‌ಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ;

ವಿಳಾಸವನ್ನು ಪಡೆಯುವ ಕಾರ್ಯಾಚರಣೆ ಇಲ್ಲಿದೆ. ನಿಜವಾದ ವಿಳಾಸವು ಒಂದು ಸಂಖ್ಯೆಯಾಗಿದೆ ಮತ್ತು ವಿಳಾಸದ ಸಾಂಕೇತಿಕ ಪ್ರಾತಿನಿಧ್ಯವು &ಹೆಸರಿನ ಪಾಯಿಂಟರ್ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.

ಸಿ ಭಾಷೆಯು ಪಾಯಿಂಟರ್ ಪ್ರಕಾರದ ಅಸ್ಥಿರಗಳನ್ನು ಸಹ ಹೊಂದಿದೆ. ಚಾರ್ ವೇರಿಯೇಬಲ್‌ನ ಮೌಲ್ಯವು ಒಂದು ಅಕ್ಷರವಾಗಿದೆ ಮತ್ತು ಇಂಟ್ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವು ಪೂರ್ಣಾಂಕವಾಗಿದೆ, ಪಾಯಿಂಟರ್ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವು ಕೆಲವು ಮೌಲ್ಯದ ವಿಳಾಸವಾಗಿದೆ.

ನಾವು ಪಾಯಿಂಟರ್‌ಗೆ ptr ಎಂಬ ಹೆಸರನ್ನು ನೀಡಿದರೆ, ನಾವು ಈ ರೀತಿಯ ಹೇಳಿಕೆಯನ್ನು ಬರೆಯಬಹುದು:

ptr = /* ವಿಳಾಸದ ಹೆಸರನ್ನು ವೇರಿಯಬಲ್ ptr */ ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ

prt ಒಂದು "ಪಾಯಿಂಟರ್ ಟು" ಹೆಸರು ಎಂದು ನಾವು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹೇಳುತ್ತೇವೆ. ಎರಡು ಸಂಕೇತಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸ: ptr ಮತ್ತು &ಹೆಸರು prt ಒಂದು ವೇರಿಯೇಬಲ್ ಆಗಿದೆ, ಆದರೆ &ಹೆಸರು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ptr ವೇರಿಯಬಲ್ ಅನ್ನು ಬೇರೆ ಯಾವುದಾದರೂ ವಸ್ತುವಿಗೆ ಸೂಚಿಸಬಹುದು:

ptr= /* ptr ಬಾಹ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಹೆಸರಲ್ಲ */

ಈಗ ವೇರಿಯೇಬಲ್ prt ನ ಮೌಲ್ಯವು ವೇರಿಯೇಬಲ್ bah ನ ವಿಳಾಸವಾಗಿದೆ. ವೇರಿಯೇಬಲ್ ptr ವೇರಿಯೇಬಲ್ bah ಗೆ ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನಂತರ, ಈ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು, ನೀವು "ಪರೋಕ್ಷ ವಿಳಾಸ" ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಬಹುದು *:

val = *ptr; /* ptr ನಿಂದ ಸೂಚಿಸಲಾದ ಮೌಲ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ */ ಒಟ್ಟಿಗೆ ತೆಗೆದುಕೊಂಡ ಕೊನೆಯ ಎರಡು ಹೇಳಿಕೆಗಳು ಈ ಕೆಳಗಿನವುಗಳಿಗೆ ಸಮನಾಗಿರುತ್ತದೆ:

ಆದ್ದರಿಂದ, ಚಿಹ್ನೆಯ ಹಿಂದೆ ಇದ್ದಾಗ & ವೇರಿಯಬಲ್ ಹೆಸರಿನ ನಂತರ, ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವೇರಿಯಬಲ್ನ ವಿಳಾಸವಾಗಿದೆ; &ನರ್ಸ್ ವೇರಿಯಬಲ್ ನರ್ಸ್ ವಿಳಾಸವನ್ನು ನೀಡುತ್ತದೆ; ಒಂದು * ಅನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ಪಾಯಿಂಟರ್ ಅನುಸರಿಸಿದಾಗ, ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವು ನಿರ್ದಿಷ್ಟ ವಿಳಾಸದಲ್ಲಿ ಮೆಮೊರಿ ಸ್ಥಳದಲ್ಲಿ ಇರಿಸಲಾದ ಮೌಲ್ಯವಾಗಿದೆ.

ಉದಾಹರಣೆ:ದಾದಿ = 22;

ptr = /* ದಾದಿಗೆ ಪಾಯಿಂಟರ್ */

ಫಲಿತಾಂಶವು ವೇರಿಯಬಲ್ ವಾಲ್‌ಗೆ ಮೌಲ್ಯ 22 ರ ನಿಯೋಜನೆಯಾಗಿದೆ.

ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪಾಯಿಂಟರ್ ಎಂದು ಹೇಳುವುದು ಸಾಕಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಈ ಪಾಯಿಂಟರ್ ಯಾವ ರೀತಿಯ ವೇರಿಯಬಲ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುವುದು ಅವಶ್ಯಕ. ಕಾರಣವೆಂದರೆ ವಿವಿಧ ರೀತಿಯ ಅಸ್ಥಿರಗಳು ವಿಭಿನ್ನ ಸಂಖ್ಯೆಯ ಮೆಮೊರಿ ಸ್ಥಳಗಳನ್ನು ಆಕ್ರಮಿಸುತ್ತವೆ, ಆದರೆ ಕೆಲವು ಪಾಯಿಂಟರ್-ಸಂಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹಂಚಿಕೆ ಮಾಡಲಾದ ಮೆಮೊರಿಯ ಪ್ರಮಾಣದ ಜ್ಞಾನದ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಉದಾಹರಣೆಗಳುಪಾಯಿಂಟರ್‌ಗಳ ಸರಿಯಾದ ವಿವರಣೆ: ಇಂಟ್ * ಪೈ; ಚಾರ್ * ಪಿಸಿ;

ಟೈಪ್ ಸ್ಪೆಸಿಫಿಕೇಶನ್ ಪಾಯಿಂಟರ್ ಸೂಚಿಸುವ ವೇರಿಯಬಲ್ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು * ಅಕ್ಷರವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪಾಯಿಂಟರ್ ಎಂದು ಗುರುತಿಸುತ್ತದೆ. ಇಂಟ್ * ಪೈ ಪ್ರಕಾರದ ವಿವರಣೆ; ಪೈ ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು * pi ಒಂದು ಇಂಟ್ ಮೌಲ್ಯ ಎಂದು ಹೇಳುತ್ತಾರೆ.

ಸಿ ಭಾಷೆಯು ಡೇಟಾ ಪ್ರಕಾರದ ಹೆಸರುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಟೈಪ್‌ಡೆಫ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಹೆಸರನ್ನು ನಿಯೋಜಿಸಬಹುದು ಮತ್ತು ವಸ್ತುಗಳನ್ನು ವಿವರಿಸುವಾಗ ಈ ಹೆಸರನ್ನು ನಂತರ ಬಳಸಬಹುದು.

ಸ್ವರೂಪ: typedef<старый тип> <новый тип> ಉದಾಹರಣೆ:ಟೈಪ್‌ಡೆಫ್ ಉದ್ದ ದೊಡ್ಡದು; /* ದೊಡ್ಡ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದು ದೀರ್ಘ ಪ್ರಕಾರಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ */

ಟೈಪ್‌ಡೆಫ್ ಯಾವುದೇ ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಚಯಿಸುವುದಿಲ್ಲ, ಆದರೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಕ್ಕೆ ಹೊಸ ಹೆಸರನ್ನು ಮಾತ್ರ ಸೇರಿಸುತ್ತದೆ. ಈ ರೀತಿಯಲ್ಲಿ ಡಿಕ್ಲೇರ್ ಮಾಡಲಾದ ಅಸ್ಥಿರಗಳು ಸ್ಪಷ್ಟವಾಗಿ ಘೋಷಿಸಿದ ಅಸ್ಥಿರಗಳಂತೆಯೇ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ. ಪ್ರಕಾರದ ಮರುನಾಮಕರಣವನ್ನು ಅರ್ಥಪೂರ್ಣ ಅಥವಾ ಸಂಕ್ಷಿಪ್ತ ಪ್ರಕಾರದ ಹೆಸರುಗಳನ್ನು ಪರಿಚಯಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಪ್ರೋಗ್ರಾಂಗಳ ಅರ್ಥವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಪೋರ್ಟೆಬಿಲಿಟಿಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ (ಒಂದೇ ಡೇಟಾ ಪ್ರಕಾರದ ಹೆಸರುಗಳು ವಿಭಿನ್ನ ಕಂಪ್ಯೂಟರ್‌ಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿರಬಹುದು).

ಕಾರ್ಯಾಚರಣೆ.ಸಿ ಭಾಷೆಯನ್ನು ವಿವಿಧ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಗಳಿಂದ (40 ಕ್ಕಿಂತ ಹೆಚ್ಚು) ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ. ಇಲ್ಲಿ ನಾವು ಮುಖ್ಯವಾದವುಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುತ್ತೇವೆ, ಟೇಬಲ್. 3.3.

ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು. ಇವುಗಳ ಸಹಿತ

ಸೇರಿಸಿ(+),

ವ್ಯವಕಲನ (ಬೈನರಿ) (-),

ಗುಣಾಕಾರ (*),

ವಿಭಾಗ (/),

ಸಂಪೂರ್ಣ ವಿಭಾಗದ ಶೇಷ (%),

ವ್ಯವಕಲನ (ಯೂನರಿ) (-) .

ಸಿ ಭಾಷೆಯು ಒಂದು ನಿಯಮವನ್ನು ಹೊಂದಿದೆ: ಲಾಭಾಂಶ ಮತ್ತು ವಿಭಾಜಕವು ಇಂಟ್ ಪ್ರಕಾರವಾಗಿದ್ದರೆ, ವಿಭಜನೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಫಲಿತಾಂಶದ ಭಾಗಶಃ ಭಾಗವನ್ನು ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ.

ಎಂದಿನಂತೆ, ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ, ಗುಣಾಕಾರ, ಭಾಗಾಕಾರ ಮತ್ತು ಶೇಷದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಕಲನ ಮತ್ತು ವ್ಯವಕಲನದ ಮೊದಲು ನಡೆಸಲಾಗುತ್ತದೆ. ಕ್ರಿಯೆಗಳ ಕ್ರಮವನ್ನು ಬದಲಾಯಿಸಲು, ಆವರಣಗಳನ್ನು ಬಳಸಿ.

ಕಾರ್ಯಕ್ರಮ 85

#ಸೇರಿಸು

5 = -3 + 4 * 5 - 6; printf("%d\n",s);

s = -3 + 4% 5 - 6; printf("%d\n",s);

s = -3 * 4% - 6/5; printf("%d\n",s);

s= (7 + 6)%5/2; printf("%d\n",s);

ಕಾರ್ಯಕ್ರಮದ ಅನುಷ್ಠಾನದ ಫಲಿತಾಂಶ: 11 1 0 1

ಕೋಷ್ಟಕ 3.3 ಕಾರ್ಯಾಚರಣೆಗಳ ಆದ್ಯತೆ ಮತ್ತು ಕ್ರಮ

ಕೊನೆಯ ನವೀಕರಣ: 09/17/2017

ಪ್ರತಿಯೊಂದು ವೇರಿಯಬಲ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ. ಮತ್ತು ಈ ಪ್ರಕಾರವು ವೇರಿಯೇಬಲ್ ಯಾವ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಬಹುದು, ಅದರ ಮೇಲೆ ಯಾವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಬಹುದು ಮತ್ತು ಮೆಮೊರಿಯಲ್ಲಿ ಎಷ್ಟು ಬೈಟ್‌ಗಳನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಕೆಳಗಿನ ಮೂಲಭೂತ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು C++ ಭಾಷೆಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:

bool : ಬೂಲಿಯನ್ ಪ್ರಕಾರ. ಎರಡು ಮೌಲ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು: ಸರಿ ಮತ್ತು ತಪ್ಪು. ಈ ಪ್ರಕಾರದ ಮೆಮೊರಿ ಹೆಜ್ಜೆಗುರುತನ್ನು ನಿಖರವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ.

ಚಾರ್ : ಒಂದೇ ASCII ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 1 ಬೈಟ್ (8 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ. -128 ರಿಂದ 127 ರವರೆಗೆ ಅಥವಾ 0 ರಿಂದ 255 ರವರೆಗೆ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

ಸಹಿ ಮಾಡಿದ ಚಾರ್ : ಒಂದೇ ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 1 ಬೈಟ್ (8 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ. -128 ರಿಂದ 127 ರವರೆಗೆ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

ಸಹಿ ಮಾಡದ ಚಾರ್ : ಒಂದೇ ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 1 ಬೈಟ್ (8 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ. 0 ರಿಂದ 255 ರವರೆಗಿನ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

wchar_t : ವಿಶಾಲವಾದ ಪಾತ್ರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ವಿಂಡೋಸ್‌ನಲ್ಲಿ ಇದು 2 ಬೈಟ್‌ಗಳು (16 ಬಿಟ್‌ಗಳು) ಮೆಮೊರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಇದು 4 ಬೈಟ್‌ಗಳು (32 ಬಿಟ್‌ಗಳು) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. 0 ರಿಂದ 65,535 (2 ಬೈಟ್‌ಗಳಿಗೆ), ಅಥವಾ 0 ರಿಂದ 4,294,967,295 (4 ಬೈಟ್‌ಗಳಿಗೆ) ವ್ಯಾಪ್ತಿಯಿಂದ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

char16_t : ಒಂದೇ ಯುನಿಕೋಡ್ ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 2 ಬೈಟ್‌ಗಳನ್ನು (16 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ. 0 ರಿಂದ 65,535 ರವರೆಗಿನ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

char32_t : ಒಂದೇ ಯುನಿಕೋಡ್ ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 4 ಬೈಟ್‌ಗಳನ್ನು (32 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ. 0 ರಿಂದ 4,294,967,295 ವರೆಗೆ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

ಚಿಕ್ಕದು : -32768 ರಿಂದ 32767 ರವರೆಗಿನ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯ 2 ಬೈಟ್‌ಗಳನ್ನು (16 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ.

ಈ ಪ್ರಕಾರವು ಶಾರ್ಟ್ ಇಂಟ್, ಸೈನ್ಡ್ ಶಾರ್ಟ್ ಇಂಟ್, ಸೈನ್ಡ್ ಶಾರ್ಟ್ ಎಂಬ ಸಮಾನಾರ್ಥಕ ಪದಗಳನ್ನು ಸಹ ಹೊಂದಿದೆ.

ಸಹಿ ಮಾಡದ ಚಿಕ್ಕದು: 0 ರಿಂದ 65535 ರವರೆಗಿನ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯ 2 ಬೈಟ್‌ಗಳನ್ನು (16 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ.

ಈ ಪ್ರಕಾರವು ಸಹಿ ಮಾಡದ ಶಾರ್ಟ್ ಇಂಟ್ ಎಂಬ ಸಮಾನಾರ್ಥಕ ಪದವನ್ನು ಸಹ ಹೊಂದಿದೆ.

int: ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಪ್ರೊಸೆಸರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಇದು 2 ಬೈಟ್‌ಗಳು (16 ಬಿಟ್‌ಗಳು) ಅಥವಾ 4 ಬೈಟ್‌ಗಳು (32 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸಬಹುದು. ಅನುಸಾರವಾಗಿ ಮಿತಿ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು –32768 ರಿಂದ 32767 (2 ಬೈಟ್‌ಗಳೊಂದಿಗೆ) ಅಥವಾ −2,147,483,648 ರಿಂದ 2,147,483,647 ವರೆಗೆ (4 ಬೈಟ್‌ಗಳೊಂದಿಗೆ) ಬದಲಾಗಬಹುದು. ಆದರೆ ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಗಾತ್ರವು ಚಿಕ್ಕ ಪ್ರಕಾರದ ಗಾತ್ರಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರಬೇಕು ಅಥವಾ ಸಮನಾಗಿರಬೇಕು ಮತ್ತು ಉದ್ದದ ಪ್ರಕಾರದ ಗಾತ್ರಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರಬೇಕು

ಈ ಪ್ರಕಾರವು ಸೈನ್ ಇನ್ಟ್ ಮತ್ತು ಸಹಿ ಮಾಡಲಾದ ಸಮಾನಾರ್ಥಕಗಳನ್ನು ಹೊಂದಿದೆ.

ಸಹಿ ಮಾಡದ ಪೂರ್ಣಾಂಕ : ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಪ್ರೊಸೆಸರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಇದು 2 ಬೈಟ್‌ಗಳು (16 ಬಿಟ್‌ಗಳು) ಅಥವಾ 4 ಬೈಟ್‌ಗಳು (32 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಈ ಕಾರಣದಿಂದಾಗಿ, ಮಿತಿ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಬದಲಾಗಬಹುದು: 0 ರಿಂದ 65535 ವರೆಗೆ (2 ಬೈಟ್‌ಗಳಿಗೆ), ಅಥವಾ 0 ರಿಂದ 4,294,967,295 (4 ಬೈಟ್‌ಗಳಿಗೆ).

ಅನ್ಸೈನ್ಡ್ ಅನ್ನು ಈ ಪ್ರಕಾರಕ್ಕೆ ಸಮಾನಾರ್ಥಕವಾಗಿ ಬಳಸಬಹುದು

ಉದ್ದ : −2,147,483,648 ರಿಂದ 2,147,483,647 ವರೆಗಿನ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯ 4 ಬೈಟ್‌ಗಳನ್ನು (32 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ.

ಈ ಪ್ರಕಾರವು ಲಾಂಗ್ ಇಂಟ್, ಸಹಿ ಲಾಂಗ್ ಇಂಟ್ ಮತ್ತು ಲಾಂಗ್ ಸಹಿ ಎಂಬ ಸಮಾನಾರ್ಥಕ ಪದಗಳನ್ನು ಸಹ ಹೊಂದಿದೆ

ಸಹಿ ಮಾಡದ ಉದ್ದ: 0 ರಿಂದ 4,294,967,295 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. 4 ಬೈಟ್‌ಗಳು (32 ಬಿಟ್‌ಗಳು) ಮೆಮೊರಿಯನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ.

ಅನ್ಸೈನ್ಡ್ ಲಾಂಗ್ ಇಂಟ್ ಎಂಬ ಸಮಾನಾರ್ಥಕ ಪದವನ್ನು ಹೊಂದಿದೆ.

ದೀರ್ಘ ಉದ್ದ: −9,223,372,036,854,775,808 ರಿಂದ +9,223,372,036,854,775,807 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ 8 ಬೈಟ್‌ಗಳು (64 ಬಿಟ್‌ಗಳು) ಮೆಮೊರಿಯನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ.

ಲಾಂಗ್ ಲಾಂಗ್ ಇಂಟ್ ಎಂಬ ಸಮಾನಾರ್ಥಕಗಳನ್ನು ಹೊಂದಿದೆ, ಲಾಂಗ್ ಲಾಂಗ್ ಇಂಟ್ ಮತ್ತು ಲಾಂಗ್ ಲಾಂಗ್ ಸಹಿ ಮಾಡಲಾಗಿದೆ.

ಸಹಿ ಮಾಡದ ಉದ್ದ: 0 ರಿಂದ 18,446,744,073,709,551,615 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ 8 ಬೈಟ್‌ಗಳು (64 ಬಿಟ್‌ಗಳು) ಮೆಮೊರಿಯನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ.

ಅನ್ಸೈನ್ಡ್ ಲಾಂಗ್ ಲಾಂಗ್ ಇಂಟ್ ಎಂಬ ಸಮಾನಾರ್ಥಕ ಪದವನ್ನು ಹೊಂದಿದೆ.

ಫ್ಲೋಟ್ : +/- 3.4E-38 ರಿಂದ 3.4E+38 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಏಕ-ನಿಖರವಾದ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ನೈಜ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 4 ಬೈಟ್‌ಗಳನ್ನು (32 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ

ಡಬಲ್ : +/- 1.7E-308 ರಿಂದ 1.7E+308 ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಎರಡು ನಿಖರವಾದ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ನೈಜ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿ 8 ಬೈಟ್‌ಗಳನ್ನು (64 ಬಿಟ್‌ಗಳು) ಆಕ್ರಮಿಸುತ್ತದೆ

ದೀರ್ಘ ಡಬಲ್ : ಕನಿಷ್ಠ 8 ಬೈಟ್‌ಗಳ (64 ಬಿಟ್‌ಗಳು) ಡಬಲ್-ನಿಖರವಾದ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ನೈಜ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಅವಲಂಬಿಸಿ, ಮಾನ್ಯ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಬದಲಾಗಬಹುದು.

ಶೂನ್ಯ: ಮೌಲ್ಯವಿಲ್ಲದೆ ಟೈಪ್ ಮಾಡಿ

ಹೀಗಾಗಿ, ಶೂನ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮೂರು ಗುಂಪುಗಳಾಗಿ ವಿಂಗಡಿಸಬಹುದು: ಅಕ್ಷರ (ಚಾರ್, wchar_t, char16_t, char32_t), ಪೂರ್ಣಾಂಕ (ಶಾರ್ಟ್, ಇಂಟ್, ಲಾಂಗ್, ಲಾಂಗ್ ಲಾಂಗ್) ಮತ್ತು ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರಗಳು (ಫ್ಲೋಟ್, ಡಬಲ್, ಲಾಂಗ್ ಡಬಲ್).

ಅಕ್ಷರ ಪ್ರಕಾರಗಳು

ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಲಾಗುವ ಪ್ರಕಾರಗಳೆಂದರೆ char, wchar_t, char16_t ಮತ್ತು char32_t.

ಹಲವಾರು ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ:

ಚಾರ್ ಸಿ="ಡಿ"; wchar_t d="c";

ಒಂದು ಚಾರ್ ವೇರಿಯೇಬಲ್ ಏಕ ಉಲ್ಲೇಖಗಳಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಅದರ ಮೌಲ್ಯವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: char c = "d" . ಪಟ್ಟಿಯಲ್ಲಿ ಮೇಲೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಶ್ರೇಣಿಯಿಂದ ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಸಹ ನಿಯೋಜಿಸಬಹುದು: char c = 120 . ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವೇರಿಯಬಲ್ c ನ ಮೌಲ್ಯವು ASCII ಅಕ್ಷರ ಕೋಷ್ಟಕದಲ್ಲಿ ಕೋಡ್ 120 ಅನ್ನು ಹೊಂದಿರುವ ಅಕ್ಷರವಾಗಿರುತ್ತದೆ.

ಕನ್ಸೋಲ್‌ಗೆ wchar_t ಅಕ್ಷರಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಲು, ನೀವು std::cout ಅಲ್ಲ, ಆದರೆ std::wcout ಸ್ಟ್ರೀಮ್: ಅನ್ನು ಬಳಸಬೇಕು ಎಂದು ಪರಿಗಣಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.

#ಸೇರಿಸು int main() (char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

ಈ ಸಂದರ್ಭದಲ್ಲಿ, std::wcout ಸ್ಟ್ರೀಮ್ char ಮತ್ತು wchar_t ಎರಡರಲ್ಲೂ ಕೆಲಸ ಮಾಡಬಹುದು. ಮತ್ತು wchar_t ವೇರಿಯೇಬಲ್‌ಗಾಗಿ std::cout ಸ್ಟ್ರೀಮ್ ಅಕ್ಷರದ ಬದಲಿಗೆ ಅದರ ಸಂಖ್ಯಾ ಕೋಡ್ ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ.

C++11 ಮಾನದಂಡವು char16_t ಮತ್ತು char32_t ಪ್ರಕಾರಗಳನ್ನು ಸೇರಿಸಿದೆ, ಇದು ಯುನಿಕೋಡ್ ಬಳಸುವ ಕಡೆಗೆ ಆಧಾರಿತವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಈ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಎಳೆಗಳನ್ನು ಇನ್ನೂ ಓಎಸ್ ಮಟ್ಟದಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿಲ್ಲ. ಆದ್ದರಿಂದ, ನೀವು ಈ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಪ್ರದರ್ಶಿಸಬೇಕಾದರೆ, ನೀವು ಅಸ್ಥಿರಗಳನ್ನು ಚಾರ್ ಅಥವಾ wchar_t ಪ್ರಕಾರಗಳಿಗೆ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ:

#ಸೇರಿಸು int main() (char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಔಟ್‌ಪುಟ್ ಮಾಡುವಾಗ, ಅಸ್ಥಿರಗಳನ್ನು ಚಾರ್ ಪ್ರಕಾರಕ್ಕೆ ಎರಕಹೊಯ್ದ ಕಾರ್ಯಾಚರಣೆಯಿಂದ ಮುಂಚಿತವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ - (ಚಾರ್) , ಇದರಿಂದಾಗಿ ವೇರಿಯಬಲ್‌ಗಳ ಮೌಲ್ಯಗಳು ಬಿ, ಸಿ ಮತ್ತು ಡಿ ಅನ್ನು ಚಾರ್ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಮಾಡಬಹುದು ಕನ್ಸೋಲ್ std ::cout ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.

ಪೂರ್ಣಾಂಕ ವಿಧಗಳು

ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರಗಳನ್ನು ಈ ಕೆಳಗಿನ ಪ್ರಕಾರಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ: ಸಣ್ಣ, ಸಹಿ ಮಾಡದ ಕಿರು, ಇಂಟ್, ಸಹಿ ಮಾಡದ ಇಂಟ್, ಉದ್ದ, ಸಹಿ ಮಾಡದ ಉದ್ದ, ದೀರ್ಘ ಉದ್ದ ಮತ್ತು ಸಹಿ ಮಾಡದ ಉದ್ದ:

ಶಾರ್ಟ್ ಎ = -10; ಸಹಿ ಮಾಡದ ಕಿರು b= 10; ಇಂಟ್ ಸಿ = -30; ಸಹಿ ಮಾಡದ ಇಂಟ್ ಡಿ = 60; ಉದ್ದ ಇ = -170; ಸಹಿ ಮಾಡದ ದೀರ್ಘ f = 45; ದೀರ್ಘ ಉದ್ದದ ಗ್ರಾಂ = 89;

ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳ ವಿಧಗಳು

ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಮತ್ತು ಭಾಗಶಃ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರಗಳನ್ನು ಫ್ಲೋಟ್, ಡಬಲ್ ಮತ್ತು ಲಾಂಗ್ ಡಬಲ್ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ:

ಫ್ಲೋಟ್ a = -10.45; ಡಬಲ್ ಬಿ = 0.00105; ಉದ್ದ ಡಬಲ್ ಸಿ = 30.890045;

ಡೇಟಾ ಪ್ರಕಾರದ ಗಾತ್ರಗಳು

ಮೇಲಿನ ಪಟ್ಟಿಯು ಪ್ರತಿಯೊಂದು ಪ್ರಕಾರಕ್ಕೂ ಅದು ಮೆಮೊರಿಯಲ್ಲಿ ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಗಾತ್ರವನ್ನು ತೋರಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕಂಪ್ಯೂಟರ್‌ನ ಹಾರ್ಡ್‌ವೇರ್ ಸಾಮರ್ಥ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಕಂಪೈಲರ್ ಡೆವಲಪರ್‌ಗಳು ಸ್ವತಂತ್ರವಾಗಿ ಪ್ರಕಾರಗಳಿಗೆ ಗಾತ್ರದ ಮಿತಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು ಎಂದು ಗಮನಿಸಬೇಕಾದ ಅಂಶವಾಗಿದೆ. ಮಾನದಂಡವು ಇರಬೇಕಾದ ಕನಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಮತ್ತು ಶಾರ್ಟ್ ಪ್ರಕಾರಗಳಿಗೆ ಕನಿಷ್ಠ ಮೌಲ್ಯವು 16 ಬಿಟ್‌ಗಳು, ದೀರ್ಘ ಪ್ರಕಾರಕ್ಕೆ - 32 ಬಿಟ್‌ಗಳು, ಉದ್ದವಾದ ಡಬಲ್ ಪ್ರಕಾರಕ್ಕೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಉದ್ದದ ಪ್ರಕಾರದ ಗಾತ್ರವು ಇಂಟ್ ಪ್ರಕಾರದ ಗಾತ್ರಕ್ಕಿಂತ ಕಡಿಮೆಯಿರಬಾರದು ಮತ್ತು ಇಂಟ್ ಪ್ರಕಾರದ ಗಾತ್ರವು ಚಿಕ್ಕ ಪ್ರಕಾರದ ಗಾತ್ರಕ್ಕಿಂತ ಕಡಿಮೆಯಿರಬಾರದು ಮತ್ತು ಉದ್ದವಾದ ಡಬಲ್ ಪ್ರಕಾರದ ಗಾತ್ರವು ಇರಬೇಕು ದ್ವಿಗುಣಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Windows ಗಾಗಿ g++ ಕಂಪೈಲರ್ ದೀರ್ಘ ಡಬಲ್ಸ್‌ಗಾಗಿ 12 ಬೈಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋದಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಕಂಪೈಲರ್ ಮತ್ತು ವಿಂಡೋಸ್ ಅಡಿಯಲ್ಲಿ ರನ್ ಆಗುವ ದೀರ್ಘ ಡಬಲ್ಸ್‌ಗಾಗಿ 8 ಬೈಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಅಂದರೆ, ಒಂದೇ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿಯೂ ಸಹ, ವಿಭಿನ್ನ ಕಂಪೈಲರ್‌ಗಳು ಕೆಲವು ಡೇಟಾ ಪ್ರಕಾರಗಳ ಗಾತ್ರಗಳಿಗೆ ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ, ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ವಿವರಿಸುವಾಗ ಮೇಲೆ ಸೂಚಿಸಲಾದ ಗಾತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಆದಾಗ್ಯೂ, ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಗಾತ್ರವನ್ನು ನಿಖರವಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಅಗತ್ಯವಾದಾಗ ಸಂದರ್ಭಗಳಿವೆ. ಮತ್ತು ಇದಕ್ಕಾಗಿ, C++ ಗಾತ್ರದ () ಆಪರೇಟರ್ ಅನ್ನು ಹೊಂದಿದೆ, ಇದು ವೇರಿಯಬಲ್ ಆಕ್ರಮಿಸುವ ಬೈಟ್‌ಗಳಲ್ಲಿ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

#ಸೇರಿಸು int main() (ಉದ್ದದ ಡಬಲ್ ಸಂಖ್ಯೆ = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

g++ ನಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡುವಾಗ ಕನ್ಸೋಲ್ ಔಟ್‌ಪುಟ್:

ಗಾತ್ರ(ಸಂಖ್ಯೆ) = 12

ಅದೇ ಸಮಯದಲ್ಲಿ, ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ, ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಅದರ ಪ್ರಕಾರಕ್ಕೆ ವಿವರಿಸಿದ ಮಿತಿಗಳನ್ನು ಮೀರಿ ಹೋಗಬಾರದು ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಉದಾಹರಣೆಗೆ:

ಸಹಿ ಮಾಡದ ಸಣ್ಣ ಸಂಖ್ಯೆ = -65535;

G++ ಕಂಪೈಲರ್, ಈ ಸಾಲಿನೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವಾಗ, -65535 ಮೌಲ್ಯವು ಸಹಿ ಮಾಡದ ಕಿರು ಪ್ರಕಾರಕ್ಕೆ ಮಾನ್ಯವಾದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯಲ್ಲಿಲ್ಲ ಮತ್ತು ಅದನ್ನು ಮೊಟಕುಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂದು ಹೇಳುವ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋದಲ್ಲಿ, ಸಂಕಲನವು ದೋಷಗಳಿಲ್ಲದೆ ಮುಂದುವರಿಯಬಹುದು, ಆದರೆ ಸಂಖ್ಯೆ ವೇರಿಯಬಲ್ ಮೌಲ್ಯ 2 ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ - ಸಂಖ್ಯೆ -65535 ಅನ್ನು ಸಹಿ ಮಾಡದ ಸಣ್ಣ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಫಲಿತಾಂಶ. ಅಂದರೆ, ಮತ್ತೆ, ಫಲಿತಾಂಶವು ನಿರೀಕ್ಷಿತ ಪ್ರಮಾಣದಲ್ಲಿರುವುದಿಲ್ಲ. ವೇರಿಯೇಬಲ್‌ನ ಮೌಲ್ಯವು ಮೆಮೊರಿಯಲ್ಲಿನ ಬಿಟ್‌ಗಳ ಸಂಗ್ರಹವಾಗಿದೆ, ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಅರ್ಥೈಸಲಾಗುತ್ತದೆ. ಮತ್ತು ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳಿಗೆ, ಒಂದೇ ರೀತಿಯ ಬಿಟ್‌ಗಳನ್ನು ವಿಭಿನ್ನವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಆದ್ದರಿಂದ, ವೇರಿಯಬಲ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುವಾಗ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಮೌಲ್ಯ ಶ್ರೇಣಿಗಳನ್ನು ಪರಿಗಣಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಸ್ವಯಂ ಸ್ಪೆಸಿಫೈಯರ್

ಕೆಲವೊಮ್ಮೆ ಅಭಿವ್ಯಕ್ತಿಯ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಮತ್ತು ಇತ್ತೀಚಿನ ಮಾನದಂಡಗಳ ಪ್ರಕಾರ, ಕಂಪೈಲರ್ ವಸ್ತುವಿನ ಪ್ರಕಾರವನ್ನು ನಿರ್ಣಯಿಸಲು ನೀವು ಅನುಮತಿಸಬಹುದು. ಮತ್ತು ಸ್ವಯಂ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಇದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ನಾವು ಸ್ವಯಂ ಸ್ಪೆಸಿಫೈಯರ್ನೊಂದಿಗೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಈ ವೇರಿಯಬಲ್ ಅನ್ನು ಕೆಲವು ಮೌಲ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು:

ಆಟೋ ಸಂಖ್ಯೆ = 5;

ನಿಯೋಜಿಸಲಾದ ಮೌಲ್ಯವನ್ನು ಆಧರಿಸಿ, ಕಂಪೈಲರ್ ವೇರಿಯಬಲ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ಣಯಿಸುತ್ತದೆ. ಸ್ವಯಂ ಸ್ಪೆಸಿಫೈಯರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸದ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ.

ಈ ವಿಭಾಗವು C++ ನಲ್ಲಿ ಮುಖ್ಯ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ; ಈ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಎಂದೂ ಕರೆಯಲಾಗುತ್ತದೆ. C++ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯು ವಿಸ್ತರಿಸಬಹುದಾದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ. ಎಕ್ಸ್‌ಟೆನ್ಸಿಬಲ್ ಎಂಬ ಪದವು ಅಂತರ್ನಿರ್ಮಿತ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಿಮ್ಮ ಸ್ವಂತ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ನೀವು ರಚಿಸಬಹುದು. ಅದಕ್ಕಾಗಿಯೇ C++ ನಲ್ಲಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಡೇಟಾ ಪ್ರಕಾರಗಳಿವೆ. ನಾವು ಮುಖ್ಯವಾದವುಗಳನ್ನು ಮಾತ್ರ ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ.

ಕೋಷ್ಟಕ 1 - C++ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಮಾದರಿ	ಬೈಟ್	ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿ
ಪೂರ್ಣಾಂಕ (ಬೂಲಿಯನ್) ಡೇಟಾ ಪ್ರಕಾರ
ಬೂಲ್	1	0 / 255
ಪೂರ್ಣಾಂಕ (ಅಕ್ಷರ) ಡೇಟಾ ಪ್ರಕಾರ
ಚಾರ್	1	0 / 255
ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರಗಳು
ಸಣ್ಣ ಇಂಟ್	2	-32 768 / 32 767
ಸಹಿ ಮಾಡದ ಶಾರ್ಟ್ ಇಂಟ್	2	0 / 65 535
ಇಂಟ್	4
ಸಹಿ ಮಾಡದ ಇಂಟ್	4	0 / 4 294 967 295
ಉದ್ದ ಇಂಟ್	4	-2 147 483 648 / 2 147 483 647
ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಇಂಟ್	4	0 / 4 294 967 295
ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು
ತೇಲುತ್ತವೆ	4	-2 147 483 648.0 / 2 147 483 647.0
ದೀರ್ಘ ಫ್ಲೋಟ್	8
ದುಪ್ಪಟ್ಟು	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

C++ ನಲ್ಲಿ ಮುಖ್ಯ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಟೇಬಲ್ 1 ತೋರಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣ ಟೇಬಲ್ ಅನ್ನು ಮೂರು ಕಾಲಮ್ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಮೊದಲ ಕಾಲಮ್ ಕಾಯ್ದಿರಿಸಿದ ಪದವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಎರಡನೇ ಕಾಲಮ್ ಅನುಗುಣವಾದ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ವೇರಿಯಬಲ್‌ಗಾಗಿ ನಿಯೋಜಿಸಲಾದ ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಮೂರನೇ ಕಾಲಮ್ ಸ್ವೀಕಾರಾರ್ಹ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಕೋಷ್ಟಕದಲ್ಲಿ ಎಲ್ಲಾ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಚಿಕ್ಕದರಿಂದ ದೊಡ್ಡದಕ್ಕೆ ಜೋಡಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

bool ಡೇಟಾ ಪ್ರಕಾರ

ಕೋಷ್ಟಕದಲ್ಲಿ ಮೊದಲನೆಯದು ಬೂಲ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದೆ — ಒಂದು ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರ, ಏಕೆಂದರೆ ಮಾನ್ಯ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು 0 ರಿಂದ 255 ರವರೆಗಿನ ಪೂರ್ಣಾಂಕಗಳಾಗಿವೆ. ಆದರೆ ನೀವು ಈಗಾಗಲೇ ಗಮನಿಸಿದಂತೆ, ಆವರಣಗಳಲ್ಲಿ ಇದು ತಾರ್ಕಿಕ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೇಳುತ್ತದೆ ಮತ್ತು ಇದು ನಿಜವಾಗಿದೆ. ಏಕೆಂದರೆ ಬೂಲ್ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಪ್ರತ್ಯೇಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿ ಎರಡು ಫಲಿತಾಂಶಗಳಲ್ಲಿ ಒಂದನ್ನು ಹೊಂದಬಹುದು: ಸರಿ ಅಥವಾ ತಪ್ಪು. ನಿಜ - ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿ ನಿಜವಾಗಿದ್ದರೆ, ತಪ್ಪು - ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿ ತಪ್ಪಾಗಿದ್ದರೆ.

ಆದರೆ ಬೂಲ್ ಡೇಟಾ ಪ್ರಕಾರದ ಮಾನ್ಯ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು 0 ರಿಂದ 255 ರವರೆಗೆ ಇರುವುದರಿಂದ, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ತಾರ್ಕಿಕ ಸ್ಥಿರಾಂಕಗಳ ಸರಿ ಮತ್ತು ತಪ್ಪುಗಳೊಂದಿಗೆ ಈ ಶ್ರೇಣಿಯನ್ನು ಹೇಗಾದರೂ ಹೊಂದಿಸುವುದು ಅಗತ್ಯವಾಗಿತ್ತು. ಹೀಗಾಗಿ, ಸ್ಥಿರ ಸತ್ಯವು 1 ರಿಂದ 255 ವರೆಗಿನ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳಿಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ಆದರೆ ಸ್ಥಿರ ತಪ್ಪು ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ - 0. ಬೂಲ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ.

// data_type.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) ( bool boolean = 25; // boole of type of variable of boolean if (boolean) // if cout operator ಸ್ಥಿತಿ<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

IN ಸಾಲು 9ಟೈಪ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಘೋಷಿಸಲಾಗಿದೆಬೂಲ್ , ಇದನ್ನು 25 ಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಸೈದ್ಧಾಂತಿಕವಾಗಿ, ನಂತರಸಾಲುಗಳು 9, ಬೂಲಿಯನ್ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಸಂಖ್ಯೆ 25 ಅನ್ನು ಹೊಂದಿರಬೇಕು, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಈ ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆ 1 ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನಾನು ಹೇಳಿದಂತೆ, ಸಂಖ್ಯೆ 0 ಒಂದು ತಪ್ಪು ಮೌಲ್ಯವಾಗಿದೆ, ಸಂಖ್ಯೆ 1 ನಿಜವಾದ ಮೌಲ್ಯವಾಗಿದೆ. ಪಾಯಿಂಟ್ ಒಂದು ವೇರಿಯೇಬಲ್ ರೀತಿಯಬೂಲ್ ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು - 0 (ತಪ್ಪು) ಅಥವಾ 1 (ನಿಜ). ಆದರೆ ಡೇಟಾ ಪ್ರಕಾರದ ಅಡಿಯಲ್ಲಿಬೂಲ್ ಸಂಪೂರ್ಣ ಬೈಟ್ ಅನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ, ಅಂದರೆ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ಬೂಲ್ 0 ರಿಂದ 255 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ತಪ್ಪು ಮತ್ತು ನಿಜವಾದ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸಲು, ಕೇವಲ ಎರಡು ಮೌಲ್ಯಗಳು 0 ಮತ್ತು 1 ಅಗತ್ಯವಿದೆ. ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸುತ್ತದೆ: "ಇತರ 253 ಮೌಲ್ಯಗಳು ಯಾವುದಕ್ಕಾಗಿ?"

ಈ ಪರಿಸ್ಥಿತಿಯ ಆಧಾರದ ಮೇಲೆ, ನಾವು 2 ರಿಂದ 255 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಖ್ಯೆ 1 ಕ್ಕೆ ಸಮಾನವಾಗಿ ಬಳಸಲು ಒಪ್ಪಿಕೊಂಡಿದ್ದೇವೆ, ಅಂದರೆ ಸತ್ಯ. ಇದಕ್ಕಾಗಿಯೇ ನಿಖರವಾಗಿ ಬೂಲಿಯನ್ ವೇರಿಯೇಬಲ್ 25 ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು 1 ಅಲ್ಲ ಸಾಲುಗಳು 10-13ಘೋಷಿಸಲಾಗಿದೆ, ಇದು ನಿಯಂತ್ರಣವನ್ನು ಆಪರೇಟರ್‌ಗೆ ವರ್ಗಾಯಿಸುತ್ತದೆ ಸಾಲು 11, ಷರತ್ತು ನಿಜವಾಗಿದ್ದರೆ ಮತ್ತು ಆಪರೇಟರ್ ಒಳಗೆ ಸಾಲು 13, ಷರತ್ತು ತಪ್ಪಾಗಿದ್ದರೆ. ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶವನ್ನು ಚಿತ್ರ 1 ರಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.

ನಿಜ = 1 ಮುಂದುವರೆಯಲು, ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. . .

ಚಿತ್ರ 1 - bool ಡೇಟಾ ಪ್ರಕಾರ

ಡೇಟಾ ಪ್ರಕಾರದ ಚಾರ್

ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವು ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದ್ದು ಅದನ್ನು ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಅಂದರೆ, ಪ್ರತಿ ಅಕ್ಷರವು ವ್ಯಾಪ್ತಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಗೆ ಅನುರೂಪವಾಗಿದೆ. ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಅಕ್ಷರ ಡೇಟಾ ಪ್ರಕಾರ ಎಂದೂ ಕರೆಯುತ್ತಾರೆ, ಏಕೆಂದರೆ C++ ನಲ್ಲಿನ ಅಕ್ಷರಗಳ ಚಿತ್ರಾತ್ಮಕ ಪ್ರಾತಿನಿಧ್ಯವು ಚಾರ್ಗೆ ಧನ್ಯವಾದಗಳು. C++ ನಲ್ಲಿ ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು, ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಒಂದು ಬೈಟ್ ಅನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ, ಒಂದು ಬೈಟ್ 8 ಬಿಟ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ನಂತರ ನಾವು ಎರಡನ್ನು 8 ರ ಶಕ್ತಿಗೆ ಹೆಚ್ಚಿಸುತ್ತೇವೆ ಮತ್ತು 256 ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತೇವೆ - ಎನ್ಕೋಡ್ ಮಾಡಬಹುದಾದ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆ. ಹೀಗಾಗಿ, ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಯಾವುದೇ 256 ಅಕ್ಷರಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬಹುದು. ಎಲ್ಲಾ ಎನ್ಕೋಡ್ ಮಾಡಲಾದ ಅಕ್ಷರಗಳನ್ನು ನಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

ASCII (ಇಂಗ್ಲಿಷ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಕೋಡ್ ಫಾರ್ ಇನ್ಫರ್ಮೇಷನ್ ಇಂಟರ್‌ಚೇಂಜ್‌ನಿಂದ) - ಮಾಹಿತಿ ವಿನಿಮಯಕ್ಕಾಗಿ ಅಮೇರಿಕನ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಕೋಡ್.

ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ.

// symbols.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) (ಚಾರ್ ಚಿಹ್ನೆ = "a"; // ಚಾರ್ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ ಅನ್ನು ಘೋಷಿಸುವುದು ಮತ್ತು ಅದನ್ನು "a" ಕೌಟ್ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

ಆದ್ದರಿಂದ, ರಲ್ಲಿ ಸಾಲು 9ಹೆಸರಿನ ವೇರಿಯಬಲ್ಚಿಹ್ನೆ , ಇದು ಸಂಕೇತ ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ"ಎ" ( ASCII ಕೋಡ್) IN ಸಾಲು 10ಕೌಟ್ ಆಪರೇಟರ್ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿರುವ ಅಕ್ಷರವನ್ನು ಮುದ್ರಿಸುತ್ತದೆಚಿಹ್ನೆ IN ಸಾಲು 11ಹೆಸರಿನೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಅರೇ ಘೋಷಿಸಲಾಗಿದೆಸ್ಟ್ರಿಂಗ್ , ಮತ್ತು ರಚನೆಯ ಗಾತ್ರವನ್ನು ಸೂಚ್ಯವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಅರೇಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ"ಜಾಲತಾಣ" . ನಾವು ಚಿಹ್ನೆಯನ್ನು ವೇರಿಯೇಬಲ್ ಆಗಿ ಉಳಿಸಿದಾಗ ದಯವಿಟ್ಟು ಗಮನಿಸಿಚಾರ್ , ನಂತರ ಸಮಾನ ಚಿಹ್ನೆಯ ನಂತರ ನಾವು ಒಂದೇ ಉಲ್ಲೇಖಗಳನ್ನು ಹಾಕುತ್ತೇವೆ, ಅದರಲ್ಲಿ ನಾವು ಚಿಹ್ನೆಯನ್ನು ಬರೆದಿದ್ದೇವೆ. ನಿರ್ದಿಷ್ಟ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಅರೇ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ಸಮಾನ ಚಿಹ್ನೆಯ ನಂತರ ಡಬಲ್ ಕೋಟ್‌ಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ, ಇದರಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ. ನಿಯಮಿತ ಅಕ್ಷರದಂತೆ, ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಔಟ್‌ಪುಟ್ ಆಗಿರುತ್ತವೆಕೌಟ್, ಸಾಲು 12. ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶವನ್ನು ಚಿತ್ರ 2 ರಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.

ಚಿಹ್ನೆ = ಒಂದು ಸ್ಟ್ರಿಂಗ್ = ಸೈಟ್ ಮುಂದುವರೆಯಲು, ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. . .

ಚಿತ್ರ 2 - ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರ

ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಕೋಷ್ಟಕ 1 ರಲ್ಲಿ ಅವುಗಳಲ್ಲಿ ಆರು ಇವೆ: ಶಾರ್ಟ್ ಇಂಟ್, ಸಹಿ ಮಾಡದ ಸಣ್ಣ ಇಂಟ್, ಇಂಟ್, ಸಹಿ ಮಾಡದ ಇಂಟ್, ಲಾಂಗ್ ಇಂಟ್, ಸಹಿ ಮಾಡದ ಲಾಂಗ್ ಇಂಟ್ . ಅವರೆಲ್ಲರೂ ತಮ್ಮದೇ ಆದ ಮೆಮೊರಿ ಗಾತ್ರ ಮತ್ತು ಸ್ವೀಕೃತ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದಾರೆ. ಕಂಪೈಲರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಮೆಮೊರಿಯ ಗಾತ್ರ ಮತ್ತು ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಬದಲಾಗಬಹುದು. ಕೋಷ್ಟಕ 1 ರಲ್ಲಿ, MVS2010 ಕಂಪೈಲರ್‌ಗಾಗಿ ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ಎಲ್ಲಾ ಶ್ರೇಣಿಗಳು ಮತ್ತು ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ಟೇಬಲ್ 1 ರಲ್ಲಿನ ಎಲ್ಲಾ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರ ಮತ್ತು ಸ್ವೀಕೃತ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯ ಕ್ರಮದಲ್ಲಿ ಜೋಡಿಸಲಾಗಿದೆ. ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು, ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು, ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಅಂತೆಯೇ, ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರವು ದೊಡ್ಡದಾಗಿದೆ, ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ದೊಡ್ಡದಾಗಿರುತ್ತದೆ. ಅಲ್ಲದೆ, ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸಹಿ ಮಾಡದ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಘೋಷಿಸಿದರೆ ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಬದಲಾಗುತ್ತದೆ. ಸಹಿ ಮಾಡದ ಪೂರ್ವಪ್ರತ್ಯಯ ಎಂದರೆ ಡೇಟಾ ಪ್ರಕಾರವು ಸಹಿ ಮಾಡಿದ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ನಂತರ ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ದ್ವಿಗುಣಗೊಳಿಸಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಶಾರ್ಟ್ ಇಂಟ್ ಮತ್ತು ಸಹಿ ಮಾಡದ ಶಾರ್ಟ್ ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು.

ಪೂರ್ಣಾಂಕ ಡೇಟಾ ಪ್ರಕಾರದ ಪೂರ್ವಪ್ರತ್ಯಯಗಳು:

ಚಿಕ್ಕದಾಗಿದೆ — ಪೂರ್ವಪ್ರತ್ಯಯವು ಆಕ್ರಮಿಸುವ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ಅದನ್ನು ಅನ್ವಯಿಸುವ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ;

ಉದ್ದವಾಗಿದೆ — ಪೂರ್ವಪ್ರತ್ಯಯವು ಅದು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ಅದನ್ನು ಅನ್ವಯಿಸುವ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ;

ಸಹಿ ಮಾಡದ-ಪೂರ್ವಪ್ರತ್ಯಯವು ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ದ್ವಿಗುಣಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಈ ಡೇಟಾ ಪ್ರಕಾರದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುವುದಿಲ್ಲ.

ಆದ್ದರಿಂದ, ಮೂಲಭೂತವಾಗಿ, ನಾವು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಒಂದು ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದ್ದೇವೆ: ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರ. ಚಿಕ್ಕದಾದ, ಉದ್ದವಾದ, ಸಹಿ ಮಾಡದ ಪೂರ್ವಪ್ರತ್ಯಯಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, ನಿರ್ದಿಷ್ಟ ವೈವಿಧ್ಯಮಯ ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ, ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರ ಮತ್ತು (ಅಥವಾ) ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯಲ್ಲಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ.

ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಡೇಟಾ ವಿಧಗಳು

C++ ನಲ್ಲಿ ಎರಡು ರೀತಿಯ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಡೇಟಾಗಳಿವೆ: ಫ್ಲೋಟ್ ಮತ್ತು ಡಬಲ್. ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಫ್ಲೋಟ್ ಮತ್ತು ಡಬಲ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಧನಾತ್ಮಕ ಮತ್ತು ಋಣಾತ್ಮಕ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರವು ಡಬಲ್ ಡೇಟಾ ಪ್ರಕಾರದ ಅರ್ಧದಷ್ಟು ಮೆಮೊರಿ ಹೆಜ್ಜೆಗುರುತನ್ನು ಹೊಂದಿದೆ, ಅಂದರೆ ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಚಿಕ್ಕದಾಗಿದೆ. ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ದೀರ್ಘ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಘೋಷಿಸಿದರೆ, ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯು ಡಬಲ್ ಡೇಟಾ ಪ್ರಕಾರದ ಸ್ವೀಕೃತ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಗೆ ಸಮನಾಗಿರುತ್ತದೆ. ಮೂಲಭೂತವಾಗಿ, ಹಣದ ವಹಿವಾಟುಗಳಂತಹ ಹೆಚ್ಚಿನ ಕಂಪ್ಯೂಟೇಶನಲ್ ನಿಖರತೆಯೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಅಗತ್ಯವಿದೆ.

ಆದ್ದರಿಂದ, C++ ನಲ್ಲಿನ ಮುಖ್ಯ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಮುಖ್ಯ ಅಂಶಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ಈ ಎಲ್ಲಾ ಸ್ವೀಕೃತ ಮೌಲ್ಯಗಳು ಮತ್ತು ಆಕ್ರಮಿತ ಮೆಮೊರಿಯ ಗಾತ್ರಗಳು ಎಲ್ಲಿಂದ ಬರುತ್ತವೆ ಎಂಬುದನ್ನು ತೋರಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ಮತ್ತು ಇದಕ್ಕಾಗಿ ನಾವು ಮೇಲೆ ಚರ್ಚಿಸಿದ ಎಲ್ಲಾ ರೀತಿಯ ಡೇಟಾದ ಮುಖ್ಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತೇವೆ.

// data_types.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು // I/O ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಲೈಬ್ರರಿ #ಸೇರಿಸು // ಗಣಿತದ ಕಾರ್ಯಗಳ ಹೆಡರ್ ಫೈಲ್ #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) (ಕೌಟ್<< " data type " << "byte" << " " << " max value "<< endl // ಕಾಲಮ್ ಹೆಡರ್ <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿರುವ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನೀವು ವೀಕ್ಷಿಸಲು ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ. ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಪ್ರೋಗ್ರಾಂ ನಿಮಗೆ ಇನ್ನೂ ಪರಿಚಯವಿಲ್ಲದ ನಿಯಂತ್ರಣ ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ನೊಂದಿಗೆ ಬಾಹ್ಯ ಪರಿಚಯಕ್ಕಾಗಿ, ನಾನು ಕೆಲವು ಅಂಶಗಳನ್ನು ಕೆಳಗೆ ವಿವರಿಸುತ್ತೇನೆ. ಆಪರೇಟರ್ಗಾತ್ರ () ಡೇಟಾ ಪ್ರಕಾರ ಅಥವಾ ವೇರಿಯೇಬಲ್‌ಗಾಗಿ ನಿಯೋಜಿಸಲಾದ ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಕಾರ್ಯಪೌ(x,y) ಅರ್ಥವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ y ನ ಶಕ್ತಿಗೆ x , ಈ ಕಾರ್ಯವು ಹೆಡರ್ ಫೈಲ್‌ನಿಂದ ಲಭ್ಯವಿದೆ . ಸ್ಥಿರ ಮತ್ತು ನಿಗದಿತ () ಮ್ಯಾನಿಪ್ಯುಲೇಟರ್‌ಗಳು ಹೆಡರ್ ಫೈಲ್‌ನಿಂದ ಲಭ್ಯವಿದೆ . ಮೊದಲನೆಯದು ಸ್ಥಿರವಾಗಿದೆ , ಔಟ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ಗೆ ಸ್ಥಿರ ರೂಪದಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸುತ್ತದೆ. ಮ್ಯಾನಿಪ್ಯುಲೇಟರ್ setprecision(n) displays n ದಶಮಾಂಶ ಸ್ಥಾನಗಳು. ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪ್ರಕಾರದ ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ಈ ಕೆಳಗಿನ ಸೂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ:

Max_val_type = 2^(b * 8 - 1) - 1; // ಋಣಾತ್ಮಕ ಮತ್ತು ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ // ಇಲ್ಲಿ b ಎಂಬುದು ಈ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ವೇರಿಯಬಲ್‌ಗಾಗಿ ಮೆಮೊರಿಯಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆ // 8 ರಿಂದ ಗುಣಿಸಿ, ಏಕೆಂದರೆ ಒಂದು ಬೈಟ್‌ನಲ್ಲಿ 8 ಬಿಟ್‌ಗಳು // ಆವರಣದಲ್ಲಿ 1 ಕಳೆಯಿರಿ, ಶ್ರೇಣಿಯ ಸಂಖ್ಯೆಗಳನ್ನು ಧನಾತ್ಮಕ ಮತ್ತು ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳಿಗೆ ಎರಡಾಗಿ ವಿಂಗಡಿಸಬೇಕು // ಕೊನೆಯಲ್ಲಿ 1 ಕಳೆಯಿರಿ, ಏಕೆಂದರೆ ಸಂಖ್ಯೆಗಳ ಶ್ರೇಣಿಯು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ // ಡೇಟಾ ಪ್ರಕಾರಗಳು ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಸಹಿ ಮಾಡದ max_val_type = 2^(b * 8) - 1; // ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಮಾತ್ರ // ಸೂತ್ರದ ವಿವರಣೆಗಳು ಹೋಲುತ್ತವೆ, ಘಟಕವನ್ನು ಮಾತ್ರ ಬ್ರಾಕೆಟ್‌ನಿಂದ ಕಳೆಯಲಾಗುವುದಿಲ್ಲ

ಪ್ರೋಗ್ರಾಂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಉದಾಹರಣೆಯನ್ನು ಚಿತ್ರ 3 ರಲ್ಲಿ ಕಾಣಬಹುದು. ಮೊದಲ ಕಾಲಮ್ C++ ನಲ್ಲಿ ಮುಖ್ಯ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ತೋರಿಸುತ್ತದೆ, ಎರಡನೇ ಕಾಲಮ್ ಪ್ರತಿ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಗಾತ್ರವನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ಮೂರನೇ ಕಾಲಮ್ ಅನುಗುಣವಾದ ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು ತೋರಿಸುತ್ತದೆ. ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಕನಿಷ್ಠ ಮೌಲ್ಯವು ಗರಿಷ್ಠಕ್ಕೆ ಹೋಲುತ್ತದೆ. ಸಹಿ ಮಾಡದ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ, ಕನಿಷ್ಠ ಮೌಲ್ಯವು 0 ಆಗಿದೆ.

ಡೇಟಾ ಪ್ರಕಾರದ ಬೈಟ್ ಗರಿಷ್ಠ ಮೌಲ್ಯ bool = 1 255.00 ಚಾರ್ = 1 255.00 ಶಾರ್ಟ್ ಇಂಟ್ = 2 32767.00 ಸಹಿ ಮಾಡದ ಶಾರ್ಟ್ ಇಂಟ್ = 2 65535.00 ಇಂಟ್ = 4 2147483647.00 ಸಹಿ ಮಾಡದ ಇಂಟ್ = 4 2147483647.00 ಇನ್‌ಸೈನ್ಡ್ ಇಂಟ್ = 490 4291 490 429 7.00 ಸಹಿ ಮಾಡದ ಉದ್ದದ ಇಂಟ್ = 4 4294967295.00 ಫ್ಲೋಟ್ = 4 2147483647.00 ಡಬಲ್ = 8 9223372036854775808.00 ಮುಂದುವರೆಯಲು, ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. . .

ಚಿತ್ರ 3 - C++ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಉದಾಹರಣೆಗೆ, ಟೈಪ್ ಶಾರ್ಟ್ ಇಂಟ್‌ನ ವೇರಿಯಬಲ್‌ಗೆ 33000 ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಿದರೆ, ಬಿಟ್ ಗ್ರಿಡ್ ಓವರ್‌ಫ್ಲೋ ಆಗುತ್ತದೆ, ಏಕೆಂದರೆ ಟೈಪ್ ಶಾರ್ಟ್ ಇಂಟ್‌ನ ವೇರಿಯಬಲ್‌ನಲ್ಲಿ ಗರಿಷ್ಠ ಮೌಲ್ಯವು 32767 ಆಗಿರುತ್ತದೆ. ಅಂದರೆ, ಕೆಲವು ಇತರ ಮೌಲ್ಯವನ್ನು ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಸಣ್ಣ ಇಂಟ್ ಪ್ರಕಾರ, ಹೆಚ್ಚಾಗಿ ಇದು ಋಣಾತ್ಮಕವಾಗಿರುತ್ತದೆ. ನಾವು ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸ್ಪರ್ಶಿಸಿರುವುದರಿಂದ, ನೀವು ಇಂಟ್ ಕೀವರ್ಡ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು ಮತ್ತು ಬರೆಯಬಹುದು ಎಂದು ಗಮನಿಸಬೇಕಾದ ಅಂಶವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ಕೇವಲ ಚಿಕ್ಕದು . ಕಂಪೈಲರ್ ಅಂತಹ ನಮೂದನ್ನು ಶಾರ್ಟ್ ಇಂಟ್ ಎಂದು ಅರ್ಥೈಸುತ್ತದೆ. ದೀರ್ಘ ಮತ್ತು ಸಹಿ ಮಾಡದ ಪೂರ್ವಪ್ರತ್ಯಯಗಳಿಗೆ ಇದು ಅನ್ವಯಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

// ಡೇಟಾ ಪ್ರಕಾರದ ಸಂಕ್ಷಿಪ್ತ ರೂಪ ಇಂಟ್ ಶಾರ್ಟ್ a1; // ಶಾರ್ಟ್ ಇಂಟ್ ಲಾಂಗ್ a1 ನಂತೆಯೇ; // ಲಾಂಗ್ ಇಂಟ್ ಸಹಿ ಮಾಡದ a1 ನಂತೆ; // ಸಹಿ ಮಾಡದ ಇಂಟ್ ಅನ್ಸೈನ್ಡ್ ಶಾರ್ಟ್ a1 ನಂತೆಯೇ; // ಸಹಿ ಮಾಡದ ಶಾರ್ಟ್ ಇಂಟ್‌ನಂತೆಯೇ

ಭಾಷಾ ಬೇಸಿಕ್ಸ್

ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಮ್ಯಾನಿಪುಲೇಟ್ ಮಾಡುವ ಡೇಟಾವನ್ನು ಕಂಪ್ಯೂಟರ್‌ನ ಮೆಮೊರಿಯಲ್ಲಿ ಬಿಟ್‌ಗಳ ಅನುಕ್ರಮವಾಗಿ ದಾಖಲಿಸಲಾಗುತ್ತದೆ. ಬಿಟ್ 0 ಅಥವಾ 1 ಎರಡನ್ನೂ ಸಂಗ್ರಹಿಸುವ ಸಾಮರ್ಥ್ಯವಿರುವ ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಯ ಚಿಕ್ಕ ಅಂಶವಾಗಿದೆ. ಭೌತಿಕ ಮಟ್ಟದಲ್ಲಿ, ಇದು ವಿದ್ಯುತ್ ವೋಲ್ಟೇಜ್ಗೆ ಅನುರೂಪವಾಗಿದೆ, ಇದು ನಮಗೆ ತಿಳಿದಿರುವಂತೆ, ಪ್ರಸ್ತುತ ಅಥವಾ ಇಲ್ಲದಿರುವುದು. ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿಯ ವಿಷಯಗಳನ್ನು ನೋಡುವಾಗ, ನಾವು ಈ ರೀತಿಯದನ್ನು ನೋಡುತ್ತೇವೆ:
...

ಅಂತಹ ಅನುಕ್ರಮವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ತುಂಬಾ ಕಷ್ಟ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನಾವು ಅಂತಹ ರಚನೆಯಿಲ್ಲದ ಡೇಟಾವನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ (ಸಾಮಾನ್ಯವಾಗಿ ಹಾರ್ಡ್‌ವೇರ್ ಸಾಧನ ಡ್ರೈವರ್‌ಗಳನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುವಾಗ ಇದರ ಅಗತ್ಯವು ಉದ್ಭವಿಸುತ್ತದೆ). C++ ಬಿಟ್ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯಾಚರಣೆಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. (ನಾವು ಇದನ್ನು ಅಧ್ಯಾಯ 4 ರಲ್ಲಿ ಮಾತನಾಡುತ್ತೇವೆ.)
ವಿಶಿಷ್ಟವಾಗಿ, ಕೆಲವು ರಚನೆಯನ್ನು ಬಿಟ್‌ಗಳ ಅನುಕ್ರಮದ ಮೇಲೆ ಹೇರಲಾಗುತ್ತದೆ, ಬಿಟ್‌ಗಳನ್ನು ಗುಂಪು ಮಾಡಲಾಗುತ್ತದೆ ಬೈಟ್‌ಗಳುಮತ್ತು ಪದಗಳು. ಒಂದು ಬೈಟ್ 8 ಬಿಟ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಪದವು 4 ಬೈಟ್‌ಗಳು ಅಥವಾ 32 ಬಿಟ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ವಿಭಿನ್ನ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಪದದ ವ್ಯಾಖ್ಯಾನವು ವಿಭಿನ್ನವಾಗಿರಬಹುದು. 64-ಬಿಟ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ಪರಿವರ್ತನೆಯು ಈಗ ಪ್ರಾರಂಭವಾಗಿದೆ ಮತ್ತು ಇತ್ತೀಚೆಗೆ 16-ಬಿಟ್ ಪದಗಳನ್ನು ಹೊಂದಿರುವ ವ್ಯವಸ್ಥೆಗಳು ವ್ಯಾಪಕವಾಗಿ ಹರಡಿವೆ. ಬಹುಪಾಲು ಸಿಸ್ಟಮ್‌ಗಳು ಒಂದೇ ಬೈಟ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿದ್ದರೂ, ನಾವು ಇನ್ನೂ ಈ ಪ್ರಮಾಣಗಳನ್ನು ಯಂತ್ರ-ನಿರ್ದಿಷ್ಟ ಎಂದು ಕರೆಯುತ್ತೇವೆ.

ಈಗ ನಾವು ವಿಳಾಸ 1040 ರಲ್ಲಿ ಬೈಟ್ ಅಥವಾ ವಿಳಾಸ 1024 ರಲ್ಲಿ ಒಂದು ಪದದ ಬಗ್ಗೆ ಮಾತನಾಡಬಹುದು ಮತ್ತು ವಿಳಾಸ 1032 ರಲ್ಲಿ ಬೈಟ್ ವಿಳಾಸ 1040 ರಲ್ಲಿ ಬೈಟ್ಗೆ ಸಮನಾಗಿರುವುದಿಲ್ಲ ಎಂದು ಹೇಳಬಹುದು.
ಆದಾಗ್ಯೂ, ಯಾವುದೇ ಬೈಟ್, ಯಾವುದೇ ಯಂತ್ರದ ಪದವು ಏನನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿಲ್ಲ. ಕೆಲವು 8 ಬಿಟ್‌ಗಳ ಅರ್ಥವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೇಗೆ? ಈ ಬೈಟ್‌ನ (ಅಥವಾ ಪದ, ಅಥವಾ ಇತರ ಬಿಟ್‌ಗಳ ಸೆಟ್) ಅರ್ಥವನ್ನು ಅನನ್ಯವಾಗಿ ಅರ್ಥೈಸಲು, ಬೈಟ್ ಪ್ರತಿನಿಧಿಸುವ ಡೇಟಾದ ಪ್ರಕಾರವನ್ನು ನಾವು ತಿಳಿದಿರಬೇಕು.
C++ ಅಂತರ್ನಿರ್ಮಿತ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ: ಅಕ್ಷರ, ಪೂರ್ಣಾಂಕ, ನೈಜ - ಮತ್ತು ಸಂಯೋಜಿತ ಮತ್ತು ವಿಸ್ತೃತ ಪ್ರಕಾರಗಳ ಒಂದು ಸೆಟ್: ತಂತಿಗಳು, ಸರಣಿಗಳು, ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಈ ಡೇಟಾದೊಂದಿಗಿನ ಕ್ರಿಯೆಗಳಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳ ಮೂಲ ಸೆಟ್ ಇದೆ: ಹೋಲಿಕೆ, ಅಂಕಗಣಿತ ಮತ್ತು ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳು. ಟ್ರಾನ್ಸಿಶನ್ ಆಪರೇಟರ್‌ಗಳು, ಲೂಪ್‌ಗಳು ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್‌ಗಳು ಸಹ ಇವೆ. ಸಿ ++ ಭಾಷೆಯ ಈ ಅಂಶಗಳು ಇಟ್ಟಿಗೆಗಳ ಗುಂಪನ್ನು ರೂಪಿಸುತ್ತವೆ, ಇದರಿಂದ ನೀವು ಯಾವುದೇ ಸಂಕೀರ್ಣತೆಯ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಸಿ ++ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವ ಮೊದಲ ಹಂತವು ಪಟ್ಟಿ ಮಾಡಲಾದ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವುದು, ಈ ಪುಸ್ತಕದ ಭಾಗ II ಮೀಸಲಾಗಿರುತ್ತದೆ.
ಅಧ್ಯಾಯ 3 ಅಂತರ್ನಿರ್ಮಿತ ಮತ್ತು ವಿಸ್ತೃತ ಪ್ರಕಾರಗಳ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸುವ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಮುಖ್ಯವಾಗಿ, ಸಹಜವಾಗಿ, ವಿಭಾಗ 2.3 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ವರ್ಗ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಅಧ್ಯಾಯ 4 ಅಭಿವ್ಯಕ್ತಿಗಳು, ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಅವುಗಳ ಆದ್ಯತೆಗಳು ಮತ್ತು ಪ್ರಕಾರ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಅಧ್ಯಾಯ 5 ಭಾಷೆಯ ಸೂಚನೆಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಅಧ್ಯಾಯ 6 C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿ ಮತ್ತು ಕಂಟೇನರ್ ಪ್ರಕಾರದ ವೆಕ್ಟರ್ ಮತ್ತು ಅಸೋಸಿಯೇಟಿವ್ ಅರೇ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.

3. C++ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಈ ಅಧ್ಯಾಯವು ಒಂದು ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ ಅಂತರ್ನಿರ್ಮಿತ, ಅಥವಾ ಪ್ರಾಥಮಿಕ, C++ ಭಾಷೆಯ ಡೇಟಾ ಪ್ರಕಾರಗಳು. ಇದು ವ್ಯಾಖ್ಯಾನದೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಅಕ್ಷರಶಃ, ಉದಾಹರಣೆಗೆ 3.14159 ಅಥವಾ pi, ಮತ್ತು ನಂತರ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸಲಾಗಿದೆ ವೇರಿಯಬಲ್, ಅಥವಾ ವಸ್ತು, ಇದು ಡೇಟಾ ಪ್ರಕಾರಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಸೇರಿರಬೇಕು. ಅಧ್ಯಾಯದ ಉಳಿದ ಭಾಗವನ್ನು ಪ್ರತಿ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ವಿವರವಾದ ವಿವರಣೆಗೆ ಮೀಸಲಿಡಲಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯಿಂದ ಒದಗಿಸಲಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಮತ್ತು ಅರೇಗಳಿಗಾಗಿ ಪಡೆದ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ. ಈ ಪ್ರಕಾರಗಳು ಪ್ರಾಥಮಿಕವಾಗಿಲ್ಲದಿದ್ದರೂ, ನೈಜ C++ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬರೆಯಲು ಅವು ಬಹಳ ಮುಖ್ಯ, ಮತ್ತು ನಾವು ಓದುಗರಿಗೆ ಸಾಧ್ಯವಾದಷ್ಟು ಬೇಗ ಅವುಗಳನ್ನು ಪರಿಚಯಿಸಲು ಬಯಸುತ್ತೇವೆ. ನಾವು ಈ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಕರೆಯುತ್ತೇವೆ ವಿಸ್ತರಣೆಮೂಲ C++ ಪ್ರಕಾರಗಳು.

3.1. ಲಿಟರಲ್ಸ್

C++ ಪೂರ್ಣಾಂಕ ಮತ್ತು ನೈಜ ಸಂಖ್ಯೆಗಳು, ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅಂತರ್ನಿರ್ಮಿತ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಗುಂಪನ್ನು ಹೊಂದಿದೆ, ಹಾಗೆಯೇ ಅಕ್ಷರ ತಂತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುವ “ಕ್ಯಾರೆಕ್ಟರ್ ಅರೇ” ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ. ಚಾರ್ ಪ್ರಕಾರವನ್ನು ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳು ಮತ್ತು ಸಣ್ಣ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಒಂದು ಯಂತ್ರ ಬೈಟ್ ಅನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ. ಸಣ್ಣ, ಇಂಟ್ ಮತ್ತು ಉದ್ದದ ಪ್ರಕಾರಗಳನ್ನು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಈ ಪ್ರಕಾರಗಳು ಸಂಖ್ಯೆಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದಾದ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಮಾತ್ರ ಭಿನ್ನವಾಗಿರುತ್ತವೆ ಮತ್ತು ಪಟ್ಟಿ ಮಾಡಲಾದ ಪ್ರಕಾರಗಳ ನಿರ್ದಿಷ್ಟ ಗಾತ್ರಗಳು ಅನುಷ್ಠಾನವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ ಶಾರ್ಟ್ ಅರ್ಧ ಯಂತ್ರ ಪದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಇಂಟ್ ಒಂದು ಪದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ದೀರ್ಘ ಒಂದು ಅಥವಾ ಎರಡು ಪದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. 32-ಬಿಟ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ, ಇಂಟ್ ಮತ್ತು ಲಾಂಗ್ ಸಾಮಾನ್ಯವಾಗಿ ಒಂದೇ ಗಾತ್ರದಲ್ಲಿರುತ್ತವೆ.

ಫ್ಲೋಟ್, ಡಬಲ್ ಮತ್ತು ಲಾಂಗ್ ಡಬಲ್ ಪ್ರಕಾರಗಳು ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳಿಗೆ ಮತ್ತು ಅವುಗಳ ಪ್ರಾತಿನಿಧ್ಯದ ನಿಖರತೆ (ಗಮನಾರ್ಹ ಅಂಕೆಗಳ ಸಂಖ್ಯೆ) ಮತ್ತು ಶ್ರೇಣಿಯಲ್ಲಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ವಿಶಿಷ್ಟವಾಗಿ, ಫ್ಲೋಟ್ (ಏಕ ನಿಖರತೆ) ಒಂದು ಯಂತ್ರ ಪದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಡಬಲ್ (ಡಬಲ್ ನಿಖರತೆ) ಎರಡು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ದೀರ್ಘ ಡಬಲ್ (ವಿಸ್ತೃತ ನಿಖರತೆ) ಮೂರು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಚಾರ್, ಶಾರ್ಟ್, ಇಂಟ್ ಮತ್ತು ಲಾಂಗ್ ಒಟ್ಟಿಗೆ ಅಪ್ ಮಾಡಿ ಸಂಪೂರ್ಣ ವಿಧಗಳು, ಇದು ಪ್ರತಿಯಾಗಿ, ಆಗಿರಬಹುದು ಸಾಂಪ್ರದಾಯಿಕ(ಸಹಿ) ಮತ್ತು ಸಹಿ ಮಾಡಿಲ್ಲ(ಸಹಿ ಮಾಡದ). ಸಹಿ ಮಾಡಿದ ಪ್ರಕಾರಗಳಲ್ಲಿ, ಎಡಭಾಗದ ಬಿಟ್ ಚಿಹ್ನೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (0 ಪ್ಲಸ್, 1 ಮೈನಸ್), ಮತ್ತು ಉಳಿದ ಬಿಟ್‌ಗಳು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಸಹಿ ಮಾಡದ ಪ್ರಕಾರಗಳಲ್ಲಿ, ಎಲ್ಲಾ ಬಿಟ್‌ಗಳನ್ನು ಮೌಲ್ಯಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. 8-ಬಿಟ್ ಸಹಿ ಮಾಡಿದ ಚಾರ್ -128 ರಿಂದ 127 ರವರೆಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು ಮತ್ತು ಸಹಿ ಮಾಡದ ಚಾರ್ 0 ರಿಂದ 255 ರವರೆಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು.

ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆ, ಉದಾಹರಣೆಗೆ 1, ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಎದುರಾದಾಗ, ಈ ಸಂಖ್ಯೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಅಕ್ಷರಶಃ, ಅಥವಾ ಅಕ್ಷರಶಃ ಸ್ಥಿರ. ನಾವು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲದ ಕಾರಣ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯದಲ್ಲಿ ಅದರ ಮೌಲ್ಯವು ಅಕ್ಷರಶಃ ಗೋಚರಿಸುತ್ತದೆ. ಅಕ್ಷರಶಃ ಒಂದು ಅಡ್ರೆಸ್ ಮಾಡಲಾಗದ ಮೌಲ್ಯವಾಗಿದೆ: ಇದು ಸಹಜವಾಗಿ, ಯಂತ್ರದ ಸ್ಮರಣೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿದ್ದರೂ, ಅದರ ವಿಳಾಸವನ್ನು ತಿಳಿದುಕೊಳ್ಳಲು ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲ. ಪ್ರತಿಯೊಂದು ಅಕ್ಷರಕ್ಕೂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವಿದೆ. ಆದ್ದರಿಂದ, 0 ಇಂಟ್ ಪ್ರಕಾರವಾಗಿದೆ, 3.14159 ಡಬಲ್ ಟೈಪ್ ಆಗಿದೆ.

ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರದ ಅಕ್ಷರಗಳನ್ನು ದಶಮಾಂಶ, ಅಷ್ಟಮ ಮತ್ತು ಹೆಕ್ಸಾಡೆಸಿಮಲ್‌ನಲ್ಲಿ ಬರೆಯಬಹುದು. ದಶಮಾಂಶ, ಅಷ್ಟಮ ಮತ್ತು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಕ್ಷರಗಳಿಂದ ಪ್ರತಿನಿಧಿಸುವ ಸಂಖ್ಯೆ 20 ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

20 // ದಶಮಾಂಶ
024 // ಅಷ್ಟಮ
0x14 // ಹೆಕ್ಸಾಡೆಸಿಮಲ್

ಅಕ್ಷರಶಃ 0 ಯಿಂದ ಪ್ರಾರಂಭವಾದರೆ, ಅದನ್ನು ಆಕ್ಟಲ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, 0x ಅಥವಾ 0X ನೊಂದಿಗೆ, ನಂತರ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯ ಸಂಕೇತವನ್ನು ದಶಮಾಂಶ ಸಂಖ್ಯೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕ ಅಕ್ಷರಗಳು ಸಹಿ ಮಾಡಿದ ಇಂಟ್ ಪ್ರಕಾರವಾಗಿದೆ. ಸಂಖ್ಯೆಯ ಅಂತ್ಯಕ್ಕೆ L ಅಕ್ಷರವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನೀವು ಸಂಪೂರ್ಣ ಅಕ್ಷರಶಃ ಉದ್ದವಾಗಿದೆ ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು (ದೊಡ್ಡಕ್ಷರ L ಮತ್ತು ಲೋವರ್ಕೇಸ್ l ಎರಡನ್ನೂ ಬಳಸಲಾಗುತ್ತದೆ, ಆದರೆ ಸುಲಭವಾಗಿ ಓದಲು ನೀವು ಲೋವರ್ಕೇಸ್ ಅನ್ನು ಬಳಸಬಾರದು: ಇದು ಸುಲಭವಾಗಿ ಗೊಂದಲಕ್ಕೊಳಗಾಗುತ್ತದೆ. ಜೊತೆಗೆ

1) ಕೊನೆಯಲ್ಲಿ U (ಅಥವಾ u) ಅಕ್ಷರವು ಅಕ್ಷರಶಃ ಸಹಿ ಮಾಡದ ಇಂಟ್ ಮತ್ತು ಎರಡು ಅಕ್ಷರಗಳನ್ನು - UL ಅಥವಾ LU - ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಪ್ರಕಾರವಾಗಿ ಗುರುತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

128u 1024UL 1L 8Lu

ನೈಜ ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅಕ್ಷರಗಳನ್ನು ದಶಮಾಂಶ ಬಿಂದು ಅಥವಾ ವೈಜ್ಞಾನಿಕ (ವೈಜ್ಞಾನಿಕ) ಸಂಕೇತಗಳಲ್ಲಿ ಬರೆಯಬಹುದು. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅವು ಡಬಲ್ ಟೈಪ್ ಆಗಿರುತ್ತವೆ. ಫ್ಲೋಟ್ ಪ್ರಕಾರವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಲು, ನೀವು ಎಫ್ ಅಥವಾ ಎಫ್ ಪ್ರತ್ಯಯವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ದೀರ್ಘ ಡಬಲ್ - ಎಲ್ ಅಥವಾ ಎಲ್, ಆದರೆ ದಶಮಾಂಶ ಬಿಂದುವಿನೊಂದಿಗೆ ಬರೆದರೆ ಮಾತ್ರ. ಉದಾಹರಣೆಗೆ:

3.14159F 0/1f 12.345L 0.0 3el 1.0E-3E 2. 1.0L

ನಿಜ ಮತ್ತು ಸುಳ್ಳು ಪದಗಳು ಬೂಲ್ ಲಿಟರಲ್ಸ್.
ಪ್ರತಿನಿಧಿಸಬಹುದಾದ ಅಕ್ಷರಶಃ ಅಕ್ಷರ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಒಂದೇ ಉಲ್ಲೇಖಗಳಲ್ಲಿ ಅಕ್ಷರಗಳಾಗಿ ಬರೆಯಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

"a" "2" "," " " (ಸ್ಪೇಸ್)

ವಿಶೇಷ ಅಕ್ಷರಗಳನ್ನು (ಟ್ಯಾಬ್, ಕ್ಯಾರೇಜ್ ರಿಟರ್ನ್) ಎಸ್ಕೇಪ್ ಸೀಕ್ವೆನ್ಸ್‌ಗಳಾಗಿ ಬರೆಯಲಾಗಿದೆ. ಕೆಳಗಿನ ಅಂತಹ ಅನುಕ್ರಮಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ (ಅವುಗಳು ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಶ್ ಅಕ್ಷರದೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ):

ಹೊಸ ಸಾಲು \n ಸಮತಲ ಟ್ಯಾಬ್ \t ಬ್ಯಾಕ್‌ಸ್ಪೇಸ್ \b ಲಂಬ ಟ್ಯಾಬ್ \v ಕ್ಯಾರೇಜ್ ರಿಟರ್ನ್ \r ಪೇಪರ್ ಫೀಡ್ \f ಕರೆ \a ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್ \\ ಪ್ರಶ್ನೆ \? ಸಿಂಗಲ್ ಕೋಟ್ \" ಡಬಲ್ ಕೋಟ್ \"

ಸಾಮಾನ್ಯ ಪಾರು ಅನುಕ್ರಮವು \ooo ರೂಪವನ್ನು ಹೊಂದಿದೆ, ಇಲ್ಲಿ ooo ಒಂದರಿಂದ ಮೂರು ಅಷ್ಟಮ ಅಂಕೆಗಳಾಗಿರುತ್ತದೆ. ಈ ಸಂಖ್ಯೆ ಅಕ್ಷರ ಸಂಕೇತವಾಗಿದೆ. ASCII ಕೋಡ್ ಬಳಸಿ, ನಾವು ಈ ಕೆಳಗಿನ ಅಕ್ಷರಗಳನ್ನು ಬರೆಯಬಹುದು:

\7 (ಬೆಲ್) \14 (ಹೊಸ ಸಾಲು) \0 (ಶೂನ್ಯ) \062 ("2")

ಅಕ್ಷರ ಅಕ್ಷರವನ್ನು L ನೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ ಮಾಡಬಹುದು (ಉದಾಹರಣೆಗೆ, L"a"), ಅಂದರೆ ವಿಶೇಷ ಪ್ರಕಾರದ wchar_t ಎರಡು-ಬೈಟ್ ಅಕ್ಷರ ಪ್ರಕಾರವಾಗಿದ್ದು, ಇದನ್ನು ಸಾಮಾನ್ಯ ಚಾರ್ ಪ್ರಕಾರದಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗದಿದ್ದರೆ ರಾಷ್ಟ್ರೀಯ ವರ್ಣಮಾಲೆಗಳಿಂದ ಅಕ್ಷರಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. , ಉದಾಹರಣೆಗೆ ಚೈನೀಸ್ ಅಥವಾ ಜಪಾನೀಸ್ ಅಕ್ಷರಗಳು.
ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಎನ್ನುವುದು ಡಬಲ್ ಕೋಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿದ ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ. ಅಂತಹ ಅಕ್ಷರಶಃ ಹಲವಾರು ಸಾಲುಗಳನ್ನು ವ್ಯಾಪಿಸಬಹುದು; ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಾಲಿನ ಕೊನೆಯಲ್ಲಿ ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್ ಅನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ. ವಿಶೇಷ ಪಾತ್ರಗಳನ್ನು ತಮ್ಮದೇ ಆದ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಅನುಕ್ರಮಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದು. ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

"" (ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್) "a" "\nCC\toptions\tfile.\n" "ಬಹು-ಸಾಲಿನ \ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ಅದರ \ ಮುಂದುವರಿಕೆಯನ್ನು ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್‌ನೊಂದಿಗೆ ಸಂಕೇತಿಸುತ್ತದೆ"

ವಾಸ್ತವವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ಅಕ್ಷರ ಸ್ಥಿರಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ, ಅಲ್ಲಿ, C ಮತ್ತು C++ ಭಾಷೆಗಳ ಸಂಪ್ರದಾಯದ ಮೂಲಕ, ಕೊನೆಯ ಅಂಶವು ಯಾವಾಗಲೂ ಕೋಡ್ 0 (\0) ನೊಂದಿಗೆ ವಿಶೇಷ ಅಕ್ಷರವಾಗಿರುತ್ತದೆ.
ಅಕ್ಷರಶಃ "A" ಒಂದು ಏಕ ಅಕ್ಷರವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ "A" ಎರಡು ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ: "A" ಮತ್ತು \0 (ಖಾಲಿ ಅಕ್ಷರ).
ಒಂದು ರೀತಿಯ wchar_t ಇರುವುದರಿಂದ, ಈ ಪ್ರಕಾರದ ಅಕ್ಷರಗಳು ಸಹ ಇವೆ, ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಪೂರ್ವಪ್ರತ್ಯಯ L ನಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ:

ಎಲ್" ವಿಶಾಲವಾದ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ"

wchar_t ಪ್ರಕಾರದ ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್ ಒಂದೇ ಪ್ರಕಾರದ ಅಕ್ಷರಗಳ ಶೂನ್ಯ-ಮುಕ್ತಾಯದ ಸರಣಿಯಾಗಿದೆ.
ಪ್ರೋಗ್ರಾಂ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳು (ಚಾರ್ ಅಥವಾ wchar_t ನಂತಹ) ಸಾಲಾಗಿ ಕಾಣಿಸಿಕೊಂಡರೆ, ಕಂಪೈಲರ್ ಅವುಗಳನ್ನು ಒಂದು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಪಠ್ಯ

"ಎರಡು" "ಕೆಲವು"

ಎಂಟು ಅಕ್ಷರಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ - ಎರಡು ಮತ್ತು ಅಂತ್ಯಗೊಳ್ಳುವ ಶೂನ್ಯ ಅಕ್ಷರ. ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳ ತಂತಿಗಳನ್ನು ಜೋಡಿಸುವ ಫಲಿತಾಂಶವನ್ನು ವಿವರಿಸಲಾಗಿಲ್ಲ. ನೀವು ಬರೆದರೆ:

// ಇದು ಒಳ್ಳೆಯ ವಿಚಾರವಲ್ಲ "ಎರಡು" L"ಕೆಲವು"

ಒಂದು ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಫಲಿತಾಂಶವು ಕೆಲವು ಅರ್ಥಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಇನ್ನೊಂದರಲ್ಲಿ ಅದು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನವಾಗಿರಬಹುದು. ನಿರ್ದಿಷ್ಟ ಕಂಪೈಲರ್ ಅಥವಾ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನ ಅನುಷ್ಠಾನದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸುವ ಪ್ರೋಗ್ರಾಂಗಳು ಪೋರ್ಟಬಲ್ ಆಗಿರುವುದಿಲ್ಲ. ಅಂತಹ ರಚನೆಗಳ ಬಳಕೆಯನ್ನು ನಾವು ಬಲವಾಗಿ ವಿರೋಧಿಸುತ್ತೇವೆ.

ವ್ಯಾಯಾಮ 3.1

ಕೆಳಗಿನ ಅಕ್ಷರಗಳ ವ್ಯಾಖ್ಯಾನಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸಿ:

(a) "a", L"a", "a", L"a" (b) 10, 10u, 10L, 10uL, 012, 0*C (c) 3.14, 3.14f, 3.14L

ವ್ಯಾಯಾಮ 3.2

ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಯಾವ ತಪ್ಪುಗಳನ್ನು ಮಾಡಲಾಗಿದೆ?

(ಎ) "F\144rgus ಜೊತೆಗೆ ಯಾರು ಹೋಗುತ್ತಾರೆ?\014" (b) 3.14e1L (c) "ಎರಡು" L"ಕೆಲವು" (d) 1024f (e) 3.14UL (f) "ಬಹು ಸಾಲಿನ ಕಾಮೆಂಟ್"

3.2. ಅಸ್ಥಿರ

2 ಅನ್ನು 10 ರ ಶಕ್ತಿಗೆ ಏರಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ನಾವು ಪರಿಹರಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ. ನಾವು ಬರೆಯುತ್ತೇವೆ:

#ಸೇರಿಸು
ಇಂಟ್ ಮುಖ್ಯ() (
// ಮೊದಲ ಪರಿಹಾರ
ಕೌಟ್<< "2 raised to the power of 10: ";
ಕೌಟ್<< 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
ಕೌಟ್<< endl;
ಹಿಂತಿರುಗಿ 0;
}

ಅಕ್ಷರಶಃ 2 ವಾಸ್ತವವಾಗಿ 10 ಬಾರಿ ಪುನರಾವರ್ತನೆಯಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪದೇ ಪದೇ ಪರಿಶೀಲಿಸಬೇಕಾಗಿದ್ದರೂ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ. ಈ ದೀರ್ಘ ಸರಣಿಯ ಎರಡನ್ನು ಬರೆಯುವಲ್ಲಿ ನಾವು ತಪ್ಪು ಮಾಡಲಿಲ್ಲ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಸರಿಯಾದ ಫಲಿತಾಂಶವನ್ನು ನೀಡಿತು - 1024.
ಆದರೆ ಈಗ ನಾವು 2 ಅನ್ನು 17 ನೇ ಪವರ್‌ಗೆ ಮತ್ತು ನಂತರ 23 ನೇ ಪವರ್‌ಗೆ ಹೆಚ್ಚಿಸಲು ಕೇಳಿದ್ದೇವೆ. ಪ್ರತಿ ಬಾರಿ ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯವನ್ನು ಮಾರ್ಪಡಿಸಲು ಇದು ಅತ್ಯಂತ ಅನಾನುಕೂಲವಾಗಿದೆ! ಮತ್ತು, ಇನ್ನೂ ಕೆಟ್ಟದಾಗಿ, ಹೆಚ್ಚುವರಿ ಎರಡನ್ನು ಬರೆಯುವ ಮೂಲಕ ಅಥವಾ ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುವ ಮೂಲಕ ತಪ್ಪು ಮಾಡುವುದು ತುಂಬಾ ಸುಲಭ ... ಆದರೆ ನೀವು 0 ರಿಂದ 15 ರ ಎರಡು ಶಕ್ತಿಗಳ ಟೇಬಲ್ ಅನ್ನು ಮುದ್ರಿಸಬೇಕಾದರೆ ಏನು ಮಾಡಬೇಕು? ಸಾಮಾನ್ಯ ರೂಪವನ್ನು ಹೊಂದಿರುವ ಎರಡು ಸಾಲುಗಳನ್ನು 16 ಬಾರಿ ಪುನರಾವರ್ತಿಸಿ:

ಕೌಟ್<< "2 в степени X\t"; cout << 2 * ... * 2;

ಅಲ್ಲಿ X ಅನ್ನು ಅನುಕ್ರಮವಾಗಿ 1 ರಿಂದ ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯನ್ನು ದಶಮಾಂಶಕ್ಕೆ ಬದಲಿಸಲಾಗುತ್ತದೆ?

ಹೌದು, ನಾವು ಕಾರ್ಯವನ್ನು ನಿಭಾಯಿಸಿದ್ದೇವೆ. ಗ್ರಾಹಕರು ವಿವರಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ, ಪಡೆದ ಫಲಿತಾಂಶದಿಂದ ತೃಪ್ತರಾಗಿದ್ದಾರೆ. ನಿಜ ಜೀವನದಲ್ಲಿ, ಈ ವಿಧಾನವು ಹೆಚ್ಚಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ; ಮೇಲಾಗಿ, ಇದು ಸಮರ್ಥನೆಯಾಗಿದೆ: ಸಮಸ್ಯೆಯನ್ನು ಸೊಗಸಾದ ರೀತಿಯಲ್ಲಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಅಪೇಕ್ಷಿತ ಸಮಯದ ಚೌಕಟ್ಟಿನಲ್ಲಿ. ಹೆಚ್ಚು ಸುಂದರವಾದ ಮತ್ತು ಸಮರ್ಥ ಆಯ್ಕೆಯನ್ನು ಹುಡುಕುವುದು ಸಮಯದ ಅಪ್ರಾಯೋಗಿಕ ವ್ಯರ್ಥವಾಗಬಹುದು.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, "ಬ್ರೂಟ್ ಫೋರ್ಸ್ ವಿಧಾನ" ಸರಿಯಾದ ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ ಈ ರೀತಿಯಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಎಷ್ಟು ಅಹಿತಕರ ಮತ್ತು ನೀರಸವಾಗಿದೆ! ಯಾವ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ಈ ಹಂತಗಳು ಸರಳ ಮತ್ತು ಏಕತಾನತೆಯಿಂದ ಕೂಡಿರುತ್ತವೆ.

ಅದೇ ಕಾರ್ಯಕ್ಕಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ನಿಯಮದಂತೆ, ಪೂರ್ವಸಿದ್ಧತಾ ಹಂತದ ಸಮಯವನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಇದರ ಜೊತೆಗೆ, ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ದೋಷಗಳ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆ. ಆದರೆ ಅನಿವಾರ್ಯ ತಪ್ಪುಗಳು ಮತ್ತು ತಪ್ಪು ಚಲನೆಗಳ ಹೊರತಾಗಿಯೂ, "ಉನ್ನತ ತಂತ್ರಜ್ಞಾನಗಳ" ಬಳಕೆಯು ಅಭಿವೃದ್ಧಿಯ ವೇಗದಲ್ಲಿ ಪ್ರಯೋಜನಗಳನ್ನು ತರಬಹುದು, ಈ ತಂತ್ರಜ್ಞಾನಗಳು ನಮ್ಮ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವಿಸ್ತರಿಸುತ್ತವೆ ಎಂಬ ಅಂಶವನ್ನು ನಮೂದಿಸಬಾರದು. ಮತ್ತು - ಆಸಕ್ತಿದಾಯಕ ಏನು! - ನಿರ್ಧಾರ ಪ್ರಕ್ರಿಯೆಯು ಆಕರ್ಷಕವಾಗಬಹುದು.
ನಮ್ಮ ಉದಾಹರಣೆಗೆ ಹಿಂತಿರುಗಿ ಮತ್ತು ಅದರ ಅನುಷ್ಠಾನವನ್ನು "ತಾಂತ್ರಿಕವಾಗಿ ಸುಧಾರಿಸಲು" ಪ್ರಯತ್ನಿಸೋಣ. ನಾವು ನಮ್ಮ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಬಯಸುವ ಶಕ್ತಿಯ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ಹೆಸರಿಸಲಾದ ವಸ್ತುವನ್ನು ಬಳಸಬಹುದು. ಜೊತೆಗೆ, ಅಕ್ಷರಗಳ ಪುನರಾವರ್ತಿತ ಅನುಕ್ರಮದ ಬದಲಿಗೆ, ಲೂಪ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು. ಇದು ಈ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ:

#ಸೇರಿಸು
ಇಂಟ್ ಮುಖ್ಯ()
{
// ಇಂಟ್ ಪ್ರಕಾರದ ವಸ್ತುಗಳು
ಇಂಟ್ ಮೌಲ್ಯ = 2;
ಇಂಟ್ ಪೌ = 10;
ಕೌಟ್<< value << " в степени "
<< pow << ": \t";
ಇಂಟ್ ರೆಸ್ = 1;
// ಲೂಪ್ ಆಪರೇಟರ್:
// ಪುನರಾವರ್ತಿತ ರೆಸ್ ಲೆಕ್ಕಾಚಾರ
// cnt ಪೌಗಿಂತ ದೊಡ್ಡದಾಗುವವರೆಗೆ
ಫಾರ್ (int cnt=1; cnt<= pow; ++cnt)
ರೆಸ್ = ರೆಸ್ * ಮೌಲ್ಯ;
ಕೌಟ್<< res << endl;
}

ಮೌಲ್ಯ, ಪೌ, ರೆಸ್ ಮತ್ತು ಸಿಎನ್‌ಟಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಅಸ್ಥಿರಗಳಾಗಿವೆ. ಫಾರ್ ಲೂಪ್ ಹೇಳಿಕೆಯು ಫಲಿತಾಂಶದ ಸಾಲಿನ ಪೌ ಸಮಯವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
ನಾವು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ ಎಂಬುದರಲ್ಲಿ ಸಂದೇಹವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಇದು ಇನ್ನೂ ಕಾರ್ಯವಾಗಿಲ್ಲ. ಸಂಖ್ಯೆಯ ಶಕ್ತಿಯನ್ನು ಲೆಕ್ಕಹಾಕಲು ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬಳಸಬಹುದಾದ ನೈಜ ಕಾರ್ಯವನ್ನು ಪಡೆಯಲು, ನೀವು ಲೆಕ್ಕಾಚಾರಗಳ ಸಾಮಾನ್ಯ ಭಾಗವನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಹೊಂದಿಸಿ.

ಇಂಟ್ ಪೌ (ಇಂಟ್ ವಾಲ್, ಇಂಟ್ ಎಕ್ಸ್) (ಇಂಟ್ ರೆಸ್ = 1; ಎಕ್ಸ್‌ಪ್ > 0; --ಎಕ್ಸ್‌ಪಿ) ರೆಸ್ = ರೆಸ್ * ವ್ಯಾಲ್; ರಿಟರ್ನ್ ರೆಸ್; )

ಈಗ ಅಪೇಕ್ಷಿತ ಸಂಖ್ಯೆಯ ಯಾವುದೇ ಶಕ್ತಿಯನ್ನು ಪಡೆಯುವುದು ಕಷ್ಟವಾಗುವುದಿಲ್ಲ. ನಮ್ಮ ಕೊನೆಯ ಕಾರ್ಯವನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ - 0 ರಿಂದ 15 ರವರೆಗಿನ ಎರಡು ಶಕ್ತಿಗಳ ಕೋಷ್ಟಕವನ್ನು ಮುದ್ರಿಸಿ:

#ಸೇರಿಸು ಬಾಹ್ಯ ಇಂಟ್ ಪೌ (ಇಂಟ್, ಇಂಟ್); int main() ( int val = 2; int exp = 15;
ಕೌಟ್<< "Степени 2\n";
ಫಾರ್ (int cnt=0; cnt<= exp; ++cnt)
ಕೌಟ್<< cnt << ": "
<< pow(val, cnt) << endl;
ಹಿಂತಿರುಗಿ 0;
}

ಸಹಜವಾಗಿ, ನಮ್ಮ ಪೌ() ಕಾರ್ಯವು ಇನ್ನೂ ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿಲ್ಲ ಮತ್ತು ಸಾಕಷ್ಟು ದೃಢವಾಗಿಲ್ಲ. ಇದು ನೈಜ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಇದು ತಪ್ಪಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು ಋಣಾತ್ಮಕ ಶಕ್ತಿಗೆ ಹೆಚ್ಚಿಸುತ್ತದೆ - ಇದು ಯಾವಾಗಲೂ 1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿನ ಶಕ್ತಿಗೆ ಹೆಚ್ಚಿಸುವ ಫಲಿತಾಂಶವು ಇಂಟ್ ವೇರಿಯೇಬಲ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ, ಮತ್ತು ನಂತರ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ತಪ್ಪಾದ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ವ್ಯಾಪಕ ಬಳಕೆಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವುದು ಎಷ್ಟು ಕಷ್ಟಕರವಾಗಿದೆ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಾ? ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿರುವ ನಿರ್ದಿಷ್ಟ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕಷ್ಟ.

3.2.1. ವೇರಿಯೇಬಲ್ ಎಂದರೇನು

ವೇರಿಯಬಲ್, ಅಥವಾ ಒಂದು ವಸ್ತು- ಇದು ನಾವು ಪ್ರೋಗ್ರಾಂನಿಂದ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವ ಮೆಮೊರಿಯ ಹೆಸರಿಸಲಾದ ಪ್ರದೇಶವಾಗಿದೆ; ನೀವು ಅಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಹಾಕಬಹುದು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಹಿಂಪಡೆಯಬಹುದು. ಪ್ರತಿಯೊಂದು C++ ವೇರಿಯೇಬಲ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ, ಅದು ಆ ಮೆಮೊರಿ ಸ್ಥಳದ ಗಾತ್ರ ಮತ್ತು ಸ್ಥಳ, ಅದು ಸಂಗ್ರಹಿಸಬಹುದಾದ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿ ಮತ್ತು ಆ ವೇರಿಯೇಬಲ್‌ಗೆ ಅನ್ವಯಿಸಬಹುದಾದ ಕಾರ್ಯಾಚರಣೆಗಳ ಸೆಟ್ ಅನ್ನು ನಿರೂಪಿಸುತ್ತದೆ. ವಿವಿಧ ರೀತಿಯ ಐದು ವಸ್ತುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ಇಂಟ್ ವಿದ್ಯಾರ್ಥಿ_ಎಣಿಕೆ; ಡಬಲ್ ಸಂಬಳ; ಬೂಲ್ ಆನ್_ಲೋನ್; ಸ್ಟ್ರಿನ್ಸ್ ಸ್ಟ್ರೀಟ್_ವಿಳಾಸ; ಚಾರ್ ಡಿಲಿಮಿಟರ್;

ವೇರಿಯೇಬಲ್, ಅಕ್ಷರಶಃ, ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಕೆಲವು ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ವಿಳಾಸ ಸಾಮರ್ಥ್ಯ- ಅದು ಅಕ್ಷರಶಃ ಕೊರತೆಯಾಗಿದೆ. ವೇರಿಯೇಬಲ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಎರಡು ಪ್ರಮಾಣಗಳಿವೆ:

• ನಿಜವಾದ ಮೌಲ್ಯ, ಅಥವಾ r-ಮೌಲ್ಯ (ಓದಲು ಮೌಲ್ಯದಿಂದ - ಓದಲು ಮೌಲ್ಯ), ಈ ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮತ್ತು ವೇರಿಯೇಬಲ್ ಮತ್ತು ಅಕ್ಷರಶಃ ಎರಡರಲ್ಲೂ ಅಂತರ್ಗತವಾಗಿರುತ್ತದೆ;
• ವೇರಿಯೇಬಲ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಮೆಮೊರಿ ಪ್ರದೇಶದ ವಿಳಾಸ ಮೌಲ್ಯ, ಅಥವಾ ಎಲ್-ಮೌಲ್ಯ (ಸ್ಥಳ ಮೌಲ್ಯದಿಂದ) - ಆರ್-ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲಾದ ಸ್ಥಳ; ವಸ್ತುವಿನಲ್ಲಿ ಮಾತ್ರ ಅಂತರ್ಗತವಾಗಿರುತ್ತದೆ.

ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ

Ch = ch - "0";

ವೇರಿಯೇಬಲ್ ch ನಿಯೋಜನೆ ಚಿಹ್ನೆಯ ಎಡ ಮತ್ತು ಬಲಕ್ಕೆ ಎರಡೂ ಇದೆ. ಬಲಭಾಗದಲ್ಲಿ ಓದಲು ಮೌಲ್ಯವಿದೆ (ch ಮತ್ತು ಅಕ್ಷರ ಅಕ್ಷರಶಃ "0"): ವೇರಿಯೇಬಲ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಡೇಟಾವನ್ನು ಅನುಗುಣವಾದ ಮೆಮೊರಿ ಪ್ರದೇಶದಿಂದ ಓದಲಾಗುತ್ತದೆ. ಎಡಭಾಗದಲ್ಲಿ ಸ್ಥಳ ಮೌಲ್ಯವಿದೆ: ವ್ಯವಕಲನದ ಫಲಿತಾಂಶವನ್ನು ವೇರಿಯಬಲ್ ch ಗೆ ಸಂಬಂಧಿಸಿದ ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಯ ಎಡಭಾಗವು ಎಲ್-ಮೌಲ್ಯವಾಗಿರಬೇಕು. ನಾವು ಈ ಕೆಳಗಿನ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ:

// ಸಂಕಲನ ದೋಷಗಳು: ಎಡಭಾಗದಲ್ಲಿರುವ ಮೌಲ್ಯಗಳು ಎಲ್-ಮೌಲ್ಯಗಳಲ್ಲ // ದೋಷ: ಅಕ್ಷರಶಃ ಎಲ್-ಮೌಲ್ಯ 0 = 1 ಅಲ್ಲ; // ದೋಷ: ಅಂಕಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಯು ಎಲ್-ಮೌಲ್ಯದ ಸಂಬಳವಲ್ಲ + ಸಂಬಳ * 0.10 = ಹೊಸ_ಸಂಬಳ;

ವೇರಿಯಬಲ್ ಡೆಫಿನಿಷನ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಅದಕ್ಕೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ. ಒಂದು ವಸ್ತುವು ಅದರೊಂದಿಗೆ ಕೇವಲ ಒಂದು ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಅಂತಹ ಹೇಳಿಕೆಯು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಒಮ್ಮೆ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಒಂದು ಮೂಲ ಫೈಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವೇರಿಯಬಲ್ ಅನ್ನು ಇನ್ನೊಂದರಲ್ಲಿ ಬಳಸಬೇಕಾದರೆ, ಸಮಸ್ಯೆಗಳು ಉದ್ಭವಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ:

// file module0.C // ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್ ನೇಮ್ ಸ್ಟ್ರಿಂಗ್ ಫೈಲ್ ನೇಮ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ; // ... ಫೈಲ್ ಹೆಸರಿಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿ
// ಫೈಲ್ ಮಾಡ್ಯೂಲ್1.ಸಿ
// ಫೈಲ್ ನೇಮ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ
// ಅಯ್ಯೋ, ಕಂಪೈಲ್ ಮಾಡುವುದಿಲ್ಲ:
// ಫೈಲ್ ಹೆಸರನ್ನು ಮಾಡ್ಯೂಲ್ 1.ಸಿ ಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ
ifstream input_file(fileName);

C++ ಗೆ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಮೊದಲು ಪ್ರವೇಶಿಸುವ ಮೊದಲು ಅದನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ವಸ್ತುವನ್ನು ಅದರ ಪ್ರಕಾರಕ್ಕೆ ಸರಿಯಾಗಿ ಬಳಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, module1.C ಕಂಪೈಲೇಶನ್ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ ಏಕೆಂದರೆ ಅದರಲ್ಲಿ ಫೈಲ್ ನೇಮ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ. ಈ ದೋಷವನ್ನು ತಪ್ಪಿಸಲು, ನಾವು ಈಗಾಗಲೇ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಫೈಲ್ ನೇಮ್ ವೇರಿಯೇಬಲ್ ಬಗ್ಗೆ ಕಂಪೈಲರ್ಗೆ ಹೇಳಬೇಕು. ವೇರಿಯಬಲ್ ಡಿಕ್ಲರೇಶನ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಬಳಸಿ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ:

// ಫೈಲ್ ಮಾಡ್ಯೂಲ್ 1. ಸಿ // ಫೈಲ್ ನೇಮ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ // ಫೈಲ್ ನೇಮ್ ಅನ್ನು ಘೋಷಿಸಲಾಗಿದೆ, ಅಂದರೆ ಪ್ರೋಗ್ರಾಂ ಸ್ವೀಕರಿಸುತ್ತದೆ
// ಈ ವಸ್ತುವಿನ ಬಗ್ಗೆ ಅದರ ದ್ವಿತೀಯ ವ್ಯಾಖ್ಯಾನವಿಲ್ಲದೆ ಮಾಹಿತಿ
ಬಾಹ್ಯ ಸ್ಟ್ರಿಂಗ್ ಫೈಲ್ ಹೆಸರು; ifstream input_file(fileName)

ವೇರಿಯಬಲ್ ಘೋಷಣೆಯು ಕಂಪೈಲರ್‌ಗೆ ನಿರ್ದಿಷ್ಟ ಹೆಸರಿನೊಂದಿಗೆ, ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ವಸ್ತುವನ್ನು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಎಲ್ಲೋ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ. ಡಿಕ್ಲೇರ್ ಮಾಡಿದಾಗ ವೇರಿಯೇಬಲ್‌ಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ. (ಬಾಹ್ಯ ಕೀವರ್ಡ್ ಅನ್ನು ವಿಭಾಗ 8.2 ರಲ್ಲಿ ಒಳಗೊಂಡಿದೆ.)
ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅದೇ ವೇರಿಯಬಲ್‌ನ ಹಲವು ಘೋಷಣೆಗಳನ್ನು ಅದು ಇಷ್ಟಪಡುವಷ್ಟು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಅದನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಅಂತಹ ಘೋಷಣೆಗಳನ್ನು ಹೆಡರ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಇರಿಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ, ಅವುಗಳು ಅಗತ್ಯವಿರುವ ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ಸೇರಿವೆ. ಈ ರೀತಿಯಾಗಿ ನಾವು ವಸ್ತುಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ ಅದನ್ನು ಸುಲಭವಾಗಿ ಮಾರ್ಪಡಿಸಬಹುದು. (ನಾವು ವಿಭಾಗ 8.2 ರಲ್ಲಿ ಹೆಡರ್ ಫೈಲ್‌ಗಳ ಕುರಿತು ಹೆಚ್ಚು ಮಾತನಾಡುತ್ತೇವೆ.)

3.2.2. ವೇರಿಯಬಲ್ ಹೆಸರು

ವೇರಿಯಬಲ್ ಹೆಸರು, ಅಥವಾ ಗುರುತಿಸುವಿಕೆ, ಲ್ಯಾಟಿನ್ ಅಕ್ಷರಗಳು, ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಅಂಡರ್ಸ್ಕೋರ್ ಅಕ್ಷರವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಹೆಸರುಗಳಲ್ಲಿನ ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಸಣ್ಣ ಅಕ್ಷರಗಳು ವಿಭಿನ್ನವಾಗಿವೆ. C++ ಭಾಷೆಯು ಗುರುತಿಸುವಿಕೆಯ ಉದ್ದವನ್ನು ಮಿತಿಗೊಳಿಸುವುದಿಲ್ಲ, ಆದರೆ gosh_this_is_an_impossibly_name_to_type ನಂತಹ ಉದ್ದವಾದ ಹೆಸರುಗಳನ್ನು ಬಳಸುವುದು ಅನಾನುಕೂಲವಾಗಿದೆ.
ಕೆಲವು ಪದಗಳು C++ ನಲ್ಲಿ ಕೀವರ್ಡ್‌ಗಳಾಗಿವೆ ಮತ್ತು ಗುರುತಿಸುವಿಕೆಗಳಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ; ಕೋಷ್ಟಕ 3.1 ಅವುಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಕೋಷ್ಟಕ 3.1. C++ ಕೀವರ್ಡ್‌ಗಳು

asm	ಸ್ವಯಂ	ಬೂಲ್	ಬ್ರೇಕ್	ಪ್ರಕರಣ
ಹಿಡಿಯಿರಿ	ಚಾರ್	ವರ್ಗ	ಸ್ಥಿರ	const_cast
ಮುಂದುವರಿಸಿ	ಪೂರ್ವನಿಯೋಜಿತ	ಅಳಿಸಿ	ಮಾಡು	ದುಪ್ಪಟ್ಟು
ಡೈನಾಮಿಕ್_ಕಾಸ್ಟ್	ಬೇರೆ	enum	ಸ್ಪಷ್ಟ	ರಫ್ತು
ಬಾಹ್ಯ	ಸುಳ್ಳು	ತೇಲುತ್ತವೆ	ಫಾರ್	ಸ್ನೇಹಿತ
ಗೊಟೊ	ಒಂದು ವೇಳೆ	ಸಾಲಿನಲ್ಲಿ	ಇಂಟ್	ಉದ್ದವಾಗಿದೆ
ಬದಲಾಗಬಲ್ಲ	ನಾಮಸ್ಥಳ	ಹೊಸ	ಆಪರೇಟರ್	ಖಾಸಗಿ
ರಕ್ಷಿಸಲಾಗಿದೆ	ಸಾರ್ವಜನಿಕ	ನೋಂದಣಿ	ಮರುವ್ಯಾಖ್ಯಾನ_ಕಾಸ್ಟ್	ಹಿಂತಿರುಗಿ
ಚಿಕ್ಕದಾಗಿದೆ	ಸಹಿ	ಗಾತ್ರ	ಸ್ಥಿರ	ಸ್ಥಿರ_ಕಾಸ್ಟ್
ರಚನೆ	ಸ್ವಿಚ್	ಟೆಂಪ್ಲೇಟ್	ಇದು	ಎಸೆಯಿರಿ
ಟೈಪ್ಡೆಫ್	ನಿಜ	ಪ್ರಯತ್ನಿಸಿ	ಟೈಪಿಡ್	ಟೈಪ್ ಹೆಸರು
ಒಕ್ಕೂಟ	ಶೂನ್ಯ ಒಕ್ಕೂಟ	ಬಳಸಿ	ವಾಸ್ತವ	ಶೂನ್ಯ

ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೆಚ್ಚು ಅರ್ಥವಾಗುವಂತೆ ಮಾಡಲು, ಸಾಮಾನ್ಯವಾಗಿ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ವಸ್ತುವಿನ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯಗಳನ್ನು ಅನುಸರಿಸಲು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ:

• ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಣ್ಣ ಅಕ್ಷರಗಳಲ್ಲಿ ಬರೆಯಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಸೂಚ್ಯಂಕ (ಹೋಲಿಕೆಗಾಗಿ: ಸೂಚ್ಯಂಕವು ಪ್ರಕಾರದ ಹೆಸರು, ಮತ್ತು INDEX ಎನ್ನುವುದು #ಡಿಫೈನ್ ಪ್ರಿಪ್ರೊಸೆಸರ್ ನಿರ್ದೇಶನವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ);
• ಗುರುತಿಸುವಿಕೆಯು ಕೆಲವು ಅರ್ಥವನ್ನು ಹೊಂದಿರಬೇಕು, ಪ್ರೋಗ್ರಾಂನಲ್ಲಿನ ವಸ್ತುವಿನ ಉದ್ದೇಶವನ್ನು ವಿವರಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ: ಜನ್ಮ_ದಿನಾಂಕ ಅಥವಾ ಸಂಬಳ;

ಅಂತಹ ಹೆಸರು ಜನ್ಮ_ದಿನಾಂಕದಂತಹ ಹಲವಾರು ಪದಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಪದಗಳನ್ನು ಅಂಡರ್ಸ್ಕೋರ್ (ಜನ್ಮ_ದಿನಾಂಕ) ನೊಂದಿಗೆ ಪ್ರತ್ಯೇಕಿಸುವುದು ಅಥವಾ ಪ್ರತಿ ನಂತರದ ಪದವನ್ನು ದೊಡ್ಡ ಅಕ್ಷರದೊಂದಿಗೆ (ಜನ್ಮದಿನಾಂಕ) ಬರೆಯುವುದು ವಾಡಿಕೆ. ಆಬ್ಜೆಕ್ಟ್ ಓರಿಯೆಂಟೆಡ್ ಅಪ್ರೋಚ್‌ಗೆ ಒಗ್ಗಿಕೊಂಡಿರುವ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ದೊಡ್ಡ ಅಕ್ಷರಗಳಲ್ಲಿ ಪದಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡಲು ಬಯಸುತ್ತಾರೆ ಎಂದು ಗಮನಿಸಲಾಗಿದೆ, ಆದರೆ_ಹೆಚ್ಚು_ಇನ್_ಸಿ_ಬರೆದಿರುವವರು ಅಂಡರ್‌ಸ್ಕೋರ್ ಅಕ್ಷರವನ್ನು ಬಳಸುತ್ತಾರೆ. ಎರಡು ವಿಧಾನಗಳಲ್ಲಿ ಯಾವುದು ಉತ್ತಮ ಎಂಬುದು ರುಚಿಯ ವಿಷಯವಾಗಿದೆ.

3.2.3. ವಸ್ತುವಿನ ವ್ಯಾಖ್ಯಾನ

ಅದರ ಸರಳ ಸಂದರ್ಭದಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ಡೆಫಿನಿಷನ್ ಆಪರೇಟರ್ ಒಳಗೊಂಡಿದೆ ಟೈಪ್ ಸ್ಪೆಸಿಫೈಯರ್ಮತ್ತು ವಸ್ತುವಿನ ಹೆಸರುಮತ್ತು ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಡಬಲ್ ಸಂಬಳ ಡಬಲ್ ವೇತನ; ಇಂಟ್ ತಿಂಗಳು; ಇಂಟ್ ದಿನ; ಇಂಟ್ ವರ್ಷ; ಸಹಿ ಮಾಡದ ದೂರದ;

ಒಂದು ಹೇಳಿಕೆಯಲ್ಲಿ ನೀವು ಒಂದೇ ರೀತಿಯ ಅನೇಕ ವಸ್ತುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರ ಹೆಸರುಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ:

ಡಬಲ್ ಸಂಬಳ, ವೇತನ; ಇಂಟ್ ತಿಂಗಳು, ದಿನ, ವರ್ಷ; ಸಹಿ ಮಾಡದ ದೂರದ;

ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸರಳವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ನೀಡುವುದಿಲ್ಲ. ಒಂದು ವಸ್ತುವನ್ನು ಜಾಗತಿಕ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, C++ ವಿವರಣೆಯು ಅದನ್ನು ಶೂನ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗುವುದು ಎಂದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ವೇರಿಯೇಬಲ್ ಸ್ಥಳೀಯ ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹಂಚಿಕೆಯಾಗಿದ್ದರೆ (ಹೊಸ ಆಪರೇಟರ್ ಬಳಸಿ), ಅದರ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ವಿವರಿಸಲಾಗಿಲ್ಲ, ಅಂದರೆ, ಇದು ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರಬಹುದು.
ಅಂತಹ ಅಸ್ಥಿರಗಳ ಬಳಕೆಯು ತುಂಬಾ ಸಾಮಾನ್ಯವಾದ ತಪ್ಪು, ಇದು ಪತ್ತೆಹಚ್ಚಲು ಸಹ ಕಷ್ಟ. ವಸ್ತುವಿನ ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ, ಕನಿಷ್ಠ ಸಂದರ್ಭಗಳಲ್ಲಿ ವಸ್ತುವು ಸ್ವತಃ ಪ್ರಾರಂಭಿಸಬಹುದೇ ಎಂದು ತಿಳಿದಿಲ್ಲ. ವರ್ಗ ಕಾರ್ಯವಿಧಾನವು ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಇದನ್ನು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. (ನಾವು ಈಗಾಗಲೇ ವಿಭಾಗ 2.3 ರಲ್ಲಿ ಇದರ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇವೆ. ನಾವು ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, ವಿಭಾಗಗಳು 3.11 ಮತ್ತು 3.15 ರಲ್ಲಿ ಮಾತನಾಡುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿಯಿಂದ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಸಂಕೀರ್ಣ ತರಗತಿಗಳನ್ನು ನೋಡುತ್ತೇವೆ.)

ಇಂಟ್ ಮುಖ್ಯ() ( // ಅನ್‌ಇನಿಶಿಯಲೈಸ್ಡ್ ಲೋಕಲ್ ಆಬ್ಜೆಕ್ಟ್ ಇಂಟ್ ಇವಾಲ್;
// ಪ್ರಕಾರದ ಸ್ಟ್ರಿಂಗ್‌ನ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ
// ಡೀಫಾಲ್ಟ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸ್ಟ್ರಿಂಗ್ ಯೋಜನೆ;
// ...
}

ಆರಂಭಿಕ ಮೌಲ್ಯವನ್ನು ನೇರವಾಗಿ ವೇರಿಯಬಲ್ ವ್ಯಾಖ್ಯಾನ ಹೇಳಿಕೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. C++ ನಲ್ಲಿ, ಎರಡು ರೀತಿಯ ವೇರಿಯಬಲ್ ಇನಿಶಿಯಲೈಸೇಶನ್ ಅನ್ನು ಅನುಮತಿಸಲಾಗಿದೆ - ಸ್ಪಷ್ಟವಾಗಿ, ನಿಯೋಜನೆ ಆಪರೇಟರ್ ಬಳಸಿ:

ಇಂಟ್ ಇವಾಲ್ = 1024; ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾಜೆಕ್ಟ್ = "ಫ್ಯಾಂಟಸಿಯಾ 2000";

ಮತ್ತು ಸೂಚ್ಯ, ಆವರಣಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆರಂಭಿಕ ಮೌಲ್ಯದೊಂದಿಗೆ:

ಇಂಟ್ ಇವಾಲ್ (1024); ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾಜೆಕ್ಟ್("ಫ್ಯಾಂಟಸಿಯಾ 2000");

ಎರಡೂ ಆಯ್ಕೆಗಳು ಸಮಾನವಾಗಿವೆ ಮತ್ತು ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ival ಗಾಗಿ ಆರಂಭಿಕ ಮೌಲ್ಯಗಳನ್ನು 1024 ಕ್ಕೆ ಮತ್ತು ಯೋಜನೆಯ ಸ್ಟ್ರಿಂಗ್‌ಗೆ "Fantasia 2000" ಗೆ ಹೊಂದಿಸಿ.
ಪಟ್ಟಿಯಲ್ಲಿರುವ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ಸ್ಪಷ್ಟವಾದ ಪ್ರಾರಂಭವನ್ನು ಸಹ ಬಳಸಬಹುದು:

ಡಬಲ್ ಸಂಬಳ = 9999.99, ವೇತನ = ಸಂಬಳ + 0.01; ಇಂಟ್ ತಿಂಗಳು = 08; ದಿನ = 07, ವರ್ಷ = 1955;

ವೇರಿಯೇಬಲ್ ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ತಕ್ಷಣ ಗೋಚರಿಸುತ್ತದೆ (ಮತ್ತು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಮಾನ್ಯವಾಗಿದೆ), ಆದ್ದರಿಂದ ನಾವು ವೇತನ ವೇರಿಯಬಲ್ ಅನ್ನು ಹೊಸದಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಂಬಳದ ವೇರಿಯಬಲ್ ಮೊತ್ತದೊಂದಿಗೆ ಕೆಲವು ಸ್ಥಿರಾಂಕಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು. ಆದ್ದರಿಂದ ವ್ಯಾಖ್ಯಾನವು ಹೀಗಿದೆ:

// ಸರಿಯಾದ, ಆದರೆ ಅರ್ಥಹೀನ ಇಂಟ್ ವಿಲಕ್ಷಣ = ವಿಲಕ್ಷಣ;

ಅರ್ಥಹೀನವಾಗಿದ್ದರೂ ವಾಕ್ಯರಚನೆಯಿಂದ ಮಾನ್ಯವಾಗಿದೆ.
ಅಂತರ್ನಿರ್ಮಿತ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ವಿಶೇಷ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೊಂದಿವೆ:

// ival 0 ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು dval 0.0 int ival = int(); ಡಬಲ್ dval = ಡಬಲ್ ();

ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನದಲ್ಲಿ:

// int() ಅನ್ನು ವೆಕ್ಟರ್‌ನ 10 ಅಂಶಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ< int >ivec (10);

ವೆಕ್ಟರ್ನ ಹತ್ತು ಅಂಶಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು int() ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. (ನಾವು ಈಗಾಗಲೇ ವಿಭಾಗ 2.8 ರಲ್ಲಿ ವೆಕ್ಟರ್ ವರ್ಗದ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇವೆ. ಇದರ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ವಿಭಾಗ 3.10 ಮತ್ತು ಅಧ್ಯಾಯ 6 ಅನ್ನು ನೋಡಿ.)
ಫಂಕ್ಷನ್ ಕರೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಯಾವುದೇ ಸಂಕೀರ್ಣತೆಯ ಅಭಿವ್ಯಕ್ತಿಯೊಂದಿಗೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

#ಸೇರಿಸು #ಸೇರಿಸು
ಡಬಲ್ ಬೆಲೆ = 109.99, ರಿಯಾಯಿತಿ = 0.16;
ಡಬಲ್ ಮಾರಾಟ_ಬೆಲೆ (ಬೆಲೆ * ರಿಯಾಯಿತಿ);
ಸ್ಟ್ರಿಂಗ್ ಪಿಇಟಿ ("ಸುಕ್ಕುಗಳು"); extern int get_value(); ಇಂಟ್ ವಾಲ್ = get_value();
ಸಹಿ ಮಾಡದ abs_val = abs(val);

abs() ಪ್ರಮಾಣಿತ ಕಾರ್ಯವಾಗಿದ್ದು ಅದು ನಿಯತಾಂಕದ ಸಂಪೂರ್ಣ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
get_value() ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಕೆಲವು ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯವಾಗಿದೆ.

ವ್ಯಾಯಾಮ 3.3

ಕೆಳಗಿನ ಯಾವ ವೇರಿಯಬಲ್ ವ್ಯಾಖ್ಯಾನಗಳು ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳನ್ನು ಒಳಗೊಂಡಿವೆ?

(ಎ) ಇಂಟ್ ಕಾರ್ = 1024, ಆಟೋ = 2048; (ಬಿ) ಇಂಟ್ ಇವಲ್ = ಇವಾಲ್; (ಸಿ) ಇಂಟ್ ಇವಾಲ್ (ಇಂಟ್ ()); (ಡಿ) ಡಬಲ್ ಸಂಬಳ = ವೇತನ = 9999.99; (ಇ) ಸಿನ್ >> ಇಂಟ್ ಇನ್ಪುಟ್_ಮೌಲ್ಯ;

ವ್ಯಾಯಾಮ 3.4

ಎಲ್-ಮೌಲ್ಯ ಮತ್ತು ಆರ್-ಮೌಲ್ಯದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸಿ. ಉದಾಹರಣೆಗಳನ್ನು ನೀಡಿ.

ವ್ಯಾಯಾಮ 3.5

ಪ್ರತಿ ಉದಾಹರಣೆಯ ಮೊದಲ ಮತ್ತು ಎರಡನೆಯ ಸಾಲುಗಳಲ್ಲಿ ಹೆಸರು ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಅಸ್ಥಿರಗಳ ಬಳಕೆಯಲ್ಲಿ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹುಡುಕಿ:

(ಎ) ಬಾಹ್ಯ ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು; ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು ("ವ್ಯಾಯಾಮ 3.5a"); (ಬಿ) ಬಾಹ್ಯ ವೆಕ್ಟರ್ ವಿದ್ಯಾರ್ಥಿಗಳು; ವೆಕ್ಟರ್ ವಿದ್ಯಾರ್ಥಿಗಳು;

ವ್ಯಾಯಾಮ 3.6

C++ ನಲ್ಲಿ ಯಾವ ವಸ್ತುವಿನ ಹೆಸರುಗಳು ಅಮಾನ್ಯವಾಗಿವೆ? ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಿ ಇದರಿಂದ ಅವು ವಾಕ್ಯರಚನೆ ಸರಿಯಾಗಿರುತ್ತವೆ:

(ಎ) ಇಂಟ್ ಡಬಲ್ = 3.14159; (ಬಿ) ವೆಕ್ಟರ್< int >_; (ಸಿ) ಸ್ಟ್ರಿಂಗ್ ನೇಮ್‌ಸ್ಪೇಸ್; (ಡಿ) ಸ್ಟ್ರಿಂಗ್ ಕ್ಯಾಚ್-22; (ಇ) ಚಾರ್ 1_or_2 = "1"; (ಎಫ್) ಫ್ಲೋಟ್ ಫ್ಲೋಟ್ = 3.14f;

ವ್ಯಾಯಾಮ 3.7

ಕೆಳಗಿನ ಜಾಗತಿಕ ಮತ್ತು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ವ್ಯಾಖ್ಯಾನಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ಸ್ಟ್ರಿಂಗ್ ಜಾಗತಿಕ_ವರ್ಗ; ಇಂಟ್ ಗ್ಲೋಬಲ್_ಇಂಟ್; ಇಂಟ್ ಮುಖ್ಯ() (
ಇಂಟ್ ಲೋಕಲ್_ಇಂಟ್;
ಸ್ಟ್ರಿಂಗ್ ಲೋಕಲ್_ಕ್ಲಾಸ್; //...
}

3.3. ಸೈನ್‌ಪೋಸ್ಟ್‌ಗಳು

ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ವಿಭಾಗ 2.2 ರಲ್ಲಿ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಚಯಿಸಲಾಗಿದೆ. ಪಾಯಿಂಟರ್ಮತ್ತೊಂದು ವಸ್ತುವಿನ ವಿಳಾಸವನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ವಸ್ತುವಾಗಿದೆ ಮತ್ತು ಈ ವಸ್ತುವಿನ ಪರೋಕ್ಷ ಕುಶಲತೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ, ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಲಾದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು, ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಗಳು ಮತ್ತು ಶ್ರೇಣಿಯ ಮರಗಳಂತಹ ಸಂಬಂಧಿತ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ದೊಡ್ಡ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು-ಅರೇಗಳು ಮತ್ತು ವರ್ಗ ವಸ್ತುಗಳನ್ನು-ಕಾರ್ಯಗಳಿಗೆ ನಿಯತಾಂಕಗಳಾಗಿ ರವಾನಿಸಲು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
ಪ್ರತಿಯೊಂದು ಪಾಯಿಂಟರ್ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದೆ, ಮತ್ತು ಅವುಗಳ ಆಂತರಿಕ ಪ್ರಾತಿನಿಧ್ಯವು ಆಂತರಿಕ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿರುವುದಿಲ್ಲ: ಪಾಯಿಂಟರ್ ಪ್ರಕಾರದ ವಸ್ತುವಿನಿಂದ ಆಕ್ರಮಿಸಲ್ಪಟ್ಟ ಮೆಮೊರಿ ಗಾತ್ರ ಮತ್ತು ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯು ಒಂದೇ ಆಗಿರುತ್ತದೆ. ಕಂಪೈಲರ್ ಉದ್ದೇಶಿತ ವಸ್ತುವನ್ನು ಹೇಗೆ ಪರಿಗಣಿಸುತ್ತದೆ ಎಂಬುದು ವ್ಯತ್ಯಾಸವಾಗಿದೆ. ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಬಹುದು, ಆದರೆ ಅನುಗುಣವಾದ ಪ್ರಕಾರಗಳು ಇರುವ ಮೆಮೊರಿ ಪ್ರದೇಶವು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ:

• ವಿಳಾಸ ಮೌಲ್ಯ 1000 ಅನ್ನು ಹೊಂದಿರುವ ಇಂಟ್‌ಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮೆಮೊರಿ ಪ್ರದೇಶ 1000-1003 ಗೆ ನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ (32-ಬಿಟ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ);
• ವಿಳಾಸ 1000 ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ದ್ವಿಗುಣಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮೆಮೊರಿ ಪ್ರದೇಶ 1000-1007 ಗೆ ನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ (32-ಬಿಟ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ).

ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

ಇಂಟ್ * ip1, * ip2; ಸಂಕೀರ್ಣ * ಸಿಪಿ; ಸ್ಟ್ರಿಂಗ್ *ಪ್ಸ್ಟ್ರಿಂಗ್; ವೆಕ್ಟರ್ * pvec; ಡಬಲ್ * ಡಿಪಿ;

ಸೂಚ್ಯಂಕವನ್ನು ಹೆಸರಿನ ಮೊದಲು ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಪಟ್ಟಿಯೊಂದಿಗೆ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಲ್ಲಿ, ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯು ಪ್ರತಿ ಪಾಯಿಂಟರ್‌ಗೆ ಮುಂಚಿತವಾಗಿರಬೇಕು (ಮೇಲೆ ನೋಡಿ: ip1 ಮತ್ತು ip2). ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, lp ದೀರ್ಘ ವಸ್ತುವಿಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ, ಮತ್ತು lp2 ದೀರ್ಘ ವಸ್ತುವಾಗಿದೆ:

ಉದ್ದ * ಎಲ್ಪಿ, ಎಲ್ಪಿ 2;

ಕೆಳಗಿನ ಸಂದರ್ಭದಲ್ಲಿ, fp ಅನ್ನು ಫ್ಲೋಟ್ ಆಬ್ಜೆಕ್ಟ್ ಎಂದು ಅರ್ಥೈಸಲಾಗುತ್ತದೆ ಮತ್ತು fp2 ಅದಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ:

ಫ್ಲೋಟ್ fp, *fp2;

ಡೆರೆಫರೆನ್ಸ್ ಆಪರೇಟರ್ (*) ಅನ್ನು ಹೆಸರಿನಿಂದ ಸ್ಥಳಗಳಿಂದ ಬೇರ್ಪಡಿಸಬಹುದು ಮತ್ತು ಟೈಪ್ ಕೀವರ್ಡ್‌ಗೆ ನೇರವಾಗಿ ಪಕ್ಕದಲ್ಲಿದೆ. ಆದ್ದರಿಂದ, ಮೇಲಿನ ವ್ಯಾಖ್ಯಾನಗಳು ವಾಕ್ಯರಚನೆಯಲ್ಲಿ ಸರಿಯಾಗಿವೆ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಸಮಾನವಾಗಿವೆ:

//ಗಮನ: ps2 ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪಾಯಿಂಟರ್ ಅಲ್ಲ! ಸ್ಟ್ರಿಂಗ್ * ps, ps2;

ps ಮತ್ತು ps2 ಎರಡೂ ಪಾಯಿಂಟರ್‌ಗಳು ಎಂದು ಊಹಿಸಬಹುದು, ಆದಾಗ್ಯೂ ಪಾಯಿಂಟರ್ ಅವುಗಳಲ್ಲಿ ಮೊದಲನೆಯದು.
ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವು 0 ಆಗಿದ್ದರೆ, ಅದು ಯಾವುದೇ ವಸ್ತು ವಿಳಾಸವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ.
ಇಂಟ್ ಪ್ರಕಾರದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಿ:

ಇಂಟ್ ಇವಾಲ್ = 1024;

ಇಂಟ್ ಪೈ ಮತ್ತು ಪೈ 2 ಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮತ್ತು ಬಳಸುವ ಉದಾಹರಣೆಗಳೆಂದರೆ:

//pi ಅನ್ನು ಶೂನ್ಯ ವಿಳಾಸಕ್ಕೆ ಇಂಟ್ * ಪೈ = 0 ಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ;
// pi2 ಅನ್ನು ival ವಿಳಾಸದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ
int *pi2 =
// ಸರಿ: pi ಮತ್ತು pi2 ಇವಾಲ್ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುತ್ತವೆ
ಪೈ = ಪೈ2;
// pi2 ವಿಳಾಸ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ
pi2 = 0;

ಪಾಯಿಂಟರ್‌ಗೆ ವಿಳಾಸವಲ್ಲದ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ:

// ದೋಷ: ಪೈ ಇಂಟ್ ಪೈ = ಇವಾಲ್ ಮೌಲ್ಯವನ್ನು ಸ್ವೀಕರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

ಅದೇ ರೀತಿಯಲ್ಲಿ, ನೀವು ಒಂದು ಪ್ರಕಾರದ ಪಾಯಿಂಟರ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಅದು ಇನ್ನೊಂದು ಪ್ರಕಾರದ ವಸ್ತುವಿನ ವಿಳಾಸವಾಗಿದೆ. ಕೆಳಗಿನ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ:

ಡಬಲ್ dval; ಡಬಲ್ * ಪಿಎಸ್ =

ನಂತರ ಕೆಳಗಿನ ಎರಡೂ ನಿಯೋಜನೆ ಅಭಿವ್ಯಕ್ತಿಗಳು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ:

// ಸಂಕಲನ ದೋಷಗಳು // ಅಮಾನ್ಯ ಡೇಟಾ ಪ್ರಕಾರದ ನಿಯೋಜನೆ: ಇಂಟ್*<== double* pi = pd pi = &dval;

ಪೈ ವೇರಿಯೇಬಲ್ dval ಆಬ್ಜೆಕ್ಟ್‌ನ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಎಂಬುದು ಅಲ್ಲ - ವಿವಿಧ ಪ್ರಕಾರಗಳ ವಸ್ತುಗಳ ವಿಳಾಸಗಳು ಒಂದೇ ಉದ್ದವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಅಂತಹ ವಿಳಾಸ ಮಿಶ್ರಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ನಿಷೇಧಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಕಂಪೈಲರ್‌ನ ವಸ್ತುಗಳ ವ್ಯಾಖ್ಯಾನವು ಅವುಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ನ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ಸಹಜವಾಗಿ, ನಾವು ವಿಳಾಸದ ಮೌಲ್ಯದಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿರುವಾಗ ಸಂದರ್ಭಗಳಿವೆ, ಮತ್ತು ಅದು ಸೂಚಿಸುವ ವಸ್ತುವಿನಲ್ಲಿ ಅಲ್ಲ (ನಾವು ಈ ವಿಳಾಸವನ್ನು ಬೇರೆ ಯಾವುದರೊಂದಿಗೆ ಹೋಲಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ). ಅಂತಹ ಸಂದರ್ಭಗಳನ್ನು ಪರಿಹರಿಸಲು, ವಿಶೇಷ ನಿರರ್ಥಕ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗಿದೆ, ಇದು ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸಬಹುದು ಮತ್ತು ಕೆಳಗಿನ ಅಭಿವ್ಯಕ್ತಿಗಳು ಸರಿಯಾಗಿರುತ್ತವೆ:

// ಸರಿ: ನಿರರ್ಥಕ* ಯಾವುದೇ ರೀತಿಯ ನಿರರ್ಥಕದ // ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿರಬಹುದು * pv = pi; pv = pd;

ಶೂನ್ಯದಿಂದ ಸೂಚಿಸಲಾದ ವಸ್ತುವಿನ ಪ್ರಕಾರವು ತಿಳಿದಿಲ್ಲ* ಮತ್ತು ನಾವು ಈ ವಸ್ತುವನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಅಂತಹ ಪಾಯಿಂಟರ್‌ನೊಂದಿಗೆ ನಾವು ಮಾಡಬಹುದಾದ ಎಲ್ಲವು ಅದರ ಮೌಲ್ಯವನ್ನು ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್‌ಗೆ ನಿಯೋಜಿಸುವುದು ಅಥವಾ ಅದನ್ನು ಕೆಲವು ವಿಳಾಸ ಮೌಲ್ಯದೊಂದಿಗೆ ಹೋಲಿಸುವುದು. (ನಾವು ವಿಭಾಗ 4.14 ರಲ್ಲಿ ನಿರರ್ಥಕ ಪಾಯಿಂಟರ್ ಬಗ್ಗೆ ಹೆಚ್ಚು ಮಾತನಾಡುತ್ತೇವೆ.)
ಅದರ ವಿಳಾಸವನ್ನು ನೀಡಿದ ವಸ್ತುವನ್ನು ಪ್ರವೇಶಿಸಲು, ನೀವು ಡಿಫರೆನ್ಸಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಅಥವಾ ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯಿಂದ ಸೂಚಿಸಲಾದ ಪರೋಕ್ಷ ವಿಳಾಸವನ್ನು (*) ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಕೆಳಗಿನ ವೇರಿಯಬಲ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಹೊಂದಿರುವ:

Int ival = 1024;, ival2 = 2048; ಇಂಟ್ * ಪೈ =

// ival2 * pi = ival2 ಮೌಲ್ಯಕ್ಕೆ ವೇರಿಯೇಬಲ್ ival ನ ಪರೋಕ್ಷ ನಿಯೋಜನೆ;
// rvalue ಮತ್ತು lvalue ಆಗಿ ival ವೇರಿಯೇಬಲ್‌ನ ಪರೋಕ್ಷ ಬಳಕೆ
* ಪೈ = abs (* pi); // ival = abs (ival);
* ಪೈ = * ಪೈ + 1; // ival = ival + 1;

ನಾವು ಇಂಟ್ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ವಿಳಾಸ ಆಪರೇಟರ್ (&) ಅನ್ನು ಅನ್ವಯಿಸಿದಾಗ, ನಾವು ಟೈಪ್ ಇಂಟ್ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ*
ಇಂಟ್ * ಪೈ =
ಅದೇ ಕಾರ್ಯಾಚರಣೆಯನ್ನು int * (ಪಾಯಿಂಟರ್‌ನಿಂದ ಇಂಟ್) ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ಅನ್ವಯಿಸಿದರೆ, ನಾವು ಇಂಟ್‌ಗೆ ಪಾಯಿಂಟರ್‌ಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅಂದರೆ. int**. int** ಎಂಬುದು ವಸ್ತುವಿನ ವಿಳಾಸವಾಗಿದ್ದು ಅದು ಇಂಟ್ ಪ್ರಕಾರದ ವಸ್ತುವಿನ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ppi ಅನ್ನು ಡಿಫರೆನ್ಸಿಂಗ್ ಮಾಡುವ ಮೂಲಕ, ನಾವು ival ನ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುವ int* ಪ್ರಕಾರದ ವಸ್ತುವನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಇವಾಲ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸ್ವತಃ ಪಡೆಯಲು, ಪಿಪಿಐನಲ್ಲಿ ಡಿರೆಫರೆನ್ಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಎರಡು ಬಾರಿ ಅನ್ವಯಿಸಬೇಕು.

Int **ppi = π int *pi2 = *ppi;
ಕೌಟ್<< "Значение ival\n" << "явное значение: " << ival << "\n"
<< "косвенная адресация: " << *pi << "\n"
<< "дважды косвенная адресация: " << **ppi << "\n"

ಅಂಕಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಗಮನಿಸಿ, ಅಲ್ಲಿ ಎರಡು ಅಭಿವ್ಯಕ್ತಿಗಳು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತವೆ:

ಇಂಟ್ ಐ, ಜೆ, ಕೆ; int *pi = // i = i + 2
* ಪೈ = * ಪೈ + 2; //ಪೈ ನಲ್ಲಿರುವ ವಿಳಾಸವನ್ನು 2 ರಿಂದ ಹೆಚ್ಚಿಸಿ
ಪೈ = ಪೈ + 2;

ನೀವು ಪಾಯಿಂಟರ್‌ಗೆ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ನೀವು ಅದರಿಂದ ಕಳೆಯಬಹುದು. ಪಾಯಿಂಟರ್‌ಗೆ 1 ಅನ್ನು ಸೇರಿಸುವುದರಿಂದ ಅದು ಹೊಂದಿರುವ ಮೌಲ್ಯವನ್ನು ಅನುಗುಣವಾದ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಗಾತ್ರದಿಂದ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಚಾರ್ 1 ಬೈಟ್ ಆಗಿದ್ದರೆ, ಇಂಟ್ 4 ಬೈಟ್‌ಗಳು ಮತ್ತು ಡಬಲ್ ಆಗಿದ್ದರೆ 8, ನಂತರ ಪಾಯಿಂಟರ್‌ಗಳಿಗೆ 2 ಅನ್ನು ಚಾರ್, ಇಂಟ್ ಮತ್ತು ಡಬಲ್ ಸೇರಿಸುವುದರಿಂದ ಅವುಗಳ ಮೌಲ್ಯವನ್ನು ಕ್ರಮವಾಗಿ 2, 8 ಮತ್ತು 16 ರಷ್ಟು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಇದನ್ನು ಹೇಗೆ ಅರ್ಥೈಸಬಹುದು? ಒಂದೇ ರೀತಿಯ ವಸ್ತುಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಒಂದರ ನಂತರ ಒಂದರಂತೆ ನೆಲೆಗೊಂಡಿದ್ದರೆ, ನಂತರ ಪಾಯಿಂಟರ್ ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಿದರೆ ಅದು ಮುಂದಿನ ವಸ್ತುವಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸರಣಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತವನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ; ಯಾವುದೇ ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅವರು ಅಷ್ಟೇನೂ ಸಮರ್ಥಿಸುವುದಿಲ್ಲ.
ಪುನರಾವರ್ತಕವನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ಅಂಶಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡುವಾಗ ವಿಳಾಸ ಅಂಕಗಣಿತವನ್ನು ಬಳಸುವ ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಯು ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಇಂಟ್ IA; int * iter = int * iter_end =
ಯಾವಾಗ (ಇಟರ್ != iter_end) (
ಮೌಲ್ಯದೊಂದಿಗೆ_ಏನಾದರೂ ಮಾಡಿ (*ಇಟರ್);
++ಇಟರ್;
}

ವ್ಯಾಯಾಮ 3.8

ಅಸ್ಥಿರಗಳ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ನೀಡಲಾಗಿದೆ:

Int ival = 1024, ival2 = 2048; int *pi1 = &ival, *pi2 = &ival2, **pi3 = 0;

ನೀವು ಈ ಕೆಳಗಿನ ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಿದಾಗ ಏನಾಗುತ್ತದೆ? ಈ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಯಾವುದೇ ತಪ್ಪುಗಳಿವೆಯೇ?

(a) ival = *pi3; (ಇ) pi1 = *pi3; (b) *pi2 = *pi3; (f) ival = *pi1; (ಸಿ) ಇವಾಲ್ = ಪೈ2; (g) pi1 = ival; (ಡಿ) pi2 = *pi1; (h)pi3 =

ವ್ಯಾಯಾಮ 3.9

ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು C ಮತ್ತು C++ ನ ಪ್ರಮುಖ ಅಂಶಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಆದರೆ ತಪ್ಪುಗಳನ್ನು ಮಾಡುವುದು ಸುಲಭ. ಉದಾಹರಣೆಗೆ, ಕೋಡ್

ಪೈ = ಪೈ = ಪೈ + 1024;

ಪೈ ಅನ್ನು ಯಾದೃಚ್ಛಿಕ ಮೆಮೊರಿಯ ಸ್ಥಳಕ್ಕೆ ಸೂಚಿಸಲು ಬಹುತೇಕ ಖಚಿತವಾಗಿ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ನಿಯೋಜನೆ ಆಪರೇಟರ್ ಏನು ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಅದು ಯಾವಾಗ ದೋಷವನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ?

ವ್ಯಾಯಾಮ 3.10

ಪಾಯಿಂಟರ್‌ಗಳ ತಪ್ಪಾದ ಬಳಕೆಗೆ ಸಂಬಂಧಿಸಿದ ದೋಷವನ್ನು ಈ ಪ್ರೋಗ್ರಾಂ ಒಳಗೊಂಡಿದೆ:

ಇಂಟ್ ಫೂಬಾರ್ (ಇಂಟ್ * ಪೈ) ( * ಪೈ = 1024; ರಿಟರ್ನ್ * ಪೈ; )
ಇಂಟ್ ಮುಖ್ಯ() (
int *pi2 = 0;
ಇಂಟ್ ಇವಾಲ್ = ಫೂಬಾರ್(ಪಿಐ2);
ಹಿಂತಿರುಗಿ 0;
}

ದೋಷ ಏನು? ನಾನು ಅದನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸಬಹುದು?

ವ್ಯಾಯಾಮ 3.11

ಹಿಂದಿನ ಎರಡು ವ್ಯಾಯಾಮಗಳಿಂದ ದೋಷಗಳು ಸ್ವತಃ ಪ್ರಕಟವಾಗುತ್ತವೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದಲ್ಲಿ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯಗಳ ಸರಿಯಾದತೆಯನ್ನು ಪರಿಶೀಲಿಸುವ C ++ ಕೊರತೆಯಿಂದಾಗಿ ಮಾರಕ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ಅಂತಹ ಚೆಕ್ ಅನ್ನು ಏಕೆ ಜಾರಿಗೊಳಿಸಲಾಗಿಲ್ಲ ಎಂದು ನೀವು ಭಾವಿಸುತ್ತೀರಿ? ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಸುರಕ್ಷಿತವಾಗಿ ಕೆಲಸ ಮಾಡಲು ನೀವು ಕೆಲವು ಸಾಮಾನ್ಯ ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ನೀಡಬಹುದೇ?

3.4 ಸ್ಟ್ರಿಂಗ್ ವಿಧಗಳು

C++ ಎರಡು ವಿಧದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ - C ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರ ಮತ್ತು C++ ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿಯಿಂದ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗ. ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವು ಹೆಚ್ಚಿನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಬಳಸಲು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದಾಗ್ಯೂ, ಪ್ರಾಯೋಗಿಕವಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರವನ್ನು ಬಳಸಲು ಅಥವಾ ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ಉತ್ತಮ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರುವಾಗ ಆಗಾಗ್ಗೆ ಸಂದರ್ಭಗಳಿವೆ. (ಒಂದು ಉದಾಹರಣೆಯೆಂದರೆ ಮುಖ್ಯ() ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾದ ಕಮಾಂಡ್ ಲೈನ್ ನಿಯತಾಂಕಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು. ನಾವು ಇದನ್ನು ಅಧ್ಯಾಯ 7 ರಲ್ಲಿ ಕವರ್ ಮಾಡುತ್ತೇವೆ.)

3.4.1. ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರ

ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವು C++ ನಿಂದ ಬಂದಿದೆ, C ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಲಾಗಿದೆ. ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಅರೇ ಆಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಚಾರ್* ಪಾಯಿಂಟರ್ ಬಳಸಿ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ. C ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಮ್ಯಾನಿಪುಲೇಟ್ ಮಾಡಲು ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

// ಸ್ಟ್ರಿಂಗ್ ಇಂಟ್ strlen (const char*) ನ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
// ಎರಡು ತಂತಿಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ
int strcmp (const char*, const char*);
// ಒಂದು ಸಾಲನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸುತ್ತದೆ
ಚಾರ್ * strcpy (ಚಾರ್ *, ಕಾನ್ಸ್ಟ್ ಚಾರ್ *);

C ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು C++ ಲೈಬ್ರರಿಯ ಭಾಗವಾಗಿದೆ. ಇದನ್ನು ಬಳಸಲು ನಾವು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:

#ಸೇರಿಸು

ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಬಳಸುವ ಪಾಯಿಂಟರ್ ಟು ಚಾರ್, ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಅನುಗುಣವಾದ ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಾವು ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬರೆಯುವಾಗಲೂ ಸಹ

Const char *st = "ಒಂದು ಬಾಟಲಿ ವೈನ್‌ನ ಬೆಲೆ\n";

ಕಂಪೈಲರ್ ಸ್ಟ್ರಿಂಗ್‌ನ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ರಚನೆಯ ಮೊದಲ ಅಂಶದ ವಿಳಾಸವನ್ನು st ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ. ಅಂತಹ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಸ್ಟ್ರಿಂಗ್ನೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬಹುದು?
ವಿಶಿಷ್ಟವಾಗಿ, ವಿಳಾಸ ಅಂಕಗಣಿತವನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಅಕ್ಷರಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ ಯಾವಾಗಲೂ ಶೂನ್ಯ ಅಕ್ಷರದೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುವುದರಿಂದ, ಮುಂದಿನ ಅಕ್ಷರವು ಶೂನ್ಯವಾಗುವವರೆಗೆ ನೀವು ಪಾಯಿಂಟರ್ ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಆದರೆ (*st++) (... )

st ಅನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಮತ್ತು ಅದು ನಿಜವೇ ಎಂದು ನೋಡಲು ಫಲಿತಾಂಶದ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಯಾವುದೇ ಶೂನ್ಯವಲ್ಲದ ಮೌಲ್ಯವನ್ನು ನಿಜವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಕೋಡ್ 0 ನೊಂದಿಗೆ ಅಕ್ಷರವನ್ನು ತಲುಪಿದಾಗ ಲೂಪ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಹೆಚ್ಚಳ ಕಾರ್ಯಾಚರಣೆ ++ ಪಾಯಿಂಟರ್ st ಗೆ 1 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗಾಗಿ ಅದನ್ನು ಮುಂದಿನ ಅಕ್ಷರಕ್ಕೆ ವರ್ಗಾಯಿಸುತ್ತದೆ.
ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಕಾರ್ಯದ ಅನುಷ್ಠಾನವು ಹೇಗಿರಬಹುದು. ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವುದರಿಂದ (ಯಾವುದಕ್ಕೂ ಸೂಚಿಸುವುದಿಲ್ಲ), ಅದನ್ನು ಡಿರೆಫರೆನ್ಸ್ ಕಾರ್ಯಾಚರಣೆಯ ಮೊದಲು ಪರಿಶೀಲಿಸಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸಿ:

Int string_length(const char *st) ( int cnt = 0; if (st) while (*st++) ++cnt; cnt ಹಿಂತಿರುಗಿ; )

ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಎರಡು ಸಂದರ್ಭಗಳಲ್ಲಿ ಖಾಲಿ ಎಂದು ಪರಿಗಣಿಸಬಹುದು: ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದ್ದರೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮಗೆ ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ಇಲ್ಲ) ಅಥವಾ ಅದು ಒಂದೇ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಒಳಗೊಂಡಿರುವ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸಿದರೆ (ಅಂದರೆ , ಯಾವುದೇ ಮಹತ್ವದ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರದ ಸ್ಟ್ರಿಂಗ್‌ಗೆ).

// pc1 ಯಾವುದೇ ಅಕ್ಷರ ರಚನೆಯ ಚಾರ್ *pc1 = 0 ಅನ್ನು ತಿಳಿಸುವುದಿಲ್ಲ; // pc2 ಶೂನ್ಯ ಅಕ್ಷರದ const char *pc2 = "";

ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್‌ಗಾಗಿ, ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ತಂತಿಗಳನ್ನು ಬಳಸುವುದು ತುಂಬಾ ಕಡಿಮೆ ಮಟ್ಟದ ಅನುಷ್ಠಾನ ಮತ್ತು ವಿಳಾಸ ಅಂಕಗಣಿತವಿಲ್ಲದೆ ಮಾಡಲು ಅಸಮರ್ಥತೆಯಿಂದಾಗಿ ದೋಷಗಳಿಂದ ತುಂಬಿರುತ್ತದೆ. ಆರಂಭಿಕರು ಮಾಡಿದ ಕೆಲವು ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳನ್ನು ನಾವು ಕೆಳಗೆ ತೋರಿಸುತ್ತೇವೆ. ಕಾರ್ಯವು ಸರಳವಾಗಿದೆ: ಸ್ಟ್ರಿಂಗ್ನ ಉದ್ದವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ. ಮೊದಲ ಆವೃತ್ತಿಯು ತಪ್ಪಾಗಿದೆ. ಅವಳನ್ನು ಸರಿಪಡಿಸಿ.

#ಸೇರಿಸು const char *st = "ಒಂದು ಬಾಟಲಿ ವೈನ್‌ನ ಬೆಲೆ\n"; ಇಂಟ್ ಮುಖ್ಯ() (
ಇಂಟ್ ಲೆನ್ = 0;
ಹಾಗೆಯೇ (st++) ++len; ಕೌಟ್<< len << ": " << st;
ಹಿಂತಿರುಗಿ 0;
}

ಈ ಆವೃತ್ತಿಯಲ್ಲಿ, ಸ್ಟ ಪಾಯಿಂಟರ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗಿಲ್ಲ. ಆದ್ದರಿಂದ, ಸಮಾನತೆ 0 ಗಾಗಿ ಪರಿಶೀಲಿಸಲಾದ st ನಿಂದ ಸೂಚಿಸಲಾದ ಅಕ್ಷರವಲ್ಲ, ಆದರೆ ಪಾಯಿಂಟರ್ ಸ್ವತಃ. ಈ ಪಾಯಿಂಟರ್ ಆರಂಭದಲ್ಲಿ ಶೂನ್ಯವಲ್ಲದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವುದರಿಂದ (ಸ್ಟ್ರಿಂಗ್‌ನ ವಿಳಾಸ), ಅದು ಎಂದಿಗೂ ಶೂನ್ಯವಾಗುವುದಿಲ್ಲ ಮತ್ತು ಲೂಪ್ ಅಂತ್ಯವಿಲ್ಲದೆ ರನ್ ಆಗುತ್ತದೆ.
ಪ್ರೋಗ್ರಾಂನ ಎರಡನೇ ಆವೃತ್ತಿಯಲ್ಲಿ ಈ ದೋಷವನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ. ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿಯಾಗಿ ಮುಕ್ತಾಯಗೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಔಟ್ಪುಟ್ ತಪ್ಪಾಗಿದೆ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಎಲ್ಲಿ ತಪ್ಪಾಗುತ್ತಿದ್ದೇವೆ?

#ಸೇರಿಸು const char *st = "ಒಂದು ಬಾಟಲಿ ವೈನ್‌ನ ಬೆಲೆ\n"; ಇಂಟ್ ಮುಖ್ಯ()
{
ಇಂಟ್ ಲೆನ್ = 0;
ಹಾಗೆಯೇ (*st++) ++len; ಕೌಟ್<< len << ": " << st << endl;
ಹಿಂತಿರುಗಿ 0;
}

ದೋಷವೆಂದರೆ ಲೂಪ್ ಮುಗಿದ ನಂತರ, st ಪಾಯಿಂಟರ್ ಮೂಲ ಅಕ್ಷರವನ್ನು ಅಕ್ಷರಶಃ ಸಂಬೋಧಿಸುವುದಿಲ್ಲ, ಆದರೆ ಅಕ್ಷರದ ಅಂತ್ಯಗೊಳ್ಳುವ ಶೂನ್ಯದ ನಂತರ ಮೆಮೊರಿಯಲ್ಲಿ ಇರುವ ಅಕ್ಷರ. ಈ ಸ್ಥಳದಲ್ಲಿ ಏನು ಬೇಕಾದರೂ ಆಗಬಹುದು ಮತ್ತು ಪ್ರೋಗ್ರಾಂನ ಔಟ್‌ಪುಟ್ ಅಕ್ಷರಗಳ ಯಾದೃಚ್ಛಿಕ ಅನುಕ್ರಮವಾಗಿರುತ್ತದೆ.
ಈ ದೋಷವನ್ನು ಸರಿಪಡಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದು:

ಸೇಂಟ್ = ಸ್ಟ - ಲೆನ್; ಕೌಟ್<< len << ": " << st;

ಈಗ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅರ್ಥಪೂರ್ಣವಾದದ್ದನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಆದರೆ ಸಂಪೂರ್ಣವಾಗಿ ಅಲ್ಲ. ಉತ್ತರವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

18: ವೈನ್ ಬಾಟಲಿಯ ಬೆಲೆ

ಲೆಕ್ಕಾಚಾರದ ಉದ್ದದಲ್ಲಿ ಹಿಂದುಳಿದ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ನಾವು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ಮರೆತಿದ್ದೇವೆ. st ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಜೊತೆಗೆ 1 ರ ಉದ್ದದಿಂದ ಸರಿದೂಗಿಸಬೇಕು. ಇಲ್ಲಿ ಅಂತಿಮವಾಗಿ ಸರಿಯಾದ ಆಪರೇಟರ್:

ಸೇಂಟ್ = ಸ್ಟ - ಲೆನ್ - 1;

ಮತ್ತು ಸರಿಯಾದ ಫಲಿತಾಂಶ ಇಲ್ಲಿದೆ:

18: ವೈನ್ ಬಾಟಲಿಯ ಬೆಲೆ

ಆದಾಗ್ಯೂ, ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸೊಗಸಾಗಿ ಕಾಣುತ್ತದೆ ಎಂದು ನಾವು ಹೇಳಲಾಗುವುದಿಲ್ಲ. ಆಪರೇಟರ್

ಸೇಂಟ್ = ಸ್ಟ - ಲೆನ್ - 1;

ಪ್ರೋಗ್ರಾಂ ವಿನ್ಯಾಸದ ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ ಮಾಡಿದ ತಪ್ಪನ್ನು ಸರಿಪಡಿಸಲು ಸೇರಿಸಲಾಗಿದೆ - ನೇರವಾಗಿ ಸ್ಟ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವುದು. ಈ ಹೇಳಿಕೆಯು ಪ್ರೋಗ್ರಾಂನ ತರ್ಕಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಈಗ ಕಷ್ಟವಾಗುತ್ತದೆ. ಈ ರೀತಿಯ ಪರಿಹಾರಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ಯಾಚ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ - ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ರಂಧ್ರವನ್ನು ಪ್ಲಗ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ತರ್ಕವನ್ನು ಮರುಪರಿಶೀಲಿಸುವುದು ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಆಯ್ಕೆಯೆಂದರೆ st ಮೌಲ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾದ ಎರಡನೇ ಪಾಯಿಂಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು:

ಕಾನ್ಸ್ಟ್ ಚಾರ್ * ಪು = ಸ್ಟ;

ಈಗ p ಅನ್ನು ಉದ್ದದ ಲೆಕ್ಕಾಚಾರದ ಲೂಪ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು, st ನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಗದೆ ಬಿಡಬಹುದು:

ಆದರೆ (*p++)

3.4.2. ಸ್ಟ್ರಿಂಗ್ ವರ್ಗ

ನಾವು ಈಗ ನೋಡಿದಂತೆ, ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವನ್ನು ಬಳಸುವುದು ದೋಷ ಪೀಡಿತ ಮತ್ತು ಅನಾನುಕೂಲವಾಗಿದೆ ಏಕೆಂದರೆ ಅದನ್ನು ಕಡಿಮೆ ಮಟ್ಟದಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನಿಮ್ಮ ಸ್ವಂತ ವರ್ಗ ಅಥವಾ ತರಗತಿಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ತುಂಬಾ ಸಾಮಾನ್ಯವಾಗಿದೆ - ಪ್ರತಿಯೊಂದು ಕಂಪನಿ, ಇಲಾಖೆ ಅಥವಾ ವೈಯಕ್ತಿಕ ಯೋಜನೆಗಳು ಸ್ಟ್ರಿಂಗ್‌ನ ಸ್ವಂತ ಅನುಷ್ಠಾನವನ್ನು ಹೊಂದಿದ್ದವು. ನಾನು ಏನು ಹೇಳಬಲ್ಲೆ, ಈ ಪುಸ್ತಕದ ಹಿಂದಿನ ಎರಡು ಆವೃತ್ತಿಗಳಲ್ಲಿ ನಾವು ಅದೇ ಕೆಲಸವನ್ನು ಮಾಡಿದ್ದೇವೆ! ಇದು ಪ್ರೋಗ್ರಾಂ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಪೋರ್ಟಬಿಲಿಟಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಯಿತು. C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯಿಂದ ಪ್ರಮಾಣಿತ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ಅನುಷ್ಠಾನವು ಬೈಸಿಕಲ್‌ಗಳ ಈ ಮರುಶೋಧನೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲು ಉದ್ದೇಶಿಸಲಾಗಿತ್ತು.
ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವು ಹೊಂದಿರಬೇಕಾದ ಕನಿಷ್ಠ ಕಾರ್ಯಾಚರಣೆಗಳ ಸೆಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:

• ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯೊಂದಿಗೆ (ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರ) ಅಥವಾ ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್‌ನ ಇನ್ನೊಂದು ವಸ್ತುವಿನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು. ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರವು ಎರಡನೇ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿಲ್ಲ;
• ಒಂದು ಸಾಲನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸುವುದು. ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರಕ್ಕಾಗಿ ನೀವು strcpy() ಕಾರ್ಯವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ;
• ಓದಲು ಮತ್ತು ಬರೆಯಲು ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳಿಗೆ ಪ್ರವೇಶ. ಅಂತರ್ನಿರ್ಮಿತ ರಚನೆಯಲ್ಲಿ, ಇದನ್ನು ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆ ಅಥವಾ ಪರೋಕ್ಷ ವಿಳಾಸವನ್ನು ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ;
• ಸಮಾನತೆಗಾಗಿ ಎರಡು ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವುದು. ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರಕ್ಕಾಗಿ, strcmp() ಕಾರ್ಯವನ್ನು ಬಳಸಿ;
• ಎರಡು ತಂತಿಗಳ ಜೋಡಣೆ, ಫಲಿತಾಂಶವನ್ನು ಮೂರನೇ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಅಥವಾ ಮೂಲ ಒಂದರ ಬದಲಿಗೆ ಉತ್ಪಾದಿಸುತ್ತದೆ. ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರಕ್ಕಾಗಿ, strcat() ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಆದರೆ ಫಲಿತಾಂಶವನ್ನು ಹೊಸ ಸಾಲಿನಲ್ಲಿ ಪಡೆಯಲು, ನೀವು strcpy() ಮತ್ತು strcat() ಕಾರ್ಯಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ಬಳಸಬೇಕಾಗುತ್ತದೆ;
• ದಾರದ ಉದ್ದವನ್ನು ಲೆಕ್ಕಹಾಕುವುದು. strlen() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು;
• ಸ್ಟ್ರಿಂಗ್ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಕಂಡುಹಿಡಿಯುವ ಸಾಮರ್ಥ್ಯ. ಅಂತರ್ನಿರ್ಮಿತ ತಂತಿಗಳಿಗಾಗಿ, ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಎರಡು ಷರತ್ತುಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕು: ಚಾರ್ str = 0; //... ವೇಳೆ (! str || ! *str) ಹಿಂತಿರುಗಿ;

C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಸ್ಟ್ರಿಂಗ್ ಕ್ಲಾಸ್ ಈ ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ (ಮತ್ತು ಹೆಚ್ಚು, ನಾವು ಅಧ್ಯಾಯ 6 ರಲ್ಲಿ ನೋಡುತ್ತೇವೆ). ಈ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಈ ವರ್ಗದ ಮೂಲ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ಕಲಿಯುತ್ತೇವೆ.
ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ವಸ್ತುಗಳನ್ನು ಬಳಸಲು, ನೀವು ಅನುಗುಣವಾದ ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:

#ಸೇರಿಸು

ಹಿಂದಿನ ವಿಭಾಗದಿಂದ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ, ಪ್ರಕಾರದ ಸ್ಟ್ರಿಂಗ್‌ನ ವಸ್ತುವಿನಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅಕ್ಷರ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ:

#ಸೇರಿಸು ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ ("ವೈನ್ ಬಾಟಲಿಯ ಬೆಲೆ\n");

ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಗಾತ್ರ() ಸದಸ್ಯ ಕಾರ್ಯದಿಂದ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ (ಉದ್ದವು ಅಂತ್ಯಗೊಳ್ಳುವ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಒಳಗೊಂಡಿಲ್ಲ).

ಕೌಟ್<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

ಸ್ಟ್ರಿಂಗ್ ವ್ಯಾಖ್ಯಾನದ ಎರಡನೇ ರೂಪವು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ:

ಸ್ಟ್ರಿಂಗ್ st2; // ಖಾಲಿ ಸಾಲು

ಸ್ಟ್ರಿಂಗ್ ಖಾಲಿಯಾಗಿದೆ ಎಂದು ನಮಗೆ ಹೇಗೆ ತಿಳಿಯುವುದು? ಸಹಜವಾಗಿ, ನೀವು ಅದರ ಉದ್ದವನ್ನು 0 ನೊಂದಿಗೆ ಹೋಲಿಸಬಹುದು:

ಒಂದು ವೇಳೆ (! st.size()) // ಸರಿಯಾಗಿದ್ದರೆ: ಖಾಲಿ

ಆದಾಗ್ಯೂ, ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುವ ಖಾಲಿ() ಒಂದು ವಿಶೇಷ ವಿಧಾನವೂ ಇದೆ ಮತ್ತು ಖಾಲಿ ಅಲ್ಲದ ಒಂದಕ್ಕೆ ತಪ್ಪು:

(st.empty()) // ಸರಿಯಾಗಿದ್ದರೆ: ಖಾಲಿ

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಮೂರನೇ ರೂಪವು ಅದೇ ಪ್ರಕಾರದ ಇನ್ನೊಂದು ವಸ್ತುವಿನೊಂದಿಗೆ ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್‌ನ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ:

ಸ್ಟ್ರಿಂಗ್ st3(st);

ಸ್ಟ್ರಿಂಗ್ st3 ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಈ ತಂತಿಗಳು ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತವೆ ಎಂದು ನಾವು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು? ಹೋಲಿಕೆ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸೋಣ (==):

ಒಂದು ವೇಳೆ (st == st3) // ಆರಂಭಿಸುವಿಕೆ ಕೆಲಸ ಮಾಡಿದ್ದರೆ

ಒಂದು ಸಾಲನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸುವುದು ಹೇಗೆ? ಸಾಮಾನ್ಯ ನಿಯೋಜನೆ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು:

St2 = st3; // st3 ಅನ್ನು st2 ಗೆ ನಕಲಿಸಿ

ತಂತಿಗಳನ್ನು ಜೋಡಿಸಲು, ಸೇರ್ಪಡೆ (+) ಅಥವಾ ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಯೊಂದಿಗೆ (+=) ಸೇರ್ಪಡೆ ಬಳಸಿ. ಎರಡು ಸಾಲುಗಳನ್ನು ನೀಡೋಣ:

ಸ್ಟ್ರಿಂಗ್ s1("ಹಲೋ,"); ಸ್ಟ್ರಿಂಗ್ s2("ವರ್ಲ್ಡ್\n");

ಮೊದಲ ಎರಡರ ಸಂಯೋಜನೆಯನ್ನು ಒಳಗೊಂಡಿರುವ ಮೂರನೇ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಾವು ಈ ರೀತಿ ಪಡೆಯಬಹುದು:

ಸ್ಟ್ರಿಂಗ್ s3 = s1 + s2;

ನಾವು s2 ಅನ್ನು s1 ನ ಅಂತ್ಯಕ್ಕೆ ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಬರೆಯಬೇಕು:

S1 += s2;

ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆಯು ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ವಸ್ತುಗಳನ್ನು ಪರಸ್ಪರ ಮಾತ್ರವಲ್ಲದೆ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ತಂತಿಗಳೊಂದಿಗೆ ಕೂಡಿಸಬಹುದು. ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ನೀವು ಪುನಃ ಬರೆಯಬಹುದು ಇದರಿಂದ ವಿಶೇಷ ಅಕ್ಷರಗಳು ಮತ್ತು ವಿರಾಮ ಚಿಹ್ನೆಗಳನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅರ್ಥಪೂರ್ಣ ಪದಗಳನ್ನು ವರ್ಗ ಸ್ಟ್ರಿಂಗ್‌ನ ವಸ್ತುಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಚಾರ್ *pc = ", "; ಸ್ಟ್ರಿಂಗ್ s1 ("ಹಲೋ"); ಸ್ಟ್ರಿಂಗ್ s2("ಜಗತ್ತು");
ಸ್ಟ್ರಿಂಗ್ s3 = s1 + pc + s2 + "\n";

ಅಂತಹ ಅಭಿವ್ಯಕ್ತಿಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಏಕೆಂದರೆ ಕಂಪೈಲರ್ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ವಸ್ತುಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ವಸ್ತುಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿದಿದೆ. ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸರಳವಾಗಿ ನಿಯೋಜಿಸಲು ಸಹ ಸಾಧ್ಯವಿದೆ:

ಸ್ಟ್ರಿಂಗ್ s1; const char *pc = "ಒಂದು ಅಕ್ಷರ ಶ್ರೇಣಿ"; s1 = ಪಿಸಿ; // ಸರಿ

ಆದಾಗ್ಯೂ, ಹಿಮ್ಮುಖ ಪರಿವರ್ತನೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಕೆಳಗಿನ ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾರಂಭವನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವುದು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ:

ಚಾರ್ * str = s1; // ಸಂಕಲನ ದೋಷ

ಈ ಪರಿವರ್ತನೆಯನ್ನು ಸಾಧಿಸಲು, ನೀವು ಸ್ವಲ್ಪ ವಿಚಿತ್ರವಾಗಿ ಹೆಸರಿಸಲಾದ c_str() ಸದಸ್ಯರ ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕರೆಯಬೇಕು:

ಚಾರ್ * str = s1.c_str (); // ಬಹುತೇಕ ಸರಿಯಾಗಿದೆ

c_str() ಕಾರ್ಯವು ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಅಕ್ಷರ ರಚನೆಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅದು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದಲ್ಲಿ ಗೋಚರಿಸುತ್ತದೆ.
char *str ಪಾಯಿಂಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೇಲಿನ ಉದಾಹರಣೆಯು ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಸರಿಯಾಗಿಲ್ಲ. c_str() ಈ ಪಾಯಿಂಟರ್‌ನಿಂದ ವಸ್ತುವಿನ ವಿಷಯಗಳನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸುವುದನ್ನು ತಡೆಯಲು ಸ್ಥಿರ ಶ್ರೇಣಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ

ಕಾನ್ಸ್ಟ್ ಚಾರ್ *

(ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ನಾವು const ಕೀವರ್ಡ್ ಅನ್ನು ಕವರ್ ಮಾಡುತ್ತೇವೆ.) ಸರಿಯಾದ ಆರಂಭಿಕ ಆಯ್ಕೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಚಾರ್ * str = s1.c_str (); // ಸರಿ

ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳು, ಅಂತರ್ನಿರ್ಮಿತ ರೀತಿಯಂತೆ, ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರವೇಶಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ ಅವಧಿಗಳನ್ನು ಅಂಡರ್‌ಸ್ಕೋರ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವ ಕೋಡ್‌ನ ತುಣುಕು ಇಲ್ಲಿದೆ:

ಸ್ಟ್ರಿಂಗ್ str("fa.disney.com"); ಇಂಟ್ ಗಾತ್ರ = str.size(); ಗಾಗಿ (int ix = 0; ix< size; ++ix) if (str[ ix ] == ".")
str[ ix ] = "_";

ನಾವು ಇದೀಗ ಸ್ಟ್ರಿಂಗ್ ಕ್ಲಾಸ್ ಬಗ್ಗೆ ಹೇಳಲು ಬಯಸಿದ್ದೇವೆ ಅಷ್ಟೆ. ವಾಸ್ತವವಾಗಿ, ಈ ವರ್ಗವು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಒಂದೇ ಬದಲಿ () ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಹಿಂದಿನ ಉದಾಹರಣೆಯನ್ನು ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳೋಣ:

ಬದಲಾಯಿಸಿ(str.begin(), str.end(), ".", "_");

ರಿಪ್ಲೇಸ್() ಎನ್ನುವುದು ನಾವು ವಿಭಾಗ 2.8 ರಲ್ಲಿ ಪರಿಚಯಿಸಿದ ಸಾಮಾನ್ಯ ಅಲ್ಗಾರಿದಮ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ಅಧ್ಯಾಯ 12 ರಲ್ಲಿ ವಿವರವಾಗಿ ಚರ್ಚಿಸಲಾಗುವುದು. ಈ ಕಾರ್ಯವು ಪ್ರಾರಂಭ() ನಿಂದ ಅಂತ್ಯ() ವರೆಗಿನ ಶ್ರೇಣಿಯ ಮೂಲಕ ಸಾಗುತ್ತದೆ, ಇದು ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ , ಅದರ ಮೂರನೇ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ನಾಲ್ಕನೆಯದಕ್ಕೆ.

ವ್ಯಾಯಾಮ 3.12

ಕೆಳಗಿನ ಹೇಳಿಕೆಗಳಲ್ಲಿ ದೋಷಗಳನ್ನು ಹುಡುಕಿ:

(ಎ) ಚಾರ್ ಚ್ = "ದೀರ್ಘ ಮತ್ತು ಅಂಕುಡೊಂಕಾದ ರಸ್ತೆ"; (ಬಿ) ಇಂಟ್ ಇವಾಲ್ = (ಸಿ) ಚಾರ್ * ಪಿಸಿ = (ಡಿ) ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ (& ಸಿ); (ಇ) ಪಿಸಿ = 0; (i) ಪಿಸಿ = "0";
(ಎಫ್) ಸ್ಟ = ಪಿಸಿ; (ಜೆ) ಸ್ಟ =
(ಜಿ) ಚ = ಪಿಸಿ; (k) ch = *pc;
(h) ಪಿಸಿ = ಸ್ಟ; (l) *pc = ival;

ವ್ಯಾಯಾಮ 3.13

ಕೆಳಗಿನ ಲೂಪ್ ಹೇಳಿಕೆಗಳ ವರ್ತನೆಯ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸಿ:

ಆದರೆ (st++) ++cnt;
ಸಮಯದಲ್ಲಿ (*st++)
++cnt;

ವ್ಯಾಯಾಮ 3.14

ಎರಡು ಶಬ್ದಾರ್ಥದ ಸಮಾನ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನೀಡಲಾಗಿದೆ. ಮೊದಲನೆಯದು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವನ್ನು ಬಳಸುತ್ತದೆ, ಎರಡನೆಯದು ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವನ್ನು ಬಳಸುತ್ತದೆ:

// ***** ಸಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಷ್ಠಾನ ***** #ಸೇರಿಸು #ಸೇರಿಸು
ಇಂಟ್ ಮುಖ್ಯ()
{
ಇಂಟ್ ದೋಷಗಳು = 0;
const char *pc = "ಬಹಳ ಉದ್ದದ ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್"; ಗಾಗಿ (int ix = 0; ix< 1000000; ++ix)
{
ಇಂಟ್ ಲೆನ್ = strlen (pc);
ಚಾರ್ *pc2 = ಹೊಸ ಚಾರ್ [ಲೆನ್ + 1];
strcpy (pc2, pc);
ವೇಳೆ (strcmp(pc2, pc))
++ ದೋಷಗಳು; ಪಿಸಿ 2 ಅನ್ನು ಅಳಿಸಿ;
}
ಕೌಟ್<< "C-строки: "
<< errors << " ошибок.\n";
) // ***** ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಷ್ಠಾನ ***** #ಸೇರಿಸು
#ಸೇರಿಸು
ಇಂಟ್ ಮುಖ್ಯ()
{
ಇಂಟ್ ದೋಷಗಳು = 0;
ಸ್ಟ್ರಿಂಗ್ str ("ಬಹಳ ಉದ್ದದ ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್"); ಗಾಗಿ (int ix = 0; ix< 1000000; ++ix)
{
ಇಂಟ್ ಲೆನ್ = str.size();
ಸ್ಟ್ರಿಂಗ್ str2 = str;
ವೇಳೆ (str != str2)
}
ಕೌಟ್<< "класс string: "
<< errors << " ошибок.\n;
}

ಈ ಕಾರ್ಯಕ್ರಮಗಳು ಏನು ಮಾಡುತ್ತವೆ?
ಎರಡನೆಯ ಅನುಷ್ಠಾನವು ಮೊದಲನೆಯದಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ವೇಗವಾಗಿ ಚಲಿಸುತ್ತದೆ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ. ಅಂತಹ ಫಲಿತಾಂಶವನ್ನು ನೀವು ನಿರೀಕ್ಷಿಸಿದ್ದೀರಾ? ನೀವು ಅದನ್ನು ಹೇಗೆ ವಿವರಿಸುತ್ತೀರಿ?

ವ್ಯಾಯಾಮ 3.15

ಕೊನೆಯ ವಿಭಾಗದಲ್ಲಿ ನೀಡಲಾದ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ಕಾರ್ಯಾಚರಣೆಗಳ ಸೆಟ್‌ಗೆ ನೀವು ಏನನ್ನಾದರೂ ಸುಧಾರಿಸಬಹುದೇ ಅಥವಾ ಸೇರಿಸಬಹುದೇ? ನಿಮ್ಮ ಪ್ರಸ್ತಾಪಗಳನ್ನು ವಿವರಿಸಿ

3.5 const ಸ್ಪೆಸಿಫೈಯರ್

ಕೆಳಗಿನ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ:

ಇದಕ್ಕಾಗಿ (ಇಂಟ್ ಇಂಡೆಕ್ಸ್ = 0; ಇಂಡೆಕ್ಸ್< 512; ++index) ... ;

512 ಅಕ್ಷರಶಃ ಬಳಸುವುದರಲ್ಲಿ ಎರಡು ಸಮಸ್ಯೆಗಳಿವೆ. ಮೊದಲನೆಯದು ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯದ ಗ್ರಹಿಕೆಯ ಸುಲಭವಾಗಿದೆ. ಲೂಪ್ ವೇರಿಯೇಬಲ್‌ನ ಮೇಲಿನ ಬೌಂಡ್ ನಿಖರವಾಗಿ 512 ಆಗಿರಬೇಕು ಏಕೆ? ಈ ಮೌಲ್ಯದ ಹಿಂದೆ ಏನು ಅಡಗಿದೆ? ಅವಳು ಆಕಸ್ಮಿಕವಾಗಿ ತೋರುತ್ತಾಳೆ ...
ಎರಡನೆಯ ಸಮಸ್ಯೆಯು ಕೋಡ್‌ನ ಮಾರ್ಪಾಡು ಮತ್ತು ನಿರ್ವಹಣೆಯ ಸುಲಭತೆಗೆ ಸಂಬಂಧಿಸಿದೆ. ಪ್ರೋಗ್ರಾಂ 10,000 ಸಾಲುಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅಕ್ಷರಶಃ 512 ಅವುಗಳಲ್ಲಿ 4% ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ ಎಂದು ಹೇಳೋಣ. 80% ಪ್ರಕರಣಗಳಲ್ಲಿ 512 ಸಂಖ್ಯೆಯನ್ನು 1024 ಗೆ ಬದಲಾಯಿಸಬೇಕು ಎಂದು ಹೇಳೋಣ. ಅಂತಹ ಕೆಲಸದ ಸಂಕೀರ್ಣತೆ ಮತ್ತು ತಪ್ಪು ಮೌಲ್ಯವನ್ನು ಸರಿಪಡಿಸುವ ಮೂಲಕ ಮಾಡಬಹುದಾದ ತಪ್ಪುಗಳ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ಊಹಿಸಬಹುದೇ?
ನಾವು ಈ ಎರಡೂ ಸಮಸ್ಯೆಗಳನ್ನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಪರಿಹರಿಸುತ್ತೇವೆ: ನಾವು 512 ಮೌಲ್ಯದೊಂದಿಗೆ ವಸ್ತುವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಬಫ್‌ಸೈಜ್‌ನಂತಹ ಅರ್ಥಪೂರ್ಣ ಹೆಸರನ್ನು ನೀಡಿ, ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೆಚ್ಚು ಅರ್ಥವಾಗುವಂತೆ ಮಾಡುತ್ತೇವೆ: ಲೂಪ್ ವೇರಿಯಬಲ್ ಅನ್ನು ನಿಖರವಾಗಿ ಹೋಲಿಸುವುದು ಸ್ಪಷ್ಟವಾಗಿದೆ ಗೆ.

ಸೂಚ್ಯಂಕ< bufSize

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬಫ್‌ಸೈಜ್‌ನ ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸುವುದರಿಂದ ಅವುಗಳಲ್ಲಿ 320 ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಕೋಡ್‌ನ 400 ಸಾಲುಗಳ ಮೂಲಕ ಹೋಗುವ ಅಗತ್ಯವಿಲ್ಲ. ಕೇವಲ ಒಂದು ವಸ್ತುವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ದೋಷಗಳ ಸಾಧ್ಯತೆಯು ಎಷ್ಟು ಕಡಿಮೆಯಾಗುತ್ತದೆ! ಈಗ ಮೌಲ್ಯ 512 ಆಗಿದೆ ಸ್ಥಳೀಕರಿಸಲಾಗಿದೆ.

ಇಂಟ್ ಬಫ್ ಸೈಜ್ = 512; // ಇನ್‌ಪುಟ್ ಬಫರ್ ಗಾತ್ರ // ... ಗಾಗಿ (ಇಂಟ್ ಸೂಚ್ಯಂಕ = 0; ಸೂಚ್ಯಂಕ< bufSize; ++index)
// ...

ಒಂದು ಸಣ್ಣ ಸಮಸ್ಯೆ ಉಳಿದಿದೆ: ಇಲ್ಲಿ bufSize ವೇರಿಯೇಬಲ್ ಒಂದು l-ಮೌಲ್ಯವಾಗಿದ್ದು ಅದು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಆಕಸ್ಮಿಕವಾಗಿ ಬದಲಾಗಬಹುದು, ಇದು ಹಾರ್ಡ್-ಟು-ಕ್ಯಾಚ್ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಒಂದು ಸಾಮಾನ್ಯ ತಪ್ಪು ಇಲ್ಲಿದೆ: ಹೋಲಿಕೆ ಆಪರೇಟರ್ (==) ಬದಲಿಗೆ ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್ (=) ಅನ್ನು ಬಳಸುವುದು:

// ಬಫ್‌ಸೈಜ್ ಮೌಲ್ಯದಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಬದಲಾವಣೆ (bufSize = 1) // ...

ಈ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದರಿಂದ bufSize ಮೌಲ್ಯವು 1 ಆಗಿರುತ್ತದೆ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಅನಿರೀಕ್ಷಿತ ಪ್ರೋಗ್ರಾಂ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಈ ರೀತಿಯ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಸಾಮಾನ್ಯವಾಗಿ ತುಂಬಾ ಕಷ್ಟ ಏಕೆಂದರೆ ಅವುಗಳು ಸರಳವಾಗಿ ಗೋಚರಿಸುವುದಿಲ್ಲ.
ಕಾನ್ಸ್ಟ್ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಬಳಸುವುದು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ವಸ್ತುವನ್ನು ಎಂದು ಘೋಷಿಸುವ ಮೂಲಕ

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಬಫ್ಸೈಜ್ = 512; // ಇನ್ಪುಟ್ ಬಫರ್ ಗಾತ್ರ

ನಾವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಮೌಲ್ಯ 512 ರೊಂದಿಗೆ ಸ್ಥಿರವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ, ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ: ಅಂತಹ ಪ್ರಯತ್ನಗಳನ್ನು ಕಂಪೈಲರ್‌ನಿಂದ ನಿಗ್ರಹಿಸಲಾಗುತ್ತದೆ: ಹೋಲಿಕೆಯ ಬದಲಿಗೆ ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್‌ನ ತಪ್ಪಾದ ಬಳಕೆ, ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ, ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

// ದೋಷ: ಸ್ಥಿರಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ (bufSize = 0) ...

ಸ್ಥಿರಾಂಕವನ್ನು ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಸ್ಥಳದಲ್ಲಿ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು. ಸ್ಥಿರಾಂಕವನ್ನು ಪ್ರಾರಂಭಿಸದೆ ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಡಬಲ್ ಪೈ; // ದೋಷ: ಪ್ರಾರಂಭಿಸದ ಸ್ಥಿರ

ಕಾನ್ಸ್ಟ್ ಡಬಲ್ ಮಿನಿವೇಜ್ = 9.60; // ಸರಿ? ದೋಷ?
ಡಬಲ್ * ptr =

ಕಂಪೈಲರ್ ಅಂತಹ ನಿಯೋಜನೆಯನ್ನು ಅನುಮತಿಸಬೇಕೇ? minWage ಸ್ಥಿರವಾಗಿರುವುದರಿಂದ, ಅದಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ. ಮತ್ತೊಂದೆಡೆ, ಯಾವುದೂ ನಮ್ಮನ್ನು ಬರೆಯದಂತೆ ತಡೆಯುವುದಿಲ್ಲ:

*ptr += 1.40; // minWage ವಸ್ತುವನ್ನು ಬದಲಾಯಿಸುವುದು!

ನಿಯಮದಂತೆ, ಕಂಪೈಲರ್ ಪಾಯಿಂಟರ್‌ಗಳ ಬಳಕೆಯ ವಿರುದ್ಧ ರಕ್ಷಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಮತ್ತು ಈ ರೀತಿ ಬಳಸಿದರೆ ದೋಷವನ್ನು ಸೂಚಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಇದಕ್ಕೆ ಪ್ರೋಗ್ರಾಂ ತರ್ಕದ ಆಳವಾದ ವಿಶ್ಲೇಷಣೆಯ ಅಗತ್ಯವಿದೆ. ಆದ್ದರಿಂದ, ಕಂಪೈಲರ್ ಸಾಮಾನ್ಯ ಪಾಯಿಂಟರ್‌ಗಳಿಗೆ ಸ್ಥಿರ ವಿಳಾಸಗಳ ನಿಯೋಜನೆಯನ್ನು ಸರಳವಾಗಿ ನಿಷೇಧಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ, ಸ್ಥಿರಾಂಕಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಸಾಮರ್ಥ್ಯದಿಂದ ನಾವು ವಂಚಿತರಾಗಿದ್ದೇವೆಯೇ? ಸಂ. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ, const ಸ್ಪೆಸಿಫೈಯರ್‌ನೊಂದಿಗೆ ಘೋಷಿಸಲಾದ ಪಾಯಿಂಟರ್‌ಗಳಿವೆ:

ಕಾನ್ಸ್ಟ್ ಡಬಲ್ * ಸಿಪಿಟಿಆರ್;

ಇಲ್ಲಿ cptr ಎಂಬುದು ಒಂದು ವಸ್ತುವಿನ ಒಂದು ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಸೂಕ್ಷ್ಮತೆಯೆಂದರೆ ಪಾಯಿಂಟರ್ ಸ್ವತಃ ಸ್ಥಿರವಾಗಿಲ್ಲ, ಅಂದರೆ ನಾವು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಕಾನ್ಸ್ಟ್ ಡಬಲ್ * ಪಿಸಿ = 0; const ಡಬಲ್ ಮಿನಿವೇಜ್ = 9.60; // ಸರಿ: ನಾವು ಪಿಸಿ ಬಳಸಿ minWage ಅನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
pc = ಡಬಲ್ dval = 3.14; // ಸರಿ: ನಾವು ಪಿಸಿ ಬಳಸಿ minWage ಅನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
// ಆದಾಗ್ಯೂ dval ಸ್ಥಿರವಾಗಿಲ್ಲ
pc = // ಸರಿಯಾದ dval = 3.14159; //ಸರಿ
* ಪಿಸಿ = 3.14159; // ದೋಷ

ಸ್ಥಿರ ವಸ್ತುವಿನ ವಿಳಾಸವನ್ನು ಸ್ಥಿರಕ್ಕೆ ಪಾಯಿಂಟರ್‌ಗೆ ಮಾತ್ರ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಅಂತಹ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸಾಮಾನ್ಯ ವೇರಿಯಬಲ್ನ ವಿಳಾಸವನ್ನು ಸಹ ನಿಯೋಜಿಸಬಹುದು:

ಪಿಸಿ =

ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್ ಪರೋಕ್ಷ ವಿಳಾಸವನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಸಂಬೋಧಿಸುವ ವಸ್ತುವನ್ನು ಮಾರ್ಪಡಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ dval ಸ್ಥಿರವಾಗಿಲ್ಲದಿದ್ದರೂ, ಕಂಪೈಲರ್ dval ಅನ್ನು ಪಿಸಿ ಮೂಲಕ ಬದಲಾಯಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ. (ಮತ್ತೆ, ಏಕೆಂದರೆ ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದಲ್ಲಿ ಯಾವ ವಸ್ತುವಿನ ವಿಳಾಸವು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೊಂದಿರಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.)
ನೈಜ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ, ಸ್ಥಿರಾಂಕಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಕಾರ್ಯಗಳ ಔಪಚಾರಿಕ ನಿಯತಾಂಕಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಅವುಗಳ ಬಳಕೆಯು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ನಿಜವಾದ ವಾದದಂತೆ ರವಾನಿಸಲಾದ ವಸ್ತುವನ್ನು ಆ ಕಾರ್ಯದಿಂದ ಮಾರ್ಪಡಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

// ನೈಜ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ, ಸ್ಥಿರಾಂಕಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ // ಇಂಟ್ strcmp (const char *str1, const char *str2) ಕಾರ್ಯಗಳ ಔಪಚಾರಿಕ ನಿಯತಾಂಕಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ;

(ನಾವು ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ ಅಧ್ಯಾಯ 7 ರಲ್ಲಿ ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್‌ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ಮಾತನಾಡುತ್ತೇವೆ.)
ನಿರಂತರ ಸೂಚಕಗಳೂ ಇವೆ. (ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಮತ್ತು ಸ್ಥಿರಾಂಕದ ಪಾಯಿಂಟರ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸಿ!). ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಸ್ಥಿರ ಅಥವಾ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪರಿಹರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

Int errNumb = 0; int *const currErr =

ಇಲ್ಲಿ curErr ಎಂಬುದು ನಾನ್-ಕಾನ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಇದರರ್ಥ ನಾವು ಅದನ್ನು ಮತ್ತೊಂದು ವಸ್ತುವಿನ ವಿಳಾಸವನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೂ ವಸ್ತುವನ್ನು ಸ್ವತಃ ಮಾರ್ಪಡಿಸಬಹುದು. curErr ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಏನಾದರೂ_ಮಾಡು(); ವೇಳೆ (*curErr) (
ದೋಷ ಹ್ಯಾಂಡ್ಲರ್ ();
*curErr = 0; // ಸರಿ: errNumb ಮೌಲ್ಯವನ್ನು ಮರುಹೊಂದಿಸಿ
}

ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸುವುದರಿಂದ ಸಂಕಲನ ದೋಷ ಉಂಟಾಗುತ್ತದೆ:

CurErr = // ದೋಷ

ಸ್ಥಿರಾಂಕಕ್ಕೆ ಸ್ಥಿರವಾದ ಸೂಚಕವು ಪರಿಗಣಿಸಲಾದ ಎರಡು ಪ್ರಕರಣಗಳ ಒಕ್ಕೂಟವಾಗಿದೆ.

ಕಾನ್ಸ್ಟ್ ಡಬಲ್ ಪೈ = 3.14159; const ಡಬಲ್ * const pi_ptr = π

pi_ptr ನಿಂದ ಸೂಚಿಸಲಾದ ವಸ್ತುವಿನ ಮೌಲ್ಯ ಅಥವಾ ಪಾಯಿಂಟರ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ.

ವ್ಯಾಯಾಮ 3.16

ಕೆಳಗಿನ ಐದು ವ್ಯಾಖ್ಯಾನಗಳ ಅರ್ಥವನ್ನು ವಿವರಿಸಿ. ಅವುಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ತಪ್ಪಾಗಿದೆಯೇ?

(ಎ) ಇಂಟ್ ನಾನು; (d) int *const cpi; (ಬಿ) const int IC; (ಇ) const int *const cpic; (ಸಿ) ಕಾನ್ಸ್ಟ್ ಇಂಟ್ * ಚಿತ್ರ;

ವ್ಯಾಯಾಮ 3.17

ಕೆಳಗಿನ ಯಾವ ವ್ಯಾಖ್ಯಾನಗಳು ಸರಿಯಾಗಿವೆ? ಏಕೆ?

(a) int i = -1; (b) const int ic = i; (ಸಿ) const int * pic = (d) int * const cpi = (e) const int * const cpic =

ವ್ಯಾಯಾಮ 3.18

ಹಿಂದಿನ ವ್ಯಾಯಾಮದಿಂದ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಬಳಸಿ, ಸರಿಯಾದ ನಿಯೋಜನೆ ನಿರ್ವಾಹಕರನ್ನು ಗುರುತಿಸಿ. ವಿವರಿಸಿ.

(a) i = ic; (ಡಿ) ಚಿತ್ರ = cpic; (b) ಚಿತ್ರ = (i) cpic = (c) cpi = ಚಿತ್ರ; (ಎಫ್) ic = *cpic;

3.6. ಉಲ್ಲೇಖದ ಪ್ರಕಾರ

ಒಂದು ಉಲ್ಲೇಖ ಪ್ರಕಾರವನ್ನು ಕೆಲವೊಮ್ಮೆ ಅಲಿಯಾಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ವಸ್ತುವಿಗೆ ಹೆಚ್ಚುವರಿ ಹೆಸರನ್ನು ನೀಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪಾಯಿಂಟರ್‌ನೊಂದಿಗೆ ನೀವು ಮಾಡಬಹುದಾದಂತಹ ವಸ್ತುವನ್ನು ಪರೋಕ್ಷವಾಗಿ ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಉಲ್ಲೇಖವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ಪರೋಕ್ಷ ಕುಶಲತೆಯು ಪಾಯಿಂಟರ್‌ಗಳಿಗೆ ಅಗತ್ಯವಿರುವ ವಿಶೇಷ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ವಿಶಿಷ್ಟವಾಗಿ, ಉಲ್ಲೇಖಗಳನ್ನು ಕಾರ್ಯಗಳ ಔಪಚಾರಿಕ ನಿಯತಾಂಕಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ನಮ್ಮದೇ ಆದ ಉಲ್ಲೇಖ ಪ್ರಕಾರದ ವಸ್ತುಗಳನ್ನು ಬಳಸುವುದನ್ನು ನೋಡುತ್ತೇವೆ.
ವೇರಿಯಬಲ್ ಹೆಸರಿನ ಮೊದಲು ವಿಳಾಸ ಆಪರೇಟರ್ (&) ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ಉಲ್ಲೇಖದ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಲಿಂಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು. ಉದಾಹರಣೆಗೆ:

ಇಂಟ್ ಇವಾಲ್ = 1024; // ಸರಿ: refVal - ival int ಗೆ ಉಲ್ಲೇಖ &refVal = ival; // ದೋಷ: ಉಲ್ಲೇಖವನ್ನು ಇಂಟ್‌ಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು

ಇಂಟ್ ಇವಾಲ್ = 1024; // ದೋಷ: refVal int ಪ್ರಕಾರವಾಗಿದೆ, int * ಇಂಟ್ ಅಲ್ಲ &refVal = int *pi = // ಸರಿ: ptrVal ಎಂಬುದು ಪಾಯಿಂಟರ್ ಇಂಟ್ *&ptrVal2 = pi;

ಉಲ್ಲೇಖವನ್ನು ಒಮ್ಮೆ ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ನೀವು ಅದನ್ನು ಮತ್ತೊಂದು ವಸ್ತುವಿನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ (ಅದಕ್ಕಾಗಿಯೇ ಉಲ್ಲೇಖವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಸ್ಥಳದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು). ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್ refVal ನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ; ಹೊಸ ಮೌಲ್ಯವನ್ನು ವೇರಿಯೇಬಲ್ ival ಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ, ಅದು refVal ವಿಳಾಸಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಇಂಟ್ min_val = 0; // ival min_val ನ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ, // refVal ಬದಲಿಗೆ ಮೌಲ್ಯವನ್ನು min_val refVal = min_val ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ;

RefVal += 2; ival ಗೆ 2 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, refVal ನಿಂದ ಉಲ್ಲೇಖಿಸಲಾದ ವೇರಿಯಬಲ್. ಹಾಗೆಯೇ ಇಂಟ್ ii = refVal; ival ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ, int *pi = ival ನ ವಿಳಾಸದೊಂದಿಗೆ pi ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

// int ಪ್ರಕಾರದ ಎರಡು ವಸ್ತುಗಳನ್ನು int ival = 1024, ival2 = 2048 ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ; // ಒಂದು ಉಲ್ಲೇಖ ಮತ್ತು ಒಂದು ವಸ್ತುವನ್ನು int &rval = ival, rval2 = ival2; // ಒಂದು ವಸ್ತು, ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು ಒಂದು ಉಲ್ಲೇಖವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
int inal3 = 1024, *pi = ival3, &ri = ival3; // ಎರಡು ಲಿಂಕ್‌ಗಳನ್ನು ಇಂಟ್ &rval3 = ival3, &rval4 = ival2;

ಕಾನ್ಸ್ಟ್ ಉಲ್ಲೇಖವನ್ನು ಮತ್ತೊಂದು ಪ್ರಕಾರದ ವಸ್ತುವಿನಿಂದ ಪ್ರಾರಂಭಿಸಬಹುದು (ಸಹಜವಾಗಿ, ಒಂದು ಪ್ರಕಾರವನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಸಾಧ್ಯವಿದೆ ಎಂದು ಊಹಿಸಿ), ಹಾಗೆಯೇ ಅಕ್ಷರಶಃ ಸ್ಥಿರಾಂಕದಂತಹ ವಿಳಾಸರಹಿತ ಮೌಲ್ಯದಿಂದ. ಉದಾಹರಣೆಗೆ:

ಡಬಲ್ dval = 3.14159; // ನಿರಂತರ ಉಲ್ಲೇಖಗಳಿಗೆ ಮಾತ್ರ ನಿಜ
const int &ir = 1024;
const int &ir2 = dval;
const ಡಬಲ್ &dr = dval + 1.0;

ನಾವು ಕಾನ್ಸ್ಟ್ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಎಲ್ಲಾ ಮೂರು ಉಲ್ಲೇಖದ ವ್ಯಾಖ್ಯಾನಗಳು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಕಂಪೈಲರ್ ಅಂತಹ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಏಕೆ ರವಾನಿಸುವುದಿಲ್ಲ ಎಂಬುದು ಅಸ್ಪಷ್ಟವಾಗಿದೆ. ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಪ್ರಯತ್ನಿಸೋಣ.
ಅಕ್ಷರಗಳಿಗೆ, ಇದು ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಸ್ಪಷ್ಟವಾಗಿದೆ: ಪಾಯಿಂಟರ್‌ಗಳು ಅಥವಾ ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಕ್ಷರಶಃ ಮೌಲ್ಯವನ್ನು ಪರೋಕ್ಷವಾಗಿ ಬದಲಾಯಿಸಲು ನಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಇತರ ಪ್ರಕಾರದ ವಸ್ತುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಕಂಪೈಲರ್ ಮೂಲ ವಸ್ತುವನ್ನು ಕೆಲವು ಸಹಾಯಕ ವಸ್ತುವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಬರೆದರೆ:

ಡಬಲ್ dval = 1024; const int &ri = dval;

ನಂತರ ಕಂಪೈಲರ್ ಅದನ್ನು ಈ ರೀತಿಯಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ:

ಇಂಟ್ ಟೆಂಪ್ = dval; const int &ri = temp;

ನಾವು ri ಉಲ್ಲೇಖಕ್ಕೆ ಹೊಸ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಾದರೆ, ನಾವು ನಿಜವಾಗಿ dval ಅಲ್ಲ, ಆದರೆ temp ಅನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ. dval ಮೌಲ್ಯವು ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಇದು ಪ್ರೋಗ್ರಾಮರ್ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಅಸ್ಪಷ್ಟವಾಗಿದೆ. ಆದ್ದರಿಂದ, ಕಂಪೈಲರ್ ಅಂತಹ ಕ್ರಿಯೆಗಳನ್ನು ನಿಷೇಧಿಸುತ್ತದೆ, ಮತ್ತು ಇನ್ನೊಂದು ಪ್ರಕಾರದ ವಸ್ತುವಿನೊಂದಿಗೆ ಉಲ್ಲೇಖವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ ಅದನ್ನು ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸುವುದು.
ಮೊದಲ ಬಾರಿಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ಲಿಂಕ್‌ನ ಇನ್ನೊಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. ಸ್ಥಿರ ವಸ್ತುವಿನ ವಿಳಾಸಕ್ಕೆ ನಾವು ಉಲ್ಲೇಖವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಯಸುತ್ತೇವೆ, ಆದರೆ ನಮ್ಮ ಮೊದಲ ಆಯ್ಕೆಯು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಇವಾಲ್ = 1024; // ದೋಷ: ನಿರಂತರ ಉಲ್ಲೇಖ ಅಗತ್ಯವಿದೆ
int *&pi_ref =

ಕಾನ್ಸ್ಟ್ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ವಿಷಯವನ್ನು ಸರಿಪಡಿಸುವ ಪ್ರಯತ್ನವೂ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಇವಾಲ್ = 1024; // ಇನ್ನೂ ಒಂದು ದೋಷ const int *&pi_ref =

ಏನು ಕಾರಣ? ನಾವು ವ್ಯಾಖ್ಯಾನವನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಓದಿದರೆ, pi_ref ಎಂಬುದು ಇಂಟ್ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್‌ಗೆ ಉಲ್ಲೇಖವಾಗಿದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಮತ್ತು ನಮಗೆ ಸ್ಥಿರ ವಸ್ತುವಿಗೆ ನಾನ್-ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ಕೆಳಗಿನ ನಮೂದು ಸರಿಯಾಗಿರುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಇವಾಲ್ = 1024; // ಸರಿ
int *const &piref =

ಲಿಂಕ್ ಮತ್ತು ಪಾಯಿಂಟರ್ ನಡುವೆ ಎರಡು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳಿವೆ. ಮೊದಲಿಗೆ, ಲಿಂಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸ್ಥಳದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು. ಎರಡನೆಯದಾಗಿ, ಲಿಂಕ್‌ಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಯು ಲಿಂಕ್ ಅಲ್ಲ, ಆದರೆ ಅದು ಸೂಚಿಸುವ ವಸ್ತುವನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ. ನಾವು ಬರೆದರೆ:

ಇಂಟ್ * ಪೈ = 0;

ನಾವು ಪಾಯಿಂಟರ್ ಪೈ ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಅಂದರೆ ಪೈ ಯಾವುದೇ ವಸ್ತುವನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ. ಅದೇ ಸಮಯದಲ್ಲಿ ರೆಕಾರ್ಡಿಂಗ್

const int &ri = 0;
ಈ ರೀತಿಯ ಅರ್ಥ:
ಇಂಟ್ ತಾಪಮಾನ = 0;
const int &ri = temp;

ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ:

Int ival = 1024, ival2 = 2048; int *pi = &ival, *pi2 = pi = pi2;

pi ಯಿಂದ ಸೂಚಿಸಲಾದ ವೇರಿಯೇಬಲ್ ival ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ ಮತ್ತು pi ವೇರಿಯೇಬಲ್ ival2 ನ ವಿಳಾಸದ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ. pi ಮತ್ತು pi2 ಎರಡೂ ಈಗ ಒಂದೇ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತವೆ, ival2.
ನಾವು ಲಿಂಕ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದರೆ:

Int &ri = ival, &ri2 = ival2; ರಿ = ರಿ2;

// ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ // ಮೌಲ್ಯವನ್ನು next_value ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ
bool get_next_value(int &next_value); // ಓವರ್‌ಲೋಡ್ಡ್ ಆಪರೇಟರ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಆಪರೇಟರ್+(ಕಾನ್ಸ್ಟ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್&, ಕಾನ್ಸ್ಟ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್&);

ಇಂಟ್ ಇವಾಲ್; ಹಾಗೆಯೇ (ನೆಕ್ಸ್ಟ್_ಮೌಲ್ಯ(ival)) ...

ಇಂಟ್ &next_value = ival;

(ಫಂಕ್ಷನ್‌ಗಳ ಔಪಚಾರಿಕ ನಿಯತಾಂಕಗಳಾಗಿ ಉಲ್ಲೇಖಗಳ ಬಳಕೆಯನ್ನು ಅಧ್ಯಾಯ 7 ರಲ್ಲಿ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಚರ್ಚಿಸಲಾಗಿದೆ.)

ವ್ಯಾಯಾಮ 3.19

ಈ ವ್ಯಾಖ್ಯಾನಗಳಲ್ಲಿ ಯಾವುದೇ ದೋಷಗಳಿವೆಯೇ? ವಿವರಿಸಿ. ನೀವು ಅವುಗಳನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸುತ್ತೀರಿ?

(ಎ) ಇಂಟ್ ಇವಾಲ್ = 1.01; (ಬಿ) ಇಂಟ್ &rval1 = 1.01; (c) int &rval2 = ival; (d) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (ಜಿ) ಇಂಟ್ &rval5 = ಪೈ*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (ಜೆ) const int &*prval2 =

ವ್ಯಾಯಾಮ 3.20

ಕೆಳಗಿನ ಯಾವುದೇ ನಿಯೋಜನೆ ಆಪರೇಟರ್‌ಗಳು ತಪ್ಪಾಗಿದೆಯೇ (ಹಿಂದಿನ ವ್ಯಾಯಾಮದಿಂದ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಬಳಸುವುದು)?

(a) rval1 = 3.14159; (b) prval1 = prval2; (ಸಿ) prval2 = rval1; (ಡಿ) *prval2 = ival2;

ವ್ಯಾಯಾಮ 3.21

ನೀಡಿರುವ ಸೂಚನೆಗಳಲ್ಲಿ ದೋಷಗಳನ್ನು ಹುಡುಕಿ:

(ಎ) ಇಂಟ್ ಇವಾಲ್ = 0; const int *pi = 0; const int &ri = 0; (ಬಿ) ಪೈ =
ರಿ =
ಪೈ =

3.7. bool ಎಂದು ಟೈಪ್ ಮಾಡಿ

ಬೂಲ್ ಪ್ರಕಾರದ ವಸ್ತುವು ಎರಡು ಮೌಲ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು: ಸರಿ ಮತ್ತು ತಪ್ಪು. ಉದಾಹರಣೆಗೆ:

// ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು search_word = get_word(); // ಕಂಡುಬರುವ ವೇರಿಯಬಲ್‌ನ ಪ್ರಾರಂಭ
bool ಕಂಡು = ತಪ್ಪು; ಸ್ಟ್ರಿಂಗ್ ಮುಂದಿನ_ಪದ; ಹಾಗೆಯೇ (ಸಿನ್ >> ಮುಂದಿನ_ಪದ)
ಒಂದು ವೇಳೆ (ಮುಂದಿನ_ಪದ == ಹುಡುಕಾಟ_ಪದ)
ಕಂಡು = ನಿಜ;
// ... // ಕಿರುಹೊತ್ತಿಗೆ: ವೇಳೆ (ಕಂಡುಬಂದ == ನಿಜ)
(ಕಂಡುಬಂದರೆ)
ಕೌಟ್<< "ok, мы нашли слово\n";
ಬೇರೆ ಕೌಟ್<< "нет, наше слово не встретилось.\n";

ಬೂಲ್ ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರಗಳಲ್ಲಿ ಒಂದಾಗಿದ್ದರೂ, ಅದನ್ನು ಸಹಿ, ಸಹಿ ಮಾಡದ, ಚಿಕ್ಕ ಅಥವಾ ಉದ್ದ ಎಂದು ಘೋಷಿಸಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಮೇಲಿನ ವ್ಯಾಖ್ಯಾನವು ತಪ್ಪಾಗಿದೆ:

// ದೋಷ ಶಾರ್ಟ್ ಬೂಲ್ ಕಂಡುಬಂದಿದೆ = ತಪ್ಪು;

ಟೈಪ್ ಬೂಲ್‌ನ ವಸ್ತುಗಳನ್ನು ಸೂಚ್ಯವಾಗಿ ಟೈಪ್ ಇಂಟ್‌ಗೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಸರಿ 1 ಆಗುತ್ತದೆ ಮತ್ತು ತಪ್ಪು 0 ಆಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಬೂಲ್ ಕಂಡು = ತಪ್ಪು; ಇಂಟ್ ಸಂಭವಿಸುವಿಕೆ_ಎಣಿಕೆ = 0; ಹಾಗೆಯೇ (/* ಗೊಣಗುವುದು */)
{
ಕಂಡುಬಂದಿದೆ = ಲುಕ್_ಫಾರ್ (/* ಏನಾದರೂ */); // ಕಂಡುಬರುವ ಮೌಲ್ಯವನ್ನು 0 ಅಥವಾ 1 ಗೆ ಪರಿವರ್ತಿಸಲಾಗಿದೆ
ಸಂಭವಿಸುವ_ಎಣಿಕೆ += ಕಂಡುಬಂದಿದೆ; )

ಅದೇ ರೀತಿಯಲ್ಲಿ, ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಟೈಪ್ ಬೂಲ್‌ನ ಮೌಲ್ಯಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, 0 ಅನ್ನು ತಪ್ಪು ಎಂದು ಅರ್ಥೈಸಲಾಗುತ್ತದೆ ಮತ್ತು ಉಳಿದಂತೆ ನಿಜವೆಂದು ಅರ್ಥೈಸಲಾಗುತ್ತದೆ:

// ಎಕ್ಸ್ಟರ್ನ್ ಇಂಟ್ ಫೈಂಡ್ (ಕಾನ್ಸ್ಟ್ ಸ್ಟ್ರಿಂಗ್&) ಘಟನೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; bool ಕಂಡು = ತಪ್ಪು; ಒಂದು ವೇಳೆ (ಫೌಂಡ್ = ಫೈಂಡ್ ("ರೋಸ್‌ಬಡ್")) // ಸರಿಯಾಗಿದೆ: ಕಂಡುಬಂದಿದೆ == ನಿಜ // ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
extern int* find(int value); ಒಂದು ವೇಳೆ (ಫೌಂಡ್ = ಫೈಂಡ್ (1024)) // ಸರಿಯಾಗಿದೆ: ಕಂಡುಬಂದಿದೆ == ನಿಜ

3.8 ವರ್ಗಾವಣೆಗಳು

ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ನಿರ್ದಿಷ್ಟ ಸೆಟ್‌ನಿಂದ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ವೇರಿಯಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಫೈಲ್ ಅನ್ನು ಯಾವುದಾದರೂ ಮೂರು ವಿಧಾನಗಳಲ್ಲಿ ತೆರೆಯಲಾಗಿದೆ ಎಂದು ಹೇಳೋಣ: ಓದಲು, ಬರೆಯಲು, ಸೇರಿಸಲು.
ಸಹಜವಾಗಿ, ಈ ವಿಧಾನಗಳನ್ನು ಸೂಚಿಸಲು ಮೂರು ಸ್ಥಿರಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಇನ್ಪುಟ್ = 1; const int ಔಟ್ಪುಟ್ = 2; const int append = 3;

ಮತ್ತು ಈ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಬಳಸಿ:

Bool open_file (string file_name, int open_mode); //...
ಓಪನ್_ಫೈಲ್ ("ಫೀನಿಕ್ಸ್_ಮತ್ತು_ದಿ_ಕ್ರೇನ್", ಅನುಬಂಧ);

ಈ ಪರಿಹಾರವು ಸಾಧ್ಯ, ಆದರೆ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ, ಏಕೆಂದರೆ open_file() ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಕೇವಲ 1, 2 ಅಥವಾ 3 ಎಂದು ನಾವು ಖಾತರಿಪಡಿಸುವುದಿಲ್ಲ.
ಎನಮ್ ಪ್ರಕಾರವನ್ನು ಬಳಸುವುದು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ನಾವು ಬರೆಯುವಾಗ:

Enum open_modes (ಇನ್ಪುಟ್ = 1, ಔಟ್ಪುಟ್, ಅನುಬಂಧ );

ನಾವು ಹೊಸ ರೀತಿಯ open_modes ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಈ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ಮಾನ್ಯವಾದ ಮೌಲ್ಯಗಳು 1, 2 ಮತ್ತು 3 ರ ಸೆಟ್‌ಗೆ ಸೀಮಿತವಾಗಿವೆ, ಪ್ರತಿ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಗಳು ಜ್ಞಾಪಕ ಹೆಸರನ್ನು ಹೊಂದಿವೆ. ಆ ಪ್ರಕಾರದ ವಸ್ತು ಮತ್ತು ಕಾರ್ಯದ ಔಪಚಾರಿಕ ನಿಯತಾಂಕಗಳ ಪ್ರಕಾರ ಎರಡನ್ನೂ ವ್ಯಾಖ್ಯಾನಿಸಲು ನಾವು ಈ ಹೊಸ ಪ್ರಕಾರದ ಹೆಸರನ್ನು ಬಳಸಬಹುದು:

ಅನೂರ್ಜಿತ ಓಪನ್_ಫೈಲ್ (ಸ್ಟ್ರಿಂಗ್ ಫೈಲ್_ಹೆಸರು, ಓಪನ್_ಮೋಡ್ಸ್ ಓಮ್);

ಇನ್ಪುಟ್, ಔಟ್ಪುಟ್ ಮತ್ತು ಅನುಬಂಧ ಎಣಿಕೆಯ ಅಂಶಗಳು. ಎಣಿಕೆಯ ಅಂಶಗಳ ಸೆಟ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ವಸ್ತುವಿಗೆ ಅನುಮತಿಸಲಾದ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಓಪನ್_ಮೋಡ್ಸ್ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ (ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ) ಈ ಮೌಲ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ; ಅವುಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ನಿಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಓಪನ್_ಫೈಲ್ ("ಫೀನಿಕ್ಸ್ ಮತ್ತು ಕ್ರೇನ್", ಅನುಬಂಧ);

ಈ ಪ್ರಕಾರದ ವೇರಿಯೇಬಲ್‌ಗೆ ಎಣಿಕೆಯ ಅಂಶಗಳಲ್ಲಿ ಒಂದನ್ನು ಹೊರತುಪಡಿಸಿ ಬೇರೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುವ ಪ್ರಯತ್ನವು (ಅಥವಾ ಅದನ್ನು ಕಾರ್ಯಕ್ಕೆ ನಿಯತಾಂಕವಾಗಿ ರವಾನಿಸಿ) ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಎಣಿಕೆಯ ಅಂಶಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಅನುಗುಣವಾದ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಲು ನಾವು ಪ್ರಯತ್ನಿಸಿದರೂ ಸಹ, ನಾವು ಇನ್ನೂ ದೋಷವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ:

// ದೋಷ: 1 ಎಣಿಕೆಯ ಅಂಶವಲ್ಲ open_modes open_file("ಜೋನಾ", 1);

ಓಪನ್_ಮೋಡ್ಸ್ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಒಂದು ಮಾರ್ಗವಿದೆ, ಅದನ್ನು ಎಣಿಕೆ ಅಂಶಗಳ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿ ಮತ್ತು ಅದನ್ನು ಕಾರ್ಯಕ್ಕೆ ನಿಯತಾಂಕವಾಗಿ ರವಾನಿಸಿ:

ಓಪನ್_ಮೋಡ್ಸ್ ಓಂ = ಇನ್‌ಪುಟ್; // ... ಓಂ = ಅನುಬಂಧ; open_file("ಟೇಲ್ ಟೆಲ್", ಓಂ);

ಆದಾಗ್ಯೂ, ಅಂತಹ ಅಂಶಗಳ ಹೆಸರನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಾವು ಔಟ್ಪುಟ್ ಹೇಳಿಕೆಯನ್ನು ಬರೆದರೆ:

ಕೌಟ್<< input << " " << om << endl;

ನಂತರ ನಾವು ಇನ್ನೂ ಪಡೆಯುತ್ತೇವೆ:

ಎಣಿಕೆಯ ಅಂಶದ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾದ ಸೂಚಿಯನ್ನು ಹೊಂದಿರುವ ಅಂಶವು ಅದರ ಹೆಸರನ್ನು ಒಳಗೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅರೇ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ. ಅಂತಹ ಶ್ರೇಣಿಯನ್ನು ನೀಡಿದರೆ, ನಾವು ಬರೆಯಬಹುದು:

ಕೌಟ್<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ಎಣಿಕೆಯ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ:

// ಬೆಂಬಲಿಸುವುದಿಲ್ಲ (open_modes iter = ಇನ್‌ಪುಟ್; iter != append; ++inter) // ...

ಎಣಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, enum ಕೀವರ್ಡ್ ಬಳಸಿ, ಮತ್ತು ಅಂಶದ ಹೆಸರುಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಿ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಮೊದಲನೆಯದು 0, ಮುಂದಿನದು 1, ಇತ್ಯಾದಿ. ನಿಯೋಜನೆ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಈ ನಿಯಮವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯವಿಲ್ಲದೆ ಪ್ರತಿ ನಂತರದ ಅಂಶವು ಪಟ್ಟಿಯಲ್ಲಿ ಅದರ ಮೊದಲು ಬರುವ ಅಂಶಕ್ಕಿಂತ 1 ಹೆಚ್ಚು ಇರುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇನ್‌ಪುಟ್‌ಗಾಗಿ ನಾವು 1 ಮೌಲ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದೇವೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಮತ್ತು ಅನುಬಂಧವು 2 ಮತ್ತು 3 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಇಲ್ಲಿ ಇನ್ನೊಂದು ಉದಾಹರಣೆ ಇದೆ:

// ಆಕಾರ == 0, ಗೋಳ == 1, ಸಿಲಿಂಡರ್ == 2, ಬಹುಭುಜಾಕೃತಿ == 3 enum ಫಾರ್ಮ್‌ಗಳು (ಹಂಚಿಕೆ, ಗೋಳ, ಸಿಲಿಂಡರ್, ಬಹುಭುಜಾಕೃತಿ );

ಒಂದೇ ಎಣಿಕೆಯ ವಿವಿಧ ಅಂಶಗಳಿಗೆ ಅನುಗುಣವಾದ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳು ವಿಭಿನ್ನವಾಗಿರಬೇಕಾಗಿಲ್ಲ. ಉದಾಹರಣೆಗೆ:

// point2d == 2, point2w == 3, point3d == 3, point3w == 4 enum ಪಾಯಿಂಟ್‌ಗಳು (point2d=2, point2w, point3d=3, point3w=4 );

ಎಣಿಕೆಯ ಪ್ರಕಾರದ ವಸ್ತುವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಬಳಸಬಹುದು ಮತ್ತು ವಾದವಾಗಿ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಬಹುದು. ಅಂತಹ ವಸ್ತುವನ್ನು ಎಣಿಕೆಯ ಅಂಶಗಳಲ್ಲಿ ಒಂದರ ಮೌಲ್ಯದೊಂದಿಗೆ ಮಾತ್ರ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ಮೌಲ್ಯವನ್ನು ಮಾತ್ರ ಅದಕ್ಕೆ ಸ್ಪಷ್ಟವಾಗಿ ಅಥವಾ ಅದೇ ಪ್ರಕಾರದ ಮತ್ತೊಂದು ವಸ್ತುವಿನ ಮೌಲ್ಯವಾಗಿ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮಾನ್ಯವಾದ ಎಣಿಕೆ ಅಂಶಗಳಿಗೆ ಅನುಗುಣವಾದ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ಸಹ ಅದಕ್ಕೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ:

ಶೂನ್ಯ ಮಂಬಲ್() ( ಪಾಯಿಂಟ್‌ಗಳು pt3d = point3d; // ಸರಿ: pt2d == 3 // ದೋಷ: pt3w ಅನ್ನು ಇಂಟ್ ಪಾಯಿಂಟ್‌ಗಳು pt3w = 3 ಪ್ರಕಾರದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ; // ದೋಷ: ಪಾಯಿಂಟ್‌ಗಳ ಎಣಿಕೆಯಲ್ಲಿ ಬಹುಭುಜಾಕೃತಿಯನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ pt3w = ಬಹುಭುಜಾಕೃತಿ; / / ಸರಿ: ಎರಡೂ ವಸ್ತುವಿನ ಪ್ರಕಾರದ ಪಾಯಿಂಟ್‌ಗಳು pt3w = pt3d; )

ಆದಾಗ್ಯೂ, ಅಂಕಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ, ಎಣಿಕೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಟೈಪ್ ಇಂಟ್‌ಗೆ ಪರಿವರ್ತಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಅರೇ_ಸೈಜ್ = 1024; // ಸರಿ: pt2w ಅನ್ನು ಇಂಟ್ ಆಗಿ ಪರಿವರ್ತಿಸಲಾಗಿದೆ
int chunk_size = array_size * pt2w;

3.9 "ಅರೇ" ಎಂದು ಟೈಪ್ ಮಾಡಿ

ನಾವು ಈಗಾಗಲೇ ವಿಭಾಗ 2.1 ರಲ್ಲಿ ಸರಣಿಗಳನ್ನು ಸ್ಪರ್ಶಿಸಿದ್ದೇವೆ. ಒಂದು ಶ್ರೇಣಿಯು ಒಂದೇ ಪ್ರಕಾರದ ಅಂಶಗಳ ಒಂದು ಗುಂಪಾಗಿದೆ, ಒಂದು ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ - ರಚನೆಯಲ್ಲಿನ ಅಂಶದ ಸರಣಿ ಸಂಖ್ಯೆ. ಉದಾಹರಣೆಗೆ:

ಇಂಟ್ ಇವಾಲ್;

ival ಅನ್ನು ಇಂಟ್ ವೇರಿಯೇಬಲ್ ಮತ್ತು ಸೂಚನೆ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ

ಇಂಟ್ IA[10];

ಇಂಟ್ ಪ್ರಕಾರದ ಹತ್ತು ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ಪ್ರತಿಯೊಂದು ವಸ್ತುಗಳಿಗೆ, ಅಥವಾ ರಚನೆಯ ಅಂಶಗಳು, ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರವೇಶಿಸಬಹುದು:

ಇವಾಲ್ = IA[2];

ವೇರಿಯೇಬಲ್ ival ಗೆ ಅರೇ ಎಲಿಮೆಂಟ್ IA ಮೌಲ್ಯವನ್ನು ಸೂಚ್ಯಂಕ 2 ನೊಂದಿಗೆ ನಿಯೋಜಿಸುತ್ತದೆ. ಹಾಗೆಯೇ

Ia[7] = ಇವಾಲ್;

ಸೂಚ್ಯಂಕ 7 ರಲ್ಲಿ ಅಂಶವನ್ನು ಇವಾಲ್ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.

ರಚನೆಯ ವ್ಯಾಖ್ಯಾನವು ಪ್ರಕಾರದ ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆ, ರಚನೆಯ ಹೆಸರು ಮತ್ತು ಗಾತ್ರವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಗಾತ್ರವು ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ (ಕನಿಷ್ಠ 1) ಮತ್ತು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿದಿದೆ. ರಚನೆಯ ಗಾತ್ರವು ಸಂಕಲನ ಹಂತದಲ್ಲಿ ತಿಳಿದಿರಬೇಕು ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ನಿರಂತರ ಅಭಿವ್ಯಕ್ತಿಯಾಗಿರಬೇಕು, ಆದರೂ ಇದನ್ನು ಅಕ್ಷರಶಃ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿಲ್ಲ. ಸರಿಯಾದ ಮತ್ತು ತಪ್ಪಾದ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನಗಳ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

Extern int get_size(); // buf_size ಮತ್ತು max_files ಸ್ಥಿರಾಂಕಗಳು
const int buf_size = 512, max_files = 20;
ಇಂಟ್ ಸಿಬ್ಬಂದಿ_ಗಾತ್ರ = 27; // ಸರಿ: ಸ್ಥಿರ ಚಾರ್ ಇನ್‌ಪುಟ್_ಬಫರ್[buf_size]; // ಸರಿ: ನಿರಂತರ ಅಭಿವ್ಯಕ್ತಿ: 20 - 3 ಅಕ್ಷರ *fileTable[max_files-3]; // ದೋಷ: ಸ್ಥಿರವಾದ ಡಬಲ್ ಸಂಬಳವಲ್ಲ[ ಸಿಬ್ಬಂದಿ_ಗಾತ್ರ ]; // ದೋಷ: ಸ್ಥಿರ ಅಭಿವ್ಯಕ್ತಿ ಇಂಟ್ ಟೆಸ್ಟ್_ಸ್ಕೋರ್ ಅಲ್ಲ[ get_size() ];

buf_size ಮತ್ತು max_files ವಸ್ತುಗಳು ಸ್ಥಿರವಾಗಿರುತ್ತವೆ, ಆದ್ದರಿಂದ input_buffer ಮತ್ತು fileTable ರಚನೆಯ ವ್ಯಾಖ್ಯಾನಗಳು ಸರಿಯಾಗಿವೆ. ಆದರೆ ಸಿಬ್ಬಂದಿ_ಗಾತ್ರವು ವೇರಿಯೇಬಲ್ ಆಗಿದೆ (ಸ್ಥಿರ 27 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದರೂ), ಅಂದರೆ ಸಂಬಳಗಳು ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ. (ವೇತನ ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದಾಗ ಕಂಪೈಲರ್‌ಗೆ ಸಿಬ್ಬಂದಿ_ಗಾತ್ರದ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.)
max_files-3 ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಹುದು, ಆದ್ದರಿಂದ ಫೈಲ್ಟೇಬಲ್ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನವು ವಾಕ್ಯರಚನೆಯ ಪ್ರಕಾರ ಸರಿಯಾಗಿದೆ.
ಎಲಿಮೆಂಟ್ ಸಂಖ್ಯೆಯು 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ 10 ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಗೆ ಸರಿಯಾದ ಸೂಚ್ಯಂಕ ಶ್ರೇಣಿ 1 - 10 ಅಲ್ಲ, ಆದರೆ 0 - 9. ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

Int main() ( const int array_size = 10; int IA[ array_size ]; (int ix = 0; ix< array_size; ++ ix)
IA[ ix ] = ix;
}

ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ, ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಲಾದ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳಲ್ಲಿ ಅದರ ಅಂಶಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವ ಮೂಲಕ ನೀವು ಅದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಅರೇ_ಸೈಜ್ = 3; ಇಂಟ್ IA [ಅರೇ_ಗಾತ್ರ] = (0, 1, 2);

ನಾವು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸಿದರೆ, ರಚನೆಯ ಗಾತ್ರವನ್ನು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿಲ್ಲ: ಕಂಪೈಲರ್ ಸ್ವತಃ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಕೆ ಮಾಡುತ್ತದೆ:

// ಗಾತ್ರದ 3 ಇಂಟ್ IA = (0, 1, 2);

ಗಾತ್ರ ಮತ್ತು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿ ಎರಡನ್ನೂ ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಾಗ, ಮೂರು ಆಯ್ಕೆಗಳು ಸಾಧ್ಯ. ಮೌಲ್ಯಗಳ ಗಾತ್ರ ಮತ್ತು ಸಂಖ್ಯೆಯು ಹೊಂದಿಕೆಯಾದರೆ, ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ. ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯು ನಿಗದಿತ ಗಾತ್ರಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ಉಳಿದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಶೂನ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಪಟ್ಟಿಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಮೌಲ್ಯಗಳಿದ್ದರೆ, ಕಂಪೈಲರ್ ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; ಇಂಟ್ IA [ಅರೇ_ಗಾತ್ರ] = (0, 1, 2);

ಕರ್ಲಿ ಬ್ರೇಸ್‌ಗಳಲ್ಲಿನ ಅಕ್ಷರ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯೊಂದಿಗೆ ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು, ಆದರೆ ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಸಹ ಪ್ರಾರಂಭಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನಗಳ ನಡುವೆ ಕೆಲವು ವ್ಯತ್ಯಾಸಗಳಿವೆ. ಹೇಳೋಣ

ಕಾನ್ಸ್ಟ್ ಚಾರ್ ಕ್ಯಾಲ್ = ("ಸಿ", "+", "+" ); const char cal2 = "C++";

ca1 ರಚನೆಯ ಆಯಾಮವು 3 ಆಗಿದೆ, ca2 ರಚನೆಯು 4 ಆಗಿದೆ (ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳಲ್ಲಿ, ಅಂತ್ಯಗೊಳ್ಳುವ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ). ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನವು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ:

// ದೋಷ: ಸ್ಟ್ರಿಂಗ್ "ಡೇನಿಯಲ್" 7 ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ const char ch3[ 6 ] = "ಡೇನಿಯಲ್";

ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತೊಂದು ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಒಂದು ರಚನೆಯನ್ನು ಇನ್ನೊಂದರಿಂದ ಪ್ರಾರಂಭಿಸಲು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಉಲ್ಲೇಖಗಳ ಶ್ರೇಣಿಯನ್ನು ಬಳಸಲು ಇದನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ. ಅರೇಗಳ ಸರಿಯಾದ ಮತ್ತು ತಪ್ಪಾದ ಬಳಕೆಯ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಅರೇ_ಸೈಜ್ = 3; int ix, jx, kx; // ಸರಿಯಾಗಿದೆ: int* int *iar = (&ix, &jx, &kx) ಪ್ರಕಾರದ ಪಾಯಿಂಟರ್‌ಗಳ ರಚನೆ; // ದೋಷ: ಉಲ್ಲೇಖ ಸರಣಿಗಳನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ int &iar = ( ix, jx, kx ); ಇಂಟ್ ಮುಖ್ಯ()
{
int ia3 (array_size ]; // ಸರಿ
// ದೋಷ: ಅಂತರ್ನಿರ್ಮಿತ ಅರೇಗಳನ್ನು ನಕಲಿಸಲಾಗುವುದಿಲ್ಲ
IA3 = IA;
ಹಿಂತಿರುಗಿ 0;
}

ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸಲು, ನೀವು ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಇದನ್ನು ಮಾಡಬೇಕು:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಅರೇ_ಸೈಜ್ = 7; int ia1 = (0, 1, 2, 3, 4, 5, 6); ಇಂಟ್ ಮುಖ್ಯ() (
ಇಂಟ್ IA3[ಅರೇ_ಗಾತ್ರ]; ಗಾಗಿ (int ix = 0; ix< array_size; ++ix)
IA2[ ix ] = IA1 [ ix ]; ಹಿಂತಿರುಗಿ 0;
}

ಅರೇ ಸೂಚ್ಯಂಕವು ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರದ ಫಲಿತಾಂಶವನ್ನು ಉಂಟುಮಾಡುವ ಯಾವುದೇ ಅಭಿವ್ಯಕ್ತಿಯಾಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಇಂಟ್ ಸಮ್ವಾಲ್, get_index(); ia2[ get_index() ] = someVal;

C++ ಭಾಷೆಯು ಸಂಕಲನ ಹಂತದಲ್ಲಿ ಅಥವಾ ರನ್‌ಟೈಮ್ ಹಂತದಲ್ಲಿ ಅರೇ ಸೂಚ್ಯಂಕಗಳ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ ಎಂದು ನಾವು ಒತ್ತಿಹೇಳುತ್ತೇವೆ. ಪ್ರೋಗ್ರಾಮರ್ ಸ್ವತಃ ಸೂಚ್ಯಂಕವು ರಚನೆಯ ಗಡಿಗಳನ್ನು ಮೀರಿ ಹೋಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ದೋಷಗಳು ತುಂಬಾ ಸಾಮಾನ್ಯವಾಗಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಕಂಪೈಲ್ ಮಾಡುವ ಮತ್ತು ಕೆಲಸ ಮಾಡುವ ಕಾರ್ಯಕ್ರಮಗಳ ಉದಾಹರಣೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ತುಂಬಾ ಕಷ್ಟವಲ್ಲ, ಆದರೆ ಅದೇನೇ ಇದ್ದರೂ ಮಾರಣಾಂತಿಕ ದೋಷಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಅದು ಬೇಗ ಅಥವಾ ನಂತರ ಕ್ರ್ಯಾಶ್ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ವ್ಯಾಯಾಮ 3.22

ಕೆಳಗಿನ ಯಾವ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನಗಳು ತಪ್ಪಾಗಿವೆ? ವಿವರಿಸಿ.

(a) int IA[ buf_size ]; (d) int IA[ 2 * 7 - 14 ] (b) int ia[ get_size() ]; (ಇ) ಚಾರ್ ಸ್ಟ[11 ] = "ಮೂಲಭೂತ"; (ಸಿ) ಇಂಟ್ IA[ 4 * 7 - 14 ];

ವ್ಯಾಯಾಮ 3.23

ಕೆಳಗಿನ ಕೋಡ್ ತುಣುಕು ಸರಣಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಸೂಚ್ಯಂಕ ಮೌಲ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು. ಮಾಡಿದ ತಪ್ಪುಗಳನ್ನು ಹುಡುಕಿ:

Int main() ( const int array_size = 10; int IA[ array_size ]; ಗಾಗಿ (int ix = 1; ix<= array_size; ++ix)
IA [ IA ] = ix; //...
}

3.9.1. ಬಹು ಆಯಾಮದ ಅರೇಗಳು

C++ ನಲ್ಲಿ, ಬಹುಆಯಾಮದ ಅರೇಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಿದೆ; ಅವುಗಳನ್ನು ಘೋಷಿಸುವಾಗ, ನೀವು ಪ್ರತಿಯೊಂದು ಆಯಾಮದ ಸರಿಯಾದ ಗಡಿಯನ್ನು ಪ್ರತ್ಯೇಕ ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸೂಚಿಸಬೇಕು. ಎರಡು ಆಯಾಮದ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನ ಇಲ್ಲಿದೆ:

ಇಂಟ್ IA[ 4 ][ 3 ];

ಮೊದಲ ಮೌಲ್ಯವು (4) ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಎರಡನೆಯದು (3) - ಕಾಲಮ್ಗಳ ಸಂಖ್ಯೆ. IA ವಸ್ತುವನ್ನು ಪ್ರತಿ ಮೂರು ಅಂಶಗಳ ನಾಲ್ಕು ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಬಹು ಆಯಾಮದ ಅರೇಗಳನ್ನು ಸಹ ಪ್ರಾರಂಭಿಸಬಹುದು:

ಇಂಟ್ IA[ 4 ][ 3 ] = ( (0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

ಒಳಗಿನ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳು, ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ರೇಖೆಗಳಾಗಿ ಒಡೆಯುತ್ತವೆ, ಇದು ಐಚ್ಛಿಕವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಓದಲು ಬಳಸಲಾಗುತ್ತದೆ. ಕೆಳಗಿನ ಪ್ರಾರಂಭವು ಹಿಂದಿನ ಉದಾಹರಣೆಯಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೂ ಇದು ಕಡಿಮೆ ಸ್ಪಷ್ಟವಾಗಿದೆ:

ಇಂಟ್ IA = (0,1,2,3,4,5,6,7,8,9,10,11);

ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನವು ಪ್ರತಿ ಸಾಲಿನ ಮೊದಲ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಉಳಿದ ಅಂಶಗಳು ಶೂನ್ಯವಾಗಿರುತ್ತದೆ:

ಇಂಟ್ IA [4 ][3 ] = ( (0), (3), (6), (9) );

ನೀವು ಒಳಗಿನ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟರೆ, ಫಲಿತಾಂಶವು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಮೊದಲ ಸಾಲಿನ ಎಲ್ಲಾ ಮೂರು ಅಂಶಗಳು ಮತ್ತು ಎರಡನೆಯ ಮೊದಲ ಅಂಶವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಉಳಿದವುಗಳನ್ನು ಸೂಚ್ಯವಾಗಿ 0 ಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.

ಇಂಟ್ IA[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

ಬಹುಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ, ನೀವು ಪ್ರತಿ ಆಯಾಮಕ್ಕೆ ಸೂಚ್ಯಂಕಗಳನ್ನು ಬಳಸಬೇಕು (ಅವು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರೆದಿವೆ). ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಹೀಗಿದೆ:

Int main() ( const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; (int = 0; i< rowSize; ++i)
ಫಾರ್ (ಇಂಟ್ ಜೆ = 0; ಜೆ< colSize; ++j)
ia[ i ][ j ] = i + j j;
}

ವಿನ್ಯಾಸ

Ia[1, 2]

C++ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ದೃಷ್ಟಿಕೋನದಿಂದ ಮಾನ್ಯವಾಗಿದೆ, ಆದರೆ ಇದು ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ ಏನನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಎಂದು ಅರ್ಥವಲ್ಲ. ಇದು ಎರಡು ಆಯಾಮದ 1-ಬೈ-2 ರಚನೆಯ ಘೋಷಣೆಯಲ್ಲ. ಚೌಕ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ಒಟ್ಟು ಮೊತ್ತವು ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾದ ಅಭಿವ್ಯಕ್ತಿಗಳ ಪಟ್ಟಿಯಾಗಿದ್ದು ಅದು ಅಂತಿಮ ಮೌಲ್ಯ 2 ಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ (ವಿಭಾಗ 4.2 ರಲ್ಲಿ ಅಲ್ಪವಿರಾಮ ಆಪರೇಟರ್ ಅನ್ನು ನೋಡಿ). ಆದ್ದರಿಂದ IA ಘೋಷಣೆಯು ia ಗೆ ಸಮನಾಗಿರುತ್ತದೆ. ತಪ್ಪು ಮಾಡಲು ಇದು ಮತ್ತೊಂದು ಅವಕಾಶ.

3.9.2. ಅರೇಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳ ನಡುವಿನ ಸಂಬಂಧ

ನಾವು ರಚನೆಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಹೊಂದಿದ್ದರೆ:

ಇಂಟ್ IA = (0, 1, 1, 2, 3, 5, 8, 13, 21);

ಹಾಗಾದರೆ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಅವರ ಹೆಸರನ್ನು ಸರಳವಾಗಿ ಸೂಚಿಸುವುದರ ಅರ್ಥವೇನು?

ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಅರೇ ಐಡೆಂಟಿಫೈಯರ್ ಅನ್ನು ಬಳಸುವುದು ಅದರ ಮೊದಲ ಅಂಶದ ವಿಳಾಸವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ:

ಅಂತೆಯೇ, ನೀವು ರಚನೆಯ ಮೊದಲ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು:

// ಎರಡೂ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮೊದಲ ಅಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ *IA; IA;

ರಚನೆಯ ಎರಡನೇ ಅಂಶದ ವಿಳಾಸವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು, ನಾವು ಬರೆಯಬೇಕು:

ನಾವು ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಅಭಿವ್ಯಕ್ತಿ

ರಚನೆಯ ಎರಡನೇ ಅಂಶದ ವಿಳಾಸವನ್ನು ಸಹ ನೀಡುತ್ತದೆ. ಅಂತೆಯೇ, ಅದರ ಅರ್ಥವನ್ನು ಈ ಕೆಳಗಿನ ಎರಡು ರೀತಿಯಲ್ಲಿ ನಮಗೆ ನೀಡಲಾಗಿದೆ:

*(IA+1); IA;

ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸಿ:

*IA+1 ಮತ್ತು *(IA+1);

dereference ಕಾರ್ಯಾಚರಣೆಯು ಹೆಚ್ಚಿನದನ್ನು ಹೊಂದಿದೆ ಒಂದು ಆದ್ಯತೆಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆಗಿಂತ (ಆಪರೇಟರ್ ಆದ್ಯತೆಗಳನ್ನು ವಿಭಾಗ 4.13 ರಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ). ಆದ್ದರಿಂದ, ಮೊದಲ ಅಭಿವ್ಯಕ್ತಿಯು ಮೊದಲು ವೇರಿಯೇಬಲ್ IA ​​ಅನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಮತ್ತು ರಚನೆಯ ಮೊದಲ ಅಂಶವನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದಕ್ಕೆ 1 ಅನ್ನು ಸೇರಿಸುತ್ತದೆ. ಎರಡನೆಯ ಅಭಿವ್ಯಕ್ತಿ ಎರಡನೇ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ.

ನಾವು ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಮಾಡಿದಂತೆ ಅಥವಾ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಿ ನೀವು ಸೂಚ್ಯಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ಶ್ರೇಣಿಯನ್ನು ದಾಟಬಹುದು. ಉದಾಹರಣೆಗೆ:

#ಸೇರಿಸು int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); int * pbegin = IA; int * pend = IA + 9; while (pbegin ! = pend) ( ಕೌಟ್<< *pbegin <<; ++pbegin; } }

ರಚನೆಯ ಮೊದಲ ಅಂಶದ ವಿಳಾಸಕ್ಕೆ pbegin ಪಾಯಿಂಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಲೂಪ್ ಮೂಲಕ ಪ್ರತಿ ಪಾಸ್ ಈ ಪಾಯಿಂಟರ್ ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸುತ್ತದೆ, ಅಂದರೆ ಅದನ್ನು ಮುಂದಿನ ಅಂಶಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಎಲ್ಲಿ ಉಳಿಯಬೇಕೆಂದು ನಿಮಗೆ ಹೇಗೆ ಗೊತ್ತು? ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಎರಡನೇ ಪೆಂಡ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ ಮತ್ತು IA ರಚನೆಯ ಕೊನೆಯ ಅಂಶವನ್ನು ಅನುಸರಿಸುವ ವಿಳಾಸದೊಂದಿಗೆ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. pbegin ಮೌಲ್ಯವು ಪೆಂಡ್‌ಗೆ ಸಮಾನವಾದ ತಕ್ಷಣ, ರಚನೆಯು ಕೊನೆಗೊಂಡಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿಯುತ್ತದೆ. ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪುನಃ ಬರೆಯೋಣ ಆದ್ದರಿಂದ ರಚನೆಯ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯವು ಯಾವುದೇ ಗಾತ್ರದ ಶ್ರೇಣಿಯನ್ನು ಮುದ್ರಿಸಬಹುದಾದ ನಿರ್ದಿಷ್ಟ ಸಾಮಾನ್ಯೀಕರಿಸಿದ ಕಾರ್ಯಕ್ಕೆ ನಿಯತಾಂಕಗಳಾಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ:

#ಸೇರಿಸು ಅನೂರ್ಜಿತ ia_print (int *pbegin, int * pend) (
ಹಾಗೆಯೇ (pbegin != ಬಾಕಿ) (
ಕೌಟ್<< *pbegin << " ";
++pbegin;
}
) ಇಂಟ್ ಮುಖ್ಯ ()
{
int IA = (0, 1, 1, 2, 3, 5, 8, 13, 21);
ia_print (IA, IA + 9);
}

ನಮ್ಮ ಕಾರ್ಯವು ಹೆಚ್ಚು ಸಾರ್ವತ್ರಿಕವಾಗಿದೆ, ಆದಾಗ್ಯೂ, ಇದು ಇಂಟ್ ಪ್ರಕಾರದ ಸರಣಿಗಳೊಂದಿಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಮಿತಿಯನ್ನು ತೆಗೆದುಹಾಕಲು ಒಂದು ಮಾರ್ಗವಿದೆ: ಈ ಕಾರ್ಯವನ್ನು ಟೆಂಪ್ಲೇಟ್ ಆಗಿ ಪರಿವರ್ತಿಸಿ (ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ವಿಭಾಗ 2.5 ರಲ್ಲಿ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಚಯಿಸಲಾಗಿದೆ):

#ಸೇರಿಸು ಟೆಂಪ್ಲೇಟ್ ಅನೂರ್ಜಿತ ಮುದ್ರಣ (elemType *pbegin, elemType * pend) (ಆದರೆ (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

ಈಗ ನಾವು ಯಾವುದೇ ಪ್ರಕಾರದ ಅರೇಗಳನ್ನು ಮುದ್ರಿಸಲು ನಮ್ಮ ಮುದ್ರಣ () ಕಾರ್ಯವನ್ನು ಕರೆಯಬಹುದು:

Int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); ಡಬಲ್ ಡಾ = ( 3.14, 6.28, 12.56, 25.12 ); ಸ್ಟ್ರಿಂಗ್ sa = ( "ಹಂದಿಮರಿ", " eeyore", "pooh" );ಮುದ್ರಣ(ia, IA+9);
ಪ್ರಿಂಟ್(ಡಾ, ಡಾ+4);
ಮುದ್ರಣ(ಸ, ಸ+3);
}

ನಾವು ಬರೆದಿದ್ದೇವೆ ಸಾಮಾನ್ಯೀಕರಿಸಲಾಗಿದೆಕಾರ್ಯ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು ಜೆನೆರಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ (ನಾವು ಇದನ್ನು ಈಗಾಗಲೇ ವಿಭಾಗ 3.4 ರಲ್ಲಿ ಉಲ್ಲೇಖಿಸಿದ್ದೇವೆ) ಇದೇ ರೀತಿಯಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಅಂತಹ ಕಾರ್ಯಗಳ ನಿಯತಾಂಕಗಳು ಕೆಲವು ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ರಚನೆಯ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್ಗಳಾಗಿವೆ. ಇಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ಸಾಮಾನ್ಯೀಕರಿಸಿದ ವಿಂಗಡಣೆ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕರೆಯುವುದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

#ಸೇರಿಸು int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( "ಹಂದಿಮರಿ", "eeyore", "pooh" ); sort(ia, ia+6);
ವಿಂಗಡಣೆ(sa, sa+3);
};

(ಅಧ್ಯಾಯ 12 ರಲ್ಲಿ ಸಾಮಾನ್ಯೀಕರಿಸಿದ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಕುರಿತು ನಾವು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಹೋಗುತ್ತೇವೆ; ಅನುಬಂಧವು ಅವುಗಳ ಬಳಕೆಯ ಉದಾಹರಣೆಗಳನ್ನು ನೀಡುತ್ತದೆ.)
C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು ಕಂಟೈನರ್‌ಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳ ಬಳಕೆಯನ್ನು ಆವರಿಸುವ ತರಗತಿಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ. (ಇದನ್ನು ವಿಭಾಗ 2.8 ರಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ.) ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಪ್ರಮಾಣಿತ ಕಂಟೇನರ್ ಪ್ರಕಾರದ ವೆಕ್ಟರ್ ಅನ್ನು ನೋಡೋಣ, ಇದು ರಚನೆಯ ವಸ್ತು-ಆಧಾರಿತ ಅನುಷ್ಠಾನವಾಗಿದೆ.

3.10. ವೆಕ್ಟರ್ ವರ್ಗ

ವೆಕ್ಟರ್ ವರ್ಗವನ್ನು ಬಳಸುವುದು (ವಿಭಾಗ 2.8 ನೋಡಿ) ಅಂತರ್ನಿರ್ಮಿತ ಅರೇಗಳನ್ನು ಬಳಸುವುದಕ್ಕೆ ಪರ್ಯಾಯವಾಗಿದೆ. ಈ ವರ್ಗವು ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದರ ಬಳಕೆಯನ್ನು ಯೋಗ್ಯವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಸರಣಿಗಳಿಲ್ಲದೆ ನೀವು ಮಾಡಲು ಸಾಧ್ಯವಾಗದ ಸಂದರ್ಭಗಳಿವೆ. ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಂದು ಪ್ರೋಗ್ರಾಂಗೆ ರವಾನಿಸಲಾದ ಆಜ್ಞಾ ಸಾಲಿನ ನಿಯತಾಂಕಗಳ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ, ಅದನ್ನು ನಾವು ವಿಭಾಗ 7.8 ರಲ್ಲಿ ಚರ್ಚಿಸುತ್ತೇವೆ. ವೆಕ್ಟರ್ ವರ್ಗ, ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದಂತೆ, C++ ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದ ಭಾಗವಾಗಿದೆ.
ವೆಕ್ಟರ್ ಅನ್ನು ಬಳಸಲು ನೀವು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:

#ಸೇರಿಸು

ವೆಕ್ಟರ್ ಅನ್ನು ಬಳಸಲು ಎರಡು ವಿಭಿನ್ನ ವಿಧಾನಗಳಿವೆ, ಅವುಗಳನ್ನು ಅರೇ ಭಾಷಾವೈಶಿಷ್ಟ್ಯ ಮತ್ತು STL ಭಾಷಾವೈಶಿಷ್ಟ್ಯ ಎಂದು ಕರೆಯೋಣ. ಮೊದಲ ಸಂದರ್ಭದಲ್ಲಿ, ವೆಕ್ಟರ್ ವಸ್ತುವನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಒಂದು ಶ್ರೇಣಿಯಂತೆ ನಿಖರವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ಆಯಾಮದ ವೆಕ್ಟರ್ ಅನ್ನು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ:

ವೆಕ್ಟರ್< int >ivec (10);

ಇದು ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೋಲುತ್ತದೆ:

ಇಂಟ್ IA[10];

ವೆಕ್ಟರ್ನ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ:

ಶೂನ್ಯ simp1e_examp1e() ( const int e1em_size = 10; ವೆಕ್ಟರ್< int >ivec (e1em_size); ಇಂಟ್ IA [e1em_size]; ಗಾಗಿ (int ix = 0; ix< e1em_size; ++ix)
IA[ ix ] = ivec [ ix ]; //...
}

ನಾವು ಗಾತ್ರ() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ವೆಕ್ಟರ್‌ನ ಆಯಾಮವನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು ಮತ್ತು ಖಾಲಿ() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ವೆಕ್ಟರ್ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್_ವೆಕ್ಟರ್(ವೆಕ್ಟರ್ ivec) ((ivec.empty()) ಹಿಂತಿರುಗಿಸಿದರೆ; (int ix=0; ix< ivec.size(); ++ix)
ಕೌಟ್<< ivec[ ix ] << " ";
}

ವೆಕ್ಟರ್ನ ಅಂಶಗಳನ್ನು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಸಂಖ್ಯಾತ್ಮಕ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳಿಗೆ, ಈ ಮೌಲ್ಯವು 0 ಆಗಿದೆ. ಅಂಶಗಳು ವರ್ಗ ವಸ್ತುಗಳಾಗಿದ್ದರೆ, ಅವುಗಳಿಗೆ ಇನಿಶಿಯೇಟರ್ ಅನ್ನು ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುತ್ತದೆ (ವಿಭಾಗ 2.3 ನೋಡಿ). ಆದಾಗ್ಯೂ, ಫಾರ್ಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇನಿಶಿಯೇಟರ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

ವೆಕ್ಟರ್< int >ivec (10, -1);

ವೆಕ್ಟರ್ನ ಎಲ್ಲಾ ಹತ್ತು ಅಂಶಗಳು -1 ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.
ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪಟ್ಟಿಯೊಂದಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು:

ಇಂಟ್ IA[ 6 ] = ( -2, -1, O, 1, 2, 1024 );

ವೆಕ್ಟರ್ ವರ್ಗದ ವಸ್ತುವಿಗೆ ಇದೇ ರೀತಿಯ ಕ್ರಿಯೆಯು ಸಾಧ್ಯವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಅಂತಹ ವಸ್ತುವನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ರಚನೆಯ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಾರಂಭಿಸಬಹುದು:

// 6 IA ಅಂಶಗಳನ್ನು ivec ವೆಕ್ಟರ್‌ಗೆ ನಕಲಿಸಲಾಗಿದೆ< int >ivec(IA, IA+6);

ವೆಕ್ಟರ್ ivec ನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ರವಾನಿಸಲಾಗಿದೆ - ರಚನೆಯ ಆರಂಭಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು ಕೊನೆಯದನ್ನು ಅನುಸರಿಸುವ ಅಂಶಕ್ಕೆ. ಸಂಪೂರ್ಣ ಶ್ರೇಣಿಯನ್ನು ಅಲ್ಲ, ಆದರೆ ಅದರ ಒಂದು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯನ್ನು ಆರಂಭಿಕ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅನುಮತಿಸಲಾಗಿದೆ:

// 3 ಅಂಶಗಳನ್ನು ನಕಲಿಸಲಾಗಿದೆ: IA, IA, IA ವೆಕ್ಟರ್< int >ivec(&IA[2], &IA[5]);

ವೆಕ್ಟರ್ ಮತ್ತು ಅಂತರ್ನಿರ್ಮಿತ ರಚನೆಯ ನಡುವಿನ ಮತ್ತೊಂದು ವ್ಯತ್ಯಾಸವೆಂದರೆ ಒಂದು ವೆಕ್ಟರ್ ವಸ್ತುವನ್ನು ಇನ್ನೊಂದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ವಸ್ತುಗಳನ್ನು ನಕಲಿಸಲು ಅಸೈನ್ಮೆಂಟ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು. ಉದಾಹರಣೆಗೆ:

ವೆಕ್ಟರ್< string >svec; void init_and_assign() ( // ಒಂದು ವೆಕ್ಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ವೆಕ್ಟರ್‌ನಿಂದ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ< string >ಬಳಕೆದಾರ_ಹೆಸರುಗಳು(svec); // ... // ಒಂದು ವೆಕ್ಟರ್ ಅನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸಲಾಗುತ್ತದೆ
svec = user_names;
}

ನಾವು STL ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ, ವೆಕ್ಟರ್ ಅನ್ನು ಬಳಸುವ ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ನಾವು ಅರ್ಥೈಸುತ್ತೇವೆ. ಬಯಸಿದ ಗಾತ್ರವನ್ನು ತಕ್ಷಣವೇ ಸೂಚಿಸುವ ಬದಲು, ನಾವು ಖಾಲಿ ವೆಕ್ಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ:

ವೆಕ್ಟರ್< string >ಪಠ್ಯ;

ನಂತರ ನಾವು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅದಕ್ಕೆ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, push_back() ಕಾರ್ಯವು ವೆಕ್ಟರ್‌ನ ಕೊನೆಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುತ್ತದೆ. ಪ್ರಮಾಣಿತ ಇನ್‌ಪುಟ್‌ನಿಂದ ಸಾಲುಗಳ ಅನುಕ್ರಮವನ್ನು ಓದುವ ಮತ್ತು ಅವುಗಳನ್ನು ವೆಕ್ಟರ್‌ಗೆ ಸೇರಿಸುವ ಕೋಡ್‌ನ ತುಣುಕು ಇಲ್ಲಿದೆ:

ಸ್ಟ್ರಿಂಗ್ ಪದ; ಹಾಗೆಯೇ (ಸಿನ್ >> ಪದ) (text.push_back(word); // ... )

ವೆಕ್ಟರ್ನ ಅಂಶಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ನಾವು ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬಳಸಬಹುದು:

ಕೌಟ್<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

ಈ ಭಾಷಾವೈಶಿಷ್ಟ್ಯದೊಳಗೆ ಪುನರಾವರ್ತಕಗಳ ಹೆಚ್ಚು ವಿಶಿಷ್ಟವಾದ ಬಳಕೆಯು ಹೀಗಿರುತ್ತದೆ:

ಕೌಟ್<< "считаны слова: \n"; for (vector:: iterator it = text.begin(); ಇದು != text.end(); ++ಇದು) ಕೌಟ್<< *it << " "; cout << endl;

ಪುನರಾವರ್ತಕವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿ ವರ್ಗವಾಗಿದ್ದು ಅದು ರಚನೆಯ ಅಂಶಕ್ಕೆ ಮೂಲಭೂತವಾಗಿ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.
ಅಭಿವ್ಯಕ್ತಿ

ಪುನರಾವರ್ತಕವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಮತ್ತು ವೆಕ್ಟರ್ ಅಂಶವನ್ನು ನೀಡುತ್ತದೆ. ಸೂಚನೆಗಳು

ಪಾಯಿಂಟರ್ ಅನ್ನು ಮುಂದಿನ ಅಂಶಕ್ಕೆ ಸರಿಸುತ್ತದೆ. ಈ ಎರಡು ವಿಧಾನಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಖಾಲಿ ವೆಕ್ಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ನೀವು STL ಭಾಷಾವೈಶಿಷ್ಟ್ಯವನ್ನು ಅನುಸರಿಸಿದರೆ:

ವೆಕ್ಟರ್ ivec;

ಬರೆಯುವುದು ತಪ್ಪಾಗುತ್ತದೆ:

ನಾವು ಇನ್ನೂ ivec ವೆಕ್ಟರ್‌ನ ಒಂದು ಅಂಶವನ್ನು ಹೊಂದಿಲ್ಲ; ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಗಾತ್ರ () ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.

ವಿರುದ್ಧ ತಪ್ಪು ಕೂಡ ಮಾಡಬಹುದು. ನಾವು ಕೆಲವು ಗಾತ್ರದ ವೆಕ್ಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಉದಾಹರಣೆಗೆ:

ವೆಕ್ಟರ್ IA (10);

ನಂತರ ಅಂಶಗಳನ್ನು ಸೇರಿಸುವುದರಿಂದ ಅದರ ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಂಶಗಳಿಗೆ ಹೊಸ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. ಇದು ಸ್ಪಷ್ಟವಾಗಿ ತೋರುತ್ತದೆಯಾದರೂ, ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ ಚೆನ್ನಾಗಿ ಬರೆಯಬಹುದು:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಗಾತ್ರ = 7; int IA[ ಗಾತ್ರ ] = ( 0, 1, 1, 2, 3, 5, 8 ); ವೆಕ್ಟರ್< int >ivec (ಗಾತ್ರ); ಗಾಗಿ (int ix = 0; ix< size; ++ix) ivec.push_back(ia[ ix ]);

ಇದರರ್ಥ ivc ವೆಕ್ಟರ್ ಅನ್ನು IA ಅಂಶಗಳ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು, ಇದು ಗಾತ್ರ 14 ರ ivec ವೆಕ್ಟರ್‌ಗೆ ಕಾರಣವಾಯಿತು.
STL ಭಾಷಾವೈಶಿಷ್ಟ್ಯವನ್ನು ಅನುಸರಿಸಿ, ನೀವು ವೆಕ್ಟರ್‌ನಿಂದ ಅಂಶಗಳನ್ನು ಸೇರಿಸುವುದು ಮಾತ್ರವಲ್ಲದೆ ತೆಗೆದುಹಾಕಬಹುದು. (ಇದೆಲ್ಲವನ್ನೂ ನಾವು ವಿವರವಾಗಿ ಮತ್ತು ಅಧ್ಯಾಯ 6 ರಲ್ಲಿ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ನೋಡೋಣ.)

ವ್ಯಾಯಾಮ 3.24

ಕೆಳಗಿನ ವ್ಯಾಖ್ಯಾನಗಳಲ್ಲಿ ಯಾವುದೇ ದೋಷಗಳಿವೆಯೇ?
int ia[7] = (0, 1, 1, 2, 3, 5, 8);

(ಎ) ವೆಕ್ಟರ್< vector< int >>ivec;
(ಬಿ) ವೆಕ್ಟರ್< int >ivec = (0, 1, 1, 2, 3, 5, 8);
(ಸಿ) ವೆಕ್ಟರ್< int >ivec(IA, IA+7);
(ಡಿ) ವೆಕ್ಟರ್< string >svec = ivec;
(ಇ) ವೆಕ್ಟರ್< string >svec(10, ಸ್ಟ್ರಿಂಗ್ ("ಶೂನ್ಯ"));

ವ್ಯಾಯಾಮ 3.25

ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ:
bool is_equal(const int*ia, int ia_size,
ಕಾನ್ಸ್ಟ್ ವೆಕ್ಟರ್ &ivec);
is_equal() ಕಾರ್ಯವು ಎರಡು ಧಾರಕಗಳ ಅಂಶವನ್ನು ಅಂಶದಿಂದ ಹೋಲಿಸುತ್ತದೆ. ವಿಭಿನ್ನ ಗಾತ್ರದ ಧಾರಕಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಉದ್ದನೆಯ "ಬಾಲ" ಅನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಎಲ್ಲಾ ಹೋಲಿಸಿದ ಅಂಶಗಳು ಸಮಾನವಾಗಿದ್ದರೆ, ಕಾರ್ಯವು ನಿಜವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಕನಿಷ್ಠ ಒಂದು ವಿಭಿನ್ನವಾಗಿದ್ದರೆ, ತಪ್ಪಾಗಿದೆ. ಅಂಶಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಪುನರಾವರ್ತಕವನ್ನು ಬಳಸಿ. is_equal() ಎಂದು ಕರೆಯುವ ಮುಖ್ಯ() ಕಾರ್ಯವನ್ನು ಬರೆಯಿರಿ.

3.11. ವರ್ಗ ಸಂಕೀರ್ಣ

ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಗಳ ಸಂಕೀರ್ಣದ ವರ್ಗವು ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದಿಂದ ಮತ್ತೊಂದು ವರ್ಗವಾಗಿದೆ. ಎಂದಿನಂತೆ, ಅದನ್ನು ಬಳಸಲು ನೀವು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ:

#ಸೇರಿಸು

ಒಂದು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯು ಎರಡು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ - ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ. ಕಾಲ್ಪನಿಕ ಭಾಗವು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಯ ವರ್ಗಮೂಲವಾಗಿದೆ. ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ರೂಪದಲ್ಲಿ ಬರೆಯಲಾಗುತ್ತದೆ

ಅಲ್ಲಿ 2 ನಿಜವಾದ ಭಾಗವಾಗಿದೆ, ಮತ್ತು 3i ಕಾಲ್ಪನಿಕ ಭಾಗವಾಗಿದೆ. ಸಂಕೀರ್ಣ ಪ್ರಕಾರದ ವಸ್ತುಗಳ ವ್ಯಾಖ್ಯಾನಗಳ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

// ಸಂಪೂರ್ಣವಾಗಿ ಕಾಲ್ಪನಿಕ ಸಂಖ್ಯೆ: 0 + 7-i ಸಂಕೀರ್ಣ< double >ಪ್ಯೂರಿ(0, 7); // ಕಾಲ್ಪನಿಕ ಭಾಗವು 0: 3 + Oi ಸಂಕೀರ್ಣವಾಗಿದೆ< float >rea1_num(3); // ನೈಜ ಮತ್ತು ಕಾಲ್ಪನಿಕ ಭಾಗಗಳೆರಡೂ 0: 0 + 0-i ಸಂಕೀರ್ಣಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ< long double >ಶೂನ್ಯ; // ಒಂದು ಸಂಕೀರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಮತ್ತೊಂದು ಸಂಕೀರ್ಣದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು< double >purei2(purei);

ವೆಕ್ಟರ್ ನಂತಹ ಸಂಕೀರ್ಣವು ಒಂದು ಟೆಂಪ್ಲೇಟ್ ಆಗಿರುವುದರಿಂದ, ನಾವು ಅದನ್ನು ಫ್ಲೋಟ್, ಡಬಲ್ ಮತ್ತು ಲಾಂಗ್ ಡಬಲ್ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಇನ್‌ಸ್ಟಾಂಟಿಯೇಟ್ ಮಾಡಬಹುದು, ನೀಡಿರುವ ಉದಾಹರಣೆಗಳಂತೆ. ಪ್ರಕಾರದ ಸಂಕೀರ್ಣದ ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸಹ ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

ಸಂಕೀರ್ಣ< double >ಸಂಯೋಗ[2] = (ಸಂಕೀರ್ಣ< double >(2, 3), ಸಂಕೀರ್ಣ< double >(2, -3) };

ಸಂಕೀರ್ಣ< double >*ptr = ಸಂಕೀರ್ಣ< double >&ref = *ptr;

3.12. ಟೈಪ್ಡೆಫ್ ನಿರ್ದೇಶನ

ಟೈಪ್‌ಡೆಫ್ ನಿರ್ದೇಶನವು ಅಂತರ್ನಿರ್ಮಿತ ಅಥವಾ ಕಸ್ಟಮ್ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಸಮಾನಾರ್ಥಕವನ್ನು ಸೂಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಟೈಪ್ಡೆಫ್ ಡಬಲ್ ವೇತನಗಳು; ಟೈಪ್ಡೆಫ್ ವೆಕ್ಟರ್ vec_int; typedef vec_int test_ಸ್ಕೋರ್‌ಗಳು; ಟೈಪ್‌ಡೆಫ್ ಬೂಲ್ ಇನ್_ಹಾಜರಾತಿ; ಟೈಪ್ಡೆಫ್ ಇಂಟ್ *ಪಿಂಟ್;

ಟೈಪ್‌ಡೆಫ್ ನಿರ್ದೇಶನವನ್ನು ಬಳಸಿಕೊಂಡು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಹೆಸರುಗಳನ್ನು ಟೈಪ್ ಸ್ಪೆಸಿಫೈಯರ್‌ಗಳ ರೀತಿಯಲ್ಲಿಯೇ ಬಳಸಬಹುದು:

// ಡಬಲ್ ಗಂಟೆಗೆ, ಸಾಪ್ತಾಹಿಕ; ಗಂಟೆಗೊಮ್ಮೆ, ವಾರಕ್ಕೊಮ್ಮೆ ಕೂಲಿ; //ವೆಕ್ಟರ್ ವೆಕ್ಲ್ (10);
vec_int vecl(10); //ವೆಕ್ಟರ್ test0(c1ass_size); const int c1ass_size = 34; test_ಸ್ಕೋರ್‌ಗಳು test0(c1ass_size); //ವೆಕ್ಟರ್< bool >ಹಾಜರಾತಿ; ವೆಕ್ಟರ್< in_attendance >ಹಾಜರಾತಿ(c1ass_size); // ಇಂಟ್ * ಟೇಬಲ್[ 10 ]; ಪಿಂಟ್ ಟೇಬಲ್ [10];

ಈ ನಿರ್ದೇಶನವು ಟೈಪ್ ಡೆಫ್ ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ ಟೈಪ್ ಸ್ಪೆಸಿಫೈಯರ್, ಮತ್ತು ಗುರುತಿಸುವಿಕೆಯೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರಕಾರಕ್ಕೆ ಸಮಾನಾರ್ಥಕವಾಗುತ್ತದೆ.
ಟೈಪ್‌ಡೆಫ್ ನಿರ್ದೇಶನವನ್ನು ಬಳಸಿಕೊಂಡು ಯಾವ ಹೆಸರುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ? ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಜ್ಞಾಪಕ ಹೆಸರುಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಸುಲಭವಾಗಿಸಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ಸಂಕೀರ್ಣ ಸಂಯೋಜಿತ ಪ್ರಕಾರಗಳಿಗೆ ಅಂತಹ ಹೆಸರುಗಳನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ (ವಿಭಾಗ 3.14 ರಲ್ಲಿನ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ), ವರ್ಗದ ಕಾರ್ಯಗಳು ಮತ್ತು ಸದಸ್ಯ ಕಾರ್ಯಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಘೋಷಿಸಲು (ವಿಭಾಗ 13.6 ನೋಡಿ).
ಬಹುತೇಕ ಎಲ್ಲರೂ ತಪ್ಪಾಗಿ ಉತ್ತರಿಸುವ ಪ್ರಶ್ನೆಯ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಟೈಪ್‌ಡೆಫ್ ನಿರ್ದೇಶನವನ್ನು ಸರಳ ಪಠ್ಯ ಮ್ಯಾಕ್ರೋ ಬದಲಿಯಾಗಿ ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಿಕೊಳ್ಳುವುದರಿಂದ ದೋಷ ಉಂಟಾಗುತ್ತದೆ. ವ್ಯಾಖ್ಯಾನವನ್ನು ನೀಡಲಾಗಿದೆ:

ಟೈಪ್ಡೆಫ್ ಚಾರ್ *ಸಿಸ್ಟ್ರಿಂಗ್;

ಕೆಳಗಿನ ಘೋಷಣೆಯಲ್ಲಿ cstr ವೇರಿಯೇಬಲ್ ಪ್ರಕಾರ ಯಾವುದು:

ಬಾಹ್ಯ const cstring cstr;

ಉತ್ತರವು ಸ್ಪಷ್ಟವಾಗಿ ತೋರುತ್ತದೆ:

ಕಾನ್ಸ್ಟ್ ಚಾರ್ * ಸಿಎಸ್ಆರ್

ಆದಾಗ್ಯೂ, ಇದು ನಿಜವಲ್ಲ. ಕಾನ್ಸ್ಟ್ ಸ್ಪೆಸಿಫೈಯರ್ cstr ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಸರಿಯಾದ ಉತ್ತರವು ಚಾರ್ಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಆಗಿದೆ:

ಚಾರ್ * const cstr;

3.13. ಬಾಷ್ಪಶೀಲ ಸ್ಪೆಸಿಫೈಯರ್

ಸಿಸ್ಟಂ ಗಡಿಯಾರದಿಂದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನವೀಕರಿಸಿದಂತಹ ಕಂಪೈಲರ್ ಗಮನಿಸದೆ ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದಾದರೆ ವಸ್ತುವನ್ನು ಬಾಷ್ಪಶೀಲವೆಂದು ಘೋಷಿಸಲಾಗುತ್ತದೆ. ಈ ವಸ್ತುವಿನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ಈ ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯು ಕಂಪೈಲರ್‌ಗೆ ಹೇಳುತ್ತದೆ.
ಬಾಷ್ಪಶೀಲ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಕಾನ್ಸ್ಟ್ ಸ್ಪೆಸಿಫೈಯರ್‌ನಂತೆಯೇ ಬಳಸಲಾಗುತ್ತದೆ:

ಬಾಷ್ಪಶೀಲ ಇಂಟ್ disp1ay_register; ಬಾಷ್ಪಶೀಲ ಕಾರ್ಯ *ಕರ್ರ್_ಟಾಸ್ಕ್; ಬಾಷ್ಪಶೀಲ ಇಂಟ್ ixa[max_size]; ಬಾಷ್ಪಶೀಲ ಪರದೆ ಬಿಟ್‌ಮ್ಯಾಪ್_ಬಫ್;

display_register ಎಂಬುದು ಇಂಟ್ ಪ್ರಕಾರದ ಬಾಷ್ಪಶೀಲ ವಸ್ತುವಾಗಿದೆ. curr_task - ಟಾಸ್ಕ್ ವರ್ಗದ ಬಾಷ್ಪಶೀಲ ವಸ್ತುವಿಗೆ ಪಾಯಿಂಟರ್. ixa ಪೂರ್ಣಾಂಕಗಳ ಅಸ್ಥಿರ ಶ್ರೇಣಿಯಾಗಿದೆ, ಮತ್ತು ಅಂತಹ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಅಸ್ಥಿರವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. bitmap_buf ಎಂಬುದು ಸ್ಕ್ರೀನ್ ವರ್ಗದ ಒಂದು ಬಾಷ್ಪಶೀಲ ವಸ್ತುವಾಗಿದೆ, ಅದರ ಪ್ರತಿಯೊಂದು ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಸಹ ಬಾಷ್ಪಶೀಲವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
ಬಾಷ್ಪಶೀಲ ಸ್ಪೆಸಿಫೈಯರ್ ಅನ್ನು ಬಳಸುವ ಏಕೈಕ ಉದ್ದೇಶವೆಂದರೆ ಕೊಟ್ಟಿರುವ ವಸ್ತುವಿನ ಮೌಲ್ಯವನ್ನು ಯಾರು ಮತ್ತು ಹೇಗೆ ಬದಲಾಯಿಸಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಕಂಪೈಲರ್‌ಗೆ ಹೇಳುವುದು. ಆದ್ದರಿಂದ, ಕಂಪೈಲರ್ ಈ ವಸ್ತುವನ್ನು ಬಳಸುವ ಕೋಡ್‌ನಲ್ಲಿ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಮಾಡಬಾರದು.

3.14. ವರ್ಗ ಜೋಡಿ

C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಜೋಡಿ ವರ್ಗವು ಅವುಗಳ ನಡುವೆ ಯಾವುದೇ ಶಬ್ದಾರ್ಥದ ಸಂಪರ್ಕವಿದ್ದರೆ ಒಂದು ವಸ್ತುವಿನೊಂದಿಗೆ ಒಂದು ಜೋಡಿ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಮೌಲ್ಯಗಳು ಒಂದೇ ಅಥವಾ ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳಾಗಿರಬಹುದು. ಈ ವರ್ಗವನ್ನು ಬಳಸಲು ನೀವು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:

#ಸೇರಿಸು

ಉದಾಹರಣೆಗೆ, ಸೂಚನೆಗಳು

ಜೋಡಿ< string, string >ಲೇಖಕ ("ಜೇಮ್ಸ್", "ಜಾಯ್ಸ್");

ಎರಡು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಟೈಪ್ ಜೋಡಿಯ ಲೇಖಕ ವಸ್ತುವನ್ನು ರಚಿಸುತ್ತದೆ.
ಮೊದಲ ಮತ್ತು ಎರಡನೆಯ ಸದಸ್ಯರನ್ನು ಬಳಸಿಕೊಂಡು ಜೋಡಿಯ ಪ್ರತ್ಯೇಕ ಭಾಗಗಳನ್ನು ಪಡೆಯಬಹುದು:

ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಪುಸ್ತಕ; ಒಂದು ವೇಳೆ (Joyce.first == "ಜೇಮ್ಸ್" &&
Joyce.second == "ಜಾಯ್ಸ್")
ಮೊದಲ ಪುಸ್ತಕ = "ಸ್ಟೀಫನ್ ಹೀರೋ";

ಈ ವರ್ಗದ ಒಂದೇ ರೀತಿಯ ಹಲವಾರು ವಸ್ತುಗಳನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾದರೆ, ಟೈಪ್‌ಡೆಫ್ ನಿರ್ದೇಶನವನ್ನು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ:

ಟೈಪ್ಡೆಫ್ ಜೋಡಿ< string, string >ಲೇಖಕರು; ಲೇಖಕರು ಪ್ರೌಸ್ಟ್("ಮಾರ್ಸೆಲ್", "ಪ್ರೌಸ್ಟ್"); ಲೇಖಕರು ಜಾಯ್ಸ್("ಜೇಮ್ಸ್", "ಜಾಯ್ಸ್"); ಲೇಖಕರು ಮುಸಿಲ್("ರಾಬರ್ಟ್", "ಮ್ಯೂಸಿ1");

ಜೋಡಿಯನ್ನು ಬಳಸುವ ಇನ್ನೊಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. ಮೊದಲ ಮೌಲ್ಯವು ಕೆಲವು ವಸ್ತುವಿನ ಹೆಸರನ್ನು ಒಳಗೊಂಡಿದೆ, ಎರಡನೆಯದು ಈ ವಸ್ತುವಿಗೆ ಅನುಗುಣವಾದ ಟೇಬಲ್ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.

ಕ್ಲಾಸ್ ಎಂಟ್ರಿಸ್ಲಾಟ್; extern EntrySlot* 1ook_up(string); ಟೈಪ್‌ಡೆಫ್ ಜೋಡಿ< string, EntrySlot* >ಸಿಂಬಲ್ ಎಂಟ್ರಿ; SymbolEntry current_entry("ಲೇಖಕ", 1ook_up("ಲೇಖಕ"));
// ... ವೇಳೆ (EntrySlot * it = 1ook_up("editor")) (
current_entry.first = "ಸಂಪಾದಕ";
ಪ್ರಸ್ತುತ_ಎಂಟ್ರಿ.ಸೆಕೆಂಡ್ = ಇದು;
}

(ನಾವು ಅಧ್ಯಾಯ 6 ರಲ್ಲಿ ಕಂಟೇನರ್ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ಮತ್ತು ಅಧ್ಯಾಯ 12 ರಲ್ಲಿ ಜೆನೆರಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ ನಾವು ಜೋಡಿ ವರ್ಗಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತೇವೆ.)

3.15. ವರ್ಗ ವಿಧಗಳು

ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ವರ್ಗ ಕಾರ್ಯವಿಧಾನವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ; ಅದರ ಸಹಾಯದಿಂದ, ಮೇಲೆ ಚರ್ಚಿಸಿದ ಸ್ಟ್ರಿಂಗ್, ವೆಕ್ಟರ್, ಸಂಕೀರ್ಣ ಮತ್ತು ಜೋಡಿ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಚಯಿಸಲಾಯಿತು. ಅಧ್ಯಾಯ 2 ರಲ್ಲಿ, ಅರೇ ವರ್ಗದ ಅನುಷ್ಠಾನದ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ವಸ್ತು ಮತ್ತು ವಸ್ತು-ಆಧಾರಿತ ವಿಧಾನಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ನಾವು ಪರಿಚಯಿಸಿದ್ದೇವೆ. ಇಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ವಿಧಾನವನ್ನು ಆಧರಿಸಿ, ನಾವು ಸರಳವಾದ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದರ ಅನುಷ್ಠಾನವು ನಮಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ, ಆಪರೇಟರ್ ಓವರ್‌ಲೋಡಿಂಗ್ - ನಾವು ಅದರ ಬಗ್ಗೆ ವಿಭಾಗ 2.3 ರಲ್ಲಿ ಮಾತನಾಡಿದ್ದೇವೆ. (ಅಧ್ಯಾಯಗಳು 13, 14 ಮತ್ತು 15 ರಲ್ಲಿ ತರಗತಿಗಳನ್ನು ವಿವರವಾಗಿ ಒಳಗೊಂಡಿದೆ.) ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಉದಾಹರಣೆಗಳನ್ನು ನೀಡಲು ನಾವು ವರ್ಗದ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆಯನ್ನು ನೀಡಿದ್ದೇವೆ. C++ ಗೆ ಹೊಸ ಓದುಗರು ಈ ವಿಭಾಗವನ್ನು ಬಿಟ್ಟುಬಿಡಲು ಬಯಸಬಹುದು ಮತ್ತು ನಂತರದ ಅಧ್ಯಾಯಗಳಲ್ಲಿ ತರಗತಿಗಳ ಹೆಚ್ಚು ವ್ಯವಸ್ಥಿತ ವಿವರಣೆಗಾಗಿ ಕಾಯಬಹುದು.)
ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವು ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ವಸ್ತು, ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ ಮತ್ತು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ಮೂಲಕ ಪ್ರಾರಂಭವನ್ನು ಬೆಂಬಲಿಸಬೇಕು, ಹಾಗೆಯೇ ಈ ಪ್ರಕಾರಗಳಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಬೆಂಬಲಿಸಬೇಕು. ಇದಕ್ಕಾಗಿ ನಾವು ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳು ಮತ್ತು ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ವೈಯಕ್ತಿಕ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಮಗೆ ಅಗತ್ಯವಿದೆ: ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಗಾತ್ರ () ಕಾರ್ಯ; ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರದ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಹೋಲಿಸುವ ಕಾರ್ಯಾಚರಣೆ; ಹಾಗೆಯೇ ನಮ್ಮ ವಸ್ತುವಿನ I/O ಕಾರ್ಯಾಚರಣೆಗಳು. ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್‌ನ ಆಂತರಿಕ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರವಾಗಿ ಪ್ರವೇಶಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.
ವರ್ಗ ವ್ಯಾಖ್ಯಾನವು ಕೀವರ್ಡ್ ವರ್ಗದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ ಗುರುತಿಸುವಿಕೆ-ವರ್ಗದ ಹೆಸರು ಅಥವಾ ಪ್ರಕಾರ. ಸಾಮಾನ್ಯವಾಗಿ, ಒಂದು ವರ್ಗವು ಸಾರ್ವಜನಿಕ (ತೆರೆದ) ಮತ್ತು ಖಾಸಗಿ (ಮುಚ್ಚಿದ) ಪದಗಳಿಂದ ಮುಂಚಿತವಾಗಿ ವಿಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಸಾರ್ವಜನಿಕ ವಿಭಾಗವು ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಗದಿಂದ ಬೆಂಬಲಿತವಾದ ಕಾರ್ಯಾಚರಣೆಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದನ್ನು ವಿಧಾನಗಳು ಅಥವಾ ವರ್ಗದ ಸದಸ್ಯ ಕಾರ್ಯಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಸದಸ್ಯ ಕಾರ್ಯಗಳು ವರ್ಗದ ಸಾರ್ವಜನಿಕ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಆ ವರ್ಗದ ವಸ್ತುಗಳ ಮೇಲೆ ಮಾಡಬಹುದಾದ ಕ್ರಿಯೆಗಳ ಸೆಟ್. ಖಾಸಗಿ ವಿಭಾಗವು ಸಾಮಾನ್ಯವಾಗಿ ಆಂತರಿಕ ಅನುಷ್ಠಾನವನ್ನು ಒದಗಿಸುವ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಆಂತರಿಕ ಸದಸ್ಯರು _ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತಾರೆ - ಒಂದು ಚಾರ್ಗೆ ಪಾಯಿಂಟರ್, ಹಾಗೆಯೇ ಇಂಟ್ನ _ ಗಾತ್ರ. _size ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು _string ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯಾಗಿದೆ. ವರ್ಗ ವ್ಯಾಖ್ಯಾನವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

#ಸೇರಿಸು ವರ್ಗ ಸ್ಟ್ರಿಂಗ್; istream& ಆಪರೇಟರ್>>(istream&, String&);
ಓಸ್ಟ್ರೀಮ್ ಮತ್ತು ಆಪರೇಟರ್<<(ostream&, const String&); class String {
ಸಾರ್ವಜನಿಕ:
// ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ಗಳ ಸೆಟ್
// ಸ್ವಯಂಚಾಲಿತ ಪ್ರಾರಂಭಕ್ಕಾಗಿ
// ಸ್ಟ್ರಿಂಗ್ strl; // ಸ್ಟ್ರಿಂಗ್()
// ಸ್ಟ್ರಿಂಗ್ str2("ಅಕ್ಷರಶಃ"); // ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಚಾರ್*);
// ಸ್ಟ್ರಿಂಗ್ str3(str2); // ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಸ್ಟ್ರಿಂಗ್&); ಸ್ಟ್ರಿಂಗ್ ();
ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಚಾರ್*);
ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಸ್ಟ್ರಿಂಗ್&); // ವಿಧ್ವಂಸಕ
~ಸ್ಟ್ರಿಂಗ್ (); // ನಿಯೋಜನೆ ನಿರ್ವಾಹಕರು
// strl = str2
// str3 = "ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ" ಸ್ಟ್ರಿಂಗ್& ಆಪರೇಟರ್=(const String&);
ಸ್ಟ್ರಿಂಗ್& ಆಪರೇಟರ್=(const char*); // ಸಮಾನತೆ ಪರೀಕ್ಷಾ ನಿರ್ವಾಹಕರು
// strl == str2;
// str3 == "ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಶಃ"; bool ಆಪರೇಟರ್==(const String&);
bool operator==(const char*); // ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶ ಆಪರೇಟರ್ ಅನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡುವುದು
// strl[ 0 ] = str2[ 0 ]; ಚಾರ್& ಆಪರೇಟರ್(ಇಂಟ್); // ವರ್ಗ ಸದಸ್ಯರಿಗೆ ಪ್ರವೇಶ
ಇಂಟ್ ಗಾತ್ರ () (ರಿಟರ್ನ್ _ ಗಾತ್ರ;)
ಚಾರ್ * c_str () ( ರಿಟರ್ನ್ _ಸ್ಟ್ರಿಂಗ್; ) ಖಾಸಗಿ:
int_size;
ಚಾರ್ *_ಸ್ಟ್ರಿಂಗ್;
}

ಸ್ಟ್ರಿಂಗ್ ವರ್ಗವು ಮೂರು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಹೊಂದಿದೆ. ವಿಭಾಗ 2.3 ರಲ್ಲಿ ಚರ್ಚಿಸಿದಂತೆ, ಓವರ್‌ಲೋಡಿಂಗ್ ಕಾರ್ಯವಿಧಾನವು ಒಂದೇ ಹೆಸರಿನೊಂದಿಗೆ ಕಾರ್ಯಗಳ ಬಹು ಅನುಷ್ಠಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಅವುಗಳು ಎಲ್ಲಾ ಸಂಖ್ಯೆ ಮತ್ತು/ಅಥವಾ ಅವುಗಳ ನಿಯತಾಂಕಗಳ ಪ್ರಕಾರಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ಮೊದಲ ನಿರ್ಮಾಣಕಾರ

ಇದು ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಏಕೆಂದರೆ ಇದಕ್ಕೆ ಸ್ಪಷ್ಟ ಆರಂಭಿಕ ಮೌಲ್ಯದ ಅಗತ್ಯವಿಲ್ಲ. ನಾವು ಬರೆಯುವಾಗ:

str1 ಗಾಗಿ, ಅಂತಹ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.
ಉಳಿದಿರುವ ಎರಡು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳು ಪ್ರತಿಯೊಂದೂ ಒಂದು ನಿಯತಾಂಕವನ್ನು ಹೊಂದಿವೆ. ಹೌದು, ಫಾರ್

ಸ್ಟ್ರಿಂಗ್ str2("ಕ್ಯಾರೆಕ್ಟರ್ ಸ್ಟ್ರಿಂಗ್");

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ

ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಚಾರ್*);

ಸ್ಟ್ರಿಂಗ್ str3(str2);

ಕನ್ಸ್ಟ್ರಕ್ಟರ್

ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಸ್ಟ್ರಿಂಗ್&);

ಎಂಬ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪ್ರಕಾರವನ್ನು ನಿಜವಾದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರಕಾರದಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳಲ್ಲಿ ಕೊನೆಯದು, ಸ್ಟ್ರಿಂಗ್ (ಕಾನ್ಸ್ಟ್ ಸ್ಟ್ರಿಂಗ್&) ಅನ್ನು ಕಾಪಿ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಇನ್ನೊಂದು ವಸ್ತುವಿನ ನಕಲನ್ನು ಹೊಂದಿರುವ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ನೀವು ಬರೆದರೆ:

ಸ್ಟ್ರಿಂಗ್ str4(1024);

ಇದು ಸಂಕಲನ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ, ಏಕೆಂದರೆ ಇಂಟ್ ಪ್ರಕಾರದ ನಿಯತಾಂಕದೊಂದಿಗೆ ಯಾವುದೇ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಇಲ್ಲ.
ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಆಪರೇಟರ್ ಘೋಷಣೆಯು ಈ ಕೆಳಗಿನ ಸ್ವರೂಪವನ್ನು ಹೊಂದಿದೆ:

ರಿಟರ್ನ್_ಟೈಪ್ ಆಪರೇಟರ್ ಆಪ್ (ಪ್ಯಾರಾಮೀಟರ್_ಲಿಸ್ಟ್);

ಆಪರೇಟರ್ ಒಂದು ಕೀವರ್ಡ್ ಆಗಿದ್ದರೆ, ಮತ್ತು op ಪೂರ್ವನಿರ್ಧರಿತ ಆಪರೇಟರ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ: +, =, ==, ಇತ್ಯಾದಿ. (ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ನಿಖರವಾದ ವ್ಯಾಖ್ಯಾನಕ್ಕಾಗಿ ಅಧ್ಯಾಯ 15 ಅನ್ನು ನೋಡಿ.) ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಸೂಚ್ಯಂಕ ಆಪರೇಟರ್‌ನ ಘೋಷಣೆ ಇಲ್ಲಿದೆ:

ಚಾರ್& ಆಪರೇಟರ್(ಇಂಟ್);

ಈ ಆಪರೇಟರ್ ಇಂಟ್ ಪ್ರಕಾರದ ಒಂದು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಚಾರ್ಗೆ ಉಲ್ಲೇಖವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ವೈಯಕ್ತಿಕ ಇನ್‌ಸ್ಟಾಂಟಿಯೇಶನ್‌ಗಳ ಪ್ಯಾರಾಮೀಟರ್ ಪಟ್ಟಿಗಳು ಭಿನ್ನವಾಗಿದ್ದರೆ ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಆಪರೇಟರ್ ಸ್ವತಃ ಓವರ್‌ಲೋಡ್ ಆಗಬಹುದು. ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ವರ್ಗಕ್ಕಾಗಿ, ನಾವು ಎರಡು ವಿಭಿನ್ನ ನಿಯೋಜನೆ ಮತ್ತು ಸಮಾನತೆಯ ನಿರ್ವಾಹಕರನ್ನು ರಚಿಸುತ್ತೇವೆ.
ಸದಸ್ಯರ ಕಾರ್ಯವನ್ನು ಕರೆಯಲು, ಸದಸ್ಯ ಪ್ರವೇಶ ನಿರ್ವಾಹಕರು ಡಾಟ್ (.) ಅಥವಾ ಬಾಣ (->) ಬಳಸಿ. ನಾವು ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ವಸ್ತುಗಳ ಘೋಷಣೆಗಳನ್ನು ಹೊಂದೋಣ:

ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ ("ಡ್ಯಾನಿ");
ಸ್ಟ್ರಿಂಗ್ *ptr = ಹೊಸ ಸ್ಟ್ರಿಂಗ್("ಅನ್ನಾ");
ಸ್ಟ್ರಿಂಗ್ ಅರೇ;
ಈ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಗಾತ್ರ() ಗೆ ಕರೆ ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
ವೆಕ್ಟರ್ ಗಾತ್ರಗಳು (3);

// ವಸ್ತುಗಳಿಗೆ ಪ್ರವೇಶ ಸದಸ್ಯ (.); // ವಸ್ತುಗಳು 5 ಗಾತ್ರದ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ[ 0 ] = object.size(); // ಪಾಯಿಂಟರ್‌ಗಳಿಗೆ ಸದಸ್ಯರ ಪ್ರವೇಶ (->)
// ptr ಗಾತ್ರ 4 ಅನ್ನು ಹೊಂದಿದೆ
ಗಾತ್ರಗಳು[ 1 ] = ptr-> ಗಾತ್ರ (); // ಪ್ರವೇಶ ಸದಸ್ಯ (.)
// ರಚನೆಯು 0 ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ
ಗಾತ್ರಗಳು[ 2 ] = array.size();

ಇದು ಕ್ರಮವಾಗಿ 5, 4 ಮತ್ತು 0 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ಆಪರೇಟರ್‌ಗಳನ್ನು ನಿಯಮಿತವಾದ ರೀತಿಯಲ್ಲಿಯೇ ವಸ್ತುವಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ:

ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು ("ಯಾಡಿ"); ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು2("ಯೋಡಿ"); // bool operator==(const String&)
ಒಂದು ವೇಳೆ (ಹೆಸರು == ಹೆಸರು2)
ಹಿಂತಿರುಗಿ;
ಬೇರೆ
// ಸ್ಟ್ರಿಂಗ್& ಆಪರೇಟರ್=(const String&)
ಹೆಸರು = ಹೆಸರು2;

ಸದಸ್ಯ ಕಾರ್ಯದ ಘೋಷಣೆಯು ವರ್ಗ ವ್ಯಾಖ್ಯಾನದ ಒಳಗಿರಬೇಕು, ಮತ್ತು ಕಾರ್ಯದ ವ್ಯಾಖ್ಯಾನವು ವರ್ಗ ವ್ಯಾಖ್ಯಾನದ ಒಳಗೆ ಅಥವಾ ಹೊರಗೆ ಇರಬಹುದು. (ಎರಡೂ ಗಾತ್ರ() ಮತ್ತು c_str() ಕಾರ್ಯಗಳನ್ನು ವರ್ಗದ ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.) ಒಂದು ಕಾರ್ಯವನ್ನು ವರ್ಗದ ಹೊರಗೆ ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ ಅದು ಯಾವ ವರ್ಗಕ್ಕೆ ಸೇರಿದೆ ಎಂಬುದನ್ನು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕ್ರಿಯೆಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಮೂಲ ಫೈಲ್‌ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, String.C ಎಂದು ಹೇಳಿ, ಮತ್ತು ವರ್ಗದ ವ್ಯಾಖ್ಯಾನವನ್ನು ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ (ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ String.h), ಅದನ್ನು ಮೂಲದಲ್ಲಿ ಸೇರಿಸಬೇಕು. :

// ಮೂಲ ಫೈಲ್‌ನ ವಿಷಯಗಳು: String.C // ಸ್ಟ್ರಿಂಗ್ ವರ್ಗದ ವ್ಯಾಖ್ಯಾನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ
#include "String.h" // strcmp() ಕಾರ್ಯದ ವ್ಯಾಖ್ಯಾನವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ
#ಸೇರಿಸು
bool // ರಿಟರ್ನ್ ಪ್ರಕಾರ
ಸ್ಟ್ರಿಂಗ್:: // ಕಾರ್ಯವು ಸೇರಿರುವ ವರ್ಗ
ಆಪರೇಟರ್== // ಕಾರ್ಯದ ಹೆಸರು: ಸಮಾನತೆ ಆಪರೇಟರ್
(const String &rhs) // ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಪಟ್ಟಿ
{
ವೇಳೆ (_ಗಾತ್ರ != rhs._size)
ಸುಳ್ಳು ಹಿಂತಿರುಗಿ;
strcmp(_strinq, rhs._string) ಹಿಂತಿರುಗಿಸುವುದೇ?
ತಪ್ಪು ಸರಿ;
}

strcmp() ಎನ್ನುವುದು C ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿ ಕಾರ್ಯವಾಗಿದೆ ಎಂದು ನೆನಪಿಸಿಕೊಳ್ಳಿ. ಇದು ಎರಡು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ, ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಸಮಾನವಾಗಿದ್ದರೆ 0 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಅವು ಸಮಾನವಾಗಿಲ್ಲದಿದ್ದರೆ ಶೂನ್ಯವಲ್ಲ. ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ (?:) ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಯ ಮೊದಲು ಮೌಲ್ಯವನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ. ನಿಜವಾಗಿದ್ದರೆ, ಕೊಲೊನ್‌ನ ಎಡಭಾಗದಲ್ಲಿರುವ ಅಭಿವ್ಯಕ್ತಿಯ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಬಲಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, strcmp() ಶೂನ್ಯವಲ್ಲದ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ ಅಭಿವ್ಯಕ್ತಿಯ ಮೌಲ್ಯವು ತಪ್ಪಾಗಿರುತ್ತದೆ ಮತ್ತು ಅದು ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ ಸರಿ. (ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ ಅನ್ನು ವಿಭಾಗ 4.7 ರಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ.)
ಹೋಲಿಕೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಾಕಷ್ಟು ಬಾರಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕಾರ್ಯವು ಚಿಕ್ಕದಾಗಿದೆ, ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯವನ್ನು ಅಂತರ್ನಿರ್ಮಿತ (ಇನ್ಲೈನ್) ಘೋಷಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಕಂಪೈಲರ್ ಕರೆ ಮಾಡುವ ಬದಲು ಕಾರ್ಯದ ಪಠ್ಯವನ್ನು ಬದಲಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅಂತಹ ಕರೆಯಲ್ಲಿ ಯಾವುದೇ ಸಮಯ ವ್ಯರ್ಥವಾಗುವುದಿಲ್ಲ. (ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ವಿಭಾಗ 7.6 ರಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ.) ವರ್ಗದೊಳಗೆ ವಿವರಿಸಲಾದ ಸದಸ್ಯ ಕಾರ್ಯವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅಂತರ್ನಿರ್ಮಿತವಾಗಿದೆ. ಇದನ್ನು ವರ್ಗದ ಹೊರಗೆ ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಅದನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಎಂದು ಘೋಷಿಸಲು, ನೀವು ಇನ್‌ಲೈನ್ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ:

ಇನ್‌ಲೈನ್ ಬೂಲ್ ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್==(const String &rhs) (// ಅದೇ ವಿಷಯ)

ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯದ ವ್ಯಾಖ್ಯಾನವು ವರ್ಗ ವ್ಯಾಖ್ಯಾನವನ್ನು ಒಳಗೊಂಡಿರುವ ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿರಬೇಕು. == ಆಪರೇಟರ್ ಅನ್ನು ಇನ್‌ಲೈನ್ ಆಪರೇಟರ್ ಆಗಿ ಮರು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನಾವು ಫಂಕ್ಷನ್ ಪಠ್ಯವನ್ನು String.C ಫೈಲ್‌ನಿಂದ String.h ಫೈಲ್‌ಗೆ ಸರಿಸಬೇಕು.
ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುವನ್ನು ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದೊಂದಿಗೆ ಹೋಲಿಸುವ ಕಾರ್ಯಾಚರಣೆಯ ಅನುಷ್ಠಾನವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

ಇನ್‌ಲೈನ್ ಬೂಲ್ ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್==(const char *s) ( strcmp(_string, s) ಹಿಂತಿರುಗಿಸುವುದೇ? ತಪ್ಪು: ನಿಜ; )

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಹೆಸರು ವರ್ಗದ ಹೆಸರಿನಂತೆಯೇ ಇರುತ್ತದೆ. ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ ಎಂದು ಪರಿಗಣಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಅದರ ವ್ಯಾಖ್ಯಾನದಲ್ಲಿ ಅಥವಾ ಅದರ ದೇಹದಲ್ಲಿ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಹಲವಾರು ನಿರ್ಮಾಣಕಾರರು ಇರಬಹುದು. ಯಾವುದೇ ಇತರ ಕಾರ್ಯಗಳಂತೆ, ಅವುಗಳನ್ನು ಇನ್ಲೈನ್ ​​ಎಂದು ಘೋಷಿಸಬಹುದು.

#ಸೇರಿಸು // ಡೀಫಾಲ್ಟ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್:: ಸ್ಟ್ರಿಂಗ್()
{
_ಗಾತ್ರ = 0;
_ಸ್ಟ್ರಿಂಗ್ = 0;
) ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್:: ಸ್ಟ್ರಿಂಗ್ (const char *str) (ಒಂದು ವೇಳೆ (! str) (_size = 0; _string = 0; ) ಬೇರೆ (_size = str1en(str); strcpy (_string, str); ) // ಕಾಪಿ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್
ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್::ಸ್ಟ್ರಿಂಗ್(const String &rhs)
{
ಗಾತ್ರ = rhs._size;
ಒಂದು ವೇಳೆ (! rhs._string)
_ಸ್ಟ್ರಿಂಗ್ = 0;
ಬೇರೆ (
_ಸ್ಟ್ರಿಂಗ್ = ಹೊಸ ಚಾರ್[_size + 1];
} }

ನಾವು ಹೊಸ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಮೊರಿಯನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಿರುವುದರಿಂದ, ನಮಗೆ ಇನ್ನು ಮುಂದೆ ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಅಳಿಸಲು ಕರೆ ಮಾಡುವ ಮೂಲಕ ನಾವು ಅದನ್ನು ಮುಕ್ತಗೊಳಿಸಬೇಕಾಗಿದೆ. ಮತ್ತೊಂದು ವಿಶೇಷ ಸದಸ್ಯ ಕಾರ್ಯವು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ - ಡಿಸ್ಟ್ರಕ್ಟರ್, ಈ ವಸ್ತುವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಕ್ಷಣದಲ್ಲಿ ವಸ್ತುವಿನ ಮೇಲೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲ್ಪಡುತ್ತದೆ. (ಆಬ್ಜೆಕ್ಟ್ ಜೀವಿತಾವಧಿಯ ಬಗ್ಗೆ ಅಧ್ಯಾಯ 7 ಅನ್ನು ನೋಡಿ.) ವಿಧ್ವಂಸಕನ ಹೆಸರನ್ನು ಟಿಲ್ಡ್ ಅಕ್ಷರ (~) ಮತ್ತು ವರ್ಗದ ಹೆಸರಿನಿಂದ ರಚಿಸಲಾಗಿದೆ. ಸ್ಟ್ರಿಂಗ್ ಕ್ಲಾಸ್ ಡಿಸ್ಟ್ರಕ್ಟರ್‌ನ ವ್ಯಾಖ್ಯಾನ ಇಲ್ಲಿದೆ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ನಾವು ಅಳಿಸುವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಇಲ್ಲಿ ಕರೆಯುತ್ತೇವೆ:

ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್: :~ಸ್ಟ್ರಿಂಗ್() (_ಸ್ಟ್ರಿಂಗ್ ಅಳಿಸಿ;)

ಎರಡೂ ಓವರ್‌ಲೋಡ್ ಮಾಡಲಾದ ನಿಯೋಜನೆ ಆಪರೇಟರ್‌ಗಳು ವಿಶೇಷ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ.
ನಾವು ಬರೆಯುವಾಗ:

ಸ್ಟ್ರಿಂಗ್ ನಾಮಲ್("ಓರ್ವಿಲ್ಲೆ"), ಹೆಸರು2("ವಿಲ್ಬರ್");
ಹೆಸರು = "ಒರ್ವಿಲ್ಲೆ ರೈಟ್";
ಇದು ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಯ ಫಂಕ್ಷನ್ ಬಾಡಿ ಒಳಗೆ name1 ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ತಿಳಿಸುವ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.
ಇದು ಯಾವಾಗಲೂ ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ವರ್ಗ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಒಂದು ವೇಳೆ
ptr-> ಗಾತ್ರ ();
obj[1024];

ನಂತರ ಗಾತ್ರದ ಒಳಗೆ () ಇದರ ಮೌಲ್ಯವು ptr ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ವಿಳಾಸವಾಗಿರುತ್ತದೆ. ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಯ ಒಳಗೆ, ಇದು obj ನ ವಿಳಾಸವನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದನ್ನು ಡಿಫರೆನ್ಸ್ ಮಾಡುವ ಮೂಲಕ (*ಇದನ್ನು ಬಳಸಿ), ನಾವು ವಸ್ತುವನ್ನು ಪಡೆಯುತ್ತೇವೆ. (ಈ ಪಾಯಿಂಟರ್ ಅನ್ನು ವಿಭಾಗ 13.4 ರಲ್ಲಿ ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ.)

ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್=(const char *s) ((! s) (_size = 0; ಅಳಿಸಿ _string; _string = 0; ) ಬೇರೆ (_size = str1en(s); _string ಅಳಿಸಿ; _string = ಹೊಸ ಚಾರ್[_size + 1 ]; strcpy (_string, s); ) ಹಿಂತಿರುಗಿ *ಇದು; )

ನಿಯೋಜನೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ಆಗಾಗ್ಗೆ ಮಾಡಲಾಗುವ ಒಂದು ತಪ್ಪು ಎಂದರೆ ನಕಲು ಮಾಡಲಾದ ವಸ್ತುವು ನಕಲು ಮಾಡಲಾಗುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಅವರು ಮರೆತುಬಿಡುತ್ತಾರೆ. ಈ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಈ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡುತ್ತೇವೆ:

ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್& ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್=(const String &rhs) ( // ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ // namel = *pointer_to_string // ಇದು name1 ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, // rhs - *pointer_to_string. ವೇಳೆ (ಇದು != &rhs) (

ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಒಂದೇ ರೀತಿಯ ವಸ್ತುವನ್ನು ನಿಯೋಜಿಸುವ ಕಾರ್ಯಾಚರಣೆಯ ಸಂಪೂರ್ಣ ಪಠ್ಯ ಇಲ್ಲಿದೆ:

ಇನ್‌ಲೈನ್ ಸ್ಟ್ರಿಂಗ್& ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್=(const String &rhs) ((ಇದು != &rhs) (_string ಅಳಿಸಿ; _size = rhs._size; ವೇಳೆ (! rhs._string)
_ಸ್ಟ್ರಿಂಗ್ = 0;
ಬೇರೆ (
_ಸ್ಟ್ರಿಂಗ್ = ಹೊಸ ಚಾರ್[_size + 1];
strcpy(_string, rhs._string);
}
}
ಹಿಂತಿರುಗಿ *ಇದು;
}

ನಾವು ವಿಭಾಗ 2.3 ರಲ್ಲಿ ರಚಿಸಿದ ಅರೇ ಅರೇಗಾಗಿ ಸೂಚ್ಯಂಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಕಾರ್ಯಾಚರಣೆಯು ಅದರ ಅನುಷ್ಠಾನಕ್ಕೆ ಬಹುತೇಕ ಹೋಲುತ್ತದೆ:

#ಸೇರಿಸು ಇನ್ಲೈನ್ ​​ಚಾರ್&
ಸ್ಟ್ರಿಂಗ್ :: ಆಪರೇಟರ್ (ಇಂಟ್ ಎಲಿಮ್)
{
ಪ್ರತಿಪಾದಿಸಿ(ಎಲೆಮ್ >= 0 && ಎಲಿಮ್< _size);
ಹಿಂತಿರುಗಿ _ಸ್ಟ್ರಿಂಗ್[ಎಲೆಮ್];
}

ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಆಪರೇಟರ್‌ಗಳನ್ನು ವರ್ಗ ಸದಸ್ಯರಿಗಿಂತ ಪ್ರತ್ಯೇಕ ಕಾರ್ಯಗಳಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ. (ನಾವು ವಿಭಾಗ 15.2 ರಲ್ಲಿ ಇದಕ್ಕೆ ಕಾರಣಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ. ವಿಭಾಗಗಳು 20.4 ಮತ್ತು 20.5 iostream ಲೈಬ್ರರಿಯ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಆಪರೇಟರ್‌ಗಳನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡುವ ಕುರಿತು ಮಾತನಾಡುತ್ತವೆ.) ನಮ್ಮ ಇನ್‌ಪುಟ್ ಆಪರೇಟರ್ ಗರಿಷ್ಠ 4095 ಅಕ್ಷರಗಳನ್ನು ಓದಬಹುದು. setw() ಒಂದು ಪೂರ್ವನಿರ್ಧರಿತ ಮ್ಯಾನಿಪ್ಯುಲೇಟರ್ ಆಗಿದೆ, ಇದು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಅಕ್ಷರಗಳನ್ನು ಮೈನಸ್ 1 ಅನ್ನು ಓದುತ್ತದೆ, ಇದರಿಂದಾಗಿ ನಾವು ನಮ್ಮ ಆಂತರಿಕ ಬಫರ್ inBuf ಅನ್ನು ಅತಿಕ್ರಮಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. (ಅಧ್ಯಾಯ 20 setw() ಮ್ಯಾನಿಪ್ಯುಲೇಟರ್ ಅನ್ನು ವಿವರವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ.) ಮ್ಯಾನಿಪ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಬಳಸಲು, ನೀವು ಸೂಕ್ತವಾದ ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕು:

#ಸೇರಿಸು inline istream& operator>>(istream &io, String &s) ( // ಕೃತಕ ಮಿತಿ: 4096 ಅಕ್ಷರಗಳ const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() ಅನ್ನು iostream ಲೈಬ್ರರಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ // ಇದು ಗಾತ್ರವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ 1imit_string_size -l io ಗೆ ಓದಬಹುದಾದ ಬ್ಲಾಕ್ >> setw(1imit_string_size) >> inBuf; s = mBuf; // ಸ್ಟ್ರಿಂಗ್:: ಆಪರೇಟರ್=(const char*); io ಹಿಂತಿರುಗಿ; )

ಔಟ್‌ಪುಟ್ ಆಪರೇಟರ್‌ಗೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಆಂತರಿಕ ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಪ್ರವೇಶದ ಅಗತ್ಯವಿದೆ. ಆಪರೇಟರ್ ಆಗಿರುವುದರಿಂದ<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

ಇನ್‌ಲೈನ್ ಓಸ್ಟ್ರೀಮ್ ಮತ್ತು ಆಪರೇಟರ್<<(ostream& os, const String &s) { return os << s.c_str(); }

ಸ್ಟ್ರಿಂಗ್ ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ ಪ್ರೋಗ್ರಾಂ ಕೆಳಗೆ ಇದೆ. ಈ ಪ್ರೋಗ್ರಾಂ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಪದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುತ್ತದೆ, ಜೊತೆಗೆ "ದಿ" ಮತ್ತು "ಇದು" ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುತ್ತದೆ ಮತ್ತು ಎದುರಿಸಿದ ಸ್ವರಗಳನ್ನು ದಾಖಲಿಸುತ್ತದೆ.

#ಸೇರಿಸು #include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / "ದಿ" ಮತ್ತು "ಇದು" ಪದಗಳು
// ನಾವು ಆಪರೇಟರ್ ಬಳಸಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ==(const char*)
ಸ್ಟ್ರಿಂಗ್ ಆದರೆ, ದಿ("ದ"), ಇದು("ಇದು"); // ಆಪರೇಟರ್>>(ಓಸ್ಟ್ರೀಮ್&, ಸ್ಟ್ರಿಂಗ್&)
ಹಾಗೆಯೇ (ಸಿನ್ >> ಬಫ್) (
++wdCnt; // ಆಪರೇಟರ್<<(ostream&, const String&)
ಕೌಟ್<< buf << " "; if (wdCnt % 12 == 0)
ಕೌಟ್<< endl; // String::operator==(const String&) and
// ಸ್ಟ್ರಿಂಗ್ :: ಆಪರೇಟರ್ ==(const char*);
ಒಂದು ವೇಳೆ (buf == the | | buf == "The")
++theCnt;
ಬೇರೆ
ವೇಳೆ (buf == ಇದು || buf == "ಇದು")
++itCnt; // ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಆಹ್ವಾನಿಸುತ್ತದೆ ::s-ize()
ಗಾಗಿ (ಇಂಟ್ ix =0; ix< buf.sizeO; ++ix)
{
// ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಆಹ್ವಾನಿಸುತ್ತದೆ :: ಆಪರೇಟರ್ (ಇಂಟ್)
ಸ್ವಿಚ್ (ಬಫ್[ ix ])
{
ಪ್ರಕರಣ "a": ಪ್ರಕರಣ "A": ++aCnt; ಬ್ರೇಕ್;
ಕೇಸ್ "ಇ": ಕೇಸ್ "ಇ": ++eCnt; ಬ್ರೇಕ್;
ಸಂದರ್ಭದಲ್ಲಿ "i": ಕೇಸ್ "I": ++iCnt; ಬ್ರೇಕ್;
ಪ್ರಕರಣ "o": ಪ್ರಕರಣ "0": ++oCnt; ಬ್ರೇಕ್;
ಕೇಸ್ "ಯು": ಕೇಸ್ "ಯು": ++uCnt; ಬ್ರೇಕ್;
ಡೀಫಾಲ್ಟ್: ++notVowe1; ಬ್ರೇಕ್;
}
}
) // ಆಪರೇಟರ್<<(ostream&, const String&)
ಕೌಟ್<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರೀಕ್ಷಿಸೋಣ: ಈ ಪುಸ್ತಕದ ಲೇಖಕರಲ್ಲಿ ಒಬ್ಬರು ಬರೆದ ಮಕ್ಕಳ ಕಥೆಯಿಂದ ನಾವು ಪ್ಯಾರಾಗ್ರಾಫ್ ಅನ್ನು ನೀಡುತ್ತೇವೆ (ನಾವು ಈ ಕಥೆಯನ್ನು ಅಧ್ಯಾಯ 6 ರಲ್ಲಿ ಭೇಟಿ ಮಾಡುತ್ತೇವೆ). ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶ ಇಲ್ಲಿದೆ:

ಆಲಿಸ್ ಎಮ್ಮಾ ಉದ್ದನೆಯ ಕೆಂಪು ಕೂದಲನ್ನು ಹೊಂದಿದ್ದಾಳೆ. ಅವಳ ಡ್ಯಾಡಿ ಹೇಳುತ್ತಾರೆ ಗಾಳಿಯು ಅವಳ ಕೂದಲಿನ ಮೂಲಕ ಬೀಸಿದಾಗ, ಅದು ಬಹುತೇಕ ಜೀವಂತವಾಗಿ ಕಾಣುತ್ತದೆ, 1 ಹಾರಾಟದಲ್ಲಿ ಉರಿಯುತ್ತಿರುವ ಹಕ್ಕಿಯಂತೆ. ಸುಂದರವಾದ ಉರಿಯುತ್ತಿರುವ ಹಕ್ಕಿ, ಅವನು ಅವಳಿಗೆ ಹೇಳುತ್ತಾನೆ, ಮಾಂತ್ರಿಕ ಆದರೆ ಪಳಗಿಸಲಾಗಿಲ್ಲ. "ಅಪ್ಪಾ, ಶುಶ್, ಅಂತಹದ್ದೇನೂ ಇಲ್ಲ," ಅವಳು ಅವನಿಗೆ ಹೇಳುತ್ತಾಳೆ, ಅದೇ ಸಮಯದಲ್ಲಿ ಅವನು ಅವಳಿಗೆ ಹೆಚ್ಚು ಹೇಳಬೇಕೆಂದು ಬಯಸುತ್ತಾಳೆ. ನಾಚಿಕೆಯಿಂದ "ಅಂದರೆ ಅಪ್ಪ ಇದ್ದಾನಾ?" ಎಂದು ಕೇಳುತ್ತಾಳೆ. ಪದಗಳು: 65
ದಿ/ದಿ: 2
ಇದು/ಇದು: 1
ವ್ಯಂಜನಗಳು: 190
ಎ: 22
ಇ: 30
ನಾನು: 24
o: 10
ಯು: 7

ವ್ಯಾಯಾಮ 3.26

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳು ಮತ್ತು ಅಸೈನ್‌ಮೆಂಟ್ ಆಪರೇಟರ್‌ಗಳ ನಮ್ಮ ಅನುಷ್ಠಾನಗಳು ಬಹಳಷ್ಟು ಪುನರಾವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ವಿಭಾಗ 2.3 ರಲ್ಲಿ ಮಾಡಿದಂತೆ ನಕಲಿ ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಖಾಸಗಿ ಸದಸ್ಯ ಕಾರ್ಯಕ್ಕೆ ಸರಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಹೊಸ ಆಯ್ಕೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ವ್ಯಾಯಾಮ 3.27

ಪರೀಕ್ಷಾ ಕಾರ್ಯಕ್ರಮವನ್ನು ಮಾರ್ಪಡಿಸಿ ಇದರಿಂದ ಅದು b, d, f, s, t ವ್ಯಂಜನಗಳನ್ನು ಎಣಿಸುತ್ತದೆ.

ವ್ಯಾಯಾಮ 3.28

ಕೆಳಗಿನ ಘೋಷಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಪಾತ್ರದ ಸಂಭವಿಸುವಿಕೆಯ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಸದಸ್ಯರ ಕಾರ್ಯವನ್ನು ಬರೆಯಿರಿ:

ವರ್ಗ ಸ್ಟ್ರಿಂಗ್ (ಸಾರ್ವಜನಿಕ: // ... int ಕೌಂಟ್ (ಚಾರ್ ch) const; // ... );

ವ್ಯಾಯಾಮ 3.29

ಸ್ಟ್ರಿಂಗ್ ಕಾನ್ಕಾಟೆನೇಶನ್ ಆಪರೇಟರ್ (+) ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಇದರಿಂದ ಅದು ಎರಡು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಕಾರ್ಯದ ಘೋಷಣೆ ಇಲ್ಲಿದೆ:

ವರ್ಗ ಸ್ಟ್ರಿಂಗ್ (ಸಾರ್ವಜನಿಕ: // ... ಸ್ಟ್ರಿಂಗ್ ಆಪರೇಟರ್+(const String &rhs) const; // ... );