Const (computer programming)
ಕೆಲವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ, ಕಾನ್ಸ್ಟ್ ಎಂಬುದು ಒಂದು ರೀತಿಯ ಅರ್ಹತಾ ಪದವಾಗಿದೆ (ದತ್ತಾಂಶ ಪ್ರಕಾರಕ್ಕೆ ಅನ್ವಯಿಸಲಾದ ಕೀವರ್ಡ್) ಇದು ದತ್ತಾಂಶವು ಓದಲು ಮಾತ್ರ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ಸ್ಥಿರಾಂಕಗಳನ್ನು ಘೋಷಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದಾದರೂ, ಸಿ ಕುಟುಂಬದ ಭಾಷೆಗಳಲ್ಲಿ ಪ್ರಕಾರದ ಭಾಗವಾಗಿರುವ ಇತರ ಭಾಷೆಗಳಲ್ಲಿನ ಇದೇ ರೀತಿಯ ರಚನೆಗಳು ಭಿನ್ನವಾಗಿರುತ್ತವೆ ಮತ್ತು ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ಗಳು, ಉಲ್ಲೇಖಗಳು, ಸಂಯೋಜಿತ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು ಮತ್ತು ಟೈಪ್-ಚೆಕಿಂಗ್ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ ಸಂಕೀರ್ಣವಾದ ನಡವಳಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇತರ ಭಾಷೆಗಳಲ್ಲಿ, ದತ್ತಾಂಶವು ಒಂದೇ ಮೆಮೊರಿ ಸ್ಥಳದಲ್ಲಿರುವುದಿಲ್ಲ, ಆದರೆ ಪ್ರತಿ ಬಳಕೆಯ ಸಂಕಲನ ಸಮಯದಲ್ಲಿ ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ. ಇದನ್ನು ಬಳಸುವ ಭಾಷೆಗಳಲ್ಲಿ ಸಿ, ಸಿ + +, ಡಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಜೂಲಿಯಾ ಮತ್ತು ರಸ್ಟ್ ಸೇರಿವೆ. ಪರಿಚಯ ವಸ್ತುವಿನ ಘೋಷಣೆಯಲ್ಲಿ ಅನ್ವಯಿಸಿದಾಗ, ಅದು ವಸ್ತುವು ಸ್ಥಿರವಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆಃ ಅದರ ಮೌಲ್ಯವನ್ನು ವೇರಿಯೇಬಲ್ಗಿಂತ ಭಿನ್ನವಾಗಿ ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಈ ಮೂಲಭೂತ ಬಳಕೆಯು-ಸ್ಥಿರಾಂಕಗಳನ್ನು ಘೋಷಿಸಲು-ಇತರ ಅನೇಕ ಭಾಷೆಗಳಲ್ಲಿ ಸಮಾನಾಂತರಗಳನ್ನು ಹೊಂದಿದೆ. ಆದಾಗ್ಯೂ, ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿ, ಸಿ ಕುಟುಂಬದ ಭಾಷೆಗಳಲ್ಲಿ ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರದ ಭಾಗವಾಗಿದೆ, ವಸ್ತುವಿನ ಭಾಗವಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಸಿ ಯಲ್ಲಿ, ಇಂಟ್ ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರದ ವಸ್ತು x ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ-ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರದ ಭಾಗವಾಗಿದೆ, ಅದು "(ಇಂಟ್ ಕಾನ್ಸ್ಟ್) x" ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಿದಂತೆ-ಆಡಾದಲ್ಲಿ, ಇಂಟೆಗರ್ ಪ್ರಕಾರದ ಸ್ಥಿರಾಂಕ (ಒಂದು ರೀತಿಯ ವಸ್ತು) ಎಕ್ಸ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆಃ ಸ್ಥಿರಾಂಕವು ವಸ್ತುವಿನ ಭಾಗವಾಗಿದೆ, ಆದರೆ ಪ್ರಕಾರದ ಭಾಗವಲ್ಲ. ಇದು ಎರಡು ಸೂಕ್ಷ್ಮ ಫಲಿತಾಂಶಗಳನ್ನು ಹೊಂದಿದೆ. ಮೊದಲನೆಯದಾಗಿ, ಸ್ಥಿರಾಂಕವನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪ್ರಕಾರದ ಭಾಗಗಳಿಗೆ ಅನ್ವಯಿಸಬಹುದು-ಉದಾಹರಣೆಗೆ, ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕ * ಸ್ಥಿರಾಂಕ x; ಸ್ಥಿರವಾದ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ, ಆದರೆ ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕ * x; ಸ್ಥಿರವಾದ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಚಲಪರಿಮಾಣದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ, ಮತ್ತು ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕ x; ಚಲಪರಿಮಾಣದ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರದ ಭಾಗವಾಗಿರುವುದರಿಂದ, ಇದು ಪ್ರಕಾರ-ಪರಿಶೀಲನೆಯ ಭಾಗವಾಗಿ ಹೊಂದಿಕೆಯಾಗಬೇಕು. ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅಮಾನ್ಯವಾಗಿದೆಃ ಶೂನ್ಯ f (int & x);//. int ಸ್ಥಿರಾಂಕ i; f (i); ಏಕೆಂದರೆ f ಗೆ ವಾದವು ವೇರಿಯೇಬಲ್ ಪೂರ್ಣಾಂಕವಾಗಿರಬೇಕು, ಆದರೆ i ಒಂದು ಸ್ಥಿರ ಪೂರ್ಣಾಂಕವಾಗಿದೆ. ಈ ಹೊಂದಾಣಿಕೆಯು ಪ್ರೋಗ್ರಾಂ ನಿಖರತೆಯ ಒಂದು ರೂಪವಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ಕಾನ್ಸ್ಟ್-ನಿಖರತೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಒಪ್ಪಂದದ ಮೂಲಕ ಒಂದು ರೀತಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಕಾರ್ಯಗಳು ತಮ್ಮ ಪ್ರಕಾರದ ಸಹಿಯ ಭಾಗವಾಗಿ ತಮ್ಮ ವಾದಗಳನ್ನು ಮಾರ್ಪಡಿಸುತ್ತವೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಮತ್ತು ಅವುಗಳ ರಿಟರ್ನ್ ಮೌಲ್ಯವು ಮಾರ್ಪಡಿಸಬಹುದೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ರೀತಿಯ-ಪರಿಶೀಲನೆಯು ಪ್ರಾಥಮಿಕವಾಗಿ ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳಲ್ಲಿ ಆಸಕ್ತಿಯನ್ನು ಹೊಂದಿದೆ-ಪೂರ್ಣಾಂಕಗಳಂತಹ ಮೂಲ ಮೌಲ್ಯದ ಪ್ರಕಾರಗಳಲ್ಲ-ಆದರೆ ಸಂಯೋಜಿತ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು ಅಥವಾ ಧಾರಕಗಳಂತಹ ಟೆಂಪ್ಲೇಟೆಡ್ ಪ್ರಕಾರಗಳಿಗೂ ಸಹ. ಟೈಪ್ ಫೋರ್ಸಿಯನ್ (ಸೂಚ್ಯ ರೀತಿಯ ಪರಿವರ್ತನೆ) ಮತ್ತು C ಯು ಕಾಲ್-ಬೈ-ವ್ಯಾಲ್ಯೂ ಆಗಿರುವುದರಿಂದ (C + + ಮತ್ತು D ಗಳು ಕಾಲ್-ಬೈ-ವ್ಯಾಲ್ಯೂ ಅಥವಾ ಕಾಲ್-ಬೈ-ರೆಫರೆನ್ಸ್ ಆಗಿರುವುದರಿಂದ) ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಬಿಟ್ಟುಬಿಡಬಹುದು ಎಂಬ ಅಂಶದಿಂದ ಇದನ್ನು ಮರೆಮಾಡಲಾಗಿದೆ. ಕಾನ್ಸ್ಟ್-ನೆಸ್ನ ಕಲ್ಪನೆಯು ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವಂತೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬರೆಯಲಾಗುವುದಿಲ್ಲ ಎಂದು ಸೂಚಿಸುವುದಿಲ್ಲ. ಬದಲಿಗೆ, ಕಾನ್ಸ್ಟ್-ನೆಸ್ ಎಂಬುದು ಕಂಪೈಲ್-ಟೈಮ್ ರಚನೆಯಾಗಿದ್ದು, ಇದು ಪ್ರೋಗ್ರಾಮರ್ ಏನು ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಆದರೆ ಅವರು ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಪೂರ್ವನಿರ್ಧರಿತ ದತ್ತಾಂಶದ ಸಂದರ್ಭದಲ್ಲಿ (ಉದಾಹರಣೆಗೆ ಚಾರ್ ಕಾನ್ಸ್ಟ್ * ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳು), ಸಿ ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಬರೆಯಲಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಸ್ಥಿರಾಂಕಗಳಿಂದ ವ್ಯತ್ಯಾಸ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಸ್ಥಿರಾಂಕವು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸದಿದ್ದರೂ, ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸಲಾದ ವಸ್ತುವು ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಡಿಜಿಟಲ್ ಇನ್ಪುಟ್ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯಂತಹ ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್ಗಳಲ್ಲಿ ಓದಲು ಮಾತ್ರ ರೆಜಿಸ್ಟರ್ಗಳು ಒಂದು ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಯಾಗಿದೆ. ಡಿಜಿಟಲ್ ಇನ್ಪುಟ್ಗಳಿಗಾಗಿ ಡೇಟಾ ರಿಜಿಸ್ಟರ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಿರ ಮತ್ತು ಅಸ್ಥಿರ ಎಂದು ಘೋಷಿಸಲಾಗುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ಏನನ್ನೂ ಮಾಡದೆಯೇ ಈ ರೆಜಿಸ್ಟರ್ಗಳ ವಿಷಯವು ಬದಲಾಗಬಹುದು (ಅಸ್ಥಿರ) ಆದರೆ ನೀವು ಅವರಿಗೆ ಬರೆಯಬಾರದು (ಕಾನ್ಸ್ಟ್). ಇದರ ಜೊತೆಗೆ, ಒಂದು (ಸ್ಥಿರವಲ್ಲದ) ಸದಸ್ಯ-ಕಾರ್ಯವನ್ನು ಸ್ಥಿರ ಎಂದು ಘೋಷಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅಂತಹ ಕಾರ್ಯದೊಳಗಿನ ಈ ಪಾಯಿಂಟರ್ ಕೇವಲ ಆಬ್ಜೆಕ್ಟ್ _ ಟೈಪ್ * ಬದಲಿಗೆ ಆಬ್ಜೆಕ್ಟ್ _ ಟೈಪ್ ಕಾನ್ಸ್ಟ್ * ರೀತಿಯದ್ದಾಗಿದೆ. ಇದರರ್ಥ ಈ ವಸ್ತುವಿನ ಸ್ಥಿರವಲ್ಲದ ಕಾರ್ಯಗಳನ್ನು ಅಂತಹ ಕಾರ್ಯದ ಒಳಗಿನಿಂದ ಕರೆಯಲಾಗುವುದಿಲ್ಲ, ಅಥವಾ ಮೆಂಬರ್ ವೇರಿಯೇಬಲ್ಗಳನ್ನು ಮಾರ್ಪಡಿಸಲಾಗುವುದಿಲ್ಲ. ಸಿ + + ನಲ್ಲಿ, ಮೆಂಬರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪರಿವರ್ತನೀಯ ಎಂದು ಘೋಷಿಸಬಹುದು, ಇದು ಈ ನಿರ್ಬಂಧವು ಅದಕ್ಕೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು, ಉದಾಹರಣೆಗೆ ಕ್ಯಾಶಿಂಗ್, ಉಲ್ಲೇಖ ಎಣಿಕೆ ಮತ್ತು ಡೇಟಾ ಸಿಂಕ್ರೊನೈಸೇಶನ್. ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ, ವಸ್ತುವಿನ ತಾರ್ಕಿಕ ಅರ್ಥ (ಸ್ಥಿತಿ) ಬದಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ವಸ್ತುವು ಭೌತಿಕವಾಗಿ ಸ್ಥಿರವಾಗಿರುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅದರ ಬಿಟ್ವೈಸ್ ಪ್ರಾತಿನಿಧ್ಯವು ಬದಲಾಗಬಹುದು. ವಾಕ್ಯರಚನೆಯು ಸಿ, ಸಿ + +, ಮತ್ತು ಡಿ ಯಲ್ಲಿ, ಬಳಕೆದಾರರಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದವುಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಎಲ್ಲಾ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳನ್ನು ಸ್ಥಿರ ಎಂದು ಘೋಷಿಸಬಹುದು, ಮತ್ತು ಸ್ಥಿರ-ನಿಖರತೆಯು ಎಲ್ಲಾ ಅಸ್ಥಿರಗಳು ಅಥವಾ ವಸ್ತುಗಳನ್ನು ಮಾರ್ಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಹೊರತು ಅವುಗಳನ್ನು ಹಾಗೆ ಘೋಷಿಸಬೇಕೆಂದು ನಿರ್ದೇಶಿಸುತ್ತದೆ. ಕಾನ್ಸ್ಟ್ನ ಅಂತಹ ಪೂರ್ವಭಾವಿ ಬಳಕೆಯು ಮೌಲ್ಯಗಳನ್ನು "ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಅದರ ಬಗ್ಗೆ ತರ್ಕಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ", ಮತ್ತು ಇದು ಕೋಡ್ನ ಓದುವಿಕೆ ಮತ್ತು ಗ್ರಹಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ತಂಡಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮತ್ತು ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಮೌಲ್ಯದ ಉದ್ದೇಶಿತ ಬಳಕೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂವಹಿಸುತ್ತದೆ. ಕೋಡ್ ಬಗ್ಗೆ ತರ್ಕಿಸುವಾಗ ಇದು ಕಂಪೈಲರ್ ಮತ್ತು ಡೆವಲಪರ್ಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಆಪ್ಟಿಮೈಸಿಂಗ್ ಕಂಪೈಲರ್ ಅನ್ನು ಸಹ ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಸರಳ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು ಸರಳವಾದ ನಾನ್-ಪಾಯಿಂಟರ್ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳಿಗೆ, ಕಾನ್ಸ್ಟ್ ಕ್ವಾಲಿಫೈಯರ್ ಅನ್ನು ಅನ್ವಯಿಸುವುದು ಸರಳವಾಗಿದೆ. ಇದು ಐತಿಹಾಸಿಕ ಕಾರಣಗಳಿಗಾಗಿ ಕೆಲವು ವಿಧಗಳ ಎರಡೂ ಬದಿಗಳಲ್ಲಿ ಹೋಗಬಹುದು (ಉದಾಹರಣೆಗೆ, ಕಾನ್ಸ್ಟ್ ಚಾರ್ ಫೂ = 'ಎ'; ಇದು ಚಾರ್ ಕಾನ್ಸ್ಟ್ ಫೂ = 'ಎ'; ಗೆ ಸಮಾನವಾಗಿದೆ). ಕೆಲವು ಅನುಷ್ಠಾನಗಳಲ್ಲಿ, ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಎರಡು ಬಾರಿ ಬಳಸುವುದು (ಉದಾಹರಣೆಗೆ, ಕಾನ್ಸ್ಟ್ ಚಾರ್ ಕಾನ್ಸ್ಟ್ ಅಥವಾ ಚಾರ್ ಕಾನ್ಸ್ಟ್ ಕಾನ್ಸ್ಟ್) ಎಚ್ಚರಿಕೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ ಆದರೆ ದೋಷವಲ್ಲ. ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು ಪಾಯಿಂಟರ್ ಮತ್ತು ಉಲ್ಲೇಖ ಪ್ರಕಾರಗಳಿಗೆ, ಕಾನ್ಸ್ಟ್ನ ಅರ್ಥವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ-ಪಾಯಿಂಟರ್ ಸ್ವತಃ, ಅಥವಾ ಸೂಚಿಸಲಾದ ಮೌಲ್ಯ, ಅಥವಾ ಎರಡೂ, ಕಾನ್ಸ್ಟ್ ಆಗಿರಬಹುದು. ಇದಲ್ಲದೆ, ವಾಕ್ಯರಚನೆಯು ಗೊಂದಲಕ್ಕೊಳಗಾಗಬಹುದು. ಪಾಯಿಂಟರ್ ಅನ್ನು ಬರೆಯಬಹುದಾದ ಮೌಲ್ಯಕ್ಕೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅಥವಾ ಕಾನ್ಸ್ಟ್ ಮೌಲ್ಯಕ್ಕೆ ಬರೆಯಬಹುದಾದ ಪಾಯಿಂಟರ್ ಅಥವಾ ಕಾನ್ಸ್ಟ್ ಮೌಲ್ಯಕ್ಕೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಎಂದು ಘೋಷಿಸಬಹುದು. ಒಂದು ಕಾಂಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಅದನ್ನು ಆರಂಭದಲ್ಲಿ ನಿಯೋಜಿಸಲಾಗಿರುವುದಕ್ಕಿಂತ ಬೇರೆ ವಸ್ತುವನ್ನು ಸೂಚಿಸಲು ಮರು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಅದು ಸೂಚಿಸುವ ಮೌಲ್ಯವನ್ನು ಮಾರ್ಪಡಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು (ಪಾಯಿಂಟಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ). ಸಿ + + ನಲ್ಲಿನ ಉಲ್ಲೇಖ ಅಸ್ಥಿರಗಳು ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ಗಳಿಗೆ ಪರ್ಯಾಯ ವಾಕ್ಯರಚನೆಯಾಗಿದೆ. ಮತ್ತೊಂದೆಡೆ, ಕಾನ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಸೂಚಿಸಲು ಮರುಹೊಂದಿಸಬಹುದು (ಇದು ಅದೇ ರೀತಿಯ ಅಥವಾ ಕನ್ವರ್ಟಿಬಲ್ ಪ್ರಕಾರದ ವಸ್ತುವಾಗಿರಬೇಕು), ಆದರೆ ಅದನ್ನು ಸೂಚಿಸುವ ಮೆಮೊರಿಯನ್ನು ಮಾರ್ಪಡಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಕಾನ್ಸ್ಟ್ ವಸ್ತುವಿಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸಹ ಘೋಷಿಸಬಹುದು ಮತ್ತು ಅಪಾಯಿಂಟಿಯನ್ನು ಮಾರ್ಪಡಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ಇನ್ನೊಂದು ವಸ್ತುವನ್ನು ಸೂಚಿಸಲು ಮರು ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ. ಈ ಕೆಳಗಿನ ಸಂಕೇತವು ಈ ಸೂಕ್ಷ್ಮತೆಗಳನ್ನು ವಿವರಿಸುತ್ತದೆಃ ಶೂನ್ಯ ಫೂ (ಇಂಟ್ * ಪಿಟಿಆರ್, ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್, ಇಂಟ್ * ಕಾನ್ಸ್ಟ್ ಕಾನ್ಸ್ಟ್ಪಿಟಿಆರ್, ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಕಾನ್ಸ್ಟ್ಪಿಟ್ರಿಟರ್-ಟು-ಕಾನ್ಸ್ಟ್) {* ಪಿಟಿಆರ್ = 0;// ಸರಿಃ ಡೇಟಾ ಪಿಟಿಆರ್ = ಎನ್ಯುಎಲ್ಎಲ್ ಗೆ ಸೂಚಿಸುತ್ತದೆ;// ಸರಿಃ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ * ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್ = 0;// ದೋಷ! ಪಾಯಿಂಟ್ ಟು ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗಿಲ್ಲ pttrToConst = null;// OK: ಪಾಯಿಂಟರ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ * ಸ್ಥಿರಾಂಕ = 0;// ಸರಿಃ ಪಾಯಿಂಟ್ ಟು ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ ಸ್ಥಿರಾಂಕ = ಶೂನ್ಯಾಂಕ;// ದೋಷ! ಪಾಯಿಂಟರ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗಿಲ್ಲ * ಸ್ಥಿರಾಂಕಃಪಿ. ಟಿ. ಆರ್. ಟು ಕಾನ್ಸ್ಟ್ = 0;// ದೋಷ! ದತ್ತಾಂಶಕ್ಕೆ ಸೂಚಿಸಲಾದ ಬಿಂದುವನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗಿಲ್ಲಃ ಸ್ಥಿರಾಂಕ = ಎನ್. ಯು. ಎಲ್. ಎಲ್;// ದೋಷ! ಪಾಯಿಂಟರ್} ಸಿ ಸಂಪ್ರದಾಯವನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಘೋಷಣೆಗಳಿಗಾಗಿ ಸಾಮಾನ್ಯ ಸಿ ಸಂಪ್ರದಾಯವನ್ನು ಅನುಸರಿಸಿ, ಘೋಷಣೆಯು ಬಳಕೆಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಮತ್ತು ಪಾಯಿಂಟರ್ ನಲ್ಲಿರುವ * ಅನ್ನು ಪಾಯಿಂಟರ್ ಮೇಲೆ ಬರೆಯಲಾಗುತ್ತದೆ, ಇದು ಉಲ್ಲೇಖವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಘೋಷಣೆಯ ಇಂಟ್ * ಪಿಟಿಆರ್ ನಲ್ಲಿ, ಉಲ್ಲೇಖಿತವಲ್ಲದ ಫಾರ್ಮ್ * ಪಿಟಿಆರ್ ಒಂದು ಇಂಟ್ ಆಗಿದ್ದರೆ, ಉಲ್ಲೇಖ ಫಾರ್ಮ್ ಪಿಟಿಆರ್ ಒಂದು ಇಂಟ್ಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಹೀಗಾಗಿ ಕಾನ್ಸ್ಟ್ ಹೆಸರನ್ನು ಅದರ ಬಲಕ್ಕೆ ಮಾರ್ಪಡಿಸುತ್ತದೆ. ಸಿ + + ಸಂಪ್ರದಾಯವು ಬದಲಿಗೆ ಇಂಟ್ * ಪಿಟಿಆರ್ ನಲ್ಲಿರುವಂತೆ * ಅನ್ನು ಪ್ರಕಾರದೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು ಮತ್ತು ಎಡಭಾಗದಲ್ಲಿರುವ ಪ್ರಕಾರವನ್ನು ಮಾರ್ಪಡಿಸುವಂತೆ ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಓದುವುದು. ಹೀಗಾಗಿ "* ptrToConst ಒಂದು int ಸ್ಥಿರಾಂಕವಾಗಿದೆ" (ಮೌಲ್ಯವು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ), ಅಥವಾ "ptrToConst ಒಂದು int ಸ್ಥಿರಾಂಕವಾಗಿದೆ *" (ಪಾಯಿಂಟರ್ ಸ್ಥಿರ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ) ಎಂದು ಓದಬಹುದು. ಹೀಗಾಗಿಃ ಇಂಟ್ * ಪಿಟಿಆರ್;// * ಪಿಟಿಆರ್ ಒಂದು ಇಂಟ್ ಮೌಲ್ಯವಾಗಿದೆ ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್;// ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್ ಒಂದು ಸ್ಥಿರಾಂಕವಾಗಿದೆ (ಇಂಟ್ಃ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ) ಇಂಟ್ * ಕಾನ್ಸ್ಟ್-ಪಿಟಿಆರ್;// ಕಾನ್ಸ್ಟ್ಪಿಟಿಆರ್ ಒಂದು ಸ್ಥಿರಾಂಕವಾಗಿದೆ (ಇಂಟ್ *: ಪೂರ್ಣಾಂಕ ಪಾಯಿಂಟರ್) ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಕಾನ್ಸ್ಟ್-ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್;// ಕಾನ್ಸ್ಟ್ಪಿಟಿಆರ್-ಟು-ಕಾನ್ಸ್ಟ್ ಒಂದು ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್ ಮತ್ತು ಬಿಂದುಗಳು// ಒಂದು ಸ್ಥಿರ ಮೌಲ್ಯಕ್ಕೆ ಸಿ + + ಸಂಪ್ರದಾಯ ಪ್ರಕಾರವನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಸಿ + + ಸಂಪ್ರದಾಯವನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಮೌಲ್ಯವಲ್ಲ, ಘೋಷಣೆಯನ್ನು ಬಲದಿಂದ ಎಡಕ್ಕೆ ಓದುವುದು ಹೆಬ್ಬೆರಳಿನ ನಿಯಮವಾಗಿದೆ. ಹೀಗಾಗಿ, ನಕ್ಷತ್ರದ ಎಡಭಾಗದಲ್ಲಿರುವ ಎಲ್ಲವನ್ನೂ ಮೊನಚಾದ ಪ್ರಕಾರವೆಂದು ಗುರುತಿಸಬಹುದು ಮತ್ತು ನಕ್ಷತ್ರದ ಬಲಭಾಗದಲ್ಲಿರುವ ಎಲ್ಲವೂ ಪಾಯಿಂಟರ್ ಗುಣಲಕ್ಷಣಗಳಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, ಮೇಲಿನ ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಅನ್ನು ಬರೆಯಲಾಗದ ಪೂರ್ಣಾಂಕವನ್ನು ಸೂಚಿಸುವ ಬರೆಯಬಹುದಾದ ಪಾಯಿಂಟರ್ ಆಗಿ ಓದಬಹುದು ಮತ್ತು ಇಂಟ್ * ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಬರೆಯಲಾಗದ ಪೂರ್ಣಾಂಕವನ್ನು ಸೂಚಿಸುವ ಬರೆಯಲಾಗದ ಪಾಯಿಂಟರ್ ಆಗಿ ಓದಬಹುದು. ಸಂಕೀರ್ಣವಾದ ಘೋಷಣೆಗಳು ಮತ್ತು ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ನಿಯಮವು ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಃ ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಯಸುವ ಘೋಷಣೆಯನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಬಲಕ್ಕೆ ಓದಲು ಬಯಸುವ ಗುರುತನ್ನು ಹುಡುಕಿ (ಅಂದರೆ, ಘೋಷಣೆಯ ಅಂತ್ಯದವರೆಗೆ ಅಥವಾ ಮುಂದಿನ ಮುಚ್ಚುವ ಆವರಣಕ್ಕೆ, ಯಾವುದು ಮೊದಲು ಬರುತ್ತದೆ) ನೀವು ಪ್ರಾರಂಭಿಸಿದ ಸ್ಥಳಕ್ಕೆ ಹಿಂತಿರುಗಿ, ಮತ್ತು ಎಡಕ್ಕೆ ಹಿಂದಕ್ಕೆ ಓದಿ (ಅಂದರೆ, ಘೋಷಣೆಯ ಆರಂಭದವರೆಗೆ ಅಥವಾ ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ಕಂಡುಬರುವ ಮುಚ್ಚುವ ಆವರಣಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ತೆರೆದ ಆವರಣಕ್ಕೆ) ನೀವು ಮಾಡಿದ ಘೋಷಣೆಯ ಆರಂಭವನ್ನು ತಲುಪಿದಾಗ. ಇಲ್ಲದಿದ್ದರೆ, ಕೊನೆಯದಾಗಿ ಹೊಂದಿಸಲಾದ ಮುಚ್ಚುವ ಆವರಣವನ್ನು ಮೀರಿ, ಹಂತ 2 ರಲ್ಲಿ ಮುಂದುವರಿಸಿ. ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ ಇದೆಃ ಎಡಕ್ಕೆ ಓದುವಾಗ, ನೀವು ಬಲದಿಂದ ಎಡಕ್ಕೆ ಅಂಶಗಳನ್ನು ಓದುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಆದ್ದರಿಂದ ಒಂದು ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಒಂದು ಕಾನ್ಸ್ಟ್ ಇಂಟ್ಗೆ ಪಾಯಿಂಟರ್ ಆಗುತ್ತದೆ ಮತ್ತು ಇಂಟ್ಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಆಗುವುದಿಲ್ಲ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಿ/ಸಿ + + ಕಾನ್ಸ್ಟ್ ಕೀವರ್ಡ್ ಅನ್ನು ಪ್ರಕಾರದ ಎಡಭಾಗದಲ್ಲಿ ಇರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. C/C + + ಅಂತಹ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆಯಾದರೂ (ಇದು ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಓದುವಾಗ ಇಂಗ್ಲಿಷ್ ಭಾಷೆಗೆ ನಿಕಟವಾಗಿ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ), ಕಂಪೈಲರ್ ಇನ್ನೂ ಮೇಲೆ ತಿಳಿಸಿದ ವಿಧಾನದ ಪ್ರಕಾರ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಓದುತ್ತಾನೆಃ ಬಲದಿಂದ ಎಡಕ್ಕೆ. ಆದರೆ ಸ್ಥಿರವಾಗಿರಬೇಕು ಎಂಬುದರ ಮೊದಲು ಸ್ಥಿರತೆಯನ್ನು ಇಡುವುದು ನೀವು ಏನು ಬರೆಯಲು ಬಯಸುತ್ತೀರಿ ಮತ್ತು ಕಂಪೈಲರ್ ನೀವು ಏನು ಬರೆಯಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತೀರಿ ಎಂಬುದರ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಯನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಚಯಿಸುತ್ತದೆ. ಪಾಯಿಂಟರ್ಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳನ್ನು ಪರಿಗಣಿಸಿಃ ಇಂಟ್ * * ಪಿಟಿಆರ್;// ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * * ಪಿಟಿಆರ್/ಗೆ ಪಾಯಿಂಟರ್ಗೆ ಪಾಯಿಂಟರ್ ಸ್ಥಿರ ಇಂಟ್ ಮೌಲ್ಯಕ್ಕೆ ಪಾಯಿಂಟರ್// (ಇಂಟ್ಗಳಿಗೆ ಸ್ಥಿರ ಪಾಯಿಂಟರ್ ಅಲ್ಲ) ಇಂಟ್ * ಕಾನ್ಸ್ಟ್ * ಪಿಟಿಆರ್// ಇಂಟ್ ಮೌಲ್ಯಗಳಿಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ಗೆ ಪಾಯಿಂಟರ್// (ಇಂಟ್ಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗೆ ಸ್ಥಿರ ಪಾಯಿಂಟರ್ ಅಲ್ಲ) ಇಂಟ್ * * ಕಾನ್ಸ್ಟ್ ಪಿಟಿಆರ್// ಇಂಟ್ಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳಿಗೆ ಸ್ಥಿರ ಪಾಯಿಂಟರ್// (ಪಿಟಿಆರ್, ಗುರುತಿಸುವಿಕೆಯು ಯಾವುದೇ ಅರ್ಥವನ್ನು ನೀಡುವುದಿಲ್ಲ) ಇಂಟ್ * ಕಾನ್ಸ್ಟ್ ಪಿಟಿಆರ್// ಸ್ಥಿರ ಇಂಟ್ ಮೌಲ್ಯಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳಿಗೆ ಸ್ಥಿರ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟರ್ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಅಂತಿಮ ಟಿಪ್ಪಣಿಯಂತೆ ಪಾಯಿಂಟರ್ ಚಿಹ್ನೆಯನ್ನು ಪ್ರಕಾರಕ್ಕೆ ಜೋಡಿಸುವುದು ಟ್ರಿಕಿ ಆಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಪಾಯಿಂಟರ್ ಪ್ರಕಾರವನ್ನು ಬಲವಾಗಿ ಸೂಚಿಸುತ್ತದೆ, ಅದು ಹಾಗಲ್ಲ. ಇಲ್ಲಿ ಕೆಲವು ಉದಾಹರಣೆಗಳಿವೆಃ ಇಂಟ್ * ಎ;/* ಬರೆಯಿರಿಃ */ಇಂಟ್ * ಎ;// ಎ ಎಂಬುದು ಇಂಟ್ ಇಂಟ್ * ಎ, ಬಿ;// ಕನ್ಫ್ಯೂಸಿಂಗ್/* ಬರೆಯಿರಿಃ */ಇಂಟ್ * ಎ, ಬಿ;// ಎ ಎಂಬುದು ಇಂಟ್ಗೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ,// ಆದರೆ ಬಿ ಕೇವಲ ಇಂಟ್ ಇಂಟ್ * ಎ, * ಬಿ;// ಯುಜಿಎಲ್ಐಃ ಎ ಮತ್ತು ಬಿ ಎರಡೂ ಇಂಟ್ಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳಾಗಿವೆ/* ಬರೆಯಿರಿಃ */ಇಂಟ್ * ಎ, * ಬಿ; ಈ ಸಮಸ್ಯೆಯನ್ನು ತಪ್ಪಿಸಲು ಸಿ + + ಸಂಪ್ರದಾಯವನ್ನು ಬಳಸಿದರೆ ಪ್ರತಿ ಸಾಲಿಗೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಮಾತ್ರ ಘೋಷಿಸಲು ಜಾರ್ನೆ ಸ್ಟ್ರೌಸ್ಟ್ರಪ್ನ ಎಫ್ಎಕ್ಯೂ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ. ಇದೇ ರೀತಿಯ ಪರಿಗಣನೆಗಳು ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಮೌಲ್ಯ ಉಲ್ಲೇಖಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನ್ವಯಿಸುತ್ತವೆಃ ಇಂಟ್ ವರ್ = 22; ಇಂಟ್ ಕಾನ್ಸ್ಟ್ & ರಿಫ್ಟೋ ಕಾನ್ಸ್ಟ್ = ವರ್;// ಓಕೆ ಇಂಟ್ ಕಾನ್ಸ್ಟ್ & ರಿಫ 2 = ವರ್, ರಿಫ 3 = ವರ್;// ಕಾನ್ಫ್ಯೂಸಿಂಗ್ಃ// ರಿಫ 2 ಒಂದು ಉಲ್ಲೇಖವಾಗಿದೆ, ಆದರೆ ರಿಫ 3 ಅಲ್ಲಃ// ರಿಫ 3 ಎಂಬುದು// ವರ್ ನ ಮೌಲ್ಯವಾದ ಇಂಟ್ & ಕಾನ್ಸ್ಟ್ರಿಫ್ = ವರ್;// ಇಆರ್ಆರ್ಒಆರ್ನೊಂದಿಗೆ ಆರಂಭಿಸಲಾದ ಸ್ಥಿರಾಂಕವಾಗಿದೆ ಏಕೆಂದರೆ ಉಲ್ಲೇಖಗಳು ಹೇಗಾದರೂ ಬದಲಾಗುವುದಿಲ್ಲ. //C + +: int & & rref = int (5), ಮೌಲ್ಯ = 10;// ಕನ್ಫ್ಯೂಸಿಂಗ್ಃ// rref ಒಂದು ಮೌಲ್ಯ ಉಲ್ಲೇಖವಾಗಿದೆ, ಆದರೆ ಮೌಲ್ಯವು// ಕೇವಲ ಪೂರ್ಣಾಂಕವಾಗಿದೆ. / * ಬರೆಯಿರಿಃ */int & & rref = int (5), ಮೌಲ್ಯ = 10; ಪಾಯಿಂಟರ್ಗಳಿಗೆ ಬಹುಆಯಾಮದ ಸರಣಿಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳನ್ನು (ಅಥವಾ ಪಾಯಿಂಟರ್ಗಳು) ಬಳಸುವಾಗ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಘೋಷಣೆಗಳು ಎದುರಾಗುತ್ತವೆ. ಅಂತಹ ಘೋಷಣೆಗಳು ಗೊಂದಲಮಯವಾಗಿವೆ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗಿವೆ ಮತ್ತು ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ತಪ್ಪಿಸಬೇಕು ಅಥವಾ ಉನ್ನತ ಮಟ್ಟದ ರಚನೆಗಳಿಂದ ಬದಲಾಯಿಸಬೇಕು ಎಂದು ಕೆಲವೊಮ್ಮೆ ವಾದಿಸಲಾಗುತ್ತದೆಯಾದರೂ, ಈ ವಿಭಾಗದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ವಿವರಿಸಲಾದ ಕಾರ್ಯವಿಧಾನವನ್ನು ಯಾವಾಗಲೂ ಅಸ್ಪಷ್ಟತೆ ಅಥವಾ ಗೊಂದಲವನ್ನು ಪರಿಚಯಿಸದೆ ಬಳಸಬಹುದು. ನಿಯತಾಂಕಗಳು ಮತ್ತು ಅಸ್ಥಿರ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಕಾರ್ಯ ನಿಯತಾಂಕಗಳ ಮೇಲೆ ಮತ್ತು ಅಸ್ಥಿರಗಳ ಮೇಲೆ (ಜಾಗತಿಕ ಅಥವಾ ಸ್ಥಳೀಯ ಸೇರಿದಂತೆ ಸ್ಥಿರ ಅಥವಾ ಸ್ವಯಂಚಾಲಿತ) ಘೋಷಿಸಬಹುದು. ವ್ಯಾಖ್ಯಾನವು ಬಳಕೆಗಳ ನಡುವೆ ಬದಲಾಗುತ್ತದೆ. ಕಾನ್ಸ್ಟ್ಯಾಟಿಕ್ ವೇರಿಯೇಬಲ್ (ಜಾಗತಿಕ ವೇರಿಯೇಬಲ್ ಅಥವಾ ಸ್ಥಿರ ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್) ಒಂದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ, ಮತ್ತು ಇದನ್ನು ಗಣಿತದ ಸ್ಥಿರಾಂಕಗಳಂತಹ ದತ್ತಾಂಶಗಳಿಗೆ ಬಳಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಡಬಲ್ ಕಾನ್ಸ್ಟ್ಯಾಕ್ಟ್ ಪಿಐ = 3.14159-ವಾಸ್ತವಿಕವಾಗಿ ಮುಂದೆ, ಅಥವಾ ಒಟ್ಟಾರೆ ಕಂಪೈಲ್-ಟೈಮ್ ನಿಯತಾಂಕಗಳು. ಒಂದು ಸ್ಥಿರಾಂಕ ಸ್ವಯಂಚಾಲಿತ ಚಲಪರಿಮಾಣವು (ಸ್ಥಿರವಲ್ಲದ ಸ್ಥಳೀಯ ಚಲಪರಿಮಾಣ) ಎಂದರೆ ಒಂದೇ ನಿಯೋಜನೆಯು ನಡೆಯುತ್ತಿದೆ ಎಂದರ್ಥ, ಆದರೂ ಪ್ರತಿ ಬಾರಿಯೂ ವಿಭಿನ್ನ ಮೌಲ್ಯವನ್ನು ಬಳಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕ x _ ಸ್ಕ್ವೇರ್ಡ್ = x * x. ಪಾಸ್-ಬೈ-ರೆಫರೆನ್ಸ್ನಲ್ಲಿ ಕಾನ್ಸ್ಟ್ ನಿಯತಾಂಕ ಎಂದರೆ ಉಲ್ಲೇಖಿತ ಮೌಲ್ಯವನ್ನು ಮಾರ್ಪಡಿಸಲಾಗಿಲ್ಲ-ಇದು ಒಪ್ಪಂದದ ಭಾಗವಾಗಿದೆ-ಆದರೆ ಪಾಸ್-ಬೈ-ವ್ಯಾಲ್ಯೂದಲ್ಲಿನ ಕಾನ್ಸ್ಟ್ ನಿಯತಾಂಕವು (ಅಥವಾ ಪಾಯಿಂಟರ್ ಸ್ವತಃ, ಪಾಸ್-ಬೈ-ರೆಫರೆನ್ಸ್ನಲ್ಲಿ) ಇಂಟರ್ಫೇಸ್ಗೆ ಏನನ್ನೂ ಸೇರಿಸುವುದಿಲ್ಲ (ಮೌಲ್ಯವನ್ನು ನಕಲಿಸಲಾಗಿರುವುದರಿಂದ), ಆದರೆ ಆಂತರಿಕವಾಗಿ, ಕಾರ್ಯವು ನಿಯತಾಂಕದ ಸ್ಥಳೀಯ ನಕಲನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ ಎಂದು ಸೂಚಿಸುತ್ತದೆ (ಇದು ಒಂದೇ ನಿಯೋಜನೆಯಾಗಿದೆ). ಈ ಕಾರಣಕ್ಕಾಗಿ, ಕೆಲವರು ಪಾಸ್-ಬೈ-ರೆಫರೆನ್ಸ್ಗಾಗಿ ಮಾತ್ರ ನಿಯತಾಂಕಗಳಲ್ಲಿ ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ, ಅಲ್ಲಿ ಅದು ಒಪ್ಪಂದವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ, ಆದರೆ ಪಾಸ್-ಬೈ-ವ್ಯಾಲ್ಯೂಗೆ ಅಲ್ಲ, ಅಲ್ಲಿ ಅದು ಅನುಷ್ಠಾನವನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ. ಸಿ + + ವಿಧಾನಗಳು ವಿಧಾನಗಳು ಮತ್ತು ಸದಸ್ಯರ ದತ್ತಾಂಶವನ್ನು ಹೊಂದಿರಬಹುದಾದ ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಪ್ರಕಾರಗಳಿಗೆ (ರಚನೆಗಳು ಮತ್ತು ವರ್ಗಗಳು) ಒಪ್ಪಂದದ ವಿಧಾನದ ಮೂಲಕ ವಿನ್ಯಾಸದ ಲಾಭವನ್ನು ಪಡೆಯಲು, ಪ್ರೋಗ್ರಾಮರ್ ಅವರು ವಸ್ತುವಿನ ದತ್ತಾಂಶ ಸದಸ್ಯರನ್ನು ಮಾರ್ಪಡಿಸದಿದ್ದರೆ ಇನ್ಸ್ಟೆನ್ಸ್ ವಿಧಾನಗಳನ್ನು ಕಾನ್ಸ್ಟ್ ಎಂದು ಟ್ಯಾಗ್ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕಾನ್ಸ್ಟ್ ಕ್ವಾಲಿಫೈಯರ್ ಅನ್ನು ಉದಾಹರಣೆ ವಿಧಾನಗಳಿಗೆ ಅನ್ವಯಿಸುವುದು ಕಾನ್ಸ್ಟ್-ನಿಖರತೆಗೆ ಅತ್ಯಗತ್ಯವಾದ ಲಕ್ಷಣವಾಗಿದೆ, ಮತ್ತು ಇದು ಜಾವಾ ಮತ್ತು ಸಿ #ನಂತಹ ಇತರ ಅನೇಕ ವಸ್ತು-ಆಧಾರಿತ ಭಾಷೆಗಳಲ್ಲಿ ಅಥವಾ ಮೈಕ್ರೋಸಾಫ್ಟ್ನ ಸಿ + +/ಸಿಎಲ್ಐ ಅಥವಾ ಸಿ + + ಗಾಗಿ ನಿರ್ವಹಿಸಿದ ವಿಸ್ತರಣೆಗಳಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲ. ಕಾನ್ಸ್ಟ್ ವಿಧಾನಗಳನ್ನು ಕಾನ್ಸ್ಟ್ ಮತ್ತು ಕಾನ್ಸ್ಟ್ ಅಲ್ಲದ ವಸ್ತುಗಳಿಂದ ಒಂದೇ ರೀತಿ ಕರೆಯಬಹುದಾದರೂ, ಕಾನ್ಸ್ಟ್ ಅಲ್ಲದ ವಿಧಾನಗಳನ್ನು ಕಾನ್ಸ್ಟ್ ಅಲ್ಲದ ವಸ್ತುಗಳಿಂದ ಮಾತ್ರ ಆಹ್ವಾನಿಸಬಹುದು. ಇನ್ಸ್ಟೆನ್ಸ್ ವಿಧಾನದಲ್ಲಿನ ಕಾನ್ಸ್ಟ್ ಮಾರ್ಪಡಕವು "ಈ" ಪಾಯಿಂಟರ್ನಿಂದ ಸೂಚಿಸಲಾದ ವಸ್ತುವಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ, ಇದು ಎಲ್ಲಾ ಇನ್ಸ್ಟೆನ್ಸ್ ವಿಧಾನಗಳಿಗೆ ರವಾನಿಸಲಾದ ಸೂಚ್ಯ ವಾದವಾಗಿದೆ. ಹೀಗಾಗಿ ಕಾನ್ಸ್ಟ್ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರುವುದು ಇತರ ವಾದಗಳಂತೆಯೇ ಸೂಚ್ಯವಾದ "ಈ" ಪಾಯಿಂಟರ್ ವಾದಕ್ಕೆ ಕಾನ್ಸ್ಟ್-ನಿಖರತೆಯನ್ನು ಅನ್ವಯಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ಈ ಉದಾಹರಣೆಯು ವಿವರಿಸುತ್ತದೆಃ ವರ್ಗ C {int i; ಸಾರ್ವಜನಿಕಃ int ಗೆಟ್ () ಕಾನ್ಸ್ಟ್// "ಕಾನ್ಸ್ಟ್" ಟ್ಯಾಗ್ ಅನ್ನು ಗಮನಿಸಿ {ರಿಟರ್ನ್ i;} ಅನೂರ್ಜಿತ ಸೆಟ್ (int j)// "ಕಾನ್ಸ್ಟ್" ನ ಕೊರತೆಯನ್ನು ಗಮನಿಸಿ {i = j;}}; ಅನೂರ್ಜಿತ ಫೂ (C & ನಾನ್ಕಾನ್ಸ್ಟಿಸಿ, C ಕಾನ್ಸ್ಟ್ & ಕಾನ್ಸ್ಟಿಸಿ) {int y = nonConstC.Get ();// Ok int x = constC.Get ();// Ok: ಗೆಟ್ () ಎಂದರೆ ಕಾನ್ಸ್ಟ್ nonConstC.Set (10);// Ok: ನಾನ್ಕಾನ್ಸ್ಟ್ಸಿಯನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು constC.Set (10);// ದೋಷ! ಸೆಟ್ () ಒಂದು ಕಾನ್ಸ್ಟ್-ಅಲ್ಲದ ವಿಧಾನವಾಗಿದೆ ಮತ್ತು ಕಾನ್ಸ್ಟ್ಸಿಯು ಕಾನ್ಸ್ಟ್-ಅರ್ಹವಾದ ವಸ್ತುವಾಗಿದೆ} ಮೇಲಿನ ಕೋಡ್ನಲ್ಲಿ, ಸೆಟ್ () ಗೆ ಸೂಚ್ಯವಾದ "ಈ" ಪಾಯಿಂಟರ್ "ಸಿ * ಕಾನ್ಸ್ಟ್" ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ; ಆದರೆ ಗೆಟ್ () ಗೆ "ಈ" ಪಾಯಿಂಟರ್ "ಸಿ ಕಾನ್ಸ್ಟ್ * ಕಾನ್ಸ್ಟ್" ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ, ಇದು ವಿಧಾನವು "ಈ" ಪಾಯಿಂಟರ್ ಮೂಲಕ ತನ್ನ ವಸ್ತುವನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ಆಗಾಗ್ಗೆ ಪ್ರೋಗ್ರಾಮರ್ ಎರಡೂ ರೀತಿಯ ಕರೆ ಮಾಡುವವರಿಗೆ ಅವಕಾಶ ಕಲ್ಪಿಸಲು ತರಗತಿಯಲ್ಲಿ ಒಂದೇ ಹೆಸರಿನ (ಆದರೆ ಬಹುಶಃ ವಿಭಿನ್ನ ಉಪಯೋಗಗಳು) ಕಾನ್ಸ್ಟ್ ಮತ್ತು ನಾನ್-ಕಾನ್ಸ್ಟ್ ವಿಧಾನ ಎರಡನ್ನೂ ಪೂರೈಸುತ್ತಾರೆ. ಪರಿಗಣಿಸಿಃ ವರ್ಗ MyArray {int ದತ್ತಾಂಶ [100]; ಸಾರ್ವಜನಿಕಃ int & Get (int i) {ಹಿಂತಿರುಗಿಸುವ ದತ್ತಾಂಶ [i];} int ಸ್ಥಿರಾಂಕ & ಪಡೆಯಿರಿ (int i) ಸ್ಥಿರಾಂಕ {ಹಿಂತಿರುಗಿಸುವ ದತ್ತಾಂಶ [i];}}; ಶೂನ್ಯವಾದ Foo (MyArray & array, MyArray ಸ್ಥಿರಾಂಕ & ಸ್ಥಿರಾಂಕ) {// ಒಂದು ಶ್ರೇಣಿಯ ಅಂಶಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಪಡೆಯಿರಿ// ಮತ್ತು ಅದರ ಉಲ್ಲೇಖಿತ ಮೌಲ್ಯವನ್ನು ಮಾರ್ಪಡಿಸಿ. array.Get (5) = 42;// ಸರಿ! (ಕರೆಗಳುಃ int & MyArray:: Get (int)) constArray.Get (5) = 42;// ದೋಷ! (ಕರೆಗಳುಃ ಇಂಟ್ ಕಾನ್ಸ್ಟ್ & ಮೈಅರೇಃಃ ಗೆಟ್ (ಇಂಟ್) ಕಾನ್ಸ್ಟ್)} ಕರೆ ಮಾಡುವ ವಸ್ತುವಿನ ಕಾನ್ಸ್ಟ್-ನೆಸ್ ಮೈಅರೇಃಃ ಗೆಟ್ () ನ ಯಾವ ಆವೃತ್ತಿಯನ್ನು ಆಹ್ವಾನಿಸಲಾಗುವುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗಾಗಿ ಕರೆ ಮಾಡುವವರಿಗೆ ಅವರು ವಸ್ತುವಿನಲ್ಲಿನ ಖಾಸಗಿ ಡೇಟಾವನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಅಥವಾ ಮಾತ್ರ ವೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಾಗುವಂತಹ ಉಲ್ಲೇಖವನ್ನು ನೀಡಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಎರಡು ವಿಧಾನಗಳು ತಾಂತ್ರಿಕವಾಗಿ ವಿಭಿನ್ನ ಸಹಿಗಳನ್ನು ಹೊಂದಿವೆ ಏಕೆಂದರೆ ಅವುಗಳ "ಈ" ಪಾಯಿಂಟರ್ಗಳು ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿದ್ದು, ಕಂಪೈಲರ್ಗೆ ಸರಿಯಾದದನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. (ಕೇವಲ ಇಂಟನ್ನು ಮೌಲ್ಯದಿಂದ ಹಿಂದಿರುಗಿಸುವ ಬದಲು, ಇಂಟ್ವೊಂದಕ್ಕೆ ಕಾನ್ಸ್ಟ್ ಉಲ್ಲೇಖವನ್ನು ಹಿಂದಿರುಗಿಸುವುದು, ಎರಡನೇ ವಿಧಾನದಲ್ಲಿ ಓವರ್ ಕಿಲ್ ಆಗಿರಬಹುದು, ಆದರೆ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಟೆಂಪ್ಲೇಟ್ ಲೈಬ್ರರಿಯಲ್ಲಿರುವಂತೆ ಅನಿಯಂತ್ರಿತ ಪ್ರಕಾರಗಳಿಗೆ ಅದೇ ತಂತ್ರವನ್ನು ಬಳಸಬಹುದು.) ಸಿ ಮತ್ತು ಸಿ + + ನಲ್ಲಿ ಶುದ್ಧ ಸ್ಥಿರತೆ-ನಿಖರತೆಗೆ ಹಲವಾರು ಲೋಪದೋಷಗಳಿವೆ. ಅವು ಮುಖ್ಯವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ನೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಗಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಮೊದಲನೆಯದು, ಇದು ಸಿ + + ಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ, ಇದು ಕಾನ್ಸ್ಟ್ ಕಾಸ್ಟ್ನ ಬಳಕೆಯಾಗಿದೆ, ಇದು ಪ್ರೋಗ್ರಾಮರ್ಗೆ ಕಾನ್ಸ್ಟ್ ಕ್ವಾಲಿಫೈಯರ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಯಾವುದೇ ವಸ್ತುವನ್ನು ಮಾರ್ಪಡಿಸಬಲ್ಲದು. ಮಾರ್ಪಡಿಸಲಾಗದ ಆದರೆ ನಿಖರವಾಗಿರದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಮತ್ತು ಗ್ರಂಥಾಲಯಗಳನ್ನು ಬಳಸುವಾಗ ಅರ್ಹತಾ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಹಾಕುವ ಅಗತ್ಯವು ಉದ್ಭವಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಈ ಕೋಡ್ ಅನ್ನು ಪರಿಗಣಿಸಿಃ// ನಾವು ಬದಲಾಯಿಸಲಾಗದ ಆದರೆ// ನಮಗೆ ತಿಳಿದಿರುವ ಒಂದು ಕಾರ್ಯಕ್ಕಾಗಿ ಮೂಲಮಾದರಿಯು ರವಾನಿಸಲಾದ ಪಾಯಿಂಟಿಯನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ. ಶೂನ್ಯ ಲೈಬ್ರರಿಫಂಕ್ (ಇಂಟ್ * ಪಿಟಿಆರ್, ಇಂಟ್ ಗಾತ್ರ); ಶೂನ್ಯ ಕಾಲ್ ಲೈಬ್ರರಿಫಂಕ್ (ಇಂಟ್ ಕಾನ್ಸ್ಟ್ * ಪಿಟಿಆರ್, ಇಂಟ್ ಗಾತ್ರ) {ಲೈಬ್ರರಿಫಂಕ್ (ಪಿಟಿಆರ್, ಗಾತ್ರ);// ದೋಷ! ಡ್ರಾಪ್ಸ್ ಕಾನ್ಸ್ಟ್ ಕ್ವಾಲಿಫೈಯರ್ ಇಂಟ್ * ನಾನ್ಕಾನ್ಸ್ಟ್ಪಿಟ್ರ್ = ಕಾನ್ಸ್ಟ್ _ ಕಾಸ್ಟ್ <ಇಂಟ್ *> (ಪಿಟಿಆರ್);// ಸ್ಟ್ರಿಪ್ ಕ್ವಾಲಿಫೈಯರ್ ಲೈಬ್ರರಿಫಂಕ್ (ನಾನ್-ಕಾನ್ಸ್ಟ್ಪಿಟ್ರ್, ಗಾತ್ರ);// ಓಕೆ) ಆದಾಗ್ಯೂ, ಕಾನ್ಸ್ಟ್ ಕಾಸ್ಟ್ ಮೂಲಕ ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸಲಾದ ವಸ್ತುವನ್ನು ಮಾರ್ಪಡಿಸುವ ಯಾವುದೇ ಪ್ರಯತ್ನವು ಐಎಸ್ಒ ಸಿ + + ಮಾನದಂಡದ ಪ್ರಕಾರ ವಿವರಿಸಲಾಗದ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪಿ. ಟಿ. ಆರ್. ಜಾಗತಿಕ, ಸ್ಥಳೀಯ, ಅಥವಾ ಸದಸ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸಿದರೆ, ಅಥವಾ ಹೊಸ ಇಂಟ್ ಕಾನ್ಸ್ಟ್ ಮೂಲಕ ರಾಶಿಗೆ ನಿಗದಿಪಡಿಸಿದ ವಸ್ತುವನ್ನು ಉಲ್ಲೇಖಿಸಿದರೆ, ಲೈಬ್ರರಿಫಂಕ್ ನಿಜವಾಗಿಯೂ ಪಿ. ಟಿ. ಆರ್. ನಿಂದ ಸೂಚಿಸಲಾದ ಮೌಲ್ಯವನ್ನು ಮಾರ್ಪಡಿಸದಿದ್ದರೆ ಮಾತ್ರ ಕೋಡ್ ಸರಿಯಾಗಿರುತ್ತದೆ. ಸಿ ಭಾಷೆಗೆ ಒಂದು ಲೋಪದೋಷದ ಅಗತ್ಯವಿರುತ್ತದೆ ಏಕೆಂದರೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪರಿಸ್ಥಿತಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಸ್ಥಿರ ಶೇಖರಣಾ ಅವಧಿಯನ್ನು ಹೊಂದಿರುವ ವೇರಿಯೇಬಲ್ಗಳನ್ನು ಆರಂಭಿಕ ಮೌಲ್ಯದೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸಲಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಇನಿಶಿಯಲೈಸರ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರಾಂಕಗಳು ಮತ್ತು ಇತರ ಅಕ್ಷರಗಳಂತಹ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು, ಮತ್ತು ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳಂತಹ ಸ್ಥಿರವಲ್ಲದ ಅಂಶಗಳನ್ನು ಬಳಸಲು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ, ಇನಿಶಿಯಲೈಸರ್ ಅಂಶಗಳನ್ನು ಸ್ಥಿರವೆಂದು ಘೋಷಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ, ಅಥವಾ ಸ್ಥಿರ ಅವಧಿಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸ್ಥಿರವೆಂದು ಘೋಷಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ. ಸ್ಥಿರ ಶೇಖರಣಾ ಅವಧಿಯನ್ನು ಹೊಂದಿರುವ ಕಾನ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪೋರ್ಟಬಲ್ ಅಲ್ಲದ ಮಾರ್ಗವಿದೆ. ನಂತರದ ನಿಯೋಜನೆಯ ಎಡಭಾಗದಲ್ಲಿ ಟೈಪ್ಕಾಸ್ಟ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ಮಿಸುವ ಮೂಲಕ, ಕಾನ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬರೆಯಬಹುದು, ಕಾನ್ಸ್ಟ್ ಗುಣಲಕ್ಷಣವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ತೆಗೆದುಹಾಕಬಹುದು ಮತ್ತು ಇತರ ಕಾನ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಗಳಂತಹ ಸ್ಥಿರವಲ್ಲದ ಅಂಶಗಳೊಂದಿಗೆ ಅದನ್ನು 'ಪ್ರಾರಂಭಿಸಬಹುದು'. ಈ ರೀತಿಯಲ್ಲಿ ಕಾನ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಬರೆಯುವುದು ಉದ್ದೇಶಿಸಿದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು, ಆದರೆ ಇದು ವಿವರಿಸಲಾಗದ ನಡವಳಿಕೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ ಮತ್ತು ಕಾನ್ಸ್ಟ್-ನಿಖರತೆಯನ್ನು ಗಂಭೀರವಾಗಿ ವಿರೋಧಿಸುತ್ತದೆಃ ಸೈಜ್ _ ಟಿ ಕಾನ್ಸ್ಟ್ ಬಫರ್ಸೈಜ್ = 8 * 1024; ಸೈಜ್ _ ಟಿ ಕಾನ್ಸ್ಟ್ ಬಳಕೆದಾರ ಟೆಕ್ಸ್ಟ್ಬಫರ್ಸೈಜ್;// ಆರಂಭಿಕ ಮೌಲ್ಯವು ಕಾನ್ಸ್ಟ್ ಬಫರ್ಸೈಜ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಇಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗುವುದಿಲ್ಲ. int ಸೆಟಪ್ ಯೂಸರ್ ಟೆಕ್ಸ್ಟ್ಬಾಕ್ಸ್ (ಟೆಕ್ಸ್ಟ್ಬಾಕ್ಸ್ _ ಟಿ * ಡಿಫಾಲ್ಟ್ ಟೆಕ್ಸ್ಟ್ಬಾಕ್ಸ್ ಟೈಪ್, ರೆಕ್ಟ್ _ ಟಿ * ಡಿಫಾಲ್ಟ್ ಟೆಕ್ಸ್ಟ್ಬಾಕ್ಸ್ ಲೊಕೇಷನ್) {* (ಸೈಜ್ _ ಟಿ *) & ಯೂಸರ್ ಟೆಕ್ಸ್ಟ್ಬಫರ್ಸೈಜ್ = ಬಫರ್ಸೈಜ್-ಸೈಜ್ ಆಫ್ ಸ್ಟ್ರಕ್ಟ್ (ಟೆಕ್ಸ್ಟ್ಬಾಕ್ಸ್ ಕಂಟ್ರೋಲ್ಸ್);// ಎಚ್ಚರಿಕೆಃ ಕೆಲಸ ಮಾಡಬಹುದು, ಆದರೆ ಸಿ ಖಾತರಿಪಡಿಸುವುದಿಲ್ಲ ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಸದಸ್ಯರ ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು ತಮ್ಮ ಮಾಲೀಕರ ಸ್ಥಿರತೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ "ಆಳವಿಲ್ಲ" ಎಂದು ಭಾಷೆಗಳು ನಿರ್ದೇಶಿಸುತ್ತವೆ-ಅಂದರೆ, ಸ್ಥಿರವಾಗಿರುವ ವಸ್ತುವು ಸದಸ್ಯರ ಪಾಯಿಂಟಿಗಳನ್ನು (ಮತ್ತು ರೆಫರಿಗಳು) ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಸ್ಥಿರ ಸದಸ್ಯರನ್ನು ಹೊಂದಿರುತ್ತದೆ. ವಿವರಿಸಲು, ಈ ಸಿ + + ಸಂಕೇತವನ್ನು ಪರಿಗಣಿಸಿಃ ಸ್ಟ್ರಕ್ಟ್ ಎಸ್ {ಇಂಟ್ವಾಲ್; ಇಂಟ್ವಾಲ್ * ಪಿಟಿಆರ್;}; ವಾಯ್ಡ್ ಫೂ (ಎಸ್ ಕಾನ್ಸ್ಟ್ & ಎಸ್) {ಇಂಟ್ವಾಲ್ ಐ = 42; s.val = ಐ;// ಎರರ್ಃ ಎಸ್ ಕಾನ್ಸ್ಟ್ ಆಗಿದೆ, ಆದ್ದರಿಂದ ವ್ಯಾಲ್ ಒಂದು ಕಾನ್ಸ್ಟ್ ಇಂಟ್ s.ptr = & ಐ;// ಎರರ್ಃ ಎಸ್ ಕಾನ್ಸ್ಟ್ ಆಗಿದೆ, ಆದ್ದರಿಂದ ಪಿಟಿಆರ್ ಇಂಟ್ವಾಲ್ * s.ptr = ಐ;// ಸರಿಃ ಪಿಟಿಆರ್ ಸೂಚಿಸಿದ ದತ್ತಾಂಶವು ಯಾವಾಗಲೂ ಪರಿವರ್ತನೀಯವಾಗಿರುತ್ತದೆ,// ಇದು ಕೆಲವೊಮ್ಮೆ ಅಪೇಕ್ಷಣೀಯವಲ್ಲದಿದ್ದರೂ ಸಹ) ವಸ್ತುವನ್ನು ಫೂ () ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆಯಾದರೂ, ಇದು ಅದರ ಎಲ್ಲಾ ಸದಸ್ಯರನ್ನು ಸ್ಥಿರಗೊಳಿಸುತ್ತದೆ, s.ptr ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದಾದ ಪಾಯಿಂಟಿಯು ಇನ್ನೂ ಮಾರ್ಪಡಿಸಬಹುದಾಗಿದೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, ಸದಸ್ಯರ ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ "ಡೀಪ್" ಕಾನ್ಸ್ಟ್-ನೆಸ್ ಆಗಿರಬೇಕು ಎಂದು ಮೇಯರ್ಸ್ ವಾದಿಸುತ್ತಾರೆ, ಇದನ್ನು ಪಾಯಿಂಟಿ ಧಾರಕದ ಒಡೆತನದಲ್ಲಿರದಿದ್ದಾಗ ಪರಿವರ್ತನೀಯ ಅರ್ಹತಾ ಮೂಲಕ ಅತಿಕ್ರಮಿಸಬಹುದು, ಆದರೆ ಈ ಕಾರ್ಯತಂತ್ರವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ನೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಐತಿಹಾಸಿಕ ಕಾರಣಗಳಿಗಾಗಿ, ಈ ಲೋಪದೋಷವು ಸಿ ಮತ್ತು ಸಿ + + ನಲ್ಲಿ ತೆರೆದಿರುತ್ತದೆ. ಕಾಂಸ್ಟ್-ಸರಿಯಾದ ಇಂಟರ್ಫೇಸ್ನ ಹಿಂದೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮರೆಮಾಡಲು ವರ್ಗವನ್ನು ಬಳಸುವ ಮೂಲಕ ನಂತರದ ಲೋಪದೋಷವನ್ನು ಮುಚ್ಚಬಹುದು, ಆದರೆ ಅಂತಹ ವರ್ಗಗಳು ಕಾಂಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ನಿಂದ ಸಾಮಾನ್ಯ ನಕಲು ಶಬ್ದಾರ್ಥಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ (ಹೊಂದಿರುವ ವರ್ಗವನ್ನು ಸಾಮಾನ್ಯ ಶಬ್ದಾರ್ಥಗಳಿಂದ ನಕಲಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಸೂಚಿಸುತ್ತದೆ) ಅಥವಾ ಅಜಾಗರೂಕತೆಯಿಂದ ಅಥವಾ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ನಕಲು ಮಾಡುವ ಮೂಲಕ ಕಾಂಸ್ಟ್-ನೆಸ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು ಅನುಮತಿಸುವ ಮೂಲಕ ಇತರ ಲೋಪದೋಷಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಸಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯಲ್ಲಿನ ಹಲವಾರು ಕಾರ್ಯಗಳು ಸಿ23ಗಿಂತ ಮೊದಲು ಕಾನ್ಸ್ಟ್-ನಿಖರತೆಯನ್ನು ಉಲ್ಲಂಘಿಸುತ್ತವೆ, ಏಕೆಂದರೆ ಅವು ಅಕ್ಷರದ ಸ್ಟ್ರಿಂಗ್ಗೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ ಮತ್ತು ಅದೇ ಸ್ಟ್ರಿಂಗ್ನ ಒಂದು ಭಾಗಕ್ಕೆ ಕಾನ್ಸ್ಟ್ ಅಲ್ಲದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ. ಈ ಕಾರ್ಯಗಳಲ್ಲಿ ಎಸ್ಟಿಆರ್ಎಸ್ಆರ್ ಮತ್ತು ಎಸ್ಟಿಆರ್ಚ್ಆರ್ ಸೇರಿವೆ. ಸಿ + + ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಕೆಲವು ಅನುಷ್ಠಾನಗಳು, ಉದಾಹರಣೆಗೆ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಕೆಲವು ಕಾರ್ಯಗಳ ಎರಡು ಓವರ್ಲೋಡ್ ಮಾಡಲಾದ ಆವೃತ್ತಿಗಳನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಈ ಲೋಪದೋಷವನ್ನು ಮುಚ್ಚಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆಃ ಒಂದು "ಕಾನ್ಸ್ಟ್" ಆವೃತ್ತಿ ಮತ್ತು ಒಂದು "ನಾನ್-ಕಾನ್ಸ್ಟ್" ಆವೃತ್ತಿ. ಸಮಸ್ಯೆಗಳು ಸ್ಥಿರತೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ಟೈಪ್ ಸಿಸ್ಟಮ್ನ ಬಳಕೆಯು ವಿವಿಧ ಸಂಕೀರ್ಣತೆಗಳು ಮತ್ತು ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಪ್ರಕಾರ ಸಿ, ಸಿ + +, ಮತ್ತು ಡಿ. ಜಾವಾ ಮತ್ತು ಸಿ #ನ ಕಿರಿದಾದ ಸಿ ಕುಟುಂಬದ ಹೊರಗೆ ಟೀಕಿಸಲಾಗಿದೆ ಮತ್ತು ಅಳವಡಿಸಿಕೊಳ್ಳಲಾಗಿಲ್ಲ, ಇವು ಸಿ ಮತ್ತು ಸಿ + + ನಿಂದ ಹೆಚ್ಚು ಪ್ರಭಾವಿತವಾಗಿವೆ, ಇವೆರಡೂ ಸ್ಪಷ್ಟವಾಗಿ ಕಾನ್ಸ್ಟ್-ಶೈಲಿಯ ಪ್ರಕಾರದ ಅರ್ಹತೆಗಳನ್ನು ತಿರಸ್ಕರಿಸಿವೆ, ಬದಲಿಗೆ ಗುರುತಿಸುವಿಕೆಗೆ ಅನ್ವಯವಾಗುವ ಕೀವರ್ಡ್ಗಳಿಂದ ಸ್ಥಿರತೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸುತ್ತವೆ (ಜಾವಾದಲ್ಲಿ ಅಂತಿಮ, ಕಾನ್ಸ್ಟ್ ಮತ್ತು ಸಿ #ನಲ್ಲಿ ಓದಲು ಮಾತ್ರ). ಸಿ ಮತ್ತು ಸಿ + + ನಲ್ಲಿಯೂ ಸಹ, ಕಾನ್ಸ್ಟ್ನ ಬಳಕೆಯು ಗಮನಾರ್ಹವಾಗಿ ಬದಲಾಗುತ್ತದೆ, ಕೆಲವು ಯೋಜನೆಗಳು ಮತ್ತು ಸಂಸ್ಥೆಗಳು ಇದನ್ನು ಸ್ಥಿರವಾಗಿ ಬಳಸುತ್ತವೆ ಮತ್ತು ಇತರರು ಅದನ್ನು ತಪ್ಪಿಸುತ್ತಾರೆ. ಒಂದು ಕಾರ್ಯದ ತರ್ಕವು ಅದರ ಇನ್ಪುಟ್ ಸ್ಥಿರವಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದರ ಬಗ್ಗೆ ಅಜ್ಞೇಯವಾದಾಗ ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರದ ಅರ್ಹತೆಯು ತೊಂದರೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ, ಆದರೆ ಇನ್ಪುಟ್ನಂತೆಯೇ ಅದೇ ಅರ್ಹ ಪ್ರಕಾರದ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಈ ಕಾರ್ಯಗಳಿಗೆ, ಇನ್ಪುಟ್ ಸ್ಥಿರವಾಗಿದ್ದರೆ (ಕಾನ್ಸ್ಟ್-ಅರ್ಹ), ರಿಟರ್ನ್ ಮೌಲ್ಯವೂ ಸಹ ಇರಬೇಕು, ಆದರೆ ಇನ್ಪುಟ್ ಬದಲಾಗುತ್ತಿದ್ದರೆ (ಕಾನ್ಸ್ಟ್-ಅರ್ಹವಲ್ಲ), ರಿಟರ್ನ್ ಮೌಲ್ಯವೂ ಸಹ ಇರಬೇಕು. ಈ ಕಾರ್ಯಗಳ ಪ್ರಕಾರದ ಸಹಿ ಭಿನ್ನವಾಗಿರುವುದರಿಂದ, ಇದಕ್ಕೆ ಒಂದೇ ತರ್ಕದೊಂದಿಗೆ ಎರಡು ಕಾರ್ಯಗಳು (ಅಥವಾ ಬಹು ಇನ್ಪುಟ್ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಭಾವ್ಯವಾಗಿ ಹೆಚ್ಚು) ಬೇಕಾಗುತ್ತವೆ-ಇದು ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ರೂಪವಾಗಿದೆ. ಈ ಸಮಸ್ಯೆಯು ಸಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯಲ್ಲಿನ ಸರಳ ಕಾರ್ಯಗಳಿಗೂ ಸಹ ಉದ್ಭವಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಎಸ್ಟಿಆರ್ಸಿಆರ್; ಈ ಅವಲೋಕನವನ್ನು ರಿಚೀ 1980 ರ ದಶಕದ ಮಧ್ಯಭಾಗದಲ್ಲಿ ಟಾಮ್ ಪ್ಲಮ್ಗೆ ಸಲ್ಲುತ್ತದೆ. ಸ್ಟ್ರಾಚರ್ ಕಾರ್ಯವು ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ; ಔಪಚಾರಿಕವಾಗಿ, ಇದು ಸ್ಟ್ರಿಂಗ್ ಎಸ್ನಲ್ಲಿ ಸಿ ಅಕ್ಷರದ ಮೊದಲ ಸಂಭವಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು ಕ್ಲಾಸಿಕ್ ಸಿ (ಕೆ & ಆರ್ಸಿ) ಯಲ್ಲಿ ಅದರ ಮೂಲಮಾದರಿಯುಃ ಚಾರ * ಸ್ಟ್ರಾಚರ್ (ಚಾರ * ಸ್, ಇಂಟಿಸಿ); ಸ್ಟ್ರಾಚರ್ ಕಾರ್ಯವು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ, ಆದರೆ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕರೆ ಮಾಡುವವರು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಬಳಸುತ್ತಾರೆ, ಉದಾಹರಣೆಗೆಃ ಇಫ್ (ಪಿ = ಸ್ಟ್ರಾಚರ್ (ಕ್ಯೂ, '/')) * ಪಿ = '; ಹೀಗಾಗಿ ಒಂದು ಕಡೆ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ (ಏಕೆಂದರೆ ಅದನ್ನು ಕಾರ್ಯದಿಂದ ಮಾರ್ಪಡಿಸಲಾಗಿಲ್ಲ), ಮತ್ತು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರವಾಗಿದ್ದರೆ ರಿಟರ್ನ್ ಮೌಲ್ಯವೂ ಸಹ ಆಗಿರಬೇಕು-ಅದು ನಿಖರವಾಗಿ ಹಿಂತಿರುಗಬಹುದು. ಸಿ + + ನಲ್ಲಿ ಇದನ್ನು ಫಂಕ್ಷನ್ ಓವರ್ಲೋಡಿಂಗ್ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಟೆಂಪ್ಲೇಟ್ ಮೂಲಕ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಎರಡು ಕಾರ್ಯಗಳು ಉಂಟಾಗುತ್ತವೆ, ಇದರಿಂದಾಗಿ ರಿಟರ್ನ್ ಮೌಲ್ಯವು ಇನ್ಪುಟ್ನಂತೆಯೇ ಕಾನ್ಸ್ಟ್-ಅರ್ಹವಾದ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿರುತ್ತದೆಃ ಚಾರ್ * ಸ್ಟ್ರಾಚರ್ (ಚಾರ್ * ಎಸ್, ಇಂಟ್ ಸಿ); ಚಾರ್ ಕಾನ್ಸ್ಟ್ * ಸ್ಟ್ರಾಚರ್ (ಚಾರ್ ಕಾನ್ಸ್ಟ್ * ಎಸ್, ಇಂಟ್ ಸಿ); ಇವುಗಳನ್ನು ಟೆಂಪ್ಲೇಟ್ನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದುಃ ಟೆಂಪ್ಲೇಟ್ <ಟಿ> ಟಿ * ಸ್ಟ್ರಾಚರ್ (ಟಿ * ಎಸ್, ಇಂಟ್ ಸಿ) {. ಡಿ ಯಲ್ಲಿ ಇದನ್ನು ಇನ್ಔಟ್ ಕೀವರ್ಡ್ ಮೂಲಕ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಇದು ಕಾನ್ಸ್ಟ್, ಅಪರಿವರ್ತನೀಯ, ಅಥವಾ ಅನರ್ಹ (ವೇರಿಯೇಬಲ್) ಗೆ ವೈಲ್ಡ್ಕಾರ್ಡ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇಳುವರಿಃ ಇನ್ಔಟ್ (ಚಾರ್) * ಸ್ಟ್ರಾಚರ್ (ಇನ್ಔಟ್ (ಚಾರ್) * ಎಸ್, ಇಂಟ್ ಈ ಪರಿಹಾರವನ್ನು ರಿಚೀ ಪ್ರಸ್ತಾಪಿಸಿದರು ಮತ್ತು ತರುವಾಯ ಅಂಗೀಕರಿಸಿದರು. ಈ ವ್ಯತ್ಯಾಸವು ಸಿ ಮತ್ತು ಸಿ + + ನ ಹೊಂದಾಣಿಕೆಯ ವೈಫಲ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. C23 ರಿಂದ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳ ಬಳಕೆಯಿಂದ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ. ಸಮಸ್ಯೆಯಿಂದ ಬಾಧಿತವಾದ ಎಸ್ಟಿಆರ್ಸಿಆರ್ಆರ್ ಮತ್ತು ಇತರ ಕಾರ್ಯಗಳು ಒಂದನ್ನು ಅವರಿಗೆ ರವಾನಿಸಿದರೆ ಕಾನ್ಸ್ಟ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಅನರ್ಹವಾದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಅವರಿಗೆ ರವಾನಿಸಿದರೆ ಅನರ್ಹವಾದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಡಿ ನ ಆವೃತ್ತಿ 2 ರಲ್ಲಿ, ಕಾನ್ಸ್ಟ್ಗೆ ಸಂಬಂಧಿಸಿದ ಎರಡು ಕೀವರ್ಡ್ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಬದಲಾಗದ ಕೀವರ್ಡ್ ಯಾವುದೇ ಉಲ್ಲೇಖದ ಮೂಲಕ ಮಾರ್ಪಡಿಸಲಾಗದ ಡೇಟಾವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಕಾನ್ಸ್ಟ್ ಕೀವರ್ಡ್ ಪರಿವರ್ತನೀಯ ದತ್ತಾಂಶದ ಬದಲಾಗದ ನೋಟವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಸಿ + + ಕಾನ್ಸ್ಟ್ನಂತಲ್ಲದೆ, ಡಿ ಕಾನ್ಸ್ಟ್ ಮತ್ತು ಅಸ್ಥಿರತೆಯು "ಆಳವಾದ" ಅಥವಾ, ಮತ್ತು ಸ್ಥಿರ ಅಥವಾ ಅಸ್ಥಿರ ವಸ್ತುವಿನ ಮೂಲಕ ತಲುಪಬಹುದಾದ ಯಾವುದಾದರೂ ವಸ್ತುವು ಅನುಕ್ರಮವಾಗಿ ಸ್ಥಿರ ಅಥವಾ ಅಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಡಿ ಇಂಟ್ [] ಫೂ = ಹೊಸ ಇಂಟ್ [5];// ಫೂ ನಲ್ಲಿ ಅಸ್ಥಿರವಾದ ಕಾನ್ಸ್ಟ್ನ ಉದಾಹರಣೆಯು ಪರಿವರ್ತನೀಯವಾಗಿದೆ. ಸ್ಥಿರಾಂಕ [] ಬಾರ್ = ಫೂ;// ಬಾರ್ ಎಂಬುದು ಪರಿವರ್ತನೀಯ ದತ್ತಾಂಶದ ಸ್ಥಿರ ನೋಟವಾಗಿದೆ. ಬದಲಾಯಿಸಲಾಗದ int [] ಬಾಜ್ = foo;// ದೋಷ-ಬದಲಾಗದ ದತ್ತಾಂಶದ ಎಲ್ಲಾ ವೀಕ್ಷಣೆಗಳು ಬದಲಾಗದಂತಿರಬೇಕು. ಅಪರಿವರ್ತನೀಯ ಪೂರ್ಣಾಂಕ [] ಸಂಖ್ಯೆಗಳು = ಹೊಸ ಅಪರಿವರ್ತನೀಯ (ಪೂರ್ಣಾಂಕ) [5];// ಸಂಖ್ಯೆಗಳ ಯಾವುದೇ ಪರಿವರ್ತನೀಯ ಉಲ್ಲೇಖವನ್ನು ರಚಿಸಲಾಗುವುದಿಲ್ಲ. ಸ್ಥಿರಾಂಕ [] ಸ್ಥಿರಾಂಕಗಳು = ಸಂಖ್ಯೆಗಳು;// ವರ್ಕ್ಸ್. ಬದಲಾಗದ ಸ್ಥಿತಿಯನ್ನು ಪರೋಕ್ಷವಾಗಿ ಸ್ಥಿರಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು. int [] ಪರಿವರ್ತನೀಯ ಸಂಖ್ಯೆಗಳು = ಸಂಖ್ಯೆಗಳು;// ದೋಷಃ ಬದಲಾಗದ ದತ್ತಾಂಶದ ಪರಿವರ್ತನೀಯ ನೋಟವನ್ನು ರಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಡಿ ವರ್ಗದಲ್ಲಿ ಪರಿವರ್ತಕ ಅಥವಾ ಆಳವಾದ ಸ್ಥಿರಾಂಕದ ಉದಾಹರಣೆ ಫೂ {ಫೂ ನೆಕ್ಸ್ಟ್; ಇಂಟ್ ನಮ್;} ಬದಲಾಗದ ಫೂ ಫೂ = ಹೊಸ ಬದಲಾಗದ (ಫೂ); foo.next.num = 5;// ಕಂಪೈಲ್ ಮಾಡುವುದಿಲ್ಲ. foo.next ಎಂಬುದು ಬದಲಾಯಿಸಲಾಗದ (Foo) ರೀತಿಯದ್ದಾಗಿದೆ. //foo.next.num ಎಂಬುದು ಬದಲಾಯಿಸಲಾಗದ (int) ರೀತಿಯದ್ದಾಗಿದೆ. ಹಿಸ್ಟರಿ ಕಾನ್ಸ್ಟ್ ಅನ್ನು 1981 ರಲ್ಲಿ ಸಿ + + ಗೆ ಪೂರ್ವವರ್ತಿಯಾದ ಕ್ಲಾಸ್ಸ್ನೊಂದಿಗೆ ಸಿ ಯಲ್ಲಿ ಜಾರ್ನೆ ಸ್ಟ್ರೌಸ್ಟ್ರಪ್ ಪರಿಚಯಿಸಿದರು ಮತ್ತು ಇದನ್ನು ಮೂಲತಃ ರೀಡ್ ಓನ್ಲಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತಿತ್ತು. ಪ್ರೇರಣೆಯ ಬಗ್ಗೆ, ಸ್ಟ್ರೌಸ್ಟ್ರಪ್ ಬರೆಯುತ್ತಾರೆಃ "ಇದು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಿತುಃ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಪ್ರಕಾರದ ನಿಯಮಗಳನ್ನು ಪಾಲಿಸುವ ಸಾಂಕೇತಿಕ ಸ್ಥಿರಾಂಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮಾರ್ಗವಾಗಿ (ಅಂದರೆ, ಸ್ಥೂಲವನ್ನು ಬಳಸದೆ) ಮತ್ತು ಸ್ಮರಣೆಯಲ್ಲಿ ವಸ್ತುವನ್ನು ಬದಲಾಗದ ಮಾರ್ಗವೆಂದು ಪರಿಗಣಿಸುವ ಮಾರ್ಗವಾಗಿ". ಮೊದಲ ಬಳಕೆಯು, ಮ್ಯಾಕ್ರೋಗಳಿಗೆ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಟೈಪ್ ಮಾಡಿದ ಪರ್ಯಾಯವಾಗಿ, ಇನ್ಲೈನ್ ಕೀವರ್ಡ್ ಮೂಲಕ ಕಾರ್ಯದಂತಹ ಮ್ಯಾಕ್ರೋಗಳಿಗೆ ಹೋಲುತ್ತದೆ. ಸ್ಥಿರವಾದ ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು * ಕಾನ್ಸ್ಟ್ ಸಂಕೇತಗಳನ್ನು ಡೆನ್ನಿಸ್ ರಿಚೀ ಸೂಚಿಸಿದರು ಮತ್ತು ಆದ್ದರಿಂದ ಅಳವಡಿಸಿಕೊಂಡರು. ಕಾನ್ಸ್ಟ್ ಅನ್ನು ನಂತರ ಪ್ರಮಾಣೀಕರಣದ ಭಾಗವಾಗಿ ಸಿ ಯಲ್ಲಿ ಅಳವಡಿಸಿಕೊಳ್ಳಲಾಯಿತು, ಮತ್ತು ಇತರ ರೀತಿಯ ಅರ್ಹತಾ, ಅಸ್ಥಿರತೆಯೊಂದಿಗೆ ಸಿ89 (ಮತ್ತು ನಂತರದ ಆವೃತ್ತಿಗಳು) ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. 1987ರ ಡಿಸೆಂಬರ್ನಲ್ಲಿ ನಡೆದ X3J11 ಸಮಿತಿಯ ಸಭೆಯಲ್ಲಿ ನೊಯಾಲಿಯಸ್ ಎಂಬ ಮತ್ತೊಂದು ಅರ್ಹತಾ ಪದವನ್ನು ಸೂಚಿಸಲಾಯಿತು, ಆದರೆ ಅದನ್ನು ತಿರಸ್ಕರಿಸಲಾಯಿತು; ಅದರ ಗುರಿಯನ್ನು ಅಂತಿಮವಾಗಿ C99ರಲ್ಲಿನ ನಿರ್ಬಂಧಿತ ಕೀವರ್ಡ್ ಪೂರೈಸಿತು. ರಿಚೀ ಈ ಸೇರ್ಪಡೆಗಳನ್ನು ಹೆಚ್ಚು ಬೆಂಬಲಿಸಲಿಲ್ಲ, ಅವು "ತಮ್ಮ ತೂಕವನ್ನು ಹೊತ್ತುಕೊಂಡಿಲ್ಲ" ಎಂದು ವಾದಿಸಿದರು, ಆದರೆ ಅಂತಿಮವಾಗಿ ಅವುಗಳನ್ನು ಮಾನದಂಡದಿಂದ ತೆಗೆದುಹಾಕಲು ವಾದಿಸಲಿಲ್ಲ. ಡಿ ತರುವಾಯ ಸಿ + + ನಿಂದ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದುಕೊಂಡಿತು, ಅಲ್ಲಿ ಇದನ್ನು ಟೈಪ್ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ (ಟೈಪ್ ಕ್ವಾಲಿಫೈಯರ್ ಅಲ್ಲ) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಸಂಬಂಧಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇನ್ನೂ ಎರಡು ರೀತಿಯ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ. ಇತರ ಭಾಷೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಮೇಲ್ನೋಟಕ್ಕೆ ಹೋಲುವ ರಚನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೂ ಮತ್ತು ಕಾನ್ಸ್ಟ್ ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬಹುದಾದರೂ, ಈ ಪ್ರಕಾರದ ಸ್ಥಿರತೆಯ ಭಾಗವನ್ನು ಹೊಂದುವಲ್ಲಿ ಇತರ ಭಾಷೆಗಳು ಸಿ/ಸಿ + + ಅನ್ನು ಅನುಸರಿಸುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯವಾಗಿ ಇದನ್ನು ಸ್ಥಿರಾಂಕಗಳಿಗೆ (ಸ್ಥಿರ ವಸ್ತುಗಳು) ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ. ಸಿ #ಕಾನ್ಸ್ಟ್ ಕೀವರ್ಡ್ ಅನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಆಮೂಲಾಗ್ರವಾಗಿ ವಿಭಿನ್ನ ಮತ್ತು ಸರಳವಾದ ಶಬ್ದಾರ್ಥಗಳೊಂದಿಗೆಃ ಇದು ಕಂಪೈಲ್-ಟೈಮ್ ಕಾನ್ಸ್ಟೆಂಟ್ ಎಂದರ್ಥ, ಮತ್ತು ಇದು ಪ್ರಕಾರದ ಭಾಗವಲ್ಲ. ನಿಮ್ ಸಿ #ನಂತೆಯೇ ಕಾನ್ಸ್ಟ್ ಕೀವರ್ಡ್ ಅನ್ನು ಹೊಂದಿದೆಃ ಇದು ಪ್ರಕಾರದ ಭಾಗವನ್ನು ರೂಪಿಸುವ ಬದಲು ಕಂಪೈಲ್-ಟೈಮ್ ಕಾನ್ಸ್ಟೆಂಟ್ ಅನ್ನು ಸಹ ಘೋಷಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನಿಮ್ನಲ್ಲಿ, ಸಂಕಲನ ಸಮಯದಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಹುದಾದ ಯಾವುದೇ ಅಭಿವ್ಯಕ್ತಿಯಿಂದ ಸ್ಥಿರಾಂಕವನ್ನು ಘೋಷಿಸಬಹುದು. ಸಿ #ನಲ್ಲಿ, ಸಿ #ಅಂತರ್ನಿರ್ಮಿತ ಪ್ರಕಾರಗಳನ್ನು ಮಾತ್ರ ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸಬಹುದು; ವರ್ಗಗಳು, ರಚನೆಗಳು ಮತ್ತು ಸರಣಿಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಪ್ರಕಾರಗಳನ್ನು ಕಾನ್ಸ್ಟ್ ಎಂದು ಘೋಷಿಸಲಾಗುವುದಿಲ್ಲ. ಜಾವಾವು ಸ್ಥಿರಾಂಕವನ್ನು ಹೊಂದಿಲ್ಲ-ಬದಲಿಗೆ ಇದು ಅಂತಿಮವನ್ನು ಹೊಂದಿದೆ, ಇದನ್ನು ಸ್ಥಳೀಯ "ವೇರಿಯೇಬಲ್" ಘೋಷಣೆಗಳಿಗೆ ಅನ್ವಯಿಸಬಹುದು ಮತ್ತು ಗುರುತಿಸುವಿಕೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ, ಪ್ರಕಾರಕ್ಕೆ ಅಲ್ಲ. ಇದು ಆಬ್ಜೆಕ್ಟ್ ಸದಸ್ಯರಿಗೆ ವಿಭಿನ್ನವಾದ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಬಳಕೆಯನ್ನು ಹೊಂದಿದೆ, ಇದು ಹೆಸರಿನ ಮೂಲವಾಗಿದೆ. ಜಾವಾ ಭಾಷೆಯ ವಿವರಣೆಯು ಕಾನ್ಸ್ಟ್ ಅನ್ನು ಕಾಯ್ದಿರಿಸಿದ ಕೀವರ್ಡ್ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ-ಅಂದರೆ, ಅದನ್ನು ವೇರಿಯೇಬಲ್ ಐಡೆಂಟಿಫೈಯರ್ ಆಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ-ಆದರೆ ಅದಕ್ಕೆ ಯಾವುದೇ ಶಬ್ದಾರ್ಥವನ್ನು ನಿಯೋಜಿಸುವುದಿಲ್ಲಃ ಇದು ಕಾಯ್ದಿರಿಸಿದ ಪದವಾಗಿದೆ (ಇದನ್ನು ಐಡೆಂಟಿಫೈಯರ್ಗಳಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ) ಆದರೆ ಕೀವರ್ಡ್ ಅಲ್ಲ (ಇದು ಯಾವುದೇ ವಿಶೇಷ ಅರ್ಥವನ್ನು ಹೊಂದಿಲ್ಲ). ಸಿ + +-ಶೈಲಿಯ ಕಾನ್ಸ್ಟ್ ವಿಧಾನಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ನಿಂದ ಕಾನ್ಸ್ಟ್ ಪ್ರಕಾರವನ್ನು ಸೇರಿಸಲು ಜಾವಾ ಭಾಷೆಯ ವಿಸ್ತರಣೆಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡಲು ಕೀವರ್ಡ್ನ ಕಾಯ್ದಿರಿಸುವಿಕೆಯು ಸಂಭವಿಸಿದೆ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ. ಕಾನ್ಸ್ಟ್ ನಿಖರತೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ವರ್ಧನೆಯ ವಿನಂತಿಯ ಟಿಕೆಟ್ ಜಾವಾ ಸಮುದಾಯ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಆದರೆ ಹಿಂದುಳಿದ-ಹೊಂದಾಣಿಕೆಯ ಶೈಲಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಅಸಾಧ್ಯ ಎಂಬ ಆಧಾರದ ಮೇಲೆ 2005ರಲ್ಲಿ ಅದನ್ನು ಮುಚ್ಚಲಾಯಿತು. ಸಮಕಾಲೀನ ಅಡಾ 83 ಸ್ವತಂತ್ರವಾಗಿ ಸ್ಥಿರವಾದ ವಸ್ತು ಮತ್ತು ಸ್ಥಿರವಾದ ಕೀವರ್ಡ್ನ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿತ್ತು, ಇನ್ಪುಟ್ ನಿಯತಾಂಕಗಳು ಮತ್ತು ಲೂಪ್ ನಿಯತಾಂಕಗಳು ಸೂಚ್ಯವಾಗಿ ಸ್ಥಿರವಾಗಿವೆ. ಇಲ್ಲಿ ಸ್ಥಿರಾಂಕವು ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣವಾಗಿದೆ, ಅದರ ಪ್ರಕಾರವಲ್ಲ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾನ್ಸ್ಟ್ ಘೋಷಣೆಯನ್ನು ಹೊಂದಿದ್ದು ಅದು ಬ್ಲಾಕ್-ಸ್ಕೋಪ್ಡ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅದನ್ನು ಮರುಹೊಂದಿಸಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ಮರುಹಂಚಿಕೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ. ಇದು ಮರು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗದ ವೇರಿಯೇಬಲ್ಗೆ ಓದಲು-ಮಾತ್ರ ಉಲ್ಲೇಖವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಸಂಭಾವ್ಯವಾಗಿ ಬದಲಾಗಬಹುದು, ಉದಾಹರಣೆಗೆ ವೇರಿಯೇಬಲ್ ಒಂದು ವಸ್ತುವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಗುಣಲಕ್ಷಣವನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ. ಒಂದೇ ನಿಯೋಜನೆಯ ನಿರ್ಬಂಧ ಪಾಯಿಂಟರ್ ಅಲಿಯಾಸಿಂಗ್ ಟಿಪ್ಪಣಿಗಳು ಉಲ್ಲೇಖಗಳು ಬಾಹ್ಯ ಕೊಂಡಿಗಳು "ಕಾನ್ಸ್ಟ್-ಕರೆಕ್ಟ್ನೆಸ್" ಬೈ ಹರ್ಬ್ ಸಟ್ಟರ್ "ಕಾನ್ಸ್ಟಂಟ್ ಆಪ್ಟಿಮೈಸೇಶನ್?" ದಿ ಸಿ + + ಎಫ್ಎಕ್ಯೂ ಲೈಟ್ಃ ದಿ ಸಿ + + ಎಫ್ಎಕ್ಯೂ ಲೈಟ್ಃ ಮಾರ್ಷಲ್ ಕ್ಲೈನ್ ಅವರ ಕಾನ್ಸ್ಟೆಂಟ್ ನಿಖರತೆ ವಿಭಾಗವು ಬ್ರೂಸ್ ಎಕೆಲ್ ಅವರ ಉಚಿತ ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಪುಸ್ತಕ ಥಿಂಕಿಂಗ್ ಇನ್ ಸಿ + + ನಿಂದ "ಮೌಲ್ಯ ಪರ್ಯಾಯ" ವಾಲ್ಟರ್ ಬ್ರೈಟ್ ಅವರ "ಹಿಯರ್ ಎ ಕಾನ್ಸ್ಟೆಂಟ್, ದೇರ್ ಎ ಕಾನ್ಸ್ಟೆಂಟ್" ಡಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ನಿರ್ದಿಷ್ಟತೆಯಿಂದ "ಕಾನ್ಸ್ಟೆಂಟ್ ಮತ್ತು ಇನ್ವೇರಿಯಂಟ್", ಆವೃತ್ತಿ 2 (ಪ್ರಾಯೋಗಿಕ) ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಕುಟುಂಬ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಉದಾಹರಣೆಗೆ ಸಿ ಕೋಡ್ ಲೇಖನಗಳೊಂದಿಗೆ ಲೇಖನಗಳು ಸಿ + + ಕೋಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ವಿಷಯಗಳೊಂದಿಗೆ