In C, besides if-else statements, there are several other types of conditional statements and constructs
used for decision-making. Here are some examples:
1. *Switch statements*:
```
switch (expression) {
case value1:
// code
break;
case value2:
// code
break;
default:
// code
```
Example:
```
int day = 2;
switch (day) {
case 1:
printf("Monday");
break;
case 2:
printf("Tuesday");
break;
default:
printf("Other day");
```
1. *Ternary operator* (Conditional Expression):
```
condition ? true_value : false_value
```
Example:
```
int x = 5;
int y = (x > 10) ? 20 : 10;
printf("%d", y); // Output: 10
```
1. *Loops with conditions*:
- *While loops*:
```
while (condition) {
// code
```
Example:
```
int i = 0;
while (i < 5) {
printf("%d", i);
i++;
```
```* **Do-while loops**:
```
```
do {
// code
} while (condition);
```
Example:
```
int i = 0;
do {
printf("%d", i);
i++;
} while (i < 5);
```
```* **For loops**:
```
```
for (init; condition; increment) {
// code
}
```
Example:
```
for (int i = 0; i < 5; i++) {
printf("%d", i);
```
1. *Conditional compilation* (using #if, #ifdef, #ifndef directives):
```
#if condition
// code
#endif
```
Example:
```
#define DEBUG 1
#if DEBUG
printf("Debug mode");
#endif
```
These are the main conditional statements and constructs used in C programming. Let me know if you
have any further questions or need more examples!
Here's a comprehensive list of conditional statements and constructs in C:
*Conditional Statements:*
1. If-else statements
2. Switch statements
3. Ternary operator (Conditional Expression)
4. Conditional compilation (#if, #ifdef, #ifndef)
*Loops with Conditions:*
1. While loops
2. Do-while loops
3. For loops
*Jump Statements:*
1. Break
2. Continue
3. Return
4. Goto
*Bitwise Operations:*
1. Bitwise AND (&)
2. Bitwise OR (|)
3. Bitwise XOR (^)
4. Bitwise NOT (~)
5. Left shift (<<)
6. Right shift (>>)
*Logical Operations:*
1. Logical AND (&&)
2. Logical OR (||)
3. Logical NOT (!)
*Comparison Operations:*
1. Equal to (==)
2. Not equal to (!=)
3. Greater than (>)
4. Less than (<)
5. Greater than or equal to (>=)
6. Less than or equal to (<=)
*Miscellaneous:*
1. Assert statements
2. Error handling (errno, perror)
Some additional constructs include:
*Preprocessor Directives:*
1. #define
2. #include
3. #ifdef
4. #ifndef
5. #if
6. #else
7. #elif
8. #endif
*Operator Precedence:*
Understanding operator precedence is crucial for writing correct conditional statements.
Would you like more information on any of these topics or C programming in general?
In C programming, `do-while`, `for`, `if`, etc. are classified as:
*Control Flow Statements* or *Control Structures*
More specifically:
- `if` and `if-else` are called *Conditional Statements*
- `switch` is called a *Multiway Branch Statement*
- `while`, `do-while`, and `for` are called *Looping Statements* or *Iteration Statements*
- `break` and `continue` are called *Jump Statements*
- `return` is called a *Function Return Statement*
- `goto` is called an *Unconditional Jump Statement*
Collectively, these statements are also referred to as:
*Flow Control Constructs*
*Control Flow Constructs*
*Program Control Statements*
*Execution Control Statements*
In the C standard (ISO/IEC 9899:2011), these statements are categorized under:
- 6.8 Statements
- 6.8.1 Labeled statements
- 6.8.2 Compound statements
- 6.8.3 Expression and null statements
- 6.8.4 Selection statements (if, switch)
- 6.8.5 Iteration statements (while, do-while, for)
- 6.8.6 Jump statements (break, continue, return, goto)
Understanding these control flow statements is essential for writing efficient and effective C programs.
Would you like more information on C programming concepts?
In C programming, `do-while`, `for`, `if`, etc. are classified as:
*Control Flow Statements* or *Control Structures*
More specifically:
- `if` and `if-else` are called *Conditional Statements*
- `switch` is called a *Multiway Branch Statement*
- `while`, `do-while`, and `for` are called *Looping Statements* or *Iteration Statements*
- `break` and `continue` are called *Jump Statements*
- `return` is called a *Function Return Statement*
- `goto` is called an *Unconditional Jump Statement*
Collectively, these statements are also referred to as:
*Flow Control Constructs*
*Control Flow Constructs*
*Program Control Statements*
*Execution Control Statements*
In the C standard (ISO/IEC 9899:2011), these statements are categorized under:
- 6.8 Statements
- 6.8.1 Labeled statements
- 6.8.2 Compound statements
- 6.8.3 Expression and null statements
- 6.8.4 Selection statements (if, switch)
- 6.8.5 Iteration statements (while, do-while, for)
- 6.8.6 Jump statements (break, continue, return, goto)
Understanding these control flow statements is essential for writing efficient and effective C programs.
Would you like more information on C programming concepts?
`do-while`, `for`, `if`, etc. are indeed classified as:
*Constructs* or *Statements* in C programming
More specifically, they are categorized as:
*Control Flow Constructs* or *Control Structures*
Here's a comprehensive list of constructs/statement categories in C:
*Control Flow Constructs:*
1. Conditional Statements
- If (`if`)
- If-else (`if-else`)
- Switch (`switch`)
2. Looping Statements
- While (`while`)
- Do-while (`do-while`)
- For (`for`)
3. Jump Statements
- Break (`break`)
- Continue (`continue`)
- Return (`return`)
- Goto (`goto`)
*Data Manipulation Constructs:*
1. Assignment Statements
- Simple assignment (`=`)
- Compound assignment (`+=`, `-=`, `*=`, `/=`, `%=`)
2. Arithmetic Statements
- Unary operators (`+`, `-`, `!`, `~`)
- Binary operators (`+`, `-`, `*`, `/`, `%`)
3. Bitwise Statements
- Bitwise AND (`&`)
- Bitwise OR (`|`)
- Bitwise XOR (`^`)
- Bitwise NOT (`~`)
*Function Constructs:*
1. Function definitions
2. Function calls
*Input/Output Constructs:*
1. Input statements (`scanf`)
2. Output statements (`printf`)
*Miscellaneous Constructs:*
1. Null statements (`;`)
2. Expression statements
3. Labeled statements (`label:`)
4. Compound statements (`{ ... }`)
These constructs are the building blocks of C programming.
Would you like more information on C programming concepts?
