Operadores de C++

Operadores C++

En este tutorial, aprenderemos sobre los diferentes tipos de operadores en C++ con la ayuda de ejemplos. En programación, un operador es un símbolo que opera sobre un valor o una variable.

Los operadores son símbolos que realizan operaciones en variables y valores. Por ejemplo, + es un operador usado para la suma, mientras que - es un operador usado para la resta.

Los operadores en C++ se pueden clasificar en 6 tipos:

Operadores aritméticos
Operadores de asignación
Operadores relacionales
Operadores lógicos
Operadores bit a bit
Otros Operadores

1. Operadores aritméticos de C++

Los operadores aritméticos se utilizan para realizar operaciones aritméticas en variables y datos. Por ejemplo,

a + b;

Aquí, el + El operador se usa para agregar dos variables a y b . De manera similar, hay varios otros operadores aritméticos en C++.

Operador	Operación
`+`	Adición
`-`	Sustracción
`*`	Multiplicación
`/`	División
`%`	Operación de módulo (resto después de la división)

Ejemplo 1:Operadores aritméticos

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 7;
    b = 2;

    // printing the sum of a and b
    cout << "a + b = " << (a + b) << endl;

    // printing the difference of a and b
    cout << "a - b = " << (a - b) << endl;

    // printing the product of a and b
    cout << "a * b = " << (a * b) << endl;

    // printing the division of a by b
    cout << "a / b = " << (a / b) << endl;

    // printing the modulo of a by b
    cout << "a % b = " << (a % b) << endl;

    return 0;
}

Salida

a + b = 9
a - b = 5
a * b = 14
a / b = 3
a % b = 1

Aquí, los operadores + , - y * calcula la suma, la resta y la multiplicación respectivamente como esperábamos.

/ Operador de división

Tenga en cuenta la operación (a / b) en nuestro programa. El / operador es el operador de división.

Como podemos ver en el ejemplo anterior, si un número entero se divide por otro número entero, obtendremos el cociente. Sin embargo, si el divisor o el dividendo es un número de punto flotante, obtendremos el resultado en decimales.

In C++,

7/2 is 3
7.0 / 2 is 3.5
7 / 2.0 is 3.5
7.0 / 2.0 is 3.5

Operador de módulo %

El operador módulo % calcula el resto. Cuando a = 9 se divide por b = 4 , el resto es 1 .

Nota: El % El operador solo se puede usar con números enteros.

Operadores de incremento y decremento

C++ también proporciona operadores de incremento y decremento:++ y -- respectivamente.

++ aumenta el valor del operando en 1
-- lo disminuye en 1

Por ejemplo,

int num = 5;

// increment operator
++num;  // 6

Aquí, el código ++num; aumenta el valor de num por 1 .

Ejemplo 2:Operadores de incremento y decremento

// Working of increment and decrement operators

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 100, result_a, result_b;

    // incrementing a by 1 and storing the result in result_a
    result_a = ++a;
    cout << "result_a = " << result_a << endl;


    // decrementing b by 1 and storing the result in result_b   
    result_b = --b;
    cout << "result_b = " << result_b << endl;

    return 0;
}

Salida

result_a = 11
result_b = 99

En el programa anterior, hemos usado el ++ y -- operadores como prefijos (++a y --b) . Sin embargo, también podemos usar estos operadores como postfijo (a++ y b--) .

Para obtener más información, visite los operadores de incremento y decremento.

2. Operadores de asignación de C++

En C++, los operadores de asignación se utilizan para asignar valores a las variables. Por ejemplo,

// assign 5 to a
a = 5;

Aquí, hemos asignado un valor de 5 a la variable a .

Operador	Ejemplo	Equivalente a
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Ejemplo 3:Operadores de asignación

#include <iostream>
using namespace std;

int main() {
    int a, b;

    // 2 is assigned to a
    a = 2;

    // 7 is assigned to b
    b = 7;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "\nAfter a += b;" << endl;

    // assigning the sum of a and b to a
    a += b;  // a = a +b
    cout << "a = " << a << endl;

    return 0;
}

Salida

a = 2
b = 7

After a += b;
a = 9

3. Operadores relacionales de C++

Un operador relacional se utiliza para comprobar la relación entre dos operandos. Por ejemplo,

// checks if a is greater than b
a > b;

Aquí, > es un operador relacional. Comprueba si a es mayor que b o no.

Si la relación es verdadera , devuelve 1 mientras que si la relación es falsa , devuelve 0 .

Operador	Significado	Ejemplo
`==`	es igual a	`3 == 5` nos da falso
`!=`	No es igual a	`3 != 5` nos da verdadero
`>`	Mayor que	`3 > 5` nos da falso
`<`	Menor que	`3 < 5` nos da verdadero
`>=`	Mayor o igual que	`3 >= 5` danos falso
`<=`	Menor o igual que	`3 <= 5` nos da verdadero

Ejemplo 4:Operadores relacionales

#include <iostream>
using namespace std;

int main() {
    int a, b;
    a = 3;
    b = 5;
    bool result;

    result = (a == b);   // false
    cout << "3 == 5 is " << result << endl;

    result = (a != b);  // true
    cout << "3 != 5 is " << result << endl;

    result = a > b;   // false
    cout << "3 > 5 is " << result << endl;

    result = a < b;   // true
    cout << "3 < 5 is " << result << endl;

    result = a >= b;  // false
    cout << "3 >= 5 is " << result << endl;

    result = a <= b;  // true
    cout << "3 <= 5 is " << result << endl;

    return 0;
}

