C++ : Practica 5: Operadores en C++

Operador de Asignación (=)

El operador de asignación atribuye un valor a una variable. Por ejemplo:

x = 5;

Esta declaración asigna el valor entero "integer" 5 a la variable x. En C++ la asignación de tareas operacionales siempre se desarrolla de derecha a izquierda <--------  y nunca de otra manera.

x = y;

Esta sentencia asigna a la variable x el valor contenido en la variable y. El valor de x en el momento en que se ejecuta esta sentencia se pierde y es reemplazado por el valor de y. Considere también que estamos asignando sólo el valor de y a x en el momento de la operación de asignación. Por lo tanto, si cambia en un momento posterior, no afectará al nuevo valor tomado por x. Para ejemplificar esto echaremos un vistazo al siguiente código: He incluído la evolución del contenido almacenado en las variables como comentários:

//operadores de asignación
#include "iostream"
using namespace std;

int main(){
    int a, b;  //a:?, b:?
    a = 10;   //a:10, b:?
    b = 4;    //a:10, b:4
    a = b;    //a:4, b:4
    b = 7;    //a:4, b:7

    cout << "a:";
    cout <<  a;
    cout << "b:";
    cout <<  b;
}

Este programa lo que hace es imprimir en pantalla los valores finales de a y b(4 y 7 respectivamente). Observe como la variable "a" no ha sido afectada por la modificación final de b(b=7), a pesar de haber declarado "a = b" antes. Es importante saber que las operaciones de asignación son expresiones que pueden ser evaluadas. Esto quiere decir que la asignación en sí: tiene un valor; y para los tipos fundamentales, este valor es el asignado en la operación. Veamos un ejemplo:

y = 2 + (x = 5);

En esta expresión, a y se le asigna el resultado de añadir 2 al valor de otra expresión de asignación (que tiene un valor de 5). Esto es más o menos equivalente a:

x = 5;
y = 2 + x;

Con el resultado final de la asignación de 7 a y.

La siguiente expresión también es válida en C++:

x = y = z = 5;

Esto asigna 5 a las 3 variables (x y y z) siempre de derecha a izquierda, no lo olviden!. [tab] [content title="Ejemplo 1: Operadores de Asignación"]

//Operadores de asignación
#include<iostream>
using namespace std;
int main()
{
  int a, b; //a:?, b:?
  a =  10; // a:10, b:?
  b = 4;  //a:10, b:4
  a = b;  //a:4, b:4
  b = 7;  //a:4, b:7

  cout << "a:";
  cout << a << "\n";
  cout << "b:";
  cout << b << "\n";

  return 0; 
}

[/content] [/tab]

Operadores Aritméticos (+,-,*,/,%)

Los 5 operadores soportados por el lenguaje C++ son:

Operador	Descripción
+	Adición
-	Sustracción
*	Multiplicación
/	División
%	Módulo

Las operaciones de suma, resta, multiplicación y división corresponden literalmente a sus respectivos operadores matemáticos. El último, operador de módulo, representado por un signo de porcentaje(%), el cual nos da el residuo de una división de 2 valores. Por ejemplo:

x = 11 % 3;

resulta en la x que contiene el valor 2, ya que dividir 11 por 3 resulta en 3, con un resto de 2.

[tab] [content title="Ejemplo 1: Suma"]

//Suma de Dos variables enteras integer a y b
//LLamando a la biblioteca iostream
#include<iostream>
//usando el namespace std
using namespace std;

int main()
{
   int a,b;
   int suma;
   a = 7;
   b = 8;
   suma = a + b;
   cout << suma << "\n";
   return 0;
} 

[/content] [content title="Ejemplo 2: Resta"]

//Resta de dos Variables integer enteros
//LLamando a la biblioeca iostream
#include <iostream>
using namespace std;
int main()
{
  int a,b;
  int resta;
  a = 17;
  b = 8;
  resta = a - b;
  cout << resta << "\n";
  return 0;
}

[/content] [content title="Ejemplo 3: Multiplicación"]

//Multiplicación de 2 variables integer enteros
#include<iostream>
using namespace std;
int main()
{
  int a,b;
  int multiplica;
  a = 7;
  b = 8;
  multiplica = a * b;
  cout << multiplica << "\n";
  return 0; 
}

[/content] [content title="Ejemplo 4: División"]

//División de dos variables integer enteros
#include<iostream>
using namespace std;
int main()
{
  int a,b;
  int divide;
  a = 8;
  b = 4;
  divide = a / b;
  cout << divide << "\n";
  return 0;
}

[/content] [content title="Ejemplo 5: Módulo"]

//Utilizando el operador módulo %
#include<iostream>
using namespace std;
int main()
{
   int a,b;
   int modulo;
   a = 11;
   b = 3;
   modulo = a % b;
   cout << modulo << "\n";
   return 0;
}

