ಕನ್ನಡದಲ್ಲಿ Object Oriented Programming

ನಾನು ಮಾಡುವ ಕೆಲಸದಲ್ಲಿ Object Oriented Programming ಸಾಕಷ್ಟು ಬಳಸುವುದರಿಂದ ಕನ್ನಡದಲ್ಲಿ ಇದನ್ನು ಏನಂತ ಕರಿಬಹುದು ಅಂತ ಆರಯ್ಯುತ್ತಿದ್ದೆ, ಅಂದ್ರೆ ಯೋಚಿಸ್ತಾ ಇದ್ದೆ. Programming ಅನ್ನೋದಕ್ಕೆ ಆಗಲೇ ಹಮ್ಮುಗೆ ಅನ್ನೋ ಪದ ಇದೆ. Orientedಗೆ ಏನೋ ಒಂದು ಹುಡುಕಬಹುದು. ಆದರೆ Objectಗೆ ಕನ್ನಡದಲ್ಲಿ ಯಾವ ಪದ ಇದೆ?

ಹೆಚ್ಚು ಕಡಿಮೆ ಎಲ್ಲರು 'ವಸ್ತು' ಅನ್ನೋ ಸಕ್ಕದ ಪದವನ್ನ ಬಳಸ್ತೀವಿ. ಆದರೆ ಅಚ್ಚಗನ್ನಡದ್ದು? ಕೊಂಚ ಯೋಚನೆ ಮಾಡಿದೆ, ಆಮೇಲೆ ಪದನೆರಕೆಗಳಲ್ಲಿ ಹುಡುಕೋದಕ್ಕೆ ತೊಡಗಿದೆ. ಎಷ್ಟೋ ಹುಡುಕಿದ ಮೇಲೆ ಸಿಕ್ಕಿದ ಪದ - ಸರಕು. ಈ ಪದಕ್ಕೆ goods, merchandise ಎಂಬ ಅರ್ತ ಬರುವಂತೆ ಕನ್ನಡದಲ್ಲಿ ಬಳಸ್ತೀವೇ ಹೊರತು object ಎಂಬ ಅರ್ತದಲ್ಲಿ ಅಲ್ಲ.

ಹಾಗೇ ಸುಮಾರು ಹುಡುಕಿದ್ ಮೇಲೆ ಇನ್ನೊಂದು ಪದ 'ಹುರುಳು/ಪುರುಳು' ಅಂತ ಸಿಕ್ಕಿತು. ಇದು ಸಿರಿ, ಸಂಪತ್ತು, ದ್ರವ್ಯ ಅನ್ನೋ ಅರ್ತದಲ್ಲಿ ಬಳಕೆಯಾಗುತ್ತೆ.

ನಾವು ಹೊರ ಪ್ರಪಂಚದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ನೋಡುವುದು Objectಗಳಾಗಿಯೇ. ಅದಕ್ಕಾಗಿಯೇ ಮೊರೆಹಮ್ಮುಗೆ (procedural programming)ಯನ್ನು ತಿದ್ದಿ OOPಯನ್ನು ನಾವು ಹಮ್ಮುಗ(programmer)ರು ಕಂಡು ಕೊಂಡಿರೋದು. ನಾವು ಹಮ್ಮುವ ಬಗೆಯು, ನಾವು ಹೊರಪ್ರಪಂಚವನ್ನು ನೋಡುವ ಬಗೆಗೆ ಹೊಂದುಕೊಂಡರೆ ಹಮ್ಮುಗೆಯು ಸುಳುವಾಗುತ್ತೆ ಅಂತ. Object ಅನ್ನೋ ಇಂತಹ ಒಂದು ಸರಳವಾದ, ಸುಳುವಾದ, ಪರಿಕಲ್ಪನೆಗೆ ಕನ್ನಡದಲ್ಲಿ ಪದವೇ ಇಲ್ಲವಲ್ಲ, ಇದ್ದರೂ ಸಿಗದೇ ಇರೋ ಅಷ್ಟು ದಿನಬಳಕೆಯಲ್ಲಿ ಕಣ್ಮರೆಯಾಗಿದ್ಯಲ್ಲ ಅಂತ ಅಚ್ಚರಿಯಾಯಿತು. ಇರಲಿ, ಈಗ ನಾನು 'ಸರಕು' ಅನ್ನೋ ಪದವನ್ನೇ ಬಳಸೋಣ ಅಂತ ತೀರ್ಮಾನಿಸಿದ್ದೀನಿ. ನಿಮಗೆ ಇನ್ನೂ ಒಳ್ಳೆ ಪದ ಹೊಳೆದರೆ/ ಸಿಕ್ಕರೆ ನನಗೆ ತಿಳಿಸಿ.