Salida

3 == 5 is 0
3 != 5 is 1
3 > 5 is 0
3 < 5 is 1
3 >= 5 is 0
3 <= 5 is 1

Nota :Los operadores relacionales se utilizan en la toma de decisiones y bucles.

4. Operadores lógicos de C++

Los operadores lógicos se utilizan para comprobar si una expresión es verdadera o falso . Si la expresión es verdadera , devuelve 1 mientras que si la expresión es falsa , devuelve 0 .

Operador	Ejemplo	Significado
`&&`	expresión1 && expresión2	Y lógico. Verdadero solo si todos los operandos son verdaderos.
`\|\|`	expresión1 \|\| expresión2	OR lógico. Verdadero si al menos uno de los operandos es verdadero.
`!`	! expresión	NO lógico. Verdadero solo si el operando es falso.

En C++, los operadores lógicos se usan comúnmente en la toma de decisiones. Para comprender mejor los operadores lógicos, veamos los siguientes ejemplos,

Suppose,
a = 5
b = 8

Then,

(a > 3) && (b > 5) evaluates to true
(a > 3)  && (b < 5) evaluates to false

(a > 3) || (b > 5) evaluates to true
(a > 3) || (b < 5) evaluates to true
(a < 3) || (b < 5) evaluates to false

!(a < 3) evaluates to true
!(a > 3) evaluates to false

Ejemplo 5:Operadores Lógicos

#include <iostream>
using namespace std;

int main() {
    bool result;

    result = (3 != 5) && (3 < 5);     // true
    cout << "(3 != 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 < 5);    // false
    cout << "(3 == 5) && (3 < 5) is " << result << endl;

    result = (3 == 5) && (3 > 5);    // false
    cout << "(3 == 5) && (3 > 5) is " << result << endl;

    result = (3 != 5) || (3 < 5);    // true
    cout << "(3 != 5) || (3 < 5) is " << result << endl;

    result = (3 != 5) || (3 > 5);    // true
    cout << "(3 != 5) || (3 > 5) is " << result << endl;

    result = (3 == 5) || (3 > 5);    // false
    cout << "(3 == 5) || (3 > 5) is " << result << endl;

    result = !(5 == 2);    // true
    cout << "!(5 == 2) is " << result << endl;

    result = !(5 == 5);    // false
    cout << "!(5 == 5) is " << result << endl;

    return 0;
}

Salida

(3 != 5) && (3 < 5) is 1
(3 == 5) && (3 < 5) is 0
(3 == 5) && (3 > 5) is 0
(3 != 5) || (3 < 5) is 1
(3 != 5) || (3 > 5) is 1
(3 == 5) || (3 > 5) is 0
!(5 == 2) is 1
!(5 == 5) is 0

Explicación del programa de operador lógico

(3 != 5) && (3 < 5) evalúa a 1 porque ambos operandos (3 != 5) y (3 < 5) son 1 (verdadero).
(3 == 5) && (3 < 5) evalúa a 0 porque el operando (3 == 5) es 0 (falso).
(3 == 5) && (3 > 5) evalúa a 0 porque ambos operandos (3 == 5) y (3 > 5) son 0 (falso).
(3 != 5) || (3 < 5) evalúa a 1 porque ambos operandos (3 != 5) y (3 < 5) son 1 (verdadero).
(3 != 5) || (3 > 5) evalúa a 1 porque el operando (3 != 5) es 1 (verdadero).
(3 == 5) || (3 > 5) evalúa a 0 porque ambos operandos (3 == 5) y (3 > 5) son 0 (falso).
!(5 == 2) evalúa a 1 porque el operando (5 == 2) es 0 (falso).
!(5 == 5) evalúa a 0 porque el operando (5 == 5) es 1 (verdadero).

5. Operadores bit a bit de C++

En C++, los operadores bit a bit se utilizan para realizar operaciones en bits individuales. Solo se pueden usar junto con char y int tipos de datos.

Operador	Descripción
`&`	Binario Y
`\|`	O binario
`^`	XOR binario
`~`	Complemento a uno binario
`<<`	Desplazamiento binario a la izquierda
`>>`	Desplazamiento binario a la derecha

Para obtener más información, visite Operadores bit a bit de C++.

6. Otros operadores de C++

Aquí hay una lista de algunos otros operadores comunes disponibles en C++. Aprenderemos sobre ellos en tutoriales posteriores.

Operador	Descripción	Ejemplo
`sizeof`	devuelve el tamaño del tipo de datos	`sizeof(int); // 4`
`?:`	devuelve valor basado en la condición	`string result = (5 > 0) ? "even" : "odd"; // "even"`
`&`	representa la dirección de memoria del operando	`&num; // address of num`
`.`	accede a miembros de variables de estructura u objetos de clase	`s1.marks = 92;`
`->`	utilizado con punteros para acceder a las variables de clase o estructura	`ptr->marks = 92;`
`<<`	imprime el valor de salida	`cout << 5;`
`>>`	obtiene el valor de entrada	`cin >> num;`

Conversión de tipo C++ Comentarios de C++

Lenguaje C