[/content] [/tab]

Asignación Compuesta (+=,-=,*=,/=,%=,>>=,<<=,&=,^=,|=)

Los operadores de Asignación Compuesta modifican el valor actual de una variable realizando una operación en ella. Son equivalentes a asignar el resultado de una operación al primer operando:

Expresión	Equivalente a...
y += x;	y = y + x;
x -= 5;	x = x - 5;
x /=y;	x = x / y;
precio *= unidades + 1;	precio = precio * (unidades + 1);

y lo mismo para todos los demás operadores de asignación compuestos. Por ejemplo:

//operadores de asignación compuestos
#include <iostream>
using namespace std;
int main ()
{
   int a, b = 3;
   a = b;
   a+= 2;  //equivalente a:  "a = a + 2"
   cout << a;
   return 0;
}

Incremento y Decremento (++,--)

Algunas expresiones pueden acortarse aún más: el operador de aumento (++) y el operador de disminución (--) aumentan o reducen en uno el valor almacenado en una variable. Son equivalentes a +=1 y -=1, respectivamente. Así:

++x;
x+=1;
x=x+1;

son todos equivalentes en su funcionalidad; los tres aumentan en uno el valor de x.

En los primeros compiladores de C, las tres expresiones anteriores podrían haber producido código ejecutable diferente dependiendo de cuál fué utilizado. En la actualidad, este tipo de optimización de código se realiza automáticamente por el compilador, por lo tanto, las tres expresiones deben producir exactamente el mismo código ejecutable. 

Una peculiaridad de este operador es que puede usarse tanto como prefijo como sufijo. Esto significa que puede escribirse antes del nombre de la variable (++x) ó despues de la variable (x++). Aunque en expresiones simples como x++ ó ++x, ambos tienen el mismo significado; en otras expresiones donde se evalúa el resultado de la operación de incremento o decremento, pueden tener una diferencia importante en su significado. En el caso de que el operador de incremento se utilize como prefijo (++x) del valor, la expresión evalúa el valor de x, una vez que ya esta aumentado. Por otro lado, en el caso que se use como sufijo (x++), el valor tambien se incrementa, pero la expresión evalúa al valor que x tenía antes de ser incrementado. Observe la diferencia:

Ejemplo 1	Ejemplo 2
x = 3;	x = 3;
y = ++x;	y = x++;
//x contiene 4, y contiene 4	//x contiene 4, y contiene 3

En el Ejemplo 1,  el valor asignado a y es el valor de x después de ser aumentado. Mientras que en el Ejemplo 2, es el valor x antes de ser aumentado.

Operadores Relacionales y de Comparación     (==,!=,>,<,>=,<=)

Se pueden comparar dos expresiones utilizando operadores relacionales y de igualdad. Por ejemplo, para saber si dos valores son iguales o si uno es mayor que el otro.

El resultado de tal operación es verdadero o falso (es decir, un valor booleano).

Los operadores relaciones en C++, son:

Operador	Descripción
==	igual a
!=	No es igual a
<	Menor que
>	Mayor que
<=	Menor que o igual a
>=	Mayor que o igual a

Aquí hay algunos ejemplos:

(7 == 5) // Se evalúa como falso
(5 > 4)  // Se evalúa como verdadero
(3 != 2)  // Se evalúa como verdadero
(6 >= 6) //Se evalúa como verdadero
(5 < 5)  //Se evalúa como falso

Operadores Lógicos(!,&&,||)

El operador ! es el operador C++ para la operación booleana NOT. Tiene sólo un operando, a su derecha e invertido, produciendo false si su operando es true y true si su operando es false. Básicamente, devuelve el valor booleano opuesto de la evaluación de su operando. Por ejemplo:

!(5 == 5)  //evaluada como false porque la expresión a su derecha es true
!(6 <= 4)  //evaluada como true porque (6<=4) seria false
!true  // evaluada como false
!false  // evaluada como true

Los operadores lógicos && y || se utilizan al evaluar dos expresiones para obtener un solo resultado relacional. El operador && corresponde a la operación lógica booleana AND, que produce TRUE si ambos operandos son TRUE y FALSE en caso contrario. El panel siguiente muestra el resultado del operador && evaluando la expresión a&&b:

El operador || corresponde a la operacion Booleana OR, que devuelve TRUE si cualquiera de sus operandos es TRUE, siendo falsa sólo cuando ambos operandos son FALSE. Aquí están los resultados posibles de un a || b: 

Por ejemplo:

( (5 == 5) && (3 & 6) )  //evaluado para false (true && false)
( (5 == 5) || (3 & 6) )  //evaluado para true (true || false)

