setembro 2017

às 0
Operador de Asignación (=)
El operador de asignación atribuye un valor a una variable. 
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, 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 tipos fundamentales, este valor es el asignado en la operación. Veamos un ejemplo: <--c digo="" highlighter--="">
y = 2 + (x = 5);
<--fin codigo="" highlighter--="">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:
<--fin codigo="" highlighter--=""> 

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!







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.

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:

&& OPERATOR (and)
a b a && b
TRUE TRUE TRUE
TRUE FALSE FALSE
FALSE TRUE FALSE
FALSE FALSE FALSE
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: 

&& OPERATOR (or)
a b a || b
TRUE TRUE TRUE
TRUE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE
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 terniario 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:

NivelGrupo de PrecedenciaOperadorDescripciónAgrupamiento
1Ámbito o Escopo::Calificador de ámbitoDe izquierda a derecha
2Sufijo (Uranio ó con solo un operando y una variable de entrada)++ --Sufijo de incremento / decrementoDe izquierda a derecha
()Formas funcionales 
[]subíndice
. ->acceso a miembros
3Prefijo (unario)++ --prefijo incremento / decrementoDe derecha a izquierda
~ !bit a bit NOT / logical NOT
+ -prefijo unario
& *referencia / desreferencia
new deleteasignación/desasignación
sizeofpaquete de parámetros
(type)Conversión de tipo estilo C
4Puntero a miembro.* ->*Puntero de AccesoDe izquierda a derecha
5Aritmética: escalamiento* / %Multiplicando, dividir, móduloDe izquierda a Derecha
6Aritmética: adición+ -adición, substracciónDe izquierda a Derecha
7Cambio de bit a bit<< >>Cambiar a la izquierda, Cambiar a la derechaDe izquierda a Derecha
8Relacional< > <= >=Operadores de ComparaciónDe izquierda a Derecha
9Equality== !=Igualdad / DesigualdadDe izquierda a Derecha
10And&bit a bit ANDDe izquierda a Derecha
11Exclusive or^bit a bit XORDe izquierda a Derecha
12Inclusive or|bit a bit ORDe izquierda a Derecha
13Conjunction&&logical ANDDe izquierda a Derecha
14Disjunction||logical ORDe izquierda a Derecha
15Expresiones de nivel de asignación= *= /= %= += -=
>>= <<= &= ^= |=		asignación / asignación compuestaDe derecha a izquierda
?:Operador Condicional
16Secuenciación,Separador ComaDe izquierda a Derecha     
Cuando una expresión tiene dos operadores con el mismo nivel de precedencia, el agrupamiento determina cual se evaluará primero: de izquierda a derecha o de derecha a izquierda.
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!
Continue reading
Assinar: Postagens (Atom)