"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 }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _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 (!Hinglish) _missingMdxReference("Hinglish", 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); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "2.3", title: "Branching Statements: goto, break, and continue" }), _jsx(English, { children: _jsx(TopicOverview, { title: "Branching Statements: goto, break, and continue", topicId: "2.3", readingTime: "10 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["This subtopic introduces three important branching statements in C: ", _jsx(_components.code, { children: "goto" }), ", ", _jsx(_components.code, { children: "break" }), ", and ", _jsx(_components.code, { children: "continue" }), ". While ", _jsx(_components.code, { children: "goto" }), " provides an unconditional jump capability within a function, ", _jsx(_components.code, { children: "break" }), " and ", _jsx(_components.code, { children: "continue" }), " offer structured ways to control loop execution flow. Understanding these statements is crucial for writing efficient loop-based programs — knowing when to exit loops early, skip certain iterations, or jump to specific code locations. We will explore the syntax, behavior, and practical use cases of each statement, along with common pitfalls to avoid."] }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "Branching Statements: goto, break, aur continue", topicId: "2.3", readingTime: "10 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["Is subtopic mein hum C ke teen important branching statements seekhenge: ", _jsx(_components.code, { children: "goto" }), ", ", _jsx(_components.code, { children: "break" }), ", aur ", _jsx(_components.code, { children: "continue" }), ". Jabki ", _jsx(_components.code, { children: "goto" }), " function ke andar unconditional jump ki ability deta hai, ", _jsx(_components.code, { children: "break" }), " aur ", _jsx(_components.code, { children: "continue" }), " loop execution flow ko control karne ke structured tarike provide karte hain. In statements ko samajhna efficient loop-based programs likhne ke liye zaroori hai — kab loop se bahar nikalna hai, kisi iteration ko skip karna hai, ya kisi specific code location par jaana hai. Hum har statement ka syntax, behavior, aur practical use cases dekhenge, saath hi kuch common pitfalls jo avoid karne chahiye."] }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "goto statement", children: _jsxs(_components.p, { children: ["An unconditional branching statement that transfers program control directly to a labeled statement within the same function. Unlike other control structures, ", _jsx(_components.code, { children: "goto" }), " does not check any condition — it always jumps. Think of it as an \"instant teleport\" within your function's code."] }) }), _jsx(DefinitionEntry, { term: "label", children: _jsxs(_components.p, { children: ["A user-defined identifier followed by a colon (", _jsx(_components.code, { children: ":" }), ") that marks a specific destination point in the code. A ", _jsx(_components.code, { children: "goto" }), " statement uses this label as its jump target. Labels are local to the function in which they appear."] }) }), _jsx(DefinitionEntry, { term: "break statement", children: _jsxs(_components.p, { children: ["A control statement that immediately terminates the nearest enclosing ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", or ", _jsx(_components.code, { children: "do-while" }), " loop, or a ", _jsx(_components.code, { children: "switch" }), " statement. Control passes to the first statement after the terminated construct. In loops, it acts like an emergency exit."] }) }), _jsx(DefinitionEntry, { term: "continue statement", children: _jsxs(_components.p, { children: ["A control statement that skips the remaining statements of the current loop iteration and jumps directly to the next iteration's condition check. Unlike ", _jsx(_components.code, { children: "break" }), ", it does not exit the loop — it merely skips one pass through the loop body."] }) }), _jsx(DefinitionEntry, { term: "fall-through", children: _jsxs(_components.p, { children: ["The default behavior in a ", _jsx(_components.code, { children: "switch" }), " statement where execution continues into the next ", _jsx(_components.code, { children: "case" }), " block when no ", _jsx(_components.code, { children: "break" }), " is encountered. This can be intentional (for shared logic across multiple cases) or a bug if not expected."] }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🔄 goto Statement" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "goto" }), " statement is C's simplest branching mechanism — it unconditionally transfers program control to a labeled position within the same function. Here's how it works:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["You define a ", _jsx(_components.strong, { children: "label" }), " (an identifier followed by ", _jsx(_components.code, { children: ":" }), ") at the target location in your code"] }), "\n", _jsxs(_components.li, { children: ["You write ", _jsx(_components.code, { children: "goto label;" }), " wherever you want to jump"] }), "\n", _jsx(_components.li, { children: "When executed, the program immediately jumps to that label and continues from there" }), "\n"] }), _jsxs(_components.p, { children: ["While ", _jsx(_components.code, { children: "goto" }), " is rarely used in modern C programming (as it makes code flow hard to follow), it has a few valid use cases:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Breaking out of ", _jsx(_components.strong, { children: "deeply nested loops" }), " (multiple levels at once, where ", _jsx(_components.code, { children: "break" }), " cannot help)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Centralized error handling" }), " in complex functions where cleanup code lives at one label"] }), "\n", _jsxs(_components.li, { children: ["Simple ", _jsx(_components.strong, { children: "state machine" }), " implementations"] }), "\n"] }), _jsxs(_components.p, { children: ["The first code example below demonstrates a simple ", _jsx(_components.code, { children: "goto" }), " loop that prints numbers 1 to 5. The second example shows ", _jsx(_components.code, { children: "goto" }), " being used for early error handling when a negative number is entered."] }), _jsx(_components.h3, { children: "⏭️ break Statement" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "break" }), " statement provides an ", _jsx(_components.strong, { children: "immediate exit" }), " from the nearest enclosing ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", or ", _jsx(_components.code, { children: "do-while" }), " loop, or from a ", _jsx(_components.code, { children: "switch" }), " statement. Here's the key behavior:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "In a loop:" }), " When ", _jsx(_components.code, { children: "break" }), " is encountered, control jumps to the first statement ", _jsx(_components.strong, { children: "after" }), " the loop — the loop terminates immediately"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["In a ", _jsx(_components.code, { children: "switch" }), ":"] }), " When ", _jsx(_components.code, { children: "break" }), " is encountered, control jumps out of the switch block — preventing fall-through to the next case"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Important:" }), " ", _jsx(_components.code, { children: "break" }), " only exits ", _jsx(_components.strong, { children: "ONE level" }), " of nesting. In nested loops, it only terminates the innermost loop"] }), "\n"] }), _jsxs(_components.p, { children: ["The code examples below show ", _jsx(_components.code, { children: "break" }), " stopping a ", _jsx(_components.code, { children: "for" }), " loop early when a condition is met, and ", _jsx(_components.code, { children: "break" }), " preventing fall-through in a ", _jsx(_components.code, { children: "switch" }), " statement that maps day numbers to names."] }), _jsx(_components.h3, { children: "🔁 continue Statement" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "continue" }), " statement ", _jsx(_components.strong, { children: "skips the remaining statements" }), " in the current loop iteration and jumps directly to the next iteration. Here's how it differs from ", _jsx(_components.code, { children: "break" }), ":"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " ", _jsx(_components.strong, { children: "exits" }), " the loop entirely — the loop stops running"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " ", _jsx(_components.strong, { children: "skips" }), " only the current iteration — the loop keeps running"] }), "\n"] }), _jsx(_components.p, { children: "Behavior differs by loop type:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "for" }), " loops: jumps to the ", _jsx(_components.strong, { children: "increment expression" }), " (the third part of the ", _jsx(_components.code, { children: "for" }), " header)"] }), "\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "while" }), " / ", _jsx(_components.code, { children: "do-while" }), " loops: jumps to the ", _jsx(_components.strong, { children: "condition check" })] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Critical Pitfall:" }), " In a ", _jsx(_components.code, { children: "while" }), " loop, if ", _jsx(_components.code, { children: "continue" }), " appears ", _jsx(_components.strong, { children: "before" }), " the increment/update statement, the loop variable never changes — causing an ", _jsx(_components.strong, { children: "infinite loop" }), ". Always ensure the loop variable is updated before ", _jsx(_components.code, { children: "continue" }), " when using ", _jsx(_components.code, { children: "while" }), " loops."] }), _jsxs(_components.p, { children: ["The code examples show printing only odd numbers using ", _jsx(_components.code, { children: "continue" }), ", and demonstrate the dangerous infinite loop pitfall with ", _jsx(_components.code, { children: "while" }), "."] }), _jsx(_components.h3, { children: "⚡ break vs continue: Key Differences" }), _jsxs(_components.p, { children: ["Both ", _jsx(_components.code, { children: "break" }), " and ", _jsx(_components.code, { children: "continue" }), " alter loop execution, but in fundamentally different ways:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " is like an ", _jsx(_components.strong, { children: "emergency exit" }), " — it takes you out of the loop completely"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " is like ", _jsx(_components.strong, { children: "skipping a turn" }), " — you skip the current round but stay in the game"] }), "\n"] }), _jsx(_components.p, { children: "The Mermaid flowchart and comparison table below illustrate these differences visually." }), _jsx(_components.h3, { children: "🧩 break in Nested Loops" }), _jsxs(_components.p, { children: ["When ", _jsx(_components.code, { children: "break" }), " is used inside ", _jsx(_components.strong, { children: "nested loops" }), ", it only terminates the ", _jsx(_components.strong, { children: "innermost" }), " loop. The outer loop continues executing normally. This is a critical behavior to remember:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Inner loop has ", _jsx(_components.code, { children: "break" }), " → inner loop exits, outer loop keeps running"] }), "\n", _jsxs(_components.li, { children: ["If you need to break out of ", _jsx(_components.strong, { children: "multiple nesting levels" }), " simultaneously, you need a different strategy"] }), "\n"] }), _jsx(_components.p, { children: "Two common approaches to break out of multiple nested loops:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["Use a ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "goto" }) }), " statement to jump to a label placed after all loops"] }), "\n", _jsxs(_components.li, { children: ["Use a ", _jsx(_components.strong, { children: "flag variable" }), " that each inner ", _jsx(_components.code, { children: "break" }), " also checks in the outer loop"] }), "\n"] }), _jsxs(_components.p, { children: ["The code example below demonstrates how ", _jsx(_components.code, { children: "break" }), " only affects the inner loop while the outer loop runs all its iterations."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔄 goto Statement" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "goto" }), " statement C ka sabse ", _jsx(_components.strong, { children: "simplest branching mechanism" }), " hai — yeh function ke andar ek labeled position par ", _jsx(_components.strong, { children: "unconditionally" }), " program control transfer karta hai. Yeh kaise kaam karta hai:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Aap target location par ek ", _jsx(_components.strong, { children: "label" }), " define karte ho (ek identifier + ", _jsx(_components.code, { children: ":" }), " ke saath)"] }), "\n", _jsxs(_components.li, { children: ["Jahan se jump karna ho, wahan ", _jsx(_components.code, { children: "goto label;" }), " likhte ho"] }), "\n", _jsx(_components.li, { children: "Jab execute hota hai, program seedha us label par chala jaata hai aur wahan se continue karta hai" }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "goto" }), " modern C programming mein ", _jsx(_components.strong, { children: "rarely use" }), " hota hai (kyunki code ka flow samajhna mushkil ho jaata hai), lekin kuch valid use cases hain:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Deeply nested loops" }), " se bahar nikalna (multiple levels ek saath, jahan ", _jsx(_components.code, { children: "break" }), " kaam na kare)"] }), "\n", _jsxs(_components.li, { children: ["Complex functions mein ", _jsx(_components.strong, { children: "centralized error handling" }), " jahan cleanup code ek hi label par ho"] }), "\n", _jsxs(_components.li, { children: ["Simple ", _jsx(_components.strong, { children: "state machine" }), " implementations"] }), "\n"] }), _jsxs(_components.p, { children: ["Pehla code example ek simple ", _jsx(_components.code, { children: "goto" }), " loop dikhata hai jo 1 se 5 tak numbers print karta hai. Doosra example dikhata hai kaise ", _jsx(_components.code, { children: "goto" }), " negative number enter hone par early error handling ke liye use hota hai."] }), _jsx(_components.h3, { children: "⏭️ break Statement" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "break" }), " statement nearest enclosing ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ya ", _jsx(_components.code, { children: "do-while" }), " loop ya ", _jsx(_components.code, { children: "switch" }), " statement se ", _jsx(_components.strong, { children: "immediate exit" }), " provide karta hai. Key behavior dekhte hain:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Loop mein:" }), " Jab ", _jsx(_components.code, { children: "break" }), " milta hai, control loop ke baad pehle statement par chala jaata hai — loop ", _jsx(_components.strong, { children: "turant terminate" }), " ho jaata hai"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "switch" }), " mein:"] }), " Jab ", _jsx(_components.code, { children: "break" }), " milta hai, control switch block se bahar chala jaata hai — next case mein ", _jsx(_components.strong, { children: "fall-through nahi" }), " hota"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Important:" }), " ", _jsx(_components.code, { children: "break" }), " sirf ", _jsx(_components.strong, { children: "EK level" }), " exit karta hai. Nested loops mein, yeh sirf innermost loop ko terminate karta hai"] }), "\n"] }), _jsxs(_components.p, { children: ["Neeche ke code examples dikhate hain kaise ", _jsx(_components.code, { children: "break" }), " ek ", _jsx(_components.code, { children: "for" }), " loop ko early stop karta hai jab condition meet hoti hai, aur kaise ", _jsx(_components.code, { children: "break" }), " ", _jsx(_components.code, { children: "switch" }), " statement mein fall-through prevent karta hai jo day numbers ko names se map karta hai."] }), _jsx(_components.h3, { children: "🔁 continue Statement" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "continue" }), " statement ", _jsx(_components.strong, { children: "current loop iteration ke baaki statements ko skip" }), " kar deta hai aur seedha next iteration par chala jaata hai. ", _jsx(_components.code, { children: "break" }), " se yeh kaise different hai:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " loop ko ", _jsx(_components.strong, { children: "completely exit" }), " karta hai — loop band ho jaata hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " sirf ", _jsx(_components.strong, { children: "current iteration" }), " ko skip karta hai — loop chalta rehta hai"] }), "\n"] }), _jsx(_components.p, { children: "Har loop type mein behavior alag hai:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "for" }), " loops mein: ", _jsx(_components.strong, { children: "increment expression" }), " (for ka teesra part) par chala jaata hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "while" }), " / ", _jsx(_components.code, { children: "do-while" }), " loops mein: ", _jsx(_components.strong, { children: "condition check" }), " par chala jaata hai"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Critical Pitfall:" }), " ", _jsx(_components.code, { children: "while" }), " loop mein, agar ", _jsx(_components.code, { children: "continue" }), " increment/update statement se ", _jsx(_components.strong, { children: "pehle" }), " aata hai, toh loop variable kabhi change nahi hota — jisse ", _jsx(_components.strong, { children: "infinite loop" }), " hota hai. ", _jsx(_components.code, { children: "while" }), " loops mein hamesha ensure karo ki loop variable ", _jsx(_components.code, { children: "continue" }), " se pehle update ho!"] }), _jsxs(_components.p, { children: ["Code examples dikhate hain kaise sirf odd numbers print karte hain ", _jsx(_components.code, { children: "continue" }), " se, aur dangerous infinite loop pitfall bhi ", _jsx(_components.code, { children: "while" }), " ke saath demonstrate karte hain."] }), _jsx(_components.h3, { children: "⚡ break vs continue: Key Differences" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "break" }), " aur ", _jsx(_components.code, { children: "continue" }), " dono loop execution ko alter karte hain, lekin fundamentally different tarike se:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " jaise ", _jsx(_components.strong, { children: "emergency exit" }), " hai — aapko loop se poora bahar nikaal deta hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " jaise ", _jsx(_components.strong, { children: "turn skip" }), " karna hai — current round skip karte ho lekin game mein rehte ho"] }), "\n"] }), _jsx(_components.p, { children: "Mermaid flowchart aur comparison table neeche yeh differences visually dikhate hain." }), _jsx(_components.h3, { children: "🧩 break in Nested Loops" }), _jsxs(_components.p, { children: ["Jab ", _jsx(_components.strong, { children: "nested loops" }), " mein ", _jsx(_components.code, { children: "break" }), " use hota hai, toh yeh sirf ", _jsx(_components.strong, { children: "innermost" }), " loop ko terminate karta hai. Outer loop normal rehta hai aur execute hota rehta hai. Yeh bahut critical behavior hai yaad rakhna:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Inner loop mein ", _jsx(_components.code, { children: "break" }), " hai → inner loop exit hota hai, outer loop chalta rehta hai"] }), "\n", _jsxs(_components.li, { children: ["Agar aapko ", _jsx(_components.strong, { children: "multiple nesting levels" }), " ek saath se bahar nikalna hai, toh alag strategy chahiye"] }), "\n"] }), _jsx(_components.p, { children: "Multiple nested loops se bahar nikalne ke do common approaches hain:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "goto" }) }), " statement use karo jo sab loops ke baad ek label par jump kare"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Flag variable" }), " use karo jo har inner ", _jsx(_components.code, { children: "break" }), " ke saath outer loop mein bhi check ho"] }), "\n"] }), _jsxs(_components.p, { children: ["Code example neeche dikhata hai kaise ", _jsx(_components.code, { children: "break" }), " sirf inner loop ko affect karta hai jabki outer loop apni saari iterations chalata hai."] })] }), _jsx(_components.h3, { children: "📝 goto — Simple Loop Example" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i = 1; loop: printf("%d ", i); i++; if (i <= 5) goto loop; printf("\\nDone!"); return 0; }` }), _jsx(_components.h3, { children: "📝 goto — Early Error Handling Example" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int num; printf("Enter a number: "); scanf("%d", &num); if (num < 0) goto error; printf("Square = %d\\n", num * num); return 0; error: printf("Error: Negative number entered!\\n"); return 1; }` }), _jsx(_components.h3, { children: "📝 break — Stopping a Loop Early" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i; for (i = 1; i <= 10; i++) { if (i == 6) break; printf("%d ", i); } printf("\\nBreak happened at i = %d\\n", i); return 0; }` }), _jsx(_components.h3, { children: "📝 break — Preventing Fall-through in switch" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int day = 3; switch (day) { case 1: printf("Monday"); break; case 2: printf("Tuesday"); break; case 3: printf("Wednesday"); break; case 4: printf("Thursday"); break; case 5: printf("Friday"); break; default: printf("Weekend"); } return 0; }` }), _jsx(_components.h3, { children: "📝 continue — Printing Only Odd Numbers" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i; for (i = 1; i <= 10; i++) { if (i % 2 == 0) continue; printf("%d ", i); } printf("\\n"); return 0; }` }), _jsx(_components.h3, { children: "📝 continue — ⚠️ Infinite Loop Pitfall in while" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i = 0; while (i < 5) { if (i == 2) continue; // Bug: i never increments! printf("%d ", i); i++; } printf("\\n"); return 0; }` }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"Loop Condition Check\"] -->|True| B[\"Execute Loop Body\"]\r\n A -->|False| G[\"Loop Ends\"]\r\n B --> C{\"break or continue?\"}\r\n C -->|\"break\"| D[\"Exit Loop Entirely\"]\r\n C -->|\"continue\"| E[\"Skip to Next Iteration\"]\r\n C -->|\"Normal\"| F[\"Execute Remaining Statements\"]\r\n F --> E\r\n E --> A\n" }) }), _jsx(_components.h3, { children: "⚡ break vs continue: Comparison" }), _jsx(ComparisonTable, { title: "break vs continue — Side by Side", 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: _jsx(_components.code, { children: "break" }) }), _jsx(_components.th, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "continue" }) })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Effect" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Exits the loop/switch entirely" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Skips current iteration, loop continues" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Scope" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Terminates innermost enclosing loop/switch" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Skips rest of current loop body only" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsxs(_components.strong, { children: ["In ", _jsx(_components.code, { children: "for" }), " loop"] }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Jumps to statement after the loop" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Jumps to increment expression" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsxs(_components.strong, { children: ["In ", _jsx(_components.code, { children: "while" }), " loop"] }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Jumps to statement after the loop" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Jumps to condition check" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsxs(_components.strong, { children: ["In ", _jsx(_components.code, { children: "switch" })] }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Exits the switch block" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Not applicable" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Analogy" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Emergency exit from a building" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Skipping a floor but staying in the building" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Code flow" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loop stops completely" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loop runs remaining iterations" })] })] })] }) }), _jsx(_components.h3, { children: "🧩 break — Only Exits the Innermost Loop" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i, j; for (i = 1; i <= 3; i++) { for (j = 1; j <= 3; j++) { if (j == 2) break; // Only exits the inner loop! printf("i = %d, j = %d\\n", i, j); } } return 0; }` }), _jsx(Remember, { title: "⚠️ goto — Use with Extreme Caution", children: _jsxs(_components.p, { children: ["Most coding standards and style guides ", _jsxs(_components.strong, { children: ["advise against using ", _jsx(_components.code, { children: "goto" })] }), " in C. It creates unstructured jumps that make code flow difficult to follow and debug. Prefer ", _jsx(_components.code, { children: "break" }), ", ", _jsx(_components.code, { children: "continue" }), ", functions, and structured programming techniques instead. The only widely accepted use case is ", _jsx(_components.strong, { children: "breaking out of deeply nested loops" }), " (multiple levels at once), where ", _jsx(_components.code, { children: "break" }), " can only exit one level. If you must use ", _jsx(_components.code, { children: "goto" }), ", always jump ", _jsx(_components.strong, { children: "forward" }), " (not backward) to keep code readable."] }) }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "goto" }), " is an unconditional jump to a labeled position — avoid it in most situations, prefer structured alternatives"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " exits the ", _jsx(_components.strong, { children: "nearest enclosing" }), " loop or ", _jsx(_components.code, { children: "switch" }), " statement immediately"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "continue" }), " skips the rest of the current iteration and moves to the ", _jsx(_components.strong, { children: "next iteration" }), " of the loop"] }), "\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "switch" }), " statements, missing ", _jsx(_components.code, { children: "break" }), " causes ", _jsx(_components.strong, { children: "fall-through" }), " to the next case block"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " only exits ", _jsx(_components.strong, { children: "one level" }), " of nesting — in nested loops, only the innermost loop terminates"] }), "\n", _jsxs(_components.li, { children: ["In ", _jsx(_components.code, { children: "while" }), " loops, always update the loop variable ", _jsx(_components.strong, { children: "before" }), " ", _jsx(_components.code, { children: "continue" }), " to avoid infinite loops"] }), "\n", _jsxs(_components.li, { children: ["Use ", _jsx(_components.code, { children: "goto" }), " or flag variables when you need to break out of ", _jsx(_components.strong, { children: "multiple nested loops" }), " simultaneously"] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "What is the 'goto' statement in C, and why is its use generally discouraged in modern programming?" }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Definition The ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "goto" }) }), " statement in C is an ", _jsx(_components.strong, { children: "unconditional branching statement" }), " that transfers the program control directly to a ", _jsx(_components.strong, { children: "labeled statement" }), " within the same function. It uses a ", _jsx(_components.strong, { children: "label" }), " (a user-defined name followed by a colon) as the target destination. ### 📝 Syntax ", _jsx(_components.code, { children: "c goto label; // ... some statements ... label: statement; " }), " ### ⚠️ Why ", _jsx(_components.code, { children: "goto" }), " is Discouraged - ", _jsx(_components.strong, { children: "Reduces readability:" }), " Using ", _jsx(_components.code, { children: "goto" }), " makes the program flow difficult to follow, as it can jump ", _jsx(_components.strong, { children: "backward" }), " or ", _jsx(_components.strong, { children: "forward" }), " unpredictably. - ", _jsx(_components.strong, { children: "Hard to debug and maintain:" }), " Programs using ", _jsx(_components.code, { children: "goto" }), " become \"spaghetti code\" — tangled and unstructured. - ", _jsx(_components.strong, { children: "Can be replaced:" }), " Any logic achievable with ", _jsx(_components.code, { children: "goto" }), " can be implemented using structured constructs like ", _jsx(_components.strong, { children: "loops" }), ", ", _jsx(_components.strong, { children: "if-else" }), ", ", _jsx(_components.strong, { children: "break" }), ", or ", _jsx(_components.strong, { children: "continue" }), ". - ", _jsx(_components.strong, { children: "Error-prone:" }), " Uncontrolled jumps can skip initialization, variable declarations, or cleanup code, leading to ", _jsx(_components.strong, { children: "bugs" }), ". The ", _jsx(_components.code, { children: "goto" }), " statement is only considered acceptable in limited scenarios, such as ", _jsx(_components.strong, { children: "breaking out of deeply nested loops" }), " (multiple levels at once) where ", _jsx(_components.code, { children: "break" }), " alone cannot help."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Differentiate between 'break' and 'continue' statements in C with suitable examples for each." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "break" }), " and ", _jsx(_components.code, { children: "continue" }), " statements are both ", _jsx(_components.strong, { children: "loop control (branching) statements" }), " but serve fundamentally different purposes: | Aspect | ", _jsx(_components.code, { children: "break" }), " | ", _jsx(_components.code, { children: "continue" }), " | |---|---|---| | ", _jsx(_components.strong, { children: "Purpose" }), " | Terminates the loop entirely and transfers control to the statement ", _jsx(_components.strong, { children: "after" }), " the loop. | Skips the ", _jsx(_components.strong, { children: "remaining statements" }), " of the current iteration and jumps to the ", _jsx(_components.strong, { children: "next iteration" }), ". | | ", _jsx(_components.strong, { children: "Works with" }), " | ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "do-while" }), ", and ", _jsx(_components.code, { children: "switch" }), " statements. | ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", and ", _jsx(_components.code, { children: "do-while" }), " loops ", _jsx(_components.strong, { children: "only" }), ". | | ", _jsx(_components.strong, { children: "Effect" }), " | Loop stops completely. | Only the current cycle is skipped; the loop continues. | | ", _jsx(_components.strong, { children: "Nested Loops" }), " | Exits only the ", _jsx(_components.strong, { children: "innermost" }), " loop. | Skips to the next iteration of the ", _jsx(_components.strong, { children: "innermost" }), " loop. | ### 📝 Example: ", _jsx(_components.code, { children: "break" }), " Statement ", _jsx(_components.code, { children: "c #include <stdio.h> int main() { int i; for (i = 1; i <= 10; i++) { if (i == 5) break; printf("%d ", i); } // Output: 1 2 3 4 return 0; } " }), " Here, when ", _jsx(_components.code, { children: "i" }), " becomes ", _jsx(_components.strong, { children: "5" }), ", ", _jsx(_components.code, { children: "break" }), " terminates the loop. So numbers 5 through 10 are ", _jsx(_components.strong, { children: "not printed" }), ". ### 📝 Example: ", _jsx(_components.code, { children: "continue" }), " Statement ", _jsx(_components.code, { children: "c #include <stdio.h> int main() { int i; for (i = 1; i <= 10; i++) { if (i == 5) continue; printf("%d ", i); } // Output: 1 2 3 4 6 7 8 9 10 return 0; } " }), " Here, when ", _jsx(_components.code, { children: "i" }), " becomes ", _jsx(_components.strong, { children: "5" }), ", ", _jsx(_components.code, { children: "continue" }), " skips the ", _jsx(_components.code, { children: "printf()" }), " for that iteration only. The loop proceeds with ", _jsx(_components.code, { children: "i = 6, 7, 8, 9, 10" }), " as usual. ", _jsx(_components.code, { children: "break" }), " ", _jsx(_components.strong, { children: "stops" }), " the loop; ", _jsx(_components.code, { children: "continue" }), " ", _jsx(_components.strong, { children: "skips and continues" }), " the loop. A common mistake is confusing the two — always remember: ", _jsx(_components.strong, { children: "break = exit" }), ", ", _jsx(_components.strong, { children: "continue = skip current" }), "."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain the 'goto' statement with its syntax, write a C program demonstrating each of 'goto', 'break', and 'continue', and discuss when each should be used." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 1. goto Statement — Syntax & Behavior The ", _jsx(_components.code, { children: "goto" }), " statement performs an ", _jsx(_components.strong, { children: "unconditional jump" }), " to a label defined within the same function. ", _jsx(_components.strong, { children: "Syntax:" }), " ", _jsx(_components.code, { children: "c goto label; // ... statements ... label: statement; " }), " - The ", _jsx(_components.code, { children: "label" }), " is any valid identifier followed by a ", _jsxs(_components.strong, { children: ["colon (", _jsx(_components.code, { children: ":" }), ")"] }), ". - ", _jsx(_components.code, { children: "goto" }), " can jump ", _jsx(_components.strong, { children: "forward" }), " (skip code) or ", _jsx(_components.strong, { children: "backward" }), " (create a loop). ### 🎯 2. break Statement — Behavior - Immediately ", _jsx(_components.strong, { children: "exits" }), " the innermost ", _jsx(_components.code, { children: "for" }), ", ", _jsx(_components.code, { children: "while" }), ", ", _jsx(_components.code, { children: "do-while" }), ", or ", _jsx(_components.code, { children: "switch" }), " block. - Control moves to the ", _jsx(_components.strong, { children: "first statement after" }), " the terminated construct. ### 🎯 3. continue Statement — Behavior - Skips the ", _jsx(_components.strong, { children: "remaining body" }), " of the current loop iteration. - In a ", _jsx(_components.code, { children: "for" }), " loop, control jumps to the ", _jsx(_components.strong, { children: "update expression" }), " (e.g., ", _jsx(_components.code, { children: "i++" }), "). - In ", _jsx(_components.code, { children: "while" }), "/", _jsx(_components.code, { children: "do-while" }), ", control jumps to the ", _jsx(_components.strong, { children: "condition check" }), ". --- ### 📝 Complete C Program Demonstrating All Three ", _jsx(_components.code, { children: "c #include <stdio.h> int main() { int i; // --- Demonstration of break --- printf("break example:\\n"); for (i = 1; i <= 10; i++) { if (i == 6) break; // Loop exits when i is 6 printf("%d ", i); } // Output: 1 2 3 4 5 printf("\\n\\n"); // --- Demonstration of continue --- printf("continue example:\\n"); for (i = 1; i <= 10; i++) { if (i 4 || i 7) continue; // Skip i = 4 and i = 7 printf("%d ", i); } // Output: 1 2 3 5 6 8 9 10 printf("\\n\\n"); // --- Demonstration of goto --- printf("goto example:\\n"); i = 1; loop_start: if (i <= 5) { printf("%d ", i); i++; goto loop_start; // Jump back to loop_start } // Output: 1 2 3 4 5 printf("\\n\\n"); // --- Practical use of goto: breaking nested loops --- printf("goto for nested loop break:\\n"); for (i = 1; i <= 5; i++) { int j; for (j = 1; j <= 5; j++) { if (i 3 && j 3) goto done; // Break out of BOTH loops printf("(%d,%d) ", i, j); } } done: printf("\\nStopped at i="3," j="3" using goto.\\n"); return 0; } " }), " ### 📝 When to Use Each | Statement | When to Use | Example Scenario | |---|---|---| | ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "break" }) }), " | When you need to ", _jsx(_components.strong, { children: "exit a loop or switch" }), " immediately based on a condition. | Search completed in an array — stop looping once the element is found. | | ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "continue" }) }), " | When you want to ", _jsx(_components.strong, { children: "skip certain iterations" }), " but keep the loop running. | Printing only ", _jsx(_components.strong, { children: "odd numbers" }), " from 1 to 100 — skip even numbers. | | ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "goto" }) }), " | When you need to ", _jsx(_components.strong, { children: "break out of multiple nested loops" }), " at once (where ", _jsx(_components.code, { children: "break" }), " only exits one level). | Searching in a 2D matrix — found the target, exit all loops immediately. | - Prefer ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "break" }) }), " and ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "continue" }) }), " over ", _jsx(_components.code, { children: "goto" }), " for everyday code — they keep logic ", _jsx(_components.strong, { children: "structured and readable" }), ". - Use ", _jsx(_components.code, { children: "goto" }), " ", _jsx(_components.strong, { children: "sparingly" }), ", only when no clean alternative (like a flag variable or function return) exists. - In ", _jsx(_components.code, { children: "switch" }), " statements, ", _jsxs(_components.strong, { children: ["forgetting ", _jsx(_components.code, { children: "break" })] }), " causes ", _jsx(_components.strong, { children: "fall-through" }), " — execution continues into the next ", _jsx(_components.code, { children: "case" }), " block, which is a common bug."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "2.3", children: [_jsx(MCQ, { questions: [{ "id": "eb9ee921-2d4c-4675-94fe-6abd87a0d62c", "q": "What is the primary purpose of the `break` statement when used inside a `switch` statement in C?", "options": ["To terminate the entire program.", "To terminate the current switch block.", "To exit the enclosing loop.", "To skip the next statement."], "answer": 1, "hint": "The break statement has a primary function when used inside a switch statement.", "explanation": "Inside a switch, the break statement terminates the execution of the switch block, preventing fall-through to subsequent cases." }, { "id": "c509bd4d-8277-4cb9-917b-2ed494cd49a5", "q": "What will be the output of the following code? `for(int i="1;" i<=5; i++) { if(i == 3) continue; printf("%d ", i); }`", "options": ["1 2 4 5", "1 2 3 4 5", "1 2", "1 2 3"], "answer": 0, "hint": "Consider the behavior of a loop that runs from 1 to 5.", "explanation": "When i is 3, the condition 'i is is 3' is true, and the continue statement skips the printf statement for that iteration. It does not terminate the loop." }, { "id": "1163f35c-2c50-4fee-bf2a-faf94a3f1906", "q": "Which branching statement in C is generally discouraged because it can lead to 'spaghetti code' and obscure control flow?", "options": ["break", "continue", "goto", "return"], "answer": 2, "hint": "Think about control flow that jumps across or out of structured blocks.", "explanation": "The goto statement can transfer control to any labeled statement within the same function, often making the program flow harder to follow and maintain." }, { "id": "c7303bd6-aaa2-48e2-bb32-c4862cc589c1", "q": "What will be the output of the following code? `for(int i="1;" i<=10; i++) { if(i == 5) break; printf("%d ", i); }`", "options": ["1 2 3 4 5 6 7 8 9 10", "1 2 3 4", "5", "1 2 3 4 5"], "answer": 3, "hint": "Observe the loop condition and the action taken when i reaches 5.", "explanation": "When i becomes 5, the break statement executes, immediately exiting the for loop. The loop's condition check (i< is 10) is not performed again." }, { "id": "bca6eb78-33f3-4c83-9691-71502dd7cddf", "q": "What is the effect of a `continue` statement inside a `for`, `while`, or `do-while` loop?", "options": ["It terminates the loop entirely.", "It jumps to the next iteration of the loop.", "It exits the current function.", "It goes to the beginning of the program."], "answer": 1, "hint": "Continue affects only the current iteration of a loop, not the loop itself.", "explanation": "The continue statement skips the remaining code in the current loop iteration and jumps to the loop's condition check for the next iteration." }, { "id": "5ef9f88f-0cbb-4765-9584-c1ac6c6d3a3a", "q": "Which of the following is the correct syntax for a `goto` statement and its corresponding label?", "options": ["goto label; ... label:", "goto label; ... label::", "goto: label ... label;", "goto: label ... label:"], "answer": 0, "hint": "Consider the syntax required to place a label for the goto statement.", "explanation": "The `goto` statement requires a label, which is an identifier followed by a colon, placed on a statement within the same function to mark a target for the jump." }, { "id": "af6e9832-da0a-4bf5-a772-4ff6250c054a", "q": "What will be the output of this code? `for(int i="1;" i<=3; i++) { for(int j="1;" j<=3; j++) { if(j == 2) break; printf("%d%d ", i, j); } }`", "options": ["11 21 31", "11 12 21 22 31 32", "11 12 13 21 22 23 31 32 33", "11 21 31"], "answer": 2, "hint": "Focus on which statement terminates the loop prematurely.", "explanation": "When j equals 2, the break statement is encountered inside the inner loop, causing immediate exit from the inner 'for j' loop. The outer loop continues normally." }, { "id": "1a0f38a0-51a0-4ec9-9950-93ffbe06e7d7", "q": "In the context of nested loops, what does the `break` statement do?", "options": ["It terminates all loops.", "It restarts the innermost loop.", "It exits the program.", "It breaks out of only the innermost loop."], "answer": 3, "hint": "Remember what 'break' does when encountered in a loop.", "explanation": "The break statement inside a nested loop only breaks out of the innermost loop that contains it. The outer loop continues to execute its remaining iterations." }, { "id": "0e25931d-544e-4bac-bc33-f12a15c6ba37", "q": "Which statement about the `goto` statement in C is true?", "options": ["It can jump to a label in a different function.", "It can only jump to a label within the same function.", "It is mandatory in all loops.", "It automatically closes open files."], "answer": 1, "hint": "The goto can jump forward, but it cannot leave the function.", "explanation": "A goto statement can only transfer control to a label that exists within the same function. It cannot jump into a different function or scope." }, { "id": "c49bc2f0-3910-41e9-b937-b7a1e5e3dc1d", "q": "What will be the output of this code? `for(int i="1;" i<=10; i++) { if(i == 7) continue; printf("%d ", i); }`", "options": ["1 2 3 4 5 6 8 9 10", "1 2 3 4 5 6 7 8 9 10", "7", "1 2 3 4 5 6"], "answer": 0, "hint": "Trace the loop: how many times does the condition check succeed?", "explanation": "The loop runs for i from 1 to 10. When i is 7, the continue statement executes, skipping the print. For all other values, the number is printed." }], topicId: "2.3" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Branching Statements", seoDesc: "Master Branching Statements with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "branching statements, branching statements notes, branching statements 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."); }