Logical Operators in C
Logical operators in C evaluate to either True or False. Logical operators are typically used with Boolean operands.
The logical AND operator (&&) and the logical OR operator (||) are both binary in nature (require two operands). The logical NOT operator (!) is a unary operator.
Since C treats “0” as False and any non-zero number as True, any operand to a logical operand is converted to a Boolean data.
Here is a table showing the logical operators in C −
Operator | Description | Example |
---|---|---|
&& | Called Logical AND operator. If both the operands are non-zero, then the condition becomes true. | (A && B) |
|| | Called Logical OR Operator. If any of the two operands is non-zero, then the condition becomes true. | (A || B) |
! | Called Logical NOT Operator. It is used to reverse the logical state of its operand. If a condition is true, then Logical NOT operator will make it false. | !(A) |
The result of a logical operator follows the principle of Boolean algebra. The logical operators follow the following truth tables.
Logical AND (&&) Operator
The && operator in C acts as the logical AND operator. It has the following truth table −
a | b | a&&b |
---|---|---|
true | true | True |
true | false | False |
false | true | False |
false | false | False |
The above truth table shows that the result of && is True only if both the operands are True.
Logical OR (||) Operator
C uses the double pipe symbol (||) as the logical OR operator. It has the following truth table −
a | b | a||b |
---|---|---|
true | true | True |
true | false | True |
false | true | true |
false | false | false |
The above truth table shows that the result of || operator is True when either of the operands is True, and False if both operands are false.
Logical NOT (!) Operator
The logical NOT ! operator negates the value of a Boolean operand. True becomes False, and False becomes True. Here is its truth table −
A | !a |
---|---|
True | False |
False | True |
Unlike the other two logical operators && and ||, the logical NOT operator ! is a unary operator.
Example 1
The following example shows the usage of logical operators in C −
#include <stdio.h>
int main(){
int a = 5;
int b = 20;
if (a && b){
printf("Line 1 - Condition is true\n" );
}
if (a || b){
printf("Line 2 - Condition is true\n" );
}
/* lets change the value of a and b */
a = 0;
b = 10;
if (a && b){
printf("Line 3 - Condition is true\n" );
} else {
printf("Line 3 - Condition is not true\n" );
}
if (!(a && b)){
printf("Line 4 - Condition is true\n" );
}
return 0;
}
Output
Run the code and check its output −
Line 1 - Condition is true
Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true
Example 2
In C, a char type is a subset of int type. Hence, logical operators can work with char type too.
#include <stdio.h>
int main(){
char a = 'a';
char b = '\0'; // Null character
if (a && b){
printf("Line 1 - Condition is true\n" );
}
if (a || b){
printf("Line 2 - Condition is true\n" );
}
return 0;
}
Output
Run the code and check its output −
Line 2 - Condition is true
Logical operators are generally used to build a compound boolean expression. Along with relational operators, logical operators too are used in decision-control and looping statements in C.
Example 3
The following example shows a compound Boolean expression in a C program −
#include <stdio.h>
int main(){
int phy = 50;
int maths = 60;
if (phy < 50 || maths < 50){
printf("Result:Fail");
}
else {
printf("Result:Pass");
}
return 0;
}
Output
Result:Pass
Example 4
The similar logic can also be expressed using the && operator as follows −
#include <stdio.h>
int main(){
int phy = 50;
int maths = 60;
if (phy >= 50 && maths >= 50){
printf("Result: Pass");
}
else {
printf("Result: Fail");
}
return 0;
}
Output
Run the code and check its output −
Result: Pass
Example 5
The following C code employs the NOT operator in a while loop −
#include <stdio.h>
int main(){
int i = 0;
while (!(i > 5)){
printf("i = %d\n", i);
i++;
}
return 0;
}
Output
In the above code, the while loop continues to iterate till the expression ”!(i > 5)” becomes false, which will be when the value of “i” becomes more than 5.
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
C has bitwise counterparts of the logical operators such as bitwise AND (&), bitwise OR (|), and binary NOT or complement (~) operator.