Operadores de C++

Introducción

En este laboratorio, aprenderá a usar operadores en C++. Aprenderá a usar operadores aritméticos, operadores relacionales, operadores lógicos y operadores bit a bit.

Skills Graph

Vista previa del contenido

Para datos numéricos y lógicos básicos, usamos operadores para operar con ellos. Al igual que otros lenguajes, C++ ofrece un amplio soporte para los operadores. Comencemos a aprenderlos.

• Operaciones aritméticas
• Operaciones de tipos mixtos
• Operadores de asignación compuesta
• Conversión de tipos
• Operadores relacionales y lógicos

Operaciones aritméticas

C++ admite los siguientes operadores aritméticos para números:

Todos los operadores anteriores son operadores binarios, toman dos operandos. La multiplicación, la división y el resto tienen precedencia sobre la suma y la resta.

Es importante tener en cuenta que int/int produce un int, con el resultado truncado, 1/2 → 0 (no 0.5).

Operaciones de tipos mixtos

Si ambos operandos de una operación aritmética pertenecen al mismo tipo, la operación se realiza en ese tipo y el resultado pertenece a ese tipo. Sin embargo, si los dos operandos pertenecen a tipos diferentes, el compilador promueve el valor del tipo más pequeño al tipo más grande (conocido como conversión implícita de tipos). Luego, la operación se realiza en el tipo más grande.

Por ejemplo

/* Probando operaciones aritméticas de tipos mixtos */
#include <iostream>
#include <iomanip>   // necesario para formatear números de punto flotante
using namespace std;

int main() {
   int i1 = 2, i2 = 4;
   double d1 = 2.5, d2 = 5.0;

   // números de punto flotante en formato fijo con 1 decimal
   cout<<fixed<<setprecision(1);

   cout << i1 << " + " << i2 << " = " << i1+i2 << endl;  // 6
   cout << d1 << " + " << d2 << " = " << d1+d2 << endl;  // 7.5
   cout << i1 << " + " << d2 << " = " << i1+d2 << endl;  // 7.0  <==

   cout << i1 << " - " << i2 << " = " << i1-i2 << endl;  // -2
   cout << d1 << " - " << d2 << " = " << d1-d2 << endl;  // -2.5
   cout << i1 << " - " << d2 << " = " << i1-d2 << endl;  // -3.0 <==

   cout << i1 << " * " << i2 << " = " << i1*i2 << endl;  // 8
   cout << d1 << " * " << d2 << " = " << d1*d2 << endl;  // 12.5
   cout << i1 << " * " << d2 << " = " << i1*d2 << endl;  // 10.0 <==

   cout << i1 << " / " << i2 << " = " << i1/i2 << endl;  // 0    <==
   cout << d1 << " / " << d2 << " = " << d1/d2 << endl;  // 0.5
   cout << i1 << " / " << d2 << " = " << i1/d2 << endl;  // 0.4  <==
   return 0;
}

Salida:

2 + 4 = 6
2.5 + 5.0 = 7.5
2 + 5.0 = 7.0
2 - 4 = -2
2.5 - 5.0 = -2.5
2 - 5.0 = -3.0
2 * 4 = 8
2.5 * 5.0 = 12.5
2 * 5.0 = 10.0
2 / 4 = 0
2.5 / 5.0 = 0.5

Desbordamiento / Subdesbordamiento

// Rango de int es [-2147483648, 2147483647]
   int i1 = 2147483647;      // int máximo
   cout << i1 + 1 << endl;   // -2147483648 (desbordamiento)
   cout << i1 * i1 << endl;  // 1

   int i2 = -2147483648;     // int mínimo
   cout << i2 - 1 << endl;   // 2147483647 (subdesbordamiento)
   cout << i2 * i2 << endl;  // 0

En las operaciones aritméticas, el valor resultante se desborda si excede su rango. El tiempo de ejecución de C++ no emite un mensaje de error/advertencia, sino que produce un resultado incorrecto. Es importante tener en cuenta que la verificación de desbordamiento/subdesbordamiento es responsabilidad del programador.

Operadores de asignación compuesta

C++ también proporciona los llamados operadores de asignación compuesta enumerados a continuación:

x = 5;
cout << x++ << endl;  // Guarda x (5); Incrementa x (=6); Imprime el antiguo x (5).
x = 5;
cout << ++x << endl;  // Incrementa x (=6); Imprime x (6).

Conversión implícita de tipos vs. Conversión explícita de tipos

Cuando asignas un valor de un tipo fundamental (integrado) a una variable de otro tipo fundamental, C++ convierte automáticamente el valor al tipo receptor, si los dos tipos son compatibles. Por ejemplo:

• Si asignas un valor de int a una variable de double, el compilador convierte automáticamente el valor de int a double (por ejemplo, de 1 a 1.0) y lo asigna a la variable de double.
• Si asignas un valor de double a una variable de int, el compilador convierte automáticamente el valor de double a un valor de int (por ejemplo, de 1.2 a 1) y lo asigna a la variable de int. La parte fraccionaria se truncará y se perderá. Algunos compiladores emiten una advertencia/error "posible pérdida de precisión"; otros no.

 int i;
 double d;

 i = 3;
 d = i;    // Asigna un valor de int a double
 cout << "d = " << d << endl;  // 3.0

 d = 5.5;
 i = d;    // Asigna un valor de double a int
 cout << "i = " << i << endl;  // 5 (truncado, ¡sin advertencia!)

Puedes realizar una conversión de tipo explícitamente a través del llamado operador de conversión de tipo unario en la forma (nuevo-tipo) operando o nuevo-tipo (operando). El operador de conversión de tipo toma un operando en el tipo particular y devuelve un valor equivalente en el nuevo tipo. Tenga en cuenta que es una operación que produce un valor resultante, similar a una operación de suma aunque la suma implica dos operandos. Por ejemplo:

cout << (double)5 << endl;  // int 5 → double 5.0
cout << (int)5.5 << endl;   // double 5.5 → int 5

double aDouble = 5.6;
int anInt = (int)aDouble; // devuelve 5 y lo asigna a anInt. aDouble no cambia!

// C++ también admite la conversión de tipo de estilo de función.
cout << double(5) << endl;     // 5.0
cout << int(5.5) << endl;      // 5
cout << int(aDouble) << endl;  // 5

Operadores relacionales y lógicos

Muy a menudo, necesitas comparar dos valores antes de decidir qué acción tomar. C++ proporciona seis operadores de comparación (o operadores relacionales):

Las tablas de verdad son las siguientes:

// Devuelve true si x está entre 0 y 100 (inclusive)
(x >= 0) && (x <= 100)
// está mal usar 0 <= x <= 100

// Devuelve true si x está fuera de 0 y 100 (inclusive)
(x < 0) || (x > 100)   //o
!((x >= 0) && (x <= 100))

// Devuelve true si year es un año bisiesto
// Un año es bisiesto si es divisible por 4 pero no por 100, o si es divisible por 400.
((year % 4 == 0) && (year % 100!= 0)) || (year % 400 == 0)

Resumen

Esta parte es relativamente fácil. Deberías relacionarlas con la sección anterior. No es necesario memorizarlas, solo entender su lógica mentalmente.