ಹಾಗಾದರೆ ಈಗ 'Oriented' ಅನ್ನೋದನ್ನ ಏನಂತ ಹೇಳೋದು? Objet Oriented Programmingನಲ್ಲಿ, ಮೊರೆಹಮ್ಮುಗೆ(Procedural Programming)ಯಲ್ಲಿನಂತೆ, ಒಂದು ಹಮ್ಮನ್ನು (program) ಒಂದು ಕೆಲಸಗಳ ಇಲ್ಲವೇ ಎಸಕಗಳ ಸರಣಿ ಎಂದು ಬಾವಿಸದೆ ಸರಕು(Object)ಗಳ ಒಡನಾಟ(collaboration)ಗಳೆಂದು ಬಾವಿಸ ಬೇಕು. ಅಂದ್ರೆ ಹಮ್ಮುಗನಿಗೆ ಆ object ಬಾವನೆ ಇಲ್ಲವೇ ಸರಕು-ಬಾವನೆ ಬೇಕು. ಕನ್ನಡಲ್ಲಿ ಬಾವನೆಗೆ ಸರಿ ಹೊಂದೋ ಪದ 'ಉನ್ನು' ಅಂತ ನನಗೆ ಅನಿಸುತ್ತೆ. ಹಾಗಾಗಿ ನಾವು OOPಯನ್ನು 'ಸರಕುನ್ನುವ ಹಮ್ಮುಗೆ'ಅಂತ ಹೇಳಬಹುದು.

'ಉನ್ನು'(ಭಾವಿಸು) ಎಂಬುದು ಎಸಕಪದವಾದ್ದರಿಂದ 'ಸರಕುನ್ನು' (ಸರಕು + ಉನ್ನು) ಕೂಡ ಎಸಕಪದವೇ. ಶಂಕರ ಬಟ್ಟರು, ತಮ್ಮ ಒಂದು ಹೊತ್ತಗೆಯಲ್ಲಿ ಹೇಳುವಂತೆ, 'ಹಮ್ಮುಗೆ' ಅನ್ನೋ ಹೆಸರು ಪದದ ಮೊದಲು 'ಸರಕುನ್ನು' ಅನ್ನೋ ಎಸಕ ಪದ ಅದರ adjectiveಆಗಿ ಬರಬಹುದು. ಶಂಕರ ಬಟ್ಟರದೇ ಕೆಲವು (ಎಸಕಪದ + ಹೆಸರುಪದ) ಎತ್ತುಗೆಗಳನ್ನು ನೋಡಿ: ಸುರಿಮಳೆ, ಹುಟ್ಟುಹಬ್ಬ, ಊರುಗೋಲು, ಬೀಸುಗಲ್ಲು. ಹಾಗಾಗಿ ಇದನ್ನು ಎರಡು ಬಿಡಿಪದಗಳಾಗಿ ಹೇಳುವು ಬದಲು ಒಂದು ಜೋಡುಪದವಾಗಿ 'ಸರಕುನ್ನುಹಮ್ಮುಗೆ' ಅಂತ ಹೇಳಬಹುದು.

ಸರಕುನ್ನು = ಸರಕು + ಉನ್ನು

Object Oriented Programming = ಸರಕುನ್ನುಹಮ್ಮುಗೆ = ಸರಕುನ್ನು + ಹಮ್ಮುಗೆ  


Object Orientation = ಸರಕುನ್ನಿಕೆ 

