logo
Icon

Logical Operators in C Programming (Types With Examples)

33 mins read

Last updated: 17 Feb 2025

1134 views

1.72%

  • Introduction
  • What Are Logical Operators in C?
  • Types of Logical Operators in C
  • Logical Operators in C Programming (With Examples)
  • Examples of Logical Operators in C Programming
  • Precedence and Associativity of Logical Operators in C
  • Short Circuit Evaluation of Logical Operators in C
  • Importance of Logical Operators in C Programming
  • Best Practices for Using C Logical Operators

Introduction

Logical operators in C programming are essential for controlling the flow of a program. They allow developers to handle multiple conditions effectively, making it easier to implement decision-making and logical operations in complex scenarios. 

Whether you're working with conditional statements or loops, learning logical operators is key to writing clean, efficient code. 

Here, we will understand how logical operators in C language work, their syntax, and practical examples.

What Are Logical Operators in C?

Logical operators in C are used to combine or negate conditions, helping control the flow of a program based on multiple conditions. They return 1 (true) or 0 (false) depending on whether the conditions are satisfied. 

C logical operators are commonly used in decision-making statements like if, while, and for loops for more complex conditions.

Types of Logical Operators in C

There are three types of logical operators in C language:

Operator Symbol

Operator Name

Description

&&

Logical AND

Returns true if both operands are true

||

Logical OR

Returns true if at least one of the conditions is true

!

Logical NOT

Reverses the truth value of the operand (negates the condition)

Logical Operators in C Programming (With Examples)

Let’s discuss the logical operators in C programming with example:

1. Logical AND Operator (&&)

The logical AND operator (&&) returns true only if both operands (conditions) are true. If either one of the conditions is false, the result is false. It is generally used when multiple conditions need to be satisfied at the same time.

Truth Table:

X

Y

X && Y

1

1

1

1

0

0

0

1

0

0

0

0

X && Y returns true (1) only if both X and Y are true (1). Otherwise, it returns false (0).

Syntax:

condition1 && condition2;

Example:

// C program for Logical AND Operator
#include <stdio.h>

// Driver code
int main()
{
    int a = 10, b = 20;

    if (a > 0 && b > 0) {
        printf("Both values are greater than 0\n");
    }
    else {
        printf("Both values are not greater than 0\n");
    }
    return 0;
}

Output:

Both values are greater than 0

Explanation: 

The condition a > 0 && b > 0 checks if both a and b are greater than 0. Since both conditions are true, the program prints "Both values are greater than 0".

2. Logical OR Operator (||)

The logical OR operator (||) returns true if at least one of the conditions is true. It only returns false if both conditions are false. This operator is often used when you need one condition to be met, but not necessarily all.

Truth Table:

X

Y

X || Y

1

1

1

1

0

1

0

1

1

0

0

0


X || Y returns true (1) if at least one of X or Y is true (1). It returns false (0) only when both are false (0).

Syntax:

condition1 || condition2;

Example:

// C program for Logical OR Operator
#include <stdio.h>

// Driver code
int main()
{
    int a = -10, b = 20;

    if (a > 0 || b > 0) {
        printf("At least one value is greater than 0\n");
    }
    else {
        printf("Neither value is greater than 0\n");
    }
    return 0;
}

Output:

At least one value is greater than 0

Explanation: 

The condition a > 0 || b > 0 checks if either a or b is greater than 0. Since b > 0 is true (even though a > 0 is false), the program prints "At least one value is greater than 0".

3. Logical NOT (!)

Description: The logical NOT operator (!) inverts the truth value of a condition. If the condition is true, ! makes it false, and if the condition is false, ! makes it true. It is used when you want to negate or reverse a condition.

Truth Table:

X

!X

1

0

0

1

!X inverts the value of X. If X is true (1), !X becomes false (0). If X is false (0), !X becomes true (1).

Syntax:

!condition;

Example:

// C program for Logical NOT Operator
#include <stdio.h>

// Driver code
int main()
{
    int a = 10;

    if (!(a < 0)) {
        printf("a is not a negative number\n");
    }
    else {
        printf("a is a negative number\n");
    }
    return 0;
}

Output:

a is not a negative number

Explanation: 

The condition !(a < 0) checks if a is not less than 0. Since a = 10 is not less than 0, the program negates the false condition and prints "a is not a negative number".

Examples of Logical Operators in C Programming

Below are examples of how logical operators are used in popular C programs, showing their application in real-world scenarios.

1. Checking for Even or Odd Numbers

This program checks if two numbers are both even or odd using the Logical AND (&&) operator.

// C program to check if both numbers are even or odd using Logical AND
#include <stdio.h>

int main() {
    int num1, num2;

    // Input two numbers
    printf("Enter two integers: ");
    scanf("%d %d", &num1, &num2);

    // Check if both numbers are even using Logical AND
    if (num1 % 2 == 0 && num2 % 2 == 0) {
        printf("Both numbers are even.\n");
    }
    else if (num1 % 2 != 0 && num2 % 2 != 0) {
        printf("Both numbers are odd.\n");
    }
    else {
        printf("One number is even and the other is odd.\n");
    }

    return 0;
}

Sample Output:

Enter two integers: 4 8
Both numbers are even.

2. Voting Eligibility Check

This program checks if a person is eligible to vote based on age and citizenship using the Logical OR (||) operator.

// C program to check voting eligibility using Logical OR
#include <stdio.h>

int main() {
    int age;
    char citizenship;

    // Input age and citizenship status
    printf("Enter your age: ");
    scanf("%d", &age);
    printf("Are you a citizen? (y/n): ");
    scanf(" %c", &citizenship);

    // Check if eligible to vote using Logical OR
    if (age >= 18 || citizenship == 'y') {
        printf("You are eligible to vote.\n");
    }
    else {
        printf("You are not eligible to vote.\n");
    }

    return 0;
}

Sample Output:

Enter your age: 19
Are you a citizen? (y/n): y
You are eligible to vote.

3. Number Validation

This program validates if a number entered by the user is negative using the Logical NOT (!) operator.

// C program to check if a number is not negative using Logical NOT
#include <stdio.h>

int main() {
    int number;

    // Input a number
    printf("Enter a number: ");
    scanf("%d", &number);

    // Check if number is not negative using Logical NOT
    if (!(number < 0)) {
        printf("The number is not negative.\n");
    } else {
        printf("The number is negative.\n");
    }

    return 0;
}

Sample Output:

Enter a number: -5
The number is negative.

4. Number Range Validation

This program checks if a number lies within a valid range using Logical AND (&&) and Logical OR (||) operators.

// C program to validate if a number is within a valid range
#include <stdio.h>

int main() {
    int num;

    // Input a number
    printf("Enter a number: ");
    scanf("%d", &num);

    // Check if the number is between 1 and 100 or equal to 200
    if ((num >= 1 && num <= 100) || num == 200) {
        printf("The number is within the valid range.\n");
    } else {
        printf("The number is not within the valid range.\n");
    }

    return 0;
}

Sample Output:

Enter a number: 200
The number is within the valid range.

Precedence and Associativity of Logical Operators in C

Precedence determines the order in which operators in C are evaluated in an expression, while associativity determines the order in which operators of the same precedence are evaluated. 

Logical operators have specific precedence levels and associativity rules that affect how expressions with multiple operators are evaluated.

C Logical Operators Precedence

The precedence of logical operators in C is as follows, from highest to lowest:

  • Logical NOT (!): Highest

  • Logical AND (&&): Middle

  • Logical OR (||): Lowest

Associativity of Logical Operators in C

C programming logical operators have left-to-right associativity, meaning when multiple operators with the same precedence appear in an expression, they are evaluated from left to right.

Short Circuit Evaluation of Logical Operators in C

Short-circuit evaluation means the behavior of logical operators when evaluating expressions. C uses short-circuiting with the Logical AND (&&) and Logical OR (||) operators. This means that the evaluation of an expression stops as soon as the result is determined, without necessarily evaluating all parts of the expression.

1. Short-Circuit Behavior of Logical AND (&&)

For the Logical AND (&&) operator, both operands must be true for the result to be true. If the left-hand side of the && is false, there’s no need to evaluate the right-hand side because the result will always be false.

Example:

#include <stdio.h>

int main() {
    int a = 0, b = 10;

    // Short-circuiting with Logical AND
    if (a != 0 && b > 5) {
        printf("Both conditions are true.\n");
    } else {
        printf("One or both conditions are false.\n");
    }

    return 0;
}

