int ಅನ್ನೋ ತುಂಬಂಕೆ(integer)ಯನ್ನು ಸೂಚಿಸುವ ಕೀಲಿಪದ(keyword)ವನ್ನು ಹಿಂದೆ ನೋಡಿದ್ವಿ. ಇದನ್ನು ನೋಡಿದ ಕೂಡಲೇ ನಮಗೆ ಬರಬಹುದಾದ ಕೆಲವು ಪ್ರಶ್ನೆಗಳು ಇವು:
೧. ಕೀಲಿಪದ ಅಂದರೆ ಏನು?
ಉ. ಸಿಯಲ್ಲಿ ಕೆಲವು ಪದಗಳನ್ನು ಮೀಸಲಾಗಿ ಇಡಲಾಗಿದೆ. ಇವುಗಳನ್ನು ಕೆಲಸ(function), ಮಾರ್ಪಡಬಲ್ಲ(variable)ಗಳ ಹೆಸರುಗಳಾಗಿ ಬಳಸುವಂತಿಲ್ಲ.
೨. ಯಾಕೆ ಬೇಕು ಈ ಕೀಲಿಪದಗಳು?
ಉ. ಹಮ್ಮಿನಲ್ಲಿ ನುಡಿಯ ಕಟ್ಟು(construct)ಗಳನ್ನು ತಿಳಿಸಿವುದಕ್ಕೆ, ಕೊಡೆ ಬಗೆಗಳ(data types)ನ್ನು ಸೂಚಿಸುವುದಕ್ಕೆ, ಒಟ್ಟುಕ(compiler)ಕ್ಕೆ ಕೆಲವು ಸುಳಿವುಗಳನ್ನು ನೀಡುವುದಕ್ಕೆ ಬಳಸಲಾಗುತ್ತದೆ.
೩. ಸಿಯಲ್ಲಿ ಎಶ್ಟು ಕೀಲಿಪದಗಳಿವೆ ಮತ್ತು ಅವು ಯಾವುವು?
ಉ. ೩೨. ಆ ಎಲ್ಲ ೩೨ ಕೀಲಿಪದಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ:
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
೪. ಈ ಒಂದೊಂದು ಕೀಲಿಪದದ ಹುರುಳೇನು?
ಉ. int ಬಗ್ಗೆ ಆಗಲೇ ಹೇಳಿದ್ದೇನೆ. ಮುಂದಿನ ಬರಹಗಳಲ್ಲಿ ಹೊಸ ಕೀಲಿಪದ ಬಳಸಿದಾಗಲೆಲ್ಲ ಅದರ ಹುರುಳನ್ನೂ, ಕುರಿ(ಉದ್ದೇಶ)ಯನ್ನೂ ಹೇಳುತ್ತೇನೆ.
Wednesday, October 27, 2010
Sunday, October 24, 2010
ಸಿ ಹಮ್ಮುಗೆ ೩
ಹಿಂದಿನ ಬರಹದಲ್ಲಿ ಒಂದು ಹೆದೆ (string)ಯನ್ನು ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸಿದೆವು. ಈಗ ನಮ್ಮ ಎಣಿ(computer)ಯಿಂದ ಕೊಂಚ ಕೆಲಸ ಮಾಡಿಸೋಣ. ದೊಡ್ಡ ಕೆಲಸವೇನೂ ಅಲ್ಲ. ಕೂಡೋ ಲೆಕ್ಕ ಮಾಡಿಸೋಣ. ನಮ್ಮ ಹಮ್ಮು (program) ಎಸಗಿದಾಗ ಮಾಡ ಬೇಕಾಗಿರುವುದು ಇಶ್ಟು:
ಒಂದಾದ ಮೆಲೊಂದಂತೆ ಎರಡು integer ಅಂಕಿಗಳನ್ನು ತೊಗೋಬೇಕು. ಅಂದರೆ ಒಳವೊಡ್ಡಿಗಳಂತೆ (ಒಳ + ಒಡ್ಡು + ಇ = input) ತೊಗೋಬೇಕು. ಆಮೇಲೆ ಅವೆರಡನ್ನೂ ಕೂಡಿಸಿ ಅದರ ಮೊತ್ತವನ್ನು ಪಳಿ(output)ಯಾಗಿ ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸ ಬೇಕು.
ಬಹಳ ಸುಳುವಾದ ತೊಂದರೆಯ ಹೇಳಿಕೆ (problem statement) ಅಲ್ವಾ? ಇದರ ಬಗೆಹರಿಕೆಯೂ ಅಶ್ಟೆ ಸಲೀಸಾದುದು. ನೋಡೋಣ ಬನ್ನಿ.
#include
main() {
int koodi1, koodi2;
int motta;
main() ಅಲ್ಲಿ ಮೂರು ಮಾರ್ಪಡಬಲ್ಲ(variable)ಗಳನ್ನು ಸಾರಿದ್ದೇವೆ (declare). ಮೊದಲನೇ ಸಾಲಿನಲ್ಲಿ ಎರಡು ಮಾರ್ಪಡಬಲ್ಲಗಳು ನಮ್ಮ ಎರಡು ಕೂಡಿ(addend)ಗಳ ಬೆಲೆ(value)ಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದಕ್ಕೆ. ಅಂದರೆ ಎರಡು ಅಂಕಿಗಳನ್ನು ಒಳವೊಡ್ಡಿ(input)ಯಾಗಿ ಕೊಡ್ತೀವಲ್ವಾ, ಈ ಎರಡು ಮಾರ್ಪಡಬಲ್ಲಗಳು ಒಳವೊಡ್ಡಿದ ಅಂಕಿಗಳ ಬೆಲೆಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಮತ್ತು ಇವೆರಡನ್ನು ಕೂಡಿದ ಮೊತ್ತದ ಬೆಲೆಯನ್ನು ಉಳಿಸುವುದಕ್ಕಾಗಿ 'motta' ಎಂಬ ಮಾರ್ಪಡಬಲ್ಲವನ್ನು ಸಾರಿದ್ದೇವೆ. ಇವು ತುಂಬಂಕೆ(integer)ಯ ಬೆಲೆಗಳನ್ನು ಹೊಂದುವುದರಿಂದ int ಎಂಬ ಕೀಲಿಪದ(keyword)ವನ್ನು ಸಾರಿಗೆ(declaration)ಯ ಮೊದಲಲ್ಲಿ ಬಲಸಲಾಗಿದೆ. ಸಾರಿಗೆಯ ಹೇಳಿಕೆಗಳ ಸೋಲ್ಲಿಟ್ಟಳ(syntax)ವನ್ನು, ಕೀಲಿಪದಗಳು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯನ್ನು ಮುಂದಿನ ಬರಹಗಳಲ್ಲಿ ತಿಳಿಸುತ್ತೇನೆ.
ಈಗ ಒಳವೊಡ್ಡಿಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳೋಣ:
scanf("%d", &koodi1);
scanf("%d", &koodi2);
ಅಶ್ಟೆ! scanf() ಎಂಬುದು stdio.h ಕಣಜ(library)ದಲ್ಲಿರುವ ಒಂದು ಕೆಲಸ(function). ಇದು ಬಳಕೆಗಾರನು ತೆರೆಯ ಮೇಲೆ ನೀಡುವ ಒಳವೊಡ್ಡಿಗಾಗಿ ಕಾಯುತ್ತಿರುತ್ತದೆ. %d ಎಂಬುದು ಬರುವ ಬೆಲೆಯ ಕೊಡೆ ಬಗೆ(data type)ಯು integer ಎಂದು ತಿಳಿಸುತ್ತದೆ.
ಮತ್ತು ಎರಡನೇ ಬಿತ್ತಿಗೆ (parameter) '&koodi1' ಒಳವೊಡ್ಡಿದ ಬೆಲೆಯನ್ನು koodi1 ಮಾರ್ಪಡಬಲ್ಲಕ್ಕೆ ಪಡಿಯಿಸ (copy) ಬೇಕೆಂದು ಹೇಳುತ್ತದೆ. ಎರಡು ಸಲ scanf() ಕರೆಯುವುದರ ಕುರಿ (ಉದ್ದೇಶ) ಎರಡು ಕೂಡಿ(addend)ಗಳ ಬೆಲೆಗಳನ್ನು ಒಳವೊಡ್ಡುವುದು.
ಅದೇನೋ ಸರಿ, ಆದರೆ ಎರಡನೇ ಬಿತ್ತಿಗೆಯಲ್ಲಿ, kood1 ಮತ್ತು koodi2 ಮುಂದೆ & ಯಾಕೆ ಬಂದಿದೆ? 'ಹಮ್ಮುಗೆ'(programming)ಯಲ್ಲಿ ಕೆಲಸ(function)ಗಳಿಗೆ ಬಿತ್ತಿಗೆಗಳನ್ನು ಕೊಡುವ ಎರಡು ಬಗೆಗಳಿವೆ: 'ಬೆಲೆಯನ್ನು ಪಡಿಯಿಸುವುದು' ಮತ್ತು 'ಪತ್ತುಗೆಯನ್ನು ಪಡಿಯಿಸುವುದು' (copy by value, copy by reference). ಮುಂದೆ & ಹಾಕುವುದರಿಂದ ಕೆಲಸದೊಳಕ್ಕೆ ಪತ್ತುಗೆಯನ್ನು ಪಡಿಯಿಸಲಾಗುತ್ತದೆ. ಇದು ಏನು, ಯಾಕೆ, ಎತ್ತ ಅಂತೆಲ್ಲ ಈಗ ತಲೆ ಕೆಡಿಸ್ಕೊಳ್ಳೋದು ಬೇಡ. ಮುಂದೆ ಯಾವಾಗಲಾದರೂ ಹೇಳುತ್ತೇನೆ. ಸದ್ಯಕ್ಕೆ & ಬಳಸಬೇಕು ಅಂತ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಿ ಸಾಕು.
ಎರಡು ಕೂಡಿಗಳ ಬೆಲೆ ತೆಗೆದು ಕೊಂಡಿದ್ದಾಯಿತು. ಈಗ ಅವೆರಡನ್ನೂ ಕೂಡಿಸಿ mottaಕ್ಕೆ ಅದರ ಬೆಲೆಯನ್ನು ಒಪ್ಪಿಸೋಣ (assign).
motta = koodi1 + koodi2;
ಈಗ ಅದನ್ನು ತೆರೆಯ ಮೇಲೆ ಅಚ್ಚಿಸೋಣ.
printf("\n%d", motta);
main() ಕೆಲಸ (function)ವನ್ನು ಮುಕ್ತಾಯ ಮಾಡೋಣ.
}
Subscribe to:
Posts (Atom)