Está en la página 1de 29

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
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.
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.
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)

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)
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


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

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

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.
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 */%
Asociatividad Operadores
derecha ! ~ ++ __ (int) (double) (string) (array) (object) @
derecha [
no asociativo new

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.

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 Sobrecarg Incluido


able en 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í

Asignación con módulo a %= b Sí Sí

Operadores de comparación

Nombre del operador Sintaxis Sobrecarg Incluido


able en C

Menor que a < b


No Sí

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 Sobrecarg Incluido
able en 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 a >>= b Sí No


derecha

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í

Otros operadores
Nombre del operador Sintaxis Sobrecarg Incluido
able en 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
No Sí

Desreferencia a miembro por a->*b Sí No


puntero

Desreferencia a miembro por a.*b


No No
objeto

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 delete[] a Sí No
(Vector)

Extensiones del lenguaje

Nombre del Sintaxis Sobrecarg Incluido Vende


operador able en C dor

Dirección de la && etiqueta Sí GCC


No
etiqueta

Obtener tipo typeof a Sí GCC


No
typeof(expr)

min y max a <? b GCC


No No
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 Asociativid


ad
:: 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
const_cast ejecución (solo C++)
dynamic_cast
reinterpret_cast Conversión de tipo (solo C++)
static_cast
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
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
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.

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#).

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

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. 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.

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 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.
Conclusión

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

www.wikipedia.com.gt

msdn.microsoft.com/es