Logical Operators In C++ | Use, Precedence & More (With Examples)

Logical operators are an essential component of programming languages, including C++. They allow programmers to manipulate and evaluate conditions based on Boolean logic, resulting in more complex and flexible decision-making within their programs. The logical operators in C++ are of three primary types, i.e., AND, OR, and NOT. These operators enable the combination and negation of conditions, enhancing the control flow and overall functionality of the code.

In this article, we will discuss these operators in C++ in proper detail, with the help of examples and visual elements.

What Are Operators In C++?

Operators are special characters or symbols that are frequently used in C++ programming and other languages in order to change data in several different ways. Such as subtraction, division, addition, and multiplication. It is possible to change characters, floating-point numbers, and integers using these operators.

Even though we will focus on logical operators in C++ for the scope of this article, the types of operators include:

Arithmetic Operators: They carry out fundamental arithmetic operations like addition (+), subtraction (-), multiplication (*), and division (/).

Logical Operators: These operators are used to check the truth value of an expression. They facilitate the combining and modifying of Boolean values. One can think of && as the logical AND, || as the logical OR, and! as the logical NOT.

Relational Operators: These are employed to compare two values and deliver a true or false Boolean result. It includes == (equality),!= (inequality), > (greater than), <(less than), >= (greater than or equal to), and <= (less than or equal to).

Bitwise Operators: These operators are used to change a variable/ value's individual bits. The only data types that allow bitwise operations are characters and integers. It includes & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), << (bitwise left shift), and >> (bitwise right shift).

Assignment Operators: They facilitate the assignment of values to variables. A variable serves as the assignment operator's left-side operand, and a value serves as its right-side operand. They include = (simple assignment), += (additive assignment), -= (subtractive assignment), *= (multiplicative assignment), /= (division assignment), %= (modulus assignment), etc.

Conditional Operator: We use these operators to make decisions in response to conditions. The symbol represents it?, and its syntax is: (condition) ? expression1 : expression2;

Increment and Decrement Operators: These are used to increase or decrease the value of a variable. They include ++ (increment), -- (decrement), ++i (prefix increment), i++ (postfix increment), --i (prefix decrement), and i-- (postfix decrement).

Now that we have an idea about the other types of operators in C++ let's continue with the logical operators which play a crucial role in the manipulation of data.

Introduction To Logical Operators In C++

The use of logical operators in C++ is prevalent in programming structures like conditional statements and loops, where they enable the program to evaluate expressions and make decisions based on their true values. Logical operators are the most suitable choice for confirming the accuracy of two or more comparing operations. The output of logical operators in C++ varies depending on the type of operator used and the truth value of one or both operands.

Types Of Logical Operators In C++ With Example Program

As mentioned before, there are 3 logical operators in C++. Let's take a look at their syntaxes in order to better grasp where these operators frequently appear in code. 

In the following sections, we will take a closer look at these types with the help of program examples.

Logical AND (&&) Operator In C++

The logical AND operator (&&) in C++ is a binary operator that delivers true when both of its operands are true and false when one of them is false. It is necessary for the operands to be of the Boolean type, which means that they can only be either true or false. The logical AND(&&) operator in C++ is commonly implemented in decision-making processes involving multiple conditions, such as in conditional statements, loops, and other control flow statements.

The truth table of the logical AND(&&) operator in C++:

The syntax of the logical AND (&&) operator in C++ is:

operand1 && operand2

Here, 

• Operand1 is the left-hand side operand, and 2 is the right-hand side operand.
• The AND operator && is placed centrally, and it compares the two operands to give a result.

Now we will see an example to better understand how we can use the AND(&&) operator in C++:

Output:

You can drive.

Explanation:

In this example,

1. We begin by including the iostream library and the namespace std function.
2. Then, in the main function, we declare a variable called age and initialize it with a value of 18.
3. Next, we declare and initialize a boolean variable hasLicense.
4. An if...else statement is then initiated, where we use the && operator to check if two conditions are true.
5. These are if age >= 18 and is hasLicense. If both conditions are true, the code prints "You can drive."
6. Otherwise, it prints, "You cannot drive." Since here the age is 18, it’s printed that you can drive.
7. We are using the cout command to print the output in the window and finally close the program with the return 0 statement.

