Using Range in Switch Case in C++
In this article, you will learn about using the range in switch case in C++ with several examples.
Introduction:
In C++, the switch statement is a control flow statement that allows a variable to be tested for equality against a list of values. It provides a cleaner and more readable way to write multiple if-else statements when you need to compare a variable against different values.
The switch statement is often used with integral or enumerated types, and the case labels represent the possible values that the variable can take. However, it's important to note that C++ only allows constant integral expressions in case labels.
The range feature is not directly supported in traditional switch statements in C++. However, you can achieve similar functionality by using a series of if statements. Starting from C++17, you can use the if statement with the range-based if constexpr to create a more concise and expressive code structure.
Syntax:
It has the following syntax:
case low … high
Example:
Let us take an example to illustrate the use of range in switch case in C++.
#include <iostream>
int main() {
int value = 42;
// Using traditional switch statement
switch (value) {
case 1:
std::cout << "Value is 1" << std::endl;
break;
case 10:
case 20:
case 30:
std::cout << "Value is 10, 20, or 30" << std::endl;
break;
case 42:
std::cout << "Value is the meaning of life, the universe, and everything!" << std::endl;
break;
default:
std::cout << "Value is not matched with any case" << std::endl;
}
// Using if statements for range checking
if (1 <= value && value <= 5) {
std::cout << "Value is between 1 and 5" << std::endl;
} else if (6 <= value && value <= 10) {
std::cout << "Value is between 6 and 10" << std::endl;
} else if (11 <= value && value <= 15) {
std::cout << "Value is between 11 and 15" << std::endl;
} else {
std::cout << "Value is outside the specified ranges" << std::endl;
}
return 0;
}
Output:
Value is the meaning of life, the universe, and everything!
Value is outside the specified ranges
Explanation:
Switch Statement:
- The switch statement is a control flow statement in C++ that allows a variable to be tested against a list of values.
- It provides a concise way to handle multiple cases for a given variable.
Traditional Switch Statement:
- In the traditional switch statement, the program evaluates the value of a variable against predefined constant values specified by case labels.
- If a match is found, the corresponding block of code is executed, and the break statement ensures that the control flow exits the switch block.
Range-based If Statements:
- The code uses a series of if statements to check if the variable value falls within certain ranges.
- Each if statement specifies a range of values, and the code within the block is executed if the condition is true.
- The else clause handles cases where the variable does not fall within any of the specified ranges.
Compilation Error and constexpr:
- The code initially attempted to use if constexpr for compile-time evaluation of conditions. However, this approach requires that the condition being tested is a constant expression.
- The compilation error occurred because the variable value was not declared as constexpr and had a runtime value.
- The code was modified to use regular if statements without constexpr to resolve the error.
Print Statements:
- The program includes std::cout statements to print messages to the console based on the conditions met during execution.
- These messages provide information about the value of the variable and whether it falls within specific ranges or matches predefined cases.
Complexity Analysis:
Time Complexity:
- Definition: Time complexity represents the amount of time an algorithm takes to complete as a function of the size of the input.
- Notation: It is often expressed using big O notation (e.g., O(n), O(n^2), etc.), where "n" is the size of the input.
- Interpretation: Lower time complexity indicates better performance. For example, an algorithm with O(n) time complexity is generally more efficient than one with O(n^2) for large inputs.
Space Complexity:
- Definition: Space complexity refers to the amount of memory space an algorithm uses in relation to the size of the input.
- Notation: Similar to time complexity, it is often expressed using big O notation (e.g., O(1), O(n), etc.).
- Interpretation: Lower space complexity is generally desirable, as it means the algorithm uses less memory. Algorithms with O(1) space complexity use a constant amount of memory regardless of input size.
Approach 1: Using if Statements with Logical OR
Let us take an example to illustrate if statements with Logical OR for range checking in C++.
Program:
#include <iostream>
int main() {
int value = 42;
// Using if statements with logical OR for range checking
if (1 <= value && value <= 5) {
std::cout << "Value is between 1 and 5" << std::endl;
} else if (6 <= value && value <= 10) {
std::cout << "Value is between 6 and 10" << std::endl;
} else if (11 <= value && value <= 15) {
std::cout << "Value is between 11 and 15" << std::endl;
} else {
std::cout << "Value is outside the specified ranges" << std::endl;
}
return 0;
}
Output:
Value is outside the specified ranges
Explanation:
Variable Initialization:
- In this example, the code initializes an integer variable value with the value 42. This variable represents the input data that will be checked against different ranges.
Range Checking with if Statements:
- The code uses a series of if statements with logical OR (||) to perform range checking on the variable value.
- Each if statement checks if the value falls within a specific range defined by the conditions. For example:
- If the value is between 1 and 5 (inclusive), a corresponding message is printed.
- If the value is between 6 and 10 (inclusive), a different message is printed.
- If the value is between 11 and 15 (inclusive), another message is printed.
- If none of the above conditions are satisfied (i.e., the value is outside the specified ranges), a default message is printed using the else clause.
Output Messages:
- Depending on the outcome of the range checks, different messages are printed to the console using std::cout.
- The messages provide information about the value of the variable and whether it falls within specific ranges or if it's outside the specified ranges.
Return Statement:
- The return 0; statement indicates the successful completion of the main() function. In C++, returning 0 from the main() usually indicates a successful program execution.
Execution Flow:
- The program flow is determined by the conditions in the if statements. Only the block of code corresponding to the first true condition is executed. Once a true condition is found, the program skips the remaining else if and else blocks.
Complexity Analysis:
Time Complexity:
- The time complexity of this approach is relatively straightforward to analyze. In each if statement, there are simple conditional checks (inequalities) that take constant time. Therefore, the time complexity is O(1) for each if statement.
- In the worst case, the program evaluates each condition sequentially until it finds the first true condition. Therefore, the overall time complexity is still O(1) because the number of conditions is constant and does not depend on the input size.
Space Complexity:
- The space complexity of this approach is minimal. It uses a constant amount of memory for the integer variable value, and the if statements themselves do not introduce additional memory requirements proportional to the input size.
- Therefore, the space complexity is O(1), indicating constant space usage regardless of the input size.
Approach 2: Using a Function for Range Checking
Let us take an example to illustrate the use of a function for range checking in C++.
Program:
#include <iostream>
bool isInRange(int value, int low, int high) {
return (low <= value && value <= high);
}
int main() {
int value = 42;
// Using a function for range checking
if (isInRange(value, 1, 5)) {
std::cout << "Value is between 1 and 5" << std::endl;
} else if (isInRange(value, 6, 10)) {
std::cout << "Value is between 6 and 10" << std::endl;
} else if (isInRange(value, 11, 15)) {
std::cout << "Value is between 11 and 15" << std::endl;
} else {
std::cout << "Value is outside the specified ranges" << std::endl;
}
return 0;
}
Output:
Value is outside the specified ranges
Explanation:
Function for Range Checking (isInRange):
- In this example, the code defines a function called isInRange that takes three parameters: value (the value to be checked), low, and high (the lower and upper bounds of the range).
- The function returns a boolean value (true or false) depending on whether the value is within the specified range (low to high, inclusive).
Variable Initialization:
- The code initializes an integer variable value with the value 42. This variable represents the input data that will be checked against different ranges.
Conditional Statements Using the Function:
- The main function uses a series of if and else if statements to check whether the value falls within different ranges. It calls the isInRange function for each range.
- If isInRange returns true for a particular range, a corresponding message is printed using std::cout.
- If none of the ranges match, the else block prints a default message indicating that the value is outside the specified ranges.
Output Messages:
- Depending on the outcome of the range checks, different messages are printed to the console using std::cout.
- The messages provide information about the value of the variable and whether it falls within specific ranges or if it's outside the specified ranges.
Return Statement:
- The return 0; statement indicates the successful completion of the main() function. In C++, returning 0 from the main() usually indicates a successful program execution.
Complexity Analysis:
Time Complexity:
Function for Range Checking (isInRange): The time complexity of the function isInRange is O(1) because it involves simple arithmetic operations and logical comparisons. The time taken does not depend on the input size.
Conditional Statements using the Function: The if statements in the main function involve calling the isInRange function, which is O(1) for each call.
The overall time complexity is O(1) because the number of function calls and operations in the code is constant and not dependent on the input size.
Space Complexity:
Variables: The space complexity is O(1) for variables used in the code. The primary variable is value, and its memory usage is constant.
Function for Range Checking (isInRange): The function isInRange introduces a constant amount of space complexity. It has parameters (value, low, and high) and local variables, but their memory usage is not proportional to the input size.
The overall space complexity is O(1) because the memory usage is constant and does not grow with the input size.
Approach 3: using a switch statement
Let us take an example to illustrate the use of a switch statement for range checking in C++.
Program:
#include <iostream>
void checkRange(int value) {
switch (value) {
case 1 ... 5:
std::cout << "Value is between 1 and 5" << std::endl;
break;
case 6 ... 10:
std::cout << "Value is between 6 and 10" << std::endl;
break;
case 11 ... 15:
std::cout << "Value is between 11 and 15" << std::endl;
break;
default:
std::cout << "Value is outside the specified ranges" << std::endl;
}
}
int main() {
int value = 42;
// Using a switch statement for range checking
checkRange(value);
return 0;
}
Output:
Value is outside the specified ranges
Explanation:
checkRange Function:
- In this example, the code defines a function called checkRange that takes an integer parameter value.
- Inside the function, a switch statement is used with range expressions (introduced in C++17). Each case label represents a range of values.
Switch Statement with Range Expressions:
- The switch statement evaluates the value of the input parameter.
- Each case label specifies a range using the range expression (1 ... 5, 6 ... 10, etc.).
- If the value falls within a specified range, the corresponding block of code is executed.
Default Case:
- The default case handles values that do not match any of the specified ranges. It prints a message indicating that the value is outside the specified ranges.
Main Function:
- The main function initializes an integer variable value with the value 42.
- After that, it is called the checkRange function to perform the range checking.
Complexity Analysis:
Time Complexity:
Switch Statement: The time complexity of the switch statement is generally O(1).
In this case, the switch statement uses range expressions (case 1 ... 5: etc.), but the evaluation of these ranges is still constant time.
Function Call (checkRange): The function called itself (checkRange(value)) is a constant time operation.
The overall time complexity is O(1) because the number of cases in the switch statement is fixed, and the execution time does not depend on the input size.
Space Complexity:
Variables: The space complexity is O(1) because the amount of memory used by variables is constant. In this case, there's only one variable (value) used in the main function.
Switch Statement: The switch statement does not introduce additional space complexity proportional to the input size. It is a control structure that doesn't use extra memory based on the input.
Function Call (checkRange): The function call introduces a constant amount of memory overhead, including the function parameters and local variables.
The overall space complexity is O(1) because the memory usage does not depend on the input size, and the program uses a fixed amount of memory.