Operadores en C++

• 1. Operadores aritméticos
• 2. Operadores de asignación
• 3. Operadores de manejo de bits
• 4. Operadores lógicos
• 5. Operador de preproceso
• 6. Operadores de puntero
• 7. Operadores relacionales
• 8. Manejo de memoria
• 9. Modelado de tipos
• 10. Miscelánea

operadores unitarios solo requieren un operando y operan
de izquierda a derecha (el operador a la izquierda, el operando a la derecha

Recuerde que las operaciones lógicas producen siempre
un resultado booleano Es decir, cierto o falso lo que se traduce en
un valor numérico cero o uno.ࠐor contra, las operaciones entre bits
producen valores arbitrar

Operadores aritméticos

Los operadores aritméticos se usan para realizar cálculos de aritmética de números reales y de aritmética de punteros. C++ dispone de los siguientes:

Nota: la aritmética de números reales es la clásica de la escuela primaria. La de punteros es una aritmética un tanto especial y rudimentaria. Los operadores aritméticos pertenecen a dos grupos: unos aceptan operandos de tipo numérico; otros aceptan operandos de tipo puntero-a-tipoX. Además son de dos tipos; unarios (que aceptan un solo operando) y binarios (que aceptan dos). La clasificación es la siguiente:

Operadores aritméticos unarios:

Tenga en cuenta que existen distintos operadores enmascarados bajo los mismos símbolos + y -. Es un caso de sobrecarga incluida en el propio lenguaje .Como en el resto de los casos de sobrecarga, el compilador deduce por el contexto de que versión del operador se trata.

En L.7 coexisten tres operadores aritméticos no homogéneos (de izquierda a derecha): +ࠠࠓuma binaria entre valores numéricos tipo int (). Los valores *ptr y -*++ptr -ࠠࠠNegación unitaria de un valor numérico tipo int (); el valor *(++ptr) ++ࠠPreincremento de un puntero-a-int࠼/b>(). Equivale a suma binaria de puntero y entero: ++ptrཽ ptr = ptr + 1

Nota: aunque válida, la sentencia de L.7 es un ejemplo de expresión peligrosa y desaconsejada. En se ha presentado una explicación del sorpresivo resultado ( 0 ) que se obtiene para L.6.

Suma y resta binaria En el primer caso: suma y resta binaria, caben
dos posibilidades sintácticas: a-ࠥxpresión-suma + expresión-de-multiplicación
b-ࠥxpresión-suma – expresión-de-multiplicación

Operador Suma binaria Las posibilidades para los operandos en la expresión
A +༯b>B son los siguientes:

A y B son tipos aritméticos, enteros o fraccionarios. En este caso ambos operandos están sujetos a las posibles conversiones aritméticas estándar y el resultado es la suma aritmética de ambos.

Ejemplo:

int x = 10,࠹ = 20;int z = x + y;ࠠࠠࠠ// z == 30

A es un entero y B es un puntero a objeto. Ejemplo:

int arr[5] = {1, 2, 3, 4, 5};int* ptr = &arr[0];ࠠ࠯/ Señala a 1int x = *(2 + ptr);ࠠ࠯/ x == 3

A es un puntero a objeto y B es un entero. En estos dos últimos casos se aplican las reglas de aritmética de punteros. Ejemplo:

int z = *(ptr + 3);ࠠ࠯/ x == 4

Operadorࠒesta binaria.

Las posibilidades para los operandos en la expresión A – B son los siguientes:

A y B son de tipo aritmético, entero o fraccionario; las posibilidades son las mismas que en el caso 1 de la suma binaria expuesta anteriormente. El resultado es la resta aritmética de ambos operandos. Ejemplo:

int x = 10,࠹ = 20;int z = x – y;ࠠࠠࠠ// z == -10

A y B son punteros a objetos de tipos compatibles. Ejemplo:

int arr[5] = {1, 2, 3, 4, 5};int* pt1 = &arr[0];ࠠ࠯/ Señala a 1int* pt2 = &arr[4];ࠠ࠯/ Señala a 5int x = pt2 – pt1;ࠠࠠ// x == 4

A es un puntero a objeto y B es un entero. En estos dos últimos casos se aplican las reglas de aritmética de punteros. Ejemplo:

int arr[5] = {1, 2, 3, 4, 5};int* ptr = &arr[4];ࠠ࠯/ señala a 5int x = *(ptr – 2);ࠠ࠯/ x == 3

Operadores࠱ Unitarios

Cuando los operadores + y – se utilizan como operadores unitarios, las posibilidades sintácticas son:

+ –

En ambos casos debe ser de tipo numérico. Los resultados son respectivamente:

Valor del operando expresión-cast después de cualquier promoción interna que sea necesaria. Valor negativo del operando expresión-cast después de cualquier promoción interna que se necesite.

Nota: recuerde que cuando + y – se utilizan como operadores unitarios, tienen mayor precedencia que cuando se utilizan como suma y resta binarias.

Ejemplo: int x = 7, y = 3;int r1 = – (y – x);ࠠ࠯/ r1 == 4int r2 = + (y – x);ࠠ࠯/ r2 == -4int r3 = – (x – y);ࠠ࠯/ r3 == -4int r4 = + (x – y);ࠠ࠯/ r4 == 4

Operadores࠭ultiplicación y división Los operadores binarios
* (multiplicación) y / (división) realizan sus operaciones
aritméticas correspondientes con todos los tipos numéricos (enteros
y fraccionarios).

Sintaxis expresión-de-multiplicación * expresión-cast
expresión-de-multiplicación / expresión-cast

Operador módulo El operador binario % (operador de módulo)
devuelve el resto de la división de dos enteros, no puede ser utilizado
con números fraccionarios float o double

Sintaxis: expresión-de-multiplicación % expresión-cast

Ejemplo: int resto = (6 % 4);cout x == 6࠹࠮ == 6

Postdecremento resta uno del valor de la expresión después de que sea evaluada. x = n– ;ࠠ࠯/ -> x == 5࠹࠮ == 4

Predecremento resta uno antes de la evaluación de la expresión. x = –n ;ࠠ࠯/ -> x == 4࠹࠮ == 4

En ambos casos, el operando debe ser una variable, no una expresión. Por ejemplo: (x+y)++ es ilegal.

Para evidenciar la diferencia entre preincremento y postincremento, observe las salidas que se obtienen con este pequeño programa según se van ejecutando las diversas líneas. Para interpretarlas correctamente debe tener en cuenta la precedencia de los operadores y recordar que, en todos los casos, el argumento recibido por printf es un puntero-a-carácter (char*). También deben recordarse las reglas de ámbito de los argumentos pasados a funciones.

char * s = "Hola mundo";printf("Letra: "%c"n", *s);ࠠࠠ// Letra "H"printf("Letra: "%c"n", *s+1);ࠠ // Letra "I"printf("Letra: "%c"n", *(s+1));࠯/ Letra "o"printf("Letra: "%c"n", *s++);ࠠ // Letra "H"printf("Letra: "%c"n", *s);ࠠࠠ// Letra "o"printf("Letra: "%c"n", *++s);ࠠ // Letra "l"printf("Letra: "%c"n", *s);ࠠࠠ// Letra "l"

Operadores de asignación

C++ dispone de los siguientes operadores de asingación:

Sintaxis:

Ejemplo: x = 3;x += 3;x &= 3;

Todos ellos son operadores binarios, de los cuales,࠼b>= es el único de asignación simple, los demás son operadores de asignación compuestos

Los seis primeros aceptan operandos de distinto tipo, mientras que los cinco últimos: =, &=, ^= y |=, implican manejo de bits por lo que sus operandos deben ser tipos int en sus distintas variantes. No olvidar que las expresiones de asignación producen un resultado. El tipo resultante es el de la (izquierda); el valor que se aplica es el determinado por el Rvalue El valor resultante de después de la asignación, es el resultado de la expresión (el Lvalue). Así pues, cualquiera que sea su sentido concreto, todos implican la "copia" de un bloque de memoria (que contiene el "resultado") en algún sitio (la dirección indicada por el Rvalue).

Ejemplo: int num;ࠦloat f = 3.14;num = f + 1;

En este caso, el valor 4.14, resultado de , se aplica a num. Teniendo en cuenta que el tipo resultante debe ser el de num (un int en este caso), se realiza automáticamente una conversión del float 4.14 a int (con pérdida de precisión si es necesario), con el resultado de que num recibe el valor 4 y el resultado de la asignación es un int de valor 4. Esta propiedad de las asignaciones de producir un resultado, es justamente la que permite expresiones de asignación compuesta del tipo: A = B = C = D;

y es ampliamente utilizada en la programación de C++. Considere el bucle del siguiente ejemplo: while ( (ch = getchar() ) != 27 ) ; aprovechando que en este caso, el resultado de la asignación es un char, se utiliza directamente en la cláusula del while, resultando que el bucle se ejecuta indefinidamente hasta que se pulse la tecla ESC (escape).

En general las sentencias de asignación tienen la forma: variable = expresion

La parte izquierda (que tiene que ser un Lvalue no constante) adquiere el valor señalado en la expresión de la derecha, pero se mantiene el tipo original de la variable de la parte izquierda. En caso necesario se realiza una conversión de tipo (con pérdida de precisión en su caso) del izquierdo al derecho. Nota: observe que el operador C++ de asignación simple (=) se distingue de otros lenguajes como Pascal que utilizan el símbolo := para este operador. Observe también que la asignación simple (=) utiliza un símbolo distinto del operador relacional de igualdad (==). Las variables se pueden inicializar en el mismo momento de la declaración (asignándoles un valor). Este es el único caso en que se puede asignar una constante Ejemplo:

int primero =࠰;char ch = "a";float balance = 123.456;char string[10] = "1234567890";const float pi = 3.14159 ;

En la expresión E1 = E2,ࠅ1 debe ser un Lvalue modificable, en caso contrario puede obtenerse un mensaje de error: Lvalue required Por ejemplo, una vez declarado char a[10], ninguna de las dos sentencias que siguen es válida: a = "0123456789"; a[10] = "0123456789";

La expresión de asignación en sí misma
no es un Lvalue.

Si @ es un operador compuesto, la expresión E1 @= E2 equivale a E1 = E1 @ E2. Por ejemplo: E1 += E2 equivale a E1 = E1 + E2.

Ejemplos

x *= yࠠࠠ௪ equivalentes */ࠠx = x * yx *= y + 2ࠠ/* equivalentes */ࠠx = x * (y + 2)