Clase4 - Operadores en Delphi

1 Embarcadero Delphi / Introducción

Ing. Américo Torres Gonzales

Expresiones

Una expresión es una construcción que retorna un valor. La siguiente tabla muestra ejemplos

de expresiones:

Las expresiones más simples son variables y constantes. Expresiones mas complejas son

construidas a partir de las mas simples usando operadores, llamadas a funciones,

constructores, índices y Casting de Tipos.

A. Operadores

Los operadores se comportan como funciones predefinidas que son parte del lenguaje Delphi.

Por ejemplo, la expresion (X + Y) esta construida a partir de las variables X e Y, llamados

operandos, con el operador +; donde X e Y representan enteros o reales, ( X + Y ) retorna su

suma. Los operadores incluyen: @, not, ^, *, /, div, mod, and, shl, shr, as, +, -, or, xor, =, >, <,

<>, <=, >=, in, is.

Los operadores @, not y ^ son unarios (toman un operando). Todos los otros operadores son

binarios (toman dos operandos), excepto + y – que pueden funcionar como operadores

unarios o binarios. Un operador unario siempre precede a su operando (por ejemplo, -B),

excepto para ^, el cual sigue a su operando (por ejemplo, P ^), Un operador binario esta

ubicado entre sus operandos (por ejemplo, A = 7).

Algunos operadores se comportan diferente dependiendo del tipo de dato pasado a ellos. Por

ejemplo, not realiza una negación a nivel de bit a un operando entero y negación lógica en un

operador Boolean.



A.1 Operadores Aritméticos

He aquí la lista de los operadores aritméticos:

Operadores Aritméticos Unarios:

Las siguientes reglas se aplican a los operadores aritméticos:

El valor de ( x / y ) es de tipo Extended, sin importar los tipos de x e y. Para otros

operadores aritméticos, el resultado es de tipo Extended si al menos un operando

es un real; de otro modo, el resultado es de tipo Int64 cuando al menos un

operando es de tipo Int64; de otro modo, el resultado es de tipo Integer. Si el tipo

de un operando es subrango de un tipo entero, es tratado como si fuera de tipo

entero.

El valor de ( x div y ) es el valor redondeado de x / y en la dirección de cero al mas

cercano entero.

El operador mod retorna el resto obtenido de dividir sus operandos.

Un error de tiempo de ejecución ocurre cuando y es cero en una expresión de la

forma x / y, x div y, ó x mod y.



Operadores Booleanos:

Los operadores booleanos not, and, or y xor toman operandos de cualquier tipo Boolean y

retornan un valor de tipo Boolean.

Tipos de Evaluación Lógica

El compilador soporta dos modos de evaluación para los operadores and y or: La evaluación

Completa y la Evaluación de Circuito Corto (Parcial). La evaluación completa significa que cada

conjunción o disyunción es evaluada, aun cuando el resultado de la expresión entera ya este

determinada. La evaluación de circuito corto significa una evaluación estricta de izquierda a

derecha que para tan pronto como el resultado de toda la expresión es determinada. Por

ejemplo, si la expresión (A and B) es evaluada bajo circuito corto cuando A es falso, el

compilador no evaluará B; sabe que la expresión completa es falsa tan pronto como evalúa A.

La evaluación de circuito corto es preferible debido a que garantiza un tiempo mínimo de

ejecución y, en la mayoría de los casos, mínimo tamaño de código. La evaluación completa es

algunas veces conveniente cuando un operando es una función con efectos que pueden alterar

la ejecución del programa.

La evaluación de circuito corto también permite el uso de construcciones que podrían de otro

modo resultar en operaciones ilegales de tiempo de ejecución. Por ejemplo el siguiente código

itera a través de la cadena S hasta la primera coma:

En caso de que S no tenga comas, la ultima iteración incrementa I al valor en el cual es mayor

que el tamaño de S. La siguiente vez que se evalúa el while, la evaluación completa intenta leer