Output:

One or both conditions are false.

Explanation:

  • The first condition a != 0 is false (a = 0), so the && operator short-circuits and skips the evaluation of b > 5.

  • The program prints "One or both conditions are false."

2. Short-Circuit Behavior of Logical OR (||)

For the Logical OR (||) operator, the result is true if at least one operand is true. If the left-hand side of the || is true, there’s no need to evaluate the right-hand side because the result is already true.

Example:

#include <stdio.h>

int main() {
    int a = 5, b = 0;

    // Short-circuiting with Logical OR
    if (a > 0 || b != 0) {
        printf("At least one condition is true.\n");
    } else {
        printf("Both conditions are false.\n");
    }

    return 0;
}

Output:

At least one condition is true.

Explanation:

  • The first condition a > 0 is true, so the || operator short-circuits and skips the evaluation of b != 0.

  • The program prints "At least one condition is true."

Importance of Logical Operators in C Programming

  • Combining Multiple Conditions: Logical operators allow you to evaluate multiple conditions simultaneously in a single statement, making decision-making more efficient.

  • Simplifying Complex Logic: They help simplify complex logical expressions by combining multiple conditions, reducing the need for nested if statements.

  • Control Flow in Loops: Logical operators are used to control the execution of loops by evaluating multiple conditions, ensuring more flexible and dynamic loop behaviors.

  • Input Validation: They are used to validate inputs by checking if multiple criteria are met, such as checking if a number falls within a certain range.

  • Making Decisions Based on Multiple Factors: Logical operators enable programs to make decisions that depend on multiple factors, such as checking the status of several variables before executing a block of code.

  • Negating Conditions: The NOT (!) operator helps negate conditions, making it easier to work with opposite logic.

  • Improving Code Efficiency: By using logical operators, you can avoid redundant code, making your program more efficient and readable.

  • Conditional Expressions: They help in evaluating conditional expressions in if, else if, while, and for loops, allowing for better control over program behavior.

Best Practices for Using C Logical Operators

1. Use Short-Circuiting to Improve Efficiency

Take advantage of short-circuiting with && and || operators to prevent unnecessary evaluations. For example, place conditions that are quicker to evaluate or more likely to fail first in an expression.

2. Avoid Side Effects in Logical Expressions

Avoid using expressions with side effects (e.g., function calls or assignments) as part of logical operations. This can lead to unexpected behavior, especially when short-circuiting is involved.

3. Always Use Parentheses for Clarity

Use parentheses to make complex logical expressions clearer and avoid ambiguity, especially when mixing logical and relational operators.

if ((a > b) && (b < c)) {  // Clearer and safer

4. Simplify Complex Conditions

Avoid overly complex expressions with multiple logical operators. Break them into simpler, readable statements to improve code clarity and maintainability.

if (a > 0 && b < 10 && c == 5)  // Better to break down if conditions are long

5. Be Careful with Relational and Logical Operators Precedence

Understand the precedence of logical operators and how they interact with relational operators. Use parentheses to ensure the correct evaluation order, especially when combining multiple operators.

6. Use Logical NOT (!) Sparingly

Avoid overusing the logical NOT (!) operator, as it can make the logic harder to understand. Instead, consider rewriting the condition to remove the negation, if possible.

// Instead of
if (!(a > b))  // Not very clear
// Use
if (a <= b)  // Clearer

7. Test Edge Cases for Logical Expressions

Ensure that you test edge cases such as 0, negative numbers, and NULL pointers when using logical operators, especially in conditions that involve multiple checks.

Yes, logical operators can be combined with relational operators (<, >, ==, etc.) to create complex conditions.

Short-circuit evaluation means that the evaluation of logical operators stops as soon as the result is determined. For example, in a && b, if a is false, b is not evaluated because the result is already false.

Yes, logical operators are commonly used in if-else statements to evaluate multiple conditions and control program flow.

Yes, logical operators can be used with integers in C. Non-zero values are considered true, and zero is considered false.

Yes, logical operators are frequently used in loop conditions like while and for to combine multiple conditions and control the execution of the loop.

Updated - 17 Feb 202533 mins readPublished : 27 Nov 2024

Assignment Operators in C (All Types With Examples)

Bitwise Operators in C Language (All Types With Examples)

1.72%