What are Programming Languages?Types of softwaresC IntroductionC HistoryC FeaturesC ApplicationsCharacter set, ASCII TableC Programming Language Standard
Turbo C++ editor installationExploring the Turbo C++ EnvironmentC Hellow world programHow a C Program ExecuteCompilation process in C
C #include statementC Displaying OutputC Reading input from the terminalC Data typesC VariablesC Variable Naming ConventionsC ConstantsC Identifiers & Naming RulesC LiteralsC CommentsC KeywordsC Type QualifiersC TokensC Format SpecifiersC Escape SequencesC preprocessorASCII value in CStatic in CWhat are Compiler ErrorsWhat are Compiler WarningsWhat are Linker ErrorsWhat are Runtime ErrorsWhat are Logical ErrorsCompile time vs RuntimeC program to displays your name  C - Basics Practice Test.1  C - Basics Practice Test.2  C - Basics Practice Test.3  C - Basics Practice Test.4  C - Basics Practice Test.5
C Arithmetic OperatorsC Assignment OperatorsC Relational OperatorsC Logical OperatorsC Increment & Decrement OperatorsC Conditional or Ternary OperatorC Bitwise OperatorsC Type CastingC Sizeof OperatorC Comma OperatorC Operators Precedence and AssociativityC ExpressionsC Evaluation of Expressions  C - Operators Practice Test.1  C - Operators Practice Test.2  C - Operators Practice Test.3
Input-Output Library FunctionsNon-Formatted Input and OutputCharacter Oriented Library FunctionsFormatted Library FunctionsMathematical Library Functions  C - Input-Output Functions Practice Test.1
C ifC if-elseC nested if-elseC if-else-ifC switch-caseC if vs switch-caseC LoopsC while loopC do-while loopC while vs do-whileC for loopC for vs WhileC Nested LoopsC Jump Control structuresC break statementC continue statementC goto statementC continue vs goto statementC return statementC goto vs return statement  C - Control Statements Practice Test.1  C - Control Statements Practice Test.2  C - Control Statements Practice Test.3
C FunctionsC Advantages of Using FunctionsC Function PrototypeC Basic Function DesignsC Programs Using FunctionsC ScopeC Local Variable and Global VariableWhy int main() return 03 Place to declare functionsC RecursionC Base Condition in RecursionC Iteration vs RecursionC Stack Overflow Error in RecursionC Nested functionsC Variable Length Number of ArgumentsC Parameter Passing – Call by value and Call by RefC Passing Strings to FunctionsImplementation of square() functionImplementation of factorial() functionImplementation of pow(x, n) functionImplementation of reverse(int) functionImplementation of countDigits(int) functionImplementation of palindrome(int) functionImplementation of primeNumber(int) function  C - Functions Practice Test.1  C - Functions Practice Test.2
What is Array?One dimensional ArrayAccessing element of 1D arrayReading and displaying elementsPrograms on 1D ArraysTwo Dimensional ArrayAccessing Element of 2D ArrayReading and Displaying ElementsPrograms on 2D ArraysPassing 1D arrays to FunctionsPassing 2D arrays to FunctionsThree Dimensional Array  C - Array Practice Test.1  C - Array Practice Test.2
Strings in CStoring StringsC The String DelimiterC String Literals (String Constants)C Strings vs. CharactersC Declaring and Initialization of StringsC Strings and the Assignment OperatorC String Input Functions / Reading StringsC String Output Functions / Writing StringsC fscanf() and fprintf() FunctionsC Single Character Library FunctionsC String Manipulation Library FunctionsC Programs Using Character ArraysC Array of StringsC Programs Using Array of Strings  C - Strings Practice Test.1  C - Strings Practice Test.2
Pointers in CUnderstanding Memory AddressesDeclare and Initialize Pointer VariablePointer Operators in Csizeof() Operator in CPointer Advantages and DisadvantagesDereferencing/Redirecting Pointer VariablesPointer Declaration versus RedirectionConst Pointer in CVoid Pointer in CNull Pointer in CC Pointer CompatibilityArray of PointersPointer to PointerPointer ArithmeticC Functions Returning PointersC Pointer to FunctionPointers and One-Dimensional ArrayPointers and Two-Dimensional ArrayPointers and StringsDynamic Memory Allocation Functions  C - Pointers Practice Test.1  C - Pointers Practice Test.2  C - Pointers Practice Test.3
Previous
Next

C - Logical Operators

Logical operators in C are used to perform logical operations on Boolean values (true or false) or to combine the results of relational and equality operators. These operators allow you to make decisions based on multiple conditions and perform more complex logical evaluations. The three main logical operators in C are:

1. Logical AND (&&) Operator:

The Logical AND (&&) operator in C is used to combine two or more conditions in a way that the overall result is true ('1') only if all the individual conditions are true. If any of the individual conditions is false ('0'), the overall result is false. It's a binary operator because it operates on two operands (conditions) and returns a Boolean result.

Key points about the Logical AND (&&) operator:

  • It is used for making decisions based on multiple conditions where all conditions must be true for the overall condition to be true.
  • It returns true (1) only if all the conditions on both sides of && are true. If any condition is false, the result is false (0).
  • It is often used in if statements and while combining multiple relational or logical conditions.

Here's a breakdown of how the Logical AND (&&) operator evaluates conditions:

  • If condition1 && condition2, both condition1 and condition2 must be true for the entire expression to be true.
  • If condition1 is false, the evaluation stops, and the result is false (0) without checking condition2 because there's no need to check further; the overall result is already false.

Let's illustrate the Logical AND (&&) operator with a step-by-step example. 


#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    if (a > 0 && b > 0) {
        printf("Both a and b are greater than 0\n");
    } else {
        printf("At least one of a and b is not greater than 0\n");
    }

    return 0;
}

In this example, we have two integer variables, a and b, with the values 5 and 3, respectively. We use the Logical AND (&&) operator to check if both a and b are greater than 0. Here's how the program works step by step:

  • int a = 5; initializes the variable a with the value 5, and int b = 3; initializes the variable b with the value 3.
  • The if statement checks the condition a > 0 && b > 0. It uses the Logical AND (&&) operator to combine two conditions:
    • a > 0 checks if a is greater than 0, which is true (5 is indeed greater than 0).
    • b > 0 checks if b is greater than 0, which is also true (3 is greater than 0).
  • Since both conditions are true, the entire condition a > 0 && b > 0 is true.
  • As a result, the code block inside the if statement is executed.
  • The program prints "Both a and b are greater than 0" to the console.

So, the output of this program is: 


Both a and b are greater than 0

This demonstrates how the Logical AND (&&) operator works by requiring both conditions to be true for the entire condition to be true.

2. Logical OR (||) Operator:

The Logical OR (||) operator in C is used to combine two or more conditions in a way that the overall result is true (1) if at least one of the individual conditions is true. If all individual conditions are false (0), the overall result is false (0). It's a binary operator because it operates on two operands (conditions) and returns a Boolean result.

Key points about the Logical OR (||) operator:

  • It is used for making decisions based on multiple conditions where at least one condition needs to be true for the overall condition to be true.
  • It returns true (1) if at least one of the conditions on either side of || is true. If all conditions are false, the result is false (0).
  • It is often used in if statements and while combining multiple relational or logical conditions.

Here's a breakdown of how the Logical OR (||) operator evaluates conditions:

  • If condition1 || condition2, either condition1 or condition2 (or both) must be true for the entire expression to be true.
  • If condition1 is true, the evaluation stops, and the result is true (1) without checking condition2 because there's no need to check further; the overall result is already true.

Let's illustrate the Logical OR (||) operator with a step-by-step example. 


#include <stdio.h>

int main() {
    int x = 5;
    int y = -3;

    if (x > 0 || y > 0) {
        printf("At least one of x and y is greater than 0\n");
    } else {
        printf("Neither x nor y is greater than 0\n");
    }

    return 0;
}

In this example, we have two integer variables, x and y, with the values 5 and -3, respectively. We use the Logical OR (||) operator to check if at least one of x and y is greater than 0. Here's how the program works step by step:

  1. int x = 5; initializes the variable x with the value 5, and int y = -3; initializes the variable y with the value -3.
  2. The if statement checks the condition x > 0 || y > 0. It uses the Logical OR (||) operator to combine two conditions: x > 0 checks if x is greater than 0, which is true (5 is indeed greater than 0). y > 0 checks if y is greater than 0, which is false (-3 is not greater than 0).
  3. Since at least one of the conditions (x > 0) is true, the entire condition x > 0 || y > 0 is true.
  4. As a result, the code block inside the if statement is executed.
  5. The program prints "At least one of x and y is greater than 0" to the console.

So, the output of this program is: 


At least one of x and y is greater than 0

This demonstrates how the Logical OR (||) operator works by requiring at least one of the conditions to be true for the entire condition to be true.

3. Logical NOT (!) Operator:

The Logical NOT (!) operator in C is a unary operator, meaning it operates on a single operand or condition. It is used to reverse the logical state of its operand. If the operand is true, it becomes false, and if it is false, it becomes true.

Key points about the Logical NOT (!) operator:

  • It is used to negate or reverse the truth value of a condition or expression.
  • It returns true (1) if the operand is false (0) and returns false (0) if the operand is true (1).
  • It is often used to create conditions that check for the absence or negation of a specific state.

Here's a breakdown of how the Logical NOT (!) operator works:

  • If !condition, it negates the value of condition. If condition is true (1), then !condition is false (0). If condition is false (0), then !condition is true (1).

Let's illustrate the Logical NOT (!) operator with a step-by-step example. 


#include <stdio.h>

int main() {
    int isSunny = 0; // 0 represents false

    if (!isSunny) {
        printf("It's not sunny today.\n");
    } else {
        printf("It's sunny today.\n");
    }

    return 0;
}

In this example, we have a single integer variable isSunny initialized with the value 0, which represents false (not sunny). We use the Logical NOT (!) operator to check if isSunny is not true (not sunny). Here's how the program works step by step:

  1. int isSunny = 0; initializes the variable isSunny with the value 0, which represents false (not sunny).
  2. The if statement checks the condition !isSunny. It uses the Logical NOT (!) operator to reverse the logical state of isSunny. Since isSunny is 0, the Logical NOT operator reverses it to 1, which represents true (sunny).
  3. The condition !isSunny is now true (1).
  4. As a result, the code block inside the if statement is executed.
  5. The program prints "It's not sunny today." to the console.

So, the output of this program is: 


It's not sunny today.

This demonstrates how the Logical NOT (!) operator works by reversing the logical state of a condition. It's commonly used when you want to check if something is "not true" or "not the case." In this example, we checked if it's "not sunny" based on the value of isSunny.

Logical operators are essential when you need to make decisions based on complex conditions or when you want to control the flow of your program based on multiple factors.

Previous
Next