S[I], lo que provoca un error de tiempo de ejecución. La evaluación corta, por el contrario, la

segunda parte de la condición (S*I+ <> ‘,’) no es evaluada si la primera parte falla.

Use la directiva de compilador $B para controlar el modo de evaluación. El estado por defecto

es {$B}, lo cual habilita la evaluación de circuito corto. Para habilitar evaluación completa

localmente agregar la directiva de compilador {$B+} a tu código. Puedes también cambiar a

evaluación completa en un proyecto seleccionando Complete Boolean Evaluation en el cuadro

de dialogo Compiler Options (todas las unidades necesitaran ser recompiladas).



Operadores Lógicos de Bits

Los siguientes operadores lógicos realizan manipulación a nivel de bits en operandos enteros.

Por ejemplo, si el valor almacenado en X (en binario) es 001101 y el valor almacenado en Y es

100001, la sentencia:

Z := X or Y;

Asigna el valor 101101 a Z.

Las siguientes reglas se aplican a operadores de bits:

El resultado de una operación not es del mismo tipo del operando.

Si los operandos de una operación and, or o xor son ambos enteros, el resultado es del

tipo entero con el rango mas pequeño que incluye todos los posibles valores de ambos

tipos.

Las operaciones ( x shl y ) y ( x shr y ) desplaza el valor de x a la izquierda o derecha por y

bits, el cual (si x es un entero sin signo) es equivalente a multiplicar o dividir x por 2

elevado a y; el resultado es del mismo tipo de x. Por ejemplo, si N tiene el valor 01101

(decimal 13), entonces N sh 1 retorna 11010 (decimal 26).

Operadores de Cadena

Los operadores relacionales =, <>, <, >, <=, >= toman todos ellos operandos de cadena. El

operador + concatena dos cadenas.

Las siguientes reglas se aplican a la concatenación de cadenas:

Los operandos para + pueden ser cadenas, cadenas packed (arreglos del tipo Char), o

caracteres. Sin embargo, si un operando es del tipo WideChar, el otro operando debe ser

una cadena UnicodeString, AnsiString o WideString.



El resultado de una operación + es compatible con cualquier tipo de cadena. Sin embago,

si los operandos son ambos cadenas cortas o caracteres, y sus tamaños combinados son

mas de 255m el resultado es truncado a los primeros 255 caracteres.

Operadores Puntero

Los operadores relacionales <, >, <= y >= pueden tomar operandos del tipo PAnsiChar y

PWideChar.

El operador ^ se referencia a un puntero. Su operando puede ser un puntero de cualquier tipo

excepto el genérico Pointer, el cual debe ser casteado antes de referenciarlo. P = Q es true solo

en el caso que P y Q apunten a la misma dirección; de otro modo, P <> Q es true.

Puedes usar los operadores + y – para incrementar y decrementar el desplazamiento del

puntero. Puedes usar también – para calcular la diferencia entre los desplazamientos de dos

punteros. Las siguientes se aplican a punteros:

Si I es un entero y P es un puntero a carácter, entonces P + I añade a la dirección dada por

P; esto es, retorna un puntero a la dirección I caracteres después de P. (La expresión I + P

es equivalente a P + I). P – I sustrae I de la dirección dada por P; esto es, que retorna un

puntero a la dirección I caracteres antes de P. Esto es true para punteros PAnsiChar; para

punteros PWideChar P + I agrega SizeOf(WideChar) a P.

Si P y Q son ambos punteros a caracteres, entonces P – Q computa la diferencia entre las

direcciones dadas por P (la dirección mas alta) y la dirección dada por Q (la dirección mas

baja); esto es, retorna un entero que denota el numero de caracteres entre P y Q. P + Q no

esta definido.

Operadores Set

Los siguientes operadores toman conjuntos como operandos.



Las siguientes reglas se aplican a +, - y *:

