"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {ComparisonTable, Definition, English, Explanation, Hinglish, HowItWorks, ImportantQA, MCQ, SubTopicHeader, Summary, TypesOf} = _components; if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!Definition) _missingMdxReference("Definition", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!HowItWorks) _missingMdxReference("HowItWorks", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Summary) _missingMdxReference("Summary", true); if (!TypesOf) _missingMdxReference("TypesOf", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "1.3", title: "C Tokens: Keywords, Variables & Constants" }), "\n", _jsxs(Definition, { term: "C Token", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "C Token" }), " is the smallest individual unit in a C program that is meaningful to the compiler. Tokens are classified into keywords, identifiers, constants, strings, special symbols, and operators."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "C Token" }), " kisi C program ki sabse choti individual unit hoti hai jisse compiler program blocks identify karta hai. Tokens keywords, identifiers, constants, strings, special symbols, aur operators mein divided hote hain."] }) })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Classification of C Tokens" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Keywords:" }), " Reserved words that have pre-defined meanings in the compiler (e.g., ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "return" }), "). C has 32 standard keywords."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identifiers:" }), " User-defined names given to variables, functions, or arrays (e.g., ", _jsx(_components.code, { children: "sum" }), ", ", _jsx(_components.code, { children: "temp_value" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constants:" }), " Fixed values that do not change during program execution (e.g., ", _jsx(_components.code, { children: "100" }), ", ", _jsx(_components.code, { children: "3.14" }), ", ", _jsx(_components.code, { children: "'A'" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operators:" }), " Symbols that perform operations on variables and values (e.g., ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ")."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C Tokens ka Classification" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Keywords:" }), " Reserved words jinka meaning compiler mein pehle se fixed hota hai (jaise ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "return" }), ", ", _jsx(_components.code, { children: "while" }), "). C mein total 32 keywords hote hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identifiers:" }), " Programming Variables, functions ya arrays ke user-defined names (jaise ", _jsx(_components.code, { children: "totalScore" }), ", ", _jsx(_components.code, { children: "num1" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constants:" }), " Aise fixed values jo program chalne ke dauran badalti nahi hain (jaise ", _jsx(_components.code, { children: "10" }), ", ", _jsx(_components.code, { children: "9.8" }), ", ", _jsx(_components.code, { children: "'b'" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operators:" }), " Symbols jo values aur variables par operations chalate hain (jaise ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "&&" }), ", ", _jsx(_components.code, { children: "<" }), ")."] }), "\n"] })] }), _jsx(TypesOf, { types: [{ "name": "Keywords", "description": "32 reserved words like int, switch, default. They must always be in lowercase and cannot be reused as variables." }, { "name": "Identifiers (Variable names)", "description": "Must begin with a letter or underscore (_). Cannot contain spaces or special symbols except underscore. Case-sensitive." }, { "name": "Constants", "description": "Declared either using the 'const' keyword (e.g., const float PI = 3.14;) or the '#define' preprocessor macro (e.g., #define PI 3.14)." }] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "Primary Data Types in C" }), _jsx(_components.p, { children: "Data types specify the type of data that a variable can store and the amount of memory allocated to it:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Character (char):" }), " Stores a single character. Size: 1 byte. Range: -128 to 127."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Integer (int):" }), " Stores whole numbers. Size: 2 bytes or 4 bytes (depends on compiler). Range: -32768 to 32767 (for 16-bit)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Floating Point (float):" }), " Stores decimal numbers. Size: 4 bytes. Range: ", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "1.2" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "E" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "−" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "38" })] })] }) }), " to ", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "3.4" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "E" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "38" })] })] }) }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Double Precision Float (double):" }), " Stores larger fractional numbers. Size: 8 bytes. Range: ", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "2.3" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "E" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "−" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "308" })] })] }) }), " to ", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "1.7" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "E" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "308" })] })] }) }), "."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C ke Primary Data Types" }), _jsx(_components.p, { children: "Data types yeh batate hain ki variable mein kis tarah ka data store hoga aur use kitni memory milegi:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Character (char):" }), " Ek single letter store karne ke liye. Size: 1 byte. Range: -128 to 127."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Integer (int):" }), " Bina decimal wale complete numbers store karne ke liye. Size: 2 ya 4 bytes. Range (16-bit): -32768 to 32767."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Floating Point (float):" }), " Point/decimal numbers store karne ke liye. Size: 4 bytes."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Double (double):" }), " Badi decimal values store karne ke liye. Size: 8 bytes."] }), "\n"] })] }), _jsx(ComparisonTable, { children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Data Type" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Keyword" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Size (16-bit)" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Size (32/64-bit)" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Format Specifier" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Character" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "char" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "1 Byte" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "1 Byte" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "%c" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Integer" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "int" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "2 Bytes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "4 Bytes" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "%d" }), " or ", _jsx(_components.code, { children: "%i" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Float" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "float" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "4 Bytes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "4 Bytes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "%f" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Double" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "double" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "8 Bytes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "8 Bytes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "%lf" }) })] })] })] }) }), _jsxs(HowItWorks, { title: "Defining Variables and Constants", children: [_jsxs(English, { children: [_jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n#define GRAVITY 9.8 // Preprocessor Constant (no memory allocated)\n\nint main() {\n int age = 18; // Integer Variable\n const float PI = 3.14159; // Constant Variable (Read-only memory)\n char grade = 'A'; // Character Variable\n\n printf(\"Age: %d, Grade: %c, PI: %f, Gravity: %f\\n\", age, grade, PI, GRAVITY);\n return 0;\n}\n" }) }), _jsxs(_components.p, { children: ["Variables like ", _jsx(_components.code, { children: "age" }), " can be updated later. Constants like ", _jsx(_components.code, { children: "PI" }), " and ", _jsx(_components.code, { children: "GRAVITY" }), " cannot be modified; trying to write ", _jsx(_components.code, { children: "PI = 3.0;" }), " will result in a compilation error."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n#define GRAVITY 9.8 // Preprocessor Constant (No memory allocation)\n\nint main() {\n int age = 18; // Integer Variable\n const float PI = 3.14159; // Read-only Constant variable\n char grade = 'A'; // Character Variable\n\n printf(\"Age: %d, Grade: %c, PI: %f, Gravity: %f\\n\", age, grade, PI, GRAVITY);\n return 0;\n}\n" }) }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "age" }), " jaise variables ko badla ja sakta hai. Par ", _jsx(_components.code, { children: "PI" }), " aur ", _jsx(_components.code, { children: "GRAVITY" }), " ko update karne par program compile time error dega, jaise ", _jsx(_components.code, { children: "PI = 3.0;" }), " valid nahi hai."] })] })] })] }), "\n", _jsxs(Summary, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Tokens are C program building blocks: keywords, identifiers, constants, operators." }), "\n", _jsx(_components.li, { children: "Variable names must follow identifier rules (no space, start with letter/_)." }), "\n", _jsxs(_components.li, { children: ["C constants are defined using ", _jsx(_components.code, { children: "const" }), " keyword or ", _jsx(_components.code, { children: "#define" }), " macro."] }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Tokens programs ke smallest units hain: keywords, identifiers, constants aur operators." }), "\n", _jsx(_components.li, { children: "Variable name ke rules fixed hain (no space, starts with letter ya underscore)." }), "\n", _jsxs(_components.li, { children: ["Constants banane ke do tarike hain: ", _jsx(_components.code, { children: "const" }), " keyword ya ", _jsx(_components.code, { children: "#define" }), " macro."] }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "What are C Tokens? List different types of C tokens. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "A **C Token** is the smallest individual unit in a program. The compiler groups characters into tokens to build syntax structures.\n\n**Types of C Tokens:**\n1. **Keywords:** e.g., `int`, `float`, `return`.\n2. **Identifiers:** User-defined variable/function names like `age`, `calculate_sum()`.\n3. **Constants:** Fixed values like `10`, `3.14`.\n4. **Strings:** Sequence of characters like `\"hello\"`.\n5. **Operators:** Mathematical or logical symbols like `+`, `&&`.\n6. **Special Symbols:** Punctuations like `;`, `{`, `[`.C program ki sabse choti meaningful unit ko **C Token** kehte hain.\n\n**Types of C Tokens:**\n1. **Keywords:** Predefined words jaise `int`, `void`.\n2. **Identifiers:** Custom variable ya function names jaise `x`, `findArea`.\n3. **Constants:** Fixed integers/floats jaise `15`, `9.8`.\n4. **Strings:** Text messages jaise `\"Welcome\"`.\n5. **Operators:** Symbols jaise `*`, `||`.\n6. **Special Symbols:** Brackets aur punctuation marks jaise `;`, `,`, `{`." }] } }, { "q": "State rules for declaring variables in C. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "Rules for declaring variable names (Identifiers):\n1. Must begin with a letter (A-Z, a-z) or an underscore (`_`).\n2. Cannot start with a digit.\n3. Can contain letters, digits, and underscores; no special characters allowed (e.g., $, @, %).\n4. Cannot use keywords as variable names.\n5. White spaces are not allowed inside names.\n6. Variable names are case-sensitive (`age` and `AGE` are different).Variable declare karne ke rules:\n1. Variable name hamesha letter (a-z, A-Z) ya underscore (`_`) se shuru hona chahiye.\n2. Pehla character number nahi ho sakta.\n3. Variable name mein digits, letters aur underscore use kar sakte hain; koi special characters ($, @, %) allowed nahi hain.\n4. Standard Keywords ko variable ki tarah use nahi kar sakte.\n5. Name ke beech mein blank space allowed nahi hai.\n6. Variables case-sensitive hote hain (`temp` aur `TEMP` do alag variables hain)." }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "1e4509c3-0286-4cda-a44b-93d52837ceff", "q": "Which of the following is NOT a valid C variable name?", "options": ["sum_1", "_value", "1_value", "value_1"], "answer": 2, "hint": "A variable name cannot start with a digit.", "explanation": "Variable names (identifiers) must start with a letter or underscore, not a number." }, { "id": "a588da33-704a-4bb8-aacc-793e8a6a785f", "q": "How many keywords are there in the standard C language?", "options": ["32", "48", "64", "50"], "answer": 0, "hint": "It is a power of 2.", "explanation": "C standard (ANSI C) defines exactly 32 reserved keywords." }, { "id": "f1d99d03-a8fa-418f-b37d-a16ea808233d", "q": "What is the size of a 'char' data type in C?", "options": ["1 byte", "2 bytes", "4 bytes", "8 bytes"], "answer": 0, "hint": "Characters take the minimum amount of memory among basic types.", "explanation": "A char variable always occupies 1 byte (8 bits) of memory." }, { "id": "8b91f96c-f2f9-4d17-8174-ef49a4468d02", "q": "Which keyword is used to declare a variable whose value cannot be changed during program execution?", "options": ["static", "const", "volatile", "extern"], "answer": 1, "hint": "Short for constant.", "explanation": "The 'const' keyword makes a variable read-only and immutable." }, { "id": "9568527f-fbdf-453c-8a47-b4274a76a445", "q": "Which of the following data types takes 8 bytes of memory in C?", "options": ["int", "float", "double", "char"], "answer": 2, "hint": "It is double the size of float.", "explanation": "A double precision floating point type takes 8 bytes of memory." }, { "id": "c7a5bc88-6a01-4c6a-b885-5732526a387f", "q": "Which of the following is a preprocessor directive used to define symbolic constants?", "options": ["const", "#define", "#include", "#constant"], "answer": 1, "hint": "Starts with a '#' and replaces values before compilation.", "explanation": "'#define' creates macros that are replaced textually by the preprocessor." }, { "id": "32f34957-ac9b-46bf-80cb-bfab57a252f7", "q": "What is the range of a signed 1-byte character in C?", "options": ["0 to 255", "-128 to 127", "-32768 to 32767", "-2147483648 to 2147483647"], "answer": 1, "hint": "It covers negative numbers up to 127 positive.", "explanation": "A signed char uses 8 bits, yielding a range from -128 to 127." }, { "id": "ec5fb5c4-1251-4efe-baf5-403863a950d0", "q": "Can a C keyword be used as a variable identifier?", "options": ["Yes, always", "No, never", "Yes, if we add an underscore at the end", "Only in global declarations"], "answer": 1, "hint": "Keywords have strict predefined meanings for the compiler.", "explanation": "Keywords are reserved words and can never be used as identifiers (variable or function names)." }, { "id": "0cfa272d-0af8-4507-be1f-71de040016c1", "q": "What is the difference between a variable declared with 'const' and a constant defined with '#define'?", "options": ["const constants have types and occupy memory; #define constants do not", "#define constants have types; const constants do not", "There is no difference at all", "const can be changed; #define cannot"], "answer": 0, "hint": "Think about compiler type checking and preprocessor text replacement.", "explanation": "'const' variables are checked by the compiler for types and have scope, whereas '#define' constants are simple text replacements." }, { "id": "0ac19ef8-a2fe-4d60-a5c2-14222d34cabe", "q": "What happens if a variable is declared but not initialized in C (for automatic local storage)?", "options": ["It gets a default value of 0", "It contains garbage value", "It causes a compilation error", "It terminates the program immediately"], "answer": 1, "hint": "Local variables take whatever values are currently in their allocated stack space.", "explanation": "Automatic local variables in C are not initialized automatically and contain unpredictable 'garbage' values." }], topicId: "1.3" })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }