"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", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {ComparisonTable, Definition, English, Explanation, FormulaBox, Hinglish, HowItWorks, ImportantQA, MCQ, SubTopicHeader, Summary} = _components; if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!Definition) _missingMdxReference("Definition", 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 (!MCQ) _missingMdxReference("MCQ", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Summary) _missingMdxReference("Summary", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "1.5", title: "Operators, Expressions & Type Casting" }), "\n", _jsxs(Definition, { term: "Operators & Type Casting", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "Operator" }), " is a symbol that tells the compiler to perform specific mathematical or logical manipulations. ", _jsx(_components.strong, { children: "Type Casting" }), " is the process of converting a variable of one data type into another (e.g., converting an integer to a float)."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Operator" }), " ek symbol hota hai jo compiler ko mathematical ya logical operations chalane ke liye direct karta hai. ", _jsx(_components.strong, { children: "Type Casting" }), " ek variable ko dusre data type mein convert karne ki process hai (jaise ", _jsx(_components.code, { children: "int" }), " value ko ", _jsx(_components.code, { children: "float" }), " number banana)."] }) })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Types of Operators in C" }), _jsx(_components.p, { children: "C provides a rich set of operators grouped by functionality:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Arithmetic Operators:" }), " Perform mathematical calculations. Includes ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", and ", _jsx(_components.code, { children: "%" }), " (modulo operator returning remainder of integer division)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Relational Operators:" }), " Compare values. Includes ", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<=" }), ", ", _jsx(_components.code, { children: ">=" }), ", ", _jsx(_components.code, { children: "==" }), " (equality), and ", _jsx(_components.code, { children: "!=" }), " (not equal)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Logical Operators:" }), " Evaluate logical conditions. Includes ", _jsx(_components.code, { children: "&&" }), " (AND), ", _jsx(_components.code, { children: "||" }), " (OR), and ", _jsx(_components.code, { children: "!" }), " (NOT)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Increment & Decrement Operators:" }), " ", _jsx(_components.code, { children: "++" }), " and ", _jsx(_components.code, { children: "--" }), " increase or decrease values by 1. Available in prefix (", _jsx(_components.code, { children: "++var" }), ") and postfix (", _jsx(_components.code, { children: "var++" }), ") forms."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Bitwise Operators:" }), " Perform bit-level manipulations. Includes ", _jsx(_components.code, { children: "&" }), " (AND), ", _jsx(_components.code, { children: "|" }), " (OR), ", _jsx(_components.code, { children: "^" }), " (XOR), ", _jsx(_components.code, { children: "~" }), " (NOT), ", _jsx(_components.code, { children: "<<" }), " (left shift), and ", _jsx(_components.code, { children: ">>" }), " (right shift)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Ternary / Conditional Operator:" }), " A shorthand for if-else, written as: ", _jsx(_components.code, { children: "Condition ? Expression1 : Expression2;" }), "."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C mein Operators ke Types" }), _jsx(_components.p, { children: "C language mein various operations chalane ke liye operators divide kiye jate hain:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Arithmetic Operators:" }), " Calculations ke liye, jaise ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", aur ", _jsx(_components.code, { children: "%" }), " (modulo operator, jo remainder return karta hai)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Relational Operators:" }), " Comparison check karne ke liye: ", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<=" }), ", ", _jsx(_components.code, { children: ">=" }), ", ", _jsx(_components.code, { children: "==" }), " (barabar hai), ", _jsx(_components.code, { children: "!=" }), " (barabar nahi hai)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Logical Operators:" }), " Multiple conditions combine karne ke liye: ", _jsx(_components.code, { children: "&&" }), " (AND), ", _jsx(_components.code, { children: "||" }), " (OR), aur ", _jsx(_components.code, { children: "!" }), " (NOT)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Increment / Decrement:" }), " ", _jsx(_components.code, { children: "++" }), " aur ", _jsx(_components.code, { children: "--" }), " value ko 1 se increment/decrement karte hain (Prefix: ", _jsx(_components.code, { children: "++a" }), ", Postfix: ", _jsx(_components.code, { children: "a++" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Bitwise Operators:" }), " Binary bits par calculation ke liye: ", _jsx(_components.code, { children: "&" }), ", ", _jsx(_components.code, { children: "|" }), ", ", _jsx(_components.code, { children: "^" }), ", ", _jsx(_components.code, { children: "~" }), ", ", _jsx(_components.code, { children: "<<" }), " (left shift), ", _jsx(_components.code, { children: ">>" }), " (right shift)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Ternary Operator:" }), " Short-cut code statement if-else ke replacement mein: ", _jsx(_components.code, { children: "Condition ? Statement1 : Statement2;" }), "."] }), "\n"] })] }), _jsxs(FormulaBox, { title: "Increment Operator Mechanics (Pre vs Post)", children: [_jsxs(_components.p, { children: ["Let ", _jsx(_components.code, { children: "a = 5;" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Prefix (", _jsx(_components.code, { children: "++a" }), "):"] }), " Increments the value of ", _jsx(_components.code, { children: "a" }), " first, then returns it.\n", _jsx(_components.code, { children: "b = ++a;" }), " -> ", _jsx(_components.code, { children: "a" }), " becomes 6, and ", _jsx(_components.code, { children: "b" }), " becomes 6."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Postfix (", _jsx(_components.code, { children: "a++" }), "):"] }), " Returns the current value of ", _jsx(_components.code, { children: "a" }), " first, then increments ", _jsx(_components.code, { children: "a" }), " in memory.\n", _jsx(_components.code, { children: "b = a++;" }), " -> ", _jsx(_components.code, { children: "b" }), " gets 5, then ", _jsx(_components.code, { children: "a" }), " becomes 6."] }), "\n"] })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "Type Conversion (Casting)" }), _jsx(_components.p, { children: "Data type conversions are of two types:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Implicit Type Conversion (Coercion):" }), " Done automatically by the compiler to prevent data loss. Smaller types are promoted to larger types (e.g., ", _jsx(_components.code, { children: "char" }), " or ", _jsx(_components.code, { children: "int" }), " to ", _jsx(_components.code, { children: "double" }), " in an expression)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Explicit Type Conversion (Casting):" }), " Done manually by the programmer using cast operators. It has the syntax: ", _jsx(_components.code, { children: "(target_type) expression" }), "."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Type Conversion (Casting) ke tarike" }), _jsx(_components.p, { children: "C variables conversion do tarah se handle karta hai:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Implicit Type Conversion (Automatic):" }), " Compiler bin kisi programmer instruction ke smaller data types ko high ranges data types mein convert kar deta hai (jaise: ", _jsx(_components.code, { children: "int" }), " + ", _jsx(_components.code, { children: "float" }), " arithmetic execution par automatically ", _jsx(_components.code, { children: "float" }), " result deta hai)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Explicit Type Casting (Manual):" }), " Programmer manually force karke conversion set karta hai. Syntax: ", _jsx(_components.code, { children: "(datatype) variable_name;" }), " (jaise: ", _jsx(_components.code, { children: "(float)total / count" }), ")."] }), "\n"] })] }), _jsx(ComparisonTable, { 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: "Performed By" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "C 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: "Data Loss Risk" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Low (promotes data to wider types)." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "High (e.g., float to int discards decimals)." })] }), _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 (automatic)." }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Cast operator: ", _jsx(_components.code, { children: "(type) value;" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Example" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "double x = 10;" }), " (int 10 promoted to 10.0)."] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "int y = (int) 5.99;" }), " (y becomes 5)."] })] })] })] }) }), _jsxs(HowItWorks, { title: "Code demonstration of Division and Cast", children: [_jsx(English, { children: _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n\nint main() {\n int sum = 17, count = 5;\n double average1, average2;\n\n average1 = sum / count; // Integer division: 17 / 5 = 3 (decimals discarded)\n average2 = (double) sum / count; // Explicit Cast: 17.0 / 5 = 3.4\n\n printf(\"Avg without cast: %lf\\n\", average1); // Output: 3.000000\n printf(\"Avg with cast: %lf\\n\", average2); // Output: 3.400000\n return 0;\n}\n" }) }) }), _jsx(Hinglish, { children: _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n\nint main() {\n int sum = 17, count = 5;\n double average1, average2;\n\n average1 = sum / count; // Integer division: 17 / 5 = 3 (decimels remove ho gaye)\n average2 = (double) sum / count; // Explicit Cast: 17.0 / 5 = 3.4\n\n printf(\"Avg without cast: %lf\\n\", average1); // Output: 3.000000\n printf(\"Avg with cast: %lf\\n\", average2); // Output: 3.400000\n return 0;\n}\n" }) }) })] })] }), "\n", _jsxs(Summary, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Modulo operator (", _jsx(_components.code, { children: "%" }), ") calculates division remainders, only working on integer types."] }), "\n", _jsx(_components.li, { children: "Postfix modifications update values after returning, whereas prefix modifications update values immediately." }), "\n", _jsx(_components.li, { children: "Explicit casting is necessary when converting from large to small variables to avoid accidental decimal truncation." }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Modulo operator (", _jsx(_components.code, { children: "%" }), ") remainder calculate karta hai aur yeh sirf integers data par apply hota hai."] }), "\n", _jsx(_components.li, { children: "Prefix statements memory aur execution lines instantly badalte hain, postfix lines execution ke baad variables badalte hain." }), "\n", _jsx(_components.li, { children: "Large to small datatype conversions mein information loss se bachne ke liye manual type casting apply hoti hai." }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Differentiate between Post-increment and Pre-increment operators with examples. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "1. **Pre-increment (`++var`):** First increments the variable by 1, and then uses the new value in the expression.\n*Example:* If `x = 5; y = ++x;`, then `x` becomes 6, and `y` becomes 6.\n2. **Post-increment (`var++`):** Uses the current value of the variable in the expression first, and then increments the variable by 1 in memory.\n*Example:* If `x = 5; y = x++;`, then `y` becomes 5, and `x` becomes 6.1. **Pre-increment (`++var`):** Yeh variable ki value ko pehle 1 se badhata hai, fir expression mein updated value return karta hai.\n*Example:* Agar `x = 5; y = ++x;`, toh `x` bhi 6 banega aur `y` bhi 6 banega.\n2. **Post-increment (`var++`):** Yeh variable ki original value ko execution statement mein return karta hai, fir memory mein use 1 se badhata hai.\n*Example:* Agar `x = 5; y = x++;`, toh `y` ko purani value 5 milegi, aur process ke baad `x` ki value 6 ho jayegi." }] } }, { "q": "Define Type Casting. Explain implicit type conversion with an example. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "**Type Casting** is the technique of converting a data value from one type to another. \n**Implicit Type Conversion:** Done by the compiler automatically when different data types are used in a single expression. It converts narrower types to wider types to avoid losing precision.\n\n*Example:* \n```c\nint a = 10;\nfloat b = 5.5, result;\nresult = a + b; // 'a' is implicitly converted to float (10.0) before addition\n```**Type Casting** data values ko ek type se dusre type mein convert karne ki process hai.\n**Implicit Type Conversion:** Yeh compiler automatically perform karta hai jab mix datatypes single expression mein aate hain. Yeh short range types (int) ko broad types (float) mein promote karta hai taaki calculation values change na hon.\n\n*Example:* \n```c\nint a = 10;\nfloat b = 5.5, result;\nresult = a + b; // a automatically float value (10.0) ban jayega\n```" }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "35e9f008-cd59-4492-8b72-c34c75068ef9", "q": "Which of the following operators is used to calculate the remainder of division between two integers?", "options": ["/", "%", "*", "\\"], "answer": 1, "hint": "Known as the modulo operator.", "explanation": "The '%' operator returns the remainder of integer division." }, { "id": "3f907609-7e7f-4d8d-a28d-c9cc50a0e741", "q": "What is the value of expression 5 % 2?", "options": ["2.5", "2", "1", "0"], "answer": 2, "hint": "When 5 is divided by 2, what is the remainder?", "explanation": "5 divided by 2 is 2 with a remainder of 1." }, { "id": "d62bb883-a760-452f-bf49-7edab9fddc8c", "q": "If x = 10, what is the value of y after y = x++; executes?", "options": ["10", "11", "12", "Garbage"], "answer": 0, "hint": "This is postfix increment.", "explanation": "In postfix, the value of x (10) is assigned to y first, and then x is incremented to 11." }, { "id": "d27e0bd4-2fd8-4311-8905-66185c025be1", "q": "Which operator is used as a shorthand replacement for simple if-else statements?", "options": ["sizeof", "&&", "? :", "->"], "answer": 2, "hint": "It takes three operands and is also known as the Conditional operator.", "explanation": "The conditional operator '? :' evaluates expressions based on truth values, mimicking an if-else statement." }, { "id": "8f69521a-5060-4b99-9aca-3c1b5bbf9f5f", "q": "What will be the output of 5 / 2 in C if both operands are integers?", "options": ["2.5", "2", "3", "0"], "answer": 1, "hint": "Integer division discards the fractional part.", "explanation": "In C, integer / integer yields an integer. 5/2 is 2 (the fractional .5 is truncated)." }, { "id": "bcc5200a-2023-4b6e-b365-0324cc768712", "q": "Which of the following describes explicit type casting?", "options": ["Conversion performed automatically by the compiler", "Conversion forced manually by the programmer using (type) syntax", "Assigning variables without declarations", "Freeing memory space dynamically"], "answer": 1, "hint": "Using parenthesis before expression.", "explanation": "Explicit type casting is programmer-specified type modification using syntax like (float)var." }, { "id": "c3a2ac69-ef4b-4339-9ae8-b3853a5f147e", "q": "What is the precedence of standard arithmetic operators in C?", "options": ["+, - have higher precedence than *, /, %", "*, /, % have higher precedence than +, -", "All arithmetic operators have equal precedence", "Precedence is determined randomly at runtime"], "answer": 1, "hint": "Think of BODMAS rule.", "explanation": "Multiplication, division, and modulo (*, /, %) have higher precedence than addition and subtraction (+, -)." }, { "id": "7988848c-55d1-4f9d-92aa-aee3805408a5", "q": "If a = 5, what is the value of expression: ++a + 10?", "options": ["15", "16", "17", "11"], "answer": 1, "hint": "This is prefix increment.", "explanation": "++a increases a to 6 immediately, then 6 + 10 = 16." }, { "id": "9e5e2fc9-d35a-4956-99f7-755846ac96f1", "q": "Which of the following is NOT allowed with floating point data types (float/double) in C?", "options": ["Division operator (/) ", "Modulo operator (%)", "Multiplication operator (*)", "Subtraction operator (-)"], "answer": 1, "hint": "You cannot find remainder of float divisions using this operator.", "explanation": "The modulo operator (%) is strictly defined for integer operand calculations; using it on float values causes compilation errors." }, { "id": "b279ca8d-4b1b-4c0a-a765-20faa16eefaf", "q": "What will be the final value of x in: int x = (int)5.8 + (int)2.5; ?", "options": ["8", "7", "8.3", "7.3"], "answer": 1, "hint": "Cast truncates decimal parts before addition.", "explanation": "(int)5.8 truncates to 5, and (int)2.5 truncates to 2. Thus, 5 + 2 = 7." }], topicId: "1.5" })] }); } 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."); }