Un ordinal O esta en X + Y si y solo si O esta en X o Y. O esta en X – Y si y solo si O esta en X

pero no en Y. O esta en X * Y si y solo si esta en ambos X e Y.

El resultado de una operación +, - o * es del tipo set de A.. B, donde A es el valor ordinal

mas pequeño en el conjunto resultado y B es el mas grande.

Las siguientes reglas se aplican a <=, >=, =, <>, y in:

X <= Y es true solo en el caso que cada miembro de X es un miembro de Y; Z >= W es

equivalente a W <= Z. U = V es true solo en el caso en que U y V contengan exactamente

los miembros, de otro modo, U <> V es true.

Para un ordinal O y un set S, O en S es true solo en el caso en que O es un miembro de S.

Operadores Relacionales

Son usados para comparar dos operandos. Los operadores =, <>, <= y >= también se aplican a

conjuntos.

Para tipos mas simples, la comparación es estricta. Por ejemplo, I = J es true solo en caso en

que I y J tienen el mismo valor, y I <> J es true de otro modo.

Las siguientes reglas se aplican a operadores relacionales:



Los operandos deben ser de tipos compatibles, excepto un real y un entero, ellos pueden

ser comparados.

Las cadenas son comparadas de acuerdo a sus valores ordinales. Los tipos carácter son

tratados como cadenas de tamaño 1.

Dos cadenas packed deben tener el mismo número de componentes para ser comparados.

Cuando una cadena packed con n componentes es comparado a una cadena, la cadena

packed es tratada como una cande a de tamaño n.

Usar los operadores <, >, <= y >= para comparar operandos PAnsiChar (y PWideChar) solo

si los dos punteros apuntan al mismo arreglo de caracteres.

Los operadores = y <> pueden tomar operandos de clase y tipos de referencia a clase. Con

operandos de tipo class, = y <> son evaluados de acuerdo a las reglas que se aplican a los

punteros: C = D es true solo en caso que C y D apunten a la misma instancia de un objeto, y

C <> D en true de otro modo. Con operandos del tipo referencia a una clase, C = D es true

solo en caso que C y D denoten la misma clase, y C <> D es true de cualquier otro modo.

Operadores de Clases e Interfaces

Los operadores as e is toman clases e instancias de objetos como operandos; as opera en

interfaces también.

Los operadores relacionales = y <> también operan sobre clases.

El operador @

Retorna la dirección de una variable, o de una función, procedimiento, o método; esto es, @

construye un puntero a su operando.

Reglas que se aplican a @:

Si X es una variable, @X retorna la dirección de X. El tipo de @X es Pointer si la directiva

de compilador {$T} está activada. En el caso en que este en el modo {$T+}, @X es de tipo

^T, donde T es del tipo de X.

Si F es una rutina (procedimiento o función), @F retorna el punto de entrada de F. El tipo

de @F es siempre Pointer.

Cuando @ es aplicado a un método de clase, el método identificador debe estar

cualificado con el nombre de la clase. Por ejemplo: @MiClase.MetodoX apunta al método

MetodoX de la clase MiClase.

Nota: Cuando uses el operador @, no es posible tomar la dirección de un método de interface,

debido a que la dirección no es conocida en tiempo de compilación y no puede ser extraído en

tiempo me ejecución.

Precedencia de Operador

En expresiones complejas, las reglas de precedencia determinan el orden en el que las

operaciones son realizadas.



Un operador con el grado de precedencia mayor es evaluado antes que uno que no lo es,

mientras los operadores de igual precedencia son evaluados de izquierda a derecha. Asi la

expresión:

X + Y * Z

Multiplica Y * Z y le agrega X al resultado; * es realizado primero, debido a que tiene un grado

de precedencia mayor que +. Pero:

X – Y + Z

Primero sustrae Y de X y luego agrega Z al resultado; - y + tienen el mismo grado de

precedencia, así la operación se realiza de izquierda a derecha.