Logical OR (||) Operator In C++

The binary logical OR operator || in C++ accepts two operands and delivers a boolean value of true if at least one of them evaluates to true and false otherwise. Whenever you need to assess multiple conditions and trigger a response if at least one of them is true, employing the logical OR operator is a beneficial approach.

The OR operator performs similar operations to the AND operator. However, there is a key difference which is that the latter evaluates to true if either the left or right operand is true. Whereas the OR operator returns false results only when both operands are false.

The truth table of the logical OR(||) operator in C++:

The syntax of the logical OR operator in C++ is:

operand1 || operand2

Here, 

• Operand1 and 2 are the left-hand and right-hand side operands, respectively.
• The OR operator || is centrally placed, and it compares the operands to produce a return a value.

To better grasp how to employ the OR(||) operator in C++, we will see an example.

Input1:

Enter your age: 20

Output1:

You are eligible for this job.

Input2:

Enter your age: 68

Output2:

You are not eligible for this job.

Explanation:

In this example, the code prompts the user to enter their age and then checks whether they are eligible for a job.

1. We begin by declaring a variable called age in the int main() function and then use the cout command to print the statement 'Enter your age:' which prompts the user to input the age. 
2. The program uses the cin command to read the input.
3. We then initiate an if...else statement where we use the OR logical operator in C++ to evaluate the operands on the basis of the eligibility criteria. This is, the user must be either below 18 years old or above 60 years old to be ineligible for the job.
4. If the user's age meets these criteria, the code prints a message saying they are not eligible.
5. Otherwise, the code prints a message saying they are eligible.
6. Since the user's age in the first example is greater than 18, it has been printed that you are eligible for this job. In input2, since the user's age is 68, which is larger than 60, it was you are not eligible for this job.

Logical NOT(!) Operator In C++

The exclamation mark (!) is used in C++ to indicate the logical NOT operator. It is a unary operator that accepts a single argument and yields a negative boolean value. When a boolean statement is subjected to the NOT operator, it is first evaluated, and then the opposing boolean value is returned.

In other words, if an expression is true, the NOT operator returns false. And if an expression is false, the NOT operator returns true.

The truth table of the logical OR(||) operator in C++:

The syntax of the logical NOT operator in C++ is:

!expression

Here,

• The exclamation mark is the NOT operator
• And the expression refers to the condition for evaluation. 

We will look at an example to better understand how to use the NOT(!) operator in C++

Output

You cannot vote in the next election.

Explanation:

In the code example above,

1. We begin by iostream header file and declare an int variable age in the main function. Also, we initialized the variable with a value of 17.
2. Next, we declare a boolean variable can_vote and create a negate the comparison expression with the outcome (age<18), using the NOT operator. This expression evaluates to true if the age is not less than 18. 
3. An if...else statement is then initiated with the cout command to print 'You can vote in the next election' if the evaluation of the NOT operator is true. Else it prints 'You cannot vote in the next election'. 
4. Since here, the value of variable age is 17, which is less than 18, the result of the program is 'You cannot vote in the next election', and we close the program with return 0. 

Also read: Pointers in C++ | A Roadmap To All Types Of Pointers With Examples

Logical Operator Precedence And Associativity In C++

The order in which C++ operators are evaluated in an expression relies on the multiple levels of precedence that each operator has. That is, operators with greater precedence are assessed before those with a lower preference/ precedence. 

Here's a table illustrating the precedence and associativity of logical operators in C++:

This table shows the logical operators in order of their precedence, with the highest precedence at the top and the lowest precedence at the bottom. It also indicates their associativity, which determines the order of evaluation when multiple operators of the same precedence are present in an expression.

The following is the precedence and associativity of logical operators in C++ (from highest to lowest precedence):

1. Logical NOT (!):

   • Unary operator with the highest precedence.
   • Has right-to-left associativity.

2. Logical AND (&&):

   • Binary operator with medium precedence.
   • Has left-to-right associativity.

