Variables जोड़ना
मान सहेजें और फिर प्राप्त करें।
Variables जोड़ना, CoddyKit पर C Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह C Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। C Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
अंकगणित से आगे
x = 5 और बाद में x + 1 का समर्थन करने के लिए इंटरप्रेटर को पहचानकर्ताओं और उनके मान संग्रहीत करने की जगह चाहिए। इस संग्रह को एनवायरनमेंट कहते हैं।
हम नामों और असाइनमेंट को संभालने के लिए लेक्सर, पार्सर और मूल्यांकक का विस्तार करेंगे।
पहचानकर्ताओं का लेक्सिंग
पहचानकर्ता किसी अक्षर या अंडरस्कोर से शुरू होता है और उसके बाद अक्षर, अंक या अंडरस्कोर आ सकते हैं। हम नाम की प्रतिलिपि टोकन में रखते हैं।
निश्चित आकार का बफ़र उदाहरण को सरल रखता है; वास्तविक लेक्सर नामों को इंटर्न करते हैं।
#include <ctype.h>
#include <string.h>
typedef struct { TokKind kind; int value; char name[32]; } Token;
static Token lex_ident(void) {
Token t; t.kind = TOK_IDENT; int i = 0;
while (isalnum((unsigned char)peek()) || peek() == '_')
if (i < 31) t.name[i++] = advance(); else advance();
t.name[i] = '\0';
return t;
}एक चर नोड
AST में दो नोड प्रकार जुड़ते हैं: चर संदर्भ और असाइनमेंट। दोनों चर का नाम संग्रहीत करते हैं।
असाइनमेंट उस अभिव्यक्ति को भी रखता है जिसका मान वह संग्रहीत करता है।
typedef struct Node {
enum { N_NUM, N_BINOP, N_VAR, N_ASSIGN } kind;
int value; char op; char name[32];
struct Node *left, *right; /* assign uses right as value expr */
} Node;एनवायरनमेंट
एनवायरनमेंट नामों को मानों से जोड़ता है। छोटे इंटरप्रेटर के लिए नाम/मान युग्मों वाली सरल रैखिक सारणी पर्याप्त है।
बड़ी भाषाएँ O(1) खोज और नेस्टेड स्कोप के लिए हैश तालिकाओं का उपयोग करती हैं।
#define MAX_VARS 64
typedef struct {
char names[MAX_VARS][32];
int values[MAX_VARS];
int count;
} Env;
static Env env; /* global for this tiny example */चर का मान निर्धारित करना
असाइन करने पर या तो मौजूदा स्थान का मान बदला जाता है या नया स्थान जोड़ा जाता है। रैखिक खोज कोड को छोटा रखती है।
संग्रहीत मान लौटाने से असाइनमेंट को y = (x = 3) जैसे अभिव्यक्ति के रूप में उपयोग किया जा सकता है।
#include <string.h>
static int env_set(const char *name, int v) {
for (int i = 0; i < env.count; i++)
if (strcmp(env.names[i], name) == 0) {
env.values[i] = v; return v;
}
strcpy(env.names[env.count], name);
env.values[env.count] = v;
env.count++;
return v;
}चर पढ़ना
खोज नाम ढूँढ़कर उसका मान लौटाती है। अपरिभाषित चर का संदर्भ लेना रनटाइम त्रुटि है।
यहीं इसे पकड़ने पर कचरा मान लौटाने के बजाय स्पष्ट संदेश मिलता है।
#include <stdio.h>
#include <stdlib.h>
static int env_get(const char *name) {
for (int i = 0; i < env.count; i++)
if (strcmp(env.names[i], name) == 0)
return env.values[i];
fprintf(stderr, "undefined variable: %s\n", name);
exit(1);
}असाइनमेंट का पार्सिंग
असाइनमेंट की प्राथमिकता सबसे कम होती है और यह दाएँ-सहचारी होता है। हम एक फैक्टर पार्स करते हैं; यदि वह अकेला पहचानकर्ता हो और उसके बाद = हो, तो हम assign node बनाते हैं।
अन्यथा पहचानकर्ता केवल चर-पठन होता है।
static Node *parse_assign(void) {
if (cur().kind == TOK_IDENT) {
char saved[32]; strcpy(saved, cur().name);
bump();
if (cur().kind == TOK_ASSIGN) {
bump();
Node *val = parse_assign();
return assign_node(saved, val);
}
return var_node(saved); /* not an assignment */
}
return parse_expr();
}चरों का मूल्यांकन
मूल्यांकक में दो स्थितियाँ जुड़ती हैं। चर नोड एनवायरनमेंट में अपना नाम खोजता है; assign node अपने मान वाली अभिव्यक्ति का मूल्यांकन करके उसे संग्रहीत करता है।
दोनों env_get और env_set सहायकों का फिर से उपयोग करते हैं।
int eval(Node *n) {
switch (n->kind) {
case N_NUM: return n->value;
case N_VAR: return env_get(n->name);
case N_ASSIGN: return env_set(n->name, eval(n->right));
case N_BINOP: {
int l = eval(n->left), r = eval(n->right);
switch (n->op) {
case '+': return l + r; case '-': return l - r;
case '*': return l * r; case '/': return l / r;
}
}
}
return 0;
}एक कार्यशील REPL चरण
यह प्रोग्राम एक चर संग्रहीत करता है और फिर उसे किसी अभिव्यक्ति में दोबारा पढ़ता है—सब कुछ एनवायरनमेंट के माध्यम से। यह वास्तविक इंटरप्रेटर की एक पंक्ति का मॉडल है।
इसे चलाकर देखें कि असाइनमेंट और खोज साथ मिलकर कैसे काम करते हैं।
#include <stdio.h>
#include <string.h>
#define MAX_VARS 64
static char names[MAX_VARS][32];
static int values[MAX_VARS];
static int count;
static int env_set(const char *n,int v){
for(int i=0;i<count;i++) if(!strcmp(names[i],n)){values[i]=v;return v;}
strcpy(names[count],n); values[count]=v; count++; return v;
}
static int env_get(const char *n){
for(int i=0;i<count;i++) if(!strcmp(names[i],n)) return values[i];
return 0;
}
int main(void){
env_set("x", 5); /* x = 5 */
int r = env_get("x") + 1; /* x + 1 */
printf("x = %d\n", env_get("x"));
printf("x + 1 = %d\n", r);
return 0;
}स्कोप और छाया-आवरण
एकल समतल एनवायरनमेंट वैश्विक होता है। वास्तविक भाषाएँ नेस्टेड स्कोप जोड़ती हैं, ताकि किसी फ़ंक्शन के स्थानीय नाम बाहरी नामों को न बदल दें।
इसे आप एनवायरनमेंट को श्रृंखलाबद्ध करके लागू करते हैं: खोज सबसे अंदरूनी स्कोप से बाहर की ओर चलती है।
typedef struct Env {
char names[MAX_VARS][32];
int values[MAX_VARS];
int count;
struct Env *parent; /* enclosing scope */
} Env;आगे की दिशा
चर जुड़ जाने के बाद आप कथन, सशर्त शाखाएँ और फ़ंक्शन जोड़ सकते हैं। हर चीज़ एक नया नोड प्रकार और eval की एक स्थिति होती है।
यहाँ से वही लेक्सर-पार्सर-मूल्यांकक पाइपलाइन बढ़कर एक वास्तविक छोटी भाषा बन सकती है।
त्वरित जाँच
सोचिए कि एनवायरनमेंट की ज़िम्मेदारी क्या है।
पुनरावलोकन
आपने लेक्सर में पहचानकर्ता, AST में var/assign नोड, set और get वाला एनवायरनमेंट, तथा पठन और असाइनमेंट के लिए eval स्थितियाँ जोड़ीं।
अब इंटरप्रेटर स्थिति याद रखता है—कथनों और फ़ंक्शन की नींव तैयार है।
एआई शिक्षक के साथ C सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 144
अक्सर पूछे जाने वाले प्रश्न
क्या “Variables जोड़ना” पाठ निःशुल्क है?
हाँ—“Variables जोड़ना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और C Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। C Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Variables जोड़ना” में मैं क्या सीखूँगा?
मान सहेजें और फिर प्राप्त करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ C Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या C Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर C Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।
“Variables जोड़ना” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस C Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर C Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Input को Token में बाँटना
- Expressions का Parsing
- Tree का मूल्यांकन
- Variables जोड़ना