ವಿಂಡೋಸ್ ಅವಾಂತರ

ಒಬ್ಬ ಹಮ್ಮುಗ(programmer)ನಿಗೆ ವಿಂಡೋಸ್ ಅಂದರೆ ಅಷ್ಟಕ್ಕೆ ಅಷ್ಟೇನೇ. ಒಂದಲ್ಲ ಒಂದು ತೊಡಕು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತಲೇ ಇರುತ್ತೆ. ಹಿಂದಿನ ಬರಹದಲ್ಲಿ ಕೊಟ್ಟ ಹಮ್ಮು(program) ವಿಂಡೋಸ್ ಅಲ್ಲಿ ಕೆಲಸ ಮಾಡಿಸಬೇಕು ಅಂದರೆ ಕೊಂಚ ಎಚ್ಚರ ವಹಿಸಬೇಕು. ಏನು, ಯಾಕೆ ಅಂತ ಹೇಳುವುದಕ್ಕೆ ಮೊದಲು ಆ ಬರಹದಲ್ಲಿ ಕೊಟ್ಟಿದ್ದ .properties ಕಡತವನ್ನು ಗಮನಿಸಿ:

            ###
            username=username
            password=password
            search_prefix=ಕ
            wiki=kn.wiktionary.org
            output_file=out.txt