3. Logical OR (||):

   • Binary operator with the lowest precedence.
   • Has left-to-right associativity.

Here's an example that demonstrates the precedence of operators in C++:

Output

a > b && b > c = 1
a == b || b != c = 1
!(a < b) && (a != c) = 1

Explanation:

In this example,

1. We begin by including the iostream header file library.
2. Then in the int main() function, we declare three integer variables named a, b, and c and initialize them with the values of 6, 4, and 2, respectively.
3. We then conduct three logical operations on these variables to demonstrate operator precedence.
4. The first logical operation is a > b && b > c. Operator precedence shows that the logical AND operator && has a higher priority than the logical OR operator ||. As a result, the computation occurs as follows: a > b delivers 1 (true), and b > c provides 1 (true) as well. Thus, the answer to this calculation is 1 (true).
5. The next logical operation is a == b || b != c. According to operator precedence, the logical OR operator || has lower precedence than the comparison operators == and !=. Therefore, the calculation is performed as follows: a == b results in 0 (false values), and then b != c results in 1 (true). Therefore, the result of this calculation is 1 (true).
6. And the last logical operation is !(a < b) && (a != c). Here, we invert the result of the comparison a < b using the logical NOT operator!. According to operator precedence, the logical NOT operator ! has the highest precedence. Therefore, the comparison a < b is performed first, resulting in 0 (false).
7. Then, the logical NOT operator is performed, resulting in 1 (true). Finally, the comparison a != c is performed, resulting in 1 (true) as well. Therefore, the result of this calculation is 1 (true).

Relation Between Conditional Statements And Logical Operators In C++

Conditional statements and logical operators are both fundamental concepts in computer programming and are frequently combined. Conditional statements allow us to execute various pieces of code depending on whether particular conditions are true or false. For example, the if statement is a widely utilized conditional statement in the C++ programming language. It analyses a particular condition, and if it's true, it triggers the execution of a set of instructions within a code block.

Logical operators are utilized to join or change conditions to form more intricate expressions. These operators allow us to combine multiple conditions and determine whether they are true or false based on their relationship to each other.

So, conditional statements and logical operators are related because logical operators are often used within conditional statements to create complex decision-making structures.

Here’s an example of how conditional statements and logical operators are used together.

Input 1:

Enter a number: 6

Output 1:

The number is positive and even.

Input 2:

Enter a number: -3

Output 2:

The number is negative.

Input 3:

Enter a number: 0

Output 3:

The number is zero.

Explanation:

In this example, the C++ program prompts the user to enter a number. Based on the entered number, it uses conditional statements and logical operators to determine and display the characteristics of the number.

1. We begin by including the iostream library, and then in the int main() function, we declare an integer variable num.
2. The cout command is then used to print 'Enter a number:' which prompts the user to input a number.
3. The cin command is then used to read the input and provide a result based on the operators and conditional statements.
4. The program uses the logical AND operator (&&) to combine conditions. Here's how the conditions work:
   The first condition num > 0 && num % 2 == 0 checks if the number is both positive and even.
   The second condition num > 0 && num % 2 != 0 checks if the number is positive or odd.
5. The third condition num < 0 checks if the number is negative.
6. If none of the above conditions are true, the program assumes the number is zero.

By using logical operators in the conditions, the program is able to determine the appropriate message to display based on the number's characteristics.

Here, for example, if the user enters 6, the output will be is 'The number is positive and even'. If the user enters -3, the output is 'The number is negative'. And when the user enters 0, the output is 'The number is zero.'

This example demonstrates how logical operators are crucial in creating complex conditions within conditional statements, allowing programmers to handle different cases and make decisions based on specific conditions.

Check this out- Boosting Career Opportunities For Engineers Through E-School Competitions

C++ Relational Operators

Relational operators in C++ are used to compare values and determine the relationship between them. These operators return a Boolean value (true or false) based on the comparison result. C++ provides six relational operators, which are discussed ahead.

Equality Operator (==)

The equality operator, denoted by two consecutive equal signs (==), compares two values and returns true if they are equal and false otherwise.

For example:

int num1 = 10;
int num2 = 5;

