सी प्रोग्रामिंग का परिचय

सी प्रोग्रामिंग भाषा का विकास 1969 से 1973 के मध्य एटी एंड टी बेल लैबोरेटरीज (AT&T Bell Laboratories) में कंप्यूटर वैज्ञानिक डेनिस रिची (Dennis Ritchie) द्वारा किया गया था। इसका प्राथमिक उद्देश्य यूनिक्स (Unix) ऑपरेटिंग सिस्टम के कर्नल को पुन: लिखना था, जो उस समय हार्डवेयर-विशिष्ट असेंबली भाषा में था। सी भाषा ने यूनिक्स को पोर्टेबल (अन्य कंप्यूटरों पर आसानी से चलने योग्य) बना दिया।

सी भाषा का विकास निम्नलिखित ऐतिहासिक अनुक्रम से हुआ:

• ALGOL 60 (1960): ब्लॉक-संरचित प्रोग्रामिंग और औपचारिक व्याकरण का सूत्रपात।
• CPL (Combined Programming Language, 1963): अत्यंत शक्तिशाली किंतु कंपाइलर निर्माण में अत्यधिक जटिल भाषा।
• BCPL (Basic Combined Programming Language, 1967): कैम्ब्रिज के मार्टिन रिचर्ड्स द्वारा विकसित सरल और टाइप-रहित भाषा।
• B भाषा (1969): बेल लैब्स में केन थॉम्पसन द्वारा यूनिक्स के प्रारंभिक विकास हेतु निर्मित सरल भाषा।
• C भाषा (1972): डेनिस रिची ने B भाषा में डेटा प्रकार (Data Types), संरचनाएं और पॉइंटर्स जोड़कर आधुनिक सी भाषा की रचना की।
• ANSI C (C89/C90): 1989 में अमेरिकन नेशनल स्टैंडर्ड्स इंस्टीट्यूट द्वारा सी का वैश्विक मानक निर्धारित किया गया।

एक सुव्यवस्थित सी प्रोग्राम में मुख्य रूप से छह अनुभाग होते हैं:

1. दस्तावेज़ीकरण अनुभाग (Documentation Section): प्रोग्राम के उद्देश्य, लेखक और नियमों से संबंधित टिप्पणियां (Comments)। सी में बहु-पंक्ति टिप्पणी (`/* टिप्पणी */`) और C99 एकल-पंक्ति टिप्पणी (`// टिप्पणी`) मान्य हैं। कंपाइलर प्रीप्रोसेसिंग के दौरान टिप्पणियों को हटा देता है।
2. लिंक अनुभाग (प्रीप्रोसेसर निर्देश): हेडर फ़ाइलों को शामिल करने के निर्देश (`#include <stdio.h>`, `#include <math.h>`), जो मानक लाइब्रेरी फ़ंक्शंस के प्रोटोटाइप प्रदान करते हैं।
3. परिभाषा अनुभाग (Definition Section): `#define` निर्देश द्वारा प्रतीकात्मक स्थिरांक घोषित करना (`#define PI 3.14159`)।
4. ग्लोबल घोषणा अनुभाग: सभी फ़ंक्शंस में प्रयुक्त होने वाले ग्लोबल चरों और यूज़र-डिफ़ाइंड फ़ंक्शंस के प्रोटोटाइप की घोषणा।
5. मुख्य फ़ंक्शन अनुभाग (`main()`): प्रत्येक सी प्रोग्राम का अनिवार्य प्रवेश द्वार (Entry Point)। प्रोग्राम का निष्पादन सदैव `main()` से ही प्रारंभ होता है। आधुनिक ANSI C में इसे `int main(void)` घोषित कर अंत में ऑपरेटिंग सिस्टम को सफलता का संकेत देने हेतु `return 0;` लिखा जाता है।
6. उप-प्रोग्राम अनुभाग (यूज़र-डिफ़ाइंड फ़ंक्शंस): प्रोग्राम की कार्यप्रणाली को मॉड्यूलर बनाने हेतु `main()` के बाहर परिभाषित किए गए अन्य स्वतंत्र फ़ंक्शंस।

सी भाषा में मानव द्वारा लिखे गए स्रोत कोड को कंप्यूटर द्वारा निष्पादन योग्य मशीन कोड में बदलने के लिए पांच सुव्यवस्थित चरण होते हैं:

जब ऑपरेटिंग सिस्टम किसी सी प्रोग्राम को रैम में निष्पादित करता है, तो उसकी मेमोरी को पांच विशिष्ट सेगमेंट्स में विभाजित किया जाता है:

• 1. टेक्स्ट सेगमेंट (Text / Code Segment): सबसे निचले मेमोरी पते पर स्थित होता है। इसमें प्रोग्राम के कंपाइल किए गए मशीन निर्देश होते हैं। कोड में दुर्घटनावश बदलाव रोकने हेतु यह केवल-पठनीय (Read-Only) होता है।
• 2. इनिशियलाइज़्ड डेटा सेगमेंट (Data Segment): प्रोग्राम में घोषित वे सभी ग्लोबल और स्टैटिक चर जिनका प्रारंभिक मान पहले से तय होता है (उदा. `int count = 10; static float rate = 5.5;`)।
• 3. अन-इनिशियलाइज़्ड डेटा सेगमेंट (BSS Segment): "Block Started by Symbol" का संक्षिप्त रूप। वे सभी ग्लोबल और स्टैटिक चर जिन्हें कोई प्रारंभिक मान नहीं दिया जाता (उदा. `int arr[100];`)। प्रोग्राम लोड होते ही ओएस इसे स्वचालित रूप से शून्य (`0`) से भर देता है।
• 4. हीप सेगमेंट (Heap Segment): रनटाइम पर डायनामिक मेमोरी आवंटन (`malloc()`, `calloc()`) के लिए प्रयुक्त होता है। यह BSS के ऊपर से उच्च मेमोरी पते की ओर (ऊपर) बढ़ता है।
• 5. स्टैक सेगमेंट (Stack Segment): सबसे उच्च मेमोरी पते से प्रारंभ होकर निम्न मेमोरी पते की ओर (नीचे) बढ़ता है। इसमें स्थानीय चर, फ़ंक्शन पैरामीटर और एक्टिवेशन रिकॉर्ड्स (LIFO क्रम में) संग्रहीत होते हैं।

सी भाषा में कोड लिखने हेतु स्वीकृत बुनियादी वर्ण समूह निम्नलिखित हैं:

• वर्णमाला: अंग्रेजी वर्णमाला के बड़े अक्षर `A`–`Z` और छोटे अक्षर `a`–`z` (सी भाषा केस-संवेदनशील है)।
• अंक: दशमलव अंक `0` से `9` तक (कुल 10 अंक)।
• विशेष प्रतीक: `+ - * / % = < > ! & | ^ ~ . , ; : ? ' " ( ) [ ] { } _ # \`।
• रिक्त स्थान वर्ण: स्पेस बार, क्षैतिज टैब (` `), न्यूलाइन (` `), कैरिज रिटर्न (` `)।

एक सी प्रोग्राम की सबसे छोटी अविभाज्य एवं अर्थपूर्ण इकाई को टोकन कहा जाता है। लेक्सिकल विश्लेषण के दौरान कंपाइलर स्रोत कोड को टोकन्स की धारा में विभाजित करता है। सी टोकन्स 6 प्रकार के होते हैं:

1. कीवर्ड्स (Keywords): पूर्वनिर्धारित आरक्षित शब्द जिनका अर्थ स्थिर और निश्चित होता है।
2. पहचानकर्ता (Identifiers): चरों, फ़ंक्शंस या सरणियों (Arrays) को दिया गया उपयोगकर्ता-परिभाषित नाम।
3. स्थिरांक (Constants / Literals): वे मान जो प्रोग्राम निष्पादन के दौरान कभी नहीं बदलते।
4. स्ट्रिंग्स (Strings): दोहरे उद्धरण चिह्नों (`" "`) में बंद अक्षरों का समूह, जो नल वर्ण (`'\0'`) पर समाप्त होता है।
5. ऑपरेटर्स (Operators): गणितीय, संबंधपरक या तार्किक कार्य करने वाले विशेष प्रतीक।
6. विशेष प्रतीक (Special Symbols / Punctuators): कोष्ठक `( )`, बड़े कोष्ठक `[ ]`, मंझले कोष्ठक `{ }`, अल्पविराम `,`, अर्धविराम `;` आदि।

ANSI C (C89) मानक में कुल 32 कीवर्ड्स आरक्षित हैं। इन्हें सदैव छोटे अक्षरों (lowercase) में लिखा जाता है और इन्हें पहचानकर्ता के रूप में उपयोग करना पूर्णतः वर्जित है:

• मान्य वर्ण: केवल अक्षर (`A-Z`, `a-z`), अंक (`0-9`) और अंडरस्कोर (`_`) मान्य हैं।
• प्रथम वर्ण का नियम: नाम सदैव किसी अक्षर या अंडरस्कोर से ही प्रारंभ होना चाहिए; अंक से प्रारंभ नहीं हो सकता (उदा. `1num` अवैध है; `num1` या `_count` वैध हैं)।
• केस संवेदनशीलता: बड़े और छोटे अक्षरों का अलग अर्थ होता है; जैसे `total`, `Total` और `TOTAL` तीन अलग-अलग चर हैं।
• वर्जित तत्व: कोई रिक्त स्थान (Space), विराम चिह्न या विशेष प्रतीक (`@`, `$`, `#`, `-`) और 32 आरक्षित कीवर्ड्स का नाम के रूप में उपयोग नहीं किया जा सकता।
• महत्वपूर्ण लंबाई: मानक सी में पहचानकर्ता के प्रथम 31 वर्ण विशिष्ट माने जाते हैं।