ಈ ಕಡತವನ್ನ ನೋಟ್-ಪ್ಯಾಡ್ ಅಲ್ಲಿ ಬರೆದು ಯು.ಟಿ.ಎಫ್ ಮಾರ್ಬರಹ(encoding)ದಲ್ಲಿ ಉಳಿಸಿ ಹಮ್ಮು ಓಡಿಸಿದ್ದೆ. ಸರಿಯಾಗೇ ಓಡಿತ್ತು. ಆದರೆ ಮೊದಲನೇ ಸಾಲಿನ ಅನಿಸಿಕೆ (comment - ####)ಯನ್ನು ತೆಗೆದು ಹಾಕಿ ಓಡಿಸಿದಾಗ ಪಾಪ ನಮ್ಮ ಹಮ್ಮು 'username' ಅನ್ನು ಸರಿಯಾಗಿ ಓದದೆ  '.username' ಅಂತ ಓದಿ, ಹೊಗುತೆ(login)ಯೇ ತೇರಮೆ (failure) ಕಂಡಿತು. ಯಾಕೆ ಅಂತ ಕೊಂಚ ವಿಕಿಪೀಡಿಯ ಹುಡುಕಿದಾಗ ತಿಳಿಯಿತು, ವಿಂಡೋಸ್ ನೋಟ್-ಪ್ಯಾಡಿನ ತೊಂದರೆ ಅಂತ. ಆ ವಿಕಿಪೀಡಿಯ ಬರಹದ ಈ ಸಾಲು ಓದಿ:

Many Windows programs (including Windows Notepad) add the bytes 0xEF, 0xBB, 0xBF at the start of any document saved as UTF-8. This is the UTF-8 encoding of the Unicode byte order mark (BOM), and is commonly referred to as a UTF-8 BOM, even though it is not relevant to byte order.

ಆದರೆ ನನಗೆ ಕಾಣಿಸಿಕೊಂಡ ಬಾಮ್(BOM) 0xFEFF. ಮತ್ತು ಮೇಲೆ ಹೇಳಿದಂತೆ ಒಂದಲ್ಲ, ಎರಡು ಎಂಕೆ(byte)ಯಷ್ಟು. ಇದೊಂದು ಬಿಟ್ಟರೆ ಕಡತದ್ಲ್ಲಿರೋ ಬೇರೆ ಎಲ್ಲ ಬರಿಗೆ(caracter)ಗಳೂ ಸರಿಯಾಗಿಯೇ ಬಂದಿದ್ದವು. ನಾನು ಬಳಸುತ್ತಿರುವುದು ವಿಂಡೋಸ್ ಎಕ್ಸ್.ಪಿ. ಆದರೆ ಬೇರೆ ವಿಂಡೋಸ್ಗಳಲ್ಲಿ ಬಾಮ್ ಆಗಿ ಎಷ್ಟು ಎಂಕೆ(byte)ಗಳು ಇರುತ್ತವೋ, ಅವುಗಳ ಬೆಲೆ ಏನೋ, ಯಾರಿಗೆ ಗೊತ್ತು? ಅವುಗಳೆಲ್ಲವನು ಓರುತ್ತ ಕೂತ್ಕೊಳ್ಳೋದಕ್ಕೆ ಆಗಲ್ಲ.

ಅದಕ್ಕೆ ಒಂದು ಸಣ್ಣ ಬಗೆಹರಿಕೆ(solution) ಇದೆ. ಮೊದಲನೇ ಸಾಲಿನಲ್ಲಿ ಯಾವುದೇ ಒಳುಪು(property)ಗಳನ್ನು ಹಾಕದಿರಿ. ಮೊದಲನೇ ಸಾಲು ಬರಿದಾಗಿ ಬಿಡಿ ಇಲ್ಲ ಅಂದರೆ ನಾನು ಮಾಡಿದ ಹಾಗೆ ಅನಿಸಿಕೆ (## ) ಹಾಕಿ. ಈ ತೊಂದರೆ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ. ಆದರೆ ಯೂನಿಕ್ಸ್  ಇಡಿವಳಿ(system)ಗಳಲ್ಲಿ ಈ ತೊಂದರೆ ಇಲ್ಲ.

ಕನ್ನಡ (ಯುನಿಕೋಡ್) ಕಡತಗಳಿಗಾಗಿ java.util.properties

ತೇಲುವ ಚುಕ್ಕಿಯ ಬಗ್ಗೆಯ ಬರಹಗಳನ್ನ ಮುಂದುವರೆಸುವುದಕ್ಕೆ ಮೊದಲು, ಒಂದು ಹಮ್ಮು ಹಂಚಿಕೊಳ್ಳೋಣ ಅಂತ ಅಂದುಕೊಂಡೆ. ಆದರೆ ಇದು ಜಾವ ಹಮ್ಮುಗ(programmer)ರಿಗೆ ಮಾತ್ರ.

ಇತ್ತೀಚಿಗೆ ವಿಕ್ಷನರಿಗೆ ಒರೆಗಳನ್ನು ಸೇರಿಸುವ ಮೊರೆ / ಪರಿವಿಡಿ(procedure)ಯನ್ನು ತನ್ನಡೆಸು(automate)ವ ಹೊಣೆಯನ್ನು ನನಗೆ ಸಂಜೀವ್ ವಹಿಸಿದರು. ಅದಕ್ಕಾಗಿ ಒಂದು ಸಣ್ಣ ಹಮ್ಮು ಬರೆದೆ, ಜಾವದಲ್ಲಿ. ಕೆಲವು ಒಳುಪುಗಳನ್ನು(properties) ಉಳಿಸಿಡಲು ಒಂದು .properties ಕಡತವನ್ನು ಬರೆದು ಅದರಲ್ಲಿ ಕೆಲವು ಕನ್ನಡದ ಬೆಲೆ(value)ಗಳನ್ನು ಬಳಸಿದೆ. ಅಂದರೆ ಕನ್ನಡ ಯುನಿಕೋಡ್ ಲಿಪಿಯಲ್ಲಿ ಬೆಲೆಗಳನ್ನು ಹಾಕಿದೆನು. ಆ ಕಡತದ ಒಳಪಿಡಿ(contents) ಹೀಗಿತ್ತು ನೋಡಿ:

###

username=username

password=password

search_prefix=ಕ

wiki=kn.wiktionary.org

output_file=out.txt

ನಾನು ಬರೆದ ಹಮ್ಮು (program) ಮಾಡಬೇಕಾಗಿದ್ದು ಇಶ್ಟು: ಈ ಕಡತದಲ್ಲಿ ಕೊಟ್ಟಿರುವ ಬಳಕೆಗಾರ-ಹೆಸರು (username) ಮತ್ತು ತೇರ್ಪದ(password)ವನ್ನು ಬಳಸಿ ವಿಕ್ಷನರಿಯನ್ನು ಹೊಕ್ಕು (login) 'ಕ' ಬರಿಗೆ(ಅಕ್ಷರ)ಯಿಂದ ಮೊದಲಾಗುವ ಎಲ್ಲ ಪದಗಳನ್ನು ಹುಡುಕಿ out.txt ಎಂಬ ಕಡತದಲ್ಲಿ ಹಾಕಬೇಕು.

ಹಮ್ಮನ್ನು ಓಡಿಸಿದೆ, ಆದರೆ ಏನೂ ಬರಲಿಲ್ಲ :-(!!! ಸರಿ ಅಂತ ಹುಳ ತೆಗೆಯೋದಕ್ಕೆ (debug) ತೊಡಗಿದೆ. ಆಮೇಲೆ ಗೊತ್ತಾಯ್ತು, ತೊಂದರೆ ಇದ್ದಿದ್ದು ನನ್ನ ಹಮ್ಮಿನಲ್ಲಿ ಅಲ್ಲ, ಈ ಕಡತವನ್ನು ಓದಲು ಬಳಸುತ್ತಿದ್ದ java.util.Properties.load() ಕೆಲಸ(function)ದಲ್ಲಿ ಅಂತ. ಇದರ ಜಾವ ಡಾಕ್ ಹೀಗೆ ಹೇಳುತ್ತೆ:

The load(InputStream) / store(OutputStream, String) methods work the same way as the load(Reader)/store(Writer, String) pair, except the input/output stream is encoded in ISO 8859-1 character encoding. Characters that cannot be directly represented in this encoding can be written using Unicode escapes ; 

ಅಂದರೆ, ಅಯ್.ಎಸ್.ಒ ೮೮೫೯-೧ ಬರಿಗೆ(character)ಗಳು ಮಾತ್ರ ಇರುವ ಕಡತವನ್ನು ಸರಿಯಾಗಿ ಓದುತ್ತೆ. ಆದರೆ ಯುನಿಕೋಡ್ ಬರಿಗೆ ಇದ್ದಲ್ಲಿ ಅದನ್ನು ಸರಿಯಾಗಿ ಮಾರ್ಬರೆ(encode)ಯಬೇಕು. ಅಂದರೆ ಈ ಕಡತದಲ್ಲಿ 'ಕ' ಬಳಸಿದ್ದೀನಲ್ಲ ಅದನ್ನ ಯುನಿಕೋಡ್ ಪಾರು ವರಸೆ (escape sequence)ಯಾಗಿ ಮಾರ್ಬರೆ(encode)ಯಬೇಕು. ಹೀಗೆ:

search_prefix=\u0C95

ಹೀಗೆ ಮಾರ್ಪಾಡು ಮಾಡಿ ಹಮ್ಮು ಓಡಿಸಿದಾಗ 'ಕ' ಇಂದ ಮೊದಲಾಗುವ ಎಲ್ಲ ಪದಗಳು 'out.txt'ಗೆ ಬಂದು ಬಿದ್ದವು. :-)) (ಚಪ್ಪಾಳೆ!!!!)

ಆದರೆ ಲಾಟಿನ್ ಬರಿಗೆಗಳನ್ನು (latin characters) ಬಳಸದ ಕನ್ನಡದಂತಹ ಲಿಪಿಗೆ ಇದು ಕೊಂಚ ತೊಡಕಿನ ಸಂಗತಿ. ಯುನಿಕೋಡ್ ಬರಿಗೆಗಳನ್ನು ಮಾರ್ಬರೆ(encode)ಯದೆ ಹಾಗೇ  .properties ಕಡತದಲ್ಲಿ ಕೊಟ್ಟಿದ್ದನ್ನು ಓದಿ ಬಳಸಬಲ್ಲ ನನ್ನದೇ ಆದ ಒಂದು Properties class ಅನ್ನು ಬರೆದೆ. ಯಾರದೂ ಹಂಗು ಬೇಡ ಅಂತ :-). ಕೆಳಗೆ ಅದರ ಹಮ್ಮು ಹಾಕಿದ್ದೀನಿ. ಇನ್ಮೇಲೆ .properties ಕಡತದಲ್ಲಿ ಕನ್ನಡ ಇಲ್ಲವೇ ಯಾವುದೇ ಯುನಿಕೋಡ್ ಬರಿಗೆಗಳನ್ನು ಬಳಸಬೇಕಾದಾಗ ಪಾರು ವರಸೆ (escape sequence)ಗಳ ಬಗ್ಗೆ ತಲೆ ಕೆಡಿಸ್ಕೊಳ್ಳೋದು ಬೇಡ. ಬಳಸಿ, ಹಾಗೇ ಹಂಚಿಕೊಳ್ಳಿ.

