## Chapter 5: Control Structures So far we have: - Stored data - Performed calculations - Made comparisons Now the most important question arises: How does a program make decisions? How does it perform different actions based on different conditions? This is where Control Structures come in. ### What are Control Structures? (Simple Language) Control structures give the program the power to: - Make decisions based on conditions - Repeat a task multiple times In simple terms: Control structure = the brain of the program ### if–else statement (Decision Making) if–else is used when we need to say: “If this condition is true, do this, otherwise do something else.” **Example: Temperature Check** C++ ``` #include <iostream> using namespace std; int main() { int temperature = 25; if (temperature > 30) { cout << "It's very hot outside!"; } else if (temperature > 20) { cout << "The weather is nice outside!"; } else if (temperature > 10) { cout << "It's a little cool outside!"; } else { cout << "It's quite cold outside!"; } return 0; } ``` Now let's understand this in human language: **Step 1: if** C++ ``` if (temperature > 30) ``` - This is checked first. - If the temperature is greater than 30 → The first message will be printed. **Step 2: else if** C++ ``` else if (temperature > 20) ``` - This will only be checked if the above if condition is false. - If the temperature is between 21–30 → This block will execute. **Step 3: Second else if** C++ ``` else if (temperature > 10) ``` - If the temperature is between 11–20 - This condition will be true. **Step 4: else** C++ ``` else ``` - When none of the above conditions are true - i.e., temperature is 10 or less This is the default case. **How does the program flow?** Program: - Executes from top to bottom - As soon as a condition is found to be true → It executes that block - And skips the rest **Important Beginner Points** - Conditions are always in round brackets ( ) - Code blocks are in curly braces { } - There is no condition with `else` Real-Life Examples - Exam result (pass/fail) - Age check (minor/adult) - Login system - Weather report `if-else` is used naturally everywhere. ### Switch Statement: When we have: - A variable - And its fixed values ​​(like 1, 2, 3, 4…) Instead of writing `if-else` repeatedly, a `switch` statement is cleaner and more readable. **When to use `switch`?** When the condition is: - `==` (equal to or not) - Values ​​are predetermined For example: - Day number - Menu option - User's choice **Example: Day Finder** C++ ``` #include <iostream> using namespace std; int main() { int day = 3; switch (day) { case 1: cout << "Monday"; break; case 2: cout << "Tuesday"; break; case 3: cout << "Wednesday"; break; case 4: cout << "Thursday"; break; case 5: cout << "Friday"; break; default: cout << "Weekend!"; } return 0; } ``` Now let's understand this in simple terms **`switch (day)`** C++ ``` switch (day) ``` Meaning: Look at the value of `day` and decide which case to execute **`case`** `case 3:` C++ ``` cout << "Wednesday"; break; ``` Meaning: - If `day == 3` - Then print "Wednesday" **Why is `break` necessary?** The function of `break` is: “Stop here, don't execute the next cases.” If `break` is not used, the program will: - execute the next case as well - and then the one after that This is called fall-through. **What happens without `break`?** C++ ``` case 3: cout << "Wednesday"; case 4: cout << "Thursday"; ``` The output will be: C++ ``` WednesdayThursday ``` Which is not what we want. **default case** C++ ``` default: cout << "Weekend!"; ``` - When none of the cases match, - the default case is executed. It is optional, but considered good practice. **Switch vs if–else** | Switch | if–else | | :--- | :--- | | Fixed values | Complex conditions | | Clean & readable | Flexible | | Fast decision | Any logic possible | **Beginner Tips** - In a switch statement, you can use: - int - char - enum (In C++, string is also supported in modern compilers) - In a switch statement: - operators like <, > do not work - Use `break` after each case (unless fall-through is desired) Remember in one line: More equal comparisons → switch Complex conditions → if–else ## Conclusion In this article, we explored the core concepts of Explore blog under C++ - Control Structures. Understanding these fundamentals is crucial for any developer looking to master this topic. ## Frequently Asked Questions (FAQs) **Q: What is Explore blog under C++ - Control Structures?** A: Explore blog under C++ - Control Structures is a fundamental concept in this programming language/topic that allows developers to perform specific tasks efficiently. **Q: Why is Explore blog under C++ - Control Structures important?** A: It helps in organizing code, improving performance, and implementing complex logic in a structured way. **Q: How to get started with Explore blog under C++ - Control Structures?** A: You can start by practicing the basic syntax and examples provided in this tutorial. **Q: Are there any prerequisites for Explore blog under C++ - Control Structures?** A: Basic knowledge of programming logic and syntax is recommended. **Q: Can Explore blog under C++ - Control Structures be used in real-world projects?** A: Yes, it is widely used in enterprise-level applications and software development. **Q: Where can I find more examples of Explore blog under C++ - Control Structures?** A: You can check our blog section for more advanced tutorials and use cases. **Q: Is Explore blog under C++ - Control Structures suitable for beginners?** A: Yes, our guide is designed to be beginner-friendly with clear explanations. **Q: How does Explore blog under C++ - Control Structures improve code quality?** A: By providing a standardized way to handle logic, it makes code more readable and maintainable. **Q: What are common mistakes when using Explore blog under C++ - Control Structures?** A: Common mistakes include incorrect syntax usage and not following best practices, which we've covered here. **Q: Does this tutorial cover advanced Explore blog under C++ - Control Structures?** A: This article covers the essentials; stay tuned for our advanced series on this topic.