Sin embargo, puedes usar paréntesis para evitar estas reglas de precedencia. Por ejemplo:

(X+Y)*Z

Multiplica Z a la suma de X + Y.

Llamadas a Funciones

Debido a que las funciones devuelven un valor, las llamadas a funciones son expresiones. Por

ejemplo, si has definido una función llamada Calculo que toma dos enteros como argumentos

y retorna un entero, entonces la llamada a función Calculo(24,47) es una expresión entera. Si I

y J son variables enteras, entonces I + Calculo(J,8) es también una expresión entera. Ejemplos

de llamadas a funciones incluyen:

Constructor de Conjuntos

Un constructor de conjuntos denotan un valor tipo set. Por ejemplo:

[5, 6, 7, 8]



Denota un conjunto cuyos miembros son 5, 6, 7, 8.

El Constructor De conjunto:

[5..8]

Puede también denotar el mismo conjunto.

La sintaxis para un constructor de conjuntos es:

*item1,…,itemN+

Donde cada ítem es ya sea una expresión denotando un ordinal del tipo base del conjunto o un

par como expresión con dos puntos (..) en medio. Cuando un ítem tiene la forma x..y, es la

manera corta para todos los ordinales en el rango de x a y, incluyendo y; pero si x es mayor

que y, entonces x..y, el conjunto [x..y] no denota nada y es un conjunto vacío. El constructor [ ]

denota un conjunto vacío, mientras que [x] denota un conjunto cuyo único miembro es el valor

de x. Son ejemplos de constructores de conjuntos:

Indices

Las Cadenas, arreglos, arreglos de propiedades, y punteros a cadenas pueden ser indexados.

Por ejemplo, si FileName es una variable cadena, la expresión FileName[3] retorna el tercer

carácter en la cadena, mientras que FileName[I+1] retorna el carácter inmediatamente

después del indexado por I.

TypeCast

Algunas veces es útil tratar una expresión como si perteneciera a un tipo diferente. Un

typecast permite hacer esto, en efecto, temporalmente cambiando el tipo de una expresión.

Por ejemplo, Integer(‘A’) castea el carácter A como un entero. La sintaxis para un typecast es:

Tipo Identificador(expresion)

Si la expresión es una variable, el resultado es llamado un typecast de variable; de otro modo

el resultado es un Valor TypeCast. Reglas diferentes se aplican a cada uno de los dos tipos de

Cast.

Valor Typecast

En un valor typecast, el tipo identificador y la expresión deben ser ordinales o tipos puntero.

Ejemplos de valores typecast incluyen:



El valor resultante es obtenido convirtiendo la expresión en paréntesis. Esto podría involucrar

truncar o extender el tamaño del tipo especificado si el tipo especificado difiere del de la

expresión. El signo de la expresión es siempre preservado. Por ejemplo, la sentencia:

I := Integer(‘A’);

Asigna el valor de Integer(‘A’), que es 65 (su valor ASCII), a la variable I.

Un valor typecast no puede ser seguido de comillas y no puede aparecer en el lado izquierdo

de una sentencia de asignación.

Typecast de Variable

Puedes castear cualquier variable a cualquier tipo, previendo que sus tamaños sean los

mismos y no mezclar enteros con reales. (Para convertir tipos numéricos, se usan las funciones

Int y Trunc). Ejemplos de Typecast de variables incluyen:

Los typecast de variables pueden aparecer en cualquier lado de una sentencia de asignación.

Asi:

Asigna el carácter z (ASCII 122) a MyChar.

Puedes castear variables a un tipo procedural. Por ejemplo, dadas las declaraciones:

Puedes hacer las asignaciones siguientes:



Los typecast de variables pueden también ser seguidos por cualificadores, como se iulustra en

el siguiente ejemplo:

Clase4 - Operadores en Delphi

Engineering

Transcript of Clase4 - Operadores en Delphi