Comparison operators allow us to compare two values and determine if they are equal, different, greater, less, greater/equal, or less/equal.

The results of the comparisons are boolean values (`true`

or `false`

), and are fundamental for flow control logic.

Comparison operators in C++ are:

Returns true if two values are equal.`==`

(Equality):Returns true if two values are not equal.`!=`

(Inequality):Returns true if the value on the left is greater than the value on the right.`>`

(Greater than):Returns true if the value on the left is less than the value on the right.`<`

(Less than):Returns true if the value on the left is greater than or equal to the value on the right.`>=`

(Greater than or equal to):Returns true if the value on the left is less than or equal to the value on the right.`<=`

(Less than or equal to):

These operators are fundamental for decision-making in programs and are commonly used in control structures such as conditionals or loops.

More information about comparison operators read more

## List of Comparison Operators

### Equality (`==`

)

The equality operator (`==`

) is used to check if two values are equal. It compares two values and returns `true`

if they are equal, or `false`

otherwise.

For example:

```
int a = 5;
int b = 5;
bool isEqual = (a == b); // true, since a and b are equal
```

### Inequality (`!=`

)

The inequality operator (`!=`

) is used to check if two values are not equal. It compares two values and returns `true`

if they are different, or `false`

otherwise.

For example:

```
int a = 5;
int b = 3;
bool isNotEqual = (a != b); // true, since a is not equal to b
```

### Greater than (`>`

)

The greater than operator (`>`

) is used to check if a value is greater than another.

```
int a = 10;
int b = 5;
bool isGreater = (a > b); // true, since a is greater than b
```

### Less than (`<`

)

The less than operator (`<`

) is used to check if a value is less than another.

```
int a = 3;
int b = 7;
bool isLess = (a < b); // true, since a is less than b
```

### Greater than or Equal to (`>=`

)

The greater than or equal to operator (`>=`

) is used to check if a value is greater than or equal to another.

```
int a = 10;
int b = 10;
bool isGreaterOrEqual = (a >= b); // true, since a is equal to b
```

### Less than or Equal to (`<=`

)

The less than or equal to operator (`<=`

) is used to check if a value is less than or equal to another.

```
int a = 5;
int b = 7;
bool isLessOrEqual = (a <= b); // true, since a is less than b
```

## Spaceship Operator <=> ⋆

C++20 provides the three-way comparison operator <=>, also called the spaceship operator, which allows comparing two objects in a similar way of strcmp.

The operator returns an object that can be directly compared with a positive, 0, or negative integer value

```
(3 <=> 3) == 0; // true
(3 <=> 5) == 0; // false
('a' <=> 'a') == 0; // true
(3 <=> 5) > 0; // false
(3 <=> 5) < 0; // true
(7 <=> 5) > 0; // true
(7 <=> 5) < 0; // false
```

## Usage Examples

#### Variable Comparison

Comparison operators are commonly used in control structures to make decisions based on variable comparisons.

```
int age = 20;
if (age >= 18) {
std::cout << "You are of legal age." << std::endl;
} else {
std::cout << "You are under age." << std::endl;
}
```

#### Use in Loops

Comparison operators are also used in loops to control the number of iterations.

```
for (int i = 0; i < 10; ++i) {
std::cout << "Number: " << i << std::endl;
}
```

#### Complex Comparisons

It is possible to combine multiple comparison operators to create more complex conditions.

```
int a = 5;
int b = 10;
int c = 5;
bool result = (a < b) && (a == c); // true, since a is less than b and a is equal to c
```