if (num1 == num2) {
  cout << "The numbers are equal.";
} else {
  cout << "The numbers are not equal.";
}

Inequality Operator (!=)

The inequality operator, represented by an exclamation mark followed by an equal sign (!=), checks if two values are not equal. It returns true if the values are different and false if they are equal.

For example:

int age = 20;

if (age != 18) {
  cout << "You are not 18 years old.";
} else {
  cout << "You are 18 years old.";
}

Greater Than Operator (>)

The greater than operator compares two values and returns true if the left operand is greater than the right operand; otherwise, it returns false.

For example:

int num1 = 8;
int num2 = 5;

if (num1 > num2) {
  cout << "num1 is greater than num2.";
} else {
  cout << "num1 is not greater than num2.";
}

Less Than Operator (<)

The less than operator, denoted by the less than symbol (<), checks if the left operand is less than the right operand. It returns true if the condition is satisfied and false otherwise.

For example:

int num1 = 4;
int num2 = 6;

if (num1 < num2) {
  cout << "num1 is less than num2.";
} else {
  cout << "num1 is not less than num2.";
}

Greater Than or Equal To Operator (>=)

The greater than or equal to operator, represented by the greater than symbol followed by an equal sign (>=), checks if the left operand is greater than or equal to the right operand. It returns true if the condition is true and false otherwise.

For example:

int num1 = 7;
int num2 = 7;

if (num1 >= num2) {
  cout << "num1 is greater than or equal to num2.";
} else {
  cout << "num1 is neither greater than nor equal to num2.";
}

Less Than or Equal To Operator (<=)

The less than or equal to operator, denoted by the less than symbol followed by an equal sign (<=), checks if the left operand is less than or equal to the right operand. It returns true if the condition is satisfied and false otherwise.

For example:

int num1 = 3;
int num2 = 5;
if (num1 <= num2) {
  cout << "num1 is less than or equal to num2.";
} else {
  cout << "num1 is neither less than nor equal to num2.";
}

Conclusion

In conclusion, logical operators are an essential concept in C++ programming that allows us to construct advanced conditional statements and make judgments depending on many conditions. We can combine several expressions and evaluate them as a single condition with the help of logical operators in C++. The three logical operators in C++ are the AND operator (&&), the OR operator (||), and the NOT operator (!), which provide a powerful way to express complex conditions and logic in our programs.

Understanding the precedence and associativity of logical operators in C++ is an essential aspect of ensuring the accurate evaluation of conditions. Additionally, it's necessary to use them properly in order to prevent any problems or peculiar program behavior. Logical operators, when used with control structures such as if-else statements and loops, enable the implementation of a diverse range of decision-making processes and algorithms.

Frequently Asked Important Interview Questions:

Q. What are logical operators in C++ explain.

Logical operators in C++ are employed to analyze logical expressions that give a Boolean result(true or false). The truth value of an expression is checked using logical operators. Combining and modifying Boolean operations is done using these logical operator symbols. The three logical operators in C++ are as follows:

AND(&&) operator: The logical AND operator (&&) in C++ is a binary operator that delivers true when both of its operands are true and false when one of them is false.

OR(||) operator: The binary logical OR operator || in C++ accepts two operands and delivers a boolean value of true if at least one of them evaluates to true and false otherwise.

NOT(!) operator: It is a unary operator that accepts a single argument and yields a negative boolean value. When a boolean statement is subjected to the NOT operator, it is first evaluated, and then the opposing boolean value is returned.

Q. What is an example of a Boolean operator in C++?

In C++, Boolean operators are used to perform logical operations on Boolean values, which are either true or false. The three logical operators are all Boolean operators as well. That is the AND Operator (&&), the OR Operator (||), and the NOT Operator (!). A full implementation example for the same is given below.

Code Example:

Output

At least one condition is true.

Explanation:

The example above analyses whether the given condition is true or not.