Cuando se utilizan los operadores lógicos, C++ sólo evalúa lo que es necesario de izquierda a derecha para obtener el resultado relacional combinado, ignorando el resto. Por lo tanto, en el último ejemplo ( (5 == 5) || (3 > 6) ), C++ evalúa primero si 5 == 5 es TRUE, y si es así, nunca verifica si 3 > 6 es TRUE ó no. Esto se conoce como evaluación de corto circuito y funciona de esta manera para estos operadores:

Operador	Corto Circuito
&&	si la expresión del lado izquierdo es FALSE, el resultado combinado es FALSE (la expresión del lado derecho nunca se evalúa).
||	si la expresión del lado izquierdo es TRUE, el resultado combinado es TRUE (la expresión del lado derecho nunca se evalúa).

Esto es principalmente importante cuando la expresión de la derecha tiene efectos secundarios, como la alteración de los valores.

if (i < 10) && (++i > n) {/*...*/}  //Tenga en cuenta que la condición incrementa i

Aquí la expresión condicional combinada aumentaría i en uno, pero esto sólo si la condición a la izquierda de && es TRUE, porque de lo contrario, la condición en el lado derecho(++i < n) nunca se evalúa.

Operador Ternario Condicional (?)

Este operador condicional evalúa una expresión, devolviendo un valor si esa expresión se evalúa como TRUE y otra diferente si esa expresión se evalúa como FALSE. Su sintaxis es:

condicion ? resultado1 : resultado2 

Si la condición es TRUE, toda la expresión evalúa el resultado1 y de la otra forma evaluará el resultado2. Veamos un ejemplo:

7 == 5 ? 4 : 3  //Se evalúa a 3, ya que 7 no es igual a 5.
7 == 5 + 2 ? 4 : 3  //Se evalúa a 4, ya que 7 es gual a 5 + 2.
5 > 3 ? a : b  //Se evalúa al valor de a, ya que 5 es mayor que 3.
a > b ? a : b  //Se evalúa según el que sea mayor a ó b.

Por ejemplo, veamos esto en la practica:

//operador condicional
#include(iostream)
using namespace std;
int main()
{
   int a,b,c;
   a = 2;
   b = 7;
   c = (a > b) ? a : b;
   cout << c << '\n';
   return 0;
}

En este ejemplo: a fue 2 y b fue 7, por lo que la expresión que está evaluando (a > b) no era TRUE, por lo tanto el primer valor especificado después de que el signo de interrogación fue descartado en favor del segundo valor (el único después del 'colon :') que era b (con un valor de 7).

Operador Coma ( , )

El operador Coma (,) es usado para separar 2 ó más expresiones que estan incluídas donde sólo se espera una expresión. Cuando el conjunto de expresiones tienen que ser evaluadas por un valor, sólo se considera la expresión que está más a la derecha.

Por ejemplo, vea el siguiente código:

a = (b = 3, b + 2);

Primero se asigna el valor 3 a b y luego se ha asignado b + 2 a la variable a. Así, al final, la variable a contendría el valor 5 mientras que la variable b contendría el valor de 3.

Operador de Conversión de Tipo Explícito

Los operadores de conversión de tipo permiten convertir un valor de un tipo dado a otro tipo. Hay varias maneras de hacer esto en C++. El más simple, que ha sido heredado del lenguaje C, es preceder a la expresión a ser convertida por el nuevo tipo encerrado entre paréntesis (()), observe:

int i;
float f = 3.14;
i = (int) f;

El código anterior convierte el numero flotante 3.14 en un valor entero (3); el resto se pierde. Aquí el operador de conversión de tipo fue (int). Otra forma de hacer lo mismo en C++ es usar la notación funcional que precede a la expresión a convertir, por el tipo y encerrar la expresión entre paréntesis:

i = int (f);

ambas formas de conversión de tipos son válidas en C++.

sizeof

Este operador acepta un parámetro que puede ser un tipo o una variable y devuelve el tamaño en bytes de ese tipo u objeto, veamos:

x = 5 + 7 % 2;

En C++, la expresión anterior siempre asigna 6 a la variable x, porque el operador % tiene una precedencia más alta que el operador + y siempre se evalúa antes. Partes de las expresiones se pueden encerrar entre paréntesis para anular este orden de precedencia ó para hacer explicitamente claro el efecto deseado. Observe la diferencia:

x = 5 + (7 % 2); // x = 6 (igual que sin paréntesis)
x = (5 + 7) % 2; // x = 0

De mayor a menor prioridad, los operadores C++ se evalúan en el siguiente orden:

La inclusión de todas las sub-sentencias entre paréntesis(incluso aquellas innecesarias debido a su precedencia) mejora la legibilidad del código.

Habiendo entendido correctamente este capítulo, estaremos habilitados para praticar los ejemplos con diferentes valores. Esto hará más prolijo su camino hacia el entendimiento del lenguaje. Ya más adelante comenzaremos a crear mucho código interesante!. Repito!, no deje de practicar, eso es vital!