1. Colegio: Liceo Metropolitano en Computación
Grado: 4to. Bachillerato en Computación
Materia: Matemáticas
Ciclo escolar: 2010
Téma: Jerarquias y Precedencia
de Operadores
Nombre: Darwin Giovanni Luna Hernández
Fecha de entrega: 8/2/2010

2. Introducción
Bueno este trabajo esta realizado por medio del internet y
de enciclopedias y conceptos que uno tenia que saber.
Este trabajo tiene información de precedencias de
operadores y asociatividades de operadores lenguajes en
matemáticas y en programación ya que esto serviria para
futuras pruebas.
Entiendo que la Matemáticas tiene que ver en la
programación ya que estas dos materias llevan lo que es
lenguajes numerales y códigos que uno tiene que
entender para poder realizar dicho ejercicio o trabajo que
sirven en la matemática programación.

3. PRECEDENCIA DE OPERADORES
Esta es una lista de los operadores de los lenguajes C++ y
C. Todos los operadores listados existen en C++. La
tercera columna indica si también está ggg presente en C.
También hay que tener en cuenta que C no permite la
sobrecarga de operadores.
Los siguientes operadores son puntos de secuencia en
ambos lenguajes (cuando no están sobrecargados): &&,
||, ?:, y , (el operador coma).
C++ también incluye los operadores de conversión de
tipos const_cast, static_cast, dynamic_cast y
reinterpret_cast que no están listados en la tabla por
brevedad. El formato de estos operadores significa que su
nivel de precedencia no es importante.
Estos operadores que están en C (con la excepción del
operador coma y el operador flecha también se
encuentran en Java, Perl, C# y PHP con la misma
precedencia, asociatividad y semántica. Con una única
excepción: la asociatividad del operador ternario en PHP
es de izquierda a derecha.

4. TABLA
Para los objetivos de esta tabla a, b y c representan
valores válidos (literales, valores de variables o valores de
retorno), nombres de objetos o valores según el caso.
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:
+ Dos posibilidades: Suma binaria ; más unitario .
++ Incremento unitario (dos clases )
- Dos posibilidades: Resta binaria ; menos unitario .
-- Decremento unitario (dos clases )
* Multiplicación (este símbolo tiene también otros usos )
/ División .
% Resto o módulo .
Observaciones
Los operadores aritméticos pertenecen a dos grupos: unos aceptan operandos de tipo
numérico; otros aceptan operandos de tipo puntero-a-tipoX [3]. 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:
+ más unitario.
++ Incremento unitario (dos clases)
- menos unitario.
-- Decremento unitario (dos clases)

5. Operadores artiméticos binaros:
+ Suma binaria.
- Resta binaria.
* Multiplicación
/ División.
% Resto o módulo.
Estos últimos pueden combinarse con el de asignación = para dar origen a operadores
compuestos ( 4.9.2) son los siguientes:
+= Asigna suma
-= Asigna diferencia (resta)
*= Asigna producto
/= Asigna división
%= Asigna resto (módulo)
Tenga en cuenta que existen distintos operadores enmascarados bajo los mismos
símbolos + y -. Es un caso de sobrecarga incluida en el propio lenguaje [1]. Como en el
resto de los casos de sobrecarga, el compilador deduce por el contexto de que versión
del operador se trata. Como veremos inmediatamente, en C++ es perfectamente válida
una expresión del tipo:
int x = *ptr+-*++ptr;
En el ejemplo siguiente se muestran los casos posibles:
int ai[] = {2, 3};
int* ptr = ai;
int r1 = +ai[0]; // L.3: más unitario sobre tipo numérico
int r2 = -ai[1] // L.3: menos unitario sobre tipo numérico
int r3 = ai[0] + ai[1]; // L.4: 2 + 3 suma binaria (de enteros)
int r4 = ai[1] - ai[0] // L.5: 3 - 2 resta binaria (de enteros)
int r5 = ai[0] + -ai[1]; // L.6: 2 +(-3) suma binaria seguida de menos unitario
int r6 = *ptr + -*++ptr; // L.7: Suma binaria (de enteros) a + (-b)

6. En L.7 coexisten tres operadores aritméticos no homogéneos (de izquierda a derecha):
+ Suma 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 ( ). 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 4.9.0a 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- expresión-suma + expresión-de-multiplicación
b- expresión-suma - expresión-de-multiplicación
Operador Suma binaria
Las posibilidades para los operandos en la expresión A + B son los siguientes:
1. A y B son tipos aritméticos, enteros o fraccionarios ( 2.2.1). En este caso
ambos operandos están sujetos a las posibles conversiones aritméticas estándar (
2.2.5) y el resultado es la suma aritmética de ambos. Ejemplo:
int x = 10, y = 20;
int z = x + y; // z == 30
2. 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 1
int x = *(2 + ptr); // x == 3
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

7. Operador Resta binaria
Las posibilidades para los operandos en la expresión A - B son los siguientes:
1. 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, y = 20;
int z = x - y; // z == -10
2. 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 1
int* pt2 = &arr[4]; // Señala a 5
int x = pt2 - pt1; // x == 4
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 arr[5] = {1, 2, 3, 4, 5};
int* ptr = &arr[4]; // señala a 5
int x = *(ptr - 2); // x == 3
Operadores ± Unitarios
Cuando los operadores + y - se utilizan como operadores unitarios, las posibilidades
sintácticas son:
+ <expresión-cast>
- <expresión-cast>
En ambos casos <expresión-cast> 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 == 4
int r2 = + (y - x); // r2 == -4
int r3 = - (x - y); // r3 == -4
int r4 = + (x - y); // r4 == 4

8. Operadores multiplicació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
§6 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 [2].
Sintaxis
expresión-de-multiplicación % expresión-cast
Ejemplo
int resto = (6 % 4);
cout << "El resto de 6/4 es " << resto << endl;
Salida:
El resto de 6/4 es 2
§7 Operadores incremento y decremento
Los operadores unitarios ++ (incremento) y -- (decremento), suman y restan
respectivamente una unidad al valor de la expresión. Existen dos variedades "Pre" y
"Post" para cada uno de ellos.
Las posibilidades sintácticas son:
postfix-expression ++ (postincremento)
++ expresión-unitaria (preincremento)
postfix-expression -- (postdecremento)
-- expresión-unitaria (predecremento)
En los ejemplos que siguen suponemos que originariamente n == 5.
El postincremento añade uno a la expresión después de que se ha evaluado:
x = n++ ; // -> x == 5 y n == 6
El preincremento añade uno antes de que sea evaluada la expresión.
x = ++n ; // -> x == 6 y n == 6

9. El postdecremento resta uno del valor de la expresión después de que sea evaluada.
x = n-- ; // -> x == 5 y n == 4
El predecremento resta uno antes de la evaluación de la expresión.
x = --n ; // -> x == 4 y n == 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"
PRECEDENCIA DE OPERADOR
La tabla siguiente es una lista que muestra el orden de
precedencia y la asociatividad de todos los operadores
del lenguaje de programación C++. Están listados de
arriba a abajo por orden de precedencia descendente y
con la misma descendencia en la misma celda (pueden
haber varias filas de operadores en la misma celda). La
precedencia de los operadores no cambia por la
sobrecarga.

10. Una tabla de precendencias, aunque adecuada, no puede
resolver todos los detalles. Por ejemplo el operador
ternario permite expresiones arbitrarias como operador
central independientemente de la precedencia del resto
de operadores. Así a ? b , c : d es interpretado como a ?
(b, c) : d en vez de (a ? b), (c : d). También hay que tener
en cuenta que el resultado sin paréntesis de una
expresión de conversión en C no puede ser el operando
de sizeof. Por eso sizeof (int) * x es interpretado como
(sizeof(int)) * x y no como sizeof ((int) *x).
Tabla 10_6_ Precedencia de Operadores
Asociatividad Operadores
izquierda ,
izquierda or
izquierda xor
izquierda and
derecha print
izquierda = += _= *= /= _= %= &= |= ^= ~= <<= >>=
izquierda ?:
izquierda ||
izquierda &&
izquierda |
izquierda ^
izquierda &
no asociativo == != ===
no asociativo < <= > >=
izquierda << >>
izquierda +__
izquierda */%
derecha ! ~ ++ __ (int) (double) (string) (array) (object) @
derecha [
no asociativo new

11. Operadores De C Y C ++
Esta es una lista de los operadores de los
lenguajes C++ y C. Todos los operadores listados
existen en C++. La tercera columna indica si
también está presente en C. También hay que
tener en cuenta que C no permite la sobrecarga de
operadores.
Los siguientes operadores son puntos de secuencia
en ambos lenguajes (cuando no están
sobrecargados): &&, ||, ?:, y , (el operador coma).
C++ también incluye los operadores de conversión
de tipos const_cast, static_cast, dynamic_cast y
reinterpret_cast que no están listados en la tabla
por brevedad. El formato de estos operadores
significa que su nivel de precedencia no es
importante.
Estos operadores que están en C (con la excepción
del operador coma y el operador flecha también se
encuentran en Java, Perl, C# y PHP con la misma
precedencia, asociatividad y semántica. Con una
única excepción: la asociatividad del operador
ternario en PHP es de izquierda a derecha.

12. TABLA
Para los objetivos de esta tabla a, b y c
representan valores válidos (literales, valores de
variables o valores de retorno), nombres de
objetos o valores según el caso.
Operadores aritméticos
Nombre del operador Sintaxis Sobrecargabl Incluido en
e C
Más unitario +a Sí Sí
Suma a + b Sí Sí
Preincremento ++a Sí Sí
Postincremento a++ Sí Sí
Asignación con suma a += b Sí Sí
Menos unitario (negación) -a Sí Sí
Resta a - b Sí Sí
Predecremento --a Sí Sí
Postdecremento a-- Sí Sí
Asignación con resta a -= b Sí Sí
Multiplicación a * b Sí Sí
Asignación con multiplicación a *= b Sí Sí
División a / b Sí Sí
Asignación con división a /= b Sí Sí
Módulo (Resto) a % b Sí Sí

13. Asignación con módulo a %= b Sí Sí
Operadores de comparación
Nombre del operador Sintaxis Sobrecargabl Incluido en
e C
Menor que a < b Sí
No
Menor o igual que a <= b Sí Sí
Mayor que a > b Sí Sí
Mayor o igual que a >= b Sí Sí
No igual que a != b Sí Sí
Igual que a == b Sí Sí
Negación lógica !a Sí Sí
AND lógico a && b Sí Sí
OR lógico a || b Sí Sí
Operadores a nivel de bit
Nombre del operador Sintaxis Sobrecargabl Incluido en
e C
Desplazamiento a la izquierda a << b Sí Sí
Asignación con desplazamiento a la a <<= b Sí Sí
izquierda
Desplazamiento a la derecha a >> b Sí Sí
Asignación con desplazamiento a la derecha a >>= b Sí No
Complemento a uno ~a Sí Sí
AND binario a & b Sí Sí
Asignación con AND binario a &= b Sí Sí
OR binario a | b Sí Sí
Asignación con OR binario a |= b Sí Sí
XOR binario a ^ b Sí Sí
Asignación con XOR binario a ^= b Sí Sí

14. Otros operadores
Nombre del operador Sintaxis Sobrecargabl Incluido en
e C
Asignación básica a = b Sí Sí
Llamada a función a() Sí Sí
Índice de Array a[b] Sí Sí
Indirección (Desreferencia) *a Sí Sí
Dirección de (Referencia) &a Sí Sí
Miembro de puntero a->b Sí Sí
Miembro a.b Sí
No
Desreferencia a miembro por puntero a->*b Sí No
Desreferencia a miembro por objeto a.*b
No No
Conversión de tipo (tipo) a Sí Sí
Coma a , b Sí Sí
Condicional ternario a ? b : c
No Sí
Resolución de ámbito a::b
No No
Puntero a función miembro a::*b
No No
Tamaño de sizeof a
No Sí
sizeof(tipo)
Identificación de tipo typeid(a)
No No
typeid(tipo)
Asignar almacenamiento new tipo Sí No
Asignar almacenamiento (Vector) new tipo[n] Sí No
Desasignar almacenamiento delete a Sí No
Desasignar almacenamiento (Vector) delete[] a Sí No
Extensiones del lenguaje

15. Nombre del operador Sintaxis Sobrecargabl Incluido en C Vendedor
e
Dirección de la etiqueta && etiqueta No Sí GCC
Obtener tipo typeof a
No Sí GCC
typeof(expr)
min y max a <? b
No No GCC
a >? b
Precedencia de operadores
La tabla siguiente es una lista que muestra el orden de
precedencia y la asociatividad de todos los operadores
del lenguaje de programación C++. Están listados de
arriba a abajo por orden de precedencia descendente y
con la misma descendencia en la misma celda (pueden
haber varias filas de operadores en la misma celda). La
precedencia de los operadores no cambia por la
sobrecarga.
Una tabla de precendencias, aunque adecuada, no puede
resolver todos los detalles. Por ejemplo el operador
ternario permite expresiones arbitrarias como operador
central independientemente de la precedencia del resto
de operadores. Así a ? b , c : d es interpretado como a ?
(b, c) : d en vez de (a ? b), (c : d). También hay que tener
en cuenta que el resultado sin paréntesis de una
expresión de conversión en C no puede ser el operando.
Operador Descripción Asociatividad

16. :: Resolución de ámbito (solo C++) Izquierda a
derecha
++ -- Post- incremento y decremento
() Llamada a función
[]
Elemento de vector
.
-> Selección de elemento por referencia
typeid() Selección de elemento con puntero
Información de tipo en tiempo de ejecución (solo
const_cast C++)
dynamic_cast
reinterpret_cast
static_cast Conversión de tipo (solo C++)
Conversión de tipo (solo C++)
Conversión de tipo (solo C++)
Conversión de tipo (solo C++)
++ -- Pre- incremento y decremento Derecha a
+- Suma y resta unitaria izquierda
!~
NOT lógico y NOT binario
(type)
* Conversión de tipo
& Indirección
sizeof Dirección de
new new[] Tamaño de
delete delete[]
Asignación dinámica de memoria (solo C++)
Desasignación dinámica de memoria (solo C++)
.* ->* Puntero a miembro (solo C++) Izquierda a
derecha
*/% Multiplicación, división y módulo
+- Suma y resta
<< >> Operaciones binarias de desplazamiento
< <= Operadores relaciones "menor que", "menor o igual
> >= que", "mayor que" y "mayor o igual que"
== != Operadores relaciones "igual a" y "distinto de"
& AND binario
^ XOR binario
| OR binario
&& AND lógico
|| OR lógico

17. c?t:f Operador ternario Derecha a
izquierda
= Asignaciones
+= -=
*= /= %=
<<= >>=
&= ^= |=
throw Operador Throw (lanzamiento de excepciones, solo
C++)
, Coma Izquierda a
derecha
Asociatividad de los operadores
Cuando una expresión contiene varios operadores, la
prioridad de los operadores controla el orden de
evaluación de las expresiones. Por ejemplo, la expresión x
+ y * z se evalúa como x + (y * z) porque el operador *
tiene una prioridad más alta que el operador +. La tabla
siguiente muestra todos los operadores en orden
descendente de prioridad. Los operadores dentro de una
misma fila tienen la misma prioridad y se evalúan en el
orden, de izquierda a derecha, que aparecen en una
expresión:
Grupo Operadores

18. Primario [] {x:y} () f(x) new x.y x[y]
Sufijo x++ x--
Unario ++x --x + - ~ ! delete typeof void
Multiplicativo * / %
Aditivo + -
Desplazamiento en modo bit << >> >>>
Relacional < > <= >= instanceof
Igualdad == != === !==
AND en modo bit &
XOR en modo bit ^
OR en modo bit |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación = *= /= %= += -= <<= >>= >>>= &= ^= |=
Coma ,
Operadores (Guía de programación de C#)
En C#, un operador es un término o un símbolo que
acepta como entrada una o más expresiones,
denominadas operandos, y devuelve un valor. Los
operadores que requieren un operando, como el
operador de incremento (++) o new, se denominan
operadores unarios. Los operadores que requieren dos
operandos, como los operadores aritméticos (+, -, *, /) se
denominan operadores binarios. Un operador, el
operador condicional (?:), utiliza tres operandos y es el
único operador terciario de C#.
La instrucción de C# siguiente contiene un solo operador
unario y un solo operando. El operador de incremento, +
+, modifica el valor del operando y.

19. Copiar código
y++;
La instrucción de C# siguiente contiene dos operadores
binarios, cada uno con dos operandos. El operador de
asignación, =, tiene el entero y y la expresión 2 + 3 como
operandos. La propia expresión 2 + 3 contiene el
operador de suma y utiliza los valores enteros 2 y 3 como
operandos:
Copiar código
y = 2 + 3;
Un operando puede ser una expresión válida de cualquier
tamaño, compuesta por una cantidad cualquiera de otras
operaciones.
Los operadores de una expresión se evalúan en un orden
concreto conocido como prioridad de operadores. La
tabla siguiente divide a los operadores en categorías
basadas en el tipo de operación que realizan. Las
categorías se muestran en orden de prioridad.
Expression Descripción
x.y Acceso a miembros
f(x) Invocación de método y delegado
a[x] Acceso a matriz e indizador
x++ Incremento postfijo
x-- Decremento postfijo
new T(...) Creación de objeto y delegado
new T(...) Creación de objetos con inicializador. Vea Inicializadores de objeto y
{...} de colección (Guía de programación de C#).

20. new {...} Inicializador de objeto anónimo. Vea Tipos anónimos (Guía de
programación de C#).
new T[...] Creación de matrices. Vea Matrices (Guía de programación de C#).
typeof(T) Obtener el objeto System.Type para T
checked(x) Evaluar expresión en contexto comprobado
unchecked(x) Evaluar expresión en contexto no comprobado
default (T) Obtener valor predeterminado de tipo T
delegate {} Función anónima (método anónimo)
Operadores unarios
Expression Descripción
+x Identidad
-x Negación
!x Negación lógica
~x Negación bit a bit
++x Incremento prefijo
--x Decremento prefijo
(T)x Convertir explícitamente x al tipo T
Operadores de multiplicación
Expression Descripción
* Multiplicación
/ División
% Resto
Operadores aditivos
Expression Descripción
x+y Suma, concatenación de cadenas, combinación de delegados
x-y Resta, eliminación de delegados
Operadores de desplazamiento
Expression Descripción
x << y Desplazamiento a la izquierda
x >> y Desplazamiento a la derecha
Operadores relacionales y de tipo

21. Expression Descripción
x<y Menor que
x>y Mayor que
x <= y Menor o igual que
x >= y Mayor o igual que
x is T Devuelve true si x es T, de lo contrario devuelve false
x as T Devuelve x escrito como T, o null si x no es T
Operadores de igualdad
Expression Descripción
x == y Igual
x != y No igual
Operadores de asignación y anónimos
Expression Descripción
= Asignación
x op= y Asignación compuesta, admite estos operadores: +=, -=, *=, /=, %=, &=, |
=, !=, <<=, >>=
(T x) => y Función anónima (expresión lambda)
Operadores lógicos, condicionales y null
Categoría Expression Descripción
AND lógico x&y AND bit a bit entero, AND lógico booleano
XOR lógico x^y XOR bit a bit entero, XOR lógico booleano
OR lógico x|y OR bit a bit entero, OR lógico booleano
AND condicional x && y Sólo evalúa y si x es true
OR condicional x || y Sólo evalúa y si x es false
Uso combinado de X ?? y Se evalúa como y si x es null, de lo contrario se
Null evalúa como x
Condicional x ?: y : z Se evalúa como y si x es true, como z si x es false
Orden de Precedencia en las Operaciones
Aritméticas con MS Excel
En una clase de cálculo le mostraba a los estudiantes
cómo utilizar MS-Excel (en lugar de la calculadora) para
aproximar las soluciones de un problema de límites.

22. Cuando obtuve el resultado el mismo me pareció extraño
porque no se aproximaba a lo que yo esperaba (esa es la
parte nítida de inventarse los problemas en el momento).
Analizamos la ecuación entre todos y no vimos ningún
problema en la misma, pero el resultado no se veía bien.
Entonces lo hicimos con la calculadora y BOOOM,
obtuvimos otro resultado (el cual sí era correcto).
El ejercicio se convirtió de pronto en uno de naturaleza
detectivesca. Había que averiguar qué era lo que estaba
mal con MS-Excel. Finalmente encontramos lo siguiente:
Excel no sigue estrictamente la jerarquía para las
operaciones aritméticas cuando se trabaja con
exponentes y signos. Se supone que
-a^b = -(a^b)
o sea que la exponenciación en la expresión tiene
precedencia sobre el signo. Sin embargo en MS-Excel
-a^b = (-a)^b
O sea que en estos casos el signo se aplica primero y
luego el exponente. Luego de descubrir cuál era el
problema ampliamos la búsqueda al Web y encontramos
que Microsoft está consciente de esta situación pero no
es que lo estén haciendo de forma incorrecta, sino que
prefieren usar sus propias reglas. Según Microsoft este
orden de evaluación se utiliza desde la primera versión de
MS-Excel.

23. Síntomas
En Microsoft Excel, cuando utiliza un signo menos (-)
como un operador de negación (por ejemplo -1) en una
fórmula, el operador de negación tiene mayor prioridad
que un operador binario. Esta orden de prioridad puede
significar que una fórmula devuelve un valor positivo
cuando se espera que devuelva un valor negativo. Por
ejemplo, la fórmula
-2 = ^ 2
se evalúa como:
(-2) ^ 2
El signo menos se evalúa como un operador de negación.
La fórmula devuelve un valor positivo, 4.
Causa
Microsoft Excel utiliza un orden de cálculo para evaluar
los operadores en fórmulas. El orden de evaluación de los
operadores determina que un signo menos (-) utiliza

24. como un operador de negación (como -1) se evalúa antes
todos los otros operadores. Porque de esta orden, la
fórmula
-1 = ^ 2
representa el valor -1 cuadrado y devuelve el valor 1, un
valor positivo.
Solución
Para conservar el orden de las operaciones en una
fórmula, puede especificar que el signo negativo en una
fórmula se aplican a toda la fórmula insertando
paréntesis alrededor de los números que desea se
evalúan primero.
Por ejemplo, si el anterior fomula
-2 = ^ 2
se cambia a
=-(2^2)
la fórmula devuelve un valor negativo,-4.
Que ha sido el método estándar para evaluar fórmulas
desde la primera versión de Microsoft Excel.
Nota: Esta orden de operaciones es diferente del orden
de las operaciones en Lotus 1-2-3.

25. Conclusión

26. Eh llegado a la conclusión de que los
operadores de precedencia son utiles en la
programación ya que los signos representan
funciones.
El trabajo nos ayudo a aprender un poco más
sobre las matemáticas y sobre los lenguajes de
programación y sobre matemáticas bueno es
mas sobre procedencias y operadores.
Bibliografía

27. www.wikipedia.com.gt
msdn.microsoft.com/es