Una vez introducidas las variables y constantes, podemos empezar a utilizarlas mediante operadores. La siguiente es una lista completa de operadores. En este momento, probablemente no es necesario conocerlas todas, pero todas están listadas aquí para que sirvan de referencia.
Operador de asignación (=)
El operador de asignación asigna un valor a una variable.
x = 5;
Esta instrucción asigna el valor entero 5 a la variable x. La operación de asignación siempre tiene lugar de derecha a izquierda, y nunca al revés:
x = y;
Esta instrucción asigna a la variable x el valor contenido en la variable y. El valor de x en el momento en que se ejecuta esta instrucción se pierde y se sustituye por el valor de y.
También tenga en cuenta que sólo asignamos el valor de y a x cuando asignamos. Por lo tanto, si y cambia más tarde, no afectará al nuevo valor tomado por x.
Por ejemplo, veamos el siguiente código – he incluido la evolución del contenido almacenado en las variables como comentarios:
// asignación operador#incluye <iostream>usando namespace std;int main (){int a, b; // a B : ?a = 10; // a: 10, b : ?b = 4; // a: 10, b: 4a = b; // a: 4, b: 4b = 7; // a: 4, b: 7cout << "a:" cost <<< a; b:" cost <<< "b:" cost}Este programa imprime los valores finales de a y b (4 y 7, respectivamente) en la pantalla. Observa cómo a no se vio afectado por la modificación final de b, incluso si ya hemos declarado a = b.
Las operaciones de asignación son expresiones que pueden evaluarse. Esto significa que la propia asignación tiene un valor y, para las clases fundamentales, este valor es el asignado a la operación. Por ejemplo:
y = 2 + (x = 5);
En esta expresión, se le asigna el resultado de sumar 2 y el valor de otra expresión de asignación (que a su vez tiene el valor 5. Es más o menos lo mismo que:
x = 5;y = 2 + x;
Con el resultado final de asignar 7 a y.
La siguiente expresión también es válida en C++:
x = y = z = 5;
Asigna 5 a las tres variables: x, y y y z; siempre de derecha a izquierda.
Operadores aritméticos (+, -, *, *, *, /,%)
Las cinco operaciones aritméticas soportadas por C++ son las siguientes:
OperadorDescripción
+ adición
– substracción
* multiplicación
/ división
modulo % modulo
Las operaciones de suma, resta, multiplicación y división corresponden literalmente a sus respectivos operadores matemáticos. El último, el operador modulo, representado por un signo de porcentaje (%), da el resto de una división de dos valores. Por ejemplo:
x = 11% 3;
da la variable x que contiene el valor 2, ya que dividimos 11 por 3, obtenemos 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 sobre ella. Son equivalentes a asignar el resultado de una operación al primer operando:
equivalente a.…
y + = x; y = y = 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 compuesta#incluyen <iostream>usando namespace std;int main (){int a, b = 3;a = b;a + = 2; // equivalente a a a = a + 2cout <<<< a;}Aumento y disminución (++, -)
Algunas expresiones pueden incluso acortarse: el operador de aumento (++) y el operador de disminución (-) aumentan o disminuyen en uno el valor almacenado en una variable.
Son equivalentes a + = 1 y – = 1, respectivamente. Así que:
++ x;x;x + + = 1;x = x + 1;
son todos equivalentes en funcionalidad; los tres aumentan el valor de x en uno.
En los primeros compiladores de C, las tres expresiones anteriores pueden haber generado diferentes códigos ejecutables dependiendo de cuál de ellas haya sido utilizada. Hoy en día, este tipo de optimización de código es usualmente realizada automáticamente por el compilador, por lo que las tres expresiones deben producir exactamente el mismo código ejecutable.
Una particularidad de este operador es que puede ser utilizado tanto como prefijo como sufijo. Esto significa que puede escribirse antes del nombre de la variable (++ x) o después (x +++. Aunque en expresiones simples como x +++ o +++ x, ambas tienen exactamente el mismo significado; en otras expresiones en las que se evalúa el resultado de la operación de incremento o decremento, pueden tener una diferencia de significado significativa: en el caso de que se utilice el operador de incremento como prefijo (++ x) del valor, la expresión se evalúa en el valor final de x, una vez que ya ha aumentado. Por otro lado, si se utiliza como sufijo (x ++++), el valor también se incrementa, pero la expresión se evalúa al valor que x tenía antes de que se incrementara. Note la diferencia:
También lea Las constantes en C+++Ejemplo
1Ejemplo
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 incrementado. En el ejemplo 2, es el valor que x tenía antes de que se incrementara.
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 superior al otro.
El resultado de tal operación es verdadero o falso (es decir, un valor booleano.
Los operadores relacionales en C++ son:
descripción del operador
== igual a
! = No es igual
a
> Mayor que
<= Inférieur ou égal à = Mayor que o igual a
Aquí hay algunos ejemplos:
(7 == 5) // se evalúa en false(5> 4) // se evalúa en true(3! = 2) // se evalúa en true(6> = 6) // se evalúa en true(5 <5) // se evalúa en false
Por supuesto, no sólo es posible comparar constantes numéricas, sino cualquier valor, incluyendo, por supuesto, variables. Suponga que a = 2, b = 3 y c = 6, entonces:
a == 5) // se evalúa a false, porque a no es igual a 5(a * b> = c) // se evalúa a true, ya que (2 * 3> = 6) es true(b + 4> a * c) // se considera false, ya que (3 + 4> 2 * 6) es false ((b = 2) == a) // se evalúa a true
¡Ten cuidado! ¡Ten cuidado! El operador de asignación (operador =, con un signo igual) no es el mismo que el operador de comparación de igualdad (operador ==, con dos signos iguales); el primero (=) asigna el valor derecho a la variable izquierda, mientras que el otro (==) compara si los valores a ambos lados del operador son iguales. Por lo tanto, en la última expresión ((b = 2) == a), primero asignamos el valor 2 a b, luego lo comparamos con a (que también almacena el valor 2), dando el valor verdadero.
Operadores lógicos (!, &&, &&, &, |||||)
El operador! es el operador C++ para la operación booleana NOT. Sólo tiene un operando, a su derecha, y el opuesto, produciendo falso si su operando es verdadero y verdadero si su operando es falso. Básicamente, devuelve el valor booleano opuesto de la evaluación de su operando. Por ejemplo:
! (5 == 5) // se evalúa como falsa porque la expresión a su derecha (5 == 5) es verdadera! (6 <= 4) // se evalúa a true porque (6 <= 4) sería falso! true // se evalúa a false! false // se evalúa a true
Los operadores lógicos &&& y ||||| se utilizan al evaluar dos expresiones para obtener un único resultado relacional.
El operador && corresponde a la operación lógica booleana AND, que devuelve true si sus dos operandos son true y false si no lo son. El siguiente panel muestra el resultado del operador && evaluando la expresión a&&& b:
El operador |||| corresponde a la operación lógica booleana OR, que devuelve true si uno de sus operandos es true, por lo tanto false sólo cuando ambos operandos son false. Aquí están los posibles resultados de a |||| b:
Por ejemplo:
((5 == 5) && (3> 6)) // se evalúa a false (true && false)((5 == 5) ||||| (3> 6)) // se evalúa a true (true ||||| false)
Utilizando operadores lógicos, C++ evalúa sólo 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 ++ determina primero si 5 == 5 es verdad y, si es así, nunca verifica si 3> 6 es verdad o no. Esto se conoce como evaluación de cortocircuito y funciona así para estos operadores:
Lea también Las funciones en C++OperatorDescription
Si la expresión izquierda es incorrecta, el resultado combinado es incorrecto (la expresión correcta nunca se evalúa.
|| Si la expresión de la izquierda es verdadera, el resultado combinado es verdadero (la expresión de la derecha nunca se evalúa.
Esto es especialmente importante cuando la expresión correcta tiene efectos secundarios, como el cambio de valores:
si ((i <10) && (++ i <n))) {/*...*/} // nota que la condición aumenta i
Aquí, la expresión condicional combinada aumentaría en uno, pero sólo si la condición a la izquierda de && es verdadera, porque de lo contrario, la condición a la derecha (++ i
Operador ternario condicional (?)
El operador condicional evalúa una expresión devolviendo un valor si esta expresión se evalúa a verdadero y un valor diferente si la expresión se evalúa a falso. Su sintaxis es la siguiente:
condición? resultado1: resultado2
Si la condición es verdadera, la expresión completa se evalúa en el resultado1 y, en caso contrario, en el resultado2.
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 igual 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 // evalúa el que es mayor, a o b.
Por ejemplo:
// Operador condicional
#incluye
utilizando el estándar namespace std;
int principal (
)
{
int a, b, c;
a = 2;
b = 7;
c = (a> b)? a B;
coste <<<<<<<<< < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <
}
En este ejemplo, a era 2 y b era 7, por lo que la expresión que se estaba evaluando (a>b) no era verdadera. Por lo tanto, el primer valor especificado después del signo de interrogación se ignoró a favor del segundo valor (el que sigue al signo de dos puntos. ) que era b (con un valor de 7.
Otros consejos interesantes:
- Clases en C++ (2) Las clases, esencialmente, definen los nuevos tipos que se utilizarán en el código C++. Y los tipos C++ no sólo interactúan con el código por medio de construcciones y asignaciones. También interactúan…..
- Memoria dinámica en C++ En los programas descritos en los capítulos anteriores, todos los requisitos de memoria se determinaron antes de ejecutar el programa mediante la definición de las variables necesarias. Pero puede suceder que las necesidades de memoria de un….
- Punteros en C++ En los capítulos anteriores, las variables se han explicado como ubicaciones en la memoria del ordenador a las que se puede acceder mediante su identificador (nombre. De esta manera, el programa no necesita….
- Estructuras de datos en C++ Una estructura de datos es un grupo de elementos de datos agrupados bajo el mismo nombre. Estos elementos de datos, llamados miembros, pueden tener diferentes tipos y longitudes. Se pueden declarar las estructuras de datos……
- Las constantes en C++ Constantes son expresiones de valor fijo. Literales Los literales son el tipo más obvio de constantes. Se utilizan para expresar valores particulares en el código fuente de un programa. Nosotros…..