"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 }, {BlockDiagram, ComparisonTable, Definition, English, Explanation, Hinglish, HowItWorks, ImportantQA, MCQ, SubTopicHeader, Summary} = _components; if (!BlockDiagram) _missingMdxReference("BlockDiagram", true); 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); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "2.3", title: "Branching Statements: break, continue & goto" }), "\n", _jsxs(Definition, { term: "Branching Statements", children: [_jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Branching Statements" }), " (or Jump Statements) are C language constructs that unconditionally transfer the control of program execution from one statement to another."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Branching Statements" }), " (ya Jump Statements) C language ke aise controls hote hain jo bina kisi intermediate state ke, program execution flow ko ek location se dusri line par transfer kar dete hain."] }) })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Branching Controls in C" }), _jsx(_components.p, { children: "C provides three primary jump statements to break sequential flow:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "break statement:" }), " Terminates the execution of the nearest enclosing loop (", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "do-while" }), ") or ", _jsx(_components.code, { children: "switch" }), " block. Program execution resumes at the statement immediately following the terminated block."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "continue statement:" }), " Skips the remaining statements in the current iteration of the nearest loop and jumps to the next loop evaluation.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "while" }), " and ", _jsx(_components.code, { children: "do-while" }), " loops, control jumps to the condition checking statement."] }), "\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "for" }), " loops, control jumps to the increment/decrement statement."] }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "goto statement:" }), " Performs an unconditional jump to a labeled statement within the same function.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Syntax:" }), " ", _jsx(_components.code, { children: "goto label; ... label: statement;" })] }), "\n", _jsx(_components.li, { children: "Its use is strongly discouraged in structured programming because it makes logic tracing hard (\"spaghetti code\")." }), "\n"] }), "\n"] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C mein Branching Controls" }), _jsx(_components.p, { children: "C programming flow ko break/divert karne ke teen basic statements data hain:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "break statement:" }), " Active loop (", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "do-while" }), ") ya ", _jsx(_components.code, { children: "switch-case" }), " block ko instantly terminate karta hai. Program control loop body ke just niche wali coding statement par chala jata hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "continue statement:" }), " Active iteration ke remaining code statements ko skip karke loop ke next step cycle par control shift karta hai.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "while" }), " aur ", _jsx(_components.code, { children: "do-while" }), " loops mein control seedhe condition verification par jump hota hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "for" }), " loops mein control step increment/decrement variable update statement par jata hai."] }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "goto statement:" }), " Program execution ko bina kisi conditional check ke directly function ke kisi defined label block par bhej deta hai.", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Syntax:" }), " ", _jsx(_components.code, { children: "goto path_label; ... path_label: code;" })] }), "\n", _jsx(_components.li, { children: "Structured programming mein iska use galat mana jata hai kyunki isse code flow complicated (\"spaghetti code\") ho jata hai." }), "\n"] }), "\n"] }), "\n"] })] }), _jsx(BlockDiagram, { children: _jsx(_components.p, { children: "Loop start ---> [ Statement 1 ]\n|\nIs it break? +---> YES ---> (Exit Loop)\n| NO\nIs it continue? +--> YES -> (Skip Statement 2, jump to next loop pass)\n| NO\n[ Statement 2 ] ---> Loop Iteration End" }) }), _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: "break" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "continue" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "goto" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Main Action" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Exits the loop block completely." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Skips current iteration remaining steps." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Jumps to a labeled code line anywhere in the function." })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Used Inside" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loops and Switch blocks." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loop blocks only." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Anywhere in the same function scope." })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Loop Effect" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Terminates loop." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Iteration continues." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Completely dependent on label position." })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Good Practice" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Essential (for switch & early exit)." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Acceptable for optimization." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Highly discouraged (spaghetti code risk)." })] })] })] }) }), _jsxs(HowItWorks, { title: "Example showing break and continue behavior", children: [_jsxs(English, { children: [_jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n\nint main() {\n printf(\"Output: \");\n for (int i = 1; i <= 5; i++) {\n if (i == 3) {\n continue; // Skip printing 3\n }\n if (i == 5) {\n break; // Exit loop when i is 5\n }\n printf(\"%d \", i);\n }\n return 0;\n}\n" }) }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "1 2 4 " })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "3" }), " is skipped because of ", _jsx(_components.code, { children: "continue" }), "."] }), "\n", _jsxs(_components.li, { children: ["The loop ends early before printing ", _jsx(_components.code, { children: "5" }), " because of ", _jsx(_components.code, { children: "break" }), "."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \n\nint main() {\n printf(\"Output: \");\n for (int i = 1; i <= 5; i++) {\n if (i == 3) {\n continue; // 3 ko print hone se skip karega\n }\n if (i == 5) {\n break; // Jab i=5 ho loop end kar do\n }\n printf(\"%d \", i);\n }\n return 0;\n}\n" }) }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "1 2 4 " })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " lagne ke karan ", _jsx(_components.code, { children: "3" }), " print nahi hua."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " lagne ke karan ", _jsx(_components.code, { children: "5" }), " screen par aane se pehle hi loop end ho gaya."] }), "\n"] })] })] })] }), "\n", _jsxs(Summary, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " interrupts loops or switch blocks, resuming execution after the block."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " skips loop statements and advances directly to the next iteration."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "goto" }), " performs unconditional jumps to local labels, though it is discouraged."] }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " statements loops ya switch blocks terminate karke code flow bahar shift karte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " active iteration skip kar seedhe loop update ya condition validation par loop ko bhejta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "goto" }), " execution ko kisi local label par transfer karta hai, par structured programming standards ise avoid karte hain."] }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Differentiate between break and continue statements with examples. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "1. **break statement:** Terminates the loop body immediately. The control passes to the statement following the loop.\n*Example:* `for(i=1; i<=5; i++) { if(i==3) break; printf(\"%d\", i); }` prints: `1 2`.\n2. **continue statement:** Does not terminate the loop. It only skips the remaining statements of the current iteration and passes control to the next iteration.\n*Example:* `for(i=1; i<=5; i++) { if(i==3) continue; printf(\"%d\", i); }` prints: `1 2 4 5`.1. **break statement:** Loop body ko instantly end kar deta hai aur loop ke just bad wali line par control pass karta hai.\n*Example:* `for(i=1; i<=5; i++) { if(i==3) break; printf(\"%d\", i); }` output deta hai: `1 2`.\n2. **continue statement:** Loop ko end nahi karta. Yeh current iteration ke bache hue statement ko skip karke sidhe agle iteration par control bhejta hai.\n*Example:* `for(i=1; i<=5; i++) { if(i==3) continue; printf(\"%d\", i); }` output deta hai: `1 2 4 5`." }] } }, { "q": "Why is the use of goto statements generally discouraged in structured programming? (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "The **goto** statement causes an unconditional jump to a labeled statement. It is discouraged because:\n1. It violates structured programming principles, leading to unorganized and messy code (known as **Spaghetti Code**).\n2. It makes tracing, understanding, and debugging code extremely difficult.\n3. It can bypass critical initialization or block-scoped checks, leading to logic bugs.**goto** statement bina kisi conditional rule ke control ko specify label par jump karwata hai. Ise avoid kiya jata hai kyunki:\n1. Yeh structured coding rules break karta hai, jisse code bohot complicated aur unorganized ho jata hai (ise **Spaghetti Code** bolte hain).\n2. Code debugging aur logic trace karna mushkil ho jata hai.\n3. Yeh variable initializations aur critical blocks checks ko bypass kar sakta hai, jisse dynamic errors badhte hain." }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "ddfec108-e3f0-45e0-8bdf-4493d83a73ca", "q": "Which statement terminates a loop and moves execution to the statement immediately following the loop?", "options": ["continue", "break", "goto", "return"], "answer": 1, "hint": "It is also used inside switch-case to prevent fall-through.", "explanation": "The 'break' statement terminates loops and switch blocks, passing control to the statements immediately following them." }, { "id": "22fb7b47-ab6e-4ab4-bae1-69cc0fc51682", "q": "Which statement skips the remaining statements of the current loop iteration and moves to the next pass?", "options": ["break", "exit", "continue", "goto"], "answer": 2, "hint": "It allows the loop to go on, just skipping the current cycle's rest of statements.", "explanation": "The 'continue' statement stops execution of the current iteration and jumps to the next loop evaluation." }, { "id": "f6507866-8610-4142-b806-06382de649b1", "q": "Which statement performs an unconditional jump within a function in C?", "options": ["break", "continue", "goto", "default"], "answer": 2, "hint": "It requires a label to jump to.", "explanation": "The 'goto' statement transfers program control to a labeled statement in the same function." }, { "id": "3a11aa82-e567-454c-861a-c826d9e3c408", "q": "In a 'for' loop, where does control jump when a 'continue' statement is executed?", "options": ["To the initialization section", "To the condition checking expression", "To the increment/decrement step expression", "Out of the loop completely"], "answer": 2, "hint": "A for loop update happens before the next condition check.", "explanation": "In for loops, continue jumps directly to the update (increment/decrement) block, then checks the condition." }, { "id": "8ae1b86f-5e35-4852-bb27-97900d02b198", "q": "In a 'while' loop, where does control jump when a 'continue' statement is executed?", "options": ["To the increment/decrement statement", "To the conditional checking expression", "To the start of the program main block", "To the next code line outside loop"], "answer": 1, "hint": "A while loop header does not contain update statements; it only checks conditions.", "explanation": "In while loops, continue transfers control directly to the conditional test expression at the loop header." }, { "id": "e8fd178e-6ab9-4867-b952-b494738317a4", "q": "What is the danger of using 'goto' statements frequently in C?", "options": ["It causes slow math calculation speeds", "It creates hard-to-debug 'spaghetti code'", "It requires more memory space", "The program causes syntax errors"], "answer": 1, "hint": "Spaghetti is tangled and messy.", "explanation": "Frequent goto usage breaks logical flow, resulting in unreadable 'spaghetti' code." }, { "id": "5b247764-2b87-4f3f-b712-c07dc394293c", "q": "What is the output? for(int i=1; i<=3; i++) { if(i==2) break; printf(\"%d \", i); }", "options": ["1 2 3", "1 3", "1", "2 3"], "answer": 2, "hint": "The loop terminates completely when i becomes 2.", "explanation": "At i=1, prints '1'. At i=2, break triggers, terminating the loop. Only '1' is printed." }, { "id": "a1edc659-4a67-4791-b895-6c0d84b8c4f0", "q": "What is the output? for(int i=1; i<=3; i++) { if(i==2) continue; printf(\"%d \", i); }", "options": ["1 2 3", "1 3", "1", "2 3"], "answer": 1, "hint": "When i is 2, it skips the print statement but continues the loop.", "explanation": "At i=2, continue skips printing '2'. The loop increments to 3, printing '1 3'." }, { "id": "ab08a037-eed7-4d7e-9418-eb5dec8fc872", "q": "Can a 'goto' statement jump from one function to another function in C?", "options": ["Yes, using global labels", "No, goto only jumps to labels within the same function scope", "Yes, if the destination function is declared inline", "Only in main()"], "answer": 1, "hint": "Labels are local to the function in which they are declared.", "explanation": "goto labels have function scope. You cannot jump across functions using goto." }, { "id": "e6c854e4-b512-4a83-b217-3c0f105168e3", "q": "What will be printed? int i=0; loop_label: printf(\"%d \", i++); if(i<3) goto loop_label;", "options": ["0 1 2", "1 2 3", "0 1 2 3", "Compilation Error"], "answer": 0, "hint": "Post-increment prints i first, then increments it.", "explanation": "i=0: prints 0, i becomes 1. 1<3 (true): loops, prints 1, i becomes 2. 2<3 (true): loops, prints 2, i becomes 3. 3<3 (false): exits. Output: '0 1 2'." }], topicId: "2.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."); }