ತೇಲುವ ಚುಕ್ಕಿ

ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆ (floating point number) ಅಂದರೆ  ಏನು? ಹಾಗೆ  ಯಾಕೆ ಕರೆಯುತ್ತಾರೆ?
ಅದನ್ನೆಲ್ಲ ಮುಂದಿನ ಬರಹದಲ್ಲಿ ತಿಳಿಸುತ್ತೇನೆ. ಆದರೆ, ಸದ್ಯಕ್ಕೆ ಇಶ್ಟು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಿ. ನನ್ನಿಯಂಕೆ(real number)ಗಳನ್ನು ಎಣಿ(computer)ಯಲ್ಲಿ ಉಳಿಸಿ ಇಟ್ಟುಕೊಳ್ಳುವ ಒಂದು ಮಾರಾಳುತನ (representation) ಇದು. ಗಿರಕು ಚುಕ್ಕಿಯ ಮಾರಾಳುತನ(fixed point representation)ವೂ ಇದೆ. ಆದರೆ ಇದು ಹೆಚ್ಚು ಕಟ್ಟುನಿಟ್ಟಾ(precise)ಗಿದ್ದರೂ ತುಂಬಾ ಎಡೆ(space) ಹಿಡಿಸುತ್ತದೆ. ಹಾಗಾಗಿ ಈ ಮಾರಾಳುತನ(representation)ವನ್ನು ಈಗಿನ ಎಣಿಗಳು ಬಳಸುವುದಿಲ್ಲ. ತೇಲುವ ಚುಕ್ಕಿಯ ಮಾರಾಳುತನವನ್ನೇ ಬಳಸುತ್ತವೆ.

ಸಿ ನುಡಿಯಲ್ಲಿ ಮೂರು ಬಗೆಯ ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆಗಳು ಇವೆ: float, double, long double. floatಗಿಂತ double ಅಂಕೆಯ ಕಟ್ಟುನಿಟ್ಟುತನ (precision) ಇಮ್ಮಡಿ. ಅದಕ್ಕೂ ಹೆಚ್ಚಿನ ಕಟ್ಟುನಿಟ್ಟುತನ ಅಂದರೆ long doubleದು. ಇವುಗಳ ಹರವು(range) ಎಷ್ಟು, ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟುತನ ಎಷ್ಟು ಅಂತ ಮುಂದೆ ಹೇಳುತ್ತೇನೆ.

ಹಾಗಿದ್ದರೆ ನಮ್ಮ ಹಿಂದಿನ ಹಮ್ಮಿ(program)ನಲ್ಲಿ int ಬದಲಾಗಿ ಈ ಯಾವುದಾದರೂ ತೇಲುವ ಚುಕ್ಕಿಯ ಅಂಕೆಯನ್ನು ಬಳಸಬಹುದು. float ಅನ್ನು ಬಳಸಿ ನೋಡೋಣ.

#include<stdio.h>


main() {
   float km;
   int mile;
   scanf("%d",&mile);
   km = 1.61 * mile;
   printf("%f",km);
}

ಒಟ್ಟಿಸಿ (compile), ಎಸಗಿ(execute) ಪಳಿ(output)ಯನ್ನು ನೋಡೋಣ:

$ ./a.out
2
3.220000

$ ./a.out
5
8.050000

ಉತ್ತರಗಳು ಈಗ ಸರಿಯಾಗಿವೆ!

ಹಳ್ಳಿ ದಾರಿಯಲ್ಲಿ.....

ಮೈಲಿಗಲ್ಲುಗಳು, ಬೋರ್ಡುಗಳು ಇಲ್ಲದೆ ಇರೋ ಹಳ್ಳಿದಾರಿಯಲ್ಲಿ ಯಾವತ್ತಾದರೂ ಗಾಡಿ ಓಡಿಸ್ಕೊಂಡು ಹೋಗಿದ್ದೀರ? ಅಂತಹ ದಾರಿಯಲ್ಲಿ ಅಲ್ಲಲ್ಲಿ ದಾರಿಯ ಬದಿಯಲ್ಲಿ ಸಿಗೋ ಹಳ್ಳಿಯವರೇ ನಮಗೆ ಮೈಲಿಗಲ್ಲುಗಳು, ಬೋರ್ಡುಗಳು ಎಲ್ಲ. ಆದರೆ ತೊಂದರೆ ಏನು ಅಂದರೆ, ಆ ಮೈಲಿಗಲ್ಲುಗಳು ಕೊಡೋ ಮಾಹಿತಿ ತಲೆನಾ ಮೊಸರುಗಡಿಗೆ ಮಾಡದೇ ಇರಲ್ಲ. "ಸ್ಟ್ರೇಟ್ ವೋಯ್ತಾ ಇರಿ ಸಾರ್, ಇನ್ನು ೮ ಮೈಲಿ ಅಶ್ಟೆ" ಅಂತ ಒಬ್ಬನ ಹತ್ತಿರ ಕೇಳಿ ಇನ್ನೂ ೧೨ ಕಿ.ಮೀ ಬಂದ ಮೇಲೆ ಇನ್ನೇನ್ ನಾವ್ ಹೋಗ್ತಾ ಇರೋ ಊರು ಬಂದೇ ಬಿಡ್ತು (೧ ಮೈಲಿ = ೧.೬೧ ಕಿ.ಮೀ, ೮*೧.೬೧ = ೧೨.೮೮) ಅಂತ ಇನ್ನೊಬ್ಬ ಯಾರೋ ಬದಿಯಲ್ಲಿ ಸಿಕ್ಕಿದ ಅಂತ ಕೇಳಿದ್ರೆ "ಏ, ಇನ್ನೇನ್ ಊರ್ ಬಂತ್ರಿ; ಇಲ್ಲಿಂದ ೫ ಕಿಲೋಮೀಟ್ರು ಅಶ್ಟೆ. ಬೇಕಿದ್ರೆ ಈ ಕಡೆ ಎಡಕ್ ತಿರ್ಕೊಂಡ್ ಓಗ್ಬುಡಿ, ಸ್ಯಾನೆ ಅತ್ರ ಆಯ್ತದೆ". ಇದೇನ್ ಈ ಹಯ್ದ ಹೀಗಂದನಲ್ಲ ಅಂತ ತಲೆ ಕೆಡಿಸ್ಕೊಂಡು ಬೇಗ ಹೋಗೋಣ ಅಂತ ಅವನು ತೋರಿಕೊಟ್ಟ short cut ತೊಗೊಂಡರೆ ಸಿಗೋದು ಗಾಡಿನೇ ಓಡಿಸೋದಕ್ಕೆ ಆಗದೆ ಇರೋ ಅಂತಹ ಬರಿ ಕಲ್ಲು-ಮಣ್ಣುಗಳ ದಾರಿ. ಅಲ್ಲಿ ಒದ್ದಾಡಿಕೊಂಡು ಅರೆ ಗಂಟೆಯಲ್ಲಿ ೨ ಕಿ.ಮೀ ಓಡಿಸಿ ಇನ್ನೊಬ್ಬ ಯಾರೋ ಸಿಕ್ದ ಅಂತ ಅವನನ್ನ ದಾರಿ ಕೇಳೋದಕ್ಕೆ ಹೋದ್ರೆ ಮತ್ತೆ ತಲೆಯನ್ನ ಮೊಸರಗಡಿಗೆ ಮಾಡೋ ಉತ್ತರಾನೇ ಸಿಗೋದು.

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