1. We begin by including the iostream library and also use the namespace std inbuilt function.
2. Then in the int main function, we declare two int variables num1 and num2, and initialize them with the values of 5 and 10, respectively.
3. We then declare and initialize a boolean variable,  is_true and equate it to true.
4. An if...else statement is then initiated with the combination of AND operator to evaluate two conditions. The first condition is num1>0 and num2<20. We have used the AND(&&) operator to test this condition.
5. Then we employed OR(||) operator to evaluate these two true conditions.
6. Using the cout command, the program prints 'At least one condition is true' to the console if at least one of the two requirements is met. If not, it prints 'All conditions are false'.

Q. What is a unary and binary operator in C++?

To begin with, operators are essential to conducting operations on variables/ other operands. In that, a unary operator is a type of operator that only accepts one operand, or value or variable, to operate on. Examples of unary operators in C++ include Unary plus (+), Unary minus (-), Increment (++), Decrement (--), Logical not (!), Bitwise complement (~), Address of (&) and Dereference (*).

A binary operator in C++, on the other hand, is a type of operator that accepts two operands (or values or variables) to act on. Some typical binary operators are arithmetic operators multiplication (*), division (/), modulus (%), addition (+), relational operators like equal to (==), not equal to (!=), logical operators AND (&&), OR (||), NOT (!), and bitwise operators AND (&), OR (|), and XOR (^).

Q. What is a conditional operator in C++? Give an example.

Conditional operators in C++, also called ternary operators, are single operators that enable the execution of single expressions under specific conditions. They often consist of a single line of code and analyze a condition to determine which of two expressions should be executed.

Simple if-else statements are frequently written with conditional operators as shorthand. Particularly for simple conditions, they can make code more terse and simpler to comprehend. 

The conditional operator has the following syntax:

condition ? expression1 : expression2

Here, the condition is a boolean expression that is evaluated first. If it is true, then expression1 is executed. Otherwise, expression 2 is executed.

Q. Give an example of a binary operator in C++.

A binary operator in computer programming is a function that operates on two operands, which may be expressions, constants, or variables. The programming languages C++, Java, Python, and others are all user-defined operators. Binary operators perform various types of operations, such as arithmetic operations, relational operations, logical operations, and bitwise operations.

Here is an illustration of a binary operator in C++:

Output:

The remainder of 10 divided by 3 is 1

In this illustration, the remainder of the division of x by y is calculated using the binary operator%. The variable z stores the operation's output.

Q. What are logical operators in Python? Give example.

Logical operations in Python are those which work with one or more expressions and carry out operations on them. The AND, OR, and NOT are the three primary logical operators in Python.

Here is an example of logical operators in Python:

Output

Congratulations! You are eligible for a high-paying job.
You may not be eligible for a senior-level position.

Explanation:

In the example above,

1. We declare three variables, namely, Age, income, and has_degree, which are initialized with the values of 25, 60000, and true, respectively. 
2. Next, we initiate three if statements to check different conditions. First, we check the conditions that age is greater than or equal to 18. Then we check if income is greater than or equal to 50,000, and has_degree is True return using the and operator. If this criterion is met, then the print() function returns 'Congratulations! You are qualified for a well-paying position'.
3. The OR operator is then used to determine whether the user's age is below 18, their income is below 30,000, or has_degree is false. So, the statement 'Sorry, you are not eligible for a high-paying job' will be printed if this condition is True.
4. Finally, we utilize the NOT operator to determine if the user's age and income are both below 30. If this condition is True, then 'You may not be eligible for a senior-level position' will be printed on the console.

Q. What is the use of logical operators?

In both math and computer programming language, logical operators in C++ are used to compare and manipulate boolean values, which can either be true or false. They grant you the facility to logically combine numerous Boolean expressions or values in order to produce a single Boolean conclusion. The use of logical operators in programming considerably facilitates decision-making since it enables you to modify the flow of your code depending on particular conditions. They are widely employed in control clauses such as switch clauses, while loops, and if statements.

You might be interested in reading the following:

1. Strings In C++ | Functions, How To Convert & More (With Examples)
2. References In C++ | Declare, Types, Properties & More (+Examples)
3. Typedef In C++ | Syntax, Application & How To Use It (With Examples)
4. Dynamic Memory Allocation In C++ Explained In Detail (With Examples)
5. 51 C++ Interview Questions For Freshers & Experienced (With Answers)