"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", h4: "h4", hr: "hr", 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 }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, FormulaBox, Hinglish, HowItWorks, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview, TypesOf, Warning} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!FormulaBox) _missingMdxReference("FormulaBox", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!HowItWorks) _missingMdxReference("HowItWorks", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); if (!TypesOf) _missingMdxReference("TypesOf", true); if (!Warning) _missingMdxReference("Warning", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "1.3", title: "Fundamental Constructs of 'C': Character Set, Tokens, Keywords, Identifiers, Constants, Variables & Data Types" }), _jsx(English, { children: _jsx(TopicOverview, { title: "Fundamental Constructs of 'C' Programming", topicId: "1.3", readingTime: "10 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["Every programming language has its own vocabulary and grammar — just like English has letters, words, and sentences. In C, the building blocks start from the ", _jsx(_components.strong, { children: "character set" }), " (the allowed symbols), which combine to form ", _jsx(_components.strong, { children: "tokens" }), " — the smallest meaningful units. Tokens include ", _jsx(_components.strong, { children: "keywords" }), " (reserved words like ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "return" }), "), ", _jsx(_components.strong, { children: "identifiers" }), " (names you create for variables and functions), and ", _jsx(_components.strong, { children: "constants" }), " (fixed values). On top of these, C provides different ", _jsx(_components.strong, { children: "data types" }), " to specify what kind of data a variable holds — integers, characters, floating-point numbers, and more. Understanding these fundamental constructs is essential because every single C program you will ever write is built from these pieces. This subtopic lays the foundation for everything that follows."] }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "C Programming Ki Fundamental Constructs", topicId: "1.3", readingTime: "10 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["Har programming language ki apni vocabulary aur grammar hoti hai — bilkul jaise English mein letters, words aur sentences hote hain. C mein, building blocks ", _jsx(_components.strong, { children: "character set" }), " se start hote hain (jo allowed symbols hain), jo milke ", _jsx(_components.strong, { children: "tokens" }), " banate hain — jo sabse chhoti meaningful units hoti hain. Tokens mein ", _jsx(_components.strong, { children: "keywords" }), " (reserved words jaise ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "return" }), "), ", _jsx(_components.strong, { children: "identifiers" }), " (jo naam aap variables aur functions ke liye khud banate ho), aur ", _jsx(_components.strong, { children: "constants" }), " (fixed values) aate hain. Inke upar, C mein alag-alag ", _jsx(_components.strong, { children: "data types" }), " diye gaye hain jo batate hain ki variable kaunsa data hold karega — integers, characters, floating-point numbers, aur bahut kuch. In fundamental constructs ko samajhna bahut zaroori hai kyunki jo bhi C program aap likhoge, wo sab in pieces se banta hai. Yeh subtopic aage sab kuch ke liye foundation rakhta hai."] }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Character Set", children: _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "character set" }), " is the complete collection of valid characters that the C language recognizes. It includes uppercase letters (A-Z), lowercase letters (a-z), digits (0-9), special characters (+, -, *, /, =, etc.), and whitespace characters (space, tab, newline). Think of it as the alphabet and symbols that C understands — if a character is not in this set, the compiler will not recognize it."] }) }), _jsx(DefinitionEntry, { term: "Token", children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "token" }), " is the smallest individual meaningful unit in a C program that the compiler can identify. When you write code, the compiler breaks it down into tokens — like breaking a sentence into words. There are six types of tokens in C: keywords, identifiers, constants, string literals, operators, and special symbols."] }) }), _jsx(DefinitionEntry, { term: "Keyword", children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Keywords" }), " are reserved words in C that already have a predefined meaning to the compiler. You cannot use them as variable names or identifiers. Examples include ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "else" }), ", ", _jsx(_components.code, { children: "return" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "for" }), ". They are the \"fixed vocabulary\" of the C language — think of them as words that C has already claimed for itself."] }) }), _jsx(DefinitionEntry, { term: "Identifier", children: _jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "identifier" }), " is a user-defined name given to a variable, function, array, or any user-created entity in a C program. For example, in ", _jsx(_components.code, { children: "int age = 25;" }), ", ", _jsx(_components.code, { children: "age" }), " is an identifier. Identifiers must start with a letter or underscore, cannot be a keyword, and are case-sensitive (", _jsx(_components.code, { children: "age" }), " and ", _jsx(_components.code, { children: "Age" }), " are different identifiers)."] }) }), _jsx(DefinitionEntry, { term: "Constant", children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "constant" }), " is a fixed value that cannot be changed during program execution. Once you define ", _jsx(_components.code, { children: "#define PI 3.14" }), ", the value ", _jsx(_components.code, { children: "3.14" }), " is a constant — no statement in your program can modify it. Constants come in types: number constants (like ", _jsx(_components.code, { children: "42" }), ", ", _jsx(_components.code, { children: "3.14" }), "), character constants (like ", _jsx(_components.code, { children: "'A'" }), "), and string constants (like ", _jsx(_components.code, { children: "\"Hello\"" }), ")."] }) }), _jsx(DefinitionEntry, { term: "Variable", children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "variable" }), " is a named storage location in memory whose value can change during program execution. When you write ", _jsx(_components.code, { children: "int count = 0;" }), ", you are creating a variable called ", _jsx(_components.code, { children: "count" }), " that holds an integer value. Variables are like labeled boxes — the label is the name, the box is the memory space, and the content is the value."] }) }), _jsx(DefinitionEntry, { term: "Data Type", children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "data type" }), " specifies what kind of value a variable can store and how much memory it occupies. C provides fundamental data types like ", _jsx(_components.code, { children: "int" }), " (integers), ", _jsx(_components.code, { children: "char" }), " (characters), ", _jsx(_components.code, { children: "float" }), " (single-precision decimals), and ", _jsx(_components.code, { children: "double" }), " (double-precision decimals). Choosing the right data type ensures efficient memory use and correct calculations."] }) }), _jsx(DefinitionEntry, { term: "Type Conversion", children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Type conversion" }), " is the process of converting a value from one data type to another. It happens in two ways: ", _jsx(_components.strong, { children: "implicit" }), " (automatic, done by the compiler when mixing types) and ", _jsx(_components.strong, { children: "explicit" }), " (manual, done by the programmer using a type cast like ", _jsx(_components.code, { children: "(float)x" }), "). Understanding type conversion is critical because mismatched types can lead to unexpected results and bugs."] }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🔤 Character Set in C" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "character set" }), " defines all the valid characters that can be used in a C program. C uses the ", _jsx(_components.strong, { children: "ASCII" }), " (American Standard Code for Information Interchange) character set, which maps every character to a numeric value. The character set includes:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Letters:" }), " A–Z (uppercase), a–z (lowercase)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Digits:" }), " 0–9"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Special Characters:" }), " ", _jsx(_components.code, { children: "+" }), " ", _jsx(_components.code, { children: "-" }), " ", _jsx(_components.code, { children: "*" }), " ", _jsx(_components.code, { children: "/" }), " ", _jsx(_components.code, { children: "=" }), " ", _jsx(_components.code, { children: "<" }), " ", _jsx(_components.code, { children: ">" }), " ", _jsx(_components.code, { children: "%" }), " ", _jsx(_components.code, { children: "#" }), " ", _jsx(_components.code, { children: "&" }), " ", _jsx(_components.code, { children: "|" }), " ", _jsx(_components.code, { children: "!" }), " ", _jsx(_components.code, { children: "~" }), " ", _jsx(_components.code, { children: "^" }), " ", _jsx(_components.code, { children: ";" }), " ", _jsx(_components.code, { children: "," }), " ", _jsx(_components.code, { children: "." }), " ", _jsx(_components.code, { children: ":" }), " ", _jsx(_components.code, { children: "?" }), " ", _jsx(_components.code, { children: "'" }), " ", _jsx(_components.code, { children: "\"" }), " ", _jsx(_components.code, { children: "(" }), " ", _jsx(_components.code, { children: ")" }), " ", _jsx(_components.code, { children: "[" }), " ] ", _jsx(_components.code, { children: "{" }), " ", _jsx(_components.code, { children: "}" }), " ", _jsx(_components.code, { children: "_" }), " ", _jsx(_components.code, { children: "\\" }), " ", _jsx(_components.code, { children: "$" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Whitespace Characters:" }), " space (", _jsx(_components.code, { children: " " }), "), horizontal tab (", _jsx(_components.code, { children: "\\t" }), "), newline (", _jsx(_components.code, { children: "\\n" }), "), carriage return (", _jsx(_components.code, { children: "\\r" }), "), form feed (", _jsx(_components.code, { children: "\\f" }), "), vertical tab (", _jsx(_components.code, { children: "\\v" }), ")"] }), "\n"] }), _jsxs(_components.p, { children: ["Each character has an ASCII value. For example, ", _jsx(_components.code, { children: "'A'" }), " = 65, ", _jsx(_components.code, { children: "'a'" }), " = 97, ", _jsx(_components.code, { children: "'0'" }), " = 48. These values become important when you work with character manipulation in C."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔤 C Mein Character Set" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Character set" }), " define karta hai ki C program mein kaun-kaun se valid characters use ho sakte hain. C ", _jsx(_components.strong, { children: "ASCII" }), " (American Standard Code for Information Interchange) character set use karta hai, jo har character ko ek numeric value deta hai. Character set mein yeh sab aate hain:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Letters:" }), " A–Z (uppercase), a–z (lowercase)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Digits:" }), " 0–9"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Special Characters:" }), " ", _jsx(_components.code, { children: "+" }), " ", _jsx(_components.code, { children: "-" }), " ", _jsx(_components.code, { children: "*" }), " ", _jsx(_components.code, { children: "/" }), " ", _jsx(_components.code, { children: "=" }), " ", _jsx(_components.code, { children: "<" }), " ", _jsx(_components.code, { children: ">" }), " ", _jsx(_components.code, { children: "%" }), " ", _jsx(_components.code, { children: "#" }), " ", _jsx(_components.code, { children: "&" }), " ", _jsx(_components.code, { children: "|" }), " ", _jsx(_components.code, { children: "!" }), " ", _jsx(_components.code, { children: "~" }), " ", _jsx(_components.code, { children: "^" }), " ", _jsx(_components.code, { children: ";" }), " ", _jsx(_components.code, { children: "," }), " ", _jsx(_components.code, { children: "." }), " ", _jsx(_components.code, { children: ":" }), " ", _jsx(_components.code, { children: "?" }), " ", _jsx(_components.code, { children: "'" }), " ", _jsx(_components.code, { children: "\"" }), " ", _jsx(_components.code, { children: "(" }), " ", _jsx(_components.code, { children: ")" }), " ", _jsx(_components.code, { children: "[" }), " ] ", _jsx(_components.code, { children: "{" }), " ", _jsx(_components.code, { children: "}" }), " ", _jsx(_components.code, { children: "_" }), " ", _jsx(_components.code, { children: "\\" }), " ", _jsx(_components.code, { children: "$" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Whitespace Characters:" }), " space (", _jsx(_components.code, { children: " " }), "), horizontal tab (", _jsx(_components.code, { children: "\\t" }), "), newline (", _jsx(_components.code, { children: "\\n" }), "), carriage return (", _jsx(_components.code, { children: "\\r" }), "), form feed (", _jsx(_components.code, { children: "\\f" }), "), vertical tab (", _jsx(_components.code, { children: "\\v" }), ")"] }), "\n"] }), _jsxs(_components.p, { children: ["Har character ki apni ASCII value hoti hai. Jaise, ", _jsx(_components.code, { children: "'A'" }), " = 65, ", _jsx(_components.code, { children: "'a'" }), " = 97, ", _jsx(_components.code, { children: "'0'" }), " = 48. Yeh values tab important ho jaati hain jab aap C mein character manipulation karte ho."] })] }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// Printing ASCII values of characters\r\nprintf(\"ASCII of 'A' = %d\\n\", 'A'); // Output: 65\r\nprintf(\"ASCII of 'a' = %d\\n\", 'a'); // Output: 97\r\nprintf(\"ASCII of '0' = %d\\n\", '0'); // Output: 48\r\nprintf(\"ASCII of '@' = %d\\n\", '@'); // Output: 64\r\nreturn 0;\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🧩 Tokens in C — The Building Blocks" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Tokens" }), " are the smallest meaningful units in a C program. The compiler scans your source code and breaks it into tokens. There are ", _jsx(_components.strong, { children: "six types of tokens" }), " in C:"] }), _jsx(TypesOf, { title: "Types of Tokens in C", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Keywords" }), " — Reserved words with predefined meanings (", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "return" }), ", etc.)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identifiers" }), " — User-defined names for variables, functions, etc."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constants" }), " — Fixed values that don't change (", _jsx(_components.code, { children: "42" }), ", ", _jsx(_components.code, { children: "'A'" }), ", ", _jsx(_components.code, { children: "\"Hello\"" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "String Literals" }), " — Text enclosed in double quotes (", _jsx(_components.code, { children: "\"Hello World\"" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operators" }), " — Symbols that perform operations (", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "=" }), ", ", _jsx(_components.code, { children: "==" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Special Symbols" }), " — Punctuation and delimiters (", _jsx(_components.code, { children: ";" }), ", ", _jsx(_components.code, { children: "{" }), ", ", _jsx(_components.code, { children: "}" }), ", ", _jsx(_components.code, { children: "(" }), ", ", _jsx(_components.code, { children: ")" }), ", ", _jsx(_components.code, { children: "," }), ")"] }), "\n"] }) }), _jsx(_components.p, { children: "Consider this line of code:" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "int result = a + b * 10;\n" }) }), _jsxs(_components.p, { children: ["Here, the tokens are: ", _jsx(_components.code, { children: "int" }), " (keyword), ", _jsx(_components.code, { children: "result" }), " (identifier), ", _jsx(_components.code, { children: "=" }), " (operator), ", _jsx(_components.code, { children: "a" }), " (identifier), ", _jsx(_components.code, { children: "+" }), " (operator), ", _jsx(_components.code, { children: "b" }), " (identifier), ", _jsx(_components.code, { children: "*" }), " (operator), ", _jsx(_components.code, { children: "10" }), " (constant), ", _jsx(_components.code, { children: ";" }), " (special symbol). So this single line has ", _jsx(_components.strong, { children: "9 tokens" }), "."] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔑 Keywords in C" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Keywords" }), " are words that C has reserved for its own use. They have special meanings to the compiler and ", _jsx(_components.strong, { children: "cannot be used as identifiers" }), " (variable names, function names, etc.). C has ", _jsx(_components.strong, { children: "32 standard keywords" }), " (as per ANSI C):"] }), _jsx(TypesOf, { title: "C Keywords (32 ANSI Keywords)", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Data Types:" }), " ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "char" }), ", ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "double" }), ", ", _jsx(_components.code, { children: "void" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Type Modifiers:" }), " ", _jsx(_components.code, { children: "short" }), ", ", _jsx(_components.code, { children: "long" }), ", ", _jsx(_components.code, { children: "signed" }), ", ", _jsx(_components.code, { children: "unsigned" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Storage Class:" }), " ", _jsx(_components.code, { children: "auto" }), ", ", _jsx(_components.code, { children: "register" }), ", ", _jsx(_components.code, { children: "static" }), ", ", _jsx(_components.code, { children: "extern" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Control Flow:" }), " ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "else" }), ", ", _jsx(_components.code, { children: "switch" }), ", ", _jsx(_components.code, { children: "case" }), ", ", _jsx(_components.code, { children: "default" }), ", ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "do" }), ", ", _jsx(_components.code, { children: "break" }), ", ", _jsx(_components.code, { children: "continue" }), ", ", _jsx(_components.code, { children: "goto" }), ", ", _jsx(_components.code, { children: "return" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Structure & Union:" }), " ", _jsx(_components.code, { children: "struct" }), ", ", _jsx(_components.code, { children: "union" }), ", ", _jsx(_components.code, { children: "enum" }), ", ", _jsx(_components.code, { children: "typedef" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Other:" }), " ", _jsx(_components.code, { children: "const" }), ", ", _jsx(_components.code, { children: "sizeof" }), ", ", _jsx(_components.code, { children: "volatile" })] }), "\n"] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["All keywords in C are ", _jsx(_components.strong, { children: "lowercase" }), ". ", _jsx(_components.code, { children: "int" }), " is a keyword, but ", _jsx(_components.code, { children: "INT" }), " or ", _jsx(_components.code, { children: "Int" }), " are not — they are treated as identifiers. This is why C is called a ", _jsx(_components.strong, { children: "case-sensitive" }), " language."] }) }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`// Valid use of keywords\r\nint age = 20; // 'int' is a keyword\r\nfloat pi = 3.14; // 'float' is a keyword"] }), _jsxs(_components.p, { children: ["// INVALID — using keyword as identifier\r\n// int int = 10; // ERROR! 'int' cannot be a variable name\r\n// float return = 5; // ERROR! 'return' cannot be a variable name\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🏷️ Identifiers in C" }), _jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "identifier" }), " is any name you create in C for a variable, function, array, or any user-defined entity. C has specific rules that all identifiers must follow:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Rules for Naming Identifiers:" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["Can contain letters (a–z, A–Z), digits (0–9), and underscores (", _jsx(_components.code, { children: "_" }), ")"] }), "\n", _jsxs(_components.li, { children: ["Must begin with a letter or underscore — ", _jsx(_components.strong, { children: "never with a digit" })] }), "\n", _jsxs(_components.li, { children: ["Cannot be a keyword (like ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "return" }), ")"] }), "\n", _jsxs(_components.li, { children: ["Are ", _jsx(_components.strong, { children: "case-sensitive" }), " — ", _jsx(_components.code, { children: "count" }), ", ", _jsx(_components.code, { children: "Count" }), ", and ", _jsx(_components.code, { children: "COUNT" }), " are three different identifiers"] }), "\n", _jsx(_components.li, { children: "No limit on length (but first 31 characters are guaranteed to be significant)" }), "\n", _jsxs(_components.li, { children: ["No special characters like ", _jsx(_components.code, { children: "@" }), ", ", _jsx(_components.code, { children: "#" }), ", ", _jsx(_components.code, { children: "$" }), ", ", _jsx(_components.code, { children: "%" }), " are allowed"] }), "\n"] }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`// ✅ Valid Identifiers\r\nint age;\r\nfloat _salary;\r\nchar studentName[50];\r\nint totalMarks;"] }), _jsxs(_components.p, { children: ["// ❌ Invalid Identifiers\r\n// int 2age; // ERROR — starts with a digit\r\n// int my-age; // ERROR — contains hyphen (not underscore)\r\n// int int; // ERROR — 'int' is a keyword\r\n// int my age; // ERROR — contains space\r\n// float @price; // ERROR — contains special character @\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔢 Constants in C" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Constants" }), " are values that remain fixed throughout the program's execution. C provides three main types of constants:"] }), _jsx(_components.h4, { children: "1. Number Constants" }), _jsx(_components.p, { children: "Number constants are of two sub-types:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Integer Constants:" }), " Whole numbers without any decimal point. They can be decimal (base 10), octal (base 8, prefixed with ", _jsx(_components.code, { children: "0" }), "), or hexadecimal (base 16, prefixed with ", _jsx(_components.code, { children: "0x" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Real (Floating-Point) Constants:" }), " Numbers with a decimal point or in scientific notation. They always contain at least one digit and a decimal point."] }), "\n"] }), _jsx(_components.h4, { children: "2. Character Constants" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "character constant" }), " is a single character enclosed in ", _jsx(_components.strong, { children: "single quotes" }), ". Its value is the ASCII numeric value of that character. For example, ", _jsx(_components.code, { children: "'A'" }), " has the value 65, ", _jsx(_components.code, { children: "'0'" }), " has the value 48."] }), _jsx(_components.h4, { children: "3. String Constants" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "string constant" }), " is a sequence of characters enclosed in ", _jsx(_components.strong, { children: "double quotes" }), ". Even a single character in double quotes becomes a string constant — ", _jsx(_components.code, { children: "'A'" }), " is a character constant, but ", _jsx(_components.code, { children: "\"A\"" }), " is a string constant. An empty string ", _jsx(_components.code, { children: "\"\"" }), " is also valid."] }), _jsx(TypesOf, { title: "Constants in C", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Integer Constants:" }), " ", _jsx(_components.code, { children: "10" }), ", ", _jsx(_components.code, { children: "-25" }), ", ", _jsx(_components.code, { children: "0" }), ", ", _jsx(_components.code, { children: "077" }), " (octal), ", _jsx(_components.code, { children: "0x1A" }), " (hexadecimal)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Floating-Point Constants:" }), " ", _jsx(_components.code, { children: "3.14" }), ", ", _jsx(_components.code, { children: "-0.5" }), ", ", _jsx(_components.code, { children: "2.0" }), ", ", _jsx(_components.code, { children: "1.5e3" }), " (scientific notation)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Character Constants:" }), " ", _jsx(_components.code, { children: "'A'" }), ", ", _jsx(_components.code, { children: "'0'" }), ", ", _jsx(_components.code, { children: "'@'" }), ", ", _jsx(_components.code, { children: "'\\\\n'" }), " (escape sequence)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "String Constants:" }), " ", _jsx(_components.code, { children: "\"Hello\"" }), ", ", _jsx(_components.code, { children: "\"C Programming\"" }), ", ", _jsx(_components.code, { children: "\"A\"" }), ", ", _jsx(_components.code, { children: "\"\"" })] }), "\n"] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["Don't confuse ", _jsx(_components.code, { children: "'A'" }), " with ", _jsx(_components.code, { children: "\"A\"" }), ". The first is a ", _jsx(_components.strong, { children: "character constant" }), " (stores one byte, value 65) and the second is a ", _jsx(_components.strong, { children: "string constant" }), " (stores 'A' + null terminator ", _jsx(_components.code, { children: "\\0" }), ", takes 2 bytes in memory). This distinction is critical in C."] }) }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// Integer constants\r\nint decimal = 42;\r\nint octal = 052; // Octal representation of 42\r\nint hex = 0x2A; // Hexadecimal representation of 42"] }), _jsx(_components.p, { children: "// Floating-point constants\r\nfloat pi = 3.14;\r\ndouble big = 1.5e10; // Scientific notation: 1.5 * 10^10" }), _jsx(_components.p, { children: "// Character constant\r\nchar letter = 'A'; // ASCII value 65" }), _jsx(_components.p, { children: "// String constant\r\nchar greeting[] = \"Hello\";" }), _jsx(_components.p, { children: "printf(\"Decimal: %d\\n\", decimal); // 42\r\nprintf(\"Octal: %d\\n\", octal); // 42\r\nprintf(\"Hex: %d\\n\", hex); // 42\r\nprintf(\"Pi: %f\\n\", pi); // 3.140000\r\nprintf(\"Letter: %c\\n\", letter); // A\r\nprintf(\"Greeting: %s\\n\", greeting); // Hello" }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "📦 Variables in C" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "variable" }), " is a named memory location that stores data which can be changed during program execution. Variables are the \"containers\" in your program where you keep your data."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Key characteristics of variables:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Each variable has a ", _jsx(_components.strong, { children: "name" }), " (identifier), a ", _jsx(_components.strong, { children: "data type" }), ", and a ", _jsx(_components.strong, { children: "value" })] }), "\n", _jsx(_components.li, { children: "Memory is allocated based on the data type" }), "\n", _jsxs(_components.li, { children: ["The value can be changed using assignment (", _jsx(_components.code, { children: "=" }), ")"] }), "\n", _jsxs(_components.li, { children: ["All variables must be ", _jsx(_components.strong, { children: "declared" }), " before use"] }), "\n"] }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// Variable declaration and initialization\r\nint age = 20; // integer variable\r\nfloat marks = 85.5; // floating-point variable\r\nchar grade = 'A'; // character variable"] }), _jsx(_components.p, { children: "// Changing variable values\r\nage = 21; // age is now 21\r\nmarks = 90.0; // marks is now 90.0" }), _jsx(_components.p, { children: "printf(\"Age: %d\\n\", age);\r\nprintf(\"Marks: %.1f\\n\", marks);\r\nprintf(\"Grade: %c\\n\", grade);" }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "📊 Data Types in C" }), _jsx(_components.p, { children: "C provides several fundamental data types, each occupying a different amount of memory and storing different kinds of values:" }), _jsx(TypesOf, { title: "Fundamental Data Types in C", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "char" }) }), " — Stores a single character. Size: 1 byte. Range: -128 to 127 (signed) or 0 to 255 (unsigned)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "int" }) }), " — Stores integers (whole numbers). Size: typically 4 bytes. Range: approximately ±2.1 billion (signed)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "float" }) }), " — Stores single-precision floating-point (decimal) numbers. Size: 4 bytes. Precision: ~6–7 decimal digits"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "double" }) }), " — Stores double-precision floating-point numbers. Size: 8 bytes. Precision: ~15–16 decimal digits"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "void" }) }), " — Represents \"no value\" or \"no type.\" Used for functions that don't return anything"] }), "\n"] }) }), _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: "center" }, children: "Size (Bytes)" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Format Specifier" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Example Range" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "char" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "1" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%c" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "-128 to 127" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "unsigned char" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "1" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%c" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "0 to 255" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "short" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "2" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%hd" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "-32,768 to 32,767" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "int" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "4" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%d" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "-2,147,483,648 to 2,147,483,647" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "unsigned int" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "4" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%u" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "0 to 4,294,967,295" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "long" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "4 or 8" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%ld" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Depends on system" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "float" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "4" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%f" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "±3.4 × 10³⁸ (6–7 digit precision)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "double" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "8" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%lf" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "±1.7 × 10³⁰⁸ (15–16 digit precision)" })] })] })] }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>\r\n#include ", "<", "limits.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// Demonstrating data types and their sizes\r\nchar c = 'A';\r\nint i = 100;\r\nfloat f = 3.14f;\r\ndouble d = 2.71828;"] }), _jsx(_components.p, { children: "printf(\"char : %c | Size: %lu byte\\n\", c, sizeof(char));\r\nprintf(\"int : %d | Size: %lu bytes\\n\", i, sizeof(int));\r\nprintf(\"float : %.2f | Size: %lu bytes\\n\", f, sizeof(float));\r\nprintf(\"double : %.5f | Size: %lu bytes\\n\", d, sizeof(double));" }), _jsx(_components.p, { children: "// Using sizeof operator\r\nprintf(\"\\nTotal memory used by all variables: %lu bytes\\n\",\r\nsizeof(c) + sizeof(i) + sizeof(f) + sizeof(d));" }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "📝 Declaring Variables" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Variable declaration" }), " tells the compiler about the variable's name and data type. You can declare and initialize variables in several ways:"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "data_type variable_name;\r\ndata_type variable_name = initial_value;\r\ndata_type var1, var2, var3; // multiple declarations\n" }) }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// Method 1: Declaration only (value is undefined/garbage)\r\nint x;"] }), _jsx(_components.p, { children: "// Method 2: Declaration with initialization\r\nint y = 10;" }), _jsx(_components.p, { children: "// Method 3: Multiple declarations of same type\r\nint a, b, c;" }), _jsx(_components.p, { children: "// Method 4: Multiple declarations with initialization\r\nint p = 1, q = 2, r = 3;" }), _jsx(_components.p, { children: "// Method 5: Declaration at the point of use (C99 and later)\r\n// You can declare variables anywhere, not just at top" }), _jsx(_components.p, { children: "a = 5;\r\nb = 10;\r\nc = a + b;" }), _jsx(_components.p, { children: "printf(\"x = %d (garbage value)\\n\", x);\r\nprintf(\"y = %d\\n\", y);\r\nprintf(\"a = %d, b = %d, c = %d\\n\", a, b, c);\r\nprintf(\"p = %d, q = %d, r = %d\\n\", p, q, r);" }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["Uninitialized variables (like ", _jsx(_components.code, { children: "int x;" }), " without ", _jsx(_components.code, { children: "= value" }), ") contain ", _jsx(_components.strong, { children: "garbage values" }), " — random data left in that memory location. Always initialize variables before using them to avoid unpredictable behavior."] }) }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔄 Data Type Conversion (Type Casting)" }), _jsxs(_components.p, { children: ["When you mix different data types in an expression (e.g., adding an ", _jsx(_components.code, { children: "int" }), " and a ", _jsx(_components.code, { children: "float" }), "), C needs to convert one type to another. This happens in two ways:"] }), _jsx(_components.h4, { children: "1. Implicit Type Conversion (Automatic / Type Promotion)" }), _jsx(_components.p, { children: "The compiler automatically converts the \"smaller\" data type to the \"larger\" one to prevent data loss. The general hierarchy is:" }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "char → int → long → float → double → long double\n" }) }), _jsxs(_components.p, { children: ["This is called ", _jsx(_components.strong, { children: "type promotion" }), " — the smaller type is promoted to the larger type."] }), _jsx(_components.h4, { children: "2. Explicit Type Conversion (Type Casting)" }), _jsxs(_components.p, { children: ["The programmer manually converts a value from one type to another using the ", _jsx(_components.strong, { children: "cast operator" }), ":"] }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "(data_type) expression\n" }) }), _jsx(HowItWorks, { title: "How Type Conversion Works", children: _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "In expressions with mixed types, the compiler first checks the data types of all operands" }), "\n", _jsxs(_components.li, { children: ["The operand with the ", _jsx(_components.strong, { children: "smaller" }), " type is converted to the ", _jsx(_components.strong, { children: "larger" }), " type (implicit promotion)"] }), "\n", _jsx(_components.li, { children: "The operation is performed, and the result is of the larger type" }), "\n", _jsxs(_components.li, { children: ["For explicit casting, the programmer forces the conversion using ", _jsx(_components.code, { children: "(type)" }), " syntax before evaluation"] }), "\n", _jsxs(_components.li, { children: ["Be cautious: converting from a larger type to a smaller type can ", _jsx(_components.strong, { children: "truncate" }), " (cut off) data"] }), "\n"] }) }), _jsx(ComparisonTable, { title: "Implicit vs Explicit Type Conversion", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Feature" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Implicit Conversion" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Explicit Conversion" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Triggered by" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Compiler automatically" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Programmer manually" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Syntax" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "No special syntax needed" }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "(data_type) value" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Example" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "int x = 5; float y = x;" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "float y = (float) 5;" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Risk" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Generally safe (promotes to larger type)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Can cause data loss if not careful" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Also called" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Type promotion / Coercion" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Type casting" })] })] })] }) }), _jsxs(CodeBlock, { language: "java", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\n// =", _jsx("mark", { children: " IMPLICIT TYPE CONVERSION " }), "=\r\nint a = 5;\r\nint b = 2;\r\nfloat result1;"] }), _jsx(_components.p, { children: "// Integer division — both operands are int, so result is int\r\nprintf(\"5 / 2 = %d\\n\", a / b); // Output: 2 (not 2.5!)" }), _jsx(_components.p, { children: "// Implicit promotion: int automatically promoted to float\r\nresult1 = a / b; // Still integer division before assignment!\r\nprintf(\"(float)5 / 2 = %f\\n\", result1); // Output: 2.000000" }), _jsx(_components.p, { children: "// To get 2.5, we must promote one operand first\r\nfloat result2 = (float)a / b;\r\nprintf(\"(float)5 / 2 = %f\\n\", result2); // Output: 2.500000" }), _jsxs(_components.p, { children: ["// =", _jsx("mark", { children: " EXPLICIT TYPE CONVERSION (CASTING) " }), "=\r\nint x = 7;\r\nint y = 2;"] }), _jsx(_components.p, { children: "// Integer division\r\nprintf(\"7 / 2 = %d\\n\", x / y); // Output: 3" }), _jsx(_components.p, { children: "// Explicit cast — force float division\r\nfloat result3 = (float)x / y;\r\nprintf(\"(float)7 / 2 = %f\\n\", result3); // Output: 3.500000" }), _jsx(_components.p, { children: "// WARNING: Data loss with narrowing conversion\r\nfloat pi = 3.14159f;\r\nint truncated = (int)pi; // Fractional part is TRUNCATED\r\nprintf(\"(int)3.14159 = %d\\n\", truncated); // Output: 3" }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(FormulaBox, { title: "Type Promotion Hierarchy", children: [_jsx(_components.span, { className: "katex-display", children: _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.6944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "char" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "→" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6679em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "int" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "→" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8889em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "long" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "→" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "float" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "→" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "double" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "→" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8889em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "long double" }) })] })] }) }) }), _jsx(_components.p, { children: "The operand with the smaller type (left side) is automatically converted to the larger type (right side) before the operation is performed." })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "⚠️ Common Mistakes to Avoid" }), _jsxs(Warning, { children: [_jsxs(_components.p, { children: [_jsxs(_components.strong, { children: ["1. Confusing ", _jsx(_components.code, { children: "'A'" }), " and ", _jsx(_components.code, { children: "\"A\"" }), ":"] }), " ", _jsx(_components.code, { children: "'A'" }), " is a character constant (1 byte, value 65). ", _jsx(_components.code, { children: "\"A\"" }), " is a string constant (2 bytes: 'A' + '\\0'). They are fundamentally different in C."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "2. Using keywords as identifiers:" }), " Writing ", _jsx(_components.code, { children: "int int = 5;" }), " or ", _jsx(_components.code, { children: "float return = 3.14;" }), " will cause compilation errors. Always check that your variable names are not keywords."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "3. Uninitialized variables:" }), " Declaring ", _jsx(_components.code, { children: "int x;" }), " without assigning a value leaves ", _jsx(_components.code, { children: "x" }), " with a garbage value. Always initialize: ", _jsx(_components.code, { children: "int x = 0;" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "4. Integer division surprise:" }), " ", _jsx(_components.code, { children: "5 / 2" }), " gives ", _jsx(_components.code, { children: "2" }), ", not ", _jsx(_components.code, { children: "2.5" }), ", because both operands are integers. Use ", _jsx(_components.code, { children: "(float)5 / 2" }), " or ", _jsx(_components.code, { children: "5.0 / 2" }), " to get ", _jsx(_components.code, { children: "2.5" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "5. Ignoring data type ranges:" }), " Storing a value larger than what the data type can hold causes ", _jsx(_components.strong, { children: "overflow" }), ". For example, storing ", _jsx(_components.code, { children: "200" }), " in a ", _jsx(_components.code, { children: "signed char" }), " (range: -128 to 127) gives unexpected results."] })] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "📌 Key Points" }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "character set" }), " defines all valid characters in C, based on the ASCII standard"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Tokens" }), " are the smallest meaningful units in a C program — there are 6 types: keywords, identifiers, constants, string literals, operators, and special symbols"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Keywords" }), " (32 in ANSI C) are reserved words and cannot be used as identifiers"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identifiers" }), " are user-defined names that must start with a letter or underscore, and are case-sensitive"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constants" }), " are fixed values — number constants (integer/real), character constants (", _jsx(_components.code, { children: "'A'" }), "), and string constants (", _jsx(_components.code, { children: "\"Hello\"" }), ")"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Variables" }), " are named memory locations whose values can change; they must be declared before use"] }), "\n", _jsxs(_components.li, { children: ["C provides fundamental data types: ", _jsx(_components.code, { children: "char" }), " (1 byte), ", _jsx(_components.code, { children: "int" }), " (4 bytes), ", _jsx(_components.code, { children: "float" }), " (4 bytes), ", _jsx(_components.code, { children: "double" }), " (8 bytes)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Implicit conversion" }), " (type promotion) happens automatically; ", _jsx(_components.strong, { children: "explicit conversion" }), " uses the cast operator ", _jsx(_components.code, { children: "(type)" })] }), "\n", _jsx(_components.li, { children: "Mixing integer types in division can lead to unexpected truncation — always use type casting when needed" }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "sizeof" }), " operator tells you the size in bytes of any data type or variable"] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Explain the difference between keywords and identifiers in the C language." }), _jsx(Answer, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Keywords" }), " and ", _jsx(_components.strong, { children: "identifiers" }), " are both tokens in C, but they serve different purposes: ### 🎯 Keywords - ", _jsx(_components.strong, { children: "Definition:" }), " Keywords are ", _jsx(_components.strong, { children: "reserved words" }), " in C that have a predefined meaning to the compiler. - ", _jsx(_components.strong, { children: "Purpose:" }), " They are used to define the syntax and structure of the language. - ", _jsx(_components.strong, { children: "Examples:" }), " ", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "else" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "return" }), ". - ", _jsx(_components.strong, { children: "Rule:" }), " You ", _jsx(_components.strong, { children: "cannot" }), " use a keyword as a variable name. ### 📝 Identifiers - ", _jsx(_components.strong, { children: "Definition:" }), " Identifiers are names given by the programmer to various program elements like variables, functions, arrays, etc. - ", _jsx(_components.strong, { children: "Purpose:" }), " They are used to uniquely identify these elements in the code. - ", _jsx(_components.strong, { children: "Examples:" }), " ", _jsx(_components.code, { children: "main" }), ", ", _jsx(_components.code, { children: "count" }), ", ", _jsx(_components.code, { children: "student_name" }), ", ", _jsx(_components.code, { children: "calculateArea" }), ". - ", _jsx(_components.strong, { children: "Rule:" }), " Identifiers ", _jsx(_components.strong, { children: "must not" }), " be a keyword and must follow naming rules (e.g., start with a letter or underscore). Think of keywords as the 'vocabulary' of the C language, and identifiers as the 'names' you create for your own things."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Describe the types of constants in C and explain how they differ from variables." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["Constants are fixed values that do not change during program execution, while variables are named memory locations whose values can be changed. ### 🎯 Types of Constants 1. ", _jsx(_components.strong, { children: "Number Constants:" }), " - ", _jsx(_components.strong, { children: "Integer Constants:" }), " Whole numbers without decimals (e.g., ", _jsx(_components.code, { children: "10" }), ", ", _jsx(_components.code, { children: "-5" }), ", ", _jsx(_components.code, { children: "0" }), "). - ", _jsx(_components.strong, { children: "Floating-Point Constants:" }), " Numbers with decimal points (e.g., ", _jsx(_components.code, { children: "3.14" }), ", ", _jsx(_components.code, { children: "-0.05" }), "). 2. ", _jsx(_components.strong, { children: "Character Constants:" }), " - A single character enclosed in single quotes (e.g., ", _jsx(_components.code, { children: "'A'" }), ", ", _jsx(_components.code, { children: "'z'" }), ", ", _jsx(_components.code, { children: "'9'" }), "). - Special characters like ", _jsx(_components.code, { children: "'\\n'" }), " (newline) are also character constants. 3. ", _jsx(_components.strong, { children: "String Constants:" }), " - A sequence of characters enclosed in double quotes (e.g., ", _jsx(_components.code, { children: ""Hello"" }), ", ", _jsx(_components.code, { children: ""C Programming"" }), ", ", _jsx(_components.code, { children: """" }), " (empty string)). ### 🔍 Difference from Variables | Feature | Constants | Variables | |---|---|---| | ", _jsx(_components.strong, { children: "Definition" }), " | Fixed value, cannot be changed after initialization. | Memory location whose value can change. | | ", _jsx(_components.strong, { children: "Initialization" }), " | Must be initialized at declaration. | Can be declared first, assigned later. | | ", _jsx(_components.strong, { children: "Modification" }), " | ", _jsx(_components.strong, { children: "Cannot" }), " be modified during execution. | ", _jsx(_components.strong, { children: "Can" }), " be modified using assignment ", _jsx(_components.code, { children: "=" }), ". | | ", _jsx(_components.strong, { children: "Example" }), " | ", _jsx(_components.code, { children: "const float PI = 3.14159;" }), " | ", _jsx(_components.code, { children: "int age;" }), " (then ", _jsx(_components.code, { children: "age = 25;" }), ") | In C, you use the ", _jsx(_components.code, { children: "const" }), " keyword to declare a variable that acts as a constant, preventing its modification."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain C data types with examples. Write a small C program to demonstrate implicit and explicit data type conversion." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 C Data Types Data types define the kind of value a variable can hold and the operations that can be performed on it. The main categories are: 1. ", _jsx(_components.strong, { children: "Basic (Built-in) Types:" }), " - ", _jsx(_components.code, { children: "int" }), ": Integer numbers (e.g., ", _jsx(_components.code, { children: "int count = 10;" }), "). - ", _jsx(_components.code, { children: "float" }), ": Single-precision floating-point (e.g., ", _jsx(_components.code, { children: "float average = 75.5;" }), "). - ", _jsx(_components.code, { children: "double" }), ": Double-precision floating-point (higher precision than ", _jsx(_components.code, { children: "float" }), "). - ", _jsx(_components.code, { children: "char" }), ": Single characters (e.g., ", _jsx(_components.code, { children: "char grade = 'A';" }), "). 2. ", _jsx(_components.strong, { children: "Derived Types:" }), " - Arrays, Pointers, Structures, Unions. 3. ", _jsx(_components.strong, { children: "Void Type:" }), " - ", _jsx(_components.code, { children: "void" }), ": Represents absence of a value (used for functions with no return). ### 📝 Data Type Conversion (Type Casting) C automatically converts data types in some situations (", _jsx(_components.strong, { children: "implicit conversion" }), ") and allows manual conversion in others (", _jsx(_components.strong, { children: "explicit conversion" }), "). - ", _jsx(_components.strong, { children: "Implicit Conversion (Coercion):" }), " The compiler automatically converts a smaller data type to a larger one to prevent data loss (e.g., ", _jsx(_components.code, { children: "int" }), " to ", _jsx(_components.code, { children: "float" }), "). - ", _jsx(_components.strong, { children: "Explicit Conversion (Casting):" }), " The programmer manually forces a conversion using the cast operator ", _jsx(_components.code, { children: "(type)" }), ". ### 💻 Example Program ", "{", "\"", "{", "\"", "}", _jsx(_components.code, { children: "#include {"<"}stdio.h> int main() {"{"} // Implicit Conversion (int to float) int num1 = 10; float result1 = num1; // Compiler implicitly converts int to float printf("Implicit (int -> float): 10 becomes %.2f\\\\n", result1); // Explicit Conversion (float to int) float num2 = 9.99; int result2 = (int)num2; // Explicitly casting float to int truncates the decimal printf("Explicit (float -> int): 9.99 becomes %d\\\\n", result2); // Arithmetic with mixed types (int and float) int a = 5; float b = 2.0; float sum = a / b; // 'a' is implicitly converted to float before division printf("Implicit in expression: 5 / 2.0 = %.2f\\\\n", sum); return 0; {"}"}" }), "{", "\"", "}", "\"", "}", " ", _jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: " Implicit (int -> float): 10 becomes 10.00 Explicit (float -> int): 9.99 becomes 9 Implicit in expression: 5 / 2.0 = 2.50 " }), " Implicit conversion generally goes from a ", _jsx(_components.strong, { children: "lower" }), " type to a ", _jsx(_components.strong, { children: "higher" }), " type (e.g., ", _jsx(_components.code, { children: "int" }), " to ", _jsx(_components.code, { children: "float" }), ") to preserve information. Explicit casting is needed to convert from a ", _jsx(_components.strong, { children: "higher" }), " type to a ", _jsx(_components.strong, { children: "lower" }), " type (e.g., ", _jsx(_components.code, { children: "float" }), " to ", _jsx(_components.code, { children: "int" }), "), which may result in data loss."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "1.3", children: [_jsx(MCQ, { questions: [{ "id": "2398acc2-e726-4deb-8b2d-87cb0525791d", "q": "Which of the following is NOT a keyword in C?", "options": ["auto", "main", "switch", "do"], "answer": 1, "hint": "Remember that keywords are predefined reserved words in C.", "explanation": "Keywords are reserved words that have a special meaning to the compiler and cannot be used as identifiers. 'auto', 'switch', and 'do' are keywords, but 'main' is not a keyword (it's a standard function name)." }, { "id": "c2a21634-cfe8-4358-b8a9-dd60fdcefc7c", "q": "Which of the following is a valid identifier in C?", "options": ["2nd_var", "my-var", "_123", "totalCount"], "answer": 3, "hint": "An identifier must start with a letter or underscore, and can contain letters, digits, and underscores.", "explanation": "Option D is the only valid identifier. Identifiers cannot start with a digit (rules out A and C) and cannot contain special characters like the '@' symbol (rules out B)." }, { "id": "9d088f63-41b5-4108-9195-2e006664a6ac", "q": "What is the data type of the constant 3.14f?", "options": ["double", "int", "float", "long double"], "answer": 2, "hint": "Think about the suffix that determines the type of a floating-point constant.", "explanation": "A numeric constant with a decimal point and the suffix 'f' is of type float. Without the suffix, it would be a double constant." }, { "id": "aebcce60-3617-4962-b1c5-210a541d43e3", "q": "What is the length of the string constant "Hi" in C, including the null terminator?", "options": ["3", "2", "4", "5"], "answer": 0, "hint": "A string constant in C is enclosed in double quotes and includes a null terminator.", "explanation": "The string "Hi" contains two visible characters ('H' and 'i') plus one hidden null terminator character ('\\\\0') that marks the end of the string, making its total length 3." }, { "id": "4ea99415-08f0-4bd3-8a04-439e3c8fec72", "q": "Which of the following best describes a 'variable' in C?", "options": ["A fixed value that cannot be changed", "A reserved keyword", "A named memory location whose value can be changed", "A sequence of characters enclosed in quotes"], "answer": 2, "hint": "Variables are named storage locations that can hold a value, and must be declared before use.", "explanation": "A variable is a named storage location in memory whose value can be modified during program execution. A constant cannot change its value, and an identifier is a general term for any name, not specifically a modifiable storage location." }, { "id": "41421130-9e7f-41d7-a26b-d133baba3f82", "q": "Which data type is used to store a single character in C?", "options": ["int", "char", "float", "string"], "answer": 1, "hint": "The 'char' data type is used to store single characters.", "explanation": "The 'char' data type in C is specifically designed to store a single character, which is internally represented as an integer (ASCII value)." }, { "id": "810f50ef-fede-4dc2-ba44-52134c8f30ed", "q": "How many variables are declared in the following statement? int a, b, c;", "options": ["1", "2", "4", "3"], "answer": 3, "hint": "Count the number of variable names listed in the declaration.", "explanation": "The line 'int a, b, c;' declares three distinct integer variables: a, b, and c. The comma separates the variable names in a single declaration statement." }, { "id": "653c3453-8ad1-4735-a8d8-c7e5af01cf56", "q": "What is the result of the expression (float)5/2 in C?", "options": ["2.5", "2", "2.0", "3"], "answer": 0, "hint": "Consider what happens when one operand is a float in an arithmetic expression.", "explanation": "When an integer (5) is explicitly cast to float, the entire operation (float)5/2 promotes the other integer operand (2) to float as well, resulting in 2.5." }, { "id": "dec58962-1157-4ffd-9e1a-3d4dfa896abd", "q": "What is the decimal value of the octal constant 010?", "options": ["10", "16", "8", "9"], "answer": 2, "hint": "Remember the prefix '0' denotes an octal (base-8) number.", "explanation": "The constant 010 is an octal number. To convert to decimal: 1*8^1 + 0*8^0 is 8 + 0 is 8." }, { "id": "40ab51a3-b380-4625-95f5-a5877e30b939", "q": "Which of the following is a correct character constant in C?", "options": ["A", "'A'", ""A"", "#A"], "answer": 1, "hint": "A character constant is enclosed in single quotes.", "explanation": "In C, character constants are enclosed in single quotes (' '). The character 'A' is a character constant, while "A" (double quotes) is a string constant." }], topicId: "1.3" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Fundamental constructs of C", seoDesc: "Master Fundamental constructs of C with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "fundamental constructs of c, fundamental constructs of c notes, fundamental constructs of c examples, diploma engineering notes, practice quiz, learningway" })] })] }); } 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."); }