#include<stdio.h>

main() {

   int km, mile;

   scanf("%d",&mile);

   km = 1.61 * mile;

   printf("%d",km);

}

ಈ ಹಮ್ಮನ್ನು ಒಟ್ಟಿಸಿ(compile), ಎಸಗಿ ನೋಡೋಣ:

$ ./a.out
2
3 $


$ ./a.out
5
8 $

೨*೧.೬೧=೩.೨೨
೫*೧.೬೧=೮.೦೫
ಆದ್ರೆ ಈ ಹಾಳಾದ್ದು ತಪ್ಪು ಉತ್ತರ ಕೊಡ್ತಿದ್ಯಲ್ಲ? ನಮ್ಮ ಹಳ್ಳಿಯವರ ಬುದ್ದಿ ನಮ್ ಹಮ್ಮಿಗೂ ಅಂಟಿಕೊಂಡಿತು ಅಂತ ಅಂದ್ಕೊಂಡ್ರಾ? ಸರಿಯಾಗಿ ಗಮನಿಸಿ ನೋಡಿ. ಇದು ಕೊಡುತ್ತಿರುವ ಪಳಿ(output)ಯಲ್ಲಿ ಹದಿ-ಚುಕ್ಕೆ (decimal point) ಮತ್ತು ಅದರ ಬಳಿಕ ಬರುವ ಅಂಕಿಗಳು ಮಾಯವಾಗಿದ್ದು ಹದಿ-ಚುಕ್ಕೆಯ ಮೊದಲು ಬರುವ ಅಂಕೆ ಸರಿಯಾಗಿಯೇ ಇದೆ. ನಮ್ಮ ಹಮ್ಮನ್ನು ಒಮ್ಮೆ ನೋಡಿದರೆ ಗೊತ್ತಾಗುತ್ತೆ, ನಾವು ಮೈಲಿಯ ಬೆಲೆಯನ್ನು ಪಡೆಯುವ ಮಾರ್ಪಡಬಲ್ಲ(variable)ವನ್ನು ತುಂಬಂಕೆ(int)ಯಾಗಿ ಸಾರಿದ್ದೇವೆ(declared). ಅಂಕೆಯಲ್ಲಿ ಚುಕ್ಕೆ ಬಂದರೆ ಅದು ತುಂಬಂಕೆಯಲ್ಲವಲ್ಲ, ಅದಕ್ಕೆ ಪಳಿ(output)ಯಲ್ಲಿ ಸರಿ-ಉತ್ತರದ ತುಂಬಂಕೆಯ ಪಾಲು ಮಾತ್ರ ಬಂದಿದ್ದು, ಚುಕ್ಕೆ ಮತ್ತು ಅದರ ಬಳಿಕ ಬರುವ ಅಂಕೆಗಳು ಮಾಯವಾಗಿವೆ.

ಮುಂದಿನ ಬರಹದಲ್ಲಿ ಇದನ್ನು ಸರಿಪಡಿಸುವುದು ಹೇಗೆ ಅಂತ ನೋಡೋಣ.

ಸಿ ಕೀಲಿಪದಗಳು

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 ಬಗ್ಗೆ ಆಗಲೇ ಹೇಳಿದ್ದೇನೆ. ಮುಂದಿನ ಬರಹಗಳಲ್ಲಿ ಹೊಸ ಕೀಲಿಪದ ಬಳಸಿದಾಗಲೆಲ್ಲ ಅದರ ಹುರುಳನ್ನೂ, ಕುರಿ(ಉದ್ದೇಶ)ಯನ್ನೂ ಹೇಳುತ್ತೇನೆ.

ಸಿ ಹಮ್ಮುಗೆ ೩

ಹಿಂದಿನ ಬರಹದಲ್ಲಿ ಒಂದು ಹೆದೆ (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)ವನ್ನು ಮುಕ್ತಾಯ ಮಾಡೋಣ.

}