• पूर्णांक स्थिरांक: दशमलव (`45`), अष्टक (प्रारंभ में `0`, जैसे `075` = $61_{10}$), षोडश आधारी (प्रारंभ में `0x`, जैसे `0x2A` = $42_{10}$)।
• फ्लोटिंग-पॉइंट स्थिरांक: दशमलव भिन्न (`3.1415`) या वैज्ञानिक घातांक संकेतन (`1.5e-3` = $1.5 imes 10^{-3}$)।
• वर्ण स्थिरांक (Character Constant): एकल उद्धरण चिह्नों में बंद एक अकेला वर्ण (`'A'`, `'9'`)। मेमोरी में इसका ASCII पूर्णांक मान (जैसे `'A'` का 65) जमा होता है। यह 1 बाइट लेता है।
• एस्केप सीक्वेंस: बैकस्लैश (`\`) से प्रारंभ होने वाले गैर-मुद्रण योग्य वर्ण: `\n` (नई पंक्ति), `\t` (टैब), `\0` (नल वर्ण), `\\` (बैकस्लैश), `\'` और `\"`।
• स्ट्रिंग स्थिरांक: दोहरे उद्धरण चिह्नों में बंद वर्णों की श्रृंखला (`"Hello"`), जिसके अंत में कंपाइलर स्वचालित रूप से नल वर्ण `'\0'` जोड़ता है। अतः `"A"` मेमोरी में 2 बाइट्स लेता है (`'A'` और `'\0'`), जबकि `'A'` लेता है 1 बाइट।

• `const`: चर को केवल-पठनीय (Read-Only) बनाता है; प्रोग्राम में इसका मान बदलने का प्रयास करने पर कंपाइलर एरर देता है (`const float PI = 3.14;`)।
• `volatile`: कंपाइलर को सूचित करता है कि इस चर का मान बाहरी हार्डवेयर या इंटरप्ट द्वारा कभी भी बदल सकता है, अतः इसे सीपीयू रजिस्टर में कैश करने के बजाय हर बार सीधे रैम से पढ़ा जाए।

सी भाषा में स्टोरेज क्लास चर के चार प्रमुख लक्षणों को नियंत्रित करती है: मेमोरी स्थान, डिफ़ॉल्ट मान, कार्यक्षेत्र (Scope) और जीवनकाल (Lifetime):

महत्वपूर्ण तकनीकी बिंदु:

• `register` चर सीधे सीपीयू में स्थित होने के कारण इस पर एड्रेस-ऑफ़ ऑपरेटर `&` का प्रयोग नहीं किया जा सकता (`&reg_var` कंपाइल एरर देता है)।
• फ़ंक्शन के अंदर घोषित `static` स्थानीय चर फ़ंक्शन समाप्त होने के बाद भी अपना मान बनाए रखता है और पूरे प्रोग्राम में केवल एक बार इनिशियलाइज़ होता है।

`<stdio.h>` हेडर फ़ाइल में घोषित `printf()` फ़ंक्शन स्क्रीन पर फॉर्मेटेड टेक्स्ट प्रदर्शित करता है:

int printf(const char *format, ...);

रिटर्न मान: यह स्क्रीन पर सफलतापूर्वक मुद्रित कुल वर्णों की संख्या रिटर्न करता है।

फॉर्मेट विनिर्देशक संरचना: `%[flags][width][.precision]type`

• फ़ील्ड विड्थ (Width): न्यूनतम कितने कॉलम में मान छपेगा (जैसे `%6d` से `42` छापने पर आगे 4 स्पेस जोड़कर `____42` बनेगा)।
• परिशुद्धता (.precision): दशमलव के बाद अंकों की संख्या (जैसे `%.2f` से `3.14159` बन जाता है `3.14`)। स्ट्रिंग हेतु अधिकतम वर्ण सीमा।
• फ्लैग्स: `-` (बायाँ संरेखण / Left Align), `0` (स्पेस के स्थान पर शून्य भरना), `+` (धनात्मक चिन्ह का स्पष्ट प्रदर्शन)।

कीबोर्ड से डेटा इनपुट लेने हेतु `scanf()` का उपयोग किया जाता है:

int scanf(const char *format, ...);

एड्रेस-ऑफ़ ऑपरेटर (&) की अनिवार्यता: सी फ़ंक्शंस में मान प्रतिलिपि (Call by Value) के रूप में पास होते हैं। `scanf` इनपुट किए गए मान को सीधे कॉलर चर के मेमोरी स्थान पर लिख सके, इसके लिए चर के नाम के पूर्व मेमोरी एड्रेस ऑपरेटर `&` (जैसे `&num`) लगाना अनिवार्य है।

स्ट्रिंग ऐरे का अपवाद: सी भाषा में ऐरे का नाम स्वयं उसके प्रथम तत्व के मेमोरी पॉइंटर को दर्शाता है, अतः स्ट्रिंग इनपुट में `&` नहीं लगाया जाता (`scanf("%s", str)` पर्याप्त है)।

• `getchar()`: इनपुट से एक अकेला वर्ण पढ़कर उसका ASCII पूर्णांक मान रिटर्न करता है।
• `putchar(c)`: स्क्रीन पर एक वर्ण प्रदर्शित करता है।
• `gets()` का गंभीर खतरा एवं बफ़र ओवरफ़्लो: `gets()` फ़ंक्शन इनपुट की लंबाई की जांच किए बिना ऐरे में डेटा भरता है। क्षमता से अधिक डेटा देने पर यह स्टैक फ्रेम को नष्ट कर देता है (Buffer Overflow)। अतः आधुनिक C11 मानक में इसे पूर्णतः हटा दिया गया है।
• सुरक्षित `fgets()`: बफ़र सीमा तय करके सुरक्षित इनपुट लेने का मानक फ़ंक्शन: `fgets(str, sizeof(str), stdin)`।
• `puts(str)`: स्ट्रिंग प्रदर्शित कर अंत में स्वचालित रूप से नई पंक्ति (`\n`) बनाता है।

1. अंकगणितीय ऑपरेटर्स: जोड़ (`+`), घटाव (`-`), गुणा (`*`), भाग (`/`), और मापांक या शेषफल (`%`)। ध्यान रहे कि `%` ऑपरेटर के दोनों ऑपरेंड्स का पूर्णांक होना अनिवार्य है; फ्लोट संख्याओं में `%` लगाने से कंपाइल एरर आता है।
2. संबंधपरक (Relational) ऑपरेटर्स: सत्य होने पर `1` तथा असत्य होने पर `0` देते हैं: `==`, `!=`, `<`, `<=`, `>`, `>=`।
3. तार्किक (Logical) ऑपरेटर्स: शॉर्ट-सर्किट विधि से हल होते हैं: `&&` (AND), `||` (OR), `!` (NOT)।
4. बिटवाइज़ ऑपरेटर्स: बाइनरी बिट स्तर पर संक्रिया करते हैं: बिटवाइज़ AND (`&`), OR (`|`), XOR (`^`), वन्स कॉम्प्लिमेंट (`~`), लेफ्ट शिफ्ट (`<<`, मान को $2^k$ से गुणा), राइट शिफ्ट (`>>`, मान को $2^k$ से भाग)।
5. असाइनमेंट ऑपरेटर्स: सरल आवंटन (`=`) एवं संयुक्त रूप: `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=` (दाएँ से बाएँ हल होते हैं)।
6. इंक्रीमेंट / डिक्रीमेंट: प्री-इंक्रीमेंट (`++x`, पहले बढ़ता है फिर उपयोग होता है), पोस्ट-इंक्रीमेंट (`x++`, पहले उपयोग होता है फिर बढ़ता है)।
7. कंडीशनल (टर्नरी) ऑपरेटर: `शर्त ? सत्य_मान : असत्य_मान`। तीन ऑपरेंड्स वाला एकमात्र ऑपरेटर।
8. विशेष ऑपरेटर्स: `sizeof` (बाइट आकार निकालना), कॉमा ऑपरेटर `,` (बाएँ से दाएँ चलकर सबसे दायाँ मान देना)।

• अंतर्निहित रूपांतरण (Implicit Promotion / Coercion): मिश्रित प्रकार के व्यंजकों में कंपाइलर स्वचालित रूप से छोटे डेटा प्रकार को बड़े प्रकार में बदल देता है (जैसे `5 / 2.0` में पूर्णांक `5` बदलकर `5.0` हो जाता है और परिणाम `2.5` आता है)।
• प्रत्यक्ष टाइपकास्टिंग (Explicit Casting): प्रोग्रामर द्वारा जबरन डेटा प्रकार बदलना: `(type) expression`। जैसे `(float)15 / 4` लिखने से दशमलव परिणाम `3.75` प्राप्त होता है, अन्यथा पूर्णांक भाग से केवल `3` आता।